cclaw-cli 7.6.0 → 7.7.0

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 -->";
@@ -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
@@ -175,7 +183,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 +214,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,12 +345,19 @@ 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 {
@@ -350,11 +371,28 @@ export async function runWaveStatus(projectRoot, options = {}) {
                 : readyToDispatch.length === 1
                     ? "single-slice"
                     : "none";
+        const topologyDecision = mode === "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
+                }
+            });
         nextDispatch = {
             waveId: firstOpenWave.waveId,
             readyToDispatch,
             pathConflicts: conflicts,
-            mode
+            mode,
+            topology: topologyDecision?.topology ?? "none",
+            topologyReason: topologyDecision?.reason ?? "no ready units",
+            maxBuilders: topologyDecision?.maxBuilders ?? maxBuilders
         };
     }
     return {
@@ -382,6 +420,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.0",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {