cclaw-cli 6.7.0 → 6.9.0

package/dist/run-persistence.js

@@ -700,6 +700,43 @@ export async function writeFlowState(projectRoot, state, options = {}) {
 export async function writeFlowStateGuarded(projectRoot, state, options = {}) {
     await writeFlowState(projectRoot, state, options);
 }
+/**
+ * v6.9.0 — backfill missing `completedStageMeta` rows for any stage that
+ * already lives in `completedStages` but has no audit timestamp. Uses the
+ * stage's artifact mtime when available, otherwise the current time. This
+ * runs as part of `flow-state-repair` so legacy v6.8 flow-state.json files
+ * get their meta carried forward without a destructive rewrite.
+ */
+async function backfillCompletedStageMeta(projectRoot, state) {
+    const meta = { ...(state.completedStageMeta ?? {}) };
+    const backfilled = [];
+    for (const stage of state.completedStages) {
+        if (meta[stage] && typeof meta[stage].completedAt === "string" && meta[stage].completedAt.length > 0) {
+            continue;
+        }
+        let completedAt = new Date().toISOString();
+        try {
+            const { resolveArtifactPath } = await import("./artifact-paths.js");
+            const resolved = await resolveArtifactPath(stage, {
+                projectRoot,
+                track: state.track,
+                intent: "read"
+            });
+            const stat = await fs.stat(resolved.absPath);
+            completedAt = new Date(stat.mtimeMs).toISOString();
+        }
+        catch {
+            // artifact missing or unreadable — fall back to "now" so the meta row
+            // is at least consistently populated; operators can re-edit if needed.
+        }
+        meta[stage] = { completedAt };
+        backfilled.push(stage);
+    }
+    if (backfilled.length === 0) {
+        return { state, backfilled };
+    }
+    return { state: { ...state, completedStageMeta: meta }, backfilled };
+}
 /**
  * Recompute the write-guard sidecar from the current on-disk flow-state
  * contents and append an audit entry to `.cclaw/.flow-state-repair.log`.
@@ -720,12 +757,26 @@ export async function repairFlowStateGuard(projectRoot, reason) {
         throw new Error(`flow-state-repair: ${FLOW_STATE_REL_PATH} does not exist; nothing to repair.`);
     }
     return withDirectoryLock(flowStateLockPath(projectRoot), async () => {
-        const raw = await fs.readFile(statePath, "utf8");
+        let raw = await fs.readFile(statePath, "utf8");
         let runId = "unknown-run";
+        let backfilledStages = [];
         try {
             const parsed = JSON.parse(raw);
             const coerced = coerceFlowState(parsed).state;
             runId = coerced.activeRunId;
+            const { state: nextState, backfilled } = await backfillCompletedStageMeta(projectRoot, coerced);
+            backfilledStages = backfilled;
+            if (backfilled.length > 0) {
+                // Persist the migrated state inside the same lock window so the
+                // sha sidecar below covers the post-migration bytes, not the
+                // pre-migration ones.
+                await writeFlowState(projectRoot, nextState, {
+                    allowReset: true,
+                    skipLock: true,
+                    writerSubsystem: "flow-state-repair-backfill"
+                });
+                raw = await fs.readFile(statePath, "utf8");
+            }
         }
         catch {
             // parsing failure falls back to "unknown-run"; repair intentionally
@@ -743,9 +794,17 @@ export async function repairFlowStateGuard(projectRoot, reason) {
         await writeFileSafe(guardPath, `${JSON.stringify(sidecar, null, 2)}\n`, { mode: 0o600 });
         const logPath = repairLogPath(projectRoot);
         await ensureDir(path.dirname(logPath));
-        const logLine = `${sidecar.writtenAt} reason=${trimmed} runId=${sidecar.runId} sha256=${sidecar.sha256}\n`;
+        const backfillNote = backfilledStages.length > 0
+            ? ` backfilledCompletedStageMeta=${backfilledStages.join(",")}`
+            : "";
+        const logLine = `${sidecar.writtenAt} reason=${trimmed} runId=${sidecar.runId} sha256=${sidecar.sha256}${backfillNote}\n`;
         await fs.appendFile(logPath, logLine, "utf8");
-        return { sidecar, repairLogPath: logPath, guardPath };
+        return {
+            sidecar,
+            repairLogPath: logPath,
+            guardPath,
+            completedStageMetaBackfilled: backfilledStages
+        };
     });
 }
 export function flowStateGuardSidecarPathFor(projectRoot) {