@triedotdev/mcp 1.0.50 → 1.0.52

package/dist/chunk-WCHIJDCD.js

@@ -0,0 +1,2051 @@
+import {
+  Executor,
+  Triager
+} from "./chunk-C3AS5OXW.js";
+import {
+  getWorkingDirectory
+} from "./chunk-ASGSTVVF.js";
+import {
+  Trie
+} from "./chunk-6NLHFIYA.js";
+
+// src/cli/checkpoint.ts
+import { existsSync } from "fs";
+import { mkdir, writeFile, readFile } from "fs/promises";
+import { join } from "path";
+async function saveCheckpoint(options) {
+  const workDir = options.workDir || getWorkingDirectory(void 0, true);
+  const trieDir = join(workDir, ".trie");
+  const checkpointPath = join(trieDir, "checkpoints.json");
+  await mkdir(trieDir, { recursive: true });
+  let log = { checkpoints: [] };
+  try {
+    if (existsSync(checkpointPath)) {
+      log = JSON.parse(await readFile(checkpointPath, "utf-8"));
+    }
+  } catch {
+    log = { checkpoints: [] };
+  }
+  const checkpoint = {
+    id: `cp-${Date.now().toString(36)}`,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    files: options.files || [],
+    createdBy: options.createdBy || "cli"
+  };
+  if (options.message) checkpoint.message = options.message;
+  if (options.notes) checkpoint.notes = options.notes;
+  log.checkpoints.push(checkpoint);
+  log.lastCheckpoint = checkpoint.id;
+  if (log.checkpoints.length > 50) {
+    log.checkpoints = log.checkpoints.slice(-50);
+  }
+  await writeFile(checkpointPath, JSON.stringify(log, null, 2));
+  await updateAgentsMdWithCheckpoint(checkpoint, workDir);
+  return checkpoint;
+}
+async function listCheckpoints(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const checkpointPath = join(dir, ".trie", "checkpoints.json");
+  try {
+    if (existsSync(checkpointPath)) {
+      const log = JSON.parse(await readFile(checkpointPath, "utf-8"));
+      return log.checkpoints;
+    }
+  } catch {
+  }
+  return [];
+}
+async function getLastCheckpoint(workDir) {
+  const checkpoints = await listCheckpoints(workDir);
+  const last = checkpoints[checkpoints.length - 1];
+  return last ?? null;
+}
+async function updateAgentsMdWithCheckpoint(checkpoint, workDir) {
+  const agentsPath = join(workDir, ".trie", "AGENTS.md");
+  let content = "";
+  try {
+    if (existsSync(agentsPath)) {
+      content = await readFile(agentsPath, "utf-8");
+    }
+  } catch {
+    content = "";
+  }
+  const checkpointSection = `
+## Last Checkpoint
+
+- **ID:** ${checkpoint.id}
+- **Time:** ${checkpoint.timestamp}
+${checkpoint.message ? `- **Message:** ${checkpoint.message}` : ""}
+${checkpoint.files.length > 0 ? `- **Files:** ${checkpoint.files.length} files` : ""}
+${checkpoint.notes ? `- **Notes:** ${checkpoint.notes}` : ""}
+`;
+  const checkpointRegex = /## Last Checkpoint[\s\S]*?(?=\n## |\n---|\Z)/;
+  if (checkpointRegex.test(content)) {
+    content = content.replace(checkpointRegex, checkpointSection.trim());
+  } else {
+    content = content.trim() + "\n\n" + checkpointSection.trim() + "\n";
+  }
+  await writeFile(agentsPath, content);
+}
+async function handleCheckpointCommand(args) {
+  const subcommand = args[0] || "save";
+  switch (subcommand) {
+    case "save": {
+      let message;
+      let notes;
+      const files = [];
+      for (let i = 1; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "-m" || arg === "--message") {
+          message = args[++i] ?? "";
+        } else if (arg === "-n" || arg === "--notes") {
+          notes = args[++i] ?? "";
+        } else if (arg === "-f" || arg === "--file") {
+          const file = args[++i];
+          if (file) files.push(file);
+        } else if (arg && !arg.startsWith("-")) {
+          message = arg;
+        }
+      }
+      const opts = { files };
+      if (message) opts.message = message;
+      if (notes) opts.notes = notes;
+      const checkpoint = await saveCheckpoint(opts);
+      console.log("\n  Checkpoint saved\n");
+      console.log(`  ID: ${checkpoint.id}`);
+      console.log(`  Time: ${checkpoint.timestamp}`);
+      if (checkpoint.message) {
+        console.log(`  Message: ${checkpoint.message}`);
+      }
+      if (checkpoint.files.length > 0) {
+        console.log(`  Files: ${checkpoint.files.join(", ")}`);
+      }
+      console.log("\n  Context saved to .trie/\n");
+      break;
+    }
+    case "list": {
+      const checkpoints = await listCheckpoints();
+      if (checkpoints.length === 0) {
+        console.log("\n  No checkpoints yet. Run `trie checkpoint` to save one.\n");
+        return;
+      }
+      console.log("\n  Checkpoints:\n");
+      for (const cp of checkpoints.slice(-10).reverse()) {
+        const date = new Date(cp.timestamp).toLocaleString();
+        console.log(`  ${cp.id}  ${date}  ${cp.message || "(no message)"}`);
+      }
+      console.log("");
+      break;
+    }
+    case "last": {
+      const checkpoint = await getLastCheckpoint();
+      if (!checkpoint) {
+        console.log("\n  No checkpoints yet. Run `trie checkpoint` to save one.\n");
+        return;
+      }
+      console.log("\n  Last Checkpoint:\n");
+      console.log(`  ID: ${checkpoint.id}`);
+      console.log(`  Time: ${new Date(checkpoint.timestamp).toLocaleString()}`);
+      if (checkpoint.message) {
+        console.log(`  Message: ${checkpoint.message}`);
+      }
+      if (checkpoint.notes) {
+        console.log(`  Notes: ${checkpoint.notes}`);
+      }
+      if (checkpoint.files.length > 0) {
+        console.log(`  Files: ${checkpoint.files.join(", ")}`);
+      }
+      console.log("");
+      break;
+    }
+    default:
+      console.log(`
+  Usage: trie checkpoint [command] [options]
+
+  Commands:
+    save [message]     Save a checkpoint (default)
+    list               List recent checkpoints
+    last               Show the last checkpoint
+
+  Options:
+    -m, --message      Checkpoint message
+    -n, --notes        Additional notes
+    -f, --file         File to include (can be repeated)
+
+  Examples:
+    trie checkpoint "finished auth flow"
+    trie checkpoint save -m "WIP: payment integration" -n "needs testing"
+    trie checkpoint list
+`);
+  }
+}
+
+// src/bootstrap/stack-detector.ts
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var SKILL_MAPPINGS = {
+  // Frontend Frameworks - React/Next.js
+  "next": [
+    "vercel-labs/agent-skills vercel-react-best-practices",
+    "vercel-labs/agent-skills web-design-guidelines",
+    "anthropics/skills frontend-design",
+    "wshobson/agents nextjs-app-router-patterns"
+  ],
+  "react": [
+    "vercel-labs/agent-skills vercel-react-best-practices",
+    "anthropics/skills frontend-design",
+    "wshobson/agents react-state-management"
+  ],
+  // Vue/Nuxt Ecosystem
+  "vue": [
+    "hyf0/vue-skills vue-best-practices",
+    "hyf0/vue-skills pinia-best-practices",
+    "hyf0/vue-skills vueuse-best-practices",
+    "onmax/nuxt-skills vue"
+  ],
+  "nuxt": [
+    "onmax/nuxt-skills nuxt",
+    "onmax/nuxt-skills nuxt-ui",
+    "onmax/nuxt-skills nuxt-content",
+    "onmax/nuxt-skills nuxt-modules",
+    "onmax/nuxt-skills nuxt-better-auth",
+    "onmax/nuxt-skills nuxthub"
+  ],
+  "pinia": [
+    "hyf0/vue-skills pinia-best-practices"
+  ],
+  "@vueuse/core": [
+    "hyf0/vue-skills vueuse-best-practices",
+    "onmax/nuxt-skills vueuse"
+  ],
+  // Mobile - Expo
+  "expo": [
+    "expo/skills building-native-ui",
+    "expo/skills upgrading-expo",
+    "expo/skills native-data-fetching",
+    "expo/skills expo-dev-client",
+    "expo/skills expo-deployment",
+    "expo/skills expo-api-routes",
+    "expo/skills expo-tailwind-setup",
+    "expo/skills expo-cicd-workflows",
+    "expo/skills use-dom"
+  ],
+  // Mobile - React Native
+  "react-native": [
+    "callstackincubator/agent-skills react-native-best-practices",
+    "wshobson/agents react-native-architecture"
+  ],
+  // Backend Frameworks
+  "@nestjs/core": [
+    "kadajett/agent-nestjs-skills nestjs-best-practices"
+  ],
+  "nestjs": [
+    "kadajett/agent-nestjs-skills nestjs-best-practices"
+  ],
+  "elysia": [
+    "elysiajs/skills elysiajs"
+  ],
+  "hono": [
+    "elysiajs/skills elysiajs"
+  ],
+  // Database/BaaS
+  "@supabase/supabase-js": [
+    "supabase/agent-skills supabase-postgres-best-practices"
+  ],
+  "convex": [
+    "waynesutton/convexskills convex-best-practices"
+  ],
+  "pg": [
+    "wshobson/agents postgresql-table-design"
+  ],
+  "postgres": [
+    "wshobson/agents postgresql-table-design"
+  ],
+  // Auth
+  "better-auth": [
+    "better-auth/skills better-auth-best-practices",
+    "better-auth/skills create-auth-skill"
+  ],
+  // Payments
+  "stripe": [
+    "stripe/ai stripe-best-practices"
+  ],
+  "@stripe/stripe-js": [
+    "stripe/ai stripe-best-practices"
+  ],
+  // Media/Graphics
+  "remotion": [
+    "remotion-dev/skills remotion-best-practices"
+  ],
+  "three": [
+    "cloudai-x/threejs-skills threejs-fundamentals",
+    "cloudai-x/threejs-skills threejs-animation",
+    "cloudai-x/threejs-skills threejs-materials",
+    "cloudai-x/threejs-skills threejs-shaders",
+    "cloudai-x/threejs-skills threejs-lighting",
+    "cloudai-x/threejs-skills threejs-geometry",
+    "cloudai-x/threejs-skills threejs-textures",
+    "cloudai-x/threejs-skills threejs-loaders",
+    "cloudai-x/threejs-skills threejs-interaction",
+    "cloudai-x/threejs-skills threejs-postprocessing"
+  ],
+  // UI Libraries
+  "tailwindcss": [
+    "wshobson/agents tailwind-design-system",
+    "jezweb/claude-skills tailwind-v4-shadcn",
+    "wshobson/agents responsive-design"
+  ],
+  "@shadcn/ui": [
+    "giuseppe-trisciuoglio/developer-kit shadcn-ui"
+  ],
+  "shadcn": [
+    "giuseppe-trisciuoglio/developer-kit shadcn-ui"
+  ],
+  "@radix-ui/react-slot": [
+    "onmax/nuxt-skills reka-ui"
+  ],
+  // State Management
+  "@tanstack/react-query": [
+    "jezweb/claude-skills tanstack-query"
+  ],
+  // Testing
+  "playwright": [
+    "anthropics/skills webapp-testing",
+    "wshobson/agents e2e-testing-patterns"
+  ],
+  "puppeteer": [
+    "anthropics/skills webapp-testing"
+  ],
+  "vitest": [
+    "wshobson/agents e2e-testing-patterns"
+  ],
+  "jest": [
+    "wshobson/agents e2e-testing-patterns"
+  ],
+  // DevTools/MCP
+  "@modelcontextprotocol/sdk": [
+    "anthropics/skills mcp-builder"
+  ],
+  // Security
+  "semgrep": [
+    "trailofbits/skills semgrep"
+  ],
+  // Monorepos
+  "turbo": [
+    "wshobson/agents monorepo-management"
+  ],
+  "nx": [
+    "wshobson/agents monorepo-management"
+  ],
+  "lerna": [
+    "wshobson/agents monorepo-management"
+  ],
+  // TypeScript (handled separately based on tsconfig.json)
+  "typescript": [
+    "wshobson/agents typescript-advanced-types"
+  ]
+};
+var SKILL_CATEGORIES = {
+  documents: [
+    "anthropics/skills pdf",
+    "anthropics/skills xlsx",
+    "anthropics/skills pptx",
+    "anthropics/skills docx",
+    "anthropics/skills doc-coauthoring"
+  ],
+  design: [
+    "anthropics/skills canvas-design",
+    "anthropics/skills theme-factory",
+    "anthropics/skills web-artifacts-builder",
+    "anthropics/skills algorithmic-art",
+    "anthropics/skills brand-guidelines",
+    "anthropics/skills slack-gif-creator",
+    "nextlevelbuilder/ui-ux-pro-max ui-ux-pro-max",
+    "superdesigndev/superdesign-skill superdesign",
+    "wshobson/agents design-system-patterns"
+  ],
+  marketing: [
+    "coreyhaines31/marketingskills seo-audit",
+    "coreyhaines31/marketingskills copywriting",
+    "coreyhaines31/marketingskills marketing-psychology",
+    "coreyhaines31/marketingskills programmatic-seo",
+    "coreyhaines31/marketingskills marketing-ideas",
+    "coreyhaines31/marketingskills copy-editing",
+    "coreyhaines31/marketingskills pricing-strategy",
+    "coreyhaines31/marketingskills social-content",
+    "coreyhaines31/marketingskills launch-strategy",
+    "coreyhaines31/marketingskills page-cro",
+    "coreyhaines31/marketingskills competitor-alternatives",
+    "coreyhaines31/marketingskills analytics-tracking",
+    "coreyhaines31/marketingskills schema-markup",
+    "coreyhaines31/marketingskills onboarding-cro",
+    "coreyhaines31/marketingskills email-sequence",
+    "coreyhaines31/marketingskills paid-ads",
+    "coreyhaines31/marketingskills signup-flow-cro",
+    "coreyhaines31/marketingskills free-tool-strategy",
+    "coreyhaines31/marketingskills form-cro",
+    "coreyhaines31/marketingskills paywall-upgrade-cro",
+    "coreyhaines31/marketingskills referral-program",
+    "coreyhaines31/marketingskills popup-cro",
+    "coreyhaines31/marketingskills ab-test-setup"
+  ],
+  development: [
+    "obra/superpowers brainstorming",
+    "obra/superpowers test-driven-development",
+    "obra/superpowers systematic-debugging",
+    "obra/superpowers writing-plans",
+    "obra/superpowers executing-plans",
+    "obra/superpowers verification-before-completion",
+    "obra/superpowers using-superpowers",
+    "obra/superpowers subagent-driven-development",
+    "obra/superpowers requesting-code-review",
+    "obra/superpowers writing-skills",
+    "obra/superpowers dispatching-parallel-agents",
+    "obra/superpowers receiving-code-review",
+    "obra/superpowers using-git-worktrees",
+    "obra/superpowers finishing-a-development-branch",
+    "wshobson/agents code-review-excellence",
+    "wshobson/agents api-design-principles",
+    "wshobson/agents architecture-patterns",
+    "wshobson/agents error-handling-patterns",
+    "wshobson/agents nodejs-backend-patterns",
+    "wshobson/agents microservices-patterns",
+    "wshobson/agents modern-javascript-patterns",
+    "wshobson/agents web-component-design",
+    "wshobson/agents async-python-patterns",
+    "wshobson/agents python-testing-patterns",
+    "boristane/agent-skills logging-best-practices"
+  ],
+  productivity: [
+    "softaworks/agent-toolkit daily-meeting-update",
+    "softaworks/agent-toolkit agent-md-refactor",
+    "softaworks/agent-toolkit session-handoff",
+    "softaworks/agent-toolkit meme-factory",
+    "softaworks/agent-toolkit qa-test-planner",
+    "softaworks/agent-toolkit writing-clearly-and-concisely",
+    "softaworks/agent-toolkit commit-work",
+    "softaworks/agent-toolkit mermaid-diagrams",
+    "softaworks/agent-toolkit dependency-updater",
+    "softaworks/agent-toolkit crafting-effective-readmes",
+    "softaworks/agent-toolkit reducing-entropy",
+    "softaworks/agent-toolkit feedback-mastery",
+    "softaworks/agent-toolkit marp-slide",
+    "softaworks/agent-toolkit professional-communication",
+    "softaworks/agent-toolkit difficult-workplace-conversations",
+    "anthropics/skills internal-comms",
+    "othmanadi/planning-with-files planning-with-files"
+  ],
+  security: [
+    "trailofbits/skills semgrep",
+    "trailofbits/skills secure-workflow-guide",
+    "trailofbits/skills codeql",
+    "trailofbits/skills property-based-testing",
+    "trailofbits/skills variant-analysis",
+    "trailofbits/skills guidelines-advisor",
+    "trailofbits/skills sharp-edges",
+    "trailofbits/skills differential-review",
+    "trailofbits/skills ask-questions-if-underspecified",
+    "squirrelscan/skills audit-website"
+  ],
+  mobile: [
+    "wshobson/agents mobile-ios-design",
+    "wshobson/agents mobile-android-design",
+    "dimillian/skills swiftui-ui-patterns",
+    "dimillian/skills swiftui-liquid-glass"
+  ],
+  obsidian: [
+    "kepano/obsidian-skills obsidian-markdown",
+    "kepano/obsidian-skills obsidian-bases",
+    "kepano/obsidian-skills json-canvas"
+  ],
+  prompts: [
+    "f/awesome-chatgpt-prompts skill-lookup",
+    "f/awesome-chatgpt-prompts prompt-lookup",
+    "wshobson/agents prompt-engineering-patterns"
+  ],
+  browser: [
+    "vercel-labs/agent-browser agent-browser"
+  ],
+  content: [
+    "op7418/humanizer-zh humanizer-zh",
+    "blader/humanizer humanizer",
+    "op7418/youtube-clipper-skill youtube-clipper",
+    "jimliu/baoyu-skills baoyu-slide-deck",
+    "jimliu/baoyu-skills baoyu-article-illustrator",
+    "jimliu/baoyu-skills baoyu-cover-image",
+    "jimliu/baoyu-skills baoyu-comic",
+    "jimliu/baoyu-skills baoyu-infographic",
+    "jimliu/baoyu-skills baoyu-image-gen"
+  ],
+  integrations: [
+    "intellectronica/agent-skills context7",
+    "softaworks/agent-toolkit gemini",
+    "softaworks/agent-toolkit codex"
+  ]
+};
+async function detectStack(projectDir) {
+  const stack = {
+    suggestedSkills: [],
+    suggestedAgents: ["security", "privacy", "bugs"],
+    dependencies: /* @__PURE__ */ new Set()
+  };
+  if (existsSync2(join2(projectDir, "tsconfig.json"))) {
+    stack.language = "TypeScript";
+    stack.suggestedAgents.push("typecheck");
+    stack.suggestedSkills.push("wshobson/agents typescript-advanced-types");
+  } else if (existsSync2(join2(projectDir, "package.json"))) {
+    stack.language = "JavaScript";
+  } else if (existsSync2(join2(projectDir, "requirements.txt")) || existsSync2(join2(projectDir, "pyproject.toml"))) {
+    stack.language = "Python";
+  } else if (existsSync2(join2(projectDir, "go.mod"))) {
+    stack.language = "Go";
+  } else if (existsSync2(join2(projectDir, "Cargo.toml"))) {
+    stack.language = "Rust";
+  }
+  if (existsSync2(join2(projectDir, "Package.swift")) || existsSync2(join2(projectDir, "project.pbxproj")) || existsSync2(join2(projectDir, "*.xcodeproj"))) {
+    stack.language = "Swift";
+    stack.suggestedSkills.push("dimillian/skills swiftui-ui-patterns");
+    stack.suggestedSkills.push("dimillian/skills swiftui-liquid-glass");
+  }
+  if (existsSync2(join2(projectDir, "pnpm-lock.yaml"))) {
+    stack.packageManager = "pnpm";
+  } else if (existsSync2(join2(projectDir, "yarn.lock"))) {
+    stack.packageManager = "yarn";
+  } else if (existsSync2(join2(projectDir, "bun.lockb"))) {
+    stack.packageManager = "bun";
+  } else if (existsSync2(join2(projectDir, "package-lock.json"))) {
+    stack.packageManager = "npm";
+  }
+  if (existsSync2(join2(projectDir, ".github", "workflows"))) {
+    stack.suggestedSkills.push("wshobson/agents github-actions-templates");
+  }
+  try {
+    const pkgPath = join2(projectDir, "package.json");
+    if (existsSync2(pkgPath)) {
+      const pkgContent = await readFile2(pkgPath, "utf-8");
+      const pkg = JSON.parse(pkgContent);
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      for (const dep of Object.keys(deps)) {
+        stack.dependencies.add(dep);
+      }
+      for (const dep of Object.keys(deps)) {
+        const skills = SKILL_MAPPINGS[dep];
+        if (skills) {
+          stack.suggestedSkills.push(...skills);
+        }
+      }
+      if (deps["next"]) {
+        stack.framework = `Next.js ${deps["next"].replace("^", "")}`;
+        stack.suggestedAgents.push("accessibility", "design");
+      } else if (deps["react"]) {
+        stack.framework = `React ${deps["react"].replace("^", "")}`;
+        stack.suggestedAgents.push("accessibility");
+      } else if (deps["vue"]) {
+        stack.framework = `Vue ${deps["vue"].replace("^", "")}`;
+      } else if (deps["nuxt"]) {
+        stack.framework = `Nuxt ${deps["nuxt"].replace("^", "")}`;
+      } else if (deps["svelte"]) {
+        stack.framework = "Svelte";
+      } else if (deps["express"]) {
+        stack.framework = "Express.js";
+      } else if (deps["fastify"]) {
+        stack.framework = "Fastify";
+      } else if (deps["hono"]) {
+        stack.framework = "Hono";
+      } else if (deps["elysia"]) {
+        stack.framework = "Elysia";
+      } else if (deps["@nestjs/core"]) {
+        stack.framework = "NestJS";
+      }
+      if (deps["next-auth"] || deps["@auth/core"]) {
+        stack.auth = "NextAuth.js";
+      } else if (deps["passport"]) {
+        stack.auth = "Passport.js";
+      } else if (deps["@clerk/nextjs"] || deps["@clerk/clerk-react"]) {
+        stack.auth = "Clerk";
+      } else if (deps["better-auth"]) {
+        stack.auth = "Better Auth";
+      }
+      if (deps["prisma"] || deps["@prisma/client"]) {
+        stack.database = "Prisma ORM";
+      } else if (deps["drizzle-orm"]) {
+        stack.database = "Drizzle ORM";
+      } else if (deps["@supabase/supabase-js"]) {
+        stack.database = "Supabase";
+      } else if (deps["mongoose"]) {
+        stack.database = "MongoDB (Mongoose)";
+      } else if (deps["pg"]) {
+        stack.database = "PostgreSQL";
+      } else if (deps["convex"]) {
+        stack.database = "Convex";
+      }
+      if (deps["stripe"] || deps["@stripe/stripe-js"]) {
+        stack.suggestedAgents.push("moneybags");
+      }
+    }
+  } catch {
+  }
+  if (!stack.database) {
+    if (existsSync2(join2(projectDir, "prisma", "schema.prisma"))) {
+      stack.database = "Prisma ORM";
+    } else if (existsSync2(join2(projectDir, "drizzle.config.ts"))) {
+      stack.database = "Drizzle ORM";
+    }
+  }
+  stack.suggestedSkills = [...new Set(stack.suggestedSkills)];
+  stack.suggestedAgents = [...new Set(stack.suggestedAgents)];
+  return stack;
+}
+function getSkillsByCategory(category) {
+  return SKILL_CATEGORIES[category] || [];
+}
+function getSkillCategories() {
+  return Object.entries(SKILL_CATEGORIES).map(([name, skills]) => ({
+    name,
+    count: skills.length
+  }));
+}
+
+// src/bootstrap/files.ts
+import { readFile as readFile3, writeFile as writeFile2, unlink, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+var BOOTSTRAP_FILES = [
+  { name: "PROJECT.md", type: "user", description: "Project overview and conventions" },
+  { name: "RULES.md", type: "user", description: "Coding standards agents enforce" },
+  { name: "TEAM.md", type: "user", description: "Team ownership and escalation" },
+  { name: "BOOTSTRAP.md", type: "one-time", description: "First-run setup (deleted after)" },
+  { name: "AGENTS.md", type: "auto", description: "Auto-generated scan context" }
+];
+async function loadBootstrapContext(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const trieDir = join3(projectDir, ".trie");
+  const files = [];
+  const contentParts = [];
+  let needsBootstrap2 = false;
+  for (const file of BOOTSTRAP_FILES) {
+    const filePath = join3(trieDir, file.name);
+    const exists = existsSync3(filePath);
+    if (file.name === "BOOTSTRAP.md" && exists) {
+      needsBootstrap2 = true;
+    }
+    let content;
+    if (exists) {
+      try {
+        content = await readFile3(filePath, "utf-8");
+        if (content.trim() && file.type !== "one-time") {
+          contentParts.push(`<!-- ${file.name} -->
+${content}`);
+        }
+      } catch {
+      }
+    }
+    const fileEntry = {
+      name: file.name,
+      path: filePath,
+      type: file.type,
+      exists
+    };
+    if (content) fileEntry.content = content;
+    files.push(fileEntry);
+  }
+  return {
+    files,
+    injectedContent: contentParts.join("\n\n---\n\n"),
+    needsBootstrap: needsBootstrap2
+  };
+}
+async function initializeBootstrapFiles(options = {}) {
+  const projectDir = options.workDir || getWorkingDirectory(void 0, true);
+  const trieDir = join3(projectDir, ".trie");
+  await mkdir2(trieDir, { recursive: true });
+  const created = [];
+  const skipped = [];
+  const stack = await detectStack(projectDir);
+  for (const file of BOOTSTRAP_FILES) {
+    const filePath = join3(trieDir, file.name);
+    const exists = existsSync3(filePath);
+    if (exists && !options.force) {
+      skipped.push(file.name);
+      continue;
+    }
+    if (file.name === "BOOTSTRAP.md" && options.skipBootstrap) {
+      skipped.push(file.name);
+      continue;
+    }
+    if (file.name === "AGENTS.md") {
+      skipped.push(file.name);
+      continue;
+    }
+    const template = getFileTemplate(file.name, stack);
+    if (template) {
+      await writeFile2(filePath, template);
+      created.push(file.name);
+    }
+  }
+  return { created, skipped, stack };
+}
+async function completeBootstrap(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const bootstrapPath = join3(projectDir, ".trie", "BOOTSTRAP.md");
+  try {
+    await unlink(bootstrapPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function needsBootstrap(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const bootstrapPath = join3(projectDir, ".trie", "BOOTSTRAP.md");
+  return existsSync3(bootstrapPath);
+}
+async function loadRules(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const rulesPath = join3(projectDir, ".trie", "RULES.md");
+  try {
+    if (existsSync3(rulesPath)) {
+      return await readFile3(rulesPath, "utf-8");
+    }
+  } catch {
+  }
+  return null;
+}
+async function loadTeamInfo(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const teamPath = join3(projectDir, ".trie", "TEAM.md");
+  try {
+    if (existsSync3(teamPath)) {
+      return await readFile3(teamPath, "utf-8");
+    }
+  } catch {
+  }
+  return null;
+}
+function getFileTemplate(fileName, stack) {
+  switch (fileName) {
+    case "PROJECT.md":
+      return getProjectTemplate(stack);
+    case "RULES.md":
+      return getRulesTemplate(stack);
+    case "TEAM.md":
+      return getTeamTemplate();
+    case "BOOTSTRAP.md":
+      return getBootstrapTemplate(stack);
+    default:
+      return null;
+  }
+}
+function getProjectTemplate(stack) {
+  const lines = ["# Project Overview", "", "> Define your project context here. AI assistants read this first.", ""];
+  lines.push("## Description", "", "[Describe what this project does and who it's for]", "");
+  lines.push("## Technology Stack", "");
+  if (stack.framework) lines.push(`- **Framework:** ${stack.framework}`);
+  if (stack.language) lines.push(`- **Language:** ${stack.language}`);
+  if (stack.database) lines.push(`- **Database:** ${stack.database}`);
+  if (stack.auth) lines.push(`- **Auth:** ${stack.auth}`);
+  if (!stack.framework && !stack.language && !stack.database) {
+    lines.push("[Add your technology stack]");
+  }
+  lines.push("");
+  lines.push("## Architecture", "", "[Key patterns and design decisions]", "");
+  lines.push("## Coding Conventions", "", "[Style rules agents should follow]", "");
+  lines.push("## AI Instructions", "", "When working on this project:", "1. [Instruction 1]", "2. [Instruction 2]", "3. [Instruction 3]", "");
+  lines.push("---", "", "*Edit this file to provide project context to AI assistants.*");
+  return lines.join("\n");
+}
+function getRulesTemplate(stack) {
+  const packageManager = stack.packageManager || "npm";
+  return `# Project Rules
+
+> These rules are enforced by Trie agents during scans.
+> Violations appear as issues with [RULES] prefix.
+
+## Code Style
+
+1. Use named exports, not default exports
+2. Prefer \`${packageManager}\` for package management
+3. Maximum file length: 300 lines
+4. Use TypeScript strict mode
+
+## Testing Requirements
+
+1. Critical paths require unit tests
+2. API endpoints require integration tests
+3. Minimum coverage: 70%
+
+## Security Rules
+
+1. Never log sensitive data (passwords, tokens, PII)
+2. All API routes require authentication
+3. Rate limiting required on public endpoints
+4. SQL queries must use parameterized statements
+
+## Review Requirements
+
+1. All PRs require at least 1 reviewer
+2. Security-sensitive changes require security review
+3. Database migrations require review
+
+---
+
+*Edit this file to define your project's coding standards.*
+`;
+}
+function getTeamTemplate() {
+  return `# Team Structure
+
+## Code Ownership
+
+| Area | Owner | Backup | Review Required |
+|------|-------|--------|-----------------|
+| \`/src/api/\` | @backend-team | - | 1 approver |
+| \`/src/ui/\` | @frontend-team | - | 1 approver |
+| \`/src/auth/\` | @security-team | - | Security review |
+
+## Escalation
+
+| Severity | First Contact | Escalate To | SLA |
+|----------|--------------|-------------|-----|
+| Critical | Team lead | CTO | 1 hour |
+| Serious | PR reviewer | Team lead | 4 hours |
+| Moderate | Self-serve | - | 1 day |
+
+## Contacts
+
+- **Security:** [email/slack]
+- **Privacy:** [email/slack]
+- **Emergencies:** [phone/pager]
+
+---
+
+*Edit this file to define your team structure.*
+`;
+}
+function getBootstrapTemplate(stack) {
+  const skillCommands = stack.suggestedSkills.map((s) => `trie skills add ${s}`).join("\n");
+  const agentList = stack.suggestedAgents.join(", ");
+  const lines = [
+    "# Trie Bootstrap Checklist",
+    "",
+    "This file guides your first scan setup. **Delete when complete.**",
+    "",
+    "## Auto-Detected Stack",
+    "",
+    "Based on your project, Trie detected:"
+  ];
+  if (stack.framework) lines.push(`- **Framework:** ${stack.framework}`);
+  if (stack.language) lines.push(`- **Language:** ${stack.language}`);
+  if (stack.database) lines.push(`- **Database:** ${stack.database}`);
+  if (stack.auth) lines.push(`- **Auth:** ${stack.auth}`);
+  lines.push("", "## Recommended Actions", "", "### 1. Skills to Install", "Based on your stack, consider installing:", "```bash");
+  lines.push(skillCommands || "# No specific skills detected - browse https://skills.sh");
+  lines.push("```", "", "### 2. Agents to Enable", `Your stack suggests these agents: ${agentList || "security, privacy, bugs"}`, "");
+  lines.push("### 3. Configure Rules", "Add your coding standards to `.trie/RULES.md`.", "");
+  lines.push("### 4. Run First Scan", "```bash", "trie scan", "```", "");
+  lines.push("---", "", "**Delete this file after completing setup.** Run:", "```bash", "rm .trie/BOOTSTRAP.md", "```");
+  return lines.join("\n");
+}
+
+// src/context/graph.ts
+import crypto from "crypto";
+import path2 from "path";
+
+// src/context/store.ts
+import Database from "better-sqlite3";
+import fs from "fs";
+import path from "path";
+var ContextStore = class {
+  db;
+  dbFilePath;
+  constructor(projectPath, dbFilePath) {
+    this.dbFilePath = dbFilePath ?? path.join(projectPath, ".trie", "context.db");
+    this.ensureDirectory();
+    this.db = new Database(this.dbFilePath);
+    this.configure();
+    this.prepareSchema();
+  }
+  get databasePath() {
+    return this.dbFilePath;
+  }
+  addNode(node) {
+    const stmt = this.db.prepare(
+      `INSERT INTO nodes (id, type, data, created_at, updated_at)
+       VALUES (@id, @type, @data, @created_at, @updated_at)`
+    );
+    stmt.run({
+      id: node.id,
+      type: node.type,
+      data: JSON.stringify(node.data),
+      created_at: node.created_at,
+      updated_at: node.updated_at
+    });
+    return node;
+  }
+  upsertNode(node) {
+    const stmt = this.db.prepare(
+      `INSERT INTO nodes (id, type, data, created_at, updated_at)
+       VALUES (@id, @type, @data, @created_at, @updated_at)
+       ON CONFLICT(id) DO UPDATE SET
+         type=excluded.type,
+         data=excluded.data,
+         updated_at=excluded.updated_at`
+    );
+    stmt.run({
+      id: node.id,
+      type: node.type,
+      data: JSON.stringify(node.data),
+      created_at: node.created_at,
+      updated_at: node.updated_at
+    });
+    return node;
+  }
+  getNode(id) {
+    const row = this.db.prepare("SELECT * FROM nodes WHERE id = ?").get(id);
+    return row ? this.mapNodeRow(row) : null;
+  }
+  getNodeByType(type, id) {
+    const row = this.db.prepare("SELECT * FROM nodes WHERE id = ? AND type = ?").get(id, type);
+    return row ? this.mapNodeRow(row) : null;
+  }
+  updateNode(id, updates, updatedAt) {
+    const existing = this.getNode(id);
+    if (!existing) {
+      return null;
+    }
+    const merged = {
+      ...existing,
+      data: { ...existing.data, ...updates },
+      updated_at: updatedAt
+    };
+    this.db.prepare(
+      `UPDATE nodes SET data = @data, updated_at = @updated_at
+         WHERE id = @id`
+    ).run({
+      id,
+      data: JSON.stringify(merged.data),
+      updated_at: merged.updated_at
+    });
+    return merged;
+  }
+  deleteNode(id) {
+    const deleteEdges = this.db.prepare("DELETE FROM edges WHERE from_id = ? OR to_id = ?");
+    const deleteNodeStmt = this.db.prepare("DELETE FROM nodes WHERE id = ?");
+    const transaction = this.db.transaction((nodeId) => {
+      deleteEdges.run(nodeId, nodeId);
+      deleteNodeStmt.run(nodeId);
+    });
+    transaction(id);
+  }
+  listNodes() {
+    const rows = this.db.prepare("SELECT * FROM nodes").all();
+    return rows.map((row) => this.mapNodeRow(row));
+  }
+  findNodesByType(type) {
+    const rows = this.db.prepare("SELECT * FROM nodes WHERE type = ?").all(type);
+    return rows.map((row) => this.mapNodeRow(row));
+  }
+  addEdge(edge) {
+    const stmt = this.db.prepare(
+      `INSERT INTO edges (id, from_id, to_id, type, weight, metadata, created_at)
+       VALUES (@id, @from_id, @to_id, @type, @weight, @metadata, @created_at)`
+    );
+    stmt.run({
+      id: edge.id,
+      from_id: edge.from_id,
+      to_id: edge.to_id,
+      type: edge.type,
+      weight: edge.weight,
+      metadata: JSON.stringify(edge.metadata ?? {}),
+      created_at: edge.created_at
+    });
+    return edge;
+  }
+  upsertEdge(edge) {
+    const stmt = this.db.prepare(
+      `INSERT INTO edges (id, from_id, to_id, type, weight, metadata, created_at)
+       VALUES (@id, @from_id, @to_id, @type, @weight, @metadata, @created_at)
+       ON CONFLICT(id) DO UPDATE SET
+         from_id=excluded.from_id,
+         to_id=excluded.to_id,
+         type=excluded.type,
+         weight=excluded.weight,
+         metadata=excluded.metadata`
+    );
+    stmt.run({
+      id: edge.id,
+      from_id: edge.from_id,
+      to_id: edge.to_id,
+      type: edge.type,
+      weight: edge.weight,
+      metadata: JSON.stringify(edge.metadata ?? {}),
+      created_at: edge.created_at
+    });
+    return edge;
+  }
+  getEdge(id) {
+    const row = this.db.prepare("SELECT * FROM edges WHERE id = ?").get(id);
+    return row ? this.mapEdgeRow(row) : null;
+  }
+  getEdges(nodeId, direction = "both") {
+    let rows;
+    if (direction === "in") {
+      rows = this.db.prepare("SELECT * FROM edges WHERE to_id = ?").all(nodeId);
+    } else if (direction === "out") {
+      rows = this.db.prepare("SELECT * FROM edges WHERE from_id = ?").all(nodeId);
+    } else {
+      rows = this.db.prepare("SELECT * FROM edges WHERE from_id = ? OR to_id = ?").all(nodeId, nodeId);
+    }
+    return rows.map((row) => this.mapEdgeRow(row));
+  }
+  listEdges() {
+    const rows = this.db.prepare("SELECT * FROM edges").all();
+    return rows.map((row) => this.mapEdgeRow(row));
+  }
+  deleteEdge(id) {
+    this.db.prepare("DELETE FROM edges WHERE id = ?").run(id);
+  }
+  close() {
+    this.db.close();
+  }
+  ensureDirectory() {
+    fs.mkdirSync(path.dirname(this.dbFilePath), { recursive: true });
+  }
+  configure() {
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("busy_timeout = 5000");
+    this.db.pragma("synchronous = NORMAL");
+  }
+  prepareSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS nodes (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        data TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS edges (
+        id TEXT PRIMARY KEY,
+        from_id TEXT NOT NULL,
+        to_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        weight REAL NOT NULL DEFAULT 1,
+        metadata TEXT DEFAULT '{}',
+        created_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_nodes_type ON nodes(type);
+      CREATE INDEX IF NOT EXISTS idx_edges_from ON edges(from_id);
+      CREATE INDEX IF NOT EXISTS idx_edges_to ON edges(to_id);
+      CREATE INDEX IF NOT EXISTS idx_edges_type ON edges(type);
+    `);
+  }
+  mapNodeRow(row) {
+    return {
+      id: row.id,
+      type: row.type,
+      data: JSON.parse(row.data),
+      created_at: row.created_at,
+      updated_at: row.updated_at
+    };
+  }
+  mapEdgeRow(row) {
+    return {
+      id: row.id,
+      from_id: row.from_id,
+      to_id: row.to_id,
+      type: row.type,
+      weight: row.weight,
+      created_at: row.created_at,
+      metadata: row.metadata ? JSON.parse(row.metadata) : {}
+    };
+  }
+};
+
+// src/context/graph.ts
+var ContextGraph = class {
+  store;
+  projectPath;
+  constructor(projectPath, dbPath, store) {
+    this.projectPath = projectPath;
+    this.store = store ?? new ContextStore(projectPath, dbPath);
+  }
+  get projectRoot() {
+    return this.projectPath;
+  }
+  async addNode(type, data) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = this.generateNodeId(type, data);
+    const node = {
+      id,
+      type,
+      data,
+      created_at: now,
+      updated_at: now
+    };
+    this.store.addNode(node);
+    return node;
+  }
+  async getNode(type, id) {
+    return this.store.getNodeByType(type, id);
+  }
+  async updateNode(type, id, updates) {
+    const updated = this.store.updateNode(id, updates, (/* @__PURE__ */ new Date()).toISOString());
+    if (updated && updated.type !== type) {
+      throw new Error(`Type mismatch for node ${id}: expected ${type} but found ${updated.type}`);
+    }
+  }
+  async deleteNode(_type, id) {
+    this.store.deleteNode(id);
+  }
+  async addEdge(fromId, toId, type, metadata = {}, weight = 1) {
+    const edge = {
+      id: crypto.randomUUID(),
+      from_id: fromId,
+      to_id: toId,
+      type,
+      weight,
+      metadata,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.store.addEdge(edge);
+    return edge;
+  }
+  async getEdges(nodeId, direction = "both") {
+    return this.store.getEdges(nodeId, direction);
+  }
+  async getIncidentsForFile(filePath) {
+    const fileNode = this.findFileNode(filePath);
+    if (!fileNode) return [];
+    const incidents = /* @__PURE__ */ new Map();
+    const affectEdges = this.store.getEdges(fileNode.id, "in").filter((edge) => edge.type === "affects");
+    for (const edge of affectEdges) {
+      const changeId = edge.from_id;
+      const leadEdges = this.store.getEdges(changeId, "out").filter((e) => e.type === "leadTo");
+      const causedByEdges = this.store.getEdges(changeId, "in").filter((e) => e.type === "causedBy");
+      for (const le of leadEdges) {
+        const incident = this.store.getNodeByType("incident", le.to_id);
+        if (incident) incidents.set(incident.id, incident);
+      }
+      for (const ce of causedByEdges) {
+        const incident = this.store.getNodeByType("incident", ce.from_id);
+        if (incident) incidents.set(incident.id, incident);
+      }
+    }
+    return Array.from(incidents.values());
+  }
+  async getPatternsForFile(filePath) {
+    const normalized = this.normalizePath(filePath);
+    const nodes = this.store.findNodesByType("pattern");
+    return nodes.filter(
+      (node) => node.data.appliesTo.some((pattern) => normalized.includes(pattern) || filePath.includes(pattern))
+    );
+  }
+  async getRecentChanges(limit) {
+    const nodes = this.store.findNodesByType("change");
+    return nodes.sort((a, b) => new Date(b.data.timestamp).getTime() - new Date(a.data.timestamp).getTime()).slice(0, limit);
+  }
+  async calculateFileRisk(filePath) {
+    const fileNode = this.findFileNode(filePath);
+    if (!fileNode) return "low";
+    const incidentScore = Math.min(fileNode.data.incidentCount * 2, 6);
+    const changeScore = Math.min(fileNode.data.changeCount, 4);
+    const baseScore = this.riskLevelToScore(fileNode.data.riskLevel);
+    const total = baseScore + incidentScore + changeScore;
+    if (total >= 10) return "critical";
+    if (total >= 7) return "high";
+    if (total >= 4) return "medium";
+    return "low";
+  }
+  async listNodes() {
+    return this.store.listNodes();
+  }
+  async listEdges() {
+    return this.store.listEdges();
+  }
+  async deleteEdge(id) {
+    this.store.deleteEdge(id);
+  }
+  async getSnapshot() {
+    return {
+      nodes: this.store.listNodes(),
+      edges: this.store.listEdges(),
+      exported_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async applySnapshot(snapshot) {
+    for (const node of snapshot.nodes) {
+      const existing = this.store.getNode(node.id);
+      if (!existing || this.isNewer(node.updated_at, existing.updated_at)) {
+        this.store.upsertNode(node);
+      }
+    }
+    for (const edge of snapshot.edges) {
+      const existing = this.store.getEdge(edge.id);
+      if (!existing) {
+        this.store.upsertEdge(edge);
+      }
+    }
+  }
+  generateNodeId(type, data) {
+    if (type === "file") {
+      const fileData = data;
+      return this.normalizePath(fileData.path);
+    }
+    if (type === "change") {
+      const changeData = data;
+      if (changeData.commitHash) {
+        return changeData.commitHash;
+      }
+    }
+    return crypto.randomUUID();
+  }
+  findFileNode(filePath) {
+    const normalized = this.normalizePath(filePath);
+    const nodes = this.store.findNodesByType("file");
+    return nodes.find(
+      (node) => node.id === normalized || this.normalizePath(node.data.path) === normalized || node.data.path === filePath
+    ) ?? null;
+  }
+  normalizePath(filePath) {
+    return path2.resolve(this.projectPath, filePath);
+  }
+  riskLevelToScore(level) {
+    switch (level) {
+      case "critical":
+        return 6;
+      case "high":
+        return 4;
+      case "medium":
+        return 2;
+      default:
+        return 0;
+    }
+  }
+  isNewer(incoming, existing) {
+    return new Date(incoming).getTime() >= new Date(existing).getTime();
+  }
+};
+
+// src/agent/perceive.ts
+import path4 from "path";
+
+// src/agent/diff-analyzer.ts
+var RISKY_PATTERNS = [/auth/i, /token/i, /password/i, /secret/i, /validate/i, /sanitize/i];
+function analyzeDiff(diff) {
+  const files = [];
+  let current = null;
+  const lines = diff.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("+++ b/")) {
+      const filePath = line.replace("+++ b/", "").trim();
+      current = {
+        filePath,
+        added: 0,
+        removed: 0,
+        functionsModified: [],
+        riskyPatterns: []
+      };
+      files.push(current);
+      continue;
+    }
+    if (!current) {
+      continue;
+    }
+    if (line.startsWith("@@")) {
+      const match = line.match(/@@.*?(function\s+([\w$]+)|class\s+([\w$]+)|([\w$]+\s*\())/i);
+      const fnName = match?.[2] || match?.[3] || match?.[4];
+      if (fnName) {
+        current.functionsModified.push(fnName.replace("(", "").trim());
+      }
+      continue;
+    }
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      current.added += 1;
+      markRisk(line, current);
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      current.removed += 1;
+      markRisk(line, current);
+    }
+  }
+  const totalAdded = files.reduce((acc, f) => acc + f.added, 0);
+  const totalRemoved = files.reduce((acc, f) => acc + f.removed, 0);
+  const riskyFiles = files.filter((f) => f.riskyPatterns.length > 0).map((f) => f.filePath);
+  return {
+    files,
+    totalAdded,
+    totalRemoved,
+    riskyFiles
+  };
+}
+function markRisk(line, file) {
+  for (const pattern of RISKY_PATTERNS) {
+    if (pattern.test(line)) {
+      const label = pattern.toString();
+      if (!file.riskyPatterns.includes(label)) {
+        file.riskyPatterns.push(label);
+      }
+    }
+  }
+}
+
+// src/agent/git.ts
+import { execFile } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import path3 from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function execGit(args, cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", ["-C", cwd, ...args], {
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return stdout.trim();
+  } catch (error) {
+    const stderr = error?.stderr?.toString();
+    if (stderr?.includes("not a git repository") || stderr?.includes("does not have any commits")) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function ensureRepo(projectPath) {
+  const result = await execGit(["rev-parse", "--is-inside-work-tree"], projectPath);
+  return result === "true";
+}
+function parseNameStatus(output) {
+  return output.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
+    const parts = line.split("	");
+    const status = parts[0] ?? "";
+    const filePath = parts[1] ?? "";
+    const oldPath = parts[2];
+    const change = { status, path: filePath };
+    if (oldPath) change.oldPath = oldPath;
+    return change;
+  }).filter((entry) => entry.path.length > 0);
+}
+async function getStagedChanges(projectPath) {
+  const isRepo = await ensureRepo(projectPath);
+  if (!isRepo) return [];
+  const output = await execGit(["diff", "--cached", "--name-status"], projectPath);
+  if (!output) return [];
+  return parseNameStatus(output);
+}
+async function getUncommittedChanges(projectPath) {
+  const isRepo = await ensureRepo(projectPath);
+  if (!isRepo) return [];
+  const changes = [];
+  const unstaged = await execGit(["diff", "--name-status"], projectPath);
+  if (unstaged) {
+    changes.push(...parseNameStatus(unstaged));
+  }
+  const untracked = await execGit(["ls-files", "--others", "--exclude-standard"], projectPath);
+  if (untracked) {
+    changes.push(
+      ...untracked.split("\n").map((p) => p.trim()).filter(Boolean).map((p) => ({ status: "??", path: p }))
+    );
+  }
+  return changes;
+}
+async function getWorkingTreeDiff(projectPath, stagedOnly = false) {
+  const isRepo = await ensureRepo(projectPath);
+  if (!isRepo) return "";
+  const args = stagedOnly ? ["diff", "--cached", "--unified=3", "--no-color"] : ["diff", "--unified=3", "--no-color"];
+  const diff = await execGit(args, projectPath);
+  return diff ?? "";
+}
+
+// src/agent/perceive.ts
+async function perceiveCurrentChanges(projectPath, graph) {
+  const ctxGraph = graph ?? new ContextGraph(projectPath);
+  const [staged, unstaged] = await Promise.all([
+    getStagedChanges(projectPath),
+    getUncommittedChanges(projectPath)
+  ]);
+  const stagedDiff = await getWorkingTreeDiff(projectPath, true);
+  const unstagedDiff = await getWorkingTreeDiff(projectPath, false);
+  const combinedDiff = [stagedDiff, unstagedDiff].filter(Boolean).join("\n");
+  const diffSummary = analyzeDiff(combinedDiff);
+  const filesTouched = /* @__PURE__ */ new Set();
+  staged.forEach((c) => filesTouched.add(c.path));
+  unstaged.forEach((c) => filesTouched.add(c.path));
+  diffSummary.files.forEach((f) => filesTouched.add(f.filePath));
+  const changeId = await upsertWorkingChange(ctxGraph, Array.from(filesTouched), projectPath);
+  const result = {
+    staged,
+    unstaged,
+    diffSummary
+  };
+  if (changeId) result.changeNodeId = changeId;
+  return result;
+}
+async function upsertWorkingChange(graph, files, projectPath) {
+  if (files.length === 0) return void 0;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const change = await graph.addNode("change", {
+    commitHash: null,
+    files,
+    message: "workspace changes",
+    diff: null,
+    author: null,
+    timestamp: now,
+    outcome: "unknown"
+  });
+  for (const filePath of files) {
+    const fileNode = await ensureFileNode(graph, filePath, projectPath);
+    await graph.addEdge(change.id, fileNode.id, "affects");
+  }
+  return change.id;
+}
+async function ensureFileNode(graph, filePath, projectPath) {
+  const normalized = path4.resolve(projectPath, filePath);
+  const existing = await graph.getNode("file", normalized);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (existing) {
+    const data2 = existing.data;
+    await graph.updateNode("file", existing.id, {
+      changeCount: (data2.changeCount ?? 0) + 1,
+      lastChanged: now
+    });
+    return await graph.getNode("file", existing.id);
+  }
+  const data = {
+    path: filePath,
+    extension: path4.extname(filePath),
+    purpose: "",
+    riskLevel: "medium",
+    whyRisky: null,
+    changeCount: 1,
+    lastChanged: now,
+    incidentCount: 0,
+    createdAt: now
+  };
+  return await graph.addNode("file", data);
+}
+
+// src/agent/risk-scorer.ts
+import path5 from "path";
+var BASE_RISK = {
+  low: 10,
+  medium: 35,
+  high: 65,
+  critical: 85
+};
+var SENSITIVE_PATHS = [
+  { pattern: /auth|login|token|session/i, weight: 20, reason: "touches authentication" },
+  { pattern: /payment|billing|stripe|paypal|checkout/i, weight: 25, reason: "touches payments" },
+  { pattern: /secret|credential|env|config\/security/i, weight: 15, reason: "touches secrets/security config" },
+  { pattern: /gdpr|privacy|pii|phi/i, weight: 15, reason: "touches sensitive data" }
+];
+function levelFromScore(score) {
+  if (score >= 90) return "critical";
+  if (score >= 65) return "high";
+  if (score >= 40) return "medium";
+  return "low";
+}
+async function scoreFile(graph, filePath, matchedPatterns = []) {
+  const reasons = [];
+  const normalized = path5.resolve(graph.projectRoot, filePath);
+  const node = await graph.getNode("file", normalized);
+  const incidents = await graph.getIncidentsForFile(filePath);
+  let score = 10;
+  const data = node?.data;
+  if (data) {
+    score = BASE_RISK[data.riskLevel] ?? score;
+    reasons.push(`baseline ${data.riskLevel}`);
+    if (data.incidentCount > 0) {
+      const incBoost = Math.min(data.incidentCount * 12, 36);
+      score += incBoost;
+      reasons.push(`historical incidents (+${incBoost})`);
+    }
+    if (data.changeCount > 5) {
+      const changeBoost = Math.min((data.changeCount - 5) * 2, 12);
+      score += changeBoost;
+      reasons.push(`frequent changes (+${changeBoost})`);
+    }
+    if (data.lastChanged) {
+      const lastChanged = new Date(data.lastChanged).getTime();
+      const days = (Date.now() - lastChanged) / (1e3 * 60 * 60 * 24);
+      if (days > 60 && data.incidentCount === 0) {
+        score -= 5;
+        reasons.push("stable for 60d (-5)");
+      }
+    }
+  }
+  for (const { pattern, weight, reason } of SENSITIVE_PATHS) {
+    if (pattern.test(filePath)) {
+      score += weight;
+      reasons.push(reason);
+    }
+  }
+  if (matchedPatterns.length > 0) {
+    const patternBoost = Math.min(
+      matchedPatterns.reduce((acc, p) => acc + (p.data.confidence ?? 50) / 10, 0),
+      20
+    );
+    score += patternBoost;
+    reasons.push(`pattern match (+${Math.round(patternBoost)})`);
+  }
+  if (incidents.length > 0) {
+    const timestamps = incidents.map((i) => new Date(i.data.timestamp).getTime()).sort((a, b) => b - a);
+    const recent = timestamps[0];
+    const daysSince = (Date.now() - recent) / (1e3 * 60 * 60 * 24);
+    if (daysSince > 90) {
+      score -= 5;
+      reasons.push("no incidents in 90d (-5)");
+    } else {
+      score += 8;
+      reasons.push("recent incident (+8)");
+    }
+  }
+  const level = levelFromScore(score);
+  return {
+    file: filePath,
+    score,
+    level,
+    reasons,
+    incidents,
+    matchedPatterns
+  };
+}
+async function scoreChangeSet(graph, files, patternMatches = {}) {
+  const fileResults = [];
+  for (const file of files) {
+    const patterns = patternMatches[file] ?? [];
+    fileResults.push(await scoreFile(graph, file, patterns));
+  }
+  const maxScore = Math.max(...fileResults.map((f) => f.score), 10);
+  const spreadBoost = files.length > 5 ? Math.min((files.length - 5) * 2, 10) : 0;
+  const overallScore = maxScore + spreadBoost;
+  const overall = levelFromScore(overallScore);
+  const shouldEscalate = overall === "critical" || overall === "high";
+  return {
+    files: fileResults,
+    overall,
+    score: overallScore,
+    shouldEscalate
+  };
+}
+
+// src/agent/pattern-matcher.ts
+async function matchPatternsForFiles(graph, files) {
+  const matches = [];
+  const byFile = {};
+  for (const file of files) {
+    const patterns = await graph.getPatternsForFile(file);
+    if (patterns.length === 0) continue;
+    byFile[file] = patterns;
+    for (const pattern of patterns) {
+      matches.push({
+        file,
+        pattern,
+        confidence: pattern.data.confidence,
+        isAntiPattern: pattern.data.isAntiPattern
+      });
+    }
+  }
+  return { matches, byFile };
+}
+
+// src/agent/reason.ts
+function buildDefaultCodeContext() {
+  return {
+    changeType: "general",
+    isNewFeature: false,
+    touchesUserData: false,
+    touchesAuth: false,
+    touchesPayments: false,
+    touchesDatabase: false,
+    touchesAPI: false,
+    touchesUI: false,
+    touchesHealthData: false,
+    touchesSecurityConfig: false,
+    linesChanged: 50,
+    filePatterns: [],
+    framework: "unknown",
+    language: "typescript",
+    touchesCrypto: false,
+    touchesFileSystem: false,
+    touchesThirdPartyAPI: false,
+    touchesLogging: false,
+    touchesErrorHandling: false,
+    hasTests: false,
+    complexity: "medium",
+    patterns: {
+      hasAsyncCode: false,
+      hasFormHandling: false,
+      hasFileUploads: false,
+      hasEmailHandling: false,
+      hasRateLimiting: false,
+      hasWebSockets: false,
+      hasCaching: false,
+      hasQueue: false
+    }
+  };
+}
+function buildExplanation(result) {
+  const top = [...result.files].sort((a, b) => b.score - a.score)[0];
+  if (!top) return `Risk level ${result.overall} (no files provided)`;
+  return `Risk level ${result.overall} because ${top.file} ${top.reasons.join(", ")}`;
+}
+function buildRecommendation(risk, hasAntiPattern) {
+  if (hasAntiPattern || risk === "critical") {
+    return "Block until reviewed: address anti-patterns and rerun targeted tests.";
+  }
+  if (risk === "high") {
+    return "Require senior review and run full test suite before merge.";
+  }
+  if (risk === "medium") {
+    return "Proceed with caution; run impacted tests and sanity checks.";
+  }
+  return "Low risk; proceed but keep an eye on recent changes.";
+}
+async function reasonAboutChanges(projectPath, files, options = {}) {
+  const graph = new ContextGraph(projectPath);
+  const { matches, byFile } = await matchPatternsForFiles(graph, files);
+  const changeRisk = await scoreChangeSet(graph, files, byFile);
+  const incidents = [];
+  for (const file of files) {
+    const fileIncidents = await graph.getIncidentsForFile(file);
+    incidents.push(...fileIncidents);
+  }
+  const hasAntiPattern = matches.some((m) => m.isAntiPattern);
+  const riskLevel = hasAntiPattern ? "critical" : changeRisk.overall;
+  const shouldBlock = hasAntiPattern || riskLevel === "critical" || riskLevel === "high";
+  const reasoning = {
+    riskLevel,
+    shouldBlock,
+    explanation: buildExplanation(changeRisk),
+    relevantIncidents: incidents,
+    matchedPatterns: matches.map((m) => m.pattern),
+    recommendation: buildRecommendation(riskLevel, hasAntiPattern),
+    files: changeRisk.files
+  };
+  if (options.runAgents) {
+    const codeContext = options.codeContext ?? buildDefaultCodeContext();
+    const triager = new Triager();
+    const agents = await triager.selectAgents(codeContext, riskLevel);
+    if (agents.length > 0) {
+      const executor = new Executor();
+      const scanContext = {
+        workingDir: projectPath,
+        ...options.scanContext
+      };
+      if (codeContext.framework) scanContext.framework = codeContext.framework;
+      if (codeContext.language) scanContext.language = codeContext.language;
+      reasoning.agentResults = await executor.executeAgents(agents, files, scanContext, {
+        parallel: true,
+        timeoutMs: options.scanContext?.config?.timeoutMs ?? 6e4
+      });
+    } else {
+      reasoning.agentResults = [];
+    }
+  }
+  return reasoning;
+}
+async function reasonAboutChangesHumanReadable(projectPath, files, options = {}) {
+  const reasoning = await reasonAboutChanges(projectPath, files, options);
+  const { humanizeReasoning } = await import("./comprehension-46F7ZNKL.js");
+  return humanizeReasoning(reasoning);
+}
+
+// src/utils/errors.ts
+var TrieError = class extends Error {
+  code;
+  recoverable;
+  userMessage;
+  constructor(message, code, userMessage, recoverable = true) {
+    super(message);
+    this.code = code;
+    this.recoverable = recoverable;
+    this.userMessage = userMessage;
+  }
+};
+function formatFriendlyError(error) {
+  if (error instanceof TrieError) {
+    return { userMessage: error.userMessage, code: error.code };
+  }
+  return {
+    userMessage: "Something went wrong. Try again or run with --offline.",
+    code: "UNKNOWN"
+  };
+}
+
+// src/context/sync.ts
+import fs2 from "fs/promises";
+import path6 from "path";
+var DEFAULT_JSON_NAME = "context.json";
+async function exportToJson(graph, targetPath) {
+  const snapshot = await graph.getSnapshot();
+  const json = JSON.stringify(snapshot, null, 2);
+  const outputPath = targetPath ?? path6.join(graph.projectRoot, ".trie", DEFAULT_JSON_NAME);
+  await fs2.mkdir(path6.dirname(outputPath), { recursive: true });
+  await fs2.writeFile(outputPath, json, "utf8");
+  return json;
+}
+async function importFromJson(graph, json, sourcePath) {
+  const payload = json.trim().length > 0 ? json : await fs2.readFile(sourcePath ?? path6.join(graph.projectRoot, ".trie", DEFAULT_JSON_NAME), "utf8");
+  const snapshot = JSON.parse(payload);
+  await graph.applySnapshot(snapshot);
+}
+
+// src/context/incident-index.ts
+import path8 from "path";
+
+// src/context/file-trie.ts
+import fs3 from "fs";
+import path7 from "path";
+import { performance } from "perf_hooks";
+function normalizePath(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  return normalized.startsWith("./") ? normalized.slice(2) : normalized;
+}
+var FilePathTrie = class {
+  trie = new Trie();
+  persistPath;
+  constructor(persistPath) {
+    if (persistPath) this.persistPath = persistPath;
+    if (persistPath && fs3.existsSync(persistPath)) {
+      try {
+        const raw = fs3.readFileSync(persistPath, "utf-8");
+        if (raw.trim().length > 0) {
+          const json = JSON.parse(raw);
+          this.trie = Trie.fromJSON(json);
+        }
+      } catch {
+        this.trie = new Trie();
+      }
+    }
+  }
+  addIncident(filePath, incident) {
+    const key = normalizePath(filePath);
+    const existing = this.trie.search(key);
+    const incidents = existing.found && Array.isArray(existing.value) ? existing.value : [];
+    incidents.push(incident);
+    this.trie.insert(key, incidents);
+    this.persist();
+  }
+  getIncidents(filePath) {
+    const key = normalizePath(filePath);
+    const result = this.trie.search(key);
+    return result.found && Array.isArray(result.value) ? result.value : [];
+  }
+  getDirectoryIncidents(prefix) {
+    const normalizedPrefix = normalizePath(prefix);
+    const matches = this.trie.getWithPrefix(normalizedPrefix);
+    return matches.flatMap((m) => Array.isArray(m.value) ? m.value : []).filter(Boolean);
+  }
+  getHotZones(threshold) {
+    const matches = this.trie.getWithPrefix("");
+    const zones = [];
+    for (const match of matches) {
+      const incidents = Array.isArray(match.value) ? match.value : [];
+      if (incidents.length >= threshold) {
+        zones.push({
+          path: match.pattern,
+          incidentCount: incidents.length,
+          confidence: this.calculateConfidence(incidents.length)
+        });
+      }
+    }
+    return zones.sort((a, b) => b.incidentCount - a.incidentCount);
+  }
+  suggestPaths(partial, limit = 5) {
+    const normalized = normalizePath(partial);
+    const results = this.trie.getWithPrefix(normalized);
+    return results.map((r) => ({
+      path: r.pattern,
+      incidentCount: Array.isArray(r.value) ? r.value.length : 0
+    })).sort((a, b) => b.incidentCount - a.incidentCount).slice(0, limit);
+  }
+  timeLookup(path9) {
+    const start = performance.now();
+    this.getIncidents(path9);
+    return performance.now() - start;
+  }
+  toJSON() {
+    return this.trie.toJSON();
+  }
+  calculateConfidence(count) {
+    const capped = Math.min(count, 10);
+    return Math.round(capped / 10 * 100) / 100;
+  }
+  persist() {
+    if (!this.persistPath) return;
+    try {
+      const dir = path7.dirname(this.persistPath);
+      if (!fs3.existsSync(dir)) {
+        fs3.mkdirSync(dir, { recursive: true });
+      }
+      fs3.writeFileSync(this.persistPath, JSON.stringify(this.trie.toJSON()), "utf-8");
+    } catch {
+    }
+  }
+};
+
+// src/context/incident-index.ts
+var IncidentIndex = class _IncidentIndex {
+  graph;
+  trie;
+  projectRoot;
+  constructor(graph, projectRoot, options) {
+    this.graph = graph;
+    this.projectRoot = projectRoot;
+    this.trie = new FilePathTrie(
+      options?.persistPath ?? path8.join(projectRoot, ".trie", "incident-trie.json")
+    );
+  }
+  static async build(graph, projectRoot, options) {
+    const index = new _IncidentIndex(graph, projectRoot, options);
+    await index.rebuild();
+    return index;
+  }
+  async rebuild() {
+    const nodes = await this.graph.listNodes();
+    const incidents = nodes.filter((n) => n.type === "incident");
+    for (const incident of incidents) {
+      const files = await this.getFilesForIncident(incident.id);
+      this.addIncidentToTrie(incident, files);
+    }
+  }
+  addIncidentToTrie(incident, files) {
+    const meta = {
+      id: incident.id,
+      file: "",
+      description: incident.data.description,
+      severity: incident.data.severity,
+      timestamp: incident.data.timestamp
+    };
+    for (const file of files) {
+      const normalized = this.normalizePath(file);
+      this.trie.addIncident(normalized, { ...meta, file: normalized });
+    }
+  }
+  getFileTrie() {
+    return this.trie;
+  }
+  async getFilesForIncident(incidentId) {
+    const files = /* @__PURE__ */ new Set();
+    const edges = await this.graph.getEdges(incidentId, "both");
+    for (const edge of edges) {
+      if (edge.type === "causedBy" || edge.type === "leadTo") {
+        const changeId = edge.type === "causedBy" ? edge.to_id : edge.from_id;
+        const change = await this.graph.getNode("change", changeId);
+        if (change?.data && "files" in change.data && Array.isArray(change.data.files)) {
+          change.data.files.forEach((f) => files.add(f));
+        }
+      }
+      if (edge.type === "affects") {
+        const fileNode = await this.graph.getNode("file", edge.to_id) || await this.graph.getNode("file", edge.from_id);
+        if (fileNode && typeof fileNode.data?.path === "string") {
+          files.add(fileNode.data.path);
+        }
+      }
+    }
+    return Array.from(files);
+  }
+  normalizePath(filePath) {
+    const absolute = path8.isAbsolute(filePath) ? filePath : path8.join(this.projectRoot, filePath);
+    const relative = path8.relative(this.projectRoot, absolute);
+    return relative.replace(/\\/g, "/");
+  }
+};
+
+// src/agent/confidence.ts
+function adjustConfidence(current, outcome, step = 0.1) {
+  const delta = outcome === "positive" ? step : -step;
+  return clamp(current + delta);
+}
+function clamp(value) {
+  if (Number.isNaN(value)) return 0.5;
+  return Math.min(1, Math.max(0, value));
+}
+
+// src/agent/pattern-discovery.ts
+var TriePatternDiscovery = class {
+  constructor(graph, incidentIndex) {
+    this.graph = graph;
+    this.incidentIndex = incidentIndex;
+  }
+  discoverHotPatterns(threshold = 3) {
+    const trie = this.incidentIndex.getFileTrie();
+    const hotZones = trie.getHotZones(threshold);
+    return hotZones.map((zone) => ({
+      type: zone.path.endsWith("/") ? "directory" : "file",
+      path: zone.path,
+      incidentCount: zone.incidentCount,
+      confidence: zone.confidence,
+      relatedFiles: trie.getDirectoryIncidents(zone.path).map((i) => i.file)
+    }));
+  }
+  async discoverCoOccurrences(minCount = 3) {
+    const incidents = await this.getAllIncidents();
+    const coOccurrences = /* @__PURE__ */ new Map();
+    for (const inc of incidents) {
+      const files = await this.getFilesForIncident(inc);
+      for (let i = 0; i < files.length; i++) {
+        for (let j = i + 1; j < files.length; j++) {
+          const a = files[i];
+          const b = files[j];
+          if (!coOccurrences.has(a)) coOccurrences.set(a, /* @__PURE__ */ new Map());
+          const counts = coOccurrences.get(a);
+          counts.set(b, (counts.get(b) || 0) + 1);
+        }
+      }
+    }
+    const patterns = [];
+    for (const [a, map] of coOccurrences.entries()) {
+      for (const [b, count] of map.entries()) {
+        if (count >= minCount) {
+          const denom = Math.min(
+            this.incidentIndex.getFileTrie().getIncidents(a).length || 1,
+            this.incidentIndex.getFileTrie().getIncidents(b).length || 1
+          );
+          patterns.push({
+            files: [a, b],
+            coOccurrences: count,
+            confidence: Math.min(1, count / denom)
+          });
+        }
+      }
+    }
+    return patterns.sort((x, y) => y.confidence - x.confidence);
+  }
+  async getAllIncidents() {
+    const nodes = await this.graph.listNodes();
+    return nodes.filter((n) => n.type === "incident");
+  }
+  async getFilesForIncident(incident) {
+    const files = /* @__PURE__ */ new Set();
+    const edges = await this.graph.getEdges(incident.id, "both");
+    for (const edge of edges) {
+      if (edge.type === "causedBy" || edge.type === "leadTo") {
+        const changeId = edge.type === "causedBy" ? edge.to_id : edge.from_id;
+        const change = await this.graph.getNode("change", changeId);
+        if (change?.data?.files && Array.isArray(change.data.files)) {
+          change.data.files.forEach((f) => files.add(f));
+        }
+      }
+    }
+    return Array.from(files).map((f) => f.replace(/\\/g, "/"));
+  }
+};
+
+// src/agent/learning.ts
+var LearningSystem = class {
+  constructor(graph, projectPath) {
+    this.graph = graph;
+    this.incidentIndex = new IncidentIndex(graph, projectPath);
+    this.discovery = new TriePatternDiscovery(graph, this.incidentIndex);
+  }
+  incidentIndex;
+  discovery;
+  async onWarningHeeded(files) {
+    await this.adjustPatterns(files, "positive");
+  }
+  async onWarningIgnored(files) {
+    await this.adjustPatterns(files, "negative");
+  }
+  async onIncidentReported(incidentId, files) {
+    const incident = await this.graph.getNode("incident", incidentId);
+    if (incident && incident.type === "incident") {
+      this.incidentIndex.addIncidentToTrie(incident, files);
+    }
+    await this.discoverAndStorePatterns();
+  }
+  async onFeedback(helpful, files = []) {
+    await this.adjustPatterns(files, helpful ? "positive" : "negative");
+  }
+  async adjustPatterns(files, outcome) {
+    if (!files.length) return;
+    for (const file of files) {
+      const patterns = await this.graph.getPatternsForFile(file);
+      await Promise.all(patterns.map((p) => this.updatePatternConfidence(p, outcome)));
+    }
+  }
+  async updatePatternConfidence(pattern, outcome) {
+    const current = pattern.data.confidence ?? 0.5;
+    const updated = adjustConfidence(current, outcome, 0.05);
+    await this.graph.updateNode("pattern", pattern.id, { confidence: updated, lastSeen: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  async discoverAndStorePatterns() {
+    const hotPatterns = this.discovery.discoverHotPatterns();
+    for (const hot of hotPatterns) {
+      await this.graph.addNode("pattern", {
+        description: `${hot.type === "directory" ? "Directory" : "File"} hot zone: ${hot.path}`,
+        appliesTo: [hot.path],
+        confidence: hot.confidence,
+        occurrences: hot.incidentCount,
+        firstSeen: (/* @__PURE__ */ new Date()).toISOString(),
+        lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
+        isAntiPattern: true,
+        source: "local"
+      });
+    }
+  }
+};
+
+// src/tools/feedback.ts
+var TrieFeedbackTool = class {
+  async execute(input) {
+    try {
+      const projectPath = input.directory || getWorkingDirectory(void 0, true);
+      const graph = new ContextGraph(projectPath);
+      const learning = new LearningSystem(graph, projectPath);
+      const decision = await graph.addNode("decision", {
+        context: input.target ?? "unspecified",
+        decision: input.helpful ? "helpful" : "not helpful",
+        reasoning: input.note ?? null,
+        outcome: input.helpful ? "good" : "bad",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      if (input.files && input.files.length) {
+        for (const file of input.files) {
+          const fileNode = await graph.getNode("file", file);
+          if (fileNode) {
+            await graph.addEdge(decision.id, fileNode.id, "affects");
+          }
+        }
+        await learning.onFeedback(input.helpful, input.files);
+      }
+      return {
+        content: [{
+          type: "text",
+          text: input.helpful ? "\u{1F44D} Thanks \u2014 I will prioritize more responses like this." : "\u{1F44E} Understood \u2014 I will adjust future guidance."
+        }]
+      };
+    } catch (error) {
+      const friendly = formatFriendlyError(error);
+      return { content: [{ type: "text", text: friendly.userMessage }] };
+    }
+  }
+};
+
+export {
+  SKILL_CATEGORIES,
+  detectStack,
+  getSkillsByCategory,
+  getSkillCategories,
+  loadBootstrapContext,
+  initializeBootstrapFiles,
+  completeBootstrap,
+  needsBootstrap,
+  loadRules,
+  loadTeamInfo,
+  saveCheckpoint,
+  listCheckpoints,
+  getLastCheckpoint,
+  handleCheckpointCommand,
+  ContextGraph,
+  perceiveCurrentChanges,
+  reasonAboutChangesHumanReadable,
+  formatFriendlyError,
+  exportToJson,
+  importFromJson,
+  IncidentIndex,
+  TrieFeedbackTool
+};
+//# sourceMappingURL=chunk-WCHIJDCD.js.map