opencode-codex-memory 0.4.4 → 0.4.6

package/README.md

@@ -18,6 +18,8 @@ project is a faithful port of the memory system in OpenAI's Codex. It works out
 of the box with zero extra configuration and uses whatever models you already
 have set up in OpenCode.
 
+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`;
@@ -50,7 +52,7 @@ If you want the mental model before the details, jump to
 
 ```json
 {
-  "plugin": ["opencode-codex-memory@0.4.4"]
+  "plugin": ["opencode-codex-memory@0.4.6"]
 }
 ```
 
@@ -237,7 +239,7 @@ To set options, turn the plugin entry into a `[name, options]` pair:
 ```json
 {
   "plugin": [
-    ["opencode-codex-memory@0.4.4", { "disable_on_external_context": true, "min_rollout_idle_hours": 2 }]
+    ["opencode-codex-memory@0.4.6", { "disable_on_external_context": true, "min_rollout_idle_hours": 2 }]
   ]
 }
 ```
@@ -296,7 +298,7 @@ directions:
 ```json
 {
   "plugin": [
-    ["opencode-codex-memory@0.4.4", { "codex_interop": { "import": true, "export": true } }]
+    ["opencode-codex-memory@0.4.6", { "codex_interop": { "import": true, "export": true } }]
   ]
 }
 ```

package/dist/src/llm.js

@@ -1,5 +1,6 @@
 import fs from "fs";
 import path from "path";
+import { memoryRoot } from "./paths.js";
 let inputRef = null;
 export function setPluginInput(input) {
     inputRef = input;
@@ -20,11 +21,27 @@ const SUBSESSION_DELETE_TIMEOUT_MS = 10_000;
 export function isMemorySubSession(sessionId) {
     return activeSubSessions.has(sessionId);
 }
+/**
+ * Host directory for memory sub-sessions. Must exist: OpenCode resolves it in
+ * SystemPrompt.environment and fails the turn with UnknownError/ENOENT when
+ * missing. Prefer the memory workspace itself — global, always ours, already
+ * granted to `memorize` via external_directory, and independent of whatever
+ * (possibly deleted) project PluginInput.directory points at.
+ */
+function resolveSubSessionDirectory() {
+    const root = memoryRoot();
+    fs.mkdirSync(root, { recursive: true });
+    return root;
+}
 async function createSession(agent, title) {
     const input = getPluginInput();
     if (!input)
         throw new Error("plugin input not initialized");
+    const directory = resolveSubSessionDirectory();
     const res = await input.client.session.create({
+        // directory is a query param (not body); without it the client inherits
+        // PluginInput.directory, which may be a deleted project path.
+        query: { directory },
         body: {
             title: title ?? `codex-memory-${agent}`,
             metadata: { [SUBSESSION_METADATA_KEY]: true },

package/dist/src/store.d.ts

@@ -70,7 +70,22 @@ export declare class MemoryStore {
      * still back the consolidated artifacts.
      */
     markPhase2Succeeded(ownershipToken: string, selected?: Pick<Stage1Output, "session_id" | "source_updated_at">[]): void;
-    /** Last recorded phase-2 success info (memory_inspect). Null when phase 2 never succeeded. */
+    /**
+     * Phase-2 job snapshot for memory_inspect. Always returns the global job row
+     * when it exists (including failed/running), so diagnostics are not limited
+     * to clean successes. `success_finished_at` is set only for a clean success
+     * (never a failure timestamp); `last_success_watermark` follows codex
+     * (preserved across later attempts; zero only counts while clean).
+     */
+    phase2JobSnapshot(): {
+        status: string;
+        last_error: string | null;
+        finished_at: number | null;
+        retry_at: number | null;
+        success_finished_at: number | null;
+        last_success_watermark: number | null;
+    } | null;
+    /** Last recorded phase-2 success info. Null when phase 2 never succeeded. */
     phase2LastSuccess(): {
         finished_at: number | null;
         last_success_watermark: number | null;

package/dist/src/store.js

@@ -311,27 +311,50 @@ export class MemoryStore {
                 mark.run(s.source_updated_at, s.session_id, s.source_updated_at);
         }).immediate();
     }
-    /** Last recorded phase-2 success info (memory_inspect). Null when phase 2 never succeeded. */
-    phase2LastSuccess() {
+    /**
+     * Phase-2 job snapshot for memory_inspect. Always returns the global job row
+     * when it exists (including failed/running), so diagnostics are not limited
+     * to clean successes. `success_finished_at` is set only for a clean success
+     * (never a failure timestamp); `last_success_watermark` follows codex
+     * (preserved across later attempts; zero only counts while clean).
+     */
+    phase2JobSnapshot() {
         const row = this.db
-            .prepare(`SELECT status, finished_at, last_error, last_success_watermark FROM memory_jobs
+            .prepare(`SELECT status, finished_at, last_error, retry_at, last_success_watermark FROM memory_jobs
          WHERE kind='memory_consolidate_global' AND job_key='global'`)
             .get();
-        if (!row || row.last_success_watermark === null)
+        if (!row)
             return null;
         const cleanSuccess = row.last_error === null &&
             row.finished_at !== null &&
             (row.status === "done" || row.status === "pending");
         // Codex initializes pending global jobs with watermark 0, so zero proves a
         // success only while the row itself is a clean completed attempt.
-        if (row.last_success_watermark === 0 && !cleanSuccess)
+        const watermark = row.last_success_watermark === null
+            ? null
+            : row.last_success_watermark === 0 && !cleanSuccess
+                ? null
+                : row.last_success_watermark;
+        return {
+            status: row.status,
+            last_error: row.last_error,
+            finished_at: row.finished_at,
+            retry_at: row.retry_at,
+            // Codex preserves last_success_watermark across later attempts, while the
+            // job finished_at describes only the latest attempt. Never label a failure
+            // timestamp as a success finish time.
+            success_finished_at: cleanSuccess ? row.finished_at : null,
+            last_success_watermark: watermark,
+        };
+    }
+    /** Last recorded phase-2 success info. Null when phase 2 never succeeded. */
+    phase2LastSuccess() {
+        const snap = this.phase2JobSnapshot();
+        if (!snap || snap.last_success_watermark === null)
             return null;
         return {
-            // Codex preserves last_success_watermark across later attempts, while
-            // finished_at describes only the latest attempt. Expose them separately
-            // so a failure timestamp is never labeled as a success timestamp.
-            finished_at: cleanSuccess ? row.finished_at : null,
-            last_success_watermark: row.last_success_watermark,
+            finished_at: snap.success_finished_at,
+            last_success_watermark: snap.last_success_watermark,
         };
     }
     markPhase2Failed(ownershipToken, error) {

package/dist/tools/control.js

@@ -150,11 +150,22 @@ export const memory_reset = tool({
         }
     },
 });
+function fmtUnixSec(sec) {
+    return sec ? new Date(sec * 1000).toISOString() : "none";
+}
+function fmtWatermarkMs(ms) {
+    if (ms === 0)
+        return "0 (no consumed inputs)";
+    if (ms === null || ms === undefined)
+        return "none";
+    return new Date(ms).toISOString();
+}
 export const memory_inspect = tool({
-    description: "Inspect the current memory state. Returns: stage1_outputs count, last Phase 2 success watermark, " +
-        "memory_summary token estimate, a listing of the memories directory, the effective plugin options, " +
-        "and any configuration warnings (unknown/malformed options). Use it to verify the plugin " +
-        "configuration took effect. Read-only.",
+    description: "Inspect the current memory state. Returns: stage1_outputs count, Phase 2 job status " +
+        "(including last error / retry time when failed), last Phase 2 success watermark, " +
+        "memory_summary token estimate (on-disk; injection caps at ~2500), a listing of the " +
+        "memories directory, the effective plugin options, and any configuration warnings " +
+        "(unknown/malformed options). Use it to verify the plugin configuration took effect. Read-only.",
     args: {},
     async execute() {
         try {
@@ -171,20 +182,30 @@ export const memory_inspect = tool({
                 summaryTokens = estimateTokens(text);
             }
             const listing = listMemoriesDir();
-            // The tool description promises the last Phase 2 success watermark.
-            const phase2 = store.phase2LastSuccess();
-            const watermark = phase2?.last_success_watermark === 0
-                ? "0 (no consumed inputs)"
-                : phase2?.last_success_watermark !== null && phase2?.last_success_watermark !== undefined
-                    ? new Date(phase2.last_success_watermark).toISOString()
-                    : "none";
-            const finishedAt = phase2?.finished_at ? new Date(phase2.finished_at * 1000).toISOString() : "none";
+            const phase2 = store.phase2JobSnapshot();
+            const phase2Lines = phase2
+                ? [
+                    `phase2_status: ${phase2.status}`,
+                    `phase2_last_error: ${phase2.last_error ?? "none"}`,
+                    `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)}`,
+                    // Clean-success finish only — never a failure timestamp.
+                    `phase2_last_success_finished_at: ${fmtUnixSec(phase2.success_finished_at)}`,
+                ]
+                : [
+                    "phase2_status: none",
+                    "phase2_last_error: none",
+                    "phase2_retry_at: none",
+                    "phase2_last_attempt_finished_at: none",
+                    "phase2_last_success_watermark: none",
+                    "phase2_last_success_finished_at: none",
+                ];
             const out = [
                 `stage1_outputs: ${outputs.length}`,
-                `phase2_last_success_watermark: ${watermark}`,
-                `phase2_last_finished_at: ${finishedAt}`,
+                ...phase2Lines,
                 `memory_summary_chars: ${summaryChars}`,
-                `memory_summary_tokens_est: ${summaryTokens}`,
+                `memory_summary_tokens_est: ${summaryTokens} (on disk; injection caps at ~2500)`,
                 `memories_dir_entries: ${listing.length}`,
                 "",
                 ...renderEffectiveConfig(),
@@ -196,8 +217,14 @@ export const memory_inspect = tool({
                 output: out,
                 metadata: {
                     stage1_count: outputs.length,
+                    phase2_status: phase2?.status ?? null,
+                    phase2_last_error: phase2?.last_error ?? null,
+                    phase2_retry_at: phase2?.retry_at ?? null,
+                    phase2_last_attempt_finished_at: phase2?.finished_at ?? null,
                     phase2_last_success_watermark: phase2?.last_success_watermark ?? null,
-                    phase2_last_finished_at: phase2?.finished_at ?? null,
+                    phase2_last_success_finished_at: phase2?.success_finished_at ?? null,
+                    // Back-compat aliases used by earlier inspect consumers.
+                    phase2_last_finished_at: phase2?.success_finished_at ?? null,
                     summary_chars: summaryChars,
                     summary_tokens_est: summaryTokens,
                     files: listing,

package/package.json

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