@claude-flow/cli 3.42.5 → 3.43.0

package/dist/src/services/policy-runtime.js

@@ -42,11 +42,40 @@ async function acquireLock(lockPath) {
     }
     throw new Error('policy-state-lock-timeout');
 }
-function writeJsonAtomic(file, value) {
+// #3398: Windows rename over a file another process holds open fails with
+// EPERM/EBUSY/EACCES. Retry (~1.3s total, inside LOCK_WAIT_MS), never leave the
+// temp file; a final failure still throws — the state holds the receipt ledger
+// and consumed approval uses, so dropping it would let an approval be reused.
+const RENAME_RETRY_DELAYS_MS = [25, 50, 100, 150, 250, 300, 400];
+const TRANSIENT_RENAME_CODES = new Set(['EPERM', 'EBUSY', 'EACCES']);
+async function writeJsonAtomic(file, value) {
     mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
     const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
-    writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
-    renameSync(temporary, file);
+    let renamed = false;
+    try {
+        writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+        for (let attempt = 0;; attempt++) {
+            try {
+                renameSync(temporary, file);
+                renamed = true;
+                return;
+            }
+            catch (error) {
+                const code = error?.code ?? '';
+                if (!TRANSIENT_RENAME_CODES.has(code) || attempt >= RENAME_RETRY_DELAYS_MS.length)
+                    throw error;
+                await sleep(RENAME_RETRY_DELAYS_MS[attempt]);
+            }
+        }
+    }
+    finally {
+        if (!renamed) {
+            try {
+                unlinkSync(temporary);
+            }
+            catch { /* never created or already gone */ }
+        }
+    }
 }
 function trustPaths(projectRoot) {
     const trustRoot = join(userInfo().homedir, '.config', 'ruflo', 'policy-trust');
@@ -87,7 +116,7 @@ function verifyStateAnchor(projectRoot, state) {
         throw new Error('policy-state-authentication-failed');
     }
 }
-function writePolicyState(projectRoot, statePath, state) {
+async function writePolicyState(projectRoot, statePath, state) {
     const anchorPath = trustPaths(projectRoot).anchor;
     if (state.mode === 'enforce' || existsSync(anchorPath)) {
         const key = trustKey(projectRoot, true);
@@ -102,15 +131,15 @@ function writePolicyState(projectRoot, statePath, state) {
         // crash then leaves either a valid pair or an anchored mismatch that
         // fails closed; it can never leave enforce state silently unanchored.
         if (!existsSync(anchorPath)) {
-            writeJsonAtomic(anchorPath, anchor);
-            writeJsonAtomic(statePath, state);
+            await writeJsonAtomic(anchorPath, anchor);
+            await writeJsonAtomic(statePath, state);
             return;
         }
-        writeJsonAtomic(statePath, state);
-        writeJsonAtomic(anchorPath, anchor);
+        await writeJsonAtomic(statePath, state);
+        await writeJsonAtomic(anchorPath, anchor);
         return;
     }
-    writeJsonAtomic(statePath, state);
+    await writeJsonAtomic(statePath, state);
 }
 function detectLegacyCapabilities(projectRoot) {
     const candidates = [
@@ -179,7 +208,7 @@ export async function autoMigratePolicyStateIfNeeded(projectRoot = process.cwd()
                 state.mode = configured;
                 state.configuredMode = configured;
             }
-            writePolicyState(projectRoot, target.state, state);
+            await writePolicyState(projectRoot, target.state, state);
         }
     }
     finally {
@@ -202,7 +231,7 @@ export async function withPolicyTransaction(projectRoot, operation, options = {}
         const nextState = engine.exportState();
         if (!engine.verifyLedger().valid)
             throw new Error('policy-ledger-verification-failed');
-        writePolicyState(projectRoot, target.state, nextState);
+        await writePolicyState(projectRoot, target.state, nextState);
         return result;
     }
     finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.42.5",
+  "version": "3.43.0",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -143,12 +143,16 @@
   },
   "peerDependencies": {
     "@metaharness/router": "^0.4.0",
+    "@ruvector/typesafe": "^0.1.0",
     "metaharness": "^0.4.1"
   },
   "peerDependenciesMeta": {
     "@metaharness/router": {
       "optional": true
     },
+    "@ruvector/typesafe": {
+      "optional": true
+    },
     "metaharness": {
       "optional": true
     }