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

package/dist/mesh/mesh-ledger-reconciliation.d.ts

@@ -0,0 +1,55 @@
+import type { AppendRemoteLedgerResult, MeshLedgerSlice, MeshLedgerSummary } from './mesh-ledger.js';
+export type MeshLedgerReplicaStatus = 'local' | 'queried' | 'imported' | 'failed';
+export interface MeshLedgerReplicaEvidence {
+    nodeId: string;
+    daemonId?: string;
+    status: MeshLedgerReplicaStatus;
+    transport: 'local' | 'p2p_datachannel';
+    protocol: 'adhdev.mesh.ledger.slice.v1';
+    entriesReceived: number;
+    entriesImported: number;
+    skippedDuplicate: number;
+    rejectedInvalid: number;
+    hasMore: boolean;
+    nextAfterId: string | null;
+    lastTimestamp: string | null;
+    summary?: MeshLedgerSummary;
+    error?: string;
+    noFallbackReason?: string;
+}
+export interface MeshLedgerReconciliationEvidence {
+    protocol: 'adhdev.mesh.ledger.reconciliation.v1';
+    meshId: string;
+    generatedAt: string;
+    sourceOfTruth: {
+        kind: 'coordinator_local_jsonl';
+        p2pOnly: true;
+        cloudD1LedgerSync: false;
+        notes: string;
+    };
+    replicas: MeshLedgerReplicaEvidence[];
+    totals: {
+        replicas: number;
+        queried: number;
+        failed: number;
+        entriesReceived: number;
+        entriesImported: number;
+        skippedDuplicate: number;
+        rejectedInvalid: number;
+    };
+    convergence: {
+        complete: boolean;
+        pendingNodes: string[];
+        failedNodes: string[];
+    };
+}
+export declare function buildMeshLedgerReplicaEvidence(args: {
+    nodeId: string;
+    daemonId?: string;
+    transport: 'local' | 'p2p_datachannel';
+    slice?: MeshLedgerSlice;
+    importResult?: AppendRemoteLedgerResult;
+    status?: MeshLedgerReplicaStatus;
+    error?: string;
+}): MeshLedgerReplicaEvidence;
+export declare function buildMeshLedgerReconciliationEvidence(meshId: string, replicas: MeshLedgerReplicaEvidence[]): MeshLedgerReconciliationEvidence;

package/dist/mesh/mesh-ledger.d.ts

@@ -13,7 +13,7 @@
  * Safety:  mode 0o600, atomic append via appendFileSync
  */
 import { EventEmitter } from 'events';
-export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_removed' | 'coordinator_started' | 'recovery_attempted';
+export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;
@@ -41,6 +41,42 @@ export interface ReadLedgerOptions {
     since?: string;
     kind?: MeshLedgerKind[];
 }
+export interface ReadLedgerSliceOptions {
+    /** Return entries strictly after this entry id. If not found, starts from the beginning of the filtered set. */
+    afterId?: string;
+    /** Return entries at or after this timestamp. */
+    since?: string;
+    /** Optional event kind filter. */
+    kind?: MeshLedgerKind[];
+    /** Maximum entries to return. Clamped to a bounded protocol maximum. */
+    limit?: number;
+}
+export interface MeshLedgerCursor {
+    afterId: string | null;
+    nextAfterId: string | null;
+    limit: number;
+    hasMore: boolean;
+}
+export interface MeshLedgerSlice {
+    protocol: 'adhdev.mesh.ledger.slice.v1';
+    meshId: string;
+    entries: MeshLedgerEntry[];
+    cursor: MeshLedgerCursor;
+    summary: MeshLedgerSummary;
+    sourceOfTruth: {
+        kind: 'local_jsonl';
+        path: string;
+        bounded: true;
+        maxLimit: number;
+    };
+}
+export interface AppendRemoteLedgerResult {
+    accepted: number;
+    skippedDuplicate: number;
+    rejectedInvalid: number;
+    entries: MeshLedgerEntry[];
+}
+export declare const MAX_LEDGER_SLICE_LIMIT = 500;
 export declare function getLedgerDir(): string;
 /**
  * Append a new entry to the mesh ledger.
@@ -49,14 +85,20 @@ export declare function getLedgerDir(): string;
 export declare const meshLedgerEvents: EventEmitter<[never]>;
 export declare function appendLedgerEntry(meshId: string, partial: Omit<MeshLedgerEntry, 'id' | 'meshId' | 'timestamp'>): MeshLedgerEntry;
 /**
- * Append entries received from the cloud to the local ledger.
- * This skips deduplicated entries and just writes new ones.
+ * Append entries received over local-first/P2P ledger replication to the local ledger.
+ * This skips deduplicated entries and rejects malformed/cross-mesh entries.
  */
-export declare function appendRemoteLedgerEntries(meshId: string, entries: MeshLedgerEntry[]): void;
+export declare function appendRemoteLedgerEntries(meshId: string, entries: MeshLedgerEntry[]): AppendRemoteLedgerResult;
 /**
  * Read ledger entries with optional filtering.
  */
 export declare function readLedgerEntries(meshId: string, opts?: ReadLedgerOptions): MeshLedgerEntry[];
+/**
+ * Read a bounded, cursor-addressable ledger slice for local-first/P2P replication.
+ * The result is intentionally small and self-describing so coordinators can query
+ * remote daemons on demand without Cloud/D1 becoming a ledger data-plane.
+ */
+export declare function readLedgerSlice(meshId: string, opts?: ReadLedgerSliceOptions): MeshLedgerSlice;
 /**
  * Get a summary of mesh activity from the ledger.
  */

package/dist/mesh/mesh-sync.d.ts

@@ -1,10 +1,12 @@
 /**
- * Mesh Sync — Sync local mesh config to/from cloud D1
+ * Mesh Sync — Sync local mesh metadata to/from cloud D1
  *
  * When cloud is available, this module pushes local mesh config
  * to the server and pulls remote meshes that were created from
  * other machines. The local ~/.adhdev/meshes.json remains the
- * canonical source; cloud is a persistence/relay layer.
+ * canonical source; cloud is a membership/metadata layer only.
+ * Task/chat/ledger evidence remains local-first and must not be
+ * synchronized through Cloud/D1.
  *
  * This is called lazily (not on daemon startup) — only when the
  * user explicitly opens the mesh page or runs `adhdev mesh sync`.
@@ -26,12 +28,6 @@ export interface MeshSyncTransport {
     }>;
     /** DELETE /api/v1/repo-meshes/:id */
     deleteRemoteMesh(meshId: string): Promise<void>;
-    /** POST /api/v1/repo-meshes/:id/ledger/sync */
-    syncMeshLedger?(meshId: string, data: {
-        newEntries: any[];
-    }): Promise<{
-        missingEntries: any[];
-    }>;
 }
 export interface RemoteMeshRecord {
     id: string;
@@ -55,7 +51,3 @@ export interface MeshSyncResult {
  * Pull remote meshes that don't exist locally.
  */
 export declare function syncMeshes(transport: MeshSyncTransport): Promise<MeshSyncResult>;
-/**
- * Sync the task ledger for a specific mesh.
- */
-export declare function syncMeshLedger(meshId: string, transport: MeshSyncTransport): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.77-rc.47",
+  "version": "0.9.77-rc.49",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/router.ts

@@ -1821,6 +1821,41 @@ export class DaemonCommandRouter {
                 }
             }
 
+            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 } = await import('../mesh/mesh-ledger.js');
+                    const kind = Array.isArray(args?.kind) ? args.kind.filter((k: any) => typeof k === 'string') : undefined;
+                    const slice = readLedgerSlice(meshId, {
+                        afterId: typeof args?.afterId === 'string' ? args.afterId : undefined,
+                        since: typeof args?.since === 'string' ? args.since : undefined,
+                        kind,
+                        limit: typeof args?.limit === 'number' ? args.limit : undefined,
+                    });
+                    return { success: true, slice };
+                } catch (e: any) {
+                    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, getLedgerSummary } = await import('../mesh/mesh-ledger.js');
+                    const entries = Array.isArray(args?.entries)
+                        ? args.entries as any[]
+                        : Array.isArray(args?.slice?.entries)
+                            ? args.slice.entries as any[]
+                            : [];
+                    const result = appendRemoteLedgerEntries(meshId, entries as any);
+                    return { success: true, result, summary: getLedgerSummary(meshId) };
+                } catch (e: any) {
+                    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' };

package/src/index.ts

@@ -150,8 +150,10 @@ export { syncMeshes } from './mesh/mesh-sync.js';
 export type { MeshSyncTransport, MeshSyncResult, RemoteMeshRecord } from './mesh/mesh-sync.js';
 
 // ── Mesh Task Ledger ──
-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';
 
 // ── Mesh Work Queue (GUPP) ──
 export { enqueueTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats } from './mesh/mesh-work-queue.js';

package/src/mesh/mesh-ledger-reconciliation.ts

@@ -0,0 +1,115 @@
+import type { AppendRemoteLedgerResult, MeshLedgerSlice, MeshLedgerSummary } from './mesh-ledger.js';
+
+export type MeshLedgerReplicaStatus = 'local' | 'queried' | 'imported' | 'failed';
+
+export interface MeshLedgerReplicaEvidence {
+    nodeId: string;
+    daemonId?: string;
+    status: MeshLedgerReplicaStatus;
+    transport: 'local' | 'p2p_datachannel';
+    protocol: 'adhdev.mesh.ledger.slice.v1';
+    entriesReceived: number;
+    entriesImported: number;
+    skippedDuplicate: number;
+    rejectedInvalid: number;
+    hasMore: boolean;
+    nextAfterId: string | null;
+    lastTimestamp: string | null;
+    summary?: MeshLedgerSummary;
+    error?: string;
+    noFallbackReason?: string;
+}
+
+export interface MeshLedgerReconciliationEvidence {
+    protocol: 'adhdev.mesh.ledger.reconciliation.v1';
+    meshId: string;
+    generatedAt: string;
+    sourceOfTruth: {
+        kind: 'coordinator_local_jsonl';
+        p2pOnly: true;
+        cloudD1LedgerSync: false;
+        notes: string;
+    };
+    replicas: MeshLedgerReplicaEvidence[];
+    totals: {
+        replicas: number;
+        queried: number;
+        failed: number;
+        entriesReceived: number;
+        entriesImported: number;
+        skippedDuplicate: number;
+        rejectedInvalid: number;
+    };
+    convergence: {
+        complete: boolean;
+        pendingNodes: string[];
+        failedNodes: string[];
+    };
+}
+
+function lastTimestamp(slice?: MeshLedgerSlice): string | null {
+    const entries = Array.isArray(slice?.entries) ? slice!.entries : [];
+    return entries.length ? entries[entries.length - 1].timestamp : null;
+}
+
+export function buildMeshLedgerReplicaEvidence(args: {
+    nodeId: string;
+    daemonId?: string;
+    transport: 'local' | 'p2p_datachannel';
+    slice?: MeshLedgerSlice;
+    importResult?: AppendRemoteLedgerResult;
+    status?: MeshLedgerReplicaStatus;
+    error?: string;
+}): MeshLedgerReplicaEvidence {
+    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.',
+        } : {}),
+    };
+}
+
+export function buildMeshLedgerReconciliationEvidence(meshId: string, replicas: MeshLedgerReplicaEvidence[]): MeshLedgerReconciliationEvidence {
+    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: 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,
+        },
+    };
+}

package/src/mesh/mesh-ledger.ts

@@ -34,6 +34,8 @@ export type MeshLedgerKind =
     | 'node_removed'
     | 'coordinator_started'
     | 'recovery_attempted'
+    | 'ledger_replicated'
+    | 'ledger_reconciled'
     ;
 
 export interface MeshLedgerEntry {
@@ -66,11 +68,52 @@ export interface ReadLedgerOptions {
     kind?: MeshLedgerKind[];
 }
 
+export interface ReadLedgerSliceOptions {
+    /** Return entries strictly after this entry id. If not found, starts from the beginning of the filtered set. */
+    afterId?: string;
+    /** Return entries at or after this timestamp. */
+    since?: string;
+    /** Optional event kind filter. */
+    kind?: MeshLedgerKind[];
+    /** Maximum entries to return. Clamped to a bounded protocol maximum. */
+    limit?: number;
+}
+
+export interface MeshLedgerCursor {
+    afterId: string | null;
+    nextAfterId: string | null;
+    limit: number;
+    hasMore: boolean;
+}
+
+export interface MeshLedgerSlice {
+    protocol: 'adhdev.mesh.ledger.slice.v1';
+    meshId: string;
+    entries: MeshLedgerEntry[];
+    cursor: MeshLedgerCursor;
+    summary: MeshLedgerSummary;
+    sourceOfTruth: {
+        kind: 'local_jsonl';
+        path: string;
+        bounded: true;
+        maxLimit: number;
+    };
+}
+
+export interface AppendRemoteLedgerResult {
+    accepted: number;
+    skippedDuplicate: number;
+    rejectedInvalid: number;
+    entries: MeshLedgerEntry[];
+}
+
 // ─── Constants ──────────────────────────────────
 
 const LEDGER_DIR_NAME = 'mesh-ledger';
 const MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024; // 10 MB
 const RECENT_FAILURE_WINDOW_MS = 30 * 60 * 1000; // 30 minutes
+const DEFAULT_LEDGER_SLICE_LIMIT = 100;
+export const MAX_LEDGER_SLICE_LIMIT = 500;
 
 // ─── Path Helpers ───────────────────────────────
 
@@ -136,23 +179,59 @@ export function appendLedgerEntry(
     }
 }
 
+function clampLedgerSliceLimit(limit: unknown): number {
+    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: string, value: unknown): value is MeshLedgerEntry {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+    const entry = value as Partial<MeshLedgerEntry>;
+    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;
+}
+
 /**
- * Append entries received from the cloud to the local ledger.
- * This skips deduplicated entries and just writes new ones.
+ * Append entries received over local-first/P2P ledger replication to the local ledger.
+ * This skips deduplicated entries and rejects malformed/cross-mesh entries.
  */
-export function appendRemoteLedgerEntries(meshId: string, entries: MeshLedgerEntry[]): void {
-    if (entries.length === 0) return;
+export function appendRemoteLedgerEntries(meshId: string, entries: MeshLedgerEntry[]): AppendRemoteLedgerResult {
+    if (entries.length === 0) return { accepted: 0, skippedDuplicate: 0, rejectedInvalid: 0, entries: [] };
     const ledgerPath = getLedgerPath(meshId);
 
     // Read existing to deduplicate by ID
     const existing = new Set(readLedgerEntries(meshId).map(e => e.id));
-    const newEntries = entries.filter(e => !existing.has(e.id));
+    const validEntries: MeshLedgerEntry[] = [];
+    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 (newEntries.length === 0) return;
+    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';
         appendFileSync(ledgerPath, lines, { encoding: 'utf-8', mode: 0o600 });
+        for (const entry of validEntries) {
+            meshLedgerEvents.emit('append', meshId, entry);
+        }
+        return { accepted: validEntries.length, skippedDuplicate, rejectedInvalid, entries: validEntries };
     } catch (e: any) {
         throw new Error(`Failed to append remote ledger entries for mesh ${meshId}: ${e.message}`);
     }
@@ -206,6 +285,40 @@ export function readLedgerEntries(meshId: string, opts?: ReadLedgerOptions): Mes
     return entries;
 }
 
+/**
+ * Read a bounded, cursor-addressable ledger slice for local-first/P2P replication.
+ * The result is intentionally small and self-describing so coordinators can query
+ * remote daemons on demand without Cloud/D1 becoming a ledger data-plane.
+ */
+export function readLedgerSlice(meshId: string, opts?: ReadLedgerSliceOptions): MeshLedgerSlice {
+    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,
+        },
+    };
+}
+
 /**
  * Get a summary of mesh activity from the ledger.
  */

package/src/mesh/mesh-sync.ts

@@ -1,10 +1,12 @@
 /**
- * Mesh Sync — Sync local mesh config to/from cloud D1
+ * Mesh Sync — Sync local mesh metadata to/from cloud D1
  *
  * When cloud is available, this module pushes local mesh config
  * to the server and pulls remote meshes that were created from
  * other machines. The local ~/.adhdev/meshes.json remains the
- * canonical source; cloud is a persistence/relay layer.
+ * canonical source; cloud is a membership/metadata layer only.
+ * Task/chat/ledger evidence remains local-first and must not be
+ * synchronized through Cloud/D1.
  *
  * This is called lazily (not on daemon startup) — only when the
  * user explicitly opens the mesh page or runs `adhdev mesh sync`.
@@ -26,8 +28,6 @@ export interface MeshSyncTransport {
     }): Promise<{ mesh: RemoteMeshRecord }>;
     /** DELETE /api/v1/repo-meshes/:id */
     deleteRemoteMesh(meshId: string): Promise<void>;
-    /** POST /api/v1/repo-meshes/:id/ledger/sync */
-    syncMeshLedger?(meshId: string, data: { newEntries: any[] }): Promise<{ missingEntries: any[] }>;
 }
 
 export interface RemoteMeshRecord {
@@ -107,35 +107,5 @@ export async function syncMeshes(transport: MeshSyncTransport): Promise<MeshSync
         }
     }
 
-    // Sync ledgers for all local meshes if the transport supports it
-    if (transport.syncMeshLedger) {
-        for (const local of localMeshes) {
-            try {
-                await syncMeshLedger(local.id, transport);
-            } catch (e: any) {
-                result.errors.push(`Ledger sync failed for "${local.name}": ${e.message}`);
-            }
-        }
-    }
-
     return result;
 }
-
-/**
- * Sync the task ledger for a specific mesh.
- */
-export async function syncMeshLedger(meshId: string, transport: MeshSyncTransport): Promise<void> {
-    if (!transport.syncMeshLedger) return;
-    const { readLedgerEntries, appendRemoteLedgerEntries } = await import('./mesh-ledger.js');
-    
-    // Read all local entries (no tail)
-    const localEntries = readLedgerEntries(meshId);
-    
-    // Send to cloud and get missing entries back
-    const res = await transport.syncMeshLedger(meshId, { newEntries: localEntries });
-    
-    // Append any missing entries from the cloud
-    if (res.missingEntries && res.missingEntries.length > 0) {
-        appendRemoteLedgerEntries(meshId, res.missingEntries);
-    }
-}