@triedotdev/mcp 1.0.138 → 1.0.140

package/dist/chunk-62POBLFC.js

@@ -0,0 +1,1925 @@
+import {
+  BackupManager,
+  CompactedSummariesIndexSchema,
+  IssueIndexSchema,
+  safeParseAndValidate
+} from "./chunk-4MJ52WBH.js";
+import {
+  atomicWriteJSON
+} from "./chunk-43X6JBEM.js";
+import {
+  getTrieDirectory,
+  getWorkingDirectory
+} from "./chunk-SH7H3WRU.js";
+
+// src/memory/issue-store.ts
+import { mkdir as mkdir3, writeFile as writeFile2, readFile as readFile3, readdir as readdir2 } from "fs/promises";
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync4 } from "fs";
+import { join as join3 } 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]) => {
+      const metadata = this.documents.get(id)?.metadata;
+      const result = { id, score };
+      if (metadata !== void 0) {
+        result.metadata = metadata;
+      }
+      return result;
+    });
+  }
+  /**
+   * 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, readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } 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 = join(getTrieDirectory(projectDir), "memory");
+  await mkdir(memoryDir, { recursive: true });
+  const summaryPath = join(memoryDir, "compacted-summaries.json");
+  let summaries = [];
+  try {
+    if (existsSync(summaryPath)) {
+      const content = await readFile(summaryPath, "utf-8");
+      const result = safeParseAndValidate(content, CompactedSummariesIndexSchema);
+      if (result.success) {
+        summaries = result.data;
+      }
+    }
+  } catch {
+    summaries = [];
+  }
+  summaries.push(summary);
+  if (summaries.length > 12) {
+    summaries = summaries.slice(-12);
+  }
+  const backupManager = new BackupManager(summaryPath);
+  await backupManager.createBackup();
+  await atomicWriteJSON(summaryPath, summaries);
+}
+async function loadCompactedSummaries(projectDir) {
+  const summaryPath = join(getTrieDirectory(projectDir), "memory", "compacted-summaries.json");
+  try {
+    if (existsSync(summaryPath)) {
+      const content = await readFile(summaryPath, "utf-8");
+      const result = safeParseAndValidate(content, CompactedSummariesIndexSchema);
+      if (result.success) {
+        return result.data;
+      }
+      const backupManager = new BackupManager(summaryPath);
+      if (await backupManager.recoverFromBackup()) {
+        const recovered = await readFile(summaryPath, "utf-8");
+        const recoveredResult = safeParseAndValidate(recovered, CompactedSummariesIndexSchema);
+        if (recoveredResult.success) {
+          return recoveredResult.data;
+        }
+      }
+    }
+  } 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/ledger.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir2, readFile as readFile2, writeFile, stat, unlink, readdir } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { createGzip, createGunzip } from "zlib";
+import { pipeline } from "stream/promises";
+import { createReadStream, createWriteStream } from "fs";
+import { join as join2 } from "path";
+
+// src/agent/git.ts
+import { existsSync as existsSync2 } from "fs";
+import path from "path";
+
+// src/utils/command-runner.ts
+import { exec, execFile, execSync } from "child_process";
+import { promisify } from "util";
+
+// 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/utils/command-runner.ts
+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 getLastCommit(projectPath) {
+  const commits = await getRecentCommits(projectPath, 1);
+  return commits[0] ?? null;
+}
+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 getGitChangedFiles(projectPath) {
+  const isRepo = await ensureRepo(projectPath);
+  if (!isRepo) return null;
+  const [staged, uncommitted] = await Promise.all([
+    getStagedChanges(projectPath).catch(() => []),
+    getUncommittedChanges(projectPath).catch(() => [])
+  ]);
+  const paths = /* @__PURE__ */ new Set();
+  for (const change of [...staged, ...uncommitted]) {
+    if (change.path) paths.add(change.path);
+    if (change.oldPath) paths.add(change.oldPath);
+  }
+  return [...paths];
+}
+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 ?? "";
+}
+async function isGitRepo(projectPath) {
+  const result = await execGit(["rev-parse", "--is-inside-work-tree"], projectPath);
+  return result === "true";
+}
+async function getChangedFilesSinceTimestamp(projectPath, timestamp) {
+  const isRepo = await isGitRepo(projectPath);
+  if (!isRepo) return null;
+  try {
+    const sinceDate = new Date(timestamp).toISOString();
+    const GIT_TIMEOUT_MS = 5e3;
+    const startTime = Date.now();
+    const committedChangesPromise = execGit(
+      ["log", `--since=${sinceDate}`, "--name-only", "--pretty=format:"],
+      projectPath
+    );
+    const committedChangesTimeout = new Promise((resolve) => {
+      setTimeout(() => resolve(null), GIT_TIMEOUT_MS);
+    });
+    const committedChanges = await Promise.race([committedChangesPromise, committedChangesTimeout]);
+    if (Date.now() - startTime > GIT_TIMEOUT_MS) {
+      return null;
+    }
+    const stagedPromise = execGit(["diff", "--cached", "--name-only"], projectPath);
+    const unstagedPromise = execGit(["diff", "--name-only"], projectPath);
+    const untrackedPromise = execGit(
+      ["ls-files", "--others", "--exclude-standard"],
+      projectPath
+    );
+    const timeoutPromise = new Promise((resolve) => {
+      setTimeout(() => resolve(null), Math.max(0, GIT_TIMEOUT_MS - (Date.now() - startTime)));
+    });
+    const [stagedChanges, unstagedChanges, untrackedFiles] = await Promise.race([
+      Promise.all([stagedPromise, unstagedPromise, untrackedPromise]),
+      timeoutPromise.then(() => [null, null, null])
+    ]);
+    const changedFiles = /* @__PURE__ */ new Set();
+    const addFiles = (output) => {
+      if (output) {
+        output.split("\n").map((f) => f.trim()).filter(Boolean).forEach((f) => changedFiles.add(path.join(projectPath, f)));
+      }
+    };
+    addFiles(committedChanges);
+    addFiles(stagedChanges);
+    addFiles(unstagedChanges);
+    addFiles(untrackedFiles);
+    return Array.from(changedFiles);
+  } catch {
+    return null;
+  }
+}
+
+// src/memory/ledger.ts
+var LEDGER_FILENAME = "ledger.json";
+var SHARED_LEDGER_DIR = ".trie-shared";
+var MANIFEST_FILENAME = "ledger-manifest.json";
+var SYNC_STATE_FILENAME = "ledger-sync.json";
+var GENESIS_HASH = "0".repeat(64);
+var LEDGER_VERSION = 2;
+async function appendIssuesToLedger(issues, workDir, author) {
+  if (issues.length === 0) return null;
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const memoryDir = join2(getTrieDirectory(projectDir), "memory");
+  await mkdir2(memoryDir, { recursive: true });
+  const isRepo = await isGitRepo(projectDir);
+  const lastCommit = isRepo ? await getLastCommit(projectDir) : null;
+  const blockAuthor = author || lastCommit?.author || "unknown";
+  const blocks = await loadLedger(projectDir);
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const entries = issues.map((issue) => ({
+    id: issue.id,
+    hash: issue.hash,
+    severity: issue.severity,
+    file: issue.file,
+    agent: issue.agent,
+    timestamp: issue.timestamp
+  }));
+  const previousBlock = blocks[blocks.length - 1];
+  const block = previousBlock && previousBlock.date === today ? previousBlock : createSyncableBlock(today, now, previousBlock?.blockHash ?? GENESIS_HASH, blockAuthor, lastCommit?.hash, blocks.length);
+  if (block !== previousBlock) {
+    blocks.push(block);
+  }
+  block.entries = [...block.entries, ...entries];
+  block.merkleRoot = computeMerkleRoot(block.entries.map((entry) => entry.hash));
+  block.blockHash = computeBlockHash(block.previousHash, block.merkleRoot, block.date, block.version);
+  block.updatedAt = now;
+  await saveLedger(blocks, projectDir);
+  return block;
+}
+async function verifyLedger(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const blocks = await loadLedger(projectDir);
+  if (blocks.length === 0) {
+    return { valid: true };
+  }
+  for (let i = 0; i < blocks.length; i += 1) {
+    const block = blocks[i];
+    if (!block) {
+      return { valid: false, error: `Block ${i} missing` };
+    }
+    const expectedPreviousHash = i === 0 ? GENESIS_HASH : blocks[i - 1]?.blockHash;
+    if (!expectedPreviousHash) {
+      return { valid: false, error: `Block ${i} missing previous block` };
+    }
+    if (block.previousHash !== expectedPreviousHash) {
+      return { valid: false, error: `Block ${i} previous hash mismatch` };
+    }
+    const computedMerkleRoot = computeMerkleRoot(block.entries.map((entry) => entry.hash));
+    if (block.merkleRoot !== computedMerkleRoot) {
+      return { valid: false, error: `Block ${i} merkle root mismatch` };
+    }
+    const computedBlockHash = computeBlockHash(block.previousHash, block.merkleRoot, block.date, block.version);
+    if (block.blockHash !== computedBlockHash) {
+      return { valid: false, error: `Block ${i} hash mismatch` };
+    }
+  }
+  return { valid: true };
+}
+function computeMerkleRoot(hashes) {
+  if (hashes.length === 0) {
+    return sha256("");
+  }
+  let level = hashes.slice();
+  while (level.length > 1) {
+    const nextLevel = [];
+    for (let i = 0; i < level.length; i += 2) {
+      const left = level[i];
+      const right = level[i + 1] ?? left;
+      nextLevel.push(sha256(`${left}:${right}`));
+    }
+    level = nextLevel;
+  }
+  return level[0];
+}
+function computeBlockHash(previousHash, merkleRoot, date, version) {
+  return sha256(`${version}:${date}:${previousHash}:${merkleRoot}`);
+}
+function createSyncableBlock(date, now, previousHash, author, gitCommit, chainHeight = 0) {
+  return {
+    version: LEDGER_VERSION,
+    date,
+    entries: [],
+    previousHash,
+    merkleRoot: "",
+    blockHash: "",
+    createdAt: now,
+    updatedAt: now,
+    author,
+    gitCommit,
+    chainHeight
+  };
+}
+async function loadLedger(projectDir) {
+  const ledgerPath = join2(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
+  try {
+    if (!existsSync3(ledgerPath)) return [];
+    const content = await readFile2(ledgerPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!Array.isArray(parsed)) return [];
+    return parsed;
+  } catch {
+    return [];
+  }
+}
+async function getLedgerBlocks(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  return loadLedger(projectDir);
+}
+async function saveLedger(blocks, projectDir) {
+  const ledgerPath = join2(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
+  await atomicWriteJSON(ledgerPath, blocks);
+}
+function sha256(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+function getSharedLedgerDir(projectDir) {
+  return join2(projectDir, SHARED_LEDGER_DIR);
+}
+function getActiveBlocksDir(projectDir) {
+  return join2(getSharedLedgerDir(projectDir), "active");
+}
+function getArchivedBlocksDir(projectDir) {
+  return join2(getSharedLedgerDir(projectDir), "archived");
+}
+function getManifestPath(projectDir) {
+  return join2(getSharedLedgerDir(projectDir), MANIFEST_FILENAME);
+}
+function getSyncStatePath(projectDir) {
+  return join2(getTrieDirectory(projectDir), "memory", SYNC_STATE_FILENAME);
+}
+async function ensureSharedStorageStructure(projectDir) {
+  const sharedDir = getSharedLedgerDir(projectDir);
+  const activeDir = getActiveBlocksDir(projectDir);
+  const archivedDir = getArchivedBlocksDir(projectDir);
+  await mkdir2(sharedDir, { recursive: true });
+  await mkdir2(activeDir, { recursive: true });
+  await mkdir2(archivedDir, { recursive: true });
+}
+async function loadManifest(projectDir) {
+  const manifestPath = getManifestPath(projectDir);
+  try {
+    if (!existsSync3(manifestPath)) return null;
+    const content = await readFile2(manifestPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function saveManifest(manifest, projectDir) {
+  const manifestPath = getManifestPath(projectDir);
+  await atomicWriteJSON(manifestPath, manifest);
+}
+async function createDefaultManifest(projectDir) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: LEDGER_VERSION,
+    created: now,
+    lastSync: now,
+    totalBlocks: 0,
+    totalEntries: 0,
+    activeBlocks: [],
+    archivedBlocks: [],
+    index: {
+      byDate: {},
+      byAuthor: {},
+      bySeverity: {}
+    },
+    compressionConfig: {
+      enabled: true,
+      archiveAfterDays: 30,
+      compressionLevel: 6,
+      maxHotStorageSize: 50 * 1024 * 1024
+      // 50MB
+    }
+  };
+}
+async function loadSyncState(projectDir) {
+  const syncStatePath = getSyncStatePath(projectDir);
+  try {
+    if (!existsSync3(syncStatePath)) return null;
+    const content = await readFile2(syncStatePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function saveSyncState(syncState, projectDir) {
+  const syncStatePath = getSyncStatePath(projectDir);
+  const memoryDir = join2(getTrieDirectory(projectDir), "memory");
+  await mkdir2(memoryDir, { recursive: true });
+  await atomicWriteJSON(syncStatePath, syncState);
+}
+async function initializeSharedLedger(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  await ensureSharedStorageStructure(projectDir);
+  const existingManifest = await loadManifest(projectDir);
+  if (!existingManifest) {
+    const manifest = await createDefaultManifest(projectDir);
+    await saveManifest(manifest, projectDir);
+  }
+  const existingSyncState = await loadSyncState(projectDir);
+  if (!existingSyncState) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const syncState = {
+      lastSyncTimestamp: now,
+      conflicts: [],
+      localChanges: false,
+      sharedChanges: false
+    };
+    await saveSyncState(syncState, projectDir);
+  }
+}
+async function syncLedgerFromShared(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  await initializeSharedLedger(projectDir);
+  const manifest = await loadManifest(projectDir);
+  const localBlocks = await loadLedger(projectDir);
+  const sharedBlocks = await loadSharedBlocks(projectDir);
+  if (!manifest) {
+    throw new Error("Failed to load ledger manifest");
+  }
+  const mergeResult = await mergeChains(localBlocks, sharedBlocks, "timestamp");
+  await saveLedger(mergeResult.mergedChain, projectDir);
+  const syncState = {
+    lastSyncTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    conflicts: mergeResult.conflicts,
+    localChanges: false,
+    sharedChanges: false
+  };
+  await saveSyncState(syncState, projectDir);
+  return mergeResult;
+}
+async function pushLedgerToShared(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  await initializeSharedLedger(projectDir);
+  const localBlocks = await loadLedger(projectDir);
+  const manifest = await loadManifest(projectDir) || await createDefaultManifest(projectDir);
+  const activeDir = getActiveBlocksDir(projectDir);
+  for (const block of localBlocks) {
+    const blockFilename = `${block.date}.json`;
+    const blockPath = join2(activeDir, blockFilename);
+    if (!existsSync3(blockPath) || block.updatedAt > manifest.lastSync) {
+      await atomicWriteJSON(blockPath, block);
+      manifest.index.byDate[block.date] = `active/${blockFilename}`;
+      if (block.author) {
+        if (!manifest.index.byAuthor[block.author]) {
+          manifest.index.byAuthor[block.author] = [];
+        }
+        if (!manifest.index.byAuthor[block.author].includes(`active/${blockFilename}`)) {
+          manifest.index.byAuthor[block.author].push(`active/${blockFilename}`);
+        }
+      }
+      if (!manifest.activeBlocks.includes(blockFilename)) {
+        manifest.activeBlocks.push(blockFilename);
+      }
+    }
+  }
+  manifest.lastSync = (/* @__PURE__ */ new Date()).toISOString();
+  manifest.totalBlocks = manifest.activeBlocks.length + manifest.archivedBlocks.length;
+  manifest.totalEntries = localBlocks.reduce((sum, block) => sum + block.entries.length, 0);
+  await saveManifest(manifest, projectDir);
+}
+async function loadSharedBlocks(projectDir) {
+  const manifest = await loadManifest(projectDir);
+  if (!manifest) return [];
+  const blocks = [];
+  const activeDir = getActiveBlocksDir(projectDir);
+  for (const filename of manifest.activeBlocks) {
+    const blockPath = join2(activeDir, filename);
+    try {
+      if (existsSync3(blockPath)) {
+        const content = await readFile2(blockPath, "utf-8");
+        const block = JSON.parse(content);
+        blocks.push(block);
+      }
+    } catch (error) {
+      console.warn(`Failed to load shared block ${filename}:`, error);
+    }
+  }
+  return blocks.sort((a, b) => a.date.localeCompare(b.date));
+}
+async function mergeChains(localBlocks, remoteBlocks, strategy = "timestamp") {
+  const conflicts = [];
+  const mergedBlocks = /* @__PURE__ */ new Map();
+  const stats = {
+    localBlocks: localBlocks.length,
+    remoteBlocks: remoteBlocks.length,
+    mergedBlocks: 0,
+    duplicatesRemoved: 0
+  };
+  const localByDate = /* @__PURE__ */ new Map();
+  for (const block of localBlocks) {
+    localByDate.set(block.date, block);
+  }
+  const remoteByDate = /* @__PURE__ */ new Map();
+  for (const block of remoteBlocks) {
+    remoteByDate.set(block.date, block);
+  }
+  const allDates = /* @__PURE__ */ new Set([...localByDate.keys(), ...remoteByDate.keys()]);
+  for (const date of allDates) {
+    const localBlock = localByDate.get(date);
+    const remoteBlock = remoteByDate.get(date);
+    if (localBlock && remoteBlock) {
+      const conflict = detectBlockConflict(localBlock, remoteBlock);
+      if (conflict) {
+        conflicts.push(conflict);
+        const resolvedBlock = resolveConflict(conflict, strategy);
+        if (resolvedBlock) {
+          mergedBlocks.set(date, resolvedBlock);
+        }
+      } else {
+        const mergedBlock = mergeBlockEntries(localBlock, remoteBlock);
+        mergedBlocks.set(date, mergedBlock);
+      }
+    } else if (localBlock) {
+      mergedBlocks.set(date, localBlock);
+    } else if (remoteBlock) {
+      mergedBlocks.set(date, remoteBlock);
+    }
+  }
+  const resultBlocks = Array.from(mergedBlocks.values()).sort((a, b) => a.date.localeCompare(b.date)).map((block, index) => ({
+    ...block,
+    chainHeight: index
+  }));
+  stats.mergedBlocks = resultBlocks.length;
+  stats.duplicatesRemoved = stats.localBlocks + stats.remoteBlocks - stats.mergedBlocks;
+  return {
+    mergedChain: resultBlocks,
+    conflicts,
+    resolutionStrategy: strategy,
+    stats
+  };
+}
+function detectBlockConflict(localBlock, remoteBlock) {
+  if (localBlock.blockHash !== remoteBlock.blockHash) {
+    return {
+      type: "hash_mismatch",
+      description: `Different block content for date ${localBlock.date}`,
+      localBlock,
+      remoteBlock
+    };
+  }
+  const localEntryHashes = new Set(localBlock.entries.map((e) => e.hash));
+  const remoteEntryHashes = new Set(remoteBlock.entries.map((e) => e.hash));
+  const hasConflictingEntries = localBlock.entries.some((localEntry) => {
+    const conflictingRemoteEntry = remoteBlock.entries.find(
+      (remoteEntry) => remoteEntry.id === localEntry.id && remoteEntry.hash !== localEntry.hash
+    );
+    return !!conflictingRemoteEntry;
+  });
+  if (hasConflictingEntries) {
+    return {
+      type: "duplicate_entry",
+      description: `Conflicting entries found for date ${localBlock.date}`,
+      localBlock,
+      remoteBlock
+    };
+  }
+  return null;
+}
+function resolveConflict(conflict, strategy) {
+  if (!conflict.localBlock || !conflict.remoteBlock) {
+    return null;
+  }
+  switch (strategy) {
+    case "longest":
+      return conflict.localBlock.entries.length >= conflict.remoteBlock.entries.length ? conflict.localBlock : conflict.remoteBlock;
+    case "timestamp":
+      return conflict.localBlock.updatedAt >= conflict.remoteBlock.updatedAt ? conflict.localBlock : conflict.remoteBlock;
+    case "manual":
+      return { ...conflict.localBlock, conflictResolved: false };
+    default:
+      return conflict.localBlock;
+  }
+}
+function mergeBlockEntries(localBlock, remoteBlock) {
+  const entryMap = /* @__PURE__ */ new Map();
+  for (const entry of localBlock.entries) {
+    entryMap.set(entry.hash, entry);
+  }
+  for (const entry of remoteBlock.entries) {
+    entryMap.set(entry.hash, entry);
+  }
+  const mergedEntries = Array.from(entryMap.values());
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const authors = [localBlock.author, remoteBlock.author].filter(Boolean);
+  const combinedAuthor = authors.length > 1 ? authors.join("+") : authors[0] || "unknown";
+  return {
+    ...localBlock,
+    entries: mergedEntries,
+    author: combinedAuthor,
+    updatedAt: now,
+    merkleRoot: computeMerkleRoot(mergedEntries.map((e) => e.hash)),
+    blockHash: computeBlockHash(
+      localBlock.previousHash,
+      computeMerkleRoot(mergedEntries.map((e) => e.hash)),
+      localBlock.date,
+      localBlock.version
+    )
+  };
+}
+async function migrateLegacyLedger(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const legacyLedgerPath = join2(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
+  if (!existsSync3(legacyLedgerPath)) {
+    return false;
+  }
+  try {
+    const legacyBlocks = await loadLedger(projectDir);
+    if (legacyBlocks.length > 0 && legacyBlocks[0].author !== void 0) {
+      return false;
+    }
+    console.log(`Migrating legacy ledger with ${legacyBlocks.length} blocks...`);
+    const isRepo = await isGitRepo(projectDir);
+    const lastCommit = isRepo ? await getLastCommit(projectDir) : null;
+    const defaultAuthor = lastCommit?.author || "legacy-migration";
+    const migratedBlocks = legacyBlocks.map((block, index) => ({
+      ...block,
+      version: LEDGER_VERSION,
+      author: defaultAuthor,
+      gitCommit: lastCommit?.hash,
+      chainHeight: index,
+      syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+    await initializeSharedLedger(projectDir);
+    await saveLedger(migratedBlocks, projectDir);
+    await pushLedgerToShared(projectDir);
+    const backupPath = `${legacyLedgerPath}.backup.${Date.now()}`;
+    await writeFile(backupPath, JSON.stringify(legacyBlocks, null, 2));
+    console.log(`\u2713 Migration complete. Backup saved to ${backupPath}`);
+    return true;
+  } catch (error) {
+    console.error("Failed to migrate legacy ledger:", error);
+    return false;
+  }
+}
+async function detectLegacyLedger(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const legacyLedgerPath = join2(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
+  if (!existsSync3(legacyLedgerPath)) {
+    return false;
+  }
+  try {
+    const blocks = await loadLedger(projectDir);
+    return blocks.length > 0 && blocks[0].author === void 0;
+  } catch {
+    return false;
+  }
+}
+async function getLedgerSyncStatus(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const hasLegacyLedger = await detectLegacyLedger(projectDir);
+  const manifest = await loadManifest(projectDir);
+  const syncState = await loadSyncState(projectDir);
+  const localBlocks = await loadLedger(projectDir);
+  const sharedBlocks = await loadSharedBlocks(projectDir);
+  return {
+    isInitialized: !!manifest,
+    hasLegacyLedger,
+    syncState,
+    manifest,
+    localBlocks: localBlocks.length,
+    sharedBlocks: sharedBlocks.length,
+    conflicts: syncState?.conflicts.length || 0
+  };
+}
+async function compressOldBlocks(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const manifest = await loadManifest(projectDir);
+  if (!manifest || !manifest.compressionConfig.enabled) {
+    return { archived: 0, sizeReduction: 0 };
+  }
+  const activeDir = getActiveBlocksDir(projectDir);
+  const archivedDir = getArchivedBlocksDir(projectDir);
+  const cutoffDate = /* @__PURE__ */ new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - manifest.compressionConfig.archiveAfterDays);
+  let archivedCount = 0;
+  let originalSize = 0;
+  let compressedSize = 0;
+  const blocksByMonth = /* @__PURE__ */ new Map();
+  for (const blockFile of manifest.activeBlocks) {
+    const blockPath = join2(activeDir, blockFile);
+    const blockDate = blockFile.replace(".json", "");
+    if (new Date(blockDate) < cutoffDate) {
+      const monthKey = blockDate.slice(0, 7);
+      if (!blocksByMonth.has(monthKey)) {
+        blocksByMonth.set(monthKey, []);
+      }
+      blocksByMonth.get(monthKey).push(blockFile);
+    }
+  }
+  for (const [monthKey, blockFiles] of blocksByMonth) {
+    const archivePath = join2(archivedDir, `${monthKey}.tar.gz`);
+    if (existsSync3(archivePath)) {
+      continue;
+    }
+    console.log(`Archiving ${blockFiles.length} blocks for ${monthKey}...`);
+    const monthlyBlocks = [];
+    for (const blockFile of blockFiles) {
+      const blockPath = join2(activeDir, blockFile);
+      try {
+        const stats = await stat(blockPath);
+        originalSize += stats.size;
+        const content = await readFile2(blockPath, "utf-8");
+        const block = JSON.parse(content);
+        monthlyBlocks.push(block);
+      } catch (error) {
+        console.warn(`Failed to read block ${blockFile}:`, error);
+      }
+    }
+    if (monthlyBlocks.length > 0) {
+      const archiveData = JSON.stringify(monthlyBlocks);
+      const tempPath = `${archivePath}.tmp`;
+      await pipeline(
+        Buffer.from(archiveData),
+        createGzip({ level: manifest.compressionConfig.compressionLevel }),
+        createWriteStream(tempPath)
+      );
+      const compressedStats = await stat(tempPath);
+      compressedSize += compressedStats.size;
+      await writeFile(archivePath, await readFile2(tempPath));
+      await unlink(tempPath);
+      for (const blockFile of blockFiles) {
+        const blockPath = join2(activeDir, blockFile);
+        await unlink(blockPath);
+        const index = manifest.activeBlocks.indexOf(blockFile);
+        if (index > -1) {
+          manifest.activeBlocks.splice(index, 1);
+        }
+      }
+      manifest.archivedBlocks.push(`${monthKey}.tar.gz`);
+      archivedCount += blockFiles.length;
+    }
+  }
+  if (archivedCount > 0) {
+    await saveManifest(manifest, projectDir);
+  }
+  return {
+    archived: archivedCount,
+    sizeReduction: originalSize > 0 ? Math.round((originalSize - compressedSize) / originalSize * 100) : 0
+  };
+}
+async function getStorageStats(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const manifest = await loadManifest(projectDir);
+  if (!manifest) {
+    return {
+      activeBlocks: 0,
+      archivedBlocks: 0,
+      activeSize: 0,
+      archivedSize: 0,
+      compressionRatio: 0,
+      totalEntries: 0
+    };
+  }
+  const activeDir = getActiveBlocksDir(projectDir);
+  const archivedDir = getArchivedBlocksDir(projectDir);
+  let activeSize = 0;
+  let archivedSize = 0;
+  for (const blockFile of manifest.activeBlocks) {
+    const blockPath = join2(activeDir, blockFile);
+    try {
+      if (existsSync3(blockPath)) {
+        const stats = await stat(blockPath);
+        activeSize += stats.size;
+      }
+    } catch {
+    }
+  }
+  for (const archiveFile of manifest.archivedBlocks) {
+    const archivePath = join2(archivedDir, archiveFile);
+    try {
+      if (existsSync3(archivePath)) {
+        const stats = await stat(archivePath);
+        archivedSize += stats.size;
+      }
+    } catch {
+    }
+  }
+  const totalSize = activeSize + archivedSize;
+  const estimatedUncompressed = archivedSize * 5;
+  const compressionRatio = estimatedUncompressed > 0 ? Math.round((1 - archivedSize / estimatedUncompressed) * 100) : 0;
+  return {
+    activeBlocks: manifest.activeBlocks.length,
+    archivedBlocks: manifest.archivedBlocks.length,
+    activeSize,
+    archivedSize,
+    compressionRatio,
+    totalEntries: manifest.totalEntries
+  };
+}
+async function shouldCompress(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const manifest = await loadManifest(projectDir);
+  if (!manifest || !manifest.compressionConfig.enabled) {
+    return false;
+  }
+  const stats = await getStorageStats(projectDir);
+  const exceedsSize = stats.activeSize > manifest.compressionConfig.maxHotStorageSize;
+  const hasOldBlocks = manifest.activeBlocks.some((blockFile) => {
+    const blockDate = blockFile.replace(".json", "");
+    const cutoffDate = /* @__PURE__ */ new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - manifest.compressionConfig.archiveAfterDays);
+    return new Date(blockDate) < cutoffDate;
+  });
+  return exceedsSize || hasOldBlocks;
+}
+async function deleteBlocks(blockDates, workDir, confirmDeletion = false) {
+  if (!confirmDeletion) {
+    return {
+      success: false,
+      deletedBlocks: 0,
+      error: "Deletion not confirmed. This is a permanent operation that cannot be undone."
+    };
+  }
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const blocks = await loadLedger(projectDir);
+  if (blocks.length === 0) {
+    return {
+      success: false,
+      deletedBlocks: 0,
+      error: "No blocks found in ledger"
+    };
+  }
+  const blocksToDelete = blocks.filter((block) => blockDates.includes(block.date));
+  const remainingBlocks = blocks.filter((block) => !blockDates.includes(block.date));
+  if (blocksToDelete.length === 0) {
+    return {
+      success: false,
+      deletedBlocks: 0,
+      error: "No matching blocks found for the specified dates"
+    };
+  }
+  const integrityIssue = checkChainIntegrityAfterDeletion(blocks, blockDates);
+  if (integrityIssue) {
+    return {
+      success: false,
+      deletedBlocks: 0,
+      error: `Cannot delete blocks: ${integrityIssue}`
+    };
+  }
+  try {
+    const repairedChain = repairChainAfterDeletion(remainingBlocks);
+    await saveLedger(repairedChain, projectDir);
+    await cleanupSharedStorage(blockDates, projectDir);
+    return {
+      success: true,
+      deletedBlocks: blocksToDelete.length,
+      warning: remainingBlocks.length === 0 ? "All blocks have been deleted. Ledger is now empty." : void 0
+    };
+  } catch (error) {
+    return {
+      success: false,
+      deletedBlocks: 0,
+      error: `Failed to delete blocks: ${error instanceof Error ? error.message : "Unknown error"}`
+    };
+  }
+}
+async function deleteAllBlocks(workDir, confirmDeletion = false) {
+  if (!confirmDeletion) {
+    return {
+      success: false,
+      deletedBlocks: 0,
+      error: "Deletion not confirmed. This will permanently delete ALL blocks and cannot be undone."
+    };
+  }
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const blocks = await loadLedger(projectDir);
+  if (blocks.length === 0) {
+    return {
+      success: true,
+      deletedBlocks: 0,
+      warning: "Ledger is already empty"
+    };
+  }
+  try {
+    await saveLedger([], projectDir);
+    await cleanupAllSharedStorage(projectDir);
+    return {
+      success: true,
+      deletedBlocks: blocks.length,
+      warning: "All blocks have been permanently deleted. Ledger is now empty."
+    };
+  } catch (error) {
+    return {
+      success: false,
+      deletedBlocks: 0,
+      error: `Failed to delete all blocks: ${error instanceof Error ? error.message : "Unknown error"}`
+    };
+  }
+}
+function checkChainIntegrityAfterDeletion(blocks, datesToDelete) {
+  const sortedBlocks = blocks.sort((a, b) => a.date.localeCompare(b.date));
+  const deleteIndices = /* @__PURE__ */ new Set();
+  sortedBlocks.forEach((block, index) => {
+    if (datesToDelete.includes(block.date)) {
+      deleteIndices.add(index);
+    }
+  });
+  if (deleteIndices.has(0) && sortedBlocks.length > 1) {
+    return "Cannot delete the genesis block when other blocks exist. This would break the chain.";
+  }
+  for (let i = 1; i < sortedBlocks.length; i++) {
+    const currentBlock = sortedBlocks[i];
+    const previousBlock = sortedBlocks[i - 1];
+    if (!deleteIndices.has(i) && deleteIndices.has(i - 1)) {
+      let lastValidIndex = i - 2;
+      while (lastValidIndex >= 0 && deleteIndices.has(lastValidIndex)) {
+        lastValidIndex--;
+      }
+      if (lastValidIndex >= 0) {
+        const expectedPreviousHash = sortedBlocks[lastValidIndex].blockHash;
+        if (currentBlock.previousHash !== expectedPreviousHash) {
+          return `Deleting block ${previousBlock.date} would break the chain. Block ${currentBlock.date} references it.`;
+        }
+      }
+    }
+  }
+  return null;
+}
+function repairChainAfterDeletion(remainingBlocks) {
+  if (remainingBlocks.length === 0) {
+    return [];
+  }
+  const sortedBlocks = remainingBlocks.sort((a, b) => a.date.localeCompare(b.date));
+  for (let i = 0; i < sortedBlocks.length; i++) {
+    const block = sortedBlocks[i];
+    const previousHash = i === 0 ? GENESIS_HASH : sortedBlocks[i - 1].blockHash;
+    block.previousHash = previousHash;
+    block.blockHash = computeBlockHash(
+      block.previousHash,
+      block.merkleRoot,
+      block.date,
+      block.version
+    );
+    block.chainHeight = i;
+    block.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  return sortedBlocks;
+}
+async function cleanupSharedStorage(deletedDates, projectDir) {
+  const manifest = await loadManifest(projectDir);
+  if (!manifest) return;
+  const activeDir = getActiveBlocksDir(projectDir);
+  const archivedDir = getArchivedBlocksDir(projectDir);
+  for (const date of deletedDates) {
+    const blockFile = `${date}.json`;
+    const blockPath = join2(activeDir, blockFile);
+    if (existsSync3(blockPath)) {
+      try {
+        await unlink(blockPath);
+      } catch {
+      }
+    }
+    const index = manifest.activeBlocks.indexOf(blockFile);
+    if (index > -1) {
+      manifest.activeBlocks.splice(index, 1);
+    }
+    delete manifest.index.byDate[date];
+  }
+  manifest.totalBlocks = manifest.activeBlocks.length + manifest.archivedBlocks.length;
+  await saveManifest(manifest, projectDir);
+}
+async function cleanupAllSharedStorage(projectDir) {
+  const sharedDir = getSharedLedgerDir(projectDir);
+  if (existsSync3(sharedDir)) {
+    try {
+      const manifest = await createDefaultManifest(projectDir);
+      await saveManifest(manifest, projectDir);
+      const activeDir = getActiveBlocksDir(projectDir);
+      if (existsSync3(activeDir)) {
+        const files = await readdir(activeDir).catch(() => []);
+        for (const file of files) {
+          if (file.endsWith(".json")) {
+            try {
+              await unlink(join2(activeDir, file));
+            } catch {
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+}
+
+// src/memory/issue-store.ts
+async function storeIssues(issues, project, workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const memoryDir = join3(getTrieDirectory(projectDir), "memory");
+  await mkdir3(memoryDir, { recursive: true });
+  const stored = [];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const seenHashes = /* @__PURE__ */ new Set();
+  let duplicates = 0;
+  for (const issue of issues) {
+    const hash = hashIssue(issue);
+    if (seenHashes.has(hash)) {
+      duplicates++;
+      continue;
+    }
+    seenHashes.add(hash);
+    const storedIssue = {
+      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,
+      resolvedAt: void 0
+    };
+    stored.push(storedIssue);
+  }
+  await appendToDailyLog(stored, projectDir);
+  await appendIssuesToLedger(stored, projectDir);
+  const dedupedCount = await updateIssueIndex(stored, projectDir);
+  return { stored: dedupedCount, duplicates: duplicates + (stored.length - dedupedCount) };
+}
+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 searchOptions = {
+    limit: (options.limit || 5) + 5,
+    // Get extra to account for filtering
+    includeResolved: true
+  };
+  if (options.workDir !== void 0) {
+    searchOptions.workDir = options.workDir;
+  }
+  const results = await searchIssues(query, searchOptions);
+  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 autoResolveIssues(newIssueHashes, scannedFiles, workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const index = await loadIssueIndex(projectDir);
+  const scannedFileSet = new Set(scannedFiles.map((f) => f.replace(/\\/g, "/")));
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let resolvedCount = 0;
+  let stillActiveCount = 0;
+  for (const issue of index) {
+    if (issue.resolved) continue;
+    const normalizedFile = issue.file.replace(/\\/g, "/");
+    if (!scannedFileSet.has(normalizedFile)) {
+      stillActiveCount++;
+      continue;
+    }
+    if (!newIssueHashes.has(issue.hash)) {
+      issue.resolved = true;
+      issue.resolvedAt = now;
+      resolvedCount++;
+    } else {
+      stillActiveCount++;
+    }
+  }
+  if (resolvedCount > 0) {
+    await saveIssueIndex(index, projectDir);
+  }
+  return { resolved: resolvedCount, stillActive: stillActiveCount };
+}
+async function resolveGoalViolation(file, goalDescription, workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const index = await loadIssueIndex(projectDir);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let resolvedCount = 0;
+  for (const issue of index) {
+    if (issue.resolved) continue;
+    if (issue.agent !== "goal-violation") continue;
+    const normalizedFile = issue.file.replace(/\\/g, "/");
+    const normalizedTarget = file.replace(/\\/g, "/");
+    if (normalizedFile === normalizedTarget && issue.issue.includes(`Goal "${goalDescription}"`)) {
+      issue.resolved = true;
+      issue.resolvedAt = now;
+      resolvedCount++;
+    }
+  }
+  if (resolvedCount > 0) {
+    await saveIssueIndex(index, projectDir);
+  }
+  return resolvedCount;
+}
+function getIssueHash(issue) {
+  return hashIssue(issue);
+}
+async function getMemoryStats(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const index = await loadIssueIndex(projectDir);
+  const historical = await getHistoricalInsights(projectDir);
+  const MAX_ISSUES = 1e4;
+  const uniqueHashes = new Set(index.map((i) => i.hash));
+  const stats = {
+    totalIssues: index.length,
+    activeIssues: 0,
+    issuesByAgent: {},
+    issuesBySeverity: {},
+    activeIssuesBySeverity: {},
+    oldestIssue: void 0,
+    newestIssue: void 0,
+    resolvedCount: 0,
+    historicalIssues: historical.totalHistoricalIssues,
+    improvementTrend: historical.improvementTrend,
+    capacityInfo: {
+      current: index.length,
+      max: MAX_ISSUES,
+      percentFull: Math.round(index.length / MAX_ISSUES * 100),
+      isAtCap: index.length >= MAX_ISSUES
+    },
+    deduplicationStats: {
+      duplicatesAvoided: index.length - uniqueHashes.size,
+      uniquePatterns: uniqueHashes.size
+    }
+  };
+  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++;
+    } else {
+      stats.activeIssues++;
+      stats.activeIssuesBySeverity[issue.severity] = (stats.activeIssuesBySeverity[issue.severity] || 0) + 1;
+    }
+  }
+  if (index.length > 0) {
+    const sorted = [...index].sort(
+      (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+    );
+    const oldest = sorted[0]?.timestamp;
+    const newest = sorted[sorted.length - 1]?.timestamp;
+    if (oldest !== void 0) {
+      stats.oldestIssue = oldest;
+    }
+    if (newest !== void 0) {
+      stats.newestIssue = newest;
+    }
+  }
+  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 includeResolved = options.includeResolved ?? false;
+  const cutoff = /* @__PURE__ */ new Date();
+  cutoff.setDate(cutoff.getDate() - daysBack);
+  return index.filter((i) => {
+    if (new Date(i.timestamp) < cutoff) return false;
+    if (!includeResolved && i.resolved) return false;
+    return true;
+  }).sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()).slice(0, limit);
+}
+async function purgeIssues(strategy, options = {}) {
+  const projectDir = options.workDir || getWorkingDirectory(void 0, true);
+  const index = await loadIssueIndex(projectDir);
+  const originalCount = index.length;
+  let remaining = [];
+  switch (strategy) {
+    case "smart":
+      const thirtyDaysAgo = /* @__PURE__ */ new Date();
+      thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+      remaining = index.filter((i) => {
+        const isRecent = new Date(i.timestamp) >= thirtyDaysAgo;
+        const isImportant = ["critical", "high"].includes(i.severity);
+        const isUnresolved = !i.resolved;
+        return isRecent || isImportant || isUnresolved;
+      });
+      break;
+    case "resolved":
+      remaining = index.filter((i) => !i.resolved);
+      break;
+    case "old":
+      const daysOld = options.daysOld || 90;
+      const cutoffDate = /* @__PURE__ */ new Date();
+      cutoffDate.setDate(cutoffDate.getDate() - daysOld);
+      remaining = index.filter((i) => new Date(i.timestamp) >= cutoffDate);
+      break;
+    case "all":
+      remaining = [];
+      break;
+  }
+  await saveIssueIndex(remaining, projectDir);
+  return {
+    removed: originalCount - remaining.length,
+    remaining: remaining.length,
+    strategy
+  };
+}
+async function getDailyLogs(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const memoryDir = join3(getTrieDirectory(projectDir), "memory");
+  try {
+    if (!existsSync4(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 = join3(getTrieDirectory(projectDir), "memory");
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const logPath = join3(memoryDir, `${today}.md`);
+  let content = "";
+  try {
+    if (existsSync4(logPath)) {
+      content = await readFile3(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 writeFile2(logPath, content);
+}
+async function loadIssueIndex(projectDir) {
+  const indexPath = join3(getTrieDirectory(projectDir), "memory", "issues.json");
+  try {
+    if (existsSync4(indexPath)) {
+      const content = await readFile3(indexPath, "utf-8");
+      const result = safeParseAndValidate(content, IssueIndexSchema);
+      if (result.success) {
+        return result.data;
+      }
+      console.error(`   Issue index corrupted: ${result.error}`);
+      const backupManager = new BackupManager(indexPath);
+      if (await backupManager.recoverFromBackup()) {
+        console.error("   \u2705 Recovered from backup");
+        const recovered = await readFile3(indexPath, "utf-8");
+        const recoveredResult = safeParseAndValidate(recovered, IssueIndexSchema);
+        if (recoveredResult.success) {
+          return recoveredResult.data;
+        }
+      }
+      console.error("   No valid backup found, starting fresh");
+    }
+  } catch {
+  }
+  return [];
+}
+async function updateIssueIndex(newIssues, projectDir) {
+  const memoryDir = join3(getTrieDirectory(projectDir), "memory");
+  await mkdir3(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));
+  const dedupedCount = toAdd.length;
+  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 > 1e4) {
+    existing = intelligentPrune(existing, 1e4);
+  }
+  await saveIssueIndex(existing, projectDir);
+  return dedupedCount;
+}
+function intelligentPrune(issues, targetCount) {
+  const severityWeight = {
+    critical: 100,
+    high: 50,
+    moderate: 20,
+    low: 10,
+    info: 5
+  };
+  const scored = issues.map((issue) => {
+    const ageInDays = (Date.now() - new Date(issue.timestamp).getTime()) / (1e3 * 60 * 60 * 24);
+    const recencyScore = Math.max(0, 100 - ageInDays * 2);
+    const severityScore = severityWeight[issue.severity] || 10;
+    const resolvedPenalty = issue.resolved ? -50 : 0;
+    return {
+      issue,
+      score: recencyScore + severityScore + resolvedPenalty
+    };
+  });
+  return scored.sort((a, b) => b.score - a.score).slice(0, targetCount).map((s) => s.issue);
+}
+async function saveIssueIndex(issues, projectDir) {
+  const memoryDir = join3(getTrieDirectory(projectDir), "memory");
+  await mkdir3(memoryDir, { recursive: true });
+  const indexPath = join3(memoryDir, "issues.json");
+  const backupManager = new BackupManager(indexPath);
+  await backupManager.createBackup();
+  await atomicWriteJSON(indexPath, issues);
+}
+function hashIssue(issue) {
+  const content = `${issue.issue}|${issue.file}|${issue.severity}|${issue.agent}`;
+  return createHash2("sha256").update(content).digest("hex").slice(0, 16);
+}
+
+export {
+  getHistoricalInsights,
+  formatAuditLog,
+  getAuditStatistics,
+  getRecentAuditLogs,
+  getSkillAuditLogs,
+  runShellCommandSync,
+  getRecentCommits,
+  getStagedChanges,
+  getUncommittedChanges,
+  getGitChangedFiles,
+  getDiff,
+  getWorkingTreeDiff,
+  isGitRepo,
+  getChangedFilesSinceTimestamp,
+  verifyLedger,
+  getLedgerBlocks,
+  initializeSharedLedger,
+  syncLedgerFromShared,
+  pushLedgerToShared,
+  migrateLegacyLedger,
+  detectLegacyLedger,
+  getLedgerSyncStatus,
+  compressOldBlocks,
+  getStorageStats,
+  shouldCompress,
+  deleteBlocks,
+  deleteAllBlocks,
+  storeIssues,
+  searchIssues,
+  findSimilarIssues,
+  markIssueResolved,
+  autoResolveIssues,
+  resolveGoalViolation,
+  getIssueHash,
+  getMemoryStats,
+  getRecentIssues,
+  purgeIssues,
+  getDailyLogs
+};
+//# sourceMappingURL=chunk-62POBLFC.js.map