@falkenslab/agent-kit 0.10.2 → 0.13.0

package/dist/core/runs.js

@@ -0,0 +1,194 @@
+import { appendFile, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+const CONVERSATION = "conversation.jsonl";
+const SUBAGENTS = "subagents";
+const SESSION = "session.json";
+/** A folder name for a new run, e.g. "2026-09-09T16-50-12-345Z" (sorts by date). */
+export function runFolderName(date = new Date()) {
+    return date.toISOString().replace(/[:.]/g, "-");
+}
+/** Creates a new, empty run folder under `runsDir`. */
+export async function createRunFolder(runsDir) {
+    const dir = path.join(runsDir, runFolderName());
+    await mkdir(dir, { recursive: true });
+    return { dir, sessionId: null };
+}
+async function readSessionFile(dir) {
+    try {
+        const parsed = JSON.parse(await readFile(path.join(dir, SESSION), "utf8"));
+        return typeof parsed.sessionId === "string" ? { sessionId: parsed.sessionId, subagents: parsed.subagents ?? {} } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The SDK session a run folder keeps, from its `session.json`, or null. */
+export async function readRunSession(dir) {
+    return (await readSessionFile(dir))?.sessionId ?? null;
+}
+async function readEntries(file) {
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    return raw
+        .split("\n")
+        .filter((line) => line.trim())
+        .map((line) => JSON.parse(line));
+}
+/** A readable, unused file name for a subagent's transcript, from its key (e.g. "subagents/agent-a67…"). */
+function subagentFileName(subpath, taken) {
+    const name = subpath.replace(/^subagents\//, "").replace(/[^A-Za-z0-9._-]+/g, "_") || "agent";
+    let file = `${SUBAGENTS}/${name}.jsonl`;
+    for (let n = 2; taken.includes(file); n++)
+        file = `${SUBAGENTS}/${name}-${n}.jsonl`;
+    return file;
+}
+/**
+ * A `SessionStore` (the SDK's adapter for keeping transcripts elsewhere) that keeps one
+ * session in one run folder: `conversation.jsonl` for the main transcript,
+ * `subagents/*.jsonl` for each subagent's, and `session.json` with the session's id and
+ * which file is which subagent's. The SDK appends to it as the transcript grows and loads
+ * from it before resuming (confirmed empirically: a resumed session remembers the
+ * conversation, its subagents' transcripts included, even with the CLI's own copy deleted).
+ * The CLI still writes that copy under `~/.claude/projects/`: it can't be turned off while a
+ * store is in use.
+ *
+ * Bound to one folder, so every key it receives is taken as this run's session: one run
+ * folder is one conversation, resumed as many times as wanted (the session keeps its id).
+ */
+export function createRunStore(dir) {
+    const seen = new Set();
+    let session = null;
+    // Appends are chained: the SDK may call append() again before the last one has finished,
+    // and entries must keep their order.
+    let queue = Promise.resolve();
+    async function currentSession() {
+        session ??= await readSessionFile(dir);
+        return session;
+    }
+    async function saveSession(next) {
+        session = next;
+        await mkdir(dir, { recursive: true });
+        await writeFile(path.join(dir, SESSION), `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    }
+    /** The file for a key; with `create`, registers the session (and a new subagent) in session.json. */
+    async function fileFor(key, create) {
+        const current = await currentSession();
+        if (!key.subpath) {
+            if (create && !current)
+                await saveSession({ sessionId: key.sessionId, subagents: {} });
+            return path.join(dir, CONVERSATION);
+        }
+        const known = current?.subagents[key.subpath];
+        if (known)
+            return path.join(dir, known);
+        if (!create)
+            return null;
+        const base = current ?? { sessionId: key.sessionId, subagents: {} };
+        const file = subagentFileName(key.subpath, Object.values(base.subagents));
+        await saveSession({ ...base, subagents: { ...base.subagents, [key.subpath]: file } });
+        return path.join(dir, file);
+    }
+    async function write(key, entries) {
+        // Retries and replays may send an entry again: its uuid, when it has one, says so.
+        const fresh = entries.filter((entry) => {
+            if (!entry.uuid)
+                return true;
+            const id = `${key.subpath ?? ""}:${entry.uuid}`;
+            if (seen.has(id))
+                return false;
+            seen.add(id);
+            return true;
+        });
+        if (fresh.length === 0)
+            return;
+        const file = (await fileFor(key, true));
+        await mkdir(path.dirname(file), { recursive: true });
+        await appendFile(file, fresh.map((entry) => `${JSON.stringify(entry)}\n`).join(""), "utf8");
+    }
+    return {
+        append(key, entries) {
+            queue = queue.then(() => write(key, entries));
+            return queue;
+        },
+        async load(key) {
+            const file = await fileFor(key, false);
+            const entries = file ? await readEntries(file) : null;
+            // What's already there counts as seen: resuming must not append it twice.
+            for (const entry of entries ?? [])
+                if (entry.uuid)
+                    seen.add(`${key.subpath ?? ""}:${entry.uuid}`);
+            return entries;
+        },
+        async listSubkeys() {
+            return Object.keys((await currentSession())?.subagents ?? {});
+        },
+    };
+}
+/** A transcript entry's text when it's something the human wrote or the agent replied, or null. */
+export function entryText(entry) {
+    if (entry.type !== "user" && entry.type !== "assistant")
+        return null;
+    if (entry.isMeta || entry.isSidechain)
+        return null;
+    const content = entry.message?.content;
+    let text = "";
+    if (typeof content === "string")
+        text = content;
+    else if (Array.isArray(content)) {
+        const parts = content;
+        // A user entry holding tool results isn't something the human wrote.
+        if (entry.type === "user" && parts.some((part) => part.type === "tool_result"))
+            return null;
+        text = parts
+            .filter((part) => part.type === "text")
+            .map((part) => part.text ?? "")
+            .join("");
+    }
+    // Slash commands and the CLI's own notes arrive as tagged text, not as the human's words.
+    if (!text.trim() || /^\s*<[a-z-]+>/.test(text))
+        return null;
+    return { role: entry.type, text };
+}
+/** The human's messages and the agent's replies in a run's conversation, in order. */
+export async function readConversation(dir) {
+    const entries = (await readEntries(path.join(dir, CONVERSATION))) ?? [];
+    return entries.map(entryText).filter((message) => message !== null);
+}
+/** The runs under `runsDir` that kept a conversation, newest first; runs without `session.json` are left out. */
+export async function listRuns(runsDir) {
+    let names;
+    try {
+        names = (await readdir(runsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+    const runs = [];
+    for (const name of names) {
+        const dir = path.join(runsDir, name);
+        const sessionId = await readRunSession(dir);
+        if (!sessionId)
+            continue;
+        const entries = (await readEntries(path.join(dir, CONVERSATION))) ?? [];
+        const times = entries.map((entry) => Date.parse(entry.timestamp ?? "")).filter((ms) => !Number.isNaN(ms));
+        const human = entries.map(entryText).filter((message) => message?.role === "user");
+        runs.push({
+            dir,
+            sessionId,
+            updatedAt: new Date(times.length > 0 ? Math.max(...times) : 0),
+            lastMessage: (human.at(-1)?.text ?? "").replace(/\s+/g, " ").trim(),
+        });
+    }
+    return runs.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+}
+/** `--continue` among the process's arguments: start by resuming the latest run. */
+export function continueArgument(argv) {
+    return argv.includes("--continue");
+}

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
@@ -39,6 +47,7 @@ export interface ModeControl {
     /** Switches to `next` if this session allows it; returns whether it did. */
     set(next: Mode): boolean;
 }
+/** A `ModeControl` starting at `initial` (`buildSessionOptions()` returns one for its session). */
 export declare function createModeControl(initial: Mode): ModeControl;
 /**
  * User message queue backed by a single long-lived generator, for any multi-turn

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,8 +177,16 @@ 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;
 }
+/** A `ModeControl` starting at `initial` (`buildSessionOptions()` returns one for its session). */
 export function createModeControl(initial) {
     let current = initial;
     const switchable = initial === "autonomous" ? ["autonomous"] : ["guided", "interactive"];

package/dist/core/toolLabels.d.ts

@@ -5,10 +5,17 @@
  * 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/).
  */
+/** Cuts `text` to `max` characters, with "…" at the end. */
 export declare function truncate(text: string, max?: number): string;
+/**
+ * Cuts a path to `max` characters from the front, with "…": unlike `truncate()` (which cuts
+ * the tail off long freeform text), a path's most useful part, the file name, is at the end.
+ */
 export declare function truncatePath(text: string, max?: number): string;
+/** An agent's labels for its own tools: the tool's short name and input, to a label, or `undefined` for the kit's default. */
 export type ToolDescriber = (shortName: string, input: Record<string, unknown>) => string | undefined;
 /**
  * Builds a `friendlyToolLabel(toolName, toolInput)` — `describe` lets the host agent

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,78 +6,59 @@
  * 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/).
  */
+/** Cuts `text` to `max` characters, with "…" at the end. */
 export function truncate(text, max = 60) {
     return text.length > max ? `${text.slice(0, max)}…` : text;
 }
-// Unlike truncate() above (which cuts the tail off long freeform text), a path's most
-// useful part — the filename — is at the *end*, so this keeps the tail and cuts the
-// front instead.
+/**
+ * Cuts a path to `max` characters from the front, with "…": unlike `truncate()` (which cuts
+ * the tail off long freeform text), a path's most useful part, the file name, is at the end.
+ */
 export function truncatePath(text, max = 60) {
     return text.length > max ? `…${text.slice(text.length - max + 1)}` : text;
 }
 /** 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.d.ts

@@ -1,3 +1,4 @@
+/** The approval tool's texts: its description (when the model should call it) and what it returns when approved or rejected. */
 export interface HumanApprovalTexts {
     description: string;
     approved: string;

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/core/tools/manualLogin.d.ts

@@ -1,3 +1,4 @@
+/** The manual-intervention tool's texts: for the model (`toolDescription`, `confirmedMessage`) and for the person (the checkpoint). */
 export interface ManualInterventionTexts {
     toolDescription: string;
     confirmedMessage: string;

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * as ui from "./tui/ui.js";
+export { setTheme, getTheme, DEFAULT_THEME, type Theme, type ThemeColor } from "./tui/theme.js";
 export { isExitPromptError } from "./tui/promptErrors.js";
 export { allowAnyMcpTool } from "./core/mcpPermissions.js";
 export { createPromptLoader } from "./core/promptTemplate.js";
@@ -9,7 +10,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 +28,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

@@ -1,6 +1,7 @@
 import { setInteractionPort } from "./core/interaction.js";
 import { terminalInteractionPort } from "./tui/terminalInteraction.js";
 export * as ui from "./tui/ui.js";
+export { setTheme, getTheme, DEFAULT_THEME } from "./tui/theme.js";
 export { isExitPromptError } from "./tui/promptErrors.js";
 export { allowAnyMcpTool } from "./core/mcpPermissions.js";
 export { createPromptLoader } from "./core/promptTemplate.js";
@@ -10,6 +11,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,8 @@
 import type { Options } from "@anthropic-ai/claude-agent-sdk";
 import { type AgentEvent } from "../core/runner.js";
+import { type Theme } from "./theme.js";
+import { type SessionOpener } from "./runs.js";
+/** Options of the chats (`runChatTui()`, and `runChatInk()` through `InkChatOptions`). */
 export interface ChatTuiOptions {
     /**
      * Turns a tool call into a one-line console label. Defaults to `createFriendlyToolLabel()`
@@ -37,7 +40,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 +56,28 @@ 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;
+    /**
+     * Colors for the kit's roles (see `Theme`), on top of the kit's defaults: only the roles
+     * given change, e.g. `{ toolResult: "yellow", selection: "#00ff00" }`. One theme per
+     * process: without this option, the one already set stays.
+     */
+    theme?: Partial<Theme>;
 }
 interface HistoryEntry {
     text: string;
@@ -97,9 +122,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 {};