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

package/dist/capabilities.d.ts

@@ -83,9 +83,13 @@ interface CapabilitiesShape {
     auto_update?: AutoUpdateState;
     /** Present when this build has the Model Selector Protocol, so Studio can
      *  say which nodes would ignore an entity's selector setting instead of
-     *  guessing from a version number. enabled is false under ADDAI_MSP=0. */
+     *  guessing from a version number. enabled is false under ADDAI_MSP=0.
+     *  jev is true on builds that can use Jev as the selector, codex on builds
+     *  that pick for Codex turns too. */
     model_selector?: {
         enabled: boolean;
+        jev?: boolean;
+        codex?: boolean;
     };
 }
 /** What the heartbeat says about claude's models. `models` keeps its old

package/dist/capabilities.js

@@ -510,7 +510,7 @@ async function probeCapabilities() {
         autostart: (0, autostart_1.status)(),
         container_engine: containerEngine,
         flows: await probeFlows(),
-        model_selector: { enabled: process.env.ADDAI_MSP !== '0' },
+        model_selector: { enabled: process.env.ADDAI_MSP !== '0', jev: true, codex: true },
         auto_update: (0, auto_update_1.autoUpdateState)(),
         machine: (0, machine_metrics_1.sampleMachine)(),
         claude: deco('claude', claude),

package/dist/claude-print.d.ts

@@ -14,7 +14,34 @@ export interface ClaudePrintInput {
     appendSystemPrompt?: string;
     /** Restrict to a specific set of tools (claude only). null/undefined = inherit. */
     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
+ * synchronously, stopping the whole daemon while it does, and the answer rarely
+ * changes between turns. A path that has gone missing is looked up again.
+ */
+export declare function cachedClaudeBinary(): string | null;
+export interface McpTimings {
+    /** Slowest first. */
+    servers: Array<{
+        name: string;
+        transport: string;
+        ms: number;
+    }>;
+    failed: string[];
+    /** Log start to the first app starting to connect: the CLI's own boot. */
+    first_start_ms: number | null;
+    /** Log start to the last app connected. */
+    last_connected_ms: number | null;
+}
+/** Each app's connection time from a CLI debug log. Takes names and numbers only:
+ *  the log can hold anything the CLI saw, so none of its free text goes further. */
+export declare function parseMcpTimings(log: string): McpTimings;
 export type ClaudePrintInputBlock = {
     type: 'text';
     text: string;
@@ -27,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.
@@ -49,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

@@ -4,17 +4,111 @@
 // Spawns Claude non-interactively, parses each JSONL line on stdout into
 // our normalised RuntimeEvent shape, and resolves when the process exits.
 // No PTY needed — Claude detects non-TTY and runs headless.
+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.cachedClaudeBinary = cachedClaudeBinary;
+exports.parseMcpTimings = parseMcpTimings;
+exports.claudePrintPromptMessage = claudePrintPromptMessage;
 exports.claudePrintInputMessage = claudePrintInputMessage;
 exports.blockDelta = blockDelta;
 exports.lineToEvents = lineToEvents;
 exports.spawnClaudePrint = spawnClaudePrint;
 const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
 const claude_binary_1 = require("./claude-binary");
 const win_1 = require("./win");
 const claude_system_prompt_1 = require("./claude-system-prompt");
 const prompt_transport_1 = require("./prompt-transport");
+let cachedBinary = null;
+const CACHED_BINARY_MS = 10 * 60_000;
+/**
+ * findClaudeBinary for the spawn path. The lookup runs `where` or a login shell
+ * synchronously, stopping the whole daemon while it does, and the answer rarely
+ * changes between turns. A path that has gone missing is looked up again.
+ */
+function cachedClaudeBinary() {
+    const c = cachedBinary;
+    if (c && c.pathEnv === process.env.PATH && Date.now() - c.at < CACHED_BINARY_MS && fs.existsSync(c.path)) {
+        return c.path;
+    }
+    const found = (0, claude_binary_1.findClaudeBinary)();
+    cachedBinary = found ? { path: found, pathEnv: process.env.PATH, at: Date.now() } : null;
+    return found;
+}
+/** Each app's connection time from a CLI debug log. Takes names and numbers only:
+ *  the log can hold anything the CLI saw, so none of its free text goes further. */
+function parseMcpTimings(log) {
+    const servers = [];
+    const failed = [];
+    const stamp = (line) => {
+        const t = Date.parse(line.slice(0, 24));
+        return Number.isNaN(t) ? null : t;
+    };
+    let logStart = null;
+    let firstStart = null;
+    let lastConnected = null;
+    for (const line of log.split('\n')) {
+        const at = stamp(line);
+        if (logStart === null && at !== null)
+            logStart = at;
+        if (firstStart === null && /MCP server "[^"]+": Starting connection/.test(line))
+            firstStart = at;
+        const ok = /MCP server "([^"]+)": Successfully connected \(transport: ([^)]+)\) in (\d+)ms/.exec(line);
+        if (ok) {
+            servers.push({ name: ok[1], transport: ok[2], ms: Number(ok[3]) });
+            if (at !== null)
+                lastConnected = at;
+            continue;
+        }
+        const bad = /MCP server "([^"]+)": Connection (?:failed|timed out)/.exec(line);
+        if (bad)
+            failed.push(bad[1]);
+    }
+    const since = (t) => (t !== null && logStart !== null ? t - logStart : null);
+    return {
+        servers: servers.sort((a, b) => b.ms - a.ms),
+        failed,
+        first_start_ms: since(firstStart),
+        last_connected_ms: since(lastConnected),
+    };
+}
 /** 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)))))
@@ -125,7 +219,7 @@ function lineToEvents(line, suppressText = false) {
 }
 function spawnClaudePrint(input) {
     const inputMessage = input.inputBlocks ? claudePrintInputMessage(input.prompt, input.inputBlocks) : undefined;
-    const bin = (0, claude_binary_1.findClaudeBinary)();
+    const bin = cachedClaudeBinary();
     // No claude on this runtime — fail THIS request cleanly rather than
     // spawning a bare 'claude' that ENOENTs and crashes the daemon. Both
     // callers (runClaudePrint, runGuardrailRetryTurn) wrap this in try/catch
@@ -150,7 +244,9 @@ function spawnClaudePrint(input) {
     ];
     if (partialStream)
         args.push('--include-partial-messages');
-    if (input.inputBlocks)
+    if (input.debugFile)
+        args.push('--debug-file', input.debugFile);
+    if (input.inputBlocks || input.deferPrompt)
         args.push('--input-format', 'stream-json');
     if (input.permissionMode === 'bypassPermissions') {
         args.push('--dangerously-skip-permissions');
@@ -217,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
@@ -356,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();
@@ -369,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/codex-models.d.ts

@@ -79,3 +79,5 @@ export declare function codexModelsFor(bin: string, key: string): CodexModelRepo
  * model is not in its list.
  */
 export declare function codexModelEfforts(model?: string | null, report?: CodexModelReport | null): string[] | null;
+/** False only when codex has listed its models and this isn't one of them. */
+export declare function codexModelListed(model: string, report?: CodexModelReport | null): boolean;

package/dist/codex-models.js

@@ -71,6 +71,7 @@ exports.probeCodexModels = probeCodexModels;
 exports.createCodexModelCache = createCodexModelCache;
 exports.codexModelsFor = codexModelsFor;
 exports.codexModelEfforts = codexModelEfforts;
+exports.codexModelListed = codexModelListed;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -383,3 +384,7 @@ function codexModelEfforts(model, report = sharedCache.last()) {
     const entry = model ? report.catalog.find(e => e.id === model) : report.catalog.find(e => e.default);
     return entry?.efforts?.length ? entry.efforts : null;
 }
+/** False only when codex has listed its models and this isn't one of them. */
+function codexModelListed(model, report = sharedCache.last()) {
+    return !report || report.catalog.some(e => e.id === model);
+}

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.d.ts

@@ -0,0 +1,8 @@
+/** The bullets of a memory pack worth showing for one message, in pack order. */
+export declare function recallLines(block: string): string[];
+/** A new session's first turn shows the whole pack in its system prompt: start
+ *  the seen list from it, so the second turn doesn't repeat those lines. */
+export declare function rememberRecall(cwd: string, block: string): void;
+/** The prompt with this message's new memories at the top, or unchanged when
+ *  there are none. Only what actually went in counts as seen. */
+export declare function withFreshRecall(prompt: string, block: string, cwd: string): string;