horizon-code 0.1.0

package/src/app.ts

@@ -0,0 +1,1454 @@
+import { BoxRenderable, ScrollBoxRenderable, type CliRenderer } from "@opentui/core";
+import { COLORS, setTheme, ULTRA_THEMES } from "./theme/colors.ts";
+import { Footer } from "./components/footer.ts";
+import { Splash } from "./components/splash.ts";
+import { SessionPanel } from "./components/session-panel.ts";
+import { StrategyPanel, setPrivacyMode } from "./components/strategy-panel.ts";
+import { CodePanel } from "./components/code-panel.ts";
+import { TutorialPanel } from "./components/tutorial-panel.ts";
+import { SettingsPanel } from "./components/settings-panel.ts";
+import { HooksPanel } from "./components/hooks-panel.ts";
+import { getHooksForEvent, executeHook, TOOL_BEFORE_HOOK, TOOL_AFTER_HOOK } from "./hooks/executor.ts";
+import { ModeBar } from "./components/mode-bar.ts";
+import { TabBar } from "./components/tab-bar.ts";
+import { InputBar } from "./components/input-bar.ts";
+import { ChatRenderer } from "./chat/renderer.ts";
+import { KeyHandler } from "./keys/handler.ts";
+import { store } from "./state/store.ts";
+import { createUserMessage } from "./chat/messages.ts";
+import { chat } from "./ai/client.ts";
+import { dashboard } from "./strategy/dashboard.ts";
+import { cleanupStrategyProcesses, runningProcesses } from "./strategy/tools.ts";
+import { abortChat } from "./ai/client.ts";
+import type { ModelPower } from "./platform/tiers.ts";
+import { listSavedStrategies, loadStrategy } from "./strategy/persistence.ts";
+import { autoFixStrategyCode } from "./strategy/validator.ts";
+import { CodeFenceDetector, finalizeStrategy, isStrategyCode, extractStrategyName } from "./strategy/code-stream.ts";
+import { loginWithBrowser, loginWithPassword, signOut, isLoggedIn, getUser } from "./platform/supabase.ts";
+import { loadConfig, saveConfig, setEncryptedEnv, removeEncryptedEnv, listEncryptedEnvNames } from "./platform/config.ts";
+import { getTreeSitterClient, destroyTreeSitterClient } from "./syntax/setup.ts";
+import type { Message } from "./chat/types.ts";
+
+// Tools that render as visual widgets in chat
+const WIDGET_TOOLS = new Set([
+  "polymarketEvents", "polymarketEventDetail", "polymarketPriceHistory",
+  "polymarketOrderBook", "whaleTracker", "newsSentiment", "evCalculator",
+  "kalshiEvents", "compareMarkets", "historicalVolatility",
+  "webSearch", "calaKnowledge", "probabilityCalculator",
+  "edit_strategy", "validate_strategy",
+  "backtest_strategy", "polymarket_data",
+]);
+
+// Strategy tools that update the code panel (edit_strategy + load)
+const CODE_PANEL_TOOLS = new Set([
+  "edit_strategy", "load_saved_strategy",
+]);
+
+// ── Slash commands ──
+const SLASH_COMMANDS: Record<string, { description: string; usage: string }> = {
+  "/help":    { description: "Show available commands", usage: "/help" },
+  "/resume":  { description: "Resume paused queue after Esc", usage: "/resume" },
+  "/clear":   { description: "Clear current chat messages", usage: "/clear" },
+  "/mode":    { description: "Switch mode", usage: "/mode [research|strategy|portfolio]" },
+  "/usage":   { description: "Toggle token/cost metrics", usage: "/usage" },
+  "/privacy": { description: "Toggle privacy mode", usage: "/privacy" },
+  "/code":    { description: "Toggle code panel", usage: "/code" },
+  "/login":   { description: "Login with Google or email/password", usage: "/login [email password]" },
+  "/logout":  { description: "Sign out", usage: "/logout" },
+  "/whoami":  { description: "Show current user", usage: "/whoami" },
+  "/tutorial": { description: "Open the guide", usage: "/tutorial" },
+  "/settings": { description: "Open settings", usage: "/settings" },
+  "/hooks":    { description: "Manage hooks", usage: "/hooks" },
+  "/home":    { description: "Back to splash screen", usage: "/home" },
+  "/compact": { description: "Force context compaction", usage: "/compact" },
+  "/context": { description: "Show context window usage", usage: "/context" },
+  "/strategies": { description: "List saved strategies", usage: "/strategies" },
+  "/load":    { description: "Load a saved strategy", usage: "/load <name>" },
+  "/env":     { description: "Manage encrypted API keys", usage: "/env [list|add|remove]" },
+  "/quit":    { description: "Exit Horizon", usage: "/quit" },
+  "/exit":    { description: "Exit Horizon", usage: "/exit" },
+};
+
+export class App {
+  private footer: Footer;
+  private splash: Splash;
+  private sessionPanel: SessionPanel;
+  private strategyPanel: StrategyPanel;
+  private codePanel: CodePanel;
+  private tutorialPanel: TutorialPanel;
+  private settingsPanel: SettingsPanel;
+  private hooksPanel: HooksPanel;
+  private tabBar: TabBar;
+  private modeBar: ModeBar;
+  private inputBar: InputBar;
+  private chatRenderer: ChatRenderer;
+  private keyHandler: KeyHandler;
+  private scrollBox: ScrollBoxRenderable;
+  private outerLayout: BoxRenderable;
+  private splitRow: BoxRenderable;
+  private chatColumn: BoxRenderable;
+  private messageRenderables: Map<string, BoxRenderable> = new Map();
+  private destroyed = false;
+  private inChatMode = false;
+  private authenticated = false;
+  private _openIdsSaveTimer: ReturnType<typeof setTimeout> | null = null;
+
+  // Per-tab stream state
+  private tabStreams: Map<string, {
+    processing: boolean;
+    streamingMsgId: string | null;
+    messageQueue: string[];
+    queuePaused: boolean;
+    thresholdWarned: boolean;
+  }> = new Map();
+
+  // Compat getters/setters that delegate to the active tab's stream
+  private get processing(): boolean { return this.getTabStream(store.get().activeSessionId).processing; }
+  private set processing(v: boolean) { this.getTabStream(store.get().activeSessionId).processing = v; }
+  private get currentStreamingMsgId(): string | null { return this.getTabStream(store.get().activeSessionId).streamingMsgId; }
+  private set currentStreamingMsgId(v: string | null) { this.getTabStream(store.get().activeSessionId).streamingMsgId = v; }
+  private get messageQueue(): string[] { return this.getTabStream(store.get().activeSessionId).messageQueue; }
+  private set messageQueue(v: string[]) { this.getTabStream(store.get().activeSessionId).messageQueue = v; }
+  private get queuePaused(): boolean { return this.getTabStream(store.get().activeSessionId).queuePaused; }
+  private set queuePaused(v: boolean) { this.getTabStream(store.get().activeSessionId).queuePaused = v; }
+
+  constructor(private renderer: CliRenderer) {
+    renderer.setBackgroundColor(COLORS.bg);
+
+    // ── Outer layout (hidden until chat mode) ──
+    this.outerLayout = new BoxRenderable(renderer, {
+      id: "outer-layout",
+      flexDirection: "column",
+      width: "100%",
+      height: "100%",
+    });
+    this.outerLayout.visible = false;
+    renderer.root.add(this.outerLayout);
+
+    // ── Horizontal split: chat (left) + code panel (right) ──
+    this.splitRow = new BoxRenderable(renderer, {
+      id: "split-row",
+      flexDirection: "row",
+      flexGrow: 1,
+      width: "100%",
+    });
+    this.outerLayout.add(this.splitRow);
+
+    // ── Chat column (left side of split) ──
+    this.chatColumn = new BoxRenderable(renderer, {
+      id: "chat-column",
+      flexDirection: "column",
+      flexGrow: 1,
+      height: "100%",
+    });
+    this.splitRow.add(this.chatColumn);
+
+    this.scrollBox = new ScrollBoxRenderable(renderer, {
+      id: "chat-scroll",
+      flexGrow: 1,
+      stickyScroll: true,
+      stickyStart: "bottom",
+      paddingTop: 1,
+      paddingLeft: 3,
+      paddingRight: 3,
+    });
+    // Tab bar at top of chat
+    this.tabBar = new TabBar(renderer);
+    this.chatColumn.add(this.tabBar.container);
+
+    this.chatColumn.add(this.scrollBox);
+
+    // Input bar
+    this.inputBar = new InputBar(renderer);
+    this.chatColumn.add(this.inputBar.renderable);
+
+    // ── Right panels (code and tutorial — hidden by default) ──
+    this.codePanel = new CodePanel(renderer);
+    this.splitRow.add(this.codePanel.container);
+
+    this.tutorialPanel = new TutorialPanel(renderer);
+    this.splitRow.add(this.tutorialPanel.container);
+
+    this.settingsPanel = new SettingsPanel(renderer);
+    this.hooksPanel = new HooksPanel(renderer);
+    this.settingsPanel.onChange((s) => {
+      // Gate Ultra themes — revert to dark if user isn't Ultra tier
+      if (ULTRA_THEMES.has(s.theme) && this.modeBar.currentTier !== "ultra") {
+        s.theme = "dark";
+        this.showSystemMsg("Ultra theme requires Ultra plan.");
+      }
+      this.chatRenderer.setShowToolCalls(s.showToolCalls);
+      setTheme(s.theme);
+      this.renderer.setBackgroundColor(COLORS.bg);
+      this.renderer.requestRender();
+      // Persist settings
+      const cfg = loadConfig();
+      cfg.settings = { ...s };
+      saveConfig(cfg);
+    });
+    this.settingsPanel.onDeleteChats(async () => {
+      // Delete all sessions from store
+      const sessions = store.get().sessions;
+      for (const s of sessions) {
+        store.deleteSession(s.id);
+      }
+      // Clear the chat display
+      for (const [id] of this.messageRenderables) this.scrollBox.remove(`msg-${id}`);
+      this.messageRenderables.clear();
+      // Anonymize in Supabase
+      try {
+        const { fetchSessions, deleteDbSession } = await import("./platform/supabase.ts");
+        const dbSessions = await fetchSessions();
+        for (const s of dbSessions) {
+          await deleteDbSession(s.id);
+        }
+      } catch {}
+      this.showSystemMsg("All chats deleted.");
+      this.settingsPanel.hide();
+    });
+    this.splitRow.add(this.settingsPanel.container);
+    this.splitRow.add(this.hooksPanel.container);
+
+    // ── Bottom bar: mode pills + footer (below the split, full width) ──
+    this.modeBar = new ModeBar(renderer);
+    this.outerLayout.add(this.modeBar.renderable);
+
+    this.footer = new Footer(renderer);
+    this.outerLayout.add(this.footer.renderable);
+
+    // ── Splash ──
+    this.splash = new Splash(renderer);
+    this.splash.onSubmit((text) => this.onFirstInput(text));
+    this.splash.focus();
+
+    // ── Overlay panels (sessions, deployments) ──
+    this.sessionPanel = new SessionPanel(renderer);
+    this.sessionPanel.onSelect((id) => this.switchSession(id));
+    this.sessionPanel.onNew(() => this.newSession());
+    this.sessionPanel.onDelete((id) => {
+      store.deleteSession(id);
+      // Sync to Supabase
+      import("./platform/supabase.ts").then(({ deleteDbSession }) => {
+        deleteDbSession(id).catch(() => {});
+      });
+      // Rebuild chat display
+      const active = store.getActiveSession();
+      if (active) {
+        for (const [mid] of this.messageRenderables) this.scrollBox.remove(`msg-${mid}`);
+        this.messageRenderables.clear();
+        for (const msg of active.messages) this.renderNewMessage(msg);
+      }
+    });
+    this.sessionPanel.onPin((id) => store.togglePinSession(id));
+    this.sessionPanel.onOpenTab((id) => {
+      store.openTab(id);
+      this.switchToActiveTab();
+    });
+    this.sessionPanel.onRename((id, name) => {
+      store.renameSession(id, name);
+      // Sync to Supabase
+      import("./platform/supabase.ts").then(({ updateDbSession }) => {
+        updateDbSession(id, { name }).catch(() => {});
+      });
+    });
+    this.sessionPanel.onRenameEnd(() => {
+      this.keyHandler.panelRenaming = false;
+      this.inputBar.focus();
+    });
+
+    this.strategyPanel = new StrategyPanel(renderer);
+
+    // ── Pass command list to input bar for autocomplete ──
+    const cmdDescriptions: Record<string, string> = {};
+    for (const [name, { description }] of Object.entries(SLASH_COMMANDS)) {
+      cmdDescriptions[name] = description;
+    }
+    this.inputBar.setCommands(cmdDescriptions);
+    this.inputBar.onAcChange((visible) => {
+      this.keyHandler.acActive = visible;
+    });
+
+    // ── Chat renderer ──
+    this.chatRenderer = new ChatRenderer(renderer);
+
+    // Load saved settings and open chats from config
+    {
+      const cfg = loadConfig();
+      if (cfg.settings) {
+        Object.assign(this.settingsPanel.settings, cfg.settings);
+        this.chatRenderer.setShowToolCalls(this.settingsPanel.settings.showToolCalls);
+        setTheme(this.settingsPanel.settings.theme as any);
+        this.renderer.setBackgroundColor(COLORS.bg);
+      }
+      // Open chat IDs are reconciled after sessions load from Supabase
+      // Don't restore them here — stale IDs cause ghost tabs
+    }
+
+    this.inputBar.onSubmit((text) => this.handleInput(text));
+
+    // ── Keyboard ──
+    this.keyHandler = new KeyHandler(renderer);
+    this.keyHandler.onQuit(() => this.handleQuitOrCancel());
+    this.keyHandler.onCancel(() => this.handleQuitOrCancel());
+    // Ctrl+L is now tab-next, clear available via /clear command only
+    this.keyHandler.onClear(() => {});
+    this.keyHandler.onSessions(() => this.togglePanel("sessions"));
+    this.keyHandler.onDeployments(() => this.togglePanel("deployments"));
+    this.keyHandler.onTabNext(() => { store.nextTab(); this.switchToActiveTab(); });
+    this.keyHandler.onTabPrev(() => { store.prevTab(); this.switchToActiveTab(); });
+    this.keyHandler.onTabClose(() => { store.closeTab(store.get().activeSessionId); this.switchToActiveTab(); });
+    this.keyHandler.onTabNew(() => { this.enterChatMode(); store.newSession(); this.switchToActiveTab(); });
+
+    this.keyHandler.onCodePanel(() => {
+      this.enterChatMode();
+      if (this.tutorialPanel.visible) this.tutorialPanel.hide();
+      this.codePanel.toggle();
+    });
+    this.keyHandler.onTutorialNav((dir) => {
+      if (this.settingsPanel.visible) {
+        this.settingsPanel.adjust(dir);
+      } else if (this.tutorialPanel.visible) {
+        if (dir === "left") this.tutorialPanel.prevTab();
+        else this.tutorialPanel.nextTab();
+      }
+    });
+    this.keyHandler.onCodeTab((tab) => {
+      if (!this.codePanel.visible) return;
+      if (tab === 0) {
+        // 0 = cycle to next tab
+        this.codePanel.cycleTab();
+      } else if (tab >= 1 && tab <= 3) {
+        const tabs = ["code", "logs", "dashboard"] as const;
+        this.codePanel.setTab(tabs[tab - 1]!);
+      }
+    });
+    this.keyHandler.onAcNav((dir) => {
+      if (dir === "up") this.inputBar.acUp();
+      else if (dir === "down") this.inputBar.acDown();
+      else if (dir === "accept") this.inputBar.acAccept();
+      else if (dir === "dismiss") this.inputBar.acDismiss();
+      this.keyHandler.acActive = this.inputBar.acVisible;
+    });
+
+    this.keyHandler.onPanelNav((d) => {
+      if (this.keyHandler.panelActive === "sessions") this.sessionPanel.navigate(d);
+      if (this.keyHandler.panelActive === "deployments") this.strategyPanel.navigate(d);
+    });
+    this.keyHandler.onPanelSelect(() => {
+      if (this.keyHandler.panelActive === "sessions") this.sessionPanel.selectCurrent();
+      if (this.keyHandler.panelActive === "deployments") this.strategyPanel.toggleExpand();
+    });
+    this.keyHandler.onPanelNew(() => {
+      if (this.keyHandler.panelActive === "sessions") this.sessionPanel.createNew();
+    });
+    this.keyHandler.onPanelClose(() => this.closePanel());
+    this.keyHandler.onPanelAction((key) => {
+      if (this.keyHandler.panelActive === "sessions") {
+        this.sessionPanel.handleAction(key);
+        this.keyHandler.panelRenaming = this.sessionPanel.isRenaming;
+      }
+      if (this.keyHandler.panelActive === "deployments") this.strategyPanel.handleAction(key);
+    });
+    this.keyHandler.onSettingsNav((delta) => {
+      if (this.settingsPanel.visible) {
+        if (delta === 0) this.settingsPanel.confirmAction(); // Enter key
+        else this.settingsPanel.navigate(delta);
+      }
+    });
+    this.keyHandler.onModeCycle(() => {
+      // Cycle mode for the active tab
+      this.modeBar.cycle();
+      const session = store.getActiveSession();
+      if (session) store.setSessionMode(session.id, this.modeBar.current);
+    });
+    this.keyHandler.onPrivacy(() => {
+      this.modeBar.togglePrivacy();
+      setPrivacyMode(this.modeBar.privacyEnabled);
+      this.footer.setPrivacy(this.modeBar.privacyEnabled);
+      this.strategyPanel.update();
+      this.renderer.requestRender();
+    });
+    this.keyHandler.onMetrics(() => {
+      this.modeBar.toggleMetrics();
+      this.footer.setMetrics(this.modeBar.metricsEnabled);
+      this.renderer.requestRender();
+    });
+
+    // ── Store subscription ──
+    store.subscribe(() => {
+      if (this.destroyed) return;
+      try {
+        if (this.inChatMode) this.footer.update();
+        this.strategyPanel.update();
+        this.tabBar.update();
+
+        // Persist open chat IDs (throttled to avoid excessive disk writes)
+        if (!this._openIdsSaveTimer) {
+          this._openIdsSaveTimer = setTimeout(() => {
+            this._openIdsSaveTimer = null;
+            const c = loadConfig();
+            const ids = [...new Set(store.get().openTabIds)]; // deduplicate
+            if (JSON.stringify(c.open_chat_ids) !== JSON.stringify(ids)) {
+              c.open_chat_ids = ids;
+              saveConfig(c);
+            }
+          }, 2000);
+        }
+
+        // Sync code panel with active session's strategy draft
+        const session = store.getActiveSession();
+        const draft = session?.strategyDraft;
+        if (draft) {
+          this.codePanel.setCode(draft.code, draft.validationStatus === "none" ? "pending" : draft.validationStatus);
+          this.codePanel.setStrategy(draft.name, draft.phase);
+        }
+
+        // Sync code panel visibility to key handler for Tab cycling
+        this.keyHandler.codePanelVisible = this.codePanel.visible;
+
+        this.renderer.requestRender();
+      } catch {}
+    });
+
+    renderer.on("resize", () => renderer.requestRender());
+
+    // Poll background processes — update count, live logs, clean dead processes
+    setInterval(() => {
+      let alive = 0;
+      let latestLogs = "";
+      const deadPids: number[] = [];
+      const now = Date.now();
+
+      for (const [pid, m] of runningProcesses) {
+        if (m.proc.exitCode === null) {
+          alive++;
+          const recent = m.stdout.slice(-30).join("\n");
+          const recentErr = m.stderr.slice(-5).join("\n");
+          latestLogs = recent + (recentErr ? "\n--- stderr ---\n" + recentErr : "");
+        } else if (now - m.startedAt > 300000) {
+          // Dead for 5+ minutes — clean up
+          deadPids.push(pid);
+        }
+      }
+      for (const pid of deadPids) runningProcesses.delete(pid);
+
+      this.modeBar.setBgProcessCount(alive);
+      // Only update logs tab if it's visible (avoid unnecessary markdown re-parse)
+      if (alive > 0 && latestLogs && this.codePanel.visible && this.codePanel.activeTab === "logs") {
+        this.codePanel.setLogs(latestLogs);
+      }
+    }, 2000);
+
+    // ── Python syntax highlighting (async init) ──
+    getTreeSitterClient().then((client) => {
+      this.codePanel.setTreeSitterClient(client);
+    }).catch(() => {});
+
+    // ── Auth restore + session loading + sync startup ──
+    this.initAuth();
+
+  }
+
+  // ── Splash → Chat ──
+
+  private onFirstInput(text: string): void {
+    this.enterChatMode();
+
+    if (!text.startsWith("/")) {
+      // Ensure there's a session to chat in
+      const current = store.getActiveSession();
+      if (!current || current.messages.length > 0) {
+        store.newSession();
+      }
+      this.switchToActiveTab();
+    }
+
+    this.handleInput(text);
+  }
+
+  // ── Input routing: slash commands, queue, or chat ──
+
+  private handleInput(text: string): void {
+    if (text.startsWith("/")) {
+      this.handleSlashCommand(text);
+      return;
+    }
+
+    if (!this.authenticated) {
+      this.showSystemMsg("You need to authenticate first. Type /login to sign in.");
+      return;
+    }
+
+    const sessionId = store.get().activeSessionId;
+    const ts = this.getTabStream(sessionId);
+
+    if (ts.processing) {
+      ts.messageQueue.push(text);
+      this.modeBar.setQueueCount(ts.messageQueue.length);
+      this.renderer.requestRender();
+      return;
+    }
+
+    this.processMessage(text, sessionId);
+  }
+
+  private async handleSlashCommand(input: string): Promise<void> {
+    const [cmd, ...args] = input.trim().split(/\s+/);
+    const arg = args.join(" ");
+
+    switch (cmd) {
+      case "/help": {
+        const lines = Object.entries(SLASH_COMMANDS)
+          .map(([name, { description, usage }]) => `  ${usage.padEnd(35)} ${description}`)
+          .join("\n");
+        const helpMsg = createUserMessage("/help");
+        store.addMessage(helpMsg);
+        this.renderNewMessage(helpMsg);
+        const sysMsg: Message = {
+          id: `msg-${Date.now()}-sys`, role: "assistant",
+          content: [{ type: "markdown", text: `**Available commands:**\n\`\`\`\n${lines}\n\`\`\`` }],
+          timestamp: Date.now(), status: "complete",
+        };
+        store.addMessage(sysMsg);
+        this.renderNewMessage(sysMsg);
+        break;
+      }
+      case "/resume":
+        if (this.queuePaused) {
+          this.queuePaused = false;
+          this.modeBar.setPaused(false);
+          this.drainQueue();
+        }
+        break;
+      case "/clear":
+        this.clearCurrentTab();
+        break;
+      case "/mode":
+        if (arg === "research" || arg === "strategy" || arg === "portfolio") {
+          this.modeBar.setMode(arg);
+        } else {
+          this.modeBar.cycle();
+        }
+        break;
+      case "/usage":
+        this.modeBar.toggleMetrics();
+        break;
+      case "/privacy":
+        this.modeBar.togglePrivacy();
+        setPrivacyMode(this.modeBar.privacyEnabled);
+        this.strategyPanel.update();
+        break;
+      case "/login": {
+        const parts = arg.split(/\s+/);
+        let loginResult: { success: boolean; error?: string; email?: string };
+
+        if (parts.length >= 2 && parts[0]!.includes("@")) {
+          this.showSystemMsg("Authenticating...");
+          loginResult = await loginWithPassword(parts[0]!, parts.slice(1).join(" "));
+        } else {
+          this.showSystemMsg("Opening browser for Google authentication...");
+          loginResult = await loginWithBrowser();
+        }
+
+        if (loginResult.success) {
+          this.authenticated = true;
+          this.showSystemMsg(`Logged in as ${loginResult.email}`);
+          import("./platform/sync.ts").then(({ platformSync }) => {
+            platformSync.start(30000).catch(() => {});
+          });
+        } else {
+          this.showSystemMsg(`Login failed: ${loginResult.error}`);
+        }
+        break;
+      }
+      case "/logout":
+        await signOut();
+        this.authenticated = false;
+        store.update({ deployments: [] });
+        this.showSystemMsg("Logged out. Type /login to re-authenticate.");
+        break;
+      case "/whoami": {
+        const loggedIn = await isLoggedIn();
+        if (loggedIn) {
+          const user = getUser();
+          this.showSystemMsg(`Logged in as ${user?.email ?? "unknown"} (${user?.id?.slice(0, 8)}...)`);
+        } else {
+          this.showSystemMsg("Not logged in. Use /login <email> <password>");
+        }
+        break;
+      }
+      case "/code":
+        if (this.tutorialPanel.visible) this.tutorialPanel.hide();
+        this.codePanel.toggle();
+        break;
+      case "/tutorial":
+        if (this.codePanel.visible) this.codePanel.hide();
+        if (this.settingsPanel.visible) this.settingsPanel.hide();
+        this.tutorialPanel.toggle();
+        break;
+      case "/settings":
+        if (this.codePanel.visible) this.codePanel.hide();
+        if (this.tutorialPanel.visible) this.tutorialPanel.hide();
+        if (this.hooksPanel.visible) this.hooksPanel.hide();
+        this.settingsPanel.toggle();
+        break;
+      case "/hooks":
+        if (this.codePanel.visible) this.codePanel.hide();
+        if (this.tutorialPanel.visible) this.tutorialPanel.hide();
+        if (this.settingsPanel.visible) this.settingsPanel.hide();
+        this.hooksPanel.toggle();
+        break;
+      case "/home":
+        this.goHome();
+        break;
+      case "/compact": {
+        this.compactContext();
+        // If there was a pending message waiting for compact, re-send it
+        if (this.pendingCompactMessage) {
+          const msg = this.pendingCompactMessage;
+          this.pendingCompactMessage = null;
+          this.showSystemMsg("Compacted. Continuing with your message...");
+          this.processMessage(msg);
+        }
+        break;
+      }
+      case "/context": {
+        const usage = this.estimateContextUsage();
+        const pct = Math.round(usage.pct * 100);
+        const bar = "\u2588".repeat(Math.round(usage.pct * 30)) + "\u2591".repeat(30 - Math.round(usage.pct * 30));
+        const ctxMsg: Message = {
+          id: `msg-${Date.now()}-sys`, role: "assistant",
+          content: [{ type: "markdown", text: `**Context window**\n\`[${bar}] ${pct}%\`\n\n~${usage.tokens.toLocaleString()} / ${usage.max.toLocaleString()} tokens  ·  ${usage.messages} messages  ·  /compact to force compaction` }],
+          timestamp: Date.now(), status: "complete",
+        };
+        store.addMessage(ctxMsg);
+        this.renderNewMessage(ctxMsg);
+        break;
+      }
+      case "/strategies": {
+        const saved = await listSavedStrategies();
+        const list = saved.length === 0
+          ? "No saved strategies. Use strategy mode to create one."
+          : saved.map((s) => `  ${s.name.padEnd(30)} ${s.modified ? new Date(s.modified).toLocaleDateString() : ""}`).join("\n");
+        const listMsg: Message = {
+          id: `msg-${Date.now()}-sys`, role: "assistant",
+          content: [{ type: "markdown", text: `**Saved strategies** (~/.horizon/strategies/)\n\`\`\`\n${list}\n\`\`\`` }],
+          timestamp: Date.now(), status: "complete",
+        };
+        store.addMessage(listMsg);
+        this.renderNewMessage(listMsg);
+        break;
+      }
+      case "/load": {
+        if (!arg) { break; }
+        const loaded = await loadStrategy(arg);
+        if (!loaded) {
+          const errMsg: Message = {
+            id: `msg-${Date.now()}-sys`, role: "assistant",
+            content: [{ type: "text", text: `Strategy "${arg}" not found.` }],
+            timestamp: Date.now(), status: "complete",
+          };
+          store.addMessage(errMsg);
+          this.renderNewMessage(errMsg);
+          break;
+        }
+        const code = autoFixStrategyCode(loaded.code);
+        store.setStrategyDraft({
+          name: arg, code, params: {}, explanation: "", riskConfig: null,
+          validationStatus: "none", validationErrors: [], phase: "generated",
+        });
+        this.codePanel.setCode(code, "pending");
+        this.codePanel.setStrategy(arg, "loaded");
+        this.codePanel.setTab("code");
+        if (!this.codePanel.visible) this.codePanel.show();
+        const okMsg: Message = {
+          id: `msg-${Date.now()}-sys`, role: "assistant",
+          content: [{ type: "text", text: `Loaded ${arg} from ${loaded.path}` }],
+          timestamp: Date.now(), status: "complete",
+        };
+        store.addMessage(okMsg);
+        this.renderNewMessage(okMsg);
+        break;
+      }
+      case "/env": {
+        const parts = arg.split(/\s+/);
+        const sub = parts[0];
+        if (!sub || sub === "list") {
+          const names = listEncryptedEnvNames();
+          this.showSystemMsg(names.length === 0
+            ? "No encrypted API keys stored. Use /env add <NAME> <VALUE>"
+            : `Stored keys:\n${names.map((n) => `  ${n}`).join("\n")}`);
+        } else if (sub === "add" && parts[1] && parts[2]) {
+          try {
+            setEncryptedEnv(parts[1], parts.slice(2).join(" "));
+            this.showSystemMsg(`Stored ${parts[1]} (encrypted)`);
+          } catch (e) {
+            this.showSystemMsg(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+          }
+        } else if (sub === "remove" && parts[1]) {
+          removeEncryptedEnv(parts[1]);
+          this.showSystemMsg(`Removed ${parts[1]}`);
+        } else {
+          this.showSystemMsg("Usage: /env list | /env add <NAME> <VALUE> | /env remove <NAME>");
+        }
+        break;
+      }
+      case "/quit":
+      case "/exit":
+        this.quit();
+        break;
+      default: {
+        // Unknown command — show as system message
+        const msg: Message = {
+          id: `msg-${Date.now()}-sys`, role: "assistant",
+          content: [{ type: "text", text: `Unknown command: ${cmd}. Type /help for available commands.` }],
+          timestamp: Date.now(), status: "complete",
+        };
+        store.addMessage(msg);
+        this.renderNewMessage(msg);
+      }
+    }
+    this.renderer.requestRender();
+  }
+
+  private pendingCompactMessage: string | null = null;
+
+  private getTabStream(sessionId: string) {
+    let ts = this.tabStreams.get(sessionId);
+    if (!ts) {
+      ts = { processing: false, streamingMsgId: null, messageQueue: [], queuePaused: false, thresholdWarned: false };
+      this.tabStreams.set(sessionId, ts);
+    }
+    return ts;
+  }
+
+  private async processMessage(text: string, _sessionId?: string): Promise<void> {
+    // Capture session ID NOW — not dynamically via getter (which resolves to active tab)
+    const sessionId = _sessionId ?? store.get().activeSessionId;
+    const ts = this.getTabStream(sessionId);
+    ts.processing = true;
+
+    const settings = this.settingsPanel.settings;
+    const power = settings.modelPower as ModelPower;
+
+    const usage = this.estimateContextUsage();
+    const threshold = settings.compactThreshold / 100;
+
+    if (settings.autoCompact && usage.pct >= 0.90) {
+      this.pendingCompactMessage = text;
+      this.showSystemMsg(
+        `Context at ${Math.round(usage.pct * 100)}%. Compaction recommended to maintain quality.\n` +
+        `Type /compact to compact and continue, or just send your message to skip.`
+      );
+      ts.processing = false;
+      return;
+    } else if (!settings.autoCompact && usage.pct >= 0.95) {
+      this.showSystemMsg("Context critically full. Auto-compacting to prevent cutoff...");
+      this.compactContext();
+    } else if (usage.pct >= threshold && usage.pct < 0.90 && !ts.thresholdWarned) {
+      ts.thresholdWarned = true;
+      this.showSystemMsg(`Context at ${Math.round(usage.pct * 100)}%. Use /compact to free space.`, sessionId);
+    }
+
+    await this.handleChat(text, power);
+    ts.processing = false;
+    this.drainQueueFor(sessionId);
+  }
+
+  private drainQueueFor(sessionId: string): void {
+    const ts = this.getTabStream(sessionId);
+    if (ts.queuePaused || ts.processing || ts.messageQueue.length === 0) return;
+    const next = ts.messageQueue.shift()!;
+    this.modeBar.setQueueCount(ts.messageQueue.length);
+    this.processMessage(next, sessionId);
+  }
+
+  private drainQueue(): void {
+    this.drainQueueFor(store.get().activeSessionId);
+  }
+
+  private async initAuth(): Promise<void> {
+    try {
+      const loggedIn = await isLoggedIn();
+      this.authenticated = loggedIn;
+
+      const cfg = loadConfig();
+      const email = cfg.user_email || getUser()?.email || undefined;
+
+      if (!loggedIn) {
+        this.splash.setAuthStatus(false);
+        this.renderer.requestRender();
+        return;
+      }
+
+      // Show loading
+      this.splash.setLoading(`Logged in as ${email ?? "user"} -- loading chats...`);
+      this.renderer.requestRender();
+
+      // Load chats from Supabase (only works with live session)
+      const { hasLiveSession } = await import("./platform/supabase.ts");
+      const live = await hasLiveSession();
+
+      if (live) {
+        const { loadSessions, startAutoSave } = await import("./platform/session-sync.ts");
+        await loadSessions().catch(() => {});
+        startAutoSave();
+      }
+
+      // Start platform sync (works with API key)
+      const { platformSync } = await import("./platform/sync.ts");
+      platformSync.start(30000).catch(() => {});
+
+      // Final status
+      const firstTime = !cfg.has_launched;
+      if (firstTime) { cfg.has_launched = true; saveConfig(cfg); }
+
+      if (!live) {
+        this.splash.setAuthStatus(true, email);
+        this.showSystemMsg("Your session has expired. Type /login to sign in again.");
+      } else {
+        this.splash.setAuthStatus(true, email, firstTime);
+      }
+
+      this.switchToActiveTab();
+    } catch {
+      this.splash.setAuthStatus(false);
+    }
+    this.renderer.requestRender();
+  }
+
+  private clearCurrentTab(): void {
+    this.enterChatMode();
+    const session = store.getActiveSession();
+    if (!session) return;
+
+    // Cancel any active stream on this tab
+    if (session.isStreaming) {
+      const ts = this.getTabStream(session.id);
+      ts.streamingMsgId = null;
+      ts.processing = false;
+      store.setSessionStreaming(session.id, false);
+      abortChat();
+      this.chatRenderer.stopSpinnerAnimation();
+    }
+
+    // Clear messages but keep the tab
+    const sessions = store.get().sessions.map((s) =>
+      s.id === session.id ? { ...s, messages: [], updatedAt: Date.now(), strategyDraft: null } : s
+    );
+    store.update({ sessions });
+    for (const [id] of this.messageRenderables) this.scrollBox.remove(`msg-${id}`);
+    this.messageRenderables.clear();
+    this.updateContextMeter();
+    this.inputBar.focus();
+    this.renderer.requestRender();
+  }
+
+  private switchToActiveTab(): void {
+    // Rebuild the chat display for the new active tab
+    for (const [id] of this.messageRenderables) this.scrollBox.remove(`msg-${id}`);
+    this.messageRenderables.clear();
+
+    const session = store.getActiveSession();
+    if (session) {
+      // Sync mode bar to this tab's mode
+      this.modeBar.setMode(session.mode);
+
+      // Sync code panel to this tab's strategy draft
+      if (session.strategyDraft) {
+        this.codePanel.setCode(session.strategyDraft.code, session.strategyDraft.validationStatus === "none" ? "pending" : session.strategyDraft.validationStatus);
+        this.codePanel.setStrategy(session.strategyDraft.name, session.strategyDraft.phase);
+      }
+
+      // Render messages
+      for (const msg of session.messages) this.renderNewMessage(msg);
+
+      // Resume spinner if this tab is streaming
+      if (session.isStreaming) {
+        this.chatRenderer.startSpinnerAnimation();
+      } else {
+        this.chatRenderer.stopSpinnerAnimation();
+      }
+    }
+
+    this.tabBar.update();
+    this.updateContextMeter();
+    this.inputBar.focus();
+    this.renderer.requestRender();
+  }
+
+  private goHome(): void {
+    // Hide everything and show the splash screen
+    this.outerLayout.visible = false;
+    this.codePanel.hide();
+    this.tutorialPanel.hide();
+    this.sessionPanel.hide();
+    this.strategyPanel.hide();
+    this.inChatMode = false;
+    this.splash.show();
+    this.splash.focus();
+    this.renderer.requestRender();
+  }
+
+  private _sysMsgCounter = 0;
+  private showSystemMsg(text: string, sessionId?: string): void {
+    if (!this.inChatMode) {
+      // On splash: show on splash status line instead of entering chat mode
+      this.splash?.setLoading?.(text);
+      return;
+    }
+    const msg: Message = {
+      id: `msg-${Date.now()}-${++this._sysMsgCounter}-sys`, role: "assistant",
+      content: [{ type: "text", text }],
+      timestamp: Date.now(), status: "complete",
+    };
+    const sid = sessionId ?? store.get().activeSessionId;
+    store.addMessageTo(sid, msg);
+    if (sid === store.get().activeSessionId) this.renderNewMessage(msg);
+  }
+
+  // ── Context management ──
+
+  private estimateContextUsage(): { tokens: number; max: number; pct: number; messages: number } {
+    // Only count user conversation — system prompt + tool defs are invisible overhead
+    const MODEL_WINDOW = 200000;
+    const SYSTEM_OVERHEAD = 12000; // ~12k tokens for system prompt + tool schemas (hidden from user)
+    const userBudget = MODEL_WINDOW - SYSTEM_OVERHEAD;
+
+    const session = store.getActiveSession();
+    const messages = session?.messages ?? [];
+    let chars = 0;
+    for (const m of messages) {
+      for (const b of m.content) {
+        if (b.text) chars += b.text.length;
+        if (b.widgetData) chars += Math.min(JSON.stringify(b.widgetData).length, 2000);
+        if (b.toolResult) chars += Math.min(JSON.stringify(b.toolResult).length, 2000);
+      }
+    }
+    const tokens = Math.round(chars / 4);
+    return { tokens, max: userBudget, pct: userBudget > 0 ? Math.min(1, tokens / userBudget) : 0, messages: messages.length };
+  }
+
+  private updateBudgetMeter(): void {
+    // Budget is updated from server meta events — nothing to do here
+  }
+
+  private updateContextMeter(): void {
+    const usage = this.estimateContextUsage();
+    this.modeBar.setContextUsage(usage.tokens, usage.max);
+  }
+
+  private compactContext(): void {
+    const session = store.getActiveSession();
+    if (!session) return;
+
+    const messages = session.messages;
+    if (messages.length <= 6) return;
+
+    // Keep last 6 messages intact for recent context continuity
+    const keep = messages.slice(-6);
+    const old = messages.slice(0, -6);
+
+    // Build a rich summary preserving key context
+    const summaryParts: string[] = [];
+
+    // Extract key context: market slugs, strategy names, decisions
+    const slugs = new Set<string>();
+    const strategyNames = new Set<string>();
+    let lastTopic = "";
+
+    for (const m of old) {
+      for (const b of m.content) {
+        // Extract slugs from tool results
+        if (b.widgetData) {
+          const data = b.widgetData as any;
+          if (data.slug) slugs.add(data.slug);
+          if (data.strategy_name) strategyNames.add(data.strategy_name);
+          if (Array.isArray(data)) {
+            for (const item of data.slice(0, 5)) {
+              if (item.slug) slugs.add(item.slug);
+            }
+          }
+          if (data.markets) {
+            for (const mk of data.markets.slice(0, 3)) {
+              if (mk.slug) slugs.add(mk.slug);
+            }
+          }
+        }
+      }
+
+      if (m.role === "user") {
+        const text = m.content.map((b) => b.text ?? "").filter(Boolean).join(" ").slice(0, 150);
+        if (text) {
+          summaryParts.push(`User: ${text}`);
+          lastTopic = text.slice(0, 50);
+        }
+      } else {
+        const tools = m.content
+          .filter((b) => b.type === "tool-result" || b.type === "tool-call")
+          .map((b) => b.toolName).filter(Boolean);
+        const text = m.content.map((b) => b.text ?? "").filter(Boolean).join(" ").slice(0, 150);
+        if (tools.length > 0) {
+          summaryParts.push(`Horizon: [${tools.join(", ")}] ${text.slice(0, 80)}`);
+        } else if (text) {
+          summaryParts.push(`Horizon: ${text}`);
+        }
+      }
+    }
+
+    // Build the compacted context message
+    const contextParts: string[] = [];
+    contextParts.push(`[Compacted ${old.length} messages]`);
+
+    if (lastTopic) contextParts.push(`Last topic: ${lastTopic}`);
+    if (slugs.size > 0) contextParts.push(`Markets discussed: ${[...slugs].slice(0, 8).join(", ")}`);
+    if (strategyNames.size > 0) contextParts.push(`Strategies: ${[...strategyNames].join(", ")}`);
+
+    // Include the strategy draft context if one exists
+    const draft = store.getActiveSession()?.strategyDraft;
+    if (draft) {
+      contextParts.push(`Active strategy: ${draft.name} (${draft.phase}, ${draft.validationStatus})`);
+    }
+
+    contextParts.push("");
+    contextParts.push("Conversation summary:");
+    contextParts.push(...summaryParts.slice(-15)); // last 15 exchanges max
+
+    const summaryMsg: Message = {
+      id: `msg-${Date.now()}-compact`,
+      role: "assistant",
+      content: [{ type: "text", text: contextParts.join("\n") }],
+      timestamp: Date.now(),
+      status: "complete",
+    };
+
+    const newMessages = [summaryMsg, ...keep];
+    const sessions = store.get().sessions.map((s) => {
+      if (s.id !== session.id) return s;
+      return { ...s, messages: newMessages, updatedAt: Date.now() };
+    });
+    store.update({ sessions });
+
+    // Rebuild display
+    for (const [id] of this.messageRenderables) this.scrollBox.remove(`msg-${id}`);
+    this.messageRenderables.clear();
+    for (const msg of newMessages) this.renderNewMessage(msg);
+
+    this.updateContextMeter();
+  }
+
+  private enterChatMode(): void {
+    if (this.inChatMode) return;
+    this.splash.dismiss();
+    this.outerLayout.visible = true;
+    this.inChatMode = true;
+    this.inputBar.focus();
+    this.renderer.requestRender();
+  }
+
+  // ── Chat ──
+
+  private async handleChat(text: string, modelPower?: ModelPower): Promise<void> {
+    // Capture the session ID at start — this stream belongs to THIS session
+    // even if the user switches to another tab during generation
+    const sessionId = store.get().activeSessionId;
+    const ts = this.getTabStream(sessionId);
+
+    const userMsg = createUserMessage(text);
+    store.addMessageTo(sessionId, userMsg);
+    if (sessionId === store.get().activeSessionId) this.renderNewMessage(userMsg);
+
+    const msgId = `msg-${Date.now()}-ai`;
+    const assistantMsg: Message = {
+      id: msgId, role: "assistant",
+      content: [{ type: "thinking" }],
+      timestamp: Date.now(), status: "thinking",
+    };
+    store.addMessageTo(sessionId, assistantMsg);
+    if (sessionId === store.get().activeSessionId) this.renderNewMessage(assistantMsg);
+    store.setSessionStreaming(sessionId, true, msgId);
+    ts.streamingMsgId = msgId;
+    this.chatRenderer.startSpinnerAnimation();
+    this.modeBar.streamStart();
+
+    const container = this.messageRenderables.get(msgId);
+
+    const rebuildContainer = (blocks: import("./chat/types.ts").ContentBlock[], status: Message["status"]) => {
+      if (!container) return;
+      for (const child of container.getChildren()) container.remove(child.id);
+      const tmpMsg: Message = { id: msgId, role: "assistant", content: blocks, timestamp: Date.now(), status };
+      const rendered = this.chatRenderer.renderMessage(tmpMsg);
+      for (const child of rendered.getChildren()) container.add(child);
+      this.renderer.requestRender();
+    };
+
+    try {
+      const session = store.getActiveSession();
+      const messages = session?.messages ?? [];
+      const allMessages = messages.filter((m) => m.role === "user" || m.role === "assistant");
+
+      // Context compaction: recent messages get full detail, old ones get compressed
+      const RECENT_WINDOW = 8; // last 8 messages get full tool results
+      const recentStart = Math.max(0, allMessages.length - RECENT_WINDOW);
+
+      const aiMessages = allMessages
+        .map((m, idx) => {
+          const isRecent = idx >= recentStart;
+          return {
+            role: m.role as "user" | "assistant",
+            content: m.content.map((b) => {
+              if (b.text) return b.text;
+              if (b.type === "tool-call") return isRecent ? `[Called ${b.toolName}]` : "";
+              if (b.type === "tool-result" || b.type === "tool-widget") {
+                const data = b.widgetData ?? b.toolResult;
+
+                // Old messages: ultra-compact summary (1 line)
+                if (!isRecent) {
+                  if (!data) return `[${b.toolName}]`;
+                  const obj = data as any;
+                  const label = obj.strategy_name ?? obj.title ?? obj.query ?? "";
+                  return `[${b.toolName}${label ? ": " + label : ""}]`;
+                }
+
+                // Recent messages: full detail
+                if (!data) return `[Result from ${b.toolName}]`;
+                try {
+                  if (Array.isArray(data)) {
+                    const summary = data.slice(0, 10).map((item: any) => {
+                      const parts = [];
+                      if (item.slug) parts.push(`slug:${item.slug}`);
+                      if (item.title) parts.push(item.title);
+                      if (item.yesPrice ?? item.markets?.[0]?.yesPrice) parts.push(`yes:${item.markets?.[0]?.yesPrice ?? item.yesPrice}`);
+                      return parts.join(" | ");
+                    }).join("\n");
+                    return `[${b.toolName} results]\n${summary}`;
+                  }
+                  const obj = data as any;
+                  const parts = [];
+                  if (obj.slug) parts.push(`slug:${obj.slug}`);
+                  if (obj.title ?? obj.strategy_name) parts.push(obj.title ?? obj.strategy_name);
+                  if (obj.markets) {
+                    for (const mk of obj.markets.slice(0, 5)) {
+                      parts.push(`market: ${mk.question ?? mk.title} yes:${mk.yesPrice} no:${mk.noPrice}`);
+                    }
+                  }
+                  if (obj.code) parts.push(`[code: ${obj.code.split("\n").length} lines]`);
+                  if (obj.validation) parts.push(obj.validation.valid ? "[valid]" : `[${obj.validation.errors?.length ?? 0} errors]`);
+                  return `[${b.toolName} result] ${parts.join(" | ") || JSON.stringify(data).slice(0, 800)}`;
+                } catch {
+                  return `[${b.toolName} result]`;
+                }
+              }
+              return "";
+            }).filter(Boolean).join("\n"),
+          };
+        })
+        .filter((m) => m.content.length > 0);
+
+      let fullText = "";
+      let currentBlocks: import("./chat/types.ts").ContentBlock[] = [];
+      let hasStartedText = false;
+
+      // Code fence detection — fallback when structured output isn't available
+      const codeFence = new CodeFenceDetector();
+      const isStrategyMode = this.modeBar.current === "strategy";
+      let structuredCodeActive = false; // true when strategy-code events are flowing (disables fence detection)
+
+      for await (const part of chat(aiMessages, this.modeBar.current, modelPower, this.settingsPanel.settings.verbosity)) {
+        if (ts.streamingMsgId !== msgId) break;
+
+        if (part.type === "thinking") {
+          currentBlocks = [{ type: "thinking" }];
+          rebuildContainer(currentBlocks, "thinking");
+        } else if (part.type === "tool-call") {
+          currentBlocks = currentBlocks.filter((b) => b.type !== "thinking");
+          currentBlocks.push({ type: "tool-call", toolName: part.toolName });
+          rebuildContainer(currentBlocks, "streaming");
+
+          // Execute before-hooks for this tool
+          const beforeEvent = TOOL_BEFORE_HOOK[part.toolName];
+          if (beforeEvent) {
+            const hooks = getHooksForEvent(beforeEvent);
+            for (const hook of hooks) {
+              this.showSystemMsg(`Hook: ${beforeEvent} -- ${hook.command}`);
+              const result = await executeHook(hook);
+              if (result.stdout) this.showSystemMsg(result.stdout);
+              if (result.stderr) this.showSystemMsg(`stderr: ${result.stderr}`);
+            }
+          }
+
+          // Show pending state in code panel for edit/load tools
+          if (CODE_PANEL_TOOLS.has(part.toolName)) {
+            this.codePanel.setCode("", "pending");
+            this.codePanel.setStrategy(
+              store.getActiveSession()?.strategyDraft?.name ?? "Strategy",
+              "editing...",
+            );
+            if (!this.codePanel.visible) this.codePanel.show();
+          }
+        } else if (part.type === "tool-result") {
+          // Replace the spinning tool-call with a completed tool-result (same line, not stacked)
+          const callIdx = currentBlocks.findIndex(
+            (b) => b.type === "tool-call" && b.toolName === part.toolName,
+          );
+          if (callIdx !== -1) {
+            currentBlocks[callIdx] = { type: "tool-result", toolName: part.toolName };
+          } else {
+            currentBlocks.push({ type: "tool-result", toolName: part.toolName });
+          }
+
+          if (WIDGET_TOOLS.has(part.toolName)) {
+            currentBlocks.push({ type: "tool-widget", toolName: part.toolName, widgetData: part.result });
+          }
+
+          // Update code panel from edit_strategy/load_saved_strategy results
+          if (CODE_PANEL_TOOLS.has(part.toolName)) {
+            const result = part.result as any;
+            if (result?.code) {
+              this.codePanel.setCode(result.code, result.validation?.valid ? "valid" : "invalid");
+              const phase = part.toolName === "load_saved_strategy" ? "generated" : "iterated";
+              this.codePanel.setStrategy(result.strategy_name ?? "Strategy", phase);
+              this.codePanel.setTab("code");
+              if (!this.codePanel.visible) this.codePanel.show();
+            }
+          }
+
+          // Feed logs into code panel logs tab
+          if (part.toolName === "run_strategy" || part.toolName === "read_logs") {
+            const result = part.result as any;
+            if (result?.initial_output) this.codePanel.setLogs(result.initial_output);
+            if (result?.stdout) this.codePanel.setLogs(result.stdout);
+            if (result?.stderr) this.codePanel.appendLog(result.stderr);
+            if (result?.error) this.codePanel.appendLog(`ERROR: ${result.error}`);
+            if (part.toolName === "run_strategy") {
+              this.codePanel.setTab("logs");
+              if (!this.codePanel.visible) this.codePanel.show();
+            }
+          }
+
+          // Feed dashboard HTML into code panel dashboard tab
+          if (part.toolName === "spawn_dashboard") {
+            const result = part.result as any;
+            if (result?.success) {
+              const html = (part as any).args?.custom_html;
+              if (html) this.codePanel.setDashboardHtml(html);
+              this.codePanel.setTab("dashboard");
+              if (!this.codePanel.visible) this.codePanel.show();
+            }
+          }
+
+          // Execute after-hooks for this tool
+          const afterEvent = TOOL_AFTER_HOOK[part.toolName];
+          if (afterEvent) {
+            const hooks = getHooksForEvent(afterEvent);
+            for (const hook of hooks) {
+              this.showSystemMsg(`Hook: ${afterEvent} -- ${hook.command}`);
+              const result = await executeHook(hook);
+              if (result.stdout) this.showSystemMsg(result.stdout);
+              if (result.stderr) this.showSystemMsg(`stderr: ${result.stderr}`);
+            }
+          }
+
+          rebuildContainer(currentBlocks, "streaming");
+        } else if (part.type === "text-delta") {
+          if (!hasStartedText) {
+            currentBlocks = currentBlocks.filter((b) => b.type !== "thinking");
+            currentBlocks.push({ type: "markdown", text: "" });
+            hasStartedText = true;
+            rebuildContainer(currentBlocks, "streaming");
+          }
+          fullText += part.textDelta;
+          this.modeBar.streamDelta(part.textDelta.length);
+
+          // ── Code fence detection (fallback when structured output isn't active) ──
+          if (isStrategyMode && !structuredCodeActive) {
+            const fenceEvent = codeFence.update(fullText);
+            if (fenceEvent) {
+              if (fenceEvent.event === "open") {
+                this.codePanel.setCode("", "pending");
+                this.codePanel.setStrategy("Strategy", "writing...");
+                if (!this.codePanel.visible) this.codePanel.show();
+              } else if (fenceEvent.event === "delta") {
+                this.codePanel.setCode(fenceEvent.code, "pending");
+                const name = extractStrategyName(fenceEvent.code);
+                if (name !== "Strategy") this.codePanel.setStrategy(name, "writing...");
+              } else if (fenceEvent.event === "close") {
+                // Finalize IMMEDIATELY so backtest/run tools can use the draft in the same response
+                if (isStrategyCode(fenceEvent.code)) {
+                  const draft = await finalizeStrategy(fenceEvent.code);
+                  this.codePanel.setCode(draft.code, draft.validationStatus === "valid" ? "valid" : "invalid");
+                  this.codePanel.setStrategy(draft.name, "generated");
+                  this.codePanel.setTab("code");
+                  if (!this.codePanel.visible) this.codePanel.show();
+                }
+              }
+            }
+          }
+
+          if (container) {
+            this.chatRenderer.updateStreamingMessage(msgId, container, fullText);
+            this.renderer.requestRender();
+          }
+        } else if (part.type === "strategy-code" as any) {
+          // Structured output: code field streaming to the code panel
+          structuredCodeActive = true;
+          const code = (part as any).code as string;
+          this.codePanel.setCode(code, "pending");
+          const name = extractStrategyName(code);
+          this.codePanel.setStrategy(name !== "Strategy" ? name : "Strategy", "writing...");
+          if (!this.codePanel.visible) this.codePanel.show();
+        } else if (part.type === "usage") {
+          // Server already recorded usage — just update the UI
+          this.updateBudgetMeter();
+        } else if (part.type === "meta") {
+          // Server tells us the tier, model, budget state
+          this.modeBar.setBudgetUsage(
+            part.budgetTotal > 0 ? part.budgetUsed / part.budgetTotal : 0,
+            part.tier,
+          );
+          if (part.overflowing) {
+            this.showSystemMsg(`Budget used. Switched to Fast mode until window refreshes.`);
+          }
+        } else if (part.type === "error") {
+          currentBlocks = currentBlocks.filter((b) => b.type !== "thinking");
+          currentBlocks.push({ type: "error", text: part.message });
+          rebuildContainer(currentBlocks, "error");
+        }
+      }
+
+      // Finalize strategy code from structured output (fence path finalizes immediately on close)
+      if (structuredCodeActive) {
+        // Get the last code emitted from structured output and finalize
+        const draft = store.getActiveSession()?.strategyDraft;
+        const pendingCode = this.codePanel.getCode();
+        if (pendingCode && isStrategyCode(pendingCode) && (!draft || draft.code !== pendingCode)) {
+          const finalized = await finalizeStrategy(pendingCode);
+          this.codePanel.setCode(finalized.code, finalized.validationStatus === "valid" ? "valid" : "invalid");
+          this.codePanel.setStrategy(finalized.name, "generated");
+          this.codePanel.setTab("code");
+          if (!this.codePanel.visible) this.codePanel.show();
+        }
+      }
+
+      const finalBlocks = currentBlocks.map((b) =>
+        b.type === "markdown" ? { ...b, text: fullText || "*(no response)*" } : b
+      );
+      store.updateMessageIn(sessionId, msgId, { content: finalBlocks, status: "complete" });
+      rebuildContainer(finalBlocks, "complete");
+
+      this.modeBar.streamEnd(aiMessages.map((m) => m.content).join(" "), fullText);
+      this.updateContextMeter();
+      this.updateBudgetMeter();
+    } catch (err) {
+      const errText = err instanceof Error ? err.message : String(err);
+      store.updateMessageIn(sessionId, msgId, { content: [{ type: "error", text: errText }], status: "error" });
+      rebuildContainer([{ type: "error", text: errText }], "error");
+    } finally {
+      this.chatRenderer.stopSpinnerAnimation();
+      store.setSessionStreaming(sessionId, false);
+      ts.streamingMsgId = null;
+      // Completion sound
+      if (this.settingsPanel.settings.soundEnabled) {
+        process.stdout.write("\x07");
+      }
+      this.renderer.requestRender();
+    }
+  }
+
+  private renderNewMessage(message: Message): void {
+    const renderable = this.chatRenderer.renderMessage(message);
+    this.messageRenderables.set(message.id, renderable);
+    this.scrollBox.add(renderable);
+    this.renderer.requestRender();
+  }
+
+  // ── Panels ──
+
+  private togglePanel(which: "sessions" | "deployments"): void {
+    this.enterChatMode();
+    if (which === "sessions") {
+      if (this.strategyPanel.visible) this.strategyPanel.hide();
+      this.sessionPanel.toggle();
+      this.keyHandler.panelActive = this.sessionPanel.visible ? "sessions" : null;
+    } else {
+      if (this.sessionPanel.visible) this.sessionPanel.hide();
+      this.strategyPanel.toggle();
+      this.keyHandler.panelActive = this.strategyPanel.visible ? "deployments" : null;
+    }
+  }
+
+  private closePanel(): void {
+    this.sessionPanel.hide();
+    this.strategyPanel.hide();
+    this.keyHandler.panelActive = null;
+    this.keyHandler.panelRenaming = false;
+    this.inputBar.focus();
+  }
+
+  private switchSession(sessionId: string): void {
+    store.openTab(sessionId);
+    this.keyHandler.panelActive = null;
+    this.switchToActiveTab();
+  }
+
+  private newSession(): void {
+    this.enterChatMode();
+    store.newSession();
+    this.switchToActiveTab();
+  }
+
+  // ── Controls ──
+
+  private handleQuitOrCancel(): void {
+    // Close right panels first
+    if (this.hooksPanel.visible) { this.hooksPanel.hide(); return; }
+    if (this.settingsPanel.visible) { this.settingsPanel.hide(); return; }
+    if (this.tutorialPanel.visible) { this.tutorialPanel.hide(); return; }
+    if (this.sessionPanel.visible || this.strategyPanel.visible) { this.closePanel(); return; }
+
+    // If streaming: stop generation and abort the HTTP request
+    if (store.getActiveSession()?.isStreaming) {
+      const sid = store.get().activeSessionId;
+      const activeTs = this.getTabStream(sid);
+      activeTs.streamingMsgId = null;
+      store.setSessionStreaming(sid, false);
+      abortChat(); // Cancel the HTTP stream to stop wasting tokens
+
+      // If queue has messages: pause and wait for /resume
+      if (this.messageQueue.length > 0) {
+        this.queuePaused = true;
+        this.modeBar.setPaused(true);
+      }
+      return;
+    }
+
+    // If paused queue: clear queue
+    if (this.queuePaused) {
+      this.messageQueue = [];
+      this.queuePaused = false;
+      this.modeBar.setPaused(false);
+      this.modeBar.setQueueCount(0);
+      return;
+    }
+
+    // Nothing active: quit
+    this.quit();
+  }
+
+  // ── Tick ──
+
+  private async quit(): Promise<void> {
+    this.destroyed = true;
+    // Save sessions before exit
+    try {
+      const { saveActiveSession, stopAutoSave } = await import("./platform/session-sync.ts");
+      stopAutoSave();
+      await saveActiveSession();
+    } catch {}
+    if (dashboard.running) dashboard.stop();
+    cleanupStrategyProcesses();
+    destroyTreeSitterClient();
+    this.renderer.destroy();
+    process.exit(0);
+  }
+}