@triedotdev/mcp 1.0.164 → 1.0.166

package/dist/{chunk-Y4B3VEL7.js → chunk-MVVPJ73K.js}

@@ -5,18 +5,146 @@ import {
   getTrieDirectory,
   getWorkingDirectory
 } from "./chunk-VVITXIHN.js";
+import {
+  __require
+} from "./chunk-DGUM43GV.js";
 
 // src/memory/ledger.ts
 import { createHash } from "crypto";
-import { mkdir, readFile, writeFile, stat, unlink } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir2, readFile as readFile2, writeFile, stat as stat2, unlink as unlink2 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
 import { createGzip, createGunzip } from "zlib";
 import { pipeline } from "stream/promises";
 import { createReadStream, createWriteStream } from "fs";
 import { join as join3 } from "path";
 
-// src/agent/git.ts
+// 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/agent/git.ts
+import { existsSync as existsSync2 } from "fs";
 import path from "path";
 
 // src/utils/command-runner.ts
@@ -319,7 +447,7 @@ 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 { existsSync as existsSync3, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 function getKeysDirectory(workDir) {
   const trieDir = getTrieDirectory(workDir || process.cwd());
@@ -338,7 +466,7 @@ async function generateKeyPair() {
 }
 function saveKeyPair(keyPair, workDir) {
   const keysDir = getKeysDirectory(workDir);
-  if (!existsSync2(keysDir)) {
+  if (!existsSync3(keysDir)) {
     mkdirSync(keysDir, { recursive: true });
   }
   const keyPath = getDefaultKeyPath(workDir);
@@ -353,7 +481,7 @@ function saveKeyPair(keyPair, workDir) {
 }
 function loadKeyPair(workDir) {
   const keyPath = getDefaultKeyPath(workDir);
-  if (!existsSync2(keyPath)) {
+  if (!existsSync3(keyPath)) {
     return null;
   }
   try {
@@ -410,25 +538,29 @@ async function verifyHashSignature(hash, signatureData) {
   }
   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);
+  return existsSync3(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 { existsSync as existsSync4 } 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)) {
+    if (!existsSync4(gitDir)) {
       return false;
     }
     const configPath = join2(getTrieDirectory(workDir), "config.json");
-    if (!existsSync3(configPath)) {
+    if (!existsSync4(configPath)) {
       return true;
     }
     const config = JSON.parse(await import("fs/promises").then((fs) => fs.readFile(configPath, "utf-8")));
@@ -473,7 +605,7 @@ async function ensureKeysIgnored(workDir) {
     const gitignorePath = join2(workDir, ".gitignore");
     const fs = await import("fs/promises");
     let gitignore = "";
-    if (existsSync3(gitignorePath)) {
+    if (existsSync4(gitignorePath)) {
       gitignore = await fs.readFile(gitignorePath, "utf-8");
     }
     if (gitignore.includes(".trie/keys/")) {
@@ -493,6 +625,12 @@ 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);
@@ -541,42 +679,48 @@ 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 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 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,
-    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) {
-    blocks.push(block);
-  }
-  block.entries = [...block.entries, ...entries];
-  block.merkleRoot = computeMerkleRoot(block.entries.map((entry) => entry.hash));
-  block.blockHash = computeBlockHash(block.previousHash, block.merkleRoot, block.date, block.version);
-  block.updatedAt = now;
-  await saveLedger(blocks, projectDir);
-  if (await isGitRepo(projectDir)) {
-    await ensureKeysIgnored(projectDir);
-    const commitMessage = `ledger: append ${entries.length} ${entries.length === 1 ? "entry" : "entries"}`;
-    await autoCommitLedger(projectDir, commitMessage);
-  }
-  return block;
+  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 = issues.map((issue) => ({
+      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
+    }));
+    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) {
+      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);
@@ -649,24 +793,80 @@ function createSyncableBlock(date, now, previousHash, author, gitCommit, chainHe
   };
 }
 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 [];
-    const content = await readFile(ledgerPath, "utf-8");
+    if (!existsSync5(ledgerPath)) {
+      return { blocks: [], contentHash: sha256("[]") };
+    }
+    const content = await readFile2(ledgerPath, "utf-8");
     const parsed = JSON.parse(content);
-    if (!Array.isArray(parsed)) return [];
-    return parsed;
+    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 [];
+    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 atomicWriteJSON(ledgerPath, blocks);
+  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");
@@ -690,15 +890,15 @@ async function ensureSharedStorageStructure(projectDir) {
   const sharedDir = getSharedLedgerDir(projectDir);
   const activeDir = getActiveBlocksDir(projectDir);
   const archivedDir = getArchivedBlocksDir(projectDir);
-  await mkdir(sharedDir, { recursive: true });
-  await mkdir(activeDir, { recursive: true });
-  await mkdir(archivedDir, { recursive: true });
+  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 readFile(manifestPath, "utf-8");
+    if (!existsSync5(manifestPath)) return null;
+    const content = await readFile2(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -735,8 +935,8 @@ async function createDefaultManifest(_projectDir) {
 async function loadSyncState(projectDir) {
   const syncStatePath = getSyncStatePath(projectDir);
   try {
-    if (!existsSync4(syncStatePath)) return null;
-    const content = await readFile(syncStatePath, "utf-8");
+    if (!existsSync5(syncStatePath)) return null;
+    const content = await readFile2(syncStatePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -745,7 +945,7 @@ async function loadSyncState(projectDir) {
 async function saveSyncState(syncState, projectDir) {
   const syncStatePath = getSyncStatePath(projectDir);
   const memoryDir = join3(getTrieDirectory(projectDir), "memory");
-  await mkdir(memoryDir, { recursive: true });
+  await mkdir2(memoryDir, { recursive: true });
   await atomicWriteJSON(syncStatePath, syncState);
 }
 async function initializeSharedLedger(workDir) {
@@ -770,54 +970,62 @@ async function initializeSharedLedger(workDir) {
 }
 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);
-  const manifest = await loadManifest(projectDir);
-  const localBlocks = await loadLedger(projectDir);
-  const sharedBlocks = await loadSharedBlocks(projectDir);
-  if (!manifest) {
-    throw new Error("Failed to load ledger manifest");
-  }
-  const mergeResult = await mergeChains(localBlocks, sharedBlocks, "timestamp");
-  await saveLedger(mergeResult.mergedChain, projectDir);
-  const syncState = {
-    lastSyncTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    conflicts: mergeResult.conflicts,
-    localChanges: false,
-    sharedChanges: false
-  };
-  await saveSyncState(syncState, projectDir);
-  return mergeResult;
+  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);
-  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] = [];
+  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 (!existsSync5(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.index.byAuthor[blockAuthor].includes(`active/${blockFilename}`)) {
-          manifest.index.byAuthor[blockAuthor].push(`active/${blockFilename}`);
+        if (!manifest.activeBlocks.includes(blockFilename)) {
+          manifest.activeBlocks.push(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);
+    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);
@@ -827,8 +1035,8 @@ async function loadSharedBlocks(projectDir) {
   for (const filename of manifest.activeBlocks) {
     const blockPath = join3(activeDir, filename);
     try {
-      if (existsSync4(blockPath)) {
-        const content = await readFile(blockPath, "utf-8");
+      if (existsSync5(blockPath)) {
+        const content = await readFile2(blockPath, "utf-8");
         const block = JSON.parse(content);
         blocks.push(block);
       }
@@ -919,16 +1127,29 @@ function resolveConflict(conflict, strategy) {
   if (!conflict.localBlock || !conflict.remoteBlock) {
     return null;
   }
+  const mergedBlock = mergeBlockEntries(conflict.localBlock, conflict.remoteBlock);
+  mergedBlock.conflictResolved = true;
   switch (strategy) {
-    case "longest":
-      return conflict.localBlock.entries.length >= conflict.remoteBlock.entries.length ? conflict.localBlock : conflict.remoteBlock;
     case "timestamp":
-      return conflict.localBlock.updatedAt >= conflict.remoteBlock.updatedAt ? conflict.localBlock : conflict.remoteBlock;
+      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":
-      return { ...conflict.localBlock, conflictResolved: false };
     default:
-      return conflict.localBlock;
+      mergedBlock.author = `${conflict.localBlock.author}+${conflict.remoteBlock.author}`;
+      break;
   }
+  return mergedBlock;
 }
 function mergeBlockEntries(localBlock, remoteBlock) {
   const entryMap = /* @__PURE__ */ new Map();
@@ -959,7 +1180,7 @@ function mergeBlockEntries(localBlock, remoteBlock) {
 async function migrateLegacyLedger(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
   const legacyLedgerPath = join3(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
-  if (!existsSync4(legacyLedgerPath)) {
+  if (!existsSync5(legacyLedgerPath)) {
     return false;
   }
   try {
@@ -994,7 +1215,7 @@ async function migrateLegacyLedger(workDir) {
 async function detectLegacyLedger(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
   const legacyLedgerPath = join3(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
-  if (!existsSync4(legacyLedgerPath)) {
+  if (!existsSync5(legacyLedgerPath)) {
     return false;
   }
   try {
@@ -1047,7 +1268,7 @@ async function compressOldBlocks(workDir) {
   }
   for (const [monthKey, blockFiles] of blocksByMonth) {
     const archivePath = join3(archivedDir, `${monthKey}.tar.gz`);
-    if (existsSync4(archivePath)) {
+    if (existsSync5(archivePath)) {
       continue;
     }
     console.log(`Archiving ${blockFiles.length} blocks for ${monthKey}...`);
@@ -1055,9 +1276,9 @@ async function compressOldBlocks(workDir) {
     for (const blockFile of blockFiles) {
       const blockPath = join3(activeDir, blockFile);
       try {
-        const stats = await stat(blockPath);
+        const stats = await stat2(blockPath);
         originalSize += stats.size;
-        const content = await readFile(blockPath, "utf-8");
+        const content = await readFile2(blockPath, "utf-8");
         const block = JSON.parse(content);
         monthlyBlocks.push(block);
       } catch (error) {
@@ -1072,13 +1293,13 @@ async function compressOldBlocks(workDir) {
         createGzip({ level: manifest.compressionConfig.compressionLevel }),
         createWriteStream(tempPath)
       );
-      const compressedStats = await stat(tempPath);
+      const compressedStats = await stat2(tempPath);
       compressedSize += compressedStats.size;
-      await writeFile(archivePath, await readFile(tempPath));
-      await unlink(tempPath);
+      await writeFile(archivePath, await readFile2(tempPath));
+      await unlink2(tempPath);
       for (const blockFile of blockFiles) {
         const blockPath = join3(activeDir, blockFile);
-        await unlink(blockPath);
+        await unlink2(blockPath);
         const index = manifest.activeBlocks.indexOf(blockFile);
         if (index > -1) {
           manifest.activeBlocks.splice(index, 1);
@@ -1099,7 +1320,7 @@ async function compressOldBlocks(workDir) {
 async function loadArchivedBlocks(projectDir, monthKey) {
   const archivedDir = getArchivedBlocksDir(projectDir);
   const archivePath = join3(archivedDir, `${monthKey}.tar.gz`);
-  if (!existsSync4(archivePath)) {
+  if (!existsSync5(archivePath)) {
     return [];
   }
   try {
@@ -1141,8 +1362,8 @@ async function getStorageStats(workDir) {
   for (const blockFile of manifest.activeBlocks) {
     const blockPath = join3(activeDir, blockFile);
     try {
-      if (existsSync4(blockPath)) {
-        const stats = await stat(blockPath);
+      if (existsSync5(blockPath)) {
+        const stats = await stat2(blockPath);
         activeSize += stats.size;
       }
     } catch {
@@ -1151,8 +1372,8 @@ async function getStorageStats(workDir) {
   for (const archiveFile of manifest.archivedBlocks) {
     const archivePath = join3(archivedDir, archiveFile);
     try {
-      if (existsSync4(archivePath)) {
-        const stats = await stat(archivePath);
+      if (existsSync5(archivePath)) {
+        const stats = await stat2(archivePath);
         archivedSize += stats.size;
       }
     } catch {
@@ -1201,94 +1422,100 @@ async function correctLedgerEntries(entryIds, reason, correctionType = "correcte
     };
   }
   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);
-      }
-    }
-  }
-  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
-      };
-    });
+  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) {
-      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;
+          entriesToCorrect.push(entry);
         }
       }
-      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;
+    }
+    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"}`
+      };
     }
-    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,
-      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 : createSyncableBlock(today, now, previousBlock?.blockHash ?? GENESIS_HASH, author, 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);
@@ -1355,6 +1582,7 @@ async function getCorrectionStats(workDir) {
 }
 
 export {
+  withFileLock,
   formatAuditLog,
   getAuditStatistics,
   getRecentAuditLogs,
@@ -1367,6 +1595,12 @@ export {
   getWorkingTreeDiff,
   isGitRepo,
   getChangedFilesSinceTimestamp,
+  generateKeyPair,
+  saveKeyPair,
+  loadKeyPair,
+  getPublicKey,
+  hasSigningKey,
+  ConcurrentModificationError,
   signLedgerEntry,
   verifyLedgerEntry,
   verifyBlockSignatures,
@@ -1374,6 +1608,8 @@ export {
   verifyLedger,
   computeMerkleRoot,
   getLedgerBlocks,
+  getLedgerBlocksWithHash,
+  saveLedgerOptimistic,
   initializeSharedLedger,
   syncLedgerFromShared,
   pushLedgerToShared,
@@ -1389,4 +1625,4 @@ export {
   getEntryCorrectionHistory,
   getCorrectionStats
 };
-//# sourceMappingURL=chunk-Y4B3VEL7.js.map
+//# sourceMappingURL=chunk-MVVPJ73K.js.map