@triedotdev/mcp 1.0.148 → 1.0.151

package/dist/{chunk-62POBLFC.js → chunk-TWPX6PHF.js}

@@ -1,422 +1,29 @@
-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
-  };
-}
+} from "./chunk-4TQQP7JD.js";
 
 // 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 { mkdir, readFile, writeFile, stat, unlink } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
 import { createGzip, createGunzip } from "zlib";
 import { pipeline } from "stream/promises";
 import { createReadStream, createWriteStream } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 
 // src/agent/git.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync } 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
+// src/utils/audit-logger.ts
 function formatAuditLog(_entry) {
   return "Audit logging has been integrated into the decision ledger";
 }
@@ -464,9 +71,6 @@ async function logSkillExecution(_execution) {
 async function getRecentAuditLogs(_limit = 10) {
   return [];
 }
-async function getSkillAuditLogs(_skillName) {
-  return [];
-}
 
 // src/utils/command-runner.ts
 var execAsync = promisify(exec);
@@ -712,6 +316,176 @@ async function getChangedFilesSinceTimestamp(projectPath, timestamp) {
   }
 }
 
+// src/memory/crypto-keys.ts
+import * as ed25519 from "@noble/ed25519";
+import { randomBytes } from "crypto";
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+function getKeysDirectory(workDir) {
+  const trieDir = getTrieDirectory(workDir || process.cwd());
+  return join(trieDir, "keys");
+}
+function getDefaultKeyPath(workDir) {
+  return join(getKeysDirectory(workDir), "signing-key.json");
+}
+async function generateKeyPair() {
+  const privateKeyBytes = randomBytes(32);
+  const publicKeyBytes = await ed25519.getPublicKeyAsync(privateKeyBytes);
+  return {
+    publicKey: Buffer.from(publicKeyBytes).toString("hex"),
+    privateKey: Buffer.from(privateKeyBytes).toString("hex")
+  };
+}
+function saveKeyPair(keyPair, workDir) {
+  const keysDir = getKeysDirectory(workDir);
+  if (!existsSync2(keysDir)) {
+    mkdirSync(keysDir, { recursive: true });
+  }
+  const keyPath = getDefaultKeyPath(workDir);
+  const keyData = {
+    ...keyPair,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    version: 1
+  };
+  writeFileSync(keyPath, JSON.stringify(keyData, null, 2), "utf-8");
+  console.error("\u26A0\uFE0F  Signing key created at:", keyPath);
+  console.error("    Keep this file secure and add to .gitignore");
+}
+function loadKeyPair(workDir) {
+  const keyPath = getDefaultKeyPath(workDir);
+  if (!existsSync2(keyPath)) {
+    return null;
+  }
+  try {
+    const keyData = JSON.parse(readFileSync(keyPath, "utf-8"));
+    return {
+      publicKey: keyData.publicKey,
+      privateKey: keyData.privateKey
+    };
+  } catch (error) {
+    console.error("Failed to load signing key:", error);
+    return null;
+  }
+}
+async function getOrCreateKeyPair(workDir) {
+  const existing = loadKeyPair(workDir);
+  if (existing) {
+    return existing;
+  }
+  const newKeyPair = await generateKeyPair();
+  saveKeyPair(newKeyPair, workDir);
+  return newKeyPair;
+}
+async function signData(data, privateKey) {
+  const dataBytes = Buffer.from(data, "utf-8");
+  const privateKeyBytes = Buffer.from(privateKey, "hex");
+  const signatureBytes = await ed25519.signAsync(dataBytes, privateKeyBytes);
+  return Buffer.from(signatureBytes).toString("hex");
+}
+async function verifySignature(data, signature, publicKey) {
+  try {
+    const dataBytes = Buffer.from(data, "utf-8");
+    const signatureBytes = Buffer.from(signature, "hex");
+    const publicKeyBytes = Buffer.from(publicKey, "hex");
+    return await ed25519.verifyAsync(signatureBytes, dataBytes, publicKeyBytes);
+  } catch (error) {
+    console.error("Signature verification failed:", error);
+    return false;
+  }
+}
+async function signHash(hash, workDir) {
+  const keyPair = await getOrCreateKeyPair(workDir);
+  const signature = await signData(hash, keyPair.privateKey);
+  return {
+    signature,
+    publicKey: keyPair.publicKey,
+    algorithm: "Ed25519",
+    signedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function verifyHashSignature(hash, signatureData) {
+  if (signatureData.algorithm !== "Ed25519") {
+    console.error("Unsupported signature algorithm:", signatureData.algorithm);
+    return false;
+  }
+  return await verifySignature(hash, signatureData.signature, signatureData.publicKey);
+}
+function hasSigningKey(workDir) {
+  const keyPath = getDefaultKeyPath(workDir);
+  return existsSync2(keyPath);
+}
+
+// src/memory/git-integration.ts
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { existsSync as existsSync3 } from "fs";
+import { join as join2 } from "path";
+var execAsync2 = promisify2(exec2);
+async function isGitIntegrationEnabled(workDir) {
+  try {
+    const gitDir = join2(workDir, ".git");
+    if (!existsSync3(gitDir)) {
+      return false;
+    }
+    const configPath = join2(getTrieDirectory(workDir), "config.json");
+    if (!existsSync3(configPath)) {
+      return true;
+    }
+    const config = JSON.parse(await import("fs/promises").then((fs) => fs.readFile(configPath, "utf-8")));
+    return config.gitIntegration !== false;
+  } catch {
+    return false;
+  }
+}
+async function autoCommitLedger(workDir, message) {
+  try {
+    const enabled = await isGitIntegrationEnabled(workDir);
+    if (!enabled) {
+      return { committed: false, error: "Git integration disabled" };
+    }
+    const ledgerPath = join2(getTrieDirectory(workDir), "memory", "ledger.json");
+    const { stdout: statusOutput } = await execAsync2("git status --porcelain", { cwd: workDir });
+    const hasLedgerChanges = statusOutput.includes("ledger.json");
+    if (!hasLedgerChanges) {
+      return { committed: false, error: "No ledger changes to commit" };
+    }
+    await execAsync2(`git add ${ledgerPath}`, { cwd: workDir });
+    const commitMessage = message || "ledger: append entries";
+    await execAsync2(
+      `git commit -m "${commitMessage}"`,
+      { cwd: workDir }
+    );
+    const { stdout: hashOutput } = await execAsync2("git rev-parse HEAD", { cwd: workDir });
+    const commitHash = hashOutput.trim();
+    return {
+      committed: true,
+      commitHash
+    };
+  } catch (error) {
+    return {
+      committed: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function ensureKeysIgnored(workDir) {
+  try {
+    const gitignorePath = join2(workDir, ".gitignore");
+    const fs = await import("fs/promises");
+    let gitignore = "";
+    if (existsSync3(gitignorePath)) {
+      gitignore = await fs.readFile(gitignorePath, "utf-8");
+    }
+    if (gitignore.includes(".trie/keys/")) {
+      return;
+    }
+    const addition = "\n# Trie signing keys (keep secure, do not commit)\n.trie/keys/\n";
+    await fs.appendFile(gitignorePath, addition, "utf-8");
+  } catch (error) {
+    console.error("Failed to update .gitignore:", error);
+  }
+}
+
 // src/memory/ledger.ts
 var LEDGER_FILENAME = "ledger.json";
 var SHARED_LEDGER_DIR = ".trie-shared";
@@ -719,25 +493,74 @@ 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 signLedgerEntry(entry, workDir) {
+  try {
+    const signatureData = await signHash(entry.hash, workDir);
+    return {
+      ...entry,
+      signature: signatureData.signature,
+      publicKey: signatureData.publicKey,
+      signedAt: signatureData.signedAt,
+      signatureAlgorithm: "Ed25519"
+    };
+  } catch (error) {
+    console.error("Failed to sign ledger entry:", error);
+    return entry;
+  }
+}
+async function verifyLedgerEntry(entry) {
+  if (!entry.signature || !entry.publicKey) {
+    return true;
+  }
+  if (entry.signatureAlgorithm !== "Ed25519") {
+    console.error("Unsupported signature algorithm:", entry.signatureAlgorithm);
+    return false;
+  }
+  const signatureData = {
+    signature: entry.signature,
+    publicKey: entry.publicKey,
+    algorithm: "Ed25519",
+    signedAt: entry.signedAt || ""
+  };
+  return await verifyHashSignature(entry.hash, signatureData);
+}
+async function verifyBlockSignatures(block) {
+  const invalidEntries = [];
+  for (const entry of block.entries) {
+    const isValid = await verifyLedgerEntry(entry);
+    if (!isValid) {
+      invalidEntries.push(entry.id);
+    }
+  }
+  return {
+    valid: invalidEntries.length === 0,
+    invalidEntries
+  };
+}
 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 memoryDir = join3(getTrieDirectory(projectDir), "memory");
+  await mkdir(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) => ({
+  const shouldSign = hasSigningKey(projectDir);
+  let entries = issues.map((issue) => ({
     id: issue.id,
     hash: issue.hash,
     severity: issue.severity,
     file: issue.file,
     agent: issue.agent,
-    timestamp: issue.timestamp
+    timestamp: issue.timestamp,
+    status: "active"
   }));
+  if (shouldSign) {
+    entries = await Promise.all(entries.map((entry) => signLedgerEntry(entry, projectDir)));
+  }
   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) {
@@ -748,6 +571,11 @@ async function appendIssuesToLedger(issues, workDir, author) {
   block.blockHash = computeBlockHash(block.previousHash, block.merkleRoot, block.date, block.version);
   block.updatedAt = now;
   await saveLedger(blocks, projectDir);
+  if (await isGitRepo(projectDir)) {
+    await ensureKeysIgnored(projectDir);
+    const commitMessage = `ledger: append ${entries.length} ${entries.length === 1 ? "entry" : "entries"}`;
+    await autoCommitLedger(projectDir, commitMessage);
+  }
   return block;
 }
 async function verifyLedger(workDir) {
@@ -774,7 +602,14 @@ async function verifyLedger(workDir) {
     }
     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: false, error: `Block ${i} block hash mismatch` };
+    }
+    const signatureVerification = await verifyBlockSignatures(block);
+    if (!signatureVerification.valid) {
+      return {
+        valid: false,
+        error: `Block ${i} has invalid signatures: ${signatureVerification.invalidEntries.join(", ")}`
+      };
     }
   }
   return { valid: true };
@@ -809,15 +644,15 @@ function createSyncableBlock(date, now, previousHash, author, gitCommit, chainHe
     createdAt: now,
     updatedAt: now,
     author,
-    gitCommit,
-    chainHeight
+    chainHeight,
+    ...gitCommit && { gitCommit }
   };
 }
 async function loadLedger(projectDir) {
-  const ledgerPath = join2(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
+  const ledgerPath = join3(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
   try {
-    if (!existsSync3(ledgerPath)) return [];
-    const content = await readFile2(ledgerPath, "utf-8");
+    if (!existsSync4(ledgerPath)) return [];
+    const content = await readFile(ledgerPath, "utf-8");
     const parsed = JSON.parse(content);
     if (!Array.isArray(parsed)) return [];
     return parsed;
@@ -830,40 +665,40 @@ async function getLedgerBlocks(workDir) {
   return loadLedger(projectDir);
 }
 async function saveLedger(blocks, projectDir) {
-  const ledgerPath = join2(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
+  const ledgerPath = join3(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);
+  return join3(projectDir, SHARED_LEDGER_DIR);
 }
 function getActiveBlocksDir(projectDir) {
-  return join2(getSharedLedgerDir(projectDir), "active");
+  return join3(getSharedLedgerDir(projectDir), "active");
 }
 function getArchivedBlocksDir(projectDir) {
-  return join2(getSharedLedgerDir(projectDir), "archived");
+  return join3(getSharedLedgerDir(projectDir), "archived");
 }
 function getManifestPath(projectDir) {
-  return join2(getSharedLedgerDir(projectDir), MANIFEST_FILENAME);
+  return join3(getSharedLedgerDir(projectDir), MANIFEST_FILENAME);
 }
 function getSyncStatePath(projectDir) {
-  return join2(getTrieDirectory(projectDir), "memory", SYNC_STATE_FILENAME);
+  return join3(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 });
+  await mkdir(sharedDir, { recursive: true });
+  await mkdir(activeDir, { recursive: true });
+  await mkdir(archivedDir, { recursive: true });
 }
 async function loadManifest(projectDir) {
   const manifestPath = getManifestPath(projectDir);
   try {
-    if (!existsSync3(manifestPath)) return null;
-    const content = await readFile2(manifestPath, "utf-8");
+    if (!existsSync4(manifestPath)) return null;
+    const content = await readFile(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -873,7 +708,7 @@ async function saveManifest(manifest, projectDir) {
   const manifestPath = getManifestPath(projectDir);
   await atomicWriteJSON(manifestPath, manifest);
 }
-async function createDefaultManifest(projectDir) {
+async function createDefaultManifest(_projectDir) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
     version: LEDGER_VERSION,
@@ -900,8 +735,8 @@ async function createDefaultManifest(projectDir) {
 async function loadSyncState(projectDir) {
   const syncStatePath = getSyncStatePath(projectDir);
   try {
-    if (!existsSync3(syncStatePath)) return null;
-    const content = await readFile2(syncStatePath, "utf-8");
+    if (!existsSync4(syncStatePath)) return null;
+    const content = await readFile(syncStatePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -909,8 +744,8 @@ async function loadSyncState(projectDir) {
 }
 async function saveSyncState(syncState, projectDir) {
   const syncStatePath = getSyncStatePath(projectDir);
-  const memoryDir = join2(getTrieDirectory(projectDir), "memory");
-  await mkdir2(memoryDir, { recursive: true });
+  const memoryDir = join3(getTrieDirectory(projectDir), "memory");
+  await mkdir(memoryDir, { recursive: true });
   await atomicWriteJSON(syncStatePath, syncState);
 }
 async function initializeSharedLedger(workDir) {
@@ -961,16 +796,17 @@ async function pushLedgerToShared(workDir) {
   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) {
+    const blockPath = join3(activeDir, blockFilename);
+    if (!existsSync4(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] = [];
+      const blockAuthor = block.author;
+      if (blockAuthor) {
+        if (!manifest.index.byAuthor[blockAuthor]) {
+          manifest.index.byAuthor[blockAuthor] = [];
         }
-        if (!manifest.index.byAuthor[block.author].includes(`active/${blockFilename}`)) {
-          manifest.index.byAuthor[block.author].push(`active/${blockFilename}`);
+        if (!manifest.index.byAuthor[blockAuthor].includes(`active/${blockFilename}`)) {
+          manifest.index.byAuthor[blockAuthor].push(`active/${blockFilename}`);
         }
       }
       if (!manifest.activeBlocks.includes(blockFilename)) {
@@ -989,10 +825,10 @@ async function loadSharedBlocks(projectDir) {
   const blocks = [];
   const activeDir = getActiveBlocksDir(projectDir);
   for (const filename of manifest.activeBlocks) {
-    const blockPath = join2(activeDir, filename);
+    const blockPath = join3(activeDir, filename);
     try {
-      if (existsSync3(blockPath)) {
-        const content = await readFile2(blockPath, "utf-8");
+      if (existsSync4(blockPath)) {
+        const content = await readFile(blockPath, "utf-8");
         const block = JSON.parse(content);
         blocks.push(block);
       }
@@ -1063,8 +899,6 @@ function detectBlockConflict(localBlock, remoteBlock) {
       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
@@ -1124,8 +958,8 @@ function mergeBlockEntries(localBlock, remoteBlock) {
 }
 async function migrateLegacyLedger(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const legacyLedgerPath = join2(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
-  if (!existsSync3(legacyLedgerPath)) {
+  const legacyLedgerPath = join3(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
+  if (!existsSync4(legacyLedgerPath)) {
     return false;
   }
   try {
@@ -1141,9 +975,9 @@ async function migrateLegacyLedger(workDir) {
       ...block,
       version: LEDGER_VERSION,
       author: defaultAuthor,
-      gitCommit: lastCommit?.hash,
       chainHeight: index,
-      syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+      syncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...lastCommit?.hash && { gitCommit: lastCommit.hash }
     }));
     await initializeSharedLedger(projectDir);
     await saveLedger(migratedBlocks, projectDir);
@@ -1159,8 +993,8 @@ async function migrateLegacyLedger(workDir) {
 }
 async function detectLegacyLedger(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const legacyLedgerPath = join2(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
-  if (!existsSync3(legacyLedgerPath)) {
+  const legacyLedgerPath = join3(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
+  if (!existsSync4(legacyLedgerPath)) {
     return false;
   }
   try {
@@ -1202,7 +1036,6 @@ async function compressOldBlocks(workDir) {
   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);
@@ -1213,18 +1046,18 @@ async function compressOldBlocks(workDir) {
     }
   }
   for (const [monthKey, blockFiles] of blocksByMonth) {
-    const archivePath = join2(archivedDir, `${monthKey}.tar.gz`);
-    if (existsSync3(archivePath)) {
+    const archivePath = join3(archivedDir, `${monthKey}.tar.gz`);
+    if (existsSync4(archivePath)) {
       continue;
     }
     console.log(`Archiving ${blockFiles.length} blocks for ${monthKey}...`);
     const monthlyBlocks = [];
     for (const blockFile of blockFiles) {
-      const blockPath = join2(activeDir, blockFile);
+      const blockPath = join3(activeDir, blockFile);
       try {
         const stats = await stat(blockPath);
         originalSize += stats.size;
-        const content = await readFile2(blockPath, "utf-8");
+        const content = await readFile(blockPath, "utf-8");
         const block = JSON.parse(content);
         monthlyBlocks.push(block);
       } catch (error) {
@@ -1241,10 +1074,10 @@ async function compressOldBlocks(workDir) {
       );
       const compressedStats = await stat(tempPath);
       compressedSize += compressedStats.size;
-      await writeFile(archivePath, await readFile2(tempPath));
+      await writeFile(archivePath, await readFile(tempPath));
       await unlink(tempPath);
       for (const blockFile of blockFiles) {
-        const blockPath = join2(activeDir, blockFile);
+        const blockPath = join3(activeDir, blockFile);
         await unlink(blockPath);
         const index = manifest.activeBlocks.indexOf(blockFile);
         if (index > -1) {
@@ -1263,6 +1096,31 @@ async function compressOldBlocks(workDir) {
     sizeReduction: originalSize > 0 ? Math.round((originalSize - compressedSize) / originalSize * 100) : 0
   };
 }
+async function loadArchivedBlocks(projectDir, monthKey) {
+  const archivedDir = getArchivedBlocksDir(projectDir);
+  const archivePath = join3(archivedDir, `${monthKey}.tar.gz`);
+  if (!existsSync4(archivePath)) {
+    return [];
+  }
+  try {
+    const chunks = [];
+    await pipeline(
+      createReadStream(archivePath),
+      createGunzip(),
+      async function* (source) {
+        for await (const chunk of source) {
+          chunks.push(chunk);
+        }
+        yield Buffer.concat(chunks);
+      }
+    );
+    const decompressedData = Buffer.concat(chunks).toString("utf-8");
+    return JSON.parse(decompressedData);
+  } catch (error) {
+    console.error(`Failed to load archived blocks for ${monthKey}:`, error);
+    return [];
+  }
+}
 async function getStorageStats(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
   const manifest = await loadManifest(projectDir);
@@ -1281,9 +1139,9 @@ async function getStorageStats(workDir) {
   let activeSize = 0;
   let archivedSize = 0;
   for (const blockFile of manifest.activeBlocks) {
-    const blockPath = join2(activeDir, blockFile);
+    const blockPath = join3(activeDir, blockFile);
     try {
-      if (existsSync3(blockPath)) {
+      if (existsSync4(blockPath)) {
         const stats = await stat(blockPath);
         activeSize += stats.size;
       }
@@ -1291,16 +1149,15 @@ async function getStorageStats(workDir) {
     }
   }
   for (const archiveFile of manifest.archivedBlocks) {
-    const archivePath = join2(archivedDir, archiveFile);
+    const archivePath = join3(archivedDir, archiveFile);
     try {
-      if (existsSync3(archivePath)) {
+      if (existsSync4(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 {
@@ -1328,566 +1185,179 @@ async function shouldCompress(workDir) {
   });
   return exceedsSize || hasOldBlocks;
 }
-async function deleteBlocks(blockDates, workDir, confirmDeletion = false) {
-  if (!confirmDeletion) {
+async function correctLedgerEntries(entryIds, reason, correctionType = "corrected", workDir, author) {
+  if (entryIds.length === 0) {
     return {
       success: false,
-      deletedBlocks: 0,
-      error: "Deletion not confirmed. This is a permanent operation that cannot be undone."
+      correctedEntries: 0,
+      error: "No entry IDs provided"
     };
   }
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const blocks = await loadLedger(projectDir);
-  if (blocks.length === 0) {
+  if (!reason || reason.trim().length === 0) {
     return {
       success: false,
-      deletedBlocks: 0,
-      error: "No blocks found in ledger"
+      correctedEntries: 0,
+      error: "Correction reason is required"
     };
   }
-  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 projectDir = workDir || getWorkingDirectory(void 0, true);
+  const blocks = await loadLedger(projectDir);
+  const entriesToCorrect = [];
+  for (const block of blocks) {
+    for (const entry of block.entries) {
+      if (entryIds.includes(entry.id) && entry.status === "active") {
+        entriesToCorrect.push(entry);
+      }
+    }
   }
-  const integrityIssue = checkChainIntegrityAfterDeletion(blocks, blockDates);
-  if (integrityIssue) {
+  if (entriesToCorrect.length === 0) {
     return {
       success: false,
-      deletedBlocks: 0,
-      error: `Cannot delete blocks: ${integrityIssue}`
+      correctedEntries: 0,
+      error: "No active entries found with the provided IDs"
     };
   }
   try {
-    const repairedChain = repairChainAfterDeletion(remainingBlocks);
-    await saveLedger(repairedChain, projectDir);
-    await cleanupSharedStorage(blockDates, projectDir);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const isRepo = await isGitRepo(projectDir);
+    const lastCommit = isRepo ? await getLastCommit(projectDir) : null;
+    const correctionAuthor = author || lastCommit?.author || "unknown";
+    const correctionEntries = entriesToCorrect.map((entry) => {
+      const correctionId = `correction-${entry.id}-${Date.now()}`;
+      return {
+        id: correctionId,
+        hash: sha256(`${correctionId}:${entry.hash}:${reason}:${now}`),
+        severity: "info",
+        file: entry.file,
+        agent: "ledger-correction",
+        timestamp: now,
+        status: "active",
+        correction: `Correcting entry ${entry.id}: ${reason}`,
+        correctedBy: entry.id
+      };
+    });
+    for (const block of blocks) {
+      let blockModified = false;
+      for (const entry of block.entries) {
+        if (entryIds.includes(entry.id) && entry.status === "active") {
+          entry.status = correctionType;
+          entry.correctionTimestamp = now;
+          entry.correction = reason;
+          blockModified = true;
+        }
+      }
+      if (blockModified) {
+        block.merkleRoot = computeMerkleRoot(block.entries.map((e) => e.hash));
+        block.blockHash = computeBlockHash(
+          block.previousHash,
+          block.merkleRoot,
+          block.date,
+          block.version
+        );
+        block.updatedAt = now;
+      }
+    }
+    await saveLedger(blocks, projectDir);
+    const correctionBlock = await appendIssuesToLedger(
+      correctionEntries.map((entry) => ({
+        id: entry.id,
+        hash: entry.hash,
+        severity: entry.severity,
+        issue: entry.correction || "",
+        fix: "",
+        file: entry.file,
+        line: 0,
+        agent: entry.agent,
+        category: "correction",
+        timestamp: entry.timestamp,
+        project: "",
+        resolved: false,
+        resolvedAt: void 0
+      })),
+      projectDir,
+      correctionAuthor
+    );
     return {
       success: true,
-      deletedBlocks: blocksToDelete.length,
-      warning: remainingBlocks.length === 0 ? "All blocks have been deleted. Ledger is now empty." : void 0
+      correctedEntries: entriesToCorrect.length,
+      ...correctionBlock && { correctionBlock }
     };
   } catch (error) {
     return {
       success: false,
-      deletedBlocks: 0,
-      error: `Failed to delete blocks: ${error instanceof Error ? error.message : "Unknown error"}`
+      correctedEntries: 0,
+      error: `Failed to correct entries: ${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."
-    };
-  }
+async function getLedgerEntries(workDir, includeStatus) {
   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.`;
-        }
+  const statusFilter = includeStatus || ["active"];
+  const entries = [];
+  for (const block of blocks) {
+    for (const entry of block.entries) {
+      const entryStatus = entry.status || "active";
+      if (statusFilter.includes(entryStatus)) {
+        entries.push(entry);
       }
     }
   }
-  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;
+  return entries;
 }
-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 {
-            }
-          }
+async function getEntryCorrectionHistory(entryIds, workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const blocks = await loadLedger(projectDir);
+  const history = /* @__PURE__ */ new Map();
+  for (const entryId of entryIds) {
+    const corrections = [];
+    let original = null;
+    for (const block of blocks) {
+      for (const entry of block.entries) {
+        if (entry.id === entryId) {
+          original = entry;
+        }
+        if (entry.correctedBy === entryId) {
+          corrections.push(entry);
         }
       }
-    } 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 (original) {
+      history.set(entryId, { original, corrections });
     }
   }
-  if (resolvedCount > 0) {
-    await saveIssueIndex(index, projectDir);
-  }
-  return resolvedCount;
+  return history;
 }
-function getIssueHash(issue) {
-  return hashIssue(issue);
-}
-async function getMemoryStats(workDir) {
+async function getCorrectionStats(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;
+  const blocks = await loadLedger(projectDir);
+  let totalEntries = 0;
+  let activeEntries = 0;
+  let correctedEntries = 0;
+  let falsePositives = 0;
+  for (const block of blocks) {
+    for (const entry of block.entries) {
+      totalEntries++;
+      const status = entry.status || "active";
+      if (status === "active") activeEntries++;
+      else if (status === "corrected") correctedEntries++;
+      else if (status === "false-positive") falsePositives++;
     }
   }
-  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);
+  const correctionRate = totalEntries > 0 ? (correctedEntries + falsePositives) / totalEntries * 100 : 0;
   return {
-    removed: originalCount - remaining.length,
-    remaining: remaining.length,
-    strategy
+    totalEntries,
+    activeEntries,
+    correctedEntries,
+    falsePositives,
+    correctionRate: Math.round(correctionRate * 100) / 100
   };
 }
-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,
@@ -1897,7 +1367,12 @@ export {
   getWorkingTreeDiff,
   isGitRepo,
   getChangedFilesSinceTimestamp,
+  signLedgerEntry,
+  verifyLedgerEntry,
+  verifyBlockSignatures,
+  appendIssuesToLedger,
   verifyLedger,
+  computeMerkleRoot,
   getLedgerBlocks,
   initializeSharedLedger,
   syncLedgerFromShared,
@@ -1906,20 +1381,12 @@ export {
   detectLegacyLedger,
   getLedgerSyncStatus,
   compressOldBlocks,
+  loadArchivedBlocks,
   getStorageStats,
   shouldCompress,
-  deleteBlocks,
-  deleteAllBlocks,
-  storeIssues,
-  searchIssues,
-  findSimilarIssues,
-  markIssueResolved,
-  autoResolveIssues,
-  resolveGoalViolation,
-  getIssueHash,
-  getMemoryStats,
-  getRecentIssues,
-  purgeIssues,
-  getDailyLogs
+  correctLedgerEntries,
+  getLedgerEntries,
+  getEntryCorrectionHistory,
+  getCorrectionStats
 };
-//# sourceMappingURL=chunk-62POBLFC.js.map
+//# sourceMappingURL=chunk-TWPX6PHF.js.map