fraim-hub 2.0.277 → 2.0.279

package/dist/src/ai-hub/hosts.js

@@ -3,11 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHubEvent = exports.createHubMessage = exports.ScriptedHostRuntime = exports.FakeHostRuntime = exports.CliHostRuntime = void 0;
+exports.createHubEvent = exports.createHubMessage = exports.ScriptedHostRuntime = exports.FakeHostRuntime = exports.CliHostRuntime = exports.COMPACT_TASK_FAILURE_PATTERN = void 0;
 exports.parseSeekMentoringSignal = parseSeekMentoringSignal;
 exports.parseFraimJobLoadSignal = parseFraimJobLoadSignal;
 exports.parseUsageSignal = parseUsageSignal;
 exports.parseAgentIdentitySignal = parseAgentIdentitySignal;
+exports.escapeWindowsArg = escapeWindowsArg;
+exports.resolveHostInvocation = resolveHostInvocation;
 exports.__setAgentAvailabilityPathForTests = __setAgentAvailabilityPathForTests;
 exports.invalidateEmployeeDetectionCache = invalidateEmployeeDetectionCache;
 exports.__clearEmployeeDetectionMemoryCacheForTests = __clearEmployeeDetectionMemoryCacheForTests;
@@ -25,6 +27,9 @@ exports.supportsDirectPath = supportsDirectPath;
 exports.buildDirectStartPlan = buildDirectStartPlan;
 exports.buildDirectContinuePlan = buildDirectContinuePlan;
 exports.parseHostLine = parseHostLine;
+exports.detectCodexCompactTaskFailure = detectCodexCompactTaskFailure;
+exports.describeSpawnError = describeSpawnError;
+exports.buildHostSpawnEnv = buildHostSpawnEnv;
 exports.findGeminiSessionIdForPrompt = findGeminiSessionIdForPrompt;
 const crypto_1 = require("crypto");
 const child_process_1 = require("child_process");
@@ -34,6 +39,7 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const manager_turns_1 = require("./manager-turns");
 const managed_agent_paths_1 = require("../cli/utils/managed-agent-paths");
+const command_resolution_1 = require("../cli/mcp/command-resolution");
 const agent_token_prices_1 = require("../local-mcp-server/agent-token-prices");
 const configured_agents_1 = require("./configured-agents");
 const pack_home_1 = require("../cli/utils/pack-home");
@@ -816,32 +822,35 @@ function quoteWindowsArg(value) {
     }
     return `"${value.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/g, '$1$1')}"`;
 }
+// Exported for reuse by server.ts's hubCommandVersion(), which builds a
+// similar single cmd.exe command-line string around a resolved absolute path.
 function escapeWindowsArg(value) {
     return /[\s"]/u.test(value) ? quoteWindowsArg(value) : value;
 }
+// Issue #1284/#1285 (Implementation Strategy §0): resolve the real agent CLI
+// binary fresh at every launch instead of handing a bare command name to
+// `spawn`/`cmd.exe` and trusting whatever PATH the process happens to have.
+// Covers every call site that builds an invocation through this function:
+// spawnHostProcess (real job launches) and both version-probe helpers.
+// Exported for direct unit testing.
 function resolveHostInvocation(plan) {
+    const resolvedPlan = { ...plan, command: (0, command_resolution_1.resolveManagedCommand)(plan.command) };
     if (process.platform !== 'win32') {
-        return plan;
+        return resolvedPlan;
     }
-    const [command, ...args] = [plan.command, ...plan.args];
+    const [command, ...args] = [resolvedPlan.command, ...resolvedPlan.args];
+    // Issue #1284/#1285: `command` can now be an absolute path resolved by
+    // resolveManagedCommand() (e.g. a temp/user directory containing a space),
+    // not just a bare command name — it needs the same escaping the args
+    // already get before joining into the single cmd.exe command-line string.
     return {
         command: 'cmd.exe',
-        args: ['/d', '/s', '/c', [command, ...args.map(escapeWindowsArg)].join(' ')],
+        args: ['/d', '/s', '/c', [command, ...args].map(escapeWindowsArg).join(' ')],
     };
 }
-function stripProjectLocalNodeBinDirs(basePath) {
-    return (basePath ?? '')
-        .split(path_1.default.delimiter)
-        .filter(Boolean)
-        .filter((entry) => {
-        const normalized = path_1.default.normalize(entry).toLowerCase();
-        return !normalized.endsWith(`${path_1.default.sep}node_modules${path_1.default.sep}.bin`);
-    })
-        .join(path_1.default.delimiter);
-}
 function buildAgentVersionProbePath(basePath) {
     const withoutManaged = (0, managed_agent_paths_1.stripManagedAgentBinDirsFromPath)(basePath);
-    const withoutProjectBins = stripProjectLocalNodeBinDirs(withoutManaged);
+    const withoutProjectBins = (0, managed_agent_paths_1.stripProjectLocalNodeBinDirs)(withoutManaged);
     return (0, managed_agent_paths_1.appendBinDirsToPath)(withoutProjectBins, (0, managed_agent_paths_1.getManagedAgentBinDirs)());
 }
 // Single source for the probe environment, shared by the sync and async probes so the two
@@ -1795,6 +1804,26 @@ function scrubGeminiAssistantLine(line) {
     const scrubbed = line.replace(/\[Thought:\s*true\]\s*/gi, '').trim();
     return scrubbed.length > 0 ? scrubbed : null;
 }
+// Issue #1284: Codex's own error text for a rejected remote context-compaction
+// call, e.g. "Error running remote compact task: unexpected status 404 Not
+// Found: ...". Exported so `server.ts`'s `classifyExit()` can recognize a
+// repeat of this exact signature from `run.lastHostError` without duplicating
+// the pattern.
+exports.COMPACT_TASK_FAILURE_PATTERN = /Error running remote compact task/;
+// Issue #1284 (Defect C): Codex reports a remote compact-endpoint failure as
+// plain stderr text, not one of the JSON shapes `parseHostLine` understands,
+// so it silently fell through to `{ raw }` with no `hostError`/classification
+// signal at all — the run then retried blindly against the same doomed call.
+// Surfacing it as `hostError` here lets `classifyExit()` recognize and
+// short-circuit a repeat instead of exhausting the retry budget. A pure,
+// directly-testable function, matching the shape of `parseSeekMentoringSignal`
+// et al. rather than inlining this check into `wireHostProcess`'s closure.
+function detectCodexCompactTaskFailure(line) {
+    if (exports.COMPACT_TASK_FAILURE_PATTERN.test(line) && /status 4\d\d/.test(line)) {
+        return { hostError: line, raw: line };
+    }
+    return null;
+}
 function wireHostProcess(hostId, child, handlers) {
     const wire = (buffer, channel) => {
         let pending = '';
@@ -1815,6 +1844,11 @@ function wireHostProcess(hostId, child, handlers) {
                     if (suppressCodexModelRefreshStderr) {
                         continue;
                     }
+                    const compactFailure = detectCodexCompactTaskFailure(line);
+                    if (compactFailure) {
+                        handlers.onEvent(compactFailure, channel);
+                        continue;
+                    }
                 }
                 const parsed = parseHostLine(hostId, line);
                 if (parsed.message || parsed.sessionId || parsed.raw) {
@@ -1833,16 +1867,55 @@ function wireHostProcess(hostId, child, handlers) {
     };
     wire(child.stdout, 'stdout');
     wire(child.stderr, 'stderr');
-    child.on('close', (code) => handlers.onExit(code));
+    // Issue #1327: preserve signal information so SIGSEGV kills (code=null,
+    // signal='SIGSEGV') are NOT treated as clean exits by classifyExit's
+    // `exitCode ?? 0` guard. Pass -1 for any signal-terminated child so the
+    // non-zero branch fires and recovery is attempted.
+    child.on('close', (code, signal) => handlers.onExit(signal ? -1 : code));
+    // Issue #1327: without this listener, an OS-level spawn failure (EAGAIN,
+    // ENOENT, EACCES) fires an 'error' event on the ChildProcess. An unhandled
+    // EventEmitter 'error' throws synchronously and crashes the Hub process.
+    // Surface the failure as a human-readable hostError so the run's terminal
+    // message names the cause. 'close' still fires after 'error' for spawn
+    // failures, so handlers.onExit is called by the close listener above.
+    child.on('error', (err) => {
+        handlers.onEvent({ hostError: describeSpawnError(err) }, 'system');
+    });
     return child;
 }
+function describeSpawnError(err) {
+    if (err.code === 'ENOENT') {
+        return `Agent binary not found${err.path ? ` (${err.path})` : ''}. Ensure the agent CLI is installed and on PATH.`;
+    }
+    if (err.code === 'EACCES') {
+        return `Permission denied starting agent process${err.path ? ` (${err.path})` : ''}. Check executable permissions.`;
+    }
+    if (err.code === 'EAGAIN') {
+        return `Could not start agent process: system resources temporarily unavailable (EAGAIN). The OS process limit may have been reached; try again in a moment.`;
+    }
+    return `Failed to start agent process: ${err.message}`;
+}
+// Issue #1284/#1285 (Defect D): the version-probe path already excludes
+// project-local `node_modules/.bin` shims via `versionProbeEnv()`; the real
+// job-spawn path built `env.PATH` straight from `process.env`/`plan.env` with
+// no such filtering, so a poisoned PATH silently ran the wrong binary on the
+// one path that actually executes jobs. Reuse the exact same construction the
+// probe uses so the two can never disagree again.
+// Exported for direct unit testing of the Defect D fix (issue #1284/#1285):
+// asserting spawnHostProcess's environment construction matches
+// versionProbeEnv()'s filtering without spawning a real child process.
+function buildHostSpawnEnv(plan) {
+    const merged = plan.env ? { ...process.env, ...plan.env } : { ...process.env };
+    const resolvedPath = buildAgentVersionProbePath(merged.PATH ?? merged.Path);
+    return { ...merged, PATH: resolvedPath, Path: resolvedPath };
+}
 function spawnHostProcess(hostId, plan, projectPath, handlers) {
     const invocation = resolveHostInvocation(plan);
     const startedAtMs = Date.now();
     const child = (0, child_process_1.spawn)(invocation.command, invocation.args, {
         cwd: projectPath,
         stdio: ['pipe', 'pipe', 'pipe'],
-        env: plan.env ? { ...process.env, ...plan.env } : process.env,
+        env: buildHostSpawnEnv(plan),
     });
     if (typeof plan.stdin === 'string') {
         child.stdin.write(plan.stdin);

package/dist/src/ai-hub/server.js

@@ -38,6 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findAvailablePortExcluding = exports.findAvailablePort = exports.AiHubServer = exports.HostConfigStore = exports.DeploymentStore = void 0;
 exports.configureFraimForHubAgent = configureFraimForHubAgent;
+exports.hubCommandVersion = hubCommandVersion;
 exports.buildOpenFileInvocation = buildOpenFileInvocation;
 const express_1 = __importDefault(require("express"));
 const path_1 = __importDefault(require("path"));
@@ -55,6 +56,7 @@ const job_visualization_1 = require("../core/job-visualization");
 const custom_employees_1 = require("./custom-employees");
 const agent_token_prices_1 = require("../local-mcp-server/agent-token-prices");
 const hosts_1 = require("./hosts");
+const command_resolution_1 = require("../cli/mcp/command-resolution");
 const configured_agents_1 = require("./configured-agents");
 const host_session_state_1 = require("./host-session-state");
 const url_safety_1 = require("./url-safety");
@@ -69,6 +71,8 @@ const restart_recovery_policy_1 = require("./restart-recovery-policy");
 const remote_hub_gateway_1 = require("./remote-hub-gateway");
 const managed_browser_1 = require("./managed-browser");
 const managed_agent_paths_1 = require("../cli/utils/managed-agent-paths");
+const managed_agent_install_1 = require("../cli/utils/managed-agent-install");
+const agent_cli_health_checks_1 = require("../cli/doctor/checks/agent-cli-health-checks");
 const user_config_1 = require("../cli/utils/user-config");
 const version_utils_1 = require("../cli/utils/version-utils");
 const hub_latest_version_1 = require("./hub-latest-version");
@@ -1499,17 +1503,26 @@ async function configureFraimForHubAgent(hubId) {
         return { configured: false, error: e instanceof Error ? e.message : String(e) };
     }
 }
+// Exported for direct unit testing of the Defect D fix (issue #1284/#1285):
+// asserting this resolves via a real system install and skips a poisoned
+// project-local node_modules/.bin entry, without spinning up a full server.
 function hubCommandVersion(command, extraBinDirs, basePath) {
     if (process.env.NODE_ENV === 'test' && process.env.FRAIM_TEST_HUB_COMMAND_VERSION_EMPTY === '1') {
         return null;
     }
-    const executable = process.platform === 'win32' ? 'cmd.exe' : command;
-    const args = process.platform === 'win32'
-        ? ['/d', '/s', '/c', `${command} --version`]
-        : ['--version'];
     const pathValue = extraBinDirs && extraBinDirs.length > 0
         ? (0, managed_agent_paths_1.appendBinDirsToPath)(basePath ?? process.env.PATH, extraBinDirs)
         : basePath;
+    // Issue #1284/#1285 (Defect D, §0): resolve to a real absolute path — with
+    // project-local node_modules/.bin stripped — instead of handing the bare
+    // command name to cmd.exe's own PATH search, which does not exclude those
+    // shims. Falls back to the bare command (today's behavior, resolves to
+    // null below) when no system install is found on the constructed PATH.
+    const resolvedCommand = (0, command_resolution_1.getSystemCommandPath)(command, pathValue ?? process.env.PATH) || command;
+    const executable = process.platform === 'win32' ? 'cmd.exe' : resolvedCommand;
+    const args = process.platform === 'win32'
+        ? ['/d', '/s', '/c', `${(0, hosts_1.escapeWindowsArg)(resolvedCommand)} --version`]
+        : ['--version'];
     const env = pathValue === undefined ? undefined : { ...process.env, PATH: pathValue };
     const result = (0, child_process_1.spawnSync)(executable, args, { encoding: 'utf8', timeout: 5000, ...(env ? { env } : {}) });
     if (result.status !== 0 || result.error)
@@ -1893,6 +1906,22 @@ function isHumanActionGate(run) {
     const lastEntry = phaseHistory.length > 0 ? phaseHistory[phaseHistory.length - 1] : null;
     return lastEntry?.latestStatus === 'incomplete' || lastEntry?.latestStatus === 'failure';
 }
+// Issue #1284 (Defect C): a 404/4xx on Codex's remote context-compaction
+// endpoint means the installed Codex build's compact request is not accepted
+// by the current backend (a version incompatibility) — not a transient
+// failure blind retry can recover from. Reads the most recent host error
+// already captured on the run (recordHostEvent sets `run.lastHostError` from
+// the stderr signal wireHostProcess raises for this exact line).
+function detectCompactFailureSignature(run) {
+    const error = run.lastHostError;
+    if (error && hosts_1.COMPACT_TASK_FAILURE_PATTERN.test(error) && /status 4\d\d/.test(error)) {
+        return 'compact-4xx';
+    }
+    return null;
+}
+const COMPACT_INCOMPATIBLE_NOTE = "Codex's remote context-compaction call was rejected by the backend (404). "
+    + 'This usually means the installed Codex CLI is out of date. Run `codex update`, confirm `codex --version` '
+    + 'matches the latest release, and retry.';
 // #1275: true when the host reported an active local_bash task. These are
 // intentional async continuations — the agent ended its turn knowing bash was
 // running, intending to check results in the next turn. In -p mode Claude Code
@@ -1928,11 +1957,21 @@ function classifyExit(run, exitCode) {
     if (run.stoppedByUser) {
         return { action: 'park', pauseReason: 'stopped' };
     }
-    const code = exitCode ?? 0;
+    // Issue #1327: null exit code means the child was killed by a signal (e.g.
+    // SIGSEGV). wireHostProcess now passes -1 in that case, but guard here too:
+    // any null that reaches classifyExit must not be treated as a clean exit.
+    const code = exitCode ?? -1;
     if (code !== 0) {
+        // Issue #1284: a repeat of the exact same classified-unrecoverable
+        // signature short-circuits to 'error' immediately instead of exhausting
+        // the retry budget against a call that will fail identically every time.
+        const signature = detectCompactFailureSignature(run);
+        if (signature && run.lastRecoverySignature === signature) {
+            return { action: 'error', pauseReason: 'error', systemNote: COMPACT_INCOMPATIBLE_NOTE };
+        }
         const attempts = (run.recoveryAttempts ?? 0);
         if (attempts < MAX_RECOVERY_ATTEMPTS) {
-            return { action: 'resume', pauseReason: 'working' };
+            return { action: 'resume', pauseReason: 'working', matchedSignature: signature ?? undefined };
         }
         return { action: 'error', pauseReason: 'error' };
     }
@@ -2801,15 +2840,26 @@ class AiHubServer {
         appendHostMessage(run, hostId, event, channel);
         // Issue #1221: a real assistant reply proves the host recovered, so a
         // previously recorded error is stale and must not keep haunting the next
-        // exit/recovery message.
+        // exit/recovery message. Issue #1284: a classified recovery signature is
+        // scoped to the same failure recurring; a genuine recovery must not let
+        // it bleed into an unrelated later failure in the same run.
         if (event.message && channel === 'stdout') {
             run.lastHostError = undefined;
+            run.lastRecoverySignature = undefined;
         }
         if (event.raw) {
             applyDelegationLedgerProjection(run, event.raw);
             try {
                 const ref = this.rawEventLogStore.append((0, conversation_store_1.conversationScopeKey)(run.scope, run.projectPath), run.conversationId || run.id, run.id, { channel, text: event.raw });
                 run.eventLogRefs = upsertEventLogRef(run.eventLogRefs, ref);
+                // Issue #1327: if the Hub crashes before the debounced conversation
+                // flush fires, run.eventLogRefs is lost from the store and the raw
+                // event log on disk becomes unreachable. Flush immediately on the
+                // first event so the ref is always on disk within the same synchronous
+                // turn. Subsequent events use the normal debounced path.
+                if (ref.eventCount === 1) {
+                    this.persistRunConversationNow(run, run.conversationId || run.id);
+                }
             }
             catch (error) {
                 run.events.push((0, hosts_1.createHubEvent)('system', 'Raw host event logging failed; visible conversation state was preserved.'));
@@ -3014,6 +3064,7 @@ class AiHubServer {
             current.status = 'running';
             current.sessionId = undefined;
             current.recoveryAttempts = 0;
+            current.lastRecoverySignature = undefined;
             current.pauseReason = 'working';
             current.events.push((0, hosts_1.createHubEvent)('system', 'Codex resume failed because the saved session was missing a required reasoning item; starting a fresh handoff-backed turn from Hub conversation context.'));
         });
@@ -5174,6 +5225,14 @@ class AiHubServer {
             if (!option)
                 return res.status(400).json({ error: `Unknown agent: ${hubId}` });
             try {
+                // Issue #1285 (Implementation Strategy §3): self-heal any shim orphaned
+                // in the legacy flat managed directory before this run's version checks
+                // consult FRAIM's managed PATH, so a stale build can no longer shadow
+                // the current one. Idempotent; cheap enough to run on every call.
+                const removedShims = (0, managed_agent_paths_1.cleanupOrphanedManagedShims)();
+                if (removedShims.length > 0) {
+                    console.warn(`[ai-hub] install-agent: removed orphaned managed shim(s): ${removedShims.join(', ')}`);
+                }
                 const systemPath = (0, managed_agent_paths_1.stripManagedAgentBinDirsFromPath)(process.env.PATH);
                 const existingVersion = hubCommandVersion(option.launchCommand, undefined, systemPath);
                 if (existingVersion) {
@@ -5200,62 +5259,19 @@ class AiHubServer {
                         loginHint: `Once installed, click "Check if Ready" to verify ${option.label} is on your PATH.`,
                     });
                 }
-                let standardInstallError = null;
-                try {
-                    await hubRunProcess('npm', ['install', '-g', option.installPackage], {
-                        PATH: systemPath,
-                        npm_config_prefix: undefined,
-                        NPM_CONFIG_PREFIX: undefined,
-                    });
-                    const standardVersion = hubCommandVersion(option.launchCommand, undefined, systemPath);
-                    const npmGlobalBinDirs = standardVersion
-                        ? []
-                        : (0, managed_agent_paths_1.resolveNpmGlobalBinDirs)(systemPath, {
-                            npm_config_prefix: undefined,
-                            NPM_CONFIG_PREFIX: undefined,
-                        });
-                    const standardVersionWithNpmBin = standardVersion
-                        || (npmGlobalBinDirs.length > 0
-                            ? hubCommandVersion(option.launchCommand, npmGlobalBinDirs, systemPath)
-                            : null);
-                    if (standardVersionWithNpmBin) {
-                        if (npmGlobalBinDirs.length > 0) {
-                            process.env.PATH = (0, managed_agent_paths_1.appendBinDirsToPath)(systemPath, npmGlobalBinDirs);
-                        }
-                        const mcp = await configureFraimForHubAgent(hubId);
-                        if (!mcp.configured) {
-                            console.warn(`[ai-hub] install-agent: FRAIM add-ide did not run for standard ${option.label}: ${mcp.error || 'unknown reason'}`);
-                        }
-                        // Issue #1010: something is now installed that was not before, so the cached
-                        // agent-availability answer is stale. Drop it here rather than waiting out the
-                        // TTL, so the newly installed CLI shows as available immediately.
-                        (0, hosts_1.invalidateEmployeeDetectionCache)();
-                        return res.json({
-                            ok: true,
-                            message: `${option.label} installed successfully.`,
-                            needsLogin: true,
-                            loginCommand: option.loginCommand,
-                            loginHint: `Sign in to ${option.label} to activate it. A terminal window will open — complete sign-in there, then click "Check if Ready".`,
-                            fraimConfigured: mcp.configured,
-                        });
-                    }
-                    standardInstallError = `${option.label} standard install completed, but the CLI is not runnable from the user PATH.`;
-                }
-                catch (error) {
-                    standardInstallError = error instanceof Error ? error.message : 'Unknown error';
-                }
-                const prefix = (0, managed_agent_paths_1.getManagedNodeRoot)();
-                fs_1.default.mkdirSync(prefix, { recursive: true });
-                await hubRunProcess('npm', ['install', '-g', option.installPackage], { npm_config_prefix: prefix });
-                const ver = hubCommandVersion(option.launchCommand, (0, managed_agent_paths_1.getManagedAgentBinDirs)());
-                if (!ver) {
-                    throw new Error(`${option.label} install completed, but the CLI is not runnable from FRAIM's managed PATH. Standard install failure: ${standardInstallError}`);
+                const outcome = await (0, managed_agent_install_1.installManagedAgent)({ label: option.label, installPackage: option.installPackage, launchCommand: option.launchCommand }, systemPath, { runProcess: hubRunProcess, commandVersion: hubCommandVersion });
+                if (outcome.outcome === 'standard' && outcome.npmGlobalBinDirs.length > 0) {
+                    process.env.PATH = (0, managed_agent_paths_1.appendBinDirsToPath)(systemPath, outcome.npmGlobalBinDirs);
                 }
-                // Issue #747: run `add-ide` for the newly installed agent so the FRAIM MCP is wired in
-                // and its first run works (previously the agent launched with no `fraim` MCP server).
                 const mcp = await configureFraimForHubAgent(hubId);
                 if (!mcp.configured) {
-                    console.warn(`[ai-hub] install-agent: FRAIM add-ide did not run for ${option.label}: ${mcp.error || 'unknown reason'}`);
+                    console.warn(`[ai-hub] install-agent: FRAIM add-ide did not run for ${option.label} (${outcome.outcome} install): ${mcp.error || 'unknown reason'}`);
+                }
+                if (outcome.outcome === 'standard') {
+                    // Issue #1010: something is now installed that was not before, so the cached
+                    // agent-availability answer is stale. Drop it here rather than waiting out the
+                    // TTL, so the newly installed CLI shows as available immediately.
+                    (0, hosts_1.invalidateEmployeeDetectionCache)();
                 }
                 return res.json({
                     ok: true,
@@ -5293,16 +5309,27 @@ class AiHubServer {
                 });
             }
         });
-        this.app.post('/api/ai-hub/check-agent', (req, res) => {
+        this.app.post('/api/ai-hub/check-agent', async (req, res) => {
             const { hubId } = req.body;
             if (!hubId)
                 return res.status(400).json({ error: 'hubId is required.' });
             const option = hubAgentOption(hubId);
             if (!option)
                 return res.status(400).json({ error: `Unknown agent: ${hubId}` });
+            (0, managed_agent_paths_1.cleanupOrphanedManagedShims)();
             const ver = hubCommandVersion(option.launchCommand, (0, managed_agent_paths_1.getManagedAgentBinDirs)());
             if (ver) {
-                return res.json({ ok: true, ready: true, message: `${option.label} is ready.` });
+                // Issue #1285 (§4): a manager who ran `codex update` and clicks "Check
+                // if Ready" should see PATH drift immediately rather than a bare pass.
+                const health = await (0, agent_cli_health_checks_1.checkAgentCliHealthByCommand)(option.launchCommand);
+                return res.json({
+                    ok: true,
+                    ready: true,
+                    message: `${option.label} is ready.`,
+                    ...(health && health.status !== 'passed'
+                        ? { driftWarning: health.message, driftSuggestion: health.suggestion }
+                        : {}),
+                });
             }
             return res.json({
                 ok: true,
@@ -6829,6 +6856,7 @@ class AiHubServer {
                         : createHubRecoveryEvent(current, exitCode, current.recoveryAttempts));
                 }
                 current.lastRecoveryAt = new Date().toISOString();
+                current.lastRecoverySignature = classification.matchedSignature ?? null;
                 current.pauseReason = 'working';
             });
             const refreshed = this.runRegistry.get(runId);

package/dist/src/ai-hub/ui-runtime.js

@@ -18,6 +18,7 @@ const BUNDLED_ASSETS = {
     styles: ['/ai-hub/styles.css', '/ai-hub/review.css'],
     scripts: ['/ai-hub/script.js'],
 };
+const REQUIRED_REMOTE_UI_CAPABILITIES = ['jobs.visualization'];
 function createAiHubBridgeInfo(options) {
     const remoteUiEnabled = options.remoteUiEnabled ?? process.env.FRAIM_HUB_REMOTE_UI === '1';
     return {
@@ -34,6 +35,7 @@ function createAiHubBridgeInfo(options) {
             'office.wordTaskpane': true,
             'customEmployees': true,
             'ui.serverDrivenRuntime': true,
+            'jobs.visualization': true,
         },
     };
 }
@@ -53,6 +55,12 @@ function evaluateHubUiManifestCompatibility(manifest, bridge) {
     if (missing) {
         return { compatible: false, updateRequired: true, reason: `missing-capability:${missing}` };
     }
+    const missingRequired = REQUIRED_REMOTE_UI_CAPABILITIES.find((capability) => {
+        return bridge.capabilities[capability] && !manifest.requiredCapabilities.includes(capability);
+    });
+    if (missingRequired) {
+        return { compatible: false, updateRequired: true, reason: `missing-required-capability:${missingRequired}` };
+    }
     return { compatible: true, updateRequired: false };
 }
 function runtimeAssetsForRelease(releaseId, manifest) {

package/dist/src/api/pricing/get-config.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPricingConfig = getPricingConfig;
+const pricing_1 = require("../../config/pricing");
+const feature_flags_1 = require("../../config/feature-flags");
+/**
+ * GET /api/pricing/config
+ * Returns pricing configuration for frontend
+ */
+async function getPricingConfig(req, res) {
+    try {
+        res.json({
+            pricing: pricing_1.PRICING,
+            fixedFees: pricing_1.FIXED_FEES,
+            managedPricing: pricing_1.MANAGED_PRICING,
+            founderDiscountRate: pricing_1.FOUNDER_DISCOUNT_RATE,
+            consumerEmailDomains: pricing_1.CONSUMER_EMAIL_DOMAINS,
+            featureFlags: (0, feature_flags_1.getPublicFeatureFlags)(),
+        });
+    }
+    catch (error) {
+        console.error('Error getting pricing config:', error);
+        res.status(500).json({ error: 'Failed to get pricing configuration' });
+    }
+}