cclaw-cli 6.14.2 → 6.14.3

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();
@@ -1333,30 +1338,6 @@ 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

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/package.json

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