cclaw-cli 6.13.1 → 6.14.1

package/dist/install.js

@@ -1003,6 +1003,90 @@ async function applyPlanLegacyContinuationIfNeeded(projectRoot) {
         // Best-effort: corrupt/missing state is handled elsewhere on sync.
     }
 }
+/**
+ * v6.14.0 — set stream-style defaults on `cclaw-cli sync` and print a
+ * one-line hint when defaults change. Strategy:
+ *
+ * - When `legacyContinuation: true` and `tddCheckpointMode` is unset, force
+ *   `tddCheckpointMode: "global-red"` (preserves hox wave protocol).
+ * - When `legacyContinuation: true` and `integrationOverseerMode` is unset,
+ *   force `integrationOverseerMode: "always"` (preserves v6.13 behavior).
+ * - When `legacyContinuation` is NOT true (new / standard projects) and
+ *   neither field is set, default to `tddCheckpointMode: "per-slice"`,
+ *   `integrationOverseerMode: "conditional"`. Also default
+ *   `worktreeExecutionMode: "worktree-first"` if unset.
+ *
+ * Returns a one-line hint string (or `null` if nothing changed) so callers
+ * can print it through the standard sync hint surface.
+ */
+async function applyV614DefaultsIfNeeded(projectRoot) {
+    // Defensive read — match `applyTddCutoverIfNeeded`'s pattern (raw +
+    // JSON.parse) so corrupt state is left untouched for the downstream
+    // fail-fast check in `materializeRuntime` (which expects to see the
+    // CorruptFlowStateError surfaced via `ensureRunSystem`). Calling
+    // `readFlowState` directly would quarantine the corrupt file and hide
+    // the failure from the caller.
+    const flowStatePath = runtimePath(projectRoot, "state", "flow-state.json");
+    let flowStateRaw;
+    try {
+        flowStateRaw = await fs.readFile(flowStatePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(flowStateRaw);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return null;
+    }
+    const obj = parsed;
+    const updates = {};
+    const summary = [];
+    const tddCheckpointModeSet = obj.tddCheckpointMode === "per-slice" || obj.tddCheckpointMode === "global-red";
+    const integrationOverseerModeSet = obj.integrationOverseerMode === "conditional" || obj.integrationOverseerMode === "always";
+    const worktreeExecutionModeSet = obj.worktreeExecutionMode === "worktree-first" || obj.worktreeExecutionMode === "single-tree";
+    const legacyContinuation = obj.legacyContinuation === true;
+    if (legacyContinuation) {
+        if (!tddCheckpointModeSet) {
+            updates.tddCheckpointMode = "global-red";
+            summary.push("tddCheckpointMode=global-red (legacyContinuation)");
+        }
+        if (!integrationOverseerModeSet) {
+            updates.integrationOverseerMode = "always";
+            summary.push("integrationOverseerMode=always (legacyContinuation)");
+        }
+    }
+    else {
+        if (!tddCheckpointModeSet) {
+            updates.tddCheckpointMode = "per-slice";
+            summary.push("tddCheckpointMode=per-slice");
+        }
+        if (!integrationOverseerModeSet) {
+            updates.integrationOverseerMode = "conditional";
+            summary.push("integrationOverseerMode=conditional");
+        }
+        if (!worktreeExecutionModeSet) {
+            updates.worktreeExecutionMode = "worktree-first";
+            summary.push("worktreeExecutionMode=worktree-first");
+        }
+    }
+    if (summary.length === 0) {
+        return null;
+    }
+    const merged = { ...obj, ...updates };
+    try {
+        await writeFileSafe(flowStatePath, `${JSON.stringify(merged, null, 2)}\n`, { mode: 0o600 });
+    }
+    catch {
+        return null;
+    }
+    return `v6.14.0 stream-style defaults applied: ${summary.join(", ")}. To opt out, edit .cclaw/state/flow-state.json directly or pin the legacy mode (tddCheckpointMode="global-red", integrationOverseerMode="always").`;
+}
 async function cleanLegacyArtifacts(projectRoot) {
     for (const legacyFolder of DEPRECATED_UTILITY_SKILL_FOLDERS) {
         await removeBestEffort(runtimePath(projectRoot, "skills", legacyFolder), true);
@@ -1178,6 +1262,10 @@ async function materializeRuntime(projectRoot, config, forceStateReset, operatio
         if (operation === "sync" || operation === "upgrade") {
             await applyTddCutoverIfNeeded(projectRoot);
             await applyPlanLegacyContinuationIfNeeded(projectRoot);
+            const v614Hint = await applyV614DefaultsIfNeeded(projectRoot);
+            if (v614Hint) {
+                process.stdout.write(`cclaw: ${v614Hint}\n`);
+            }
         }
         try {
             await ensureRunSystem(projectRoot, { createIfMissing: false });

package/dist/run-persistence.js

@@ -473,6 +473,8 @@ function coerceFlowState(parsed) {
     const completedStageMeta = sanitizeCompletedStageMeta(parsed.completedStageMeta);
     const tddCutoverSliceId = coerceTddCutoverSliceId(parsed.tddCutoverSliceId);
     const worktreeExecutionMode = coerceWorktreeExecutionMode(parsed.worktreeExecutionMode);
+    const tddCheckpointMode = coerceTddCheckpointMode(parsed.tddCheckpointMode);
+    const integrationOverseerMode = coerceIntegrationOverseerMode(parsed.integrationOverseerMode);
     const legacyContinuation = typeof parsed.legacyContinuation === "boolean" ? parsed.legacyContinuation : undefined;
     const state = {
         schemaVersion: FLOW_STATE_SCHEMA_VERSION,
@@ -488,6 +490,8 @@ function coerceFlowState(parsed) {
         ...(completedStageMeta ? { completedStageMeta } : {}),
         ...(tddCutoverSliceId ? { tddCutoverSliceId } : {}),
         ...(worktreeExecutionMode !== undefined ? { worktreeExecutionMode } : {}),
+        ...(tddCheckpointMode !== undefined ? { tddCheckpointMode } : {}),
+        ...(integrationOverseerMode !== undefined ? { integrationOverseerMode } : {}),
         ...(legacyContinuation !== undefined ? { legacyContinuation } : {}),
         skippedStages: sanitizeSkippedStages(parsed.skippedStages, track),
         staleStages: sanitizeStaleStages(parsed.staleStages),
@@ -514,6 +518,16 @@ function coerceWorktreeExecutionMode(value) {
         return value;
     return undefined;
 }
+function coerceTddCheckpointMode(value) {
+    if (value === "per-slice" || value === "global-red")
+        return value;
+    return undefined;
+}
+function coerceIntegrationOverseerMode(value) {
+    if (value === "conditional" || value === "always")
+        return value;
+    return undefined;
+}
 export class CorruptFlowStateError extends Error {
     statePath;
     quarantinedPath;

package/package.json

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