@claude-flow/cli 3.45.0 → 3.46.0

package/.claude/helpers/helpers.manifest.json

@@ -1,6 +1,6 @@
 {
   "manifest": {
-    "version": "3.45.0",
+    "version": "3.46.0",
     "files": {
       "auto-memory-hook.mjs": "85fe05c757421c52137c0bc8545a0896bab6b4714538c2a11d1d0835bfcc8c1c",
       "hook-handler.cjs": "209d9fafe10e17d1be0866727f6f9cf9ac66f9a0793f1c793a4f58319e8e4583",
@@ -9,6 +9,6 @@
       "router.js": "b6998397e7883191b62229ccdc66fb87f1ccca1d5b2039ecb8c1e686d1ad81f8"
     }
   },
-  "signature": "IO42tJDeyKIl8l7ewYgoPdlZqQdsESvjIJr3KoAHDYHTi7gMCElwEyah4jx/RC6+Lq2zXv8XSOd/cgHI2U5zAg==",
+  "signature": "LwKXka3qAKGSIVpcv4vpg5vlv8CFHolvyCQwzW0hNvPIn7Un3+qpidc7drdoDzsrNyzx3gnZJBFEWeXxlTabDA==",
   "algorithm": "ed25519"
 }

package/README.md

@@ -19,6 +19,8 @@
 
 # Ruflo
 
+[English](README.md) · [简体中文](README.zh-CN.md)
+
 **An agent meta-harness for Claude Code and Codex.**
 
 [![RuFlo Explained — build an AI team that plans, remembers, tests, and improves](docs/assets/ruflo-explained/ch14.jpg)](docs/ruflo-explained.md)

package/bin/cli.js

@@ -164,6 +164,8 @@ const isMCPMode = !process.stdin.isTTY
 if (isMCPMode) {
   // Run MCP server mode
   const { listMCPTools, callMCPTool, hasTool } = await import('../dist/src/mcp-client.js');
+  const { isPolicyEnforcementEnabled, loadMcpPolicy, evaluateToolCall } =
+    await import('../dist/src/mcp-tools/policy-enforcer.js');
 
   const VERSION = '3.0.0';
   const sessionId = `mcp-${Date.now()}-${randomUUID().slice(0, 8)}`;
@@ -287,6 +289,17 @@ if (isMCPMode) {
           };
         }
 
+        if (isPolicyEnforcementEnabled()) {
+          const check = evaluateToolCall(loadMcpPolicy(), sessionId, toolName);
+          if (!check.allowed) {
+            return {
+              jsonrpc: '2.0',
+              id: message.id,
+              error: { code: -32001, message: `Policy denied: ${check.reason}` },
+            };
+          }
+        }
+
         try {
           const result = await callMCPTool(toolName, toolParams, { sessionId });
           return {

package/bin/mcp-server.js

@@ -28,6 +28,11 @@ console.log = (...args) => {
 };
 
 import { listMCPTools, callMCPTool, hasTool } from '../dist/src/mcp-client.js';
+import {
+  isPolicyEnforcementEnabled,
+  loadMcpPolicy,
+  evaluateToolCall,
+} from '../dist/src/mcp-tools/policy-enforcer.js';
 
 const VERSION = '3.0.0';
 const sessionId = `mcp-${Date.now()}-${randomUUID().slice(0, 8)}`;
@@ -173,6 +178,17 @@ async function handleMessage(message) {
           };
         }
 
+        if (isPolicyEnforcementEnabled()) {
+          const check = evaluateToolCall(loadMcpPolicy(), sessionId, toolName);
+          if (!check.allowed) {
+            return {
+              jsonrpc: '2.0',
+              id: message.id,
+              error: { code: -32001, message: `Policy denied: ${check.reason}` },
+            };
+          }
+        }
+
         try {
           const result = await callMCPTool(toolName, toolParams, { sessionId });
           return {

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 6,
-  "generatedAt": "2026-09-24T22:48:10.625Z",
-  "gitSha": "aab1d625",
+  "generatedAt": "2026-09-26T22:32:39.004Z",
+  "gitSha": "39ea61fd",
   "catalog": {
     "agents": 167,
     "tools": 418,

package/dist/src/commands/doctor.d.ts

@@ -11,6 +11,9 @@ interface HealthCheck {
     message: string;
     fix?: string;
 }
+/** ADR-122 Phase 0: probe only the CLI version, without launching a browser. */
+export declare function evaluateAgentBrowserVersion(rawOutput: string): HealthCheck;
+export declare function checkAgentBrowserVersion(probe?: () => Promise<string>): Promise<HealthCheck>;
 export declare function checkMemoryPersistenceDriver(): Promise<HealthCheck>;
 /**
  * #3392: pure verdict for "does the @claude-flow/memory the CLI loads satisfy

package/dist/src/commands/doctor.js

@@ -9,7 +9,7 @@ import { existsSync, readFileSync, statSync, openSync, readSync, closeSync } fro
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
-import { execSync, exec } from 'child_process';
+import { execSync, exec, execFile } from 'child_process';
 import { promisify } from 'util';
 import { decodeKey, isEncryptionEnabled } from '../encryption/vault.js';
 import { isEncryptedBlob } from '../encryption/vault.js';
@@ -17,6 +17,7 @@ import * as semver from 'semver';
 import { resolveMemoryPackageFromProject, resolveMemoryPackageFromCli, readMemoryPackageVersion, recordMemoryPackagePath, } from '../init/memory-package-resolver.js';
 // Promisified exec with proper shell and env inheritance for cross-platform support
 const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 /**
  * Execute command asynchronously with proper environment inheritance
  * Critical for Windows where PATH may not be inherited properly
@@ -62,6 +63,39 @@ async function checkNpmVersion() {
         return { name: 'npm Version', status: 'fail', message: 'npm not found', fix: 'Install Node.js from https://nodejs.org' };
     }
 }
+/** ADR-122 Phase 0: probe only the CLI version, without launching a browser. */
+export function evaluateAgentBrowserVersion(rawOutput) {
+    const name = 'agent-browser CLI (ADR-122)';
+    const fix = 'npm install -g agent-browser@latest';
+    const versionOutput = rawOutput.trim().replace(/\x1b\[[0-9;]*m/g, '');
+    const match = /^(?:agent-browser(?:\s+version)?\s+)?v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)(?:\s|$)/i.exec(versionOutput);
+    const version = match ? semver.parse(match[1]) : null;
+    if (!version) {
+        return { name, status: 'warn', message: `Unable to parse agent-browser version${versionOutput ? `: ${versionOutput.slice(0, 120)}` : ' (empty output)'}. Browser MCP tools may be unavailable.`, fix };
+    }
+    if (semver.lt(version, '0.27.0')) {
+        return { name, status: 'warn', message: `v${version.version} is below the ADR-122 v0.27.0 minimum for browser MCP tools`, fix };
+    }
+    return { name, status: 'pass', message: `v${version.version} meets the ADR-122 v0.27.0 minimum for browser MCP tools` };
+}
+export async function checkAgentBrowserVersion(probe = async () => {
+    const { stdout } = await execFileAsync('agent-browser', ['--version'], {
+        encoding: 'utf8', timeout: 3000, maxBuffer: 16 * 1024, windowsHide: true,
+    });
+    return String(stdout);
+}) {
+    try {
+        return evaluateAgentBrowserVersion(await probe());
+    }
+    catch (error) {
+        const name = 'agent-browser CLI (ADR-122)';
+        const fix = 'npm install -g agent-browser@latest';
+        const code = error.code;
+        return code === 'ENOENT'
+            ? { name, status: 'warn', message: 'Not found on PATH; @claude-flow/browser and browser MCP tools need agent-browser v0.27.0 or newer', fix }
+            : { name, status: 'warn', message: `Version check failed: ${error instanceof Error ? error.message : String(error)}`, fix };
+    }
+}
 // Check config file
 async function checkConfigFile() {
     // JSON configs (parse-validated). The first three are LEGACY shapes from
@@ -306,6 +340,22 @@ async function resolveMemoryDbPath() {
             return p;
     return null;
 }
+/** Native AgentDB writes to a plaintext sibling of the sql.js memory file.
+ * Probe only stores that already exist: projects without the native bridge
+ * should not acquire an extra warning just by running doctor (#3195). */
+async function existingNativeAgentDbPaths() {
+    const candidates = new Set();
+    try {
+        const { getMemoryRoot, resolveDbPath } = await import('../memory/memory-initializer.js');
+        candidates.add(join(getMemoryRoot(), 'agentdb-memory.db'));
+        // Explicit CLAUDE_FLOW_DB_PATH callers may put the sibling elsewhere.
+        candidates.add(join(dirname(resolveDbPath()), 'agentdb-memory.db'));
+    }
+    catch {
+        candidates.add(join(process.cwd(), '.swarm', 'agentdb-memory.db'));
+    }
+    return [...candidates].filter((path) => existsSync(path));
+}
 /** Open a sql.js Database over an on-disk file, returning null when the
  * file can't be opened as a SQLite database (encrypted / corrupted / not
  * a database). Callers decide whether that's warn or fail. */
@@ -507,6 +557,79 @@ async function checkMemoryStructuralIntegrity() {
         catch { /* best-effort */ }
     }
 }
+/** Check the AgentDB authority independently from the legacy memory.db.
+ * Opening read-only with SQLite keeps WAL commits visible without mutating
+ * either store; the existing legacy health checks retain their own scope. */
+async function checkNativeAgentDbStructuralIntegrity(dbPath) {
+    const NAME = 'Native AgentDB Structural Integrity (quick_check)';
+    if (!existsSync(dbPath)) {
+        return { name: NAME, status: 'warn', message: `${dbPath} disappeared before the native check could run` };
+    }
+    if (isMemoryDbEncryptedAtRest(dbPath)) {
+        return {
+            name: NAME,
+            status: 'fail',
+            message: `${dbPath} — RFE1-encrypted; native AgentDB requires a plaintext SQLite file`,
+            fix: `back up ${dbPath} and restore a usable native AgentDB database`,
+        };
+    }
+    let Database;
+    try {
+        Database = (await import('better-sqlite3')).default;
+    }
+    catch {
+        return {
+            name: NAME,
+            status: 'warn',
+            message: `${dbPath} — better-sqlite3 not installed; native AgentDB structural health is unverified`,
+            fix: 'install better-sqlite3 with npm install scripts enabled, then rerun this check',
+        };
+    }
+    let db;
+    try {
+        db = new Database(dbPath, { readonly: true, fileMustExist: true });
+    }
+    catch (error) {
+        if (isNativeSqliteBindingUnavailable(error)) {
+            return nativeBindingUnavailableCheck(NAME, dbPath, error, '[native AgentDB structural health unverified]');
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            name: NAME,
+            status: 'fail',
+            message: `${dbPath} — better-sqlite3 failed to open: ${message} [native AgentDB]`,
+            fix: `back up ${dbPath} and its WAL sidecars, then restore a known-good native AgentDB database`,
+        };
+    }
+    try {
+        const rows = db.pragma('quick_check');
+        const values = rows.map((row) => String(Object.values(row)[0]));
+        if (values.length === 1 && values[0] === 'ok') {
+            return { name: NAME, status: 'pass', message: `${dbPath} — PRAGMA quick_check: ok [native AgentDB, WAL-aware]` };
+        }
+        return {
+            name: NAME,
+            status: 'fail',
+            message: `${dbPath} — PRAGMA quick_check: ${values.slice(0, 3).join('; ')}${values.length > 3 ? ` (+${values.length - 3} more)` : ''} [native AgentDB]`,
+            fix: `back up ${dbPath} and its WAL sidecars, then restore a known-good native AgentDB database`,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            name: NAME,
+            status: 'fail',
+            message: `${dbPath} — quick_check probe threw: ${message} [native AgentDB]`,
+            fix: `back up ${dbPath} and its WAL sidecars, then restore a known-good native AgentDB database`,
+        };
+    }
+    finally {
+        try {
+            db.close();
+        }
+        catch { /* best-effort */ }
+    }
+}
 // #2968/#3321 — read-only native SQLite capability probe. A skipped
 // postinstall can leave the wrapper importable but its binding unavailable.
 // Schema size cannot identify the runtime driver or the database's history:
@@ -2337,7 +2460,7 @@ export const doctorCommand = {
         {
             name: 'component',
             short: 'c',
-            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, mcp-overhead, claude, disk, typescript, agentic-flow, encryption, federation, funnel, proxy, auth, typesafe, metaharness)',
+            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, mcp-overhead, claude, browser, disk, typescript, agentic-flow, encryption, federation, funnel, proxy, auth, typesafe, metaharness)',
             type: 'string'
         },
         {
@@ -2444,11 +2567,14 @@ export const doctorCommand = {
         output.writeln(output.dim('System diagnostics and health check'));
         output.writeln(output.dim('─'.repeat(50)));
         output.writeln();
+        const nativeAgentDbChecks = (await existingNativeAgentDbPaths())
+            .map((dbPath) => () => checkNativeAgentDbStructuralIntegrity(dbPath));
         const allChecks = [
             checkVersionFreshness,
             checkNodeVersion,
             checkNpmVersion,
             checkClaudeCode,
+            checkAgentBrowserVersion, // ADR-122 Phase 0 — browser runtime compatibility
             checkGit,
             checkGitRepo,
             checkConfigFile,
@@ -2456,6 +2582,7 @@ export const doctorCommand = {
             checkDaemonStatus,
             checkMemoryDatabase,
             checkMemoryStructuralIntegrity, // #2737 — bounded, native quick_check on every default run
+            ...nativeAgentDbChecks, // #3195 — verify each present native authority file
             checkMemoryPersistenceDriver, // #2968/#3321 — read-only native capability probe
             checkLearningBridge, // #2545 — can the auto-memory hook actually load @claude-flow/memory?
             checkMemoryPackageVersion, // #3392 — loaded @claude-flow/memory must satisfy the CLI's declared range
@@ -2489,12 +2616,14 @@ export const doctorCommand = {
             'node': checkNodeVersion,
             'npm': checkNpmVersion,
             'claude': checkClaudeCode,
+            'browser': checkAgentBrowserVersion,
             'config': checkConfigFile,
             'stale-settings': checkStaleSettingsNpx, // #2448
             'daemon': checkDaemonStatus,
             'memory': [
                 checkMemoryDatabase, // existing: exists + statable (unchanged)
                 checkMemoryIntegrity, // #2677 check 1: sql.js open + PRAGMA integrity_check
+                ...nativeAgentDbChecks, // #3195: present AgentDB authority, checked independently
                 checkMemoryPersistenceDriver, // #2968/#3321: read-only native capability probe
                 checkMemoryPackageVersion, // #3392: loaded memory package satisfies the declared range
                 checkMemoryContent, // #2677 check 2: memory_entries content coverage

package/dist/src/commands/embeddings.js

@@ -679,7 +679,12 @@ const initCommand = {
             if (!fs.existsSync(modelDir)) {
                 fs.mkdirSync(modelDir, { recursive: true });
             }
-            // Download model if requested
+            // Download model if requested. #3376: record what actually happened
+            // instead of assuming the download ran — `getEmbeddings()` returns null
+            // whenever the optional @claude-flow/embeddings package is absent, which
+            // is every plain `npm i -g ruflo` install.
+            let modelDownloaded = false;
+            let modelSkipReason = null;
             if (download) {
                 spinner.setText(`Downloading ONNX model: ${model}...`);
                 const embeddings = await getEmbeddings();
@@ -687,13 +692,19 @@ const initCommand = {
                     await embeddings.downloadEmbeddingModel(model, modelDir, (p) => {
                         spinner.setText(`Downloading ${model}... ${p.percent.toFixed(0)}%`);
                     });
+                    modelDownloaded = true;
                 }
                 else {
-                    // Embeddings package not available — skip download
-                    await new Promise(r => setTimeout(r, 500));
-                    output.writeln(output.dim('  (Skipped — @claude-flow/embeddings not installed)'));
+                    // No download happened. That is the outcome of this command, not an
+                    // aside — reported below via spinner.fail + a warning, never as a
+                    // dimmed note on a success path. No fake progress delay: there is
+                    // nothing in progress.
+                    modelSkipReason = '@claude-flow/embeddings is not installed';
                 }
             }
+            else {
+                modelSkipReason = 'download disabled by --no-download';
+            }
             // Write embeddings config
             spinner.setText('Writing configuration...');
             const dimension = model.includes('mpnet') ? 768 : 384;
@@ -702,6 +713,12 @@ const initCommand = {
                 modelPath: modelDir,
                 dimension,
                 cacheSize,
+                // #3376: additive, optional fields. `modelPath` keeps its old meaning
+                // (the directory the model belongs in), but it no longer implies a
+                // model is in it — `modelDownloaded` says whether one is. Readers that
+                // predate these keys are unaffected; they ignore unknown properties.
+                modelDownloaded,
+                ...(modelSkipReason ? { modelSkipReason } : {}),
                 hyperbolic: {
                     enabled: hyperbolic,
                     curvature,
@@ -716,7 +733,15 @@ const initCommand = {
                 initialized: new Date().toISOString(),
             };
             fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-            spinner.succeed('Embedding subsystem initialized');
+            // A download that was asked for and did not happen is a failed init:
+            // the only substantive step of `embeddings init` did not run. #3376.
+            const downloadSkipped = download && !modelDownloaded;
+            if (downloadSkipped) {
+                spinner.fail('Embedding model NOT downloaded — embedding subsystem is not ready');
+            }
+            else {
+                spinner.succeed('Embedding subsystem initialized');
+            }
             output.writeln();
             output.printTable({
                 columns: [
@@ -725,6 +750,7 @@ const initCommand = {
                 ],
                 data: [
                     { setting: 'Model', value: model },
+                    { setting: 'Model Status', value: modelDownloaded ? output.success('Downloaded') : output.error('NOT downloaded') },
                     { setting: 'Dimension', value: String(dimension) },
                     { setting: 'Cache Size', value: String(cacheSize) + ' entries' },
                     { setting: 'Hyperbolic', value: hyperbolic ? `${output.success('Enabled')} (c=${curvature})` : output.dim('Disabled') },
@@ -733,6 +759,20 @@ const initCommand = {
                     { setting: 'Config', value: configPath },
                 ],
             });
+            if (downloadSkipped) {
+                output.writeln();
+                output.printWarning(`No embedding model was installed: ${modelSkipReason}.`);
+                output.printWarning('Until a real embedder is present, embeddings fall back to hash vectors, which carry no semantic meaning.');
+                output.printInfo(`Configuration was still written to ${configPath}, recording "modelDownloaded": false.`);
+                output.writeln();
+                output.writeln(output.dim('To finish initializing:'));
+                output.printList([
+                    'npm install @claude-flow/embeddings   - the package this command downloads with; then: embeddings init --force',
+                    'npm install ruvector                  - the other real embedder ruflo accepts; needs no download step',
+                    'embeddings init --no-download --force - keep this configuration without a model (exits 0)',
+                ]);
+                return { success: false, exitCode: 1, data: config };
+            }
             output.writeln();
             if (hyperbolic) {
                 output.printBox([
@@ -1182,8 +1222,11 @@ const modelsCommand = {
                 }
             }
             else {
-                await new Promise(r => setTimeout(r, 500));
-                spinner.succeed(`Download skipped — @claude-flow/embeddings not installed`);
+                // #3376, same class as `init`: nothing was downloaded, so this is a
+                // failure, not a success with a caveat. No fake progress delay either.
+                spinner.fail(`Download skipped — @claude-flow/embeddings is not installed`);
+                output.printWarning(`"${download}" was not downloaded. Install @claude-flow/embeddings to enable model downloads.`);
+                return { success: false, exitCode: 1 };
             }
             return { success: true };
         }

package/dist/src/commands/init.js

@@ -113,7 +113,9 @@ export function runCodexInitializerCli(cwd, options) {
 // init) and scripted `--format json` output.
 async function maybeAutoDetectCodex(ctx, options) {
     try {
-        if (ctx.flags['no-codex-detect'] === true)
+        // The CLI parser turns `--no-codex-detect` into `codexDetect: false`.
+        // Retain the literal key for programmatic CommandContext callers.
+        if (ctx.flags.codexDetect === false || ctx.flags['no-codex-detect'] === true)
             return;
         if (ctx.flags.format === 'json')
             return; // scripted output stays pure
@@ -295,7 +297,8 @@ function isBloatedRufloSkillDir(dir) {
 }
 async function maybeInstallSkillsSh(ctx) {
     try {
-        if (ctx.flags['no-skills-sh'] === true)
+        // The CLI parser turns `--no-skills-sh` into `skillsSh: false`.
+        if (ctx.flags.skillsSh === false || ctx.flags['no-skills-sh'] === true)
             return;
         if (ctx.flags.format === 'json')
             return;

package/dist/src/commands/mcp.js

@@ -66,6 +66,11 @@ const startCommand = {
             description: 'Tools to advertise (comma-separated categories, prefixes, exact names, or "all")',
             type: 'string'
         },
+        {
+            name: 'request-timeout-ms',
+            description: 'HTTP request timeout in milliseconds (default 30000; env RUFLO_MCP_REQUEST_TIMEOUT_MS)',
+            type: 'number'
+        },
         {
             name: 'daemon',
             short: 'd',
@@ -84,6 +89,7 @@ const startCommand = {
     examples: [
         { command: 'claude-flow mcp start', description: 'Start with defaults (stdio)' },
         { command: 'claude-flow mcp start -p 8080 -t http', description: 'Start HTTP server' },
+        { command: 'claude-flow mcp start -t http --request-timeout-ms 120000', description: 'Allow slower cold-start HTTP tools' },
         { command: 'claude-flow mcp start -d', description: 'Start as daemon' },
         { command: 'claude-flow mcp start -f', description: 'Force restart (kill existing)' }
     ],
@@ -94,6 +100,15 @@ const startCommand = {
         const tools = ctx.flags.tools
             || process.env.CLAUDE_FLOW_MCP_TOOLS
             || 'all';
+        const timeoutInput = ctx.flags.requestTimeoutMs
+            ?? ctx.flags['request-timeout-ms']
+            ?? process.env.RUFLO_MCP_REQUEST_TIMEOUT_MS;
+        const requestTimeoutMs = timeoutInput === undefined ? undefined : Number(timeoutInput);
+        if (requestTimeoutMs !== undefined &&
+            (!Number.isSafeInteger(requestTimeoutMs) || requestTimeoutMs < 1 || requestTimeoutMs > 3_600_000)) {
+            output.printError('Request timeout must be an integer from 1 to 3600000 milliseconds');
+            return { success: false, exitCode: 1 };
+        }
         const daemon = ctx.flags.daemon ?? false;
         const force = ctx.flags.force ?? false;
         output.writeln();
@@ -104,10 +119,17 @@ const startCommand = {
         // PID file exists, which would cause us to SIGKILL ourselves)
         const existingStatus = await getMCPServerStatus();
         const isSelfDetected = existingStatus.pid === process.pid;
-        if (existingStatus.running && !isSelfDetected) {
-            // For stdio transport, always force restart since we can't health check it
-            // For other transports, check health unless --force is specified
-            const shouldForceRestart = force || transport === 'stdio';
+        // #3364: only a port-bound transport (http/websocket) is single-instance.
+        // A stdio server belongs to the client that spawned it, over that client's
+        // own pipes, and any number run side by side. The PID file is a single
+        // slot per os.tmpdir(), so for stdio "already running" only ever meant
+        // "some other server is recorded" — and force-restarting SIGKILLed it
+        // (another terminal's stdio server, or a live http server). Stdio now
+        // kills a recorded server only when explicitly asked with --force.
+        const isSingleInstance = transport !== 'stdio';
+        if (existingStatus.running && !isSelfDetected && (isSingleInstance || force)) {
+            // --force always restarts; otherwise check health (http/websocket)
+            const shouldForceRestart = force;
             if (!shouldForceRestart) {
                 // Verify the server is actually healthy/responsive
                 const manager = getServerManager();
@@ -143,6 +165,7 @@ const startCommand = {
             host,
             port,
             tools: !tools || tools === 'all' ? 'all' : tools.split(','),
+            ...(requestTimeoutMs === undefined ? {} : { requestTimeoutMs }),
             daemonize: daemon,
         };
         try {

package/dist/src/mcp-server.d.ts

@@ -29,6 +29,7 @@ export interface MCPServerOptions {
     tools?: string[] | 'all';
     daemonize?: boolean;
     timeout?: number;
+    requestTimeoutMs?: number;
 }
 /**
  * MCP Server status
@@ -85,6 +86,21 @@ export declare class MCPServerManager extends EventEmitter {
     private startTime?;
     private healthCheckInterval?;
     private mcpServers;
+    /**
+     * This manager's own lifecycle (#3364). A stdio server keeps no PID record,
+     * so nothing on disk can answer "is this manager running?" — only the
+     * manager can. `idle` is a manager that has never started, and only there
+     * does the #2934 fallback in getStatus() ("assume a client-launched stdio
+     * server") apply; `stopped` is a handle on a server that is gone, and it
+     * says so rather than reporting whatever PID the shared file happens to hold.
+     */
+    private lifecycle;
+    /**
+     * The exact bytes this manager wrote to the PID file, while they are still
+     * there (#3364). stop() retracts the record only while it is byte for byte
+     * the one we wrote: the slot may have changed hands in between.
+     */
+    private ownedRecord;
     constructor(options?: MCPServerOptions);
     /**
      * Start the MCP server
@@ -136,15 +152,43 @@ export declare class MCPServerManager extends EventEmitter {
      */
     private startHealthMonitoring;
     /**
-     * Write PID file
+     * Write the PID record.
+     *
+     * Line 1 is the bare PID, byte for byte what this file has always held, so
+     * every existing reader keeps working: an older ruflo's
+     * `parseInt(content.trim(), 10)` stops at the newline, and
+     * `v3/scripts/start-mcp.sh` reads the first line. Line 2 is the durable
+     * identity of the instance that wrote it (#3364). Returns the bytes written,
+     * which stop() uses to retract only its own record.
      */
     private writePidFile;
     /**
-     * Read PID file
-     */
-    private readPidFile;
-    /**
-     * Remove PID file
+     * Read the PID record.
+     *
+     * A bare-integer file — an older ruflo, `start-mcp.sh --daemon`, or a
+     * hand-written one — parses to a record with no identity, which keeps
+     * exactly the old behaviour: the PID is checked for liveness and nothing
+     * more. An identity line is only believed for the PID it names.
+     */
+    private readPidRecord;
+    /**
+     * Is the recorded server still the instance the record names? (#3364)
+     *
+     * `kill -0`, and isProcessRunning()'s process-name check on top of it, only
+     * answer "something with this number is alive". Durable identity answers
+     * "it is still the one we wrote down":
+     *  - another host, OS, kernel boot or PID namespace issues its own PIDs, so
+     *    the number says nothing here. On Linux this is the ordinary stale case,
+     *    because /tmp commonly survives a reboot;
+     *  - within one boot the OS reuses a PID once the process is reaped, and the
+     *    owner's start time is what tells the two apart.
+     * Where the start time cannot be read — Windows — the answer falls back to
+     * isProcessRunning(), i.e. exactly the evidence used today.
+     */
+    private recordedServerIsLive;
+    /**
+     * Remove PID file. With `ownedRecord`, only while the file still holds
+     * exactly those bytes: the slot may have changed hands (#3364).
      */
     private removePidFile;
     /**