@triedotdev/mcp 1.0.168 → 1.0.170

package/dist/cli/main.js

@@ -1,3134 +1,390 @@
 #!/usr/bin/env node
 import {
-  completeBootstrap,
-  initProjectInfo,
-  initializeBootstrapFiles,
-  loadContextState,
-  loadProjectInfo,
-  needsBootstrap,
-  projectInfoExists
-} from "../chunk-HVCDY3AK.js";
-import {
-  LinearIngester
-} from "../chunk-Q63FFI6D.js";
-import {
-  LearningEngine,
-  formatFriendlyError,
-  isTrieInitialized,
-  perceiveCurrentChanges,
-  reasonAboutChangesHumanReadable
-} from "../chunk-YZ6Y2H3P.js";
-import {
-  measureInitialGoalValue
-} from "../chunk-5BRRRTN6.js";
-import {
-  exportToJson
-} from "../chunk-OBQ74FOU.js";
-import {
-  loadConfig,
-  saveConfig
-} from "../chunk-XPZZFPBZ.js";
-import {
-  IncidentIndex
-} from "../chunk-TN5WEKWI.js";
-import "../chunk-ZV2K6M7T.js";
-import {
-  GotchaPredictor,
-  SlackIntegration,
-  findCrossProjectPatterns,
-  getGlobalMemoryStats,
-  listTrackedProjects,
-  searchGlobalPatterns,
-  updateGlobalMemoryMd
-} from "../chunk-7WITSO22.js";
-import "../chunk-SY6KQG44.js";
-import "../chunk-OMR4YCBS.js";
-import {
-  ContextGraph
-} from "../chunk-VUL52BQL.js";
-import "../chunk-6NLHFIYA.js";
-import {
-  getStorage
-} from "../chunk-575YT2SD.js";
-import "../chunk-FQ45QP5A.js";
-import {
-  getDailyLogs,
-  getMemoryStats,
-  getRecentIssues,
-  markIssueResolved,
-  purgeIssues,
-  searchIssues
-} from "../chunk-XE6KQRKZ.js";
-import {
-  compressOldBlocks,
-  correctLedgerEntries,
-  detectLegacyLedger,
-  generateKeyPair,
-  getCorrectionStats,
-  getEntryCorrectionHistory,
-  getLedgerBlocks,
-  getLedgerSyncStatus,
-  getPublicKey,
-  getStorageStats,
-  hasSigningKey,
-  initializeSharedLedger,
-  loadKeyPair,
-  migrateLegacyLedger,
-  pushLedgerToShared,
-  saveKeyPair,
-  shouldCompress,
-  syncLedgerFromShared,
-  verifyLedger
-} from "../chunk-ZJF5FTBX.js";
-import {
-  getProjectState
-} from "../chunk-GTKYBOXL.js";
-import "../chunk-EFWVF6TI.js";
-import "../chunk-43X6JBEM.js";
-import {
-  getAutonomyConfig,
-  recordBypass,
-  shouldAutoFix,
-  shouldBlockPush,
-  trackIssueOccurrence
-} from "../chunk-ME2OERF5.js";
-import {
-  getTrieDirectory,
-  getWorkingDirectory
-} from "../chunk-VVITXIHN.js";
-import "../chunk-KDHN2ZQE.js";
-import {
-  getStagedChanges,
-  getUncommittedChanges,
-  isGitRepo
-} from "../chunk-2HF65EHQ.js";
-import {
-  __require
-} from "../chunk-DGUM43GV.js";
-
-// src/cli/main.ts
-import { resolve, join as join4, dirname } from "path";
-import { readFileSync as readFileSync2, realpathSync } from "fs";
-import { fileURLToPath } from "url";
-import pc9 from "picocolors";
-
-// src/hooks/install.ts
-import fs from "fs";
-import path from "path";
-
-// src/hooks/templates.ts
-var PATH_FIX = 'export PATH="/usr/local/bin:/opt/homebrew/bin:$PATH"\n';
-function hookHeader() {
-  return "#!/bin/sh\n" + PATH_FIX + "\n";
-}
-function trieCommand(name) {
-  return `
-TRIE_BIN="$(command -v trie || command -v trie-agent || true)"
-if [ -n "$TRIE_BIN" ]; then
-  "$TRIE_BIN" ${name} || true
-else
-  echo "Trie not available; skipping ${name} hook."
-fi
-`;
-}
-function prePushCommand() {
-  return `
-TRIE_BIN="$(command -v trie || command -v trie-agent || true)"
-if [ -n "$TRIE_BIN" ]; then
-  # Check for bypass
-  if [ "$TRIE_BYPASS" = "1" ] || [ "$TRIE_BYPASS" = "true" ]; then
-    echo "Trie push blocking bypassed (TRIE_BYPASS=1)"
-    "$TRIE_BIN" pre-push --bypassed || true
-    exit 0
-  fi
-  
-  # Run pre-push check with blocking enabled
-  "$TRIE_BIN" pre-push --block
-  EXIT_CODE=$?
-  
-  if [ $EXIT_CODE -eq 0 ]; then
-    exit 0
-  elif [ $EXIT_CODE -eq 2 ]; then
-    # Exit code 2 = blocked but bypassable
-    echo ""
-    echo "\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\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"
-    echo "Push blocked by Trie due to critical issues."
-    echo ""
-    echo "To bypass (not recommended):"
-    echo "  TRIE_BYPASS=1 git push"
-    echo "  OR: git push --no-verify"
-    echo ""
-    echo "To fix issues first:"
-    echo "  trie fix"
-    echo "\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\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"
-    exit 1
-  else
-    # Other errors - don't block
-    exit 0
-  fi
-else
-  echo "Trie not available; skipping pre-push hook."
-fi
-`;
-}
-function preCommitTemplate() {
-  return (hookHeader() + "# Trie pre-commit hook\n" + trieCommand("pre-commit")).trim() + "\n";
-}
-function postCommitTemplate() {
-  return (hookHeader() + "# Trie post-commit hook\n" + trieCommand("post-commit")).trim() + "\n";
-}
-function prePushTemplate() {
-  return (hookHeader() + "# Trie pre-push hook with blocking support\n# Bypass with: TRIE_BYPASS=1 git push\n" + prePushCommand()).trim() + "\n";
-}
-
-// src/hooks/install.ts
-var HOOK_BUILDERS = {
-  "pre-commit": preCommitTemplate,
-  "post-commit": postCommitTemplate,
-  "pre-push": prePushTemplate
-};
-function hookPath(repoPath, name) {
-  return path.join(repoPath, ".git", "hooks", name);
-}
-function ensureHookDir(repoPath) {
-  const dir = path.join(repoPath, ".git", "hooks");
-  fs.mkdirSync(dir, { recursive: true });
-}
-function appendHookFile(targetPath, content) {
-  if (fs.existsSync(targetPath)) {
-    const existing = fs.readFileSync(targetPath, "utf8");
-    if (existing.includes("# Trie pre-commit hook") || existing.includes("# Trie post-commit hook")) {
-      return;
-    }
-    fs.appendFileSync(targetPath, `
-# --- Added by Trie ---
-${content}`);
-  } else {
-    fs.writeFileSync(targetPath, content, { mode: 493 });
-  }
-  fs.chmodSync(targetPath, 493);
-}
-function installGitHooks(projectPath) {
-  const gitDir = path.join(projectPath, ".git");
-  if (!fs.existsSync(gitDir)) {
-    return [];
-  }
-  ensureHookDir(projectPath);
-  const installed = [];
-  Object.keys(HOOK_BUILDERS).forEach((name) => {
-    const content = HOOK_BUILDERS[name]();
-    const target = hookPath(projectPath, name);
-    appendHookFile(target, content);
-    installed.push(name);
-  });
-  return installed;
-}
-
-// src/cli/init.ts
-import fs2 from "fs";
-import path2 from "path";
-function ensureGitignore(workDir) {
-  const target = path2.join(workDir, ".gitignore");
-  const entries = [".trie/context.db", ".trie/context.json", ".trie/*.db", "trie-reports/"];
-  let content = "";
-  if (fs2.existsSync(target)) {
-    content = fs2.readFileSync(target, "utf8");
-  }
-  const missing = entries.filter((e) => !content.includes(e));
-  if (missing.length > 0) {
-    const updated = content.trimEnd() + "\n" + missing.join("\n") + "\n";
-    fs2.writeFileSync(target, updated);
-  }
-}
-async function handleInitCommand(args) {
-  try {
-    const subcommand = args[0]?.toLowerCase();
-    const workDir = getWorkingDirectory(void 0, true);
-    if (subcommand === "complete") {
-      const result2 = await completeBootstrap(workDir);
-      if (result2) {
-        console.log("Bootstrap completed. BOOTSTRAP.md has been deleted.");
-      } else {
-        console.log("No BOOTSTRAP.md file found.");
-      }
-      return;
-    }
-    if (subcommand === "status") {
-      const needs = needsBootstrap(workDir);
-      if (needs) {
-        console.log("Bootstrap pending: .trie/BOOTSTRAP.md exists");
-        console.log('Run "trie init complete" after finishing setup.');
-      } else {
-        console.log("Bootstrap complete: No pending setup.");
-      }
-      return;
-    }
-    const force = args.includes("--force") || args.includes("-f");
-    const skipBootstrap = args.includes("--skip-bootstrap");
-    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\u2557
-\u2551                                                \u2551
-\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557                 \u2551
-\u2551   \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D                 \u2551
-\u2551      \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557                   \u2551
-\u2551      \u2588\u2588\u2551   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D                   \u2551
-\u2551      \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557                 \u2551
-\u2551      \u255A\u2550\u255D   \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D                 \u2551
-\u2551                                                \u2551
-\u2551   Your code quality agent and tools registry   \u2551
-\u2551                                                \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\u255D
-
-  by Louis Kishfy
-
-  Download the Trie workspace: https://www.trie.dev
-  Follow me on X: https://x.com/louiskishfy
-
-`);
-    const result = await initializeBootstrapFiles({
-      workDir,
-      force,
-      skipBootstrap
-    });
-    const isReInit = result.created.length === 0 && result.skipped.length > 0;
-    if (isReInit && !force) {
-      console.log("Trie is already initialized in this project.\n");
-      console.log("Your files:");
-      for (const file of result.skipped) {
-        console.log(`  \u2713 .trie/${file}`);
-      }
-      console.log("\nTo reset and recreate files: trie init --force");
-    } else {
-      if (result.created.length > 0) {
-        console.log("Created files:");
-        for (const file of result.created) {
-          console.log(`  + .trie/${file}`);
-        }
-      }
-      if (result.skipped.length > 0 && !force) {
-        console.log("\nSkipped (already exist):");
-        for (const file of result.skipped) {
-          console.log(`  - .trie/${file}`);
-        }
-      }
-    }
-    console.log("\nDetected Stack:");
-    if (result.stack.framework) console.log(`  Framework: ${result.stack.framework}`);
-    if (result.stack.language) console.log(`  Language: ${result.stack.language}`);
-    if (result.stack.database) console.log(`  Database: ${result.stack.database}`);
-    if (result.stack.auth) console.log(`  Auth: ${result.stack.auth}`);
-    if (result.stack.packageManager) console.log(`  Package Manager: ${result.stack.packageManager}`);
-    console.log(`
-Quick Start:
-  1. trie watch             # Start watching (nudges as you code)
-  2. trie tell "what broke" # Teach Trie about past incidents
-  3. trie check             # Risk check before pushing
-
-Trie is now active via git hooks (pre-commit, pre-push).
-For real-time nudges while coding, run "trie watch" in a terminal.
-
-Customize Later:
-  - .trie/PROJECT.md  \u2014 Describe your project for better context
-  - .trie/RULES.md    \u2014 Define coding standards Trie should enforce
-
-Run "trie help" to see all available commands.
-`);
-    const hooks = installGitHooks(workDir);
-    if (hooks.length > 0) {
-      console.log("\nGit hooks installed:");
-      for (const hook of hooks) {
-        console.log(`  .git/hooks/${hook}`);
-      }
-    } else {
-      console.log("\nGit hooks not installed (no .git directory found).");
-    }
-    ensureGitignore(workDir);
-    const skipKeys = args.includes("--no-keys");
-    if (!skipKeys && !hasSigningKey(workDir)) {
-      console.log("\nSetting up Ed25519 signing for governance ledger...");
-      try {
-        const keyPair = await generateKeyPair();
-        saveKeyPair(keyPair, workDir);
-        console.log(`  \u2713 Signing key generated`);
-        console.log(`    Public key: ${keyPair.publicKey.slice(0, 16)}...${keyPair.publicKey.slice(-8)}`);
-        console.log("    All ledger entries will be signed automatically.");
-        console.log("    Your private key stays local (never committed to git).");
-      } catch (keyError) {
-        console.log(`  \u26A0 Could not generate signing key: ${keyError}`);
-        console.log('    Run "trie keys generate" to set up signing later.');
-      }
-    } else if (hasSigningKey(workDir)) {
-      console.log("\n\u2713 Signing key already configured (ledger entries will be signed)");
-    }
-    if (!process.env.ANTHROPIC_API_KEY) {
-      console.log(`
-Note: Running in pattern-only mode. For AI-powered analysis, set your API key:
-
-  This session only:
-    export ANTHROPIC_API_KEY=sk-ant-...
-
-  Persist in shell config (~/.zshrc or ~/.bashrc):
-    echo 'export ANTHROPIC_API_KEY=sk-ant-...' >> ~/.zshrc
-    source ~/.zshrc
-
-  Or add to your MCP config for Cursor/Claude Code (see README).`);
-    }
-  } catch (error) {
-    const friendly = formatFriendlyError(error);
-    console.error(friendly.userMessage);
-  }
-}
-
-// src/cli/memory.ts
-async function handleMemoryCommand(args) {
-  const subcommand = args[0]?.toLowerCase();
-  const restArgs = args.slice(1);
-  switch (subcommand) {
-    case "search":
-      await handleSearch(restArgs);
-      break;
-    case "stats":
-      await handleStats();
-      break;
-    case "recent":
-      await handleRecent(restArgs);
-      break;
-    case "logs":
-      await handleLogs();
-      break;
-    case "resolve":
-      await handleResolve(restArgs);
-      break;
-    case "purge":
-      await handlePurge(restArgs);
-      break;
-    case "global":
-      await handleGlobal(restArgs);
-      break;
-    default:
-      showHelp();
-  }
-}
-async function handleSearch(args) {
-  const query = args.join(" ");
-  if (!query) {
-    console.log("Usage: trie memory search <query>");
-    console.log('Example: trie memory search "SQL injection"');
-    return;
-  }
-  const workDir = getWorkingDirectory(void 0, true);
-  const results = await searchIssues(query, { workDir, limit: 10 });
-  if (results.length === 0) {
-    console.log(`No issues found matching "${query}"`);
-    return;
-  }
-  console.log(`Found ${results.length} issue(s) matching "${query}":
-`);
-  for (const result of results) {
-    const i = result.issue;
-    const status = i.resolved ? "[RESOLVED]" : "";
-    console.log(`[${i.severity.toUpperCase()}] ${status} ${i.issue.slice(0, 80)}`);
-    console.log(`  File: ${i.file}${i.line ? `:${i.line}` : ""}`);
-    console.log(`  Agent: ${i.agent} | Score: ${(result.score * 100).toFixed(0)}%`);
-    console.log(`  Date: ${new Date(i.timestamp).toLocaleDateString()}`);
-    console.log("");
-  }
-}
-async function handleStats() {
-  const workDir = getWorkingDirectory(void 0, true);
-  const stats = await getMemoryStats(workDir);
-  const globalStats = await getGlobalMemoryStats();
-  console.log("Local Issue Memory Stats:");
-  console.log(`  Active Issues: ${stats.activeIssues}`);
-  console.log(`  Resolved: ${stats.resolvedCount}`);
-  console.log(`  Total (all-time): ${stats.totalIssues}`);
-  const cap = stats.capacityInfo;
-  if (cap.isAtCap) {
-    console.log("\n\u26A0\uFE0F  CAPACITY WARNING");
-    console.log(`  Memory is at maximum capacity (${cap.current}/${cap.max}, ${cap.percentFull}%)`);
-    console.log("  New repeats are deduplicated. Older issues are compacted into summaries, and if still over cap the oldest/lowest-value issues are pruned.");
-    console.log("\n  To free up space:");
-    console.log("    trie memory purge smart      - Remove resolved & old low-priority (recommended)");
-    console.log("    trie memory purge resolved   - Remove all resolved issues");
-    console.log("    trie memory purge old        - Remove issues older than 90 days");
-    console.log("    trie memory purge all        - Clear all issues (keeps summaries)");
-  } else if (cap.percentFull >= 80) {
-    console.log(`
-\u2139\uFE0F  Memory Usage: ${cap.percentFull}% (${cap.current}/${cap.max})`);
-    console.log("  Consider running: trie memory purge smart");
-  } else {
-    console.log(`  Memory Usage: ${cap.percentFull}% (${cap.current}/${cap.max})`);
-  }
-  if (stats.deduplicationStats.duplicatesAvoided > 0) {
-    console.log("\n  Deduplication:");
-    console.log(`    Unique Patterns: ${stats.deduplicationStats.uniquePatterns}`);
-    console.log(`    Duplicates Avoided: ${stats.deduplicationStats.duplicatesAvoided}`);
-  }
-  if (stats.oldestIssue) {
-    console.log(`
-  Date Range: ${stats.oldestIssue.split("T")[0]} to ${stats.newestIssue?.split("T")[0]}`);
-  }
-  console.log("\n  Active Issues by Severity:");
-  const severityOrder = ["critical", "serious", "moderate", "low", "info"];
-  let hasActiveIssues = false;
-  for (const severity of severityOrder) {
-    const activeCount = stats.activeIssuesBySeverity[severity] || 0;
-    const totalCount = stats.issuesBySeverity[severity] || 0;
-    if (totalCount > 0) {
-      hasActiveIssues = hasActiveIssues || activeCount > 0;
-      console.log(`    ${severity}: ${activeCount} active (${totalCount} all-time)`);
-    }
-  }
-  if (!hasActiveIssues && stats.totalIssues > 0) {
-    console.log("    \u2705 All issues have been resolved!");
-  }
-  console.log("\n  By Agent:");
-  const sortedAgents = Object.entries(stats.issuesByAgent).sort((a, b) => b[1] - a[1]);
-  for (const [agent, count] of sortedAgents.slice(0, 10)) {
-    console.log(`    ${agent}: ${count}`);
-  }
-  console.log("\nGlobal Cross-Project Stats:");
-  console.log(`  Tracked Projects: ${globalStats.trackedProjects}`);
-  console.log(`  Total Patterns: ${globalStats.totalPatterns}`);
-  console.log(`  Cross-Project Patterns: ${globalStats.crossProjectPatterns}`);
-  console.log(`  Fixed Patterns: ${globalStats.fixedPatterns}`);
-}
-async function handleRecent(args) {
-  const limit = parseInt(args[0] || "10", 10);
-  const workDir = getWorkingDirectory(void 0, true);
-  const issues = await getRecentIssues({ workDir, limit });
-  if (issues.length === 0) {
-    console.log("No recent issues found.");
-    return;
-  }
-  console.log(`Recent Issues (last 7 days):
-`);
-  for (const i of issues) {
-    const status = i.resolved ? "[RESOLVED]" : "";
-    console.log(`[${i.severity.toUpperCase()}] ${status} ${i.issue.slice(0, 70)}`);
-    console.log(`  ${i.file}${i.line ? `:${i.line}` : ""} | ${i.agent}`);
-    console.log("");
-  }
-}
-async function handleLogs() {
-  const workDir = getWorkingDirectory(void 0, true);
-  const logs = await getDailyLogs(workDir);
-  if (logs.length === 0) {
-    console.log("No daily logs found.");
-    return;
-  }
-  console.log("Daily Logs (.trie/memory/):\n");
-  for (const log of logs.slice(0, 14)) {
-    console.log(`  ${log}`);
-  }
-  if (logs.length > 14) {
-    console.log(`  ... and ${logs.length - 14} more`);
-  }
-}
-async function handleResolve(args) {
-  const issueId = args[0];
-  if (!issueId) {
-    console.log("Usage: trie memory resolve <issue-id>");
-    return;
-  }
-  const workDir = getWorkingDirectory(void 0, true);
-  const result = await markIssueResolved(issueId, workDir);
-  if (result) {
-    console.log(`Issue ${issueId} marked as resolved.`);
-  } else {
-    console.log(`Issue ${issueId} not found.`);
-  }
-}
-async function handleGlobal(args) {
-  const action = args[0]?.toLowerCase();
-  if (action === "patterns") {
-    const patterns = await findCrossProjectPatterns(2);
-    if (patterns.length === 0) {
-      console.log("No cross-project patterns found yet.");
-      console.log("Patterns appear when the same issue is detected in multiple projects.");
-      return;
-    }
-    console.log(`Cross-Project Patterns (${patterns.length}):
-`);
-    for (const p of patterns.slice(0, 10)) {
-      console.log(`[${p.severity.toUpperCase()}] ${p.pattern.slice(0, 60)}`);
-      console.log(`  Occurrences: ${p.occurrences} across ${p.projects.length} projects`);
-      console.log(`  Agent: ${p.agent}`);
-      if (p.fixApplied) {
-        console.log(`  Fixed in: ${p.fixApplied.project}`);
-      }
-      console.log("");
-    }
-    return;
-  }
-  if (action === "projects") {
-    const projects = await listTrackedProjects();
-    if (projects.length === 0) {
-      console.log("No projects tracked yet.");
-      return;
-    }
-    console.log(`Tracked Projects (${projects.length}):
-`);
-    console.log("| Project | Last Scan | Issues |");
-    console.log("|---------|-----------|--------|");
-    for (const p of projects) {
-      console.log(`| ${p.name.slice(0, 20)} | ${p.lastScan.split("T")[0]} | ${p.totalIssues} |`);
-    }
-    return;
-  }
-  if (action === "search") {
-    const query = args.slice(1).join(" ");
-    if (!query) {
-      console.log("Usage: trie memory global search <query>");
-      return;
-    }
-    const patterns = await searchGlobalPatterns(query, { limit: 10 });
-    if (patterns.length === 0) {
-      console.log(`No global patterns found matching "${query}"`);
-      return;
-    }
-    console.log(`Global patterns matching "${query}":
-`);
-    for (const p of patterns) {
-      console.log(`[${p.severity.toUpperCase()}] ${p.pattern.slice(0, 60)}`);
-      console.log(`  Projects: ${p.projects.slice(0, 3).join(", ")}`);
-      console.log("");
-    }
-    return;
-  }
-  if (action === "update") {
-    await updateGlobalMemoryMd();
-    console.log("Updated ~/.trie/memory/GLOBAL_MEMORY.md");
-    return;
-  }
-  console.log(`
-Global Memory Commands:
-  trie memory global patterns   Show cross-project patterns
-  trie memory global projects   Show tracked projects
-  trie memory global search <q> Search global patterns
-  trie memory global update     Update GLOBAL_MEMORY.md
-`);
-}
-async function handlePurge(args) {
-  const strategy = args[0]?.toLowerCase() || "smart";
-  const validStrategies = ["smart", "resolved", "old", "all"];
-  if (!validStrategies.includes(strategy)) {
-    console.log("Invalid purge strategy. Use: smart, resolved, old, or all");
-    console.log("\nUsage:");
-    console.log("  trie memory purge smart      - Remove resolved & old low-priority (recommended)");
-    console.log("  trie memory purge resolved   - Remove all resolved issues");
-    console.log("  trie memory purge old [days] - Remove issues older than N days (default 90)");
-    console.log("  trie memory purge all        - Clear all issues (keeps summaries)");
-    return;
-  }
-  const daysOld = strategy === "old" ? parseInt(args[1] || "90", 10) : void 0;
-  if (strategy === "all") {
-    console.log("\u26A0\uFE0F  WARNING: This will clear ALL issues from active memory.");
-    console.log("Historical summaries will be preserved, but individual issues will be removed.");
-    console.log("\nTo confirm, run: trie memory purge all --confirm");
-    if (!args.includes("--confirm")) {
-      return;
-    }
-  }
-  const workDir = getWorkingDirectory(void 0, true);
-  console.log(`
-Purging issues with strategy: ${strategy}...`);
-  const options = { workDir };
-  if (daysOld !== void 0) {
-    options.daysOld = daysOld;
-  }
-  const result = await purgeIssues(strategy, options);
-  console.log(`
-\u2705 Purge Complete`);
-  console.log(`  Strategy: ${result.strategy}`);
-  console.log(`  Removed: ${result.removed} issues`);
-  console.log(`  Remaining: ${result.remaining} issues`);
-  switch (strategy) {
-    case "smart":
-      console.log("\nWhat was removed:");
-      console.log("  \u2022 Resolved issues older than 30 days");
-      console.log("  \u2022 Low-priority issues (info/low) older than 30 days");
-      console.log("\nWhat was kept:");
-      console.log("  \u2022 All critical and high severity issues");
-      console.log("  \u2022 All unresolved issues");
-      console.log("  \u2022 All issues from the last 30 days");
-      break;
-    case "resolved":
-      console.log("\nRemoved all resolved issues.");
-      console.log("Kept all unresolved issues.");
-      break;
-    case "old":
-      console.log(`
-Removed all issues older than ${daysOld} days.`);
-      console.log("Kept all recent issues.");
-      break;
-    case "all":
-      console.log("\nCleared all issues from active memory.");
-      console.log("Historical summaries preserved in .trie/memory/compacted-summaries.json");
-      break;
-  }
-  console.log('\nRun "trie memory stats" to see updated memory usage.');
-}
-function showHelp() {
-  console.log(`
-Memory - Search and manage issue memory
-
-Commands:
-  trie memory search <query>    Search issues by keyword
-  trie memory stats             Show memory statistics
-  trie memory recent [limit]    Show recent issues
-  trie memory logs              List daily log files
-  trie memory resolve <id>      Mark issue as resolved
-  trie memory purge <strategy>  Free up memory space
-  trie memory global <action>   Cross-project memory
-
-Purge Strategies:
-  smart      Remove resolved & old low-priority issues (recommended)
-  resolved   Remove all resolved issues
-  old [N]    Remove issues older than N days (default 90)
-  all        Clear all issues (keeps historical summaries)
-
-Examples:
-  trie memory search "SQL injection"
-  trie memory recent 20
-  trie memory purge smart
-  trie memory global patterns
-`);
-}
-
-// src/cli/check.ts
-function parseArgs(args) {
-  let mode = "full";
-  const filesFlag = args.find((a) => a.startsWith("--files="));
-  const parsedFiles = filesFlag ? filesFlag.replace("--files=", "").split(",").map((f) => f.trim()).filter(Boolean) : [];
-  if (args.includes("--quick") || args.includes("-q")) mode = "quick";
-  if (args.includes("--offline")) mode = "offline";
-  if (args.includes("--full")) mode = "full";
-  const result = { mode };
-  if (parsedFiles.length > 0) result.files = parsedFiles;
-  return result;
-}
-function printResult(result) {
-  console.log(`
-Risk: ${result.original.riskLevel.toUpperCase()} (${result.original.shouldBlock ? "block" : "allow"})`);
-  console.log(`Explanation: ${result.original.explanation}`);
-  console.log(`Recommendation: ${result.original.recommendation}`);
-  if (result.original.files?.length) {
-    console.log("\nHigh-risk files:");
-    for (const file of result.original.files.filter((f) => ["high", "critical"].includes(f.level))) {
-      console.log(`  - ${file.file}: ${file.reasons.join("; ")}`);
-    }
-  }
-  console.log("\nPlain-English summary:");
-  console.log(`  Summary: ${result.summary}`);
-  console.log(`  What I found: ${result.whatIFound}`);
-  console.log(`  How bad: ${result.howBad}`);
-  console.log(`  What to do: ${result.whatToDo}`);
-}
-async function handleCheckCommand(args) {
-  try {
-    const options = parseArgs(args);
-    const projectPath = getWorkingDirectory(void 0, true);
-    let files = options.files;
-    if (!files || files.length === 0) {
-      const perception = await perceiveCurrentChanges(projectPath);
-      files = perception.diffSummary.files.map((f) => f.filePath);
-      if (files.length === 0) {
-        console.log("No changes detected. Provide files with --files=path1,path2 or make a change first.");
-        return;
-      }
-    }
-    const runAgents = options.mode === "full";
-    const reasoning = await reasonAboutChangesHumanReadable(projectPath, files, {
-      runAgents,
-      scanContext: {
-        config: { timeoutMs: options.mode === "quick" ? 15e3 : 6e4 }
-      }
-    });
-    printResult(reasoning);
-  } catch (error) {
-    const friendly = formatFriendlyError(error);
-    console.error(friendly.userMessage);
-  }
-}
-
-// src/cli/pre-push.ts
-import pc from "picocolors";
-function parseArgs2(args) {
-  return {
-    block: args.includes("--block"),
-    bypassed: args.includes("--bypassed"),
-    quick: args.includes("--quick") || args.includes("-q")
-  };
-}
-async function handlePrePushCommand(args) {
-  const options = parseArgs2(args);
-  const projectPath = getWorkingDirectory(void 0, true);
-  try {
-    const autonomyConfig = await getAutonomyConfig(projectPath);
-    if (options.bypassed) {
-      console.error(pc.yellow("Pre-push check bypassed by user"));
-      if (autonomyConfig.pushBlocking.logBypasses) {
-        await recordBypass(
-          projectPath,
-          "git-push",
-          void 0,
-          "pre-push-bypass",
-          "env",
-          "User set TRIE_BYPASS=1"
-        );
-      }
-      process.exit(0);
-    }
-    const perception = await perceiveCurrentChanges(projectPath);
-    const files = perception.diffSummary.files.map((f) => f.filePath);
-    if (files.length === 0) {
-      console.error(pc.green("\u2713 No changes to check"));
-      process.exit(0);
-    }
-    console.error(pc.cyan(`
-\u{1F50D} Checking ${files.length} file(s) before push...
-`));
-    const reasoning = await reasonAboutChangesHumanReadable(projectPath, files, {
-      runAgents: !options.quick,
-      scanContext: {
-        config: { timeoutMs: options.quick ? 15e3 : 3e4 }
-      }
-    });
-    if (options.block && autonomyConfig.pushBlocking.enabled) {
-      const issues = collectIssuesForBlocking(reasoning);
-      for (const issue of issues) {
-        await trackIssueOccurrence(
-          projectPath,
-          issue.file,
-          issue.line,
-          issue.severity,
-          autonomyConfig
-        );
-      }
-      const blockResult = shouldBlockPush(issues, autonomyConfig);
-      if (blockResult.blocked) {
-        console.error("");
-        console.error(pc.red("\u2501".repeat(60)));
-        console.error(pc.bold(pc.red("PUSH BLOCKED")));
-        console.error(pc.red("\u2501".repeat(60)));
-        console.error("");
-        console.error(pc.yellow(`Found ${blockResult.blockingIssues.length} blocking issue(s):`));
-        console.error("");
-        for (const issue of blockResult.blockingIssues.slice(0, 5)) {
-          const icon = issue.severity === "critical" ? "[!]" : "[!]";
-          console.error(`  ${icon} ${pc.dim(issue.file)}${issue.line ? `:${issue.line}` : ""}`);
-          console.error(`     ${issue.issue.slice(0, 80)}${issue.issue.length > 80 ? "..." : ""}`);
-        }
-        if (blockResult.blockingIssues.length > 5) {
-          console.error(`  ... and ${blockResult.blockingIssues.length - 5} more`);
-        }
-        console.error("");
-        console.error(pc.dim("\u2500".repeat(60)));
-        if (blockResult.bypassInstructions) {
-          console.error("");
-          console.error(pc.yellow("To bypass (not recommended):"));
-          for (const line of blockResult.bypassInstructions.split("\n")) {
-            console.error(pc.dim(line));
-          }
-        }
-        console.error("");
-        console.error(pc.cyan("To fix issues:"));
-        console.error(pc.dim("  trie fix        # Auto-fix trivial issues"));
-        console.error(pc.dim("  trie check      # See all issues"));
-        console.error("");
-        process.exit(2);
-      } else if (blockResult.bypassed) {
-        console.error(pc.yellow(`Bypassed: ${blockResult.blockingIssues.length} issue(s) ignored`));
-      }
-    }
-    const riskLevel = reasoning.original?.riskLevel || "low";
-    const riskColor = riskLevel === "critical" ? pc.red : riskLevel === "high" ? pc.yellow : riskLevel === "medium" ? pc.blue : pc.green;
-    console.error("");
-    console.error(riskColor(`Risk: ${riskLevel.toUpperCase()}`));
-    console.error(pc.dim(reasoning.summary || "No significant risks detected"));
-    console.error("");
-    process.exit(0);
-  } catch (error) {
-    const friendly = formatFriendlyError(error);
-    console.error(pc.yellow(`Pre-push check error: ${friendly.userMessage}`));
-    console.error(pc.dim("Allowing push to continue."));
-    process.exit(0);
-  }
-}
-function collectIssuesForBlocking(reasoning) {
-  const issues = [];
-  if (reasoning.original?.files) {
-    for (const file of reasoning.original.files) {
-      if (file.level === "critical" || file.level === "high") {
-        issues.push({
-          file: file.file,
-          severity: file.level === "critical" ? "critical" : "serious",
-          issue: file.reasons?.join("; ") || "High-risk file"
-        });
-      }
-    }
-  }
-  if (reasoning.scanResults?.issues) {
-    for (const issue of reasoning.scanResults.issues) {
-      if (issue.severity === "critical" || issue.severity === "serious") {
-        issues.push({
-          file: issue.file,
-          line: issue.line,
-          severity: issue.severity,
-          issue: issue.issue
-        });
-      }
-    }
-  }
-  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";
-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)
-  };
-}
-async function handlePreCommitCommand(_args) {
-  console.log(pc2.cyan("\u{1F50D} Running pre-commit hook..."));
-  console.log(pc2.dim("Checking ledger for issues in staged files...\n"));
-  try {
-    const { execSync } = await import("child_process");
-    const workDir = getWorkingDirectory(void 0, true);
-    let stagedFiles;
-    try {
-      const output = execSync("git diff --cached --name-only --diff-filter=ACMR", {
-        cwd: workDir,
-        encoding: "utf-8"
-      });
-      stagedFiles = output.trim().split("\n").filter(Boolean);
-      if (stagedFiles.length === 0) {
-        console.log(pc2.green("\u2713 No staged files to check"));
-        process.exit(0);
-      }
-      console.log(pc2.dim(`Checking ${stagedFiles.length} staged file(s)...
-`));
-    } catch (error) {
-      console.error(pc2.yellow("\u26A0 Could not get staged files, skipping pre-commit check"));
-      process.exit(0);
-    }
-    const { searchIssues: searchIssues2 } = await import("../issue-store-ZIRP23EP.js");
-    let criticalIssues = 0;
-    let totalIssues = 0;
-    const issuesByFile = /* @__PURE__ */ new Map();
-    for (const file of stagedFiles) {
-      const results = await searchIssues2(file, {
-        workDir,
-        limit: 100,
-        includeResolved: false
-        // Only unresolved issues
-      });
-      if (results.length > 0) {
-        totalIssues += results.length;
-        const issues = results.map((r) => ({
-          severity: r.issue.severity,
-          issue: r.issue.issue
-        }));
-        const critical = issues.filter((i) => i.severity === "critical").length;
-        criticalIssues += critical;
-        issuesByFile.set(file, issues);
-      }
-    }
-    if (criticalIssues > 0) {
-      console.log(pc2.red(`\u2717 Found ${criticalIssues} critical issue(s) in staged files
-`));
-      for (const [file, issues] of issuesByFile.entries()) {
-        const critical = issues.filter((i) => i.severity === "critical");
-        if (critical.length > 0) {
-          console.log(pc2.red(`  ${file}:`));
-          for (const issue of critical) {
-            console.log(pc2.dim(`    \u2022 ${issue.issue.slice(0, 80)}...`));
-          }
-          console.log();
-        }
-      }
-      console.log(pc2.dim("Fix critical issues before committing, or use:"));
-      console.log(pc2.dim("  git commit --no-verify  (to skip this check)\n"));
-      process.exit(1);
-    } else if (totalIssues > 0) {
-      console.log(pc2.yellow(`\u26A0 Found ${totalIssues} non-critical issue(s) in staged files`));
-      console.log(pc2.dim("(Not blocking commit - only critical issues block commits)\n"));
-      process.exit(0);
-    } else {
-      console.log(pc2.green("\u2713 No issues found in staged files"));
-      console.log(pc2.dim("Commit allowed\n"));
-      process.exit(0);
-    }
-  } catch (error) {
-    console.error(pc2.red("Error in pre-commit hook:"), error);
-    console.log(pc2.yellow("\n\u26A0 Pre-commit check failed, but not blocking commit"));
-    console.log(pc2.dim("(Hook errors never block commits)\n"));
-    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: Get started!
-${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: "Use trie" for the menu, or "Use trie_fix" for fixes
-`);
-}
-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 existsSync4 } from "fs";
-import { createInterface } from "readline";
-import pc4 from "picocolors";
-
-// src/utils/auto-fix-apply.ts
-import { readFile, writeFile as writeFile2 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-async function applyAutoFix(fix) {
-  try {
-    if (!existsSync3(fix.file)) {
-      return false;
-    }
-    const content = await readFile(fix.file, "utf-8");
-    const lines = content.split("\n");
-    if (fix.line === void 0 || fix.line < 1 || fix.line > lines.length) {
-      return false;
-    }
-    const lineIndex = fix.line - 1;
-    let newContent;
-    if (fix.type === "remove-console-log" || fix.type === "remove-debugger" || fix.fixed === "") {
-      lines.splice(lineIndex, 1);
-      newContent = lines.join("\n");
-    } else if (fix.type === "remove-emoji") {
-      const emojiPattern = /[\u{1F300}-\u{1F9FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}]/gu;
-      lines[lineIndex] = lines[lineIndex].replace(emojiPattern, "");
-      newContent = lines.join("\n");
-    } else if (fix.fixed) {
-      lines[lineIndex] = fix.fixed;
-      newContent = lines.join("\n");
-    } else {
-      return false;
-    }
-    await writeFile2(fix.file, newContent);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/cli/auto-fix.ts
-function detectAutoFixes(issues) {
-  const fixes = [];
-  for (const issue of issues) {
-    const fix = generateFixForIssue(issue);
-    if (fix) {
-      fixes.push(fix);
-    }
-  }
-  return fixes;
-}
-function generateFixForIssue(issue) {
-  if (!issue.line) return null;
-  if (issue.issue.toLowerCase().includes("console.log") || issue.issue.toLowerCase().includes("console log")) {
-    return {
-      id: `fix-${issue.id}`,
-      file: issue.file,
-      line: issue.line,
-      original: "",
-      // Will be filled when reading file
-      fixed: "",
-      // Will be deletion
-      type: "remove-console-log",
-      category: "trivial",
-      description: "Remove console.log statement",
-      confidence: 0.95
-    };
-  }
-  if (issue.issue.toLowerCase().includes("debugger")) {
-    return {
-      id: `fix-${issue.id}`,
-      file: issue.file,
-      line: issue.line,
-      original: "",
-      fixed: "",
-      type: "remove-debugger",
-      category: "trivial",
-      description: "Remove debugger statement",
-      confidence: 0.98
-    };
-  }
-  return null;
-}
-async function promptUser(question) {
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stderr
-  });
-  return new Promise((resolve2) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve2(answer.toLowerCase().trim());
-    });
-  });
-}
-function displayFixPreview(fix, index, total) {
-  console.error("");
-  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(pc4.red("- " + fix.original));
-  }
-  if (fix.fixed) {
-    console.error(pc4.green("+ " + fix.fixed));
-  } else if (fix.original) {
-    console.error(pc4.dim("  (line will be removed)"));
-  }
-  console.error("");
-}
-async function loadFixContent(fixes) {
-  const enrichedFixes = [];
-  for (const fix of fixes) {
-    if (!fix.line || !existsSync4(fix.file)) {
-      continue;
-    }
-    try {
-      const content = await readFile2(fix.file, "utf-8");
-      const lines = content.split("\n");
-      const originalLine = lines[fix.line - 1];
-      if (originalLine) {
-        enrichedFixes.push({
-          ...fix,
-          original: originalLine
-        });
-      }
-    } catch {
-    }
-  }
-  return enrichedFixes;
-}
-async function handleAutoFixCommand(args, issues) {
-  const projectPath = getWorkingDirectory(void 0, true);
-  const config = await getAutonomyConfig(projectPath);
-  if (!config.autoFix.enabled) {
-    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(pc4.yellow("No issues provided. Run trie watch first, or use trie_fix via MCP."));
-    console.error(pc4.dim("  trie watch"));
-    return;
-  }
-  let fixes = detectAutoFixes(issues);
-  if (fixes.length === 0) {
-    console.error(pc4.green("\u2713 No auto-fixable issues found."));
-    return;
-  }
-  fixes = fixes.filter((fix) => shouldAutoFix(fix, config));
-  if (fixes.length === 0) {
-    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(pc4.yellow("Could not load fix content from files."));
-    return;
-  }
-  console.error("");
-  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 ${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);
-  }
-  for (const [cat, count] of byCategory) {
-    console.error(`  \u2022 ${cat}: ${count}`);
-  }
-  console.error("");
-  if (dryRun) {
-    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);
-    }
-    return;
-  }
-  if (config.autoFix.askFirst && !skipConfirm) {
-    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(pc4.dim("Cancelled."));
-      return;
-    }
-    if (response === "r" || response === "review") {
-      let applied2 = 0;
-      let skipped = 0;
-      for (let i = 0; i < fixes.length; i++) {
-        const fix = fixes[i];
-        displayFixPreview(fix, i, fixes.length);
-        const answer = await promptUser("Apply this fix? (y/n/q): ");
-        if (answer === "q" || answer === "quit") {
-          console.error(pc4.dim("Stopped."));
-          break;
-        }
-        if (answer === "y" || answer === "yes") {
-          const success = await applyAutoFix(fix);
-          if (success) {
-            console.error(pc4.green(`\u2713 Applied fix to ${fix.file}:${fix.line}`));
-            applied2++;
-          } else {
-            console.error(pc4.red(`\u2717 Failed to apply fix`));
-          }
-        } else {
-          console.error(pc4.dim("Skipped."));
-          skipped++;
-        }
-      }
-      console.error("");
-      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(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(pc4.green(`\u2713 Applied fix to ${fix.file}:${fix.line}`));
-      applied++;
-    } else {
-      console.error(pc4.red(`\u2717 Failed to apply fix to ${fix.file}:${fix.line}`));
-      failed++;
-    }
-  }
-  console.error("");
-  console.error(pc4.cyan("\u2501\u2501\u2501 Complete \u2501\u2501\u2501"));
-  console.error(`Applied: ${pc4.green(applied.toString())}`);
-  if (failed > 0) {
-    console.error(`Failed: ${pc4.red(failed.toString())}`);
-  }
-}
-
-// src/cli/goal.ts
-import pc5 from "picocolors";
-async function handleGoalCommand(args) {
-  const projectPath = getWorkingDirectory(void 0, true);
-  const projectState = getProjectState(projectPath);
-  await projectState.load();
-  const subcommand = args[0];
-  const restArgs = args.slice(1);
-  switch (subcommand) {
-    case "add":
-    case "create":
-      await addGoal(projectState, restArgs);
-      break;
-    case "list":
-    case "ls":
-      await listGoals(projectState);
-      break;
-    case "complete":
-    case "done":
-      await completeGoal(projectState, restArgs[0]);
-      break;
-    case "delete":
-    case "rm":
-      await deleteGoal(projectState, restArgs[0]);
-      break;
-    default:
-      if (subcommand && !subcommand.startsWith("-")) {
-        await addGoal(projectState, [subcommand, ...restArgs]);
-      } else {
-        printGoalHelp();
-      }
-  }
-}
-async function addGoal(projectState, args) {
-  const description = args.join(" ").replace(/^["']|["']$/g, "");
-  if (!description) {
-    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+)/);
-  const targetMatch = description.match(/--target[=\s](\d+)/);
-  const deadlineMatch = description.match(/--deadline[=\s](\S+)/);
-  let cleanDesc = description.replace(/--category[=\s]\w+/g, "").replace(/--target[=\s]\d+/g, "").replace(/--deadline[=\s]\S+/g, "").trim();
-  const reductionMatch = cleanDesc.match(/reduce.*?(\d+)%/i);
-  const eliminateMatch = cleanDesc.match(/eliminate|remove all|zero/i);
-  const streakMatch = cleanDesc.match(/(\d+)\s*days?\s*(streak|in a row|consecutive)/i);
-  let goalType = "custom";
-  let target = 100;
-  let metric = "progress";
-  if (reductionMatch && reductionMatch[1]) {
-    goalType = "reduction";
-    target = parseInt(reductionMatch[1], 10);
-    metric = "reduction_percent";
-  } else if (eliminateMatch) {
-    goalType = "reduction";
-    target = 100;
-    metric = "elimination";
-  } else if (streakMatch && streakMatch[1]) {
-    goalType = "streak";
-    target = parseInt(streakMatch[1], 10);
-    metric = "days_streak";
-  }
-  if (targetMatch && targetMatch[1]) {
-    target = parseInt(targetMatch[1], 10);
-  }
-  const category = categoryMatch?.[1] || detectCategory(cleanDesc);
-  const deadline = /* @__PURE__ */ new Date();
-  if (deadlineMatch && deadlineMatch[1]) {
-    const days = parseInt(deadlineMatch[1], 10);
-    deadline.setDate(deadline.getDate() + (isNaN(days) ? 14 : days));
-  } else {
-    deadline.setDate(deadline.getDate() + 14);
-  }
-  const workDir = getWorkingDirectory(void 0, true);
-  const initialValue = await measureInitialGoalValue(cleanDesc, workDir);
-  const goal = {
-    id: `goal-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-    description: cleanDesc,
-    type: goalType,
-    metric,
-    target,
-    currentValue: initialValue,
-    startValue: initialValue,
-    status: "active",
-    autoGenerated: false,
-    // User-created
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    deadline: deadline.toISOString(),
-    category
-  };
-  await projectState.addGoal(goal);
-  console.error("");
-  console.error(pc5.green("\u2713 Goal created"));
-  console.error("");
-  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(pc5.dim(`Starting value: ${initialValue} issues found`));
-  }
-  console.error(pc5.dim(`Deadline: ${deadline.toLocaleDateString()}`));
-  console.error("");
-  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(pc5.dim("No goals yet."));
-    console.error(pc5.dim('Create one: trie goal add "Reduce auth issues by 50%"'));
-    return;
-  }
-  console.error("");
-  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(pc5.cyan("Active:"));
-    for (const goal of active) {
-      const progress = calculateGoalProgress(goal);
-      const bar = renderProgressBar(progress);
-      const source = goal.autoGenerated ? pc5.dim("[auto]") : pc5.dim("[manual]");
-      console.error(`  ${bar} ${goal.description} ${source}`);
-      console.error(pc5.dim(`     ID: ${goal.id} | ${progress}% complete`));
-    }
-    console.error("");
-  }
-  if (achieved.length > 0) {
-    console.error(pc5.green("Achieved:"));
-    for (const goal of achieved) {
-      console.error(`  [+] ${goal.description}`);
-    }
-    console.error("");
-  }
-  if (other.length > 0) {
-    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})`);
-    }
-  }
-}
-async function completeGoal(projectState, goalId) {
-  if (!goalId) {
-    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(pc5.red(`Goal not found: ${goalId}`));
-    return;
-  }
-  await projectState.updateGoal(goal.id, {
-    status: "achieved",
-    currentValue: goal.target,
-    achievedAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  console.error("");
-  console.error(pc5.green("Goal achieved!"));
-  console.error(pc5.bold(goal.description));
-  console.error("");
-}
-async function deleteGoal(projectState, goalId) {
-  if (!goalId) {
-    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(pc5.red(`Goal not found: ${goalId}`));
-    return;
-  }
-  await projectState.updateGoal(goal.id, { status: "rejected" });
-  console.error(pc5.dim(`Removed goal: ${goal.description}`));
-}
-function calculateGoalProgress(goal) {
-  if (goal.target <= 0) return 0;
-  const startValue = goal.startValue ?? goal.currentValue;
-  if (startValue > goal.target) {
-    const totalReduction = startValue - goal.target;
-    if (totalReduction === 0) return 100;
-    const actualReduction = startValue - goal.currentValue;
-    return Math.round(actualReduction / totalReduction * 100);
-  }
-  return Math.round(goal.currentValue / goal.target * 100);
-}
-function renderProgressBar(percent) {
-  const width = 10;
-  const clamped = Math.max(0, Math.min(100, percent));
-  const filled = Math.round(clamped / 100 * width);
-  const empty = width - filled;
-  return `[${pc5.green("\u2588".repeat(filled))}${pc5.gray("\u2591".repeat(empty))}]`;
-}
-function detectCategory(description) {
-  const lower = description.toLowerCase();
-  if (/security|auth|password|token|xss|sql|inject/i.test(lower)) return "security";
-  if (/quality|bug|issue|error|fix/i.test(lower)) return "quality";
-  if (/performance|speed|fast|slow|latency/i.test(lower)) return "performance";
-  if (/coverage|test|spec/i.test(lower)) return "coverage";
-  return "general";
-}
-function printGoalHelp() {
-  console.error("");
-  console.error(pc5.bold("trie goal - Manage guardian goals"));
-  console.error("");
-  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(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(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');
-  console.error("");
-}
-async function handleHypothesisCommand(args) {
-  const projectPath = getWorkingDirectory(void 0, true);
-  const projectState = getProjectState(projectPath);
-  await projectState.load();
-  const subcommand = args[0];
-  const restArgs = args.slice(1);
-  switch (subcommand) {
-    case "add":
-    case "create":
-      await addHypothesis(projectState, restArgs);
-      break;
-    case "list":
-    case "ls":
-      await listHypotheses(projectState);
-      break;
-    case "validate":
-      await validateHypothesis(projectState, restArgs[0]);
-      break;
-    case "invalidate":
-      await invalidateHypothesis(projectState, restArgs[0]);
-      break;
-    case "delete":
-    case "rm":
-      await deleteHypothesis(projectState, restArgs[0]);
-      break;
-    default:
-      if (subcommand && !subcommand.startsWith("-")) {
-        await addHypothesis(projectState, [subcommand, ...restArgs]);
-      } else {
-        printHypothesisHelp();
-      }
-  }
-}
-async function addHypothesis(projectState, args) {
-  const statement = args.join(" ").replace(/^["']|["']$/g, "");
-  if (!statement) {
-    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+)/);
-  const testMatch = statement.match(/--test[=\s]["']([^"']+)["']/);
-  let cleanStatement = statement.replace(/--category[=\s]\w+/g, "").replace(/--test[=\s]["'][^"']+["']/g, "").trim();
-  const category = categoryMatch?.[1] || detectHypothesisCategory(cleanStatement);
-  const testCriteria = testMatch?.[1] || generateTestCriteria(cleanStatement);
-  const hypothesis = {
-    id: `hypo-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-    statement: cleanStatement,
-    confidence: 0,
-    // No evidence yet
-    status: "testing",
-    evidence: [],
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    testCriteria,
-    category,
-    autoGenerated: false
-  };
-  await projectState.addHypothesis(hypothesis);
-  console.error("");
-  console.error(pc5.green("\u2713 Hypothesis created"));
-  console.error("");
-  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(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(pc5.dim("No hypotheses yet."));
-    console.error(pc5.dim('Create one: trie hypothesis add "Mondays have more bugs"'));
-    return;
-  }
-  console.error("");
-  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(pc5.cyan("Testing:"));
-    for (const hypo of testing) {
-      const conf = Math.round(hypo.confidence * 100);
-      const confColor = conf >= 70 ? pc5.green : conf >= 40 ? pc5.yellow : pc5.red;
-      console.error(`  [?] "${hypo.statement}" ${confColor(`(${conf}% confidence)`)}`);
-      console.error(pc5.dim(`     ID: ${hypo.id} | Evidence: ${hypo.evidence.length} points`));
-    }
-    console.error("");
-  }
-  if (validated.length > 0) {
-    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(pc5.red("Invalidated:"));
-    for (const hypo of invalidated) {
-      console.error(`  [X] "${hypo.statement}"`);
-    }
-  }
-}
-async function validateHypothesis(projectState, hypoId) {
-  if (!hypoId) {
-    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(pc5.red(`Hypothesis not found: ${hypoId}`));
-    return;
-  }
-  await projectState.updateHypothesis(hypo.id, {
-    status: "validated",
-    confidence: 0.9,
-    validatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  console.error(pc5.green(`Hypothesis validated: "${hypo.statement}"`));
-}
-async function invalidateHypothesis(projectState, hypoId) {
-  if (!hypoId) {
-    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(pc5.red(`Hypothesis not found: ${hypoId}`));
-    return;
-  }
-  await projectState.updateHypothesis(hypo.id, {
-    status: "invalidated",
-    confidence: 0.1
-  });
-  console.error(pc5.red(`Hypothesis invalidated: "${hypo.statement}"`));
-}
-async function deleteHypothesis(projectState, hypoId) {
-  if (!hypoId) {
-    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(pc5.red(`Hypothesis not found: ${hypoId}`));
-    return;
-  }
-  await projectState.updateHypothesis(hypo.id, { status: "retired" });
-  console.error(pc5.dim(`Removed hypothesis: "${hypo.statement}"`));
-}
-function detectHypothesisCategory(statement) {
-  const lower = statement.toLowerCase();
-  if (/monday|friday|weekend|morning|night|time|day|hour/i.test(lower)) return "timing";
-  if (/pattern|recurring|always|never|consistently/i.test(lower)) return "pattern";
-  if (/team|developer|engineer|review/i.test(lower)) return "team";
-  if (/code|file|function|class|module|refactor/i.test(lower)) return "code";
-  return "general";
-}
-function generateTestCriteria(statement) {
-  const lower = statement.toLowerCase();
-  if (lower.includes("monday")) {
-    return "Compare Monday issue counts to weekly average";
-  }
-  if (lower.includes("friday")) {
-    return "Compare Friday issue introduction rate to other days";
-  }
-  if (lower.includes("more bug") || lower.includes("more issue")) {
-    return "Compare issue counts between conditions over time";
-  }
-  if (lower.includes("causes") || lower.includes("leads to")) {
-    return "Track correlation between trigger and outcome events";
-  }
-  return "Collect supporting and contradicting evidence from scans";
-}
-function printHypothesisHelp() {
-  console.error("");
-  console.error(pc5.bold("trie hypothesis - Manage project hypotheses"));
-  console.error("");
-  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(pc5.cyan("Options for add:"));
-  console.error("  --category=timing|pattern|team|code|general");
-  console.error('  --test="<test criteria>"');
-  console.error("");
-  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"');
-  console.error("");
-}
+  cloudClient,
+  fetchDocuments,
+  fetchGraph,
+  fetchLedger,
+  fetchSignals,
+  getMachineFingerprint,
+  loadLocalConfig,
+  normalizeAndValidateApiBaseUrl,
+  persistAuthTokens,
+  revokeSession,
+  saveLocalConfig,
+  sessionCache
+} from "../chunk-QR64Y5TI.js";
 
-// src/cli/tell.ts
-import path3 from "path";
-function escalateRisk(level) {
-  if (level === "low") return "medium";
-  if (level === "medium") return "high";
-  if (level === "high") return "critical";
-  return "critical";
-}
-function extractFilePathsFromDescription(description) {
-  const matches = description.match(/[\\w./_-]+\\.(ts|tsx|js|jsx|mjs|cjs)/gi);
-  if (!matches) return [];
-  const unique = /* @__PURE__ */ new Set();
-  matches.forEach((m) => unique.add(m.replace(/^\.\/+/, "")));
-  return Array.from(unique);
-}
-async function handleTellCommand(args) {
-  try {
-    const projectPath = getWorkingDirectory(void 0, true);
-    const description = args.join(" ").trim();
-    if (!description) {
-      console.log('Usage: trie tell "<incident description>"');
-      return;
-    }
-    const graph = new ContextGraph(projectPath);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const change = (await graph.getRecentChanges(1))[0];
-    const incident = await graph.addNode("incident", {
-      description,
-      severity: "major",
-      affectedUsers: null,
-      duration: null,
-      timestamp: now,
-      resolved: false,
-      resolution: null,
-      fixChangeId: change?.id ?? null,
-      reportedVia: "manual"
-    });
-    const linkedFiles = /* @__PURE__ */ new Set();
-    if (change) {
-      await graph.addEdge(change.id, incident.id, "leadTo");
-      await graph.addEdge(incident.id, change.id, "causedBy");
-      for (const filePath of change.data.files) {
-        linkedFiles.add(filePath);
-        const fileNode = await graph.getNode("file", path3.resolve(projectPath, filePath));
-        if (fileNode) {
-          const data = fileNode.data;
-          await graph.updateNode("file", fileNode.id, {
-            incidentCount: (data.incidentCount ?? 0) + 1,
-            riskLevel: escalateRisk(data.riskLevel)
-          });
-        }
-      }
-    }
-    const mentionedFiles = extractFilePathsFromDescription(description);
-    mentionedFiles.forEach((f) => linkedFiles.add(f));
-    const incidentIndex = new IncidentIndex(graph, projectPath);
-    incidentIndex.addIncidentToTrie(incident, Array.from(linkedFiles));
-    await exportToJson(graph);
-    console.log("Incident recorded.");
-    if (change) {
-      console.log(`Linked to change: ${change.id}`);
-    } else {
-      console.log("No recent change found; incident recorded without linkage.");
-    }
-  } catch (error) {
-    const friendly = formatFriendlyError(error);
-    console.error(friendly.userMessage);
-  }
-}
+// src/cli/main.ts
+import { mkdir, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
 
-// src/cli/linear.ts
-async function handleLinearCommand(args) {
-  try {
-    const subcommand = args[0]?.toLowerCase();
-    const workDir = getWorkingDirectory(void 0, true);
-    if (subcommand === "auth") {
-      const apiKey = args[1];
-      if (!apiKey) {
-        console.log("Usage: trie linear auth <your-linear-api-key>");
-        return;
-      }
-      const config = await loadConfig();
-      if (!config.apiKeys) {
-        config.apiKeys = {};
-      }
-      config.apiKeys.linear = apiKey;
-      await saveConfig(config);
-      console.log("Linear API key saved successfully.");
-      return;
-    }
-    if (subcommand === "sync") {
-      const graph = new ContextGraph(workDir);
-      const ingester = new LinearIngester(workDir, graph);
-      console.log("Syncing Linear tickets...");
-      await ingester.syncTickets();
-      console.log("Linear tickets synced successfully.");
-      return;
-    }
-    console.log("Usage:");
-    console.log("  trie linear auth <api-key>   Save Linear API key");
-    console.log("  trie linear sync             Sync active tickets");
-  } catch (error) {
-    const friendly = formatFriendlyError(error);
-    console.error(friendly.userMessage);
-  }
+// src/cloud/teams.ts
+async function listTeams() {
+  const data = await cloudClient.request("/api/teams");
+  return data.teams || data.items || [];
 }
-
-// src/cli/gotcha.ts
-import picocolors from "picocolors";
-async function handleGotchaCommand() {
-  try {
-    const workDir = getWorkingDirectory(void 0, true);
-    const graph = new ContextGraph(workDir);
-    const predictor = new GotchaPredictor(workDir, graph);
-    console.log('Analyzing current changes for "gotchas"...');
-    const staged = await getStagedChanges(workDir);
-    const uncommitted = await getUncommittedChanges(workDir);
-    const allChanges = [...staged, ...uncommitted].map((c) => c.path);
-    const uniqueFiles = Array.from(new Set(allChanges));
-    if (uniqueFiles.length === 0) {
-      console.log("No changes detected to analyze.");
-      return;
-    }
-    const gotchas = await predictor.predictGotchas(uniqueFiles);
-    if (gotchas.length === 0) {
-      console.log(picocolors.green('\u2713 No "gotchas" predicted for your current changes.'));
-      return;
-    }
-    console.log(picocolors.yellow(`
-Found ${gotchas.length} potential "gotchas":
-`));
-    const storage = getStorage(workDir);
-    await storage.initialize();
-    const primaryFile = uniqueFiles[0];
-    for (const gotcha of gotchas) {
-      const ledgerGotcha = {
-        id: gotcha.id,
-        message: gotcha.message,
-        confidence: gotcha.confidence,
-        riskLevel: gotcha.riskLevel,
-        recommendation: gotcha.recommendation,
-        ...primaryFile && { file: primaryFile },
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        ...gotcha.precedentId && { precedentId: gotcha.precedentId },
-        tags: gotcha.evidence.matchingPatterns,
-        evidence: gotcha.evidence,
-        resolved: false
-      };
-      await storage.storeGotcha(ledgerGotcha);
-    }
-    for (const gotcha of gotchas) {
-      const color = gotcha.riskLevel === "critical" ? picocolors.red : gotcha.riskLevel === "high" ? picocolors.yellow : picocolors.blue;
-      console.log(color(`[${gotcha.riskLevel.toUpperCase()}] ${gotcha.message}`));
-      const explanation = await predictor.synthesizeGotchaExplanation(gotcha);
-      if (explanation !== gotcha.message) {
-        console.log(picocolors.dim(`  ${explanation}`));
-      }
-      console.log(picocolors.cyan(`  \u{1F4A1} Recommendation: ${gotcha.recommendation}`));
-      console.log("");
-    }
-    console.log(picocolors.dim(`Stored ${gotchas.length} gotcha(s) in Ledger. View in: trie watch \u2192 Ledger tab`));
-  } catch (error) {
-    const friendly = formatFriendlyError(error);
-    console.error(friendly.userMessage);
+async function switchTeam(teamId) {
+  const data = await cloudClient.request("/api/teams/switch", {
+    method: "POST",
+    body: JSON.stringify({ teamId })
+  });
+  const confirmedTeamId = data.team?.id;
+  if (confirmedTeamId && confirmedTeamId !== teamId) {
+    throw new Error("Server returned mismatched team selection.");
+  }
+  const cfg = await loadLocalConfig();
+  const nextConfig = {
+    ...cfg,
+    activeTeamId: confirmedTeamId || teamId
+  };
+  if (data.team?.name) {
+    nextConfig.activeTeamName = data.team.name;
+  }
+  await saveLocalConfig(nextConfig);
+}
+
+// src/auth/browser-login.ts
+import { createServer } from "http";
+import { spawn } from "child_process";
+import crypto2 from "crypto";
+
+// src/auth/pkce.ts
+import crypto from "crypto";
+function base64Url(input) {
+  return input.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function generateCodeVerifier() {
+  return base64Url(crypto.randomBytes(64));
+}
+function generateCodeChallenge(verifier) {
+  return base64Url(crypto.createHash("sha256").update(verifier).digest());
+}
+function generateVerificationCode() {
+  const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+  const bytes = crypto.randomBytes(8);
+  let out = "";
+  for (const b of bytes) {
+    out += chars[b % chars.length];
+  }
+  return `${out.slice(0, 4)}-${out.slice(4)}`;
+}
+function generateStateParts() {
+  const nonce = base64Url(crypto.randomBytes(32));
+  const timestamp = Date.now().toString();
+  const payload = `${nonce}.${timestamp}`;
+  const secret = base64Url(crypto.randomBytes(32));
+  const sig = base64Url(crypto.createHmac("sha256", secret).update(payload).digest());
+  return { nonce: payload, secret, state: `${payload}.${sig}` };
+}
+function verifyState(state, secret, maxAgeMs = 5 * 6e4) {
+  const parts = state.split(".");
+  if (parts.length < 3) return false;
+  const ts = Number(parts[1]);
+  if (!Number.isFinite(ts) || Date.now() - ts > maxAgeMs) return false;
+  const payload = `${parts[0]}.${parts[1]}`;
+  const providedSig = parts.slice(2).join(".");
+  const expectedSig = base64Url(
+    crypto.createHmac("sha256", secret).update(payload).digest()
+  );
+  const a = Buffer.from(providedSig);
+  const b = Buffer.from(expectedSig);
+  if (a.length !== b.length) return false;
+  return crypto.timingSafeEqual(a, b);
+}
+
+// src/auth/browser-login.ts
+function openUrl(url) {
+  const command = process.platform === "win32" ? "start" : process.platform === "darwin" ? "open" : "xdg-open";
+  spawn(command, [url], { stdio: "ignore", detached: true }).unref();
+}
+var CALLBACK_MAX_BODY_BYTES = 64 * 1024;
+var ALLOWED_ORIGINS = /* @__PURE__ */ new Set(["https://trie.dev", "https://www.trie.dev"]);
+var RequestError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
   }
-}
-
-// src/cli/learn.ts
-import picocolors2 from "picocolors";
-async function handleLearnCommand(args) {
+};
+function writeCors(res, origin) {
+  res.setHeader("Access-Control-Allow-Origin", origin);
+  res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+}
+function parseContentLength(req) {
+  const header = req.headers["content-length"];
+  if (!header) return null;
+  const first = Array.isArray(header) ? header[0] : header;
+  const parsed = Number(first);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new RequestError("Invalid content length", 400);
+  }
+  return parsed;
+}
+async function readJsonBody(req) {
+  const contentLength = parseContentLength(req);
+  if (contentLength !== null && contentLength > CALLBACK_MAX_BODY_BYTES) {
+    throw new RequestError("Payload too large", 413);
+  }
+  const chunks = [];
+  let seenBytes = 0;
+  for await (const chunk of req) {
+    const buffer = Buffer.from(chunk);
+    chunks.push(buffer);
+    seenBytes += buffer.length;
+    if (seenBytes > CALLBACK_MAX_BODY_BYTES) {
+      throw new RequestError("Payload too large", 413);
+    }
+  }
+  const text = Buffer.concat(chunks).toString("utf-8");
   try {
-    const workDir = getWorkingDirectory(void 0, true);
-    const engine = new LearningEngine(workDir);
-    const firstArg = args[0]?.toLowerCase();
-    if (firstArg === "ok" || firstArg === "good") {
-      const note = args.slice(1).join(" ");
-      const staged = await getStagedChanges(workDir);
-      const files = staged.map((s) => s.path);
-      await engine.learn({
-        manualFeedback: { helpful: true, files, note }
-      });
-      console.log(picocolors2.green("\u{1F44D} Learned that this pattern is good."));
-      if (files.length > 0) {
-        console.log(picocolors2.dim(`   Linked to: ${files.join(", ")}`));
-      }
-      return;
-    }
-    if (firstArg === "bad" || firstArg === "wrong") {
-      const note = args.slice(1).join(" ");
-      const staged = await getStagedChanges(workDir);
-      const files = staged.map((s) => s.path);
-      await engine.learn({
-        manualFeedback: { helpful: false, files, note }
-      });
-      console.log(picocolors2.yellow("\u{1F44E} Learned that this pattern is problematic."));
-      if (files.length > 0) {
-        console.log(picocolors2.dim(`   Linked to: ${files.join(", ")}`));
-      }
-      return;
-    }
-    console.log(picocolors2.cyan("Scanning history for implicit failure signals (reverts/fixes)..."));
-    const results = await engine.learn({ limit: 50 });
-    const implicit = results.find((r) => r.source === "git-history");
-    console.log(picocolors2.green(`\u2713 Learned ${implicit?.learned ?? 0} new cases from your git history.`));
-    console.log(picocolors2.dim("  Trie will now use these precedents to predict future gotchas."));
-  } catch (error) {
-    const friendly = formatFriendlyError(error);
-    console.error(friendly.userMessage);
-  }
-}
-
-// src/cli/sync.ts
-import pc6 from "picocolors";
-import { Command } from "commander";
-function createSyncCommand() {
-  const sync = new Command("sync").description("Sync ledger with shared storage");
-  sync.command("init").description("Initialize shared ledger storage").action(async () => {
-    try {
-      const workDir = getWorkingDirectory(void 0, true);
-      console.log(`Initializing shared ledger in ${workDir}...`);
-      await initializeSharedLedger();
-      console.log(pc6.green("\u2713 Shared ledger initialized successfully"));
-    } catch (error) {
-      console.error(pc6.red("Failed to initialize shared ledger:"), error);
-      process.exit(1);
-    }
-  });
-  sync.command("pull").description("Pull updates from shared ledger").action(async () => {
-    try {
-      console.log("Syncing from shared ledger...");
-      const hasLegacy = await detectLegacyLedger();
-      if (hasLegacy) {
-        console.log("Detected legacy ledger, migrating...");
-        await migrateLegacyLedger();
-      }
-      const result = await syncLedgerFromShared();
-      console.log(pc6.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('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);
-      process.exit(1);
-    }
-  });
-  sync.command("push").description("Push local changes to shared ledger").action(async () => {
-    try {
-      console.log("Pushing to shared ledger...");
-      const hasLegacy = await detectLegacyLedger();
-      if (hasLegacy) {
-        console.log("Detected legacy ledger, migrating...");
-        await migrateLegacyLedger();
-      }
-      await pushLedgerToShared();
-      console.log(pc6.green("\u2713 Push completed"));
-    } catch (error) {
-      console.error(pc6.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"));
-      if (!status.isInitialized) {
-        console.log(pc6.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(`Local blocks: ${pc6.cyan(status.localBlocks.toString())}`);
-      console.log(`Shared blocks: ${pc6.cyan(status.sharedBlocks.toString())}`);
-      if (status.syncState) {
-        const lastSync = new Date(status.syncState.lastSyncTimestamp);
-        console.log(`Last sync: ${pc6.dim(lastSync.toLocaleString())}`);
-        if (status.conflicts > 0) {
-          console.log(pc6.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"));
+    return text ? JSON.parse(text) : {};
+  } catch {
+    throw new RequestError("Invalid JSON body", 400);
+  }
+}
+async function loginWithBrowser() {
+  const cfg = await loadLocalConfig();
+  const apiBaseUrl = normalizeAndValidateApiBaseUrl(cfg.apiBaseUrl);
+  const verifier = generateCodeVerifier();
+  const challenge = generateCodeChallenge(verifier);
+  const { state, secret } = generateStateParts();
+  const code = generateVerificationCode();
+  const callbackToken = crypto2.randomBytes(16).toString("hex");
+  const callbackPath = `/callback/${callbackToken}`;
+  let used = false;
+  let timeout;
+  let closeServer;
+  const tokenPromise = new Promise((resolve, reject) => {
+    const server = createServer(async (req, res) => {
+      const reqOrigin = req.headers.origin || "";
+      const originAllowed = ALLOWED_ORIGINS.has(reqOrigin);
+      if (originAllowed) {
+        writeCors(res, reqOrigin);
+      }
+      if (req.method === "OPTIONS") {
+        if (!originAllowed) {
+          res.statusCode = 403;
+          res.end("Invalid origin");
+          return;
         }
-      }
-      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")}`);
-      }
-    } catch (error) {
-      console.error(pc6.red("Failed to get sync status:"), error);
-      process.exit(1);
-    }
-  });
-  sync.command("migrate").description("Migrate legacy ledger to new format").action(async () => {
-    try {
-      const hasLegacy = await detectLegacyLedger();
-      if (!hasLegacy) {
-        console.log(pc6.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"));
-      } else {
-        console.log(pc6.red("Migration failed"));
-        process.exit(1);
-      }
-    } catch (error) {
-      console.error(pc6.red("Failed to migrate legacy ledger:"), error);
-      process.exit(1);
-    }
-  });
-  sync.command("hooks").description("Manage git hooks for automatic sync").option("--install", "Install git hooks").option("--status", "Check git hooks status").action(async (options) => {
-    try {
-      if (options.install) {
-        await installGitHooks2();
+        res.statusCode = 204;
+        res.end();
         return;
       }
-      const status = await checkGitHooks();
-      if (!status.isGitRepo) {
-        console.log(pc6.yellow("Not a git repository"));
+      if (used) {
+        res.statusCode = 403;
+        res.end("Callback already used");
         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")}`);
-      if (!status.prePushInstalled || !status.postMergeInstalled) {
-        console.log(`
-${pc6.yellow("\u{1F4A1} Tip:")} Run ${pc6.bold("trie sync hooks --install")} to install missing hooks`);
-      }
-    } catch (error) {
-      console.error(pc6.red("Failed to manage git hooks:"), error);
-      process.exit(1);
-    }
-  });
-  return sync;
-}
-
-// src/cli/ledger.ts
-import pc7 from "picocolors";
-import { Command as Command2 } from "commander";
-function createLedgerCommand() {
-  const ledger = new Command2("ledger").description("Manage and inspect the ledger");
-  ledger.command("verify").description("Verify ledger chain integrity and signatures").action(async () => {
-    try {
-      console.log("Verifying ledger chain...");
-      console.log("  \u2022 Checking block hashes");
-      console.log("  \u2022 Verifying Merkle roots");
-      console.log("  \u2022 Validating Ed25519 signatures");
-      const result = await verifyLedger();
-      if (result.valid) {
-        console.log(pc7.green("\u2713 Ledger chain is valid"));
-        console.log(pc7.dim("  All blocks, hashes, and signatures verified"));
-      } else {
-        console.log(pc7.red(`\u2717 Ledger chain is invalid: ${result.error}`));
-        process.exit(1);
-      }
-    } catch (error) {
-      console.error(pc7.red("Failed to verify ledger:"), error);
-      process.exit(1);
-    }
-  });
-  ledger.command("history").description("Show ledger history with author attribution").option("-l, --limit <number>", "Number of blocks to show", "10").action(async (options) => {
-    try {
-      const limit = parseInt(options.limit, 10);
-      const blocks = await getLedgerBlocks();
-      if (blocks.length === 0) {
-        console.log("No ledger blocks found");
+      if (req.method !== "POST" || req.url !== callbackPath) {
+        res.statusCode = 405;
+        res.end("Method not allowed");
         return;
       }
-      console.log(pc7.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}`)));
-        if (syncableBlock.author) {
-          console.log(`Author: ${pc7.dim(syncableBlock.author)}`);
-        }
-        if (syncableBlock.gitCommit) {
-          console.log(`Git: ${pc7.dim(syncableBlock.gitCommit.slice(0, 8))}`);
-        }
-        console.log(`Entries: ${block.entries.length}`);
-        console.log(`Hash: ${pc7.dim(block.blockHash.slice(0, 16))}...`);
-        const signedEntries = block.entries.filter((e) => e.signature);
-        if (signedEntries.length > 0) {
-          console.log(`Signed: ${pc7.green(`${signedEntries.length}/${block.entries.length}`)}`);
-        }
-        if (block.entries.length > 0) {
-          console.log("Issues:");
-          for (const entry of block.entries) {
-            const signatureIndicator = entry.signature ? pc7.green("\u2713") : pc7.dim("\u25CB");
-            console.log(`  ${signatureIndicator} ${entry.severity} - ${entry.file} (${entry.agent})`);
-          }
-        }
-        console.log("");
-      }
-    } catch (error) {
-      console.error(pc7.red("Failed to show ledger history:"), error);
-      process.exit(1);
-    }
-  });
-  ledger.command("stats").description("Show ledger statistics").action(async () => {
-    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())}`);
-      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())}`);
-        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`)}`);
-        }
-      }
-      if (blocks.length > 0) {
-        const firstBlock = blocks[0];
-        const lastBlock = blocks[blocks.length - 1];
-        if (firstBlock && lastBlock) {
-          console.log(`Date range: ${pc7.dim(`${firstBlock.date} to ${lastBlock.date}`)}`);
-        }
-      }
-      const authorCounts = /* @__PURE__ */ new Map();
-      for (const block of blocks) {
-        const syncableBlock = block;
-        if (syncableBlock.author) {
-          authorCounts.set(syncableBlock.author, (authorCounts.get(syncableBlock.author) || 0) + 1);
-        }
-      }
-      if (authorCounts.size > 0) {
-        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())}`);
-        }
-      }
-      const severityCounts = /* @__PURE__ */ new Map();
-      for (const block of blocks) {
-        for (const entry of block.entries) {
-          severityCounts.set(entry.severity, (severityCounts.get(entry.severity) || 0) + 1);
-        }
-      }
-      if (severityCounts.size > 0) {
-        console.log("\nIssues by severity:");
-        const severityOrder = ["critical", "high", "medium", "low", "info"];
-        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())}`);
-          }
-        }
-      }
-    } catch (error) {
-      console.error(pc7.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"));
-      if (!status.isInitialized) {
-        console.log(pc7.yellow("Shared ledger not initialized"));
+      if (!originAllowed) {
+        res.statusCode = 403;
+        res.end("Invalid origin");
         return;
       }
-      console.log(`Local blocks: ${pc7.cyan(status.localBlocks.toString())}`);
-      console.log(`Shared blocks: ${pc7.cyan(status.sharedBlocks.toString())}`);
-      const diff = status.sharedBlocks - status.localBlocks;
-      if (diff > 0) {
-        console.log(pc7.green(`\u2193 ${diff} blocks available to pull`));
-      } else if (diff < 0) {
-        console.log(pc7.blue(`\u2191 ${-diff} local blocks not yet pushed`));
-      } else {
-        console.log(pc7.green("\u2713 Local and shared ledgers are in sync"));
-      }
-      if (status.conflicts > 0) {
-        console.log(pc7.red(`\u26A0 ${status.conflicts} conflicts detected`));
-      }
-    } catch (error) {
-      console.error(pc7.red("Failed to diff ledgers:"), error);
-      process.exit(1);
-    }
-  });
-  ledger.command("compress").description("Manually compress and archive old blocks").action(async () => {
-    try {
-      const shouldRun = await shouldCompress();
-      if (!shouldRun) {
-        console.log("No compression needed at this time");
+      if (!(req.headers["content-type"] || "").includes("application/json")) {
+        res.statusCode = 400;
+        res.end("Invalid content type");
         return;
       }
-      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(`Space saved: ${result.sizeReduction}%`);
-      } else {
-        console.log("No blocks were archived");
-      }
-    } catch (error) {
-      console.error(pc7.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:"));
-      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`))}`);
-      if (stats.compressionRatio > 0) {
-        console.log(`  Compression ratio: ${pc7.green(`${stats.compressionRatio}%`)}`);
-      }
-      console.log(pc7.bold("\nData:"));
-      console.log(`  Total entries: ${pc7.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`);
-      }
-    } catch (error) {
-      console.error(pc7.red("Failed to get storage stats:"), error);
-      process.exit(1);
-    }
-  });
-  ledger.command("correct").description("Mark ledger entries as corrected (maintains immutability)").argument("<entry-ids...>", "Entry IDs to mark as corrected").option("-r, --reason <reason>", "Reason for the correction (required)").option("-t, --type <type>", "Correction type: corrected or false-positive", "corrected").action(async (entryIds, options) => {
-    try {
-      if (!options.reason) {
-        console.error(pc7.red("\u2717 Correction reason is required"));
-        console.log("");
-        console.log("Usage:");
-        console.log(`  ${pc7.dim('trie ledger correct <entry-id> -r "reason for correction"')}`);
-        console.log("");
-        console.log("Examples:");
-        console.log(`  ${pc7.dim('trie ledger correct abc123 -r "False positive - this is expected behavior"')}`);
-        console.log(`  ${pc7.dim('trie ledger correct xyz789 -r "Duplicate detection" -t false-positive')}`);
-        process.exit(1);
-      }
-      const validTypes = ["corrected", "false-positive"];
-      if (!validTypes.includes(options.type)) {
-        console.error(pc7.red(`\u2717 Invalid correction type: ${options.type}`));
-        console.log(`Valid types: ${validTypes.join(", ")}`);
-        process.exit(1);
-      }
-      console.log(pc7.yellow(`\u{1F4DD} Marking ${entryIds.length} entry(ies) as ${options.type}...`));
-      console.log(`Reason: ${pc7.dim(options.reason)}`);
-      console.log("");
-      const result = await correctLedgerEntries(
-        entryIds,
-        options.reason,
-        options.type
-      );
-      if (result.success) {
-        console.log(pc7.green(`\u2713 Successfully corrected ${result.correctedEntries} entry(ies)`));
-        console.log("");
-        console.log(pc7.dim("Note: Original entries remain in the ledger for audit trail."));
-        console.log(pc7.dim("      Queries will automatically filter out corrected entries."));
-      } else {
-        console.error(pc7.red("\u2717 Correction failed:"), result.error);
-        process.exit(1);
-      }
-    } catch (error) {
-      console.error(pc7.red("Failed to correct entries:"), error);
-      process.exit(1);
-    }
-  });
-  ledger.command("corrections").description("Show correction statistics and history").option("-e, --entries <ids...>", "Show correction history for specific entry IDs").action(async (options) => {
-    try {
-      if (options.entries && options.entries.length > 0) {
-        const history = await getEntryCorrectionHistory(options.entries);
-        if (history.size === 0) {
-          console.log("No correction history found for the specified entries");
+      try {
+        const body = await readJsonBody(req);
+        const returnedState = String(body.state || "");
+        const firebaseToken = String(body.firebase_token || "");
+        const verificationCode = String(body.code || "");
+        if (!verifyState(returnedState, secret)) {
+          res.statusCode = 403;
+          res.end("Invalid state");
           return;
         }
-        console.log(pc7.bold("Correction History\n"));
-        for (const [entryId, data] of history) {
-          console.log(pc7.bold(pc7.cyan(`Entry: ${entryId}`)));
-          console.log(`Status: ${pc7.yellow(data.original.status || "active")}`);
-          console.log(`File: ${pc7.dim(data.original.file)}`);
-          console.log(`Agent: ${pc7.dim(data.original.agent)}`);
-          if (data.original.correction) {
-            console.log(`Correction: ${data.original.correction}`);
-          }
-          if (data.original.correctionTimestamp) {
-            console.log(`Corrected at: ${pc7.dim(data.original.correctionTimestamp)}`);
-          }
-          if (data.corrections.length > 0) {
-            console.log("\nCorrection Entries:");
-            for (const correction of data.corrections) {
-              console.log(`  \u2022 ${correction.id} - ${correction.correction}`);
-            }
-          }
-          console.log("");
+        if (verificationCode && verificationCode !== code) {
+          res.statusCode = 403;
+          res.end("Invalid verification code");
+          return;
         }
-      } else {
-        const stats = await getCorrectionStats();
-        console.log(pc7.bold("Correction Statistics\n"));
-        console.log(`Total entries: ${pc7.cyan(stats.totalEntries.toString())}`);
-        console.log(`Active entries: ${pc7.green(stats.activeEntries.toString())}`);
-        console.log(`Corrected entries: ${pc7.yellow(stats.correctedEntries.toString())}`);
-        console.log(`False positives: ${pc7.yellow(stats.falsePositives.toString())}`);
-        console.log(`Correction rate: ${pc7.cyan(`${stats.correctionRate}%`)}`);
-        console.log("");
-        console.log(pc7.dim("\u{1F4A1} Tip: Use --entries <id> to see correction history for specific entries"));
-      }
-    } catch (error) {
-      console.error(pc7.red("Failed to show corrections:"), error);
-      process.exit(1);
-    }
+        used = true;
+        const exchangeRes = await fetch(`${apiBaseUrl}/api/auth/cli/exchange`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${firebaseToken}`
+          },
+          body: JSON.stringify({
+            firebase_token: firebaseToken,
+            code_verifier: verifier,
+            code_challenge: challenge,
+            machine_fingerprint: getMachineFingerprint()
+          })
+        });
+        if (!exchangeRes.ok) {
+          throw new Error(`Auth exchange failed (${exchangeRes.status})`);
+        }
+        const tokens = await exchangeRes.json();
+        await persistAuthTokens(tokens);
+        res.statusCode = 200;
+        res.end("Authorized. You can return to your terminal.");
+        resolve(tokens);
+      } catch (err) {
+        if (err instanceof RequestError) {
+          res.statusCode = err.statusCode;
+          res.end(err.message);
+        } else {
+          res.statusCode = 500;
+          res.end("Authorization failed");
+        }
+        reject(err);
+      } finally {
+        await closeServer?.();
+      }
+    }).listen(0, "127.0.0.1");
+    server.requestTimeout = 15e3;
+    server.headersTimeout = 1e4;
+    server.keepAliveTimeout = 5e3;
+    closeServer = async () => {
+      if (timeout) clearTimeout(timeout);
+      await new Promise((done) => server.close(() => done()));
+    };
+    server.on("listening", async () => {
+      const port = server.address().port;
+      const loginUrl = new URL("/cli-auth", "https://trie.dev");
+      loginUrl.searchParams.set("challenge", challenge);
+      loginUrl.searchParams.set("state", state);
+      loginUrl.searchParams.set("port", String(port));
+      loginUrl.searchParams.set("code", code);
+      loginUrl.searchParams.set("callback_path", callbackPath);
+      console.log(`Verification code: ${code}`);
+      console.log(`Opening browser: ${loginUrl.origin}${loginUrl.pathname}`);
+      openUrl(loginUrl.toString());
+    });
+    timeout = setTimeout(async () => {
+      await closeServer?.();
+      reject(new Error("Login timed out after 5 minutes."));
+    }, 5 * 6e4);
   });
-  return ledger;
-}
-
-// src/cli/keys.ts
-import pc8 from "picocolors";
-import { join as join3 } from "path";
-async function handleKeysCommand(args) {
-  const subcommand = args[0]?.toLowerCase() || "status";
-  const workDir = getWorkingDirectory(void 0, true);
-  switch (subcommand) {
-    case "generate":
-    case "create":
-    case "init":
-      await handleKeysGenerate(workDir, args.includes("--force") || args.includes("-f"));
-      break;
-    case "status":
-    case "info":
-      await handleKeysStatus(workDir);
-      break;
-    case "public":
-    case "pubkey":
-      await handleKeysPublic(workDir);
-      break;
-    case "help":
-    case "--help":
-    case "-h":
-      showKeysHelp();
-      break;
-    default:
-      console.error(pc8.red(`Unknown subcommand: ${subcommand}`));
-      showKeysHelp();
-      process.exit(1);
-  }
-}
-async function handleKeysGenerate(workDir, force) {
-  const hasKey = hasSigningKey(workDir);
-  if (hasKey && !force) {
-    console.log(pc8.yellow("Signing key already exists."));
-    console.log(pc8.dim("Use --force to regenerate (WARNING: will invalidate existing signatures)"));
-    const pubKey = getPublicKey(workDir);
-    if (pubKey) {
-      console.log(`
-Public key: ${pc8.cyan(pubKey.slice(0, 16))}...${pc8.cyan(pubKey.slice(-8))}`);
-    }
-    return;
-  }
-  if (hasKey && force) {
-    console.log(pc8.yellow("Regenerating signing key..."));
-    console.log(pc8.red("WARNING: This will invalidate all existing signatures in the ledger."));
-  }
-  console.log("Generating Ed25519 signing key pair...\n");
-  const keyPair = await generateKeyPair();
-  saveKeyPair(keyPair, workDir);
-  const keysDir = join3(getTrieDirectory(workDir), "keys");
-  console.log(pc8.green("\u2713 Signing key generated successfully\n"));
-  console.log(`Location: ${pc8.dim(keysDir)}`);
-  console.log(`Public key: ${pc8.cyan(keyPair.publicKey.slice(0, 16))}...${pc8.cyan(keyPair.publicKey.slice(-8))}`);
-  console.log(`Algorithm: ${pc8.dim("Ed25519")}
-`);
-  console.log(pc8.bold("What this means:"));
-  console.log("  \u2022 All new ledger entries will be signed automatically");
-  console.log("  \u2022 Signatures prove who created each entry");
-  console.log("  \u2022 Tampering with entries will be detectable");
-  console.log("  \u2022 Your private key stays local (never committed to git)\n");
-  console.log(pc8.yellow("Security notes:"));
-  console.log("  \u2022 The private key is stored in .trie/keys/signing-key.json");
-  console.log("  \u2022 This directory is automatically added to .gitignore");
-  console.log("  \u2022 Back up this key if you need to prove authorship later");
-  console.log("  \u2022 Team members each generate their own keys");
-}
-async function handleKeysStatus(workDir) {
-  const hasKey = hasSigningKey(workDir);
-  const keysDir = join3(getTrieDirectory(workDir), "keys");
-  console.log(pc8.bold("Signing Key Status\n"));
-  if (hasKey) {
-    const keyPair = loadKeyPair(workDir);
-    const keyPath = join3(keysDir, "signing-key.json");
-    console.log(`Status: ${pc8.green("\u2713 Active")}`);
-    console.log(`Location: ${pc8.dim(keyPath)}`);
-    if (keyPair) {
-      console.log(`Public key: ${pc8.cyan(keyPair.publicKey.slice(0, 16))}...${pc8.cyan(keyPair.publicKey.slice(-8))}`);
-    }
-    console.log(`Algorithm: ${pc8.dim("Ed25519")}`);
-    console.log(`
-New ledger entries will be ${pc8.green("signed automatically")}.`);
-  } else {
-    console.log(`Status: ${pc8.yellow("\u25CB Not configured")}`);
-    console.log(`
-Ledger entries are ${pc8.yellow("not being signed")}.`);
-    console.log(`
-To enable signing, run:`);
-    console.log(`  ${pc8.cyan("trie keys generate")}`);
-  }
-}
-async function handleKeysPublic(workDir) {
-  const pubKey = getPublicKey(workDir);
-  if (!pubKey) {
-    console.error(pc8.yellow("No signing key found."));
-    console.error(`Run ${pc8.cyan("trie keys generate")} to create one.`);
-    process.exit(1);
-  }
-  console.log(pubKey);
+  return tokenPromise;
 }
-function showKeysHelp() {
-  console.log(`
-${pc8.bold("trie keys")} - Manage Ed25519 signing keys for the governance ledger
-
-${pc8.bold("USAGE:")}
-  trie keys <command> [options]
-
-${pc8.bold("COMMANDS:")}
-  generate    Generate a new Ed25519 signing key pair
-  status      Show current key status (default)
-  public      Print the public key (for sharing/verification)
-  help        Show this help message
-
-${pc8.bold("OPTIONS:")}
-  --force, -f   Force regenerate key (WARNING: invalidates signatures)
-
-${pc8.bold("EXAMPLES:")}
-  trie keys                 # Check if signing is configured
-  trie keys generate        # Generate a new signing key
-  trie keys public          # Get your public key for verification
 
-${pc8.bold("ABOUT SIGNING:")}
-  Ed25519 signatures provide:
-  \u2022 ${pc8.green("Authenticity")} - Prove who created each ledger entry
-  \u2022 ${pc8.green("Tamper-evidence")} - Detect if entries are modified
-  \u2022 ${pc8.green("Accountability")} - Track decisions to humans or agents
-
-  Keys are stored locally in .trie/keys/ and never committed to git.
-  Each team member should generate their own key.
-`);
+// src/auth/sanitize.ts
+function scrubProcessArgv() {
+  process.argv = process.argv.map((arg) => {
+    if (arg.startsWith("--token=")) return "--token=[REDACTED]";
+    if (arg.startsWith("--access_token=")) return "--access_token=[REDACTED]";
+    return arg;
+  });
 }
 
 // src/cli/main.ts
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = dirname(__filename2);
-var DEFAULT_VERSION = "0.0.0";
-function getCliVersion() {
-  try {
-    const pkgPath = resolve(__dirname2, "..", "..", "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;
-  }
-}
-function showBanner() {
-  console.log(`
- \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
- \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D
-    \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557  
-    \u2588\u2588\u2551   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  
-    \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
-    \u255A\u2550\u255D   \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D
-  
-  Your decision ledger that travels
-
-  by Louis Kishfy
-
-  Download the Trie workspace: https://www.trie.dev
-  Follow me on X: https://x.com/louiskishfy
-`);
-}
-function showHelp2() {
-  showBanner();
-  console.log(`Version: ${getCliVersion()}
-
-USAGE:
-  trie <command> [options]
-
-COMMANDS:
-  init              Initialize Trie in your project
-  watch             Start watching (nudges as you code)
-                     Use screen/tmux to run in background
-  check             Run risk check before pushing
-  
-  tell "<incident>" Report an incident ("users can't log in")
-  learn             Train Trie from git history or feedback (alias: train)
-  ok                Mark current pattern as good (alias: learn ok)
-  bad               Mark current pattern as bad (alias: learn bad)
-  
-  linear sync       Sync active tickets from Linear
-  gotcha            Predict problems with current changes (alias: predict)
-
-  memory            Search and manage issue memory
-  status            Quick health check (project health + memory stats)
-  project           View/manage project info (.trie/PROJECT.md)
-  setup             Configure API key and environment
-  keys              Manage Ed25519 signing keys (for ledger signatures)
-  
-  help              Show this help message
-  version           Show version information
-
-EXAMPLES:
-  trie init                              # Initialize Trie in your project
-  trie watch                             # Start watching (nudges as you code)
-  trie watch                             # Run in background: screen -S trie-watch
-  
-  trie tell "users couldn't log in"      # Report an incident
-  trie ok                                # Mark current pattern as good
-  trie bad                               # Mark current pattern as bad
-  
-  trie linear sync                       # Sync active tickets from Linear
-  trie learn                             # Scan history for precedents
-  trie gotcha                            # Predict for current changes
-  
-  trie check                             # Risk check before pushing
-
-  trie memory search "SQL injection"
-  trie memory stats                      # View memory statistics
-  trie status                           # Quick health check (project + memory)
-
-MCP TOOLS (use via Cursor/Claude Desktop):
-  trie_linear_sync     Sync active tickets from Linear
-  trie_fix             Generate high-confidence fix prompts
-  trie_explain         Explain code, issues, or changes
-  trie_watch           Watch mode for autonomous reporting
-
-`);
-}
-function showVersion() {
-  showBanner();
-  console.error(`v${getCliVersion()}`);
-}
-async function handleStatusCommand() {
-  const workDir = getWorkingDirectory(void 0, true);
-  try {
-    const state = await loadContextState();
-    const memoryStats = await getMemoryStats(workDir);
-    console.log("\n\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");
-    console.log("\u2551                      PROJECT STATUS                              \u2551");
-    console.log("\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\n");
-    if (state.lastScan) {
-      const lastScanDate = new Date(state.lastScan.timestamp);
-      const daysAgo = Math.floor((Date.now() - lastScanDate.getTime()) / (1e3 * 60 * 60 * 24));
-      console.log(`
-${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(`
-${pc9.bold("Last Scan:")} Never ${pc9.dim("(run `trie watch` to get started)")}`);
-    }
-    console.log(`
-${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 ? 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(`
-   ${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(pc9.dim(`     ${severity}: ${count}`));
-        }
-      }
-    } else if (memoryStats.totalIssues > 0) {
-      console.log(`
-   ${pc9.green("\u25CF")} All issues have been resolved`);
-    }
-    if (cap.isAtCap) {
-      console.log(`
-${pc9.yellow("\u2B22 Warning:")} Memory at capacity - consider running: ${pc9.bold("trie memory purge smart")}`);
-    } else if (cap.percentFull >= 80) {
-      console.log(`
-${pc9.yellow("\u2B22 Notice:")} Memory usage high - consider running: ${pc9.bold("trie memory purge smart")}`);
-    }
-    console.log(`
-${pc9.bold("Quick Commands:")}`);
-    console.log(pc9.dim("   trie watch         - Start watching for nudges"));
-    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);
-    process.exit(1);
-  }
-}
-async function handleProject(args) {
-  const subcommand = args[0]?.toLowerCase();
-  const workDir = getWorkingDirectory(void 0, true);
-  if (subcommand === "init") {
-    const result = await initProjectInfo(workDir);
-    if (result.created) {
-      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                    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
-
-${pc9.bold("Path:")} ${result.path}
-
-A template has been created with sections for:
-  \u2022 Project Overview
-  \u2022 Technology Stack
-  \u2022 Architecture
-  \u2022 Coding Conventions
-  \u2022 Environment
-  \u2022 Team
-  \u2022 Compliance
-  \u2022 AI Instructions
-
-Next steps:
-  1. Edit the file to add your project details
-  2. The info will be available via trie://project resource
-  3. AI assistants will use this context automatically
-`);
-    } else {
-      console.log(`PROJECT.md already exists at: ${result.path}`);
-      console.log('Use "trie project" to view it.');
-    }
-    return;
-  }
-  if (subcommand === "edit") {
-    const editor = process.env.EDITOR || process.env.VISUAL || "nano";
-    const projectPath = join4(getTrieDirectory(workDir), "PROJECT.md");
-    if (!projectInfoExists(workDir)) {
-      console.log("No PROJECT.md found. Creating one first...");
-      await initProjectInfo(workDir);
-    }
-    const { spawn } = await import("child_process");
-    const child = spawn(editor, [projectPath], { stdio: "inherit" });
-    child.on("close", (code) => {
-      process.exit(code || 0);
-    });
-    return;
-  }
-  if (!projectInfoExists(workDir)) {
-    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                    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
-
-${pc9.bold("No PROJECT.md found in this project.")}
-
-COMMANDS:
-  trie project init    Create PROJECT.md from template
-  trie project edit    Open PROJECT.md in $EDITOR
-  trie project         View PROJECT.md contents
-
-WHAT IS PROJECT.MD?
-PROJECT.md stores important project context for AI assistants:
-  \u2022 Project description and purpose
-  \u2022 Technology stack and frameworks
-  \u2022 Architecture decisions
-  \u2022 Coding conventions
-  \u2022 Environment info (URLs, endpoints)
-  \u2022 Team ownership
-  \u2022 Compliance requirements
-  \u2022 Special instructions for AI
-
-This info is available via trie://project MCP resource.
-`);
-    return;
-  }
-  const content = await loadProjectInfo(workDir);
-  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                    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
+var CURSOR_RULE = `---
+description: Trie Cloud Context - proactive risk warnings
+globs: **/*
+alwaysApply: true
+---
+
+Before editing any file, call the trie_check_file MCP tool with the file path.
+If warnings are returned, summarize them before proceeding.
+Also read trie://context at conversation start.
+`;
+var CLAUDE_RULE = `## Trie Cloud Context
 
-${pc9.bold("Path:")} ${join4(getTrieDirectory(workDir), "PROJECT.md")}
+Before editing any file, call the trie_check_file MCP tool with the file path.
+If warnings are returned, summarize them before proceeding.
+Read trie://context at conversation start for hot zones and recent signals.
+`;
+function help() {
+  console.log(`Usage: trie <command>
 
-${"-".repeat(68)}
+Commands:
+  trie init
+  trie login
+  trie logout
+  trie teams [list|switch <teamId>]
+  trie pull [context|graph|signals|documents|ledger|all]
+  trie status
 `);
-  console.log(content);
-}
-async function runWatch(args) {
-  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 executor = daemonPath.endsWith(".ts") ? "npx" : "node";
-  const execArgs = daemonPath.endsWith(".ts") ? ["tsx", daemonPath, ...args] : [daemonPath, ...args];
-  const child = spawn(executor, execArgs, {
-    stdio: "inherit",
-    env: process.env
-  });
-  child.on("close", (code) => {
-    process.exit(code || 0);
-  });
 }
-async function main() {
-  const args = process.argv.slice(2);
-  const command = args[0]?.toLowerCase();
-  const restArgs = args.slice(1);
-  if (!command || command === "help" || command === "--help" || command === "-h") {
-    showHelp2();
-    process.exit(0);
-  }
-  const initRequired = !["init", "version", "--version", "-v"].includes(command);
-  if (initRequired) {
-    const workDir = getWorkingDirectory(void 0, true);
-    if (!isTrieInitialized(workDir)) {
-      console.error("Trie is not initialized for this project.");
-      console.error("Run `trie init` first.");
-      process.exit(1);
-    }
-  }
-  switch (command) {
-    case "setup":
-    case "config":
-    case "configure":
-      await handleSetupCommand(restArgs);
-      break;
-    case "init":
-    case "bootstrap":
-      handleInitCommand(restArgs);
-      break;
-    case "memory":
-    case "mem":
-      handleMemoryCommand(restArgs);
-      break;
-    case "status":
-    case "stats":
-      await handleStatusCommand();
-      break;
-    case "project":
-    case "info":
-    case "project-info":
-      handleProject(restArgs);
-      break;
-    case "version":
-    case "--version":
-    case "-v":
-      showVersion();
-      break;
-    case "watch":
-      runWatch(restArgs);
-      break;
-    case "check":
-      handleCheckCommand(restArgs);
-      break;
-    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":
-      handleAutoFixCommand(restArgs);
-      break;
-    case "goal":
-    case "goals":
-      handleGoalCommand(restArgs);
-      break;
-    case "hypothesis":
-    case "hypo":
-    case "hypotheses":
-      handleHypothesisCommand(restArgs);
-      break;
-    case "tell":
-      handleTellCommand(restArgs);
-      break;
-    case "learn":
-    case "train":
-      handleLearnCommand(restArgs);
-      break;
-    case "ok":
-    case "thumbs-up":
-      handleLearnCommand(["ok", ...restArgs]);
-      break;
-    case "bad":
-    case "thumbs-down":
-      handleLearnCommand(["bad", ...restArgs]);
-      break;
-    case "linear":
-      handleLinearCommand(restArgs);
-      break;
-    case "gotcha":
-    case "predict":
-      handleGotchaCommand();
-      break;
-    case "sync":
-      {
-        const syncCommand = createSyncCommand();
-        syncCommand.parse(["node", "trie", "sync", ...restArgs], { from: "user" });
-      }
-      break;
-    case "ledger":
+async function cmdInit() {
+  const rulesDir = join(process.cwd(), ".cursor", "rules");
+  await mkdir(rulesDir, { recursive: true });
+  await writeFile(join(rulesDir, "trie.mdc"), CURSOR_RULE, "utf-8");
+  const claudePath = join(process.cwd(), "CLAUDE.md");
+  if (existsSync(claudePath)) {
+    const append = `
+
+${CLAUDE_RULE}`;
+    await writeFile(claudePath, append, { encoding: "utf-8", flag: "a" });
+  }
+  console.log("Proactive warnings enabled in Cursor and Claude Code.");
+}
+async function cmdLogin() {
+  const tokens = await loginWithBrowser();
+  console.log(
+    `Logged in${tokens.user?.email ? ` as ${tokens.user.email}` : ""}${tokens.team?.name ? ` (team: ${tokens.team.name})` : ""}`
+  );
+}
+async function cmdLogout() {
+  const cfg = await loadLocalConfig();
+  await revokeSession(cfg.apiBaseUrl);
+  console.log("Logged out.");
+}
+async function cmdTeams(args) {
+  if (args[0] === "switch" && args[1]) {
+    await switchTeam(args[1]);
+    console.log(`Switched to team ${args[1]}`);
+    return;
+  }
+  const teams = await listTeams();
+  console.log(JSON.stringify(teams, null, 2));
+}
+async function cmdPull(args) {
+  const what = args[0] || "all";
+  const out = {};
+  if (what === "context" || what === "all") {
+    out.context = await Promise.all([fetchGraph(), fetchSignals(20), fetchDocuments()]);
+  }
+  if (what === "graph" || what === "all") out.graph = await fetchGraph();
+  if (what === "signals" || what === "all") out.signals = await fetchSignals(20);
+  if (what === "documents" || what === "all") out.documents = await fetchDocuments();
+  if (what === "ledger" || what === "all") out.ledger = await fetchLedger();
+  console.log(JSON.stringify(out, null, 2));
+}
+async function cmdStatus() {
+  const cfg = await loadLocalConfig();
+  console.log(
+    JSON.stringify(
       {
-        const ledgerCommand = createLedgerCommand();
-        ledgerCommand.parse(["node", "trie", "ledger", ...restArgs], { from: "user" });
-      }
-      break;
-    case "keys":
-    case "key":
-    case "signing":
-      await handleKeysCommand(restArgs);
-      break;
-    default:
-      if (command.startsWith("-")) {
-        const { spawn } = __require("child_process");
-        const daemonPath = resolve(__dirname2, "yolo-daemon.js");
-        const child = spawn("node", [daemonPath, ...args], {
-          stdio: "inherit",
-          env: process.env
-        });
-        child.on("close", (code) => {
-          process.exit(code || 0);
-        });
-      } else {
-        console.error(`Unknown command: ${command}`);
-        console.error(`Run 'trie help' for usage information.`);
-        process.exit(1);
-      }
-  }
-}
-var isEntryPoint = (() => {
-  const entry = process.argv[1];
-  if (!entry) return false;
-  try {
-    const realEntry = realpathSync(entry);
-    const realThis = fileURLToPath(import.meta.url);
-    return realEntry === realThis;
-  } catch {
-    return !process.env.VITEST && !process.env.VITEST_WORKER_ID;
-  }
-})();
-if (isEntryPoint) {
-  main().catch((error) => {
-    console.error("Error:", error);
-    process.exit(1);
-  });
+        apiBaseUrl: cfg.apiBaseUrl,
+        activeTeamId: cfg.activeTeamId,
+        activeTeamName: cfg.activeTeamName,
+        userEmail: cfg.userEmail,
+        cache: sessionCache.stats()
+      },
+      null,
+      2
+    )
+  );
 }
-export {
-  handleStatusCommand
-};
+async function main() {
+  scrubProcessArgv();
+  const [, , cmd, ...args] = process.argv;
+  if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
+    help();
+    return;
+  }
+  if (cmd === "init") return cmdInit();
+  if (cmd === "login") return cmdLogin();
+  if (cmd === "logout") return cmdLogout();
+  if (cmd === "teams") return cmdTeams(args);
+  if (cmd === "pull") return cmdPull(args);
+  if (cmd === "status") return cmdStatus();
+  throw new Error(`Unknown command: ${cmd}`);
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});
 //# sourceMappingURL=main.js.map