@triedotdev/mcp 1.0.61 → 1.0.63

package/dist/cli/main.js

@@ -2,56 +2,71 @@
 import {
   ContextGraph,
   IncidentIndex,
-  SKILL_CATEGORIES,
   TrieFeedbackTool,
   completeBootstrap,
-  detectStack,
   exportToJson,
   formatFriendlyError,
-  getSkillCategories,
-  getSkillsByCategory,
+  getAutonomyConfig,
   handleCheckpointCommand,
   importFromJson,
   initializeBootstrapFiles,
   needsBootstrap,
   perceiveCurrentChanges,
-  reasonAboutChangesHumanReadable
-} from "../chunk-NUT4G5AY.js";
-import "../chunk-XSPS463E.js";
+  reasonAboutChangesHumanReadable,
+  recordBypass,
+  shouldAutoFix,
+  shouldBlockPush,
+  trackIssueOccurrence
+} from "../chunk-R7Z7OHTJ.js";
+import {
+  SKILL_CATEGORIES,
+  detectStack,
+  getSkillCategories,
+  getSkillsByCategory,
+  isTrieInitialized
+} from "../chunk-ALA6733H.js";
+import {
+  getGuardianState
+} from "../chunk-4YSLDGBL.js";
 import {
-  findCrossProjectPatterns,
-  getDailyLogs,
-  getGlobalMemoryStats,
-  getMemoryStats,
-  getRecentIssues,
   initProjectInfo,
   installSkill,
   listInstalledSkills,
-  listTrackedProjects,
   loadContextState,
   loadProjectInfo,
-  markIssueResolved,
   projectInfoExists,
   recordSkillInstalled,
-  removeSkill,
+  removeSkill
+} from "../chunk-X2PABPBH.js";
+import {
+  findCrossProjectPatterns,
+  getGlobalMemoryStats,
+  listTrackedProjects,
   searchGlobalPatterns,
-  searchIssues,
   updateGlobalMemoryMd
-} from "../chunk-S4VGGLXF.js";
+} from "../chunk-7KHT2NKR.js";
 import "../chunk-MVUCBUBR.js";
-import "../chunk-32WLOG6E.js";
+import "../chunk-6NLHFIYA.js";
+import "../chunk-K6BQBKIR.js";
+import "../chunk-AQCAMIQQ.js";
+import {
+  getDailyLogs,
+  getMemoryStats,
+  getRecentIssues,
+  markIssueResolved,
+  searchIssues
+} from "../chunk-TSHZQKCM.js";
 import {
   getWorkingDirectory
-} from "../chunk-ASGSTVVF.js";
-import "../chunk-6NLHFIYA.js";
+} from "../chunk-KOFQ47YW.js";
 import "../chunk-RAZUNSBI.js";
 import {
   __require
 } from "../chunk-DGUM43GV.js";
 
 // src/cli/main.ts
-import { resolve, join, dirname } from "path";
-import { existsSync, readFileSync } from "fs";
+import { resolve, join as join2, dirname } from "path";
+import { existsSync as existsSync3, readFileSync } from "fs";
 import { fileURLToPath } from "url";
 
 // src/cli/skills.ts
@@ -61,12 +76,12 @@ async function handleSkillsCommand(args) {
     case "add":
     case "install": {
       if (!rest[0]) {
-        console.log("Usage: trie-agent skills add <owner/repo> [skill-name]");
+        console.log("Usage: trie skills add <owner/repo> [skill-name]");
         console.log("");
         console.log("Examples:");
-        console.log("  trie-agent skills add vercel-labs/agent-skills react-best-practices");
-        console.log("  trie-agent skills add anthropics/skills claude-code-review");
-        console.log("  trie-agent skills add myorg/internal-standards");
+        console.log("  trie skills add vercel-labs/agent-skills react-best-practices");
+        console.log("  trie skills add anthropics/skills claude-code-review");
+        console.log("  trie skills add myorg/internal-standards");
         return;
       }
       console.log(`Installing skill from ${rest[0]}...`);
@@ -77,7 +92,7 @@ async function handleSkillsCommand(args) {
         console.log(`Path: ${result.path}`);
         console.log("");
         console.log("This skill is now a capability the skill-review agent can apply.");
-        console.log('Run "trie-agent scan" to apply skills to your codebase.');
+        console.log('Run "trie scan" to apply skills to your codebase.');
       } else {
         console.error(`Failed to install: ${result.error}`);
         process.exit(1);
@@ -164,7 +179,7 @@ async function handleSkillsCommand(args) {
     case "rm":
     case "uninstall": {
       if (!rest[0]) {
-        console.log("Usage: trie-agent skills remove <skill-name>");
+        console.log("Usage: trie skills remove <skill-name>");
         return;
       }
       const removed = await removeSkill(rest[0]);
@@ -206,7 +221,7 @@ async function handleSkillsCommand(args) {
     }
     case "info": {
       if (!rest[0]) {
-        console.log("Usage: trie-agent skills info <skill-name>");
+        console.log("Usage: trie skills info <skill-name>");
         return;
       }
       const skills = await listInstalledSkills();
@@ -290,6 +305,46 @@ else
 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 "\u26A0\uFE0F  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 "\u{1F6D1} 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";
 }
@@ -297,7 +352,7 @@ function postCommitTemplate() {
   return (hookHeader() + "# Trie post-commit hook\n" + trieCommand("post-commit")).trim() + "\n";
 }
 function prePushTemplate() {
-  return (hookHeader() + "# Trie pre-push hook\n" + trieCommand("check --quick")).trim() + "\n";
+  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
@@ -767,6 +822,792 @@ async function handleCheckCommand(args) {
   }
 }
 
+// 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("\u26A0\uFE0F  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("\u{1F6D1} 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" ? "\u{1F534}" : "\u{1F7E1}";
+          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 scan       # See all issues"));
+        console.error("");
+        process.exit(2);
+      } else if (blockResult.bypassed) {
+        console.error(pc.yellow(`\u26A0\uFE0F  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(`\u26A0\uFE0F  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/auto-fix.ts
+import { readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { createInterface } from "readline";
+import pc2 from "picocolors";
+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(pc2.cyan(`\u2501\u2501\u2501 Fix ${index + 1}/${total} \u2501\u2501\u2501`));
+  console.error(pc2.dim(`File: ${fix.file}${fix.line ? `:${fix.line}` : ""}`));
+  console.error(pc2.dim(`Type: ${fix.type}`));
+  console.error(pc2.yellow(`Description: ${fix.description}`));
+  console.error("");
+  if (fix.original) {
+    console.error(pc2.red("- " + fix.original));
+  }
+  if (fix.fixed) {
+    console.error(pc2.green("+ " + fix.fixed));
+  } else if (fix.original) {
+    console.error(pc2.dim("  (line will be removed)"));
+  }
+  console.error("");
+}
+async function applyFix(fix) {
+  try {
+    if (!existsSync(fix.file)) {
+      console.error(pc2.red(`File not found: ${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) {
+      console.error(pc2.red(`Invalid line number: ${fix.line}`));
+      return false;
+    }
+    const lineIndex = fix.line - 1;
+    const originalLine = lines[lineIndex];
+    let newContent;
+    if (fix.type === "remove-console-log" || fix.type === "remove-debugger") {
+      lines.splice(lineIndex, 1);
+      newContent = lines.join("\n");
+    } else if (fix.fixed) {
+      lines[lineIndex] = fix.fixed;
+      newContent = lines.join("\n");
+    } else {
+      console.error(pc2.red(`Unknown fix type: ${fix.type}`));
+      return false;
+    }
+    await writeFile(fix.file, newContent);
+    console.error(pc2.green(`\u2713 Applied fix to ${fix.file}:${fix.line}`));
+    if (originalLine) {
+      console.error(pc2.dim(`  Removed: ${originalLine.trim().slice(0, 60)}...`));
+    }
+    return true;
+  } catch (error) {
+    console.error(pc2.red(`Failed to apply fix: ${error}`));
+    return false;
+  }
+}
+async function loadFixContent(fixes) {
+  const enrichedFixes = [];
+  for (const fix of fixes) {
+    if (!fix.line || !existsSync(fix.file)) {
+      continue;
+    }
+    try {
+      const content = await readFile(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(pc2.yellow("Auto-fix is disabled in config."));
+    console.error(pc2.dim("Enable it with: trie config set autoFix.enabled true"));
+    return;
+  }
+  const dryRun = args.includes("--dry-run");
+  const skipConfirm = args.includes("--yes") || args.includes("-y");
+  if (!issues || issues.length === 0) {
+    console.error(pc2.yellow("No issues provided. Run a scan first:"));
+    console.error(pc2.dim("  trie scan --fix"));
+    return;
+  }
+  let fixes = detectAutoFixes(issues);
+  if (fixes.length === 0) {
+    console.error(pc2.green("\u2713 No auto-fixable issues found."));
+    return;
+  }
+  fixes = fixes.filter((fix) => shouldAutoFix(fix, config));
+  if (fixes.length === 0) {
+    console.error(pc2.yellow("Found fixable issues but they are not in allowed categories."));
+    console.error(pc2.dim("Allowed categories: " + config.autoFix.categories.join(", ")));
+    return;
+  }
+  fixes = await loadFixContent(fixes);
+  if (fixes.length === 0) {
+    console.error(pc2.yellow("Could not load fix content from files."));
+    return;
+  }
+  console.error("");
+  console.error(pc2.cyan("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
+  console.error(pc2.bold("Auto-Fix: Human-in-the-Loop"));
+  console.error(pc2.cyan("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
+  console.error("");
+  console.error(`Found ${pc2.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(pc2.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(pc2.yellow("Trie will ask before applying each fix."));
+    console.error("");
+    const response = await promptUser(
+      `Apply all ${fixes.length} fixes? (y)es / (n)o / (r)eview each: `
+    );
+    if (response === "n" || response === "no") {
+      console.error(pc2.dim("Cancelled."));
+      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(pc2.dim("Stopped."));
+          break;
+        }
+        if (answer === "y" || answer === "yes") {
+          const success = await applyFix(fix);
+          if (success) applied2++;
+        } else {
+          console.error(pc2.dim("Skipped."));
+          skipped++;
+        }
+      }
+      console.error("");
+      console.error(pc2.cyan("\u2501\u2501\u2501 Summary \u2501\u2501\u2501"));
+      console.error(`Applied: ${pc2.green(applied2.toString())}`);
+      console.error(`Skipped: ${pc2.dim(skipped.toString())}`);
+      return;
+    }
+  }
+  console.error("");
+  console.error(pc2.cyan("Applying fixes..."));
+  console.error("");
+  let applied = 0;
+  let failed = 0;
+  for (const fix of fixes) {
+    const success = await applyFix(fix);
+    if (success) {
+      applied++;
+    } else {
+      failed++;
+    }
+  }
+  console.error("");
+  console.error(pc2.cyan("\u2501\u2501\u2501 Complete \u2501\u2501\u2501"));
+  console.error(`Applied: ${pc2.green(applied.toString())}`);
+  if (failed > 0) {
+    console.error(`Failed: ${pc2.red(failed.toString())}`);
+  }
+}
+
+// src/cli/goal.ts
+import pc3 from "picocolors";
+async function handleGoalCommand(args) {
+  const projectPath = getWorkingDirectory(void 0, true);
+  const guardianState = getGuardianState(projectPath);
+  await guardianState.load();
+  const subcommand = args[0];
+  const restArgs = args.slice(1);
+  switch (subcommand) {
+    case "add":
+    case "create":
+      await addGoal(guardianState, restArgs);
+      break;
+    case "list":
+    case "ls":
+      await listGoals(guardianState);
+      break;
+    case "complete":
+    case "done":
+      await completeGoal(guardianState, restArgs[0]);
+      break;
+    case "delete":
+    case "rm":
+      await deleteGoal(guardianState, restArgs[0]);
+      break;
+    default:
+      if (subcommand && !subcommand.startsWith("-")) {
+        await addGoal(guardianState, [subcommand, ...restArgs]);
+      } else {
+        printGoalHelp();
+      }
+  }
+}
+async function addGoal(guardianState, args) {
+  const description = args.join(" ").replace(/^["']|["']$/g, "");
+  if (!description) {
+    console.error(pc3.red("Please provide a goal description."));
+    console.error(pc3.dim('Example: trie goal add "Reduce auth issues by 50%"'));
+    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 goal = {
+    id: `goal-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    description: cleanDesc,
+    type: goalType,
+    metric,
+    target,
+    currentValue: 0,
+    startValue: 0,
+    status: "active",
+    autoGenerated: false,
+    // User-created
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    deadline: deadline.toISOString(),
+    category
+  };
+  await guardianState.addGoal(goal);
+  console.error("");
+  console.error(pc3.green("\u2713 Goal created"));
+  console.error("");
+  console.error(pc3.bold(cleanDesc));
+  console.error(pc3.dim(`ID: ${goal.id}`));
+  console.error(pc3.dim(`Type: ${goalType} | Target: ${target} | Category: ${category}`));
+  console.error(pc3.dim(`Deadline: ${deadline.toLocaleDateString()}`));
+  console.error("");
+  console.error(pc3.cyan("The guardian will track progress and celebrate when you achieve it!"));
+}
+async function listGoals(guardianState) {
+  const goals = guardianState.getAllGoals();
+  if (goals.length === 0) {
+    console.error(pc3.dim("No goals yet."));
+    console.error(pc3.dim('Create one: trie goal add "Reduce auth issues by 50%"'));
+    return;
+  }
+  console.error("");
+  console.error(pc3.bold("\u{1F3AF} Goals"));
+  console.error("");
+  const active = goals.filter((g) => g.status === "active");
+  const achieved = goals.filter((g) => g.status === "achieved");
+  const other = goals.filter((g) => g.status !== "active" && g.status !== "achieved");
+  if (active.length > 0) {
+    console.error(pc3.cyan("Active:"));
+    for (const goal of active) {
+      const progress = goal.target > 0 ? Math.round(goal.currentValue / goal.target * 100) : 0;
+      const bar = renderProgressBar(progress);
+      const source = goal.autoGenerated ? pc3.dim("[auto]") : pc3.dim("[manual]");
+      console.error(`  ${bar} ${goal.description} ${source}`);
+      console.error(pc3.dim(`     ID: ${goal.id} | ${progress}% complete`));
+    }
+    console.error("");
+  }
+  if (achieved.length > 0) {
+    console.error(pc3.green("Achieved:"));
+    for (const goal of achieved) {
+      console.error(`  \u2705 ${goal.description}`);
+    }
+    console.error("");
+  }
+  if (other.length > 0) {
+    console.error(pc3.dim("Other:"));
+    for (const goal of other) {
+      const icon = goal.status === "failed" ? "\u274C" : goal.status === "paused" ? "\u23F8\uFE0F" : "\u2022";
+      console.error(`  ${icon} ${goal.description} (${goal.status})`);
+    }
+  }
+}
+async function completeGoal(guardianState, goalId) {
+  if (!goalId) {
+    console.error(pc3.red("Please provide a goal ID."));
+    console.error(pc3.dim('Run "trie goal list" to see IDs.'));
+    return;
+  }
+  const goals = guardianState.getAllGoals();
+  const goal = goals.find((g) => g.id === goalId || g.id.includes(goalId));
+  if (!goal) {
+    console.error(pc3.red(`Goal not found: ${goalId}`));
+    return;
+  }
+  await guardianState.updateGoal(goal.id, {
+    status: "achieved",
+    currentValue: goal.target,
+    achievedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  console.error("");
+  console.error(pc3.green("\u{1F389} Goal achieved!"));
+  console.error(pc3.bold(goal.description));
+  console.error("");
+}
+async function deleteGoal(guardianState, goalId) {
+  if (!goalId) {
+    console.error(pc3.red("Please provide a goal ID."));
+    return;
+  }
+  const goals = guardianState.getAllGoals();
+  const goal = goals.find((g) => g.id === goalId || g.id.includes(goalId));
+  if (!goal) {
+    console.error(pc3.red(`Goal not found: ${goalId}`));
+    return;
+  }
+  await guardianState.updateGoal(goal.id, { status: "rejected" });
+  console.error(pc3.dim(`Removed goal: ${goal.description}`));
+}
+function renderProgressBar(percent) {
+  const width = 10;
+  const filled = Math.round(percent / 100 * width);
+  const empty = width - filled;
+  return `[${pc3.green("\u2588".repeat(filled))}${pc3.dim("\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(pc3.bold("trie goal - Manage guardian goals"));
+  console.error("");
+  console.error(pc3.cyan("Usage:"));
+  console.error('  trie goal add "Reduce auth issues by 50%"');
+  console.error("  trie goal list");
+  console.error("  trie goal complete <id>");
+  console.error("  trie goal delete <id>");
+  console.error("");
+  console.error(pc3.cyan("Options for add:"));
+  console.error("  --category=security|quality|performance|coverage|general");
+  console.error("  --target=<number>");
+  console.error("  --deadline=<days>");
+  console.error("");
+  console.error(pc3.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 guardianState = getGuardianState(projectPath);
+  await guardianState.load();
+  const subcommand = args[0];
+  const restArgs = args.slice(1);
+  switch (subcommand) {
+    case "add":
+    case "create":
+      await addHypothesis(guardianState, restArgs);
+      break;
+    case "list":
+    case "ls":
+      await listHypotheses(guardianState);
+      break;
+    case "validate":
+      await validateHypothesis(guardianState, restArgs[0]);
+      break;
+    case "invalidate":
+      await invalidateHypothesis(guardianState, restArgs[0]);
+      break;
+    case "delete":
+    case "rm":
+      await deleteHypothesis(guardianState, restArgs[0]);
+      break;
+    default:
+      if (subcommand && !subcommand.startsWith("-")) {
+        await addHypothesis(guardianState, [subcommand, ...restArgs]);
+      } else {
+        printHypothesisHelp();
+      }
+  }
+}
+async function addHypothesis(guardianState, args) {
+  const statement = args.join(" ").replace(/^["']|["']$/g, "");
+  if (!statement) {
+    console.error(pc3.red("Please provide a hypothesis statement."));
+    console.error(pc3.dim('Example: trie hypothesis add "Mondays have more bugs than Fridays"'));
+    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.5,
+    // Start neutral
+    status: "testing",
+    evidence: [],
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    testCriteria,
+    category
+  };
+  await guardianState.addHypothesis(hypothesis);
+  console.error("");
+  console.error(pc3.green("\u2713 Hypothesis created"));
+  console.error("");
+  console.error(pc3.bold(`"${cleanStatement}"`));
+  console.error(pc3.dim(`ID: ${hypothesis.id}`));
+  console.error(pc3.dim(`Status: testing | Confidence: 50% | Category: ${category}`));
+  console.error("");
+  console.error(pc3.cyan("The guardian will collect evidence and update confidence over time."));
+  console.error(pc3.dim(`Test criteria: ${testCriteria}`));
+}
+async function listHypotheses(guardianState) {
+  const hypotheses = guardianState.getAllHypotheses();
+  if (hypotheses.length === 0) {
+    console.error(pc3.dim("No hypotheses yet."));
+    console.error(pc3.dim('Create one: trie hypothesis add "Mondays have more bugs"'));
+    return;
+  }
+  console.error("");
+  console.error(pc3.bold("\u{1F52E} Hypotheses"));
+  console.error("");
+  const testing = hypotheses.filter((h) => h.status === "testing");
+  const validated = hypotheses.filter((h) => h.status === "validated");
+  const invalidated = hypotheses.filter((h) => h.status === "invalidated");
+  if (testing.length > 0) {
+    console.error(pc3.cyan("Testing:"));
+    for (const hypo of testing) {
+      const conf = Math.round(hypo.confidence * 100);
+      const confColor = conf >= 70 ? pc3.green : conf >= 40 ? pc3.yellow : pc3.red;
+      console.error(`  \u{1F9EA} "${hypo.statement}" ${confColor(`(${conf}% confidence)`)}`);
+      console.error(pc3.dim(`     ID: ${hypo.id} | Evidence: ${hypo.evidence.length} points`));
+    }
+    console.error("");
+  }
+  if (validated.length > 0) {
+    console.error(pc3.green("Validated:"));
+    for (const hypo of validated) {
+      console.error(`  \u2705 "${hypo.statement}" (${Math.round(hypo.confidence * 100)}%)`);
+    }
+    console.error("");
+  }
+  if (invalidated.length > 0) {
+    console.error(pc3.red("Invalidated:"));
+    for (const hypo of invalidated) {
+      console.error(`  \u274C "${hypo.statement}"`);
+    }
+  }
+}
+async function validateHypothesis(guardianState, hypoId) {
+  if (!hypoId) {
+    console.error(pc3.red("Please provide a hypothesis ID."));
+    return;
+  }
+  const hypotheses = guardianState.getAllHypotheses();
+  const hypo = hypotheses.find((h) => h.id === hypoId || h.id.includes(hypoId));
+  if (!hypo) {
+    console.error(pc3.red(`Hypothesis not found: ${hypoId}`));
+    return;
+  }
+  await guardianState.updateHypothesis(hypo.id, {
+    status: "validated",
+    confidence: 0.9,
+    validatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  console.error(pc3.green(`\u2705 Hypothesis validated: "${hypo.statement}"`));
+}
+async function invalidateHypothesis(guardianState, hypoId) {
+  if (!hypoId) {
+    console.error(pc3.red("Please provide a hypothesis ID."));
+    return;
+  }
+  const hypotheses = guardianState.getAllHypotheses();
+  const hypo = hypotheses.find((h) => h.id === hypoId || h.id.includes(hypoId));
+  if (!hypo) {
+    console.error(pc3.red(`Hypothesis not found: ${hypoId}`));
+    return;
+  }
+  await guardianState.updateHypothesis(hypo.id, {
+    status: "invalidated",
+    confidence: 0.1
+  });
+  console.error(pc3.red(`\u274C Hypothesis invalidated: "${hypo.statement}"`));
+}
+async function deleteHypothesis(guardianState, hypoId) {
+  if (!hypoId) {
+    console.error(pc3.red("Please provide a hypothesis ID."));
+    return;
+  }
+  const hypotheses = guardianState.getAllHypotheses();
+  const hypo = hypotheses.find((h) => h.id === hypoId || h.id.includes(hypoId));
+  if (!hypo) {
+    console.error(pc3.red(`Hypothesis not found: ${hypoId}`));
+    return;
+  }
+  await guardianState.updateHypothesis(hypo.id, { status: "retired" });
+  console.error(pc3.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(pc3.bold("trie hypothesis - Manage guardian hypotheses"));
+  console.error("");
+  console.error(pc3.cyan("Usage:"));
+  console.error('  trie hypothesis add "Mondays have more bugs than Fridays"');
+  console.error("  trie hypothesis list");
+  console.error("  trie hypothesis validate <id>");
+  console.error("  trie hypothesis invalidate <id>");
+  console.error("  trie hypothesis delete <id>");
+  console.error("");
+  console.error(pc3.cyan("Options for add:"));
+  console.error("  --category=timing|pattern|team|code|general");
+  console.error('  --test="<test criteria>"');
+  console.error("");
+  console.error(pc3.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("");
+}
+
 // src/cli/tell.ts
 import path3 from "path";
 function escalateRisk(level) {
@@ -908,10 +1749,192 @@ async function handleQuietCommand() {
   }
 }
 
+// src/cli/ci.ts
+import { writeFileSync, existsSync as existsSync2, mkdirSync } from "fs";
+import { join } from "path";
+import pc4 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 = join(workDir, ".github", "workflows");
+  const workflowPath = join(workflowsDir, "trie-scan.yml");
+  const isMinimal = args.includes("--minimal") || args.includes("-m");
+  const isDryRun = args.includes("--dry-run") || args.includes("-n");
+  const showHelp3 = args.includes("--help") || args.includes("-h");
+  if (showHelp3) {
+    console.log(`
+${pc4.bold("trie ci")} - Generate GitHub Actions workflow with memory caching
+
+${pc4.bold("USAGE:")}
+  trie ci [options]
+
+${pc4.bold("OPTIONS:")}
+  --minimal, -m    Generate minimal workflow (simpler, fewer features)
+  --dry-run, -n    Preview workflow without creating files
+  --help, -h       Show this help
+
+${pc4.bold("WHAT IT DOES:")}
+  Creates .github/workflows/trie-scan.yml that:
+  
+  1. ${pc4.green("Caches Trie memory")} - Patterns and fixes persist across runs
+  2. ${pc4.green("Enables learning")} - Trie remembers issues from previous PRs
+  3. ${pc4.green("Tracks patterns")} - Detects recurring issues across your codebase
+  4. ${pc4.green("SARIF upload")} - Results appear in GitHub Security tab
+
+${pc4.bold("MEMORY BENEFITS:")}
+  \u2022 "This issue was introduced 3 PRs ago"
+  \u2022 "Similar issue was fixed in PR #42"
+  \u2022 "This pattern keeps recurring in auth code"
+  \u2022 Trend tracking: improving, stable, or declining
+
+${pc4.bold("EXAMPLES:")}
+  trie ci               # Generate full workflow
+  trie ci --minimal     # Generate simple workflow
+  trie ci --dry-run     # Preview without writing
+
+${pc4.bold("REQUIRED SECRETS:")}
+  ANTHROPIC_API_KEY     Your Anthropic API key (add in GitHub repo settings)
+`);
+    return;
+  }
+  const template = isMinimal ? WORKFLOW_MINIMAL : WORKFLOW_TEMPLATE;
+  if (isDryRun) {
+    console.log(pc4.bold("\n\u{1F4CB} Workflow Preview:\n"));
+    console.log(pc4.dim("\u2500".repeat(60)));
+    console.log(template);
+    console.log(pc4.dim("\u2500".repeat(60)));
+    console.log(pc4.dim("\nRun without --dry-run to create the file."));
+    return;
+  }
+  if (existsSync2(workflowPath)) {
+    console.log(pc4.yellow("\u26A0\uFE0F  Workflow already exists: .github/workflows/trie-scan.yml"));
+    console.log(pc4.dim("   Run with --dry-run to preview what would be written."));
+    console.log(pc4.dim("   Delete the existing file to regenerate."));
+    return;
+  }
+  if (!existsSync2(workflowsDir)) {
+    mkdirSync(workflowsDir, { recursive: true });
+  }
+  writeFileSync(workflowPath, template);
+  console.log(pc4.green("\u2713") + " Created .github/workflows/trie-scan.yml");
+  console.log("");
+  console.log(pc4.bold("Next steps:"));
+  console.log("");
+  console.log("  1. Add your Anthropic API key to GitHub Secrets:");
+  console.log(pc4.dim("     Settings \u2192 Secrets \u2192 Actions \u2192 New repository secret"));
+  console.log(pc4.dim("     Name: ANTHROPIC_API_KEY"));
+  console.log("");
+  console.log("  2. Commit and push:");
+  console.log(pc4.dim("     git add .github/workflows/trie-scan.yml"));
+  console.log(pc4.dim('     git commit -m "Add Trie security scan with memory"'));
+  console.log(pc4.dim("     git push"));
+  console.log("");
+  console.log(pc4.bold("Memory caching benefits:"));
+  console.log(pc4.dim("  \u2022 Trie learns from past scans"));
+  console.log(pc4.dim("  \u2022 Tracks issue trends over time"));
+  console.log(pc4.dim("  \u2022 Remembers when issues were introduced"));
+  console.log(pc4.dim("  \u2022 Recognizes recurring patterns"));
+}
+
 // src/cli/main.ts
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = dirname(__filename2);
-var VERSION = "1.0.0";
+var DEFAULT_VERSION = "0.0.0";
+function getCliVersion() {
+  try {
+    const pkgPath = resolve(__dirname2, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync(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
@@ -931,20 +1954,24 @@ function showBanner() {
 }
 function showHelp2() {
   showBanner();
-  console.log(`Version: ${VERSION}
+  console.log(`Version: ${getCliVersion()}
 
 USAGE:
-  trie-agent <command> [options]
+  trie <command> [options]
 
 COMMANDS:
   init              Initialize Trie in your project
   scan              Scan codebase once and exit
   watch             Start the guardian (watches + nudges as you code)
   check             Run risk check before pushing
+  
   tell "<incident>" Report an incident ("users can't log in")
   ok                Mark last warning as helpful (thumbs up)
   bad               Mark last warning as not helpful (thumbs down)
   quiet             Snooze nudges for 1 hour
+  
+  checkpoint        Save work context to .trie/ (aliases: cp, save)
+  reconcile         Reconcile context graph from JSON backup
 
   skills            Manage external skills from skills.sh
   memory            Search and manage issue memory
@@ -955,38 +1982,31 @@ COMMANDS:
   agent-smith       Run Agent Smith (35 vibe code hunters)
   super-reviewer    Run interactive PR review
   
+  ci                Generate GitHub Actions workflow with memory caching
+  
   help              Show this help message
   version           Show version information
 
 EXAMPLES:
-  # Initialize Trie in your project
-  trie init
-
-  # Start the guardian (watches + nudges as you code)
-  trie watch
-
-  # Scan your codebase now
-  trie scan
-
-  # Report an incident to teach Trie
-  trie tell "users couldn't log in after my last push"
-
-  # Give feedback on warnings
-  trie ok                  # Warning was helpful
-  trie bad                 # Warning was noise
-
-  # Check before pushing (also runs via git hooks)
-  trie check
-
-  # Install skills from skills.sh
+  trie init                              # Initialize Trie in your project
+  trie watch                             # Start the guardian (watches + nudges)
+  trie scan                              # Scan your codebase now
+  trie scan --agents security,privacy    # Scan with specific agents
+  
+  trie tell "users couldn't log in"      # Report an incident
+  trie ok                                # Warning was helpful (thumbs up)
+  trie bad                               # Warning was noise (thumbs down)
+  trie quiet                             # Snooze nudges for 1 hour
+  
+  trie check                             # Risk check before pushing
+  trie checkpoint "finished auth"        # Save work context
+  trie checkpoint list                   # List recent checkpoints
+  
   trie skills add vercel-labs/agent-skills react-best-practices
-
-  # Search your incident memory
   trie memory search "SQL injection"
-
-  # Run specialized scans
-  trie agent-smith         # 35 vibe code hunters
-  trie super-reviewer      # Interactive PR review
+  trie agent-smith                       # 35 vibe code hunters
+  trie super-reviewer                    # Interactive PR review
+  trie ci                                # Generate CI workflow with memory caching
 
 MCP TOOLS (use via Cursor/Claude Desktop):
   trie_scan            Intelligent scan with agent selection
@@ -1085,14 +2105,14 @@ BUILT-IN AGENTS:
 
   Custom Skills:
   \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`);
-  const skillsDir = join(getWorkingDirectory(void 0, true), ".trie", "agents");
-  if (existsSync(skillsDir)) {
+  const skillsDir = join2(getWorkingDirectory(void 0, true), ".trie", "agents");
+  if (existsSync3(skillsDir)) {
     try {
       const { readdirSync } = __require("fs");
       const files = readdirSync(skillsDir).filter((f) => f.endsWith(".json"));
       if (files.length > 0) {
         for (const file of files) {
-          const config = JSON.parse(readFileSync(join(skillsDir, file), "utf-8"));
+          const config = JSON.parse(readFileSync(join2(skillsDir, file), "utf-8"));
           console.log(`  ${config.name.padEnd(18)} ${config.description || "Custom skill"}`);
         }
       } else {
@@ -1118,7 +2138,7 @@ to code reviews. Great for style guides, compliance docs, etc.
 }
 function showVersion() {
   showBanner();
-  console.error(`v${VERSION}`);
+  console.error(`v${getCliVersion()}`);
 }
 async function handleProject(args) {
   const subcommand = args[0]?.toLowerCase();
@@ -1150,13 +2170,13 @@ Next steps:
 `);
     } else {
       console.log(`PROJECT.md already exists at: ${result.path}`);
-      console.log('Use "trie-agent project" to view it.');
+      console.log('Use "trie project" to view it.');
     }
     return;
   }
   if (subcommand === "edit") {
     const editor = process.env.EDITOR || process.env.VISUAL || "nano";
-    const projectPath = join(workDir, ".trie", "PROJECT.md");
+    const projectPath = join2(workDir, ".trie", "PROJECT.md");
     if (!projectInfoExists(workDir)) {
       console.log("No PROJECT.md found. Creating one first...");
       await initProjectInfo(workDir);
@@ -1177,9 +2197,9 @@ Next steps:
 No PROJECT.md found in this project.
 
 COMMANDS:
-  trie-agent project init    Create PROJECT.md from template
-  trie-agent project edit    Open PROJECT.md in $EDITOR
-  trie-agent project         View PROJECT.md contents
+  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:
@@ -1202,7 +2222,7 @@ This info is available via trie://project MCP resource.
 \u2551                    \u{1F4CB} 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
 
-Path: ${join(workDir, ".trie", "PROJECT.md")}
+Path: ${join2(workDir, ".trie", "PROJECT.md")}
 
 ${"-".repeat(68)}
 `);
@@ -1253,6 +2273,15 @@ function main() {
     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":
@@ -1300,6 +2329,23 @@ function main() {
     case "check":
       handleCheckCommand(restArgs);
       break;
+    case "pre-push":
+      handlePrePushCommand(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;
@@ -1328,6 +2374,10 @@ function main() {
     case "trie_super_reviewer":
       runScan(["--agents", "super-reviewer", ...restArgs]);
       break;
+    case "ci":
+    case "ci-setup":
+      handleCISetupCommand(restArgs);
+      break;
     default:
       if (command.startsWith("-")) {
         const { spawn } = __require("child_process");
@@ -1341,7 +2391,7 @@ function main() {
         });
       } else {
         console.error(`Unknown command: ${command}`);
-        console.error(`Run 'trie-agent help' for usage information.`);
+        console.error(`Run 'trie help' for usage information.`);
         process.exit(1);
       }
   }