@falkenslab/agent-kit 0.30.1 → 0.31.0

package/README.md

@@ -1,67 +1,48 @@
-<h1>
-  <img src="https://raw.githubusercontent.com/falkenslab/agent-kit/main/docs/assets/logo-readme-any.svg" alt="agent-kit" height="64">
-</h1>
+<div align="center">
 
-[![npm](https://img.shields.io/npm/v/@falkenslab/agent-kit?logo=npm)](https://www.npmjs.com/package/@falkenslab/agent-kit)
-[![npm downloads](https://img.shields.io/npm/dm/@falkenslab/agent-kit)](https://www.npmjs.com/package/@falkenslab/agent-kit)
-[![types](https://img.shields.io/npm/types/@falkenslab/agent-kit)](https://www.npmjs.com/package/@falkenslab/agent-kit)
-[![node](https://img.shields.io/node/v/@falkenslab/agent-kit)](https://nodejs.org/)
-[![license](https://img.shields.io/npm/l/@falkenslab/agent-kit)](LICENSE)
-[![docs](https://img.shields.io/badge/docs-falkenslab.github.io%2Fagent--kit-4453b8)](https://falkenslab.github.io/agent-kit/)
+<img src="https://raw.githubusercontent.com/falkenslab/agent-kit/main/docs/static/img/logo.svg" alt="agent-kit logo: three blue building blocks and a coral one being set in place" width="112"/>
 
-**[📖 Documentation](https://falkenslab.github.io/agent-kit/)** · [📖 Documentación en español](https://falkenslab.github.io/agent-kit/es/)
-
-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
+# agent-kit
 
-- **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), and a plan mode where it only reads and plans until you let it act. Within the same conversation you can switch among guided, step by step and plan.
-- **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.
-- **Look the way you want.** The terminal's colors come from a theme by roles (the agent's replies, tool results, the focused option, borders…): pass only the ones you want to change, as a color name, a hex or a function.
-- **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 shown in as much detail as the agent chooses (each call with its result, the calls alone, or one line per group; Ctrl+O unfolds them), 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.
+**Build an AI agent on Claude that asks before it acts, remembers, and chats like Claude Code.**<br/>
+You write what your agent knows and does; the kit brings oversight, safety, memory and the interface.
 
-## Examples
+[![npm](https://img.shields.io/npm/v/@falkenslab/agent-kit?color=cb3837&logo=npm)](https://www.npmjs.com/package/@falkenslab/agent-kit)
+![Node.js 20+](https://img.shields.io/badge/node-20%2B-339933?logo=node.js&logoColor=white)
+![Claude Agent SDK](https://img.shields.io/badge/Claude-Agent%20SDK-d97757?logo=anthropic&logoColor=white)
+![TypeScript](https://img.shields.io/badge/types-included-3178c6?logo=typescript&logoColor=white)
+[![License: MIT](https://img.shields.io/badge/license-MIT-16a34a)](LICENSE)
 
-### 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.
+**[📖 Documentation](https://falkenslab.github.io/agent-kit/)** · [📖 Documentación en español](https://falkenslab.github.io/agent-kit/es/)
 
-![Captain Whiskers in Windows Terminal: his logo with the mode and the agent-kit version at the top, his crew at work in the middle, a task list under the spinner, and the framed prompt and status bar at the bottom](docs/assets/captain-whiskers.png)
+</div>
 
-See [everything he can do](https://falkenslab.github.io/agent-kit/docs/next/examples/captain-whiskers#what-he-can-do), with screenshots.
+agent-kit is 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 (levels of oversight, approvals, safe limits, memory across sessions, extensions, and a terminal chat as good as Claude Code's), so each agent writes only what belongs to its own domain: what it knows how to do, with which tools, and how it talks. A teacher's assistant for Moodle and a pirate cat who tells jokes are built the same way.
 
-### miyagi
+## ✨ Why agent-kit
 
-[miyagi](https://github.com/falkenslab/miyagi) 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.
+- 🎚️ **You choose how much it acts alone.** Autonomous, guided (it asks before what others will see or can't be undone), step by step, or a plan mode where it only reads and plans; switch among them in the same conversation.
+- ✋ **It asks a person, and the kit makes sure.** Approvals, choices, a file, a sign-in by hand; an installed extension's tool that changes things waits for a yes whatever the model decided, and answers can last for the session or for good.
+- 🧠 **It remembers.** A knowledge base that grows with every session, the original documents it learns from kept untouched, a memory of the person, and every conversation to pick up again with `--continue` or `/resume`.
+- 🛡️ **It stays within limits.** Only its own folders, never protected files, subagents that can't slip past the main agent's limits, secrets hidden from the logs, remote servers allowed, asked about or denied.
+- 🧩 **It grows with extensions.** Claude Code plugins with MCP servers, skills and commands, installed from a marketplace or a folder, with their own options, sign-in and a catalog in the chat; no Git needed.
+- 🌐 **It speaks your language.** Its interface in English, Spanish, French or German, and it answers in that language unless you write in another.
+- 🖥️ **A terminal chat like Claude Code's, or none at all.** Full screen, live markdown, folded tool calls, panels, history, themes; or the same agent inside a desktop app or a web page with its own interface.
 
-Oversight, memory, safety and the chat come from the kit; miyagi brings what it knows about Moodle and driving the browser.
+## 🚀 Quick start
 
-## Installation
+You need [Node.js](https://nodejs.org) 20 or later and a Claude account. In a project with `"type": "module"` in its `package.json`:
 
-```
-npm install @falkenslab/agent-kit
+```bash
+npm install @falkenslab/agent-kit tsx
 ```
 
-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:
+Save this as `agent.ts`: the only part that's your agent's is the spec at the top.
 
 ```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
@@ -70,42 +51,125 @@ const spec: AgentSpec<BaseSessionConfig> = {
 };
 
 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.
+// Each run gets a folder under .run/ (keep it out of git): its log, transcript and conversation.
 await runChatInk((run) => buildSessionOptions(config, run.dir, spec, { run }), {
   runsDir: path.resolve(".run"),
   header: { title: "My agent" },
   mode: config.mode, // Shift+Tab cycles through guided, step by step and plan
   fullscreen: true,
-  theme: { toolResult: "gray", selection: "#ffb86c" }, // only the colors you want to change
 });
 ```
 
-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.
+Run it with `npx tsx agent.ts`: a full-screen chat opens, in your system's language, and the agent asks before anything it shouldn't do alone. The [tutorial](https://falkenslab.github.io/agent-kit/docs/getting-started/first-agent) takes it from there.
+
+## 🧪 A taste of the code
+
+Give it a memory and a folder of sources, with the kit's own extensions:
+
+```ts
+import { knowledge, memory, sources } from "@falkenslab/agent-kit";
+
+const spec: AgentSpec<BaseSessionConfig> = {
+  // …
+  extensions: [sources({ dir: "sources" }), knowledge({ dir: "knowledge" }), memory({ dir: "memory" })],
+};
+```
+
+Let it install extensions from your marketplace, and keep its data from leaving the computer without asking:
+
+```ts
+const config: BaseSessionConfig = {
+  mode: "guided",
+  projectDir: process.cwd(),
+  extensionDirs: { agent: path.join(os.homedir(), ".my-agent", "extensions") },
+  officialMarketplace: "falkenslab/agent-extensions",
+  remoteServers: "ask",
+};
+```
+
+Make a tool always wait for the person's yes, on every call:
 
-## Documentation
+```ts
+const spec: AgentSpec<BaseSessionConfig> = {
+  // …
+  extensionGate: { confirmTools: { canva: ["create-design", "publish-design"] } },
+};
+```
+
+## 📸 See it at work
+
+[Captain Whiskers](./examples/captain-whiskers), the kit's example agent: a retired pirate cat who tells jokes in your language, with a crew of subagents (one looks for new jokes on the web, one rates them, one tells the time), a logbook and an extension of his own. He runs in the terminal, in a browser and as a Windows app.
+
+<div align="center">
+
+<img src="https://raw.githubusercontent.com/falkenslab/agent-kit/main/docs/assets/captain-whiskers.png" alt="Captain Whiskers in Windows Terminal: his logo with the mode and the agent-kit version at the top, his crew at work in the middle, a task list under the spinner, and the framed prompt and status bar at the bottom" width="760"/>
+
+</div>
+
+See [everything he can do](https://falkenslab.github.io/agent-kit/docs/examples/captain-whiskers#what-he-can-do), with screenshots. For a real one, [miyagi](https://github.com/falkenslab/miyagi) is an assistant for Moodle teachers: it grades, answers the forum, builds content and sums up how the class is going, asking before publishing anything students will see. Oversight, memory, safety and the chat come from the kit; miyagi brings what it knows about Moodle.
+
+## 🧰 What's inside
+
+| Area | For example |
+| --- | --- |
+| 🎚️ Modes and gates | Autonomous, guided, step by step and plan; the guided gate for extensions' tools, the plan gate, the step gate |
+| ✋ Human in the loop | Approvals, choices, free text, files, manual steps, MCP elicitation forms, a response file for hosts without a keyboard |
+| 🧠 Memory | A knowledge base (an LLM wiki), sources kept as obtained, a memory of the person, runs resumed with `--continue` and `/resume` |
+| 🧩 Extensions | Claude Code plugins with MCP servers (local, npm, remote with OAuth), skills, commands and subagents; scopes, a lock, workspace trust, options, marketplaces and a catalog |
+| 🛡️ Security | A file scope gate, denied paths, subagent gates, a remote-servers gate, isolation from the runner's own Claude Code, redacted transcripts |
+| 🤖 Subagents | Declared types only, in the foreground, without Bash for the main agent |
+| 🖥️ Interfaces | A full-screen Ink chat, a plain readline chat, a progress view, a wizard, themes; a chat controller for desktop apps and web pages |
+| 🌐 Languages | English, Spanish, French and German, for the interface, the replies and the extensions' servers |
+
+Every export, with what it takes and what it gives, is in the [API reference](https://falkenslab.github.io/agent-kit/docs/api).
+
+## 📚 Documentation
 
-The full documentation is at **[falkenslab.github.io/agent-kit](https://falkenslab.github.io/agent-kit/)**: a tutorial, guides for every part of the kit (modes, human in the loop, security, tools, subagents, the knowledge base, the terminal UI, runs, languages, themes, hosts without a terminal), recipes, and an API reference generated from the source, for each released version.
+- **[Getting started](https://falkenslab.github.io/agent-kit/docs/getting-started/installation)**: installation and a first agent, step by step.
+- **[Modes](https://falkenslab.github.io/agent-kit/docs/core-concepts/modes)** and **[human in the loop](https://falkenslab.github.io/agent-kit/docs/human-in-the-loop/overview)**: how much the agent does alone, and how it asks.
+- **[Extensions](https://falkenslab.github.io/agent-kit/docs/extensions/overview)**: installing, writing and publishing them.
+- **[Security](https://falkenslab.github.io/agent-kit/docs/security/overview)**: every guardrail, and what the kit doesn't protect.
+- **[The terminal chat](https://falkenslab.github.io/agent-kit/docs/terminal-ui/ink-chat)**: its keys, panels, options and themes.
+- **[Captain Whiskers](https://falkenslab.github.io/agent-kit/docs/examples/captain-whiskers)**: the example agent, piece by piece.
 
-For whoever works on the kit itself, 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.
+## 🛠️ Developing
 
-## Development
+The design decisions, and the SDK behaviors checked by hand behind several safeguards, are in [`.minispec/`](./.minispec/README.md).
 
 | 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 |
+| `npm test` | Runs all the tests (one file: `npx tsx --test test/tui/promptErrors.test.ts`) |
 | `npm run docs:install` | Installs the documentation site's dependencies (once) |
 | `npm run docs:start` | Serves the documentation site locally, reloading on changes |
 | `npm run docs:build` | Builds the documentation site (fails on broken links) |
 
-To run a single test file:
+To try changes to the kit in an agent without publishing them, point its `package.json` to a local clone (`"file:../agent-kit"`) and run `npm run build` after each change.
 
+Working on the kit with Claude Code goes through Falken's Lab's own skills (commit, verify, update-docs, release, sync-issues, and the house style for READMEs, sites and Markdown), from the [falkenslab/falkenslab-plugins](https://github.com/falkenslab/falkenslab-plugins) marketplace. Install them once, for all of Falken's Lab's repositories:
+
+```bash
+claude plugin marketplace add falkenslab/falkenslab-plugins
+claude plugin install falkenslab-dev@falkenslab-plugins
+claude plugin install falkenslab-style@falkenslab-plugins
 ```
-npx tsx --test test/tui/promptErrors.test.ts
-```
+
+<details>
+<summary>What each plugin brings, and what stays in this repository</summary>
+
+- 🔧 **falkenslab-dev**: `commit`, `verify`, `update-docs`, `release`, `sync-issues`, `upgrade-deps` and `add-tool`.
+- 🎨 **falkenslab-style**: `falkenslab-docs`, `falkenslab-site-style`, `falkenslab-terminal-screenshots` and `markdown-writing`.
+
+Inside Claude Code, the same with `/plugin marketplace add falkenslab/falkenslab-plugins` and `/plugin install falkenslab-dev@falkenslab-plugins`; `/plugin marketplace update falkenslab-plugins` brings their latest version. This repository keeps only the skills that are agent-kit's own, in `.claude/skills/` (`add-export`, the MiniSpec ones and `upgrade-sdk`), and what its release adds to the general one is in [`CLAUDE.md`](./CLAUDE.md#releasing).
+
+</details>
+
+<div align="center">
+
+Made with 💖 by Falken's Lab Team
+
+</div>

package/dist/chat/chatController.d.ts

@@ -71,6 +71,14 @@ export interface ChatSettings {
      * The link is shown either way, on a line of its own, for another computer.
      */
     openBrowser?: boolean | ((url: string) => Promise<boolean>);
+    /**
+     * Claude Code's own commands in the `/` menu and the state's `commands` (#87): none by default,
+     * since they're for whoever develops with Claude Code (`/batch`, `/agents`, `/mcp`…), not for the
+     * agent's person; `"all"`, or the ones named (`["compact", "context"]`). The agent's own, its
+     * plugins', its extensions', the project's, the kit's and the view's are always there, and a
+     * command typed by hand still reaches the SDK.
+     */
+    cliCommands?: "all" | readonly string[];
 }
 /** One tool call in the transcript. */
 export interface TranscriptCall {

package/dist/chat/chatController.js

@@ -183,7 +183,10 @@ export async function createChatController(options, settings = {}) {
                 { name: "extensions", description: t().commandExtensions, argumentHint: "[enable|disable|config|search|install|update|remove|reload]" },
             ];
             const details = new Map();
-            for (const command of [...(commands ?? []).map(({ name, description, argumentHint }) => ({ name, description: description ?? "", argumentHint: argumentHint ?? "" })), ...local])
+            // Claude Code's own (builtin) only when the agent asks for them (#87).
+            const cli = settings.cliCommands;
+            const offered = (commands ?? []).filter((command) => !command.builtin || cli === "all" || (Array.isArray(cli) && cli.includes(command.name)));
+            for (const command of [...offered.map(({ name, description, argumentHint }) => ({ name, description: description ?? "", argumentHint: argumentHint ?? "" })), ...local])
                 details.set(command.name, command);
             for (const name of exits)
                 if (!details.has(name))

package/dist/core/agentSpec.d.ts

@@ -154,8 +154,11 @@ export interface AgentSpec<TConfig extends BaseSessionConfig> {
      * 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.
+     * When the language isn't English, the kit also says it again after each of the main agent's
+     * tool calls and with each message of the person (#85), since the narration between tool calls
+     * drifted to English after an English result; `"prompt-only"` keeps only the prompt's line.
      */
-    replyInLanguage?: boolean;
+    replyInLanguage?: boolean | "prompt-only";
     /**
      * 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"

package/dist/core/externalExtensions.js

@@ -1,10 +1,8 @@
-import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { cp, mkdtemp, readdir, readFile, rm, stat, writeFile, mkdir } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { promisify } from "node:util";
 import { capabilitiesProblem, parseCapabilities, parseDescriptions, providedBy } from "./extensions.js";
 import { getLanguage } from "./messages/index.js";
 import { truncate } from "./toolLabels.js";
@@ -14,6 +12,7 @@ import { extensionSecretsPath, fillOptions, missingOptions, optionsNamed, parseO
 import { isTrusted } from "./workspaceTrust.js";
 import { checkRequirements, describeMissing, findOnPath, parseRequirements, requirementsProblem } from "./extensionRequirements.js";
 import { cachedPackageDir, cachedPackageProblem, cachePackage, npxServer, packageCacheDir, packageSpec } from "./npxPackages.js";
+import { cloneRepository } from "./gitClone.js";
 /** Whether a server is remote (#61). */
 export function isRemoteServer(server) {
     return "url" in server;
@@ -203,7 +202,20 @@ async function pluginServers(dir, raw) {
 }
 /** `${CLAUDE_PLUGIN_ROOT}`, `${CLAUDE_PLUGIN_DATA}` and `${VAR}` (the agent's variable) in a server's values. */
 function expand(value, folders) {
-    return value.replace(/\$\{(\w+)\}/g, (_, name) => name === "CLAUDE_PLUGIN_ROOT" ? folders.root : name === "CLAUDE_PLUGIN_DATA" ? folders.data : (process.env[name] ?? ""));
+    return value.replace(/\$\{(\w+)\}/g, (_, name) => (name === "CLAUDE_PLUGIN_ROOT" ? folders.root : name === "CLAUDE_PLUGIN_DATA" ? folders.data : (process.env[name] ?? "")));
+}
+/** The POSIX locale for a session's language: what any program reads to speak the person's language. */
+const LOCALES = { en: "en_US.UTF-8", es: "es_ES.UTF-8", fr: "fr_FR.UTF-8", de: "de_DE.UTF-8" };
+/**
+ * A server's locale in the session's language (#86): `LANG` and `LC_MESSAGES`, and `LC_ALL` when the
+ * system sets one (it would win). The standard way, so a server asks in the person's language
+ * knowing nothing of the kit, and does the same under Claude Code or any other client.
+ */
+function localeEnv(language) {
+    const locale = language ? LOCALES[language] : undefined;
+    if (!locale)
+        return {};
+    return { LANG: locale, LC_MESSAGES: locale, ...(process.env.LC_ALL ? { LC_ALL: locale } : {}) };
 }
 /**
  * Why one of an extension's servers can't run through the launcher (Node, its script first,
@@ -214,7 +226,8 @@ function serverLaunch(name, server, folders, packages = {}) {
     const { root } = folders;
     // Its folders as variables too, as Claude Code gives them to a plugin's servers.
     const declared = Object.fromEntries(Object.entries(server.env ?? {}).map(([key, value]) => [key, expand(String(value), folders)]));
-    const env = { CLAUDE_PLUGIN_ROOT: root, CLAUDE_PLUGIN_DATA: folders.data, ...declared };
+    // And the session's language as its locale (#86): a server that reads it can ask and answer in it.
+    const env = { CLAUDE_PLUGIN_ROOT: root, CLAUDE_PLUGIN_DATA: folders.data, ...localeEnv(folders.language), ...declared };
     const npx = npxServer(server);
     if (typeof npx === "string")
         return `${npx} (its server "${name}")`;
@@ -390,7 +403,7 @@ function externalExtension(installed, manifest, cache, unavailable = []) {
             const remote = [];
             if (Object.keys(manifest.servers).length)
                 await mkdir(installed.dataDir, { recursive: true });
-            const folders = { root: installed.dir, data: installed.dataDir };
+            const folders = { root: installed.dir, data: installed.dataDir, language: getLanguage() };
             // A remote server's options go into its URL and headers here, when the session opens: the
             // SDK fixes them then, so a changed value takes opening the session again (#61).
             const values = Object.values(manifest.servers).some(isRemoteServer) ? await readOptionValues(installed.privateDir, installed.name, manifest.userConfig, installed.lock.options) : {};
@@ -525,7 +538,6 @@ async function problem(installed, cache) {
         return options;
     return (await serversProblem(manifest, installed.dir, { cache, locked: installed.lock.packages })) ?? { manifest, unavailable };
 }
-const exec = promisify(execFile);
 /** Whether `source` names a git repository rather than a folder. */
 export function isGitSource(source) {
     return /^(https?:\/\/|git@|ssh:\/\/|git:\/\/|file:\/\/|github:)/.test(source) || /\.git(#.*)?$/.test(source);
@@ -549,12 +561,9 @@ export async function addExtension(source, scopeDir, options = {}) {
     if (isGitSource(source)) {
         const [url, ref] = source.replace(/^github:/, "https://github.com/").split("#");
         clone = await mkdtemp(path.join(os.tmpdir(), "agent-kit-extension-"));
-        // A pinned commit needs the history to check it out; otherwise the tip is enough.
-        await exec("git", ["clone", ...(options.sha ? [] : ["--depth", "1"]), ...(ref ? ["--branch", ref] : []), url, clone]);
-        if (options.sha)
-            await exec("git", ["-C", clone, "checkout", "--quiet", options.sha]);
-        commit = (await exec("git", ["-C", clone, "rev-parse", "HEAD"])).stdout.trim();
-        if (options.sha && commit !== options.sha.toLowerCase())
+        // Without the git program (#89): a pinned commit takes the history, otherwise the tip is enough.
+        commit = await cloneRepository(url, clone, { ...(ref ? { ref } : {}), ...(options.sha ? { sha: options.sha } : {}) });
+        if (options.sha && !commit.startsWith(options.sha.toLowerCase()))
             throw new Error(`${url} has no commit ${options.sha}.`);
         from = clone;
     }

package/dist/core/gitClone.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Clones a git repository into `dir` (#89), without the `git` program: an extension or a
+ * marketplace from GitHub installs on a computer without Git, as in a desktop app on a clean
+ * Windows. Over HTTP(S) with isomorphic-git (pure JavaScript: Node and Electron); a `file://`
+ * repository is read where it is and its files written out, never changed; SSH (`git@…`,
+ * `ssh://`, `git://`), which isomorphic-git can't speak, goes to the system's `git` when there is
+ * one. `ref` is a branch or a tag (the default branch without it); `sha` pins a commit, which must
+ * be on that branch's history. Returns the commit checked out. `dir` keeps no `.git`.
+ */
+export declare function cloneRepository(url: string, dir: string, options?: {
+    ref?: string;
+    sha?: string;
+}): Promise<string>;

package/dist/core/gitClone.js

@@ -0,0 +1,117 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import git from "isomorphic-git";
+import http from "isomorphic-git/http/node";
+const exec = promisify(execFile);
+/**
+ * Clones a git repository into `dir` (#89), without the `git` program: an extension or a
+ * marketplace from GitHub installs on a computer without Git, as in a desktop app on a clean
+ * Windows. Over HTTP(S) with isomorphic-git (pure JavaScript: Node and Electron); a `file://`
+ * repository is read where it is and its files written out, never changed; SSH (`git@…`,
+ * `ssh://`, `git://`), which isomorphic-git can't speak, goes to the system's `git` when there is
+ * one. `ref` is a branch or a tag (the default branch without it); `sha` pins a commit, which must
+ * be on that branch's history. Returns the commit checked out. `dir` keeps no `.git`.
+ */
+export async function cloneRepository(url, dir, options = {}) {
+    try {
+        if (/^(git@|ssh:\/\/|git:\/\/)/.test(url))
+            return await cloneWithGitProgram(url, dir, options);
+        if (/^https?:\/\//.test(url))
+            return await cloneOverHttp(url, dir, options);
+        // A local repository: a file:// URL, or a path (one ending in .git, perhaps bare).
+        return await exportLocal(url.startsWith("file://") ? fileURLToPath(url) : path.resolve(url), dir, options);
+    }
+    catch (error) {
+        throw new Error(explain(url, options, error), { cause: error });
+    }
+}
+/** Over HTTP(S): the tip of a branch or tag in one shallow fetch, or its history when a commit is pinned. */
+async function cloneOverHttp(url, dir, { ref, sha }) {
+    await git.clone({ fs, http, dir, url, ...(ref ? { ref } : {}), singleBranch: true, ...(sha ? {} : { depth: 1 }), noTags: !ref });
+    if (sha)
+        await git.checkout({ fs, dir, ref: await expandCommit(path.join(dir, ".git"), sha), force: true });
+    const commit = await git.resolveRef({ fs, dir, ref: "HEAD" });
+    await fs.promises.rm(path.join(dir, ".git"), { recursive: true, force: true });
+    return commit;
+}
+/** A local repository: the commit's files written into `dir`, the repository itself untouched (no checkout, no index). */
+async function exportLocal(repo, dir, { ref, sha }) {
+    // A working copy's .git, or the repository itself when it's bare.
+    const gitdir = fs.existsSync(path.join(repo, ".git")) ? path.join(repo, ".git") : repo;
+    const commit = sha ? await expandCommit(gitdir, sha) : await git.resolveRef({ fs, gitdir, ref: ref ?? "HEAD" });
+    const { commit: { tree } } = await git.readCommit({ fs, gitdir, oid: commit });
+    await git.walk({
+        fs,
+        gitdir,
+        trees: [git.TREE({ ref: tree })],
+        map: async (filepath, [entry]) => {
+            if (!entry || filepath === ".")
+                return true;
+            const type = await entry.type();
+            const target = path.join(dir, filepath);
+            if (type === "tree")
+                await mkdir(target, { recursive: true });
+            else if (type === "blob") {
+                await mkdir(path.dirname(target), { recursive: true });
+                await writeFile(target, (await entry.content()) ?? new Uint8Array());
+            }
+            return true;
+        },
+    });
+    return commit;
+}
+/** A commit given whole or abbreviated, as git takes it: the whole id, or an error when there's no such commit. */
+async function expandCommit(gitdir, sha) {
+    const oid = sha.length === 40 ? sha.toLowerCase() : await git.expandOid({ fs, gitdir, oid: sha.toLowerCase() });
+    await git.readCommit({ fs, gitdir, oid });
+    return oid;
+}
+/** SSH, which isomorphic-git can't speak: the system's `git`, or a clear error without one. */
+async function cloneWithGitProgram(url, dir, { ref, sha }) {
+    try {
+        await exec("git", ["clone", ...(sha ? [] : ["--depth", "1"]), ...(ref ? ["--branch", ref] : []), url, dir]);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            throw Object.assign(new Error("no git"), { code: "NoGitForSsh" });
+        throw error;
+    }
+    if (sha)
+        await exec("git", ["-C", dir, "checkout", "--quiet", sha]);
+    const commit = (await exec("git", ["-C", dir, "rev-parse", "HEAD"])).stdout.trim();
+    await fs.promises.rm(path.join(dir, ".git"), { recursive: true, force: true });
+    return commit;
+}
+/** What went wrong, for a person: which repository, and whether it's the network, the repository, the ref or the commit. */
+function explain(url, { ref, sha }, error) {
+    const code = error.code ?? "";
+    const status = error.data?.statusCode;
+    let host = url;
+    try {
+        host = new URL(url).host || url;
+    }
+    catch {
+        // Not a URL (git@host:…): the address as given.
+    }
+    if (code === "NoGitForSsh")
+        return `${url} is an SSH address, which needs the git program, and this computer has none: use its HTTPS address instead.`;
+    if (code === "HttpError" && (status === 401 || status === 403 || status === 404))
+        return `${url} isn't a repository this computer can reach: it doesn't exist, or it's private.`;
+    if (code === "HttpError")
+        return `${host} answered with an error (${status ?? "?"}) for ${url}.`;
+    if (["ENOTFOUND", "EAI_AGAIN", "ECONNREFUSED", "ECONNRESET", "ETIMEDOUT"].includes(code))
+        return `Couldn't reach ${host} for ${url}: check the network.`;
+    if (code === "NotFoundError" || code === "AmbiguousError") {
+        if (sha)
+            return `${url} has no commit ${sha}${ref ? ` on ${ref}` : ""}.`;
+        if (ref)
+            return `${url} has no branch or tag ${ref}.`;
+    }
+    if (code === "NotFoundError" && !/^https?:\/\//.test(url))
+        return `${url} isn't a git repository.`;
+    return `Couldn't get ${url}${ref ? ` at ${ref}` : ""}: ${error instanceof Error ? error.message : String(error)}`;
+}

package/dist/core/hooks/languageReminder.d.ts

@@ -0,0 +1,16 @@
+import type { HookCallback } from "@anthropic-ai/claude-agent-sdk";
+import { type Language } from "../language.js";
+/**
+ * The reply language, said again next to what the model just read (#85): with only the system
+ * prompt's line, far from the turn, its narration between tool calls drifted to English after an
+ * English result (a source, a skill, the kit's own messages). One short line, about fifteen tokens.
+ */
+export declare function languageReminderLine(language: Language): string;
+/**
+ * Its hooks: after each of the main agent's tool calls (a subagent has its own prompt line, and
+ * its narration isn't the person's), and with the person's message.
+ */
+export declare function createLanguageReminder(language: Language): {
+    postToolUse: HookCallback;
+    userPromptSubmit: HookCallback;
+};

package/dist/core/hooks/languageReminder.js

@@ -0,0 +1,24 @@
+import { LANGUAGE_NAMES } from "../language.js";
+/**
+ * The reply language, said again next to what the model just read (#85): with only the system
+ * prompt's line, far from the turn, its narration between tool calls drifted to English after an
+ * English result (a source, a skill, the kit's own messages). One short line, about fifteen tokens.
+ */
+export function languageReminderLine(language) {
+    return `Reply language: ${LANGUAGE_NAMES[language]}, your narration between tool calls too.`;
+}
+/**
+ * Its hooks: after each of the main agent's tool calls (a subagent has its own prompt line, and
+ * its narration isn't the person's), and with the person's message.
+ */
+export function createLanguageReminder(language) {
+    const line = languageReminderLine(language);
+    return {
+        postToolUse: async (input) => {
+            if (input.agent_id)
+                return {};
+            return { hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: line } };
+        },
+        userPromptSubmit: async () => ({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: line } }),
+    };
+}

package/dist/core/hooks/stepGate.d.ts

@@ -1,4 +1,5 @@
 import type { HookCallback } from "@anthropic-ai/claude-agent-sdk";
+import { type ToolLabels } from "../toolLabels.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
@@ -7,5 +8,9 @@ import type { HookCallback } from "@anthropic-ai/claude-agent-sdk";
  * `isActive` lets one session switch between "guided" and "interactive" while it runs (see
  * session.ts's `ModeControl`): the hook stays registered and, while inactive, gives no
  * decision at all, so the tool call goes on exactly as if the hook weren't there.
+ *
+ * The panel says the call as the chat does (#88), in the person's language: the session's
+ * labels (`labels`: the extensions'), else the kit's for its own tools, then the tool's name and
+ * its parameters in one line, cut short; the person approving needn't read JSON.
  */
-export declare function createStepGate(runDir: string, isActive?: () => boolean, selfAskingTools?: readonly string[]): HookCallback;
+export declare function createStepGate(runDir: string, isActive?: () => boolean, selfAskingTools?: readonly string[], labels?: () => ToolLabels | undefined): HookCallback;

package/dist/core/hooks/stepGate.js

@@ -1,5 +1,8 @@
 import { askForDecision } from "./humanInput.js";
 import { t } from "../messages/index.js";
+import { createFriendlyToolLabel, withToolLabels } from "../toolLabels.js";
+/** How much of a call's parameters the panel shows, as one line (#88). */
+const MAX_PARAMETERS = 300;
 const SELF_ASKING_SERVERS = ["mcp__approvals__", "mcp__manualLogin__"];
 const SELF_ASKING_TOOLS = new Set(["TodoWrite"]);
 /**
@@ -10,8 +13,13 @@ const SELF_ASKING_TOOLS = new Set(["TodoWrite"]);
  * `isActive` lets one session switch between "guided" and "interactive" while it runs (see
  * session.ts's `ModeControl`): the hook stays registered and, while inactive, gives no
  * decision at all, so the tool call goes on exactly as if the hook weren't there.
+ *
+ * The panel says the call as the chat does (#88), in the person's language: the session's
+ * labels (`labels`: the extensions'), else the kit's for its own tools, then the tool's name and
+ * its parameters in one line, cut short; the person approving needn't read JSON.
  */
-export function createStepGate(runDir, isActive = () => true, selfAskingTools = []) {
+export function createStepGate(runDir, isActive = () => true, selfAskingTools = [], labels = () => undefined) {
+    const describe = withToolLabels(labels, createFriendlyToolLabel());
     return async (input) => {
         if (!isActive())
             return {};
@@ -20,9 +28,10 @@ export function createStepGate(runDir, isActive = () => true, selfAskingTools =
         // 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) || selfAskingTools.includes(pre.tool_name))
             return {};
+        const compact = JSON.stringify(pre.tool_input ?? {});
         const answer = await askForDecision(runDir, {
             title: t().proposedAction,
-            lines: [t().toolLine(pre.tool_name), t().parametersLine(JSON.stringify(pre.tool_input, null, 2))],
+            lines: [describe(pre.tool_name, pre.tool_input), t().toolLine(pre.tool_name), t().parametersLine(compact.length > MAX_PARAMETERS ? `${compact.slice(0, MAX_PARAMETERS)}…` : compact)],
         });
         if (answer === "q") {
             return {

package/dist/core/marketplaces.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Marketplaces (ADR-025, #29): a repository of extensions is a Claude Code marketplace as it is,
+ * a folder or git repository with `.claude-plugin/marketplace.json` listing plugins and where
+ * each comes from. An agent knows the marketplaces added to it, kept in its extensions folder
+ * (`marketplaces.json`, and a copy of each in `.marketplaces/<name>/`), and installs from them
+ * by `<plugin>@<marketplace>` into either scope, through `addExtension()`: the same copy, hash and
+ * lock as any extension. Its official marketplace is known without asking; any other is added
+ * only by hand, after a warning (the command asks to type its name).
+ */
 /** Where a marketplace's plugin comes from, as `marketplace.json` says (Claude Code's forms). */
 export type PluginSource = string | {
     source: "github";

package/dist/core/marketplaces.js

@@ -1,20 +1,9 @@
-import { execFile } from "node:child_process";
 import { cp, mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { promisify } from "node:util";
 import { addExtension, isGitSource } from "./externalExtensions.js";
 import { fetchArchivePlugin, fetchNpmPlugin } from "./pluginDownloads.js";
-/**
- * Marketplaces (ADR-025, #29): a repository of extensions is a Claude Code marketplace as it is,
- * a folder or git repository with `.claude-plugin/marketplace.json` listing plugins and where
- * each comes from. An agent knows the marketplaces added to it, kept in its extensions folder
- * (`marketplaces.json`, and a copy of each in `.marketplaces/<name>/`), and installs from them
- * by `<plugin>@<marketplace>` into either scope, through `addExtension()`: the same copy, hash and
- * lock as any extension. Its official marketplace is known without asking; any other is added
- * only by hand, after a warning (the command asks to type its name).
- */
-const exec = promisify(execFile);
+import { cloneRepository } from "./gitClone.js";
 const REGISTRY = "marketplaces.json";
 const COPIES = ".marketplaces";
 const NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
@@ -77,9 +66,8 @@ async function fetchMarketplace(source) {
     try {
         if (await isGitMarketplace(source)) {
             const [location, ref] = source.split("#");
-            await exec("git", ["clone", "--depth", "1", ...(ref ? ["--branch", ref] : []), gitUrl(location), copy]);
-            const commit = (await exec("git", ["-C", copy, "rev-parse", "HEAD"])).stdout.trim();
-            await rm(path.join(copy, ".git"), { recursive: true, force: true });
+            // Without the git program (#89).
+            const commit = await cloneRepository(gitUrl(location), copy, ref ? { ref } : {});
             return { copy, commit };
         }
         await cp(path.resolve(source), copy, { recursive: true, filter: (file) => path.basename(file) !== ".git" });

package/dist/core/session.js

@@ -31,6 +31,7 @@ import { createElicitationHandler } from "./elicitation.js";
 import { createReadOnlyHints, createToolHints } from "./readOnlyHints.js";
 import { projectServerDuplicates } from "./projectServers.js";
 import { createSignInReminder, SIGN_IN_RULE } from "./hooks/signInReminder.js";
+import { createLanguageReminder } from "./hooks/languageReminder.js";
 import { agentKitVersion } from "./version.js";
 /**
  * Builds the `options` object passed to the Agent SDK's `query()` — everything about
@@ -58,6 +59,8 @@ export async function buildSessionOptions(config, runDir, spec, options = {}) {
     // for the interface too, so the agent answers in the language its interface is in.
     const language = chooseLanguage(config.language);
     const replyLine = spec.replyInLanguage === false ? null : replyLanguageInstruction(language);
+    // Said again next to what the model reads, so its narration doesn't drift to English (#85).
+    const languageReminder = spec.replyInLanguage !== false && spec.replyInLanguage !== "prompt-only" && language !== "en" ? createLanguageReminder(language) : undefined;
     const withReplyLine = (prompt) => (replyLine ? `${prompt}\n\n${replyLine}` : prompt);
     const modeControl = createModeControl(mode);
     // The human approval server only exists outside autonomous mode: the point of
@@ -379,7 +382,7 @@ export async function buildSessionOptions(config, runDir, spec, options = {}) {
                     : []),
                 // Registered wherever the approval tool is, and asking only while the current mode is
                 // "interactive": a guided session can switch to interactive and back (ModeControl).
-                ...(includeApprovalTool ? [{ hooks: [createStepGate(runDir, () => modeControl.mode === "interactive", fromExtensions((contribution) => contribution.selfAskingTools))] }] : []),
+                ...(includeApprovalTool ? [{ hooks: [createStepGate(runDir, () => modeControl.mode === "interactive", fromExtensions((contribution) => contribution.selfAskingTools), () => toolLabels)] }] : []),
                 // Likewise for "plan", which any non-autonomous session can switch into: the agent
                 // only reads and plans while it's on (hooks/planGate.ts).
                 ...(includeApprovalTool
@@ -405,12 +408,14 @@ export async function buildSessionOptions(config, runDir, spec, options = {}) {
                     ]
                     : []),
             ],
-            PostToolUse: [{ hooks: [transcriptLogger.postToolUse] }],
+            PostToolUse: [{ hooks: [transcriptLogger.postToolUse] }, ...(languageReminder ? [{ hooks: [languageReminder.postToolUse] }] : [])],
             // The person's message: it ends a batch they approved (#74), and carries the sign-in reminders (#82).
-            ...(guidedGate || signInExtensions.length
+            ...(guidedGate || signInExtensions.length || languageReminder
                 ? {
                     UserPromptSubmit: [
                         ...(guidedGate ? [{ hooks: [guidedGate.userPromptSubmit] }] : []),
+                        // The reply language, next to the person's message too (#85).
+                        ...(languageReminder ? [{ hooks: [languageReminder.userPromptSubmit] }] : []),
                         // With the person's message, which extensions now wait for a sign-in (#82).
                         ...(signInExtensions.length ? [{ hooks: [createSignInReminder({ extensions: () => signInExtensions, status: () => late.view?.controls().mcpServerStatus })] }] : []),
                     ],

package/dist/tui/chatTui.d.ts

@@ -17,6 +17,8 @@ export interface ChatTuiOptions {
     formatAction?: (toolName: string, input: unknown) => string;
     /** Signing in to an extension: whether its link opens in this computer's browser (the default), or how (see `ChatSettings.openBrowser`, #72). */
     openBrowser?: ChatSettings["openBrowser"];
+    /** Claude Code's own commands in the `/` menu: none by default, `"all"`, or the ones named (see `ChatSettings.cliCommands`, #87). */
+    cliCommands?: ChatSettings["cliCommands"];
     /** Printed once before the first prompt, if given. */
     welcomeMessage?: string;
     /** Shown before the cursor at each prompt. */

package/dist/tui/chatTui.js

@@ -77,6 +77,7 @@ export async function runChatTui(options, tuiOptions = {}) {
         toolLabels: tuiOptions.toolLabels,
         formatAction: tuiOptions.formatAction,
         ...(tuiOptions.openBrowser !== undefined ? { openBrowser: tuiOptions.openBrowser } : {}),
+        ...(tuiOptions.cliCommands !== undefined ? { cliCommands: tuiOptions.cliCommands } : {}),
         // Nothing here shows them.
         promptSuggestions: false,
         // /resume: a numbered list, and a number typed.

package/dist/tui/ink/runChatInk.js

@@ -200,6 +200,7 @@ export async function runChatInk(options, tuiOptions = {}) {
         toolPhrase: tuiOptions.toolPhrase,
         formatResult: tuiOptions.formatResult,
         ...(tuiOptions.openBrowser !== undefined ? { openBrowser: tuiOptions.openBrowser } : {}),
+        ...(tuiOptions.cliCommands !== undefined ? { cliCommands: tuiOptions.cliCommands } : {}),
         promptSuggestions: tuiOptions.promptSuggestions ?? true,
         // The /resume list in place of the prompt.
         pick: (title, choices) => input.pick(title, choices),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@falkenslab/agent-kit",
-  "version": "0.30.1",
+  "version": "0.31.0",
   "description": "Library for building an agent on top of the Claude Agent SDK",
   "author": "Francisco Vargas Ruiz",
   "license": "MIT",
@@ -54,6 +54,7 @@
     "@inquirer/prompts": "^8.5.2",
     "@types/react": "^19.3.0",
     "ink": "^6.8.0",
+    "isomorphic-git": "^1.44.5",
     "marked": "^18.0.14",
     "picocolors": "^1.1.1",
     "react": "^19.3.0",