@triedotdev/mcp 1.0.94 → 1.0.99

package/dist/{chunk-AZRCKBGF.js → chunk-FNCCZ3XB.js}

@@ -1,35 +1,32 @@
 import {
-  Executor,
-  Triager,
   detectStack,
-  loadConfig
-} from "./chunk-Q764X2WD.js";
-import {
-  getDiff,
-  getRecentCommits,
-  getStagedChanges,
-  getUncommittedChanges,
-  getWorkingTreeDiff
-} from "./chunk-FK6DQKDY.js";
+  runExecFile
+} from "./chunk-HSNE46VE.js";
 import {
   ContextGraph
-} from "./chunk-Y62VM3ER.js";
+} from "./chunk-NIASHOAB.js";
 import {
   scanForVulnerabilities
-} from "./chunk-JO6RVXS6.js";
-import {
-  storeIssues
-} from "./chunk-OEYIOOYB.js";
+} from "./chunk-F4NJ4CBP.js";
 import {
   scanForVibeCodeIssues
-} from "./chunk-STEFLYPR.js";
+} from "./chunk-IXO4G4D3.js";
 import {
   Trie
 } from "./chunk-6NLHFIYA.js";
+import {
+  storeIssues
+} from "./chunk-JDHR5BDR.js";
 import {
   getTrieDirectory,
   getWorkingDirectory
-} from "./chunk-WT3XQCG2.js";
+} from "./chunk-R4AAPFXC.js";
+import {
+  isInteractiveMode
+} from "./chunk-APMV77PU.js";
+import {
+  __require
+} from "./chunk-DGUM43GV.js";
 
 // src/cli/checkpoint.ts
 import { existsSync } from "fs";
@@ -202,10 +199,449 @@ async function handleCheckpointCommand(args) {
   }
 }
 
-// src/utils/autonomy-config.ts
+// src/config/loader.ts
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3, dirname } from "path";
+
+// src/config/validation.ts
+import { z } from "zod";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { resolve, join as join2 } 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 = join2(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
+        if (existsSync2(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 (!existsSync2(resolvedPath)) {
+          errors.push(`Include path does not exist: ${path8}`);
+        }
+      }
+    }
+    if (paths?.configDir) {
+      const configPath = resolve(paths.configDir);
+      if (!existsSync2(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 = join2(workDir, envFile);
+          if (existsSync2(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 = join3(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
+  try {
+    if (!existsSync3(configPath)) {
+      return DEFAULT_CONFIG;
+    }
+    const configFile = await readFile2(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 = join3(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
+  const dir = dirname(configPath);
+  if (!existsSync3(dir)) {
+    await mkdir2(dir, { recursive: true });
+  }
+  await writeFile2(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 readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
 
 // src/types/autonomy.ts
 var DEFAULT_AUTONOMY_CONFIG = {
@@ -252,12 +688,12 @@ var DEFAULT_AUTONOMY_CONFIG = {
 // src/utils/autonomy-config.ts
 import { createHash } from "crypto";
 async function loadAutonomyConfig(projectPath) {
-  const configPath = join2(getTrieDirectory(projectPath), "config.json");
+  const configPath = join4(getTrieDirectory(projectPath), "config.json");
   try {
-    if (!existsSync2(configPath)) {
+    if (!existsSync4(configPath)) {
       return { ...DEFAULT_AUTONOMY_CONFIG };
     }
-    const content = await readFile2(configPath, "utf-8");
+    const content = await readFile3(configPath, "utf-8");
     const config = JSON.parse(content);
     return mergeWithDefaults(config.autonomy || {});
   } catch (error) {
@@ -295,11 +731,11 @@ async function getOccurrences(projectPath) {
   if (occurrenceCache.has(projectPath)) {
     return occurrenceCache.get(projectPath);
   }
-  const occurrencesPath = join2(getTrieDirectory(projectPath), "memory", "occurrences.json");
+  const occurrencesPath = join4(getTrieDirectory(projectPath), "memory", "occurrences.json");
   const occurrences = /* @__PURE__ */ new Map();
   try {
-    if (existsSync2(occurrencesPath)) {
-      const content = await readFile2(occurrencesPath, "utf-8");
+    if (existsSync4(occurrencesPath)) {
+      const content = await readFile3(occurrencesPath, "utf-8");
       const data = JSON.parse(content);
       for (const [hash, occ] of Object.entries(data)) {
         occurrences.set(hash, occ);
@@ -313,17 +749,17 @@ async function getOccurrences(projectPath) {
 async function saveOccurrences(projectPath) {
   const occurrences = occurrenceCache.get(projectPath);
   if (!occurrences) return;
-  const occurrencesPath = join2(getTrieDirectory(projectPath), "memory", "occurrences.json");
-  const memoryDir = join2(getTrieDirectory(projectPath), "memory");
+  const occurrencesPath = join4(getTrieDirectory(projectPath), "memory", "occurrences.json");
+  const memoryDir = join4(getTrieDirectory(projectPath), "memory");
   try {
-    if (!existsSync2(memoryDir)) {
-      await mkdir2(memoryDir, { recursive: true });
+    if (!existsSync4(memoryDir)) {
+      await mkdir3(memoryDir, { recursive: true });
     }
     const data = {};
     for (const [hash, occ] of occurrences.entries()) {
       data[hash] = occ;
     }
-    await writeFile2(occurrencesPath, JSON.stringify(data, null, 2));
+    await writeFile3(occurrencesPath, JSON.stringify(data, null, 2));
   } catch (error) {
     console.error("Failed to save occurrences:", error);
   }
@@ -470,8 +906,93 @@ async function getAutonomyConfig(projectPath) {
   return config;
 }
 
-// src/agent/perceive.ts
+// src/agent/git.ts
+import { existsSync as existsSync5 } from "fs";
 import path from "path";
+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];
@@ -575,7 +1096,7 @@ async function upsertWorkingChange(graph, files, projectPath) {
   return change.id;
 }
 async function ensureFileNode(graph, filePath, projectPath) {
-  const normalized = path.resolve(projectPath, filePath);
+  const normalized = path2.resolve(projectPath, filePath);
   const existing = await graph.getNode("file", normalized);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   if (existing) {
@@ -588,7 +1109,7 @@ async function ensureFileNode(graph, filePath, projectPath) {
   }
   const data = {
     path: filePath,
-    extension: path.extname(filePath),
+    extension: path2.extname(filePath),
     purpose: "",
     riskLevel: "medium",
     whyRisky: null,
@@ -601,7 +1122,7 @@ async function ensureFileNode(graph, filePath, projectPath) {
 }
 
 // src/agent/risk-scorer.ts
-import path2 from "path";
+import path3 from "path";
 var BASE_RISK = {
   low: 10,
   medium: 35,
@@ -611,8 +1132,7 @@ var BASE_RISK = {
 var SENSITIVE_PATHS = [
   { pattern: /auth|login|token|session/i, weight: 20, reason: "touches authentication" },
   { pattern: /payment|billing|stripe|paypal|checkout/i, weight: 25, reason: "touches payments" },
-  { pattern: /secret|credential|env|config\/security/i, weight: 15, reason: "touches secrets/security config" },
-  { pattern: /gdpr|privacy|pii|phi/i, weight: 15, reason: "touches sensitive data" }
+  { pattern: /secret|credential|env|config\/security/i, weight: 15, reason: "touches secrets/security config" }
 ];
 function levelFromScore(score) {
   if (score >= 90) return "critical";
@@ -622,7 +1142,7 @@ function levelFromScore(score) {
 }
 async function scoreFile(graph, filePath, matchedPatterns = []) {
   const reasons = [];
-  const normalized = path2.resolve(graph.projectRoot, filePath);
+  const normalized = path3.resolve(graph.projectRoot, filePath);
   const node = await graph.getNode("file", normalized);
   const incidents = await graph.getIncidentsForFile(filePath);
   let score = 10;
@@ -724,6 +1244,629 @@ async function matchPatternsForFiles(graph, files) {
   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 existsSync6 } 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 = existsSync6(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 readFile4, writeFile as writeFile4, mkdir as mkdir4, stat } from "fs/promises";
+import { join as join5 } 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 = join5(getTrieDirectory(baseDir), "cache");
+    this.indexPath = join5(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 readFile4(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 readFile4(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 mkdir4(this.cacheDir, { recursive: true });
+      await writeFile4(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 {
@@ -801,7 +1944,7 @@ async function reasonAboutChanges(projectPath, files, options = {}) {
   if (options.runAgents) {
     const codeContext = options.codeContext ?? buildDefaultCodeContext();
     const triager = new Triager();
-    const agents = await triager.selectAgents(codeContext, riskLevel);
+    const agents = await triager.triage(codeContext);
     if (agents.length > 0) {
       const executor = new Executor();
       const scanContext = {
@@ -827,9 +1970,9 @@ async function reasonAboutChangesHumanReadable(projectPath, files, options = {})
 }
 
 // src/bootstrap/files.ts
-import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
+import { readFile as readFile5, writeFile as writeFile5, unlink, mkdir as mkdir5 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+import { join as join6 } 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" },
@@ -844,15 +1987,15 @@ async function loadBootstrapContext(workDir) {
   const contentParts = [];
   let needsBootstrap2 = false;
   for (const file of BOOTSTRAP_FILES) {
-    const filePath = join3(trieDir, file.name);
-    const exists = existsSync3(filePath);
+    const filePath = join6(trieDir, file.name);
+    const exists = existsSync7(filePath);
     if (file.name === "BOOTSTRAP.md" && exists) {
       needsBootstrap2 = true;
     }
     let content;
     if (exists) {
       try {
-        content = await readFile3(filePath, "utf-8");
+        content = await readFile5(filePath, "utf-8");
         if (content.trim() && file.type !== "one-time") {
           contentParts.push(`<!-- ${file.name} -->
 ${content}`);
@@ -878,13 +2021,13 @@ ${content}`);
 async function initializeBootstrapFiles(options = {}) {
   const projectDir = options.workDir || getWorkingDirectory(void 0, true);
   const trieDir = getTrieDirectory(projectDir);
-  await mkdir3(trieDir, { recursive: true });
+  await mkdir5(trieDir, { recursive: true });
   const created = [];
   const skipped = [];
   const stack = await detectStack(projectDir);
   for (const file of BOOTSTRAP_FILES) {
-    const filePath = join3(trieDir, file.name);
-    const exists = existsSync3(filePath);
+    const filePath = join6(trieDir, file.name);
+    const exists = existsSync7(filePath);
     if (exists && !options.force) {
       skipped.push(file.name);
       continue;
@@ -899,7 +2042,7 @@ async function initializeBootstrapFiles(options = {}) {
     }
     const template = getFileTemplate(file.name, stack);
     if (template) {
-      await writeFile3(filePath, template);
+      await writeFile5(filePath, template);
       created.push(file.name);
     }
   }
@@ -907,7 +2050,7 @@ async function initializeBootstrapFiles(options = {}) {
 }
 async function completeBootstrap(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const bootstrapPath = join3(getTrieDirectory(projectDir), "BOOTSTRAP.md");
+  const bootstrapPath = join6(getTrieDirectory(projectDir), "BOOTSTRAP.md");
   try {
     await unlink(bootstrapPath);
     return true;
@@ -917,15 +2060,15 @@ async function completeBootstrap(workDir) {
 }
 function needsBootstrap(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const bootstrapPath = join3(getTrieDirectory(projectDir), "BOOTSTRAP.md");
-  return existsSync3(bootstrapPath);
+  const bootstrapPath = join6(getTrieDirectory(projectDir), "BOOTSTRAP.md");
+  return existsSync7(bootstrapPath);
 }
 async function loadRules(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const rulesPath = join3(getTrieDirectory(projectDir), "RULES.md");
+  const rulesPath = join6(getTrieDirectory(projectDir), "RULES.md");
   try {
-    if (existsSync3(rulesPath)) {
-      return await readFile3(rulesPath, "utf-8");
+    if (existsSync7(rulesPath)) {
+      return await readFile5(rulesPath, "utf-8");
     }
   } catch {
   }
@@ -933,10 +2076,10 @@ async function loadRules(workDir) {
 }
 async function loadTeamInfo(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const teamPath = join3(getTrieDirectory(projectDir), "TEAM.md");
+  const teamPath = join6(getTrieDirectory(projectDir), "TEAM.md");
   try {
-    if (existsSync3(teamPath)) {
-      return await readFile3(teamPath, "utf-8");
+    if (existsSync7(teamPath)) {
+      return await readFile5(teamPath, "utf-8");
     }
   } catch {
   }
@@ -1060,7 +2203,7 @@ function getBootstrapTemplate(stack) {
   if (stack.auth) lines.push(`- **Auth:** ${stack.auth}`);
   lines.push("", "## Recommended Actions", "", "### 1. Skills to Install", "Based on your stack, consider installing:", "```bash");
   lines.push(skillCommands || "# No specific skills detected - browse https://skills.sh");
-  lines.push("```", "", "### 2. Agents to Enable", `Your stack suggests these agents: ${agentList || "security, privacy, bugs"}`, "");
+  lines.push("```", "", "### 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", "```");
@@ -1091,28 +2234,28 @@ function formatFriendlyError(error) {
 
 // src/context/sync.ts
 import fs from "fs/promises";
-import path3 from "path";
+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 ?? path3.join(getTrieDirectory(graph.projectRoot), DEFAULT_JSON_NAME);
-  await fs.mkdir(path3.dirname(outputPath), { recursive: true });
+  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 ?? path3.join(getTrieDirectory(graph.projectRoot), DEFAULT_JSON_NAME), "utf8");
+  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 path5 from "path";
+import path6 from "path";
 
 // src/context/file-trie.ts
 import fs2 from "fs";
-import path4 from "path";
+import path5 from "path";
 import { performance } from "perf_hooks";
 function normalizePath(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
@@ -1176,9 +2319,9 @@ var FilePathTrie = class {
       incidentCount: Array.isArray(r.value) ? r.value.length : 0
     })).sort((a, b) => b.incidentCount - a.incidentCount).slice(0, limit);
   }
-  timeLookup(path7) {
+  timeLookup(path8) {
     const start = performance.now();
-    this.getIncidents(path7);
+    this.getIncidents(path8);
     return performance.now() - start;
   }
   toJSON() {
@@ -1191,7 +2334,7 @@ var FilePathTrie = class {
   persist() {
     if (!this.persistPath) return;
     try {
-      const dir = path4.dirname(this.persistPath);
+      const dir = path5.dirname(this.persistPath);
       if (!fs2.existsSync(dir)) {
         fs2.mkdirSync(dir, { recursive: true });
       }
@@ -1210,7 +2353,7 @@ var IncidentIndex = class _IncidentIndex {
     this.graph = graph;
     this.projectRoot = projectRoot;
     this.trie = new FilePathTrie(
-      options?.persistPath ?? path5.join(getTrieDirectory(projectRoot), "incident-trie.json")
+      options?.persistPath ?? path6.join(getTrieDirectory(projectRoot), "incident-trie.json")
     );
   }
   static async build(graph, projectRoot, options) {
@@ -1263,8 +2406,8 @@ var IncidentIndex = class _IncidentIndex {
     return Array.from(files);
   }
   normalizePath(filePath) {
-    const absolute = path5.isAbsolute(filePath) ? filePath : path5.join(this.projectRoot, filePath);
-    const relative = path5.relative(this.projectRoot, absolute);
+    const absolute = path6.isAbsolute(filePath) ? filePath : path6.join(this.projectRoot, filePath);
+    const relative = path6.relative(this.projectRoot, absolute);
     return relative.replace(/\\/g, "/");
   }
 };
@@ -1404,7 +2547,7 @@ var LearningSystem = class {
 };
 
 // src/guardian/learning-engine.ts
-import path6 from "path";
+import path7 from "path";
 var LearningEngine = class {
   projectPath;
   graph;
@@ -1453,7 +2596,7 @@ var LearningEngine = class {
       }
     }
     if (issuesToStore.length > 0) {
-      const result = await storeIssues(issuesToStore, path6.basename(this.projectPath), this.projectPath);
+      const result = await storeIssues(issuesToStore, path7.basename(this.projectPath), this.projectPath);
       return result.stored;
     }
     return 0;
@@ -1666,11 +2809,15 @@ var LinearIngester = class {
 };
 
 export {
+  loadConfig,
+  saveConfig,
   trackIssueOccurrence,
   recordBypass,
   shouldAutoFix,
   shouldBlockPush,
   getAutonomyConfig,
+  getStagedChanges,
+  getUncommittedChanges,
   perceiveCurrentChanges,
   reasonAboutChangesHumanReadable,
   loadBootstrapContext,
@@ -1690,4 +2837,4 @@ export {
   LearningEngine,
   LinearIngester
 };
-//# sourceMappingURL=chunk-AZRCKBGF.js.map
+//# sourceMappingURL=chunk-FNCCZ3XB.js.map