@falkenslab/agent-kit 0.10.1 → 0.12.0

package/README.md

@@ -1,97 +1,91 @@
-# agent-kit
-
-A foundation for building AI agents on top of the [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk). It isn't an agent itself: it solves once what every agent needs (human oversight, safety, memory and a good terminal interface), so each concrete agent only has to write what belongs to its own domain: what it knows how to do, with which tools, and how it talks.
-
-> **Status:** version `0.x`, still evolving. MIT license.
-
-## What an agent built with it can do
-
-- **Work at different levels of oversight.** Autonomous, guided (it asks for permission before anything that can't be undone or that other people will see) or step by step (it asks before every action). Within the same conversation you can switch from guided to step by step and back.
-- **Ask a person for help.** It asks for approvals, or stops so someone can do something by hand, such as signing in to a website. It can be answered from the keyboard or from another program driving it, for example a desktop app.
-- **Remember between sessions.** It keeps its own knowledge base, a small wiki of notes that grows with every session, and keeps the original documents you give it or that it downloads untouched.
-- **Delegate to subagents safely.** Only to the ones it declares, always waiting for their result, and without the main agent being able to slip past its own limits through them.
-- **Stay within limits.** It only reads and writes in the folders that belong to it, and never in protected files, such as one holding passwords.
-- **Use external tools.** MCP servers of its own or of the project, and skills and commands organized in plugins.
-- **Leave a trail.** It records every action and the whole conversation, with secrets hidden.
-- **Chat in a terminal the way Claude Code does.** Full screen, with the reply written live and its markdown already formatted, the tools it uses summed up in one line (Ctrl+O unfolds it), panels for approvals, history and search, a suggestion for the next message, pasted blocks, file mentions with `@`, mouse selection (right-click to copy), and the agent's status in the tab and in the Windows taskbar.
-- **Also work without a terminal.** The same foundation runs inside a desktop app or a server, which bring their own interface.
-
-## Examples
-
-### Captain Whiskers
-
-[Captain Whiskers](./examples/captain-whiskers) is a toy agent to see the kit in action: a retired pirate cat who tells jokes in the terminal, in Spanish. It starts full screen with its logo and has a small crew of subagents: one looks for new jokes on the web, another rates them before they're told, and a third, optional one tells the time. It lets you try the different levels of oversight and is the best starting point for an agent of your own. Its README explains how to run it.
-
-![Captain Whiskers in Windows Terminal: its logo at the top, the conversation in the middle and the framed prompt at the bottom, with a suggestion for the next message](docs/assets/captain-whiskers.png)
-
-### teacher-agent
-
-[teacher-agent](https://github.com/falkenslab/teacher-agent) is a real assistant for Moodle teachers. It signs in with your account in a Chrome window and works as you would: it grades submissions, answers in the forum, creates or reviews content and sums up how the class is going. It asks for your permission before publishing anything students will see, and takes notes about the course to remember everything in the next session.
-
-Oversight, memory, safety and the chat come from the kit; teacher-agent brings what it knows about Moodle and driving the browser.
-
-## Installation
-
-```
-npm install @falkenslab/agent-kit
-```
-
-To try changes to the kit without publishing them, point to a local clone with `"file:../agent-kit"` in your `package.json` and build it with `npm run build` after each change.
-
-Requires Node.js 20 or later.
-
-## A minimal agent
-
-An agent only describes what belongs to it (who it is, which MCP servers, skills and subagents it has) and picks a level of oversight; the kit sets up the session and the chat:
-
-```ts
-import { mkdir } from "node:fs/promises";
-import path from "node:path";
-import { buildSessionOptions, ensureClaudeAuth, runChatInk, type AgentSpec, type BaseSessionConfig } from "@falkenslab/agent-kit";
-
-// The only part specific to the agent: who it is and what it has.
-const spec: AgentSpec<BaseSessionConfig> = {
-  buildSystemPrompt: () => "You are a pirate cat who tells jokes. Always answer in character.",
-  buildMcpServers: () => ({}), // its own MCP servers, if any
-  pluginRoots: () => [], // folders with skills and commands
-  buildSubagents: () => undefined, // subagents, if it delegates to any
-};
-
-await ensureClaudeAuth(); // offers to create a Claude token if it finds none
-
-// Each session keeps its logs in a folder of its own.
-const runDir = path.resolve(".run", new Date().toISOString().replace(/[:.]/g, "-"));
-await mkdir(runDir, { recursive: true });
-
-const config: BaseSessionConfig = { mode: "guided", projectDir: process.cwd() };
-const { options, modeControl } = await buildSessionOptions(config, runDir, spec);
-
-await runChatInk(options, {
-  header: { title: "My agent" },
-  mode: config.mode,
-  modeControl, // Shift+Tab switches between guided and step by step
-  fullscreen: true,
-  sessionLogPath: path.join(runDir, "session.log"),
-});
-```
-
-Save it as `agent.ts` in a project with the kit and `tsx` installed and `"type": "module"` in its `package.json`, and run it with `npx tsx agent.ts`. Captain Whiskers is this same skeleton with more pieces: skills, subagents and its logo.
-
-## More details
-
-The specification in [`.minispec/`](./.minispec/README.md) explains how each part is built and why, including the SDK behaviors checked by hand that motivate several of its safeguards. Captain Whiskers' code is the quickest way to see how an agent is put together.
-
-## Development
-
-| Command | What it does |
-| --- | --- |
-| `npm run build` | Builds the kit into `dist/` |
-| `npm run typecheck` | Checks the types without building |
-| `npm run lint` | Checks the code style |
-| `npm test` | Runs all the tests |
-
-To run a single test file:
-
-```
-npx tsx --test test/tui/promptErrors.test.ts
-```
+# agent-kit
+
+A foundation for building AI agents on top of the [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk). It isn't an agent itself: it solves once what every agent needs (human oversight, safety, memory and a good terminal interface), so each concrete agent only has to write what belongs to its own domain: what it knows how to do, with which tools, and how it talks.
+
+## What an agent built with it can do
+
+- **Work at different levels of oversight.** Autonomous, guided (it asks for permission before anything that can't be undone or that other people will see) or step by step (it asks before every action). Within the same conversation you can switch from guided to step by step and back.
+- **Ask a person for help.** It asks for approvals, or stops so someone can do something by hand, such as signing in to a website. It can be answered from the keyboard or from another program driving it, for example a desktop app.
+- **Remember between sessions.** It keeps its own knowledge base, a small wiki of notes that grows with every session, and keeps the original documents you give it or that it downloads untouched. Each conversation stays in the project's folder, so you can pick it up again with `--continue` (the latest one) or `/resume` (any of them).
+- **Speak your language.** Its interface comes in English, Spanish, French or German, the system's by default or the one you ask for with `--language=fr`, and it answers in that language unless you write to it in another one.
+- **Delegate to subagents safely.** Only to the ones it declares, always waiting for their result, and without the main agent being able to slip past its own limits through them.
+- **Stay within limits.** It only reads and writes in the folders that belong to it, and never in protected files, such as one holding passwords.
+- **Use external tools.** MCP servers of its own or of the project, and skills and commands organized in plugins.
+- **Leave a trail.** It records every action and the whole conversation, with secrets hidden.
+- **Chat in a terminal the way Claude Code does.** Full screen, with the reply written live and its markdown already formatted, the tools it uses summed up in one line (Ctrl+O unfolds it), panels for approvals, history and search, a suggestion for the next message, pasted blocks, file mentions with `@`, mouse selection (right-click to copy), and the agent's status in the tab and in the Windows taskbar.
+- **Also work without a terminal.** The same foundation runs inside a desktop app or a server, which bring their own interface.
+
+## Examples
+
+### Captain Whiskers
+
+[Captain Whiskers](./examples/captain-whiskers) is a toy agent to see the kit in action: a retired pirate cat who tells jokes in the terminal, in your language. It starts full screen with its logo and has a small crew of subagents: one looks for new jokes on the web, another rates them before they're told, and a third tells the time with a tool of the captain's own. It lets you try the different levels of oversight and is the best starting point for an agent of your own. Its README explains how to run it.
+
+![Captain Whiskers in Windows Terminal: its logo at the top, the conversation in the middle and the framed prompt at the bottom, with a suggestion for the next message](docs/assets/captain-whiskers.png)
+
+### teacher-agent
+
+[teacher-agent](https://github.com/falkenslab/teacher-agent) is a real assistant for Moodle teachers. It signs in with your account in a Chrome window and works as you would: it grades submissions, answers in the forum, creates or reviews content and sums up how the class is going. It asks for your permission before publishing anything students will see, and takes notes about the course to remember everything in the next session.
+
+Oversight, memory, safety and the chat come from the kit; teacher-agent brings what it knows about Moodle and driving the browser.
+
+## Installation
+
+```
+npm install @falkenslab/agent-kit
+```
+
+To try changes to the kit without publishing them, point to a local clone with `"file:../agent-kit"` in your `package.json` and build it with `npm run build` after each change.
+
+Requires Node.js 20 or later.
+
+## A minimal agent
+
+An agent only describes what belongs to it (who it is, which MCP servers, skills and subagents it has) and picks a level of oversight; the kit sets up the session and the chat:
+
+```ts
+import path from "node:path";
+import { buildSessionOptions, ensureClaudeAuth, runChatInk, type AgentSpec, type BaseSessionConfig } from "@falkenslab/agent-kit";
+
+// The only part specific to the agent: who it is and what it has.
+const spec: AgentSpec<BaseSessionConfig> = {
+  buildSystemPrompt: () => "You are a pirate cat who tells jokes. Always answer in character.",
+  buildMcpServers: () => ({}), // its own MCP servers, if any
+  pluginRoots: () => [], // folders with skills and commands
+  buildSubagents: () => undefined, // subagents, if it delegates to any
+};
+
+await ensureClaudeAuth(); // offers to create a Claude token if it finds none
+
+const config: BaseSessionConfig = { mode: "guided", projectDir: process.cwd() };
+
+// Each run gets a folder of its own under .run/ (keep it out of git): its log, its
+// transcript and the conversation, to pick it up again with --continue or /resume.
+await runChatInk((run) => buildSessionOptions(config, run.dir, spec, { run }), {
+  runsDir: path.resolve(".run"),
+  header: { title: "My agent" },
+  mode: config.mode, // Shift+Tab switches between guided and step by step
+  fullscreen: true,
+});
+```
+
+Save it as `agent.ts` in a project with the kit and `tsx` installed and `"type": "module"` in its `package.json`, and run it with `npx tsx agent.ts`. Captain Whiskers is this same skeleton with more pieces: skills, subagents and its logo.
+
+## More details
+
+The specification in [`.minispec/`](./.minispec/README.md) explains how each part is built and why, including the SDK behaviors checked by hand that motivate several of its safeguards. Captain Whiskers' code is the quickest way to see how an agent is put together.
+
+## Development
+
+| Command | What it does |
+| --- | --- |
+| `npm run build` | Builds the kit into `dist/` |
+| `npm run typecheck` | Checks the types without building |
+| `npm run lint` | Checks the code style |
+| `npm test` | Runs all the tests |
+
+To run a single test file:
+
+```
+npx tsx --test test/tui/promptErrors.test.ts
+```

package/dist/core/agentSpec.d.ts

@@ -1,4 +1,4 @@
-import type { AgentDefinition as SdkSubagentDefinition, McpServerConfig } from "@anthropic-ai/claude-agent-sdk";
+import type { AgentDefinition as SdkSubagentDefinition, McpServerConfig, SettingSource } from "@anthropic-ai/claude-agent-sdk";
 /**
  * The human-supervision spectrum every agent built on this kit shares, independent of
  * domain: "interactive" pauses before every single action, "guided" only pauses before a
@@ -42,6 +42,12 @@ export interface BaseSessionConfig {
     deniedPaths?: string[];
     /** Extra values (e.g. a password) to scrub out of the transcript log — see hooks/transcriptLogger.ts. */
     secrets?: string[];
+    /**
+     * The language ("en", "es", "fr", "de") the agent replies in and the kit's interface uses.
+     * `--language=<code>` on the command line wins over it; without either, the system's
+     * language (see language.ts). Pass the same value to the chat, wizard or progress view.
+     */
+    language?: string;
 }
 /**
  * Everything actually *about the domain* that `buildSessionOptions()` needs but doesn't
@@ -103,6 +109,30 @@ export interface AgentSpec<TConfig extends BaseSessionConfig> {
      * notes) — `knowledgePromptSection()`/`knowledgePluginRoot()` are exported to reuse the pieces.
      */
     knowledgeBase?: boolean;
+    /**
+     * Whether the kit tells the agent (and each subagent) to reply in the resolved language
+     * (`config.language`, `--language`, the system's), following the human if they write in
+     * another one. On by default; `false` leaves the reply language to the agent's own prompt.
+     */
+    replyInLanguage?: boolean;
+    /**
+     * Which filesystem settings the session loads (the SDK's `settingSources`): "project" is
+     * the project's `.claude/` (settings, skills, commands) and its CLAUDE.md files, "local"
+     * its `.claude/settings.local.json`, "user" the runner's own `~/.claude/` (settings,
+     * CLAUDE.md, skills). Default `["project"]`: the runner's personal Claude Code
+     * configuration (its `language`, output style, CLAUDE.md, hooks...) never reaches the
+     * agent unless asked for with "user" — the SDK's own default loads all three, and the
+     * runner's `language` setting then outranked the agent's prompt. `[]` isolates the agent
+     * from every settings file, CLAUDE.md included.
+     */
+    settingSources?: SettingSource[];
+    /**
+     * The skills the agent offers (the SDK's `skills`): names, or `plugin:skill` for a
+     * plugin's. Default `"all"`, every skill found (the SDK's own, the project's, the
+     * plugins'). A list keeps the rest out of each turn's context; the knowledge base's own
+     * skills are added to it when the knowledge base is on. A context filter, not a sandbox.
+     */
+    skills?: string[] | "all";
     /**
      * Text for the generic human-approval checkpoint (see tools/humanApproval.ts) — what
      * counts as "publishing something visible to others" is entirely domain-specific.

package/dist/core/hooks/stepGate.js

@@ -1,4 +1,5 @@
 import { askForDecision } from "./humanInput.js";
+import { t } from "../messages/index.js";
 /**
  * PreToolUse hook for "interactive" mode: pauses before every action and asks for
  * confirmation (by keyboard or by file, see humanInput.ts), like reviewing a plan step
@@ -14,8 +15,8 @@ export function createStepGate(runDir, isActive = () => true) {
             return {};
         const pre = input;
         const answer = await askForDecision(runDir, {
-            title: "Proposed action",
-            lines: [`Tool: ${pre.tool_name}`, `Parameters: ${JSON.stringify(pre.tool_input, null, 2)}`],
+            title: t().proposedAction,
+            lines: [t().toolLine(pre.tool_name), t().parametersLine(JSON.stringify(pre.tool_input, null, 2))],
         });
         if (answer === "q") {
             return {

package/dist/core/language.d.ts

@@ -0,0 +1,39 @@
+/** The languages the kit's own texts come in. */
+export type Language = "en" | "es" | "fr" | "de";
+export declare const SUPPORTED_LANGUAGES: readonly Language[];
+/** Each language's name in English, as the model is told it (the kit's text for the model stays in English). */
+export declare const LANGUAGE_NAMES: Record<Language, string>;
+/** Where the language can come from, in order of precedence. */
+export interface LanguageSources {
+    /** The process's arguments; `--language=<code>` wins over everything else. */
+    argv?: readonly string[];
+    /** The agent's own choice (its code or configuration). */
+    option?: string;
+    /** The system's locale, e.g. "es-ES" (`Intl`). */
+    locale?: string;
+    /** The environment, for `LC_ALL`, `LC_MESSAGES` and `LANG` (e.g. "fr_FR.UTF-8"). */
+    env?: Readonly<Record<string, string | undefined>>;
+}
+export interface ResolvedLanguage {
+    language: Language;
+    /** One line per code that was asked for and isn't supported (English text, for the caller to show). */
+    warnings: string[];
+}
+/** "es", "ES", "es-ES", "es_ES.UTF-8" → "es"; anything unsupported → null. */
+export declare function toLanguage(code: string | undefined): Language | null;
+/** The value of `--language=<code>` (or `--language <code>`) in `argv`, if any. */
+export declare function languageArgument(argv: readonly string[]): string | undefined;
+/**
+ * The language for the kit's texts and the agent's replies: `--language=<code>`, then the
+ * agent's option, then the system's language, then English. A code that is asked for but
+ * isn't supported falls through to the next source, with a warning. Pure: `detectLanguage()`
+ * fills the sources from the running process.
+ */
+export declare function resolveLanguage(sources: LanguageSources): ResolvedLanguage;
+/** `resolveLanguage()` with the running process's arguments, locale and environment. */
+export declare function detectLanguage(option?: string): ResolvedLanguage;
+/**
+ * The line appended to the agent's (and each subagent's) prompt so it answers in the
+ * resolved language, but follows the human if they write in another one.
+ */
+export declare function replyLanguageInstruction(language: Language): string;

package/dist/core/language.js

@@ -0,0 +1,59 @@
+export const SUPPORTED_LANGUAGES = ["en", "es", "fr", "de"];
+/** Each language's name in English, as the model is told it (the kit's text for the model stays in English). */
+export const LANGUAGE_NAMES = { en: "English", es: "Spanish", fr: "French", de: "German" };
+/** "es", "ES", "es-ES", "es_ES.UTF-8" → "es"; anything unsupported → null. */
+export function toLanguage(code) {
+    const base = code?.trim().toLowerCase().split(/[-_.@]/)[0];
+    return SUPPORTED_LANGUAGES.find((language) => language === base) ?? null;
+}
+/** The value of `--language=<code>` (or `--language <code>`) in `argv`, if any. */
+export function languageArgument(argv) {
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg.startsWith("--language="))
+            return arg.slice("--language=".length);
+        if (arg === "--language")
+            return argv[i + 1];
+    }
+    return undefined;
+}
+/**
+ * The language for the kit's texts and the agent's replies: `--language=<code>`, then the
+ * agent's option, then the system's language, then English. A code that is asked for but
+ * isn't supported falls through to the next source, with a warning. Pure: `detectLanguage()`
+ * fills the sources from the running process.
+ */
+export function resolveLanguage(sources) {
+    const warnings = [];
+    const asked = (code, from) => {
+        if (code === undefined || code.trim() === "")
+            return null;
+        const language = toLanguage(code);
+        if (!language)
+            warnings.push(`Unsupported language "${code}" (${from}); supported: ${SUPPORTED_LANGUAGES.join(", ")}.`);
+        return language;
+    };
+    const env = sources.env ?? {};
+    const system = [sources.locale, env.LC_ALL, env.LC_MESSAGES, env.LANG].map(toLanguage).find((language) => language !== null);
+    const language = asked(sources.argv ? languageArgument(sources.argv) : undefined, "--language") ?? asked(sources.option, "language option") ?? system ?? "en";
+    return { language, warnings };
+}
+/** `resolveLanguage()` with the running process's arguments, locale and environment. */
+export function detectLanguage(option) {
+    let locale;
+    try {
+        locale = Intl.DateTimeFormat().resolvedOptions().locale;
+    }
+    catch {
+        locale = undefined;
+    }
+    return resolveLanguage({ argv: process.argv.slice(2), option, locale, env: process.env });
+}
+/**
+ * The line appended to the agent's (and each subagent's) prompt so it answers in the
+ * resolved language, but follows the human if they write in another one.
+ */
+export function replyLanguageInstruction(language) {
+    const name = LANGUAGE_NAMES[language];
+    return `Language: reply in ${name}, whatever language these instructions, your skills or the human's name are in. Switch to another language only when the human's message is clearly written in it; a greeting, a slash command or a single word doesn't count.`;
+}

package/dist/core/messages/de.d.ts

@@ -0,0 +1,2 @@
+import type { Messages } from "./en.js";
+export declare const de: Partial<Messages>;

package/dist/core/messages/de.js

@@ -0,0 +1,103 @@
+const plural = (count, one, many) => (count === 1 ? one : many);
+const MODES = { autonomous: "autonom", guided: "geführt", interactive: "interaktiv" };
+export const de = {
+    thinking: "Denkt nach…",
+    escToInterrupt: "Esc zum Unterbrechen",
+    workedFor: (seconds) => `${seconds}s gearbeitet`,
+    turns: (count) => `${count} ${plural(count, "Runde", "Runden")}`,
+    tokens: (input, output) => `${input} ein / ${output} aus`,
+    context: (percent) => `Kontext ${percent}%`,
+    mode: (mode) => MODES[mode],
+    switchModeKey: "⇧Tab",
+    modeLocked: (mode) => (mode ? `(der Modus ${MODES[mode]} kann während der Sitzung nicht gewechselt werden)` : "(der Modus kann während der Sitzung nicht gewechselt werden)"),
+    linesBelow: (count) => `↓ ${count} weitere ${plural(count, "Zeile", "Zeilen")} (Strg+Ende)`,
+    copiedCharacters: (count) => `${count} ${plural(count, "Zeichen", "Zeichen")} kopiert`,
+    queued: (line) => `in der Warteschlange: ${line}`,
+    interrupted: "(unterbrochen)",
+    copiedReply: (characters) => `(letzte Antwort kopiert: ${characters} Zeichen)`,
+    nothingToCopy: "(noch nichts zu kopieren)",
+    unknownCommand: (command) => `Unbekannter Befehl: /${command}`,
+    mcpFailed: (servers) => `Einige MCP-Server konnten keine Verbindung herstellen: ${servers}`,
+    resumeTitle: "Ein Gespräch fortsetzen",
+    resumeHint: "↑/↓ wählen · Enter fortsetzen · Esc abbrechen",
+    resumeQuestion: "Nummer des Gesprächs, das fortgesetzt werden soll (Enter zum Abbrechen): ",
+    noEarlierRuns: "(keine früheren Gespräche zum Fortsetzen)",
+    currentRun: "(dieses)",
+    resumed: (date) => `(Gespräch vom ${date} fortgesetzt)`,
+    suggestionKey: "Tab",
+    reverseSearch: (query) => `(Rückwärtssuche)'${query}': `,
+    pastedText: (id, extraLines) => `[Eingefügter Text #${id} +${extraLines} ${plural(extraLines, "Zeile", "Zeilen")}]`,
+    shortcuts: [
+        "Enter senden  ·  \\ + Enter oder Strg+J neue Zeile  ·  Tab vervollständigen oder den Vorschlag übernehmen",
+        "↑/↓ Verlauf  ·  Strg+R im Verlauf suchen  ·  ↑ bei leerer Eingabe bearbeitet die letzte wartende Nachricht",
+        "Strg+W Wort löschen  ·  Strg+K bis zum Zeilenende  ·  Strg+U leeren  ·  Strg+←/→ wortweise bewegen",
+        "@ eine Datei erwähnen  ·  /copy letzte Antwort kopieren  ·  Umschalt+Tab Modus wechseln  ·  Strg+O Werkzeuge aufklappen",
+        "Esc unterbrechen  ·  Strg+C unterbrechen oder beenden  ·  Bild↑/Bild↓ oder Mausrad scrollen  ·  Strg+Ende ganz nach unten",
+        "Ziehen zum Markieren, Rechtsklick zum Kopieren (Vollbild)",
+        "/resume ein früheres Gespräch fortsetzen  ·  --continue beim Start setzt das letzte fort",
+    ],
+    moreLines: (count) => `… (${count} weitere Zeilen)`,
+    proceed: "Möchtest du fortfahren?",
+    yes: "Ja",
+    no: "Nein",
+    stop: "Anhalten",
+    doneContinue: "Erledigt, weiter",
+    approved: "✔ Genehmigt",
+    rejected: "✘ Abgelehnt",
+    stopped: "■ Angehalten",
+    done: "✔ Erledigt",
+    answeredByFile: "(über die Antwortdatei beantwortet)",
+    terminalQuestion: "Fortfahren erlauben? [Y/n/q] ",
+    proposedAction: "Vorgeschlagene Aktion",
+    toolLine: (tool) => `Werkzeug: ${tool}`,
+    parametersLine: (parameters) => `Parameter: ${parameters}`,
+    approvalTitle: "Vor dem Veröffentlichen ist eine menschliche Bestätigung nötig",
+    summaryLine: (summary) => `Zusammenfassung: ${summary}`,
+    toolPhrases: {
+        Read: ["hat {n} Datei gelesen", "hat {n} Dateien gelesen"],
+        Write: ["hat {n} Datei geschrieben", "hat {n} Dateien geschrieben"],
+        Edit: ["hat {n} Datei bearbeitet", "hat {n} Dateien bearbeitet"],
+        Glob: ["hat Dateien aufgelistet", "hat {n}-mal Dateien aufgelistet"],
+        Grep: ["hat {n}-mal gesucht", "hat {n}-mal gesucht"],
+        Bash: ["hat {n} Befehl ausgeführt", "hat {n} Befehle ausgeführt"],
+        WebSearch: ["hat im Web gesucht", "hat {n}-mal im Web gesucht"],
+        WebFetch: ["hat {n} Seite geöffnet", "hat {n} Seiten geöffnet"],
+        Skill: ["hat {n} Skill verwendet", "hat {n} Skills verwendet"],
+        Agent: ["hat {n} Subagenten gestartet", "hat {n} Subagenten gestartet"],
+        Task: ["hat {n} Subagenten gestartet", "hat {n} Subagenten gestartet"],
+    },
+    otherTools: ["hat {n} Werkzeug verwendet", "hat {n} Werkzeuge verwendet"],
+    noOutput: "(keine Ausgabe)",
+    error: "Fehler",
+    moreResultLines: (count) => `(+${count} ${plural(count, "Zeile", "Zeilen")})`,
+    earlierCalls: (count) => `… ${count} frühere`,
+    labels: {
+        askingApproval: (summary) => `Bittet um menschliche Genehmigung: ${summary}`,
+        waitingManual: "Wartet auf einen manuellen Eingriff",
+        savingToSources: (destination) => `Speichert eine Datei in sources/${destination}`,
+        reading: (file) => `Liest ${file}`,
+        writing: (file) => `Schreibt in ${file}`,
+        editing: (file) => `Bearbeitet ${file}`,
+        aFile: "eine Datei",
+        findingFiles: (pattern) => `Sucht Dateien, die zu "${pattern}" passen`,
+        searchingContents: (pattern) => `Sucht "${pattern}" in den Dateien`,
+        running: (command) => `Führt "${command}" aus`,
+        delegating: (subagent) => `Delegiert an "${subagent}"`,
+        delegatingTask: (subagent, description) => `Delegiert an "${subagent}": ${description}`,
+        aSubagent: "einen Subagenten",
+        fetching: (url) => `Öffnet ${url}`,
+        aPage: "eine Seite",
+        searchingWeb: (query) => `Sucht im Web nach "${query}"`,
+        applyingSkill: (skill) => `Wendet den Skill "${skill}" an`,
+        aSkill: "einen Skill",
+    },
+    auth: {
+        noToken: "Es wurde kein Claude-Authentifizierungstoken gefunden",
+        noTokenDetail: "(weder die Umgebungsvariable CLAUDE_CODE_OAUTH_TOKEN noch ein im Code übergebenes).",
+        generateQuestion: 'Jetzt eines mit "claude setup-token" erzeugen? (erfordert ein Claude-Pro/Max-Abonnement)',
+        cantStart: "Der Agent kann ohne Token nicht starten. Setze CLAUDE_CODE_OAUTH_TOKEN von Hand (oder starte erneut und lass es erzeugen) und versuche es noch einmal.",
+        generatingHeading: "=== Claude-Authentifizierungstoken wird erzeugt ===",
+        browserWillOpen: "Zum Anmelden öffnet sich ein Browser; folge den Anweisungen, die der Befehl unten ausgibt.",
+        generated: "Token für diese Ausführung erzeugt. Speichere es selbst (z. B. CLAUDE_CODE_OAUTH_TOKEN im Profil deiner Shell), um diesen Schritt beim nächsten Mal zu überspringen.",
+    },
+};

package/dist/core/messages/en.d.ts

@@ -0,0 +1,90 @@
+import type { Mode } from "../agentSpec.js";
+/** How a tool counts in a folded group's summary: the phrase for one call and for several, "{n}" standing for the count. */
+export type ToolPhrase = [one: string, many: string];
+/**
+ * Every text the kit shows a person, in one language. Texts for the model (tool
+ * descriptions, hook deny reasons, the knowledge base's prompt section) aren't here: they
+ * stay in English whatever the language.
+ */
+export interface Messages {
+    thinking: string;
+    escToInterrupt: string;
+    workedFor(seconds: number): string;
+    turns(count: number): string;
+    tokens(input: string, output: string): string;
+    context(percent: number): string;
+    mode(mode: Mode): string;
+    switchModeKey: string;
+    modeLocked(mode: Mode | undefined): string;
+    linesBelow(count: number): string;
+    copiedCharacters(count: number): string;
+    queued(line: string): string;
+    interrupted: string;
+    copiedReply(characters: number): string;
+    nothingToCopy: string;
+    unknownCommand(command: string): string;
+    mcpFailed(servers: string): string;
+    resumeTitle: string;
+    resumeHint: string;
+    resumeQuestion: string;
+    noEarlierRuns: string;
+    currentRun: string;
+    resumed(date: string): string;
+    suggestionKey: string;
+    reverseSearch(query: string): string;
+    pastedText(id: number, extraLines: number): string;
+    shortcuts: string[];
+    moreLines(count: number): string;
+    proceed: string;
+    yes: string;
+    no: string;
+    stop: string;
+    doneContinue: string;
+    approved: string;
+    rejected: string;
+    stopped: string;
+    done: string;
+    answeredByFile: string;
+    terminalQuestion: string;
+    proposedAction: string;
+    toolLine(tool: string): string;
+    parametersLine(parameters: string): string;
+    approvalTitle: string;
+    summaryLine(summary: string): string;
+    toolPhrases: Record<string, ToolPhrase>;
+    otherTools: ToolPhrase;
+    noOutput: string;
+    error: string;
+    moreResultLines(count: number): string;
+    earlierCalls(count: number): string;
+    labels: {
+        askingApproval(summary: string): string;
+        waitingManual: string;
+        savingToSources(destination: string): string;
+        reading(file: string): string;
+        writing(file: string): string;
+        editing(file: string): string;
+        aFile: string;
+        findingFiles(pattern: string): string;
+        searchingContents(pattern: string): string;
+        running(command: string): string;
+        delegating(subagent: string): string;
+        delegatingTask(subagent: string, description: string): string;
+        aSubagent: string;
+        fetching(url: string): string;
+        aPage: string;
+        searchingWeb(query: string): string;
+        applyingSkill(skill: string): string;
+        aSkill: string;
+    };
+    auth: {
+        noToken: string;
+        noTokenDetail: string;
+        generateQuestion: string;
+        cantStart: string;
+        generatingHeading: string;
+        browserWillOpen: string;
+        generated: string;
+    };
+}
+export declare const en: Messages;