@falkenslab/agent-kit 0.10.2 → 0.13.0

package/dist/tui/ink/promptEditing.js

@@ -1,3 +1,9 @@
+/**
+ * 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.
+ */
+import { t } from "../../core/messages/index.js";
 export function insert({ value, cursor }, text) {
     return { value: value.slice(0, cursor) + text + value.slice(cursor), cursor: cursor + text.length };
 }
@@ -91,10 +97,12 @@ export function continueLine(state) {
         return null;
     return insert(deleteBack(state), "\n");
 }
-const PASTE_TOKEN = /\[Pasted text #(\d+) \+\d+ lines?\]/g;
+// A paste token in any language ("[Pasted text #1 +2 lines]", "[Texto pegado #1 +2 líneas]"...).
+const PASTE_TOKEN = /\[[^\]\n#]+#(\d+) \+\d+ [^\]\n]+\]/g;
+export const PASTE_TOKEN_BEFORE = /\[[^\]\n#]+#\d+ \+\d+ [^\]\n]+\]$/;
+export const PASTE_TOKEN_AFTER = /^\[[^\]\n#]+#\d+ \+\d+ [^\]\n]+\]/;
 function pasteToken(id, text) {
-    const extra = text.split("\n").length - 1;
-    return `[Pasted text #${id} +${extra} ${extra === 1 ? "line" : "lines"}]`;
+    return t().pastedText(id, text.split("\n").length - 1);
 }
 /** Normalizes a pasted chunk's line breaks (terminals send "\r" or "\r\n"). */
 export function normalizePaste(text) {

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

@@ -2,10 +2,12 @@ import type { Options } from "@anthropic-ai/claude-agent-sdk";
 import type { Mode } from "../../core/agentSpec.js";
 import { type ModeControl } from "../../core/session.js";
 import { type ChatTuiOptions } from "../chatTui.js";
+import { type SessionOpener } from "../runs.js";
 import { type RenderApproval } from "./SessionView.js";
 import type { ToolPhrase } from "./toolGroup.js";
 import { type HeaderInfo } from "./header.js";
 export type { HeaderInfo } from "./header.js";
+/** Options of `runChatInk()`: the chat's options plus the Ink-only ones. */
 export interface InkChatOptions extends ChatTuiOptions {
     /**
      * Title, fields and an optional logo for the top of the chat: fixed at the top in full
@@ -46,7 +48,8 @@ export interface InkChatOptions extends ChatTuiOptions {
     /**
      * The session's mode control (`buildSessionOptions()` returns it): the status bar shows the
      * current mode, and Shift+Tab switches between the modes it allows ("guided" and
-     * "interactive"; an autonomous session can't switch).
+     * "interactive"; an autonomous session can't switch). With a session opener, the one it
+     * returns is used instead.
      */
     modeControl?: ModeControl;
     /**
@@ -55,6 +58,16 @@ export interface InkChatOptions extends ChatTuiOptions {
      */
     firstPromptSuggestion?: string;
 }
+/** A choice asked in place of the prompt (the /resume list). */
+export interface ChatPicker {
+    title: string;
+    options: {
+        label: string;
+        value: string;
+    }[];
+    /** Settles it with the chosen value, or null if cancelled. */
+    resolve(value: string | null): void;
+}
 export interface ChatInputSnapshot {
     /** The chat loop is waiting for a line (no turn in flight). */
     prompting: boolean;
@@ -68,6 +81,8 @@ export interface ChatInputSnapshot {
     files: string[];
     /** The current mode, when a mode control is given. */
     mode: Mode | null;
+    /** A choice shown in place of the prompt, if any. */
+    picker: ChatPicker | null;
     closed: boolean;
 }
 /**
@@ -85,6 +100,11 @@ export declare function createChatInput(): {
     setSuggestion: (suggestion: string | null) => void;
     setFiles: (files: string[]) => void;
     setMode: (mode: Mode | null) => void;
+    /** Shows a choice in place of the prompt; resolves with the value chosen, or null if cancelled. */
+    pick(title: string, options: {
+        label: string;
+        value: string;
+    }[]): Promise<string | null>;
     /** Takes the last queued line back out of the queue (to edit it in the prompt), or null. */
     unqueueLast(): string | null;
     close: () => void;
@@ -98,6 +118,10 @@ export declare function createChatInput(): {
  *
  * With `fullscreen` it takes the whole terminal instead (see `InkChatOptions.fullscreen`).
  *
+ * Given a session opener instead of options, and `runsDir`, each run keeps its conversation
+ * in its own folder and can be resumed: `--continue` on the command line starts with the
+ * latest, and `/resume` picks one (see `ChatTuiOptions.runsDir`).
+ *
  * Without a TTY (piped, background) or with `plain`, it is `runChatTui()` unchanged.
  */
-export declare function runChatInk(options: Options, tuiOptions?: InkChatOptions): Promise<void>;
+export declare function runChatInk(options: Options | SessionOpener, tuiOptions?: InkChatOptions): Promise<void>;

package/dist/tui/ink/runChatInk.js

@@ -1,18 +1,26 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { createWriteStream } from "node:fs";
+import path from "node:path";
 import { stdin, stdout } from "node:process";
 import { useSyncExternalStore } from "react";
 import { Box, render, Text, useInput } from "ink";
+import { Select } from "@inkjs/ui";
 import { getInteractionPort, setInteractionPort } from "../../core/interaction.js";
 import { createInputQueue } from "../../core/session.js";
 import { runQuery } from "../../core/runner.js";
+import { listRuns, readConversation } from "../../core/runs.js";
 import { capHistory, loadHistory, runChatTui, saveHistory, slashCommandToken } from "../chatTui.js";
 import * as ui from "../ui.js";
+import { t } from "../../core/messages/index.js";
+import { applyLanguage } from "../language.js";
+import { applyTheme, inkColor } from "../theme.js";
+import { KitTheme } from "./inkTheme.js";
+import { firstRun, openSession, runDate, runFolderOf, runLabel } from "../runs.js";
 import { createInkInteraction } from "./inkInteraction.js";
 import { PromptInput } from "./PromptInput.js";
 import { createSessionModel, liveWidth } from "./sessionModel.js";
 import { SessionView } from "./SessionView.js";
-import { stripAnsi } from "./lineBuffer.js";
+import { fitWidth, stripAnsi } from "./lineBuffer.js";
 import { clipboardSequence, enterFullscreen } from "./fullscreen.js";
 import { createCursorController, CursorContext } from "./terminalCursor.js";
 import { createTerminalStatus, focusFromReport } from "./terminalStatus.js";
@@ -30,7 +38,7 @@ const PROMPT_FRAME_COLUMNS = 4;
  */
 export function createChatInput() {
     const listeners = new Set();
-    let snapshot = { prompting: false, history: [], commands: [], queued: [], suggestion: null, files: [], mode: null, closed: false };
+    let snapshot = { prompting: false, history: [], commands: [], queued: [], suggestion: null, files: [], mode: null, picker: null, closed: false };
     let pending = null;
     let exited = false;
     function update(changes) {
@@ -74,6 +82,21 @@ export function createChatInput() {
         setSuggestion: (suggestion) => update({ suggestion }),
         setFiles: (files) => update({ files }),
         setMode: (mode) => update({ mode }),
+        /** Shows a choice in place of the prompt; resolves with the value chosen, or null if cancelled. */
+        pick(title, options) {
+            return new Promise((resolve) => {
+                update({
+                    picker: {
+                        title,
+                        options,
+                        resolve(value) {
+                            update({ picker: null });
+                            resolve(value);
+                        },
+                    },
+                });
+            });
+        },
         /** Takes the last queued line back out of the queue (to edit it in the prompt), or null. */
         unqueueLast() {
             const last = snapshot.queued.at(-1);
@@ -85,10 +108,21 @@ export function createChatInput() {
         close: () => update({ prompting: false, closed: true }),
     };
 }
-function ChatApp({ model, interaction, input, promptLabel, renderApproval, mode, fullscreen, header, onFocusChange, modeControl, onInterrupt }) {
+/** The /resume list, in place of the prompt: ↑/↓ and Enter choose, Esc cancels. */
+function PickerPanel({ picker }) {
+    const { columns } = stdout;
+    useInput((_text, key) => {
+        if (key.escape)
+            picker.resolve(null);
+    });
+    const width = liveWidth(columns) - PROMPT_FRAME_COLUMNS;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: inkColor("border"), paddingX: 1, children: [_jsx(Text, { bold: true, children: picker.title }), _jsx(Select, { options: picker.options.map((option) => ({ ...option, label: fitWidth(option.label, Math.max(10, width - 2)) })), visibleOptionCount: Math.min(8, picker.options.length), onChange: (value) => picker.resolve(value) }), _jsx(Text, { dimColor: true, children: t().resumeHint })] }));
+}
+function ChatApp({ model, interaction, input, promptLabel, renderApproval, mode, fullscreen, header, onFocusChange, modeControl: currentModeControl, onInterrupt }) {
     const chat = useSyncExternalStore(input.subscribe, input.getSnapshot);
     const session = useSyncExternalStore(model.subscribe, model.getSnapshot);
     const checkpoint = useSyncExternalStore(interaction.subscribe, interaction.getSnapshot);
+    const modeControl = currentModeControl();
     // Ctrl+C stops what is running (a checkpoint, then the turn) and leaves only when idle;
     // Esc interrupts the turn but never answers a checkpoint or leaves.
     useInput((text, key) => {
@@ -104,7 +138,7 @@ function ChatApp({ model, interaction, input, promptLabel, renderApproval, mode,
         if (key.shift && key.tab) {
             // Shift+Tab: the next mode this session allows.
             if (!modeControl || modeControl.switchable.length < 2) {
-                model.note(ui.dim(`(${modeControl?.mode ?? mode ?? "this"} mode can't be switched during the session)`), "notice");
+                model.note(ui.dim(t().modeLocked(modeControl?.mode ?? mode)), "notice");
                 return;
             }
             const next = modeControl.switchable[(modeControl.switchable.indexOf(modeControl.mode) + 1) % modeControl.switchable.length];
@@ -112,6 +146,10 @@ function ChatApp({ model, interaction, input, promptLabel, renderApproval, mode,
             input.setMode(next);
             return;
         }
+        if (key.ctrl && text === "c" && chat.picker) {
+            chat.picker.resolve(null);
+            return;
+        }
         if (key.ctrl && text === "c") {
             if (checkpoint)
                 checkpoint.answer(checkpoint.kind === "decision" ? "q" : "");
@@ -124,7 +162,7 @@ function ChatApp({ model, interaction, input, promptLabel, renderApproval, mode,
             onInterrupt();
         }
     });
-    return (_jsx(SessionView, { model: model, interaction: interaction, renderApproval: renderApproval, mode: chat.mode ?? mode, modeSwitchable: (modeControl?.switchable.length ?? 0) > 1, closed: chat.closed, fullscreen: fullscreen, header: header, onCopy: fullscreen ? (text) => void stdout.write(clipboardSequence(text)) : undefined, children: _jsxs(Box, { flexDirection: "column", children: [chat.queued.map((line, index) => (_jsx(Text, { wrap: "truncate-end", children: ui.dim(`  queued: ${line}`) }, index))), _jsx(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: _jsx(PromptInput, { label: promptLabel.replace(/^\n+/, ""), history: chat.history, commands: chat.commands, inset: PROMPT_FRAME_COLUMNS, suggestion: chat.suggestion, onSubmit: (line) => input.submit(line), onRecallQueued: () => input.unqueueLast(), files: chat.files, onExit: () => input.submit(null) }) })] }) }));
+    return (_jsx(SessionView, { model: model, interaction: interaction, renderApproval: renderApproval, mode: chat.mode ?? mode, modeSwitchable: (modeControl?.switchable.length ?? 0) > 1, closed: chat.closed, fullscreen: fullscreen, header: header, onCopy: fullscreen ? (text) => void stdout.write(clipboardSequence(text)) : undefined, children: _jsxs(Box, { flexDirection: "column", children: [chat.queued.map((line, index) => (_jsx(Text, { wrap: "truncate-end", children: ui.dim(`  ${t().queued(line)}`) }, index))), chat.picker ? (_jsx(PickerPanel, { picker: chat.picker })) : (_jsx(Box, { borderStyle: "round", borderColor: inkColor("border"), paddingX: 1, children: _jsx(PromptInput, { label: promptLabel.replace(/^\n+/, ""), history: chat.history, commands: chat.commands, inset: PROMPT_FRAME_COLUMNS, suggestion: chat.suggestion, onSubmit: (line) => input.submit(line), onRecallQueued: () => input.unqueueLast(), files: chat.files, onExit: () => input.submit(null) }) }))] }) }));
 }
 /**
  * The Ink counterpart of `runChatTui()`, with the same options, session log and history
@@ -135,19 +173,39 @@ function ChatApp({ model, interaction, input, promptLabel, renderApproval, mode,
  *
  * With `fullscreen` it takes the whole terminal instead (see `InkChatOptions.fullscreen`).
  *
+ * Given a session opener instead of options, and `runsDir`, each run keeps its conversation
+ * in its own folder and can be resumed: `--continue` on the command line starts with the
+ * latest, and `/resume` picks one (see `ChatTuiOptions.runsDir`).
+ *
  * Without a TTY (piped, background) or with `plain`, it is `runChatTui()` unchanged.
  */
 export async function runChatInk(options, tuiOptions = {}) {
     if (tuiOptions.plain || !stdin.isTTY || !stdout.isTTY)
         return await runChatTui(options, tuiOptions);
+    // Warnings about an unsupported language code go into the chat, not behind the full screen.
+    const languageWarnings = [];
+    applyLanguage(tuiOptions.language, (line) => languageWarnings.push(line));
+    applyTheme(tuiOptions.theme);
+    const opener = typeof options === "function" ? options : null;
+    const runsDir = opener ? tuiOptions.runsDir : undefined;
+    if (opener && !runsDir)
+        throw new Error("runChatInk(): a session opener needs `runsDir`.");
     const exitCommands = new Set((tuiOptions.exitCommands ?? DEFAULT_EXIT_COMMANDS).map((c) => c.toLowerCase()));
     const promptLabel = tuiOptions.promptLabel ?? DEFAULT_PROMPT_LABEL;
+    const userLine = (text) => `${promptLabel.replace(/^\n+/, "")}${text}`;
     const historyLimit = tuiOptions.historyLimit ?? DEFAULT_HISTORY_LIMIT;
     let historyEntries = tuiOptions.historyPath ? capHistory(await loadHistory(tuiOptions.historyPath), historyLimit) : [];
-    const queue = createInputQueue();
-    const run = runQuery(queue.iterable, { ...options, promptSuggestions: tuiOptions.promptSuggestions ?? true });
-    const events = run.events[Symbol.asyncIterator]();
-    const sessionLog = tuiOptions.sessionLogPath ? createWriteStream(tuiOptions.sessionLogPath, { flags: "a" }) : null;
+    // 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 };
+    const modeControl = () => current.modeControl ?? tuiOptions.modeControl;
+    // 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();
     const mirror = (text) => void sessionLog?.write(stripAnsi(text));
     const model = createSessionModel({
         formatAction: tuiOptions.formatAction,
@@ -160,29 +218,19 @@ export async function runChatInk(options, tuiOptions = {}) {
     const input = createChatInput();
     if (tuiOptions.firstPromptSuggestion)
         input.setSuggestion(tuiOptions.firstPromptSuggestion);
-    if (tuiOptions.modeControl)
-        input.setMode(tuiOptions.modeControl.mode);
-    void listProjectFiles(options.cwd ?? process.cwd()).then((files) => input.setFiles(files));
-    // Every registered command name and alias, built-ins included, for completion and for
-    // catching an unknown "/command" before it reaches the model as plain text (see chatTui.ts).
-    const knownCommands = run.supportedCommands().then((commands) => new Set(commands.flatMap((c) => [c.name, ...(c.aliases ?? [])])), () => null);
-    void knownCommands.then((names) => {
-        const exits = [...exitCommands].filter((c) => c.startsWith("/")).map((c) => c.slice(1));
-        const local = tuiOptions.terminalIntegration === false ? [] : ["copy"];
-        input.setCommands([...new Set([...(names ?? []), ...exits, ...local])].sort());
-    });
+    void listProjectFiles(current.options.cwd ?? process.cwd()).then((files) => input.setFiles(files));
     let turnInterrupted = false;
     function interruptTurn() {
         if (turnInterrupted)
             return;
         turnInterrupted = true;
         void run.interrupt();
-        model.writeLine(ui.warn("(interrupted)"));
+        model.writeLine(ui.warn(t().interrupted));
     }
-    // One reader for the whole session instead of drainTurn()'s one per turn: the prompt
-    // suggestion arrives after its turn's turn-end, while the human is already at the prompt,
-    // and MCP errors arrive before the first turn. Still manual .next() calls, never a
-    // for-await that could be broken out of (ADR-010).
+    // One reader per session instead of drainTurn()'s one per turn: the prompt suggestion
+    // arrives after its turn's turn-end, while the human is already at the prompt, and MCP
+    // errors arrive before the first turn. Still manual .next() calls, never a for-await that
+    // could be broken out of (ADR-010). A reader left behind by /resume stops reporting.
     let turnDone = null;
     let readError = null;
     function finishTurn() {
@@ -190,26 +238,48 @@ export async function runChatInk(options, tuiOptions = {}) {
         turnDone = null;
         done?.();
     }
-    void (async () => {
-        try {
-            while (true) {
-                const { value, done } = await events.next();
-                if (done)
-                    break;
-                if (value.type === "prompt-suggestion") {
-                    input.setSuggestion(value.suggestion);
-                    continue;
+    let queue = createInputQueue();
+    let run;
+    let knownCommands;
+    let generation = 0;
+    function connect() {
+        const own = ++generation;
+        queue = createInputQueue();
+        run = runQuery(queue.iterable, { ...current.options, promptSuggestions: tuiOptions.promptSuggestions ?? true });
+        const events = run.events[Symbol.asyncIterator]();
+        input.setMode(modeControl()?.mode ?? null);
+        // Every registered command name and alias, built-ins included, for completion and for
+        // catching an unknown "/command" before it reaches the model as plain text (see chatTui.ts).
+        knownCommands = run.supportedCommands().then((commands) => new Set(commands.flatMap((c) => [c.name, ...(c.aliases ?? [])])), () => null);
+        void knownCommands.then((names) => {
+            const exits = [...exitCommands].filter((c) => c.startsWith("/")).map((c) => c.slice(1));
+            const local = [...(tuiOptions.terminalIntegration === false ? [] : ["copy"]), ...(runsDir ? ["resume"] : [])];
+            input.setCommands([...new Set([...(names ?? []), ...exits, ...local])].sort());
+        });
+        void (async () => {
+            try {
+                while (true) {
+                    const { value, done } = await events.next();
+                    if (own !== generation || done)
+                        break;
+                    if (value.type === "prompt-suggestion") {
+                        input.setSuggestion(value.suggestion);
+                        continue;
+                    }
+                    model.render(value);
+                    if (value.type === "turn-end")
+                        finishTurn();
                 }
-                model.render(value);
-                if (value.type === "turn-end")
-                    finishTurn();
             }
-        }
-        catch (error) {
-            readError = error;
-        }
-        finishTurn();
-    })();
+            catch (error) {
+                if (own === generation)
+                    readError = error;
+            }
+            if (own === generation)
+                finishTurn();
+        })();
+    }
+    connect();
     async function runTurn(line) {
         input.setSuggestion(null);
         status?.turnStarted();
@@ -225,22 +295,59 @@ export async function runChatInk(options, tuiOptions = {}) {
         if (readError)
             throw readError;
     }
+    /** Draws the run's earlier conversation (when it has one) and says it was resumed. */
+    async function showConversation(folder, fromResume) {
+        if (!folder.sessionId)
+            return;
+        const messages = await readConversation(folder.dir);
+        const [summary] = (await listRuns(path.dirname(folder.dir))).filter((r) => path.resolve(r.dir) === path.resolve(folder.dir));
+        // In full screen the history is redrawn from the start; inline, the terminal's
+        // scrollback can't be taken back, so the conversation follows what's already there.
+        if (fromResume && tuiOptions.fullscreen)
+            model.reset();
+        model.replay(messages, userLine);
+        model.writeLine(ui.dim(t().resumed(runDate(summary?.updatedAt ?? new Date()))));
+    }
+    /** /resume: picks one of the runs and switches the session to it. */
+    async function resume() {
+        if (!opener || !runsDir)
+            return;
+        const runs = await listRuns(runsDir);
+        if (runs.length === 0) {
+            model.writeLine(ui.dim(t().noEarlierRuns));
+            return;
+        }
+        const chosen = await input.pick(t().resumeTitle, runs.map((summary, i) => ({ label: `${i + 1}. ${runLabel(summary, current.run ?? undefined)}`, value: summary.dir })));
+        const summary = runs.find((r) => r.dir === chosen);
+        if (!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();
+        connect();
+        await showConversation(current.run, true);
+    }
     const previousPort = getInteractionPort();
     setInteractionPort(interaction.port);
     const restoreTerminal = tuiOptions.fullscreen ? enterFullscreen(stdout) : null;
     const cursor = tuiOptions.fullscreen ? createCursorController(stdout) : null;
     const status = tuiOptions.terminalIntegration === false ? null : createTerminalStatus((text) => void stdout.write(text), tuiOptions.header?.title ?? "agent");
     status?.start();
-    const app = render(_jsx(CursorContext.Provider, { value: cursor, children: _jsx(ChatApp, { model: model, interaction: interaction, input: input, promptLabel: promptLabel, renderApproval: tuiOptions.renderApproval, mode: tuiOptions.mode, fullscreen: tuiOptions.fullscreen, header: tuiOptions.header && tuiOptions.fullscreen ? headerLines(tuiOptions.header) : undefined, onFocusChange: status ? (focused) => status.setFocused(focused) : undefined, modeControl: tuiOptions.modeControl, onInterrupt: interruptTurn }) }), 
+    const app = render(_jsx(CursorContext.Provider, { value: cursor, children: _jsx(KitTheme, { children: _jsx(ChatApp, { model: model, interaction: interaction, input: input, promptLabel: promptLabel, renderApproval: tuiOptions.renderApproval, mode: tuiOptions.mode, fullscreen: tuiOptions.fullscreen, header: tuiOptions.header && tuiOptions.fullscreen ? headerLines(tuiOptions.header) : undefined, onFocusChange: status ? (focused) => status.setFocused(focused) : undefined, modeControl: modeControl, onInterrupt: interruptTurn }) }) }), 
     // In full screen Ink writes through the cursor controller, which places the terminal's cursor.
     { exitOnCtrlC: false, ...(cursor ? { stdout: cursor.stream } : {}) });
     try {
         // In full screen the header is pinned above the history (see SessionView) instead.
         if (tuiOptions.header && !tuiOptions.fullscreen)
             model.note(headerLines(tuiOptions.header).join("\n"));
+        for (const warning of languageWarnings)
+            model.writeLine(ui.warn(warning));
         if (tuiOptions.welcomeMessage)
             model.writeLine(tuiOptions.welcomeMessage);
-        if (tuiOptions.initialPrompt) {
+        if (current.run)
+            await showConversation(current.run, false);
+        if (tuiOptions.initialPrompt && !current.run?.sessionId) {
             // Logged but not shown, like runChatTui(): it is the agent's cue, not something typed.
             mirror(`${promptLabel}${tuiOptions.initialPrompt}\n`);
             await runTurn(tuiOptions.initialPrompt);
@@ -256,7 +363,7 @@ export async function runChatInk(options, tuiOptions = {}) {
             if (!line)
                 continue;
             mirror(`${promptLabel}${line}\n`);
-            model.note(`${promptLabel.replace(/^\n+/, "")}${line}`, "user");
+            model.note(userLine(line), "user");
             if (tuiOptions.historyPath) {
                 historyEntries = capHistory([...historyEntries, { text: line, timestamp: new Date().toISOString() }], historyLimit);
                 await saveHistory(tuiOptions.historyPath, historyEntries);
@@ -268,14 +375,18 @@ export async function runChatInk(options, tuiOptions = {}) {
                 const reply = model.lastReply();
                 if (reply)
                     stdout.write(clipboardSequence(reply));
-                model.writeLine(ui.dim(reply ? `(copied the last reply: ${reply.length} characters)` : "(nothing to copy yet)"));
+                model.writeLine(ui.dim(reply ? t().copiedReply(reply.length) : t().nothingToCopy));
+                continue;
+            }
+            if (runsDir && line.toLowerCase() === "/resume") {
+                await resume();
                 continue;
             }
             const commandToken = slashCommandToken(line);
             if (commandToken) {
                 const names = await knownCommands;
                 if (names && !names.has(commandToken)) {
-                    model.writeLine(ui.warn(`Unknown command: /${commandToken}`));
+                    model.writeLine(ui.warn(t().unknownCommand(commandToken)));
                     continue;
                 }
             }

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

@@ -71,6 +71,16 @@ export interface SessionModel {
     /** The agent's text in the latest turn, plain (for /copy). */
     lastReply(): string;
     setContextPercent(percent: number | null): void;
+    /** Empties the history and the counters, for a resumed conversation redrawn from the start. */
+    reset(): void;
+    /**
+     * Draws an earlier conversation (a resumed one): the human's lines as `userLine()` makes
+     * them and the agent's replies with their markdown, without passing them to `onWrite`.
+     */
+    replay(messages: readonly {
+        role: "user" | "assistant";
+        text: string;
+    }[], userLine: (text: string) => string): void;
 }
 /**
  * The state behind the Ink views, in the look of the Claude Code CLI: the agent's words

package/dist/tui/ink/sessionModel.js

@@ -4,6 +4,7 @@ import { fitWidth, stripAnsi } from "./lineBuffer.js";
 import { finishedLength, renderMarkdown } from "./markdown.js";
 import { toolGroupExpanded, toolGroupSummary } from "./toolGroup.js";
 import * as ui from "../ui.js";
+import { t } from "../../core/messages/index.js";
 /**
  * Columns the live area may use: short of the edge, where the Windows console wraps early
  * (see lineBuffer.ts). Read on every use, so a resized terminal is picked up.
@@ -196,7 +197,7 @@ export function createSessionModel(options = {}) {
                 }
                 case "mcp-error":
                     closeAll();
-                    push([ui.warn(`Some MCP servers failed to connect: ${event.failedServers.join(", ")}`)], "notice");
+                    push([ui.warn(t().mcpFailed(event.failedServers.join(", ")))], "notice");
                     refreshLive();
                     return;
                 case "info":
@@ -242,7 +243,7 @@ export function createSessionModel(options = {}) {
             const started = snapshot.turnStartedAt;
             if (started !== null) {
                 const seconds = Math.max(1, Math.round((Date.now() - started) / 1000));
-                push([ui.dim(`✻ Worked for ${seconds}s`)], "note");
+                push([ui.dim(`✻ ${t().workedFor(seconds)}`)], "note");
             }
             snapshot = { ...snapshot, busy: false, turnStartedAt: null, activity: null, subagentActivity: null };
             refreshLive();
@@ -258,5 +259,29 @@ export function createSessionModel(options = {}) {
         getSnapshot: () => snapshot,
         lastReply: () => reply.trim(),
         setContextPercent: (percent) => update({ contextPercent: percent }),
+        reset() {
+            closeAll();
+            lastKind = null;
+            gapPending = false;
+            reply = "";
+            snapshot = { ...snapshot, items: [], live: "", liveGap: false, turns: 0, usage: null, contextPercent: null };
+            refreshLive();
+        },
+        replay(messages, userLine) {
+            closeAll();
+            for (const message of messages) {
+                if (!lastIsBlank(snapshot.items))
+                    gapPending = true;
+                if (message.role === "user") {
+                    push(userLine(message.text).split("\n"), "user");
+                }
+                else {
+                    segment = message.text;
+                    flushSegment(true);
+                }
+            }
+            snapshot = { ...snapshot, turns: snapshot.turns + messages.filter((message) => message.role === "user").length };
+            refreshLive();
+        },
     };
 }

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

@@ -1,3 +1,4 @@
+import { type ToolPhrase } from "../../core/messages/index.js";
 export interface ToolCall {
     id?: string;
     toolName: string;
@@ -11,7 +12,7 @@ export interface ToolCall {
     children?: string[];
 }
 /** How a tool counts in a group's summary: the phrase for one call and for several, "{n}" standing for the count. */
-export type ToolPhrase = [one: string, many: string];
+export type { ToolPhrase };
 /**
  * A folded group's one line, as in the Claude Code CLI: "Read 2 files, ran 1 shell
  * command". Calls to the same kind of tool are counted together, in the order they first

package/dist/tui/ink/toolGroup.js

@@ -1,24 +1,11 @@
-import { fitWidth } from "./lineBuffer.js";
+import { fitWidth, stripAnsi } from "./lineBuffer.js";
 import { renderMarkdown } from "./markdown.js";
 import * as ui from "../ui.js";
+import { t } from "../../core/messages/index.js";
 // A subagent can make many calls; the latest ones are shown, the rest counted.
 const MAX_CHILDREN = 5;
 // Tools whose result is a subagent's answer, in markdown: its first line is rendered.
 const SUBAGENT_TOOLS = new Set(["Agent", "Task"]);
-const BUILT_IN = {
-    Read: ["read {n} file", "read {n} files"],
-    Write: ["wrote {n} file", "wrote {n} files"],
-    Edit: ["edited {n} file", "edited {n} files"],
-    Glob: ["listed files", "listed files {n} times"],
-    Grep: ["searched {n} time", "searched {n} times"],
-    Bash: ["ran {n} shell command", "ran {n} shell commands"],
-    WebSearch: ["searched the web", "searched the web {n} times"],
-    WebFetch: ["fetched {n} page", "fetched {n} pages"],
-    Skill: ["used {n} skill", "used {n} skills"],
-    Agent: ["ran {n} subagent", "ran {n} subagents"],
-    Task: ["ran {n} subagent", "ran {n} subagents"],
-};
-const OTHER = ["used {n} tool", "used {n} tools"];
 /**
  * A folded group's one line, as in the Claude Code CLI: "Read 2 files, ran 1 shell
  * command". Calls to the same kind of tool are counted together, in the order they first
@@ -29,7 +16,7 @@ export function toolGroupSummary(calls, phraseFor) {
     // Counted by the phrase's text: a consumer's phraseFor() may return a new array each call.
     const counts = new Map();
     for (const call of calls) {
-        const phrase = phraseFor?.(call.toolName) ?? BUILT_IN[call.toolName] ?? OTHER;
+        const phrase = phraseFor?.(call.toolName) ?? t().toolPhrases[call.toolName] ?? t().otherTools;
         const key = phrase.join("|");
         const entry = counts.get(key) ?? { phrase, n: 0 };
         entry.n++;
@@ -46,13 +33,15 @@ export function toolGroupSummary(calls, phraseFor) {
 export function resultSummary(result, markdown = false) {
     const lines = result.text.split("\n").filter((line) => line.trim() !== "");
     if (lines.length === 0)
-        return result.isError ? ui.error("error") : ui.dim("(no output)");
-    const more = lines.length > 1 ? ui.dim(` (+${lines.length - 1} ${lines.length === 2 ? "line" : "lines"})`) : "";
+        return result.isError ? ui.error(t().error) : ui.dim(t().noOutput);
+    const more = lines.length > 1 ? ui.dim(` ${t().moreResultLines(lines.length - 1)}`) : "";
     const first = lines[0].trim();
     if (result.isError)
         return ui.error(first) + more;
     // Rendered wide, as one row: the summary line is cut to the room left afterwards.
-    return (markdown ? (renderMarkdown(first, 1000)[0] ?? first) : first) + more;
+    // Plain before the theme's color: a style the markdown opened and closed (bold's reset)
+    // would cancel a dim around it.
+    return ui.toolResult(markdown ? stripAnsi(renderMarkdown(first, 1000)[0] ?? first) : first) + more;
 }
 /**
  * The calls one by one: each behind a `●`, then after `⎿` the calls a subagent made (the
@@ -65,12 +54,12 @@ export function toolGroupExpanded(calls, width) {
         const shown = children.slice(-MAX_CHILDREN);
         const result = call.result ? fitWidth(resultSummary(call.result, SUBAGENT_TOOLS.has(call.toolName)), width - 5) : ui.dim("…");
         const under = [
-            ...(children.length > shown.length ? [ui.dim(`… ${children.length - shown.length} earlier`)] : []),
+            ...(children.length > shown.length ? [ui.dim(t().earlierCalls(children.length - shown.length))] : []),
             ...shown.map((label) => fitWidth(ui.dim(`· ${label}`), width - 5)),
             result,
         ];
         return [
-            `${ui.toolBullet("●")} ${fitWidth(call.label, width - 2)}`,
+            `${ui.toolBullet("●")} ${fitWidth(ui.toolLabel(call.label), width - 2)}`,
             ...under.map((line, i) => (line === "" ? "" : `  ${i === 0 ? ui.dim("⎿") : " "}  ${line}`)),
         ];
     });