@triedotdev/mcp 1.0.102 → 1.0.103

package/dist/chunk-M4YMTHGG.js

@@ -0,0 +1,2822 @@
+import {
+  getGuardian
+} from "./chunk-HFKOGW7H.js";
+import {
+  findCrossProjectPatterns,
+  isAIAvailable
+} from "./chunk-SPQJC7RA.js";
+import {
+  getGuardianState,
+  getMemoryStats,
+  getRecentIssues
+} from "./chunk-6JPPYG7F.js";
+import {
+  getTrieDirectory,
+  getWorkingDirectory
+} from "./chunk-R4AAPFXC.js";
+import {
+  isInteractiveMode
+} from "./chunk-APMV77PU.js";
+
+// src/tools/scan.ts
+var TrieScanTool = class {
+  async execute(_input) {
+    console.error("\u2139\uFE0F  Trie scan has been refocused on decision ledger");
+    console.error("   Use: trie tell - to report incidents");
+    console.error("   Use: trie gotcha - to predict risks");
+    console.error("   Use: trie learn - to learn from history");
+    return {
+      content: [{
+        type: "text",
+        text: "Scan functionality has been refocused on decision ledger.\n\nUse:\n- trie tell - to report incidents\n- trie gotcha - to predict risks\n- trie learn - to learn from history"
+      }]
+    };
+  }
+};
+
+// src/utils/streaming.ts
+var shouldSuppressConsole = () => isInteractiveMode();
+var StreamingManager = class {
+  listeners = /* @__PURE__ */ new Set();
+  progress = {
+    totalFiles: 0,
+    processedFiles: 0,
+    activeAgents: [],
+    completedAgents: [],
+    totalIssues: 0,
+    issuesBySeverity: { critical: 0, serious: 0, moderate: 0, low: 0 }
+  };
+  /**
+   * Subscribe to scan updates
+   */
+  subscribe(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  /**
+   * Emit an update to all listeners
+   */
+  emit(type, data) {
+    const update = {
+      type,
+      timestamp: Date.now(),
+      data
+    };
+    this.listeners.forEach((listener) => {
+      try {
+        listener(update);
+      } catch (error) {
+        if (!shouldSuppressConsole()) {
+          console.warn("Stream listener error:", error);
+        }
+      }
+    });
+  }
+  /**
+   * Initialize scan with file count
+   */
+  startScan(totalFiles) {
+    this.progress = {
+      totalFiles,
+      processedFiles: 0,
+      activeAgents: [],
+      completedAgents: [],
+      totalIssues: 0,
+      issuesBySeverity: { critical: 0, serious: 0, moderate: 0, low: 0 }
+    };
+    this.emit("progress", { ...this.progress });
+  }
+  /**
+   * Update current file being processed
+   */
+  updateCurrentFile(file) {
+    this.progress.currentFile = file;
+    this.emit("progress", { ...this.progress });
+  }
+  /**
+   * Mark file as processed
+   */
+  completeFile() {
+    this.progress.processedFiles++;
+    this.emit("progress", { ...this.progress });
+  }
+  /**
+   * Start agent execution
+   */
+  startAgent(agentName) {
+    if (!this.progress.activeAgents.includes(agentName)) {
+      this.progress.activeAgents.push(agentName);
+    }
+    this.emit("agent_start", { agent: agentName });
+    this.emit("progress", { ...this.progress });
+  }
+  /**
+   * Complete agent execution
+   */
+  completeAgent(agentName, issues) {
+    this.progress.activeAgents = this.progress.activeAgents.filter((a) => a !== agentName);
+    if (!this.progress.completedAgents.includes(agentName)) {
+      this.progress.completedAgents.push(agentName);
+    }
+    for (const issue of issues) {
+      this.progress.issuesBySeverity[issue.severity]++;
+      this.progress.totalIssues++;
+    }
+    this.emit("agent_complete", {
+      agent: agentName,
+      issueCount: issues.length,
+      issues: issues.slice(0, 5)
+      // Only send first 5 for streaming
+    });
+    this.emit("progress", { ...this.progress });
+  }
+  /**
+   * Report new issue found
+   */
+  reportIssue(issue) {
+    this.progress.issuesBySeverity[issue.severity]++;
+    this.progress.totalIssues++;
+    this.emit("issue_found", issue);
+    this.emit("progress", { ...this.progress });
+  }
+  /**
+   * Complete the entire scan
+   */
+  completeScan(totalIssues) {
+    this.emit("scan_complete", {
+      totalFiles: this.progress.totalFiles,
+      totalIssues: totalIssues.length,
+      issues: totalIssues,
+      // Include all issues for the dashboard
+      issuesBySeverity: this.progress.issuesBySeverity,
+      completedAgents: this.progress.completedAgents
+    });
+  }
+  /**
+   * Report error
+   */
+  reportError(error, context) {
+    this.emit("error", {
+      message: error.message,
+      context,
+      stack: error.stack
+    });
+  }
+  /**
+   * Get current progress
+   */
+  getProgress() {
+    return { ...this.progress };
+  }
+  /**
+   * Reset state
+   */
+  reset() {
+    this.progress = {
+      totalFiles: 0,
+      processedFiles: 0,
+      activeAgents: [],
+      completedAgents: [],
+      totalIssues: 0,
+      issuesBySeverity: { critical: 0, serious: 0, moderate: 0, low: 0 }
+    };
+  }
+  /**
+   * Report watch status (directories, debounce, last change)
+   */
+  reportWatchStatus(status) {
+    this.emit("watch_status", status);
+  }
+  /**
+   * Report a specific file change when watching
+   */
+  reportWatchChange(file) {
+    this.emit("watch_change", { file });
+  }
+  /**
+   * Report memory operations (saving context, learning patterns)
+   */
+  reportMemory(action, details) {
+    this.emit("memory", { action, details });
+  }
+  /**
+   * Report signal extraction from watch mode
+   */
+  reportSignalExtraction(signals) {
+    this.emit("signal_extracted", signals);
+  }
+  // ============================================
+  // Rich Content Events (for TUI panes)
+  // ============================================
+  /**
+   * Report a code snippet for display
+   */
+  reportSnippet(snippet) {
+    this.emit("snippet", snippet);
+  }
+  /**
+   * Report cost estimate from Moneybags
+   */
+  reportCost(cost) {
+    this.emit("cost_report", cost);
+  }
+  /**
+   * Report production readiness score
+   */
+  reportReadiness(readiness) {
+    this.emit("readiness_report", readiness);
+  }
+  /**
+   * Report semantic analysis results
+   */
+  reportSemantic(semantic) {
+    this.emit("semantic_report", semantic);
+  }
+  /**
+   * Report attack surface analysis
+   */
+  reportAttackSurface(attack) {
+    this.emit("attack_surface", attack);
+  }
+  /**
+   * Report skill banner (ASCII art + quote)
+   */
+  reportBanner(banner) {
+    this.emit("skill_banner", banner);
+  }
+  /**
+   * Report raw log entry
+   */
+  reportRawLog(level, message) {
+    this.emit("raw_log", { level, message, time: (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false }) });
+  }
+};
+
+// src/cli/dashboard/index.ts
+import { render } from "ink";
+import React7 from "react";
+
+// src/cli/dashboard/App.tsx
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback4, useRef } from "react";
+import { Box as Box11, useInput as useInput7, useApp } from "ink";
+
+// src/cli/dashboard/state.tsx
+import React, { createContext, useContext, useReducer } from "react";
+import { jsx } from "react/jsx-runtime";
+function addActivity(state, message) {
+  const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+  const activityLog = [{ time, message }, ...state.activityLog].slice(0, 50);
+  return { ...state, activityLog };
+}
+function getVisibleInsights(state) {
+  return state.agentInsights.filter((i) => !i.dismissed);
+}
+function getMemoryTreeNodes(state) {
+  const nodes = [];
+  const { expandedNodes, issues, globalPatterns } = state.memoryTree;
+  nodes.push({ id: "severity", level: 0 });
+  if (expandedNodes.has("severity")) {
+    nodes.push({ id: "severity-critical", level: 1 });
+    if (expandedNodes.has("severity-critical")) {
+      issues.filter((i) => i.severity === "critical").slice(0, 5).forEach((issue) => {
+        nodes.push({ id: `severity-critical-${issue.id}`, level: 2 });
+      });
+    }
+    nodes.push({ id: "severity-serious", level: 1 });
+    nodes.push({ id: "severity-moderate", level: 1 });
+    nodes.push({ id: "severity-low", level: 1 });
+  }
+  nodes.push({ id: "files", level: 0 });
+  if (expandedNodes.has("files")) {
+    const byFile = /* @__PURE__ */ new Map();
+    for (const issue of issues) {
+      byFile.set(issue.file, (byFile.get(issue.file) || 0) + 1);
+    }
+    Array.from(byFile.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).forEach(([file]) => nodes.push({ id: `file-${file}`, level: 1 }));
+  }
+  nodes.push({ id: "agents", level: 0 });
+  if (expandedNodes.has("agents")) {
+    const byAgent = /* @__PURE__ */ new Map();
+    for (const issue of issues) {
+      byAgent.set(issue.agent, (byAgent.get(issue.agent) || 0) + 1);
+    }
+    Array.from(byAgent.entries()).sort((a, b) => b[1] - a[1]).forEach(([agent]) => nodes.push({ id: `agent-${agent}`, level: 1 }));
+  }
+  nodes.push({ id: "patterns", level: 0 });
+  if (expandedNodes.has("patterns")) {
+    globalPatterns.slice(0, 5).forEach((p) => nodes.push({ id: `pattern-${p.id}`, level: 1 }));
+  }
+  return nodes;
+}
+function handleStreamUpdate(state, update) {
+  let s = { ...state, lastUpdate: Date.now() };
+  switch (update.type) {
+    case "progress": {
+      const oldProgress = s.progress;
+      if (oldProgress.totalFiles === 0 && update.data.totalFiles > 0 || oldProgress.processedFiles > 0 && update.data.processedFiles === 0) {
+        s.scanStartTime = Date.now();
+        s.scanComplete = false;
+        s = { ...s };
+        delete s.scanEndTime;
+      }
+      s.progress = update.data;
+      if (update.data.issuesBySeverity?.critical > 0) {
+        s.alerts = { hasCritical: true, lastCriticalAt: update.timestamp };
+      }
+      if (update.data.currentFile && update.data.processedFiles % 10 === 0 && update.data.processedFiles !== oldProgress.processedFiles) {
+        s = addActivity(s, `Scanned ${update.data.processedFiles}/${update.data.totalFiles} files`);
+      }
+      break;
+    }
+    case "agent_start":
+      s = addActivity(s, `[*] Scout started: ${update.data.agent}`);
+      break;
+    case "agent_complete":
+      s = addActivity(s, `[+] Scout complete: ${update.data.agent} (${update.data.issueCount} issues)`);
+      break;
+    case "issue_found":
+      s.issues = [...s.issues, update.data];
+      if (update.data.severity === "critical" || update.data.severity === "serious") {
+        const icon = update.data.severity === "critical" ? "[!]" : "[x]";
+        const fileName = update.data.file?.split("/").pop() || "unknown";
+        s = addActivity(s, `${icon} ${update.data.severity.toUpperCase()}: ${update.data.message?.slice(0, 40) || fileName}`);
+        if (update.data.severity === "critical") {
+          s.alerts = { hasCritical: true, lastCriticalAt: update.timestamp };
+        }
+      }
+      break;
+    case "scan_complete":
+      s.scanComplete = true;
+      s.scanEndTime = update.timestamp;
+      s.progress = { ...s.progress, processedFiles: s.progress.totalFiles };
+      if (update.data.issues && Array.isArray(update.data.issues)) {
+        s.issues = update.data.issues;
+      }
+      s = addActivity(s, `=== Scan complete - ${s.progress.totalIssues} issues ===`);
+      break;
+    case "watch_status":
+      s.watch = {
+        watching: update.data.watching ?? s.watch.watching,
+        directories: update.data.directories ?? s.watch.directories,
+        debounceMs: update.data.debounceMs ?? s.watch.debounceMs,
+        lastChange: update.data.lastChange ?? s.watch.lastChange,
+        recentChanges: update.data.recentChanges ?? s.watch.recentChanges
+      };
+      if (update.data.watching !== void 0) {
+        s = addActivity(s, update.data.watching ? `[*] Watch mode: ACTIVE (${update.data.directories ?? 0} dirs)` : "[*] Watch mode: OFF");
+      }
+      break;
+    case "watch_change": {
+      const entry = { file: update.data.file, time: new Date(update.timestamp).toLocaleTimeString("en-US", { hour12: false }) };
+      s.watch = {
+        ...s.watch,
+        recentChanges: [entry, ...s.watch.recentChanges].slice(0, 5),
+        lastChange: entry.time
+      };
+      s = addActivity(s, `Change detected: ${update.data.file}`);
+      break;
+    }
+    case "signal_extracted": {
+      const se = { ...s.signalExtraction };
+      if (update.data.decisions) se.decisionsExtracted += update.data.decisions;
+      if (update.data.facts) se.factsExtracted += update.data.facts;
+      if (update.data.blockers) se.blockersExtracted += update.data.blockers;
+      if (update.data.questions) se.questionsExtracted += update.data.questions;
+      s.signalExtraction = se;
+      const total = (update.data.decisions || 0) + (update.data.facts || 0) + (update.data.blockers || 0) + (update.data.questions || 0);
+      if (total > 0) {
+        s = addActivity(s, `[+] Extracted ${total} signals (${update.data.decisions}d, ${update.data.facts}f, ${update.data.blockers}b)`);
+      }
+      break;
+    }
+    case "memory":
+      if (update.data.action === "saving") s = addActivity(s, "[~] Saving to memory...");
+      else if (update.data.action === "saved") s = addActivity(s, `[+] Memory updated: ${update.data.details || "context saved"}`);
+      else if (update.data.action === "learning") s = addActivity(s, `[~] Learning: ${update.data.details || "analyzing patterns"}`);
+      break;
+    case "raw_log":
+      s.rawLog = [{
+        time: update.data.time || new Date(update.timestamp).toLocaleTimeString("en-US", { hour12: false }),
+        level: update.data.level,
+        message: update.data.message
+      }, ...s.rawLog].slice(0, 500);
+      break;
+  }
+  return s;
+}
+function applyAgentConfigPatch(current, patch) {
+  const config = { ...current };
+  if (patch.agentSmith) {
+    config.agentSmith = {
+      ...config.agentSmith,
+      ...patch.agentSmith,
+      enabledCategories: {
+        ...config.agentSmith.enabledCategories,
+        ...patch.agentSmith.enabledCategories || {}
+      }
+    };
+  }
+  if (patch.performance) config.performance = { ...config.performance, ...patch.performance };
+  if (patch.riskThresholds) config.riskThresholds = { ...config.riskThresholds, ...patch.riskThresholds };
+  return config;
+}
+function dashboardReducer(state, action) {
+  switch (action.type) {
+    case "STREAM_UPDATE":
+      return handleStreamUpdate(state, action.update);
+    case "SET_VIEW":
+      return { ...state, previousView: state.view, view: action.view };
+    case "GO_BACK":
+      return { ...state, view: state.previousView || "overview", previousView: null };
+    case "ADD_ACTIVITY":
+      return addActivity(state, action.message);
+    case "SHOW_NOTIFICATION": {
+      const now = Date.now();
+      const historyEntry = {
+        message: action.message,
+        severity: action.severity,
+        timestamp: now,
+        dismissed: false
+      };
+      if (action.file !== void 0) historyEntry.file = action.file;
+      const notification = {
+        active: true,
+        message: action.message,
+        severity: action.severity,
+        timestamp: now
+      };
+      if (action.file !== void 0) notification.file = action.file;
+      if (action.autoHideMs !== void 0) notification.autoHideAt = now + action.autoHideMs;
+      let s = {
+        ...state,
+        notification,
+        notificationHistory: [historyEntry, ...state.notificationHistory].slice(0, 50)
+      };
+      const prefix = action.severity === "critical" ? "[!]" : action.severity === "warning" ? "[!]" : "[>]";
+      s = addActivity(s, `${prefix} ${action.message}`);
+      return s;
+    }
+    case "DISMISS_NOTIFICATION": {
+      if (!state.notification) return state;
+      const history = state.notificationHistory.map(
+        (h) => h.timestamp === state.notification?.timestamp ? { ...h, dismissed: true } : h
+      );
+      return { ...state, notification: null, notificationHistory: history };
+    }
+    case "SET_INSIGHTS":
+      return { ...state, agentInsights: action.insights };
+    case "ADD_INSIGHTS": {
+      const existing = state.agentInsights;
+      const newOnes = action.insights.filter(
+        (ni) => !existing.some((ei) => ei.message === ni.message && !ei.dismissed)
+      );
+      const merged = [...newOnes, ...existing].slice(0, 50);
+      let s = { ...state, agentInsights: merged };
+      if (newOnes.length > 0) {
+        s = addActivity(s, `Trie Agent: ${newOnes.length} new insight${newOnes.length > 1 ? "s" : ""}`);
+      }
+      return s;
+    }
+    case "SET_AGENT_INITIALIZED":
+      return { ...state, agentInitialized: action.initialized };
+    case "SET_AGENCY_STATUS":
+      return { ...state, agencyStatus: action.status };
+    case "SELECT_INSIGHT":
+      return { ...state, selectedInsight: action.index };
+    case "TOGGLE_INSIGHT":
+      return {
+        ...state,
+        expandedInsight: state.expandedInsight === action.index ? null : action.index
+      };
+    case "DISMISS_INSIGHT": {
+      const visible = getVisibleInsights(state);
+      const insight = visible[action.index];
+      if (!insight) return state;
+      const insights = state.agentInsights.map(
+        (i) => i.id === insight.id ? { ...i, dismissed: true } : i
+      );
+      const remaining = insights.filter((i) => !i.dismissed);
+      return {
+        ...state,
+        agentInsights: insights,
+        selectedInsight: Math.min(state.selectedInsight, Math.max(0, remaining.length - 1)),
+        expandedInsight: state.expandedInsight === action.index ? null : state.expandedInsight
+      };
+    }
+    case "IGNORE_INSIGHT": {
+      const visible = getVisibleInsights(state);
+      const insight = visible[action.index];
+      if (!insight) return state;
+      const insights = state.agentInsights.map(
+        (i) => i.id === insight.id ? { ...i, dismissed: true } : i
+      );
+      const remaining = insights.filter((i) => !i.dismissed);
+      let s = { ...state, agentInsights: insights };
+      s.selectedInsight = Math.min(s.selectedInsight, Math.max(0, remaining.length - 1));
+      s.expandedInsight = s.expandedInsight === action.index ? null : s.expandedInsight;
+      s = addActivity(s, `Ignored: ${insight.message.slice(0, 40)}...`);
+      return s;
+    }
+    case "CLEAR_DISMISSED_INSIGHTS": {
+      const dismissedCount = state.agentInsights.filter((i) => i.dismissed).length;
+      if (dismissedCount === 0) return addActivity(state, "No dismissed insights to clear");
+      const filtered = state.agentInsights.filter((i) => !i.dismissed);
+      let s = {
+        ...state,
+        agentInsights: filtered,
+        notificationHistory: [],
+        expandedInsight: null,
+        scrollPositions: { ...state.scrollPositions, agent: 0 }
+      };
+      s.selectedInsight = Math.min(s.selectedInsight, Math.max(0, filtered.length - 1));
+      s = addActivity(s, `Cleared ${dismissedCount} dismissed insight${dismissedCount !== 1 ? "s" : ""}`);
+      return s;
+    }
+    case "SET_GOALS":
+      return { ...state, goalsPanel: { ...state.goalsPanel, goals: action.goals } };
+    case "SET_GOALS_INPUT_MODE":
+      return { ...state, goalsPanel: { ...state.goalsPanel, inputMode: action.mode, inputBuffer: action.mode === "add" ? "" : state.goalsPanel.inputBuffer } };
+    case "SET_GOALS_INPUT_BUFFER":
+      return { ...state, goalsPanel: { ...state.goalsPanel, inputBuffer: action.buffer } };
+    case "SELECT_GOAL":
+      return { ...state, goalsPanel: { ...state.goalsPanel, selectedIndex: action.index } };
+    case "SET_HYPOTHESES":
+      return { ...state, hypothesesPanel: { ...state.hypothesesPanel, hypotheses: action.hypotheses } };
+    case "SET_HYPOTHESES_INPUT_MODE":
+      return { ...state, hypothesesPanel: { ...state.hypothesesPanel, inputMode: action.mode, inputBuffer: action.mode === "add" ? "" : state.hypothesesPanel.inputBuffer } };
+    case "SET_HYPOTHESES_INPUT_BUFFER":
+      return { ...state, hypothesesPanel: { ...state.hypothesesPanel, inputBuffer: action.buffer } };
+    case "SELECT_HYPOTHESIS":
+      return { ...state, hypothesesPanel: { ...state.hypothesesPanel, selectedIndex: action.index } };
+    case "SET_MEMORY_TREE":
+      return {
+        ...state,
+        memoryTree: { ...state.memoryTree, loaded: true, issues: action.issues, stats: action.stats, globalPatterns: action.patterns }
+      };
+    case "SELECT_MEMORY_NODE":
+      return { ...state, memoryTree: { ...state.memoryTree, selectedNode: action.nodeId } };
+    case "TOGGLE_MEMORY_NODE": {
+      const expandable = ["severity", "files", "agents", "patterns", "severity-critical", "severity-serious", "severity-moderate", "severity-low"];
+      if (!expandable.includes(action.nodeId)) return state;
+      const expanded = new Set(state.memoryTree.expandedNodes);
+      if (expanded.has(action.nodeId)) expanded.delete(action.nodeId);
+      else expanded.add(action.nodeId);
+      return { ...state, memoryTree: { ...state.memoryTree, expandedNodes: expanded } };
+    }
+    case "SET_AGENT_CONFIG":
+      return { ...state, agentConfig: applyAgentConfigPatch(state.agentConfig, action.config) };
+    case "NAVIGATE_UP": {
+      if (state.view === "agent") {
+        const visible = getVisibleInsights(state);
+        if (visible.length === 0) return state;
+        const idx = Math.max(0, state.selectedInsight - 1);
+        const scroll = Math.min(state.scrollPositions.agent, idx);
+        return { ...state, selectedInsight: idx, scrollPositions: { ...state.scrollPositions, agent: scroll } };
+      }
+      if (state.view === "memory") {
+        const nodes = getMemoryTreeNodes(state);
+        const cur = nodes.findIndex((n) => n.id === state.memoryTree.selectedNode);
+        if (cur > 0) {
+          return { ...state, memoryTree: { ...state.memoryTree, selectedNode: nodes[cur - 1]?.id || "severity" } };
+        }
+        return state;
+      }
+      return state;
+    }
+    case "NAVIGATE_DOWN": {
+      if (state.view === "agent") {
+        const visible = getVisibleInsights(state);
+        if (visible.length === 0) return state;
+        const maxIdx = Math.max(0, visible.length - 1);
+        const idx = Math.min(maxIdx, state.selectedInsight + 1);
+        const visibleItems = Math.floor(20 / 4);
+        let scroll = state.scrollPositions.agent;
+        if (idx >= scroll + visibleItems) scroll = idx - visibleItems + 1;
+        return { ...state, selectedInsight: idx, scrollPositions: { ...state.scrollPositions, agent: scroll } };
+      }
+      if (state.view === "memory") {
+        const nodes = getMemoryTreeNodes(state);
+        const cur = nodes.findIndex((n) => n.id === state.memoryTree.selectedNode);
+        if (cur < nodes.length - 1) {
+          return { ...state, memoryTree: { ...state.memoryTree, selectedNode: nodes[cur + 1]?.id || "severity" } };
+        }
+        return state;
+      }
+      return state;
+    }
+    case "NEXT_PAGE":
+      return { ...state, activityPage: Math.min(Math.max(1, Math.ceil(state.activityLog.length / 6)) - 1, state.activityPage + 1) };
+    case "PREV_PAGE":
+      return { ...state, activityPage: Math.max(0, state.activityPage - 1) };
+    case "SET_RAW_LOG_PAGE":
+      return { ...state, rawLogPage: action.page };
+    case "AUTO_DISMISS_NOTIFICATIONS": {
+      const now = Date.now();
+      let changed = false;
+      const history = state.notificationHistory.map((n) => {
+        if (!n.dismissed && n.severity !== "critical") {
+          const age = now - n.timestamp;
+          const autoHideMs = n.severity === "info" ? 3e4 : 6e4;
+          if (age > autoHideMs) {
+            changed = true;
+            return { ...n, dismissed: true };
+          }
+        }
+        return n;
+      });
+      if (!changed) return state;
+      return { ...state, notificationHistory: history };
+    }
+    default:
+      return state;
+  }
+}
+function createInitialState() {
+  return {
+    issues: [],
+    progress: {
+      totalFiles: 0,
+      processedFiles: 0,
+      activeAgents: [],
+      completedAgents: [],
+      totalIssues: 0,
+      issuesBySeverity: { critical: 0, serious: 0, moderate: 0, low: 0 }
+    },
+    filter: { severity: "all", agent: "all", search: "" },
+    view: "overview",
+    previousView: null,
+    lastUpdate: Date.now(),
+    scanComplete: true,
+    startTime: Date.now(),
+    scanStartTime: Date.now(),
+    activityLog: [],
+    activityPage: 0,
+    quietMode: false,
+    signalExtraction: {
+      enabled: !!process.env["ANTHROPIC_API_KEY"],
+      decisionsExtracted: 0,
+      factsExtracted: 0,
+      blockersExtracted: 0,
+      questionsExtracted: 0
+    },
+    alerts: { hasCritical: false },
+    watch: { watching: false, directories: 0, recentChanges: [] },
+    rawLog: [],
+    rawLogPage: 0,
+    scrollPositions: { overview: 0, rawlog: 0, agent: 0, goals: 0, hypotheses: 0, memory: 0 },
+    notification: null,
+    notificationHistory: [],
+    agentInsights: [],
+    agentInitialized: false,
+    agencyStatus: null,
+    selectedInsight: 0,
+    expandedInsight: null,
+    agentConfig: {
+      agentSmith: {
+        aiEnhancement: true,
+        minSeverity: "low",
+        enabledCategories: { security: true, codeSmells: true, asyncBugs: true, reactPatterns: true, uxPatterns: true, backendPatterns: true },
+        memoryRetentionDays: 30
+      },
+      performance: { parallel: true, cache: true, maxConcurrency: 4, timeoutMs: 12e4, workers: true, streaming: true },
+      riskThresholds: { critical: 70, high: 40, medium: 20 }
+    },
+    goalsPanel: { goals: [], selectedIndex: 0, selectedAchievedIndex: 0, inputMode: "browse", inputBuffer: "", lastRefresh: 0 },
+    hypothesesPanel: { hypotheses: [], selectedIndex: 0, selectedCompletedIndex: 0, inputMode: "browse", inputBuffer: "", lastRefresh: 0 },
+    memoryTree: { loaded: false, issues: [], stats: null, globalPatterns: [], expandedNodes: /* @__PURE__ */ new Set(["severity", "files"]), selectedNode: "severity", scrollPosition: 0, lastRefresh: 0 }
+  };
+}
+var DashboardContext = createContext(null);
+function DashboardProvider({ children, initialState }) {
+  const [state, dispatch] = useReducer(dashboardReducer, initialState || createInitialState());
+  const value = React.useMemo(() => ({ state, dispatch }), [state, dispatch]);
+  return /* @__PURE__ */ jsx(DashboardContext.Provider, { value, children });
+}
+function useDashboard() {
+  const ctx = useContext(DashboardContext);
+  if (!ctx) throw new Error("useDashboard must be used within DashboardProvider");
+  return ctx;
+}
+
+// src/utils/output-manager.ts
+import pc from "picocolors";
+var OutputManagerImpl = class {
+  mode = "console";
+  streamingManager;
+  markdownBuffer = [];
+  jsonBuffer = [];
+  rawLogBuffer = [];
+  // Callbacks for TUI integration (explicitly allow undefined for exactOptionalPropertyTypes)
+  onBanner = void 0;
+  onSnippet = void 0;
+  onCost = void 0;
+  onReadiness = void 0;
+  onSemantic = void 0;
+  onAttack = void 0;
+  onActivity = void 0;
+  onLog = void 0;
+  onNudge = void 0;
+  /**
+   * Set the output mode
+   */
+  setMode(mode) {
+    this.mode = mode;
+  }
+  /**
+   * Get current output mode
+   */
+  getMode() {
+    return this.mode;
+  }
+  /**
+   * Set streaming manager for TUI updates
+   */
+  setStreamingManager(manager) {
+    this.streamingManager = manager;
+  }
+  /**
+   * Register TUI callbacks for rich content
+   */
+  registerTUICallbacks(callbacks) {
+    this.onBanner = callbacks.onBanner;
+    this.onSnippet = callbacks.onSnippet;
+    this.onCost = callbacks.onCost;
+    this.onReadiness = callbacks.onReadiness;
+    this.onSemantic = callbacks.onSemantic;
+    this.onAttack = callbacks.onAttack;
+    this.onActivity = callbacks.onActivity;
+    this.onLog = callbacks.onLog;
+    this.onNudge = callbacks.onNudge;
+  }
+  /**
+   * Clear TUI callbacks (when dashboard stops)
+   */
+  clearTUICallbacks() {
+    this.onBanner = void 0;
+    this.onSnippet = void 0;
+    this.onCost = void 0;
+    this.onReadiness = void 0;
+    this.onSemantic = void 0;
+    this.onAttack = void 0;
+    this.onActivity = void 0;
+    this.onLog = void 0;
+    this.onNudge = void 0;
+  }
+  /**
+   * Emit content - routes to appropriate handler based on mode
+   */
+  emit(content) {
+    content.timestamp = content.timestamp ?? Date.now();
+    switch (this.mode) {
+      case "tui":
+        this.routeToTUI(content);
+        break;
+      case "console":
+        this.routeToConsole(content);
+        break;
+      case "mcp":
+        this.routeToMarkdown(content);
+        break;
+      case "json":
+        this.routeToJson(content);
+        break;
+      case "silent":
+        break;
+    }
+    this.captureRawLog(content);
+  }
+  /**
+   * Route content to TUI (dashboard callbacks)
+   */
+  routeToTUI(content) {
+    switch (content.type) {
+      case "banner":
+        this.onBanner?.(content.content);
+        break;
+      case "snippet":
+        this.onSnippet?.(content.content);
+        break;
+      case "cost":
+        this.onCost?.(content.content);
+        break;
+      case "readiness":
+        this.onReadiness?.(content.content);
+        break;
+      case "semantic":
+        this.onSemantic?.(content.content);
+        break;
+      case "attack":
+        this.onAttack?.(content.content);
+        break;
+      case "activity":
+        this.onActivity?.(content.content);
+        break;
+      case "log":
+        const level = content.metadata?.severity ?? "info";
+        this.onLog?.(level, content.content);
+        break;
+      case "issue":
+        this.streamingManager?.reportIssue(content.content);
+        break;
+      case "progress":
+        break;
+      case "report":
+        break;
+      case "nudge":
+        this.onNudge?.(content.content);
+        break;
+    }
+  }
+  /**
+   * Route content to console (ANSI formatted)
+   */
+  routeToConsole(content) {
+    switch (content.type) {
+      case "banner":
+        const banner = content.content;
+        console.error("\n" + "=".repeat(60));
+        console.error(banner.art);
+        if (banner.version) {
+          console.error(`        ${banner.skill} v${banner.version}`);
+        }
+        console.error("");
+        if (banner.quote) {
+          console.error(`   "${banner.quote}"`);
+        }
+        console.error("=".repeat(60) + "\n");
+        break;
+      case "snippet":
+        const snippet = content.content;
+        console.error(`
+${pc.dim("File:")} ${snippet.file}`);
+        for (let i = 0; i < snippet.lines.length; i++) {
+          const lineNum = snippet.startLine + i;
+          const isHighlight = lineNum === snippet.highlightLine;
+          const prefix = isHighlight ? pc.red("\u2192") : " ";
+          const lineNumStr = pc.dim(lineNum.toString().padStart(4));
+          const line = isHighlight ? pc.yellow(snippet.lines[i]) : snippet.lines[i];
+          console.error(`${prefix} ${lineNumStr} | ${line}`);
+        }
+        console.error("");
+        break;
+      case "cost":
+        const cost = content.content;
+        console.error("\n" + pc.cyan("[$] Cost Estimate:"));
+        console.error(`   Fix now: ${pc.green(this.formatCurrency(cost.fixNowCost))}`);
+        console.error(`   If production: ${pc.red(this.formatCurrency(cost.productionCost))}`);
+        console.error(`   Savings: ${pc.yellow(this.formatCurrency(cost.savings))}`);
+        console.error("");
+        break;
+      case "readiness":
+        const readiness = content.content;
+        const statusColor = readiness.status === "ready" ? pc.green : readiness.status === "caution" ? pc.yellow : pc.red;
+        console.error("\n" + pc.cyan("[%] Production Readiness:"));
+        console.error(`   Score: ${statusColor(readiness.score + "/100")}`);
+        console.error(`   Requirements: ${readiness.requirementsMet}/${readiness.total}`);
+        console.error(`   Status: ${statusColor(readiness.status.toUpperCase())}`);
+        console.error("");
+        break;
+      case "semantic":
+        const semantic = content.content;
+        console.error("\n" + pc.cyan("[?] Semantic Analysis:"));
+        if (semantic.dataFlowIssues > 0) {
+          console.error(`   ${pc.red("[!]")} ${semantic.dataFlowIssues} data flow vulnerabilities`);
+        }
+        if (semantic.raceConditions > 0) {
+          console.error(`   ${pc.yellow("[~]")} ${semantic.raceConditions} race conditions`);
+        }
+        if (semantic.authIssues > 0) {
+          console.error(`   ${pc.red("[!]")} ${semantic.authIssues} authentication issues`);
+        }
+        console.error("");
+        break;
+      case "attack":
+        const attack = content.content;
+        console.error("\n" + pc.cyan("[>] Attack Surface:"));
+        console.error(`   Endpoints: ${attack.totalEndpoints}`);
+        if (attack.unprotected > 0) {
+          console.error(`   ${pc.red("Unprotected:")} ${attack.unprotected}`);
+        }
+        console.error(`   Risk Score: ${attack.riskScore}/100`);
+        console.error("");
+        break;
+      case "activity":
+        console.error(pc.dim(`[${this.formatTime()}]`) + ` ${content.content}`);
+        break;
+      case "log":
+        const logLevel = String(content.metadata?.severity ?? "info");
+        const levelColor = logLevel === "error" || logLevel === "critical" ? pc.red : logLevel === "warn" || logLevel === "serious" ? pc.yellow : logLevel === "info" || logLevel === "moderate" ? pc.blue : pc.dim;
+        console.error(levelColor(`[${logLevel.toUpperCase()}]`) + ` ${content.content}`);
+        break;
+      case "issue":
+        const issue = content.content;
+        const sevColor = issue.severity === "critical" ? pc.red : issue.severity === "serious" ? pc.yellow : issue.severity === "moderate" ? pc.blue : pc.dim;
+        console.error(`${sevColor(`[${issue.severity.toUpperCase()}]`)} ${issue.issue}`);
+        console.error(`   ${pc.dim("File:")} ${issue.file}:${issue.line ?? "?"}`);
+        break;
+      case "report":
+        console.error(content.content);
+        break;
+      case "nudge":
+        const nudge = content.content;
+        const nudgeColor = nudge.severity === "critical" ? pc.red : nudge.severity === "warning" ? pc.yellow : pc.cyan;
+        const nudgeIcon = nudge.severity === "critical" ? "[!!!]" : nudge.severity === "warning" ? "[!]" : "[>]";
+        console.error("");
+        console.error(nudgeColor("\u2501".repeat(60)));
+        console.error(nudgeColor(`${nudgeIcon}  TRIE AGENT SAYS:`));
+        console.error(nudgeColor("\u2501".repeat(60)));
+        console.error("");
+        console.error(`   ${pc.bold(nudge.message)}`);
+        if (nudge.file) {
+          console.error(`   ${pc.dim("File:")} ${nudge.file}`);
+        }
+        console.error("");
+        console.error(nudgeColor("\u2501".repeat(60)));
+        console.error("");
+        break;
+    }
+  }
+  /**
+   * Route content to markdown buffer
+   */
+  routeToMarkdown(content) {
+    switch (content.type) {
+      case "banner":
+        const banner = content.content;
+        this.markdownBuffer.push(`## ${banner.skill}
+`);
+        if (banner.quote) {
+          this.markdownBuffer.push(`> ${banner.quote}
+`);
+        }
+        break;
+      case "snippet":
+        const snippet = content.content;
+        this.markdownBuffer.push(`
+**File:** \`${snippet.file}\`
+`);
+        this.markdownBuffer.push("```\n");
+        for (let i = 0; i < snippet.lines.length; i++) {
+          const lineNum = snippet.startLine + i;
+          const prefix = lineNum === snippet.highlightLine ? "\u2192" : " ";
+          this.markdownBuffer.push(`${prefix} ${lineNum.toString().padStart(4)} | ${snippet.lines[i]}
+`);
+        }
+        this.markdownBuffer.push("```\n");
+        break;
+      case "cost":
+        const cost = content.content;
+        this.markdownBuffer.push(`
+### Cost Estimate
+`);
+        this.markdownBuffer.push(`- Fix now: ${this.formatCurrency(cost.fixNowCost)}
+`);
+        this.markdownBuffer.push(`- If production: ${this.formatCurrency(cost.productionCost)}
+`);
+        this.markdownBuffer.push(`- Savings: ${this.formatCurrency(cost.savings)}
+`);
+        break;
+      case "readiness":
+        const readiness = content.content;
+        this.markdownBuffer.push(`
+### Production Readiness
+`);
+        this.markdownBuffer.push(`- Score: ${readiness.score}/100
+`);
+        this.markdownBuffer.push(`- Requirements: ${readiness.requirementsMet}/${readiness.total}
+`);
+        this.markdownBuffer.push(`- Status: **${readiness.status.toUpperCase()}**
+`);
+        break;
+      case "semantic":
+        const semantic = content.content;
+        this.markdownBuffer.push(`
+### Semantic Analysis
+`);
+        if (semantic.dataFlowIssues > 0) {
+          this.markdownBuffer.push(`- [CRITICAL] ${semantic.dataFlowIssues} data flow vulnerabilities
+`);
+        }
+        if (semantic.raceConditions > 0) {
+          this.markdownBuffer.push(`- [WARN] ${semantic.raceConditions} race conditions
+`);
+        }
+        if (semantic.authIssues > 0) {
+          this.markdownBuffer.push(`- [CRITICAL] ${semantic.authIssues} authentication issues
+`);
+        }
+        break;
+      case "attack":
+        const attack = content.content;
+        this.markdownBuffer.push(`
+### Attack Surface
+`);
+        this.markdownBuffer.push(`- Endpoints: ${attack.totalEndpoints}
+`);
+        this.markdownBuffer.push(`- Unprotected: ${attack.unprotected}
+`);
+        this.markdownBuffer.push(`- Risk Score: ${attack.riskScore}/100
+`);
+        break;
+      case "report":
+        this.markdownBuffer.push(content.content);
+        break;
+      default:
+        this.jsonBuffer.push(content);
+    }
+  }
+  /**
+   * Route content to JSON buffer
+   */
+  routeToJson(content) {
+    this.jsonBuffer.push(content);
+  }
+  /**
+   * Capture content in raw log buffer
+   */
+  captureRawLog(content) {
+    const time = this.formatTime(content.timestamp);
+    const level = content.metadata?.severity ?? content.type;
+    let message = "";
+    switch (content.type) {
+      case "banner":
+        message = `[BANNER] ${content.content.skill}`;
+        break;
+      case "activity":
+      case "log":
+        message = content.content;
+        break;
+      case "issue":
+        const issue = content.content;
+        message = `[${issue.severity.toUpperCase()}] ${issue.issue}`;
+        break;
+      default:
+        message = `[${content.type.toUpperCase()}] Content received`;
+    }
+    this.rawLogBuffer.push({ time, level, message });
+    if (this.rawLogBuffer.length > 500) {
+      this.rawLogBuffer = this.rawLogBuffer.slice(-500);
+    }
+  }
+  /**
+   * Get raw log buffer for display
+   */
+  getRawLog() {
+    return [...this.rawLogBuffer];
+  }
+  /**
+   * Get accumulated markdown output
+   */
+  getMarkdown() {
+    return this.markdownBuffer.join("\n");
+  }
+  /**
+   * Get accumulated JSON output
+   */
+  getJson() {
+    return [...this.jsonBuffer];
+  }
+  /**
+   * Clear buffers
+   */
+  clearBuffers() {
+    this.markdownBuffer = [];
+    this.jsonBuffer = [];
+  }
+  // ============================================
+  // Convenience methods for common output types
+  // ============================================
+  /**
+   * Display a skill banner
+   */
+  banner(skill, art, options) {
+    this.emit({
+      type: "banner",
+      content: { skill, art, quote: options?.quote, version: options?.version },
+      metadata: { agent: skill }
+    });
+  }
+  /**
+   * Display a code snippet
+   */
+  snippet(file, lines, startLine, highlightLine) {
+    this.emit({
+      type: "snippet",
+      content: { file, lines, startLine, highlightLine },
+      metadata: { file }
+    });
+  }
+  /**
+   * Display cost estimate
+   */
+  cost(fixNowCost, productionCost, savings, perIssue) {
+    this.emit({
+      type: "cost",
+      content: { fixNowCost, productionCost, savings, perIssue }
+    });
+  }
+  /**
+   * Display production readiness
+   */
+  readiness(score, requirementsMet, total, status, requirements) {
+    const content = { score, requirementsMet, total, status };
+    if (requirements) {
+      content.requirements = requirements;
+    }
+    this.emit({
+      type: "readiness",
+      content
+    });
+  }
+  /**
+   * Display semantic analysis results
+   */
+  semantic(dataFlowIssues, raceConditions, authIssues) {
+    this.emit({
+      type: "semantic",
+      content: { dataFlowIssues, raceConditions, authIssues }
+    });
+  }
+  /**
+   * Display attack surface analysis
+   */
+  attack(totalEndpoints, unprotected, riskScore) {
+    this.emit({
+      type: "attack",
+      content: { totalEndpoints, unprotected, riskScore }
+    });
+  }
+  /**
+   * Log an activity message
+   */
+  activity(message) {
+    this.emit({
+      type: "activity",
+      content: message
+    });
+  }
+  /**
+   * Log a message at specified level
+   */
+  log(level, message) {
+    this.emit({
+      type: "log",
+      content: message,
+      metadata: { severity: level }
+    });
+  }
+  /**
+   * Log info message
+   */
+  info(message) {
+    this.log("info", message);
+  }
+  /**
+   * Log warning message
+   */
+  warn(message) {
+    this.log("warn", message);
+  }
+  /**
+   * Log error message
+   */
+  error(message) {
+    this.log("error", message);
+  }
+  /**
+   * Log debug message
+   */
+  debug(message) {
+    this.log("debug", message);
+  }
+  /**
+   * Report an issue
+   */
+  issue(issue) {
+    this.emit({
+      type: "issue",
+      content: issue,
+      metadata: { severity: issue.severity, agent: issue.agent, file: issue.file }
+    });
+  }
+  /**
+   * Add a report section
+   */
+  report(content) {
+    this.emit({
+      type: "report",
+      content
+    });
+  }
+  /**
+   * Send a proactive notification/nudge to the user
+   * This creates a prominent popup in TUI mode or a boxed message in console mode
+   */
+  nudge(message, severity = "warning", file, autoHideMs) {
+    const metadata = {};
+    if (severity === "critical") metadata.severity = "critical";
+    else if (severity === "warning") metadata.severity = "moderate";
+    else metadata.severity = "low";
+    if (file !== void 0) metadata.file = file;
+    this.emit({
+      type: "nudge",
+      content: { message, severity, file, autoHideMs },
+      metadata
+    });
+  }
+  // ============================================
+  // Helpers
+  // ============================================
+  formatCurrency(amount) {
+    if (amount >= 1e6) return `$${(amount / 1e6).toFixed(2)}M`;
+    if (amount >= 1e3) return `$${(amount / 1e3).toFixed(1)}k`;
+    return `$${amount}`;
+  }
+  formatTime(timestamp) {
+    const date = timestamp ? new Date(timestamp) : /* @__PURE__ */ new Date();
+    return date.toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+  }
+};
+var instance = null;
+function getOutputManager() {
+  if (!instance) {
+    instance = new OutputManagerImpl();
+    if (isInteractiveMode()) {
+      instance.setMode("tui");
+    }
+  }
+  return instance;
+}
+
+// src/cli/dashboard/App.tsx
+import { existsSync } from "fs";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+
+// src/cli/dashboard/components/Header.tsx
+import { Box, Text } from "ink";
+
+// src/cli/dashboard/theme.ts
+import pc2 from "picocolors";
+var colors = {
+  border: (s) => pc2.cyan(s),
+  header: (s) => pc2.bold(pc2.cyan(s)),
+  brand: (s) => pc2.bold(pc2.cyan(s)),
+  dim: (s) => pc2.dim(s),
+  critical: (s) => pc2.bold(pc2.red(s)),
+  serious: (s) => pc2.yellow(s),
+  moderate: (s) => pc2.blue(s),
+  low: (s) => pc2.dim(s),
+  success: (s) => pc2.green(s),
+  running: (s) => pc2.yellow(s),
+  waiting: (s) => pc2.dim(s),
+  alert: (s) => pc2.bold(pc2.red(s)),
+  selected: (s) => pc2.bold(pc2.magenta(s)),
+  highlight: (s) => pc2.bold(pc2.white(s)),
+  yellow: (s) => pc2.yellow(s)
+};
+var WATCH_FRAMES = ["\u25D0", "\u25D3", "\u25D1", "\u25D2"];
+function formatTimeAgo(timestamp) {
+  const seconds = Math.floor((Date.now() - timestamp) / 1e3);
+  if (seconds < 10) return "just now";
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  return `${hours}h ago`;
+}
+function insightIcon(type) {
+  switch (type) {
+    case "warning":
+      return { icon: "[!]", color: colors.critical };
+    case "observation":
+      return { icon: "[>]", color: colors.serious };
+    case "suggestion":
+      return { icon: "[?]", color: colors.highlight };
+    case "celebration":
+      return { icon: "[+]", color: colors.success };
+    case "question":
+      return { icon: "[?]", color: colors.moderate };
+    default:
+      return { icon: "[>]", color: colors.dim };
+  }
+}
+function progressBar(current, total, width = 10) {
+  if (total <= 0) return colors.dim("[" + "\u2591".repeat(width) + "]");
+  const progress = Math.min(1, current / total);
+  const filled = Math.round(width * progress);
+  const empty = width - filled;
+  return colors.border("[") + colors.success("\u2588".repeat(filled)) + colors.dim("\u2591".repeat(empty)) + colors.border("]");
+}
+function stripEmojis(s) {
+  return s.replace(/[\u{1F300}-\u{1F9FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{FE00}-\u{FE0F}\u{200D}\u{20E3}\u{FE0F}\u{E0020}-\u{E007F}]/gu, "").trim();
+}
+
+// src/cli/dashboard/components/Header.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function Header() {
+  const { state } = useDashboard();
+  const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+  const frameIdx = Math.floor(Date.now() / 200) % WATCH_FRAMES.length;
+  const spinner = WATCH_FRAMES[frameIdx] || "\u25D0";
+  const { signalExtraction, watch, alerts } = state;
+  const totalExtracted = signalExtraction.decisionsExtracted + signalExtraction.factsExtracted + signalExtraction.blockersExtracted + signalExtraction.questionsExtracted;
+  let statusLabel;
+  if (watch.watching) {
+    statusLabel = totalExtracted > 0 ? /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsxs(Text, { color: "green", bold: true, children: [
+        spinner,
+        " LEARNING"
+      ] }),
+      "  ",
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        totalExtracted,
+        " signals"
+      ] })
+    ] }) : /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+        spinner,
+        " WATCHING"
+      ] }),
+      "  ",
+      /* @__PURE__ */ jsx2(Text, { dimColor: true, children: "ready" })
+    ] });
+  } else {
+    statusLabel = /* @__PURE__ */ jsx2(Text, { dimColor: true, children: "IDLE" });
+  }
+  const watchBadge = watch.watching ? /* @__PURE__ */ jsxs(Text, { color: "green", children: [
+    "[",
+    spinner,
+    " WATCHING]"
+  ] }) : /* @__PURE__ */ jsx2(Text, { dimColor: true, children: "[WATCH OFF]" });
+  return /* @__PURE__ */ jsxs(Box, { borderStyle: "single", borderColor: "cyan", paddingX: 1, justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx2(Text, { color: "cyan", bold: true, children: "TRIE" }),
+      watch.watching && /* @__PURE__ */ jsx2(Text, { dimColor: true, children: " [autonomous]" })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { gap: 2, children: [
+      statusLabel,
+      watchBadge,
+      alerts.hasCritical && /* @__PURE__ */ jsx2(Text, { color: "red", bold: true, children: "\u2502 ALERT: CRITICAL" }),
+      /* @__PURE__ */ jsx2(Text, { dimColor: true, children: time })
+    ] })
+  ] });
+}
+
+// src/cli/dashboard/components/Footer.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var VIEW_LABELS = {
+  overview: "Overview",
+  rawlog: "Log",
+  agent: "Agent",
+  goals: "Goals",
+  hypotheses: "Hypotheses",
+  memory: "Memory"
+};
+function Hint({ k, label }) {
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsx3(Text2, { color: "cyan", children: "[" }),
+    /* @__PURE__ */ jsx3(Text2, { bold: true, children: k }),
+    /* @__PURE__ */ jsx3(Text2, { color: "cyan", children: "]" }),
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      " ",
+      label
+    ] })
+  ] });
+}
+function Footer() {
+  const { state } = useDashboard();
+  const { view } = state;
+  const viewTabs = ["overview", "memory", "goals", "hypotheses", "agent"].map((v) => {
+    const isActive = v === view;
+    const label = VIEW_LABELS[v];
+    return isActive ? /* @__PURE__ */ jsx3(Text2, { color: "cyan", bold: true, inverse: true, children: ` ${label} ` }, v) : /* @__PURE__ */ jsx3(Text2, { dimColor: true, children: ` ${label} ` }, v);
+  });
+  let hints;
+  if (view === "goals" && state.goalsPanel.inputMode === "add") {
+    hints = /* @__PURE__ */ jsxs2(Box2, { gap: 2, children: [
+      /* @__PURE__ */ jsx3(Hint, { k: "Enter", label: "Save" }),
+      /* @__PURE__ */ jsx3(Hint, { k: "Esc", label: "Cancel" })
+    ] });
+  } else if (view === "hypotheses" && state.hypothesesPanel.inputMode === "add") {
+    hints = /* @__PURE__ */ jsxs2(Box2, { gap: 2, children: [
+      /* @__PURE__ */ jsx3(Hint, { k: "Enter", label: "Save" }),
+      /* @__PURE__ */ jsx3(Hint, { k: "Esc", label: "Cancel" })
+    ] });
+  } else if (view === "goals") {
+    hints = /* @__PURE__ */ jsxs2(Box2, { gap: 2, children: [
+      /* @__PURE__ */ jsx3(Hint, { k: "j/k", label: "Nav" }),
+      /* @__PURE__ */ jsx3(Hint, { k: "a", label: "Add" }),
+      /* @__PURE__ */ jsx3(Hint, { k: "Enter", label: "Complete" }),
+      /* @__PURE__ */ jsx3(Hint, { k: "d", label: "Delete" })
+    ] });
+  } else if (view === "hypotheses") {
+    hints = /* @__PURE__ */ jsxs2(Box2, { gap: 2, children: [
+      /* @__PURE__ */ jsx3(Hint, { k: "j/k", label: "Nav" }),
+      /* @__PURE__ */ jsx3(Hint, { k: "a", label: "Add" }),
+      /* @__PURE__ */ jsx3(Hint, { k: "v", label: "Validate" }),
+      /* @__PURE__ */ jsx3(Hint, { k: "x", label: "Invalidate" })
+    ] });
+  } else if (view === "agent") {
+    hints = /* @__PURE__ */ jsxs2(Box2, { gap: 2, children: [
+      /* @__PURE__ */ jsx3(Hint, { k: "j/k", label: "Nav" }),
+      /* @__PURE__ */ jsx3(Hint, { k: "Enter", label: "Expand" }),
+      /* @__PURE__ */ jsx3(Hint, { k: "d", label: "Dismiss" }),
+      /* @__PURE__ */ jsx3(Hint, { k: "i", label: "Ignore" }),
+      /* @__PURE__ */ jsx3(Hint, { k: "x", label: "Clear" })
+    ] });
+  } else if (view === "memory") {
+    hints = /* @__PURE__ */ jsxs2(Box2, { gap: 2, children: [
+      /* @__PURE__ */ jsx3(Hint, { k: "j/k", label: "Nav" }),
+      /* @__PURE__ */ jsx3(Hint, { k: "Enter", label: "Expand" }),
+      /* @__PURE__ */ jsx3(Hint, { k: "b", label: "Back" })
+    ] });
+  } else if (view === "rawlog") {
+    hints = /* @__PURE__ */ jsxs2(Box2, { gap: 2, children: [
+      /* @__PURE__ */ jsx3(Hint, { k: "n/p", label: "Pages" }),
+      /* @__PURE__ */ jsx3(Hint, { k: "b", label: "Back" })
+    ] });
+  } else {
+    hints = /* @__PURE__ */ jsxs2(Box2, { gap: 2, children: [
+      /* @__PURE__ */ jsx3(Hint, { k: "Tab", label: "Views" }),
+      /* @__PURE__ */ jsx3(Hint, { k: "n/p", label: "Pages" }),
+      /* @__PURE__ */ jsx3(Hint, { k: "h", label: "Help" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Box2, { borderStyle: "single", borderColor: "cyan", borderTop: false, borderLeft: false, borderRight: false, children: /* @__PURE__ */ jsx3(Box2, { gap: 0, children: viewTabs }) }),
+    /* @__PURE__ */ jsxs2(Box2, { paddingX: 1, justifyContent: "space-between", children: [
+      hints,
+      /* @__PURE__ */ jsx3(Hint, { k: "q", label: "Quit" })
+    ] })
+  ] });
+}
+
+// src/cli/dashboard/components/Notification.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function Notification() {
+  const { state } = useDashboard();
+  const { notification } = state;
+  if (!notification || !notification.active) return null;
+  if (notification.autoHideAt && Date.now() > notification.autoHideAt) return null;
+  const bgColor = notification.severity === "critical" ? "red" : notification.severity === "warning" ? "yellow" : "blue";
+  const icon = notification.severity === "critical" ? "[!]" : notification.severity === "warning" ? "[!]" : "[>]";
+  return /* @__PURE__ */ jsxs3(Box3, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx4(Text3, { backgroundColor: bgColor, color: "white", bold: true, children: ` ${icon} ${notification.message} ` }),
+    notification.file && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      " (",
+      notification.file,
+      ")"
+    ] })
+  ] });
+}
+
+// src/cli/dashboard/components/ConfigDialog.tsx
+import { useState } from "react";
+import { Box as Box4, Text as Text4, useInput } from "ink";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function ConfigDialog({ onClose }) {
+  const { state, dispatch } = useDashboard();
+  const [section, setSection] = useState("main");
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [editing, setEditing] = useState(false);
+  const [editBuffer, setEditBuffer] = useState("");
+  const config = state.agentConfig;
+  const mainMenu = [
+    { label: "Agent Smith Settings", key: "agentSmith", value: config.agentSmith.aiEnhancement ? "AI Enhanced" : "Basic", section: "main" },
+    { label: "Performance Settings", key: "performance", value: `${config.performance.maxConcurrency} concurrent`, section: "main" },
+    { label: "Risk Thresholds", key: "riskThresholds", value: `critical: ${config.riskThresholds.critical}%`, section: "main" }
+  ];
+  const performanceItems = [
+    { label: "Max Concurrency", key: "maxConcurrency", value: String(config.performance.maxConcurrency), section: "performance" },
+    { label: "Timeout (ms)", key: "timeoutMs", value: String(config.performance.timeoutMs), section: "performance" },
+    { label: "Parallel", key: "parallel", value: config.performance.parallel ? "on" : "off", section: "performance" },
+    { label: "Cache", key: "cache", value: config.performance.cache ? "on" : "off", section: "performance" },
+    { label: "Workers", key: "workers", value: config.performance.workers ? "on" : "off", section: "performance" }
+  ];
+  const riskItems = [
+    { label: "Critical Threshold", key: "critical", value: String(config.riskThresholds.critical), section: "riskThresholds" },
+    { label: "High Threshold", key: "high", value: String(config.riskThresholds.high), section: "riskThresholds" },
+    { label: "Medium Threshold", key: "medium", value: String(config.riskThresholds.medium), section: "riskThresholds" }
+  ];
+  const items = section === "main" ? mainMenu : section === "performance" ? performanceItems : section === "riskThresholds" ? riskItems : mainMenu;
+  useInput((_input, key) => {
+    if (editing) {
+      if (key.escape) {
+        setEditing(false);
+        setEditBuffer("");
+      } else if (key.return) {
+        const item = items[selectedIndex];
+        if (item) {
+          const val = parseInt(editBuffer, 10);
+          if (!isNaN(val)) {
+            const patch = {};
+            if (section === "performance") {
+              if (item.key === "maxConcurrency" || item.key === "timeoutMs") {
+                patch.performance = { ...config.performance, [item.key]: val };
+              }
+            } else if (section === "riskThresholds") {
+              patch.riskThresholds = { ...config.riskThresholds, [item.key]: val };
+            }
+            if (Object.keys(patch).length > 0) {
+              dispatch({ type: "SET_AGENT_CONFIG", config: patch });
+              dispatch({ type: "ADD_ACTIVITY", message: `Config: ${item.label} set to ${val}` });
+            }
+          }
+        }
+        setEditing(false);
+        setEditBuffer("");
+      } else if (key.backspace || key.delete) {
+        setEditBuffer(editBuffer.slice(0, -1));
+      } else if (_input && /\d/.test(_input)) {
+        setEditBuffer(editBuffer + _input);
+      }
+      return;
+    }
+    if (key.escape || _input === "b") {
+      if (section === "main") onClose();
+      else {
+        setSection("main");
+        setSelectedIndex(0);
+      }
+    } else if (key.upArrow || _input === "k") {
+      setSelectedIndex(Math.max(0, selectedIndex - 1));
+    } else if (key.downArrow || _input === "j") {
+      setSelectedIndex(Math.min(items.length - 1, selectedIndex + 1));
+    } else if (key.return) {
+      if (section === "main") {
+        const item = items[selectedIndex];
+        if (item) {
+          setSection(item.key);
+          setSelectedIndex(0);
+        }
+      } else {
+        const item = items[selectedIndex];
+        if (item) {
+          if (["parallel", "cache", "workers"].includes(item.key)) {
+            const patch = {
+              performance: { ...config.performance, [item.key]: !config.performance[item.key] }
+            };
+            dispatch({ type: "SET_AGENT_CONFIG", config: patch });
+          } else {
+            setEditing(true);
+            setEditBuffer(item.value);
+          }
+        }
+      }
+    }
+  });
+  const sectionTitle = section === "main" ? "TRIE AGENT CONFIGURATION" : section === "performance" ? "PERFORMANCE SETTINGS" : section === "riskThresholds" ? "RISK THRESHOLDS" : section === "agentSmith" ? "AGENT SMITH SETTINGS" : "CONFIGURATION";
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, paddingY: 0, children: [
+    /* @__PURE__ */ jsx5(Text4, { color: "cyan", bold: true, children: sectionTitle }),
+    /* @__PURE__ */ jsx5(Text4, { children: " " }),
+    items.map((item, idx) => {
+      const isSelected = selectedIndex === idx;
+      return /* @__PURE__ */ jsxs4(Text4, { children: [
+        isSelected ? /* @__PURE__ */ jsx5(Text4, { bold: true, color: "magenta", children: "\u25B6 " }) : /* @__PURE__ */ jsx5(Text4, { children: "  " }),
+        /* @__PURE__ */ jsxs4(Text4, { bold: isSelected, children: [
+          item.label,
+          ": "
+        ] }),
+        editing && isSelected ? /* @__PURE__ */ jsxs4(Text4, { children: [
+          editBuffer,
+          /* @__PURE__ */ jsx5(Text4, { bold: true, color: "cyan", children: "\u258C" })
+        ] }) : /* @__PURE__ */ jsx5(Text4, { dimColor: true, children: item.value })
+      ] }, item.key);
+    }),
+    /* @__PURE__ */ jsx5(Text4, { children: " " }),
+    /* @__PURE__ */ jsx5(Text4, { dimColor: true, children: section === "main" ? "Enter to select \u2022 Esc to close" : "Enter to edit \u2022 Esc/b to go back" })
+  ] });
+}
+
+// src/cli/dashboard/views/OverviewView.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { Fragment, jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function OverviewView() {
+  const { state } = useDashboard();
+  const { progress, signalExtraction, watch, issues, activityLog, activityPage } = state;
+  const { issuesBySeverity, totalIssues, processedFiles } = progress;
+  const endTime = state.scanComplete && state.scanEndTime ? state.scanEndTime : Date.now();
+  const elapsed = ((endTime - state.scanStartTime) / 1e3).toFixed(1);
+  const totalExtracted = signalExtraction.decisionsExtracted + signalExtraction.factsExtracted + signalExtraction.blockersExtracted + signalExtraction.questionsExtracted;
+  const criticalIssues = issues.filter((i) => i.severity === "critical").slice(0, 3);
+  const activityRows = 8;
+  const startIdx = activityPage * activityRows;
+  const pageActivities = activityLog.slice(startIdx, startIdx + activityRows);
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      /* @__PURE__ */ jsx6(Text5, { bold: true, children: processedFiles }),
+      /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+        " files scanned in ",
+        elapsed,
+        "s"
+      ] })
+    ] }),
+    watch.watching && /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs5(Text5, { children: [
+        signalExtraction.enabled ? "[+]" : "[!]",
+        " Signal extraction:",
+        " ",
+        /* @__PURE__ */ jsx6(Text5, { dimColor: true, children: signalExtraction.enabled ? "enabled" : "limited (set ANTHROPIC_API_KEY)" })
+      ] }),
+      totalExtracted > 0 && /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+        "  \u2514 ",
+        signalExtraction.decisionsExtracted,
+        " decisions, ",
+        signalExtraction.factsExtracted,
+        " facts, ",
+        signalExtraction.blockersExtracted,
+        " blockers extracted"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx6(Text5, { children: " " }),
+    /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Text5, { color: "cyan", bold: true, children: "SUMMARY" }),
+      /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs5(Text5, { children: [
+          /* @__PURE__ */ jsxs5(Text5, { color: "red", bold: true, children: [
+            "[!] ",
+            String(issuesBySeverity.critical).padStart(4),
+            " Critical issues"
+          ] }),
+          issuesBySeverity.critical > 0 && /* @__PURE__ */ jsxs5(Text5, { color: "red", bold: true, children: [
+            "    ",
+            "<-",
+            " FIX NOW"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs5(Text5, { color: "yellow", children: [
+          "[x] ",
+          String(issuesBySeverity.serious).padStart(4),
+          " Serious issues"
+        ] }),
+        /* @__PURE__ */ jsxs5(Text5, { color: "blue", children: [
+          "[~] ",
+          String(issuesBySeverity.moderate).padStart(4),
+          " Moderate issues"
+        ] }),
+        /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+          "[-] ",
+          String(issuesBySeverity.low).padStart(4),
+          " Low issues"
+        ] })
+      ] })
+    ] }),
+    watch.watching && signalExtraction.enabled && /* @__PURE__ */ jsxs5(Fragment, { children: [
+      /* @__PURE__ */ jsx6(Text5, { children: " " }),
+      /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx6(Text5, { color: "cyan", bold: true, children: "DECISION LEDGER" }),
+        /* @__PURE__ */ jsxs5(Text5, { children: [
+          /* @__PURE__ */ jsx6(Text5, { bold: true, children: "Agent Learning" }),
+          /* @__PURE__ */ jsx6(Text5, { dimColor: true, children: " - Building institutional knowledge" })
+        ] }),
+        /* @__PURE__ */ jsx6(Text5, { children: " " }),
+        /* @__PURE__ */ jsx6(Text5, { dimColor: true, children: "Signals Extracted:" }),
+        /* @__PURE__ */ jsxs5(Text5, { children: [
+          "  ",
+          /* @__PURE__ */ jsx6(Text5, { bold: true, children: signalExtraction.decisionsExtracted }),
+          /* @__PURE__ */ jsx6(Text5, { dimColor: true, children: " decisions" })
+        ] }),
+        /* @__PURE__ */ jsxs5(Text5, { children: [
+          "  ",
+          /* @__PURE__ */ jsx6(Text5, { bold: true, children: signalExtraction.factsExtracted }),
+          /* @__PURE__ */ jsx6(Text5, { dimColor: true, children: " facts" })
+        ] }),
+        /* @__PURE__ */ jsxs5(Text5, { children: [
+          "  ",
+          /* @__PURE__ */ jsx6(Text5, { bold: true, children: signalExtraction.blockersExtracted }),
+          /* @__PURE__ */ jsx6(Text5, { dimColor: true, children: " blockers" })
+        ] }),
+        /* @__PURE__ */ jsxs5(Text5, { children: [
+          "  ",
+          /* @__PURE__ */ jsx6(Text5, { bold: true, children: signalExtraction.questionsExtracted }),
+          /* @__PURE__ */ jsx6(Text5, { dimColor: true, children: " questions" })
+        ] }),
+        /* @__PURE__ */ jsx6(Text5, { children: " " }),
+        /* @__PURE__ */ jsxs5(Text5, { children: [
+          /* @__PURE__ */ jsx6(Text5, { dimColor: true, children: "Use " }),
+          /* @__PURE__ */ jsx6(Text5, { bold: true, children: "trie gotcha" }),
+          /* @__PURE__ */ jsx6(Text5, { dimColor: true, children: " to query the ledger" })
+        ] })
+      ] })
+    ] }),
+    criticalIssues.length > 0 && /* @__PURE__ */ jsxs5(Fragment, { children: [
+      /* @__PURE__ */ jsx6(Text5, { children: " " }),
+      /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx6(Text5, { color: "red", bold: true, children: "TOP CRITICAL ISSUES" }),
+        criticalIssues.map((issue, i) => {
+          const filename = issue.file.split("/").pop() || issue.file;
+          const lineNum = issue.line ? `:${issue.line}` : "";
+          const desc = issue.issue.slice(0, 50) + (issue.issue.length > 50 ? "..." : "");
+          return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsxs5(Text5, { children: [
+              /* @__PURE__ */ jsx6(Text5, { color: "red", children: "\u25B8" }),
+              " ",
+              /* @__PURE__ */ jsx6(Text5, { color: "red", children: desc })
+            ] }),
+            /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+              "  ",
+              filename,
+              lineNum
+            ] })
+          ] }, i);
+        })
+      ] })
+    ] }),
+    totalIssues === 0 && criticalIssues.length === 0 && /* @__PURE__ */ jsxs5(Fragment, { children: [
+      /* @__PURE__ */ jsx6(Text5, { children: " " }),
+      /* @__PURE__ */ jsx6(Text5, { color: "green", children: "[ok] No issues found" })
+    ] }),
+    /* @__PURE__ */ jsx6(Text5, { children: " " }),
+    /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Text5, { color: "cyan", bold: true, children: "ACTIVITY LOG" }),
+      pageActivities.map((entry, i) => /* @__PURE__ */ jsxs5(Text5, { children: [
+        /* @__PURE__ */ jsx6(Text5, { dimColor: true, children: entry.time }),
+        "  ",
+        entry.message
+      ] }, i)),
+      pageActivities.length === 0 && /* @__PURE__ */ jsx6(Text5, { dimColor: true, children: "No activity yet." })
+    ] })
+  ] });
+}
+
+// src/cli/dashboard/views/AgentView.tsx
+import { Box as Box6, Text as Text6, useInput as useInput2 } from "ink";
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+function AgentView() {
+  const { state, dispatch } = useDashboard();
+  const { agentInsights, agencyStatus, selectedInsight, expandedInsight } = state;
+  const totalInsights = agentInsights.length;
+  const visibleInsights = getVisibleInsights(state);
+  const activeCount = visibleInsights.length;
+  useInput2((input, key) => {
+    if (key.upArrow || input === "k") {
+      dispatch({ type: "NAVIGATE_UP" });
+    } else if (key.downArrow || input === "j") {
+      dispatch({ type: "NAVIGATE_DOWN" });
+    } else if (key.return) {
+      dispatch({ type: "TOGGLE_INSIGHT", index: selectedInsight });
+    } else if (input === "d") {
+      dispatch({ type: "DISMISS_INSIGHT", index: selectedInsight });
+    } else if (input === "i") {
+      dispatch({ type: "IGNORE_INSIGHT", index: selectedInsight });
+    } else if (input === "x") {
+      dispatch({ type: "CLEAR_DISMISSED_INSIGHTS" });
+    }
+  });
+  const agency = agencyStatus;
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs6(Text6, { children: [
+      /* @__PURE__ */ jsx7(Text6, { color: "cyan", bold: true, children: "TRIE AGENT INSIGHTS" }),
+      activeCount > 0 ? /* @__PURE__ */ jsxs6(Text6, { color: "red", bold: true, children: [
+        " (",
+        activeCount,
+        " active)"
+      ] }) : /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+        " (",
+        totalInsights,
+        " total)"
+      ] }),
+      "  ",
+      /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "Your autonomous code companion" })
+    ] }),
+    agency && /* @__PURE__ */ jsxs6(Box6, { gap: 2, children: [
+      /* @__PURE__ */ jsxs6(Text6, { children: [
+        /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "Goals:" }),
+        " ",
+        /* @__PURE__ */ jsx7(Text6, { bold: true, children: agency.goals.active }),
+        "/",
+        agency.goals.completed + agency.goals.active
+      ] }),
+      /* @__PURE__ */ jsxs6(Text6, { children: [
+        /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "Hypo:" }),
+        " ",
+        /* @__PURE__ */ jsx7(Text6, { bold: true, children: agency.hypotheses.testing }),
+        " testing"
+      ] }),
+      /* @__PURE__ */ jsxs6(Text6, { children: [
+        /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "Risk:" }),
+        " ",
+        /* @__PURE__ */ jsx7(Text6, { color: agency.riskLevel === "critical" ? "red" : agency.riskLevel === "high" ? "yellow" : agency.riskLevel === "medium" ? "yellow" : "green", children: agency.riskLevel.toUpperCase() })
+      ] }),
+      /* @__PURE__ */ jsxs6(Text6, { children: [
+        /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "Effect:" }),
+        " ",
+        /* @__PURE__ */ jsxs6(Text6, { color: agency.effectiveness >= 80 ? "green" : agency.effectiveness >= 50 ? "yellow" : "yellow", children: [
+          agency.effectiveness,
+          "%"
+        ] })
+      ] }),
+      agency.isQuietHours && /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "[quiet]" })
+    ] }),
+    /* @__PURE__ */ jsx7(Text6, { children: " " }),
+    visibleInsights.length === 0 && state.notificationHistory.length === 0 ? /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx7(Text6, { bold: true, children: "The Trie Agent is watching over your code." }),
+      /* @__PURE__ */ jsx7(Text6, { children: " " }),
+      /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "Unlike a log viewer, the Trie Agent:" }),
+      /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "  \u2022 Synthesizes insights from all skills" }),
+      /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "  \u2022 Speaks conversationally about what matters" }),
+      /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "  \u2022 Suggests specific actions to take" }),
+      /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "  \u2022 Celebrates when you fix issues" }),
+      /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "  \u2022 Tracks patterns over time" }),
+      /* @__PURE__ */ jsx7(Text6, { children: " " }),
+      /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "When the Trie Agent has something to say, it'll appear here." }),
+      /* @__PURE__ */ jsx7(Text6, { children: " " }),
+      isAIAvailable() ? /* @__PURE__ */ jsxs6(Text6, { children: [
+        /* @__PURE__ */ jsx7(Text6, { color: "green", children: "[+]" }),
+        /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: " AI-enhanced insights enabled" })
+      ] }) : /* @__PURE__ */ jsxs6(Text6, { children: [
+        /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "Want smarter insights? Set " }),
+        /* @__PURE__ */ jsx7(Text6, { bold: true, children: "ANTHROPIC_API_KEY" }),
+        /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: " for AI enhancement" })
+      ] })
+    ] }) : /* @__PURE__ */ jsx7(Box6, { flexDirection: "column", children: visibleInsights.map((insight, idx) => {
+      const isSelected = idx === selectedInsight;
+      const isExpanded = idx === expandedInsight;
+      const ago = formatTimeAgo(insight.timestamp);
+      const { icon, color } = insightIcon(insight.type);
+      const cleanMessage = stripEmojis(insight.message);
+      const msgMaxLen = 70;
+      const msg = cleanMessage.length > msgMaxLen ? cleanMessage.slice(0, msgMaxLen - 3) + "..." : cleanMessage;
+      const status = isExpanded ? "v" : ">";
+      return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsxs6(Text6, { children: [
+          isSelected ? /* @__PURE__ */ jsx7(Text6, { bold: true, color: "magenta", children: "\u25B6 " }) : /* @__PURE__ */ jsx7(Text6, { children: "  " }),
+          /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+            status,
+            " "
+          ] }),
+          isSelected ? /* @__PURE__ */ jsx7(Text6, { inverse: true, children: ` ${icon} ${msg} ` }) : /* @__PURE__ */ jsxs6(Text6, { children: [
+            icon,
+            " ",
+            color(msg)
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+          "      ",
+          ago,
+          " \u2022 ",
+          insight.category,
+          isSelected && !isExpanded ? " \u2022 Press Enter to expand" : ""
+        ] }),
+        isExpanded && insight.details && /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginLeft: 7, children: [
+          insight.details.issueBreakdown && Object.keys(insight.details.issueBreakdown).length > 0 && /* @__PURE__ */ jsxs6(Text6, { children: [
+            insight.details.issueBreakdown["critical"] ? /* @__PURE__ */ jsxs6(Text6, { color: "red", children: [
+              insight.details.issueBreakdown["critical"],
+              " critical"
+            ] }) : null,
+            insight.details.issueBreakdown["serious"] ? /* @__PURE__ */ jsxs6(Text6, { color: "yellow", children: [
+              " \u2022 ",
+              insight.details.issueBreakdown["serious"],
+              " serious"
+            ] }) : null,
+            insight.details.issueBreakdown["moderate"] ? /* @__PURE__ */ jsxs6(Text6, { color: "blue", children: [
+              " \u2022 ",
+              insight.details.issueBreakdown["moderate"],
+              " moderate"
+            ] }) : null
+          ] }),
+          insight.details.affectedFiles && insight.details.affectedFiles.length > 0 && /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsx7(Text6, { color: "cyan", bold: true, children: "Files:" }),
+            insight.details.affectedFiles.slice(0, 8).map((f, fi) => /* @__PURE__ */ jsxs6(Text6, { color: "cyan", children: [
+              "  \u2022 ",
+              f
+            ] }, fi)),
+            insight.details.affectedFiles.length > 8 && /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+              "  ... +",
+              insight.details.affectedFiles.length - 8,
+              " more"
+            ] })
+          ] }),
+          insight.details.examples && insight.details.examples.length > 0 && /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsx7(Text6, { color: "cyan", bold: true, children: "Examples:" }),
+            insight.details.examples.slice(0, 5).map((ex, ei) => /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+              "  \u2022 ",
+              ex.slice(0, 60),
+              ex.length > 60 ? "..." : ""
+            ] }, ei))
+          ] }),
+          insight.details.comparison && /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+            insight.details.trend === "improving" ? "\u2193" : insight.details.trend === "worsening" ? "\u2191" : "\u2192",
+            " ",
+            insight.details.comparison
+          ] })
+        ] }),
+        insight.suggestedAction && (isExpanded || isSelected) && /* @__PURE__ */ jsxs6(Text6, { children: [
+          "     ",
+          /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "\u2192 " }),
+          /* @__PURE__ */ jsx7(Text6, { bold: true, children: insight.suggestedAction })
+        ] }),
+        insight.actionCommand && isExpanded && /* @__PURE__ */ jsxs6(Text6, { children: [
+          "     ",
+          /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "$ " }),
+          /* @__PURE__ */ jsx7(Text6, { color: "green", children: insight.actionCommand }),
+          isSelected && /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "  " }),
+          isSelected && /* @__PURE__ */ jsx7(Text6, { bold: true, children: "[Enter to run]" })
+        ] })
+      ] }, insight.id);
+    }) }),
+    /* @__PURE__ */ jsx7(Text6, { children: " " }),
+    /* @__PURE__ */ jsxs6(Box6, { gap: 2, children: [
+      agentInsights.filter((i) => i.type === "warning").length > 0 && /* @__PURE__ */ jsxs6(Text6, { color: "red", children: [
+        agentInsights.filter((i) => i.type === "warning").length,
+        " warnings"
+      ] }),
+      agentInsights.filter((i) => i.type === "suggestion").length > 0 && /* @__PURE__ */ jsxs6(Text6, { bold: true, children: [
+        agentInsights.filter((i) => i.type === "suggestion").length,
+        " suggestions"
+      ] }),
+      agentInsights.filter((i) => i.type === "celebration").length > 0 && /* @__PURE__ */ jsxs6(Text6, { color: "green", children: [
+        agentInsights.filter((i) => i.type === "celebration").length,
+        " wins"
+      ] }),
+      /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "\u2502" }),
+      isAIAvailable() ? /* @__PURE__ */ jsx7(Text6, { color: "green", children: "AI \u2713" }) : /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "AI off" })
+    ] })
+  ] });
+}
+
+// src/cli/dashboard/views/GoalsView.tsx
+import { useCallback } from "react";
+import { Box as Box7, Text as Text7, useInput as useInput3 } from "ink";
+import { Fragment as Fragment2, jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+function calculateGoalProgress(goal) {
+  if (goal.target <= 0) return 0;
+  const startValue = goal.startValue ?? goal.currentValue;
+  if (startValue > goal.target) {
+    const totalReduction = startValue - goal.target;
+    const actualReduction = startValue - goal.currentValue;
+    return Math.round(actualReduction / totalReduction * 100);
+  }
+  return Math.round(goal.currentValue / goal.target * 100);
+}
+function GoalsView() {
+  const { state, dispatch } = useDashboard();
+  const { goalsPanel } = state;
+  const activeGoals = goalsPanel.goals.filter((g) => g.status === "active");
+  const achievedGoals = goalsPanel.goals.filter((g) => g.status === "achieved");
+  const otherGoals = goalsPanel.goals.filter((g) => g.status !== "active" && g.status !== "achieved");
+  const refreshGoals = useCallback(async () => {
+    try {
+      const workDir = getWorkingDirectory(void 0, true);
+      const agentState = getGuardianState(workDir);
+      await agentState.load();
+      const goals = agentState.getAllGoals();
+      dispatch({
+        type: "SET_GOALS",
+        goals: goals.map((g) => {
+          const base = { id: g.id, description: g.description, type: g.type, target: g.target, currentValue: g.currentValue, status: g.status, autoGenerated: g.autoGenerated, updatedAt: g.updatedAt };
+          return g.category ? { ...base, category: g.category } : base;
+        })
+      });
+    } catch {
+    }
+  }, [dispatch]);
+  const addGoal = useCallback(async (description) => {
+    if (!description.trim()) return;
+    try {
+      const workDir = getWorkingDirectory(void 0, true);
+      const agentState = getGuardianState(workDir);
+      await agentState.load();
+      const goal = {
+        id: `goal-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        description: description.trim(),
+        type: "reduction",
+        metric: "semantic",
+        target: 0,
+        currentValue: 0,
+        startValue: 0,
+        status: "active",
+        autoGenerated: false,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        deadline: new Date(Date.now() + 14 * 864e5).toISOString()
+      };
+      await agentState.addGoal(goal);
+      dispatch({ type: "ADD_ACTIVITY", message: `Goal added: ${description.slice(0, 40)}` });
+      await refreshGoals();
+    } catch {
+    }
+  }, [dispatch, refreshGoals]);
+  const completeGoal = useCallback(async (goalId) => {
+    try {
+      const workDir = getWorkingDirectory(void 0, true);
+      const agentState = getGuardianState(workDir);
+      await agentState.load();
+      const goals = agentState.getAllGoals();
+      const goal = goals.find((g) => g.id === goalId);
+      if (goal) {
+        await agentState.updateGoal(goalId, { status: "achieved", currentValue: goal.target, achievedAt: (/* @__PURE__ */ new Date()).toISOString() });
+        dispatch({ type: "ADD_ACTIVITY", message: `Goal achieved: ${goal.description.slice(0, 30)}` });
+        await refreshGoals();
+      }
+    } catch {
+    }
+  }, [dispatch, refreshGoals]);
+  const deleteGoal = useCallback(async (goalId) => {
+    try {
+      const workDir = getWorkingDirectory(void 0, true);
+      const agentState = getGuardianState(workDir);
+      await agentState.load();
+      await agentState.updateGoal(goalId, { status: "rejected" });
+      dispatch({ type: "ADD_ACTIVITY", message: "Goal removed" });
+      await refreshGoals();
+    } catch {
+    }
+  }, [dispatch, refreshGoals]);
+  const reactivateGoal = useCallback(async (goalId) => {
+    try {
+      const workDir = getWorkingDirectory(void 0, true);
+      const agentState = getGuardianState(workDir);
+      await agentState.load();
+      await agentState.updateGoal(goalId, { status: "active", achievedAt: void 0 });
+      dispatch({ type: "ADD_ACTIVITY", message: "Goal reactivated" });
+      await refreshGoals();
+    } catch {
+    }
+  }, [dispatch, refreshGoals]);
+  useInput3((_input, key) => {
+    if (goalsPanel.inputMode === "add") {
+      if (key.escape) {
+        dispatch({ type: "SET_GOALS_INPUT_MODE", mode: "browse" });
+      } else if (key.return) {
+        void addGoal(goalsPanel.inputBuffer);
+        dispatch({ type: "SET_GOALS_INPUT_MODE", mode: "browse" });
+      } else if (key.backspace || key.delete) {
+        dispatch({ type: "SET_GOALS_INPUT_BUFFER", buffer: goalsPanel.inputBuffer.slice(0, -1) });
+      } else if (_input && _input.length === 1 && !key.ctrl && !key.meta) {
+        dispatch({ type: "SET_GOALS_INPUT_BUFFER", buffer: goalsPanel.inputBuffer + _input });
+      }
+      return;
+    }
+    if (_input === "a") dispatch({ type: "SET_GOALS_INPUT_MODE", mode: "add" });
+    else if (key.upArrow || _input === "k") dispatch({ type: "SELECT_GOAL", index: Math.max(0, goalsPanel.selectedIndex - 1) });
+    else if (key.downArrow || _input === "j") dispatch({ type: "SELECT_GOAL", index: Math.min(activeGoals.length - 1, goalsPanel.selectedIndex + 1) });
+    else if (key.return) {
+      const selected = activeGoals[goalsPanel.selectedIndex];
+      if (selected) void completeGoal(selected.id);
+    } else if (_input === "d") {
+      const selected = activeGoals[goalsPanel.selectedIndex];
+      if (selected) void deleteGoal(selected.id);
+    } else if (_input === "x") {
+      const completed = goalsPanel.goals.filter((g) => g.status === "achieved" || g.status === "failed");
+      if (completed[0]) void deleteGoal(completed[0].id);
+    } else if (_input === "u") {
+      const recent = goalsPanel.goals.filter((g) => g.status === "achieved").sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+      if (recent[0]) void reactivateGoal(recent[0].id);
+    }
+  });
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs7(Text7, { children: [
+      /* @__PURE__ */ jsx8(Text7, { color: "cyan", bold: true, children: "GOALS" }),
+      "  ",
+      /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "Track progress, achieve targets" })
+    ] }),
+    /* @__PURE__ */ jsx8(Text7, { children: " " }),
+    goalsPanel.inputMode === "add" ? /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        /* @__PURE__ */ jsx8(Text7, { bold: true, children: "New goal:" }),
+        " ",
+        goalsPanel.inputBuffer,
+        /* @__PURE__ */ jsx8(Text7, { bold: true, color: "cyan", children: "\u258C" })
+      ] }),
+      /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: 'Examples: "Reduce auth bugs by 50%", "Eliminate critical issues"' }),
+      /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "Press Enter to add, Escape to cancel" })
+    ] }) : /* @__PURE__ */ jsx8(Fragment2, { children: goalsPanel.goals.length === 0 ? /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "No goals yet." }),
+      /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "Press [a] to add your first goal, or wait for auto-generated goals." })
+    ] }) : /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+      activeGoals.length > 0 && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx8(Text7, { bold: true, children: "Active:" }),
+        activeGoals.map((goal, idx) => {
+          const isSelected = goalsPanel.selectedIndex === idx;
+          const progress = calculateGoalProgress(goal);
+          const bar = progressBar(progress, 100, 10);
+          const source = goal.autoGenerated ? /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "[auto]" }) : /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "[manual]" });
+          return /* @__PURE__ */ jsxs7(Text7, { children: [
+            isSelected ? /* @__PURE__ */ jsx8(Text7, { bold: true, color: "magenta", children: "\u25B6 " }) : /* @__PURE__ */ jsx8(Text7, { children: "  " }),
+            bar,
+            " ",
+            goal.description.slice(0, 50),
+            " ",
+            source
+          ] }, goal.id);
+        }),
+        /* @__PURE__ */ jsx8(Text7, { children: " " })
+      ] }),
+      achievedGoals.length > 0 && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs7(Text7, { children: [
+          /* @__PURE__ */ jsx8(Text7, { color: "green", children: "Achieved:" }),
+          /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: " [x to remove]" })
+        ] }),
+        achievedGoals.slice(0, 5).map((g) => /* @__PURE__ */ jsxs7(Text7, { color: "green", children: [
+          "  [+] ",
+          g.description.slice(0, 50)
+        ] }, g.id)),
+        achievedGoals.length > 5 && /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+          "  +",
+          achievedGoals.length - 5,
+          " more"
+        ] }),
+        /* @__PURE__ */ jsx8(Text7, { children: " " })
+      ] }),
+      otherGoals.length > 0 && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "Other:" }),
+        otherGoals.slice(0, 2).map((g) => {
+          const icon = g.status === "failed" ? "[X]" : g.status === "paused" ? "[P]" : "\u2022";
+          return /* @__PURE__ */ jsxs7(Text7, { children: [
+            "  ",
+            icon,
+            " ",
+            g.description.slice(0, 50),
+            /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+              " (",
+              g.status,
+              ")"
+            ] })
+          ] }, g.id);
+        })
+      ] })
+    ] }) })
+  ] });
+}
+
+// src/cli/dashboard/views/HypothesesView.tsx
+import { useCallback as useCallback2 } from "react";
+import { Box as Box8, Text as Text8, useInput as useInput4 } from "ink";
+import { Fragment as Fragment3, jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+function HypothesesView() {
+  const { state, dispatch } = useDashboard();
+  const { hypothesesPanel } = state;
+  const testing = hypothesesPanel.hypotheses.filter((h) => h.status === "testing");
+  const validated = hypothesesPanel.hypotheses.filter((h) => h.status === "validated");
+  const invalidated = hypothesesPanel.hypotheses.filter((h) => h.status === "invalidated");
+  const refreshHypotheses = useCallback2(async () => {
+    try {
+      const workDir = getWorkingDirectory(void 0, true);
+      const agentState = getGuardianState(workDir);
+      await agentState.load();
+      const hypotheses = agentState.getAllHypotheses();
+      dispatch({
+        type: "SET_HYPOTHESES",
+        hypotheses: hypotheses.map((h) => {
+          const base = { id: h.id, statement: h.statement, confidence: h.confidence, status: h.status, evidenceCount: h.evidence.length, updatedAt: h.updatedAt };
+          return h.category ? { ...base, category: h.category } : base;
+        })
+      });
+    } catch {
+    }
+  }, [dispatch]);
+  const addHypothesis = useCallback2(async (statement) => {
+    if (!statement.trim()) return;
+    try {
+      const workDir = getWorkingDirectory(void 0, true);
+      const agentState = getGuardianState(workDir);
+      await agentState.load();
+      const hypothesis = {
+        id: `hypo-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        statement: statement.trim(),
+        confidence: 0.5,
+        status: "testing",
+        evidence: [],
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        testCriteria: "Collect evidence from scans"
+      };
+      await agentState.addHypothesis(hypothesis);
+      dispatch({ type: "ADD_ACTIVITY", message: `Hypothesis added: ${statement.slice(0, 40)}` });
+      await refreshHypotheses();
+    } catch {
+    }
+  }, [dispatch, refreshHypotheses]);
+  const updateHypothesis = useCallback2(async (hypoId, action) => {
+    try {
+      const workDir = getWorkingDirectory(void 0, true);
+      const agentState = getGuardianState(workDir);
+      await agentState.load();
+      if (action === "validate") await agentState.updateHypothesis(hypoId, { status: "validated", confidence: 0.9 });
+      else if (action === "invalidate") await agentState.updateHypothesis(hypoId, { status: "invalidated", confidence: 0.1 });
+      else await agentState.updateHypothesis(hypoId, { status: "retired" });
+      dispatch({ type: "ADD_ACTIVITY", message: `Hypothesis ${action === "validate" ? "validated" : action === "invalidate" ? "invalidated" : "removed"}` });
+      await refreshHypotheses();
+    } catch {
+    }
+  }, [dispatch, refreshHypotheses]);
+  const reactivateHypothesis = useCallback2(async (hypoId) => {
+    try {
+      const workDir = getWorkingDirectory(void 0, true);
+      const agentState = getGuardianState(workDir);
+      await agentState.load();
+      await agentState.updateHypothesis(hypoId, { status: "testing", confidence: 0.5, validatedAt: void 0 });
+      dispatch({ type: "ADD_ACTIVITY", message: "Hypothesis reactivated" });
+      await refreshHypotheses();
+    } catch {
+    }
+  }, [dispatch, refreshHypotheses]);
+  useInput4((_input, key) => {
+    if (hypothesesPanel.inputMode === "add") {
+      if (key.escape) {
+        dispatch({ type: "SET_HYPOTHESES_INPUT_MODE", mode: "browse" });
+      } else if (key.return) {
+        void addHypothesis(hypothesesPanel.inputBuffer);
+        dispatch({ type: "SET_HYPOTHESES_INPUT_MODE", mode: "browse" });
+      } else if (key.backspace || key.delete) {
+        dispatch({ type: "SET_HYPOTHESES_INPUT_BUFFER", buffer: hypothesesPanel.inputBuffer.slice(0, -1) });
+      } else if (_input && _input.length === 1 && !key.ctrl && !key.meta) {
+        dispatch({ type: "SET_HYPOTHESES_INPUT_BUFFER", buffer: hypothesesPanel.inputBuffer + _input });
+      }
+      return;
+    }
+    if (_input === "a") dispatch({ type: "SET_HYPOTHESES_INPUT_MODE", mode: "add" });
+    else if (key.upArrow || _input === "k") dispatch({ type: "SELECT_HYPOTHESIS", index: Math.max(0, hypothesesPanel.selectedIndex - 1) });
+    else if (key.downArrow || _input === "j") dispatch({ type: "SELECT_HYPOTHESIS", index: Math.min(testing.length - 1, hypothesesPanel.selectedIndex + 1) });
+    else if (_input === "v") {
+      const selected = testing[hypothesesPanel.selectedIndex];
+      if (selected) void updateHypothesis(selected.id, "validate");
+    } else if (_input === "x") {
+      const selected = testing[hypothesesPanel.selectedIndex];
+      if (selected) void updateHypothesis(selected.id, "invalidate");
+    } else if (_input === "d") {
+      const selected = testing[hypothesesPanel.selectedIndex];
+      if (selected) void updateHypothesis(selected.id, "delete");
+    } else if (_input === "r") {
+      const completed = hypothesesPanel.hypotheses.filter((h) => h.status === "validated" || h.status === "invalidated");
+      if (completed[0]) void updateHypothesis(completed[0].id, "delete");
+    } else if (_input === "u") {
+      const recent = hypothesesPanel.hypotheses.filter((h) => h.status === "validated" || h.status === "invalidated").sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+      if (recent[0]) void reactivateHypothesis(recent[0].id);
+    }
+  });
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs8(Text8, { children: [
+      /* @__PURE__ */ jsx9(Text8, { color: "cyan", bold: true, children: "HYPOTHESES" }),
+      "  ",
+      /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: "Test theories about your codebase" })
+    ] }),
+    /* @__PURE__ */ jsx9(Text8, { children: " " }),
+    hypothesesPanel.inputMode === "add" ? /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs8(Text8, { children: [
+        /* @__PURE__ */ jsx9(Text8, { bold: true, children: "New hypothesis:" }),
+        " ",
+        hypothesesPanel.inputBuffer,
+        /* @__PURE__ */ jsx9(Text8, { bold: true, color: "cyan", children: "\u258C" })
+      ] }),
+      /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: 'Examples: "Mondays have more bugs", "Code reviews reduce issues"' }),
+      /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: "Press Enter to add, Escape to cancel" })
+    ] }) : /* @__PURE__ */ jsx9(Fragment3, { children: hypothesesPanel.hypotheses.length === 0 ? /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: "No hypotheses yet." }),
+      /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: "Press [a] to add your first hypothesis." }),
+      /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: "The agent will collect evidence and update confidence over time." })
+    ] }) : /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      testing.length > 0 && /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx9(Text8, { bold: true, children: "Testing:" }),
+        testing.map((hypo, idx) => {
+          const isSelected = hypothesesPanel.selectedIndex === idx;
+          const conf = Math.round(hypo.confidence * 100);
+          return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsxs8(Text8, { children: [
+              isSelected ? /* @__PURE__ */ jsx9(Text8, { bold: true, color: "magenta", children: "\u25B6 " }) : /* @__PURE__ */ jsx9(Text8, { children: "  " }),
+              '[?] "',
+              hypo.statement.slice(0, 50),
+              '" ',
+              /* @__PURE__ */ jsxs8(Text8, { color: conf >= 70 ? "green" : conf >= 40 ? "yellow" : "yellow", children: [
+                "(",
+                conf,
+                "%)"
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+              "     Evidence: ",
+              hypo.evidenceCount,
+              " points"
+            ] })
+          ] }, hypo.id);
+        }),
+        /* @__PURE__ */ jsx9(Text8, { children: " " })
+      ] }),
+      validated.length > 0 && /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs8(Text8, { children: [
+          /* @__PURE__ */ jsx9(Text8, { color: "green", children: "Validated:" }),
+          /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: " [r to remove]" })
+        ] }),
+        validated.slice(0, 3).map((h) => /* @__PURE__ */ jsxs8(Text8, { color: "green", children: [
+          '  [+] "',
+          h.statement.slice(0, 50),
+          '"'
+        ] }, h.id)),
+        validated.length > 3 && /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+          "  +",
+          validated.length - 3,
+          " more"
+        ] }),
+        /* @__PURE__ */ jsx9(Text8, { children: " " })
+      ] }),
+      invalidated.length > 0 && /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs8(Text8, { children: [
+          /* @__PURE__ */ jsx9(Text8, { color: "yellow", children: "Invalidated:" }),
+          /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: " [r to remove]" })
+        ] }),
+        invalidated.slice(0, 2).map((h) => /* @__PURE__ */ jsx9(Text8, { children: /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
+          '  [X] "',
+          h.statement.slice(0, 50),
+          '"'
+        ] }) }, h.id)),
+        invalidated.length > 2 && /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+          "  +",
+          invalidated.length - 2,
+          " more"
+        ] })
+      ] })
+    ] }) })
+  ] });
+}
+
+// src/cli/dashboard/views/MemoryTreeView.tsx
+import { useEffect, useCallback as useCallback3 } from "react";
+import { Box as Box9, Text as Text9, useInput as useInput5 } from "ink";
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+function severityBar(count, max, width = 16) {
+  const filled = max > 0 ? Math.round(count / max * width) : 0;
+  return "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+}
+function MemoryTreeView() {
+  const { state, dispatch } = useDashboard();
+  const { memoryTree } = state;
+  const { issues, stats, globalPatterns, expandedNodes, selectedNode, loaded } = memoryTree;
+  const loadData = useCallback3(async () => {
+    try {
+      const workDir = getWorkingDirectory(void 0, true);
+      const [issueList, memStats, patterns] = await Promise.all([
+        getRecentIssues({ workDir, limit: 200, daysBack: 30 }),
+        getMemoryStats(workDir),
+        findCrossProjectPatterns(2)
+      ]);
+      dispatch({ type: "SET_MEMORY_TREE", issues: issueList, stats: memStats, patterns });
+    } catch {
+      dispatch({ type: "ADD_ACTIVITY", message: "Memory load error" });
+    }
+  }, [dispatch]);
+  useEffect(() => {
+    if (!loaded) {
+      void loadData();
+    }
+  }, [loaded, loadData]);
+  useInput5((_input, key) => {
+    if (key.upArrow || _input === "k") dispatch({ type: "NAVIGATE_UP" });
+    else if (key.downArrow || _input === "j") dispatch({ type: "NAVIGATE_DOWN" });
+    else if (key.return) dispatch({ type: "TOGGLE_MEMORY_NODE", nodeId: selectedNode });
+  });
+  const bySeverity = { critical: [], serious: [], moderate: [], low: [] };
+  for (const issue of issues) {
+    const arr = bySeverity[issue.severity];
+    if (arr) arr.push(issue);
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    if (!byFile.has(issue.file)) byFile.set(issue.file, []);
+    byFile.get(issue.file).push(issue);
+  }
+  const sortedFiles = Array.from(byFile.entries()).sort((a, b) => b[1].length - a[1].length).slice(0, 10);
+  const byAgent = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    if (!byAgent.has(issue.agent)) byAgent.set(issue.agent, []);
+    byAgent.get(issue.agent).push(issue);
+  }
+  const sortedAgents = Array.from(byAgent.entries()).sort((a, b) => b[1].length - a[1].length);
+  const maxCount = Math.max(bySeverity["critical"]?.length || 0, bySeverity["serious"]?.length || 0, bySeverity["moderate"]?.length || 0, bySeverity["low"]?.length || 0, 1);
+  const totalIssues = stats?.totalIssues || issues.length;
+  const sel = (nodeId) => selectedNode === nodeId;
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs9(Text9, { children: [
+      /* @__PURE__ */ jsx10(Text9, { color: "cyan", bold: true, children: "MEMORY TREE" }),
+      "  ",
+      /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+        "[",
+        totalIssues,
+        " issues]"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx10(Text9, { children: " " }),
+    !loaded ? /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: "Loading memory data..." }) : issues.length === 0 && globalPatterns.length === 0 ? /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: "No issues in memory yet." }),
+      /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: "Run a scan to populate the memory tree." })
+    ] }) : /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs9(Text9, { children: [
+        sel("severity") ? /* @__PURE__ */ jsx10(Text9, { bold: true, color: "magenta", children: "\u2192 " }) : /* @__PURE__ */ jsx10(Text9, { children: "  " }),
+        expandedNodes.has("severity") ? "\u25BC" : "\u25B6",
+        " ",
+        sel("severity") ? /* @__PURE__ */ jsx10(Text9, { bold: true, color: "magenta", children: "By Severity" }) : /* @__PURE__ */ jsx10(Text9, { color: "cyan", bold: true, children: "By Severity" })
+      ] }),
+      expandedNodes.has("severity") && ["critical", "serious", "moderate", "low"].map((sev) => {
+        const count = bySeverity[sev]?.length || 0;
+        const nodeId = `severity-${sev}`;
+        const barStr = severityBar(count, maxCount);
+        const isLow = sev === "low";
+        const sevColorMap = { critical: "red", serious: "yellow", moderate: "blue" };
+        const sevColor = isLow ? void 0 : sevColorMap[sev];
+        const SevText = ({ children }) => isLow ? /* @__PURE__ */ jsx10(Text9, { dimColor: true, children }) : sevColor ? /* @__PURE__ */ jsx10(Text9, { color: sevColor, children }) : /* @__PURE__ */ jsx10(Text9, { children });
+        return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs9(Text9, { children: [
+            sel(nodeId) ? /* @__PURE__ */ jsx10(Text9, { bold: true, color: "magenta", children: "\u2192 " }) : /* @__PURE__ */ jsx10(Text9, { children: "  " }),
+            "   \u2502  ",
+            sel(nodeId) ? /* @__PURE__ */ jsx10(Text9, { bold: true, color: "magenta", children: sev }) : /* @__PURE__ */ jsx10(SevText, { children: sev }),
+            ` (${count})  `,
+            /* @__PURE__ */ jsx10(SevText, { children: barStr })
+          ] }),
+          expandedNodes.has(nodeId) && (bySeverity[sev] || []).slice(0, 5).map((issue, i) => {
+            const issueId = `severity-${sev}-${issue.id}`;
+            const filename = issue.file.split("/").pop() || issue.file;
+            const line = issue.line ? `:${issue.line}` : "";
+            const desc = issue.issue.slice(0, 35) + (issue.issue.length > 35 ? "..." : "");
+            return /* @__PURE__ */ jsxs9(Text9, { children: [
+              sel(issueId) ? /* @__PURE__ */ jsx10(Text9, { bold: true, color: "magenta", children: "\u2192 " }) : /* @__PURE__ */ jsx10(Text9, { children: "  " }),
+              "   \u2502     ",
+              i === Math.min(5, bySeverity[sev]?.length || 0) - 1 ? "\u2514\u2500 " : "\u251C\u2500 ",
+              /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+                filename,
+                line
+              ] }),
+              " - ",
+              /* @__PURE__ */ jsx10(SevText, { children: desc })
+            ] }, i);
+          })
+        ] }, sev);
+      }),
+      /* @__PURE__ */ jsxs9(Text9, { children: [
+        sel("files") ? /* @__PURE__ */ jsx10(Text9, { bold: true, color: "magenta", children: "\u2192 " }) : /* @__PURE__ */ jsx10(Text9, { children: "  " }),
+        expandedNodes.has("files") ? "\u25BC" : "\u25B6",
+        " ",
+        sel("files") ? /* @__PURE__ */ jsx10(Text9, { bold: true, color: "magenta", children: "By File (Hot Spots)" }) : /* @__PURE__ */ jsx10(Text9, { color: "cyan", bold: true, children: "By File (Hot Spots)" })
+      ] }),
+      expandedNodes.has("files") && sortedFiles.map(([file, fileIssues], idx) => {
+        const fileId = `file-${file}`;
+        const filename = file.split("/").pop() || file;
+        const count = fileIssues.length;
+        const isLast = idx === sortedFiles.length - 1;
+        return /* @__PURE__ */ jsxs9(Text9, { children: [
+          sel(fileId) ? /* @__PURE__ */ jsx10(Text9, { bold: true, color: "magenta", children: "\u2192 " }) : /* @__PURE__ */ jsx10(Text9, { children: "  " }),
+          "   ",
+          isLast ? "\u2514\u2500 " : "\u251C\u2500 ",
+          sel(fileId) ? /* @__PURE__ */ jsx10(Text9, { bold: true, color: "magenta", children: filename }) : /* @__PURE__ */ jsx10(Text9, { children: filename }),
+          ` (${count})`
+        ] }, file);
+      }),
+      /* @__PURE__ */ jsxs9(Text9, { children: [
+        sel("agents") ? /* @__PURE__ */ jsx10(Text9, { bold: true, color: "magenta", children: "\u2192 " }) : /* @__PURE__ */ jsx10(Text9, { children: "  " }),
+        expandedNodes.has("agents") ? "\u25BC" : "\u25B6",
+        " ",
+        sel("agents") ? /* @__PURE__ */ jsx10(Text9, { bold: true, color: "magenta", children: "By Agent" }) : /* @__PURE__ */ jsx10(Text9, { color: "cyan", bold: true, children: "By Agent" })
+      ] }),
+      expandedNodes.has("agents") && sortedAgents.map(([agent, agentIssues], idx) => {
+        const agentId = `agent-${agent}`;
+        const isLast = idx === sortedAgents.length - 1;
+        return /* @__PURE__ */ jsxs9(Text9, { children: [
+          sel(agentId) ? /* @__PURE__ */ jsx10(Text9, { bold: true, color: "magenta", children: "\u2192 " }) : /* @__PURE__ */ jsx10(Text9, { children: "  " }),
+          "   ",
+          isLast ? "\u2514\u2500 " : "\u251C\u2500 ",
+          sel(agentId) ? /* @__PURE__ */ jsx10(Text9, { bold: true, color: "magenta", children: agent }) : /* @__PURE__ */ jsx10(Text9, { children: agent }),
+          ` (${agentIssues.length})`
+        ] }, agent);
+      }),
+      /* @__PURE__ */ jsxs9(Text9, { children: [
+        sel("patterns") ? /* @__PURE__ */ jsx10(Text9, { bold: true, color: "magenta", children: "\u2192 " }) : /* @__PURE__ */ jsx10(Text9, { children: "  " }),
+        expandedNodes.has("patterns") ? "\u25BC" : "\u25B6",
+        " ",
+        sel("patterns") ? /* @__PURE__ */ jsxs9(Text9, { bold: true, color: "magenta", children: [
+          "Cross-Project Patterns (",
+          globalPatterns.length,
+          " recurring)"
+        ] }) : /* @__PURE__ */ jsxs9(Text9, { color: "cyan", bold: true, children: [
+          "Cross-Project Patterns (",
+          globalPatterns.length,
+          " recurring)"
+        ] })
+      ] }),
+      expandedNodes.has("patterns") && globalPatterns.slice(0, 5).map((pattern, idx) => {
+        const patternId = `pattern-${pattern.id}`;
+        const isLast = idx === Math.min(4, globalPatterns.length - 1);
+        const desc = pattern.pattern.slice(0, 40) + (pattern.pattern.length > 40 ? "..." : "");
+        return /* @__PURE__ */ jsxs9(Text9, { children: [
+          sel(patternId) ? /* @__PURE__ */ jsx10(Text9, { bold: true, color: "magenta", children: "\u2192 " }) : /* @__PURE__ */ jsx10(Text9, { children: "  " }),
+          "   ",
+          isLast ? "\u2514\u2500 " : "\u251C\u2500 ",
+          /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+            '"',
+            desc,
+            '" - seen in ',
+            pattern.projects.length,
+            " projects"
+          ] })
+        ] }, pattern.id);
+      }),
+      /* @__PURE__ */ jsx10(Text9, { children: " " }),
+      /* @__PURE__ */ jsxs9(Box9, { gap: 2, children: [
+        /* @__PURE__ */ jsxs9(Text9, { children: [
+          /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: "Trend: " }),
+          stats?.improvementTrend === "improving" ? /* @__PURE__ */ jsx10(Text9, { color: "green", children: "\u2191 Improving" }) : stats?.improvementTrend === "declining" ? /* @__PURE__ */ jsx10(Text9, { color: "red", children: "\u2193 Declining" }) : /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: "\u2192 Stable" })
+        ] }),
+        /* @__PURE__ */ jsxs9(Text9, { children: [
+          /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: "Resolved:" }),
+          " ",
+          /* @__PURE__ */ jsx10(Text9, { color: "green", children: stats?.resolvedCount || 0 })
+        ] }),
+        /* @__PURE__ */ jsxs9(Text9, { children: [
+          /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: "Historical:" }),
+          " ",
+          /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: stats?.historicalIssues || 0 })
+        ] })
+      ] })
+    ] })
+  ] });
+}
+
+// src/cli/dashboard/views/RawLogView.tsx
+import { Box as Box10, Text as Text10, useInput as useInput6 } from "ink";
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+function RawLogView() {
+  const { state, dispatch } = useDashboard();
+  const { rawLog, rawLogPage } = state;
+  const pageSize = Math.max(10, (process.stdout.rows || 40) - 15);
+  const totalPages = Math.max(1, Math.ceil(rawLog.length / pageSize));
+  useInput6((input, _key) => {
+    if (input === "n") {
+      dispatch({ type: "SET_RAW_LOG_PAGE", page: Math.min(totalPages - 1, rawLogPage + 1) });
+    } else if (input === "p") {
+      dispatch({ type: "SET_RAW_LOG_PAGE", page: Math.max(0, rawLogPage - 1) });
+    }
+  });
+  const startIdx = rawLogPage * pageSize;
+  const logs = rawLog.slice(startIdx, startIdx + pageSize);
+  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs10(Text10, { children: [
+      /* @__PURE__ */ jsx11(Text10, { color: "cyan", bold: true, children: "RAW LOG" }),
+      "  ",
+      /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+        "Page ",
+        rawLogPage + 1,
+        "/",
+        totalPages
+      ] }),
+      "  ",
+      /* @__PURE__ */ jsx11(Text10, { bold: true, children: rawLog.length }),
+      /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: " entries" })
+    ] }),
+    /* @__PURE__ */ jsx11(Text10, { children: " " }),
+    rawLog.length === 0 ? /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: "No log entries yet." }) : /* @__PURE__ */ jsx11(Box10, { flexDirection: "column", children: logs.map((entry, i) => {
+      const levelTag = `[${entry.level.toUpperCase().padEnd(5)}]`;
+      const levelEl = entry.level === "error" ? /* @__PURE__ */ jsx11(Text10, { color: "red", children: levelTag }) : entry.level === "warn" ? /* @__PURE__ */ jsx11(Text10, { color: "yellow", children: levelTag }) : entry.level === "info" ? /* @__PURE__ */ jsx11(Text10, { color: "green", children: levelTag }) : /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: levelTag });
+      return /* @__PURE__ */ jsxs10(Text10, { children: [
+        /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: entry.time }),
+        " ",
+        levelEl,
+        " ",
+        entry.message.slice(0, 80)
+      ] }, i);
+    }) })
+  ] });
+}
+
+// src/cli/dashboard/App.tsx
+import { jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
+var MAIN_VIEWS = ["overview", "memory", "goals", "hypotheses", "agent"];
+function DashboardApp({ onReady }) {
+  const { state, dispatch } = useDashboard();
+  const { exit } = useApp();
+  const [showConfig, setShowConfig] = useState2(false);
+  const dispatchRef = useRef(dispatch);
+  dispatchRef.current = dispatch;
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const configPath = join(getTrieDirectory(getWorkingDirectory(void 0, true)), "agent.json");
+  const loadConfig = useCallback4(async () => {
+    if (!existsSync(configPath)) return;
+    try {
+      const raw = await readFile(configPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      dispatchRef.current({ type: "SET_AGENT_CONFIG", config: parsed });
+    } catch {
+    }
+  }, [configPath]);
+  const persistConfig = useCallback4(async () => {
+    try {
+      await mkdir(getTrieDirectory(getWorkingDirectory(void 0, true)), { recursive: true });
+      await writeFile(configPath, JSON.stringify(stateRef.current.agentConfig, null, 2), "utf-8");
+    } catch {
+    }
+  }, [configPath]);
+  const processInsights = useCallback4(async (issues) => {
+    try {
+      const workDir = getWorkingDirectory(void 0, true);
+      const trieAgent = getGuardian(workDir);
+      if (!stateRef.current.agentInitialized) {
+        await trieAgent.initialize();
+        dispatchRef.current({ type: "SET_AGENT_INITIALIZED", initialized: true });
+        const persisted = trieAgent.getActiveInsights();
+        if (persisted.length > 0) {
+          dispatchRef.current({ type: "ADD_INSIGHTS", insights: persisted });
+        }
+      }
+      const filesChanged = stateRef.current.watch.recentChanges.map((c) => c.file);
+      const newInsights = await trieAgent.processIssues(issues, { filesChanged, isWatchMode: stateRef.current.watch.watching });
+      if (newInsights.length > 0) {
+        dispatchRef.current({ type: "ADD_INSIGHTS", insights: newInsights });
+      }
+      try {
+        const agencyStatus = await trieAgent.getAgencyStatus();
+        dispatchRef.current({ type: "SET_AGENCY_STATUS", status: agencyStatus });
+      } catch {
+      }
+    } catch (error) {
+      dispatchRef.current({ type: "ADD_ACTIVITY", message: `Trie Agent error: ${error instanceof Error ? error.message : "unknown"}` });
+    }
+  }, []);
+  const refreshGoals = useCallback4(async () => {
+    try {
+      const workDir = getWorkingDirectory(void 0, true);
+      const agentState = getGuardianState(workDir);
+      await agentState.load();
+      const goals = agentState.getAllGoals();
+      dispatchRef.current({
+        type: "SET_GOALS",
+        goals: goals.map((g) => {
+          const base = { id: g.id, description: g.description, type: g.type, target: g.target, currentValue: g.currentValue, status: g.status, autoGenerated: g.autoGenerated, updatedAt: g.updatedAt };
+          return g.category ? { ...base, category: g.category } : base;
+        })
+      });
+    } catch {
+    }
+  }, []);
+  const refreshHypotheses = useCallback4(async () => {
+    try {
+      const workDir = getWorkingDirectory(void 0, true);
+      const agentState = getGuardianState(workDir);
+      await agentState.load();
+      const hypotheses = agentState.getAllHypotheses();
+      dispatchRef.current({
+        type: "SET_HYPOTHESES",
+        hypotheses: hypotheses.map((h) => {
+          const base = { id: h.id, statement: h.statement, confidence: h.confidence, status: h.status, evidenceCount: h.evidence.length, updatedAt: h.updatedAt };
+          return h.category ? { ...base, category: h.category } : base;
+        })
+      });
+    } catch {
+    }
+  }, []);
+  useEffect2(() => {
+    void loadConfig();
+    void refreshGoals();
+    void refreshHypotheses();
+    const outputManager = getOutputManager();
+    outputManager.setMode("tui");
+    outputManager.registerTUICallbacks({
+      onActivity: (message) => {
+        dispatchRef.current({ type: "ADD_ACTIVITY", message });
+      },
+      onLog: (level, message) => {
+        const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+        dispatchRef.current({ type: "STREAM_UPDATE", update: { type: "raw_log", data: { time, level, message }, timestamp: Date.now() } });
+      },
+      onNudge: (nudge) => {
+        const action = { type: "SHOW_NOTIFICATION", message: nudge.message, severity: nudge.severity };
+        if (nudge.file !== void 0) action.file = nudge.file;
+        if (nudge.autoHideMs !== void 0) action.autoHideMs = nudge.autoHideMs;
+        dispatchRef.current(action);
+      }
+    });
+    const handleUpdate = (update) => {
+      dispatchRef.current({ type: "STREAM_UPDATE", update });
+      if (update.type === "scan_complete" && update.data.issues) {
+        void processInsights(update.data.issues);
+      }
+    };
+    const getConfig = () => {
+      const c = stateRef.current.agentConfig;
+      return {
+        agentSmith: { ...c.agentSmith, enabledCategories: { ...c.agentSmith.enabledCategories } },
+        performance: { ...c.performance },
+        riskThresholds: { ...c.riskThresholds }
+      };
+    };
+    onReady(handleUpdate, getConfig);
+    return () => {
+      outputManager.clearTUICallbacks();
+      outputManager.setMode("console");
+    };
+  }, [loadConfig, onReady, processInsights, refreshGoals, refreshHypotheses]);
+  useEffect2(() => {
+    const interval = setInterval(() => {
+      dispatchRef.current({ type: "AUTO_DISMISS_NOTIFICATIONS" });
+    }, 5e3);
+    return () => clearInterval(interval);
+  }, []);
+  useInput7((input, key) => {
+    if (showConfig) return;
+    if (state.view === "goals" && state.goalsPanel.inputMode === "add") return;
+    if (state.view === "hypotheses" && state.hypothesesPanel.inputMode === "add") return;
+    if (state.view === "agent" || state.view === "memory") return;
+    if (input === "q" || key.escape) {
+      exit();
+      process.exit(0);
+    }
+    if (key.tab) {
+      const currentIndex = MAIN_VIEWS.indexOf(state.view);
+      const nextIndex = currentIndex >= 0 ? (currentIndex + 1) % MAIN_VIEWS.length : 0;
+      dispatch({ type: "SET_VIEW", view: MAIN_VIEWS[nextIndex] || "overview" });
+    }
+    if (input === "b") dispatch({ type: "GO_BACK" });
+    if (input === "c") setShowConfig(true);
+    if (input === "n") dispatch({ type: "NEXT_PAGE" });
+    if (input === "p") dispatch({ type: "PREV_PAGE" });
+    if (input === "l") dispatch({ type: "SET_VIEW", view: "rawlog" });
+    if (input === "g") dispatch({ type: "SET_VIEW", view: "agent" });
+    if (input === "o") {
+      dispatch({ type: "SET_VIEW", view: "goals" });
+      void refreshGoals();
+    }
+    if (input === "y") {
+      dispatch({ type: "SET_VIEW", view: "hypotheses" });
+      void refreshHypotheses();
+    }
+    if (input === "t") dispatch({ type: "SET_VIEW", view: "memory" });
+  });
+  let viewComponent;
+  switch (state.view) {
+    case "overview":
+      viewComponent = /* @__PURE__ */ jsx12(OverviewView, {});
+      break;
+    case "agent":
+      viewComponent = /* @__PURE__ */ jsx12(AgentView, {});
+      break;
+    case "goals":
+      viewComponent = /* @__PURE__ */ jsx12(GoalsView, {});
+      break;
+    case "hypotheses":
+      viewComponent = /* @__PURE__ */ jsx12(HypothesesView, {});
+      break;
+    case "memory":
+      viewComponent = /* @__PURE__ */ jsx12(MemoryTreeView, {});
+      break;
+    case "rawlog":
+      viewComponent = /* @__PURE__ */ jsx12(RawLogView, {});
+      break;
+    default:
+      viewComponent = /* @__PURE__ */ jsx12(OverviewView, {});
+  }
+  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", height: process.stdout.rows || 40, children: [
+    /* @__PURE__ */ jsx12(Header, {}),
+    /* @__PURE__ */ jsx12(Notification, {}),
+    /* @__PURE__ */ jsx12(Box11, { flexGrow: 1, flexDirection: "column", overflow: "hidden", children: showConfig ? /* @__PURE__ */ jsx12(ConfigDialog, { onClose: () => {
+      setShowConfig(false);
+      void persistConfig();
+    } }) : viewComponent }),
+    /* @__PURE__ */ jsx12(Footer, {})
+  ] });
+}
+function App({ onReady }) {
+  return /* @__PURE__ */ jsx12(DashboardProvider, { children: /* @__PURE__ */ jsx12(DashboardApp, { onReady }) });
+}
+
+// src/cli/dashboard/index.ts
+var InteractiveDashboard = class {
+  app = null;
+  updateHandler = null;
+  getConfigFn = null;
+  async start() {
+    this.app = render(
+      React7.createElement(App, {
+        onReady: (handler, getConfig) => {
+          this.updateHandler = handler;
+          this.getConfigFn = getConfig;
+        }
+      }),
+      { exitOnCtrlC: false }
+    );
+  }
+  stop() {
+    if (this.app) {
+      this.app.unmount();
+      this.app = null;
+    }
+  }
+  handleStreamUpdate(update) {
+    this.updateHandler?.(update);
+  }
+  getAgentConfig() {
+    if (this.getConfigFn) return this.getConfigFn();
+    return {
+      agentSmith: { aiEnhancement: true, minSeverity: "low", enabledCategories: { security: true, codeSmells: true, asyncBugs: true, reactPatterns: true, uxPatterns: true, backendPatterns: true }, memoryRetentionDays: 30 },
+      performance: { parallel: true, cache: true, maxConcurrency: 4, timeoutMs: 12e4, workers: true, streaming: true },
+      riskThresholds: { critical: 70, high: 40, medium: 20 }
+    };
+  }
+};
+
+export {
+  TrieScanTool,
+  StreamingManager,
+  getOutputManager,
+  InteractiveDashboard
+};
+//# sourceMappingURL=chunk-M4YMTHGG.js.map