@adhdev/daemon-core 0.9.77-rc.9 → 0.9.78

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

@@ -27,12 +27,15 @@ export type MeshLedgerKind =
     | '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 {
@@ -46,6 +49,56 @@ export interface MeshLedgerEntry {
     payload: Record<string, unknown>;
 }
 
+export function isIntentionalCleanupStopEntry(entry: Pick<MeshLedgerEntry, 'kind' | 'payload'>): boolean {
+    if (entry.kind !== 'session_stopped' && entry.kind !== 'task_failed' && entry.kind !== 'task_stalled') return false;
+    const payload = entry.payload && typeof entry.payload === 'object' && !Array.isArray(entry.payload)
+        ? entry.payload as Record<string, unknown>
+        : {};
+    return payload.intentional === true
+        && (payload.reason === 'operator_cleanup'
+            || payload.intentionalStopReason === 'operator_cleanup'
+            || payload.source === 'mesh_cleanup_sessions'
+            || payload.source === 'mesh_remove_node');
+}
+
+export interface MeshTaskCompletionEvidence {
+    source: 'agent_status_event';
+    event: 'agent:generating_completed' | 'agent:ready';
+    nodeId: string;
+    sessionId: string;
+    providerType?: string;
+    completedAt: string;
+    transcriptHandle: {
+        kind: 'provider_session' | 'runtime_session';
+        sessionId: string;
+        providerSessionId?: string;
+        finalSummaryAvailable: boolean;
+    };
+    git: {
+        status: 'deferred';
+        reason: string;
+    };
+    validation: {
+        status: 'deferred';
+        commandsRun: string[];
+        reason: string;
+    };
+    checkpoint: {
+        attempted: false;
+        reason: 'not_attempted_for_ordinary_completion';
+    };
+}
+
+export interface BuildTaskCompletionEvidenceOptions {
+    event: MeshTaskCompletionEvidence['event'];
+    nodeId: string;
+    sessionId: string;
+    providerType?: string;
+    providerSessionId?: string;
+    finalSummary?: string;
+    completedAt?: string;
+}
+
 export interface MeshLedgerSummary {
     meshId: string;
     totalEntries: number;
@@ -65,11 +118,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 ───────────────────────────────
 
@@ -94,6 +188,38 @@ function getRotatedPath(meshId: string, index: number): string {
 
 // ─── Core API ───────────────────────────────────
 
+export function buildTaskCompletionEvidence(opts: BuildTaskCompletionEvidenceOptions): MeshTaskCompletionEvidence {
+    const providerSessionId = opts.providerSessionId?.trim() || undefined;
+    const providerType = opts.providerType?.trim() || undefined;
+    return {
+        source: 'agent_status_event',
+        event: opts.event,
+        nodeId: opts.nodeId,
+        sessionId: opts.sessionId,
+        providerType,
+        completedAt: opts.completedAt || new Date().toISOString(),
+        transcriptHandle: {
+            kind: providerSessionId ? 'provider_session' : 'runtime_session',
+            sessionId: opts.sessionId,
+            providerSessionId,
+            finalSummaryAvailable: typeof opts.finalSummary === 'string' && opts.finalSummary.trim().length > 0,
+        },
+        git: {
+            status: 'deferred',
+            reason: 'ordinary_completion_git_status_not_checked',
+        },
+        validation: {
+            status: 'deferred',
+            commandsRun: [],
+            reason: 'ordinary_completion_validation_not_run',
+        },
+        checkpoint: {
+            attempted: false,
+            reason: 'not_attempted_for_ordinary_completion',
+        },
+    };
+}
+
 /**
  * Append a new entry to the mesh ledger.
  * Handles file creation, rotation on size overflow, and atomic writes.
@@ -135,23 +261,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}`);
     }
@@ -205,6 +367,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.
  */
@@ -231,13 +427,17 @@ export function getLedgerSummary(meshId: string): MeshLedgerSummary {
             case 'task_dispatched': summary.taskDispatched++; break;
             case 'task_completed': summary.taskCompleted++; break;
             case 'task_failed': {
+                if (isIntentionalCleanupStopEntry(entry)) break;
                 summary.taskFailed++;
                 if (new Date(entry.timestamp).getTime() >= recentFailureCutoff) {
                     summary.recentFailures++;
                 }
                 break;
             }
-            case 'task_stalled': summary.taskStalled++; break;
+            case 'task_stalled': {
+                if (!isIntentionalCleanupStopEntry(entry)) summary.taskStalled++;
+                break;
+            }
             case 'session_launched': summary.sessionLaunched++; break;
             case 'checkpoint_created': summary.checkpointCreated++; break;
         }
@@ -308,6 +508,7 @@ export function getSessionRecoveryContext(
         if (new Date(e.timestamp).getTime() < recentWindow) break;
         if (opts.nodeId && e.nodeId !== opts.nodeId) continue;
         if (e.kind === 'task_failed') {
+            if (isIntentionalCleanupStopEntry(e)) continue;
             consecutiveNodeFailures++;
         } else if (e.kind === 'task_completed' || e.kind === 'task_dispatched') {
             // A completion or new dispatch breaks the consecutive failure chain

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);
-    }
-}