opencode-claude-memory 2.3.0 → 2.3.1

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

@@ -1,6 +1,7 @@
 import type { AgentEditor } from "@opencode/plugin/promise/agent";
-import type { MemoryAgents } from "../../config.js";
+import { type MemoryAgents } from "../../config.js";
 import type { PermissionRule } from "./fork.js";
+export declare function isMemoryAgent(agent: unknown, agents?: MemoryAgents): boolean;
 export type { PermissionRule };
 export declare const BASELINE_PROBE_AGENT = "opencode-memory-baseline-probe";
 export declare const PERMISSIONS_PROBE_AGENT = "opencode-memory-permissions-probe";

package/dist/host/v2/agents.js

@@ -1,4 +1,8 @@
 import { memoryAgentDefaults } from "../../agents.js";
+import { MEMORY_AGENTS } from "../../config.js";
+export function isMemoryAgent(agent, agents = MEMORY_AGENTS) {
+    return typeof agent === "string" && (agent === agents.extract || agent === agents.dream || agent === agents.recall);
+}
 // A throwaway id used to read the host's default ruleset inside the same draft.
 export const BASELINE_PROBE_AGENT = "opencode-memory-baseline-probe";
 // A hidden, deny-all agent that is kept: every rule after its own PROBE_RULES was appended to all

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

@@ -1,3 +1,4 @@
+import { type MemoryAgents } from "../../config.js";
 import type { ExtractionCoordinator } from "../../extraction/ExtractionCoordinator.js";
 import type { RecalledMemory } from "../../recall/format.js";
 import { type RecallCoordinator } from "../../recall/RecallCoordinator.js";
@@ -9,19 +10,26 @@ export type V2Event = {
     } | null;
     data?: Record<string, unknown>;
 };
+export declare const MAX_IGNORED_FORKS = 512;
 export type V2EventDeps = {
     directory: string;
     owned: OwnedSessions;
     recall: Pick<RecallCoordinator, "forget">;
     extraction: Pick<ExtractionCoordinator, "onSessionIdle" | "onSessionStatus" | "onSessionDeleted">;
+    agents?: MemoryAgents;
     now?: () => number;
 };
 export declare class V2SessionEvents {
     private readonly deps;
     private readonly sessions;
     private readonly recalled;
+    private readonly seenForks;
+    private readonly retainedForks;
     private readonly now;
     constructor(deps: V2EventDeps);
+    isIgnoredFork(sessionID: string): boolean;
+    ignoreFork(sessionID: string, persistent?: boolean): void;
+    untrack(sessionID: string): void;
     track(sessionID: string): void;
     isTracked(sessionID: string): boolean;
     surfacedKeys(sessionID: string): ReadonlySet<string>;

package/dist/host/v2/events.js

@@ -1,11 +1,33 @@
+// V2 events → coordinator calls.
+//
+// The event stream is global across server locations, and the session execution events carry no
+// location at all, so the adapter only acts on sessions it knows belong to its own location: those
+// created here (`session.created` with this location) or seen by the location-scoped prompt and
+// context hooks. Turn boundaries: `session.execution.started` = busy, `succeeded` / `failed` /
+// `interrupted` = idle. The deprecated `session.status` / `session.idle` events are honoured too.
+import { MEMORY_AGENTS } from "../../config.js";
 import { SESSION_STATE_TTL_MS } from "../../recall/RecallCoordinator.js";
 import { surfaceKey } from "../../store/scan.js";
+import { isMemoryAgent } from "./agents.js";
+import { isMemoryForkMetadata } from "./fork.js";
 const IDLE_EVENTS = [
     "session.execution.succeeded",
     "session.execution.failed",
     "session.execution.interrupted",
     "session.idle",
 ];
+export const MAX_IGNORED_FORKS = 512;
+function rememberBounded(set, id, maxSize = MAX_IGNORED_FORKS) {
+    if (set.has(id))
+        set.delete(id);
+    set.add(id);
+    while (set.size > maxSize) {
+        const oldest = set.values().next().value;
+        if (oldest === undefined)
+            break;
+        set.delete(oldest);
+    }
+}
 export class V2SessionEvents {
     deps;
     // Tracked sessions → last time a hook or event saw them. Entries idle for longer than
@@ -16,13 +38,32 @@ export class V2SessionEvents {
     // model request and does not keep it in the history, so the recalled section is re-injected on
     // every request (not only the first one of a turn) and its keys are what the selector skips.
     recalled = new Map();
+    // Bounded sets of plugin forks that carry no `parentID` on V2: `seenForks` captures forks
+    // announced on `session.created` (including when it races ahead of `session.create()`), while
+    // `retainedForks` keeps forks whose cleanup delete failed or that a context hook observed under
+    // a memory agent so successful forks cannot evict them after the 60 s `owned` grace expires.
+    seenForks = new Set();
+    retainedForks = new Set();
     now;
     constructor(deps) {
         this.deps = deps;
         this.now = deps.now ?? Date.now;
     }
+    isIgnoredFork(sessionID) {
+        return this.seenForks.has(sessionID) || this.retainedForks.has(sessionID);
+    }
+    // Marks a session as a plugin-owned fork and clears any accidental user-session state.
+    ignoreFork(sessionID, persistent = false) {
+        rememberBounded(persistent ? this.retainedForks : this.seenForks, sessionID);
+        this.forget(sessionID);
+    }
+    // Drops any user-session tracking recorded before `session.create()` resolved (e.g., from an
+    // unannotated `session.created` race), without permanently retaining normal deleted forks.
+    untrack(sessionID) {
+        this.forget(sessionID);
+    }
     track(sessionID) {
-        if (this.deps.owned.has(sessionID))
+        if (this.deps.owned.has(sessionID) || this.isIgnoredFork(sessionID))
             return;
         const now = this.now();
         this.evictStale(now);
@@ -65,16 +106,22 @@ export class V2SessionEvents {
             return;
         if (type === "session.deleted") {
             this.deps.owned.release(sessionID, 5_000);
+            this.seenForks.delete(sessionID);
+            this.retainedForks.delete(sessionID);
             this.forget(sessionID);
             return;
         }
         if (type === "session.created") {
+            if (isMemoryForkMetadata(data.metadata) || isMemoryAgent(data.agent, this.deps.agents ?? MEMORY_AGENTS)) {
+                this.ignoreFork(sessionID);
+                return;
+            }
             const directory = data.location?.directory ?? event.location?.directory;
             if (directory === this.deps.directory && !data.parentID)
                 this.track(sessionID);
             return;
         }
-        if (this.deps.owned.has(sessionID) || !this.sessions.has(sessionID))
+        if (this.deps.owned.has(sessionID) || this.isIgnoredFork(sessionID) || !this.sessions.has(sessionID))
             return;
         this.sessions.set(sessionID, this.now());
         if (type === "session.execution.started") {

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

@@ -3,6 +3,8 @@ export declare const FORK_CREATE_TIMEOUT_MS = 30000;
 export declare const FORK_CLEANUP_TIMEOUT_MS = 15000;
 export declare const FORK_READ_TIMEOUT_MS = 30000;
 export declare const FORK_SETTLE_POLL_MS = 250;
+export declare const FORK_METADATA_KEY = "opencodeClaudeMemoryFork";
+export declare function isMemoryForkMetadata(metadata: unknown): boolean;
 export type PermissionRule = {
     action: string;
     resource: string;
@@ -31,6 +33,7 @@ export type V2SessionApi = {
         title?: string;
         agent?: string;
         model?: ModelRef;
+        metadata?: Record<string, unknown>;
         permissions?: PermissionRule[];
     }): Promise<{
         id: string;

package/dist/host/v2/fork.js

@@ -11,6 +11,14 @@ export const FORK_CLEANUP_TIMEOUT_MS = 15_000;
 export const FORK_READ_TIMEOUT_MS = 30_000;
 // `wait` can return before an enqueued prompt was admitted; re-check this often until the deadline.
 export const FORK_SETTLE_POLL_MS = 250;
+// Durable session annotation so V2 forks stay identifiable without `parentID` (setting `parentID`
+// causes OpenCode 2.x to post a `<subagent>` report into the parent chat and wake its model).
+export const FORK_METADATA_KEY = "opencodeClaudeMemoryFork";
+export function isMemoryForkMetadata(metadata) {
+    return (typeof metadata === "object" &&
+        metadata !== null &&
+        metadata[FORK_METADATA_KEY] === true);
+}
 export class ForkSessionTimeoutError extends Error {
     constructor(title, timeoutMs) {
         super(`${title} timed out after ${timeoutMs}ms`);
@@ -66,10 +74,10 @@ export async function runV2Fork(session, input) {
     const cleanupTimeoutMs = input.cleanupTimeoutMs ?? FORK_CLEANUP_TIMEOUT_MS;
     const pollMs = input.pollMs ?? FORK_SETTLE_POLL_MS;
     const created = await deadline(`${input.title} session.create`, createTimeoutMs, () => session.create({
-        ...(input.parentSessionID ? { parentID: input.parentSessionID } : {}),
         title: input.title,
         agent: input.agent,
         ...(input.model ? { model: input.model } : {}),
+        metadata: { [FORK_METADATA_KEY]: true },
         permissions: input.permissions,
     }));
     const forkID = created?.id;

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

@@ -1,5 +1,5 @@
 import type { Logger } from "../../util/log.js";
-import { type GenerateInput, type MemoryHost } from "../types.js";
+import { type ForkCleanupStage, type GenerateInput, type MemoryHost } from "../types.js";
 import { type ModelRef, type PermissionRule, type V2SessionApi } from "./fork.js";
 export type V2AgentInfo = {
     model?: ModelRef;
@@ -15,6 +15,8 @@ export type V2HostOptions = {
     }>;
     getAgent: (name: string) => Promise<V2AgentInfo | undefined>;
     sandboxFor: (name: string) => PermissionRule[];
+    onForkCreated?: (sessionID: string) => void;
+    onForkCleanupFailed?: (sessionID: string, stage: ForkCleanupStage) => void;
     log?: Logger;
 };
 export declare class V2Host implements MemoryHost {

package/dist/host/v2/host.js

@@ -69,12 +69,17 @@ export class V2Host {
             onCreated: (id) => {
                 if (input.system)
                     this.forkSystems.set(id, input.system);
+                this.options.onForkCreated?.(id);
                 input.onCreated?.(id);
             },
             onFinished: (id) => {
                 this.forkSystems.delete(id);
                 input.onFinished?.(id);
             },
+            onCleanupFailed: (id, stage, error) => {
+                this.options.onForkCleanupFailed?.(id, stage);
+                input.onCleanupFailed?.(id, stage, error);
+            },
         });
     }
 }

package/dist/host/v2/plugin.js

@@ -11,7 +11,7 @@ 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 { applyMemoryAgents, isMemoryAgent, sandboxRules } from "./agents.js";
 import { consumeEvents, V2SessionEvents } from "./events.js";
 import { V2Host } from "./host.js";
 import { createFileLogger } from "./log.js";
@@ -45,6 +45,7 @@ export const createV2Setup = (env, homeDir) => async (ctx) => {
     const log = config.readOnly ? () => { } : createFileLogger(store.stateDir);
     const owned = new OwnedSessions();
     const defaults = memoryAgentDefaults(config.agents, config.readOnly);
+    let events;
     const host = new V2Host({
         session: ctx.session,
         generateText: (input) => ctx.generate.text(input),
@@ -53,12 +54,17 @@ export const createV2Setup = (env, homeDir) => async (ctx) => {
             return agent?.data;
         },
         sandboxFor: (name) => sandboxRules(defaults[name]?.allowedTools ?? []),
+        onForkCreated: (id) => events?.untrack(id),
+        onForkCleanupFailed: (id, stage) => {
+            if (stage === "delete")
+                events?.ignoreFork(id, true);
+        },
         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 });
+    events = new V2SessionEvents({ directory, owned, recall, extraction, agents: config.agents });
     const registrations = [];
     const register = async (what, call) => {
         registrations.push(await bounded(what, SETUP_CALL_TIMEOUT_MS, call));
@@ -83,7 +89,7 @@ export const createV2Setup = (env, homeDir) => async (ctx) => {
         // 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)
+            if (owned.has(sessionID) || events.isIgnoredFork(sessionID) || host.systemFor(sessionID) !== undefined)
                 return;
             events.track(sessionID);
             const text = event.prompt?.text;
@@ -105,8 +111,12 @@ export const createV2Setup = (env, homeDir) => async (ctx) => {
                 event.system.push({ type: "text", text: forkSystem });
                 return;
             }
-            if (owned.has(sessionID))
+            if (owned.has(sessionID) || events.isIgnoredFork(sessionID))
+                return;
+            if (isMemoryAgent(event.agent, config.agents)) {
+                events.ignoreFork(sessionID, true);
                 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-claude-memory",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "type": "module",
   "description": "OpenCode plugin for Claude Code memory: persistent, local-first shared memory with Claude Code-compatible Markdown files, LLM recall, in-process auto extraction, and auto-dream consolidation",
   "main": "dist/index.js",