opencode-codex-memory 0.7.3 → 0.7.5

package/README.md

@@ -23,9 +23,10 @@ See the [changelog](./CHANGELOG.md) for release history.
 **Local-first by design.** Memory is plain markdown files plus a small SQLite
 database on your own machine — no memory service to sign up for, no MCP server,
 no separate process, no sync. Installing it is one line in your `opencode.json`;
-from there everything lives under `~/.local/share/opencode/`, so you can read it,
-grep it, edit it, or delete it like anything else you own. Nothing leaves your
-machine beyond the model calls OpenCode already makes.
+from there everything lives under `~/.local/share/opencode/` by default (or a
+directory you set with `home`), so you can read it, grep it, edit it, or delete
+it like anything else you own. Nothing leaves your machine beyond the model
+calls OpenCode already makes.
 
 If you *do* also use the Codex CLI or Claude Code on the same machine: the
 plugin can bring their memories in (and, for Codex, push ours back). Off by
@@ -52,7 +53,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.5"]
 }
 ```
 
@@ -72,7 +73,7 @@ V2 plugin syntax:
 
 ```jsonc
 {
-  "plugins": [{ "package": "opencode-codex-memory@0.7.3" }],
+  "plugins": [{ "package": "opencode-codex-memory@0.7.5" }],
 }
 ```
 
@@ -126,9 +127,15 @@ echo 'I prefer TypeScript strict mode and 2-space indentation.' \
     └── extensions/ad_hoc/notes/    # things you explicitly asked it to remember
 ```
 
-The location follows OpenCode's own data directory — `$XDG_DATA_HOME/opencode`
+By default this is OpenCode's own data directory — `$XDG_DATA_HOME/opencode`
 when that's set, otherwise `~/.local/share/opencode` (same resolution on macOS,
-Linux, and Windows).
+Linux, and Windows). Relocating OpenCode's local dir (for example by setting
+`XDG_DATA_HOME`) therefore moves memory with it. To pin **only** `memory.db`
+and `memories/` somewhere else — a sandbox mount, without the rest of
+OpenCode's database — set `home`. That pin is always enforced; OpenCode's data
+dir and `XDG_DATA_HOME` no longer apply. Precedence:
+[Relocating memory](#relocating-memory-sandbox-mounts). Do not symlink
+`memories/` — the plugin refuses a symlinked memory root.
 
 It's all plain files and a local SQLite database. Read them, edit them, delete
 them — it's yours. (The `memories/` folder also holds a few working files and
@@ -143,11 +150,13 @@ leave job state, Git baseline, and memory files out of sync. Include hidden
 files, especially `memories/.git/`, and SQLite sidecars such as `memory.db-wal`
 or `memory.db-shm` when present.
 
-The directory is `$XDG_DATA_HOME/opencode` when `XDG_DATA_HOME` is set,
-otherwise `~/.local/share/opencode`. Copy that whole directory to a dated
-backup location. To restore, stop OpenCode, replace the current `opencode/`
-data directory with the backup copy, then start OpenCode again. Do not restore
-while OpenCode is running or copy only `memory.db` or only `memories/`.
+The default directory is `$XDG_DATA_HOME/opencode` when `XDG_DATA_HOME` is set,
+otherwise `~/.local/share/opencode`. If you set `home` (or
+`OPENCODE_CODEX_MEMORY_HOME`), back up that directory instead — it is the pair
+`memory.db` + `memories/`. Copy it to a dated backup location. To restore, stop
+OpenCode, replace the current home with the backup copy, then start OpenCode
+again. Do not restore while OpenCode is running or copy only `memory.db` or
+only `memories/`.
 
 ## Privacy & safety
 
@@ -192,13 +201,14 @@ Codex's `[memories]` config so the two stay easy to compare:
 | `max_unused_days` | `30` | Prune memories unused for this long |
 | `codex_interop` | `{ "import": false, "export": false }` | Two-way memory exchange with a local Codex CLI (see below) |
 | `claude_import` | `{ "enabled": false }` | One-way import of Claude Code project memories (see below) |
+| `home` | unset (follows OpenCode data dir) | Pin `memory.db` + `memories/` here. When set, OpenCode's data dir and `XDG_DATA_HOME` are ignored. See [Relocating memory](#relocating-memory-sandbox-mounts) |
 
 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.5", { "disable_on_external_context": true, "min_rollout_idle_hours": 2 }]
   ]
 }
 ```
@@ -253,6 +263,56 @@ nearest OpenCode variant on `none < minimal < low < medium < high < xhigh < max`
 > maintenance tools (`memory_reset`, `memory_inspect`, `memory_mode`) stay
 > available either way.
 
+### Relocating memory (sandbox mounts)
+
+First match wins:
+
+1. **`home` plugin option** — pinned. Always enforced. OpenCode's data
+   directory and `XDG_DATA_HOME` do not apply.
+2. **`OPENCODE_CODEX_MEMORY_HOME`** — same pin, only if `home` is unset.
+3. **OpenCode data dir** (default) — `$XDG_DATA_HOME/opencode` when that env
+   is set, otherwise `~/.local/share/opencode`. Memory moves with OpenCode's
+   local directory.
+
+To mount **only** memory into a sandbox, use (1) or (2) and point at a
+dedicated directory:
+
+```json
+{
+  "plugin": [
+    ["opencode-codex-memory@0.7.5", { "home": "/path/to/opencode-memory" }]
+  ]
+}
+```
+
+OpenCode 2:
+
+```jsonc
+{
+  "plugins": [
+    { "package": "opencode-codex-memory@0.7.5", "options": { "home": "/path/to/opencode-memory" } }
+  ]
+}
+```
+
+`~` is expanded. The path must be absolute — a project-relative path would
+make memory follow the cwd, and memory is global. Same layout as the default,
+just elsewhere:
+
+```
+/path/to/opencode-memory/
+├── memory.db
+└── memories/
+```
+
+Mount that directory into the sandbox at the **same absolute path**.
+
+This does not move existing files. Stop OpenCode, copy `memory.db` (and
+`memory.db-wal` / `memory.db-shm` if present) plus `memories/` into the new
+home, then start it again. Do not symlink `memories/` in place of `home` —
+a symlinked memory root is refused. Ask the agent to run `memory_inspect` to
+confirm the resolved path.
+
 ### Sharing memory with the Codex CLI
 
 If you use OpenCode and the Codex CLI on the same machine, turn this on so each
@@ -265,7 +325,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.5",
       { "codex_interop": { "import": true, "export": true } }
     ]
   ]
@@ -322,7 +382,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.5", { "claude_import": { "enabled": true } }]
   ]
 }
 ```
@@ -349,7 +409,7 @@ Claude names each project with an opaque id (a folder under
 {
   "plugin": [
     [
-      "opencode-codex-memory@0.7.3",
+      "opencode-codex-memory@0.7.5",
       {
         "claude_import": {
           "enabled": true,

package/dist/src/db.js

@@ -1,4 +1,6 @@
 import { Database } from "bun:sqlite";
+import fs from "fs";
+import path from "path";
 import { memoryDbPath } from "./paths.js";
 const SCHEMA_V1 = [
     `CREATE TABLE IF NOT EXISTS memory_stage1_outputs (
@@ -46,6 +48,7 @@ export function openDb() {
     if (dbInstance)
         return dbInstance;
     const dbPath = memoryDbPath();
+    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
     const db = new Database(dbPath, { create: true, readwrite: true, strict: false });
     try {
         // Match codex's memories-DB open options (runtime.rs): WAL, NORMAL sync,

package/dist/src/index.js

@@ -1,5 +1,6 @@
 import { ensureMemoryLayout, buildMemorySystemPrompt, invalidateCache } from "./source.js";
-import { memoryRoot } from "./paths.js";
+import { memoryRoot, memoryDbPath, setConfiguredHome, resolveHomePath } from "./paths.js";
+import { closeDb } from "./db.js";
 import { stripCitations, extractCitedSessionIds, hasCitationMarkup } from "./citation.js";
 import { memory_read, memory_search, memory_list, memory_add_note } from "../tools/memory.js";
 import { memory_reset, memory_inspect, memory_mode } from "../tools/control.js";
@@ -137,8 +138,12 @@ export default {
         clearConfigWarnings();
         if (opts)
             applyPluginOptions(opts);
-        else
+        else {
+            const previousDb = memoryDbPath();
             resetPluginOptions();
+            if (memoryDbPath() !== previousDb)
+                closeDb();
+        }
         // Finish bounded reseeding before hooks can see a surviving memory
         // sub-session after a plugin reload.
         await cleanupOldSubSessions();
@@ -165,6 +170,7 @@ const KNOWN_OPTION_KEYS = new Set([
     "max_rollout_age_days",
     "max_rollouts_per_startup",
     "min_rollout_idle_hours",
+    "home",
     "codex_interop",
     "claude_import",
 ]);
@@ -183,6 +189,7 @@ function clampInt(key, value, min, max, fallback) {
 export function applyPluginOptions(opts) {
     // Fresh pass per apply so memory_inspect never shows warnings for keys the
     // caller has since fixed. server() clears too, for boots without options.
+    const previousDb = memoryDbPath();
     clearConfigWarnings();
     resetPluginOptions();
     const raw = opts;
@@ -220,6 +227,28 @@ export function applyPluginOptions(opts) {
         pluginOptions.max_rollouts_per_startup = clampInt("max_rollouts_per_startup", opts.max_rollouts_per_startup, 1, 128, 2);
     if ("min_rollout_idle_hours" in opts)
         pluginOptions.min_rollout_idle_hours = clampInt("min_rollout_idle_hours", opts.min_rollout_idle_hours, 1, 48, 6);
+    if ("home" in raw) {
+        if (typeof raw.home !== "string") {
+            recordConfigWarning("home must be a string; using the OpenCode data dir");
+        }
+        else {
+            const resolved = resolveHomePath(raw.home);
+            if (!resolved) {
+                recordConfigWarning("home must be an absolute path (tilde ~ is ok); using the OpenCode data dir");
+            }
+            else {
+                pluginOptions.home = resolved;
+                setConfiguredHome(resolved);
+                const envHome = process.env.OPENCODE_CODEX_MEMORY_HOME;
+                if (envHome) {
+                    const envResolved = resolveHomePath(envHome);
+                    if (envResolved && envResolved !== resolved) {
+                        recordConfigWarning("OPENCODE_CODEX_MEMORY_HOME ignored because home option is set");
+                    }
+                }
+            }
+        }
+    }
     if ("codex_interop" in opts) {
         const raw = opts.codex_interop;
         if (raw && typeof raw === "object" && !Array.isArray(raw)) {
@@ -282,6 +311,8 @@ export function applyPluginOptions(opts) {
             recordConfigWarning("claude_import must be an object like { enabled, claude_home, projects }; ignored");
         }
     }
+    if (memoryDbPath() !== previousDb)
+        closeDb();
 }
 /**
  * codex marks every MCP server as memory-polluting unconditionally
@@ -376,7 +407,7 @@ export function injectAgentDefinitions(config) {
     }
     // Sub-sessions use directory=memoryRoot (llm.ts), so memory paths are usually
     // in-bounds. Keep an explicit external_directory allow for the memory root as
-    // belt-and-suspenders (path is homedir/env-dependent; out-ranks `"*": deny`).
+    // belt-and-suspenders (path is home/env-dependent; out-ranks `"*": deny`).
     const memorize = defs["memorize"];
     if (memorize?.permission && !("external_directory" in memorize.permission)) {
         memorize.permission["external_directory"] = { [path.join(memoryRoot(), "*")]: "allow" };

package/dist/src/options.d.ts

@@ -7,9 +7,9 @@ import type { ClaudeImportOptions } from "./claude-import.js";
  *
  * Option names and defaults mirror codex's MemoriesToml/MemoriesConfig
  * (codex-rs/config/src/types.rs). Keep them 1:1 so the drift script and
- * manual syncing stay trivial; do not rename for taste. codex_interop and
- * claude_import are opencode-facing knobs for external-agent exchange
- * (codex's Claude importer is migration-UI gated / default-off).
+ * manual syncing stay trivial; do not rename for taste. codex_interop,
+ * claude_import, and home are opencode-facing knobs (Codex has no equivalent
+ * of relocating just the memory files away from the host data dir).
  */
 export interface PluginOptionsState {
     generate_memories: boolean;
@@ -18,6 +18,8 @@ export interface PluginOptionsState {
     disable_on_external_context: boolean;
     extract_model?: string;
     consolidation_model?: string;
+    /** Resolved absolute plugin home (parent of memory.db + memories/). Unset = default. */
+    home?: string;
     max_raw_memories_for_consolidation: number;
     max_unused_days: number;
     max_rollout_age_days: number;

package/dist/src/options.js

@@ -1,3 +1,4 @@
+import { setConfiguredHome } from "./paths.js";
 const DEFAULT_PLUGIN_OPTIONS = {
     generate_memories: true,
     use_memories: true,
@@ -19,6 +20,8 @@ export const pluginOptions = {
 export function resetPluginOptions() {
     delete pluginOptions.extract_model;
     delete pluginOptions.consolidation_model;
+    delete pluginOptions.home;
+    setConfiguredHome(undefined);
     Object.assign(pluginOptions, DEFAULT_PLUGIN_OPTIONS, {
         codex_interop: { ...DEFAULT_PLUGIN_OPTIONS.codex_interop },
         claude_import: { ...DEFAULT_PLUGIN_OPTIONS.claude_import },

package/dist/src/paths.d.ts

@@ -1,3 +1,30 @@
+export type MemoryHomeSource = "test" | "option" | "env" | "default";
+/**
+ * Memory lives under a dedicated home, mirroring codex's
+ * `<codex_home>/memories` (codex-rs `find_codex_home` + `from_codex_home`) but
+ * with an opencode-specific default. opencode resolves its data dir as
+ * `path.join(xdgData, "opencode")` via the `xdg-basedir` lib
+ * (packages/core/src/global.ts), so we reuse the SAME lib to stay byte-identical
+ * across platforms and `XDG_DATA_HOME` overrides. opencode does not surface this
+ * directory through the plugin API (`/path` gives home/config/state/worktree/
+ * directory, not data), so it must be recomputed here.
+ *
+ * User-facing precedence (first match). `home` / OPENCODE_CODEX_MEMORY_HOME
+ * pin this plugin's files and do NOT follow OpenCode's data dir or XDG_DATA_HOME:
+ *   1. plugin option `home` — always enforced when set
+ *   2. `OPENCODE_CODEX_MEMORY_HOME` — same pin if `home` is unset
+ *   3. OpenCode data dir (`$XDG_DATA_HOME/opencode` or `~/.local/share/opencode`)
+ *
+ * Tests only: `OPENCODE_CODEX_MEMORY_TEST_ROOT` wins over all of the above
+ * (write-pipeline sandbox + unit tests). Not a user relocation knob.
+ *
+ * (1) and (2) exist so a sandbox can mount `memory.db` + `memories/` without
+ * the rest of OpenCode's local database. They are not Codex knobs.
+ */
+export declare function resolveHomePath(raw: string): string | null;
+export declare function setConfiguredHome(home: string | undefined): void;
+export declare function dataRoot(): string;
+export declare function memoryHomeSource(): MemoryHomeSource;
 export declare function memoryRoot(): string;
 export declare function memoryDbPath(): string;
 export declare function memorySummaryPath(): string;

package/dist/src/paths.js

@@ -3,30 +3,77 @@ import os from "os";
 import { xdgData } from "xdg-basedir";
 const MEMORY_DIR_NAME = "memories";
 const MEMORY_DB_NAME = "memory.db";
-const OVERRIDE_ENV = "OPENCODE_CODEX_MEMORY_TEST_ROOT";
+const TEST_ROOT_ENV = "OPENCODE_CODEX_MEMORY_TEST_ROOT";
+const HOME_ENV = "OPENCODE_CODEX_MEMORY_HOME";
 const OPENCODE_APP_DIR = "opencode";
+/** Plugin-option override of the memory home (parent of memory.db + memories/). */
+let configuredHome;
 /**
- * Memory lives under opencode's data dir, mirroring codex's
+ * Memory lives under a dedicated home, mirroring codex's
  * `<codex_home>/memories` (codex-rs `find_codex_home` + `from_codex_home`) but
- * with the opencode-specific home. opencode resolves its data dir as
+ * with an opencode-specific default. opencode resolves its data dir as
  * `path.join(xdgData, "opencode")` via the `xdg-basedir` lib
  * (packages/core/src/global.ts), so we reuse the SAME lib to stay byte-identical
  * across platforms and `XDG_DATA_HOME` overrides. opencode does not surface this
  * directory through the plugin API (`/path` gives home/config/state/worktree/
  * directory, not data), so it must be recomputed here.
  *
- * `OPENCODE_CODEX_MEMORY_TEST_ROOT` is our `CODEX_HOME` analog: an explicit
- * override that wins outright (tests + the write-pipeline sandbox).
+ * User-facing precedence (first match). `home` / OPENCODE_CODEX_MEMORY_HOME
+ * pin this plugin's files and do NOT follow OpenCode's data dir or XDG_DATA_HOME:
+ *   1. plugin option `home` — always enforced when set
+ *   2. `OPENCODE_CODEX_MEMORY_HOME` — same pin if `home` is unset
+ *   3. OpenCode data dir (`$XDG_DATA_HOME/opencode` or `~/.local/share/opencode`)
+ *
+ * Tests only: `OPENCODE_CODEX_MEMORY_TEST_ROOT` wins over all of the above
+ * (write-pipeline sandbox + unit tests). Not a user relocation knob.
+ *
+ * (1) and (2) exist so a sandbox can mount `memory.db` + `memories/` without
+ * the rest of OpenCode's local database. They are not Codex knobs.
  */
-function dataRoot() {
-    const override = process.env[OVERRIDE_ENV];
-    if (override)
-        return override;
+export function resolveHomePath(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    let expanded = trimmed;
+    if (trimmed === "~")
+        expanded = os.homedir();
+    else if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
+        expanded = path.join(os.homedir(), trimmed.slice(2));
+    }
+    if (!path.isAbsolute(expanded))
+        return null;
+    return path.normalize(expanded);
+}
+export function setConfiguredHome(home) {
+    configuredHome = home;
+}
+export function dataRoot() {
+    const testRoot = process.env[TEST_ROOT_ENV];
+    if (testRoot)
+        return testRoot;
+    if (configuredHome)
+        return configuredHome;
+    const envHome = process.env[HOME_ENV];
+    if (envHome) {
+        const resolved = resolveHomePath(envHome);
+        if (resolved)
+            return resolved;
+    }
     // xdgData = XDG_DATA_HOME || ~/.local/share (identical on every platform).
     // The `??` mirrors xdg-basedir's own guard for a missing home directory.
     const base = xdgData ?? path.join(os.homedir(), ".local", "share");
     return path.join(base, OPENCODE_APP_DIR);
 }
+export function memoryHomeSource() {
+    if (process.env[TEST_ROOT_ENV])
+        return "test";
+    if (configuredHome)
+        return "option";
+    const envHome = process.env[HOME_ENV];
+    if (envHome && resolveHomePath(envHome))
+        return "env";
+    return "default";
+}
 export function memoryRoot() {
     return path.join(dataRoot(), MEMORY_DIR_NAME);
 }

package/dist/src/v2/plugin.js

@@ -25,12 +25,14 @@ import { runPhase1 } from "../phase1.js";
 import { runPhase2 } from "../phase2.js";
 import { setPluginInput, setSubSessionDirectory, cleanupOldSubSessions, isMemorySubSession, abortActiveSubSessions, } from "../llm.js";
 import { pluginOptions, clearConfigWarnings, resetPluginOptions } from "../options.js";
+import { memoryDbPath } from "../paths.js";
+import { closeDb } from "../db.js";
 import { beginPluginShutdown, isPluginShuttingDown, resetPluginLifecycle } from "../lifecycle.js";
 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 +180,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");
     }
@@ -277,8 +280,12 @@ export async function setup(ctx) {
     clearConfigWarnings();
     if (ctx.options)
         applyPluginOptions(ctx.options);
-    else
+    else {
+        const previousDb = memoryDbPath();
         resetPluginOptions();
+        if (memoryDbPath() !== previousDb)
+            closeDb();
+    }
     await ensureV2Agents(ctx);
     const statusRegistration = await ctx.rpc.register(MemoryStatusRpc, {
         status: async (input) => {
@@ -336,7 +343,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 +443,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

@@ -1,7 +1,7 @@
 import fs from "fs";
 import path from "path";
 import { tool } from "@opencode-ai/plugin";
-import { memoryRoot, memorySummaryPath } from "../src/paths.js";
+import { memoryRoot, memorySummaryPath, dataRoot, memoryHomeSource } from "../src/paths.js";
 import { MemoryStore } from "../src/store.js";
 import { invalidateCache } from "../src/source.js";
 import { estimateTokens } from "../src/token.js";
@@ -42,6 +42,18 @@ function wipeMemoriesDir() {
             fs.unlinkSync(abs);
     }
 }
+function homeSourceLabel(source) {
+    switch (source) {
+        case "test":
+            return "test root";
+        case "option":
+            return "option";
+        case "env":
+            return "OPENCODE_CODEX_MEMORY_HOME";
+        case "default":
+            return "OpenCode data dir";
+    }
+}
 /**
  * Renders the effective (post-parse, post-clamp) plugin options plus any
  * problems recorded while applying them. The plugin never hard-fails on bad
@@ -65,6 +77,7 @@ function renderEffectiveConfig() {
         `  max_rollout_age_days: ${o.max_rollout_age_days}`,
         `  max_rollouts_per_startup: ${o.max_rollouts_per_startup}`,
         `  min_rollout_idle_hours: ${o.min_rollout_idle_hours}`,
+        `  home: ${dataRoot()} (${homeSourceLabel(memoryHomeSource())})`,
     ];
     const ci = o.codex_interop;
     if (!ci.import && !ci.export) {

package/package.json

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