cclaw-cli 0.48.17 → 0.48.19

package/dist/content/node-hooks.js

@@ -118,26 +118,54 @@ async function writeFileAtomic(filePath, content, options = {}) {
     "." + path.basename(filePath) + ".tmp-" + process.pid + "-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8)
   );
   await fs.writeFile(tempPath, content, { encoding: "utf8" });
-  try {
-    await fs.rename(tempPath, filePath);
-    if (options.mode !== undefined) {
-      await fs.chmod(filePath, options.mode).catch(() => undefined);
-    }
-  } catch (error) {
-    const code = error && typeof error === "object" && "code" in error ? error.code : null;
-    if (code === "EXDEV") {
-      try {
-        await fs.copyFile(tempPath, filePath);
-      } finally {
-        await fs.unlink(tempPath).catch(() => undefined);
-      }
+  // Windows' fs.rename can fail transiently with EPERM/EBUSY/EACCES when the
+  // destination file is held open by another process (antivirus, indexer,
+  // or a sibling hook invocation racing on the same file). Retry with tiny
+  // backoff before falling back to copyFile.
+  const renameRetryableCodes = new Set(["EPERM", "EBUSY", "EACCES"]);
+  let attempt = 0;
+  const maxAttempts = 6;
+  while (true) {
+    try {
+      await fs.rename(tempPath, filePath);
       if (options.mode !== undefined) {
         await fs.chmod(filePath, options.mode).catch(() => undefined);
       }
       return;
+    } catch (error) {
+      const code = error && typeof error === "object" && "code" in error ? error.code : null;
+      if (code === "EXDEV") {
+        try {
+          await fs.copyFile(tempPath, filePath);
+        } finally {
+          await fs.unlink(tempPath).catch(() => undefined);
+        }
+        if (options.mode !== undefined) {
+          await fs.chmod(filePath, options.mode).catch(() => undefined);
+        }
+        return;
+      }
+      if (renameRetryableCodes.has(code) && attempt < maxAttempts) {
+        attempt += 1;
+        await hookSleep(10 * attempt + Math.floor(Math.random() * 10));
+        continue;
+      }
+      if (renameRetryableCodes.has(code)) {
+        // Last-resort fallback: copy-then-unlink. Not atomic, but the
+        // directory lock around this call already serializes writers.
+        try {
+          await fs.copyFile(tempPath, filePath);
+          if (options.mode !== undefined) {
+            await fs.chmod(filePath, options.mode).catch(() => undefined);
+          }
+          return;
+        } finally {
+          await fs.unlink(tempPath).catch(() => undefined);
+        }
+      }
+      await fs.unlink(tempPath).catch(() => undefined);
+      throw error;
     }
-    await fs.unlink(tempPath).catch(() => undefined);
-    throw error;
   }
 }
 

package/dist/fs-utils.js

@@ -75,35 +75,67 @@ export async function writeFileSafe(filePath, content, options = {}) {
     const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
     const targetMode = options.mode;
     await fs.writeFile(tempPath, content, { encoding: "utf8", ...(targetMode !== undefined ? { mode: targetMode } : {}) });
-    try {
-        await fs.rename(tempPath, filePath);
-        if (targetMode !== undefined) {
-            await fs.chmod(filePath, targetMode).catch(() => undefined);
+    // On Windows, `fs.rename` can fail transiently with EPERM / EBUSY / EACCES
+    // when the target file is briefly held open by another process (antivirus,
+    // search indexer, or a concurrent cclaw hook). Retry with small backoff
+    // before falling back to a non-atomic copy + unlink.
+    const renameRetryableCodes = new Set(["EPERM", "EBUSY", "EACCES"]);
+    let attempt = 0;
+    const maxAttempts = 6;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        try {
+            await fs.rename(tempPath, filePath);
+            if (targetMode !== undefined) {
+                await fs.chmod(filePath, targetMode).catch(() => undefined);
+            }
+            return;
         }
-    }
-    catch (error) {
-        const code = error?.code;
-        // `rename` fails with EXDEV when the temp file and target live on
-        // different filesystems (container bind mounts, tmpfs + rootfs,
-        // cross-volume setups). Fall back to copy + unlink so atomic writes
-        // still work — copyFile is not fully atomic but is the best we can
-        // do across devices, and we remove the temp even if copy fails.
-        if (code === "EXDEV") {
-            try {
-                await fs.copyFile(tempPath, filePath);
-                if (targetMode !== undefined) {
-                    await fs.chmod(filePath, targetMode).catch(() => undefined);
+        catch (error) {
+            const code = error?.code;
+            // `rename` fails with EXDEV when the temp file and target live on
+            // different filesystems (container bind mounts, tmpfs + rootfs,
+            // cross-volume setups). Fall back to copy + unlink so atomic writes
+            // still work — copyFile is not fully atomic but is the best we can
+            // do across devices, and we remove the temp even if copy fails.
+            if (code === "EXDEV") {
+                try {
+                    await fs.copyFile(tempPath, filePath);
+                    if (targetMode !== undefined) {
+                        await fs.chmod(filePath, targetMode).catch(() => undefined);
+                    }
+                }
+                finally {
+                    await fs.unlink(tempPath).catch(() => undefined);
                 }
+                return;
             }
-            finally {
-                await fs.unlink(tempPath).catch(() => undefined);
+            if (code !== undefined && renameRetryableCodes.has(code) && attempt < maxAttempts) {
+                attempt += 1;
+                const waitMs = 10 * attempt + Math.floor(Math.random() * 10);
+                await new Promise((resolve) => setTimeout(resolve, waitMs));
+                continue;
             }
-            return;
+            if (code !== undefined && renameRetryableCodes.has(code)) {
+                // Last-resort fallback on Windows: copy-then-unlink. Not atomic,
+                // but the caller is expected to have serialized via a directory
+                // lock so this only loses atomicity under extreme contention.
+                try {
+                    await fs.copyFile(tempPath, filePath);
+                    if (targetMode !== undefined) {
+                        await fs.chmod(filePath, targetMode).catch(() => undefined);
+                    }
+                    return;
+                }
+                finally {
+                    await fs.unlink(tempPath).catch(() => undefined);
+                }
+            }
+            // Other errors: try to clean up the temp to avoid littering the
+            // directory with orphaned `.tmp-<pid>-*` files, then rethrow.
+            await fs.unlink(tempPath).catch(() => undefined);
+            throw error;
         }
-        // Other errors: try to clean up the temp to avoid littering the
-        // directory with orphaned `.tmp-<pid>-*` files, then rethrow.
-        await fs.unlink(tempPath).catch(() => undefined);
-        throw error;
     }
 }
 export async function exists(filePath) {

package/dist/internal/tdd-red-evidence.js

@@ -89,14 +89,40 @@ function hasFailingAutoEvidenceForPath(entries, targetPath, options = {}) {
 export async function runTddRedEvidenceCommand(projectRoot, tokens, io) {
     const args = parseArgs(tokens);
     const flowState = await readFlowState(projectRoot).catch(() => null);
+    // Strict runId scoping: a previous implementation fell back to no
+    // filter when both `--runId` and `flowState.activeRunId` were missing,
+    // which let evidence rows from past runs satisfy the current check
+    // (false positive). Now: require an explicit or inferred runId or
+    // fail loud so the caller cannot silently inherit cross-run state.
     const effectiveRunId = args.runId ?? flowState?.activeRunId;
+    if (!effectiveRunId || effectiveRunId.trim().length === 0) {
+        const reason = "tdd-red-evidence: cannot scope check — no --runId provided and " +
+            "flow-state.json has no activeRunId. Pass --runId=<id> explicitly " +
+            "or run `cclaw doctor` to reconcile state.";
+        if (!args.quiet) {
+            io.stdout.write(`${JSON.stringify({
+                ok: false,
+                path: args.targetPath,
+                runId: null,
+                error: reason,
+                sources: { tddCycleLog: false, autoEvidence: false }
+            }, null, 2)}\n`);
+        }
+        else {
+            io.stderr.write(`${reason}\n`);
+        }
+        return 2;
+    }
     const tddLogPath = path.join(projectRoot, RUNTIME_ROOT, "state", "tdd-cycle-log.jsonl");
     const autoEvidencePath = path.join(projectRoot, RUNTIME_ROOT, "state", "tdd-red-evidence.jsonl");
     let cycleLogHasRed = false;
     let autoEvidenceHasRed = false;
     try {
         const raw = await fs.readFile(tddLogPath, "utf8");
-        const entries = parseTddCycleLog(raw);
+        // Strict parse: drop malformed/underspecified rows rather than
+        // backfilling runId=active / stage=tdd defaults, which used to
+        // silently glue foreign entries to the current run.
+        const entries = parseTddCycleLog(raw, { strict: true });
         cycleLogHasRed = hasFailingTestForPath(entries, args.targetPath, {
             runId: effectiveRunId
         });
@@ -119,7 +145,7 @@ export async function runTddRedEvidenceCommand(projectRoot, tokens, io) {
         io.stdout.write(`${JSON.stringify({
             ok: hasRed,
             path: args.targetPath,
-            runId: effectiveRunId ?? null,
+            runId: effectiveRunId,
             sources: {
                 tddCycleLog: cycleLogHasRed,
                 autoEvidence: autoEvidenceHasRed

package/dist/tdd-cycle.d.ts

@@ -22,7 +22,28 @@ export interface TddCycleValidation {
     openRedSlices: string[];
     sliceCount: number;
 }
-export declare function parseTddCycleLog(text: string): TddCycleEntry[];
+export interface TddCycleParseIssue {
+    lineNumber: number;
+    reason: string;
+    rawLine: string;
+}
+export interface ParseTddCycleLogOptions {
+    /**
+     * Collect one issue per dropped/malformed line. Callers that care
+     * (doctor, red-evidence) can surface them; hooks keep soft-fail.
+     */
+    issues?: TddCycleParseIssue[];
+    /**
+     * When true, reject lines that omit required fields instead of
+     * back-filling them with defaults. Used by validation paths
+     * (`validateTddCycleOrder`, `cclaw doctor`) to avoid silently
+     * bucketing unscoped rows into "runId=active, stage=tdd". Soft paths
+     * (generated hooks) keep the legacy defaults so a half-written file
+     * never takes the session down.
+     */
+    strict?: boolean;
+}
+export declare function parseTddCycleLog(text: string, options?: ParseTddCycleLogOptions): TddCycleEntry[];
 export declare function validateTddCycleOrder(entries: TddCycleEntry[], options?: {
     runId?: string;
 }): TddCycleValidation;

package/dist/tdd-cycle.js

@@ -1,41 +1,77 @@
-export function parseTddCycleLog(text) {
+export function parseTddCycleLog(text, options = {}) {
+    const issues = options.issues;
+    const strict = options.strict === true;
     const out = [];
     // Strip a leading UTF-8 BOM on the whole blob so the first line parses
     // cleanly; `trim()` handles BOM on subsequent lines through the same
     // codepath (empty/whitespace-only lines are skipped).
     const normalized = text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
-    for (const raw of normalized.split(/\r?\n/)) {
+    const lines = normalized.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+        const raw = lines[index] ?? "";
         const line = raw.trim();
         if (!line)
             continue;
+        const lineNumber = index + 1;
+        let parsed;
         try {
-            const parsed = JSON.parse(line);
-            const phase = parsed.phase;
-            if (phase !== "red" && phase !== "green" && phase !== "refactor") {
+            parsed = JSON.parse(line);
+        }
+        catch (err) {
+            issues?.push({
+                lineNumber,
+                reason: `json-parse-failed: ${err instanceof Error ? err.message : String(err)}`,
+                rawLine: raw
+            });
+            continue;
+        }
+        const phase = parsed.phase;
+        if (phase !== "red" && phase !== "green" && phase !== "refactor") {
+            issues?.push({
+                lineNumber,
+                reason: `invalid-phase: ${JSON.stringify(parsed.phase)}`,
+                rawLine: raw
+            });
+            continue;
+        }
+        const runIdField = typeof parsed.runId === "string" ? parsed.runId : null;
+        const stageField = typeof parsed.stage === "string" ? parsed.stage : null;
+        const sliceField = typeof parsed.slice === "string" ? parsed.slice : null;
+        if (strict) {
+            const missing = [];
+            if (!runIdField)
+                missing.push("runId");
+            if (!stageField)
+                missing.push("stage");
+            if (!sliceField)
+                missing.push("slice");
+            if (missing.length > 0) {
+                issues?.push({
+                    lineNumber,
+                    reason: `missing-required-fields: ${missing.join(",")}`,
+                    rawLine: raw
+                });
                 continue;
             }
-            const entry = {
-                ts: typeof parsed.ts === "string" ? parsed.ts : "",
-                runId: typeof parsed.runId === "string" ? parsed.runId : "active",
-                stage: typeof parsed.stage === "string" ? parsed.stage : "tdd",
-                slice: typeof parsed.slice === "string" ? parsed.slice : "S-unknown",
-                phase,
-                command: typeof parsed.command === "string" ? parsed.command : "",
-                files: Array.isArray(parsed.files)
-                    ? parsed.files.filter((item) => typeof item === "string")
-                    : undefined,
-                exitCode: typeof parsed.exitCode === "number" ? parsed.exitCode : undefined,
-                note: typeof parsed.note === "string" ? parsed.note : undefined,
-                acIds: Array.isArray(parsed.acIds)
-                    ? parsed.acIds
-                        .filter((item) => typeof item === "string" && item.length > 0)
-                    : undefined
-            };
-            out.push(entry);
-        }
-        catch {
-            // skip malformed line
         }
+        const entry = {
+            ts: typeof parsed.ts === "string" ? parsed.ts : "",
+            runId: runIdField ?? "active",
+            stage: stageField ?? "tdd",
+            slice: sliceField ?? "S-unknown",
+            phase,
+            command: typeof parsed.command === "string" ? parsed.command : "",
+            files: Array.isArray(parsed.files)
+                ? parsed.files.filter((item) => typeof item === "string")
+                : undefined,
+            exitCode: typeof parsed.exitCode === "number" ? parsed.exitCode : undefined,
+            note: typeof parsed.note === "string" ? parsed.note : undefined,
+            acIds: Array.isArray(parsed.acIds)
+                ? parsed.acIds
+                    .filter((item) => typeof item === "string" && item.length > 0)
+                : undefined
+        };
+        out.push(entry);
     }
     return out;
 }

package/package.json

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