@prestyj/cli 4.3.161 → 4.3.200

package/dist/ui/App.js

@@ -4,11 +4,12 @@ import { Box, Text, Static, useStdout } from "ink";
 import { useTerminalSize } from "./hooks/useTerminalSize.js";
 import { useDoublePress } from "./hooks/useDoublePress.js";
 import { useTaskBarStore, useTaskBarPolling, focusTaskBar, exitTaskBar, expandTaskBar, collapseTaskBar, navigateTaskBar, killTask, } from "./stores/taskbar-store.js";
-import crypto, { createHash } from "node:crypto";
+import { createHash } from "node:crypto";
 import { readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { playNotificationSound } from "../utils/sound.js";
+import { formatError, } from "@prestyj/ai";
 import { extractImagePaths } from "../utils/image.js";
 import { useAgentLoop } from "./hooks/useAgentLoop.js";
 import { isEyesActive, journalCount } from "@prestyj/eyes";
@@ -34,63 +35,64 @@ import { EyesOverlay } from "./components/EyesOverlay.js";
 import { ThemeSelector } from "./components/ThemeSelector.js";
 import { BackgroundTasksBar } from "./components/BackgroundTasksBar.js";
 import { useTheme, useSetTheme } from "./theme/theme.js";
-import { useAnimationTick, useAnimationActive, deriveFrame, } from "./components/AnimationContext.js";
 import { useTerminalTitle } from "./hooks/useTerminalTitle.js";
 import { getGitBranch } from "../utils/git.js";
-import { getModel, getContextWindow } from "../core/model-registry.js";
+import { getModel, getContextWindow, getMaxThinkingLevel } from "../core/model-registry.js";
 import { SessionManager } from "../core/session-manager.js";
+import { appendMessagesToSession as appendSessionMessages, createCompactedSessionCheckpoint, } from "../core/session-compaction.js";
 import { log } from "../core/logger.js";
 import { getPendingUpdate, startPeriodicUpdateCheck, stopPeriodicUpdateCheck, } from "../core/auto-update.js";
 import { generateSessionTitle } from "../utils/session-title.js";
 import { SettingsManager } from "../core/settings-manager.js";
-import { shouldCompact, compact } from "../core/compaction/compactor.js";
+import { shouldCompact, compact, getCompactionReserveTokens, } from "../core/compaction/compactor.js";
 import { estimateConversationTokens } from "../core/compaction/token-estimator.js";
 import { PROMPT_COMMANDS, getPromptCommand } from "../core/prompt-commands.js";
+import { isFirstTimeSetup, markSetupAudited, getAnnouncedLanguages, markLanguagesAnnounced, } from "../core/setup-history.js";
 import { loadCustomCommands } from "../core/custom-commands.js";
 import { buildSystemPrompt } from "../system-prompt.js";
+import { detectLanguages, LANGUAGE_DISPLAY_NAMES, } from "../core/language-detector.js";
+import { detectVerifyCommands } from "../core/verify-commands.js";
+import { FOCUSED_REPO_MAP_MAX_CHARS, FIRST_TURN_REPO_MAP_MAX_CHARS, buildRepoMap, createRepoMapCache, } from "../core/repomap.js";
+import { getLatestUserText, injectRepoMapContextMessages, stripRepoMapContextMessages, } from "../core/repomap-context.js";
 import { extractPlanSteps, findCompletedMarkers, markStepsCompleted, segmentDisplayText, stripDoneMarkers, } from "../utils/plan-steps.js";
 import { getMCPServers } from "../core/mcp/index.js";
 import { trimFlushedItems, flushOnTurnText, flushOnTurnEnd, flushOverflow, } from "./live-item-flush.js";
-import { Buddy } from "./buddy/Buddy.js";
-// ── Provider Error Hints ──────────────────────────────────
-/** Detect provider-side errors and return a user-facing hint. */
-function getProviderErrorHint(message) {
-    const lower = message.toLowerCase();
-    if (lower.includes("overloaded") || lower.includes("engine_overloaded")) {
-        return "This is a provider-side issue — their servers are under heavy load. Try again in a moment.";
-    }
-    if (lower.includes("insufficient balance") ||
-        lower.includes("no resource package") ||
-        lower.includes("quota exceeded") ||
-        lower.includes("recharge")) {
-        return "The provider reports a billing or quota issue. Check your account balance or resource package.";
-    }
-    if (lower.includes("rate limit") ||
-        lower.includes("too many requests") ||
-        lower.includes("429")) {
-        return "You've hit the provider's rate limit. Wait a moment before retrying.";
-    }
-    if (lower.includes("502") || lower.includes("bad gateway")) {
-        return "The provider returned a server error. This is not a ezcoder issue — try again shortly.";
-    }
-    if (lower.includes("503") || lower.includes("service unavailable")) {
-        return "The provider's service is temporarily unavailable. Try again in a moment.";
-    }
-    if (lower.includes("timeout") || lower.includes("timed out")) {
-        return "The request to the provider timed out. Their servers may be slow — try again.";
-    }
-    if (lower.includes("500") && lower.includes("internal server error")) {
-        return "The provider experienced an internal error. This is not a ezcoder issue.";
-    }
-    if (lower.includes("does not recognize the requested model") ||
-        (lower.includes("model") &&
-            (lower.includes("not exist") || lower.includes("not found") || lower.includes("no access")))) {
-        return "Use /model to switch to a different model, or check that your account has access to the requested model.";
-    }
-    return null;
+/** Where ezcoder bugs should be reported. Surfaced in the guidance line. */
+const GGCODER_BUG_REPORT_URL = "github.com/Gahroot/ezcoder/issues";
+/**
+ * Build an ErrorItem from any thrown value. Centralises headline / message /
+ * guidance extraction so every error answers the same question for the user:
+ *   "Should I retry, or is this a ezcoder bug to report?"
+ */
+function toErrorItem(err, id, contextPrefix) {
+    const f = formatError(err);
+    const headline = contextPrefix ? `${contextPrefix} — ${f.headline}` : f.headline;
+    // For ezcoder bugs, swap the generic "see /help" guidance for an actual URL
+    // so users have a clear place to send the report.
+    const guidance = f.source === "ezcoder"
+        ? `This looks like a ezcoder bug — please send it to the dev at ${GGCODER_BUG_REPORT_URL}.`
+        : f.guidance;
+    // Mirror every user-visible error into ~/.ezcoder/debug.log so reports can be
+    // diagnosed even after the terminal scrollback is gone.
+    log("ERROR", "ui-error", headline, {
+        source: f.source,
+        message: f.message,
+        ...(f.provider ? { provider: f.provider } : {}),
+        ...(f.statusCode != null ? { statusCode: String(f.statusCode) } : {}),
+        ...(f.requestId ? { requestId: f.requestId } : {}),
+        ...(err instanceof Error && err.stack ? { stack: err.stack } : {}),
+    });
+    return {
+        kind: "error",
+        headline,
+        message: f.message,
+        guidance,
+        id,
+    };
 }
 /** Tools that get aggregated into a single compact group when concurrent. */
 const AGGREGATABLE_TOOLS = new Set(["read", "grep", "find", "ls"]);
+const RUNNING_INDICATOR_ANIMATION_MS = 1_200;
 /**
  * Cap memory by replacing old items with tiny tombstones. Ink's <Static>
  * tracks rendered items by array length — the array must never shrink, but
@@ -312,15 +314,22 @@ export function App(props) {
     // Items from the current/last turn — rendered in the live area so they stay visible
     const [liveItems, setLiveItems] = useState([]);
     // overlay seeded from sessionStore (lives across remount). Falls back to
-    // props.initialOverlay (CLI launched with one), then null.
-    const [overlay, setOverlay] = useState(props.sessionStore?.overlay ?? props.initialOverlay ?? null);
+    // props.initialOverlay (CLI launched with one) ONLY when there's no
+    // sessionStore — otherwise sessionStore is authoritative (its initial
+    // value already incorporated initialOverlay at session creation). Without
+    // this distinction, closing an overlay that was opened via initialOverlay
+    // (e.g. `ezcoder pixel`) re-asserts the overlay on resetUI remount because
+    // `null ?? "pixel"` is `"pixel"`.
+    const [overlay, setOverlay] = useState(props.sessionStore ? (props.sessionStore.overlay ?? null) : (props.initialOverlay ?? null));
     const [taskCount, setTaskCount] = useState(() => getTaskCount(props.cwd));
     const [eyesCount, setEyesCount] = useState(() => isEyesActive(props.cwd) ? journalCount({ status: "open" }, props.cwd) : undefined);
     const [updatePending, setUpdatePending] = useState(() => getPendingUpdate(props.version) !== null);
-    const [runAllTasks, setRunAllTasks] = useState(false);
-    const runAllTasksRef = useRef(false);
+    // Seed from sessionStore so "Run All" chaining survives the resetUI()
+    // remount that startTask() triggers between tasks.
+    const [runAllTasks, setRunAllTasks] = useState(props.sessionStore?.runAllTasks ?? false);
+    const runAllTasksRef = useRef(props.sessionStore?.runAllTasks ?? false);
     const startTaskRef = useRef(() => { });
-    const runAllPixelRef = useRef(false);
+    const runAllPixelRef = useRef(props.sessionStore?.runAllPixel ?? false);
     const currentPixelFixRef = useRef(null);
     const startPixelFixRef = useRef(() => { });
     const cwdRef = useRef(props.cwd);
@@ -333,13 +342,41 @@ export function App(props) {
     const [currentModel, setCurrentModel] = useState(props.model);
     const [currentProvider, setCurrentProvider] = useState(props.provider);
     const [currentTools, setCurrentTools] = useState(props.tools);
+    const currentToolsRef = useRef(props.tools);
     const [thinkingEnabled, setThinkingEnabled] = useState(!!props.thinking);
     const messagesRef = useRef(props.sessionStore?.messages ?? props.messages);
+    const repoMapInjectionEnabledRef = useRef(true);
+    const repoMapDirtyRef = useRef(true);
+    const repoMapMarkdownRef = useRef("");
+    const repoMapSnapshotRef = useRef(undefined);
+    const repoMapChangedCountRef = useRef(0);
+    const repoMapCacheRef = useRef(createRepoMapCache());
     const [planAutoExpand, setPlanAutoExpand] = useState(props.sessionStore?.planAutoExpand ?? false);
     const approvedPlanPathRef = useRef(props.sessionStore?.approvedPlanPath);
     const planStepsRef = useRef(props.sessionStore?.planSteps ?? []);
     const [planSteps, setPlanSteps] = useState(props.sessionStore?.planSteps ?? []);
-    const nextIdRef = useRef(0);
+    const planModeStateRef = useRef(planMode);
+    // Stuck-guard for the plan-continuation follow-up nudge. Tracks how many
+    // times we've nudged the agent to continue the same step. Reset whenever a
+    // new [DONE:n] marker advances progress (see onTurnText). Caps at 2 nudges
+    // so a genuinely stuck agent surfaces instead of looping forever.
+    const followUpNudgesRef = useRef({ step: 0, count: 0 });
+    // Seed the per-item ID counter so it doesn't collide with IDs already in
+    // sessionStore.history (which survives remount). Without this, a remount
+    // (resize, overlay toggle, etc.) starts the counter at 0 and new items
+    // generate ids "0", "1", "2"… that collide with the same ids from the
+    // previous mount, triggering React's duplicate-key warning and causing
+    // duplicate/omitted renders.
+    const nextIdRef = useRef((() => {
+        const hist = props.sessionStore?.history ?? props.initialHistory ?? [];
+        let max = -1;
+        for (const item of hist) {
+            const n = Number(item.id);
+            if (Number.isFinite(n) && n > max)
+                max = n;
+        }
+        return max + 1;
+    })());
     const sessionManagerRef = useRef(props.sessionsDir ? new SessionManager(props.sessionsDir) : null);
     const sessionPathRef = useRef(props.sessionStore?.sessionPath ?? props.sessionPath);
     const persistedIndexRef = useRef(messagesRef.current.length);
@@ -349,6 +386,26 @@ export function App(props) {
     const lastActualTokensTimestampRef = useRef(0);
     /** Timestamp of last compaction — used for time-based cooldown and staleness detection. */
     const lastCompactionTimeRef = useRef(0);
+    /**
+     * Languages whose style packs are currently injected into the system prompt.
+     * Grown by `maybeInjectLanguagePacks` after `write`/`bash` tool results when
+     * the language detector sees new marker files. Reset on `chdir` (pixel-fix).
+     * Only grows within a session; we never strip packs once injected (cheaper
+     * than invalidating prompt caching, and stale guidance is harmless).
+     */
+    const injectedLanguagesRef = useRef(new Set());
+    /**
+     * True until the first style-pack badge is pushed. Used to gate the
+     * one-time "/setup" hint so users learn the slash command without being
+     * spammed on every subsequent pack swap.
+     */
+    const setupHintShownRef = useRef(false);
+    /**
+     * Callback that fires `/setup` programmatically. Assigned later in the
+     * component once `agentLoop` is in scope. Called from the initial
+     * language-detection path when this cwd has never been audited before.
+     */
+    const triggerAutoSetupRef = useRef(async () => { });
     const getId = () => String(nextIdRef.current++);
     // Two-phase flush: items waiting to be moved to Static history after the
     // live area has been cleared and Ink has committed the smaller output.
@@ -372,9 +429,9 @@ export function App(props) {
     }, [currentProvider, onRuntimeStateChange]);
     useEffect(() => {
         onRuntimeStateChange?.({
-            thinking: thinkingEnabled ? (props.thinking ?? "medium") : undefined,
+            thinking: thinkingEnabled ? getMaxThinkingLevel(currentModel) : undefined,
         });
-    }, [thinkingEnabled, props.thinking, onRuntimeStateChange]);
+    }, [thinkingEnabled, currentModel, onRuntimeStateChange]);
     // Mirror session state into renderApp's closure so resetUI() can re-seed
     // the conversation on remount. Each panel that previously did a bare ANSI
     // screen clear (overlay open/close, plan accept/reject, /clear, startTask)
@@ -404,6 +461,7 @@ export function App(props) {
     const activeApiKey = currentCreds?.accessToken ?? props.apiKey;
     const activeAccountId = currentCreds?.accountId ?? props.accountId;
     const activeBaseUrl = currentCreds?.baseUrl ?? props.baseUrl;
+    const contextWindowOptions = useMemo(() => ({ provider: currentProvider, accountId: activeAccountId }), [currentProvider, activeAccountId]);
     // Load git branch — re-runs whenever the displayed cwd changes (e.g. when
     // a pixel fix moves the agent into a different project root).
     useEffect(() => {
@@ -425,25 +483,118 @@ export function App(props) {
     useEffect(() => {
         reloadCustomCommands();
     }, [reloadCustomCommands]);
+    useEffect(() => {
+        currentToolsRef.current = currentTools;
+    }, [currentTools]);
     // ── Plan mode wiring ─────────────────────────────────────
     // Sync planModeRef with React state
     useEffect(() => {
+        planModeStateRef.current = planMode;
         if (props.planModeRef) {
             props.planModeRef.current = planMode;
         }
     }, [planMode, props.planModeRef]);
+    const rebuildSystemPrompt = useCallback(async (options) => {
+        const approvedPlanPath = options?.clearApprovedPlan
+            ? undefined
+            : (options?.approvedPlanPath ?? approvedPlanPathRef.current);
+        return buildSystemPrompt(options?.cwd ?? cwdRef.current, props.skills, options?.planMode ?? planModeStateRef.current, approvedPlanPath, (options?.tools ?? currentToolsRef.current).map((tool) => tool.name), options?.activeLanguages ?? injectedLanguagesRef.current);
+    }, [props.skills]);
+    const replaceSystemPrompt = useCallback(async (options) => {
+        const newPrompt = await rebuildSystemPrompt(options);
+        if (messagesRef.current[0]?.role === "system") {
+            messagesRef.current[0] = { role: "system", content: newPrompt };
+        }
+        return newPrompt;
+    }, [rebuildSystemPrompt]);
+    /**
+     * Unified "apply detection result" pipeline. Called from three sites:
+     *   1. Initial mount (existing project at startup).
+     *   2. After every `write`/`bash` tool result (reactive to new manifests).
+     *   3. Before every user submit (catches external changes between turns,
+     *      and ensures non-writing prompts still surface the badge).
+     *
+     * No-op when no new languages were added vs `injectedLanguagesRef.current`.
+     * The set-growth gate keeps this safe to call from every hot path.
+     */
+    const applyLanguageDetectionRef = useRef(async () => { });
+    applyLanguageDetectionRef.current = async (source) => {
+        const cwd = cwdRef.current;
+        const detected = detectLanguages(cwd);
+        const added = [];
+        for (const id of detected) {
+            if (!injectedLanguagesRef.current.has(id))
+                added.push(id);
+        }
+        if (added.length === 0) {
+            // No new packs to inject. The empty-detection hint + auto-run are
+            // first-time-per-cwd only — once the user has been shown the box and
+            // /setup has had a chance to run, re-showing on every session is noise.
+            // The with-packs path below is gated the same way via
+            // getAnnouncedLanguages / markLanguagesAnnounced: badge fires once per
+            // (cwd, language) and stays silent on subsequent sessions / /clear.
+            if (source === "initial" &&
+                !setupHintShownRef.current &&
+                injectedLanguagesRef.current.size === 0 &&
+                isFirstTimeSetup(cwd)) {
+                setupHintShownRef.current = true;
+                markSetupAudited(cwd);
+                log("INFO", "language", `No style packs detected for ${cwd}`, { source });
+                setLiveItems((prev) => [...prev, { kind: "setup_hint", id: getId() }]);
+                // /setup handles the empty / parent-folder / scratch-dir case via
+                // its brand-new-empty-project branch in the prompt template.
+                void triggerAutoSetupRef.current();
+            }
+            return;
+        }
+        injectedLanguagesRef.current = detected;
+        try {
+            await replaceSystemPrompt({ cwd, activeLanguages: detected });
+            const verifyCmds = detectVerifyCommands(cwd, detected);
+            const tag = source === "initial" ? "Initial style packs" : "Style pack(s) loaded";
+            log("INFO", "language", `${tag}: ${added.join(", ")}`, {
+                source,
+                active: [...detected].join(","),
+                verify_count: String(verifyCmds.length),
+                verify: verifyCmds.map((c) => `${c.language}:${c.label}=${c.command}`).join(" | "),
+            });
+            // The badge is purely user-facing notification ("hey, this pack just
+            // turned on"). The system prompt is already updated above — that's the
+            // load-bearing part. We persist the announced set per-cwd so /clear,
+            // restart, and new sessions stay quiet for packs the user has seen.
+            const alreadyAnnounced = new Set(getAnnouncedLanguages(cwd));
+            const toAnnounce = added.filter((id) => !alreadyAnnounced.has(id));
+            if (toAnnounce.length > 0) {
+                markLanguagesAnnounced(cwd, toAnnounce);
+                const showSetupHint = !setupHintShownRef.current;
+                setupHintShownRef.current = true;
+                setLiveItems((prev) => [
+                    ...prev,
+                    { kind: "style_pack", added: toAnnounce, showSetupHint, id: getId() },
+                ]);
+            }
+            // First-time-per-project auto-run. Fires only on the initial mount
+            // detection path — not on tool/input triggers — so we don't surprise
+            // users mid-session. Persisted across sessions via setup-history.json.
+            if (source === "initial" && isFirstTimeSetup(cwd)) {
+                markSetupAudited(cwd);
+                void triggerAutoSetupRef.current();
+            }
+        }
+        catch (err) {
+            log("WARN", "language", `Detection apply failed (${source}): ${err.message}`);
+        }
+    };
+    // Initial language detection — runs once on mount so existing projects with
+    // marker files (package.json, Cargo.toml, etc.) get their style packs from
+    // turn 1, with a visible badge.
+    useEffect(() => {
+        void applyLanguageDetectionRef.current("initial");
+    }, []);
     // Rebuild system prompt when plan mode changes
     useEffect(() => {
-        void (async () => {
-            const newPrompt = await buildSystemPrompt(props.cwd, props.skills, planMode, approvedPlanPathRef.current);
-            if (messagesRef.current[0]?.role === "system") {
-                messagesRef.current[0] = {
-                    role: "system",
-                    content: newPrompt,
-                };
-            }
-        })();
-    }, [planMode, props.cwd, props.skills]);
+        void replaceSystemPrompt({ planMode });
+    }, [planMode, replaceSystemPrompt]);
     // Wire onEnterPlan callback ref
     useEffect(() => {
         if (props.onEnterPlanRef) {
@@ -462,8 +613,10 @@ export function App(props) {
         if (props.onExitPlanRef) {
             props.onExitPlanRef.current = async (planPath) => {
                 // Deactivate plan mode, store approved plan path, open pane
+                planModeStateRef.current = false;
                 setPlanMode(false);
                 approvedPlanPathRef.current = planPath;
+                await replaceSystemPrompt({ planMode: false, approvedPlanPath: planPath });
                 // Use setTimeout to open pane after the current tool execution completes,
                 // so the turn can finish and the UI transitions cleanly
                 // Flag that the plan overlay is about to open — suppresses the
@@ -492,43 +645,79 @@ export function App(props) {
                     planPath);
             };
         }
-    }, [props.onExitPlanRef, stdout]);
-    const persistNewMessages = useCallback(async () => {
+    }, [props.onExitPlanRef, replaceSystemPrompt, stdout]);
+    const appendMessagesToSession = useCallback(async (sessionPath, messages, startIndex) => {
+        const sm = sessionManagerRef.current;
+        if (!sm)
+            return;
+        await appendSessionMessages(sm, sessionPath, messages, startIndex);
+    }, []);
+    const persistCompactedSession = useCallback(async (compactedMessages) => {
         const sm = sessionManagerRef.current;
+        if (!sm)
+            return;
+        const session = await createCompactedSessionCheckpoint(sm, {
+            cwd: cwdRef.current,
+            provider: currentProvider,
+            model: currentModel,
+            messages: compactedMessages,
+        });
+        sessionPathRef.current = session.path;
+        persistedIndexRef.current = compactedMessages.length;
+        if (sessionStore) {
+            sessionStore.sessionPath = session.path;
+            sessionStore.messages = [...compactedMessages];
+        }
+        log("INFO", "compaction", "Persisted compacted session checkpoint", { path: session.path });
+    }, [currentModel, currentProvider, sessionStore]);
+    const persistNewMessages = useCallback(async () => {
         const sp = sessionPathRef.current;
-        if (!sm || !sp)
+        if (!sp)
             return;
         const allMsgs = messagesRef.current;
-        for (let i = persistedIndexRef.current; i < allMsgs.length; i++) {
-            const msg = allMsgs[i];
-            if (msg.role === "system")
-                continue;
-            const entry = {
-                type: "message",
-                id: crypto.randomUUID(),
-                parentId: null,
-                timestamp: new Date().toISOString(),
-                message: msg,
-            };
-            await sm.appendEntry(sp, entry);
-        }
+        await appendMessagesToSession(sp, allMsgs, persistedIndexRef.current);
         persistedIndexRef.current = allMsgs.length;
-    }, []);
+        if (sessionStore) {
+            sessionStore.messages = [...allMsgs];
+            sessionStore.sessionPath = sp;
+        }
+    }, [appendMessagesToSession, sessionStore]);
+    /**
+     * Run the language detector against the current cwd. If the detected set is a
+     * strict superset of what's already injected, rebuild the system prompt with
+     * the expanded set and swap `messagesRef.current[0]`.
+     *
+     * Called from `onToolEnd` after `write`/`bash` succeeds — these are the only
+     * tools that can introduce new marker files (package.json, Cargo.toml, etc.).
+     * Other tool kinds skip detection entirely to avoid wasted filesystem stats.
+     *
+     * No restart required: the system prompt is mutated in place, same mechanism
+     * already used for plan mode + pixel-fix chdir.
+     *
+     * Stored in a ref so `onToolEnd` (whose useCallback dep array is intentionally
+     * empty to keep agent-loop options stable) can call the freshest version.
+     */
+    const maybeInjectLanguagePacksRef = useRef(async () => { });
+    maybeInjectLanguagePacksRef.current = async (toolName, isError) => {
+        if (isError)
+            return;
+        if (toolName !== "write" && toolName !== "bash")
+            return;
+        await applyLanguageDetectionRef.current("tool");
+    };
     // ── Compaction ─────────────────────────────────────────
-    // Load settings for auto-compaction + buddy
+    // Load settings for auto-compaction
     const settingsRef = useRef(null);
-    const [buddyEnabled, setBuddyEnabled] = useState(false);
     useEffect(() => {
         if (props.settingsFile) {
             const sm = new SettingsManager(props.settingsFile);
             sm.load().then(() => {
                 settingsRef.current = sm;
-                setBuddyEnabled(sm.get("buddyEnabled") ?? false);
             });
         }
     }, [props.settingsFile]);
     const compactConversation = useCallback(async (messages) => {
-        const contextWindow = getContextWindow(currentModel);
+        const contextWindow = getContextWindow(currentModel, contextWindowOptions);
         const tokensBefore = estimateConversationTokens(messages);
         const spinId = getId();
         log("INFO", "compaction", `Running compaction`, {
@@ -541,14 +730,20 @@ export function App(props) {
         try {
             // Resolve fresh credentials for compaction too
             let compactApiKey = activeApiKey;
+            let compactAccountId = activeAccountId;
+            let compactBaseUrl = activeBaseUrl;
             if (props.authStorage) {
                 const creds = await props.authStorage.resolveCredentials(currentProvider);
                 compactApiKey = creds.accessToken;
+                compactAccountId = creds.accountId;
+                compactBaseUrl = creds.baseUrl ?? compactBaseUrl;
             }
             const result = await compact(messages, {
                 provider: currentProvider,
                 model: currentModel,
                 apiKey: compactApiKey,
+                accountId: compactAccountId,
+                baseUrl: compactBaseUrl,
                 contextWindow,
                 signal: undefined,
                 approvedPlanPath: approvedPlanPathRef.current,
@@ -577,65 +772,118 @@ export function App(props) {
             const msg = err instanceof Error ? err.message : String(err);
             log("ERROR", "compaction", `Compaction failed: ${msg}`);
             // Replace spinner with error
-            setLiveItems((prev) => prev.map((item) => item.id === spinId
-                ? { kind: "error", message: `Compaction failed: ${msg}`, id: spinId }
-                : item));
+            setLiveItems((prev) => prev.map((item) => item.id === spinId ? toErrorItem(err, spinId, "Compaction failed") : item));
             return messages; // Return unchanged on failure
         }
-    }, [currentModel, currentProvider, activeApiKey]);
+    }, [
+        currentModel,
+        currentProvider,
+        activeApiKey,
+        activeAccountId,
+        activeBaseUrl,
+        contextWindowOptions,
+        props.authStorage,
+    ]);
+    const getRepoMapSignalCount = useCallback(() => {
+        return ((props.repoMapChangedFilesRef?.current.size ?? 0) +
+            (props.repoMapReadFilesRef?.current.size ?? 0));
+    }, [props.repoMapChangedFilesRef, props.repoMapReadFilesRef]);
+    const getRepoMapBudget = useCallback(() => {
+        const userTurns = messagesRef.current.filter((message) => message.role === "user").length;
+        const readCount = props.repoMapReadFilesRef?.current.size ?? 0;
+        if (userTurns <= 1 && readCount === 0)
+            return FIRST_TURN_REPO_MAP_MAX_CHARS;
+        if (readCount > 0)
+            return FOCUSED_REPO_MAP_MAX_CHARS;
+        return FOCUSED_REPO_MAP_MAX_CHARS + 1000;
+    }, [props.repoMapReadFilesRef]);
+    const refreshRepoMap = useCallback(async (latestUserPrompt) => {
+        const rendered = await buildRepoMap({
+            cwd: cwdRef.current,
+            maxChars: getRepoMapBudget(),
+            changedFiles: [...(props.repoMapChangedFilesRef?.current ?? new Set())],
+            readFiles: [...(props.repoMapReadFilesRef?.current ?? new Set())],
+            focusTerms: latestUserPrompt ? [latestUserPrompt] : [],
+            cache: repoMapCacheRef.current,
+        });
+        repoMapMarkdownRef.current = rendered.markdown;
+        repoMapSnapshotRef.current = rendered.snapshot;
+        repoMapChangedCountRef.current = getRepoMapSignalCount();
+        repoMapDirtyRef.current = false;
+        return rendered.markdown;
+    }, [
+        getRepoMapBudget,
+        getRepoMapSignalCount,
+        props.repoMapChangedFilesRef,
+        props.repoMapReadFilesRef,
+    ]);
+    const stripRepoMapMessages = useCallback((messages) => {
+        return stripRepoMapContextMessages(messages);
+    }, []);
+    const injectRepoMapContext = useCallback(async (messages) => {
+        if (!repoMapInjectionEnabledRef.current)
+            return stripRepoMapMessages(messages);
+        const stripped = stripRepoMapMessages(messages);
+        const latestUserPrompt = getLatestUserText(stripped);
+        const signalCount = getRepoMapSignalCount();
+        if (signalCount !== repoMapChangedCountRef.current)
+            repoMapDirtyRef.current = true;
+        if (repoMapDirtyRef.current || !repoMapMarkdownRef.current) {
+            await refreshRepoMap(latestUserPrompt);
+        }
+        if (!repoMapMarkdownRef.current)
+            return stripped;
+        return injectRepoMapContextMessages(stripped, repoMapMarkdownRef.current);
+    }, [props.repoMapChangedFilesRef, props.repoMapReadFilesRef, refreshRepoMap, stripRepoMapMessages]);
     /**
      * transformContext callback for the agent loop.
      * Called before each LLM call and on context overflow.
-     * Checks if auto-compaction is needed and runs it.
-     *
-     * Uses actual API-reported token counts (from previous turn_end) when
-     * available, falling back to the character-based estimate. A 30-second
-     * cooldown prevents repeated compaction — matching the pattern used by
-     * Mysti, openclaw, and other real-world agent frameworks.
+     * Compacts persistent chat only, then injects the dynamic repo map transiently.
      */
     const transformContext = useCallback(async (messages, options) => {
+        const stripped = stripRepoMapMessages(messages);
         const settings = settingsRef.current;
         const autoCompact = settings?.get("autoCompact") ?? true;
         const threshold = settings?.get("compactThreshold") ?? 0.8;
         // Force-compact on context overflow regardless of settings
         if (options?.force) {
-            const result = await compactConversation(messages);
+            const result = await compactConversation(stripped);
+            if (result !== stripped) {
+                messagesRef.current = result;
+                await persistCompactedSession(result);
+            }
             lastCompactionTimeRef.current = Date.now();
-            return result;
+            return injectRepoMapContext(result);
         }
         if (!autoCompact)
-            return messages;
+            return injectRepoMapContext(stripped);
         // Time-based cooldown: skip if compaction ran within the last 30 seconds
         if (Date.now() - lastCompactionTimeRef.current < 30_000) {
             log("INFO", "compaction", `Skipping compaction — cooldown active`);
-            return messages;
+            return injectRepoMapContext(stripped);
         }
-        const contextWindow = getContextWindow(currentModel);
-        // Reserve = max output budget + ~5K headroom for system prompt + tool
-        // schemas. Otherwise the API rejects requests where the prompt fits the
-        // window but leaves no room for the response (e.g. Codex Mini at 200K
-        // ctx / 100K out — pre-turn estimate may say 160K but a 100K reasoning
-        // response then overflows).
-        const modelInfo = getModel(currentModel);
-        const reserveTokens = (modelInfo?.maxOutputTokens ?? 0) + 5_000;
-        // Prefer actual API-reported tokens over char-based estimate, but only
-        // when the token count was recorded AFTER the most recent compaction.
-        // A count from before compaction is stale — it reflects the old context
-        // size and would trigger compaction again immediately for no reason.
+        const contextWindow = getContextWindow(currentModel, contextWindowOptions);
+        const reserveTokens = getCompactionReserveTokens(props.maxTokens);
         const tokensFresh = lastActualTokensTimestampRef.current > lastCompactionTimeRef.current;
         const actualTokens = lastActualTokensRef.current > 0 && tokensFresh ? lastActualTokensRef.current : undefined;
-        if (shouldCompact(messages, contextWindow, threshold, actualTokens, reserveTokens)) {
-            const before = messages.length;
-            const result = await compactConversation(messages);
+        if (shouldCompact(stripped, contextWindow, threshold, actualTokens, reserveTokens)) {
+            const result = await compactConversation(stripped);
+            if (result !== stripped) {
+                messagesRef.current = result;
+                await persistCompactedSession(result);
+            }
             lastCompactionTimeRef.current = Date.now();
-            // If compaction was a no-op (e.g. too few middle messages to summarize),
-            // return the original reference so the agent loop doesn't replace messages.
-            if (result.length === before)
-                return messages;
-            return result;
+            return injectRepoMapContext(result);
         }
-        return messages;
-    }, [currentModel, compactConversation]);
+        return injectRepoMapContext(stripped);
+    }, [
+        currentModel,
+        compactConversation,
+        contextWindowOptions,
+        injectRepoMapContext,
+        persistCompactedSession,
+        stripRepoMapMessages,
+    ]);
     // ── Background task bar state (external store) ──────────
     const { bgTasks, focused: taskBarFocused, expanded: taskBarExpanded, selectedIndex: selectedTaskIndex, } = useTaskBarStore();
     useTaskBarPolling(props.processManager);
@@ -663,7 +911,7 @@ export function App(props) {
         tools: currentTools,
         webSearch: props.webSearch,
         maxTokens: props.maxTokens,
-        thinking: thinkingEnabled ? (props.thinking ?? "medium") : undefined,
+        thinking: thinkingEnabled ? getMaxThinkingLevel(currentModel) : undefined,
         apiKey: activeApiKey,
         baseUrl: activeBaseUrl,
         accountId: activeAccountId,
@@ -671,6 +919,7 @@ export function App(props) {
         transformContext,
     }, {
         onComplete: useCallback(() => {
+            messagesRef.current = stripRepoMapMessages(messagesRef.current);
             persistNewMessages();
             // Auto-clear plan progress and approved plan when all steps are completed
             const steps = planStepsRef.current;
@@ -679,12 +928,7 @@ export function App(props) {
                 setPlanSteps([]);
                 approvedPlanPathRef.current = undefined;
                 // Rebuild system prompt to remove the completed plan from context
-                void (async () => {
-                    const newPrompt = await buildSystemPrompt(props.cwd, props.skills, planMode, undefined);
-                    if (messagesRef.current[0]?.role === "system") {
-                        messagesRef.current[0] = { role: "system", content: newPrompt };
-                    }
-                })();
+                void replaceSystemPrompt({ clearApprovedPlan: true });
             }
             // Generate session title after the first turn (background, best-effort)
             if (!sessionTitleGeneratedRef.current) {
@@ -728,6 +972,7 @@ export function App(props) {
             }
         }, [
             persistNewMessages,
+            stripRepoMapMessages,
             planMode,
             props.cwd,
             props.skills,
@@ -747,6 +992,9 @@ export function App(props) {
                         planStepsRef.current = updated;
                         setPlanSteps(updated);
                     }
+                    // Real progress happened — reset the stuck-guard so the next
+                    // step gets its own fresh nudge budget.
+                    followUpNudgesRef.current = { step: 0, count: 0 };
                 }
             }
             // Flush all completed items from the previous turn to Static history.
@@ -814,6 +1062,8 @@ export function App(props) {
         }, []),
         onToolStart: useCallback((toolCallId, name, args) => {
             log("INFO", "tool", `Tool call started: ${name}`, { id: toolCallId });
+            const startedAt = Date.now();
+            const animateUntil = startedAt + RUNNING_INDICATOR_ANIMATION_MS;
             // Flush completed items (assistant text, finished tools) to Static
             // before adding tool UI. Keeping both in the live area makes it tall
             // and causes Ink's cursor math to clip the top.
@@ -859,7 +1109,10 @@ export function App(props) {
                         const next = [...prev];
                         next[groupIdx] = {
                             ...group,
-                            tools: [...group.tools, { toolCallId, name, args, status: "running" }],
+                            tools: [
+                                ...group.tools,
+                                { toolCallId, name, args, status: "running", animateUntil },
+                            ],
                         };
                         return next;
                     }
@@ -867,7 +1120,7 @@ export function App(props) {
                         ...prev,
                         {
                             kind: "tool_group",
-                            tools: [{ toolCallId, name, args, status: "running" }],
+                            tools: [{ toolCallId, name, args, status: "running", animateUntil }],
                             id: getId(),
                         },
                     ];
@@ -876,7 +1129,7 @@ export function App(props) {
             else {
                 setLiveItems((prev) => [
                     ...prev,
-                    { kind: "tool_start", toolCallId, name, args, id: getId() },
+                    { kind: "tool_start", toolCallId, name, args, id: getId(), startedAt, animateUntil },
                 ]);
             }
         }, []),
@@ -921,6 +1174,10 @@ export function App(props) {
             });
         }, []),
         onToolEnd: useCallback((toolCallId, name, result, isError, durationMs, details) => {
+            // Language-pack detection — gated on `write`/`bash` inside the
+            // helper; cheap to call unconditionally. Fire-and-forget; the next
+            // LLM turn picks up the swapped system prompt automatically.
+            void maybeInjectLanguagePacksRef.current(name, isError);
             const level = isError ? "ERROR" : "INFO";
             log(level, "tool", `Tool call ended: ${name}`, {
                 id: toolCallId,
@@ -1025,6 +1282,8 @@ export function App(props) {
         }, []),
         onServerToolCall: useCallback((id, name, input) => {
             log("INFO", "server_tool", `Server tool call: ${name}`, { id });
+            const startedAt = Date.now();
+            const animateUntil = startedAt + RUNNING_INDICATOR_ANIMATION_MS;
             // Flush completed items (including assistant text) to Static before
             // adding server tool UI — same rationale as onToolStart.
             setLiveItems((prev) => {
@@ -1039,7 +1298,8 @@ export function App(props) {
                         serverToolCallId: id,
                         name,
                         input,
-                        startedAt: Date.now(),
+                        startedAt,
+                        animateUntil,
                         id: getId(),
                     },
                 ];
@@ -1230,7 +1490,7 @@ export function App(props) {
                     }
                     return item;
                 });
-                return [...next, { kind: "info", text: "Request was stopped.", id: getId() }];
+                return [...next, { kind: "stopped", text: "Request was stopped.", id: getId() }];
             });
         }, []),
         onQueuedStart: useCallback((content) => {
@@ -1260,7 +1520,75 @@ export function App(props) {
             setDoneStatus(null);
             setLiveItems([userItem]);
         }, []),
+        // Inject a "continue with the next step" follow-up when the agent
+        // would otherwise stop mid-plan. The prompt-only instruction wasn't
+        // enough — some models (notably Opus) treat each [DONE:n] as a
+        // natural completion boundary regardless. The stuck-guard caps
+        // nudges per step so a genuinely blocked agent surfaces.
+        getFollowUpMessages: useCallback(() => {
+            const steps = planStepsRef.current;
+            if (steps.length === 0 || !approvedPlanPathRef.current)
+                return null;
+            const next = steps.find((s) => !s.completed);
+            if (!next)
+                return null;
+            const r = followUpNudgesRef.current;
+            if (r.step !== next.step) {
+                r.step = next.step;
+                r.count = 0;
+            }
+            if (r.count >= 2)
+                return null;
+            r.count++;
+            return [
+                {
+                    role: "user",
+                    content: `Continue with step ${next.step}: ${next.text}. ` +
+                        `Emit [DONE:${next.step}] when done, then proceed to step ${next.step + 1} ` +
+                        `in the same turn. Only stop when every step in \`## Steps\` is complete ` +
+                        `or you genuinely need user input.`,
+                },
+            ];
+        }, []),
     });
+    // First-time-per-project auto-run of /setup. Bound after `agentLoop` is in
+    // scope so the ref closure can dispatch to it. Called from the initial
+    // language-detection path when `isFirstTimeSetup(cwd)` is true. Pushes a
+    // notice item explaining what's happening, then runs the audit prompt.
+    triggerAutoSetupRef.current = async () => {
+        const setupCmd = getPromptCommand("setup");
+        if (!setupCmd) {
+            log("WARN", "setup", "Auto-setup skipped — /setup command not found in registry.");
+            return;
+        }
+        log("INFO", "setup", `Auto-running /setup (first session for ${cwdRef.current})`);
+        setLiveItems((prev) => [
+            ...prev,
+            {
+                kind: "info",
+                text: "First time in this project — auto-running /setup to audit hygiene, tooling, and style-pack alignment. " +
+                    "Press Esc to cancel.",
+                id: getId(),
+            },
+            { kind: "user", text: "/setup", id: getId() },
+        ]);
+        setLastUserMessage("/setup");
+        setDoneStatus(null);
+        try {
+            await agentLoop.run(setupCmd.prompt);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const isAbort = msg.includes("aborted") || msg.includes("abort");
+            log(isAbort ? "INFO" : "ERROR", "setup", `Auto-setup ended: ${msg}`);
+            setLiveItems((prev) => [
+                ...prev,
+                isAbort
+                    ? { kind: "stopped", text: "Auto-setup cancelled.", id: getId() }
+                    : toErrorItem(err, getId()),
+            ]);
+        }
+    };
     // Phase 2 of the two-phase flush: after onDone clears liveItems (phase 1)
     // and Ink renders the smaller live area (updating its internal line
     // counter), this effect pushes the stashed items into Static history.
@@ -1279,6 +1607,29 @@ export function App(props) {
     useEffect(() => {
         setTitleRunning(agentLoop.isRunning);
     }, [agentLoop.isRunning]);
+    // Mirror agent running state into sessionStore so renderApp's resize
+    // handler and overlay toggles can skip their unmount/remount while the
+    // agent is in flight (unmounting fires useAgentLoop's cleanup which
+    // aborts the in-flight request). On the running→idle transition,
+    // consume any pendingResetUI flag set during the run by scheduling a
+    // deferred resetUI to clean up accumulated log-update drift. The 100ms
+    // setTimeout lets onDone's two-phase flush commit to sessionStore.history
+    // first, so the chat isn't lost. The cleanup also bails if the user
+    // started a new run before the timer fires, to avoid aborting it.
+    useEffect(() => {
+        if (!sessionStore)
+            return;
+        sessionStore.isAgentRunning = agentLoop.isRunning;
+        if (!agentLoop.isRunning && sessionStore.pendingResetUI) {
+            sessionStore.pendingResetUI = false;
+            const timer = setTimeout(() => {
+                if (sessionStore.isAgentRunning)
+                    return;
+                props.resetUI?.();
+            }, 100);
+            return () => clearTimeout(timer);
+        }
+    }, [agentLoop.isRunning, sessionStore, props.resetUI]);
     // Consume sessionStore.pendingAction once on mount. Set by resetUI options
     // for paths that remount AND immediately drive the agent (plan accept,
     // plan reject, startTask, pixel fix). The action survives the unmount
@@ -1292,7 +1643,14 @@ export function App(props) {
         pendingActionConsumedRef.current = true;
         if (sessionStore)
             sessionStore.pendingAction = undefined;
-        if (action.infoText) {
+        if (action.planEvent) {
+            const ev = action.planEvent;
+            setLiveItems((prev) => [
+                ...prev,
+                { kind: "plan_event", event: ev.event, detail: ev.detail, id: getId() },
+            ]);
+        }
+        else if (action.infoText) {
             setLiveItems((prev) => [
                 ...prev,
                 { kind: "info", text: action.infoText, id: getId() },
@@ -1302,7 +1660,7 @@ export function App(props) {
         void agentLoop.run(action.prompt).catch((err) => {
             const errMsg = err instanceof Error ? err.message : String(err);
             log("ERROR", "error", errMsg);
-            setLiveItems((prev) => [...prev, { kind: "error", message: errMsg, id: getId() }]);
+            setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
         });
         // Intentional one-shot: run once on mount, never re-fire on re-render.
     }, []);
@@ -1314,12 +1672,6 @@ export function App(props) {
             setEyesCount(isEyesActive(props.cwd) ? journalCount({ status: "open" }, props.cwd) : undefined);
         }
     }, [agentLoop.isRunning, props.cwd]);
-    // Animated thinking border — derived from global animation tick
-    useAnimationActive();
-    const animTick = useAnimationTick();
-    const thinkingBorderFrame = agentLoop.activityPhase === "thinking"
-        ? deriveFrame(animTick, 1000, THINKING_BORDER_COLORS.length)
-        : 0;
     const handleSubmit = useCallback(async (input, inputImages = [], pasteInfo) => {
         const trimmed = input.trim();
         if (trimmed.startsWith("/")) {
@@ -1328,6 +1680,11 @@ export function App(props) {
         else {
             const truncated = trimmed.length > 100 ? trimmed.slice(0, 100) + "..." : trimmed;
             log("INFO", "input", `User input: ${truncated}${inputImages.length > 0 ? ` (+${inputImages.length} image${inputImages.length > 1 ? "s" : ""})` : ""}`);
+            // Re-detect on every user submit — cheap (fs stats only). Catches
+            // external changes between turns and ensures non-writing prompts still
+            // surface the badge when packs are newly applicable. No-op if the set
+            // has not grown.
+            await applyLanguageDetectionRef.current("input");
         }
         // Handle /model directly — open inline selector
         if (trimmed === "/model" || trimmed === "/m") {
@@ -1339,7 +1696,7 @@ export function App(props) {
             const compacted = await compactConversation(messagesRef.current);
             if (compacted !== messagesRef.current) {
                 messagesRef.current = compacted;
-                persistedIndexRef.current = 0; // Re-persist after compaction
+                await persistCompactedSession(compacted);
             }
             return;
         }
@@ -1359,7 +1716,7 @@ export function App(props) {
         if (trimmed === "/clear") {
             if (props.resetUI) {
                 void (async () => {
-                    const newPrompt = await buildSystemPrompt(props.cwd, props.skills, planMode, undefined);
+                    const newPrompt = await rebuildSystemPrompt({ clearApprovedPlan: true });
                     props.resetUI?.({
                         wipeSession: true,
                         messages: [{ role: "system", content: newPrompt }],
@@ -1378,7 +1735,7 @@ export function App(props) {
             planStepsRef.current = [];
             setPlanSteps([]);
             void (async () => {
-                const newPrompt = await buildSystemPrompt(props.cwd, props.skills, planMode, undefined);
+                const newPrompt = await rebuildSystemPrompt({ clearApprovedPlan: true });
                 messagesRef.current = [{ role: "system", content: newPrompt }];
                 persistedIndexRef.current = messagesRef.current.length;
             })();
@@ -1440,29 +1797,46 @@ export function App(props) {
             planStepsRef.current = [];
             setPlanSteps([]);
             // Rebuild system prompt without the plan
-            void (async () => {
-                const newPrompt = await buildSystemPrompt(props.cwd, props.skills, planMode, undefined);
-                if (messagesRef.current[0]?.role === "system") {
-                    messagesRef.current[0] = { role: "system", content: newPrompt };
-                }
-            })();
-            setLiveItems([{ kind: "info", text: "Approved plan dismissed.", id: getId() }]);
+            void replaceSystemPrompt({ clearApprovedPlan: true });
+            setLiveItems([{ kind: "plan_event", event: "dismissed", id: getId() }]);
             return;
         }
-        // Handle /buddy — toggle companion
-        if (trimmed === "/buddy") {
-            const next = !buddyEnabled;
-            setBuddyEnabled(next);
-            if (settingsRef.current) {
-                settingsRef.current.set("buddyEnabled", next);
+        // Handle /map — show, refresh, or toggle dynamic repo map injection
+        if (trimmed === "/map" ||
+            trimmed === "/map refresh" ||
+            trimmed === "/map on" ||
+            trimmed === "/map off") {
+            const action = trimmed.slice("/map".length).trim();
+            if (action === "on") {
+                repoMapInjectionEnabledRef.current = true;
+                repoMapDirtyRef.current = true;
+                setLiveItems((prev) => [
+                    ...prev,
+                    { kind: "info", text: "Dynamic repo map injection is on.", id: getId() },
+                ]);
+                return;
             }
-            setLiveItems((items) => [
-                ...items,
+            if (action === "off") {
+                repoMapInjectionEnabledRef.current = false;
+                messagesRef.current = stripRepoMapMessages(messagesRef.current);
+                setLiveItems((prev) => [
+                    ...prev,
+                    {
+                        kind: "info",
+                        text: "Dynamic repo map injection is off for this session.",
+                        id: getId(),
+                    },
+                ]);
+                return;
+            }
+            if (action === "refresh")
+                repoMapDirtyRef.current = true;
+            const markdown = await refreshRepoMap(getLatestUserText(messagesRef.current));
+            setLiveItems((prev) => [
+                ...prev,
                 {
                     kind: "info",
-                    text: next
-                        ? "Buddy enabled! Your companion will appear near the prompt."
-                        : "Buddy disabled.",
+                    text: formatRepoMapCommandOutput(repoMapInjectionEnabledRef.current, markdown, action === "refresh"),
                     id: getId(),
                 },
             ]);
@@ -1470,13 +1844,18 @@ export function App(props) {
         }
         // Handle /plans — open plan pane
         if (trimmed === "/plans") {
-            if (props.resetUI && props.sessionStore) {
+            if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
                 props.sessionStore.overlay = "plan";
                 props.sessionStore.planAutoExpand = false;
                 props.resetUI();
             }
             else {
-                stdout?.write("\x1b[2J\x1b[3J\x1b[H");
+                if (props.sessionStore) {
+                    props.sessionStore.overlay = "plan";
+                    props.sessionStore.planAutoExpand = false;
+                    if (agentLoop.isRunning)
+                        props.sessionStore.pendingResetUI = true;
+                }
                 setPlanAutoExpand(false);
                 setOverlay("plan");
             }
@@ -1518,8 +1897,8 @@ export function App(props) {
                     setLiveItems((prev) => [
                         ...prev,
                         isAbort
-                            ? { kind: "info", text: "Request was stopped.", id: getId() }
-                            : { kind: "error", message: msg, id: getId() },
+                            ? { kind: "stopped", text: "Request was stopped.", id: getId() }
+                            : toErrorItem(err, getId()),
                     ]);
                 }
                 // Reload custom commands in case a setup command created new ones
@@ -1642,11 +2021,19 @@ export function App(props) {
             setLiveItems((prev) => [
                 ...prev,
                 isAbort
-                    ? { kind: "info", text: "Request was stopped.", id: getId() }
-                    : { kind: "error", message: msg, id: getId() },
+                    ? { kind: "stopped", text: "Request was stopped.", id: getId() }
+                    : toErrorItem(err, getId()),
             ]);
         }
-    }, [agentLoop, props.onSlashCommand, compactConversation]);
+    }, [
+        agentLoop,
+        props.onSlashCommand,
+        compactConversation,
+        rebuildSystemPrompt,
+        replaceSystemPrompt,
+        refreshRepoMap,
+        stripRepoMapMessages,
+    ]);
     const handleDoubleExit = useDoublePress(setExitPending, () => process.exit(0));
     const handleAbort = useCallback(() => {
         if (agentLoop.isRunning) {
@@ -1663,7 +2050,7 @@ export function App(props) {
             log("INFO", "thinking", `Thinking ${next ? "enabled" : "disabled"}`);
             setLiveItems((items) => [
                 ...items,
-                { kind: "info", text: `Thinking ${next ? "on" : "off"}`, id: getId() },
+                { kind: "thinking_transition", active: next, id: getId() },
             ]);
             if (props.settingsFile) {
                 const sm = new SettingsManager(props.settingsFile);
@@ -1680,6 +2067,10 @@ export function App(props) {
         const newProvider = value.slice(0, colonIdx);
         const newModelId = value.slice(colonIdx + 1);
         log("INFO", "model", `Model changed`, { provider: newProvider, model: newModelId });
+        const rebuildPromptWithTools = (tools) => {
+            currentToolsRef.current = tools;
+            void replaceSystemPrompt({ tools });
+        };
         // Handle provider-specific tool changes when provider changes
         setCurrentProvider((prevProvider) => {
             if (newProvider !== prevProvider) {
@@ -1687,15 +2078,17 @@ export function App(props) {
                 // Anthropic has native server-side web search; all other providers need the client tool.
                 setCurrentTools((prev) => {
                     const hasWebSearch = prev.some((t) => t.name === "web_search");
+                    let next = prev;
                     if (newProvider === "anthropic" && hasWebSearch) {
                         // Switching TO anthropic — remove client-side web_search (server-side handles it)
-                        return prev.filter((t) => t.name !== "web_search");
+                        next = prev.filter((t) => t.name !== "web_search");
                     }
                     else if (newProvider !== "anthropic" && !hasWebSearch) {
                         // Switching FROM anthropic — add client-side web_search
-                        return [...prev, createWebSearchTool()];
+                        next = [...prev, createWebSearchTool()];
                     }
-                    return prev;
+                    rebuildPromptWithTools(next);
+                    return next;
                 });
                 // Reconnect MCP servers
                 if (props.mcpManager) {
@@ -1718,16 +2111,21 @@ export function App(props) {
                         }
                         try {
                             const mcpTools = await props.mcpManager.connectAll(getMCPServers(newProvider, apiKey));
-                            setCurrentTools((prev) => [
-                                ...prev.filter((t) => !t.name.startsWith("mcp__")),
-                                ...mcpTools,
-                            ]);
+                            setCurrentTools((prev) => {
+                                const next = [...prev.filter((t) => !t.name.startsWith("mcp__")), ...mcpTools];
+                                rebuildPromptWithTools(next);
+                                return next;
+                            });
                             log("INFO", "mcp", `MCP servers reconnected for provider ${newProvider}`);
                         }
                         catch (err) {
                             log("WARN", "mcp", `MCP reconnection failed: ${err instanceof Error ? err.message : String(err)}`);
                             // Still remove old MCP tools even if reconnection fails
-                            setCurrentTools((prev) => prev.filter((t) => !t.name.startsWith("mcp__")));
+                            setCurrentTools((prev) => {
+                                const next = prev.filter((t) => !t.name.startsWith("mcp__"));
+                                rebuildPromptWithTools(next);
+                                return next;
+                            });
                         }
                     })();
                 }
@@ -1739,7 +2137,7 @@ export function App(props) {
         const displayName = modelInfo?.name ?? newModelId;
         setLiveItems((prev) => [
             ...prev,
-            { kind: "info", text: `Switched to ${displayName}`, id: getId() },
+            { kind: "model_transition", modelName: displayName, id: getId() },
         ]);
         // Persist model selection for next CLI launch
         if (props.settingsFile) {
@@ -1760,10 +2158,7 @@ export function App(props) {
             const sm = new SettingsManager(props.settingsFile);
             sm.load().then(() => sm.set("theme", name));
         }
-        setLiveItems((prev) => [
-            ...prev,
-            { kind: "info", text: `Theme switched to: ${name}`, id: getId() },
-        ]);
+        setLiveItems((prev) => [...prev, { kind: "theme_transition", themeName: name, id: getId() }]);
     }, [switchTheme, props.settingsFile]);
     // All available slash commands for the command palette — ordered by how
     // commonly they're used and grouped by purpose; /quit stays dead last.
@@ -1779,6 +2174,8 @@ export function App(props) {
             "research",
             "scan",
             "verify",
+            "expand",
+            "bullet-proof",
             "simplify",
             "compare",
             "batch",
@@ -1823,21 +2220,28 @@ export function App(props) {
                 return (_jsx(UserMessage, { text: item.text, imageCount: item.imageCount, pasteInfo: item.pasteInfo }, item.id));
             case "task":
                 return (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: theme.success, bold: true, children: "▶ " }), _jsx(Text, { color: theme.textDim, children: "Task: " }), _jsx(Text, { color: theme.success, children: item.title })] }) }, item.id));
+            case "style_pack": {
+                const names = item.added.map((id) => LANGUAGE_DISPLAY_NAMES[id]);
+                const headerLabel = item.added.length > 1 ? "STYLE PACKS ACTIVE" : "STYLE PACK ACTIVE";
+                return (_jsxs(Box, { marginTop: 1, flexShrink: 1, flexDirection: "column", borderStyle: "round", borderColor: theme.language, paddingX: 1, children: [_jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: theme.language, bold: true, children: "◆ " }), _jsx(Text, { color: theme.language, bold: true, children: headerLabel })] }), _jsx(Text, { color: theme.text, bold: true, wrap: "wrap", children: names.join(", ") }), item.showSetupHint && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: theme.textMuted, children: "Tip: run " }), _jsx(Text, { color: theme.language, bold: true, children: "/setup" }), _jsx(Text, { color: theme.textMuted, children: " to audit this project against the active pack(s)" })] }) }))] }, item.id));
+            }
+            case "setup_hint":
+                return (_jsxs(Box, { marginTop: 1, flexShrink: 1, flexDirection: "column", borderStyle: "round", borderColor: theme.language, paddingX: 1, children: [_jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: theme.language, bold: true, children: "◆ " }), _jsx(Text, { color: theme.language, bold: true, children: "NO STYLE PACKS DETECTED" })] }), _jsx(Text, { color: theme.textMuted, wrap: "wrap", children: "This directory has no recognized language manifest at its root." }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: theme.textMuted, children: "Tip: run " }), _jsx(Text, { color: theme.language, bold: true, children: "/setup" }), _jsx(Text, { color: theme.textMuted, children: " to audit project hygiene or bootstrap a new project from scratch" })] }) })] }, item.id));
             case "assistant":
-                return (_jsx(AssistantMessage, { text: item.text, thinking: item.thinking, thinkingMs: item.thinkingMs, showThinking: props.showThinking, planMode: item.planMode }, item.id));
+                return (_jsx(AssistantMessage, { text: item.text, thinking: item.thinking, thinkingMs: item.thinkingMs, planMode: item.planMode }, item.id));
             case "tool_start":
-                return (_jsx(ToolExecution, { status: "running", name: item.name, args: item.args, progressOutput: item.progressOutput }, item.id));
+                return (_jsx(ToolExecution, { status: "running", name: item.name, args: item.args, progressOutput: item.progressOutput, animateUntil: item.animateUntil }, item.id));
             case "tool_done":
                 return (_jsx(ToolExecution, { status: "done", name: item.name, args: item.args, result: item.result, isError: item.isError, details: item.details }, item.id));
             case "tool_group":
                 return _jsx(ToolGroupExecution, { tools: item.tools }, item.id);
             case "server_tool_start":
-                return (_jsx(ServerToolExecution, { status: "running", name: item.name, input: item.input, startedAt: item.startedAt }, item.id));
+                return (_jsx(ServerToolExecution, { status: "running", name: item.name, input: item.input, startedAt: item.startedAt, animateUntil: item.animateUntil }, item.id));
             case "server_tool_done":
                 return (_jsx(ServerToolExecution, { status: "done", name: item.name, input: item.input, durationMs: item.durationMs, resultType: item.resultType }, item.id));
             case "error": {
-                const providerHint = getProviderErrorHint(item.message);
-                return (_jsxs(Box, { marginTop: 1, flexDirection: "column", flexShrink: 1, children: [_jsxs(Text, { color: theme.error, wrap: "wrap", children: ["✗ ", item.message] }), providerHint && (_jsxs(Text, { color: theme.textDim, wrap: "wrap", children: ["  Hint: ", providerHint] }))] }, item.id));
+                const showMessage = item.message && item.message !== item.headline;
+                return (_jsxs(Box, { marginTop: 1, flexDirection: "column", flexShrink: 1, children: [_jsxs(Text, { color: theme.error, wrap: "wrap", children: ["✗ ", item.headline] }), showMessage && (_jsx(Text, { color: theme.textDim, wrap: "wrap", children: `  ${item.message}` })), _jsx(Text, { color: theme.textDim, wrap: "wrap", children: `  → ${item.guidance}` })] }, item.id));
             }
             case "info":
                 return (_jsx(Box, { marginTop: 1, flexShrink: 1, children: _jsx(Text, { color: theme.textDim, wrap: "wrap", children: item.text }) }, item.id));
@@ -1845,6 +2249,34 @@ export function App(props) {
                 return (_jsx(Box, { marginTop: 1, flexShrink: 1, borderStyle: "round", borderColor: theme.success, paddingX: 1, children: _jsxs(Text, { color: theme.success, bold: true, wrap: "wrap", children: ["✨ ", item.text] }) }, item.id));
             case "plan_transition":
                 return (_jsx(Box, { marginTop: 1, flexShrink: 1, children: _jsxs(Text, { color: theme.planPrimary, bold: true, wrap: "wrap", children: [item.active ? "● " : "● ", item.text] }) }, item.id));
+            case "thinking_transition": {
+                const glyphColor = item.active ? THINKING_BORDER_COLORS[0] : theme.textDim;
+                return (_jsxs(Box, { marginTop: 1, flexShrink: 1, children: [_jsx(Text, { color: glyphColor, bold: true, children: "✻ " }), _jsx(Text, { color: item.active ? theme.accent : theme.textDim, bold: true, children: item.active ? "Thinking ON" : "Thinking OFF" })] }, item.id));
+            }
+            case "model_transition": {
+                const glyphColor = THINKING_BORDER_COLORS[0];
+                return (_jsxs(Box, { marginTop: 1, flexShrink: 1, children: [_jsx(Text, { color: glyphColor, bold: true, children: "▸ " }), _jsx(Text, { color: theme.textDim, children: "Switched to " }), _jsx(Text, { color: theme.primary, bold: true, children: item.modelName })] }, item.id));
+            }
+            case "theme_transition": {
+                const glyphColor = THINKING_BORDER_COLORS[0];
+                return (_jsxs(Box, { marginTop: 1, flexShrink: 1, children: [_jsx(Text, { color: glyphColor, bold: true, children: "◐ " }), _jsx(Text, { color: theme.textDim, children: "Theme switched to " }), _jsx(Text, { color: theme.primary, bold: true, children: item.themeName })] }, item.id));
+            }
+            case "plan_event": {
+                // Plan-domain status changes (approve / reject / dismiss). Uses
+                // theme.planPrimary to match the existing plan_transition family,
+                // distinct from the model/thinking gradient.
+                const label = item.event === "approved"
+                    ? "Plan approved"
+                    : item.event === "rejected"
+                        ? "Plan rejected"
+                        : "Plan dismissed";
+                return (_jsxs(Box, { marginTop: 1, flexShrink: 1, children: [_jsxs(Text, { color: theme.planPrimary, bold: true, children: ["○ ", label] }), item.detail ? _jsx(Text, { color: theme.textDim, children: ` — "${item.detail}"` }) : null] }, item.id));
+            }
+            case "stopped":
+                // Cancellation / abort acknowledgement (ESC, auto-setup cancel, etc.).
+                // Muted dim treatment — this is an ack, not a state change worth a
+                // gradient. Glyph `⊘` reads as "stop" without being alarming.
+                return (_jsx(Box, { marginTop: 1, flexShrink: 1, children: _jsxs(Text, { color: theme.textDim, bold: true, children: ["⊘ ", item.text] }) }, item.id));
             case "step_done":
                 return (_jsx(Box, { marginTop: 1, flexShrink: 1, children: _jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: theme.success, bold: true, children: "✓ " }), _jsx(Text, { color: theme.success, bold: true, children: `Step ${item.stepNum} done` }), item.description ? (_jsx(Text, { color: theme.textDim, children: ` — ${item.description}` })) : null] }) }, item.id));
             case "queued":
@@ -1852,7 +2284,7 @@ export function App(props) {
                                     ? ` (+${item.imageCount} image${item.imageCount > 1 ? "s" : ""})`
                                     : ""] })] }, item.id));
             case "compacting":
-                return _jsx(CompactionSpinner, {}, item.id);
+                return _jsx(CompactionSpinner, { staticDisplay: true }, item.id);
             case "compacted":
                 return (_jsx(CompactionDone, { originalCount: item.originalCount, newCount: item.newCount, tokensBefore: item.tokensBefore, tokensAfter: item.tokensAfter }, item.id));
             case "duration":
@@ -1928,8 +2360,8 @@ export function App(props) {
                 setLiveItems((prev) => [
                     ...prev,
                     isAbort
-                        ? { kind: "info", text: "Request was stopped.", id: getId() }
-                        : { kind: "error", message: msg, id: getId() },
+                        ? { kind: "stopped", text: "Request was stopped.", id: getId() }
+                        : toErrorItem(err, getId()),
                 ]);
                 setRunAllTasks(false);
             }
@@ -1947,7 +2379,9 @@ export function App(props) {
     startTaskRef.current = startTask;
     useEffect(() => {
         runAllTasksRef.current = runAllTasks;
-    }, [runAllTasks]);
+        if (props.sessionStore)
+            props.sessionStore.runAllTasks = runAllTasks;
+    }, [runAllTasks, props.sessionStore]);
     const startPixelFix = useCallback((errorId) => {
         void (async () => {
             try {
@@ -1969,11 +2403,35 @@ export function App(props) {
                     log("WARN", "pixel", `chdir failed: ${err.message}`);
                 }
                 cwdRef.current = prep.projectPath;
+                repoMapDirtyRef.current = true;
+                repoMapMarkdownRef.current = "";
+                repoMapSnapshotRef.current = undefined;
+                repoMapChangedCountRef.current = 0;
+                repoMapCacheRef.current = createRepoMapCache();
+                props.repoMapChangedFilesRef?.current.clear();
+                props.repoMapReadFilesRef?.current.clear();
                 setDisplayedCwd(prep.projectPath);
+                let toolsForPixelFix = currentToolsRef.current;
                 if (props.rebuildToolsForCwd) {
-                    setCurrentTools(props.rebuildToolsForCwd(prep.projectPath));
+                    toolsForPixelFix = props.rebuildToolsForCwd(prep.projectPath);
+                    currentToolsRef.current = toolsForPixelFix;
+                    setCurrentTools(toolsForPixelFix);
                 }
-                const newSystemPrompt = await buildSystemPrompt(prep.projectPath, props.skills, false, undefined);
+                // Pixel-fix swaps the project root — reset injected packs so the
+                // new project re-detects from scratch on the next tool call. Also
+                // reset the setup-hint flag so the new project's first badge re-
+                // surfaces the tip (different project, may need the reminder).
+                injectedLanguagesRef.current = new Set();
+                setupHintShownRef.current = false;
+                const detectedForPixelFix = detectLanguages(prep.projectPath);
+                injectedLanguagesRef.current = detectedForPixelFix;
+                const newSystemPrompt = await rebuildSystemPrompt({
+                    cwd: prep.projectPath,
+                    planMode: false,
+                    clearApprovedPlan: true,
+                    activeLanguages: detectedForPixelFix,
+                    tools: toolsForPixelFix,
+                });
                 // Now that the cwd swap is committed, reset chat. Doing this BEFORE
                 // the chdir would print a banner with the old cwd, then bumping
                 // staticKey would print a second banner with the new cwd — leaving
@@ -2010,30 +2468,37 @@ export function App(props) {
                 log("ERROR", "pixel", msg);
                 currentPixelFixRef.current = null;
                 setRunAllPixel(false);
-                setLiveItems((prev) => [...prev, { kind: "error", message: msg, id: getId() }]);
+                setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
             }
         })();
     }, [props.cwd, stdout, agentLoop, currentProvider, currentModel]);
     startPixelFixRef.current = startPixelFix;
-    const [runAllPixel, setRunAllPixel] = useState(false);
+    // Seed from sessionStore so "Fix All" chaining survives a deferred
+    // resetUI() if it fires between pixel fixes (e.g. user toggled a pane).
+    const [runAllPixel, setRunAllPixel] = useState(props.sessionStore?.runAllPixel ?? false);
     useEffect(() => {
         runAllPixelRef.current = runAllPixel;
-    }, [runAllPixel]);
+        if (props.sessionStore)
+            props.sessionStore.runAllPixel = runAllPixel;
+    }, [runAllPixel, props.sessionStore]);
     const isTaskView = overlay === "tasks";
     const isSkillsView = overlay === "skills";
     const isPlanView = overlay === "plan";
     const isEyesView = overlay === "eyes";
     const isPixelView = overlay === "pixel";
     const isOverlayView = isTaskView || isSkillsView || isPlanView || isEyesView || isPixelView;
-    return (_jsxs(Box, { flexDirection: "column", width: columns, children: [_jsx(Static, { items: isOverlayView ? [] : history, style: { width: "100%" }, children: (item) => (_jsx(Box, { flexDirection: "column", paddingRight: 1, children: renderItem(item) }, item.id)) }, `${resizeKey}-${staticKey}`), isTaskView ? (_jsx(TaskOverlay, { cwd: props.cwd, agentRunning: agentLoop.isRunning, onClose: () => {
-                    if (props.resetUI && props.sessionStore) {
+    return (_jsxs(Box, { flexDirection: "column", width: columns, children: [_jsx(Static, { items: isOverlayView && !agentLoop.isRunning ? [] : history, style: { width: "100%" }, children: (item) => (_jsx(Box, { flexDirection: "column", paddingRight: 1, children: renderItem(item) }, item.id)) }, `${resizeKey}-${staticKey}`), isTaskView ? (_jsx(TaskOverlay, { cwd: props.cwd, agentRunning: agentLoop.isRunning, onClose: () => {
+                    if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
                         props.sessionStore.overlay = null;
                         props.resetUI();
                     }
                     else {
-                        stdout?.write("\x1b[2J\x1b[3J\x1b[H");
+                        if (props.sessionStore) {
+                            props.sessionStore.overlay = null;
+                            if (agentLoop.isRunning)
+                                props.sessionStore.pendingResetUI = true;
+                        }
                         setTaskCount(getTaskCount(props.cwd));
-                        setStaticKey((k) => k + 1);
                         setOverlay(null);
                     }
                 }, onWorkOnTask: (title, prompt, taskId) => {
@@ -2048,13 +2513,16 @@ export function App(props) {
                         startTask(next.title, next.prompt, next.id);
                     }
                 } })) : isPixelView ? (_jsx(PixelOverlay, { version: props.version, agentRunning: agentLoop.isRunning, onClose: () => {
-                    if (props.resetUI && props.sessionStore) {
+                    if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
                         props.sessionStore.overlay = null;
                         props.resetUI();
                     }
                     else {
-                        stdout?.write("\x1b[2J\x1b[3J\x1b[H");
-                        setStaticKey((k) => k + 1);
+                        if (props.sessionStore) {
+                            props.sessionStore.overlay = null;
+                            if (agentLoop.isRunning)
+                                props.sessionStore.pendingResetUI = true;
+                        }
                         setOverlay(null);
                     }
                 }, onFixOne: (entry) => {
@@ -2068,38 +2536,48 @@ export function App(props) {
                     setRunAllPixel(true);
                     startPixelFix(first.errorId);
                 } })) : isSkillsView ? (_jsx(SkillsOverlay, { cwd: props.cwd, onClose: () => {
-                    if (props.resetUI && props.sessionStore) {
+                    if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
                         props.sessionStore.overlay = null;
                         props.resetUI();
                     }
                     else {
-                        stdout?.write("\x1b[2J\x1b[3J\x1b[H");
-                        setStaticKey((k) => k + 1);
+                        if (props.sessionStore) {
+                            props.sessionStore.overlay = null;
+                            if (agentLoop.isRunning)
+                                props.sessionStore.pendingResetUI = true;
+                        }
                         setOverlay(null);
                     }
                 } })) : isEyesView ? (_jsx(EyesOverlay, { cwd: props.cwd, onClose: () => {
-                    if (props.resetUI && props.sessionStore) {
+                    if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
                         props.sessionStore.overlay = null;
                         props.resetUI();
                     }
                     else {
-                        stdout?.write("\x1b[2J\x1b[3J\x1b[H");
+                        if (props.sessionStore) {
+                            props.sessionStore.overlay = null;
+                            if (agentLoop.isRunning)
+                                props.sessionStore.pendingResetUI = true;
+                        }
                         setEyesCount(isEyesActive(props.cwd) ? journalCount({ status: "open" }, props.cwd) : undefined);
-                        setStaticKey((k) => k + 1);
                         setOverlay(null);
                     }
                 }, onQueueMessage: (msg) => {
                     agentLoop.queueMessage(msg);
                 } })) : isPlanView ? (_jsx(PlanOverlay, { cwd: props.cwd, autoExpandNewest: planAutoExpand, onClose: () => {
                     planOverlayPendingRef.current = false;
-                    if (props.resetUI && props.sessionStore) {
+                    if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
                         props.sessionStore.overlay = null;
                         props.sessionStore.planAutoExpand = false;
                         props.resetUI();
                     }
                     else {
-                        stdout?.write("\x1b[2J\x1b[3J\x1b[H");
-                        setStaticKey((k) => k + 1);
+                        if (props.sessionStore) {
+                            props.sessionStore.overlay = null;
+                            props.sessionStore.planAutoExpand = false;
+                            if (agentLoop.isRunning)
+                                props.sessionStore.pendingResetUI = true;
+                        }
                         setPlanAutoExpand(false);
                         setOverlay(null);
                     }
@@ -2115,7 +2593,10 @@ export function App(props) {
                             const planContent = await import("node:fs/promises").then(({ readFile }) => readFile(planPath, "utf-8"));
                             const steps = extractPlanSteps(planContent);
                             // Build the new system prompt with the approved plan baked in.
-                            const newPrompt = await buildSystemPrompt(props.cwd, props.skills, false, planPath);
+                            const newPrompt = await rebuildSystemPrompt({
+                                planMode: false,
+                                approvedPlanPath: planPath,
+                            });
                             // Create a new session file BEFORE remount so the new tree
                             // picks it up via sessionStore.sessionPath.
                             let newSessionPath;
@@ -2137,7 +2618,7 @@ export function App(props) {
                                     sessionPath: newSessionPath,
                                     pendingAction: {
                                         prompt: "The plan has been approved. Implement it now, following each step in order.",
-                                        infoText: "Plan approved — starting fresh session for implementation",
+                                        planEvent: { event: "approved" },
                                     },
                                 });
                                 return;
@@ -2170,7 +2651,7 @@ export function App(props) {
                         catch (err) {
                             const errMsg = err instanceof Error ? err.message : String(err);
                             log("ERROR", "error", errMsg);
-                            setLiveItems((prev) => [...prev, { kind: "error", message: errMsg, id: getId() }]);
+                            setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
                         }
                     })();
                 }, onReject: (planPath, feedback) => {
@@ -2185,7 +2666,7 @@ export function App(props) {
                         props.resetUI({
                             pendingAction: {
                                 prompt: rejectionMsg,
-                                infoText: `Plan rejected — "${feedback}"`,
+                                planEvent: { event: "rejected", detail: feedback },
                             },
                         });
                         return;
@@ -2202,36 +2683,52 @@ export function App(props) {
                     void agentLoop.run(rejectionMsg).catch((err) => {
                         const errMsg = err instanceof Error ? err.message : String(err);
                         log("ERROR", "error", errMsg);
-                        setLiveItems((prev) => [...prev, { kind: "error", message: errMsg, id: getId() }]);
+                        setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
                     });
-                } })) : (_jsxs(_Fragment, { children: [_jsxs(Box, { flexDirection: "column", flexGrow: 1, paddingRight: 1, children: [liveItems.map((item) => renderItem(item)), _jsx(StreamingArea, { isRunning: agentLoop.isRunning, streamingText: agentLoop.streamingText, streamingThinking: agentLoop.streamingThinking, showThinking: props.showThinking, thinkingMs: agentLoop.thinkingMs, planMode: planMode })] }), agentLoop.isRunning && agentLoop.activityPhase !== "idle" ? (_jsx(Box, { marginTop: 1, borderStyle: "round", borderColor: agentLoop.activityPhase === "thinking"
-                            ? THINKING_BORDER_COLORS[thinkingBorderFrame]
-                            : "transparent", paddingLeft: 1, paddingRight: 1, width: columns, children: _jsx(ActivityIndicator, { phase: agentLoop.activityPhase, elapsedMs: agentLoop.elapsedMs, runStartRef: agentLoop.runStartRef, thinkingMs: agentLoop.thinkingMs, isThinking: agentLoop.isThinking, tokenEstimate: agentLoop.streamedTokenEstimate, charCountRef: agentLoop.charCountRef, realTokensAccumRef: agentLoop.realTokensAccumRef, userMessage: lastUserMessage, activeToolNames: agentLoop.activeToolCalls.map((tc) => tc.name), planMode: planMode, retryInfo: agentLoop.retryInfo, planDone: planSteps.filter((s) => s.completed).length, planTotal: planSteps.length }) })) : agentLoop.stallError ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: theme.warning, children: "⚠ API provider stream interrupted — retries exhausted." }), _jsx(Text, { color: theme.textDim, children: "  Your conversation is preserved. Send a message to continue." })] })) : (doneStatus &&
+                } })) : (_jsxs(_Fragment, { children: [_jsxs(Box, { flexDirection: "column", flexGrow: 1, paddingRight: 1, children: [liveItems.map((item) => renderItem(item)), _jsx(StreamingArea, { isRunning: agentLoop.isRunning, streamingText: agentLoop.streamingText, streamingThinking: agentLoop.streamingThinking, thinkingMs: agentLoop.thinkingMs, planMode: planMode })] }), agentLoop.isRunning && agentLoop.activityPhase !== "idle" ? (_jsx(Box, { marginTop: 1, borderStyle: "round", borderColor: agentLoop.activityPhase === "thinking" ? THINKING_BORDER_COLORS[0] : "transparent", paddingLeft: 1, paddingRight: 1, width: columns, children: _jsx(ActivityIndicator, { phase: agentLoop.activityPhase, elapsedMs: agentLoop.elapsedMs, runStartRef: agentLoop.runStartRef, thinkingMs: agentLoop.thinkingMs, isThinking: agentLoop.isThinking, thinkingEnabled: thinkingEnabled, tokenEstimate: agentLoop.streamedTokenEstimate, charCountRef: agentLoop.charCountRef, realTokensAccumRef: agentLoop.realTokensAccumRef, userMessage: lastUserMessage, activeToolNames: agentLoop.activeToolCalls.map((tc) => tc.name), planMode: planMode, retryInfo: agentLoop.retryInfo, planDone: planSteps.filter((s) => s.completed).length, planTotal: planSteps.length, staticDisplay: true }) })) : agentLoop.stallError ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: theme.warning, children: "⚠ API provider stream interrupted — retries exhausted." }), _jsx(Text, { color: theme.textDim, children: "  Your conversation is preserved. Send a message to continue." })] })) : (doneStatus &&
                         !agentLoop.isRunning && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.success, children: ["✻ ", doneStatus.verb, " ", formatDuration(doneStatus.durationMs)] }) }))), agentLoop.queuedCount > 0 && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.accent, children: ["⏳ ", agentLoop.queuedCount, " message", agentLoop.queuedCount > 1 ? "s" : "", " queued"] }) })), _jsx(InputArea, { onSubmit: handleSubmit, onAbort: handleAbort, disabled: agentLoop.isRunning, isActive: !taskBarFocused && !overlay, onDownAtEnd: handleFocusTaskBar, onShiftTab: handleToggleThinking, onToggleTasks: () => {
-                            if (props.resetUI && props.sessionStore) {
+                            // While the agent is running, skip the screen-clear + staticKey
+                            // bump that would otherwise wipe the chat history from scrollback.
+                            // Just flip the overlay state — Ink's log-update handles the
+                            // live-area transition (chat input → TaskOverlay) natively, and
+                            // the chat history above stays in scrollback. When the overlay
+                            // closes, the history is still there (banner included).
+                            if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
                                 props.sessionStore.overlay = "tasks";
                                 props.resetUI();
                             }
                             else {
-                                stdout?.write("\x1b[2J\x1b[3J\x1b[H");
+                                if (props.sessionStore) {
+                                    props.sessionStore.overlay = "tasks";
+                                    if (agentLoop.isRunning)
+                                        props.sessionStore.pendingResetUI = true;
+                                }
                                 setOverlay("tasks");
                             }
                         }, onToggleSkills: () => {
-                            if (props.resetUI && props.sessionStore) {
+                            if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
                                 props.sessionStore.overlay = "skills";
                                 props.resetUI();
                             }
                             else {
-                                stdout?.write("\x1b[2J\x1b[3J\x1b[H");
+                                if (props.sessionStore) {
+                                    props.sessionStore.overlay = "skills";
+                                    if (agentLoop.isRunning)
+                                        props.sessionStore.pendingResetUI = true;
+                                }
                                 setOverlay("skills");
                             }
                         }, onTogglePixel: () => {
-                            if (props.resetUI && props.sessionStore) {
+                            if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
                                 props.sessionStore.overlay = "pixel";
                                 props.resetUI();
                             }
                             else {
-                                stdout?.write("\x1b[2J\x1b[3J\x1b[H");
+                                if (props.sessionStore) {
+                                    props.sessionStore.overlay = "pixel";
+                                    if (agentLoop.isRunning)
+                                        props.sessionStore.pendingResetUI = true;
+                                }
                                 setOverlay("pixel");
                             }
                         }, onTogglePlanMode: () => {
@@ -2247,6 +2744,13 @@ export function App(props) {
                                     id: getId(),
                                 },
                             ]);
-                        }, cwd: props.cwd, commands: allCommands, eyesCount: eyesCount }), overlay === "model" ? (_jsx(ModelSelector, { onSelect: handleModelSelect, onCancel: () => setOverlay(null), loggedInProviders: props.loggedInProviders ?? [currentProvider], currentModel: currentModel, currentProvider: currentProvider })) : overlay === "theme" ? (_jsx(ThemeSelector, { onSelect: handleThemeSelect, onCancel: () => setOverlay(null), currentTheme: theme.name })) : (_jsx(Footer, { model: currentModel, tokensIn: agentLoop.contextUsed, cwd: displayedCwd, gitBranch: gitBranch, thinkingEnabled: thinkingEnabled, planMode: planMode, exitPending: exitPending })), buddyEnabled && _jsx(Buddy, { phase: agentLoop.activityPhase }), (bgTasks.length > 0 || (eyesCount !== undefined && eyesCount > 0) || updatePending) && (_jsxs(Box, { children: [bgTasks.length > 0 && (_jsx(BackgroundTasksBar, { tasks: bgTasks, focused: taskBarFocused, expanded: taskBarExpanded, selectedIndex: selectedTaskIndex, onExpand: handleTaskBarExpand, onCollapse: handleTaskBarCollapse, onKill: handleTaskKill, onExit: handleTaskBarExit, onNavigate: handleTaskNavigate })), eyesCount !== undefined && eyesCount > 0 && (_jsx(Box, { paddingLeft: bgTasks.length > 0 ? 2 : 1, paddingRight: 1, children: _jsx(Text, { color: theme.accent, bold: true, children: `${eyesCount} eyes signal${eyesCount === 1 ? "" : "s"} · Run /eyes-improve to enhance EZ Coder` }) })), updatePending && (_jsx(Box, { paddingLeft: bgTasks.length > 0 || (eyesCount !== undefined && eyesCount > 0) ? 2 : 1, paddingRight: 1, children: _jsx(Text, { color: theme.success, bold: true, children: "\u2728 Update ready \u00B7 restart to apply" }) }))] }))] }))] }));
+                        }, cwd: props.cwd, commands: allCommands, eyesCount: eyesCount }), overlay === "model" ? (_jsx(ModelSelector, { onSelect: handleModelSelect, onCancel: () => setOverlay(null), loggedInProviders: props.loggedInProviders ?? [currentProvider], currentModel: currentModel, currentProvider: currentProvider })) : overlay === "theme" ? (_jsx(ThemeSelector, { onSelect: handleThemeSelect, onCancel: () => setOverlay(null), currentTheme: theme.name })) : (_jsx(Footer, { model: currentModel, tokensIn: agentLoop.contextUsed, contextWindowOptions: contextWindowOptions, cwd: displayedCwd, gitBranch: gitBranch, thinkingLevel: thinkingEnabled ? getMaxThinkingLevel(currentModel) : undefined, planMode: planMode, exitPending: exitPending })), (bgTasks.length > 0 || (eyesCount !== undefined && eyesCount > 0) || updatePending) && (_jsxs(Box, { children: [bgTasks.length > 0 && (_jsx(BackgroundTasksBar, { tasks: bgTasks, focused: taskBarFocused, expanded: taskBarExpanded, selectedIndex: selectedTaskIndex, onExpand: handleTaskBarExpand, onCollapse: handleTaskBarCollapse, onKill: handleTaskKill, onExit: handleTaskBarExit, onNavigate: handleTaskNavigate })), eyesCount !== undefined && eyesCount > 0 && (_jsx(Box, { paddingLeft: bgTasks.length > 0 ? 2 : 1, paddingRight: 1, children: _jsx(Text, { color: theme.accent, bold: true, children: `${eyesCount} eyes signal${eyesCount === 1 ? "" : "s"} · Run /eyes-improve to enhance EZ Coder` }) })), updatePending && (_jsx(Box, { paddingLeft: bgTasks.length > 0 || (eyesCount !== undefined && eyesCount > 0) ? 2 : 1, paddingRight: 1, children: _jsx(Text, { color: theme.success, bold: true, children: "\u2728 Update ready \u00B7 restart to apply" }) }))] }))] }))] }));
+}
+function formatRepoMapCommandOutput(enabled, markdown, refreshed) {
+    const status = enabled ? "on" : "off";
+    const prefix = refreshed
+        ? `Dynamic repo map refreshed · injection: ${status}`
+        : `Dynamic repo map · injection: ${status}`;
+    return `${prefix}\n\n${markdown}`;
 }
 //# sourceMappingURL=App.js.map