@namzu/cli 0.0.2 → 0.1.0

package/dist/tui/App.js

@@ -0,0 +1,742 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text, useApp, useInput } from 'ink';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { writePreferences, } from '../integrations/providers/index.js';
+import { isTrusted, trustDir } from '../integrations/trust/store.js';
+import { appendMemory, composeMemoryPrompt, readMemory } from '../memory/store.js';
+import { composeSkillsPrompt, discoverSkills, loadSkillBody } from '../skills/store.js';
+import { deregisterPeer, drainInbox, heartbeatPeer, listPeers, registerPeer, sendPeerMessage, } from '../integrations/clawtool/peers.js';
+import { checkUpdates } from '../integrations/updates.js';
+import { LiveActivity, formatElapsed } from './LiveActivity.js';
+import { expandFileMentions } from './mentions.js';
+import { Composer } from './Composer.js';
+import { TrustPrompt } from './TrustPrompt.js';
+import { NAMZU_MARK, NAMZU_MARK_COLOR, NAMZU_WORDMARK, NAMZU_WORDMARK_GRADIENT, NAMZU_WORDMARK_MIN_WIDTH, } from './logo.js';
+import { PermissionOverlay } from './PermissionOverlay.js';
+import { Picker } from './Picker.js';
+import { StatusBar } from './StatusBar.js';
+import { Transcript } from './Transcript.js';
+import { createAssistantMessage, createUserMessage } from '@namzu/sdk';
+import { appendMessages, listRecent, loadConversation, openSessions, startConversation, } from '../integrations/sessions/store.js';
+import { createAgentSession, probeAgentSession, } from './agent.js';
+import { ResumePicker } from './ResumePicker.js';
+import { runSlash } from './slashCommands.js';
+import { theme } from './theme.js';
+export function App({ ctx }) {
+    const { exit } = useApp();
+    const [messages, setMessages] = useState([]);
+    const [history, setHistory] = useState([]);
+    const [state, setState] = useState('idle');
+    const [phase, setPhase] = useState('probing');
+    const [session, setSession] = useState(null);
+    const [detected, setDetected] = useState([]);
+    const [currentProvider, setCurrentProvider] = useState(null);
+    const [permission, setPermission] = useState(null);
+    const [activeSkills, setActiveSkills] = useState([]);
+    const [usage, setUsage] = useState(null);
+    // Tools currently executing — rendered live (spinner + elapsed) below the
+    // transcript, then committed as static lines on completion.
+    const [activeTools, setActiveTools] = useState([]);
+    const [expanded, setExpanded] = useState(false);
+    // Bumped to reset the <Static> transcript log (on /clear and /resume).
+    const [resetKey, setResetKey] = useState(0);
+    // Messages typed while a turn is running — auto-sent when it settles.
+    const [queued, setQueued] = useState([]);
+    const [resumeList, setResumeList] = useState([]);
+    const [selectedResume, setSelectedResume] = useState(0);
+    const exitArmedRef = useRef(false);
+    const abortRef = useRef(null);
+    // Source of truth for in-flight tools (the event loop runs across renders, so
+    // a ref avoids stale state); `activeTools` mirrors it for rendering.
+    const activeToolsRef = useRef([]);
+    const clearActiveTools = useCallback(() => {
+        activeToolsRef.current = [];
+        setActiveTools([]);
+    }, []);
+    const permissionResolveRef = useRef(null);
+    // SDK-backed conversation persistence (DiskSessionStore). `scopeRef` carries
+    // the active session id used by query() — mutated in place on /resume so new
+    // turns attribute to the resumed conversation.
+    const sessionsRef = useRef(null);
+    const scopeRef = useRef(null);
+    const idRef = useRef(0);
+    // This session's clawtool BIAM peer id (null when no clawtool daemon).
+    // Registering as a peer lets other terminals/agents see + message us.
+    const peerIdRef = useRef(null);
+    // Mirror of `state` for callbacks/pollers that need the current value
+    // without re-subscribing (the inbox poller decides whether namzu is free).
+    const stateRef = useRef(state);
+    const nextId = useCallback(() => {
+        idRef.current += 1;
+        return `m${idRef.current}`;
+    }, []);
+    // Reset the transcript view: clear the terminal + remount <Static> so its
+    // already-printed lines don't linger above fresh content (/clear, /resume).
+    const resetTranscript = useCallback(() => {
+        if (process.stdout.isTTY)
+            process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
+        setResetKey((k) => k + 1);
+    }, []);
+    const pushMessage = useCallback((role, content, pending = false, glyph, detail, glyphColor, meta) => {
+        const id = nextId();
+        setMessages((prev) => [
+            ...prev,
+            { id, role, content, pending, glyph, detail, glyphColor, meta },
+        ]);
+        return id;
+    }, [nextId]);
+    const appendToMessage = useCallback((id, delta) => {
+        setMessages((prev) => prev.map((m) => (m.id === id ? { ...m, content: m.content + delta } : m)));
+    }, []);
+    const finalizeMessage = useCallback((id, finalContent) => {
+        setMessages((prev) => prev.map((m) => m.id === id ? { ...m, content: finalContent ?? m.content, pending: false } : m));
+    }, []);
+    // Open the SDK session store + start a fresh conversation once. Best-effort:
+    // on failure persistence is simply unavailable and the chat still works.
+    const ensureSessions = useCallback(async () => {
+        if (scopeRef.current)
+            return scopeRef.current;
+        try {
+            const sessions = await openSessions(ctx.cwd);
+            const sessionId = await startConversation(sessions);
+            sessionsRef.current = sessions;
+            scopeRef.current = {
+                sessionId,
+                threadId: sessions.threadId,
+                projectId: sessions.projectId,
+                tenantId: sessions.tenantId,
+            };
+            return scopeRef.current;
+        }
+        catch {
+            return undefined;
+        }
+    }, [ctx.cwd]);
+    const hydrateSession = useCallback(async (prefs, detectedNow) => {
+        const scope = await ensureSessions();
+        const s = await createAgentSession(prefs, detectedNow, scope);
+        setSession(s);
+        setCurrentProvider(prefs.provider);
+        if (s.hasProvider) {
+            setPhase('ready');
+            pushMessage('system', `Connected to ${s.providerSummary}${s.modelSummary ? ` · ${s.modelSummary}` : ''} · ${s.toolNames.length} tools${s.deferredToolCount > 0 ? ` (+${s.deferredToolCount} on demand)` : ''}`);
+        }
+        else {
+            setPhase('unhealthy');
+            if (s.errorHint)
+                pushMessage('system', s.errorHint);
+        }
+    }, [pushMessage]);
+    const runProbe = useCallback(async () => {
+        try {
+            const probe = await probeAgentSession();
+            setDetected(probe.detected);
+            if (probe.needsRepickReason) {
+                pushMessage('system', probe.needsRepickReason);
+                setPhase('picker');
+                return;
+            }
+            if (probe.preferences) {
+                await hydrateSession(probe.preferences, probe.detected);
+                return;
+            }
+            setPhase('picker');
+        }
+        catch (err) {
+            setPhase('unhealthy');
+            pushMessage('system', `Failed to probe agents: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }, [hydrateSession, pushMessage]);
+    // Trust gate runs first: don't touch the folder until the user trusts it.
+    useEffect(() => {
+        if (isTrusted(ctx.cwd)) {
+            void runProbe();
+        }
+        else {
+            setPhase('trust');
+        }
+    }, [ctx.cwd, runProbe]);
+    const acceptTrust = useCallback(() => {
+        try {
+            trustDir(ctx.cwd);
+        }
+        catch {
+            // Non-fatal: proceed for this session even if persisting failed.
+        }
+        setPhase('probing');
+        void runProbe();
+    }, [ctx.cwd, runProbe]);
+    const slashCtx = {
+        availableTools: session?.toolNames ?? [],
+        providerSummary: session?.providerSummary ?? null,
+        modelSummary: session?.modelSummary ?? null,
+    };
+    // `/resume`: open the picker with this folder's recent conversations.
+    const doResume = useCallback(async () => {
+        const sessions = sessionsRef.current ?? (await ensureSessions(), sessionsRef.current);
+        if (!sessions) {
+            pushMessage('system', 'Conversation history is unavailable in this folder.');
+            return;
+        }
+        try {
+            const recent = await listRecent(sessions);
+            // Don't offer the active (empty/just-started) conversation.
+            const others = recent.filter((c) => c.id !== scopeRef.current?.sessionId);
+            if (others.length === 0) {
+                pushMessage('system', 'No past conversations to resume in this folder yet.');
+                return;
+            }
+            setResumeList(others);
+            setSelectedResume(0);
+            setPhase('resume');
+        }
+        catch (err) {
+            pushMessage('system', `Could not list conversations: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }, [ensureSessions, pushMessage]);
+    // `/agents`: list every agent peer clawtool knows about — across terminals
+    // and (via clawtool's mDNS) the LAN. clawtool's BIAM registry is the single
+    // source of truth; namzu just renders it.
+    const doListAgents = useCallback(async () => {
+        const peers = await listPeers();
+        if (peers.length === 0) {
+            pushMessage('system', 'No agent peers found. Is clawtool running? Other namzu / claude / codex / gemini windows register here automatically.');
+            return;
+        }
+        const lines = peers.map((p) => {
+            const mine = p.peer_id === peerIdRef.current ? ' (this one)' : '';
+            const where = p.path ? ` · ${p.path}` : '';
+            return `● ${p.display_name} [${p.backend}]${where}${mine}`;
+        });
+        pushMessage('system', `agent peers (${peers.length}):\n${lines.join('\n')}`);
+    }, [pushMessage]);
+    // Load the chosen conversation into the transcript and continue in it.
+    const resumeConversation = useCallback(async (conv) => {
+        const sessions = sessionsRef.current;
+        const scope = scopeRef.current;
+        setPhase('ready');
+        if (!sessions || !scope)
+            return;
+        try {
+            const msgs = await loadConversation(sessions, conv.id);
+            const restored = msgs
+                .filter((m) => m.role === 'user' || m.role === 'assistant')
+                .map((m) => ({
+                id: nextId(),
+                role: m.role,
+                content: typeof m.content === 'string' ? m.content : '',
+            }));
+            resetTranscript();
+            setMessages(restored);
+            scope.sessionId = conv.id; // new turns now attribute to the resumed session
+            pushMessage('system', `Resumed: ${conv.title}`);
+        }
+        catch (err) {
+            pushMessage('system', `Could not resume: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }, [nextId, pushMessage]);
+    // Resolve a pending permission prompt with the user's decision and tear
+    // down the overlay. No-op if nothing is pending.
+    const resolvePermission = useCallback((decision) => {
+        const resolve = permissionResolveRef.current;
+        permissionResolveRef.current = null;
+        setPermission(null);
+        if (resolve)
+            resolve(decision);
+    }, []);
+    // Bridge passed into session.send(): the agent calls this before a
+    // non-read-only tool batch; it parks until the user presses y/n/a.
+    const onPermission = useCallback((req) => new Promise((resolve) => {
+        permissionResolveRef.current = resolve;
+        setPermission(req);
+        setState('awaiting-permission');
+    }), []);
+    // Render one agent event onto the transcript. Shared by the local turn loop
+    // and the daemon-attach poller, so both paths produce identical output.
+    // `st` carries the streaming-assistant bubble id + accumulated text across
+    // events within a turn/stream.
+    const applyEvent = useCallback((event, st) => {
+        const ensureAssistant = () => {
+            if (!st.assistantId)
+                st.assistantId = pushMessage('assistant', '', true);
+            return st.assistantId;
+        };
+        const closeAssistant = () => {
+            if (st.assistantId) {
+                finalizeMessage(st.assistantId);
+                st.assistantId = null;
+            }
+        };
+        switch (event.kind) {
+            case 'delta':
+                setState('thinking');
+                st.text += event.text;
+                appendToMessage(ensureAssistant(), event.text);
+                break;
+            case 'tool-start': {
+                closeAssistant();
+                setState('tool');
+                const tool = {
+                    id: event.toolUseId,
+                    toolName: event.toolName,
+                    label: formatToolCall(event.toolName, event.summary),
+                    startedAt: Date.now(),
+                    detail: event.detail,
+                };
+                activeToolsRef.current = [...activeToolsRef.current, tool];
+                setActiveTools(activeToolsRef.current);
+                break;
+            }
+            case 'tool-end': {
+                const running = activeToolsRef.current;
+                // Match strictly by toolUseId. Never fall back to "the first
+                // active tool" — under parallel calls that mis-attributes a
+                // result to the wrong call. If no id matches, render the
+                // completion on its own (label from the end event itself).
+                const i = running.findIndex((t) => t.id === event.toolUseId);
+                const done = i >= 0 ? running[i] : undefined;
+                if (i >= 0) {
+                    activeToolsRef.current = [...running.slice(0, i), ...running.slice(i + 1)];
+                    setActiveTools(activeToolsRef.current);
+                }
+                pushMessage('tool', done?.label ?? formatToolCall(event.toolName, event.summary), false, event.isError ? '✗' : '✓', done?.detail, event.isError ? theme.status.error : theme.status.ok, done ? formatElapsed(Date.now() - done.startedAt) : undefined);
+                if (event.isError || event.summary.length > 0 || (event.detail?.length ?? 0) > 0) {
+                    pushMessage('tool', event.isError ? `failed: ${event.summary}` : event.summary, false, '⎿', event.detail);
+                }
+                setState(activeToolsRef.current.length > 0 ? 'tool' : 'thinking');
+                break;
+            }
+            case 'usage':
+                setUsage({ totalTokens: event.totalTokens, costUsd: event.costUsd });
+                break;
+            case 'task':
+                pushMessage('tool', event.subject, false, event.status === 'completed' ? '☑' : '☐');
+                break;
+            case 'done':
+                closeAssistant();
+                break;
+            case 'error':
+                closeAssistant();
+                if (event.message !== 'aborted')
+                    pushMessage('system', `Error: ${event.message}`);
+                break;
+        }
+    }, [appendToMessage, finalizeMessage, pushMessage]);
+    const runTurn = useCallback(async (text, images, replyTo) => {
+        if (!session || !session.hasProvider) {
+            pushMessage('system', session?.errorHint ?? 'Agent is not ready yet — give it a moment.');
+            return;
+        }
+        // `@path` mentions: the visible message keeps the readable token, but
+        // the model receives the file contents inlined.
+        const { sendText, attached } = expandFileMentions(text, ctx.cwd);
+        const priorForSdk = messages
+            .filter((m) => (m.role === 'user' || m.role === 'assistant') && !m.pending)
+            .map((m) => ({
+            role: m.role,
+            content: m.content,
+            timestamp: Date.now(),
+        }));
+        priorForSdk.push({
+            role: 'user',
+            content: sendText,
+            timestamp: Date.now(),
+            ...(images && images.length > 0 ? { attachments: images } : {}),
+        });
+        const metaParts = [];
+        if (attached.length > 0)
+            metaParts.push(`${attached.length} file${attached.length > 1 ? 's' : ''} attached`);
+        if (images && images.length > 0)
+            metaParts.push(`${images.length} image${images.length > 1 ? 's' : ''}`);
+        pushMessage('user', text, false, undefined, undefined, undefined, metaParts.length > 0 ? metaParts.join(' · ') : undefined);
+        setState('thinking');
+        // The model interleaves text → tool → text across iterations; `applyEvent`
+        // (shared with the daemon-attach poller) renders each one in order.
+        const st = { assistantId: null, text: '' };
+        const ac = new AbortController();
+        abortRef.current = ac;
+        try {
+            for await (const event of session.send(priorForSdk, {
+                signal: ac.signal,
+                // Bypass mode (--dangerously-skip-permissions / --yolo): omit the
+                // permission callback so every tool batch auto-approves.
+                onPermission: ctx.skipPermissions ? undefined : onPermission,
+                extraSystem: composeSkillsPrompt(activeSkills) ?? undefined,
+            })) {
+                applyEvent(event, st);
+            }
+        }
+        catch (err) {
+            if (st.assistantId)
+                finalizeMessage(st.assistantId);
+            pushMessage('system', `Error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            abortRef.current = null;
+            permissionResolveRef.current = null;
+            setPermission(null);
+            clearActiveTools();
+            setState('idle');
+            // Persist the turn to the SDK session store (best-effort) so it can
+            // be resumed later. User message + the assistant's reply text.
+            const sessions = sessionsRef.current;
+            const scope = scopeRef.current;
+            if (sessions && scope) {
+                const turn = [createUserMessage(text)];
+                if (st.text.trim().length > 0)
+                    turn.push(createAssistantMessage(st.text));
+                void appendMessages(sessions, scope.sessionId, turn).catch(() => { });
+            }
+            // If this turn answered an inbound peer message, send the reply back
+            // to that peer's inbox — closing the BIAM loop (agent↔agent).
+            if (replyTo && st.text.trim().length > 0) {
+                void sendPeerMessage(replyTo, st.text.trim(), { from: peerIdRef.current ?? undefined });
+            }
+        }
+    }, [activeSkills, applyEvent, ctx.cwd, ctx.skipPermissions, finalizeMessage, messages, onPermission, pushMessage, session]);
+    // Send a message to another agent peer's BIAM inbox (cross-terminal /
+    // cross-agent). Pick the peer by a substring of its display name or id.
+    const doSendPeer = useCallback(async (query, text) => {
+        const peers = await listPeers();
+        const match = peers.find((p) => p.peer_id !== peerIdRef.current &&
+            (p.peer_id === query ||
+                p.display_name.toLowerCase().includes(query.toLowerCase()) ||
+                p.backend.toLowerCase() === query.toLowerCase()));
+        if (!match) {
+            pushMessage('system', `No peer matching "${query}". See /agents.`);
+            return;
+        }
+        const ok = await sendPeerMessage(match.peer_id, text, { from: peerIdRef.current ?? undefined });
+        pushMessage('system', ok
+            ? `Sent to ${match.display_name} [${match.backend}]: ${text}`
+            : `Could not reach ${match.display_name}.`);
+    }, [pushMessage]);
+    const handleSubmit = useCallback((value, images) => {
+        setHistory((prev) => [...prev, value]);
+        const slash = runSlash(value, slashCtx);
+        if (slash) {
+            switch (slash.kind) {
+                case 'message':
+                    pushMessage(slash.role, slash.content);
+                    return;
+                case 'clear':
+                    setMessages([]);
+                    resetTranscript();
+                    return;
+                case 'exit':
+                    exit();
+                    return;
+                case 'repick':
+                    setPhase('picker');
+                    return;
+                case 'remember':
+                    try {
+                        appendMemory(slash.text);
+                        pushMessage('system', `Remembered: ${slash.text}`);
+                    }
+                    catch (err) {
+                        pushMessage('system', `Could not save memory: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    return;
+                case 'show-memory': {
+                    const mem = composeMemoryPrompt(readMemory());
+                    pushMessage('system', mem ?? 'Nothing remembered yet. Use /remember <text>, or edit ~/.namzu/MEMORY.md.');
+                    return;
+                }
+                case 'list-skills': {
+                    const skills = discoverSkills();
+                    if (skills.length === 0) {
+                        pushMessage('system', 'No skills found. Add one at ~/.namzu/skills/<name>/SKILL.md or ./skills/<name>/SKILL.md.');
+                        return;
+                    }
+                    const activeNames = new Set(activeSkills.map((s) => s.name));
+                    const lines = skills.map((s) => `${activeNames.has(s.name) ? '● ' : '○ '}${s.name} — ${s.description}`);
+                    pushMessage('system', `Skills (● active):\n  ${lines.join('\n  ')}`);
+                    return;
+                }
+                case 'load-skill': {
+                    const info = discoverSkills().find((s) => s.name === slash.name);
+                    if (!info) {
+                        pushMessage('system', `No skill named "${slash.name}". See /skills.`);
+                        return;
+                    }
+                    try {
+                        const body = loadSkillBody(info);
+                        setActiveSkills((prev) => [
+                            ...prev.filter((s) => s.name !== info.name),
+                            { name: info.name, body },
+                        ]);
+                        pushMessage('system', `Activated skill: ${info.name}`);
+                    }
+                    catch (err) {
+                        pushMessage('system', `Could not load skill "${slash.name}": ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    return;
+                }
+                case 'resume':
+                    void doResume();
+                    return;
+                case 'list-agents':
+                    void doListAgents();
+                    return;
+                case 'send-peer':
+                    void doSendPeer(slash.peer, slash.text);
+                    return;
+                case 'none':
+                    return;
+            }
+        }
+        // A turn is in flight → queue the message; it auto-sends when idle.
+        // (Queued messages are text-only; pasted images aren't carried.)
+        if (state !== 'idle') {
+            setQueued((q) => [...q, value]);
+            return;
+        }
+        void runTurn(value, images);
+    }, [activeSkills, doListAgents, doResume, doSendPeer, exit, pushMessage, runTurn, slashCtx, state]);
+    // Drain the queue: when a turn settles (idle) and nothing is running,
+    // send the next queued message automatically.
+    useEffect(() => {
+        if (state !== 'idle' || phase !== 'ready' || queued.length === 0 || abortRef.current)
+            return;
+        const [next, ...rest] = queued;
+        setQueued(rest);
+        if (next !== undefined)
+            void runTurn(next);
+    }, [state, phase, queued, runTurn]);
+    // BIAM presence (best-effort, no-op without clawtool): register once ready
+    // as a peer in clawtool's registry, heartbeat, and deregister on unmount.
+    // `registerPeer` ensures clawtool's daemon, so the user never starts it by
+    // hand. clawtool also prunes stale peers, so a missed deregister self-heals.
+    useEffect(() => {
+        if (phase !== 'ready' || peerIdRef.current)
+            return;
+        const home = process.env.HOME;
+        const title = home && ctx.cwd.startsWith(home) ? `~${ctx.cwd.slice(home.length)}` : ctx.cwd;
+        let cancelled = false;
+        void registerPeer({
+            display_name: `namzu ${title}`,
+            backend: 'namzu',
+            path: ctx.cwd,
+            pid: process.pid,
+        }).then((id) => {
+            if (!cancelled)
+                peerIdRef.current = id;
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [phase, ctx.cwd]);
+    useEffect(() => {
+        stateRef.current = state;
+    }, [state]);
+    // One-shot update check on launch: namzu (npm) + clawtool (`upgrade --check`).
+    // Best-effort; surfaces a single notice when something newer is out.
+    const updateCheckedRef = useRef(false);
+    useEffect(() => {
+        if (phase !== 'ready' || updateCheckedRef.current)
+            return;
+        updateCheckedRef.current = true;
+        void checkUpdates(ctx.version).then((ups) => {
+            if (ups.length === 0)
+                return;
+            const lines = ups.map((u) => `  • ${u.name} ${u.current} → ${u.latest}  (${u.how})`);
+            pushMessage('system', `⬆ Update available:\n${lines.join('\n')}`);
+        });
+    }, [phase, ctx.version, pushMessage]);
+    useEffect(() => {
+        const id = peerIdRef.current;
+        if (id)
+            void heartbeatPeer(id);
+    }, [state]);
+    // Inbound BIAM: drain our peer inbox so clawtool / another agent can talk
+    // TO namzu. Each message is surfaced; when namzu is free it answers and the
+    // reply goes back to the sender (closing the agent↔agent loop).
+    useEffect(() => {
+        if (phase !== 'ready')
+            return;
+        let stopped = false;
+        const tick = async () => {
+            const id = peerIdRef.current;
+            if (stopped || !id)
+                return;
+            const msgs = await drainInbox(id);
+            let answered = stateRef.current !== 'idle' || Boolean(abortRef.current);
+            for (const m of msgs) {
+                const text = m.text?.trim();
+                if (!text)
+                    continue;
+                pushMessage('system', `📨 ${m.from_peer}: ${text}`);
+                // Answer the first message while free; reply routes back via replyTo.
+                if (!answered) {
+                    answered = true;
+                    void runTurn(text, undefined, m.from_peer);
+                }
+            }
+        };
+        const timer = setInterval(() => void tick(), 2000);
+        return () => {
+            stopped = true;
+            clearInterval(timer);
+        };
+    }, [phase, pushMessage, runTurn]);
+    useEffect(() => () => {
+        const id = peerIdRef.current;
+        if (id)
+            void deregisterPeer(id);
+    }, []);
+    const handlePickerSubmit = useCallback((selection) => {
+        const prefs = {
+            version: 2,
+            provider: selection.provider,
+            model: selection.model,
+            subagents: { active: [] },
+        };
+        try {
+            writePreferences(prefs);
+        }
+        catch (err) {
+            pushMessage('system', `Could not save preferences: ${err instanceof Error ? err.message : String(err)}`);
+            return;
+        }
+        void hydrateSession(prefs, detected);
+    }, [detected, hydrateSession, pushMessage]);
+    const handlePickerCancel = useCallback(() => {
+        setPhase('unhealthy');
+        pushMessage('system', 'Picker cancelled. Set an LLM credential (ANTHROPIC_API_KEY / OPENAI_API_KEY / OPENROUTER_API_KEY / start Ollama) and restart namzu.');
+    }, [pushMessage]);
+    useInput((input, key) => {
+        // Resume picker owns the keyboard while open.
+        if (phase === 'resume') {
+            if (key.upArrow)
+                setSelectedResume((i) => Math.max(0, i - 1));
+            else if (key.downArrow)
+                setSelectedResume((i) => Math.min(resumeList.length - 1, i + 1));
+            else if (key.return) {
+                const conv = resumeList[selectedResume];
+                if (conv)
+                    void resumeConversation(conv);
+            }
+            else if (key.escape || (key.ctrl && input === 'c'))
+                setPhase('ready');
+            return;
+        }
+        // Trust gate owns the keyboard until the folder is trusted or we exit.
+        if (phase === 'trust') {
+            const ch = input.toLowerCase();
+            if (ch === 'y' || key.return)
+                acceptTrust();
+            else if (ch === 'n' || key.escape || (key.ctrl && input === 'c'))
+                exit();
+            return;
+        }
+        // A pending permission prompt owns the keyboard: y/n/a decide it.
+        if (permissionResolveRef.current) {
+            const ch = input.toLowerCase();
+            if (key.ctrl && (input === 'c' || input === '\x03')) {
+                resolvePermission({ kind: 'reject', feedback: 'User interrupted.' });
+                abortRef.current?.abort();
+                return;
+            }
+            if (ch === 'y' || key.return)
+                resolvePermission({ kind: 'approve' });
+            else if (ch === 'a')
+                resolvePermission({ kind: 'approve-all' });
+            else if (ch === 'n' || key.escape)
+                resolvePermission({ kind: 'reject' });
+            return;
+        }
+        // Esc interrupts a running turn (Ctrl+C stays reserved for exit). Mirrors
+        // the Ctrl+C interrupt path: abort, drop the queue, one "Interrupted." line.
+        if (key.escape && abortRef.current) {
+            abortRef.current.abort();
+            abortRef.current = null;
+            setQueued([]);
+            pushMessage('system', 'Interrupted.');
+            return;
+        }
+        // Ctrl+O toggles expansion of collapsed tool diffs / output.
+        if (key.ctrl && input === 'o') {
+            setExpanded((e) => !e);
+            return;
+        }
+        if (key.ctrl && (input === 'c' || input === '\x03')) {
+            // A turn is running → first Ctrl+C interrupts it, not exits.
+            if (abortRef.current) {
+                abortRef.current.abort();
+                // Drop the ref now so a second Ctrl+C arms exit instead of
+                // re-aborting (which spammed "Interrupted." lines), and clear any
+                // queued messages — interrupting means stop, not "run the next one".
+                abortRef.current = null;
+                setQueued([]);
+                pushMessage('system', 'Interrupted.');
+                return;
+            }
+            if (exitArmedRef.current) {
+                exit();
+                return;
+            }
+            exitArmedRef.current = true;
+            pushMessage('system', 'Press Ctrl+C again to exit.');
+            setTimeout(() => {
+                exitArmedRef.current = false;
+            }, 2000);
+        }
+    }, { isActive: phase !== 'picker' });
+    // Background is left natural — we inherit the terminal's own background
+    // (like claude-code / gemini-cli) and only theme the foreground. Forcing
+    // a filled bg left mismatched patches around bordered areas, so we don't.
+    return (_jsxs(Box, { flexDirection: "column", children: [phase !== 'ready' ? (_jsx(Banner, { version: ctx.version, session: session, bypass: ctx.skipPermissions === true, cwd: ctx.cwd })) : null, _jsxs(Box, { flexDirection: "column", paddingX: 1, children: [phase === 'trust' ? (_jsx(TrustPrompt, { cwd: ctx.cwd })) : phase === 'resume' ? (_jsx(ResumePicker, { conversations: resumeList, selected: selectedResume })) : phase === 'picker' ? (_jsx(Picker, { detected: detected, currentProvider: currentProvider, onSubmit: handlePickerSubmit, onCancel: handlePickerCancel })) : (_jsxs(_Fragment, { children: [_jsx(TranscriptFrame, { children: _jsx(Transcript, { messages: messages.filter((m) => !m.pending), pending: messages.find((m) => m.pending) ?? null, state: state, expanded: expanded, resetKey: resetKey, header: phase === 'ready' ? (_jsx(Banner, { version: ctx.version, session: session, bypass: ctx.skipPermissions === true, cwd: ctx.cwd })) : undefined }) }), _jsx(LiveActivity, { activeTools: activeTools, thinking: state === 'thinking' && !messages.some((m) => m.pending) }), permission ? (_jsx(PermissionOverlay, { toolCalls: permission.toolCalls })) : (_jsxs(ComposerFrame, { focus: state === 'idle' && phase === 'ready', children: [queued.length > 0 ? (_jsx(Box, { paddingX: 1, children: _jsxs(Text, { color: theme.text.muted, children: ["\u23CE ", queued.length, " message", queued.length > 1 ? 's' : '', " queued \u2014 sending when ready"] }) })) : null, _jsx(Composer, { disabled: phase !== 'ready' || state === 'awaiting-permission', onSubmit: handleSubmit, history: history })] }))] })), _jsx(Box, { paddingTop: 1, children: _jsx(StatusBar, { cwd: ctx.cwd, provider: session?.providerSummary ?? null, model: session?.modelSummary ?? null, state: state, hint: hintForPhase(phase, state), usage: usage, contextWindow: contextWindowFor(session?.modelSummary ?? null) }) })] })] }));
+}
+function Banner({ version, session, bypass, cwd, }) {
+    const cols = process.stdout.columns ?? 80;
+    const wide = cols >= NAMZU_WORDMARK_MIN_WIDTH;
+    const provider = session?.providerSummary;
+    const model = session?.modelSummary;
+    const home = process.env.HOME;
+    const prettyCwd = home && cwd.startsWith(home) ? `~${cwd.slice(home.length)}` : cwd;
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingTop: 1, paddingBottom: 1, children: [_jsxs(Box, { flexDirection: "row", children: [wide ? (_jsx(Box, { flexDirection: "column", marginRight: 2, children: NAMZU_WORDMARK.map((line, i) => (_jsx(Text, { color: NAMZU_WORDMARK_GRADIENT[i], bold: true, children: line }, `wm-${i}`))) })) : (_jsxs(Text, { color: NAMZU_MARK_COLOR, children: [NAMZU_MARK, " "] })), _jsxs(Box, { flexDirection: "column", marginTop: wide ? 1 : 0, children: [_jsxs(Text, { children: [_jsx(Text, { color: theme.text.secondary, children: "Cogitave" }), wide ? null : (_jsxs(Text, { color: NAMZU_MARK_COLOR, bold: true, children: [' ', "Namzu"] })), _jsxs(Text, { color: theme.text.muted, children: [" v", version] })] }), _jsx(Text, { color: theme.text.secondary, children: provider ? `${provider}${model ? ` · ${model}` : ''}` : 'the agent in your terminal' }), _jsx(Text, { color: theme.text.muted, children: prettyCwd })] })] }), bypass ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.status.error, bold: true, children: "\u26A0 bypass permissions \u2014 tools run without asking" }) })) : null] }));
+}
+function TranscriptFrame({ children }) {
+    // Borderless, edge-to-edge — the message glyph gutter provides structure.
+    return _jsx(Box, { flexDirection: "column", children: children });
+}
+/** Approximate context window (tokens) per model, for the status gauge. The
+ *  `[1m]` long-context variants get 1M; everything else defaults to 200k. */
+function contextWindowFor(model) {
+    if (!model)
+        return 200_000;
+    if (model.includes('[1m]') || model.includes('-1m'))
+        return 1_000_000;
+    return 200_000;
+}
+function ComposerFrame({ focus, children, }) {
+    // Input-field look: a rounded rule above and below the composer, no side
+    // borders, so the input reads as a field rather than a heavy box.
+    return (_jsx(Box, { flexDirection: "column", borderStyle: "round", borderTop: true, borderBottom: true, borderLeft: false, borderRight: false, borderColor: focus ? theme.border.focus : theme.border.default, marginTop: 1, children: children }));
+}
+// Claude-Code-style tool call label: `Bash(ls -la)`, `Read(file.ts)`.
+// The `clawtool_` prefix is stripped and the name title-cased.
+function formatToolCall(toolName, summary) {
+    const base = toolName.replace(/^clawtool_/, '');
+    const display = base.length > 0 ? base[0]?.toUpperCase() + base.slice(1) : base;
+    return summary.length > 0 ? `${display}(${summary})` : display;
+}
+function hintForPhase(phase, state) {
+    if (phase === 'trust')
+        return 'y trust this folder · n exit';
+    if (phase === 'resume')
+        return '↑↓ navigate · enter resume · esc cancel';
+    if (phase === 'probing')
+        return 'discovering providers…';
+    if (phase === 'picker')
+        return '↑↓ navigate · enter accept · esc cancel';
+    if (phase === 'unhealthy')
+        return 'Ctrl+C ×2 to exit';
+    if (state === 'awaiting-permission')
+        return 'y approve · n reject · a approve all';
+    if (state !== 'idle')
+        return 'agent is working — esc to interrupt';
+    return '/help · @file / Ctrl+V to attach · Ctrl+C ×2 to exit';
+}
+//# sourceMappingURL=App.js.map