@falkenslab/agent-kit 0.10.2 → 0.12.0

package/dist/core/session.d.ts

@@ -1,6 +1,8 @@
 import type { Options, SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
 import { type TranscriptLogger } from "./hooks/transcriptLogger.js";
 import type { AgentSpec, BaseSessionConfig, Mode } from "./agentSpec.js";
+import { type Language } from "./language.js";
+import { type RunFolder } from "./runs.js";
 /**
  * Builds the `options` object passed to the Agent SDK's `query()` — everything about
  * *how* the agent runs a session (system prompt, tools, MCP servers, hooks), independent
@@ -15,14 +17,20 @@ import type { AgentSpec, BaseSessionConfig, Mode } from "./agentSpec.js";
  * The per-mode behavioral differences (whether the approval/manual-intervention tools
  * exist, whether the interactive step gate hook runs) all fall out of `config.mode`
  * alone.
+ *
+ * `options.run` keeps the SDK's transcript of the conversation in that run folder (see
+ * runs.ts's createRunStore()) and, when it has a session already, resumes it: the chat
+ * passes it when the agent gives it a runs folder (`InkChatOptions.runsDir`).
  */
 export declare function buildSessionOptions<TConfig extends BaseSessionConfig>(config: TConfig, runDir: string, spec: AgentSpec<TConfig>, options?: {
     autoCompactEnabled?: boolean;
+    run?: RunFolder;
 }): Promise<{
     options: Options;
     transcriptLogger: TranscriptLogger;
     transcriptPath: string;
     modeControl: ModeControl;
+    language: Language;
 }>;
 /**
  * The supervision mode of a running session. Only "guided" and "interactive" can switch into

package/dist/core/session.js

@@ -10,6 +10,9 @@ import { createManualLoginServer } from "./tools/manualLogin.js";
 import { createSaveToSourcesServer } from "./tools/saveToSources.js";
 import { allowAnyMcpTool } from "./mcpPermissions.js";
 import { knowledgePluginRoot, knowledgePromptSection } from "./knowledge.js";
+import { replyLanguageInstruction } from "./language.js";
+import { chooseLanguage } from "./messages/index.js";
+import { createRunStore } from "./runs.js";
 /**
  * Builds the `options` object passed to the Agent SDK's `query()` — everything about
  * *how* the agent runs a session (system prompt, tools, MCP servers, hooks), independent
@@ -24,9 +27,18 @@ import { knowledgePluginRoot, knowledgePromptSection } from "./knowledge.js";
  * The per-mode behavioral differences (whether the approval/manual-intervention tools
  * exist, whether the interactive step gate hook runs) all fall out of `config.mode`
  * alone.
+ *
+ * `options.run` keeps the SDK's transcript of the conversation in that run folder (see
+ * runs.ts's createRunStore()) and, when it has a session already, resumes it: the chat
+ * passes it when the agent gives it a runs folder (`InkChatOptions.runsDir`).
  */
 export async function buildSessionOptions(config, runDir, spec, options = {}) {
     const { mode } = config;
+    // The kit's language (`--language`, then config.language, then the system's), chosen here
+    // for the interface too, so the agent answers in the language its interface is in.
+    const language = chooseLanguage(config.language);
+    const replyLine = spec.replyInLanguage === false ? null : replyLanguageInstruction(language);
+    const withReplyLine = (prompt) => (replyLine ? `${prompt}\n\n${replyLine}` : prompt);
     const modeControl = createModeControl(mode);
     // The human approval server only exists outside autonomous mode: the point of
     // autonomous is that the agent has no channel to ask for human intervention at all.
@@ -69,6 +81,10 @@ export async function buildSessionOptions(config, runDir, spec, options = {}) {
     // anything not already present here — which is why the hook, not just omitting "Bash"
     // from this list, is what actually confines it to subagent use).
     const subagents = spec.buildSubagents(config);
+    // Each subagent gets the reply line too: its prompt doesn't include the main one's.
+    const subagentDefinitions = subagents
+        ? Object.fromEntries(Object.entries(subagents.agents).map(([name, agent]) => [name, { ...agent, prompt: withReplyLine(agent.prompt) }]))
+        : undefined;
     const includeSubagentTools = subagents !== undefined;
     // The exact set of subagent_type values the Agent tool may spawn in this session — see
     // createSubagentTypeGate() below for why this can't just be "whatever's in `agents`
@@ -79,10 +95,20 @@ export async function buildSessionOptions(config, runDir, spec, options = {}) {
     const transcriptPath = path.join(runDir, "transcript.jsonl");
     const transcriptLogger = createTranscriptLogger(transcriptPath, config.secrets ?? []);
     const sdkOptions = {
-        systemPrompt: includeKnowledgeBase && config.knowledgeDir
+        systemPrompt: withReplyLine(includeKnowledgeBase && config.knowledgeDir
             ? `${spec.buildSystemPrompt(config)}\n\n${knowledgePromptSection(config.projectDir, config.knowledgeDir, config.sourcesDir)}`
-            : spec.buildSystemPrompt(config),
-        settings: { autoCompactEnabled: options.autoCompactEnabled ?? true },
+            : spec.buildSystemPrompt(config)),
+        // Not the SDK's default (every source): "user" hands the agent the runner's own Claude
+        // Code configuration, and its `language` setting outranked the agent's prompt.
+        settingSources: spec.settingSources ?? ["project"],
+        // autoMemoryEnabled: false keeps out the runner's own Claude Code memory for the project
+        // (~/.claude/projects/<repository>/memory/MEMORY.md), which the CLI loads whatever
+        // settingSources says (confirmed empirically): it's notes for them, not for this agent,
+        // whose own memory is the knowledge base. includeGitInstructions: false leaves out the
+        // CLI's commit workflow and git context (the runner's git user name among it), which no
+        // agent here needs and which pulled replies towards the runner's language (confirmed
+        // empirically, see ADR-018).
+        settings: { autoCompactEnabled: options.autoCompactEnabled ?? true, autoMemoryEnabled: false, includeGitInstructions: false },
         // No built-in tools except, if applicable, Read/Write/Edit/Glob/Grep scoped to the
         // project's own folders (fileScopeGate below), and WebFetch/WebSearch
         // with no domain restriction (not conditioned on includeFileTools: it's read-only,
@@ -116,13 +142,15 @@ export async function buildSessionOptions(config, runDir, spec, options = {}) {
                 additionalDirectories: searchableDirs,
                 // "skills" acts as a name whitelist, not an addition: "all" enables both the
                 // SDK's own official skills (pdf/docx), the project's own custom ones, and the
-                // plugin-provided built-ins below.
-                skills: "all",
+                // plugin-provided built-ins below. A spec's own list gets the knowledge base's
+                // skills added, so it only names its own.
+                skills: skillList(spec.skills, includeKnowledgeBase),
                 plugins: pluginRoots.map((pluginPath) => ({ type: "local", path: pluginPath, skipMcpDiscovery: true })),
             }
             : {}),
         maxTurns: 400,
-        ...(subagents ? { agents: subagents.agents } : {}),
+        ...(options.run ? { sessionStore: createRunStore(options.run.dir), ...(options.run.sessionId ? { resume: options.run.sessionId } : {}) } : {}),
+        ...(subagentDefinitions ? { agents: subagentDefinitions } : {}),
         mcpServers: {
             ...spec.buildMcpServers(config, runDir),
             ...(includeApprovalTool ? { approvals: createHumanApprovalServer(runDir, spec.humanApprovalTexts) } : {}),
@@ -149,7 +177,14 @@ export async function buildSessionOptions(config, runDir, spec, options = {}) {
             PostToolUse: [{ hooks: [transcriptLogger.postToolUse] }],
         },
     };
-    return { options: sdkOptions, transcriptLogger, transcriptPath, modeControl };
+    return { options: sdkOptions, transcriptLogger, transcriptPath, modeControl, language };
+}
+/** The knowledge plugin's skills, as the SDK names a plugin's skills ("plugin:skill"). */
+const KNOWLEDGE_SKILLS = ["knowledge-pages", "knowledge-ingest", "knowledge-query", "knowledge-lint"].map((skill) => `knowledge:${skill}`);
+function skillList(skills, includeKnowledgeBase) {
+    if (skills === undefined || skills === "all")
+        return "all";
+    return includeKnowledgeBase ? [...new Set([...skills, ...KNOWLEDGE_SKILLS])] : skills;
 }
 export function createModeControl(initial) {
     let current = initial;

package/dist/core/toolLabels.d.ts

@@ -5,7 +5,8 @@
  * plus its own human-approval/manual-intervention/save-to-sources MCP tools)
  * generically; a
  * concrete agent supplies a `describe` callback for its own domain-specific tools (e.g.
- * Playwright's browser_* cases) via `createFriendlyToolLabel()`.
+ * Playwright's browser_* cases) via `createFriendlyToolLabel()`. The kit's own labels are in
+ * the current language (see messages/).
  */
 export declare function truncate(text: string, max?: number): string;
 export declare function truncatePath(text: string, max?: number): string;

package/dist/core/toolLabels.js

@@ -1,3 +1,4 @@
+import { t } from "./messages/index.js";
 /**
  * Turns a raw tool name + input into a short, readable console description, instead of
  * the tool's technical name (e.g. "mcp__playwright__browser_click"). Covers the tools
@@ -5,7 +6,8 @@
  * plus its own human-approval/manual-intervention/save-to-sources MCP tools)
  * generically; a
  * concrete agent supplies a `describe` callback for its own domain-specific tools (e.g.
- * Playwright's browser_* cases) via `createFriendlyToolLabel()`.
+ * Playwright's browser_* cases) via `createFriendlyToolLabel()`. The kit's own labels are in
+ * the current language (see messages/).
  */
 export function truncate(text, max = 60) {
     return text.length > max ? `${text.slice(0, max)}…` : text;
@@ -18,65 +20,43 @@ export function truncatePath(text, max = 60) {
 }
 /** Returns undefined for anything it doesn't specifically recognize — the caller decides the fallback. */
 function describeCore(shortName, input) {
+    const labels = t().labels;
+    const text = (value, fallback) => (typeof value === "string" ? value : fallback);
     switch (shortName) {
-        case "request_human_approval": {
-            const summary = typeof input.summary === "string" ? input.summary : "";
-            return `Asking for human approval: ${truncate(summary, 120)}`;
-        }
+        case "request_human_approval":
+            return labels.askingApproval(truncate(text(input.summary, ""), 120));
         case "request_manual_login":
-            return "Waiting for a human to intervene manually";
-        case "save_to_sources": {
-            const destination = typeof input.destination === "string" ? input.destination : "sources/";
-            return `Saving a file to sources/${truncatePath(destination, 70)}`;
-        }
-        case "Read": {
-            const file = typeof input.file_path === "string" ? input.file_path : "a file";
-            return `Reading ${truncatePath(file, 80)}`;
-        }
-        case "Write": {
-            const file = typeof input.file_path === "string" ? input.file_path : "a file";
-            return `Writing to ${truncatePath(file, 80)}`;
-        }
-        case "Edit": {
-            const file = typeof input.file_path === "string" ? input.file_path : "a file";
-            return `Editing ${truncatePath(file, 80)}`;
-        }
-        case "Glob": {
-            const pattern = typeof input.pattern === "string" ? input.pattern : "*";
-            return `Searching for files matching "${truncate(pattern, 60)}"`;
-        }
-        case "Grep": {
-            const pattern = typeof input.pattern === "string" ? input.pattern : "";
-            return `Searching file contents for "${truncate(pattern, 60)}"`;
-        }
-        case "Bash": {
-            const command = typeof input.command === "string" ? input.command : "";
-            return `Running "${truncate(command, 80)}"`;
-        }
+            return labels.waitingManual;
+        case "save_to_sources":
+            return labels.savingToSources(truncatePath(text(input.destination, ""), 70));
+        case "Read":
+            return labels.reading(truncatePath(text(input.file_path, labels.aFile), 80));
+        case "Write":
+            return labels.writing(truncatePath(text(input.file_path, labels.aFile), 80));
+        case "Edit":
+            return labels.editing(truncatePath(text(input.file_path, labels.aFile), 80));
+        case "Glob":
+            return labels.findingFiles(truncate(text(input.pattern, "*"), 60));
+        case "Grep":
+            return labels.searchingContents(truncate(text(input.pattern, ""), 60));
+        case "Bash":
+            return labels.running(truncate(text(input.command, ""), 80));
         // The SDK's built-in subagent-delegation tool. Confirmed empirically (real
         // transcript) its input is { description, prompt, subagent_type }, not
         // { subagent_type, task } as its own tool description might suggest.
         case "Agent": {
-            const subagentType = typeof input.subagent_type === "string" ? input.subagent_type : "a subagent";
-            const description = typeof input.description === "string" ? input.description : "";
-            return description
-                ? `Delegating to "${subagentType}": ${truncate(description, 80)}`
-                : `Delegating to "${subagentType}"`;
-        }
-        case "WebFetch": {
-            const url = typeof input.url === "string" ? input.url : "a page";
-            return `Fetching ${truncate(url, 80)}`;
-        }
-        case "WebSearch": {
-            const query = typeof input.query === "string" ? input.query : "";
-            return `Searching the web for "${truncate(query, 80)}"`;
+            const subagentType = text(input.subagent_type, labels.aSubagent);
+            const description = text(input.description, "");
+            return description ? labels.delegatingTask(subagentType, truncate(description, 80)) : labels.delegating(subagentType);
         }
+        case "WebFetch":
+            return labels.fetching(truncate(text(input.url, labels.aPage), 80));
+        case "WebSearch":
+            return labels.searchingWeb(truncate(text(input.query, ""), 80));
         // The SDK's own tool for invoking a skill (see session.ts for why it's listed
         // explicitly in `tools`). Confirmed empirically: its input is `{ skill: "name" }`.
-        case "Skill": {
-            const skill = typeof input.skill === "string" ? input.skill : "a skill";
-            return `Applying the "${skill}" skill`;
-        }
+        case "Skill":
+            return labels.applyingSkill(text(input.skill, labels.aSkill));
         default:
             return undefined;
     }

package/dist/core/tools/humanApproval.js

@@ -1,6 +1,7 @@
 import { tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
 import { z } from "zod";
 import { askForDecision } from "../hooks/humanInput.js";
+import { t } from "../messages/index.js";
 const APPROVED_ANSWERS = new Set(["", "y", "yes"]);
 /** Domain-neutral defaults — a concrete agent should normally override these via `AgentSpec.humanApprovalTexts` with wording specific to what "publishing" means in its domain. */
 export const DEFAULT_HUMAN_APPROVAL_TEXTS = {
@@ -21,8 +22,8 @@ export function createHumanApprovalServer(runDir, texts = DEFAULT_HUMAN_APPROVAL
         summary: z.string().describe("Brief summary of what you're about to submit or publish"),
     }, async (args) => {
         const answer = await askForDecision(runDir, {
-            title: "Human confirmation required before publishing",
-            lines: [`Summary: ${args.summary}`],
+            title: t().approvalTitle,
+            lines: [t().summaryLine(args.summary)],
         });
         const approved = APPROVED_ANSWERS.has(answer);
         return {

package/dist/index.d.ts

@@ -9,7 +9,11 @@ export type { Mode, BaseSessionConfig, AgentSpec } from "./core/agentSpec.js";
 export { buildSessionOptions, createInputQueue, createDeferred, createModeControl, type ModeControl } from "./core/session.js";
 export { runQuery, type AgentEvent, type AgentRun, type SessionUsage, type ContextUsage } from "./core/runner.js";
 export { knowledgePluginRoot, knowledgePromptSection } from "./core/knowledge.js";
+export { resolveLanguage, detectLanguage, SUPPORTED_LANGUAGES, type Language, type LanguageSources, type ResolvedLanguage, } from "./core/language.js";
+export { setLanguage, getLanguage, messagesFor, type Messages } from "./core/messages/index.js";
+export { createRunStore, createRunFolder, listRuns, readConversation, type RunFolder, type RunSummary, type ConversationMessage, } from "./core/runs.js";
 export type { Options, McpServerConfig, AgentDefinition } from "@anthropic-ai/claude-agent-sdk";
+export { tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
 export { createTranscriptLogger, summarizeToolResponse, type TranscriptLogger } from "./core/hooks/transcriptLogger.js";
 export { createStepGate } from "./core/hooks/stepGate.js";
 export { createSubagentBashGate } from "./core/hooks/subagentBashGate.js";
@@ -23,6 +27,7 @@ export { createHumanApprovalServer, DEFAULT_HUMAN_APPROVAL_TEXTS, type HumanAppr
 export { createManualLoginServer, type ManualInterventionTexts } from "./core/tools/manualLogin.js";
 export { createSaveToSourcesServer } from "./core/tools/saveToSources.js";
 export { runChatTui, type ChatTuiOptions } from "./tui/chatTui.js";
+export type { SessionOpener } from "./tui/runs.js";
 export { createConsoleRenderer, type ConsoleRenderer, type ConsoleRendererOptions } from "./tui/consoleRenderer.js";
 export { runChatInk, type InkChatOptions, type HeaderInfo } from "./tui/ink/runChatInk.js";
 export type { ToolPhrase } from "./tui/ink/toolGroup.js";

package/dist/index.js

@@ -10,6 +10,12 @@ export { createFriendlyToolLabel, truncate, truncatePath, } from "./core/toolLab
 export { buildSessionOptions, createInputQueue, createDeferred, createModeControl } from "./core/session.js";
 export { runQuery } from "./core/runner.js";
 export { knowledgePluginRoot, knowledgePromptSection } from "./core/knowledge.js";
+export { resolveLanguage, detectLanguage, SUPPORTED_LANGUAGES, } from "./core/language.js";
+export { setLanguage, getLanguage, messagesFor } from "./core/messages/index.js";
+export { createRunStore, createRunFolder, listRuns, readConversation, } from "./core/runs.js";
+// And the two functions an agent needs for tools of its own (an in-process MCP server,
+// returned from AgentSpec.buildMcpServers()), so it doesn't need the SDK for those either.
+export { tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
 export { createTranscriptLogger, summarizeToolResponse } from "./core/hooks/transcriptLogger.js";
 export { createStepGate } from "./core/hooks/stepGate.js";
 export { createSubagentBashGate } from "./core/hooks/subagentBashGate.js";

package/dist/tui/chatTui.d.ts

@@ -1,5 +1,6 @@
 import type { Options } from "@anthropic-ai/claude-agent-sdk";
 import { type AgentEvent } from "../core/runner.js";
+import { type SessionOpener } from "./runs.js";
 export interface ChatTuiOptions {
     /**
      * Turns a tool call into a one-line console label. Defaults to `createFriendlyToolLabel()`
@@ -37,7 +38,7 @@ export interface ChatTuiOptions {
      * so a session leaves behind an exact, always-present transcript of what the terminal
      * showed even when the agent never calls a single tool (unlike `transcriptPath` from
      * `buildSessionOptions()`, which only gets written to on the first tool call). Omit to
-     * skip session logging entirely.
+     * skip session logging entirely. With `runsDir`, the run's own `session.log` is used instead.
      */
     sessionLogPath?: string;
     /**
@@ -53,6 +54,22 @@ export interface ChatTuiOptions {
     historyPath?: string;
     /** Max entries kept in `historyPath` (and in the in-session ↑/↓ list). Defaults to 100. */
     historyLimit?: number;
+    /**
+     * 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;
+    /**
+     * The agent's runs folder, with a session opener in place of the options (e.g.
+     * `(run) => buildSessionOptions(config, run.dir, spec, { run })`): each run gets its own
+     * folder (`<runsDir>/<timestamp>/`) keeping its conversation, its session log
+     * (`session.log`, instead of `sessionLogPath`) and its transcript, and can be resumed:
+     * `--continue` on the command line starts with the latest run, and `/resume` lists them
+     * (date and the human's last message) to switch to one. The runs folder holds the whole
+     * conversation, tool results included and not redacted: keep it out of version control.
+     */
+    runsDir?: string;
 }
 interface HistoryEntry {
     text: string;
@@ -97,9 +114,13 @@ export declare function drainTurn(events: AsyncIterator<AgentEvent>, onEvent: (e
  *   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 declare function runChatTui(options: Options, tuiOptions?: ChatTuiOptions): Promise<void>;
+export declare function runChatTui(options: Options | SessionOpener, tuiOptions?: ChatTuiOptions): Promise<void>;
 export {};

package/dist/tui/chatTui.js

@@ -5,9 +5,13 @@ 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 { 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 +96,27 @@ 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);
     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 +128,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 +204,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 +225,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 +293,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 +306,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.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