opencode-codex-memory 0.7.3 → 0.7.4

package/README.md

@@ -52,7 +52,7 @@ If you want the mental model — learning, remembering, forgetting — see
 
 ```json
 {
-  "plugin": ["opencode-codex-memory@0.7.3"]
+  "plugin": ["opencode-codex-memory@0.7.4"]
 }
 ```
 
@@ -72,7 +72,7 @@ V2 plugin syntax:
 
 ```jsonc
 {
-  "plugins": [{ "package": "opencode-codex-memory@0.7.3" }],
+  "plugins": [{ "package": "opencode-codex-memory@0.7.4" }],
 }
 ```
 
@@ -198,7 +198,7 @@ To set options, turn the plugin entry into a `[name, options]` pair:
 ```json
 {
   "plugin": [
-    ["opencode-codex-memory@0.7.3", { "disable_on_external_context": true, "min_rollout_idle_hours": 2 }]
+    ["opencode-codex-memory@0.7.4", { "disable_on_external_context": true, "min_rollout_idle_hours": 2 }]
   ]
 }
 ```
@@ -265,7 +265,7 @@ Off by default; no changes to Codex's own config are required.
 {
   "plugin": [
     [
-      "opencode-codex-memory@0.7.3",
+      "opencode-codex-memory@0.7.4",
       { "codex_interop": { "import": true, "export": true } }
     ]
   ]
@@ -322,7 +322,7 @@ from the project memories Claude already keeps on your machine. **One-way only**
 ```json
 {
   "plugin": [
-    ["opencode-codex-memory@0.7.3", { "claude_import": { "enabled": true } }]
+    ["opencode-codex-memory@0.7.4", { "claude_import": { "enabled": true } }]
   ]
 }
 ```
@@ -349,7 +349,7 @@ Claude names each project with an opaque id (a folder under
 {
   "plugin": [
     [
-      "opencode-codex-memory@0.7.3",
+      "opencode-codex-memory@0.7.4",
       {
         "claude_import": {
           "enabled": true,

package/dist/src/v2/plugin.js

@@ -30,7 +30,7 @@ import { hostMcpStatus } from "../host-client.js";
 import { recordDiagnostic } from "../diagnostics.js";
 import { resetAgentHealth } from "../agent-health.js";
 import { applyPluginOptions, handleSessionDeleted } from "../index.js";
-import { setV2Context, buildV1ClientShim, } from "./shim.js";
+import { setV2Context, buildV1ClientShim, rememberV2Session, } from "./shim.js";
 import { ensureV2Agents } from "./agents.js";
 import { buildV2Tools } from "./tools.js";
 import { MemoryStatusRpc } from "./status-rpc.js";
@@ -178,7 +178,8 @@ async function classifyExternalContextTool(toolName) {
     }
     return false;
 }
-function stampAndPump(sid) {
+function stampAndPump(sid, directory) {
+    rememberV2Session(sid, directory ?? null);
     try {
         getStore().stampMemoryModeIfAbsent(sid, pluginOptions.generate_memories ? "enabled" : "disabled");
     }
@@ -336,7 +337,7 @@ export async function setup(ctx) {
                 return;
             if (!markV2TurnSeen(sid))
                 return;
-            stampAndPump(sid);
+            stampAndPump(sid, ctx.location?.directory);
         }
         catch (err) {
             console.error("[opencode-codex-memory] v2 prompt hook error:", err);
@@ -436,6 +437,7 @@ export async function setup(ctx) {
                         if (e.type === "session.execution.succeeded" || e.type === "session.execution.ended") {
                             const sid = sessionIdFromV2Event(data);
                             if (sid && !isMemorySubSession(sid)) {
+                                rememberV2Session(sid, ctx.location?.directory);
                                 trackBackgroundTask(triggerPhase1(sid));
                             }
                         }

package/dist/src/v2/service.d.ts

@@ -64,10 +64,14 @@ export declare function serviceHeaders(endpoint: V2ServiceEndpoint): Record<stri
 export declare function parseReadyStatus(body: unknown): V2ServiceStatus | null;
 export declare function readRegisteredEndpoint(file?: string): Promise<V2ServiceEndpoint | undefined>;
 export declare function fetchServiceStatus(endpoint: V2ServiceEndpoint, headers: Record<string, string> | undefined, signal?: AbortSignal): Promise<V2ServiceStatus>;
+/** Local loopback only — IDE `serve --port 0` shares opencode.db with `--service`. */
+export declare function isLoopbackEndpointUrl(url: string): boolean;
 /**
  * Find a ready, registered OpenCode service without starting or replacing one.
- * A missing service is a normal unavailable result; a PID mismatch is a
- * safety failure because it would make global memory operate on another host.
+ * A missing service is a normal unavailable result. A PID mismatch on a
+ * non-loopback URL is a safety failure (would operate on another host).
+ * Loopback PID mismatch is the IDE isolated-serve case: same machine, shared
+ * session database, so global list/get/messages still go through that service.
  */
 export declare function discoverOwnService(dependencies?: V2ServiceDependencies, timeoutMs?: number): Promise<{
     endpoint: V2ServiceEndpoint;

package/dist/src/v2/service.js

@@ -154,10 +154,22 @@ async function probeEndpoint(deps, endpoint, client, signal) {
     }
     return fetchServiceStatus(endpoint, deps.service.headers(endpoint), signal);
 }
+/** Local loopback only — IDE `serve --port 0` shares opencode.db with `--service`. */
+export function isLoopbackEndpointUrl(url) {
+    try {
+        const hostname = new URL(url).hostname;
+        return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1";
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Find a ready, registered OpenCode service without starting or replacing one.
- * A missing service is a normal unavailable result; a PID mismatch is a
- * safety failure because it would make global memory operate on another host.
+ * A missing service is a normal unavailable result. A PID mismatch on a
+ * non-loopback URL is a safety failure (would operate on another host).
+ * Loopback PID mismatch is the IDE isolated-serve case: same machine, shared
+ * session database, so global list/get/messages still go through that service.
  */
 export async function discoverOwnService(dependencies, timeoutMs = SERVICE_REQUEST_TIMEOUT_MS) {
     const deps = dependencies ?? testDependencies ?? productionDependencies();
@@ -168,7 +180,10 @@ export async function discoverOwnService(dependencies, timeoutMs = SERVICE_REQUE
     const controller = new AbortController();
     const health = await withServiceTimeout(probeEndpoint(deps, endpoint, client, controller.signal), timeoutMs, controller);
     if (health.pid !== process.pid) {
-        throw new Error(`registered OpenCode service PID ${String(health.pid)} does not match plugin host PID ${process.pid}`);
+        if (!isLoopbackEndpointUrl(endpoint.url)) {
+            throw new Error(`registered OpenCode service PID ${String(health.pid)} does not match plugin host PID ${process.pid}`);
+        }
+        console.warn(`[opencode-codex-memory] registered OpenCode service PID ${String(health.pid)} is a different local process than plugin host PID ${process.pid}; using it for global session list`);
     }
     return { endpoint, client, health };
 }

package/dist/src/v2/shim.d.ts

@@ -5,8 +5,11 @@
  * run byte-identical) by presenting a V1-shaped client façade backed by the
  * V2 plugin context. Only genuinely missing V2 surfaces are adapted:
  *
- * - session list/discovery → the authenticated public service client
- *   discovered through the registered local service.
+ * - session list/discovery → ctx.session.list when the host exposes it,
+ *   else the authenticated public client for THIS process's registered
+ *   service. A PID mismatch (IDE `serve --port 0` vs `serve --service`)
+ *   does not list another host; it falls back to sessions this process
+ *   has observed.
  * - session.prompt agent/system/model/format/variant → V2 create-time
  *   agent/model (via switchAgent/switchModel) + generate.text for the
  *   json_schema extraction path (V2 prompts carry text only).
@@ -27,6 +30,13 @@ export declare function setV2Context(ctx: V2Context | null): void;
 export declare function isReleasedSubSession(id: string): boolean;
 /** Stable synthetic id for extraction helpers (see create below). */
 export declare const EXTRACT_STUB_SESSION_ID = "codex-memory-extract-stub";
+/**
+ * Isolated OpenCode 2 serves (IntelliJ/desktop `serve --port 0`) are not the
+ * registered `--service` process, so global session.list is unavailable.
+ * Remember sessions this process has actually seen so phase 1 can still
+ * extract them.
+ */
+export declare function rememberV2Session(id: string, directory?: string | null, title?: string): void;
 /** Test seam. */
 export declare function resetV2ShimStateForTest(): void;
 /**

package/dist/src/v2/shim.js

@@ -59,9 +59,58 @@ export function isReleasedSubSession(id) {
 }
 /** Stable synthetic id for extraction helpers (see create below). */
 export const EXTRACT_STUB_SESSION_ID = "codex-memory-extract-stub";
+const OBSERVED_CAP = 5000;
+const observedSessions = new Map();
+/**
+ * Isolated OpenCode 2 serves (IntelliJ/desktop `serve --port 0`) are not the
+ * registered `--service` process, so global session.list is unavailable.
+ * Remember sessions this process has actually seen so phase 1 can still
+ * extract them.
+ */
+export function rememberV2Session(id, directory, title) {
+    if (!id || id === EXTRACT_STUB_SESSION_ID)
+        return;
+    if (releasedSubSessions.has(id))
+        return;
+    observedSessions.delete(id);
+    observedSessions.set(id, {
+        updated_at: Date.now(),
+        directory: directory ?? null,
+        title: typeof title === "string" ? title : "",
+    });
+    while (observedSessions.size > OBSERVED_CAP) {
+        const oldest = observedSessions.keys().next().value;
+        if (oldest === undefined)
+            break;
+        observedSessions.delete(oldest);
+    }
+}
+function listObservedSessions(limit, cursor, search) {
+    const timestampCursor = typeof cursor === "number" ? cursor : undefined;
+    const needle = typeof search === "string" && search.length > 0 ? search.toLowerCase() : undefined;
+    const rows = [...observedSessions.entries()].sort((a, b) => b[1].updated_at - a[1].updated_at);
+    const out = [];
+    for (const [id, rec] of rows) {
+        if (timestampCursor !== undefined && rec.updated_at >= timestampCursor)
+            continue;
+        if (needle && !`${id}\n${rec.title}`.toLowerCase().includes(needle))
+            continue;
+        out.push({
+            id,
+            parentID: null,
+            ...(rec.title ? { title: rec.title } : {}),
+            directory: rec.directory,
+            time: { updated: rec.updated_at },
+        });
+        if (out.length >= limit)
+            break;
+    }
+    return out;
+}
 /** Test seam. */
 export function resetV2ShimStateForTest() {
     releasedSubSessions.clear();
+    observedSessions.clear();
     invalidateOwnService();
 }
 // ---------------------------------------------------------------------------
@@ -367,10 +416,13 @@ export function buildV1ClientShim() {
         if (typeof localList === "function") {
             return paginateSessionList((input) => localList(input), limit, cursor, search);
         }
-        const client = await serviceOrThrow();
-        if (typeof client.session.list !== "function")
+        const client = await ownServiceClient();
+        if (client && typeof client.session.list === "function") {
+            return paginateSessionList((input) => client.session.list(input), limit, cursor, search);
+        }
+        if (client)
             throw new Error("registered service does not support session.list");
-        return paginateSessionList((input) => client.session.list(input), limit, cursor, search);
+        return { data: listObservedSessions(limit, cursor, search) };
     }
     const session = {
         create: async (opts) => {
@@ -408,25 +460,30 @@ export function buildV1ClientShim() {
             try {
                 if (isReleasedSubSession(opts.path.id))
                     throw Object.assign(new Error("SessionNotFound"), { _tag: "SessionNotFoundError" });
-                const client = await serviceOrThrow();
-                if (typeof client.message?.list !== "function")
-                    throw new Error("registered service does not support message.list");
-                const messages = [];
-                const seenCursors = new Set();
-                let cursor;
-                while (true) {
-                    const response = await client.message.list(cursor ? { sessionID: opts.path.id, cursor } : { sessionID: opts.path.id, order: "asc" });
-                    const rows = responseRows(response);
-                    if (!rows)
-                        throw new Error("registered service returned an invalid message list");
-                    messages.push(...rows);
-                    const next = responseNextCursor(response);
-                    if (!next || seenCursors.has(next))
-                        break;
-                    seenCursors.add(next);
-                    cursor = next;
+                const client = await ownServiceClient();
+                if (typeof client?.message?.list === "function") {
+                    const messages = [];
+                    const seenCursors = new Set();
+                    let cursor;
+                    while (true) {
+                        const response = await client.message.list(cursor ? { sessionID: opts.path.id, cursor } : { sessionID: opts.path.id, order: "asc" });
+                        const rows = responseRows(response);
+                        if (!rows)
+                            throw new Error("registered service returned an invalid message list");
+                        messages.push(...rows);
+                        const next = responseNextCursor(response);
+                        if (!next || seenCursors.has(next))
+                            break;
+                        seenCursors.add(next);
+                        cursor = next;
+                    }
+                    return { data: adaptV2Messages(messages) };
                 }
-                return { data: adaptV2Messages(messages) };
+                const raw = await ctx().session.context({
+                    sessionID: opts.path.id,
+                });
+                const rows = Array.isArray(raw) ? raw : responseRows(raw) ?? [];
+                return { data: adaptV2Messages(rows) };
             }
             catch (e) {
                 return { error: e };
@@ -463,18 +520,23 @@ export function buildV1ClientShim() {
             }
             try {
                 const client = await ownServiceClient();
-                if (!client?.session?.get)
-                    return { error: shutdownError ?? new Error("session still exists after interrupt") };
-                const info = await client.session.get({ sessionID: opts.path.id });
-                if (info?.error && isNotFoundError(info.error)) {
-                    markReleased(opts.path.id);
-                    return {};
-                }
-                const data = und(info);
-                if (data && typeof data === "object") {
+                if (client?.session?.get) {
+                    const info = await client.session.get({ sessionID: opts.path.id });
+                    if (info?.error && isNotFoundError(info.error)) {
+                        markReleased(opts.path.id);
+                        return {};
+                    }
+                    const data = und(info);
+                    if (data && typeof data === "object") {
+                        return { error: shutdownError ?? new Error("session still exists after interrupt") };
+                    }
                     return { error: shutdownError ?? new Error("session still exists after interrupt") };
                 }
-                return { error: shutdownError ?? new Error("session still exists after interrupt") };
+                // Isolated serve: no session.remove on plugin ctx. interrupt+wait already
+                // finished, so the helper is idle. Holding the phase-2 lease until it
+                // expires would block consolidation for an hour.
+                markReleased(opts.path.id);
+                return {};
             }
             catch (e) {
                 if (isNotFoundError(e)) {
@@ -489,8 +551,19 @@ export function buildV1ClientShim() {
                 if (isReleasedSubSession(opts.path.id)) {
                     return { response: { status: 404 }, error: { _tag: "SessionNotFoundError" } };
                 }
-                const client = await serviceOrThrow();
-                const info = und(await client.session.get?.({ sessionID: opts.path.id }));
+                const client = await ownServiceClient();
+                if (client?.session?.get) {
+                    try {
+                        const info = und(await client.session.get({ sessionID: opts.path.id }));
+                        return { data: info };
+                    }
+                    catch (e) {
+                        if (isNotFoundError(e))
+                            return { response: { status: 404 }, error: e };
+                        return { error: e };
+                    }
+                }
+                const info = und(await ctx().session.get({ sessionID: opts.path.id }));
                 return { data: info };
             }
             catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-codex-memory",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "description": "Persistent memory plugin for opencode — ports codex's two-phase memory system (extraction → consolidation → injection → citation feedback)",
   "type": "module",
   "main": "./dist/src/index.js",