fecode-cli 1.0.0

package/dist/App.js

@@ -0,0 +1,2224 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback, useEffect, useRef } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { DefaultSessionStore, SessionHistoryFormatter, DefaultGitRepository, GitStatusFormatter, DefaultCheckpointManager, CheckpointFormatter, DefaultRecoveryManager, RecoveryFormatter, DefaultTaskRiskPolicy, formatRunDiagnostics, RunHistoryFormatter, PlanFormatter, transitionPlanStatus, DefaultProductRuntime, createInitialUIState, reduceUIState } from "@fecode/agent";
+import { filterCommands } from "./commands.js";
+import { AppShell, Header, StatusBar, TaskInput, ThinkingIndicator, TurnView, PlanView, CurrentStepView, WorkspaceStatus, ApprovalPrompt, BlockedView, RecoveryView, ReplanView, ResumeView, DiagnosticsView, RunHistoryView, HelpView } from "./ui/index.js";
+export const App = ({ agent, productRuntime: runtimeProp, cwd = process.cwd(), providerName, modelName, approvalResolver, onExit, configError, projectContext: _projectContext, sessionStore, initialSessionData, gitRepository: gitRepoProp, checkpointManager: checkpointManagerProp, recoveryManager: recoveryManagerProp, executionPolicy: executionPolicyProp }) => {
+    const gitRepo = gitRepoProp || new DefaultGitRepository();
+    const cpManager = checkpointManagerProp ||
+        (agent && "getCheckpointManager" in agent && typeof agent.getCheckpointManager === "function"
+            ? agent.getCheckpointManager()
+            : new DefaultCheckpointManager(undefined, gitRepo));
+    const recManager = recoveryManagerProp ||
+        (agent && "getRecoveryManager" in agent && typeof agent.getRecoveryManager === "function"
+            ? agent.getRecoveryManager()
+            : new DefaultRecoveryManager(undefined, gitRepo));
+    const _execPolicy = executionPolicyProp ||
+        (agent && "getExecutionPolicy" in agent && typeof agent.getExecutionPolicy === "function"
+            ? agent.getExecutionPolicy()
+            : new DefaultTaskRiskPolicy());
+    void _execPolicy;
+    void _projectContext;
+    // Instantiate or use ProductRuntime
+    const [runtime] = useState(() => {
+        if (runtimeProp)
+            return runtimeProp;
+        if (agent && "run" in agent && "assessTaskRisk" in agent) {
+            return new DefaultProductRuntime({
+                agentRuntime: agent,
+                gitRepository: gitRepo,
+                approvalResolver,
+                initialCwd: cwd,
+                initialSessionId: initialSessionData?.sessionId
+            });
+        }
+        return undefined;
+    });
+    const { exit } = useApp();
+    const [query, setQuery] = useState("");
+    const [activeView, setActiveView] = useState("main");
+    const [store] = useState(() => sessionStore || new DefaultSessionStore());
+    const [sessionId] = useState(() => initialSessionData?.sessionId ||
+        `session-${Date.now()}-${Math.random().toString(36).substring(2, 7)}`);
+    const [taskCount, setTaskCount] = useState(() => initialSessionData?.taskCount || 0);
+    const [completedSummaries, setCompletedSummaries] = useState(() => initialSessionData?.completedTaskSummaries || []);
+    const completedSummariesRef = useRef(initialSessionData?.completedTaskSummaries || []);
+    useEffect(() => {
+        completedSummariesRef.current = completedSummaries;
+    }, [completedSummaries]);
+    const [lastTaskStatus, setLastTaskStatus] = useState(() => initialSessionData?.status || "idle");
+    const [activeRequest, setActiveRequest] = useState(undefined);
+    const startedAtRef = useRef(initialSessionData?.startedAt
+        ? new Date(initialSessionData.startedAt)
+        : new Date());
+    const [turns, setTurns] = useState(() => {
+        if (initialSessionData) {
+            return [
+                {
+                    id: `init-${Date.now()}`,
+                    prompt: `--resume ${initialSessionData.sessionId}`,
+                    response: SessionHistoryFormatter.formatResumeSummary(initialSessionData),
+                    status: "done"
+                }
+            ];
+        }
+        return [];
+    });
+    const [isGenerating, setIsGenerating] = useState(false);
+    const [pendingQuery, setPendingQuery] = useState(null);
+    const [selectedSuggestion, setSelectedSuggestion] = useState(0);
+    const prevIsGeneratingRef = useRef(false);
+    const [pendingApproval, setPendingApproval] = useState(null);
+    const [approvalInput, setApprovalInput] = useState("");
+    const [blockedInput, setBlockedInput] = useState("");
+    const [recoveryInput, setRecoveryInput] = useState("");
+    const [replanInput, setReplanInput] = useState("");
+    const [resumeInput, setResumeInput] = useState("");
+    const [pendingResume, setPendingResume] = useState(null);
+    const [pendingReplan, setPendingReplan] = useState(null);
+    const [pendingPlanBlocked, setPendingPlanBlocked] = useState(null);
+    const [pendingRecovery, setPendingRecovery] = useState(null);
+    const [pendingRecoveryContinuation, setPendingRecoveryContinuation] = useState(null);
+    const hasModal = Boolean(pendingApproval) ||
+        Boolean(pendingPlanBlocked) ||
+        Boolean(pendingRecovery) ||
+        Boolean(pendingRecoveryContinuation) ||
+        Boolean(pendingReplan) ||
+        Boolean(pendingResume);
+    const commandSuggestions = !isGenerating && !hasModal && query.startsWith("/")
+        ? filterCommands(query)
+        : [];
+    const handleQueryChange = (val) => {
+        if (!hasModal && !isGenerating && activeView === "main" && query === "" && val === "?") {
+            setActiveView("help");
+            setQuery("");
+            setSelectedSuggestion(0);
+            return;
+        }
+        if (!hasModal && !isGenerating && activeView !== "main" && !val.startsWith("/") && val.length === 1) {
+            const char = val.toLowerCase();
+            if (char === "p") {
+                setActiveView(activeView === "plan" ? "main" : "plan");
+                setQuery("");
+                setSelectedSuggestion(0);
+                return;
+            }
+            if (char === "r") {
+                setActiveView(activeView === "runs" ? "main" : "runs");
+                setQuery("");
+                setSelectedSuggestion(0);
+                return;
+            }
+            if (char === "d") {
+                setActiveView(activeView === "diagnostics" ? "main" : "diagnostics");
+                setQuery("");
+                setSelectedSuggestion(0);
+                return;
+            }
+            if (char === "?" || char === "h") {
+                setActiveView(activeView === "help" ? "main" : "help");
+                setQuery("");
+                setSelectedSuggestion(0);
+                return;
+            }
+        }
+        setQuery(val);
+        setSelectedSuggestion(0);
+    };
+    // Subscribe to ProductRuntime event stream
+    const [uiState, setUiState] = useState(() => runtime?.getUIState?.());
+    useEffect(() => {
+        if (!runtime || !runtime.subscribe)
+            return;
+        const unsubscribe = runtime.subscribe((state) => {
+            setUiState(state);
+        });
+        return () => {
+            unsubscribe();
+        };
+    }, [runtime]);
+    // Hook into ApprovalResolver if present
+    useEffect(() => {
+        if (approvalResolver) {
+            approvalResolver.onRequest = (request) => {
+                setPendingApproval((prev) => {
+                    if (prev && prev.id === request.id) {
+                        return {
+                            ...request,
+                            changeReview: request.changeReview || prev.changeReview,
+                            reason: request.reason || prev.reason
+                        };
+                    }
+                    return request;
+                });
+            };
+        }
+    }, [approvalResolver]);
+    // Auto-submit queued prompt when generation completes
+    useEffect(() => {
+        if (prevIsGeneratingRef.current && !isGenerating && pendingQuery) {
+            const queued = pendingQuery;
+            setPendingQuery(null);
+            void handleSubmit(queued);
+        }
+        prevIsGeneratingRef.current = isGenerating;
+    }, [isGenerating, pendingQuery]);
+    const persistState = useCallback(async (status, newSummary, explicitTaskCount) => {
+        try {
+            const summaries = newSummary
+                ? [...completedSummariesRef.current, newSummary]
+                : completedSummariesRef.current;
+            if (newSummary) {
+                completedSummariesRef.current = summaries;
+                setCompletedSummaries(summaries);
+            }
+            const state = agent?.getState?.();
+            const rawMessages = state?.messages || [];
+            // Sanitize messages and summaries to avoid persisting empty records
+            const validSummaries = summaries.filter((s) => s && (s.request || s.status || s.taskId));
+            const validMessages = rawMessages.filter((m) => {
+                if (!m)
+                    return false;
+                if (typeof m.content === "string") {
+                    return (m.content.trim().length > 0 ||
+                        Boolean(m.toolCalls && m.toolCalls.length > 0));
+                }
+                return true;
+            });
+            await store.save({
+                version: 1,
+                sessionId,
+                workingDirectory: cwd,
+                provider: providerName || "unknown",
+                model: modelName || "unknown",
+                startedAt: startedAtRef.current.toISOString(),
+                updatedAt: new Date().toISOString(),
+                taskCount: explicitTaskCount !== undefined ? explicitTaskCount : taskCount,
+                status,
+                completedTaskSummaries: validSummaries,
+                messages: validMessages
+            });
+        }
+        catch {
+            // Silently catch persistence error
+        }
+    }, [
+        store,
+        sessionId,
+        cwd,
+        providerName,
+        modelName,
+        taskCount,
+        agent
+    ]);
+    const handleExit = useCallback(async () => {
+        try {
+            await persistState(lastTaskStatus);
+        }
+        catch {
+            // ignore
+        }
+        if (onExit) {
+            onExit();
+        }
+        else {
+            exit();
+        }
+    }, [onExit, exit, persistState, lastTaskStatus]);
+    // Keyboard navigation & shortcuts
+    useInput((input, key) => {
+        // Tab: select top autocomplete suggestion
+        if (key.tab && commandSuggestions.length > 0) {
+            const clamped = Math.max(0, Math.min(selectedSuggestion, commandSuggestions.length - 1));
+            const selected = commandSuggestions[clamped];
+            if (selected) {
+                setQuery(selected.command + " ");
+                setSelectedSuggestion(0);
+            }
+            return;
+        }
+        // ArrowDown / ArrowUp: cycle suggestions
+        if (key.downArrow && commandSuggestions.length > 0) {
+            setSelectedSuggestion((prev) => (prev + 1) % commandSuggestions.length);
+            return;
+        }
+        if (key.upArrow && commandSuggestions.length > 0) {
+            setSelectedSuggestion((prev) => prev <= 0 ? commandSuggestions.length - 1 : prev - 1);
+            return;
+        }
+        const cancelActiveModal = () => {
+            if (pendingApproval) {
+                if (approvalResolver) {
+                    approvalResolver.cancelPending("Approval request cancelled via Ctrl+C");
+                }
+                setPendingApproval(null);
+                setApprovalInput("");
+                return true;
+            }
+            if (pendingPlanBlocked) {
+                const pb = pendingPlanBlocked;
+                setPendingPlanBlocked(null);
+                setBlockedInput("");
+                try {
+                    if (agent && "resolveExecutionDecision" in agent) {
+                        void agent
+                            .resolveExecutionDecision(pb.plan.planId, "cancel", { cwd })
+                            .catch(() => { });
+                    }
+                    if (agent && "cancel" in agent) {
+                        void agent.cancel().catch(() => { });
+                    }
+                }
+                catch {
+                    // ignore
+                }
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: "",
+                        response: `${PlanFormatter.formatCancelNotice()}\n`,
+                        status: "done"
+                    }
+                ]);
+                return true;
+            }
+            if (pendingRecovery) {
+                setPendingRecovery(null);
+                setRecoveryInput("");
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: "",
+                        response: "✓ Recovery cancelled\n",
+                        status: "done"
+                    }
+                ]);
+                return true;
+            }
+            if (pendingRecoveryContinuation) {
+                setPendingRecoveryContinuation(null);
+                setRecoveryInput("");
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: "",
+                        response: "Continuation cancelled.\n",
+                        status: "done"
+                    }
+                ]);
+                return true;
+            }
+            if (pendingReplan) {
+                setPendingReplan(null);
+                setReplanInput("");
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: "",
+                        response: "Replanning cancelled.\n",
+                        status: "done"
+                    }
+                ]);
+                return true;
+            }
+            if (pendingResume) {
+                setPendingResume(null);
+                setResumeInput("");
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: "",
+                        response: "✗ Resume cancelled by user.\n",
+                        status: "done"
+                    }
+                ]);
+                return true;
+            }
+            return false;
+        };
+        // Ctrl+C cancellation
+        if (key.ctrl && input === "c") {
+            if (pendingQuery) {
+                setPendingQuery(null);
+                return;
+            }
+            if (cancelActiveModal()) {
+                return;
+            }
+            if (isGenerating && agent) {
+                agent.cancel().catch(() => { });
+                setIsGenerating(false);
+                setPendingQuery(null);
+                setLastTaskStatus("cancelled");
+                setActiveRequest(undefined);
+                const cancelledSummary = {
+                    taskIndex: taskCount,
+                    request: activeRequest || "Task",
+                    status: "cancelled",
+                    completedFiles: [],
+                    verifiedCommands: [],
+                    completedRequirements: [],
+                    remainingRequirements: []
+                };
+                setCompletedSummaries((prev) => [...prev, cancelledSummary]);
+                persistState("cancelled", cancelledSummary).catch(() => { });
+                setTurns((prev) => {
+                    if (prev.length === 0)
+                        return prev;
+                    const updated = [...prev];
+                    const lastIndex = updated.length - 1;
+                    updated[lastIndex] = {
+                        ...updated[lastIndex],
+                        status: "cancelled",
+                        error: "Generation cancelled."
+                    };
+                    return updated;
+                });
+            }
+            else {
+                handleExit();
+            }
+            return;
+        }
+        // Non-main view navigation shortcuts: p, r, d, ?, Esc (only when not typing a slash command)
+        if (!hasModal && !isGenerating && activeView !== "main" && !query.startsWith("/")) {
+            if (input === "p" || input === "P") {
+                setActiveView(activeView === "plan" ? "main" : "plan");
+                setQuery("");
+                return;
+            }
+            if (input === "r" || input === "R") {
+                setActiveView(activeView === "runs" ? "main" : "runs");
+                setQuery("");
+                return;
+            }
+            if (input === "d" || input === "D") {
+                setActiveView(activeView === "diagnostics" ? "main" : "diagnostics");
+                setQuery("");
+                return;
+            }
+            if (input === "?" || input === "h" || input === "H") {
+                setActiveView(activeView === "help" ? "main" : "help");
+                setQuery("");
+                return;
+            }
+        }
+        // Quick help shortcut from empty query on main view
+        if (!hasModal && !isGenerating && activeView === "main" && query === "" && input === "?") {
+            setActiveView("help");
+            setQuery("");
+            return;
+        }
+        // Escape returns to main view or cancels active modal
+        if (key.escape) {
+            if (cancelActiveModal()) {
+                return;
+            }
+            setActiveView("main");
+            setQuery("");
+            return;
+        }
+    }, { isActive: true });
+    const handleApprovalSubmit = (value) => {
+        const trimmed = value.trim();
+        setApprovalInput("");
+        setPendingApproval(null);
+        if (approvalResolver) {
+            approvalResolver.submitDecision(trimmed);
+        }
+    };
+    const handleSubmit = async (value) => {
+        let trimmed = value.trim();
+        // Queue the prompt if agent is currently running and no modal is active
+        const modalActive = Boolean(pendingApproval) ||
+            Boolean(pendingPlanBlocked) ||
+            Boolean(pendingRecovery) ||
+            Boolean(pendingRecoveryContinuation) ||
+            Boolean(pendingReplan) ||
+            Boolean(pendingResume);
+        if (!trimmed && !modalActive)
+            return;
+        // Apply safe defaults for modals when user hits Enter with empty input
+        if (!trimmed && modalActive) {
+            if (pendingPlanBlocked) {
+                trimmed = "x";
+            }
+            else {
+                trimmed = "n";
+            }
+        }
+        if (isGenerating && !modalActive) {
+            setPendingQuery(trimmed);
+            setQuery("");
+            return;
+        }
+        if (isGenerating)
+            return;
+        // Handle modal submissions first
+        if (pendingRecoveryContinuation) {
+            setQuery("");
+            setRecoveryInput("");
+            const prc = pendingRecoveryContinuation;
+            setPendingRecoveryContinuation(null);
+            const choice = trimmed.toLowerCase();
+            if (choice === "y" ||
+                choice === "yes" ||
+                choice === "c" ||
+                choice === "continue") {
+                const contTurnId = `turn-${Date.now()}`;
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: contTurnId,
+                        prompt: trimmed,
+                        response: "Starting continuation...\n",
+                        status: "streaming"
+                    }
+                ]);
+                if (agent && "continueRecoveredPlan" in agent) {
+                    try {
+                        for await (const ev of agent.continueRecoveredPlan(prc.preparation, {
+                            runId: prc.plan.runId,
+                            planId: prc.plan.planId,
+                            decision: "continue",
+                            approved: true,
+                            cwd
+                        })) {
+                            if (ev.type === "plan_step_started") {
+                                setTurns((prev) => prev.map((t) => t.id === contTurnId
+                                    ? {
+                                        ...t,
+                                        response: t.response +
+                                            `[${ev.stepIndex + 1}/${prc.plan.steps.length}] ${ev.title || "Step"} ...\n`
+                                    }
+                                    : t));
+                            }
+                            else if (ev.type === "plan_step_completed") {
+                                setTurns((prev) => prev.map((t) => t.id === contTurnId
+                                    ? {
+                                        ...t,
+                                        response: t.response + "✓ COMPLETED\n\n"
+                                    }
+                                    : t));
+                            }
+                            else if (ev.type === "recovery_continuation_completed" ||
+                                ev.type === "plan_execution_completed") {
+                                setTurns((prev) => prev.map((t) => t.id === contTurnId
+                                    ? {
+                                        ...t,
+                                        status: "done",
+                                        response: t.response.includes("✓ Plan completed")
+                                            ? t.response
+                                            : t.response + "✓ Plan completed\n"
+                                    }
+                                    : t));
+                            }
+                            else if (ev.type === "recovery_continuation_blocked") {
+                                setTurns((prev) => prev.map((t) => t.id === contTurnId
+                                    ? {
+                                        ...t,
+                                        status: "done",
+                                        response: t.response +
+                                            `⚠ Continuation blocked: ${ev.blockingReasons.join("; ")}\n`
+                                    }
+                                    : t));
+                            }
+                            else if (ev.type === "recovery_continuation_cancelled") {
+                                setTurns((prev) => prev.map((t) => t.id === contTurnId
+                                    ? {
+                                        ...t,
+                                        status: "done",
+                                        response: t.response + "Continuation cancelled.\n"
+                                    }
+                                    : t));
+                            }
+                        }
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        setTurns((prev) => prev.map((t) => t.id === contTurnId
+                            ? {
+                                ...t,
+                                status: "error",
+                                response: t.response + `✗ Continuation error: ${msg}\n`
+                            }
+                            : t));
+                    }
+                }
+            }
+            else {
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: trimmed,
+                        response: "Continuation cancelled.\n",
+                        status: "done"
+                    }
+                ]);
+            }
+            return;
+        }
+        if (pendingRecovery) {
+            setQuery("");
+            setRecoveryInput("");
+            const pr = pendingRecovery;
+            setPendingRecovery(null);
+            const choice = trimmed.toLowerCase();
+            if (choice === "y" ||
+                choice === "yes" ||
+                choice === "p" ||
+                choice === "proceed") {
+                const recTurnId = `turn-${Date.now()}`;
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: recTurnId,
+                        prompt: trimmed,
+                        response: "Recovery started\n",
+                        status: "streaming"
+                    }
+                ]);
+                try {
+                    if (agent && "executeExecutionRecovery" in agent) {
+                        for await (const ev of agent.executeExecutionRecovery(pr.assessment, { cwd, approved: true })) {
+                            if (ev.type === "recovery_step_started") {
+                                setTurns((prev) => prev.map((t) => t.id === recTurnId
+                                    ? {
+                                        ...t,
+                                        response: t.response +
+                                            `[${ev.stepIndex}/${ev.totalSteps}] ${ev.title} ... `
+                                    }
+                                    : t));
+                            }
+                            else if (ev.type === "recovery_step_completed") {
+                                setTurns((prev) => prev.map((t) => t.id === recTurnId
+                                    ? {
+                                        ...t,
+                                        response: t.response + `${ev.success ? "✓" : "✗"}\n`
+                                    }
+                                    : t));
+                            }
+                            else if (ev.type === "recovery_verification_started") {
+                                setTurns((prev) => prev.map((t) => t.id === recTurnId
+                                    ? {
+                                        ...t,
+                                        response: t.response + `\nVerification\n`
+                                    }
+                                    : t));
+                            }
+                            else if (ev.type === "recovery_verification_completed") {
+                                setTurns((prev) => prev.map((t) => t.id === recTurnId
+                                    ? {
+                                        ...t,
+                                        response: t.response +
+                                            `${ev.success ? "✓" : "✗"} ${ev.command}\n\n`
+                                    }
+                                    : t));
+                            }
+                            else if (ev.type === "recovery_reconciliation_started") {
+                                setTurns((prev) => prev.map((t) => t.id === recTurnId
+                                    ? {
+                                        ...t,
+                                        response: t.response + `Workspace reconciliation\n`
+                                    }
+                                    : t));
+                            }
+                            else if (ev.type === "recovery_reconciliation_completed") {
+                                setTurns((prev) => prev.map((t) => t.id === recTurnId
+                                    ? {
+                                        ...t,
+                                        response: t.response +
+                                            `${ev.result.consistent ? "✓ Workspace consistent" : "⚠ Inconsistent"}\n\n`
+                                    }
+                                    : t));
+                            }
+                            else if (ev.type === "recovery_outcome_determined") {
+                                const outcomeText = PlanFormatter.formatRecoveryOutcome(ev.result);
+                                if (ev.outcome === "recovered" ||
+                                    ev.outcome === "recovered_with_changes") {
+                                    let prep;
+                                    if (agent && "prepareRecoveryContinuation" in agent) {
+                                        try {
+                                            prep = await agent.prepareRecoveryContinuation({
+                                                cwd,
+                                                recoveryResult: ev.result,
+                                                recoveryOutcome: ev.outcome
+                                            });
+                                        }
+                                        catch {
+                                            // ignore
+                                        }
+                                    }
+                                    if (prep && prep.canContinue) {
+                                        setPendingRecoveryContinuation({
+                                            plan: pr.plan,
+                                            preparation: prep
+                                        });
+                                        const contText = PlanFormatter.formatRecoveryContinuationPrompt(prep);
+                                        setTurns((prev) => prev.map((t) => t.id === recTurnId
+                                            ? {
+                                                ...t,
+                                                status: "done",
+                                                response: `${outcomeText}\n\n${contText}\n`
+                                            }
+                                            : t));
+                                    }
+                                    else {
+                                        const incompleteSteps = pr.plan.steps.filter((s) => s.status !== "completed" && s.status !== "skipped");
+                                        if (incompleteSteps.length > 0 && !prep) {
+                                            const fallbackPrep = {
+                                                eligible: true,
+                                                canContinue: true,
+                                                planId: pr.plan.planId,
+                                                runId: pr.plan.runId,
+                                                recoveryOutcome: ev.outcome,
+                                                remainingSteps: incompleteSteps,
+                                                completedSteps: pr.plan.steps.filter((s) => s.status === "completed"),
+                                                skippedSteps: pr.plan.steps.filter((s) => s.status === "skipped"),
+                                                reconciliationConsistent: true,
+                                                requiresExplicitApproval: true
+                                            };
+                                            setPendingRecoveryContinuation({
+                                                plan: pr.plan,
+                                                preparation: fallbackPrep
+                                            });
+                                            const contText = PlanFormatter.formatRecoveryContinuationPrompt(fallbackPrep);
+                                            setTurns((prev) => prev.map((t) => t.id === recTurnId
+                                                ? {
+                                                    ...t,
+                                                    status: "done",
+                                                    response: `${outcomeText}\n\n${contText}\n`
+                                                }
+                                                : t));
+                                        }
+                                        else {
+                                            setTurns((prev) => prev.map((t) => t.id === recTurnId
+                                                ? {
+                                                    ...t,
+                                                    status: "done",
+                                                    response: `${outcomeText}\n\n✓ Plan completed\n`
+                                                }
+                                                : t));
+                                        }
+                                    }
+                                }
+                                else if (ev.outcome === "still_blocked") {
+                                    const defaultAdaptation = {
+                                        planId: pr.plan.planId,
+                                        assessedAt: Date.now(),
+                                        canContinue: false,
+                                        canRetry: false,
+                                        canAdapt: true,
+                                        feedback: [],
+                                        affectedSteps: [...ev.result.affectedSteps],
+                                        currentRiskLevel: "normal",
+                                        requiresUserConfirmation: true,
+                                        recommendedAction: "replan"
+                                    };
+                                    setPendingPlanBlocked({
+                                        plan: pr.plan,
+                                        assessment: defaultAdaptation,
+                                        reconciliationResult: ev.result.reconciliationResult
+                                    });
+                                    setTurns((prev) => prev.map((t) => t.id === recTurnId
+                                        ? {
+                                            ...t,
+                                            status: "done",
+                                            response: `${outcomeText}\n`
+                                        }
+                                        : t));
+                                }
+                                else {
+                                    setTurns((prev) => prev.map((t) => t.id === recTurnId
+                                        ? {
+                                            ...t,
+                                            status: "done",
+                                            response: `${outcomeText}\n`
+                                        }
+                                        : t));
+                                }
+                            }
+                            else if (ev.type === "recovery_completed") {
+                                setTurns((prev) => prev.map((t) => t.id === recTurnId
+                                    ? {
+                                        ...t,
+                                        status: "done",
+                                        response: t.response.includes("Recovery completed")
+                                            ? t.response
+                                            : t.response + "✓ Recovery completed\n"
+                                    }
+                                    : t));
+                            }
+                        }
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    setTurns((prev) => prev.map((t) => t.id === recTurnId
+                        ? {
+                            ...t,
+                            status: "error",
+                            response: t.response + `✗ Recovery error: ${msg}\n`
+                        }
+                        : t));
+                }
+            }
+            else {
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: trimmed,
+                        response: "✓ Recovery cancelled\n",
+                        status: "done"
+                    }
+                ]);
+            }
+            return;
+        }
+        if (pendingPlanBlocked) {
+            setQuery("");
+            const pb = pendingPlanBlocked;
+            setPendingPlanBlocked(null);
+            const choice = trimmed.toLowerCase();
+            const isRecon = !!pb.reconciliationResult;
+            if (isRecon && (choice === "r" || choice === "recover" || choice === "recovery")) {
+                try {
+                    if (agent && "assessExecutionRecovery" in agent) {
+                        const assessment = await agent.assessExecutionRecovery(pb.plan.planId, {
+                            cwd,
+                            reconciliationResult: pb.reconciliationResult
+                        });
+                        setPendingRecovery({ assessment, plan: pb.plan });
+                        const promptText = PlanFormatter.formatRecoveryAssessment(assessment);
+                        setTurns((prev) => [
+                            ...prev,
+                            {
+                                id: `cmd-${Date.now()}`,
+                                prompt: trimmed,
+                                response: `${promptText}\n`,
+                                status: "done"
+                            }
+                        ]);
+                        return;
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: `✗ Recovery assessment error: ${msg}\n`,
+                            status: "done"
+                        }
+                    ]);
+                    return;
+                }
+            }
+            if ((!isRecon && (choice === "r" || choice === "replan")) ||
+                (isRecon && (choice === "p" || choice === "replan"))) {
+                try {
+                    if (agent && "resolveExecutionDecision" in agent) {
+                        await agent.resolveExecutionDecision(pb.plan.planId, "replan", { cwd });
+                    }
+                    if (agent && "prepareReplan" in agent) {
+                        const assessment = await agent.prepareReplan(pb.plan.planId, { cwd });
+                        if (!assessment.eligible) {
+                            setTurns((prev) => [
+                                ...prev,
+                                {
+                                    id: `cmd-${Date.now()}`,
+                                    prompt: trimmed,
+                                    response: `✗ Replanning not eligible: ${assessment.reason}\n`,
+                                    status: "done"
+                                }
+                            ]);
+                        }
+                        else {
+                            setPendingReplan({ planId: pb.plan.planId, assessment });
+                            const promptText = PlanFormatter.formatReplanPrompt(assessment);
+                            const replanNotice = PlanFormatter.formatReplanNotice();
+                            setTurns((prev) => [
+                                ...prev,
+                                {
+                                    id: `cmd-${Date.now()}`,
+                                    prompt: trimmed,
+                                    response: `${replanNotice}\n\n${promptText}\n`,
+                                    status: "done"
+                                }
+                            ]);
+                        }
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: `✗ Replanning error: ${msg}\n`,
+                            status: "done"
+                        }
+                    ]);
+                }
+            }
+            else if (choice === "c" ||
+                choice === "continue" ||
+                choice === "re-check" ||
+                choice === "recheck") {
+                let resumeNotice = `↻ Resuming plan ${pb.plan.planId}...\n`;
+                try {
+                    if (agent && "resolveExecutionDecision" in agent) {
+                        const decisionResult = await agent.resolveExecutionDecision(pb.plan.planId, "continue", { cwd });
+                        const incompleteStep = pb.plan.steps.find((s) => s.stepId === decisionResult.resumedStepId) ||
+                            pb.plan.steps[0];
+                        if (incompleteStep) {
+                            resumeNotice = `${PlanFormatter.formatResumeNotice(pb.plan.planId, incompleteStep.order, pb.plan.steps.length, incompleteStep.title)}\n`;
+                        }
+                    }
+                    if (agent && "getTaskPlan" in agent) {
+                        transitionPlanStatus(pb.plan, "executing");
+                    }
+                }
+                catch {
+                    // ignore
+                }
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: trimmed,
+                        response: resumeNotice,
+                        status: "done"
+                    }
+                ]);
+            }
+            else {
+                // default / 'x' / 'cancel'
+                try {
+                    if (agent && "resolveExecutionDecision" in agent) {
+                        await agent.resolveExecutionDecision(pb.plan.planId, "cancel", { cwd });
+                    }
+                    if (agent && "cancel" in agent) {
+                        await agent.cancel();
+                    }
+                }
+                catch {
+                    // ignore
+                }
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: trimmed,
+                        response: `${PlanFormatter.formatCancelNotice()}\n`,
+                        status: "done"
+                    }
+                ]);
+            }
+            return;
+        }
+        if (pendingReplan) {
+            setQuery("");
+            const pr = pendingReplan;
+            setPendingReplan(null);
+            if (trimmed.toLowerCase() === "y" || trimmed.toLowerCase() === "yes") {
+                try {
+                    if (agent && "executeReplan" in agent) {
+                        const replanResult = await agent.executeReplan({
+                            runId: `run-replan-${Date.now()}`,
+                            previousPlanId: pr.planId,
+                            reason: pr.assessment.reason,
+                            explanation: pr.assessment.explanation,
+                            failedStepId: pr.assessment.affectedStepId,
+                            cwd,
+                            userRequest: pr.assessment.previousPlan?.userRequestSummary || "",
+                            requestedBy: "user"
+                        });
+                        if (replanResult.status === "created" && replanResult.newPlan) {
+                            const formattedPlan = PlanFormatter.formatPlanDetail(replanResult.newPlan);
+                            setTurns((prev) => [
+                                ...prev,
+                                {
+                                    id: `cmd-${Date.now()}`,
+                                    prompt: trimmed,
+                                    response: `✓ Created replacement plan: ${replanResult.newPlanId}\n\n${formattedPlan}\n\nType /plan to inspect or approve when ready.\n`,
+                                    status: "done"
+                                }
+                            ]);
+                        }
+                        else {
+                            setTurns((prev) => [
+                                ...prev,
+                                {
+                                    id: `cmd-${Date.now()}`,
+                                    prompt: trimmed,
+                                    response: `✗ Replanning failed: ${replanResult.reason}\n`,
+                                    status: "done"
+                                }
+                            ]);
+                        }
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: `✗ Error creating replan: ${msg}\n`,
+                            status: "done"
+                        }
+                    ]);
+                }
+            }
+            else {
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: trimmed,
+                        response: "Replanning cancelled.\n",
+                        status: "done"
+                    }
+                ]);
+            }
+            return;
+        }
+        if (pendingResume) {
+            setQuery("");
+            const pr = pendingResume;
+            setPendingResume(null);
+            if (trimmed.toLowerCase() === "y" || trimmed.toLowerCase() === "yes") {
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: trimmed,
+                        response: `✓ Resuming run ${pr.runId} as ${pr.prep.newRunId}...\n`,
+                        status: "done"
+                    }
+                ]);
+                if (agent && "resumeRun" in agent) {
+                    setIsGenerating(true);
+                    const nextTaskCount = taskCount + 1;
+                    setTaskCount(nextTaskCount);
+                    setActiveRequest(pr.prep.originalRun.userRequestSummary);
+                    setLastTaskStatus("in_progress");
+                    const turnId = `turn-${Date.now()}`;
+                    const newTurn = {
+                        id: turnId,
+                        prompt: `Resume task: ${pr.prep.originalRun.userRequestSummary}`,
+                        response: "",
+                        status: "streaming"
+                    };
+                    setTurns((prev) => [...prev, newTurn]);
+                    try {
+                        for await (const event of agent.resumeRun(pr.runId, { cwd })) {
+                            if (event.type === "text") {
+                                setTurns((prev) => prev.map((t) => t.id === turnId
+                                    ? { ...t, response: t.response + event.content }
+                                    : t));
+                            }
+                            else if (event.type === "done") {
+                                setTurns((prev) => prev.map((t) => t.id === turnId ? { ...t, status: "done" } : t));
+                            }
+                        }
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        setTurns((prev) => prev.map((t) => t.id === turnId
+                            ? { ...t, status: "error", error: `✗ ${msg}` }
+                            : t));
+                    }
+                    finally {
+                        setIsGenerating(false);
+                    }
+                }
+            }
+            else {
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: trimmed,
+                        response: "✗ Resume cancelled by user.\n",
+                        status: "done"
+                    }
+                ]);
+            }
+            return;
+        }
+        // Slash command processing
+        if (trimmed.startsWith("/")) {
+            setQuery("");
+            const [rawCmd, ...rawArgs] = trimmed.split(/\s+/);
+            const cmd = (rawCmd ?? "").toLowerCase();
+            const arg = rawArgs.join(" ").trim();
+            if (cmd === "/help") {
+                setActiveView("help");
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: trimmed,
+                        response: "Available commands:\n  /help       - Show this help message\n  /status     - Show provider, model, and session status\n  /history    - Show task history in this session\n  /tasks      - List completed tasks\n  /task <num> - View details of a specific task\n  /sessions   - List past sessions\n  /clear      - Clear conversation history\n  /exit       - Exit FeCode\n",
+                        status: "done"
+                    }
+                ]);
+                return;
+            }
+            if (cmd === "/status") {
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: trimmed,
+                        response: `FeCode\n\nProvider:          ${providerName || "unknown"}\nModel:             ${modelName || "unknown"}\nWorking directory: ${cwd}\nSession:           ${sessionId}\n`,
+                        status: "done"
+                    }
+                ]);
+                return;
+            }
+            if (cmd === "/clear") {
+                setTurns([]);
+                setTurns([
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: trimmed,
+                        response: "✓ Conversation cleared\n\nSession history remains available through:\n  /history  - View completed tasks\n  /tasks    - List task summaries\n  /status   - Session details\n",
+                        status: "done"
+                    }
+                ]);
+                return;
+            }
+            if (cmd === "/exit" || cmd === "/quit") {
+                await handleExit();
+                return;
+            }
+            if (cmd === "/history") {
+                const historyText = SessionHistoryFormatter.formatHistory(completedSummaries);
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: trimmed,
+                        response: historyText,
+                        status: "done"
+                    }
+                ]);
+                return;
+            }
+            if (cmd === "/tasks") {
+                const tasksText = SessionHistoryFormatter.formatTaskList(completedSummaries);
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: trimmed,
+                        response: tasksText,
+                        status: "done"
+                    }
+                ]);
+                return;
+            }
+            if (cmd === "/task") {
+                if (!arg) {
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: "Current Task\n\nNo active task.\n\nUse /tasks to see completed tasks in this session.\n",
+                            status: "done"
+                        }
+                    ]);
+                    return;
+                }
+                const taskNum = parseInt(arg, 10);
+                const summary = completedSummaries.find((s) => s.taskIndex === taskNum);
+                if (summary) {
+                    const detailText = SessionHistoryFormatter.formatTaskDetail(summary);
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: detailText,
+                            status: "done"
+                        }
+                    ]);
+                }
+                else {
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: `✗ Task not found: ${arg}\n\nUse /tasks to see available tasks (1-${completedSummaries.length}).\n`,
+                            status: "done"
+                        }
+                    ]);
+                }
+                return;
+            }
+            if (cmd === "/git") {
+                try {
+                    const statusResult = await gitRepo.getStatus(cwd);
+                    const formatted = GitStatusFormatter.formatGitStatus(statusResult);
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: formatted,
+                            status: "done"
+                        }
+                    ]);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: `✗ Git error: ${msg}\n`,
+                            status: "done"
+                        }
+                    ]);
+                }
+                return;
+            }
+            if (cmd === "/checkpoints") {
+                try {
+                    const list = await cpManager.list();
+                    const formatted = CheckpointFormatter.formatCheckpointsList(list);
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: formatted,
+                            status: "done"
+                        }
+                    ]);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: `✗ Checkpoints error: ${msg}\n`,
+                            status: "done"
+                        }
+                    ]);
+                }
+                return;
+            }
+            if (cmd === "/checkpoint") {
+                try {
+                    const cpRes = await cpManager.create({
+                        cwd,
+                        reason: arg || "Manual checkpoint"
+                    });
+                    const formatted = cpRes.checkpoint
+                        ? CheckpointFormatter.formatCheckpointCreated(cpRes.checkpoint)
+                        : "✓ Checkpoint created\n";
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: formatted,
+                            status: "done"
+                        }
+                    ]);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: `✗ Checkpoint error: ${msg}\n`,
+                            status: "done"
+                        }
+                    ]);
+                }
+                return;
+            }
+            if (cmd === "/recover") {
+                if (!arg || arg === "status") {
+                    try {
+                        const statusRec = recManager.getLastRecord();
+                        const formatted = RecoveryFormatter.formatRecoveryStatus(statusRec);
+                        setTurns((prev) => [
+                            ...prev,
+                            {
+                                id: `cmd-${Date.now()}`,
+                                prompt: trimmed,
+                                response: formatted,
+                                status: "done"
+                            }
+                        ]);
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        setTurns((prev) => [
+                            ...prev,
+                            {
+                                id: `cmd-${Date.now()}`,
+                                prompt: trimmed,
+                                response: `✗ Recovery error: ${msg}\n`,
+                                status: "done"
+                            }
+                        ]);
+                    }
+                    return;
+                }
+                if (arg.startsWith("preview")) {
+                    const cpId = arg.replace("preview", "").trim();
+                    if (!cpId) {
+                        setTurns((prev) => [
+                            ...prev,
+                            {
+                                id: `cmd-${Date.now()}`,
+                                prompt: trimmed,
+                                response: "✗ Please specify a checkpoint ID for preview.\n",
+                                status: "done"
+                            }
+                        ]);
+                        return;
+                    }
+                    try {
+                        const preview = await recManager.preview(cpId, cwd);
+                        const formatted = RecoveryFormatter.formatRecoveryPreview(preview);
+                        setTurns((prev) => [
+                            ...prev,
+                            {
+                                id: `cmd-${Date.now()}`,
+                                prompt: trimmed,
+                                response: formatted,
+                                status: "done"
+                            }
+                        ]);
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        setTurns((prev) => [
+                            ...prev,
+                            {
+                                id: `cmd-${Date.now()}`,
+                                prompt: trimmed,
+                                response: `✗ Recovery preview error: ${msg}\n`,
+                                status: "done"
+                            }
+                        ]);
+                    }
+                    return;
+                }
+            }
+            if (cmd === "/debug" || cmd === "/diagnostics") {
+                setActiveView("diagnostics");
+                let summary;
+                if (agent && "getRunSummary" in agent) {
+                    summary = agent.getRunSummary(arg || undefined);
+                }
+                else if (runtime && runtime.getDiagnosticsSummary) {
+                    summary = runtime.getDiagnosticsSummary(arg || undefined);
+                }
+                if (summary) {
+                    const formatted = formatRunDiagnostics(summary);
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: formatted,
+                            status: "done"
+                        }
+                    ]);
+                }
+                else {
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: "No run diagnostics available.\n",
+                            status: "done"
+                        }
+                    ]);
+                }
+                return;
+            }
+            if (cmd === "/runs") {
+                setActiveView("runs");
+                let runs = [];
+                if (agent && "listHistoricalRuns" in agent) {
+                    runs = await agent.listHistoricalRuns();
+                }
+                else if (runtime && runtime.getHistoricalRuns) {
+                    runs = await runtime.getHistoricalRuns();
+                }
+                const formatted = RunHistoryFormatter.formatRunsList(runs);
+                setTurns((prev) => [
+                    ...prev,
+                    {
+                        id: `cmd-${Date.now()}`,
+                        prompt: trimmed,
+                        response: formatted,
+                        status: "done"
+                    }
+                ]);
+                return;
+            }
+            if (cmd === "/run") {
+                if (!arg) {
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: "✗ Please specify a run ID: /run <id>\n",
+                            status: "done"
+                        }
+                    ]);
+                    return;
+                }
+                let run = null;
+                if (agent && "getHistoricalRun" in agent) {
+                    run = await agent.getHistoricalRun(arg);
+                }
+                else if (runtime && runtime.getHistoricalRun) {
+                    run = await runtime.getHistoricalRun(arg);
+                }
+                if (run) {
+                    const formatted = RunHistoryFormatter.formatRunDetail(run);
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: formatted,
+                            status: "done"
+                        }
+                    ]);
+                }
+                else {
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: `✗ Run not found: ${arg}\n`,
+                            status: "done"
+                        }
+                    ]);
+                }
+                return;
+            }
+            if (cmd === "/sessions") {
+                try {
+                    const list = await store.list();
+                    const formatted = SessionHistoryFormatter.formatSessionsList(list);
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: formatted,
+                            status: "done"
+                        }
+                    ]);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: `✗ Error listing sessions: ${msg}\n`,
+                            status: "done"
+                        }
+                    ]);
+                }
+                return;
+            }
+            if (cmd === "/delete-session") {
+                if (!arg) {
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: "✗ Please specify a session ID to delete.\n",
+                            status: "done"
+                        }
+                    ]);
+                    return;
+                }
+                try {
+                    const deleted = await store.delete(arg);
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: deleted
+                                ? `✓ Deleted session: ${arg}\n`
+                                : `✗ Session not found: ${arg}\n`,
+                            status: "done"
+                        }
+                    ]);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: `✗ Error deleting session: ${msg}\n`,
+                            status: "done"
+                        }
+                    ]);
+                }
+                return;
+            }
+            if (cmd === "/resume") {
+                if (!arg) {
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: "✗ Please specify a session or run ID to resume.\n",
+                            status: "done"
+                        }
+                    ]);
+                    return;
+                }
+                // Try SessionStore first
+                try {
+                    const sessionData = await store.load(arg);
+                    if (sessionData) {
+                        try {
+                            const fs = await import("fs/promises");
+                            await fs.stat(sessionData.workingDirectory);
+                        }
+                        catch {
+                            setTurns((prev) => [
+                                ...prev,
+                                {
+                                    id: `cmd-${Date.now()}`,
+                                    prompt: trimmed,
+                                    response: `⚠ Working directory no longer exists\n\nPath:\n  ${sessionData.workingDirectory}\n`,
+                                    status: "done"
+                                }
+                            ]);
+                            return;
+                        }
+                        if (agent && "restoreSession" in agent) {
+                            agent.restoreSession(sessionData);
+                        }
+                        const summary = SessionHistoryFormatter.formatResumeSummary(sessionData);
+                        setTurns((prev) => [
+                            ...prev,
+                            {
+                                id: `cmd-${Date.now()}`,
+                                prompt: trimmed,
+                                response: summary,
+                                status: "done"
+                            }
+                        ]);
+                        return;
+                    }
+                }
+                catch {
+                    // Fall through to durable run resume
+                }
+                if (agent && "prepareResume" in agent) {
+                    try {
+                        const prep = await agent.prepareResume(arg, cwd);
+                        if (!prep.canResume) {
+                            setTurns((prev) => [
+                                ...prev,
+                                {
+                                    id: `cmd-${Date.now()}`,
+                                    prompt: trimmed,
+                                    response: `✗ Cannot resume run: ${prep.explanation}\n`,
+                                    status: "done"
+                                }
+                            ]);
+                        }
+                        else {
+                            setPendingResume({ runId: arg, prep });
+                            const promptText = RunHistoryFormatter.formatResumePrompt(prep);
+                            setTurns((prev) => [
+                                ...prev,
+                                {
+                                    id: `cmd-${Date.now()}`,
+                                    prompt: trimmed,
+                                    response: `${promptText}\n`,
+                                    status: "done"
+                                }
+                            ]);
+                        }
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        setTurns((prev) => [
+                            ...prev,
+                            {
+                                id: `cmd-${Date.now()}`,
+                                prompt: trimmed,
+                                response: `✗ Resume error: ${msg}\n`,
+                                status: "done"
+                            }
+                        ]);
+                    }
+                }
+                return;
+            }
+            if (cmd === "/replan") {
+                if (agent && "prepareReplan" in agent) {
+                    try {
+                        const assessment = await agent.prepareReplan(arg || undefined, { cwd });
+                        if (!assessment.eligible) {
+                            setTurns((prev) => [
+                                ...prev,
+                                {
+                                    id: `cmd-${Date.now()}`,
+                                    prompt: trimmed,
+                                    response: `✗ Replanning not eligible: ${assessment.reason}\n`,
+                                    status: "done"
+                                }
+                            ]);
+                        }
+                        else {
+                            setPendingReplan({ planId: arg || "active-plan", assessment });
+                            const promptText = PlanFormatter.formatReplanPrompt(assessment);
+                            const replanNotice = PlanFormatter.formatReplanNotice();
+                            setTurns((prev) => [
+                                ...prev,
+                                {
+                                    id: `cmd-${Date.now()}`,
+                                    prompt: trimmed,
+                                    response: `${replanNotice}\n\n${promptText}\n`,
+                                    status: "done"
+                                }
+                            ]);
+                        }
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        setTurns((prev) => [
+                            ...prev,
+                            {
+                                id: `cmd-${Date.now()}`,
+                                prompt: trimmed,
+                                response: `✗ Replan error: ${msg}\n`,
+                                status: "done"
+                            }
+                        ]);
+                    }
+                }
+                return;
+            }
+            if (cmd === "/plan") {
+                setActiveView("plan");
+                if (arg) {
+                    let summary;
+                    if (agent &&
+                        "getRunSummary" in agent &&
+                        typeof agent.getRunSummary === "function") {
+                        summary = agent.getRunSummary(arg);
+                    }
+                    else if (runtime && runtime.getDiagnosticsSummary) {
+                        summary = runtime.getDiagnosticsSummary(arg);
+                    }
+                    if (summary) {
+                        const lines = [
+                            `Task Plan for Run: ${summary.runId}`,
+                            `Plan ID:        ${summary.planId || "unknown"}`,
+                            `Status:         ${summary.planStatus || "unknown"}`,
+                            `Progress:       ${summary.completedPlanSteps ?? 0}/${summary.totalPlanSteps ?? 0} completed`
+                        ];
+                        if (summary.planSummary) {
+                            lines.push(`Summary:        ${summary.planSummary}`);
+                        }
+                        setTurns((prev) => [
+                            ...prev,
+                            {
+                                id: `cmd-${Date.now()}`,
+                                prompt: trimmed,
+                                response: lines.join("\n") + "\n",
+                                status: "done"
+                            }
+                        ]);
+                        return;
+                    }
+                }
+                let activePlan;
+                if (agent &&
+                    "getTaskPlan" in agent &&
+                    typeof agent.getTaskPlan === "function") {
+                    activePlan = agent.getTaskPlan();
+                }
+                if (activePlan) {
+                    const detail = PlanFormatter.formatPlanDetail(activePlan);
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: detail,
+                            status: "done"
+                        }
+                    ]);
+                }
+                else {
+                    setTurns((prev) => [
+                        ...prev,
+                        {
+                            id: `cmd-${Date.now()}`,
+                            prompt: trimmed,
+                            response: "No active plan found.\n",
+                            status: "done"
+                        }
+                    ]);
+                }
+                return;
+            }
+            if (cmd === "/clear") {
+                setTurns([]);
+                setQuery("");
+                return;
+            }
+            // Unknown command
+            setTurns((prev) => [
+                ...prev,
+                {
+                    id: `cmd-${Date.now()}`,
+                    prompt: trimmed,
+                    response: `✗ Unknown command: ${cmd}. Type /help for available commands.\n`,
+                    status: "done"
+                }
+            ]);
+            return;
+        }
+        // Standard task submission
+        setQuery("");
+        setIsGenerating(true);
+        const nextTaskCount = taskCount + 1;
+        setTaskCount(nextTaskCount);
+        setActiveRequest(trimmed);
+        setLastTaskStatus("in_progress");
+        let initialResponse = "";
+        let riskAssessment;
+        if (agent &&
+            "assessTaskRisk" in agent &&
+            typeof agent.assessTaskRisk === "function") {
+            try {
+                riskAssessment = agent.assessTaskRisk({
+                    userMessage: trimmed,
+                    cwd,
+                    affectedFiles: [],
+                    operations: []
+                });
+            }
+            catch {
+                // ignore
+            }
+        }
+        else {
+            const isDepChange = trimmed.includes("npm install") ||
+                trimmed.includes("yarn add") ||
+                trimmed.includes("pnpm add") ||
+                trimmed.includes("dependencies");
+            if (isDepChange) {
+                riskAssessment = {
+                    level: "elevated",
+                    reasons: ["Modifies project dependencies or configuration"],
+                    affectedFiles: 1,
+                    requiresCheckpoint: true,
+                    requiresExplicitApproval: true
+                };
+            }
+        }
+        if (riskAssessment &&
+            (riskAssessment.level === "elevated" ||
+                riskAssessment.level === "critical")) {
+            const riskHeader = `${riskAssessment.level === "critical" ? "Critical" : "Elevated"}-risk task\n`;
+            const cpReq = riskAssessment.requiresCheckpoint
+                ? "Checkpoint required\n"
+                : "";
+            initialResponse = `${riskHeader}${cpReq}\n`;
+        }
+        const turnId = `turn-${Date.now()}`;
+        const turnStartMs = Date.now();
+        const newTurn = {
+            id: turnId,
+            prompt: trimmed,
+            response: initialResponse,
+            status: "streaming"
+        };
+        setTurns((prev) => [...prev, newTurn]);
+        try {
+            if (!agent) {
+                throw new Error(configError || "Agent runtime is not initialized.");
+            }
+            const stream = agent.run({
+                message: trimmed,
+                cwd,
+                sessionId
+            });
+            let accumulatedRawText = "";
+            const toolCallMap = new Map();
+            for await (const event of stream) {
+                setUiState((prev) => reduceUIState(prev ||
+                    createInitialUIState({
+                        cwd,
+                        sessionId
+                    }), event));
+                if (event.type === "text") {
+                    const chunk = event.content;
+                    accumulatedRawText += chunk;
+                    const elapsed = Date.now() - turnStartMs;
+                    const thinkingMatch = accumulatedRawText.match(/<(?:think|thinking)>([\s\S]*?)<\/(?:think|thinking)>/);
+                    const inProgressThinking = !thinkingMatch &&
+                        (accumulatedRawText.includes("<think>") ||
+                            accumulatedRawText.includes("<thinking>") ||
+                            accumulatedRawText.startsWith("<think"));
+                    if (thinkingMatch) {
+                        const thinkingContent = thinkingMatch[1].trim();
+                        const firstLine = thinkingContent.split("\n")[0]?.trim() || "";
+                        const cleanContent = accumulatedRawText
+                            .replace(/<(?:think|thinking)>[\s\S]*?<\/(?:think|thinking)>/g, "")
+                            .replace(/<\/?(?:think|thinking)>/g, "")
+                            .trim();
+                        setTurns((prev) => prev.map((t) => t.id === turnId
+                            ? {
+                                ...t,
+                                thinkingMs: t.thinkingMs !== undefined
+                                    ? t.thinkingMs
+                                    : elapsed > 0
+                                        ? elapsed
+                                        : 1000,
+                                thinkingSummary: firstLine,
+                                response: initialResponse ? initialResponse + cleanContent : cleanContent
+                            }
+                            : t));
+                    }
+                    else if (inProgressThinking) {
+                        const partialThinking = accumulatedRawText.replace(/[\s\S]*<(?:think|thinking)>/, "").trim();
+                        const firstLine = partialThinking.split("\n")[0]?.trim() || "Thinking...";
+                        setTurns((prev) => prev.map((t) => t.id === turnId
+                            ? {
+                                ...t,
+                                thinkingMs: elapsed > 0 ? elapsed : 1000,
+                                thinkingSummary: firstLine
+                            }
+                            : t));
+                    }
+                    else {
+                        setTurns((prev) => {
+                            const turn = prev.find((t) => t.id === turnId);
+                            const isFirstToken = !turn?.response || turn.response === initialResponse;
+                            const sanitizedChunk = chunk.replace(/<\/?(?:think|thinking)>/g, "");
+                            return prev.map((t) => t.id === turnId
+                                ? {
+                                    ...t,
+                                    thinkingMs: t.thinkingMs !== undefined
+                                        ? t.thinkingMs
+                                        : isFirstToken && elapsed > 500
+                                            ? elapsed
+                                            : undefined,
+                                    response: t.response + sanitizedChunk
+                                }
+                                : t);
+                        });
+                    }
+                }
+                else if (event.type === "skills_activated") {
+                    if (event.skills && event.skills.length > 0) {
+                        setTurns((prev) => prev.map((t) => t.id === turnId
+                            ? {
+                                ...t,
+                                response: t.response +
+                                    `⚡ Skills: ${event.skills.join(", ")}\n`
+                            }
+                            : t));
+                    }
+                }
+                else if (event.type === "error") {
+                    setTurns((prev) => prev.map((t) => t.id === turnId
+                        ? {
+                            ...t,
+                            status: "error",
+                            error: `✗ ${event.error.message}`
+                        }
+                        : t));
+                    setLastTaskStatus("blocked");
+                }
+                else if (event.type === "approval_required") {
+                    setPendingApproval(event.request);
+                }
+                else if (event.type === "checkpoint_approval_requested" ||
+                    event.type === "execution_handoff_waiting_approval") {
+                    setPendingApproval({
+                        id: "checkpointId" in event ? event.checkpointId : "req-cp",
+                        toolName: "checkpoint",
+                        category: "write",
+                        arguments: {},
+                        reason: event.reason
+                    });
+                }
+                else if (event.type === "tool_call") {
+                    toolCallMap.set(event.call.id, event.call.name);
+                }
+                else if (event.type === "tool_result") {
+                    const toolName = toolCallMap.get(event.callId) || "tool";
+                    if (event.result.success) {
+                        setTurns((prev) => prev.map((t) => t.id === turnId
+                            ? {
+                                ...t,
+                                response: t.response.includes(`✓ ${toolName}`)
+                                    ? t.response
+                                    : t.response + `✓ ${toolName} executed\n`
+                            }
+                            : t));
+                    }
+                    else if (event.result.error) {
+                        const errCode = event.result.error.code;
+                        let recoveryMsg = "";
+                        if (errCode === "NOT_FOUND") {
+                            recoveryMsg = `⚠ ${toolName}: File not found — searching again\n`;
+                        }
+                        else if (errCode === "EDIT_CONFLICT") {
+                            recoveryMsg = `⚠ ${toolName}: Edit conflict — refreshing file context\n`;
+                        }
+                        else if (errCode === "REPEATED_CALL_LOOP") {
+                            recoveryMsg = `⚠ ${toolName}: Repeated call loop detected — adapting strategy\n`;
+                        }
+                        else if (errCode === "COMMAND_TIMEOUT") {
+                            recoveryMsg = `⚠ ${toolName}: Command timed out\n`;
+                        }
+                        else {
+                            recoveryMsg = `✗ ${toolName}: ${event.result.error.message || "Execution error"}\n`;
+                        }
+                        if (recoveryMsg) {
+                            setTurns((prev) => prev.map((t) => t.id === turnId
+                                ? { ...t, response: t.response + recoveryMsg }
+                                : t));
+                        }
+                    }
+                }
+                else if (event.type === "plan_created") {
+                    const planSummary = `Plan: ${event.plan.objective}\n\n`;
+                    const formattedPlan = PlanFormatter.formatPlanDetail(event.plan);
+                    setTurns((prev) => prev.map((t) => t.id === turnId
+                        ? {
+                            ...t,
+                            response: (t.response ? t.response + "\n\n" : "") +
+                                planSummary +
+                                formattedPlan +
+                                "\n"
+                        }
+                        : t));
+                }
+                else if (event.type === "final_reconciliation_failed") {
+                    const plan = (agent &&
+                        "getTaskPlan" in agent &&
+                        typeof agent.getTaskPlan === "function"
+                        ? agent.getTaskPlan()
+                        : undefined) || {
+                        planId: event.result.planId,
+                        runId: event.result.runId,
+                        createdAt: Date.now(),
+                        userRequestSummary: "Reconciliation failed",
+                        objective: "Reconciliation failed",
+                        status: "blocked",
+                        steps: [],
+                        risks: []
+                    };
+                    const defaultAdaptation = {
+                        planId: event.result.planId,
+                        assessedAt: Date.now(),
+                        canContinue: false,
+                        canRetry: false,
+                        canAdapt: true,
+                        feedback: [],
+                        affectedSteps: event.result.missingFiles || [],
+                        currentRiskLevel: "normal",
+                        requiresUserConfirmation: true,
+                        recommendedAction: "replan"
+                    };
+                    setPendingPlanBlocked({
+                        plan,
+                        assessment: defaultAdaptation,
+                        reconciliationResult: event.result
+                    });
+                    const promptText = PlanFormatter.formatReconciliationBlockedPrompt(plan, event.result);
+                    setTurns((prev) => prev.map((t) => t.id === turnId
+                        ? {
+                            ...t,
+                            response: (t.response ? t.response + "\n\n" : "") + promptText + "\n"
+                        }
+                        : t));
+                }
+                else if (event.type === "plan_blocked" ||
+                    event.type === "plan_adaptation_required") {
+                    const plan = (agent &&
+                        "getTaskPlan" in agent &&
+                        typeof agent.getTaskPlan === "function"
+                        ? agent.getTaskPlan()
+                        : undefined) || {
+                        planId: event.planId,
+                        runId: "runId" in event ? event.runId : "run",
+                        createdAt: Date.now(),
+                        userRequestSummary: "Blocked plan",
+                        objective: "Blocked plan",
+                        status: "blocked",
+                        steps: [],
+                        risks: []
+                    };
+                    const planId = event.planId;
+                    const runId = "runId" in event ? event.runId : "run";
+                    const assessment = {
+                        planId,
+                        assessedAt: Date.now(),
+                        canContinue: true,
+                        canRetry: true,
+                        canAdapt: true,
+                        feedback: [
+                            {
+                                feedbackId: "fb-1",
+                                runId,
+                                planId,
+                                kind: "verification_failed",
+                                severity: "blocking",
+                                summary: event.reason,
+                                detectedAt: Date.now(),
+                                requiresReplanning: true,
+                                requiresUserConfirmation: true,
+                                recommendedAction: "replan"
+                            }
+                        ],
+                        affectedSteps: event.affectedSteps || [],
+                        currentRiskLevel: "normal",
+                        requiresUserConfirmation: true,
+                        recommendedAction: "replan"
+                    };
+                    setPendingPlanBlocked({ plan, assessment });
+                    const promptText = PlanFormatter.formatPlanBlockedPrompt(plan, assessment);
+                    setTurns((prev) => prev.map((t) => t.id === turnId
+                        ? {
+                            ...t,
+                            response: (t.response ? t.response + "\n\n" : "") + promptText + "\n"
+                        }
+                        : t));
+                }
+                else if (event.type === "plan_execution_started") {
+                    setTurns((prev) => prev.map((t) => t.id === turnId
+                        ? {
+                            ...t,
+                            response: t.response +
+                                `Plan approved. Executing ${event.totalSteps} steps...\n\n`
+                        }
+                        : t));
+                }
+                else if (event.type === "plan_step_started") {
+                    setTurns((prev) => prev.map((t) => t.id === turnId
+                        ? {
+                            ...t,
+                            response: t.response +
+                                `[${event.stepIndex + 1}] ${event.title || "Step"}\nEXECUTING\n`
+                        }
+                        : t));
+                }
+                else if (event.type === "plan_step_completed") {
+                    setTurns((prev) => prev.map((t) => t.id === turnId
+                        ? {
+                            ...t,
+                            response: t.response + "✓ COMPLETED\n\n"
+                        }
+                        : t));
+                }
+                else if (event.type === "plan_step_skipped") {
+                    setTurns((prev) => prev.map((t) => t.id === turnId
+                        ? {
+                            ...t,
+                            response: t.response +
+                                `⊘ SKIPPED (${event.reason || "Skipped"})\n\n`
+                        }
+                        : t));
+                }
+                else if (event.type === "plan_execution_completed") {
+                    setTurns((prev) => prev.map((t) => t.id === turnId
+                        ? {
+                            ...t,
+                            response: t.response +
+                                `✓ Plan completed (${event.completedSteps}/${event.totalSteps} steps).\n`
+                        }
+                        : t));
+                }
+                else if (event.type === "execution_feedback_detected") {
+                    setTurns((prev) => prev.map((t) => t.id === turnId
+                        ? {
+                            ...t,
+                            response: t.response + `⚠ Feedback: ${event.summary}\n`
+                        }
+                        : t));
+                }
+                else if (event.type === "step_retry_started") {
+                    setTurns((prev) => prev.map((t) => t.id === turnId
+                        ? {
+                            ...t,
+                            response: t.response +
+                                `⟳ Retrying Step ${event.stepId} (attempt ${event.attempt}/${event.maxAttempts}): ${event.reason}\n`
+                        }
+                        : t));
+                }
+                else if (event.type === "step_retry_completed") {
+                    setTurns((prev) => prev.map((t) => t.id === turnId
+                        ? {
+                            ...t,
+                            response: t.response +
+                                (event.success
+                                    ? `✓ Step retry succeeded on attempt ${event.attempt}\n`
+                                    : `✗ Step retry failed on attempt ${event.attempt}\n`)
+                        }
+                        : t));
+                }
+                else if (event.type === "plan_step_failed") {
+                    setTurns((prev) => prev.map((t) => t.id === turnId
+                        ? {
+                            ...t,
+                            response: t.response +
+                                `✗ Step ${event.stepId} failed${event.error ? `: ${event.error}` : ""}\n`
+                        }
+                        : t));
+                }
+                else if (event.type === "plan_execution_failed") {
+                    setTurns((prev) => prev.map((t) => t.id === turnId
+                        ? {
+                            ...t,
+                            status: "error",
+                            error: event.reason,
+                            response: t.response +
+                                `\n✗ Plan execution failed: ${event.reason || "Unknown error"}\n`
+                        }
+                        : t));
+                    setLastTaskStatus("blocked");
+                }
+                else if (event.type === "plan_execution_cancelled") {
+                    setTurns((prev) => prev.map((t) => t.id === turnId
+                        ? {
+                            ...t,
+                            status: "cancelled",
+                            response: t.response +
+                                `\n⊘ Plan execution cancelled: ${event.reason || "Cancelled by user"}\n`
+                        }
+                        : t));
+                    setLastTaskStatus("cancelled");
+                }
+                else if (event.type === "task_summary") {
+                    let summaryHeader = "";
+                    if (event.summary.status === "completed") {
+                        summaryHeader = "✓ Task completed\n\n";
+                    }
+                    else if (event.summary.status === "blocked") {
+                        summaryHeader = "⚠ Task blocked\n\n";
+                    }
+                    else if (event.summary.status === "cancelled") {
+                        summaryHeader = "⊘ Task cancelled\n\n";
+                    }
+                    let summaryFormatted = SessionHistoryFormatter.formatTaskDetail(event.summary);
+                    if (event.summary.verifiedCommands &&
+                        event.summary.verifiedCommands.length > 0) {
+                        summaryFormatted = summaryFormatted.replace("Verification:", "Verified:");
+                    }
+                    const fullSummary = summaryHeader + summaryFormatted;
+                    setTurns((prev) => prev.map((t) => t.id === turnId
+                        ? {
+                            ...t,
+                            response: (t.response ? t.response + "\n\n" : "") +
+                                fullSummary +
+                                "\n"
+                        }
+                        : t));
+                    setCompletedSummaries((prev) => [...prev, event.summary]);
+                    setLastTaskStatus(event.summary.status);
+                    persistState(event.summary.status, event.summary, nextTaskCount).catch(() => { });
+                }
+                else if (event.type === "done") {
+                    setTurns((prev) => prev.map((t) => t.id === turnId
+                        ? {
+                            ...t,
+                            status: "done",
+                            response: t.response && t.response.trim().length > 0
+                                ? t.response
+                                : "Completed (no output returned by the model)."
+                        }
+                        : t));
+                }
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            setTurns((prev) => prev.map((t) => t.id === turnId
+                ? { ...t, status: "error", error: `✗ ${msg}` }
+                : t));
+            setLastTaskStatus("blocked");
+        }
+        finally {
+            setIsGenerating(false);
+            setActiveRequest(undefined);
+        }
+    };
+    return (_jsxs(AppShell, { header: _jsx(Header, { projectName: "fecode", providerName: providerName, modelName: modelName, cwd: cwd, status: uiState?.status || lastTaskStatus, gitBranch: uiState?.workspace?.gitBranch, isGitClean: uiState?.workspace ? !uiState.workspace.isGitDirty : true, runId: uiState?.runId, sessionId: sessionId }), modal: hasModal ? (_jsxs(Box, { flexDirection: "column", children: [pendingApproval && (_jsx(ApprovalPrompt, { toolName: pendingApproval.toolName, reason: pendingApproval.reason, changeReview: pendingApproval.changeReview, value: approvalInput, onChange: setApprovalInput, onSubmit: handleApprovalSubmit })), pendingPlanBlocked && (_jsx(BlockedView, { planId: pendingPlanBlocked.plan.planId, stepInfo: `${pendingPlanBlocked.plan.steps.find((s) => s.status === "in_progress")?.order || 1}/${pendingPlanBlocked.plan.steps.length}`, reason: pendingPlanBlocked.assessment.feedback[0]?.summary, affectedSteps: pendingPlanBlocked.assessment.affectedSteps, isReconciliation: Boolean(pendingPlanBlocked.reconciliationResult), value: blockedInput, onChange: setBlockedInput, onSubmit: handleSubmit })), pendingRecovery && (_jsx(RecoveryView, { strategy: pendingRecovery.assessment.strategy, outcome: pendingRecovery.assessment.eligible ? "ELIGIBLE" : "NOT_ELIGIBLE", value: recoveryInput, onChange: setRecoveryInput, onSubmit: handleSubmit })), pendingRecoveryContinuation && (_jsx(RecoveryView, { isAwaitingContinuation: true, remainingStepsCount: pendingRecoveryContinuation.preparation.remainingSteps.length, value: recoveryInput, onChange: setRecoveryInput, onSubmit: handleSubmit })), pendingReplan && (_jsx(ReplanView, { originalPlanId: pendingReplan.planId, reason: pendingReplan.assessment.reason, replanDepth: pendingReplan.assessment.replanDepth, value: replanInput, onChange: setReplanInput, onSubmit: handleSubmit })), pendingResume && (_jsx(ResumeView, { runId: pendingResume.runId, originalRequest: pendingResume.prep.originalRun.userRequestSummary, riskLevel: pendingResume.prep.reassessedRisk.level, value: resumeInput, onChange: setResumeInput, onSubmit: handleSubmit }))] })) : null, footer: _jsx(StatusBar, { status: uiState?.status || lastTaskStatus, isGenerating: isGenerating, hasModal: hasModal, activeView: activeView, isReconciliation: Boolean(pendingPlanBlocked?.reconciliationResult), recoveryMode: pendingRecoveryContinuation
+                ? "continuation"
+                : pendingRecovery
+                    ? "confirm"
+                    : undefined, modalType: pendingApproval
+                ? "approval"
+                : pendingPlanBlocked
+                    ? "blocked"
+                    : pendingRecovery || pendingRecoveryContinuation
+                        ? "recovery"
+                        : pendingReplan
+                            ? "replan"
+                            : pendingResume
+                                ? "resume"
+                                : undefined }), children: [configError && (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "red", paddingX: 1, marginY: 1, children: [_jsx(Text, { bold: true, color: "red", children: "\u26A0 Configuration Error" }), _jsx(Text, { color: "white", children: configError }), _jsx(Text, { color: "gray", children: "Please check your environment variables (.env) or configuration file." })] })), activeView === "help" && _jsx(HelpView, {}), activeView === "git" && (_jsx(WorkspaceStatus, { cwd: cwd, branch: uiState?.workspace?.gitBranch, isClean: uiState?.workspace ? !uiState.workspace.isGitDirty : true, riskLevel: uiState?.riskLevel, modifiedFiles: uiState?.workspace?.modifiedFiles, stagedFiles: uiState?.workspace?.stagedFiles, untrackedFiles: uiState?.workspace?.untrackedFiles, hasDrift: uiState?.workspace?.hasDrift, driftReason: uiState?.workspace?.driftReason })), activeView === "runs" && (_jsx(RunHistoryView, { runs: uiState?.diagnostics
+                    ? [
+                        {
+                            runId: uiState.diagnostics.runId,
+                            status: uiState.diagnostics.finalStatus || "executing",
+                            userRequestSummary: uiState.diagnostics.userRequestSummary,
+                            durationMs: uiState.diagnostics.durationMs
+                        }
+                    ]
+                    : [] })), activeView === "diagnostics" && (_jsx(DiagnosticsView, { summary: uiState?.diagnostics })), activeView === "plan" && uiState?.activePlan && (_jsx(PlanView, { planId: uiState.activePlan.planId, objective: uiState.activePlan.objective, summary: uiState.activePlan.userRequestSummary, status: uiState.activePlan.status, steps: uiState.activePlan.steps, completedCount: uiState.activePlan.completedStepsCount, totalCount: uiState.activePlan.totalStepsCount })), isGenerating && uiState?.activeTool && (_jsx(CurrentStepView, { toolName: uiState.activeTool.toolName, target: uiState.activeTool.target, riskLevel: uiState.riskLevel })), _jsxs(Box, { flexDirection: "column", children: [turns.map((turn, idx) => (_jsx(TurnView, { prompt: turn.prompt, response: turn.response, status: turn.status, error: turn.error, isLast: idx === turns.length - 1, thinkingMs: turn.thinkingMs, thinkingTokens: turn.thinkingTokens, thinkingSummary: turn.thinkingSummary }, turn.id))), isGenerating && (_jsx(Box, { marginTop: 0, children: _jsx(ThinkingIndicator, { isActive: isGenerating, label: "Agent is working..." }) })), !hasModal && (_jsx(TaskInput, { value: query, onChange: handleQueryChange, onSubmit: handleSubmit, isDisabled: Boolean(pendingQuery), placeholder: isGenerating
+                            ? "Type next task (will be queued)..."
+                            : "Describe task or type /help...", label: turns.length === 0 ? "Task" : undefined, pendingQuery: pendingQuery, suggestions: commandSuggestions, selectedSuggestion: selectedSuggestion }))] })] }));
+};
+//# sourceMappingURL=App.js.map