eve 0.6.0-beta.6 → 0.6.0-beta.7

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # eve
 
+## 0.6.0-beta.7
+
+### Minor Changes
+
+- edf9f1a: Redesign the `eve dev` terminal UI and add `Client.info()`.
+
+  The TUI now streams its transcript into the terminal's native scrollback instead of a bordered alt-screen, so scrolling, copy/paste, and the transcript all survive after you exit. The visual language follows the Vercel / Next.js CLI: a monochrome base with the `▲` brand mark, colored gutter glyphs per speaker, the `dots` spinner, and status icons (`✓` done, `⨯` error). Tool calls collapse to a one-line summary (`✓ get_weather  city="SF" → 73°F`) that expands under `--tools full`, subagent work is indented beneath a `◆` header, and a startup header prints the connected agent's model, instructions, tools, skills, and subagents. Subagents now default to `auto-collapsed`.
+
+  The prompt input gains shell-style editing: `↑`/`↓` cycle through your previously sent messages, `←`/`→`/Home/End/`Ctrl+A`/`Ctrl+E` move the caret, and `Ctrl+U`/`Ctrl+K`/`Ctrl+W` kill the line/word. Escape sequences that arrive split across reads (common with PTYs) are reassembled, and pasted text is sanitized of stray control bytes.
+
+  Failures read more cleanly: a terminal `session.failed` (or a dead-socket transport error) no longer leaves you stuck — the TUI starts a fresh session before the next prompt and notes it inline, so you can keep going. A failure cascade (`step.failed` → `turn.failed` → `session.failed`) renders one error block instead of three, and code bugs escaping user code show their stack trace dim beneath the headline (capped to a dozen lines; recognized provider/config failures keep their curated one-line summary). Error blocks no longer double-print a `Code: Code:` prefix and render docs links in cyan, and denied tool approvals settle to a `→ denied` line instead of a frozen `?`.
+
+  Captured server `stdout`/`stderr` renders as quiet, indented log runs: consecutive lines from the same source coalesce behind one `stdout ·` / `stderr ·` label with a hanging indent, runs get a blank line of breathing room on both sides, and nothing is ever truncated — a transcript can't be clicked open, so the full output is always shown.
+
+  `Client.info()` fetches the agent inspection payload (`GET /eve/v1/info`) — model id, instructions source, tools, skills, subagents, schedules, and sandbox — for both local and remote targets, returning the new `AgentInfoResult` type.
+
 ## 0.6.0-beta.6
 
 ### Minor Changes

package/dist/docs/public/advanced/dev-tui.md

@@ -9,7 +9,22 @@ description: "Drive an Eve agent locally in an interactive terminal UI: chat, st
 eve dev
 ```
 
-The screen has three parts. A header shows the app name and live response stats. The middle is a scrollable transcript of everything that happened: your prompts, streamed messages, reasoning, tool calls, subagent sections, connection-authorization prompts, and any captured `stdout`/`stderr`. The bottom is an input and status bar. Press `Enter` to send and `↑`/`↓` to scroll. `q` quits when the agent is idle, and `Ctrl+C` quits at any time. Two slash commands: `/new` starts a fresh session and `/exit` quits.
+On startup the TUI prints a header for the connected agent — the model, instructions prompt, and the tools, skills, and subagents it has available:
+
+```text
+ ▲ Weather Agent
+ · Model         openai/gpt-5
+ · Instructions  agent/instructions.md
+ · Tools         get_weather, get_forecast, geocode
+ · Subagents     researcher
+ · Server        http://localhost:3000
+
+ Type to chat  ·  ↑ history  ·  /new reset session  ·  /exit quit  ·  Ctrl+C interrupt
+```
+
+From there the conversation streams straight into your terminal's normal scrollback — your prompts, the agent's replies, reasoning, tool calls, nested subagents, connection-authorization prompts, and any captured `stdout`/`stderr` — so you keep native scrolling, copy/paste, and a transcript that persists after you exit. Each turn is rendered without boxes: a colored gutter glyph marks who's speaking, tool calls collapse to a one-line summary (`✓ get_weather  city="SF" → 73°F`), and a subagent's work is indented beneath its `◆` header. A sticky line at the bottom shows the input prompt or the live status (spinner, token usage). Press `Enter` to send; `Ctrl+C` interrupts a running turn or quits at the prompt. Two slash commands: `/new` starts a fresh session and `/exit` quits.
+
+The prompt input behaves like a shell line editor: `↑`/`↓` cycle through the messages you've sent this session, `←`/`→`, Home/End, and `Ctrl+A`/`Ctrl+E` move the caret, and `Ctrl+U`/`Ctrl+K`/`Ctrl+W` kill the line, the rest of the line, or the previous word. If a turn fails terminally — the server session dies or the connection drops — the TUI starts a fresh session and notes it inline so you can keep going (server-side context resets with the old session). Errors render compactly, with docs links highlighted, and a code bug escaping your agent's own code shows its stack trace dim beneath the error headline. Captured server `stdout`/`stderr` renders as dim, indented log runs behind a `│` rule — consecutive lines from the same source share one label, and nothing is ever hidden.
 
 The agent will sometimes need something from you, and the TUI asks inline. Tool approvals are a `y`/`n`. Option questions let you pick with `↑`/`↓` and `Enter`, or you can type a freeform answer. If a tool needs an authorized [connection](../connections), the URL shows up right in the transcript, and the turn picks back up once you've finished the flow.
 

package/dist/docs/public/advanced/sessions-runs-and-streaming.md

@@ -100,7 +100,7 @@ Start with the [TypeScript Client](../client/overview) guide. It covers basic us
 
 ## Inspect the agent over HTTP
 
-`GET /eve/v1/info` returns a JSON inspection payload for the running agent: model id, instructions preview, skills, schedules, subagents, tools, sandbox, and the runtime's endpoint catalog. It's the `eve info` CLI, served over HTTP.
+`GET /eve/v1/info` returns a JSON inspection snapshot for the running agent: model, instructions, authored and framework tools, skills, channels, schedules, subagents, sandbox, connections, hooks, workflow, and workspace metadata. Local development accepts loopback requests; deployed Vercel targets require the route's OIDC auth.
 
 ```bash
 curl http://127.0.0.1:3000/eve/v1/info

package/dist/src/chunks/{use-eve-agent-9vL56Fjy.js → use-eve-agent-DCZbkLG7.js}

@@ -434,6 +434,16 @@ var Client = class {
 		}
 		return await response.json();
 	}
+	async info() {
+		const url = createClientUrl(this.#host, EVE_INFO_ROUTE_PATH);
+		const headers = await this.#resolveHeaders();
+		const response = await fetch(url, { headers });
+		if (!response.ok) {
+			const body = await response.text();
+			throw new ClientError(response.status, body);
+		}
+		return await response.json();
+	}
 	session(state) {
 		let resolved;
 		if (typeof state === "string") resolved = {

package/dist/src/chunks/{use-eve-agent-DTWI5Lji.js → use-eve-agent-DoheC4_o.js}

@@ -434,6 +434,16 @@ var Client = class {
 		}
 		return await response.json();
 	}
+	async info() {
+		const url = createClientUrl(this.#host, EVE_INFO_ROUTE_PATH);
+		const headers = await this.#resolveHeaders();
+		const response = await fetch(url, { headers });
+		if (!response.ok) {
+			const body = await response.text();
+			throw new ClientError(response.status, body);
+		}
+		return await response.json();
+	}
 	session(state) {
 		let resolved;
 		if (typeof state === "string") resolved = {

package/dist/src/cli/dev/tui/agent-header.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Builds the startup header the dev TUI commits to scrollback before the first
+ * prompt. Styled after the Next.js dev banner: a leading `▲` brand mark, then
+ * an aligned `·` list of the agent's resolved configuration (model,
+ * instructions, authored tools, skills, subagents, server). When the
+ * `/eve/v1/info` payload is unavailable it degrades to a minimal name +
+ * server banner.
+ */
+import type { AgentInfoResult } from "#client/index.js";
+import type { Theme } from "./theme.js";
+export interface AgentHeaderInput {
+    /** Resolved display name (e.g. "Weather Agent"). */
+    name: string;
+    /** Server URL the TUI is connected to. */
+    serverUrl: string;
+    /** Agent inspection payload, or `undefined` when it could not be fetched. */
+    info?: AgentInfoResult;
+    theme: Theme;
+    /** Available terminal width. */
+    width: number;
+}
+/**
+ * Returns the styled rows of the startup header (no trailing blank line is
+ * added by callers other than the one separating it from the transcript).
+ */
+export declare function buildAgentHeader(input: AgentHeaderInput): string[];

package/dist/src/cli/dev/tui/agent-header.js

@@ -0,0 +1 @@
+import{truncate}from"./tool-format.js";function buildAgentHeader(t){let{theme:n,info:r,name:i,serverUrl:a,width:o}=t,s=n.colors,c=[];if(r){c.push({label:`Model`,value:r.agent.model.id}),r.instructions.static&&c.push({label:`Instructions`,value:r.instructions.static.logicalPath});let e=[...r.tools.authored,...r.tools.dynamic.filter(e=>e.origin===`authored`).map(e=>({name:e.slug}))];e.length>0&&c.push({label:`Tools`,value:joinNames(e)});let t=[...r.skills.static,...r.skills.dynamic.filter(e=>e.origin===`authored`).map(e=>({name:e.slug}))];t.length>0&&c.push({label:`Skills`,value:joinNames(t)}),r.subagents.local.length>0&&c.push({label:`Subagents`,value:joinNames(r.subagents.local)}),r.schedules.length>0&&c.push({label:`Schedules`,value:joinNames(r.schedules)}),r.sandbox&&c.push({label:`Sandbox`,value:r.sandbox.logicalPath})}c.push({label:`Server`,value:a,link:!0});let l=c.reduce((e,t)=>Math.max(e,t.label.length),0),u=Math.max(8,o-l-6),d=[];if(d.push(` ${s.bold(`${n.glyph.brand} ${i}`)}`),r&&(r.diagnostics.discoveryErrors>0||r.diagnostics.discoveryWarnings>0)){let e=[];r.diagnostics.discoveryErrors>0&&e.push(s.red(`${r.diagnostics.discoveryErrors} error${plural(r.diagnostics.discoveryErrors)}`)),r.diagnostics.discoveryWarnings>0&&e.push(s.yellow(`${r.diagnostics.discoveryWarnings} warning${plural(r.diagnostics.discoveryWarnings)}`)),d.push(` ${s.dim(n.glyph.warning)} ${e.join(s.dim(` · `))}`)}for(let t of c){let r=s.dim(n.glyph.dot)+` `+s.gray(t.label.padEnd(l)),i=truncate(t.value,u);d.push(` ${r}  ${t.link?s.cyan(i):i}`)}return d.push(``),d.push(` ${s.dim(`Type to chat  ${n.glyph.dot}  ↑ history  ${n.glyph.dot}  /new reset session  ${n.glyph.dot}  /exit quit  ${n.glyph.dot}  Ctrl+C interrupt`)}`),d}function joinNames(e){return e.map(e=>e.name).join(`, `)}function plural(e){return e===1?``:`s`}export{buildAgentHeader};

package/dist/src/cli/dev/tui/blocks.d.ts

@@ -0,0 +1,72 @@
+/**
+ * The transcript block model and its renderer.
+ *
+ * A {@link Block} is one logical unit of the conversation — a user message, a
+ * streamed assistant reply, a reasoning trace, a tool call, a nested subagent
+ * step, a log line, and so on. {@link renderBlockLines} turns a block into the
+ * exact terminal rows it occupies: a colored gutter glyph, brand-aligned
+ * indentation, nesting rules for subagents, and word-wrapped content — with no
+ * boxes anywhere. Every returned row is already styled and fits within the
+ * given width, so the live region can place rows verbatim.
+ */
+import type { Theme } from "./theme.js";
+export type ToolStatus = "running" | "done" | "error" | "denied" | "approval";
+export type BlockKind = "user" | "assistant" | "reasoning" | "tool" | "error" | "notice" | "question" | "subagent" | "subagent-step" | "subagent-tool" | "connection-auth" | "log";
+/**
+ * One renderable transcript unit. Fields are interpreted per `kind`; unset
+ * fields are simply omitted from the rendered output.
+ */
+export interface Block {
+    kind: BlockKind;
+    /** Stable id for in-place updates while the block is live. */
+    id?: string;
+    /** Nesting depth: 0 = top level, 1 = inside a subagent, etc. */
+    depth?: number;
+    /** Whether the block is still streaming / mutating (drives the spinner). */
+    live?: boolean;
+    /** Primary label — tool name, subagent name, log source, error title. */
+    title?: string;
+    /** Compact secondary text — summarized tool args. */
+    subtitle?: string;
+    /** Main multi-line content (markdown for prose, plain for logs). */
+    body?: string;
+    /** Reasoning trace shown above `body` (subagent steps). */
+    reasoning?: string;
+    /** One-line summarized result shown after a tool resolves. */
+    result?: string;
+    /**
+     * Errors only: multi-line diagnostic dump (stack trace, cause chain)
+     * rendered dim beneath the headline, capped to a handful of lines.
+     */
+    detail?: string;
+    /** Tool / connection lifecycle status. */
+    status?: ToolStatus;
+    /** When true, treat `body` as pre-styled and only wrap + indent it. */
+    preformatted?: boolean;
+    /** Reasoning only: collapse the trace to a single "thinking" line. */
+    collapsed?: boolean;
+    /** When true, expand tool input/output instead of summarizing. */
+    expanded?: boolean;
+    /** Raw tool input / output for the expanded view. */
+    toolInput?: unknown;
+    toolOutput?: unknown;
+}
+export interface RenderBlockContext {
+    /** Current spinner frame for live blocks. */
+    spinner: string;
+    /**
+     * Kind and title of the block rendered immediately above this one. Lets a
+     * log block detect that it continues a same-source run (label suppressed,
+     * lines hang under the previous block's label) without any mutable run
+     * state — each captured write stays its own immediately-committed block.
+     */
+    previous?: {
+        kind: BlockKind;
+        title?: string;
+    };
+}
+/**
+ * Renders a block to its terminal rows. Each row is fully styled and clipped
+ * to `width` visible columns.
+ */
+export declare function renderBlockLines(block: Block, width: number, theme: Theme, context: RenderBlockContext): string[];

package/dist/src/cli/dev/tui/blocks.js

@@ -0,0 +1,6 @@
+import{formatValuePretty,truncate}from"./tool-format.js";import{sliceVisible,visibleLength,wrapVisibleLine}from"./terminal-text.js";import{renderMarkdown}from"./markdown.js";function renderBlockLines(e,t,n,i){let a=nestingPrefix(e.depth??0,n);return renderBody(e,Math.max(8,t-visibleLength(a)),n,i).map(e=>`${a}${e}`)}function nestingPrefix(e,t){return e<=0?``:`${t.colors.orange(t.glyph.rule)} `.repeat(e)}function renderBody(e,t,n,r){switch(e.kind){case`user`:return renderUser(e,t,n);case`assistant`:case`subagent-step`:return renderProse(e,t,n);case`reasoning`:return renderReasoning(e,t,n);case`tool`:case`subagent-tool`:return renderTool(e,t,n,r);case`error`:return renderError(e,t,n);case`notice`:return renderNotice(e,t,n);case`question`:case`connection-auth`:return renderPreformatted(e,t,n);case`log`:return renderLog(e,t,n,r);case`subagent`:return renderSubagentHeader(e,t,n)}}function renderUser(e,t,n){let r=n.colors.cyan(n.glyph.user);return wrap(e.body??``,t-2).map(e=>`${r} ${e}`)}function renderProse(e,t,n){let r=[],o=e.kind===`subagent-step`,s=o?``:`${n.colors.bold(n.colors.white(n.glyph.brand))} `,c=o?``:`  `;e.reasoning&&e.reasoning.trim().length>0&&r.push(...renderReasoningLines(e.reasoning,t,n));let l=(e.body??``).trim();return l.length===0&&r.length===0?[`${s}${n.colors.dim(`thinking${n.glyph.ellipsis}`)}`]:(l.length>0&&renderMarkdown(l).split(`
+`).flatMap(e=>wrapVisibleLine(e,t-c.length)).forEach((e,t)=>{t===0&&!o&&r.length===0?r.push(`${s}${e}`):r.push(`${c}${e}`)}),r.length>0?r:[`${s}`])}function renderReasoning(e,t,n){return e.collapsed?[`${n.colors.gray(n.glyph.reasoning)} ${n.colors.dim(`thinking`)}`]:renderReasoningLines(e.body??``,t,n,n.glyph.reasoning)}function renderReasoningLines(e,t,n,r){let i=r?2:0,a=wrap(e.trim(),t-i);return a.length===0?[]:a.map((e,t)=>`${r?t===0?`${n.colors.gray(r)} `:`  `:``}${n.colors.dim(n.colors.italic(e))}`)}function renderTool(e,n,r,i){let{icon:a,accent:o}=toolGlyph(e.status??`running`,r,i),s=e.title??`tool`,c=n-2,l=truncatePlain(s,c),u=`${a} ${r.colors.bold(l)}`,d=c-l.length-2,f=e.subtitle??``;f.length>0&&d>=6&&(u+=`  ${r.colors.gray(truncate(f,d))}`);let p=[u];return e.expanded?p.push(...renderToolExpanded(e,n,r)):e.status===`done`&&e.result&&e.result.length>0?p.push(resultLine(r.glyph.arrow,e.result,n,r,o)):e.status===`error`&&e.result?p.push(resultLine(r.glyph.arrow,e.result,n,r,r.colors.red)):e.status===`denied`&&p.push(resultLine(r.glyph.arrow,`denied`,n,r,r.colors.yellow)),p}function renderToolExpanded(t,n,r){let i=[],push=(t,a,o)=>{if(a!==void 0){i.push(`  ${r.colors.dim(t)}`);for(let t of wrap(formatValuePretty(a),n-4))i.push(`    ${o(t)}`)}};return push(`input`,t.toolInput,r.colors.gray),t.status===`error`&&t.result?push(`error`,t.result,r.colors.red):push(`output`,t.toolOutput,r.colors.gray),i}function resultLine(e,n,r,i,a){let o=r-4;return`  ${i.colors.dim(e)} ${a(truncate(n,o))}`}function toolGlyph(e,t,n){switch(e){case`done`:return{icon:t.colors.green(t.glyph.success),accent:t.colors.gray};case`error`:return{icon:t.colors.red(t.glyph.error),accent:t.colors.red};case`denied`:return{icon:t.colors.yellow(t.glyph.warning),accent:t.colors.yellow};case`approval`:return{icon:t.colors.yellow(t.glyph.question),accent:t.colors.yellow};default:return{icon:t.colors.yellow(n.spinner),accent:t.colors.gray}}}function renderError(e,t,n){let r=n.colors.red(n.colors.bold(n.glyph.error)),i=e.title??`Error`,a=[`${r} ${n.colors.red(n.colors.bold(i))}`];for(let r of wrap(e.body??``,t-2))a.push(`  ${colorizeError(r,n)}`);return a.push(...renderErrorDetail(e.detail,t,n)),a}function renderErrorDetail(e,t,n){if(e===void 0||e.trim().length===0)return[];let r=e.split(`
+`),i=r.slice(0,12),a=i.map(e=>`  ${n.colors.dim(truncatePlain(e,Math.max(1,t-2)))}`),o=r.length-i.length;return o>0&&a.push(`  ${n.colors.dim(`${n.glyph.ellipsis} +${o} more line${o===1?``:`s`}`)}`),a}const URL_PATTERN=/(https?:\/\/\S+)/u;function colorizeError(e,t){return URL_PATTERN.test(e)?e.split(URL_PATTERN).map((e,n)=>n%2==1?t.colors.cyan(e):t.colors.red(e)).join(``):t.colors.red(e)}function renderNotice(e,t,n){let r=n.colors.dim(n.glyph.dot),i=wrap(e.body??``,t-2);return i.length===0?[r]:i.map(e=>`${r} ${n.colors.dim(e)}`)}function renderPreformatted(e,t,n){let r=e.kind===`connection-auth`?n.colors.yellow(n.glyph.connection):n.colors.yellow(n.colors.bold(n.glyph.question)),a=e.title??``,o=[`${r} ${n.colors.bold(a)}`];for(let n of(e.body??``).split(`
+`))for(let e of wrapVisibleLine(n,t-2))o.push(`  ${e}`);return o}function renderLog(e,t,n,a){let o=e.title===`stderr`,s=o?n.colors.red:n.colors.gray,c=n.colors.dim(n.glyph.rule),l=o?`stderr`:`stdout`,u=n.colors.dim(`${l} ${n.glyph.dot} `),d=visibleLength(u),f=` `.repeat(d),p=a.previous?.kind===`log`&&a.previous.title===e.title,m=(e.body??``).split(`
+`),h=[];for(let e of m){let r=wrapVisibleLine(e,Math.max(1,t-2-d));for(let e of r){let t=h.length===0&&!p?u:f;h.push(`${c} ${t}${n.colors.dim(s(e))}`)}}return h.length>0?h:[`${c}`]}function renderSubagentHeader(e,t,n){let r=truncatePlain(e.title??`subagent`,Math.max(8,t-14));return[`${n.colors.orange(n.glyph.subagent)} ${n.colors.bold(r)} ${n.colors.dim(`subagent`)}`]}function wrap(e,t){return e.trim().length===0?[]:e.split(`
+`).flatMap(e=>wrapVisibleLine(e,Math.max(1,t)))}function truncatePlain(e,t){return visibleLength(e)<=t?e:sliceVisible(e,t)}export{renderBlockLines};

package/dist/src/cli/dev/tui/errors.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Error classification and display formatting shared by the TUI runner and
+ * terminal renderer. One module owns the interrupt sentinel and the
+ * failure-event projections so the two sides cannot drift apart.
+ */
+import type { SessionFailedStreamEvent, StepFailedStreamEvent, TurnFailedStreamEvent } from "#client/index.js";
+/**
+ * One of the failure events a session stream can carry. All three share the
+ * same `{ code, message, details? }` payload shape — the harness emits them
+ * as a cascade (`step.failed` → `turn.failed` → `session.failed` /
+ * `session.waiting`) describing a single underlying failure.
+ */
+export type FailureStreamEvent = StepFailedStreamEvent | TurnFailedStreamEvent | SessionFailedStreamEvent;
+/**
+ * Thrown when the user interrupts the TUI (Ctrl+C, or Ctrl+D on an empty
+ * prompt). The runner treats it as a clean exit, never as a failure.
+ */
+export declare class InterruptedError extends Error {
+    constructor();
+}
+export declare function interruptedError(): InterruptedError;
+export declare function isInterruptedError(error: unknown): boolean;
+/**
+ * Recognizes errors raised by aborting an in-flight fetch/stream (e.g. the
+ * subagent child-session pump being cancelled). These are expected shutdown
+ * noise, not failures to surface.
+ */
+export declare function isAbortLikeError(error: unknown): boolean;
+/**
+ * Stable identity for one failure cascade entry. The harness emits the same
+ * `{ code, message }` payload on `step.failed`, `turn.failed`, and (for
+ * terminal failures) `session.failed`; keying on both lets the stream
+ * translator render the underlying failure exactly once.
+ */
+export declare function failureKey(event: FailureStreamEvent): string;
+/**
+ * One-line headline for a failure event: `code: message`, except when the
+ * message already carries its own class-name prefix (e.g. a
+ * `HookConflictError` whose message starts with `HookConflictError:`), in
+ * which case the message stands alone instead of reading `Code: Code: …`.
+ */
+export declare function formatFailureMessage(event: FailureStreamEvent): string;
+/**
+ * Extracts the diagnostic dump attached to a failure event, if any.
+ *
+ * `details.detail` is the `util.inspect` rendering (stack trace and cause
+ * chain included) that `formatError` attaches to *unrecognized* failures —
+ * i.e. code bugs escaping user code. Recognized provider/config failures
+ * deliberately ship a curated summary without the dump, so this returns
+ * `undefined` for them and the headline stands alone.
+ */
+export declare function formatFailureDetail(event: FailureStreamEvent): string | undefined;

package/dist/src/cli/dev/tui/errors.js

@@ -0,0 +1 @@
+var InterruptedError=class extends Error{constructor(){super(`Interrupted`),this.name=`InterruptedError`}};function interruptedError(){return new InterruptedError}function isInterruptedError(e){return e instanceof InterruptedError}function isAbortLikeError(e){return e instanceof Error?e.name===`AbortError`||/\babort(?:ed)?\b/iu.test(e.message):!1}function failureKey(e){return`${e.data.code}:${e.data.message}`}function formatFailureMessage(e){let{code:t,message:n}=e.data;return!t||n===t||n.startsWith(`${t}:`)||n.startsWith(`${t} `)?n:`${t}: ${n}`}function formatFailureDetail(e){let t=e.data.details;if(typeof t!=`object`||!t)return;let n=t.detail;if(typeof n!=`string`)return;let r=n.trim();if(!(r.length===0||r===e.data.message.trim()))return r}export{InterruptedError,failureKey,formatFailureDetail,formatFailureMessage,interruptedError,isAbortLikeError,isInterruptedError};

package/dist/src/cli/dev/tui/line-editor.d.ts

@@ -0,0 +1,68 @@
+/**
+ * A tiny, dependency-free line-editing model for the prompt input.
+ *
+ * The renderer owns the terminal; this module owns the *text* — a single
+ * logical line plus a caret position — and exposes pure transforms for the
+ * common readline-style edits (insert, delete, word/line kill, cursor moves)
+ * and a {@link visibleLine} helper that windows a long line around the caret
+ * so it stays on screen. Keeping it pure makes the editing rules trivial to
+ * unit test without a TTY.
+ */
+/** One logical input line: its text and the caret's index within it. */
+export interface LineState {
+    readonly text: string;
+    readonly cursor: number;
+}
+/** The empty line with the caret at column 0. */
+export declare const EMPTY_LINE: LineState;
+/** Builds a line from `text` with the caret placed at the end. */
+export declare function lineOf(text: string): LineState;
+/** Inserts `value` at the caret and advances the caret past it. */
+export declare function insert(state: LineState, value: string): LineState;
+/** Deletes the character before the caret (Backspace). */
+export declare function backspace(state: LineState): LineState;
+/** Deletes the character at the caret (Delete / Ctrl+D mid-line). */
+export declare function deleteForward(state: LineState): LineState;
+/** Moves the caret one column left. */
+export declare function moveLeft(state: LineState): LineState;
+/** Moves the caret one column right. */
+export declare function moveRight(state: LineState): LineState;
+/** Moves the caret to the start of the line (Home / Ctrl+A). */
+export declare function moveHome(state: LineState): LineState;
+/** Moves the caret to the end of the line (End / Ctrl+E). */
+export declare function moveEnd(state: LineState): LineState;
+/** Deletes from the caret to the end of the line (Ctrl+K). */
+export declare function killToEnd(state: LineState): LineState;
+/** Deletes from the start of the line to the caret (Ctrl+U). */
+export declare function killToStart(state: LineState): LineState;
+/** Deletes the whitespace-delimited word before the caret (Ctrl+W). */
+export declare function deleteWord(state: LineState): LineState;
+/**
+ * The portion of `state.text` to draw within `budget` columns, split at the
+ * caret so the renderer can place its caret glyph between `before` and
+ * `after`. When the line is wider than `budget` it is windowed around the
+ * caret, marking truncated ends with `…` so the caret is always visible.
+ */
+export interface VisibleLine {
+    readonly before: string;
+    readonly after: string;
+}
+export declare function visibleLine(state: LineState, budget: number, ellipsis?: string): VisibleLine;
+/**
+ * In-memory, append-only prompt history with shell-style up/down navigation.
+ *
+ * Navigation is non-destructive: stepping back from the live line stashes the
+ * in-progress draft and restores it when the user steps forward past the
+ * newest entry. Consecutive duplicate submissions are collapsed.
+ */
+export declare class PromptHistory {
+    #private;
+    /** Records a submitted prompt (skips blanks and consecutive duplicates). */
+    add(entry: string): void;
+    /** Resets navigation to the live line, stashing `draft` as the in-progress text. */
+    begin(draft: string): void;
+    /** The previous (older) entry, or `undefined` at the oldest entry. */
+    previous(currentDraft: string): string | undefined;
+    /** The next (newer) entry, or the stashed draft once past the newest entry. */
+    next(): string | undefined;
+}

package/dist/src/cli/dev/tui/line-editor.js

@@ -0,0 +1 @@
+const EMPTY_LINE={text:``,cursor:0};function lineOf(e){return{text:e,cursor:e.length}}function insert(e,t){return t.length===0?e:{text:e.text.slice(0,e.cursor)+t+e.text.slice(e.cursor),cursor:e.cursor+t.length}}function backspace(e){return e.cursor===0?e:{text:e.text.slice(0,e.cursor-1)+e.text.slice(e.cursor),cursor:e.cursor-1}}function deleteForward(e){return e.cursor>=e.text.length?e:{text:e.text.slice(0,e.cursor)+e.text.slice(e.cursor+1),cursor:e.cursor}}function moveLeft(e){return e.cursor===0?e:{text:e.text,cursor:e.cursor-1}}function moveRight(e){return e.cursor>=e.text.length?e:{text:e.text,cursor:e.cursor+1}}function moveHome(e){return e.cursor===0?e:{text:e.text,cursor:0}}function moveEnd(e){return e.cursor===e.text.length?e:{text:e.text,cursor:e.text.length}}function killToEnd(e){return e.cursor>=e.text.length?e:{text:e.text.slice(0,e.cursor),cursor:e.cursor}}function killToStart(e){return e.cursor===0?e:{text:e.text.slice(e.cursor),cursor:0}}function deleteWord(e){if(e.cursor===0)return e;let t=e.cursor;for(;t>0&&isWhitespace(e.text[t-1]);)--t;for(;t>0&&!isWhitespace(e.text[t-1]);)--t;return{text:e.text.slice(0,t)+e.text.slice(e.cursor),cursor:t}}function isWhitespace(e){return e!==void 0&&/\s/u.test(e)}function visibleLine(e,t,n=`…`){let r=Math.max(1,t),{text:i,cursor:a}=e;if(i.length<=r)return{before:i.slice(0,a),after:i.slice(a)};let o=a<r?0:a-r+1;o=Math.min(o,i.length-r),o=Math.max(0,o);let s=o+r,c=i.slice(o,s),l=a-o;return o>0&&l>0&&(c=n+c.slice(n.length)),s<i.length&&l<c.length&&(c=c.slice(0,c.length-n.length)+n),{before:c.slice(0,l),after:c.slice(l)}}var PromptHistory=class{#e=[];#t=0;#n=``;add(e){if(e.trim().length!==0){if(this.#e.at(-1)===e){this.#r();return}this.#e.push(e),this.#r()}}begin(e){this.#t=this.#e.length,this.#n=e}previous(e){if(this.#e.length!==0&&(this.#t===this.#e.length&&(this.#n=e),this.#t!==0))return--this.#t,this.#e[this.#t]}next(){if(!(this.#t>=this.#e.length))return this.#t+=1,this.#t===this.#e.length?this.#n:this.#e[this.#t]}#r(){this.#t=this.#e.length,this.#n=``}};export{EMPTY_LINE,PromptHistory,backspace,deleteForward,deleteWord,insert,killToEnd,killToStart,lineOf,moveEnd,moveHome,moveLeft,moveRight,visibleLine};

package/dist/src/cli/dev/tui/live-region.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The inline scrollback engine.
+ *
+ * Unlike a full-screen alt-buffer UI, the dev TUI streams its transcript into
+ * the terminal's *native* scrollback so the user keeps real scrolling, copy /
+ * paste, and a persistent transcript after exit. Two regions are maintained:
+ *
+ * - **Committed scrollback** — finalized rows printed once and owned by the
+ *   terminal thereafter (never repainted).
+ * - **Live region** — the still-streaming rows plus the sticky footer, redrawn
+ *   in place on every update.
+ *
+ * Redrawing moves the cursor to the top of the previous live region, clears to
+ * the end of the screen, and reprints. {@link flush} additionally writes a run
+ * of newly-finalized rows above the live region so they scroll away for good.
+ *
+ * Writes go through the terminal's original `write` captured at construction,
+ * so the renderer's foreign-output capture (which monkeypatches
+ * `process.stdout.write`) never mistakes the engine's own paint for agent log
+ * output.
+ */
+export interface LiveRegionOutput {
+    write(chunk: string): boolean;
+}
+export interface LiveRegionOptions {
+    /** Wrap each paint in synchronized-update markers to avoid flicker. */
+    synchronized?: boolean;
+}
+export declare class LiveRegion {
+    #private;
+    constructor(output: LiveRegionOutput, options?: LiveRegionOptions);
+    /** Hides the hardware cursor; the renderer draws its own caret. */
+    hideCursor(): void;
+    showCursor(): void;
+    /** Writes a newline through the bound (original) write. */
+    newline(): void;
+    /**
+     * Repaints the live region in place from `liveRows`. Each row must already
+     * be styled and fit within the terminal width (one row == one screen line).
+     */
+    update(liveRows: readonly string[]): void;
+    /**
+     * Commits `committedRows` to scrollback above the live region, then repaints
+     * `liveRows`. Committed rows are permanent and scroll with the terminal.
+     */
+    flush(committedRows: readonly string[], liveRows: readonly string[]): void;
+    /**
+     * Erases the live region, leaving the cursor at its former top. Committed
+     * scrollback is untouched. Used on teardown before restoring the cursor.
+     */
+    clear(): void;
+    /** Clears the visible transcript and, where supported, terminal scrollback. */
+    clearAll(): void;
+    /**
+     * Forgets the live-region row count without moving the cursor. Call after
+     * the cursor position is known to be a fresh column-0 line that the engine
+     * did not itself paint (e.g. immediately after teardown).
+     */
+    reset(): void;
+}

package/dist/src/cli/dev/tui/live-region.js

@@ -0,0 +1,3 @@
+const CLEAR_TO_END=`\x1B[0J`;var LiveRegion=class{#e;#t;#n=0;constructor(e,t){this.#e=e.write.bind(e),this.#t=t?.synchronized??!0}hideCursor(){this.#e(`\x1B[?25l`)}showCursor(){this.#e(`\x1B[?25h`)}newline(){this.#e(`
+`)}update(e){this.#r([],e)}flush(e,t){this.#r(e,t)}clear(){if(this.#n===0){this.#e(`\r`),this.#e(CLEAR_TO_END);return}this.#e(`${this.#i()}${CLEAR_TO_END}`),this.#n=0}clearAll(){this.#e(`\x1B[3J\x1B[2J\x1B[H`),this.#n=0}reset(){this.#n=0}#r(t,n){let r=this.#i()+CLEAR_TO_END+t.map(e=>`${e}\n`).join(``)+n.join(`
+`);this.#e(this.#t?`[?2026h${r}[?2026l`:r),this.#n=n.length}#i(){return this.#n<=1?`\r`:`[${this.#n-1}F`}};export{LiveRegion};

package/dist/src/cli/dev/tui/markdown.d.ts

@@ -1,14 +1 @@
-export type MarkdownToken = {
-    type: "text";
-    text: string;
-} | {
-    type: "bold";
-    text: string;
-} | {
-    type: "italic";
-    text: string;
-} | {
-    type: "code";
-    text: string;
-};
 export declare function renderMarkdown(input: string): string;

package/dist/src/cli/dev/tui/runner.d.ts

@@ -1,20 +1,69 @@
-import { type ConnectionAuthorizationOutcome, Client, ClientSession } from "#client/index.js";
-import { type UIMessage, type UIMessageChunk } from "ai";
+import { type AgentInfoResult, type ConnectionAuthorizationOutcome, type InputRequest, Client, ClientSession } from "#client/index.js";
 import type { AssistantResponseStatsMode, TerminalPartDisplayMode, TuiDisplayOptions } from "./types.js";
 import { type TerminalInput, type TerminalOutput } from "./terminal-renderer.js";
 export type AgentTUIStreamResult = {
-    uiMessageStream: AsyncIterable<UIMessageChunk> | ReadableStream<UIMessageChunk>;
-    message?: UIMessage;
+    events: AsyncIterable<AgentTUIStreamEvent> | ReadableStream<AgentTUIStreamEvent>;
     abort?: () => void;
+    turnState?: AgentTUITurnState;
 };
-export type AgentTUIStreamOptions = {
-    messages: UIMessage[];
+export type AgentTUIStreamUsage = {
+    inputTokens?: number;
+    outputTokens?: number;
+};
+export type AgentTUIStreamEvent = {
+    type: "step-start";
+} | {
+    type: "step-finish";
+    usage?: AgentTUIStreamUsage;
+} | {
+    type: "assistant-delta";
+    id: string;
+    delta: string;
+} | {
+    type: "assistant-complete";
+    id: string;
+    text?: string | null;
+} | {
+    type: "reasoning-delta";
+    id: string;
+    delta: string;
+} | {
+    type: "reasoning-complete";
+    id: string;
+} | {
+    type: "tool-call";
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+} | {
+    type: "tool-approval-request";
+    approvalId: string;
+    toolCallId: string;
+} | {
+    type: "tool-result";
+    toolCallId: string;
+    output: unknown;
+} | {
+    type: "tool-error";
+    toolCallId: string;
+    errorText: string;
+} | {
+    type: "error";
+    errorText: string;
+    detail?: string;
+} | {
+    type: "finish";
+    usage?: AgentTUIStreamUsage;
+};
+export type AgentTUITurnState = {
+    boundaryEvent?: "session.completed" | "session.failed" | "session.waiting";
+    pendingApprovals: AgentTUIToolApprovalRequest[];
+    pendingQuestions: InputRequest[];
+    sawSessionFailure: boolean;
 };
 export type AgentTUISessionOptions = {
     title?: string;
-    initialPrompt?: string;
     submittedPrompt?: string;
-    waitForExit?: boolean;
     continueSession?: boolean;
     tools?: TerminalPartDisplayMode;
     reasoning?: TerminalPartDisplayMode;
@@ -29,9 +78,6 @@ export type AgentTUIToolApprovalRequest = {
     toolName: string;
     title?: string;
     input: unknown;
-    providerExecuted?: boolean;
-    messageId: string;
-    partIndex: number;
 };
 export type AgentTUIToolApprovalResponse = {
     approved: boolean;
@@ -54,11 +100,27 @@ export type AgentTUIInputQuestionResponse = {
     optionId?: string;
     text?: string;
 };
+export type AgentTUIAgentHeader = {
+    name: string;
+    serverUrl: string;
+    info?: AgentInfoResult;
+};
 export type AgentTUIRenderer = {
+    /**
+     * Commits a startup header describing the connected agent (brand mark,
+     * model, instructions, tools, skills, subagents) to the transcript before
+     * the first prompt. Optional — renderers without a header simply skip it.
+     */
+    renderAgentHeader?(header: AgentTUIAgentHeader): void;
+    /**
+     * Commits a single dim informational line to the transcript. Used to
+     * announce session recovery after a terminal server failure. Optional.
+     */
+    renderNotice?(text: string): void;
     readPrompt?(options?: AgentTUISessionOptions): Promise<string | undefined>;
     readToolApproval?(request: AgentTUIToolApprovalRequest, options?: AgentTUISessionOptions): Promise<AgentTUIToolApprovalResponse>;
     readInputQuestion?(question: AgentTUIInputQuestion, options?: AgentTUISessionOptions): Promise<AgentTUIInputQuestionResponse | undefined>;
-    renderStream(result: AgentTUIStreamResult, options?: AgentTUISessionOptions): Promise<UIMessage | undefined>;
+    renderStream(result: AgentTUIStreamResult, options?: AgentTUISessionOptions): Promise<void>;
     /**
      * Out-of-band update for one child step (reasoning + message text) of a
      * subagent dispatch. Called by the runner as child-session stream events
@@ -72,9 +134,8 @@ export type AgentTUIRenderer = {
     upsertSubagentTool?(update: SubagentToolUpdate): void;
     /**
      * Registers a tool call id as originating from a subagent's child
-     * session. The renderer must skip rendering parent UIMessage tool parts
-     * for these ids — they are surfaced via {@link upsertSubagentTool}
-     * instead.
+     * session. The renderer must skip or remove parent-level tool blocks for
+     * these ids — they are surfaced via {@link upsertSubagentTool} instead.
      */
     markChildToolCallId?(callId: string): void;
     /**
@@ -138,12 +199,6 @@ export declare class EveTUIRunner {
     constructor(options: EveTUIRunnerOptions);
     run(): Promise<void>;
 }
-type ResponseMetadata = {
-    usage?: {
-        totalTokens?: number;
-        outputTokens?: number;
-    };
-};
 type SubagentChildStep = {
     reasoning: string;
     message: string;
@@ -208,4 +263,4 @@ export type ConnectionAuthUpdate = {
     challenge?: ConnectionAuthChallenge;
     reason?: string;
 };
-export type { ResponseMetadata as _ResponseMetadata };
+export {};