@triedotdev/mcp 1.0.151 → 1.0.155

package/dist/{chunk-SU3WCAC4.js → chunk-BUA5PQJY.js}

@@ -1,65 +1,76 @@
 import {
   getChatStore
-} from "./chunk-F7BMFOZ6.js";
+} from "./chunk-3CYMLM35.js";
 import {
   getTrieAgent
-} from "./chunk-4UDBGYI3.js";
+} from "./chunk-X64XFVAY.js";
+import {
+  CodebaseIndex
+} from "./chunk-YEQXKKZQ.js";
 import {
   getOutputManager
-} from "./chunk-TIMIKBY2.js";
+} from "./chunk-KLMJKM63.js";
 import {
   LearningEngine,
   exportToJson,
   formatFriendlyError,
   getLastCheckpoint,
+  isTrieInitialized,
   listCheckpoints,
   perceiveCurrentChanges,
   reasonAboutChangesHumanReadable,
   saveCheckpoint
-} from "./chunk-G7Q23IGF.js";
+} from "./chunk-EMJ7RVWB.js";
 import {
   loadConfig,
   saveConfig
-} from "./chunk-TU7D5DEW.js";
+} from "./chunk-FTOF3FHT.js";
 import {
   IncidentIndex
-} from "./chunk-TCNCNWGV.js";
+} from "./chunk-KYKADM7P.js";
 import {
   findCrossProjectPatterns
-} from "./chunk-IFBEAOHH.js";
+} from "./chunk-RY57G46E.js";
 import {
   ContextGraph
-} from "./chunk-TWQPOVRA.js";
+} from "./chunk-JYWGYUKX.js";
 import {
   measureInitialGoalValue
-} from "./chunk-7HYOJ4Q7.js";
+} from "./chunk-Z2E7X4WI.js";
 import {
   getKeyFromKeychain,
   isAIAvailable,
+  runAIAnalysis,
   runAIWithTools,
   setAPIKey
-} from "./chunk-OJXFQRUE.js";
+} from "./chunk-UL337UDQ.js";
 import {
   getProjectState
-} from "./chunk-GLY76TSI.js";
+} from "./chunk-L4FODDDB.js";
 import {
   TieredStorage,
   getStorage
-} from "./chunk-LNUMECBJ.js";
+} from "./chunk-XUGUKSKO.js";
 import {
+  getAutonomyConfig,
   loadAutonomyConfig,
   saveAutonomyConfig
-} from "./chunk-QQG42HCI.js";
+} from "./chunk-XD2HKZVB.js";
+import {
+  storeIssues
+} from "./chunk-4ZAFQEP6.js";
 import {
+  getChangedFilesSinceTimestamp,
+  getGitChangedFiles,
   getLedgerBlocks
-} from "./chunk-TWPX6PHF.js";
+} from "./chunk-HD5H7YSW.js";
 import {
   getTrieDirectory,
   getWorkingDirectory
-} from "./chunk-4TQQP7JD.js";
+} from "./chunk-7F2R2ITA.js";
 import {
   isInteractiveMode
-} from "./chunk-APMV77PU.js";
+} from "./chunk-JKEEQAG2.js";
 
 // src/utils/streaming.ts
 var shouldSuppressConsole = () => isInteractiveMode();
@@ -238,6 +249,12 @@ var StreamingManager = class {
   reportSignalExtraction(signals) {
     this.emit("signal_extracted", signals);
   }
+  /**
+   * Report ledger update (new entries added)
+   */
+  reportLedgerUpdate(entryCount, source) {
+    this.emit("ledger_updated", { entryCount, source });
+  }
   // ============================================
   // Rich Content Events (for TUI panes)
   // ============================================
@@ -443,6 +460,11 @@ function handleStreamUpdate(state, update) {
       }
       break;
     }
+    case "ledger_updated": {
+      s.memoryTree = { ...s.memoryTree, loaded: false };
+      s = addActivity(s, `[L] Ledger updated: ${update.data.entryCount} ${update.data.source} entries`);
+      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"}`);
@@ -960,13 +982,13 @@ import { Box, Text, useStdout } from "ink";
 import { jsx as jsx2, jsxs } from "react/jsx-runtime";
 function Header() {
   const { state } = useDashboard();
-  const { signalExtraction, watch, alerts } = state;
+  const { signalExtraction, watch: watch2, alerts } = state;
   const { stdout } = useStdout();
   const cols = stdout?.columns || 80;
   const narrow = cols < 50;
   const totalExtracted = signalExtraction.governanceExtracted + signalExtraction.factsExtracted + signalExtraction.blockersExtracted + signalExtraction.questionsExtracted;
   let status;
-  if (watch.watching) {
+  if (watch2.watching) {
     status = totalExtracted > 0 ? /* @__PURE__ */ jsxs(Text, { children: [
       /* @__PURE__ */ jsx2(Text, { color: "green", children: "\u25CF" }),
       narrow ? "" : " ",
@@ -1194,8 +1216,8 @@ function ConfigDialog({ onClose }) {
       const loadStats = async () => {
         try {
           const workDir = getWorkingDirectory(void 0, true);
-          const { CodebaseIndex } = await import("./codebase-index-OOE7OAHP.js");
-          const index = new CodebaseIndex(workDir);
+          const { CodebaseIndex: CodebaseIndex2 } = await import("./codebase-index-N37NDF2A.js");
+          const index = new CodebaseIndex2(workDir);
           const stats = index.getStats();
           let lastUpdatedDisplay = "Never";
           if (stats.lastUpdated) {
@@ -1387,8 +1409,8 @@ function ConfigDialog({ onClose }) {
             const loadStats = async () => {
               try {
                 const workDir = getWorkingDirectory(void 0, true);
-                const { CodebaseIndex } = await import("./codebase-index-OOE7OAHP.js");
-                const index = new CodebaseIndex(workDir);
+                const { CodebaseIndex: CodebaseIndex2 } = await import("./codebase-index-N37NDF2A.js");
+                const index = new CodebaseIndex2(workDir);
                 const stats = index.getStats();
                 setIndexStats({
                   fileCount: stats.totalFiles,
@@ -1462,9 +1484,9 @@ function ConfigDialog({ onClose }) {
   }
   async function reindexCodebase() {
     const workDir = getWorkingDirectory(void 0, true);
-    const { CodebaseIndex } = await import("./codebase-index-OOE7OAHP.js");
+    const { CodebaseIndex: CodebaseIndex2 } = await import("./codebase-index-N37NDF2A.js");
     const { glob } = await import("glob");
-    const index = new CodebaseIndex(workDir);
+    const index = new CodebaseIndex2(workDir);
     const indexPattern = `${workDir}/**/*.{ts,tsx,js,jsx,mjs,vue,svelte,astro,py,go,rs,java,c,cpp,h,hpp,cs,rb,php,css,scss,html}`;
     const indexFiles = await glob(indexPattern, {
       ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**", "**/.trie/**", "**/coverage/**"],
@@ -1713,7 +1735,7 @@ function truncate(str, max) {
 }
 function OverviewView() {
   const { state, dispatch } = useDashboard();
-  const { progress, signalExtraction, watch, issues, activityLog, activityPage, pendingFixes: pendingFixes2, selectedFixIndex } = state;
+  const { progress, signalExtraction, watch: watch2, issues, activityLog, activityPage, pendingFixes: pendingFixes2, selectedFixIndex } = state;
   const { totalIssues } = progress;
   const { stdout } = useStdout4();
   const cols = stdout?.columns || 80;
@@ -1744,12 +1766,12 @@ function OverviewView() {
   return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingX: 1, children: [
     /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
       "Scanned ",
-      watch.filesScannedSession,
+      watch2.filesScannedSession,
       " files  ",
       elapsed,
       "s"
     ] }),
-    watch.watching && signalExtraction.enabled && /* @__PURE__ */ jsxs6(Text6, { wrap: "truncate", children: [
+    watch2.watching && signalExtraction.enabled && /* @__PURE__ */ jsxs6(Text6, { wrap: "truncate", children: [
       /* @__PURE__ */ jsx7(Text6, { color: "green", children: "\u25CF" }),
       " Signal extraction",
       !narrow && (signalExtraction.governanceExtracted > 0 || signalExtraction.factsExtracted > 0 || signalExtraction.blockersExtracted > 0) && /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
@@ -1925,10 +1947,10 @@ function AgentView() {
     if (!insight) return;
     try {
       const workDir = getWorkingDirectory(void 0, true);
-      const { getInsightStore } = await import("./insight-store-QEEUQR5L.js");
+      const { getInsightStore } = await import("./insight-store-AMEP5PPF.js");
       const store = getInsightStore(workDir);
       await store.dismissInsight(insight.id);
-      const { getStorage: getStorage2 } = await import("./tiered-storage-P6Z3NV2Q.js");
+      const { getStorage: getStorage2 } = await import("./tiered-storage-SQDVZM2M.js");
       const storage = getStorage2(workDir);
       await storage.dismissNudge(insight.id).catch(() => {
       });
@@ -2287,7 +2309,7 @@ function GoalsView() {
       dispatch({ type: "SET_GOAL_SCANNING", goalId, progress: "Starting scan..." });
       dispatch({ type: "ADD_ACTIVITY", message: `Scanning goal: ${goalSummary.description}...` });
       dispatch({ type: "SET_GOAL_SCANNING", goalId, progress: "Loading goal configuration..." });
-      const { checkFilesForGoalViolations } = await import("./goal-validator-EM5XVWVC.js");
+      const { checkFilesForGoalViolations } = await import("./goal-validator-FU5QWDQT.js");
       const agentState = getProjectState(workDir);
       await agentState.load();
       const fullGoal = agentState.getAllGoals().find((g) => g.id === goalId);
@@ -2562,7 +2584,7 @@ function HypothesesView() {
       dispatch({ type: "SET_HYPOTHESIS_SCANNING", hypothesisId: hypoId, progress: "Gathering evidence..." });
       dispatch({ type: "ADD_ACTIVITY", message: `Testing hypothesis: ${hypo.statement}` });
       dispatch({ type: "SHOW_NOTIFICATION", message: `Gathering evidence for hypothesis...`, severity: "info", autoHideMs: 3e3 });
-      const { gatherEvidenceForHypothesis } = await import("./hypothesis-4UPE7KXU.js");
+      const { gatherEvidenceForHypothesis } = await import("./hypothesis-JURDWVDC.js");
       const evidence = await gatherEvidenceForHypothesis(hypoId, workDir, signal);
       scanAbortRef.current = null;
       dispatch({ type: "SET_HYPOTHESIS_SCANNING", hypothesisId: null, progress: "" });
@@ -6238,7 +6260,7 @@ function getPendingFixes() {
 }
 async function loadPendingFixesFromMemory() {
   try {
-    const { getRecentIssues } = await import("./issue-store-C6XYENE5.js");
+    const { getRecentIssues } = await import("./issue-store-RM3XLLKG.js");
     pendingFixes.clear();
     const recentIssues = await getRecentIssues({ limit: 50, includeResolved: false });
     for (const storedIssue of recentIssues) {
@@ -6541,7 +6563,7 @@ var TrieCloudFixTool = class {
     if (pending.length === 0) {
       try {
         console.log("Loading issues from memory...");
-        const { getRecentIssues } = await import("./issue-store-C6XYENE5.js");
+        const { getRecentIssues } = await import("./issue-store-RM3XLLKG.js");
         const recentIssues = await getRecentIssues({ limit: 50, includeResolved: false });
         console.log(`Found ${recentIssues.length} recent issues in memory`);
         const memoryIssues = recentIssues.map((storedIssue) => ({
@@ -6981,7 +7003,7 @@ var TrieQueryContextTool = class {
     }
     if (includeIncidents) {
       try {
-        const { ContextGraph: ContextGraph2 } = await import("./graph-26JPZ3DF.js");
+        const { ContextGraph: ContextGraph2 } = await import("./graph-JO7GG65P.js");
         const graph = new ContextGraph2(workDir);
         const allNodes = await graph.listNodes();
         const incidentNodes = allNodes.filter((n) => n.type === "incident");
@@ -8246,7 +8268,7 @@ ${truncated}`;
         const goalId = input.goalId ? String(input.goalId).trim() : void 0;
         try {
           onProgress?.("Loading goals...");
-          const { getActiveGoals } = await import("./goal-validator-EM5XVWVC.js");
+          const { getActiveGoals } = await import("./goal-validator-FU5QWDQT.js");
           const agentState = getProjectState(directory);
           await agentState.load();
           const allGoals = await getActiveGoals(directory);
@@ -8255,7 +8277,7 @@ ${truncated}`;
             return goalId ? `No active goal found with ID: ${goalId}` : "No active goals to check. Add goals in the Goals view first.";
           }
           onProgress?.("Scanning codebase for violations...");
-          const { analyzeFilesRapidly } = await import("./fast-analyzer-FMU3X4AZ.js");
+          const { analyzeFilesRapidly } = await import("./fast-analyzer-U6URGNQT.js");
           const analysisOptions = {
             maxFiles: 50,
             enableSmartBatching: true
@@ -8269,8 +8291,8 @@ ${truncated}`;
             const cacheInfo2 = analysisResult.cacheHitRatio > 0 ? ` (${Math.round(analysisResult.cacheHitRatio * 100)}% cache hit, ${analysisResult.timeMs}ms)` : ` (${analysisResult.timeMs}ms)`;
             return `\u2713 Scan complete! No violations found for ${goalsToCheck.length} goal(s).${cacheInfo2}`;
           }
-          const { storeIssues } = await import("./issue-store-C6XYENE5.js");
-          const { basename } = await import("path");
+          const { storeIssues: storeIssues2 } = await import("./issue-store-RM3XLLKG.js");
+          const { basename: basename2 } = await import("path");
           const issuesToStore = violations.map((v, i) => ({
             id: `goal-violation-${Date.now()}-${i}`,
             file: v.file,
@@ -8282,7 +8304,7 @@ ${truncated}`;
             confidence: 80,
             autoFixable: false
           }));
-          await storeIssues(issuesToStore, basename(directory), directory);
+          await storeIssues2(issuesToStore, basename2(directory), directory);
           let violationsReport = `Found ${violations.length} violation(s):
 
 `;
@@ -8348,7 +8370,7 @@ ${truncated}`;
         }
         try {
           onProgress?.("Gathering evidence for hypothesis...");
-          const { gatherEvidenceForHypothesis } = await import("./hypothesis-4UPE7KXU.js");
+          const { gatherEvidenceForHypothesis } = await import("./hypothesis-JURDWVDC.js");
           const evidence = await gatherEvidenceForHypothesis(hypothesisId, directory);
           if (evidence.length === 0) {
             return `No evidence found for this hypothesis yet. The codebase may not have enough data to validate it \u2014 try running trie_scan_for_goal_violations first to populate issues, or add more context.`;
@@ -8612,7 +8634,7 @@ function ChatView() {
     const saveChat = async () => {
       try {
         const workDir = getWorkingDirectory(void 0, true);
-        const { getChatStore: getChatStore2 } = await import("./chat-store-HMTDL7I2.js");
+        const { getChatStore: getChatStore2 } = await import("./chat-store-O3IJ5PMN.js");
         const store = getChatStore2(workDir);
         const sessionId = await store.saveSession(
           messages,
@@ -9247,7 +9269,7 @@ import { jsx as jsx15, jsxs as jsxs14 } from "react/jsx-runtime";
 var MAIN_VIEWS = ["overview", "memory", "goals", "hypotheses", "agent", "chat"];
 async function applyGoalFix(fix, dispatch) {
   try {
-    const { runAIAnalysis, isAIAvailable: isAIAvailable2 } = await import("./client-5L64D5SQ.js");
+    const { runAIAnalysis: runAIAnalysis2, isAIAvailable: isAIAvailable2 } = await import("./client-ZHOLZTRW.js");
     if (!isAIAvailable2()) {
       dispatch({ type: "DISMISS_FIX", id: fix.id });
       getOutputManager().nudge("AI not available for fix", "warning");
@@ -9256,7 +9278,7 @@ async function applyGoalFix(fix, dispatch) {
     const projectPath = getWorkingDirectory(void 0, true);
     const fullPath = join3(projectPath, fix.file);
     const content = await readFile4(fullPath, "utf-8");
-    const result = await runAIAnalysis({
+    const result = await runAIAnalysis2({
       systemPrompt: `You are a precise code fixer. The user has a quality goal: "${fix.goalDescription}".
 A violation was detected: "${fix.description}"
 Suggested fix: "${fix.suggestedFix}"
@@ -9282,7 +9304,7 @@ ${content}
       fixedContent = fixedContent.replace(/^```\w*\n?/, "").replace(/\n?```$/, "");
     }
     await writeFile2(fullPath, fixedContent, "utf-8");
-    const { recordGoalViolationFixed, getActiveGoals } = await import("./goal-validator-EM5XVWVC.js");
+    const { recordGoalViolationFixed, getActiveGoals } = await import("./goal-validator-FU5QWDQT.js");
     const goals = await getActiveGoals(projectPath);
     const matchedGoal = goals.find((g) => g.description === fix.goalDescription);
     if (matchedGoal) {
@@ -9320,7 +9342,7 @@ function DashboardApp({ onReady }) {
       const workDir = getWorkingDirectory(void 0, true);
       await mkdir2(getTrieDirectory(workDir), { recursive: true });
       await writeFile2(configPath, JSON.stringify(stateRef.current.agentConfig, null, 2), "utf-8");
-      const { saveAutonomyConfig: saveAutonomyConfig2, loadAutonomyConfig: loadAutonomyConfig2 } = await import("./autonomy-config-3APNC6QF.js");
+      const { saveAutonomyConfig: saveAutonomyConfig2, loadAutonomyConfig: loadAutonomyConfig2 } = await import("./autonomy-config-RKLZW4XL.js");
       const autonomy = await loadAutonomyConfig2(workDir);
       autonomy.aiWatcher = stateRef.current.agentConfig.aiWatcher;
       await saveAutonomyConfig2(workDir, autonomy);
@@ -9398,7 +9420,7 @@ function DashboardApp({ onReady }) {
   const loadPersistedNudges = useCallback7(async () => {
     try {
       const workDir = getWorkingDirectory(void 0, true);
-      const { getStorage: getStorage2 } = await import("./tiered-storage-P6Z3NV2Q.js");
+      const { getStorage: getStorage2 } = await import("./tiered-storage-SQDVZM2M.js");
       const storage = getStorage2(workDir);
       await storage.initialize();
       const nudges = await storage.queryNudges({ resolved: false, limit: 50 });
@@ -9626,6 +9648,17 @@ var InteractiveDashboard = class {
   updateHandler = null;
   getConfigFn = null;
   async start() {
+    if (!process.stdin.isTTY || typeof process.stdin.setRawMode !== "function") {
+      return;
+    }
+    try {
+      const currentMode = process.stdin.isRaw;
+      if (currentMode === void 0) {
+        return;
+      }
+    } catch {
+      return;
+    }
     this.app = render(
       React11.createElement(App, {
         onReady: (handler, getConfig) => {
@@ -9655,6 +9688,1411 @@ var InteractiveDashboard = class {
   }
 };
 
+// src/tools/watch.ts
+import { watch, existsSync as existsSync6, readFileSync as readFileSync2 } from "fs";
+import { stat, readFile as readFile5 } from "fs/promises";
+import { join as join4, extname as extname3, basename } from "path";
+import { createHash as createHash2 } from "crypto";
+var WATCH_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".vue",
+  ".svelte",
+  ".astro",
+  ".py",
+  ".go",
+  ".rs"
+]);
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".turbo",
+  ".cache"
+]);
+var TrieWatchTool = class _TrieWatchTool {
+  extractionPipeline = null;
+  watchedDirectory = "";
+  codebaseIndex = null;
+  state = {
+    isRunning: false,
+    lastScan: /* @__PURE__ */ new Map(),
+    pendingFiles: /* @__PURE__ */ new Set(),
+    scanDebounceTimer: null,
+    issueCache: /* @__PURE__ */ new Map(),
+    totalIssuesFound: 0,
+    filesScanned: 0,
+    nudgedFiles: /* @__PURE__ */ new Set(),
+    nudges: [],
+    lastAutoScan: 0,
+    autoScanInProgress: false,
+    tokenBudget: {
+      used: 0,
+      windowStart: Date.now(),
+      hourlyLimit: 5e4,
+      scansSaved: 0
+    },
+    cleanFiles: /* @__PURE__ */ new Map()
+  };
+  watchers = /* @__PURE__ */ new Map();
+  streamingManager = void 0;
+  dashboard = void 0;
+  lastHypothesisCheck = 0;
+  pipelineSyncTimer = null;
+  static HYPOTHESIS_CHECK_INTERVAL_MS = 3e5;
+  // Check every 5 minutes
+  static PIPELINE_SYNC_INTERVAL_MS = 30 * 60 * 1e3;
+  // 30 minutes
+  async execute(args) {
+    const { action, directory, debounceMs = 1e3 } = args;
+    switch (action) {
+      case "start":
+        return this.startWatching(getWorkingDirectory(directory), debounceMs);
+      case "stop":
+        return await this.stopWatching();
+      case "status":
+        return await this.getStatus();
+      case "issues":
+        return this.getCurrentIssues();
+      case "nudges":
+        return this.getNudges();
+      default:
+        return {
+          content: [{
+            type: "text",
+            text: `Unknown action: ${action}. Use 'start', 'stop', 'status', or 'issues'.`
+          }]
+        };
+    }
+  }
+  async startWatching(directory, debounceMs) {
+    if (this.state.isRunning) {
+      return {
+        content: [{
+          type: "text",
+          text: "[!] Watch mode is already running. Use `trie_watch stop` to stop it first."
+        }]
+      };
+    }
+    if (!isTrieInitialized(directory)) {
+      return {
+        content: [{
+          type: "text",
+          text: "Trie is not initialized for this project. Run `trie init` first."
+        }]
+      };
+    }
+    const anthropicApiKey = process.env.ANTHROPIC_API_KEY;
+    if (anthropicApiKey) {
+      this.extractionPipeline = new ExtractionPipeline({
+        workingDirectory: directory,
+        anthropicApiKey
+      });
+      await this.extractionPipeline.initialize();
+    }
+    this.codebaseIndex = new CodebaseIndex(directory);
+    this.state.isRunning = true;
+    this.watchedDirectory = directory;
+    this.state.issueCache.clear();
+    this.state.totalIssuesFound = 0;
+    this.state.filesScanned = 0;
+    this.state.nudgedFiles.clear();
+    this.state.nudges = [];
+    try {
+      const storage = getStorage(directory);
+      await storage.initialize();
+      const unresolvedNudges = await storage.queryNudges({ resolved: false });
+      console.debug(`[Watch] Found ${unresolvedNudges.length} unresolved nudges in storage`);
+      for (const nudge of unresolvedNudges) {
+        let mappedSeverity = "high";
+        if (nudge.severity === "critical") {
+          mappedSeverity = "critical";
+        } else if (nudge.severity === "high") {
+          mappedSeverity = "high";
+        }
+        this.state.nudges.push({
+          file: nudge.file || "unknown",
+          // Keep full path, don't use basename
+          message: nudge.message,
+          severity: mappedSeverity,
+          timestamp: new Date(nudge.timestamp).toLocaleTimeString("en-US", { hour12: false })
+        });
+        console.debug(`[Watch] Loaded nudge: ${nudge.message.slice(0, 60)}... (${nudge.severity} -> ${mappedSeverity})`);
+      }
+      if (unresolvedNudges.length > 0) {
+        console.log(`[Watch] \u2713 Loaded ${unresolvedNudges.length} unresolved nudges from storage`);
+      } else {
+        console.debug(`[Watch] No unresolved nudges found in storage`);
+      }
+    } catch (error) {
+      console.error("[Watch] Failed to load nudges from storage:", error);
+    }
+    try {
+      const graph = new ContextGraph(directory);
+      const allNodes = await graph.listNodes();
+      const unresolvedIncidents = allNodes.filter(
+        (n) => n.type === "incident" && !n.data.resolved
+      );
+      console.debug(`[Watch] Found ${unresolvedIncidents.length} unresolved incidents in context graph`);
+      for (const incident of unresolvedIncidents) {
+        const incidentData = incident.data;
+        let mappedSeverity = "high";
+        if (incidentData.severity === "critical") {
+          mappedSeverity = "critical";
+        } else if (incidentData.severity === "major") {
+          mappedSeverity = "critical";
+        } else if (incidentData.severity === "minor") {
+          mappedSeverity = "high";
+        }
+        const edges = await graph.getEdges(incident.id);
+        const linkedFiles = edges.filter((e) => e.type === "causedBy" || e.type === "affects").map((e) => {
+          const node = allNodes.find((n) => n.id === e.to_id || n.id === e.from_id);
+          if (node?.type === "file") {
+            return node.data.path;
+          }
+          return null;
+        }).filter((f) => f !== null);
+        const file = linkedFiles[0] || "unknown";
+        const message = `INCIDENT: ${incidentData.description}`;
+        this.state.nudges.push({
+          file,
+          message,
+          severity: mappedSeverity,
+          timestamp: new Date(incidentData.timestamp).toLocaleTimeString("en-US", { hour12: false })
+        });
+        console.debug(`[Watch] Loaded incident: ${incidentData.description.slice(0, 60)}... (${incidentData.severity} -> ${mappedSeverity})`);
+      }
+      if (unresolvedIncidents.length > 0) {
+        console.log(`[Watch] \u2713 Loaded ${unresolvedIncidents.length} unresolved incidents from context graph`);
+      } else {
+        console.debug(`[Watch] No unresolved incidents found in context graph`);
+      }
+    } catch (error) {
+      console.error("[Watch] Failed to load incidents from context graph:", error);
+    }
+    if (!isInteractiveMode()) {
+      console.error("\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+      console.error("TRIE AGENT - NOW WATCHING");
+      console.error("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n");
+      console.error("Your Trie agent is now watching over your codebase.");
+      console.error("Signal extraction: ENABLED (building governance ledger)");
+      console.error(`Watching: ${directory}`);
+      console.error(`Debounce: ${debounceMs}ms`);
+      console.error("");
+    }
+    if (isInteractiveMode()) {
+      this.streamingManager = new StreamingManager();
+      this.dashboard = new InteractiveDashboard();
+      this.streamingManager.subscribe((update) => this.dashboard?.handleStreamUpdate(update));
+      const outputManager = getOutputManager();
+      outputManager.setMode("tui");
+      outputManager.setStreamingManager(this.streamingManager);
+      await this.dashboard.start();
+      this.streamingManager.reportWatchStatus({ watching: true, directories: 0, debounceMs });
+    } else {
+      getOutputManager().setMode("console");
+    }
+    await this.watchDirectory(directory, debounceMs);
+    await this.watchContextGraph(directory);
+    if (this.streamingManager) {
+      this.streamingManager.reportWatchStatus({
+        watching: true,
+        directories: this.watchers.size,
+        debounceMs
+      });
+    }
+    setTimeout(() => {
+      void this.initialGoalComplianceScan();
+      void this.initialHypothesisGeneration();
+      void this.syncPipelineIntegrations();
+    }, 1e3);
+    this.pipelineSyncTimer = setInterval(() => {
+      void this.syncPipelineIntegrations();
+    }, _TrieWatchTool.PIPELINE_SYNC_INTERVAL_MS);
+    const indexStatus = this.codebaseIndex?.isEmpty() ? "BUILDING (one-time, speeds up goal checks)" : "READY";
+    return {
+      content: [{
+        type: "text",
+        text: `**TRIE AGENT ACTIVATED** 
+
+Your Trie agent is now autonomously watching and learning from your codebase.
+
+**Watching:** \`${directory}\`
+**Debounce:** ${debounceMs}ms (waits for you to stop typing)
+**Signal Extraction:** ${process.env.ANTHROPIC_API_KEY ? "ENABLED" : "LIMITED (set ANTHROPIC_API_KEY for full extraction)"}
+**Codebase Index:** ${indexStatus}
+
+### How the agent works:
+1. You write/edit code
+2. Agent detects the change
+3. Extracts governance, facts, blockers -> stores in ledger
+4. Predicts risks based on historical patterns
+5. Nudges you if something looks risky
+
+### The agent learns:
+- Every commit builds the governance ledger
+- \`trie gotcha\` queries the ledger for predictions
+- \`trie ok\` / \`trie bad\` teach the agent what matters
+
+### Commands:
+- \`trie_watch status\` - See agent status
+- \`trie_watch stop\` - Stop the agent
+- \`trie_index status\` - Check codebase index`
+      }]
+    };
+  }
+  shouldSkipPath(filePath) {
+    const parts = filePath.split("/");
+    return parts.some((p) => SKIP_DIRS.has(p) || p.startsWith(".") && p !== ".");
+  }
+  async watchDirectory(dir, debounceMs) {
+    if (!existsSync6(dir)) return;
+    try {
+      const dirStat = await stat(dir);
+      if (!dirStat.isDirectory()) return;
+      const watcher = watch(dir, { persistent: true, recursive: true }, (_eventType, filename) => {
+        if (!filename) return;
+        if (this.shouldSkipPath(filename)) return;
+        const ext = extname3(filename).toLowerCase();
+        if (!WATCH_EXTENSIONS.has(ext)) return;
+        const fullPath = join4(dir, filename);
+        if (!existsSync6(fullPath)) return;
+        this.state.pendingFiles.add(fullPath);
+        if (this.state.scanDebounceTimer) {
+          clearTimeout(this.state.scanDebounceTimer);
+        }
+        this.state.scanDebounceTimer = setTimeout(() => {
+          this.processPendingFiles();
+        }, debounceMs);
+      });
+      watcher.on("error", (err) => {
+        if (!isInteractiveMode()) {
+          console.error(`[!] Watcher error: ${err.message}`);
+        }
+        watcher.close();
+        this.watchers.delete(dir);
+      });
+      this.watchers.set(dir, watcher);
+      if (this.streamingManager) {
+        this.streamingManager.reportWatchStatus({
+          watching: true,
+          directories: 1,
+          debounceMs
+        });
+      }
+    } catch {
+    }
+  }
+  /**
+   * Watch .trie/context.json for incident changes
+   */
+  async watchContextGraph(directory) {
+    const contextPath = join4(getTrieDirectory(directory), "context.json");
+    if (!existsSync6(contextPath)) {
+      console.debug("[Watch] No context.json found, skipping incident watcher");
+      return;
+    }
+    try {
+      const watcher = watch(contextPath, { persistent: true }, async (_eventType, _filename) => {
+        console.debug("[Watch] context.json changed, reloading incidents...");
+        await this.reloadIncidents(directory);
+      });
+      watcher.on("error", (err) => {
+        console.error(`[Watch] Context watcher error: ${err.message}`);
+        watcher.close();
+      });
+      this.watchers.set("context.json", watcher);
+      console.debug("[Watch] \u2713 Watching context.json for incident changes");
+    } catch (error) {
+      console.error("[Watch] Failed to set up context.json watcher:", error);
+    }
+  }
+  /**
+   * Reload incidents from context graph
+   */
+  async reloadIncidents(directory) {
+    try {
+      const graph = new ContextGraph(directory);
+      const allNodes = await graph.listNodes();
+      const unresolvedIncidents = allNodes.filter(
+        (n) => n.type === "incident" && !n.data.resolved
+      );
+      this.state.nudges = this.state.nudges.filter((n) => !n.message.startsWith("INCIDENT:"));
+      for (const incident of unresolvedIncidents) {
+        const incidentData = incident.data;
+        let mappedSeverity = "high";
+        if (incidentData.severity === "critical") {
+          mappedSeverity = "critical";
+        } else if (incidentData.severity === "major") {
+          mappedSeverity = "critical";
+        } else if (incidentData.severity === "minor") {
+          mappedSeverity = "high";
+        }
+        const edges = await graph.getEdges(incident.id);
+        const linkedFiles = edges.filter((e) => e.type === "causedBy" || e.type === "affects").map((e) => {
+          const node = allNodes.find((n) => n.id === e.to_id || n.id === e.from_id);
+          if (node?.type === "file") {
+            return node.data.path;
+          }
+          return null;
+        }).filter((f) => f !== null);
+        const file = linkedFiles[0] || "unknown";
+        const message = `INCIDENT: ${incidentData.description}`;
+        this.state.nudges.push({
+          file,
+          message,
+          severity: mappedSeverity,
+          timestamp: new Date(incidentData.timestamp).toLocaleTimeString("en-US", { hour12: false })
+        });
+      }
+      console.log(`[Watch] \u2713 Reloaded ${unresolvedIncidents.length} unresolved incidents`);
+    } catch (error) {
+      console.error("[Watch] Failed to reload incidents:", error);
+    }
+  }
+  async processPendingFiles() {
+    if (this.state.pendingFiles.size === 0) return;
+    const files = Array.from(this.state.pendingFiles);
+    this.state.pendingFiles.clear();
+    if (!isInteractiveMode()) {
+      console.error(`
+Detected changes in ${files.length} file(s):`);
+      for (const file of files) {
+        console.error(`   - ${basename(file)}`);
+      }
+      console.error("");
+    }
+    try {
+      const projectPath = this.watchedDirectory || getWorkingDirectory(void 0, true);
+      if (this.extractionPipeline) {
+        try {
+          const fileContents = await Promise.all(
+            files.map(async (file) => {
+              try {
+                const content = await readFile5(file, "utf-8");
+                return { file, content };
+              } catch {
+                return null;
+              }
+            })
+          );
+          const validFiles = fileContents.filter((f) => f !== null);
+          if (validFiles.length > 0) {
+            const combinedContent = validFiles.map(
+              (f) => `File: ${basename(f.file)}
+${f.content.slice(0, 1e3)}`
+              // First 1KB of each file
+            ).join("\n\n---\n\n");
+            if (!isInteractiveMode()) {
+              console.error("[*] Extracting signals from changes...");
+            }
+            const signal = await this.extractionPipeline.process(combinedContent, {
+              sourceType: "file",
+              sourceId: `watch-${Date.now()}`
+            });
+            if (signal.governance.length > 0 || signal.facts.length > 0 || signal.blockers.length > 0) {
+              const govCount = signal.governance.length;
+              if (!isInteractiveMode()) {
+                console.error(`   [+] Extracted: ${govCount} governance, ${signal.facts.length} facts, ${signal.blockers.length} blockers`);
+              }
+              if (this.streamingManager) {
+                this.streamingManager.reportSignalExtraction({
+                  governance: govCount,
+                  facts: signal.facts.length,
+                  blockers: signal.blockers.length,
+                  questions: signal.questions.length
+                });
+              }
+            }
+          }
+        } catch (error) {
+          if (!isInteractiveMode()) {
+            console.error(`   [!] Signal extraction failed: ${error}`);
+          }
+        }
+      } else {
+        if (files.length > 0 && !isInteractiveMode()) {
+          console.debug("[Watch] Signal extraction skipped: ANTHROPIC_API_KEY not set");
+        }
+      }
+      void this.autoScanFiles(files).catch((err) => {
+        getOutputManager().log("warn", `Auto scan failed: ${err}`);
+      });
+      await this.discoverPatternsFromIssues(projectPath);
+      const now = Date.now();
+      if (now - this.lastHypothesisCheck > _TrieWatchTool.HYPOTHESIS_CHECK_INTERVAL_MS) {
+        this.checkAndGenerateHypotheses(projectPath);
+        this.lastHypothesisCheck = now;
+      }
+      if (this.streamingManager) {
+        const now2 = Date.now();
+        for (const file of files) {
+          const lastReport = this.state.lastScan.get(file) || 0;
+          if (now2 - lastReport > 2e3) {
+            this.streamingManager.reportWatchChange(file);
+          }
+        }
+      }
+      this.state.filesScanned += files.length;
+      for (const file of files) {
+        this.state.lastScan.set(file, Date.now());
+        if (this.codebaseIndex) {
+          const relativePath = file.replace(projectPath + "/", "");
+          void this.codebaseIndex.indexFile(relativePath).then(() => {
+            void this.codebaseIndex?.save();
+          });
+        }
+      }
+    } catch (error) {
+      if (!isInteractiveMode()) {
+        console.error(`Scan error: ${error}`);
+      }
+    }
+  }
+  isQuiet() {
+    const projectPath = this.watchedDirectory || getWorkingDirectory(void 0, true);
+    const quietPath = join4(getTrieDirectory(projectPath), "quiet.json");
+    try {
+      const raw = readFileSync2(quietPath, "utf-8");
+      const data = JSON.parse(raw);
+      const until = new Date(data.until).getTime();
+      return Date.now() < until;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check and generate hypotheses autonomously
+   * Claude observes patterns and creates new hypotheses to test
+   */
+  async checkAndGenerateHypotheses(projectPath) {
+    if (!isAIAvailable()) return;
+    try {
+      const { getHypothesisEngine } = await import("./hypothesis-JURDWVDC.js");
+      const { getOutputManager: getOutputManager2 } = await import("./output-manager-FX4V7ERT.js");
+      const hypothesisEngine = getHypothesisEngine(projectPath);
+      const recentIssues = Array.from(this.state.issueCache.values()).flat();
+      const patterns = [];
+      const observations = [];
+      if (this.state.nudges.length > 0) {
+        const nudgesByFile = {};
+        for (const nudge of this.state.nudges) {
+          nudgesByFile[nudge.file] = (nudgesByFile[nudge.file] || 0) + 1;
+        }
+        const topFiles = Object.entries(nudgesByFile).sort(([, a], [, b]) => b - a).slice(0, 3);
+        if (topFiles[0] && topFiles[0][1] > 2) {
+          observations.push(`File ${topFiles[0][0]} has ${topFiles[0][1]} repeated issues this session`);
+        }
+      }
+      if (this.state.nudges.length > 5) {
+        observations.push(`High issue detection rate: ${this.state.nudges.length} violations detected in watch session`);
+      }
+      let generated = await hypothesisEngine.generateHypothesesWithAI({
+        recentIssues,
+        patterns,
+        observations
+      });
+      if (generated.length === 0) {
+        generated = await hypothesisEngine.autoGenerateHypotheses();
+      }
+      for (const hypothesis of generated) {
+        const message = `[New Hypothesis] "${hypothesis.statement}" (${Math.round(hypothesis.confidence * 100)}% confidence)`;
+        getOutputManager2().nudge(
+          message,
+          "info",
+          void 0,
+          1e4
+        );
+        if (!isInteractiveMode()) {
+          console.error(`
+   [?] ${message}`);
+          console.error(`       Test: ${hypothesis.testCriteria || "Collecting evidence..."}`);
+        }
+        if (this.streamingManager) {
+          this.streamingManager.reportSignalExtraction({
+            governance: 0,
+            facts: 0,
+            blockers: 0,
+            questions: 1
+            // Hypotheses are questions to answer
+          });
+        }
+      }
+      if (recentIssues.length > 10) {
+        await hypothesisEngine.updateConfidenceFromOutcomes();
+      }
+    } catch (error) {
+      if (!isInteractiveMode()) {
+        console.error(`   [!] Hypothesis check failed: ${error}`);
+      }
+    }
+  }
+  /**
+   * Discover patterns from accumulated issues
+   * Patterns emerge naturally from your coding workflow
+   */
+  async discoverPatternsFromIssues(projectPath) {
+    const totalIssues = Array.from(this.state.issueCache.values()).flat().length;
+    if (totalIssues < 5) return;
+    try {
+      const { ContextGraph: ContextGraph2 } = await import("./graph-JO7GG65P.js");
+      const { IncidentIndex: IncidentIndex2 } = await import("./incident-index-7CAXUNTL.js");
+      const { TriePatternDiscovery } = await import("./pattern-discovery-F7LU5K6E.js");
+      const graph = new ContextGraph2(projectPath);
+      const incidentIndex = await IncidentIndex2.build(graph, projectPath);
+      const discovery = new TriePatternDiscovery(graph, incidentIndex);
+      const hotPatterns = discovery.discoverHotPatterns(2);
+      for (const hot of hotPatterns) {
+        const existingPatterns = await graph.listNodes();
+        const alreadyExists = existingPatterns.some(
+          (n) => n.type === "pattern" && n.data.description?.includes(hot.path)
+        );
+        if (!alreadyExists) {
+          await graph.addNode("pattern", {
+            description: `${hot.type === "directory" ? "Directory" : "File"} hot zone: ${hot.path}`,
+            appliesTo: [hot.path],
+            confidence: Math.min(0.95, hot.confidence),
+            occurrences: hot.incidentCount,
+            firstSeen: (/* @__PURE__ */ new Date()).toISOString(),
+            lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
+            isAntiPattern: hot.incidentCount >= 3,
+            // 3+ incidents = anti-pattern
+            source: "local"
+          });
+          if (!isInteractiveMode()) {
+            console.error(`   [+] Pattern discovered: ${hot.path} (${hot.incidentCount} issues)`);
+          }
+          if (this.streamingManager) {
+            this.streamingManager.reportSignalExtraction({
+              governance: 0,
+              facts: 1,
+              // Patterns are facts about the codebase
+              blockers: 0,
+              questions: 0
+            });
+          }
+        }
+      }
+      if (totalIssues >= 10) {
+        const coOccurrences = await discovery.discoverCoOccurrences(2);
+        for (const coOcc of coOccurrences.slice(0, 3)) {
+          const desc = `Files break together: ${coOcc.files[0]} + ${coOcc.files[1]}`;
+          const existingPatterns = await graph.listNodes();
+          const alreadyExists = existingPatterns.some(
+            (n) => n.type === "pattern" && n.data.description === desc
+          );
+          if (!alreadyExists) {
+            await graph.addNode("pattern", {
+              description: desc,
+              appliesTo: [...coOcc.files],
+              confidence: Math.min(0.95, coOcc.confidence),
+              occurrences: coOcc.coOccurrences,
+              firstSeen: (/* @__PURE__ */ new Date()).toISOString(),
+              lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
+              isAntiPattern: coOcc.confidence > 0.7,
+              source: "local"
+            });
+            if (!isInteractiveMode()) {
+              console.error(`   [+] Co-occurrence pattern: ${coOcc.files[0]} + ${coOcc.files[1]}`);
+            }
+          }
+        }
+      }
+    } catch (error) {
+      if (!isInteractiveMode()) {
+        console.error(`   [!] Pattern discovery failed: ${error}`);
+      }
+    }
+  }
+  // Defaults -- overridden by config when loaded
+  aiWatcherCooldownMs = 3e4;
+  cleanFileCooldownMs = 3e5;
+  maxFilesPerScan = 5;
+  maxCharsPerFile = 4e3;
+  /**
+   * Use the trie (context graph) to score how urgently a file needs scanning.
+   * Higher score = more worth spending tokens on.
+   */
+  async scoreScanPriority(file, graph, projectPath) {
+    let score = 1;
+    const lastClean = this.state.cleanFiles.get(file);
+    if (lastClean && Date.now() - lastClean < this.cleanFileCooldownMs) {
+      return 0;
+    }
+    const fileNode = await graph.getNode("file", join4(projectPath, file));
+    if (!fileNode) return score;
+    const data = fileNode.data;
+    const riskScores = { critical: 10, high: 6, medium: 2, low: 1 };
+    score += riskScores[data.riskLevel] ?? 1;
+    score += Math.min(data.incidentCount * 3, 12);
+    if (data.changeCount > 10) score += 2;
+    return score;
+  }
+  /**
+   * Roll the token budget window if an hour has passed.
+   * Returns remaining tokens in the current window.
+   */
+  getRemainingBudget() {
+    const budget = this.state.tokenBudget;
+    const elapsed = Date.now() - budget.windowStart;
+    if (elapsed > 36e5) {
+      budget.used = 0;
+      budget.windowStart = Date.now();
+    }
+    return Math.max(0, budget.hourlyLimit - budget.used);
+  }
+  recordTokenUsage(tokens) {
+    this.state.tokenBudget.used += tokens;
+  }
+  /**
+   * AI-powered watcher -- the primary detection system.
+   * 
+   * This is the single AI call that handles:
+   * 1. Code review (bugs, security, logic errors)
+   * 2. Goal violation detection (user-defined quality goals)
+   * 
+   * When goals are active, files with goal violations bypass priority scoring
+   * so violations are always caught. Throttled by cooldown + token budget.
+   */
+  async autoScanFiles(files) {
+    if (!isAIAvailable()) return;
+    if (this.state.autoScanInProgress) return;
+    const now = Date.now();
+    if (now - this.state.lastAutoScan < this.aiWatcherCooldownMs) return;
+    this.state.autoScanInProgress = true;
+    this.state.lastAutoScan = now;
+    const projectPath = this.watchedDirectory || getWorkingDirectory(void 0, true);
+    try {
+      try {
+        const config = await getAutonomyConfig(projectPath);
+        const wc = config.aiWatcher;
+        if (!wc.enabled) return;
+        this.state.tokenBudget.hourlyLimit = wc.hourlyTokenLimit;
+        this.aiWatcherCooldownMs = wc.scanCooldownSec * 1e3;
+        this.cleanFileCooldownMs = wc.cleanFileCooldownSec * 1e3;
+        this.maxFilesPerScan = wc.maxFilesPerScan;
+        this.maxCharsPerFile = wc.maxCharsPerFile;
+      } catch {
+      }
+      const remaining = this.getRemainingBudget();
+      if (remaining < 500) return;
+      try {
+        const graph = new ContextGraph(projectPath);
+        const { getActiveGoals, recordGoalViolationCaught } = await import("./goal-validator-FU5QWDQT.js");
+        console.debug("[AI Watcher] Loading active goals...");
+        const activeGoals = await getActiveGoals(projectPath);
+        const hasGoals = activeGoals.length > 0;
+        console.debug("[AI Watcher] Goals loaded:", {
+          totalGoals: activeGoals.length,
+          hasGoals,
+          goals: activeGoals.map((g) => ({ id: g.id, description: g.description, status: g.status }))
+        });
+        if (this.isQuiet() && !hasGoals) return;
+        const scored = [];
+        for (const file of files) {
+          const relativePath = file.replace(projectPath + "/", "");
+          const score = await this.scoreScanPriority(relativePath, graph, projectPath);
+          if (hasGoals || score > 0) {
+            scored.push({ file, relativePath, score: Math.max(score, hasGoals ? 1 : 0) });
+          } else {
+            this.state.tokenBudget.scansSaved++;
+          }
+        }
+        if (scored.length === 0) return;
+        scored.sort((a, b) => b.score - a.score);
+        const budgetScale = remaining > 2e4 ? 1 : remaining > 1e4 ? 0.6 : 0.4;
+        const maxFiles = Math.max(1, Math.round(this.maxFilesPerScan * budgetScale));
+        const filesToScan = scored.slice(0, maxFiles);
+        const charLimit = Math.round(this.maxCharsPerFile * (remaining > 15e3 ? 1 : 0.5));
+        const fileContents = await Promise.all(
+          filesToScan.map(async ({ file, relativePath }) => {
+            try {
+              const content = await readFile5(file, "utf-8");
+              return { path: relativePath, content: content.slice(0, charLimit) };
+            } catch {
+              return null;
+            }
+          })
+        );
+        const valid = fileContents.filter(Boolean);
+        if (valid.length === 0) return;
+        const filesBlock = valid.map(
+          (f) => `### ${f.path}
+\`\`\`
+${f.content}
+\`\`\``
+        ).join("\n\n");
+        let goalsSection = "";
+        if (hasGoals) {
+          goalsSection = `
+USER-DEFINED GOALS (IMPORTANT - check EVERY file against ALL goals):
+${activeGoals.map((g, i) => `  ${i + 1}. "${g.description}"`).join("\n")}
+
+Goal violations are HIGH PRIORITY. If a file violates any goal, you MUST report it.
+`;
+        }
+        console.debug("[AI Watcher] Sending files to AI analysis:", {
+          fileCount: valid.length,
+          hasGoals,
+          goalsIncluded: hasGoals,
+          filePaths: valid.map((f) => f.path),
+          goalsSection: goalsSection.slice(0, 200) + (goalsSection.length > 200 ? "..." : "")
+        });
+        const result = await runAIAnalysis({
+          systemPrompt: `You are a code quality watcher. You review code for two things:
+
+1. CODE ISSUES: bugs, security vulnerabilities, logic errors, risky patterns
+2. GOAL VIOLATIONS: check every file against the user's quality goals
+${goalsSection}
+Reply ONLY with a JSON array. Each element must have:
+- "file": relative file path
+- "severity": "critical" | "major" | "minor"
+- "description": 1-sentence description of what you found
+- "confidence": number 0-100, how confident you are this is a real issue
+- "suggestedFix": 1-sentence description of what should change to fix it
+- "isGoalViolation": true if this violates a user goal, false otherwise
+- "goalIndex": 0-based index of the violated goal (only if isGoalViolation is true)
+
+Be thorough with goal checking. If a goal says "no emojis" and you see an emoji anywhere in the file, report it with the exact location. If a goal says "no inline styles" and you see a style attribute, report it.
+
+If no issues or violations found, reply with: []
+Output ONLY the JSON array, no markdown fences, no commentary.`,
+          userPrompt: `Review these changed files:
+
+${filesBlock}`,
+          maxTokens: 2048,
+          temperature: 0.1
+        });
+        if (result.tokensUsed) {
+          this.recordTokenUsage(result.tokensUsed.input + result.tokensUsed.output);
+        }
+        console.debug("[AI Watcher] AI analysis result:", {
+          success: result.success,
+          contentLength: result.content ? result.content.length : 0,
+          tokensUsed: result.tokensUsed,
+          contentPreview: result.content ? result.content.slice(0, 500) : "null"
+        });
+        if (!result.success || !result.content.trim()) {
+          console.debug("[AI Watcher] AI analysis failed or returned empty content");
+          return;
+        }
+        let issues = [];
+        try {
+          const cleaned = result.content.replace(/```json?\n?|\n?```/g, "").trim();
+          console.debug("[AI Watcher] Parsing AI response:", { cleanedContent: cleaned.slice(0, 300) });
+          issues = JSON.parse(cleaned);
+          if (!Array.isArray(issues)) issues = [];
+          console.debug("[AI Watcher] Parsed issues:", {
+            totalIssues: issues.length,
+            goalViolations: issues.filter((i) => i.isGoalViolation).length,
+            issueTypes: issues.map((i) => ({ file: i.file, isGoalViolation: i.isGoalViolation, goalIndex: i.goalIndex }))
+          });
+        } catch (error) {
+          console.debug("[AI Watcher] Failed to parse AI response:", error);
+          return;
+        }
+        const issuedFiles = new Set(issues.map((i) => i.file));
+        for (const { relativePath } of filesToScan) {
+          if (!issuedFiles.has(relativePath)) {
+            this.state.cleanFiles.set(relativePath, Date.now());
+          }
+        }
+        if (issues.length === 0) return;
+        for (const issue of issues.slice(0, 10)) {
+          const severity = issue.severity === "critical" ? "critical" : issue.severity === "major" ? "major" : "minor";
+          if (issue.isGoalViolation && issue.goalIndex != null && issue.goalIndex >= 0 && issue.goalIndex < activeGoals.length) {
+            const goal = activeGoals[issue.goalIndex];
+            if (!goal) continue;
+            const confidence = Math.min(100, Math.max(0, issue.confidence ?? 80));
+            const fixId = `fix-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            console.debug("[AI Watcher] Goal violation detected:", {
+              goalDescription: goal.description,
+              file: issue.file,
+              violation: issue.description,
+              confidence,
+              goalIndex: issue.goalIndex,
+              totalActiveGoals: activeGoals.length
+            });
+            const goalViolationIssue = {
+              id: fixId,
+              file: issue.file,
+              agent: "goal-violation",
+              severity: severity === "critical" ? "critical" : severity === "major" ? "serious" : "moderate",
+              issue: `Goal "${goal.description}" violated: ${issue.description}`,
+              fix: issue.suggestedFix || "Review and fix",
+              category: "goal-violation",
+              confidence,
+              autoFixable: true
+            };
+            await storeIssues([goalViolationIssue], basename(projectPath), projectPath);
+            await recordGoalViolationCaught(goal, issue.file, projectPath);
+            if (this.streamingManager) {
+              this.streamingManager.reportLedgerUpdate(1, "goal-violation");
+            }
+            const confidenceStr = `${confidence}%`;
+            const nudgeMsg = `Goal "${goal.description}" violated in ${issue.file}: ${issue.description} [${confidenceStr} confidence]`;
+            console.debug("[AI Watcher] Sending nudge:", {
+              message: nudgeMsg,
+              file: issue.file,
+              severity: "warning"
+            });
+            getOutputManager().nudge(nudgeMsg, "warning", issue.file);
+            await this.persistNudge({
+              message: nudgeMsg,
+              severity: "warning",
+              file: issue.file,
+              category: "quality",
+              goalId: goal.id,
+              priority: 7,
+              suggestedAction: issue.suggestedFix || "Review and fix manually",
+              relatedIssues: [fixId]
+            });
+            if (this.streamingManager) {
+              this.streamingManager.reportPendingFix({
+                id: fixId,
+                file: issue.file,
+                description: issue.description,
+                goalDescription: goal.description,
+                confidence,
+                severity: issue.severity,
+                suggestedFix: issue.suggestedFix || "Remove the violating code"
+              });
+            }
+            if (!isInteractiveMode()) {
+              console.error(`   [!] Goal violation (${confidenceStr}): ${issue.description}`);
+              console.error(`       Fix: ${issue.suggestedFix || "Review and fix manually"}`);
+            }
+            continue;
+          }
+          const incident = await graph.addNode("incident", {
+            description: issue.description,
+            severity,
+            affectedUsers: null,
+            duration: null,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            resolved: false,
+            resolution: null,
+            fixChangeId: null,
+            reportedVia: "detected"
+          });
+          const filePath = join4(projectPath, issue.file);
+          const fileNode = await graph.getNode("file", filePath);
+          if (fileNode) {
+            await graph.addEdge(fileNode.id, incident.id, "affects");
+            const data = fileNode.data;
+            const newRisk = severity === "critical" ? "critical" : severity === "major" ? "high" : data.riskLevel === "low" ? "medium" : data.riskLevel;
+            await graph.updateNode("file", fileNode.id, {
+              incidentCount: (data.incidentCount ?? 0) + 1,
+              riskLevel: newRisk
+            });
+          }
+          this.state.totalIssuesFound++;
+          if (severity !== "minor") {
+            getOutputManager().nudge(
+              `${issue.description}`,
+              severity === "critical" ? "critical" : "warning",
+              issue.file,
+              severity === "critical" ? void 0 : 15e3
+            );
+            await this.persistNudge({
+              message: issue.description,
+              severity: severity === "critical" ? "critical" : "warning",
+              file: issue.file,
+              category: "quality",
+              priority: severity === "critical" ? 9 : 6,
+              ...issue.suggestedFix && { suggestedAction: issue.suggestedFix }
+            });
+          }
+        }
+        if (this.streamingManager && issues.length > 0) {
+          this.streamingManager.reportSignalExtraction({
+            governance: 0,
+            facts: 0,
+            blockers: issues.length,
+            questions: 0
+          });
+        }
+      } catch (error) {
+        getOutputManager().log("warn", `AI watcher error: ${error}`);
+      }
+    } finally {
+      this.state.autoScanInProgress = false;
+    }
+  }
+  /**
+   * Initial hypothesis generation when watch starts.
+   *
+   * This generates hypotheses from existing patterns and issues to give
+   * users immediate insights about their codebase.
+   */
+  async initialHypothesisGeneration() {
+    if (!isAIAvailable()) {
+      console.debug("[Initial Hypothesis] AI not available, skipping initial hypothesis generation");
+      return;
+    }
+    const projectPath = this.watchedDirectory || getWorkingDirectory(void 0, true);
+    console.debug("[Initial Hypothesis] Starting initial hypothesis generation", { projectPath });
+    try {
+      const { getHypothesisEngine } = await import("./hypothesis-JURDWVDC.js");
+      const hypothesisEngine = getHypothesisEngine(projectPath);
+      console.debug("[Initial Hypothesis] Running AI-powered hypothesis generation...");
+      const generated = await hypothesisEngine.generateHypothesesWithAI({
+        recentIssues: [],
+        // No recent issues yet on startup
+        patterns: [],
+        observations: ["Initial watch session started", "Analyzing codebase for potential patterns"]
+      });
+      console.debug("[Initial Hypothesis] Generated hypotheses on startup:", {
+        count: generated.length,
+        hypotheses: generated.map((h) => ({ statement: h.statement, confidence: h.confidence }))
+      });
+      if (generated.length > 0) {
+        const { getOutputManager: getOutputManager2 } = await import("./output-manager-FX4V7ERT.js");
+        const outputManager = getOutputManager2();
+        for (const hypothesis of generated.slice(0, 2)) {
+          const message = `[Initial Hypothesis] "${hypothesis.statement}" (${Math.round(hypothesis.confidence * 100)}% confidence)`;
+          outputManager.nudge(message, "info", void 0, 1e4);
+          if (!isInteractiveMode()) {
+            console.error(`   [?] ${message}`);
+          }
+        }
+        if (this.streamingManager) {
+          this.streamingManager.reportSignalExtraction({
+            governance: 0,
+            facts: 0,
+            blockers: 0,
+            questions: generated.length
+          });
+        }
+      }
+    } catch (error) {
+      console.debug("[Initial Hypothesis] Failed to generate initial hypotheses:", error);
+    }
+  }
+  /**
+   * Initial goal compliance scan when watch starts.
+   * 
+   * This checks recently modified files against active goals so the user
+   * gets immediate feedback about goal violations without waiting for files
+   * to be changed.
+   * 
+   * Strategy:
+   * 1. Check if there are any active goals - if not, skip
+   * 2. Find recently modified files (last 24 hours OR uncommitted changes)
+   * 3. Filter to watched file types
+   * 4. Run a quick AI scan focused only on goal violations
+   * 5. Nudge the user about any violations found
+   */
+  async initialGoalComplianceScan() {
+    if (!isAIAvailable()) {
+      console.debug("[Initial Scan] AI not available, skipping initial goal compliance scan");
+      return;
+    }
+    const projectPath = this.watchedDirectory || getWorkingDirectory(void 0, true);
+    console.debug("[Initial Scan] Starting initial goal compliance scan", { projectPath });
+    try {
+      const { getActiveGoals, recordGoalViolationCaught } = await import("./goal-validator-FU5QWDQT.js");
+      const activeGoals = await getActiveGoals(projectPath);
+      console.debug("[Initial Scan] Loaded goals for initial scan:", {
+        goalCount: activeGoals.length,
+        goals: activeGoals.map((g) => ({ id: g.id, description: g.description }))
+      });
+      if (activeGoals.length === 0) {
+        console.debug("[Initial Scan] No active goals found, skipping initial scan");
+        return;
+      }
+      if (!isInteractiveMode()) {
+        console.error("[*] Checking recent files against active goals...");
+      }
+      const recentFiles = /* @__PURE__ */ new Set();
+      const uncommittedFiles = await getGitChangedFiles(projectPath);
+      if (uncommittedFiles) {
+        uncommittedFiles.forEach((f) => recentFiles.add(join4(projectPath, f)));
+      }
+      const oneDayAgo = Date.now() - 24 * 60 * 60 * 1e3;
+      const recentChanges = await getChangedFilesSinceTimestamp(projectPath, oneDayAgo);
+      if (recentChanges) {
+        recentChanges.forEach((f) => recentFiles.add(f));
+      }
+      const filesToCheck = Array.from(recentFiles).filter((file) => {
+        const ext = extname3(file).toLowerCase();
+        return WATCH_EXTENSIONS.has(ext) && existsSync6(file);
+      });
+      console.debug("[Initial Scan] Files discovered for initial scan:", {
+        totalRecentFiles: recentFiles.size,
+        filteredFiles: filesToCheck.length,
+        filePaths: filesToCheck.slice(0, 5).map((f) => f.replace(projectPath + "/", "")),
+        // Show first 5
+        watchedExtensions: Array.from(WATCH_EXTENSIONS)
+      });
+      if (filesToCheck.length === 0) {
+        console.debug("[Initial Scan] No recent files found for initial scan");
+        return;
+      }
+      const maxInitialFiles = 10;
+      const filesToScan = filesToCheck.slice(0, maxInitialFiles);
+      if (!isInteractiveMode()) {
+        console.error(`   Scanning ${filesToScan.length} recent file(s) against ${activeGoals.length} goal(s)...`);
+      }
+      const maxCharsPerFile = 3e3;
+      const fileContents = await Promise.all(
+        filesToScan.map(async (file) => {
+          try {
+            const content = await readFile5(file, "utf-8");
+            const relativePath = file.replace(projectPath + "/", "");
+            return { path: relativePath, content: content.slice(0, maxCharsPerFile) };
+          } catch {
+            return null;
+          }
+        })
+      );
+      const valid = fileContents.filter(Boolean);
+      if (valid.length === 0) return;
+      const filesBlock = valid.map(
+        (f) => `### ${f.path}
+\`\`\`
+${f.content}
+\`\`\``
+      ).join("\n\n");
+      const goalsSection = `
+USER-DEFINED GOALS (check EVERY file against ALL goals):
+${activeGoals.map((g, i) => `  ${i + 1}. "${g.description}"`).join("\n")}
+
+This is an INITIAL SCAN at watch startup. Report ALL goal violations you find.
+`;
+      const result = await runAIAnalysis({
+        systemPrompt: `You are checking code for GOAL VIOLATIONS ONLY.
+${goalsSection}
+Reply ONLY with a JSON array. Each element must have:
+- "file": relative file path
+- "severity": "critical" | "major" | "minor"
+- "description": 1-sentence description of the goal violation
+- "confidence": number 0-100, how confident you are this is a violation
+- "suggestedFix": 1-sentence description of what should change
+- "isGoalViolation": true (always true for this scan)
+- "goalIndex": 0-based index of the violated goal
+
+Be thorough. If a goal says "no emojis" and you see ANY emoji in the file, report it. If a goal says "no console.log" and you see console.log, report it.
+
+If no violations found, reply with: []
+Output ONLY the JSON array, no markdown fences, no commentary.`,
+        userPrompt: `Check these files for goal violations:
+
+${filesBlock}`,
+        maxTokens: 2048,
+        temperature: 0.1
+      });
+      if (result.tokensUsed) {
+        this.recordTokenUsage(result.tokensUsed.input + result.tokensUsed.output);
+      }
+      if (!result.success || !result.content.trim()) return;
+      let issues = [];
+      try {
+        const parsed = JSON.parse(result.content.trim());
+        issues = Array.isArray(parsed) ? parsed : [];
+      } catch {
+        return;
+      }
+      const issuesToStore = [];
+      let violationsFound = 0;
+      for (const issue of issues) {
+        if (!issue.isGoalViolation || issue.confidence < 40) continue;
+        violationsFound++;
+        if (issue.goalIndex != null && issue.goalIndex >= 0 && issue.goalIndex < activeGoals.length) {
+          const goal = activeGoals[issue.goalIndex];
+          if (!goal) continue;
+          const fixId = `fix-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+          issuesToStore.push({
+            id: fixId,
+            file: issue.file,
+            agent: "goal-violation",
+            severity: issue.severity === "critical" ? "critical" : issue.severity === "major" ? "serious" : "moderate",
+            issue: `Goal "${goal.description}" violated: ${issue.description}`,
+            fix: issue.suggestedFix || "Review and fix",
+            category: "goal-violation",
+            confidence: issue.confidence,
+            autoFixable: true
+          });
+          await recordGoalViolationCaught(goal, issue.file, projectPath);
+          const confidenceStr = issue.confidence >= 80 ? "high" : issue.confidence >= 60 ? "medium" : "low";
+          const nudgeMsg = `Goal "${goal.description}" violated in ${issue.file}: ${issue.description} [${confidenceStr} confidence]`;
+          getOutputManager().nudge(nudgeMsg, "warning", issue.file);
+          await this.persistNudge({
+            message: nudgeMsg,
+            severity: "warning",
+            file: issue.file,
+            category: "quality",
+            goalId: goal.id,
+            priority: issue.confidence >= 80 ? 8 : issue.confidence >= 60 ? 6 : 4,
+            ...issue.suggestedFix && { suggestedAction: issue.suggestedFix }
+          });
+        }
+      }
+      if (issuesToStore.length > 0) {
+        await storeIssues(issuesToStore, basename(projectPath), projectPath);
+        if (this.streamingManager) {
+          this.streamingManager.reportLedgerUpdate(issuesToStore.length, "goal-violation");
+        }
+      }
+      if (!isInteractiveMode()) {
+        if (violationsFound > 0) {
+          console.error(`   [!] Found ${violationsFound} goal violation(s) in recent files`);
+        } else {
+          console.error(`   [\u2713] No goal violations found in recent files`);
+        }
+      }
+    } catch (error) {
+      if (!isInteractiveMode()) {
+        console.error(`   [!] Initial goal scan error: ${error}`);
+      }
+    }
+  }
+  async syncPipelineIntegrations() {
+    const projectPath = this.watchedDirectory || getWorkingDirectory(void 0, true);
+    try {
+      const config = await loadConfig();
+      const hasLinear = !!(config.apiKeys?.linear ?? process.env.LINEAR_API_KEY);
+      const hasGithub = !!(config.apiKeys?.github ?? process.env.GITHUB_TOKEN);
+      if (!hasLinear && !hasGithub) return;
+      const graph = new ContextGraph(projectPath);
+      if (hasLinear) {
+        try {
+          const { LinearIngester } = await import("./linear-ingester-NHFMKJBZ.js");
+          const ingester = new LinearIngester(projectPath, graph);
+          await ingester.syncTickets();
+          if (!isInteractiveMode()) {
+            console.error("[Pipeline] Linear tickets synced");
+          }
+        } catch (error) {
+          if (!isInteractiveMode()) {
+            console.error(`[Pipeline] Linear sync failed: ${error}`);
+          }
+        }
+      }
+      if (hasGithub) {
+        try {
+          const { GitHubIngester } = await import("./github-ingester-AR5A4RAC.js");
+          const ingester = new GitHubIngester(graph);
+          const token = await ingester.getApiToken();
+          const repoInfo = ingester.getRepoInfo(projectPath);
+          if (repoInfo) {
+            await ingester.syncPullRequests(repoInfo.owner, repoInfo.name, token);
+            await ingester.syncIssues(repoInfo.owner, repoInfo.name, token);
+            if (!isInteractiveMode()) {
+              console.error("[Pipeline] GitHub PRs/issues synced");
+            }
+          }
+        } catch (error) {
+          if (!isInteractiveMode()) {
+            console.error(`[Pipeline] GitHub sync failed: ${error}`);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  async stopWatching() {
+    if (!this.state.isRunning) {
+      return {
+        content: [{
+          type: "text",
+          text: "[!] Watch mode is not running."
+        }]
+      };
+    }
+    for (const watcher of this.watchers.values()) {
+      watcher.close();
+    }
+    this.watchers.clear();
+    if (this.extractionPipeline) {
+      this.extractionPipeline.close();
+      this.extractionPipeline = null;
+    }
+    if (this.pipelineSyncTimer) {
+      clearInterval(this.pipelineSyncTimer);
+      this.pipelineSyncTimer = null;
+    }
+    if (this.codebaseIndex) {
+      await this.codebaseIndex.save();
+      this.codebaseIndex = null;
+    }
+    if (this.state.scanDebounceTimer) {
+      clearTimeout(this.state.scanDebounceTimer);
+    }
+    this.state.isRunning = false;
+    if (!isInteractiveMode()) {
+      console.error("\n[*] Watch mode stopped.\n");
+    }
+    if (this.streamingManager) {
+      this.streamingManager.reportWatchStatus({ watching: false, directories: 0 });
+    }
+    const outputManager = getOutputManager();
+    outputManager.clearTUICallbacks();
+    outputManager.setMode("console");
+    if (this.dashboard) {
+      this.dashboard.stop();
+      this.dashboard = void 0;
+    }
+    const budget = this.state.tokenBudget;
+    const tokensK = (budget.used / 1e3).toFixed(1);
+    return {
+      content: [{
+        type: "text",
+        text: `[*] **TRIE AGENT STOPPED**
+
+### Session Summary:
+- Files scanned: ${this.state.filesScanned}
+- Issues found: ${this.state.totalIssuesFound}
+- Tokens used: ${tokensK}k / ${(budget.hourlyLimit / 1e3).toFixed(0)}k hourly limit
+- Scans skipped (trie-throttled): ${budget.scansSaved}
+- Governance ledger: Updated continuously
+
+Use \`trie_watch start\` to resume.`
+      }]
+    };
+  }
+  async getStatus() {
+    if (!this.state.isRunning) {
+      return {
+        content: [{
+          type: "text",
+          text: `[*] **Watch Mode Status: STOPPED**
+
+Use \`trie_watch start\` to begin autonomous scanning.`
+        }]
+      };
+    }
+    const recentScans = Array.from(this.state.lastScan.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([file, time]) => {
+      const ago = Math.round((Date.now() - time) / 1e3);
+      return `- \`${basename(file)}\` (${ago}s ago)`;
+    }).join("\n");
+    const recentNudges = this.state.nudges.slice(-3).map(
+      (n) => `- ${basename(n.file)} [${n.severity}] @ ${n.timestamp}`
+    ).join("\n");
+    let agencyStatus = "";
+    try {
+      const { getTrieAgent: getTrieAgent2 } = await import("./trie-agent-TLOJ2UFS.js");
+      const trieAgent = getTrieAgent2(this.watchedDirectory || getWorkingDirectory(void 0, true));
+      await trieAgent.initialize();
+      const status = await trieAgent.getAgencyStatus();
+      agencyStatus = `
+### [AI] Trie Agent:
+- **Goals:** ${status.goals.active} active, ${status.goals.completed} completed${status.goals.topGoal ? ` (${status.goals.topGoal.slice(0, 40)}...)` : ""}
+- **Hypotheses:** ${status.hypotheses.testing} testing, ${status.hypotheses.validated} validated
+- **Risk Level:** ${status.riskLevel.toUpperCase()}
+- **Effectiveness:** ${status.effectiveness}%
+- **Scan Frequency:** ${Math.round(status.scanFrequency / 1e3)}s${status.isQuietHours ? " (quiet hours)" : ""}`;
+    } catch {
+    }
+    const budget = this.state.tokenBudget;
+    const remaining = this.getRemainingBudget();
+    const tokensK = (budget.used / 1e3).toFixed(1);
+    const remainingK = (remaining / 1e3).toFixed(1);
+    return {
+      content: [{
+        type: "text",
+        text: `[*] **WATCH MODE Status: RUNNING**
+
+### Stats:
+- Directories watched: ${this.watchers.size}
+- Files scanned: ${this.state.filesScanned}
+- Issues found: ${this.state.totalIssuesFound}
+- Pending: ${this.state.pendingFiles.size}
+
+### Token Budget:
+- Used: ${tokensK}k / ${(budget.hourlyLimit / 1e3).toFixed(0)}k hourly
+- Remaining: ${remainingK}k
+- Scans skipped (trie-throttled): ${budget.scansSaved}
+${agencyStatus}
+
+### Recently Scanned:
+${recentScans || "(none yet)"}
+
+### Recent Nudges:
+${recentNudges || "(none)"}
+
+### Commands:
+- \`trie_watch issues\` - Get all issues found
+- \`trie_watch stop\` - Stop watching`
+      }]
+    };
+  }
+  /**
+   * Helper to persist a nudge to both in-memory state and SQL storage
+   */
+  async persistNudge(params) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const nudgeId = createHash2("sha256").update(`${params.message}|${params.file || ""}|${timestamp}`).digest("hex").slice(0, 16);
+    const nudge = {
+      id: nudgeId,
+      message: params.message,
+      severity: params.severity,
+      timestamp,
+      resolved: false,
+      dismissed: false,
+      priority: params.priority ?? 5,
+      relatedIssues: params.relatedIssues ?? [],
+      metadata: {},
+      ...params.file && { file: params.file },
+      ...params.category && { category: params.category },
+      ...params.goalId && { goalId: params.goalId },
+      ...params.suggestedAction && { suggestedAction: params.suggestedAction }
+    };
+    this.state.nudges.push({
+      file: params.file || "unknown",
+      // Keep full path for consistency with loaded nudges
+      message: params.message,
+      severity: params.severity === "warning" || params.severity === "info" ? "high" : params.severity,
+      timestamp: (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false })
+    });
+    try {
+      const storage = getStorage(this.watchedDirectory);
+      await storage.storeNudge(nudge);
+      console.debug(`[Watch] \u2713 Persisted nudge to storage: ${nudge.message.slice(0, 60)}...`);
+    } catch (error) {
+      console.error("[Watch] Failed to persist nudge to storage:", error);
+    }
+  }
+  getNudges() {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `[#] Recent nudges (${this.state.nudges.length} this session)
+` + (this.state.nudges.length ? this.state.nudges.map(
+            (n) => `- ${basename(n.file)} [${n.severity}] @ ${n.timestamp}
+  ${n.message}`
+          ).join("\n") : "(none)")
+        },
+        {
+          type: "json",
+          json: this.state.nudges
+        }
+      ]
+    };
+  }
+  getCurrentIssues() {
+    return {
+      content: [{
+        type: "text",
+        text: `[L] **Issues Found This Session**
+
+Total issues: ${this.state.totalIssuesFound}
+Files scanned: ${this.state.filesScanned}
+
+To get a full report, run \`trie watch\` on your codebase.`
+      }]
+    };
+  }
+};
+
 export {
   getPrompt,
   getSystemPrompt,
@@ -9662,7 +11100,6 @@ export {
   TrieCloudFixTool,
   TrieExplainTool,
   StreamingManager,
-  ExtractionPipeline,
   TrieTellTool,
   TrieFeedbackTool,
   TrieCheckTool,
@@ -9675,6 +11112,7 @@ export {
   handleCheckpointTool,
   TriePipelineTool,
   GitHubBranchesTool,
-  InteractiveDashboard
+  InteractiveDashboard,
+  TrieWatchTool
 };
-//# sourceMappingURL=chunk-SU3WCAC4.js.map
+//# sourceMappingURL=chunk-BUA5PQJY.js.map