cclaw-cli 7.6.0 → 7.7.1

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;
@@ -12,11 +13,25 @@ export interface WaveStatusWaveSummary {
     blockedMembers: string[];
     status: "closed" | "open" | "partial" | "empty";
 }
+/**
+ * 7.7.1 — `controller-inline` is added so the controller knows it must
+ * fulfil the ready slices in this turn (no slice-builder dispatch). The
+ * remaining values (`single-slice`, `wave-fanout`, `blocked`, `none`) keep
+ * their pre-7.7.1 contract.
+ */
 export interface WaveStatusNextDispatch {
     waveId: string | null;
     readyToDispatch: string[];
     pathConflicts: string[];
-    mode: "single-slice" | "wave-fanout" | "blocked" | "none";
+    mode: "single-slice" | "wave-fanout" | "blocked" | "none" | "controller-inline";
+    topology: Exclude<ExecutionTopology, "auto"> | "none";
+    topologyReason: string;
+    maxBuilders: number;
+    /**
+     * Optional natural-language hint for the controller, populated when the
+     * router selects a non-default mode (currently only `inline`).
+     */
+    controllerHint?: string;
 }
 export interface WaveStatusReport {
     activeRunId: string;

package/dist/internal/wave-status.js

@@ -4,6 +4,8 @@ import { RUNTIME_ROOT } from "../constants.js";
 import { readDelegationEvents, readDelegationLedger } from "../delegation.js";
 import { readFlowState } from "../runs.js";
 import { DEFAULT_SLICE_STREAM_REL_PATH, readEventStreamFile } from "../streaming/event-stream.js";
+import { readConfig, resolveExecutionStrictness, resolveExecutionTopology, resolveMaxBuilders } from "../config.js";
+import { routeExecutionTopology } from "../execution-topology.js";
 import { mergeParallelWaveDefinitions, parseParallelExecutionPlanWaves, parseWavePlanDirectory } from "./plan-split-waves.js";
 import { compareSliceIds, parseSliceId } from "../util/slice-id.js";
 const PARALLEL_EXEC_MANAGED_START = "<!-- parallel-exec-managed-start -->";
@@ -55,7 +57,7 @@ function parsePipeRow(trimmedLine) {
 function normalizePathToken(raw) {
     return raw.trim().replace(/^`|`$/gu, "").replace(/^\.\/+/u, "");
 }
-function parseManagedWaveClaimedPaths(planMarkdown) {
+function parseManagedWaveSliceMeta(planMarkdown) {
     const out = new Map();
     const startIdx = planMarkdown.indexOf(PARALLEL_EXEC_MANAGED_START);
     const endIdx = planMarkdown.indexOf(PARALLEL_EXEC_MANAGED_END);
@@ -82,7 +84,11 @@ function parseManagedWaveClaimedPaths(planMarkdown) {
         if (cells.length === 0)
             continue;
         const first = cells[0].toLowerCase();
-        if (first === "sliceid" || first === "slice id") {
+        if (first === "sliceid" ||
+            first === "slice id" ||
+            first === "unitid" ||
+            first === "unit id" ||
+            first === "unit") {
             headerIdx = new Map();
             for (let i = 0; i < cells.length; i += 1) {
                 const key = cells[i].toLowerCase().replace(/[^a-z0-9]/gu, "");
@@ -95,10 +101,12 @@ function parseManagedWaveClaimedPaths(planMarkdown) {
         if (cells.every((cell) => /^:?-{3,}:?$/u.test(cell))) {
             continue;
         }
-        const parsedSlice = parseSliceId(cells[0]);
-        if (!parsedSlice)
+        const firstCell = (cells[0] ?? "").replace(/^`|`$/gu, "").trim();
+        const parsedSlice = parseSliceId(firstCell);
+        const parsedUnit = /^U-(\d+(?:[a-z][a-z0-9]*)?)$/iu.exec(firstCell);
+        if (!parsedSlice && !parsedUnit)
             continue;
-        const sliceId = parsedSlice.id;
+        const sliceId = parsedSlice?.id ?? `S-${parsedUnit[1].toLowerCase()}`;
         const pathsIdx = headerIdx.get("claimedpaths");
         const rawPaths = pathsIdx !== undefined ? (cells[pathsIdx] ?? "") : "";
         const claimedPaths = rawPaths.length === 0
@@ -107,10 +115,52 @@ function parseManagedWaveClaimedPaths(planMarkdown) {
                 .split(",")
                 .map((p) => normalizePathToken(p))
                 .filter((p) => p.length > 0);
-        out.get(currentWaveId).set(sliceId, claimedPaths);
+        const laneIdx = headerIdx.get("lane");
+        const rawLane = laneIdx !== undefined ? (cells[laneIdx] ?? "") : "";
+        const lane = rawLane.replace(/^`|`$/gu, "").trim().toLowerCase();
+        const riskIdx = headerIdx.get("risktier");
+        const rawRisk = riskIdx !== undefined ? (cells[riskIdx] ?? "") : "";
+        const riskTier = rawRisk.replace(/^`|`$/gu, "").trim().toLowerCase();
+        out.get(currentWaveId).set(sliceId, {
+            claimedPaths,
+            lane: lane.length > 0 ? lane : undefined,
+            riskTier: riskTier.length > 0 ? riskTier : undefined
+        });
     }
     return out;
 }
+/**
+ * Backward-compatible projection: callers that only need claimed paths
+ * keep getting `Map<sliceId, paths[]>` shapes.
+ */
+function projectClaimedPaths(meta) {
+    const out = new Map();
+    for (const [sliceId, info] of meta) {
+        out.set(sliceId, info.claimedPaths);
+    }
+    return out;
+}
+const DISCOVERY_LANES = new Set(["scaffold", "docs"]);
+/**
+ * 7.7.1 — count ready members whose lane is `scaffold` or `docs` and whose
+ * `riskTier` is not `high`. Members with no recorded lane fall back to
+ * non-discovery (so the controller never collapses substantive work into
+ * inline by accident).
+ */
+function countDiscoveryOnlyUnits(readySlices, meta) {
+    let count = 0;
+    for (const sliceId of readySlices) {
+        const info = meta.get(sliceId);
+        if (!info)
+            continue;
+        if (!info.lane || !DISCOVERY_LANES.has(info.lane))
+            continue;
+        if (info.riskTier === "high")
+            continue;
+        count += 1;
+    }
+    return count;
+}
 function detectPathConflicts(readySlices, bySlice) {
     const conflicts = new Set();
     const ordered = [...readySlices].sort(compareSliceIds);
@@ -175,7 +225,10 @@ export async function runWaveStatus(projectRoot, options = {}) {
                 waveId: null,
                 readyToDispatch: [],
                 pathConflicts: [],
-                mode: "none"
+                mode: "none",
+                topology: "none",
+                topologyReason: "wave plan could not be parsed",
+                maxBuilders: 0
             },
             warnings: [
                 `wave_plan_parse_error: ${err instanceof Error ? err.message : String(err)}`
@@ -203,7 +256,10 @@ export async function runWaveStatus(projectRoot, options = {}) {
                 waveId: null,
                 readyToDispatch: [],
                 pathConflicts: [],
-                mode: "none"
+                mode: "none",
+                topology: "none",
+                topologyReason: "wave plan sources conflict",
+                maxBuilders: 0
             },
             warnings: [
                 `wave_plan_merge_conflict: ${err instanceof Error ? err.message : String(err)}`
@@ -331,30 +387,68 @@ export async function runWaveStatus(projectRoot, options = {}) {
         warnings.push("wave_plan_managed_block_missing: <!-- parallel-exec-managed-start --> block not found in 05-plan.md and wave-plans/ has no parseable wave files.");
     }
     let nextDispatch;
+    const config = await readConfig(projectRoot).catch(() => null);
+    const configuredTopology = resolveExecutionTopology(config);
+    const strictness = resolveExecutionStrictness(config);
+    const maxBuilders = resolveMaxBuilders(config);
     if (firstOpenWave === null) {
         nextDispatch = {
             waveId: null,
             readyToDispatch: [],
             pathConflicts: [],
-            mode: "none"
+            mode: "none",
+            topology: "none",
+            topologyReason: "no open wave has ready units",
+            maxBuilders
         };
     }
     else {
         const readyToDispatch = [...firstOpenWave.readyMembers].sort(compareSliceIds);
-        const claimedPathsByWave = parseManagedWaveClaimedPaths(planRaw);
-        const conflicts = detectPathConflicts(readyToDispatch, claimedPathsByWave.get(firstOpenWave.waveId) ?? new Map());
-        const mode = conflicts.length > 0
+        const sliceMetaByWave = parseManagedWaveSliceMeta(planRaw);
+        const sliceMeta = sliceMetaByWave.get(firstOpenWave.waveId) ?? new Map();
+        const conflicts = detectPathConflicts(readyToDispatch, projectClaimedPaths(sliceMeta));
+        const discoveryOnlyUnits = countDiscoveryOnlyUnits(readyToDispatch, sliceMeta);
+        const baseMode = conflicts.length > 0
             ? "blocked"
             : readyToDispatch.length > 1
                 ? "wave-fanout"
                 : readyToDispatch.length === 1
                     ? "single-slice"
                     : "none";
+        const topologyDecision = baseMode === "none"
+            ? null
+            : routeExecutionTopology({
+                configuredTopology,
+                strictness,
+                maxBuilders,
+                shape: {
+                    unitCount: readyToDispatch.length,
+                    independentUnitCount: conflicts.length > 0 ? 0 : readyToDispatch.length,
+                    substantialUnitCount: readyToDispatch.length,
+                    hasPathConflicts: conflicts.length > 0,
+                    inlineSafe: false,
+                    discoveryOnlyUnits
+                }
+            });
+        // 7.7.1 — when the router collapses a discovery-only ready set into
+        // `inline`, surface `controller-inline` mode + a controllerHint so the
+        // controller knows it must fulfil the slices this turn instead of
+        // dispatching slice-builder per file.
+        const mode = topologyDecision?.topology === "inline"
+            ? "controller-inline"
+            : baseMode;
+        const controllerHint = topologyDecision?.topology === "inline"
+            ? "Fulfill ready slices in this turn without dispatching slice-builder. Record delegation rows with role=controller (scheduled→completed) per slice."
+            : undefined;
         nextDispatch = {
             waveId: firstOpenWave.waveId,
             readyToDispatch,
             pathConflicts: conflicts,
-            mode
+            mode,
+            topology: topologyDecision?.topology ?? "none",
+            topologyReason: topologyDecision?.reason ?? "no ready units",
+            maxBuilders: topologyDecision?.maxBuilders ?? maxBuilders,
+            ...(controllerHint ? { controllerHint } : {})
         };
     }
     return {
@@ -382,6 +476,7 @@ function formatHumanReport(report) {
     }
     lines.push(`nextDispatch: wave=${report.nextDispatch.waveId ?? "(none)"} ` +
         `mode=${report.nextDispatch.mode} ` +
+        `topology=${report.nextDispatch.topology} ` +
         `ready=[${report.nextDispatch.readyToDispatch.join(",")}]`);
     if (report.warnings.length > 0) {
         lines.push("warnings:");

package/dist/types.d.ts

@@ -163,6 +163,10 @@ export interface ReviewLoopConfig {
 export type VcsMode = "git-with-remote" | "git-local-only" | "none";
 export type TddCommitMode = "managed-per-slice" | "agent-required" | "checkpoint-only" | "off";
 export type TddIsolationMode = "worktree" | "in-place" | "auto";
+export type ExecutionTopology = "auto" | "inline" | "single-builder" | "parallel-builders" | "strict-micro";
+export type ExecutionStrictnessProfile = "fast" | "balanced" | "strict";
+export type PlanSliceGranularity = "feature-atomic" | "strict-micro";
+export type PlanMicroTaskPolicy = "advisory" | "strict";
 /**
  * 7.6.0 — what slice-commit does when a manifest in the slice's
  * claim drifts its corresponding lockfile twin (e.g. Cargo.toml +
@@ -206,11 +210,52 @@ export interface TddConfig {
      */
     lockfileTwinPolicy?: LockfileTwinPolicy;
 }
+export interface ExecutionConfig {
+    /**
+     * 7.7.0 — adaptive execution topology for implementation units.
+     *
+     * - `auto` (default): choose the cheapest safe route from plan shape.
+     * - `inline`: controller may execute a low-risk unit inline while still
+     *   recording RED/GREEN/REFACTOR evidence.
+     * - `single-builder`: one slice-builder owns a feature-atomic unit.
+     * - `parallel-builders`: fan out independent substantial units only.
+     * - `strict-micro`: preserve the pre-7.7 posture where each tiny task is
+     *   its own schedulable slice.
+     */
+    topology?: ExecutionTopology;
+    /**
+     * 7.7.0 — default calibration for topology and plan-shape advisories.
+     * `balanced` is the default: prefer feature-atomic units with internal
+     * 2-5 minute TDD steps, warning on microtask-only plans without blocking.
+     */
+    strictness?: ExecutionStrictnessProfile;
+    /**
+     * 7.7.0 — upper bound for simultaneous slice-builder workers when the
+     * router selects `parallel-builders`.
+     */
+    maxBuilders?: number;
+}
+export interface PlanConfig {
+    /**
+     * 7.7.0 — default schedulable surface for plan authoring.
+     * - feature-atomic: U-* slices contain internal 2-5 minute TDD steps.
+     * - strict-micro: one tiny task can remain one schedulable slice.
+     */
+    sliceGranularity?: PlanSliceGranularity;
+    /**
+     * 7.7.0 — how strongly the plan linter reacts to microtask-only plans.
+     * `advisory` warns in fast/balanced execution; `strict` treats strict
+     * microtask planning as intentional.
+     */
+    microTaskPolicy?: PlanMicroTaskPolicy;
+}
 export interface CclawConfig {
     version: string;
     flowVersion: string;
     harnesses: HarnessId[];
     tdd?: TddConfig;
+    execution?: ExecutionConfig;
+    plan?: PlanConfig;
 }
 export interface TransitionRule {
     from: FlowStage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "7.6.0",
+  "version": "7.7.1",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {