opencode-claude-memory 2.0.2 → 2.1.1

package/dist/host/v2/plugin.js

@@ -0,0 +1,149 @@
+import { z } from "zod/v4";
+import { memoryAgentDefaults } from "../../agents.js";
+import { parseConfig } from "../../config.js";
+import { ExtractionCoordinator } from "../../extraction/ExtractionCoordinator.js";
+import { buildMemorySystemPrompt } from "../../prompt/systemPrompt.js";
+import { formatRecalledMemories } from "../../recall/format.js";
+import { RecallCoordinator } from "../../recall/RecallCoordinator.js";
+import { MemoryStore } from "../../store/MemoryStore.js";
+import { resolveMemoryRoot } from "../../store/paths.js";
+import { buildMemoryToolSpecs } from "../../tools.js";
+import { getErrorMessage } from "../../util/log.js";
+import { OwnedSessions } from "../../util/ownedSessions.js";
+import { withDeadline } from "../../util/timeout.js";
+import { applyMemoryAgents, sandboxRules } from "./agents.js";
+import { consumeEvents, V2SessionEvents } from "./events.js";
+import { V2Host } from "./host.js";
+import { createFileLogger } from "./log.js";
+// Deadline for host calls made while setting up and tearing down (registrations, disposal).
+export const SETUP_CALL_TIMEOUT_MS = 30_000;
+export const CLEANUP_CALL_TIMEOUT_MS = 5_000;
+// The V2 plugin calls take no AbortSignal; withDeadline only bounds the wait.
+function bounded(what, timeoutMs, call) {
+    return withDeadline(what, timeoutMs, () => call());
+}
+// `codemode: false` exposes the tool to the model under its own name (and permission action);
+// otherwise V2 only reaches it through the Code Mode `execute` tool.
+export function toV2Tool(spec) {
+    return {
+        name: spec.name,
+        description: spec.description,
+        input: z.object(spec.args),
+        options: { codemode: false },
+        async execute(input, context) {
+            const result = await spec.execute((input ?? {}), { sessionID: context.sessionID });
+            return { content: result.output, ...(result.title ? { metadata: { title: result.title } } : {}) };
+        },
+    };
+}
+export const createV2Setup = (env, homeDir) => async (ctx) => {
+    const config = parseConfig(ctx.options, env, homeDir);
+    const directory = ctx.location.directory;
+    const worktree = ctx.location.project?.directory ?? directory;
+    const store = new MemoryStore(resolveMemoryRoot(worktree, directory), config);
+    const log = createFileLogger(store.stateDir);
+    const owned = new OwnedSessions();
+    const defaults = memoryAgentDefaults(config.agents);
+    const host = new V2Host({
+        session: ctx.session,
+        generateText: (input) => ctx.generate.text(input),
+        getAgent: async (name) => {
+            const agent = (await ctx.agent.get({ agentID: name }));
+            return agent?.data;
+        },
+        sandboxFor: (name) => sandboxRules(defaults[name]?.allowedTools ?? []),
+        log,
+    });
+    const deps = { store, config, host, owned, log };
+    const recall = new RecallCoordinator(deps);
+    const extraction = new ExtractionCoordinator(deps);
+    const events = new V2SessionEvents({ directory, owned, recall, extraction });
+    const registrations = [];
+    const register = async (what, call) => {
+        registrations.push(await bounded(what, SETUP_CALL_TIMEOUT_MS, call));
+    };
+    const disposeRegistrations = async () => {
+        for (const registration of registrations.splice(0).reverse()) {
+            try {
+                await bounded("registration.dispose", CLEANUP_CALL_TIMEOUT_MS, () => registration.dispose());
+            }
+            catch {
+                // the host tears the plugin scope down anyway
+            }
+        }
+    };
+    const registerHooks = async () => {
+        await register("agent.transform", () => ctx.agent.transform((editor) => applyMemoryAgents(editor, config.agents)));
+        await register("tool.transform", () => ctx.tool.transform((editor) => {
+            for (const spec of buildMemoryToolSpecs(store, extraction)) {
+                editor.add(toV2Tool(spec));
+            }
+        }));
+        // Before the prompt is admitted: start the recall selector for this turn.
+        await register("session.hook(prompt)", () => ctx.session.hook("prompt", (event) => {
+            const { sessionID } = event;
+            if (owned.has(sessionID) || host.systemFor(sessionID) !== undefined)
+                return;
+            events.track(sessionID);
+            const text = event.prompt?.text;
+            recall.onTurn({
+                sessionID,
+                turnID: event.messageID,
+                query: typeof text === "string" ? text : undefined,
+                // Prompts reach the plugin one by one; there is no history to replay here.
+                ignoredInHistory: () => false,
+                surfaced: () => events.surfacedKeys(sessionID),
+                recentTools: () => [],
+            });
+        }));
+        // Before every model request: the fork's own system prompt, or the memory prompt.
+        await register("session.hook(context)", () => ctx.session.hook("context", async (event) => {
+            const { sessionID } = event;
+            const forkSystem = host.systemFor(sessionID);
+            if (forkSystem !== undefined) {
+                event.system.push({ type: "text", text: forkSystem });
+                return;
+            }
+            if (owned.has(sessionID))
+                return;
+            events.track(sessionID);
+            // Everything recalled in this session so far, not only this turn's selection: the system
+            // prompt is rebuilt for every request, so a memory shown once would otherwise vanish after
+            // the first tool call while the selector keeps skipping it as already surfaced.
+            const recalled = events.remember(sessionID, await recall.takeRecalled(sessionID));
+            const ignored = recall.isIgnored(sessionID);
+            const text = buildMemorySystemPrompt(store, ignored ? "" : formatRecalledMemories(recalled), {
+                includeIndex: !ignored,
+            });
+            event.system.push({ type: "text", text });
+        }));
+    };
+    try {
+        await registerHooks();
+    }
+    catch (error) {
+        // A registration that failed or timed out fails the whole setup: undo the ones that succeeded
+        // so the host is not left with hidden agents or hooks of a plugin it reports as failed.
+        extraction.dispose();
+        owned.dispose();
+        await disposeRegistrations();
+        throw error;
+    }
+    const abort = new AbortController();
+    const consuming = consumeEvents((options) => ctx.event.subscribe(options), abort.signal, (event) => events.handle(event), (error) => log("warn", "Event stream failed; re-subscribing", { error: getErrorMessage(error) }));
+    // Runs once the agent sandbox is registered; failures are logged inside catchUp().
+    void extraction.catchUp();
+    log("info", "opencode-claude-memory loaded", { directory, memoryDir: store.memoryDir });
+    return async () => {
+        abort.abort();
+        extraction.dispose();
+        owned.dispose();
+        await disposeRegistrations();
+        try {
+            await bounded("event stream", CLEANUP_CALL_TIMEOUT_MS, () => consuming);
+        }
+        catch {
+            // an iterator that ignores the abort is left to the host
+        }
+    };
+};

package/dist/host/v2/transcript.d.ts

@@ -0,0 +1,3 @@
+import type { TranscriptMessage } from "../types.js";
+import type { V2Message } from "./fork.js";
+export declare function toTranscript(messages: readonly V2Message[]): TranscriptMessage[];

package/dist/host/v2/transcript.js

@@ -0,0 +1,50 @@
+function toolOutput(content) {
+    if (!Array.isArray(content))
+        return undefined;
+    const text = content
+        .map((item) => (item && typeof item === "object" ? item.text : undefined))
+        .filter((value) => typeof value === "string")
+        .join("\n");
+    return text || undefined;
+}
+function assistantParts(content) {
+    if (!Array.isArray(content))
+        return [];
+    const parts = [];
+    for (const raw of content) {
+        if (!raw || typeof raw !== "object")
+            continue;
+        if (raw.type === "text" && typeof raw.text === "string") {
+            parts.push({ type: "text", text: raw.text });
+        }
+        else if (raw.type === "tool" && typeof raw.name === "string") {
+            const status = typeof raw.state?.status === "string" ? raw.state.status : undefined;
+            parts.push({ type: "tool", tool: raw.name, state: { status, output: toolOutput(raw.state?.content) } });
+        }
+    }
+    return parts;
+}
+// User and assistant messages only: synthetic, system, compaction and bookkeeping messages carry no
+// conversation the user had.
+export function toTranscript(messages) {
+    const transcript = [];
+    for (const message of messages) {
+        if (message.type === "user") {
+            transcript.push({
+                info: { id: message.id, role: "user", time: { created: message.time?.created } },
+                parts: typeof message.text === "string" ? [{ type: "text", text: message.text }] : [],
+            });
+        }
+        else if (message.type === "assistant") {
+            transcript.push({
+                info: {
+                    id: message.id,
+                    role: "assistant",
+                    time: { created: message.time?.created, completed: message.time?.completed },
+                },
+                parts: assistantParts(message.content),
+            });
+        }
+    }
+    return transcript;
+}

package/dist/index.d.ts

@@ -1,8 +1,13 @@
 import type { Plugin, PluginModule } from "@opencode-ai/plugin";
+import { createMemoryPlugin } from "./host/v1/plugin.js";
+import { createV2Setup, type V2Cleanup, type V2Context } from "./host/v2/plugin.js";
 export declare const PLUGIN_ID = "opencode-claude-memory";
-export declare const createMemoryPlugin: (env?: NodeJS.ProcessEnv, homeDir?: string) => Plugin;
+export { createMemoryPlugin, createV2Setup };
 export declare const MemoryPlugin: Plugin;
-declare const plugin: PluginModule;
+export declare const MemorySetup: (context: V2Context) => Promise<V2Cleanup>;
+declare const plugin: PluginModule & {
+    setup: typeof MemorySetup;
+};
 export default plugin;
 export { MEMORY_AGENTS, type MemoryConfig, type MemoryOptions, MemoryOptionsSchema } from "./config.js";
 export { MemoryStore } from "./store/MemoryStore.js";

package/dist/index.js

@@ -1,60 +1,10 @@
-import { AgentRegistry } from "./agents.js";
-import { parseConfig } from "./config.js";
-import { ExtractionCoordinator } from "./extraction/ExtractionCoordinator.js";
-import { buildMemorySystemPrompt } from "./prompt/systemPrompt.js";
-import { formatRecalledMemories } from "./recall/format.js";
-import { RecallCoordinator } from "./recall/RecallCoordinator.js";
-import { MemoryStore } from "./store/MemoryStore.js";
-import { resolveMemoryRoot } from "./store/paths.js";
-import { buildMemoryTools } from "./tools.js";
-import { createLogger } from "./util/log.js";
-import { OwnedSessions } from "./util/ownedSessions.js";
+import { createMemoryPlugin } from "./host/v1/plugin.js";
+import { createV2Setup } from "./host/v2/plugin.js";
 export const PLUGIN_ID = "opencode-claude-memory";
-// Assembly only. Every piece of mutable state lives on the coordinators created here, so OpenCode's
-// multi-directory `serve` gets fully isolated instances. `env` and `homeDir` are injectable so tests
-// never touch the real environment (CLAUDE_CONFIG_DIR is the only variable read, see config.ts).
-export const createMemoryPlugin = (env, homeDir) => async ({ worktree, directory, client }, options) => {
-    const config = parseConfig(options, env, homeDir);
-    const dir = directory ?? worktree;
-    const store = new MemoryStore(resolveMemoryRoot(worktree, dir), config);
-    const log = createLogger(client, dir);
-    const owned = new OwnedSessions();
-    const agents = new AgentRegistry(config.agents);
-    const deps = { store, config, client, directory: dir, owned, agents, log };
-    const recall = new RecallCoordinator(deps);
-    const extraction = new ExtractionCoordinator(deps);
-    return {
-        config: async (cfg) => {
-            agents.register(cfg);
-            // Runs once the agent sandbox is known; failures are logged inside catchUp().
-            void extraction.catchUp();
-        },
-        event: async ({ event }) => {
-            if (event.type === "session.deleted")
-                owned.release(event.properties.info.id, 5_000);
-            recall.onEvent(event);
-            extraction.onEvent(event);
-        },
-        "experimental.chat.messages.transform": async (_input, output) => {
-            recall.onMessagesTransform(output);
-        },
-        "experimental.chat.system.transform": async ({ sessionID }, output) => {
-            if (owned.has(sessionID))
-                return;
-            const recalled = await recall.takeRecalled(sessionID);
-            output.system.push(buildMemorySystemPrompt(store, formatRecalledMemories(recalled), {
-                includeIndex: !recall.isIgnored(sessionID),
-            }));
-        },
-        tool: buildMemoryTools(store, extraction),
-        dispose: async () => {
-            extraction.dispose();
-            owned.dispose();
-        },
-    };
-};
+export { createMemoryPlugin, createV2Setup };
 export const MemoryPlugin = createMemoryPlugin();
-const plugin = { id: PLUGIN_ID, server: MemoryPlugin };
+export const MemorySetup = createV2Setup();
+const plugin = { id: PLUGIN_ID, server: MemoryPlugin, setup: MemorySetup };
 export default plugin;
 export { MEMORY_AGENTS, MemoryOptionsSchema } from "./config.js";
 export { MemoryStore } from "./store/MemoryStore.js";

package/dist/recall/RecallCoordinator.d.ts

@@ -1,34 +1,39 @@
-import type { AgentRegistry } from "../agents.js";
 import type { MemoryConfig } from "../config.js";
-import type { ChatMessage, OpencodeClient, PluginEvent } from "../sdk.js";
+import type { MemoryHost } from "../host/types.js";
 import type { MemoryStore } from "../store/MemoryStore.js";
 import type { Logger } from "../util/log.js";
 import type { OwnedSessions } from "../util/ownedSessions.js";
 import { type RecalledMemory } from "./format.js";
 export declare const SESSION_STATE_TTL_MS: number;
 export declare const SELECTOR_GRACE_MS = 60000;
+export type RecallTurn = {
+    sessionID: string;
+    turnID: string;
+    query: string | undefined;
+    ignoredInHistory: () => boolean;
+    surfaced: () => ReadonlySet<string>;
+    recentTools: () => readonly string[];
+};
 export type RecallCoordinatorDeps = {
     store: MemoryStore;
     config: MemoryConfig;
-    client: OpencodeClient | undefined;
-    directory: string;
+    host: MemoryHost | undefined;
     owned: OwnedSessions;
-    agents: AgentRegistry;
     log: Logger;
     now?: () => number;
 };
 export declare class RecallCoordinator {
-    private readonly deps;
+    protected readonly deps: RecallCoordinatorDeps;
     private readonly sessions;
     private warnedMissingSessionID;
     private readonly now;
     constructor(deps: RecallCoordinatorDeps);
-    onMessagesTransform(output: {
-        messages: ChatMessage[];
-    }): void;
+    onTurn(turn: RecallTurn): {
+        ignored: boolean;
+    };
     takeRecalled(sessionID: string | undefined): Promise<RecalledMemory[]>;
     isIgnored(sessionID: string | undefined): boolean;
-    onEvent(event: PluginEvent): void;
+    forget(sessionID: string): void;
     get trackedSessions(): number;
     private race;
     private evictStale;

package/dist/recall/RecallCoordinator.js

@@ -1,8 +1,7 @@
-import { deriveIgnoredFromHistory, detectIgnoreMemory, detectResumeMemory, stripAutoMemoryParts, } from "../hooks/ignore.js";
-import { buildTurnID, collectSurfacedMemoryKeys, extractRecentTools, getLastUserQuery } from "../hooks/messages.js";
 import { surfaceKey } from "../store/scan.js";
 import { recallSelectedMemories } from "./format.js";
-import { selectRelevantMemoryFilenames } from "./selector.js";
+import { selectRelevantMemories } from "./selector.js";
+import { detectIgnoreMemory, detectResumeMemory } from "./turn.js";
 export const SESSION_STATE_TTL_MS = 60 * 60 * 1000;
 export const SELECTOR_GRACE_MS = 60_000;
 const TIMEOUT = Symbol("recall-timeout");
@@ -23,39 +22,32 @@ export class RecallCoordinator {
         this.deps = deps;
         this.now = deps.now ?? Date.now;
     }
-    // `experimental.chat.messages.transform`: derive the turn state and start the selector prefetch.
-    onMessagesTransform(output) {
-        const turn = getLastUserQuery(output.messages);
+    // Derives the turn state and starts the selector prefetch. Returns whether memory is ignored for
+    // this session, so the host can drop the plugin's own prompt segment from the history.
+    onTurn(turn) {
         const { sessionID } = turn;
-        if (!sessionID) {
-            if (detectIgnoreMemory(turn.query))
-                output.messages = stripAutoMemoryParts(output.messages);
-            return;
-        }
         if (this.deps.owned.has(sessionID))
-            return;
+            return { ignored: false };
         const now = this.now();
         this.evictStale(now);
         const state = this.sessions.get(sessionID) ?? {
             updatedAt: now,
-            ignored: deriveIgnoredFromHistory(output.messages),
+            ignored: turn.ignoredInHistory(),
         };
         state.updatedAt = now;
-        const turnID = buildTurnID(sessionID, turn);
-        if (state.turnID !== turnID) {
+        if (state.turnID !== turn.turnID) {
             if (detectIgnoreMemory(turn.query))
                 state.ignored = true;
             else if (state.ignored && detectResumeMemory(turn.query))
                 state.ignored = false;
-            state.turnID = turnID;
-            state.prefetch = state.ignored ? undefined : this.startPrefetch(sessionID, turnID, turn.query, output.messages);
+            state.turnID = turn.turnID;
+            state.prefetch = state.ignored ? undefined : this.startPrefetch(turn);
         }
         this.sessions.set(sessionID, state);
-        if (state.ignored)
-            output.messages = stripAutoMemoryParts(output.messages);
+        return { ignored: state.ignored };
     }
-    // `experimental.chat.system.transform`: wait for the prefetch (bounded by recall.waitMs) and hand
-    // the result over exactly once. On timeout the prefetch keeps running for the next LLM call.
+    // Waits for the prefetch (bounded by recall.waitMs) and hands the result over exactly once. On
+    // timeout the prefetch keeps running for the next model call.
     async takeRecalled(sessionID) {
         if (!sessionID) {
             if (!this.warnedMissingSessionID) {
@@ -77,9 +69,9 @@ export class RecallCoordinator {
     isIgnored(sessionID) {
         return sessionID !== undefined && this.sessions.get(sessionID)?.ignored === true;
     }
-    onEvent(event) {
-        if (event.type === "session.deleted")
-            this.sessions.delete(event.properties.info.id);
+    // The session was deleted: its preference and turn cache go with it.
+    forget(sessionID) {
+        this.sessions.delete(sessionID);
     }
     get trackedSessions() {
         return this.sessions.size;
@@ -110,24 +102,23 @@ export class RecallCoordinator {
             }
         }
     }
-    startPrefetch(sessionID, turnID, query, messages) {
-        const { client, config, store, owned, agents, directory } = this.deps;
-        if (!config.recall.enabled || !client || !isUsefulRecallQuery(query))
+    startPrefetch(turn) {
+        const { host, config, store, owned } = this.deps;
+        const { query } = turn;
+        if (!config.recall.enabled || !host || !isUsefulRecallQuery(query))
             return undefined;
-        const alreadySurfaced = collectSurfacedMemoryKeys(messages);
-        const recentTools = extractRecentTools(messages);
+        const alreadySurfaced = turn.surfaced();
+        const recentTools = turn.recentTools();
         const headers = store.scan().filter((header) => !alreadySurfaced.has(surfaceKey(header)));
         if (headers.length === 0)
             return undefined;
-        const promise = selectRelevantMemoryFilenames({
-            client,
-            directory,
-            parentSessionID: sessionID,
+        const promise = selectRelevantMemories({
+            host,
+            parentSessionID: turn.sessionID,
             query,
             memories: headers,
             recentTools,
             agent: config.agents.recall,
-            tools: agents.toolsFor(config.agents.recall),
             timeoutMs: config.recall.timeoutMs,
             maxMemories: config.recall.maxMemories,
             onSessionCreated: (id) => owned.add(id),
@@ -135,6 +126,6 @@ export class RecallCoordinator {
         })
             .then((selected) => recallSelectedMemories(headers, selected, alreadySurfaced, { maxMemories: config.recall.maxMemories }))
             .catch(() => []);
-        return { turnID, promise, consumed: false };
+        return { turnID: turn.turnID, promise, consumed: false };
     }
 }

package/dist/recall/selector.d.ts

@@ -1,37 +1,32 @@
-import { type OpencodeClient } from "../sdk.js";
+import type { MemoryHost } from "../host/types.js";
 import { type MemoryHeader } from "../store/scan.js";
 export declare const SELECT_MEMORIES_SYSTEM_PROMPT = "You are selecting memories that will be useful to OpenCode as it processes a user's query. You will be given the user's query and a list of available memory files with their filenames and descriptions.\n\nReturn a list of filenames for the memories that will clearly be useful to OpenCode as it processes the user's query (up to 5). Only include memories that you are certain will be helpful based on their name and description.\n- If you are unsure if a memory will be useful in processing the user's query, then do not include it in your list. Be selective and discerning.\n- If there are no memories in the list that would clearly be useful, feel free to return an empty list.\n- If a list of recently-used tools is provided, do not select memories that are usage reference or API documentation for those tools (OpenCode is already exercising them). DO still select memories containing warnings, gotchas, or known issues about those tools \u2014 active use is exactly when those matter.\n";
-export declare const SELECT_MEMORIES_FORMAT: {
-    readonly type: "json_schema";
-    readonly schema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly selected_memories: {
-                readonly type: "array";
-                readonly items: {
-                    readonly type: "string";
-                };
+export declare const SELECT_MEMORIES_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly selected_memories: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
             };
         };
-        readonly required: readonly ["selected_memories"];
-        readonly additionalProperties: false;
     };
+    readonly required: readonly ["selected_memories"];
+    readonly additionalProperties: false;
 };
 export declare const RECALL_SELECTOR_TITLE = "opencode-memory recall selector";
-export type SelectRelevantMemoryFilenamesInput = {
-    client: OpencodeClient;
-    directory: string;
+export type SelectRelevantMemoriesInput = {
+    host: MemoryHost;
     parentSessionID: string;
     query: string;
     memories: readonly MemoryHeader[];
     recentTools: readonly string[];
     agent: string;
-    tools?: Record<string, boolean>;
     timeoutMs: number;
     maxMemories: number;
     onSessionCreated?: (sessionID: string) => void;
     onSessionFinished?: (sessionID: string) => void;
 };
-export declare function extractSelectedMemories(response: unknown): string[];
+export declare function parseSelectedMemories(text: string): string[];
 export declare function buildSelectorQuery(query: string, memories: readonly MemoryHeader[], recentTools: readonly string[]): string;
-export declare function selectRelevantMemoryFilenames(input: SelectRelevantMemoryFilenamesInput): Promise<string[]>;
+export declare function selectRelevantMemories(input: SelectRelevantMemoriesInput): Promise<string[]>;

package/dist/recall/selector.js

@@ -1,7 +1,3 @@
-// LLM memory selection, ported from Claude Code's findRelevantMemories.ts side query. Runs in a
-// hidden child session so the main conversation never sees the selector exchange.
-import { runForkSession } from "../extraction/forkSession.js";
-import { unwrapData } from "../sdk.js";
 import { formatMemoryManifest } from "../store/scan.js";
 export const SELECT_MEMORIES_SYSTEM_PROMPT = `You are selecting memories that will be useful to OpenCode as it processes a user's query. You will be given the user's query and a list of available memory files with their filenames and descriptions.
 
@@ -10,52 +6,49 @@ Return a list of filenames for the memories that will clearly be useful to OpenC
 - If there are no memories in the list that would clearly be useful, feel free to return an empty list.
 - If a list of recently-used tools is provided, do not select memories that are usage reference or API documentation for those tools (OpenCode is already exercising them). DO still select memories containing warnings, gotchas, or known issues about those tools — active use is exactly when those matter.
 `;
-export const SELECT_MEMORIES_FORMAT = {
-    type: "json_schema",
-    schema: {
-        type: "object",
-        properties: {
-            selected_memories: { type: "array", items: { type: "string" } },
-        },
-        required: ["selected_memories"],
-        additionalProperties: false,
+export const SELECT_MEMORIES_SCHEMA = {
+    type: "object",
+    properties: {
+        selected_memories: { type: "array", items: { type: "string" } },
     },
+    required: ["selected_memories"],
+    additionalProperties: false,
 };
 export const RECALL_SELECTOR_TITLE = "opencode-memory recall selector";
-function tryParseSelectedMemories(raw) {
+function selectedFrom(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const selected = value.selected_memories;
+    if (!Array.isArray(selected))
+        return undefined;
+    return selected.filter((item) => typeof item === "string");
+}
+function tryParse(raw) {
     try {
-        const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed.selected_memories))
-            return undefined;
-        return parsed.selected_memories.filter((item) => typeof item === "string");
+        return selectedFrom(JSON.parse(raw));
     }
     catch {
         return undefined;
     }
 }
-export function extractSelectedMemories(response) {
-    const data = unwrapData(response);
-    if (!data || typeof data !== "object")
-        return [];
-    const structured = data.info?.structured;
-    if (structured && typeof structured === "object") {
-        const selected = structured.selected_memories;
-        if (Array.isArray(selected)) {
-            return selected.filter((item) => typeof item === "string");
-        }
-    }
-    if (!Array.isArray(data.parts))
+// The selector answer as text: the whole answer, one of its lines, or the first JSON object inside
+// prose / a code fence. Anything unparsable selects nothing.
+export function parseSelectedMemories(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
         return [];
-    for (const part of data.parts) {
-        if (!part || typeof part !== "object")
-            continue;
-        const text = part.text;
-        if (typeof text !== "string")
-            continue;
-        const parsed = tryParseSelectedMemories(text);
+    const whole = tryParse(trimmed);
+    if (whole)
+        return whole;
+    for (const line of trimmed.split("\n")) {
+        const parsed = tryParse(line.trim());
         if (parsed)
             return parsed;
     }
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start >= 0 && end > start)
+        return tryParse(trimmed.slice(start, end + 1)) ?? [];
     return [];
 }
 export function buildSelectorQuery(query, memories, recentTools) {
@@ -63,26 +56,23 @@ export function buildSelectorQuery(query, memories, recentTools) {
     return `Query: ${query}\n\nAvailable memories:\n${formatMemoryManifest(memories)}${toolsSection}`;
 }
 // Never throws: a failed or timed-out selector simply recalls nothing for this turn.
-export async function selectRelevantMemoryFilenames(input) {
+export async function selectRelevantMemories(input) {
     if (input.memories.length === 0)
         return [];
     try {
-        const response = await runForkSession({
-            client: input.client,
-            directory: input.directory,
-            parentSessionID: input.parentSessionID,
-            title: RECALL_SELECTOR_TITLE,
+        const answer = await input.host.generate({
             agent: input.agent,
+            title: RECALL_SELECTOR_TITLE,
             system: SELECT_MEMORIES_SYSTEM_PROMPT,
-            tools: input.tools ?? { "*": false },
-            format: SELECT_MEMORIES_FORMAT,
-            parts: [{ type: "text", text: buildSelectorQuery(input.query, input.memories, input.recentTools) }],
+            text: buildSelectorQuery(input.query, input.memories, input.recentTools),
+            schema: SELECT_MEMORIES_SCHEMA,
+            parentSessionID: input.parentSessionID,
             timeoutMs: input.timeoutMs,
             onCreated: input.onSessionCreated,
             onFinished: input.onSessionFinished,
         });
         const validFilenames = new Set(input.memories.map((memory) => memory.filename));
-        return extractSelectedMemories(response)
+        return parseSelectedMemories(answer)
             .filter((filename) => validFilenames.has(filename))
             .slice(0, input.maxMemories);
     }

package/dist/recall/turn.d.ts

@@ -0,0 +1,4 @@
+export declare function detectIgnoreMemory(query: string | undefined): boolean;
+export declare function detectResumeMemory(query: string | undefined): boolean;
+export declare function deriveIgnoredFromQueries(queries: Iterable<string | undefined>): boolean;
+export declare function extractSurfacedMemoryKeys(systemText: string): Set<string>;