opencode-codex-memory 0.4.2 → 0.4.3

package/README.md

@@ -48,11 +48,11 @@ If you want the mental model before the details, jump to
 
 1. Add the plugin to your `~/.config/opencode/opencode.json`:
 
-   ```json
-   {
-  "plugin": ["opencode-codex-memory@0.4.2"]
-   }
-   ```
+```json
+{
+  "plugin": ["opencode-codex-memory@0.4.3"]
+}
+```
 
    **Pin the version** (here and for any OpenCode plugin). OpenCode installs a
    plugin spec once into its package cache and never re-resolves it, so a bare
@@ -237,7 +237,7 @@ To set options, turn the plugin entry into a `[name, options]` pair:
 ```json
 {
   "plugin": [
-    ["opencode-codex-memory@0.4.2", { "disable_on_external_context": true, "min_rollout_idle_hours": 2 }]
+    ["opencode-codex-memory@0.4.3", { "disable_on_external_context": true, "min_rollout_idle_hours": 2 }]
   ]
 }
 ```
@@ -296,7 +296,7 @@ directions:
 ```json
 {
   "plugin": [
-    ["opencode-codex-memory@0.4.2", { "codex_interop": { "import": true, "export": true } }]
+    ["opencode-codex-memory@0.4.3", { "codex_interop": { "import": true, "export": true } }]
   ]
 }
 ```

package/dist/src/llm.d.ts

@@ -15,6 +15,14 @@ export declare function isMemorySubSession(sessionId: string): boolean;
 export declare class SubagentTimeoutError extends Error {
     constructor(timeoutMs: number);
 }
+/**
+ * Thrown when a sub-agent session could not be closed. Codex treats a failed
+ * consolidation-agent shutdown as "the agent may still be alive", so the caller
+ * must keep its job lease instead of completing the job (phase2.rs).
+ */
+export declare class SubagentShutdownError extends Error {
+    constructor(sessionId: string);
+}
 export interface ExtractOptions {
     cwd?: string;
     model?: string;

package/dist/src/llm.js

@@ -81,6 +81,17 @@ export class SubagentTimeoutError extends Error {
         this.name = "SubagentTimeoutError";
     }
 }
+/**
+ * Thrown when a sub-agent session could not be closed. Codex treats a failed
+ * consolidation-agent shutdown as "the agent may still be alive", so the caller
+ * must keep its job lease instead of completing the job (phase2.rs).
+ */
+export class SubagentShutdownError extends Error {
+    constructor(sessionId) {
+        super(`failed to close memory sub-session ${sessionId}`);
+        this.name = "SubagentShutdownError";
+    }
+}
 async function abortSession(sessionId) {
     const input = getPluginInput();
     const session = input?.client?.session;
@@ -224,6 +235,9 @@ export async function extractViaSubagent(sessionId, transcript, opts = {}) {
         return parseExtraction(extractAssistantText(data));
     }
     finally {
+        // Fire-and-forget on purpose (unlike consolidation): stage 1 has no codex
+        // agent-shutdown step, and memorize-extract has no write tools, so a
+        // lingering extract session cannot touch the memory root.
         void deleteSession(subId).catch(() => { });
     }
 }
@@ -234,15 +248,28 @@ const CONSOLIDATION_TIMEOUT_MS = 3600_000;
 export async function consolidateViaSubagent(memoryRoot, diffFileName, model) {
     const agent = "memorize";
     const subId = await createSession(agent, "codex-memory-consolidate");
+    let promptError;
+    let promptFailed = false;
     try {
         const prompt = buildConsolidationPrompt(memoryRoot, diffFileName);
         // consolidation_model option > opencode model (main) > session default.
         const resolved = model ?? (await getConfigModels()).model;
         await promptSession(subId, prompt, agent, { model: resolved, timeoutMs: CONSOLIDATION_TIMEOUT_MS });
     }
-    finally {
-        void deleteSession(subId).catch(() => { });
+    catch (err) {
+        promptError = err;
+        promptFailed = true;
     }
+    // codex phase2.rs awaits the consolidation agent's shutdown BEFORE artifacts
+    // are validated and the job is finished, and a failed shutdown outranks the
+    // run result: the caller must keep its lease rather than release it to a
+    // worker that could race a consolidator which is still alive. The
+    // consolidation agent holds write access to the memory root, so this is the
+    // difference between one writer and two.
+    if (!(await deleteSession(subId)))
+        throw new SubagentShutdownError(subId);
+    if (promptFailed)
+        throw promptError;
 }
 // Must exceed the longest legitimate sub-session lifetime (consolidation may
 // run up to CONSOLIDATION_TIMEOUT_MS = 60min), or a second opencode instance /
@@ -294,25 +321,38 @@ export async function cleanupOldSubSessions(maxAgeMinutes = 90, timeoutMs = SUBS
 function isPluginSubSessionTitle(title) {
     return title === "codex-memory-consolidate" || /^codex-memory-extract-ses_[A-Za-z0-9]+$/.test(title ?? "");
 }
+/**
+ * Closes a sub-session. Returns true when the delete call itself succeeded —
+ * the port's equivalent of codex's `shutdown_consolidation_agent` returning Ok
+ * (runtime.rs). A false return means the sub-agent may still be running.
+ *
+ * The 404 confirmation below is a separate, stricter question (is the session
+ * really gone?) and only governs ownership tracking, never the shutdown result:
+ * hosts without `session.get` would otherwise never report a clean shutdown.
+ */
 async function deleteSession(id) {
     const input = getPluginInput();
     if (!input)
-        return;
+        return false;
     try {
         const res = await input.client.session.delete({ path: { id } });
         if (res.error) {
             console.warn(`[opencode-codex-memory] failed to delete sub-session ${id}: ${JSON.stringify(res.error)}`);
-            return;
+            return false;
         }
         // OpenCode's Session.remove logs and swallows some internal failures while
         // the HTTP route still returns success. Only a confirmed 404 proves the
         // session is gone; otherwise retain ownership so hooks keep skipping it.
+        // codex runtime.rs drops the thread from its manager the same way: only
+        // after shutdown succeeded.
         if (await sessionDeletionConfirmed(input.client, id)) {
             activeSubSessions.delete(id);
         }
+        return true;
     }
     catch (err) {
         console.warn(`[opencode-codex-memory] error deleting sub-session ${id}:`, err);
+        return false;
     }
 }
 async function sessionDeletionConfirmed(client, id) {

package/dist/src/phase2.js

@@ -1,6 +1,6 @@
 import { ensureLayout, rebuildRawMemories, writeRolloutSummaries, pruneExtensionResources, writeWorkspaceDiff, validateConsolidationArtifacts, } from "./workspace.js";
 import { ensureBaseline, captureWorkspaceDiff, resetBaseline, DIFF_ARTIFACT } from "./git-baseline.js";
-import { consolidateViaSubagent } from "./llm.js";
+import { consolidateViaSubagent, SubagentShutdownError } from "./llm.js";
 import { invalidateCache } from "./source.js";
 import { memoryRoot } from "./paths.js";
 import { checkRateLimit } from "./ratelimit.js";
@@ -105,6 +105,17 @@ export async function runPhase2(store, opts = DEFAULT_PHASE2_OPTIONS, rateLimitC
             try {
                 await consolidateViaSubagent(memoryRoot(), DIFF_ARTIFACT, opts.consolidationModel);
             }
+            catch (err) {
+                // codex phase2.rs: when the consolidation agent's shutdown fails, keep
+                // the existing lease until it expires so another worker cannot race a
+                // consolidator whose shutdown has not completed. Neither succeed nor
+                // fail the job — marking it failed would release the lease immediately.
+                if (err instanceof SubagentShutdownError) {
+                    console.warn(`[opencode-codex-memory] ${err.message}; holding the phase2 lease until it expires`);
+                    return { status: "shutdown_failed" };
+                }
+                throw err;
+            }
             finally {
                 clearInterval(heartbeat);
             }

package/package.json

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