dynamic-workflow

name	dynamic-workflow
description	Controllable re-creation of Claude Code's dynamic-workflow model on ClauKit's own primitives — markdown recipes + Agent-tool fan-out/pipeline over the 30 existing agents, with 4-axis inheritance and hard gates. Use when a task needs deterministic large-ish fan-out + verification (whole-repo audit, N-file migration, cross-checked review, multi-angle plan) under explicit control, NOT the native closed runtime.
category	Orchestration
status	active

Dynamic Workflow

What This Skill Does

Defines ClauKit's controllable orchestration model: take one task, decompose it into phases, fan-out/pipeline those phases over the 30 existing agents, gate between phases, and synthesize a single report — all driven by an orchestrator running in the main session under explicit control.

This re-creates Claude Code's native dynamic-workflow model (workflow → agent → subagent, with inheritance) on primitives ClauKit fully controls. It borrows the patterns (adversarial verify, judge panel, loop-until-dry, multi-modal sweep, completeness critic) — it does NOT call the native Workflow tool or ultracode runtime. The native feature is the reference model; this skill is the controllable substitute.

This is knowledge only — no execution logic. The /ck:flow command (.claude/commands/ck/flow.md) is the trigger that activates this skill; /ck:fix --flow and /ck:review --flow are flag-variants that reuse this model. Trio rule: skill = knowledge, agent = persona, command = trigger.

When to Use

Reach for this model when the task is a deterministic fan-out + verify at moderate scale (10s of agents), and you want it gated and inspectable:

• Whole-repo / whole-module audit (security, quality, dead code).
• N-file migration or mechanical sweep needing per-file verification.
• Cross-checked review — multiple dimensions, each finding adversarially verified.
• Multi-angle plan — N independent attempts judged + synthesized.

Avoid when — see references/decision-matrix.md:

• Quick one-turn parallel reads → plain subagent fan-out (Agent tool directly).
• 3+ workstreams needing persistent sessions + discussion + cross-session memory → /ck:team.
• A single readable canonical recipe is enough → markdown workflow (.claude/workflows/*.md).

Decomposition Model

workflow (recipe + main-session orchestrator)   ← holds the loop + gates, IN main session
   └── agent stage (one of 29 personas via subagent_type)
          └── subagent (delegate within a stage)

The orchestrator stays in the main session — it holds the phase loop, the gate decisions, and the synthesis. This is the control advantage over the native runtime (which runs the plan as background JS, unsupervised). Each phase routes to a persona via the Agent tool's subagent_type; a phase may itself fan-out to several agents (parallel) or chain them (pipeline).

4-Axis Inheritance Contract

The differentiator vs plain subagent fan-out: parent workflow → child agent → subagent inherit along four named axes. Full table + ClauKit examples in references/inheritance-contract.md.

1. context/output — every stage reads/writes the shared plans/<plan>/reports/ dir; a child reads the parent's handoff file. No re-discovery.
2. persona — a stage routes to code-reviewer/debugger/scout/planner/tester/etc. via Agent subagent_type. Zero new agent code — the 30 existing agents ARE the persona library.
3. config/gate — development-rules pre-flight + every parent gate apply to every stage; a child stage cannot silently skip a gate.
4. model/budget — a stage inherits the parent model or overrides it (e.g. parent opus, verify-skeptics haiku). Always name the model explicitly per stage — tier by work shape per model-tiering.md (single source: matrix, turn-count-beats-token-price, 529 one-tier fallback, dead-agent diff check). Cost estimate shown pre-run; no injected hard cap — the user decides.

Quality Patterns

Borrowed from the native feature, expressed as ClauKit orchestration (Agent-tool fan-out/pipeline) — never native JS agent()/parallel()/pipeline(). Full recipes in references/quality-patterns.md.

• Adversarial verify — N independent skeptic agents per finding, each prompted to refute (default refuted=true if unsure); kill the finding on majority refute. Filters plausible-but-wrong findings.
• Judge panel — N independent attempts from different angles → score → synthesize from the winner. Beats one-attempt-iterated.
• Loop-until-dry — re-spawn finders until K consecutive rounds surface nothing new. Catches the tail a single pass misses.
• Multi-modal sweep — parallel agents each searching a different way (by-container, by-content, by-entity).
• Completeness critic — a final agent asks "what's missing?" → its findings become the next round.

Guardrails

• Never recommend native ultracode — neither the ultracode keyword nor /effort ultracode. CLAUDE.md never enables session-wide ultracode. /ck:flow is the sole blessed orchestration entry point and is independent of the native runtime.
• Cost preview is mandatory — show the phase plan + token/budget estimate range before any fan-out; user approves / adjusts / aborts.
• Control-first — gates between phases + mid-run inspect/abort. Bounded by control, so no native 1000-agent backstop is needed.
• Preserve all 4 inheritance axes — a stage that drops one (e.g. doesn't read the parent handoff) breaks the model.
• Borrow patterns, not the runtime — express everything as ClauKit fan-out/pipeline.

⚠️ Patterns mirror Claude Code dynamic-workflows (research preview). Reference model verified 2026-06-03 — borrow patterns, do NOT call the native runtime. Re-verify https://code.claude.com/docs/en/workflows before relying on native signatures. No version floor: this skill uses the stable Agent tool, not the v2.1.154+ preview API.

Cross-links

[[team]] (persistent multi-session), [[orchestrate]] / orchestration-protocol (4th layer), [[cook]] (gated lifecycle), [[code-review]], [[planning]], [[scenario]]. Entry points: /ck:flow <task>, /ck:fix --flow, /ck:review --flow.