@falkenslab/agent-kit 0.10.2 → 0.13.0

package/dist/tui/chatTui.js

@@ -5,9 +5,14 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { createInputQueue } from "../core/session.js";
 import { runQuery } from "../core/runner.js";
+import { listRuns, readConversation } from "../core/runs.js";
 import { isSharedQuestionActive, setSharedReadline } from "./terminalInteraction.js";
 import * as ui from "./ui.js";
+import { t } from "../core/messages/index.js";
+import { applyLanguage } from "./language.js";
+import { applyTheme } from "./theme.js";
 import { createConsoleRenderer } from "./consoleRenderer.js";
+import { firstRun, openSession, runDate, runFolderOf, runLabel } from "./runs.js";
 // Only strips picocolors' own SGR sequences (`\x1b[<codes>m`) — the only kind this file
 // ever writes to the console — not a general-purpose ANSI stripper for arbitrary escape
 // sequences (cursor movement, OSC, ...) this kit never emits.
@@ -92,16 +97,28 @@ export async function drainTurn(events, onEvent) {
  *   const { options } = await buildSessionOptions(config, runDir, spec);
  *   await runChatTui(options, { welcomeMessage: "Ready. Type /exit to quit." });
  *
+ * or, to keep each run's conversation in its folder and resume it (see `runsDir`):
+ *
+ *   await runChatTui((run) => buildSessionOptions(config, run.dir, spec, { run }), { runsDir });
+ *
  * Resolves once the chat ends (an exit command, Ctrl+C/Ctrl+D at an idle prompt) — this
  * function owns the whole session lifecycle, closing the underlying query and readline
  * interface itself before returning.
  */
 export async function runChatTui(options, tuiOptions = {}) {
+    applyLanguage(tuiOptions.language);
+    applyTheme(tuiOptions.theme);
     const exitCommands = new Set((tuiOptions.exitCommands ?? DEFAULT_EXIT_COMMANDS).map((c) => c.toLowerCase()));
     const promptLabel = tuiOptions.promptLabel ?? DEFAULT_PROMPT_LABEL;
-    const queue = createInputQueue();
-    const run = runQuery(queue.iterable, options);
-    const events = run.events[Symbol.asyncIterator]();
+    const opener = typeof options === "function" ? options : null;
+    const runsDir = opener ? tuiOptions.runsDir : undefined;
+    if (opener && !runsDir)
+        throw new Error("runChatTui(): a session opener needs `runsDir`.");
+    // The session in use: with runs, the run's folder, rebuilt on /resume.
+    let current = opener && runsDir ? await openSession(opener, await firstRun(runsDir)) : { options: options, run: null };
+    let queue = createInputQueue();
+    let run = runQuery(queue.iterable, current.options);
+    let events = run.events[Symbol.asyncIterator]();
     const historyLimit = tuiOptions.historyLimit ?? DEFAULT_HISTORY_LIMIT;
     let historyEntries = tuiOptions.historyPath ? capHistory(await loadHistory(tuiOptions.historyPath), historyLimit) : [];
     const rl = readline.createInterface({
@@ -113,7 +130,14 @@ export async function runChatTui(options, tuiOptions = {}) {
         historySize: historyLimit,
     });
     setSharedReadline(rl);
-    const sessionLog = tuiOptions.sessionLogPath ? createWriteStream(tuiOptions.sessionLogPath, { flags: "a" }) : null;
+    // With runs, the session log is the run's own; it moves with /resume.
+    let sessionLog = null;
+    function openLog() {
+        sessionLog?.end();
+        const file = current.run ? path.join(current.run.dir, "session.log") : tuiOptions.sessionLogPath;
+        sessionLog = file ? createWriteStream(file, { flags: "a" }) : null;
+    }
+    openLog();
     // Mirrors to the log file only — for text already visible on the terminal some other
     // way (readline's own prompt + the human's local echo), so it isn't printed twice.
     function mirror(text) {
@@ -182,7 +206,7 @@ export async function runChatTui(options, tuiOptions = {}) {
             return;
         turnInterrupted = true;
         void run.interrupt();
-        writeLine(ui.warn("(interrupted)"));
+        writeLine(ui.warn(t().interrupted));
     }
     rl.on("SIGINT", () => {
         if (turnInFlight) {
@@ -203,10 +227,48 @@ export async function runChatTui(options, tuiOptions = {}) {
             interruptTurn();
     };
     stdin.on("keypress", onKeypress);
+    /** Prints the run's earlier conversation (when it has one) and says it was resumed. */
+    async function showConversation(folder) {
+        if (!folder.sessionId)
+            return;
+        for (const message of await readConversation(folder.dir)) {
+            // Printed, not logged: the run's session log already has it.
+            stdout.write(message.role === "user" ? `${promptLabel}${message.text}\n` : `\n${tuiOptions.agentLabel ? `${tuiOptions.agentLabel} ` : ""}${message.text}\n`);
+        }
+        const [summary] = (await listRuns(path.dirname(folder.dir))).filter((r) => path.resolve(r.dir) === path.resolve(folder.dir));
+        writeLine(ui.dim(`\n${t().resumed(runDate(summary?.updatedAt ?? new Date()))}`));
+    }
+    /** /resume: lists the runs, asks for one and switches the session to it. */
+    async function resume() {
+        if (!opener || !runsDir)
+            return;
+        const runs = await listRuns(runsDir);
+        if (runs.length === 0) {
+            writeLine(ui.dim(t().noEarlierRuns));
+            return;
+        }
+        writeLine(ui.heading(t().resumeTitle));
+        runs.forEach((summary, i) => writeLine(`  ${i + 1}. ${runLabel(summary, current.run ?? undefined)}`));
+        const answer = (await rl.question(t().resumeQuestion)).trim();
+        const summary = runs[Number(answer) - 1];
+        if (!answer || !summary || (current.run && path.resolve(summary.dir) === path.resolve(current.run.dir)))
+            return;
+        queue.end();
+        run.close();
+        current = await openSession(opener, await runFolderOf(summary));
+        openLog();
+        queue = createInputQueue();
+        run = runQuery(queue.iterable, current.options);
+        events = run.events[Symbol.asyncIterator]();
+        knownCommandTokens = null;
+        await showConversation(current.run);
+    }
     if (tuiOptions.welcomeMessage)
         writeLine(tuiOptions.welcomeMessage);
     try {
-        if (tuiOptions.initialPrompt) {
+        if (current.run)
+            await showConversation(current.run);
+        if (tuiOptions.initialPrompt && !current.run?.sessionId) {
             mirror(`${promptLabel}${tuiOptions.initialPrompt}\n`);
             queue.push(tuiOptions.initialPrompt);
             turnInFlight = true;
@@ -233,6 +295,10 @@ export async function runChatTui(options, tuiOptions = {}) {
             }
             if (exitCommands.has(line.toLowerCase()))
                 break;
+            if (runsDir && line.toLowerCase() === "/resume") {
+                await resume();
+                continue;
+            }
             // A line that *looks* like a slash command but matches nothing registered (a typo,
             // an unnamespaced plugin command, ...) would otherwise reach the model as literal
             // text with no special handling — confirmed empirically (captain-whiskers'
@@ -242,7 +308,7 @@ export async function runChatTui(options, tuiOptions = {}) {
             // silence on unrecognized input might mean.
             const commandToken = slashCommandToken(line);
             if (commandToken && !(await isKnownSlashCommand(commandToken))) {
-                writeLine(ui.warn(`Unknown command: /${commandToken}`));
+                writeLine(ui.warn(t().unknownCommand(commandToken)));
                 continue;
             }
             queue.push(line);

package/dist/tui/claudeAuth.d.ts

@@ -16,4 +16,6 @@ import { type ClaudeAuthConfig } from "../core/claudeAuth.js";
  * Only makes sense with a real terminal in front of a human (a `runWizard()` confirm, colored console
  * output), which is why it lives here rather than in the non-interactive core.
  */
-export declare function ensureClaudeAuth(config?: ClaudeAuthConfig): Promise<string | undefined>;
+export declare function ensureClaudeAuth(config?: ClaudeAuthConfig, options?: {
+    language?: string;
+}): Promise<string | undefined>;

package/dist/tui/claudeAuth.js

@@ -3,6 +3,8 @@ import { resolveClaudeAuth } from "../core/claudeAuth.js";
 import { isExitPromptError } from "./promptErrors.js";
 import * as ui from "./ui.js";
 import { runWizard } from "./ink/wizard.js";
+import { applyLanguage } from "./language.js";
+import { t } from "../core/messages/index.js";
 // The real format of "claude setup-token" tokens ("sk-ant-oat01-...", seen in the
 // installed @anthropic-ai/claude-code binary) — used to extract the token from its output.
 const TOKEN_PATTERN = /sk-ant-oat\d{2}-[A-Za-z0-9_-]+/;
@@ -61,23 +63,17 @@ function runSetupToken() {
  * Only makes sense with a real terminal in front of a human (a `runWizard()` confirm, colored console
  * output), which is why it lives here rather than in the non-interactive core.
  */
-export async function ensureClaudeAuth(config = {}) {
+export async function ensureClaudeAuth(config = {}, options = {}) {
     if (resolveClaudeAuth(config))
         return undefined;
-    console.log(ui.warn("\nNo Claude authentication token was found"));
-    console.log(ui.dim("(neither the CLAUDE_CODE_OAUTH_TOKEN environment variable, nor one passed in)."));
+    applyLanguage(options.language);
+    const texts = t().auth;
+    console.log(ui.warn(`\n${texts.noToken}`));
+    console.log(ui.dim(texts.noTokenDetail));
     try {
-        const { generate } = await runWizard([
-            {
-                type: "confirm",
-                name: "generate",
-                message: 'Generate one now with "claude setup-token" (requires a Claude Pro/Max subscription)?',
-                default: true,
-            },
-        ]);
+        const { generate } = await runWizard([{ type: "confirm", name: "generate", message: texts.generateQuestion, default: true }]);
         if (!generate) {
-            console.log(ui.error("\nThe agent can't start without a token. Set CLAUDE_CODE_OAUTH_TOKEN by hand " +
-                "(or run this again and accept generating it) and try again."));
+            console.log(ui.error(`\n${texts.cantStart}`));
             process.exit(0);
         }
     }
@@ -86,11 +82,10 @@ export async function ensureClaudeAuth(config = {}) {
             process.exit(0);
         throw error;
     }
-    console.log(ui.heading("\n=== Generating a Claude authentication token ==="));
-    console.log(ui.dim("A browser will open to log in; follow the instructions the command itself prints " +
-        "below.\n"));
+    console.log(ui.heading(`\n${texts.generatingHeading}`));
+    console.log(ui.dim(`${texts.browserWillOpen}\n`));
     const token = await runSetupToken();
     process.env.CLAUDE_CODE_OAUTH_TOKEN = token;
-    console.log(ui.success("\nToken generated for this run. Save it yourself (e.g. CLAUDE_CODE_OAUTH_TOKEN in your shell profile) to skip this next time.\n"));
+    console.log(ui.success(`\n${texts.generated}\n`));
     return token;
 }

package/dist/tui/consoleRenderer.d.ts

@@ -1,4 +1,5 @@
 import type { AgentEvent } from "../core/runner.js";
+/** Options of `createConsoleRenderer()`. */
 export interface ConsoleRendererOptions {
     /** Turns a tool call into its console label; defaults to `createFriendlyToolLabel()`. */
     formatAction?: (toolName: string, toolInput: unknown) => string;
@@ -9,6 +10,7 @@ export interface ConsoleRendererOptions {
     /** Called after every write with the same text, e.g. to mirror it into a log file. */
     onWrite?: (text: string) => void;
 }
+/** Prints `runQuery()`'s events as plain console lines (see `createConsoleRenderer()`). */
 export interface ConsoleRenderer {
     /** Prints one normalized event from `runQuery()`. */
     render(event: AgentEvent): void;

package/dist/tui/consoleRenderer.js

@@ -1,6 +1,7 @@
 import { stdout } from "node:process";
 import { createFriendlyToolLabel } from "../core/toolLabels.js";
 import * as ui from "./ui.js";
+import { t } from "../core/messages/index.js";
 /**
  * The console rendering of `runQuery()`'s event stream, shared by `runChatTui()` and by any
  * one-shot run that prints the same events. Streamed text rarely ends in a newline, so
@@ -46,7 +47,7 @@ export function createConsoleRenderer(options = {}) {
             case "prompt-suggestion":
                 return;
             case "mcp-error":
-                writeLine(ui.warn(`Some MCP servers failed to connect: ${event.failedServers.join(", ")}`));
+                writeLine(ui.warn(t().mcpFailed(event.failedServers.join(", "))));
                 return;
             case "info":
                 writeLine((event.level === "warning" ? ui.warn : ui.dim)(`(${event.text})`));

package/dist/tui/ink/PromptInput.d.ts

@@ -27,8 +27,6 @@ export interface PromptInputProps {
     /** Project files for `@` mentions (paths relative to the session's folder). */
     files?: readonly string[];
 }
-/** The shortcuts panel, opened with "?" on an empty prompt. */
-export declare const SHORTCUTS: string[];
 /**
  * The chat's prompt: history (↑/↓), "/command" completion and suggestions (Tab), pasted
  * blocks folded into a token, multi-line input (`\` + Enter or Ctrl+J), word and line

package/dist/tui/ink/PromptInput.js

@@ -8,8 +8,9 @@ import { isMouseReport } from "./fullscreen.js";
 import { CursorContext } from "./terminalCursor.js";
 import { isFocusReport } from "./terminalStatus.js";
 import { matchingFiles, mentionAt } from "./fileMentions.js";
-import { continueLine, createPasteRegistry, cursorLine, deleteBack, deleteForward, deleteWordBack, insert, isBlockPaste, isForwardDelete, killToLineEnd, moveLine, normalizePaste, searchHistory, toLineEnd, toLineStart, wordLeft, wordRight, } from "./promptEditing.js";
+import { continueLine, createPasteRegistry, cursorLine, deleteBack, deleteForward, deleteWordBack, insert, isBlockPaste, isForwardDelete, killToLineEnd, moveLine, normalizePaste, PASTE_TOKEN_AFTER, PASTE_TOKEN_BEFORE, searchHistory, toLineEnd, toLineStart, wordLeft, wordRight, } from "./promptEditing.js";
 import * as ui from "../ui.js";
+import { t } from "../../core/messages/index.js";
 const MAX_SUGGESTIONS = 6;
 /** Commands (names without "/") a partial "/name" line could still become. */
 export function matchingCommands(value, commands) {
@@ -44,19 +45,8 @@ export function visibleWindow(length, cursor, room) {
     const start = Math.min(Math.max(0, cursor + 1 - span), Math.max(0, length + 1 - span));
     return [start, Math.min(length, start + span)];
 }
-/** The shortcuts panel, opened with "?" on an empty prompt. */
-export const SHORTCUTS = [
-    "Enter send  ·  \\ + Enter or Ctrl+J new line  ·  Tab complete or take the suggestion",
-    "↑/↓ history  ·  Ctrl+R search history  ·  ↑ on an empty prompt edits the last queued message",
-    "Ctrl+W delete word  ·  Ctrl+K to line end  ·  Ctrl+U clear  ·  Ctrl+←/→ move by word",
-    "@ mention a file  ·  /copy copy the last reply  ·  Shift+Tab switch mode  ·  Ctrl+O unfold tool calls",
-    "Esc interrupt  ·  Ctrl+C interrupt or exit  ·  PgUp/PgDn or wheel scroll  ·  Ctrl+End bottom",
-    "Drag to select, right-click to copy (full screen)",
-];
 // A paste can reach us in several chunks; pieces this close together extend the same one.
 const PASTE_CHUNK_MS = 100;
-const PASTE_TOKEN_BEFORE = /\[Pasted text #\d+ \+\d+ lines?\]$/;
-const PASTE_TOKEN_AFTER = /^\[Pasted text #\d+ \+\d+ lines?\]/;
 /**
  * The chat's prompt: history (↑/↓), "/command" completion and suggestions (Tab), pasted
  * blocks folded into a token, multi-line input (`\` + Enter or Ctrl+J), word and line
@@ -310,7 +300,7 @@ export function PromptInput({ label, inset = 0, suggestion, history, commands, o
     const width = liveWidth(stdout.columns) - inset;
     const labelWidth = stringWidth(stripAnsi(label));
     const room = width - labelWidth;
-    const ghost = suggestion ? `${suggestion}  (tab)` : null;
+    const ghost = suggestion ? `${suggestion}  (${t().suggestionKey})` : null;
     // Suggestions give way on a short terminal: the live area must stay shorter than it.
     const maxSuggestions = Math.min(MAX_SUGGESTIONS, Math.max(0, (stdout.rows || 24) - 10));
     const mention = mentionAt(value, cursor);
@@ -326,7 +316,7 @@ export function PromptInput({ label, inset = 0, suggestion, history, commands, o
     let rows;
     let cursorColumn;
     if (search) {
-        const prefix = `(reverse-i-search)'${search.query}': `;
+        const prefix = t().reverseSearch(search.query);
         const match = search.index >= 0 ? history[search.index] : "";
         cursorColumn = Math.min(stringWidth(prefix) - 3, width - 1);
         rows = [
@@ -352,5 +342,5 @@ export function PromptInput({ label, inset = 0, suggestion, history, commands, o
             cursorController.setTarget({ node: cursorLineRef.current, column: cursorColumn });
     });
     useLayoutEffect(() => () => cursorController?.setTarget(null), [cursorController]);
-    return (_jsxs(Box, { flexDirection: "column", children: [rows, suggestions.map((item) => (_jsx(Text, { children: ui.dim(fitWidth(`  ${item}`, width)) }, item))), showHelp ? SHORTCUTS.map((line) => _jsx(Text, { children: ui.dim(fitWidth(`  ${line}`, width)) }, line)) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [rows, suggestions.map((item) => (_jsx(Text, { children: ui.dim(fitWidth(`  ${item}`, width)) }, item))), showHelp ? t().shortcuts.map((line) => _jsx(Text, { children: ui.dim(fitWidth(`  ${line}`, width)) }, line)) : null] }));
 }

package/dist/tui/ink/SessionView.js

@@ -8,15 +8,16 @@ import { framePosition } from "./terminalCursor.js";
 import { isFocusReport } from "./terminalStatus.js";
 import { fitWidth, stripAnsi } from "./lineBuffer.js";
 import * as ui from "../ui.js";
+import { t } from "../../core/messages/index.js";
+import { inkColor } from "../theme.js";
 // Numbered as in the Claude Code CLI's permission prompt; the digits and y/n/q answer too.
-const DECISION_OPTIONS = [
-    { label: "1. Yes", value: "y" },
-    { label: "2. No", value: "n" },
-    { label: "3. Stop", value: "q" },
+const decisionOptions = () => [
+    { label: `1. ${t().yes}`, value: "y" },
+    { label: `2. ${t().no}`, value: "n" },
+    { label: `3. ${t().stop}`, value: "q" },
 ];
-const MANUAL_OPTIONS = [{ label: "1. Done, continue", value: "continue" }];
+const manualOptions = () => [{ label: `1. ${t().doneContinue}`, value: "continue" }];
 const DECISION_KEYS = { "1": "y", "2": "n", "3": "q", y: "y", n: "n", q: "q" };
-const ACCENT_HEX = "#d77757";
 /**
  * The preview's lines, capped so the whole live area stays shorter than the terminal: Ink
  * clears the entire screen (scrollback included) to redraw anything taller, and a step-gate
@@ -25,7 +26,7 @@ const ACCENT_HEX = "#d77757";
 export function previewLines(lines, terminalRows) {
     const all = lines.flatMap((line) => line.split("\n"));
     const max = Math.max(3, (terminalRows || 24) - 12);
-    return all.length <= max ? all : [...all.slice(0, max - 1), ui.dim(`… (${all.length - max + 1} more lines)`)];
+    return all.length <= max ? all : [...all.slice(0, max - 1), ui.dim(t().moreLines(all.length - max + 1))];
 }
 function CheckpointPanel({ checkpoint, renderApproval }) {
     const decision = checkpoint.kind === "decision";
@@ -38,17 +39,17 @@ function CheckpointPanel({ checkpoint, renderApproval }) {
     });
     const { prompt } = checkpoint;
     const { stdout } = useStdout();
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: ACCENT_HEX, paddingX: 1, children: [renderApproval ? (renderApproval(prompt)) : (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: prompt.title }), previewLines(prompt.lines, stdout.rows).map((line, index) => (_jsx(Text, { children: line }, index))), !decision && prompt.question ? _jsx(Text, { dimColor: true, children: prompt.question }) : null] })), decision ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { children: "Do you want to proceed?" }) })) : null, _jsx(Box, { marginTop: decision ? 0 : 1, children: _jsx(Select, { options: decision ? DECISION_OPTIONS : MANUAL_OPTIONS, onChange: (value) => checkpoint.answer(decision ? value : "") }, checkpoint.id) })] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: inkColor("accent"), paddingX: 1, children: [renderApproval ? (renderApproval(prompt)) : (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: prompt.title }), previewLines(prompt.lines, stdout.rows).map((line, index) => (_jsx(Text, { children: line }, index))), !decision && prompt.question ? _jsx(Text, { dimColor: true, children: prompt.question }) : null] })), decision ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { children: t().proceed }) })) : null, _jsx(Box, { marginTop: decision ? 0 : 1, children: _jsx(Select, { options: decision ? decisionOptions() : manualOptions(), onChange: (value) => checkpoint.answer(decision ? value : "") }, checkpoint.id) })] }));
 }
 function formatTokens(count) {
     return count >= 1000 ? `${(count / 1000).toFixed(1)}k` : String(count);
 }
 export function statusText(mode, turns, usage, extra = {}) {
     const parts = [
-        ...(mode ? [`⏵⏵ ${mode}${extra.modeSwitchable ? " (shift+tab)" : ""}`] : []),
-        `${turns} ${turns === 1 ? "turn" : "turns"}`,
-        ...(usage ? [`${formatTokens(usage.inputTokens)} in / ${formatTokens(usage.outputTokens)} out`] : []),
-        ...(extra.contextPercent != null ? [`context ${Math.round(extra.contextPercent)}%`] : []),
+        ...(mode ? [`⏵⏵ ${t().mode(mode)}${extra.modeSwitchable ? ` (${t().switchModeKey})` : ""}`] : []),
+        t().turns(turns),
+        ...(usage ? [t().tokens(formatTokens(usage.inputTokens), formatTokens(usage.outputTokens))] : []),
+        ...(extra.contextPercent != null ? [t().context(Math.round(extra.contextPercent))] : []),
     ];
     return parts.join(" · ");
 }
@@ -63,7 +64,7 @@ function Working({ label, startedAt, width }) {
     }, []);
     const seconds = startedAt === null ? 0 : Math.floor((Date.now() - startedAt) / 1000);
     const glyph = WORKING_GLYPHS[tick % WORKING_GLYPHS.length];
-    return _jsx(Text, { children: fitWidth(`${ui.working(`${glyph} ${label}`)} ${ui.dim(`(${seconds}s · esc to interrupt)`)}`, width) });
+    return _jsx(Text, { children: fitWidth(`${ui.working(`${glyph} ${label}`)} ${ui.dim(`(${seconds}s · ${t().escToInterrupt})`)}`, width) });
 }
 /** Line in progress, checkpoint panel or spinner, the input, and the status bar. */
 function LiveArea({ session, checkpoint, renderApproval, mode, width, statusExtra, modeSwitchable, children }) {
@@ -74,7 +75,7 @@ function LiveArea({ session, checkpoint, renderApproval, mode, width, statusExtr
     return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, width: width, marginTop: session.liveGap ? 1 : 0, children: [stripAnsi(session.live) ? _jsx(Text, { children: session.live }) : null, checkpoint ? (_jsx(CheckpointPanel, { checkpoint: checkpoint, renderApproval: renderApproval })) : session.busy ? (
             // Always one blank line above the spinner: from this margin, or from the live area's
             // own when a separator is pending and nothing is written above the spinner yet.
-            _jsxs(Box, { flexDirection: "column", marginTop: stripAnsi(session.live) || !session.liveGap ? 1 : 0, children: [_jsx(Working, { label: session.activity ?? "Thinking…", startedAt: session.turnStartedAt, width: width }), session.subagentActivity ? _jsx(Text, { dimColor: true, children: fitWidth(`  ↳ ${session.subagentActivity}`, width) }) : null] })) : null, checkpoint ? null : children, _jsx(Text, { children: fitWidth(status, width) })] }));
+            _jsxs(Box, { flexDirection: "column", marginTop: stripAnsi(session.live) || !session.liveGap ? 1 : 0, children: [_jsx(Working, { label: session.activity ?? t().thinking, startedAt: session.turnStartedAt, width: width }), session.subagentActivity ? _jsx(Text, { dimColor: true, children: fitWidth(`  ↳ ${session.subagentActivity}`, width) }) : null] })) : null, checkpoint ? null : children, _jsx(Text, { children: fitWidth(status, width) })] }));
 }
 /** A history line for the inline view: the human's line as a bar, a tool group unfolded with Ctrl+O. */
 function inlineItem(item, expanded, width) {
@@ -184,7 +185,7 @@ function FullscreenSession({ session, checkpoint, renderApproval, mode, header,
                 setSelection(null);
                 if (text && onCopy) {
                     onCopy(text);
-                    setCopied(`copied ${text.length} ${text.length === 1 ? "character" : "characters"}`);
+                    setCopied(t().copiedCharacters(text.length));
                 }
             }
         }
@@ -205,7 +206,7 @@ function FullscreenSession({ session, checkpoint, renderApproval, mode, header,
             setAnchor(null); // typing
     });
     const below = rowsBelow(anchor, total);
-    const statusExtra = [anchor === null ? null : `↓ ${below} more ${below === 1 ? "line" : "lines"} (Ctrl+End)`, copied]
+    const statusExtra = [anchor === null ? null : t().linesBelow(below), copied]
         .filter(Boolean)
         .join(" · ");
     return (_jsxs(Box, { flexDirection: "column", width: columns - 1, height: rows, children: [header && header.length > 0 ? (_jsx(Box, { flexDirection: "column", flexShrink: 0, marginBottom: 1, children: header.map((line, i) => (_jsx(Text, { wrap: "truncate-end", children: line || " " }, i))) })) : null, _jsx(Box, { ref: historyRef, flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", justifyContent: "flex-end", children: wrapped.rows.slice(start, end).map((row, i) => (_jsx(Text, { wrap: "truncate-end", children: highlightRow(row, selection, start + i) || " " }, start + i))) }), _jsx(LiveArea, { session: session, checkpoint: checkpoint, renderApproval: renderApproval, mode: mode, width: width, statusExtra: statusExtra || undefined, modeSwitchable: modeSwitchable, children: children })] }));

package/dist/tui/ink/header.d.ts

@@ -1,3 +1,4 @@
+/** The top of the Ink chat: a title, optional fields and an optional logo. */
 export interface HeaderInfo {
     title: string;
     /** Shown under the title as "name value" pairs, e.g. the workspace or the model. */

package/dist/tui/ink/inkInteraction.js

@@ -1,9 +1,6 @@
 import * as ui from "../ui.js";
-const OUTCOMES = {
-    y: ui.success("✔ Approved"),
-    n: ui.warn("✘ Rejected"),
-    q: ui.error("■ Stopped"),
-};
+import { t } from "../../core/messages/index.js";
+const outcome = (answer) => ({ y: ui.success(t().approved), n: ui.warn(t().rejected), q: ui.error(t().stopped) })[answer];
 /**
  * An `InteractionPort` for the Ink views: each checkpoint waits in a queue (the step gate
  * can fire for several tool calls at once) until the panel answers it, or until the
@@ -37,13 +34,13 @@ export function createInkInteraction(note) {
                 answer(value) {
                     if (!remove(checkpoint))
                         return;
-                    record(prompt, kind === "decision" ? (OUTCOMES[value] ?? value) : ui.success("✔ Done"));
+                    record(prompt, kind === "decision" ? (outcome(value) ?? value) : ui.success(t().done));
                     resolve(value);
                 },
             };
             signal.addEventListener("abort", () => {
                 if (remove(checkpoint))
-                    record(prompt, ui.dim("(answered through the response file)"));
+                    record(prompt, ui.dim(t().answeredByFile));
             }, { once: true });
             queue = [...queue, checkpoint];
             emit();

package/dist/tui/ink/inkTheme.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from "react";
+/**
+ * `@inkjs/ui`'s components in the kit's theme: the focused option of a `Select` (and its
+ * `❯`) in the theme's `selection` color and bold, instead of the library's blue, which on
+ * most dark terminals is a navy that barely shows.
+ */
+export declare function KitTheme({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/tui/ink/inkTheme.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { defaultTheme, extendTheme, ThemeProvider } from "@inkjs/ui";
+import { inkColor } from "../theme.js";
+/**
+ * `@inkjs/ui`'s components in the kit's theme: the focused option of a `Select` (and its
+ * `❯`) in the theme's `selection` color and bold, instead of the library's blue, which on
+ * most dark terminals is a navy that barely shows.
+ */
+export function KitTheme({ children }) {
+    const selection = inkColor("selection");
+    const theme = extendTheme(defaultTheme, {
+        components: {
+            Select: {
+                styles: {
+                    focusIndicator: () => ({ color: selection }),
+                    label: ({ isFocused, isSelected }) => ({
+                        color: isFocused ? selection : isSelected ? "green" : undefined,
+                        bold: isFocused,
+                    }),
+                },
+            },
+        },
+    });
+    return _jsx(ThemeProvider, { theme: theme, children: children });
+}

package/dist/tui/ink/markdown.js

@@ -79,16 +79,57 @@ function renderList(list, width) {
     });
     return lines;
 }
+const visibleWidth = (text) => stringWidth(stripAnsi(text));
+/**
+ * The widest columns shrunk, one column at a time, until the grid (`widths` plus one border
+ * and two spaces of padding per column, plus the last border) fits `room`; a column never
+ * goes below 3.
+ */
+function fitColumns(widths, room) {
+    const fitted = [...widths];
+    const total = () => fitted.reduce((sum, w) => sum + w, 0) + fitted.length * 3 + 1;
+    while (total() > room) {
+        const widest = fitted.indexOf(Math.max(...fitted));
+        if (fitted[widest] <= 3)
+            break;
+        fitted[widest]--;
+    }
+    return fitted;
+}
+/**
+ * A table as a grid: dimmed box-drawing borders, one space of padding, the header in bold,
+ * a rule between rows and each column aligned as its markdown says. A table wider than the
+ * room shrinks its widest columns and wraps their cells onto more lines.
+ */
 function renderTable(table, width) {
     const cell = (c) => inline(c.tokens, c.text);
-    const header = table.header.map(cell);
-    const rows = table.rows.map((row) => row.map(cell));
-    const widths = header.map((h, i) => Math.max(stringWidth(stripAnsi(h)), ...rows.map((row) => stringWidth(stripAnsi(row[i] ?? "")))));
-    const pad = (text, i) => text + " ".repeat(Math.max(0, widths[i] - stringWidth(stripAnsi(text))));
-    const line = (cells) => cells.map(pad).join("  ").trimEnd();
-    const out = [ui.bold(line(header)), ui.dim(widths.map((w) => "─".repeat(w)).join("  ")), ...rows.map(line)];
-    // A table wider than the room is cut, not wrapped: wrapping would scramble the columns.
-    return out.map((row) => (stringWidth(stripAnsi(row)) > width ? wrapAnsi(row, width, { hard: true, wordWrap: false }).split("\n")[0] : row));
+    const header = table.header.map((c) => ui.bold(cell(c)));
+    const rows = table.rows.map((row) => table.header.map((_, i) => (row[i] ? cell(row[i]) : "")));
+    const natural = header.map((h, i) => Math.max(1, visibleWidth(h), ...rows.map((row) => visibleWidth(row[i]))));
+    const widths = fitColumns(natural, width);
+    const place = (text, i) => {
+        const room = widths[i] - visibleWidth(text);
+        if (room <= 0)
+            return text;
+        if (table.align[i] === "right")
+            return " ".repeat(room) + text;
+        if (table.align[i] === "center")
+            return " ".repeat(Math.floor(room / 2)) + text + " ".repeat(Math.ceil(room / 2));
+        return text + " ".repeat(room);
+    };
+    const border = (left, middle, right) => ui.dim(left + widths.map((w) => "─".repeat(w + 2)).join(middle) + right);
+    const bar = ui.dim("│");
+    // A row's cells wrapped to their columns: as many lines as its tallest cell.
+    const rowLines = (cells) => {
+        const wrapped = cells.map((text, i) => wrapAnsi(text, widths[i], { hard: true, trim: true }).split("\n"));
+        const height = Math.max(...wrapped.map((lines) => lines.length));
+        return Array.from({ length: height }, (_, line) => `${bar}${wrapped.map((lines, i) => ` ${place(lines[line] ?? "", i)} `).join(bar)}${bar}`);
+    };
+    const lines = [border("┌", "┬", "┐"), ...rowLines(header)];
+    for (const row of rows)
+        lines.push(border("├", "┼", "┤"), ...rowLines(row));
+    lines.push(border("└", "┴", "┘"));
+    return lines;
 }
 /** Inline tokens (bold, italic, code, links...) as styled text. */
 function inline(tokens, fallback) {

package/dist/tui/ink/progressView.d.ts

@@ -2,6 +2,8 @@ import type { Mode } from "../../core/agentSpec.js";
 import { type ConsoleRenderer, type ConsoleRendererOptions } from "../consoleRenderer.js";
 import { type RenderApproval } from "./SessionView.js";
 import type { ToolPhrase } from "./toolGroup.js";
+import { type Theme } from "../theme.js";
+/** Options of `createProgressView()`. */
 export interface ProgressViewOptions extends Omit<ConsoleRendererOptions, "output"> {
     /** How one of the agent's own tools counts in a folded group's summary (see `InkChatOptions.toolPhrase`). */
     toolPhrase?: (toolName: string) => ToolPhrase | undefined;
@@ -11,7 +13,20 @@ export interface ProgressViewOptions extends Omit<ConsoleRendererOptions, "outpu
     mode?: Mode;
     /** Use the plain console renderer even on a TTY. */
     plain?: boolean;
+    /**
+     * Colors for the kit's roles (see `Theme`), on top of the kit's defaults: only the roles
+     * given change, e.g. `{ toolResult: "yellow", selection: "#00ff00" }`. One theme per
+     * process: without this option, the one already set stays.
+     */
+    theme?: Partial<Theme>;
+    /**
+     * The language of the kit's texts ("en", "es", "fr", "de"). `--language=<code>` on the
+     * command line wins; without either, the one `buildSessionOptions()` chose from
+     * `config.language`, or else the system's.
+     */
+    language?: string;
 }
+/** A one-shot run's live view: a console renderer drawn with Ink, plus `close()`. */
 export interface ProgressView extends ConsoleRenderer {
     /** Removes the live area and restores the previous interaction port; await it before printing anything else. */
     close(): Promise<void>;

package/dist/tui/ink/progressView.js

@@ -7,6 +7,9 @@ import { createConsoleRenderer } from "../consoleRenderer.js";
 import { createInkInteraction } from "./inkInteraction.js";
 import { createSessionModel, liveWidth } from "./sessionModel.js";
 import { SessionView } from "./SessionView.js";
+import { applyLanguage } from "../language.js";
+import { applyTheme } from "../theme.js";
+import { KitTheme } from "./inkTheme.js";
 function ProgressApp({ model, interaction, renderApproval, mode, closed }) {
     const checkpoint = useSyncExternalStore(interaction.subscribe, interaction.getSnapshot);
     // Only a panel reads the keyboard (and so puts stdin in raw mode, where Ctrl+C no longer
@@ -29,6 +32,8 @@ function ProgressApp({ model, interaction, renderApproval, mode, closed }) {
  * Without a TTY or with `plain`, it is `createConsoleRenderer()` with a no-op `close()`.
  */
 export function createProgressView(options = {}) {
+    applyLanguage(options.language);
+    applyTheme(options.theme);
     if (options.plain || !stdin.isTTY || !stdout.isTTY) {
         const renderer = createConsoleRenderer(options);
         return Object.assign(renderer, { close: async () => { } });
@@ -37,7 +42,7 @@ export function createProgressView(options = {}) {
     const interaction = createInkInteraction((text) => model.note(text));
     const previousPort = getInteractionPort();
     setInteractionPort(interaction.port);
-    const app = (closed) => (_jsx(ProgressApp, { model: model, interaction: interaction, renderApproval: options.renderApproval, mode: options.mode, closed: closed }));
+    const app = (closed) => (_jsx(KitTheme, { children: _jsx(ProgressApp, { model: model, interaction: interaction, renderApproval: options.renderApproval, mode: options.mode, closed: closed }) }));
     const instance = render(app(false), { exitOnCtrlC: false });
     model.startTurn();
     let closing = null;

package/dist/tui/ink/promptEditing.d.ts

@@ -1,8 +1,3 @@
-/**
- * Pure editing operations on the prompt's text and cursor (a UTF-16 index into `value`),
- * so PromptInput.tsx only maps keys to them. The value may hold line breaks ("\n"): a
- * multi-line prompt.
- */
 export interface EditState {
     value: string;
     cursor: number;
@@ -51,6 +46,8 @@ export interface PasteRegistry {
     /** `value` with every token replaced by its text. */
     expand(value: string): string;
 }
+export declare const PASTE_TOKEN_BEFORE: RegExp;
+export declare const PASTE_TOKEN_AFTER: RegExp;
 /** Normalizes a pasted chunk's line breaks (terminals send "\r" or "\r\n"). */
 export declare function normalizePaste(text: string): string;
 /** A paste worth folding into a token: more than one line. */