@pellux/goodvibes-tui 2.0.21 → 2.1.0

package/CHANGELOG.md

@@ -4,6 +4,64 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [2.1.0] - 2026-09-30
+
+### Added
+
+- **Themes.** display.theme picks goodvibes (the default), goodvibes-neon,
+  catppuccin, tokyonight, dracula, nord, gruvbox, one-dark, rosepine,
+  solarized, github, or system, which follows the terminal's own palette,
+  under tmux and over ssh too. Settings previews themes live. A theme you
+  already chose is kept.
+- **Modals replace panes.** Usage, Changes, Agents and Notifications open as
+  large dimmed modals on one surface kit with a live search row and one-level
+  Esc; ctrl+p opens the command palette.
+- **A calmer base screen.** A one-row header, an empty row under it,
+  full-width user messages, an input area that holds only input, and a status
+  line with the context bar and its compaction tick.
+- **The throbber is back** on its own row above the input area, naming what
+  the session is doing with elapsed time, with half-row gaps between output,
+  throbber, input area and status line.
+- **A lane-graph work tree** with status on each bead, agents as lanes,
+  folding, and a display.treeGlyphs choice of rounded, square or ascii.
+- **Full-screen agent and process views** with session chips. Esc never
+  stops them and ctrl+x asks before stopping.
+- **A back-to-bottom pill** shows while the output is scrolled back. Esc
+  returns to the live output and never interrupts the turn.
+- **Notifications name the work** on the desktop, in the terminal, on
+  webhooks and for approvals, budgets, agents and workstreams. The
+  behavior.notificationsMetadataOnly setting sends metadata only and is off
+  by default.
+- **System notices are toasts** kept in a /notifications history with plain
+  names, one entry per event.
+- /context window and /status say where the context window came from.
+
+### Changed
+
+- **WRFC chains run in their own git worktree.** A passed chain commits only
+  its own changes plus edits GoodVibes' own tools made, runs your git hooks,
+  and leaves your other uncommitted edits in place. A failed chain stops its
+  remaining fix tasks.
+- A remote model with no real window takes it from the models.dev catalog,
+  so abacusai route-llm reads 128.0k instead of a guessed 8.2k.
+- The pins move to sdk 2.1.0 and daemon 1.29.0.
+- Every open dependency advisory is closed: undici, brace-expansion, the
+  Anthropic client (0.92), qs, body-parser, ip-address, fflate, fast-uri,
+  js-yaml and sharp move to patched versions.
+
+### Fixed
+
+- Read and command bodies keep their indentation; wrapped prose no longer
+  starts one column right; long code lines wrap.
+- A finished turn stops saying working; ended processes stop counting as
+  running.
+- The recovery offer opens before the first frame and never takes keys typed
+  before it appeared.
+- Instructions meant for the model no longer show as notices, and notices
+  keep their full text.
+- Printed command output survives resizes.
+
+
 ## [2.0.21] - 2026-08-23
 
 ### Changes

package/README.md

@@ -2,11 +2,11 @@
 
 [![CI](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml/badge.svg)](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-2.0.21-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
+[![Version](https://img.shields.io/badge/version-2.1.0-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
 
 GoodVibes is a terminal console for coding and operations work with an AI model. You run `goodvibes` in a project directory and get a full-screen terminal app where you talk to a model that can read and edit your files, run shell commands, search the web, and hand work off to background agents, asking your permission before anything that writes or executes.
 
-It talks to many model providers (OpenAI, Anthropic, Gemini, Bedrock, Copilot, OpenRouter and other OpenAI-compatible gateways, plus local servers like Ollama and LM Studio that `/scan` finds on your machine and LAN), keeps its settings, sessions, and secrets on your own machine, and shows you the token count and running cost of every turn. Alongside the conversation, panels turn background work into live control rooms: running agents, git state, diffs, tokens, cost.
+It talks to many model providers (OpenAI, Anthropic, Gemini, Bedrock, Copilot, OpenRouter and other OpenAI-compatible gateways, plus local servers like Ollama and LM Studio that `/scan` finds on your machine and LAN), keeps its settings, sessions, and secrets on your own machine, and shows you the token count and running cost of every turn. Background work opens in large modals over the conversation: running agents, changed files and diffs, tokens and cost.
 
 <img src="docs/assets/splash.png" alt="GoodVibes starting up in a terminal: a glitch-art GOODVIBES wordmark in cyan-to-magenta gradient, the version and tagline beneath it, the active model and tool count, the working directory, a line offering to resume the last session, and a hint line reading Ctrl+P panels / ? help / F2 fleet. A status footer shows mode, token usage, context usage, and the daemon and web listener addresses." width="900">
 
@@ -80,11 +80,11 @@ Models come from a live catalog, so the picker lists far more than a hardcoded s
 
 The `synthetic` provider groups the same model across every backend that serves it into one entry. Pick it and requests route to whichever backend is healthy, failing over on rate limits and transient errors without changing the model you chose, and without ever crossing the free, paid, and subscription boundaries. Any OpenAI-compatible API can be added as a custom provider by dropping a JSON file in `~/.goodvibes/tui/providers/`. It is hot-reloaded. See [docs/providers-and-routing.md](docs/providers-and-routing.md).
 
-### The Fleet control room
+### The Agents control room
 
 <img src="docs/assets/fleet-panel.png" alt="The Fleet panel open beside the conversation. It lists background work as rows with a kind, a name, elapsed time, token count, and cost: a CI watch poller and a runtime heartbeat watcher at 4 minutes 23 seconds each, and an idle code indexer. The detail region below shows the selected watcher's id, state idle, elapsed time, model, tokens, cost, a headline reading CI watch poller, healthy, an activity phase, and an approvals line. The action hints read j/k navigate, Enter attach, K kill, A archive finished, v archived, n host agent." width="900">
 
-Work that is not conversation goes into panels instead of scrolling past in the transcript. Fleet, reached with `F2`, is the live control room for agents, workstreams, watchers, and scheduled jobs: what is running, for how long, at what token cost, and what it is waiting on. You can attach to a running agent to watch or steer it, detach again without killing it, pause and resume, and archive finished work. Git, diff, cost, token, and local-auth panels sit alongside it. Heavier operator surfaces open as review modals.
+Work that is not conversation opens in modals instead of scrolling past in the transcript. Agents, reached with `F2`, is the live control room for agents, WRFC chains, workstreams, watchers, scheduled jobs and hosted sessions: what is running, for how long, at what token cost, and what it is waiting on. You can open a running agent to watch its live tail or steer it, back out with `Esc` without stopping it, stop it with `Ctrl+X` (it asks first), pause and resume, and archive finished work. Usage (`/usage`) shows context pressure, tokens and cost; Changes (`/changes`) shows changed files with a tinted diff, a semantic summary, hunk staging and review comments; Notifications (`/notifications`) keeps the history. The screenshot above predates the modal redesign.
 
 ### Everything else is a command
 
@@ -99,14 +99,14 @@ Press `?` for a searchable, categorized list of every slash command with its arg
 | `Enter` / `Shift+Enter` | Send the message / insert a newline |
 | `?` | Help and command picker (on an empty prompt) |
 | `@` | File picker: insert a path into the prompt |
-| `Tab` | Toggle collapse on the nearest block, or complete a path |
+| `Tab` | Complete a path, or toggle collapse on the nearest block. With the session chips showing and an empty composer, switch to the next session |
 | `Ctrl+F` | Search the conversation |
 | `Ctrl+Y` / `Ctrl+S` | Copy / save the nearest block |
-| `Ctrl+P` | Toggle the panel sidebar |
-| `F2` | Toggle Fleet: open and focus it, bring it to front, or close it |
-| `Ctrl+K` | Command palette: search and run any command |
-| `Shift+Tab` | Cycle the session permission mode |
-| `Esc` | Leave the current mode: search, command, or modal |
+| `Ctrl+P` / `Ctrl+K` | Command palette: search and run any command, view or setting |
+| `F2` / `Ctrl+O` | Open or close Agents |
+| `Shift+Tab` | Cycle the session permission mode. With the session chips showing and an empty composer, switch to the previous session |
+| `Esc` | Close the top modal (one level), clear the composer, leave an agent or process view (never stops it), or interrupt main's turn |
+| `Ctrl+X` | Inside an agent or process view: stop it (press twice to confirm) |
 | `Ctrl+C` | Clear input, cancel a running turn. Press twice to quit |
 
 Most bindings are customizable in `~/.goodvibes/tui/keybindings.json`, and `/keybindings` shows what is currently bound. Five keys are fixed and stay out of that file: `F2` (Fleet), `Shift+Tab` (permission-mode cycle), `Esc` (leave the current mode), `?` (help), and `@` (file picker). The full reference is in [docs/tools-and-commands.md](docs/tools-and-commands.md).
@@ -129,7 +129,7 @@ Each row links to the page that documents it. The product's own `?` overlay and
 | CLI flags | Session lifecycle (`--continue`, `--resume`, `--fork`), non-interactive mode, output formats, host selection | [cli-flags.md](docs/cli-flags.md) |
 | Knowledge and memory | Session and durable memory, a structured knowledge store with connectors and extractors, embeddings and retrieval, artifacts, multimodal analysis | [knowledge-artifacts-and-multimodal.md](docs/knowledge-artifacts-and-multimodal.md) |
 | Session durability | Post-turn snapshots plus an fsync-per-record transcript journal replayed at every resume | [session-durability.md](docs/session-durability.md) |
-| Planning | Conversational planning loop, project-scoped knowledge spaces, readiness evaluation, the Planning panel | [project-planning.md](docs/project-planning.md) |
+| Planning | Conversational planning loop, project-scoped knowledge spaces, readiness evaluation, the Planning modal | [project-planning.md](docs/project-planning.md) |
 | Sharing and export | `/share` to HTML, JSON, or Markdown with redaction, upload, and clipboard options | [share-command.md](docs/share-command.md) |
 | Daemon and services | Connecting to the standalone GoodVibes daemon, browser operator surface, background service and autostart, inbound TLS, outbound trust | [deployment-and-services.md](docs/deployment-and-services.md) |
 | Remote access | A worked home-server setup: always-on daemon, browser access, TUI over SSH, reachability and TLS | [remote-access.md](docs/remote-access.md) |
@@ -137,7 +137,7 @@ Each row links to the page that documents it. The product's own `?` overlay and
 | Voice | Live `/tts` playback, TTS and STT providers, streaming voice API | [voice-and-live-tts.md](docs/voice-and-live-tts.md) |
 | Sandboxing | Bounded eval and isolated MCP execution, with a QEMU-backed VM path | [qemu-sandbox.md](docs/qemu-sandbox.md) |
 | Integrations | Home Assistant surface, Cloudflare Workers/Queues batch, GitHub Action | [homeassistant-surface.md](docs/homeassistant-surface.md) · [cloudflare-batch.md](docs/cloudflare-batch.md) · [github-action.md](docs/github-action.md) |
-| Contributing surfaces | Writing a new TUI panel; the checked-in operator/peer contracts and knowledge schemas | [panel-authoring.md](docs/panel-authoring.md) · [foundation-artifacts](docs/foundation-artifacts/README.md) |
+| Contributing surfaces | The checked-in operator/peer contracts and knowledge schemas | [foundation-artifacts](docs/foundation-artifacts/README.md) |
 
 Full index: [docs/README.md](docs/README.md).
 
@@ -218,12 +218,12 @@ bun run dev
 
 The compiled binary is the TUI entrypoint. With `daemon.enabled` on (the default) it adopts a running standalone GoodVibes daemon over loopback, and when a daemon is installed as a service but stopped, it starts that service once and waits for it to come online. It never embeds or constructs a daemon of its own. The control plane, HTTP listener (`danger.httpListener`), and web surface are all hosted by the daemon; the TUI configures them and reports their bindings.
 
-Tests live under `src/test/`, mirroring the source tree, and cover contract, security, release-gate, runtime, renderer, panel, integration, and anti-regression cases. Several gates run alongside them in CI: byte-exact golden renderer frames, performance budgets for startup and frame composition and line production (`scripts/perf-baseline.json`), and architecture rules for import cycles, layer boundaries, source-file size, and unused renderer exports (`scripts/check-architecture.ts`).
+Tests live under `src/test/`, mirroring the source tree, and cover contract, security, release-gate, runtime, renderer, view, integration, and anti-regression cases. Several gates run alongside them in CI: byte-exact golden renderer frames, performance budgets for startup and frame composition and line production (`scripts/perf-baseline.json`), and architecture rules for import cycles, layer boundaries, source-file size, and unused renderer exports (`scripts/check-architecture.ts`).
 
 Some decisions worth knowing before you read the source:
 
 - **Bun runtime.** Native TypeScript execution, fast startup, built-in test runner.
-- **Raw ANSI renderer.** It writes the UI straight to the alternate screen buffer, giving direct control over every byte sent to the terminal. Conversation, panels, modals, overlays, and the footer all share that one renderer.
+- **Raw ANSI renderer.** It writes the UI straight to the alternate screen buffer, giving direct control over every byte sent to the terminal. Conversation, modals, overlays, and the footer all share that one renderer.
 - **In-process agents.** Agents run in the same process rather than over IPC, staying isolated through scoped tool registries and namespaced state.
 - **Typed runtime store.** A plain `zustand/vanilla` store with typed selectors and dispatch paths, reachable from agents, tools, renderer, hooks, channels, and daemon surfaces alike.
 - **Tree-sitter and bundled language servers.** Grammars for structural analysis, outlines, and AST-level edits, several embedded as WASM for instant startup. TypeScript, Python, Bash, CSS, HTML, and JSON language servers ship as dependencies, while `rust-analyzer` and `gopls` are fetched on first use with checksum verification.
@@ -233,13 +233,13 @@ Some decisions worth knowing before you read the source:
 
 The TUI consumes the published `@pellux/goodvibes-sdk` platform layer for shared contracts, daemon routes, and transports, and keeps the terminal UI, host wiring, and product composition here. The dependency is pinned in `package.json`. Reference consumers of those surfaces live under [`examples/`](examples/reference-operator-client/README.md).
 
-Source layout, in brief:
+Source layout, in brief (the layer rules and the operator API bridge are in [docs/architecture.md](docs/architecture.md)):
 
 ```text
 src/
 ├── main.ts, core/          terminal entrypoint, orchestrator, conversation and transcript state
 ├── renderer/               raw ANSI compositor, overlays, modals, fullscreen workspaces
-├── panels/                 panel manager, the Fleet control room, git/diff/cost/token consoles
+├── views/                  modal surfaces, the fleet read model and acts behind Agents, view wiring
 ├── input/                  slash commands, keybindings, composer, pickers, settings modals
 ├── runtime/                bootstrap wiring, typed store, service composition, session recovery
 ├── shell/                  shell-level modal openers, blocking input, retry affordances

package/docs/README.md

@@ -32,7 +32,7 @@ This directory contains the current product documentation for `goodvibes-tui`.
   Session memory, durable memory, structured knowledge, connectors, extractors, embeddings, artifacts, and multimodal analysis.
 
 - [Project planning](project-planning.md)
-  TUI-owned conversational planning loop, passive SDK planning artifacts, project-scoped knowledge spaces, readiness evaluation, and the Planning panel.
+  TUI-owned conversational planning loop, passive SDK planning artifacts, project-scoped knowledge spaces, readiness evaluation, and the Planning modal.
 
 - [Channels, remote runtime, and API](channels-remote-and-api.md)
   Omnichannel surfaces, reply routing, remote peers, node-host contracts, and the daemon/control-plane HTTP + streaming surfaces.
@@ -46,6 +46,9 @@ This directory contains the current product documentation for `goodvibes-tui`.
 - [CLI flags](cli-flags.md)
   Global flags reference covering session lifecycle (`--continue`, `--resume`, `--fork`), the `-y`/`--non-interactive` commit gate for plugin bundle installs, output format consolidation, the `--host` alias, and all other startup and command-specific flags.
 
+- [Architecture](architecture.md)
+  Source layout, the import-direction rules `bun run architecture:check` enforces, and the operator API bridge that answers `panels.list` / `panels.open` with the modal views.
+
 - [Commands reference](commands-reference.md)
   The generated, categorized list of every slash command, its arguments, and its description. It is the same list `?` renders in the product.
 
@@ -64,9 +67,6 @@ This directory contains the current product documentation for `goodvibes-tui`.
 - [Local verification](verification/local-verification.md)
   Inventory coverage, GoodVibes home audits, compiled CLI probes, authenticated daemon probes, and release-oriented local gates.
 
-- [Panel authoring](panel-authoring.md)
-  Class hierarchy, canonical example, palette convention, rendering utilities, input handling, performance instrumentation, and contract test registration for contributors building new TUI panels.
-
 - [Changelog](../CHANGELOG.md)
   Current release history. Older per-version release-note files remain under `docs/releases/` for historical releases, but `CHANGELOG.md` is the canonical current stream.
 

package/docs/foundation-artifacts/operator-contract.json

@@ -3,7 +3,7 @@
   "product": {
     "id": "goodvibes",
     "surface": "operator",
-    "version": "2.0.23"
+    "version": "2.1.0"
   },
   "auth": {
     "modes": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "2.0.21",
+  "version": "2.1.0",
   "description": "Terminal-native GoodVibes client for coding, operations, knowledge and channel workflows; a pure client of the GoodVibes daemon.",
   "type": "module",
   "main": "src/main.ts",
@@ -96,11 +96,11 @@
     "@anthropic-ai/bedrock-sdk": "^0.29.1",
     "@anthropic-ai/sdk": "^0.92.0",
     "@ast-grep/napi": "^0.42.0",
-    "@pellux/goodvibes-sdk": "2.0.23",
-    "@pellux/goodvibes-terminal-shell": "2.0.23",
+    "@pellux/goodvibes-sdk": "2.1.0",
+    "@pellux/goodvibes-terminal-shell": "2.1.0",
     "bash-language-server": "^5.6.0",
     "fuse.js": "^7.1.0",
-    "@pellux/goodvibes-daemon": "1.28.25",
+    "@pellux/goodvibes-daemon": "1.29.0",
     "graphql": "^16.13.2",
     "jszip": "^3.10.1",
     "node-edge-tts": "^1.2.10",
@@ -121,7 +121,7 @@
     "zustand": "^5.0.12"
   },
   "devDependencies": {
-    "@pellux/goodvibes-toolchain": "2.0.23",
+    "@pellux/goodvibes-toolchain": "2.1.0",
     "@types/bun": "^1.3.10",
     "typescript": "^5.9.3"
   },
@@ -133,6 +133,16 @@
   },
   "trustedDependencies": [],
   "overrides": {
-    "minimatch": "^10.2.5"
+    "minimatch": "^10.2.5",
+    "undici": "^7.29.1",
+    "brace-expansion": "^5.0.11",
+    "@anthropic-ai/sdk": "^0.92.0",
+    "qs": "^6.16.0",
+    "body-parser": "^1.20.8",
+    "ip-address": "^10.7.2",
+    "fflate": "^0.8.3",
+    "fast-uri": "^3.1.6",
+    "js-yaml": "^4.3.2",
+    "sharp": "^0.35.4"
   }
 }

package/src/cli/management.ts

@@ -232,6 +232,8 @@ async function renderModels(runtime: CliCommandRuntime): Promise<string> {
         id: model.id,
         displayName: model.displayName,
         contextWindow: services.providerRegistry.getContextWindowForModel(model),
+        // False when nothing states the window (a guess, or disproven by a larger accepted request).
+        contextWindowKnown: services.providerRegistry.getKnownContextWindowForModel(model) !== null,
         providerConfigured: providerSnapshot?.runtime.auth?.configured ?? true,
         setup,
       };
@@ -241,7 +243,7 @@ async function renderModels(runtime: CliCommandRuntime): Promise<string> {
         `  provider: ${model.provider}`,
         `  setup: ${setup.setupLabel}`,
         `  provider configured: ${yesNo(value.providerConfigured)}`,
-        `  context: ${value.contextWindow.toLocaleString()}`,
+        `  context: ${value.contextWindowKnown ? value.contextWindow.toLocaleString() : 'unknown'}`,
       ].join('\n'));
     }
     if (subOrFilter === 'use' || subOrFilter === 'set') {
@@ -316,6 +318,7 @@ async function renderModels(runtime: CliCommandRuntime): Promise<string> {
         id: model.id,
         displayName: model.displayName,
         contextWindow: services.providerRegistry.getContextWindowForModel(model),
+        contextWindowKnown: services.providerRegistry.getKnownContextWindowForModel(model) !== null,
         current: model.registryKey === current,
         ...(synthInfo !== null ? {
           isSynthetic: true,
@@ -331,7 +334,7 @@ async function renderModels(runtime: CliCommandRuntime): Promise<string> {
         const synthLabel = model.isSynthetic
           ? ` [synthetic ${model.syntheticConfiguredBackends}/${model.syntheticBackends}p]`
           : '';
-        return `  ${model.current ? '*' : ' '} ${model.registryKey.padEnd(42)} setup=${model.setupClass} ctx=${model.contextWindow.toLocaleString()}${synthLabel} ${model.displayName}`;
+        return `  ${model.current ? '*' : ' '} ${model.registryKey.padEnd(42)} setup=${model.setupClass} ctx=${model.contextWindowKnown ? model.contextWindow.toLocaleString() : 'unknown'}${synthLabel} ${model.displayName}`;
       }),
     ].join('\n'));
   });

package/src/cli/tui-startup.ts

@@ -7,7 +7,7 @@ import { startOnboardingFastPath } from '../runtime/onboarding/fast-path.ts';
 import { checkRecoveryForSession, readLastSessionPointer, type SessionSurface } from '@/runtime/index.ts';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { writeFatalLine } from '@pellux/goodvibes-sdk/platform/daemon';
-import { offerRecoverySnapshot } from '../runtime/recovery-prompt.ts';
+import { offerRecoverySnapshot, type RecoveryTypeaheadHooks } from '../runtime/recovery-prompt.ts';
 import { buildRecoveryOfferWiring } from '../runtime/recovery-offer-wiring.ts';
 import type { ConversationManager } from '../core/conversation.ts';
 import type { SessionManager } from '@pellux/goodvibes-sdk/platform/sessions';
@@ -34,6 +34,8 @@ export interface TuiStartupRecoveryDeps {
   readonly conversation: ConversationManager;
   readonly writeLastSessionPointer: (sessionId: string) => void;
   readonly receipt: (line: string) => void;
+  /** Holds typeahead out of the offer modal (see RecoveryPromptDeps.typeahead). */
+  readonly typeahead?: RecoveryTypeaheadHooks;
 }
 
 /**
@@ -59,11 +61,12 @@ export interface TuiStartupRecoveryDeps {
  *     plain store resume, after the follow-up Keep/Remove question the
  *     established flow always asks on decline.
  *
- * The modal itself is deferred to the next macrotask, mirroring
- * `scheduleRecoveryOffer`'s own reasoning: `applyInitialTuiCliState` runs
- * before the shell's first render, so asking a question here synchronously
- * would draw it at a blank terminal. The synchronous `checkRecoveryForSession`
- * probe above needs no such deferral, only opening the modal does.
+ * The modal opens synchronously, before the shell's first frame, like the
+ * general boot offer (startRecoveryOffer in runtime/recovery-prompt.ts): the
+ * first frame already carries the question, so the composer is never live
+ * underneath it, and keys typed before it was painted are held out of it by
+ * the typeahead gate (recovery.typeahead). This runs before the general
+ * offer, so it still asks first.
  */
 async function resumeNamedSessionWithRecoveryCheck(options: {
   readonly sessionId: string;
@@ -88,39 +91,31 @@ async function resumeNamedSessionWithRecoveryCheck(options: {
     return;
   }
 
-  await new Promise<void>((resolve) => {
-    const timer = setTimeout(() => {
-      void (async () => {
-        try {
-          const deps = buildRecoveryOfferWiring({
-            surface,
-            sessionManager: recovery.sessionManager,
-            runtime: recovery.runtime,
-            conversation: recovery.conversation,
-            commandContext,
-            writeLastSessionPointer: recovery.writeLastSessionPointer,
-            receipt: recovery.receipt,
-            render,
-          });
-          const outcome = await offerRecoverySnapshot({ ...deps, targetSessionId: sessionId });
-          if (outcome !== 'resumed') {
-            await plainResume();
-          }
-        } catch {
-          // Best-effort by construction (mirrors offerRecoverySnapshot's own
-          // guarantee): a failure here must fall back to the plain resume
-          // rather than leave the boot with nothing resumed at all.
-          await plainResume().catch(() => {
-            // A failing plain resume here is no worse than the pre-existing
-            // behavior when session resume itself fails.
-          });
-        } finally {
-          resolve();
-        }
-      })();
-    }, 0);
-    timer.unref?.();
-  });
+  try {
+    const deps = buildRecoveryOfferWiring({
+      surface,
+      sessionManager: recovery.sessionManager,
+      runtime: recovery.runtime,
+      conversation: recovery.conversation,
+      commandContext,
+      writeLastSessionPointer: recovery.writeLastSessionPointer,
+      receipt: recovery.receipt,
+      render,
+      ...(recovery.typeahead ? { typeahead: recovery.typeahead } : {}),
+    });
+    const outcome = await offerRecoverySnapshot({ ...deps, targetSessionId: sessionId });
+    if (outcome !== 'resumed') {
+      await plainResume();
+    }
+  } catch {
+    // Best-effort by construction (mirrors offerRecoverySnapshot's own
+    // guarantee): a failure here must fall back to the plain resume rather
+    // than leave the boot with nothing resumed at all.
+    await plainResume().catch(() => {
+      // A failing plain resume here is no worse than the pre-existing
+      // behavior when session resume itself fails.
+    });
+  }
 }
 
 /**

package/src/core/agent-view-render.ts

@@ -0,0 +1,157 @@
+/**
+ * agent-view-render.ts, one agent opened full screen.
+ *
+ * The agent becomes the session: its own transcript is the spine (drawn by
+ * the same lane-graph path as main, conversation-rendering.ts), the agents
+ * it spawned branch off it as lanes, and steers you sent that it has not
+ * picked up yet sit at the bottom marked as queued. Its lanes are drawn with
+ * the color base shifted (lane-graph/paint.ts withLaneColorBase) so its spine
+ * keeps the color its lane has in main.
+ *
+ *   row 0     ◆ engineer · the task · started by main 2m 14s ago
+ *   row 1     (blank)
+ *   rows      the agent's transcript
+ *
+ * A WRFC chain owner takes no turns of its own: its view is its chain, each
+ * phase agent a lane off its spine drawn from that agent's own transcript
+ * (work-tree-model.ts buildWrfcOwnerModel).
+ *
+ * The thin bar down column 0, the blank rows above and below the body, and
+ * the scroll window are the caller's (shell/session-views.ts); this returns
+ * every line.
+ */
+
+import { createEmptyLine, type Line } from '@pellux/goodvibes-sdk/platform/types';
+import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';
+import { appendConversationMessages, drawConversationTurn, type ConversationRenderContext } from './conversation-rendering.ts';
+import { buildWrfcOwnerModel } from './work-tree-model.ts';
+import type { AgentLaneInfo, WorkTreeSources } from './work-tree-sources.ts';
+import { laneColor, withLaneColorBase } from '../renderer/lane-graph/paint.ts';
+import type { TreeGlyphSetName } from '../renderer/lane-graph/glyphs.ts';
+import { UIFactory } from '../renderer/ui-factory.ts';
+import { activeTokens } from '../renderer/theme.ts';
+import { formatElapsed } from '../utils/format-elapsed.ts';
+import { getDisplayWidth, truncateDisplay } from '../utils/terminal-width.ts';
+
+export interface AgentViewInput {
+  readonly width: number;
+  readonly agent: AgentLaneInfo;
+  /** The agent's transcript (its lane info carries none for a WRFC owner). */
+  readonly messages: readonly ConversationMessageSnapshot[];
+  /** The agent's lane color index in main. */
+  readonly colorIndex: number;
+  /** Who started it: "main" or the parent agent's name. */
+  readonly parentName: string;
+  /** Main's work-tree sources (timings, spawned agents, waiting calls). */
+  readonly sources: WorkTreeSources;
+  /** Fold state for this view's beads; kept by the caller across frames. */
+  readonly collapse: Map<string, boolean>;
+  readonly glyphSet: TreeGlyphSetName;
+  readonly frame: number;
+  readonly now: number;
+  /** Steers sent from this view that the agent has not picked up yet, oldest first. */
+  readonly queuedSteers: readonly string[];
+}
+
+const TEXT_X = 3;
+
+function put(line: Line, x: number, endX: number, text: string, style: { fg: string; bold?: boolean }): number {
+  let cx = x;
+  for (const ch of text) {
+    const w = getDisplayWidth(ch);
+    if (w <= 0) continue;
+    if (cx + w > endX || cx >= line.length) break;
+    line[cx] = { char: ch, fg: style.fg, bg: '', bold: style.bold ?? false, dim: false, underline: false, italic: false, strikethrough: false };
+    if (w === 2 && cx + 1 < line.length) line[cx + 1] = { ...line[cx]!, char: '' };
+    cx += w;
+  }
+  return cx;
+}
+
+function stateText(agent: AgentLaneInfo, parentName: string, now: number): { text: string; tone: 'faint' | 'good' | 'bad' | 'warn' } {
+  const started = agent.startedAt !== undefined ? `started by ${parentName} ${formatElapsed(Math.max(0, now - agent.startedAt))} ago` : `started by ${parentName}`;
+  switch (agent.status) {
+    case 'running': return { text: started, tone: 'faint' };
+    case 'pending': return { text: `waiting to start · ${started}`, tone: 'faint' };
+    case 'completed': {
+      const took = agent.startedAt !== undefined && agent.completedAt !== undefined ? ` in ${formatElapsed(agent.completedAt - agent.startedAt)}` : '';
+      return { text: `finished${took} · ${agent.toolCallCount} tool${agent.toolCallCount === 1 ? '' : 's'}`, tone: 'good' };
+    }
+    case 'failed': return { text: `failed${agent.error ? `: ${agent.error.split('\n')[0]}` : ''}`, tone: 'bad' };
+    case 'cancelled': return { text: 'stopped', tone: 'warn' };
+  }
+}
+
+/** The ◆ head row. */
+function headRow(input: AgentViewInput): Line {
+  const t = activeTokens();
+  const line = createEmptyLine(input.width);
+  for (const cell of line) cell.bg = '';
+  const end = input.width - 3;
+  const color = laneColor(input.colorIndex);
+  let x = put(line, TEXT_X, end, '◆', { fg: color, bold: true });
+  // A chain owner is named for what it is, as its lane in main is.
+  x = put(line, x + 1, end, input.agent.wrfcPhases ? 'WRFC chain' : input.agent.hostedLabel ?? input.agent.name, { fg: color, bold: true });
+  const state = stateText(input.agent, input.parentName, input.now);
+  const stateFg = state.tone === 'good' ? t.success : state.tone === 'bad' ? t.error : state.tone === 'warn' ? t.warning : t.textFaint;
+  const task = input.agent.task.split('\n').find((l) => l.trim().length > 0)?.trim() ?? '';
+  // The state is kept whole; the task yields its room first.
+  const stateW = getDisplayWidth(state.text) + 3;
+  const taskRoom = end - x - 3 - stateW;
+  if (task && taskRoom >= 8) {
+    x = put(line, x + 1, end, '·', { fg: t.textFaint });
+    x = put(line, x + 1, end, truncateDisplay(task, taskRoom), { fg: t.textMuted });
+  }
+  x = put(line, x + 1, end, '·', { fg: t.textFaint });
+  put(line, x + 1, end, truncateDisplay(state.text, Math.max(0, end - x - 1)), { fg: stateFg });
+  return line;
+}
+
+/** Every line of the agent view, top to bottom. */
+export function renderAgentView(input: AgentViewInput): Line[] {
+  const t = activeTokens();
+  const lines: Line[] = [headRow(input), createEmptyLine(input.width)];
+  const running = input.agent.status === 'running' || input.agent.status === 'pending';
+  const context: ConversationRenderContext = {
+    history: { addLine: (l) => { lines.push(l); }, addLines: (ls) => { lines.push(...ls); }, getLineCount: () => lines.length },
+    blockRegistry: [],
+    collapseState: input.collapse,
+    errorLineRegistry: [],
+    messageKindRegistry: new Map(),
+    configManager: null,
+    splashOptions: {},
+    // The agent's own turns are live while the agent runs, not while main does.
+    workTreeSources: { ...input.sources, turnActive: () => running, turnTiming: undefined },
+    treeGlyphSet: input.glyphSet,
+    focusId: null,
+    frame: input.frame,
+  };
+  const phases = input.agent.wrfcPhases;
+  if (phases) {
+    if (phases.length > 0) {
+      const model = buildWrfcOwnerModel({ info: input.agent, sources: context.workTreeSources ?? {}, collapse: input.collapse });
+      withLaneColorBase(input.colorIndex, () => { lines.push(...drawConversationTurn(context, model, input.width).lines); });
+    }
+  } else {
+    withLaneColorBase(input.colorIndex, () => appendConversationMessages(context, [...input.messages], input.width, []));
+  }
+  const empty = phases ? phases.length === 0 : input.messages.length === 0;
+  if (empty) {
+    const note = createEmptyLine(input.width);
+    for (const cell of note) cell.bg = '';
+    const text = phases
+      ? (running ? 'The chain has not started a phase yet.' : 'This chain ran no phases.')
+      : running ? 'No transcript yet: the agent has not taken a turn.' : 'This agent left no transcript.';
+    put(note, TEXT_X + 2, input.width - 3, text, { fg: t.textFaint });
+    lines.push(note);
+  }
+  for (const steer of input.queuedSteers) {
+    lines.push(createEmptyLine(input.width));
+    lines.push(...UIFactory.createMessageBar(input.width, steer));
+    const note = createEmptyLine(input.width);
+    for (const cell of note) cell.bg = '';
+    put(note, TEXT_X + 2, input.width - 3, '⧗ queued · it arrives at the agent\'s next turn', { fg: t.textFaint });
+    lines.push(note);
+  }
+  return lines;
+}