tackline

name	tackline
description	Use when you need to research, analyze, compare, plan, or structure thinking and aren't sure which primitive to reach for. Chains operations (gather, distill, rank, filter, verify, etc.) automatically based on your goal. Prefer this over individual primitives for multi-step work.
argument-hint	<goal or operation chain>
allowed-tools	["Read","Grep","Glob","Agent","Bash(git log:*, git show:*, git diff:*)"]
user-invocable	true
disable-model-invocation	false
context	inline

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.