fraim-hub 2.0.301 → 2.0.303

package/README.md

@@ -312,7 +312,7 @@ Use these defaults:
 - `feature-specification` when the request is still fuzzy or needs clarified requirements, UX, or acceptance criteria.
 - `technical-design` after the spec is approved and you need the implementation plan, file touchpoints, and risk handling.
 - `feature-implementation` for code changes, bug fixes, and documentation updates that should be executed and validated.
-- `test-execution` when you need reproduction coverage, missing tests, or stronger regression protection before implementation.
+- `test-authoring` when you need reproduction coverage, missing tests, or stronger regression protection before implementation.
 - `browser-application-validation` or `ui-polish-validation` after user-facing UI changes or when the ask is explicitly browser validation.
 - `implementation-feature-review` when you need to verify the delivered behavior matches the feature spec.
 - `implementation-design-review` when you need to verify the code matches the approved technical design.

package/dist/src/ai-hub/configured-agents.js

@@ -99,15 +99,15 @@ function normalizeCommand(value) {
         timeoutMs: typeof value.timeoutMs === 'number' && value.timeoutMs > 0 ? Math.min(value.timeoutMs, 120_000) : 30_000,
     };
 }
-function synthesizeDefaultConfiguredAgents(employees) {
+function synthesizeDefaultConfiguredAgents(hosts) {
     const timestamp = '1970-01-01T00:00:00.000Z';
-    return employees
-        .filter((employee) => employee.available)
-        .map((employee) => ({
-        id: `${employee.id}-default`,
-        label: employee.label,
+    return hosts
+        .filter((host) => host.available)
+        .map((host) => ({
+        id: `${host.id}-default`,
+        label: host.label,
         description: 'Default local launch for this agent tool.',
-        baseHostId: employee.id,
+        baseHostId: host.id,
         enabled: true,
         createdAt: timestamp,
         updatedAt: timestamp,
@@ -133,9 +133,9 @@ class AiHubConfiguredAgentStore {
             return [];
         }
     }
-    listWithDefaults(employees) {
+    listWithDefaults(hosts) {
         const persisted = this.list();
-        const defaults = synthesizeDefaultConfiguredAgents(employees);
+        const defaults = synthesizeDefaultConfiguredAgents(hosts);
         const seen = new Set(persisted.map((agent) => agent.id));
         return [...persisted, ...defaults.filter((agent) => !seen.has(agent.id))];
     }
@@ -166,14 +166,14 @@ class AiHubConfiguredAgentStore {
     }
 }
 exports.AiHubConfiguredAgentStore = AiHubConfiguredAgentStore;
-function checkConfiguredAgentAvailability(agent, employees, env = process.env) {
+function checkConfiguredAgentAvailability(agent, hosts, env = process.env) {
     const reasons = [];
     const warnings = [];
-    const employee = employees.find((entry) => entry.id === agent.baseHostId);
+    const host = hosts.find((entry) => entry.id === agent.baseHostId);
     if (!agent.enabled)
         reasons.push('Configured agent is disabled.');
-    if (!employee?.available)
-        reasons.push(`${employee?.label || agent.baseHostId} is not available on this machine.`);
+    if (!host?.available)
+        reasons.push(`${host?.label || agent.baseHostId} is not available on this machine.`);
     if (agent.command) {
         if (!agent.command.command.trim()) {
             reasons.push('Command is empty.');
@@ -202,8 +202,8 @@ function checkConfiguredAgentAvailability(agent, employees, env = process.env) {
     }
     return { id: agent.id, label: agent.label, baseHostId: agent.baseHostId, enabled: agent.enabled, available: reasons.length === 0, reasons, warnings };
 }
-function checkConfiguredAgentReadiness(agent, employees, env = process.env) {
-    const check = checkConfiguredAgentAvailability(agent, employees, env);
+function checkConfiguredAgentReadiness(agent, hosts, env = process.env) {
+    const check = checkConfiguredAgentAvailability(agent, hosts, env);
     if (!check.available)
         return check;
     if (agent.command)
@@ -225,8 +225,8 @@ function checkConfiguredAgentReadiness(agent, employees, env = process.env) {
         };
     }
 }
-function projectConfiguredAgent(agent, employees) {
-    const check = checkConfiguredAgentAvailability(agent, employees);
+function projectConfiguredAgent(agent, hosts) {
+    const check = checkConfiguredAgentAvailability(agent, hosts);
     return {
         id: agent.id,
         label: agent.label,

package/dist/src/ai-hub/conversation-store.js

@@ -689,6 +689,13 @@ class AiHubConversationStore {
         const { headers } = this.loadIndex(this.bucketDir(key), key);
         return headers.map((h) => ({ ...h }));
     }
+    // Issue #1477: the active conversation id, from the same cheap index used by
+    // loadProjectHeaders, so a headers-only list response can still report it.
+    loadProjectActiveId(projectPath) {
+        this.ensureMigrated();
+        const key = normalizeConversationKey(projectPath);
+        return this.loadIndex(this.bucketDir(key), key).activeId;
+    }
     // Lazy body read: one full conversation.
     loadConversation(projectPath, conversationId) {
         this.ensureMigrated();

package/dist/src/ai-hub/host-session-state.js

@@ -57,6 +57,15 @@ class HostSessionState {
         const fallback = Object.values(sessions).find((session) => this.isResumableForOwner(session, owner));
         if (fallback)
             return fallback;
+        // Issue #1515: once this conversation has ANY owner-qualified session recorded, that
+        // ledger is authoritative. The legacy `sessionId` mirror always reflects whichever
+        // configured agent last ran (see `mergeFromRun` below), not the requested owner, so
+        // treating it as resumable here would resume a different agent's session under the
+        // wrong owner (e.g. Codex Azure Script silently reusing a plain Codex session because
+        // both share `baseHostId: 'codex'`). The legacy fallback below is reserved for
+        // conversations that predate the owner-qualified ledger entirely.
+        if (Object.keys(sessions).length > 0)
+            return null;
         const legacySessionId = typeof conversation.sessionId === 'string' ? conversation.sessionId.trim() : '';
         if (!legacySessionId)
             return null;

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

@@ -5,7 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHubEvent = exports.createHubMessage = exports.ScriptedHostRuntime = exports.FakeHostRuntime = exports.CliHostRuntime = exports.COMPACT_TASK_FAILURE_PATTERN = void 0;
 exports.parseSeekMentoringSignal = parseSeekMentoringSignal;
+exports.parseRecurringParkSignal = parseRecurringParkSignal;
 exports.parseFraimJobLoadSignal = parseFraimJobLoadSignal;
+exports.parseExecutionModeSignal = parseExecutionModeSignal;
 exports.parseUsageSignal = parseUsageSignal;
 exports.parseAgentIdentitySignal = parseAgentIdentitySignal;
 exports.escapeWindowsArg = escapeWindowsArg;
@@ -16,6 +18,7 @@ exports.__clearEmployeeDetectionMemoryCacheForTests = __clearEmployeeDetectionMe
 exports.__setEmployeeDetectionTtlForTests = __setEmployeeDetectionTtlForTests;
 exports.__getEmployeeProbeRoundsForTests = __getEmployeeProbeRoundsForTests;
 exports.__resetEmployeeProbeRoundsForTests = __resetEmployeeProbeRoundsForTests;
+exports.isEmployeeDetectionRefreshing = isEmployeeDetectionRefreshing;
 exports.detectEmployeesAsync = detectEmployeesAsync;
 exports.detectEmployees = detectEmployees;
 exports.prepareCodexBrowserHome = prepareCodexBrowserHome;
@@ -123,6 +126,41 @@ function parseSeekMentoringSignal(line) {
     }
     return null;
 }
+// Issue #1509: detect the recurring-park marker emitted by the mentor inside its
+// tool_result when it resolves a phase transition to WAITING_FOR_NEXT_INVOCATION.
+// Scoped to genuine tool-result-shaped sub-objects — not a bare substring match —
+// so any job that prints ai-mentor.ts source in an assistant-text message does NOT
+// accidentally set the flag.  A plain assistant message carries no sub-object whose
+// type matches the tool-result pattern, so it is naturally excluded.
+//
+// Detection property: the marker must appear inside a JSON sub-object whose own
+// `type` field matches the tool-result-type pattern.  This covers all known host
+// shapes (Claude Code tool_result, Codex function_call_output/mcp_tool_result,
+// Copilot tool.execution_complete) and future hosts without per-host branches.
+const TOOL_RESULT_TYPE_RE = /tool_result|function_call_output|mcp_tool_result|tool\.execution_complete/i;
+function containsMarkerInToolResult(value) {
+    if (Array.isArray(value))
+        return value.some(item => containsMarkerInToolResult(item));
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const obj = value;
+    if (typeof obj.type === 'string' && TOOL_RESULT_TYPE_RE.test(obj.type)) {
+        return JSON.stringify(obj).includes('FRAIM_RECURRING_PARK');
+    }
+    return Object.values(obj).some(v => containsMarkerInToolResult(v));
+}
+function parseRecurringParkSignal(line) {
+    if (!line.includes('FRAIM_RECURRING_PARK'))
+        return false;
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return false;
+    }
+    return containsMarkerInToolResult(parsed);
+}
 // Issue #710: extract the job name from a get_fraim_job tool call. This
 // is structured known-job evidence; the server still validates the job id
 // against the catalog before promoting any run.
@@ -183,6 +221,43 @@ function parseFraimJobLoadSignal(line) {
     }
     return null;
 }
+function parseExecutionModeSignal(line) {
+    if (!line.includes('Execution Mode Context'))
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null)
+        return null;
+    const obj = parsed;
+    // Codex/codex_apps shape: the completed get_fraim_job tool call carries its
+    // result in item.result.content[].text. The local proxy side-channel does not
+    // run for this connector path, so Hub must consume the same payload directly.
+    if (obj.type === 'item.completed' &&
+        typeof obj.item === 'object' &&
+        obj.item !== null) {
+        const item = obj.item;
+        if (item.type === 'mcp_tool_call' && isFraimTool(item.tool, 'get_fraim_job')) {
+            const result = item.result;
+            const content = result && Array.isArray(result.content) ? result.content : [];
+            for (const entry of content) {
+                if (typeof entry !== 'object' || entry === null)
+                    continue;
+                const text = entry.text;
+                if (typeof text !== 'string')
+                    continue;
+                const signal = readExecutionModeFromText(text);
+                if (signal)
+                    return signal;
+            }
+        }
+    }
+    return null;
+}
 // Issue #347 — extract per-turn usage from the host's JSON stream.
 // Codex: `{"type":"turn.completed","usage":{input_tokens, cached_input_tokens, output_tokens, reasoning_output_tokens}}`.
 // Claude Code: `{"type":"result", ..., "usage":{input_tokens, output_tokens, cache_creation_input_tokens, cache_read_input_tokens}, "total_cost_usd": ...}`.
@@ -476,6 +551,29 @@ function readFraimJobFromArgs(rawArgs) {
         return null;
     return { jobId, source: 'get_fraim_job' };
 }
+function readExecutionModeFromText(text) {
+    const marker = '**Execution Mode Context:**';
+    const idx = text.indexOf(marker);
+    if (idx < 0)
+        return null;
+    const jsonStart = text.indexOf('```json', idx);
+    const jsonEnd = text.indexOf('```', jsonStart + 7);
+    if (jsonStart < 0 || jsonEnd < 0)
+        return null;
+    try {
+        const parsed = JSON.parse(text.slice(jsonStart + 7, jsonEnd).trim());
+        const mode = parsed.executionMode?.mode;
+        if (typeof mode !== 'string')
+            return null;
+        return {
+            mode: mode === 'trusted' ? 'trusted' : 'coached',
+            completedRuns: typeof parsed.executionMode?.completedRuns === 'number' ? parsed.executionMode.completedRuns : 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}
 function normalizeToolArgs(rawArgs) {
     if (rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs)) {
         return rawArgs;
@@ -895,10 +993,11 @@ function resolveHostInvocation(plan) {
         args: ['/d', '/s', '/c', [command, ...args].map(escapeWindowsArg).join(' ')],
     };
 }
+// Issue #1256 (slice a, AC-A3): delegates to the shared recovery helper so this probe agrees
+// with server.ts's hubCommandVersion() and fraim doctor's health check on the same PATH,
+// instead of each independently deciding what "the agent's PATH" means.
 function buildAgentVersionProbePath(basePath) {
-    const withoutManaged = (0, managed_agent_paths_1.stripManagedAgentBinDirsFromPath)(basePath);
-    const withoutProjectBins = (0, managed_agent_paths_1.stripProjectLocalNodeBinDirs)(withoutManaged);
-    return (0, managed_agent_paths_1.appendBinDirsToPath)(withoutProjectBins, (0, managed_agent_paths_1.getManagedAgentBinDirs)());
+    return (0, managed_agent_paths_1.buildRecoveredAgentPath)(basePath);
 }
 // Single source for the probe environment, shared by the sync and async probes so the two
 // cannot drift on how agent bin directories are put on PATH. Project-local npm shims are
@@ -918,7 +1017,10 @@ const availableByVersionProbe = (command) => {
     });
     if (result.status !== 0 || result.error)
         return null;
-    return (result.stdout || result.stderr || '').trim() || null;
+    // Issue #1256 (AC-D1/D2): only stdout counts as a version — an agent that exits 0 while
+    // writing only to stderr (e.g. GitHub Copilot CLI's current failure mode) is broken, not
+    // "available with an odd version string".
+    return (0, managed_agent_paths_1.versionFromProbeOutput)(result.stdout, result.stderr);
 };
 // Issue #1010: the async counterpart of availableByVersionProbe. Same semantics (exit 0
 // from `<agent> --version` means the CLI is installed AND actually runs), but non-blocking
@@ -937,7 +1039,11 @@ const availableByVersionProbeAsync = (command) => new Promise((resolve) => {
     let settled = false;
     let timer;
     let child;
-    const chunks = [];
+    // Issue #1256 (AC-D1/D2): kept as separate stdout/stderr buffers rather than one combined
+    // buffer, so a broken CLI that exits 0 while writing only to stderr cannot have its error
+    // text mistaken for a version string.
+    const stdoutChunks = [];
+    const stderrChunks = [];
     const finish = (value) => {
         if (settled)
             return;
@@ -951,8 +1057,8 @@ const availableByVersionProbeAsync = (command) => new Promise((resolve) => {
             env: versionProbeEnv(),
             stdio: ['ignore', 'pipe', 'pipe'],
         });
-        child.stdout?.on('data', (chunk) => chunks.push(chunk));
-        child.stderr?.on('data', (chunk) => chunks.push(chunk));
+        child.stdout?.on('data', (chunk) => stdoutChunks.push(chunk));
+        child.stderr?.on('data', (chunk) => stderrChunks.push(chunk));
         timer = setTimeout(() => {
             console.warn(`[ai-hub] agent version probe timed out after ${VERSION_PROBE_TIMEOUT_MS}ms: ${command}`);
             try {
@@ -965,8 +1071,9 @@ const availableByVersionProbeAsync = (command) => new Promise((resolve) => {
         timer.unref?.();
         child.on('error', () => finish(null));
         child.on('close', (code) => {
-            const raw = Buffer.concat(chunks).toString('utf8').trim();
-            finish(code === 0 ? (raw || null) : null);
+            const stdout = Buffer.concat(stdoutChunks).toString('utf8');
+            const stderr = Buffer.concat(stderrChunks).toString('utf8');
+            finish(code === 0 ? (0, managed_agent_paths_1.versionFromProbeOutput)(stdout, stderr) : null);
         });
     }
     catch {
@@ -986,11 +1093,13 @@ const availableByVersionProbeAsync = (command) => new Promise((resolve) => {
 // cached. The TTL is a safety net for a CLI installed outside the Hub; installs performed
 // THROUGH the Hub invalidate explicitly (see the install-agent route) so they appear at once.
 const EMPLOYEE_DETECTION_TTL_MS = 5 * 60 * 1000;
+const EMPLOYEE_DETECTION_REFRESH_SIGNAL_MS = 500;
 let employeeDetectionTtlMs = EMPLOYEE_DETECTION_TTL_MS;
 let cachedEmployees = null;
 let cachedEmployeesAtMs = 0;
 let cachedEmployeesContext = null;
 let inFlightDetection = null;
+let employeeDetectionRefreshSignalUntilMs = 0;
 function employeeDetectionContext() {
     return JSON.stringify({
         PATH: process.env.PATH || '',
@@ -1080,6 +1189,7 @@ function adoptPersistedEmployees(persisted) {
     cachedEmployeesAtMs = persisted.detectedAtMs;
     cachedEmployeesContext = employeeDetectionContext();
     if (Date.now() - persisted.detectedAtMs > employeeDetectionTtlMs) {
+        employeeDetectionRefreshSignalUntilMs = Date.now() + EMPLOYEE_DETECTION_REFRESH_SIGNAL_MS;
         void detectEmployeesAsync({ force: true }).catch(() => undefined);
     }
     return persisted.employees;
@@ -1116,6 +1226,7 @@ function invalidateEmployeeDetectionCache() {
     cachedEmployeesAtMs = 0;
     cachedEmployeesContext = null;
     inFlightDetection = null;
+    employeeDetectionRefreshSignalUntilMs = 0;
     try {
         fs_1.default.rmSync(agentAvailabilityFilePath(), { force: true });
     }
@@ -1127,6 +1238,7 @@ function __clearEmployeeDetectionMemoryCacheForTests() {
     cachedEmployeesAtMs = 0;
     cachedEmployeesContext = null;
     inFlightDetection = null;
+    employeeDetectionRefreshSignalUntilMs = 0;
 }
 /** Test seam only. Mirrors __resetLatestVersionCache in hub-latest-version.ts. */
 function __setEmployeeDetectionTtlForTests(ttlMs) {
@@ -1158,6 +1270,16 @@ function buildEmployeeStatus(id, version) {
         supportsRaw: supportsDirectPath(id),
     };
 }
+/**
+ * Issue #1256 (slice b, AC-B1): true when a background re-probe is currently in flight —
+ * i.e. the most recent detectEmployees()/detectEmployeesAsync() answer may have been served
+ * from a stale persisted snapshot rather than a fresh probe. bootstrapResponse reads this
+ * right after detection so the client can be told to poll again shortly instead of latching
+ * a one-shot answer.
+ */
+function isEmployeeDetectionRefreshing() {
+    return inFlightDetection !== null || Date.now() < employeeDetectionRefreshSignalUntilMs;
+}
 /**
  * Non-blocking employee detection. Probes every agent CONCURRENTLY, so the cost is the
  * slowest single probe rather than the sum of all of them, and the event loop stays free
@@ -1677,24 +1799,29 @@ function parseHostLine(hostId, line) {
         return {};
     // Scan every line for structured signals the Hub UI cares about:
     // seekMentoring (tracker), get_fraim_job (job identity promotion),
-    // turn-level usage (totals), and fraim_connect agent identity
-    // (cost lookup when the host doesn't emit it).
+    // turn-level usage (totals), fraim_connect agent identity
+    // (cost lookup when the host doesn't emit it), and recurringPark
+    // (marker emitted by the mentor when transitioning to the recurring sentinel).
     const seekMentoring = parseSeekMentoringSignal(trimmed);
     const fraimJob = parseFraimJobLoadSignal(trimmed);
+    const executionMode = parseExecutionModeSignal(trimmed);
     const usage = parseUsageSignal(trimmed);
     const agentIdentity = parseAgentIdentitySignal(trimmed);
+    const recurringPark = parseRecurringParkSignal(trimmed);
     // Issue #1264 (R3): only worth checking when seekMentoring itself did not
     // already resolve — a recognized call has nothing to diagnose.
     const unrecognizedReviewHandoffError = seekMentoring ? null : detectUnrecognizedReviewHandoffCall(trimmed);
     const withSignal = (event) => {
-        if (!seekMentoring && !fraimJob && !usage && !agentIdentity && !unrecognizedReviewHandoffError)
+        if (!seekMentoring && !fraimJob && !executionMode && !usage && !agentIdentity && !recurringPark && !unrecognizedReviewHandoffError)
             return event;
         return {
             ...event,
             ...(seekMentoring ? { seekMentoring } : {}),
             ...(fraimJob ? { fraimJob } : {}),
+            ...(executionMode ? { executionMode } : {}),
             ...(usage ? { usage } : {}),
             ...(agentIdentity ? { agentIdentity } : {}),
+            ...(recurringPark ? { recurringPark: true } : {}),
             ...(unrecognizedReviewHandoffError && !event.hostError ? { hostError: unrecognizedReviewHandoffError } : {}),
         };
     };
@@ -2140,6 +2267,11 @@ class CliHostRuntime {
     detectEmployeesAsync() {
         return detectEmployeesAsync();
     }
+    // Issue #1256 (slice b): lets bootstrapResponse tell the client whether the roster it just
+    // served may be stale while a background re-probe lands.
+    isEmployeeDetectionRefreshing() {
+        return isEmployeeDetectionRefreshing();
+    }
     startRun(hostId, projectPath, message, handlers, sessionId, launchContext) {
         // R11: start/startDirect mint sessions rather than resuming one, so they
         // stay outside the continuation queue entirely.