@triedotdev/mcp 1.0.149 → 1.0.154

package/dist/{chunk-ZUEAHFSY.js → chunk-HD5H7YSW.js}

@@ -4,16 +4,16 @@ import {
 import {
   getTrieDirectory,
   getWorkingDirectory
-} from "./chunk-SH7H3WRU.js";
+} from "./chunk-7F2R2ITA.js";
 
 // src/memory/ledger.ts
 import { createHash } from "crypto";
 import { mkdir, readFile, writeFile, stat, unlink } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { createGzip, createGunzip } from "zlib";
 import { pipeline } from "stream/promises";
 import { createReadStream, createWriteStream } from "fs";
-import { join } from "path";
+import { join as join3 } from "path";
 
 // src/agent/git.ts
 import { existsSync } from "fs";
@@ -23,7 +23,7 @@ import path from "path";
 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";
 }
@@ -71,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);
@@ -319,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";
@@ -326,10 +493,54 @@ 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 = join(getTrieDirectory(projectDir), "memory");
+  const memoryDir = join3(getTrieDirectory(projectDir), "memory");
   await mkdir(memoryDir, { recursive: true });
   const isRepo = await isGitRepo(projectDir);
   const lastCommit = isRepo ? await getLastCommit(projectDir) : null;
@@ -337,7 +548,8 @@ async function appendIssuesToLedger(issues, workDir, author) {
   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,
@@ -346,6 +558,9 @@ async function appendIssuesToLedger(issues, workDir, author) {
     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) {
@@ -356,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) {
@@ -382,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 };
@@ -417,14 +644,14 @@ function createSyncableBlock(date, now, previousHash, author, gitCommit, chainHe
     createdAt: now,
     updatedAt: now,
     author,
-    gitCommit,
-    chainHeight
+    chainHeight,
+    ...gitCommit && { gitCommit }
   };
 }
 async function loadLedger(projectDir) {
-  const ledgerPath = join(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
+  const ledgerPath = join3(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
   try {
-    if (!existsSync2(ledgerPath)) return [];
+    if (!existsSync4(ledgerPath)) return [];
     const content = await readFile(ledgerPath, "utf-8");
     const parsed = JSON.parse(content);
     if (!Array.isArray(parsed)) return [];
@@ -438,26 +665,26 @@ async function getLedgerBlocks(workDir) {
   return loadLedger(projectDir);
 }
 async function saveLedger(blocks, projectDir) {
-  const ledgerPath = join(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 join(projectDir, SHARED_LEDGER_DIR);
+  return join3(projectDir, SHARED_LEDGER_DIR);
 }
 function getActiveBlocksDir(projectDir) {
-  return join(getSharedLedgerDir(projectDir), "active");
+  return join3(getSharedLedgerDir(projectDir), "active");
 }
 function getArchivedBlocksDir(projectDir) {
-  return join(getSharedLedgerDir(projectDir), "archived");
+  return join3(getSharedLedgerDir(projectDir), "archived");
 }
 function getManifestPath(projectDir) {
-  return join(getSharedLedgerDir(projectDir), MANIFEST_FILENAME);
+  return join3(getSharedLedgerDir(projectDir), MANIFEST_FILENAME);
 }
 function getSyncStatePath(projectDir) {
-  return join(getTrieDirectory(projectDir), "memory", SYNC_STATE_FILENAME);
+  return join3(getTrieDirectory(projectDir), "memory", SYNC_STATE_FILENAME);
 }
 async function ensureSharedStorageStructure(projectDir) {
   const sharedDir = getSharedLedgerDir(projectDir);
@@ -470,7 +697,7 @@ async function ensureSharedStorageStructure(projectDir) {
 async function loadManifest(projectDir) {
   const manifestPath = getManifestPath(projectDir);
   try {
-    if (!existsSync2(manifestPath)) return null;
+    if (!existsSync4(manifestPath)) return null;
     const content = await readFile(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch {
@@ -481,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,
@@ -508,7 +735,7 @@ async function createDefaultManifest(projectDir) {
 async function loadSyncState(projectDir) {
   const syncStatePath = getSyncStatePath(projectDir);
   try {
-    if (!existsSync2(syncStatePath)) return null;
+    if (!existsSync4(syncStatePath)) return null;
     const content = await readFile(syncStatePath, "utf-8");
     return JSON.parse(content);
   } catch {
@@ -517,7 +744,7 @@ async function loadSyncState(projectDir) {
 }
 async function saveSyncState(syncState, projectDir) {
   const syncStatePath = getSyncStatePath(projectDir);
-  const memoryDir = join(getTrieDirectory(projectDir), "memory");
+  const memoryDir = join3(getTrieDirectory(projectDir), "memory");
   await mkdir(memoryDir, { recursive: true });
   await atomicWriteJSON(syncStatePath, syncState);
 }
@@ -569,16 +796,17 @@ async function pushLedgerToShared(workDir) {
   const activeDir = getActiveBlocksDir(projectDir);
   for (const block of localBlocks) {
     const blockFilename = `${block.date}.json`;
-    const blockPath = join(activeDir, blockFilename);
-    if (!existsSync2(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)) {
@@ -597,9 +825,9 @@ async function loadSharedBlocks(projectDir) {
   const blocks = [];
   const activeDir = getActiveBlocksDir(projectDir);
   for (const filename of manifest.activeBlocks) {
-    const blockPath = join(activeDir, filename);
+    const blockPath = join3(activeDir, filename);
     try {
-      if (existsSync2(blockPath)) {
+      if (existsSync4(blockPath)) {
         const content = await readFile(blockPath, "utf-8");
         const block = JSON.parse(content);
         blocks.push(block);
@@ -671,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
@@ -732,8 +958,8 @@ function mergeBlockEntries(localBlock, remoteBlock) {
 }
 async function migrateLegacyLedger(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const legacyLedgerPath = join(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
-  if (!existsSync2(legacyLedgerPath)) {
+  const legacyLedgerPath = join3(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
+  if (!existsSync4(legacyLedgerPath)) {
     return false;
   }
   try {
@@ -749,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);
@@ -767,8 +993,8 @@ async function migrateLegacyLedger(workDir) {
 }
 async function detectLegacyLedger(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const legacyLedgerPath = join(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
-  if (!existsSync2(legacyLedgerPath)) {
+  const legacyLedgerPath = join3(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
+  if (!existsSync4(legacyLedgerPath)) {
     return false;
   }
   try {
@@ -810,7 +1036,6 @@ async function compressOldBlocks(workDir) {
   let compressedSize = 0;
   const blocksByMonth = /* @__PURE__ */ new Map();
   for (const blockFile of manifest.activeBlocks) {
-    const blockPath = join(activeDir, blockFile);
     const blockDate = blockFile.replace(".json", "");
     if (new Date(blockDate) < cutoffDate) {
       const monthKey = blockDate.slice(0, 7);
@@ -821,14 +1046,14 @@ async function compressOldBlocks(workDir) {
     }
   }
   for (const [monthKey, blockFiles] of blocksByMonth) {
-    const archivePath = join(archivedDir, `${monthKey}.tar.gz`);
-    if (existsSync2(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 = join(activeDir, blockFile);
+      const blockPath = join3(activeDir, blockFile);
       try {
         const stats = await stat(blockPath);
         originalSize += stats.size;
@@ -852,7 +1077,7 @@ async function compressOldBlocks(workDir) {
       await writeFile(archivePath, await readFile(tempPath));
       await unlink(tempPath);
       for (const blockFile of blockFiles) {
-        const blockPath = join(activeDir, blockFile);
+        const blockPath = join3(activeDir, blockFile);
         await unlink(blockPath);
         const index = manifest.activeBlocks.indexOf(blockFile);
         if (index > -1) {
@@ -871,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);
@@ -889,9 +1139,9 @@ async function getStorageStats(workDir) {
   let activeSize = 0;
   let archivedSize = 0;
   for (const blockFile of manifest.activeBlocks) {
-    const blockPath = join(activeDir, blockFile);
+    const blockPath = join3(activeDir, blockFile);
     try {
-      if (existsSync2(blockPath)) {
+      if (existsSync4(blockPath)) {
         const stats = await stat(blockPath);
         activeSize += stats.size;
       }
@@ -899,16 +1149,15 @@ async function getStorageStats(workDir) {
     }
   }
   for (const archiveFile of manifest.archivedBlocks) {
-    const archivePath = join(archivedDir, archiveFile);
+    const archivePath = join3(archivedDir, archiveFile);
     try {
-      if (existsSync2(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 {
@@ -1014,16 +1263,16 @@ async function correctLedgerEntries(entryIds, reason, correctionType = "correcte
         id: entry.id,
         hash: entry.hash,
         severity: entry.severity,
+        issue: entry.correction || "",
+        fix: "",
         file: entry.file,
+        line: 0,
         agent: entry.agent,
-        timestamp: entry.timestamp,
-        description: entry.correction || "",
         category: "correction",
-        line: 0,
-        column: 0,
-        context: "",
-        createdAt: entry.timestamp,
-        lastSeen: entry.timestamp
+        timestamp: entry.timestamp,
+        project: "",
+        resolved: false,
+        resolvedAt: void 0
       })),
       projectDir,
       correctionAuthor
@@ -1031,7 +1280,7 @@ async function correctLedgerEntries(entryIds, reason, correctionType = "correcte
     return {
       success: true,
       correctedEntries: entriesToCorrect.length,
-      correctionBlock: correctionBlock || void 0
+      ...correctionBlock && { correctionBlock }
     };
   } catch (error) {
     return {
@@ -1109,7 +1358,6 @@ export {
   formatAuditLog,
   getAuditStatistics,
   getRecentAuditLogs,
-  getSkillAuditLogs,
   runShellCommandSync,
   getRecentCommits,
   getStagedChanges,
@@ -1119,6 +1367,9 @@ export {
   getWorkingTreeDiff,
   isGitRepo,
   getChangedFilesSinceTimestamp,
+  signLedgerEntry,
+  verifyLedgerEntry,
+  verifyBlockSignatures,
   appendIssuesToLedger,
   verifyLedger,
   computeMerkleRoot,
@@ -1130,6 +1381,7 @@ export {
   detectLegacyLedger,
   getLedgerSyncStatus,
   compressOldBlocks,
+  loadArchivedBlocks,
   getStorageStats,
   shouldCompress,
   correctLedgerEntries,
@@ -1137,4 +1389,4 @@ export {
   getEntryCorrectionHistory,
   getCorrectionStats
 };
-//# sourceMappingURL=chunk-ZUEAHFSY.js.map
+//# sourceMappingURL=chunk-HD5H7YSW.js.map