opencode-codex-memory 0.1.8 → 0.2.0

package/README.md

@@ -8,6 +8,11 @@ It's a single plugin. No core changes, no MCP server, no separate process, no
 cloud service. Everything stays on your machine under
 `~/.local/share/opencode/`.
 
+Despite the name: **no codex subscription or OpenAI account is needed.** This
+project ports the memory *design* from OpenAI's codex to opencode. It works out
+of the box with zero extra configuration and uses whatever models you already
+have set up in opencode.
+
 ## Why
 
 By default every opencode session starts from zero. You re-explain your build
@@ -15,9 +20,9 @@ commands, your code style, and the quirks of each repo over and over.
 
 opencode-codex-memory closes that loop:
 
-- **It learns in the background.** After a session goes idle, the plugin reviews
-  the transcript and extracts durable facts — preferences, project structure,
-  what worked and what didn't.
+- **It learns in the background.** Once a session has been idle for a while
+  (default 6 h), a later background pass reviews the transcript and extracts
+  durable facts — preferences, project structure, what worked and what didn't.
 - **It consolidates.** Periodically it merges those notes into a compact,
   searchable memory, pruning what's stale.
 - **It remembers at the right time.** A short summary is injected into the system
@@ -44,22 +49,30 @@ anything.
 
 2. That's it. The memory workspace is created on first use. Installing the
    plugin is the opt-in: background learning and summary injection are active
-   immediately (codex ships the same system behind an experimental flag with a
-   consent prompt; a standalone memory plugin *is* the consent).
+   immediately (codex ships the same system behind a default-off feature flag
+   with a consent prompt; a standalone memory plugin *is* the consent).
 
 Requires only opencode (official release). Git is bundled (`isomorphic-git`) —
 no `git` binary or any other external tool needed.
 
 The two restricted sub-agents that do the background learning (`memorize`,
-`memorize-extract`) register themselves automatically. To customize one — e.g.
-pin a cheaper model for extraction — define an agent with the same name in your
-own config; your definition wins and the plugin leaves it alone.
+`memorize-extract`) register themselves automatically while background learning
+is enabled. To choose which models
+they use, set the `extract_model` / `consolidation_model` plugin options (see
+[Configuration](#configuration)) — don't override the agents for that. Defining
+an agent with the same name in your own config is only for advanced tweaks
+(e.g. permissions); your definition then replaces the shipped one. If you
+override `memorize`, keep an `external_directory` allow for
+`~/.local/share/opencode/memories/*` (e.g.
+`"external_directory": { "$HOME/.local/share/opencode/memories/*": "allow" }`
+after the wildcard deny) — the memory folder lives outside your project, and
+without that grant opencode blocks the consolidator's file access.
 
 ## Try it
 
-Just use opencode normally. After a session goes idle, the plugin reviews it in
-the background and starts building memory — you don't have to do anything. Come
-back for a later session and ask something like *"what do you know about how I
+Just use opencode normally. Sessions that have been idle for a few hours get
+reviewed in the background and memory starts building up — you don't have to do
+anything. Come back the next day and ask something like *"what do you know about how I
 work?"* or *"what was I doing in this repo?"* and the agent draws on what it
 learned. The more you use it, the more it knows.
 
@@ -82,7 +95,7 @@ echo 'I prefer TypeScript strict mode and 2-space indentation.' \
 
 ```
 ~/.local/share/opencode/
-├── memory.db                       # the plugin's own database (never touches opencode's)
+├── memory.db                       # the plugin's own database (opencode's is only ever read)
 └── memories/
     ├── memory_summary.md           # compact summary injected into the system prompt
     ├── MEMORY.md                   # searchable index of everything learned
@@ -92,16 +105,20 @@ echo 'I prefer TypeScript strict mode and 2-space indentation.' \
 ```
 
 It's all plain files and a local SQLite database. Read them, edit them, delete
-them, or check them into a private repo — it's yours.
+them — it's yours. (The `memories/` folder also holds a few working files and
+an internal `.git/` the plugin uses for change tracking; `memory_reset` wipes
+those too.)
 
 ## Privacy & safety
 
 - **Local only.** Nothing is sent anywhere except through your existing opencode
   provider, using your existing credentials. The plugin holds no keys of its own.
-- **Secrets are redacted** (API keys, tokens, private keys, passwords) before any
-  memory is written or sent to a model.
-- **The learning agents are sandboxed** — they cannot run shell commands or reach
-  the network.
+- **Secrets are redacted** (API keys, tokens, private keys, passwords) from
+  session transcripts and extracted memories before anything is written or sent
+  to a model. Notes you explicitly dictate ("remember that ...") are stored as
+  you said them.
+- **The learning agents are sandboxed** — every tool except reading and editing
+  the memory files is denied, including shell and network access.
 - **Reset is safe.** `memory_reset` refuses to run if the memory folder is a
   symlink, so it can't be tricked into deleting something else.
 - **Web/MCP sessions:** by default, sessions that used web search, fetch, or MCP
@@ -120,8 +137,8 @@ codex's `[memories]` config so the two stay easy to compare:
 | `use_memories` | `true` | Inject the memory summary into the system prompt |
 | `dedicated_tools` | `true` | Expose the `memory_read`/`memory_search`/`memory_list`/`memory_add_note` tools |
 | `disable_on_external_context` | `false` | Exclude sessions that used web/MCP tools from memory |
-| `extract_model` | opencode `small_model`, else current model | Model used for per-session extraction |
-| `consolidation_model` | opencode `model`, else current model | Model used for consolidation |
+| `extract_model` | opencode `small_model`, else see below | Model used for per-session extraction |
+| `consolidation_model` | opencode `model`, else see below | Model used for consolidation |
 | `max_raw_memories_for_consolidation` | `256` | How many raw memories feed each consolidation pass |
 | `max_rollout_age_days` | `10` | Ignore sessions older than this for extraction |
 | `min_rollout_idle_hours` | `6` | How long a session must be idle before it's eligible |
@@ -148,14 +165,33 @@ Model selection mirrors codex's cheap-extraction / capable-consolidation
 split using opencode's own concepts: when `extract_model` is unset, the
 `small_model` from your `opencode.json` is used (codex uses `gpt-5.4-mini`);
 when `consolidation_model` is unset, your main `model` is used (codex uses
-`gpt-5.4`). If neither is configured, both fall back to the session's default
-model. (opencode's *automatic* small-model pick is internal to opencode and
-not exposed to plugins — set `small_model` explicitly to get the cheap
-extraction path.)
+`gpt-5.4`). If neither is configured, the learning sub-agents fall back to
+their own agent-level `model` (if you defined one), else the provider default.
+(opencode's *automatic* small-model pick is internal to opencode and not
+exposed to plugins — set `small_model` explicitly to get the cheap extraction
+path.)
+
+The full precedence per phase: plugin option (`extract_model` /
+`consolidation_model`) → opencode config (`small_model` / `model`) → a `model`
+on your own `memorize-extract`/`memorize` agent definition, if you overrode
+one → the provider's default model. Note that the first two pass the model
+explicitly, so they win over an agent-level `model`.
 
 > Note: `dedicated_tools` defaults to `true` here (codex defaults it to `false`).
 > This is the one intentional default difference — the tools are a core part of a
 > standalone memory plugin. Everything else matches codex's defaults.
+>
+> Turning `dedicated_tools` off keeps background learning, summary injection,
+> and citation tracking working. The injected guidance switches to codex's
+> file-based mode — the agent reads the memory files with its normal file
+> tools and writes "remember this" notes directly into
+> `extensions/ad_hoc/notes/`. Caveat: the memory folder lives outside your
+> project, so opencode raises an `external_directory` permission prompt the
+> first time an agent touches it (allow-always covers later access); agents
+> whose permissions deny that ask cannot use file-based mode. The dedicated
+> tools have no such friction — that's why they are the default. The
+> maintenance tools (`memory_reset`, `memory_inspect`, `memory_mode`) stay
+> available either way.
 
 ## Under the hood
 

package/dist/opencode.json

@@ -20,7 +20,7 @@
     },
     "memorize-extract": {
       "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.",
+      "prompt": "You are a memory extraction agent. The session transcript is provided inline in the prompt. Extract raw_memory, rollout_summary, and rollout_slug as JSON. Exclude AGENTS.md/instruction content. Redact secrets.",
       "permission": {
         "*": "deny",
         "bash": "deny",
@@ -28,11 +28,11 @@
         "websearch": "deny",
         "task": "deny",
         "todowrite": "deny",
-        "read": "allow",
+        "read": "deny",
         "write": "deny",
         "edit": "deny",
-        "glob": "allow",
-        "grep": "allow"
+        "glob": "deny",
+        "grep": "deny"
       }
     }
   }

package/dist/src/capture.d.ts

@@ -1,19 +1,44 @@
-import { MemoryStore } from "./store.js";
+import type { MemoryStore } from "./store.js";
 export interface SessionRow {
     id: string;
     updated_at: number;
     directory: string | null;
 }
-export declare function listRecentSessions(limit?: number): SessionRow[];
+/**
+ * Global session discovery through the official API: opencode's session.list
+ * is project-scoped, so enumerate projects (project.list) and list each one
+ * with scope=project (routes the request to that project's instance AND
+ * widens the filter from the session directory to the whole project).
+ * Instance contexts created this way are cached by the host for the process
+ * lifetime, and the whole pass is rate-limited (30s min interval).
+ *
+ * Fail-safe at two levels: a failed project.list skips the pass ([]), a
+ * failed per-project session.list skips that project — neither claims or
+ * finalizes any job. Transcript loading must NOT be fail-safe — see
+ * loadTranscript.
+ */
+export declare function listRecentSessions(limit?: number): Promise<SessionRow[]>;
 export interface TranscriptMessage {
     type: string;
     role?: string;
     text?: string;
 }
-export declare function loadTranscript(sessionId: string): TranscriptMessage[];
+/**
+ * Transcript loading uses the official API — the same surface opencode's own
+ * UI renders history from; the session-scoped route resolves the right
+ * instance even for sessions from other projects.
+ *
+ * Errors PROPAGATE. An empty result must mean "session has no extractable
+ * content" — a swallowed error here used to surface as a successful
+ * no-output extraction, which deletes any previous extraction for the
+ * session (codex: load_rollout_items errors fail the job, which retries
+ * under its lease/backoff). A claimed session normally has messages, so a
+ * legitimately empty result is logged for observability.
+ */
+export declare function loadTranscript(sessionId: string): Promise<TranscriptMessage[]>;
 export interface EligibilityOptions {
     maxAgeDays: number;
     minIdleHours: number;
     excludeSession?: string;
 }
-export declare function selectEligibleSessions(store: MemoryStore, opts: EligibilityOptions): SessionRow[];
+export declare function selectEligibleSessions(store: MemoryStore, opts: EligibilityOptions): Promise<SessionRow[]>;

package/dist/src/capture.js

@@ -1,76 +1,130 @@
-import { Database } from "bun:sqlite";
-import { opencodeDbPath } from "./paths.js";
 import { SCAN_LIMIT } from "./store.js";
-let opencodeDb = null;
-function openOpencodeDb() {
-    if (opencodeDb)
-        return opencodeDb;
-    const p = opencodeDbPath();
+import { getPluginInput } from "./llm.js";
+const API_TIMEOUT_MS = 60_000;
+async function withTimeout(promise, ms, label) {
+    let timer;
     try {
-        opencodeDb = new Database(p, { readonly: true });
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+            }),
+        ]);
     }
-    catch {
-        opencodeDb = null;
+    finally {
+        clearTimeout(timer);
     }
-    return opencodeDb;
 }
-export function listRecentSessions(limit = SCAN_LIMIT) {
-    const db = openOpencodeDb();
-    if (!db)
+/**
+ * Global session discovery through the official API: opencode's session.list
+ * is project-scoped, so enumerate projects (project.list) and list each one
+ * with scope=project (routes the request to that project's instance AND
+ * widens the filter from the session directory to the whole project).
+ * Instance contexts created this way are cached by the host for the process
+ * lifetime, and the whole pass is rate-limited (30s min interval).
+ *
+ * Fail-safe at two levels: a failed project.list skips the pass ([]), a
+ * failed per-project session.list skips that project — neither claims or
+ * finalizes any job. Transcript loading must NOT be fail-safe — see
+ * loadTranscript.
+ */
+export async function listRecentSessions(limit = SCAN_LIMIT) {
+    const client = getPluginInput()?.client;
+    if (!client?.project?.list || !client?.session?.list)
         return [];
+    let projects;
     try {
-        // Top-level sessions only: task-tool children are summarized into their
-        // parent, and the plugin's own sub-sessions must never be memorized.
-        return db
-            .prepare(`SELECT id, time_updated AS updated_at, directory FROM session
-         WHERE parent_id IS NULL AND title NOT LIKE 'codex-memory-%'
-         ORDER BY time_updated DESC LIMIT ?`)
-            .all(limit);
+        const res = await withTimeout(client.project.list(), API_TIMEOUT_MS, "project.list");
+        if (!res || res.error || !Array.isArray(res.data))
+            throw new Error(`project.list failed: ${JSON.stringify(res?.error ?? {})}`);
+        projects = res.data;
     }
-    catch {
+    catch (err) {
+        console.warn("[opencode-codex-memory] project discovery failed; skipping pass:", err);
         return [];
     }
-}
-export function loadTranscript(sessionId) {
-    const db = openOpencodeDb();
-    if (!db)
-        return [];
-    try {
-        const rows = db
-            .prepare(`SELECT p.data, m.data AS msg_data
-         FROM part p
-         JOIN message m ON p.message_id = m.id
-         WHERE p.session_id = ?
-         ORDER BY p.time_created ASC`)
-            .all(sessionId);
-        return rows.map((r) => {
-            let parsed = {};
-            try {
-                parsed = JSON.parse(r.data);
-            }
-            catch {
+    const all = [];
+    for (const project of projects) {
+        if (!project?.worktree)
+            continue;
+        try {
+            const res = await withTimeout(client.session.list({
+                // scope/roots/limit are in the server's ListQuery since 1.17; the
+                // pinned SDK types lag behind, hence the cast at the call site.
+                query: { directory: project.worktree, scope: "project", roots: true, limit },
+            }), API_TIMEOUT_MS, "session.list");
+            if (!res || res.error || !Array.isArray(res.data))
+                throw new Error(JSON.stringify(res?.error ?? {}));
+            for (const s of res.data) {
+                // Top-level sessions only: task-tool children are summarized into
+                // their parent, and the plugin's own sub-sessions must never be
+                // memorized (roots=true drops children server-side; keep both belts).
+                if (!s?.id || s.parentID)
+                    continue;
+                if (s.title && s.title.startsWith("codex-memory-"))
+                    continue;
+                all.push({ id: s.id, updated_at: s.time?.updated ?? 0, directory: s.directory ?? null });
             }
-            let role;
-            try {
-                const msg = JSON.parse(r.msg_data);
-                role = msg.role;
-            }
-            catch {
-            }
-            return {
-                type: parsed.type ?? "unknown",
-                role,
-                text: extractText(parsed),
-            };
-        });
+        }
+        catch (err) {
+            console.warn(`[opencode-codex-memory] session.list failed for ${project.worktree}; skipping project:`, err);
+        }
     }
-    catch {
+    all.sort((a, b) => b.updated_at - a.updated_at);
+    return all.slice(0, limit);
+}
+/** Official transcript surface: GET /session/{id}/message via the plugin's authenticated client. */
+async function fetchMessagesViaApi(sessionId) {
+    const client = getPluginInput()?.client;
+    if (typeof client?.session?.messages !== "function") {
+        throw new Error("plugin client unavailable; cannot load transcript");
+    }
+    const res = await withTimeout(client.session.messages({ path: { id: sessionId } }), API_TIMEOUT_MS, "session.messages");
+    if (!res || res.error || !Array.isArray(res.data)) {
+        throw new Error(`session.messages failed: ${JSON.stringify(res?.error ?? {})}`);
+    }
+    return res.data;
+}
+/**
+ * Transcript loading uses the official API — the same surface opencode's own
+ * UI renders history from; the session-scoped route resolves the right
+ * instance even for sessions from other projects.
+ *
+ * Errors PROPAGATE. An empty result must mean "session has no extractable
+ * content" — a swallowed error here used to surface as a successful
+ * no-output extraction, which deletes any previous extraction for the
+ * session (codex: load_rollout_items errors fail the job, which retries
+ * under its lease/backoff). A claimed session normally has messages, so a
+ * legitimately empty result is logged for observability.
+ */
+export async function loadTranscript(sessionId) {
+    const rows = await fetchMessagesViaApi(sessionId);
+    if (rows.length === 0) {
+        console.warn(`[opencode-codex-memory] session.messages returned no messages for claimed session ${sessionId}`);
         return [];
     }
+    // One entry per part — the granularity extraction expects.
+    const out = [];
+    for (const row of rows) {
+        const role = row?.info?.role;
+        for (const part of row?.parts ?? []) {
+            out.push({
+                type: part?.type ?? "unknown",
+                role,
+                text: extractText(part),
+            });
+        }
+    }
+    return out;
 }
 function extractText(msg) {
     if (!msg)
         return undefined;
+    // codex excludes reasoning items from extraction transcripts
+    // (rollout policy: ResponseItem::Reasoning => false); opencode reasoning
+    // parts carry `text`, so they must be dropped before the text check.
+    if (msg.type === "reasoning")
+        return undefined;
     if (typeof msg.text === "string")
         return msg.text;
     if (msg.type === "tool") {
@@ -98,11 +152,11 @@ function extractText(msg) {
     }
     return undefined;
 }
-export function selectEligibleSessions(store, opts) {
+export async function selectEligibleSessions(store, opts) {
     const now = Date.now();
     const minUpdated = now - opts.maxAgeDays * 24 * 60 * 60 * 1000;
     const maxUpdated = now - opts.minIdleHours * 60 * 60 * 1000;
-    const sessions = listRecentSessions();
+    const sessions = await listRecentSessions();
     return sessions.filter((s) => {
         if (opts.excludeSession && s.id === opts.excludeSession)
             return false;

package/dist/src/git-baseline.js

@@ -62,8 +62,8 @@ async function commitBaseline(dir) {
  * without any commit gets a fresh baseline.
  */
 export async function ensureBaseline() {
+    const dir = memoryRoot();
     try {
-        const dir = memoryRoot();
         removeDiffArtifact(dir);
         await ensureInit(dir);
         if (!(await hasHeadCommit(dir))) {
@@ -72,8 +72,20 @@ export async function ensureBaseline() {
         return true;
     }
     catch (err) {
-        console.error("[opencode-codex-memory] ensureBaseline error:", err);
-        return false;
+        // codex ensure_git_baseline_repository: unusable/corrupt git metadata is
+        // recovered by a destructive fresh re-init (reset_git_repository_sync)
+        // instead of failing the job forever.
+        console.error("[opencode-codex-memory] ensureBaseline error, re-initializing baseline:", err);
+        try {
+            fs.rmSync(path.join(dir, ".git"), { recursive: true, force: true });
+            await isogit.init({ fs, dir });
+            await commitBaseline(dir);
+            return true;
+        }
+        catch (err2) {
+            console.error("[opencode-codex-memory] baseline re-init failed:", err2);
+            return false;
+        }
     }
 }
 async function readBaselineText(dir, headOid, filepath) {
@@ -93,41 +105,38 @@ function readWorkdirText(dir, filepath) {
         return "";
     }
 }
+// Throws on failure: codex fails the phase-2 job on workspace-status errors
+// (failed_workspace_status). Swallowing the error here would make an errored
+// diff indistinguishable from "no changes" and falsely mark the job succeeded.
 export async function captureWorkspaceDiff() {
+    const dir = memoryRoot();
+    await ensureInit(dir);
+    removeDiffArtifact(dir);
+    const matrix = await isogit.statusMatrix({ fs, dir });
+    const changedRows = matrix.filter(([filepath, head, workdir]) => head !== workdir && filepath !== DIFF_ARTIFACT);
+    const changes = changedRows.map(([filepath, head, workdir]) => {
+        if (head === 0)
+            return { status: "A", path: filepath };
+        if (workdir === 0)
+            return { status: "D", path: filepath };
+        return { status: "M", path: filepath };
+    });
+    let headOid = null;
     try {
-        const dir = memoryRoot();
-        await ensureInit(dir);
-        removeDiffArtifact(dir);
-        const matrix = await isogit.statusMatrix({ fs, dir });
-        const changedRows = matrix.filter(([filepath, head, workdir]) => head !== workdir && filepath !== DIFF_ARTIFACT);
-        const changes = changedRows.map(([filepath, head, workdir]) => {
-            if (head === 0)
-                return { status: "A", path: filepath };
-            if (workdir === 0)
-                return { status: "D", path: filepath };
-            return { status: "M", path: filepath };
-        });
-        let headOid = null;
-        try {
-            headOid = await isogit.resolveRef({ fs, dir, ref: "HEAD" });
-        }
-        catch {
-            // no commits yet — every file diffs against empty
-        }
-        const patches = [];
-        for (const [filepath, head, workdir] of changedRows) {
-            const oldText = head === 1 && headOid ? await readBaselineText(dir, headOid, filepath) : "";
-            const newText = workdir === 0 ? "" : readWorkdirText(dir, filepath);
-            // No per-file cap: codex renders every file's patch in full and relies
-            // on the global 4 MiB truncation in writeWorkspaceDiff.
-            patches.push(createPatch(filepath, oldText, newText));
-        }
-        return { changes, unifiedDiff: patches.join("\n") };
+        headOid = await isogit.resolveRef({ fs, dir, ref: "HEAD" });
     }
-    catch (err) {
-        console.error("[opencode-codex-memory] captureWorkspaceDiff error:", err);
-        return { changes: [], unifiedDiff: "" };
+    catch {
+        // no commits yet — every file diffs against empty
+    }
+    const patches = [];
+    for (const [filepath, head, workdir] of changedRows) {
+        const oldText = head === 1 && headOid ? await readBaselineText(dir, headOid, filepath) : "";
+        const newText = workdir === 0 ? "" : readWorkdirText(dir, filepath);
+        // No per-file cap: codex renders every file's patch in full and relies
+        // on the global 4 MiB truncation in writeWorkspaceDiff.
+        patches.push(createPatch(filepath, oldText, newText));
     }
+    return { changes, unifiedDiff: patches.join("\n") };
 }
 /**
  * Mirrors codex reset_git_repository: delete .git and re-create a fresh

package/dist/src/index.d.ts

@@ -1,6 +1,8 @@
 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 markTurnSeen(sessionId: string): boolean;
+export declare function shouldHandleIdle(sessionId: string, now?: number): boolean;
 export declare function handleSessionDeleted(sessionId: string, store?: Pick<MemoryStore, "deleteSessionMemory">, schedulePhase2?: () => void): void;
 declare const _default: {
     id: string;
@@ -22,16 +24,32 @@ declare const _default: {
             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>;
@@ -131,6 +149,22 @@ declare const _default: {
         }, output: {
             system: string[];
         }): Promise<void>;
+        /**
+         * Fires at text-end, before opencode persists the final part text
+         * (session/processor.ts): the returned text replaces the stored one.
+         * Primary citation seam — records usage and strips the block so neither
+         * the UI nor history ever shows citation markup (matches codex, which
+         * strips from the displayed/persisted message). The event and
+         * messages.transform paths below stay as fallbacks for older opencode
+         * hosts and for history persisted before this hook existed.
+         */
+        "experimental.text.complete"(input: {
+            sessionID: string;
+            messageID: string;
+            partID: string;
+        }, output: {
+            text: string;
+        }): Promise<void>;
         "experimental.chat.messages.transform"(_input: unknown, output: {
             messages: {
                 info: {
@@ -142,6 +176,24 @@ declare const _default: {
                 }[];
             }[];
         }): Promise<void>;
+        /**
+         * Turn start. codex stamps memory_mode at thread creation (session.rs) and
+         * schedules memory work per startup/turn; the first user message is the
+         * closest plugin-visible moment. Stamping here (instead of waiting for the
+         * first idle) means a session created while generate_memories=false keeps
+         * its 'disabled' stamp even if the option flips mid-session, and the
+         * phase-1 pump no longer depends on idle events at all. The idle path
+         * below stays as a second pump trigger; both are cheap (stamp is INSERT OR
+         * IGNORE, the pump is gated by in-flight/rate/claim guards).
+         */
+        "chat.message"(input: {
+            sessionID?: string;
+        }): Promise<void>;
+        "tool.execute.after"(input: {
+            tool: string;
+            sessionID: string;
+            callID: string;
+        }): Promise<void>;
         event(input: {
             event: {
                 type: string;