opencode-summary 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 frostehhh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,140 @@
-# Temporary Holding Version
+# opencode-summary
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![CI](https://github.com/frostehhh/opencode-summary/actions/workflows/ci.yml/badge.svg)](https://github.com/frostehhh/opencode-summary/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+TUI plugin for [opencode](https://opencode.ai) V2. `/summary` opens a modal that generates and shows a summary of the
+current session using `session.generate` (the session's current model; the conversation history is not changed). The
+summary is stored in session metadata (`metadata["opencode-summary"]`), and a footer indicator shows how many turns ago
+it was made.
+
+## Install
+
+Add the plugin to your TUI config (`cli.json`), since it is a TUI-only plugin:
+
+```json
+{ "plugins": ["github:frostehhh/opencode-summary#v0.1.0"] }
+```
+
+Or install it with the CLI:
+
+```sh
+opencode plugin add github:frostehhh/opencode-summary#v0.1.0
+```
+
+Replace `v0.1.0` with the [release](https://github.com/frostehhh/opencode-summary/releases) you want. Omit the `#tag`
+to follow the default branch. Restart opencode afterwards.
+
+### Local development
+
+Clone the repo and symlink it into the global plugin directory, where the TUI discovers it:
+
+```sh
+git clone https://github.com/frostehhh/opencode-summary
+ln -s "$PWD/opencode-summary" ~/.config/opencode/plugins/opencode-summary
+```
+
+Edits hot-reload in a running TUI.
+
+## Usage
+
+Run `/summary` (or "Open summary modal" in the command palette) inside a session.
+
+| Key | Action |
+|---|---|
+| `g` | generate a summary |
+| `v` | toggle prompt view |
+| `c` | copy the summary (summary view) |
+| `e` | edit the prompt (prompt view) |
+| `r` | reset the prompt (prompt view) |
+| `j`/`k`, `↑`/`↓` | scroll |
+| `esc` | close |
+
+Bind a global key in `cli.json` with `keybinds`: `{"summary.open": "<key>"}`.
+
+### Commands
+
+Palette group "Summary". Only the first has a slash command.
+
+| Command | Id | Does |
+|---|---|---|
+| Open summary modal | `summary.open` (`/summary`) | opens the modal |
+| Generate summary | `summary.generate` | generates without the modal |
+| Copy summary | `summary.copy` | copies the stored summary |
+| Delete summary | `summary.delete` | removes the stored summary, after confirm |
+| View summary prompt | `summary.prompt.view` | modal in prompt view |
+| Edit summary prompt | `summary.prompt.edit` | `$VISUAL`/`$EDITOR`, else modal editor |
+| Reset summary prompt | `summary.prompt.reset` | deletes the override, after confirm |
+| Toggle summary footer indicator | `summary.indicator.toggle` | hides or shows `summary N turns ago` (the spinner stays) |
+
+The indicator setting is persisted, so it survives restarts.
+
+## Prompt
+
+The default prompt is in [`src/prompt.ts`](src/prompt.ts). Your own prompt is stored at:
+
+```
+$XDG_CONFIG_HOME/opencode/opencode-summary/summary.md   # default: ~/.config/opencode/opencode-summary/summary.md
+```
+
+This lives outside the plugin, so it survives plugin updates. A fixed line forbidding tool calls is always prepended
+and cannot be edited. `e` opens `$VISUAL`/`$EDITOR` on the file; if neither is set, a multi-line editor opens in the
+modal (`ctrl+s` save, `esc` cancel). `r` deletes the override.
+
+## Development
+
+```sh
+bun install
+bun test
+```
+
+`src/lib.ts` is pure and must not import opencode packages; `test/lib.test.ts` covers it. `src/tui.tsx` is checked
+manually with the checklist below.
+
+### Manual checklist
+
+- [ ] `/summary` in slash completion and palette; on home shows "Open a session first"
+- [ ] `g` shows the summary and "Generated …"; it persists after a TUI restart; `c` copies the markdown
+- [ ] Footer: `summary up to date` after `g`, then `summary N turns ago` as messages are sent
+- [ ] `g` then `esc`: footer spinner, then toast "Summary ready"; `g` mid-run shows "Already generating"
+- [ ] Revert and fork behave as described in the design docs
+- [ ] `e`/`r` only in prompt view, `c` only in summary view
+- [ ] Prompt edit with `$EDITOR` set and unset; saved file appears at the override path above; `r` removes it
+- [ ] Palette "Summary" lists all eight commands; only "Open summary modal" has `/summary`
+- [ ] Toggle footer indicator hides/shows the label and persists after restart
+
+## Contributing
+
+Commits and PR titles follow [Conventional Commits](https://www.conventionalcommits.org/), enforced by
+[commitlint](https://commitlint.js.org/) (a `commit-msg` hook locally, and CI on pull requests).
+
+```
+<type>(<optional scope>): <description>
+
+feat: add a new capability              -> minor bump
+fix: correct a bug                      -> patch bump
+feat!: change behavior incompatibly     -> breaking (minor while < 1.0)
+docs | refactor | test | chore | ci | build | perf | style
+```
+
+## Releasing
+
+Versions follow [SemVer](https://semver.org/) and are derived from commit messages by
+[release-please](https://github.com/googleapis/release-please). While the version is `0.x`, `feat` bumps the minor
+version and `fix` bumps the patch.
+
+1. Merge changes to `main` using conventional commits.
+2. release-please opens or updates a "chore(main): release x.y.z" PR with the version bump and `CHANGELOG.md`.
+3. Merge that PR: it creates the `vX.Y.Z` tag and a GitHub Release.
+
+Repository setting required once: **Settings → Actions → General → "Allow GitHub Actions to create and approve pull
+requests"**.
+
+## Design docs
+
+The design, plan and research for this plugin live in the
+[`ai-tools`](https://github.com/frostehhh/ai-tools/tree/main/openspec/changes/create-opencode-summary-plugin) repo.
+
+## License
+
+[MIT](LICENSE)

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "opencode-summary",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "opencode TUI plugin: generate and view a summary of the current session",
+  "license": "MIT",
+  "type": "module",
+  "author": "frostehhh",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/frostehhh/opencode-summary.git"
+  },
+  "bugs": {
+    "url": "https://github.com/frostehhh/opencode-summary/issues"
+  },
+  "homepage": "https://github.com/frostehhh/opencode-summary#readme",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "tui",
+    "summary"
+  ],
+  "exports": {
+    "./tui": "./src/tui.tsx"
+  },
+  "files": [
+    "src",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "bun test",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@opencode/plugin": "latest"
+  },
+  "peerDependencies": {
+    "@opentui/core": ">=0.6.6",
+    "@opentui/solid": ">=0.6.6",
+    "solid-js": ">=1.9.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^21.2.4",
+    "@commitlint/config-conventional": "^21.2.4",
+    "husky": "^9.1.7"
+  }
+}

package/src/lib.ts

@@ -0,0 +1,135 @@
+import path from "node:path"
+import { DEFAULT_PROMPT, GUARD } from "./prompt"
+
+export const METADATA_KEY = "opencode-summary"
+export type Metadata = Record<string, unknown>
+export type SummaryRecord = { text: string; generatedAt: number; promptId: string; lastMessageID: string }
+
+export const buildRequest = (prompt: string) => `${GUARD}\n\n${prompt}`
+
+/** FNV-1a 32-bit, hex. Stable id for "generated with a different prompt". */
+export function promptId(text: string): string {
+  let hash = 0x811c9dc5
+  for (let i = 0; i < text.length; i++) hash = Math.imul(hash ^ text.charCodeAt(i), 0x01000193) >>> 0
+  return hash.toString(16).padStart(8, "0")
+}
+
+export function readSummary(metadata: unknown): SummaryRecord | undefined {
+  if (!metadata || typeof metadata !== "object") return undefined
+  const value = (metadata as Metadata)[METADATA_KEY]
+  if (!value || typeof value !== "object") return undefined
+  const { text, generatedAt, promptId, lastMessageID } = value as Record<string, unknown>
+  if (typeof text !== "string" || typeof generatedAt !== "number") return undefined
+  if (typeof promptId !== "string" || typeof lastMessageID !== "string") return undefined
+  return { text, generatedAt, promptId, lastMessageID }
+}
+
+export const withSummary = (metadata: Metadata | undefined, record: SummaryRecord): Metadata => ({
+  ...metadata,
+  [METADATA_KEY]: record,
+})
+
+export function withoutSummary(metadata: Metadata | undefined): Metadata {
+  const { [METADATA_KEY]: _removed, ...rest } = metadata ?? {}
+  return rest
+}
+
+export const isBlank = (text: string | undefined) => !text || text.trim() === ""
+
+/** Copy of tui/src/component/dialog-stash.tsx getRelativeTime; undefined at 7+ days. */
+export function relativeTime(ts: number, now: number): string | undefined {
+  const s = Math.floor((now - ts) / 1000)
+  const m = Math.floor(s / 60)
+  const h = Math.floor(m / 60)
+  const d = Math.floor(h / 24)
+  if (s < 60) return "just now"
+  if (m < 60) return `${m}m ago`
+  if (h < 24) return `${h}h ago`
+  if (d < 7) return `${d}d ago`
+  return undefined
+}
+
+/** Copy of tui/src/util/locale.ts datetime: "<time> · <date>". */
+export function datetime(ts: number): string {
+  const date = new Date(ts)
+  return `${date.toLocaleTimeString(undefined, { timeStyle: "short" })} · ${date.toLocaleDateString()}`
+}
+
+export const TURN_LIMIT = 200
+export const GENERATE_TIMEOUT_MS = 180_000
+export type Turns = { count: number; capped: boolean }
+
+/** `userMessageIDs` = one page of user messages (newest first, at most `limit`). IDs sort as strings. */
+export function turnsSince(userMessageIDs: readonly string[], lastMessageID: string, limit = TURN_LIMIT): Turns {
+  const count = userMessageIDs.filter((id) => id > lastMessageID).length
+  return { count, capped: userMessageIDs.length >= limit && count >= limit }
+}
+
+export function turnsText({ count, capped }: Turns): string {
+  if (capped) return `${TURN_LIMIT}+ turns ago`
+  if (count === 0) return "up to date"
+  return count === 1 ? "1 turn ago" : `${count} turns ago`
+}
+
+export const turnLabel = (turns: Turns) => `summary ${turnsText(turns)}`
+
+export function generatedLine(record: SummaryRecord, now: number, turns?: Turns): string {
+  const relative = relativeTime(record.generatedAt, now)
+  const parts = ["Generated", ...(relative ? [`${relative} ·`] : []), datetime(record.generatedAt)]
+  return turns ? `${parts.join(" ")} · ${turnsText(turns)}` : parts.join(" ")
+}
+
+export function errorMessage(cause: unknown): string {
+  if (cause instanceof Error && cause.message) return cause.message
+  return typeof cause === "string" && cause ? cause : "Unknown error"
+}
+
+export type BlockReason = "running" | "in-flight"
+
+export function blockReason(input: { status: "idle" | "running"; inFlight: boolean }): BlockReason | undefined {
+  if (input.inFlight) return "in-flight"
+  if (input.status === "running") return "running"
+  return undefined
+}
+
+/** Newest visible message id. `idsDesc` is newest first; a staged revert hides ids >= `revertBoundary`. */
+export function lastVisibleID(idsDesc: readonly string[], revertBoundary?: string): string | undefined {
+  return revertBoundary === undefined ? idsDesc[0] : idsDesc.find((id) => id < revertBoundary)
+}
+
+export function blockMessage(reason: BlockReason): string {
+  switch (reason) {
+    case "in-flight":
+      return "Already generating"
+    case "running":
+      return "Agent is running - wait for it to finish"
+  }
+}
+
+export function isMessageNotFound(error: unknown): boolean {
+  if (!error || typeof error !== "object") return false
+  const { _tag, name } = error as { _tag?: unknown; name?: unknown }
+  return _tag === "MessageNotFoundError" || name === "MessageNotFoundError"
+}
+
+export type ValidityCheck = { found: true } | { found: false; notFound: boolean }
+export const validityAction = (check: ValidityCheck): "keep" | "delete" =>
+  !check.found && check.notFound ? "delete" : "keep"
+
+export type PromptSource = "default" | "override"
+export type ResolvedPrompt = { text: string; source: PromptSource }
+
+export const resolvePrompt = (override: string | undefined): ResolvedPrompt =>
+  isBlank(override) ? { text: DEFAULT_PROMPT, source: "default" } : { text: override!.trim(), source: "override" }
+
+export function saveAction(edited: string): "noop" | "delete" | "write" {
+  if (isBlank(edited)) return "noop"
+  return edited.trim() === DEFAULT_PROMPT.trim() ? "delete" : "write"
+}
+
+/** User-level prompt override location: `<config home>/opencode/opencode-summary/summary.md`. */
+export function promptPaths(env: { XDG_CONFIG_HOME?: string }, home: string): { dir: string; override: string } {
+  const base = env.XDG_CONFIG_HOME?.trim() || path.join(home, ".config")
+  const dir = path.join(base, "opencode", "opencode-summary")
+  return { dir, override: path.join(dir, "summary.md") }
+}

package/src/prompt.ts

@@ -0,0 +1,12 @@
+export const GUARD = "Do not call any tools and do not take any actions."
+
+export const DEFAULT_PROMPT = `Summarize the conversation so far for the user.
+Output markdown only, no preamble, about 300 words or less. Use exactly these sections, bullets only below TL;DR; omit a section if empty:
+
+## TL;DR
+2-3 sentences.
+## Goal
+## Decisions
+## Progress / current state
+## Open questions / next steps
+## Key files and references`

package/src/tui.tsx

@@ -0,0 +1,558 @@
+import { Plugin } from "@opencode/plugin/tui"
+import { SyntaxStyle, TextAttributes, type ScrollBoxRenderable, type TextareaRenderable } from "@opentui/core"
+import { useKeyboard, useTerminalDimensions } from "@opentui/solid"
+import { createMemo, createResource, createSignal, For, onCleanup, onMount, Show } from "solid-js"
+import { spawn } from "node:child_process"
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises"
+import { homedir } from "node:os"
+import path from "node:path"
+import * as lib from "./lib"
+import { GUARD } from "./prompt"
+
+const INSET = 3
+const paths = lib.promptPaths(process.env, homedir())
+type Mode = "summary" | "prompt" | "edit"
+
+export default Plugin.define({
+  id: "opencode-summary",
+  setup(context) {
+    const { client, ui } = context
+    const theme = () => context.theme.surface("dialog")
+    const syntax = SyntaxStyle.fromStyles(
+      {
+        default: { fg: context.theme.markdown.text },
+        "markup.heading": { fg: context.theme.markdown.heading, bold: true },
+        "markup.strong": { fg: context.theme.markdown.strong, bold: true },
+        "markup.italic": { fg: context.theme.markdown.emphasis, italic: true },
+        "markup.list": { fg: context.theme.markdown.listItem },
+        "markup.quote": { fg: context.theme.markdown.blockQuote, italic: true },
+        "markup.raw": { fg: context.theme.markdown.code },
+        "markup.link": { fg: context.theme.markdown.link, underline: true },
+      },
+      context.renderer.nativeScene,
+    )
+    const toastError = (cause: unknown) => ui.toast.show({ variant: "error", message: lib.errorMessage(cause) })
+
+    async function readMetadata(sessionID: string): Promise<lib.Metadata> {
+      return ((await client.session.get({ sessionID })).metadata ?? {}) as lib.Metadata
+    }
+
+    /** Read-merge-write; `undefined` removes the summary. */
+    async function writeSummary(sessionID: string, record: lib.SummaryRecord | undefined): Promise<void> {
+      const current = await readMetadata(sessionID)
+      const metadata = record ? lib.withSummary(current, record) : lib.withoutSummary(current)
+      await client.session.update({ sessionID, metadata: metadata as never })
+    }
+
+    async function loadSummary(sessionID: string): Promise<lib.SummaryRecord | undefined> {
+      const record = lib.readSummary(await readMetadata(sessionID))
+      if (!record) return undefined
+      const check: lib.ValidityCheck = await client.session.message
+        .get({ sessionID, messageID: record.lastMessageID })
+        .then(
+          () => ({ found: true }) as const,
+          (error: unknown) => ({ found: false, notFound: lib.isMessageNotFound(error) }) as const,
+        )
+      if (lib.validityAction(check) === "keep") return record
+      await writeSummary(sessionID, undefined)
+      return undefined
+    }
+
+    async function blocked(sessionID: string): Promise<lib.BlockReason | undefined> {
+      return lib.blockReason({
+        status: context.data.session.status(sessionID),
+        inFlight: inFlight(sessionID),
+      })
+    }
+
+    const [tick, setTick] = createSignal(0)
+    let pending: ReturnType<typeof setTimeout> | undefined
+    const bump = () => {
+      clearTimeout(pending)
+      pending = setTimeout(() => setTick((n) => n + 1), 150)
+    }
+    const stops = (
+      [
+        "session.inbox.delivered",
+        "session.metadata.updated",
+        "session.revert.committed",
+        "session.revert.staged",
+        "session.revert.cleared",
+        "session.execution.started",
+        "session.execution.succeeded",
+        "session.execution.failed",
+        "session.execution.interrupted",
+      ] as const
+    ).map((type) => context.data.on(type, bump))
+
+    const [flight, setFlight] = context.storage.memory("inflight", { initial: { sessions: [] as string[] } })
+    const inFlight = (sessionID: string) => flight.sessions.includes(sessionID)
+    const [modalFor, setModalFor] = createSignal<string>()
+
+    async function countTurns(sessionID: string, lastMessageID: string): Promise<lib.Turns> {
+      const page = await client.message.list({ sessionID, type: "user", order: "desc", limit: lib.TURN_LIMIT })
+      return lib.turnsSince(page.data.map((message) => message.id), lastMessageID)
+    }
+
+    async function loadView(sessionID: string) {
+      const record = await loadSummary(sessionID)
+      return record ? { record, turns: await countTurns(sessionID, record.lastMessageID) } : undefined
+    }
+
+    async function readOverride(): Promise<string | undefined> {
+      return readFile(paths.override, "utf8").catch((error: NodeJS.ErrnoException) =>
+        error.code === "ENOENT" ? undefined : Promise.reject(error),
+      )
+    }
+    const loadPrompt = async () => lib.resolvePrompt(await readOverride())
+
+    async function applyEdited(edited: string, previous: string | undefined): Promise<void> {
+      switch (lib.saveAction(edited)) {
+        case "noop":
+          if (previous === undefined) await rm(paths.override, { force: true })
+          else await writeFile(paths.override, previous)
+          return void ui.toast.show({ variant: "warning", message: "Empty prompt - not saved" })
+        case "delete":
+          await rm(paths.override, { force: true })
+          return void ui.toast.show({ message: "Prompt matches default - override removed" })
+        case "write":
+          await mkdir(path.dirname(paths.override), { recursive: true })
+          await writeFile(paths.override, edited.trim() + "\n")
+          return void ui.toast.show({ variant: "success", message: "Prompt saved" })
+      }
+    }
+
+    function spawnEditor(command: string, file: string): Promise<void> {
+      const [bin, ...args] = command.split(" ")
+      return new Promise((resolve, reject) => {
+        const child = spawn(bin!, [...args, file], { stdio: "inherit" })
+        child.on("error", reject)
+        child.on("exit", (code, signal) =>
+          code === 0 ? resolve() : reject(new Error(`Editor exited with ${signal ? `signal ${signal}` : `code ${code}`}`)),
+        )
+      })
+    }
+
+    const externalEditor = () => process.env.VISUAL || process.env.EDITOR
+
+    async function editWithEditor(sessionID: string, editor: string): Promise<void> {
+      const previous = await readOverride()
+      await mkdir(path.dirname(paths.override), { recursive: true })
+      if (previous === undefined) await writeFile(paths.override, (await loadPrompt()).text + "\n")
+      await context.renderer.suspend()
+      try {
+        await spawnEditor(editor, paths.override)
+      } catch (cause) {
+        toastError(cause)
+        return
+      } finally {
+        await context.renderer.resume()
+      }
+      await applyEdited((await readOverride()) ?? "", previous)
+      openModal(sessionID, "prompt")
+    }
+
+    async function resetPrompt(sessionID: string, reopen = true): Promise<void> {
+      const confirmed = await ui.dialog.confirm({
+        title: "Reset summary prompt?",
+        message: `Delete ${ui.format.path(paths.override)} and use the default prompt.`,
+        label: { confirm: "Reset", cancel: "Cancel" },
+      })
+      if (confirmed) {
+        await rm(paths.override, { force: true })
+        ui.toast.show({ message: "Prompt reset to default" })
+      }
+      if (reopen) openModal(sessionID, "prompt")
+    }
+
+    /** Returns true when a new record was written. */
+    async function generate(sessionID: string): Promise<boolean> {
+      const prompt = (await loadPrompt()).text
+      const [info, page] = await Promise.all([
+        client.session.get({ sessionID }),
+        client.message.list({ sessionID, order: "desc", limit: lib.TURN_LIMIT }),
+      ])
+      // A staged revert hides messages from revert.messageID on; cap lastMessageID at the boundary.
+      const lastMessageID = lib.lastVisibleID(page.data.map((message) => message.id), info.revert?.messageID)
+      if (!lastMessageID) {
+        ui.toast.show({ variant: "warning", message: "Nothing to summarize yet" })
+        return false
+      }
+      // No abort signal on session.generate: race a timeout so a hung call cannot keep the session "in flight" forever.
+      let timer: ReturnType<typeof setTimeout> | undefined
+      const timeout = new Promise<never>((_, reject) => {
+        timer = setTimeout(() => reject(new Error("Summary timed out")), lib.GENERATE_TIMEOUT_MS)
+      })
+      const result = await Promise.race([client.session.generate({ sessionID, prompt: lib.buildRequest(prompt) }), timeout])
+        .catch((cause: unknown) => (toastError(cause), undefined))
+        .finally(() => clearTimeout(timer))
+      if (!result) return false
+      if (lib.isBlank(result.text)) {
+        ui.toast.show({ variant: "error", message: "Summary came back empty" })
+        return false
+      }
+      await writeSummary(sessionID, {
+        text: result.text.trim(),
+        generatedAt: Date.now(),
+        promptId: lib.promptId(prompt),
+        lastMessageID,
+      })
+      return true
+    }
+
+    const [settings, setSettings] = context.storage.store("settings", { initial: { indicator: true } })
+
+    function copyText(text: string) {
+      if (!context.renderer.copyToClipboardOSC52(text))
+        ui.toast.show({ variant: "warning", message: "Copy not supported by this terminal" })
+      else ui.toast.show({ variant: "success", message: "Summary copied" })
+    }
+
+    function currentSession(): string | undefined {
+      const route = ui.router.current()
+      if (route.type === "session") return route.sessionID
+      ui.toast.show({ variant: "warning", message: "Open a session first" })
+      return undefined
+    }
+
+    async function deleteSummary(sessionID: string): Promise<void> {
+      if (!(await loadSummary(sessionID))) return void ui.toast.show({ message: "No summary to delete" })
+      const confirmed = await ui.dialog.confirm({
+        title: "Delete summary?",
+        message: "Remove this session's stored summary.",
+        label: { confirm: "Delete", cancel: "Cancel" },
+      })
+      if (!confirmed) return
+      await writeSummary(sessionID, undefined)
+      ui.toast.show({ message: "Summary deleted" })
+      bump()
+    }
+
+    async function startGenerate(sessionID: string): Promise<void> {
+      const reason = await blocked(sessionID)
+      if (reason) return void ui.toast.show({ variant: "warning", message: lib.blockMessage(reason) })
+      setFlight((draft) => void draft.sessions.push(sessionID))
+      try {
+        const written = await generate(sessionID)
+        if (written && modalFor() !== sessionID) ui.toast.show({ variant: "success", message: "Summary ready", sessionID })
+      } catch (cause) {
+        toastError(cause)
+      } finally {
+        setFlight((draft) => void (draft.sessions = draft.sessions.filter((id) => id !== sessionID)))
+        bump()
+      }
+    }
+
+    function Spinner(props: { label: string }) {
+      const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+      const [i, setI] = createSignal(0)
+      const timer = setInterval(() => setI((n) => (n + 1) % frames.length), 80)
+      onCleanup(() => clearInterval(timer))
+      return <text fg={context.theme.hue.interactive[200]}>{`${frames[i()]} ${props.label}`}</text>
+    }
+
+    function FooterStatus(props: { sessionID?: string }) {
+      const [view] = createResource(
+        () => (props.sessionID ? ([props.sessionID, tick()] as const) : undefined),
+        ([sessionID]) => loadView(sessionID).catch(() => undefined),
+      )
+      return (
+        <Show when={props.sessionID}>
+          {(sessionID) => (
+            <Show when={!inFlight(sessionID())} fallback={<Spinner label="/summary" />}>
+              <Show when={settings.indicator && view()}>
+                {(current) => <text fg={context.theme.text.muted}>{lib.turnLabel(current().turns)}</text>}
+              </Show>
+            </Show>
+          )}
+        </Show>
+      )
+    }
+
+    ui.slot({ append: "prompt.footer.status", render: (props) => <FooterStatus sessionID={props.sessionID} /> })
+
+    function Hints(props: { items: [title: string, key: string][] }) {
+      return (
+        <box flexDirection="row" gap={2}>
+          <For each={props.items}>{([title, key]) => <text fg={theme().text.muted}>{`${title} ${key}`}</text>}</For>
+        </box>
+      )
+    }
+
+    function PromptEditor(props: { initial: string; height: number; onDone: (saved: boolean) => void }) {
+      const [target, setTarget] = createSignal<TextareaRenderable>()
+      let textarea: TextareaRenderable | undefined
+      const save = async () => {
+        const previous = await readOverride()
+        await applyEdited(textarea?.plainText ?? "", previous).then(() => props.onDone(true), toastError)
+      }
+      context.keymap.layer(() => ({
+        mode: "modal",
+        priority: 1,
+        target,
+        enabled: target() !== undefined,
+        commands: [
+          { bind: "ctrl+s", title: "Save prompt", group: "Dialog", run: () => void save() },
+          { bind: "escape", title: "Cancel edit", group: "Dialog", run: () => props.onDone(false) },
+        ],
+      }))
+      onMount(() => setTimeout(() => textarea && !textarea.isDestroyed && textarea.focus(), 1))
+      return (
+        <box gap={1}>
+          <text fg={theme().text.muted}>{`fixed: ${GUARD}`}</text>
+          <textarea
+            ref={(element: TextareaRenderable) => ((textarea = element), setTarget(element))}
+            initialValue={props.initial}
+            height={props.height}
+            wrapMode="word"
+            textColor={theme().text.formfield.base}
+            focusedTextColor={theme().text.formfield.base}
+            cursorColor={theme().text.base}
+          />
+          <Hints items={[["save", "ctrl+s"], ["cancel", "esc"]]} />
+        </box>
+      )
+    }
+
+    function SummaryDialog(props: { sessionID: string; mode: Mode }) {
+      const dimensions = useTerminalDimensions()
+      const maxHeight = createMemo(() => Math.max(8, Math.floor(dimensions().height * 0.6)))
+      const [mode, setMode] = createSignal<Mode>(props.mode)
+      const [view] = createResource(() => [props.sessionID, tick()] as const, ([id]) => loadView(id).catch(toastError))
+      const [reason] = createResource(() => [props.sessionID, tick()] as const, ([id]) => blocked(id).catch(() => undefined))
+      const [prompt, { refetch: refetchPrompt }] = createResource(() => [mode(), tick()] as const, () => loadPrompt())
+      const record = () => view()?.record
+      const busy = () => inFlight(props.sessionID)
+      const stale = () => view() && prompt() && view()!.record.promptId !== lib.promptId(prompt()!.text)
+      let scroll: ScrollBoxRenderable | undefined
+
+      const run = () => void startGenerate(props.sessionID)
+      const copy = () => {
+        const text = record()?.text
+        if (text) copyText(text)
+      }
+      const edit = () => {
+        const editor = externalEditor()
+        if (editor) void editWithEditor(props.sessionID, editor).catch(toastError)
+        else setMode("edit")
+      }
+
+      context.keymap.layer(() => ({
+        mode: "modal",
+        enabled: mode() !== "edit",
+        commands: [
+          { bind: "g", title: "Generate summary", group: "Dialog", run },
+          { bind: "v", title: "Toggle prompt view", group: "Dialog", run: () => setMode((m) => (m === "summary" ? "prompt" : "summary")) },
+        ],
+      }))
+      context.keymap.layer(() => ({
+        mode: "modal",
+        enabled: mode() === "summary",
+        commands: [{ bind: "c", title: "Copy summary", group: "Dialog", run: copy }],
+      }))
+      context.keymap.layer(() => ({
+        mode: "modal",
+        enabled: mode() === "prompt",
+        commands: [
+          { bind: "e", title: "Edit prompt", group: "Dialog", run: edit },
+          { bind: "r", title: "Reset prompt", group: "Dialog", run: () => void resetPrompt(props.sessionID).catch(toastError) },
+        ],
+      }))
+
+      useKeyboard((event) => {
+        if (!scroll || mode() === "edit") return
+        if (event.name === "up" || event.name === "k") return scroll.scrollBy(-1)
+        if (event.name === "down" || event.name === "j") return scroll.scrollBy(1)
+        if (event.name === "pageup") return scroll.scrollBy(-maxHeight())
+        if (event.name === "pagedown") return scroll.scrollBy(maxHeight())
+        if (event.name === "home") return scroll.scrollTo(0)
+        if (event.name === "end") return scroll.scrollTo(scroll.scrollHeight)
+      })
+
+      const summaryBody = () => (
+        <Show when={record()}>
+          {(current) => (
+            <scrollbox
+              ref={(element: ScrollBoxRenderable) => (scroll = element)}
+              maxHeight={maxHeight()}
+              scrollbarOptions={{ visible: false }}
+            >
+              <markdown content={current().text} syntaxStyle={syntax} conceal fg={theme().markdown.text} />
+            </scrollbox>
+          )}
+        </Show>
+      )
+
+      return (
+        <box paddingLeft={INSET} paddingRight={INSET} paddingBottom={1} gap={1}>
+          <box flexDirection="row" justifyContent="space-between">
+            <text attributes={TextAttributes.BOLD} fg={theme().text.base}>/summary</text>
+            <text fg={theme().text.muted}>esc</text>
+          </box>
+          <text fg={theme().text.muted}>
+            {busy() ? "Generating…" : view() ? lib.generatedLine(view()!.record, Date.now(), view()!.turns) : "No summary yet - press g to generate"}
+          </text>
+          <Show when={mode() === "edit" && prompt()}>
+            <PromptEditor
+              initial={prompt()!.text}
+              height={Math.max(6, maxHeight() - 4)}
+              onDone={(saved) => {
+                setMode("prompt")
+                if (saved) void refetchPrompt()
+              }}
+            />
+          </Show>
+          <Show when={mode() === "prompt"}>
+            <scrollbox ref={(element: ScrollBoxRenderable) => (scroll = element)} maxHeight={maxHeight()} scrollbarOptions={{ visible: false }}>
+              <box gap={1}>
+                <text fg={theme().text.muted}>{`fixed: ${GUARD}`}</text>
+                <text fg={theme().text.base}>{prompt()?.text ?? ""}</text>
+                <text fg={theme().text.muted}>
+                  {prompt()?.source === "override" ? `source: override (${ui.format.path(paths.override)})` : "source: default (prompt.ts)"}
+                </text>
+              </box>
+            </scrollbox>
+          </Show>
+          <Show when={mode() === "summary"}>{summaryBody()}</Show>
+          <Show when={mode() === "summary" && stale()}>
+            <text fg={theme().text.muted}>Generated with a different prompt</text>
+          </Show>
+          <Show when={mode() !== "edit"}>
+            <Hints
+              items={[
+                [reason() ? `generate (${reason()})` : "generate", "g"],
+                [mode() === "summary" ? "prompt" : "summary", "v"],
+                ...(mode() === "prompt" ? ([["edit", "e"], ["reset", "r"]] as [string, string][]) : []),
+                ...(mode() === "summary" ? ([["copy", "c"]] as [string, string][]) : []),
+                ["scroll", "j/k"],
+              ]}
+            />
+          </Show>
+        </box>
+      )
+    }
+
+    function openModal(sessionID: string, mode: Mode = "summary") {
+      setModalFor(sessionID)
+      ui.dialog.show(() => <SummaryDialog sessionID={sessionID} mode={mode} />, () => setModalFor(undefined))
+      ui.dialog.set({ size: "large", centered: true })
+    }
+
+    ui.slot({
+      append: "app",
+      render() {
+        context.keymap.layer(() => ({
+          mode: "global",
+          commands: [
+            {
+              id: "summary.open",
+              title: "Open summary modal",
+              description: "View or generate a summary of this session",
+              group: "Summary",
+              palette: true,
+              slash: { name: "summary" },
+              run() {
+                const sessionID = currentSession()
+                if (sessionID) openModal(sessionID)
+              },
+            },
+            {
+              id: "summary.generate",
+              title: "Generate summary",
+              description: "Generate a summary without opening the modal",
+              group: "Summary",
+              palette: true,
+              run() {
+                const sessionID = currentSession()
+                if (sessionID) void startGenerate(sessionID)
+              },
+            },
+            {
+              id: "summary.copy",
+              title: "Copy summary",
+              description: "Copy the stored summary to the clipboard",
+              group: "Summary",
+              palette: true,
+              run() {
+                const sessionID = currentSession()
+                if (!sessionID) return
+                void loadSummary(sessionID).then(
+                  (record) => (record ? copyText(record.text) : ui.toast.show({ message: "No summary yet" })),
+                  toastError,
+                )
+              },
+            },
+            {
+              id: "summary.delete",
+              title: "Delete summary",
+              description: "Remove the stored summary of this session",
+              group: "Summary",
+              palette: true,
+              run() {
+                const sessionID = currentSession()
+                if (sessionID) void deleteSummary(sessionID).catch(toastError)
+              },
+            },
+            {
+              id: "summary.prompt.view",
+              title: "View summary prompt",
+              description: "Show the prompt used for summaries",
+              group: "Summary",
+              palette: true,
+              run() {
+                const sessionID = currentSession()
+                if (sessionID) openModal(sessionID, "prompt")
+              },
+            },
+            {
+              id: "summary.prompt.edit",
+              title: "Edit summary prompt",
+              description: "Edit the prompt used for summaries",
+              group: "Summary",
+              palette: true,
+              run() {
+                const sessionID = currentSession()
+                if (!sessionID) return
+                const editor = externalEditor()
+                if (editor) void editWithEditor(sessionID, editor).catch(toastError)
+                else openModal(sessionID, "edit")
+              },
+            },
+            {
+              id: "summary.prompt.reset",
+              title: "Reset summary prompt",
+              description: "Restore the default summary prompt",
+              group: "Summary",
+              palette: true,
+              run() {
+                const sessionID = currentSession()
+                if (sessionID) void resetPrompt(sessionID, false).catch(toastError)
+              },
+            },
+            {
+              id: "summary.indicator.toggle",
+              title: "Toggle summary footer indicator",
+              description: "Show or hide the turns-ago indicator in the prompt footer",
+              group: "Summary",
+              palette: true,
+              run() {
+                const next = !settings.indicator
+                void setSettings((draft) => void (draft.indicator = next)).then(
+                  () => ui.toast.show({ message: next ? "Footer indicator shown" : "Footer indicator hidden" }),
+                  toastError,
+                )
+              },
+            },
+          ],
+        }))
+        return null
+      },
+    })
+
+    return () => {
+      clearTimeout(pending)
+      stops.forEach((stop) => stop())
+      void context.renderer.idle().then(() => syntax.destroy())
+    }
+  },
+})