@falkenslab/agent-kit 0.14.0 → 0.16.0

package/dist/core/hooks/planGate.js

@@ -1,8 +1,17 @@
 import path from "node:path";
-/** Built-in tools that only read, search, load a skill or delegate (a subagent's own calls come through this gate too). */
-const READING_TOOLS = new Set(["Read", "Glob", "Grep", "WebFetch", "WebSearch", "Skill", "Agent"]);
-/** The kit's own MCP tools that only ask a human: approvals and manual intervention. */
-const ASKING_SERVERS = ["mcp__approvals__", "mcp__manualLogin__"];
+/** Built-in tools that only read, search, load a skill, delegate or keep the task list (a subagent's own calls come through this gate too). */
+const READING_TOOLS = new Set(["Read", "Glob", "Grep", "WebFetch", "WebSearch", "Skill", "Agent", "TodoWrite"]);
+/** The kit's own MCP servers whose tools only ask a human (approvals, manual intervention) or only read (the date and time). */
+const ASKING_SERVERS = ["mcp__approvals__", "mcp__manualLogin__", "mcp__time__"];
+/** The kit's own MCP tools that only read, on servers that also have tools that write. */
+const READING_KIT_TOOLS = new Set([
+    "mcp__sourceFiles__list_sources",
+    "mcp__sourceFiles__extract_text",
+    "mcp__knowledge__knowledge_index",
+    "mcp__knowledge__knowledge_search",
+    "mcp__knowledge__knowledge_read",
+    "mcp__knowledge__knowledge_check",
+]);
 /** Why a call is denied in plan mode, and what the model should do instead. */
 const denial = "Plan mode: nothing can be changed until the user leaves plan mode. Keep reading and researching, then present the plan; the user switches out of plan mode when they want it carried out.";
 /**
@@ -13,7 +22,7 @@ const denial = "Plan mode: nothing can be changed until the user leaves plan mod
 export function checkPlanScope(scope, toolName, input) {
     if (READING_TOOLS.has(toolName))
         return undefined;
-    if (ASKING_SERVERS.some((prefix) => toolName.startsWith(prefix)))
+    if (ASKING_SERVERS.some((prefix) => toolName.startsWith(prefix)) || READING_KIT_TOOLS.has(toolName))
         return undefined;
     if (toolName === "Write" || toolName === "Edit") {
         const target = typeof input.file_path === "string" && input.file_path !== "" ? path.resolve(scope.projectDir, input.file_path) : undefined;

package/dist/core/hooks/stepGate.js

@@ -1,5 +1,7 @@
 import { askForDecision } from "./humanInput.js";
 import { t } from "../messages/index.js";
+const SELF_ASKING_SERVERS = ["mcp__approvals__", "mcp__manualLogin__"];
+const SELF_ASKING_TOOLS = new Set(["mcp__sourceFiles__request_file", "mcp__sourceFiles__retire_source", "mcp__knowledge__knowledge_retire", "TodoWrite"]);
 /**
  * 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,6 +16,10 @@ export function createStepGate(runDir, isActive = () => true) {
         if (!isActive())
             return {};
         const pre = input;
+        // A tool that asks the person itself (an approval, a question, the plan, a file, retiring
+        // a source) or only keeps the task list isn't asked about first: that would be asking to ask.
+        if (SELF_ASKING_SERVERS.some((prefix) => pre.tool_name.startsWith(prefix)) || SELF_ASKING_TOOLS.has(pre.tool_name))
+            return {};
         const answer = await askForDecision(runDir, {
             title: t().proposedAction,
             lines: [t().toolLine(pre.tool_name), t().parametersLine(JSON.stringify(pre.tool_input, null, 2))],

package/dist/core/interaction.d.ts

@@ -4,6 +4,13 @@ export interface ApprovalPrompt {
     lines: string[];
     /** Terminal question text; defaults to the approve/reject one. */
     question?: string;
+    /** The lines are markdown (a plan): a UI that can render it should. */
+    markdown?: boolean;
+}
+/** How `askChoice()` asks: the options to pick from, and whether several can be picked. */
+export interface ChoiceSettings {
+    options: readonly string[];
+    multiple: boolean;
 }
 /**
  * The UI side of a human-in-the-loop checkpoint: how a host shows the question and reads a
@@ -23,6 +30,19 @@ export interface InteractionPort {
     askDecision(prompt: ApprovalPrompt, signal: AbortSignal): Promise<string>;
     /** Waits until the person confirms they intervened by hand (e.g. logged in). */
     askManualIntervention(prompt: ApprovalPrompt, signal: AbortSignal): Promise<string>;
+    /**
+     * A free-text answer (e.g. the path of a file the agent asked for), with case and spaces
+     * kept; "" for none. Optional: without it the kit asks through `askDecision()`, whose
+     * answer a plain terminal reads as text too.
+     */
+    askText?(prompt: ApprovalPrompt, signal: AbortSignal): Promise<string>;
+    /**
+     * A choice between options. Resolves to the raw answer: the chosen options' numbers
+     * (1-based, comma-separated, "1" or "1,3") on the first line, and the person's own answer
+     * ("Other") on the lines after it, or alone. Optional: without it the kit asks through
+     * `askDecision()`, with the options numbered in the prompt.
+     */
+    askChoice?(prompt: ApprovalPrompt, choice: ChoiceSettings, signal: AbortSignal): Promise<string>;
     /** A one-way message for the person. */
     notify(message: string): void;
 }

package/dist/core/knowledge.d.ts

@@ -1,3 +1,4 @@
+import type { PageType } from "./knowledgeStore.js";
 /**
  * The built-in knowledge base (an "LLM wiki"): `sourcesDir` holds the originals, `knowledgeDir`
  * is the wiki the agent writes and maintains, and the rules below plus the plugin's skills
@@ -6,10 +7,19 @@
  * with its own page types (topics, activities...) opts out with `AgentSpec.knowledgeBase: false` and
  * writes its own rules, or extends these.
  */
-/** Absolute path of the plugin shipped with the kit — `assets/knowledge-plugin` next to `dist/` (or `src/` under tsx). */
-export declare function knowledgePluginRoot(): string;
+/**
+ * Absolute path of the plugin shipped with the kit, next to `dist/` (or `src/` under tsx):
+ * `assets/knowledge-plugin`, whose skills work through the `knowledge_*` tools, or with
+ * `"files"` `assets/knowledge-plugin-files`, whose skills work on the files (ADR-024).
+ */
+export declare function knowledgePluginRoot(variant?: "tools" | "files"): string;
 /**
  * The "Knowledge base" section appended to the system prompt: the layout and the working
- * rules. The exact page templates live in the `knowledge-pages` skill, to keep this short.
+ * rules. With `tools` (the kit's default since ADR-024), for a knowledge base reached through
+ * the `knowledge_*` tools, listing `pageTypes`; otherwise for one kept with the file tools,
+ * whose page templates live in the `knowledge-pages` skill.
  */
-export declare function knowledgePromptSection(projectDir: string, knowledgeDir: string, sourcesDir?: string): string;
+export declare function knowledgePromptSection(projectDir: string, knowledgeDir: string, sourcesDir?: string, options?: {
+    tools?: boolean;
+    pageTypes?: readonly PageType[];
+}): string;

package/dist/core/knowledge.js

@@ -8,26 +8,56 @@ import { fileURLToPath } from "node:url";
  * with its own page types (topics, activities...) opts out with `AgentSpec.knowledgeBase: false` and
  * writes its own rules, or extends these.
  */
-/** Absolute path of the plugin shipped with the kit — `assets/knowledge-plugin` next to `dist/` (or `src/` under tsx). */
-export function knowledgePluginRoot() {
-    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "assets", "knowledge-plugin");
+/**
+ * Absolute path of the plugin shipped with the kit, next to `dist/` (or `src/` under tsx):
+ * `assets/knowledge-plugin`, whose skills work through the `knowledge_*` tools, or with
+ * `"files"` `assets/knowledge-plugin-files`, whose skills work on the files (ADR-024).
+ */
+export function knowledgePluginRoot(variant = "tools") {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "assets", variant === "files" ? "knowledge-plugin-files" : "knowledge-plugin");
 }
 /** A path as shown to the model: relative to the project, forward slashes, with a trailing slash. */
 function shown(projectDir, dir) {
     return `${path.relative(projectDir, dir).split(path.sep).join("/")}/`;
 }
+/** The originals' line of the prompt section, the same in both variants. */
+function originalsLine(originals) {
+    return `- **Originals (read-only for you)**: \`${originals}\`. Never rewrite one; build pages *about* them. \`list_sources\` says which are new (not ingested yet), changed since their ingest or missing; add a file only with \`save_to_sources\`, \`download_to_sources\` or by asking the person (\`request_file\`), and take out a wrong or superseded one only with \`retire_source\`. \`Read\` reads PDFs and images; \`extract_text\` reads DOCX, PPTX (with speaker notes) and XLSX.\n`;
+}
+/** The section for a knowledge base reached through the `knowledge_*` tools (ADR-024). */
+function toolsSection(originals, pageTypes) {
+    return `## Knowledge base
+Your memory across sessions is an interlinked knowledge base of pages that you write and maintain yourself — a wiki, not a pile of notes. A future session only knows what is written there, so anything worth remembering must end up in a page, not just in this turn's reply. You reach it only through the \`knowledge_*\` tools. Write page content in the language you are using with the human.
+
+### Layers
+${originals ? originalsLine(originals) : ""}- **The knowledge base**: pages identified by type and slug (\`concept/spring-tides\`), plus the \`overview\`, a living synthesis of the whole. Page types: ${pageTypes.map((type) => `\`${type.type}\` (${type.description})`).join("; ")}.
+- **The schema**: these rules plus the \`knowledge-ingest\`, \`knowledge-query\` and \`knowledge-lint\` skills. \`knowledge_create\` without content gives a type's template.
+
+### Working rules
+- Start from \`knowledge_search\` or \`knowledge_index\`, then \`knowledge_read\` only the pages the task needs.
+- Link pages by id, \`[Spring tides](concept/spring-tides)\`; links must point to existing pages. The index and the backlinks ("linked from") are kept for you.
+- Change a page with \`knowledge_edit\` (a fragment); \`knowledge_rewrite\` only to redo it whole. Pages are never deleted or renamed: \`knowledge_supersede\` one replaced by another; \`knowledge_retire\` one that was wrong.
+- When an operation is done, \`knowledge_log\` it: \`ingest\`, \`query\`, \`lint\` or \`update\`, with the pages touched.
+- Every claim must be traceable to a summary page, an original, or — clearly labelled as outside the knowledge base — the web.
+- Contradictions are kept, not overwritten: record both versions with attribution in the affected pages.
+- Short, focused, well-linked pages beat long ones: when a page mixes two things, split it.`;
+}
 /**
  * The "Knowledge base" section appended to the system prompt: the layout and the working
- * rules. The exact page templates live in the `knowledge-pages` skill, to keep this short.
+ * rules. With `tools` (the kit's default since ADR-024), for a knowledge base reached through
+ * the `knowledge_*` tools, listing `pageTypes`; otherwise for one kept with the file tools,
+ * whose page templates live in the `knowledge-pages` skill.
  */
-export function knowledgePromptSection(projectDir, knowledgeDir, sourcesDir) {
+export function knowledgePromptSection(projectDir, knowledgeDir, sourcesDir, options = {}) {
     const notes = shown(projectDir, knowledgeDir);
     const originals = sourcesDir ? shown(projectDir, sourcesDir) : undefined;
+    if (options.tools)
+        return toolsSection(originals, options.pageTypes ?? []);
     return `## Knowledge base (${notes})
 \`${notes}\` is your memory across sessions, kept as an interlinked knowledge base of markdown pages that you write and maintain yourself — a wiki, not a pile of notes. A future session only knows what is written there, so anything worth remembering must end up in a page, not just in this turn's reply. Write page content in the language you are using with the human; file names stay lowercase ASCII with hyphens.
 
 ### Layers
-${originals ? `- **Originals (read-only for you)**: \`${originals}\`. Never rewrite one; build pages *about* them. Add a file there only with \`save_to_sources\`.\n` : ""}- **The knowledge base**: \`${notes}\`, entirely yours to write.
+${originals ? originalsLine(originals) : ""}- **The knowledge base**: \`${notes}\`, entirely yours to write.
 - **The schema**: these rules plus the \`knowledge-pages\` skill (exact template of every page type — load it before creating a page) and the \`knowledge-ingest\`, \`knowledge-query\` and \`knowledge-lint\` skills.
 
 ### Layout

package/dist/core/knowledgeStore.d.ts

@@ -0,0 +1,134 @@
+/**
+ * The knowledge base as pages, not files (ADR-024): the agent reaches it only through the
+ * kit's `knowledge_*` tools, which sit on this interface, so the storage can change (markdown
+ * files today, a vector database tomorrow) without touching the tools, the prompt or the
+ * skills. A page is identified by its type and slug, `concept/bowline`, and links between
+ * pages use that id too: `[Bowline](concept/bowline)`.
+ */
+/** A kind of page: the kit's four, or one an agent declares (`AgentSpec.knowledgePageTypes`). */
+export interface PageType {
+    /** Its name, lowercase: `concept`, `topic`. Page ids start with it. */
+    type: string;
+    /** Where a file store keeps its pages, relative to the knowledge folder; "" for the root. */
+    dir: string;
+    /** Its section in the index, e.g. "Concepts". */
+    indexSection: string;
+    /** What it holds and when to create one, in one line: told to the model. */
+    description: string;
+    /** The page's body skeleton (markdown, under its title), shown when one is created. */
+    template: string;
+    /** Frontmatter fields shown in the page's index line, e.g. `["mastery"]`. */
+    indexFields?: string[];
+}
+/** One page, as the store returns it. */
+export interface KnowledgePage {
+    id: string;
+    type: string;
+    slug: string;
+    title: string;
+    /** Frontmatter fields besides type and title (aliases, file, url, updated, status...). */
+    fields: Record<string, string>;
+    /** The markdown body, links to other pages as ids. */
+    content: string;
+    /** The pages that link to this one. */
+    linkedFrom: string[];
+}
+/** A page's line in a listing. */
+export interface PageInfo {
+    id: string;
+    type: string;
+    title: string;
+    /** One line: its `description` field, or its first sentence. */
+    description: string;
+    /** `active`, `superseded` or `retired`. */
+    status: string;
+    fields: Record<string, string>;
+}
+export interface SearchHit {
+    id: string;
+    title: string;
+    /** Where it matched, one line. */
+    snippet: string;
+}
+/** What `check()` finds: the mechanical problems, for the agent to fix or report. */
+export interface CheckReport {
+    /** Links to pages that don't exist. */
+    brokenLinks: {
+        page: string;
+        target: string;
+    }[];
+    /** Pages nothing links to (summaries and syntheses aside, which the index reaches). */
+    orphans: string[];
+    /** Links to retired pages. */
+    linksToRetired: {
+        page: string;
+        target: string;
+    }[];
+    /** Summary pages whose original is gone from the sources folder. */
+    missingOriginals: {
+        page: string;
+        file: string;
+    }[];
+}
+/** A page to create. */
+export interface NewPage {
+    type: string;
+    slug: string;
+    title: string;
+    content: string;
+    fields?: FieldChanges;
+}
+/** A change to a page's frontmatter fields: a string sets it, null removes it. */
+export type FieldChanges = Record<string, string | null>;
+/**
+ * Where the knowledge base lives. The kit ships one over markdown files
+ * (`createFileKnowledgeStore()`); another one (a database, a vector store) implements this
+ * interface and is passed with `AgentSpec.knowledgeStore`. Pages are never deleted or renamed:
+ * their ids are what links point to.
+ */
+export interface KnowledgeStore {
+    /** The page types it holds, the kit's and the agent's. */
+    types(): readonly PageType[];
+    /** Every page but the retired ones. */
+    list(): Promise<PageInfo[]>;
+    /** A page, retired ones included; `null` if there's none. */
+    read(id: string): Promise<KnowledgePage | null>;
+    /** A new page; fails if the id exists or a link points nowhere. Returns its id. */
+    create(type: string, slug: string, title: string, content: string, fields?: FieldChanges): Promise<string>;
+    /**
+     * Several new pages at once, whose links may point to each other (a summary and the
+     * concepts it feeds): all are created, or none. Returns their ids.
+     */
+    createMany(pages: readonly NewPage[]): Promise<string[]>;
+    /** Replaces the one occurrence of `oldText` in a page's body; fails if it's missing or appears more than once. */
+    edit(id: string, oldText: string, newText: string, fields?: FieldChanges): Promise<void>;
+    /** Replaces a page's whole body, keeping its id. */
+    rewrite(id: string, content: string, fields?: FieldChanges): Promise<void>;
+    /** Marks a page superseded by another, with a notice at its top. */
+    supersede(id: string, by: string, reason?: string): Promise<void>;
+    /** Takes a page out of the index and the search (it's kept, and can be restored). */
+    retire(id: string, reason: string): Promise<void>;
+    /** Pages matching words of `query` in their title, aliases or body, best first. */
+    search(query: string, limit?: number): Promise<SearchHit[]>;
+    /** The catalog: every active or superseded page, one line each, by section. */
+    index(): Promise<string>;
+    /** Adds an entry to the operation log, dated today. */
+    log(operation: string, what: string, pages?: readonly string[]): Promise<void>;
+    /** The mechanical problems. */
+    check(): Promise<CheckReport>;
+    /** The overview: a living synthesis of the whole knowledge base ("" if none yet). */
+    overview(): Promise<string>;
+    /** Replaces the overview. */
+    writeOverview(content: string): Promise<void>;
+}
+/** The kit's page types (ADR-008). */
+export declare const BUILT_IN_PAGE_TYPES: readonly PageType[];
+/** Whether `slug` is lowercase ASCII words joined by hyphens. */
+export declare function isSlug(slug: string): boolean;
+/** `type/slug` split, or null when it isn't one. */
+export declare function parseId(id: string): {
+    type: string;
+    slug: string;
+} | null;
+/** The ids every `[text](id)` link in `markdown` points to (links that look like page ids). */
+export declare function linkedIds(markdown: string): string[];

package/dist/core/knowledgeStore.js

@@ -0,0 +1,84 @@
+/**
+ * The knowledge base as pages, not files (ADR-024): the agent reaches it only through the
+ * kit's `knowledge_*` tools, which sit on this interface, so the storage can change (markdown
+ * files today, a vector database tomorrow) without touching the tools, the prompt or the
+ * skills. A page is identified by its type and slug, `concept/bowline`, and links between
+ * pages use that id too: `[Bowline](concept/bowline)`.
+ */
+/** The kit's page types (ADR-008). */
+export const BUILT_IN_PAGE_TYPES = [
+    {
+        type: "summary",
+        dir: "summaries",
+        indexSection: "Summaries",
+        description: "One per ingested source: what it says, its key points and the pages it feeds. Fields: file (the original, relative to sources/) or url; ingested.",
+        template: `## Summary
+<Two to four paragraphs: what it actually says.>
+
+## Key points
+- <Claims, definitions or figures likely to be needed later, quoted literally when exact wording matters.>
+
+## Pages it feeds
+- [<Concept or entity>](concept/<slug>)
+
+## New or surprising
+- <What this source adds to what the knowledge base already had.>
+
+## Contradictions
+- <Conflicts with other pages, linked.>`,
+    },
+    {
+        type: "concept",
+        dir: "concepts",
+        indexSection: "Concepts",
+        description: "One idea per page: its definition, explanation, connections and sources. Fields: aliases (other names, comma-separated).",
+        template: `<Definition in one or two sentences.>
+
+## Explanation
+<How it works, at the depth the sources give.>
+
+## Connections
+- Requires: [<Concept>](concept/<slug>)
+- Related: [<Concept>](concept/<slug>) - how
+
+## Sources
+- [<Summary>](summary/<slug>) - what it says about this
+
+## Contradictions and open questions
+- "<Source A> says X; <source B> says Y" - both attributed.`,
+    },
+    {
+        type: "entity",
+        dir: "entities",
+        indexSection: "Entities",
+        description: "A concrete thing: a system, component, organization or document (a person only as a public role). Fields: kind, aliases.",
+        template: `<What it is, one or two sentences.>
+
+## Facts
+- <Attributed facts, each linking the summary it comes from.>
+
+## Connections
+- [<Concept or entity>](concept/<slug>) - how`,
+    },
+    {
+        type: "synthesis",
+        dir: "syntheses",
+        indexSection: "Syntheses",
+        description: "An answer worth keeping: a comparison, an analysis, a report. Fields: question.",
+        template: `<The answer, with links to every page it draws on.>`,
+    },
+];
+const SLUG = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+/** Whether `slug` is lowercase ASCII words joined by hyphens. */
+export function isSlug(slug) {
+    return SLUG.test(slug);
+}
+/** `type/slug` split, or null when it isn't one. */
+export function parseId(id) {
+    const match = /^([a-z][a-z0-9-]*)\/([a-z0-9]+(?:-[a-z0-9]+)*)$/.exec(id.trim());
+    return match ? { type: match[1], slug: match[2] } : null;
+}
+/** The ids every `[text](id)` link in `markdown` points to (links that look like page ids). */
+export function linkedIds(markdown) {
+    return [...markdown.matchAll(/\]\(([a-z][a-z0-9-]*\/[a-z0-9]+(?:-[a-z0-9]+)*)(?:#[^)]*)?\)/g)].map((m) => m[1]);
+}

package/dist/core/messages/de.js

@@ -54,6 +54,29 @@ export const de = {
     parametersLine: (parameters) => `Parameter: ${parameters}`,
     approvalTitle: "Vor dem Veröffentlichen ist eine menschliche Bestätigung nötig",
     summaryLine: (summary) => `Zusammenfassung: ${summary}`,
+    noAnswer: "(keine Antwort)",
+    textAnswerHint: "Antwort eingeben",
+    textAnswerKeys: "Enter zum Senden · Esc für keine Antwort",
+    fileRequestTitle: "Der Agent bittet um eine Datei",
+    fileRequestQuestion: "Pfad der Datei (hierher ziehen), oder Enter, wenn du sie nicht hast: ",
+    retireTitle: "Eine Quelle zurückziehen?",
+    retirePageTitle: "Eine Seite der Wissensbasis zurückziehen?",
+    choiceQuestion: (multiple) => (multiple ? "Nummern durch Kommas getrennt, oder deine eigene Antwort: " : "Nummer, oder deine eigene Antwort: "),
+    otherOption: "Andere (eigene Antwort eingeben)",
+    choiceKeys: (multiple) => (multiple ? "Leertaste markiert · Enter sendet" : "↑/↓ wählen · Enter sendet"),
+    questionTitle: "Der Agent fragt",
+    planTitle: "Der Plan, zur Freigabe",
+    runPlan: "Ausführen",
+    keepPlanning: "Weiter planen",
+    cancelPlan: "Abbrechen",
+    planCommentQuestion: "Was soll sich ändern? (Enter zum Überspringen): ",
+    retireLines: (source, why, reason, replacedBy) => [
+        `Quelle: ${source}`,
+        why === "wrong" ? "Warum: sie ist falsch; ihre Zusammenfassung wird zurückgezogen" : "Warum: sie wird ersetzt; ihre Zusammenfassung wird als ersetzt markiert",
+        `Grund: ${reason}`,
+        ...(replacedBy ? [`Ersetzt durch: ${replacedBy}`] : []),
+        "Sie wird nach sources/.agent-kit/retired/ verschoben, nicht gelöscht.",
+    ],
     toolPhrases: {
         Read: ["hat {n} Datei gelesen", "hat {n} Dateien gelesen"],
         Write: ["hat {n} Datei geschrieben", "hat {n} Dateien geschrieben"],
@@ -66,16 +89,40 @@ export const de = {
         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"],
+        mcp__time__current_time: ["Uhrzeit abgefragt", "Uhrzeit {n}-mal abgefragt"],
+        mcp__time__date_math: ["Daten berechnet", "Daten {n}-mal berechnet"],
+        mcp__sourceFiles__list_sources: ["Quellen geprüft", "Quellen {n}-mal geprüft"],
+        mcp__sourceFiles__extract_text: ["{n} Dokument gelesen", "{n} Dokumente gelesen"],
+        mcp__sourceFiles__save_to_sources: ["{n} Quelle gespeichert", "{n} Quellen gespeichert"],
+        mcp__sourceFiles__download_to_sources: ["{n} Quelle heruntergeladen", "{n} Quellen heruntergeladen"],
+        mcp__sourceFiles__request_file: ["um {n} Datei gebeten", "um {n} Dateien gebeten"],
+        mcp__sourceFiles__retire_source: ["{n} Quelle zurückgezogen", "{n} Quellen zurückgezogen"],
+        mcp__knowledge__knowledge_index: ["Index gelesen", "Index {n}-mal gelesen"],
+        mcp__knowledge__knowledge_search: ["Wissensbasis durchsucht", "Wissensbasis {n}-mal durchsucht"],
+        mcp__knowledge__knowledge_read: ["{n} Seite gelesen", "{n} Seiten gelesen"],
+        mcp__knowledge__knowledge_create: ["{n} Seite angelegt", "{n} Seiten angelegt"],
+        mcp__knowledge__knowledge_edit: ["{n} Seite bearbeitet", "{n} Seiten bearbeitet"],
+        mcp__knowledge__knowledge_rewrite: ["{n} Seite neu geschrieben", "{n} Seiten neu geschrieben"],
+        mcp__knowledge__knowledge_supersede: ["{n} Seite ersetzt", "{n} Seiten ersetzt"],
+        mcp__knowledge__knowledge_retire: ["{n} Seite zurückgezogen", "{n} Seiten zurückgezogen"],
+        mcp__knowledge__knowledge_log: ["Protokoll aktualisiert", "Protokoll {n}-mal aktualisiert"],
+        mcp__knowledge__knowledge_check: ["Wissensbasis geprüft", "Wissensbasis {n}-mal geprüft"],
+        mcp__approvals__ask_human: ["{n} Frage gestellt", "{n} Fragen gestellt"],
+        mcp__approvals__present_plan: ["Plan vorgelegt", "Plan {n}-mal vorgelegt"],
     },
     otherTools: ["hat {n} Werkzeug verwendet", "hat {n} Werkzeuge verwendet"],
     noOutput: "(keine Ausgabe)",
     error: "Fehler",
+    toolFailed: "Konnte nicht abgeschlossen werden",
     moreResultLines: (count) => `(+${count} ${plural(count, "Zeile", "Zeilen")})`,
     earlierCalls: (count) => `… ${count} frühere`,
+    moreTodos: (count) => `… ${count} weitere ${plural(count, "Aufgabe", "Aufgaben")}`,
     labels: {
         askingApproval: (summary) => `Bittet um menschliche Genehmigung: ${summary}`,
         waitingManual: "Wartet auf einen manuellen Eingriff",
         savingToSources: (destination) => `Speichert eine Datei in sources/${destination}`,
+        checkingTime: "Datum und Uhrzeit abfragen",
+        calculatingDates: "Daten berechnen",
         reading: (file) => `Liest ${file}`,
         writing: (file) => `Schreibt in ${file}`,
         editing: (file) => `Bearbeitet ${file}`,
@@ -91,6 +138,24 @@ export const de = {
         searchingWeb: (query) => `Sucht im Web nach "${query}"`,
         applyingSkill: (skill) => `Wendet den Skill "${skill}" an`,
         aSkill: "einen Skill",
+        updatingTasks: "Aufgabenliste aktualisieren",
+        listingSources: "Quellen prüfen",
+        extractingText: (source) => `${source} lesen`,
+        downloading: (url) => `${url} in die Quellen herunterladen`,
+        requestingFile: (description) => `Um eine Datei bitten: ${description}`,
+        retiringSource: (source) => `Quelle ${source} zurückziehen`,
+        knowledgeIndex: "Index der Wissensbasis lesen",
+        knowledgeSearch: (query) => `Wissensbasis nach "${query}" durchsuchen`,
+        knowledgeRead: (page) => `${page} lesen`,
+        knowledgeCreate: (page) => `${page} anlegen`,
+        knowledgeEdit: (page) => `${page} bearbeiten`,
+        knowledgeRewrite: (page) => `${page} neu schreiben`,
+        knowledgeSupersede: (page) => `${page} als ersetzt markieren`,
+        knowledgeRetire: (page) => `${page} zurückziehen`,
+        knowledgeLog: "Protokoll der Wissensbasis aktualisieren",
+        knowledgeCheck: "Wissensbasis prüfen",
+        askingHuman: (question) => `Frage: ${question}`,
+        presentingPlan: "Plan vorlegen",
     },
     auth: {
         noToken: "Es wurde kein Claude-Authentifizierungstoken gefunden",

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

@@ -51,16 +51,39 @@ export interface Messages {
     parametersLine(parameters: string): string;
     approvalTitle: string;
     summaryLine(summary: string): string;
+    noAnswer: string;
+    textAnswerHint: string;
+    textAnswerKeys: string;
+    fileRequestTitle: string;
+    fileRequestQuestion: string;
+    retireTitle: string;
+    retirePageTitle: string;
+    choiceQuestion(multiple: boolean): string;
+    otherOption: string;
+    choiceKeys(multiple: boolean): string;
+    questionTitle: string;
+    planTitle: string;
+    runPlan: string;
+    keepPlanning: string;
+    cancelPlan: string;
+    planCommentQuestion: string;
+    retireLines(source: string, why: "wrong" | "replaced", reason: string, replacedBy?: string): string[];
     toolPhrases: Record<string, ToolPhrase>;
     otherTools: ToolPhrase;
     noOutput: string;
     error: string;
+    /** A failed tool call when results are hidden (`toolDetail: "calls"`): no tool output, just that it failed. */
+    toolFailed: string;
     moreResultLines(count: number): string;
     earlierCalls(count: number): string;
+    /** Tasks of the task list left out of the view. */
+    moreTodos(count: number): string;
     labels: {
         askingApproval(summary: string): string;
         waitingManual: string;
         savingToSources(destination: string): string;
+        checkingTime: string;
+        calculatingDates: string;
         reading(file: string): string;
         writing(file: string): string;
         editing(file: string): string;
@@ -76,6 +99,24 @@ export interface Messages {
         searchingWeb(query: string): string;
         applyingSkill(skill: string): string;
         aSkill: string;
+        updatingTasks: string;
+        listingSources: string;
+        extractingText(source: string): string;
+        downloading(url: string): string;
+        requestingFile(description: string): string;
+        retiringSource(source: string): string;
+        knowledgeIndex: string;
+        knowledgeSearch(query: string): string;
+        knowledgeRead(page: string): string;
+        knowledgeCreate(page: string): string;
+        knowledgeEdit(page: string): string;
+        knowledgeRewrite(page: string): string;
+        knowledgeSupersede(page: string): string;
+        knowledgeRetire(page: string): string;
+        knowledgeLog: string;
+        knowledgeCheck: string;
+        askingHuman(question: string): string;
+        presentingPlan: string;
     };
     auth: {
         noToken: string;