opencode-codex-memory 0.1.9 → 0.2.1

package/dist/src/llm.d.ts

@@ -5,6 +5,7 @@ export interface ExtractionResult {
     rollout_slug: string | null;
 }
 export declare function setPluginInput(input: PluginInput): void;
+export declare function getPluginInput(): PluginInput | null;
 export declare function isMemorySubSession(sessionId: string): boolean;
 export interface ExtractOptions {
     cwd?: string;

package/dist/src/llm.js

@@ -4,7 +4,7 @@ let inputRef = null;
 export function setPluginInput(input) {
     inputRef = input;
 }
-function getPluginInput() {
+export function getPluginInput() {
     return inputRef;
 }
 // Sessions this plugin spawned for extraction/consolidation. The main

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

@@ -7,4 +7,13 @@
  * - every existing component is lstat-checked: symlinks are rejected, so a
  *   link placed inside the workspace cannot lead reads outside it
  */
+/**
+ * The memory root itself must not be a symlink: every scoped resolution and
+ * every workspace walk starts there, so a symlinked root would redirect ALL
+ * memory reads/writes elsewhere on disk. codex rejects a symlinked root when
+ * clearing (control.rs clear_memory_root_contents); the model-facing tools
+ * here extend that check to every memory operation. Returns the root path.
+ * A missing root is fine — callers create it as a real directory.
+ */
+export declare function assertMemoryRootSafe(): string;
 export declare function safeResolveMemoryPath(rel: string): string;

package/dist/src/path-guard.js

@@ -10,8 +10,30 @@ import { memoryRoot } from "./paths.js";
  * - every existing component is lstat-checked: symlinks are rejected, so a
  *   link placed inside the workspace cannot lead reads outside it
  */
-export function safeResolveMemoryPath(rel) {
+/**
+ * The memory root itself must not be a symlink: every scoped resolution and
+ * every workspace walk starts there, so a symlinked root would redirect ALL
+ * memory reads/writes elsewhere on disk. codex rejects a symlinked root when
+ * clearing (control.rs clear_memory_root_contents); the model-facing tools
+ * here extend that check to every memory operation. Returns the root path.
+ * A missing root is fine — callers create it as a real directory.
+ */
+export function assertMemoryRootSafe() {
     const root = memoryRoot();
+    let st = null;
+    try {
+        st = fs.lstatSync(root);
+    }
+    catch {
+        return root;
+    }
+    if (st.isSymbolicLink()) {
+        throw new Error(`memory root is a symlink; refusing memory operations: ${root}`);
+    }
+    return root;
+}
+export function safeResolveMemoryPath(rel) {
+    const root = assertMemoryRootSafe();
     if (path.isAbsolute(rel)) {
         throw new Error(`path escapes memory root: ${rel}`);
     }

package/dist/src/paths.d.ts

@@ -1,4 +1,3 @@
 export declare function memoryRoot(): string;
 export declare function memoryDbPath(): string;
-export declare function opencodeDbPath(): string;
 export declare function memorySummaryPath(): string;

package/dist/src/paths.js

@@ -15,9 +15,6 @@ export function memoryRoot() {
 export function memoryDbPath() {
     return path.join(dataRoot(), MEMORY_DB_NAME);
 }
-export function opencodeDbPath() {
-    return path.join(dataRoot(), "opencode.db");
-}
 export function memorySummaryPath() {
     return path.join(memoryRoot(), "memory_summary.md");
 }

package/dist/src/phase1.d.ts

@@ -9,3 +9,4 @@ export interface Phase1Options {
 }
 export declare const DEFAULT_PHASE1_OPTIONS: Phase1Options;
 export declare function runPhase1(store: MemoryStore, opts?: Phase1Options): Promise<void>;
+export declare function buildTranscript(sessionId: string): Promise<string>;

package/dist/src/phase1.js

@@ -26,7 +26,7 @@ export async function runPhase1(store, opts = DEFAULT_PHASE1_OPTIONS) {
         console.warn("[opencode-codex-memory] skipping phase1 due to rate limit:", rl.reason);
         return;
     }
-    const eligible = selectEligibleSessions(store, opts);
+    const eligible = await selectEligibleSessions(store, opts);
     if (eligible.length === 0)
         return;
     const claimed = store.claimStage1Jobs(eligible, opts.excludeSession, opts.maxClaimed);
@@ -38,7 +38,7 @@ export async function runPhase1(store, opts = DEFAULT_PHASE1_OPTIONS) {
         try {
             const session = sessionById.get(sid);
             const sourceUpdatedAt = session?.updated_at ?? Date.now();
-            const transcript = buildTranscript(sid);
+            const transcript = await buildTranscript(sid);
             if (!transcript.trim()) {
                 store.markStage1SucceededNoOutput(sid, claim.ownershipToken, sourceUpdatedAt);
                 return;
@@ -68,14 +68,19 @@ export async function runPhase1(store, opts = DEFAULT_PHASE1_OPTIONS) {
         }
     });
 }
-function buildTranscript(sessionId) {
-    const msgs = loadTranscript(sessionId);
+export async function buildTranscript(sessionId) {
+    const msgs = await loadTranscript(sessionId);
     if (msgs.length === 0)
         return "";
     const lines = [];
     for (const m of msgs) {
         if (m.type === "system")
             continue;
+        // codex sanitize_response_item_for_memories drops developer-role messages
+        // entirely (injected instructions, not conversation). opencode 1.17 only
+        // stores user/assistant roles; this guards future role additions.
+        if (m.role === "developer")
+            continue;
         const role = m.role ?? m.type;
         const text = m.text ?? "";
         if (!text.trim())

package/dist/src/phase2.d.ts

@@ -6,6 +6,8 @@ export interface Phase2Options {
     consolidationModel?: string;
 }
 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<{
     status: string;
 }>;

package/dist/src/phase2.js

@@ -10,6 +10,10 @@ export const DEFAULT_PHASE2_OPTIONS = {
     extensionRetentionDays: 7,
 };
 let phase2InFlight = false;
+/** True while THIS process runs a consolidation (memory_reset refuses then). */
+export function isPhase2InFlight() {
+    return phase2InFlight;
+}
 export async function runPhase2(store, opts = DEFAULT_PHASE2_OPTIONS) {
     if (phase2InFlight)
         return { status: "already_running" };

package/dist/src/redact.js

@@ -10,8 +10,11 @@ const REDACTIONS = [
         re: /-----BEGIN [A-Z]+ PRIVATE KEY-----[\s\S]*?-----END [A-Z]+ PRIVATE KEY-----/g,
         replacement: "[REDACTED:private-key]",
     },
-    { re: /(password|passwd|pwd|secret|api[_-]?key|token|access[_-]?token)\s*[:=]\s*["']?[^\s"']{4,}["']?/gi, replacement: "$1=[REDACTED]" },
-    { re: /(?:aws_secret_access_key|aws_access_key_id)\s*[:=]\s*["']?[^\s"']{4,}["']?/gi, replacement: "$1=[REDACTED]" },
+    // Optional quotes around the KEY cover JSON/YAML forms like
+    // "password": "value" — codex's SECRET_ASSIGNMENT_REGEX misses those (it
+    // allows a quote only before the value); this is a deliberate superset.
+    { re: /["']?(password|passwd|pwd|secret|api[_-]?key|token|access[_-]?token)["']?\s*[:=]\s*["']?[^\s"']{4,}["']?/gi, replacement: "$1=[REDACTED]" },
+    { re: /["']?(aws_secret_access_key|aws_access_key_id)["']?\s*[:=]\s*["']?[^\s"']{4,}["']?/gi, replacement: "$1=[REDACTED]" },
 ];
 export function redact(text) {
     let out = text;

package/dist/src/store.d.ts

@@ -69,6 +69,11 @@ 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. */
+    phase2LastSuccess(): {
+        finished_at: number | null;
+        last_success_watermark: number | null;
+    } | null;
     markPhase2Failed(ownershipToken: string, error: string): void;
     /**
      * Phase 2 input set, mirroring codex get_phase2_input_selection:

package/dist/src/store.js

@@ -269,19 +269,35 @@ export class MemoryStore {
         // codex stores the completion watermark = max source_updated_at consumed;
         // the 6h cooldown is keyed on finished_at, not on this value.
         const watermark = selected.reduce((max, s) => Math.max(max, s.source_updated_at), 0);
-        const res = this.db
-            .prepare(`UPDATE memory_jobs SET status='done', finished_at=?, lease_until=NULL, last_error=NULL, retry_remaining=?,
-           last_success_watermark=MAX(COALESCE(last_success_watermark, 0), ?), retry_at=NULL
-         WHERE kind='memory_consolidate_global' AND job_key='global' AND ownership_token=? AND status='running'`)
-            .run(nowSec(), DEFAULT_RETRY_REMAINING, watermark, ownershipToken);
-        if (res.changes === 0)
-            return;
-        this.db.exec("UPDATE memory_stage1_outputs SET selected_for_phase2 = 0, selected_for_phase2_source_updated_at = NULL");
-        const mark = this.db.prepare(`UPDATE memory_stage1_outputs
-       SET selected_for_phase2 = 1, selected_for_phase2_source_updated_at = ?
-       WHERE session_id = ? AND source_updated_at = ?`);
-        for (const s of selected)
-            mark.run(s.source_updated_at, s.session_id, s.source_updated_at);
+        // One transaction for the job row + the selected-input flags (codex
+        // mark_global_phase2_job_succeeded does the same): a crash between them
+        // must not leave a done job whose retention flags still describe the
+        // previous run — pruning could then delete inputs backing the artifacts.
+        this.db.transaction(() => {
+            const res = this.db
+                .prepare(`UPDATE memory_jobs SET status='done', finished_at=?, lease_until=NULL, last_error=NULL, retry_remaining=?,
+             last_success_watermark=MAX(COALESCE(last_success_watermark, 0), ?), retry_at=NULL
+           WHERE kind='memory_consolidate_global' AND job_key='global' AND ownership_token=? AND status='running'`)
+                .run(nowSec(), DEFAULT_RETRY_REMAINING, watermark, ownershipToken);
+            if (res.changes === 0)
+                return;
+            this.db.exec("UPDATE memory_stage1_outputs SET selected_for_phase2 = 0, selected_for_phase2_source_updated_at = NULL");
+            const mark = this.db.prepare(`UPDATE memory_stage1_outputs
+         SET selected_for_phase2 = 1, selected_for_phase2_source_updated_at = ?
+         WHERE session_id = ? AND source_updated_at = ?`);
+            for (const s of selected)
+                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() {
+        const row = this.db
+            .prepare(`SELECT finished_at, last_success_watermark FROM memory_jobs
+         WHERE kind='memory_consolidate_global' AND job_key='global'`)
+            .get();
+        if (!row || !row.last_success_watermark)
+            return null;
+        return row;
     }
     markPhase2Failed(ownershipToken, error) {
         const res = this.db

package/dist/src/workspace.js

@@ -166,9 +166,10 @@ export function pruneExtensionResources(retentionDays) {
     const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
     for (const extName of fs.readdirSync(extensionsDir)) {
         const extDir = path.join(extensionsDir, extName);
+        // lstat: never prune through a symlinked extension dir.
         let extStat;
         try {
-            extStat = fs.statSync(extDir);
+            extStat = fs.lstatSync(extDir);
         }
         catch {
             continue;
@@ -213,8 +214,12 @@ export function writeWorkspaceDiff(diff) {
             rendered += `- ${change.status} ${change.path}\n`;
         }
         let body = diff.unifiedDiff;
-        if (body.length > WORKSPACE_DIFF_MAX_BYTES) {
-            body = body.slice(0, WORKSPACE_DIFF_MAX_BYTES) + `\n[workspace diff truncated at ${WORKSPACE_DIFF_MAX_BYTES} bytes]\n`;
+        // The cap is in BYTES: .length counts UTF-16 code units and undercounts
+        // multibyte content. Cut on the byte buffer and drop a split trailing char.
+        if (Buffer.byteLength(body, "utf8") > WORKSPACE_DIFF_MAX_BYTES) {
+            body =
+                Buffer.from(body, "utf8").subarray(0, WORKSPACE_DIFF_MAX_BYTES).toString("utf8").replace(/\uFFFD+$/, "") +
+                    `\n[workspace diff truncated at ${WORKSPACE_DIFF_MAX_BYTES} bytes]\n`;
         }
         rendered += "\n## Diff\n\n```diff\n" + body + (body.endsWith("\n") ? "" : "\n") + "```\n";
     }

package/dist/tools/control.js

@@ -5,32 +5,34 @@ import { memoryRoot, memorySummaryPath } from "../src/paths.js";
 import { MemoryStore } from "../src/store.js";
 import { invalidateCache } from "../src/source.js";
 import { estimateTokens } from "../src/token.js";
+import { assertMemoryRootSafe } from "../src/path-guard.js";
+import { isPhase2InFlight } from "../src/phase2.js";
 function isSymlinkedRoot() {
-    const root = memoryRoot();
     try {
-        return fs.lstatSync(root).isSymbolicLink();
+        assertMemoryRootSafe();
+        return false;
     }
     catch {
-        return false;
+        return true;
     }
 }
 // Mirrors codex clear_memory_root_contents: deletes EVERY entry including
 // .git, so previously deleted/redacted memory content is not recoverable
-// from git history after a reset.
+// from git history after a reset. Deletion errors PROPAGATE — codex bubbles
+// every remove failure up, and a swallowed error here would report a
+// successful reset while secrets/memories survive on disk. lstat semantics:
+// a symlinked entry is unlinked itself, never followed.
 function wipeMemoriesDir() {
     const root = memoryRoot();
     if (!fs.existsSync(root))
         return;
     for (const entry of fs.readdirSync(root)) {
         const abs = path.join(root, entry);
-        try {
-            const stat = fs.statSync(abs);
-            if (stat.isDirectory())
-                fs.rmSync(abs, { recursive: true, force: true });
-            else
-                fs.unlinkSync(abs);
-        }
-        catch { }
+        const st = fs.lstatSync(abs);
+        if (st.isDirectory())
+            fs.rmSync(abs, { recursive: true, force: true });
+        else
+            fs.unlinkSync(abs);
     }
 }
 function listMemoriesDir() {
@@ -44,14 +46,19 @@ function listMemoriesDir() {
                 continue;
             const abs = path.join(dir, name);
             const rel = prefix ? `${prefix}/${name}` : name;
+            // lstat: report symlinks as entries but never walk THROUGH them —
+            // a link to a big/looping directory must not be followed.
             let stat;
             try {
-                stat = fs.statSync(abs);
+                stat = fs.lstatSync(abs);
             }
             catch {
                 continue;
             }
-            if (stat.isDirectory()) {
+            if (stat.isSymbolicLink()) {
+                out.push(`${rel}@`);
+            }
+            else if (stat.isDirectory()) {
                 out.push(`${rel}/`);
                 walk(abs, rel);
             }
@@ -76,6 +83,15 @@ export const memory_reset = tool({
         if (isSymlinkedRoot()) {
             return { output: "Reset refused: memory root is a symlink. Remove it manually to be safe." };
         }
+        // A consolidation running in THIS process would recreate files right
+        // after the wipe (the sub-agent edits live artifacts and resets the git
+        // baseline). Refuse instead of racing it. Cross-process consolidators
+        // are still ownership-guarded DB-side (the wiped job rows make their
+        // final confirmation a no-op) but may leave stray files; same window
+        // codex has between CLI clear and a running daemon.
+        if (isPhase2InFlight()) {
+            return { output: "Reset refused: memory consolidation is currently running. Try again in a few minutes." };
+        }
         try {
             const store = new MemoryStore();
             store.clearMemoryData();
@@ -96,6 +112,8 @@ export const memory_inspect = tool({
     args: {},
     async execute() {
         try {
+            // Refuse to walk/report through a symlinked root (same rule as reset).
+            assertMemoryRootSafe();
             const store = new MemoryStore();
             const outputs = store.stage1Outputs();
             const summaryPath = memorySummaryPath();
@@ -107,8 +125,14 @@ 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 ? new Date(phase2.last_success_watermark).toISOString() : "none";
+            const finishedAt = phase2?.finished_at ? new Date(phase2.finished_at * 1000).toISOString() : "none";
             const out = [
                 `stage1_outputs: ${outputs.length}`,
+                `phase2_last_success_watermark: ${watermark}`,
+                `phase2_last_finished_at: ${finishedAt}`,
                 `memory_summary_chars: ${summaryChars}`,
                 `memory_summary_tokens_est: ${summaryTokens}`,
                 `memories_dir_entries: ${listing.length}`,
@@ -120,6 +144,8 @@ export const memory_inspect = tool({
                 output: out,
                 metadata: {
                     stage1_count: outputs.length,
+                    phase2_last_success_watermark: phase2?.last_success_watermark ?? null,
+                    phase2_last_finished_at: phase2?.finished_at ?? null,
                     summary_chars: summaryChars,
                     summary_tokens_est: summaryTokens,
                     files: listing,

package/dist/tools/memory.d.ts

@@ -25,16 +25,32 @@ export declare const memory_list: {
 export declare const memory_search: {
     description: string;
     args: {
-        query: import("zod").ZodOptional<import("zod").ZodString>;
+        queries: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        match_mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            any: "any";
+            all_on_same_line: "all_on_same_line";
+            all_within_lines: "all_within_lines";
+        }>>;
+        line_count: import("zod").ZodOptional<import("zod").ZodNumber>;
+        path: import("zod").ZodOptional<import("zod").ZodString>;
+        cursor: import("zod").ZodOptional<import("zod").ZodString>;
+        context_lines: import("zod").ZodDefault<import("zod").ZodNumber>;
         case_sensitive: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        normalized: import("zod").ZodDefault<import("zod").ZodBoolean>;
         since: import("zod").ZodOptional<import("zod").ZodString>;
         until: import("zod").ZodOptional<import("zod").ZodString>;
-        limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+        max_results: import("zod").ZodDefault<import("zod").ZodNumber>;
     };
     execute(args: {
+        match_mode: "any" | "all_on_same_line" | "all_within_lines";
+        context_lines: number;
         case_sensitive: boolean;
-        limit: number;
-        query?: string | undefined;
+        normalized: boolean;
+        max_results: number;
+        queries?: string[] | undefined;
+        line_count?: number | undefined;
+        path?: string | undefined;
+        cursor?: string | undefined;
         since?: string | undefined;
         until?: string | undefined;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;