opencode-codex-memory 0.6.5 → 0.7.1

package/README.md

@@ -43,8 +43,8 @@ worked and what didn't — and puts that context back in front of the agent in
 later conversations. You don't manage any of it; OpenCode just gets more useful
 the more you use it.
 
-If you want the mental model before the details, jump to
-[How it works](#how-it-works).
+If you want the mental model — learning, remembering, forgetting — see
+[How OpenCode Codex Memory works](./docs/how-ai-memory-works.md).
 
 ## Install
 
@@ -52,7 +52,7 @@ If you want the mental model before the details, jump to
 
 ```json
 {
-  "plugin": ["opencode-codex-memory@0.6.5"]
+  "plugin": ["opencode-codex-memory@0.7.1"]
 }
 ```
 
@@ -67,6 +67,20 @@ learning starts immediately.
 Requires OpenCode 1.18 or newer. Models and other options: see
 [Configuration](#configuration).
 
+**OpenCode 2:** the same package works on opencode2 — install it with the
+V2 plugin syntax:
+
+```jsonc
+{
+  "plugins": [{ "package": "opencode-codex-memory@0.7.1" }],
+}
+```
+
+Same pipeline, not the same host APIs — see [docs/opencode2.md](./docs/opencode2.md)
+for the limits (registered service, retained citation markup, no `small_model`).
+On opencode2 you also get a **Memory** section in the session sidebar plus a
+`/memory-status` command, served live from the same state as `memory_inspect`.
+
 ### Installation hints
 
 To bump pins, copy
@@ -99,23 +113,6 @@ echo 'I prefer TypeScript strict mode and 2-space indentation.' \
   > ~/.local/share/opencode/memories/memory_summary.md
 ```
 
-## How it works
-
-You don't need to know any of this to use the plugin. In short: two background
-writers and one reader. Once a session has been idle long enough (default 6 h),
-a cheap model reviews its transcript and writes a structured note (**phase 1 —
-extraction**). Every few hours, a stronger model merges those notes into the
-actual memory files — the index, the short summary, reusable skills — resolving
-duplicates and dropping what went stale (**phase 2 — consolidation**). On every
-turn, the short summary goes into the system prompt, and the agent searches
-deeper layers itself when a task looks familiar (**read path**). When the agent
-uses a memory it cites it; those citations feed consolidation's ranking, so
-useful memories survive and unused ones age out.
-
-For the full architecture — learning, remembering, forgetting, and the
-trade-offs behind each — see
-[How OpenCode Codex Memory works](./docs/how-ai-memory-works.md).
-
 ## Where your data lives
 
 ```
@@ -201,7 +198,7 @@ To set options, turn the plugin entry into a `[name, options]` pair:
 ```json
 {
   "plugin": [
-    ["opencode-codex-memory@0.6.5", { "disable_on_external_context": true, "min_rollout_idle_hours": 2 }]
+    ["opencode-codex-memory@0.7.1", { "disable_on_external_context": true, "min_rollout_idle_hours": 2 }]
   ]
 }
 ```
@@ -221,9 +218,9 @@ the default value appearing where you expected your setting.
 
 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`);
+`small_model` from your `opencode.json` is used (Codex uses `gpt-5.6-luna`);
 when `consolidation_model` is unset, your main `model` is used (Codex uses
-`gpt-5.4`). If neither is configured, the learning sub-agents fall back to
+`gpt-5.6-terra`). 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
@@ -268,7 +265,7 @@ Off by default; no changes to Codex's own config are required.
 {
   "plugin": [
     [
-      "opencode-codex-memory@0.6.5",
+      "opencode-codex-memory@0.7.1",
       { "codex_interop": { "import": true, "export": true } }
     ]
   ]
@@ -325,7 +322,7 @@ from the project memories Claude already keeps on your machine. **One-way only**
 ```json
 {
   "plugin": [
-    ["opencode-codex-memory@0.6.5", { "claude_import": { "enabled": true } }]
+    ["opencode-codex-memory@0.7.1", { "claude_import": { "enabled": true } }]
   ]
 }
 ```
@@ -352,7 +349,7 @@ Claude names each project with an opaque id (a folder under
 {
   "plugin": [
     [
-      "opencode-codex-memory@0.6.5",
+      "opencode-codex-memory@0.7.1",
       {
         "claude_import": {
           "enabled": true,
@@ -462,8 +459,9 @@ package cache.
 ## Contributing
 
 The port follows Codex closely: same two-phase pipeline, same on-disk artifacts,
-same prompts (adapted only where OpenCode differs). If you want the full design
-and the trade-offs, see [`ARCHITECTURE.md`](./ARCHITECTURE.md); contributor
+same prompts (adapted only where OpenCode differs). Conceptual design:
+[How OpenCode Codex Memory works](./docs/how-ai-memory-works.md). Implementation
+map and workarounds: [`ARCHITECTURE.md`](./ARCHITECTURE.md). Contributor
 guidance lives in [`CONTRIBUTING.md`](./CONTRIBUTING.md) and
 [`AGENTS.md`](./AGENTS.md) — in short: this repo exists to port Codex's memory
 system to OpenCode, and PRs that break that parity will be rejected.

package/dist/opencode.json

@@ -37,4 +37,4 @@
       }
     }
   }
-}
+}

package/dist/src/citation.d.ts

@@ -9,6 +9,15 @@ export interface ParsedCitation {
     entries: MemoryCitationEntry[];
     raw: string;
 }
+/** Fence language the TUI code-block renderer is registered for. */
+export declare const CITATION_FENCE_LANG = "memory-citation";
+/** Parse the fenced body: entry lines plus an optional `sessions:` line. */
+export declare function parseCitationBody(body: string): {
+    entries: MemoryCitationEntry[];
+    sessionIds: string[];
+};
 export declare function parseCitations(text: string): ParsedCitation[];
+/** Cheap pre-check before running the full parser (either format). */
+export declare function hasCitationMarkup(text: string): boolean;
 export declare function extractCitedSessionIds(text: string): string[];
 export declare function stripCitations(text: string): string;

package/dist/src/citation.js

@@ -1,17 +1,41 @@
-const CITATION_BLOCK_RE = /<memory-citation>[\s\S]*?<\/memory-citation>/gi;
+/** Fence language the TUI code-block renderer is registered for. */
+export const CITATION_FENCE_LANG = "memory-citation";
+// Legacy bare-XML block (still accepted for persisted history) or the current
+// fenced form ```memory-citation ... ``` which markdown clients render as a
+// code block and the V2 TUI renders natively.
+const CITATION_BLOCK_RE = /<memory-citation>[\s\S]*?<\/memory-citation>|^[ \t]{0,3}(`{3,})memory-citation[ \t]*\r?\n[\s\S]*?\r?\n[ \t]*\1[ \t]*$/gim;
+const FENCE_RE = /^[ \t]{0,3}(`{3,})memory-citation[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]*\1[ \t]*$/i;
+const SESSIONS_LINE_RE = /^sessions?\s*:\s*(.*)$/i;
 function extractSection(block, name) {
     const m = block.match(new RegExp(`<${name}>([\\s\\S]*?)</${name}>`, "i"));
     return m ? m[1] : null;
 }
-function parseEntry(line) {
-    const trimmed = line.trim();
-    if (!trimmed)
-        return null;
-    const noteSplit = trimmed.lastIndexOf("|note=[");
-    if (noteSplit === -1 || !trimmed.endsWith("]"))
-        return null;
-    const location = trimmed.slice(0, noteSplit);
-    const note = trimmed.slice(noteSplit + "|note=[".length, -1).trim();
+/** Parse the fenced body: entry lines plus an optional `sessions:` line. */
+export function parseCitationBody(body) {
+    const entries = [];
+    const sessionIds = [];
+    const seen = new Set();
+    for (const line of body.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const sessions = trimmed.match(SESSIONS_LINE_RE);
+        if (sessions) {
+            for (const id of sessions[1].split(/[\s,]+/).map((s) => s.trim()).filter(Boolean)) {
+                if (!seen.has(id)) {
+                    seen.add(id);
+                    sessionIds.push(id);
+                }
+            }
+            continue;
+        }
+        const entry = parseFenceEntry(trimmed);
+        if (entry)
+            entries.push(entry);
+    }
+    return { entries, sessionIds };
+}
+function parseLocation(location, note) {
     const colon = location.lastIndexOf(":");
     if (colon === -1)
         return null;
@@ -26,19 +50,48 @@ function parseEntry(line) {
         return null;
     return { path, lineStart, lineEnd, note };
 }
+function parseXmlEntry(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    const noteSplit = trimmed.lastIndexOf("|note=[");
+    if (noteSplit === -1 || !trimmed.endsWith("]"))
+        return null;
+    const note = trimmed.slice(noteSplit + "|note=[".length, -1).trim();
+    return parseLocation(trimmed.slice(0, noteSplit), note);
+}
+function parseFenceEntry(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    const noteSplit = trimmed.lastIndexOf("|note=");
+    if (noteSplit === -1)
+        return null;
+    let note = trimmed.slice(noteSplit + "|note=".length).trim();
+    if (note.startsWith("[") && note.endsWith("]"))
+        note = note.slice(1, -1).trim();
+    return parseLocation(trimmed.slice(0, noteSplit), note);
+}
 export function parseCitations(text) {
     const results = [];
     const re = new RegExp(CITATION_BLOCK_RE);
     let m;
     while ((m = re.exec(text)) !== null) {
         const raw = m[0];
+        const fenced = raw.match(FENCE_RE);
+        if (fenced) {
+            const parsed = parseCitationBody(fenced[2]);
+            if (parsed.entries.length > 0 || parsed.sessionIds.length > 0)
+                results.push({ ...parsed, raw });
+            continue;
+        }
         const entries = [];
         const sessionIds = [];
         const seen = new Set();
         const entriesBlock = extractSection(raw, "citation_entries");
         if (entriesBlock) {
             for (const line of entriesBlock.split(/\r?\n/)) {
-                const entry = parseEntry(line);
+                const entry = parseXmlEntry(line);
                 if (entry)
                     entries.push(entry);
             }
@@ -68,6 +121,10 @@ export function parseCitations(text) {
     }
     return results;
 }
+/** Cheap pre-check before running the full parser (either format). */
+export function hasCitationMarkup(text) {
+    return /<memory-citation>/i.test(text) || /^[ \t]{0,3}`{3,}memory-citation[ \t]*$/im.test(text);
+}
 export function extractCitedSessionIds(text) {
     const seen = new Set();
     for (const c of parseCitations(text)) {

package/dist/src/db.js

@@ -78,6 +78,16 @@ function runMigrations(db) {
                 db.run(stmt);
             db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (?, ?)").run(1, Date.now());
         }
+        if (currentVersion < 2) {
+            db.run(`CREATE TABLE IF NOT EXISTS memory_citation_usage (
+        session_id TEXT NOT NULL,
+        assistant_message_id TEXT NOT NULL,
+        cited_session_id TEXT NOT NULL,
+        recorded_at INTEGER NOT NULL,
+        PRIMARY KEY (session_id, assistant_message_id, cited_session_id)
+      )`);
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (?, ?)").run(2, Date.now());
+        }
     }).immediate();
 }
 export function closeDb() {

package/dist/src/host-client.d.ts

@@ -82,6 +82,7 @@ export interface HostPromptBody {
 export declare function hostSessionPrompt(client: PluginInput["client"], opts: {
     sessionId: string;
     body: HostPromptBody;
+    signal?: AbortSignal;
 }): Promise<{
     error?: unknown;
     data?: unknown;

package/dist/src/host-client.js

@@ -96,6 +96,7 @@ export async function hostSessionPrompt(client, opts) {
             ...(opts.body.variant ? { variant: opts.body.variant } : {}),
             parts: opts.body.parts,
         },
+        ...(opts.signal ? { signal: opts.signal } : {}),
     });
 }
 /** Read AssistantMessage.structured when the host captured json_schema output. */

package/dist/src/index.d.ts

@@ -1,13 +1,23 @@
-import { MemoryStore } from "./store.js";
 import type { PluginInput, PluginOptions } from "@opencode-ai/plugin";
 /** Test seam: wait for all hook-launched work, including follow-up phase 2. */
 export declare function waitForBackgroundTasks(): Promise<void>;
+/**
+ * Load the OpenCode 2 implementation only when a V2 host actually invokes
+ * setup(). OpenCode 1 imports this module to obtain server(); it must not need
+ * the V2 SDK or execute any V2 module initialization just to start.
+ */
+type PluginSetup = (() => void | Promise<void>) | void;
+declare function setupV2(ctx: unknown): Promise<PluginSetup>;
 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;
+interface SessionMemoryStore {
+    deleteSessionMemory(sessionId: string): boolean;
+}
+export declare function handleSessionDeleted(sessionId: string, store?: SessionMemoryStore, schedulePhase2?: () => void): void;
 declare const _default: {
     id: string;
+    setup: typeof setupV2;
     server(input: PluginInput, opts?: PluginOptions): Promise<{
         tool: {
             memory_read: {

package/dist/src/index.js

@@ -1,6 +1,6 @@
 import { ensureMemoryLayout, buildMemorySystemPrompt, invalidateCache } from "./source.js";
 import { memoryRoot } from "./paths.js";
-import { stripCitations, extractCitedSessionIds } from "./citation.js";
+import { stripCitations, extractCitedSessionIds, hasCitationMarkup } from "./citation.js";
 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 { MemoryStore } from "./store.js";
@@ -39,6 +39,22 @@ const MCP_STATUS_TIMEOUT_MS = 1_000;
 function getStore() {
     return new MemoryStore();
 }
+function isV2PluginContext(ctx) {
+    if (!ctx || typeof ctx !== "object")
+        return false;
+    const session = ctx.session;
+    const directory = ctx.location?.directory;
+    return typeof session?.hook === "function" && typeof directory === "string";
+}
+async function setupV2(ctx) {
+    // OpenCode 1.x may still invoke a `setup` export if present. Running the
+    // V2 adapter there replaces the V1 client with the shim and breaks
+    // discovery/consolidation. Only a V2 Plugin.Context has session.hook.
+    if (!isV2PluginContext(ctx))
+        return;
+    const { setup } = await import("./v2/plugin.js");
+    return setup(ctx);
+}
 // Citation blocks are seen by both the text.complete hook (once, at
 // completion) and message.part.updated (once per streaming delta), so the
 // same block surfaces many times. Track which session ids were already
@@ -105,6 +121,9 @@ schedulePhase2 = () => { if (pluginOptions.generate_memories)
 }
 export default {
     id: "opencode-codex-memory",
+    // opencode2 entry point (V2 reads id + setup(), ignoring server()).
+    // Added additively: V1 hosts keep calling server() exactly as before.
+    setup: setupV2,
     async server(input, opts) {
         // A reload after dispose must be able to run the pipeline again.
         resetPluginLifecycle();
@@ -123,6 +142,14 @@ export default {
         // Finish bounded reseeding before hooks can see a surviving memory
         // sub-session after a plugin reload.
         await cleanupOldSubSessions();
+        try {
+            if (getStore().releaseOrphanedPhase2Job()) {
+                console.warn("[opencode-codex-memory] released a consolidation lease orphaned by a dead process");
+            }
+        }
+        catch (err) {
+            console.warn("[opencode-codex-memory] orphaned phase2 sweep failed:", err);
+        }
         return buildHooks();
     },
 };
@@ -417,7 +444,7 @@ function buildHooks() {
             try {
                 if (isMemorySubSession(input.sessionID))
                     return;
-                if (!output.text.includes("<memory-citation>"))
+                if (!hasCitationMarkup(output.text))
                     return;
                 try {
                     const ids = extractCitedSessionIds(output.text);
@@ -445,10 +472,10 @@ function buildHooks() {
                     if (msg.info?.role !== "assistant")
                         continue;
                     for (const part of msg.parts) {
-                        if (part.type === "text" && typeof part.text === "string" && part.text.includes("<memory-citation>")) {
+                        if (part.type === "text" && typeof part.text === "string" && hasCitationMarkup(part.text)) {
                             const before = part.text;
                             part.text = stripCitations(part.text);
-                            if (part.text.includes("<memory-citation>")) {
+                            if (hasCitationMarkup(part.text)) {
                                 console.warn("[opencode-codex-memory] citation marker still present after stripCitations — hook contract may have changed");
                             }
                         }
@@ -527,7 +554,7 @@ function buildHooks() {
                         return;
                     if (part.sessionID && isMemorySubSession(part.sessionID))
                         return;
-                    if (!part.text.includes("<memory-citation>"))
+                    if (!hasCitationMarkup(part.text))
                         return;
                     let ids = [];
                     try {

package/dist/src/llm.d.ts

@@ -6,6 +6,12 @@ export interface ExtractionResult {
 }
 export declare function setPluginInput(input: PluginInput): void;
 export declare function getPluginInput(): PluginInput | null;
+/**
+ * V2 agent definitions are location-scoped. The V2 setup supplies the active
+ * location so helper sessions resolve the same agent; V1 leaves this unset
+ * and continues using the dedicated memory workspace as its session root.
+ */
+export declare function setSubSessionDirectory(directory?: string): void;
 /** Test seam. */
 export declare function setSubSessionCreateTimeoutForTest(ms?: number): void;
 /** Test seam. */

package/dist/src/llm.js

@@ -8,6 +8,7 @@ import { SCAN_LIMIT } from "./store.js";
 import { isProviderCapacityError, ProviderCapacityError } from "./ratelimit.js";
 let inputRef = null;
 let inputGeneration = 0;
+let subSessionDirectoryOverride = null;
 export function setPluginInput(input) {
     inputRef = input;
     inputGeneration++;
@@ -19,6 +20,14 @@ export function setPluginInput(input) {
 export function getPluginInput() {
     return inputRef;
 }
+/**
+ * V2 agent definitions are location-scoped. The V2 setup supplies the active
+ * location so helper sessions resolve the same agent; V1 leaves this unset
+ * and continues using the dedicated memory workspace as its session root.
+ */
+export function setSubSessionDirectory(directory) {
+    subSessionDirectoryOverride = directory ?? null;
+}
 // Sessions this plugin spawned for extraction/consolidation. The main
 // hooks skip these so the plugin never injects memory into (or memorizes) its
 // own sub-agents.
@@ -59,16 +68,17 @@ export function isMemorySubSession(sessionId) {
 /**
  * Host directory for memory sub-sessions. Must exist: OpenCode resolves it in
  * SystemPrompt.environment and fails the turn with UnknownError/ENOENT when
- * missing. Prefer the memory workspace itself — global, always ours, already
- * granted to `memorize` via external_directory, and independent of whatever
- * (possibly deleted) project PluginInput.directory points at.
+ * missing. V1 uses the memory workspace; V2 supplies the active project
+ * location so its location-scoped `memorize` agent is available, with the
+ * memory workspace as the safe fallback.
  */
 function resolveSubSessionDirectory() {
-    const root = memoryRoot();
+    const configured = subSessionDirectoryOverride;
+    const root = configured && fs.existsSync(configured) ? configured : memoryRoot();
     fs.mkdirSync(root, { recursive: true });
     return root;
 }
-async function createSession(agent, title) {
+async function createSession(title) {
     const input = getPluginInput();
     if (!input)
         throw new Error("plugin input not initialized");
@@ -81,7 +91,7 @@ async function createSession(agent, title) {
     const res = await withHostTimeout(hostSessionCreate(input.client, {
         directory,
         body: {
-            title: title ?? `codex-memory-${agent}`,
+            title,
             metadata: { [SUBSESSION_METADATA_KEY]: true },
         },
         signal: controller.signal,
@@ -98,8 +108,8 @@ async function createSession(agent, title) {
 /**
  * opencode's config carries the same split codex expresses with provider
  * model preferences: `small_model` for cheap background work (codex:
- * memory_extraction_preferred_model = gpt-5.4-mini) and `model` for capable
- * work (codex: memory_consolidation_preferred_model = gpt-5.4). Cached per
+ * memory_extraction_preferred_model = gpt-5.6-luna) and `model` for capable
+ * work (codex: memory_consolidation_preferred_model = gpt-5.6-terra). Cached per
  * plugin instance — opencode reloads plugins on config change.
  */
 let configModels = null;
@@ -265,6 +275,7 @@ async function runPrompt(sessionId, prompt, agent, opts = {}) {
     const model = opts.model ? parseModelRef(opts.model) : null;
     const promptPromise = hostSessionPrompt(input.client, {
         sessionId,
+        signal: opts.signal,
         body: {
             agent,
             ...(opts.system ? { system: opts.system } : {}),
@@ -377,7 +388,7 @@ const EXTRACTION_SCHEMA = {
  */
 export async function extractViaSubagent(sessionId, transcript, opts = {}) {
     const agent = "memorize-extract";
-    const subId = await createSession(agent, `codex-memory-extract-${sessionId}`);
+    const subId = await createSession(`codex-memory-extract-${sessionId}`);
     try {
         const prompt = buildExtractionInput(sessionId, opts.cwd ?? "unknown", transcript);
         // extract_model option > opencode small_model > session default.
@@ -421,7 +432,7 @@ export async function extractViaSubagent(sessionId, transcript, opts = {}) {
 const CONSOLIDATION_TIMEOUT_MS = 3600_000;
 export async function consolidateViaSubagent(memoryRoot, diffFileName, model, signal) {
     const agent = "memorize";
-    const subId = await createSession(agent, "codex-memory-consolidate");
+    const subId = await createSession("codex-memory-consolidate");
     let promptError;
     let promptFailed = false;
     try {

package/dist/src/phase2.d.ts

@@ -10,6 +10,8 @@ export interface Phase2Options {
     claudeImport?: ClaudeImportOptions;
     /** Override the 90s heartbeat interval (tests / advanced). */
     heartbeatIntervalMs?: number;
+    /** User-requested run: skip the 6h success cooldown (lease/retry gates still apply). */
+    bypassCooldown?: boolean;
 }
 export declare const DEFAULT_PHASE2_OPTIONS: Phase2Options;
 /**

package/dist/src/phase2.js

@@ -111,7 +111,7 @@ export async function runPhase2(store, opts = DEFAULT_PHASE2_OPTIONS) {
         const rl = await checkRateLimit("phase2", consolidationModel);
         if (!rl.ok)
             return { status: "skipped_rate_limit" };
-        const claim = store.claimGlobalPhase2Job();
+        const claim = store.claimGlobalPhase2Job({ bypassCooldown: opts.bypassCooldown });
         if (claim.type !== "claimed")
             return { status: claim.type };
         // Abort scope covers prep + consolidator so dispose during baseline/diff

package/dist/src/rollout-input.d.ts

@@ -0,0 +1,6 @@
+import type { TranscriptMessage } from "./capture.js";
+/**
+ * Human-first extract input. OpenCode parts, not Codex RolloutItem:
+ * no commentary phase, no request_user_input pairing.
+ */
+export declare function serializeTieredInput(items: TranscriptMessage[], charLimit?: number): string;

package/dist/src/rollout-input.js

@@ -0,0 +1,111 @@
+import { isMemoryExcludedFragment } from "./redact.js";
+const OMITTED = "[... response items omitted ...]\n";
+const TOOL_ROW_CHARS = 8_000;
+const MAX_ROW_CHARS = 10_000;
+const DEFAULT_CHAR_LIMIT = 600_000;
+const TIER_ORDER = ["human", "final", "other_agent", "commentary", "context", "tool"];
+const LABELS = {
+    human: "human user",
+    final: "assistant final",
+    other_agent: "other agent",
+    commentary: "assistant commentary",
+    context: "harness context",
+    tool: "tool",
+};
+function isEnvContext(text) {
+    const trimmed = text.trim();
+    return trimmed.startsWith("<environment_context>") && trimmed.endsWith("</environment_context>");
+}
+function isOtherAgent(text) {
+    const trimmed = text.trimStart();
+    return (trimmed.startsWith("<subagent_notification>")
+        || (trimmed.startsWith("Message Type:")
+            && trimmed.includes("\nTask name:")
+            && trimmed.includes("\nSender:")));
+}
+function classify(msg) {
+    if (msg.type === "reasoning" || msg.type === "step-start" || msg.type === "step-finish")
+        return null;
+    if (msg.role === "developer" || msg.role === "system")
+        return null;
+    if (msg.type === "tool")
+        return "tool";
+    if (msg.type === "file" || msg.type === "image")
+        return msg.role === "user" ? "human" : "final";
+    const text = msg.text ?? "";
+    if (!text.trim() && msg.type !== "file" && msg.type !== "image")
+        return null;
+    if (msg.type === "agent" || msg.type === "task")
+        return "other_agent";
+    if (msg.role === "user") {
+        if (isMemoryExcludedFragment(text))
+            return null;
+        if (isEnvContext(text))
+            return "context";
+        return "human";
+    }
+    if (msg.role === "assistant") {
+        if (isOtherAgent(text))
+            return "other_agent";
+        return "final";
+    }
+    return null;
+}
+function rowText(msg, tier) {
+    if (msg.type === "image")
+        return "[image omitted]";
+    if (msg.type === "file" && !msg.text?.trim())
+        return "[file omitted]";
+    let text = msg.text ?? "";
+    if (tier === "tool" && text.length > TOOL_ROW_CHARS)
+        text = text.slice(0, TOOL_ROW_CHARS);
+    if (text.length > MAX_ROW_CHARS)
+        text = text.slice(0, MAX_ROW_CHARS);
+    return text;
+}
+/**
+ * Human-first extract input. OpenCode parts, not Codex RolloutItem:
+ * no commentary phase, no request_user_input pairing.
+ */
+export function serializeTieredInput(items, charLimit = DEFAULT_CHAR_LIMIT) {
+    const rows = [];
+    for (const msg of items) {
+        const tier = classify(msg);
+        if (!tier)
+            continue;
+        const body = rowText(msg, tier);
+        if (!body.trim())
+            continue;
+        rows.push({ tier, text: `[${LABELS[tier]}]\n${body}\n` });
+    }
+    let remaining = Math.max(0, charLimit - OMITTED.length);
+    const selected = rows.map(() => null);
+    for (const tier of TIER_ORDER) {
+        for (let i = rows.length - 1; i >= 0; i--) {
+            if (rows[i].tier !== tier || remaining <= OMITTED.length)
+                continue;
+            let text = rows[i].text;
+            if (text.length > remaining)
+                text = text.slice(0, Math.max(0, remaining - OMITTED.length));
+            if (!text)
+                continue;
+            remaining -= text.length + OMITTED.length;
+            selected[i] = text;
+        }
+    }
+    let rendered = "";
+    let gap = false;
+    for (const row of selected) {
+        if (row) {
+            rendered += row;
+            gap = false;
+        }
+        else if (!gap) {
+            rendered += OMITTED;
+            gap = true;
+        }
+    }
+    if (rendered.length > charLimit)
+        return "";
+    return rendered;
+}