cclaw-cli 6.14.2 → 6.14.4

package/dist/artifact-linter/tdd.js

@@ -285,13 +285,25 @@ export async function lintTddStage(ctx) {
             "refactor-deferred",
             "resolve-conflict"
         ]);
-        // v6.14.2 — under `legacyContinuation: true` AND a stamped
-        // boundary, exempt closed slices that NEVER recorded ANY of the
-        // three worktree-first metadata fields. This is the "all-or-
-        // nothing legacy" rule from v6.14.2 Fix 3: partial-metadata
-        // slices stay flagged (a real bug), but slices that pre-date
-        // the worktree-first flip get amnesty.
-        const sliceWorktreeMetaState = computeSliceWorktreeMetaState(runEvents);
+        // v6.14.3 — under `legacyContinuation: true` AND a stamped
+        // boundary, exempt every slice closed at or before
+        // `tddWorktreeCutoverSliceId`. The cutover boundary itself is the
+        // contract: slices ≤ boundary were closed before the
+        // worktree-first metadata mandate took effect, so we trust the
+        // boundary as authoritative and do not require the slice to have
+        // recorded zero metadata across all rows.
+        //
+        // The earlier v6.14.2 "all-or-nothing" rule rejected the common
+        // hox-shape pattern where the GREEN row carries claim/lane/lease
+        // (added on the v6.14.x worktree-first flip) but a later
+        // `refactor-deferred` terminal row does not. That partial-
+        // metadata layout is the operator-visible signature of the
+        // failure mode this exemption was introduced to fix; flagging it
+        // again under a different code defeated the entire migration.
+        //
+        // Operators who want a strict gate can opt out by clearing
+        // `legacyContinuation` (or omitting `tddWorktreeCutoverSliceId`)
+        // — both fields are explicit, persisted, and operator-editable.
         const isExemptLegacySlice = (sliceId) => {
             if (!legacyContinuation)
                 return false;
@@ -300,14 +312,7 @@ export async function lintTddStage(ctx) {
             const n = parseSliceNumber(sliceId);
             if (n === null)
                 return false;
-            if (n > worktreeCutoverBoundary)
-                return false;
-            const meta = sliceWorktreeMetaState.get(sliceId);
-            if (!meta)
-                return true; // no slice-implementer rows at all → fully legacy
-            // Exempt only when the slice carries ZERO worktree fields across
-            // all rows. Partial metadata stays flagged.
-            return !meta.anyMeta;
+            return n <= worktreeCutoverBoundary;
         };
         const missingGreenMeta = new Set();
         const exemptedGreenMeta = new Set();
@@ -1334,35 +1339,19 @@ function pickEventTs(rows) {
     return undefined;
 }
 /**
- * v6.14.2 — for each slice id appearing in `slice-implementer` rows of
- * the active run, record whether ANY row carried at least one of the
- * three worktree-first metadata fields (`claimToken`, `ownerLaneId`,
- * `leasedUntil`). Used by `isExemptLegacySlice` to enforce the "all-or-
- * nothing legacy" rule: only slices with NO worktree fields anywhere
- * in their rows qualify for the legacyContinuation amnesty.
- */
-function computeSliceWorktreeMetaState(events) {
-    const out = new Map();
-    for (const ev of events) {
-        if (ev.stage !== "tdd" || ev.agent !== "slice-implementer")
-            continue;
-        if (typeof ev.sliceId !== "string")
-            continue;
-        const tok = ev.claimToken?.trim() ?? "";
-        const lane = ev.ownerLaneId?.trim() ?? "";
-        const lease = ev.leasedUntil?.trim() ?? "";
-        const anyHere = tok.length > 0 || lane.length > 0 || lease.length > 0;
-        const prev = out.get(ev.sliceId) ?? { anyMeta: false };
-        out.set(ev.sliceId, { anyMeta: prev.anyMeta || anyHere });
-    }
-    return out;
-}
-/**
- * v6.14.2 — slices whose terminal `refactor` / `refactor-deferred` /
- * `resolve-conflict` row recorded a `completedTs` that PRECEDES the
- * latest `leasedUntil` for the same slice. The lease was never
- * reclaimed but the wave closed in time; the missing audit row is
- * advisory bookkeeping, not a correctness failure.
+ * v6.14.2 — slices whose terminal closure event recorded a `completedTs`
+ * that PRECEDES the latest `leasedUntil` for the same slice. The lease
+ * was never reclaimed but the wave closed in time; the missing audit
+ * row is advisory bookkeeping, not a correctness failure.
+ *
+ * v6.14.4 — also recognize stream-mode (per-slice checkpoint) closure:
+ * a `phase=green status=completed` row carrying `refactorOutcome`
+ * (`inline` or `deferred`) IS the slice closure. Without this, every
+ * stream-mode slice incorrectly fired `tdd_lease_expired_unreclaimed`
+ * once its lease expired, even though the slice was already closed
+ * (this mirrors the same predicate already used in
+ * `src/internal/wave-status.ts` for `closedSlices` tracking — same
+ * decision, just now applied to lease-closure detection).
  */
 function computeClosedBeforeLeaseExpiry(events) {
     const terminalPhases = new Set([
@@ -1372,6 +1361,15 @@ function computeClosedBeforeLeaseExpiry(events) {
     ]);
     const lastLease = new Map();
     const earliestTerminal = new Map();
+    const recordTerminal = (sliceId, completedTs) => {
+        const ts = Date.parse(completedTs);
+        if (!Number.isFinite(ts))
+            return;
+        const prev = earliestTerminal.get(sliceId);
+        if (prev === undefined || ts < prev) {
+            earliestTerminal.set(sliceId, ts);
+        }
+    };
     for (const ev of events) {
         if (ev.stage !== "tdd" || ev.agent !== "slice-implementer")
             continue;
@@ -1386,16 +1384,21 @@ function computeClosedBeforeLeaseExpiry(events) {
                 }
             }
         }
-        if (ev.status === "completed" &&
-            typeof ev.phase === "string" &&
-            terminalPhases.has(ev.phase) &&
-            typeof ev.completedTs === "string") {
-            const ts = Date.parse(ev.completedTs);
-            if (Number.isFinite(ts)) {
-                const prev = earliestTerminal.get(ev.sliceId);
-                if (prev === undefined || ts < prev) {
-                    earliestTerminal.set(ev.sliceId, ts);
-                }
+        if (ev.status !== "completed" || typeof ev.completedTs !== "string") {
+            continue;
+        }
+        if (typeof ev.phase !== "string")
+            continue;
+        if (terminalPhases.has(ev.phase)) {
+            recordTerminal(ev.sliceId, ev.completedTs);
+            continue;
+        }
+        // v6.14.4 — stream-mode closure: GREEN-only with refactorOutcome
+        // folded inline IS the slice's terminal row.
+        if (ev.phase === "green" && ev.refactorOutcome) {
+            const mode = ev.refactorOutcome.mode;
+            if (mode === "inline" || mode === "deferred") {
+                recordTerminal(ev.sliceId, ev.completedTs);
             }
         }
     }

package/dist/install.js

@@ -939,8 +939,20 @@ async function applyTddCutoverIfNeeded(projectRoot) {
     if (typeof obj.tddCutoverSliceId === "string" && obj.tddCutoverSliceId.length > 0) {
         return;
     }
-    obj.tddCutoverSliceId = cutoverSliceId;
-    await writeFileSafe(flowStatePath, `${JSON.stringify(obj, null, 2)}\n`, { mode: 0o600 });
+    // v6.14.3 — refresh the SHA256 sidecar by writing through
+    // `writeFlowState`. The previous direct `writeFileSafe` invocation
+    // left the sidecar stale, so the very next guarded hook on a synced
+    // legacy project rejected its own `tddCutoverSliceId` stamp.
+    try {
+        const state = await readFlowState(projectRoot);
+        await writeFlowState(projectRoot, { ...state, tddCutoverSliceId: cutoverSliceId }, {
+            allowReset: true,
+            writerSubsystem: "sync-v6.12-tdd-cutover-stamp"
+        });
+    }
+    catch {
+        // Best-effort: corrupt/missing state is handled elsewhere on sync.
+    }
 }
 const V613_LEGACY_PLAN_BANNER = "<!-- legacy-continuation: predates v6.13 parallel metadata. New units MAY add dependsOn/claimedPaths/parallelizable; existing units treated as best-effort serial. -->";
 /**
@@ -1091,9 +1103,16 @@ async function applyV614DefaultsIfNeeded(projectRoot) {
     if (summary.length === 0) {
         return null;
     }
-    const merged = { ...obj, ...updates };
+    // v6.14.3 — refresh the SHA256 sidecar in lockstep so guarded reads
+    // (verify-current-state, advance-stage, etc.) don't trip a guard
+    // mismatch immediately after `cclaw-cli sync`/`upgrade` writes the
+    // v6.14.2 stream-style defaults.
     try {
-        await writeFileSafe(flowStatePath, `${JSON.stringify(merged, null, 2)}\n`, { mode: 0o600 });
+        const state = await readFlowState(projectRoot);
+        await writeFlowState(projectRoot, { ...state, ...updates }, {
+            allowReset: true,
+            writerSubsystem: "sync-v6.14.2-stream-defaults"
+        });
     }
     catch {
         return null;
@@ -1204,10 +1223,18 @@ async function applyV6142WorktreeCutoverIfNeeded(projectRoot) {
     }
     if (!stamped)
         return null;
-    const merged = { ...obj, tddWorktreeCutoverSliceId: stamped };
+    // v6.14.3 — go through `writeFlowState` so the SHA256 sidecar
+    // (`.cclaw/.flow-state.guard.json`) is refreshed in lockstep with
+    // the on-disk flow-state.json. The previous v6.14.2 implementation
+    // wrote the field via `writeFileSafe` directly, which left the
+    // sidecar pointing at the pre-stamp digest; the next guarded hook
+    // (e.g. `cclaw internal verify-current-state`) then failed with
+    // `flow-state guard mismatch` and demanded a manual repair.
     try {
-        await writeFileSafe(flowStatePath, `${JSON.stringify(merged, null, 2)}\n`, {
-            mode: 0o600
+        const state = await readFlowState(projectRoot);
+        await writeFlowState(projectRoot, { ...state, tddWorktreeCutoverSliceId: stamped }, {
+            allowReset: true,
+            writerSubsystem: "sync-v6.14.2-worktree-cutover-stamp"
         });
     }
     catch {

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

@@ -57,8 +57,48 @@ 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.
+ * v6.14.4 — 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 that hox-shape
+ * projects emit alongside (or instead of) the legacy `**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 preserves the hox convention of recording 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 legacy
+ *   `S-NN → U-NN` derivation so the existing `**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 legacy `**Members:**` /
+ * `Members:` line shape AND the markdown-table shape
+ * (`| sliceId | unit | dependsOn | …`) used by hox-shape projects and by
+ * any plan written by `cclaw-cli sync` after v6.13.x.
+ *
+ * Wave headings accepted (case-insensitive, trailing text allowed):
+ * - `### Wave 04`
+ * - `### Wave W-04`
+ * - `### Wave W-04 — после успешного 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[];
 /**

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

@@ -61,8 +61,73 @@ 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.
+ * v6.14.4 — 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 that hox-shape
+ * projects emit alongside (or instead of) the legacy `**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 preserves the hox convention of recording 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 legacy
+ *   `S-NN → U-NN` derivation so the existing `**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 legacy `**Members:**` /
+ * `Members:` line shape AND the markdown-table shape
+ * (`| sliceId | unit | dependsOn | …`) used by hox-shape projects and by
+ * any plan written by `cclaw-cli sync` after v6.13.x.
+ *
+ * Wave headings accepted (case-insensitive, trailing text allowed):
+ * - `### Wave 04`
+ * - `### Wave W-04`
+ * - `### Wave W-04 — после успешного 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 +137,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 v6.13.1's 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 +199,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();

package/package.json

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