claude-flow 3.45.0 → 3.46.1

package/v3/@claude-flow/cli/dist/src/services/policy-runtime.js

@@ -1,14 +1,39 @@
 import { AgenticPolicyEngine, createLegacyCompatibleState, isMcpCallerAuthEnabled, decodeTokenEnvelope, publicKeyFromHex, verifyInvocationToken, } from '@claude-flow/security';
 import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { closeSync, constants as fsConstants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readlinkSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { userInfo } from 'node:os';
+import { hostname, userInfo } from 'node:os';
 const POLICY_DIR = join('.claude-flow', 'policy');
 const POLICY_FILE = 'state.json';
 const LOCK_FILE = 'state.lock';
 const LOCK_STALE_MS = 30_000;
 const LOCK_WAIT_MS = 5_000;
+// A lock is ~170 bytes plus the hostname (at most 255 bytes).
+const LOCK_MAX_BYTES = 1_024;
+// Linux PID namespace of this process, e.g. `pid:[4026531836]`; undefined on
+// other platforms or without /proc. Recorded in the lock because a pid only
+// identifies a process inside the namespace that wrote it.
+const PID_NAMESPACE = (() => {
+    try {
+        return readlinkSync('/proc/self/ns/pid');
+    }
+    catch {
+        return undefined;
+    }
+})();
+// Linux boot id: one uuid per kernel boot, shared by every process on that
+// kernel and readable inside containers. Recorded because `host` is only a
+// name: two machines that share a project directory can report the same
+// hostname, and the init PID namespace has the same inode on every Linux host.
+const BOOT_ID = (() => {
+    try {
+        return readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim();
+    }
+    catch {
+        return undefined;
+    }
+})();
 function paths(projectRoot) {
     const root = resolve(projectRoot);
     const dir = join(root, POLICY_DIR);
@@ -17,12 +42,96 @@ function paths(projectRoot) {
 function sleep(ms) {
     return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
 }
+/**
+ * Signal-0 existence probe, as in #1799 (`isPidAlive` in swarm-tools.ts), but
+ * only ESRCH counts as dead (as `processIsAlive` in helper-refresh.ts): here a
+ * false "dead" breaks mutual exclusion, so EPERM (another user's process) and
+ * any unexpected error mean alive.
+ */
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code !== 'ESRCH';
+    }
+}
+/**
+ * Reads a lock only if it is a small regular file: never follows a symlink,
+ * never blocks on a FIFO or device, never reads more than LOCK_MAX_BYTES.
+ * Anything else returns undefined and the caller keeps the mtime rule.
+ */
+function readLockFile(lockPath) {
+    if (!lstatSync(lockPath).isFile())
+        return undefined;
+    const fd = openSync(lockPath, fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0) | (fsConstants.O_NONBLOCK ?? 0));
+    try {
+        const stat = fstatSync(fd);
+        if (!stat.isFile() || stat.size > LOCK_MAX_BYTES)
+            return undefined;
+        const buffer = Buffer.alloc(LOCK_MAX_BYTES);
+        return buffer.toString('utf8', 0, readSync(fd, buffer, 0, LOCK_MAX_BYTES, 0));
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/**
+ * A process killed inside a transaction (SIGKILL, OOM, or a signal whose
+ * default action terminates it) never runs `finally { release() }`, so every
+ * caller, MCP reads included, waited LOCK_WAIT_MS and failed with
+ * policy-state-lock-timeout until the orphan's mtime crossed LOCK_STALE_MS.
+ * The pid is trusted only if the lock was written by this OS, on this kernel
+ * boot and in this PID namespace: anywhere else (a bwrap --unshare-pid
+ * sandbox, a container, another machine on a shared filesystem) a live owner
+ * also answers ESRCH. Locks without that identity (older ruflo, a crash
+ * between create and write, anything unparsable) return false and keep the
+ * mtime rule.
+ */
+function lockOwnerIsDead(lockPath) {
+    try {
+        const read = readLockFile(lockPath);
+        if (read === undefined)
+            return false;
+        const owner = JSON.parse(read);
+        if (!owner || owner.host !== hostname() || owner.platform !== process.platform
+            || owner.pidns !== PID_NAMESPACE || owner.boot !== BOOT_ID)
+            return false;
+        // Without /proc, one Linux kernel boot or PID namespace cannot be told
+        // from another, and `host` is only a name.
+        if (process.platform === 'linux'
+            && (PID_NAMESPACE === undefined || BOOT_ID === undefined))
+            return false;
+        const pid = owner.pid;
+        if (typeof pid !== 'number' || !Number.isInteger(pid) || pid <= 0 || pid > 0x7fffffff
+            || isPidAlive(pid))
+            return false;
+        // The lock can change hands while it is read and probed (its owner
+        // releases and exits, another process acquires). Re-read it and answer
+        // only if it is byte for byte the lock that was read: the next owner's
+        // lock always differs in `pid` or `acquiredAt`. `dev`/`ino`/`ctime` cannot
+        // stand in for that — ext4 reuses a freed inode number at once, and before
+        // Linux 6.13 two files created in one clock tick share a ctime.
+        return readLockFile(lockPath) === read;
+    }
+    catch {
+        return false;
+    }
+}
 async function acquireLock(lockPath) {
     const started = Date.now();
     while (Date.now() - started < LOCK_WAIT_MS) {
         try {
             const fd = openSync(lockPath, 'wx', 0o600);
-            writeFileSync(fd, JSON.stringify({ pid: process.pid, acquiredAt: Date.now() }));
+            writeFileSync(fd, JSON.stringify({
+                pid: process.pid,
+                acquiredAt: Date.now(),
+                host: hostname(),
+                platform: process.platform,
+                pidns: PID_NAMESPACE,
+                boot: BOOT_ID,
+            }));
             closeSync(fd);
             return () => {
                 try {
@@ -33,7 +142,8 @@ async function acquireLock(lockPath) {
         }
         catch {
             try {
-                if (Date.now() - statSync(lockPath).mtimeMs > LOCK_STALE_MS)
+                if (lockOwnerIsDead(lockPath)
+                    || Date.now() - statSync(lockPath).mtimeMs > LOCK_STALE_MS)
                     unlinkSync(lockPath);
             }
             catch { /* another process changed the lock */ }

package/v3/@claude-flow/cli/dist/src/services/worker-daemon.js

@@ -14,6 +14,7 @@ import { EventEmitter } from 'events';
 import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync, unlinkSync } from 'fs';
 import { cpus } from 'os';
 import { join } from 'path';
+import { createRequire } from 'node:module';
 import { writeFileAtomic } from '../fs-secure.js';
 import { HeadlessWorkerExecutor, isHeadlessWorker, } from './headless-worker-executor.js';
 // ADR-174 M3: the consolidate worker below drives the real DISTILL/CONSOLIDATE
@@ -26,6 +27,9 @@ import { backupMemoryDb } from './memory-backup.js';
 import { resolveGitWorkspaceIdentity } from './git-workspace-identity.js';
 import { getWorkspaceLeaseRegistry } from './workspace-lease.js';
 import { getRepoSupervisorRegistry } from './repo-supervisor.js';
+// Daemon config is read synchronously from the constructor. In an ESM build,
+// bare `require` is undefined, so use a module-relative require for YAML.
+const requireYaml = createRequire(import.meta.url);
 // Default worker configurations with improved intervals (P0 fix: map 5min -> 15min)
 const DEFAULT_WORKERS = [
     { type: 'map', intervalMs: 15 * 60 * 1000, offsetMs: 0, priority: 'normal', description: 'Codebase mapping', enabled: true },
@@ -368,8 +372,7 @@ export class WorkerDaemon extends EventEmitter {
             try {
                 // Lazy-load yaml so the daemon doesn't hard-require it; if the
                 // dep isn't installed, fall back to the previous warn-only path.
-                // eslint-disable-next-line @typescript-eslint/no-var-requires
-                const yamlMod = require('yaml');
+                const yamlMod = requireYaml('yaml');
                 const parsed = yamlMod.parse(readFileSync(yPath, 'utf-8'));
                 if (parsed && typeof parsed === 'object') {
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -1013,7 +1016,9 @@ export class WorkerDaemon extends EventEmitter {
             return `max age ${Math.round(ttlMs / 1000)}s reached`;
         }
         if (idleMs > 0) {
-            const lastActivity = this.lastWorkerActivityMs() ?? startedMs;
+            // Worker timestamps survive restarts; they cannot make this process
+            // idle before it has been alive for a full idle window (#3194).
+            const lastActivity = Math.max(this.lastWorkerActivityMs() ?? startedMs, startedMs);
             if (now - lastActivity >= idleMs) {
                 return `idle for ${Math.round(idleMs / 1000)}s (no worker activity)`;
             }

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.45.0",
+  "version": "3.46.1",
   "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",
@@ -98,10 +98,10 @@
     "vitest": "^4.1.0"
   },
   "dependencies": {
-    "@claude-flow/cli-core": "3.7.0-alpha.5",
+    "@claude-flow/cli-core": "3.7.0-alpha.6",
     "@claude-flow/codex": "3.0.3",
     "@claude-flow/mcp": "3.0.0-alpha.10",
-    "@claude-flow/neural": "3.0.0-alpha.9",
+    "@claude-flow/neural": "3.0.0-alpha.10",
     "@claude-flow/plugin-agent-federation": "1.0.0-alpha.18",
     "@claude-flow/security": "3.0.0-alpha.14",
     "@claude-flow/shared": "3.0.0-alpha.7",
@@ -125,11 +125,11 @@
     "ws": "^8.21.0",
     "yaml": "^2.8.0",
     "zod": "^3.22.0",
-    "@claude-flow/memory": "3.0.0-alpha.25"
+    "@claude-flow/memory": "3.0.0-alpha.26"
   },
   "optionalDependencies": {
     "@agntcy/slim-bindings": "2.0.0-alpha.5",
-    "@claude-flow/memory": "3.0.0-alpha.25",
+    "@claude-flow/memory": "3.0.0-alpha.26",
     "@metaharness/darwin": "~0.10.2",
     "@metaharness/flywheel": "~0.1.10",
     "@metaharness/radio": "~0.1.0",

package/.claude/.proven-config-version

@@ -1 +0,0 @@
-sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319

package/.claude/proven-config.json

@@ -1,42 +0,0 @@
-{
-  "adoptedAt": 1790287605043,
-  "championId": "sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319",
-  "manifest": {
-    "schema": "ruflo.proven-config/v1",
-    "policy": {
-      "ref": "sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319",
-      "value": {
-        "alpha": 0.3,
-        "subjectWeight": 1,
-        "mmrLambda": 0.5,
-        "bodyWeight": 1.5,
-        "typePenaltyFactor": 0.5
-      }
-    },
-    "layer": "framework/node-cli",
-    "compatibility": {
-      "ruflo": ">=3.24.0"
-    },
-    "benchmark": {
-      "corpus": "ADR-081-labelled-v1",
-      "corpusHash": "sha256:2f700b5c363e20a3bd88ce2bc9b87bbbbaa61732c6177894c6ec37890f888982"
-    },
-    "receipt": {
-      "heldOutDelta": 0.07381404928570845,
-      "redblue": "PASS",
-      "drift": 0,
-      "canary": {
-        "rollbackRate": 0,
-        "latencyP95": 244.612458000076,
-        "costPerTask": 0
-      },
-      "receiptCoverage": 1
-    },
-    "platform": [
-      "linux",
-      "macOS",
-      "windows"
-    ]
-  },
-  "previous": ""
-}