@triedotdev/mcp 1.0.169 → 1.0.171

package/dist/chunk-ZJF5FTBX.js

@@ -1,1396 +0,0 @@
-import {
-  atomicWriteJSON
-} from "./chunk-43X6JBEM.js";
-import {
-  getTrieDirectory,
-  getWorkingDirectory
-} from "./chunk-VVITXIHN.js";
-import {
-  getLastCommit,
-  isGitRepo
-} from "./chunk-2HF65EHQ.js";
-import {
-  __require
-} from "./chunk-DGUM43GV.js";
-
-// src/memory/ledger.ts
-import { createHash } from "crypto";
-import { mkdir as mkdir2, readFile as readFile2, writeFile, stat as stat2, unlink as unlink2 } 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 join3 } from "path";
-
-// src/utils/file-lock.ts
-import { open, unlink, readFile, stat, mkdir } from "fs/promises";
-import { existsSync } from "fs";
-import { dirname } from "path";
-var activeLocks = /* @__PURE__ */ new Set();
-function setupCleanupHandler() {
-  const cleanup = () => {
-    for (const lockPath of activeLocks) {
-      try {
-        const fs = __require("fs");
-        if (fs.existsSync(lockPath)) {
-          fs.unlinkSync(lockPath);
-        }
-      } catch {
-      }
-    }
-  };
-  process.on("exit", cleanup);
-  process.on("SIGINT", () => {
-    cleanup();
-    process.exit(130);
-  });
-  process.on("SIGTERM", () => {
-    cleanup();
-    process.exit(143);
-  });
-}
-var cleanupHandlerInstalled = false;
-async function withFileLock(filePath, fn, options = {}) {
-  const {
-    timeout = 1e4,
-    retryDelay = 50,
-    maxRetryDelay = 500,
-    staleTimeout = 3e4
-  } = options;
-  const lockPath = `${filePath}.lock`;
-  const start = Date.now();
-  let currentDelay = retryDelay;
-  if (!cleanupHandlerInstalled) {
-    setupCleanupHandler();
-    cleanupHandlerInstalled = true;
-  }
-  await mkdir(dirname(lockPath), { recursive: true });
-  while (true) {
-    try {
-      await cleanupStaleLock(lockPath, staleTimeout);
-      const lockInfo = {
-        pid: process.pid,
-        timestamp: Date.now(),
-        hostname: __require("os").hostname()
-      };
-      const handle = await open(lockPath, "wx");
-      await handle.writeFile(JSON.stringify(lockInfo));
-      await handle.close();
-      activeLocks.add(lockPath);
-      try {
-        return await fn();
-      } finally {
-        activeLocks.delete(lockPath);
-        await unlink(lockPath).catch(() => {
-        });
-      }
-    } catch (err) {
-      if (err.code !== "EEXIST") {
-        throw err;
-      }
-      if (Date.now() - start > timeout) {
-        let lockHolder = "unknown";
-        try {
-          const content = await readFile(lockPath, "utf-8");
-          const info = JSON.parse(content);
-          lockHolder = `PID ${info.pid} on ${info.hostname}`;
-        } catch {
-        }
-        throw new Error(
-          `Timeout acquiring lock for ${filePath} after ${timeout}ms. Lock held by: ${lockHolder}`
-        );
-      }
-      await new Promise((resolve) => setTimeout(resolve, currentDelay));
-      currentDelay = Math.min(currentDelay * 2, maxRetryDelay);
-    }
-  }
-}
-async function cleanupStaleLock(lockPath, staleTimeout) {
-  if (!existsSync(lockPath)) {
-    return;
-  }
-  try {
-    const content = await readFile(lockPath, "utf-8");
-    const info = JSON.parse(content);
-    const lockAge = Date.now() - info.timestamp;
-    if (lockAge > staleTimeout) {
-      console.warn(`[FileLock] Removing stale lock (age: ${Math.round(lockAge / 1e3)}s): ${lockPath}`);
-      await unlink(lockPath);
-      return;
-    }
-    const currentHostname = __require("os").hostname();
-    if (info.hostname === currentHostname) {
-      if (!isProcessRunning(info.pid)) {
-        console.warn(`[FileLock] Removing orphaned lock (PID ${info.pid} not running): ${lockPath}`);
-        await unlink(lockPath);
-        return;
-      }
-    }
-  } catch {
-    try {
-      const stats = await stat(lockPath);
-      const fileAge = Date.now() - stats.mtimeMs;
-      if (fileAge > staleTimeout) {
-        console.warn(`[FileLock] Removing stale/corrupted lock: ${lockPath}`);
-        await unlink(lockPath);
-      }
-    } catch {
-    }
-  }
-}
-function isProcessRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// 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 getPublicKey(workDir) {
-  const keyPair = loadKeyPair(workDir);
-  return keyPair?.publicKey || null;
-}
-function hasSigningKey(workDir) {
-  const keyPath = getDefaultKeyPath(workDir);
-  return existsSync2(keyPath);
-}
-
-// src/memory/git-integration.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-import { existsSync as existsSync3 } from "fs";
-import { join as join2 } from "path";
-var execAsync = promisify(exec);
-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 execAsync("git status --porcelain", { cwd: workDir });
-    const hasLedgerChanges = statusOutput.includes("ledger.json");
-    if (!hasLedgerChanges) {
-      return { committed: false, error: "No ledger changes to commit" };
-    }
-    await execAsync(`git add ${ledgerPath}`, { cwd: workDir });
-    const commitMessage = message || "ledger: append entries";
-    await execAsync(
-      `git commit -m "${commitMessage}"`,
-      { cwd: workDir }
-    );
-    const { stdout: hashOutput } = await execAsync("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";
-var MANIFEST_FILENAME = "ledger-manifest.json";
-var SYNC_STATE_FILENAME = "ledger-sync.json";
-var GENESIS_HASH = "0".repeat(64);
-var LEDGER_VERSION = 2;
-var ConcurrentModificationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ConcurrentModificationError";
-  }
-};
-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 = join3(getTrieDirectory(projectDir), "memory");
-  await mkdir2(memoryDir, { recursive: true });
-  const ledgerPath = join3(memoryDir, LEDGER_FILENAME);
-  return withFileLock(ledgerPath, async () => {
-    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 shouldSign = hasSigningKey(projectDir);
-    let entries = await Promise.all(issues.map(async (issue) => {
-      const context = {
-        detectionMethod: "automated-scan",
-        confidence: issue.confidence || 80,
-        ruleId: issue.agent,
-        exposureScope: "repository",
-        riskFactors: [],
-        escalatedTo: blockAuthor
-      };
-      if (issue.line !== void 0) {
-        context.line = issue.line;
-      }
-      if (lastCommit?.hash) {
-        context.gitCommit = lastCommit.hash;
-      }
-      if (lastCommit?.branch) {
-        context.gitBranch = lastCommit.branch;
-      }
-      if (issue.category === "security") {
-        context.complianceViolations = ["security-policy"];
-        context.requiresNotification = issue.severity === "critical";
-      }
-      if (issue.category === "pii" || issue.issue?.toLowerCase().includes("personal")) {
-        context.complianceViolations = ["GDPR", "privacy-policy"];
-        context.requiresNotification = true;
-        context.exposureScope = "public";
-        context.riskFactors.push("data-exposure", "privacy-violation");
-      }
-      try {
-        const filePath = join3(projectDir, issue.file);
-        if (existsSync4(filePath)) {
-          const { readFile: readFile3, stat: stat3 } = await import("fs/promises");
-          const stats = await stat3(filePath);
-          context.fileSize = stats.size;
-          context.fileModified = stats.mtime.toISOString();
-          if (issue.line && issue.line > 0) {
-            const content = await readFile3(filePath, "utf-8");
-            const lines = content.split("\n");
-            const startLine = Math.max(0, issue.line - 3);
-            const endLine = Math.min(lines.length, issue.line + 2);
-            const snippet = lines.slice(startLine, endLine).join("\n");
-            context.codeSnippet = snippet.length > 500 ? snippet.slice(0, 500) + "..." : snippet;
-          }
-        }
-      } catch (error) {
-        console.debug("Failed to collect file metadata:", error);
-      }
-      return {
-        id: issue.id,
-        hash: issue.hash,
-        severity: issue.severity,
-        file: issue.file,
-        agent: issue.agent,
-        timestamp: issue.timestamp,
-        status: "active",
-        // Include semantic content for ambient awareness
-        issue: issue.issue,
-        fix: issue.fix,
-        // Enhanced forensic context
-        context
-      };
-    }));
-    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 : await createSyncableBlock(today, now, previousBlock?.blockHash ?? GENESIS_HASH, blockAuthor, projectDir, 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 saveLedgerInternal(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;
-  }, { timeout: 15e3 });
-}
-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} 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 };
-}
-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}`);
-}
-async function createSyncableBlock(date, now, previousHash, author, projectDir, gitCommit, chainHeight = 0) {
-  const metadata = {};
-  try {
-    metadata.hostname = __require("os").hostname();
-    metadata.workingDirectory = projectDir;
-    metadata.scanId = `scan-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    metadata.toolVersion = process.env.npm_package_version || "unknown";
-    if (await isGitRepo(projectDir)) {
-      const { getLastCommit: getLastCommit2 } = await import("./git-EO5SRFMN.js");
-      const lastCommit = await getLastCommit2(projectDir);
-      if (lastCommit?.hash) {
-        metadata.gitHeadCommit = lastCommit.hash;
-      }
-    }
-    metadata.summary = {
-      totalIssues: 0,
-      issuesBySeverity: {},
-      issuesByAgent: {},
-      newIssues: 0,
-      resolvedIssues: 0
-    };
-  } catch (error) {
-    console.debug("Failed to collect block metadata:", error);
-  }
-  return {
-    version: LEDGER_VERSION,
-    date,
-    entries: [],
-    previousHash,
-    merkleRoot: "",
-    blockHash: "",
-    createdAt: now,
-    updatedAt: now,
-    author,
-    chainHeight,
-    metadata,
-    ...gitCommit && { gitCommit }
-  };
-}
-async function loadLedger(projectDir) {
-  const result = await loadLedgerWithHash(projectDir);
-  return result.blocks;
-}
-async function loadLedgerWithHash(projectDir) {
-  const ledgerPath = join3(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
-  try {
-    if (!existsSync4(ledgerPath)) {
-      return { blocks: [], contentHash: sha256("[]") };
-    }
-    const content = await readFile2(ledgerPath, "utf-8");
-    const parsed = JSON.parse(content);
-    if (parsed && parsed._format === "ledger-v2") {
-      const file = parsed;
-      return {
-        blocks: file.blocks || [],
-        contentHash: file._contentHash
-      };
-    }
-    if (!Array.isArray(parsed)) {
-      return { blocks: [], contentHash: sha256("[]") };
-    }
-    const blocks = parsed;
-    const contentHash = sha256(JSON.stringify(blocks));
-    return { blocks, contentHash };
-  } catch {
-    return { blocks: [], contentHash: sha256("[]") };
-  }
-}
-async function getLedgerBlocks(workDir) {
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  return loadLedger(projectDir);
-}
-async function getLedgerBlocksWithHash(workDir) {
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  return loadLedgerWithHash(projectDir);
-}
-async function saveLedgerOptimistic(blocks, expectedHash, workDir) {
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const memoryDir = join3(getTrieDirectory(projectDir), "memory");
-  const ledgerPath = join3(memoryDir, LEDGER_FILENAME);
-  await withFileLock(ledgerPath, async () => {
-    await saveLedgerWithConcurrencyCheck(blocks, projectDir, expectedHash);
-  }, { timeout: 1e4 });
-}
-async function saveLedger(blocks, projectDir) {
-  const ledgerPath = join3(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
-  await withFileLock(ledgerPath, async () => {
-    await saveLedgerWithFormat(ledgerPath, blocks);
-  }, { timeout: 1e4 });
-}
-async function saveLedgerInternal(blocks, projectDir) {
-  const ledgerPath = join3(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
-  await saveLedgerWithFormat(ledgerPath, blocks);
-}
-async function saveLedgerWithConcurrencyCheck(blocks, projectDir, expectedHash) {
-  const ledgerPath = join3(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
-  const { contentHash: currentHash } = await loadLedgerWithHash(projectDir);
-  if (currentHash !== expectedHash) {
-    throw new ConcurrentModificationError(
-      `Ledger was modified by another process. Expected hash: ${expectedHash.slice(0, 16)}..., Current hash: ${currentHash.slice(0, 16)}...`
-    );
-  }
-  await saveLedgerWithFormat(ledgerPath, blocks);
-}
-async function saveLedgerWithFormat(ledgerPath, blocks) {
-  const blocksJson = JSON.stringify(blocks);
-  const contentHash = sha256(blocksJson);
-  const ledgerFile = {
-    _format: "ledger-v2",
-    _contentHash: contentHash,
-    _lastModified: (/* @__PURE__ */ new Date()).toISOString(),
-    blocks
-  };
-  await atomicWriteJSON(ledgerPath, ledgerFile);
-}
-function sha256(input) {
-  return createHash("sha256").update(input).digest("hex");
-}
-function getSharedLedgerDir(projectDir) {
-  return join3(projectDir, SHARED_LEDGER_DIR);
-}
-function getActiveBlocksDir(projectDir) {
-  return join3(getSharedLedgerDir(projectDir), "active");
-}
-function getArchivedBlocksDir(projectDir) {
-  return join3(getSharedLedgerDir(projectDir), "archived");
-}
-function getManifestPath(projectDir) {
-  return join3(getSharedLedgerDir(projectDir), MANIFEST_FILENAME);
-}
-function getSyncStatePath(projectDir) {
-  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 });
-}
-async function loadManifest(projectDir) {
-  const manifestPath = getManifestPath(projectDir);
-  try {
-    if (!existsSync4(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 (!existsSync4(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 = join3(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);
-  const memoryDir = join3(getTrieDirectory(projectDir), "memory");
-  const ledgerPath = join3(memoryDir, LEDGER_FILENAME);
-  await initializeSharedLedger(projectDir);
-  return withFileLock(ledgerPath, async () => {
-    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 saveLedgerInternal(mergeResult.mergedChain, projectDir);
-    const syncState = {
-      lastSyncTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      conflicts: mergeResult.conflicts,
-      localChanges: false,
-      sharedChanges: false
-    };
-    await saveSyncState(syncState, projectDir);
-    return mergeResult;
-  }, { timeout: 3e4 });
-}
-async function pushLedgerToShared(workDir) {
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const memoryDir = join3(getTrieDirectory(projectDir), "memory");
-  const ledgerPath = join3(memoryDir, LEDGER_FILENAME);
-  await initializeSharedLedger(projectDir);
-  await withFileLock(ledgerPath, async () => {
-    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 = join3(activeDir, blockFilename);
-      if (!existsSync4(blockPath) || block.updatedAt > manifest.lastSync) {
-        await atomicWriteJSON(blockPath, block);
-        manifest.index.byDate[block.date] = `active/${blockFilename}`;
-        const blockAuthor = block.author;
-        if (blockAuthor) {
-          if (!manifest.index.byAuthor[blockAuthor]) {
-            manifest.index.byAuthor[blockAuthor] = [];
-          }
-          if (!manifest.index.byAuthor[blockAuthor].includes(`active/${blockFilename}`)) {
-            manifest.index.byAuthor[blockAuthor].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);
-  }, { timeout: 3e4 });
-}
-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 = join3(activeDir, filename);
-    try {
-      if (existsSync4(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([
-    ...Array.from(localByDate.keys()),
-    ...Array.from(remoteByDate.keys())
-  ]);
-  for (const date of Array.from(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 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;
-  }
-  const mergedBlock = mergeBlockEntries(conflict.localBlock, conflict.remoteBlock);
-  mergedBlock.conflictResolved = true;
-  switch (strategy) {
-    case "timestamp":
-      if (conflict.remoteBlock.updatedAt > conflict.localBlock.updatedAt) {
-        mergedBlock.author = `${conflict.remoteBlock.author}+${conflict.localBlock.author}`;
-      } else {
-        mergedBlock.author = `${conflict.localBlock.author}+${conflict.remoteBlock.author}`;
-      }
-      break;
-    case "longest":
-      if (conflict.remoteBlock.entries.length > conflict.localBlock.entries.length) {
-        mergedBlock.author = `${conflict.remoteBlock.author}+${conflict.localBlock.author}`;
-      } else {
-        mergedBlock.author = `${conflict.localBlock.author}+${conflict.remoteBlock.author}`;
-      }
-      break;
-    case "manual":
-    default:
-      mergedBlock.author = `${conflict.localBlock.author}+${conflict.remoteBlock.author}`;
-      break;
-  }
-  return mergedBlock;
-}
-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 = join3(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
-  if (!existsSync4(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,
-      chainHeight: index,
-      syncedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      ...lastCommit?.hash && { gitCommit: lastCommit.hash }
-    }));
-    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 = join3(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
-  if (!existsSync4(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 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 Array.from(blocksByMonth.entries())) {
-    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 = join3(activeDir, blockFile);
-      try {
-        const stats = await stat2(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 stat2(tempPath);
-      compressedSize += compressedStats.size;
-      await writeFile(archivePath, await readFile2(tempPath));
-      await unlink2(tempPath);
-      for (const blockFile of blockFiles) {
-        const blockPath = join3(activeDir, blockFile);
-        await unlink2(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 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);
-  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 = join3(activeDir, blockFile);
-    try {
-      if (existsSync4(blockPath)) {
-        const stats = await stat2(blockPath);
-        activeSize += stats.size;
-      }
-    } catch {
-    }
-  }
-  for (const archiveFile of manifest.archivedBlocks) {
-    const archivePath = join3(archivedDir, archiveFile);
-    try {
-      if (existsSync4(archivePath)) {
-        const stats = await stat2(archivePath);
-        archivedSize += stats.size;
-      }
-    } catch {
-    }
-  }
-  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 correctLedgerEntries(entryIds, reason, correctionType = "corrected", workDir, author) {
-  if (entryIds.length === 0) {
-    return {
-      success: false,
-      correctedEntries: 0,
-      error: "No entry IDs provided"
-    };
-  }
-  if (!reason || reason.trim().length === 0) {
-    return {
-      success: false,
-      correctedEntries: 0,
-      error: "Correction reason is required"
-    };
-  }
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const memoryDir = join3(getTrieDirectory(projectDir), "memory");
-  const ledgerPath = join3(memoryDir, LEDGER_FILENAME);
-  return withFileLock(ledgerPath, async () => {
-    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);
-        }
-      }
-    }
-    if (entriesToCorrect.length === 0) {
-      return {
-        success: false,
-        correctedEntries: 0,
-        error: "No active entries found with the provided IDs"
-      };
-    }
-    try {
-      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 saveLedgerInternal(blocks, projectDir);
-      const correctionBlock = await appendCorrectionEntries(
-        correctionEntries,
-        projectDir,
-        correctionAuthor
-      );
-      return {
-        success: true,
-        correctedEntries: entriesToCorrect.length,
-        ...correctionBlock && { correctionBlock }
-      };
-    } catch (error) {
-      return {
-        success: false,
-        correctedEntries: 0,
-        error: `Failed to correct entries: ${error instanceof Error ? error.message : "Unknown error"}`
-      };
-    }
-  }, { timeout: 15e3 });
-}
-async function appendCorrectionEntries(correctionEntries, projectDir, author) {
-  const blocks = await loadLedger(projectDir);
-  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const previousBlock = blocks[blocks.length - 1];
-  const block = previousBlock && previousBlock.date === today ? previousBlock : await createSyncableBlock(today, now, previousBlock?.blockHash ?? GENESIS_HASH, author, projectDir, void 0, blocks.length);
-  if (block !== previousBlock) {
-    blocks.push(block);
-  }
-  block.entries = [...block.entries, ...correctionEntries];
-  block.merkleRoot = computeMerkleRoot(block.entries.map((entry) => entry.hash));
-  block.blockHash = computeBlockHash(block.previousHash, block.merkleRoot, block.date, block.version);
-  block.updatedAt = now;
-  await saveLedgerInternal(blocks, projectDir);
-  return block;
-}
-async function getLedgerEntries(workDir, includeStatus) {
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const blocks = await loadLedger(projectDir);
-  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 entries;
-}
-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);
-        }
-      }
-    }
-    if (original) {
-      history.set(entryId, { original, corrections });
-    }
-  }
-  return history;
-}
-async function getCorrectionStats(workDir) {
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  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++;
-    }
-  }
-  const correctionRate = totalEntries > 0 ? (correctedEntries + falsePositives) / totalEntries * 100 : 0;
-  return {
-    totalEntries,
-    activeEntries,
-    correctedEntries,
-    falsePositives,
-    correctionRate: Math.round(correctionRate * 100) / 100
-  };
-}
-
-export {
-  withFileLock,
-  generateKeyPair,
-  saveKeyPair,
-  loadKeyPair,
-  getPublicKey,
-  hasSigningKey,
-  ConcurrentModificationError,
-  signLedgerEntry,
-  verifyLedgerEntry,
-  verifyBlockSignatures,
-  appendIssuesToLedger,
-  verifyLedger,
-  computeMerkleRoot,
-  getLedgerBlocks,
-  getLedgerBlocksWithHash,
-  saveLedgerOptimistic,
-  initializeSharedLedger,
-  syncLedgerFromShared,
-  pushLedgerToShared,
-  migrateLegacyLedger,
-  detectLegacyLedger,
-  getLedgerSyncStatus,
-  compressOldBlocks,
-  loadArchivedBlocks,
-  getStorageStats,
-  shouldCompress,
-  correctLedgerEntries,
-  getLedgerEntries,
-  getEntryCorrectionHistory,
-  getCorrectionStats
-};
-//# sourceMappingURL=chunk-ZJF5FTBX.js.map