cclaw-cli 7.6.0 → 7.7.0

package/dist/content/stages/plan.js

@@ -10,8 +10,8 @@ export const PLAN = {
     skillDescription: "Execution planning stage with strict confirmation gate before implementation.",
     philosophy: {
         hardGate: "Do NOT write code or tests. Planning only. This stage produces a task graph and execution order. WAIT_FOR_CONFIRM before any handoff to implementation.",
-        ironLaw: "EVERY TASK IS 2–5 MINUTES, FULLY SPELLED OUT, AND CARRIES A STABLE ID — NO PLACEHOLDERS, NO ‘ETC.’.",
-        purpose: "Create small executable tasks with dependencies and pause for explicit user confirmation.",
+        ironLaw: "EVERY IMPLEMENTATION UNIT IS FEATURE-ATOMIC, WITH INTERNAL 2–5 MINUTE TDD STEPS — STRICT MICRO-SLICES ARE RESERVED FOR HIGH-RISK WORK.",
+        purpose: "Create feature-atomic implementation units with dependencies, internal TDD steps, and explicit confirmation before execution.",
         whenToUse: [
             "After spec approval",
             "Before writing tests or implementation",
@@ -43,21 +43,21 @@ export const PLAN = {
             "Read upstream — load spec, design, and scope artifacts. Cross-reference acceptance criteria.",
             "Build dependency graph — identify task ordering, parallel opportunities, and blocking dependencies.",
             "Group tasks into dependency batches — batch N+1 cannot start until batch N has verification evidence.",
-            "Slice into vertical tasks — each task targets 2-5 minutes, produces one testable outcome, and touches one coherent area.",
-            "Task Contract — every task has one coherent outcome, AC mapping, exact verification command/manual step, and expected evidence snippet or pass condition. Avoid vague `run tests` wording.",
+            "Slice into implementation units — each unit is feature-atomic and testable end-to-end, with internal 2-5 minute RED/GREEN/REFACTOR steps. Use `strict-micro` only for high-risk or explicitly requested micro-slice execution.",
+            "Task Contract — every unit has one coherent outcome, AC mapping, exact verification command/manual step, and expected evidence snippet or pass condition. Internal steps may be `T-NNN` rows, but they are not automatically separate schedulable agents in balanced/fast mode.",
             "Annotate slice-review metadata — task rows may carry `touchCount` (rough number of files expected to change), `touchPaths` (glob hints, e.g. `migrations/**`, `src/auth/**`), and optional `highRisk: true` to force a review pass. These fields feed the TDD stage's Per-Slice Review point.",
             "For every `### Implementation Unit U-<n>`, declare parallel metadata bullets: `id`, `dependsOn` (unit ids or `none`), `claimedPaths` (repo-relative), `parallelizable` (true|false), `riskTier` (low|standard|high), optional `lane` — used for conflict-aware wave plans and schedulers.",
             "Map scope Locked Decisions — every D-XX ID from scope is referenced by at least one plan task (or explicitly marked deferred with reason).",
             "Run anti-placeholder + anti-scope-reduction scans — block `TODO/TBD/...` and phrasing like `v1`, `for now`, `later` for locked boundaries.",
             "Define validation points — mark where progress must be checked before continuing, with concrete command and expected evidence.",
-            "Define execution posture — record whether execution should be sequential, dependency-batched, parallel-safe, or blocked; include risk triggers and RED/GREEN/REFACTOR checkpoint/commit expectations when the repo workflow supports them. This fulfills the `plan_execution_posture_recorded` gate.",
-            "**Author the FULL Parallel Execution Plan.** Inside the `<!-- parallel-exec-managed-start -->` block, enumerate ALL waves W-02..W-N covering EVERY T-NNN task in `## Task List` — no `we'll author waves later`, `next batch only`, or open-ended Backlog handwave is acceptable. Each task gets a slice with `sliceId | taskId | dependsOn | claimedPaths | parallelizable | riskTier | lane`. Spike rows (`S-N`) and tasks marked `deferred` in an explicit `Deferred:` column may be omitted, but every other T-NNN must be claimed. This fulfills the `plan_parallel_exec_full_coverage` gate. The TDD stage downstream is a pure consumer of these waves — if the plan does not author them, TDD cannot fan out that work.",
-            "After authoring/refreshing the managed parallel-exec block, render a Mermaid `flowchart` or `gantt` covering waves (`W-*`) and slice dependencies (`S-*`) so parallelism and fan-in boundaries are visually auditable.",
+            "Define execution topology — record `execution.topology` (`auto|inline|single-builder|parallel-builders|strict-micro`), `execution.strictness` (`fast|balanced|strict`), `execution.maxBuilders`, `plan.sliceGranularity`, `plan.microTaskPolicy`, stop conditions, and RED/GREEN/REFACTOR checkpoint/commit expectations. Default posture is `auto` + `balanced`: choose the cheapest safe route, not the most parallel one.",
+            "**Author the FULL Parallel Execution Plan.** Inside the `<!-- parallel-exec-managed-start -->` block, enumerate all waves W-01..W-N covering every feature-atomic `U-*` implementation unit/slice. Legacy strict-micro plans may cover each non-deferred `T-NNN` task instead. Each row carries `unit|sliceId | dependsOn | claimedPaths | parallelizable | riskTier | lane`. Do not leave `we'll author waves later`, `next batch only`, or open-ended Backlog handwaves. This fulfills the `plan_parallel_exec_full_coverage` gate. The TDD stage downstream is a pure consumer of these waves — if the plan does not author them, TDD cannot fan out that work.",
+            "After authoring/refreshing the managed parallel-exec block, render a Mermaid `flowchart` or `gantt` covering waves (`W-*`) and unit/slice dependencies (`U-*`/`S-*`) so topology and fan-in boundaries are visually auditable.",
             "WAIT_FOR_CONFIRM — write plan artifact and explicitly pause. **STOP.** Do NOT proceed until user confirms. Then close the stage with `node .cclaw/hooks/stage-complete.mjs plan` and tell user to run `/cc`."
         ],
         interactionProtocol: [
             "Plan in read-only mode relative to implementation.",
-            "Split work into small vertical slices (target 2-5 minute tasks).",
+            "Split work into feature-atomic vertical units; place 2-5 minute TDD steps inside each unit.",
             "Publish explicit dependency batches with entry and exit checks for each batch.",
             "Expose execution posture: sequential vs batch/parallel, stop conditions, and checkpoint cadence for the TDD handoff.",
             "Keep same-wave `claimedPaths` disjoint; if overlap exists, split waves or serialize explicitly before handoff.",
@@ -79,18 +79,18 @@ export const PLAN = {
             "Write plan artifact and pause at WAIT_FOR_CONFIRM."
         ],
         requiredGates: [
-            { id: "plan_tasks_sliced_2_5_min", description: "Tasks are small, executable slices." },
+            { id: "plan_tasks_sliced_2_5_min", description: "Implementation units are feature-atomic and contain internal 2-5 minute TDD steps; strict micro-slices are explicit." },
             { id: "plan_dependency_batches_defined", description: "Tasks are grouped into executable batches with gate checks and execution posture." },
             { id: "plan_acceptance_mapped", description: "Each task maps to a spec acceptance criterion." },
-            { id: "plan_execution_posture_recorded", description: "Execution posture is recorded before implementation handoff." },
-            { id: "plan_parallel_exec_full_coverage", description: "Every T-NNN task in `## Task List` (other than spikes/explicitly-deferred) is assigned to at least one slice inside the `<!-- parallel-exec-managed-start -->` block; TDD cannot fan out work that the plan never authored as waves." },
+            { id: "plan_execution_posture_recorded", description: "Execution topology/posture is recorded before implementation handoff." },
+            { id: "plan_parallel_exec_full_coverage", description: "Every U-* implementation unit/slice (or every T-NNN task in explicit strict-micro plans) is assigned inside the `<!-- parallel-exec-managed-start -->` block; TDD cannot fan out work that the plan never authored as waves." },
             { id: "plan_wave_paths_disjoint", description: "Within each authored wave, slice `claimedPaths` remain disjoint so `wave-fanout` can dispatch safely without overlap conflicts." },
             { id: "plan_module_introducing_slice_wires_root", description: "When a slice introduces a new module file, the stack-adapter's wiring aggregator (Rust `lib.rs`, Python `__init__.py`, Node-TS barrel when present) must appear in the same slice's claim or a transitive predecessor's claim so RED can be expressed." },
             { id: "plan_wait_for_confirm", description: "Execution blocked until explicit user confirmation." }
         ],
         requiredEvidence: [
             "Artifact written to `.cclaw/artifacts/05-plan.md`.",
-            "Task list includes acceptance mapping, exact verification command/manual step, and expected evidence/pass condition.",
+            "Implementation units include acceptance mapping, internal 2-5 minute TDD steps, exact verification command/manual step, and expected evidence/pass condition.",
             "Locked decision coverage table present with D-XX trace links.",
             "Dependency graph documented.",
             "Dependency batches documented with batch-by-batch verification gates.",
@@ -136,13 +136,13 @@ export const PLAN = {
             { section: "Upstream Handoff", required: false, validationRule: "Summarizes spec/design/scope decisions, constraints, open questions, and explicit drift before task breakdown." },
             { section: "Dependency Graph", required: false, validationRule: "Ordering and parallel opportunities explicit. No circular dependencies." },
             { section: "Dependency Batches", required: true, validationRule: "Every task belongs to a batch. Each batch has an exit gate and dependency statement." },
-            { section: "Task List", required: true, validationRule: "Each task row includes ID, description, acceptance criterion, exact verification command/manual step, expected evidence/pass condition, and effort estimate (S/M/L). Every task must also carry a minutes estimate within the 2-5 minute budget. When present, touchCount/touchPaths/highRisk metadata drives Per-Slice Review escalation in TDD." },
+            { section: "Task List", required: true, validationRule: "Task rows may describe internal 2-5 minute TDD steps. In balanced/fast mode, the schedulable unit is the feature-atomic Implementation Unit, not every T-NNN row. Strict-micro plans may still use one T-NNN per slice." },
             { section: "Acceptance Mapping", required: true, validationRule: "Every spec criterion is covered by at least one task." },
-            { section: "Execution Posture", required: true, validationRule: "States sequential/batch/parallel posture, stop conditions, risk triggers, and RED/GREEN/REFACTOR checkpoint or commit expectations for TDD when consistent with the repo workflow." },
+            { section: "Execution Posture", required: true, validationRule: "States `execution.topology` (`auto|inline|single-builder|parallel-builders|strict-micro`), `execution.strictness`, `execution.maxBuilders`, `plan.sliceGranularity`, `plan.microTaskPolicy`, stop conditions, risk triggers, and RED/GREEN/REFACTOR checkpoint or commit expectations for TDD when consistent with the repo workflow." },
             { section: "Locked Decision Coverage", required: false, validationRule: "Every locked decision ID (D-XX) from scope is listed with linked task IDs or explicit defer rationale." },
             { section: "Risk Assessment", required: false, validationRule: "If present: per-task or per-batch risk identification with likelihood, impact, and mitigation strategy." },
             { section: "Boundary Map", required: false, validationRule: "If present: per-batch or per-task interface contracts listing what each task produces (exports) and consumes (imports) from other tasks." },
-            { section: "Implementation Units", required: false, validationRule: "If present: each `### Implementation Unit U-<n>` includes Goal, Files, Approach, Test scenarios, Verification fields, plus bullets (`id`, `dependsOn`, `claimedPaths`, `parallelizable`, `riskTier`, optional `lane`)." },
+            { section: "Implementation Units", required: false, validationRule: "Each `### Implementation Unit U-<n>` includes Goal, Files, Approach, Test scenarios, Verification, internal 2-5 minute TDD steps, plus bullets (`id`, `dependsOn`, `claimedPaths`, `parallelizable`, `riskTier`, optional `lane`)." },
             { section: "Calibrated Findings", required: false, validationRule: "If present: either `None this stage` or one or more lines in `[P1|P2|P3] (confidence: <n>/10) <path>[:<line>] — <description>` format." },
             { section: "Regression Iron Rule", required: false, validationRule: "If present: includes `Iron rule acknowledged: yes`." },
             { section: "WAIT_FOR_CONFIRM", required: true, validationRule: "Explicit marker present. Status: pending until user approves." },
@@ -156,7 +156,7 @@ export const PLAN = {
                 title: "Task Decomposition Audit",
                 evaluationPoints: [
                     "Does every task target a single coherent area (vertical slice)?",
-                    "Can each task be completed in 2-5 minutes?",
+                    "Is each implementation unit feature-atomic, with internal steps that fit 2-5 minutes each?",
                     "Does every task have an acceptance criterion link, exact verification command/manual step, and expected evidence/pass condition?",
                     "Are there tasks that touch multiple unrelated areas?",
                     "Would a new engineer understand and start each task within two minutes?"
@@ -178,7 +178,7 @@ export const PLAN = {
             {
                 title: "Five-Minute Budget + No-Placeholders Audit",
                 evaluationPoints: [
-                    "Does every task carry an explicit minutes estimate (e.g. `[~3m]`) and does every estimate fit the 2-to-5-minute budget? Estimates >5 minutes must be split.",
+                    "Does every internal TDD step carry a bounded 2-to-5-minute estimate or checkbox-level step? Whole units may be larger when feature-atomic.",
                     "Are all file paths, test commands, verification commands, and expected evidence copy-pasteable/specific as written — no `TODO`, `TBD`, `FIXME`, `<fill-in>`, `<your-*-here>`, `xxx`, bare `run tests`, or ellipsis standing in for omitted args?",
                     "Does every acceptance-criterion reference resolve to a real R# / AC-### in the spec (not a blank link)?",
                     "If an estimate is genuinely uncertain (first-time integration, unfamiliar library), is the uncertainty named explicitly and scheduled as a spike task in batch 0, rather than hidden behind a large estimate?"

package/dist/content/stages/tdd.js

@@ -8,7 +8,7 @@ export const TDD = {
     complexityTier: "standard",
     skillFolder: "tdd",
     skillName: "tdd",
-    skillDescription: "Full vertical-slice TDD cycle: discover existing tests and system impact, then RED (failing tests), GREEN (minimal implementation), REFACTOR (cleanup). One source item at a time with strict traceability.",
+    skillDescription: "Adaptive vertical-slice TDD cycle: route each feature-atomic implementation unit through inline, single-builder, parallel-builder, or strict-micro execution while preserving RED-first traceability.",
     philosophy: {
         hardGate: "Do NOT merge, ship, or skip review. Follow RED → GREEN → REFACTOR strictly for each plan slice. Do NOT write implementation code before RED tests exist. Do NOT write RED tests before discovering relevant existing tests and impacted contracts. Do NOT skip the REFACTOR step.",
         ironLaw: "NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST — THE RED FAILURE IS THE SPEC.",
@@ -37,19 +37,21 @@ export const TDD = {
     },
     executionModel: {
         checklist: [
-            "**Wave discovery:** Entering TDD, first call `node .cclaw/cli.mjs internal wave-status --json`. It parses the managed `<!-- parallel-exec-managed-start -->` block; read `05-plan.md`/`wave-plans/` only once `wave-status` names work. Restore partial waves by parallelizing remaining members.",
-            "**Routing AskQuestion:** Two or more ready slices ⇒ exactly one AskQuestion (“launch wave …” vs “single slice …”, default wave). Otherwise do not ask “which slice next?” when the plan already resolves it.",
+            "**Wave discovery:** Entering TDD, first call `node .cclaw/cli.mjs internal wave-status --json`. It parses the managed `<!-- parallel-exec-managed-start -->` block and reports the adaptive `topology`; read `05-plan.md`/`wave-plans/` only once `wave-status` names work. Restore partial waves by resuming remaining units.",
+            "**Topology routing:** Default `auto` + `balanced` means cheapest safe route: inline for one low-risk inline-safe unit, single-builder for one feature-atomic unit or conflicts, parallel-builders only for genuinely independent substantial units, strict-micro for high-risk/configured micro-slice work.",
+            "**Routing AskQuestion:** Two or more ready units with `topology=parallel-builders` ⇒ exactly one AskQuestion (“launch wave …” vs “single builder …”, default wave). Otherwise do not ask “which slice next?” when the plan already resolves it.",
             "**Record before dispatch:** For every `Task`, write `delegation-record` `--status=scheduled` then `--status=launched` before the tool call. Workers self-record `acknowledged` and `completed`; back-fill is `--repair` only.",
-            "**One worker per slice:** Dispatch `slice-builder` with `--slice S-<id>` and explicit `--paths` from the plan. Parallel builders are allowed when paths are disjoint; honor any lane/lease flags the hook requires today.",
-            "**Single span owns the slice:** `slice-builder` runs RED → GREEN → REFACTOR (separate phase rows or `--refactor-outcome` on GREEN) and authors `<artifacts-dir>/tdd-slices/S-<id>.md`. Follow the agent body and `delegation-record` snippets it embeds.",
-            "**Wave closure:** When every slice in the wave has GREEN + REFACTOR coverage, call `integrationCheckRequired`. Dispatch `integration-overseer` when required; otherwise emit `cclaw_integration_overseer_skipped` via `delegation-record --audit-kind=...`.",
+            "**One worker per feature-atomic unit when delegated:** Dispatch `slice-builder` with `--slice S-<id>` and explicit `--paths` from the plan. The worker owns the unit's internal 2-5 minute RED/GREEN/REFACTOR steps. Parallel builders are allowed only when topology says `parallel-builders` and paths are disjoint; honor any lane/lease flags the hook requires today.",
+            "**Inline topology:** When the router/guidance chooses `inline`, the controller may execute the unit without a builder dispatch, but must still keep RED-before-GREEN, AC traceability, path containment, verification-before-completion, lockfile twin handling, managed commit/worktree policy, and orphan-change gates intact.",
+            "**Single span owns the delegated unit:** `slice-builder` runs RED → GREEN → REFACTOR (separate phase rows or `--refactor-outcome` on GREEN) and authors `<artifacts-dir>/tdd-slices/S-<id>.md`. Follow the agent body and `delegation-record` snippets it embeds.",
+            "**Wave closure:** When every slice/unit in the wave has GREEN + REFACTOR coverage, call `integrationCheckRequired`. Dispatch `integration-overseer` when required; otherwise emit `cclaw_integration_overseer_skipped` via `delegation-record --audit-kind=...`.",
             "**Plan triggers:** If the unit row demands extra scrutiny (`touchCount >= filesChangedThreshold`, matching `touchPaths`, or `highRisk`), capture that review posture in `tdd-slices/S-<id>.md` or via a reviewer dispatch before closing the slice.",
             "**Auto-render tables:** Do not hand-edit content between `auto-start: tdd-slice-summary` markers; the linter overwrites them from `delegation-events.jsonl`.",
             "**Active-span collisions:** If scheduling fails with `dispatch_duplicate` / `dispatch_active_span_collision`, identify the live span; use `--allow-parallel` or `--supersede` deliberately. Do not silence errors blindly.",
         ],
         interactionProtocol: [
-            "Parallel `slice-builder` tasks are allowed when `claimedPaths` are disjoint; remain serial when the plan orders dependencies.",
-            "Controller never writes production code or per-slice prose — the delegated worker does. Record routing decisions; cite `wave-status` before redundant slice questions.",
+            "Parallel `slice-builder` tasks are allowed only when topology is `parallel-builders` and `claimedPaths` are disjoint; remain serial for dependencies, conflicts, high-risk units, or strict-micro chains.",
+            "Controller normally orchestrates delegated builders. In `inline` topology it may execute directly, but must record the routing decision and satisfy the same RED/GREEN/REFACTOR evidence gates before completion.",
             "Discover existing tests and commands before RED; run a system-wide impact check (callbacks, state, interfaces, contracts) before GREEN.",
             "RED must fail for the right reason; capture logs. GREEN must run the full relevant suite, not a narrow subset.",
             "Before calling a slice done, run verification-before-completion (command + PASS/FAIL + durable commit evidence: managed-per-slice git commits when `.git` is present, or explicit no-VCS attestation + hash).",
@@ -59,8 +61,9 @@ export const TDD = {
         process: [
             "Map the slice to acceptance criteria; read `ralph-loop.json` for open RED cycles before starting new work.",
             "Discover tests, fixtures, helpers, and commands; record impact on public surfaces.",
-            "Dispatch `slice-builder` for RED (failing tests, no production edits beyond test files).",
-            "Dispatch the same builder for GREEN with minimal production changes and full-suite evidence.",
+            "Route the active unit via topology (`inline`, `single-builder`, `parallel-builders`, or `strict-micro`) before RED.",
+            "For delegated units, dispatch `slice-builder` for RED (failing tests, no production edits beyond test files).",
+            "For delegated units, dispatch the same builder for GREEN with minimal production changes and full-suite evidence.",
             "Close REFACTOR inline, via deferred phase, or `--refactor-outcome` on GREEN — match what `delegation-record` expects.",
             "Keep `tdd-slices/S-<id>.md` aligned with evidence as the builder finishes.",
             "Run fresh verification and attach traceability (plan task + spec criterion).",

package/dist/content/start-command.js

@@ -117,9 +117,9 @@ If during any stage the agent discovers evidence that contradicts the initial Ph
 4. Otherwise check current stage gates, resume if incomplete, and advance if complete.
 5. **TDD wave dispatch:** When \`currentStage\` is \`tdd\`, run \`node .cclaw/cli.mjs internal wave-status --json\` first, then read the managed **Parallel Execution Plan** block inside \`${RUNTIME_ROOT}/artifacts/05-plan.md\` plus \`${RUNTIME_ROOT}/artifacts/wave-plans/\` for detail. Resume partial waves on remaining members only.
 
-   **The controller never edits production code in TDD.** When \`mode: wave-fanout\` and \`pathConflicts: []\`, fan out the entire wave in a SINGLE controller message: one harness \`Task(subagent_type=…, description="slice-builder S-<id>", prompt=<full slice context>)\` call per ready slice, **side by side in the same tool batch**. Each \`slice-builder\` span owns the full RED → GREEN → REFACTOR → DOC cycle for its slice and emits its own \`delegation-record --phase=red|green|refactor|refactor-deferred|doc\` rows. RED-before-GREEN is enforced per-slice by the linter.
+   **The controller preserves TDD evidence.** When \`topology: parallel-builders\` and \`pathConflicts: []\`, fan out the ready independent units in a SINGLE controller message: one harness \`Task(subagent_type=…, description="slice-builder S-<id>", prompt=<full slice context>)\` call per routed builder, **side by side in the same tool batch**. Each \`slice-builder\` span owns the full RED → GREEN → REFACTOR → DOC cycle for its feature-atomic unit and emits its own \`delegation-record --phase=red|green|refactor|refactor-deferred|doc\` rows. RED-before-GREEN is enforced per-slice by the linter.
 
-   When \`mode: blocked\` with \`pathConflicts\`, surface exactly one AskQuestion that lets the user resolve the overlap (drop / split / serialize). When \`mode: single-slice\`, dispatch one \`Task\` for the next ready slice.
+   When \`mode: blocked\` with \`pathConflicts\`, surface exactly one AskQuestion that lets the user resolve the overlap (drop / split / serialize). When \`topology: single-builder\`, dispatch one \`Task\` for the next ready unit. When \`topology: inline\`, execute inline only if the same RED/GREEN/REFACTOR evidence and path/commit gates can be satisfied.
 
 6. **Auto-advance after stage-complete:** when \`stage-complete\` returns \`ok\` with a new \`currentStage\`, immediately load the next stage skill and continue without waiting for the user to retype \`/cc\`. Announce \`Stage <prev> complete → entering <next>. Continuing.\` and proceed.
 
@@ -214,7 +214,7 @@ Progress the tracked flow only when one exists:
 2. If missing, guide the user to run \`npx cclaw-cli init\` and stop.
 3. If it is only a fresh init placeholder (\`completedStages: []\`, no passed gates, and no \`${RUNTIME_ROOT}/artifacts/00-idea.md\`), stop and ask for \`/cc <prompt>\` to start a tracked run. Do not silently create a brainstorm run.
 4. Check gates for \`currentStage\`.
-5. **TDD:** When \`currentStage\` is \`tdd\`, run \`wave-status --json\`, then reconcile the managed **Parallel Execution Plan** in \`05-plan.md\` with \`wave-plans/wave-NN.md\`. **The controller never edits production code in TDD.** When \`mode: wave-fanout\` and \`pathConflicts: []\`, fan out the wave in a SINGLE controller message — one \`Task\` per ready slice, side by side. If \`mode: blocked\`, resolve overlaps first. Each \`slice-builder\` span owns its full RED → GREEN → REFACTOR → DOC cycle. Mirror plan \`dependsOn\` ordering between waves.
+5. **TDD:** When \`currentStage\` is \`tdd\`, run \`wave-status --json\`, then reconcile the managed **Parallel Execution Plan** in \`05-plan.md\` with \`wave-plans/wave-NN.md\`. Route by \`nextDispatch.topology\`: \`parallel-builders\` fans out independent units in one controller message, \`single-builder\` dispatches one builder, \`inline\` executes directly only with equivalent evidence, and \`strict-micro\` preserves tiny-slice sequencing. If \`mode: blocked\`, resolve overlaps first. Each delegated \`slice-builder\` span owns its full RED → GREEN → REFACTOR → DOC cycle. Mirror plan \`dependsOn\` ordering between waves.
 6. **Wave resume:** Parallelize unfinished members; never restart completed lanes. Integration-overseer follows \`integrationCheckRequired\`; when skipped, emit \`cclaw_integration_overseer_skipped\` per the hook contract.
 7. If incomplete → load current stage skill and execute.
 8. If complete → advance to next stage and execute. **Auto-advance:** when \`stage-complete\` returns \`ok\`, immediately load the next stage skill and continue without waiting for the user to retype \`/cc\`.

package/dist/content/subagent-context-skills.js

@@ -10,7 +10,7 @@ function skillFrontmatter(name, description) {
 function tddCycleEvidenceSkill() {
     return `${skillFrontmatter("tdd-cycle-evidence", "Evidence contract for the mandatory slice-builder delegation across RED/GREEN/REFACTOR/DOC.")}# TDD Cycle Evidence
 
-Use with the \`slice-builder\` delegation in the \`tdd\` stage. One \`slice-builder\` span owns the full cycle for a single vertical slice.
+Use with the \`slice-builder\` delegation in the \`tdd\` stage. One \`slice-builder\` span owns the full cycle for a feature-atomic implementation unit/slice, including its internal 2-5 minute TDD steps.
 
 ## Required Output
 
@@ -25,7 +25,7 @@ Use with the \`slice-builder\` delegation in the \`tdd\` stage. One \`slice-buil
 - No production code before RED evidence exists.
 - If a RED test cannot be expressed, stop and route back to design/spec with the blocker.
 - Record command output summaries, not just "tests passed".
-- Multiple \`slice-builder\` spans run in parallel inside one wave only when their \`claimedPaths\` are disjoint.
+- Multiple \`slice-builder\` spans run in parallel inside one wave only when topology is \`parallel-builders\` and their \`claimedPaths\` are disjoint. \`strict-micro\` keeps tiny tasks separate; \`inline\` skips delegation but not RED/GREEN/REFACTOR evidence.
 `;
 }
 function reviewSpecPassSkill() {

package/dist/content/subagents.js

@@ -37,7 +37,7 @@ description: "Orchestrate implementation via isolated subagents — one fresh ag
 Use a **controller -> coder -> overseer** loop when building multi-step software work.
 
 - **Controller (parent agent):** owns the plan, gating, sequencing, and dispatch decisions; never mixes deep implementation context with review evidence.
-- **Coder / slice-builder (subagent):** receives a **single self-contained task** and edits code only within that scope; exits with a structured status contract.
+- **Coder / slice-builder (subagent):** receives a **single feature-atomic implementation unit/slice** and edits code only within that scope; exits with a structured status contract.
 - **Overseer / reviewer (subagent):** validates outputs against the specification **by reading code** and never edits during the overseer pass.
 
 This pattern is intentionally **Superpowers-style**: cheap parallelism where it doesn’t corrupt state, strict serialization where it would.
@@ -62,7 +62,7 @@ Reconcile findings into \`.cclaw/artifacts/07-review-army.json\` with explicit s
 
 ### TDD evidence protocol
 
-Each parallel slice runs end-to-end inside one \`slice-builder\` delegation, with RED, GREEN, REFACTOR, and per-slice DOC as phase intents on a single span:
+Each delegated feature-atomic slice runs end-to-end inside one \`slice-builder\` delegation, with RED, GREEN, REFACTOR, and per-slice DOC as phase intents on a single span. The slice may contain internal 2-5 minute TDD steps; \`strict-micro\` is the explicit mode for one tiny task per slice:
 
 - \`--phase red\`: failing tests only, no production writes
 - \`--phase green\`: minimal production implementation that passes the matching RED
@@ -70,7 +70,7 @@ Each parallel slice runs end-to-end inside one \`slice-builder\` delegation, wit
 - \`--phase doc\`: write \`<artifacts-dir>/tdd-slices/S-<id>.md\` for the slice
 
 Set \`CCLAW_ACTIVE_AGENT\` to the active phase name when possible so workflow-guard
-can enforce phase-appropriate write boundaries. The mandatory gate is the evidence-backed \`slice-builder\` row, not multiple default subagents.
+can enforce phase-appropriate write boundaries. The mandatory gate is the evidence-backed \`slice-builder\` row for delegated topologies, not multiple default subagents. When TDD topology is \`inline\`, the controller may skip the builder but must preserve the same RED-before-GREEN, AC traceability, path containment, verification, managed commit/worktree, lockfile twin, and orphan-change gates.
 
 ## Model & Harness Routing Notes
 
@@ -154,7 +154,7 @@ If you catch yourself writing “read PLAN.md Task 3” or “implement the next
 Borrow the good part of Team/Ruflo-style orchestration without adding a swarm runtime:
 
 - **One controller owns alignment.** The parent keeps the task list, gate state, and final synthesis.
-- **Small fan-out by default.** Run at most 3-5 parallel agents, and only for independent read-only research or non-overlapping files.
+- **Small fan-out by topology.** Run at most configured \`maxBuilders\` parallel builders, and only for independent substantial units or independent read-only research/review lenses.
 - **No parallel writes to adjacent surfaces.** If tasks may touch the same module, serialize them.
 - **Checkpoint before synthesis.** Each agent returns status, files inspected/changed, evidence, and blockers before the parent acts.
 - **Consensus is for hard calls only.** Use two reviewers when severity or architecture is disputed; otherwise one evidence-backed reviewer is enough.
@@ -177,7 +177,7 @@ Before parallel dispatch, answer yes to all gates: tasks are independent, write
    - Copy each task verbatim into a working queue (checklist is fine).
    - Normalize each task so it includes: goal, acceptance criteria, constraints, and explicit “out of scope.”
 
-2. **For each task — sequential by default; parallel only with cohesion controls:**
+2. **For each unit — cheapest safe topology first; parallel only with cohesion controls:**
    - Implementation subagents are sequential by default. Parallel implementers
      are allowed only when ALL three conditions hold:
      - (a) the lanes touch non-overlapping files (verify via the plan's task
@@ -397,7 +397,7 @@ This document bridges **Superpowers-style task isolation** with the **gstack “
 ${conversationLanguagePolicyMarkdown()}
 **Default rule:** parallel implementation agents are SAFE for investigation, analysis, review, and the **TDD wave-fanout** path; otherwise keep implementation sequential.
 
-**TDD wave-fanout is the supported parallel-implementation path.** When \`cclaw-cli internal wave-status --json\` reports \`mode: wave-fanout\` and \`pathConflicts: []\`, fan out one \`slice-builder\` span per ready slice in a single controller message. Each span owns its disjoint \`claimedPaths\`; the dispatcher rejects overlapping spans with \`DispatchOverlapError\` inline, so the disjoint-paths invariant is enforced for you.
+**TDD wave-fanout is the supported parallel-implementation path.** When \`cclaw-cli internal wave-status --json\` reports \`topology: parallel-builders\` and \`pathConflicts: []\`, fan out one \`slice-builder\` span per ready feature-atomic unit/slice in a single controller message, capped by \`maxBuilders\`. Each span owns its disjoint \`claimedPaths\`; the dispatcher rejects overlapping spans with \`DispatchOverlapError\` inline, so the disjoint-paths invariant is enforced for you.
 
 **Outside wave-fanout** — for ad-hoc parallel implementation that touches shared source trees — keep work **sequential** unless you have proven disjoint filesystem ownership and an explicit merge protocol.
 

package/dist/content/templates.js

@@ -868,7 +868,7 @@ Execution rule: complete and verify each batch before starting the next batch.
 ## Task List
 
 **Rules (apply before writing rows):**
-- Every task fits the **2-5 minute budget**. If \`[~Nm]\` is >5, split the task.
+- Task rows are internal TDD steps unless \`Execution Topology\` is \`strict-micro\`. Keep each step in the **2-5 minute budget**; group related steps into feature-atomic \`U-*\` Implementation Units.
 - **No placeholders.** Forbidden tokens anywhere in this table: \`TODO\`, \`TBD\`, \`FIXME\`, \`<fill-in>\`, \`<your-*-here>\`, \`xxx\`, bare ellipsis. Every file path, test, and verification command must be copy-pasteable as written.
 - **No silent scope reduction.** Forbidden phrasing when locked decisions exist: \`v1\`, \`for now\`, \`later\`, \`temporary\`, \`placeholder\`, \`mock for now\`, \`hardcoded for now\`, \`will improve later\`.
 - If an estimate is genuinely uncertain (new library, unfamiliar subsystem), add a **spike task in batch 0** to de-risk — do NOT hide the uncertainty inside a large estimate.
@@ -883,7 +883,12 @@ Execution rule: complete and verify each batch before starting the next batch.
 | AC-1 | T-1 |
 
 ## Execution Posture
-- Posture: sequential | dependency-batched | parallel-safe | blocked
+- execution.topology: auto | inline | single-builder | parallel-builders | strict-micro
+- execution.strictness: fast | balanced | strict
+- execution.maxBuilders: 5
+- plan.sliceGranularity: feature-atomic | strict-micro
+- plan.microTaskPolicy: advisory | strict
+- Posture rationale: (why this is the cheapest safe topology)
 - Stop conditions:
 - Risk triggers:
 - TDD checkpoint plan: RED commit/checkpoint -> GREEN commit/checkpoint -> REFACTOR commit/checkpoint (or deferred because: )
@@ -904,7 +909,7 @@ Execution rule: complete and verify each batch before starting the next batch.
 |  |  |  |
 
 ## Implementation Units
-> Required structural form per implementation unit. Use ≥1 unit; bite-sized 2-5 minute steps inside each. The linter validates shape, not topic.
+> Required structural form per implementation unit. Default is feature-atomic units with bite-sized 2-5 minute TDD steps inside each. Use strict micro-slices only for high-risk work or when explicitly configured.
 
 ### Implementation Unit U-1
 - **id:** U-1
@@ -947,10 +952,10 @@ Execution rule: complete and verify each batch before starting the next batch.
 - Required pre-merge proof:
 
 ## Execution Handoff
-- **Posture chosen:** Subagent-Driven (recommended) | Inline executor
-- **Why this posture:** (one line tying choice to plan size, parallelism, novelty)
-- **Subagent recipe (if Subagent-Driven):** \`<harness>\` -> \`<dispatch surface>\` -> \`<agent-definition path>\` (substitute neutral placeholders; full recipes in \`docs/harnesses.md\`)
-- **Inline recipe (if Inline executor):** TDD loop unit-by-unit with batch checkpoints
+- **Topology chosen:** execution.topology = auto | inline | single-builder | parallel-builders | strict-micro
+- **Why this topology:** (one line tying choice to unit count, path independence, risk, and maxBuilders)
+- **Subagent recipe (if single/parallel builder):** \`<harness>\` -> \`<dispatch surface>\` -> \`<agent-definition path>\` (substitute neutral placeholders; full recipes in \`docs/harnesses.md\`)
+- **Inline recipe (if inline):** TDD loop unit-by-unit with the same RED-before-GREEN, AC traceability, path containment, verification, and managed commit/worktree gates
 
 ## Plan Quality Scan
 <!-- linter-meta -->

package/dist/delegation.d.ts

@@ -330,8 +330,9 @@ export declare class DispatchOverlapError extends Error {
 /**
  * Thrown when the count of active `slice-builder` spans reaches
  * `MAX_PARALLEL_SLICE_BUILDERS` and a new scheduled row would push it past
- * the cap. Cap can be overridden once via `--override-cap=N` on the hook
- * flag or globally via `CCLAW_MAX_PARALLEL_SLICE_BUILDERS=<N>` env.
+ * the cap. Cap can be configured via `.cclaw/config.yaml::execution.maxBuilders`,
+ * overridden once via `--override-cap=N` on the hook flag, or globally via
+ * `CCLAW_MAX_PARALLEL_SLICE_BUILDERS=<N>` env.
  */
 export declare class DispatchCapError extends Error {
     readonly cap: number;
@@ -536,7 +537,7 @@ export declare function validateFileOverlap(stamped: DelegationEntry, activeEntr
 };
 /**
  * Enforce the slice-builder fan-out cap. The new scheduled row pushes the
- * active count from N to N+1; if that would exceed the cap (default 5,
+ * active count from N to N+1; if that would exceed the cap (default/config 5,
  * env-overridable via `CCLAW_MAX_PARALLEL_SLICE_BUILDERS`), throw
  * `DispatchCapError`.
  *

package/dist/delegation.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { RUNTIME_ROOT } from "./constants.js";
-import { readConfig } from "./config.js";
+import { readConfig, resolveMaxBuilders } from "./config.js";
 import { exists, withDirectoryLock, writeFileSafe } from "./fs-utils.js";
 import { HARNESS_ADAPTERS } from "./harness-adapters.js";
 import { readFlowState } from "./runs.js";
@@ -616,8 +616,9 @@ export class DispatchOverlapError extends Error {
 /**
  * Thrown when the count of active `slice-builder` spans reaches
  * `MAX_PARALLEL_SLICE_BUILDERS` and a new scheduled row would push it past
- * the cap. Cap can be overridden once via `--override-cap=N` on the hook
- * flag or globally via `CCLAW_MAX_PARALLEL_SLICE_BUILDERS=<N>` env.
+ * the cap. Cap can be configured via `.cclaw/config.yaml::execution.maxBuilders`,
+ * overridden once via `--override-cap=N` on the hook flag, or globally via
+ * `CCLAW_MAX_PARALLEL_SLICE_BUILDERS=<N>` env.
  */
 export class DispatchCapError extends Error {
     cap;
@@ -1111,7 +1112,7 @@ export function validateFileOverlap(stamped, activeEntries) {
 }
 /**
  * Enforce the slice-builder fan-out cap. The new scheduled row pushes the
- * active count from N to N+1; if that would exceed the cap (default 5,
+ * active count from N to N+1; if that would exceed the cap (default/config 5,
  * env-overridable via `CCLAW_MAX_PARALLEL_SLICE_BUILDERS`), throw
  * `DispatchCapError`.
  *
@@ -1126,9 +1127,13 @@ export function validateFanOutCap(stamped, activeEntries, override) {
         return;
     if (stamped.status !== "scheduled")
         return;
-    const cap = (override !== null && override !== undefined && Number.isInteger(override) && override >= 1)
-        ? override
-        : (readMaxParallelOverrideFromEnv() ?? MAX_PARALLEL_SLICE_BUILDERS);
+    const cap = readMaxParallelOverrideFromEnv() ??
+        (override !== null &&
+            override !== undefined &&
+            Number.isInteger(override) &&
+            override >= 1
+            ? override
+            : MAX_PARALLEL_SLICE_BUILDERS);
     const sameLaneActive = activeEntries.filter((entry) => entry.stage === stamped.stage &&
         entry.agent === stamped.agent &&
         entry.spanId !== stamped.spanId);
@@ -1271,7 +1276,8 @@ export async function appendDelegation(projectRoot, entry) {
             if (overlap.autoParallel && stamped.allowParallel !== true) {
                 stamped.allowParallel = true;
             }
-            validateFanOutCap(stamped, activeForRun);
+            const config = await readConfig(projectRoot).catch(() => null);
+            validateFanOutCap(stamped, activeForRun, resolveMaxBuilders(config));
             if (stamped.allowParallel !== true) {
                 const existing = findActiveSpanForPair(stamped.stage, stamped.agent, activeRunId, prior);
                 if (existing && existing.spanId && existing.spanId !== stamped.spanId) {

package/dist/execution-topology.d.ts

@@ -0,0 +1,36 @@
+import type { ExecutionStrictnessProfile, ExecutionTopology } from "./types.js";
+export interface ExecutionTopologyShape {
+    /** Ready implementation units/slices the controller could execute now. */
+    unitCount: number;
+    /** Ready units with no declared dependency/path conflict against each other. */
+    independentUnitCount?: number;
+    /** Ready units large enough to justify isolated builder overhead. */
+    substantialUnitCount?: number;
+    /** True when same-wave path ownership overlaps or is unknown-dangerous. */
+    hasPathConflicts?: boolean;
+    /** True for migrations, public contracts, security, data loss, or broad API changes. */
+    highRisk?: boolean;
+    /** True when a plan or controller explicitly requests micro-slice discipline. */
+    requiresStrictMicro?: boolean;
+    /** True when the controller can safely execute the unit inline in the current harness. */
+    inlineSafe?: boolean;
+}
+export interface ExecutionTopologyDecision {
+    topology: Exclude<ExecutionTopology, "auto">;
+    maxBuilders: number;
+    reason: string;
+}
+export interface RouteExecutionTopologyOptions {
+    configuredTopology?: ExecutionTopology;
+    strictness?: ExecutionStrictnessProfile;
+    maxBuilders?: number;
+    shape: ExecutionTopologyShape;
+}
+/**
+ * Choose the cheapest safe execution topology for a ready TDD surface.
+ *
+ * Safety invariants are intentionally conservative: explicit strict-micro wins,
+ * path conflicts prevent fan-out, and parallel builders require multiple
+ * independent substantial units plus a builder cap above one.
+ */
+export declare function routeExecutionTopology(options: RouteExecutionTopologyOptions): ExecutionTopologyDecision;

package/dist/execution-topology.js

@@ -0,0 +1,73 @@
+const DEFAULT_MAX_BUILDERS = 5;
+function normalizeMaxBuilders(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 1
+        ? value
+        : DEFAULT_MAX_BUILDERS;
+}
+/**
+ * Choose the cheapest safe execution topology for a ready TDD surface.
+ *
+ * Safety invariants are intentionally conservative: explicit strict-micro wins,
+ * path conflicts prevent fan-out, and parallel builders require multiple
+ * independent substantial units plus a builder cap above one.
+ */
+export function routeExecutionTopology(options) {
+    const configured = options.configuredTopology ?? "auto";
+    const strictness = options.strictness ?? "balanced";
+    const maxBuilders = normalizeMaxBuilders(options.maxBuilders);
+    const shape = options.shape;
+    if (configured !== "auto") {
+        return {
+            topology: configured,
+            maxBuilders,
+            reason: `configured execution.topology=${configured}`
+        };
+    }
+    if (shape.requiresStrictMicro || strictness === "strict") {
+        return {
+            topology: "strict-micro",
+            maxBuilders,
+            reason: shape.requiresStrictMicro
+                ? "plan requested strict micro-slice execution"
+                : "strict execution profile selected"
+        };
+    }
+    const unitCount = Math.max(0, shape.unitCount);
+    if (unitCount === 0) {
+        return {
+            topology: "inline",
+            maxBuilders,
+            reason: "no ready units; controller can reconcile inline"
+        };
+    }
+    if (shape.hasPathConflicts) {
+        return {
+            topology: "single-builder",
+            maxBuilders,
+            reason: "path conflicts require serialized execution"
+        };
+    }
+    const independent = shape.independentUnitCount ?? unitCount;
+    const substantial = shape.substantialUnitCount ?? unitCount;
+    if (maxBuilders > 1 && independent >= 2 && substantial >= 2) {
+        return {
+            topology: "parallel-builders",
+            maxBuilders,
+            reason: "multiple independent substantial units are ready"
+        };
+    }
+    if (unitCount === 1 && shape.inlineSafe && !shape.highRisk) {
+        return {
+            topology: "inline",
+            maxBuilders,
+            reason: "single low-risk inline-safe unit"
+        };
+    }
+    return {
+        topology: "single-builder",
+        maxBuilders,
+        reason: unitCount === 1
+            ? "single ready unit keeps builder evidence isolated"
+            : "ready units are not safely parallelizable"
+    };
+}

package/dist/internal/plan-split-waves.d.ts

@@ -64,8 +64,11 @@ export declare function extractMembersListFromLine(trimmedLine: string): string
  *
  * Rules:
  * - The line must start with `|` (after trimming).
- * - Column 1 (after stripping markdown noise) must match `^S-(\d+)$` —
- *   header rows (`| sliceId | …`) and separator rows (`|---|---|…`) are
+ * - Column 1 (after stripping markdown noise) may be either a slice id
+ *   (`S-N`) or an implementation-unit id (`U-N`). Unit ids derive their
+ *   execution slice as `S-N`, which lets 7.7+ plans schedule feature-atomic
+ *   units without inventing a tiny `T-NNN` row per dispatch lane. Header rows
+ *   (`| sliceId | …`, `| unit | …`) and separator rows (`|---|---|…`) are
  *   silently skipped.
  * - Column 2, when present and non-empty, becomes the `unitId`
  *   verbatim (after stripping whitespace + backticks/quotes/brackets).

package/dist/internal/plan-split-waves.js

@@ -71,8 +71,11 @@ export function extractMembersListFromLine(trimmedLine) {
  *
  * Rules:
  * - The line must start with `|` (after trimming).
- * - Column 1 (after stripping markdown noise) must match `^S-(\d+)$` —
- *   header rows (`| sliceId | …`) and separator rows (`|---|---|…`) are
+ * - Column 1 (after stripping markdown noise) may be either a slice id
+ *   (`S-N`) or an implementation-unit id (`U-N`). Unit ids derive their
+ *   execution slice as `S-N`, which lets 7.7+ plans schedule feature-atomic
+ *   units without inventing a tiny `T-NNN` row per dispatch lane. Header rows
+ *   (`| sliceId | …`, `| unit | …`) and separator rows (`|---|---|…`) are
  *   silently skipped.
  * - Column 2, when present and non-empty, becomes the `unitId`
  *   verbatim (after stripping whitespace + backticks/quotes/brackets).
@@ -94,13 +97,16 @@ export function parseTableRowMember(trimmedLine) {
     const stripDecorations = (raw) => raw.replace(/^[`"'[\]()]+|[`"'[\]()]+$/gu, "").trim();
     const col1 = stripDecorations(cells[0]);
     const parsedSlice = parseSliceId(col1);
-    if (!parsedSlice)
+    const parsedUnit = tokenToSliceAndUnit(col1);
+    if (!parsedSlice && !parsedUnit)
         return null;
-    const sliceTail = parsedSlice.suffix.length > 0
-        ? `${parsedSlice.numeric}${parsedSlice.suffix}`
-        : `${parsedSlice.numeric}`;
-    const sliceId = parsedSlice.id;
-    let unitId = `U-${sliceTail}`;
+    const sliceTail = parsedSlice
+        ? parsedSlice.suffix.length > 0
+            ? `${parsedSlice.numeric}${parsedSlice.suffix}`
+            : `${parsedSlice.numeric}`
+        : "";
+    const sliceId = parsedSlice ? parsedSlice.id : parsedUnit.sliceId;
+    let unitId = parsedSlice ? `U-${sliceTail}` : parsedUnit.unitId;
     if (cells.length >= 2) {
         const col2 = stripDecorations(cells[1]);
         if (col2.length > 0) {

package/dist/internal/wave-status.d.ts

@@ -1,4 +1,5 @@
 import type { Writable } from "node:stream";
+import type { ExecutionTopology } from "../types.js";
 interface InternalIo {
     stdout: Writable;
     stderr: Writable;
@@ -17,6 +18,9 @@ export interface WaveStatusNextDispatch {
     readyToDispatch: string[];
     pathConflicts: string[];
     mode: "single-slice" | "wave-fanout" | "blocked" | "none";
+    topology: Exclude<ExecutionTopology, "auto"> | "none";
+    topologyReason: string;
+    maxBuilders: number;
 }
 export interface WaveStatusReport {
     activeRunId: string;