kritya 0.8.2-beta

package/dist/ui/useAgent.js

@@ -0,0 +1,534 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import path from "node:path";
+import { gitBranch } from "../git/git.js";
+import { listProviders, resolveProvider, saveConfig, saveProviderModel, } from "../config/config.js";
+import { DEFAULT_MODEL, contextWindowFor } from "../config/models.js";
+import { ProviderClient, RetryExhaustedError } from "../provider/client.js";
+import { createSwitchyardClient } from "../provider/switchyardClient.js";
+import { SWITCHYARD_ROUTE_ID, resolveEffectiveModel } from "../provider/switchyardSidecar.js";
+import { KillSwitchError } from "../agent/killSwitch.js";
+import { loadProjectState, nextPhase, PHASE_COMMAND, } from "../agent/workflow.js";
+import { tavilySearch } from "../tools/webSearch.js";
+import { killActiveNotice, useKillSwitch } from "./useKillSwitch.js";
+import { useUsageBudget } from "./useUsageBudget.js";
+import { useSessionResume } from "./useSessionResume.js";
+/**
+ * Owns everything tied to running agent turns: the transcript, streaming and
+ * permission state, usage/cost tracking, and session resume. Input handling
+ * (text box, slash-command suggestions, @mention autocomplete) stays in App.
+ */
+export function useAgent({ agent, workspace, modelRef, providerRef, config, uiBridge, resumedCount, initialTasks, resumeSessions, refreshFileList, onSwitchClient, }) {
+    const nextId = useRef(0);
+    const [items, setItems] = useState(() => {
+        const initial = [
+            {
+                id: nextId.current++,
+                kind: "banner",
+                subtitle: `${path.basename(workspace)} · ${modelRef.current} · type a request, or /help for commands`,
+            },
+        ];
+        if (resumedCount > 0) {
+            const done = initialTasks?.filter((t) => t.status === "done").length ?? 0;
+            const taskNote = initialTasks?.length
+                ? ` — checklist restored (${done}/${initialTasks.length} done)`
+                : "";
+            initial.push({
+                id: nextId.current++,
+                kind: "info",
+                text: `Resumed previous session (${resumedCount} messages)${taskNote}.`,
+            });
+        }
+        return initial;
+    });
+    const [phase, setPhase] = useState(resumeSessions?.length ? "resume" : "input");
+    const [stream, setStream] = useState("");
+    const [thinking, setThinking] = useState(false);
+    const [activity, setActivity] = useState(null);
+    /**
+     * Which workflow phase the *current turn* is running. Turn-scoped and cleared
+     * when the turn ends, unlike `workflow` below — `activity` can't carry this,
+     * since retries and permission prompts overwrite it mid-turn. The ref is what
+     * the turn's teardown reads: a command sets this and calls runAgent in the
+     * same tick, so the state value inside runAgent's closure is still stale.
+     */
+    const runningPhaseRef = useRef(null);
+    const [runningPhase, setRunningPhaseState] = useState(null);
+    const setRunningPhase = useCallback((p) => {
+        runningPhaseRef.current = p;
+        setRunningPhaseState(p);
+    }, []);
+    /** The active project workflow, for the statusline. Persists between turns. */
+    const [workflow, setWorkflow] = useState(() => loadProjectState(workspace));
+    const [permission, setPermission] = useState(null);
+    const [elicitation, setElicitation] = useState(null);
+    const [model, setModel] = useState(modelRef.current);
+    const [provider, setProvider] = useState(providerRef.current);
+    /** The model that actually served the most recent turn — see Usage.servedModel.
+     *  Only meaningful behind a router (switchyard), where it can differ from
+     *  `model` (the route name); cleared on provider/model switch. */
+    const [servedModel, setServedModel] = useState(undefined);
+    const [tasks, setTasks] = useState(initialTasks ?? []);
+    const [branch, setBranch] = useState(() => gitBranch(workspace));
+    const [planMode, setPlanMode] = useState(false);
+    /** The manual Shift+Tab read-only toggle — independent of the project
+     *  workflow's own `planMode`. */
+    const [dryRunMode, setDryRunMode] = useState(false);
+    const [acceptEdits, setAcceptEdits] = useState(false);
+    const [autoApprovedCount, setAutoApprovedCount] = useState(0);
+    const hasConfirmedAcceptEdits = useRef(false);
+    const abortRef = useRef(null);
+    /** Tool calls currently running, keyed by call id — more than one when a
+     *  turn's read-only calls are dispatched in parallel. Rendered as live rows. */
+    const [inFlight, setInFlight] = useState([]);
+    /**
+     * The phase to restore once a permission prompt resolves. Tool-call
+     * permission requests always arrive mid-turn (phase "working"), but MCP
+     * sampling requests can arrive at any time — including while the user is
+     * simply sitting at the input prompt — so restoring to the phase captured
+     * when the prompt opened (rather than hardcoding "working") keeps the UI
+     * from getting stuck in a false "working" state afterward.
+     */
+    const phaseRef = useRef(phase);
+    useEffect(() => {
+        phaseRef.current = phase;
+    }, [phase]);
+    const previousPhaseRef = useRef("input");
+    /** Reusable permission prompt, shared by in-turn tool calls and out-of-turn
+     *  callers (e.g. MCP sampling) — same UI, same three-way decision. */
+    const requestPermission = useCallback((toolName, summary, diff, warning) => new Promise((resolve) => {
+        previousPhaseRef.current = phaseRef.current;
+        setActivity(null);
+        process.stdout.write("\x07"); // ring the terminal bell when input is needed
+        setPermission({ toolName, summary, diff, warning, resolve });
+        setPhase("permission");
+    }), []);
+    /** Same out-of-turn reasoning as `requestPermission` — MCP elicitation
+     *  requests can arrive at any time, not just mid-turn. */
+    const requestElicitation = useCallback((message, fields) => new Promise((resolve) => {
+        previousPhaseRef.current = phaseRef.current;
+        setActivity(null);
+        process.stdout.write("\x07");
+        setElicitation({ message, fields, resolve });
+        setPhase("elicitation");
+    }), []);
+    const addItem = useCallback((item) => {
+        setItems((prev) => {
+            // A model that calls the same tool with the same arguments several times
+            // in a row still gets a line each — hiding the calls would misreport what
+            // it did — but repeating the identical preview under every one buries the
+            // rest of the turn. Show the output once.
+            const last = prev[prev.length - 1];
+            const repeat = item.kind === "tool" &&
+                last?.kind === "tool" &&
+                last.summary === item.summary &&
+                last.output === item.output &&
+                !!item.output;
+            const next = repeat ? { ...item, output: "" } : item;
+            return [...prev, { ...next, id: nextId.current++ }];
+        });
+    }, []);
+    const { usageByModel, totalUsage, totalCost, costReport, ctxPct, setCtxPct, tokenBudget, budgetPct, budgetUsed, budgetStopped, resetBudget, setBudgetLimit, recordUsage, totalTokensRef, } = useUsageBudget({ agent, config, modelRef, model, addItem, abortRef });
+    const { killed, killReason, engageKill, releaseKill } = useKillSwitch({
+        agent,
+        addItem,
+        abortRef,
+        permission,
+        setPermission,
+        setInFlight,
+        setActivity,
+        setStream,
+        setThinking,
+        setPhase,
+    });
+    useEffect(() => {
+        uiBridge.onTasksUpdate = setTasks;
+        uiBridge.onExternalEdit = (relPath) => {
+            addItem({
+                kind: "info",
+                text: `Detected an external edit to ${relPath} (made outside kritya) — checkpointed for /undo.`,
+            });
+        };
+    }, [uiBridge, addItem]);
+    useEffect(() => {
+        agent.onAutoApprove = () => setAutoApprovedCount((n) => n + 1);
+    }, [agent]);
+    const enterAcceptEdits = () => {
+        hasConfirmedAcceptEdits.current = true;
+        agent.acceptEdits = true;
+        setAcceptEdits(true);
+        setAutoApprovedCount(0);
+        addItem({
+            kind: "info",
+            text: "Accept-edits mode ON — file writes/edits auto-approve without asking. Destructive shell " +
+                "commands (rm -rf, force-push, etc.) still always ask. Shift+Tab again for dry-run mode, once " +
+                "more for normal.",
+        });
+    };
+    /** Cycles normal → accept-edits → dry-run → normal. First entry into accept-edits this session pauses on a confirmation instead of switching immediately. */
+    const cycleMode = () => {
+        if (dryRunMode) {
+            agent.dryRunMode = false;
+            setDryRunMode(false);
+            addItem({ kind: "info", text: "Dry-run mode OFF — the agent can make changes again." });
+            return;
+        }
+        if (acceptEdits) {
+            agent.acceptEdits = false;
+            setAcceptEdits(false);
+            agent.dryRunMode = true;
+            setDryRunMode(true);
+            addItem({
+                kind: "info",
+                text: "Dry-run mode ON — read-only. The agent will explore and propose a plan; edits and shell are blocked.",
+            });
+            return;
+        }
+        if (!hasConfirmedAcceptEdits.current) {
+            setPhase("confirmMode");
+            return;
+        }
+        enterAcceptEdits();
+    };
+    const onAcceptEditsConfirm = (confirmed) => {
+        setPhase("input");
+        if (confirmed)
+            enterAcceptEdits();
+    };
+    const setModelEverywhere = (id) => {
+        modelRef.current = id;
+        setModel(id);
+        setServedModel(undefined);
+        agent.contextWindow = contextWindowFor(id, config);
+        // Persists to providers.<name>.model — scoped to the active provider, so
+        // picking a model here never leaks into any other provider's resolution.
+        // On switchyard specifically, "model" is a routing directive, not a
+        // portable choice: the route id (SWITCHYARD_ROUTE_ID) means "let
+        // escalation routing decide," while any other id means "call this model
+        // directly, skip routing entirely." Persisting a raw id would silently
+        // disable routing on every future launch, so a bypass id is kept
+        // session-only there.
+        if (providerRef.current !== "switchyard" || id === SWITCHYARD_ROUTE_ID) {
+            saveProviderModel(providerRef.current, id);
+        }
+        addItem({ kind: "info", text: `Model set to ${id}` });
+    };
+    /**
+     * Switch the active provider mid-session — e.g. as a fallback when the
+     * current one keeps timing out or rate-limiting. Only the underlying HTTP
+     * client changes; `agent.history` (and the persisted session file) are
+     * untouched, so the conversation carries over.
+     *
+     * Session-only by default: closing and relaunching kritya reverts to
+     * config.provider. Pass `persist: true` (from `/provider <name> --default`)
+     * to make this the new default for future launches too.
+     */
+    const setProviderEverywhere = (name, persist = false) => {
+        const resolved = resolveProvider(config, name);
+        if (!resolved.apiKey) {
+            addItem({
+                kind: "info",
+                text: `No API key found for provider "${name}". Set its env var, a .env file, or ` +
+                    `providers.${name}.apiKey in ~/.kritya/config.json, then try again.`,
+            });
+            return;
+        }
+        const sampling = {
+            temperature: resolved.temperature,
+            topP: resolved.topP,
+            maxTokens: resolved.maxTokens,
+        };
+        const finishSwitch = () => {
+            providerRef.current = name;
+            setProvider(name);
+            setServedModel(undefined);
+            if (persist)
+                saveConfig({ provider: name });
+            const providerDefaultModel = config.providers?.[name]?.model;
+            // Filters out SWITCHYARD_ROUTE_ID as a carry-over candidate when `name`
+            // isn't switchyard — it's a routing directive, not a real model, so it
+            // would 404 against any other provider (see the config.model === config.provider
+            // mismatch this was built to fix).
+            const targetModel = resolveEffectiveModel(name, [
+                providerDefaultModel,
+                name === "switchyard" ? SWITCHYARD_ROUTE_ID : undefined,
+                modelRef.current,
+            ], name === "switchyard" ? SWITCHYARD_ROUTE_ID : DEFAULT_MODEL);
+            let note = `Switched provider to ${name} — conversation history kept.`;
+            if (targetModel !== modelRef.current) {
+                setModelEverywhere(targetModel);
+                note = `Switched provider to ${name} (model: ${targetModel}) — conversation history kept.`;
+            }
+            else {
+                note += ` Model "${modelRef.current}" carried over — /model to change it if it isn't offered here.`;
+            }
+            note += persist
+                ? ` Saved as the default for future launches.`
+                : ` This session only — /provider ${name} --default to make it the default.`;
+            addItem({ kind: "info", text: note });
+        };
+        if (name === "switchyard") {
+            addItem({ kind: "info", text: "Starting local switchyard-server…" });
+            createSwitchyardClient(resolved.apiKey, sampling)
+                .then((newClient) => {
+                agent.setClient(newClient);
+                onSwitchClient(newClient);
+                finishSwitch();
+            })
+                .catch((err) => {
+                addItem({
+                    kind: "info",
+                    text: `Couldn't start switchyard: ${err instanceof Error ? err.message : String(err)}`,
+                });
+            });
+            return;
+        }
+        const newClient = new ProviderClient(resolved.apiKey, resolved.baseUrl, sampling);
+        agent.setClient(newClient);
+        onSwitchClient(newClient);
+        finishSwitch();
+    };
+    /** Re-read the workflow pointer from disk after anything that may have moved it. */
+    const refreshWorkflow = useCallback(() => {
+        setWorkflow(loadProjectState(workspace));
+    }, [workspace]);
+    /**
+     * Say what to run next, once a phase turn has finished.
+     *
+     * The phase prompts also ask the model to name the next command, but a model
+     * paraphrasing its instructions drops it often enough that the handoff can't
+     * depend on that — the user is left at a prompt with no idea what comes next.
+     * Printing it here makes it deterministic.
+     */
+    const announceNextPhase = useCallback(() => {
+        const ran = runningPhaseRef.current;
+        setRunningPhase(null);
+        if (!ran)
+            return;
+        // Prefer the phase on disk: an autonomous turn may have advanced it past
+        // whatever the command started.
+        const current = loadProjectState(workspace)?.phase ?? ran;
+        const next = nextPhase(current);
+        addItem({
+            kind: "info",
+            text: next
+                ? `✓ ${current} phase done — next: ${PHASE_COMMAND[next]} (or /project to review where you are)`
+                : `✓ ${current} phase done — the workflow is complete. /project clear ends it.`,
+        });
+    }, [workspace, addItem, setRunningPhase]);
+    const runWebSearch = async (query) => {
+        if (agent.kill.active) {
+            addItem({ kind: "info", text: killActiveNotice(agent.kill.reason) });
+            return;
+        }
+        setPhase("working");
+        setActivity(`Web search: ${query}`);
+        try {
+            const results = await tavilySearch(query, 5);
+            addItem({ kind: "info", text: `Web search: ${query}\n\n${results}` });
+            agent.addUserNote(`[Results of a web search I ran for "${query}"]:\n${results}`);
+        }
+        catch (err) {
+            addItem({
+                kind: "info",
+                text: `Web search failed: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+        finally {
+            setActivity(null);
+            setPhase("input");
+        }
+    };
+    const runAgent = async (text, images = []) => {
+        // The kill switch is checked first, ahead of every other stop condition:
+        // once it's on, the only thing the user can get back is this line.
+        if (agent.kill.active) {
+            addItem({ kind: "info", text: killActiveNotice(agent.kill.reason) });
+            return;
+        }
+        if (budgetStopped) {
+            addItem({
+                kind: "info",
+                text: `Token budget reached (${totalTokensRef.current.toLocaleString()} / ` +
+                    `${tokenBudget.toLocaleString()} tokens) — run /budget reset to clear it, or ` +
+                    `/budget <number> to raise the cap, before continuing.`,
+            });
+            return;
+        }
+        setPhase("working");
+        const ac = new AbortController();
+        abortRef.current = ac;
+        setInFlight([]);
+        try {
+            await agent.runTurn(text, {
+                onTextDelta: (delta) => {
+                    setThinking(false);
+                    setStream((prev) => prev + delta);
+                },
+                onReasoningDelta: () => setThinking(true),
+                onAssistantText: (full) => {
+                    setStream("");
+                    setThinking(false);
+                    addItem({ kind: "assistant", text: full });
+                },
+                onToolStart: (id, name, summary) => {
+                    setStream("");
+                    setInFlight((prev) => [...prev, { id, name, summary }]);
+                },
+                onToolEnd: (id, name, summary, preview, isError, resultSummary) => {
+                    setInFlight((prev) => prev.filter((t) => t.id !== id));
+                    if (name !== "update_tasks")
+                        addItem({
+                            kind: "tool",
+                            name,
+                            summary,
+                            error: isError,
+                            output: preview,
+                            resultSummary,
+                        });
+                },
+                onToolProgress: (id, text) => {
+                    setInFlight((prev) => prev.map((t) => (t.id === id ? { ...t, status: text } : t)));
+                },
+                requestPermission,
+                requestElicitation,
+                onRetry: (attempt, status) => {
+                    // Drop the partial text the failed attempt streamed, or the
+                    // retried answer would appear twice.
+                    setStream("");
+                    setActivity(`Provider error${status ? ` (${status})` : ""} — retrying (attempt ${attempt})…`);
+                },
+                onUsage: (usage) => {
+                    if (usage.servedModel)
+                        setServedModel(usage.servedModel);
+                    recordUsage(usage);
+                },
+            }, ac.signal, images);
+        }
+        catch (err) {
+            const isAbort = (err instanceof Error && err.name === "AbortError") ||
+                (err instanceof Error && /abort/i.test(err.message));
+            let text;
+            if (err instanceof KillSwitchError || agent.kill.active) {
+                // engageKill already printed the banner; don't follow it with a
+                // stack-trace-flavored "Error:" line for the abort it caused.
+                text = "Turn stopped by the kill switch.";
+            }
+            else if (isAbort) {
+                text = "Interrupted.";
+            }
+            else {
+                const message = err instanceof Error ? err.message : String(err);
+                if (err instanceof RetryExhaustedError) {
+                    const alternatives = listProviders(config)
+                        .filter((p) => p.hasKey && p.name !== provider)
+                        .map((p) => p.name);
+                    const hint = alternatives.length
+                        ? ` Provider "${provider}" isn't responding — try /provider ${alternatives[0]}` +
+                            (alternatives.length > 1
+                                ? ` (also available: ${alternatives.slice(1).join(", ")})`
+                                : "") +
+                            ` to switch without losing this conversation.`
+                        : ` Provider "${provider}" isn't responding, and no other provider has an API key ` +
+                            `configured to fall back to — see the "Providers" section of the README.`;
+                    text = `Error: ${message}${hint}`;
+                }
+                else {
+                    text = `Error: ${message}`;
+                }
+            }
+            addItem({ kind: "info", text });
+        }
+        finally {
+            abortRef.current = null;
+            setInFlight([]);
+            setStream("");
+            setThinking(false);
+            setActivity(null);
+            setPermission(null);
+            setPhase("input");
+            refreshFileList();
+            setBranch(gitBranch(workspace));
+            // A phase can advance itself by writing .kritya/project.json, so re-read
+            // it rather than trusting the command that started the turn.
+            refreshWorkflow();
+            announceNextPhase();
+            process.stdout.write("\x07"); // bell: the turn is done
+        }
+    };
+    const onPermissionDecision = (decision) => {
+        const pending = permission;
+        setPermission(null);
+        setPhase(previousPhaseRef.current);
+        pending?.resolve(decision);
+    };
+    const onElicitationDecision = (result) => {
+        const pending = elicitation;
+        setElicitation(null);
+        setPhase(previousPhaseRef.current);
+        pending?.resolve(result);
+    };
+    const { onResumeSelect } = useSessionResume({
+        agent,
+        resumeSessions,
+        addItem,
+        setPhase,
+        setTasks,
+    });
+    return {
+        items,
+        addItem,
+        phase,
+        setPhase,
+        stream,
+        thinking,
+        activity,
+        setActivity,
+        runningPhase,
+        setRunningPhase,
+        workflow,
+        refreshWorkflow,
+        permission,
+        elicitation,
+        inFlight,
+        model,
+        provider,
+        servedModel,
+        usageByModel,
+        totalUsage,
+        totalCost,
+        tasks,
+        setTasks,
+        ctxPct,
+        setCtxPct,
+        tokenBudget,
+        budgetPct,
+        budgetUsed,
+        budgetStopped,
+        resetBudget,
+        setBudgetLimit,
+        branch,
+        planMode,
+        setPlanMode,
+        dryRunMode,
+        killed,
+        killReason,
+        engageKill,
+        releaseKill,
+        acceptEdits,
+        setAcceptEdits,
+        autoApprovedCount,
+        cycleMode,
+        onAcceptEditsConfirm,
+        abortRef,
+        setModelEverywhere,
+        setProviderEverywhere,
+        costReport,
+        runAgent,
+        runWebSearch,
+        onPermissionDecision,
+        onElicitationDecision,
+        onResumeSelect,
+        requestPermission,
+        requestElicitation,
+    };
+}

package/dist/ui/useKillSwitch.js

@@ -0,0 +1,65 @@
+import { useState } from "react";
+/** The line shown for anything the user tries while the switch is engaged. */
+export function killActiveNotice(reason) {
+    return (`⛔ Kill switch ACTIVE${reason ? ` — ${reason}` : ""}. Nothing will run. ` +
+        `Release it with /kill off.`);
+}
+/** Owns the kill-switch UI state: engaging/releasing it and tearing down whatever turn was in flight. */
+export function useKillSwitch({ agent, addItem, abortRef, permission, setPermission, setInFlight, setActivity, setStream, setThinking, setPhase, }) {
+    const [killed, setKilled] = useState(agent.kill.active);
+    const [killReason, setKillReason] = useState(agent.kill.reason);
+    /**
+     * Engage the kill switch: abort the in-flight turn, answer any open
+     * permission prompt with "no" (otherwise the tool call would hang forever
+     * waiting on a promise nobody will resolve), and drop back to the input
+     * line. The agent-side gates in agent/loop.ts are what actually enforce it;
+     * this is the UI half.
+     */
+    const engageKill = (reason) => {
+        if (!agent.kill.engage(reason))
+            return; // already engaged
+        setKilled(true);
+        setKillReason(agent.kill.reason);
+        abortRef.current?.abort();
+        permission?.resolve("no");
+        setPermission(null);
+        setInFlight([]);
+        setActivity(null);
+        setStream("");
+        setThinking(false);
+        setPhase("input");
+        agent.audit?.logTool({
+            tool: "kill-switch",
+            summary: `kill switch engaged${agent.kill.reason ? `: ${agent.kill.reason}` : ""}`,
+            outcome: "blocked",
+        });
+        agent.turnSpan?.addEvent("kill_switch.engaged", {
+            "kritya.kill_reason": agent.kill.reason ?? "",
+        });
+        process.stdout.write("\x07"); // bell: something just stopped hard
+        addItem({
+            kind: "info",
+            text: `⛔ KILL SWITCH ENGAGED${agent.kill.reason ? ` — ${agent.kill.reason}` : ""}.\n` +
+                `Everything in flight was aborted; no model calls, tools, or subagents will run.\n` +
+                `Release it with /kill off when you're ready to continue.`,
+        });
+    };
+    const releaseKill = () => {
+        if (!agent.kill.release()) {
+            addItem({ kind: "info", text: "The kill switch isn't engaged." });
+            return;
+        }
+        setKilled(false);
+        setKillReason(undefined);
+        agent.audit?.logTool({
+            tool: "kill-switch",
+            summary: "kill switch released",
+            outcome: "ok",
+        });
+        addItem({
+            kind: "info",
+            text: "Kill switch released — the agent can run again. The interrupted turn is not resumed; send a new message.",
+        });
+    };
+    return { killed, killReason, engageKill, releaseKill };
+}

package/dist/ui/useSessionResume.js

@@ -0,0 +1,39 @@
+import { SessionStore } from "../session/store.js";
+/** Loading a saved session file into the agent's history and replaying its last few turns to the transcript. */
+export function useSessionResume({ agent, resumeSessions, addItem, setPhase, setTasks, }) {
+    const agentLoadSession = (file) => {
+        const messages = SessionStore.loadFile(file);
+        agent.loadHistory(messages);
+        const replay = messages.filter((m) => (m.role === "user" || m.role === "assistant") &&
+            typeof m.content === "string" &&
+            m.content.trim() &&
+            !(m.role === "user" && m.content.startsWith("[")));
+        for (const m of replay.slice(-6)) {
+            addItem({
+                kind: m.role === "user" ? "user" : "assistant",
+                text: String(m.content),
+            });
+        }
+        return messages.length;
+    };
+    const onResumeSelect = (file) => {
+        setPhase("input");
+        if (!file) {
+            addItem({ kind: "info", text: "Starting a fresh session." });
+            return;
+        }
+        const meta = resumeSessions?.find((s) => s.file === file);
+        const messages = agentLoadSession(file);
+        const restoredTasks = SessionStore.loadTasksForSession(file);
+        setTasks(restoredTasks);
+        const done = restoredTasks.filter((t) => t.status === "done").length;
+        const taskNote = restoredTasks.length
+            ? ` — checklist restored (${done}/${restoredTasks.length} done)`
+            : "";
+        addItem({
+            kind: "info",
+            text: `Resumed session from ${meta?.date ?? "?"} (${messages} messages)${taskNote}.`,
+        });
+    };
+    return { onResumeSelect };
+}