@triedotdev/mcp 1.0.110 → 1.0.111

package/dist/chunk-QYOACM2C.js

@@ -0,0 +1,1923 @@
+import {
+  ContextGraph
+} from "./chunk-6QR6QZIX.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";
+
+// src/cli/checkpoint.ts
+import { existsSync } from "fs";
+import { mkdir, writeFile, readFile } from "fs/promises";
+import { join } from "path";
+async function saveCheckpoint(options) {
+  const workDir = options.workDir || getWorkingDirectory(void 0, true);
+  const trieDir = getTrieDirectory(workDir);
+  const checkpointPath = join(trieDir, "checkpoints.json");
+  await mkdir(trieDir, { recursive: true });
+  let log = { checkpoints: [] };
+  try {
+    if (existsSync(checkpointPath)) {
+      log = JSON.parse(await readFile(checkpointPath, "utf-8"));
+    }
+  } catch {
+    log = { checkpoints: [] };
+  }
+  const checkpoint = {
+    id: `cp-${Date.now().toString(36)}`,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    files: options.files || [],
+    createdBy: options.createdBy || "cli"
+  };
+  if (options.message) checkpoint.message = options.message;
+  if (options.notes) checkpoint.notes = options.notes;
+  log.checkpoints.push(checkpoint);
+  log.lastCheckpoint = checkpoint.id;
+  if (log.checkpoints.length > 50) {
+    log.checkpoints = log.checkpoints.slice(-50);
+  }
+  await writeFile(checkpointPath, JSON.stringify(log, null, 2));
+  await updateAgentsMdWithCheckpoint(checkpoint, workDir);
+  return checkpoint;
+}
+async function listCheckpoints(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const checkpointPath = join(getTrieDirectory(dir), "checkpoints.json");
+  try {
+    if (existsSync(checkpointPath)) {
+      const log = JSON.parse(await readFile(checkpointPath, "utf-8"));
+      return log.checkpoints;
+    }
+  } catch {
+  }
+  return [];
+}
+async function getLastCheckpoint(workDir) {
+  const checkpoints = await listCheckpoints(workDir);
+  const last = checkpoints[checkpoints.length - 1];
+  return last ?? null;
+}
+async function updateAgentsMdWithCheckpoint(checkpoint, workDir) {
+  const agentsPath = join(getTrieDirectory(workDir), "AGENTS.md");
+  let content = "";
+  try {
+    if (existsSync(agentsPath)) {
+      content = await readFile(agentsPath, "utf-8");
+    }
+  } catch {
+    content = "";
+  }
+  const checkpointSection = `
+## Last Checkpoint
+
+- **ID:** ${checkpoint.id}
+- **Time:** ${checkpoint.timestamp}
+${checkpoint.message ? `- **Message:** ${checkpoint.message}` : ""}
+${checkpoint.files.length > 0 ? `- **Files:** ${checkpoint.files.length} files` : ""}
+${checkpoint.notes ? `- **Notes:** ${checkpoint.notes}` : ""}
+`;
+  const checkpointRegex = /## Last Checkpoint[\s\S]*?(?=\n## |\n---|\Z)/;
+  if (checkpointRegex.test(content)) {
+    content = content.replace(checkpointRegex, checkpointSection.trim());
+  } else {
+    content = content.trim() + "\n\n" + checkpointSection.trim() + "\n";
+  }
+  await writeFile(agentsPath, content);
+}
+async function handleCheckpointCommand(args) {
+  const subcommand = args[0] || "save";
+  switch (subcommand) {
+    case "save": {
+      let message;
+      let notes;
+      const files = [];
+      for (let i = 1; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "-m" || arg === "--message") {
+          message = args[++i] ?? "";
+        } else if (arg === "-n" || arg === "--notes") {
+          notes = args[++i] ?? "";
+        } else if (arg === "-f" || arg === "--file") {
+          const file = args[++i];
+          if (file) files.push(file);
+        } else if (arg && !arg.startsWith("-")) {
+          message = arg;
+        }
+      }
+      const opts = { files };
+      if (message) opts.message = message;
+      if (notes) opts.notes = notes;
+      const checkpoint = await saveCheckpoint(opts);
+      console.log("\n  Checkpoint saved\n");
+      console.log(`  ID: ${checkpoint.id}`);
+      console.log(`  Time: ${checkpoint.timestamp}`);
+      if (checkpoint.message) {
+        console.log(`  Message: ${checkpoint.message}`);
+      }
+      if (checkpoint.files.length > 0) {
+        console.log(`  Files: ${checkpoint.files.join(", ")}`);
+      }
+      console.log("\n  Context saved to .trie/\n");
+      break;
+    }
+    case "list": {
+      const checkpoints = await listCheckpoints();
+      if (checkpoints.length === 0) {
+        console.log("\n  No checkpoints yet. Run `trie checkpoint` to save one.\n");
+        return;
+      }
+      console.log("\n  Checkpoints:\n");
+      for (const cp of checkpoints.slice(-10).reverse()) {
+        const date = new Date(cp.timestamp).toLocaleString();
+        console.log(`  ${cp.id}  ${date}  ${cp.message || "(no message)"}`);
+      }
+      console.log("");
+      break;
+    }
+    case "last": {
+      const checkpoint = await getLastCheckpoint();
+      if (!checkpoint) {
+        console.log("\n  No checkpoints yet. Run `trie checkpoint` to save one.\n");
+        return;
+      }
+      console.log("\n  Last Checkpoint:\n");
+      console.log(`  ID: ${checkpoint.id}`);
+      console.log(`  Time: ${new Date(checkpoint.timestamp).toLocaleString()}`);
+      if (checkpoint.message) {
+        console.log(`  Message: ${checkpoint.message}`);
+      }
+      if (checkpoint.notes) {
+        console.log(`  Notes: ${checkpoint.notes}`);
+      }
+      if (checkpoint.files.length > 0) {
+        console.log(`  Files: ${checkpoint.files.join(", ")}`);
+      }
+      console.log("");
+      break;
+    }
+    default:
+      console.log(`
+  Usage: trie checkpoint [command] [options]
+
+  Commands:
+    save [message]     Save a checkpoint (default)
+    list               List recent checkpoints
+    last               Show the last checkpoint
+
+  Options:
+    -m, --message      Checkpoint message
+    -n, --notes        Additional notes
+    -f, --file         File to include (can be repeated)
+
+  Examples:
+    trie checkpoint "finished auth flow"
+    trie checkpoint save -m "WIP: payment integration" -n "needs testing"
+    trie checkpoint list
+`);
+  }
+}
+
+// src/utils/trie-init.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var INIT_MARKERS = [
+  "PROJECT.md",
+  "RULES.md",
+  "TEAM.md",
+  "BOOTSTRAP.md",
+  "AGENTS.md",
+  "config.json"
+];
+function isTrieInitialized(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const trieDir = getTrieDirectory(dir);
+  return INIT_MARKERS.some((marker) => existsSync2(join2(trieDir, marker)));
+}
+
+// src/context/sync.ts
+import fs from "fs/promises";
+import path 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 ?? path.join(getTrieDirectory(graph.projectRoot), DEFAULT_JSON_NAME);
+  await fs.mkdir(path.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 ?? path.join(getTrieDirectory(graph.projectRoot), DEFAULT_JSON_NAME), "utf8");
+  const snapshot = JSON.parse(payload);
+  await graph.applySnapshot(snapshot);
+}
+
+// src/context/incident-index.ts
+import path3 from "path";
+
+// src/context/file-trie.ts
+import fs2 from "fs";
+import path2 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 = path2.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 ?? path3.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 = path3.isAbsolute(filePath) ? filePath : path3.join(this.projectRoot, filePath);
+    const relative = path3.relative(this.projectRoot, absolute);
+    return relative.replace(/\\/g, "/");
+  }
+};
+
+// 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/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 existsSync3 } from "fs";
+import path4 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/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 path5 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, path5.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/agent/perceive.ts
+import path6 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 = path6.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: path6.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 path7 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 = path7.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 existsSync4 } 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 = existsSync4(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((resolve, 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);
+          resolve(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 readFile2, writeFile as writeFile2, mkdir as mkdir2, stat } from "fs/promises";
+import { join as join3 } from "path";
+import { createHash } 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 = join3(getTrieDirectory(baseDir), "cache");
+    this.indexPath = join3(this.cacheDir, "index.json");
+  }
+  /**
+   * Generate cache key for a file and agent combination
+   */
+  generateCacheKey(filePath, agent, fileHash) {
+    const key = `${filePath}:${agent}:${fileHash}`;
+    return createHash("sha256").update(key).digest("hex").slice(0, 16);
+  }
+  /**
+   * Get file hash for cache validation
+   */
+  async getFileHash(filePath) {
+    try {
+      const content = await readFile2(filePath, "utf-8");
+      const stats = await stat(filePath);
+      const hash = createHash("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 readFile2(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 mkdir2(this.cacheDir, { recursive: true });
+      await writeFile2(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 (resolve, 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);
+        resolve(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);
+}
+
+export {
+  exportToJson,
+  importFromJson,
+  IncidentIndex,
+  formatFriendlyError,
+  formatAuditLog,
+  getAuditStatistics,
+  getRecentAuditLogs,
+  getSkillAuditLogs,
+  runShellCommandSync,
+  getStagedChanges,
+  getUncommittedChanges,
+  LearningEngine,
+  perceiveCurrentChanges,
+  reasonAboutChangesHumanReadable,
+  saveCheckpoint,
+  listCheckpoints,
+  getLastCheckpoint,
+  handleCheckpointCommand,
+  isTrieInitialized
+};
+//# sourceMappingURL=chunk-QYOACM2C.js.map