opencode-codex-memory 0.4.0 → 0.4.2

package/dist/src/index.js

@@ -7,13 +7,14 @@ import { MemoryStore } from "./store.js";
 import { runPhase1 } from "./phase1.js";
 import { runPhase2 } from "./phase2.js";
 import { setPluginInput, cleanupOldSubSessions, isMemorySubSession } from "./llm.js";
-import { pluginOptions, recordConfigWarning } from "./options.js";
+import { pluginOptions, recordConfigWarning, clearConfigWarnings } from "./options.js";
 import fs from "fs";
 import path from "path";
 let phase1InFlight = false;
 let pluginClient = null;
-// Configured MCP server names, fetched lazily; null until first successful fetch.
-let mcpServerNames = null;
+// Single-flight guard for mcp.status(); see mcpToolPrefixes below.
+let mcpStatusInFlight = null;
+const MCP_STATUS_TIMEOUT_MS = 1_000;
 // Deliberately uncached: openDb() is already a singleton, and caching a store
 // here would hold a stale handle across closeDb() (e.g. after memory_reset).
 function getStore() {
@@ -25,17 +26,25 @@ function getStore() {
 // recorded per part to count each citation exactly once across both paths.
 const recordedCitations = new Map();
 const MAX_TRACKED_PARTS = 500;
-export function takeNewCitations(partKey, ids) {
-    let seen = recordedCitations.get(partKey);
-    if (!seen) {
-        seen = new Set();
-        recordedCitations.set(partKey, seen);
-        if (recordedCitations.size > MAX_TRACKED_PARTS) {
-            const oldest = recordedCitations.keys().next().value;
-            if (oldest !== undefined)
-                recordedCitations.delete(oldest);
-        }
+/**
+ * Inserts `key` at the most-recently-used end and evicts the oldest entry
+ * beyond `max`. Map.set alone does NOT reorder an existing key, so the
+ * delete is what makes eviction least-recently-*used* rather than
+ * first-inserted — long-lived sessions must not age out mid-use.
+ */
+function lruSet(map, key, value, max) {
+    map.delete(key);
+    map.set(key, value);
+    if (map.size > max) {
+        const oldest = map.keys().next().value;
+        if (oldest !== undefined)
+            map.delete(oldest);
     }
+    return value;
+}
+export function takeNewCitations(partKey, ids) {
+    const seen = recordedCitations.get(partKey) ?? new Set();
+    lruSet(recordedCitations, partKey, seen, MAX_TRACKED_PARTS);
     const fresh = ids.filter((id) => !seen.has(id));
     for (const id of fresh)
         seen.add(id);
@@ -43,19 +52,13 @@ export function takeNewCitations(partKey, ids) {
 }
 // One stamp+pump per session per process from the chat.message hook; later
 // messages in the same session add nothing (stamp is idempotent, the pump
-// re-fires on idle anyway).
-const seenTurnSessions = new Set();
+// re-fires on idle anyway). Value = first-seen timestamp (debugging only).
+const seenTurnSessions = new Map();
 const MAX_TRACKED_TURN_SESSIONS = 1000;
 export function markTurnSeen(sessionId) {
-    if (seenTurnSessions.has(sessionId))
-        return false;
-    seenTurnSessions.add(sessionId);
-    if (seenTurnSessions.size > MAX_TRACKED_TURN_SESSIONS) {
-        const oldest = seenTurnSessions.keys().next().value;
-        if (oldest !== undefined)
-            seenTurnSessions.delete(oldest);
-    }
-    return true;
+    const first = seenTurnSessions.get(sessionId);
+    lruSet(seenTurnSessions, sessionId, first ?? Date.now(), MAX_TRACKED_TURN_SESSIONS);
+    return first === undefined;
 }
 // opencode 1.17 publishes BOTH session.status {type:"idle"} and the
 // deprecated session.idle for the same transition, back to back. Handle
@@ -65,15 +68,11 @@ const IDLE_DEDUP_MS = 5000;
 const MAX_TRACKED_IDLE = 500;
 export function shouldHandleIdle(sessionId, now = Date.now()) {
     const last = recentIdle.get(sessionId);
-    if (last !== undefined && now - last < IDLE_DEDUP_MS)
-        return false;
-    recentIdle.set(sessionId, now);
-    if (recentIdle.size > MAX_TRACKED_IDLE) {
-        const oldest = recentIdle.keys().next().value;
-        if (oldest !== undefined)
-            recentIdle.delete(oldest);
-    }
-    return true;
+    const deduped = last !== undefined && now - last < IDLE_DEDUP_MS;
+    // Keep the original stamp while deduping so the window cannot be extended
+    // indefinitely by a stream of twins; refresh LRU order either way.
+    lruSet(recentIdle, sessionId, deduped ? last : now, MAX_TRACKED_IDLE);
+    return !deduped;
 }
 export function handleSessionDeleted(sessionId, store = getStore(), 
 // With generation off the memorize agent is not injected, so a consolidation
@@ -90,9 +89,16 @@ export default {
     async server(input, opts) {
         setPluginInput(input);
         pluginClient = input.client;
+        mcpStatusInFlight = null;
+        // Unconditional, like the caches above: a boot WITHOUT options must not
+        // inherit the previous boot's warnings (opencode can host several
+        // instances in one process — see the ARCHITECTURE known-gaps table).
+        clearConfigWarnings();
         if (opts)
             applyPluginOptions(opts);
-        void cleanupOldSubSessions().catch(() => { });
+        // Finish bounded reseeding before hooks can see a surviving memory
+        // sub-session after a plugin reload.
+        await cleanupOldSubSessions();
         return buildHooks();
     },
 };
@@ -119,6 +125,9 @@ function clampInt(value, min, max, fallback) {
     return Math.min(max, Math.max(min, Math.floor(value)));
 }
 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.
+    clearConfigWarnings();
     for (const key of Object.keys(opts)) {
         if (!KNOWN_OPTION_KEYS.has(key)) {
             // codex uses deny_unknown_fields; a plugin can only warn (recorded for
@@ -168,27 +177,68 @@ export function applyPluginOptions(opts) {
  * codex marks every MCP server as memory-polluting unconditionally
  * (codex-mcp server.rs pollutes_memory: true). opencode registers MCP tools
  * as "<server>_<tool>", so match tool names against the configured server
- * list. Fails closed to the web-tools-only check when the list is unavailable.
+ * list. Query live status so runtime MCP changes cannot escape pollution
+ * marking. Falls back to the web-tools-only check when status is unavailable.
+ *
+ * Concurrent tool calls coalesce on one in-flight status fetch. Deliberately
+ * NOT cached with a TTL: a stale list would miss servers connected
+ * mid-session and silently stop marking their calls as polluting, which is
+ * the failure this classification exists to prevent. The accepted cost is one
+ * status round trip per tool call — bounded to sessions that opt in with
+ * disable_on_external_context (off by default), and paid only in
+ * tool.execute.before.
  */
-async function isExternalContextTool(toolName) {
-    if (toolName === "websearch" || toolName === "webfetch")
-        return true;
-    if (!mcpServerNames && pluginClient) {
-        try {
-            const res = await pluginClient.mcp.status();
-            const servers = res?.data ?? res;
-            if (servers && typeof servers === "object") {
-                mcpServerNames = new Set(Object.keys(servers));
+async function mcpToolPrefixes() {
+    if (!pluginClient)
+        return null;
+    if (!mcpStatusInFlight) {
+        mcpStatusInFlight = (async () => {
+            const controller = new AbortController();
+            let timer;
+            try {
+                const res = await Promise.race([
+                    pluginClient.mcp.status({ signal: controller.signal }),
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => {
+                            controller.abort();
+                            reject(new Error(`mcp.status timed out after ${MCP_STATUS_TIMEOUT_MS}ms`));
+                        }, MCP_STATUS_TIMEOUT_MS);
+                    }),
+                ]);
+                if (res?.error)
+                    return null;
+                const servers = res?.data;
+                if (!servers || typeof servers !== "object" || Array.isArray(servers))
+                    return null;
+                const prefixes = [];
+                for (const [server, status] of Object.entries(servers)) {
+                    if (!status || typeof status !== "object" || typeof status.status !== "string")
+                        continue;
+                    // Mirrors OpenCode's McpCatalog.sanitize when constructing tool names.
+                    prefixes.push(server.replace(/[^a-zA-Z0-9_-]/g, "_"));
+                }
+                return prefixes;
             }
-        }
-        catch {
-            // MCP status unavailable (older opencode); keep web-tools-only checks.
-        }
+            catch {
+                // MCP status unavailable (older OpenCode); keep web-tools-only checks.
+                return null;
+            }
+            finally {
+                clearTimeout(timer);
+                mcpStatusInFlight = null;
+            }
+        })();
     }
-    if (!mcpServerNames)
-        return false;
-    for (const server of mcpServerNames) {
-        if (toolName.startsWith(`${server}_`))
+    return mcpStatusInFlight;
+}
+async function classifyExternalContextTool(toolName) {
+    if (toolName === "websearch" || toolName === "webfetch")
+        return true;
+    const prefixes = await mcpToolPrefixes();
+    if (prefixes === null)
+        return null;
+    for (const prefix of prefixes) {
+        if (toolName.startsWith(`${prefix}_`))
             return true;
     }
     return false;
@@ -247,7 +297,9 @@ function buildHooks() {
             try {
                 if (!pluginOptions.use_memories)
                     return;
-                if (input.sessionID && isMemorySubSession(input.sessionID))
+                // OpenCode also invokes this hook while generating agent definitions,
+                // without a session. Memory belongs only in real conversation prompts.
+                if (!input.sessionID || isMemorySubSession(input.sessionID))
                     return;
                 ensureMemoryLayout();
                 const memoryPrompt = buildMemorySystemPrompt(pluginOptions.dedicated_tools);
@@ -343,20 +395,34 @@ function buildHooks() {
                 console.error("[opencode-codex-memory] chat.message error:", err);
             }
         },
-        // Dedicated plugin hook (NOT an event-bus type): fires after every tool
-        // call. Mirrors codex: external context (web search or any MCP tool) only
-        // pollutes the session's memory when disable_on_external_context is
-        // enabled. Off by default.
-        async "tool.execute.after"(input) {
+        /**
+         * Dedicated plugin hook (NOT an event-bus type). Marks the session polluted
+         * at INVOCATION, mirroring codex: mcp_tool_call.rs calls
+         * maybe_mark_thread_memory_mode_polluted inside handle_approved_mcp_tool_call
+         * BEFORE the call runs, and web search marks on the completed response item
+         * (stream_events_utils.rs response_item_may_include_external_context).
+         *
+         * Deliberately not tool.execute.after: opencode does not guarantee that hook
+         * (session/tools.ts awaits execute() with no ensuring/catchAll, and an abort
+         * interrupts the fiber), so a failed or cancelled websearch/webfetch/MCP call
+         * left the session unmarked while its output had already entered the
+         * transcript. Marking early over-marks a permission-denied call, which is the
+         * safe direction for an opt-in guard.
+         *
+         * Pollution remains gated by disable_on_external_context, off by default.
+         */
+        async "tool.execute.before"(input) {
             try {
-                if (!pluginOptions.disable_on_external_context)
+                if (!pluginOptions.disable_on_external_context || !input.sessionID)
                     return;
-                if (input.sessionID && (await isExternalContextTool(input.tool))) {
-                    getStore().markPolluted(input.sessionID);
-                }
+                // null = MCP status unavailable; websearch/webfetch still classify true
+                // without it, so only MCP-prefixed tools go unmarked.
+                if ((await classifyExternalContextTool(input.tool)) !== true)
+                    return;
+                getStore().markPolluted(input.sessionID);
             }
             catch (err) {
-                console.error("[opencode-codex-memory] tool.execute.after error:", err);
+                console.error("[opencode-codex-memory] tool.execute.before error:", err);
             }
         },
         async event(input) {

package/dist/src/llm.d.ts

@@ -7,14 +7,24 @@ export interface ExtractionResult {
 export declare function setPluginInput(input: PluginInput): void;
 export declare function getPluginInput(): PluginInput | null;
 export declare function isMemorySubSession(sessionId: string): boolean;
+/**
+ * Thrown when a sub-agent prompt exceeds its budget. A distinct type (rather
+ * than matching on the message text) is what tells the catch below that the
+ * run is still executing server-side and must be aborted.
+ */
+export declare class SubagentTimeoutError extends Error {
+    constructor(timeoutMs: number);
+}
 export interface ExtractOptions {
     cwd?: string;
     model?: string;
+    /** Override the default 1h extract timeout (tests / advanced). */
+    timeoutMs?: number;
 }
 /** Returns null when the extractor reported a no-op (nothing worth remembering). */
 export declare function extractViaSubagent(sessionId: string, transcript: string, opts?: ExtractOptions): Promise<ExtractionResult | null>;
 export declare function consolidateViaSubagent(memoryRoot: string, diffFileName: string, model?: string): Promise<void>;
-export declare function cleanupOldSubSessions(maxAgeMinutes?: number): Promise<void>;
+export declare function cleanupOldSubSessions(maxAgeMinutes?: number, timeoutMs?: number): Promise<void>;
 export declare function fillTemplate(tmpl: string, vars: Record<string, string>): string;
 export declare function buildConsolidationPrompt(memoryRoot: string, diffFileName: string): string;
 /**

package/dist/src/llm.js

@@ -11,6 +11,10 @@ export function getPluginInput() {
 // hooks skip these so the plugin never injects memory into (or memorizes) its
 // own sub-agents.
 const activeSubSessions = new Set();
+const SUBSESSION_METADATA_KEY = "opencode-codex-memory";
+const SUBSESSION_LIST_TIMEOUT_MS = 5_000;
+const SUBSESSION_ABORT_TIMEOUT_MS = 1_000;
+const SUBSESSION_CONFIRM_TIMEOUT_MS = 1_000;
 export function isMemorySubSession(sessionId) {
     return activeSubSessions.has(sessionId);
 }
@@ -19,7 +23,10 @@ async function createSession(agent, title) {
     if (!input)
         throw new Error("plugin input not initialized");
     const res = await input.client.session.create({
-        body: { title: title ?? `codex-memory-${agent}` },
+        body: {
+            title: title ?? `codex-memory-${agent}`,
+            metadata: { [SUBSESSION_METADATA_KEY]: true },
+        },
     });
     if (!res.data)
         throw new Error(`session create failed: ${JSON.stringify(res.error ?? {})}`);
@@ -63,6 +70,42 @@ function parseModelRef(ref) {
         return null;
     return { providerID: ref.slice(0, slash), modelID: ref.slice(slash + 1) };
 }
+/**
+ * Thrown when a sub-agent prompt exceeds its budget. A distinct type (rather
+ * than matching on the message text) is what tells the catch below that the
+ * run is still executing server-side and must be aborted.
+ */
+export class SubagentTimeoutError extends Error {
+    constructor(timeoutMs) {
+        super(`sub-agent prompt timed out after ${timeoutMs}ms`);
+        this.name = "SubagentTimeoutError";
+    }
+}
+async function abortSession(sessionId) {
+    const input = getPluginInput();
+    const session = input?.client?.session;
+    if (typeof session?.abort !== "function")
+        return;
+    const controller = new AbortController();
+    let timer;
+    try {
+        await Promise.race([
+            session.abort({ path: { id: sessionId }, signal: controller.signal }),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    controller.abort();
+                    reject(new Error(`session.abort timed out after ${SUBSESSION_ABORT_TIMEOUT_MS}ms`));
+                }, SUBSESSION_ABORT_TIMEOUT_MS);
+            }),
+        ]);
+    }
+    catch {
+        // Best-effort: deleteSession is the backup cancel path.
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 /** Runs a sub-agent prompt and returns the raw response data (`{ info, parts }`). */
 async function runPrompt(sessionId, prompt, agent, opts = {}) {
     const timeoutMs = opts.timeoutMs ?? 300_000;
@@ -87,13 +130,27 @@ async function runPrompt(sessionId, prompt, agent, opts = {}) {
         const res = await Promise.race([
             promptPromise,
             new Promise((_, reject) => {
-                timer = setTimeout(() => reject(new Error(`sub-agent prompt timed out after ${timeoutMs}ms`)), timeoutMs);
+                timer = setTimeout(() => reject(new SubagentTimeoutError(timeoutMs)), timeoutMs);
             }),
         ]);
         if (!res.data)
             throw new Error(`prompt failed: ${JSON.stringify(res.error ?? {})}`);
+        const promptError = res.data.info?.error;
+        if (promptError) {
+            const detail = promptError.data?.message;
+            throw new Error(`sub-agent prompt failed${promptError.name ? ` (${promptError.name})` : ""}${detail ? `: ${detail}` : ""}`);
+        }
         return res.data;
     }
+    catch (err) {
+        // Only a timeout leaves the turn running server-side; every other failure
+        // here means the request already settled. Stop the run so tokens stop
+        // burning — deleteSession in the caller finally is the backup.
+        if (err instanceof SubagentTimeoutError) {
+            await abortSession(sessionId);
+        }
+        throw err;
+    }
     finally {
         clearTimeout(timer);
     }
@@ -148,7 +205,7 @@ export async function extractViaSubagent(sessionId, transcript, opts = {}) {
             // Mirrors the stage-1 job lease (1h): codex has no per-request timeout,
             // and a near-600k-char transcript on a slow model can easily exceed a
             // short one — repeated timeouts would exhaust the job's retries.
-            timeoutMs: 3600_000,
+            timeoutMs: opts.timeoutMs ?? 3600_000,
             system: readTemplate("stage_one_system.md"),
             model,
             // opencode enforces json_schema output via a forced StructuredOutput tool
@@ -190,31 +247,54 @@ export async function consolidateViaSubagent(memoryRoot, diffFileName, model) {
 // Must exceed the longest legitimate sub-session lifetime (consolidation may
 // run up to CONSOLIDATION_TIMEOUT_MS = 60min), or a second opencode instance /
 // plugin reload would delete a working sub-session mid-run.
-export async function cleanupOldSubSessions(maxAgeMinutes = 90) {
+export async function cleanupOldSubSessions(maxAgeMinutes = 90, timeoutMs = SUBSESSION_LIST_TIMEOUT_MS) {
     const input = getPluginInput();
     if (!input)
         return;
+    let timer;
     try {
-        const res = await input.client.session.list();
+        if (typeof input.client?.session?.list !== "function")
+            return;
+        const res = await Promise.race([
+            input.client.session.list(),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`session.list timed out after ${timeoutMs}ms`)), timeoutMs);
+            }),
+        ]);
         if (!res.data)
             return;
         const list = res.data;
         const cutoff = Date.now() - maxAgeMinutes * 60 * 1000;
         for (const s of list) {
-            if (s.title && s.title.startsWith("codex-memory-")) {
-                const created = s.time?.created ?? 0;
-                if (created && created < cutoff) {
-                    await deleteSession(s.id);
-                }
+            if (!s.id)
+                continue;
+            const pluginTitle = isPluginSubSessionTitle(s.title);
+            const owned = s.metadata?.[SUBSESSION_METADATA_KEY] === true && pluginTitle;
+            const legacy = s.metadata?.[SUBSESSION_METADATA_KEY] !== true && pluginTitle;
+            if (!owned && !legacy)
+                continue;
+            // Durable ownership requires marker + generated title; a legacy title
+            // alone can reseed the skip set but never authorizes deletion.
+            activeSubSessions.add(s.id);
+            if (!owned)
+                continue;
+            const created = s.time?.created ?? 0;
+            if (created && created < cutoff) {
+                void deleteSession(s.id);
             }
         }
     }
     catch {
         // best effort only
     }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function isPluginSubSessionTitle(title) {
+    return title === "codex-memory-consolidate" || /^codex-memory-extract-ses_[A-Za-z0-9]+$/.test(title ?? "");
 }
 async function deleteSession(id) {
-    activeSubSessions.delete(id);
     const input = getPluginInput();
     if (!input)
         return;
@@ -222,12 +302,44 @@ async function deleteSession(id) {
         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;
+        }
+        // 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.
+        if (await sessionDeletionConfirmed(input.client, id)) {
+            activeSubSessions.delete(id);
         }
     }
     catch (err) {
         console.warn(`[opencode-codex-memory] error deleting sub-session ${id}:`, err);
     }
 }
+async function sessionDeletionConfirmed(client, id) {
+    const session = client.session;
+    if (typeof session?.get !== "function")
+        return false;
+    const controller = new AbortController();
+    let timer;
+    try {
+        const res = await Promise.race([
+            session.get({ path: { id }, signal: controller.signal }),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    controller.abort();
+                    reject(new Error(`session.get timed out after ${SUBSESSION_CONFIRM_TIMEOUT_MS}ms`));
+                }, SUBSESSION_CONFIRM_TIMEOUT_MS);
+            }),
+        ]);
+        return res?.response?.status === 404;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 // Substitute with a function so `$&`/`$'` sequences in the value are not
 // expanded as String.replace replacement patterns.
 export function fillTemplate(tmpl, vars) {

package/dist/src/options.d.ts

@@ -26,5 +26,7 @@ export interface PluginOptionsState {
 export declare const pluginOptions: PluginOptionsState;
 export declare function recordConfigWarning(message: string): void;
 export declare function getConfigWarnings(): readonly string[];
+/** Drop warnings from a previous apply pass (server boot / option re-apply). */
+export declare function clearConfigWarnings(): void;
 /** Test seam: options/warnings are module state, tests need a clean slate. */
 export declare function resetConfigWarningsForTest(): void;

package/dist/src/options.js

@@ -25,7 +25,11 @@ export function recordConfigWarning(message) {
 export function getConfigWarnings() {
     return configWarnings;
 }
+/** Drop warnings from a previous apply pass (server boot / option re-apply). */
+export function clearConfigWarnings() {
+    configWarnings.length = 0;
+}
 /** Test seam: options/warnings are module state, tests need a clean slate. */
 export function resetConfigWarningsForTest() {
-    configWarnings.length = 0;
+    clearConfigWarnings();
 }

package/dist/src/path-guard.d.ts

@@ -17,3 +17,5 @@
  */
 export declare function assertMemoryRootSafe(): string;
 export declare function safeResolveMemoryPath(rel: string): string;
+/** Resolve a relative path under an arbitrary trusted root without following symlinks. */
+export declare function safeResolveUnderRoot(root: string, rel: string): string;

package/dist/src/path-guard.js

@@ -34,9 +34,26 @@ export function assertMemoryRootSafe() {
 }
 export function safeResolveMemoryPath(rel) {
     const root = assertMemoryRootSafe();
+    return safeResolveUnderRoot(root, rel);
+}
+/** Resolve a relative path under an arbitrary trusted root without following symlinks. */
+export function safeResolveUnderRoot(root, rel) {
     if (path.isAbsolute(rel)) {
         throw new Error(`path escapes memory root: ${rel}`);
     }
+    try {
+        const rootStat = fs.lstatSync(root);
+        if (rootStat.isSymbolicLink()) {
+            throw new Error(`root is a symlink; refusing write: ${root}`);
+        }
+        if (!rootStat.isDirectory()) {
+            throw new Error(`root is not a directory: ${root}`);
+        }
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
     const parts = rel.split(/[\\/]+/).filter((p) => p.length > 0 && p !== ".");
     let current = root;
     for (const part of parts) {

package/dist/src/phase1.js

@@ -64,7 +64,7 @@ export async function runPhase1(store, opts = DEFAULT_PHASE1_OPTIONS) {
             });
         }
         catch (err) {
-            store.markStage1Failed(sid, claim.ownershipToken, err.message);
+            store.markStage1Failed(sid, claim.ownershipToken, err);
         }
     });
 }

package/dist/src/phase2.d.ts

@@ -1,4 +1,5 @@
 import { MemoryStore } from "./store.js";
+import { checkRateLimit } from "./ratelimit.js";
 import { type CodexInteropOptions } from "./codex-interop.js";
 export interface Phase2Options {
     maxRaw: number;
@@ -10,6 +11,6 @@ export interface Phase2Options {
 export declare const DEFAULT_PHASE2_OPTIONS: Phase2Options;
 /** True while THIS process runs a consolidation (memory_reset refuses then). */
 export declare function isPhase2InFlight(): boolean;
-export declare function runPhase2(store: MemoryStore, opts?: Phase2Options): Promise<{
+export declare function runPhase2(store: MemoryStore, opts?: Phase2Options, rateLimitCheck?: typeof checkRateLimit): Promise<{
     status: string;
 }>;

package/dist/src/phase2.js

@@ -27,21 +27,23 @@ let phase2InFlight = false;
 export function isPhase2InFlight() {
     return phase2InFlight;
 }
-export async function runPhase2(store, opts = DEFAULT_PHASE2_OPTIONS) {
+export async function runPhase2(store, opts = DEFAULT_PHASE2_OPTIONS, rateLimitCheck = checkRateLimit) {
     if (phase2InFlight)
         return { status: "already_running" };
     phase2InFlight = true;
     try {
-        const rl = await checkRateLimit("phase2");
+        const rl = await rateLimitCheck("phase2");
         if (!rl.ok)
             return { status: "skipped_rate_limit" };
         const claim = store.claimGlobalPhase2Job();
         if (claim.type !== "claimed")
             return { status: claim.type };
-        // Resolved once per claimed job (not per attempt): resolution warns on
-        // misconfiguration, and warning on every skipped attempt would be noise.
-        const interop = opts.codexInterop ? resolveCodexInterop(opts.codexInterop) : null;
         try {
+            // Resolved once per claimed job (not per attempt): resolution warns on
+            // misconfiguration, and warning on every skipped attempt would be noise.
+            // Keep this inside the claimed-job try so resolution failures release
+            // the lease instead of leaving the row running until it expires.
+            const interop = opts.codexInterop ? resolveCodexInterop(opts.codexInterop) : null;
             ensureLayout();
             // Preserves an existing baseline (only initializes a missing one): the
             // diff below must span last-successful-run -> now so user edits and
@@ -100,10 +102,8 @@ export async function runPhase2(store, opts = DEFAULT_PHASE2_OPTIONS) {
                     console.warn("[opencode-codex-memory] phase2 heartbeat error:", err);
                 }
             }, 90_000);
-            let agentCompleted = false;
             try {
                 await consolidateViaSubagent(memoryRoot(), DIFF_ARTIFACT, opts.consolidationModel);
-                agentCompleted = true;
             }
             finally {
                 clearInterval(heartbeat);
@@ -118,10 +118,6 @@ export async function runPhase2(store, opts = DEFAULT_PHASE2_OPTIONS) {
                 store.markPhase2Failed(claim.ownershipToken, "ownership lost");
                 return { status: "heartbeat_lost" };
             }
-            if (!agentCompleted) {
-                store.markPhase2Failed(claim.ownershipToken, "failed_agent");
-                return { status: "failed_agent" };
-            }
             // codex failed_invalid_artifacts: do not reset baseline on bad output so
             // the next run still sees a diff / can re-INIT.
             const artifacts = validateConsolidationArtifacts();
@@ -139,7 +135,7 @@ export async function runPhase2(store, opts = DEFAULT_PHASE2_OPTIONS) {
             return { status: "succeeded" };
         }
         catch (err) {
-            store.markPhase2Failed(claim.ownershipToken, err.message);
+            store.markPhase2Failed(claim.ownershipToken, err);
             return { status: "failed" };
         }
     }

package/dist/src/redact.d.ts

@@ -4,5 +4,13 @@ export declare function redact(text: string): string;
  * injected AGENTS.md instruction blocks and <skill> payloads inside user
  * content are contextual boilerplate, not conversation — they must not be
  * mined for memories.
+ *
+ * NOTE: inert on opencode today, kept for codex parity and future-proofing.
+ * opencode delivers both of these through the SYSTEM prompt, never as a user
+ * text part: AGENTS.md is joined into `system[0]` and skills are a
+ * `<available_skills>` catalog (skill/index.ts `fmt`), so neither shape ever
+ * reaches this check. Do not treat it as an active safeguard — the structural
+ * filters in capture.ts (`ignored` parts) are what actually exclude
+ * non-conversation content on this platform.
  */
 export declare function isMemoryExcludedFragment(text: string): boolean;