@falkenslab/agent-kit 0.18.0 → 0.19.0

package/dist/core/messages/es.js

@@ -22,6 +22,17 @@ export const es = {
     resumeHint: "↑/↓ elegir · Intro retomar · Esc cancelar",
     resumeQuestion: "Número de la conversación que retomar (Intro para cancelar): ",
     noEarlierRuns: "(no hay conversaciones anteriores que retomar)",
+    commandResume: "Elegir una conversación anterior para seguir con ella",
+    commandPlan: "Entrar en el modo plan, o volver",
+    commandExtensions: "Qué funciona, qué no y por qué; activar o desactivar una",
+    extensionsRunning: (names) => `Funcionando con: ${names}`,
+    extensionsNone: "(ninguna extensión)",
+    extensionOff: (name, reason) => `${name} está desactivada: ${reason}`,
+    extensionsInstalled: "Instaladas:",
+    extensionToggled: (name, enabled) => `(${name} ${enabled ? "activada" : "desactivada"}: la sesión se reabre, con la misma conversación)`,
+    extensionNotInstalled: (name) => `(${name} no está instalada: /extensions las lista)`,
+    extensionsUsage: "(uso: /extensions, /extensions enable <nombre>, /extensions disable <nombre>)",
+    extensionsCantReopen: "(este chat no puede reabrir su sesión: actívala o desactívala desde la terminal y vuelve a empezar)",
     currentRun: "(esta)",
     resumed: (date) => `(retomada la conversación del ${date})`,
     suggestionKey: "tab",
@@ -91,22 +102,6 @@ export const es = {
         Task: ["lanzó {n} subagente", "lanzó {n} subagentes"],
         mcp__time__current_time: ["consultó la hora", "consultó la hora {n} veces"],
         mcp__time__date_math: ["calculó fechas", "calculó fechas {n} veces"],
-        mcp__sourceFiles__list_sources: ["revisó las fuentes", "revisó las fuentes {n} veces"],
-        mcp__sourceFiles__extract_text: ["leyó {n} documento", "leyó {n} documentos"],
-        mcp__sourceFiles__save_to_sources: ["guardó {n} fuente", "guardó {n} fuentes"],
-        mcp__sourceFiles__download_to_sources: ["descargó {n} fuente", "descargó {n} fuentes"],
-        mcp__sourceFiles__request_file: ["pidió {n} fichero", "pidió {n} ficheros"],
-        mcp__sourceFiles__retire_source: ["retiró {n} fuente", "retiró {n} fuentes"],
-        mcp__knowledge__knowledge_index: ["leyó el índice", "leyó el índice {n} veces"],
-        mcp__knowledge__knowledge_search: ["buscó en la base de conocimiento", "buscó en la base de conocimiento {n} veces"],
-        mcp__knowledge__knowledge_read: ["leyó {n} página", "leyó {n} páginas"],
-        mcp__knowledge__knowledge_create: ["creó {n} página", "creó {n} páginas"],
-        mcp__knowledge__knowledge_edit: ["editó {n} página", "editó {n} páginas"],
-        mcp__knowledge__knowledge_rewrite: ["reescribió {n} página", "reescribió {n} páginas"],
-        mcp__knowledge__knowledge_supersede: ["sustituyó {n} página", "sustituyó {n} páginas"],
-        mcp__knowledge__knowledge_retire: ["retiró {n} página", "retiró {n} páginas"],
-        mcp__knowledge__knowledge_log: ["actualizó el registro", "actualizó el registro {n} veces"],
-        mcp__knowledge__knowledge_check: ["revisó la base de conocimiento", "revisó la base de conocimiento {n} veces"],
         mcp__approvals__ask_human: ["hizo {n} pregunta", "hizo {n} preguntas"],
         mcp__approvals__present_plan: ["presentó el plan", "presentó el plan {n} veces"],
     },
@@ -120,7 +115,6 @@ export const es = {
     labels: {
         askingApproval: (summary) => `Pidiendo aprobación humana: ${summary}`,
         waitingManual: "Esperando a que una persona intervenga a mano",
-        savingToSources: (destination) => `Guardando ${destination} en las fuentes`,
         checkingTime: "Consultando la fecha y la hora",
         calculatingDates: "Calculando fechas",
         reading: (file) => `Leyendo ${file}`,
@@ -139,21 +133,6 @@ export const es = {
         applyingSkill: (skill) => `Aplicando la skill "${skill}"`,
         aSkill: "una skill",
         updatingTasks: "Actualizando la lista de tareas",
-        listingSources: "Revisando las fuentes",
-        extractingText: (source) => `Leyendo ${source}`,
-        downloading: (url) => `Descargando ${url} a las fuentes`,
-        requestingFile: (description) => `Pidiendo un fichero: ${description}`,
-        retiringSource: (source) => `Retirando la fuente ${source}`,
-        knowledgeIndex: "Leyendo el índice de la base de conocimiento",
-        knowledgeSearch: (query) => `Buscando "${query}" en la base de conocimiento`,
-        knowledgeRead: (page) => `Leyendo ${page}`,
-        knowledgeCreate: (page) => `Creando ${page}`,
-        knowledgeEdit: (page) => `Editando ${page}`,
-        knowledgeRewrite: (page) => `Reescribiendo ${page}`,
-        knowledgeSupersede: (page) => `Marcando ${page} como sustituida`,
-        knowledgeRetire: (page) => `Retirando ${page}`,
-        knowledgeLog: "Actualizando el registro de la base de conocimiento",
-        knowledgeCheck: "Revisando la base de conocimiento",
         askingHuman: (question) => `Preguntando: ${question}`,
         presentingPlan: "Presentando el plan",
     },

package/dist/core/messages/fr.js

@@ -22,6 +22,17 @@ export const fr = {
     resumeHint: "↑/↓ choisir · Entrée reprendre · Échap annuler",
     resumeQuestion: "Numéro de la conversation à reprendre (Entrée pour annuler) : ",
     noEarlierRuns: "(aucune conversation précédente à reprendre)",
+    commandResume: "Choisir une conversation précédente pour la reprendre",
+    commandPlan: "Passer en mode plan, ou revenir",
+    commandExtensions: "Ce qui tourne, ce qui est éteint et pourquoi ; en activer ou désactiver une",
+    extensionsRunning: (names) => `En service : ${names}`,
+    extensionsNone: "(aucune extension)",
+    extensionOff: (name, reason) => `${name} est désactivée : ${reason}`,
+    extensionsInstalled: "Installées :",
+    extensionToggled: (name, enabled) => `(${name} ${enabled ? "activée" : "désactivée"} : la session se rouvre, avec la même conversation)`,
+    extensionNotInstalled: (name) => `(${name} n'est pas installée : /extensions les liste)`,
+    extensionsUsage: "(usage : /extensions, /extensions enable <nom>, /extensions disable <nom>)",
+    extensionsCantReopen: "(ce chat ne peut pas rouvrir sa session : activez-la ou désactivez-la depuis le terminal, puis recommencez)",
     currentRun: "(celle-ci)",
     resumed: (date) => `(conversation du ${date} reprise)`,
     suggestionKey: "tab",
@@ -91,22 +102,6 @@ export const fr = {
         Task: ["a lancé {n} sous-agent", "a lancé {n} sous-agents"],
         mcp__time__current_time: ["a consulté l'heure", "a consulté l'heure {n} fois"],
         mcp__time__date_math: ["a calculé des dates", "a calculé des dates {n} fois"],
-        mcp__sourceFiles__list_sources: ["a examiné les sources", "a examiné les sources {n} fois"],
-        mcp__sourceFiles__extract_text: ["a lu {n} document", "a lu {n} documents"],
-        mcp__sourceFiles__save_to_sources: ["a enregistré {n} source", "a enregistré {n} sources"],
-        mcp__sourceFiles__download_to_sources: ["a téléchargé {n} source", "a téléchargé {n} sources"],
-        mcp__sourceFiles__request_file: ["a demandé {n} fichier", "a demandé {n} fichiers"],
-        mcp__sourceFiles__retire_source: ["a retiré {n} source", "a retiré {n} sources"],
-        mcp__knowledge__knowledge_index: ["a lu l'index", "a lu l'index {n} fois"],
-        mcp__knowledge__knowledge_search: ["a cherché dans la base", "a cherché dans la base {n} fois"],
-        mcp__knowledge__knowledge_read: ["a lu {n} page", "a lu {n} pages"],
-        mcp__knowledge__knowledge_create: ["a créé {n} page", "a créé {n} pages"],
-        mcp__knowledge__knowledge_edit: ["a modifié {n} page", "a modifié {n} pages"],
-        mcp__knowledge__knowledge_rewrite: ["a réécrit {n} page", "a réécrit {n} pages"],
-        mcp__knowledge__knowledge_supersede: ["a remplacé {n} page", "a remplacé {n} pages"],
-        mcp__knowledge__knowledge_retire: ["a retiré {n} page", "a retiré {n} pages"],
-        mcp__knowledge__knowledge_log: ["a mis à jour le journal", "a mis à jour le journal {n} fois"],
-        mcp__knowledge__knowledge_check: ["a vérifié la base", "a vérifié la base {n} fois"],
         mcp__approvals__ask_human: ["a posé {n} question", "a posé {n} questions"],
         mcp__approvals__present_plan: ["a présenté le plan", "a présenté le plan {n} fois"],
     },
@@ -120,7 +115,6 @@ export const fr = {
     labels: {
         askingApproval: (summary) => `Demande d'approbation humaine : ${summary}`,
         waitingManual: "En attente d'une intervention manuelle",
-        savingToSources: (destination) => `Enregistrement de ${destination} dans les sources`,
         checkingTime: "Consultation de la date et de l'heure",
         calculatingDates: "Calcul de dates",
         reading: (file) => `Lecture de ${file}`,
@@ -139,21 +133,6 @@ export const fr = {
         applyingSkill: (skill) => `Application de la skill "${skill}"`,
         aSkill: "une skill",
         updatingTasks: "Mise à jour de la liste des tâches",
-        listingSources: "Examen des sources",
-        extractingText: (source) => `Lecture de ${source}`,
-        downloading: (url) => `Téléchargement de ${url} dans les sources`,
-        requestingFile: (description) => `Demande d'un fichier : ${description}`,
-        retiringSource: (source) => `Retrait de la source ${source}`,
-        knowledgeIndex: "Lecture de l'index de la base de connaissances",
-        knowledgeSearch: (query) => `Recherche de "${query}" dans la base de connaissances`,
-        knowledgeRead: (page) => `Lecture de ${page}`,
-        knowledgeCreate: (page) => `Création de ${page}`,
-        knowledgeEdit: (page) => `Modification de ${page}`,
-        knowledgeRewrite: (page) => `Réécriture de ${page}`,
-        knowledgeSupersede: (page) => `${page} marquée comme remplacée`,
-        knowledgeRetire: (page) => `Retrait de ${page}`,
-        knowledgeLog: "Mise à jour du journal de la base de connaissances",
-        knowledgeCheck: "Vérification de la base de connaissances",
         askingHuman: (question) => `Question : ${question}`,
         presentingPlan: "Présentation du plan",
     },

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

@@ -17,6 +17,12 @@ export declare function getLanguage(): Language;
  * once per process.
  */
 export declare function chooseLanguage(option?: string): Language;
+/**
+ * Switches the kit's language on purpose, e.g. the person picked another in a chat (#47): from
+ * then on it wins over `--language` and `config.language`, until switched again. The session
+ * says so to the model when it opens next (the controller's `setLanguage()` reopens it).
+ */
+export declare function switchLanguage(language: Language): void;
 /** Warnings about unsupported language codes not shown yet (English, one line each). */
 export declare function takeLanguageWarnings(): string[];
 /** The kit's texts in the current language. */

package/dist/core/messages/index.js

@@ -23,6 +23,8 @@ export function withEnglishFallback(own) {
 let current = "en";
 let messages = en;
 let chosen = false;
+// A language switched to on purpose (switchLanguage()): kept over --language and options.
+let switched = false;
 let pendingWarnings = [];
 const warned = new Set();
 /** Sets the language of the kit's texts directly (a host that resolved it itself, tests). */
@@ -43,7 +45,7 @@ export function getLanguage() {
  * once per process.
  */
 export function chooseLanguage(option) {
-    if (chosen && option === undefined)
+    if (switched || (chosen && option === undefined))
         return current;
     const resolved = detectLanguage(option);
     for (const warning of resolved.warnings) {
@@ -55,6 +57,15 @@ export function chooseLanguage(option) {
     setLanguage(resolved.language);
     return current;
 }
+/**
+ * Switches the kit's language on purpose, e.g. the person picked another in a chat (#47): from
+ * then on it wins over `--language` and `config.language`, until switched again. The session
+ * says so to the model when it opens next (the controller's `setLanguage()` reopens it).
+ */
+export function switchLanguage(language) {
+    setLanguage(language);
+    switched = true;
+}
 /** Warnings about unsupported language codes not shown yet (English, one line each). */
 export function takeLanguageWarnings() {
     const taken = pendingWarnings;

package/dist/core/packaged.d.ts

@@ -0,0 +1,10 @@
+/** A path inside `…/app.asar/…`, as the unpacked copy next to it (`…/app.asar.unpacked/…`); any other path as it is. */
+export declare function outsideArchive(file: string): string;
+/**
+ * The SDK's CLI binary unpacked next to the archive, when the kit runs packaged: the SDK would
+ * resolve it inside `app.asar`, where it can't be executed, and its first turn would hang with
+ * no error (confirmed empirically). Looked up as the SDK does (`@anthropic-ai/claude-agent-sdk-
+ * <platform>-<arch>`, either libc on Linux), with `resolve` replaceable for tests. `undefined`
+ * when not packaged, or when the build didn't unpack it: then the SDK finds its own.
+ */
+export declare function unpackedClaudeExecutable(resolve?: (request: string) => string, platform?: NodeJS.Platform, arch?: string): string | undefined;

package/dist/core/packaged.js

@@ -0,0 +1,38 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+/**
+ * Running packaged in an archive (Electron's `app.asar`, ADR-026, #42). Electron reads files
+ * inside the archive for its own process, but another process can't: not the Claude Code CLI
+ * reading a plugin, not the binary itself. So every path the kit hands to another process goes
+ * through `outsideArchive()`, which points it at the copy the build unpacked (`asarUnpack`).
+ */
+const ARCHIVE = /([\\/])app\.asar([\\/])/;
+/** A path inside `…/app.asar/…`, as the unpacked copy next to it (`…/app.asar.unpacked/…`); any other path as it is. */
+export function outsideArchive(file) {
+    return file.replace(ARCHIVE, "$1app.asar.unpacked$2");
+}
+/**
+ * The SDK's CLI binary unpacked next to the archive, when the kit runs packaged: the SDK would
+ * resolve it inside `app.asar`, where it can't be executed, and its first turn would hang with
+ * no error (confirmed empirically). Looked up as the SDK does (`@anthropic-ai/claude-agent-sdk-
+ * <platform>-<arch>`, either libc on Linux), with `resolve` replaceable for tests. `undefined`
+ * when not packaged, or when the build didn't unpack it: then the SDK finds its own.
+ */
+export function unpackedClaudeExecutable(resolve = createRequire(import.meta.url).resolve, platform = process.platform, arch = process.arch) {
+    const packages = platform === "linux" ? [`linux-${arch}`, `linux-${arch}-musl`] : [`${platform}-${arch}`];
+    for (const suffix of packages) {
+        let file;
+        try {
+            file = resolve(`@anthropic-ai/claude-agent-sdk-${suffix}/claude${platform === "win32" ? ".exe" : ""}`);
+        }
+        catch {
+            continue;
+        }
+        if (!ARCHIVE.test(file))
+            return undefined;
+        const unpacked = outsideArchive(file);
+        if (existsSync(unpacked))
+            return unpacked;
+    }
+    return undefined;
+}

package/dist/core/pluginAgents.d.ts

@@ -0,0 +1,20 @@
+import type { AgentDefinition } from "@anthropic-ai/claude-agent-sdk";
+/**
+ * A plugin's subagents (`agents/<file>.md`, ADR-025), read so the session registers them as it
+ * does an agent's own from `buildSubagents()`: in the type gate's allow-list, in the `Agent` and
+ * `Bash` decision, and with the reply-language line. The SDK loads them itself as
+ * `<plugin>:<name>`, the name from the frontmatter, not the file (confirmed empirically); a
+ * definition under that same key in `options.agents` replaces the plugin's (also confirmed), which
+ * is how the kit adds the line.
+ */
+/** A markdown file's frontmatter: `key: value`, with `[a, b]`, `a, b` or a YAML list for lists. */
+export declare function frontmatter(text: string): {
+    fields: Record<string, string | string[]>;
+    body: string;
+};
+/**
+ * The subagents of the plugins in `roots`, by the name the SDK gives them (`<plugin>:<name>`):
+ * `description` and the body as the prompt, `tools` (none listed: it inherits the session's),
+ * `model` and `maxTurns` when given.
+ */
+export declare function pluginAgents(roots: readonly string[]): Promise<Record<string, AgentDefinition>>;

package/dist/core/pluginAgents.js

@@ -0,0 +1,76 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+/**
+ * A plugin's subagents (`agents/<file>.md`, ADR-025), read so the session registers them as it
+ * does an agent's own from `buildSubagents()`: in the type gate's allow-list, in the `Agent` and
+ * `Bash` decision, and with the reply-language line. The SDK loads them itself as
+ * `<plugin>:<name>`, the name from the frontmatter, not the file (confirmed empirically); a
+ * definition under that same key in `options.agents` replaces the plugin's (also confirmed), which
+ * is how the kit adds the line.
+ */
+/** A markdown file's frontmatter: `key: value`, with `[a, b]`, `a, b` or a YAML list for lists. */
+export function frontmatter(text) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+    if (!match)
+        return { fields: {}, body: text };
+    const fields = {};
+    const lines = match[1].split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const kv = /^([A-Za-z_][\w-]*):\s*(.*)$/.exec(lines[i]);
+        if (!kv)
+            continue;
+        const [, key, raw] = kv;
+        if (raw === "") {
+            const items = [];
+            while (i + 1 < lines.length && /^\s+-\s/.test(lines[i + 1]))
+                items.push(lines[++i].replace(/^\s+-\s*/, ""));
+            fields[key] = items.map(unquote);
+        }
+        else if (/^\[.*\]$/.test(raw)) {
+            fields[key] = raw.slice(1, -1).split(",").map(unquote).filter(Boolean);
+        }
+        else {
+            fields[key] = unquote(raw);
+        }
+    }
+    return { fields, body: text.slice(match[0].length).trim() };
+}
+const unquote = (value) => value.trim().replace(/^["']|["']$/g, "");
+/** A field as a list: a list as is, `a, b` split on commas. */
+function list(value) {
+    if (value === undefined)
+        return undefined;
+    return Array.isArray(value) ? value : value.split(",").map(unquote).filter(Boolean);
+}
+/**
+ * The subagents of the plugins in `roots`, by the name the SDK gives them (`<plugin>:<name>`):
+ * `description` and the body as the prompt, `tools` (none listed: it inherits the session's),
+ * `model` and `maxTurns` when given.
+ */
+export async function pluginAgents(roots) {
+    const agents = {};
+    for (const root of roots) {
+        let plugin;
+        try {
+            plugin = JSON.parse(await readFile(path.join(root, ".claude-plugin", "plugin.json"), "utf8")).name;
+        }
+        catch {
+            continue;
+        }
+        const files = await readdir(path.join(root, "agents")).catch(() => []);
+        for (const file of files.filter((name) => name.endsWith(".md"))) {
+            const { fields, body } = frontmatter(await readFile(path.join(root, "agents", file), "utf8"));
+            const name = typeof fields.name === "string" && fields.name ? fields.name : file.replace(/\.md$/, "");
+            const tools = list(fields.tools);
+            const maxTurns = typeof fields.maxTurns === "string" ? Number(fields.maxTurns) : undefined;
+            agents[`${plugin}:${name}`] = {
+                description: typeof fields.description === "string" ? fields.description : "",
+                prompt: body,
+                ...(tools ? { tools } : {}),
+                ...(typeof fields.model === "string" ? { model: fields.model } : {}),
+                ...(maxTurns && Number.isFinite(maxTurns) ? { maxTurns } : {}),
+            };
+        }
+    }
+    return agents;
+}

package/dist/core/runner.js

@@ -1,4 +1,5 @@
 import { query } from "@anthropic-ai/claude-agent-sdk";
+import { sessionViewOf } from "./sessionFacts.js";
 /**
  * A turn's errors without the CLI's internal diagnostics: an interrupted turn ends with
  * one like "[ede_diagnostic] result_type=user ... stop_reason=tool_use" (seen on Esc),
@@ -27,11 +28,16 @@ export function toolResultText(content) {
  */
 export function runQuery(prompt, options) {
     const result = query({ prompt, options });
+    // What the session is, for an extension that asks (sessionFacts.ts): the controls now, the
+    // tools and skills when the session starts.
+    const view = sessionViewOf(options);
+    view?.attach({ supportedCommands: () => result.supportedCommands(), contextUsage: () => contextUsage() });
     // The main agent's tool calls by id, to name the results that come back for them.
     const toolNames = new Map();
     async function* generateEvents() {
         for await (const message of result) {
             if (message.type === "system" && message.subtype === "init") {
+                view?.attach({ tools: message.tools, skills: message.skills });
                 const failedServers = message.mcp_servers.filter((s) => s.status === "failed").map((s) => s.name);
                 if (failedServers.length > 0)
                     yield { type: "mcp-error", failedServers };
@@ -103,14 +109,15 @@ export function runQuery(prompt, options) {
         interrupt: () => result.interrupt(),
         close: () => result.close(),
         supportedCommands: () => result.supportedCommands(),
-        contextUsage: async () => {
-            try {
-                const usage = await result.getContextUsage();
-                return { percentage: usage.percentage, totalTokens: usage.totalTokens, maxTokens: usage.maxTokens };
-            }
-            catch {
-                return null;
-            }
-        },
+        contextUsage,
     };
+    async function contextUsage() {
+        try {
+            const usage = await result.getContextUsage();
+            return { percentage: usage.percentage, totalTokens: usage.totalTokens, maxTokens: usage.maxTokens };
+        }
+        catch {
+            return null;
+        }
+    }
 }

package/dist/core/session.d.ts

@@ -1,7 +1,9 @@
 import type { Options, SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
 import { type TranscriptLogger } from "./hooks/transcriptLogger.js";
 import { type ModeControl } from "./modeControl.js";
-import type { KnowledgeStore } from "./knowledgeStore.js";
+import type { KnowledgeStore } from "../extensions/knowledge/knowledgeStore.js";
+import { type ExtensionDirs, type InstalledExtension } from "./externalExtensions.js";
+import type { ToolLabels } from "./toolLabels.js";
 import type { AgentSpec, BaseSessionConfig } from "./agentSpec.js";
 import { type Language } from "./language.js";
 import { type RunFolder } from "./runs.js";
@@ -12,9 +14,10 @@ import { type RunFolder } from "./runs.js";
  * one-shot run or an `AsyncIterable` for a multi-turn chat).
  *
  * Everything actually *about the domain* (which system prompt, which MCP servers besides
- * the generic human-in-the-loop/knowledge ones below, which plugin roots, which
- * subagents) is behind `spec` (see agentSpec.ts) — this function only knows the generic
- * fields on `BaseSessionConfig`.
+ * the generic human-in-the-loop ones below, which plugin roots, which subagents) is behind
+ * `spec` (see agentSpec.ts), and the kit's optional parts (the knowledge base, the sources
+ * folder) are extensions whose contributions this function puts together (extensions.ts,
+ * ADR-025): it names none of them.
  *
  * The per-mode behavioral differences (whether the approval/manual-intervention tools
  * exist, whether the interactive step gate or the plan gate decides) all fall out of
@@ -33,10 +36,32 @@ export declare function buildSessionOptions<TConfig extends BaseSessionConfig>(c
     transcriptPath: string;
     modeControl: ModeControl;
     language: Language;
-    /** The knowledge base's store, when the agent reaches it through the `knowledge_*` tools. */
+    /** How the chat shows the extensions' tools (`runChatInk()` takes them from a session opener). */
+    toolLabels: ToolLabels;
+    /** The installed extensions and what this session runs with, for `/extensions` (#37). */
+    extensions: ExtensionsStatus;
+    /** The knowledge base's store, when the knowledge extension is on (for a host that reads the knowledge base). */
     knowledgeStore?: KnowledgeStore;
+    /** What each active extension hands the host (its contribution's `api`), by its name: the sources' `addSource`, the knowledge base's store. */
+    apis: Record<string, Record<string, unknown>>;
 }>;
 export { createModeControl, togglePlanMode, type ModeControl } from "./modeControl.js";
+/** The extensions of a session: where they're installed, what's installed, what runs and what can't (with why). */
+export interface ExtensionsStatus {
+    dirs: ExtensionDirs;
+    installed: InstalledExtension[];
+    /** The names of the extensions this session runs with, the kit's and the agent's too. */
+    active: string[];
+    /** What each active one is, from its manifest: for a view that lists them. */
+    about: Record<string, {
+        description: string;
+        provides: string[];
+    }>;
+    inactive: {
+        name: string;
+        reason: string;
+    }[];
+}
 /**
  * The CLI's folder for a project, where it keeps each session's transcript and large tool
  * results (`<session>/tool-results/`): the project's path with every character but letters