opencode-codex-memory 0.6.5 → 0.7.1

package/dist/src/v2/status-rpc.d.ts

@@ -0,0 +1,197 @@
+/**
+ * Shared server↔TUI wire contract for the memory sidebar status.
+ *
+ * Dependency-free on purpose: the TUI bundle runs in the CLI sandbox, where
+ * only `@opencode/plugin/tui` (+ rendering peers) is guaranteed to resolve.
+ * `Rpc.define` is a runtime passthrough (validation only), so a plain object
+ * with JSON Schema nodes is an equivalent portable definition.
+ */
+export declare const MEMORY_STATUS_ACTIVITIES: readonly ["idle", "extracting", "consolidating", "retrying", "error", "read_only", "disabled", "stopping"];
+export type MemoryStatusActivity = (typeof MEMORY_STATUS_ACTIVITIES)[number];
+export interface MemoryStatus {
+    activity: MemoryStatusActivity;
+    useMemories: boolean;
+    generateMemories: boolean;
+    extractModel: string | null;
+    consolidationModel: string | null;
+    codexImport: boolean;
+    lastSuccessAt: number | null;
+    retryAt: number | null;
+    warnings: string[];
+    /** Per-session read/write mode when a sessionID was supplied. */
+    sessionMode: "enabled" | "disabled" | "polluted" | null;
+    /** Root directory of the memory workspace. */
+    memoryRoot: string;
+    /** Estimated memory tokens injected into model requests (chars/4). */
+    injected: {
+        sessionTokens: number;
+        sessionRequests: number;
+        totalTokens: number;
+        totalRequests: number;
+    };
+}
+export declare const MemoryStatusRpc: {
+    readonly id: "opencode-codex-memory";
+    readonly methods: {
+        readonly status: {
+            readonly input: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly sessionID: {
+                        readonly type: "string";
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly output: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly activity: {
+                        readonly type: "string";
+                        readonly enum: readonly ["idle", "extracting", "consolidating", "retrying", "error", "read_only", "disabled", "stopping"];
+                    };
+                    readonly useMemories: {
+                        readonly type: "boolean";
+                    };
+                    readonly generateMemories: {
+                        readonly type: "boolean";
+                    };
+                    readonly extractModel: {
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly consolidationModel: {
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly codexImport: {
+                        readonly type: "boolean";
+                    };
+                    readonly lastSuccessAt: {
+                        readonly type: readonly ["number", "null"];
+                    };
+                    readonly retryAt: {
+                        readonly type: readonly ["number", "null"];
+                    };
+                    readonly warnings: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly sessionMode: {
+                        readonly type: readonly ["string", "null"];
+                        readonly enum: readonly ["enabled", "disabled", "polluted", null];
+                    };
+                    readonly memoryRoot: {
+                        readonly type: "string";
+                    };
+                    readonly injected: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly sessionTokens: {
+                                readonly type: "number";
+                            };
+                            readonly sessionRequests: {
+                                readonly type: "number";
+                            };
+                            readonly totalTokens: {
+                                readonly type: "number";
+                            };
+                            readonly totalRequests: {
+                                readonly type: "number";
+                            };
+                        };
+                        readonly required: readonly ["sessionTokens", "sessionRequests", "totalTokens", "totalRequests"];
+                        readonly additionalProperties: false;
+                    };
+                };
+                readonly required: readonly ["activity", "useMemories", "generateMemories", "extractModel", "consolidationModel", "codexImport", "lastSuccessAt", "retryAt", "warnings", "sessionMode", "memoryRoot", "injected"];
+                readonly additionalProperties: false;
+            };
+        };
+        /** Runtime-only toggle of a boolean plugin option (until server restart). */
+        readonly setOption: {
+            readonly input: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly key: {
+                        readonly type: "string";
+                        readonly enum: readonly ["use_memories", "generate_memories"];
+                    };
+                    readonly value: {
+                        readonly type: "boolean";
+                    };
+                };
+                readonly required: readonly ["key", "value"];
+                readonly additionalProperties: false;
+            };
+            readonly output: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly ok: {
+                        readonly type: "boolean";
+                    };
+                };
+                readonly required: readonly ["ok"];
+                readonly additionalProperties: false;
+            };
+        };
+        /** Same effect as the memory_mode tool. */
+        readonly setSessionMode: {
+            readonly input: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly sessionID: {
+                        readonly type: "string";
+                    };
+                    readonly mode: {
+                        readonly type: "string";
+                        readonly enum: readonly ["enabled", "disabled"];
+                    };
+                };
+                readonly required: readonly ["sessionID", "mode"];
+                readonly additionalProperties: false;
+            };
+            readonly output: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly ok: {
+                        readonly type: "boolean";
+                    };
+                };
+                readonly required: readonly ["ok"];
+                readonly additionalProperties: false;
+            };
+        };
+        /** Run extraction + consolidation now, bypassing the success cooldown (not the lease). */
+        readonly consolidateNow: {
+            readonly input: {
+                readonly type: "object";
+                readonly properties: {};
+                readonly additionalProperties: false;
+            };
+            readonly output: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly status: {
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["status"];
+                readonly additionalProperties: false;
+            };
+        };
+    };
+    readonly events: {
+        readonly changed: {
+            readonly schema: {
+                readonly type: "object";
+                readonly properties: {};
+                readonly additionalProperties: false;
+            };
+        };
+    };
+};
+/** Runtime guard for the untyped RPC client result (no zod in the TUI bundle). */
+export declare function isMemoryStatus(value: unknown): value is MemoryStatus;
+/** Throwing parser for tests and call sites that want a typed value. */
+export declare function parseMemoryStatus(value: unknown): MemoryStatus;

package/dist/src/v2/status-rpc.js

@@ -0,0 +1,159 @@
+/**
+ * Shared server↔TUI wire contract for the memory sidebar status.
+ *
+ * Dependency-free on purpose: the TUI bundle runs in the CLI sandbox, where
+ * only `@opencode/plugin/tui` (+ rendering peers) is guaranteed to resolve.
+ * `Rpc.define` is a runtime passthrough (validation only), so a plain object
+ * with JSON Schema nodes is an equivalent portable definition.
+ */
+export const MEMORY_STATUS_ACTIVITIES = [
+    "idle",
+    "extracting",
+    "consolidating",
+    "retrying",
+    "error",
+    "read_only",
+    "disabled",
+    "stopping",
+];
+const INJECTED_SCHEMA = {
+    type: "object",
+    properties: {
+        sessionTokens: { type: "number" },
+        sessionRequests: { type: "number" },
+        totalTokens: { type: "number" },
+        totalRequests: { type: "number" },
+    },
+    required: ["sessionTokens", "sessionRequests", "totalTokens", "totalRequests"],
+    additionalProperties: false,
+};
+export const MemoryStatusRpc = {
+    id: "opencode-codex-memory",
+    methods: {
+        status: {
+            input: {
+                type: "object",
+                properties: { sessionID: { type: "string" } },
+                additionalProperties: false,
+            },
+            output: {
+                type: "object",
+                properties: {
+                    activity: { type: "string", enum: [...MEMORY_STATUS_ACTIVITIES] },
+                    useMemories: { type: "boolean" },
+                    generateMemories: { type: "boolean" },
+                    extractModel: { type: ["string", "null"] },
+                    consolidationModel: { type: ["string", "null"] },
+                    codexImport: { type: "boolean" },
+                    lastSuccessAt: { type: ["number", "null"] },
+                    retryAt: { type: ["number", "null"] },
+                    warnings: { type: "array", items: { type: "string" } },
+                    sessionMode: { type: ["string", "null"], enum: ["enabled", "disabled", "polluted", null] },
+                    memoryRoot: { type: "string" },
+                    injected: INJECTED_SCHEMA,
+                },
+                required: [
+                    "activity",
+                    "useMemories",
+                    "generateMemories",
+                    "extractModel",
+                    "consolidationModel",
+                    "codexImport",
+                    "lastSuccessAt",
+                    "retryAt",
+                    "warnings",
+                    "sessionMode",
+                    "memoryRoot",
+                    "injected",
+                ],
+                additionalProperties: false,
+            },
+        },
+        /** Runtime-only toggle of a boolean plugin option (until server restart). */
+        setOption: {
+            input: {
+                type: "object",
+                properties: {
+                    key: { type: "string", enum: ["use_memories", "generate_memories"] },
+                    value: { type: "boolean" },
+                },
+                required: ["key", "value"],
+                additionalProperties: false,
+            },
+            output: { type: "object", properties: { ok: { type: "boolean" } }, required: ["ok"], additionalProperties: false },
+        },
+        /** Same effect as the memory_mode tool. */
+        setSessionMode: {
+            input: {
+                type: "object",
+                properties: {
+                    sessionID: { type: "string" },
+                    mode: { type: "string", enum: ["enabled", "disabled"] },
+                },
+                required: ["sessionID", "mode"],
+                additionalProperties: false,
+            },
+            output: { type: "object", properties: { ok: { type: "boolean" } }, required: ["ok"], additionalProperties: false },
+        },
+        /** Run extraction + consolidation now, bypassing the success cooldown (not the lease). */
+        consolidateNow: {
+            input: { type: "object", properties: {}, additionalProperties: false },
+            output: {
+                type: "object",
+                properties: { status: { type: "string" } },
+                required: ["status"],
+                additionalProperties: false,
+            },
+        },
+    },
+    events: {
+        changed: { schema: { type: "object", properties: {}, additionalProperties: false } },
+    },
+};
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Runtime guard for the untyped RPC client result (no zod in the TUI bundle). */
+export function isMemoryStatus(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.activity !== "string" ||
+        !MEMORY_STATUS_ACTIVITIES.includes(value.activity)) {
+        return false;
+    }
+    for (const key of ["useMemories", "generateMemories", "codexImport"]) {
+        if (typeof value[key] !== "boolean")
+            return false;
+    }
+    for (const key of ["extractModel", "consolidationModel", "lastSuccessAt", "retryAt"]) {
+        const v = value[key];
+        if (v !== null && typeof v !== (key === "extractModel" || key === "consolidationModel" ? "string" : "number")) {
+            return false;
+        }
+    }
+    if (!Array.isArray(value.warnings) || !value.warnings.every((w) => typeof w === "string")) {
+        return false;
+    }
+    if (value.sessionMode !== null &&
+        value.sessionMode !== "enabled" &&
+        value.sessionMode !== "disabled" &&
+        value.sessionMode !== "polluted") {
+        return false;
+    }
+    if (typeof value.memoryRoot !== "string")
+        return false;
+    const injected = value.injected;
+    if (!isRecord(injected))
+        return false;
+    for (const key of ["sessionTokens", "sessionRequests", "totalTokens", "totalRequests"]) {
+        if (typeof injected[key] !== "number")
+            return false;
+    }
+    return true;
+}
+/** Throwing parser for tests and call sites that want a typed value. */
+export function parseMemoryStatus(value) {
+    if (!isMemoryStatus(value))
+        throw new Error("invalid memory status payload");
+    return value;
+}

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

@@ -0,0 +1,3 @@
+import type { MemoryStatus } from "./status-rpc.js";
+/** Read the same snapshots as memory_inspect; never claim or advance a job. */
+export declare function readMemoryStatus(sessionID?: string | null): MemoryStatus;

package/dist/src/v2/status.js

@@ -0,0 +1,83 @@
+import { MemoryStore } from "../store.js";
+import { pluginOptions, getConfigWarnings } from "../options.js";
+import { getAgentHealth } from "../agent-health.js";
+import { isPhase2InFlight } from "../phase2.js";
+import { isPluginShuttingDown } from "../lifecycle.js";
+import { activeProviderCapacityBackoffs } from "../ratelimit.js";
+import { resolveCodexInterop } from "../codex-interop.js";
+import { injectionTotals, sessionInjection } from "./injection.js";
+import { memoryRoot } from "../paths.js";
+/** Read the same snapshots as memory_inspect; never claim or advance a job. */
+export function readMemoryStatus(sessionID) {
+    const store = new MemoryStore();
+    const phase1 = store.stage1JobSnapshot();
+    const phase2 = store.phase2JobSnapshot();
+    const options = pluginOptions;
+    const now = Date.now();
+    const session = sessionInjection(sessionID);
+    const total = injectionTotals();
+    const retryTimes = [
+        ...activeProviderCapacityBackoffs().map((backoff) => backoff.retry_at),
+        ...phase1.recent_errors.map((error) => error.retry_at),
+        phase2?.retry_at,
+    ].filter((time) => time != null && time * 1000 > now);
+    const retryAt = retryTimes.length ? Math.min(...retryTimes) * 1000 : null;
+    const warnings = [...getConfigWarnings()];
+    const health = getAgentHealth();
+    if (options.generate_memories && health.observed) {
+        // V2 extraction is sessionless; only the consolidator agent is used.
+        warnings.push(...health.agents.memorize.issues.map((issue) => `memorize: ${issue}`));
+    }
+    if (phase2?.last_error)
+        warnings.push("Consolidation failed; see memory_inspect for details.");
+    if (phase1.by_failure_class.other_exhausted > 0)
+        warnings.push("Some extraction jobs exhausted their retries.");
+    if (phase1.by_failure_class.provider_capacity > 0)
+        warnings.push("Some extraction jobs hit provider capacity limits.");
+    const codexImport = options.codex_interop.import && resolveCodexInterop(options.codex_interop) !== null;
+    if (options.codex_interop.import && !codexImport)
+        warnings.push("Codex import is misconfigured.");
+    // A `running` row this process does not own is either another opencode
+    // instance's live job or an orphaned lease (e.g. a server restart killed the
+    // owner mid-run). Neither is "consolidating" here; surface it instead.
+    const foreignLease = !isPhase2InFlight() &&
+        phase2?.status === "running" &&
+        phase2.lease_until != null &&
+        phase2.lease_until * 1000 > now;
+    if (foreignLease) {
+        warnings.push(`Consolidation lease held by another process until ${new Date(phase2.lease_until * 1000).toLocaleTimeString()}.`);
+    }
+    let activity = "idle";
+    if (isPluginShuttingDown())
+        activity = "stopping";
+    else if (isPhase2InFlight())
+        activity = "consolidating";
+    else if ((phase1.by_status.running ?? 0) > 0)
+        activity = "extracting";
+    else if (!options.generate_memories)
+        activity = options.use_memories ? "read_only" : "disabled";
+    else if (retryAt !== null)
+        activity = "retrying";
+    else if (warnings.length > 0)
+        activity = "error";
+    return {
+        activity,
+        useMemories: options.use_memories,
+        generateMemories: options.generate_memories,
+        extractModel: options.extract_model ?? null,
+        consolidationModel: options.consolidation_model ?? null,
+        codexImport,
+        // finished_at on a failed attempt is NOT a successful consolidation.
+        lastSuccessAt: phase2?.success_finished_at != null ? phase2.success_finished_at * 1000 : null,
+        retryAt,
+        warnings,
+        sessionMode: sessionID ? store.getMemoryMode(sessionID) : null,
+        memoryRoot: memoryRoot(),
+        injected: {
+            sessionTokens: session.tokens,
+            sessionRequests: session.requests,
+            totalTokens: total.tokens,
+            totalRequests: total.requests,
+        },
+    };
+}

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

@@ -0,0 +1,33 @@
+/**
+ * opencode2 tool registration.
+ *
+ * The memory tools' logic lives in tools/*.ts (V1 tool() definitions) and is
+ * reused verbatim: each V1 definition already bundles {description, args
+ * (zod raw shape), execute}. V2 accepts any StandardSchema as input, which
+ * zod v4 satisfies natively, so the adapter just re-wraps the same validate
+ * + execute path and maps the result shape:
+ *   V1 string | {output, metadata}  →  V2 {content, metadata}
+ * No V1 file is touched and behavior is identical by construction.
+ */
+import { z } from "zod";
+interface V2ToolDefinition {
+    name: string;
+    description: string;
+    input: z.ZodTypeAny;
+    execute: (input: any, ctx: {
+        sessionID: string;
+        messageID: string;
+        agent: string;
+        abort?: AbortSignal;
+    }) => Promise<{
+        content: string | unknown[];
+        metadata?: unknown;
+    }>;
+}
+/**
+ * Same gating as the V1 entry: the read/search/list/add-note tools require
+ * BOTH use_memories and dedicated_tools (codex MemoriesExtension); the
+ * control tools are always available.
+ */
+export declare function buildV2Tools(): V2ToolDefinition[];
+export {};

package/dist/src/v2/tools.js

@@ -0,0 +1,57 @@
+/**
+ * opencode2 tool registration.
+ *
+ * The memory tools' logic lives in tools/*.ts (V1 tool() definitions) and is
+ * reused verbatim: each V1 definition already bundles {description, args
+ * (zod raw shape), execute}. V2 accepts any StandardSchema as input, which
+ * zod v4 satisfies natively, so the adapter just re-wraps the same validate
+ * + execute path and maps the result shape:
+ *   V1 string | {output, metadata}  →  V2 {content, metadata}
+ * No V1 file is touched and behavior is identical by construction.
+ */
+import { z } from "zod";
+import { memory_read, memory_search, memory_list, memory_add_note } from "../../tools/memory.js";
+import { memory_reset, memory_inspect, memory_mode } from "../../tools/control.js";
+import { pluginOptions } from "../options.js";
+function adaptTool(name, v1) {
+    return {
+        name,
+        description: v1.description,
+        input: z.object(v1.args),
+        async execute(input, tctx) {
+            const v1ctx = {
+                sessionID: tctx.sessionID,
+                messageID: tctx.messageID,
+                agent: tctx.agent,
+                directory: "",
+                worktree: "",
+                abort: tctx.abort instanceof AbortSignal ? tctx.abort : new AbortController().signal,
+                metadata: () => { },
+                ask: async () => { },
+            };
+            const res = await v1.execute(input, v1ctx);
+            if (typeof res === "string")
+                return { content: res };
+            return { content: res.output ?? "", ...(res.metadata !== undefined ? { metadata: res.metadata } : {}) };
+        },
+    };
+}
+const ALL_MEMORY_TOOLS = [
+    ["memory_read", memory_read],
+    ["memory_search", memory_search],
+    ["memory_list", memory_list],
+    ["memory_add_note", memory_add_note],
+    ["memory_reset", memory_reset],
+    ["memory_inspect", memory_inspect],
+    ["memory_mode", memory_mode],
+];
+const CONTROL_ONLY = new Set(["memory_reset", "memory_inspect", "memory_mode"]);
+/**
+ * Same gating as the V1 entry: the read/search/list/add-note tools require
+ * BOTH use_memories and dedicated_tools (codex MemoriesExtension); the
+ * control tools are always available.
+ */
+export function buildV2Tools() {
+    const full = pluginOptions.use_memories && pluginOptions.dedicated_tools;
+    return ALL_MEMORY_TOOLS.filter(([name]) => full || CONTROL_ONLY.has(name)).map(([name, v1]) => adaptTool(name, v1));
+}

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

@@ -0,0 +1,3 @@
+import { Plugin } from "@opencode/plugin/tui";
+declare const _default: Plugin.Definition;
+export default _default;