opencode-codex-memory 0.4.9 → 0.4.11

package/README.md

@@ -52,7 +52,7 @@ If you want the mental model before the details, jump to
 
 ```json
 {
-  "plugin": ["opencode-codex-memory@0.4.9"]
+  "plugin": ["opencode-codex-memory@0.4.11"]
 }
 ```
 
@@ -239,7 +239,7 @@ To set options, turn the plugin entry into a `[name, options]` pair:
 ```json
 {
   "plugin": [
-    ["opencode-codex-memory@0.4.9", { "disable_on_external_context": true, "min_rollout_idle_hours": 2 }]
+    ["opencode-codex-memory@0.4.11", { "disable_on_external_context": true, "min_rollout_idle_hours": 2 }]
   ]
 }
 ```
@@ -298,7 +298,7 @@ directions:
 ```json
 {
   "plugin": [
-    ["opencode-codex-memory@0.4.9", { "codex_interop": { "import": true, "export": true } }]
+    ["opencode-codex-memory@0.4.11", { "codex_interop": { "import": true, "export": true } }]
   ]
 }
 ```

package/dist/src/capture.js

@@ -47,9 +47,15 @@ export async function listRecentSessions(limit = SCAN_LIMIT) {
         return [];
     }
     try {
+        // Opencode's SDK client injects `directory` from x-opencode-directory on
+        // every GET (sdk client rewrite). The experimental session handler treats
+        // any present directory query as "filter to this instance's project",
+        // which would hide every other project's idle sessions — memory is global.
+        // Pass an empty directory so rewrite does not re-inject, and the handler
+        // sees a falsy value → listGlobal without a directory filter.
         const res = await withTimeout(get({
             url: "/experimental/session",
-            query: { roots: true, limit },
+            query: { roots: true, limit, directory: "" },
         }), API_TIMEOUT_MS, "experimental.session.list");
         if (!res || res.error || !Array.isArray(res.data)) {
             throw new Error(`experimental.session.list failed: ${JSON.stringify(res?.error ?? {})}`);

package/dist/src/index.js

@@ -291,14 +291,9 @@ export function injectAgentDefinitions(config) {
         console.warn("[opencode-codex-memory] could not load bundled agent definitions:", err);
         return;
     }
-    // opencode gates file tools outside the session's project behind the
-    // `external_directory` permission, and the memory workspace is global —
-    // outside every project — so the consolidator's reads/writes there always
-    // trigger that ask. The bundled `"*": "deny"` matches it (permission rules
-    // are wildcard-on-name, last match wins), which would block consolidation
-    // entirely. Grant the memory root here rather than in opencode.json: the
-    // path is homedir/env-dependent (src/paths.ts is its single source of
-    // truth). Appended last so it out-ranks the wildcard deny.
+    // 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`).
     const memorize = defs["memorize"];
     if (memorize?.permission && !("external_directory" in memorize.permission)) {
         memorize.permission["external_directory"] = { [path.join(memoryRoot(), "*")]: "allow" };

package/dist/src/lifecycle.d.ts

@@ -1,14 +1,20 @@
 /**
- * Plugin process lifecycle: shutdown flag + phase-2 abort signal shared by
- * the entry dispose hook and the write pipeline.
+ * Plugin process lifecycle: shutdown flag + abort signals shared by the entry
+ * dispose hook and the write pipeline.
  *
  * Opencode can reload plugins while a consolidator helper still holds write
  * access to the memory root. dispose() sets the flag (so new pumps stop),
- * aborts the in-flight consolidation prompt, and best-effort aborts active
- * sub-sessions (llm.ts).
+ * aborts pluginShutdownSignal (extract + any other waiters) and the in-flight
+ * phase-2 AbortSignal (consolidateViaSubagent), and best-effort session.aborts
+ * active sub-sessions (llm.ts abortActiveSubSessions).
+ *
+ * Phase-2 keeps its own scope so heartbeat loss can cancel the consolidator
+ * without marking the whole plugin as shutting down.
  */
 export declare function isPluginShuttingDown(): boolean;
-/** Begin shutdown: no new phase work, abort any in-flight consolidator. */
+/** Aborted when dispose begins; replaced on resetPluginLifecycle / re-boot. */
+export declare function pluginShutdownSignal(): AbortSignal;
+/** Begin shutdown: no new phase work, abort extract + consolidator waiters. */
 export declare function beginPluginShutdown(): void;
 /**
  * Test / re-boot seam: a fresh server() call clears the previous dispose.

package/dist/src/lifecycle.js

@@ -1,20 +1,32 @@
 /**
- * Plugin process lifecycle: shutdown flag + phase-2 abort signal shared by
- * the entry dispose hook and the write pipeline.
+ * Plugin process lifecycle: shutdown flag + abort signals shared by the entry
+ * dispose hook and the write pipeline.
  *
  * Opencode can reload plugins while a consolidator helper still holds write
  * access to the memory root. dispose() sets the flag (so new pumps stop),
- * aborts the in-flight consolidation prompt, and best-effort aborts active
- * sub-sessions (llm.ts).
+ * aborts pluginShutdownSignal (extract + any other waiters) and the in-flight
+ * phase-2 AbortSignal (consolidateViaSubagent), and best-effort session.aborts
+ * active sub-sessions (llm.ts abortActiveSubSessions).
+ *
+ * Phase-2 keeps its own scope so heartbeat loss can cancel the consolidator
+ * without marking the whole plugin as shutting down.
  */
 let shuttingDown = false;
 let phase2Abort = null;
+/** Fresh each boot; aborted on dispose. Extract (and others) subscribe here. */
+let shutdownAbort = new AbortController();
 export function isPluginShuttingDown() {
     return shuttingDown;
 }
-/** Begin shutdown: no new phase work, abort any in-flight consolidator. */
+/** Aborted when dispose begins; replaced on resetPluginLifecycle / re-boot. */
+export function pluginShutdownSignal() {
+    return shutdownAbort.signal;
+}
+/** Begin shutdown: no new phase work, abort extract + consolidator waiters. */
 export function beginPluginShutdown() {
     shuttingDown = true;
+    if (!shutdownAbort.signal.aborted)
+        shutdownAbort.abort();
     phase2Abort?.abort();
 }
 /**
@@ -25,6 +37,7 @@ export function beginPluginShutdown() {
 export function resetPluginLifecycle() {
     phase2Abort?.abort();
     phase2Abort = null;
+    shutdownAbort = new AbortController();
     shuttingDown = false;
 }
 /**

package/dist/src/llm.d.ts

@@ -32,8 +32,20 @@ export interface ExtractOptions {
     model?: string;
     /** Override the default 1h extract timeout (tests / advanced). */
     timeoutMs?: number;
+    /**
+     * Cancel in-flight extract. Defaults to pluginShutdownSignal() so dispose
+     * unblocks phase1 without waiting on the host to reject session.prompt.
+     */
+    signal?: AbortSignal;
 }
-/** Returns null when the extractor reported a no-op (nothing worth remembering). */
+/**
+ * Returns null when the extractor reported a no-op (nothing worth remembering).
+ *
+ * Defaults to pluginShutdownSignal so dispose cancels the in-flight prompt
+ * race the same way as consolidateViaSubagent (phase-2 scope). dispose still
+ * session.aborts the sub-session for host-side cleanup; extractor has no FS
+ * write tools (D2) so a lingering server turn cannot dual-write the memory root.
+ */
 export declare function extractViaSubagent(sessionId: string, transcript: string, opts?: ExtractOptions): Promise<ExtractionResult | null>;
 export declare function consolidateViaSubagent(memoryRoot: string, diffFileName: string, model?: string, signal?: AbortSignal): Promise<void>;
 export declare function cleanupOldSubSessions(maxAgeMinutes?: number, timeoutMs?: number): Promise<void>;

package/dist/src/llm.js

@@ -2,6 +2,7 @@ import fs from "fs";
 import path from "path";
 import { memoryRoot } from "./paths.js";
 import { hostSessionCreate, hostSessionDeletionConfirmed, hostSessionPrompt, hostStructuredOutput, } from "./host-client.js";
+import { pluginShutdownSignal } from "./lifecycle.js";
 let inputRef = null;
 export function setPluginInput(input) {
     inputRef = input;
@@ -171,8 +172,13 @@ async function runPrompt(sessionId, prompt, agent, opts = {}) {
         const cancellation = new Promise((_, reject) => {
             if (!opts.signal)
                 return;
+            // Abort may fire between the pre-check above and this setup (e.g. dispose
+            // during hostSessionPrompt construction). Already-aborted signals do not
+            // re-emit; observe current state after attaching the listener.
             onAbort = () => reject(new SubagentCancelledError());
             opts.signal.addEventListener("abort", onAbort, { once: true });
+            if (opts.signal.aborted)
+                onAbort();
         });
         const res = await Promise.race([
             promptPromise,
@@ -243,7 +249,14 @@ const EXTRACTION_SCHEMA = {
     },
     required: ["raw_memory", "rollout_summary", "rollout_slug"],
 };
-/** Returns null when the extractor reported a no-op (nothing worth remembering). */
+/**
+ * Returns null when the extractor reported a no-op (nothing worth remembering).
+ *
+ * Defaults to pluginShutdownSignal so dispose cancels the in-flight prompt
+ * race the same way as consolidateViaSubagent (phase-2 scope). dispose still
+ * session.aborts the sub-session for host-side cleanup; extractor has no FS
+ * write tools (D2) so a lingering server turn cannot dual-write the memory root.
+ */
 export async function extractViaSubagent(sessionId, transcript, opts = {}) {
     const agent = "memorize-extract";
     const subId = await createSession(agent, `codex-memory-extract-${sessionId}`);
@@ -258,6 +271,7 @@ export async function extractViaSubagent(sessionId, transcript, opts = {}) {
             timeoutMs: opts.timeoutMs ?? 3600_000,
             system: readTemplate("stage_one_system.md"),
             model,
+            signal: opts.signal ?? pluginShutdownSignal(),
             // opencode enforces json_schema output via a forced StructuredOutput tool
             // call (toolChoice: required) — which is why memorize-extract must allow
             // that one otherwise-denied tool.

package/dist/src/phase1.js

@@ -2,7 +2,7 @@ import { STAGE1_CONCURRENCY } from "./store.js";
 import { loadTranscript, selectEligibleSessions } from "./capture.js";
 import { redact, isMemoryExcludedFragment } from "./redact.js";
 import { stripCitations } from "./citation.js";
-import { extractViaSubagent } from "./llm.js";
+import { extractViaSubagent, SubagentCancelledError } from "./llm.js";
 import { checkRateLimit, markRateLimitUsed } from "./ratelimit.js";
 import { isPluginShuttingDown } from "./lifecycle.js";
 import { recordDiagnostic } from "./diagnostics.js";
@@ -38,7 +38,9 @@ export async function runPhase1(store, opts = DEFAULT_PHASE1_OPTIONS, rateLimitC
     // Empty claim: do not stamp the process timer (codex only metrics
     // skipped_no_candidates and leaves the next startup free to try again).
     if (claimed.length === 0) {
-        recordDiagnostic("info", "phase1", `no claims (eligible=${eligible.length})`);
+        // eligible ≠ claimable: already done at this watermark, exhausted retries,
+        // or lease held. Surface that so inspect is not "memory stuck".
+        recordDiagnostic("info", "phase1", `no claims (eligible=${eligible.length}; already extracted, in backoff, or at claim cap)`);
         return;
     }
     markRateLimitUsed("phase1");
@@ -95,9 +97,9 @@ export async function runPhase1(store, opts = DEFAULT_PHASE1_OPTIONS, rateLimitC
             });
         }
         catch (err) {
-            // Aborted mid-extract on dispose: release for immediate reclaim, do not
-            // burn a retry or impose the 1h failure backoff.
-            if (isPluginShuttingDown()) {
+            // Aborted mid-extract on dispose (shutdown signal / flag): release for
+            // immediate reclaim, do not burn a retry or impose the 1h failure backoff.
+            if (err instanceof SubagentCancelledError || isPluginShuttingDown()) {
                 store.releaseStage1OnShutdown(sid, claim.ownershipToken);
             }
             else {

package/package.json

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