@falkenslab/agent-kit 0.10.1 → 0.12.0

package/dist/core/messages/en.js

@@ -0,0 +1,102 @@
+const plural = (count, one, many) => (count === 1 ? one : many);
+export const en = {
+    thinking: "Thinking…",
+    escToInterrupt: "esc to interrupt",
+    workedFor: (seconds) => `Worked for ${seconds}s`,
+    turns: (count) => `${count} ${plural(count, "turn", "turns")}`,
+    tokens: (input, output) => `${input} in / ${output} out`,
+    context: (percent) => `context ${percent}%`,
+    mode: (mode) => mode,
+    switchModeKey: "shift+tab",
+    modeLocked: (mode) => (mode ? `(${mode} mode can't be switched during the session)` : "(the mode can't be switched during the session)"),
+    linesBelow: (count) => `↓ ${count} more ${plural(count, "line", "lines")} (Ctrl+End)`,
+    copiedCharacters: (count) => `copied ${count} ${plural(count, "character", "characters")}`,
+    queued: (line) => `queued: ${line}`,
+    interrupted: "(interrupted)",
+    copiedReply: (characters) => `(copied the last reply: ${characters} characters)`,
+    nothingToCopy: "(nothing to copy yet)",
+    unknownCommand: (command) => `Unknown command: /${command}`,
+    mcpFailed: (servers) => `Some MCP servers failed to connect: ${servers}`,
+    resumeTitle: "Resume a conversation",
+    resumeHint: "↑/↓ choose · Enter resume · Esc cancel",
+    resumeQuestion: "Number of the conversation to resume (Enter to cancel): ",
+    noEarlierRuns: "(no earlier conversations to resume)",
+    currentRun: "(this one)",
+    resumed: (date) => `(resumed the conversation of ${date})`,
+    suggestionKey: "tab",
+    reverseSearch: (query) => `(reverse-i-search)'${query}': `,
+    pastedText: (id, extraLines) => `[Pasted text #${id} +${extraLines} ${plural(extraLines, "line", "lines")}]`,
+    shortcuts: [
+        "Enter send  ·  \\ + Enter or Ctrl+J new line  ·  Tab complete or take the suggestion",
+        "↑/↓ history  ·  Ctrl+R search history  ·  ↑ on an empty prompt edits the last queued message",
+        "Ctrl+W delete word  ·  Ctrl+K to line end  ·  Ctrl+U clear  ·  Ctrl+←/→ move by word",
+        "@ mention a file  ·  /copy copy the last reply  ·  Shift+Tab switch mode  ·  Ctrl+O unfold tool calls",
+        "Esc interrupt  ·  Ctrl+C interrupt or exit  ·  PgUp/PgDn or wheel scroll  ·  Ctrl+End bottom",
+        "Drag to select, right-click to copy (full screen)",
+        "/resume resume an earlier conversation  ·  --continue on the command line resumes the latest one",
+    ],
+    moreLines: (count) => `… (${count} more lines)`,
+    proceed: "Do you want to proceed?",
+    yes: "Yes",
+    no: "No",
+    stop: "Stop",
+    doneContinue: "Done, continue",
+    approved: "✔ Approved",
+    rejected: "✘ Rejected",
+    stopped: "■ Stopped",
+    done: "✔ Done",
+    answeredByFile: "(answered through the response file)",
+    terminalQuestion: "Allow this to continue? [Y/n/q] ",
+    proposedAction: "Proposed action",
+    toolLine: (tool) => `Tool: ${tool}`,
+    parametersLine: (parameters) => `Parameters: ${parameters}`,
+    approvalTitle: "Human confirmation required before publishing",
+    summaryLine: (summary) => `Summary: ${summary}`,
+    toolPhrases: {
+        Read: ["read {n} file", "read {n} files"],
+        Write: ["wrote {n} file", "wrote {n} files"],
+        Edit: ["edited {n} file", "edited {n} files"],
+        Glob: ["listed files", "listed files {n} times"],
+        Grep: ["searched {n} time", "searched {n} times"],
+        Bash: ["ran {n} shell command", "ran {n} shell commands"],
+        WebSearch: ["searched the web", "searched the web {n} times"],
+        WebFetch: ["fetched {n} page", "fetched {n} pages"],
+        Skill: ["used {n} skill", "used {n} skills"],
+        Agent: ["ran {n} subagent", "ran {n} subagents"],
+        Task: ["ran {n} subagent", "ran {n} subagents"],
+    },
+    otherTools: ["used {n} tool", "used {n} tools"],
+    noOutput: "(no output)",
+    error: "error",
+    moreResultLines: (count) => `(+${count} ${plural(count, "line", "lines")})`,
+    earlierCalls: (count) => `… ${count} earlier`,
+    labels: {
+        askingApproval: (summary) => `Asking for human approval: ${summary}`,
+        waitingManual: "Waiting for a human to intervene manually",
+        savingToSources: (destination) => `Saving a file to sources/${destination}`,
+        reading: (file) => `Reading ${file}`,
+        writing: (file) => `Writing to ${file}`,
+        editing: (file) => `Editing ${file}`,
+        aFile: "a file",
+        findingFiles: (pattern) => `Searching for files matching "${pattern}"`,
+        searchingContents: (pattern) => `Searching file contents for "${pattern}"`,
+        running: (command) => `Running "${command}"`,
+        delegating: (subagent) => `Delegating to "${subagent}"`,
+        delegatingTask: (subagent, description) => `Delegating to "${subagent}": ${description}`,
+        aSubagent: "a subagent",
+        fetching: (url) => `Fetching ${url}`,
+        aPage: "a page",
+        searchingWeb: (query) => `Searching the web for "${query}"`,
+        applyingSkill: (skill) => `Applying the "${skill}" skill`,
+        aSkill: "a skill",
+    },
+    auth: {
+        noToken: "No Claude authentication token was found",
+        noTokenDetail: "(neither the CLAUDE_CODE_OAUTH_TOKEN environment variable, nor one passed in).",
+        generateQuestion: 'Generate one now with "claude setup-token" (requires a Claude Pro/Max subscription)?',
+        cantStart: "The agent can't start without a token. Set CLAUDE_CODE_OAUTH_TOKEN by hand (or run this again and accept generating it) and try again.",
+        generatingHeading: "=== Generating a Claude authentication token ===",
+        browserWillOpen: "A browser will open to log in; follow the instructions the command itself prints below.",
+        generated: "Token generated for this run. Save it yourself (e.g. CLAUDE_CODE_OAUTH_TOKEN in your shell profile) to skip this next time.",
+    },
+};

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

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

package/dist/core/messages/es.js

@@ -0,0 +1,103 @@
+const plural = (count, one, many) => (count === 1 ? one : many);
+const MODES = { autonomous: "autónomo", guided: "guiado", interactive: "interactivo" };
+export const es = {
+    thinking: "Pensando…",
+    escToInterrupt: "esc para interrumpir",
+    workedFor: (seconds) => `Trabajó ${seconds}s`,
+    turns: (count) => `${count} ${plural(count, "turno", "turnos")}`,
+    tokens: (input, output) => `${input} ent. / ${output} sal.`,
+    context: (percent) => `contexto ${percent}%`,
+    mode: (mode) => MODES[mode],
+    switchModeKey: "⇧tab",
+    modeLocked: (mode) => (mode ? `(el modo ${MODES[mode]} no se puede cambiar durante la sesión)` : "(el modo no se puede cambiar durante la sesión)"),
+    linesBelow: (count) => `↓ ${count} ${plural(count, "línea más", "líneas más")} (Ctrl+Fin)`,
+    copiedCharacters: (count) => `${count} ${plural(count, "carácter copiado", "caracteres copiados")}`,
+    queued: (line) => `en cola: ${line}`,
+    interrupted: "(interrumpido)",
+    copiedReply: (characters) => `(copiada la última respuesta: ${characters} caracteres)`,
+    nothingToCopy: "(aún no hay nada que copiar)",
+    unknownCommand: (command) => `Comando desconocido: /${command}`,
+    mcpFailed: (servers) => `Algunos servidores MCP no se han podido conectar: ${servers}`,
+    resumeTitle: "Retomar una conversación",
+    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)",
+    currentRun: "(esta)",
+    resumed: (date) => `(retomada la conversación del ${date})`,
+    suggestionKey: "tab",
+    reverseSearch: (query) => `(búsqueda inversa)'${query}': `,
+    pastedText: (id, extraLines) => `[Texto pegado #${id} +${extraLines} ${plural(extraLines, "línea", "líneas")}]`,
+    shortcuts: [
+        "Intro enviar  ·  \\ + Intro o Ctrl+J nueva línea  ·  Tab completar o aceptar la sugerencia",
+        "↑/↓ historial  ·  Ctrl+R buscar en el historial  ·  ↑ con el prompt vacío edita el último mensaje en cola",
+        "Ctrl+W borrar palabra  ·  Ctrl+K hasta el final  ·  Ctrl+U vaciar  ·  Ctrl+←/→ moverse por palabras",
+        "@ mencionar un fichero  ·  /copy copiar la última respuesta  ·  Mayús+Tab cambiar de modo  ·  Ctrl+O desplegar herramientas",
+        "Esc interrumpir  ·  Ctrl+C interrumpir o salir  ·  RePág/AvPág o rueda desplazarse  ·  Ctrl+Fin abajo del todo",
+        "Arrastrar para seleccionar, clic derecho para copiar (pantalla completa)",
+        "/resume retomar una conversación anterior  ·  --continue al arrancar retoma la última",
+    ],
+    moreLines: (count) => `… (${count} líneas más)`,
+    proceed: "¿Quieres continuar?",
+    yes: "Sí",
+    no: "No",
+    stop: "Parar",
+    doneContinue: "Hecho, continuar",
+    approved: "✔ Aprobado",
+    rejected: "✘ Rechazado",
+    stopped: "■ Parado",
+    done: "✔ Hecho",
+    answeredByFile: "(respondido con el fichero de respuesta)",
+    terminalQuestion: "¿Permitir que continúe? [Y/n/q] ",
+    proposedAction: "Acción propuesta",
+    toolLine: (tool) => `Herramienta: ${tool}`,
+    parametersLine: (parameters) => `Parámetros: ${parameters}`,
+    approvalTitle: "Hace falta confirmación humana antes de publicar",
+    summaryLine: (summary) => `Resumen: ${summary}`,
+    toolPhrases: {
+        Read: ["leyó {n} fichero", "leyó {n} ficheros"],
+        Write: ["escribió {n} fichero", "escribió {n} ficheros"],
+        Edit: ["editó {n} fichero", "editó {n} ficheros"],
+        Glob: ["listó ficheros", "listó ficheros {n} veces"],
+        Grep: ["buscó {n} vez", "buscó {n} veces"],
+        Bash: ["ejecutó {n} comando", "ejecutó {n} comandos"],
+        WebSearch: ["buscó en la web", "buscó en la web {n} veces"],
+        WebFetch: ["abrió {n} página", "abrió {n} páginas"],
+        Skill: ["usó {n} skill", "usó {n} skills"],
+        Agent: ["lanzó {n} subagente", "lanzó {n} subagentes"],
+        Task: ["lanzó {n} subagente", "lanzó {n} subagentes"],
+    },
+    otherTools: ["usó {n} herramienta", "usó {n} herramientas"],
+    noOutput: "(sin salida)",
+    error: "error",
+    moreResultLines: (count) => `(+${count} ${plural(count, "línea", "líneas")})`,
+    earlierCalls: (count) => `… ${count} ${plural(count, "anterior", "anteriores")}`,
+    labels: {
+        askingApproval: (summary) => `Pidiendo aprobación humana: ${summary}`,
+        waitingManual: "Esperando a que una persona intervenga a mano",
+        savingToSources: (destination) => `Guardando un fichero en sources/${destination}`,
+        reading: (file) => `Leyendo ${file}`,
+        writing: (file) => `Escribiendo en ${file}`,
+        editing: (file) => `Editando ${file}`,
+        aFile: "un fichero",
+        findingFiles: (pattern) => `Buscando ficheros que coincidan con "${pattern}"`,
+        searchingContents: (pattern) => `Buscando "${pattern}" en los ficheros`,
+        running: (command) => `Ejecutando "${command}"`,
+        delegating: (subagent) => `Delegando en "${subagent}"`,
+        delegatingTask: (subagent, description) => `Delegando en "${subagent}": ${description}`,
+        aSubagent: "un subagente",
+        fetching: (url) => `Abriendo ${url}`,
+        aPage: "una página",
+        searchingWeb: (query) => `Buscando en la web "${query}"`,
+        applyingSkill: (skill) => `Aplicando la skill "${skill}"`,
+        aSkill: "una skill",
+    },
+    auth: {
+        noToken: "No se ha encontrado ningún token de autenticación de Claude",
+        noTokenDetail: "(ni la variable de entorno CLAUDE_CODE_OAUTH_TOKEN ni uno pasado por código).",
+        generateQuestion: '¿Generar uno ahora con "claude setup-token"? (requiere una suscripción Claude Pro/Max)',
+        cantStart: "El agente no puede arrancar sin un token. Define CLAUDE_CODE_OAUTH_TOKEN a mano (o vuelve a ejecutarlo y acepta generarlo) e inténtalo de nuevo.",
+        generatingHeading: "=== Generando un token de autenticación de Claude ===",
+        browserWillOpen: "Se abrirá un navegador para iniciar sesión; sigue las instrucciones que el propio comando muestra abajo.",
+        generated: "Token generado para esta ejecución. Guárdalo tú (p. ej. CLAUDE_CODE_OAUTH_TOKEN en el perfil de tu shell) para no repetir esto la próxima vez.",
+    },
+};

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

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

package/dist/core/messages/fr.js

@@ -0,0 +1,103 @@
+const plural = (count, one, many) => (count === 1 ? one : many);
+const MODES = { autonomous: "autonome", guided: "guidé", interactive: "interactif" };
+export const fr = {
+    thinking: "Réflexion…",
+    escToInterrupt: "échap pour interrompre",
+    workedFor: (seconds) => `A travaillé ${seconds}s`,
+    turns: (count) => `${count} ${plural(count, "tour", "tours")}`,
+    tokens: (input, output) => `${input} entr. / ${output} sort.`,
+    context: (percent) => `contexte ${percent}%`,
+    mode: (mode) => MODES[mode],
+    switchModeKey: "⇧tab",
+    modeLocked: (mode) => (mode ? `(le mode ${MODES[mode]} ne peut pas changer pendant la session)` : "(le mode ne peut pas changer pendant la session)"),
+    linesBelow: (count) => `↓ ${count} ${plural(count, "ligne de plus", "lignes de plus")} (Ctrl+Fin)`,
+    copiedCharacters: (count) => `${count} ${plural(count, "caractère copié", "caractères copiés")}`,
+    queued: (line) => `en attente : ${line}`,
+    interrupted: "(interrompu)",
+    copiedReply: (characters) => `(dernière réponse copiée : ${characters} caractères)`,
+    nothingToCopy: "(rien à copier pour l'instant)",
+    unknownCommand: (command) => `Commande inconnue : /${command}`,
+    mcpFailed: (servers) => `Certains serveurs MCP n'ont pas pu se connecter : ${servers}`,
+    resumeTitle: "Reprendre une conversation",
+    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)",
+    currentRun: "(celle-ci)",
+    resumed: (date) => `(conversation du ${date} reprise)`,
+    suggestionKey: "tab",
+    reverseSearch: (query) => `(recherche inverse)'${query}': `,
+    pastedText: (id, extraLines) => `[Texte collé #${id} +${extraLines} ${plural(extraLines, "ligne", "lignes")}]`,
+    shortcuts: [
+        "Entrée envoyer  ·  \\ + Entrée ou Ctrl+J nouvelle ligne  ·  Tab compléter ou accepter la suggestion",
+        "↑/↓ historique  ·  Ctrl+R chercher dans l'historique  ·  ↑ sur un prompt vide modifie le dernier message en attente",
+        "Ctrl+W effacer un mot  ·  Ctrl+K jusqu'à la fin  ·  Ctrl+U vider  ·  Ctrl+←/→ par mots",
+        "@ mentionner un fichier  ·  /copy copier la dernière réponse  ·  Maj+Tab changer de mode  ·  Ctrl+O déplier les outils",
+        "Échap interrompre  ·  Ctrl+C interrompre ou quitter  ·  PgPréc/PgSuiv ou molette défiler  ·  Ctrl+Fin tout en bas",
+        "Glisser pour sélectionner, clic droit pour copier (plein écran)",
+        "/resume reprendre une conversation précédente  ·  --continue au démarrage reprend la dernière",
+    ],
+    moreLines: (count) => `… (${count} lignes de plus)`,
+    proceed: "Voulez-vous continuer ?",
+    yes: "Oui",
+    no: "Non",
+    stop: "Arrêter",
+    doneContinue: "Terminé, continuer",
+    approved: "✔ Approuvé",
+    rejected: "✘ Refusé",
+    stopped: "■ Arrêté",
+    done: "✔ Terminé",
+    answeredByFile: "(répondu par le fichier de réponse)",
+    terminalQuestion: "Autoriser la suite ? [Y/n/q] ",
+    proposedAction: "Action proposée",
+    toolLine: (tool) => `Outil : ${tool}`,
+    parametersLine: (parameters) => `Paramètres : ${parameters}`,
+    approvalTitle: "Confirmation humaine requise avant de publier",
+    summaryLine: (summary) => `Résumé : ${summary}`,
+    toolPhrases: {
+        Read: ["a lu {n} fichier", "a lu {n} fichiers"],
+        Write: ["a écrit {n} fichier", "a écrit {n} fichiers"],
+        Edit: ["a modifié {n} fichier", "a modifié {n} fichiers"],
+        Glob: ["a listé des fichiers", "a listé des fichiers {n} fois"],
+        Grep: ["a cherché {n} fois", "a cherché {n} fois"],
+        Bash: ["a exécuté {n} commande", "a exécuté {n} commandes"],
+        WebSearch: ["a cherché sur le web", "a cherché sur le web {n} fois"],
+        WebFetch: ["a ouvert {n} page", "a ouvert {n} pages"],
+        Skill: ["a utilisé {n} skill", "a utilisé {n} skills"],
+        Agent: ["a lancé {n} sous-agent", "a lancé {n} sous-agents"],
+        Task: ["a lancé {n} sous-agent", "a lancé {n} sous-agents"],
+    },
+    otherTools: ["a utilisé {n} outil", "a utilisé {n} outils"],
+    noOutput: "(aucune sortie)",
+    error: "erreur",
+    moreResultLines: (count) => `(+${count} ${plural(count, "ligne", "lignes")})`,
+    earlierCalls: (count) => `… ${count} ${plural(count, "précédent", "précédents")}`,
+    labels: {
+        askingApproval: (summary) => `Demande d'approbation humaine : ${summary}`,
+        waitingManual: "En attente d'une intervention manuelle",
+        savingToSources: (destination) => `Enregistrement d'un fichier dans sources/${destination}`,
+        reading: (file) => `Lecture de ${file}`,
+        writing: (file) => `Écriture dans ${file}`,
+        editing: (file) => `Modification de ${file}`,
+        aFile: "un fichier",
+        findingFiles: (pattern) => `Recherche des fichiers correspondant à "${pattern}"`,
+        searchingContents: (pattern) => `Recherche de "${pattern}" dans les fichiers`,
+        running: (command) => `Exécution de "${command}"`,
+        delegating: (subagent) => `Délégation à "${subagent}"`,
+        delegatingTask: (subagent, description) => `Délégation à "${subagent}" : ${description}`,
+        aSubagent: "un sous-agent",
+        fetching: (url) => `Ouverture de ${url}`,
+        aPage: "une page",
+        searchingWeb: (query) => `Recherche sur le web de "${query}"`,
+        applyingSkill: (skill) => `Application de la skill "${skill}"`,
+        aSkill: "une skill",
+    },
+    auth: {
+        noToken: "Aucun jeton d'authentification Claude n'a été trouvé",
+        noTokenDetail: "(ni la variable d'environnement CLAUDE_CODE_OAUTH_TOKEN, ni un jeton passé par le code).",
+        generateQuestion: 'En générer un maintenant avec "claude setup-token" ? (nécessite un abonnement Claude Pro/Max)',
+        cantStart: "L'agent ne peut pas démarrer sans jeton. Définissez CLAUDE_CODE_OAUTH_TOKEN à la main (ou relancez et acceptez de le générer), puis réessayez.",
+        generatingHeading: "=== Génération d'un jeton d'authentification Claude ===",
+        browserWillOpen: "Un navigateur va s'ouvrir pour vous connecter ; suivez les instructions que la commande affiche ci-dessous.",
+        generated: "Jeton généré pour cette exécution. Enregistrez-le vous-même (par ex. CLAUDE_CODE_OAUTH_TOKEN dans le profil de votre shell) pour éviter cette étape la prochaine fois.",
+    },
+};

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

@@ -0,0 +1,23 @@
+import { type Language } from "../language.js";
+import { type Messages } from "./en.js";
+export type { Messages, ToolPhrase } from "./en.js";
+/** A language's texts; any it lacks come from English (nested groups key by key). */
+export declare function messagesFor(language: Language): Messages;
+/** A catalog completed with the English text for every key it lacks. */
+export declare function withEnglishFallback(own: Partial<Messages>): Messages;
+/** Sets the language of the kit's texts directly (a host that resolved it itself, tests). */
+export declare function setLanguage(language: Language): void;
+/** The language of the kit's texts right now. */
+export declare function getLanguage(): Language;
+/**
+ * Resolves the language from `--language`, `option` and the system's (see language.ts) and
+ * makes it the kit's, the first time or whenever an option is given; otherwise keeps the one
+ * already chosen (so a chat started without `language` follows `buildSessionOptions()`'s
+ * `config.language`). Warnings for unsupported codes wait in `takeLanguageWarnings()`, each
+ * once per process.
+ */
+export declare function chooseLanguage(option?: string): Language;
+/** 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. */
+export declare function t(): Messages;

package/dist/core/messages/index.js

@@ -0,0 +1,67 @@
+import { detectLanguage } from "../language.js";
+import { en } from "./en.js";
+import { es } from "./es.js";
+import { fr } from "./fr.js";
+import { de } from "./de.js";
+const CATALOGS = { en, es, fr, de };
+/** A language's texts; any it lacks come from English (nested groups key by key). */
+export function messagesFor(language) {
+    return withEnglishFallback(CATALOGS[language]);
+}
+/** A catalog completed with the English text for every key it lacks. */
+export function withEnglishFallback(own) {
+    return {
+        ...en,
+        ...own,
+        labels: { ...en.labels, ...own.labels },
+        auth: { ...en.auth, ...own.auth },
+        toolPhrases: { ...en.toolPhrases, ...own.toolPhrases },
+    };
+}
+// One language per process: `--language` and the system's language are the process's, and
+// an agent has one. English until something chooses (tests, a component used on its own).
+let current = "en";
+let messages = en;
+let chosen = false;
+let pendingWarnings = [];
+const warned = new Set();
+/** Sets the language of the kit's texts directly (a host that resolved it itself, tests). */
+export function setLanguage(language) {
+    current = language;
+    messages = messagesFor(language);
+    chosen = true;
+}
+/** The language of the kit's texts right now. */
+export function getLanguage() {
+    return current;
+}
+/**
+ * Resolves the language from `--language`, `option` and the system's (see language.ts) and
+ * makes it the kit's, the first time or whenever an option is given; otherwise keeps the one
+ * already chosen (so a chat started without `language` follows `buildSessionOptions()`'s
+ * `config.language`). Warnings for unsupported codes wait in `takeLanguageWarnings()`, each
+ * once per process.
+ */
+export function chooseLanguage(option) {
+    if (chosen && option === undefined)
+        return current;
+    const resolved = detectLanguage(option);
+    for (const warning of resolved.warnings) {
+        if (warned.has(warning))
+            continue;
+        warned.add(warning);
+        pendingWarnings.push(warning);
+    }
+    setLanguage(resolved.language);
+    return current;
+}
+/** Warnings about unsupported language codes not shown yet (English, one line each). */
+export function takeLanguageWarnings() {
+    const taken = pendingWarnings;
+    pendingWarnings = [];
+    return taken;
+}
+/** The kit's texts in the current language. */
+export function t() {
+    return messages;
+}

package/dist/core/runs.d.ts

@@ -0,0 +1,51 @@
+import type { SessionStore, SessionStoreEntry } from "@anthropic-ai/claude-agent-sdk";
+/**
+ * One run of an agent: a folder under the agent's runs folder (`<runsDir>/<timestamp>/`)
+ * holding its session log, its transcript of tool calls and, with a run store, the SDK's
+ * own transcript of the conversation, so a person can resume it later.
+ */
+export interface RunFolder {
+    /** The run's folder. */
+    dir: string;
+    /** The SDK session kept in this folder (to resume it), or null for a new run. */
+    sessionId: string | null;
+}
+export interface RunSummary extends RunFolder {
+    sessionId: string;
+    /** When the run's conversation last changed. */
+    updatedAt: Date;
+    /** The human's last message, on one line (empty if none). */
+    lastMessage: string;
+}
+export interface ConversationMessage {
+    role: "user" | "assistant";
+    text: string;
+}
+/** A folder name for a new run, e.g. "2026-09-09T16-50-12-345Z" (sorts by date). */
+export declare function runFolderName(date?: Date): string;
+/** Creates a new, empty run folder under `runsDir`. */
+export declare function createRunFolder(runsDir: string): Promise<RunFolder>;
+/** The SDK session a run folder keeps, from its `session.json`, or null. */
+export declare function readRunSession(dir: string): Promise<string | null>;
+/**
+ * A `SessionStore` (the SDK's adapter for keeping transcripts elsewhere) that keeps one
+ * session in one run folder: `conversation.jsonl` for the main transcript,
+ * `subagents/*.jsonl` for each subagent's, and `session.json` with the session's id and
+ * which file is which subagent's. The SDK appends to it as the transcript grows and loads
+ * from it before resuming (confirmed empirically: a resumed session remembers the
+ * conversation, its subagents' transcripts included, even with the CLI's own copy deleted).
+ * The CLI still writes that copy under `~/.claude/projects/`: it can't be turned off while a
+ * store is in use.
+ *
+ * Bound to one folder, so every key it receives is taken as this run's session: one run
+ * folder is one conversation, resumed as many times as wanted (the session keeps its id).
+ */
+export declare function createRunStore(dir: string): SessionStore;
+/** A transcript entry's text when it's something the human wrote or the agent replied, or null. */
+export declare function entryText(entry: SessionStoreEntry): ConversationMessage | null;
+/** The human's messages and the agent's replies in a run's conversation, in order. */
+export declare function readConversation(dir: string): Promise<ConversationMessage[]>;
+/** The runs under `runsDir` that kept a conversation, newest first; runs without `session.json` are left out. */
+export declare function listRuns(runsDir: string): Promise<RunSummary[]>;
+/** `--continue` among the process's arguments: start by resuming the latest run. */
+export declare function continueArgument(argv: readonly string[]): boolean;

package/dist/core/runs.js

@@ -0,0 +1,194 @@
+import { appendFile, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+const CONVERSATION = "conversation.jsonl";
+const SUBAGENTS = "subagents";
+const SESSION = "session.json";
+/** A folder name for a new run, e.g. "2026-09-09T16-50-12-345Z" (sorts by date). */
+export function runFolderName(date = new Date()) {
+    return date.toISOString().replace(/[:.]/g, "-");
+}
+/** Creates a new, empty run folder under `runsDir`. */
+export async function createRunFolder(runsDir) {
+    const dir = path.join(runsDir, runFolderName());
+    await mkdir(dir, { recursive: true });
+    return { dir, sessionId: null };
+}
+async function readSessionFile(dir) {
+    try {
+        const parsed = JSON.parse(await readFile(path.join(dir, SESSION), "utf8"));
+        return typeof parsed.sessionId === "string" ? { sessionId: parsed.sessionId, subagents: parsed.subagents ?? {} } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The SDK session a run folder keeps, from its `session.json`, or null. */
+export async function readRunSession(dir) {
+    return (await readSessionFile(dir))?.sessionId ?? null;
+}
+async function readEntries(file) {
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    return raw
+        .split("\n")
+        .filter((line) => line.trim())
+        .map((line) => JSON.parse(line));
+}
+/** A readable, unused file name for a subagent's transcript, from its key (e.g. "subagents/agent-a67…"). */
+function subagentFileName(subpath, taken) {
+    const name = subpath.replace(/^subagents\//, "").replace(/[^A-Za-z0-9._-]+/g, "_") || "agent";
+    let file = `${SUBAGENTS}/${name}.jsonl`;
+    for (let n = 2; taken.includes(file); n++)
+        file = `${SUBAGENTS}/${name}-${n}.jsonl`;
+    return file;
+}
+/**
+ * A `SessionStore` (the SDK's adapter for keeping transcripts elsewhere) that keeps one
+ * session in one run folder: `conversation.jsonl` for the main transcript,
+ * `subagents/*.jsonl` for each subagent's, and `session.json` with the session's id and
+ * which file is which subagent's. The SDK appends to it as the transcript grows and loads
+ * from it before resuming (confirmed empirically: a resumed session remembers the
+ * conversation, its subagents' transcripts included, even with the CLI's own copy deleted).
+ * The CLI still writes that copy under `~/.claude/projects/`: it can't be turned off while a
+ * store is in use.
+ *
+ * Bound to one folder, so every key it receives is taken as this run's session: one run
+ * folder is one conversation, resumed as many times as wanted (the session keeps its id).
+ */
+export function createRunStore(dir) {
+    const seen = new Set();
+    let session = null;
+    // Appends are chained: the SDK may call append() again before the last one has finished,
+    // and entries must keep their order.
+    let queue = Promise.resolve();
+    async function currentSession() {
+        session ??= await readSessionFile(dir);
+        return session;
+    }
+    async function saveSession(next) {
+        session = next;
+        await mkdir(dir, { recursive: true });
+        await writeFile(path.join(dir, SESSION), `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    }
+    /** The file for a key; with `create`, registers the session (and a new subagent) in session.json. */
+    async function fileFor(key, create) {
+        const current = await currentSession();
+        if (!key.subpath) {
+            if (create && !current)
+                await saveSession({ sessionId: key.sessionId, subagents: {} });
+            return path.join(dir, CONVERSATION);
+        }
+        const known = current?.subagents[key.subpath];
+        if (known)
+            return path.join(dir, known);
+        if (!create)
+            return null;
+        const base = current ?? { sessionId: key.sessionId, subagents: {} };
+        const file = subagentFileName(key.subpath, Object.values(base.subagents));
+        await saveSession({ ...base, subagents: { ...base.subagents, [key.subpath]: file } });
+        return path.join(dir, file);
+    }
+    async function write(key, entries) {
+        // Retries and replays may send an entry again: its uuid, when it has one, says so.
+        const fresh = entries.filter((entry) => {
+            if (!entry.uuid)
+                return true;
+            const id = `${key.subpath ?? ""}:${entry.uuid}`;
+            if (seen.has(id))
+                return false;
+            seen.add(id);
+            return true;
+        });
+        if (fresh.length === 0)
+            return;
+        const file = (await fileFor(key, true));
+        await mkdir(path.dirname(file), { recursive: true });
+        await appendFile(file, fresh.map((entry) => `${JSON.stringify(entry)}\n`).join(""), "utf8");
+    }
+    return {
+        append(key, entries) {
+            queue = queue.then(() => write(key, entries));
+            return queue;
+        },
+        async load(key) {
+            const file = await fileFor(key, false);
+            const entries = file ? await readEntries(file) : null;
+            // What's already there counts as seen: resuming must not append it twice.
+            for (const entry of entries ?? [])
+                if (entry.uuid)
+                    seen.add(`${key.subpath ?? ""}:${entry.uuid}`);
+            return entries;
+        },
+        async listSubkeys() {
+            return Object.keys((await currentSession())?.subagents ?? {});
+        },
+    };
+}
+/** A transcript entry's text when it's something the human wrote or the agent replied, or null. */
+export function entryText(entry) {
+    if (entry.type !== "user" && entry.type !== "assistant")
+        return null;
+    if (entry.isMeta || entry.isSidechain)
+        return null;
+    const content = entry.message?.content;
+    let text = "";
+    if (typeof content === "string")
+        text = content;
+    else if (Array.isArray(content)) {
+        const parts = content;
+        // A user entry holding tool results isn't something the human wrote.
+        if (entry.type === "user" && parts.some((part) => part.type === "tool_result"))
+            return null;
+        text = parts
+            .filter((part) => part.type === "text")
+            .map((part) => part.text ?? "")
+            .join("");
+    }
+    // Slash commands and the CLI's own notes arrive as tagged text, not as the human's words.
+    if (!text.trim() || /^\s*<[a-z-]+>/.test(text))
+        return null;
+    return { role: entry.type, text };
+}
+/** The human's messages and the agent's replies in a run's conversation, in order. */
+export async function readConversation(dir) {
+    const entries = (await readEntries(path.join(dir, CONVERSATION))) ?? [];
+    return entries.map(entryText).filter((message) => message !== null);
+}
+/** The runs under `runsDir` that kept a conversation, newest first; runs without `session.json` are left out. */
+export async function listRuns(runsDir) {
+    let names;
+    try {
+        names = (await readdir(runsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+    const runs = [];
+    for (const name of names) {
+        const dir = path.join(runsDir, name);
+        const sessionId = await readRunSession(dir);
+        if (!sessionId)
+            continue;
+        const entries = (await readEntries(path.join(dir, CONVERSATION))) ?? [];
+        const times = entries.map((entry) => Date.parse(entry.timestamp ?? "")).filter((ms) => !Number.isNaN(ms));
+        const human = entries.map(entryText).filter((message) => message?.role === "user");
+        runs.push({
+            dir,
+            sessionId,
+            updatedAt: new Date(times.length > 0 ? Math.max(...times) : 0),
+            lastMessage: (human.at(-1)?.text ?? "").replace(/\s+/g, " ").trim(),
+        });
+    }
+    return runs.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+}
+/** `--continue` among the process's arguments: start by resuming the latest run. */
+export function continueArgument(argv) {
+    return argv.includes("--continue");
+}