opencode-codex-memory 0.1.6 → 0.1.8

package/dist/opencode.json

@@ -5,6 +5,7 @@
       "mode": "subagent",
       "prompt": "You are a memory consolidation agent. Read the workspace diff file and update MEMORY.md, memory_summary.md, and skills/ to reflect the latest memories. Keep memory_summary.md under 10000 chars (2500 tokens). Prune stale entries. Do not access the network.",
       "permission": {
+        "*": "deny",
         "bash": "deny",
         "webfetch": "deny",
         "websearch": "deny",
@@ -21,6 +22,7 @@
       "mode": "subagent",
       "prompt": "You are a memory extraction agent. Read the session transcript and extract raw_memory, rollout_summary, and rollout_slug as JSON. Exclude AGENTS.md/instruction content. Redact secrets.",
       "permission": {
+        "*": "deny",
         "bash": "deny",
         "webfetch": "deny",
         "websearch": "deny",

package/dist/src/index.d.ts

@@ -1,5 +1,7 @@
+import { MemoryStore } from "./store.js";
 import type { PluginInput, PluginOptions } from "@opencode-ai/plugin";
 export declare function takeNewCitations(partKey: string, ids: string[]): string[];
+export declare function handleSessionDeleted(sessionId: string, store?: Pick<MemoryStore, "deleteSessionMemory">, schedulePhase2?: () => void): void;
 declare const _default: {
     id: string;
     server(input: PluginInput, opts?: PluginOptions): Promise<{

package/dist/src/index.js

@@ -52,6 +52,10 @@ export function takeNewCitations(partKey, ids) {
         seen.add(id);
     return fresh;
 }
+export function handleSessionDeleted(sessionId, store = getStore(), schedulePhase2 = () => { void triggerPhase2(); }) {
+    if (store.deleteSessionMemory(sessionId))
+        schedulePhase2();
+}
 export default {
     id: "opencode-codex-memory",
     async server(input, opts) {
@@ -267,13 +271,13 @@ function buildHooks() {
                 }
                 if (ev.type === "session.deleted") {
                     // Mirrors codex delete_thread_memory: drop the extracted memory and
-                    // its job when the session is deleted; the file disappears at the
-                    // next phase-2 rebuild and the diff drives forgetting.
+                    // its job when the session is deleted. If phase 2 had consumed it,
+                    // enqueue and attempt consolidation so the diff drives forgetting.
                     const props = ev.properties;
                     const sid = props?.info?.id;
                     if (sid) {
                         try {
-                            getStore().deleteSessionMemory(sid);
+                            handleSessionDeleted(sid);
                         }
                         catch (e) {
                             console.error("[opencode-codex-memory] deleteSessionMemory failed:", e);

package/dist/src/llm.d.ts

@@ -15,5 +15,6 @@ export declare function extractViaSubagent(sessionId: string, transcript: string
 export declare function consolidateViaSubagent(memoryRoot: string, diffFileName: string, model?: string): Promise<void>;
 export declare function cleanupOldSubSessions(maxAgeMinutes?: number): Promise<void>;
 export declare function fillTemplate(tmpl: string, vars: Record<string, string>): string;
+export declare function buildConsolidationPrompt(memoryRoot: string, diffFileName: string): string;
 /** Parses the stage-1 JSON output. Returns null for the all-empty no-op response. */
 export declare function parseExtraction(raw: string): ExtractionResult | null;

package/dist/src/llm.js

@@ -209,10 +209,46 @@ function buildExtractionInput(sessionId, cwd, transcript) {
         transcript,
     });
 }
-function buildConsolidationPrompt(memoryRoot, diffFileName) {
+// codex lib.rs prompt_blocks: rendered into consolidation.md's
+// {{ memory_extensions_* }} placeholders when <memory_root>/extensions exists
+// (prompts.rs build_consolidation_prompt), empty strings otherwise.
+const EXTENSIONS_FOLDER_STRUCTURE = `
+Memory extensions (under {{ memory_extensions_root }}/):
+
+- <extension_name>/instructions.md
+  - Source-specific guidance for interpreting additional memory signals. If an
+    extension folder exists, you must read its instructions.md to determine how to use this memory
+    source.
+
+If the user has any memory extensions, you MUST read the instructions for each extension to
+determine how to use the memory source. If the workspace diff shows deleted extension resource files,
+remove stale memories derived only from those resources. If it has no extension folders, continue
+with the standard memory inputs only.
+`;
+const EXTENSIONS_PRIMARY_INPUTS = `
+Optional source-specific inputs:
+Under \`{{ memory_extensions_root }}/\`:
+
+- \`<extension_name>/instructions.md\`
+  - If extension folders exist, read each instructions.md first and follow it when interpreting
+    that extension's memory source.
+
+If the workspace diff shows deleted memory extension resources, use that extension-specific deletion
+signal to remove stale memories derived only from those resources.
+`;
+export function buildConsolidationPrompt(memoryRoot, diffFileName) {
+    const extensionsRoot = path.join(memoryRoot, "extensions");
+    let extensionsExist = false;
+    try {
+        extensionsExist = fs.statSync(extensionsRoot).isDirectory();
+    }
+    catch { }
+    const blockVars = { memory_extensions_root: extensionsRoot };
     return fillTemplate(readTemplate("consolidation.md"), {
         memory_root: memoryRoot,
         phase2_workspace_diff_file: diffFileName,
+        memory_extensions_folder_structure: extensionsExist ? fillTemplate(EXTENSIONS_FOLDER_STRUCTURE, blockVars) : "",
+        memory_extensions_primary_inputs: extensionsExist ? fillTemplate(EXTENSIONS_PRIMARY_INPUTS, blockVars) : "",
     });
 }
 function readTemplate(name) {
@@ -231,7 +267,8 @@ export function parseExtraction(raw) {
     if (typeof obj.raw_memory !== "string" || typeof obj.rollout_summary !== "string") {
         throw new Error("extraction response missing required fields");
     }
-    if (!obj.raw_memory.trim() && !obj.rollout_summary.trim()) {
+    // codex phase1: either field empty → SucceededNoOutput (not a partial upsert).
+    if (!obj.raw_memory.trim() || !obj.rollout_summary.trim()) {
         return null;
     }
     // Guard against the model echoing the format skeleton from the system prompt.

package/dist/src/phase2.js

@@ -1,4 +1,4 @@
-import { ensureLayout, rebuildRawMemories, writeRolloutSummaries, pruneExtensionResources, writeWorkspaceDiff } from "./workspace.js";
+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 { invalidateCache } from "./source.js";
@@ -37,9 +37,16 @@ export async function runPhase2(store, opts = DEFAULT_PHASE2_OPTIONS) {
             writeRolloutSummaries(outputs);
             pruneExtensionResources(opts.extensionRetentionDays);
             const diff = await captureWorkspaceDiff();
+            // codex: early succeed only when there are no changes AND artifacts are
+            // already valid. Invalid/empty summary (e.g. ensureLayout's empty file)
+            // falls through so the consolidator can INIT/repair.
             if (diff.changes.length === 0) {
-                store.markPhase2Succeeded(claim.ownershipToken, outputs);
-                return { status: "no_workspace_changes" };
+                const valid = validateConsolidationArtifacts();
+                if (valid.ok) {
+                    store.markPhase2Succeeded(claim.ownershipToken, outputs);
+                    return { status: "no_workspace_changes" };
+                }
+                console.warn("[opencode-codex-memory] no workspace changes but artifacts invalid; running consolidator:", valid.reason);
             }
             writeWorkspaceDiff(diff);
             let heartbeatLost = false;
@@ -48,8 +55,10 @@ export async function runPhase2(store, opts = DEFAULT_PHASE2_OPTIONS) {
                     heartbeatLost = true;
                 }
             }, 90_000);
+            let agentCompleted = false;
             try {
                 await consolidateViaSubagent(memoryRoot(), DIFF_ARTIFACT, opts.consolidationModel);
+                agentCompleted = true;
             }
             finally {
                 clearInterval(heartbeat);
@@ -64,6 +73,17 @@ 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();
+            if (!artifacts.ok) {
+                store.markPhase2Failed(claim.ownershipToken, `failed_invalid_artifacts: ${artifacts.reason}`);
+                return { status: "failed_invalid_artifacts" };
+            }
             if (!await resetBaseline()) {
                 store.markPhase2Failed(claim.ownershipToken, "baseline reset failed");
                 return { status: "baseline_reset_failed" };

package/dist/src/store.d.ts

@@ -56,6 +56,11 @@ export declare class MemoryStore {
     /** Extraction succeeded but produced nothing worth keeping: finish the job and drop any stale output. */
     markStage1SucceededNoOutput(sessionId: string, ownershipToken: string, sourceUpdatedAt: number): void;
     markStage1Failed(sessionId: string, ownershipToken: string, error: string): void;
+    /**
+     * Enqueues global consolidation after stage-1 state changes. If phase 2 is
+     * already running, preserve its lease and advance only the input watermark.
+     */
+    private enqueueGlobalConsolidation;
     claimGlobalPhase2Job(): Phase2ClaimResult;
     heartbeatPhase2Job(ownershipToken: string): boolean;
     /**
@@ -74,8 +79,11 @@ export declare class MemoryStore {
      * - ranked by usage, then recency
      */
     getPhase2InputSelection(maxRaw: number, maxUnusedDays: number): Stage1Output[];
-    /** Mirrors codex delete_thread_memory: remove a deleted session's output + job. */
-    deleteSessionMemory(sessionId: string): void;
+    /**
+     * Mirrors codex delete_thread_memory: remove a deleted session's output and
+     * job, then enqueue forgetting if phase 2 had consumed that output.
+     */
+    deleteSessionMemory(sessionId: string): boolean;
     /**
      * codex clear_memory_data deletes extracted memories and jobs but explicitly
      * preserves per-session memory modes: a reset must not re-enable sessions

package/dist/src/store.js

@@ -146,8 +146,10 @@ export class MemoryStore {
                 .run(nowSec(), out.source_updated_at, sessionId, ownershipToken);
             // Ownership lost (lease expired, job re-claimed): do not clobber the new
             // owner's output. Mirrors codex mark_stage1_job_succeeded.
-            if (res.changes > 0)
+            if (res.changes > 0) {
                 this.upsertStage1Output(out);
+                this.enqueueGlobalConsolidation(out.source_updated_at);
+            }
         }).immediate();
     }
     /** Extraction succeeded but produced nothing worth keeping: finish the job and drop any stale output. */
@@ -158,8 +160,11 @@ export class MemoryStore {
             last_success_watermark=?, retry_at=NULL
            WHERE kind='memory_stage1' AND job_key=? AND status='running' AND ownership_token=?`)
                 .run(nowSec(), sourceUpdatedAt, sessionId, ownershipToken);
-            if (res.changes > 0)
-                this.db.prepare("DELETE FROM memory_stage1_outputs WHERE session_id = ?").run(sessionId);
+            if (res.changes === 0)
+                return;
+            const deleted = this.db.prepare("DELETE FROM memory_stage1_outputs WHERE session_id = ?").run(sessionId);
+            if (deleted.changes > 0)
+                this.enqueueGlobalConsolidation(sourceUpdatedAt);
         }).immediate();
     }
     markStage1Failed(sessionId, ownershipToken, error) {
@@ -174,6 +179,32 @@ export class MemoryStore {
          WHERE kind='memory_stage1' AND job_key=? AND status='running' AND ownership_token=?`)
             .run(error.slice(0, 4000), nowSec() + STAGE1_RETRY_DELAY_SECONDS, nowSec(), sessionId, ownershipToken);
     }
+    /**
+     * Enqueues global consolidation after stage-1 state changes. If phase 2 is
+     * already running, preserve its lease and advance only the input watermark.
+     */
+    enqueueGlobalConsolidation(inputWatermark) {
+        this.db
+            .prepare(`INSERT INTO memory_jobs
+          (kind, job_key, status, retry_remaining, input_watermark, last_success_watermark)
+         VALUES ('memory_consolidate_global', 'global', 'pending', ?, ?, 0)
+         ON CONFLICT(kind, job_key) DO UPDATE SET
+           status = CASE
+             WHEN memory_jobs.status = 'running' THEN 'running'
+             ELSE 'pending'
+           END,
+           retry_at = CASE
+             WHEN memory_jobs.status = 'running' THEN memory_jobs.retry_at
+             ELSE NULL
+           END,
+           retry_remaining = MAX(memory_jobs.retry_remaining, excluded.retry_remaining),
+           input_watermark = CASE
+             WHEN excluded.input_watermark > COALESCE(memory_jobs.input_watermark, 0)
+               THEN excluded.input_watermark
+             ELSE COALESCE(memory_jobs.input_watermark, 0) + 1
+           END`)
+            .run(DEFAULT_RETRY_REMAINING, inputWatermark);
+    }
     claimGlobalPhase2Job() {
         const workerId = newId();
         const ownershipToken = newId();
@@ -287,11 +318,21 @@ export class MemoryStore {
          LIMIT ?`)
             .all(cutoff, cutoff, maxRaw);
     }
-    /** Mirrors codex delete_thread_memory: remove a deleted session's output + job. */
+    /**
+     * Mirrors codex delete_thread_memory: remove a deleted session's output and
+     * job, then enqueue forgetting if phase 2 had consumed that output.
+     */
     deleteSessionMemory(sessionId) {
-        this.db.transaction(() => {
-            this.db.prepare("DELETE FROM memory_stage1_outputs WHERE session_id = ?").run(sessionId);
+        return this.db.transaction(() => {
+            const existing = this.db
+                .prepare("SELECT selected_for_phase2 FROM memory_stage1_outputs WHERE session_id = ?")
+                .get(sessionId);
+            const deleted = this.db.prepare("DELETE FROM memory_stage1_outputs WHERE session_id = ?").run(sessionId);
             this.db.prepare("DELETE FROM memory_jobs WHERE kind='memory_stage1' AND job_key = ?").run(sessionId);
+            const shouldConsolidate = deleted.changes > 0 && existing !== null && existing.selected_for_phase2 !== 0;
+            if (shouldConsolidate)
+                this.enqueueGlobalConsolidation(now());
+            return shouldConsolidate;
         }).immediate();
     }
     /**