opencode-claude-memory 2.0.2 → 2.1.0

package/dist/host/v1/agents.js

@@ -0,0 +1,48 @@
+// V1 registration of the hidden memory agents. Users override any field in opencode.json
+// (`agent.opencode-memory-extract.model`, ...); the plugin only fills in what they did not set.
+import { memoryAgentDefaults } from "../../agents.js";
+export function buildAgentDefaults(agents) {
+    return Object.fromEntries(Object.entries(memoryAgentDefaults(agents)).map(([name, defaults]) => {
+        const config = {
+            mode: "all",
+            hidden: true,
+            ...(defaults.temperature !== undefined ? { temperature: defaults.temperature } : {}),
+            prompt: defaults.prompt,
+            ...(defaults.steps !== undefined ? { steps: defaults.steps } : {}),
+            tools: { "*": false, ...Object.fromEntries(defaults.allowedTools.map((tool) => [tool, true])) },
+        };
+        return [name, config];
+    }));
+}
+export function mergeAgentConfig(defaults, user) {
+    if (!user)
+        return { ...defaults };
+    const merged = { ...defaults, ...user };
+    // `maxSteps` is the deprecated spelling of `steps`; a user who only set the old name must not be
+    // overridden by the default `steps`.
+    if (user.steps === undefined && user.maxSteps !== undefined)
+        delete merged.steps;
+    return merged;
+}
+export class AgentRegistry {
+    defaults;
+    merged;
+    constructor(agents) {
+        this.defaults = buildAgentDefaults(agents);
+        this.merged = { ...this.defaults };
+    }
+    // `config` hook: merge defaults under the user's own entries and remember the outcome so forks can
+    // pass the effective tool sandbox explicitly (defence in depth, see fork.ts).
+    register(config) {
+        config.agent ??= {};
+        const agent = config.agent;
+        for (const [name, defaults] of Object.entries(this.defaults)) {
+            const merged = mergeAgentConfig(defaults, agent[name]);
+            agent[name] = merged;
+            this.merged[name] = merged;
+        }
+    }
+    toolsFor(name) {
+        return this.merged[name]?.tools;
+    }
+}

package/dist/host/v1/coordinators.d.ts

@@ -0,0 +1,12 @@
+import { ExtractionCoordinator } from "../../extraction/ExtractionCoordinator.js";
+import { RecallCoordinator } from "../../recall/RecallCoordinator.js";
+import type { ChatMessage, PluginEvent } from "./sdk.js";
+export declare class V1RecallCoordinator extends RecallCoordinator {
+    onMessagesTransform(output: {
+        messages: ChatMessage[];
+    }): void;
+    onEvent(event: PluginEvent): void;
+}
+export declare class V1ExtractionCoordinator extends ExtractionCoordinator {
+    onEvent(event: PluginEvent): void;
+}

package/dist/host/v1/coordinators.js

@@ -0,0 +1,43 @@
+// V1 hook payloads → coordinator calls. The coordinators themselves are host-independent; these
+// subclasses only translate V1 events and the V1 message list.
+import { ExtractionCoordinator } from "../../extraction/ExtractionCoordinator.js";
+import { RecallCoordinator } from "../../recall/RecallCoordinator.js";
+import { deriveIgnoredFromHistory, detectIgnoreMemory, stripAutoMemoryParts } from "./ignore.js";
+import { buildTurnID, collectSurfacedMemoryKeys, extractRecentTools, getLastUserQuery } from "./messages.js";
+export class V1RecallCoordinator extends RecallCoordinator {
+    // `experimental.chat.messages.transform`: derive the turn state and start the selector prefetch.
+    onMessagesTransform(output) {
+        const turn = getLastUserQuery(output.messages);
+        const { sessionID } = turn;
+        if (!sessionID) {
+            if (detectIgnoreMemory(turn.query))
+                output.messages = stripAutoMemoryParts(output.messages);
+            return;
+        }
+        const messages = output.messages;
+        const { ignored } = this.onTurn({
+            sessionID,
+            turnID: buildTurnID(sessionID, turn),
+            query: turn.query,
+            ignoredInHistory: () => deriveIgnoredFromHistory(messages),
+            surfaced: () => collectSurfacedMemoryKeys(messages),
+            recentTools: () => extractRecentTools(messages),
+        });
+        if (ignored)
+            output.messages = stripAutoMemoryParts(output.messages);
+    }
+    onEvent(event) {
+        if (event.type === "session.deleted")
+            this.forget(event.properties.info.id);
+    }
+}
+export class V1ExtractionCoordinator extends ExtractionCoordinator {
+    onEvent(event) {
+        if (event.type === "session.idle")
+            this.onSessionIdle(event.properties.sessionID);
+        else if (event.type === "session.deleted")
+            this.onSessionDeleted(event.properties.info.id);
+        else if (event.type === "session.status")
+            this.onSessionStatus(event.properties.sessionID, event.properties.status.type);
+    }
+}

package/dist/{extraction/forkSession.d.ts → host/v1/fork.d.ts}

@@ -1,7 +1,8 @@
-import { type OpencodeClient } from "../sdk.js";
+import type { ForkCleanupStage } from "../types.js";
+import { type OpencodeClient } from "./sdk.js";
 export declare const FORK_CREATE_TIMEOUT_MS = 30000;
 export declare const FORK_CLEANUP_TIMEOUT_MS = 15000;
-export type ForkCleanupStage = "abort" | "delete";
+export type { ForkCleanupStage };
 export type ForkSessionInput = {
     client: OpencodeClient;
     directory: string;

package/dist/{extraction/forkSession.js → host/v1/fork.js}

@@ -4,8 +4,8 @@
 // Every stage has its own deadline and AbortSignal: the SDK client disables fetch timeouts, so a
 // hung `create`, `abort` or `delete` would otherwise pin the caller (and with it the extraction
 // queue and the maintenance lock) forever. `onFinished` always fires, even when cleanup timed out.
-import { unwrapData } from "../sdk.js";
-import { TimeoutError, withDeadline } from "../util/timeout.js";
+import { TimeoutError, withDeadline } from "../../util/timeout.js";
+import { unwrapData } from "./sdk.js";
 export const FORK_CREATE_TIMEOUT_MS = 30_000;
 export const FORK_CLEANUP_TIMEOUT_MS = 15_000;
 export class ForkSessionTimeoutError extends Error {

package/dist/host/v1/host.d.ts

@@ -0,0 +1,9 @@
+import { type MemoryHost } from "../types.js";
+import { type OpencodeClient } from "./sdk.js";
+export type V1HostOptions = {
+    client: OpencodeClient;
+    directory: string;
+    toolsFor?: (agent: string) => Record<string, boolean> | undefined;
+};
+export declare function forkAnswerText(response: unknown): string;
+export declare function createV1Host({ client, directory, toolsFor }: V1HostOptions): MemoryHost;

package/dist/host/v1/host.js

@@ -0,0 +1,79 @@
+// MemoryHost over the V1 SDK client (`server` plugin entry). Every call keeps the exact SDK traffic
+// the coordinators used to make directly: deadlines, `directory` query and the tool sandbox.
+import { withDeadline } from "../../util/timeout.js";
+import { SDK_READ_TIMEOUT_MS } from "../types.js";
+import { runForkSession } from "./fork.js";
+import { unwrapData } from "./sdk.js";
+// Structured output when the server produced it, otherwise the text parts of the answer.
+export function forkAnswerText(response) {
+    const data = unwrapData(response);
+    if (!data || typeof data !== "object")
+        return "";
+    const structured = data.info?.structured;
+    if (structured && typeof structured === "object")
+        return JSON.stringify(structured);
+    if (!Array.isArray(data.parts))
+        return "";
+    // Answer text only: reasoning parts carry text too, and their prose (or a JSON-looking line in it)
+    // must not be parsed as the selection.
+    return data.parts
+        .filter((part) => {
+        const type = part && typeof part === "object" ? part.type : undefined;
+        return type === undefined || type === "text";
+    })
+        .map((part) => (part && typeof part === "object" ? part.text : undefined))
+        .filter((text) => typeof text === "string")
+        .join("\n");
+}
+export function createV1Host({ client, directory, toolsFor }) {
+    return {
+        async readTranscript(sessionID) {
+            const response = await withDeadline("session.messages", SDK_READ_TIMEOUT_MS, (signal) => client.session.messages({ path: { id: sessionID }, query: { directory }, signal }));
+            const messages = unwrapData(response) ?? [];
+            // V1 returns the full session history, so the watermark message is never cut off.
+            return { messages, truncated: false };
+        },
+        async listSessions() {
+            const sessions = unwrapData(await withDeadline("session.list", SDK_READ_TIMEOUT_MS, (signal) => client.session.list({ query: { directory }, signal }))) ?? [];
+            return sessions.map((session) => ({
+                id: session.id,
+                parentID: session.parentID,
+                updatedAt: session.time?.updated,
+            }));
+        },
+        async runFork(input) {
+            await runForkSession({
+                client,
+                directory,
+                parentSessionID: input.parentSessionID,
+                title: input.title,
+                agent: input.agent,
+                system: input.system,
+                tools: toolsFor?.(input.agent),
+                parts: [{ type: "text", text: input.text }],
+                timeoutMs: input.timeoutMs,
+                onCreated: input.onCreated,
+                onFinished: input.onFinished,
+                onCleanupFailed: input.onCleanupFailed,
+            });
+        },
+        async generate(input) {
+            const response = await runForkSession({
+                client,
+                directory,
+                parentSessionID: input.parentSessionID,
+                title: input.title,
+                agent: input.agent,
+                system: input.system,
+                tools: toolsFor?.(input.agent) ?? { "*": false },
+                ...(input.schema ? { format: { type: "json_schema", schema: input.schema } } : {}),
+                parts: [{ type: "text", text: input.text }],
+                timeoutMs: input.timeoutMs,
+                onCreated: input.onCreated,
+                onFinished: input.onFinished,
+                onCleanupFailed: input.onCleanupFailed,
+            });
+            return forkAnswerText(response);
+        },
+    };
+}

package/dist/{hooks → host/v1}/ignore.d.ts

@@ -1,6 +1,5 @@
-import type { ChatMessage, MessagePart } from "../sdk.js";
-export declare function detectIgnoreMemory(query: string | undefined): boolean;
-export declare function detectResumeMemory(query: string | undefined): boolean;
+import type { ChatMessage, MessagePart } from "./sdk.js";
+export { detectIgnoreMemory, detectResumeMemory } from "../../recall/turn.js";
 export declare function deriveIgnoredFromHistory(messages: readonly ChatMessage[]): boolean;
 export declare function isAutoMemoryPart(part: MessagePart): boolean;
 export declare function stripAutoMemoryParts(messages: readonly ChatMessage[]): ChatMessage[];

package/dist/host/v1/ignore.js

@@ -0,0 +1,29 @@
+// "Ignore memory" handling over the V1 message shape; the phrase rules live in recall/turn.ts.
+import { AUTO_MEMORY_MARKER } from "../../prompt/systemPrompt.js";
+import { deriveIgnoredFromQueries } from "../../recall/turn.js";
+import { extractUserQuery, roleOf } from "./messages.js";
+export { detectIgnoreMemory, detectResumeMemory } from "../../recall/turn.js";
+// Replays every user message in order and returns whether memory is ignored at the end. Used to
+// rebuild session state that the coordinator no longer holds (process restart, cache eviction), so
+// an "ignore memory" said earlier in the session keeps applying without the user repeating it.
+export function deriveIgnoredFromHistory(messages) {
+    return deriveIgnoredFromQueries(messages.filter((message) => roleOf(message) === "user").map((message) => extractUserQuery(message)));
+}
+export function isAutoMemoryPart(part) {
+    if (!part || typeof part !== "object")
+        return false;
+    const text = part.text;
+    return typeof text === "string" && text.trimStart().startsWith(AUTO_MEMORY_MARKER);
+}
+// Drops the plugin's own system segment from system-role messages; messages left without parts
+// are removed entirely.
+export function stripAutoMemoryParts(messages) {
+    return messages
+        .map((message) => {
+        if (roleOf(message) !== "system" || !Array.isArray(message.parts))
+            return message;
+        const parts = message.parts.filter((part) => !isAutoMemoryPart(part));
+        return parts.length === message.parts.length ? message : { ...message, parts };
+    })
+        .filter((message) => !Array.isArray(message.parts) || message.parts.length > 0);
+}

package/dist/host/v1/log.d.ts

@@ -0,0 +1,4 @@
+import { LOG_SERVICE, type Logger } from "../../util/log.js";
+import type { OpencodeClient } from "./sdk.js";
+export { LOG_SERVICE };
+export declare function createLogger(client: OpencodeClient | undefined, directory: string): Logger;

package/dist/host/v1/log.js

@@ -0,0 +1,20 @@
+import { LOG_SERVICE } from "../../util/log.js";
+export { LOG_SERVICE };
+// Logging goes through the OpenCode service log only. stderr is rendered into the chat UI, so a
+// failing background task must never write there. Every call is best-effort and never throws.
+export function createLogger(client, directory) {
+    return (level, message, extra) => {
+        const log = client?.app?.log;
+        if (typeof log !== "function")
+            return;
+        try {
+            void Promise.resolve(log.call(client?.app, {
+                body: { service: LOG_SERVICE, level, message, extra },
+                query: { directory },
+            })).catch(() => { });
+        }
+        catch {
+            // best-effort
+        }
+    };
+}

package/dist/{hooks → host/v1}/messages.d.ts

@@ -1,4 +1,6 @@
-import type { ChatMessage } from "../sdk.js";
+import { extractSurfacedMemoryKeys } from "../../recall/turn.js";
+import type { ChatMessage } from "./sdk.js";
+export { extractSurfacedMemoryKeys };
 export type TurnInfo = {
     sessionID?: string;
     query?: string;
@@ -9,6 +11,5 @@ export declare function roleOf(message: ChatMessage): string;
 export declare function extractUserQuery(message: ChatMessage): string | undefined;
 export declare function getLastUserQuery(messages: readonly ChatMessage[]): TurnInfo;
 export declare function buildTurnID(sessionID: string, turn: TurnInfo): string;
-export declare function extractSurfacedMemoryKeys(systemText: string): Set<string>;
 export declare function collectSurfacedMemoryKeys(messages: readonly ChatMessage[]): Set<string>;
 export declare function extractRecentTools(messages: readonly ChatMessage[]): string[];

package/dist/{hooks → host/v1}/messages.js

@@ -1,5 +1,6 @@
-// Pure helpers over the SDK message shape passed to `experimental.chat.messages.transform`.
-import { RECALLED_MEMORIES_HEADING } from "../prompt/systemPrompt.js";
+// Pure helpers over the V1 SDK message shape passed to `experimental.chat.messages.transform`.
+import { extractSurfacedMemoryKeys } from "../../recall/turn.js";
+export { extractSurfacedMemoryKeys };
 // Older runtimes and tests may hand over messages whose `info` lacks the full SDK shape; only the
 // fields actually used are read, defensively.
 export function roleOf(message) {
@@ -41,21 +42,6 @@ export function getLastUserQuery(messages) {
 export function buildTurnID(sessionID, turn) {
     return `${sessionID}:${turn.messageID ?? `${turn.messageIndex ?? -1}:${turn.query ?? ""}`}`;
 }
-// Parses "### <name> (<type>)" headers from the ## Recalled Memories section
-// of system prompts. After compaction old system messages disappear, so
-// the returned set naturally shrinks — no manual reset needed.
-export function extractSurfacedMemoryKeys(systemText) {
-    const keys = new Set();
-    const recalledSection = systemText.indexOf(RECALLED_MEMORIES_HEADING);
-    if (recalledSection === -1)
-        return keys;
-    const headerPattern = /^### (.+?) \((\w+)\)/gm;
-    const section = systemText.slice(recalledSection);
-    for (let match = headerPattern.exec(section); match !== null; match = headerPattern.exec(section)) {
-        keys.add(`${match[1]}|${match[2]}`);
-    }
-    return keys;
-}
 export function collectSurfacedMemoryKeys(messages) {
     const keys = new Set();
     for (const message of messages) {

package/dist/host/v1/plugin.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const createMemoryPlugin: (env?: NodeJS.ProcessEnv, homeDir?: string) => Plugin;

package/dist/host/v1/plugin.js

@@ -0,0 +1,58 @@
+import { parseConfig } from "../../config.js";
+import { buildMemorySystemPrompt } from "../../prompt/systemPrompt.js";
+import { formatRecalledMemories } from "../../recall/format.js";
+import { MemoryStore } from "../../store/MemoryStore.js";
+import { resolveMemoryRoot } from "../../store/paths.js";
+import { OwnedSessions } from "../../util/ownedSessions.js";
+import { AgentRegistry } from "./agents.js";
+import { V1ExtractionCoordinator, V1RecallCoordinator } from "./coordinators.js";
+import { createV1Host } from "./host.js";
+import { createLogger } from "./log.js";
+import { buildMemoryTools } from "./tools.js";
+// 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 host = client
+        ? createV1Host({ client, directory: dir, toolsFor: (name) => agents.toolsFor(name) })
+        : undefined;
+    const deps = { store, config, host, owned, log };
+    const recall = new V1RecallCoordinator(deps);
+    const extraction = new V1ExtractionCoordinator(deps);
+    log("info", "opencode-claude-memory loaded", { directory: dir, memoryDir: store.memoryDir });
+    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();
+        },
+    };
+};

package/dist/host/v1/selector.d.ts

@@ -0,0 +1,18 @@
+import type { MemoryHeader } from "../../store/scan.js";
+import type { OpencodeClient } from "./sdk.js";
+export type SelectRelevantMemoryFilenamesInput = {
+    client: OpencodeClient;
+    directory: string;
+    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 selectRelevantMemoryFilenames(input: SelectRelevantMemoryFilenamesInput): Promise<string[]>;

package/dist/host/v1/selector.js

@@ -0,0 +1,12 @@
+// V1 entry points of the recall selector: a hidden child session with structured output, driven
+// through the V1 host. The selection logic itself lives in recall/selector.ts.
+import { parseSelectedMemories, selectRelevantMemories } from "../../recall/selector.js";
+import { createV1Host, forkAnswerText } from "./host.js";
+export function extractSelectedMemories(response) {
+    return parseSelectedMemories(forkAnswerText(response));
+}
+// Never throws: a failed or timed-out selector simply recalls nothing for this turn.
+export function selectRelevantMemoryFilenames(input) {
+    const { client, directory, tools, ...rest } = input;
+    return selectRelevantMemories({ ...rest, host: createV1Host({ client, directory, toolsFor: () => tools }) });
+}

package/dist/host/v1/tools.d.ts

@@ -0,0 +1,5 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { ExtractionCoordinator } from "../../extraction/ExtractionCoordinator.js";
+import type { MemoryStore } from "../../store/MemoryStore.js";
+export type MemoryTools = NonNullable<Hooks["tool"]>;
+export declare function buildMemoryTools(store: MemoryStore, extraction: Pick<ExtractionCoordinator, "recordSave">): MemoryTools;

package/dist/host/v1/tools.js

@@ -0,0 +1,17 @@
+import { buildMemoryToolSpecs } from "../../tools.js";
+export function buildMemoryTools(store, extraction) {
+    const tools = {};
+    for (const spec of buildMemoryToolSpecs(store, extraction)) {
+        tools[spec.name] = {
+            description: spec.description,
+            args: spec.args,
+            async execute(args, ctx) {
+                const result = await spec.execute(args, { sessionID: ctx?.sessionID });
+                return result.title === undefined ? { output: result.output } : { title: result.title, output: result.output };
+            },
+        };
+    }
+    // The Zod v4 shapes come from the plugin's own `zod` dependency, not the SDK's copy; V1 accepts
+    // any object carrying `_zod`, but the two copies' types do not unify.
+    return tools;
+}

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

@@ -0,0 +1,8 @@
+import type { AgentEditor } from "@opencode/plugin/promise/agent";
+import type { MemoryAgents } from "../../config.js";
+import type { PermissionRule } from "./fork.js";
+export type { PermissionRule };
+export declare const BASELINE_PROBE_AGENT = "opencode-memory-baseline-probe";
+export declare function sandboxRules(allowedTools: readonly string[]): PermissionRule[];
+export declare function userRules(rules: readonly PermissionRule[], baseline: readonly PermissionRule[]): PermissionRule[];
+export declare function applyMemoryAgents(editor: AgentEditor, agents: MemoryAgents): void;

package/dist/host/v2/agents.js

@@ -0,0 +1,41 @@
+import { memoryAgentDefaults } from "../../agents.js";
+// A throwaway id used to read the host's default ruleset inside the same draft.
+export const BASELINE_PROBE_AGENT = "opencode-memory-baseline-probe";
+export function sandboxRules(allowedTools) {
+    return [
+        { action: "*", resource: "*", effect: "deny" },
+        ...allowedTools.map((tool) => ({ action: tool, resource: "*", effect: "allow" })),
+    ];
+}
+function ruleKey(rule) {
+    return `${rule.action}\u0000${rule.resource}\u0000${rule.effect}`;
+}
+// The user's own rules: the agent's ruleset minus the host defaults every agent starts with.
+export function userRules(rules, baseline) {
+    const prefix = baseline.every((rule, index) => rules[index] && ruleKey(rules[index]) === ruleKey(rule));
+    if (prefix)
+        return rules.slice(baseline.length).map((rule) => ({ ...rule }));
+    const base = new Set(baseline.map(ruleKey));
+    return rules.filter((rule) => !base.has(ruleKey(rule))).map((rule) => ({ ...rule }));
+}
+export function applyMemoryAgents(editor, agents) {
+    editor.update(BASELINE_PROBE_AGENT, () => { });
+    const baseline = (editor.get(BASELINE_PROBE_AGENT)?.permissions ?? []).map((rule) => ({ ...rule }));
+    editor.remove(BASELINE_PROBE_AGENT);
+    for (const [name, defaults] of Object.entries(memoryAgentDefaults(agents))) {
+        applyAgent(editor, name, defaults, baseline);
+    }
+}
+function applyAgent(editor, name, defaults, baseline) {
+    const prior = editor.get(name);
+    const configured = prior ? userRules(prior.permissions, baseline) : [];
+    editor.update(name, (agent) => {
+        agent.mode = "subagent";
+        agent.hidden = true;
+        // Fill only what the user did not set (an agent configured before this transform keeps its own).
+        agent.system ??= defaults.prompt;
+        if (agent.steps === undefined && defaults.steps !== undefined)
+            agent.steps = defaults.steps;
+        agent.permissions = [...sandboxRules(defaults.allowedTools), ...configured];
+    });
+}

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

@@ -0,0 +1,40 @@
+import type { ExtractionCoordinator } from "../../extraction/ExtractionCoordinator.js";
+import type { RecalledMemory } from "../../recall/format.js";
+import { type RecallCoordinator } from "../../recall/RecallCoordinator.js";
+import type { OwnedSessions } from "../../util/ownedSessions.js";
+export type V2Event = {
+    type?: string;
+    location?: {
+        directory?: string;
+    } | null;
+    data?: Record<string, unknown>;
+};
+export type V2EventDeps = {
+    directory: string;
+    owned: OwnedSessions;
+    recall: Pick<RecallCoordinator, "forget">;
+    extraction: Pick<ExtractionCoordinator, "onSessionIdle" | "onSessionStatus" | "onSessionDeleted">;
+    now?: () => number;
+};
+export declare class V2SessionEvents {
+    private readonly deps;
+    private readonly sessions;
+    private readonly recalled;
+    private readonly now;
+    constructor(deps: V2EventDeps);
+    track(sessionID: string): void;
+    isTracked(sessionID: string): boolean;
+    surfacedKeys(sessionID: string): ReadonlySet<string>;
+    remember(sessionID: string, memories: readonly RecalledMemory[]): RecalledMemory[];
+    private evictStale;
+    handle(event: V2Event): void;
+    private forget;
+}
+export declare const RESUBSCRIBE_MIN_MS = 1000;
+export declare const RESUBSCRIBE_MAX_MS = 30000;
+export declare function consumeEvents(subscribe: (options: {
+    signal: AbortSignal;
+}) => AsyncIterable<unknown>, signal: AbortSignal, onEvent: (event: V2Event) => void, onError: (error: unknown) => void, backoff?: {
+    minMs: number;
+    maxMs: number;
+}): Promise<void>;