opencode-codex-memory 0.6.5 → 0.7.0

package/dist/src/store.d.ts

@@ -52,6 +52,12 @@ export declare class MemoryStore {
     pruneStage1Outputs(maxUnusedDays: number): number;
     upsertStage1Output(out: Omit<Stage1Output, "usage_count" | "last_usage">): boolean;
     recordUsage(sessionIds: string[]): void;
+    /**
+     * Record citations from a durable assistant message exactly once. V2 can
+     * observe the same persisted text through session.text.ended and later
+     * context calls, and either observation may happen after a process restart.
+     */
+    recordUsageOnce(sessionId: string, assistantMessageId: string, citedSessionIds: string[]): string[];
     claimStage1Jobs(sessions: ClaimableSession[], excludeSession?: string, maxClaimed?: number): Stage1Claim[];
     markStage1Succeeded(sessionId: string, ownershipToken: string, out: Omit<Stage1Output, "usage_count" | "last_usage">): void;
     /** Extraction succeeded but produced nothing worth keeping: finish the job and drop any stale output. */
@@ -75,7 +81,9 @@ export declare class MemoryStore {
      * already running, preserve its lease and advance only the input watermark.
      */
     private enqueueGlobalConsolidation;
-    claimGlobalPhase2Job(): Phase2ClaimResult;
+    claimGlobalPhase2Job(opts?: {
+        bypassCooldown?: boolean;
+    }): Phase2ClaimResult;
     heartbeatPhase2Job(ownershipToken: string): boolean;
     /**
      * Marks the phase-2 job done and records exactly which stage-1 snapshots the
@@ -95,6 +103,7 @@ export declare class MemoryStore {
         last_error: string | null;
         finished_at: number | null;
         retry_at: number | null;
+        lease_until: number | null;
         success_finished_at: number | null;
         last_success_watermark: number | null;
     } | null;
@@ -108,6 +117,13 @@ export declare class MemoryStore {
      * Plugin dispose/reload: release the global phase-2 job without retry backoff
      * so the next process can reclaim immediately. Ownership-token guarded.
      */
+    /**
+     * Boot-time sweep: a `running` global row whose owning pid is dead can never
+     * be finished by anyone; release it so the next pass can reclaim instead of
+     * waiting the full lease out. Rows from live pids (a peer instance) and rows
+     * without a pid tag (older schema) are left alone.
+     */
+    releaseOrphanedPhase2Job(): boolean;
     releasePhase2OnShutdown(ownershipToken: string): void;
     /**
      * Phase 2 input set, mirroring codex get_phase2_input_selection:

package/dist/src/store.js

@@ -12,6 +12,26 @@ export const PRUNE_BATCH_SIZE = 200;
 function newId() {
     return crypto.randomUUID();
 }
+/**
+ * Phase-2 worker ids embed the owning pid so a later boot can tell a live
+ * peer's lease from one orphaned by a hard kill (host auto-update/restart).
+ */
+const PHASE2_WORKER_PREFIX = `pid:${process.pid}:`;
+function phase2WorkerId() {
+    return `${PHASE2_WORKER_PREFIX}${crypto.randomUUID()}`;
+}
+function pidAlive(pid) {
+    if (pid === process.pid)
+        return true;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // EPERM: exists but not ours. Only ESRCH proves it is gone.
+        return err.code !== "ESRCH";
+    }
+}
 function now() {
     return Date.now();
 }
@@ -98,6 +118,39 @@ export class MemoryStore {
                 stmt.run(ts, id);
         }).immediate();
     }
+    /**
+     * Record citations from a durable assistant message exactly once. V2 can
+     * observe the same persisted text through session.text.ended and later
+     * context calls, and either observation may happen after a process restart.
+     */
+    recordUsageOnce(sessionId, assistantMessageId, citedSessionIds) {
+        const ids = [...new Set(citedSessionIds)];
+        if (!sessionId || !assistantMessageId || ids.length === 0)
+            return [];
+        const fresh = [];
+        const insert = this.db.prepare(`INSERT OR IGNORE INTO memory_citation_usage
+        (session_id, assistant_message_id, cited_session_id, recorded_at)
+       VALUES (?, ?, ?, ?)`);
+        const update = this.db.prepare("UPDATE memory_stage1_outputs SET usage_count = usage_count + 1, last_usage = ? WHERE session_id = ?");
+        const ts = now();
+        this.db.transaction(() => {
+            for (const citedSessionId of ids) {
+                const result = insert.run(sessionId, assistantMessageId, citedSessionId, ts);
+                if (result.changes === 0)
+                    continue;
+                const updated = update.run(ts, citedSessionId);
+                if (updated.changes > 0) {
+                    fresh.push(citedSessionId);
+                }
+                else {
+                    this.db
+                        .prepare("DELETE FROM memory_citation_usage WHERE session_id = ? AND assistant_message_id = ? AND cited_session_id = ?")
+                        .run(sessionId, assistantMessageId, citedSessionId);
+                }
+            }
+        }).immediate();
+        return fresh;
+    }
     claimStage1Jobs(sessions, excludeSession, maxClaimed) {
         const workerId = newId();
         // Cap per-pass claims at codex's max_rollouts_per_startup (max_claimed,
@@ -286,8 +339,8 @@ export class MemoryStore {
            END`)
             .run(DEFAULT_RETRY_REMAINING, inputWatermark);
     }
-    claimGlobalPhase2Job() {
-        const workerId = newId();
+    claimGlobalPhase2Job(opts = {}) {
+        const workerId = phase2WorkerId();
         const ownershipToken = newId();
         const tNow = nowSec();
         const lease = tNow + PHASE2_LEASE_SECONDS;
@@ -309,7 +362,10 @@ export class MemoryStore {
             }
             // codex: cooldown after a clean success (last_error IS NULL AND
             // finished_at within the window); failures fall through to retry_at.
-            if (row.last_error == null && row.finished_at != null && tNow - row.finished_at < PHASE2_COOLDOWN_MS / 1000) {
+            if (!opts.bypassCooldown &&
+                row.last_error == null &&
+                row.finished_at != null &&
+                tNow - row.finished_at < PHASE2_COOLDOWN_MS / 1000) {
                 return { type: "skipped_cooldown" };
             }
             // codex gates on retry_at regardless of status and never exhausts
@@ -378,7 +434,7 @@ export class MemoryStore {
      */
     phase2JobSnapshot() {
         const row = this.db
-            .prepare(`SELECT status, finished_at, last_error, retry_at, last_success_watermark FROM memory_jobs
+            .prepare(`SELECT status, finished_at, last_error, retry_at, lease_until, last_success_watermark FROM memory_jobs
          WHERE kind='memory_consolidate_global' AND job_key='global'`)
             .get();
         if (!row)
@@ -398,6 +454,7 @@ export class MemoryStore {
             last_error: row.last_error,
             finished_at: row.finished_at,
             retry_at: row.retry_at,
+            lease_until: row.lease_until,
             // Codex preserves last_success_watermark across later attempts, while the
             // job finished_at describes only the latest attempt. Never label a failure
             // timestamp as a success finish time.
@@ -447,6 +504,34 @@ export class MemoryStore {
      * Plugin dispose/reload: release the global phase-2 job without retry backoff
      * so the next process can reclaim immediately. Ownership-token guarded.
      */
+    /**
+     * Boot-time sweep: a `running` global row whose owning pid is dead can never
+     * be finished by anyone; release it so the next pass can reclaim instead of
+     * waiting the full lease out. Rows from live pids (a peer instance) and rows
+     * without a pid tag (older schema) are left alone.
+     */
+    releaseOrphanedPhase2Job() {
+        const row = this.db
+            .prepare(`SELECT worker_id FROM memory_jobs
+         WHERE kind='memory_consolidate_global' AND job_key='global' AND status='running'`)
+            .get();
+        const m = row?.worker_id?.match(/^pid:(\d+):/);
+        if (!m)
+            return false;
+        if (pidAlive(Number(m[1])))
+            return false;
+        const res = this.db
+            .prepare(`UPDATE memory_jobs SET
+           status = 'pending',
+           last_error = ?,
+           retry_at = NULL,
+           finished_at = ?,
+           lease_until = NULL,
+           ownership_token = NULL
+         WHERE kind='memory_consolidate_global' AND job_key='global' AND status='running' AND worker_id=?`)
+            .run(`owner pid ${m[1]} exited before finishing`, nowSec(), row.worker_id);
+        return res.changes > 0;
+    }
     releasePhase2OnShutdown(ownershipToken) {
         this.db
             .prepare(`UPDATE memory_jobs SET
@@ -515,6 +600,7 @@ export class MemoryStore {
         this.db.transaction(() => {
             this.db.run("DELETE FROM memory_stage1_outputs");
             this.db.run("DELETE FROM memory_jobs");
+            this.db.run("DELETE FROM memory_citation_usage");
             this.db
                 .prepare(`INSERT INTO memory_jobs
             (kind, job_key, status, finished_at, last_error, retry_remaining, last_success_watermark)

package/dist/src/v2/agents.d.ts

@@ -0,0 +1,53 @@
+export declare const MEMORIZE_AGENT_ID = "memorize";
+export declare const MEMORIZE_EXTRACT_AGENT_ID = "memorize-extract";
+export declare const MEMORIZE_SYSTEM = "You are a memory consolidation agent. Read the workspace diff file and update MEMORY.md, memory_summary.md, and skills/ under the memory workspace only. Do not read or edit project source files outside that memory root. Keep memory_summary.md under 10000 chars (2500 tokens). Prune stale entries. Do not access the network.";
+export declare const MEMORIZE_EXTRACT_SYSTEM = "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.";
+export declare const MEMORIZE_DESCRIPTION = "Memory consolidation agent (opencode-codex-memory)";
+export declare const MEMORIZE_EXTRACT_DESCRIPTION = "Memory extraction agent (opencode-codex-memory)";
+export interface V2AgentDefinition {
+    description: string;
+    mode: "subagent";
+    hidden?: boolean;
+    system: string;
+    permissions: {
+        action: string;
+        resource: string;
+        effect: "allow" | "deny" | "ask";
+    }[];
+}
+/** V2-native memorize definition (V2 action names: edit covers write/patch). */
+export declare function buildMemorizeAgent(): V2AgentDefinition;
+/**
+ * Hidden extraction definition. Unused at runtime (extraction goes through
+ * generate.text), kept for parity with the V1 bundle and the health
+ * snapshot. deny-all: V2 has no StructuredOutput-capture concept, and the
+ * sessionless generate path needs no tools at all.
+ */
+export declare function buildMemorizeExtractAgent(): V2AgentDefinition;
+interface AgentEditorLike {
+    get(id: string): {
+        description?: string;
+        mode?: string;
+        system?: string;
+        permissions?: unknown;
+    } | undefined;
+    update(id: string, update: (agent: Record<string, unknown>) => void): void;
+}
+/**
+ * V2 agent definition converted back to the V1 permission-map shape so the
+ * shared agent-health snapshot (surfaced by memory_inspect) keeps working.
+ */
+export declare function toV1AgentDefinition(def: V2AgentDefinition, agentId?: string): Record<string, unknown>;
+export declare function shippedV1AgentForHealth(): Record<string, unknown>;
+/**
+ * Ensure both sub-agents exist. A user-defined agent of the same name
+ * always wins (mirrors injectAgentDefinitions). Records health for
+ * memory_inspect in both cases.
+ */
+export declare function ensureV2Agents(ctx: {
+    agent: {
+        transform(cb: (editor: AgentEditorLike) => void): Promise<unknown>;
+        get(input: unknown): Promise<unknown>;
+    };
+}): Promise<void>;
+export {};

package/dist/src/v2/agents.js

@@ -0,0 +1,204 @@
+/**
+ * opencode2 agent provisioning.
+ *
+ * V1 ships memorize/memorize-extract via the config hook (opencode.json
+ * `agent` map). V2 has no config hook, but agent.transform's update() creates
+ * a missing agent in the active plugin location, so setup() ensures them here
+ * instead. Helper sessions must run in that same location because V2 agent
+ * registration is location-scoped.
+ *
+ * Both agents ship for parity, with the V1 prompts verbatim. `memorize` does
+ * consolidation work; `memorize-extract` is hidden and unused — extraction
+ * runs through generate.text (inherently tool-less, no session, no agent),
+ * and V1 skips injecting unused agents for the same reason. Keeping the
+ * hidden definition preserves the health snapshot both agents report into.
+ */
+import path from "path";
+import { memoryRoot } from "../paths.js";
+import { pluginOptions } from "../options.js";
+import { recordAgentConfig } from "../agent-health.js";
+export const MEMORIZE_AGENT_ID = "memorize";
+export const MEMORIZE_EXTRACT_AGENT_ID = "memorize-extract";
+export const MEMORIZE_SYSTEM = "You are a memory consolidation agent. Read the workspace diff file and update MEMORY.md, memory_summary.md, and skills/ under the memory workspace only. Do not read or edit project source files outside that memory root. Keep memory_summary.md under 10000 chars (2500 tokens). Prune stale entries. Do not access the network.";
+export const MEMORIZE_EXTRACT_SYSTEM = "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.";
+export const MEMORIZE_DESCRIPTION = "Memory consolidation agent (opencode-codex-memory)";
+export const MEMORIZE_EXTRACT_DESCRIPTION = "Memory extraction agent (opencode-codex-memory)";
+/** V2-native memorize definition (V2 action names: edit covers write/patch). */
+export function buildMemorizeAgent() {
+    return {
+        description: MEMORIZE_DESCRIPTION,
+        mode: "subagent",
+        system: MEMORIZE_SYSTEM,
+        permissions: [
+            { action: "*", resource: "*", effect: "deny" },
+            { action: "read", resource: path.join(memoryRoot(), "*"), effect: "allow" },
+            { action: "edit", resource: path.join(memoryRoot(), "*"), effect: "allow" },
+            { action: "glob", resource: path.join(memoryRoot(), "*"), effect: "allow" },
+            { action: "grep", resource: path.join(memoryRoot(), "*"), effect: "allow" },
+            // Memories live outside every project: without this grant the wildcard
+            // deny blocks consolidation from touching the memory workspace (same
+            // role as external_directory in the V1 definition).
+            { action: "external_directory", resource: path.join(memoryRoot(), "*"), effect: "allow" },
+        ],
+    };
+}
+/**
+ * Hidden extraction definition. Unused at runtime (extraction goes through
+ * generate.text), kept for parity with the V1 bundle and the health
+ * snapshot. deny-all: V2 has no StructuredOutput-capture concept, and the
+ * sessionless generate path needs no tools at all.
+ */
+export function buildMemorizeExtractAgent() {
+    return {
+        description: MEMORIZE_EXTRACT_DESCRIPTION,
+        mode: "subagent",
+        hidden: true,
+        system: MEMORIZE_EXTRACT_SYSTEM,
+        permissions: [{ action: "*", resource: "*", effect: "deny" }],
+    };
+}
+/**
+ * V2 agent definition converted back to the V1 permission-map shape so the
+ * shared agent-health snapshot (surfaced by memory_inspect) keeps working.
+ */
+export function toV1AgentDefinition(def, agentId) {
+    const permission = {};
+    for (const rule of def.permissions) {
+        if (rule.action === "*") {
+            permission["*"] = rule.effect;
+            continue;
+        }
+        if (rule.action === "external_directory") {
+            const cur = (permission.external_directory ?? {});
+            cur[rule.resource] = rule.effect;
+            permission.external_directory = cur;
+            continue;
+        }
+        if (rule.action === "edit") {
+            // V1 names write/patch separately from edit.
+            permission.edit = rule.effect;
+            permission.write = rule.effect;
+            continue;
+        }
+        permission[rule.action] = rule.effect;
+    }
+    if (agentId === MEMORIZE_EXTRACT_AGENT_ID) {
+        // The V1 bundle allows the synthetic StructuredOutput capture tool so
+        // json_schema extraction works; V2 needs no tools for the sessionless
+        // generate path, but health validates the V1 bundle semantics.
+        permission.StructuredOutput = "allow";
+    }
+    return { mode: def.mode, prompt: def.system, description: def.description, permission };
+}
+export function shippedV1AgentForHealth() {
+    return {
+        [MEMORIZE_AGENT_ID]: toV1AgentDefinition(buildMemorizeAgent(), MEMORIZE_AGENT_ID),
+        [MEMORIZE_EXTRACT_AGENT_ID]: toV1AgentDefinition(buildMemorizeExtractAgent(), MEMORIZE_EXTRACT_AGENT_ID),
+    };
+}
+/**
+ * Ensure both sub-agents exist. A user-defined agent of the same name
+ * always wins (mirrors injectAgentDefinitions). Records health for
+ * memory_inspect in both cases.
+ */
+export async function ensureV2Agents(ctx) {
+    const shipped = [
+        [MEMORIZE_AGENT_ID, buildMemorizeAgent()],
+        [MEMORIZE_EXTRACT_AGENT_ID, buildMemorizeExtractAgent()],
+    ];
+    if (!pluginOptions.generate_memories) {
+        recordAgentConfig({ agent: {} }, false, shippedV1AgentForHealth());
+        return;
+    }
+    const effective = {};
+    const missing = [];
+    for (const [id, def] of shipped) {
+        let existing = null;
+        try {
+            const res = (await ctx.agent.get({ agentID: id }));
+            existing = res && typeof res === "object" && "data" in res ? res.data : res;
+        }
+        catch {
+            existing = null;
+        }
+        if (existing && typeof existing === "object") {
+            const cur = existing;
+            if (isShippedIncomplete(id, cur, def)) {
+                missing.push([id, def]);
+            }
+            else {
+                effective[id] = {
+                    mode: cur.mode,
+                    prompt: cur.system,
+                    description: cur.description,
+                    permission: v2PermissionsToV1Map(cur.permissions),
+                };
+            }
+        }
+        else {
+            missing.push([id, def]);
+        }
+    }
+    if (missing.length > 0) {
+        await ctx.agent.transform((editor) => {
+            for (const [id, def] of missing) {
+                editor.update(id, (agent) => {
+                    agent.description = def.description;
+                    agent.mode = def.mode;
+                    if (def.hidden !== undefined)
+                        agent.hidden = def.hidden;
+                    agent.system = def.system;
+                    agent.permissions = def.permissions.map((r) => ({ ...r }));
+                });
+            }
+        });
+        for (const [id, def] of missing) {
+            effective[id] = toV1AgentDefinition(def, id);
+        }
+    }
+    recordAgentConfig({ agent: effective }, true, shippedV1AgentForHealth());
+}
+function isShippedIncomplete(id, existing, shipped) {
+    const system = typeof existing.system === "string"
+        ? existing.system
+        : typeof existing.prompt === "string"
+            ? existing.prompt
+            : "";
+    if (system !== shipped.system)
+        return false;
+    if (typeof existing.description === "string" && existing.description !== shipped.description)
+        return false;
+    if (id !== MEMORIZE_AGENT_ID)
+        return false;
+    const perms = existing.permissions;
+    if (!Array.isArray(perms))
+        return true;
+    return !perms.some((rule) => rule && typeof rule === "object" && rule.action === "external_directory");
+}
+function v2PermissionsToV1Map(permissions) {
+    const out = {};
+    if (!Array.isArray(permissions))
+        return out;
+    for (const rule of permissions) {
+        if (typeof rule?.action !== "string")
+            continue;
+        if (rule.action === "*") {
+            out["*"] = rule.effect;
+            continue;
+        }
+        if (rule.action === "external_directory" && typeof rule.resource === "string") {
+            const cur = (out.external_directory ?? {});
+            cur[rule.resource] = rule.effect;
+            out.external_directory = cur;
+            continue;
+        }
+        if (rule.action === "edit") {
+            out.edit = rule.effect;
+            out.write = rule.effect;
+        }
+        else {
+            out[rule.action] = rule.effect;
+        }
+    }
+    return out;
+}

package/dist/src/v2/citation-overlay.d.ts

@@ -0,0 +1,7 @@
+/**
+ * V2-only citation instructions. V1 `read_path.md` keeps the XML contract;
+ * the TUI renders fenced `memory-citation` blocks, so the V2 context hook
+ * overlays this section onto the shared inject prompt.
+ */
+export declare const V2_CITATION_INSTRUCTIONS = "Memory citation requirements:\n\n- If ANY relevant memory files were used: append exactly one fenced code\n  block with the language tag `memory-citation` as the VERY LAST content of\n  the final reply. Normal responses should include the answer first, then\n  append the block at the end. The host renders this block natively.\n- Use this exact structure for programmatic parsing:\n````\n```memory-citation\nMEMORY.md:234-236|note=build command for the api service\nrollout_summaries/2026-02-17T21-23-02-ln3m-example.md:10-12|note=weekly report format\nsessions: ses_abc123 ses_def456\n```\n````\n- Do not wrap it in `<memory-citation>` XML tags; the fenced form replaces\n  that older format.\n- Citation entry lines are for rendering:\n  - one citation entry per line\n  - format: `<file>:<line_start>-<line_end>|note=<how memory was used>`\n  - use file paths relative to the memory base path (for example, `MEMORY.md`,\n    `rollout_summaries/...`, `skills/...`)\n  - only cite files actually used under the memory base path (do not cite\n    workspace files as memory citations)\n  - if you used `MEMORY.md` and then a rollout summary/skill file, cite both\n  - list entries in order of importance (most important first)\n  - `note` should be short, single-line, and use simple characters only (avoid\n    unusual symbols, no newlines)\n- The final `sessions:` line is for us to track which past sessions you find\n  useful:\n  - one line, space-separated session ids after `sessions:`\n  - session ids look like `ses_...` and appear in rollout summary files and\n    MEMORY.md as `session_id:`\n  - include unique ids only; do not repeat ids\n  - omit the `sessions:` line if no session ids are available\n  - do not include file paths or notes on this line\n  - for every citation entry, try to find and cite the corresponding session id\n- Never include memory citations inside pull-request messages.\n- Never cite blank lines; double-check ranges.\n\n";
+export declare function overlayV2CitationInstructions(prompt: string): string;

package/dist/src/v2/citation-overlay.js

@@ -0,0 +1,52 @@
+/**
+ * V2-only citation instructions. V1 `read_path.md` keeps the XML contract;
+ * the TUI renders fenced `memory-citation` blocks, so the V2 context hook
+ * overlays this section onto the shared inject prompt.
+ */
+export const V2_CITATION_INSTRUCTIONS = `Memory citation requirements:
+
+- If ANY relevant memory files were used: append exactly one fenced code
+  block with the language tag \`memory-citation\` as the VERY LAST content of
+  the final reply. Normal responses should include the answer first, then
+  append the block at the end. The host renders this block natively.
+- Use this exact structure for programmatic parsing:
+\`\`\`\`
+\`\`\`memory-citation
+MEMORY.md:234-236|note=build command for the api service
+rollout_summaries/2026-02-17T21-23-02-ln3m-example.md:10-12|note=weekly report format
+sessions: ses_abc123 ses_def456
+\`\`\`
+\`\`\`\`
+- Do not wrap it in \`<memory-citation>\` XML tags; the fenced form replaces
+  that older format.
+- Citation entry lines are for rendering:
+  - one citation entry per line
+  - format: \`<file>:<line_start>-<line_end>|note=<how memory was used>\`
+  - use file paths relative to the memory base path (for example, \`MEMORY.md\`,
+    \`rollout_summaries/...\`, \`skills/...\`)
+  - only cite files actually used under the memory base path (do not cite
+    workspace files as memory citations)
+  - if you used \`MEMORY.md\` and then a rollout summary/skill file, cite both
+  - list entries in order of importance (most important first)
+  - \`note\` should be short, single-line, and use simple characters only (avoid
+    unusual symbols, no newlines)
+- The final \`sessions:\` line is for us to track which past sessions you find
+  useful:
+  - one line, space-separated session ids after \`sessions:\`
+  - session ids look like \`ses_...\` and appear in rollout summary files and
+    MEMORY.md as \`session_id:\`
+  - include unique ids only; do not repeat ids
+  - omit the \`sessions:\` line if no session ids are available
+  - do not include file paths or notes on this line
+  - for every citation entry, try to find and cite the corresponding session id
+- Never include memory citations inside pull-request messages.
+- Never cite blank lines; double-check ranges.
+
+`;
+export function overlayV2CitationInstructions(prompt) {
+    const start = prompt.indexOf("Memory citation requirements:");
+    const end = prompt.indexOf("Updating memories:");
+    if (start === -1 || end === -1 || end <= start)
+        return `${prompt.trimEnd()}\n\n${V2_CITATION_INSTRUCTIONS}`;
+    return prompt.slice(0, start) + V2_CITATION_INSTRUCTIONS + prompt.slice(end);
+}

package/dist/src/v2/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * opencode2 entry point (re-exported through the package main for
+ * single-entry dual-host support: V1 reads server(), V2 reads id+setup()).
+ */
+import { Plugin } from "@opencode/plugin";
+declare const _default: Plugin.Plugin;
+export default _default;

package/dist/src/v2/index.js

@@ -0,0 +1,10 @@
+/**
+ * opencode2 entry point (re-exported through the package main for
+ * single-entry dual-host support: V1 reads server(), V2 reads id+setup()).
+ */
+import { Plugin } from "@opencode/plugin";
+import { setup } from "./plugin.js";
+export default Plugin.define({
+    id: "opencode-codex-memory",
+    setup,
+});

package/dist/src/v2/injection.d.ts

@@ -0,0 +1,14 @@
+/**
+ * In-process ledger of memory text injected into model requests by the V2
+ * `context` hook. Token counts are the same chars/4 estimate used for the
+ * injection cap, so they are comparable to `memory_inspect`'s
+ * `summary_tokens_est`, not provider-billed tokens.
+ */
+export interface InjectionTotals {
+    tokens: number;
+    requests: number;
+}
+export declare function recordInjection(sessionID: string, tokens: number): void;
+export declare function injectionTotals(): InjectionTotals;
+export declare function sessionInjection(sessionID: string | null | undefined): InjectionTotals;
+export declare function resetInjectionStats(): void;

package/dist/src/v2/injection.js

@@ -0,0 +1,19 @@
+const perSession = new Map();
+let global = { tokens: 0, requests: 0 };
+export function recordInjection(sessionID, tokens) {
+    global = { tokens: global.tokens + tokens, requests: global.requests + 1 };
+    const current = perSession.get(sessionID) ?? { tokens: 0, requests: 0 };
+    perSession.set(sessionID, { tokens: current.tokens + tokens, requests: current.requests + 1 });
+}
+export function injectionTotals() {
+    return { ...global };
+}
+export function sessionInjection(sessionID) {
+    if (!sessionID)
+        return { tokens: 0, requests: 0 };
+    return { ...(perSession.get(sessionID) ?? { tokens: 0, requests: 0 }) };
+}
+export function resetInjectionStats() {
+    perSession.clear();
+    global = { tokens: 0, requests: 0 };
+}

package/dist/src/v2/plugin.d.ts

@@ -0,0 +1,7 @@
+import { type V2Context } from "./shim.js";
+/** Test seam: wait for hook-launched work to settle. */
+export declare function waitForV2BackgroundTasks(): Promise<void>;
+/** Test seam: reset module state between tests. */
+export declare function resetV2ModuleStateForTest(): void;
+export declare function markV2TurnSeen(sessionId: string): boolean;
+export declare function setup(ctx: V2Context): Promise<(() => void | Promise<void>) | void>;