cclaw-cli 7.5.0 → 7.7.0

package/README.md

@@ -68,7 +68,8 @@ That gives you:
 
 - **One path** from idea to ship, with one user-chosen discovery mode (`lean`, `guided`, `deep`) and internal `quick` / `medium` / `standard` tracks.
 - **Real gates** for evidence, tests, review, delegation, stale-stage recovery, and closeout.
-- **Subagents with accountability**: controller owns state, workers do bounded tasks, overseers validate, evidence lands in `delegation-log.json`.
+- **Adaptive TDD execution**: feature-atomic slices carry internal 2-5 minute RED/GREEN/REFACTOR steps; cclaw routes them inline, through one builder, through parallel builders, or through strict micro-slices when risk demands it.
+- **Subagents with accountability**: controller owns state, workers do bounded implementation units, overseers validate, evidence lands in `delegation-log.json`.
 - **Recovery instead of confusion**: `npx cclaw-cli sync` tells you blockers and next fixes.
 - **Portable harness behavior** across Claude Code, Cursor, OpenCode, and Codex.
 

package/dist/artifact-linter/plan.js

@@ -4,10 +4,17 @@ import { exists } from "../fs-utils.js";
 import { FORBIDDEN_PLACEHOLDER_TOKENS, CONFIDENCE_FINDING_REGEX_SOURCE } from "../content/skills.js";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { PLAN_SPLIT_SMALL_PLAN_THRESHOLD, parseImplementationUnits, parseImplementationUnitParallelFields } from "../internal/plan-split-waves.js";
+import { PLAN_SPLIT_SMALL_PLAN_THRESHOLD, parseImplementationUnits, parseImplementationUnitParallelFields, parseParallelExecutionPlanWaves } from "../internal/plan-split-waves.js";
+import { compareSliceIds, parseSliceId } from "../util/slice-id.js";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { loadStackAdapter } from "../stack-detection.js";
+import { readConfig, resolveExecutionStrictness, resolveExecutionTopology, resolvePlanMicroTaskPolicy, resolvePlanSliceGranularity } from "../config.js";
+const execFileAsync = promisify(execFile);
 const PARALLEL_EXEC_MANAGED_START = "<!-- parallel-exec-managed-start -->";
 const PARALLEL_EXEC_MANAGED_END = "<!-- parallel-exec-managed-end -->";
 const TASK_ID_PATTERN = /\bT-\d{3}[a-z]?(?:\.\d{1,3})?\b/giu;
+const UNIT_ID_PATTERN = /\bU-\d+(?:[a-z][a-z0-9]*)?\b/giu;
 const ACCEPTANCE_ID_PATTERN = /\bAC-\d+\b/giu;
 const PLAN_LANE_WHITELIST = new Set([
     "production",
@@ -31,6 +38,13 @@ function extractTaskIds(body) {
     }
     return ids;
 }
+function extractUnitIds(body) {
+    const ids = new Set();
+    for (const match of body.matchAll(UNIT_ID_PATTERN)) {
+        ids.add(match[0].toUpperCase());
+    }
+    return ids;
+}
 function extractAcceptanceTaskLinks(body) {
     const links = [];
     for (const line of body.split(/\r?\n/u)) {
@@ -111,7 +125,11 @@ function parseParallelWaveTableMetadata(planMarkdown) {
         if (cells.length === 0)
             continue;
         const first = cells[0].toLowerCase();
-        const isHeader = first === "sliceid" || first === "slice id";
+        const isHeader = first === "sliceid" ||
+            first === "slice id" ||
+            first === "unitid" ||
+            first === "unit id" ||
+            first === "unit";
         if (isHeader) {
             headerIdx = headerIndexByName(cells);
             continue;
@@ -119,14 +137,18 @@ function parseParallelWaveTableMetadata(planMarkdown) {
         if (cells.every((cell) => /^:?-{3,}:?$/u.test(cell))) {
             continue;
         }
-        const sliceCell = cells[0];
-        if (!/^S-\d+$/iu.test(sliceCell))
+        const sliceCell = cells[0].replace(/^`|`$/gu, "").trim();
+        const parsedSlice = parseSliceId(sliceCell);
+        const parsedUnit = /^U-(\d+(?:[a-z][a-z0-9]*)?)$/iu.exec(sliceCell);
+        if (!parsedSlice && !parsedUnit)
             continue;
+        const sliceId = parsedSlice?.id ?? `S-${parsedUnit[1].toLowerCase()}`;
         const idx = headerIdx ?? new Map();
         const unitIdx = idx.get("unit") ?? idx.get("taskid") ?? 1;
         const pathsIdx = idx.get("claimedpaths");
         const parallelizableIdx = idx.get("parallelizable");
         const laneIdx = idx.get("lane");
+        const dependsOnIdx = idx.get("dependson");
         const rawPaths = pathsIdx !== undefined ? (cells[pathsIdx] ?? "") : "";
         const claimedPaths = rawPaths.length === 0
             ? []
@@ -141,12 +163,22 @@ function parseParallelWaveTableMetadata(planMarkdown) {
         if (rawParallel === "false" || rawParallel === "no")
             parallelizable = false;
         const laneRaw = laneIdx !== undefined ? (cells[laneIdx] ?? "").trim().toLowerCase() : "";
+        const rawDeps = dependsOnIdx !== undefined ? (cells[dependsOnIdx] ?? "") : "";
+        const dependsOn = rawDeps.length === 0
+            ? []
+            : rawDeps
+                .replace(/^\[|\]$/gu, "")
+                .split(/[,\s]+/u)
+                .map((token) => token.trim().replace(/^`|`$/gu, ""))
+                .map((token) => parseSliceId(token)?.id ?? "")
+                .filter((id) => id.length > 0);
         current.rows.push({
-            sliceId: sliceCell.toUpperCase(),
+            sliceId,
             unit: (cells[unitIdx] ?? "").trim(),
             claimedPaths,
             parallelizable,
-            lane: laneRaw.length > 0 ? laneRaw : null
+            lane: laneRaw.length > 0 ? laneRaw : null,
+            dependsOn
         });
     }
     flush();
@@ -156,8 +188,72 @@ function waveHasSequentialModeHint(wave) {
     const noteText = wave.notes.join("\n").toLowerCase();
     return /mode\s*:\s*sequential/iu.test(noteText) || /\bsequential\b/iu.test(noteText) || /\bserial\b/iu.test(noteText);
 }
+/**
+ * Capture the set of repo-relative paths tracked at HEAD. Returns an
+ * empty set when the project root is not a git repo or `git ls-files`
+ * fails — the wiring linter degrades to "no aggregator required" in
+ * that case rather than crashing the whole stage check.
+ */
+async function readHeadFiles(projectRoot) {
+    try {
+        const { stdout } = await execFileAsync("git", ["ls-files", "-z"], { cwd: projectRoot, maxBuffer: 64 * 1024 * 1024 });
+        const out = new Set();
+        for (const segment of stdout.split("\u0000")) {
+            const trimmed = segment.trim();
+            if (trimmed.length === 0)
+                continue;
+            out.add(trimmed.replace(/\\/gu, "/"));
+        }
+        return out;
+    }
+    catch {
+        return new Set();
+    }
+}
+function buildSliceClaimGraph(waves) {
+    const bySliceId = new Map();
+    for (const wave of waves) {
+        for (const row of wave.rows) {
+            bySliceId.set(row.sliceId, row);
+        }
+    }
+    return { bySliceId };
+}
+/**
+ * Walk the dependsOn graph from `sliceId` and return the set of
+ * predecessor slice ids (transitive). Skips ids that aren't in the
+ * graph and handles cycles via a `visiting` set so a malformed plan
+ * doesn't lock the linter.
+ */
+function transitivePredecessors(sliceId, graph) {
+    const out = new Set();
+    const stack = [sliceId];
+    const visiting = new Set();
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (visiting.has(current))
+            continue;
+        visiting.add(current);
+        const row = graph.bySliceId.get(current);
+        if (!row)
+            continue;
+        for (const predecessor of row.dependsOn) {
+            const normalized = parseSliceId(predecessor)?.id ?? predecessor;
+            if (out.has(normalized))
+                continue;
+            out.add(normalized);
+            stack.push(normalized);
+        }
+    }
+    return out;
+}
 export async function lintPlanStage(ctx) {
     const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
+    const config = await readConfig(projectRoot).catch(() => null);
+    const executionStrictness = resolveExecutionStrictness(config);
+    const executionTopology = resolveExecutionTopology(config);
+    const planSliceGranularity = resolvePlanSliceGranularity(config);
+    const planMicroTaskPolicy = resolvePlanMicroTaskPolicy(config);
     evaluateInvestigationTrace(ctx, "Implementation Units");
     const strictPlanGuards = parsedFrontmatter.hasFrontmatter ||
         headingPresent(sections, "Plan Quality Scan") ||
@@ -424,6 +520,29 @@ export async function lintPlanStage(ctx) {
         });
     }
     const planUnits = parseImplementationUnits(raw);
+    const authoredTaskIdsForShape = extractTaskIds(sectionBodyByName(sections, "Task List") ?? "");
+    const microtaskOnlyPlan = authoredTaskIdsForShape.size > 1 &&
+        planUnits.length === 0 &&
+        executionTopology !== "strict-micro" &&
+        planSliceGranularity !== "strict-micro";
+    const strictMicroPolicy = executionStrictness === "strict" ||
+        executionTopology === "strict-micro" ||
+        planSliceGranularity === "strict-micro" ||
+        planMicroTaskPolicy === "strict";
+    const microtaskOnlyAdvisoryApplies = microtaskOnlyPlan &&
+        !strictMicroPolicy &&
+        (executionStrictness === "fast" || executionStrictness === "balanced");
+    findings.push({
+        section: "plan_microtask_only_advisory",
+        required: false,
+        rule: "Balanced/fast execution should plan feature-atomic implementation units/slices with internal 2-5 minute TDD steps; reserve one-task-one-slice microtask plans for `execution.topology: strict-micro`, `execution.strictness: strict`, or `plan.microTaskPolicy: strict`.",
+        found: !microtaskOnlyAdvisoryApplies,
+        details: microtaskOnlyAdvisoryApplies
+            ? `Task List has ${authoredTaskIdsForShape.size} tiny task id(s) but no Implementation Units. In execution.strictness=${executionStrictness} with plan.microTaskPolicy=${planMicroTaskPolicy}, group related tasks into U-* feature-atomic slices with internal RED/GREEN/REFACTOR steps, or set execution.topology=strict-micro / plan.microTaskPolicy=strict for high-risk micro-slice execution.`
+            : strictMicroPolicy
+                ? "Strict micro-slice posture is configured; microtask-only planning is allowed."
+                : "Plan includes implementation units or does not look microtask-only."
+    });
     const parallelMetaApplies = strictPlanGuards && planUnits.length > 0;
     if (parallelMetaApplies) {
         const metaRulesRequired = true;
@@ -497,6 +616,7 @@ export async function lintPlanStage(ctx) {
     if (strictPlanGuards) {
         const taskListSection = sectionBodyByName(sections, "Task List") ?? "";
         const authoredTaskIds = extractTaskIds(taskListSection);
+        const authoredUnitIds = new Set(planUnits.map((unit) => unit.id.toUpperCase()));
         // Collect deferred / backlog task ids so they don't trigger the
         // "uncovered" finding. Both heading variants are accepted.
         const deferredBody = (sectionBodyByName(sections, "Deferred Tasks") ?? "") +
@@ -505,29 +625,58 @@ export async function lintPlanStage(ctx) {
         const deferredIds = extractTaskIds(deferredBody);
         const parallelExecBody = extractParallelExecManagedBody(raw);
         const claimedIds = extractTaskIds(parallelExecBody);
+        const claimedUnitIds = extractUnitIds(parallelExecBody);
+        try {
+            for (const wave of parseParallelExecutionPlanWaves(raw)) {
+                for (const member of wave.members) {
+                    if (/^U-\d+(?:[a-z][a-z0-9]*)?$/iu.test(member.unitId)) {
+                        claimedUnitIds.add(member.unitId.toUpperCase());
+                    }
+                }
+            }
+        }
+        catch {
+            // Duplicate/malformed wave plans are reported by the wave parser/status
+            // path; this coverage gate falls back to raw token extraction.
+        }
+        const useImplementationUnitCoverage = authoredUnitIds.size > 0;
         const uncovered = [];
-        for (const id of authoredTaskIds) {
-            if (claimedIds.has(id))
-                continue;
-            if (deferredIds.has(id))
-                continue;
-            uncovered.push(id);
+        if (useImplementationUnitCoverage) {
+            for (const id of authoredUnitIds) {
+                if (claimedUnitIds.has(id))
+                    continue;
+                uncovered.push(id);
+            }
+        }
+        else {
+            for (const id of authoredTaskIds) {
+                if (claimedIds.has(id))
+                    continue;
+                if (deferredIds.has(id))
+                    continue;
+                uncovered.push(id);
+            }
         }
         uncovered.sort();
         const blockPresent = parallelExecBody.length > 0;
-        const taskListPresent = authoredTaskIds.size > 0;
+        const coverageTargetPresent = useImplementationUnitCoverage || authoredTaskIds.size > 0;
+        const coverageTargetLabel = useImplementationUnitCoverage
+            ? "implementation unit"
+            : "task id";
         findings.push({
             section: "plan_parallel_exec_full_coverage",
-            required: taskListPresent,
-            rule: "Every T-NNN task in `## Task List` must be assigned to at least one slice inside the `<!-- parallel-exec-managed-start -->` block (or moved to an explicit `## Deferred Tasks` / `## Backlog` section). TDD cannot fan out waves the plan never authored.",
-            found: taskListPresent && blockPresent && uncovered.length === 0,
-            details: !taskListPresent
-                ? "Task List section is empty or missing T-NNN ids; full-coverage check skipped."
+            required: coverageTargetPresent,
+            rule: "Every feature-atomic Implementation Unit (`U-*`) must be assigned to at least one slice/wave inside the `<!-- parallel-exec-managed-start -->` block. Legacy strict-micro plans without units may instead cover every non-deferred `T-NNN` task. TDD cannot fan out waves the plan never authored.",
+            found: coverageTargetPresent && blockPresent && uncovered.length === 0,
+            details: !coverageTargetPresent
+                ? "No Implementation Units or T-NNN task ids found; full-coverage check skipped."
                 : !blockPresent
-                    ? "`<!-- parallel-exec-managed-start -->` block is missing or empty. Author the Parallel Execution Plan with W-02..W-N covering every task before plan-final-approval."
+                    ? "`<!-- parallel-exec-managed-start -->` block is missing or empty. Author the Parallel Execution Plan with W-02..W-N covering every implementation unit/slice before plan-final-approval."
                     : uncovered.length === 0
-                        ? `Parallel Execution Plan covers all ${authoredTaskIds.size} authored task id(s); ${deferredIds.size} task id(s) are explicitly deferred.`
-                        : `Uncovered task id(s) — author waves for: ${uncovered.slice(0, 25).join(", ")}${uncovered.length > 25 ? `, … (${uncovered.length - 25} more)` : ""}. Either add slices for them inside <!-- parallel-exec-managed-start --> or move them under \`## Deferred Tasks\` with a reason.`
+                        ? useImplementationUnitCoverage
+                            ? `Parallel Execution Plan covers all ${authoredUnitIds.size} implementation unit(s); internal ${authoredTaskIds.size} T-NNN step(s) remain inside those units.`
+                            : `Parallel Execution Plan covers all ${authoredTaskIds.size} authored task id(s); ${deferredIds.size} task id(s) are explicitly deferred.`
+                        : `Uncovered ${coverageTargetLabel}(s) — author waves for: ${uncovered.slice(0, 25).join(", ")}${uncovered.length > 25 ? `, … (${uncovered.length - 25} more)` : ""}. ${useImplementationUnitCoverage ? "Add U-* rows/members inside <!-- parallel-exec-managed-start -->." : "Either add slices for them inside <!-- parallel-exec-managed-start --> or move them under `## Deferred Tasks` with a reason."}`
         });
         const waveMeta = parseParallelWaveTableMetadata(raw);
         const pathConflicts = [];
@@ -547,11 +696,11 @@ export async function lintPlanStage(ctx) {
         }
         findings.push({
             section: "plan_wave_paths_disjoint",
-            required: taskListPresent,
+            required: coverageTargetPresent,
             rule: "Slices within the same wave must keep `claimedPaths` disjoint so TDD can safely fan out parallel slice-builders.",
-            found: taskListPresent && blockPresent && pathConflicts.length === 0,
-            details: !taskListPresent
-                ? "Task List section is empty or missing T-NNN ids; disjoint-path wave check skipped."
+            found: coverageTargetPresent && blockPresent && pathConflicts.length === 0,
+            details: !coverageTargetPresent
+                ? "No Implementation Units or T-NNN task ids found; disjoint-path wave check skipped."
                 : !blockPresent
                     ? "`<!-- parallel-exec-managed-start -->` block is missing or empty; cannot validate wave path disjointness."
                     : pathConflicts.length === 0
@@ -600,7 +749,7 @@ export async function lintPlanStage(ctx) {
                 : `Serial slice(s) found without sequential wave mode hints in: ${inconsistentParallelizable.join(", ")}. Add a wave mode/note indicating sequential execution.`
         });
         const mermaidBlocks = raw.match(/```mermaid[\s\S]*?```/giu) ?? [];
-        const hasParallelExecMermaid = mermaidBlocks.some((block) => /(flowchart|gantt)/iu.test(block) && /\bW-\d+\b/iu.test(block) && /\bS-\d+\b/iu.test(block));
+        const hasParallelExecMermaid = mermaidBlocks.some((block) => /(flowchart|gantt)/iu.test(block) && /\bW-\d+\b/iu.test(block) && /\bS-\d+(?:[a-z][a-z0-9]*)?\b/iu.test(block));
         findings.push({
             section: "plan_parallel_exec_mermaid_present",
             required: false,
@@ -610,5 +759,68 @@ export async function lintPlanStage(ctx) {
                 ? "Mermaid visualization for parallel execution waves is present."
                 : "No mermaid parallel-execution visualization found (advisory). Add a ` ```mermaid ` flowchart or gantt with W-* and S-* nodes."
         });
+        // 7.6.0 — plan_module_introducing_slice_wires_root.
+        // Stack-aware: stack-adapter exposes a `wiringAggregator` contract
+        // for stacks where introducing a new module file requires a
+        // sibling aggregator update (Rust lib.rs, Python __init__.py,
+        // optional Node-TS index.ts). For each NEW path in a slice's
+        // claim, if the adapter says an aggregator is required, the
+        // aggregator path must appear in the slice's own claim or in any
+        // transitive predecessor's claim within the same flow.
+        //
+        // For unknown stacks (Go, Java, Ruby, Swift, .NET, Elixir, …)
+        // the adapter returns `wiringAggregator: undefined`, so this
+        // gate is a no-op and `found: true`.
+        const stackAdapter = await loadStackAdapter(projectRoot);
+        const headFiles = await readHeadFiles(projectRoot);
+        const wiringIssues = [];
+        if (stackAdapter.wiringAggregator) {
+            const claimGraph = buildSliceClaimGraph(waveMeta);
+            for (const wave of waveMeta) {
+                for (const row of [...wave.rows].sort((a, b) => compareSliceIds(a.sliceId, b.sliceId))) {
+                    const predecessors = transitivePredecessors(row.sliceId, claimGraph);
+                    const predecessorClaims = new Set();
+                    for (const predId of predecessors) {
+                        const predRow = claimGraph.bySliceId.get(predId);
+                        if (!predRow)
+                            continue;
+                        for (const claim of predRow.claimedPaths) {
+                            predecessorClaims.add(normalizePathToken(claim));
+                        }
+                    }
+                    const ownClaims = new Set(row.claimedPaths.map(normalizePathToken));
+                    for (const rawClaim of row.claimedPaths) {
+                        const claim = normalizePathToken(rawClaim);
+                        if (claim.length === 0)
+                            continue;
+                        // Only NEW paths (not present at HEAD) require an
+                        // aggregator update — existing modules are already wired.
+                        if (headFiles.size > 0 && headFiles.has(claim))
+                            continue;
+                        const required = stackAdapter.wiringAggregator.resolveAggregatorFor(claim, { headFiles });
+                        if (!required)
+                            continue;
+                        const aggregatorPath = normalizePathToken(required);
+                        if (ownClaims.has(aggregatorPath))
+                            continue;
+                        if (predecessorClaims.has(aggregatorPath))
+                            continue;
+                        wiringIssues.push(`${wave.waveId}/${row.sliceId} introduces ${claim} but wiring aggregator ${aggregatorPath} is not in its claim or any predecessor's claim`);
+                    }
+                }
+            }
+        }
+        const wiringApplies = stackAdapter.wiringAggregator !== undefined;
+        findings.push({
+            section: "plan_module_introducing_slice_wires_root",
+            required: coverageTargetPresent && wiringApplies,
+            rule: "When a slice introduces a new module file, the stack-adapter's wiring aggregator (e.g. Rust `lib.rs`, Python `__init__.py`, Node-TS barrel `index.*` when present) must be in the same slice's claim or in a transitive predecessor's claim, otherwise the new module is dead code and RED can't be expressed.",
+            found: !wiringApplies || wiringIssues.length === 0,
+            details: !wiringApplies
+                ? `Stack adapter (id=${stackAdapter.id}) does not declare a wiring aggregator; gate is a no-op for this stack.`
+                : wiringIssues.length === 0
+                    ? `Stack adapter (id=${stackAdapter.id}) wiring aggregator coverage verified across all wave slices.`
+                    : `Wiring aggregator coverage gaps: ${wiringIssues.slice(0, 12).join(" | ")}${wiringIssues.length > 12 ? ` | … (${wiringIssues.length - 12} more)` : ""}.`
+        });
     }
 }

package/dist/artifact-linter/tdd.js

@@ -6,6 +6,7 @@ import { loadTddReadySlicePool, readDelegationLedger, readDelegationEvents, sele
 import { resolveArtifactPath as resolveStageArtifactPath } from "../artifact-paths.js";
 import { exists } from "../fs-utils.js";
 import { mergeParallelWaveDefinitions, parseParallelExecutionPlanWaves, parseWavePlanDirectory } from "../internal/plan-split-waves.js";
+import { compareSliceIds } from "../util/slice-id.js";
 import { extractAcceptanceCriterionIdsFromMarkdown, extractH2Sections, evaluateInvestigationTrace, sectionBodyByName } from "./shared.js";
 const SLICE_SUMMARY_START = "<!-- auto-start: tdd-slice-summary -->";
 const SLICE_SUMMARY_END = "<!-- auto-end: tdd-slice-summary -->";
@@ -509,7 +510,7 @@ async function listSliceFiles(slicesDir) {
             continue;
         files.push({ sliceId: match[1], absPath: path.join(slicesDir, name) });
     }
-    files.sort((a, b) => (a.sliceId < b.sliceId ? -1 : a.sliceId > b.sliceId ? 1 : 0));
+    files.sort((a, b) => compareSliceIds(a.sliceId, b.sliceId));
     return files;
 }
 function escapeForRegex(value) {
@@ -995,9 +996,9 @@ export async function evaluateWavePlanDispatchIgnored(params) {
         return {
             section: "tdd_wave_plan_ignored",
             required: true,
-            rule: "When the Parallel Execution Plan (or wave-plans/) defines an open wave with two or more ready parallelizable slices, the controller must fan out slice-builder Tasks for each ready slice instead of serializing to one slice only.",
+            rule: "When the Parallel Execution Plan (or wave-plans/) defines an open wave with two or more ready parallelizable units/slices, the controller must honor the parallel-builders topology instead of serializing to one slice only.",
             found: false,
-            details: `Wave ${wave.waveId}: scheduler-ready members ${ready.map((r) => r.sliceId).join(", ")}; last 20 delegation events show slice workers only for ${only}. Missed parallel dispatch: ${missed.join(", ")}. Remediation: load \`05-plan.md\` (Parallel Execution Plan) and \`wave-plans/\` before routing, launch the wave (AskQuestion only when waveCount>=2 and single-slice is a real alternative), then dispatch workers for every ready slice.`
+            details: `Wave ${wave.waveId}: scheduler-ready members ${ready.map((r) => r.sliceId).join(", ")}; last 20 delegation events show slice workers only for ${only}. Missed parallel dispatch: ${missed.join(", ")}. Remediation: load \`05-plan.md\` (Parallel Execution Plan) and \`wave-plans/\` before routing, honor \`nextDispatch.topology=parallel-builders\`, then dispatch the routed ready builders in one controller message.`
         };
     }
     return null;

package/dist/config.d.ts

@@ -1,9 +1,20 @@
-import type { CclawConfig, FlowTrack, HarnessId, LanguageRulePack, TddCommitMode, TddIsolationMode } from "./types.js";
+import type { CclawConfig, ExecutionStrictnessProfile, ExecutionTopology, FlowTrack, HarnessId, LanguageRulePack, LockfileTwinPolicy, PlanMicroTaskPolicy, PlanSliceGranularity, TddCommitMode, TddIsolationMode } from "./types.js";
 export declare const TDD_COMMIT_MODES: readonly ["managed-per-slice", "agent-required", "checkpoint-only", "off"];
 export declare const DEFAULT_TDD_COMMIT_MODE: TddCommitMode;
 export declare const TDD_ISOLATION_MODES: readonly ["worktree", "in-place", "auto"];
 export declare const DEFAULT_TDD_ISOLATION_MODE: TddIsolationMode;
 export declare const DEFAULT_TDD_WORKTREE_ROOT = ".cclaw/worktrees";
+export declare const LOCKFILE_TWIN_POLICIES: readonly ["auto-include", "auto-revert", "strict-fence"];
+export declare const DEFAULT_LOCKFILE_TWIN_POLICY: LockfileTwinPolicy;
+export declare const EXECUTION_TOPOLOGIES: readonly ["auto", "inline", "single-builder", "parallel-builders", "strict-micro"];
+export declare const DEFAULT_EXECUTION_TOPOLOGY: ExecutionTopology;
+export declare const EXECUTION_STRICTNESS_PROFILES: readonly ["fast", "balanced", "strict"];
+export declare const DEFAULT_EXECUTION_STRICTNESS: ExecutionStrictnessProfile;
+export declare const DEFAULT_MAX_BUILDERS = 5;
+export declare const PLAN_SLICE_GRANULARITIES: readonly ["feature-atomic", "strict-micro"];
+export declare const DEFAULT_PLAN_SLICE_GRANULARITY: PlanSliceGranularity;
+export declare const PLAN_MICRO_TASK_POLICIES: readonly ["advisory", "strict"];
+export declare const DEFAULT_PLAN_MICRO_TASK_POLICY: PlanMicroTaskPolicy;
 export declare const DEFAULT_TDD_TEST_PATH_PATTERNS: readonly string[];
 export declare const DEFAULT_TDD_TEST_GLOBS: readonly string[];
 export declare const DEFAULT_TDD_PRODUCTION_PATH_PATTERNS: readonly string[];
@@ -24,6 +35,12 @@ export declare function createDefaultConfig(harnesses?: HarnessId[], _defaultTra
 export declare function resolveTddCommitMode(config: Pick<CclawConfig, "tdd"> | null | undefined): TddCommitMode;
 export declare function resolveTddIsolationMode(config: Pick<CclawConfig, "tdd"> | null | undefined): TddIsolationMode;
 export declare function resolveTddWorktreeRoot(config: Pick<CclawConfig, "tdd"> | null | undefined): string;
+export declare function resolveLockfileTwinPolicy(config: Pick<CclawConfig, "tdd"> | null | undefined): LockfileTwinPolicy;
+export declare function resolveExecutionTopology(config: Pick<CclawConfig, "execution"> | null | undefined): ExecutionTopology;
+export declare function resolveExecutionStrictness(config: Pick<CclawConfig, "execution"> | null | undefined): ExecutionStrictnessProfile;
+export declare function resolveMaxBuilders(config: Pick<CclawConfig, "execution"> | null | undefined): number;
+export declare function resolvePlanSliceGranularity(config: Pick<CclawConfig, "plan"> | null | undefined): PlanSliceGranularity;
+export declare function resolvePlanMicroTaskPolicy(config: Pick<CclawConfig, "plan"> | null | undefined): PlanMicroTaskPolicy;
 export declare function detectLanguageRulePacks(_projectRoot: string): Promise<LanguageRulePack[]>;
 export declare function readConfig(projectRoot: string, _options?: ReadConfigOptions): Promise<CclawConfig>;
 export interface WriteConfigOptions {