@azatakmyradov/opencode-recap-plugin 0.1.0

package/README.md

@@ -0,0 +1,54 @@
+# @azatakmyradov/opencode-recap-plugin
+
+OpenCode V2 plugin that writes a recap and suggested next step after each root-session run. It places the recap after the run's last message without adding it to the session history or future model context.
+
+## Install
+
+Install the plugin from npm:
+
+```bash
+opencode2 plugin add @azatakmyradov/opencode-recap-plugin
+opencode2 plugin list
+```
+
+The server entrypoint enables the TUI entrypoint. An unversioned install starts with its cached version and checks npm for updates in the background. A downloaded update takes effect the next time the service starts. Restart it now with:
+
+```bash
+opencode2 service restart
+```
+
+Use an exact package version for a reproducible install that does not update.
+
+## Recaps
+
+The plugin generates a recap when a run succeeds, fails, or is interrupted. It ignores child sessions. While generation runs, the prompt footer shows `generating run recap...`.
+
+The recap card contains a summary of up to 2,400 characters and a next step of up to 400 characters. OpenCode stores the latest recap for each root session outside its messages, so the card survives TUI restarts but never enters model context. New user input or a revert removes the old recap and cancels any recap still being generated.
+
+The model request times out after 45 seconds. If the request fails, times out, or returns invalid data, the plugin shows a warning and builds a local fallback from tool names and the last assistant response.
+
+Each open TUI instance handles session events on its own. If several instances are open, each one may request a recap for the same run.
+
+## Model
+
+Run `/recap-model` from the slash menu or choose "Choose recap model" from the command palette. The dialog lists enabled models and their declared variants. The selected model persists across TUI restarts.
+
+The default is `openai-codex/gpt-5.6-luna#medium`.
+
+## Transcript data
+
+The plugin sends the selected provider a transcript of the current run. The transcript can contain user and assistant text, shell commands and output, arguments and textual results from completed or failed tools, and execution errors.
+
+The transcript excludes reasoning, files, binary tool output, system and skill messages, and compaction records. Tool arguments and shell commands are capped at 2 KB each. Tool results and shell output are capped at 5 KB each. The full transcript is capped at 48 KB and keeps content from its beginning and end when truncated.
+
+The plugin redacts common secret formats and values under keys such as `token`, `password`, and `apiKey`. This is a best-effort filter, not a security boundary. Do not send sensitive session data to a recap provider you do not trust.
+
+## Development
+
+For local development, run `bun install`. Add `packages/recap/src/index.ts` to `opencode.jsonc` and `packages/recap/src/tui.tsx` to the global CLI plugin configuration. OpenCode cannot find the package-level `./tui` export when it loads the server source file directly, so you must add both entries.
+
+```bash
+bun run --filter @azatakmyradov/opencode-recap-plugin check
+bun run --filter @azatakmyradov/opencode-recap-plugin test
+bun run check
+```

package/dist/index.js

@@ -0,0 +1,12 @@
+// @bun
+// src/index.ts
+import { Effect } from "effect";
+import { Plugin } from "@opencode-ai/plugin/effect";
+var src_default = Plugin.define({
+  id: "recap",
+  tui: true,
+  effect: () => Effect.void
+});
+export {
+  src_default as default
+};

package/dist/tui.js

@@ -0,0 +1,786 @@
+// @bun
+// src/tui.tsx
+import { setProp as _$setProp2 } from "@opentui/solid";
+import { effect as _$effect2 } from "@opentui/solid";
+import { createTextNode as _$createTextNode2 } from "@opentui/solid";
+import { insertNode as _$insertNode2 } from "@opentui/solid";
+import { createElement as _$createElement2 } from "@opentui/solid";
+import { memo as _$memo2 } from "@opentui/solid";
+import { createComponent as _$createComponent2 } from "@opentui/solid";
+import { Plugin } from "@opencode-ai/plugin/tui";
+import { Cause as Cause2, Effect as Effect3, ManagedRuntime } from "effect";
+import { Show as Show2 } from "solid-js";
+
+// src/core/controller.ts
+import { Cause, Clock, Context, Effect, FiberMap, Layer, Ref } from "effect";
+
+// src/core/transcript.ts
+var TOOL_ARGUMENT_MAX_BYTES = 2000;
+var TOOL_RESULT_MAX_BYTES = 5000;
+var TRANSCRIPT_MAX_BYTES = 48000;
+var ARGUMENT_MAX_DEPTH = 6;
+var ARGUMENT_MAX_ITEMS = 30;
+var SECRET_KEY = /(?:api[_-]?key|access[_-]?key|authorization|cookie|credential|password|passwd|private[_-]?key|secret|token)/i;
+function redactSecrets(text) {
+  return text.replace(/\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]+/gi, "$1 [REDACTED]").replace(/\b(sk-[A-Za-z0-9_-]{12,}|gh[pousr]_[A-Za-z0-9_]{12,}|eyJ[A-Za-z0-9_-]{12,}\.[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,})\b/g, "[REDACTED]").replace(/(["']?(?:api[_-]?key|access[_-]?key|authorization|cookie|credential|password|passwd|private[_-]?key|secret|token)["']?\s*[:=]\s*)(["']?)[^\s,;}]+\2/gi, "$1[REDACTED]").replace(/([?&](?:api[_-]?key|access[_-]?token|key|secret|token)=)[^&#\s]+/gi, "$1[REDACTED]");
+}
+function truncateUtf8(text, bytes) {
+  if (Buffer.byteLength(text) <= bytes) {
+    return text;
+  }
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(text.slice(0, mid)) <= bytes) {
+      low = mid;
+    } else {
+      high = mid - 1;
+    }
+  }
+  const end = /[\uD800-\uDBFF]/.test(text.charAt(low - 1)) ? low - 1 : low;
+  return text.slice(0, end);
+}
+function capped(text, bytes, notice) {
+  if (Buffer.byteLength(text) <= bytes) {
+    return text;
+  }
+  const suffix = `
+[${notice}]`;
+  return `${truncateUtf8(text, bytes - Buffer.byteLength(suffix))}${suffix}`;
+}
+function sanitizeArgument(value, depth = 0, seen = new WeakSet) {
+  if (depth >= ARGUMENT_MAX_DEPTH) {
+    return "[nested value omitted]";
+  }
+  if (typeof value === "string") {
+    return redactSecrets(value);
+  }
+  if (value === null || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value !== "object") {
+    return `[${typeof value} omitted]`;
+  }
+  if (seen.has(value)) {
+    return "[cyclic value omitted]";
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const items = value.slice(0, ARGUMENT_MAX_ITEMS).map((item) => sanitizeArgument(item, depth + 1, seen));
+    if (value.length > ARGUMENT_MAX_ITEMS) {
+      items.push("[additional items omitted]");
+    }
+    return items;
+  }
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+    key,
+    SECRET_KEY.test(key) ? "[REDACTED]" : sanitizeArgument(item, depth + 1, seen)
+  ]));
+}
+function toolText(content) {
+  const text = content?.flatMap((part) => part.type === "text" && part.text ? [part.text] : []).join(`
+`);
+  return redactSecrets(text ?? "");
+}
+function serializeMessage(message) {
+  if (message.type === "user") {
+    return message.text ? [`USER
+${redactSecrets(message.text)}`] : [];
+  }
+  if (message.type === "shell") {
+    const command = capped(redactSecrets(message.command), TOOL_ARGUMENT_MAX_BYTES, "command capped");
+    const output = capped(redactSecrets(message.output?.output ?? ""), TOOL_RESULT_MAX_BYTES, "command output capped");
+    return [
+      `USER SHELL${message.exit === undefined ? "" : ` (exit ${message.exit})`}
+${command}
+${output}`
+    ];
+  }
+  if (message.type !== "assistant") {
+    return [];
+  }
+  const sections = [];
+  const text = message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+`);
+  if (text) {
+    sections.push(`ASSISTANT
+${redactSecrets(text)}`);
+  }
+  for (const part of message.content) {
+    if (part.type !== "tool" || part.state.status !== "completed" && part.state.status !== "error") {
+      continue;
+    }
+    let args;
+    try {
+      args = JSON.stringify(sanitizeArgument(part.state.input), null, 2);
+    } catch {
+      args = "[tool arguments could not be serialized]";
+    }
+    sections.push(`TOOL CALL ${part.name}
+${capped(redactSecrets(args), TOOL_ARGUMENT_MAX_BYTES, "tool arguments capped")}`);
+    const content = "content" in part.state ? part.state.content : undefined;
+    const result = capped(toolText(content), TOOL_RESULT_MAX_BYTES, "tool result capped");
+    sections.push(`TOOL RESULT ${part.name}${part.state.status === "error" ? " (error)" : ""}
+${result || "(no text output)"}`);
+  }
+  return sections;
+}
+function serializeRunTranscript(messages, detail, maxBytes = TRANSCRIPT_MAX_BYTES) {
+  const sections = messages.flatMap(serializeMessage);
+  if (detail) {
+    sections.push(redactSecrets(detail));
+  }
+  const transcript = sections.join(`
+
+---
+
+`) || "(no textual run output)";
+  if (Buffer.byteLength(transcript) <= maxBytes) {
+    return transcript;
+  }
+  const marker = `
+
+[... transcript capped; middle omitted ...]
+
+`;
+  const remaining = maxBytes - Buffer.byteLength(marker);
+  const head = truncateUtf8(transcript, Math.floor(remaining * 0.58));
+  const chars = Array.from(transcript);
+  const reversedTail = truncateUtf8(chars.reverse().join(""), remaining - Buffer.byteLength(head));
+  const tail = Array.from(reversedTail).reverse().join("");
+  return `${head}${marker}${tail}`;
+}
+function buildFallbackRecap(messages, outcome = "completed") {
+  const tools = [];
+  let final = "";
+  for (const message of messages) {
+    if (message.type !== "assistant") {
+      continue;
+    }
+    for (const part of message.content) {
+      if (part.type === "tool") {
+        tools.push(part.name);
+      }
+      if (part.type === "text" && part.text.trim()) {
+        final = redactSecrets(part.text.trim());
+      }
+    }
+  }
+  const names = [...new Set(tools)];
+  let activity = "";
+  if (names.length) {
+    const toolCallLabel = tools.length === 1 ? "tool call" : "tool calls";
+    activity = ` The run used ${tools.length} ${toolCallLabel} across ${names.join(", ")}.`;
+  }
+  const result = final ? ` ${capped(final.replace(/\s+/g, " "), 700, "final response capped")}` : "";
+  return {
+    recap: `The main-agent run ${outcome}.${activity}${result}`.trim(),
+    next: "Review the completed work above and continue if anything remains."
+  };
+}
+function selectRunMessages(messages, baseline) {
+  return messages.filter((message) => !baseline.has(message.id));
+}
+
+// src/core/controller.ts
+class RecapControllerService extends Context.Service()("opencode-recap-plugin/RecapController") {
+}
+var createRecapController = Effect.fn("createRecapController")(function* (deps) {
+  const state = yield* Ref.make({
+    inboxBaselines: new Map,
+    runs: new Map
+  });
+  const active = yield* FiberMap.make();
+  const invalidate = Effect.fn("RecapController.invalidate")(function* (sessionID) {
+    yield* FiberMap.remove(active, sessionID);
+    yield* Ref.modify(state, (current) => {
+      const runs = new Map(current.runs);
+      runs.delete(sessionID);
+      return [undefined, { ...current, runs }];
+    });
+    yield* deps.persist(undefined, sessionID);
+  });
+  const inbox = Effect.fn("RecapController.inbox")(function* (sessionID, user) {
+    if (!user || deps.session(sessionID)?.parentID) {
+      return;
+    }
+    const baseline = new Set(deps.messages(sessionID).map((message) => message.id));
+    yield* Ref.modify(state, (current) => {
+      const inboxBaselines = new Map(current.inboxBaselines);
+      const runs = new Map(current.runs);
+      inboxBaselines.set(sessionID, baseline);
+      runs.delete(sessionID);
+      return [undefined, { inboxBaselines, runs }];
+    });
+    yield* FiberMap.remove(active, sessionID);
+    yield* deps.persist(undefined, sessionID);
+  });
+  const started = Effect.fn("RecapController.started")(function* (sessionID) {
+    if (deps.session(sessionID)?.parentID) {
+      return;
+    }
+    yield* FiberMap.remove(active, sessionID);
+    yield* deps.syncMessages(sessionID);
+    const currentMessages = deps.messages(sessionID);
+    yield* Ref.modify(state, (current) => {
+      const inboxBaselines = new Map(current.inboxBaselines);
+      const runs = new Map(current.runs);
+      const baseline = inboxBaselines.get(sessionID) ?? new Set(currentMessages.map((message) => message.id));
+      inboxBaselines.delete(sessionID);
+      runs.set(sessionID, baseline);
+      return [undefined, { inboxBaselines, runs }];
+    });
+    yield* deps.persist(undefined, sessionID);
+  });
+  const terminal = Effect.fn("RecapController.terminal")(function* (input) {
+    const baseline = yield* Ref.modify(state, (current) => {
+      const runs = new Map(current.runs);
+      const boundary = runs.get(input.sessionID);
+      runs.delete(input.sessionID);
+      return [boundary, { ...current, runs }];
+    });
+    if (!baseline) {
+      return;
+    }
+    const generation = Effect.gen(function* () {
+      yield* deps.syncMessages(input.sessionID);
+      const messages = selectRunMessages(deps.messages(input.sessionID), baseline);
+      if (messages.length === 0) {
+        return;
+      }
+      const model = deps.model();
+      const result = yield* deps.generate({
+        transcript: serializeRunTranscript(messages, input.detail),
+        model
+      }).pipe(Effect.map((recap) => ({ recap, fallback: false })), Effect.catch((error) => deps.warning(`The recap model failed; showing a local fallback. ${error.message}`).pipe(Effect.as({
+        recap: buildFallbackRecap(messages, input.outcome),
+        fallback: true
+      }))));
+      const created = yield* Clock.currentTimeMillis;
+      yield* deps.persist({
+        ...result.recap,
+        sessionID: input.sessionID,
+        model,
+        outcome: input.outcome,
+        fallback: result.fallback,
+        terminalEventID: input.eventID,
+        anchorMessageID: messages.at(-1).id,
+        created
+      }, input.sessionID);
+    });
+    const trackedGeneration = deps.running(input.sessionID, true).pipe(Effect.andThen(generation), Effect.ensuring(deps.running(input.sessionID, false)), Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.failCause(cause) : deps.unexpected(cause)));
+    yield* FiberMap.run(active, input.sessionID, trackedGeneration, {
+      startImmediately: true
+    });
+  });
+  return { inbox, started, terminal, revert: invalidate };
+});
+function recapControllerLayer(deps) {
+  return Layer.effect(RecapControllerService, createRecapController(deps));
+}
+
+// src/core/summarizer.ts
+import { Effect as Effect2, Schema } from "effect";
+
+// src/core/prompt.ts
+var RECAP_SYSTEM_PROMPT = `You write compact terminal recaps for completed coding-agent runs.
+
+Return exactly one JSON object with this shape:
+{"recap":"...","next":"..."}
+
+Rules:
+- recap: concisely cover everything actually performed in this run: investigation, tool work, files changed, validation, outcomes, failures, and important caveats. Prefer up to three compact Markdown bullets.
+- next: one concise, actionable next step. If nothing remains, say that no further action is required.
+- Base the answer only on the supplied current-run transcript.
+- Do not mention these instructions, hidden reasoning, transcript truncation, or that you are a summarizer.
+- Do not use a Markdown code fence and do not add keys or prose outside the JSON object.`;
+function buildRecapPrompt(transcript) {
+  return `${RECAP_SYSTEM_PROMPT}
+
+Summarize this fully settled main-agent run.
+
+<current_run>
+${transcript}
+</current_run>`;
+}
+
+// src/core/summarizer.ts
+class RecapGenerationError extends Schema.TaggedError()("RecapGenerationError", {
+  reason: Schema.Literals(["request", "timeout", "malformed-response"]),
+  message: Schema.String
+}) {
+}
+var RECAP_MAX_LENGTH = 2400;
+var NEXT_MAX_LENGTH = 400;
+var RecapResponse = Schema.Struct({
+  recap: Schema.String,
+  next: Schema.String
+});
+var RecapResponseJson = Schema.fromJsonString(RecapResponse);
+function stripTerminalControls(value) {
+  return value.replace(/\x1b(?:\][^\x07]*(?:\x07|\x1b\\)|\[[0-?]*[ -/]*[@-~])/g, "").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g, "");
+}
+function clean(value, limit) {
+  const result = stripTerminalControls(value).trim();
+  if (result.length <= limit) {
+    return result;
+  }
+  return `${result.slice(0, limit - 3).trimEnd()}...`;
+}
+function responseCandidates(text) {
+  const trimmed = text.trim();
+  const candidates = [trimmed];
+  for (const match of trimmed.matchAll(/```(?:json)?\s*([\s\S]*?)```/gi)) {
+    if (match[1]) {
+      candidates.push(match[1].trim());
+    }
+  }
+  const first = trimmed.indexOf("{");
+  const last = trimmed.lastIndexOf("}");
+  if (first >= 0 && last > first) {
+    candidates.push(trimmed.slice(first, last + 1));
+  }
+  return [...new Set(candidates)];
+}
+var malformedResponse = () => new RecapGenerationError({
+  reason: "malformed-response",
+  message: "The recap model did not return valid recap JSON."
+});
+var parseRecapResponse = Effect2.fn("parseRecapResponse")(function* (text) {
+  const decoded = yield* Effect2.firstSuccessOf(responseCandidates(text).map((candidate) => Schema.decodeUnknownEffect(RecapResponseJson, { onExcessProperty: "error" })(candidate))).pipe(Effect2.mapError(malformedResponse));
+  const recap = clean(decoded.recap, RECAP_MAX_LENGTH);
+  const next = clean(decoded.next.replace(/^next\s*:\s*/i, ""), NEXT_MAX_LENGTH);
+  if (!recap || !next) {
+    return yield* malformedResponse();
+  }
+  return { recap, next };
+});
+var summarizeRun = Effect2.fn("summarizeRun")(function* (options) {
+  const text = yield* options.generate({
+    prompt: buildRecapPrompt(options.transcript),
+    model: options.model
+  }).pipe(Effect2.timeout(options.timeoutMs ?? 45000), Effect2.mapError((error) => error._tag === "TimeoutError" ? new RecapGenerationError({
+    reason: "timeout",
+    message: "The recap model request timed out."
+  }) : error));
+  return yield* parseRecapResponse(text);
+});
+
+// src/tui/inline.tsx
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { isRenderable } from "@opentui/core";
+import { Portal } from "@opentui/solid";
+import { createSignal, onCleanup, onMount, Show } from "solid-js";
+
+// src/tui/card.tsx
+import { effect as _$effect } from "@opentui/solid";
+import { memo as _$memo } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+function RecapCard(props) {
+  return (() => {
+    var _el$ = _$createElement("box"), _el$2 = _$createElement("text"), _el$3 = _$createElement("b"), _el$5 = _$createElement("text"), _el$6 = _$createElement("text");
+    _$insertNode(_el$, _el$2);
+    _$insertNode(_el$, _el$5);
+    _$insertNode(_el$, _el$6);
+    _$setProp(_el$, "flexDirection", "column");
+    _$setProp(_el$, "marginTop", 1);
+    _$setProp(_el$, "paddingLeft", 3);
+    _$insertNode(_el$2, _el$3);
+    _$insertNode(_el$3, _$createTextNode(`Summary:`));
+    _$insert(_el$5, () => props.recap.recap);
+    _$insert(_el$6, () => `Next: ${props.recap.next}`);
+    _$insert(_el$, (() => {
+      var _c$ = _$memo(() => !!props.recap.fallback);
+      return () => _c$() ? (() => {
+        var _el$7 = _$createElement("text");
+        _$insertNode(_el$7, _$createTextNode(`Local fallback`));
+        _$effect((_$p) => _$setProp(_el$7, "fg", props.theme.text.muted, _$p));
+        return _el$7;
+      })() : null;
+    })(), null);
+    _$effect((_p$) => {
+      var _v$ = props.theme.text.muted, _v$2 = props.theme.text.default, _v$3 = props.theme.text.muted;
+      _v$ !== _p$.e && (_p$.e = _$setProp(_el$2, "fg", _v$, _p$.e));
+      _v$2 !== _p$.t && (_p$.t = _$setProp(_el$5, "fg", _v$2, _p$.t));
+      _v$3 !== _p$.a && (_p$.a = _$setProp(_el$6, "fg", _v$3, _p$.a));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined,
+      a: undefined
+    });
+    return _el$;
+  })();
+}
+
+// src/tui/inline.tsx
+function assistantContentRowCount(content) {
+  let rows = 0;
+  let group;
+  for (const part of content) {
+    if ((part.type === "text" || part.type === "reasoning") && !part.text?.trim()) {
+      continue;
+    }
+    let nextGroup;
+    if (part.type === "reasoning") {
+      nextGroup = "reasoning";
+    } else if (part.type === "tool" && ["read", "glob", "grep"].includes(part.name?.toLowerCase() ?? "")) {
+      nextGroup = "exploration";
+    }
+    if (!nextGroup || nextGroup !== group) {
+      rows++;
+    }
+    group = nextGroup;
+  }
+  return rows;
+}
+function recapInsertionIndex(children, anchor, card, messageIDs, contentRows) {
+  const ordered = children.filter((child) => child !== card);
+  const anchorIndex = ordered.indexOf(anchor);
+  const cardIndex = children.indexOf(card);
+  if (anchorIndex < 0 || cardIndex < 0) {
+    return;
+  }
+  if (contentRows !== undefined) {
+    return Math.min(anchorIndex + contentRows, ordered.length);
+  }
+  const nextBoundary = ordered.findIndex((child, index) => index > anchorIndex && (child.id === "session-navigation-slack" || messageIDs.has(child.id)));
+  return nextBoundary < 0 ? ordered.length : nextBoundary;
+}
+function InlineRecap(props) {
+  const [mount, setMount] = createSignal();
+  let card;
+  function placeCard(parent, anchor) {
+    if (!card || card.parent !== parent) {
+      return;
+    }
+    const children = parent.getChildren();
+    const cardIndex = children.indexOf(card);
+    const targetIndex = recapInsertionIndex(children, anchor, card, props.messageIDs, props.contentRows);
+    if (targetIndex === undefined || cardIndex === targetIndex) {
+      return;
+    }
+    parent.remove(card);
+    parent.add(card, targetIndex);
+  }
+  function sync() {
+    const anchor = props.renderer.root.findDescendantById(props.recap.anchorMessageID);
+    const parent = isRenderable(anchor?.parent) ? anchor.parent : undefined;
+    if (parent !== mount()) {
+      setMount(parent);
+    }
+    if (parent && isRenderable(anchor)) {
+      placeCard(parent, anchor);
+    }
+  }
+  onMount(() => {
+    props.renderer.on("frame", sync);
+    sync();
+  });
+  onCleanup(() => {
+    props.renderer.off("frame", sync);
+    card = undefined;
+  });
+  return _$createComponent(Show, {
+    get when() {
+      return mount();
+    },
+    keyed: true,
+    children: (parent) => _$createComponent(Portal, {
+      mount: parent,
+      ref: (element) => {
+        if (!isRenderable(element)) {
+          return;
+        }
+        card = element;
+        sync();
+      },
+      get children() {
+        return _$createComponent(RecapCard, {
+          get recap() {
+            return props.recap;
+          },
+          get theme() {
+            return props.theme;
+          }
+        });
+      }
+    })
+  });
+}
+
+// src/tui.tsx
+var DEFAULT_MODEL = {
+  providerID: "openai-codex",
+  id: "gpt-5.6-luna",
+  variant: "medium"
+};
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var tui_default = Plugin.define({
+  id: "recap",
+  setup(context) {
+    const [state, updateState] = context.storage.store("state", {
+      initial: {
+        model: DEFAULT_MODEL,
+        recaps: {}
+      }
+    });
+    const [runtime, updateRuntime] = context.storage.memory("runtime", {
+      initial: {
+        running: {}
+      }
+    });
+    const selectRecapModel = Effect3.fn("selectRecapModel")(function* () {
+      const location = context.location ?? context.data.location.default();
+      yield* Effect3.tryPromise(() => context.data.location.model.sync(location));
+      const models = yield* Effect3.sync(() => (context.data.location.model.list(location) ?? []).filter((model2) => model2.enabled));
+      const selected = yield* Effect3.tryPromise(() => context.ui.dialog.select({
+        title: "Recap model",
+        current: `${state.model.providerID}/${state.model.id}`,
+        options: models.map((model2) => ({
+          title: model2.name,
+          description: `${model2.providerID}/${model2.id}`,
+          value: `${model2.providerID}/${model2.id}`
+        }))
+      }));
+      if (!selected) {
+        return;
+      }
+      const model = models.find((item) => `${item.providerID}/${item.id}` === selected);
+      let variant;
+      if (model.variants.length) {
+        variant = yield* Effect3.tryPromise(() => context.ui.dialog.select({
+          title: "Recap model variant",
+          current: state.model.variant,
+          options: model.variants.map((item) => ({
+            title: item.id,
+            value: item.id
+          }))
+        }));
+        if (!variant) {
+          return;
+        }
+      }
+      yield* Effect3.tryPromise(() => updateState((draft) => {
+        draft.model = {
+          providerID: model.providerID,
+          id: model.id,
+          ...variant ? {
+            variant
+          } : {}
+        };
+      }));
+      yield* Effect3.sync(() => context.ui.toast.show({
+        title: "Recap",
+        message: `Recap model: ${model.providerID}/${model.id}${variant ? `#${variant}` : ""}`,
+        variant: "success"
+      }));
+    });
+    const controllerRuntime = ManagedRuntime.make(recapControllerLayer({
+      session(sessionID) {
+        return context.data.session.get(sessionID);
+      },
+      syncMessages(sessionID) {
+        return Effect3.tryPromise(() => context.data.session.message.sync(sessionID));
+      },
+      messages(sessionID) {
+        return context.data.session.message.list(sessionID);
+      },
+      model() {
+        return {
+          ...state.model
+        };
+      },
+      generate({
+        transcript,
+        model
+      }) {
+        return summarizeRun({
+          transcript,
+          model,
+          generate(request) {
+            return Effect3.tryPromise({
+              try: (signal) => context.client.generate.text({
+                prompt: request.prompt,
+                model: request.model
+              }, {
+                signal
+              }).then((result) => result.text),
+              catch: (error) => new RecapGenerationError({
+                reason: "request",
+                message: `The recap model request failed. ${errorMessage(error)}`
+              })
+            });
+          }
+        });
+      },
+      persist(recap, sessionID) {
+        return Effect3.tryPromise(() => updateState((draft) => {
+          if (!recap) {
+            delete draft.recaps[sessionID];
+            return;
+          }
+          if (draft.recaps[sessionID]?.terminalEventID !== recap.terminalEventID) {
+            draft.recaps[sessionID] = recap;
+          }
+        }));
+      },
+      running(sessionID, value) {
+        return Effect3.sync(() => updateRuntime((draft) => {
+          if (value) {
+            draft.running[sessionID] = true;
+          } else {
+            delete draft.running[sessionID];
+          }
+        }));
+      },
+      warning(message) {
+        return Effect3.sync(() => context.ui.toast.show({
+          title: "Recap",
+          message,
+          variant: "warning"
+        }));
+      },
+      unexpected: reportUnexpected
+    }));
+    function reportUnexpected(cause) {
+      return Effect3.sync(() => {
+        const message = errorMessage(Cause2.squash(cause));
+        console.error(`opencode-recap-plugin: ${message}`);
+        context.ui.toast.show({
+          title: "Recap",
+          message: `Recap failed unexpectedly. ${message}`,
+          variant: "warning"
+        });
+      }).pipe(Effect3.catchCause(() => Effect3.void));
+    }
+    function runEffect(effect) {
+      const handled = effect.pipe(Effect3.catchCause((cause) => Cause2.hasInterruptsOnly(cause) ? Effect3.void : reportUnexpected(cause)));
+      controllerRuntime.runPromise(handled).catch((error) => {
+        console.error(`opencode-recap-plugin: ${errorMessage(error)}`);
+      });
+    }
+    const stops = [context.data.on("session.inbox.enqueued", (event) => runEffect(RecapControllerService.use((controller) => controller.inbox(event.data.sessionID, event.data.item.type === "user")))), context.data.on("session.execution.started", (event) => runEffect(RecapControllerService.use((controller) => controller.started(event.data.sessionID)))), context.data.on("session.execution.succeeded", (event) => runEffect(RecapControllerService.use((controller) => controller.terminal({
+      sessionID: event.data.sessionID,
+      eventID: event.id,
+      outcome: "succeeded"
+    })))), context.data.on("session.execution.failed", (event) => runEffect(RecapControllerService.use((controller) => controller.terminal({
+      sessionID: event.data.sessionID,
+      eventID: event.id,
+      outcome: "failed",
+      detail: `EXECUTION FAILED
+${event.data.error.type}: ${event.data.error.message}`
+    })))), context.data.on("session.execution.interrupted", (event) => runEffect(RecapControllerService.use((controller) => controller.terminal({
+      sessionID: event.data.sessionID,
+      eventID: event.id,
+      outcome: "interrupted",
+      detail: `EXECUTION INTERRUPTED
+${event.data.reason}`
+    })))), context.data.on("session.revert.staged", (event) => runEffect(RecapControllerService.use((controller) => controller.revert(event.data.sessionID))))];
+    function AppExtensions() {
+      context.keymap.layer(() => ({
+        mode: "global",
+        priority: 10,
+        commands: [{
+          id: "recap.model",
+          title: "Choose recap model",
+          group: "Recap",
+          palette: true,
+          bind: false,
+          slash: {
+            name: "recap-model"
+          },
+          run: () => runEffect(selectRecapModel())
+        }]
+      }));
+      function currentSessionID() {
+        const route = context.ui.router.current();
+        return route.type === "session" ? route.sessionID : undefined;
+      }
+      return _$createComponent2(Show2, {
+        get when() {
+          return currentSessionID();
+        },
+        keyed: true,
+        children: (sessionID) => _$createComponent2(Show2, {
+          get when() {
+            return currentRecap(sessionID);
+          },
+          keyed: true,
+          children: (recap) => _$createComponent2(InlineRecap, {
+            recap,
+            get messageIDs() {
+              return new Set(context.data.session.message.list(sessionID).map((message) => message.id));
+            },
+            get contentRows() {
+              return anchorContentRowCount(sessionID, recap.anchorMessageID);
+            },
+            get renderer() {
+              return context.renderer;
+            },
+            get theme() {
+              return context.theme;
+            }
+          })
+        })
+      });
+    }
+    function anchorContentRowCount(sessionID, anchorMessageID) {
+      const message = context.data.session.message.get(sessionID, anchorMessageID);
+      if (message?.type !== "assistant") {
+        return;
+      }
+      return assistantContentRowCount(message.content);
+    }
+    function currentRecap(sessionID) {
+      const recap = state.recaps[sessionID];
+      if (!recap || context.data.session.get(sessionID)?.revert) {
+        return;
+      }
+      const messages = context.data.session.message.list(sessionID);
+      const anchor = messages.findIndex((message) => message.id === recap.anchorMessageID);
+      if (anchor < 0 || messages.slice(anchor + 1).some((message) => message.type === "user")) {
+        return;
+      }
+      return recap;
+    }
+    const removeApp = context.ui.slot({
+      append: "app",
+      render: AppExtensions
+    });
+    const removeStatus = context.ui.slot({
+      append: "prompt.footer.status",
+      render: ({
+        sessionID
+      }) => _$createComponent2(Show2, {
+        get when() {
+          return sessionID && runtime.running[sessionID];
+        },
+        get children() {
+          var _el$ = _$createElement2("text");
+          _$insertNode2(_el$, _$createTextNode2(`\u25CF generating run recap...`));
+          _$effect2((_$p) => _$setProp2(_el$, "fg", context.theme.text.status.running, _$p));
+          return _el$;
+        }
+      })
+    });
+    return () => {
+      for (const stop of stops) {
+        stop();
+      }
+      removeStatus();
+      removeApp();
+      return controllerRuntime.dispose();
+    };
+  }
+});
+export {
+  tui_default as default
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@azatakmyradov/opencode-recap-plugin",
+  "version": "0.1.0",
+  "description": "Run recaps and suggested next steps for the OpenCode V2 TUI",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "recap",
+    "tui"
+  ],
+  "homepage": "https://github.com/azatakmyradov/opencode-plugins/tree/main/packages/recap",
+  "bugs": "https://github.com/azatakmyradov/opencode-plugins/issues",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/azatakmyradov/opencode-plugins.git",
+    "directory": "packages/recap"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./tui": "./dist/tui.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bun ../../scripts/build.ts .",
+    "check": "tsc --noEmit",
+    "prepack": "bun run build",
+    "test": "vp test run"
+  },
+  "dependencies": {
+    "@opencode-ai/client": "0.0.0-beta-18414",
+    "@opencode-ai/plugin": "0.0.0-beta-18414",
+    "effect": "4.0.0-rc.111"
+  },
+  "peerDependencies": {
+    "@opentui/core": ">=0.5.8",
+    "@opentui/solid": ">=0.5.8",
+    "solid-js": ">=1.9.0"
+  },
+  "peerDependenciesMeta": {
+    "@opentui/core": {
+      "optional": true
+    },
+    "@opentui/solid": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    }
+  }
+}