@nac3/forge-cli 0.2.0-alpha.9 → 1.0.0

package/dist/chat/claude_cli.js

@@ -0,0 +1,679 @@
+/**
+ * Yujin Forge -- Claude Code CLI subprocess client.
+ *
+ * Drop-in alternative to `ClaudeClient` that routes every chat turn
+ * through the `claude -p` binary instead of the Anthropic HTTP API.
+ * Billing flows against the user's Claude Code subscription
+ * (`apiKeySource: "none"`) instead of the Console balance.
+ *
+ * Trade-offs vs ClaudeClient (the HTTP path):
+ *
+ *  * The `claude -p` subprocess owns the tool-use loop. The caller's
+ *    `tools` + `runTool` are ignored; the subprocess uses Claude
+ *    Code's native tool surface (Read, Edit, Write, Bash, Glob, Grep,
+ *    Task, plus any MCP servers configured in the user's
+ *    `~/.claude/config`). This is intentional: for build-side
+ *    workflows (the redesign/sumi-forge target), the native tools are
+ *    strictly more efficient than text-routed NAC3 invokes.
+ *
+ *  * Each `chat()` call spawns one subprocess. Latency is dominated
+ *    by the subprocess startup (~500 ms-1 s) on top of the LLM turn.
+ *    The output is parsed from the JSONL stream the binary writes to
+ *    stdout when invoked with `--output-format stream-json --verbose`.
+ *
+ *  * Token + cost accounting comes from the `result` event the binary
+ *    emits at the end of the run. Those values reflect what the user
+ *    subscription consumed; they are reported back as `tokensIn` /
+ *    `tokensOut` for parity with ClaudeClient, with the qualification
+ *    that under subscription billing the marginal $ cost is zero.
+ *
+ *  * Multi-turn conversation history is concatenated into a single
+ *    prompt the subprocess sees on stdin. The subprocess does not
+ *    receive a structured `messages[]` array; the convention is the
+ *    same role-tagged format the Anthropic SDK uses internally
+ *    (User: / Assistant:).
+ *
+ *  * No truncation detection: the subprocess does not report stop
+ *    reasons in a comparable way. The `truncation` field of the
+ *    response is left undefined.
+ *
+ * ASCII-only.
+ */
+import { spawn } from 'node:child_process';
+import { writeFileSync, mkdirSync } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { tForLang, currentLanguage } from '../i18n/index.js';
+import { mcpEnabledSync } from '../mcp/config.js';
+import { readPlanBridgesSync } from '../mcp/plan_bridges.js';
+import { ClaudeApiError } from './claude.js';
+/** PND-064 slice B -- absolute path to the compiled forge_panel MCP
+ *  server. At runtime this module is dist/chat/claude_cli.js, so the
+ *  server is dist/mcp/forge_panel_server.js. */
+function panelServerScriptPath() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    return path.join(here, '..', 'mcp', 'forge_panel_server.js');
+}
+/** PND-064 -- the MCP tool name `claude -p` must allow:
+ *  mcp__<serverName>__<toolName>. La tool es nac3_invoke (proxy del
+ *  catalogo completo de verbos yujin). */
+const PANEL_MCP_SERVER = 'forge_panel';
+const PANEL_MCP_ALLOWED_TOOL = 'mcp__forge_panel__nac3_invoke';
+/** Convert ChatMessage[] -> single prompt string for `claude -p`.
+ *  Role-tagged, oldest first. The user's final message is the active
+ *  turn the subprocess responds to. */
+function flattenMessages(messages) {
+    if (messages.length === 0)
+        return '';
+    const lines = [];
+    for (const m of messages) {
+        if (m.hidden)
+            continue;
+        const role = m.role === 'assistant' ? 'Assistant' : 'User';
+        lines.push(role + ': ' + m.content);
+    }
+    return lines.join('\n\n');
+}
+/** True when `m` is a Claude model `claude -p` accepts (full id or the
+ *  opus/sonnet/haiku aliases). Non-Claude ids (gemini, gpt, ...) must NOT
+ *  be passed to claude -p -- Plan mode always runs the Claude
+ *  subscription. */
+export function isClaudeCliModel(m) {
+    const s = String(m).trim().toLowerCase();
+    return s.startsWith('claude') || s === 'opus' || s === 'sonnet' || s === 'haiku' || s === 'default';
+}
+/** Map any resolved model id/alias to the stable CLI alias `claude -p`
+ *  accepts (opus|sonnet|haiku). A full id (claude-opus-4-8) or a
+ *  non-Claude id (gemini-*) both resolve to a sane Claude tier so the
+ *  subscription turn never 404s on an "unknown model". */
+export function toCliModelAlias(m) {
+    const s = String(m || '').trim().toLowerCase();
+    if (s.includes('opus'))
+        return 'opus';
+    if (s.includes('haiku'))
+        return 'haiku';
+    if (s.includes('sonnet'))
+        return 'sonnet';
+    /* gemini/unknown/empty -> default the subscription turn to sonnet. */
+    return 'sonnet';
+}
+export class ClaudeCliClient {
+    opts;
+    /** Cache of the generated mcp-config path (written once). */
+    mcpConfigPath = null;
+    /** Path of the temp system-prompt file (rewritten per turn). */
+    systemPromptPath = null;
+    /** Dogfood 2026-06-10 -- write the system prompt to a temp file so
+     *  it goes via --append-system-prompt-file instead of a CLI arg
+     *  (Windows ~32 KB command-line limit -> spawn ENAMETOOLONG). The
+     *  same path is reused (overwritten) each turn. */
+    writeSystemPromptFile(content) {
+        const dir = path.join(os.tmpdir(), 'yujin-forge');
+        try {
+            mkdirSync(dir, { recursive: true });
+        }
+        catch { /* exists */ }
+        if (!this.systemPromptPath) {
+            this.systemPromptPath = path.join(dir, 'sysprompt-' + process.pid + '.txt');
+        }
+        writeFileSync(this.systemPromptPath, content, 'utf-8');
+        return this.systemPromptPath;
+    }
+    constructor(opts = {}) {
+        this.opts = {
+            binary: opts.binary ?? 'claude',
+            permissionMode: opts.permissionMode ?? 'bypassPermissions',
+            timeoutMs: opts.timeoutMs ?? 30 * 60 * 1000,
+            addDirs: opts.addDirs ?? [],
+            allowedTools: opts.allowedTools ?? [],
+            spawnImpl: opts.spawnImpl ?? ((cmd, args, o) => spawn(cmd, args, o)),
+            ...(opts.model ? { model: opts.model } : {}),
+            ...(opts.panelBridge ? { panelBridge: opts.panelBridge } : {}),
+        };
+    }
+    /** PND-064 slice B -- write (once) the mcp-config that points
+     *  `claude -p` at the forge_panel MCP server, with the port +
+     *  token in the server's env block so it can POST back to us.
+     *  Returns null when no panel bridge is configured. */
+    ensureMcpConfig() {
+        if (!this.opts.panelBridge)
+            return null;
+        if (this.mcpConfigPath)
+            return this.mcpConfigPath;
+        const dir = path.join(os.tmpdir(), 'yujin-forge');
+        try {
+            mkdirSync(dir, { recursive: true });
+        }
+        catch { /* exists */ }
+        const cfgPath = path.join(dir, 'panel-mcp-' + process.pid + '.json');
+        const mcpServers = {
+            [PANEL_MCP_SERVER]: {
+                command: process.execPath, /* node */
+                args: [panelServerScriptPath()],
+                env: {
+                    FORGE_PANEL_PORT: String(this.opts.panelBridge.port),
+                    FORGE_PANEL_TOKEN: this.opts.panelBridge.token,
+                },
+            },
+        };
+        /* PND-029 (Plan-mode MCP) -- when the MCP feature flag is ON, merge
+         * the user's configured EXTERNAL MCP servers into the same config.
+         * claude -p spawns + discovers them natively; no Forge runtime
+         * needed in Plan. The panel bridge always wins its own name. */
+        try {
+            if (mcpEnabledSync()) {
+                const external = readPlanBridgesSync();
+                for (const [name, def] of Object.entries(external)) {
+                    if (name === PANEL_MCP_SERVER)
+                        continue;
+                    mcpServers[name] = def;
+                }
+            }
+        }
+        catch { /* bridges are best-effort; never break a chat turn */ }
+        writeFileSync(cfgPath, JSON.stringify({ mcpServers }), 'utf-8');
+        this.mcpConfigPath = cfgPath;
+        return cfgPath;
+    }
+    /** Convenience for callers (and tests) that want to know what
+     *  binary + flags will run before spawning. */
+    buildArgs(req) {
+        const args = ['-p', '--output-format', 'stream-json', '--verbose'];
+        if (this.opts.permissionMode === 'bypassPermissions') {
+            args.push('--dangerously-skip-permissions');
+        }
+        /* Plan mode ALWAYS runs `claude -p` (the Claude subscription), so the
+         * model passed must be a Claude model. The eco/frontier config can
+         * resolve to a non-Claude id (e.g. gemini for the eco tier, or a
+         * retired claude-opus-4-7) -- passing that to `claude -p` yields a
+         * 404 / "unknown model". So we only pass --model when it is a Claude
+         * model; otherwise we omit it and let `claude -p` use the
+         * subscription's current default. */
+        /* Pablo 2026-06-15 -- a FULL id like 'claude-opus-4-8' makes the
+         * subscription `claude -p` 404 ("unknown model"); the CLI reliably
+         * accepts only the stable ALIASES opus/sonnet/haiku. Map the
+         * resolved model (full id or alias) to its CLI alias and pass that.
+         * Non-Claude ids (gemini for eco) map to a sensible Claude tier so
+         * the subscription turn still runs. */
+        const candidateModel = this.opts.model ?? req.model;
+        args.push('--model', toCliModelAlias(candidateModel));
+        /* alpha.59z.163 PND-027 -- the HTTP path splits system into
+         *  cached prefix + uncached dynamic suffix for Anthropic's prompt
+         *  cache. `claude -p --append-system-prompt` takes a single
+         *  string, so we concatenate here. The subscription path does
+         *  not bill against the cache anyway, so the optimisation is
+         *  HTTP-path-only. */
+        const systemFull = (req.system ?? '')
+            + (req.systemDynamic ? '\n' + req.systemDynamic : '');
+        if (systemFull.trim().length > 0) {
+            /* Dogfood 2026-06-10 -- el system prompt (manifest + doctrinas
+             * + secciones de modo) supera el limite de ~32 KB de la linea
+             * de comando en Windows si va como argumento -> spawn
+             * ENAMETOOLONG. Lo escribimos a un archivo temporal y usamos
+             * --append-system-prompt-file, que no tiene ese limite. */
+            const promptPath = this.writeSystemPromptFile(systemFull);
+            args.push('--append-system-prompt-file', promptPath);
+        }
+        /* PND-064 slice B -- wire the panel MCP bridge so the subprocess
+         * can create pizarron tabs. The mcp-config carries the port +
+         * token in the server env block. */
+        const mcpConfig = this.ensureMcpConfig();
+        const allowed = [...this.opts.allowedTools];
+        if (mcpConfig) {
+            args.push('--mcp-config', mcpConfig);
+            if (!allowed.includes(PANEL_MCP_ALLOWED_TOOL))
+                allowed.push(PANEL_MCP_ALLOWED_TOOL);
+        }
+        if (allowed.length > 0) {
+            args.push('--allowed-tools', allowed.join(' '));
+        }
+        for (const dir of this.opts.addDirs) {
+            args.push('--add-dir', dir);
+        }
+        return args;
+    }
+    async chat(req) {
+        const prompt = flattenMessages(req.messages);
+        const args = this.buildArgs(req);
+        /* Spawn the subprocess and feed the USER prompt on stdin so we
+         * are not bounded by the command-line length limit. The SYSTEM
+         * prompt goes via --append-system-prompt-file (see buildArgs)
+         * for the same reason. */
+        /* Dogfood 2026-06-10 -- el contrato de Plan mode es facturar
+         * contra la SUSCRIPCION. Si el entorno tiene ANTHROPIC_API_KEY
+         * (comun: el usuario la usa para BYOK/Console en otros lados),
+         * `claude -p` la hereda y factura Console sin querer (Pablo vio
+         * el warning repetido). La limpiamos del env del subproceso
+         * para honrar la eleccion de Plan; quien quiera Console usa el
+         * toggle de Ajustes > Brain (PND-069). */
+        const childEnv = { ...process.env };
+        delete childEnv['ANTHROPIC_API_KEY'];
+        delete childEnv['ANTHROPIC_AUTH_TOKEN'];
+        return await new Promise((resolve, reject) => {
+            const child = this.opts.spawnImpl(this.opts.binary, args, {
+                stdio: ['pipe', 'pipe', 'pipe'],
+                windowsHide: true,
+                env: childEnv,
+                /* Run in the ACTIVE project so `claude -p` operates there, not in
+                 * the launch cwd. Follows a hot project switch. (Pablo 2026-06-15)
+                 * Without this the subprocess always ran in C:\yujin-forge while
+                 * the panel injected a different project -> "two contexts". */
+                ...(req.cwd ? { cwd: req.cwd } : {}),
+            });
+            const events = [];
+            let stdoutBuf = '';
+            let stderrBuf = '';
+            const finalize = (err) => {
+                clearTimeout(timer);
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                /* Walk the events tail-first: the `result` event is the final
+                 * authoritative summary. */
+                let resultEvent;
+                const assistantTexts = [];
+                let model = this.opts.model ?? req.model ?? 'claude-code-cli';
+                let apiKeySource = '';
+                for (const ev of events) {
+                    if (ev.type === 'result' && resultEvent === undefined) {
+                        resultEvent = ev;
+                    }
+                    else if (ev.type === 'assistant') {
+                        const msg = ev.message;
+                        const blocks = msg?.content ?? [];
+                        for (const b of blocks) {
+                            if (b.type === 'text' && typeof b.text === 'string') {
+                                assistantTexts.push(b.text);
+                            }
+                        }
+                        if (msg?.model)
+                            model = msg.model;
+                    }
+                    else if (ev.type === 'system') {
+                        const sys = ev;
+                        if (sys.subtype === 'init' && sys.apiKeySource) {
+                            apiKeySource = sys.apiKeySource;
+                        }
+                        if (sys.subtype === 'init' && sys.model)
+                            model = sys.model;
+                    }
+                }
+                if (!resultEvent) {
+                    reject(new ClaudeApiError('claude -p produced no result event', 500));
+                    return;
+                }
+                if (resultEvent.is_error || resultEvent.subtype !== 'success') {
+                    reject(new ClaudeApiError('claude -p reported error: ' + (resultEvent.api_error_status ?? resultEvent.subtype), 502));
+                    return;
+                }
+                const text = resultEvent.result ?? assistantTexts.join('');
+                const u = resultEvent.usage ?? {};
+                const tokensIn = (u.input_tokens ?? 0)
+                    + (u.cache_creation_input_tokens ?? 0)
+                    + (u.cache_read_input_tokens ?? 0);
+                const tokensOut = u.output_tokens ?? 0;
+                /* PND-055 (CR-D11) -- apiKeySource senala contra que se
+                 * facturo: "none" = suscripcion (lo esperado en modo CLI);
+                 * cualquier otra cosa ("api_key", "bedrock", ...) = el
+                 * entorno del usuario forzo otra auth y el turno se cobro
+                 * contra Console (dinero real). Lo surfaceamos en el reply
+                 * para que el server avise, y dejamos un warn server-side. */
+                const billedToConsole = apiKeySource !== '' && apiKeySource !== 'none';
+                if (billedToConsole) {
+                    try {
+                        console.error('[claude-cli] WARNING: el turno se facturo contra Console (apiKeySource="'
+                            + apiKeySource + '"), no contra tu suscripcion Claude. '
+                            + 'Quita ANTHROPIC_API_KEY del entorno para usar el plan.');
+                    }
+                    catch { /* ignore */ }
+                }
+                resolve({
+                    text,
+                    tokensIn,
+                    tokensOut,
+                    model,
+                    toolRounds: [],
+                    billedToConsole,
+                });
+            };
+            const timer = setTimeout(() => {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch { /* ignore */ }
+                finalize(new ClaudeApiError('claude -p timed out after ' + this.opts.timeoutMs + 'ms', 504));
+            }, this.opts.timeoutMs);
+            /* Interrupt (panel "Detener" / relay control): kill the subprocess
+             * gracefully (SIGTERM, SIGKILL fallback) and resolve with a
+             * controlled-fall result. Resolving twice is a no-op, so a late
+             * child-close that also finalizes is harmless. */
+            if (req.signal) {
+                const onAbort = () => {
+                    clearTimeout(timer);
+                    try {
+                        child.kill('SIGTERM');
+                    }
+                    catch { /* ignore */ }
+                    const k = setTimeout(() => { try {
+                        child.kill('SIGKILL');
+                    }
+                    catch { /* ignore */ } }, 2000);
+                    if (typeof k.unref === 'function')
+                        k.unref();
+                    resolve({
+                        text: '[Turno interrumpido por el usuario. Lo que se alcanzo a hacer quedo aplicado.]',
+                        tokensIn: 0, tokensOut: 0,
+                        model: this.opts.model ?? req.model ?? 'claude-code-cli',
+                        toolRounds: [], interrupted: true,
+                    });
+                };
+                if (req.signal.aborted)
+                    onAbort();
+                else
+                    req.signal.addEventListener('abort', onAbort, { once: true });
+            }
+            const onStream = req.onStreamEvent;
+            /* round counter matches the HTTP path's tool_round_start /
+             * _done semantics: one round per tool_use the model invoked,
+             * incremented in order of arrival. */
+            let roundCounter = 0;
+            const pendingRounds = new Map();
+            const emitToolEvents = (ev) => {
+                if (!onStream)
+                    return;
+                if (ev.type === 'assistant') {
+                    const blocks = ev.message?.content ?? [];
+                    for (const b of blocks) {
+                        if (b.type === 'tool_use' && typeof b.id === 'string') {
+                            roundCounter += 1;
+                            const verb = typeof b.name === 'string' ? b.name : 'tool';
+                            const verbHint = verb.startsWith('mcp__')
+                                ? verb.replace(/^mcp__/, 'mcp/').replace(/__/, '.')
+                                : verb;
+                            /* Granularidad (dogfood 2026-06-10) -- resumen humano
+                             * de QUE esta haciendo claude a partir del input del
+                             * tool_use, para mostrarlo en vivo mientras codea. */
+                            const toolInput = b.input;
+                            const summary = summarizeToolUse(verb, toolInput);
+                            /* Detalle estructurado para el modo "codewrapper"
+                             * (transparencia: el archivo, el diff, el comando). */
+                            const detail = extractToolDetail(verb, toolInput);
+                            pendingRounds.set(b.id, { round: roundCounter, verb, t0: Date.now() });
+                            try {
+                                onStream('tool_round_start', {
+                                    round: roundCounter, verb_id: verb, verb_hint: verbHint, summary, detail,
+                                });
+                            }
+                            catch { /* never let a panel hiccup break the loop */ }
+                        }
+                    }
+                }
+                else if (ev.type === 'user') {
+                    const blocks = ev.message?.content ?? [];
+                    for (const b of blocks) {
+                        if (b.type === 'tool_result' && typeof b.tool_use_id === 'string') {
+                            const pr = pendingRounds.get(b.tool_use_id);
+                            if (pr) {
+                                pendingRounds.delete(b.tool_use_id);
+                                try {
+                                    onStream('tool_round_done', {
+                                        round: pr.round, verb_id: pr.verb,
+                                        is_error: b.is_error === true,
+                                        duration_ms: Date.now() - pr.t0,
+                                    });
+                                }
+                                catch { /* swallow */ }
+                            }
+                        }
+                    }
+                }
+            };
+            /* spawnImpl returns the generic ChildProcess shape with
+             * nullable stdio. We requested stdio:'pipe', so the streams
+             * are non-null by contract; assert and narrow once. */
+            const stdout = child.stdout;
+            const stderr = child.stderr;
+            const stdin = child.stdin;
+            stdout.setEncoding('utf-8');
+            stdout.on('data', (chunk) => {
+                stdoutBuf += chunk;
+                let idx;
+                while ((idx = stdoutBuf.indexOf('\n')) >= 0) {
+                    const line = stdoutBuf.slice(0, idx).trim();
+                    stdoutBuf = stdoutBuf.slice(idx + 1);
+                    if (line.length === 0)
+                        continue;
+                    try {
+                        const ev = JSON.parse(line);
+                        events.push(ev);
+                        emitToolEvents(ev);
+                    }
+                    catch {
+                        /* Non-JSON line -- ignore. The subprocess sometimes
+                         * writes occasional progress lines that are not part of
+                         * the JSONL stream. */
+                    }
+                }
+            });
+            stderr.setEncoding('utf-8');
+            stderr.on('data', (chunk) => {
+                stderrBuf += chunk;
+            });
+            child.on('error', (err) => {
+                finalize(new ClaudeApiError('claude -p spawn failed: ' + err.message + (stderrBuf ? ' (stderr: ' + stderrBuf.slice(0, 500) + ')' : ''), 500));
+            });
+            child.on('close', (code) => {
+                if (code !== 0 && events.length === 0) {
+                    finalize(new ClaudeApiError('claude -p exited ' + code + ' with no output' + (stderrBuf ? ' (stderr: ' + stderrBuf.slice(0, 500) + ')' : ''), 500));
+                    return;
+                }
+                finalize(null);
+            });
+            try {
+                stdin.write(prompt);
+                stdin.end();
+            }
+            catch (err) {
+                finalize(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+    }
+}
+/** Granularidad de actividad (dogfood 2026-06-10) -- traduce un
+ *  tool_use del subproceso claude -p a una linea humana de "que
+ *  esta haciendo ahora", para el feed en vivo del pizarron. Best
+ *  effort: si no reconoce la herramienta, cae al nombre. */
+/** Human one-liner for a tool_use, shown live in the Coding canvas.
+ *  i18n: the EXPERIENCE phrases ("Reading X", "Running: cmd") follow
+ *  the app language (PND -- Pablo); the PROTOCOL identifiers (NAC3
+ *  verb ids, mcp server.tool) stay neutral ("traduci la experiencia,
+ *  no el protocolo"). lang defaults to the current app language. */
+export function summarizeToolUse(name, input, lang) {
+    const inp = (input && typeof input === 'object') ? input : {};
+    const s = (v) => (typeof v === 'string' ? v : '');
+    const base = (p) => p.replace(/\\/g, '/').split('/').filter(Boolean).pop() || p;
+    const L = (lang ?? currentLanguage());
+    const T = (key, x) => tForLang(L, 'coding.' + key, x ? { x } : undefined);
+    /* Herramientas nativas de Claude Code. */
+    switch (name) {
+        case 'Read': return inp.file_path ? T('read', base(s(inp.file_path))) : T('read_bare');
+        case 'Edit':
+        case 'MultiEdit': return inp.file_path ? T('edit', base(s(inp.file_path))) : T('edit_bare');
+        case 'Write': return inp.file_path ? T('write', base(s(inp.file_path))) : T('write_bare');
+        case 'NotebookEdit': return inp.notebook_path ? T('edit', base(s(inp.notebook_path))) : T('notebook_bare');
+        case 'Bash': return inp.command ? T('bash', s(inp.command).slice(0, 80)) : T('bash_bare');
+        case 'Grep': return inp.pattern ? T('grep', s(inp.pattern).slice(0, 40)) : T('grep_bare');
+        case 'Glob': return inp.pattern ? T('glob', s(inp.pattern)) : T('glob_bare');
+        case 'WebFetch': return inp.url ? T('read', s(inp.url).slice(0, 60)) : T('web_bare');
+        case 'WebSearch': return inp.query ? T('websearch', s(inp.query).slice(0, 50)) : T('websearch_bare');
+        case 'Task': return inp.description ? T('task', s(inp.description).slice(0, 50)) : T('task_bare');
+        case 'TodoWrite': return T('todo');
+        default: break;
+    }
+    /* Proxy NAC3 del pizarron: el verb real va en el input (PROTOCOLO,
+     * neutral). */
+    if (name.includes('nac3_invoke') || name.endsWith('__nac3_invoke')) {
+        const verb = s(inp.verb_id) || s(inp.verb);
+        if (verb)
+            return 'NAC3: ' + verb;
+        return T('verb_bare');
+    }
+    /* Otros MCP: mcp__server__tool -> server.tool (PROTOCOLO, neutral) */
+    if (name.startsWith('mcp__')) {
+        return name.replace(/^mcp__/, '').replace(/__/g, '.');
+    }
+    return name;
+}
+const DETAIL_CAP = 1200;
+function capStr(v, n = DETAIL_CAP) {
+    const s = typeof v === 'string' ? v : '';
+    return s.length > n ? s.slice(0, n) + '\n...[+' + (s.length - n) + ' chars]' : s;
+}
+function baseName(p) {
+    return p.replace(/\\/g, '/').split('/').filter(Boolean).pop() || p;
+}
+export function extractToolDetail(name, input) {
+    const inp = (input && typeof input === 'object') ? input : {};
+    const sp = (v) => (typeof v === 'string' ? v : '');
+    switch (name) {
+        case 'Read':
+            return { kind: 'read', path: sp(inp.file_path) || null, target: inp.file_path ? baseName(sp(inp.file_path)) : 'archivo', diff: null, body: null };
+        case 'Edit':
+            return { kind: 'edit', path: sp(inp.file_path) || null, target: inp.file_path ? baseName(sp(inp.file_path)) : 'archivo', diff: { old: capStr(inp.old_string), new: capStr(inp.new_string) }, body: null };
+        case 'MultiEdit': {
+            const edits = Array.isArray(inp.edits) ? inp.edits : [];
+            const old = edits.map((e) => sp(e.old_string)).join('\n---\n');
+            const neu = edits.map((e) => sp(e.new_string)).join('\n---\n');
+            return { kind: 'edit', path: sp(inp.file_path) || null, target: (inp.file_path ? baseName(sp(inp.file_path)) : 'archivo') + ' (' + edits.length + ')', diff: { old: capStr(old), new: capStr(neu) }, body: null };
+        }
+        case 'Write':
+            return { kind: 'write', path: sp(inp.file_path) || null, target: inp.file_path ? baseName(sp(inp.file_path)) : 'archivo', diff: null, body: capStr(inp.content) };
+        case 'NotebookEdit':
+            return { kind: 'edit', path: sp(inp.notebook_path) || null, target: inp.notebook_path ? baseName(sp(inp.notebook_path)) : 'notebook', diff: { old: '', new: capStr(inp.new_source) }, body: null };
+        case 'Bash':
+            return { kind: 'bash', path: null, target: capStr(inp.command, 80).split('\n')[0], diff: null, body: capStr(inp.command) };
+        case 'Grep':
+            return { kind: 'search', path: sp(inp.path) || null, target: sp(inp.pattern), diff: null, body: null };
+        case 'Glob':
+            return { kind: 'search', path: null, target: sp(inp.pattern), diff: null, body: null };
+        case 'WebFetch':
+            return { kind: 'read', path: null, target: capStr(inp.url, 80), diff: null, body: null };
+        case 'WebSearch':
+            return { kind: 'search', path: null, target: capStr(inp.query, 80), diff: null, body: null };
+        case 'Task':
+            return { kind: 'task', path: null, target: capStr(inp.description, 80), diff: null, body: capStr(inp.prompt, 400) };
+        case 'TodoWrite':
+            return { kind: 'todo', path: null, target: 'todos', diff: null, body: capStr(JSON.stringify(inp.todos ?? []), 800) };
+        default: break;
+    }
+    if (name.includes('nac3_invoke')) {
+        return { kind: 'verb', path: null, target: sp(inp.verb_id) || sp(inp.verb) || 'yujin', diff: null, body: capStr(JSON.stringify(inp), 400) };
+    }
+    return { kind: 'other', path: null, target: name.replace(/^mcp__/, '').replace(/__/g, '.'), diff: null, body: null };
+}
+/** Console / managed / other-brain path: the server runs NAC3 verbs
+ *  (yujin.*) instead of Claude's native tools, so the codewrapper
+ *  detail comes from a parallel adapter that maps verbs -> the same
+ *  ToolDetail shape. write-project-file carries full content (no
+ *  old/new), so it surfaces as a body, not a diff. */
+export function extractVerbDetail(verbId, input) {
+    const inp = (input && typeof input === 'object') ? input : {};
+    const sp = (v) => (typeof v === 'string' ? v : '');
+    const v = verbId || '';
+    if (v === 'yujin.shell.exec') {
+        return { kind: 'bash', path: null, target: capStr(inp.command, 80).split('\n')[0], diff: null, body: capStr(inp.command) };
+    }
+    if (v.includes('write-project-file') || v === 'yujin.fs.write') {
+        return { kind: 'write', path: sp(inp.path) || null, target: inp.path ? baseName(sp(inp.path)) : 'archivo', diff: null, body: capStr(inp.content) };
+    }
+    if (v.startsWith('yujin.fs.read') || v.startsWith('yujin.reader.') || v === 'yujin.pizarron.open-file') {
+        return { kind: 'read', path: sp(inp.path) || null, target: inp.path ? baseName(sp(inp.path)) : v.replace('yujin.', ''), diff: null, body: null };
+    }
+    if (v.includes('grep') || v.includes('search') || v.includes('glob')) {
+        return { kind: 'search', path: null, target: sp(inp.pattern) || sp(inp.query) || v, diff: null, body: null };
+    }
+    if (v.startsWith('yujin.pizarron.')) {
+        return { kind: 'other', path: null, target: v.replace('yujin.pizarron.', 'pizarron/'), diff: null, body: null };
+    }
+    if (v.startsWith('yujin.git.')) {
+        return { kind: 'other', path: null, target: v.replace('yujin.', ''), diff: null, body: null };
+    }
+    return { kind: 'verb', path: null, target: v, diff: null, body: capStr(JSON.stringify(inp), 300) };
+}
+/** Probe `claude -p` once with a trivial prompt. Useful as a
+ *  pre-flight before launching a long-running orchestration: a fresh
+ *  failure here (binary missing, not logged in, rate limit window
+ *  exhausted) is much cheaper to detect than to discover mid-sprint.
+ *
+ *  Returns the rate-limit info from the system init event so the
+ *  caller can decide whether the 5-hour window has room for the
+ *  upcoming workload. */
+export async function probeClaudeCli(opts = {}) {
+    return await new Promise((resolve) => {
+        const args = ['-p', '--output-format', 'stream-json', '--verbose', 'ok?'];
+        const child = spawn(opts.binary ?? 'claude', args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        let buf = '';
+        const out = {};
+        const timer = setTimeout(() => {
+            try {
+                child.kill('SIGKILL');
+            }
+            catch { /* ignore */ }
+            resolve({ ok: false, error: 'probe timed out after 60s' });
+        }, 60_000);
+        child.stdout.setEncoding('utf-8');
+        child.stdout.on('data', (chunk) => {
+            buf += chunk;
+            let idx;
+            while ((idx = buf.indexOf('\n')) >= 0) {
+                const line = buf.slice(0, idx).trim();
+                buf = buf.slice(idx + 1);
+                if (!line)
+                    continue;
+                try {
+                    const ev = JSON.parse(line);
+                    if (ev.type === 'system' && ev.subtype === 'init') {
+                        if (ev.apiKeySource)
+                            out.apiKeySource = ev.apiKeySource;
+                        if (ev.model)
+                            out.model = ev.model;
+                    }
+                    else if (ev.type === 'rate_limit_event' && ev.rate_limit_info) {
+                        if (ev.rate_limit_info.status)
+                            out.rateLimitStatus = ev.rate_limit_info.status;
+                        if (ev.rate_limit_info.resetsAt)
+                            out.resetsAt = ev.rate_limit_info.resetsAt;
+                    }
+                }
+                catch { /* ignore */ }
+            }
+        });
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            resolve({ ok: false, error: 'spawn failed: ' + err.message });
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            const result = {
+                ok: code === 0,
+            };
+            if (out.apiKeySource)
+                result.apiKeySource = out.apiKeySource;
+            if (out.model)
+                result.model = out.model;
+            if (out.rateLimitStatus)
+                result.rateLimitStatus = out.rateLimitStatus;
+            if (out.resetsAt)
+                result.resetsAt = out.resetsAt;
+            if (code !== 0)
+                result.error = 'exit ' + code;
+            resolve(result);
+        });
+    });
+}
+//# sourceMappingURL=claude_cli.js.map