fraim-hub 2.0.302 → 2.0.303

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/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;
@@ -124,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.
@@ -184,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": ...}`.
@@ -477,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;
@@ -996,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 || '',
@@ -1090,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;
@@ -1126,6 +1226,7 @@ function invalidateEmployeeDetectionCache() {
     cachedEmployeesAtMs = 0;
     cachedEmployeesContext = null;
     inFlightDetection = null;
+    employeeDetectionRefreshSignalUntilMs = 0;
     try {
         fs_1.default.rmSync(agentAvailabilityFilePath(), { force: true });
     }
@@ -1137,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) {
@@ -1176,7 +1278,7 @@ function buildEmployeeStatus(id, version) {
  * a one-shot answer.
  */
 function isEmployeeDetectionRefreshing() {
-    return inFlightDetection !== null;
+    return inFlightDetection !== null || Date.now() < employeeDetectionRefreshSignalUntilMs;
 }
 /**
  * Non-blocking employee detection. Probes every agent CONCURRENTLY, so the cost is the
@@ -1697,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 } : {}),
         };
     };

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

@@ -58,9 +58,6 @@ const brand_store_1 = require("../core/brand-store");
 const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
 const catalog_1 = require("./catalog");
 const job_visualization_1 = require("../core/job-visualization");
-// Issue #1491: reserved sentinel phase a recurring job parks at between
-// scheduled checks (registry/delivery/recurring-checkpoint.md).
-const resolve_phase_edge_1 = require("../core/resolve-phase-edge");
 const custom_employees_1 = require("./custom-employees");
 const agent_token_prices_1 = require("../local-mcp-server/agent-token-prices");
 const hosts_1 = require("./hosts");
@@ -442,7 +439,7 @@ class AiHubRunRegistry {
     }
 }
 // ─── Issue #578: Deployment + Host stores ─────────────────────────────────────
-const VALID_EMPLOYEE_IDS = ['codex', 'claude', 'gemini', 'copilot', 'antigravity'];
+const VALID_HOST_IDS = ['codex', 'claude', 'gemini', 'copilot', 'antigravity'];
 const SCHEDULED_FIRE_LEASE_TTL_MS = 2 * 60 * 1000;
 const SCHEDULED_FIRE_LEASE_PRUNE_MS = 7 * 24 * 60 * 60 * 1000;
 function startSessionSeedForHost(hostId, runId) {
@@ -2614,6 +2611,19 @@ function classifyExit(run, exitCode) {
             const declaredPath = (0, catalog_1.loadJobPhases)(run.jobId, run.projectPath, run.runDiscriminant || 'feature');
             const lastDeclared = declaredPath.length > 0 ? declaredPath[declaredPath.length - 1] : null;
             if (lastDeclared && lastDeclared.id === currentPhase) {
+                // Issues #1491/#1509: the mentor emits <!-- FRAIM_RECURRING_PARK --> in its reply
+                // when it resolves the completed phase to the recurring-checkpoint sentinel.
+                // This takes priority over the 'done' classification because the recurring-checkpoint
+                // phase IS by design the terminal phase of its job — the job is NOT done, it is
+                // parked until its next scheduled invocation.
+                if (run.recurringPark === true) {
+                    // Scheduled/webhook runs park at the recurring sentinel; manager-triggered
+                    // runs are handled conservatively so the manager sees a response.
+                    if (run.sourceTrigger === 'scheduled' || run.sourceTrigger === 'webhook') {
+                        return { action: 'park', pauseReason: 'parked_recurring' };
+                    }
+                    return { action: 'park', pauseReason: 'awaiting_user' };
+                }
                 return { action: 'done', pauseReason: 'done' };
             }
             if (compactingActive) {
@@ -2637,13 +2647,10 @@ function classifyExit(run, exitCode) {
                 // real description, not the post-clear fallback.
                 return { action: 'resume', pauseReason: 'working', recoveryKind: 'background_task_lost', systemNote: describeKilledBackgroundTasks(run) };
             }
-            // Issue #1491: a non-final scheduled/webhook check parks at the reserved
-            // recurring-checkpoint sentinel by design (registry/delivery/recurring-checkpoint.md).
-            // This is not a human-decision gate — the scheduler resumes it on its own. Gated on
-            // sourceTrigger so a manager-initiated run that somehow lands on the sentinel phase
-            // (not expected in normal operation) keeps today's conservative awaiting_user default.
-            if (currentPhase === resolve_phase_edge_1.WAITING_FOR_NEXT_INVOCATION
-                && (run.sourceTrigger === 'scheduled' || run.sourceTrigger === 'webhook')) {
+            // Issues #1491/#1509: also check recurringPark for mid-job phases (not the last
+            // declared phase) — covers jobs where the sentinel is reached before the final step.
+            if ((run.sourceTrigger === 'scheduled' || run.sourceTrigger === 'webhook')
+                && run.recurringPark === true) {
                 return { action: 'park', pauseReason: 'parked_recurring' };
             }
             return { action: 'park', pauseReason: 'awaiting_user' };
@@ -3266,9 +3273,18 @@ class AiHubServer {
         // cache miss the synchronous form would spawnSync per agent (~2.7s) and freeze the
         // event loop, making every concurrent request wait. Falls back to the sync form for
         // HostRuntime stubs that do not implement the async variant.
+        let employeesRefreshing = false;
         const employees = this.hostRuntime.detectEmployeesAsync
-            ? await this.hostRuntime.detectEmployeesAsync()
+            ? await (() => {
+                const wasRefreshing = this.hostRuntime.isEmployeeDetectionRefreshing?.() ?? false;
+                const detection = this.hostRuntime.detectEmployeesAsync();
+                employeesRefreshing = !wasRefreshing && (this.hostRuntime.isEmployeeDetectionRefreshing?.() ?? false);
+                return detection;
+            })()
             : this.hostRuntime.detectEmployees();
+        if (!this.hostRuntime.detectEmployeesAsync) {
+            employeesRefreshing = this.hostRuntime.isEmployeeDetectionRefreshing?.() ?? false;
+        }
         const configuredAgents = this.configuredAgentStore
             .listWithDefaults(employees)
             .map((agent) => (0, configured_agents_1.projectConfiguredAgent)(agent, employees));
@@ -3360,7 +3376,7 @@ class AiHubServer {
             // Issue #1256 (slice b, AC-B1): true when `employees` above may be a stale persisted
             // snapshot while a background re-probe is in flight. The client uses this to schedule
             // a bounded follow-up refresh instead of trusting a one-shot bootstrap forever.
-            employeesRefreshing: this.hostRuntime.isEmployeeDetectionRefreshing?.() ?? false,
+            employeesRefreshing,
             configuredAgents,
             personas,
             // Issue #1005: lets the client tell a resolved projection from the first-paint
@@ -3558,7 +3574,23 @@ class AiHubServer {
         run.resumeCommand = (0, hosts_1.buildInteractiveResumeCommand)(hostIdForCommand, sessionId);
     }
     recordHostEvent(run, hostId, event, channel) {
+        // Issue #1509: reset when a new agent process session starts (system event with
+        // sessionId). Without this, a marker set during a compaction or background-task-lost
+        // auto-resume's first process would bleed into the continuation's unrelated exit and
+        // force parked_recurring on work that has nothing to do with the recurring sentinel.
+        if (channel === 'system' && event.sessionId)
+            run.recurringPark = undefined;
+        // Set once the marker is confirmed in the current process; cleared above at next start.
+        if (event.recurringPark)
+            run.recurringPark = true;
         appendHostMessage(run, hostId, event, channel);
+        if (event.executionMode) {
+            const normalizedMode = event.executionMode.mode === 'trusted' ? 'trusted' : 'coached';
+            const normalizedRuns = typeof event.executionMode.completedRuns === 'number'
+                ? event.executionMode.completedRuns
+                : 0;
+            run.executionMode = { mode: normalizedMode, completedRuns: normalizedRuns };
+        }
         // 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. Issue #1284: a classified recovery signature is
@@ -5458,11 +5490,20 @@ class AiHubServer {
                 }
                 const employees = this.hostRuntime.detectEmployees();
                 const priorBaseHostId = (conversation.baseHostId || conversation.agentName);
-                const priorSessionId = typeof conversation.sessionId === 'string' && conversation.sessionId.trim() ? conversation.sessionId.trim() : '';
                 const resolved = this.resolveLaunchAgent(configuredAgentId, undefined, employees);
+                // Issue #1515: a shared baseHostId (e.g. Codex vs. Codex Azure Script) does not mean
+                // the two configured agents share a session/auth store. Require the base host to
+                // still match, then resolve the owner-qualified host session from #1047's ledger
+                // instead of trusting whichever session the conversation's legacy `sessionId` field
+                // last mirrored, so a switch across an isolated CODEX_HOME always restarts with a
+                // handoff brief rather than attempting a resume that cannot succeed.
+                const resolvedHostSession = priorBaseHostId === resolved.hostId
+                    ? host_session_state_1.hostSessionState.resolve(conversation, { configuredAgentId: resolved.agent.id, baseHostId: resolved.hostId })
+                    : null;
+                const priorSessionId = resolvedHostSession?.sessionId || '';
                 const managerNote = (body.instructions || '').trim() || 'Continue this job from the preserved Hub conversation state.';
                 const handoffSummary = buildAgentSwitchHandoffSummary(conversation);
-                const canResumeSameHost = priorBaseHostId === resolved.hostId && !!priorSessionId;
+                const canResumeSameHost = !!priorSessionId;
                 const initialStrategy = canResumeSameHost ? 'resume_same_host' : 'restart_with_handoff';
                 const activePriorRun = typeof conversation.runId === 'string' ? this.runRegistry.get(conversation.runId) : undefined;
                 if (activePriorRun?.status === 'running') {
@@ -6580,6 +6621,7 @@ class AiHubServer {
                         // offering next-job recommendations immediately, not only once the
                         // resumed session's next seekMentoring signal arrives.
                         current.nextJobRecommendations = null;
+                        current.reviewHandoff = null;
                     });
                     const startedFresh = this.runRegistry.get(run.id);
                     if (startedFresh)
@@ -6639,6 +6681,7 @@ class AiHubServer {
                     // Issue #1373 (Defect 2): see the no-session branch above for why
                     // this can only be stale at coaching-send time.
                     current.nextJobRecommendations = null;
+                    current.reviewHandoff = null;
                 });
                 const started = this.runRegistry.get(run.id);
                 if (started)
@@ -7102,8 +7145,8 @@ class AiHubServer {
             if (!cronLib.validate(cronExpr)) {
                 return res.status(400).json({ error: 'Invalid cron expression.' });
             }
-            const validEmployees = VALID_EMPLOYEE_IDS;
-            const resolvedHostId = validEmployees.includes(hostId) ? hostId : 'claude';
+            const validHosts = VALID_HOST_IDS;
+            const resolvedHostId = validHosts.includes(hostId) ? hostId : 'claude';
             let resolvedProjectPath;
             let normalizedExpiresAt;
             try {
@@ -7212,7 +7255,7 @@ class AiHubServer {
             catch (err) {
                 return res.status(400).json({ error: err instanceof Error ? err.message : 'Invalid project path.' });
             }
-            const validEmployees = VALID_EMPLOYEE_IDS;
+            const validHosts = VALID_HOST_IDS;
             const existing = this.deploymentStore.load().find((d) => d.id === id && d.type === 'scheduled');
             if (!existing)
                 return res.status(404).json({ error: 'Deployment not found.' });
@@ -7221,7 +7264,7 @@ class AiHubServer {
             if (jobId !== undefined && !this.resolveHubJob(resolvedProjectPath !== undefined ? resolvedProjectPath : existing.projectPath, jobId)) {
                 return res.status(400).json(this.invalidScheduleJobIdError(jobId));
             }
-            const nextHostId = hostId !== undefined && validEmployees.includes(hostId) ? hostId : existing.hostId;
+            const nextHostId = hostId !== undefined && validHosts.includes(hostId) ? hostId : existing.hostId;
             const nextConfiguredAgentId = configuredAgentId !== undefined
                 ? (typeof configuredAgentId === 'string' && configuredAgentId.trim() ? configuredAgentId.trim() : undefined)
                 : existing.configuredAgentId;
@@ -7294,8 +7337,8 @@ class AiHubServer {
             if (!label || !jobId) {
                 return res.status(400).json({ error: 'label and jobId are required.' });
             }
-            const validEmployees = VALID_EMPLOYEE_IDS;
-            const resolvedHostId = validEmployees.includes(hostId) ? hostId : 'claude';
+            const validHosts = VALID_HOST_IDS;
+            const resolvedHostId = validHosts.includes(hostId) ? hostId : 'claude';
             const now = new Date().toISOString();
             const deployment = {
                 id: (0, crypto_1.randomUUID)(),
@@ -7347,7 +7390,7 @@ class AiHubServer {
             catch (err) {
                 return res.status(400).json({ error: err instanceof Error ? err.message : 'Invalid project path.' });
             }
-            const validEmployees = VALID_EMPLOYEE_IDS;
+            const validHosts = VALID_HOST_IDS;
             let updated = null;
             const ok = this.deploymentStore.update(id, (dep) => {
                 if (label !== undefined)
@@ -7356,7 +7399,7 @@ class AiHubServer {
                     dep.jobId = jobId;
                 if (resolvedProjectPath !== undefined)
                     dep.projectPath = resolvedProjectPath;
-                if (hostId !== undefined && validEmployees.includes(hostId))
+                if (hostId !== undefined && validHosts.includes(hostId))
                     dep.hostId = hostId;
                 if (configuredAgentId !== undefined)
                     dep.configuredAgentId = typeof configuredAgentId === 'string' && configuredAgentId.trim() ? configuredAgentId.trim() : undefined;
@@ -7640,23 +7683,33 @@ class AiHubServer {
         // Stable API endpoint for extension surfaces (Office add-ins, browser
         // extensions, VS Code extensions, Electron tray) to start FRAIM jobs.
         //
-        // Body: { employeeId, jobName, context?: { text, sourceApp, fileName, ... }, projectPath? }
-        // Response: { runId, status: "started", employee, job }
+        // Body: { configuredAgentId?, hostId?, personaKey?, jobName, context?, projectPath? }
+        // Response: { hubRunId, status, hostId, configuredAgentId, personaKey, jobName }
         // -------------------------------------------------------------------------
         this.app.post('/api/trigger', (req, res) => {
             try {
-                const { employeeId, jobName, context, projectPath: reqProjectPath } = req.body;
-                if (!employeeId) {
-                    return res.status(400).json({ error: 'employeeId is required.' });
-                }
+                const { jobName, context, projectPath: reqProjectPath } = req.body;
+                const configuredAgentId = typeof req.body.configuredAgentId === 'string' ? req.body.configuredAgentId.trim() : '';
+                const hostIdInput = typeof req.body.hostId === 'string' ? req.body.hostId.trim() : '';
+                const explicitPersonaKey = typeof req.body.personaKey === 'string' ? req.body.personaKey.trim() : '';
                 if (!jobName) {
                     return res.status(400).json({ error: 'jobName is required.' });
                 }
+                if (hostIdInput && !VALID_HOST_IDS.includes(hostIdInput)) {
+                    return res.status(400).json({ error: 'hostId must be one of the supported execution hosts.' });
+                }
                 const projectPath = ensureDirectoryPath(reqProjectPath || this.defaultProjectPath());
-                // Use the requested agent directly — caller specifies which agent to run (claude, codex, gemini).
-                const requestedAgentId = req.body.configuredAgentId || employeeId;
-                const requestedHostId = VALID_EMPLOYEE_IDS.includes(employeeId) ? employeeId : undefined;
-                const { hostId, agent: configuredAgent, launchContext } = this.resolveLaunchAgent(requestedAgentId, requestedHostId);
+                // Use the requested configured profile or base host directly.
+                const requestedConfiguredAgentId = configuredAgentId || undefined;
+                const requestedHostId = hostIdInput ? hostIdInput : undefined;
+                if (!requestedConfiguredAgentId && !requestedHostId) {
+                    return res.status(400).json({ error: 'configuredAgentId or hostId is required.' });
+                }
+                const { hostId, agent: configuredAgent, launchContext } = this.resolveLaunchAgent(requestedConfiguredAgentId, requestedHostId);
+                if (requestedConfiguredAgentId && requestedHostId && hostId !== requestedHostId) {
+                    return res.status(400).json({ error: 'configuredAgentId does not match hostId.' });
+                }
+                const personaKey = explicitPersonaKey || getCustomPersonaForJob(projectPath, jobName) || getHubPersonaForJob(jobName);
                 const contextText = context?.text?.trim() || '';
                 const sourceInfo = [
                     context?.sourceApp ? `sourceApp: ${context.sourceApp}` : '',
@@ -7687,8 +7740,7 @@ class AiHubServer {
                     phaseVisits: [],
                     totals: emptyTotals(),
                     lastStatusChangeAt: startTimestamp,
-                    // Issue #1357: consult custom persona owner before falling back to catalog.
-                    personaKey: getCustomPersonaForJob(projectPath, jobName) ?? getHubPersonaForJob(jobName),
+                    personaKey,
                 };
                 // Register the run before spawning so onEvent/onExit callbacks can
                 // safely call update() even if they fire synchronously (FakeHostRuntime).
@@ -7726,7 +7778,14 @@ class AiHubServer {
                 }, startSessionSeedForHost(hostId, run.id), this.withHubRunIdEnv(launchContext, run.id));
                 // Update the registry entry with the real child process handle.
                 this.runRegistry.attachChildIfRunning(run.id, child);
-                return res.json({ runId: run.id, status: 'started', employee: employeeId, job: jobName });
+                return res.json({
+                    hubRunId: run.id,
+                    status: 'started',
+                    hostId,
+                    configuredAgentId: configuredAgent.id,
+                    personaKey,
+                    jobName,
+                });
             }
             catch (error) {
                 return res.status(400).json({ error: error instanceof Error ? error.message : 'Could not start run.' });

package/dist/src/config/persona-capability-bundles.js

@@ -81,7 +81,7 @@ exports.PERSONA_CAPABILITY_BUNDLES = {
         personaKey: 'huxley',
         bundleId: 'persona-huxley-core',
         catalogMetadata: buildCatalogMetadata('huxley', ['design-system-creation', 'user-facing-prototyping', 'ux-research-synthesis']),
-        protectedJobs: ['design-system-creation', 'user-facing-prototyping', 'website-creation', 'brand-creation', 'branding-quality-audit', 'ux-research-synthesis', 'user-journey-mapping'],
+        protectedJobs: ['design-system-creation', 'user-facing-prototyping', 'website-creation', 'brand-creation', 'branding-quality-audit', 'ux-research-synthesis', 'user-journey-mapping', 'ui-quality-assessment'],
         protectedAliases: ['ux-design', 'brand-design'],
         defaultHireMode: 'job',
         lockCopy: 'Hire hUXley to unlock design-system, UX research, and brand design work for this request.'

package/dist/src/core/quality-evidence.js

@@ -39,6 +39,8 @@ exports.QUALITY_REGISTRY = {
     'branding-quality-audit': { stage: 'branding', enforced: true, telemetryKind: 'score' },
     // Product Quality
     'code-quality-assessment': { stage: 'product-quality', enforced: true, telemetryKind: 'score' },
+    // UI/UX Quality
+    'ui-quality-assessment': { stage: 'ui-ux-quality', enforced: true, telemetryKind: 'score' },
     // Test Quality
     'test-quality-assessment': { stage: 'test-quality', enforced: true, telemetryKind: 'score' },
     // Security
@@ -76,6 +78,7 @@ exports.STAGE_DISPLAY_NAMES = {
     'business-strategy': 'Business Strategy',
     'branding': 'Branding',
     'product-quality': 'Product Quality',
+    'ui-ux-quality': 'UI/UX Quality',
     'test-quality': 'Test Quality',
     'security': 'Security',
     'production-readiness': 'Production Readiness',
@@ -90,6 +93,7 @@ exports.ALL_STAGE_CATEGORIES = [
     'business-strategy',
     'branding',
     'product-quality',
+    'ui-ux-quality',
     'test-quality',
     'security',
     'production-readiness',
@@ -153,6 +157,12 @@ const QUALITY_SCORE_DIMENSIONS = {
         'architecture',
         'maintainability'
     ],
+    'ui-quality-assessment': [
+        'lookAndFeel',
+        'usabilityHeuristics',
+        'interactionConsistency',
+        'accessibility'
+    ],
     'test-quality-assessment': [
         'coverage',
         'testIntegrity',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-hub",
-  "version": "2.0.302",
+  "version": "2.0.303",
   "description": "FRAIM Hub local companion package.",
   "author": "Sid Mathur <sid.mathur@gmail.com>",
   "homepage": "https://github.com/mathursrus/FRAIM#readme",
@@ -211,7 +211,7 @@
     "electron-updater": "^6.8.9",
     "express": "^5.2.1",
     "extract-zip": "^2.0.1",
-    "fraim": "2.0.302",
+    "fraim": "2.0.303",
     "mongodb": "^7.0.0",
     "node-cron": "4.2.1",
     "node-edge-tts": "^1.2.10",

package/public/ai-hub/script.js

@@ -3187,6 +3187,15 @@ function truncateKickoffForTitle(text) {
   return words.slice(0, 6).join(' ');
 }
 
+function hasManagerKickoffMessage(conv) {
+  return !!(conv && Array.isArray(conv.messages)
+    && conv.messages.some((message) => message && message.role === 'manager' && (message.text || '').trim()));
+}
+
+function savedTitleMatchesKickoff(conv, kickoffText) {
+  return !!(conv && conv.title && String(conv.title).replace(/\s+/g, ' ').trim() === String(kickoffText || '').replace(/\s+/g, ' ').trim());
+}
+
 function kickoffDescription(conv) {
   const text = managerKickoffText(conv);
   if (!text) return '';
@@ -3197,9 +3206,12 @@ function kickoffDescription(conv) {
 function composedConversationTitle(conv) {
   if (!conv) return '';
   const jobName = resolvedConversationJobName(conv);
-  const kickoff = truncateKickoffForTitle(managerKickoffText(conv));
+  const kickoffText = managerKickoffText(conv);
+  const kickoff = truncateKickoffForTitle(kickoffText);
   if (jobName && kickoff) return `${jobName}: ${kickoff}`;
   if (jobName) return jobName;
+  if (kickoff && hasManagerKickoffMessage(conv) && savedTitleMatchesKickoff(conv, kickoffText)) return kickoff;
+  if (conv && conv.title) return conv.title;
   if (kickoff) return kickoff;
   return 'New job';
 }