tackline

Tackline

You are running /tackline — a unified composable knowledge-work engine. You have 14 operations you can perform inline (no separate skill invocations needed) and orchestration patterns for parallelizing work across agents.

Goal: $ARGUMENTS

---

Phase 0 — Parse Intent

Read the goal. Determine which operations to apply and in what order.

If $ARGUMENTS is empty, ask for a goal in one sentence.

If $ARGUMENTS names operations explicitly (e.g., "gather auth patterns then rank by risk"), follow that chain.

If $ARGUMENTS is a natural-language goal, select operations yourself using the decision tree below.

Decision Tree

User wants to...	Operations
Research a topic	gather
Research then prioritize	gather → distill → rank
Research then fact-check	gather → filter → verify
Compare two approaches	gather (both) → diff-ideas
Break down a large goal	decompose → plan
Break down then implement	decompose → rank → plan
Stress-test an idea	gather → critique
Prototype a structure	gather → distill → sketch
Condense verbose input	distill
Elaborate sparse input	expand
Rewrite items to a format	transform
Categorize by severity/type	assess
Remove irrelevant items	filter
Combine scattered findings	merge
Check claims against reality	verify
Find flaws in a proposal	critique
Sequence by dependency	plan

Bias toward fewer operations. If the goal can be achieved in one operation, use one. Don't chain gather → distill → rank when gather alone answers the question.

---

Operations Reference

Each operation transforms input into structured output. All emit pipe format (see rules/pipe-format.md). Output of one operation feeds the next via conversation context.

Input Operations

gather — Collect information with sources and confidence levels.

• Search codebase first (Grep/Glob/Read), web second.
• Every finding gets: title, detail, source (file:line or URL), confidence (CONFIRMED/LIKELY/POSSIBLE).
• For 3+ distinct source types, fan out 2-3 agents (see Orchestration below).

Transform Operations

distill — Reduce to essentials. Arg: target count or topic filter ("to 5 bullets", "auth only").

expand — Add depth and evidence to sparse items. Inverse of distill. Ground new claims in sources.

transform — Rewrite every item independently per instruction ("as ticket titles", "as acceptance criteria"). Item count in = item count out.

rank — Score items 1-5 on stated criteria, reorder highest-to-lowest. Add criteria table. Break all ties.

filter — Binary keep/drop per item against a criterion. Renumber kept items. List dropped items separately.

assess — Assign categorical verdicts (CRITICAL/WARNING/OK or custom rubric). Group by category. Add rubric table.

verify — Check claims against code, git history, docs, or web. Verdict per claim: VERIFIED/REFUTED/UNCERTAIN with cited evidence. For 8+ claims, fan out up to 4 agents.

critique — Adversarial review. Classify each finding as FLAW (incorrect), GAP (missing), or RISK (could fail). Add severity table.

merge — Combine multiple pipe-format blocks from context. Dedup (>80% overlap or same title). Upgrade confidence when 2+ sources confirm. Combine source lists.

diff-ideas — Compare exactly two approaches across 4-6 dimensions. Produce comparison table with per-dimension winner and recommendation.

Output Operations

decompose — Split into 3-6 MECE sub-parts with scope, boundary, and isolation hint (independent/shared-state). Ground in actual file structure.

plan — Sequence items by dependency. Output: execution order, dependency graph, parallel waves with isolation hints (worktree/shared).

sketch — Structural skeleton with TODO placeholders. No implementation — just bones. Code, doc, config, schema, or workflow.

---

Guidelines

All output follows the pipe-format rule (loaded alongside this skill). For fan-out dispatch, follow the fan-out-protocol rule. For chains of 3+ operations, checkpoint per rules/memory-layout.md.

1. Fewer operations is better. Don't chain when one operation suffices.
2. Code first, web second. When researching, exhaust codebase sources before hitting the web.
3. Ground in reality. Decompose/plan should read actual file structure, not guess.
4. Abort on empty. If an operation produces 0 items, stop and report rather than continuing with nothing.
5. Preserve provenance. Source attribution and confidence flow through the entire chain.
6. Be concrete. Cite file:line, commit hashes, URLs. No hand-waving.
7. Operation-specific sections (criteria tables, rubrics, comparison tables, dependency graphs) go between Items and Summary.