fraim-hub 2.0.310 → 2.0.312

package/dist/src/ai-hub/hub-main-diagnostics.js

@@ -0,0 +1,278 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HubMainDiagnostics = void 0;
+exports.getHubMainDiagnostics = getHubMainDiagnostics;
+exports.resetHubMainDiagnosticsForTest = resetHubMainDiagnosticsForTest;
+exports.recordHubMainDiagnostic = recordHubMainDiagnostic;
+exports.getHubMainDiagnosticsSnapshot = getHubMainDiagnosticsSnapshot;
+exports.installHubMainConsoleTee = installHubMainConsoleTee;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = __importDefault(require("node:util"));
+const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+const version_utils_1 = require("../cli/utils/version-utils");
+const DEFAULT_MAX_EVENTS = 100;
+const DEFAULT_MAX_CURRENT_BYTES = 1024 * 1024;
+const DEFAULT_MAX_RETAINED_CHUNKS = 20;
+const DEFAULT_MAX_RETAINED_BYTES = 50 * 1024 * 1024;
+const MAX_STRING_LENGTH = 1000;
+const SENSITIVE_KEY_PATTERN = /token|secret|password|api[-_]?key|credential|authorization/i;
+const EMAIL_PATTERN = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
+const SENSITIVE_TEXT_PATTERNS = [
+    /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g,
+    /\bsk-[A-Za-z0-9]{48,}\b/g,
+    /\bgh[pousr]_[A-Za-z0-9]{36,}\b/g,
+    /\bAKIA[0-9A-Z]{16}\b/g,
+    /\bSG\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}\b/g,
+    /\bsk_live_[A-Za-z0-9]{24,}\b/g,
+    /(?:authorization|api[-_]?key|token|secret|password|credential)(["'\s:=]+)([^"',\s]{8,})/gi,
+];
+function resolveDefaultLogDir() {
+    try {
+        return node_path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'logs');
+    }
+    catch {
+        return node_path_1.default.join(node_os_1.default.homedir(), '.fraim', 'logs');
+    }
+}
+function redactSensitiveText(value) {
+    let redacted = value.replace(EMAIL_PATTERN, '[redacted-email]');
+    for (const pattern of SENSITIVE_TEXT_PATTERNS) {
+        redacted = redacted.replace(pattern, (match, separator) => {
+            if (typeof separator === 'string' && match.includes(separator)) {
+                return match.replace(new RegExp(`${separator.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}.*$`), `${separator}[redacted]`);
+            }
+            return '[redacted-secret]';
+        });
+    }
+    return redacted;
+}
+function boundedString(value, max = MAX_STRING_LENGTH) {
+    const redacted = redactSensitiveText(value);
+    return redacted.length > max ? `${redacted.slice(0, max)}...[truncated ${redacted.length - max} chars]` : redacted;
+}
+function safeFileSegment(value) {
+    const sanitized = value.replace(/[^a-z0-9._-]+/gi, '-').replace(/^-+|-+$/g, '');
+    return sanitized || 'hub';
+}
+function sanitizeDetail(value, depth = 0) {
+    if (value == null || typeof value === 'boolean' || typeof value === 'number')
+        return value;
+    if (typeof value === 'string')
+        return boundedString(value);
+    if (value instanceof Error)
+        return { name: value.name, message: boundedString(value.message) };
+    if (depth >= 4)
+        return '[truncated-depth]';
+    if (Array.isArray(value))
+        return value.slice(0, 20).map((item) => sanitizeDetail(item, depth + 1));
+    if (typeof value === 'object') {
+        const out = {};
+        for (const [key, item] of Object.entries(value).slice(0, 40)) {
+            out[key] = SENSITIVE_KEY_PATTERN.test(key) ? '[redacted]' : sanitizeDetail(item, depth + 1);
+        }
+        return out;
+    }
+    return boundedString(String(value));
+}
+function toDetails(details) {
+    if (!details)
+        return undefined;
+    const sanitized = sanitizeDetail(details);
+    return sanitized && typeof sanitized === 'object' && !Array.isArray(sanitized)
+        ? sanitized
+        : { value: sanitized };
+}
+function safeStat(filePath) {
+    try {
+        return node_fs_1.default.statSync(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+function buildVersions() {
+    return {
+        node: process.versions.node,
+        ...(process.versions.electron ? { electron: process.versions.electron } : {}),
+        ...(process.versions.chrome ? { chrome: process.versions.chrome } : {}),
+    };
+}
+class HubMainDiagnostics {
+    constructor(options = {}) {
+        this.events = [];
+        this.rotationSequence = 0;
+        this.lastWriteError = null;
+        this.lastRenderProcessGone = null;
+        this.lastChildProcessGone = null;
+        this.lastUnresponsiveAt = null;
+        this.lastResponsiveAt = null;
+        this.runtimeId = options.runtimeId || process.env.FRAIM_HUB_RUNTIME_ID || 'hub';
+        this.now = options.now || (() => new Date());
+        this.maxEvents = options.maxEvents || DEFAULT_MAX_EVENTS;
+        this.maxCurrentBytes = options.maxCurrentBytes || DEFAULT_MAX_CURRENT_BYTES;
+        this.maxRetainedChunks = options.maxRetainedChunks || DEFAULT_MAX_RETAINED_CHUNKS;
+        this.maxRetainedBytes = options.maxRetainedBytes || DEFAULT_MAX_RETAINED_BYTES;
+        this.logDir = node_path_1.default.resolve(options.logDir || resolveDefaultLogDir());
+        this.logPath = node_path_1.default.join(this.logDir, 'hub-main.log');
+    }
+    record(type, details) {
+        const event = {
+            type,
+            timestamp: this.now().toISOString(),
+            runtimeId: this.runtimeId,
+            pid: process.pid,
+            appVersion: (0, version_utils_1.getFraimVersion)(),
+            ...(details ? { details: toDetails(details) } : {}),
+        };
+        this.events.push(event);
+        if (this.events.length > this.maxEvents)
+            this.events.splice(0, this.events.length - this.maxEvents);
+        if (type === 'webcontents.render_process_gone')
+            this.lastRenderProcessGone = event;
+        if (type === 'app.child_process_gone')
+            this.lastChildProcessGone = event;
+        if (type === 'webcontents.unresponsive')
+            this.lastUnresponsiveAt = event.timestamp;
+        if (type === 'webcontents.responsive')
+            this.lastResponsiveAt = event.timestamp;
+        this.persist(event);
+        return event;
+    }
+    snapshot(window = null) {
+        const current = safeStat(this.logPath);
+        return {
+            ok: true,
+            process: {
+                pid: process.pid,
+                platform: process.platform,
+                versions: buildVersions(),
+                uptimeSeconds: Math.round(process.uptime()),
+            },
+            log: {
+                path: this.logPath,
+                directory: this.logDir,
+                exists: Boolean(current),
+                bytes: current?.size || 0,
+                maxCurrentBytes: this.maxCurrentBytes,
+                retainedChunks: this.retainedChunks(),
+                lastWriteError: this.lastWriteError,
+            },
+            window,
+            lastEvents: [...this.events],
+            lastRenderProcessGone: this.lastRenderProcessGone,
+            lastChildProcessGone: this.lastChildProcessGone,
+            lastUnresponsiveAt: this.lastUnresponsiveAt,
+            lastResponsiveAt: this.lastResponsiveAt,
+            capturedAt: this.now().toISOString(),
+        };
+    }
+    persist(event) {
+        try {
+            node_fs_1.default.mkdirSync(this.logDir, { recursive: true });
+            const line = `${JSON.stringify(event)}\n`;
+            const current = safeStat(this.logPath);
+            if (current && current.size > 0 && current.size + Buffer.byteLength(line, 'utf8') > this.maxCurrentBytes) {
+                this.rotateCurrentLog();
+            }
+            node_fs_1.default.appendFileSync(this.logPath, line, 'utf8');
+            this.lastWriteError = null;
+        }
+        catch (error) {
+            this.lastWriteError = error instanceof Error ? boundedString(error.message, 500) : boundedString(String(error), 500);
+        }
+    }
+    rotateCurrentLog() {
+        if (!node_fs_1.default.existsSync(this.logPath))
+            return;
+        const timestamp = this.now().toISOString().replace(/[-:]/g, '').replace(/\.\d{3}Z$/, 'Z');
+        const chunkPath = node_path_1.default.join(this.logDir, `hub-main-${timestamp}-${safeFileSegment(this.runtimeId)}-${String(this.rotationSequence).padStart(4, '0')}.log`);
+        this.rotationSequence += 1;
+        node_fs_1.default.renameSync(this.logPath, chunkPath);
+        this.pruneRetainedChunks();
+    }
+    retainedChunks() {
+        try {
+            return node_fs_1.default.readdirSync(this.logDir)
+                .filter((name) => /^hub-main-.+\.log$/.test(name))
+                .map((name) => {
+                const filePath = node_path_1.default.join(this.logDir, name);
+                const stat = node_fs_1.default.statSync(filePath);
+                return { path: filePath, bytes: stat.size, modifiedAt: stat.mtime.toISOString() };
+            })
+                .sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt));
+        }
+        catch {
+            return [];
+        }
+    }
+    pruneRetainedChunks() {
+        const chunks = this.retainedChunks();
+        let retainedBytes = 0;
+        chunks.forEach((chunk, index) => {
+            retainedBytes += chunk.bytes;
+            if (index < this.maxRetainedChunks && retainedBytes <= this.maxRetainedBytes)
+                return;
+            try {
+                node_fs_1.default.unlinkSync(chunk.path);
+            }
+            catch {
+                // Best effort pruning; endpoint still reports remaining chunks.
+            }
+        });
+    }
+}
+exports.HubMainDiagnostics = HubMainDiagnostics;
+let singleton = null;
+let consoleTeeInstalled = false;
+let inConsoleTee = false;
+function getHubMainDiagnostics() {
+    if (!singleton)
+        singleton = new HubMainDiagnostics();
+    return singleton;
+}
+function resetHubMainDiagnosticsForTest(options = {}) {
+    singleton = new HubMainDiagnostics(options);
+    return singleton;
+}
+function recordHubMainDiagnostic(type, details) {
+    return getHubMainDiagnostics().record(type, details);
+}
+function getHubMainDiagnosticsSnapshot(window = null) {
+    return getHubMainDiagnostics().snapshot(window);
+}
+function installHubMainConsoleTee() {
+    if (consoleTeeInstalled)
+        return;
+    consoleTeeInstalled = true;
+    const originals = {
+        log: console.log.bind(console),
+        warn: console.warn.bind(console),
+        error: console.error.bind(console),
+    };
+    const wrap = (level, type) => {
+        return (...args) => {
+            originals[level](...args);
+            if (inConsoleTee)
+                return;
+            inConsoleTee = true;
+            try {
+                getHubMainDiagnostics().record(type, { message: node_util_1.default.format(...args) });
+            }
+            catch (error) {
+                originals.warn('[fraim] hub main diagnostic console tee failed:', error);
+            }
+            finally {
+                inConsoleTee = false;
+            }
+        };
+    };
+    console.log = wrap('log', 'log.info');
+    console.warn = wrap('warn', 'log.warn');
+    console.error = wrap('error', 'log.error');
+    getHubMainDiagnostics().record('hub.log_tee_installed');
+}

package/dist/src/ai-hub/restart-recovery-policy.js

@@ -67,6 +67,17 @@ class RestartRecoveryPolicy {
         if (['stopped', 'done', 'awaiting_review', 'awaiting_user'].includes(pauseReason)) {
             return { action: 'skip', reason: `pause_${pauseReason}` };
         }
+        // Issue #1634: `activeRunExists` is direct, in-process proof this run is not
+        // orphaned — it must outrank every "does this LOOK orphaned" heuristic below.
+        // A freshly-fired scheduled/webhook run legitimately has no sessionId yet (the
+        // host CLI hasn't reported one) for its entire lifetime if it is short-lived;
+        // checking `missing_session` first force-failed a run that was actively
+        // executing in this same process, the instant its status became observably
+        // 'running' (issue #1634's own fix for that visibility gap is what turned this
+        // from a narrow, mostly-unreachable window into a routinely-hit one).
+        if (options.activeRunExists) {
+            return { action: 'defer', reason: 'active_run_exists' };
+        }
         if (!conversation.sessionId || typeof conversation.sessionId !== 'string' || !conversation.sessionId.trim()) {
             return { action: 'skip', reason: 'missing_session' };
         }
@@ -81,9 +92,6 @@ class RestartRecoveryPolicy {
         if (conversation.reviewHandoff?.reviewRequired) {
             return { action: 'skip', reason: 'awaiting_review' };
         }
-        if (options.activeRunExists) {
-            return { action: 'defer', reason: 'active_run_exists' };
-        }
         // Issue #1159: `activeRunExists` only sees this process's run registry, so it
         // cannot tell that a *different* live Hub owns this run. Two Hubs on one
         // machine is the normal case here: the desktop Hub plus any Hub a job starts

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

@@ -69,6 +69,7 @@ const manager_turns_1 = require("./manager-turns");
 const preferences_1 = require("./preferences");
 const conversation_store_1 = require("./conversation-store");
 const raw_event_log_store_1 = require("./raw-event-log-store");
+const hub_main_diagnostics_1 = require("./hub-main-diagnostics");
 const run_working_directory_1 = require("./run-working-directory");
 const conversation_search_1 = require("./conversation-search");
 const conversation_search_index_1 = require("./conversation-search-index");
@@ -3005,6 +3006,7 @@ class AiHubServer {
             userDataDir: process.env.FRAIM_BROWSER_USER_DATA_DIR || undefined,
             explicitPath: process.env.FRAIM_BROWSER_PATH || undefined,
         });
+        this.hubMainDiagnostics = options.hubMainDiagnostics || { snapshot: () => (0, hub_main_diagnostics_1.getHubMainDiagnosticsSnapshot)(null) };
         this.hostRuntime = options.hostRuntime || (process.env.FRAIM_AI_HUB_FAKE_HOST === '1' ? new hosts_1.FakeHostRuntime() : new hosts_1.CliHostRuntime());
         // Issue #701 / #749: the AI Hub is a loopback companion that runs on user machines and
         // never touches a database. Persona and manager-team state resolve from the hosted server
@@ -5008,6 +5010,9 @@ class AiHubServer {
                 'from the Hub job catalog, not the per-run tracking UUID returned by get_fraim_job\'s "Job ID" field.',
         };
     }
+    isAdhocPromptJobId(jobId) {
+        return typeof jobId === 'string' && jobId.trim() === 'adhoc-prompt';
+    }
     applySeekMentoringSignalToRun(run, signal) {
         // Issue #732: promote using the stable jobName slug, not the per-call UUID
         // jobId (resolveHubJob would never match a UUID, leaving a freeform run
@@ -6122,6 +6127,17 @@ class AiHubServer {
         this.app.get('/api/ai-hub/pid', (_req, res) => {
             return res.json({ pid: process.pid });
         });
+        this.app.get('/api/ai-hub/debug/window-state', (_req, res) => {
+            try {
+                (0, hub_main_diagnostics_1.recordHubMainDiagnostic)('debug.window_state_requested');
+                return res.json(this.hubMainDiagnostics.snapshot());
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                (0, hub_main_diagnostics_1.recordHubMainDiagnostic)('debug.window_state_failed', { error: message });
+                return res.status(500).json({ error: message });
+            }
+        });
         // Issue #1415/#1379: the update badge's click handler POSTs here instead of just telling the
         // user to quit and relaunch by hand. `restartToLatest` (the Electron shell's
         // restartToLatestNow) responds before it actually tears the process down, so the client can
@@ -6485,10 +6501,25 @@ class AiHubServer {
                 return res.status(404).json({ error: 'Configured agent not found or cannot be deleted.' });
             return res.json({ ok: true });
         });
-        this.app.post('/api/ai-hub/configured-agents/:id/check', (req, res) => {
+        this.app.post('/api/ai-hub/configured-agents/:id/check', async (req, res) => {
             if (!this.requireTrustedHubOrigin(req, res))
                 return;
-            const employees = this.hostRuntime.detectEmployees();
+            // Issue #1618: this is the manager's explicit "check now" action, so it must reflect
+            // reality immediately rather than serving the up-to-5-minute-stale detection cache -
+            // the same reasoning installAgentAndRefreshDetection() already applies after install
+            // (see the comment above that function, server.ts:~2430).
+            (0, hosts_1.invalidateEmployeeDetectionCache)();
+            // Security review (implement-security-review, issue #1618): prefer the non-blocking
+            // parallel probe here for the same reason bootstrapResponse() does (server.ts:~3939) -
+            // invalidating the cache on every click means this route now pays the full re-probe
+            // cost every time instead of at most once per TTL window, so the synchronous form
+            // would let a manager repeatedly clicking Check block the single-threaded Hub event
+            // loop for ~1-3s per click, reintroducing the exact issue-#1010 unresponsiveness this
+            // route previously avoided only by accident (via the cache). Falls back to the sync
+            // form for HostRuntime stubs that do not implement the async variant.
+            const employees = this.hostRuntime.detectEmployeesAsync
+                ? await this.hostRuntime.detectEmployeesAsync()
+                : this.hostRuntime.detectEmployees();
             const agent = this.configuredAgentsForCurrentMachine(employees).find((entry) => entry.id === req.params.id);
             if (!agent)
                 return res.status(404).json({ error: 'Configured agent not found.' });
@@ -7496,9 +7527,15 @@ class AiHubServer {
             // Issue #1477 R1/R2: reject a jobId that doesn't resolve to a known catalog entry
             // (e.g. the per-run tracking UUID from get_fraim_job, mistaken for this field in
             // the reported repro) before the deployment is ever persisted.
-            if (!this.resolveHubJob(resolvedProjectPath, jobId)) {
+            const isAdhocPrompt = this.isAdhocPromptJobId(jobId);
+            if (!isAdhocPrompt && !this.resolveHubJob(resolvedProjectPath, jobId)) {
                 return res.status(400).json(this.invalidScheduleJobIdError(jobId));
             }
+            // Issue #1610 R3: adhoc-prompt has no fixed task — the instructions field is its
+            // sole driver. An adhoc-prompt schedule with no instructions would silently do nothing.
+            if (isAdhocPrompt && !(typeof instructions === 'string' && instructions.trim())) {
+                return res.status(400).json({ error: 'Ad-hoc assignments require a non-empty instructions field.' });
+            }
             const normalizedConversationId = typeof conversationId === 'string' && conversationId.trim()
                 ? conversationId.trim()
                 : undefined;
@@ -7598,9 +7635,19 @@ class AiHubServer {
                 return res.status(404).json({ error: 'Deployment not found.' });
             // Issue #1477 R3: same catalog validation as create, applied only when jobId is
             // actually part of this update.
-            if (jobId !== undefined && !this.resolveHubJob(resolvedProjectPath !== undefined ? resolvedProjectPath : existing.projectPath, jobId)) {
+            if (jobId !== undefined && !this.isAdhocPromptJobId(jobId) && !this.resolveHubJob(resolvedProjectPath !== undefined ? resolvedProjectPath : existing.projectPath, jobId)) {
                 return res.status(400).json(this.invalidScheduleJobIdError(jobId));
             }
+            // Issue #1610 R4: guard the same invariant as POST — an adhoc-prompt deployment
+            // must always have non-empty instructions. Compute the effective post-update values
+            // before writing so we can reject before any state change.
+            const effectiveJobId = jobId !== undefined ? jobId : existing.jobId;
+            const effectiveInstructions = instructions !== undefined
+                ? (typeof instructions === 'string' ? instructions.trim() : undefined)
+                : existing.instructions;
+            if (effectiveJobId === 'adhoc-prompt' && !effectiveInstructions) {
+                return res.status(400).json({ error: 'Ad-hoc assignments require a non-empty instructions field.' });
+            }
             const nextHostId = hostId !== undefined && validHosts.includes(hostId) ? hostId : existing.hostId;
             const nextConfiguredAgentId = configuredAgentId !== undefined
                 ? (typeof configuredAgentId === 'string' && configuredAgentId.trim() ? configuredAgentId.trim() : undefined)
@@ -8354,6 +8401,13 @@ class AiHubServer {
         // can call runRegistry.update without "Run not found" throws.
         this.runRegistry.create(run, {});
         this.deploymentStore.update(deployment.id, (d) => { d.activeRunId = run.id; });
+        // Issue #1634 (Defect B): persist status: 'running' synchronously, before the
+        // host process is launched. Without this, the persisted conversation is only
+        // ever written on the first stream event (onEvent) or at exit (onExit) — a
+        // job fast enough to finish before its first stream event lands can go
+        // straight from one 'completed' state to the next, with 'running' never
+        // observably written for any poll to find.
+        this.persistRunConversation(run, run.conversationId || run.id);
         const handlers = {
             onEvent: (event, channel) => {
                 this.runRegistry.update(run.id, (current) => {
@@ -8376,19 +8430,17 @@ class AiHubServer {
                 if (updated)
                     this.scheduleRunConversationPersistence(updated, updated.conversationId || updated.id);
             },
-            onExit: (exitCode) => {
-                this.runRegistry.update(run.id, (r) => {
-                    r.exitCode = exitCode;
-                    r.status = exitCode === 0 ? 'completed' : 'failed';
-                    r.events.push((0, hosts_1.createHubEvent)('system', `Run exited with code ${exitCode ?? 'unknown'}.${hostErrorSuffix(r)}`));
-                    pushTerminalFailureToThread(r, exitCode);
-                });
-                const updated = this.runRegistry.get(run.id);
-                if (updated)
-                    this.persistRunConversation(updated, updated.conversationId || updated.id);
+            // Issue #1634 (Defect A): route through the shared handleRunExit()/classifyExit()
+            // chokepoint (issue #904), matching every other run-exit call site in this file
+            // (server.ts:4678, 4992, 7396, 7632, 7726, 9315 as of this change). The previous
+            // bespoke handler below set status/exitCode directly and never called
+            // classifyExit(), so a deployment-triggered exit's pauseReason was never computed
+            // — the recurringPark latch set mid-run (via the shared onEvent -> recordHostEvent
+            // path above) was silently discarded, and a compaction/background-task exit was
+            // force-terminated instead of auto-continuing like a manager-started run.
+            onExit: (exitCode) => this.handleRunExit(run.id, exitCode, () => {
                 this.deploymentStore.update(deployment.id, (d) => { d.activeRunId = undefined; });
-                this.runRegistry.dispose(run.id);
-            },
+            }),
         };
         const childLaunchContext = this.withHubRunIdEnv(launchContext, run.id);
         const child = existingHostSession

package/dist/src/cli/setup/ide-invocation-surfaces.js

@@ -72,7 +72,7 @@ ${buildDeferredToolBootstrapSection(profile)}1. **Confirm FRAIM activation**:
    If local FRAIM job stubs are present in the workspace, inspect those first and match the request locally. Also inspect \`fraim/personalized-employee/jobs/\` for local overrides or repo-specific jobs. If local files are missing or you cannot inspect workspace files, call \`list_fraim_jobs()\` to view the full catalog, including any proxy-discoverable personalized jobs.
 
 3. **Find the match**:
-   If the user names an exact FRAIM job, call \`get_fraim_job({ job: "<job-name>" })\` directly. Otherwise, match the user's request to a FRAIM job from the local stub catalog, \`fraim/personalized-employee/jobs/\`, or the full \`list_fraim_jobs()\` response. If no exact or high-confidence job match exists, say that no FRAIM job matches and continue with normal tools or ask one concise clarification. Do not pick the nearest catalog job.
+   If the user names an exact FRAIM job, call \`get_fraim_job({ job: "<job-name>" })\` directly. Otherwise, match the user's request to a FRAIM job from the local stub catalog, \`fraim/personalized-employee/jobs/\`, or the full \`list_fraim_jobs()\` response. If no exact or high-confidence job match exists, ask once: "No catalog job matches. Would you like to run this as an ad-hoc task?" On confirmation, call \`get_fraim_job({ job: "adhoc-prompt" })\` and execute it with the user's instructions as the task input — do not pick the nearest catalog job. Do not ask again if the user already provided instructions.
 
 4. **Load the full content**:
    - For jobs, call \`get_fraim_job({ job: "<matched-job-name>" })\`.

package/dist/src/cli/setup/user-level-sync.js

@@ -125,6 +125,10 @@ function ensureUserLevelDependencies(userFraimDir) {
     if (missing.length === 0) {
         return;
     }
+    if (process.env.FRAIM_SKIP_USER_LEVEL_DEP_INSTALL === '1') {
+        console.log(chalk_1.default.yellow(`TEST_MODE: skipping user-level runtime dependency install (${missing.join(', ')}).`));
+        return;
+    }
     console.log(chalk_1.default.blue(`📦 Installing user-level runtime dependencies (${missing.join(', ')})...`));
     try {
         (0, child_process_1.execSync)('npm install --no-audit --no-fund --no-save --no-package-lock --omit=dev', {

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PERSONA_CAPABILITY_BUNDLES = exports.FREE_JOBS = exports.GENERIC_WORKER_PERSONA_KEY = void 0;
+exports.UNOWNED_EXEMPT_JOBS = exports.PERSONA_CAPABILITY_BUNDLES = exports.FREE_JOBS = exports.GENERIC_WORKER_PERSONA_KEY = void 0;
 exports.isFreeJob = isFreeJob;
 exports.getPersonaCapabilityBundle = getPersonaCapabilityBundle;
 exports.getProtectedPersonaForJob = getProtectedPersonaForJob;
@@ -315,6 +315,17 @@ const GENERIC_WORKER_OWNED_JOBS = new Set([
     'organization-onboarding',
     'organizational-learning-synthesis',
 ]);
+// Jobs intentionally left without a named persona owner. They resolve to null
+// from getProtectedPersonaForJob (runs ungated; Hub attributes them to the
+// DEFAULT_UNASSIGNED_PERSONA_KEY/MANdy — same behavior as today's adhoc runs).
+// validate-job-ownership exempts these from the "every job must have an owner"
+// assertion so the validator still catches accidentally unowned jobs.
+//
+// Issue #1610: adhoc-prompt is a manager-directed fallback job, not tied to any
+// specialist hire, matching the existing no-employee attribution of adhoc runs.
+exports.UNOWNED_EXEMPT_JOBS = new Set([
+    'adhoc-prompt',
+]);
 function getPersonaCapabilityBundle(personaKey) {
     return exports.PERSONA_CAPABILITY_BUNDLES[personaKey];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-hub",
-  "version": "2.0.310",
+  "version": "2.0.312",
   "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.310",
+    "fraim": "2.0.312",
     "mongodb": "^7.0.0",
     "node-cron": "4.2.1",
     "node-edge-tts": "^1.2.10",

package/public/ai-hub/index.html

@@ -1145,7 +1145,7 @@
           <p class="dep-trig-note">Runs when an external system POSTs to the inbound URL, generated after you add the assignment.</p>
         </div>
         <div class="hm-field">
-          <label for="dep-instructions">Instructions <span class="dep-optional">(optional)</span></label>
+          <label for="dep-instructions">Instructions <span class="dep-optional" id="dep-inst-optional-label">(optional)</span></label>
           <textarea id="dep-instructions" rows="2" placeholder="Optional message sent to the agent at the start of each run"></textarea>
         </div>
         <div class="dep-modal-actions">