@addai/node 0.30.16-msp.1 → 0.30.16-msp.10

package/dist/session-runner.js

@@ -43,6 +43,8 @@ exports.notifyFlowsIfFlowRequest = notifyFlowsIfFlowRequest;
 exports.notifyWidgetstudioIfWidgetRequest = notifyWidgetstudioIfWidgetRequest;
 exports.notifySelfImproveIfEnabled = notifySelfImproveIfEnabled;
 exports.resumeSessionIsVoid = resumeSessionIsVoid;
+exports.earlyStartWanted = earlyStartWanted;
+exports.prepareFastSetup = prepareFastSetup;
 exports.runRequest = runRequest;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -77,8 +79,10 @@ const projects_2 = require("./projects");
 const run_retry_1 = require("./run-retry");
 const hang_watchdog_1 = require("./hang-watchdog");
 const install_1 = require("./install");
+const mcp_direct_1 = require("./mcp-direct");
 const memory_capture_1 = require("./memory-capture");
 const memory_pack_1 = require("./memory-pack");
+const memory_recall_1 = require("./memory-recall");
 const context_files_1 = require("./context-files");
 const guardrails_1 = require("./guardrails");
 const time_context_1 = require("./time-context");
@@ -1577,22 +1581,23 @@ async function runClaudeTui(req, cwd, installed) {
         });
     });
 }
-// ── Model Selector Protocol ────────────────────────────────────────────────
-/** Ask the server whether MSP is on for this turn and, if it is, run the
- *  selector. Never rejects: anything that goes wrong resolves null (the old
+/** Ask the server whether MSP is on for this turn. Neither this nor
+ *  startModelSelection rejects: anything that goes wrong resolves null (the old
  *  path) or a fallback decision (the old model, nothing said). */
-async function startModelSelection(req) {
-    let setting;
+async function fetchModelSelectorSetting(req) {
     try {
-        setting = await (0, supabase_client_1.rpc)('runtime_model_selector_for_request', { p_token: token(), p_request_id: req.id });
+        const setting = await (0, supabase_client_1.rpc)('runtime_model_selector_for_request', { p_token: token(), p_request_id: req.id });
+        return setting && typeof setting === 'object' ? setting : null;
     }
     catch {
         return null; // not deployed, or not ours: the old path
     }
-    if (!setting || typeof setting !== 'object')
-        return null;
+}
+/** Run the selector. Its line goes out the moment it answers, not when the turn
+ *  spawns: it's the first thing the person sees, and setup has seconds to run. */
+async function startModelSelection(req, setting) {
     try {
-        return await (0, model_selector_1.decide)({
+        const decision = await (0, model_selector_1.decide)({
             config: setting.config,
             last: setting.last ?? null,
             prompt: req.prompt ?? '',
@@ -1600,16 +1605,36 @@ async function startModelSelection(req) {
             entityName: setting.entity_name || 'the assistant',
             entityModel: req.model,
             entityEffort: req.effort,
+            agent: req.agent === 'codex' ? 'codex' : 'claude',
+            runJev: (0, model_selector_1.askJev)(token(), req.id),
         });
+        if (decision)
+            postModelLine(req, decision);
+        return decision;
     }
     catch (err) {
         console.error(`[msp] selection failed [reqId=${req.id}]: ${err.message}`);
         return null;
     }
 }
-/** Record the decision (the next turn reads it back to stay steady), put the
+/** A ChatGPT login refuses a model codex doesn't list, which would fail the
+ *  turn. The node's list can differ from the node the tiers were chosen on. */
+function modelMissingOnNode(req, d) {
+    return req.agent === 'codex' && !!d.model && d.model !== req.model && !(0, codex_models_1.codexModelListed)(d.model);
+}
+function postModelLine(req, d) {
+    if (!d.line || modelMissingOnNode(req, d))
+        return;
+    void (0, supabase_client_1.rpc)('runtime_model_selector_announce', {
+        p_token: token(),
+        p_request_id: req.id,
+        p_line: d.line,
+        p_decision: { tier: d.tier, model: d.model, effort: d.effort },
+    }).catch(err => console.error(`[msp] announce failed [reqId=${req.id}]: ${err.message}`));
+}
+/** Record the decision (the next turn reads it back to stay steady) and put the
  *  model and effort that will really run on the request row so usage counts
- *  them, and post the line. All best-effort: the turn has already been decided. */
+ *  them. All best-effort: the turn has already been decided. */
 function publishModelSelection(req, d, changed) {
     void emit(req.id, 'msp_decision', d);
     if (changed && req.model && req.effort) {
@@ -1620,22 +1645,95 @@ function publishModelSelection(req, d, changed) {
             p_effort: req.effort,
         }).catch(err => console.error(`[msp] record failed [reqId=${req.id}]: ${err.message}`));
     }
-    if (!d.line)
-        return;
-    void (0, supabase_client_1.rpc)('runtime_model_selector_announce', {
-        p_token: token(),
-        p_request_id: req.id,
-        p_line: d.line,
-        p_decision: { tier: d.tier, model: d.model, effort: d.effort },
-    }).catch(err => console.error(`[msp] announce failed [reqId=${req.id}]: ${err.message}`));
+}
+/** This turn's model and effort, when MSP is on. Written onto req so a guardrail
+ *  retry turn stays on the same model. Call it just before the spawn. */
+function applyModelSelection(req) {
+    return req.mspApplied ??= selectModelOnce(req);
+}
+async function selectModelOnce(req) {
+    const msp = req.mspDecision ? await req.mspDecision : null;
+    if (!msp)
+        return null;
+    if (modelMissingOnNode(req, msp)) {
+        console.log(`[msp] ${msp.model} is not on this node's codex; running the entity's own model [reqId=${req.id}]`);
+        msp.fallback_reason = msp.selector_error = `model_not_on_node: ${msp.model}`;
+        msp.fell_back = true;
+        msp.line = null;
+        msp.model = req.model;
+        msp.effort = req.effort;
+    }
+    const changed = (!!msp.model && msp.model !== req.model) || (!!msp.effort && msp.effort !== req.effort);
+    if (msp.model)
+        req.model = msp.model;
+    if (msp.effort)
+        req.effort = msp.effort;
+    publishModelSelection(req, msp, changed);
+    return msp;
+}
+/** The selector's mcp_timing test setting: each app's connection time for this
+ *  turn, from the CLI's debug log. The log itself never leaves the node and goes
+ *  as soon as the turn ends, as it can hold anything the CLI saw. */
+function reportMcpTimings(req, file) {
+    try {
+        void emit(req.id, 'mcp_timing', (0, claude_print_1.parseMcpTimings)(fs.readFileSync(file, 'utf8')));
+    }
+    catch { /* no log, nothing to report */ }
+    try {
+        fs.rmSync(file, { force: true });
+    }
+    catch { /* best-effort */ }
 }
 // ── claude --print ─────────────────────────────────────────────────────────
+function mcpDebugFileFor(req, msp) {
+    return msp?.mcp_timing ? path.join(os.tmpdir(), `ainode-mcp-${req.id}.log`) : null;
+}
+function claudePrintInputFor(req, cwd, installed, msp) {
+    const debugFile = mcpDebugFileFor(req, msp);
+    return {
+        workingDirectory: cwd,
+        prompt: req.prompt ?? '',
+        permissionMode: req.agent === 'claude-bypass' ? 'bypassPermissions' : (req.permission_mode ?? undefined),
+        effortLevel: req.effort ?? undefined,
+        model: (0, model_filter_1.modelForAgent)('claude', req.model),
+        mcpConfigPath: installed.mcpConfigPath ?? undefined,
+        resumeSessionId: req.resume_session_id ?? undefined,
+        appendSystemPrompt: msp ? (0, time_context_1.appendChatTimeContext)(req.system_prompt) : (0, time_context_1.appendTimeContext)(req.system_prompt),
+        allowedTools: req.allowed_tools ?? undefined,
+        ...(debugFile ? { debugFile } : {}),
+    };
+}
+/** The selector's early_start setting, on a turn it can work for. A new session
+ *  carries its memories in the system prompt, so that can't start before they land. */
+function earlyStartWanted(req, config) {
+    if (process.env.ADDAI_EARLY_START === '0')
+        return false;
+    if (config?.early_start !== true)
+        return false;
+    return req.agent === 'claude' && req.mode === 'print' && !!req.prompt && !!req.resume_session_id
+        && req.entitybox_file_request !== true;
+}
+/**
+ * Start the CLI while the memory lookup is still running. Its start-up doesn't
+ * need the message, so the two can overlap instead of one waiting for the other.
+ * It's still one process for one turn, gone when the turn ends, so nothing stays
+ * running on the node. If this fails, runClaudePrint spawns the normal way.
+ */
+async function startClaudeEarly(req, cwd, installed) {
+    try {
+        const msp = await applyModelSelection(req);
+        const handle = (0, claude_print_1.spawnClaudePrint)({ ...claudePrintInputFor(req, cwd, installed, msp), prompt: '', deferPrompt: true });
+        req.earlyStart = { handle, at: Date.now() };
+    }
+    catch (err) {
+        console.error(`[setup] early start failed [reqId=${req.id}]: ${err.message}`);
+    }
+}
 async function runClaudePrint(req, cwd, installed) {
     if (!req.prompt) {
         await setStatus(req.id, { status: 'failed', errorCode: 'no_prompt', errorMessage: 'print mode requires a prompt' });
         return;
     }
-    const permissionMode = req.agent === 'claude-bypass' ? 'bypassPermissions' : (req.permission_mode ?? undefined);
     // Floor for "which subagent transcripts belong to this attempt" — see
     // subagent-usage.ts. Taken before the spawn so nothing this run writes
     // can fall outside the window.
@@ -1660,31 +1758,25 @@ async function runClaudePrint(req, cwd, installed) {
             abort.abort();
         }
     }
-    // Model Selector Protocol: this turn's model and effort, when it is on.
-    // Written onto req so a guardrail retry turn stays on the same model.
-    const msp = req.mspDecision ? await req.mspDecision : null;
-    if (msp) {
-        const changed = (!!msp.model && msp.model !== req.model) || (!!msp.effort && msp.effort !== req.effort);
-        if (msp.model)
-            req.model = msp.model;
-        if (msp.effort)
-            req.effort = msp.effort;
-        publishModelSelection(req, msp, changed);
-    }
+    const msp = await applyModelSelection(req);
+    const mcpDebugFile = mcpDebugFileFor(req, msp);
+    // A CLI that started early and has already gone (a session it can't resume, a
+    // bad flag) is passed over, so the normal spawn gives this turn its usual chance.
+    const early = req.earlyStart && !req.earlyStart.handle.hasExited() ? req.earlyStart : null;
+    req.earlyStart = undefined;
     let handle;
     try {
-        handle = (0, claude_print_1.spawnClaudePrint)({
-            workingDirectory: cwd,
-            prompt: req.prompt,
-            ...(inputBlocks ? { inputBlocks } : {}),
-            permissionMode,
-            effortLevel: req.effort ?? undefined,
-            model: (0, model_filter_1.modelForAgent)('claude', req.model),
-            mcpConfigPath: installed.mcpConfigPath ?? undefined,
-            resumeSessionId: req.resume_session_id ?? undefined,
-            appendSystemPrompt: (0, time_context_1.appendTimeContext)(req.system_prompt),
-            allowedTools: req.allowed_tools ?? undefined,
-        });
+        if (early) {
+            handle = early.handle;
+            handle.sendPrompt?.(req.prompt);
+            void emit(req.id, 'early_start', { lead_ms: Date.now() - early.at });
+        }
+        else {
+            handle = (0, claude_print_1.spawnClaudePrint)({
+                ...claudePrintInputFor(req, cwd, installed, msp),
+                ...(inputBlocks ? { inputBlocks } : {}),
+            });
+        }
     }
     catch (err) {
         await failRequest(req, 'spawn_failed', err.message);
@@ -1745,12 +1837,16 @@ async function runClaudePrint(req, cwd, installed) {
         nodeTimeout.clear();
         watcher.stop();
         hang.stop();
+        if (mcpDebugFile)
+            reportMcpTimings(req, mcpDebugFile);
         await failRequest(req, 'spawn_failed', err.message);
         return;
     }
     nodeTimeout.clear();
     watcher.stop();
     hang.stop();
+    if (mcpDebugFile)
+        reportMcpTimings(req, mcpDebugFile);
     // An MSP run that worked and then went quiet for max_run.silence_minutes
     // ends with what it has, and says so, instead of being retried from the
     // top. One that never produced anything still takes the old route (retry,
@@ -1810,6 +1906,7 @@ async function runCodex(req, cwd, installed) {
         void emit(req.id, 'session_dropped_missing_rollout', { sessionId: req.resume_session_id });
         req.resume_session_id = null;
     }
+    const msp = await applyModelSelection(req);
     let handle;
     try {
         const codexModel = (0, model_filter_1.modelForAgent)('codex', req.model);
@@ -1848,11 +1945,15 @@ async function runCodex(req, cwd, installed) {
     // call looks identical to a hang. Give it grok's leash: standard window
     // before any output (a wedged spawn/resume trips fast), 3x after activity
     // has been seen (silent tool work is expected, not a hang). Raw stdout/
-    // stderr bytes count as liveness via onActivity.
+    // stderr bytes count as liveness via onActivity. An MSP run can lengthen
+    // that leash with max_run.silence_minutes but not shorten it, because silence
+    // here can be a tool working. It is stopped rather than retried (below).
     const sawActivity = { current: false };
-    const hang = armHangWatchdog(req, lastError, () => handle.kill(), {
+    const silenced = { current: false };
+    const quietMs = () => Math.max(config_1.HANG_WATCHDOG_IDLE_MS * 3, (msp?.max_run.silence_minutes ?? 0) * 60_000);
+    const hang = armHangWatchdog(req, lastError, () => { silenced.current = true; handle.kill(); }, {
         sawActivity: () => sawActivity.current,
-        idleMsFn: () => (sawActivity.current ? config_1.HANG_WATCHDOG_IDLE_MS * 3 : config_1.HANG_WATCHDOG_IDLE_MS),
+        idleMsFn: () => (sawActivity.current ? quietMs() : config_1.HANG_WATCHDOG_IDLE_MS),
     });
     handle.onActivity(() => { sawActivity.current = true; hang.touch(); });
     handle.onEvent(ev => {
@@ -1868,7 +1969,7 @@ async function runCodex(req, cwd, installed) {
     });
     // Node-configured execution timeout (null/0 = unlimited). On timeout we
     // kill the agent; the completion below treats it as complete-with-partial.
-    const nodeTimeout = armNodeTimeout(req, () => handle.kill());
+    const nodeTimeout = armNodeTimeout(req, () => handle.kill(), msp ? msp.max_run.backstop_hours * 3600 : undefined);
     let exitCode;
     try {
         exitCode = await handle.done;
@@ -1888,6 +1989,14 @@ async function runCodex(req, cwd, installed) {
     nodeTimeout.clear();
     watcher.stop();
     hang.stop();
+    // An MSP run that worked and then went quiet ends with what it has, and says
+    // so, instead of being retried from the top. As in runClaudePrint.
+    const mspSilenced = !!msp && silenced.current && sawActivity.current;
+    if (mspSilenced) {
+        await emit(req.id, 'assistant_text', {
+            delta: `\n\n_I went quiet for ${Math.round(quietMs() / 60_000)} minutes, so I was stopped here._`,
+        });
+    }
     if (handle.threadId)
         await setStatus(req.id, { spawnedSessionId: handle.threadId });
     void emit(req.id, 'session_end', { reason: 'codex_exit', exitCode });
@@ -1895,7 +2004,7 @@ async function runCodex(req, cwd, installed) {
     if (currentStatus !== 'canceled') {
         // A timed-out run completes-with-partial: the node asked for a cap, not
         // a failure, so surface whatever the agent produced.
-        const cleanExit = exitCode === 0 || nodeTimeout.timedOut();
+        const cleanExit = exitCode === 0 || nodeTimeout.timedOut() || mspSilenced;
         await finalizeTerminal(req, {
             clean: cleanExit,
             errorCode: cleanExit ? undefined : (lastError.current?.code ?? `exit_${exitCode}`),
@@ -2185,7 +2294,7 @@ async function fetchDriveList(apiKey, workspaceId, folderId, signal) {
         return null;
     return (await res.json());
 }
-async function buildDriveManifest(installed) {
+async function buildDriveManifest(installed, concurrent = false) {
     const drive = installed.mcps.find((m) => m.slug === 'addai-drive');
     const env = drive?.env ?? null;
     const apiKey = env?.ADDAI_DRIVE_API_KEY;
@@ -2205,9 +2314,12 @@ async function buildDriveManifest(installed) {
             lines.push(fmt(f));
         // One level of subfolders so the entity sees its structure, capped to keep
         // the injection small and the listing fast.
-        for (const sub of (root.folders ?? []).slice(0, 12)) {
+        const subs = (root.folders ?? []).slice(0, 12);
+        const listSub = (id) => fetchDriveList(apiKey, workspaceId, id, controller.signal).catch(() => null);
+        const listed = concurrent ? await Promise.all(subs.map(sub => listSub(sub.id))) : null;
+        for (const [i, sub] of subs.entries()) {
             lines.push(`  - ${sub.name}/`);
-            const child = await fetchDriveList(apiKey, workspaceId, sub.id, controller.signal).catch(() => null);
+            const child = listed ? listed[i] : await listSub(sub.id);
             for (const f of (child?.files ?? []).slice(0, 30))
                 lines.push(`    - ${sub.name}/${f.name}`);
         }
@@ -2274,8 +2386,156 @@ async function buildMemoryManifest(installed) {
         clearTimeout(timer);
     }
 }
+// ── Turn setup ─────────────────────────────────────────────────────────────
+function appendToSystemPrompt(req, block) {
+    req.system_prompt =
+        req.system_prompt && req.system_prompt.trim().length > 0
+            ? `${req.system_prompt}\n\n${block}`
+            : block;
+}
+/** With no inline listing it points at ./context/drive.md instead. */
+function driveManifestBlock(count, inlineListing) {
+    const intro = "You have a private +Ai Drive — file storage for working files and artifacts (documents, exports, data you produce) that survives across runs. This is for FILES, not memory: to remember facts, preferences, decisions, or what you learned, use your DocFlows memory (see below), never the Drive and never a local file.";
+    const tools = 'Use your +Ai Drive tools (list_files, read_file, write_file, make_folder, …) to read, add, and organise files.';
+    return inlineListing === null
+        ? ['## Your +Ai Drive', intro, `Your current file list (${count} entries) is in ./context/drive.md — read it when you need a file.`, tools].join('\n')
+        : ['## Your +Ai Drive', `${intro} Files currently in your Drive:`, inlineListing, tools].join('\n');
+}
+function writeDriveFile(cwd, listing) {
+    return (0, context_files_1.writeContextFiles)(cwd, { 'context/drive.md': `# Your +Ai Drive\n\nFiles currently in your Drive:\n${listing}\n` }).written.length > 0;
+}
+/** The size of the listing an earlier turn left in this folder, if there is one. */
+function driveCountOnDisk(cwd) {
+    try {
+        const text = fs.readFileSync(path.join(cwd, 'context', 'drive.md'), 'utf8');
+        return text.split('\n').filter(line => /^\s+- /.test(line)).length;
+    }
+    catch {
+        return null;
+    }
+}
+function livingPresenceBlock() {
+    return [
+        'LIVING PRESENCE — narrate your work so people can see what you are doing in real time.',
+        'Whenever you are working on a specific table record (a card / task / row), call the `report_status` tool at your real milestones: when you claim/start it (status "working", a low progress, a short note), at each checkpoint (bump progress + update the note), if you get stuck and need a human (status "blocked"), and when you finish (status "done"). ALWAYS pass the record_id you are working on; if you are working on several records at once, report each separately with its own record_id so they never overwrite each other. This is lightweight — a handful of milestone updates per task; progress is a rough milestone percent (0-100), not a precise measurement.',
+        'THE `note` MUST BE ULTRA-SHORT — 1 to 3 plain, friendly words a teammate could read at a glance, e.g. "Reviewing", "Playing widget", "Writing summary", "Checking design", "Almost done". It renders in a tiny bubble, so NEVER write a sentence and NEVER use technical or internal jargon (not "waiting for publish propagation" — just "Publishing"). Think status label, not explanation.',
+    ].join('\n');
+}
+/** How long a turn the selector calls quick waits on the memory pack. A quick
+ *  question can still lean on memory, so it gets a moment, and no more: the pack
+ *  usually lands around when the selector does, but can take seconds. */
+const QUICK_RECALL_WAIT_MS = 500;
+/** Selector turns start our own apps from the copy npx already has. */
+function launchAppsDirectly(cwd, installed) {
+    if (process.env.ADDAI_MCP_DIRECT === '0' || !installed.mcps?.length)
+        return;
+    const mcps = (0, mcp_direct_1.directMcps)(installed.mcps);
+    if (mcps === installed.mcps)
+        return;
+    installed.mcps = mcps;
+    installed.mcpConfigPath = (0, install_1.writeMcpConfig)(cwd, mcps) ?? installed.mcpConfigPath;
+}
+/**
+ * Setup for a turn with the model selector on. It does what the block in
+ * runRequest does, without the wait: the Drive listing and memory pack run side
+ * by side, and neither holds the spawn back when its answer can't change the
+ * turn. Claude reuses a resumed session's first system prompt, so its memory
+ * pack and pointer there are only read again after a compaction.
+ */
+async function prepareFastSetup(req, cwd, installed, pack, startedAt, onSystemPromptReady) {
+    const resumedClaude = req.agent !== 'codex' && !!req.resume_session_id;
+    const timing = { pack_ms: null };
+    try {
+        launchAppsDirectly(cwd, installed);
+    }
+    catch (err) {
+        console.error(`[setup] direct app launch failed [reqId=${req.id}]: ${err.message}`);
+    }
+    void pack.then(() => { timing.pack_ms = Date.now() - startedAt; });
+    // A listing from an earlier turn is good enough to point at. This turn's
+    // replaces it in the background, well before the agent's first look.
+    const hasDrive = installed.mcps?.some(m => m.slug === 'addai-drive') ?? false;
+    const listing = hasDrive ? buildDriveManifest(installed, true).catch(() => null) : Promise.resolve(null);
+    const knownCount = hasDrive ? driveCountOnDisk(cwd) : null;
+    if (knownCount !== null) {
+        void listing.then(drive => { if (drive)
+            writeDriveFile(cwd, drive.body); }).catch(() => { });
+    }
+    let fallbackSent = false;
+    const onFallback = () => {
+        fallbackSent = true;
+        void emit(req.id, 'memory_fallback', { at: 'pack' });
+    };
+    // The dispatcher's keyword block is already in place for a compaction to pick
+    // up, so a resumed turn has no reason to wait for a better one here.
+    if (!(resumedClaude && (req.system_prompt ?? '').includes('\n\n## Memory\n'))) {
+        try {
+            req.system_prompt = await (0, memory_pack_1.applyMemoryPack)(req, req.system_prompt ?? null, config_1.SUPABASE_URL, config_1.SUPABASE_ANON_KEY, {
+                fetchPack: () => pack,
+                buildLegacyManifest: () => buildMemoryManifest(installed),
+                onFallback,
+                onFlagged: (flagged) => { req.memoryV2Flagged = flagged; },
+            });
+        }
+        catch (err) {
+            console.error('[memory-pack] wrapper failed:', err?.message);
+        }
+    }
+    // Memory goes in first: replaceMemoryBlock cuts from its heading to the end, so
+    // anything appended before it would be lost.
+    try {
+        if (knownCount !== null) {
+            appendToSystemPrompt(req, driveManifestBlock(knownCount, null));
+        }
+        else {
+            const drive = await listing;
+            if (drive)
+                appendToSystemPrompt(req, driveManifestBlock(drive.count, writeDriveFile(cwd, drive.body) ? null : drive.body));
+        }
+    }
+    catch {
+        /* drive manifest is best-effort — never block a run */
+    }
+    if (installed.mcps?.some((m) => m.slug === 'entity-self-mcp'))
+        appendToSystemPrompt(req, livingPresenceBlock());
+    let recall = 'system_prompt';
+    if (resumedClaude) {
+        const decision = await req.mspDecision;
+        // Only the message changes from here on, and that's what the pack is for.
+        await onSystemPromptReady?.();
+        const found = await (decision?.picked === 'quick'
+            ? Promise.race([pack, new Promise(done => setTimeout(() => done(null), QUICK_RECALL_WAIT_MS))])
+            : pack);
+        if (!found) {
+            recall = 'missed';
+        }
+        else if (found.degraded) {
+            recall = 'unavailable';
+            if (!fallbackSent)
+                onFallback();
+        }
+        else {
+            const withRecall = (0, memory_recall_1.withFreshRecall)(req.prompt ?? '', found.block, cwd);
+            recall = withRecall === (req.prompt ?? '') ? 'nothing_new' : 'added';
+            if (req.prompt)
+                req.prompt = withRecall;
+        }
+    }
+    else if (req.agent !== 'codex') {
+        const found = await pack;
+        (0, memory_recall_1.rememberRecall)(cwd, found.degraded ? '' : found.block);
+    }
+    void emit(req.id, 'setup_timing', {
+        setup_ms: Date.now() - startedAt,
+        pack_ms: timing.pack_ms,
+        drive_waited: hasDrive && knownCount === null,
+        resumed: !!req.resume_session_id,
+        recall,
+    });
+}
 // ── Dispatcher ─────────────────────────────────────────────────────────────
 async function runRequest(req, entitybox) {
+    const startedAt = Date.now();
     if (await (0, entitybox_queue_request_1.runEntityboxQueueRequest)(req, { rpc: supabase_client_1.rpc, pairing: store_1.readPairing }, entitybox))
         return;
     if (req.entitybox_file_request === true) {
@@ -2304,12 +2564,28 @@ async function runRequest(req, entitybox) {
         return;
     }
     // Model Selector Protocol: start now, so the selector runs alongside the
-    // cwd/install/memory setup below instead of after it. Claude print chat
-    // turns only; whether it is on for this entity is the server's answer.
+    // cwd/install/memory setup below instead of after it. Claude print and Codex
+    // chat turns only; whether it is on for this entity is the server's answer.
     // Nothing in here may stop the run, so even the gate is guarded.
+    //
+    // The memory pack starts now too, on the person's own words rather than the
+    // whole briefing, when the selector is on. ADDAI_FAST_SETUP=0 turns that part
+    // back to the old order.
+    let mspSetting = null;
+    let earlyPack = null;
     try {
-        if ((0, model_selector_1.mspApplies)(req))
-            req.mspDecision = startModelSelection(req);
+        if ((0, model_selector_1.mspApplies)(req)) {
+            const setting = fetchModelSelectorSetting(req);
+            mspSetting = setting;
+            req.mspDecision = setting.then(s => (s ? startModelSelection(req, s) : null));
+            const entityId = (0, memory_pack_1.resolvePackEntityId)(req);
+            if (entityId && process.env.ADDAI_FAST_SETUP !== '0') {
+                const message = (0, model_selector_1.messageFromPrompt)(req.prompt ?? '');
+                earlyPack = setting.then(s => (s
+                    ? (0, memory_pack_1.fetchMemoryPackVia)(s.config?.memory_pack, config_1.SUPABASE_URL, config_1.SUPABASE_ANON_KEY, { entityId, prompt: message, memberProfileId: req.member_profile_id ?? null })
+                    : { block: '', degraded: false, flagged: false }));
+            }
+        }
     }
     catch (err) {
         console.error(`[msp] not started [reqId=${req.id}]: ${err.message}`);
@@ -2378,46 +2654,40 @@ async function runRequest(req, entitybox) {
             skills_installed: installed.skillSlugs,
         });
     }
+    const fastSetting = earlyPack ? await mspSetting : null;
+    const fast = !!fastSetting;
+    if (fast) {
+        try {
+            await prepareFastSetup(req, cwd, installed, earlyPack, startedAt, earlyStartWanted(req, fastSetting?.config) ? () => startClaudeEarly(req, cwd, installed) : undefined);
+        }
+        catch (err) {
+            console.error(`[setup] fast setup failed [reqId=${req.id}]: ${err.message}`);
+        }
+    }
     // Fold the entity's +Ai Drive contents into its system prompt (best-effort) so
     // it begins the run already aware of the files it has. All spawn paths read
     // req.system_prompt, so mutating it here reaches every agent variant.
-    try {
-        const drive = await buildDriveManifest(installed);
-        if (drive) {
-            const intro = "You have a private +Ai Drive — file storage for working files and artifacts (documents, exports, data you produce) that survives across runs. This is for FILES, not memory: to remember facts, preferences, decisions, or what you learned, use your DocFlows memory (see below), never the Drive and never a local file.";
-            const tools = 'Use your +Ai Drive tools (list_files, read_file, write_file, make_folder, …) to read, add, and organise files.';
-            // The listing can run to hundreds of lines and changes whenever a file
-            // does, so it lives in a file the entity reads when it needs one, and the
-            // system prompt keeps a two-line pointer that stays stable turn to turn.
-            // If the file cannot be written, the full listing goes inline as before.
-            const wrote = (0, context_files_1.writeContextFiles)(cwd, { 'context/drive.md': `# Your +Ai Drive\n\nFiles currently in your Drive:\n${drive.body}\n` }).written.length > 0;
-            const driveManifest = wrote
-                ? ['## Your +Ai Drive', intro, `Your current file list (${drive.count} entries) is in ./context/drive.md — read it when you need a file.`, tools].join('\n')
-                : ['## Your +Ai Drive', `${intro} Files currently in your Drive:`, drive.body, tools].join('\n');
-            req.system_prompt =
-                req.system_prompt && req.system_prompt.trim().length > 0
-                    ? `${req.system_prompt}\n\n${driveManifest}`
-                    : driveManifest;
+    if (!fast)
+        try {
+            const drive = await buildDriveManifest(installed);
+            if (drive) {
+                // The listing can run to hundreds of lines and changes whenever a file
+                // does, so it lives in a file the entity reads when it needs one, and the
+                // system prompt keeps a two-line pointer that stays stable turn to turn.
+                // If the file cannot be written, the full listing goes inline as before.
+                appendToSystemPrompt(req, driveManifestBlock(drive.count, writeDriveFile(cwd, drive.body) ? null : drive.body));
+            }
+        }
+        catch {
+            /* drive manifest is best-effort — never block a run */
         }
-    }
-    catch {
-        /* drive manifest is best-effort — never block a run */
-    }
     // Living Presence: entities that carry the entity-self MCP narrate their work on
     // table records via its `report_status` tool. Injected HERE — the one place every
     // spawn path reads (req.system_prompt) — so it reaches EVERY session, board and
     // channel from a single source, never per-board. Gated on the tool actually being
     // installed, so it can't confuse entities that don't have it.
-    if (installed.mcps?.some((m) => m.slug === 'entity-self-mcp')) {
-        const livingPresence = [
-            'LIVING PRESENCE — narrate your work so people can see what you are doing in real time.',
-            'Whenever you are working on a specific table record (a card / task / row), call the `report_status` tool at your real milestones: when you claim/start it (status "working", a low progress, a short note), at each checkpoint (bump progress + update the note), if you get stuck and need a human (status "blocked"), and when you finish (status "done"). ALWAYS pass the record_id you are working on; if you are working on several records at once, report each separately with its own record_id so they never overwrite each other. This is lightweight — a handful of milestone updates per task; progress is a rough milestone percent (0-100), not a precise measurement.',
-            'THE `note` MUST BE ULTRA-SHORT — 1 to 3 plain, friendly words a teammate could read at a glance, e.g. "Reviewing", "Playing widget", "Writing summary", "Checking design", "Almost done". It renders in a tiny bubble, so NEVER write a sentence and NEVER use technical or internal jargon (not "waiting for publish propagation" — just "Publishing"). Think status label, not explanation.',
-        ].join('\n');
-        req.system_prompt =
-            req.system_prompt && req.system_prompt.trim().length > 0
-                ? `${req.system_prompt}\n\n${livingPresence}`
-                : livingPresence;
+    if (!fast && installed.mcps?.some((m) => m.slug === 'entity-self-mcp')) {
+        appendToSystemPrompt(req, livingPresenceBlock());
     }
     // Same for the entity's long-term memory: try the +Ai Memory semantic pack
     // (T6's entity-memory-pack edge function) first — it replaces the flat
@@ -2437,20 +2707,21 @@ async function runRequest(req, entitybox) {
     // runtime_pick_next_request returns the bare entity_runtime_requests
     // rowtype (no jsonb aliasing), so that is the real field name; req.entity_id
     // is kept only as a fallback (see resolvePackEntityId in memory-pack.ts).
-    try {
-        req.system_prompt = await (0, memory_pack_1.applyMemoryPack)(req, req.system_prompt ?? null, config_1.SUPABASE_URL, config_1.SUPABASE_ANON_KEY, {
-            buildLegacyManifest: () => buildMemoryManifest(installed),
-            onFallback: () => void emit(req.id, 'memory_fallback', { at: 'pack' }),
-            // Phase 4 T7: PreCompact hook gate (see precompact-hook.ts). Reuses
-            // this same pack fetch's `skipped:"flag"` signal instead of asking
-            // the flag question a second time.
-            onFlagged: (flagged) => { req.memoryV2Flagged = flagged; },
-        });
-    }
-    catch (err) {
-        /* memory manifest is best-effort — never block a run */
-        console.error('[memory-pack] wrapper failed:', err?.message);
-    }
+    if (!fast)
+        try {
+            req.system_prompt = await (0, memory_pack_1.applyMemoryPack)(req, req.system_prompt ?? null, config_1.SUPABASE_URL, config_1.SUPABASE_ANON_KEY, {
+                buildLegacyManifest: () => buildMemoryManifest(installed),
+                onFallback: () => void emit(req.id, 'memory_fallback', { at: 'pack' }),
+                // Phase 4 T7: PreCompact hook gate (see precompact-hook.ts). Reuses
+                // this same pack fetch's `skipped:"flag"` signal instead of asking
+                // the flag question a second time.
+                onFlagged: (flagged) => { req.memoryV2Flagged = flagged; },
+            });
+        }
+        catch (err) {
+            /* memory manifest is best-effort — never block a run */
+            console.error('[memory-pack] wrapper failed:', err?.message);
+        }
     try {
         // Agent value now encodes the mode for claude variants:
         //   'claude'      → claude --print  (one-shot stream)
@@ -2481,6 +2752,8 @@ async function runRequest(req, entitybox) {
         }
     }
     finally {
+        // An early start nothing went on to use. The turn is over, so it must not outlive it.
+        req.earlyStart?.handle.kill();
         // Best-effort cleanup of installed files. If the request crashed
         // mid-flight we may leak files; next install run for the same cwd
         // will overwrite them.