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

package/dist/index.js

@@ -22894,13 +22894,15 @@ Follow these recovery rules:
     });
     var mesh_ledger_exports = {};
     __export2(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);
@@ -22943,15 +22945,49 @@ Follow these recovery rules:
         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}`);
       }
@@ -22990,6 +23026,34 @@ Follow these recovery rules:
       }
       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();
@@ -23119,6 +23183,8 @@ Follow these recovery rules:
     var LEDGER_DIR_NAME;
     var MAX_FILE_SIZE_BYTES;
     var RECENT_FAILURE_WINDOW_MS;
+    var DEFAULT_LEDGER_SLICE_LIMIT;
+    var MAX_LEDGER_SLICE_LIMIT;
     var meshLedgerEvents;
     var init_mesh_ledger = __esm2({
       "src/mesh/mesh-ledger.ts"() {
@@ -23131,6 +23197,8 @@ Follow these recovery rules:
         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();
       }
     });
@@ -27444,6 +27512,7 @@ ${lastSnapshot}`;
       IdeProviderInstance: () => IdeProviderInstance,
       InMemoryGitSnapshotStore: () => InMemoryGitSnapshotStore,
       LOG: () => LOG2,
+      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_MS2,
       MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS: () => MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS2,
@@ -27459,12 +27528,15 @@ ${lastSnapshot}`;
       addNode: () => addNode,
       appendLedgerEntry: () => appendLedgerEntry,
       appendRecentActivity: () => appendRecentActivity,
+      appendRemoteLedgerEntries: () => appendRemoteLedgerEntries,
       buildAssistantChatMessage: () => buildAssistantChatMessage,
       buildChatMessage: () => buildChatMessage,
       buildChatMessageSignature: () => buildChatMessageSignature,
       buildChatTailDeliverySignature: () => buildChatTailDeliverySignature,
       buildCoordinatorSystemPrompt: () => buildCoordinatorSystemPrompt,
       buildMachineInfo: () => buildMachineInfo2,
+      buildMeshLedgerReconciliationEvidence: () => buildMeshLedgerReconciliationEvidence,
+      buildMeshLedgerReplicaEvidence: () => buildMeshLedgerReplicaEvidence,
       buildP2pRelayFailurePayload: () => buildP2pRelayFailurePayload,
       buildPinnedGlobalInstallCommand: () => buildPinnedGlobalInstallCommand,
       buildRuntimeSystemChatMessage: () => buildRuntimeSystemChatMessage,
@@ -27587,6 +27659,7 @@ ${lastSnapshot}`;
       probeCdpPort: () => probeCdpPort,
       readChatHistory: () => readChatHistory,
       readLedgerEntries: () => readLedgerEntries,
+      readLedgerSlice: () => readLedgerSlice,
       recordDebugTrace: () => recordDebugTrace,
       registerExtensionProviders: () => registerExtensionProviders,
       removeNode: () => removeNode,
@@ -29454,27 +29527,65 @@ ${lastSnapshot}`;
           }
         }
       }
-      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);
-      }
-    }
     init_mesh_ledger();
+    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
+        }
+      };
+    }
     init_mesh_work_queue();
     init_mesh_events();
     var NO_FALLBACK_REASON = "Repo Mesh command/data-plane is P2P-only; WS/REST command fallback is intentionally disabled to preserve the transport boundary.";
@@ -46872,6 +46983,35 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               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" };