@falkenslab/agent-kit 0.10.2 → 0.12.0

package/dist/tui/ink/runChatInk.js

@@ -1,18 +1,24 @@
 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 { 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 +36,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 +80,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 +106,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: "gray", 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 +136,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 +144,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 +160,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: "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) }) }))] }) }));
 }
 /**
  * The Ink counterpart of `runChatTui()`, with the same options, session log and history
@@ -135,19 +171,38 @@ 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));
+    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 +215,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 +235,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 +292,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(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 +360,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 +372,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 { 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,8 +33,8 @@ 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;
@@ -65,7 +52,7 @@ 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,
         ];

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

@@ -37,6 +37,12 @@ export interface WizardOptions {
     title?: string;
     /** Use the plain @inquirer/prompts questions even on a TTY. */
     plain?: boolean;
+    /**
+     * 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;
 }
 /**
  * How many choices a select shows at once, so the question, its choices and a validation

package/dist/tui/ink/wizard.js

@@ -7,6 +7,8 @@ import { liveWidth } from "./sessionModel.js";
 import { ConfirmInput, PasswordInput, Select, TextInput } from "@inkjs/ui";
 import * as inquirer from "@inquirer/prompts";
 import * as ui from "../ui.js";
+import { t } from "../../core/messages/index.js";
+import { applyLanguage } from "../language.js";
 function resolve(value, answers) {
     return typeof value === "function" ? value(answers) : value;
 }
@@ -63,7 +65,7 @@ function summary(step, value, answers) {
     if (step.type === "password")
         return "*".repeat(String(value).length);
     if (step.type === "confirm")
-        return value ? "Yes" : "No";
+        return value ? t().yes : t().no;
     if (step.type === "select")
         return resolve(step.choices, answers).find((c) => c.value === value)?.name ?? String(value);
     return String(value);
@@ -154,6 +156,7 @@ async function runPlainWizard(steps, title) {
  * steps through @inquirer/prompts.
  */
 export async function runWizard(steps, options = {}) {
+    applyLanguage(options.language);
     if (options.plain || !stdin.isTTY || !stdout.isTTY)
         return await runPlainWizard(steps, options.title);
     if (nextIndex(steps, -1, {}) >= steps.length)

package/dist/tui/language.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Chooses the kit's language for a terminal entry point (see messages/'s chooseLanguage())
+ * and prints the warnings about unsupported codes not shown yet, or hands them to `show`.
+ */
+export declare function applyLanguage(option: string | undefined, show?: (line: string) => void): void;

package/dist/tui/language.js

@@ -0,0 +1,11 @@
+import { chooseLanguage, takeLanguageWarnings } from "../core/messages/index.js";
+import * as ui from "./ui.js";
+/**
+ * Chooses the kit's language for a terminal entry point (see messages/'s chooseLanguage())
+ * and prints the warnings about unsupported codes not shown yet, or hands them to `show`.
+ */
+export function applyLanguage(option, show = (line) => console.warn(ui.warn(line))) {
+    chooseLanguage(option);
+    for (const warning of takeLanguageWarnings())
+        show(warning);
+}

package/dist/tui/runs.d.ts

@@ -0,0 +1,27 @@
+import type { Options } from "@anthropic-ai/claude-agent-sdk";
+import type { ModeControl } from "../core/session.js";
+import { type RunFolder, type RunSummary } from "../core/runs.js";
+/**
+ * Builds the session's options for a run folder, e.g.
+ * `(run) => buildSessionOptions(config, run.dir, spec, { run })`: called for the first run
+ * and again for each one resumed with /resume (MCP servers, the step gate and the transcript
+ * are bound to the run's folder, so they're built anew).
+ */
+export type SessionOpener = (run: RunFolder) => Promise<Options | {
+    options: Options;
+    modeControl?: ModeControl;
+}>;
+export interface OpenedSession {
+    run: RunFolder;
+    options: Options;
+    modeControl?: ModeControl;
+}
+/** The run a chat starts with: the latest one with `--continue` (if any), a new one otherwise. */
+export declare function firstRun(runsDir: string, argv?: readonly string[]): Promise<RunFolder>;
+export declare function openSession(opener: SessionOpener, run: RunFolder): Promise<OpenedSession>;
+/** A run's date for a person, in the kit's language. */
+export declare function runDate(date: Date): string;
+/** A run in the /resume list: its date and the human's last message. */
+export declare function runLabel(run: RunSummary, current?: RunFolder): string;
+/** The run folder of a summary, re-reading its session (a run resumed a moment ago may have changed). */
+export declare function runFolderOf(run: RunSummary): Promise<RunFolder>;

package/dist/tui/runs.js

@@ -0,0 +1,30 @@
+import path from "node:path";
+import { continueArgument, createRunFolder, listRuns, readRunSession } from "../core/runs.js";
+import { getLanguage, t } from "../core/messages/index.js";
+/** The run a chat starts with: the latest one with `--continue` (if any), a new one otherwise. */
+export async function firstRun(runsDir, argv = process.argv.slice(2)) {
+    if (continueArgument(argv)) {
+        const [latest] = await listRuns(runsDir);
+        if (latest)
+            return { dir: latest.dir, sessionId: latest.sessionId };
+    }
+    return await createRunFolder(runsDir);
+}
+export async function openSession(opener, run) {
+    const opened = await opener(run);
+    // The SDK's Options has no "options" field: this is buildSessionOptions()'s result.
+    return "options" in opened ? { run, options: opened.options, modeControl: opened.modeControl } : { run, options: opened };
+}
+/** A run's date for a person, in the kit's language. */
+export function runDate(date) {
+    return new Intl.DateTimeFormat(getLanguage(), { dateStyle: "medium", timeStyle: "short" }).format(date);
+}
+/** A run in the /resume list: its date and the human's last message. */
+export function runLabel(run, current) {
+    const mark = current && path.resolve(current.dir) === path.resolve(run.dir) ? ` ${t().currentRun}` : "";
+    return `${runDate(run.updatedAt)}${mark}${run.lastMessage ? ` · ${run.lastMessage}` : ""}`;
+}
+/** The run folder of a summary, re-reading its session (a run resumed a moment ago may have changed). */
+export async function runFolderOf(run) {
+    return { dir: run.dir, sessionId: (await readRunSession(run.dir)) ?? run.sessionId };
+}

package/dist/tui/terminalInteraction.js

@@ -1,6 +1,6 @@
 import readline from "node:readline/promises";
 import { stdin, stdout } from "node:process";
-const DEFAULT_QUESTION = "Allow this to continue? [Y/n/q] ";
+import { t } from "../core/messages/index.js";
 /**
  * A long-lived chat REPL's readline interface (if any), so that the terminal port reuses
  * it instead of creating its own.
@@ -55,7 +55,7 @@ async function askOnTerminal(prompt, signal) {
     console.log(`\n=== ${prompt.title} ===`);
     for (const line of prompt.lines)
         console.log(line);
-    const question = prompt.question ?? DEFAULT_QUESTION;
+    const question = prompt.question ?? t().terminalQuestion;
     const shared = sharedReadline;
     if (shared)
         return await askOnSharedReadline(shared, question);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@falkenslab/agent-kit",
-  "version": "0.10.2",
+  "version": "0.12.0",
   "description": "Library for building an agent on top of the Claude Agent SDK",
   "author": "Francisco Vargas Ruiz",
   "license": "MIT",