@triedotdev/mcp 1.0.102 → 1.0.104

package/dist/{chunk-M4JCQO5G.js → chunk-CKYU5JOD.js}

@@ -1,25 +1,22 @@
-import {
-  runExecFile
-} from "./chunk-CCI6LKXZ.js";
 import {
   ContextGraph
-} from "./chunk-NIASHOAB.js";
-import {
-  scanForVulnerabilities
-} from "./chunk-F4NJ4CBP.js";
+} from "./chunk-SPQJC7RA.js";
 import {
   scanForVibeCodeIssues
 } from "./chunk-IXO4G4D3.js";
-import {
-  Trie
-} from "./chunk-6NLHFIYA.js";
 import {
   storeIssues
-} from "./chunk-JDHR5BDR.js";
+} 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";
@@ -27,19 +24,235 @@ import {
   __require
 } from "./chunk-DGUM43GV.js";
 
-// src/cli/checkpoint.ts
+// src/utils/project-info.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
 import { existsSync } from "fs";
-import { mkdir, writeFile, readFile } from "fs/promises";
 import { join } from "path";
+var PROJECT_MD_PATH = "PROJECT.md";
+function getProjectTemplate() {
+  return `# Project Information
+
+> This file stores important project context for AI assistants.
+> Edit freely - this file is yours, not auto-generated.
+> Available via MCP resource: \`trie://project\`
+
+---
+
+## Project Overview
+
+<!-- Describe your project's purpose and goals -->
+
+[Add project description here]
+
+---
+
+## Technology Stack
+
+<!-- List frameworks, languages, databases, cloud services, etc. -->
+
+- **Language:** 
+- **Framework:** 
+- **Database:** 
+- **Hosting:** 
+
+---
+
+## Architecture
+
+<!-- Key patterns, architectural decisions, and system design -->
+
+[Describe your architecture here]
+
+---
+
+## Coding Conventions
+
+<!-- Style guidelines, naming conventions, patterns to follow -->
+
+- 
+- 
+- 
+
+---
+
+## Environment
+
+<!-- URLs, API endpoints, deployment info -->
+
+| Environment | URL | Notes |
+|-------------|-----|-------|
+| Development | | |
+| Staging | | |
+| Production | | |
+
+---
+
+## Team
+
+<!-- Ownership, contacts, responsibilities -->
+
+- **Owner:** 
+- **Team:** 
+
+---
+
+## Compliance
+
+<!-- HIPAA, SOC2, GDPR, PCI-DSS requirements if applicable -->
+
+- [ ] GDPR
+- [ ] SOC2
+- [ ] HIPAA
+- [ ] PCI-DSS
+
+---
+
+## AI Instructions
+
+<!-- Special instructions for AI assistants working on this project -->
+
+When working on this project, AI assistants should:
+
+1. 
+2. 
+3. 
+
+---
+
+*This file is read by Trie agents and exposed via \`trie://project\` MCP resource.*
+*Edit this file to provide context to Claude Code, Cursor, GitHub Actions, and other AI tools.*
+`;
+}
+function projectInfoExists(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const projectPath = join(getTrieDirectory(dir), PROJECT_MD_PATH);
+  return existsSync(projectPath);
+}
+async function loadProjectInfo(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const projectPath = join(getTrieDirectory(dir), PROJECT_MD_PATH);
+  try {
+    if (!existsSync(projectPath)) {
+      return null;
+    }
+    return await readFile(projectPath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function saveProjectInfo(content, workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const trieDir = getTrieDirectory(dir);
+  const projectPath = join(trieDir, PROJECT_MD_PATH);
+  await mkdir(trieDir, { recursive: true });
+  await writeFile(projectPath, content, "utf-8");
+}
+async function initProjectInfo(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const projectPath = join(getTrieDirectory(dir), PROJECT_MD_PATH);
+  if (existsSync(projectPath)) {
+    return { created: false, path: projectPath };
+  }
+  await saveProjectInfo(getProjectTemplate(), dir);
+  return { created: true, path: projectPath };
+}
+async function getProjectSection(sectionName, workDir) {
+  const content = await loadProjectInfo(workDir);
+  if (!content) return null;
+  const sectionRegex = new RegExp(
+    `## ${escapeRegex(sectionName)}\\s*\\n([\\s\\S]*?)(?=\\n## |\\n---\\s*$|$)`,
+    "i"
+  );
+  const match = content.match(sectionRegex);
+  if (match?.[1]) {
+    return match[1].trim();
+  }
+  return null;
+}
+async function updateProjectSection(sectionName, newContent, workDir) {
+  let content = await loadProjectInfo(workDir);
+  if (!content) {
+    await initProjectInfo(workDir);
+    content = await loadProjectInfo(workDir);
+    if (!content) return false;
+  }
+  const sectionRegex = new RegExp(
+    `(## ${escapeRegex(sectionName)}\\s*\\n)([\\s\\S]*?)((?=\\n## )|(?=\\n---\\s*$)|$)`,
+    "i"
+  );
+  if (content.match(sectionRegex)) {
+    const updatedContent = content.replace(sectionRegex, `$1
+${newContent}
+
+$3`);
+    await saveProjectInfo(updatedContent, workDir);
+    return true;
+  }
+  return false;
+}
+async function appendToSection(sectionName, contentToAdd, workDir) {
+  const currentContent = await getProjectSection(sectionName, workDir);
+  if (currentContent === null) return false;
+  const newContent = currentContent + "\n" + contentToAdd;
+  return updateProjectSection(sectionName, newContent, workDir);
+}
+async function getProjectSections(workDir) {
+  const content = await loadProjectInfo(workDir);
+  if (!content) return [];
+  const sectionRegex = /^## (.+)$/gm;
+  const sections = [];
+  let match;
+  while ((match = sectionRegex.exec(content)) !== null) {
+    if (match[1]) {
+      sections.push(match[1].trim());
+    }
+  }
+  return sections;
+}
+async function getProjectInfoStructured(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const projectPath = join(getTrieDirectory(dir), PROJECT_MD_PATH);
+  const content = await loadProjectInfo(dir);
+  if (!content) {
+    return {
+      exists: false,
+      path: projectPath,
+      sections: {},
+      raw: null
+    };
+  }
+  const sectionNames = await getProjectSections(dir);
+  const sections = {};
+  for (const name of sectionNames) {
+    const sectionContent = await getProjectSection(name, dir);
+    if (sectionContent) {
+      sections[name] = sectionContent;
+    }
+  }
+  return {
+    exists: true,
+    path: projectPath,
+    sections,
+    raw: content
+  };
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/cli/checkpoint.ts
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
 async function saveCheckpoint(options) {
   const workDir = options.workDir || getWorkingDirectory(void 0, true);
   const trieDir = getTrieDirectory(workDir);
-  const checkpointPath = join(trieDir, "checkpoints.json");
-  await mkdir(trieDir, { recursive: true });
+  const checkpointPath = join2(trieDir, "checkpoints.json");
+  await mkdir2(trieDir, { recursive: true });
   let log = { checkpoints: [] };
   try {
-    if (existsSync(checkpointPath)) {
-      log = JSON.parse(await readFile(checkpointPath, "utf-8"));
+    if (existsSync2(checkpointPath)) {
+      log = JSON.parse(await readFile2(checkpointPath, "utf-8"));
     }
   } catch {
     log = { checkpoints: [] };
@@ -57,16 +270,16 @@ async function saveCheckpoint(options) {
   if (log.checkpoints.length > 50) {
     log.checkpoints = log.checkpoints.slice(-50);
   }
-  await writeFile(checkpointPath, JSON.stringify(log, null, 2));
+  await writeFile2(checkpointPath, JSON.stringify(log, null, 2));
   await updateAgentsMdWithCheckpoint(checkpoint, workDir);
   return checkpoint;
 }
 async function listCheckpoints(workDir) {
   const dir = workDir || getWorkingDirectory(void 0, true);
-  const checkpointPath = join(getTrieDirectory(dir), "checkpoints.json");
+  const checkpointPath = join2(getTrieDirectory(dir), "checkpoints.json");
   try {
-    if (existsSync(checkpointPath)) {
-      const log = JSON.parse(await readFile(checkpointPath, "utf-8"));
+    if (existsSync2(checkpointPath)) {
+      const log = JSON.parse(await readFile2(checkpointPath, "utf-8"));
       return log.checkpoints;
     }
   } catch {
@@ -79,11 +292,11 @@ async function getLastCheckpoint(workDir) {
   return last ?? null;
 }
 async function updateAgentsMdWithCheckpoint(checkpoint, workDir) {
-  const agentsPath = join(getTrieDirectory(workDir), "AGENTS.md");
+  const agentsPath = join2(getTrieDirectory(workDir), "AGENTS.md");
   let content = "";
   try {
-    if (existsSync(agentsPath)) {
-      content = await readFile(agentsPath, "utf-8");
+    if (existsSync2(agentsPath)) {
+      content = await readFile2(agentsPath, "utf-8");
     }
   } catch {
     content = "";
@@ -103,7 +316,7 @@ ${checkpoint.notes ? `- **Notes:** ${checkpoint.notes}` : ""}
   } else {
     content = content.trim() + "\n\n" + checkpointSection.trim() + "\n";
   }
-  await writeFile(agentsPath, content);
+  await writeFile2(agentsPath, content);
 }
 async function handleCheckpointCommand(args) {
   const subcommand = args[0] || "save";
@@ -198,15 +411,107 @@ async function handleCheckpointCommand(args) {
   }
 }
 
-// src/config/loader.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+// src/utils/context-state.ts
+import { readFile as readFile3, mkdir as mkdir3 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import { join as join3, dirname } from "path";
+import { join as join3, basename } from "path";
+var STATE_JSON_PATH = "state.json";
+async function loadContextState() {
+  const workDir = getWorkingDirectory(void 0, true);
+  const statePath = join3(getTrieDirectory(workDir), STATE_JSON_PATH);
+  const defaults = getDefaultState();
+  try {
+    if (existsSync3(statePath)) {
+      const content = await readFile3(statePath, "utf-8");
+      const loaded = JSON.parse(content);
+      return {
+        ...defaults,
+        ...loaded,
+        skills: loaded.skills || defaults.skills
+      };
+    }
+  } catch {
+  }
+  return defaults;
+}
+function getDefaultState() {
+  return {
+    lastScan: null,
+    healthScore: 0,
+    activePriorities: [
+      "Initial setup required - run first scan with `trie scan`",
+      "Configure agents in `.trie/config.json`",
+      "Set up CI/CD integration"
+    ],
+    contextSignals: {},
+    agentStatus: {},
+    scanHistory: [],
+    customAgents: [],
+    skills: {},
+    environment: detectEnvironment()
+  };
+}
+function detectEnvironment() {
+  if (process.env.GITHUB_ACTIONS) return "github-actions";
+  if (process.env.GITLAB_CI) return "gitlab-ci";
+  if (process.env.CI) return "ci";
+  const parent = process.env._ || "";
+  if (parent.includes("cursor")) return "cursor";
+  if (parent.includes("claude")) return "claude-code";
+  return "cli";
+}
+async function getContextForAI() {
+  const state = await loadContextState();
+  const workDir = getWorkingDirectory(void 0, true);
+  const lines = [];
+  if (projectInfoExists(workDir)) {
+    const projectInfo = await loadProjectInfo(workDir);
+    if (projectInfo) {
+      lines.push(projectInfo);
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+    }
+  }
+  lines.push(
+    "## Trie Scan Context",
+    "",
+    `**Health Score:** ${state.healthScore}%`,
+    `**Last Scan:** ${state.lastScan ? new Date(state.lastScan.timestamp).toLocaleString() : "Never"}`,
+    "",
+    "**Active Priorities:**",
+    ...state.activePriorities.map((p) => `- ${p}`),
+    ""
+  );
+  if (state.lastScan) {
+    lines.push(
+      "**Recent Issues:**",
+      `- Critical: ${state.lastScan.issues.critical}`,
+      `- Serious: ${state.lastScan.issues.serious}`,
+      `- Moderate: ${state.lastScan.issues.moderate}`,
+      `- Low: ${state.lastScan.issues.low}`,
+      ""
+    );
+    if (state.lastScan.hotFiles.length > 0) {
+      lines.push(
+        "**Hot Files (most issues):**",
+        ...state.lastScan.hotFiles.slice(0, 5).map((f) => `- ${f.file}: ${f.issueCount} issues`),
+        ""
+      );
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/config/loader.ts
+import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir4 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { join as join5, dirname } from "path";
 
 // src/config/validation.ts
 import { z } from "zod";
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { resolve, join as join2 } from "path";
+import { existsSync as existsSync4, readFileSync } from "fs";
+import { resolve, join as join4 } from "path";
 var API_KEY_PATTERNS = {
   anthropic: /^sk-ant-api\d{2}-[\w-]{95}$/,
   openai: /^sk-[\w]{48}$/,
@@ -342,8 +647,8 @@ var ConfigValidator = class {
     let anthropicKey = process.env.ANTHROPIC_API_KEY;
     if (!anthropicKey) {
       try {
-        const configPath = join2(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
-        if (existsSync2(configPath)) {
+        const configPath = join4(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
+        if (existsSync4(configPath)) {
           const config = JSON.parse(readFileSync(configPath, "utf-8"));
           anthropicKey = config.apiKeys?.anthropic;
         }
@@ -373,14 +678,14 @@ var ConfigValidator = class {
     if (paths?.include) {
       for (const path8 of paths.include) {
         const resolvedPath = resolve(path8);
-        if (!existsSync2(resolvedPath)) {
+        if (!existsSync4(resolvedPath)) {
           errors.push(`Include path does not exist: ${path8}`);
         }
       }
     }
     if (paths?.configDir) {
       const configPath = resolve(paths.configDir);
-      if (!existsSync2(configPath)) {
+      if (!existsSync4(configPath)) {
         try {
           __require("fs").mkdirSync(configPath, { recursive: true });
         } catch {
@@ -500,8 +805,8 @@ var ConfigValidator = class {
         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 envPath = join4(workDir, envFile);
+          if (existsSync4(envPath)) {
             const envContent = readFileSync(envPath, "utf-8");
             if (envContent.includes("ANTHROPIC_API_KEY=")) {
               hasApiKey = true;
@@ -578,12 +883,12 @@ var DEFAULT_CONFIG = {
 // src/config/loader.ts
 async function loadConfig() {
   const validator = new ConfigValidator();
-  const configPath = join3(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
+  const configPath = join5(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
   try {
-    if (!existsSync3(configPath)) {
+    if (!existsSync5(configPath)) {
       return DEFAULT_CONFIG;
     }
-    const configFile = await readFile2(configPath, "utf-8");
+    const configFile = await readFile4(configPath, "utf-8");
     const userConfig = JSON.parse(configFile);
     const merged = mergeConfig(DEFAULT_CONFIG, userConfig);
     const result = validator.validateConfig(merged);
@@ -614,12 +919,12 @@ async function loadConfig() {
   }
 }
 async function saveConfig(config) {
-  const configPath = join3(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
+  const configPath = join5(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
   const dir = dirname(configPath);
-  if (!existsSync3(dir)) {
-    await mkdir2(dir, { recursive: true });
+  if (!existsSync5(dir)) {
+    await mkdir4(dir, { recursive: true });
   }
-  await writeFile2(configPath, JSON.stringify(config, null, 2), "utf-8");
+  await writeFile3(configPath, JSON.stringify(config, null, 2), "utf-8");
 }
 function mergeConfig(defaults, user) {
   if (typeof user !== "object" || user === null || Array.isArray(user)) {
@@ -638,9 +943,9 @@ function mergeConfig(defaults, user) {
 }
 
 // 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";
+import { readFile as readFile5, writeFile as writeFile4, mkdir as mkdir5 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
 
 // src/types/autonomy.ts
 var DEFAULT_AUTONOMY_CONFIG = {
@@ -687,12 +992,12 @@ var DEFAULT_AUTONOMY_CONFIG = {
 // src/utils/autonomy-config.ts
 import { createHash } from "crypto";
 async function loadAutonomyConfig(projectPath) {
-  const configPath = join4(getTrieDirectory(projectPath), "config.json");
+  const configPath = join6(getTrieDirectory(projectPath), "config.json");
   try {
-    if (!existsSync4(configPath)) {
+    if (!existsSync6(configPath)) {
       return { ...DEFAULT_AUTONOMY_CONFIG };
     }
-    const content = await readFile3(configPath, "utf-8");
+    const content = await readFile5(configPath, "utf-8");
     const config = JSON.parse(content);
     return mergeWithDefaults(config.autonomy || {});
   } catch (error) {
@@ -730,11 +1035,11 @@ async function getOccurrences(projectPath) {
   if (occurrenceCache.has(projectPath)) {
     return occurrenceCache.get(projectPath);
   }
-  const occurrencesPath = join4(getTrieDirectory(projectPath), "memory", "occurrences.json");
+  const occurrencesPath = join6(getTrieDirectory(projectPath), "memory", "occurrences.json");
   const occurrences = /* @__PURE__ */ new Map();
   try {
-    if (existsSync4(occurrencesPath)) {
-      const content = await readFile3(occurrencesPath, "utf-8");
+    if (existsSync6(occurrencesPath)) {
+      const content = await readFile5(occurrencesPath, "utf-8");
       const data = JSON.parse(content);
       for (const [hash, occ] of Object.entries(data)) {
         occurrences.set(hash, occ);
@@ -748,17 +1053,17 @@ async function getOccurrences(projectPath) {
 async function saveOccurrences(projectPath) {
   const occurrences = occurrenceCache.get(projectPath);
   if (!occurrences) return;
-  const occurrencesPath = join4(getTrieDirectory(projectPath), "memory", "occurrences.json");
-  const memoryDir = join4(getTrieDirectory(projectPath), "memory");
+  const occurrencesPath = join6(getTrieDirectory(projectPath), "memory", "occurrences.json");
+  const memoryDir = join6(getTrieDirectory(projectPath), "memory");
   try {
-    if (!existsSync4(memoryDir)) {
-      await mkdir3(memoryDir, { recursive: true });
+    if (!existsSync6(memoryDir)) {
+      await mkdir5(memoryDir, { recursive: true });
     }
     const data = {};
     for (const [hash, occ] of occurrences.entries()) {
       data[hash] = occ;
     }
-    await writeFile3(occurrencesPath, JSON.stringify(data, null, 2));
+    await writeFile4(occurrencesPath, JSON.stringify(data, null, 2));
   } catch (error) {
     console.error("Failed to save occurrences:", error);
   }
@@ -905,9 +1210,158 @@ async function getAutonomyConfig(projectPath) {
   return config;
 }
 
+// src/skills/audit-logger.ts
+function formatAuditLog(_entry) {
+  return "Audit logging has been integrated into the decision ledger";
+}
+function getAuditStatistics() {
+  return {
+    totalScans: 0,
+    totalIssues: 0,
+    criticalCount: 0,
+    seriousCount: 0,
+    moderateCount: 0,
+    lowCount: 0,
+    totalExecutions: 0,
+    successfulExecutions: 0,
+    failedExecutions: 0,
+    uniqueSkills: 0,
+    totalCommands: 0,
+    blockedCommands: 0,
+    totalNetworkCalls: 0,
+    blockedNetworkCalls: 0
+  };
+}
+function createAuditEntry(skillName, skillSource, triggeredBy, targetPath) {
+  return {
+    skillName,
+    skillSource,
+    triggeredBy,
+    targetPath,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    commands: []
+  };
+}
+function completeAuditEntry(entry, success, error) {
+  const result = {
+    ...entry,
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    success
+  };
+  if (error !== void 0) {
+    result.error = error;
+  }
+  return result;
+}
+async function logSkillExecution(_execution) {
+}
+async function getRecentAuditLogs(_limit = 10) {
+  return [];
+}
+async function getSkillAuditLogs(_skillName) {
+  return [];
+}
+
 // src/agent/git.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import path from "path";
+
+// src/utils/command-runner.ts
+import { exec, execFile, execSync } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var execFileAsync = promisify(execFile);
+function redact(text) {
+  return text.replace(/\b(AWS|ANTHROPIC|OPENAI|GITHUB)_[A-Z0-9_]*\s*=\s*([^\s"'`]+)/gi, "$1_<REDACTED>=<REDACTED>").replace(/\bBearer\s+[A-Za-z0-9\-._~+/]+=*\b/g, "Bearer <REDACTED>").replace(/\bghp_[A-Za-z0-9]{20,}\b/g, "ghp_<REDACTED>").replace(/\b(?:xox[baprs]-)[A-Za-z0-9-]{10,}\b/g, "<REDACTED_SLACK_TOKEN>").replace(/\bAKIA[0-9A-Z]{16}\b/g, "AKIA<REDACTED>");
+}
+function clampOutput(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars) + `
+\u2026(truncated ${text.length - maxChars} chars)`;
+}
+function buildCommandRecord(command) {
+  return {
+    command,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function finalizeAndWrite(entry, cmd, outcome, options) {
+  const duration = Date.now() - outcome.startedAt;
+  cmd.duration = duration;
+  if (outcome.exitCode !== void 0) {
+    cmd.exitCode = outcome.exitCode;
+  }
+  const captureOutput = options?.captureOutput ?? false;
+  const redactOutput = options?.redactOutput ?? true;
+  const maxOutputChars = options?.maxOutputChars ?? 2e3;
+  if (captureOutput) {
+    const out = outcome.stdout ?? "";
+    const err = outcome.stderr ?? "";
+    cmd.stdout = redactOutput ? redact(clampOutput(out, maxOutputChars)) : clampOutput(out, maxOutputChars);
+    cmd.stderr = redactOutput ? redact(clampOutput(err, maxOutputChars)) : clampOutput(err, maxOutputChars);
+  }
+  const completed = completeAuditEntry(entry, outcome.success, outcome.error);
+  await logSkillExecution(completed);
+}
+function runShellCommandSync(command, audit, options) {
+  const startedAt = Date.now();
+  const entry = createAuditEntry(audit.actor, audit.source ?? "trie", audit.triggeredBy, audit.targetPath);
+  const cmd = buildCommandRecord(command);
+  entry.commands?.push(cmd);
+  try {
+    const stdout = execSync(command, {
+      cwd: options?.cwd,
+      timeout: options?.timeoutMs,
+      maxBuffer: options?.maxBuffer,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    void finalizeAndWrite(entry, cmd, { success: true, exitCode: 0, stdout, stderr: "", startedAt }, options);
+    return { stdout: stdout ?? "", exitCode: 0 };
+  } catch (e) {
+    const err = e;
+    const stdout = typeof err.stdout === "string" ? err.stdout : "";
+    const stderr = typeof err.stderr === "string" ? err.stderr : "";
+    const exitCode = typeof err.status === "number" ? err.status : 1;
+    void finalizeAndWrite(
+      entry,
+      cmd,
+      { success: false, exitCode, stdout, stderr, error: err.message, startedAt },
+      { ...options, captureOutput: options?.captureOutput ?? true }
+    );
+    return { stdout, exitCode };
+  }
+}
+async function runExecFile(file, args, audit, options) {
+  const startedAt = Date.now();
+  const command = [file, ...args].join(" ");
+  const entry = createAuditEntry(audit.actor, audit.source ?? "trie", audit.triggeredBy, audit.targetPath);
+  const cmd = buildCommandRecord(command);
+  entry.commands?.push(cmd);
+  try {
+    const { stdout, stderr } = await execFileAsync(file, args, {
+      cwd: options?.cwd,
+      timeout: options?.timeoutMs,
+      maxBuffer: options?.maxBuffer
+    });
+    await finalizeAndWrite(entry, cmd, { success: true, exitCode: 0, stdout: String(stdout ?? ""), stderr: String(stderr ?? ""), startedAt }, options);
+    return { stdout: String(stdout ?? ""), stderr: String(stderr ?? ""), exitCode: 0 };
+  } catch (e) {
+    const err = e;
+    const stdout = typeof err.stdout === "string" ? err.stdout : "";
+    const stderr = typeof err.stderr === "string" ? err.stderr : "";
+    const exitCode = typeof err.code === "number" ? err.code : 1;
+    await finalizeAndWrite(
+      entry,
+      cmd,
+      { success: false, exitCode, stdout, stderr, error: err.message, startedAt },
+      { ...options, captureOutput: options?.captureOutput ?? true }
+    );
+    return { stdout, stderr, exitCode };
+  }
+}
+
+// src/agent/git.ts
 async function execGit(args, cwd) {
   try {
     const { stdout } = await runExecFile(
@@ -1265,7 +1719,7 @@ var Triager = class {
 // src/utils/parallel-executor.ts
 import { Worker } from "worker_threads";
 import { cpus } from "os";
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { fileURLToPath } from "url";
 var ParallelExecutor = class {
   maxWorkers;
@@ -1422,7 +1876,7 @@ var ParallelExecutor = class {
       return this.workerAvailable;
     }
     const workerUrl = this.getWorkerUrl();
-    this.workerAvailable = existsSync6(fileURLToPath(workerUrl));
+    this.workerAvailable = existsSync8(fileURLToPath(workerUrl));
     if (!this.workerAvailable && !this.warnedWorkerFallback && !isInteractiveMode()) {
       console.error("Worker threads unavailable; falling back to in-process agents.");
       this.warnedWorkerFallback = true;
@@ -1521,8 +1975,8 @@ function calculateOptimalConcurrency() {
 }
 
 // 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 { readFile as readFile6, writeFile as writeFile5, mkdir as mkdir6, stat } from "fs/promises";
+import { join as join7 } from "path";
 import { createHash as createHash2 } from "crypto";
 var CacheManager = class {
   cacheDir;
@@ -1532,8 +1986,8 @@ var CacheManager = class {
   // 24 hours
   MAX_ENTRIES = 1e3;
   constructor(baseDir) {
-    this.cacheDir = join5(getTrieDirectory(baseDir), "cache");
-    this.indexPath = join5(this.cacheDir, "index.json");
+    this.cacheDir = join7(getTrieDirectory(baseDir), "cache");
+    this.indexPath = join7(this.cacheDir, "index.json");
   }
   /**
    * Generate cache key for a file and agent combination
@@ -1547,7 +2001,7 @@ var CacheManager = class {
    */
   async getFileHash(filePath) {
     try {
-      const content = await readFile4(filePath, "utf-8");
+      const content = await readFile6(filePath, "utf-8");
       const stats = await stat(filePath);
       const hash = createHash2("sha256").update(content).digest("hex").slice(0, 16);
       return {
@@ -1564,7 +2018,7 @@ var CacheManager = class {
    */
   async loadIndex() {
     try {
-      const content = await readFile4(this.indexPath, "utf-8");
+      const content = await readFile6(this.indexPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return {
@@ -1579,8 +2033,8 @@ var CacheManager = class {
    */
   async saveIndex(index) {
     try {
-      await mkdir4(this.cacheDir, { recursive: true });
-      await writeFile4(this.indexPath, JSON.stringify(index, null, 2));
+      await mkdir6(this.cacheDir, { recursive: true });
+      await writeFile5(this.indexPath, JSON.stringify(index, null, 2));
     } catch (error) {
       if (!isInteractiveMode()) {
         console.warn("Failed to save cache index:", error);
@@ -1969,9 +2423,9 @@ async function reasonAboutChangesHumanReadable(projectPath, files, options = {})
 }
 
 // src/bootstrap/stack-detector.ts
-import { readFile as readFile5 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
-import { join as join6 } from "path";
+import { readFile as readFile7 } from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
+import { join as join8 } from "path";
 var SKILL_MAPPINGS = {
   // Frontend Frameworks - React/Next.js
   "next": [
@@ -2278,40 +2732,39 @@ async function detectStack(projectDir) {
     suggestedAgents: ["security", "bugs"],
     dependencies: /* @__PURE__ */ new Set()
   };
-  if (existsSync7(join6(projectDir, "tsconfig.json"))) {
+  if (existsSync9(join8(projectDir, "tsconfig.json"))) {
     stack.language = "TypeScript";
-    stack.suggestedAgents.push("typecheck");
     stack.suggestedSkills.push("wshobson/agents typescript-advanced-types");
-  } else if (existsSync7(join6(projectDir, "package.json"))) {
+  } else if (existsSync9(join8(projectDir, "package.json"))) {
     stack.language = "JavaScript";
-  } else if (existsSync7(join6(projectDir, "requirements.txt")) || existsSync7(join6(projectDir, "pyproject.toml"))) {
+  } else if (existsSync9(join8(projectDir, "requirements.txt")) || existsSync9(join8(projectDir, "pyproject.toml"))) {
     stack.language = "Python";
-  } else if (existsSync7(join6(projectDir, "go.mod"))) {
+  } else if (existsSync9(join8(projectDir, "go.mod"))) {
     stack.language = "Go";
-  } else if (existsSync7(join6(projectDir, "Cargo.toml"))) {
+  } else if (existsSync9(join8(projectDir, "Cargo.toml"))) {
     stack.language = "Rust";
   }
-  if (existsSync7(join6(projectDir, "Package.swift")) || existsSync7(join6(projectDir, "project.pbxproj")) || existsSync7(join6(projectDir, "*.xcodeproj"))) {
+  if (existsSync9(join8(projectDir, "Package.swift")) || existsSync9(join8(projectDir, "project.pbxproj")) || existsSync9(join8(projectDir, "*.xcodeproj"))) {
     stack.language = "Swift";
     stack.suggestedSkills.push("dimillian/skills swiftui-ui-patterns");
     stack.suggestedSkills.push("dimillian/skills swiftui-liquid-glass");
   }
-  if (existsSync7(join6(projectDir, "pnpm-lock.yaml"))) {
+  if (existsSync9(join8(projectDir, "pnpm-lock.yaml"))) {
     stack.packageManager = "pnpm";
-  } else if (existsSync7(join6(projectDir, "yarn.lock"))) {
+  } else if (existsSync9(join8(projectDir, "yarn.lock"))) {
     stack.packageManager = "yarn";
-  } else if (existsSync7(join6(projectDir, "bun.lockb"))) {
+  } else if (existsSync9(join8(projectDir, "bun.lockb"))) {
     stack.packageManager = "bun";
-  } else if (existsSync7(join6(projectDir, "package-lock.json"))) {
+  } else if (existsSync9(join8(projectDir, "package-lock.json"))) {
     stack.packageManager = "npm";
   }
-  if (existsSync7(join6(projectDir, ".github", "workflows"))) {
+  if (existsSync9(join8(projectDir, ".github", "workflows"))) {
     stack.suggestedSkills.push("wshobson/agents github-actions-templates");
   }
   try {
-    const pkgPath = join6(projectDir, "package.json");
-    if (existsSync7(pkgPath)) {
-      const pkgContent = await readFile5(pkgPath, "utf-8");
+    const pkgPath = join8(projectDir, "package.json");
+    if (existsSync9(pkgPath)) {
+      const pkgContent = await readFile7(pkgPath, "utf-8");
       const pkg = JSON.parse(pkgContent);
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       for (const dep of Object.keys(deps)) {
@@ -2368,16 +2821,13 @@ async function detectStack(projectDir) {
       } else if (deps["convex"]) {
         stack.database = "Convex";
       }
-      if (deps["stripe"] || deps["@stripe/stripe-js"]) {
-        stack.suggestedAgents.push("moneybags");
-      }
     }
   } catch {
   }
   if (!stack.database) {
-    if (existsSync7(join6(projectDir, "prisma", "schema.prisma"))) {
+    if (existsSync9(join8(projectDir, "prisma", "schema.prisma"))) {
       stack.database = "Prisma ORM";
-    } else if (existsSync7(join6(projectDir, "drizzle.config.ts"))) {
+    } else if (existsSync9(join8(projectDir, "drizzle.config.ts"))) {
       stack.database = "Drizzle ORM";
     }
   }
@@ -2393,9 +2843,9 @@ function getSkillCategories() {
 }
 
 // src/bootstrap/files.ts
-import { readFile as readFile6, writeFile as writeFile5, unlink, mkdir as mkdir5 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
-import { join as join7 } from "path";
+import { readFile as readFile8, writeFile as writeFile6, unlink, mkdir as mkdir7 } from "fs/promises";
+import { existsSync as existsSync10 } from "fs";
+import { join as join9 } from "path";
 var BOOTSTRAP_FILES = [
   { name: "PROJECT.md", type: "user", description: "Project overview and conventions" },
   { name: "RULES.md", type: "user", description: "Coding standards agents enforce" },
@@ -2410,15 +2860,15 @@ async function loadBootstrapContext(workDir) {
   const contentParts = [];
   let needsBootstrap2 = false;
   for (const file of BOOTSTRAP_FILES) {
-    const filePath = join7(trieDir, file.name);
-    const exists = existsSync8(filePath);
+    const filePath = join9(trieDir, file.name);
+    const exists = existsSync10(filePath);
     if (file.name === "BOOTSTRAP.md" && exists) {
       needsBootstrap2 = true;
     }
     let content;
     if (exists) {
       try {
-        content = await readFile6(filePath, "utf-8");
+        content = await readFile8(filePath, "utf-8");
         if (content.trim() && file.type !== "one-time") {
           contentParts.push(`<!-- ${file.name} -->
 ${content}`);
@@ -2444,13 +2894,13 @@ ${content}`);
 async function initializeBootstrapFiles(options = {}) {
   const projectDir = options.workDir || getWorkingDirectory(void 0, true);
   const trieDir = getTrieDirectory(projectDir);
-  await mkdir5(trieDir, { recursive: true });
+  await mkdir7(trieDir, { recursive: true });
   const created = [];
   const skipped = [];
   const stack = await detectStack(projectDir);
   for (const file of BOOTSTRAP_FILES) {
-    const filePath = join7(trieDir, file.name);
-    const exists = existsSync8(filePath);
+    const filePath = join9(trieDir, file.name);
+    const exists = existsSync10(filePath);
     if (exists && !options.force) {
       skipped.push(file.name);
       continue;
@@ -2465,7 +2915,7 @@ async function initializeBootstrapFiles(options = {}) {
     }
     const template = getFileTemplate(file.name, stack);
     if (template) {
-      await writeFile5(filePath, template);
+      await writeFile6(filePath, template);
       created.push(file.name);
     }
   }
@@ -2473,7 +2923,7 @@ async function initializeBootstrapFiles(options = {}) {
 }
 async function completeBootstrap(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const bootstrapPath = join7(getTrieDirectory(projectDir), "BOOTSTRAP.md");
+  const bootstrapPath = join9(getTrieDirectory(projectDir), "BOOTSTRAP.md");
   try {
     await unlink(bootstrapPath);
     return true;
@@ -2483,15 +2933,15 @@ async function completeBootstrap(workDir) {
 }
 function needsBootstrap(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const bootstrapPath = join7(getTrieDirectory(projectDir), "BOOTSTRAP.md");
-  return existsSync8(bootstrapPath);
+  const bootstrapPath = join9(getTrieDirectory(projectDir), "BOOTSTRAP.md");
+  return existsSync10(bootstrapPath);
 }
 async function loadRules(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const rulesPath = join7(getTrieDirectory(projectDir), "RULES.md");
+  const rulesPath = join9(getTrieDirectory(projectDir), "RULES.md");
   try {
-    if (existsSync8(rulesPath)) {
-      return await readFile6(rulesPath, "utf-8");
+    if (existsSync10(rulesPath)) {
+      return await readFile8(rulesPath, "utf-8");
     }
   } catch {
   }
@@ -2499,10 +2949,10 @@ async function loadRules(workDir) {
 }
 async function loadTeamInfo(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const teamPath = join7(getTrieDirectory(projectDir), "TEAM.md");
+  const teamPath = join9(getTrieDirectory(projectDir), "TEAM.md");
   try {
-    if (existsSync8(teamPath)) {
-      return await readFile6(teamPath, "utf-8");
+    if (existsSync10(teamPath)) {
+      return await readFile8(teamPath, "utf-8");
     }
   } catch {
   }
@@ -2511,7 +2961,7 @@ async function loadTeamInfo(workDir) {
 function getFileTemplate(fileName, stack) {
   switch (fileName) {
     case "PROJECT.md":
-      return getProjectTemplate(stack);
+      return getProjectTemplate2(stack);
     case "RULES.md":
       return getRulesTemplate(stack);
     case "TEAM.md":
@@ -2522,7 +2972,7 @@ function getFileTemplate(fileName, stack) {
       return null;
   }
 }
-function getProjectTemplate(stack) {
+function getProjectTemplate2(stack) {
   const lines = ["# Project Overview", "", "> Define your project context here. AI assistants read this first.", ""];
   lines.push("## Description", "", "[Describe what this project does and who it's for]", "");
   lines.push("## Technology Stack", "");
@@ -3239,10 +3689,23 @@ export {
   shouldAutoFix,
   shouldBlockPush,
   getAutonomyConfig,
+  formatAuditLog,
+  getAuditStatistics,
+  getRecentAuditLogs,
+  getSkillAuditLogs,
+  runShellCommandSync,
   getStagedChanges,
   getUncommittedChanges,
   perceiveCurrentChanges,
   reasonAboutChangesHumanReadable,
+  projectInfoExists,
+  loadProjectInfo,
+  initProjectInfo,
+  getProjectSection,
+  updateProjectSection,
+  appendToSection,
+  getProjectSections,
+  getProjectInfoStructured,
   getSkillCategories,
   loadBootstrapContext,
   initializeBootstrapFiles,
@@ -3259,6 +3722,8 @@ export {
   importFromJson,
   IncidentIndex,
   LearningEngine,
-  LinearIngester
+  LinearIngester,
+  loadContextState,
+  getContextForAI
 };
-//# sourceMappingURL=chunk-M4JCQO5G.js.map
+//# sourceMappingURL=chunk-CKYU5JOD.js.map