@datename/fastcode-termux 0.1.6 → 0.1.8-beta.0

package/src/app.ts

@@ -11,58 +11,129 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Box, Static, Text, useApp, useInput } from "ink";
-import { AGENT_SYSTEM_PROMPT, formatToolResults, parseToolCalls, stripToolCalls, } from "./agent/protocol.js";
-import { runAgentTool } from "./agent/tools.js";
+import { AGENT_SYSTEM_PROMPT, stripToolCalls, } from "./agent/protocol.js";
+import { compactionConfigFromEnv, removeSummaryFile } from "./agent/compaction.js";
+import { resolveToolProtocol, withToolCapability } from "./agent/protocol-mode.js";
+import { runAgent } from "./agent/runner.js";
+import { decisionForOption, parseApprovalChoice, type ApprovalDecision, type ApprovalRequest } from "./agent/approval.js";
+import { nativeApproval } from "./agent/approval-native.js";
+import { toolSchemas } from "./agent/tool-schemas.js";
+import { setShellPoolSize as applyShellPoolSize, shutdownShells, shutdownShellsAsync } from "./agent/shell-session.js";
 import { Banner } from "./ui/Banner.js";
 import { Spinner } from "./ui/Spinner.js";
 import { StatusBar } from "./ui/StatusBar.js";
 import { MessageBubble } from "./ui/Message.js";
 import { Prompt } from "./ui/Prompt.js";
+import { Picker } from "./ui/Picker.js";
 import { COMMANDS, findCommand, parseSlash } from "./commands/index.js";
-import { saveScopedKey } from "./commands/login.js";
-import { getProvider, getProviderOrThrow, PROVIDERS } from "./providers/index.js";
-import { loadConfig, saveConfig, resolveApiKey, getLegacy, } from "./config/store.js";
+import { maskLoginEcho, saveScopedKey } from "./commands/login.js";
+import { isValidModelId } from "./commands/model.js";
+import { getProvider, getProviderOrThrow, probeProvider, PROVIDERS } from "./providers/index.js";
+import { loadConfig, saveConfig, resolveApiKey, resolveProviderKey, getLegacy, } from "./config/store.js";
 import { getTheme } from "./config/themes.js";
 import { createStartupTranscript } from "./lib/startup.js";
 import { shouldUseLiveStreamingUi, shouldUseStableTerminalUi } from "./lib/uiMode.js";
 import { buildPluginsPrompt } from "./plugins/manager.js";
 import { buildSkillsPrompt } from "./skills/manager.js";
-import { createSessionLog, loadSessionMessages, openSessionLog } from "./session/log.js";
+import { createSessionLog, latestUnclosedSession, loggingEnabled, openSessionLog, staleSummaryRefs } from "./session/log.js";
+import { resumeSession } from "./session/projection.js";
 import { isTrusted, trustProject } from "./config/trust.js";
 import { TrustGate } from "./ui/TrustGate.js";
-/**
- * Mask the secret part of a `/login` invocation in the transcript:
- * `/login prov` → unchanged, `/login prov <key>` → key masked,
- * `/login prov model <key>` → provider/model shown, key masked.
- */
-function maskLoginEcho(args) {
-    const parts = ["/login", args[0] ?? ""];
-    if (args.length === 2) {
-        parts.push("********");
+import type { CommandCompaction } from "./types.js";
+function positiveInt(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function streamingTail(text, maxLines = 6) {
+    const lines = String(text ?? "").split(/\r?\n/);
+    if (lines.length <= maxLines)
+        return String(text ?? "");
+    return "…\n" + lines.slice(-maxLines).join("\n");
+}
+function collapseToolOutput(output) {
+    const text = String(output ?? "");
+    const lines = text.split(/\r?\n/);
+    const first = (lines.find((line) => line.trim()) ?? "").trim();
+    const clipped = first.length > 160 ? first.slice(0, 157) + "..." : first;
+    const rest = Math.max(0, lines.length - 1);
+    return `${clipped}${clipped ? "\n" : ""}[${rest} more lines, ${text.length} chars]`;
+}
+function optionalBudget(name) {
+    const value = Number(process.env[name]);
+    return Number.isFinite(value) && value > 0 ? value : undefined;
+}
+function uniqueModelList(models) {
+    const seen = new Set();
+    const result = [];
+    for (const model of models) {
+        if (!model?.id || seen.has(model.id))
+            continue;
+        seen.add(model.id);
+        result.push(model);
     }
-    else if (args.length >= 3) {
-        parts.push(args[1]);
-        for (let i = 2; i < args.length; i += 1)
-            parts.push("********");
+    return result;
+}
+function unclosedNotice(session) {
+    const where = session.cwd || "(unknown directory)";
+    const files = session.activeFiles?.length ?? 0;
+    return `Last session did not close normally (${where}, ~${session.turns} turns, ${files} file${files === 1 ? "" : "s"} changed).\n` +
+        `Resume it with \`fastcode resume ${session.id}\`, or list sessions with \`fastcode sessions\`.`;
+}
+function streamErrorMessage(message, provider, model) {
+    if (/\b(401|403)\b/.test(message) || /invalid api key|unauthorized|authentication/i.test(message)) {
+        return `Authentication failed for ${provider.label} · ${model}. The key may be wrong or not allowed for this model.\n` +
+            `Check with \`/whoami\`, or re-save: \`/login ${provider.id} ${model} <key>\`.`;
     }
-    return parts.filter((p) => p !== "").join(" ");
+    if (/\b(402|429)\b/.test(message) || /quota|insufficient|rate limit|billing|balance/i.test(message)) {
+        return `Request blocked: ${provider.label} reports no remaining quota / rate limit for ${model}.\n` +
+            `Top up the account or switch model/provider. (${message.slice(0, 200)})`;
+    }
+    return `Error: ${message}`;
 }
-export const App = ({ initialPrompt, resume }) => {
+export const App = ({ initialPrompt, resume, ui = "tty" }) => {
     const { exit } = useApp();
     const startupRef = useRef(null);
     if (!startupRef.current) {
         const config = loadConfig();
-        const restored = resume ? loadSessionMessages(resume) : [];
+        const resumed = resume ? resumeSession(resume) : undefined;
+        if (resumed) {
+            const provider = resumed.meta.providerId ? getProvider(resumed.meta.providerId) : undefined;
+            if (provider) {
+                config.providerId = provider.id;
+                if (resumed.meta.model)
+                    config.model = resumed.meta.model;
+            }
+        }
+        const restored = resumed?.messages ?? [];
+        const transcript = restored.length > 0
+            ? restored.map((message, index) => ({
+                id: index + 1,
+                role: message.role,
+                content: message.role === "assistant" ? stripToolCalls(message.content) : message.content,
+                markdown: message.role !== "user",
+            }))
+            : createStartupTranscript(config);
+        if (resumed) {
+            const push = (text) => transcript.push({ id: transcript.length + 1, role: "system", content: text, markdown: true });
+            if (resumed.meta.providerId && !getProvider(resumed.meta.providerId))
+                push(`The session used provider ${resumed.meta.providerId}, which is not available in this build.`);
+            push(`Resumed session: ${config.providerId}::${config.model}${resumed.rebuilt ? " (projection rebuilt)" : ""}.`);
+            for (const warning of resumed.warnings)
+                push(warning);
+        }
+        else if (!resume && loggingEnabled()) {
+            const unclosed = latestUnclosedSession();
+            if (unclosed) {
+                transcript.push({
+                    id: transcript.length + 1,
+                    role: "system",
+                    content: unclosedNotice(unclosed),
+                    markdown: true,
+                });
+            }
+        }
         startupRef.current = {
             config,
-            transcript: restored.length > 0
-                ? restored.map((message, index) => ({
-                    id: index + 1,
-                    role: message.role,
-                    content: message.content,
-                    markdown: message.role !== "user",
-                }))
-                : createStartupTranscript(config),
+            transcript,
             history: restored.map((message) => ({ role: message.role, content: message.content })),
         };
     }
@@ -70,43 +141,104 @@ export const App = ({ initialPrompt, resume }) => {
     const sessionRef = useRef(null as any);
     if (!sessionRef.current) {
         sessionRef.current = resume
-            ? openSessionLog(resume)
+            ? openSessionLog(resume, {
+                providerId: startup.config.providerId,
+                model: startup.config.model,
+                cwd: process.cwd(),
+            })
             : createSessionLog({
                 providerId: startup.config.providerId,
                 model: startup.config.model,
                 cwd: process.cwd(),
             });
     }
-    const [trusted, setTrusted] = useState(() => isTrusted(process.cwd()));
+    const [, setTrustEpoch] = useState(0);
+    const trusted = isTrusted(process.cwd());
     const [config, setConfig] = useState(startup.config);
     const [history, setHistory] = useState(startup.history ?? []);
     const [transcript, setTranscript] = useState(startup.transcript);
     const [streamingId, setStreamingId] = useState(null);
     const [streamingText, setStreamingText] = useState("");
+    const [streamPhase, setStreamPhase] = useState("thinking");
     const [input, setInput] = useState("");
     const [pendingLogin, setPendingLogin] = useState(null);
+    const [picker, setPicker] = useState(null);
+    const [pickerIndex, setPickerIndex] = useState(0);
+    const modelSetupIdRef = useRef(0);
+    const openModelSetupPickerRef = useRef(null);
+    const plainApprovalRef = useRef<null | {
+        request: ApprovalRequest;
+        submit(text: string): void;
+        cancel(): void;
+    }>(null);
+    const [approvalFeedbackPrompt, setApprovalFeedbackPrompt] = useState<string | null>(null);
+    const approvalFeedbackRef = useRef<null | {
+        submit(text: string): void;
+        cancel(): void;
+    }>(null);
     const [busy, setBusy] = useState(false);
+    const [expanded, setExpanded] = useState(false);
+    const steerQueueRef = useRef([]);
     const [totalIn, setTotalIn] = useState(0);
     const [totalOut, setTotalOut] = useState(0);
     const [totalCost, setTotalCost] = useState(0);
     const [agentActivity, setAgentActivity] = useState(null);
     const idRef = useRef(startup.transcript.length);
     const abortRef = useRef(null);
+    const sawDeltaRef = useRef(false);
+    const lastStreamFlushRef = useRef(0);
     const ctrlCRef = useRef(0);
+    const exitConfirmRef = useRef(0);
+    const busyRef = useRef(false);
     const initialPromptSubmittedRef = useRef(false);
+    const quittingRef = useRef(false);
+    const quitCleanly = useCallback(async () => {
+        if (quittingRef.current)
+            return;
+        quittingRef.current = true;
+        if (abortRef.current) {
+            abortRef.current.abort();
+            abortRef.current = null;
+        }
+        // Give the aborted run a chance to append its final facts before the
+        // session save point is closed.
+        const idleDeadline = Date.now() + 1000;
+        while (busyRef.current && Date.now() < idleDeadline)
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        try {
+            await shutdownShellsAsync(400);
+        }
+        catch {
+            shutdownShells();
+        }
+        try {
+            sessionRef.current?.close?.({ reason: "exit" });
+        }
+        catch {
+            // Session close is best effort during exit.
+        }
+        exit();
+    }, [exit]);
+    useEffect(() => {
+        applyShellPoolSize(config.shellPoolSize);
+    }, [config.shellPoolSize]);
     const theme = getTheme(config.theme);
     const stableUi = useMemo(() => shouldUseStableTerminalUi(), []);
     const liveStreamingUi = useMemo(() => shouldUseLiveStreamingUi(), []);
     // The banner picks a font that fits the terminal width (see ui/Banner.ts)
     // and renders nothing when even the smallest font is too wide.
     const showBanner = transcript.length <= startup.transcript.length && !busy;
-    const promptPlaceholder = pendingLogin
-        ? pendingLogin.step === "provider"
-            ? "Provider id (e.g. deepseek) · Esc to cancel"
-            : pendingLogin.step === "model"
-                ? "Model id (e.g. deepseek-chat) · Esc to cancel"
+    const promptPlaceholder = approvalFeedbackPrompt
+        ? `${approvalFeedbackPrompt} · Esc to cancel`
+        : pendingLogin
+        ? pendingLogin.step === "loading-models"
+            ? "Loading available models…"
+            : pendingLogin.step === "model-manual"
+            ? "Model id (e.g. deepseek-flash) · Esc to cancel"
+            : pendingLogin.hasExistingKey
+                ? "API key (masked), or Enter to keep existing key · Esc to cancel"
                 : pendingLogin.provider && getLegacy(pendingLogin.provider)
-                    ? "Paste API key (masked), or type 'keep' · Esc to cancel"
+                    ? "API key (masked), or type 'keep' · Esc to cancel"
                     : "Paste API key (masked) · Esc to cancel"
         : undefined;
     const promptMask = pendingLogin?.step === "key" ? "*" : undefined;
@@ -114,13 +246,55 @@ export const App = ({ initialPrompt, resume }) => {
     useEffect(() => {
         saveConfig(config);
     }, [config]);
+    const chooseItem = useCallback((request, index) => {
+        const item = request?.items?.[index];
+        setPicker(null);
+        if (item)
+            request.onSelect(item.value, item);
+    }, []);
     // Esc cancels streaming. Double Ctrl+C quits.
     useInput((inputChar, key) => {
-        if (key.escape) {
+        if (picker) {
+            if (key.escape || (key.ctrl && inputChar === "c")) {
+                const onCancel = picker.onCancel;
+                setPicker(null);
+                onCancel?.();
+                return;
+            }
+            if (picker.items.length === 0)
+                return;
+            if (key.upArrow) {
+                setPickerIndex((i) => Math.max(0, i - 1));
+                return;
+            }
+            if (key.downArrow) {
+                setPickerIndex((i) => Math.min(picker.items.length - 1, i + 1));
+                return;
+            }
+            if (key.return) {
+                chooseItem(picker, pickerIndex);
+                return;
+            }
+            if (/^[1-9]$/.test(inputChar)) {
+                chooseItem(picker, Number(inputChar) - 1);
+                return;
+            }
+            return;
+        }
+        if (key.escape || (key.ctrl && inputChar === "c" && (approvalFeedbackRef.current || plainApprovalRef.current || pendingLogin))) {
+            if (approvalFeedbackRef.current) {
+                approvalFeedbackRef.current.cancel();
+                return;
+            }
+            if (plainApprovalRef.current) {
+                plainApprovalRef.current.cancel();
+                return;
+            }
             if (pendingLogin) {
+                modelSetupIdRef.current += 1;
                 setPendingLogin(null);
                 setInput("");
-                pushSystem("API key entry cancelled.");
+                pushSystem("Model configuration cancelled. Existing settings were not changed.");
                 return;
             }
             if (abortRef.current) {
@@ -131,8 +305,19 @@ export const App = ({ initialPrompt, resume }) => {
         }
         if (key.ctrl && inputChar === "c") {
             ctrlCRef.current += 1;
+            if (busy && ctrlCRef.current === 1) {
+                if (abortRef.current) {
+                    abortRef.current.abort();
+                    abortRef.current = null;
+                }
+                pushSystem("Cancelled current run; partial output kept. Press Ctrl+C again to quit, or type 继续 to continue.");
+                setTimeout(() => {
+                    ctrlCRef.current = 0;
+                }, 1500);
+                return;
+            }
             if (ctrlCRef.current >= 2) {
-                exit();
+                void quitCleanly();
             }
             else {
                 pushSystem("Press Ctrl+C again to quit.");
@@ -144,27 +329,355 @@ export const App = ({ initialPrompt, resume }) => {
     });
     const pushSystem = useCallback((text) => {
         idRef.current += 1;
-        sessionRef.current.append({ type: "message", role: "system", content: text });
+        sessionRef.current.append({ type: "notice", content: text });
         setTranscript((prev) => [
             ...prev,
             { id: idRef.current, role: "system", content: text, markdown: true },
         ]);
     }, []);
-    const pushUser = useCallback((text) => {
+    const pushUser = useCallback((text, recordFact = true) => {
         idRef.current += 1;
-        sessionRef.current.append({ type: "message", role: "user", content: text });
+        sessionRef.current.append(recordFact
+            ? { type: "user", content: text }
+            : { type: "notice", content: text });
         setTranscript((prev) => [
             ...prev,
             { id: idRef.current, role: "user", content: text, markdown: false },
         ]);
     }, []);
+    const finishModelSetup = useCallback((setup, providerId, modelId, keyReceipt = undefined) => {
+        if (setup.id !== modelSetupIdRef.current)
+            return;
+        const provider = getProvider(providerId);
+        if (!provider) {
+            setPendingLogin(null);
+            setInput("");
+            pushSystem("Provider is no longer available. Configuration was not changed.");
+            return;
+        }
+        setConfig((current) => ({ ...current, providerId: provider.id, model: modelId }));
+        setPendingLogin(null);
+        setInput("");
+        modelSetupIdRef.current += 1;
+        pushSystem(keyReceipt
+            ? `${keyReceipt}\nActive model: ${provider.id} · ${modelId}.`
+            : `Provider/model set to ${provider.id} · ${modelId}. ${provider.authEnv.length === 0 ? "No API key is required." : ""}`);
+    }, [pushSystem]);
+    const continueModelSetup = useCallback((setup, providerId, modelId) => {
+        if (setup.id !== modelSetupIdRef.current)
+            return;
+        const provider = getProvider(providerId);
+        if (!provider) {
+            setPendingLogin(null);
+            pushSystem("Unknown provider. Configuration was not changed.");
+            return;
+        }
+        if (provider.authEnv.length === 0) {
+            finishModelSetup(setup, provider.id, modelId);
+            return;
+        }
+        const existing = resolveApiKey(provider.id, modelId, provider.authEnv);
+        setPendingLogin({
+            ...setup,
+            step: "key",
+            provider: provider.id,
+            model: modelId,
+            hasExistingKey: existing.status === "ok",
+        });
+        setPicker(null);
+        setInput("");
+        pushSystem(`Selected ${provider.label} · ${modelId}. Enter the API key for this provider. ` +
+            "The key is provider-wide and will be reused for its models." +
+            (existing.status === "ok" ? " Press Enter on an empty input to keep the existing key." : ""));
+    }, [finishModelSetup, pushSystem]);
+    const openModelSetupPicker = useCallback(async (setup, step, providerId = undefined) => {
+        if (setup.id !== modelSetupIdRef.current)
+            return;
+        if (step === "provider") {
+            setPendingLogin({ ...setup, step: "provider", provider: undefined, model: undefined });
+            const currentProvider = setup.provider ?? config.providerId;
+            setPickerIndex(Math.max(0, PROVIDERS.findIndex((provider) => provider.id === currentProvider)));
+            setPicker({
+                title: "Configure provider · choose a provider",
+                current: currentProvider,
+                items: PROVIDERS.map((provider) => ({
+                    value: provider.id,
+                    label: `${provider.id.padEnd(12)} ${provider.label}`,
+                    hint: provider.authEnv.length === 0 ? "no API key required" : provider.defaultModel,
+                })),
+                onSelect: (id) => {
+                    const selected = getProvider(id);
+                    if (!selected)
+                        return;
+                    const nextSetup = {
+                        ...setup,
+                        provider: selected.id,
+                        model: selected.id === config.providerId ? config.model : selected.defaultModel,
+                    };
+                    void openModelSetupPickerRef.current?.(nextSetup, "model", selected.id);
+                },
+                onCancel: () => {
+                    if (setup.id !== modelSetupIdRef.current)
+                        return;
+                    modelSetupIdRef.current += 1;
+                    setPendingLogin(null);
+                    setInput("");
+                    pushSystem("Model configuration cancelled. Existing settings were not changed.");
+                },
+            });
+            return;
+        }
+
+        const provider = getProvider(providerId);
+        if (!provider) {
+            setPendingLogin(null);
+            pushSystem("Unknown provider. Configuration was not changed.");
+            return;
+        }
+        setPendingLogin({ ...setup, step: "loading-models", provider: provider.id });
+        setInput("");
+        setPickerIndex(0);
+        setPicker({
+            title: `Loading models · ${provider.label}`,
+            current: undefined,
+            items: [],
+            onSelect: () => { },
+            onCancel: () => {
+                if (setup.id !== modelSetupIdRef.current)
+                    return;
+                modelSetupIdRef.current += 1;
+                setPendingLogin(null);
+                setInput("");
+                pushSystem("Model configuration cancelled. Existing settings were not changed.");
+            },
+        });
+        const { key } = resolveProviderKey(provider.id, provider.authEnv);
+        let models = [];
+        let online = false;
+        try {
+            models = uniqueModelList(await provider.listModels(key));
+            online = await probeProvider(provider, key);
+        }
+        catch {
+            online = false;
+        }
+        if (setup.id !== modelSetupIdRef.current)
+            return;
+        if (!models.some((model) => model.id === provider.defaultModel))
+            models.unshift({ id: provider.defaultModel, label: "provider default" });
+        const manualModelValue = "__fastcode_manual_model_id__";
+        const items = [
+            ...models.slice(0, 49).map((model) => ({
+                value: model.id,
+                label: model.id,
+                hint: model.label && model.label !== model.id ? model.label : undefined,
+            })),
+            { value: manualModelValue, label: "Enter model ID manually…" },
+        ];
+        const currentModel = setup.model ?? provider.defaultModel;
+        const currentIndex = items.findIndex((item) => item.value === currentModel);
+        setPendingLogin({ ...setup, step: "model", provider: provider.id, model: currentModel });
+        setPickerIndex(currentIndex >= 0 ? currentIndex : 0);
+        pushSystem(`Models for ${provider.label}: ${models.length}${online ? "" : " (offline — showing built-in/cached models)"}.`);
+        setPicker({
+            title: `Configure model · ${provider.label}${online ? "" : " · offline list"}`,
+            current: currentModel,
+            items,
+            onSelect: (id) => {
+                if (setup.id !== modelSetupIdRef.current)
+                    return;
+                if (id === manualModelValue) {
+                    setPendingLogin({ ...setup, step: "model-manual", provider: provider.id });
+                    setInput("");
+                    pushSystem("Enter a model ID (letters, numbers, . _ : / + -; up to 200 characters).");
+                    return;
+                }
+                continueModelSetup(setup, provider.id, id);
+            },
+            onCancel: () => {
+                if (setup.id === modelSetupIdRef.current)
+                    void openModelSetupPickerRef.current?.(setup, "provider");
+            },
+        });
+    }, [config.model, config.providerId, continueModelSetup, pushSystem]);
+    openModelSetupPickerRef.current = openModelSetupPicker;
+    const startModelSetup = useCallback(({ provider, model, flow = "login" }) => {
+        const setup = {
+            id: ++modelSetupIdRef.current,
+            flow,
+            originalProvider: config.providerId,
+            originalModel: config.model,
+            provider,
+            model,
+        };
+        setPendingLogin(setup);
+        setInput("");
+        if (flow === "model" && provider) {
+            void openModelSetupPicker(setup, "model", provider);
+        }
+        else if (provider && model) {
+            continueModelSetup(setup, provider, model);
+        }
+        else if (provider) {
+            void openModelSetupPicker(setup, "model", provider);
+        }
+        else {
+            void openModelSetupPicker(setup, "provider");
+        }
+    }, [config.model, config.providerId, continueModelSetup, openModelSetupPicker]);
+    const requestApproval = useCallback(async (request: ApprovalRequest): Promise<ApprovalDecision> => {
+        const defaultDecision = (): ApprovalDecision => {
+            const option = request.options[request.defaultIndex ?? 0];
+            if (!option || option.kind === "allow")
+                return { kind: "deny", reason: "approval timeout/cancel (fail closed)" };
+            return decisionForOption(option);
+        };
+        if (ui === "native" && process.platform !== "win32") {
+            const native = await nativeApproval(request, abortRef.current?.signal);
+            if (native)
+                return native;
+        }
+        const preview = request.preview?.kind === "diff" && request.preview.text
+            ? `\n\n${request.preview.text.slice(0, 4000)}`
+            : "";
+        pushSystem(`[approval] Tier ${request.tier ?? 2} · ${request.tool}\n${request.prompt ?? "Approval required"}${preview}`);
+        if (ui === "json") {
+            return { kind: "deny", reason: "JSON approval mode requires the headless protocol channel (not wired in this build)" };
+        }
+        const approvalSignal = abortRef.current?.signal;
+        if (ui === "plain") {
+            return await new Promise((resolve) => {
+                let settled = false;
+                let timer;
+                const onAbort = () => finish({ kind: "deny", reason: "run cancelled" });
+                const finish = (decision: ApprovalDecision) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    if (timer)
+                        clearTimeout(timer);
+                    approvalSignal?.removeEventListener("abort", onAbort);
+                    plainApprovalRef.current = null;
+                    resolve(decision);
+                };
+                approvalSignal?.addEventListener("abort", onAbort, { once: true });
+                const lines = request.options.map((option, index) => `${index + 1}. ${option.label}`);
+                pushSystem(`Choose an option:\n${lines.join("\n")}\nEnter a number (1-${request.options.length}); Esc cancels.`);
+                plainApprovalRef.current = {
+                    request,
+                    submit: (text) => {
+                        const option = parseApprovalChoice(request, text);
+                        if (!option) {
+                            pushSystem(`Invalid approval choice. Enter 1-${request.options.length}.`);
+                            return;
+                        }
+                        if (option.kind === "feedback") {
+                            const prompt = option.prompt || "Why should this be denied?";
+                            pushSystem(`${prompt}\nType your reason and press Enter; Esc cancels.`);
+                            plainApprovalRef.current = {
+                                request,
+                                submit: (feedbackText) => {
+                                    const feedback = feedbackText.trim();
+                                    if (!feedback) {
+                                        pushSystem("Feedback cannot be empty. Type a reason, or Esc to cancel.");
+                                        return;
+                                    }
+                                    finish({ kind: "feedback", text: feedback });
+                                },
+                                cancel: () => finish({ kind: "deny", reason: "cancelled during feedback" }),
+                            };
+                            return;
+                        }
+                        finish(decisionForOption(option));
+                    },
+                    cancel: () => finish({ kind: "deny", reason: "cancelled" }),
+                };
+                timer = setTimeout(() => {
+                    pushSystem("Approval timed out; applying the most conservative option.");
+                    finish(defaultDecision());
+                }, Math.max(1000, request.timeoutMs ?? 60_000));
+                timer.unref?.();
+            });
+        }
+        return await new Promise((resolve) => {
+            let settled = false;
+            let timer;
+            const onAbort = () => finish({ kind: "deny", reason: "run cancelled" });
+            const finish = (decision: ApprovalDecision) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                approvalSignal?.removeEventListener("abort", onAbort);
+                if (approvalFeedbackRef.current) {
+                    approvalFeedbackRef.current = null;
+                    setApprovalFeedbackPrompt(null);
+                }
+                setPicker(null);
+                resolve(decision);
+            };
+            approvalSignal?.addEventListener("abort", onAbort, { once: true });
+            const items = request.options.map((option, index) => ({
+                value: option.id ?? String(index),
+                label: option.label,
+            }));
+            const defaultIndex = Math.max(0, Math.min(request.defaultIndex ?? 0, items.length - 1));
+            setPickerIndex(defaultIndex);
+            setPicker({
+                title: `Approval · Tier ${request.tier ?? 2}`,
+                items,
+                current: items[defaultIndex]?.value,
+                onSelect: (value) => {
+                    const index = items.findIndex((item) => item.value === value);
+                    const option = request.options[index];
+                    if (!option) {
+                        finish({ kind: "deny", reason: "unknown approval option" });
+                        return;
+                    }
+                    if (option.kind === "feedback") {
+                        const prompt = option.prompt || "Why should this be denied?";
+                        setPicker(null);
+                        setInput("");
+                        setApprovalFeedbackPrompt(prompt);
+                        pushSystem(`${prompt}\nType your reason and press Enter; Esc cancels.`);
+                        approvalFeedbackRef.current = {
+                            submit: (text) => {
+                                const feedback = text.trim();
+                                if (!feedback) {
+                                    pushSystem("Feedback cannot be empty. Type a reason, or Esc to cancel.");
+                                    return;
+                                }
+                                finish({ kind: "feedback", text: feedback });
+                            },
+                            cancel: () => finish({ kind: "deny", reason: "cancelled during feedback" }),
+                        };
+                        return;
+                    }
+                    finish(decisionForOption(option));
+                },
+                onCancel: () => finish({ kind: "deny", reason: "cancelled" }),
+            });
+            timer = setTimeout(() => {
+                pushSystem("Approval timed out; applying the most conservative option.");
+                finish(defaultDecision());
+            }, Math.max(1000, request.timeoutMs ?? 60_000));
+            timer.unref?.();
+        });
+    }, [pushSystem, ui]);
+
     const actions = useMemo(() => ({
         setProvider: (id) => setConfig((c) => ({ ...c, providerId: id })),
         setModel: (id) => setConfig((c) => ({ ...c, model: id })),
+        setReasoningEffort: (effort) => setConfig((c) => ({ ...c, reasoningEffort: effort })),
         setTheme: (id) => setConfig((c) => ({ ...c, theme: id })),
         setAgentMode: (enabled) => setConfig((c) => ({ ...c, agentMode: enabled })),
         setSystemPrompt: (p) => setConfig((c) => ({ ...c, systemPrompt: p })),
         setSkillsRegistry: (url) => setConfig((c) => ({ ...c, skillsRegistry: url })),
+        setShellPoolSize: (size) => {
+            const applied = applyShellPoolSize(size);
+            setConfig((c) => ({ ...c, shellPoolSize: applied }));
+        },
         enableSkill: (name) => setConfig((c) => ({
             ...c,
             enabledSkills: Array.from(new Set([...(c.enabledSkills ?? []), name])),
@@ -185,15 +698,29 @@ export const App = ({ initialPrompt, resume }) => {
             setHistory([]);
             setTranscript([]);
         },
-        pushSystemMessage: pushSystem,
-        startLogin: ({ provider, model }) => {
-            setPendingLogin({
-                step: provider ? (model ? "key" : "model") : "provider",
-                provider,
-                model,
-            });
+        replaceHistory: (messages) => setHistory(messages),
+        cancelRun: () => {
+            if (abortRef.current) {
+                abortRef.current.abort();
+                abortRef.current = null;
+            }
         },
-    }), [pushSystem]);
+        steer: (text) => {
+            steerQueueRef.current.push(text);
+        },
+        setExpanded: (value) => setExpanded(value),
+        setInput: (value) => setInput(value),
+        pushSystemMessage: pushSystem,
+        startLogin: (options) => startModelSetup(options),
+    }), [pushSystem, startModelSetup]);
+    const appendCompactionFact = useCallback((info: CommandCompaction) => {
+        const file = sessionRef.current?.file;
+        sessionRef.current.append({ type: "compacted", ...info });
+        if (typeof file === "string") {
+            for (const ref of staleSummaryRefs(file))
+                removeSummaryFile(ref);
+        }
+    }, []);
     const runSlash = useCallback(async (raw) => {
         const parsed = parseSlash(raw);
         if (!parsed)
@@ -203,10 +730,24 @@ export const App = ({ initialPrompt, resume }) => {
             pushSystem(`Unknown command "/${parsed.name}". Try /help.`);
             return true;
         }
+        if (cmd.name === "exit" && busy) {
+            const now = Date.now();
+            if (now - exitConfirmRef.current > 5000) {
+                exitConfirmRef.current = now;
+                pushSystem("A run is active. /exit will stop it, keep the partial output, and save the session. " +
+                    "Type /exit again within 5s to confirm, or /cancel to stop first.");
+                return true;
+            }
+            exitConfirmRef.current = 0;
+        }
+        if (busy && !["cancel", "steer", "jobs", "kill", "attach", "expand", "context", "threads", "exit"].includes(cmd.name)) {
+            pushSystem(`/${cmd.name} is unavailable while a run is active. Try /cancel or /steer.`);
+            return true;
+        }
         // Echo the slash invocation for transcript clarity, but never echo a
         // secret: the login key is masked, while provider/model stay readable.
         const echo = parsed.name === "login" ? maskLoginEcho(parsed.args) : raw;
-        pushUser(echo);
+        pushUser(echo, false);
         try {
             const res = await cmd.run({
                 args: parsed.args,
@@ -224,20 +765,37 @@ export const App = ({ initialPrompt, resume }) => {
                     enabledSkills: config.enabledSkills,
                     enabledPlugins: config.enabledPlugins,
                     skillsRegistry: config.skillsRegistry,
+                    reasoningEffort: config.reasoningEffort,
+                    expanded,
+                    busy,
+                    draft: input,
                 },
                 actions,
             });
             if (res?.message)
                 pushSystem(res.message);
+            if (res?.picker) {
+                const index = Math.max(0, res.picker.items.findIndex((item) => item.value === res.picker.current));
+                setPickerIndex(index);
+                setPicker(res.picker);
+                setInput("");
+            }
+            if (res?.compacted)
+                appendCompactionFact(res.compacted);
+            if (res?.cleared)
+                sessionRef.current.append({ type: "cleared" });
             if (res?.quit)
-                exit();
+                void quitCleanly();
         }
         catch (err) {
-            pushSystem(`Command failed: ${err.message}`);
+            pushSystem(parsed.name === "login"
+                ? "Login failed. The credential was not included in this error message."
+                : `Command failed: ${err.message}`);
         }
         return true;
     }, [
         actions,
+        appendCompactionFact,
         config.agentMode,
         config.enabledPlugins,
         config.enabledSkills,
@@ -246,7 +804,9 @@ export const App = ({ initialPrompt, resume }) => {
         config.skillsRegistry,
         config.systemPrompt,
         config.theme,
-        exit,
+        busy,
+        expanded,
+        quitCleanly,
         history,
         pushSystem,
         pushUser,
@@ -256,8 +816,26 @@ export const App = ({ initialPrompt, resume }) => {
     ]);
     const handleSubmit = useCallback(async (raw) => {
         const text = raw.trim();
-        if (!text || busy)
+        if (!text)
+            return;
+        if (approvalFeedbackRef.current) {
+            approvalFeedbackRef.current.submit(text);
+            setInput("");
             return;
+        }
+        if (plainApprovalRef.current) {
+            plainApprovalRef.current.submit(text);
+            setInput("");
+            return;
+        }
+        if (busy) {
+            if (text.startsWith("/")) {
+                await runSlash(text);
+                return;
+            }
+            pushSystem("A run is active. Use /cancel to stop, /steer <text> to guide it, or wait.");
+            return;
+        }
         setInput("");
         if (text.startsWith("/")) {
             await runSlash(text);
@@ -274,114 +852,222 @@ export const App = ({ initialPrompt, resume }) => {
                 return;
             }
             if (lookup.status === "missing") {
-                pushSystem(`Cannot send: no API key for ${provider.label} · ${config.model}.\n` +
-                    `Run \`/login ${provider.id} ${config.model} <key>\` for this model, or set ${provider.authEnv[0]} (provider-wide).`);
+                pushSystem(`Cannot send: no API key for ${provider.label}.\n` +
+                    `Run \`/login ${provider.id} ${config.model} <key>\` (one key covers every ${provider.id} model), or set ${provider.authEnv[0]}.`);
                 return;
             }
             apiKey = lookup.key;
         }
-        const nextHistory = [...history, { role: "user", content: text }];
-        setHistory(nextHistory);
         idRef.current += 1;
         const bubbleId = idRef.current;
         setStreamingId(bubbleId);
         setStreamingText("");
+        setStreamPhase("thinking");
+        steerQueueRef.current = [];
+        lastStreamFlushRef.current = 0;
         const ctrl = new AbortController();
         abortRef.current = ctrl;
+        busyRef.current = true;
         setBusy(true);
+        let receivedDone = false;
         try {
-            let workingHistory = nextHistory;
-            let finalText = "";
-            for (let turn = 0; turn < (config.agentMode ? 8 : 1); turn += 1) {
-                const skillsBlock = buildSkillsPrompt(config.enabledSkills);
-                const pluginsBlock = buildPluginsPrompt(config.enabledPlugins);
-                const agentBlock = config.agentMode ? AGENT_SYSTEM_PROMPT : "";
-                const fullSystem = [config.systemPrompt, skillsBlock, pluginsBlock, agentBlock]
-                    .filter((part) => part.trim())
-                    .join("\n\n");
-                let acc = "";
-                for await (const chunk of provider.stream({
-                    model: config.model,
-                    messages: workingHistory,
-                    system: fullSystem,
-                    signal: ctrl.signal,
-                }, apiKey)) {
-                    if (chunk.delta) {
-                        acc += chunk.delta;
-                        if (liveStreamingUi)
-                            setStreamingText(stripToolCalls(acc));
+            const maxTurns = config.agentMode ? positiveInt(config.maxAgentTurns, 24) : 1;
+            const skillsBlock = buildSkillsPrompt(config.enabledSkills);
+            const pluginsBlock = buildPluginsPrompt(config.enabledPlugins);
+            const agentBlock = config.agentMode ? AGENT_SYSTEM_PROMPT : "";
+            const fullSystem = [config.systemPrompt, skillsBlock, pluginsBlock, agentBlock]
+                .filter((part) => part.trim())
+                .join("\n\n");
+            let compactionNotified = false;
+            let lastRawFact = "";
+            sawDeltaRef.current = false;
+            const protocol = config.agentMode ? resolveToolProtocol(config, config.providerId, config.model) : "legacy";
+            for await (const ev of runAgent({
+                provider,
+                apiKey,
+                model: config.model,
+                messages: history,
+                prompt: text,
+                system: fullSystem,
+                maxTurns,
+                allowTools: config.agentMode,
+                tokenBudget: optionalBudget("FASTCODE_TOKEN_BUDGET"),
+                costBudgetUsd: optionalBudget("FASTCODE_COST_BUDGET_USD"),
+                signal: ctrl.signal,
+                cwd: process.cwd(),
+                idleTimeoutMs: config.requestIdleTimeoutMs,
+                compaction: compactionConfigFromEnv(),
+                reasoningEffort: config.reasoningEffort,
+                protocol,
+                tools: protocol === "native" ? toolSchemas() : undefined,
+                onProtocolFallback: (message) => {
+                    setConfig((current) => withToolCapability(current, config.providerId, config.model, "pseudo"));
+                    pushSystem(message);
+                },
+                onNativeOk: () => {
+                    if (protocol === "native")
+                        setConfig((current) => withToolCapability(current, config.providerId, config.model, "native"));
+                },
+                takeSteering: () => {
+                    const queued = steerQueueRef.current;
+                    steerQueueRef.current = [];
+                    return queued;
+                },
+                requestApproval,
+                onDelta: (delta, full) => {
+                    if (!sawDeltaRef.current) {
+                        sawDeltaRef.current = true;
+                        setStreamPhase("streaming");
                     }
-                    if (chunk.done) {
-                        if (chunk.usage?.inputTokens)
-                            setTotalIn((n) => n + (chunk.usage.inputTokens ?? 0));
-                        if (chunk.usage?.outputTokens)
-                            setTotalOut((n) => n + (chunk.usage.outputTokens ?? 0));
-                        if (chunk.usage?.costUsd)
-                            setTotalCost((n) => n + (chunk.usage.costUsd ?? 0));
+                    if (!liveStreamingUi)
+                        return;
+                    const now = Date.now();
+                    if (now - lastStreamFlushRef.current < 60)
+                        return;
+                    lastStreamFlushRef.current = now;
+                    setStreamingText(stripToolCalls(full));
+                },
+            })) {
+                switch (ev.type) {
+                    case "compaction":
+                        appendCompactionFact({
+                            summaryRef: ev.summaryFile,
+                            source: ev.source,
+                            beforeTokens: ev.beforeTokens,
+                            afterTokens: ev.afterTokens,
+                            droppedMessages: ev.droppedMessages,
+                            keepMessages: ev.keptMessages,
+                            reason: ev.reason === "heap" ? "heap" : "threshold",
+                        });
+                        if (!compactionNotified) {
+                            compactionNotified = true;
+                            pushSystem(`[context compacted] ${ev.beforeTokens} → ${ev.afterTokens} tokens (${ev.reason}); recent turns kept.` +
+                                (ev.summaryFile ? `\nSummary: ${ev.summaryFile}` : ""));
+                        }
+                        break;
+                    case "assistant_raw":
+                        lastRawFact = ev.text;
+                        sessionRef.current.append({ type: "assistant_raw", content: ev.text, toolCalls: ev.toolCalls });
+                        break;
+                    case "assistant_text":
+                        pushSystem(ev.text);
+                        break;
+                    case "tool_call":
+                        sessionRef.current.append({ type: "tool_call", id: ev.id, tool: ev.call.tool, args: ev.call, native: Boolean(ev.native) });
+                        setStreamPhase("tool");
+                        setAgentActivity(`Coding: ${ev.call.tool}`);
+                        pushSystem(`Running tool: \`${ev.call.tool}\`\n\n\`\`\`json\n${JSON.stringify(ev.call, null, 2)}\n\`\`\``);
+                        break;
+                    case "tool_result": {
+                        sessionRef.current.append({
+                            type: "tool_result",
+                            id: ev.id,
+                            tool: ev.call.tool,
+                            ok: ev.ok,
+                            output: ev.output,
+                            sideEffects: ev.sideEffects,
+                            ...(ev.code ? { code: ev.code } : {}),
+                            ...(ev.hint ? { hint: ev.hint } : {}),
+                            ...(ev.truncated !== undefined ? { truncated: ev.truncated } : {}),
+                            ...(ev.totalLines !== undefined ? { totalLines: ev.totalLines } : {}),
+                            ...(ev.returnedLines !== undefined ? { returnedLines: ev.returnedLines } : {}),
+                            ...(ev.totalBytes !== undefined ? { totalBytes: ev.totalBytes } : {}),
+                            ...(ev.returnedBytes !== undefined ? { returnedBytes: ev.returnedBytes } : {}),
+                            ...(ev.filesRead !== undefined ? { filesRead: ev.filesRead } : {}),
+                            ...(ev.filesSkipped !== undefined ? { filesSkipped: ev.filesSkipped } : {}),
+                            ...(ev.matches !== undefined ? { matches: ev.matches } : {}),
+                        });
+                        const collapsed = stableUi && !expanded;
+                        const body = collapsed ? collapseToolOutput(ev.output) : ev.output;
+                        const hint = collapsed ? "\n\n_(output collapsed; /expand to show full output)_" : "";
+                        pushSystem(`Tool ${ev.ok ? "completed" : "failed"}: \`${ev.call.tool}\`\n\n\`\`\`\n${body}\n\`\`\`${hint}`);
+                        break;
                     }
+                    case "usage":
+                        if (ev.usage.inputTokens)
+                            setTotalIn((n) => n + (ev.usage.inputTokens ?? 0));
+                        if (ev.usage.outputTokens)
+                            setTotalOut((n) => n + (ev.usage.outputTokens ?? 0));
+                        if (ev.usage.costUsd)
+                            setTotalCost((n) => n + (ev.usage.costUsd ?? 0));
+                        break;
+                    case "loop_detected":
+                        pushSystem(`Loop detected: \`${ev.fingerprint.split(":")[0]}\` repeated ${ev.occurrences} times. Asking the model to change approach.`);
+                        break;
+                    case "egress_denied": {
+                        idRef.current += 1;
+                        sessionRef.current.append({
+                            type: "egress_denied",
+                            outlet: ev.outlet,
+                            target: ev.target,
+                            rule: ev.rule,
+                            mode: ev.mode,
+                            wouldBlock: ev.wouldBlock,
+                            code: ev.code,
+                            reason: ev.reason,
+                        });
+                        const target = ev.target ? ` target=${JSON.stringify(ev.target)}` : "";
+                        setTranscript((prev) => [
+                            ...prev,
+                            { id: idRef.current, role: "system", content: `[egress] ${ev.mode} rule=${ev.rule}${target} would_block=${ev.wouldBlock}\n${ev.reason}`, markdown: true },
+                        ]);
+                        break;
+                    }
+                    case "notice":
+                        pushSystem(ev.text);
+                        break;
+                    case "checkpoint":
+                        sessionRef.current.append({
+                            type: "checkpoint",
+                            turn: ev.turn,
+                            cwd: ev.cwd,
+                            providerId: ev.providerId,
+                            model: ev.model,
+                            activeFiles: ev.activeFiles,
+                            lastFactSeq: sessionRef.current.count(),
+                        });
+                        break;
+                    case "error":
+                        if (ev.kind === "aborted")
+                            pushSystem("Cancelled current run; partial output kept. Type 继续 to continue.");
+                        else if (ev.kind === "stream_error")
+                            pushSystem(streamErrorMessage(ev.message, provider, config.model));
+                        else
+                            pushSystem(ev.message);
+                        break;
+                    case "done":
+                        receivedDone = true;
+                        setHistory(ev.history);
+                        if (ev.finalText) {
+                            idRef.current += 1;
+                            const finalId = idRef.current;
+                            if (ev.finalText !== lastRawFact)
+                                sessionRef.current.append({ type: "assistant_raw", content: ev.finalText });
+                            setTranscript((prev) => [
+                                ...prev,
+                                { id: finalId, role: "assistant", content: ev.finalText, markdown: true },
+                            ]);
+                        }
+                        break;
                 }
-                const visibleText = stripToolCalls(acc);
-                const calls = config.agentMode ? parseToolCalls(acc) : [];
-                if (calls.length === 0) {
-                    finalText = visibleText || acc;
-                    break;
-                }
-                if (visibleText)
-                    pushSystem(visibleText);
-                const results: any[] = [];
-                for (const call of calls) {
-                    setAgentActivity(`Coding: ${call.tool}`);
-                    pushSystem(`Running tool: \`${call.tool}\`\n\n\`\`\`json\n${JSON.stringify(call, null, 2)}\n\`\`\``);
-                    const result: any = await runAgentTool(call, process.cwd());
-                    results.push({ call, ...result });
-                    pushSystem(`Tool ${result.ok ? "completed" : "failed"}: \`${call.tool}\`\n\n\`\`\`\n${result.output}\n\`\`\``);
-                }
-                const toolMessage = formatToolResults(results);
-                workingHistory = [
-                    ...workingHistory,
-                    { role: "assistant", content: acc },
-                    { role: "user", content: toolMessage },
-                ];
-                setHistory(workingHistory);
-                setStreamingText("");
-                setAgentActivity(null);
-            }
-            if (!finalText) {
-                finalText = "Stopped after running the maximum number of agent tool turns.";
             }
-            setHistory([...workingHistory, { role: "assistant", content: finalText }]);
-            idRef.current = Math.max(idRef.current, bubbleId);
-            sessionRef.current.append({ type: "message", role: "assistant", content: finalText });
-            setTranscript((prev) => [
-                ...prev,
-                { id: bubbleId, role: "assistant", content: finalText, markdown: true },
-            ]);
         }
         catch (err) {
-            const message = String(err?.message ?? err);
-            if (err?.name === "AbortError") {
-                pushSystem("Cancelled.");
-            }
-            else if (/\b(401|403)\b/.test(message) || /invalid api key|unauthorized|authentication/i.test(message)) {
-                pushSystem(`Authentication failed for ${provider.label} · ${config.model}. The key may be wrong or not allowed for this model.\n` +
-                    `Check with \`/whoami\`, or re-save: \`/login ${provider.id} ${config.model} <key>\`.`);
-            }
-            else if (/\b(402|429)\b/.test(message) || /quota|insufficient|rate limit|billing|balance/i.test(message)) {
-                pushSystem(`Request blocked: ${provider.label} reports no remaining quota / rate limit for ${config.model}.\n` +
-                    `Top up the account or switch model/provider. (${message.slice(0, 200)})`);
-            }
-            else {
-                pushSystem(`Error: ${message}`);
-            }
+            if (!receivedDone)
+                setHistory([...history, { role: "user", content: text }]);
+            pushSystem(`Error: ${String(err?.message ?? err)}`);
         }
         finally {
             setStreamingId(null);
             setStreamingText("");
             setAgentActivity(null);
+            setStreamPhase("thinking");
+            busyRef.current = false;
             setBusy(false);
             abortRef.current = null;
         }
     }, [
+        appendCompactionFact,
         busy,
         config.agentMode,
         config.enabledSkills,
@@ -392,6 +1078,7 @@ export const App = ({ initialPrompt, resume }) => {
         history,
         pushSystem,
         pushUser,
+        requestApproval,
         runSlash,
     ]);
     // Guided `/login`: provider → model → key. Text prompts only; the key step
@@ -399,55 +1086,50 @@ export const App = ({ initialPrompt, resume }) => {
     const handleWizardSubmit = useCallback(async (raw) => {
         const value = raw.trim();
         setInput("");
-        if (!value || !pendingLogin)
+        if (!pendingLogin)
             return;
-        if (pendingLogin.step === "provider") {
-            const provider = getProvider(value);
-            if (!provider) {
-                pushSystem(`Unknown provider "${value}". Available: ${PROVIDERS.map((p) => p.id).join(", ")}`);
-                return;
-            }
-            if (provider.authEnv.length === 0) {
-                pushSystem(`${provider.label} doesn't require an API key. Nothing to save.`);
-                setPendingLogin(null);
+        if (pendingLogin.step === "model-manual") {
+            if (!isValidModelId(value)) {
+                pushSystem("Invalid model ID. Use 1-200 letters, numbers, or . _ : / + -; configuration was not changed.");
                 return;
             }
-            setPendingLogin({ step: "model", provider: provider.id });
-            const models = await provider.listModels(undefined).catch(() => []);
-            const names = models.slice(0, 8).map((m) => m.id).join(", ");
-            pushSystem(`Provider: ${provider.label} (${provider.id}).\n` +
-                `Type the model id to bind this key to — e.g. \`${provider.defaultModel}\`.` +
-                (names ? `\n  known models: ${names}` : ""));
+            continueModelSetup(pendingLogin, pendingLogin.provider, value);
             return;
         }
-        if (pendingLogin.step === "model") {
-            const provider = getProvider(pendingLogin.provider);
-            if (!provider) {
-                setPendingLogin(null);
-                return;
-            }
-            setPendingLogin({ step: "key", provider: provider.id, model: value });
-            pushSystem(`Scope: ${provider.id} · ${value}.\nPaste the API key for this model (input is masked).` +
-                (getLegacy(provider.id) ? `\nOr type \`keep\` to re-bind the stored ${provider.label} key.` : ""));
+        if (pendingLogin.step !== "key")
             return;
-        }
         const provider = getProvider(pendingLogin.provider);
         if (!provider) {
             setPendingLogin(null);
+            pushSystem("Provider is no longer available. Configuration was not changed.");
+            return;
+        }
+        if (!value) {
+            if (pendingLogin.hasExistingKey) {
+                finishModelSetup(pendingLogin, provider.id, pendingLogin.model);
+            }
+            else {
+                pushSystem("An API key is required for this provider. Configuration was not changed.");
+            }
             return;
         }
         let key = value;
         if (value.toLowerCase() === "keep") {
             const legacy = getLegacy(provider.id);
             if (!legacy) {
-                pushSystem(`No stored ${provider.label} key to reuse — paste the key instead.`);
+                pushSystem(`No stored ${provider.label} key to reuse. Paste the API key; configuration was not changed.`);
                 return;
             }
             key = legacy;
         }
-        pushSystem(saveScopedKey(provider.id, provider.label, pendingLogin.model, key));
-        setPendingLogin(null);
-    }, [pendingLogin, pushSystem]);
+        try {
+            const receipt = saveScopedKey(provider.id, provider.label, pendingLogin.model, key);
+            finishModelSetup(pendingLogin, provider.id, pendingLogin.model, receipt);
+        }
+        catch {
+            pushSystem("Could not save the API key. Credential details were omitted; model settings were not changed.");
+        }
+    }, [continueModelSetup, finishModelSetup, pendingLogin, pushSystem]);
     useEffect(() => {
         if (!initialPrompt || initialPromptSubmittedRef.current)
             return;
@@ -456,6 +1138,7 @@ export const App = ({ initialPrompt, resume }) => {
         return () => clearTimeout(t);
     }, [handleSubmit, initialPrompt]);
     useEffect(() => () => {
+        shutdownShells();
         if (sessionRef.current)
             sessionRef.current.close();
     }, []);
@@ -468,9 +1151,9 @@ export const App = ({ initialPrompt, resume }) => {
                 setConfig((c) => ({ ...c, agentMode: false }));
                 pushSystem("Trust declined: agent tools are off for this session (chat only).");
             }
-            setTrusted(true);
+            setTrustEpoch((n) => n + 1);
         };
         return _jsx(TrustGate, { theme: theme, cwd: process.cwd(), onDecision: decide });
     }
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [showBanner ? _jsx(Banner, { theme: theme, stable: stableUi }) : null, _jsx(Static, { items: transcript, children: (entry) => (_jsx(Box, { marginTop: 1, children: _jsx(MessageBubble, { theme: theme, role: entry.role, content: entry.content, markdown: entry.markdown }) }, entry.id)) }), streamingId !== null && liveStreamingUi ? (_jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(MessageBubble, { theme: theme, role: "assistant", content: streamingText, markdown: true, streaming: true }) })) : null, _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [busy ? (_jsx(Box, { marginBottom: 1, children: _jsx(Spinner, { theme: theme, label: agentActivity ?? (streamingId !== null ? "Streaming" : "Thinking"), stable: stableUi && !agentActivity }) })) : null, _jsx(Prompt, { theme: theme, value: input, onChange: setInput, onSubmit: pendingLogin ? handleWizardSubmit : handleSubmit, disabled: busy, stable: stableUi, placeholder: promptPlaceholder, mask: promptMask }), _jsx(StatusBar, { theme: theme, providerId: config.providerId, model: config.model, inputTokens: totalIn, outputTokens: totalOut, costUsd: totalCost, enabledSkillCount: config.enabledSkills.length + config.enabledPlugins.length }), _jsxs(Text, { color: theme.muted, children: [COMMANDS.length, " commands \u00B7 ", config.enabledSkills.length, " skill(s) active"] })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [showBanner ? _jsx(Banner, { theme: theme, stable: stableUi }) : null, _jsx(Static, { items: transcript, children: (entry) => (_jsx(Box, { marginTop: 1, children: _jsx(MessageBubble, { theme: theme, role: entry.role, content: entry.content, markdown: entry.markdown }) }, entry.id)) }), streamingId !== null && liveStreamingUi ? (_jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(MessageBubble, { theme: theme, role: "assistant", content: streamingTail(streamingText, 6), markdown: false, streaming: true }) })) : null, _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [busy ? (_jsx(Box, { marginBottom: 1, children: _jsx(Spinner, { theme: theme, label: agentActivity ?? (streamPhase === "streaming" ? "Streaming" : streamPhase === "tool" ? "Waiting for tool" : "Thinking"), stable: stableUi }) })) : null, picker ? _jsx(Picker, { theme: theme, title: picker.title, items: picker.items, index: pickerIndex, current: picker.current }) : _jsx(Prompt, { theme: theme, value: input, onChange: setInput, onSubmit: pendingLogin ? handleWizardSubmit : handleSubmit, disabled: false, placeholder: promptPlaceholder, mask: promptMask }), _jsx(StatusBar, { theme: theme, providerId: config.providerId, model: config.model, inputTokens: totalIn, outputTokens: totalOut, costUsd: totalCost, enabledSkillCount: config.enabledSkills.length + config.enabledPlugins.length, reasoningEffort: config.reasoningEffort }), _jsxs(Text, { color: theme.muted, children: [COMMANDS.length, " commands \u00B7 ", config.enabledSkills.length, " skill(s) active"] })] })] }));
 };