opencode-codex-memory 0.7.4 → 0.7.6

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.4"]
+  "plugin": ["opencode-codex-memory@0.7.6"]
 }
 ```
 
@@ -72,7 +73,7 @@ V2 plugin syntax:
 
 ```jsonc
 {
-  "plugins": [{ "package": "opencode-codex-memory@0.7.4" }],
+  "plugins": [{ "package": "opencode-codex-memory@0.7.6" }],
 }
 ```
 
@@ -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.4", { "disable_on_external_context": true, "min_rollout_idle_hours": 2 }]
+    ["opencode-codex-memory@0.7.6", { "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.6", { "home": "/path/to/opencode-memory" }]
+  ]
+}
+```
+
+OpenCode 2:
+
+```jsonc
+{
+  "plugins": [
+    { "package": "opencode-codex-memory@0.7.6", "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.4",
+      "opencode-codex-memory@0.7.6",
       { "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.4", { "claude_import": { "enabled": true } }]
+    ["opencode-codex-memory@0.7.6", { "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.4",
+      "opencode-codex-memory@0.7.6",
       {
         "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/citation-overlay.d.ts

@@ -3,5 +3,5 @@
  * the TUI renders fenced `memory-citation` blocks, so the V2 context hook
  * overlays this section onto the shared inject prompt.
  */
-export declare const V2_CITATION_INSTRUCTIONS = "Memory citation requirements:\n\n- If ANY relevant memory files were used: append exactly one fenced code\n  block with the language tag `memory-citation` as the VERY LAST content of\n  the final reply. Normal responses should include the answer first, then\n  append the block at the end. The host renders this block natively.\n- Use this exact structure for programmatic parsing:\n````\n```memory-citation\nMEMORY.md:234-236|note=build command for the api service\nrollout_summaries/2026-02-17T21-23-02-ln3m-example.md:10-12|note=weekly report format\nsessions: ses_abc123 ses_def456\n```\n````\n- Do not wrap it in `<memory-citation>` XML tags; the fenced form replaces\n  that older format.\n- Citation entry lines are for rendering:\n  - one citation entry per line\n  - format: `<file>:<line_start>-<line_end>|note=<how memory was used>`\n  - use file paths relative to the memory base path (for example, `MEMORY.md`,\n    `rollout_summaries/...`, `skills/...`)\n  - only cite files actually used under the memory base path (do not cite\n    workspace files as memory citations)\n  - if you used `MEMORY.md` and then a rollout summary/skill file, cite both\n  - list entries in order of importance (most important first)\n  - `note` should be short, single-line, and use simple characters only (avoid\n    unusual symbols, no newlines)\n- The final `sessions:` line is for us to track which past sessions you find\n  useful:\n  - one line, space-separated session ids after `sessions:`\n  - session ids look like `ses_...` and appear in rollout summary files and\n    MEMORY.md as `session_id:`\n  - include unique ids only; do not repeat ids\n  - omit the `sessions:` line if no session ids are available\n  - do not include file paths or notes on this line\n  - for every citation entry, try to find and cite the corresponding session id\n- Never include memory citations inside pull-request messages.\n- Never cite blank lines; double-check ranges.\n\n";
+export declare const V2_CITATION_INSTRUCTIONS = "Memory citation requirements:\n\n- If ANY relevant memory files were used: append exactly one fenced code\n  block with the language tag `memory-citation` as the VERY LAST content of\n  the final reply. Answer first, then a blank line, then the block. The\n  opening fence must be on its own line at column 0 \u2014 never glue it to the\n  last sentence, or markdown clients treat the block as paragraph text and\n  collapse its newlines. The host renders this block natively.\n- Use this exact structure for programmatic parsing (blank line before the\n  fence is required):\n````\nanswer text ends here.\n\n```memory-citation\nMEMORY.md:234-236|note=build command for the api service\nrollout_summaries/2026-02-17T21-23-02-ln3m-example.md:10-12|note=weekly report format\nsessions: ses_abc123 ses_def456\n```\n````\n- Do not wrap it in `<memory-citation>` XML tags; the fenced form replaces\n  that older format.\n- Citation entry lines are for rendering:\n  - one citation entry per line\n  - format: `<file>:<line_start>-<line_end>|note=<how memory was used>`\n  - use file paths relative to the memory base path (for example, `MEMORY.md`,\n    `rollout_summaries/...`, `skills/...`)\n  - only cite files actually used under the memory base path (do not cite\n    workspace files as memory citations)\n  - if you used `MEMORY.md` and then a rollout summary/skill file, cite both\n  - list entries in order of importance (most important first)\n  - `note` should be short, single-line, and use simple characters only (avoid\n    unusual symbols, no newlines)\n- The final `sessions:` line is for us to track which past sessions you find\n  useful:\n  - one line, space-separated session ids after `sessions:`\n  - session ids look like `ses_...` and appear in rollout summary files and\n    MEMORY.md as `session_id:`\n  - include unique ids only; do not repeat ids\n  - omit the `sessions:` line if no session ids are available\n  - do not include file paths or notes on this line\n  - for every citation entry, try to find and cite the corresponding session id\n- Never include memory citations inside pull-request messages.\n- Never cite blank lines; double-check ranges.\n\n";
 export declare function overlayV2CitationInstructions(prompt: string): string;

package/dist/src/v2/citation-overlay.js

@@ -7,10 +7,15 @@ export const V2_CITATION_INSTRUCTIONS = `Memory citation requirements:
 
 - If ANY relevant memory files were used: append exactly one fenced code
   block with the language tag \`memory-citation\` as the VERY LAST content of
-  the final reply. Normal responses should include the answer first, then
-  append the block at the end. The host renders this block natively.
-- Use this exact structure for programmatic parsing:
+  the final reply. Answer first, then a blank line, then the block. The
+  opening fence must be on its own line at column 0 — never glue it to the
+  last sentence, or markdown clients treat the block as paragraph text and
+  collapse its newlines. The host renders this block natively.
+- Use this exact structure for programmatic parsing (blank line before the
+  fence is required):
 \`\`\`\`
+answer text ends here.
+
 \`\`\`memory-citation
 MEMORY.md:234-236|note=build command for the api service
 rollout_summaries/2026-02-17T21-23-02-ln3m-example.md:10-12|note=weekly report format

package/dist/src/v2/plugin.js

@@ -25,6 +25,8 @@ 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";
@@ -278,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) => {

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.4",
+  "version": "0.7.6",
   "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",