horizon-code 0.5.1 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "horizon-code",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "AI-powered trading strategy terminal for Polymarket",
   "type": "module",
   "bin": {

package/src/ai/client.ts

@@ -32,7 +32,7 @@ export async function initMCP(): Promise<{ toolCount: number }> {
     });
     mcpTools = await mcpClient.tools();
     return { toolCount: Object.keys(mcpTools).length };
-  } catch { return { toolCount: 0 }; }
+  } catch (e) { console.error("[mcp] init failed:", e); return { toolCount: 0 }; }
 }
 
 export async function closeMCP(): Promise<void> {
@@ -141,7 +141,7 @@ async function* consumeSSE(res: Response): AsyncGenerator<Record<string, any>> {
       if (!line.startsWith("data: ")) continue;
       const data = line.slice(6);
       if (data === "[DONE]") return;
-      try { yield JSON.parse(data); } catch {}
+      try { yield JSON.parse(data); } catch (e) { console.error("[sse] malformed JSON:", data.slice(0, 100)); }
     }
   }
 }
@@ -162,7 +162,7 @@ function toolsToServerFormat(tools: Record<string, any>): Record<string, any> {
         const converted = zodSchema(tool.parameters);
         params = converted.jsonSchema ?? params;
       }
-    } catch {}
+    } catch (e) { failures++; console.error("[tools] schema conversion failed for", name, e); }
     result[name] = { description: tool.description ?? "", parameters: params };
   }
   return result;
@@ -273,6 +273,7 @@ export async function* chat(
     let emittedResponseLen = 0;
     let emittedCode: string | null = null;
     let structuredActive = useStructuredOutput;
+    let emittedAnyText = false;
     const pendingToolCalls: { toolName: string; args: Record<string, unknown> }[] = [];
     let eventCount = 0;
 
@@ -297,6 +298,7 @@ export async function* chat(
           if (trimmed.length > 3 && !trimmed.startsWith("{") && !trimmed.startsWith("[")) {
             structuredActive = false;
             yield { type: "text-delta", textDelta: jsonBuf };
+            emittedAnyText = true;
             jsonBuf = "";
             continue;
           }
@@ -304,6 +306,7 @@ export async function* chat(
           const response = extractJsonStringField(jsonBuf, "response");
           if (response && response.length > emittedResponseLen) {
             yield { type: "text-delta", textDelta: response.slice(emittedResponseLen) };
+            emittedAnyText = true;
             emittedResponseLen = response.length;
           }
 
@@ -314,6 +317,7 @@ export async function* chat(
           }
         } else {
           yield { type: "text-delta", textDelta: delta };
+          emittedAnyText = true;
         }
       } else if (event.type === "tool-call") {
         hasToolCalls = true;
@@ -339,15 +343,17 @@ export async function* chat(
     // the model likely responded with plain text — flush jsonBuf as text
     if (structuredActive && jsonBuf && emittedResponseLen === 0) {
       yield { type: "text-delta", textDelta: jsonBuf };
+      emittedAnyText = true;
     }
 
     // If no tool calls, we're done
     if (!hasToolCalls || pendingToolCalls.length === 0) {
       if (eventCount === 0) {
         yield { type: "error", message: "No response from server. Check your connection or try again." };
-      } else if (!hasToolCalls && jsonBuf === "" && emittedResponseLen === 0) {
-        // Server sent events (meta, usage) but no actual content
-        yield { type: "text-delta", textDelta: "*(Server returned no content. This may happen if the model is overloaded. Try again.)*" };
+      } else if (!emittedAnyText && !hasToolCalls && emittedCode === null) {
+        // Server sent events (meta, usage) but no actual text or code content
+        console.error("[chat] No content received. Events:", eventCount, "jsonBuf:", jsonBuf.slice(0, 200));
+        yield { type: "text-delta", textDelta: "*(No response received. Try again.)*" };
       }
       yield { type: "finish" };
       return;
@@ -391,6 +397,7 @@ export async function* chat(
     if (structuredActive) {
       jsonBuf = "";
       emittedResponseLen = 0;
+      emittedAnyText = false;
     }
 
     // Loop back — server will call OpenRouter again with the full conversation including tool results

package/src/ai/system-prompt.ts

@@ -1,5 +1,6 @@
 import type { Mode } from "../components/mode-bar.ts";
 import { buildGeneratePrompt } from "../strategy/prompts.ts";
+import { store } from "../state/store.ts";
 
 const BASE = `You are Horizon, an AI trading research assistant running in a CLI terminal.
 
@@ -123,7 +124,25 @@ const VERBOSITY_PREFIX: Record<string, string> = {
 
 export function getSystemPrompt(mode: Mode, verbosity: string = "normal"): string {
   // Strategy mode has its own verbosity rules — don't override
-  if (mode === "strategy") return buildGeneratePrompt();
+  if (mode === "strategy") {
+    let prompt = buildGeneratePrompt();
+    // Inject user profile context if available
+    try {
+      const { buildProfileContext } = require("../platform/profile.ts");
+      const profileCtx = buildProfileContext();
+      if (profileCtx) prompt += "\n\n" + profileCtx;
+    } catch (e) { console.error("[prompt] profile context failed:", e); }
+    // Inject active strategy context so research tools auto-scope
+    const draft = store.getActiveSession()?.strategyDraft;
+    if (draft?.code) {
+      const marketsMatch = draft.code.match(/markets\s*=\s*\[([\s\S]*?)\]/);
+      const slugs = marketsMatch ? [...marketsMatch[1]!.matchAll(/["']([^"']+)["']/g)].map(m => m[1]!) : [];
+      if (slugs.length > 0) {
+        prompt += `\n\n## Active Strategy Context\nThe user is working on "${draft.name}" trading these markets: ${slugs.join(", ")}. When they ask about "the market" or "what's happening", scope to these markets first. Use these slugs for polymarket_data, scan_correlations, etc.`;
+      }
+    }
+    return prompt;
+  }
   const prefix = VERBOSITY_PREFIX[verbosity] ?? "";
   return MODE_PROMPTS[mode] + prefix;
 }

package/src/app.ts

@@ -76,6 +76,17 @@ const SLASH_COMMANDS: Record<string, { description: string; usage: string }> = {
   "/exchanges": { description: "Show exchange connection status", usage: "/exchanges" },
   "/quit":    { description: "Exit Horizon", usage: "/quit" },
   "/exit":    { description: "Exit Horizon", usage: "/exit" },
+  "/bt":      { description: "Backtest current strategy", usage: "/bt" },
+  "/backtest": { description: "Backtest current strategy", usage: "/backtest" },
+  "/run":     { description: "Run current strategy", usage: "/run" },
+  "/dash":    { description: "Open strategy dashboard", usage: "/dash" },
+  "/dashboard": { description: "Open strategy dashboard", usage: "/dashboard" },
+  "/save":    { description: "Save current strategy", usage: "/save [name]" },
+  "/health":  { description: "Check strategy health score", usage: "/health" },
+  "/versions": { description: "List strategy versions", usage: "/versions [name]" },
+  "/export":  { description: "Export strategy to file", usage: "/export" },
+  "/report":  { description: "Generate strategy ledger report", usage: "/report [name]" },
+  "/session-export": { description: "Export chat session to markdown", usage: "/session-export" },
 };
 
 export class App {
@@ -212,7 +223,7 @@ export class App {
         for (const s of dbSessions) {
           await deleteDbSession(s.id);
         }
-      } catch {}
+      } catch (e: any) { console.error("[app] delete chats failed:", e?.message); }
       this.showSystemMsg("All chats deleted.");
       this.settingsPanel.hide();
     });
@@ -304,6 +315,18 @@ export class App {
     this.keyHandler.onClear(() => {});
     this.keyHandler.onSessions(() => this.togglePanel("sessions"));
     this.keyHandler.onDeployments(() => this.togglePanel("deployments"));
+    this.keyHandler.onOpenDashboard(() => {
+      if (dashboard.running) {
+        Bun.spawn(["open", dashboard.url]);
+      } else {
+        // Auto-start built-in dashboard if processes running
+        const hasLocal = [...runningProcesses.values()].some(m => m.proc.exitCode === null);
+        if (hasLocal) {
+          const url = dashboard.start("local", 0, true);
+          Bun.spawn(["open", url]);
+        }
+      }
+    });
     this.keyHandler.onTabNext(() => { store.nextTab(); this.switchToActiveTab(); });
     this.keyHandler.onTabPrev(() => { store.prevTab(); this.switchToActiveTab(); });
     this.keyHandler.onTabClose(() => { store.closeTab(store.get().activeSessionId); this.switchToActiveTab(); });
@@ -438,7 +461,7 @@ export class App {
         this.keyHandler.codePanelVisible = this.codePanel.visible;
 
         this.renderer.requestRender();
-      } catch {}
+      } catch (e: any) { console.error("[app] state listener error:", e?.message); }
     });
 
     renderer.on("resize", () => renderer.requestRender());
@@ -527,6 +550,49 @@ export class App {
           startedAt: localProcessStartedAt,
         });
         this._hasLocalMetrics = true;
+
+        // Check alerts against current local metrics (fire-and-forget — setInterval is not async)
+        ((metrics) => {
+          (async () => {
+            try {
+              const { checkAlerts } = await import("./strategy/alerts.ts");
+              const draft = store.getActiveSession()?.strategyDraft;
+              const alertResults = await checkAlerts(
+                draft?.name ?? "local",
+                {
+                  pnl: metrics.pnl,
+                  max_dd: metrics.max_dd ?? 0,
+                  exposure: metrics.exposure ?? 0,
+                  win_rate: metrics.win_rate ?? 0,
+                  trades: metrics.trades ?? 0,
+                },
+                () => {
+                  // Stop all running processes
+                  for (const [pid, m] of runningProcesses) {
+                    if (m.proc.exitCode === null) m.cleanup?.();
+                  }
+                },
+              );
+              for (const r of alertResults) {
+                if (r.triggered && r.actionTaken) {
+                  this.codePanel.appendLog(r.actionTaken);
+                }
+              }
+            } catch (e: any) { console.error("[app] alert check failed:", e?.message); }
+          })();
+        })(localMetricsData);
+
+        // Record replay metrics (fire-and-forget)
+        ((metrics) => {
+          (async () => {
+            try {
+              const { recordMetrics, isRecording } = await import("./strategy/replay.ts");
+              for (const [pid] of runningProcesses) {
+                if (isRecording(pid)) recordMetrics(pid, metrics as any);
+              }
+            } catch (e: any) { console.error("[app] replay record failed:", e?.message); }
+          })();
+        })(localMetricsData);
       } else if (this._hasLocalMetrics && alive === 0) {
         // Local process stopped — clear local metrics, let platform data take over
         this._hasLocalMetrics = false;
@@ -654,11 +720,11 @@ export class App {
           this.showSystemMsg(`Logged in as ${loginResult.email}`);
           // Start session sync + platform sync now that we have a live session
           import("./platform/session-sync.ts").then(({ loadSessions, startAutoSave }) => {
-            loadSessions().catch(() => {});
+            loadSessions().catch((e: any) => console.error("[app] session/sync init failed:", e?.message));
             startAutoSave();
-          }).catch(() => {});
+          }).catch((e: any) => console.error("[app] session/sync init failed:", e?.message));
           import("./platform/sync.ts").then(({ platformSync }) => {
-            platformSync.start(30000).catch(() => {});
+            platformSync.start(30000).catch((e: any) => console.error("[app] platformSync start failed:", e?.message));
           });
         } else {
           this.showSystemMsg(`Login failed: ${loginResult.error}`);
@@ -845,6 +911,81 @@ export class App {
       case "/exit":
         this.quit();
         break;
+      case "/bt":
+      case "/backtest": {
+        const tool = (await import("./strategy/tools.ts")).strategyTools.backtest_strategy;
+        const result = await tool.execute({});
+        this.codePanel.appendLog(typeof result === "object" ? JSON.stringify(result, null, 2) : String(result));
+        this.codePanel.setTab("logs");
+        break;
+      }
+      case "/run": {
+        const tool = (await import("./strategy/tools.ts")).strategyTools.run_strategy;
+        const result = await tool.execute({});
+        this.codePanel.appendLog(typeof result === "object" ? JSON.stringify(result, null, 2) : String(result));
+        this.codePanel.setTab("logs");
+        break;
+      }
+      case "/dash":
+      case "/dashboard": {
+        const tool = (await import("./strategy/tools.ts")).strategyTools.spawn_dashboard;
+        const result = await tool.execute({ strategy_id: "local" });
+        if (result?.url) Bun.spawn(["open", result.url]);
+        break;
+      }
+      case "/save": {
+        const tool = (await import("./strategy/tools.ts")).strategyTools.save_strategy;
+        const draft = store.getActiveSession()?.strategyDraft;
+        const result = await tool.execute({ name: draft?.name ?? arg ?? "untitled" });
+        this.codePanel.appendLog(`Saved: ${JSON.stringify(result)}`);
+        break;
+      }
+      case "/health": {
+        const { computeHealthScore } = await import("./strategy/health.ts");
+        const draft = store.getActiveSession()?.strategyDraft;
+        if (!draft?.code) { this.codePanel.appendLog("No strategy loaded"); break; }
+        const report = computeHealthScore(draft.code);
+        this.codePanel.appendLog(`Health: ${report.score}/${report.maxScore} (${report.grade}) — ${report.summary}`);
+        break;
+      }
+      case "/versions": {
+        const { listVersions } = await import("./strategy/versioning.ts");
+        const draft = store.getActiveSession()?.strategyDraft;
+        const versions = await listVersions(draft?.name ?? arg ?? "");
+        this.codePanel.appendLog(versions.length === 0 ? "No versions found" : versions.map(v => `v${v.version} [${v.hash}] ${v.label} — ${v.timestamp}`).join("\n"));
+        break;
+      }
+      case "/export": {
+        const { exportStrategy } = await import("./strategy/export.ts");
+        const draft = store.getActiveSession()?.strategyDraft;
+        if (!draft?.code) { this.codePanel.appendLog("No strategy loaded"); break; }
+        const result = await exportStrategy(draft.name, draft.code, draft.params ?? {}, null);
+        this.codePanel.appendLog(`Exported to ${result.path} (${result.size} bytes)`);
+        break;
+      }
+      case "/report": {
+        const { generateReport } = await import("./strategy/ledger.ts");
+        const draft = store.getActiveSession()?.strategyDraft;
+        const report = generateReport(draft?.name ?? arg ?? "");
+        this.codePanel.appendLog(report.summary);
+        break;
+      }
+      case "/session-export": {
+        const session = store.getActiveSession();
+        if (!session) break;
+        const { writeWorkspaceFile } = await import("./strategy/workspace.ts");
+        const lines: string[] = [];
+        lines.push(`# ${session.id} — ${new Date().toISOString()}\n`);
+        for (const msg of session.messages) {
+          const role = msg.role === "user" ? "**User**" : "**Horizon**";
+          const text = msg.content.map((b: any) => b.text ?? b.markdown ?? "").join("\n");
+          lines.push(`### ${role}\n${text}\n`);
+        }
+        const fileName = `session_${Date.now()}.md`;
+        await writeWorkspaceFile(`exports/${fileName}`, lines.join("\n"));
+        this.codePanel.appendLog(`Session exported to exports/${fileName}`);
+        break;
+      }
       default: {
         // Unknown command — show as system message
         const msg: Message = {
@@ -938,15 +1079,19 @@ export class App {
       const { hasLiveSession } = await import("./platform/supabase.ts");
       const live = await hasLiveSession();
 
+      const { loadSessions, startAutoSave } = await import("./platform/session-sync.ts");
       if (live) {
-        const { loadSessions, startAutoSave } = await import("./platform/session-sync.ts");
-        await loadSessions().catch(() => {});
+        await loadSessions().catch((e) => {
+          this.splash.setLoading(`Failed to load chats: ${e?.message ?? "unknown error"}`);
+        });
         startAutoSave();
+      } else {
+        this.splash.setLoading("Session expired -- type /login to restore your chats");
       }
 
       // Start platform sync (works with API key)
       const { platformSync } = await import("./platform/sync.ts");
-      platformSync.start(30000).catch(() => {});
+      platformSync.start(30000).catch((e: any) => console.error("[app] platformSync start failed:", e?.message));
 
       // Final status
       const firstTime = !cfg.has_launched;
@@ -987,6 +1132,10 @@ export class App {
     store.update({ sessions });
     for (const [id] of this.messageRenderables) this.scrollBox.remove(`msg-${id}`);
     this.messageRenderables.clear();
+    this.codePanel.clearWidgets();
+    this.codePanel.setLogs("");
+    this.codePanel.setCode("", "none");
+    this.codePanel.setMetrics(null);
     this.updateContextMeter();
     this.inputBar.focus();
     this.renderer.requestRender();
@@ -1158,6 +1307,23 @@ export class App {
       contextParts.push(`Active strategy: ${draft.name} (${draft.phase}, ${draft.validationStatus})`);
     }
 
+    // Preserve strategy context through compaction
+    if (draft?.code) {
+      contextParts.push(`\nActive strategy code hash: ${draft.code.length} chars`);
+      // Preserve active market slugs
+      const marketsMatch = draft.code.match(/markets\s*=\s*\[([\s\S]*?)\]/);
+      if (marketsMatch) {
+        const slugs2 = [...marketsMatch[1]!.matchAll(/["']([^"']+)["']/g)].map(m => m[1]!);
+        contextParts.push(`Active markets: ${slugs2.join(", ")}`);
+      }
+    }
+
+    // Preserve running process info
+    const pids = [...runningProcesses.keys()].filter(pid => runningProcesses.get(pid)?.proc.exitCode === null);
+    if (pids.length > 0) {
+      contextParts.push(`Running processes: PIDs ${pids.join(", ")}`);
+    }
+
     contextParts.push("");
     contextParts.push("Conversation summary:");
     contextParts.push(...summaryParts.slice(-15)); // last 15 exchanges max
@@ -1336,13 +1502,20 @@ export class App {
           }
         } else if (part.type === "tool-result") {
           // Replace the spinning tool-call with a completed tool-result (same line, not stacked)
+          // Include toolResult so renderer can detect errors and show brief explanations
+          const hasError = part.result && typeof part.result === "object" && "error" in (part.result as any);
+          const resultBlock: import("./chat/types.ts").ContentBlock = {
+            type: "tool-result",
+            toolName: part.toolName,
+            ...(hasError ? { toolResult: part.result } : {}),
+          };
           const callIdx = currentBlocks.findIndex(
             (b) => b.type === "tool-call" && b.toolName === part.toolName,
           );
           if (callIdx !== -1) {
-            currentBlocks[callIdx] = { type: "tool-result", toolName: part.toolName };
+            currentBlocks[callIdx] = resultBlock;
           } else {
-            currentBlocks.push({ type: "tool-result", toolName: part.toolName });
+            currentBlocks.push(resultBlock);
           }
 
           if (WIDGET_TOOLS.has(part.toolName)) {
@@ -1616,7 +1789,7 @@ export class App {
       const { saveActiveSession, stopAutoSave } = await import("./platform/session-sync.ts");
       stopAutoSave();
       await saveActiveSession();
-    } catch {}
+    } catch (e: any) { console.error("[app] shutdown save failed:", e?.message); }
     if (dashboard.running) dashboard.stop();
     cleanupStrategyProcesses();
     destroyTreeSitterClient();

package/src/chat/renderer.ts

@@ -33,7 +33,7 @@ const syntaxStyle = SyntaxStyle.fromStyles({
   "@punctuation.special": { fg: h("#D7BA7D") },
 });
 
-// Braille spinner frames
+// Braille spinner frames (tool calls)
 const BRAILLE = [
   "\u2801", "\u2803", "\u2807", "\u280f",
   "\u281f", "\u283f", "\u287f", "\u28ff",
@@ -41,6 +41,11 @@ const BRAILLE = [
   "\u28e0", "\u28c0", "\u2880", "\u2800",
 ];
 
+// Dot orbit spinner for header (different visual rhythm)
+const ORBIT = [
+  "\u25DC", "\u25DD", "\u25DE", "\u25DF",  // ◜ ◝ ◞ ◟
+];
+
 // Tool name → human-readable label
 function toolLabel(name: string): string {
   return name.replace(/_/g, " ");
@@ -62,9 +67,14 @@ export class ChatRenderer {
     this.spinnerTimer = setInterval(() => {
       if (this.spinnerNodes.length === 0) return;
       this.spinnerFrame = (this.spinnerFrame + 1) % BRAILLE.length;
-      const char = BRAILLE[this.spinnerFrame]!;
+      const brailleChar = BRAILLE[this.spinnerFrame]!;
+      const orbitChar = ORBIT[this.spinnerFrame % ORBIT.length]!;
       for (const node of this.spinnerNodes) {
-        node.content = `${char} `;
+        if (node.id.includes("stream-spin")) {
+          node.content = `  ${orbitChar}`;
+        } else {
+          node.content = `${brailleChar} `;
+        }
       }
       this.renderer.requestRender();
     }, 60);
@@ -80,6 +90,7 @@ export class ChatRenderer {
 
   renderMessage(message: Message): BoxRenderable {
     const isUser = message.role === "user";
+    const isStreaming = message.status === "streaming" || message.status === "thinking";
 
     const box = new BoxRenderable(this.renderer, {
       id: `msg-${message.id}`,
@@ -92,16 +103,60 @@ export class ChatRenderer {
     });
 
     if (message.role === "user" || message.role === "assistant") {
-      box.add(new TextRenderable(this.renderer, {
+      const headerBox = new BoxRenderable(this.renderer, {
+        id: `msg-header-${message.id}`,
+        flexDirection: "row",
+        width: "100%",
+      });
+      headerBox.add(new TextRenderable(this.renderer, {
         id: `msg-label-${message.id}`,
         content: isUser ? "U S E R" : "H O R I Z O N",
         fg: isUser ? COLORS.textMuted : COLORS.borderDim,
       }));
+
+      // Streaming indicator next to the role label — always visible at top
+      if (!isUser && isStreaming) {
+        const streamSpinner = new TextRenderable(this.renderer, {
+          id: `msg-stream-spin-${message.id}`,
+          content: `  ${ORBIT[0]}`,
+          fg: COLORS.accent,
+        });
+        this.spinnerNodes.push(streamSpinner);
+        headerBox.add(streamSpinner);
+      }
+
+      box.add(headerBox);
     }
 
+    // Render tool blocks first, then content blocks (text/markdown/widgets)
+    // This ensures tools are always at the top, generation text at the bottom
+    const toolBlocks: { block: ContentBlock; idx: number }[] = [];
+    const contentBlocks: { block: ContentBlock; idx: number }[] = [];
+
     for (let i = 0; i < message.content.length; i++) {
       const block = message.content[i]!;
-      const renderable = this.renderBlock(block, message, i);
+      if (block.type === "tool-call" || block.type === "tool-result") {
+        toolBlocks.push({ block, idx: i });
+      } else {
+        contentBlocks.push({ block, idx: i });
+      }
+    }
+
+    for (const { block, idx } of toolBlocks) {
+      const renderable = this.renderBlock(block, message, idx);
+      if (renderable) box.add(renderable);
+    }
+
+    // Add spacing between tool section and content
+    if (toolBlocks.length > 0 && contentBlocks.length > 0) {
+      box.add(new TextRenderable(this.renderer, {
+        id: `msg-tool-spacer-${message.id}`,
+        content: "",
+      }));
+    }
+
+    for (const { block, idx } of contentBlocks) {
+      const renderable = this.renderBlock(block, message, idx);
       if (renderable) box.add(renderable);
     }
 
@@ -144,12 +199,19 @@ export class ChatRenderer {
       case "thinking":
         return this.renderThinking(message.id, index);
 
-      case "error":
+      case "error": {
+        const rawErr = block.text ?? "Unknown error";
+        // Clean up error text: first line only, remove stack traces and verbose prefixes
+        const cleanErr = rawErr
+          .replace(/^Error:\s*/i, "")
+          .replace(/\n[\s\S]*/, "")
+          .slice(0, 120);
         return new TextRenderable(this.renderer, {
           id: `msg-err-${message.id}-${index}`,
-          content: `x ${block.text ?? "Unknown error"}`,
+          content: `\u2716 ${cleanErr}`,
           fg: COLORS.error,
         });
+      }
 
       default:
         return null;
@@ -179,7 +241,7 @@ export class ChatRenderer {
     return box;
   }
 
-  // Tool in-progress: braille spinner + name
+  // Tool in-progress: accent braille spinner + name
   private renderToolCall(block: ContentBlock, msgId: string, index: number): BoxRenderable {
     const box = new BoxRenderable(this.renderer, {
       id: `msg-tool-${msgId}-${index}`,
@@ -189,7 +251,7 @@ export class ChatRenderer {
     const spinner = new TextRenderable(this.renderer, {
       id: `msg-tool-icon-${msgId}-${index}`,
       content: `${BRAILLE[0]} `,
-      fg: COLORS.textMuted,
+      fg: COLORS.accent,
     });
     this.spinnerNodes.push(spinner);
     box.add(spinner);
@@ -197,34 +259,54 @@ export class ChatRenderer {
     box.add(new TextRenderable(this.renderer, {
       id: `msg-tool-name-${msgId}-${index}`,
       content: toolLabel(block.toolName ?? "tool"),
-      fg: COLORS.textMuted,
+      fg: COLORS.text,
     }));
 
     return box;
   }
 
-  // Tool completed: tick or error icon + name
+  // Tool completed: green check or red error with brief explanation
   private renderToolResult(block: ContentBlock, msgId: string, index: number): BoxRenderable {
     const box = new BoxRenderable(this.renderer, {
       id: `msg-result-${msgId}-${index}`,
       flexDirection: "row",
-      marginBottom: 1,
     });
 
     const hasError = block.toolResult && typeof block.toolResult === "object" && "error" in (block.toolResult as any);
-    box.add(new TextRenderable(this.renderer, {
-      id: `msg-result-icon-${msgId}-${index}`,
-      content: hasError ? "x " : ". ",
-      fg: hasError ? COLORS.error : COLORS.success,
-    }));
 
-    const label = toolLabel(block.toolName ?? "done");
-    const errorText = hasError ? ` — ${((block.toolResult as any).error ?? "").slice(0, 60)}` : "";
-    box.add(new TextRenderable(this.renderer, {
-      id: `msg-result-name-${msgId}-${index}`,
-      content: label + errorText,
-      fg: hasError ? COLORS.error : COLORS.textMuted,
-    }));
+    if (hasError) {
+      // Red x + tool name + brief, human-readable error
+      box.add(new TextRenderable(this.renderer, {
+        id: `msg-result-icon-${msgId}-${index}`,
+        content: "\u2716 ",
+        fg: COLORS.error,
+      }));
+
+      const label = toolLabel(block.toolName ?? "tool");
+      const rawError = String((block.toolResult as any).error ?? "failed");
+      // Clean up common error patterns to be user-friendly
+      const briefError = rawError
+        .replace(/^Error:\s*/i, "")
+        .replace(/\n[\s\S]*/, "")  // first line only
+        .slice(0, 80);
+      box.add(new TextRenderable(this.renderer, {
+        id: `msg-result-name-${msgId}-${index}`,
+        content: `${label} -- ${briefError}`,
+        fg: COLORS.error,
+      }));
+    } else {
+      // Green check + tool name
+      box.add(new TextRenderable(this.renderer, {
+        id: `msg-result-icon-${msgId}-${index}`,
+        content: "\u2713 ",
+        fg: COLORS.success,
+      }));
+      box.add(new TextRenderable(this.renderer, {
+        id: `msg-result-name-${msgId}-${index}`,
+        content: toolLabel(block.toolName ?? "done"),
+        fg: COLORS.textMuted,
+      }));
+    }
 
     return box;
   }

package/src/components/footer.ts

@@ -33,7 +33,7 @@ export class Footer {
 
     this.hintsText = new TextRenderable(renderer, {
       id: "footer-hints",
-      content: "esc stop  ^N new chat  ^L ^H switch  ^W close  ^R mode  ^E chats  ^D bots  / cmd",
+      content: "esc stop  ^N new  ^L ^H switch  ^W close  ^R mode  ^E chats  ^D bots  ^O dash  / cmd",
       fg: COLORS.borderDim,
     });
     this.container.add(this.hintsText);

package/src/keys/handler.ts

@@ -20,6 +20,7 @@ export class KeyHandler {
   private tabCloseCallback: (() => void) | null = null;
   private tabNewCallback: (() => void) | null = null;
   private acNavCallback: ((dir: "up" | "down" | "accept" | "dismiss") => void) | null = null;
+  private openDashboardCallback: (() => void) | null = null;
   acActive = false; // set by app when autocomplete is visible
 
   // Panel navigation (shared by session & strategy panels)
@@ -56,6 +57,7 @@ export class KeyHandler {
   onTabClose(cb: () => void): void { this.tabCloseCallback = cb; }
   onTabNew(cb: () => void): void { this.tabNewCallback = cb; }
   onAcNav(cb: (dir: "up" | "down" | "accept" | "dismiss") => void): void { this.acNavCallback = cb; }
+  onOpenDashboard(cb: () => void): void { this.openDashboardCallback = cb; }
 
   onPanelNav(cb: (delta: number) => void): void { this.panelNavCallback = cb; }
   onPanelSelect(cb: () => void): void { this.panelSelectCallback = cb; }
@@ -123,6 +125,12 @@ export class KeyHandler {
       return;
     }
 
+    // Ctrl+O — open dashboard in browser
+    if (key.ctrl && key.name === "o") {
+      this.openDashboardCallback?.();
+      return;
+    }
+
     // Ctrl+L — next tab (was clear, now tab navigation)
     if (key.ctrl && key.name === "l") {
       if (this.panelActive === "sessions") { this.panelNewCallback?.(); return; }