@triedotdev/mcp 1.0.43 → 1.0.45

package/dist/chunk-PZDQIFKO.js

@@ -0,0 +1,1598 @@
+import {
+  getWorkingDirectory
+} from "./chunk-IMFD4SJC.js";
+
+// src/utils/project-info.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+var PROJECT_MD_PATH = ".trie/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(dir, PROJECT_MD_PATH);
+  return existsSync(projectPath);
+}
+async function loadProjectInfo(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const projectPath = join(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 = join(dir, ".trie");
+  const projectPath = join(dir, 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(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) {
+    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) {
+    sections.push(match[1].trim());
+  }
+  return sections;
+}
+async function getProjectInfoStructured(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const projectPath = join(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/skills/installer.ts
+import { mkdir as mkdir2, rm, writeFile as writeFile2, readdir, readFile as readFile3, access, cp } from "fs/promises";
+import { join as join3 } from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+// src/skills/parser.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+async function parseSkillMd(skillPath) {
+  const skillMdPath = join2(skillPath, "SKILL.md");
+  const rawContent = await readFile2(skillMdPath, "utf-8");
+  const frontmatterMatch = rawContent.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch || !frontmatterMatch[1]) {
+    throw new Error("Invalid SKILL.md: missing YAML frontmatter");
+  }
+  const frontmatter = parseYamlFrontmatter(frontmatterMatch[1]);
+  if (!frontmatter.name || !frontmatter.description) {
+    throw new Error("Invalid SKILL.md: missing required name or description in frontmatter");
+  }
+  const content = rawContent.slice(frontmatterMatch[0].length).trim();
+  return {
+    frontmatter,
+    content,
+    rawContent
+  };
+}
+function parseYamlFrontmatter(yaml) {
+  const result = {};
+  const lines = yaml.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = trimmed.slice(0, colonIndex).trim();
+    let value = trimmed.slice(colonIndex + 1).trim();
+    if (value === "") continue;
+    if (typeof value === "string") {
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      if (typeof value === "string" && value.startsWith("[") && value.endsWith("]")) {
+        value = value.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, ""));
+      }
+    }
+    result[key] = value;
+  }
+  return result;
+}
+
+// src/skills/installer.ts
+var execAsync = promisify(exec);
+async function installSkill(source, skillName) {
+  const parts = source.split("/");
+  if (parts.length < 2) {
+    return { success: false, name: "unknown", error: "Invalid source format. Use owner/repo or owner/repo/skill-name" };
+  }
+  const owner = parts[0];
+  const repo = parts[1];
+  const specifiedSkill = skillName || parts[2];
+  const skillsDir = join3(getWorkingDirectory(void 0, true), ".trie", "skills");
+  const tempDir = join3(skillsDir, `.temp-${Date.now()}`);
+  try {
+    await mkdir2(skillsDir, { recursive: true });
+    const repoUrl = `https://github.com/${owner}/${repo}.git`;
+    await execAsync(`git clone --depth 1 "${repoUrl}" "${tempDir}"`, { timeout: 6e4 });
+    const sourcePath = await findSkillPath(tempDir, specifiedSkill);
+    if (!sourcePath) {
+      throw new Error(`SKILL.md not found in repository. Searched in: root, skills/, ${specifiedSkill || "subdirectories"}`);
+    }
+    const parsed = await parseSkillMd(sourcePath);
+    const name = parsed.frontmatter.name;
+    const targetPath = join3(skillsDir, name);
+    await rm(targetPath, { recursive: true, force: true });
+    await cp(sourcePath, targetPath, { recursive: true });
+    await writeFile2(join3(targetPath, ".installed.json"), JSON.stringify({
+      installedFrom: source,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      repository: `${owner}/${repo}`
+    }, null, 2));
+    return { success: true, name, path: targetPath };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, name: skillName || "unknown", error: message };
+  } finally {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function findSkillPath(repoPath, skillName) {
+  const searchPaths = [];
+  if (skillName) {
+    searchPaths.push(
+      join3(repoPath, "skills", skillName),
+      join3(repoPath, skillName)
+    );
+  }
+  searchPaths.push(
+    repoPath,
+    join3(repoPath, "skill")
+  );
+  if (!skillName) {
+    try {
+      const skillsSubdir = join3(repoPath, "skills");
+      await access(skillsSubdir);
+      const entries = await readdir(skillsSubdir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && !entry.name.startsWith(".")) {
+          searchPaths.push(join3(skillsSubdir, entry.name));
+        }
+      }
+    } catch {
+    }
+  }
+  for (const searchPath of searchPaths) {
+    try {
+      await parseSkillMd(searchPath);
+      return searchPath;
+    } catch {
+    }
+  }
+  return null;
+}
+async function listInstalledSkills() {
+  const skillsDir = join3(getWorkingDirectory(void 0, true), ".trie", "skills");
+  const skills = [];
+  try {
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const skillPath = join3(skillsDir, entry.name);
+      try {
+        const parsed = await parseSkillMd(skillPath);
+        const metaPath = join3(skillPath, ".installed.json");
+        let meta = { installedFrom: "unknown", installedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        try {
+          meta = JSON.parse(await readFile3(metaPath, "utf-8"));
+        } catch {
+        }
+        skills.push({
+          name: parsed.frontmatter.name,
+          description: parsed.frontmatter.description,
+          path: skillPath,
+          installedFrom: meta.installedFrom,
+          installedAt: meta.installedAt
+        });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return skills;
+}
+async function removeSkill(skillName) {
+  const skillsDir = join3(getWorkingDirectory(void 0, true), ".trie", "skills");
+  const skillPath = join3(skillsDir, skillName);
+  try {
+    await rm(skillPath, { recursive: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/memory/issue-store.ts
+import { mkdir as mkdir4, writeFile as writeFile4, readFile as readFile5, readdir as readdir2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
+
+// src/memory/bm25.ts
+var BM25Index = class _BM25Index {
+  documents = /* @__PURE__ */ new Map();
+  termFrequencies = /* @__PURE__ */ new Map();
+  documentFrequencies = /* @__PURE__ */ new Map();
+  documentLengths = /* @__PURE__ */ new Map();
+  avgDocLength = 0;
+  k1 = 1.5;
+  b = 0.75;
+  /**
+   * Add a document to the index
+   */
+  addDocument(doc) {
+    const tokens = this.tokenize(doc.text);
+    this.documents.set(doc.id, doc);
+    this.documentLengths.set(doc.id, tokens.length);
+    const termFreq = /* @__PURE__ */ new Map();
+    const seenTerms = /* @__PURE__ */ new Set();
+    for (const token of tokens) {
+      termFreq.set(token, (termFreq.get(token) || 0) + 1);
+      if (!seenTerms.has(token)) {
+        seenTerms.add(token);
+        this.documentFrequencies.set(token, (this.documentFrequencies.get(token) || 0) + 1);
+      }
+    }
+    this.termFrequencies.set(doc.id, termFreq);
+    this.updateAvgDocLength();
+  }
+  /**
+   * Add multiple documents
+   */
+  addDocuments(docs) {
+    for (const doc of docs) {
+      this.addDocument(doc);
+    }
+  }
+  /**
+   * Search the index
+   */
+  search(query, limit = 10) {
+    const queryTokens = this.tokenize(query);
+    const scores = /* @__PURE__ */ new Map();
+    const N = this.documents.size;
+    for (const [docId] of this.documents) {
+      let score = 0;
+      const docLength = this.documentLengths.get(docId) || 0;
+      const termFreqs = this.termFrequencies.get(docId);
+      if (!termFreqs) continue;
+      for (const term of queryTokens) {
+        const tf = termFreqs.get(term) || 0;
+        if (tf === 0) continue;
+        const df = this.documentFrequencies.get(term) || 0;
+        const idf = Math.log((N - df + 0.5) / (df + 0.5) + 1);
+        const numerator = tf * (this.k1 + 1);
+        const denominator = tf + this.k1 * (1 - this.b + this.b * (docLength / this.avgDocLength));
+        score += idf * (numerator / denominator);
+      }
+      if (score > 0) {
+        scores.set(docId, score);
+      }
+    }
+    return Array.from(scores.entries()).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([id, score]) => ({
+      id,
+      score,
+      metadata: this.documents.get(id)?.metadata
+    }));
+  }
+  /**
+   * Get document count
+   */
+  get size() {
+    return this.documents.size;
+  }
+  /**
+   * Clear the index
+   */
+  clear() {
+    this.documents.clear();
+    this.termFrequencies.clear();
+    this.documentFrequencies.clear();
+    this.documentLengths.clear();
+    this.avgDocLength = 0;
+  }
+  /**
+   * Serialize the index to JSON
+   */
+  serialize() {
+    return JSON.stringify({
+      documents: Array.from(this.documents.entries()),
+      termFrequencies: Array.from(this.termFrequencies.entries()).map(([k, v]) => [k, Array.from(v.entries())]),
+      documentFrequencies: Array.from(this.documentFrequencies.entries()),
+      documentLengths: Array.from(this.documentLengths.entries()),
+      avgDocLength: this.avgDocLength
+    });
+  }
+  /**
+   * Load from serialized JSON
+   */
+  static deserialize(json) {
+    const data = JSON.parse(json);
+    const index = new _BM25Index();
+    index.documents = new Map(data.documents);
+    index.termFrequencies = new Map(data.termFrequencies.map(([k, v]) => [k, new Map(v)]));
+    index.documentFrequencies = new Map(data.documentFrequencies);
+    index.documentLengths = new Map(data.documentLengths);
+    index.avgDocLength = data.avgDocLength;
+    return index;
+  }
+  tokenize(text) {
+    return text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((token) => token.length > 2 && !this.isStopWord(token));
+  }
+  isStopWord(word) {
+    const stopWords = /* @__PURE__ */ new Set([
+      "the",
+      "be",
+      "to",
+      "of",
+      "and",
+      "a",
+      "in",
+      "that",
+      "have",
+      "i",
+      "it",
+      "for",
+      "not",
+      "on",
+      "with",
+      "he",
+      "as",
+      "you",
+      "do",
+      "at",
+      "this",
+      "but",
+      "his",
+      "by",
+      "from",
+      "they",
+      "we",
+      "say",
+      "her",
+      "she",
+      "or",
+      "an",
+      "will",
+      "my",
+      "one",
+      "all",
+      "would",
+      "there",
+      "their",
+      "what",
+      "so",
+      "up",
+      "out",
+      "if",
+      "about",
+      "who",
+      "get",
+      "which",
+      "go",
+      "me",
+      "when",
+      "make",
+      "can",
+      "like",
+      "time",
+      "no",
+      "just",
+      "him",
+      "know",
+      "take",
+      "into",
+      "year",
+      "your",
+      "some",
+      "could",
+      "them",
+      "see",
+      "other",
+      "than",
+      "then",
+      "now",
+      "look",
+      "only",
+      "come",
+      "its",
+      "over",
+      "also",
+      "back",
+      "after",
+      "use",
+      "two",
+      "how",
+      "our",
+      "first",
+      "way",
+      "even",
+      "new",
+      "want",
+      "because",
+      "any",
+      "these",
+      "give",
+      "day",
+      "most",
+      "us",
+      "should",
+      "been",
+      "has",
+      "was",
+      "are"
+    ]);
+    return stopWords.has(word);
+  }
+  updateAvgDocLength() {
+    if (this.documentLengths.size === 0) {
+      this.avgDocLength = 0;
+      return;
+    }
+    const total = Array.from(this.documentLengths.values()).reduce((a, b) => a + b, 0);
+    this.avgDocLength = total / this.documentLengths.size;
+  }
+};
+
+// src/memory/compactor.ts
+import { mkdir as mkdir3, writeFile as writeFile3, readFile as readFile4 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join4 } from "path";
+async function compactOldIssues(issues, options = {}) {
+  const keepDays = options.keepDays ?? 30;
+  const minIssues = options.minIssuesToCompact ?? 100;
+  const cutoffDate = /* @__PURE__ */ new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - keepDays);
+  const oldIssues = issues.filter((i) => new Date(i.timestamp) < cutoffDate);
+  const recentIssues = issues.filter((i) => new Date(i.timestamp) >= cutoffDate);
+  if (oldIssues.length < minIssues) {
+    return { summary: null, remaining: issues };
+  }
+  const summary = buildSummary(oldIssues);
+  return { summary, remaining: recentIssues };
+}
+function buildSummary(issues) {
+  const sorted = issues.sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+  const bySeverity = {};
+  const byAgent = {};
+  const patternMap = /* @__PURE__ */ new Map();
+  const fileCount = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    bySeverity[issue.severity] = (bySeverity[issue.severity] || 0) + 1;
+    byAgent[issue.agent] = (byAgent[issue.agent] || 0) + 1;
+    const patternKey = normalizePattern(issue.issue);
+    const existing = patternMap.get(patternKey);
+    if (existing) {
+      existing.count++;
+    } else {
+      patternMap.set(patternKey, { count: 1, issue });
+    }
+    const fileName = issue.file.split("/").pop() || issue.file;
+    fileCount.set(fileName, (fileCount.get(fileName) || 0) + 1);
+  }
+  const topPatterns = Array.from(patternMap.entries()).sort((a, b) => b[1].count - a[1].count).slice(0, 10).map(([pattern, data]) => ({
+    pattern: pattern.slice(0, 100),
+    count: data.count,
+    severity: data.issue.severity,
+    agent: data.issue.agent,
+    exampleFix: data.issue.fix.slice(0, 200)
+  }));
+  const hotFiles = Array.from(fileCount.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([file, count]) => ({ file, count }));
+  return {
+    period: `${sorted[0]?.timestamp.split("T")[0]} to ${sorted[sorted.length - 1]?.timestamp.split("T")[0]}`,
+    startDate: sorted[0]?.timestamp || "",
+    endDate: sorted[sorted.length - 1]?.timestamp || "",
+    totalIssues: issues.length,
+    resolvedCount: issues.filter((i) => i.resolved).length,
+    bySeverity,
+    byAgent,
+    topPatterns,
+    hotFiles,
+    compactedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizePattern(text) {
+  return text.toLowerCase().replace(/`[^`]+`/g, "CODE").replace(/\b\d+\b/g, "N").replace(/["']/g, "").replace(/\s+/g, " ").trim().slice(0, 150);
+}
+async function saveCompactedSummary(summary, projectDir) {
+  const memoryDir = join4(projectDir, ".trie", "memory");
+  await mkdir3(memoryDir, { recursive: true });
+  const summaryPath = join4(memoryDir, "compacted-summaries.json");
+  let summaries = [];
+  try {
+    if (existsSync2(summaryPath)) {
+      summaries = JSON.parse(await readFile4(summaryPath, "utf-8"));
+    }
+  } catch {
+    summaries = [];
+  }
+  summaries.push(summary);
+  if (summaries.length > 12) {
+    summaries = summaries.slice(-12);
+  }
+  await writeFile3(summaryPath, JSON.stringify(summaries, null, 2));
+}
+async function loadCompactedSummaries(projectDir) {
+  const summaryPath = join4(projectDir, ".trie", "memory", "compacted-summaries.json");
+  try {
+    if (existsSync2(summaryPath)) {
+      return JSON.parse(await readFile4(summaryPath, "utf-8"));
+    }
+  } catch {
+  }
+  return [];
+}
+async function getHistoricalInsights(projectDir) {
+  const summaries = await loadCompactedSummaries(projectDir);
+  if (summaries.length === 0) {
+    return {
+      totalHistoricalIssues: 0,
+      recurringPatterns: [],
+      improvementTrend: "unknown"
+    };
+  }
+  const totalHistoricalIssues = summaries.reduce((sum, s) => sum + s.totalIssues, 0);
+  const patternCounts = /* @__PURE__ */ new Map();
+  for (const summary of summaries) {
+    for (const pattern of summary.topPatterns) {
+      const key = pattern.pattern;
+      const existing = patternCounts.get(key);
+      if (existing) {
+        existing.count += pattern.count;
+        existing.appearances++;
+      } else {
+        patternCounts.set(key, { ...pattern, appearances: 1 });
+      }
+    }
+  }
+  const recurringPatterns = Array.from(patternCounts.values()).filter((p) => p.appearances >= 2).sort((a, b) => b.count - a.count).slice(0, 5);
+  let improvementTrend = "unknown";
+  if (summaries.length >= 2) {
+    const recent = summaries.slice(-2);
+    const olderCount = recent[0]?.totalIssues || 0;
+    const newerCount = recent[1]?.totalIssues || 0;
+    if (newerCount < olderCount * 0.8) {
+      improvementTrend = "improving";
+    } else if (newerCount > olderCount * 1.2) {
+      improvementTrend = "declining";
+    } else {
+      improvementTrend = "stable";
+    }
+  }
+  return {
+    totalHistoricalIssues,
+    recurringPatterns,
+    improvementTrend
+  };
+}
+
+// src/memory/issue-store.ts
+async function storeIssues(issues, project, workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const memoryDir = join5(projectDir, ".trie", "memory");
+  await mkdir4(memoryDir, { recursive: true });
+  const stored = [];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const issue of issues) {
+    const hash = hashIssue(issue);
+    stored.push({
+      id: issue.id,
+      hash,
+      severity: issue.severity,
+      issue: issue.issue,
+      fix: issue.fix,
+      file: issue.file,
+      line: issue.line,
+      agent: issue.agent,
+      category: issue.category,
+      timestamp: now,
+      project,
+      resolved: false
+    });
+  }
+  await appendToDailyLog(stored, projectDir);
+  await updateIssueIndex(stored, projectDir);
+  return stored.length;
+}
+async function searchIssues(query, options = {}) {
+  const projectDir = options.workDir || getWorkingDirectory(void 0, true);
+  const limit = options.limit || 10;
+  const allIssues = await loadIssueIndex(projectDir);
+  if (allIssues.length === 0) {
+    return [];
+  }
+  const filteredIssues = allIssues.filter((issue) => {
+    if (options.project && issue.project !== options.project) return false;
+    if (options.severity && !options.severity.includes(issue.severity)) return false;
+    if (options.agent && issue.agent !== options.agent) return false;
+    if (!options.includeResolved && issue.resolved) return false;
+    return true;
+  });
+  if (filteredIssues.length === 0) {
+    return [];
+  }
+  const bm25 = new BM25Index();
+  const issueMap = /* @__PURE__ */ new Map();
+  for (const issue of filteredIssues) {
+    const searchText = `${issue.issue} ${issue.fix} ${issue.file} ${issue.agent} ${issue.category || ""} ${issue.severity}`;
+    bm25.addDocument({
+      id: issue.id,
+      text: searchText
+    });
+    issueMap.set(issue.id, issue);
+  }
+  const bm25Results = bm25.search(query, limit);
+  return bm25Results.map((result) => ({
+    issue: issueMap.get(result.id),
+    score: result.score,
+    matchType: "bm25"
+  }));
+}
+async function findSimilarIssues(issue, options = {}) {
+  const query = `${issue.issue} ${issue.fix} ${issue.agent}`;
+  const results = await searchIssues(query, {
+    workDir: options.workDir,
+    limit: (options.limit || 5) + 5,
+    // Get extra to account for filtering
+    includeResolved: true
+  });
+  let filtered = results.filter((r) => r.issue.id !== issue.id);
+  if (options.excludeSameFile) {
+    filtered = filtered.filter((r) => r.issue.file !== issue.file);
+  }
+  return filtered.slice(0, options.limit || 5);
+}
+async function markIssueResolved(issueId, workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const index = await loadIssueIndex(projectDir);
+  const issue = index.find((i) => i.id === issueId);
+  if (!issue) return false;
+  issue.resolved = true;
+  issue.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveIssueIndex(index, projectDir);
+  return true;
+}
+async function getMemoryStats(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const index = await loadIssueIndex(projectDir);
+  const historical = await getHistoricalInsights(projectDir);
+  const stats = {
+    totalIssues: index.length,
+    issuesByAgent: {},
+    issuesBySeverity: {},
+    resolvedCount: 0,
+    historicalIssues: historical.totalHistoricalIssues,
+    improvementTrend: historical.improvementTrend
+  };
+  for (const issue of index) {
+    stats.issuesByAgent[issue.agent] = (stats.issuesByAgent[issue.agent] || 0) + 1;
+    stats.issuesBySeverity[issue.severity] = (stats.issuesBySeverity[issue.severity] || 0) + 1;
+    if (issue.resolved) stats.resolvedCount++;
+  }
+  if (index.length > 0) {
+    const sorted = [...index].sort(
+      (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+    );
+    stats.oldestIssue = sorted[0]?.timestamp;
+    stats.newestIssue = sorted[sorted.length - 1]?.timestamp;
+  }
+  return stats;
+}
+async function getRecentIssues(options = {}) {
+  const projectDir = options.workDir || getWorkingDirectory(void 0, true);
+  const index = await loadIssueIndex(projectDir);
+  const limit = options.limit || 20;
+  const daysBack = options.daysBack || 7;
+  const cutoff = /* @__PURE__ */ new Date();
+  cutoff.setDate(cutoff.getDate() - daysBack);
+  return index.filter((i) => new Date(i.timestamp) >= cutoff).sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()).slice(0, limit);
+}
+async function getDailyLogs(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const memoryDir = join5(projectDir, ".trie", "memory");
+  try {
+    if (!existsSync3(memoryDir)) return [];
+    const files = await readdir2(memoryDir);
+    return files.filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort().reverse();
+  } catch {
+    return [];
+  }
+}
+async function appendToDailyLog(issues, projectDir) {
+  const memoryDir = join5(projectDir, ".trie", "memory");
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const logPath = join5(memoryDir, `${today}.md`);
+  let content = "";
+  try {
+    if (existsSync3(logPath)) {
+      content = await readFile5(logPath, "utf-8");
+    } else {
+      content = `# Issue Log: ${today}
+
+`;
+    }
+  } catch {
+    content = `# Issue Log: ${today}
+
+`;
+  }
+  const time = (/* @__PURE__ */ new Date()).toTimeString().split(" ")[0];
+  const newEntries = issues.map(
+    (i) => `## [${time}] ${i.severity.toUpperCase()}: ${i.issue.slice(0, 80)}${i.issue.length > 80 ? "..." : ""}
+- **File:** \`${i.file}\`${i.line ? `:${i.line}` : ""}
+- **Agent:** ${i.agent}
+- **Fix:** ${i.fix.slice(0, 200)}${i.fix.length > 200 ? "..." : ""}
+`
+  ).join("\n");
+  content += newEntries + "\n";
+  await writeFile4(logPath, content);
+}
+async function loadIssueIndex(projectDir) {
+  const indexPath = join5(projectDir, ".trie", "memory", "issues.json");
+  try {
+    if (existsSync3(indexPath)) {
+      const content = await readFile5(indexPath, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return [];
+}
+async function updateIssueIndex(newIssues, projectDir) {
+  const memoryDir = join5(projectDir, ".trie", "memory");
+  const indexPath = join5(memoryDir, "issues.json");
+  await mkdir4(memoryDir, { recursive: true });
+  let existing = await loadIssueIndex(projectDir);
+  const hashSet = new Set(existing.map((i) => i.hash));
+  const toAdd = newIssues.filter((i) => !hashSet.has(i.hash));
+  existing = [...existing, ...toAdd];
+  if (existing.length > 500) {
+    const { summary, remaining } = await compactOldIssues(existing, {
+      keepDays: 30,
+      minIssuesToCompact: 100
+    });
+    if (summary) {
+      await saveCompactedSummary(summary, projectDir);
+      existing = remaining;
+    }
+  }
+  if (existing.length > 1e3) {
+    existing = existing.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()).slice(0, 1e3);
+  }
+  await saveIssueIndex(existing, projectDir);
+}
+async function saveIssueIndex(issues, projectDir) {
+  const indexPath = join5(projectDir, ".trie", "memory", "issues.json");
+  await writeFile4(indexPath, JSON.stringify(issues, null, 2));
+}
+function hashIssue(issue) {
+  const content = `${issue.issue}|${issue.file}|${issue.severity}|${issue.agent}`;
+  let hash = 0;
+  for (let i = 0; i < content.length; i++) {
+    const char = content.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+
+// src/memory/global-memory.ts
+import { mkdir as mkdir5, writeFile as writeFile5, readFile as readFile6, readdir as readdir3 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join6 } from "path";
+import { homedir } from "os";
+var GLOBAL_TRIE_DIR = join6(homedir(), ".trie");
+var GLOBAL_MEMORY_DIR = join6(GLOBAL_TRIE_DIR, "memory");
+async function recordToGlobalMemory(issues, projectName, projectPath, healthScore = 0) {
+  await mkdir5(GLOBAL_MEMORY_DIR, { recursive: true });
+  await mkdir5(join6(GLOBAL_MEMORY_DIR, "projects"), { recursive: true });
+  const patterns = await loadGlobalPatterns();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const issue of issues) {
+    const patternId = extractPatternId(issue);
+    const existing = patterns.find((p) => p.id === patternId);
+    if (existing) {
+      existing.occurrences++;
+      existing.lastSeen = now;
+      if (!existing.projects.includes(projectName)) {
+        existing.projects.push(projectName);
+      }
+    } else {
+      patterns.push({
+        id: patternId,
+        pattern: issue.issue.slice(0, 200),
+        description: issue.fix.slice(0, 200),
+        severity: issue.severity,
+        agent: issue.agent,
+        occurrences: 1,
+        projects: [projectName],
+        firstSeen: now,
+        lastSeen: now
+      });
+    }
+  }
+  await saveGlobalPatterns(patterns);
+  const summaryPath = join6(GLOBAL_MEMORY_DIR, "projects", `${sanitizeName(projectName)}.json`);
+  const summary = {
+    name: projectName,
+    path: projectPath,
+    lastScan: now,
+    healthScore,
+    totalIssues: issues.length,
+    patterns: [...new Set(issues.map((i) => extractPatternId(i)))]
+  };
+  await writeFile5(summaryPath, JSON.stringify(summary, null, 2));
+}
+async function findCrossProjectPatterns(minOccurrences = 2) {
+  const patterns = await loadGlobalPatterns();
+  return patterns.filter((p) => p.projects.length >= minOccurrences).sort((a, b) => b.occurrences - a.occurrences);
+}
+async function listTrackedProjects() {
+  const projectsDir = join6(GLOBAL_MEMORY_DIR, "projects");
+  try {
+    if (!existsSync4(projectsDir)) return [];
+    const files = await readdir3(projectsDir);
+    const summaries = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const content = await readFile6(join6(projectsDir, file), "utf-8");
+        summaries.push(JSON.parse(content));
+      } catch {
+      }
+    }
+    return summaries.sort(
+      (a, b) => new Date(b.lastScan).getTime() - new Date(a.lastScan).getTime()
+    );
+  } catch {
+    return [];
+  }
+}
+async function getGlobalMemoryStats() {
+  const patterns = await loadGlobalPatterns();
+  const projects = await listTrackedProjects();
+  const patternsByAgent = {};
+  for (const pattern of patterns) {
+    patternsByAgent[pattern.agent] = (patternsByAgent[pattern.agent] || 0) + 1;
+  }
+  return {
+    totalPatterns: patterns.length,
+    crossProjectPatterns: patterns.filter((p) => p.projects.length >= 2).length,
+    trackedProjects: projects.length,
+    totalOccurrences: patterns.reduce((sum, p) => sum + p.occurrences, 0),
+    fixedPatterns: patterns.filter((p) => p.fixApplied).length,
+    patternsByAgent
+  };
+}
+async function updateGlobalMemoryMd() {
+  const patterns = await loadGlobalPatterns();
+  const crossProject = patterns.filter((p) => p.projects.length >= 2);
+  const projects = await listTrackedProjects();
+  const lines = [
+    "# Global Trie Memory",
+    "",
+    "> Auto-generated file tracking patterns across all your projects.",
+    `> Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "## Summary",
+    "",
+    `- **Projects tracked:** ${projects.length}`,
+    `- **Total patterns:** ${patterns.length}`,
+    `- **Cross-project patterns:** ${crossProject.length}`,
+    "",
+    "## Cross-Project Patterns",
+    "",
+    "These issues appear in multiple projects:",
+    ""
+  ];
+  for (const p of crossProject.slice(0, 20)) {
+    lines.push(
+      `### ${p.pattern.slice(0, 60)}${p.pattern.length > 60 ? "..." : ""}`,
+      "",
+      `- **Severity:** ${p.severity}`,
+      `- **Agent:** ${p.agent}`,
+      `- **Occurrences:** ${p.occurrences} across ${p.projects.length} projects`,
+      `- **Projects:** ${p.projects.slice(0, 5).join(", ")}${p.projects.length > 5 ? "..." : ""}`
+    );
+    if (p.fixApplied) {
+      lines.push(`- **Fixed in:** ${p.fixApplied.project} on ${p.fixApplied.timestamp.split("T")[0]}`);
+    } else {
+      lines.push("- **Status:** Not fixed");
+    }
+    lines.push("");
+  }
+  lines.push(
+    "## Tracked Projects",
+    "",
+    "| Project | Last Scan | Health | Issues |",
+    "|---------|-----------|--------|--------|"
+  );
+  for (const p of projects.slice(0, 20)) {
+    lines.push(`| ${p.name} | ${p.lastScan.split("T")[0]} | ${p.healthScore}% | ${p.totalIssues} |`);
+  }
+  lines.push("", "---", "", "*This file is auto-generated by Trie. Do not edit manually.*");
+  await mkdir5(GLOBAL_MEMORY_DIR, { recursive: true });
+  await writeFile5(join6(GLOBAL_MEMORY_DIR, "GLOBAL_MEMORY.md"), lines.join("\n"));
+}
+async function searchGlobalPatterns(query, options = {}) {
+  const patterns = await loadGlobalPatterns();
+  const limit = options.limit || 10;
+  const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+  const scored = patterns.filter((p) => {
+    if (options.severity && !options.severity.includes(p.severity)) return false;
+    if (options.agent && p.agent !== options.agent) return false;
+    return true;
+  }).map((p) => {
+    const text = `${p.pattern} ${p.description} ${p.agent}`.toLowerCase();
+    let score = 0;
+    for (const term of queryTerms) {
+      if (text.includes(term)) score++;
+    }
+    return { pattern: p, score };
+  }).filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
+  return scored.map((s) => s.pattern);
+}
+async function loadGlobalPatterns() {
+  const patternsPath = join6(GLOBAL_MEMORY_DIR, "global-patterns.json");
+  try {
+    if (existsSync4(patternsPath)) {
+      const content = await readFile6(patternsPath, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return [];
+}
+async function saveGlobalPatterns(patterns) {
+  await mkdir5(GLOBAL_MEMORY_DIR, { recursive: true });
+  const patternsPath = join6(GLOBAL_MEMORY_DIR, "global-patterns.json");
+  const pruned = patterns.sort((a, b) => new Date(b.lastSeen).getTime() - new Date(a.lastSeen).getTime()).slice(0, 500);
+  await writeFile5(patternsPath, JSON.stringify(pruned, null, 2));
+}
+function extractPatternId(issue) {
+  const normalized = issue.issue.toLowerCase().replace(/`[^`]+`/g, "CODE").replace(/\b\d+\b/g, "N").replace(/['"]/g, "").slice(0, 100);
+  let hash = 0;
+  for (let i = 0; i < normalized.length; i++) {
+    const char = normalized.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return `${issue.agent}-${issue.severity}-${Math.abs(hash).toString(36)}`;
+}
+function sanitizeName(name) {
+  return name.replace(/[^a-zA-Z0-9-_]/g, "-").toLowerCase();
+}
+
+// src/utils/context-state.ts
+import { readFile as readFile7, writeFile as writeFile6, mkdir as mkdir6 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { join as join7, basename } from "path";
+var AGENTS_MD_PATH = ".trie/AGENTS.md";
+var STATE_JSON_PATH = ".trie/state.json";
+async function loadContextState() {
+  const workDir = getWorkingDirectory(void 0, true);
+  const statePath = join7(workDir, STATE_JSON_PATH);
+  const defaults = getDefaultState();
+  try {
+    if (existsSync5(statePath)) {
+      const content = await readFile7(statePath, "utf-8");
+      const loaded = JSON.parse(content);
+      return {
+        ...defaults,
+        ...loaded,
+        skills: loaded.skills || defaults.skills
+      };
+    }
+  } catch {
+  }
+  return defaults;
+}
+async function saveContextState(state) {
+  const workDir = getWorkingDirectory(void 0, true);
+  const trieDir = join7(workDir, ".trie");
+  const statePath = join7(workDir, STATE_JSON_PATH);
+  await mkdir6(trieDir, { recursive: true });
+  await writeFile6(statePath, JSON.stringify(state, null, 2));
+}
+async function updateContextAfterScan(results, filesScanned, contextSignals, duration) {
+  const state = await loadContextState();
+  const workDir = getWorkingDirectory(void 0, true);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const allIssues = results.flatMap((r) => r.issues);
+  const issueCounts = {
+    critical: allIssues.filter((i) => i.severity === "critical").length,
+    serious: allIssues.filter((i) => i.severity === "serious").length,
+    moderate: allIssues.filter((i) => i.severity === "moderate").length,
+    low: allIssues.filter((i) => i.severity === "low").length,
+    total: allIssues.length
+  };
+  const fileIssueMap = /* @__PURE__ */ new Map();
+  for (const issue of allIssues) {
+    const count = fileIssueMap.get(issue.file) || 0;
+    fileIssueMap.set(issue.file, count + 1);
+  }
+  const hotFiles = Array.from(fileIssueMap.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([file, issueCount]) => ({ file, issueCount }));
+  const scanSummary = {
+    timestamp: now,
+    agents: results.map((r) => r.agent),
+    filesScanned,
+    issues: issueCounts,
+    duration,
+    hotFiles
+  };
+  for (const result of results) {
+    state.agentStatus[result.agent] = {
+      lastRun: now,
+      issuesFound: result.issues.length
+    };
+  }
+  const criticalPenalty = issueCounts.critical * 25;
+  const seriousPenalty = issueCounts.serious * 10;
+  const moderatePenalty = issueCounts.moderate * 3;
+  const lowPenalty = issueCounts.low * 1;
+  const totalPenalty = Math.min(100, criticalPenalty + seriousPenalty + moderatePenalty + lowPenalty);
+  state.healthScore = Math.max(0, 100 - totalPenalty);
+  state.activePriorities = generatePriorities(issueCounts, contextSignals);
+  state.contextSignals = { ...state.contextSignals, ...contextSignals };
+  state.scanHistory = [scanSummary, ...state.scanHistory.slice(0, 19)];
+  state.lastScan = scanSummary;
+  await saveContextState(state);
+  await updateAgentsMd(state);
+  if (allIssues.length > 0) {
+    const projectName = basename(workDir);
+    try {
+      await storeIssues(allIssues, projectName, workDir);
+      await recordToGlobalMemory(allIssues, projectName, workDir, state.healthScore);
+      await updateGlobalMemoryMd();
+    } catch {
+    }
+  }
+}
+async function updateAgentsMd(state) {
+  const workDir = getWorkingDirectory(void 0, true);
+  const mdPath = join7(workDir, AGENTS_MD_PATH);
+  let content;
+  try {
+    content = await readFile7(mdPath, "utf-8");
+  } catch {
+    content = getAgentsMdTemplate();
+  }
+  content = updateSection(content, "Project State", generateProjectStateTable(state));
+  content = updateSection(content, "Active Priorities", generatePrioritiesList(state));
+  content = updateSection(content, "Agent Status", generateAgentStatusTable(state));
+  content = updateSection(content, "Recent Scan History", generateScanHistoryTable(state));
+  content = updateSection(content, "Context Signals Detected", generateContextSignals(state));
+  content = updateSection(content, "Risk Assessment", generateRiskAssessment(state));
+  content = updateSection(content, "Hot Files", generateHotFilesSection(state));
+  content = content.replace(
+    /Last updated:.*$/m,
+    `Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`
+  );
+  await writeFile6(mdPath, content);
+}
+function updateSection(content, sectionName, newContent) {
+  const sectionRegex = new RegExp(
+    `(### ${sectionName}[\\s\\S]*?)(?=###|---|
+## |$)`,
+    "g"
+  );
+  const replacement = `### ${sectionName}
+${newContent}
+
+`;
+  if (content.match(sectionRegex)) {
+    return content.replace(sectionRegex, replacement);
+  }
+  return content;
+}
+function generateProjectStateTable(state) {
+  const lastScan = state.lastScan;
+  const lastScanDate = lastScan ? new Date(lastScan.timestamp).toLocaleString() : "Never";
+  const criticalCount = lastScan?.issues.critical ?? 0;
+  const totalTasks = lastScan?.issues.total ?? 0;
+  return `| Metric | Value | Updated |
+|--------|-------|---------|
+| Last Scan | ${lastScanDate} | ${lastScan ? "Auto" : "-"} |
+| Critical Issues | ${criticalCount} | ${lastScan ? "Auto" : "-"} |
+| Open Tasks | ${totalTasks} | ${lastScan ? "Auto" : "-"} |
+| Health Score | ${state.healthScore}% | ${lastScan ? "Auto" : "-"} |`;
+}
+function generatePrioritiesList(state) {
+  if (state.activePriorities.length === 0) {
+    return "_No active priorities. Run a scan to identify issues._";
+  }
+  return state.activePriorities.map((p, i) => `${i + 1}. ${p}`).join("\n");
+}
+function generatePriorities(issues, contextSignals) {
+  const priorities = [];
+  if (issues.critical > 0) {
+    priorities.push(`\u{1F6A8} Fix ${issues.critical} critical security issue${issues.critical > 1 ? "s" : ""} immediately`);
+  }
+  if (issues.serious > 0) {
+    priorities.push(`\u26A0\uFE0F Address ${issues.serious} serious issue${issues.serious > 1 ? "s" : ""} before deployment`);
+  }
+  if (contextSignals.touchesAuth && issues.critical === 0) {
+    priorities.push("\u2705 Auth code reviewed - continue monitoring");
+  }
+  if (contextSignals.touchesPayments) {
+    priorities.push("\u{1F4B3} Payment code detected - ensure PCI compliance");
+  }
+  if (contextSignals.touchesUserData) {
+    priorities.push("\u{1F510} User data handling detected - verify privacy compliance");
+  }
+  if (issues.moderate > 5) {
+    priorities.push(`\u{1F4CB} Schedule time to address ${issues.moderate} moderate issues`);
+  }
+  if (priorities.length === 0) {
+    priorities.push("\u2728 No critical issues - focus on feature development");
+  }
+  return priorities.slice(0, 5);
+}
+function generateAgentStatusTable(state) {
+  const builtInAgents = [
+    "security",
+    "privacy",
+    "legal",
+    "accessibility",
+    "bugs",
+    "design",
+    "architecture",
+    "performance",
+    "devops",
+    "soc2",
+    "e2e",
+    "typecheck",
+    "visual-qa",
+    "data-flow"
+  ];
+  let table = `| Agent | Status | Last Run | Issues Found |
+|-------|--------|----------|--------------|`;
+  for (const agent of builtInAgents) {
+    const status = state.agentStatus[agent];
+    const lastRun = status?.lastRun ? new Date(status.lastRun).toLocaleDateString() : "Never";
+    const issues = status?.issuesFound ?? "-";
+    const statusEmoji = status ? "\u2705" : "\u23F8\uFE0F";
+    table += `
+| ${agent} | ${statusEmoji} Ready | ${lastRun} | ${issues} |`;
+  }
+  return table;
+}
+function generateScanHistoryTable(state) {
+  if (state.scanHistory.length === 0) {
+    return `| Date | Agents | Files | Issues | Duration |
+|------|--------|-------|--------|----------|
+| - | - | - | - | - |`;
+  }
+  let table = `| Date | Agents | Files | Issues | Duration |
+|------|--------|-------|--------|----------|`;
+  for (const scan of state.scanHistory.slice(0, 10)) {
+    const date = new Date(scan.timestamp).toLocaleDateString();
+    const agents = scan.agents.slice(0, 3).join(", ") + (scan.agents.length > 3 ? "..." : "");
+    const duration = `${(scan.duration / 1e3).toFixed(1)}s`;
+    table += `
+| ${date} | ${agents} | ${scan.filesScanned} | ${scan.issues.total} | ${duration} |`;
+  }
+  return table;
+}
+function generateContextSignals(state) {
+  const signals = [
+    "touchesAuth",
+    "touchesPayments",
+    "touchesUserData",
+    "touchesAPI",
+    "touchesDatabase",
+    "touchesCrypto"
+  ];
+  return signals.map((s) => {
+    const value = state.contextSignals[s];
+    const emoji = value === true ? "\u2705" : value === false ? "\u274C" : "\u2753";
+    return `- \`${s}\`: ${emoji} ${value === void 0 ? "Unknown" : value ? "Yes" : "No"}`;
+  }).join("\n");
+}
+function generateRiskAssessment(state) {
+  const score = state.healthScore;
+  let riskLevel;
+  let confidence;
+  if (state.lastScan === null) {
+    return `- Overall Risk: Unknown
+- Confidence: 0%`;
+  }
+  if (score >= 90) {
+    riskLevel = "\u{1F7E2} Low";
+    confidence = 95;
+  } else if (score >= 70) {
+    riskLevel = "\u{1F7E1} Medium";
+    confidence = 85;
+  } else if (score >= 50) {
+    riskLevel = "\u{1F7E0} High";
+    confidence = 80;
+  } else {
+    riskLevel = "\u{1F534} Critical";
+    confidence = 90;
+  }
+  return `- Overall Risk: ${riskLevel}
+- Health Score: ${score}%
+- Confidence: ${confidence}%`;
+}
+function generateHotFilesSection(state) {
+  if (!state.lastScan || state.lastScan.hotFiles.length === 0) {
+    return "_Run a scan to identify hot files._";
+  }
+  return state.lastScan.hotFiles.map((f) => `- \`${f.file}\` - ${f.issueCount} issue${f.issueCount > 1 ? "s" : ""}`).join("\n");
+}
+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 recordSkillInstalled(params) {
+  const state = await loadContextState();
+  state.skills[params.name] = {
+    source: params.source,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    timesApplied: 0,
+    appliedBy: []
+  };
+  await saveContextState(state);
+}
+async function recordSkillUsage(params) {
+  const state = await loadContextState();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const skillName of params.skillNames) {
+    const skillRecord = state.skills[skillName];
+    if (skillRecord) {
+      skillRecord.timesApplied++;
+      skillRecord.lastApplied = now;
+      if (!skillRecord.appliedBy.includes(params.agentName)) {
+        skillRecord.appliedBy.push(params.agentName);
+      }
+    }
+  }
+  const agentStatus = state.agentStatus[params.agentName];
+  if (agentStatus) {
+    agentStatus.skillsApplied = params.skillNames;
+  }
+  await saveContextState(state);
+}
+function getAgentsMdTemplate() {
+  return `# Trie Agent Context
+
+> **Auto-generated file** - Updated automatically when agents run.
+> Last updated: Never (initial state)
+
+This file provides prioritized context for all AI coding assistants working with this codebase.
+Agents should read this file first and update it after completing scans.
+
+---
+
+## Quick Context (Read First)
+
+### Project State
+| Metric | Value | Updated |
+|--------|-------|---------|
+| Last Scan | Never | - |
+| Critical Issues | 0 | - |
+| Open Tasks | 0 | - |
+| Health Score | Unknown | - |
+
+### Active Priorities
+1. Initial setup required - run first scan with \`trie scan\`
+2. Configure agents in \`.trie/config.json\`
+3. Set up CI/CD integration
+
+### Hot Files
+_Run a scan to identify hot files._
+
+---
+
+## Agent Status
+
+### Agent Status
+| Agent | Status | Last Run | Issues Found |
+|-------|--------|----------|--------------|
+| security | Ready | Never | - |
+| privacy | Ready | Never | - |
+| bugs | Ready | Never | - |
+
+### Recent Scan History
+| Date | Agents | Files | Issues | Duration |
+|------|--------|-------|--------|----------|
+| - | - | - | - | - |
+
+---
+
+## Context Analysis
+
+### Context Signals Detected
+- \`touchesAuth\`: Unknown
+- \`touchesPayments\`: Unknown
+- \`touchesUserData\`: Unknown
+- \`touchesAPI\`: Unknown
+- \`touchesDatabase\`: Unknown
+- \`touchesCrypto\`: Unknown
+
+### Risk Assessment
+- Overall Risk: Unknown
+- Confidence: 0%
+
+---
+
+*This file is maintained by Trie agents. Manual edits will be preserved in non-auto sections.*
+`;
+}
+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");
+}
+
+export {
+  parseSkillMd,
+  installSkill,
+  listInstalledSkills,
+  removeSkill,
+  projectInfoExists,
+  loadProjectInfo,
+  initProjectInfo,
+  getProjectSection,
+  updateProjectSection,
+  appendToSection,
+  getProjectSections,
+  getProjectInfoStructured,
+  getHistoricalInsights,
+  searchIssues,
+  findSimilarIssues,
+  markIssueResolved,
+  getMemoryStats,
+  getRecentIssues,
+  getDailyLogs,
+  findCrossProjectPatterns,
+  listTrackedProjects,
+  getGlobalMemoryStats,
+  updateGlobalMemoryMd,
+  searchGlobalPatterns,
+  loadContextState,
+  updateContextAfterScan,
+  recordSkillInstalled,
+  recordSkillUsage,
+  getContextForAI
+};
+//# sourceMappingURL=chunk-PZDQIFKO.js.map