@triedotdev/mcp 1.0.140 → 1.0.142

package/dist/cli/main.js

@@ -21,7 +21,7 @@ import {
   isTrieInitialized,
   perceiveCurrentChanges,
   reasonAboutChangesHumanReadable
-} from "../chunk-GXF6JOCN.js";
+} from "../chunk-4PAAGLKO.js";
 import {
   loadConfig,
   saveConfig
@@ -32,22 +32,36 @@ import {
 import "../chunk-ZV2K6M7T.js";
 import {
   GotchaPredictor,
+  SlackIntegration,
   findCrossProjectPatterns,
   getGlobalMemoryStats,
   listTrackedProjects,
   searchGlobalPatterns,
   updateGlobalMemoryMd
-} from "../chunk-UOSTOLU7.js";
+} from "../chunk-WMDFK7LI.js";
 import {
   ContextGraph
 } from "../chunk-FH335WL5.js";
 import {
   measureInitialGoalValue
-} from "../chunk-75ADWWUF.js";
+} from "../chunk-T6PS3MXJ.js";
 import "../chunk-FPEMP54L.js";
 import {
   getProjectState
 } from "../chunk-LT6VUZG2.js";
+import "../chunk-F4NJ4CBP.js";
+import "../chunk-IXO4G4D3.js";
+import "../chunk-6NLHFIYA.js";
+import {
+  getStorage
+} from "../chunk-FG467PDD.js";
+import {
+  getAutonomyConfig,
+  recordBypass,
+  shouldAutoFix,
+  shouldBlockPush,
+  trackIssueOccurrence
+} from "../chunk-5KJ4UJOY.js";
 import {
   compressOldBlocks,
   deleteAllBlocks,
@@ -78,19 +92,6 @@ import {
 } from "../chunk-62POBLFC.js";
 import "../chunk-4MJ52WBH.js";
 import "../chunk-43X6JBEM.js";
-import "../chunk-F4NJ4CBP.js";
-import "../chunk-IXO4G4D3.js";
-import "../chunk-6NLHFIYA.js";
-import {
-  getStorage
-} from "../chunk-FG467PDD.js";
-import {
-  getAutonomyConfig,
-  recordBypass,
-  shouldAutoFix,
-  shouldBlockPush,
-  trackIssueOccurrence
-} from "../chunk-5KJ4UJOY.js";
 import {
   getTrieDirectory,
   getWorkingDirectory
@@ -101,10 +102,10 @@ import {
 } from "../chunk-DGUM43GV.js";
 
 // src/cli/main.ts
-import { resolve, join as join4, dirname } from "path";
-import { readFileSync, realpathSync } from "fs";
-import { fileURLToPath } from "url";
-import pc8 from "picocolors";
+import { resolve as resolve2, join as join5, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync2, realpathSync } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import pc9 from "picocolors";
 
 // src/hooks/install.ts
 import fs from "fs";
@@ -879,18 +880,371 @@ function collectIssuesForBlocking(reasoning) {
   return issues;
 }
 
+// src/cli/hooks.ts
+import { writeFile, mkdir, chmod } from "fs/promises";
+import { join } from "path";
+import { existsSync } from "fs";
+import pc2 from "picocolors";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+async function installGitHooks2() {
+  const workDir = getWorkingDirectory(void 0, true);
+  const isRepo = await isGitRepo(workDir);
+  if (!isRepo) {
+    console.log(pc2.yellow("\u26A0 Not a git repository. Git hooks not installed."));
+    return;
+  }
+  const hooksDir = join(workDir, ".git", "hooks");
+  if (!existsSync(hooksDir)) {
+    await mkdir(hooksDir, { recursive: true });
+  }
+  const prePushHook = `#!/bin/sh
+# Auto-sync ledger to shared storage before push
+
+# Only run if trie is initialized
+if [ ! -d ".trie" ]; then
+  exit 0
+fi
+
+# Check if trie command is available
+if ! command -v trie >/dev/null 2>&1; then
+  echo "Warning: trie command not found, skipping ledger sync"
+  exit 0
+fi
+
+# Sync ledger to shared storage
+echo "Syncing ledger to shared storage..."
+trie sync push 2>/dev/null || true
+
+exit 0
+`;
+  const postMergeHook = `#!/bin/sh
+# Auto-sync ledger from shared storage after merge
+
+# Only run if trie is initialized
+if [ ! -d ".trie" ]; then
+  exit 0
+fi
+
+# Check if trie command is available
+if ! command -v trie >/dev/null 2>&1; then
+  exit 0
+fi
+
+# Sync ledger from shared storage
+echo "Syncing ledger from shared storage..."
+trie sync pull 2>/dev/null || true
+
+exit 0
+`;
+  const prePushPath = join(hooksDir, "pre-push");
+  const postMergePath = join(hooksDir, "post-merge");
+  await writeFile(prePushPath, prePushHook);
+  await writeFile(postMergePath, postMergeHook);
+  await chmod(prePushPath, 493);
+  await chmod(postMergePath, 493);
+  console.log(pc2.green("\u2713 Git hooks installed successfully"));
+  console.log(pc2.dim("  pre-push: Syncs ledger to shared storage"));
+  console.log(pc2.dim("  post-merge: Syncs ledger from shared storage"));
+}
+async function checkGitHooks() {
+  const workDir = getWorkingDirectory(void 0, true);
+  const isRepo = await isGitRepo(workDir);
+  if (!isRepo) {
+    return {
+      isGitRepo: false,
+      prePushInstalled: false,
+      postMergeInstalled: false
+    };
+  }
+  const hooksDir = join(workDir, ".git", "hooks");
+  const prePushPath = join(hooksDir, "pre-push");
+  const postMergePath = join(hooksDir, "post-merge");
+  return {
+    isGitRepo: true,
+    prePushInstalled: existsSync(prePushPath),
+    postMergeInstalled: existsSync(postMergePath)
+  };
+}
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+async function handlePreCommitCommand(_args) {
+  console.log(pc2.cyan("\u{1F50D} Running pre-commit hook..."));
+  try {
+    const { spawn } = await import("child_process");
+    let daemonPath;
+    if (__filename2.endsWith(".ts")) {
+      daemonPath = resolve(__dirname2, "yolo-daemon.ts");
+    } else {
+      daemonPath = resolve(__dirname2, "yolo-daemon.js");
+    }
+    const daemonArgs = ["--once", "--staged-only", "--fail-on", "critical"];
+    const executor = daemonPath.endsWith(".ts") ? "npx" : "node";
+    const execArgs = daemonPath.endsWith(".ts") ? ["tsx", daemonPath, ...daemonArgs] : [daemonPath, ...daemonArgs];
+    const child = spawn(executor, execArgs, {
+      stdio: "inherit",
+      env: process.env
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        console.log(pc2.green("\u2713 Pre-commit hook completed successfully"));
+      } else {
+        console.log(pc2.red("\u2717 Pre-commit hook found critical issues"));
+        console.log(pc2.dim("  Commit blocked. Fix issues and try again."));
+      }
+      process.exit(code || 0);
+    });
+  } catch (error) {
+    console.error(pc2.red("Error in pre-commit hook:"), error);
+    process.exit(0);
+  }
+}
+async function handlePostCommitCommand(_args) {
+  console.log(pc2.cyan("\u{1F4DD} Running post-commit hook..."));
+  try {
+    const workDir = getWorkingDirectory(void 0, true);
+    const { spawn } = await import("child_process");
+    const updateProcess = spawn("node", [
+      "-e",
+      `
+      const { updateContextAfterCommit } = require('./context.js');
+      updateContextAfterCommit('${workDir}').catch(console.error);
+      `
+    ], {
+      stdio: "pipe",
+      env: process.env
+    });
+    updateProcess.on("close", (code) => {
+      if (code === 0) {
+        console.log(pc2.green("\u2713 Post-commit hook completed - context updated"));
+      } else {
+        console.log(pc2.yellow("\u26A0 Post-commit hook completed with warnings"));
+      }
+    });
+    updateProcess.unref();
+  } catch (error) {
+    console.error(pc2.yellow("Warning in post-commit hook:"), error);
+  }
+}
+
+// src/cli/setup.ts
+import pc3 from "picocolors";
+import { readFileSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+async function handleSetupCommand(args) {
+  const subcommand = args[0]?.toLowerCase();
+  if (subcommand === "slack") {
+    await setupSlackIntegration(args.slice(1));
+    return;
+  }
+  if (subcommand === "test-slack") {
+    await testSlackIntegration();
+    return;
+  }
+  showSetup();
+}
+async function setupSlackIntegration(args) {
+  const webhookUrl = args[0];
+  if (!webhookUrl) {
+    console.log(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                    Slack Integration Setup                       \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+
+STEP 1: Create a Slack Webhook
+${pc3.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}
+1. Go to https://api.slack.com/apps
+2. Click "Create New App" > "From scratch"
+3. Name your app (e.g. "Trie Security Bot")
+4. Choose your workspace
+5. Go to "Incoming Webhooks" in the sidebar
+6. Toggle "Activate Incoming Webhooks" to On
+7. Click "Add New Webhook to Workspace"
+8. Choose a channel (e.g. #security, #alerts)
+9. Copy the webhook URL
+
+STEP 2: Configure Trie
+${pc3.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}
+Run: trie setup slack <webhook-url> [channel]
+
+EXAMPLES:
+  trie setup slack https://hooks.slack.com/services/T.../B.../... #security
+  trie setup slack https://hooks.slack.com/services/T.../B.../...
+
+STEP 3: Test the Integration
+${pc3.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}
+Run: trie setup test-slack
+
+WHAT TRIE SENDS TO SLACK:
+\u2022 Decision extractions from incidents
+\u2022 Active blockers and risk predictions
+\u2022 Daily/weekly team summaries
+\u2022 Critical security findings
+\u2022 Auto-escalation notifications
+`);
+    return;
+  }
+  const channel = args[1];
+  try {
+    if (!webhookUrl.startsWith("https://hooks.slack.com/services/")) {
+      console.error(pc3.red("Error:"), "Invalid Slack webhook URL format");
+      console.error("Expected: https://hooks.slack.com/services/...");
+      process.exit(1);
+    }
+    const config = await loadConfig();
+    const updatedConfig = {
+      ...config,
+      integrations: {
+        ...config.integrations,
+        slack: {
+          enabled: true,
+          webhook: webhookUrl,
+          channel: channel || void 0
+        }
+      }
+    };
+    await saveConfig(updatedConfig);
+    console.log(pc3.green("\u2713"), "Slack integration configured successfully!");
+    if (channel) {
+      console.log(pc3.dim(`  Channel: ${channel}`));
+    }
+    console.log(pc3.dim(`  Webhook: ${webhookUrl.substring(0, 50)}...`));
+    console.log(`
+${pc3.bold("Next steps:")}
+1. Test the integration: ${pc3.cyan("trie setup test-slack")}
+2. Configure auto-escalation (optional):
+   ${pc3.dim("Add to .trie/config.json:")}
+   ${pc3.dim(`{
+     "autoEscalation": {
+       "enabled": true,
+       "webhookUrl": "${webhookUrl}",
+       "quietHours": { "start": "21:00", "end": "08:00" }
+     }
+   }`)}
+3. Notifications will be sent for:
+   \u2022 Critical security issues
+   \u2022 Team assignments and escalations
+   \u2022 Daily/weekly summaries
+`);
+  } catch (error) {
+    console.error(pc3.red("Error configuring Slack integration:"), error);
+    process.exit(1);
+  }
+}
+async function testSlackIntegration() {
+  try {
+    const config = await loadConfig();
+    if (!config.integrations?.slack?.enabled || !config.integrations.slack.webhook) {
+      console.error(pc3.red("Error:"), "Slack integration not configured");
+      console.error("Run:", pc3.cyan("trie setup slack <webhook-url>"));
+      process.exit(1);
+    }
+    console.log(pc3.cyan("\u{1F50D}"), "Testing Slack integration...");
+    const slack = new SlackIntegration({
+      webhookUrl: config.integrations.slack.webhook,
+      channel: config.integrations.slack.channel
+    });
+    const success = await slack.testConnection();
+    if (success) {
+      console.log(pc3.green("\u2713"), "Slack integration test successful!");
+      console.log(pc3.dim("  Check your Slack channel for the test message"));
+    } else {
+      console.log(pc3.red("\u2717"), "Slack integration test failed");
+      console.log(pc3.dim("  Check your webhook URL and network connection"));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(pc3.red("Error testing Slack integration:"), error);
+    process.exit(1);
+  }
+}
+function showSetup() {
+  const config = getCurrentConfig();
+  const hasSlack = config?.integrations?.slack?.enabled;
+  const hasGitHub = config?.apiKeys?.github;
+  const hasLinear = config?.apiKeys?.linear;
+  console.log(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                    Trie Agent Setup                              \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+
+STEP 1: API Keys
+${pc3.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}
+Trie can work offline, but performs best with these keys:
+
+1. ANTHROPIC_API_KEY (Required for AI analysis)
+   Get it: https://console.anthropic.com/
+
+2. LINEAR_API_KEY (Required for JIT defect prediction)
+   Get it: https://linear.app/settings/api
+
+3. GITHUB_TOKEN (Optional for GitHub integration)
+   Get it: https://github.com/settings/tokens
+
+Set them in your environment (~/.zshrc) or .trie/config.json:
+  export ANTHROPIC_API_KEY=sk-ant-...
+  export LINEAR_API_KEY=lin_api_...
+  export GITHUB_TOKEN=ghp_...
+
+STEP 2: Team Integrations
+${pc3.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}
+${hasSlack ? pc3.green("\u2713") : pc3.red("\u2717")} Slack: ${hasSlack ? "Configured" : "trie setup slack <webhook>"}
+${hasGitHub ? pc3.green("\u2713") : pc3.red("\u2717")} GitHub: ${hasGitHub ? "Configured" : "Set GITHUB_TOKEN"}
+${hasLinear ? pc3.green("\u2713") : pc3.red("\u2717")} Linear: ${hasLinear ? "Configured" : "Set LINEAR_API_KEY"}
+
+SLACK SETUP:
+  trie setup slack                    # Show Slack setup guide
+  trie setup slack <webhook> [channel] # Configure Slack webhook
+  trie setup test-slack              # Test Slack integration
+
+STEP 3: Configure for your AI tool
+${pc3.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}
+
+For CLAUDE CODE:
+  claude mcp add Trie -- npx @triedotdev/mcp
+
+For CURSOR (~/.cursor/mcp.json):
+{
+  "mcpServers": {
+    "Trie": {
+      "command": "npx",
+      "args": ["-y", "@triedotdev/mcp"],
+      "env": {
+        "ANTHROPIC_API_KEY": "your-key-here",
+        "LINEAR_API_KEY": "your-key-here"
+      }
+    }
+  }
+}
+
+STEP 4: Start scanning!
+${pc3.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}
+Ask your AI assistant: "Scan this with Trie" or "Use trie_scan"
+`);
+}
+function getCurrentConfig() {
+  try {
+    const configPath = join2(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
+    if (existsSync2(configPath)) {
+      return JSON.parse(readFileSync(configPath, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+
 // src/cli/auto-fix.ts
 import { readFile as readFile2 } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { createInterface } from "readline";
-import pc2 from "picocolors";
+import pc4 from "picocolors";
 
 // src/utils/auto-fix-apply.ts
-import { readFile, writeFile } from "fs/promises";
-import { existsSync } from "fs";
+import { readFile, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
 async function applyAutoFix(fix) {
   try {
-    if (!existsSync(fix.file)) {
+    if (!existsSync3(fix.file)) {
       return false;
     }
     const content = await readFile(fix.file, "utf-8");
@@ -913,7 +1267,7 @@ async function applyAutoFix(fix) {
     } else {
       return false;
     }
-    await writeFile(fix.file, newContent);
+    await writeFile2(fix.file, newContent);
     return true;
   } catch {
     return false;
@@ -968,34 +1322,34 @@ async function promptUser(question) {
     input: process.stdin,
     output: process.stderr
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve2(answer.toLowerCase().trim());
+      resolve3(answer.toLowerCase().trim());
     });
   });
 }
 function displayFixPreview(fix, index, total) {
   console.error("");
-  console.error(pc2.cyan(`\u2501\u2501\u2501 Fix ${index + 1}/${total} \u2501\u2501\u2501`));
-  console.error(pc2.dim(`File: ${fix.file}${fix.line ? `:${fix.line}` : ""}`));
-  console.error(pc2.dim(`Type: ${fix.type}`));
-  console.error(pc2.yellow(`Description: ${fix.description}`));
+  console.error(pc4.cyan(`\u2501\u2501\u2501 Fix ${index + 1}/${total} \u2501\u2501\u2501`));
+  console.error(pc4.dim(`File: ${fix.file}${fix.line ? `:${fix.line}` : ""}`));
+  console.error(pc4.dim(`Type: ${fix.type}`));
+  console.error(pc4.yellow(`Description: ${fix.description}`));
   console.error("");
   if (fix.original) {
-    console.error(pc2.red("- " + fix.original));
+    console.error(pc4.red("- " + fix.original));
   }
   if (fix.fixed) {
-    console.error(pc2.green("+ " + fix.fixed));
+    console.error(pc4.green("+ " + fix.fixed));
   } else if (fix.original) {
-    console.error(pc2.dim("  (line will be removed)"));
+    console.error(pc4.dim("  (line will be removed)"));
   }
   console.error("");
 }
 async function loadFixContent(fixes) {
   const enrichedFixes = [];
   for (const fix of fixes) {
-    if (!fix.line || !existsSync2(fix.file)) {
+    if (!fix.line || !existsSync4(fix.file)) {
       continue;
     }
     try {
@@ -1017,39 +1371,39 @@ async function handleAutoFixCommand(args, issues) {
   const projectPath = getWorkingDirectory(void 0, true);
   const config = await getAutonomyConfig(projectPath);
   if (!config.autoFix.enabled) {
-    console.error(pc2.yellow("Auto-fix is disabled in config."));
-    console.error(pc2.dim("Enable it with: trie config set autoFix.enabled true"));
+    console.error(pc4.yellow("Auto-fix is disabled in config."));
+    console.error(pc4.dim("Enable it with: trie config set autoFix.enabled true"));
     return;
   }
   const dryRun = args.includes("--dry-run");
   const skipConfirm = args.includes("--yes") || args.includes("-y");
   if (!issues || issues.length === 0) {
-    console.error(pc2.yellow("No issues provided. Run a scan first:"));
-    console.error(pc2.dim("  trie scan --fix"));
+    console.error(pc4.yellow("No issues provided. Run a scan first:"));
+    console.error(pc4.dim("  trie scan --fix"));
     return;
   }
   let fixes = detectAutoFixes(issues);
   if (fixes.length === 0) {
-    console.error(pc2.green("\u2713 No auto-fixable issues found."));
+    console.error(pc4.green("\u2713 No auto-fixable issues found."));
     return;
   }
   fixes = fixes.filter((fix) => shouldAutoFix(fix, config));
   if (fixes.length === 0) {
-    console.error(pc2.yellow("Found fixable issues but they are not in allowed categories."));
-    console.error(pc2.dim("Allowed categories: " + config.autoFix.categories.join(", ")));
+    console.error(pc4.yellow("Found fixable issues but they are not in allowed categories."));
+    console.error(pc4.dim("Allowed categories: " + config.autoFix.categories.join(", ")));
     return;
   }
   fixes = await loadFixContent(fixes);
   if (fixes.length === 0) {
-    console.error(pc2.yellow("Could not load fix content from files."));
+    console.error(pc4.yellow("Could not load fix content from files."));
     return;
   }
   console.error("");
-  console.error(pc2.cyan("\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(pc2.bold("Auto-Fix: Human-in-the-Loop"));
-  console.error(pc2.cyan("\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(pc4.cyan("\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(pc4.bold("Auto-Fix: Human-in-the-Loop"));
+  console.error(pc4.cyan("\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("");
-  console.error(`Found ${pc2.bold(fixes.length.toString())} auto-fixable issues:`);
+  console.error(`Found ${pc4.bold(fixes.length.toString())} auto-fixable issues:`);
   const byCategory = /* @__PURE__ */ new Map();
   for (const fix of fixes) {
     byCategory.set(fix.category, (byCategory.get(fix.category) || 0) + 1);
@@ -1059,7 +1413,7 @@ async function handleAutoFixCommand(args, issues) {
   }
   console.error("");
   if (dryRun) {
-    console.error(pc2.yellow("[DRY RUN] No changes will be made."));
+    console.error(pc4.yellow("[DRY RUN] No changes will be made."));
     console.error("");
     for (let i = 0; i < fixes.length; i++) {
       displayFixPreview(fixes[i], i, fixes.length);
@@ -1067,13 +1421,13 @@ async function handleAutoFixCommand(args, issues) {
     return;
   }
   if (config.autoFix.askFirst && !skipConfirm) {
-    console.error(pc2.yellow("Trie will ask before applying each fix."));
+    console.error(pc4.yellow("Trie will ask before applying each fix."));
     console.error("");
     const response = await promptUser(
       `Apply all ${fixes.length} fixes? (y)es / (n)o / (r)eview each: `
     );
     if (response === "n" || response === "no") {
-      console.error(pc2.dim("Cancelled."));
+      console.error(pc4.dim("Cancelled."));
       return;
     }
     if (response === "r" || response === "review") {
@@ -1084,54 +1438,54 @@ async function handleAutoFixCommand(args, issues) {
         displayFixPreview(fix, i, fixes.length);
         const answer = await promptUser("Apply this fix? (y/n/q): ");
         if (answer === "q" || answer === "quit") {
-          console.error(pc2.dim("Stopped."));
+          console.error(pc4.dim("Stopped."));
           break;
         }
         if (answer === "y" || answer === "yes") {
           const success = await applyAutoFix(fix);
           if (success) {
-            console.error(pc2.green(`\u2713 Applied fix to ${fix.file}:${fix.line}`));
+            console.error(pc4.green(`\u2713 Applied fix to ${fix.file}:${fix.line}`));
             applied2++;
           } else {
-            console.error(pc2.red(`\u2717 Failed to apply fix`));
+            console.error(pc4.red(`\u2717 Failed to apply fix`));
           }
         } else {
-          console.error(pc2.dim("Skipped."));
+          console.error(pc4.dim("Skipped."));
           skipped++;
         }
       }
       console.error("");
-      console.error(pc2.cyan("\u2501\u2501\u2501 Summary \u2501\u2501\u2501"));
-      console.error(`Applied: ${pc2.green(applied2.toString())}`);
-      console.error(`Skipped: ${pc2.dim(skipped.toString())}`);
+      console.error(pc4.cyan("\u2501\u2501\u2501 Summary \u2501\u2501\u2501"));
+      console.error(`Applied: ${pc4.green(applied2.toString())}`);
+      console.error(`Skipped: ${pc4.dim(skipped.toString())}`);
       return;
     }
   }
   console.error("");
-  console.error(pc2.cyan("Applying fixes..."));
+  console.error(pc4.cyan("Applying fixes..."));
   console.error("");
   let applied = 0;
   let failed = 0;
   for (const fix of fixes) {
     const success = await applyAutoFix(fix);
     if (success) {
-      console.error(pc2.green(`\u2713 Applied fix to ${fix.file}:${fix.line}`));
+      console.error(pc4.green(`\u2713 Applied fix to ${fix.file}:${fix.line}`));
       applied++;
     } else {
-      console.error(pc2.red(`\u2717 Failed to apply fix to ${fix.file}:${fix.line}`));
+      console.error(pc4.red(`\u2717 Failed to apply fix to ${fix.file}:${fix.line}`));
       failed++;
     }
   }
   console.error("");
-  console.error(pc2.cyan("\u2501\u2501\u2501 Complete \u2501\u2501\u2501"));
-  console.error(`Applied: ${pc2.green(applied.toString())}`);
+  console.error(pc4.cyan("\u2501\u2501\u2501 Complete \u2501\u2501\u2501"));
+  console.error(`Applied: ${pc4.green(applied.toString())}`);
   if (failed > 0) {
-    console.error(`Failed: ${pc2.red(failed.toString())}`);
+    console.error(`Failed: ${pc4.red(failed.toString())}`);
   }
 }
 
 // src/cli/goal.ts
-import pc3 from "picocolors";
+import pc5 from "picocolors";
 async function handleGoalCommand(args) {
   const projectPath = getWorkingDirectory(void 0, true);
   const projectState = getProjectState(projectPath);
@@ -1166,8 +1520,8 @@ async function handleGoalCommand(args) {
 async function addGoal(projectState, args) {
   const description = args.join(" ").replace(/^["']|["']$/g, "");
   if (!description) {
-    console.error(pc3.red("Please provide a goal description."));
-    console.error(pc3.dim('Example: trie goal add "Reduce auth issues by 50%"'));
+    console.error(pc5.red("Please provide a goal description."));
+    console.error(pc5.dim('Example: trie goal add "Reduce auth issues by 50%"'));
     return;
   }
   const categoryMatch = description.match(/--category[=\s](\w+)/);
@@ -1224,51 +1578,51 @@ async function addGoal(projectState, args) {
   };
   await projectState.addGoal(goal);
   console.error("");
-  console.error(pc3.green("\u2713 Goal created"));
+  console.error(pc5.green("\u2713 Goal created"));
   console.error("");
-  console.error(pc3.bold(cleanDesc));
-  console.error(pc3.dim(`ID: ${goal.id}`));
-  console.error(pc3.dim(`Type: ${goalType} | Target: ${target} | Category: ${category}`));
+  console.error(pc5.bold(cleanDesc));
+  console.error(pc5.dim(`ID: ${goal.id}`));
+  console.error(pc5.dim(`Type: ${goalType} | Target: ${target} | Category: ${category}`));
   if (initialValue > 0) {
-    console.error(pc3.dim(`Starting value: ${initialValue} issues found`));
+    console.error(pc5.dim(`Starting value: ${initialValue} issues found`));
   }
-  console.error(pc3.dim(`Deadline: ${deadline.toLocaleDateString()}`));
+  console.error(pc5.dim(`Deadline: ${deadline.toLocaleDateString()}`));
   console.error("");
-  console.error(pc3.cyan("Progress will be tracked and you'll be notified when you achieve it!"));
+  console.error(pc5.cyan("Progress will be tracked and you'll be notified when you achieve it!"));
 }
 async function listGoals(projectState) {
   const goals = projectState.getAllGoals();
   if (goals.length === 0) {
-    console.error(pc3.dim("No goals yet."));
-    console.error(pc3.dim('Create one: trie goal add "Reduce auth issues by 50%"'));
+    console.error(pc5.dim("No goals yet."));
+    console.error(pc5.dim('Create one: trie goal add "Reduce auth issues by 50%"'));
     return;
   }
   console.error("");
-  console.error(pc3.bold("Goals"));
+  console.error(pc5.bold("Goals"));
   console.error("");
   const active = goals.filter((g) => g.status === "active");
   const achieved = goals.filter((g) => g.status === "achieved");
   const other = goals.filter((g) => g.status !== "active" && g.status !== "achieved");
   if (active.length > 0) {
-    console.error(pc3.cyan("Active:"));
+    console.error(pc5.cyan("Active:"));
     for (const goal of active) {
       const progress = calculateGoalProgress(goal);
       const bar = renderProgressBar(progress);
-      const source = goal.autoGenerated ? pc3.dim("[auto]") : pc3.dim("[manual]");
+      const source = goal.autoGenerated ? pc5.dim("[auto]") : pc5.dim("[manual]");
       console.error(`  ${bar} ${goal.description} ${source}`);
-      console.error(pc3.dim(`     ID: ${goal.id} | ${progress}% complete`));
+      console.error(pc5.dim(`     ID: ${goal.id} | ${progress}% complete`));
     }
     console.error("");
   }
   if (achieved.length > 0) {
-    console.error(pc3.green("Achieved:"));
+    console.error(pc5.green("Achieved:"));
     for (const goal of achieved) {
       console.error(`  [+] ${goal.description}`);
     }
     console.error("");
   }
   if (other.length > 0) {
-    console.error(pc3.dim("Other:"));
+    console.error(pc5.dim("Other:"));
     for (const goal of other) {
       const icon = goal.status === "failed" ? "[X]" : goal.status === "paused" ? "[P]" : "\u2022";
       console.error(`  ${icon} ${goal.description} (${goal.status})`);
@@ -1277,14 +1631,14 @@ async function listGoals(projectState) {
 }
 async function completeGoal(projectState, goalId) {
   if (!goalId) {
-    console.error(pc3.red("Please provide a goal ID."));
-    console.error(pc3.dim('Run "trie goal list" to see IDs.'));
+    console.error(pc5.red("Please provide a goal ID."));
+    console.error(pc5.dim('Run "trie goal list" to see IDs.'));
     return;
   }
   const goals = projectState.getAllGoals();
   const goal = goals.find((g) => g.id === goalId || g.id.startsWith(goalId));
   if (!goal) {
-    console.error(pc3.red(`Goal not found: ${goalId}`));
+    console.error(pc5.red(`Goal not found: ${goalId}`));
     return;
   }
   await projectState.updateGoal(goal.id, {
@@ -1293,23 +1647,23 @@ async function completeGoal(projectState, goalId) {
     achievedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   console.error("");
-  console.error(pc3.green("Goal achieved!"));
-  console.error(pc3.bold(goal.description));
+  console.error(pc5.green("Goal achieved!"));
+  console.error(pc5.bold(goal.description));
   console.error("");
 }
 async function deleteGoal(projectState, goalId) {
   if (!goalId) {
-    console.error(pc3.red("Please provide a goal ID."));
+    console.error(pc5.red("Please provide a goal ID."));
     return;
   }
   const goals = projectState.getAllGoals();
   const goal = goals.find((g) => g.id === goalId || g.id.startsWith(goalId));
   if (!goal) {
-    console.error(pc3.red(`Goal not found: ${goalId}`));
+    console.error(pc5.red(`Goal not found: ${goalId}`));
     return;
   }
   await projectState.updateGoal(goal.id, { status: "rejected" });
-  console.error(pc3.dim(`Removed goal: ${goal.description}`));
+  console.error(pc5.dim(`Removed goal: ${goal.description}`));
 }
 function calculateGoalProgress(goal) {
   if (goal.target <= 0) return 0;
@@ -1327,7 +1681,7 @@ function renderProgressBar(percent) {
   const clamped = Math.max(0, Math.min(100, percent));
   const filled = Math.round(clamped / 100 * width);
   const empty = width - filled;
-  return `[${pc3.green("\u2588".repeat(filled))}${pc3.gray("\u2591".repeat(empty))}]`;
+  return `[${pc5.green("\u2588".repeat(filled))}${pc5.gray("\u2591".repeat(empty))}]`;
 }
 function detectCategory(description) {
   const lower = description.toLowerCase();
@@ -1339,20 +1693,20 @@ function detectCategory(description) {
 }
 function printGoalHelp() {
   console.error("");
-  console.error(pc3.bold("trie goal - Manage guardian goals"));
+  console.error(pc5.bold("trie goal - Manage guardian goals"));
   console.error("");
-  console.error(pc3.cyan("Usage:"));
+  console.error(pc5.cyan("Usage:"));
   console.error('  trie goal add "Reduce auth issues by 50%"');
   console.error("  trie goal list");
   console.error("  trie goal complete <id>");
   console.error("  trie goal delete <id>");
   console.error("");
-  console.error(pc3.cyan("Options for add:"));
+  console.error(pc5.cyan("Options for add:"));
   console.error("  --category=security|quality|performance|coverage|general");
   console.error("  --target=<number>");
   console.error("  --deadline=<days>");
   console.error("");
-  console.error(pc3.cyan("Examples:"));
+  console.error(pc5.cyan("Examples:"));
   console.error('  trie goal add "Eliminate all critical security issues"');
   console.error('  trie goal add "7 days streak of clean builds"');
   console.error('  trie goal add "Reduce test flakiness by 80%" --category=quality');
@@ -1394,8 +1748,8 @@ async function handleHypothesisCommand(args) {
 async function addHypothesis(projectState, args) {
   const statement = args.join(" ").replace(/^["']|["']$/g, "");
   if (!statement) {
-    console.error(pc3.red("Please provide a hypothesis statement."));
-    console.error(pc3.dim('Example: trie hypothesis add "Mondays have more bugs than Fridays"'));
+    console.error(pc5.red("Please provide a hypothesis statement."));
+    console.error(pc5.dim('Example: trie hypothesis add "Mondays have more bugs than Fridays"'));
     return;
   }
   const categoryMatch = statement.match(/--category[=\s](\w+)/);
@@ -1418,47 +1772,47 @@ async function addHypothesis(projectState, args) {
   };
   await projectState.addHypothesis(hypothesis);
   console.error("");
-  console.error(pc3.green("\u2713 Hypothesis created"));
+  console.error(pc5.green("\u2713 Hypothesis created"));
   console.error("");
-  console.error(pc3.bold(`"${cleanStatement}"`));
-  console.error(pc3.dim(`ID: ${hypothesis.id}`));
-  console.error(pc3.dim(`Status: testing | Confidence: untested | Category: ${category}`));
+  console.error(pc5.bold(`"${cleanStatement}"`));
+  console.error(pc5.dim(`ID: ${hypothesis.id}`));
+  console.error(pc5.dim(`Status: testing | Confidence: untested | Category: ${category}`));
   console.error("");
-  console.error(pc3.cyan("The agent will collect evidence and update confidence over time."));
-  console.error(pc3.dim(`Test criteria: ${testCriteria}`));
+  console.error(pc5.cyan("The agent will collect evidence and update confidence over time."));
+  console.error(pc5.dim(`Test criteria: ${testCriteria}`));
 }
 async function listHypotheses(projectState) {
   const hypotheses = projectState.getAllHypotheses();
   if (hypotheses.length === 0) {
-    console.error(pc3.dim("No hypotheses yet."));
-    console.error(pc3.dim('Create one: trie hypothesis add "Mondays have more bugs"'));
+    console.error(pc5.dim("No hypotheses yet."));
+    console.error(pc5.dim('Create one: trie hypothesis add "Mondays have more bugs"'));
     return;
   }
   console.error("");
-  console.error(pc3.bold("Hypotheses"));
+  console.error(pc5.bold("Hypotheses"));
   console.error("");
   const testing = hypotheses.filter((h) => h.status === "testing");
   const validated = hypotheses.filter((h) => h.status === "validated");
   const invalidated = hypotheses.filter((h) => h.status === "invalidated");
   if (testing.length > 0) {
-    console.error(pc3.cyan("Testing:"));
+    console.error(pc5.cyan("Testing:"));
     for (const hypo of testing) {
       const conf = Math.round(hypo.confidence * 100);
-      const confColor = conf >= 70 ? pc3.green : conf >= 40 ? pc3.yellow : pc3.red;
+      const confColor = conf >= 70 ? pc5.green : conf >= 40 ? pc5.yellow : pc5.red;
       console.error(`  [?] "${hypo.statement}" ${confColor(`(${conf}% confidence)`)}`);
-      console.error(pc3.dim(`     ID: ${hypo.id} | Evidence: ${hypo.evidence.length} points`));
+      console.error(pc5.dim(`     ID: ${hypo.id} | Evidence: ${hypo.evidence.length} points`));
     }
     console.error("");
   }
   if (validated.length > 0) {
-    console.error(pc3.green("Validated:"));
+    console.error(pc5.green("Validated:"));
     for (const hypo of validated) {
       console.error(`  [+] "${hypo.statement}" (${Math.round(hypo.confidence * 100)}%)`);
     }
     console.error("");
   }
   if (invalidated.length > 0) {
-    console.error(pc3.red("Invalidated:"));
+    console.error(pc5.red("Invalidated:"));
     for (const hypo of invalidated) {
       console.error(`  [X] "${hypo.statement}"`);
     }
@@ -1466,13 +1820,13 @@ async function listHypotheses(projectState) {
 }
 async function validateHypothesis(projectState, hypoId) {
   if (!hypoId) {
-    console.error(pc3.red("Please provide a hypothesis ID."));
+    console.error(pc5.red("Please provide a hypothesis ID."));
     return;
   }
   const hypotheses = projectState.getAllHypotheses();
   const hypo = hypotheses.find((h) => h.id === hypoId || h.id.startsWith(hypoId));
   if (!hypo) {
-    console.error(pc3.red(`Hypothesis not found: ${hypoId}`));
+    console.error(pc5.red(`Hypothesis not found: ${hypoId}`));
     return;
   }
   await projectState.updateHypothesis(hypo.id, {
@@ -1480,38 +1834,38 @@ async function validateHypothesis(projectState, hypoId) {
     confidence: 0.9,
     validatedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
-  console.error(pc3.green(`Hypothesis validated: "${hypo.statement}"`));
+  console.error(pc5.green(`Hypothesis validated: "${hypo.statement}"`));
 }
 async function invalidateHypothesis(projectState, hypoId) {
   if (!hypoId) {
-    console.error(pc3.red("Please provide a hypothesis ID."));
+    console.error(pc5.red("Please provide a hypothesis ID."));
     return;
   }
   const hypotheses = projectState.getAllHypotheses();
   const hypo = hypotheses.find((h) => h.id === hypoId || h.id.startsWith(hypoId));
   if (!hypo) {
-    console.error(pc3.red(`Hypothesis not found: ${hypoId}`));
+    console.error(pc5.red(`Hypothesis not found: ${hypoId}`));
     return;
   }
   await projectState.updateHypothesis(hypo.id, {
     status: "invalidated",
     confidence: 0.1
   });
-  console.error(pc3.red(`Hypothesis invalidated: "${hypo.statement}"`));
+  console.error(pc5.red(`Hypothesis invalidated: "${hypo.statement}"`));
 }
 async function deleteHypothesis(projectState, hypoId) {
   if (!hypoId) {
-    console.error(pc3.red("Please provide a hypothesis ID."));
+    console.error(pc5.red("Please provide a hypothesis ID."));
     return;
   }
   const hypotheses = projectState.getAllHypotheses();
   const hypo = hypotheses.find((h) => h.id === hypoId || h.id.startsWith(hypoId));
   if (!hypo) {
-    console.error(pc3.red(`Hypothesis not found: ${hypoId}`));
+    console.error(pc5.red(`Hypothesis not found: ${hypoId}`));
     return;
   }
   await projectState.updateHypothesis(hypo.id, { status: "retired" });
-  console.error(pc3.dim(`Removed hypothesis: "${hypo.statement}"`));
+  console.error(pc5.dim(`Removed hypothesis: "${hypo.statement}"`));
 }
 function detectHypothesisCategory(statement) {
   const lower = statement.toLowerCase();
@@ -1539,20 +1893,20 @@ function generateTestCriteria(statement) {
 }
 function printHypothesisHelp() {
   console.error("");
-  console.error(pc3.bold("trie hypothesis - Manage project hypotheses"));
+  console.error(pc5.bold("trie hypothesis - Manage project hypotheses"));
   console.error("");
-  console.error(pc3.cyan("Usage:"));
+  console.error(pc5.cyan("Usage:"));
   console.error('  trie hypothesis add "Mondays have more bugs than Fridays"');
   console.error("  trie hypothesis list");
   console.error("  trie hypothesis validate <id>");
   console.error("  trie hypothesis invalidate <id>");
   console.error("  trie hypothesis delete <id>");
   console.error("");
-  console.error(pc3.cyan("Options for add:"));
+  console.error(pc5.cyan("Options for add:"));
   console.error("  --category=timing|pattern|team|code|general");
   console.error('  --test="<test criteria>"');
   console.error("");
-  console.error(pc3.cyan("Examples:"));
+  console.error(pc5.cyan("Examples:"));
   console.error('  trie hypothesis add "Code reviews reduce bug rate"');
   console.error('  trie hypothesis add "Auth module has highest churn"');
   console.error('  trie hypothesis add "Deploy Fridays cause weekend incidents"');
@@ -1677,9 +2031,9 @@ async function handleQuietCommand() {
 }
 
 // src/cli/ci.ts
-import { writeFileSync, existsSync as existsSync3, mkdirSync } from "fs";
-import { join } from "path";
-import pc4 from "picocolors";
+import { writeFileSync, existsSync as existsSync5, mkdirSync } from "fs";
+import { join as join3 } from "path";
+import pc6 from "picocolors";
 var WORKFLOW_TEMPLATE = `# Trie Security Scan with Memory Persistence
 # Generated by: trie ci
 # 
@@ -1769,84 +2123,84 @@ jobs:
 `;
 function handleCISetupCommand(args) {
   const workDir = getWorkingDirectory(void 0, true);
-  const workflowsDir = join(workDir, ".github", "workflows");
-  const workflowPath = join(workflowsDir, "trie-scan.yml");
+  const workflowsDir = join3(workDir, ".github", "workflows");
+  const workflowPath = join3(workflowsDir, "trie-scan.yml");
   const isMinimal = args.includes("--minimal") || args.includes("-m");
   const isDryRun = args.includes("--dry-run") || args.includes("-n");
   const showHelp3 = args.includes("--help") || args.includes("-h");
   if (showHelp3) {
     console.log(`
-${pc4.bold("trie ci")} - Generate GitHub Actions workflow with memory caching
+${pc6.bold("trie ci")} - Generate GitHub Actions workflow with memory caching
 
-${pc4.bold("USAGE:")}
+${pc6.bold("USAGE:")}
   trie ci [options]
 
-${pc4.bold("OPTIONS:")}
+${pc6.bold("OPTIONS:")}
   --minimal, -m    Generate minimal workflow (simpler, fewer features)
   --dry-run, -n    Preview workflow without creating files
   --help, -h       Show this help
 
-${pc4.bold("WHAT IT DOES:")}
+${pc6.bold("WHAT IT DOES:")}
   Creates .github/workflows/trie-scan.yml that:
   
-  1. ${pc4.green("Caches Trie memory")} - Patterns and fixes persist across runs
-  2. ${pc4.green("Enables learning")} - Trie remembers issues from previous PRs
-  3. ${pc4.green("Tracks patterns")} - Detects recurring issues across your codebase
-  4. ${pc4.green("SARIF upload")} - Results appear in GitHub Security tab
+  1. ${pc6.green("Caches Trie memory")} - Patterns and fixes persist across runs
+  2. ${pc6.green("Enables learning")} - Trie remembers issues from previous PRs
+  3. ${pc6.green("Tracks patterns")} - Detects recurring issues across your codebase
+  4. ${pc6.green("SARIF upload")} - Results appear in GitHub Security tab
 
-${pc4.bold("MEMORY BENEFITS:")}
+${pc6.bold("MEMORY BENEFITS:")}
   \u2022 "This issue was introduced 3 PRs ago"
   \u2022 "Similar issue was fixed in PR #42"
   \u2022 "This pattern keeps recurring in auth code"
   \u2022 Trend tracking: improving, stable, or declining
 
-${pc4.bold("EXAMPLES:")}
+${pc6.bold("EXAMPLES:")}
   trie ci               # Generate full workflow
   trie ci --minimal     # Generate simple workflow
   trie ci --dry-run     # Preview without writing
 
-${pc4.bold("REQUIRED SECRETS:")}
+${pc6.bold("REQUIRED SECRETS:")}
   ANTHROPIC_API_KEY     Your Anthropic API key (add in GitHub repo settings)
 `);
     return;
   }
   const template = isMinimal ? WORKFLOW_MINIMAL : WORKFLOW_TEMPLATE;
   if (isDryRun) {
-    console.log(pc4.bold("\nWorkflow Preview:\n"));
-    console.log(pc4.dim("\u2500".repeat(60)));
+    console.log(pc6.bold("\nWorkflow Preview:\n"));
+    console.log(pc6.dim("\u2500".repeat(60)));
     console.log(template);
-    console.log(pc4.dim("\u2500".repeat(60)));
-    console.log(pc4.dim("\nRun without --dry-run to create the file."));
+    console.log(pc6.dim("\u2500".repeat(60)));
+    console.log(pc6.dim("\nRun without --dry-run to create the file."));
     return;
   }
-  if (existsSync3(workflowPath)) {
-    console.log(pc4.yellow("Workflow already exists: .github/workflows/trie-scan.yml"));
-    console.log(pc4.dim("   Run with --dry-run to preview what would be written."));
-    console.log(pc4.dim("   Delete the existing file to regenerate."));
+  if (existsSync5(workflowPath)) {
+    console.log(pc6.yellow("Workflow already exists: .github/workflows/trie-scan.yml"));
+    console.log(pc6.dim("   Run with --dry-run to preview what would be written."));
+    console.log(pc6.dim("   Delete the existing file to regenerate."));
     return;
   }
-  if (!existsSync3(workflowsDir)) {
+  if (!existsSync5(workflowsDir)) {
     mkdirSync(workflowsDir, { recursive: true });
   }
   writeFileSync(workflowPath, template);
-  console.log(pc4.green("\u2713") + " Created .github/workflows/trie-scan.yml");
+  console.log(pc6.green("\u2713") + " Created .github/workflows/trie-scan.yml");
   console.log("");
-  console.log(pc4.bold("Next steps:"));
+  console.log(pc6.bold("Next steps:"));
   console.log("");
   console.log("  1. Add your Anthropic API key to GitHub Secrets:");
-  console.log(pc4.dim("     Settings \u2192 Secrets \u2192 Actions \u2192 New repository secret"));
-  console.log(pc4.dim("     Name: ANTHROPIC_API_KEY"));
+  console.log(pc6.dim("     Settings \u2192 Secrets \u2192 Actions \u2192 New repository secret"));
+  console.log(pc6.dim("     Name: ANTHROPIC_API_KEY"));
   console.log("");
   console.log("  2. Commit and push:");
-  console.log(pc4.dim("     git add .github/workflows/trie-scan.yml"));
-  console.log(pc4.dim('     git commit -m "Add Trie security scan with memory"'));
-  console.log(pc4.dim("     git push"));
+  console.log(pc6.dim("     git add .github/workflows/trie-scan.yml"));
+  console.log(pc6.dim('     git commit -m "Add Trie security scan with memory"'));
+  console.log(pc6.dim("     git push"));
   console.log("");
-  console.log(pc4.bold("Memory caching benefits:"));
-  console.log(pc4.dim("  \u2022 Trie learns from past scans"));
-  console.log(pc4.dim("  \u2022 Tracks issue trends over time"));
-  console.log(pc4.dim("  \u2022 Remembers when issues were introduced"));
-  console.log(pc4.dim("  \u2022 Recognizes recurring patterns"));
+  console.log(pc6.bold("Memory caching benefits:"));
+  console.log(pc6.dim("  \u2022 Trie learns from past scans"));
+  console.log(pc6.dim("  \u2022 Tracks issue trends over time"));
+  console.log(pc6.dim("  \u2022 Remembers when issues were introduced"));
+  console.log(pc6.dim("  \u2022 Recognizes recurring patterns"));
 }
 
 // src/cli/audit.ts
@@ -2091,20 +2445,20 @@ async function handleLearnCommand(args) {
 }
 
 // src/cli/patterns.ts
-import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
 import { basename as basename2 } from "path";
 import picocolors3 from "picocolors";
 
 // src/patterns/saved-patterns.ts
 import { createHash } from "crypto";
-import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import { join as join2, basename } from "path";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { join as join4, basename } from "path";
 async function loadSavedPatterns(workDir) {
-  const patternsPath = join2(getTrieDirectory(workDir), "saved-patterns.json");
+  const patternsPath = join4(getTrieDirectory(workDir), "saved-patterns.json");
   try {
-    if (existsSync4(patternsPath)) {
+    if (existsSync6(patternsPath)) {
       const content = await readFile3(patternsPath, "utf-8");
       return JSON.parse(content);
     }
@@ -2114,9 +2468,9 @@ async function loadSavedPatterns(workDir) {
 }
 async function savePatternsToProject(patterns, workDir) {
   const { mkdir: mkdir2 } = await import("fs/promises");
-  const patternsPath = join2(getTrieDirectory(workDir), "saved-patterns.json");
+  const patternsPath = join4(getTrieDirectory(workDir), "saved-patterns.json");
   await mkdir2(getTrieDirectory(workDir), { recursive: true });
-  await writeFile2(patternsPath, JSON.stringify(patterns, null, 2));
+  await writeFile3(patternsPath, JSON.stringify(patterns, null, 2));
 }
 async function savePatternToProject(pattern, workDir) {
   const patterns = await loadSavedPatterns(workDir);
@@ -2151,8 +2505,8 @@ function detectPatternType(target, workDir) {
   if (scoutNames.includes(target.toLowerCase())) {
     return "detection-rule";
   }
-  const fullPath = join2(workDir, target);
-  if (existsSync4(fullPath) || target.includes("/") || target.includes("*") || target.endsWith(".ts") || target.endsWith(".js")) {
+  const fullPath = join4(workDir, target);
+  if (existsSync6(fullPath) || target.includes("/") || target.includes("*") || target.endsWith(".ts") || target.endsWith(".js")) {
     return "file-structure";
   }
   return "code-pattern";
@@ -2310,7 +2664,7 @@ async function handleExportPatterns(args, workDir) {
     exportedFrom: basename2(workDir),
     patterns
   };
-  await writeFile3(outputPath, JSON.stringify(exportData, null, 2));
+  await writeFile4(outputPath, JSON.stringify(exportData, null, 2));
   console.log(picocolors3.green(`\u2713 Exported ${patterns.length} patterns to ${outputPath}`));
   console.log(picocolors3.dim(`  Import to another project with: trie patterns import ${outputPath}`));
 }
@@ -2320,7 +2674,7 @@ async function handleImportPatterns(args, workDir) {
     console.error(picocolors3.red("Usage: trie patterns import <path-to-patterns.json>"));
     process.exit(1);
   }
-  if (!existsSync5(inputPath)) {
+  if (!existsSync7(inputPath)) {
     console.error(picocolors3.red(`File not found: ${inputPath}`));
     process.exit(1);
   }
@@ -2417,95 +2771,8 @@ ${picocolors3.dim("Patterns are saved in .trie/saved-patterns.json")}
 }
 
 // src/cli/sync.ts
-import pc6 from "picocolors";
+import pc7 from "picocolors";
 import { Command } from "commander";
-
-// src/cli/hooks.ts
-import { writeFile as writeFile4, mkdir, chmod } from "fs/promises";
-import { join as join3 } from "path";
-import { existsSync as existsSync6 } from "fs";
-import pc5 from "picocolors";
-async function installGitHooks2() {
-  const workDir = getWorkingDirectory(void 0, true);
-  const isRepo = await isGitRepo(workDir);
-  if (!isRepo) {
-    console.log(pc5.yellow("\u26A0 Not a git repository. Git hooks not installed."));
-    return;
-  }
-  const hooksDir = join3(workDir, ".git", "hooks");
-  if (!existsSync6(hooksDir)) {
-    await mkdir(hooksDir, { recursive: true });
-  }
-  const prePushHook = `#!/bin/sh
-# Auto-sync ledger to shared storage before push
-
-# Only run if trie is initialized
-if [ ! -d ".trie" ]; then
-  exit 0
-fi
-
-# Check if trie command is available
-if ! command -v trie >/dev/null 2>&1; then
-  echo "Warning: trie command not found, skipping ledger sync"
-  exit 0
-fi
-
-# Sync ledger to shared storage
-echo "Syncing ledger to shared storage..."
-trie sync push 2>/dev/null || true
-
-exit 0
-`;
-  const postMergeHook = `#!/bin/sh
-# Auto-sync ledger from shared storage after merge
-
-# Only run if trie is initialized
-if [ ! -d ".trie" ]; then
-  exit 0
-fi
-
-# Check if trie command is available
-if ! command -v trie >/dev/null 2>&1; then
-  exit 0
-fi
-
-# Sync ledger from shared storage
-echo "Syncing ledger from shared storage..."
-trie sync pull 2>/dev/null || true
-
-exit 0
-`;
-  const prePushPath = join3(hooksDir, "pre-push");
-  const postMergePath = join3(hooksDir, "post-merge");
-  await writeFile4(prePushPath, prePushHook);
-  await writeFile4(postMergePath, postMergeHook);
-  await chmod(prePushPath, 493);
-  await chmod(postMergePath, 493);
-  console.log(pc5.green("\u2713 Git hooks installed successfully"));
-  console.log(pc5.dim("  pre-push: Syncs ledger to shared storage"));
-  console.log(pc5.dim("  post-merge: Syncs ledger from shared storage"));
-}
-async function checkGitHooks() {
-  const workDir = getWorkingDirectory(void 0, true);
-  const isRepo = await isGitRepo(workDir);
-  if (!isRepo) {
-    return {
-      isGitRepo: false,
-      prePushInstalled: false,
-      postMergeInstalled: false
-    };
-  }
-  const hooksDir = join3(workDir, ".git", "hooks");
-  const prePushPath = join3(hooksDir, "pre-push");
-  const postMergePath = join3(hooksDir, "post-merge");
-  return {
-    isGitRepo: true,
-    prePushInstalled: existsSync6(prePushPath),
-    postMergeInstalled: existsSync6(postMergePath)
-  };
-}
-
-// src/cli/sync.ts
 function createSyncCommand() {
   const sync = new Command("sync").description("Sync ledger with shared storage");
   sync.command("init").description("Initialize shared ledger storage").action(async () => {
@@ -2513,9 +2780,9 @@ function createSyncCommand() {
       const workDir = getWorkingDirectory(void 0, true);
       console.log(`Initializing shared ledger in ${workDir}...`);
       await initializeSharedLedger();
-      console.log(pc6.green("\u2713 Shared ledger initialized successfully"));
+      console.log(pc7.green("\u2713 Shared ledger initialized successfully"));
     } catch (error) {
-      console.error(pc6.red("Failed to initialize shared ledger:"), error);
+      console.error(pc7.red("Failed to initialize shared ledger:"), error);
       process.exit(1);
     }
   });
@@ -2528,17 +2795,17 @@ function createSyncCommand() {
         await migrateLegacyLedger();
       }
       const result = await syncLedgerFromShared();
-      console.log(pc6.green("\u2713 Sync completed"));
+      console.log(pc7.green("\u2713 Sync completed"));
       console.log(`Merged ${result.stats.mergedBlocks} blocks`);
       if (result.conflicts.length > 0) {
-        console.log(pc6.yellow(`\u26A0 ${result.conflicts.length} conflicts detected`));
+        console.log(pc7.yellow(`\u26A0 ${result.conflicts.length} conflicts detected`));
         console.log('Run "trie sync status" to see details');
       }
       if (result.stats.duplicatesRemoved > 0) {
         console.log(`Removed ${result.stats.duplicatesRemoved} duplicate entries`);
       }
     } catch (error) {
-      console.error(pc6.red("Failed to sync from shared ledger:"), error);
+      console.error(pc7.red("Failed to sync from shared ledger:"), error);
       process.exit(1);
     }
   });
@@ -2551,45 +2818,45 @@ function createSyncCommand() {
         await migrateLegacyLedger();
       }
       await pushLedgerToShared();
-      console.log(pc6.green("\u2713 Push completed"));
+      console.log(pc7.green("\u2713 Push completed"));
     } catch (error) {
-      console.error(pc6.red("Failed to push to shared ledger:"), error);
+      console.error(pc7.red("Failed to push to shared ledger:"), error);
       process.exit(1);
     }
   });
   sync.command("status").description("Show ledger sync status").action(async () => {
     try {
       const status = await getLedgerSyncStatus();
-      console.log(pc6.bold("Ledger Sync Status\n"));
+      console.log(pc7.bold("Ledger Sync Status\n"));
       if (!status.isInitialized) {
-        console.log(pc6.yellow('\u26A0 Shared ledger not initialized. Run "trie sync init" first.'));
+        console.log(pc7.yellow('\u26A0 Shared ledger not initialized. Run "trie sync init" first.'));
         return;
       }
       if (status.hasLegacyLedger) {
-        console.log(pc6.yellow('\u26A0 Legacy ledger detected. Run "trie sync pull" to migrate.'));
+        console.log(pc7.yellow('\u26A0 Legacy ledger detected. Run "trie sync pull" to migrate.'));
       }
-      console.log(`Local blocks: ${pc6.cyan(status.localBlocks.toString())}`);
-      console.log(`Shared blocks: ${pc6.cyan(status.sharedBlocks.toString())}`);
+      console.log(`Local blocks: ${pc7.cyan(status.localBlocks.toString())}`);
+      console.log(`Shared blocks: ${pc7.cyan(status.sharedBlocks.toString())}`);
       if (status.syncState) {
         const lastSync = new Date(status.syncState.lastSyncTimestamp);
-        console.log(`Last sync: ${pc6.dim(lastSync.toLocaleString())}`);
+        console.log(`Last sync: ${pc7.dim(lastSync.toLocaleString())}`);
         if (status.conflicts > 0) {
-          console.log(pc6.yellow(`Conflicts: ${status.conflicts}`));
+          console.log(pc7.yellow(`Conflicts: ${status.conflicts}`));
           console.log("\nConflicts:");
           for (const conflict of status.syncState.conflicts) {
             console.log(`  \u2022 ${conflict.type}: ${conflict.description}`);
           }
         } else {
-          console.log(pc6.green("\u2713 No conflicts"));
+          console.log(pc7.green("\u2713 No conflicts"));
         }
       }
       if (status.manifest) {
         console.log(`
-Total entries: ${pc6.cyan(status.manifest.totalEntries.toString())}`);
-        console.log(`Compression: ${status.manifest.compressionConfig.enabled ? pc6.green("enabled") : pc6.red("disabled")}`);
+Total entries: ${pc7.cyan(status.manifest.totalEntries.toString())}`);
+        console.log(`Compression: ${status.manifest.compressionConfig.enabled ? pc7.green("enabled") : pc7.red("disabled")}`);
       }
     } catch (error) {
-      console.error(pc6.red("Failed to get sync status:"), error);
+      console.error(pc7.red("Failed to get sync status:"), error);
       process.exit(1);
     }
   });
@@ -2597,19 +2864,19 @@ Total entries: ${pc6.cyan(status.manifest.totalEntries.toString())}`);
     try {
       const hasLegacy = await detectLegacyLedger();
       if (!hasLegacy) {
-        console.log(pc6.yellow("No legacy ledger found to migrate"));
+        console.log(pc7.yellow("No legacy ledger found to migrate"));
         return;
       }
       console.log("Migrating legacy ledger...");
       const success = await migrateLegacyLedger();
       if (success) {
-        console.log(pc6.green("\u2713 Migration completed successfully"));
+        console.log(pc7.green("\u2713 Migration completed successfully"));
       } else {
-        console.log(pc6.red("Migration failed"));
+        console.log(pc7.red("Migration failed"));
         process.exit(1);
       }
     } catch (error) {
-      console.error(pc6.red("Failed to migrate legacy ledger:"), error);
+      console.error(pc7.red("Failed to migrate legacy ledger:"), error);
       process.exit(1);
     }
   });
@@ -2621,18 +2888,18 @@ Total entries: ${pc6.cyan(status.manifest.totalEntries.toString())}`);
       }
       const status = await checkGitHooks();
       if (!status.isGitRepo) {
-        console.log(pc6.yellow("Not a git repository"));
+        console.log(pc7.yellow("Not a git repository"));
         return;
       }
-      console.log(pc6.bold("Git Hooks Status\n"));
-      console.log(`Pre-push hook: ${status.prePushInstalled ? pc6.green("\u2713 installed") : pc6.red("\u2717 not installed")}`);
-      console.log(`Post-merge hook: ${status.postMergeInstalled ? pc6.green("\u2713 installed") : pc6.red("\u2717 not installed")}`);
+      console.log(pc7.bold("Git Hooks Status\n"));
+      console.log(`Pre-push hook: ${status.prePushInstalled ? pc7.green("\u2713 installed") : pc7.red("\u2717 not installed")}`);
+      console.log(`Post-merge hook: ${status.postMergeInstalled ? pc7.green("\u2713 installed") : pc7.red("\u2717 not installed")}`);
       if (!status.prePushInstalled || !status.postMergeInstalled) {
         console.log(`
-${pc6.yellow("\u{1F4A1} Tip:")} Run ${pc6.bold("trie sync hooks --install")} to install missing hooks`);
+${pc7.yellow("\u{1F4A1} Tip:")} Run ${pc7.bold("trie sync hooks --install")} to install missing hooks`);
       }
     } catch (error) {
-      console.error(pc6.red("Failed to manage git hooks:"), error);
+      console.error(pc7.red("Failed to manage git hooks:"), error);
       process.exit(1);
     }
   });
@@ -2640,7 +2907,7 @@ ${pc6.yellow("\u{1F4A1} Tip:")} Run ${pc6.bold("trie sync hooks --install")} to
 }
 
 // src/cli/ledger.ts
-import pc7 from "picocolors";
+import pc8 from "picocolors";
 import { Command as Command2 } from "commander";
 function createLedgerCommand() {
   const ledger = new Command2("ledger").description("Manage and inspect the ledger");
@@ -2649,13 +2916,13 @@ function createLedgerCommand() {
       console.log("Verifying ledger chain...");
       const result = await verifyLedger();
       if (result.valid) {
-        console.log(pc7.green("\u2713 Ledger chain is valid"));
+        console.log(pc8.green("\u2713 Ledger chain is valid"));
       } else {
-        console.log(pc7.red(`\u2717 Ledger chain is invalid: ${result.error}`));
+        console.log(pc8.red(`\u2717 Ledger chain is invalid: ${result.error}`));
         process.exit(1);
       }
     } catch (error) {
-      console.error(pc7.red("Failed to verify ledger:"), error);
+      console.error(pc8.red("Failed to verify ledger:"), error);
       process.exit(1);
     }
   });
@@ -2667,20 +2934,20 @@ function createLedgerCommand() {
         console.log("No ledger blocks found");
         return;
       }
-      console.log(pc7.bold(`Ledger History (last ${Math.min(limit, blocks.length)} blocks)
+      console.log(pc8.bold(`Ledger History (last ${Math.min(limit, blocks.length)} blocks)
 `));
       const recentBlocks = blocks.slice(-limit).reverse();
       for (const block of recentBlocks) {
         const syncableBlock = block;
-        console.log(pc7.bold(pc7.cyan(`Block ${block.date}`)));
+        console.log(pc8.bold(pc8.cyan(`Block ${block.date}`)));
         if (syncableBlock.author) {
-          console.log(`Author: ${pc7.dim(syncableBlock.author)}`);
+          console.log(`Author: ${pc8.dim(syncableBlock.author)}`);
         }
         if (syncableBlock.gitCommit) {
-          console.log(`Git: ${pc7.dim(syncableBlock.gitCommit.slice(0, 8))}`);
+          console.log(`Git: ${pc8.dim(syncableBlock.gitCommit.slice(0, 8))}`);
         }
         console.log(`Entries: ${block.entries.length}`);
-        console.log(`Hash: ${pc7.dim(block.blockHash.slice(0, 16))}...`);
+        console.log(`Hash: ${pc8.dim(block.blockHash.slice(0, 16))}...`);
         if (block.entries.length > 0) {
           console.log("Issues:");
           for (const entry of block.entries) {
@@ -2690,7 +2957,7 @@ function createLedgerCommand() {
         console.log("");
       }
     } catch (error) {
-      console.error(pc7.red("Failed to show ledger history:"), error);
+      console.error(pc8.red("Failed to show ledger history:"), error);
       process.exit(1);
     }
   });
@@ -2698,22 +2965,22 @@ function createLedgerCommand() {
     try {
       const status = await getLedgerSyncStatus();
       const blocks = await getLedgerBlocks();
-      console.log(pc7.bold("Ledger Statistics\n"));
-      console.log(`Total blocks: ${pc7.cyan(blocks.length.toString())}`);
+      console.log(pc8.bold("Ledger Statistics\n"));
+      console.log(`Total blocks: ${pc8.cyan(blocks.length.toString())}`);
       if (status.manifest) {
-        console.log(`Total entries: ${pc7.cyan(status.manifest.totalEntries.toString())}`);
-        console.log(`Active blocks: ${pc7.cyan(status.manifest.activeBlocks.length.toString())}`);
-        console.log(`Archived blocks: ${pc7.cyan(status.manifest.archivedBlocks.length.toString())}`);
+        console.log(`Total entries: ${pc8.cyan(status.manifest.totalEntries.toString())}`);
+        console.log(`Active blocks: ${pc8.cyan(status.manifest.activeBlocks.length.toString())}`);
+        console.log(`Archived blocks: ${pc8.cyan(status.manifest.archivedBlocks.length.toString())}`);
         if (status.manifest.compressionConfig.enabled) {
           const hotSize = Math.round(status.manifest.compressionConfig.maxHotStorageSize / 1024 / 1024);
-          console.log(`Hot storage limit: ${pc7.cyan(`${hotSize}MB`)}`);
-          console.log(`Archive after: ${pc7.cyan(`${status.manifest.compressionConfig.archiveAfterDays} days`)}`);
+          console.log(`Hot storage limit: ${pc8.cyan(`${hotSize}MB`)}`);
+          console.log(`Archive after: ${pc8.cyan(`${status.manifest.compressionConfig.archiveAfterDays} days`)}`);
         }
       }
       if (blocks.length > 0) {
         const firstBlock = blocks[0];
         const lastBlock = blocks[blocks.length - 1];
-        console.log(`Date range: ${pc7.dim(`${firstBlock.date} to ${lastBlock.date}`)}`);
+        console.log(`Date range: ${pc8.dim(`${firstBlock.date} to ${lastBlock.date}`)}`);
       }
       const authorCounts = /* @__PURE__ */ new Map();
       for (const block of blocks) {
@@ -2726,7 +2993,7 @@ function createLedgerCommand() {
         console.log("\nBlocks by author:");
         const sortedAuthors = Array.from(authorCounts.entries()).sort((a, b) => b[1] - a[1]);
         for (const [author, count] of sortedAuthors.slice(0, 10)) {
-          console.log(`  ${author}: ${pc7.cyan(count.toString())}`);
+          console.log(`  ${author}: ${pc8.cyan(count.toString())}`);
         }
       }
       const severityCounts = /* @__PURE__ */ new Map();
@@ -2741,39 +3008,39 @@ function createLedgerCommand() {
         for (const severity of severityOrder) {
           const count = severityCounts.get(severity);
           if (count) {
-            const color = severity === "critical" ? pc7.red : severity === "high" ? pc7.yellow : severity === "medium" ? pc7.blue : pc7.gray;
-            console.log(`  ${color(severity)}: ${pc7.cyan(count.toString())}`);
+            const color = severity === "critical" ? pc8.red : severity === "high" ? pc8.yellow : severity === "medium" ? pc8.blue : pc8.gray;
+            console.log(`  ${color(severity)}: ${pc8.cyan(count.toString())}`);
           }
         }
       }
     } catch (error) {
-      console.error(pc7.red("Failed to show ledger stats:"), error);
+      console.error(pc8.red("Failed to show ledger stats:"), error);
       process.exit(1);
     }
   });
   ledger.command("diff").description("Compare local and shared ledger state").action(async () => {
     try {
       const status = await getLedgerSyncStatus();
-      console.log(pc7.bold("Ledger Diff\n"));
+      console.log(pc8.bold("Ledger Diff\n"));
       if (!status.isInitialized) {
-        console.log(pc7.yellow("Shared ledger not initialized"));
+        console.log(pc8.yellow("Shared ledger not initialized"));
         return;
       }
-      console.log(`Local blocks: ${pc7.cyan(status.localBlocks.toString())}`);
-      console.log(`Shared blocks: ${pc7.cyan(status.sharedBlocks.toString())}`);
+      console.log(`Local blocks: ${pc8.cyan(status.localBlocks.toString())}`);
+      console.log(`Shared blocks: ${pc8.cyan(status.sharedBlocks.toString())}`);
       const diff = status.sharedBlocks - status.localBlocks;
       if (diff > 0) {
-        console.log(pc7.green(`\u2193 ${diff} blocks available to pull`));
+        console.log(pc8.green(`\u2193 ${diff} blocks available to pull`));
       } else if (diff < 0) {
-        console.log(pc7.blue(`\u2191 ${-diff} local blocks not yet pushed`));
+        console.log(pc8.blue(`\u2191 ${-diff} local blocks not yet pushed`));
       } else {
-        console.log(pc7.green("\u2713 Local and shared ledgers are in sync"));
+        console.log(pc8.green("\u2713 Local and shared ledgers are in sync"));
       }
       if (status.conflicts > 0) {
-        console.log(pc7.red(`\u26A0 ${status.conflicts} conflicts detected`));
+        console.log(pc8.red(`\u26A0 ${status.conflicts} conflicts detected`));
       }
     } catch (error) {
-      console.error(pc7.red("Failed to diff ledgers:"), error);
+      console.error(pc8.red("Failed to diff ledgers:"), error);
       process.exit(1);
     }
   });
@@ -2787,42 +3054,42 @@ function createLedgerCommand() {
       console.log("Compressing old ledger blocks...");
       const result = await compressOldBlocks();
       if (result.archived > 0) {
-        console.log(pc7.green(`\u2713 Compressed ${result.archived} blocks`));
+        console.log(pc8.green(`\u2713 Compressed ${result.archived} blocks`));
         console.log(`Space saved: ${result.sizeReduction}%`);
       } else {
         console.log("No blocks were archived");
       }
     } catch (error) {
-      console.error(pc7.red("Failed to compress blocks:"), error);
+      console.error(pc8.red("Failed to compress blocks:"), error);
       process.exit(1);
     }
   });
   ledger.command("storage").description("Show detailed storage statistics").action(async () => {
     try {
       const stats = await getStorageStats();
-      console.log(pc7.bold("Ledger Storage Statistics\n"));
-      console.log(pc7.bold("Block Storage:"));
-      console.log(`  Active blocks: ${pc7.cyan(stats.activeBlocks.toString())}`);
-      console.log(`  Archived blocks: ${pc7.cyan(stats.archivedBlocks.toString())}`);
-      console.log(pc7.bold("\nStorage Usage:"));
+      console.log(pc8.bold("Ledger Storage Statistics\n"));
+      console.log(pc8.bold("Block Storage:"));
+      console.log(`  Active blocks: ${pc8.cyan(stats.activeBlocks.toString())}`);
+      console.log(`  Archived blocks: ${pc8.cyan(stats.archivedBlocks.toString())}`);
+      console.log(pc8.bold("\nStorage Usage:"));
       const activeMB = (stats.activeSize / 1024 / 1024).toFixed(2);
       const archivedMB = (stats.archivedSize / 1024 / 1024).toFixed(2);
       const totalMB = (Number(activeMB) + Number(archivedMB)).toFixed(2);
-      console.log(`  Active storage: ${pc7.cyan(`${activeMB} MB`)}`);
-      console.log(`  Archived storage: ${pc7.cyan(`${archivedMB} MB`)}`);
-      console.log(`  Total storage: ${pc7.bold(pc7.cyan(`${totalMB} MB`))}`);
+      console.log(`  Active storage: ${pc8.cyan(`${activeMB} MB`)}`);
+      console.log(`  Archived storage: ${pc8.cyan(`${archivedMB} MB`)}`);
+      console.log(`  Total storage: ${pc8.bold(pc8.cyan(`${totalMB} MB`))}`);
       if (stats.compressionRatio > 0) {
-        console.log(`  Compression ratio: ${pc7.green(`${stats.compressionRatio}%`)}`);
+        console.log(`  Compression ratio: ${pc8.green(`${stats.compressionRatio}%`)}`);
       }
-      console.log(pc7.bold("\nData:"));
-      console.log(`  Total entries: ${pc7.cyan(stats.totalEntries.toString())}`);
+      console.log(pc8.bold("\nData:"));
+      console.log(`  Total entries: ${pc8.cyan(stats.totalEntries.toString())}`);
       const needsCompression = await shouldCompress();
       if (needsCompression) {
         console.log(`
-${pc7.yellow("\u{1F4A1} Tip:")} Run ${pc7.bold("trie ledger compress")} to archive old blocks`);
+${pc8.yellow("\u{1F4A1} Tip:")} Run ${pc8.bold("trie ledger compress")} to archive old blocks`);
       }
     } catch (error) {
-      console.error(pc7.red("Failed to get storage stats:"), error);
+      console.error(pc8.red("Failed to get storage stats:"), error);
       process.exit(1);
     }
   });
@@ -2831,69 +3098,69 @@ ${pc7.yellow("\u{1F4A1} Tip:")} Run ${pc7.bold("trie ledger compress")} to archi
       const datePattern = /^\d{4}-\d{2}-\d{2}$/;
       const invalidDates = dates.filter((date) => !datePattern.test(date));
       if (invalidDates.length > 0) {
-        console.error(pc7.red("Invalid date format(s):"), invalidDates.join(", "));
+        console.error(pc8.red("Invalid date format(s):"), invalidDates.join(", "));
         console.error("Please use YYYY-MM-DD format");
         process.exit(1);
       }
       if (!options.confirm) {
-        console.log(pc7.bold(pc7.red("\u26A0\uFE0F  DANGER: PERMANENT DELETION")));
+        console.log(pc8.bold(pc8.red("\u26A0\uFE0F  DANGER: PERMANENT DELETION")));
         console.log("");
         console.log(`You are about to permanently delete ${dates.length} block(s):`);
         for (const date of dates) {
-          console.log(`  \u2022 ${pc7.cyan(date)}`);
+          console.log(`  \u2022 ${pc8.cyan(date)}`);
         }
         console.log("");
-        console.log(pc7.red("This operation cannot be undone and will permanently remove"));
-        console.log(pc7.red("all issues and data from these blocks."));
+        console.log(pc8.red("This operation cannot be undone and will permanently remove"));
+        console.log(pc8.red("all issues and data from these blocks."));
         console.log("");
-        console.log(`To proceed, add the ${pc7.bold("--confirm")} flag:`);
-        console.log(`  ${pc7.dim("trie ledger delete " + dates.join(" ") + " --confirm")}`);
+        console.log(`To proceed, add the ${pc8.bold("--confirm")} flag:`);
+        console.log(`  ${pc8.dim("trie ledger delete " + dates.join(" ") + " --confirm")}`);
         return;
       }
-      console.log(pc7.yellow("\u{1F5D1}\uFE0F  Deleting blocks..."));
+      console.log(pc8.yellow("\u{1F5D1}\uFE0F  Deleting blocks..."));
       const result = await deleteBlocks(dates, void 0, true);
       if (result.success) {
-        console.log(pc7.green(`\u2713 Successfully deleted ${result.deletedBlocks} block(s)`));
+        console.log(pc8.green(`\u2713 Successfully deleted ${result.deletedBlocks} block(s)`));
         if (result.warning) {
-          console.log(pc7.yellow(`\u26A0\uFE0F  ${result.warning}`));
+          console.log(pc8.yellow(`\u26A0\uFE0F  ${result.warning}`));
         }
       } else {
-        console.error(pc7.red("\u2717 Deletion failed:"), result.error);
+        console.error(pc8.red("\u2717 Deletion failed:"), result.error);
         process.exit(1);
       }
     } catch (error) {
-      console.error(pc7.red("Failed to delete blocks:"), error);
+      console.error(pc8.red("Failed to delete blocks:"), error);
       process.exit(1);
     }
   });
   ledger.command("clear").description("Delete ALL blocks from the ledger (PERMANENT)").option("--confirm", "Confirm the permanent deletion of all blocks").action(async (options) => {
     try {
       if (!options.confirm) {
-        console.log(pc7.bold(pc7.red("\u{1F6A8} DANGER: COMPLETE LEDGER DELETION")));
+        console.log(pc8.bold(pc8.red("\u{1F6A8} DANGER: COMPLETE LEDGER DELETION")));
         console.log("");
-        console.log(pc7.red("You are about to permanently delete ALL blocks in the ledger."));
-        console.log(pc7.red("This will completely erase the entire ledger history."));
+        console.log(pc8.red("You are about to permanently delete ALL blocks in the ledger."));
+        console.log(pc8.red("This will completely erase the entire ledger history."));
         console.log("");
-        console.log(pc7.red("This operation cannot be undone and will permanently remove"));
-        console.log(pc7.red("ALL issues and historical data."));
+        console.log(pc8.red("This operation cannot be undone and will permanently remove"));
+        console.log(pc8.red("ALL issues and historical data."));
         console.log("");
-        console.log(`To proceed, add the ${pc7.bold("--confirm")} flag:`);
-        console.log(`  ${pc7.dim("trie ledger clear --confirm")}`);
+        console.log(`To proceed, add the ${pc8.bold("--confirm")} flag:`);
+        console.log(`  ${pc8.dim("trie ledger clear --confirm")}`);
         return;
       }
-      console.log(pc7.yellow("\u{1F5D1}\uFE0F  Clearing entire ledger..."));
+      console.log(pc8.yellow("\u{1F5D1}\uFE0F  Clearing entire ledger..."));
       const result = await deleteAllBlocks(void 0, true);
       if (result.success) {
-        console.log(pc7.green(`\u2713 Successfully deleted ${result.deletedBlocks} block(s)`));
+        console.log(pc8.green(`\u2713 Successfully deleted ${result.deletedBlocks} block(s)`));
         if (result.warning) {
-          console.log(pc7.yellow(`\u26A0\uFE0F  ${result.warning}`));
+          console.log(pc8.yellow(`\u26A0\uFE0F  ${result.warning}`));
         }
       } else {
-        console.error(pc7.red("\u2717 Clear operation failed:"), result.error);
+        console.error(pc8.red("\u2717 Clear operation failed:"), result.error);
         process.exit(1);
       }
     } catch (error) {
-      console.error(pc7.red("Failed to clear ledger:"), error);
+      console.error(pc8.red("Failed to clear ledger:"), error);
       process.exit(1);
     }
   });
@@ -2901,13 +3168,13 @@ ${pc7.yellow("\u{1F4A1} Tip:")} Run ${pc7.bold("trie ledger compress")} to archi
 }
 
 // src/cli/main.ts
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = dirname(__filename2);
+var __filename3 = fileURLToPath2(import.meta.url);
+var __dirname3 = dirname2(__filename3);
 var DEFAULT_VERSION = "0.0.0";
 function getCliVersion() {
   try {
-    const pkgPath = resolve(__dirname2, "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const pkgPath = resolve2(__dirname3, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
     return typeof pkg.version === "string" && pkg.version.trim() ? pkg.version.trim() : DEFAULT_VERSION;
   } catch {
     return DEFAULT_VERSION;
@@ -2996,51 +3263,6 @@ MCP TOOLS (use via Cursor/Claude Desktop):
   trie_explain         Explain code, issues, or changes
   trie_watch           Watch mode for autonomous reporting
 
-`);
-}
-function showSetup() {
-  console.log(`
-\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
-\u2551                    Trie Agent Setup                           \u2551
-\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
-
-STEP 1: API Keys
-\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
-Trie can work offline, but performs best with these keys:
-
-1. ANTHROPIC_API_KEY (Required for AI analysis)
-   Get it: https://console.anthropic.com/
-
-2. LINEAR_API_KEY (Required for JIT defect prediction)
-   Get it: https://linear.app/settings/api
-
-Set them in your environment (~/.zshrc) or MCP config:
-  export ANTHROPIC_API_KEY=sk-ant-...
-  export LINEAR_API_KEY=lin_api_...
-
-STEP 2: Configure for your AI tool
-\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
-
-For CLAUDE CODE:
-  claude mcp add Trie -- npx @triedotdev/mcp
-
-For CURSOR (~/.cursor/mcp.json):
-{
-  "mcpServers": {
-    "Trie": {
-      "command": "npx",
-      "args": ["-y", "@triedotdev/mcp"],
-      "env": {
-        "ANTHROPIC_API_KEY": "your-key-here",
-        "LINEAR_API_KEY": "your-key-here"
-      }
-    }
-  }
-}
-
-STEP 3: Start scanning!
-\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
-Ask your AI assistant: "Scan this with Trie" or "Use trie_scan"
 `);
 }
 function showVersion() {
@@ -3059,47 +3281,47 @@ async function handleStatusCommand() {
       const lastScanDate = new Date(state.lastScan.timestamp);
       const daysAgo = Math.floor((Date.now() - lastScanDate.getTime()) / (1e3 * 60 * 60 * 24));
       console.log(`
-${pc8.bold("Last Scan:")} ${lastScanDate.toLocaleDateString()} (${daysAgo === 0 ? "today" : daysAgo === 1 ? "yesterday" : `${daysAgo} days ago`})`);
-      console.log(pc8.dim(`   Files scanned: ${state.lastScan.filesScanned}`));
-      console.log(pc8.dim(`   Issues found: ${state.lastScan.issues.total} (${state.lastScan.issues.critical} critical, ${state.lastScan.issues.serious} serious)`));
+${pc9.bold("Last Scan:")} ${lastScanDate.toLocaleDateString()} (${daysAgo === 0 ? "today" : daysAgo === 1 ? "yesterday" : `${daysAgo} days ago`})`);
+      console.log(pc9.dim(`   Files scanned: ${state.lastScan.filesScanned}`));
+      console.log(pc9.dim(`   Issues found: ${state.lastScan.issues.total} (${state.lastScan.issues.critical} critical, ${state.lastScan.issues.serious} serious)`));
     } else {
       console.log(`
-${pc8.bold("Last Scan:")} Never ${pc8.dim("(run `trie scan` to get started)")}`);
+${pc9.bold("Last Scan:")} Never ${pc9.dim("(run `trie scan` to get started)")}`);
     }
     console.log(`
-${pc8.bold("Memory Stats:")}`);
-    console.log(pc8.dim(`   Active Issues: ${memoryStats.activeIssues}`));
-    console.log(pc8.dim(`   Resolved: ${memoryStats.resolvedCount}`));
-    console.log(pc8.dim(`   Total (all-time): ${memoryStats.totalIssues}`));
+${pc9.bold("Memory Stats:")}`);
+    console.log(pc9.dim(`   Active Issues: ${memoryStats.activeIssues}`));
+    console.log(pc9.dim(`   Resolved: ${memoryStats.resolvedCount}`));
+    console.log(pc9.dim(`   Total (all-time): ${memoryStats.totalIssues}`));
     const cap = memoryStats.capacityInfo;
-    const capIndicator = cap.isAtCap ? pc8.red("\u25CB") : cap.percentFull >= 80 ? pc8.yellow("\u25C9") : pc8.green("\u25CF");
-    console.log(`   ${capIndicator} Memory Usage: ${pc8.bold(cap.percentFull + "%")} ${pc8.dim(`(${cap.current}/${cap.max})`)}`);
+    const capIndicator = cap.isAtCap ? pc9.red("\u25CB") : cap.percentFull >= 80 ? pc9.yellow("\u25C9") : pc9.green("\u25CF");
+    console.log(`   ${capIndicator} Memory Usage: ${pc9.bold(cap.percentFull + "%")} ${pc9.dim(`(${cap.current}/${cap.max})`)}`);
     if (memoryStats.activeIssues > 0) {
       console.log(`
-   ${pc8.bold("Active Issues by Severity:")}`);
+   ${pc9.bold("Active Issues by Severity:")}`);
       const severityOrder = ["critical", "serious", "moderate", "low", "info"];
       for (const severity of severityOrder) {
         const count = memoryStats.activeIssuesBySeverity[severity] || 0;
         if (count > 0) {
-          console.log(pc8.dim(`     ${severity}: ${count}`));
+          console.log(pc9.dim(`     ${severity}: ${count}`));
         }
       }
     } else if (memoryStats.totalIssues > 0) {
       console.log(`
-   ${pc8.green("\u25CF")} All issues have been resolved`);
+   ${pc9.green("\u25CF")} All issues have been resolved`);
     }
     if (cap.isAtCap) {
       console.log(`
-${pc8.yellow("\u2B22 Warning:")} Memory at capacity - consider running: ${pc8.bold("trie memory purge smart")}`);
+${pc9.yellow("\u2B22 Warning:")} Memory at capacity - consider running: ${pc9.bold("trie memory purge smart")}`);
     } else if (cap.percentFull >= 80) {
       console.log(`
-${pc8.yellow("\u2B22 Notice:")} Memory usage high - consider running: ${pc8.bold("trie memory purge smart")}`);
+${pc9.yellow("\u2B22 Notice:")} Memory usage high - consider running: ${pc9.bold("trie memory purge smart")}`);
     }
     console.log(`
-${pc8.bold("Quick Commands:")}`);
-    console.log(pc8.dim("   trie scan          - Scan codebase now"));
-    console.log(pc8.dim("   trie memory stats  - Detailed memory statistics"));
-    console.log(pc8.dim("   trie project       - View project information"));
+${pc9.bold("Quick Commands:")}`);
+    console.log(pc9.dim("   trie scan          - Scan codebase now"));
+    console.log(pc9.dim("   trie memory stats  - Detailed memory statistics"));
+    console.log(pc9.dim("   trie project       - View project information"));
     console.log("");
   } catch (error) {
     console.error("Error loading status:", error);
@@ -3117,7 +3339,7 @@ async function handleProject(args) {
 \u2551                    PROJECT.md Created                            \u2551
 \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
 
-${pc8.bold("Path:")} ${result.path}
+${pc9.bold("Path:")} ${result.path}
 
 A template has been created with sections for:
   \u2022 Project Overview
@@ -3142,7 +3364,7 @@ Next steps:
   }
   if (subcommand === "edit") {
     const editor = process.env.EDITOR || process.env.VISUAL || "nano";
-    const projectPath = join4(getTrieDirectory(workDir), "PROJECT.md");
+    const projectPath = join5(getTrieDirectory(workDir), "PROJECT.md");
     if (!projectInfoExists(workDir)) {
       console.log("No PROJECT.md found. Creating one first...");
       await initProjectInfo(workDir);
@@ -3160,7 +3382,7 @@ Next steps:
 \u2551                    Project Information                           \u2551
 \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
 
-${pc8.bold("No PROJECT.md found in this project.")}
+${pc9.bold("No PROJECT.md found in this project.")}
 
 COMMANDS:
   trie project init    Create PROJECT.md from template
@@ -3188,7 +3410,7 @@ This info is available via trie://project MCP resource.
 \u2551                    Project Information                           \u2551
 \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
 
-${pc8.bold("Path:")} ${join4(getTrieDirectory(workDir), "PROJECT.md")}
+${pc9.bold("Path:")} ${join5(getTrieDirectory(workDir), "PROJECT.md")}
 
 ${"-".repeat(68)}
 `);
@@ -3197,10 +3419,10 @@ ${"-".repeat(68)}
 async function runScan(args) {
   const { spawn } = await import("child_process");
   let daemonPath;
-  if (__filename2.endsWith(".ts")) {
-    daemonPath = resolve(__dirname2, "yolo-daemon.ts");
+  if (__filename3.endsWith(".ts")) {
+    daemonPath = resolve2(__dirname3, "yolo-daemon.ts");
   } else {
-    daemonPath = resolve(__dirname2, "yolo-daemon.js");
+    daemonPath = resolve2(__dirname3, "yolo-daemon.js");
   }
   const daemonArgs = ["--once", ...args];
   const executor = daemonPath.endsWith(".ts") ? "npx" : "node";
@@ -3216,10 +3438,10 @@ async function runScan(args) {
 async function runWatch(args) {
   const { spawn } = await import("child_process");
   let daemonPath;
-  if (__filename2.endsWith(".ts")) {
-    daemonPath = resolve(__dirname2, "yolo-daemon.ts");
+  if (__filename3.endsWith(".ts")) {
+    daemonPath = resolve2(__dirname3, "yolo-daemon.ts");
   } else {
-    daemonPath = resolve(__dirname2, "yolo-daemon.js");
+    daemonPath = resolve2(__dirname3, "yolo-daemon.js");
   }
   const executor = daemonPath.endsWith(".ts") ? "npx" : "node";
   const execArgs = daemonPath.endsWith(".ts") ? ["tsx", daemonPath, ...args] : [daemonPath, ...args];
@@ -3252,7 +3474,7 @@ async function main() {
     case "setup":
     case "config":
     case "configure":
-      showSetup();
+      await handleSetupCommand(restArgs);
       break;
     case "init":
     case "bootstrap":
@@ -3296,6 +3518,12 @@ async function main() {
     case "pre-push":
       handlePrePushCommand(restArgs);
       break;
+    case "pre-commit":
+      handlePreCommitCommand(restArgs);
+      break;
+    case "post-commit":
+      handlePostCommitCommand(restArgs);
+      break;
     case "fix":
     case "auto-fix":
     case "autofix":
@@ -3362,7 +3590,7 @@ async function main() {
     default:
       if (command.startsWith("-")) {
         const { spawn } = __require("child_process");
-        const daemonPath = resolve(__dirname2, "yolo-daemon.js");
+        const daemonPath = resolve2(__dirname3, "yolo-daemon.js");
         const child = spawn("node", [daemonPath, ...args], {
           stdio: "inherit",
           env: process.env
@@ -3382,7 +3610,7 @@ var isEntryPoint = (() => {
   if (!entry) return false;
   try {
     const realEntry = realpathSync(entry);
-    const realThis = fileURLToPath(import.meta.url);
+    const realThis = fileURLToPath2(import.meta.url);
     return realEntry === realThis;
   } catch {
     return !process.env.VITEST && !process.env.VITEST_WORKER_ID;