zoe-agent 0.3.1

package/dist/adapters/cli/tui/components/text-input.d.ts

@@ -0,0 +1,27 @@
+interface TextInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit: (value: string) => void;
+    placeholder?: string;
+    /** When true, ↑/↓ are left to the parent (e.g. autocomplete dropdown nav). */
+    ignoreArrows?: boolean;
+    /** When true, Enter does not submit — the parent owns it (autocomplete accept). */
+    ignoreReturn?: boolean;
+    /** Called when ↑ is pressed on the top line (recall previous history). */
+    onHistoryUp?: () => void;
+    /** Called when ↓ is pressed on the bottom line (recall next history). */
+    onHistoryDown?: () => void;
+}
+/**
+ * Multi-line controlled text input with cursor control + history.
+ *
+ * Newline: Shift+Enter / Alt+Enter / Ctrl+J (terminal-dependent — all three are
+ * bound for max compatibility). Plain Enter submits. ↑/↓ move between lines;
+ * at the top line ↑ recalls previous history, at the bottom line ↓ recalls next
+ * (via onHistoryUp/Down). Tab is left to the parent.
+ *
+ * External value changes (history recall, post-submit clear) move the cursor to
+ * the end; user keystrokes move it to the insertion point.
+ */
+export declare function TextInput({ value, onChange, onSubmit, placeholder, ignoreArrows, ignoreReturn, onHistoryUp, onHistoryDown, }: TextInputProps): import("react").JSX.Element;
+export {};

package/dist/adapters/cli/tui/components/text-input.js

@@ -0,0 +1,142 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { useTheme } from '../hooks/use-theme.js';
+// ── line/column math (value may contain '\n') ───────────────────────────
+function lineColOf(value, cursor) {
+    let line = 0;
+    let col = 0;
+    for (let i = 0; i < cursor && i < value.length; i++) {
+        if (value[i] === '\n') {
+            line++;
+            col = 0;
+        }
+        else {
+            col++;
+        }
+    }
+    return { line, col };
+}
+function lineStarts(value) {
+    const starts = [0];
+    for (let i = 0; i < value.length; i++) {
+        if (value[i] === '\n')
+            starts.push(i + 1);
+    }
+    return starts;
+}
+/** Move the cursor up/down one line, keeping the column; returns the same cursor at an edge. */
+function moveVertical(value, cursor, dir) {
+    const starts = lineStarts(value);
+    const { line, col } = lineColOf(value, cursor);
+    const target = line + dir;
+    if (target < 0 || target >= starts.length)
+        return cursor;
+    const targetStart = starts[target];
+    const targetEnd = target < starts.length - 1 ? starts[target + 1] - 1 : value.length; // exclude '\n'
+    const targetCol = Math.min(col, targetEnd - targetStart);
+    return targetStart + targetCol;
+}
+/**
+ * Multi-line controlled text input with cursor control + history.
+ *
+ * Newline: Shift+Enter / Alt+Enter / Ctrl+J (terminal-dependent — all three are
+ * bound for max compatibility). Plain Enter submits. ↑/↓ move between lines;
+ * at the top line ↑ recalls previous history, at the bottom line ↓ recalls next
+ * (via onHistoryUp/Down). Tab is left to the parent.
+ *
+ * External value changes (history recall, post-submit clear) move the cursor to
+ * the end; user keystrokes move it to the insertion point.
+ */
+export function TextInput({ value, onChange, onSubmit, placeholder, ignoreArrows, ignoreReturn, onHistoryUp, onHistoryDown, }) {
+    const theme = useTheme();
+    const [cursor, setCursor] = useState(value.length);
+    const selfUpdate = useRef(false);
+    useEffect(() => {
+        if (selfUpdate.current) {
+            selfUpdate.current = false;
+            return;
+        }
+        setCursor(value.length); // external change → cursor to end
+    }, [value]);
+    const at = Math.min(cursor, value.length);
+    const insert = (text) => {
+        selfUpdate.current = true;
+        onChange(value.slice(0, at) + text + value.slice(at));
+        setCursor(at + text.length);
+    };
+    useInput((inputChar, key) => {
+        // Newline before submit. Ink doesn't parse the modified-return CSI a
+        // terminal sends for Shift+Enter/Alt+Enter (`\x1B[27;<modifier>;13~`, where
+        // 13=return); detect that raw sequence too, plus the key-flag paths + Ctrl+J.
+        const isModifiedReturn = key.return && (key.shift || key.meta || key.ctrl);
+        const isCtrlJ = !key.return && (inputChar === '\n' || inputChar === '\x0a' || (key.ctrl && inputChar === 'j'));
+        const isModifiedReturnCSI = /\x1b?\[27;\d*;?13~/.test(inputChar);
+        if (isModifiedReturn || isCtrlJ || isModifiedReturnCSI) {
+            insert('\n');
+            return;
+        }
+        if (key.return) {
+            if (!ignoreReturn)
+                onSubmit(value);
+            return;
+        }
+        if (key.backspace || key.delete) {
+            if (at === 0)
+                return;
+            selfUpdate.current = true;
+            onChange(value.slice(0, at - 1) + value.slice(at));
+            setCursor(at - 1);
+            return;
+        }
+        if (!ignoreArrows) {
+            if (key.upArrow) {
+                const { line } = lineColOf(value, at);
+                if (line === 0) {
+                    onHistoryUp?.();
+                    return;
+                }
+                setCursor(moveVertical(value, at, -1));
+                return;
+            }
+            if (key.downArrow) {
+                const last = lineStarts(value).length - 1;
+                const { line } = lineColOf(value, at);
+                if (line === last) {
+                    onHistoryDown?.();
+                    return;
+                }
+                setCursor(moveVertical(value, at, 1));
+                return;
+            }
+        }
+        if (key.leftArrow) {
+            setCursor(Math.max(0, at - 1));
+            return;
+        }
+        if (key.rightArrow) {
+            setCursor(Math.min(value.length, at + 1));
+            return;
+        }
+        // Insert printable text (multi-char = paste), but never raw CSI escape
+        // sequences (e.g. leftover `\x1B[27;2;13~` from an unparsed modified key).
+        const isCsi = /\x1b?\[\d[\d;]*[~A-Za-z]/.test(inputChar);
+        if (inputChar && !key.ctrl && !key.meta && inputChar.length >= 1 && inputChar >= ' ' && !isCsi) {
+            insert(inputChar);
+        }
+    });
+    // Render — one <Text> per line; the cursor line shows the block cursor.
+    if (value.length === 0) {
+        return _jsx(Text, { color: theme.fgDim, children: placeholder ?? '' });
+    }
+    const { line: curLine, col: curCol } = lineColOf(value, at);
+    const lines = value.split('\n');
+    return (_jsx(Box, { flexDirection: "column", children: lines.map((line, i) => {
+            if (i !== curLine)
+                return _jsx(Text, { children: line || ' ' }, i);
+            const before = line.slice(0, curCol);
+            const c = line.slice(curCol, curCol + 1);
+            const after = line.slice(curCol + 1);
+            return (_jsxs(Text, { children: [before, _jsx(Text, { backgroundColor: theme.fg, color: theme.bg, children: c || ' ' }), after] }, i));
+        }) }));
+}

package/dist/adapters/cli/tui/components/tool-call-block.d.ts

@@ -0,0 +1,11 @@
+import type { ToolCallEntry } from '../types.js';
+/**
+ * Bordered tool-execution block: shared header, then the output buffer (or an
+ * inline diff for `write_file`). Collapsed by default (truncated output + hint);
+ * `expanded` shows the full output. Ctrl+O (handled in app.tsx) toggles
+ * expand-all and bumps the `<Static>` key so this re-renders.
+ */
+export declare function ToolCallBlock({ entry, expanded }: {
+    entry: ToolCallEntry;
+    expanded: boolean;
+}): import("react").JSX.Element;

package/dist/adapters/cli/tui/components/tool-call-block.js

@@ -0,0 +1,68 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useTheme } from '../hooks/use-theme.js';
+import { Markdown } from './markdown.js';
+import { GoalStatus } from './goal-status.js';
+import { DiffViewer } from './diff-viewer.js';
+import { isFileWriteMetadata } from '../diff/file-write-meta.js';
+const STATUS_GLYPH = {
+    running: '~',
+    ok: '✓',
+    fail: '✗',
+};
+/** Tools whose output is markdown-formatted (render via Markdown component). */
+const MARKDOWN_TOOLS = new Set(['web_search', 'read_website', 'optimize_prompt']);
+/** One-line preview of a tool's args — `command` shown verbatim, else JSON. */
+function formatArgs(args) {
+    if (typeof args.command === 'string' && args.command.length > 0)
+        return args.command;
+    const json = JSON.stringify(args);
+    return json === '{}' ? '' : json;
+}
+function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, max)} … (${text.length - max} more chars)`;
+}
+/** Status glyph + tool name + args preview + duration — shared by every block. */
+function BlockHeader({ entry, theme }) {
+    const glyph = STATUS_GLYPH[entry.status];
+    const glyphColor = entry.status === 'fail' ? theme.red : entry.status === 'running' ? theme.yellow : theme.green;
+    const argsPreview = formatArgs(entry.args);
+    return (_jsxs(Box, { children: [_jsxs(Text, { color: glyphColor, bold: true, children: [glyph, " "] }), _jsx(Text, { color: theme.purple, bold: true, children: entry.name }), argsPreview ? _jsxs(Text, { color: theme.fgDim, children: [" ", truncate(argsPreview, 120)] }) : null, entry.durationMs != null ? _jsxs(Text, { color: theme.fgDim, children: [" (", entry.durationMs, "ms)"] }) : null] }));
+}
+/**
+ * Bordered tool-execution block: shared header, then the output buffer (or an
+ * inline diff for `write_file`). Collapsed by default (truncated output + hint);
+ * `expanded` shows the full output. Ctrl+O (handled in app.tsx) toggles
+ * expand-all and bumps the `<Static>` key so this re-renders.
+ */
+export function ToolCallBlock({ entry, expanded }) {
+    const theme = useTheme();
+    // manage_todos renders as a GoalStatus (task list with glyphs), not a
+    // generic tool block.
+    if (entry.name === 'manage_todos' && entry.output) {
+        try {
+            const todos = JSON.parse(entry.output);
+            if (Array.isArray(todos) && todos.length > 0)
+                return _jsx(GoalStatus, { todos: todos });
+        }
+        catch { /* fall through to generic block */ }
+    }
+    // write_file with captured diff metadata → inline unified diff (collapsed by
+    // default; expanded via the global Ctrl+O toggle). Falls through to the
+    // generic block when there's no metadata (e.g. on session resume) or when the
+    // write was oversized (diffSkipped) — in which case the plain output shows.
+    if (entry.name === 'write_file') {
+        const meta = isFileWriteMetadata(entry.metadata) ? entry.metadata : null;
+        if (meta && !meta.diffSkipped && meta.newContent !== undefined) {
+            return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.fgGutter, paddingLeft: 1, paddingRight: 1, children: [_jsx(BlockHeader, { entry: entry, theme: theme }), _jsx(DiffViewer, { oldContent: meta.oldContent ?? null, newContent: meta.newContent, expanded: expanded })] }));
+        }
+    }
+    const output = entry.output ?? '';
+    const isMarkdown = MARKDOWN_TOOLS.has(entry.name);
+    const limit = expanded ? 50000 : isMarkdown ? 1000 : 400;
+    const shown = truncate(output, limit);
+    const hasMore = output.length > limit;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.fgGutter, paddingLeft: 1, paddingRight: 1, children: [_jsx(BlockHeader, { entry: entry, theme: theme }), output ? (MARKDOWN_TOOLS.has(entry.name) ? (_jsx(Markdown, { content: shown })) : (_jsx(Text, { color: theme.fgDim, children: shown }))) : null, hasMore ? (_jsxs(Text, { color: theme.fgDim, children: [" \u2026 ", output.length - limit, " more chars (Ctrl+O to expand)"] })) : output && expanded ? (_jsx(Text, { color: theme.fgDim, children: " (Ctrl+O to collapse)" })) : null] }));
+}

package/dist/adapters/cli/tui/components/user-message.d.ts

@@ -0,0 +1,5 @@
+import type { UserMessageEntry } from '../types.js';
+/** A user input entry — green speaker token + content. */
+export declare function UserMessage({ entry }: {
+    entry: UserMessageEntry;
+}): import("react").JSX.Element;

package/dist/adapters/cli/tui/components/user-message.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useTheme } from '../hooks/use-theme.js';
+/** A user input entry — green speaker token + content. */
+export function UserMessage({ entry }) {
+    const theme = useTheme();
+    return (_jsxs(Box, { children: [_jsx(Text, { color: theme.green, bold: true, children: "You \u203A " }), _jsx(Text, { color: theme.fg, children: entry.content })] }));
+}

package/dist/adapters/cli/tui/diff/file-write-meta.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Boundary parse guard for `write_file`'s tool-result metadata.
+ *
+ * `StepResult.metadata` is an opaque `Record<string, unknown>` at the core
+ * level; the TUI must parse it before use (constitution: parse, don't cast).
+ * The `FileWriteMetadata` type is owned by the producer (`src/tools/core.ts`)
+ * and imported here type-only — Adapter→Infrastructure is the allowed direction
+ * and the import is erased at runtime.
+ */
+import type { FileWriteMetadata } from '../../../../tools/core.js';
+export declare function isFileWriteMetadata(u: unknown): u is FileWriteMetadata;

package/dist/adapters/cli/tui/diff/file-write-meta.js

@@ -0,0 +1,11 @@
+export function isFileWriteMetadata(u) {
+    if (typeof u !== 'object' || u === null)
+        return false;
+    const m = u;
+    return (typeof m.path === 'string' &&
+        typeof m.isNewFile === 'boolean' &&
+        typeof m.byteDelta === 'number' &&
+        // oldContent, when present, is a string or null; newContent is a string.
+        (m.oldContent === undefined || m.oldContent === null || typeof m.oldContent === 'string') &&
+        (m.newContent === undefined || typeof m.newContent === 'string'));
+}

package/dist/adapters/cli/tui/diff/line-diff.d.ts

@@ -0,0 +1,17 @@
+export type DiffViewLine = {
+    kind: 'added';
+    newLineNo: number;
+    text: string;
+} | {
+    kind: 'removed';
+    oldLineNo: number;
+    text: string;
+} | {
+    kind: 'context';
+    oldLineNo: number;
+    newLineNo: number;
+    text: string;
+};
+/** Compute a line-level diff view-model. `oldContent === null` ⇒ new file
+ *  (every line added). */
+export declare function computeDiffLines(oldContent: string | null, newContent: string): DiffViewLine[];

package/dist/adapters/cli/tui/diff/line-diff.js

@@ -0,0 +1,44 @@
+/**
+ * Pure line-diff view-model for the inline diff viewer.
+ *
+ * Uses the `diff` package's `diffLines` (the same engine the Pi coding agent
+ * uses — see specs/006-inline-diff-viewer/research.md R1). CRLF/CR are
+ * normalized to LF before comparison so a CRLF file doesn't diff as
+ * fully-changed; the on-disk write is unaffected (research.md R5).
+ */
+import { diffLines } from 'diff';
+const toLF = (s) => s.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+/** Split a diff part's value into lines, dropping the trailing empty segment
+ *  produced by a final newline (diff parts always end with \n). */
+function splitLines(value) {
+    const segs = value.split('\n');
+    if (segs.length > 0 && segs[segs.length - 1] === '')
+        segs.pop();
+    return segs;
+}
+/** Compute a line-level diff view-model. `oldContent === null` ⇒ new file
+ *  (every line added). */
+export function computeDiffLines(oldContent, newContent) {
+    const parts = diffLines(oldContent === null ? '' : toLF(oldContent), toLF(newContent));
+    const out = [];
+    let oldNo = 1;
+    let newNo = 1;
+    for (const part of parts) {
+        for (const text of splitLines(part.value)) {
+            if (part.added) {
+                out.push({ kind: 'added', newLineNo: newNo, text });
+                newNo++;
+            }
+            else if (part.removed) {
+                out.push({ kind: 'removed', oldLineNo: oldNo, text });
+                oldNo++;
+            }
+            else {
+                out.push({ kind: 'context', oldLineNo: oldNo, newLineNo: newNo, text });
+                oldNo++;
+                newNo++;
+            }
+        }
+    }
+    return out;
+}

package/dist/adapters/cli/tui/feed-serializer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * feed-serializer — rebuild the TUI feed from persisted messages.
+ *
+ * When a session is resumed, its `Message[]` history must be projected back
+ * into the `FeedEntry` union the feed renders. During a live run, entries are
+ * built imperatively from `StepResult` callbacks (see use-agent.ts); on replay
+ * there is no loop, so this pure function does the equivalent mapping in one
+ * pass.
+ *
+ * `manage_todos` is handled exactly like the live path: it updates the
+ * persistent todo panel, NOT the feed. The most-recent `manage_todos` result is
+ * returned as `latestTodos` so the caller (session resume) can restore the
+ * pinned panel — otherwise the todos would only appear as a scrolling box.
+ *
+ * Tool results are NOT stored on the assistant message's toolCalls[].result —
+ * runAgentLoop emits them as separate role:"tool" messages linked by
+ * toolCallId (agent-loop.ts:459). This serializer joins the two so replayed
+ * tool blocks show their output. Tool durationMs is not persisted, so replayed
+ * blocks render without duration (cosmetic only).
+ */
+import type { Message } from '../../../core/types.js';
+import type { FeedEntryInput } from './types.js';
+import type { Todo } from './components/goal-status.js';
+export interface RebuiltFeed {
+    entries: FeedEntryInput[];
+    /** The most-recent manage_todos result (the current todo list), or null. */
+    latestTodos: Todo[] | null;
+}
+export declare function messagesToFeedEntries(messages: Message[]): RebuiltFeed;

package/dist/adapters/cli/tui/feed-serializer.js

@@ -0,0 +1,70 @@
+/**
+ * feed-serializer — rebuild the TUI feed from persisted messages.
+ *
+ * When a session is resumed, its `Message[]` history must be projected back
+ * into the `FeedEntry` union the feed renders. During a live run, entries are
+ * built imperatively from `StepResult` callbacks (see use-agent.ts); on replay
+ * there is no loop, so this pure function does the equivalent mapping in one
+ * pass.
+ *
+ * `manage_todos` is handled exactly like the live path: it updates the
+ * persistent todo panel, NOT the feed. The most-recent `manage_todos` result is
+ * returned as `latestTodos` so the caller (session resume) can restore the
+ * pinned panel — otherwise the todos would only appear as a scrolling box.
+ *
+ * Tool results are NOT stored on the assistant message's toolCalls[].result —
+ * runAgentLoop emits them as separate role:"tool" messages linked by
+ * toolCallId (agent-loop.ts:459). This serializer joins the two so replayed
+ * tool blocks show their output. Tool durationMs is not persisted, so replayed
+ * blocks render without duration (cosmetic only).
+ */
+export function messagesToFeedEntries(messages) {
+    // Index tool results by toolCallId for O(1) lookup when rendering tool calls.
+    const toolResults = new Map();
+    for (const m of messages) {
+        if (m.role === 'tool' && m.toolCallId) {
+            toolResults.set(m.toolCallId, m.content);
+        }
+    }
+    const entries = [];
+    let latestTodos = null;
+    for (const m of messages) {
+        if (m.role === 'system')
+            continue;
+        if (m.role === 'user') {
+            entries.push({ kind: 'user', content: m.content });
+        }
+        else if (m.role === 'assistant') {
+            if (m.content)
+                entries.push({ kind: 'assistant', content: m.content });
+            if (m.toolCalls) {
+                for (const tc of m.toolCalls) {
+                    const result = tc.result ?? toolResults.get(tc.id);
+                    // manage_todos feeds the persistent panel, not the scrollback (mirrors
+                    // the live intercept in use-agent). Track the latest; skip the feed.
+                    if (tc.name === 'manage_todos') {
+                        if (result) {
+                            try {
+                                const parsed = JSON.parse(result);
+                                if (Array.isArray(parsed))
+                                    latestTodos = parsed;
+                            }
+                            catch { /* ignore parse error */ }
+                        }
+                        continue;
+                    }
+                    entries.push({
+                        kind: 'tool',
+                        name: tc.name,
+                        args: tc.arguments,
+                        status: result != null ? 'ok' : 'fail',
+                        output: result,
+                    });
+                }
+            }
+        }
+        // role: 'tool' messages are consumed above via the toolResults index —
+        // they are provider-facing duplicates, not feed entries.
+    }
+    return { entries, latestTodos };
+}

package/dist/adapters/cli/tui/file-index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Recursively list project files as relative posix paths, skipping dependency
+ * / build / VCS directories. Pure (no cache): the caller (`prompt-area`) owns
+ * the result in React state and refreshes it on each idle mount and whenever
+ * `@` is entered — so files an agent created during a run show up immediately
+ * on the next prompt, with no restart.
+ */
+export declare function getFileIndex(root?: string): string[];

package/dist/adapters/cli/tui/file-index.js

@@ -0,0 +1,41 @@
+import * as fs from 'fs';
+import * as path from 'path';
+// Dirs we never want in `@file` completion (deps, build output, VCS, caches).
+const IGNORED_DIRS = new Set([
+    'node_modules', '.git', 'dist', 'build', 'out', 'coverage',
+    '.next', '.cache', '.turbo', '.verdaccio', 'tmp',
+]);
+const MAX_FILES = 5000;
+/**
+ * Recursively list project files as relative posix paths, skipping dependency
+ * / build / VCS directories. Pure (no cache): the caller (`prompt-area`) owns
+ * the result in React state and refreshes it on each idle mount and whenever
+ * `@` is entered — so files an agent created during a run show up immediately
+ * on the next prompt, with no restart.
+ */
+export function getFileIndex(root = process.cwd()) {
+    const files = [];
+    const stack = [root];
+    while (stack.length > 0 && files.length < MAX_FILES) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            if (e.isDirectory()) {
+                if (IGNORED_DIRS.has(e.name) || e.name.startsWith('.'))
+                    continue;
+                stack.push(path.join(dir, e.name));
+            }
+            else if (e.isFile()) {
+                files.push(path.relative(root, path.join(dir, e.name)).split(path.sep).join('/'));
+            }
+        }
+    }
+    files.sort();
+    return files;
+}

package/dist/adapters/cli/tui/hooks/use-agent.d.ts

@@ -0,0 +1,54 @@
+/**
+ * use-agent — agent run state for the TUI.
+ *
+ * Drives `Agent.chat(input, signal, approveTool, permissionLevel, onStep)`,
+ * which (in TUI mode) opts into token streaming — the loop emits `text_delta`
+ * steps as tokens arrive. Those accumulate into `streamingText` (rendered live
+ * in the message area, since Ink `<Static>` freezes completed entries); on a
+ * tool call or turn end the accumulated text is committed to the feed history.
+ * ESC/Ctrl+C calls `agent.abort()`.
+ *
+ * `approveTool` runs inside the detached `runAgentLoop` promise, so it must
+ * pause and wait for the user to press y/n in `<PermissionPrompt>`. This hook
+ * owns that bridge: it stores the pending resolver in a ref (stable across
+ * renders) and the pending prompt's view in state (so the component re-renders).
+ */
+import { Agent } from '../../agent.js';
+import type { PermissionLevel, CumulativeUsage } from '../../../../core/types.js';
+import type { Todo } from '../components/goal-status.js';
+import type { FeedApi } from './use-feed.js';
+export interface PendingPermissionView {
+    toolName: string;
+    args: Record<string, unknown>;
+}
+export interface StreamingToolView {
+    name: string;
+    args: Record<string, unknown>;
+    output: string;
+}
+export interface AgentApi {
+    isRunning: boolean;
+    pendingPermission: PendingPermissionView | null;
+    /** Live, accumulating assistant text while streaming (empty when idle). */
+    streamingText: string;
+    /** Live, accumulating tool output while a tool runs (null when idle). */
+    streamingTool: StreamingToolView | null;
+    /** Cumulative token/cost usage across the session (for the footer). */
+    usage: CumulativeUsage;
+    /** Last turn's input size in tokens — the current context-window usage. */
+    contextTokens: number;
+    /** Persistent todo list (updated by manage_todos tool; null when none). */
+    latestTodos: Todo[] | null;
+    submit: (input: string) => Promise<void>;
+    resolvePermission: (approve: boolean) => void;
+    abort: () => void;
+    resetTodos: () => void;
+    /** Restore the persistent todo panel (e.g. from a resumed session). */
+    restoreTodos: (todos: Todo[] | null) => void;
+}
+export interface UseAgentArgs {
+    agent: Agent;
+    feed: FeedApi;
+    permissionLevel?: PermissionLevel;
+}
+export declare function useAgent({ agent, feed, permissionLevel }: UseAgentArgs): AgentApi;