opencode-codex-memory 0.7.2 → 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.2"]
+  "plugin": ["opencode-codex-memory@0.7.4"]
 }
 ```
 
@@ -72,7 +72,7 @@ V2 plugin syntax:
 
 ```jsonc
 {
-  "plugins": [{ "package": "opencode-codex-memory@0.7.2" }],
+  "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.2", { "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.2",
+      "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.2", { "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.2",
+      "opencode-codex-memory@0.7.4",
       {
         "claude_import": {
           "enabled": true,

package/dist/src/git-baseline.js

@@ -29,7 +29,7 @@ async function ensureInit(dir) {
     const gitDir = path.join(dir, ".git");
     let recreate = false;
     try {
-        recreate = containsSymlink(gitDir) || !fs.lstatSync(gitDir).isDirectory();
+        recreate = gitMetadataUnusable(gitDir);
     }
     catch (err) {
         if (err.code !== "ENOENT")
@@ -41,17 +41,14 @@ async function ensureInit(dir) {
         await isogit.init({ fs, dir });
     }
 }
-function containsSymlink(root) {
-    const st = fs.lstatSync(root);
-    if (st.isSymbolicLink())
-        return true;
-    if (!st.isDirectory())
-        return false;
-    for (const name of fs.readdirSync(root)) {
-        if (containsSymlink(path.join(root, name)))
-            return true;
-    }
-    return false;
+/**
+ * Only the `.git` entry itself. A recursive walk of git objects hangs on
+ * Windows junctions / symlink cycles and is not needed: we only refuse a
+ * `.git` that is a symlink or a non-directory.
+ */
+function gitMetadataUnusable(gitDir) {
+    const st = fs.lstatSync(gitDir);
+    return st.isSymbolicLink() || !st.isDirectory();
 }
 // statusMatrix rows are [filepath, head, workdir, stage]; head !== workdir
 // means the working tree differs from HEAD (added, modified, or deleted).

package/dist/src/phase2.js

@@ -2,7 +2,7 @@ import { checkRateLimit, isProviderCapacityError, noteProviderCapacityExhausted
 import { ensureLayout, rebuildRawMemories, writeRolloutSummaries, pruneExtensionResources, writeWorkspaceDiff, validateConsolidationArtifacts, removeMemorySymlinks, } from "./workspace.js";
 import { ensureBaseline, captureWorkspaceDiff, resetBaseline, DIFF_ARTIFACT } from "./git-baseline.js";
 import { consolidateViaSubagent, getPluginInput, SubagentCancelledError, SubagentShutdownError, } from "./llm.js";
-import { hostSessionLiveness } from "./host-client.js";
+import { hostSessionLiveness, withHostTimeout } from "./host-client.js";
 import { invalidateCache } from "./source.js";
 import { memoryRoot } from "./paths.js";
 import { abortPhase2Consolidation, beginPhase2AbortScope, endPhase2AbortScope, isPluginShuttingDown, } from "./lifecycle.js";
@@ -16,6 +16,7 @@ export const DEFAULT_PHASE2_OPTIONS = {
 // Export runs only after a successful phase 2 (fresh, validated artifacts) and
 // must never fail the run — Codex's workspace is best-effort foreign territory.
 const PHASE2_LIVE_CHECK_CONCURRENCY = 8;
+const GIT_TIMEOUT_MS = 120_000;
 /**
  * Codex get_phase2_input_selection re-validates each row against the live
  * threads table. We only drop a row on a confirmed 404 (same as session.deleted);
@@ -132,7 +133,7 @@ export async function runPhase2(store, opts = DEFAULT_PHASE2_OPTIONS) {
             // ad-hoc notes added since then reach consolidation. Stale stage-1
             // output pruning happens in phase 1, before the rate gate (codex
             // start.rs ordering).
-            if (!await ensureBaseline()) {
+            if (!await withHostTimeout(ensureBaseline(), GIT_TIMEOUT_MS, "ensureBaseline")) {
                 store.markPhase2Failed(claim.ownershipToken, "git baseline failed");
                 return { status: "baseline_failed" };
             }
@@ -171,7 +172,7 @@ export async function runPhase2(store, opts = DEFAULT_PHASE2_OPTIONS) {
                     console.warn("[opencode-codex-memory] claude import sync failed:", err);
                 }
             }
-            const diff = await captureWorkspaceDiff();
+            const diff = await withHostTimeout(captureWorkspaceDiff(), GIT_TIMEOUT_MS, "captureWorkspaceDiff");
             if (releaseIfShuttingDown(store, claim.ownershipToken)) {
                 return { status: "shutting_down" };
             }
@@ -273,7 +274,7 @@ export async function runPhase2(store, opts = DEFAULT_PHASE2_OPTIONS) {
                 store.markPhase2Failed(claim.ownershipToken, `failed_invalid_artifacts: ${artifacts.reason}`);
                 return { status: "failed_invalid_artifacts" };
             }
-            if (!await resetBaseline()) {
+            if (!await withHostTimeout(resetBaseline(), GIT_TIMEOUT_MS, "resetBaseline")) {
                 store.markPhase2Failed(claim.ownershipToken, "baseline reset failed");
                 return { status: "baseline_reset_failed" };
             }

package/dist/src/store.d.ts

@@ -101,6 +101,7 @@ export declare class MemoryStore {
     phase2JobSnapshot(): {
         status: string;
         last_error: string | null;
+        started_at: number | null;
         finished_at: number | null;
         retry_at: number | null;
         lease_until: number | null;

package/dist/src/store.js

@@ -434,7 +434,7 @@ export class MemoryStore {
      */
     phase2JobSnapshot() {
         const row = this.db
-            .prepare(`SELECT status, finished_at, last_error, retry_at, lease_until, last_success_watermark FROM memory_jobs
+            .prepare(`SELECT status, started_at, finished_at, last_error, retry_at, lease_until, last_success_watermark FROM memory_jobs
          WHERE kind='memory_consolidate_global' AND job_key='global'`)
             .get();
         if (!row)
@@ -452,6 +452,7 @@ export class MemoryStore {
         return {
             status: row.status,
             last_error: row.last_error,
+            started_at: row.started_at,
             finished_at: row.finished_at,
             retry_at: row.retry_at,
             lease_until: row.lease_until,

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/dist/tools/control.js

@@ -192,6 +192,16 @@ export const memory_reset = tool({
 function fmtUnixSec(sec) {
     return sec ? new Date(sec * 1000).toISOString() : "none";
 }
+function fmtElapsedSec(startedAtSec) {
+    if (!startedAtSec)
+        return "unknown";
+    const sec = Math.max(0, Math.floor(Date.now() / 1000) - startedAtSec);
+    if (sec < 60)
+        return `${sec}s`;
+    if (sec < 3600)
+        return `${Math.floor(sec / 60)}m ${sec % 60}s`;
+    return `${Math.floor(sec / 3600)}h ${Math.floor((sec % 3600) / 60)}m`;
+}
 function fmtWatermarkMs(ms) {
     if (ms === 0)
         return "0 (no consumed inputs)";
@@ -229,6 +239,9 @@ export const memory_inspect = tool({
                 ? [
                     `phase2_status: ${phase2.status}`,
                     `phase2_last_error: ${phase2.last_error ?? "none"}`,
+                    `phase2_started_at: ${fmtUnixSec(phase2.started_at)}`,
+                    `phase2_running_for: ${phase2.status === "running" ? fmtElapsedSec(phase2.started_at) : "n/a"}`,
+                    `phase2_lease_until: ${fmtUnixSec(phase2.lease_until)}`,
                     `phase2_retry_at: ${fmtUnixSec(phase2.retry_at)}`,
                     `phase2_last_attempt_finished_at: ${fmtUnixSec(phase2.finished_at)}`,
                     `phase2_last_success_watermark: ${fmtWatermarkMs(phase2.last_success_watermark)}`,
@@ -238,6 +251,9 @@ export const memory_inspect = tool({
                 : [
                     "phase2_status: none",
                     "phase2_last_error: none",
+                    "phase2_started_at: none",
+                    "phase2_running_for: n/a",
+                    "phase2_lease_until: none",
                     "phase2_retry_at: none",
                     "phase2_last_attempt_finished_at: none",
                     "phase2_last_success_watermark: none",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-codex-memory",
-  "version": "0.7.2",
+  "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",