@falkenslab/agent-kit 0.16.1 → 0.18.0

package/dist/core/tools/humanApproval.js

@@ -34,8 +34,8 @@ export function createHumanApprovalServer(runDir, texts = DEFAULT_HUMAN_APPROVAL
         };
     });
     const askHuman = tool("ask_human", "Ask the person to choose between options, in a panel, and get the answer in this same turn, instead of ending your turn with a written question. Use it when you need their decision to go on (which approach, which of several items). They can also type their own answer.", {
-        question: z.string().describe("The question, in one sentence, in the person's language"),
-        options: z.array(z.string()).min(2).max(8).describe("The options, short, in the person's language (2 to 8; an \"Other\" for their own answer is added)"),
+        question: z.string().describe("The question, in one sentence, in the language you reply in"),
+        options: z.array(z.string()).min(2).max(8).describe("The options, short, in the language you reply in (2 to 8; an \"Other\" for their own answer is added)"),
         multiple: z.boolean().optional().describe("Whether they can pick several (default: one)"),
     }, async (args) => {
         const answer = await askForChoice(runDir, { title: t().questionTitle, lines: [args.question] }, args.options, args.multiple ?? false);
@@ -46,7 +46,7 @@ export function createHumanApprovalServer(runDir, texts = DEFAULT_HUMAN_APPROVAL
         return ok(parts.length ? parts.join("\n") : "The person didn't answer. Go on with what you can, or ask in your reply.");
     });
     const control = options.modeControl;
-    const presentPlan = tool("present_plan", "In plan mode, when the plan is ready: show it to the person, who decides to run it (plan mode ends and you carry it out right away, in this turn), to keep planning (with a comment on what to change) or to cancel. Outside plan mode it's refused.", { plan: z.string().describe("The whole plan, in markdown, in the person's language: steps, what changes, what to check") }, async (args) => {
+    const presentPlan = tool("present_plan", "In plan mode, when the plan is ready: show it to the person, who decides to run it (plan mode ends and you carry it out right away, in this turn), to keep planning (with a comment on what to change) or to cancel. Outside plan mode it's refused.", { plan: z.string().describe("The whole plan, in markdown, in the language you reply in: steps, what changes, what to check") }, async (args) => {
         if (!control || control.mode !== "plan")
             return { ...ok("present_plan only works in plan mode: you aren't in it, so just go ahead."), isError: true };
         const choices = [t().runPlan, t().keepPlanning, t().cancelPlan];

package/dist/core/tools/knowledgeTools.d.ts

@@ -1,16 +1,16 @@
 import type { KnowledgeStore } from "../knowledgeStore.js";
+/**
+ * Text as the model meant it: a body that arrives with escaped newlines ("\\n") and no real
+ * one gets them back. A model sometimes double-escapes a long markdown argument, and the page
+ * would be stored as one line with literal "\n"s (found by a real session).
+ */
+export declare function unescapedText(text: string): string;
 /** Options of `createKnowledgeServer()`. */
 export interface KnowledgeToolsOptions {
     /** This run's folder (for the response file of `knowledge_retire`'s approval). */
     runDir: string;
     /** A person can be asked (not autonomous): adds `knowledge_retire`, which asks first. */
     interactive?: boolean;
-    /** The sources folder: summaries record their original's hash, and `knowledge_check` reports new, changed and missing originals. */
-    sourcesDir?: string;
-    /** The project root, for `list_sources`' paths. */
-    projectDir?: string;
-    /** The knowledge folder, for `list_sources`' ingest status. */
-    knowledgeDir?: string;
 }
 /** The `knowledge` MCP server over `store`. */
 export declare function createKnowledgeServer(store: KnowledgeStore, options: KnowledgeToolsOptions): import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;

package/dist/core/tools/knowledgeTools.js

@@ -1,7 +1,5 @@
-import path from "node:path";
 import { tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
 import { z } from "zod";
-import { listSources, loadManifest, recordIngest } from "../sources.js";
 import { askForDecision } from "../hooks/humanInput.js";
 import { t } from "../messages/index.js";
 /**
@@ -21,6 +19,14 @@ async function attempt(work) {
         return fail(message(error));
     }
 }
+/**
+ * Text as the model meant it: a body that arrives with escaped newlines ("\\n") and no real
+ * one gets them back. A model sometimes double-escapes a long markdown argument, and the page
+ * would be stored as one line with literal "\n"s (found by a real session).
+ */
+export function unescapedText(text) {
+    return !text.includes("\n") && text.includes("\\n") ? text.replace(/\\r\\n|\\n/g, "\n").replace(/\\t/g, "\t") : text;
+}
 const OVERVIEW = "overview";
 const LOG = "log";
 /** The `knowledge` MCP server over `store`. */
@@ -31,20 +37,8 @@ export function createKnowledgeServer(store, options) {
     const fields = z
         .array(z.object({ name: z.string(), value: z.string().nullable() }))
         .optional()
-        .describe('Frontmatter fields to set (value null removes one), e.g. [{"name": "aliases", "value": "tide range, tidal range"}]; for a summary, "file" is its original relative to sources/');
+        .describe('Frontmatter fields to set (value null removes one), e.g. [{"name": "aliases", "value": "tide range, tidal range"}]; for a summary, "file" is its original as list_sources names it (its "ingested" is set for you)');
     const changes = (pairs) => pairs ? Object.fromEntries(pairs.map(({ name, value }) => [name, value])) : undefined;
-    /** A summary written from an original: record its hash, so "changed" means changed after this. */
-    async function ingested(id) {
-        if (!options.sourcesDir || !id.startsWith("summary/"))
-            return;
-        const page = await store.read(id);
-        const file = page?.fields.file;
-        if (!file || /^[a-z]+:\/\//i.test(file))
-            return;
-        const knowledgeDir = options.knowledgeDir;
-        const original = knowledgeDir ? path.resolve(knowledgeDir, "summaries", file) : path.resolve(options.sourcesDir, file);
-        await recordIngest(options.sourcesDir, path.relative(options.sourcesDir, original));
-    }
     const index = tool("knowledge_index", "The knowledge base's catalog: every page, one line each (title, id, what it is), by section. Start here, then read only the pages the task needs.", {}, async () => attempt(async () => (await store.list()).length ? await store.index() : "The knowledge base is empty."), { annotations: { readOnlyHint: true } });
     const search = tool("knowledge_search", "Find pages by words: in titles, aliases and content, best first, with the line that matched. Search before creating a page, so you don't duplicate one under another name.", { query: z.string().describe("Words to look for"), limit: z.number().int().positive().max(50).optional() }, async (args) => attempt(async () => {
         const hits = await store.search(args.query, args.limit ?? 10);
@@ -71,7 +65,7 @@ export function createKnowledgeServer(store, options) {
         .join("; ")}. Without content, returns the type's template: fill it and call again. Links to other pages are ids, [Bowline](concept/bowline), and must exist, or be created in the same call (\`also\`); the index is kept for you.`, {
         type: z.enum(typeNames),
         slug: z.string().describe('Lowercase ASCII words joined by hyphens, e.g. "spring-tides"'),
-        title: z.string().describe("The page's title, in the person's language"),
+        title: z.string().describe("The page's title, in the language you reply in"),
         content: z.string().optional().describe("The page's markdown body (under its title), following the type's template"),
         fields,
         also: z
@@ -87,34 +81,30 @@ export function createKnowledgeServer(store, options) {
     }, async (args) => attempt(async () => {
         const type = store.types().find((t) => t.type === args.type);
         if (!args.content)
-            return `Template for a ${type.type} page (${type.description}):\n\n${type.template}\n\nFill it in the person's language and call knowledge_create again with content.`;
+            return `Template for a ${type.type} page (${type.description}):\n\n${type.template}\n\nFill it in the language you reply in and call knowledge_create again with content.`;
         const ids = await store.createMany([
-            { type: args.type, slug: args.slug, title: args.title, content: args.content, fields: changes(args.fields) },
-            ...(args.also ?? []).map((page) => ({ ...page, fields: changes(page.fields) })),
+            { type: args.type, slug: args.slug, title: args.title, content: unescapedText(args.content), fields: changes(args.fields) },
+            ...(args.also ?? []).map((page) => ({ ...page, content: unescapedText(page.content), fields: changes(page.fields) })),
         ]);
-        for (const id of ids)
-            await ingested(id);
         return `Created ${ids.join(", ")}.`;
     }));
     const edit = tool("knowledge_edit", "Change one fragment of a page: oldText (exactly as knowledge_read returned it, unique in the page) becomes newText. Prefer it to rewriting a page.", { page: z.string(), oldText: z.string(), newText: z.string(), fields }, async (args) => attempt(async () => {
-        await store.edit(args.page, args.oldText, args.newText, changes(args.fields));
-        await ingested(args.page);
+        await store.edit(args.page, unescapedText(args.oldText), unescapedText(args.newText), changes(args.fields));
         return `Edited ${args.page}.`;
     }));
     const rewrite = tool("knowledge_rewrite", 'Replace a page\'s whole content, keeping its id and the links to it: for a page redone from a better source, or the "overview" (the living synthesis of the whole knowledge base). For small changes use knowledge_edit.', { page: z.string().describe('The page id, or "overview"'), content: z.string(), fields }, async (args) => attempt(async () => {
         if (args.page === OVERVIEW) {
-            await store.writeOverview(args.content);
+            await store.writeOverview(unescapedText(args.content));
             return "Rewrote the overview.";
         }
-        await store.rewrite(args.page, args.content, changes(args.fields));
-        await ingested(args.page);
+        await store.rewrite(args.page, unescapedText(args.content), changes(args.fields));
         return `Rewrote ${args.page}.`;
     }));
     const supersede = tool("knowledge_supersede", "Mark a page superseded by another one (it stays, with a notice pointing to the new one). Pages are never deleted or renamed.", { page: z.string(), by: z.string().describe("The page that replaces it"), reason: z.string().optional() }, async (args) => attempt(async () => {
         await store.supersede(args.page, args.by, args.reason);
         return `${args.page} is now superseded by ${args.by}. Repoint the links that should go to the new page.`;
     }));
-    const retire = tool("knowledge_retire", "Retire a page whose knowledge was wrong (e.g. learned from a wrong original), after the person approves: it leaves the index and the search but is kept. Then fix the pages that link to it (knowledge_check lists them).", { page: z.string(), reason: z.string().describe("Why, in one sentence, in the person's language") }, async (args) => attempt(async () => {
+    const retire = tool("knowledge_retire", "Retire a page whose knowledge was wrong (e.g. learned from a wrong original). It asks the person itself, with a panel: don't ask them first. Retired, it leaves the index and the search but is kept. Then fix the pages that link to it (knowledge_check lists them).", { page: z.string(), reason: z.string().describe("Why, in one sentence, in the language you reply in") }, async (args) => attempt(async () => {
         const page = await store.read(args.page);
         if (!page)
             throw new Error(`There's no page "${args.page}".`);
@@ -134,32 +124,7 @@ export function createKnowledgeServer(store, options) {
         await store.log(args.operation, args.what, args.pages ?? []);
         return "Logged.";
     }));
-    const check = tool("knowledge_check", "The knowledge base's mechanical problems in one call: broken links, orphan pages, links to retired pages, summaries whose original is gone, originals that are new, changed or missing, and the passages that cite a retired original. Fix what's mechanical; report what needs the person.", {}, async () => attempt(async () => {
-        const report = { ...(await store.check()) };
-        if (options.sourcesDir) {
-            const sources = await listSources(options.sourcesDir, options.knowledgeDir, options.projectDir ?? path.dirname(options.sourcesDir));
-            report.newOriginals = sources.filter((s) => s.status === "new").map((s) => s.path);
-            report.changedOriginals = sources.filter((s) => s.status === "changed").map((s) => ({ path: s.path, summaries: s.summaries }));
-            report.missingFromSources = sources.filter((s) => s.status === "missing").map((s) => s.path);
-            const retired = (await loadManifest(options.sourcesDir)).retired;
-            if (retired.length) {
-                const citations = [];
-                for (const info of await store.list()) {
-                    const page = await store.read(info.id);
-                    for (const original of retired) {
-                        const name = path.basename(original.path);
-                        for (const line of (page?.content ?? "").split(/\r?\n/))
-                            if (line.includes(name))
-                                citations.push({ original: original.path, page: info.id, passage: line.trim() });
-                        if (page?.fields.file?.endsWith(name) && info.status === "active")
-                            citations.push({ original: original.path, page: info.id, passage: `file: ${page.fields.file}` });
-                    }
-                }
-                report.citesRetiredOriginals = citations;
-            }
-        }
-        return JSON.stringify(report, null, 2);
-    }), { annotations: { readOnlyHint: true } });
+    const check = tool("knowledge_check", "The knowledge base's mechanical problems in one call: broken links, orphan pages and links to retired pages. Fix what's mechanical; report what needs the person. Whether its summaries are up to date with their originals is a comparison you make: list_sources' changedAt against each summary's ingested (knowledge_index shows them): both ISO 8601 in UTC, the later one sorts after as text.", {}, async () => attempt(async () => JSON.stringify(await store.check(), null, 2)), { annotations: { readOnlyHint: true } });
     return createSdkMcpServer({
         name: "knowledge",
         version: "1.0.0",

package/dist/core/tools/saveToSources.d.ts

@@ -8,10 +8,14 @@ export declare const MAX_SOURCE_BYTES: number;
 export declare function htmlToMarkdown(html: string, url: string): Promise<string | null>;
 /** Downloads `url` into `file`, refusing other schemes and anything over `maxBytes`; returns its content type. */
 export declare function downloadToFile(url: string, file: string, maxBytes: number): Promise<string>;
+/**
+ * The "Sources" section appended to the system prompt whenever there's a sources folder, with or
+ * without a knowledge base: what the originals are and how they come and go. `projectDir` and
+ * `sourcesDir` give the folder's name as the model reads it.
+ */
+export declare function sourcesPromptSection(projectDir: string, sourcesDir: string): string;
 /** Options of `createSaveToSourcesServer()`. */
 export interface SourceToolsOptions {
-    /** The knowledge folder, to tell which originals have a summary page (`list_sources`). */
-    knowledgeDir?: string;
     /** The project root: paths in the tools' answers are relative to it. Defaults to the parent of `sourcesDir`. */
     projectDir?: string;
     /** A person can be asked (not autonomous): adds `request_file` and `retire_source`, which ask first. */

package/dist/core/tools/saveToSources.js

@@ -104,6 +104,16 @@ export async function downloadToFile(url, file, maxBytes) {
     await writeFile(file, Buffer.concat(chunks));
     return response.headers.get("content-type") ?? "";
 }
+/**
+ * The "Sources" section appended to the system prompt whenever there's a sources folder, with or
+ * without a knowledge base: what the originals are and how they come and go. `projectDir` and
+ * `sourcesDir` give the folder's name as the model reads it.
+ */
+export function sourcesPromptSection(projectDir, sourcesDir) {
+    const folder = `${path.relative(projectDir, sourcesDir).split(path.sep).join("/") || "."}/`;
+    return `## Sources
+- **Originals (read-only for you)**: \`${folder}\`. Never rewrite one; build on them. \`list_sources\` lists them with when each one's content last changed (\`changedAt\`), and the missing and retired ones; 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.`;
+}
 /**
  * The tools that keep `sourcesDir`, the originals the agent reads but never edits (Write/Edit
  * are scoped to the notes folder, see hooks/fileScopeGate.ts): `save_to_sources`,
@@ -149,9 +159,9 @@ export function createSaveToSourcesServer(runDir, sourcesDir, description = DEFA
             return fail(message(error));
         }
     });
-    const listSourcesTool = tool("list_sources", "List the originals in sources/ with their status: new (no summary page points to it: ingest it), ingested, changed (it changed after its ingest: update its summary), missing (deleted by hand) or present (no knowledge base to compare with); with type, size, pages of a PDF or slides of a PPTX (read long ones in parts), provenance, the version it replaces and its summary pages. Use it instead of listing the folder.", {}, async () => {
+    const listSourcesTool = tool("list_sources", "List the originals in sources/: present, missing (deleted by hand) or retired (when, why, what replaced it); with changedAt (when its content last changed, ISO 8601 in UTC: a later date sorts after as text, to compare with when something was built from it), type, size, pages of a PDF or slides of a PPTX (read long ones in parts), provenance and the version it replaces. Use it instead of listing the folder.", {}, async () => {
         try {
-            return ok(JSON.stringify(await listSources(sourcesDir, options.knowledgeDir, projectDir), null, 2));
+            return ok(JSON.stringify(await listSources(sourcesDir), null, 2));
         }
         catch (error) {
             return fail(message(error));
@@ -215,7 +225,7 @@ export function createSaveToSourcesServer(runDir, sourcesDir, description = DEFA
         }
     });
     const requestFile = tool("request_file", "Ask the person for a file you need (a syllabus, a document they have) and copy it into sources/ with its provenance. They give a path or say they don't have it; never overwrites, and doesn't copy a file identical to one already there.", {
-        description: z.string().describe("What file you need and why, in one or two sentences, in the person's language"),
+        description: z.string().describe("What file you need and why, in one or two sentences, in the language you reply in"),
         destination: z.string().optional().describe("Path to save it under, relative to sources/; the file's own name if omitted"),
         replaces,
     }, async (args) => {
@@ -235,23 +245,18 @@ export function createSaveToSourcesServer(runDir, sourcesDir, description = DEFA
             return fail(message(error));
         }
     });
-    const retire = tool("retire_source", 'Retire an original that was wrong ("wrong") or replaced by a better one ("replaced"), after the person approves it: it\'s moved to sources/.agent-kit/retired/ (never deleted), and its summary page is marked retired (wrong) or superseded, pointing to the replacement\'s summary (replaced). Afterwards, update the index and correct or re-ground the pages that cited it.', {
+    const retire = tool("retire_source", 'Retire an original that was wrong ("wrong") or replaced by a better one ("replaced"). It asks the person itself, with a panel: don\'t ask them first. Approved, it\'s moved to sources/.agent-kit/retired/ (never deleted), and list_sources shows it as retired. What you built from it is yours to review afterwards.', {
         source: z.string().describe("The original, relative to sources/"),
         why: z.enum(["wrong", "replaced"]),
-        reason: z.string().describe("Why, in one sentence, in the person's language"),
+        reason: z.string().describe("Why, in one sentence, in the language you reply in"),
         replacedBy: z.string().optional().describe('For "replaced": the original that replaces it, relative to sources/'),
     }, async (args) => {
         const answer = await askForDecision(runDir, { title: t().retireTitle, lines: t().retireLines(inFolder(args.source), args.why, args.reason, args.replacedBy && inFolder(args.replacedBy), folder) });
         if (answer !== "" && answer !== "y" && answer !== "yes")
             return ok(answer === "q" ? "The person stopped: don't retire it, and stop what you were doing." : "The person said no: the original stays.");
         try {
-            const result = await retireSource(sourcesDir, options.knowledgeDir, projectDir, inFolder(args.source), args.why, args.reason, args.replacedBy && inFolder(args.replacedBy));
-            const pages = result.summaries.map((s) => `${s.page} marked ${s.marked}${s.supersededBy ? ` (see ${s.supersededBy})` : ""}`);
-            return ok([
-                `Retired: moved to sources/${result.movedTo}.`,
-                ...(pages.length ? pages : ["It had no summary page."]),
-                "Now update index.md, and correct or re-ground the pages that cite it (search the knowledge base for its file name).",
-            ].join("\n"));
+            const result = await retireSource(sourcesDir, inFolder(args.source), args.why, args.reason, args.replacedBy && inFolder(args.replacedBy));
+            return ok(`Retired: moved to sources/${result.movedTo}. If anything was built from it (a summary, notes that cite it), review it now: ${args.why === "wrong" ? "what it taught was wrong" : `it was replaced${args.replacedBy ? ` by sources/${inFolder(args.replacedBy)}` : ""}`}.`);
         }
         catch (error) {
             return fail(message(error));

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export { createPromptLoader } from "./core/promptTemplate.js";
 export { resolveClaudeAuth, type ClaudeAuthConfig } from "./core/claudeAuth.js";
 export { ensureClaudeAuth } from "./tui/claudeAuth.js";
 export { createFriendlyToolLabel, truncate, truncatePath, type ToolDescriber, } from "./core/toolLabels.js";
-export type { Mode, BaseSessionConfig, AgentSpec, PlanModeSpec } from "./core/agentSpec.js";
+export type { Mode, BaseSessionConfig, AgentSpec, AgentIdentity, PlanModeSpec } from "./core/agentSpec.js";
 export { buildSessionOptions, createInputQueue, createDeferred, createModeControl, togglePlanMode, 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";
@@ -31,7 +31,7 @@ export { setInteractionPort, getInteractionPort, type InteractionPort, type Appr
 export { terminalInteractionPort, setSharedReadline, getSharedReadline } from "./tui/terminalInteraction.js";
 export { createHumanApprovalServer, DEFAULT_HUMAN_APPROVAL_TEXTS, type HumanApprovalTexts } from "./core/tools/humanApproval.js";
 export { createManualLoginServer, type ManualInterventionTexts } from "./core/tools/manualLogin.js";
-export { createSaveToSourcesServer, type SourceToolsOptions } from "./core/tools/saveToSources.js";
+export { createSaveToSourcesServer, sourcesPromptSection, type SourceToolsOptions } 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";

package/dist/index.js

@@ -36,7 +36,7 @@ export { terminalInteractionPort, setSharedReadline, getSharedReadline } from ".
 setInteractionPort(terminalInteractionPort);
 export { createHumanApprovalServer, DEFAULT_HUMAN_APPROVAL_TEXTS } from "./core/tools/humanApproval.js";
 export { createManualLoginServer } from "./core/tools/manualLogin.js";
-export { createSaveToSourcesServer } from "./core/tools/saveToSources.js";
+export { createSaveToSourcesServer, sourcesPromptSection } from "./core/tools/saveToSources.js";
 export { runChatTui } from "./tui/chatTui.js";
 export { createConsoleRenderer } from "./tui/consoleRenderer.js";
 export { runChatInk } from "./tui/ink/runChatInk.js";

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

@@ -19,6 +19,7 @@ export declare function previewLines(lines: readonly string[], terminalRows: num
 export declare function statusText(mode: Mode | undefined, turns: number, usage: SessionUsage | null, extra?: {
     contextPercent?: number | null;
     modeSwitchable?: boolean;
+    width?: number;
 }): string;
 export interface SessionViewProps {
     model: SessionModel;

package/dist/tui/ink/SessionView.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import wrapAnsi from "wrap-ansi";
+import stringWidth from "string-width";
 import { useEffect, useReducer, useRef, useState, useSyncExternalStore } from "react";
 import { Box, measureElement, Static, Text, useInput, useStdout } from "ink";
 import { MultiSelect, Select, TextInput } from "@inkjs/ui";
@@ -86,13 +87,24 @@ function formatTokens(count) {
     return count >= 1000 ? `${(count / 1000).toFixed(1)}k` : String(count);
 }
 export function statusText(mode, turns, usage, extra = {}) {
-    const parts = [
+    const text = (withCached) => statusParts(mode, turns, usage, extra, withCached).join(" · ");
+    const full = text(true);
+    // The cached part goes first when the terminal is too narrow for it.
+    return extra.width !== undefined && stringWidth(full) > extra.width ? text(false) : full;
+}
+function statusParts(mode, turns, usage, extra, withCached) {
+    return [
         ...(mode ? [`⏵⏵ ${t().mode(mode)}${extra.modeSwitchable ? ` (${t().switchModeKey})` : ""}`] : []),
         t().turns(turns),
-        ...(usage ? [t().tokens(formatTokens(usage.inputTokens), formatTokens(usage.outputTokens))] : []),
+        // The new input apart from what was read again from the cache: the total grows with every
+        // call (each one sends the whole context again), which looked like the context growing.
+        ...(usage
+            ? [
+                t().tokens(formatTokens(usage.inputTokens - (usage.cacheReadTokens ?? 0)), formatTokens(usage.outputTokens), withCached && usage.cacheReadTokens ? formatTokens(usage.cacheReadTokens) : undefined),
+            ]
+            : []),
         ...(extra.contextPercent != null ? [t().context(Math.round(extra.contextPercent))] : []),
     ];
-    return parts.join(" · ");
 }
 // No emoji-capable characters: Windows Terminal draws ✳ (U+2733) as a green emoji.
 const WORKING_GLYPHS = ["·", "✢", "✱", "✶", "✻", "✽", "✻", "✶", "✱", "✢"];
@@ -110,7 +122,8 @@ function Working({ label, startedAt, width }) {
 /** Line in progress, checkpoint panel or spinner, the input, and the status bar. */
 function LiveArea({ session, checkpoint, renderApproval, mode, width, statusExtra, modeSwitchable, reservedRows, children }) {
     // The mode in the spinner's color; the rest dim.
-    const plain = statusText(mode, session.turns, session.usage, { contextPercent: session.contextPercent, modeSwitchable }) + (statusExtra ? ` · ${statusExtra}` : "");
+    const extraText = statusExtra ? ` · ${statusExtra}` : "";
+    const plain = statusText(mode, session.turns, session.usage, { contextPercent: session.contextPercent, modeSwitchable, width: width - stringWidth(extraText) }) + extraText;
     const cut = mode ? plain.indexOf(" · ") : -1;
     const status = cut > 0 ? ui.working(plain.slice(0, cut)) + ui.dim(plain.slice(cut)) : ui.dim(plain);
     return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, width: width, marginTop: session.liveGap ? 1 : 0, children: [stripAnsi(session.live) ? _jsx(Text, { children: session.live }) : null, checkpoint ? (_jsx(CheckpointPanel, { checkpoint: checkpoint, renderApproval: renderApproval, reservedRows: reservedRows, width: width })) : session.busy ? (

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

@@ -74,6 +74,13 @@ export interface InkChatOptions extends ChatTuiOptions {
      */
     firstPromptSuggestion?: string;
 }
+/** The chat's own commands, never sent to the model (the agent-help skill lists them; a test keeps both in step). */
+export declare const DEFAULT_EXIT_COMMANDS: readonly string[];
+export declare const LOCAL_COMMANDS: {
+    readonly copy: "/copy";
+    readonly resume: "/resume";
+    readonly plan: "/plan";
+};
 /** A choice asked in place of the prompt (the /resume list). */
 export interface ChatPicker {
     title: string;

package/dist/tui/ink/runChatInk.js

@@ -27,7 +27,9 @@ import { createTerminalStatus, focusFromReport } from "./terminalStatus.js";
 import { listProjectFiles } from "./fileMentions.js";
 import { headerLines } from "./header.js";
 const DEFAULT_PROMPT_LABEL = "\n> ";
-const DEFAULT_EXIT_COMMANDS = ["/exit", "/quit"];
+/** The chat's own commands, never sent to the model (the agent-help skill lists them; a test keeps both in step). */
+export const DEFAULT_EXIT_COMMANDS = ["/exit", "/quit"];
+export const LOCAL_COMMANDS = { copy: "/copy", resume: "/resume", plan: "/plan" };
 const DEFAULT_HISTORY_LIMIT = 100;
 // The prompt's frame: a border and one column of padding on each side.
 const PROMPT_FRAME_COLUMNS = 4;
@@ -382,19 +384,19 @@ export async function runChatInk(options, tuiOptions = {}) {
             if (exitCommands.has(line.toLowerCase()))
                 break;
             // A local command, never sent to the model: the last reply to the clipboard (OSC 52).
-            if (status && line.toLowerCase() === "/copy") {
+            if (status && line.toLowerCase() === LOCAL_COMMANDS.copy) {
                 const reply = model.lastReply();
                 if (reply)
                     stdout.write(clipboardSequence(reply));
                 model.writeLine(ui.dim(reply ? t().copiedReply(reply.length) : t().nothingToCopy));
                 continue;
             }
-            if (runsDir && line.toLowerCase() === "/resume") {
+            if (runsDir && line.toLowerCase() === LOCAL_COMMANDS.resume) {
                 await resume();
                 continue;
             }
             // A local command too: into plan mode, or back to the mode it was entered from.
-            if (line.toLowerCase() === "/plan") {
+            if (line.toLowerCase() === LOCAL_COMMANDS.plan) {
                 const control = modeControl();
                 const next = control ? togglePlanMode(control) : null;
                 if (next)

package/package.json

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

package/assets/knowledge-plugin-files/.claude-plugin/plugin.json

@@ -1,4 +0,0 @@
-{
-  "name": "knowledge",
-  "description": "Built-in knowledge base workflows (an LLM wiki): page templates, ingesting sources, querying the knowledge base and health-checking it."
-}

package/assets/knowledge-plugin-files/commands/ingest.md

@@ -1,7 +0,0 @@
----
-description: Ingest material into the knowledge base right now - the files or topic given, or everything in sources/ not ingested yet
----
-
-Apply the `knowledge-ingest` skill right now to: $ARGUMENTS
-
-If nothing is given above, ingest every original `list_sources` reports as new, and update the summaries of the ones it reports as changed. When you're done, summarize which pages you created and updated, and anything you couldn't read.

package/assets/knowledge-plugin-files/commands/lint.md

@@ -1,5 +0,0 @@
----
-description: Health-check the knowledge base right now - broken links, orphans, duplicates, contradictions, gaps
----
-
-Apply the `knowledge-lint` skill right now over the whole knowledge base. Fix what's mechanical (links, index, missing back-links) and report the rest: what needs the human's decision, and the gaps worth filling next.

package/assets/knowledge-plugin-files/commands/query.md

@@ -1,5 +0,0 @@
----
-description: Answer a question from the knowledge base, and file the answer back if it is worth keeping
----
-
-Apply the `knowledge-query` skill right now to answer: $ARGUMENTS

package/assets/knowledge-plugin-files/skills/knowledge-ingest/SKILL.md

@@ -1,46 +0,0 @@
----
-name: knowledge-ingest
-description: Ingest one source into the knowledge base - a file in sources/, a document, a page - creating its summary page, creating or updating the concept and entity pages it touches, linking everything both ways, and updating index.md and log.md.
----
-
-# Ingesting a source into the knowledge base
-
-A source is ingested once, and from then on the knowledge base holds what it taught: later sessions read the pages, not the original again. Ingesting is not summarizing a file in isolation - its value is in how it connects to what the knowledge base already knows. Load the `knowledge-pages` skill first for the page templates.
-
-## 1. Check it isn't already ingested
-
-`list_sources` gives each original's status and summary pages: *new* needs ingesting; *ingested* has a page; *changed* changed after its ingest. For a document from elsewhere, look for it in `index.md` (Summaries) or `Grep` its URL inside the knowledge base. If it already has a page:
-- unchanged source: nothing to do;
-- the source changed or the page is thin: update that page instead of creating another.
-
-## 2. Read it for real
-
-Read the whole source, not its first page (a long PDF in parts: `list_sources` gives its pages). If it exists only outside the sources folder, keep the original first: `download_to_sources` for a URL (a web page is kept as markdown too: read that one), `save_to_sources` for a file in the run's folder, `request_file` to ask the person for one. `Read` reads PDFs and images; read DOCX, PPTX (with its speaker notes) and XLSX with `extract_text`.
-
-## 3. Write the summary page
-
-Create `summaries/<slug>.md` with the template: summary, key points (literal wording where exactness matters), frontmatter `file`/`url` pointing to the original.
-
-## 4. Update concepts and entities
-
-For every concept or entity the source explains or relies on:
-- no page yet: create it;
-- page exists: add what is new (a better definition, an example, a nuance, a fact) with `Edit`, and link the summary under "Sources".
-
-Check first whether it exists under another name (`Grep` the knowledge base for the term and look at `aliases`): a duplicate page is worse than none.
-
-## 5. Link both ways and look for conflicts
-
-Every link you added from page A to page B needs its counterpart in B. If the source contradicts an existing page, record both versions with attribution in both pages - don't overwrite.
-
-## 6. Close
-
-- `index.md`: new pages, and one-line descriptions that changed.
-- `log.md`: `## [date] ingest | <source title>` with the pages created and updated.
-- `overview.md`: only if the source changes the big picture.
-
-When ingesting several sources in a row, do steps 1-5 for each and close once at the end.
-
-## An original that was wrong or replaced
-
-`retire_source` (the person approves it) moves it aside and marks its summary retired (wrong) or superseded (replaced by a better one). Then update `index.md`, and fix the pages that cite it (`Grep` its file name): after a wrong one, correct or remove what it taught; after a replaced one, ingest the new original and re-ground those passages on it.

package/assets/knowledge-plugin-files/skills/knowledge-lint/SKILL.md

@@ -1,26 +0,0 @@
----
-name: knowledge-lint
-description: Health-check the knowledge base - broken links, pages missing from index.md, orphan pages, one-way links, duplicated concepts, mentioned-but-missing concepts, contradictions, gaps - fix what's mechanical and report the rest.
----
-
-# Linting the knowledge base
-
-A knowledge base maintained across sessions drifts: links break, pages go unlisted, the same concept appears under two names. Lint it when asked and after a large ingest. Load `knowledge-pages` first for the templates.
-
-## Checks
-
-Use `Glob` to list pages and `Grep` (always with `path` inside the knowledge base) to find links, instead of reading every page in full.
-
-1. **Broken links**: a relative link whose target file doesn't exist. Fix it if the right target is obvious (a typo, a page under a close name); otherwise report it.
-2. **Index**: every page is listed in `index.md` and every entry there points to an existing page. Fix it.
-3. **Orphans**: pages nothing links to (`Grep` for the file name). Link them from where they belong, or report why they don't belong anywhere.
-4. **One-way links**: a summary that feeds a concept which doesn't list it back... Add the missing side.
-5. **Duplicates**: two pages for the same idea under different names. Merge the content into one, mark the other as superseded (never delete it) and repoint links.
-6. **Missing pages**: terms that several pages treat as concepts or entities but have no page. Create them if the material is there; otherwise list them.
-7. **Contradictions**: claims that disagree across pages without being recorded as such. Record both sides, attributed.
-8. **Provenance**: claims with no traceable source. Add the link, or mark them as unsourced.
-9. **Gaps**: originals `list_sources` reports as new (no summary yet), changed (their summary may be stale) or missing (deleted by hand: their summaries point nowhere), and concepts mentioned but never explained by any source. Report them - they are what to ingest, update or find next.
-
-## Close
-
-Append `## [date] lint | <summary>` to `log.md` listing what was fixed. Then report to the human: what you fixed, and what needs their decision or more material. Don't make judgement calls silently - merging pages that are only similar, or choosing between contradictory sources, goes in the report.