@addai/node 0.30.16-msp.7 → 0.30.16-msp.9

package/dist/claude-print.d.ts

@@ -16,6 +16,9 @@ export interface ClaudePrintInput {
     allowedTools?: string[];
     /** Write the CLI's debug log here, to time each app's connection. */
     debugFile?: string;
+    /** Start now and take the prompt later through sendPrompt, so the CLI's
+     *  start-up overlaps whatever the prompt is still waiting on. */
+    deferPrompt?: boolean;
 }
 /**
  * findClaudeBinary for the spawn path. The lookup runs `where` or a login shell
@@ -51,6 +54,8 @@ export type ClaudePrintInputBlock = {
     };
 };
 /** Stream JSON reaches stdin only; files never become command-line arguments. */
+/** The one stdin line a run started with deferPrompt gets. */
+export declare function claudePrintPromptMessage(prompt: string): string;
 export declare function claudePrintInputMessage(prompt: string, blocks: readonly ClaudePrintInputBlock[]): string;
 /**
  * The text to emit for one flushed block, given what came before.
@@ -73,6 +78,11 @@ export interface ClaudePrintHandle {
     onEvent(cb: (e: RuntimeEvent) => void): void;
     /** Resolves with exit code; rejects on spawn error. */
     done: Promise<number>;
+    /** deferPrompt only. Closes stdin behind the message, so from here the run
+     *  ends the way any other run does: one turn, then the process exits. */
+    sendPrompt?(prompt: string): void;
+    /** True once the process has gone, so a deferred start can be passed over. */
+    hasExited(): boolean;
 }
 /**
  * Parse one stream-json line into 0+ RuntimeEvents.

package/dist/claude-print.js

@@ -40,6 +40,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cachedClaudeBinary = cachedClaudeBinary;
 exports.parseMcpTimings = parseMcpTimings;
+exports.claudePrintPromptMessage = claudePrintPromptMessage;
 exports.claudePrintInputMessage = claudePrintInputMessage;
 exports.blockDelta = blockDelta;
 exports.lineToEvents = lineToEvents;
@@ -104,6 +105,10 @@ function parseMcpTimings(log) {
     };
 }
 /** Stream JSON reaches stdin only; files never become command-line arguments. */
+/** The one stdin line a run started with deferPrompt gets. */
+function claudePrintPromptMessage(prompt) {
+    return JSON.stringify({ type: 'user', session_id: '', parent_tool_use_id: null, message: { role: 'user', content: [{ type: 'text', text: prompt }] } }) + '\n';
+}
 function claudePrintInputMessage(prompt, blocks) {
     if (!Array.isArray(blocks) || blocks.length < 1 || blocks.length > 12 || !blocks.every(b => b && (b.type === 'text' && typeof b.text === 'string' || ['image', 'document'].includes(b.type) && 'source' in b && b.source?.type === 'base64' && typeof b.source.data === 'string' && /^[A-Za-z0-9+/]*={0,2}$/.test(b.source.data)
         && (b.type === 'document' ? b.source.media_type === 'application/pdf' : ['image/png', 'image/jpeg', 'image/webp', 'image/gif'].includes(b.source.media_type)))))
@@ -241,7 +246,7 @@ function spawnClaudePrint(input) {
         args.push('--include-partial-messages');
     if (input.debugFile)
         args.push('--debug-file', input.debugFile);
-    if (input.inputBlocks)
+    if (input.inputBlocks || input.deferPrompt)
         args.push('--input-format', 'stream-json');
     if (input.permissionMode === 'bypassPermissions') {
         args.push('--dangerously-skip-permissions');
@@ -308,15 +313,28 @@ function spawnClaudePrint(input) {
         // Mark handled now — the caller awaits `done` a few ticks later, and an
         // already-rejected promise with no handler would fire unhandledRejection.
         done.catch(() => { });
-        return { pid: undefined, sessionId: null, kill: () => { }, onEvent: () => { }, done };
+        return { pid: undefined, sessionId: null, kill: () => { }, onEvent: () => { }, done, hasExited: () => true };
     }
-    (0, prompt_transport_1.feedStdin)(proc, transport.stdin);
+    // A child that dies before its deferred prompt turns the later write into
+    // EPIPE; its exit reports that, same as feedStdin.
+    if (input.deferPrompt)
+        proc.stdin?.on('error', () => { });
+    else
+        (0, prompt_transport_1.feedStdin)(proc, transport.stdin);
     const listeners = [];
-    const emit = (e) => { for (const l of listeners)
-        try {
-            l(e);
+    // A deferred start can say something before the run has attached to it.
+    const unheard = [];
+    const emit = (e) => {
+        if (input.deferPrompt && listeners.length === 0) {
+            unheard.push(e);
+            return;
         }
-        catch { } };
+        for (const l of listeners)
+            try {
+                l(e);
+            }
+            catch { }
+    };
     let sessionId = null;
     let buffer = '';
     // Text-delta coalescer (partial-stream mode). Token deltas arrive many times
@@ -447,9 +465,11 @@ function spawnClaudePrint(input) {
     proc.stderr?.on('data', (chunk) => {
         stderrBuf += chunk.toString('utf8');
     });
+    let exited = false;
     const done = new Promise((resolve, reject) => {
-        proc.once('error', reject);
+        proc.once('error', (err) => { exited = true; reject(err); });
         proc.once('exit', (code) => {
+            exited = true;
             sysPrompt.cleanup();
             flushThinking();
             flushText();
@@ -460,11 +480,24 @@ function spawnClaudePrint(input) {
             resolve(code ?? -1);
         });
     });
+    // Nothing awaits a deferred start's done until its prompt is ready, and a
+    // rejection nobody has handled yet would take the whole daemon down.
+    if (input.deferPrompt)
+        done.catch(() => { });
     return {
         pid: proc.pid,
         get sessionId() { return sessionId; },
         kill: () => { (0, win_1.killProcessTree)(proc); },
-        onEvent: (cb) => { listeners.push(cb); },
+        onEvent: (cb) => {
+            listeners.push(cb);
+            for (const e of unheard.splice(0))
+                try {
+                    cb(e);
+                }
+                catch { }
+        },
         done,
+        hasExited: () => exited,
+        ...(input.deferPrompt ? { sendPrompt: (prompt) => { proc.stdin?.end(claudePrintPromptMessage(prompt), 'utf8'); } } : {}),
     };
 }

package/dist/mcp-direct.d.ts

@@ -0,0 +1,22 @@
+export interface InstalledCopy {
+    version: string;
+    bin: string;
+}
+interface McpEntry {
+    command: string;
+    args: string[] | null;
+}
+/** The package an `npx -y @addai/x[@latest]` entry runs. Null for any other
+ *  entry, including one pinned to a version, which npx should keep resolving. */
+export declare function npxPackage(entry: McpEntry): string | null;
+/** True when a is a higher release than b. A prerelease counts as its release. */
+export declare function isNewer(a: string, b: string): boolean;
+/** The newest complete copy of a package in npx's cache. */
+export declare function findInstalledCopy(pkg: string, roots?: string[]): InstalledCopy | null;
+/** What the registry last said is latest, or null if it hasn't said yet. Asks
+ *  again in the background once an hour, so it never holds a turn back. */
+export declare function latestVersion(pkg: string): string | null;
+/** The entries with our npx apps switched to their installed copies. The same
+ *  array when there's nothing to switch, and the same object for every other entry. */
+export declare function directMcps<T extends McpEntry>(mcps: T[], find?: (pkg: string) => InstalledCopy | null, latest?: (pkg: string) => string | null): T[];
+export {};

package/dist/mcp-direct.js

@@ -0,0 +1,163 @@
+"use strict";
+// Starting our own apps without asking the npm registry first.
+//
+// An app registered as `npx -y @addai/x@latest` checks the registry before it
+// starts, which makes it the slowest app on a turn: 1.7 s on PopadomTV, against
+// 0.4-0.8 s for each remote app, and the agent waits for all of them. npx has
+// already unpacked the package, so selector turns run that copy directly.
+//
+// `@latest` still means latest. The registry is asked in the background, and when
+// it knows of a newer version than the copy, the app goes through npx for that
+// turn, which updates the copy. Anything unexpected leaves the entry on npx, as it
+// was. ADDAI_MCP_DIRECT=0 turns all of this off.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.npxPackage = npxPackage;
+exports.isNewer = isNewer;
+exports.findInstalledCopy = findInstalledCopy;
+exports.latestVersion = latestVersion;
+exports.directMcps = directMcps;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const OUR_PACKAGE = /^(@addai\/[a-z0-9._-]+)(?:@latest)?$/;
+const LATEST_TTL_MS = 60 * 60 * 1000;
+const LATEST_TIMEOUT_MS = 5000;
+/** The package an `npx -y @addai/x[@latest]` entry runs. Null for any other
+ *  entry, including one pinned to a version, which npx should keep resolving. */
+function npxPackage(entry) {
+    const { command, args } = entry;
+    if (command !== 'npx' || !Array.isArray(args) || args.length !== 2 || args[0] !== '-y')
+        return null;
+    return OUR_PACKAGE.exec(args[1])?.[1] ?? null;
+}
+/** True when a is a higher release than b. A prerelease counts as its release. */
+function isNewer(a, b) {
+    const parts = (v) => v.split('-')[0].split('.').map(n => parseInt(n, 10) || 0);
+    const [x, y] = [parts(a), parts(b)];
+    for (let i = 0; i < 3; i++) {
+        if ((x[i] ?? 0) !== (y[i] ?? 0))
+            return (x[i] ?? 0) > (y[i] ?? 0);
+    }
+    return false;
+}
+function npxRoots() {
+    const roots = [];
+    if (process.env.npm_config_cache)
+        roots.push(path.join(process.env.npm_config_cache, '_npx'));
+    if (process.platform === 'win32' && process.env.LOCALAPPDATA) {
+        roots.push(path.join(process.env.LOCALAPPDATA, 'npm-cache', '_npx'));
+    }
+    roots.push(path.join(os.homedir(), '.npm', '_npx'));
+    return roots;
+}
+function readCopy(modules, pkg) {
+    try {
+        const dir = path.join(modules, ...pkg.split('/'));
+        const manifest = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+        const bins = typeof manifest.bin === 'string'
+            ? { [pkg.split('/')[1]]: manifest.bin }
+            : manifest.bin ?? {};
+        const names = Object.keys(bins);
+        const bin = bins[pkg.split('/')[1]] ?? (names.length === 1 ? bins[names[0]] : undefined);
+        if (typeof bin !== 'string' || typeof manifest.version !== 'string')
+            return null;
+        const entry = path.resolve(dir, bin);
+        if (!fs.existsSync(entry))
+            return null;
+        // A half-finished install can hold the package without what it needs.
+        for (const dep of Object.keys(manifest.dependencies ?? {})) {
+            if (!fs.existsSync(path.join(modules, ...dep.split('/'), 'package.json')))
+                return null;
+        }
+        return { version: manifest.version, bin: entry };
+    }
+    catch {
+        return null;
+    }
+}
+/** The newest complete copy of a package in npx's cache. */
+function findInstalledCopy(pkg, roots = npxRoots()) {
+    let best = null;
+    for (const root of roots) {
+        let dirs = [];
+        try {
+            dirs = fs.readdirSync(root);
+        }
+        catch {
+            continue;
+        }
+        for (const dir of dirs) {
+            const copy = readCopy(path.join(root, dir, 'node_modules'), pkg);
+            if (copy && (!best || isNewer(copy.version, best.version)))
+                best = copy;
+        }
+    }
+    return best;
+}
+const latestKnown = new Map();
+/** What the registry last said is latest, or null if it hasn't said yet. Asks
+ *  again in the background once an hour, so it never holds a turn back. */
+function latestVersion(pkg) {
+    const known = latestKnown.get(pkg);
+    if (known && Date.now() - known.at < LATEST_TTL_MS)
+        return known.version;
+    latestKnown.set(pkg, { version: known?.version ?? null, at: Date.now() });
+    void fetch(`https://registry.npmjs.org/${pkg.replace('/', '%2f')}/latest`, { signal: AbortSignal.timeout(LATEST_TIMEOUT_MS) })
+        .then(r => (r.ok ? r.json() : null))
+        .then(body => {
+        if (typeof body?.version === 'string')
+            latestKnown.set(pkg, { version: body.version, at: Date.now() });
+    })
+        .catch(() => { });
+    return known?.version ?? null;
+}
+/** The entries with our npx apps switched to their installed copies. The same
+ *  array when there's nothing to switch, and the same object for every other entry. */
+function directMcps(mcps, find = findInstalledCopy, latest = latestVersion) {
+    let changed = false;
+    const out = mcps.map(m => {
+        const pkg = npxPackage(m);
+        if (!pkg)
+            return m;
+        const copy = find(pkg);
+        const newest = latest(pkg);
+        if (!copy || (newest && isNewer(newest, copy.version)))
+            return m;
+        changed = true;
+        return { ...m, command: process.execPath, args: [copy.bin] };
+    });
+    return changed ? out : mcps;
+}

package/dist/memory-pack.d.ts

@@ -11,11 +11,17 @@ export declare function fetchMemoryPack(baseUrl: string, serviceToken: string, a
     prompt: string;
     budgetTokens?: number;
     memberProfileId?: string | null;
-}, timeoutMs?: number): Promise<{
+}, timeoutMs?: number, fn?: string): Promise<{
     block: string;
     degraded: boolean;
     flagged: boolean;
 }>;
+export declare function fetchMemoryPackVia(copy: unknown, baseUrl: string, serviceToken: string, args: {
+    entityId: string;
+    prompt: string;
+    budgetTokens?: number;
+    memberProfileId?: string | null;
+}): ReturnType<typeof fetchMemoryPack>;
 export declare function resolvePackEntityId(req: {
     entity_studio_entity_id?: string | null;
     entity_id?: string | null;

package/dist/memory-pack.js

@@ -4,6 +4,7 @@ exports.MEMORY_FALLBACK_MARKER = void 0;
 exports.replaceMemoryBlock = replaceMemoryBlock;
 exports.buildPackBody = buildPackBody;
 exports.fetchMemoryPack = fetchMemoryPack;
+exports.fetchMemoryPackVia = fetchMemoryPackVia;
 exports.resolvePackEntityId = resolvePackEntityId;
 exports.applyMemoryPack = applyMemoryPack;
 // +Ai Memory (Task 7) — semantic memory pack fetcher.
@@ -68,9 +69,9 @@ function buildPackBody(args) {
 async function fetchMemoryPack(baseUrl, serviceToken, args, 
 // edge fn steady-state ~600ms, cold start ~950ms; 3s bounds worst-case
 // spawn latency
-timeoutMs = 3000) {
+timeoutMs = 3000, fn = 'entity-memory-pack') {
     try {
-        const r = await fetch(`${baseUrl}/functions/v1/entity-memory-pack`, {
+        const r = await fetch(`${baseUrl}/functions/v1/${fn}`, {
             method: 'POST',
             headers: {
                 'content-type': 'application/json',
@@ -98,6 +99,17 @@ timeoutMs = 3000) {
         return { block: exports.MEMORY_FALLBACK_MARKER, degraded: true, flagged: false };
     }
 }
+// A selector setting can name a test copy of the pack, for proving a change to
+// recall on one entity. If the copy fails, the real pack still answers.
+const PACK_COPY = /^entity-memory-pack-[a-z0-9-]{1,40}$/;
+async function fetchMemoryPackVia(copy, baseUrl, serviceToken, args) {
+    if (typeof copy === 'string' && PACK_COPY.test(copy)) {
+        const pack = await fetchMemoryPack(baseUrl, serviceToken, args, 3000, copy);
+        if (!pack.degraded)
+            return pack;
+    }
+    return fetchMemoryPack(baseUrl, serviceToken, args);
+}
 // +Ai Memory — runtime "entity_id alias" fix (final phase-3 review finding).
 //
 // runtime_pick_next_request (addai-entity-studio/supabase/migrations/

package/dist/memory-recall.js

@@ -53,29 +53,67 @@ const path = __importStar(require("path"));
 /** Beside the session's other per-chat files. Holds hashes, no memory text. */
 const SEEN_FILENAME = '.ainode.memory-seen.json';
 const MAX_SEEN = 300;
-/** The most one turn can add, so recall never becomes the bulk of a message. */
-const MAX_LINES = 8;
+/** The most one turn can add, so recall never becomes the bulk of a message. A
+ *  single memory can run to several lines, so the characters are the real limit. */
+const MAX_LINES = 16;
 const MAX_CHARS = 2400;
 // The pack sections that answer this message. The rest (working memory, recent,
 // the person) don't change with the message, and the chat already carries them.
-const RECALL_SECTIONS = new Set(['Corrections', 'Relevant memories', 'Related (from your memory graph)']);
+// The graph's links are bare keywords, nothing that can answer anything.
+const RECALL_SECTIONS = new Set(['Corrections', 'Relevant memories']);
+// Every heading a pack writes. A memory's own text can hold a markdown heading,
+// which must not read as the end of the section.
+const PACK_SECTIONS = new Set([
+    ...RECALL_SECTIONS, 'Related (from your memory graph)', 'Memory index', 'Working memory', 'Recent', "Who you're talking to",
+]);
+// Search can also return the dream's own digests: its "Right now" notes and memory
+// index, which have sections of their own, and a day's journal, whose lines all
+// live on elsewhere. None of them is a memory matched to this message.
+const DIGEST_HIT = /^- (?:Right now|Memory Index|\d{4}-\d{2}-\d{2}): /;
+// The pack keeps this much of each hit, which is how to tell where a multi-line
+// digest ends and the next hit starts.
+const HIT_TEXT_LIMIT = 300;
 /** The bullets of a memory pack worth showing for one message, in pack order. */
 function recallLines(block) {
     const lines = [];
-    let inSection = false;
-    for (const line of (block ?? '').split('\n')) {
-        const heading = /^#{2,3} (.+)$/.exec(line.trim());
-        if (heading) {
-            inSection = RECALL_SECTIONS.has(heading[1].trim());
+    const working = new Set();
+    let section = '';
+    let digestLeft = 0;
+    for (const raw of (block ?? '').split('\n')) {
+        const heading = /^#{2,3} (.+)$/.exec(raw.trim())?.[1].trim();
+        if (heading && PACK_SECTIONS.has(heading)) {
+            section = heading;
+            digestLeft = 0;
             continue;
         }
-        if (inSection && line.startsWith('- '))
-            lines.push(line.trim());
+        if (section === 'Working memory') {
+            if (raw.startsWith('- '))
+                working.add(raw.trim());
+            continue;
+        }
+        if (!RECALL_SECTIONS.has(section))
+            continue;
+        if (digestLeft > 0) {
+            digestLeft -= raw.length + 1;
+            continue;
+        }
+        const digest = DIGEST_HIT.exec(raw);
+        if (digest) {
+            digestLeft = HIT_TEXT_LIMIT - (raw.length - digest[0].length) - 1;
+            continue;
+        }
+        if (!raw.startsWith('- '))
+            continue;
+        const line = raw.trim().replace(/^- (?:- )+/, '- ');
+        if (!working.has(line))
+            lines.push(line);
     }
     return lines;
 }
+// The system prompt's pack and a message's pack render a memory with no heading
+// differently, and it's still the one memory.
 function hashLine(line) {
-    return (0, crypto_1.createHash)('sha1').update(line).digest('hex').slice(0, 16);
+    return (0, crypto_1.createHash)('sha1').update(line.replace(/^- memory: /, '- ')).digest('hex').slice(0, 16);
 }
 function readSeen(cwd) {
     try {

package/dist/session-runner.d.ts

@@ -1,3 +1,4 @@
+import { type ClaudePrintHandle } from './claude-print';
 import { type EntityboxQueueServices } from './entitybox-queue-request';
 import { type InstallResult } from './install';
 import { fetchMemoryPack } from './memory-pack';
@@ -130,6 +131,14 @@ export interface RuntimeRequestRow {
      *  the spawn. Resolves null for every entity without MSP switched on, and
      *  is undefined for runs it can't apply to. See model-selector.ts. */
     mspDecision?: Promise<MspDecision | null>;
+    /** NOT a DB column. What applyModelSelection decided: it publishes, so it
+     *  runs once however many steps ask. */
+    mspApplied?: Promise<MspDecision | null>;
+    /** NOT a DB column. A CLI startClaudeEarly has running, waiting for its prompt. */
+    earlyStart?: {
+        handle: ClaudePrintHandle;
+        at: number;
+    };
 }
 export declare function notifyFlowsIfFlowRequest(requestId: string): Promise<void>;
 export declare function notifyWidgetstudioIfWidgetRequest(requestId: string): Promise<void>;
@@ -145,6 +154,9 @@ export declare function notifySelfImproveIfEnabled(requestId: string): Promise<v
  *
  *  Exported for tests. */
 export declare function resumeSessionIsVoid(workingDirectory: string | null | undefined, resumeSessionId: string | null | undefined, cwdSubstituted: boolean): boolean;
+/** 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. */
+export declare function earlyStartWanted(req: Pick<RuntimeRequestRow, 'agent' | 'mode' | 'prompt' | 'resume_session_id' | 'entitybox_file_request'>, config: unknown): boolean;
 type MemoryPack = Awaited<ReturnType<typeof fetchMemoryPack>>;
 /**
  * Setup for a turn with the model selector on. It does what the block in
@@ -153,6 +165,6 @@ type MemoryPack = Awaited<ReturnType<typeof fetchMemoryPack>>;
  * turn. Claude reuses a resumed session's first system prompt, so its memory
  * pack and pointer there are only read again after a compaction.
  */
-export declare function prepareFastSetup(req: RuntimeRequestRow, cwd: string, installed: InstallResult, pack: Promise<MemoryPack>, startedAt: number): Promise<void>;
+export declare function prepareFastSetup(req: RuntimeRequestRow, cwd: string, installed: InstallResult, pack: Promise<MemoryPack>, startedAt: number, onSystemPromptReady?: () => Promise<void>): Promise<void>;
 export declare function runRequest(req: RuntimeRequestRow, entitybox?: EntityboxQueueServices): Promise<void>;
 export {};

package/dist/session-runner.js

@@ -43,6 +43,7 @@ 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"));
@@ -78,6 +79,7 @@ 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");
@@ -1646,7 +1648,10 @@ function publishModelSelection(req, d, changed) {
 }
 /** 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. */
-async function applyModelSelection(req) {
+function applyModelSelection(req) {
+    return req.mspApplied ??= selectModelOnce(req);
+}
+async function selectModelOnce(req) {
     const msp = req.mspDecision ? await req.mspDecision : null;
     if (!msp)
         return null;
@@ -1680,12 +1685,55 @@ function reportMcpTimings(req, file) {
     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.
@@ -1711,22 +1759,24 @@ async function runClaudePrint(req, cwd, installed) {
         }
     }
     const msp = await applyModelSelection(req);
-    const mcpDebugFile = msp?.mcp_timing ? path.join(os.tmpdir(), `ainode-mcp-${req.id}.log`) : null;
+    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: msp ? (0, time_context_1.appendChatTimeContext)(req.system_prompt) : (0, time_context_1.appendTimeContext)(req.system_prompt),
-            allowedTools: req.allowed_tools ?? undefined,
-            ...(mcpDebugFile ? { debugFile: mcpDebugFile } : {}),
-        });
+        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);
@@ -2375,6 +2425,16 @@ function livingPresenceBlock() {
  *  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
@@ -2382,9 +2442,15 @@ const QUICK_RECALL_WAIT_MS = 500;
  * 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) {
+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.
@@ -2435,6 +2501,8 @@ async function prepareFastSetup(req, cwd, installed, pack, startedAt) {
     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);
@@ -2514,7 +2582,7 @@ async function runRequest(req, entitybox) {
             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.fetchMemoryPack)(config_1.SUPABASE_URL, config_1.SUPABASE_ANON_KEY, { entityId, prompt: message, memberProfileId: req.member_profile_id ?? null })
+                    ? (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 }));
             }
         }
@@ -2586,10 +2654,11 @@ async function runRequest(req, entitybox) {
             skills_installed: installed.skillSlugs,
         });
     }
-    const fast = !!earlyPack && !!(await mspSetting);
+    const fastSetting = earlyPack ? await mspSetting : null;
+    const fast = !!fastSetting;
     if (fast) {
         try {
-            await prepareFastSetup(req, cwd, installed, earlyPack, startedAt);
+            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}`);
@@ -2683,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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@addai/node",
-  "version": "0.30.16-msp.7",
+  "version": "0.30.16-msp.9",
   "description": "Daemon that pairs a machine with your +Ai account and runs Claude / Codex / Kimi / Gemini agents on its behalf. Reachable via Supabase from Vault, Entity Studio, or any other +Ai surface.",
   "license": "MIT",
   "keywords": [