@eleboucher/opencode-memini 0.7.19 → 0.7.20

package/README.md

@@ -38,27 +38,65 @@ opencode installs it from npm with Bun at startup.
 opencode's v2 preview (`opencode2`) uses a different plugin system: a `plugins`
 (plural) config array and a `Plugin.define({ id, setup })` module — the v1
 `{ id, server }` plugin above does not load under it. memini ships a v2 sibling
-at the `/v2` subpath that wires the same recall / capture / `memini_status`
-behaviour to the v2 `ctx.session.hook("request")`, `ctx.event.subscribe`, and
-`ctx.tool.transform` API:
+that wires the same recall / capture / `memini_status` behaviour to v2's
+session hooks, public event stream, and tool transforms.
+
+The v2 loader treats a `plugins` entry as either an npm package specifier or a
+path. It cannot install this package's `/v2` export subpath as an npm package,
+so v2 ships under its own package name:
 
 ```jsonc
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugins": [["@eleboucher/opencode-memini/v2", { "namespace": "my-project" }]],
+  "plugins": ["@eleboucher/opencode-memini-v2"],
+}
+```
+
+A bare entry resolves to the `latest` dist-tag, so that is where this package
+is published. `opencode2 plugin add @eleboucher/opencode-memini-v2` writes the
+entry for you, using whatever specifier you pass it.
+
+> **Why a second package rather than one with two entrypoints?** opencode
+> resolves a plugin through `exports["./server"]` before falling back to
+> `main`, and it uses that same `server` kind for v1-style plugins. Adding a
+> `./server` key to `@eleboucher/opencode-memini` would therefore hand the v2
+> module to v1 hosts, which cannot load it.
+
+To run from a checkout, use the local entrypoint. opencode does not install
+dependencies for path-loaded plugins; this one has none, so nothing else is
+needed:
+
+```jsonc
+{
+  "plugins": ["/absolute/path/to/memini/integrations/opencode/plugin/memini-v2.js"],
+}
+```
+
+For options, use the documented object form:
+
+```jsonc
+{
+  "plugins": [
+    {
+      "package": "@eleboucher/opencode-memini-v2",
+      "options": { "namespace": "my-project" },
+    },
+  ],
 }
 ```
 
 The same options and env vars below apply. Recall injects into the request's
 `system` prompt (rather than a synthetic message part).
 
-> **Beta status.** The v2 plugin `ctx` is still gaining these hooks upstream.
-> On a build where `ctx.session.hook` / `ctx.event.subscribe` / `ctx.tool.transform`
-> are absent, the plugin logs which capability is unavailable and no-ops that
-> part rather than crashing — it activates cleanly and lights up automatically
-> once opencode exposes the hook. Track the plugin `ctx` in opencode's
-> `core/src/plugin/host.ts`. Until then, stay on the v1 entry above with the
-> stable `opencode` binary.
+> **Beta status.** Verified against `opencode2 v0.0.0-next-16502` and re-checked
+> through `v0.0.0-beta-18050`: the working request hook is `context` (the docs
+> call it `request`); user/assistant turns are captured from
+> `session.inbox.enqueued`, `session.text.ended`, and `session.execution.*`
+> because these builds emit no `session.idle` and expose no session-message list
+> method. `next-17444` renamed the first event from `session.input.admitted` and
+> moved its text from `input.data` to `item.payload`; the plugin reads both
+> shapes, and registers both hook names so it remains compatible with the
+> documented spelling.
 
 The v2 plugin sends diagnostics through the structured `ctx.app.log` logger when
 available. Logging is best-effort and remains silent when that logger is absent

package/memini-v2.js

@@ -1,17 +1,43 @@
 /**
  * memini memory plugin for opencode v2 (the Plugin.define / `setup` API).
  *
- * This is the v2 sibling of memini.js. It targets the documented v2 plugin
- * contract (https://v2.opencode.ai — "Plugins"):
- *   - ctx.session.hook("request", …): recall memories relevant to the incoming
- *     turn and inject them into the model request (the `system` prompt) before
- *     dispatch. This is the v2 equivalent of v1's `chat.message`.
- *   - ctx.event.subscribe("session.idle"): once a session goes idle, capture the
- *     completed user/assistant turn into memini. The v2 equivalent of v1's
- *     `event` hook. Started detached (never awaited inside `setup`, per the docs)
- *     and torn down by the returned cleanup.
- *   - ctx.tool.transform(t => t.add(…)): register the read-only `memini_status`
- *     tool. The v2 equivalent of v1's `tool: { memini_status }`.
+ * This is the v2 sibling of memini.js. It targets the v2 plugin contract as
+ * verified against opencode2 v0.0.0-next-16502 and re-checked through
+ * v0.0.0-beta-18050 (@opencode-ai/plugin `next` / `beta`), which differs from
+ * the docs at https://opencode.ai/v2/docs/build/plugins in several places —
+ * every shape below is feature-detected and was confirmed against the live
+ * runtime:
+ *
+ *   - RECALL — ctx.session.hook("context", …): the docs call this hook
+ *     "request", but this build fires "context" (unknown names register without
+ *     error and simply never fire). The event is
+ *     { sessionID, agent, model, system, messages, tools }, where `system` is an
+ *     array of { type: "text", text } parts and `messages` are AI-SDK-shaped
+ *     ({ id, role, content: [{ type: "text", text } …] }). The hook fires once
+ *     per model DISPATCH — i.e. again on every tool-loop continuation step — so
+ *     recall is deduplicated per TURN (last user message id): the search runs
+ *     once per user message and the rendered block is re-injected from cache on
+ *     continuation dispatches of the same turn. This is the v2 equivalent of
+ *     v1's `chat.message`.
+ *   - CAPTURE — ctx.event.subscribe() (no type argument; the whole public
+ *     server event stream, across every project the service hosts). There is no
+ *     `session.idle` in v2: a turn's boundary is the
+ *     `session.execution.succeeded` / `.failed` / `.interrupted` event. There is
+ *     also no message-listing method on ctx.session (create/get/prompt/command/
+ *     synthetic/generate/interrupt only; session.get returns SessionInfo with
+ *     no messages). Capture is therefore event-driven: the user text comes from
+ *     `session.inbox.enqueued` (data.item.payload.text) and the assistant text
+ *     from `session.text.ended` parts (keyed by assistantMessageID + ordinal),
+ *     flushed to memini when the execution terminal event arrives. v1's
+ *     failed-turn marking maps to execution.failed / execution.interrupted.
+ *     Builds up to next-16502 named that event `session.input.admitted` and
+ *     nested the same Prompt.fields under `data.input.data`; both shapes are
+ *     read, so one plugin covers either build.
+ *   - STATUS TOOL — ctx.tool.transform(t => t.add(…)): `add` takes ONE
+ *     structural Tool.Info object ({ name, input, description, execute,
+ *     options? }) — not the docs' three-argument add(name, def, options). The
+ *     input schema field is `input` (raw JSON Schema is fine) and the result is
+ *     { content: [{ type: "text", text }] }.
  *
  * Everything that is not opencode-contract-specific — config/namespace
  * resolution, the handshake, formatting, token budgeting, status rendering, the
@@ -26,7 +52,16 @@
  * The v2 plugin API is beta and its ctx is still gaining hooks upstream. Every
  * capability below is feature-detected: on a build where `ctx.session.hook`,
  * `ctx.event.subscribe`, or `ctx.tool.transform` is absent, that capability logs
- * once and no-ops rather than throwing and taking down plugin activation.
+ * once and no-ops rather than throwing and taking down plugin activation. Note
+ * that ctx.app has no `log` method on current builds (it is { name, version,
+ * channel }), so diagnostics stay silent — they are best-effort by design.
+ *
+ * KNOWN LIMITATION (beta): the v2 service hosts every project in ONE process
+ * with ONE plugin instance, and hooks/events are service-global. The namespace
+ * is resolved from the plugin process's cwd (typically the service's start
+ * directory), so sessions from other projects would recall/capture against the
+ * same namespace. Pin `MEMINI_NAMESPACE` if needed and re-check the upstream
+ * ctx as it gains per-location routing.
  */
 
 import {
@@ -40,8 +75,6 @@ import {
   formatResults,
   fitByTokens,
   labelsEnv,
-  extractLastTurn,
-  lastAssistantFailed,
   describeSettings,
   renderStatus,
   createClient,
@@ -55,6 +88,25 @@ const INJECT_PREAMBLE =
   "Relevant long-term memory from memini (background context — prefer " +
   "current workspace state and the user's instructions):";
 const BUDGET_EXPIRED = Symbol("memini-recall-budget-expired");
+// OpenCode activates a plugin per location while event.subscribe() is global.
+// Assistant message IDs are globally unique, so this prevents duplicate writes.
+const capturedAssistantIDs = new Set();
+const MAX_CAPTURED_ASSISTANT_IDS = 1000;
+
+function claimCapturedAssistant(id) {
+  if (capturedAssistantIDs.has(id)) return false;
+  capturedAssistantIDs.add(id);
+  while (capturedAssistantIDs.size > MAX_CAPTURED_ASSISTANT_IDS) {
+    const oldest = capturedAssistantIDs.keys().next().value;
+    if (oldest === undefined) break;
+    capturedAssistantIDs.delete(oldest);
+  }
+  return true;
+}
+
+export function resetForTests() {
+  capturedAssistantIDs.clear();
+}
 
 // messageText pulls the plain text out of one v2 request message, tolerating the
 // shapes the beta may hand us: `content` as a string, `content` as an array of
@@ -72,18 +124,16 @@ function messageText(msg) {
   return "";
 }
 
-// extractQueryFromRequest returns the latest user text from a request event's
+// extractQueryFromRequest returns the latest user text from a context event's
 // `messages`, falling back to the last non-empty message so a recall still fires
 // on unusual message layouts. Exported for testing.
 export function extractQueryFromRequest(event) {
-  const messages = Array.isArray(event && event.messages) ? event.messages : [];
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const role = messages[i] && (messages[i].role || (messages[i].info && messages[i].info.role));
-    if (role === "user") {
-      const text = messageText(messages[i]);
-      if (text) return text;
-    }
+  const lastUser = lastUserMessage(event);
+  if (lastUser) {
+    const text = messageText(lastUser);
+    if (text) return text;
   }
+  const messages = Array.isArray(event && event.messages) ? event.messages : [];
   for (let i = messages.length - 1; i >= 0; i--) {
     const text = messageText(messages[i]);
     if (text) return text;
@@ -91,14 +141,34 @@ export function extractQueryFromRequest(event) {
   return "";
 }
 
+// lastUserMessage returns the most recent user-role message, or null.
+function lastUserMessage(event) {
+  const messages = Array.isArray(event && event.messages) ? event.messages : [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const role = messages[i] && (messages[i].role || (messages[i].info && messages[i].info.role));
+    if (role === "user") return messages[i];
+  }
+  return null;
+}
+
+// turnKey identifies a user TURN (as opposed to one model dispatch): the
+// context hook re-fires on every tool-loop continuation with the same last
+// user message. Exported for testing.
+export function turnKey(event, query) {
+  const sessionID = event && event.sessionID ? String(event.sessionID) : "";
+  const lastUser = lastUserMessage(event);
+  const id = lastUser && (lastUser.id || (lastUser.info && lastUser.info.id));
+  return `${sessionID}|${id || query}`;
+}
+
 // injectContext places the rendered memory block where the model will see it:
-// the request event's `system` array first (transient, not persisted as a
-// message part), falling back to prepending a system message. Returns true when
-// it found a slot. Exported for testing.
+// the event's `system` array first (an array of { type: "text", text } parts,
+// transient and not persisted as a message), falling back to prepending a
+// system message. Returns true when it found a slot. Exported for testing.
 export function injectContext(event, block) {
   if (!event || !block) return false;
   if (Array.isArray(event.system)) {
-    event.system.push(block);
+    event.system.push({ type: "text", text: block });
     return true;
   }
   if (Array.isArray(event.messages)) {
@@ -108,34 +178,11 @@ export function injectContext(event, block) {
   return false;
 }
 
-// fetchSessionMessages reads a session's message list through whichever server
-// client method the running build exposes ([{info, parts}, …] is what
-// extractLastTurn expects). The v2 ctx is "essentially a server client", but the
-// exact accessor for GET /api/session/{id}/message isn't pinned in the beta, so
-// try the plausible names and unwrap the common envelope shapes.
-async function fetchSessionMessages(ctx, sessionID) {
-  const session = ctx && ctx.session;
-  if (!session) return [];
-  const unwrap = (res) =>
-    Array.isArray(res) ? res
-    : Array.isArray(res && res.data) ? res.data
-    : Array.isArray(res && res.messages) ? res.messages
-    : [];
-  const attempts = [
-    () => session.messages && session.messages({ path: { id: sessionID } }),
-    () => session.message && session.message({ path: { id: sessionID } }),
-    () => session.messages && session.messages(sessionID),
-  ];
-  for (const attempt of attempts) {
-    try {
-      const res = await attempt();
-      const arr = unwrap(res);
-      if (arr.length) return arr;
-    } catch {
-      /* try the next accessor shape */
-    }
-  }
-  return [];
+function contextAlreadyInjected(event) {
+  return Array.isArray(event && event.system) && event.system.some((part) => {
+    const text = typeof part === "string" ? part : part && part.text;
+    return typeof text === "string" && text.startsWith(INJECT_PREAMBLE);
+  });
 }
 
 export async function setup(ctx) {
@@ -177,7 +224,6 @@ export async function setup(ctx) {
   // unchanged match is suppressed while inside EITHER window, re-served once
   // BOTH lapse, and re-served immediately when its content changed (h
   // mismatch). Both maps bounded for a long-lived host.
-  const captured = new Set();
   const injectedBySession = new Map(); // session -> { n, ids: Map<id, {h, at, n}> }
   const MAX_TRACKED_SESSIONS = 200;
   const MAX_INJECTED_PER_SESSION = 200;
@@ -217,27 +263,49 @@ export async function setup(ctx) {
     else if (reg && typeof reg.dispose === "function") cleanups.push(() => reg.dispose());
   };
 
-  // --- RECALL: ctx.session.hook("request") -------------------------------
+  // --- RECALL: ctx.session.hook("context") --------------------------------
+  //
+  // opencode awaits this hook immediately before model dispatch (the doc's "a
+  // hook failure fails the operation it intercepts"), so the callback swallows
+  // its own errors and races the search against recall_budget_ms: if memini is
+  // slow, the turn proceeds without memory rather than freezing for the full
+  // timeout_ms.
   //
-  // opencode awaits this hook immediately before model dispatch (a throw fails
-  // the turn — the doc's "a hook failure fails the operation it intercepts"), so
-  // the callback swallows its own errors and races the search against
-  // recall_budget_ms: if memini is slow, the turn proceeds without memory rather
-  // than freezing for the full timeout_ms.
+  // The build verified against fires "context"; the docs name the same hook
+  // "request". Unknown names register without error and never fire, so both
+  // are registered: on any given build only the implemented one runs, and a
+  // build that ever fires both for one dispatch is neutralized by the
+  // per-turn dedup plus the injected-event WeakSet below.
   if (ctx && ctx.session && typeof ctx.session.hook === "function") {
-    const reg = await ctx.session.hook("request", async (event) => {
+    // Events whose system/messages this hook generation already injected —
+    // guards against a build that fires both names for one dispatch.
+    const injectedEvents = new WeakSet();
+    const handleRequest = async (event) => {
       try {
         const live = await currentConfig();
         if (!live.recall) return;
         const query = extractQueryFromRequest(event);
         if (!query) return;
         const sessionID = event.sessionID || event.sessionId || (event.session && event.session.id) || "";
-        // One request-hook fire == one prompt for the cooldown's prompt
-        // dimension (the v2 beta's closest per-turn signal): bump before any
-        // gate, so the window measures prompts-since-injection even on turns
-        // that inject nothing.
         const seen = sessionID ? sessionSeen(sessionID) : null;
-        if (seen) seen.n += 1;
+
+        // One USER TURN == one prompt for the cooldown's prompt dimension. The
+        // hook re-fires per tool-loop step of the same turn, so dedupe on the
+        // last user message: a repeat turnKey skips the search and the counter,
+        // but re-injects this turn's cached block into the new dispatch's
+        // system (each dispatch rebuilds its request from scratch).
+        const key = turnKey(event, query);
+        if (seen && seen.lastTurnKey === key) {
+          if (seen.block && !contextAlreadyInjected(event) && !injectedEvents.has(event) && injectContext(event, seen.block)) {
+            injectedEvents.add(event);
+          }
+          return;
+        }
+        if (seen) {
+          seen.lastTurnKey = key;
+          seen.block = undefined;
+          seen.n += 1;
+        }
         const cooldownOpts = () => ({
           now: Date.now(),
           counter: seen ? seen.n : 0,
@@ -323,21 +391,35 @@ export async function setup(ctx) {
         }
         if (fit.dropped > 0) lines.push(`[... ${fit.dropped} item(s) truncated by token budget]`);
 
-        if (injectContext(event, lines.join("\n")) && seen) {
-          // Record only the slice formatResults actually renders, stamped with
-          // {h, at, n} so the windowed cooldown can judge re-admission later.
-          rememberInjected(seen, filtered.slice(0, live.recall_limit || 3));
+        const block = lines.join("\n");
+        if (!contextAlreadyInjected(event) && injectContext(event, block)) {
+          injectedEvents.add(event);
+          if (seen) {
+            // Cache for re-injection on this turn's continuation dispatches,
+            // and record only the slice formatResults actually renders,
+            // stamped {h, at, n} so the windowed cooldown can judge later.
+            seen.block = block;
+            rememberInjected(seen, filtered.slice(0, live.recall_limit || 3));
+          }
         }
       } catch (error) {
         log.warn(`request hook failed: ${String(error)}`);
       }
-    });
-    disposeReg(reg);
+    };
+    for (const name of ["context", "request"]) {
+      const reg = await ctx.session.hook(name, handleRequest);
+      disposeReg(reg);
+    }
   } else if (cfg.recall) {
     log.warn("recall unavailable: ctx.session.hook is not present on this opencode build");
   }
 
-  // --- STATUS TOOL: ctx.tool.transform(t => t.add(...)) ------------------
+  // --- STATUS TOOL: ctx.tool.transform(t => t.add(info)) ------------------
+  //
+  // `add` takes ONE structural Tool.Info: { name, input, description, execute,
+  // options? } (verified against next-16502; the docs' three-argument
+  // add(name, def, options) is wrong for this build). `input` is a raw JSON
+  // Schema; the result is { content: [{ type: "text", text }] }.
   if (ctx && ctx.tool && typeof ctx.tool.transform === "function") {
     const reg = await ctx.tool.transform((tools) => {
       tools.add({
@@ -349,7 +431,7 @@ export async function setup(ctx) {
           "would be without the env/option pin, and any misconfiguration worth flagging. Read-only; " +
           "secrets are redacted. Call it when the user asks what memini is doing, why a memory " +
           "cannot be recalled, or which namespace is in use.",
-        jsonSchema: { type: "object", properties: {}, additionalProperties: false },
+        input: { type: "object", properties: {}, additionalProperties: false },
         options: { codemode: false },
         execute: async () => {
           try {
@@ -365,13 +447,7 @@ export async function setup(ctx) {
             report.memory.recall_max_tokens = live.recall_max_tokens;
             report.memory.recall_min_score = live.recall_min_score;
             const text = renderStatus(report);
-            return {
-              structured: {
-                namespace: report.namespace.effective,
-                source: report.namespace.source,
-              },
-              content: [{ type: "text", text }],
-            };
+            return { content: [{ type: "text", text }] };
           } catch (error) {
             return { content: [{ type: "text", text: `memini status failed: ${String(error)}` }] };
           }
@@ -383,45 +459,122 @@ export async function setup(ctx) {
     log.warn("memini_status unavailable: ctx.tool.transform is not present on this opencode build");
   }
 
-  // --- CAPTURE: ctx.event.subscribe("session.idle") ----------------------
+  // --- CAPTURE: ctx.event.subscribe() -------------------------------------
+  //
+  // Detached: the docs say not to await an infinite stream inside setup. We
+  // spawn the consumer and hand back an AbortController-based cleanup.
   //
-  // Detached: the docs say not to await an infinite stream inside setup. We spawn
-  // the consumer and hand back an AbortController-based cleanup.
-  const handleIdle = async (event) => {
+  // There is no `session.idle` and no message list accessor in v2, so a turn
+  // is reconstructed from the public event stream:
+  //   session.inbox.enqueued      -> user text    (data.item.payload.text;
+  //                                  session.input.admitted / data.input.data
+  //                                  on builds up to next-16502)
+  //   session.text.ended          -> assistant part (data: sessionID,
+  //                                  assistantMessageID, ordinal, text)
+  //   session.execution.succeeded -> flush        (failed / interrupted flush
+  //                                  with metadata.failed = true)
+  // An execution event with no pending user text (compaction, synthetic
+  // input, a turn that started before this plugin generation loaded) captures
+  // nothing — same as v1's skip on an empty turn.
+  const MAX_TRACKED_CAPTURE = 200;
+  const pendingBySession = new Map(); // sessionID -> { userText, texts: Map<aid, Map<ordinal, text>>, lastAid }
+  const pendingState = (sessionID) => {
+    let state = pendingBySession.get(sessionID);
+    if (!state) {
+      state = { userText: "", texts: new Map(), lastAid: "" };
+      pendingBySession.set(sessionID, state);
+      while (pendingBySession.size > MAX_TRACKED_CAPTURE) {
+        const oldest = pendingBySession.keys().next().value;
+        if (oldest === undefined) break;
+        pendingBySession.delete(oldest);
+      }
+    }
+    return state;
+  };
+  const flushTurn = async (sessionID, failed) => {
     const live = await currentConfig();
     if (!live.capture) return;
-    // The stream may be narrower or broader than session.idle depending on how
-    // subscribe filters; guard on the type when present.
-    if (event && event.type && event.type !== "session.idle") return;
-    const sessionID =
-      (event && event.properties && event.properties.sessionID) || (event && event.sessionID);
-    if (!sessionID) return;
-    const ancestry = await resolveSessionAncestry(ctx.session, sessionID);
-    if (ancestry.session_type !== "root" && !live.capture_child_sessions) return;
-    const messages = await fetchSessionMessages(ctx, sessionID);
-    const { userText, assistantText, assistantID } = extractLastTurn(messages);
-    if (!userText || !assistantText) return;
-    if (assistantID && captured.has(assistantID)) return;
+    const pending = pendingBySession.get(sessionID);
+    pendingBySession.delete(sessionID);
+    if (!pending || !pending.userText || !pending.lastAid) return;
+    const parts = pending.texts.get(pending.lastAid);
+    const assistantText = parts
+      ? [...parts.entries()].sort((a, b) => a[0] - b[0]).map(([, text]) => text).join("\n").trim()
+      : "";
+    if (!assistantText) return;
+    const assistantID = pending.lastAid;
+    if (!claimCapturedAssistant(assistantID)) return;
+    const ancestry = await resolveSessionAncestry(
+      {
+        get: (input) => {
+          const id = typeof input === "string" ? input : input?.sessionID || input?.path?.id;
+          return ctx.session.get({ sessionID: id });
+        },
+      },
+      sessionID,
+    );
+    if (ancestry.session_type !== "root" && !live.capture_child_sessions) {
+      capturedAssistantIDs.delete(assistantID);
+      return;
+    }
     const metadata = { source: "opencode", session_id: sessionID, format: "turn", ...ancestry };
-    if (lastAssistantFailed(messages)) metadata.failed = true;
+    if (failed) metadata.failed = true;
     const stored = await rest.postJson(
       "/v1/memories",
       {
-        content: buildTurnCapture(userText, assistantText, live.capture_user_max_chars, live.capture_assistant_max_chars),
+        content: buildTurnCapture(pending.userText, assistantText, live.capture_user_max_chars, live.capture_assistant_max_chars),
         tags: ["opencode"],
         metadata,
       },
       live.namespace,
     );
-    if (stored !== null && assistantID) captured.add(assistantID);
+    if (stored === null) capturedAssistantIDs.delete(assistantID);
+  };
+  const handleEvent = async (event) => {
+    const type = event && event.type;
+    const data = (event && event.data) || {};
+    const sessionID = data.sessionID || (data.properties && data.properties.sessionID);
+    if (!sessionID) return;
+    if (type === "session.inbox.enqueued" || type === "session.input.admitted") {
+      // next-17444 renamed the event and its payload: session.input.admitted
+      // { input: { type, data } } became session.inbox.enqueued
+      // { item: { type, payload } }. Both carry Prompt.fields, so `text` is
+      // read the same way once the wrapper is unwrapped. Synthetic and
+      // compaction items are skipped, as the "user" check always did.
+      const item = data.item || data.input;
+      const payload = item && item.type === "user" ? item.payload || item.data : null;
+      const text = payload && payload.text;
+      const pending = pendingState(sessionID);
+      pending.userText = typeof text === "string" ? text : "";
+      pending.texts = new Map();
+      pending.lastAid = "";
+      return;
+    }
+    if (type === "session.text.ended") {
+      if (!data.assistantMessageID || typeof data.text !== "string") return;
+      const pending = pendingState(sessionID);
+      let parts = pending.texts.get(data.assistantMessageID);
+      if (!parts) {
+        parts = new Map();
+        pending.texts.set(data.assistantMessageID, parts);
+      }
+      parts.set(data.ordinal ?? parts.size, data.text);
+      pending.lastAid = data.assistantMessageID;
+      return;
+    }
+    if (type === "session.execution.succeeded") return flushTurn(sessionID, false);
+    if (type === "session.execution.failed" || type === "session.execution.interrupted") {
+      return flushTurn(sessionID, true);
+    }
   };
 
   if (cfg.capture && ctx && ctx.event && typeof ctx.event.subscribe === "function") {
     const controller = new AbortController();
+    let iterator;
     const task = (async () => {
       let stream;
       try {
-        stream = ctx.event.subscribe("session.idle");
+        stream = ctx.event.subscribe();
       } catch (error) {
         log.warn(`capture unavailable: ctx.event.subscribe threw: ${String(error)}`);
         return;
@@ -431,10 +584,13 @@ export async function setup(ctx) {
         return;
       }
       try {
-        for await (const event of stream) {
+        iterator = stream[Symbol.asyncIterator]();
+        for (;;) {
           if (controller.signal.aborted) break;
+          const { value: event, done } = await iterator.next();
+          if (done) break;
           try {
-            await handleIdle(event);
+            await handleEvent(event);
           } catch (error) {
             log.warn(`event hook failed: ${String(error)}`);
           }
@@ -445,6 +601,11 @@ export async function setup(ctx) {
     })();
     cleanups.push(async () => {
       controller.abort();
+      try {
+        if (iterator && typeof iterator.return === "function") await iterator.return();
+      } catch {
+        /* closing the event stream is best-effort */
+      }
       await task.catch(() => {});
     });
   } else if (cfg.capture) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleboucher/opencode-memini",
-  "version": "0.7.19",
+  "version": "0.7.20",
   "description": "Automatic cross-session memory for opencode via memini — recall before each turn, capture after.",
   "keywords": [
     "memini",