@triedotdev/mcp 1.0.109 → 1.0.111

package/dist/chunk-FLBK5ILJ.js

@@ -1,3729 +0,0 @@
-import {
-  ContextGraph
-} from "./chunk-OTTR5JX4.js";
-import {
-  scanForVibeCodeIssues
-} from "./chunk-IXO4G4D3.js";
-import {
-  storeIssues
-} from "./chunk-6JPPYG7F.js";
-import {
-  getTrieDirectory,
-  getWorkingDirectory
-} from "./chunk-R4AAPFXC.js";
-import {
-  scanForVulnerabilities
-} from "./chunk-F4NJ4CBP.js";
-import {
-  Trie
-} from "./chunk-6NLHFIYA.js";
-import {
-  isInteractiveMode
-} from "./chunk-APMV77PU.js";
-import {
-  __require
-} from "./chunk-DGUM43GV.js";
-
-// src/utils/project-info.ts
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { existsSync } from "fs";
-import { join } from "path";
-var PROJECT_MD_PATH = "PROJECT.md";
-function getProjectTemplate() {
-  return `# Project Information
-
-> This file stores important project context for AI assistants.
-> Edit freely - this file is yours, not auto-generated.
-> Available via MCP resource: \`trie://project\`
-
----
-
-## Project Overview
-
-<!-- Describe your project's purpose and goals -->
-
-[Add project description here]
-
----
-
-## Technology Stack
-
-<!-- List frameworks, languages, databases, cloud services, etc. -->
-
-- **Language:** 
-- **Framework:** 
-- **Database:** 
-- **Hosting:** 
-
----
-
-## Architecture
-
-<!-- Key patterns, architectural decisions, and system design -->
-
-[Describe your architecture here]
-
----
-
-## Coding Conventions
-
-<!-- Style guidelines, naming conventions, patterns to follow -->
-
-- 
-- 
-- 
-
----
-
-## Environment
-
-<!-- URLs, API endpoints, deployment info -->
-
-| Environment | URL | Notes |
-|-------------|-----|-------|
-| Development | | |
-| Staging | | |
-| Production | | |
-
----
-
-## Team
-
-<!-- Ownership, contacts, responsibilities -->
-
-- **Owner:** 
-- **Team:** 
-
----
-
-## Compliance
-
-<!-- HIPAA, SOC2, GDPR, PCI-DSS requirements if applicable -->
-
-- [ ] GDPR
-- [ ] SOC2
-- [ ] HIPAA
-- [ ] PCI-DSS
-
----
-
-## AI Instructions
-
-<!-- Special instructions for AI assistants working on this project -->
-
-When working on this project, AI assistants should:
-
-1. 
-2. 
-3. 
-
----
-
-*This file is read by Trie agents and exposed via \`trie://project\` MCP resource.*
-*Edit this file to provide context to Claude Code, Cursor, GitHub Actions, and other AI tools.*
-`;
-}
-function projectInfoExists(workDir) {
-  const dir = workDir || getWorkingDirectory(void 0, true);
-  const projectPath = join(getTrieDirectory(dir), PROJECT_MD_PATH);
-  return existsSync(projectPath);
-}
-async function loadProjectInfo(workDir) {
-  const dir = workDir || getWorkingDirectory(void 0, true);
-  const projectPath = join(getTrieDirectory(dir), PROJECT_MD_PATH);
-  try {
-    if (!existsSync(projectPath)) {
-      return null;
-    }
-    return await readFile(projectPath, "utf-8");
-  } catch {
-    return null;
-  }
-}
-async function saveProjectInfo(content, workDir) {
-  const dir = workDir || getWorkingDirectory(void 0, true);
-  const trieDir = getTrieDirectory(dir);
-  const projectPath = join(trieDir, PROJECT_MD_PATH);
-  await mkdir(trieDir, { recursive: true });
-  await writeFile(projectPath, content, "utf-8");
-}
-async function initProjectInfo(workDir) {
-  const dir = workDir || getWorkingDirectory(void 0, true);
-  const projectPath = join(getTrieDirectory(dir), PROJECT_MD_PATH);
-  if (existsSync(projectPath)) {
-    return { created: false, path: projectPath };
-  }
-  await saveProjectInfo(getProjectTemplate(), dir);
-  return { created: true, path: projectPath };
-}
-async function getProjectSection(sectionName, workDir) {
-  const content = await loadProjectInfo(workDir);
-  if (!content) return null;
-  const sectionRegex = new RegExp(
-    `## ${escapeRegex(sectionName)}\\s*\\n([\\s\\S]*?)(?=\\n## |\\n---\\s*$|$)`,
-    "i"
-  );
-  const match = content.match(sectionRegex);
-  if (match?.[1]) {
-    return match[1].trim();
-  }
-  return null;
-}
-async function updateProjectSection(sectionName, newContent, workDir) {
-  let content = await loadProjectInfo(workDir);
-  if (!content) {
-    await initProjectInfo(workDir);
-    content = await loadProjectInfo(workDir);
-    if (!content) return false;
-  }
-  const sectionRegex = new RegExp(
-    `(## ${escapeRegex(sectionName)}\\s*\\n)([\\s\\S]*?)((?=\\n## )|(?=\\n---\\s*$)|$)`,
-    "i"
-  );
-  if (content.match(sectionRegex)) {
-    const updatedContent = content.replace(sectionRegex, `$1
-${newContent}
-
-$3`);
-    await saveProjectInfo(updatedContent, workDir);
-    return true;
-  }
-  return false;
-}
-async function appendToSection(sectionName, contentToAdd, workDir) {
-  const currentContent = await getProjectSection(sectionName, workDir);
-  if (currentContent === null) return false;
-  const newContent = currentContent + "\n" + contentToAdd;
-  return updateProjectSection(sectionName, newContent, workDir);
-}
-async function getProjectSections(workDir) {
-  const content = await loadProjectInfo(workDir);
-  if (!content) return [];
-  const sectionRegex = /^## (.+)$/gm;
-  const sections = [];
-  let match;
-  while ((match = sectionRegex.exec(content)) !== null) {
-    if (match[1]) {
-      sections.push(match[1].trim());
-    }
-  }
-  return sections;
-}
-async function getProjectInfoStructured(workDir) {
-  const dir = workDir || getWorkingDirectory(void 0, true);
-  const projectPath = join(getTrieDirectory(dir), PROJECT_MD_PATH);
-  const content = await loadProjectInfo(dir);
-  if (!content) {
-    return {
-      exists: false,
-      path: projectPath,
-      sections: {},
-      raw: null
-    };
-  }
-  const sectionNames = await getProjectSections(dir);
-  const sections = {};
-  for (const name of sectionNames) {
-    const sectionContent = await getProjectSection(name, dir);
-    if (sectionContent) {
-      sections[name] = sectionContent;
-    }
-  }
-  return {
-    exists: true,
-    path: projectPath,
-    sections,
-    raw: content
-  };
-}
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-// src/cli/checkpoint.ts
-import { existsSync as existsSync2 } from "fs";
-import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile2 } from "fs/promises";
-import { join as join2 } from "path";
-async function saveCheckpoint(options) {
-  const workDir = options.workDir || getWorkingDirectory(void 0, true);
-  const trieDir = getTrieDirectory(workDir);
-  const checkpointPath = join2(trieDir, "checkpoints.json");
-  await mkdir2(trieDir, { recursive: true });
-  let log = { checkpoints: [] };
-  try {
-    if (existsSync2(checkpointPath)) {
-      log = JSON.parse(await readFile2(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 writeFile2(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 = join2(getTrieDirectory(dir), "checkpoints.json");
-  try {
-    if (existsSync2(checkpointPath)) {
-      const log = JSON.parse(await readFile2(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 = join2(getTrieDirectory(workDir), "AGENTS.md");
-  let content = "";
-  try {
-    if (existsSync2(agentsPath)) {
-      content = await readFile2(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 writeFile2(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/utils/context-state.ts
-import { readFile as readFile3, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import { join as join3, basename } from "path";
-var STATE_JSON_PATH = "state.json";
-async function loadContextState() {
-  const workDir = getWorkingDirectory(void 0, true);
-  const statePath = join3(getTrieDirectory(workDir), STATE_JSON_PATH);
-  const defaults = getDefaultState();
-  try {
-    if (existsSync3(statePath)) {
-      const content = await readFile3(statePath, "utf-8");
-      const loaded = JSON.parse(content);
-      return {
-        ...defaults,
-        ...loaded,
-        skills: loaded.skills || defaults.skills
-      };
-    }
-  } catch {
-  }
-  return defaults;
-}
-function getDefaultState() {
-  return {
-    lastScan: null,
-    healthScore: 0,
-    activePriorities: [
-      "Initial setup required - run first scan with `trie scan`",
-      "Configure agents in `.trie/config.json`",
-      "Set up CI/CD integration"
-    ],
-    contextSignals: {},
-    agentStatus: {},
-    scanHistory: [],
-    customAgents: [],
-    skills: {},
-    environment: detectEnvironment()
-  };
-}
-function detectEnvironment() {
-  if (process.env.GITHUB_ACTIONS) return "github-actions";
-  if (process.env.GITLAB_CI) return "gitlab-ci";
-  if (process.env.CI) return "ci";
-  const parent = process.env._ || "";
-  if (parent.includes("cursor")) return "cursor";
-  if (parent.includes("claude")) return "claude-code";
-  return "cli";
-}
-async function getContextForAI() {
-  const state = await loadContextState();
-  const workDir = getWorkingDirectory(void 0, true);
-  const lines = [];
-  if (projectInfoExists(workDir)) {
-    const projectInfo = await loadProjectInfo(workDir);
-    if (projectInfo) {
-      lines.push(projectInfo);
-      lines.push("");
-      lines.push("---");
-      lines.push("");
-    }
-  }
-  lines.push(
-    "## Trie Scan Context",
-    "",
-    `**Health Score:** ${state.healthScore}%`,
-    `**Last Scan:** ${state.lastScan ? new Date(state.lastScan.timestamp).toLocaleString() : "Never"}`,
-    "",
-    "**Active Priorities:**",
-    ...state.activePriorities.map((p) => `- ${p}`),
-    ""
-  );
-  if (state.lastScan) {
-    lines.push(
-      "**Recent Issues:**",
-      `- Critical: ${state.lastScan.issues.critical}`,
-      `- Serious: ${state.lastScan.issues.serious}`,
-      `- Moderate: ${state.lastScan.issues.moderate}`,
-      `- Low: ${state.lastScan.issues.low}`,
-      ""
-    );
-    if (state.lastScan.hotFiles.length > 0) {
-      lines.push(
-        "**Hot Files (most issues):**",
-        ...state.lastScan.hotFiles.slice(0, 5).map((f) => `- ${f.file}: ${f.issueCount} issues`),
-        ""
-      );
-    }
-  }
-  return lines.join("\n");
-}
-
-// src/config/loader.ts
-import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir4 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-import { join as join5, dirname } from "path";
-
-// src/config/validation.ts
-import { z } from "zod";
-import { existsSync as existsSync4, readFileSync } from "fs";
-import { resolve, join as join4 } from "path";
-var API_KEY_PATTERNS = {
-  anthropic: /^sk-ant-api\d{2}-[\w-]{95}$/,
-  openai: /^sk-[\w]{48}$/,
-  github: /^ghp_[\w]{36}$/,
-  vercel: /^[\w]{24}$/,
-  linear: /^lin_api_[\w]{40,60}$/
-};
-var ApiKeysSchema = z.object({
-  anthropic: z.string().regex(API_KEY_PATTERNS.anthropic, "Invalid Anthropic API key format").optional(),
-  openai: z.string().regex(API_KEY_PATTERNS.openai, "Invalid OpenAI API key format").optional(),
-  github: z.string().regex(API_KEY_PATTERNS.github, "Invalid GitHub token format").optional(),
-  vercel: z.string().regex(API_KEY_PATTERNS.vercel, "Invalid Vercel token format").optional(),
-  linear: z.string().optional()
-  // Linear keys can vary, so we'll be flexible but allow storage
-});
-var AgentConfigSchema = z.object({
-  enabled: z.array(z.string()).optional().default([]),
-  disabled: z.array(z.string()).optional().default([]),
-  parallel: z.boolean().optional().default(true),
-  maxConcurrency: z.number().int().min(1).max(20).optional().default(4),
-  timeout: z.number().int().min(1e3).max(3e5).optional().default(12e4),
-  // 2 minutes
-  cache: z.boolean().optional().default(true)
-});
-var ComplianceSchema = z.object({
-  standards: z.array(z.enum(["SOC2", "GDPR", "HIPAA", "CCPA", "PCI-DSS"])).optional().default(["SOC2"]),
-  enforceCompliance: z.boolean().optional().default(false),
-  reportFormat: z.enum(["json", "sarif", "csv", "html"]).optional().default("json")
-});
-var OutputSchema = z.object({
-  format: z.enum(["console", "json", "sarif", "junit"]).optional().default("console"),
-  level: z.enum(["critical", "serious", "moderate", "low", "all"]).optional().default("all"),
-  interactive: z.boolean().optional().default(false),
-  streaming: z.boolean().optional().default(true),
-  colors: z.boolean().optional().default(true)
-});
-var PathsSchema = z.object({
-  include: z.array(z.string()).optional().default([]),
-  exclude: z.array(z.string()).optional().default(["node_modules", "dist", "build", ".git"]),
-  configDir: z.string().optional().default(".trie"),
-  outputDir: z.string().optional().default("trie-reports")
-});
-var IntegrationsSchema = z.object({
-  github: z.object({
-    enabled: z.boolean().optional().default(false),
-    token: z.string().optional(),
-    webhook: z.string().url().optional()
-  }).optional(),
-  slack: z.object({
-    enabled: z.boolean().optional().default(false),
-    webhook: z.string().url().optional(),
-    channel: z.string().optional()
-  }).optional(),
-  jira: z.object({
-    enabled: z.boolean().optional().default(false),
-    url: z.string().url().optional(),
-    token: z.string().optional(),
-    project: z.string().optional()
-  }).optional()
-});
-var UserSchema = z.object({
-  name: z.string().min(1).optional(),
-  email: z.string().email().optional(),
-  role: z.enum([
-    "developer",
-    "designer",
-    "qa",
-    "devops",
-    "security",
-    "architect",
-    "manager",
-    "contributor"
-  ]).optional().default("developer"),
-  github: z.string().optional(),
-  // GitHub username
-  url: z.string().url().optional()
-  // Personal/portfolio URL
-});
-var TrieConfigSchema = z.object({
-  version: z.string().optional().default("1.0.0"),
-  apiKeys: ApiKeysSchema.optional(),
-  agents: AgentConfigSchema.optional(),
-  compliance: ComplianceSchema.optional(),
-  output: OutputSchema.optional(),
-  paths: PathsSchema.optional(),
-  integrations: IntegrationsSchema.optional(),
-  user: UserSchema.optional()
-  // User identity for attribution
-});
-var ConfigValidator = class {
-  /**
-   * Validate configuration object
-   */
-  validateConfig(config) {
-    try {
-      const validated = TrieConfigSchema.parse(config);
-      const businessErrors = this.validateBusinessLogic(validated);
-      if (businessErrors.length > 0) {
-        return { success: false, errors: businessErrors };
-      }
-      return { success: true, data: validated };
-    } catch (error) {
-      if (error instanceof z.ZodError) {
-        const errors = error.errors.map(
-          (err) => `${err.path.join(".")}: ${err.message}`
-        );
-        return { success: false, errors };
-      }
-      return {
-        success: false,
-        errors: [`Configuration validation failed: ${error instanceof Error ? error.message : "Unknown error"}`]
-      };
-    }
-  }
-  /**
-   * Validate environment variables for API keys
-   */
-  validateEnvironment() {
-    const warnings = [];
-    const errors = [];
-    const exposedPatterns = [
-      "NEXT_PUBLIC_ANTHROPIC",
-      "REACT_APP_ANTHROPIC",
-      "VITE_ANTHROPIC",
-      "PUBLIC_ANTHROPIC"
-    ];
-    for (const pattern of exposedPatterns) {
-      const envVars = Object.keys(process.env).filter((key) => key.includes(pattern));
-      for (const envVar of envVars) {
-        errors.push(`[!] Security risk: API key in client-side environment variable: ${envVar}`);
-      }
-    }
-    let anthropicKey = process.env.ANTHROPIC_API_KEY;
-    if (!anthropicKey) {
-      try {
-        const configPath = join4(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
-        if (existsSync4(configPath)) {
-          const config = JSON.parse(readFileSync(configPath, "utf-8"));
-          anthropicKey = config.apiKeys?.anthropic;
-        }
-      } catch {
-      }
-    }
-    if (anthropicKey && !API_KEY_PATTERNS.anthropic.test(anthropicKey)) {
-      errors.push("ANTHROPIC_API_KEY does not match expected format");
-    }
-    if (!anthropicKey) {
-      warnings.push("ANTHROPIC_API_KEY not set - AI features will be disabled. Set in environment, .trie/config.json, or .env file");
-    }
-    if (!process.env.GITHUB_TOKEN && process.env.CI) {
-      warnings.push("GITHUB_TOKEN not set - GitHub integration disabled");
-    }
-    return {
-      valid: errors.length === 0,
-      warnings,
-      errors
-    };
-  }
-  /**
-   * Validate file paths in configuration
-   */
-  validatePaths(paths) {
-    const errors = [];
-    if (paths?.include) {
-      for (const path8 of paths.include) {
-        const resolvedPath = resolve(path8);
-        if (!existsSync4(resolvedPath)) {
-          errors.push(`Include path does not exist: ${path8}`);
-        }
-      }
-    }
-    if (paths?.configDir) {
-      const configPath = resolve(paths.configDir);
-      if (!existsSync4(configPath)) {
-        try {
-          __require("fs").mkdirSync(configPath, { recursive: true });
-        } catch {
-          errors.push(`Cannot create config directory: ${paths.configDir}`);
-        }
-      }
-    }
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-  /**
-   * Validate integration configurations
-   */
-  validateIntegrations(integrations) {
-    const errors = [];
-    if (integrations?.github?.enabled) {
-      if (!integrations.github.token) {
-        errors.push("GitHub integration enabled but no token provided");
-      }
-    }
-    if (integrations?.slack?.enabled) {
-      if (!integrations.slack.webhook) {
-        errors.push("Slack integration enabled but no webhook URL provided");
-      }
-    }
-    if (integrations?.jira?.enabled) {
-      if (!integrations.jira.url || !integrations.jira.token || !integrations.jira.project) {
-        errors.push("JIRA integration enabled but missing required fields (url, token, project)");
-      }
-    }
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-  /**
-   * Business logic validation
-   */
-  validateBusinessLogic(config) {
-    const errors = [];
-    if (config.agents?.enabled && config.agents?.disabled) {
-      const overlap = config.agents.enabled.filter(
-        (agent) => config.agents?.disabled?.includes(agent)
-      );
-      if (overlap.length > 0) {
-        errors.push(`Agents cannot be both enabled and disabled: ${overlap.join(", ")}`);
-      }
-    }
-    if (config.agents?.maxConcurrency && config.agents.maxConcurrency > 10) {
-      errors.push("maxConcurrency should not exceed 10 for optimal performance");
-    }
-    if (config.compliance?.standards) {
-      const invalidStandards = config.compliance.standards.filter(
-        (standard) => !["SOC2", "GDPR", "HIPAA", "CCPA", "PCI-DSS"].includes(standard)
-      );
-      if (invalidStandards.length > 0) {
-        errors.push(`Invalid compliance standards: ${invalidStandards.join(", ")}`);
-      }
-    }
-    if (config.paths) {
-      const pathValidation = this.validatePaths(config.paths);
-      errors.push(...pathValidation.errors);
-    }
-    if (config.integrations) {
-      const integrationValidation = this.validateIntegrations(config.integrations);
-      errors.push(...integrationValidation.errors);
-    }
-    return errors;
-  }
-  /**
-   * Generate configuration template
-   */
-  generateTemplate() {
-    return {
-      version: "1.0.0",
-      agents: {
-        enabled: ["security", "bugs", "types"],
-        disabled: [],
-        parallel: true,
-        maxConcurrency: 4,
-        timeout: 12e4,
-        cache: true
-      },
-      compliance: {
-        standards: ["SOC2"],
-        enforceCompliance: false,
-        reportFormat: "json"
-      },
-      output: {
-        format: "console",
-        level: "all",
-        interactive: false,
-        streaming: true,
-        colors: true
-      },
-      paths: {
-        include: [],
-        exclude: ["node_modules", "dist", "build", ".git"],
-        configDir: ".trie",
-        outputDir: "trie-reports"
-      }
-    };
-  }
-  /**
-   * Validate and provide suggestions for improvement
-   */
-  analyze(config) {
-    const suggestions = [];
-    const securityIssues = [];
-    const optimizations = [];
-    let score = 100;
-    let hasApiKey = Boolean(config.apiKeys?.anthropic || process.env.ANTHROPIC_API_KEY);
-    if (!hasApiKey) {
-      try {
-        const workDir = getWorkingDirectory(void 0, true);
-        const envFiles = [".env", ".env.local", ".env.production"];
-        for (const envFile of envFiles) {
-          const envPath = join4(workDir, envFile);
-          if (existsSync4(envPath)) {
-            const envContent = readFileSync(envPath, "utf-8");
-            if (envContent.includes("ANTHROPIC_API_KEY=")) {
-              hasApiKey = true;
-              break;
-            }
-          }
-        }
-      } catch {
-      }
-    }
-    if (!hasApiKey) {
-      suggestions.push("Add ANTHROPIC_API_KEY to enable AI-powered analysis for better issue detection. Set in environment, .trie/config.json, or .env file");
-      score -= 10;
-    }
-    if (config.agents?.parallel === false) {
-      optimizations.push("Enable parallel agent execution for 3-5x faster scans");
-      score -= 15;
-    }
-    if (config.agents?.cache === false) {
-      optimizations.push("Enable result caching to speed up repeated scans");
-      score -= 10;
-    }
-    if (!config.compliance?.standards || config.compliance.standards.length === 0) {
-      suggestions.push("Configure compliance standards (SOC2, GDPR, etc.) for regulatory requirements");
-      score -= 5;
-    }
-    const hasIntegrations = config.integrations && (config.integrations.github?.enabled || config.integrations.slack?.enabled || config.integrations.jira?.enabled);
-    if (!hasIntegrations) {
-      suggestions.push("Consider enabling GitHub/Slack/JIRA integrations for better team collaboration");
-      score -= 5;
-    }
-    if (config.apiKeys) {
-      securityIssues.push("API keys in config file - consider using environment variables instead");
-      score -= 20;
-    }
-    return {
-      score: Math.max(0, score),
-      suggestions,
-      securityIssues,
-      optimizations
-    };
-  }
-};
-var DEFAULT_CONFIG = {
-  version: "1.0.0",
-  agents: {
-    enabled: [],
-    disabled: [],
-    parallel: true,
-    maxConcurrency: 4,
-    timeout: 12e4,
-    cache: true
-  },
-  compliance: {
-    standards: ["SOC2"],
-    enforceCompliance: false,
-    reportFormat: "json"
-  },
-  output: {
-    format: "console",
-    level: "all",
-    interactive: false,
-    streaming: true,
-    colors: true
-  },
-  paths: {
-    include: [],
-    exclude: ["node_modules", "dist", "build", ".git", ".next", ".nuxt", "coverage"],
-    configDir: ".trie",
-    outputDir: "trie-reports"
-  }
-};
-
-// src/config/loader.ts
-async function loadConfig() {
-  const validator = new ConfigValidator();
-  const configPath = join5(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
-  try {
-    if (!existsSync5(configPath)) {
-      return DEFAULT_CONFIG;
-    }
-    const configFile = await readFile4(configPath, "utf-8");
-    const userConfig = JSON.parse(configFile);
-    const merged = mergeConfig(DEFAULT_CONFIG, userConfig);
-    const result = validator.validateConfig(merged);
-    if (!result.success) {
-      if (!isInteractiveMode()) {
-        console.error("Configuration validation failed:");
-        for (const error of result.errors) {
-          console.error(`  - ${error}`);
-        }
-      }
-      return DEFAULT_CONFIG;
-    }
-    if (!isInteractiveMode()) {
-      const envValidation = validator.validateEnvironment();
-      for (const warning of envValidation.warnings) {
-        console.warn(warning);
-      }
-      for (const error of envValidation.errors) {
-        console.error(error);
-      }
-    }
-    return result.data;
-  } catch (error) {
-    if (!isInteractiveMode()) {
-      console.error("Failed to load config, using defaults:", error);
-    }
-    return DEFAULT_CONFIG;
-  }
-}
-async function saveConfig(config) {
-  const configPath = join5(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
-  const dir = dirname(configPath);
-  if (!existsSync5(dir)) {
-    await mkdir4(dir, { recursive: true });
-  }
-  await writeFile3(configPath, JSON.stringify(config, null, 2), "utf-8");
-}
-function mergeConfig(defaults, user) {
-  if (typeof user !== "object" || user === null || Array.isArray(user)) {
-    return { ...defaults };
-  }
-  const result = { ...defaults };
-  for (const [key, value] of Object.entries(user)) {
-    const defaultValue = defaults[key];
-    if (typeof value === "object" && value !== null && !Array.isArray(value) && typeof defaultValue === "object" && defaultValue !== null) {
-      result[key] = mergeConfig(defaultValue, value);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-
-// src/utils/autonomy-config.ts
-import { readFile as readFile5, writeFile as writeFile4, mkdir as mkdir5 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import { join as join6 } from "path";
-
-// src/types/autonomy.ts
-var DEFAULT_AUTONOMY_CONFIG = {
-  level: "proactive",
-  autoCheck: {
-    enabled: true,
-    threshold: 5,
-    onCritical: true,
-    cooldownMs: 3e4
-    // 30 seconds
-  },
-  autoFix: {
-    enabled: true,
-    askFirst: true,
-    // Always ask (human-in-the-loop)
-    categories: ["trivial", "safe"],
-    allowedFixTypes: [
-      "remove-console-log",
-      "remove-unused-import",
-      "add-missing-await",
-      "fix-typo"
-    ]
-  },
-  pushBlocking: {
-    enabled: true,
-    allowBypass: true,
-    blockOn: ["critical"],
-    bypassMethods: ["env", "flag", "confirm"],
-    logBypasses: true
-  },
-  progressiveEscalation: {
-    enabled: true,
-    thresholds: {
-      suggest: 1,
-      autoCheck: 3,
-      escalate: 5,
-      block: 10
-    },
-    windowMs: 24 * 60 * 60 * 1e3
-    // 24 hours
-  }
-};
-
-// src/utils/autonomy-config.ts
-import { createHash } from "crypto";
-async function loadAutonomyConfig(projectPath) {
-  const configPath = join6(getTrieDirectory(projectPath), "config.json");
-  try {
-    if (!existsSync6(configPath)) {
-      return { ...DEFAULT_AUTONOMY_CONFIG };
-    }
-    const content = await readFile5(configPath, "utf-8");
-    const config = JSON.parse(content);
-    return mergeWithDefaults(config.autonomy || {});
-  } catch (error) {
-    console.error("Failed to load autonomy config:", error);
-    return { ...DEFAULT_AUTONOMY_CONFIG };
-  }
-}
-function mergeWithDefaults(partial) {
-  return {
-    level: partial.level ?? DEFAULT_AUTONOMY_CONFIG.level,
-    autoCheck: {
-      ...DEFAULT_AUTONOMY_CONFIG.autoCheck,
-      ...partial.autoCheck || {}
-    },
-    autoFix: {
-      ...DEFAULT_AUTONOMY_CONFIG.autoFix,
-      ...partial.autoFix || {}
-    },
-    pushBlocking: {
-      ...DEFAULT_AUTONOMY_CONFIG.pushBlocking,
-      ...partial.pushBlocking || {}
-    },
-    progressiveEscalation: {
-      ...DEFAULT_AUTONOMY_CONFIG.progressiveEscalation,
-      ...partial.progressiveEscalation || {},
-      thresholds: {
-        ...DEFAULT_AUTONOMY_CONFIG.progressiveEscalation.thresholds,
-        ...partial.progressiveEscalation?.thresholds || {}
-      }
-    }
-  };
-}
-var occurrenceCache = /* @__PURE__ */ new Map();
-async function getOccurrences(projectPath) {
-  if (occurrenceCache.has(projectPath)) {
-    return occurrenceCache.get(projectPath);
-  }
-  const occurrencesPath = join6(getTrieDirectory(projectPath), "memory", "occurrences.json");
-  const occurrences = /* @__PURE__ */ new Map();
-  try {
-    if (existsSync6(occurrencesPath)) {
-      const content = await readFile5(occurrencesPath, "utf-8");
-      const data = JSON.parse(content);
-      for (const [hash, occ] of Object.entries(data)) {
-        occurrences.set(hash, occ);
-      }
-    }
-  } catch {
-  }
-  occurrenceCache.set(projectPath, occurrences);
-  return occurrences;
-}
-async function saveOccurrences(projectPath) {
-  const occurrences = occurrenceCache.get(projectPath);
-  if (!occurrences) return;
-  const occurrencesPath = join6(getTrieDirectory(projectPath), "memory", "occurrences.json");
-  const memoryDir = join6(getTrieDirectory(projectPath), "memory");
-  try {
-    if (!existsSync6(memoryDir)) {
-      await mkdir5(memoryDir, { recursive: true });
-    }
-    const data = {};
-    for (const [hash, occ] of occurrences.entries()) {
-      data[hash] = occ;
-    }
-    await writeFile4(occurrencesPath, JSON.stringify(data, null, 2));
-  } catch (error) {
-    console.error("Failed to save occurrences:", error);
-  }
-}
-function createIssueHash(file, line, issueType) {
-  const input = `${file}:${line || 0}:${issueType}`;
-  return createHash("md5").update(input).digest("hex").slice(0, 12);
-}
-async function trackIssueOccurrence(projectPath, file, line, issueType, config) {
-  const occurrences = await getOccurrences(projectPath);
-  const hash = createIssueHash(file, line, issueType);
-  const now = Date.now();
-  let occurrence = occurrences.get(hash);
-  if (occurrence) {
-    const windowMs = config.progressiveEscalation.windowMs;
-    if (now - occurrence.firstSeen > windowMs) {
-      occurrence = {
-        hash,
-        firstSeen: now,
-        lastSeen: now,
-        count: 1,
-        escalationLevel: "suggest",
-        notified: false,
-        bypassed: false,
-        bypassHistory: occurrence.bypassHistory
-        // Keep bypass history
-      };
-    } else {
-      occurrence.lastSeen = now;
-      occurrence.count++;
-      const thresholds = config.progressiveEscalation.thresholds;
-      if (occurrence.count >= thresholds.block) {
-        occurrence.escalationLevel = "block";
-      } else if (occurrence.count >= thresholds.escalate) {
-        occurrence.escalationLevel = "escalate";
-      } else if (occurrence.count >= thresholds.autoCheck) {
-        occurrence.escalationLevel = "autoCheck";
-      }
-    }
-  } else {
-    occurrence = {
-      hash,
-      firstSeen: now,
-      lastSeen: now,
-      count: 1,
-      escalationLevel: "suggest",
-      notified: false,
-      bypassed: false,
-      bypassHistory: []
-    };
-  }
-  occurrences.set(hash, occurrence);
-  await saveOccurrences(projectPath);
-  return occurrence;
-}
-async function recordBypass(projectPath, file, line, issueType, method, reason) {
-  const occurrences = await getOccurrences(projectPath);
-  const hash = createIssueHash(file, line, issueType);
-  const occurrence = occurrences.get(hash);
-  if (occurrence) {
-    occurrence.bypassed = true;
-    occurrence.bypassHistory.push({
-      timestamp: Date.now(),
-      method,
-      ...reason !== void 0 ? { reason } : {}
-    });
-    await saveOccurrences(projectPath);
-  }
-}
-function shouldAutoFix(fix, config) {
-  if (!config.autoFix.enabled) {
-    return false;
-  }
-  const allowedCategories = config.autoFix.categories;
-  if (!allowedCategories.includes(fix.category) && !allowedCategories.includes("all")) {
-    return false;
-  }
-  if (config.autoFix.allowedFixTypes.length > 0 && !config.autoFix.allowedFixTypes.includes(fix.type)) {
-    return false;
-  }
-  if (fix.confidence < 0.9) {
-    return false;
-  }
-  return true;
-}
-function shouldBlockPush(issues, config) {
-  if (!config.pushBlocking.enabled) {
-    return {
-      blocked: false,
-      blockingIssues: [],
-      bypassed: false
-    };
-  }
-  const blockingIssues = issues.filter(
-    (issue) => config.pushBlocking.blockOn.includes(issue.severity)
-  );
-  if (blockingIssues.length === 0) {
-    return {
-      blocked: false,
-      blockingIssues: [],
-      bypassed: false
-    };
-  }
-  const envBypass = process.env.TRIE_BYPASS === "1" || process.env.TRIE_BYPASS === "true";
-  if (envBypass && config.pushBlocking.allowBypass) {
-    return {
-      blocked: false,
-      blockingIssues,
-      bypassed: true,
-      bypassMethod: "env"
-    };
-  }
-  const bypassInstructions = buildBypassInstructions(config);
-  return {
-    blocked: true,
-    reason: `${blockingIssues.length} ${blockingIssues[0]?.severity || "critical"} issue(s) must be fixed before pushing`,
-    blockingIssues,
-    bypassInstructions,
-    bypassed: false
-  };
-}
-function buildBypassInstructions(config) {
-  const instructions = [];
-  if (config.pushBlocking.bypassMethods.includes("env")) {
-    instructions.push("\u2022 Set TRIE_BYPASS=1 to bypass: TRIE_BYPASS=1 git push");
-  }
-  if (config.pushBlocking.bypassMethods.includes("flag")) {
-    instructions.push("\u2022 Use --no-verify flag: git push --no-verify");
-  }
-  if (config.pushBlocking.bypassMethods.includes("confirm")) {
-    instructions.push("\u2022 Run: trie bypass --confirm to bypass this push");
-  }
-  return instructions.join("\n");
-}
-var configCache = /* @__PURE__ */ new Map();
-var CACHE_TTL = 6e4;
-async function getAutonomyConfig(projectPath) {
-  const cached = configCache.get(projectPath);
-  if (cached && Date.now() - cached.loadedAt < CACHE_TTL) {
-    return cached.config;
-  }
-  const config = await loadAutonomyConfig(projectPath);
-  configCache.set(projectPath, { config, loadedAt: Date.now() });
-  return config;
-}
-
-// src/skills/audit-logger.ts
-function formatAuditLog(_entry) {
-  return "Audit logging has been integrated into the decision ledger";
-}
-function getAuditStatistics() {
-  return {
-    totalScans: 0,
-    totalIssues: 0,
-    criticalCount: 0,
-    seriousCount: 0,
-    moderateCount: 0,
-    lowCount: 0,
-    totalExecutions: 0,
-    successfulExecutions: 0,
-    failedExecutions: 0,
-    uniqueSkills: 0,
-    totalCommands: 0,
-    blockedCommands: 0,
-    totalNetworkCalls: 0,
-    blockedNetworkCalls: 0
-  };
-}
-function createAuditEntry(skillName, skillSource, triggeredBy, targetPath) {
-  return {
-    skillName,
-    skillSource,
-    triggeredBy,
-    targetPath,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    commands: []
-  };
-}
-function completeAuditEntry(entry, success, error) {
-  const result = {
-    ...entry,
-    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    success
-  };
-  if (error !== void 0) {
-    result.error = error;
-  }
-  return result;
-}
-async function logSkillExecution(_execution) {
-}
-async function getRecentAuditLogs(_limit = 10) {
-  return [];
-}
-async function getSkillAuditLogs(_skillName) {
-  return [];
-}
-
-// src/agent/git.ts
-import { existsSync as existsSync7 } from "fs";
-import path from "path";
-
-// src/utils/command-runner.ts
-import { exec, execFile, execSync } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-var execFileAsync = promisify(execFile);
-function redact(text) {
-  return text.replace(/\b(AWS|ANTHROPIC|OPENAI|GITHUB)_[A-Z0-9_]*\s*=\s*([^\s"'`]+)/gi, "$1_<REDACTED>=<REDACTED>").replace(/\bBearer\s+[A-Za-z0-9\-._~+/]+=*\b/g, "Bearer <REDACTED>").replace(/\bghp_[A-Za-z0-9]{20,}\b/g, "ghp_<REDACTED>").replace(/\b(?:xox[baprs]-)[A-Za-z0-9-]{10,}\b/g, "<REDACTED_SLACK_TOKEN>").replace(/\bAKIA[0-9A-Z]{16}\b/g, "AKIA<REDACTED>");
-}
-function clampOutput(text, maxChars) {
-  if (text.length <= maxChars) return text;
-  return text.slice(0, maxChars) + `
-\u2026(truncated ${text.length - maxChars} chars)`;
-}
-function buildCommandRecord(command) {
-  return {
-    command,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-async function finalizeAndWrite(entry, cmd, outcome, options) {
-  const duration = Date.now() - outcome.startedAt;
-  cmd.duration = duration;
-  if (outcome.exitCode !== void 0) {
-    cmd.exitCode = outcome.exitCode;
-  }
-  const captureOutput = options?.captureOutput ?? false;
-  const redactOutput = options?.redactOutput ?? true;
-  const maxOutputChars = options?.maxOutputChars ?? 2e3;
-  if (captureOutput) {
-    const out = outcome.stdout ?? "";
-    const err = outcome.stderr ?? "";
-    cmd.stdout = redactOutput ? redact(clampOutput(out, maxOutputChars)) : clampOutput(out, maxOutputChars);
-    cmd.stderr = redactOutput ? redact(clampOutput(err, maxOutputChars)) : clampOutput(err, maxOutputChars);
-  }
-  const completed = completeAuditEntry(entry, outcome.success, outcome.error);
-  await logSkillExecution(completed);
-}
-function runShellCommandSync(command, audit, options) {
-  const startedAt = Date.now();
-  const entry = createAuditEntry(audit.actor, audit.source ?? "trie", audit.triggeredBy, audit.targetPath);
-  const cmd = buildCommandRecord(command);
-  entry.commands?.push(cmd);
-  try {
-    const stdout = execSync(command, {
-      cwd: options?.cwd,
-      timeout: options?.timeoutMs,
-      maxBuffer: options?.maxBuffer,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    void finalizeAndWrite(entry, cmd, { success: true, exitCode: 0, stdout, stderr: "", startedAt }, options);
-    return { stdout: stdout ?? "", exitCode: 0 };
-  } catch (e) {
-    const err = e;
-    const stdout = typeof err.stdout === "string" ? err.stdout : "";
-    const stderr = typeof err.stderr === "string" ? err.stderr : "";
-    const exitCode = typeof err.status === "number" ? err.status : 1;
-    void finalizeAndWrite(
-      entry,
-      cmd,
-      { success: false, exitCode, stdout, stderr, error: err.message, startedAt },
-      { ...options, captureOutput: options?.captureOutput ?? true }
-    );
-    return { stdout, exitCode };
-  }
-}
-async function runExecFile(file, args, audit, options) {
-  const startedAt = Date.now();
-  const command = [file, ...args].join(" ");
-  const entry = createAuditEntry(audit.actor, audit.source ?? "trie", audit.triggeredBy, audit.targetPath);
-  const cmd = buildCommandRecord(command);
-  entry.commands?.push(cmd);
-  try {
-    const { stdout, stderr } = await execFileAsync(file, args, {
-      cwd: options?.cwd,
-      timeout: options?.timeoutMs,
-      maxBuffer: options?.maxBuffer
-    });
-    await finalizeAndWrite(entry, cmd, { success: true, exitCode: 0, stdout: String(stdout ?? ""), stderr: String(stderr ?? ""), startedAt }, options);
-    return { stdout: String(stdout ?? ""), stderr: String(stderr ?? ""), exitCode: 0 };
-  } catch (e) {
-    const err = e;
-    const stdout = typeof err.stdout === "string" ? err.stdout : "";
-    const stderr = typeof err.stderr === "string" ? err.stderr : "";
-    const exitCode = typeof err.code === "number" ? err.code : 1;
-    await finalizeAndWrite(
-      entry,
-      cmd,
-      { success: false, exitCode, stdout, stderr, error: err.message, startedAt },
-      { ...options, captureOutput: options?.captureOutput ?? true }
-    );
-    return { stdout, stderr, exitCode };
-  }
-}
-
-// src/agent/git.ts
-async function execGit(args, cwd) {
-  try {
-    const { stdout } = await runExecFile(
-      "git",
-      ["-C", cwd, ...args],
-      { actor: "internal:git", triggeredBy: "manual", targetPath: cwd },
-      { maxBuffer: 10 * 1024 * 1024, captureOutput: false }
-    );
-    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 getRecentCommits(projectPath, limit) {
-  const isRepo = await ensureRepo(projectPath);
-  if (!isRepo) return [];
-  const output = await execGit(
-    ["log", `-n`, String(limit), "--pretty=format:%H%x09%an%x09%ad%x09%s", "--date=iso"],
-    projectPath
-  );
-  if (!output) return [];
-  return output.split("\n").map((line) => {
-    const [hash, author, date, message] = line.split("	");
-    return { hash, author, date, message };
-  });
-}
-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 getDiff(projectPath, commitHash) {
-  const isRepo = await ensureRepo(projectPath);
-  if (!isRepo) return "";
-  const diff = await execGit(["show", commitHash, "--unified=3", "--no-color"], projectPath);
-  return diff ?? "";
-}
-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
-import path2 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/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 = path2.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: path2.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 path3 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" }
-];
-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 = path3.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/orchestrator/triager.ts
-var Triager = class {
-  constructor(_config) {
-  }
-  /**
-   * Triage a change to select appropriate agents
-   * Note: Skills/agents have been removed - Trie is now purely a decision ledger
-   */
-  async triage(_context, _forceAgents) {
-    return [];
-  }
-  /**
-   * Get all available agent names (deprecated - returns empty array)
-   */
-  getAvailableAgents() {
-    return [];
-  }
-};
-
-// src/utils/parallel-executor.ts
-import { Worker } from "worker_threads";
-import { cpus } from "os";
-import { existsSync as existsSync8 } from "fs";
-import { fileURLToPath } from "url";
-var ParallelExecutor = class {
-  maxWorkers;
-  cache;
-  streaming;
-  activeWorkers = /* @__PURE__ */ new Set();
-  cacheEnabled = true;
-  useWorkerThreads = false;
-  workerAvailable = null;
-  warnedWorkerFallback = false;
-  constructor(cacheManager, maxWorkers = Math.max(2, Math.min(cpus().length - 1, 8)), options) {
-    this.maxWorkers = maxWorkers;
-    this.cache = cacheManager;
-    this.cacheEnabled = options?.cacheEnabled ?? true;
-    this.useWorkerThreads = options?.useWorkerThreads ?? false;
-  }
-  /**
-   * Set streaming manager for real-time updates
-   */
-  setStreaming(streaming) {
-    this.streaming = streaming;
-  }
-  /**
-   * Execute agents in parallel with intelligent scheduling
-   */
-  async executeAgents(agents, files, context) {
-    if (agents.length === 0) {
-      return /* @__PURE__ */ new Map();
-    }
-    if (this.streaming && this.streaming.getProgress().totalFiles === 0) {
-      this.streaming.startScan(files.length);
-    }
-    const cacheResults = /* @__PURE__ */ new Map();
-    const uncachedTasks = [];
-    for (const agent of agents) {
-      const cached = await this.checkAgentCache(agent, files);
-      if (cached) {
-        cacheResults.set(agent.name, cached);
-        this.streaming?.completeAgent(agent.name, cached.issues);
-      } else {
-        uncachedTasks.push({
-          agent,
-          files,
-          context,
-          priority: agent.priority?.tier || 2,
-          timeoutMs: context?.config?.timeoutMs || 12e4
-        });
-      }
-    }
-    uncachedTasks.sort((a, b) => a.priority - b.priority);
-    const parallelResults = await this.executeTasksParallel(uncachedTasks);
-    await this.cacheResults(parallelResults);
-    const allResults = /* @__PURE__ */ new Map();
-    for (const [agent, result] of cacheResults) {
-      allResults.set(agent, result);
-    }
-    for (const result of parallelResults) {
-      allResults.set(result.agent, result.result);
-    }
-    const allIssues = Array.from(allResults.values()).flatMap((r) => r.issues);
-    this.streaming?.completeScan(allIssues);
-    return allResults;
-  }
-  /**
-   * Check if agent has cached results for given files
-   */
-  async checkAgentCache(agent, files) {
-    if (!this.cacheEnabled || !this.cache) {
-      return null;
-    }
-    const cachedIssues = await this.cache.getCachedBatch(files, agent.name);
-    if (cachedIssues.size === files.length) {
-      const allIssues = Array.from(cachedIssues.values()).flat();
-      return {
-        agent: agent.name,
-        issues: allIssues,
-        executionTime: 0,
-        // Cached
-        success: true,
-        metadata: {
-          filesAnalyzed: files.length,
-          linesAnalyzed: 0
-        }
-      };
-    }
-    return null;
-  }
-  /**
-   * Execute tasks in parallel batches
-   */
-  async executeTasksParallel(tasks) {
-    if (tasks.length === 0) {
-      return [];
-    }
-    const results = [];
-    const batches = this.createBatches(tasks, this.maxWorkers);
-    for (const batch of batches) {
-      const batchResults = await Promise.all(
-        batch.map((task) => this.executeTask(task))
-      );
-      results.push(...batchResults);
-    }
-    return results;
-  }
-  /**
-   * Create batches for parallel execution
-   */
-  createBatches(tasks, batchSize) {
-    const batches = [];
-    for (let i = 0; i < tasks.length; i += batchSize) {
-      batches.push(tasks.slice(i, i + batchSize));
-    }
-    return batches;
-  }
-  /**
-   * Execute a single task
-   */
-  async executeTask(task) {
-    const startTime = Date.now();
-    this.streaming?.startAgent(task.agent.name);
-    try {
-      const result = this.canUseWorkers() ? await this.executeTaskInWorker(task) : await task.agent.scan(task.files, task.context);
-      const executionTime = Date.now() - startTime;
-      this.streaming?.completeAgent(task.agent.name, result.issues);
-      return {
-        agent: task.agent.name,
-        result,
-        fromCache: false,
-        executionTime
-      };
-    } catch (error) {
-      const executionTime = Date.now() - startTime;
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.streaming?.reportError(new Error(errorMessage), `Agent: ${task.agent.name}`);
-      return {
-        agent: task.agent.name,
-        result: {
-          agent: task.agent.name,
-          issues: [],
-          executionTime,
-          success: false,
-          error: errorMessage
-        },
-        fromCache: false,
-        executionTime
-      };
-    }
-  }
-  canUseWorkers() {
-    if (!this.useWorkerThreads) {
-      return false;
-    }
-    if (this.workerAvailable !== null) {
-      return this.workerAvailable;
-    }
-    const workerUrl = this.getWorkerUrl();
-    this.workerAvailable = existsSync8(fileURLToPath(workerUrl));
-    if (!this.workerAvailable && !this.warnedWorkerFallback && !isInteractiveMode()) {
-      console.error("Worker threads unavailable; falling back to in-process agents.");
-      this.warnedWorkerFallback = true;
-    }
-    return this.workerAvailable;
-  }
-  getWorkerUrl() {
-    const distDir = new URL(".", import.meta.url);
-    return new URL("workers/agent-worker.js", distDir);
-  }
-  async executeTaskInWorker(task) {
-    const workerUrl = this.getWorkerUrl();
-    return new Promise((resolve2, reject) => {
-      const worker = new Worker(workerUrl, {
-        workerData: {
-          agentName: task.agent.name,
-          files: task.files,
-          context: task.context
-        }
-      });
-      this.activeWorkers.add(worker);
-      const timeout = setTimeout(() => {
-        worker.terminate().catch(() => void 0);
-        reject(new Error(`Agent ${task.agent.name} timed out after ${task.timeoutMs}ms`));
-      }, task.timeoutMs);
-      worker.on("message", (message) => {
-        if (message?.type === "result") {
-          clearTimeout(timeout);
-          resolve2(message.result);
-        } else if (message?.type === "error") {
-          clearTimeout(timeout);
-          reject(new Error(message.error));
-        }
-      });
-      worker.on("error", (error) => {
-        clearTimeout(timeout);
-        reject(error);
-      });
-      worker.on("exit", (code) => {
-        this.activeWorkers.delete(worker);
-        if (code !== 0) {
-          clearTimeout(timeout);
-          reject(new Error(`Worker stopped with exit code ${code}`));
-        }
-      });
-    });
-  }
-  /**
-   * Cache results for future use
-   */
-  async cacheResults(results) {
-    if (!this.cacheEnabled || !this.cache) {
-      return;
-    }
-    const cachePromises = results.filter((r) => r.result.success && !r.fromCache).map((r) => {
-      const issuesByFile = this.groupIssuesByFile(r.result.issues);
-      const perFilePromises = Object.entries(issuesByFile).map(
-        ([file, issues]) => this.cache.setCached(file, r.agent, issues, r.executionTime)
-      );
-      return Promise.all(perFilePromises);
-    });
-    await Promise.allSettled(cachePromises);
-  }
-  /**
-   * Cleanup resources
-   */
-  async cleanup() {
-    const terminationPromises = Array.from(this.activeWorkers).map(
-      (worker) => worker.terminate()
-    );
-    await Promise.allSettled(terminationPromises);
-    this.activeWorkers.clear();
-  }
-  groupIssuesByFile(issues) {
-    const grouped = {};
-    for (const issue of issues) {
-      if (!grouped[issue.file]) {
-        grouped[issue.file] = [];
-      }
-      grouped[issue.file].push(issue);
-    }
-    return grouped;
-  }
-};
-function calculateOptimalConcurrency() {
-  const numCPUs = cpus().length;
-  const availableMemoryGB = process.memoryUsage().rss / 1024 / 1024 / 1024;
-  let optimal = Math.max(2, Math.min(numCPUs - 1, 8));
-  if (availableMemoryGB < 2) {
-    optimal = Math.max(2, Math.floor(optimal / 2));
-  }
-  if (numCPUs > 8) {
-    optimal = Math.min(optimal + 2, 12);
-  }
-  return optimal;
-}
-
-// src/utils/cache-manager.ts
-import { readFile as readFile6, writeFile as writeFile5, mkdir as mkdir6, stat } from "fs/promises";
-import { join as join7 } from "path";
-import { createHash as createHash2 } from "crypto";
-var CacheManager = class {
-  cacheDir;
-  indexPath;
-  VERSION = "1.0.0";
-  MAX_AGE_MS = 24 * 60 * 60 * 1e3;
-  // 24 hours
-  MAX_ENTRIES = 1e3;
-  constructor(baseDir) {
-    this.cacheDir = join7(getTrieDirectory(baseDir), "cache");
-    this.indexPath = join7(this.cacheDir, "index.json");
-  }
-  /**
-   * Generate cache key for a file and agent combination
-   */
-  generateCacheKey(filePath, agent, fileHash) {
-    const key = `${filePath}:${agent}:${fileHash}`;
-    return createHash2("sha256").update(key).digest("hex").slice(0, 16);
-  }
-  /**
-   * Get file hash for cache validation
-   */
-  async getFileHash(filePath) {
-    try {
-      const content = await readFile6(filePath, "utf-8");
-      const stats = await stat(filePath);
-      const hash = createHash2("sha256").update(content).digest("hex").slice(0, 16);
-      return {
-        hash,
-        size: stats.size,
-        mtime: stats.mtime.getTime()
-      };
-    } catch {
-      return { hash: "", size: 0, mtime: 0 };
-    }
-  }
-  /**
-   * Load cache index
-   */
-  async loadIndex() {
-    try {
-      const content = await readFile6(this.indexPath, "utf-8");
-      return JSON.parse(content);
-    } catch {
-      return {
-        version: this.VERSION,
-        created: Date.now(),
-        entries: {}
-      };
-    }
-  }
-  /**
-   * Save cache index
-   */
-  async saveIndex(index) {
-    try {
-      await mkdir6(this.cacheDir, { recursive: true });
-      await writeFile5(this.indexPath, JSON.stringify(index, null, 2));
-    } catch (error) {
-      if (!isInteractiveMode()) {
-        console.warn("Failed to save cache index:", error);
-      }
-    }
-  }
-  /**
-   * Clean up expired entries
-   */
-  cleanupExpired(index) {
-    const now = Date.now();
-    const validEntries = {};
-    for (const [key, entry] of Object.entries(index.entries)) {
-      if (now - entry.timestamp < this.MAX_AGE_MS) {
-        validEntries[key] = entry;
-      }
-    }
-    const entries = Object.entries(validEntries);
-    if (entries.length > this.MAX_ENTRIES) {
-      entries.sort((a, b) => b[1].timestamp - a[1].timestamp);
-      const limited = entries.slice(0, this.MAX_ENTRIES);
-      return {
-        ...index,
-        entries: Object.fromEntries(limited)
-      };
-    }
-    return {
-      ...index,
-      entries: validEntries
-    };
-  }
-  /**
-   * Get cached result for a file and agent
-   * 
-   * Cache automatically invalidates when files change:
-   * - Cache key includes file hash: hash(filePath:agent:fileHash)
-   * - When file changes, hash changes, so cache key changes
-   * - Old cache entry won't be found (different key)
-   * - File is automatically rescanned
-   * 
-   * This means cache auto-updates when Claude fixes code - no manual invalidation needed!
-   */
-  async getCached(filePath, agent) {
-    try {
-      const { hash, size: _size, mtime: _mtime } = await this.getFileHash(filePath);
-      if (!hash) return null;
-      const index = await this.loadIndex();
-      const cacheKey = this.generateCacheKey(filePath, agent, hash);
-      const entry = index.entries[cacheKey];
-      if (!entry) return null;
-      const isValid = entry.fileHash === hash && entry.version === this.VERSION && Date.now() - entry.timestamp < this.MAX_AGE_MS;
-      if (!isValid) {
-        delete index.entries[cacheKey];
-        await this.saveIndex(index);
-        return null;
-      }
-      return entry.issues;
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Cache result for a file and agent
-   */
-  async setCached(filePath, agent, issues, executionTime) {
-    try {
-      const { hash, size } = await this.getFileHash(filePath);
-      if (!hash) return;
-      const index = await this.loadIndex();
-      const cacheKey = this.generateCacheKey(filePath, agent, hash);
-      index.entries[cacheKey] = {
-        version: this.VERSION,
-        timestamp: Date.now(),
-        fileHash: hash,
-        fileSize: size,
-        agent,
-        issues,
-        executionTime
-      };
-      const cleanedIndex = this.cleanupExpired(index);
-      await this.saveIndex(cleanedIndex);
-    } catch (error) {
-      if (!isInteractiveMode()) {
-        console.warn("Failed to cache result:", error);
-      }
-    }
-  }
-  /**
-   * Check if multiple files have cached results
-   */
-  async getCachedBatch(files, agent) {
-    const results = /* @__PURE__ */ new Map();
-    await Promise.all(
-      files.map(async (file) => {
-        const cached = await this.getCached(file, agent);
-        if (cached) {
-          results.set(file, cached);
-        }
-      })
-    );
-    return results;
-  }
-  /**
-   * Get cache statistics
-   */
-  async getStats() {
-    try {
-      const index = await this.loadIndex();
-      const entries = Object.values(index.entries);
-      const totalSizeKB = entries.reduce((acc, entry) => acc + entry.fileSize, 0) / 1024;
-      const timestamps = entries.map((e) => e.timestamp);
-      const agents = [...new Set(entries.map((e) => e.agent))];
-      return {
-        totalEntries: entries.length,
-        totalSizeKB: Math.round(totalSizeKB),
-        oldestEntry: timestamps.length > 0 ? Math.min(...timestamps) : null,
-        newestEntry: timestamps.length > 0 ? Math.max(...timestamps) : null,
-        agents
-      };
-    } catch {
-      return {
-        totalEntries: 0,
-        totalSizeKB: 0,
-        oldestEntry: null,
-        newestEntry: null,
-        agents: []
-      };
-    }
-  }
-  /**
-   * Clean up stale cache entries by verifying file hashes
-   * This removes entries where files have changed or no longer exist
-   * Called periodically to keep cache clean
-   * 
-   * Note: Since cache keys are hashed, we can't easily reverse-engineer file paths.
-   * However, when getCached() is called, it naturally invalidates stale entries
-   * by checking if the current file hash matches the cached hash. This method
-   * proactively cleans up entries for known changed files.
-   */
-  async cleanupStaleEntries(filePaths) {
-    try {
-      const index = await this.loadIndex();
-      let removedCount = 0;
-      const keysToRemove = [];
-      if (filePaths && filePaths.length > 0) {
-        const agents = /* @__PURE__ */ new Set();
-        for (const entry of Object.values(index.entries)) {
-          agents.add(entry.agent);
-        }
-        for (const filePath of filePaths) {
-          try {
-            const { hash: currentHash } = await this.getFileHash(filePath);
-            if (!currentHash) {
-              continue;
-            }
-            for (const agent of agents) {
-              for (const [key, entry] of Object.entries(index.entries)) {
-                if (entry.agent !== agent) continue;
-                if (entry.fileHash !== currentHash) {
-                  const oldKey = this.generateCacheKey(filePath, agent, entry.fileHash);
-                  if (oldKey === key) {
-                    keysToRemove.push(key);
-                    removedCount++;
-                  }
-                }
-              }
-            }
-          } catch {
-            continue;
-          }
-        }
-      }
-      const uniqueKeys = [...new Set(keysToRemove)];
-      for (const key of uniqueKeys) {
-        delete index.entries[key];
-      }
-      if (removedCount > 0) {
-        await this.saveIndex(index);
-      }
-      return removedCount;
-    } catch (error) {
-      if (!isInteractiveMode()) {
-        console.warn("Failed to cleanup stale cache entries:", error);
-      }
-      return 0;
-    }
-  }
-  /**
-   * Clear all cache
-   */
-  async clear() {
-    try {
-      const emptyIndex = {
-        version: this.VERSION,
-        created: Date.now(),
-        entries: {}
-      };
-      await this.saveIndex(emptyIndex);
-    } catch (error) {
-      if (!isInteractiveMode()) {
-        console.warn("Failed to clear cache:", error);
-      }
-    }
-  }
-};
-
-// src/orchestrator/executor.ts
-var Executor = class {
-  async executeAgents(agents, files, context, options) {
-    const parallel = options?.parallel ?? true;
-    const cacheEnabled = options?.cacheEnabled ?? true;
-    const maxConcurrency = options?.maxConcurrency ?? calculateOptimalConcurrency();
-    const useWorkerThreads = options?.useWorkerThreads ?? false;
-    if (!isInteractiveMode()) {
-      console.error(`Executing ${agents.length} scouts ${parallel ? "in parallel" : "sequentially"}...`);
-    }
-    if (parallel) {
-      const cacheManager = cacheEnabled ? new CacheManager(context.workingDir) : null;
-      const executor = new ParallelExecutor(cacheManager, maxConcurrency, {
-        cacheEnabled,
-        useWorkerThreads
-      });
-      if (options?.streaming) {
-        executor.setStreaming(options.streaming);
-      }
-      const results = await executor.executeAgents(agents, files, {
-        ...context,
-        config: { timeoutMs: options?.timeoutMs ?? 12e4 }
-      });
-      return agents.map((agent) => results.get(agent.name)).filter(Boolean);
-    }
-    const promises = agents.map(
-      (agent) => this.executeAgentWithTimeout(agent, files, context, options?.timeoutMs ?? 3e4)
-    );
-    try {
-      const results = await Promise.allSettled(promises);
-      return results.map((result, index) => {
-        if (result.status === "fulfilled") {
-          if (!isInteractiveMode()) {
-            console.error(`${agents[index].name} completed in ${result.value.executionTime}ms`);
-          }
-          return result.value;
-        } else {
-          if (!isInteractiveMode()) {
-            console.error(`${agents[index].name} failed:`, result.reason);
-          }
-          return {
-            agent: agents[index].name,
-            issues: [],
-            executionTime: 0,
-            success: false,
-            error: result.reason instanceof Error ? result.reason.message : String(result.reason)
-          };
-        }
-      });
-    } catch (error) {
-      if (!isInteractiveMode()) {
-        console.error("Executor error:", error);
-      }
-      return agents.map((agent) => ({
-        agent: agent.name,
-        issues: [],
-        executionTime: 0,
-        success: false,
-        error: "Execution failed"
-      }));
-    }
-  }
-  async executeAgentWithTimeout(agent, files, context, timeoutMs = 3e4) {
-    return new Promise(async (resolve2, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error(`Agent ${agent.name} timed out after ${timeoutMs}ms`));
-      }, timeoutMs);
-      try {
-        const result = await agent.scan(files, context);
-        clearTimeout(timeout);
-        resolve2(result);
-      } catch (error) {
-        clearTimeout(timeout);
-        reject(error);
-      }
-    });
-  }
-};
-
-// 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.triage(codeContext);
-    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/bootstrap/stack-detector.ts
-import { readFile as readFile7 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
-import { join as join8 } 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", "bugs"],
-    dependencies: /* @__PURE__ */ new Set()
-  };
-  if (existsSync9(join8(projectDir, "tsconfig.json"))) {
-    stack.language = "TypeScript";
-    stack.suggestedSkills.push("wshobson/agents typescript-advanced-types");
-  } else if (existsSync9(join8(projectDir, "package.json"))) {
-    stack.language = "JavaScript";
-  } else if (existsSync9(join8(projectDir, "requirements.txt")) || existsSync9(join8(projectDir, "pyproject.toml"))) {
-    stack.language = "Python";
-  } else if (existsSync9(join8(projectDir, "go.mod"))) {
-    stack.language = "Go";
-  } else if (existsSync9(join8(projectDir, "Cargo.toml"))) {
-    stack.language = "Rust";
-  }
-  if (existsSync9(join8(projectDir, "Package.swift")) || existsSync9(join8(projectDir, "project.pbxproj")) || existsSync9(join8(projectDir, "*.xcodeproj"))) {
-    stack.language = "Swift";
-    stack.suggestedSkills.push("dimillian/skills swiftui-ui-patterns");
-    stack.suggestedSkills.push("dimillian/skills swiftui-liquid-glass");
-  }
-  if (existsSync9(join8(projectDir, "pnpm-lock.yaml"))) {
-    stack.packageManager = "pnpm";
-  } else if (existsSync9(join8(projectDir, "yarn.lock"))) {
-    stack.packageManager = "yarn";
-  } else if (existsSync9(join8(projectDir, "bun.lockb"))) {
-    stack.packageManager = "bun";
-  } else if (existsSync9(join8(projectDir, "package-lock.json"))) {
-    stack.packageManager = "npm";
-  }
-  if (existsSync9(join8(projectDir, ".github", "workflows"))) {
-    stack.suggestedSkills.push("wshobson/agents github-actions-templates");
-  }
-  try {
-    const pkgPath = join8(projectDir, "package.json");
-    if (existsSync9(pkgPath)) {
-      const pkgContent = await readFile7(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";
-      }
-    }
-  } catch {
-  }
-  if (!stack.database) {
-    if (existsSync9(join8(projectDir, "prisma", "schema.prisma"))) {
-      stack.database = "Prisma ORM";
-    } else if (existsSync9(join8(projectDir, "drizzle.config.ts"))) {
-      stack.database = "Drizzle ORM";
-    }
-  }
-  stack.suggestedSkills = [...new Set(stack.suggestedSkills)];
-  stack.suggestedAgents = [...new Set(stack.suggestedAgents)];
-  return stack;
-}
-function getSkillCategories() {
-  return Object.entries(SKILL_CATEGORIES).map(([name, skills]) => ({
-    name,
-    count: skills.length
-  }));
-}
-
-// src/bootstrap/files.ts
-import { readFile as readFile8, writeFile as writeFile6, unlink, mkdir as mkdir7 } from "fs/promises";
-import { existsSync as existsSync10 } from "fs";
-import { join as join9 } 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 = getTrieDirectory(projectDir);
-  const files = [];
-  const contentParts = [];
-  let needsBootstrap2 = false;
-  for (const file of BOOTSTRAP_FILES) {
-    const filePath = join9(trieDir, file.name);
-    const exists = existsSync10(filePath);
-    if (file.name === "BOOTSTRAP.md" && exists) {
-      needsBootstrap2 = true;
-    }
-    let content;
-    if (exists) {
-      try {
-        content = await readFile8(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 = getTrieDirectory(projectDir);
-  await mkdir7(trieDir, { recursive: true });
-  const created = [];
-  const skipped = [];
-  const stack = await detectStack(projectDir);
-  for (const file of BOOTSTRAP_FILES) {
-    const filePath = join9(trieDir, file.name);
-    const exists = existsSync10(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 writeFile6(filePath, template);
-      created.push(file.name);
-    }
-  }
-  return { created, skipped, stack };
-}
-async function completeBootstrap(workDir) {
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const bootstrapPath = join9(getTrieDirectory(projectDir), "BOOTSTRAP.md");
-  try {
-    await unlink(bootstrapPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function needsBootstrap(workDir) {
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const bootstrapPath = join9(getTrieDirectory(projectDir), "BOOTSTRAP.md");
-  return existsSync10(bootstrapPath);
-}
-async function loadRules(workDir) {
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const rulesPath = join9(getTrieDirectory(projectDir), "RULES.md");
-  try {
-    if (existsSync10(rulesPath)) {
-      return await readFile8(rulesPath, "utf-8");
-    }
-  } catch {
-  }
-  return null;
-}
-async function loadTeamInfo(workDir) {
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const teamPath = join9(getTrieDirectory(projectDir), "TEAM.md");
-  try {
-    if (existsSync10(teamPath)) {
-      return await readFile8(teamPath, "utf-8");
-    }
-  } catch {
-  }
-  return null;
-}
-function getFileTemplate(fileName, stack) {
-  switch (fileName) {
-    case "PROJECT.md":
-      return getProjectTemplate2(stack);
-    case "RULES.md":
-      return getRulesTemplate(stack);
-    case "TEAM.md":
-      return getTeamTemplate();
-    case "BOOTSTRAP.md":
-      return getBootstrapTemplate(stack);
-    default:
-      return null;
-  }
-}
-function getProjectTemplate2(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, 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/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 fs from "fs/promises";
-import path4 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 ?? path4.join(getTrieDirectory(graph.projectRoot), DEFAULT_JSON_NAME);
-  await fs.mkdir(path4.dirname(outputPath), { recursive: true });
-  await fs.writeFile(outputPath, json, "utf8");
-  return json;
-}
-async function importFromJson(graph, json, sourcePath) {
-  const payload = json.trim().length > 0 ? json : await fs.readFile(sourcePath ?? path4.join(getTrieDirectory(graph.projectRoot), DEFAULT_JSON_NAME), "utf8");
-  const snapshot = JSON.parse(payload);
-  await graph.applySnapshot(snapshot);
-}
-
-// src/context/incident-index.ts
-import path6 from "path";
-
-// src/context/file-trie.ts
-import fs2 from "fs";
-import path5 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 && fs2.existsSync(persistPath)) {
-      try {
-        const raw = fs2.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(path8) {
-    const start = performance.now();
-    this.getIncidents(path8);
-    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 = path5.dirname(this.persistPath);
-      if (!fs2.existsSync(dir)) {
-        fs2.mkdirSync(dir, { recursive: true });
-      }
-      fs2.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 ?? path6.join(getTrieDirectory(projectRoot), "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 = path6.isAbsolute(filePath) ? filePath : path6.join(this.projectRoot, filePath);
-    const relative = path6.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/guardian/learning-engine.ts
-import path7 from "path";
-var LearningEngine = class {
-  projectPath;
-  graph;
-  learningSystem;
-  constructor(projectPath, graph) {
-    this.projectPath = projectPath;
-    this.graph = graph || new ContextGraph(projectPath);
-    this.learningSystem = new LearningSystem(this.graph, projectPath);
-  }
-  /**
-   * Unified learning method: Scans history AND processes manual feedback
-   */
-  async learn(options = {}) {
-    const results = [];
-    if (!options.manualFeedback) {
-      const implicitCount = await this.learnFromHistory(options.limit || 20);
-      results.push({ learned: implicitCount, source: "git-history" });
-    }
-    if (options.manualFeedback) {
-      await this.recordManualFeedback(
-        options.manualFeedback.helpful,
-        options.manualFeedback.files,
-        options.manualFeedback.note
-      );
-      results.push({ learned: options.manualFeedback.files.length || 1, source: "manual-feedback" });
-    }
-    return results;
-  }
-  /**
-   * Scan recent commits for implicit failure signals (reverts, fixes)
-   */
-  async learnFromHistory(limit = 20) {
-    const commits = await getRecentCommits(this.projectPath, limit);
-    const issuesToStore = [];
-    for (const commit of commits) {
-      const isRevert = commit.message.toLowerCase().includes("revert") || commit.message.startsWith('Revert "');
-      const isFix = /fix(es|ed)?\s+#\d+/i.test(commit.message) || commit.message.toLowerCase().includes("bugfix");
-      if (isRevert || isFix) {
-        const type = isRevert ? "revert" : "fix";
-        const diff = await getDiff(this.projectPath, commit.hash);
-        const files = this.extractFilesFromDiff(diff);
-        for (const file of files) {
-          const learnedIssues = await this.extractIssuesFromDiff(diff, file, type, commit.message);
-          issuesToStore.push(...learnedIssues);
-        }
-      }
-    }
-    if (issuesToStore.length > 0) {
-      const result = await storeIssues(issuesToStore, path7.basename(this.projectPath), this.projectPath);
-      return result.stored;
-    }
-    return 0;
-  }
-  /**
-   * Record manual feedback (trie ok/bad) and adjust pattern confidence
-   */
-  async recordManualFeedback(helpful, files, note) {
-    const context = files[0] ?? "unspecified";
-    const decision = await this.graph.addNode("decision", {
-      context,
-      decision: helpful ? "helpful" : "not helpful",
-      reasoning: note ?? null,
-      outcome: helpful ? "good" : "bad",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    if (files.length > 0) {
-      for (const file of files) {
-        const fileNode = await this.graph.getNode("file", file);
-        if (fileNode) {
-          await this.graph.addEdge(decision.id, fileNode.id, "affects");
-        }
-      }
-      await this.learningSystem.onFeedback(helpful, files);
-    }
-  }
-  extractFilesFromDiff(diff) {
-    const files = /* @__PURE__ */ new Set();
-    const lines = diff.split("\n");
-    for (const line of lines) {
-      if (line.startsWith("+++ b/")) {
-        files.add(line.slice(6));
-      }
-    }
-    return Array.from(files);
-  }
-  async extractIssuesFromDiff(diff, file, type, message) {
-    const issues = [];
-    const badLines = this.getBadLinesFromDiff(diff, file, type);
-    const content = badLines.join("\n");
-    if (!content) return [];
-    const vulnerabilities = await scanForVulnerabilities(content, file);
-    const vibeIssues = await scanForVibeCodeIssues(content, file);
-    const allMatches = [...vulnerabilities, ...vibeIssues];
-    for (const match of allMatches) {
-      issues.push({
-        id: `implicit-${type}-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
-        severity: "serious",
-        issue: `Implicit failure detected via ${type}: ${message}. Linked to pattern: ${match.category}`,
-        fix: `Review the ${type} commit and avoid this pattern in ${file}.`,
-        file,
-        confidence: 0.7,
-        autoFixable: false,
-        agent: "implicit-learning",
-        category: match.category
-      });
-    }
-    if (issues.length === 0) {
-      issues.push({
-        id: `implicit-${type}-${Date.now()}`,
-        severity: "moderate",
-        issue: `Historical ${type} detected: ${message}`,
-        fix: `Review the changes in ${file} from this commit to avoid regression.`,
-        file,
-        confidence: 0.5,
-        autoFixable: false,
-        agent: "implicit-learning"
-      });
-    }
-    return issues;
-  }
-  getBadLinesFromDiff(diff, file, type) {
-    const badLines = [];
-    const lines = diff.split("\n");
-    let inTargetFile = false;
-    for (const line of lines) {
-      if (line.startsWith("+++ b/") || line.startsWith("--- a/")) {
-        inTargetFile = line.includes(file);
-        continue;
-      }
-      if (!inTargetFile) continue;
-      if (type === "fix" && line.startsWith("-") && !line.startsWith("---")) {
-        badLines.push(line.slice(1));
-      } else if (type === "revert" && line.startsWith("+") && !line.startsWith("+++")) {
-        badLines.push(line.slice(1));
-      }
-    }
-    return badLines;
-  }
-};
-
-// src/ingest/linear-ingester.ts
-var LinearIngester = class {
-  graph;
-  constructor(_projectPath, graph) {
-    this.graph = graph;
-  }
-  async syncTickets() {
-    const apiKey = await this.getApiKey();
-    if (!apiKey) {
-      console.warn('Linear API key not found. Run "trie linear auth <key>" to enable ticket sync.');
-      return;
-    }
-    const tickets = await this.fetchActiveTickets(apiKey);
-    for (const ticket of tickets) {
-      await this.ingestTicket(ticket);
-    }
-  }
-  async getApiKey() {
-    const config = await loadConfig();
-    return config.apiKeys?.linear || process.env.LINEAR_API_KEY || null;
-  }
-  async fetchActiveTickets(apiKey) {
-    const query = `
-      query {
-        issues(filter: { state: { type: { in: ["started", "unstarted"] } } }) {
-          nodes {
-            id
-            identifier
-            title
-            description
-            priority
-            status {
-              name
-            }
-            assignee {
-              name
-            }
-            labels {
-              nodes {
-                name
-              }
-            }
-            createdAt
-            updatedAt
-          }
-        }
-      }
-    `;
-    const response = await fetch("https://api.linear.app/graphql", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": apiKey
-      },
-      body: JSON.stringify({ query })
-    });
-    if (!response.ok) {
-      throw new Error(`Linear API error: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return data.data.issues.nodes;
-  }
-  async ingestTicket(ticket) {
-    const labels = ticket.labels.nodes.map((l) => l.name);
-    const intentVibe = this.extractIntentVibes(ticket.title, ticket.description, labels);
-    const linkedFiles = this.extractLinkedFiles(ticket.description);
-    const data = {
-      ticketId: ticket.identifier,
-      title: ticket.title,
-      description: ticket.description || "",
-      priority: this.mapPriority(ticket.priority),
-      labels,
-      intentVibe,
-      linkedFiles,
-      status: ticket.status.name,
-      assignee: ticket.assignee?.name || null,
-      createdAt: ticket.createdAt,
-      updatedAt: ticket.updatedAt
-    };
-    await this.graph.addNode("linear-ticket", data);
-    for (const file of linkedFiles) {
-      const fileNode = await this.graph.getNode("file", file);
-      if (fileNode) {
-        await this.graph.addEdge(`linear:${ticket.identifier}`, fileNode.id, "relatedTo");
-      }
-    }
-  }
-  extractIntentVibes(title, description, labels) {
-    const vibes = /* @__PURE__ */ new Set();
-    const text = (title + " " + (description || "") + " " + labels.join(" ")).toLowerCase();
-    if (text.includes("performance") || text.includes("slow") || text.includes("optimize")) vibes.add("performance");
-    if (text.includes("security") || text.includes("auth") || text.includes("vulnerability")) vibes.add("security");
-    if (text.includes("refactor") || text.includes("cleanup") || text.includes("debt")) vibes.add("refactor");
-    if (text.includes("feature") || text.includes("new")) vibes.add("feature");
-    if (text.includes("bug") || text.includes("fix") || text.includes("broken")) vibes.add("bug");
-    if (text.includes("breaking") || text.includes("major change")) vibes.add("breaking-change");
-    return Array.from(vibes);
-  }
-  extractLinkedFiles(description) {
-    if (!description) return [];
-    const matches = description.match(/[\\w./_-]+\\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs)/gi);
-    if (!matches) return [];
-    return Array.from(new Set(matches.map((m) => m.replace(/^\.\/+/, ""))));
-  }
-  mapPriority(priority) {
-    switch (priority) {
-      case 1:
-        return "urgent";
-      case 2:
-        return "high";
-      case 3:
-        return "medium";
-      case 4:
-        return "low";
-      default:
-        return "none";
-    }
-  }
-};
-
-export {
-  loadConfig,
-  saveConfig,
-  trackIssueOccurrence,
-  recordBypass,
-  shouldAutoFix,
-  shouldBlockPush,
-  getAutonomyConfig,
-  formatAuditLog,
-  getAuditStatistics,
-  getRecentAuditLogs,
-  getSkillAuditLogs,
-  runShellCommandSync,
-  getStagedChanges,
-  getUncommittedChanges,
-  perceiveCurrentChanges,
-  reasonAboutChangesHumanReadable,
-  projectInfoExists,
-  loadProjectInfo,
-  initProjectInfo,
-  getProjectSection,
-  updateProjectSection,
-  appendToSection,
-  getProjectSections,
-  getProjectInfoStructured,
-  getSkillCategories,
-  loadBootstrapContext,
-  initializeBootstrapFiles,
-  completeBootstrap,
-  needsBootstrap,
-  loadRules,
-  loadTeamInfo,
-  saveCheckpoint,
-  listCheckpoints,
-  getLastCheckpoint,
-  handleCheckpointCommand,
-  formatFriendlyError,
-  exportToJson,
-  importFromJson,
-  IncidentIndex,
-  LearningEngine,
-  LinearIngester,
-  loadContextState,
-  getContextForAI
-};
-//# sourceMappingURL=chunk-FLBK5ILJ.js.map