@adhdev/daemon-core 0.9.77-rc.47 → 0.9.77-rc.49

package/dist/index.d.ts

@@ -31,8 +31,10 @@ export { buildCoordinatorSystemPrompt } from './mesh/coordinator-prompt.js';
 export type { CoordinatorPromptContext } from './mesh/coordinator-prompt.js';
 export { syncMeshes } from './mesh/mesh-sync.js';
 export type { MeshSyncTransport, MeshSyncResult, RemoteMeshRecord } from './mesh/mesh-sync.js';
-export { appendLedgerEntry, readLedgerEntries, getLedgerSummary, getLedgerDir, getSessionRecoveryContext } from './mesh/mesh-ledger.js';
-export type { MeshLedgerEntry, MeshLedgerKind, MeshLedgerSummary, ReadLedgerOptions, SessionRecoveryContext } from './mesh/mesh-ledger.js';
+export { appendLedgerEntry, appendRemoteLedgerEntries, readLedgerEntries, readLedgerSlice, getLedgerSummary, getLedgerDir, getSessionRecoveryContext, MAX_LEDGER_SLICE_LIMIT } from './mesh/mesh-ledger.js';
+export type { AppendRemoteLedgerResult, MeshLedgerEntry, MeshLedgerKind, MeshLedgerSlice, MeshLedgerSummary, ReadLedgerOptions, ReadLedgerSliceOptions, SessionRecoveryContext } from './mesh/mesh-ledger.js';
+export { buildMeshLedgerReconciliationEvidence, buildMeshLedgerReplicaEvidence } from './mesh/mesh-ledger-reconciliation.js';
+export type { MeshLedgerReconciliationEvidence, MeshLedgerReplicaEvidence, MeshLedgerReplicaStatus } from './mesh/mesh-ledger-reconciliation.js';
 export { enqueueTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats } from './mesh/mesh-work-queue.js';
 export type { MeshWorkQueueEntry, MeshTaskStatus, MeshWorkQueueStats } from './mesh/mesh-work-queue.js';
 export { triggerMeshQueue } from './mesh/mesh-events.js';

package/dist/index.js

@@ -795,13 +795,15 @@ Follow these recovery rules:
 // src/mesh/mesh-ledger.ts
 var mesh_ledger_exports = {};
 __export(mesh_ledger_exports, {
+  MAX_LEDGER_SLICE_LIMIT: () => MAX_LEDGER_SLICE_LIMIT,
   appendLedgerEntry: () => appendLedgerEntry,
   appendRemoteLedgerEntries: () => appendRemoteLedgerEntries,
   getLedgerDir: () => getLedgerDir,
   getLedgerSummary: () => getLedgerSummary,
   getSessionRecoveryContext: () => getSessionRecoveryContext,
   meshLedgerEvents: () => meshLedgerEvents,
-  readLedgerEntries: () => readLedgerEntries
+  readLedgerEntries: () => readLedgerEntries,
+  readLedgerSlice: () => readLedgerSlice
 });
 function getLedgerDir() {
   const dir = (0, import_path3.join)(getConfigDir(), LEDGER_DIR_NAME);
@@ -844,15 +846,49 @@ function appendLedgerEntry(meshId, partial) {
     throw new Error(`Failed to append to ledger for mesh ${meshId}: ${e.message}`);
   }
 }
+function clampLedgerSliceLimit(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit)) return DEFAULT_LEDGER_SLICE_LIMIT;
+  return Math.max(1, Math.min(MAX_LEDGER_SLICE_LIMIT, Math.floor(limit)));
+}
+function isValidRemoteLedgerEntry(meshId, value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const entry = value;
+  if (typeof entry.id !== "string" || !entry.id.trim()) return false;
+  if (entry.meshId !== meshId) return false;
+  if (typeof entry.timestamp !== "string" || Number.isNaN(new Date(entry.timestamp).getTime())) return false;
+  if (typeof entry.kind !== "string" || !entry.kind.trim()) return false;
+  if (!entry.payload || typeof entry.payload !== "object" || Array.isArray(entry.payload)) return false;
+  return true;
+}
 function appendRemoteLedgerEntries(meshId, entries) {
-  if (entries.length === 0) return;
+  if (entries.length === 0) return { accepted: 0, skippedDuplicate: 0, rejectedInvalid: 0, entries: [] };
   const ledgerPath = getLedgerPath(meshId);
   const existing = new Set(readLedgerEntries(meshId).map((e) => e.id));
-  const newEntries = entries.filter((e) => !existing.has(e.id));
-  if (newEntries.length === 0) return;
+  const validEntries = [];
+  let rejectedInvalid = 0;
+  let skippedDuplicate = 0;
+  for (const entry of entries) {
+    if (!isValidRemoteLedgerEntry(meshId, entry)) {
+      rejectedInvalid++;
+      continue;
+    }
+    if (existing.has(entry.id)) {
+      skippedDuplicate++;
+      continue;
+    }
+    existing.add(entry.id);
+    validEntries.push(entry);
+  }
+  if (validEntries.length === 0) {
+    return { accepted: 0, skippedDuplicate, rejectedInvalid, entries: [] };
+  }
   try {
-    const lines = newEntries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    const lines = validEntries.map((e) => JSON.stringify(e)).join("\n") + "\n";
     (0, import_fs3.appendFileSync)(ledgerPath, lines, { encoding: "utf-8", mode: 384 });
+    for (const entry of validEntries) {
+      meshLedgerEvents.emit("append", meshId, entry);
+    }
+    return { accepted: validEntries.length, skippedDuplicate, rejectedInvalid, entries: validEntries };
   } catch (e) {
     throw new Error(`Failed to append remote ledger entries for mesh ${meshId}: ${e.message}`);
   }
@@ -891,6 +927,34 @@ function readLedgerEntries(meshId, opts) {
   }
   return entries;
 }
+function readLedgerSlice(meshId, opts) {
+  const limit = clampLedgerSliceLimit(opts?.limit);
+  let entries = readLedgerEntries(meshId, { since: opts?.since, kind: opts?.kind });
+  const afterId = typeof opts?.afterId === "string" && opts.afterId.trim() ? opts.afterId.trim() : null;
+  if (afterId) {
+    const index = entries.findIndex((entry) => entry.id === afterId);
+    entries = index >= 0 ? entries.slice(index + 1) : entries;
+  }
+  const bounded = entries.slice(0, limit);
+  return {
+    protocol: "adhdev.mesh.ledger.slice.v1",
+    meshId,
+    entries: bounded,
+    cursor: {
+      afterId,
+      nextAfterId: bounded.length ? bounded[bounded.length - 1].id : afterId,
+      limit,
+      hasMore: entries.length > bounded.length
+    },
+    summary: getLedgerSummary(meshId),
+    sourceOfTruth: {
+      kind: "local_jsonl",
+      path: getLedgerPath(meshId),
+      bounded: true,
+      maxLimit: MAX_LEDGER_SLICE_LIMIT
+    }
+  };
+}
 function getLedgerSummary(meshId) {
   const entries = readLedgerEntries(meshId);
   const now = Date.now();
@@ -1013,7 +1077,7 @@ function rotateLedgerFile(meshId, currentPath) {
   } catch {
   }
 }
-var import_fs3, import_path3, import_crypto4, import_events, LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, RECENT_FAILURE_WINDOW_MS, meshLedgerEvents;
+var import_fs3, import_path3, import_crypto4, import_events, LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, RECENT_FAILURE_WINDOW_MS, DEFAULT_LEDGER_SLICE_LIMIT, MAX_LEDGER_SLICE_LIMIT, meshLedgerEvents;
 var init_mesh_ledger = __esm({
   "src/mesh/mesh-ledger.ts"() {
     "use strict";
@@ -1025,6 +1089,8 @@ var init_mesh_ledger = __esm({
     LEDGER_DIR_NAME = "mesh-ledger";
     MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024;
     RECENT_FAILURE_WINDOW_MS = 30 * 60 * 1e3;
+    DEFAULT_LEDGER_SLICE_LIMIT = 100;
+    MAX_LEDGER_SLICE_LIMIT = 500;
     meshLedgerEvents = new import_events.EventEmitter();
   }
 });
@@ -5318,6 +5384,7 @@ __export(index_exports, {
   IdeProviderInstance: () => IdeProviderInstance,
   InMemoryGitSnapshotStore: () => InMemoryGitSnapshotStore,
   LOG: () => LOG,
+  MAX_LEDGER_SLICE_LIMIT: () => MAX_LEDGER_SLICE_LIMIT,
   MIN_GIT_WORKSPACE_POLL_INTERVAL_MS: () => MIN_GIT_WORKSPACE_POLL_INTERVAL_MS,
   MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS: () => MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
   MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS: () => MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
@@ -5333,12 +5400,15 @@ __export(index_exports, {
   addNode: () => addNode,
   appendLedgerEntry: () => appendLedgerEntry,
   appendRecentActivity: () => appendRecentActivity,
+  appendRemoteLedgerEntries: () => appendRemoteLedgerEntries,
   buildAssistantChatMessage: () => buildAssistantChatMessage,
   buildChatMessage: () => buildChatMessage,
   buildChatMessageSignature: () => buildChatMessageSignature,
   buildChatTailDeliverySignature: () => buildChatTailDeliverySignature,
   buildCoordinatorSystemPrompt: () => buildCoordinatorSystemPrompt,
   buildMachineInfo: () => buildMachineInfo,
+  buildMeshLedgerReconciliationEvidence: () => buildMeshLedgerReconciliationEvidence,
+  buildMeshLedgerReplicaEvidence: () => buildMeshLedgerReplicaEvidence,
   buildP2pRelayFailurePayload: () => buildP2pRelayFailurePayload,
   buildPinnedGlobalInstallCommand: () => buildPinnedGlobalInstallCommand,
   buildRuntimeSystemChatMessage: () => buildRuntimeSystemChatMessage,
@@ -5461,6 +5531,7 @@ __export(index_exports, {
   probeCdpPort: () => probeCdpPort,
   readChatHistory: () => readChatHistory,
   readLedgerEntries: () => readLedgerEntries,
+  readLedgerSlice: () => readLedgerSlice,
   recordDebugTrace: () => recordDebugTrace,
   registerExtensionProviders: () => registerExtensionProviders,
   removeNode: () => removeNode,
@@ -7362,29 +7433,71 @@ async function syncMeshes(transport) {
       }
     }
   }
-  if (transport.syncMeshLedger) {
-    for (const local of localMeshes) {
-      try {
-        await syncMeshLedger(local.id, transport);
-      } catch (e) {
-        result.errors.push(`Ledger sync failed for "${local.name}": ${e.message}`);
-      }
-    }
-  }
   return result;
 }
-async function syncMeshLedger(meshId, transport) {
-  if (!transport.syncMeshLedger) return;
-  const { readLedgerEntries: readLedgerEntries2, appendRemoteLedgerEntries: appendRemoteLedgerEntries2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
-  const localEntries = readLedgerEntries2(meshId);
-  const res = await transport.syncMeshLedger(meshId, { newEntries: localEntries });
-  if (res.missingEntries && res.missingEntries.length > 0) {
-    appendRemoteLedgerEntries2(meshId, res.missingEntries);
-  }
-}
 
 // src/index.ts
 init_mesh_ledger();
+
+// src/mesh/mesh-ledger-reconciliation.ts
+function lastTimestamp(slice) {
+  const entries = Array.isArray(slice?.entries) ? slice.entries : [];
+  return entries.length ? entries[entries.length - 1].timestamp : null;
+}
+function buildMeshLedgerReplicaEvidence(args) {
+  const entriesReceived = Array.isArray(args.slice?.entries) ? args.slice.entries.length : 0;
+  return {
+    nodeId: args.nodeId,
+    ...args.daemonId ? { daemonId: args.daemonId } : {},
+    status: args.status ?? (args.importResult && args.importResult.accepted > 0 ? "imported" : "queried"),
+    transport: args.transport,
+    protocol: "adhdev.mesh.ledger.slice.v1",
+    entriesReceived,
+    entriesImported: args.importResult?.accepted ?? 0,
+    skippedDuplicate: args.importResult?.skippedDuplicate ?? 0,
+    rejectedInvalid: args.importResult?.rejectedInvalid ?? 0,
+    hasMore: args.slice?.cursor?.hasMore === true,
+    nextAfterId: args.slice?.cursor?.nextAfterId ?? null,
+    lastTimestamp: lastTimestamp(args.slice),
+    ...args.slice?.summary ? { summary: args.slice.summary } : {},
+    ...args.error ? {
+      error: args.error,
+      noFallbackReason: "Ledger reconciliation is P2P/local-first only; Cloud/D1 ledger sync is intentionally disabled."
+    } : {}
+  };
+}
+function buildMeshLedgerReconciliationEvidence(meshId, replicas) {
+  const failedNodes = replicas.filter((replica) => replica.status === "failed").map((replica) => replica.nodeId);
+  const pendingNodes = replicas.filter((replica) => replica.hasMore && replica.status !== "failed").map((replica) => replica.nodeId);
+  return {
+    protocol: "adhdev.mesh.ledger.reconciliation.v1",
+    meshId,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sourceOfTruth: {
+      kind: "coordinator_local_jsonl",
+      p2pOnly: true,
+      cloudD1LedgerSync: false,
+      notes: "Coordinator reconciles bounded slices from daemon-local JSONL ledgers over P2P DataChannel; Cloud/D1 is not a ledger source of truth."
+    },
+    replicas,
+    totals: {
+      replicas: replicas.length,
+      queried: replicas.filter((replica) => replica.status !== "failed").length,
+      failed: failedNodes.length,
+      entriesReceived: replicas.reduce((sum, replica) => sum + replica.entriesReceived, 0),
+      entriesImported: replicas.reduce((sum, replica) => sum + replica.entriesImported, 0),
+      skippedDuplicate: replicas.reduce((sum, replica) => sum + replica.skippedDuplicate, 0),
+      rejectedInvalid: replicas.reduce((sum, replica) => sum + replica.rejectedInvalid, 0)
+    },
+    convergence: {
+      complete: failedNodes.length === 0 && pendingNodes.length === 0,
+      pendingNodes,
+      failedNodes
+    }
+  };
+}
+
+// src/index.ts
 init_mesh_work_queue();
 init_mesh_events();
 
@@ -24918,6 +25031,35 @@ var DaemonCommandRouter = class {
           return { success: false, error: e.message };
         }
       }
+      case "get_mesh_ledger_slice": {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        try {
+          const { readLedgerSlice: readLedgerSlice2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+          const kind = Array.isArray(args?.kind) ? args.kind.filter((k) => typeof k === "string") : void 0;
+          const slice = readLedgerSlice2(meshId, {
+            afterId: typeof args?.afterId === "string" ? args.afterId : void 0,
+            since: typeof args?.since === "string" ? args.since : void 0,
+            kind,
+            limit: typeof args?.limit === "number" ? args.limit : void 0
+          });
+          return { success: true, slice };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      }
+      case "import_mesh_ledger_slice": {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        try {
+          const { appendRemoteLedgerEntries: appendRemoteLedgerEntries2, getLedgerSummary: getLedgerSummary2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+          const entries = Array.isArray(args?.entries) ? args.entries : Array.isArray(args?.slice?.entries) ? args.slice.entries : [];
+          const result = appendRemoteLedgerEntries2(meshId, entries);
+          return { success: true, result, summary: getLedgerSummary2(meshId) };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      }
       case "get_mesh_queue": {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         if (!meshId) return { success: false, error: "meshId required" };
@@ -33678,6 +33820,7 @@ async function shutdownDaemonComponents(components) {
   IdeProviderInstance,
   InMemoryGitSnapshotStore,
   LOG,
+  MAX_LEDGER_SLICE_LIMIT,
   MIN_GIT_WORKSPACE_POLL_INTERVAL_MS,
   MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
   MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
@@ -33693,12 +33836,15 @@ async function shutdownDaemonComponents(components) {
   addNode,
   appendLedgerEntry,
   appendRecentActivity,
+  appendRemoteLedgerEntries,
   buildAssistantChatMessage,
   buildChatMessage,
   buildChatMessageSignature,
   buildChatTailDeliverySignature,
   buildCoordinatorSystemPrompt,
   buildMachineInfo,
+  buildMeshLedgerReconciliationEvidence,
+  buildMeshLedgerReplicaEvidence,
   buildP2pRelayFailurePayload,
   buildPinnedGlobalInstallCommand,
   buildRuntimeSystemChatMessage,
@@ -33821,6 +33967,7 @@ async function shutdownDaemonComponents(components) {
   probeCdpPort,
   readChatHistory,
   readLedgerEntries,
+  readLedgerSlice,
   recordDebugTrace,
   registerExtensionProviders,
   removeNode,