cclaw-cli 6.14.3 → 7.0.0

package/dist/internal/advance-stage/advance.js

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { resolveArtifactPath } from "../../artifact-paths.js";
 import { appendDelegation, checkMandatoryDelegations, readDelegationEvents, readDelegationLedger } from "../../delegation.js";
-import { verifyCompletedStagesGateClosure, verifyCurrentStageGateEvidence, verifyTddWorktreeFanInClosure } from "../../gate-evidence.js";
+import { verifyCompletedStagesGateClosure, verifyCurrentStageGateEvidence } from "../../gate-evidence.js";
 import { extractMarkdownSectionBody, learningsParseFailureHumanSummary, parseLearningsSection } from "../../artifact-linter.js";
 import { getAvailableTransitions, getTransitionGuards } from "../../flow-state.js";
 import { appendKnowledge } from "../../knowledge-store.js";
@@ -13,7 +13,6 @@ import { unique } from "./helpers.js";
 import { AUTO_REVIEW_LOOP_GATE_BY_STAGE, reviewLoopArtifactFixHint, reviewLoopEnvelopeExample, validateGateEvidenceShape } from "./review-loop.js";
 import { ensureProactiveDelegationTrace } from "./proactive-delegation-trace.js";
 import { consumeWaiverToken } from "../waiver-grant.js";
-import { runTddDeterministicFanInBeforeAdvance } from "../../integration-fanin.js";
 function resolveSuccessorTransition(stage, track, transitionTargets, satisfiedGuards, selectedTransitionGuards) {
     const natural = transitionTargets[0] ?? null;
     const specialTargets = transitionTargets.filter((target) => target !== natural);
@@ -60,16 +59,16 @@ function nextInteractionHints(flowState, args, successor) {
     return hints;
 }
 /**
- * Wave 24 entry point — auto-hydrate evidence for an auto-hydratable
+ * entry point — auto-hydrate evidence for an auto-hydratable
  * gate that the agent already included in --passed but for which they
  * forgot to provide --evidence-json. Returns silently when no
  * hydration is possible (no auto-hydratable gate, no artifact, no
  * envelope, etc.).
  *
- * Wave 25 (v6.1.0) layered `tryAutoHydrateAndSelectReviewLoopGate` on
+ * layered `tryAutoHydrateAndSelectReviewLoopGate` on
  * top of this so the gate is also auto-included in selectedGateIds
  * when the artifact yields a valid envelope. Together the two helpers
- * remove the contradiction the user reported in Wave 24:
+ * remove the contradiction:
  *   - "omit this gate from --evidence-json so stage-complete can
  *      auto-hydrate it" → "missing --evidence-json entries for passed
  *      gates: design_diagram_freshness".
@@ -105,7 +104,7 @@ export async function hydrateReviewLoopEvidenceFromArtifact(projectRoot, stage,
     evidenceByGate[gateId] = JSON.stringify(envelope);
 }
 /**
- * Wave 25 (v6.1.0) — auto-include an auto-hydratable review-loop gate
+ * auto-include an auto-hydratable review-loop gate
  * in `selectedGateIds` when:
  *   - The stage has an auto-hydratable gate registered via
  *     `AUTO_REVIEW_LOOP_GATE_BY_STAGE` (currently `design`).
@@ -162,7 +161,7 @@ export async function tryAutoHydrateAndSelectReviewLoopGate(projectRoot, stage,
     return [...selectedGateIds, gateId];
 }
 export async function buildValidationReport(projectRoot, flowState, options = {}) {
-    // Wave 24 follow-up (v6.1.1): forward `flowState.taskClass` so the
+    // forward `flowState.taskClass` so the
     // bugfix-skip lights up via the `cclaw advance-stage` path. The
     // delegation helper now has its own fallback (it reads `flowState`
     // internally), but threading the value here keeps the call site
@@ -314,11 +313,11 @@ export async function runAdvanceStage(projectRoot, args, io) {
     let selectedGateIds = args.passedGateIds.length > 0
         ? args.passedGateIds.filter((gateId) => selectableGateIds.has(gateId))
         : requiredGateIds;
-    // Wave 25 (v6.1.0): if the active stage has an auto-hydratable
+    // if the active stage has an auto-hydratable
     // review-loop gate (currently `design.design_architecture_locked`)
     // and the artifact already contains a valid review-loop envelope,
     // include the gate in selectedGateIds and hydrate evidence in one
-    // step. This removes the Wave 24 contradiction between "omit from
+    // step. This removes the contradiction between "omit from
     // --evidence-json so we can auto-hydrate" and "missing
     // --evidence-json entries for passed gates".
     selectedGateIds = await tryAutoHydrateAndSelectReviewLoopGate(projectRoot, args.stage, flowState.track, requiredGateIds, selectedGateIds, args.evidenceByGate);
@@ -363,7 +362,7 @@ export async function runAdvanceStage(projectRoot, args, io) {
             });
         }
     }
-    // Wave 25 (v6.1.0): hydration + auto-select happens earlier via
+    // hydration + auto-select happens earlier via
     // `tryAutoHydrateAndSelectReviewLoopGate`. The previous explicit
     // call here was redundant (helper already covered both the
     // already-selected and not-yet-selected paths).
@@ -603,20 +602,6 @@ export async function runAdvanceStage(projectRoot, args, io) {
     }
     const satisfiedGuards = new Set([...nextPassed, ...selectedTransitionGuards]);
     const successor = resolveSuccessorTransition(args.stage, flowState.track, transitionTargets, satisfiedGuards, new Set(selectedTransitionGuards));
-    if (args.stage === "tdd" && successor !== null && successor !== "tdd") {
-        const fanIn = await runTddDeterministicFanInBeforeAdvance(projectRoot, flowState);
-        if (!fanIn.ok) {
-            io.stderr.write(`cclaw internal advance-stage: deterministic worktree fan-in failed:\n${fanIn.issues
-                .map((line) => `  - ${line}`)
-                .join("\n")}\n`);
-            return 1;
-        }
-        const closure = await verifyTddWorktreeFanInClosure(projectRoot, flowState);
-        if (closure.length > 0) {
-            io.stderr.write(`cclaw internal advance-stage: ${closure.join(" | ")}\n`);
-            return 1;
-        }
-    }
     const completedStages = blockedReviewRoute
         ? flowState.completedStages.filter((finished) => finished !== args.stage)
         : flowState.completedStages.includes(args.stage)

package/dist/internal/advance-stage/parsers.d.ts

@@ -49,7 +49,7 @@ export interface StartFlowArgs {
     reclassify: boolean;
     quiet: boolean;
     /**
-     * Wave 23 (v5.0.0) — `/cc-ideate` handoff carry-forward.
+     * `/cc-ideate` handoff carry-forward.
      * Workspace-relative POSIX path to `.cclaw/ideas/idea-YYYY-MM-DD-<slug>.md`
      * (or wherever `/cc-ideate` wrote its artifact).
      */

package/dist/internal/advance-stage/review-loop.d.ts

@@ -1,7 +1,7 @@
 import type { FlowStage } from "../../types.js";
 export declare const AUTO_REVIEW_LOOP_GATE_BY_STAGE: Partial<Record<FlowStage, string>>;
 /**
- * Wave 25 (v6.1.0) — exact JSON shape that gate-evidence validators
+ * exact JSON shape that gate-evidence validators
  * accept for a review-loop envelope. The error messages emitted by
  * `validateReviewLoopGateEvidence` always include this example so the
  * agent never has to guess where `stage` lives (top-level of the

package/dist/internal/advance-stage/review-loop.js

@@ -12,7 +12,7 @@ const REVIEW_LOOP_STOP_REASONS = new Set([
     "user_opt_out"
 ]);
 /**
- * Wave 25 (v6.1.0) — exact JSON shape that gate-evidence validators
+ * exact JSON shape that gate-evidence validators
  * accept for a review-loop envelope. The error messages emitted by
  * `validateReviewLoopGateEvidence` always include this example so the
  * agent never has to guess where `stage` lives (top-level of the
@@ -183,9 +183,9 @@ export async function validateGateEvidenceShape(projectRoot, stage, gateId, evid
 export function reviewLoopArtifactFixHint(stage, gateId) {
     if (AUTO_REVIEW_LOOP_GATE_BY_STAGE[stage] !== gateId)
         return "";
-    // Wave 25 (v6.1.0): the consistent flow is "include the gate in
+    // the consistent flow is "include the gate in
     // --passed AND let stage-complete auto-hydrate evidence from the
-    // artifact". Wave 24's hint told agents to omit the gate from
+    // artifact". An older hint told agents to omit the gate from
     // --evidence-json, but they then hit
     // `missing --evidence-json entries for passed gates: <gateId>`
     // because hydration only runs when --evidence-json is also present

package/dist/internal/advance-stage/start-flow.js

@@ -175,8 +175,7 @@ export async function runStartFlow(projectRoot, args, io) {
             guardEvidence,
             stageGateCatalog,
             rewinds: current.rewinds,
-            staleStages: current.staleStages,
-            worktreeExecutionMode: current.worktreeExecutionMode ?? "worktree-first"
+            staleStages: current.staleStages
         };
         const validation = await buildValidationReport(projectRoot, nextState);
         const evidenceIssues = completedStageClosureEvidenceIssues(nextState);
@@ -194,7 +193,6 @@ export async function runStartFlow(projectRoot, args, io) {
         if (nextTaskClass !== undefined) {
             nextState = { ...nextState, taskClass: nextTaskClass };
         }
-        nextState = { ...nextState, worktreeExecutionMode: "worktree-first" };
     }
     if (args.fromIdeaArtifact) {
         const existingHints = nextState.interactionHints ?? {};

package/dist/internal/advance-stage.js

@@ -14,11 +14,8 @@ import { parseAdvanceStageArgs, parseCancelRunArgs, parseHookArgs, parseRewindAr
 import { parseFlowStateRepairArgs, runFlowStateRepair } from "./flow-state-repair.js";
 import { parseWaiverGrantArgs, runWaiverGrant } from "./waiver-grant.js";
 import { FlowStateGuardMismatchError, verifyFlowStateGuard } from "../run-persistence.js";
-import { DelegationTimestampError, DispatchCapError, DispatchClaimInvalidError, DispatchDuplicateError, DispatchOverlapError } from "../delegation.js";
+import { DelegationTimestampError, DispatchCapError, DispatchDuplicateError, DispatchOverlapError } from "../delegation.js";
 import { parsePlanSplitWavesArgs, runPlanSplitWaves } from "./plan-split-waves.js";
-import { runSetWorktreeMode } from "./set-worktree-mode.js";
-import { runSetCheckpointMode } from "./set-checkpoint-mode.js";
-import { runSetIntegrationOverseerMode } from "./set-integration-overseer-mode.js";
 import { runWaveStatusCommand } from "./wave-status.js";
 import { runCohesionContractCommand } from "./cohesion-contract-stub.js";
 /**
@@ -33,15 +30,12 @@ const GUARD_ENFORCED_SUBCOMMANDS = new Set([
     "cancel-run",
     "rewind",
     "verify-flow-state-diff",
-    "verify-current-state",
-    "set-worktree-mode",
-    "set-checkpoint-mode",
-    "set-integration-overseer-mode"
+    "verify-current-state"
 ]);
 export async function runInternalCommand(projectRoot, argv, io) {
     const [subcommand, ...tokens] = argv;
     if (!subcommand) {
-        io.stderr.write("cclaw internal requires a subcommand: advance-stage | start-flow | cancel-run | rewind | verify-flow-state-diff | verify-current-state | envelope-validate | tdd-red-evidence | tdd-loop-status | early-loop-status | compound-readiness | runtime-integrity | hook | flow-state-repair | waiver-grant | plan-split-waves | set-worktree-mode | set-checkpoint-mode | set-integration-overseer-mode | wave-status | cohesion-contract\n");
+        io.stderr.write("cclaw internal requires a subcommand: advance-stage | start-flow | cancel-run | rewind | verify-flow-state-diff | verify-current-state | envelope-validate | tdd-red-evidence | tdd-loop-status | early-loop-status | compound-readiness | runtime-integrity | hook | flow-state-repair | waiver-grant | plan-split-waves | wave-status | cohesion-contract\n");
         return 1;
     }
     try {
@@ -96,22 +90,13 @@ export async function runInternalCommand(projectRoot, argv, io) {
         if (subcommand === "plan-split-waves") {
             return await runPlanSplitWaves(projectRoot, parsePlanSplitWavesArgs(tokens), io);
         }
-        if (subcommand === "set-worktree-mode") {
-            return await runSetWorktreeMode(projectRoot, tokens, io);
-        }
-        if (subcommand === "set-checkpoint-mode") {
-            return await runSetCheckpointMode(projectRoot, tokens, io);
-        }
-        if (subcommand === "set-integration-overseer-mode") {
-            return await runSetIntegrationOverseerMode(projectRoot, tokens, io);
-        }
         if (subcommand === "wave-status") {
             return await runWaveStatusCommand(projectRoot, tokens, io);
         }
         if (subcommand === "cohesion-contract") {
             return await runCohesionContractCommand(projectRoot, tokens, io);
         }
-        io.stderr.write(`Unknown internal subcommand: ${subcommand}. Expected advance-stage | start-flow | cancel-run | rewind | verify-flow-state-diff | verify-current-state | envelope-validate | tdd-red-evidence | tdd-loop-status | early-loop-status | compound-readiness | runtime-integrity | hook | flow-state-repair | waiver-grant | plan-split-waves | set-worktree-mode | set-checkpoint-mode | set-integration-overseer-mode | wave-status | cohesion-contract\n`);
+        io.stderr.write(`Unknown internal subcommand: ${subcommand}. Expected advance-stage | start-flow | cancel-run | rewind | verify-flow-state-diff | verify-current-state | envelope-validate | tdd-red-evidence | tdd-loop-status | early-loop-status | compound-readiness | runtime-integrity | hook | flow-state-repair | waiver-grant | plan-split-waves | wave-status | cohesion-contract\n`);
         return 1;
     }
     catch (err) {
@@ -135,10 +120,6 @@ export async function runInternalCommand(projectRoot, argv, io) {
             io.stderr.write(`error: dispatch_cap — ${err.message}\n`);
             return 2;
         }
-        if (err instanceof DispatchClaimInvalidError) {
-            io.stderr.write(`error: dispatch_claim_invalid — ${err.message}\n`);
-            return 2;
-        }
         io.stderr.write(`cclaw internal ${subcommand} failed: ${err instanceof Error ? err.message : String(err)}\n`);
         return 1;
     }

package/dist/internal/cohesion-contract-stub.d.ts

@@ -10,20 +10,15 @@ export interface CohesionContractArgs {
 }
 export declare function parseCohesionContractArgs(tokens: string[]): CohesionContractArgs | null;
 /**
- * v6.14.2 — emit a minimal advisory cohesion contract that satisfies
- * the linter shape check (`cohesion-contract.{md,json}`) so projects
- * with `legacyContinuation: true` and ≥ 2 completed slice-implementer
- * rows can clear the soft `tdd.cohesion_contract_missing` finding
- * without hand-authoring the document.
+ * Scaffold a minimal cohesion-contract pair (`cohesion-contract.{md,json}`)
+ * so authors have a starting point when a multi-slice wave needs cross-slice
+ * cohesion documentation. The stub seeds `sharedTypes`, `touchpoints`, and
+ * `slices` from the active run delegation ledger and carries
+ * `status.verdict: "scaffold"` so reviewers know to fill in the real content
+ * before treating it as authoritative.
  *
- * The stub is intentionally bare — `sharedTypes`, `touchpoints`, and
- * `slices` are populated from the active run delegation ledger so
- * downstream tooling can see which slices the contract acknowledges,
- * but the contract carries `status.verdict: "advisory_legacy"` so
- * reviewers know not to treat it as authoritative.
- *
- * Refuses to overwrite an existing contract unless `--force` is
- * passed; the existing file is treated as authored work.
+ * Refuses to overwrite an existing contract unless `--force` is passed; the
+ * existing file is treated as authored work.
  */
 export declare function runCohesionContractCommand(projectRoot: string, tokens: string[], io: InternalIo): Promise<number>;
 export {};

package/dist/internal/cohesion-contract-stub.js

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { RUNTIME_ROOT } from "../constants.js";
 import { writeFileSafe } from "../fs-utils.js";
-import { readDelegationLedger } from "../delegation.js";
+import { readDelegationLedger, isParallelTddSliceWorker } from "../delegation.js";
 export function parseCohesionContractArgs(tokens) {
     const args = { stub: false, force: false, reason: null };
     for (const token of tokens) {
@@ -27,20 +27,15 @@ export function parseCohesionContractArgs(tokens) {
     return args;
 }
 /**
- * v6.14.2 — emit a minimal advisory cohesion contract that satisfies
- * the linter shape check (`cohesion-contract.{md,json}`) so projects
- * with `legacyContinuation: true` and ≥ 2 completed slice-implementer
- * rows can clear the soft `tdd.cohesion_contract_missing` finding
- * without hand-authoring the document.
+ * Scaffold a minimal cohesion-contract pair (`cohesion-contract.{md,json}`)
+ * so authors have a starting point when a multi-slice wave needs cross-slice
+ * cohesion documentation. The stub seeds `sharedTypes`, `touchpoints`, and
+ * `slices` from the active run delegation ledger and carries
+ * `status.verdict: "scaffold"` so reviewers know to fill in the real content
+ * before treating it as authoritative.
  *
- * The stub is intentionally bare — `sharedTypes`, `touchpoints`, and
- * `slices` are populated from the active run delegation ledger so
- * downstream tooling can see which slices the contract acknowledges,
- * but the contract carries `status.verdict: "advisory_legacy"` so
- * reviewers know not to treat it as authoritative.
- *
- * Refuses to overwrite an existing contract unless `--force` is
- * passed; the existing file is treated as authored work.
+ * Refuses to overwrite an existing contract unless `--force` is passed; the
+ * existing file is treated as authored work.
  */
 export async function runCohesionContractCommand(projectRoot, tokens, io) {
     const parsed = parseCohesionContractArgs(tokens);
@@ -63,13 +58,12 @@ export async function runCohesionContractCommand(projectRoot, tokens, io) {
     const sliceIds = collectSliceIds(ledger?.entries ?? []);
     const reasonNote = parsed.reason
         ? `Reason: ${parsed.reason}`
-        : "Reason: legacyContinuation auto-stub.";
+        : "Reason: scaffold for a multi-slice wave that needs cohesion documentation.";
     const md = [
         "# Cohesion Contract",
         "",
-        "_Advisory stub generated by `cclaw-cli internal cohesion-contract --stub`._",
-        "_Status: `advisory_legacy` — populated for legacyContinuation projects so the_",
-        "_TDD linter does not block stage-complete on `tdd.cohesion_contract_missing`._",
+        "_Scaffold generated by `cclaw-cli internal cohesion-contract --stub`._",
+        "_Status: `scaffold` — replace placeholders with real cross-slice data before review._",
         "",
         `${reasonNote}`,
         "",
@@ -110,21 +104,21 @@ export async function runCohesionContractCommand(projectRoot, tokens, io) {
         touchpoints: [],
         slices: sliceIds.map((sid) => ({
             sliceId: sid,
-            description: `Stub entry for ${sid}; advisory under legacyContinuation.`,
+            description: `Scaffold entry for ${sid}; replace with real behavior summary.`,
             implemented: true,
             testsPass: true,
             cohesionVerified: false
         })),
         status: {
-            verdict: "advisory_legacy",
+            verdict: "scaffold",
             generatedBy: "cclaw-cli internal cohesion-contract --stub",
-            reason: parsed.reason ?? "legacyContinuation auto-stub"
+            reason: parsed.reason ?? "scaffold for a multi-slice wave"
         }
     };
     await writeFileSafe(mdPath, md);
     await writeFileSafe(jsonPath, `${JSON.stringify(jsonStub, null, 2)}\n`);
-    io.stdout.write(`cclaw: cohesion-contract stub written (${sliceIds.length} slice(s) referenced). ` +
-        "Status: advisory_legacy — review and replace once cross-slice cohesion data is real.\n");
+    io.stdout.write(`cclaw: cohesion-contract scaffold written (${sliceIds.length} slice(s) referenced). ` +
+        "Status: scaffold — replace placeholders with real cross-slice data.\n");
     return 0;
 }
 async function fileExists(filePath) {
@@ -139,7 +133,7 @@ async function fileExists(filePath) {
 function collectSliceIds(entries) {
     const set = new Set();
     for (const entry of entries) {
-        if (entry.agent !== "slice-implementer")
+        if (!isParallelTddSliceWorker(entry.agent ?? ""))
             continue;
         if (entry.status !== "completed")
             continue;

package/dist/internal/flow-state-repair.d.ts

@@ -8,7 +8,7 @@ export interface FlowStateRepairArgs {
     json: boolean;
     quiet: boolean;
     /**
-     * v6.9.0 — when true, normalize `state/early-loop.json` to the canonical
+     * when true, normalize `state/early-loop.json` to the canonical
      * shape derived from `early-loop-log.jsonl`. Lets operators recover from
      * legacy hand-written `early-loop.json` files that drifted from the
      * source-of-truth log.

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

@@ -4,7 +4,7 @@ interface InternalIo {
     stderr: Writable;
 }
 /**
- * v6.10.0 (P3) — split a large `05-plan.md` Implementation Units section
+ * split a large `05-plan.md` Implementation Units section
  * into wave-NN.md sub-files so an executor can carry one wave at a time
  * without re-reading the whole plan.
  *
@@ -31,7 +31,7 @@ export interface PlanSplitWavesArgs {
 }
 export declare const PLAN_SPLIT_DEFAULT_WAVE_SIZE = 5;
 export declare const PLAN_SPLIT_SMALL_PLAN_THRESHOLD = 50;
-/** v6.13.1 — member line in Parallel Execution Plan or wave-NN.md */
+/** Member line in Parallel Execution Plan or wave-NN.md */
 export interface ParsedParallelWaveMember {
     sliceId: string;
     unitId: string;
@@ -57,8 +57,45 @@ export declare function extractParallelExecutionManagedBody(planMarkdown: string
  */
 export declare function extractMembersListFromLine(trimmedLine: string): string | null;
 /**
- * Parse `## Parallel Execution Plan` managed block for wave headings and Members lines.
- * Malformed member tokens are skipped. Duplicate slice ids in one plan source throw.
+ * Extract a `(sliceId, unitId)` pair from a markdown table data row
+ * whose first column is an `S-NN` token. Used by the wave parser to
+ * recognize the table-format Parallel Execution Plan alongside (or
+ * instead of) the `**Members:**` bullet line.
+ *
+ * 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
+ *   silently skipped.
+ * - Column 2, when present and non-empty, becomes the `unitId`
+ *   verbatim (after stripping whitespace + backticks/quotes/brackets).
+ *   This lets authors record task ids (`T-010`, `T-008a`, …) in the
+ *   `unit` column without forcing a `U-NN` derivation.
+ * - When column 2 is absent or empty, fall back to the
+ *   `S-NN → U-NN` derivation so the `**Members:**` parser path stays
+ *   bit-identical for non-table plans.
+ */
+export declare function parseTableRowMember(trimmedLine: string): ParsedParallelWaveMember | null;
+/**
+ * Parse `## Parallel Execution Plan` managed block for wave headings and
+ * member declarations. Recognizes BOTH the `**Members:**` / `Members:`
+ * line shape AND the markdown-table shape
+ * (`| sliceId | unit | dependsOn | …`).
+ *
+ * Wave headings accepted (case-insensitive, trailing text allowed):
+ * - `### Wave 04`
+ * - `### Wave W-04`
+ * - `### Wave W-04 — after fan-in W-03 (5 lanes …)`
+ *
+ * Within a single wave the parser dedupes by `sliceId`: if the same
+ * slice appears in both `**Members:**` and a table row, the first
+ * occurrence wins (line-order). Cross-wave duplicates still throw
+ * `WavePlanDuplicateSliceError`.
+ *
+ * Malformed member tokens are skipped. Empty waves (heading present
+ * but neither a Members line nor any matching `| S-NN |` row found
+ * before the next heading) are RETURNED with `members: []` so callers
+ * can surface the boundary; classification is up to the caller.
  */
 export declare function parseParallelExecutionPlanWaves(planMarkdown: string): ParsedParallelWave[];
 /**
@@ -98,20 +135,20 @@ export interface ImplementationUnitParallelFields {
 }
 export interface ParseImplementationUnitParallelOptions {
     /**
-     * Legacy continuation (v6.13.0): when the plan predates explicit parallel
+     * Continuation: when the plan predates explicit parallel
      * bullets, units without a `parallelizable:` line default to serial eligibility
      * in the scheduler (`parallelizable: false`).
      */
     legacyParallelDefaultSerial?: boolean;
 }
 /**
- * Parse v6.13 parallel-metadata bullets from an implementation unit body.
+ * Parse parallel-metadata bullets from an implementation unit body.
  * Missing keys use conservative defaults (`dependsOn: []`, `parallelizable: true`
  * unless `legacyParallelDefaultSerial` is set).
  */
 export declare function parseImplementationUnitParallelFields(unit: ParsedImplementationUnit, options?: ParseImplementationUnitParallelOptions): ImplementationUnitParallelFields;
 /**
- * True when the plan has implementation units but any unit is missing v6.13.0
+ * True when the plan has implementation units but any unit is missing
  * `dependsOn` / `claimedPaths` / `parallelizable` / `riskTier` bullets.
  */
 export declare function planArtifactLacksV613ParallelMetadata(planMarkdown: string): boolean;

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

@@ -61,8 +61,70 @@ export function extractMembersListFromLine(trimmedLine) {
     return null;
 }
 /**
- * Parse `## Parallel Execution Plan` managed block for wave headings and Members lines.
- * Malformed member tokens are skipped. Duplicate slice ids in one plan source throw.
+ * Extract a `(sliceId, unitId)` pair from a markdown table data row
+ * whose first column is an `S-NN` token. Used by the wave parser to
+ * recognize the table-format Parallel Execution Plan alongside (or
+ * instead of) the `**Members:**` bullet line.
+ *
+ * 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
+ *   silently skipped.
+ * - Column 2, when present and non-empty, becomes the `unitId`
+ *   verbatim (after stripping whitespace + backticks/quotes/brackets).
+ *   This lets authors record task ids (`T-010`, `T-008a`, …) in the
+ *   `unit` column without forcing a `U-NN` derivation.
+ * - When column 2 is absent or empty, fall back to the
+ *   `S-NN → U-NN` derivation so the `**Members:**` parser path stays
+ *   bit-identical for non-table plans.
+ */
+export function parseTableRowMember(trimmedLine) {
+    if (!trimmedLine.startsWith("|"))
+        return null;
+    const inner = trimmedLine.replace(/^\|/u, "").replace(/\|\s*$/u, "");
+    if (inner.length === 0)
+        return null;
+    const cells = inner.split("|").map((cell) => cell.trim());
+    if (cells.length === 0)
+        return null;
+    const stripDecorations = (raw) => raw.replace(/^[`"'[\]()]+|[`"'[\]()]+$/gu, "").trim();
+    const col1 = stripDecorations(cells[0]);
+    const sliceMatch = /^S-(\d+)$/u.exec(col1);
+    if (!sliceMatch)
+        return null;
+    const sliceNum = sliceMatch[1];
+    const sliceId = `S-${sliceNum}`;
+    let unitId = `U-${sliceNum}`;
+    if (cells.length >= 2) {
+        const col2 = stripDecorations(cells[1]);
+        if (col2.length > 0) {
+            const normalized = tokenToSliceAndUnit(col2);
+            unitId = normalized ? normalized.unitId : col2;
+        }
+    }
+    return { sliceId, unitId };
+}
+/**
+ * Parse `## Parallel Execution Plan` managed block for wave headings and
+ * member declarations. Recognizes BOTH the `**Members:**` / `Members:`
+ * line shape AND the markdown-table shape
+ * (`| sliceId | unit | dependsOn | …`).
+ *
+ * Wave headings accepted (case-insensitive, trailing text allowed):
+ * - `### Wave 04`
+ * - `### Wave W-04`
+ * - `### Wave W-04 — after fan-in W-03 (5 lanes …)`
+ *
+ * Within a single wave the parser dedupes by `sliceId`: if the same
+ * slice appears in both `**Members:**` and a table row, the first
+ * occurrence wins (line-order). Cross-wave duplicates still throw
+ * `WavePlanDuplicateSliceError`.
+ *
+ * Malformed member tokens are skipped. Empty waves (heading present
+ * but neither a Members line nor any matching `| S-NN |` row found
+ * before the next heading) are RETURNED with `members: []` so callers
+ * can surface the boundary; classification is up to the caller.
  */
 export function parseParallelExecutionPlanWaves(planMarkdown) {
     const body = extractParallelExecutionManagedBody(planMarkdown);
@@ -72,22 +134,60 @@ export function parseParallelExecutionPlanWaves(planMarkdown) {
     const waves = [];
     let current = null;
     const seenSlices = new Set();
+    let inWaveSlicesSeen = new Set();
     const flushCurrent = () => {
-        if (current && current.members.length > 0) {
+        if (current) {
             waves.push(current);
         }
     };
+    /**
+     * Strict add: throw on duplicates within the same wave OR across waves.
+     * Used for the `**Members:**` path so the duplicate-detection
+     * contract is preserved bit-identically.
+     */
+    const addMemberStrict = (member) => {
+        if (!current)
+            return;
+        if (inWaveSlicesSeen.has(member.sliceId) ||
+            seenSlices.has(member.sliceId)) {
+            throw new WavePlanDuplicateSliceError(`duplicate slice ${member.sliceId} in Parallel Execution Plan managed block`);
+        }
+        seenSlices.add(member.sliceId);
+        inWaveSlicesSeen.add(member.sliceId);
+        current.members.push(member);
+    };
+    /**
+     * Lenient add: silently dedupe duplicates within the same wave (so the
+     * documented "Members + table both present" case keeps the Members
+     * declaration as authoritative); still throw on cross-wave duplicates
+     * to surface real plan-authoring bugs.
+     */
+    const addMemberDedupInWave = (member) => {
+        if (!current)
+            return;
+        if (inWaveSlicesSeen.has(member.sliceId))
+            return;
+        if (seenSlices.has(member.sliceId)) {
+            throw new WavePlanDuplicateSliceError(`duplicate slice ${member.sliceId} in Parallel Execution Plan managed block`);
+        }
+        seenSlices.add(member.sliceId);
+        inWaveSlicesSeen.add(member.sliceId);
+        current.members.push(member);
+    };
     for (const rawLine of lines) {
         const trimmed = rawLine.trim();
-        const waveMatch = /^###\s+Wave\s+(\d+)\s*$/iu.exec(trimmed);
+        const waveMatch = /^###\s+Wave\s+(?:W-)?(\d+)\b/iu.exec(trimmed);
         if (waveMatch) {
             flushCurrent();
             const n = waveMatch[1];
             current = { waveId: `W-${n.padStart(2, "0")}`, members: [] };
+            inWaveSlicesSeen = new Set();
             continue;
         }
+        if (!current)
+            continue;
         const membersCsv = extractMembersListFromLine(trimmed);
-        if (membersCsv !== null && current) {
+        if (membersCsv !== null) {
             const parts = membersCsv
                 .split(/,/u)
                 .map((p) => p.trim())
@@ -96,12 +196,13 @@ export function parseParallelExecutionPlanWaves(planMarkdown) {
                 const ids = tokenToSliceAndUnit(part);
                 if (!ids)
                     continue;
-                if (seenSlices.has(ids.sliceId)) {
-                    throw new WavePlanDuplicateSliceError(`duplicate slice ${ids.sliceId} in Parallel Execution Plan managed block`);
-                }
-                seenSlices.add(ids.sliceId);
-                current.members.push(ids);
+                addMemberStrict(ids);
             }
+            continue;
+        }
+        const tableMember = parseTableRowMember(trimmed);
+        if (tableMember) {
+            addMemberDedupInWave(tableMember);
         }
     }
     flushCurrent();
@@ -220,7 +321,7 @@ export function formatNextParallelWaveSyncHint(merged) {
     return `Parallel Execution Plan: ${candidate.waveId} has ${candidate.members.length} parallel members (${ids}).`;
 }
 /**
- * Parse v6.13 parallel-metadata bullets from an implementation unit body.
+ * Parse parallel-metadata bullets from an implementation unit body.
  * Missing keys use conservative defaults (`dependsOn: []`, `parallelizable: true`
  * unless `legacyParallelDefaultSerial` is set).
  */
@@ -276,7 +377,7 @@ function unitBodyHasV613ParallelBullet(body, label) {
     });
 }
 /**
- * True when the plan has implementation units but any unit is missing v6.13.0
+ * True when the plan has implementation units but any unit is missing
  * `dependsOn` / `claimedPaths` / `parallelizable` / `riskTier` bullets.
  */
 export function planArtifactLacksV613ParallelMetadata(planMarkdown) {

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

@@ -21,9 +21,6 @@ export interface WaveStatusNextDispatch {
 export interface WaveStatusReport {
     activeRunId: string;
     currentStage: string;
-    tddCutoverSliceId: string | null;
-    tddWorktreeCutoverSliceId: string | null;
-    legacyContinuation: boolean;
     waves: WaveStatusWaveSummary[];
     nextDispatch: WaveStatusNextDispatch;
     warnings: string[];
@@ -37,11 +34,11 @@ export interface RunWaveStatusOptions {
     artifactsDir?: string;
 }
 /**
- * v6.14.2 — deterministic helper for the TDD controller. Reads the
- * managed `<!-- parallel-exec-managed-start -->` block from
+ * Deterministic helper for the TDD controller. Reads the managed
+ * `<!-- parallel-exec-managed-start -->` block from
  * `<artifacts-dir>/05-plan.md` plus the `wave-plans/` directory and
  * reports waves + the next dispatchable members so the controller does
- * NOT have to page through a 1400-line plan to find the active wave.
+ * NOT have to page through a long plan to find the active wave.
  *
  * Always exits 0 unless the plan is malformed (no managed block AND no
  * wave-plans directory), in which case exit 2 with a structured error.