cclaw-cli 7.6.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,15 +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",
@@ -36,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)) {
@@ -116,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;
@@ -124,10 +137,12 @@ function parseParallelWaveTableMetadata(planMarkdown) {
         if (cells.every((cell) => /^:?-{3,}:?$/u.test(cell))) {
             continue;
         }
-        const sliceCell = cells[0];
+        const sliceCell = cells[0].replace(/^`|`$/gu, "").trim();
         const parsedSlice = parseSliceId(sliceCell);
-        if (!parsedSlice)
+        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");
@@ -158,7 +173,7 @@ function parseParallelWaveTableMetadata(planMarkdown) {
                 .map((token) => parseSliceId(token)?.id ?? "")
                 .filter((id) => id.length > 0);
         current.rows.push({
-            sliceId: parsedSlice.id,
+            sliceId,
             unit: (cells[unitIdx] ?? "").trim(),
             claimedPaths,
             parallelizable,
@@ -234,6 +249,11 @@ function transitivePredecessors(sliceId, graph) {
 }
 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") ||
@@ -500,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;
@@ -573,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") ?? "") +
@@ -581,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 = [];
@@ -623,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
@@ -740,7 +813,7 @@ export async function lintPlanStage(ctx) {
         const wiringApplies = stackAdapter.wiringAggregator !== undefined;
         findings.push({
             section: "plan_module_introducing_slice_wires_root",
-            required: taskListPresent && wiringApplies,
+            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

package/dist/artifact-linter/tdd.js

@@ -996,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,4 +1,4 @@
-import type { CclawConfig, FlowTrack, HarnessId, LanguageRulePack, LockfileTwinPolicy, 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"];
@@ -6,6 +6,15 @@ 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[];
@@ -27,6 +36,11 @@ export declare function resolveTddCommitMode(config: Pick<CclawConfig, "tdd"> |
 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 {

package/dist/config.js

@@ -6,7 +6,14 @@ import { exists, writeFileSafe } from "./fs-utils.js";
 import { HARNESS_IDS } from "./types.js";
 const CONFIG_PATH = `${RUNTIME_ROOT}/config.yaml`;
 const HARNESS_ID_SET = new Set(HARNESS_IDS);
-const ALLOWED_CONFIG_KEYS = new Set(["version", "flowVersion", "harnesses", "tdd"]);
+const ALLOWED_CONFIG_KEYS = new Set([
+    "version",
+    "flowVersion",
+    "harnesses",
+    "tdd",
+    "execution",
+    "plan"
+]);
 const SUPPORTED_HARNESSES_TEXT = HARNESS_IDS.join(", ");
 export const TDD_COMMIT_MODES = [
     "managed-per-slice",
@@ -23,6 +30,25 @@ export const DEFAULT_TDD_WORKTREE_ROOT = `${RUNTIME_ROOT}/worktrees`;
 export const LOCKFILE_TWIN_POLICIES = ["auto-include", "auto-revert", "strict-fence"];
 const LOCKFILE_TWIN_POLICY_SET = new Set(LOCKFILE_TWIN_POLICIES);
 export const DEFAULT_LOCKFILE_TWIN_POLICY = "auto-include";
+export const EXECUTION_TOPOLOGIES = [
+    "auto",
+    "inline",
+    "single-builder",
+    "parallel-builders",
+    "strict-micro"
+];
+const EXECUTION_TOPOLOGY_SET = new Set(EXECUTION_TOPOLOGIES);
+export const DEFAULT_EXECUTION_TOPOLOGY = "auto";
+export const EXECUTION_STRICTNESS_PROFILES = ["fast", "balanced", "strict"];
+const EXECUTION_STRICTNESS_PROFILE_SET = new Set(EXECUTION_STRICTNESS_PROFILES);
+export const DEFAULT_EXECUTION_STRICTNESS = "balanced";
+export const DEFAULT_MAX_BUILDERS = 5;
+export const PLAN_SLICE_GRANULARITIES = ["feature-atomic", "strict-micro"];
+const PLAN_SLICE_GRANULARITY_SET = new Set(PLAN_SLICE_GRANULARITIES);
+export const DEFAULT_PLAN_SLICE_GRANULARITY = "feature-atomic";
+export const PLAN_MICRO_TASK_POLICIES = ["advisory", "strict"];
+const PLAN_MICRO_TASK_POLICY_SET = new Set(PLAN_MICRO_TASK_POLICIES);
+export const DEFAULT_PLAN_MICRO_TASK_POLICY = "advisory";
 // Kept for runtime modules that use these defaults directly.
 export const DEFAULT_TDD_TEST_PATH_PATTERNS = [
     "**/*.test.*",
@@ -49,7 +75,14 @@ function configFixExample() {
 tdd:
   commitMode: managed-per-slice
   isolationMode: worktree
-  worktreeRoot: .cclaw/worktrees`;
+  worktreeRoot: .cclaw/worktrees
+execution:
+  topology: auto
+  strictness: balanced
+  maxBuilders: 5
+plan:
+  sliceGranularity: feature-atomic
+  microTaskPolicy: advisory`;
 }
 function configValidationError(configFilePath, reason) {
     return new InvalidConfigError(`Invalid cclaw config at ${configFilePath}: ${reason}\n` +
@@ -73,6 +106,15 @@ export function createDefaultConfig(harnesses = DEFAULT_HARNESSES, _defaultTrack
             isolationMode: DEFAULT_TDD_ISOLATION_MODE,
             worktreeRoot: DEFAULT_TDD_WORKTREE_ROOT,
             lockfileTwinPolicy: DEFAULT_LOCKFILE_TWIN_POLICY
+        },
+        execution: {
+            topology: DEFAULT_EXECUTION_TOPOLOGY,
+            strictness: DEFAULT_EXECUTION_STRICTNESS,
+            maxBuilders: DEFAULT_MAX_BUILDERS
+        },
+        plan: {
+            sliceGranularity: DEFAULT_PLAN_SLICE_GRANULARITY,
+            microTaskPolicy: DEFAULT_PLAN_MICRO_TASK_POLICY
         }
     };
 }
@@ -104,6 +146,41 @@ export function resolveLockfileTwinPolicy(config) {
     }
     return DEFAULT_LOCKFILE_TWIN_POLICY;
 }
+export function resolveExecutionTopology(config) {
+    const raw = config?.execution?.topology;
+    if (typeof raw === "string" && EXECUTION_TOPOLOGY_SET.has(raw)) {
+        return raw;
+    }
+    return DEFAULT_EXECUTION_TOPOLOGY;
+}
+export function resolveExecutionStrictness(config) {
+    const raw = config?.execution?.strictness;
+    if (typeof raw === "string" && EXECUTION_STRICTNESS_PROFILE_SET.has(raw)) {
+        return raw;
+    }
+    return DEFAULT_EXECUTION_STRICTNESS;
+}
+export function resolveMaxBuilders(config) {
+    const raw = config?.execution?.maxBuilders;
+    if (typeof raw === "number" && Number.isInteger(raw) && raw >= 1) {
+        return raw;
+    }
+    return DEFAULT_MAX_BUILDERS;
+}
+export function resolvePlanSliceGranularity(config) {
+    const raw = config?.plan?.sliceGranularity;
+    if (typeof raw === "string" && PLAN_SLICE_GRANULARITY_SET.has(raw)) {
+        return raw;
+    }
+    return DEFAULT_PLAN_SLICE_GRANULARITY;
+}
+export function resolvePlanMicroTaskPolicy(config) {
+    const raw = config?.plan?.microTaskPolicy;
+    if (typeof raw === "string" && PLAN_MICRO_TASK_POLICY_SET.has(raw)) {
+        return raw;
+    }
+    return DEFAULT_PLAN_MICRO_TASK_POLICY;
+}
 function assertOnlySupportedKeys(parsed, fullPath) {
     const unknownKeys = Object.keys(parsed).filter((key) => !ALLOWED_CONFIG_KEYS.has(key));
     if (unknownKeys.length === 0)
@@ -141,6 +218,14 @@ export async function readConfig(projectRoot, _options = {}) {
         !isRecord(parsed.tdd)) {
         throw configValidationError(fullPath, `"tdd" must be an object when provided`);
     }
+    if (Object.prototype.hasOwnProperty.call(parsed, "execution") &&
+        !isRecord(parsed.execution)) {
+        throw configValidationError(fullPath, `"execution" must be an object when provided`);
+    }
+    if (Object.prototype.hasOwnProperty.call(parsed, "plan") &&
+        !isRecord(parsed.plan)) {
+        throw configValidationError(fullPath, `"plan" must be an object when provided`);
+    }
     const rawHarnesses = Array.isArray(parsed.harnesses) ? parsed.harnesses : DEFAULT_HARNESSES;
     const normalizedHarnesses = [];
     for (const harness of rawHarnesses) {
@@ -165,6 +250,13 @@ export async function readConfig(projectRoot, _options = {}) {
     const rawIsolationMode = parsedTdd.isolationMode;
     const rawWorktreeRoot = parsedTdd.worktreeRoot;
     const rawLockfileTwinPolicy = parsedTdd.lockfileTwinPolicy;
+    const parsedExecution = isRecord(parsed.execution) ? parsed.execution : {};
+    const rawExecutionTopology = parsedExecution.topology;
+    const rawExecutionStrictness = parsedExecution.strictness;
+    const rawMaxBuilders = parsedExecution.maxBuilders;
+    const parsedPlan = isRecord(parsed.plan) ? parsed.plan : {};
+    const rawPlanSliceGranularity = parsedPlan.sliceGranularity;
+    const rawPlanMicroTaskPolicy = parsedPlan.microTaskPolicy;
     if (rawCommitMode !== undefined &&
         (typeof rawCommitMode !== "string" || !TDD_COMMIT_MODE_SET.has(rawCommitMode))) {
         throw configValidationError(fullPath, `"tdd.commitMode" must be one of: ${TDD_COMMIT_MODES.join(", ")}`);
@@ -181,6 +273,29 @@ export async function readConfig(projectRoot, _options = {}) {
         (typeof rawLockfileTwinPolicy !== "string" || !LOCKFILE_TWIN_POLICY_SET.has(rawLockfileTwinPolicy))) {
         throw configValidationError(fullPath, `"tdd.lockfileTwinPolicy" must be one of: ${LOCKFILE_TWIN_POLICIES.join(", ")}`);
     }
+    if (rawExecutionTopology !== undefined &&
+        (typeof rawExecutionTopology !== "string" || !EXECUTION_TOPOLOGY_SET.has(rawExecutionTopology))) {
+        throw configValidationError(fullPath, `"execution.topology" must be one of: ${EXECUTION_TOPOLOGIES.join(", ")}`);
+    }
+    if (rawExecutionStrictness !== undefined &&
+        (typeof rawExecutionStrictness !== "string" ||
+            !EXECUTION_STRICTNESS_PROFILE_SET.has(rawExecutionStrictness))) {
+        throw configValidationError(fullPath, `"execution.strictness" must be one of: ${EXECUTION_STRICTNESS_PROFILES.join(", ")}`);
+    }
+    if (rawMaxBuilders !== undefined &&
+        (!Number.isInteger(rawMaxBuilders) || rawMaxBuilders < 1)) {
+        throw configValidationError(fullPath, `"execution.maxBuilders" must be an integer >= 1 when provided`);
+    }
+    if (rawPlanSliceGranularity !== undefined &&
+        (typeof rawPlanSliceGranularity !== "string" ||
+            !PLAN_SLICE_GRANULARITY_SET.has(rawPlanSliceGranularity))) {
+        throw configValidationError(fullPath, `"plan.sliceGranularity" must be one of: ${PLAN_SLICE_GRANULARITIES.join(", ")}`);
+    }
+    if (rawPlanMicroTaskPolicy !== undefined &&
+        (typeof rawPlanMicroTaskPolicy !== "string" ||
+            !PLAN_MICRO_TASK_POLICY_SET.has(rawPlanMicroTaskPolicy))) {
+        throw configValidationError(fullPath, `"plan.microTaskPolicy" must be one of: ${PLAN_MICRO_TASK_POLICIES.join(", ")}`);
+    }
     const commitMode = typeof rawCommitMode === "string"
         ? rawCommitMode
         : DEFAULT_TDD_COMMIT_MODE;
@@ -193,6 +308,23 @@ export async function readConfig(projectRoot, _options = {}) {
     const lockfileTwinPolicy = typeof rawLockfileTwinPolicy === "string"
         ? rawLockfileTwinPolicy
         : DEFAULT_LOCKFILE_TWIN_POLICY;
+    const executionTopology = typeof rawExecutionTopology === "string"
+        ? rawExecutionTopology
+        : DEFAULT_EXECUTION_TOPOLOGY;
+    const executionStrictness = typeof rawExecutionStrictness === "string"
+        ? rawExecutionStrictness
+        : DEFAULT_EXECUTION_STRICTNESS;
+    const maxBuilders = typeof rawMaxBuilders === "number" &&
+        Number.isInteger(rawMaxBuilders) &&
+        rawMaxBuilders >= 1
+        ? rawMaxBuilders
+        : DEFAULT_MAX_BUILDERS;
+    const planSliceGranularity = typeof rawPlanSliceGranularity === "string"
+        ? rawPlanSliceGranularity
+        : DEFAULT_PLAN_SLICE_GRANULARITY;
+    const planMicroTaskPolicy = typeof rawPlanMicroTaskPolicy === "string"
+        ? rawPlanMicroTaskPolicy
+        : DEFAULT_PLAN_MICRO_TASK_POLICY;
     return {
         version,
         flowVersion,
@@ -202,6 +334,15 @@ export async function readConfig(projectRoot, _options = {}) {
             isolationMode,
             worktreeRoot,
             lockfileTwinPolicy
+        },
+        execution: {
+            topology: executionTopology,
+            strictness: executionStrictness,
+            maxBuilders
+        },
+        plan: {
+            sliceGranularity: planSliceGranularity,
+            microTaskPolicy: planMicroTaskPolicy
         }
     };
 }
@@ -215,6 +356,15 @@ export async function writeConfig(projectRoot, config, _options = {}) {
             isolationMode: resolveTddIsolationMode(config),
             worktreeRoot: resolveTddWorktreeRoot(config),
             lockfileTwinPolicy: resolveLockfileTwinPolicy(config)
+        },
+        execution: {
+            topology: resolveExecutionTopology(config),
+            strictness: resolveExecutionStrictness(config),
+            maxBuilders: resolveMaxBuilders(config)
+        },
+        plan: {
+            sliceGranularity: resolvePlanSliceGranularity(config),
+            microTaskPolicy: resolvePlanMicroTaskPolicy(config)
         }
     };
     await writeFileSafe(configPath(projectRoot), stringify(serialisable));

package/dist/content/core-agents.d.ts

@@ -196,7 +196,7 @@ export declare const CCLAW_AGENTS: readonly [{
     readonly body: string;
 }, {
     readonly name: "slice-builder";
-    readonly description: "MANDATORY for every TDD slice. Owns RED → GREEN → REFACTOR → per-slice DOC for one bounded vertical slice in a single delegated span. Multiple slice-builder spans run in parallel inside one wave when their `claimedPaths` are disjoint.";
+    readonly description: "MANDATORY for delegated TDD slices. Owns RED → GREEN → REFACTOR → per-slice DOC for one feature-atomic implementation unit/slice in a single delegated span. Multiple slice-builder spans run in parallel only under `parallel-builders` topology with disjoint `claimedPaths`; `strict-micro` keeps tiny tasks separate.";
     readonly tools: ["Read", "Write", "Edit", "Grep", "Glob", "Bash"];
     readonly model: "balanced";
     readonly activation: "mandatory";

package/dist/content/core-agents.js

@@ -151,7 +151,7 @@ export function sliceBuilderProtocol() {
     return [
         "## slice-builder protocol",
         "",
-        "**slice-builder** is the canonical worker for **one bounded vertical slice** end-to-end: **RED → GREEN → REFACTOR → inline DOC** in **one** delegated span. Multiple slice-builder spans run in parallel under a single wave when the wave plan declares disjoint `claimedPaths`.",
+        "**slice-builder** is the canonical worker for **one feature-atomic implementation unit/slice** end-to-end: **RED → GREEN → REFACTOR → inline DOC** in **one** delegated span. The unit may contain internal 2-5 minute TDD steps; do not split those into separate agents unless the parent selected `strict-micro`. Multiple slice-builder spans run in parallel only when topology is `parallel-builders` and the wave plan declares disjoint `claimedPaths`.",
         "",
         "### Invariants",
         "- Produce failing RED evidence (or cite the delegated RED artifact) **before** production edits.",
@@ -589,7 +589,7 @@ export const CCLAW_AGENTS = [
     },
     {
         name: "slice-builder",
-        description: "MANDATORY for every TDD slice. Owns RED → GREEN → REFACTOR → per-slice DOC for one bounded vertical slice in a single delegated span. Multiple slice-builder spans run in parallel inside one wave when their `claimedPaths` are disjoint.",
+        description: "MANDATORY for delegated TDD slices. Owns RED → GREEN → REFACTOR → per-slice DOC for one feature-atomic implementation unit/slice in a single delegated span. Multiple slice-builder spans run in parallel only under `parallel-builders` topology with disjoint `claimedPaths`; `strict-micro` keeps tiny tasks separate.",
         tools: ["Read", "Write", "Edit", "Grep", "Glob", "Bash"],
         model: "balanced",
         activation: "mandatory",

package/dist/content/meta-skill.js

@@ -57,14 +57,14 @@ If you think any of these, stop and follow the routing flow:
 - "I can answer from memory without loading the active stage skill." -> No. Load the skill first.
 - "Hook guard warned, but I can ignore it." -> No. Resolve the warning before continuing.
 - "I'll edit \`.cclaw/state\` directly to move faster." -> No. Use managed commands only.
-- "I'll just do the worker's job inline so we move faster." -> No. See the Controller dispatch discipline below.
+- "I'll just do the worker's job inline so we move faster." -> Only if the active TDD topology is explicitly \`inline\`; otherwise see the Controller dispatch discipline below.
 
 ## Controller dispatch discipline (applies to every stage)
 
-cclaw stages have **mandatory delegations** (TDD: \`slice-builder\`; review: \`reviewer\` + \`security-reviewer\`; design: \`architect\`; scope: \`planner\`; etc.). The controller is the **orchestrator**, not the worker. When a stage declares a mandatory delegation:
+cclaw stages have **mandatory delegations** (TDD normally routes through \`slice-builder\`; review: \`reviewer\` + \`security-reviewer\`; design: \`architect\`; scope: \`planner\`; etc.). The controller is the **orchestrator**, not the worker, except when TDD topology is explicitly \`inline\` for a low-risk unit. When a stage declares a mandatory delegation:
 
-- **Dispatch via the harness Task tool.** Do NOT write the worker's output (slice code, review findings, architect notes) into the artifact yourself as a substitute for delegating. Editing \`06-tdd.md\` slice cards, \`07-review.md\` findings, or any other "result of mandatory worker" content inline in the controller chat is a protocol violation.
-- **Parallel by default when paths/lenses are independent.** TDD wave-fanout (disjoint \`claimedPaths\`) and review-army (independent reviewer lenses) MUST emit all parallel \`Task\` calls in a SINGLE controller message — not sequentially over multiple turns. The controller waits for all spans to return before reconciling.
+- **Dispatch via the harness Task tool unless topology says inline.** Do NOT write the worker's output (slice code, review findings, architect notes) into the artifact yourself as a substitute for delegating. For TDD \`inline\`, record the routing reason and satisfy the same RED/GREEN/REFACTOR, AC traceability, path containment, managed commit/worktree, lockfile twin, and orphan-change gates.
+- **Parallel only when topology says parallel-builders.** TDD fan-out requires genuinely independent substantial units with disjoint \`claimedPaths\`; review-army (independent reviewer lenses) MUST emit all parallel \`Task\` calls in a SINGLE controller message — not sequentially over multiple turns. The controller waits for all spans to return before reconciling.
 - **Record lifecycle on the same span** via \`delegation-record --status=scheduled|launched|acknowledged|completed\`; the worker emits its own \`--phase=…\` and evidence rows. A \`completed\` row without a matching ACK or dispatch surface is a forgery.
 - **Auto-advance when stage-complete returns ok.** When the helper reports a new \`currentStage\`, immediately load the next stage skill and continue. Announce \`Stage <prev> complete → entering <next>. Continuing.\` Do NOT pause for the user to retype \`/cc\` or say \"продолжай\" — that pause is the failure mode 7.0.2 explicitly removed. The only legitimate stop is a real blocker (missing user input, ambiguous decision, hook fail).
 

package/dist/content/skills.js

@@ -183,22 +183,24 @@ export function tddTopOfSkillBlock(stage) {
         return "";
     return `## TDD orchestration primer
 
-**MANDATE — controller never implements.** In TDD the controller plans, dispatches, and reconciles. **NEVER edit production code, tests, or run cargo/npm/pytest yourself in the controller chat.** Every slice's RED → GREEN → REFACTOR → DOC cycle MUST happen inside an isolated \`slice-builder\` span dispatched via the harness Task tool. Inline code edits in the controller chat are a protocol violation that defeats parallelism, evidence isolation, and the audit ledger.
+**MANDATE — controller preserves TDD evidence.** In TDD the controller routes, dispatches when needed, and reconciles. Default topology is \`auto\` + \`balanced\`: feature-atomic units contain internal 2-5 minute RED/GREEN/REFACTOR steps. Inline execution is allowed only when \`wave-status\`/the plan selects \`inline\`; it still must satisfy RED-before-GREEN, AC traceability, path containment, verification, managed commit/worktree, lockfile twin, and orphan-change gates. \`single-builder\` and \`parallel-builders\` use \`slice-builder\`; \`strict-micro\` preserves one tiny task per schedulable slice for high-risk work.
 
 **Step 1 — Wave status (always first):**
 \`node .cclaw/cli.mjs internal wave-status --json\`
 
-The output names: \`waves[]\` (closed/open), \`nextDispatch.waveId\`, \`nextDispatch.mode\` (\`wave-fanout\`, \`single-slice\`, or \`blocked\`), \`nextDispatch.readyToDispatch\` (slice ids), and \`nextDispatch.pathConflicts\` (overlapping \`claimedPaths\` between members).
+The output names: \`waves[]\` (closed/open), \`nextDispatch.waveId\`, \`nextDispatch.mode\` (\`wave-fanout\`, \`single-slice\`, or \`blocked\`), \`nextDispatch.topology\` (\`inline\`, \`single-builder\`, \`parallel-builders\`, or \`strict-micro\`), \`nextDispatch.readyToDispatch\` (slice ids), and \`nextDispatch.pathConflicts\` (overlapping \`claimedPaths\` between members).
 
 **Step 2 — Decide automatically (no user question when paths disjoint):**
 
-| \`mode\`         | \`pathConflicts\` | Action                                                                                                                                  |
-|------------------|-------------------|-----------------------------------------------------------------------------------------------------------------------------------------|
-| \`wave-fanout\`  | \`[]\`            | **Fan out the entire wave in one tool batch.** Emit one \`Task\` per ready slice in a single controller message. Do NOT ask the user.   |
-| \`blocked\`      | non-empty         | Issue exactly one AskQuestion (resolve overlap, split/serialize, or adjust claimedPaths), then re-run \`wave-status\`.                    |
-| \`single-slice\` | —                 | One \`Task\` for the next ready slice.                                                                                                  |
+| \`topology\`              | \`pathConflicts\` | Action                                                                                                                                     |
+|---------------------------|-------------------|--------------------------------------------------------------------------------------------------------------------------------------------|
+| \`parallel-builders\`     | \`[]\`            | **Fan out independent substantial units in one tool batch.** Emit one \`Task\` per routed ready builder in a single controller message. Do NOT ask. |
+| \`single-builder\`        | any/none          | Dispatch one \`slice-builder\` for the next feature-atomic unit; serialize remaining ready units.                                          |
+| \`inline\`                | \`[]\`            | Execute inline only for low-risk inline-safe units; record equivalent RED/GREEN/REFACTOR evidence before completion.                       |
+| \`strict-micro\`          | any/none          | Preserve micro-slice sequencing: one tiny task/slice at a time unless the strict plan explicitly proves safe fan-out.                      |
+| \`blocked\`/mode blocked  | non-empty         | Issue exactly one AskQuestion (resolve overlap, split/serialize, or adjust claimedPaths), then re-run \`wave-status\`.                     |
 
-**Step 3 — Dispatch protocol per slice:** in the SAME controller message that issues the \`Task\` call:
+**Step 3 — Dispatch protocol per delegated slice:** for \`single-builder\`, \`parallel-builders\`, and delegated \`strict-micro\`, in the SAME controller message that issues the \`Task\` call:
 
 1. Append \`delegation-record --status=scheduled\` for the \`slice-builder\` span (one row per slice; reuse the same \`spanId\` across the entire RED → GREEN → REFACTOR → DOC lifecycle).
 2. Append \`delegation-record --status=launched\` immediately after.
@@ -206,6 +208,8 @@ The output names: \`waves[]\` (closed/open), \`nextDispatch.waveId\`, \`nextDisp
 4. The slice-builder span ACKs locally (\`delegation-record --status=acknowledged\`) and runs the **complete** RED → GREEN → REFACTOR → DOC cycle inside the span — including writing \`tdd-slices/S-<id>.md\` and emitting \`--phase=red\`, \`--phase=green\`, \`--phase=refactor\` (or \`--phase=refactor-deferred\` with rationale), and \`--phase=doc\` rows on its own.
 5. The controller waits for ALL parallel spans to terminate before reconciling. Do not page back into the controller chat between spans.
 
+For \`inline\`, skip the Task call but do not skip evidence: write the same per-slice card/evidence refs, run RED before GREEN, verify before completion, and keep all path/commit/worktree gates satisfied.
+
 **Step 4 — Wave closeout:** after all in-flight slices report \`completed\`:
 
 1. Re-run \`wave-status --json\`. Confirm the wave is \`closed\` and the next dispatch is the following wave (or \`closeout\`).

package/dist/content/stage-schema.js

@@ -678,8 +678,8 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
             agent: "slice-builder",
             mode: "mandatory",
             requiredAtTier: "lightweight",
-            when: "Always during the TDD cycle. Controller MUST NOT write tests or production code itself.",
-            purpose: "Own one bounded vertical slice end-to-end: RED → GREEN → REFACTOR → per-slice DOC in a single delegated span. Multiple slice-builder spans run in parallel inside one wave when their `claimedPaths` are disjoint. Linter rules `tdd_slice_builder_missing` and `tdd_slice_doc_missing` block unauthorized GREEN authors and missing per-slice prose.",
+            when: "During delegated TDD topologies (`single-builder`, `parallel-builders`, `strict-micro`). Inline topology may skip the dispatch only when the same RED/GREEN/REFACTOR evidence gates are preserved.",
+            purpose: "Own one feature-atomic implementation unit/slice end-to-end: RED → GREEN → REFACTOR → per-slice DOC in a single delegated span. Multiple slice-builder spans run in parallel only under `parallel-builders` topology with disjoint `claimedPaths`. Linter rules `tdd_slice_builder_missing` and `tdd_slice_doc_missing` block unauthorized GREEN authors and missing per-slice prose unless inline topology is explicitly recorded.",
             requiresUserGate: false,
             skill: "tdd-cycle-evidence"
         },