claude-flow 3.47.1 → 3.49.0

package/v3/@claude-flow/cli/dist/src/init/executor.js

@@ -18,6 +18,7 @@ import { generatePreCommitHook, generatePostCommitHook, generateSessionManager,
 import { getInstalledCliVersion, HELPERS_STAMP_FILE } from './helper-refresh.js';
 import { generateClaudeMd } from './claudemd-generator.js';
 import { recordMemoryPackagePath } from './memory-package-resolver.js';
+import { ensureCommonJsCompanions } from './helper-companions.js';
 import { scanSettingsForRisk, formatRiskFindingsAsWarnings } from './settings-risk-scanner.js';
 /**
  * Skills to copy based on configuration
@@ -499,7 +500,7 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
         const sourceHelpersForUpgrade = findSourceHelpersDir();
         if (sourceHelpersForUpgrade) {
             // Keep in sync with helper-refresh.ts:CRITICAL_HELPERS.
-            const criticalHelpers = ['auto-memory-hook.mjs', 'hook-handler.cjs', 'intelligence.cjs', 'statusline.cjs', 'router.js'];
+            const criticalHelpers = ['auto-memory-hook.mjs', 'hook-handler.cjs', 'intelligence.cjs', 'statusline.cjs', 'router.cjs'];
             for (const helperName of criticalHelpers) {
                 const targetPath = path.join(targetDir, '.claude', 'helpers', helperName);
                 const sourcePath = path.join(sourceHelpersForUpgrade, helperName);
@@ -524,7 +525,7 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 'hook-handler.cjs': generateHookHandler(),
                 'intelligence.cjs': generateIntelligenceStub(),
                 'auto-memory-hook.mjs': generateAutoMemoryHook(),
-                'router.js': generateAgentRouter(), // ADR-389
+                'router.cjs': generateAgentRouter(), // ADR-389 / #3555
             };
             for (const [helperName, content] of Object.entries(generatedCritical)) {
                 const targetPath = path.join(targetDir, '.claude', 'helpers', helperName);
@@ -541,6 +542,11 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 catch { }
             }
         }
+        // #3555: the refreshed hook-handler requires the .cjs companions; older
+        // installs only have session.js / memory.js, which can't load in ESM.
+        for (const name of await ensureCommonJsCompanions(path.join(targetDir, '.claude', 'helpers'))) {
+            result.created.push(`.claude/helpers/${name}`);
+        }
         // Stamp the installed version so the startup auto-refresh treats these as
         // current (no redundant re-copy on the next command).
         try {
@@ -1295,9 +1301,9 @@ async function writeHelpers(targetDir, options, result) {
     const helpers = {
         'pre-commit': generatePreCommitHook(),
         'post-commit': generatePostCommitHook(),
-        'session.js': generateSessionManager(),
-        'router.js': generateAgentRouter(),
-        'memory.js': generateMemoryHelper(),
+        'session.cjs': generateSessionManager(),
+        'router.cjs': generateAgentRouter(),
+        'memory.cjs': generateMemoryHelper(),
         'hook-handler.cjs': generateHookHandler(),
         'intelligence.cjs': generateIntelligenceStub(),
         'auto-memory-hook.mjs': generateAutoMemoryHook(),

package/v3/@claude-flow/cli/dist/src/init/helper-companions.d.ts

@@ -0,0 +1,3 @@
+export declare const COMMONJS_COMPANION_HELPERS: readonly ["session.cjs", "memory.cjs"];
+export declare function ensureCommonJsCompanions(helpersDir: string): Promise<string[]>;
+//# sourceMappingURL=helper-companions.d.ts.map

package/v3/@claude-flow/cli/dist/src/init/helper-companions.js

@@ -0,0 +1,34 @@
+/**
+ * CommonJS companion helpers that `hook-handler.cjs` requires but that are not
+ * in the signed critical set (#3555).
+ *
+ * They are CommonJS, so they ship as `.cjs`: a `.js` copy cannot load in a
+ * `"type":"module"` project. Installs made before the rename have only the
+ * `.js` copies, which the refreshed hook-handler no longer requires, so the
+ * refresh writes any missing `.cjs` companion from the CLI's own compiled
+ * generators (the trust root; no external file to verify). Stale `.js` copies
+ * are left in place and ignored. Existing `.cjs` files are never overwritten.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+export const COMMONJS_COMPANION_HELPERS = ['session.cjs', 'memory.cjs'];
+export async function ensureCommonJsCompanions(helpersDir) {
+    const missing = COMMONJS_COMPANION_HELPERS.filter((name) => !fs.existsSync(path.join(helpersDir, name)));
+    if (missing.length === 0)
+        return [];
+    const gen = await import('./helpers-generator.js');
+    const content = {
+        'session.cjs': gen.generateSessionManager,
+        'memory.cjs': gen.generateMemoryHelper,
+    };
+    const written = [];
+    for (const name of missing) {
+        try {
+            fs.writeFileSync(path.join(helpersDir, name), content[name](), { encoding: 'utf-8', mode: 0o755 });
+            written.push(name);
+        }
+        catch { /* best-effort: hook-handler degrades gracefully without it */ }
+    }
+    return written;
+}
+//# sourceMappingURL=helper-companions.js.map

package/v3/@claude-flow/cli/dist/src/init/helper-integrity.d.ts

@@ -0,0 +1,21 @@
+export interface IntegrityResult {
+    /** Critical helper names whose on-disk hash doesn't match the signed manifest
+     *  (or that are missing from disk despite being part of the signed set). */
+    tampered: string[];
+    /** Set only when the package's OWN signed manifest can't be verified at all —
+     *  there's no ground truth to check the installed files against, distinct
+     *  from a clean `tampered: []` result. */
+    blocked?: string;
+}
+/**
+ * Re-verify each of `criticalHelpers` present on disk in `helpersDir` against
+ * `sourceDir`'s signed manifest. Read-only — safe to call without holding any
+ * refresh lock; callers only need to acquire one if `tampered` comes back
+ * non-empty and they intend to repair it.
+ *
+ * `sourceDir: null` (package source unresolvable) returns `{ tampered: [] }`
+ * — fails open rather than flagging every install as tampered when there is
+ * no ground truth at all to compare against.
+ */
+export declare function verifyInstalledCriticalHelpers(helpersDir: string, sourceDir: string | null, criticalHelpers: readonly string[], pubkeyPemOverride?: string): IntegrityResult;
+//# sourceMappingURL=helper-integrity.d.ts.map

package/v3/@claude-flow/cli/dist/src/init/helper-integrity.js

@@ -0,0 +1,62 @@
+/**
+ * Post-install integrity re-verification for signed critical helpers (#3565).
+ *
+ * `helper-refresh.ts` verifies a helper's signature/hash once, at copy time,
+ * then stamps the target directory with the installed CLI version. Every
+ * later command short-circuited on "stamp already matches" with NO further
+ * verification — so a critical helper modified on disk after that point (a
+ * sibling package's postinstall, a stray older CLI process racing a write,
+ * direct tampering) stayed silently modified through any number of
+ * subsequent commands, forever. This module re-hashes the already-INSTALLED
+ * helpers against the signed manifest independent of the stamp, so callers
+ * can re-run it on every invocation rather than trusting a single past check.
+ *
+ * Deliberately has no opinion on WHAT to do about tampering (re-copy, warn,
+ * refuse) — that policy lives in helper-refresh.ts, which already owns the
+ * fail-closed verify-then-copy path this result feeds into to heal.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { verifyHelpersManifest, sha256Hex, HELPERS_MANIFEST_FILE, } from './helper-signing.js';
+/**
+ * Re-verify each of `criticalHelpers` present on disk in `helpersDir` against
+ * `sourceDir`'s signed manifest. Read-only — safe to call without holding any
+ * refresh lock; callers only need to acquire one if `tampered` comes back
+ * non-empty and they intend to repair it.
+ *
+ * `sourceDir: null` (package source unresolvable) returns `{ tampered: [] }`
+ * — fails open rather than flagging every install as tampered when there is
+ * no ground truth at all to compare against.
+ */
+export function verifyInstalledCriticalHelpers(helpersDir, sourceDir, criticalHelpers, pubkeyPemOverride) {
+    if (!sourceDir)
+        return { tampered: [] };
+    let trusted = null;
+    try {
+        trusted = verifyHelpersManifest(fs.readFileSync(path.join(sourceDir, HELPERS_MANIFEST_FILE), 'utf-8'), pubkeyPemOverride);
+    }
+    catch {
+        trusted = null;
+    }
+    if (!trusted)
+        return { tampered: [], blocked: 'signed helpers manifest missing or signature invalid' };
+    const tampered = [];
+    for (const name of criticalHelpers) {
+        const expected = trusted.files[name];
+        // Not part of THIS version's signed set (or source doesn't ship it) —
+        // nothing to compare the installed copy against.
+        if (!expected || !fs.existsSync(path.join(sourceDir, name)))
+            continue;
+        let actual = null;
+        try {
+            actual = sha256Hex(fs.readFileSync(path.join(helpersDir, name)));
+        }
+        catch {
+            actual = null;
+        }
+        if (actual !== expected)
+            tampered.push(name);
+    }
+    return { tampered };
+}
+//# sourceMappingURL=helper-integrity.js.map

package/v3/@claude-flow/cli/dist/src/init/helper-refresh.d.ts

@@ -10,6 +10,20 @@ interface RefreshOptions {
     lockRetryMsOverride?: number;
     malformedLockStaleMsOverride?: number;
 }
+interface RefreshResult {
+    refreshed: boolean;
+    from?: string;
+    to?: string;
+    blocked?: string;
+    /** Set when `refreshed` was caused by #3565 healing, not a version bump —
+     *  the stamp already matched but one or more critical helpers failed
+     *  on-disk integrity verification and were re-copied from the verified
+     *  source. */
+    healed?: boolean;
+    /** Critical helper names that failed integrity verification, present only
+     *  alongside `healed: true`. */
+    tampered?: string[];
+}
 /**
  * ruflo-owned helpers that carry hook logic (or the render surface for the
  * funnel disclosure row) and must track the package version. Adding to this
@@ -19,6 +33,8 @@ interface RefreshOptions {
 export declare const CRITICAL_HELPERS: string[];
 /** Installed @claude-flow/cli version — the value the helpers are stamped with. */
 export declare function getInstalledCliVersion(): string;
+/** Locate the in-package `.claude/helpers` dir (the copy source). Null if not found. */
+export declare function findPackageHelpersDir(): string | null;
 /**
  * On CLI startup, refresh critical helpers if their stamp is older than the
  * installed CLI version. Two passes:
@@ -70,17 +86,8 @@ export declare function getInstalledCliVersion(): string;
  * compat with pre-3.31.3 callers). If the global pass ran, its own result is
  * carried in the optional `global` field.
  */
-export declare function autoRefreshHelpersIfStale(cwd: string, opts?: RefreshOptions): Promise<{
-    refreshed: boolean;
-    from?: string;
-    to?: string;
-    blocked?: string;
-    global?: {
-        refreshed: boolean;
-        from?: string;
-        to?: string;
-        blocked?: string;
-    };
+export declare function autoRefreshHelpersIfStale(cwd: string, opts?: RefreshOptions): Promise<RefreshResult & {
+    global?: RefreshResult;
 }>;
 export {};
 //# sourceMappingURL=helper-refresh.d.ts.map

package/v3/@claude-flow/cli/dist/src/init/helper-refresh.js

@@ -20,6 +20,8 @@ import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
 import * as semver from 'semver';
 import { verifyHelpersManifest, sha256Hex, HELPERS_MANIFEST_FILE, } from './helper-signing.js';
+import { ensureCommonJsCompanions } from './helper-companions.js';
+import { verifyInstalledCriticalHelpers } from './helper-integrity.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 /**
  * Walk up from `startDir` to the nearest ancestor whose `package.json` names
@@ -71,10 +73,11 @@ export const CRITICAL_HELPERS = [
     // statusline.cjs is here so the funnel disclosure row (ADR-301) reaches
     // existing installs on the next `ruflo` command, not only fresh `ruflo init`.
     'statusline.cjs',
-    // router.js is loaded by hook-handler.cjs to label each prompt with an agent.
+    // router.cjs is loaded by hook-handler.cjs to label each prompt with an agent.
     // Without it here, installs kept the pre-#2257 substring router forever
-    // ("latest" -> tester). ADR-389 / #3401.
-    'router.js',
+    // ("latest" -> tester). ADR-389 / #3401. It is CommonJS, so it ships as
+    // `.cjs`: a `.js` copy cannot load in a `"type":"module"` project (#3555).
+    'router.cjs',
 ];
 function errorCode(error) {
     return typeof error === 'object' && error !== null && 'code' in error
@@ -230,7 +233,7 @@ export function getInstalledCliVersion() {
     }
 }
 /** Locate the in-package `.claude/helpers` dir (the copy source). Null if not found. */
-function findPackageHelpersDir() {
+export function findPackageHelpersDir() {
     const candidates = [];
     try {
         const esmRequire = createRequire(import.meta.url);
@@ -313,7 +316,7 @@ async function writeCriticalHelpers(helpersDir, version, opts = {}) {
         'hook-handler.cjs': gen.generateHookHandler(),
         'intelligence.cjs': gen.generateIntelligenceStub(),
         'auto-memory-hook.mjs': gen.generateAutoMemoryHook(),
-        'router.js': gen.generateAgentRouter(), // ADR-389
+        'router.cjs': gen.generateAgentRouter(), // ADR-389 / #3555
         // Fallback needs the same generator inputs `ruflo init` uses. We match the
         // hardcoded default (maxAgents 15) because the fallback fires when the
         // installed package is unresolvable — no way to read the user's project
@@ -339,9 +342,12 @@ async function writeCriticalHelpers(helpersDir, version, opts = {}) {
 }
 /**
  * On CLI startup: if an initialized project's critical helpers are stamped older
- * than the installed CLI version, silently re-copy them. Fast path is a single
- * stamp read + string compare (sub-ms); the copy runs at most once per version
- * bump. Best-effort, never throws. No-op outside a ruflo project (requires an
+ * than the installed CLI version, silently re-copy them. Fast path is a stamp
+ * read + string compare, PLUS a re-hash of each installed critical helper
+ * against the signed manifest (#3565) — still sub-ms for the handful of small
+ * files involved, and lock-free unless a mismatch is found. The copy runs at
+ * most once per version bump; the heal-on-tamper path can run on any call.
+ * Best-effort, never throws. No-op outside a ruflo project (requires an
  * existing hook-handler.cjs — never creates files in an unrelated directory).
  *
  * FORWARD-ONLY (never downgrades): refreshing on any mere INEQUALITY, rather
@@ -365,6 +371,9 @@ async function writeCriticalHelpers(helpersDir, version, opts = {}) {
  * `pubkeyPemOverride` let a test build its own tiny, throwaway-keypair-
  * signed fixture and get real, deterministic coverage of the verify → hash →
  * copy logic without depending on that.
+ *
+ * #3565: also re-verifies on every stamp-match call (see helper-integrity.ts)
+ * and heals a mismatch via this same verify-then-copy path.
  */
 async function refreshOneHelpersDirLocked(helpersDir, version, opts) {
     if (!fs.existsSync(path.join(helpersDir, 'hook-handler.cjs')))
@@ -377,7 +386,9 @@ async function refreshOneHelpersDirLocked(helpersDir, version, opts) {
     // on this repo (CLAUDE.md "Concurrent-session helper corruption"). The
     // existing semver.gte guard below still fires for normal installs — this
     // is the escape hatch for the small set of users editing helpers directly.
-    // Applies to whichever dir this call is refreshing (project or global).
+    // Applies to whichever dir this call is refreshing (project or global),
+    // and also exempts it from the #3565 integrity re-check below — a
+    // deliberate local edit is not "tampering".
     if (fs.existsSync(path.join(helpersDir, '.LOCKED'))) {
         return { refreshed: false, blocked: '.LOCKED marker present — refresh skipped (delete to re-enable)' };
     }
@@ -386,8 +397,28 @@ async function refreshOneHelpersDirLocked(helpersDir, version, opts) {
         stamped = fs.readFileSync(path.join(helpersDir, HELPERS_STAMP_FILE), 'utf-8').trim();
     }
     catch { /* pre-feature: unstamped */ }
-    if (stamped === version)
-        return { refreshed: false }; // up to date — fast path
+    if (stamped === version) {
+        const source = opts.sourceDirOverride ?? findPackageHelpersDir();
+        const integrity = verifyInstalledCriticalHelpers(helpersDir, source, CRITICAL_HELPERS, opts.pubkeyPemOverride);
+        if (integrity.blocked)
+            return { refreshed: false, blocked: integrity.blocked };
+        if (integrity.tampered.length === 0)
+            return { refreshed: false }; // up to date AND verified intact
+        // Tampering detected post-install — heal via the same fail-closed
+        // verify-then-copy path a version-bump refresh already uses.
+        await opts.beforeWriteOverride?.();
+        const healRes = await writeCriticalHelpers(helpersDir, version, {
+            sourceDirOverride: opts.sourceDirOverride,
+            pubkeyPemOverride: opts.pubkeyPemOverride,
+        });
+        if (healRes.blocked)
+            return { refreshed: false, blocked: healRes.blocked };
+        if (healRes.wrote)
+            await ensureCommonJsCompanions(helpersDir); // #3555
+        return healRes.wrote
+            ? { refreshed: true, healed: true, tampered: integrity.tampered, from: stamped, to: version }
+            : { refreshed: false };
+    }
     if (stamped && semver.valid(stamped) && semver.valid(version) && semver.gte(stamped, version)) {
         // Stamped version is already >= what this binary reports — refreshing
         // would silently DOWNGRADE the helpers. Skip, untouched.
@@ -400,6 +431,8 @@ async function refreshOneHelpersDirLocked(helpersDir, version, opts) {
     });
     if (res.blocked)
         return { refreshed: false, blocked: res.blocked };
+    if (res.wrote)
+        await ensureCommonJsCompanions(helpersDir); // #3555
     return res.wrote ? { refreshed: true, from: stamped || '(unstamped)', to: version } : { refreshed: false };
 }
 async function refreshOneHelpersDir(helpersDir, version, opts) {
@@ -412,8 +445,18 @@ async function refreshOneHelpersDir(helpersDir, version, opts) {
         return { refreshed: false, blocked: '.LOCKED marker present — refresh skipped (delete to re-enable)' };
     }
     try {
-        if (fs.readFileSync(path.join(helpersDir, HELPERS_STAMP_FILE), 'utf-8').trim() === version)
-            return { refreshed: false };
+        if (fs.readFileSync(path.join(helpersDir, HELPERS_STAMP_FILE), 'utf-8').trim() === version) {
+            // #3565: re-hash before trusting a stamp match (helper-integrity.ts).
+            // Read-only — no lock needed unless something's actually wrong; the
+            // (rare) heal path below re-verifies under lock.
+            const source = opts.sourceDirOverride ?? findPackageHelpersDir();
+            const integrity = verifyInstalledCriticalHelpers(helpersDir, source, CRITICAL_HELPERS, opts.pubkeyPemOverride);
+            if (integrity.blocked)
+                return { refreshed: false, blocked: integrity.blocked };
+            if (integrity.tampered.length === 0)
+                return { refreshed: false };
+            // else: tampering found — fall through to acquire the lock and heal.
+        }
     }
     catch { /* unstamped: continue to the locked path */ }
     const releaseLock = await acquireRefreshLock(helpersDir, opts);

package/v3/@claude-flow/cli/dist/src/init/helpers-generator.js

@@ -242,7 +242,7 @@ const [,, command, ...args] = process.argv;
 if (command && commands[command]) {
   commands[command](...args);
 } else {
-  console.log('Usage: session.js <start|restore|end|status|update|metric> [args]');
+  console.log('Usage: session.cjs <start|restore|end|status|update|metric> [args]');
 }
 
 module.exports = commands;
@@ -336,7 +336,7 @@ if (require.main === module) {
     const result = routeTask(task);
     console.log(JSON.stringify(result, null, 2));
   } else {
-    console.log('Usage: router.js <task description>');
+    console.log('Usage: router.cjs <task description>');
     console.log('\\nAvailable agents:', Object.keys(AGENT_CAPABILITIES).join(', '));
   }
 }
@@ -427,7 +427,7 @@ const value = valueParts.join(' ');
 if (command && commands[command]) {
   commands[command](key, value);
 } else {
-  console.log('Usage: memory.js <get|set|delete|clear|keys> [key] [value]');
+  console.log('Usage: memory.cjs <get|set|delete|clear|keys> [key] [value]');
 }
 
 module.exports = commands;
@@ -504,9 +504,9 @@ export function generateHookHandler() {
         '  return null;',
         '}',
         '',
-        "const router = safeRequire(path.join(helpersDir, 'router.js'));",
-        "const session = safeRequire(path.join(helpersDir, 'session.js'));",
-        "const memory = safeRequire(path.join(helpersDir, 'memory.js'));",
+        "const router = safeRequire(path.join(helpersDir, 'router.cjs'));",
+        "const session = safeRequire(path.join(helpersDir, 'session.cjs'));",
+        "const memory = safeRequire(path.join(helpersDir, 'memory.cjs'));",
         "const intelligence = safeRequire(path.join(helpersDir, 'intelligence.cjs'));",
         '',
         'const [,, command, ...args] = process.argv;',
@@ -1005,12 +1005,14 @@ export function generateAutoMemoryHook() {
  */
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const PROJECT_ROOT = join(__dirname, '../..');
+const PROJECT_ROOT = process.env.CLAUDE_PROJECT_DIR
+  ? resolve(process.env.CLAUDE_PROJECT_DIR)
+  : join(__dirname, '../..');
 const DATA_DIR = join(PROJECT_ROOT, '.claude-flow', 'data');
 const STORE_PATH = join(DATA_DIR, 'auto-memory-store.json');
 
@@ -1356,7 +1358,7 @@ const [,, command, ...args] = process.argv;
 if (command && commands[command]) {
   commands[command](...args);
 } else {
-  console.log('Usage: session.js <start|restore|end|status>');
+  console.log('Usage: session.cjs <start|restore|end|status>');
   console.log(\`Platform: \${platform}\`);
   console.log(\`Data dir: \${SESSION_DIR}\`);
 }
@@ -1374,9 +1376,9 @@ export function generateHelpers(options) {
         helpers['pre-commit'] = generatePreCommitHook();
         helpers['post-commit'] = generatePostCommitHook();
         // Cross-platform Node.js scripts
-        helpers['session.js'] = generateCrossPlatformSessionManager();
-        helpers['router.js'] = generateAgentRouter();
-        helpers['memory.js'] = generateMemoryHelper();
+        helpers['session.cjs'] = generateCrossPlatformSessionManager();
+        helpers['router.cjs'] = generateAgentRouter();
+        helpers['memory.cjs'] = generateMemoryHelper();
         // Windows-specific scripts
         helpers['daemon-manager.ps1'] = generateWindowsDaemonManager();
         helpers['daemon-manager.cmd'] = generateWindowsBatchWrapper();

package/v3/@claude-flow/cli/dist/src/mcp-server.js

@@ -27,6 +27,12 @@ import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import { trackRequest } from './mcp-tools/request-tracker.js';
 import { isPolicyEnforcementEnabled, loadMcpPolicy, evaluateToolCall, } from './mcp-tools/policy-enforcer.js';
+/** A failed task can be valid data; only an explicit error denotes tool failure. */
+function hasToolError(result) {
+    return result !== null && typeof result === 'object'
+        && typeof result.error === 'string'
+        && result.error.trim().length > 0;
+}
 // ESM-compatible __dirname
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -666,11 +672,12 @@ export class MCPServerManager extends EventEmitter {
                     }
                     try {
                         const result = await callMCPTool(toolName, toolParams, { sessionId });
-                        trackRequest(toolName, true);
+                        const isError = hasToolError(result);
+                        trackRequest(toolName, !isError);
                         return {
                             jsonrpc: '2.0',
                             id: message.id,
-                            result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] },
+                            result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }], isError },
                         };
                     }
                     catch (error) {
@@ -741,7 +748,7 @@ export class MCPServerManager extends EventEmitter {
             handler: async (input, context) => {
                 try {
                     const result = await callMCPTool(tool.name, input || {}, { sessionId: context?.sessionId || fallbackSessionId });
-                    trackRequest(tool.name, true);
+                    trackRequest(tool.name, !hasToolError(result));
                     return result;
                 }
                 catch (error) {