flow

Plugin flow from marketplace dorkos in dork-labs/marketplace. Commands read from the repo's manifest — 2 days ago.

Skills (20)

• fake-adapter

  The fake tracker flow's self-test runs against. An in-memory tracker in a JSON file, behind the code adapter contract. It reaches no real tracker.

• linear-composio-adapter

  Reference tracker adapter for /flow - Linear reached over the Composio CLI. A concrete, forkable realization of the adapter contract (../../SPEC.md) built on `composio execute LINEAR_*` calls. Implements all 16 required capability verbs plus the optional completeProject, and normalizes Linear into t

• linear-mcp-adapter

  Reference tracker adapter for /flow - Linear reached over an in-session MCP server. A concrete, forkable realization of the adapter contract (../../SPEC.md) built on the Linear MCP tools (the mcp__linear__* / mcp__plugin_linear_linear__* family). Implements all 16 required capability verbs plus the

• building-adapters

  Guided procedure for generating and verifying a concrete /flow tracker adapter that conforms to the adapter contract. Use when building, porting, or scaffolding a tracker adapter for a new tracker (Jira, GitHub Issues, or another), or when /flow:init must produce one for an adopter. Teaches the gene

• capturing-work

  The /flow engine's CAPTURE stage — quick, low-commitment intake of a new piece of work into the tracker as an idea, without doing full triage or evaluation. Use when the goal is to get a thought captured cleanly so it survives, not to assess, classify deeply, or plan it. Generalizes the legacy /line

• closing-work

  The /flow engine's DONE stage — report completion on a work item, move it to Done with the agent/completed label, create any follow-up work, run a project pulse check for the next loop action, and clean up the worktree. Use when running /flow:done or advancing an approved work item into the DONE sta

• decomposing-work

  The /flow engine's DECOMPOSE stage — break a validated specification into actionable tasks in 03-tasks.json, mirror the active phase into the tracker as a plan checklist, project the stage/decompose label, then hand the item on at stage/execute. Use when running /flow:decompose or advancing a work i

• executing-specs

  Orchestrates parallel implementation of decomposed specifications with incremental progress tracking. Use when running the /flow:execute stage (the EXECUTE stage of the /flow engine).

• flow-drain

  Claim the top-ranked eligible issue and carry it to its review gate.

• flow-groom

  Scheduled read-only backlog health check — run the groom oracles and report, never write.

• flow-retro

  Scheduled weekly retro — measure how flow's own runs went and file up to five concrete fixes to flow, never ready.

• flow-triage

  Scheduled daily triage — ready or park every untriaged item, and release claims nobody has touched for a week.

• grooming-backlog

  The /flow engine's backlog GROOM — a whole-backlog corrective sweep that makes the configured team's backlog honestly dispatchable. Audits every open item against the fifteen groom invariants, closes shipped/duplicate/junk work with cited evidence, reconciles projects with the repo's real programme

• ideating-features

  Turns a feature brief, rough notes, or an existing partial design into a structured ideation artifact and next-step plan. Use when the user wants to explore a feature or shape rough requirements into a structured ideation artifact.

• initializing-flow

  First-run setup for the /flow engine in a new repo - detect or reconfigure an existing install, gather setup choices (tracker + connection, identity mode, project routing, adversarial review, model tiers) via the calibration ladder, generate and verify the concrete tracker adapter, scaffold the comm

• linear-adapter

  The /flow engine's tracker adapter — the single skill that owns EVERY Linear MCP / Composio call and normalizes Linear into the generic WorkItem shape. Use whenever a /flow stage skill or the loop engine needs to read or write the tracker (claim, transition, comment, inbox, relations, evidence, sub-

• specifying-work

  The /flow engine's SPECIFY stage — turns a validated ideation artifact into an implementation-ready specification, resolves its open decisions, and seeds draft ADRs. Use when work is ready to move from IDEATE to a frozen spec. PM-agnostic; all tracker I/O routes through the adapter skill.

• tending-tracker

  The /flow engine's agent-as-team-member loop — the agent participates in a shared tracker like a teammate. Each tick it polls its inbox, decides respond/act/ignore per the five comment-response rules, claims work with durable agent/* labels, asks the human via comment+assign when genuinely stuck (so

• triaging-work

  The /flow engine's TRIAGE stage — classify and route incoming work. Classifies a freeform brief/idea/bug/question into the right work-item type, or evaluates an already-captured item (accept/reject/needs-research/needs-refinement) and routes it simple-vs-complex (stay-in-tracker task vs escalate to

• verifying-work

  The /flow engine's VERIFY stage — trace recent work for correctness, run the verification gate, put the branch through an independent adversarial review before any PR opens, gather proof-of-completion scaled to the change, attach it to the work item under a deliberately chosen closing or non-closing

Slash commands (15)

• /flow:capture

  Capture a thought as a low-commitment work item (the /flow CAPTURE stage)

• /flow:decompose

  Run the DECOMPOSE stage — break a validated spec into tasks and mirror them into the tracker

• /flow:done

  Run the DONE stage — report completion, close the work item, and check project follow-ups

• /flow:execute

  Run the EXECUTE stage — implement a validated spec by orchestrating concurrent agents

• /flow:flow

  The /flow engine — route stages, advance work or drain the ready queue.

• /flow:groom

  Groom the whole backlog — audit, correct, and verify it against the dispatch contract (check = read-only report)

• /flow:ideate

  /flow IDEATE stage — shape a brief into a structured ideation artifact

• /flow:init

  First-run setup for /flow - pick your tracker, generate its adapter, and scaffold config

• /flow:pause

  Halt every autonomous /flow mode from one place (drain sentinel + pause flag)

• /flow:resume

  Restore autonomous /flow operation that /flow:pause halted

• /flow:self-test

  Check this flow install, its prose and how its commands behave, and report what is broken

• /flow:specify

  /flow SPECIFY stage — turn an ideation artifact into a validated specification

• /flow:status

  Show every in-flight item, parked question and drift across the /flow loop, plus this project's flow schedules

• /flow:triage

  Classify and route incoming work, simple-vs-complex (the /flow TRIAGE stage)

• /flow:verify

  Run the VERIFY stage — verify recent work, gather proof, and hand off to the review gate

Hooks (2)

• Stop

  cd "$(git rev-parse --show-toplevel)" && node "${CLAUDE_PLUGIN_ROOT}/hooks/flow-loop.mjs"

• PostToolUse

  node --experimental-strip-types "${CLAUDE_PLUGIN_ROOT}/scripts/flow.ts" limit-check --hook

Similar plugins