@triedotdev/mcp 1.0.166 → 1.0.168

package/dist/cli/main.js

@@ -7,29 +7,27 @@ import {
   loadProjectInfo,
   needsBootstrap,
   projectInfoExists
-} from "../chunk-ZBXW244P.js";
+} from "../chunk-HVCDY3AK.js";
 import {
   LinearIngester
-} from "../chunk-OLNZJ3XV.js";
+} from "../chunk-Q63FFI6D.js";
 import {
   LearningEngine,
   formatFriendlyError,
-  handleCheckpointCommand,
   isTrieInitialized,
   perceiveCurrentChanges,
   reasonAboutChangesHumanReadable
-} from "../chunk-LG5CBK6A.js";
+} from "../chunk-YZ6Y2H3P.js";
 import {
   measureInitialGoalValue
-} from "../chunk-ZKKKLRZZ.js";
+} from "../chunk-5BRRRTN6.js";
 import {
-  exportToJson,
-  importFromJson
+  exportToJson
 } from "../chunk-OBQ74FOU.js";
 import {
   loadConfig,
   saveConfig
-} from "../chunk-GDWA3CH3.js";
+} from "../chunk-XPZZFPBZ.js";
 import {
   IncidentIndex
 } from "../chunk-TN5WEKWI.js";
@@ -42,7 +40,7 @@ import {
   listTrackedProjects,
   searchGlobalPatterns,
   updateGlobalMemoryMd
-} from "../chunk-TQOO6A4G.js";
+} from "../chunk-7WITSO22.js";
 import "../chunk-SY6KQG44.js";
 import "../chunk-OMR4YCBS.js";
 import {
@@ -51,7 +49,7 @@ import {
 import "../chunk-6NLHFIYA.js";
 import {
   getStorage
-} from "../chunk-LR5M4RTN.js";
+} from "../chunk-575YT2SD.js";
 import "../chunk-FQ45QP5A.js";
 import {
   getDailyLogs,
@@ -60,37 +58,20 @@ import {
   markIssueResolved,
   purgeIssues,
   searchIssues
-} from "../chunk-S36IO3EE.js";
-import {
-  getProjectState
-} from "../chunk-GTKYBOXL.js";
-import "../chunk-EFWVF6TI.js";
-import {
-  getAutonomyConfig,
-  recordBypass,
-  shouldAutoFix,
-  shouldBlockPush,
-  trackIssueOccurrence
-} from "../chunk-ME2OERF5.js";
+} from "../chunk-XE6KQRKZ.js";
 import {
   compressOldBlocks,
   correctLedgerEntries,
   detectLegacyLedger,
-  formatAuditLog,
   generateKeyPair,
-  getAuditStatistics,
   getCorrectionStats,
   getEntryCorrectionHistory,
   getLedgerBlocks,
   getLedgerSyncStatus,
   getPublicKey,
-  getRecentAuditLogs,
-  getStagedChanges,
   getStorageStats,
-  getUncommittedChanges,
   hasSigningKey,
   initializeSharedLedger,
-  isGitRepo,
   loadKeyPair,
   migrateLegacyLedger,
   pushLedgerToShared,
@@ -98,22 +79,38 @@ import {
   shouldCompress,
   syncLedgerFromShared,
   verifyLedger
-} from "../chunk-MVVPJ73K.js";
+} 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 join6, dirname } from "path";
+import { resolve, join as join4, dirname } from "path";
 import { readFileSync as readFileSync2, realpathSync } from "fs";
 import { fileURLToPath } from "url";
-import pc10 from "picocolors";
+import pc9 from "picocolors";
 
 // src/hooks/install.ts
 import fs from "fs";
@@ -838,7 +835,7 @@ async function handlePrePushCommand(args) {
         console.error("");
         console.error(pc.cyan("To fix issues:"));
         console.error(pc.dim("  trie fix        # Auto-fix trivial issues"));
-        console.error(pc.dim("  trie scan       # See all issues"));
+        console.error(pc.dim("  trie check      # See all issues"));
         console.error("");
         process.exit(2);
       } else if (blockResult.bypassed) {
@@ -994,7 +991,7 @@ async function handlePreCommitCommand(_args) {
       console.error(pc2.yellow("\u26A0 Could not get staged files, skipping pre-commit check"));
       process.exit(0);
     }
-    const { searchIssues: searchIssues2 } = await import("../issue-store-UZAPI5DU.js");
+    const { searchIssues: searchIssues2 } = await import("../issue-store-ZIRP23EP.js");
     let criticalIssues = 0;
     let totalIssues = 0;
     const issuesByFile = /* @__PURE__ */ new Map();
@@ -2032,300 +2029,6 @@ async function handleTellCommand(args) {
   }
 }
 
-// src/cli/reconcile.ts
-import path4 from "path";
-async function removeOrphanEdges(graph) {
-  const nodes = await graph.listNodes();
-  const nodeIds = new Set(nodes.map((n) => n.id));
-  const edges = await graph.listEdges();
-  let removed = 0;
-  for (const edge of edges) {
-    if (!nodeIds.has(edge.from_id) || !nodeIds.has(edge.to_id)) {
-      await graph.deleteEdge(edge.id);
-      removed++;
-    }
-  }
-  return removed;
-}
-async function handleReconcileCommand(args) {
-  try {
-    const projectPath = getWorkingDirectory(void 0, true);
-    const source = args.find((a) => a.startsWith("--from="))?.replace("--from=", "") ?? path4.join(getTrieDirectory(projectPath), "context.json");
-    const graph = new ContextGraph(projectPath);
-    await importFromJson(graph, "", source);
-    const removed = await removeOrphanEdges(graph);
-    console.log(`Reconciled context from ${source}. Removed ${removed} orphaned edges.`);
-  } catch (error) {
-    const friendly = formatFriendlyError(error);
-    console.error(friendly.userMessage);
-  }
-}
-
-// src/cli/quiet.ts
-import fs3 from "fs";
-import path5 from "path";
-async function handleQuietCommand() {
-  const projectPath = getWorkingDirectory(void 0, true);
-  const quietPath = path5.join(getTrieDirectory(projectPath), "quiet.json");
-  const until = new Date(Date.now() + 60 * 60 * 1e3).toISOString();
-  const payload = { until };
-  try {
-    const dir = path5.dirname(quietPath);
-    fs3.mkdirSync(dir, { recursive: true });
-    fs3.writeFileSync(quietPath, JSON.stringify(payload, null, 2));
-    console.log("\u{1F515} Nudges snoozed for 1 hour.");
-  } catch (error) {
-    console.error("Failed to set quiet mode:", error);
-  }
-}
-
-// src/cli/ci.ts
-import { writeFileSync, existsSync as existsSync5, mkdirSync } from "fs";
-import { join as join3 } from "path";
-import pc6 from "picocolors";
-var WORKFLOW_TEMPLATE = `# Trie Security Scan with Memory Persistence
-# Generated by: trie ci
-# 
-# This workflow scans your code and caches Trie's memory
-# across runs for cross-run learning and pattern recognition.
-
-name: Trie Security Scan
-
-on:
-  push:
-    branches: [main, master, develop]
-  pull_request:
-    branches: [main, master]
-
-jobs:
-  security-scan:
-    runs-on: ubuntu-latest
-    permissions:
-      security-events: write
-      pull-requests: write
-      contents: read
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      # Restore Trie memory from previous runs
-      # This enables cross-run learning and pattern recognition
-      - name: Restore Trie Memory
-        uses: actions/cache@v4
-        with:
-          path: |
-            .trie/memory
-            .trie/context
-            .trie/summaries
-          key: trie-memory-\${{ github.repository }}-\${{ github.ref_name }}
-          restore-keys: |
-            trie-memory-\${{ github.repository }}-
-            trie-memory-
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-
-      - name: Install Trie
-        run: npm install -g @triedotdev/mcp
-
-      - name: Run Security Scan
-        run: |
-          trie scan --format sarif --output trie-results.sarif
-        env:
-          ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
-
-      - name: Upload SARIF Results
-        uses: github/codeql-action/upload-sarif@v3
-        if: always()
-        with:
-          sarif_file: trie-results.sarif
-        continue-on-error: true
-
-      # Memory is automatically saved by cache action on job completion
-`;
-var WORKFLOW_MINIMAL = `# Trie Security Scan (Minimal)
-# Generated by: trie ci --minimal
-
-name: Trie Scan
-
-on: [push, pull_request]
-
-jobs:
-  scan:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      
-      # Cache Trie memory for cross-run learning
-      - uses: actions/cache@v4
-        with:
-          path: .trie/memory
-          key: trie-memory-\${{ github.repository }}
-      
-      - run: npm install -g @triedotdev/mcp
-      - run: trie scan
-        env:
-          ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
-`;
-function handleCISetupCommand(args) {
-  const workDir = getWorkingDirectory(void 0, true);
-  const workflowsDir = join3(workDir, ".github", "workflows");
-  const workflowPath = join3(workflowsDir, "trie-scan.yml");
-  const isMinimal = args.includes("--minimal") || args.includes("-m");
-  const isDryRun = args.includes("--dry-run") || args.includes("-n");
-  const showHelp3 = args.includes("--help") || args.includes("-h");
-  if (showHelp3) {
-    console.log(`
-${pc6.bold("trie ci")} - Generate GitHub Actions workflow with memory caching
-
-${pc6.bold("USAGE:")}
-  trie ci [options]
-
-${pc6.bold("OPTIONS:")}
-  --minimal, -m    Generate minimal workflow (simpler, fewer features)
-  --dry-run, -n    Preview workflow without creating files
-  --help, -h       Show this help
-
-${pc6.bold("WHAT IT DOES:")}
-  Creates .github/workflows/trie-scan.yml that:
-  
-  1. ${pc6.green("Caches Trie memory")} - Patterns and fixes persist across runs
-  2. ${pc6.green("Enables learning")} - Trie remembers issues from previous PRs
-  3. ${pc6.green("Tracks patterns")} - Detects recurring issues across your codebase
-  4. ${pc6.green("SARIF upload")} - Results appear in GitHub Security tab
-
-${pc6.bold("MEMORY BENEFITS:")}
-  \u2022 "This issue was introduced 3 PRs ago"
-  \u2022 "Similar issue was fixed in PR #42"
-  \u2022 "This pattern keeps recurring in auth code"
-  \u2022 Trend tracking: improving, stable, or declining
-
-${pc6.bold("EXAMPLES:")}
-  trie ci               # Generate full workflow
-  trie ci --minimal     # Generate simple workflow
-  trie ci --dry-run     # Preview without writing
-
-${pc6.bold("REQUIRED SECRETS:")}
-  ANTHROPIC_API_KEY     Your Anthropic API key (add in GitHub repo settings)
-`);
-    return;
-  }
-  const template = isMinimal ? WORKFLOW_MINIMAL : WORKFLOW_TEMPLATE;
-  if (isDryRun) {
-    console.log(pc6.bold("\nWorkflow Preview:\n"));
-    console.log(pc6.dim("\u2500".repeat(60)));
-    console.log(template);
-    console.log(pc6.dim("\u2500".repeat(60)));
-    console.log(pc6.dim("\nRun without --dry-run to create the file."));
-    return;
-  }
-  if (existsSync5(workflowPath)) {
-    console.log(pc6.yellow("Workflow already exists: .github/workflows/trie-scan.yml"));
-    console.log(pc6.dim("   Run with --dry-run to preview what would be written."));
-    console.log(pc6.dim("   Delete the existing file to regenerate."));
-    return;
-  }
-  if (!existsSync5(workflowsDir)) {
-    mkdirSync(workflowsDir, { recursive: true });
-  }
-  writeFileSync(workflowPath, template);
-  console.log(pc6.green("\u2713") + " Created .github/workflows/trie-scan.yml");
-  console.log("");
-  console.log(pc6.bold("Next steps:"));
-  console.log("");
-  console.log("  1. Add your Anthropic API key to GitHub Secrets:");
-  console.log(pc6.dim("     Settings \u2192 Secrets \u2192 Actions \u2192 New repository secret"));
-  console.log(pc6.dim("     Name: ANTHROPIC_API_KEY"));
-  console.log("");
-  console.log("  2. Commit and push:");
-  console.log(pc6.dim("     git add .github/workflows/trie-scan.yml"));
-  console.log(pc6.dim('     git commit -m "Add Trie security scan with memory"'));
-  console.log(pc6.dim("     git push"));
-  console.log("");
-  console.log(pc6.bold("Memory caching benefits:"));
-  console.log(pc6.dim("  \u2022 Trie learns from past scans"));
-  console.log(pc6.dim("  \u2022 Tracks issue trends over time"));
-  console.log(pc6.dim("  \u2022 Remembers when issues were introduced"));
-  console.log(pc6.dim("  \u2022 Recognizes recurring patterns"));
-}
-
-// src/cli/audit.ts
-async function handleAuditCommand(args) {
-  const [cmd, ...rest] = args;
-  switch (cmd) {
-    case "logs":
-    case "list": {
-      const limit = rest[0] ? parseInt(rest[0], 10) : 20;
-      const logs = await getRecentAuditLogs(limit);
-      if (logs.length === 0) {
-        console.log("\nNo audit logs found.");
-        console.log("Audit logs are created when tools execute commands.\n");
-        return;
-      }
-      console.log(`
-Recent Executions (last ${logs.length}):
-`);
-      for (const log of logs) {
-        console.log(formatAuditLog(log));
-        console.log("");
-      }
-      break;
-    }
-    case "stats":
-    case "statistics": {
-      const stats = await getAuditStatistics();
-      console.log("\n\u{1F4CA} Audit Statistics\n");
-      console.log(`Total executions: ${stats.totalExecutions}`);
-      console.log(`  \u2705 Successful: ${stats.successfulExecutions}`);
-      console.log(`  \u274C Failed: ${stats.failedExecutions}`);
-      console.log("");
-      console.log(`Unique tools executed: ${stats.uniqueSkills}`);
-      console.log("");
-      console.log(`Commands executed: ${stats.totalCommands}`);
-      if (stats.blockedCommands > 0) {
-        console.log(`  \u26A0\uFE0F  Blocked: ${stats.blockedCommands}`);
-      }
-      console.log("");
-      console.log(`Network calls: ${stats.totalNetworkCalls}`);
-      if (stats.blockedNetworkCalls > 0) {
-        console.log(`  \u26A0\uFE0F  Blocked: ${stats.blockedNetworkCalls}`);
-      }
-      console.log("");
-      if (stats.blockedCommands > 0 || stats.blockedNetworkCalls > 0) {
-        console.log("\u26A0\uFE0F  Some operations were blocked by security policies.");
-        console.log('Run "trie audit logs" to see details.\n');
-      }
-      break;
-    }
-    default: {
-      console.log(`
-Audit - View security audit logs
-
-Trie logs tool operations for security auditing. View what
-commands were executed and any blocked operations.
-
-Commands:
-  trie audit logs [count]        Show recent audit logs (default: 20)
-  trie audit stats               Show audit statistics
-
-Examples:
-  trie audit logs 50             Show last 50 executions
-  trie audit stats               View overall statistics
-
-Audit logs are stored in .trie/audit/ and include:
-  \u2022 Tool name and source
-  \u2022 Commands executed
-  \u2022 Network calls made
-  \u2022 Files accessed/modified
-  \u2022 Any blocked operations
-      `);
-    }
-  }
-}
-
 // src/cli/linear.ts
 async function handleLinearCommand(args) {
   try {
@@ -2467,334 +2170,8 @@ async function handleLearnCommand(args) {
   }
 }
 
-// src/cli/patterns.ts
-import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
-import { basename as basename2 } from "path";
-import picocolors3 from "picocolors";
-
-// src/patterns/saved-patterns.ts
-import { createHash } from "crypto";
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import { join as join4, basename } from "path";
-async function loadSavedPatterns(workDir) {
-  const patternsPath = join4(getTrieDirectory(workDir), "saved-patterns.json");
-  try {
-    if (existsSync6(patternsPath)) {
-      const content = await readFile3(patternsPath, "utf-8");
-      return JSON.parse(content);
-    }
-  } catch {
-  }
-  return [];
-}
-async function savePatternsToProject(patterns, workDir) {
-  const { mkdir: mkdir2 } = await import("fs/promises");
-  const patternsPath = join4(getTrieDirectory(workDir), "saved-patterns.json");
-  await mkdir2(getTrieDirectory(workDir), { recursive: true });
-  await writeFile3(patternsPath, JSON.stringify(patterns, null, 2));
-}
-async function savePatternToProject(pattern, workDir) {
-  const patterns = await loadSavedPatterns(workDir);
-  const existing = patterns.findIndex((p) => p.id === pattern.id);
-  if (existing >= 0) {
-    patterns[existing] = {
-      ...patterns[existing],
-      ...pattern,
-      occurrences: patterns[existing].occurrences + 1
-    };
-  } else {
-    patterns.push(pattern);
-  }
-  await savePatternsToProject(patterns, workDir);
-}
-function detectPatternType(target, workDir) {
-  const scoutNames = [
-    "security",
-    "legal",
-    "accessibility",
-    "bug-finding",
-    "architecture",
-    "types",
-    "clean",
-    "devops",
-    "performance",
-    "ux",
-    "design",
-    "production-ready",
-    "agent-smith"
-  ];
-  if (scoutNames.includes(target.toLowerCase())) {
-    return "detection-rule";
-  }
-  const fullPath = join4(workDir, target);
-  if (existsSync6(fullPath) || target.includes("/") || target.includes("*") || target.endsWith(".ts") || target.endsWith(".js")) {
-    return "file-structure";
-  }
-  return "code-pattern";
-}
-function generatePatternId(target, type) {
-  const hash = createHash("sha256").update(`${type}:${target}`).digest("hex").slice(0, 12);
-  return `${type}-${hash}`;
-}
-async function createSavedPattern(target, note, workDir) {
-  const projectName = basename(workDir);
-  const patternType = detectPatternType(target, workDir);
-  const savedPattern = {
-    id: generatePatternId(target, patternType),
-    type: patternType,
-    name: target,
-    description: note || `Pattern saved from ${projectName}`,
-    validated: false,
-    projects: [projectName],
-    occurrences: 1,
-    savedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    savedBy: projectName
-  };
-  if (patternType === "file-structure") {
-    savedPattern.filePatterns = [target];
-    savedPattern.architecture = {
-      structure: `Files matching ${target}`,
-      rationale: note || "File structure pattern that worked well"
-    };
-  } else if (patternType === "code-pattern") {
-    const issues = await searchIssues(target, { limit: 5 });
-    if (issues.length > 0) {
-      const latestIssue = issues[0];
-      savedPattern.codePattern = {
-        pattern: latestIssue?.issue.issue || target,
-        fix: latestIssue?.issue.fix || "Review and apply similar fix",
-        context: note || "Code pattern that worked well"
-      };
-    } else {
-      savedPattern.codePattern = {
-        pattern: target,
-        fix: "Review and apply similar fix",
-        context: note || "Code pattern that worked well"
-      };
-    }
-  } else if (patternType === "detection-rule") {
-    savedPattern.detectionRule = {
-      agent: target,
-      rule: `Detection rules from ${target} scout`,
-      severity: "moderate"
-    };
-  }
-  return savedPattern;
-}
-
-// src/cli/patterns.ts
-async function handlePatternsCommand(args) {
-  const subcommand = args[0]?.toLowerCase();
-  const workDir = getWorkingDirectory(void 0, true);
-  try {
-    switch (subcommand) {
-      case "save":
-        await handleSavePattern(args.slice(1), workDir);
-        break;
-      case "list":
-        await handleListPatterns(args.slice(1), workDir);
-        break;
-      case "export":
-        await handleExportPatterns(args.slice(1), workDir);
-        break;
-      case "import":
-        await handleImportPatterns(args.slice(1), workDir);
-        break;
-      case "validate":
-        await handleValidatePattern(args.slice(1), workDir);
-        break;
-      default:
-        showPatternsHelp();
-    }
-  } catch (error) {
-    const friendly = formatFriendlyError(error);
-    console.error(picocolors3.red(`Error: ${friendly.userMessage}`));
-    process.exit(1);
-  }
-}
-async function handleSavePattern(args, workDir) {
-  const target = args[0];
-  const note = args.slice(1).join(" ") || void 0;
-  if (!target) {
-    console.error(picocolors3.red("Usage: trie patterns save <target> [note]"));
-    console.log(picocolors3.dim("\nExamples:"));
-    console.log('  trie patterns save "path/to/file.ts" "Short note about why it worked"');
-    console.log('  trie patterns save "path/*" "Folder structure that worked well"');
-    console.log('  trie patterns save security "Scout that caught issues early"');
-    process.exit(1);
-  }
-  const savedPattern = await createSavedPattern(target, note, workDir);
-  await savePatternToProject(savedPattern, workDir);
-  console.log(picocolors3.green(`\u2713 Pattern saved: ${target}`));
-  if (note) {
-    console.log(picocolors3.dim(`  Note: ${note}`));
-  }
-  console.log(picocolors3.dim(`  Type: ${savedPattern.type}`));
-  console.log(picocolors3.dim(`  Export with: trie patterns export`));
-}
-async function handleListPatterns(args, workDir) {
-  const filter = args[0]?.toLowerCase();
-  const patterns = await loadSavedPatterns(workDir);
-  let filtered = patterns;
-  if (filter === "validated" || filter === "saved") {
-    filtered = patterns.filter((p) => filter === "validated" ? p.validated : true);
-  }
-  if (filtered.length === 0) {
-    console.log(picocolors3.yellow("No saved patterns found."));
-    console.log(picocolors3.dim("Save patterns with: trie patterns save <target> [note]"));
-    return;
-  }
-  console.log(picocolors3.bold(`
-\u{1F4CB} Saved Patterns (${filtered.length})
-`));
-  for (const pattern of filtered) {
-    const typeEmoji = {
-      "file-structure": "\u{1F4C1}",
-      "code-pattern": "\u{1F4BB}",
-      "detection-rule": "\u{1F50D}"
-    }[pattern.type] || "\u{1F4CC}";
-    console.log(`${typeEmoji} ${picocolors3.bold(pattern.name)}`);
-    console.log(`   Type: ${pattern.type}`);
-    if (pattern.description) {
-      console.log(`   ${picocolors3.dim(pattern.description)}`);
-    }
-    if (pattern.validated) {
-      console.log(`   ${picocolors3.green("\u2713 Validated")}`);
-      if (pattern.validationNotes) {
-        console.log(`   ${picocolors3.dim(pattern.validationNotes)}`);
-      }
-    }
-    console.log(`   Projects: ${pattern.projects.join(", ")}`);
-    console.log("");
-  }
-}
-async function handleExportPatterns(args, workDir) {
-  const outputPath = args[0] || "trie-patterns.json";
-  const filter = args[1]?.toLowerCase();
-  let patterns = await loadSavedPatterns(workDir);
-  if (filter === "validated" || filter === "saved") {
-    patterns = patterns.filter((p) => filter === "validated" ? p.validated : true);
-  }
-  if (patterns.length === 0) {
-    console.error(picocolors3.yellow("No patterns to export."));
-    return;
-  }
-  const exportData = {
-    version: "1.0",
-    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    exportedFrom: basename2(workDir),
-    patterns
-  };
-  await writeFile4(outputPath, JSON.stringify(exportData, null, 2));
-  console.log(picocolors3.green(`\u2713 Exported ${patterns.length} patterns to ${outputPath}`));
-  console.log(picocolors3.dim(`  Import to another project with: trie patterns import ${outputPath}`));
-}
-async function handleImportPatterns(args, workDir) {
-  const inputPath = args[0];
-  if (!inputPath) {
-    console.error(picocolors3.red("Usage: trie patterns import <path-to-patterns.json>"));
-    process.exit(1);
-  }
-  if (!existsSync7(inputPath)) {
-    console.error(picocolors3.red(`File not found: ${inputPath}`));
-    process.exit(1);
-  }
-  const content = await readFile4(inputPath, "utf-8");
-  const importData = JSON.parse(content);
-  if (!importData.patterns || !Array.isArray(importData.patterns)) {
-    console.error(picocolors3.red("Invalid pattern file format."));
-    process.exit(1);
-  }
-  const existingPatterns = await loadSavedPatterns(workDir);
-  const projectName = basename2(workDir);
-  let imported = 0;
-  let skipped = 0;
-  for (const pattern of importData.patterns) {
-    const existing = existingPatterns.find((p) => p.id === pattern.id);
-    if (existing) {
-      if (!existing.projects.includes(projectName)) {
-        existing.projects.push(projectName);
-      }
-      existing.occurrences++;
-      skipped++;
-    } else {
-      const newPattern = {
-        ...pattern,
-        projects: [...pattern.projects, projectName],
-        savedBy: importData.exportedFrom || "unknown"
-      };
-      existingPatterns.push(newPattern);
-      imported++;
-    }
-  }
-  await savePatternsToProject(existingPatterns, workDir);
-  console.log(picocolors3.green(`\u2713 Imported ${imported} new patterns`));
-  if (skipped > 0) {
-    console.log(picocolors3.dim(`  Updated ${skipped} existing patterns`));
-  }
-  console.log(picocolors3.dim(`  Total patterns: ${existingPatterns.length}`));
-}
-async function handleValidatePattern(args, workDir) {
-  const patternId = args[0];
-  const note = args.slice(1).join(" ") || "Validated - worked well";
-  if (!patternId) {
-    console.error(picocolors3.red("Usage: trie patterns validate <pattern-id> [note]"));
-    process.exit(1);
-  }
-  const patterns = await loadSavedPatterns(workDir);
-  const pattern = patterns.find((p) => p.id === patternId || p.name === patternId);
-  if (!pattern) {
-    console.error(picocolors3.red(`Pattern not found: ${patternId}`));
-    console.log(picocolors3.dim("List patterns with: trie patterns list"));
-    process.exit(1);
-  }
-  pattern.validated = true;
-  pattern.validationNotes = note;
-  await savePatternsToProject(patterns, workDir);
-  console.log(picocolors3.green(`\u2713 Pattern validated: ${pattern.name}`));
-  console.log(picocolors3.dim(`  Note: ${note}`));
-}
-function showPatternsHelp() {
-  console.log(`
-${picocolors3.bold("Pattern Management")}
-
-Save, validate, and share patterns that worked well across projects.
-
-${picocolors3.bold("Commands:")}
-  trie patterns save <target> [note]     Save a pattern (file, code, or scout)
-  trie patterns list [--validated]       List saved patterns
-  trie patterns export [file] [--validated]  Export patterns to JSON
-  trie patterns import <file>            Import patterns from JSON
-  trie patterns validate <id> [note]     Mark pattern as validated
-
-${picocolors3.bold("Examples:")}
-  # Save a file structure pattern
-  trie patterns save "path/*" "This folder structure worked well"
-
-  # Save a code pattern
-  trie patterns save path/to/file.ts "This error handling prevented bugs"
-
-  # Save a detection rule
-  trie patterns save security "This scout caught issues early"
-
-  # Validate a pattern
-  trie patterns validate pattern-abc123 "Worked great in production"
-
-  # Export validated patterns
-  trie patterns export patterns.json --validated
-
-  # Import to another project
-  cd ../another-project
-  trie patterns import ../source-project/patterns.json
-
-${picocolors3.dim("Patterns are saved in .trie/saved-patterns.json")}
-`);
-}
-
 // src/cli/sync.ts
-import pc7 from "picocolors";
+import pc6 from "picocolors";
 import { Command } from "commander";
 function createSyncCommand() {
   const sync = new Command("sync").description("Sync ledger with shared storage");
@@ -2803,9 +2180,9 @@ function createSyncCommand() {
       const workDir = getWorkingDirectory(void 0, true);
       console.log(`Initializing shared ledger in ${workDir}...`);
       await initializeSharedLedger();
-      console.log(pc7.green("\u2713 Shared ledger initialized successfully"));
+      console.log(pc6.green("\u2713 Shared ledger initialized successfully"));
     } catch (error) {
-      console.error(pc7.red("Failed to initialize shared ledger:"), error);
+      console.error(pc6.red("Failed to initialize shared ledger:"), error);
       process.exit(1);
     }
   });
@@ -2818,17 +2195,17 @@ function createSyncCommand() {
         await migrateLegacyLedger();
       }
       const result = await syncLedgerFromShared();
-      console.log(pc7.green("\u2713 Sync completed"));
+      console.log(pc6.green("\u2713 Sync completed"));
       console.log(`Merged ${result.stats.mergedBlocks} blocks`);
       if (result.conflicts.length > 0) {
-        console.log(pc7.yellow(`\u26A0 ${result.conflicts.length} conflicts detected`));
+        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(pc7.red("Failed to sync from shared ledger:"), error);
+      console.error(pc6.red("Failed to sync from shared ledger:"), error);
       process.exit(1);
     }
   });
@@ -2841,45 +2218,45 @@ function createSyncCommand() {
         await migrateLegacyLedger();
       }
       await pushLedgerToShared();
-      console.log(pc7.green("\u2713 Push completed"));
+      console.log(pc6.green("\u2713 Push completed"));
     } catch (error) {
-      console.error(pc7.red("Failed to push to shared ledger:"), 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(pc7.bold("Ledger Sync Status\n"));
+      console.log(pc6.bold("Ledger Sync Status\n"));
       if (!status.isInitialized) {
-        console.log(pc7.yellow('\u26A0 Shared ledger not initialized. Run "trie sync init" first.'));
+        console.log(pc6.yellow('\u26A0 Shared ledger not initialized. Run "trie sync init" first.'));
         return;
       }
       if (status.hasLegacyLedger) {
-        console.log(pc7.yellow('\u26A0 Legacy ledger detected. Run "trie sync pull" to migrate.'));
+        console.log(pc6.yellow('\u26A0 Legacy ledger detected. Run "trie sync pull" to migrate.'));
       }
-      console.log(`Local blocks: ${pc7.cyan(status.localBlocks.toString())}`);
-      console.log(`Shared blocks: ${pc7.cyan(status.sharedBlocks.toString())}`);
+      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: ${pc7.dim(lastSync.toLocaleString())}`);
+        console.log(`Last sync: ${pc6.dim(lastSync.toLocaleString())}`);
         if (status.conflicts > 0) {
-          console.log(pc7.yellow(`Conflicts: ${status.conflicts}`));
+          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(pc7.green("\u2713 No conflicts"));
+          console.log(pc6.green("\u2713 No conflicts"));
         }
       }
       if (status.manifest) {
         console.log(`
-Total entries: ${pc7.cyan(status.manifest.totalEntries.toString())}`);
-        console.log(`Compression: ${status.manifest.compressionConfig.enabled ? pc7.green("enabled") : pc7.red("disabled")}`);
+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(pc7.red("Failed to get sync status:"), error);
+      console.error(pc6.red("Failed to get sync status:"), error);
       process.exit(1);
     }
   });
@@ -2887,19 +2264,19 @@ Total entries: ${pc7.cyan(status.manifest.totalEntries.toString())}`);
     try {
       const hasLegacy = await detectLegacyLedger();
       if (!hasLegacy) {
-        console.log(pc7.yellow("No legacy ledger found to migrate"));
+        console.log(pc6.yellow("No legacy ledger found to migrate"));
         return;
       }
       console.log("Migrating legacy ledger...");
       const success = await migrateLegacyLedger();
       if (success) {
-        console.log(pc7.green("\u2713 Migration completed successfully"));
+        console.log(pc6.green("\u2713 Migration completed successfully"));
       } else {
-        console.log(pc7.red("Migration failed"));
+        console.log(pc6.red("Migration failed"));
         process.exit(1);
       }
     } catch (error) {
-      console.error(pc7.red("Failed to migrate legacy ledger:"), error);
+      console.error(pc6.red("Failed to migrate legacy ledger:"), error);
       process.exit(1);
     }
   });
@@ -2911,18 +2288,18 @@ Total entries: ${pc7.cyan(status.manifest.totalEntries.toString())}`);
       }
       const status = await checkGitHooks();
       if (!status.isGitRepo) {
-        console.log(pc7.yellow("Not a git repository"));
+        console.log(pc6.yellow("Not a git repository"));
         return;
       }
-      console.log(pc7.bold("Git Hooks Status\n"));
-      console.log(`Pre-push hook: ${status.prePushInstalled ? pc7.green("\u2713 installed") : pc7.red("\u2717 not installed")}`);
-      console.log(`Post-merge hook: ${status.postMergeInstalled ? pc7.green("\u2713 installed") : pc7.red("\u2717 not installed")}`);
+      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(`
-${pc7.yellow("\u{1F4A1} Tip:")} Run ${pc7.bold("trie sync hooks --install")} to install missing hooks`);
+${pc6.yellow("\u{1F4A1} Tip:")} Run ${pc6.bold("trie sync hooks --install")} to install missing hooks`);
       }
     } catch (error) {
-      console.error(pc7.red("Failed to manage git hooks:"), error);
+      console.error(pc6.red("Failed to manage git hooks:"), error);
       process.exit(1);
     }
   });
@@ -2930,7 +2307,7 @@ ${pc7.yellow("\u{1F4A1} Tip:")} Run ${pc7.bold("trie sync hooks --install")} to
 }
 
 // src/cli/ledger.ts
-import pc8 from "picocolors";
+import pc7 from "picocolors";
 import { Command as Command2 } from "commander";
 function createLedgerCommand() {
   const ledger = new Command2("ledger").description("Manage and inspect the ledger");
@@ -2942,14 +2319,14 @@ function createLedgerCommand() {
       console.log("  \u2022 Validating Ed25519 signatures");
       const result = await verifyLedger();
       if (result.valid) {
-        console.log(pc8.green("\u2713 Ledger chain is valid"));
-        console.log(pc8.dim("  All blocks, hashes, and signatures verified"));
+        console.log(pc7.green("\u2713 Ledger chain is valid"));
+        console.log(pc7.dim("  All blocks, hashes, and signatures verified"));
       } else {
-        console.log(pc8.red(`\u2717 Ledger chain is invalid: ${result.error}`));
+        console.log(pc7.red(`\u2717 Ledger chain is invalid: ${result.error}`));
         process.exit(1);
       }
     } catch (error) {
-      console.error(pc8.red("Failed to verify ledger:"), error);
+      console.error(pc7.red("Failed to verify ledger:"), error);
       process.exit(1);
     }
   });
@@ -2961,35 +2338,35 @@ function createLedgerCommand() {
         console.log("No ledger blocks found");
         return;
       }
-      console.log(pc8.bold(`Ledger History (last ${Math.min(limit, blocks.length)} blocks)
+      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(pc8.bold(pc8.cyan(`Block ${block.date}`)));
+        console.log(pc7.bold(pc7.cyan(`Block ${block.date}`)));
         if (syncableBlock.author) {
-          console.log(`Author: ${pc8.dim(syncableBlock.author)}`);
+          console.log(`Author: ${pc7.dim(syncableBlock.author)}`);
         }
         if (syncableBlock.gitCommit) {
-          console.log(`Git: ${pc8.dim(syncableBlock.gitCommit.slice(0, 8))}`);
+          console.log(`Git: ${pc7.dim(syncableBlock.gitCommit.slice(0, 8))}`);
         }
         console.log(`Entries: ${block.entries.length}`);
-        console.log(`Hash: ${pc8.dim(block.blockHash.slice(0, 16))}...`);
+        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: ${pc8.green(`${signedEntries.length}/${block.entries.length}`)}`);
+          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 ? pc8.green("\u2713") : pc8.dim("\u25CB");
+            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(pc8.red("Failed to show ledger history:"), error);
+      console.error(pc7.red("Failed to show ledger history:"), error);
       process.exit(1);
     }
   });
@@ -2997,23 +2374,23 @@ function createLedgerCommand() {
     try {
       const status = await getLedgerSyncStatus();
       const blocks = await getLedgerBlocks();
-      console.log(pc8.bold("Ledger Statistics\n"));
-      console.log(`Total blocks: ${pc8.cyan(blocks.length.toString())}`);
+      console.log(pc7.bold("Ledger Statistics\n"));
+      console.log(`Total blocks: ${pc7.cyan(blocks.length.toString())}`);
       if (status.manifest) {
-        console.log(`Total entries: ${pc8.cyan(status.manifest.totalEntries.toString())}`);
-        console.log(`Active blocks: ${pc8.cyan(status.manifest.activeBlocks.length.toString())}`);
-        console.log(`Archived blocks: ${pc8.cyan(status.manifest.archivedBlocks.length.toString())}`);
+        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: ${pc8.cyan(`${hotSize}MB`)}`);
-          console.log(`Archive after: ${pc8.cyan(`${status.manifest.compressionConfig.archiveAfterDays} days`)}`);
+          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: ${pc8.dim(`${firstBlock.date} to ${lastBlock.date}`)}`);
+          console.log(`Date range: ${pc7.dim(`${firstBlock.date} to ${lastBlock.date}`)}`);
         }
       }
       const authorCounts = /* @__PURE__ */ new Map();
@@ -3027,7 +2404,7 @@ function createLedgerCommand() {
         console.log("\nBlocks by author:");
         const sortedAuthors = Array.from(authorCounts.entries()).sort((a, b) => b[1] - a[1]);
         for (const [author, count] of sortedAuthors.slice(0, 10)) {
-          console.log(`  ${author}: ${pc8.cyan(count.toString())}`);
+          console.log(`  ${author}: ${pc7.cyan(count.toString())}`);
         }
       }
       const severityCounts = /* @__PURE__ */ new Map();
@@ -3042,39 +2419,39 @@ function createLedgerCommand() {
         for (const severity of severityOrder) {
           const count = severityCounts.get(severity);
           if (count) {
-            const color = severity === "critical" ? pc8.red : severity === "high" ? pc8.yellow : severity === "medium" ? pc8.blue : pc8.gray;
-            console.log(`  ${color(severity)}: ${pc8.cyan(count.toString())}`);
+            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(pc8.red("Failed to show ledger stats:"), 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(pc8.bold("Ledger Diff\n"));
+      console.log(pc7.bold("Ledger Diff\n"));
       if (!status.isInitialized) {
-        console.log(pc8.yellow("Shared ledger not initialized"));
+        console.log(pc7.yellow("Shared ledger not initialized"));
         return;
       }
-      console.log(`Local blocks: ${pc8.cyan(status.localBlocks.toString())}`);
-      console.log(`Shared blocks: ${pc8.cyan(status.sharedBlocks.toString())}`);
+      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(pc8.green(`\u2193 ${diff} blocks available to pull`));
+        console.log(pc7.green(`\u2193 ${diff} blocks available to pull`));
       } else if (diff < 0) {
-        console.log(pc8.blue(`\u2191 ${-diff} local blocks not yet pushed`));
+        console.log(pc7.blue(`\u2191 ${-diff} local blocks not yet pushed`));
       } else {
-        console.log(pc8.green("\u2713 Local and shared ledgers are in sync"));
+        console.log(pc7.green("\u2713 Local and shared ledgers are in sync"));
       }
       if (status.conflicts > 0) {
-        console.log(pc8.red(`\u26A0 ${status.conflicts} conflicts detected`));
+        console.log(pc7.red(`\u26A0 ${status.conflicts} conflicts detected`));
       }
     } catch (error) {
-      console.error(pc8.red("Failed to diff ledgers:"), error);
+      console.error(pc7.red("Failed to diff ledgers:"), error);
       process.exit(1);
     }
   });
@@ -3088,66 +2465,66 @@ function createLedgerCommand() {
       console.log("Compressing old ledger blocks...");
       const result = await compressOldBlocks();
       if (result.archived > 0) {
-        console.log(pc8.green(`\u2713 Compressed ${result.archived} blocks`));
+        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(pc8.red("Failed to compress blocks:"), 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(pc8.bold("Ledger Storage Statistics\n"));
-      console.log(pc8.bold("Block Storage:"));
-      console.log(`  Active blocks: ${pc8.cyan(stats.activeBlocks.toString())}`);
-      console.log(`  Archived blocks: ${pc8.cyan(stats.archivedBlocks.toString())}`);
-      console.log(pc8.bold("\nStorage Usage:"));
+      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: ${pc8.cyan(`${activeMB} MB`)}`);
-      console.log(`  Archived storage: ${pc8.cyan(`${archivedMB} MB`)}`);
-      console.log(`  Total storage: ${pc8.bold(pc8.cyan(`${totalMB} MB`))}`);
+      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: ${pc8.green(`${stats.compressionRatio}%`)}`);
+        console.log(`  Compression ratio: ${pc7.green(`${stats.compressionRatio}%`)}`);
       }
-      console.log(pc8.bold("\nData:"));
-      console.log(`  Total entries: ${pc8.cyan(stats.totalEntries.toString())}`);
+      console.log(pc7.bold("\nData:"));
+      console.log(`  Total entries: ${pc7.cyan(stats.totalEntries.toString())}`);
       const needsCompression = await shouldCompress();
       if (needsCompression) {
         console.log(`
-${pc8.yellow("\u{1F4A1} Tip:")} Run ${pc8.bold("trie ledger compress")} to archive old blocks`);
+${pc7.yellow("\u{1F4A1} Tip:")} Run ${pc7.bold("trie ledger compress")} to archive old blocks`);
       }
     } catch (error) {
-      console.error(pc8.red("Failed to get storage stats:"), 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(pc8.red("\u2717 Correction reason is required"));
+        console.error(pc7.red("\u2717 Correction reason is required"));
         console.log("");
         console.log("Usage:");
-        console.log(`  ${pc8.dim('trie ledger correct <entry-id> -r "reason for correction"')}`);
+        console.log(`  ${pc7.dim('trie ledger correct <entry-id> -r "reason for correction"')}`);
         console.log("");
         console.log("Examples:");
-        console.log(`  ${pc8.dim('trie ledger correct abc123 -r "False positive - this is expected behavior"')}`);
-        console.log(`  ${pc8.dim('trie ledger correct xyz789 -r "Duplicate detection" -t false-positive')}`);
+        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(pc8.red(`\u2717 Invalid correction type: ${options.type}`));
+        console.error(pc7.red(`\u2717 Invalid correction type: ${options.type}`));
         console.log(`Valid types: ${validTypes.join(", ")}`);
         process.exit(1);
       }
-      console.log(pc8.yellow(`\u{1F4DD} Marking ${entryIds.length} entry(ies) as ${options.type}...`));
-      console.log(`Reason: ${pc8.dim(options.reason)}`);
+      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,
@@ -3155,16 +2532,16 @@ ${pc8.yellow("\u{1F4A1} Tip:")} Run ${pc8.bold("trie ledger compress")} to archi
         options.type
       );
       if (result.success) {
-        console.log(pc8.green(`\u2713 Successfully corrected ${result.correctedEntries} entry(ies)`));
+        console.log(pc7.green(`\u2713 Successfully corrected ${result.correctedEntries} entry(ies)`));
         console.log("");
-        console.log(pc8.dim("Note: Original entries remain in the ledger for audit trail."));
-        console.log(pc8.dim("      Queries will automatically filter out corrected entries."));
+        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(pc8.red("\u2717 Correction failed:"), result.error);
+        console.error(pc7.red("\u2717 Correction failed:"), result.error);
         process.exit(1);
       }
     } catch (error) {
-      console.error(pc8.red("Failed to correct entries:"), error);
+      console.error(pc7.red("Failed to correct entries:"), error);
       process.exit(1);
     }
   });
@@ -3176,17 +2553,17 @@ ${pc8.yellow("\u{1F4A1} Tip:")} Run ${pc8.bold("trie ledger compress")} to archi
           console.log("No correction history found for the specified entries");
           return;
         }
-        console.log(pc8.bold("Correction History\n"));
+        console.log(pc7.bold("Correction History\n"));
         for (const [entryId, data] of history) {
-          console.log(pc8.bold(pc8.cyan(`Entry: ${entryId}`)));
-          console.log(`Status: ${pc8.yellow(data.original.status || "active")}`);
-          console.log(`File: ${pc8.dim(data.original.file)}`);
-          console.log(`Agent: ${pc8.dim(data.original.agent)}`);
+          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: ${pc8.dim(data.original.correctionTimestamp)}`);
+            console.log(`Corrected at: ${pc7.dim(data.original.correctionTimestamp)}`);
           }
           if (data.corrections.length > 0) {
             console.log("\nCorrection Entries:");
@@ -3198,17 +2575,17 @@ ${pc8.yellow("\u{1F4A1} Tip:")} Run ${pc8.bold("trie ledger compress")} to archi
         }
       } else {
         const stats = await getCorrectionStats();
-        console.log(pc8.bold("Correction Statistics\n"));
-        console.log(`Total entries: ${pc8.cyan(stats.totalEntries.toString())}`);
-        console.log(`Active entries: ${pc8.green(stats.activeEntries.toString())}`);
-        console.log(`Corrected entries: ${pc8.yellow(stats.correctedEntries.toString())}`);
-        console.log(`False positives: ${pc8.yellow(stats.falsePositives.toString())}`);
-        console.log(`Correction rate: ${pc8.cyan(`${stats.correctionRate}%`)}`);
+        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(pc8.dim("\u{1F4A1} Tip: Use --entries <id> to see correction history for specific entries"));
+        console.log(pc7.dim("\u{1F4A1} Tip: Use --entries <id> to see correction history for specific entries"));
       }
     } catch (error) {
-      console.error(pc8.red("Failed to show corrections:"), error);
+      console.error(pc7.red("Failed to show corrections:"), error);
       process.exit(1);
     }
   });
@@ -3216,8 +2593,8 @@ ${pc8.yellow("\u{1F4A1} Tip:")} Run ${pc8.bold("trie ledger compress")} to archi
 }
 
 // src/cli/keys.ts
-import pc9 from "picocolors";
-import { join as join5 } from "path";
+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);
@@ -3241,7 +2618,7 @@ async function handleKeysCommand(args) {
       showKeysHelp();
       break;
     default:
-      console.error(pc9.red(`Unknown subcommand: ${subcommand}`));
+      console.error(pc8.red(`Unknown subcommand: ${subcommand}`));
       showKeysHelp();
       process.exit(1);
   }
@@ -3249,34 +2626,34 @@ async function handleKeysCommand(args) {
 async function handleKeysGenerate(workDir, force) {
   const hasKey = hasSigningKey(workDir);
   if (hasKey && !force) {
-    console.log(pc9.yellow("Signing key already exists."));
-    console.log(pc9.dim("Use --force to regenerate (WARNING: will invalidate existing signatures)"));
+    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: ${pc9.cyan(pubKey.slice(0, 16))}...${pc9.cyan(pubKey.slice(-8))}`);
+Public key: ${pc8.cyan(pubKey.slice(0, 16))}...${pc8.cyan(pubKey.slice(-8))}`);
     }
     return;
   }
   if (hasKey && force) {
-    console.log(pc9.yellow("Regenerating signing key..."));
-    console.log(pc9.red("WARNING: This will invalidate all existing signatures in the ledger."));
+    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 = join5(getTrieDirectory(workDir), "keys");
-  console.log(pc9.green("\u2713 Signing key generated successfully\n"));
-  console.log(`Location: ${pc9.dim(keysDir)}`);
-  console.log(`Public key: ${pc9.cyan(keyPair.publicKey.slice(0, 16))}...${pc9.cyan(keyPair.publicKey.slice(-8))}`);
-  console.log(`Algorithm: ${pc9.dim("Ed25519")}
+  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(pc9.bold("What this means:"));
+  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(pc9.yellow("Security notes:"));
+  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");
@@ -3284,63 +2661,63 @@ Public key: ${pc9.cyan(pubKey.slice(0, 16))}...${pc9.cyan(pubKey.slice(-8))}`);
 }
 async function handleKeysStatus(workDir) {
   const hasKey = hasSigningKey(workDir);
-  const keysDir = join5(getTrieDirectory(workDir), "keys");
-  console.log(pc9.bold("Signing Key Status\n"));
+  const keysDir = join3(getTrieDirectory(workDir), "keys");
+  console.log(pc8.bold("Signing Key Status\n"));
   if (hasKey) {
     const keyPair = loadKeyPair(workDir);
-    const keyPath = join5(keysDir, "signing-key.json");
-    console.log(`Status: ${pc9.green("\u2713 Active")}`);
-    console.log(`Location: ${pc9.dim(keyPath)}`);
+    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: ${pc9.cyan(keyPair.publicKey.slice(0, 16))}...${pc9.cyan(keyPair.publicKey.slice(-8))}`);
+      console.log(`Public key: ${pc8.cyan(keyPair.publicKey.slice(0, 16))}...${pc8.cyan(keyPair.publicKey.slice(-8))}`);
     }
-    console.log(`Algorithm: ${pc9.dim("Ed25519")}`);
+    console.log(`Algorithm: ${pc8.dim("Ed25519")}`);
     console.log(`
-New ledger entries will be ${pc9.green("signed automatically")}.`);
+New ledger entries will be ${pc8.green("signed automatically")}.`);
   } else {
-    console.log(`Status: ${pc9.yellow("\u25CB Not configured")}`);
+    console.log(`Status: ${pc8.yellow("\u25CB Not configured")}`);
     console.log(`
-Ledger entries are ${pc9.yellow("not being signed")}.`);
+Ledger entries are ${pc8.yellow("not being signed")}.`);
     console.log(`
 To enable signing, run:`);
-    console.log(`  ${pc9.cyan("trie keys generate")}`);
+    console.log(`  ${pc8.cyan("trie keys generate")}`);
   }
 }
 async function handleKeysPublic(workDir) {
   const pubKey = getPublicKey(workDir);
   if (!pubKey) {
-    console.error(pc9.yellow("No signing key found."));
-    console.error(`Run ${pc9.cyan("trie keys generate")} to create one.`);
+    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);
 }
 function showKeysHelp() {
   console.log(`
-${pc9.bold("trie keys")} - Manage Ed25519 signing keys for the governance ledger
+${pc8.bold("trie keys")} - Manage Ed25519 signing keys for the governance ledger
 
-${pc9.bold("USAGE:")}
+${pc8.bold("USAGE:")}
   trie keys <command> [options]
 
-${pc9.bold("COMMANDS:")}
+${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
 
-${pc9.bold("OPTIONS:")}
+${pc8.bold("OPTIONS:")}
   --force, -f   Force regenerate key (WARNING: invalidates signatures)
 
-${pc9.bold("EXAMPLES:")}
+${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
 
-${pc9.bold("ABOUT SIGNING:")}
+${pc8.bold("ABOUT SIGNING:")}
   Ed25519 signatures provide:
-  \u2022 ${pc9.green("Authenticity")} - Prove who created each ledger entry
-  \u2022 ${pc9.green("Tamper-evidence")} - Detect if entries are modified
-  \u2022 ${pc9.green("Accountability")} - Track decisions to humans or agents
+  \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.
@@ -3394,23 +2771,16 @@ COMMANDS:
   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)
-  quiet             Snooze nudges for 1 hour
   
-  checkpoint        Save work context to .trie/ (aliases: cp, save)
   linear sync       Sync active tickets from Linear
   gotcha            Predict problems with current changes (alias: predict)
-  reconcile         Reconcile context graph from JSON backup
 
-  audit             View security audit logs
   memory            Search and manage issue memory
-  patterns          Save, validate, and share patterns across projects
   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)
   
-  ci                Generate GitHub Actions workflow with memory caching
-  
   help              Show this help message
   version           Show version information
 
@@ -3422,7 +2792,6 @@ EXAMPLES:
   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 quiet                             # Snooze nudges for 1 hour
   
   trie linear sync                       # Sync active tickets from Linear
   trie learn                             # Scan history for precedents
@@ -3433,7 +2802,6 @@ EXAMPLES:
   trie memory search "SQL injection"
   trie memory stats                      # View memory statistics
   trie status                           # Quick health check (project + memory)
-  trie ci                                # Generate CI workflow with memory caching
 
 MCP TOOLS (use via Cursor/Claude Desktop):
   trie_linear_sync     Sync active tickets from Linear
@@ -3459,47 +2827,47 @@ async function handleStatusCommand() {
       const lastScanDate = new Date(state.lastScan.timestamp);
       const daysAgo = Math.floor((Date.now() - lastScanDate.getTime()) / (1e3 * 60 * 60 * 24));
       console.log(`
-${pc10.bold("Last Scan:")} ${lastScanDate.toLocaleDateString()} (${daysAgo === 0 ? "today" : daysAgo === 1 ? "yesterday" : `${daysAgo} days ago`})`);
-      console.log(pc10.dim(`   Files scanned: ${state.lastScan.filesScanned}`));
-      console.log(pc10.dim(`   Issues found: ${state.lastScan.issues.total} (${state.lastScan.issues.critical} critical, ${state.lastScan.issues.serious} serious)`));
+${pc9.bold("Last Scan:")} ${lastScanDate.toLocaleDateString()} (${daysAgo === 0 ? "today" : daysAgo === 1 ? "yesterday" : `${daysAgo} days ago`})`);
+      console.log(pc9.dim(`   Files scanned: ${state.lastScan.filesScanned}`));
+      console.log(pc9.dim(`   Issues found: ${state.lastScan.issues.total} (${state.lastScan.issues.critical} critical, ${state.lastScan.issues.serious} serious)`));
     } else {
       console.log(`
-${pc10.bold("Last Scan:")} Never ${pc10.dim("(run `trie watch` to get started)")}`);
+${pc9.bold("Last Scan:")} Never ${pc9.dim("(run `trie watch` to get started)")}`);
     }
     console.log(`
-${pc10.bold("Memory Stats:")}`);
-    console.log(pc10.dim(`   Active Issues: ${memoryStats.activeIssues}`));
-    console.log(pc10.dim(`   Resolved: ${memoryStats.resolvedCount}`));
-    console.log(pc10.dim(`   Total (all-time): ${memoryStats.totalIssues}`));
+${pc9.bold("Memory Stats:")}`);
+    console.log(pc9.dim(`   Active Issues: ${memoryStats.activeIssues}`));
+    console.log(pc9.dim(`   Resolved: ${memoryStats.resolvedCount}`));
+    console.log(pc9.dim(`   Total (all-time): ${memoryStats.totalIssues}`));
     const cap = memoryStats.capacityInfo;
-    const capIndicator = cap.isAtCap ? pc10.red("\u25CB") : cap.percentFull >= 80 ? pc10.yellow("\u25C9") : pc10.green("\u25CF");
-    console.log(`   ${capIndicator} Memory Usage: ${pc10.bold(cap.percentFull + "%")} ${pc10.dim(`(${cap.current}/${cap.max})`)}`);
+    const capIndicator = cap.isAtCap ? pc9.red("\u25CB") : cap.percentFull >= 80 ? pc9.yellow("\u25C9") : pc9.green("\u25CF");
+    console.log(`   ${capIndicator} Memory Usage: ${pc9.bold(cap.percentFull + "%")} ${pc9.dim(`(${cap.current}/${cap.max})`)}`);
     if (memoryStats.activeIssues > 0) {
       console.log(`
-   ${pc10.bold("Active Issues by Severity:")}`);
+   ${pc9.bold("Active Issues by Severity:")}`);
       const severityOrder = ["critical", "serious", "moderate", "low", "info"];
       for (const severity of severityOrder) {
         const count = memoryStats.activeIssuesBySeverity[severity] || 0;
         if (count > 0) {
-          console.log(pc10.dim(`     ${severity}: ${count}`));
+          console.log(pc9.dim(`     ${severity}: ${count}`));
         }
       }
     } else if (memoryStats.totalIssues > 0) {
       console.log(`
-   ${pc10.green("\u25CF")} All issues have been resolved`);
+   ${pc9.green("\u25CF")} All issues have been resolved`);
     }
     if (cap.isAtCap) {
       console.log(`
-${pc10.yellow("\u2B22 Warning:")} Memory at capacity - consider running: ${pc10.bold("trie memory purge smart")}`);
+${pc9.yellow("\u2B22 Warning:")} Memory at capacity - consider running: ${pc9.bold("trie memory purge smart")}`);
     } else if (cap.percentFull >= 80) {
       console.log(`
-${pc10.yellow("\u2B22 Notice:")} Memory usage high - consider running: ${pc10.bold("trie memory purge smart")}`);
+${pc9.yellow("\u2B22 Notice:")} Memory usage high - consider running: ${pc9.bold("trie memory purge smart")}`);
     }
     console.log(`
-${pc10.bold("Quick Commands:")}`);
-    console.log(pc10.dim("   trie watch         - Start watching for nudges"));
-    console.log(pc10.dim("   trie memory stats  - Detailed memory statistics"));
-    console.log(pc10.dim("   trie project       - View project information"));
+${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);
@@ -3517,7 +2885,7 @@ async function handleProject(args) {
 \u2551                    PROJECT.md Created                            \u2551
 \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
 
-${pc10.bold("Path:")} ${result.path}
+${pc9.bold("Path:")} ${result.path}
 
 A template has been created with sections for:
   \u2022 Project Overview
@@ -3542,7 +2910,7 @@ Next steps:
   }
   if (subcommand === "edit") {
     const editor = process.env.EDITOR || process.env.VISUAL || "nano";
-    const projectPath = join6(getTrieDirectory(workDir), "PROJECT.md");
+    const projectPath = join4(getTrieDirectory(workDir), "PROJECT.md");
     if (!projectInfoExists(workDir)) {
       console.log("No PROJECT.md found. Creating one first...");
       await initProjectInfo(workDir);
@@ -3560,7 +2928,7 @@ Next steps:
 \u2551                    Project Information                           \u2551
 \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
 
-${pc10.bold("No PROJECT.md found in this project.")}
+${pc9.bold("No PROJECT.md found in this project.")}
 
 COMMANDS:
   trie project init    Create PROJECT.md from template
@@ -3588,7 +2956,7 @@ This info is available via trie://project MCP resource.
 \u2551                    Project Information                           \u2551
 \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
 
-${pc10.bold("Path:")} ${join6(getTrieDirectory(workDir), "PROJECT.md")}
+${pc9.bold("Path:")} ${join4(getTrieDirectory(workDir), "PROJECT.md")}
 
 ${"-".repeat(68)}
 `);
@@ -3647,19 +3015,11 @@ async function main() {
     case "stats":
       await handleStatusCommand();
       break;
-    case "checkpoint":
-    case "cp":
-    case "save":
-      handleCheckpointCommand(restArgs);
-      break;
     case "project":
     case "info":
     case "project-info":
       handleProject(restArgs);
       break;
-    case "audit":
-      handleAuditCommand(restArgs);
-      break;
     case "version":
     case "--version":
     case "-v":
@@ -3697,9 +3057,6 @@ async function main() {
     case "tell":
       handleTellCommand(restArgs);
       break;
-    case "reconcile":
-      handleReconcileCommand(restArgs);
-      break;
     case "learn":
     case "train":
       handleLearnCommand(restArgs);
@@ -3712,14 +3069,6 @@ async function main() {
     case "thumbs-down":
       handleLearnCommand(["bad", ...restArgs]);
       break;
-    case "quiet":
-    case "snooze":
-      handleQuietCommand();
-      break;
-    case "ci":
-    case "ci-setup":
-      handleCISetupCommand(restArgs);
-      break;
     case "linear":
       handleLinearCommand(restArgs);
       break;
@@ -3727,10 +3076,6 @@ async function main() {
     case "predict":
       handleGotchaCommand();
       break;
-    case "patterns":
-    case "pattern":
-      handlePatternsCommand(restArgs);
-      break;
     case "sync":
       {
         const syncCommand = createSyncCommand();