@opencode-cockpit/subagents 0.7.0

package/dist/tui/render.js

@@ -0,0 +1,103 @@
+/**
+ * The only place that knows what a tone looks like: every colour from the user's OpenCode theme,
+ * through the host (so OpenCode 2's tokens arrive under the same names — client/host `themeFromV2`).
+ *
+ * Nothing of OpenTUI is imported at runtime: it is the host's, not installed beside a published
+ * plugin (docs/opencode/v2.md). `StyledText` and the colour class are borrowed from objects the host
+ * made, as Shell's and Review's pools do.
+ */
+
+const BOLD = 1 << 0;
+const ITALIC = 1 << 2;
+export function toneColour(theme, tone) {
+  switch (tone) {
+    case "muted":
+      return theme.textMuted;
+    case "accent":
+      return theme.accent;
+    case "info":
+      return theme.info;
+    case "tool":
+      return theme.primary;
+    case "success":
+      return theme.success;
+    case "error":
+      return theme.error;
+    case "warning":
+      return theme.warning;
+    case "border":
+      return theme.border;
+    default:
+      return theme.text;
+  }
+}
+export function fillColour(theme, fill) {
+  if (fill === "band") return theme.backgroundPanel;
+  if (fill === "block" || fill === "card") return theme.backgroundElement;
+  if (fill === "selected") return theme.backgroundPanel;
+  return undefined;
+}
+
+/** Bold is bold; faint is the muted colour in italics — the terminal's DIM draws too dark to read. */
+export const attributesOf = run => (run.bold ? BOLD : 0) | (run.faint ? ITALIC : 0);
+
+/**
+ * A surface colour certain to paint. A theme may leave its backgrounds transparent (OpenCode's
+ * "system" theme), and a full-window surface painted with one lets the conversation show through —
+ * the 0.6 fix, carried over from Shell and Review.
+ */
+export function solidSurface(theme) {
+  const found = [theme.background, theme.backgroundPanel, theme.backgroundElement].find(c => c !== undefined && c.a > 0);
+  if (found) return found;
+  const text = theme.text;
+  const scale = Math.max(text.r, text.g, text.b) > 1 ? 255 : 1;
+  const light = (0.2126 * text.r + 0.7152 * text.g + 0.0722 * text.b) / scale > 0.5;
+  const Colour = text.constructor;
+  return Colour.fromHex?.(light ? "#0b0b0e" : "#fafafa") ?? text;
+}
+/** Rows onto a pool of lines — Shell's pool: only lines that changed are touched. */
+export function createRowPool(lines) {
+  let StyledText;
+  let painted = [];
+  let drawnWith;
+  const styled = chunks => {
+    if (!StyledText && lines[0]) {
+      const found = lines[0].content?.constructor;
+      if (found && found !== Object) StyledText = found;
+    }
+    return StyledText ? new StyledText(chunks) : chunks.map(part => part.text).join("");
+  };
+  const chunk = (theme, run) => ({
+    __isChunk: true,
+    text: run.text,
+    fg: toneColour(theme, run.tone),
+    bg: fillColour(theme, run.fill),
+    attributes: attributesOf(run)
+  });
+  return {
+    draw(rows, theme) {
+      /** A new theme changes every colour, so nothing on screen can be trusted to still be right. */
+      const all = theme !== drawnWith;
+      drawnWith = theme;
+      rows.forEach((row, index) => {
+        const line = lines[index];
+        if (!line) return;
+        const key = JSON.stringify(row);
+        if (all || painted[index] !== key) {
+          line.content = styled(row.map(run => chunk(theme, run)));
+          painted[index] = key;
+        }
+        line.visible = true;
+      });
+      for (let index = rows.length; index < lines.length; index++) {
+        const line = lines[index];
+        if (line) line.visible = false;
+        painted[index] = undefined;
+      }
+    },
+    clear() {
+      for (const line of lines) line.visible = false;
+      painted = [];
+    }
+  };
+}

package/dist/tui/source.js

@@ -0,0 +1,228 @@
+/**
+ * Where subagents come from: the host's live events, and the stored runs of subagents that existed
+ * before this plugin did. The only file that reaches past `Host` into a specific OpenCode — through
+ * `api.v1` / `api.v2`, as Status's snapshot does — and every shape it reads was measured on 1.18.32
+ * and 2.0.15 (docs/opencode/agents.md). Everything it learns becomes `Change`s for the model.
+ */
+
+import { createV1Translator } from "../core/adapt/v1.js";
+import { createV2Translator } from "../core/adapt/v2.js";
+/** OpenCode 1 event types that concern sessions, messages and what they wait on. */
+const V1_EVENTS = ["session.created", "session.updated", "session.status", "session.idle", "session.error", "message.updated", "message.part.updated", "message.part.delta", "permission.asked", "permission.replied", "question.asked", "question.replied", "question.rejected"];
+
+/**
+ * The host's objects, reached by the shapes measured on real runs (docs/opencode/agents.md) rather than
+ * by types: `api.v1` / `api.v2` are typed only as far as the host needs them.
+ */
+// biome-ignore lint/suspicious/noExplicitAny: see above — every access is to a measured field
+
+export function createSource(api, log, emit) {
+  /** Each unexpected shape once, not once per event. */
+  const told = new Set();
+  const unknown = (what, detail) => {
+    const key = `${what} ${JSON.stringify(detail)}`;
+    if (told.has(key)) return;
+    told.add(key);
+    log.warn("unrecognised event", {
+      what,
+      ...detail
+    });
+  };
+  const offs = [];
+  const guard = (where, fn) => {
+    try {
+      fn();
+    } catch (error) {
+      log.error(`${where} failed`, {
+        error
+      });
+    }
+  };
+  if (api.v1) {
+    const v1 = api.v1;
+    const translate = createV1Translator(unknown);
+    for (const type of V1_EVENTS) {
+      const off = v1.event.on(type, event => guard("event", () => emit(translate.event(event))));
+      if (typeof off === "function") offs.push(off);
+    }
+    return {
+      async load(root) {
+        const seen = new Set();
+        const visit = async (parent, depth) => {
+          if (depth > 4 || seen.has(parent)) return;
+          seen.add(parent);
+          const result = await v1.client.session.children({
+            sessionID: parent
+          }).catch(error => {
+            log.warn("children failed", {
+              parent,
+              error
+            });
+            return undefined;
+          });
+          const children = result?.data ?? result ?? [];
+          for (const child of Array.isArray(children) ? children : []) {
+            const id = child.id;
+            const messages = v1.state.session.messages(id) ?? [];
+            const history = messages.map(info => ({
+              info,
+              parts: v1.state.part(info.id) ?? []
+            }));
+            const status = v1.state.session.status(id);
+            /**
+             * Busy only when the host says so. A finished subagent is not in the host's status store at
+             * all — reading "no status" as "unknown" left every old subagent running forever.
+             */
+            const busy = status?.type === "busy" || status?.type === "retry";
+            emit([...translate.session(child), ...translate.history(history), busy ? {
+              type: "status",
+              id,
+              status: "busy",
+              at: Date.now()
+            } : {
+              type: "status",
+              id,
+              status: "idle",
+              at: Number(child.time?.updated) || Date.now()
+            }]);
+            await visit(id, depth + 1);
+          }
+        };
+        await visit(root, 0);
+      },
+      async send(id, text, _busy, agent) {
+        await v1.client.session.promptAsync({
+          sessionID: id,
+          agent,
+          parts: [{
+            type: "text",
+            text
+          }]
+        });
+      },
+      async stop(id) {
+        await v1.client.session.abort({
+          sessionID: id
+        });
+      },
+      async background(parentID) {
+        const result = await v1.client.experimental.session.background({
+          sessionID: parentID
+        });
+        return (result?.data ?? result) === true;
+      },
+      async quiet(sessionID, text, agent) {
+        await v1.client.session.promptAsync({
+          sessionID,
+          noReply: true,
+          ...(agent ? {
+            agent
+          } : {}),
+          parts: [{
+            type: "text",
+            text
+          }]
+        });
+      },
+      async note(sessionID, text, _busy, agent) {
+        await v1.client.session.promptAsync({
+          sessionID,
+          ...(agent ? {
+            agent
+          } : {}),
+          parts: [{
+            type: "text",
+            text
+          }]
+        });
+      },
+      check(id) {
+        const status = v1.state.session.status(id);
+        return status ? translate.event({
+          type: "session.status",
+          properties: {
+            sessionID: id,
+            status
+          }
+        }) : [];
+      },
+      dispose: () => {
+        for (const off of offs.splice(0)) off();
+      }
+    };
+  }
+  const v2 = api.v2;
+  const translate = createV2Translator(unknown);
+  const off = v2.data.listen(event => guard("event", () => emit(translate.event(event))));
+  if (typeof off === "function") offs.push(off);
+  return {
+    async load(root) {
+      const sessions = v2.data.session.list() ?? [];
+      const byId = new Map(sessions.map(s => [s.id, s]));
+      const family = new Set(v2.data.session.family(root) ?? []);
+      for (const id of family) {
+        const info = byId.get(id);
+        if (!info?.parentID) continue;
+        let messages = v2.data.session.message.list(id) ?? [];
+        if (messages.length === 0) {
+          await Promise.resolve(v2.data.session.message.sync(id)).catch(error => log.warn("history sync failed", {
+            id,
+            error
+          }));
+          messages = v2.data.session.message.list(id) ?? [];
+        }
+        const status = translate.status(id, v2.data.session.status(id));
+        emit([...translate.session(info), ...translate.history(id, messages), /** Not known to the host is not running: the same lesson as OpenCode 1's store. */
+        ...(status.length > 0 ? status : [{
+          type: "status",
+          id,
+          status: "idle",
+          at: Number(info.time?.updated) || Date.now()
+        }])]);
+      }
+    },
+    async send(id, text, busy) {
+      await v2.client.session.prompt({
+        sessionID: id,
+        text,
+        ...(busy ? {
+          delivery: "steer"
+        } : {})
+      });
+    },
+    async stop(id) {
+      await v2.client.session.interrupt({
+        sessionID: id
+      });
+    },
+    async background(parentID) {
+      await v2.client.session.background({
+        sessionID: parentID
+      });
+      return true;
+    },
+    async quiet(sessionID, text) {
+      await v2.client.session.synthetic({
+        sessionID,
+        text,
+        resume: false,
+        description: "Subagent exchange"
+      });
+    },
+    async note(sessionID, text, busy) {
+      await v2.client.session.prompt({
+        sessionID,
+        text,
+        ...(busy ? {
+          delivery: "steer"
+        } : {})
+      });
+    },
+    check(id) {
+      return translate.status(id, v2.data.session.status(id));
+    },
+    dispose: () => {
+      for (const each of offs.splice(0)) each();
+    }
+  };
+}

package/dist/tui/view/overlay.js

@@ -0,0 +1,87 @@
+import { effect as _$effect } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { use as _$use } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+/** @jsxImportSource @opentui/solid */
+// biome-ignore-all lint/a11y/noStaticElementInteractions: these are terminal boxes, not DOM elements
+
+/** Enough lines for any terminal: a slot's tree is read once, so the pool cannot grow later. */
+export const MAX_LINES = 300;
+/**
+ * The pane's surface — Review's shape: a full-window, transparent backdrop that catches clicks off
+ * the pane, and the pane inside it, right-aligned, half the window or all of it.
+ *
+ * **Nothing here is reactive.** The host reads a slot's children once (docs/opencode/gotchas.md), so
+ * the component hands its boxes up and the plugin assigns to them. Anchored bottom-right, because an
+ * absolute box is placed against the `app_bottom` container at the foot of the window. Only props a
+ * box actually uses: an unused one (`titleColor`) blanked Review's pane on OpenCode 2.
+ */
+export function Overlay(props) {
+  let backdrop;
+  let panel;
+  const lines = [];
+  /** Refs arrive child-first; act once every piece is here. */
+  const ready = () => {
+    if (backdrop && panel && lines.length === MAX_LINES) props.onReady({
+      backdrop,
+      panel,
+      lines
+    });
+  };
+  return (() => {
+    var _el$ = _$createElement("box"),
+      _el$2 = _$createElement("box");
+    _$insertNode(_el$, _el$2);
+    _$use(element => {
+      backdrop = element;
+      ready();
+    }, _el$);
+    _$setProp(_el$, "visible", false);
+    _$setProp(_el$, "position", "absolute");
+    _$setProp(_el$, "right", 0);
+    _$setProp(_el$, "bottom", 0);
+    _$setProp(_el$, "width", 20);
+    _$setProp(_el$, "height", 0);
+    _$setProp(_el$, "zIndex", 1000);
+    _$setProp(_el$, "flexDirection", "row");
+    _$setProp(_el$, "justifyContent", "flex-end");
+    _$setProp(_el$, "backgroundColor", "transparent");
+    _$setProp(_el$, "onMouseDown", () => props.onDismiss());
+    _$use(element => {
+      panel = element;
+      ready();
+    }, _el$2);
+    _$setProp(_el$2, "width", 20);
+    _$setProp(_el$2, "height", 0);
+    _$setProp(_el$2, "flexShrink", 0);
+    _$setProp(_el$2, "flexDirection", "column");
+    _$setProp(_el$2, "onMouseDown", event => event.stopPropagation());
+    _$setProp(_el$2, "onMouseUp", event => {
+      event.stopPropagation();
+      props.onClick(event.y);
+    });
+    _$setProp(_el$2, "onMouse", event => {
+      const scroll = event.scroll;
+      if (!scroll) return;
+      event.stopPropagation();
+      props.onScroll(scroll.direction === "up" ? -3 : 3);
+    });
+    _$insert(_el$2, () => Array.from({
+      length: MAX_LINES
+    }, () => (() => {
+      var _el$3 = _$createElement("text");
+      _$use(element => {
+        lines.push(element);
+        ready();
+      }, _el$3);
+      _$setProp(_el$3, "wrapMode", "none");
+      _$setProp(_el$3, "flexShrink", 0);
+      _$setProp(_el$3, "visible", false);
+      return _el$3;
+    })()));
+    _$effect(_$p => _$setProp(_el$2, "backgroundColor", props.api.theme.current.background, _$p));
+    return _el$;
+  })();
+}

package/dist/tui/view/sidebar.js

@@ -0,0 +1,78 @@
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { use as _$use } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+/** @jsxImportSource @opentui/solid */
+// biome-ignore-all lint/a11y/noStaticElementInteractions: these are terminal boxes, not DOM elements
+
+import { For } from "solid-js";
+import { fillColour, toneColour } from "../render.js";
+/**
+ * The Subagents block: the rows `core/view/sidebar.ts` produced, one `<text>` per row.
+ *
+ * Shell's and Status's sidebar pattern, proven live on both OpenCodes: a signal read by `<For>`
+ * redraws, where anything decided once in a slot's tree never would (docs/opencode/gotchas.md).
+ * Every line of a subagent opens it; mouse-up, not mouse-down, because the host acts on the release
+ * that follows (as Shell's sidebar found).
+ */
+export function SidebarBlock(props) {
+  const theme = () => props.api.theme.current;
+  return (() => {
+    var _el$ = _$createElement("box");
+    _$use(box => props.onReady?.(box), _el$);
+    _$setProp(_el$, "flexDirection", "column");
+    _$insert(_el$, _$createComponent(For, {
+      get each() {
+        return props.lines();
+      },
+      children: line => (() => {
+        var _el$2 = _$createElement("box"),
+          _el$3 = _$createElement("text");
+        _$insertNode(_el$2, _el$3);
+        _$setProp(_el$2, "flexDirection", "row");
+        _$setProp(_el$2, "onMouseUp", () => {
+          if (line.id) props.onOpen(line.id);
+        });
+        _$setProp(_el$3, "wrapMode", "none");
+        _$setProp(_el$3, "flexShrink", 0);
+        _$insert(_el$3, _$createComponent(For, {
+          get each() {
+            return line.row;
+          },
+          children: run => {
+            const style = {
+              fg: toneColour(theme(), run.tone),
+              ...(run.fill && run.fill !== "none" ? {
+                bg: fillColour(theme(), run.fill)
+              } : {})
+            };
+            return run.bold ? (() => {
+              var _el$4 = _$createElement("span"),
+                _el$5 = _$createElement("b");
+              _$insertNode(_el$4, _el$5);
+              _$setProp(_el$4, "style", style);
+              _$insert(_el$5, () => run.text);
+              return _el$4;
+            })() : run.faint ? (() => {
+              var _el$6 = _$createElement("span"),
+                _el$7 = _$createElement("i");
+              _$insertNode(_el$6, _el$7);
+              _$setProp(_el$6, "style", style);
+              _$insert(_el$7, () => run.text);
+              return _el$6;
+            })() : (() => {
+              var _el$8 = _$createElement("span");
+              _$setProp(_el$8, "style", style);
+              _$insert(_el$8, () => run.text);
+              return _el$8;
+            })();
+          }
+        }));
+        return _el$2;
+      })()
+    }));
+    return _el$;
+  })();
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@opencode-cockpit/subagents",
+  "version": "0.7.0",
+  "description": "See what your subagents are doing: in the sidebar, full screen, and message them",
+  "type": "module",
+  "license": "MIT",
+  "author": "Codestz",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Codestz/opencode-cockpit.git",
+    "directory": "packages/subagents"
+  },
+  "homepage": "https://github.com/Codestz/opencode-cockpit#readme",
+  "bugs": {
+    "url": "https://github.com/Codestz/opencode-cockpit/issues"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "subagents",
+    "agents",
+    "tui",
+    "terminal"
+  ],
+  "exports": {
+    "./server": {
+      "types": "./types/server.d.ts",
+      "default": "./dist/server.js"
+    },
+    "./tui": {
+      "types": "./types/tui/index.d.ts",
+      "default": "./dist/tui/index.js"
+    }
+  },
+  "engines": {
+    "opencode": ">=1.18.0",
+    "bun": ">=1.3.5"
+  },
+  "files": [
+    "server.js",
+    "tui.js",
+    "dist",
+    "types",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@opencode-cockpit/client": "0.7.0",
+    "@opencode-ai/plugin": "1.18.31"
+  },
+  "devDependencies": {
+    "@opentui/core": "0.4.5",
+    "@opentui/keymap": "0.4.5",
+    "@opentui/solid": "0.4.5",
+    "solid-js": "1.9.12"
+  },
+  "bin": {
+    "opencode-subagents": "./dist/cli/preview.js",
+    "subagents": "./dist/cli/preview.js"
+  }
+}

package/server.js

@@ -0,0 +1,6 @@
+/**
+ * OpenCode 2 finds a plugin configured by *path* by the files at its root — `<package>/tui`,
+ * `<package>/server` — rather than through `exports` (docs/opencode/v2.md). A package installed by
+ * name resolves through `exports` as before; this file is only the door for the path case.
+ */
+export { default } from "./dist/server.js"

package/tui.js

@@ -0,0 +1,6 @@
+/**
+ * OpenCode 2 finds a plugin configured by *path* by the files at its root — `<package>/tui`,
+ * `<package>/server` — rather than through `exports` (docs/opencode/v2.md). A package installed by
+ * name resolves through `exports` as before; this file is only the door for the path case.
+ */
+export { default } from "./dist/tui/index.js"

package/types/agent/plugin.d.ts

@@ -0,0 +1,32 @@
+import { type ServerStart } from "@opencode-cockpit/client/server";
+import type { Change } from "../core/model/changes.ts";
+/**
+ * What the agent is told about subagents, once per request.
+ *
+ * Measured on both OpenCodes (docs/opencode/agents.md): a subagent launched in the background lets the
+ * conversation carry on, and the main agent is told when it finishes. OpenCode 2 offers it on its
+ * `subagent` tool; OpenCode 1 only with `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true`, which a
+ * plugin cannot set — so the guidance says "if your tool offers it", and never promises it.
+ *
+ * Continuing a subagent was measured too: given its id, the same subagent picks up with everything it
+ * already read, and answers in seconds. Main agents rarely do it on their own — the id scrolls away —
+ * so the guidance asks for it, and `subagents_list` hands the ids back.
+ */
+export declare const GUIDANCE = "## Subagents (opencode-cockpit)\nWhen you delegate independent work to a subagent, launch it with background: true if your task or subagent tool offers that option, so this conversation continues while it works; you are notified when it finishes. Work on something else meanwhile, or tell the user what you launched.\nWhen the user asks for a fix or follow-up on work a subagent already did, continue that same subagent (task_id or sessionID) rather than launching a new one \u2014 it keeps its context. subagents_list gives each subagent's id, task and last answer.\nThe user can watch each subagent and message it directly; when they do, a note in this conversation tells you what they asked and what it answered.";
+export declare const SUBAGENTS_PACKAGE = "@opencode-cockpit/subagents";
+export interface SubagentsServerOptions {
+    source?: string;
+}
+/**
+ * What the agent side keeps of each run: enough to list it — not what calls printed, nor thinking, so
+ * a long session does not hold every file its subagents read.
+ */
+export declare function slim(changes: Change[]): Change[];
+/** The agent side as a factory, so the `opencode-cockpit` bundle can include it. */
+export declare function createSubagentsServer({ source, }?: SubagentsServerOptions): ServerStart;
+declare const _default: {
+    id: string;
+    server: (input: import("@opencode-ai/plugin").PluginInput, options?: unknown) => Promise<import("@opencode-ai/plugin").Hooks>;
+    setup: (ctx: import("@opencode-cockpit/client/server").V2ServerContext) => Promise<(() => Promise<void>) | undefined>;
+};
+export default _default;

package/types/cli/preview.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env bun
+/**
+ * The see-it loop: the sidebar block and the full screen, drawn in this terminal from a recorded run,
+ * with no OpenCode running. The same rows OpenCode draws — only the colours come from a fixed
+ * palette (OpenCode's default theme) instead of the user's.
+ *
+ *   bunx @opencode-cockpit/subagents preview            a sample run, mid-flight
+ *   bunx @opencode-cockpit/subagents preview --width 34 the sidebar at another width
+ */
+export {};

package/types/core/adapt/v1.d.ts

@@ -0,0 +1,33 @@
+/**
+ * OpenCode 1's events and state, as changes.
+ *
+ * OpenCode 1 describes a run as parts of messages: a part is created (`message.part.updated`), may
+ * stream (`message.part.delta`, which names the part but not its kind — so kinds are remembered), and
+ * is updated as it completes. A user message's text is what the session was told; an assistant's
+ * `reasoning` and `text` are its thinking and its answer; a `tool` part is a call. Shapes measured on
+ * 1.18.32 (test/fixtures/v1.jsonl).
+ *
+ * Anything it does not recognise it returns nothing for, and says so through `unknown` — a new event
+ * shape is logged, never guessed at.
+ */
+import type { Change } from "../model/changes.ts";
+type Json = Record<string, unknown>;
+export interface V1Translator {
+    /** One host event as changes. */
+    event(event: unknown, at?: number): Change[];
+    /** A session's stored messages (each `{ info, parts }`), for one that existed before we did. */
+    history(messages: readonly {
+        info: unknown;
+        parts: readonly unknown[];
+    }[], at?: number): Change[];
+    /** A session as `session.children` or `state.session.get` returns it. */
+    session(info: unknown, at?: number): Change[];
+}
+export declare function createV1Translator(unknown?: (what: string, detail?: Json) => void): V1Translator;
+/** `input + output + reasoning + cache`, the host's own total. */
+export declare function tokenTotal(tokens: Json): number;
+/** OpenCode 1 titles a subagent session "Task title (@explore subagent)"; the agent is shown apart. */
+export declare function stripAgentSuffix(title: string): string;
+/** A call's result in a few words, when the host gives the number. */
+export declare function summaryOf(tool: string | undefined, metadata: Json): string | undefined;
+export {};

package/types/core/adapt/v2.d.ts

@@ -0,0 +1,22 @@
+/**
+ * OpenCode 2's events and state, as changes.
+ *
+ * OpenCode 2 names what happened: `session.reasoning.delta`, `session.tool.called`,
+ * `session.execution.succeeded`. Its interface context hands them over as
+ * `{ name, details: { data } }` (`ctx.data.listen`). Thinking and text are keyed by the assistant
+ * message and their ordinal in it; a tool call by its id; what the session was told arrives as an
+ * inbox item. Shapes measured on 2.0.15 (test/fixtures/v2.jsonl).
+ */
+import type { Change } from "../model/changes.ts";
+type Json = Record<string, unknown>;
+export interface V2Translator {
+    event(event: unknown, at?: number): Change[];
+    /** One session's loaded messages (`ctx.data.session.message.list(id)`). */
+    history(id: string, messages: readonly unknown[], at?: number): Change[];
+    /** A session as `ctx.data.session.list()` returns it. */
+    session(info: unknown, at?: number): Change[];
+    /** A status as `ctx.data.session.status(id)` returns it: "busy", "idle"… */
+    status(id: string, status: unknown, at?: number): Change[];
+}
+export declare function createV2Translator(unknown?: (what: string, detail?: Json) => void): V2Translator;
+export {};