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

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

@@ -8,20 +8,27 @@ export interface PendingMeshCoordinatorEvent {
 }
 /** Drain and return all pending coordinator events, clearing the queue. */
 export declare function drainPendingMeshCoordinatorEvents(): PendingMeshCoordinatorEvent[];
-export declare function tryAssignQueueTask(components: {
-    cliManager: any;
-}, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
+/** Peek at pending coordinator events without draining (non-destructive). */
+export declare function getPendingMeshCoordinatorEvents(): readonly PendingMeshCoordinatorEvent[];
+/** Explicitly clear all pending coordinator events. */
+export declare function clearPendingMeshCoordinatorEvents(): void;
+export declare function tryAssignQueueTask(components: DaemonComponents, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
 /**
  * Triggers a queue check for all nodes in the mesh.
  * Called when a new task is enqueued, in case nodes are already idle.
  */
-export declare function triggerMeshQueue(components: {
-    instanceManager: any;
-    cliManager: any;
-}, meshId: string): void;
+export declare function triggerMeshQueue(components: DaemonComponents, meshId: string): Promise<void>;
 export declare function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>): {
     success: boolean;
     forwarded: number;
+    suppressed: boolean;
+    intentionalCleanupStop: boolean;
+    error?: undefined;
+} | {
+    success: boolean;
+    forwarded: number;
+    suppressed?: undefined;
+    intentionalCleanupStop?: undefined;
     error?: undefined;
 } | {
     success: boolean;

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_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;
@@ -24,6 +24,43 @@ export interface MeshLedgerEntry {
     providerType?: string;
     payload: Record<string, unknown>;
 }
+export declare function isIntentionalCleanupStopEntry(entry: Pick<MeshLedgerEntry, 'kind' | 'payload'>): boolean;
+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;
@@ -41,7 +78,44 @@ 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;
+export declare function buildTaskCompletionEvidence(opts: BuildTaskCompletionEvidenceOptions): MeshTaskCompletionEvidence;
 /**
  * Append a new entry to the mesh ledger.
  * Handles file creation, rotation on size overflow, and atomic writes.
@@ -49,14 +123,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/dist/mesh/mesh-visualization.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Mesh Visualization — Transform RepoMeshStatus into a graph structure
+ * for SVG/Canvas rendering without external dependencies.
+ */
+import type { RepoMeshStatus, RepoMeshNodeStatus, RepoMeshNodeHealth } from '../repo-mesh-types.js';
+export type MeshGraphNodeType = 'defaultBranchNode' | 'worktreeNode' | 'orphanNode';
+export type MeshGraphEdgeType = 'parentBranch' | 'worktreeLink' | 'sessionLink';
+export interface MeshGraphNode {
+    id: string;
+    type: MeshGraphNodeType;
+    label: string;
+    workspace: string;
+    branch: string | null;
+    health: RepoMeshNodeHealth;
+    ahead: number;
+    behind: number;
+    dirty: boolean;
+    dirtyFiles: number;
+    hasConflicts: boolean;
+    activeSessionCount: number;
+    activeSessions: string[];
+    providers: string[];
+    isOrphan: boolean;
+    orphanReasons: string[];
+    /** Next-step hint from convergence analysis */
+    nextStepHint?: string;
+    /** Original node status for drill-down */
+    source: RepoMeshNodeStatus;
+}
+export interface MeshGraphEdge {
+    id: string;
+    source: string;
+    target: string;
+    type: MeshGraphEdgeType;
+    label?: string;
+}
+export interface MeshGraph {
+    meshId: string;
+    meshName: string;
+    repoIdentity: string;
+    refreshedAt: string;
+    nodes: MeshGraphNode[];
+    edges: MeshGraphEdge[];
+    /** Summary statistics */
+    stats: {
+        totalNodes: number;
+        onlineNodes: number;
+        dirtyNodes: number;
+        orphanNodes: number;
+        errorNodes: number;
+        offlineNodes: number;
+        totalActiveSessions: number;
+    };
+    /** Global orphan / stale warnings */
+    warnings: string[];
+}
+/**
+ * Build a visualization graph from RepoMeshStatus.
+ *
+ * Nodes:
+ *   - defaultBranchNode: the mesh's default branch (aggregated from nodes on that branch)
+ *   - worktreeNode: a node on a feature / worktree branch
+ *   - orphanNode: a node with orphanReasons (upstream missing, detached HEAD, etc.)
+ *
+ * Edges:
+ *   - parentBranch: default branch → worktree branch (when branch name differs)
+ *   - worktreeLink: links nodes that share the same branch (clustering hint)
+ *   - sessionLink: node → session (lightweight, optional; not rendered as primary edge)
+ */
+export declare function buildMeshGraph(status: RepoMeshStatus): MeshGraph;

package/dist/mesh/mesh-work-queue.d.ts

@@ -1,4 +1,8 @@
-export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed';
+export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | 'cancelled';
+export type MeshActiveTaskStatus = Extract<MeshTaskStatus, 'pending' | 'assigned'>;
+export type MeshHistoricalTaskStatus = Extract<MeshTaskStatus, 'completed' | 'failed' | 'cancelled'>;
+export declare const ACTIVE_MESH_QUEUE_STATUSES: MeshActiveTaskStatus[];
+export declare const HISTORICAL_MESH_QUEUE_STATUSES: MeshHistoricalTaskStatus[];
 export interface MeshWorkQueueEntry {
     id: string;
     meshId: string;
@@ -6,10 +10,30 @@ export interface MeshWorkQueueEntry {
     status: MeshTaskStatus;
     /** If specified, only this node can claim the task (used by legacy mesh_send_task) */
     targetNodeId?: string;
+    /** If specified, only this runtime session can claim the task */
+    targetSessionId?: string;
     /** The node that actually claimed and is executing the task */
     assignedNodeId?: string;
     /** The session currently executing the task */
     assignedSessionId?: string;
+    /** Human/operator reason for terminal cancellation. */
+    cancelReason?: string;
+    cancelledAt?: string;
+    /** Human/operator reason for manually requeueing a task. */
+    requeueReason?: string;
+    requeuedAt?: string;
+    requeueCount?: number;
+    /** Last automatic queue session spin-up attempt, for mesh_view_queue/debug visibility. */
+    autoLaunch?: {
+        status: 'skipped' | 'started' | 'failed' | 'completed';
+        reason?: string;
+        nodeId?: string;
+        providerType?: string;
+        sessionId?: string;
+        updatedAt: string;
+    };
+    /** ISO timestamp when the task was dispatched (assigned) to a node/session. Used for precise matching on completion. */
+    dispatchTimestamp?: string;
     createdAt: string;
     updatedAt: string;
 }
@@ -18,6 +42,7 @@ export interface MeshWorkQueueEntry {
  */
 export declare function enqueueTask(meshId: string, message: string, opts?: {
     targetNodeId?: string;
+    targetSessionId?: string;
 }): MeshWorkQueueEntry;
 /**
  * Get all tasks in the queue, optionally filtered by status.
@@ -34,15 +59,47 @@ export declare function claimNextTask(meshId: string, nodeId: string, sessionId:
  * Used when a session completes, fails, or stalls.
  */
 export declare function updateTaskStatus(meshId: string, taskId: string, status: MeshTaskStatus): MeshWorkQueueEntry | null;
+export declare function recordTaskAutoLaunch(meshId: string, taskId: string, autoLaunch: Omit<NonNullable<MeshWorkQueueEntry['autoLaunch']>, 'updatedAt'>): MeshWorkQueueEntry | null;
+/**
+ * Mark a queue task as manually cancelled without deleting audit history.
+ */
+export declare function cancelTask(meshId: string, taskId: string, opts?: {
+    reason?: string;
+}): MeshWorkQueueEntry | null;
+/**
+ * Return a queue task to pending for retry. By default, dead session targeting
+ * and assigned ownership are cleared so stale assignments do not strand again.
+ */
+export declare function requeueTask(meshId: string, taskId: string, opts?: {
+    reason?: string;
+    targetNodeId?: string;
+    targetSessionId?: string;
+    clearTargetNode?: boolean;
+    clearTargetSession?: boolean;
+}): MeshWorkQueueEntry | null;
 /**
  * Update the status of the task currently assigned to a specific session.
  */
 export declare function updateSessionTaskStatus(meshId: string, sessionId: string, status: MeshTaskStatus): MeshWorkQueueEntry | null;
 export interface MeshWorkQueueStats {
+    total: number;
+    active: number;
+    historical: number;
     pending: number;
     assigned: number;
     completed: number;
     failed: number;
+    cancelled: number;
+    /** Source-of-truth active queue counters; only pending/assigned are live work. */
+    activeCounts: Record<MeshActiveTaskStatus, number>;
+    /** Terminal ledger records kept for audit/history; never count as active work. */
+    historicalCounts: Record<MeshHistoricalTaskStatus, number>;
+    activeAssignments: Array<{
+        id: string;
+        nodeId?: string;
+        sessionId?: string;
+        message: string;
+    }>;
 }
 /**
  * Return aggregate queue statistics for the given mesh.

package/dist/mesh/p2p-relay-failure.d.ts

@@ -0,0 +1,35 @@
+export type P2pRelayFailureCode = 'p2p_unavailable' | 'p2p_timeout' | 'p2p_not_connected' | 'p2p_datachannel_closed' | 'p2p_no_route' | 'p2p_daemon_offline' | 'mesh_logic_or_provider_failure';
+export interface P2pRelayFailureContext {
+    command?: string;
+    targetDaemonId?: string;
+}
+export interface P2pRelayFailureClassification {
+    code: P2pRelayFailureCode;
+    reason: string;
+    transport: 'p2p' | 'unknown';
+    recoverable: boolean;
+    retryRecommended: boolean;
+    nextAction: string;
+    noFallbackReason: string;
+}
+export interface P2pRelayFailurePayload extends P2pRelayFailureClassification {
+    success: false;
+    error: string;
+    command?: string;
+    targetDaemonId?: string;
+}
+export declare function classifyP2pRelayFailure(error: unknown, _context?: P2pRelayFailureContext): P2pRelayFailureClassification;
+export declare function isP2pRelayTransportFailure(error: unknown): boolean;
+export declare function buildP2pRelayFailurePayload(error: unknown, context?: P2pRelayFailureContext): P2pRelayFailurePayload;
+export declare class P2pRelayFailureError extends Error {
+    code: P2pRelayFailureCode;
+    reason: string;
+    transport: 'p2p' | 'unknown';
+    recoverable: boolean;
+    retryRecommended: boolean;
+    nextAction: string;
+    noFallbackReason: string;
+    command?: string;
+    targetDaemonId?: string;
+    constructor(message: string, context?: P2pRelayFailureContext);
+}

package/dist/providers/chat-message-normalization.d.ts

@@ -1,4 +1,5 @@
 import type { ChatMessage } from '../types.js';
+export declare function extractFinalSummaryFromMessages(messages: ChatMessage[] | null | undefined, maxChars?: number): string;
 export declare const BUILTIN_CHAT_MESSAGE_KINDS: readonly ["standard", "thought", "tool", "terminal", "system"];
 export type BuiltinChatMessageKind = typeof BUILTIN_CHAT_MESSAGE_KINDS[number];
 export type ChatMessageKind = BuiltinChatMessageKind | (string & {});

package/dist/providers/cli-provider-instance.d.ts

@@ -100,6 +100,12 @@ export declare class CliProviderInstance implements ProviderInstance {
     private completedDebounceTimer;
     private completedDebouncePending;
     private enforceFreshSessionLaunchIfNeeded;
+    private completionHasFinalAssistantMessage;
+    private hasAdapterPendingResponse;
+    private shouldSuppressStaleParsedBusyStatus;
+    private getCompletedFinalizationBlockReason;
+    private scheduleCompletedDebounceFlush;
+    private flushCompletedDebounceIfFinalized;
     private maybeAutoApproveStatus;
     private detectStatusTransition;
     private pushEvent;

package/dist/repo-mesh-types.d.ts

@@ -179,6 +179,8 @@ export interface LocalMeshNodeEntry {
     workspace: string;
     repoRoot?: string;
     daemonId?: string;
+    /** Machine registry ID that owns this workspace, when known. */
+    machineId?: string;
     userOverrides: Partial<RepoMeshNodeCapabilities>;
     policy: RepoMeshNodePolicy;
     /** For single-machine mesh: same daemon, different worktree */

package/dist/shared-types.d.ts

@@ -293,10 +293,29 @@ export interface SessionEntry {
     surfaceHidden?: boolean;
     settings?: Record<string, any>;
     meshQueueStats?: {
+        total?: number;
+        active?: number;
+        historical?: number;
         pending: number;
         assigned: number;
         completed: number;
         failed: number;
+        cancelled?: number;
+        activeCounts?: {
+            pending: number;
+            assigned: number;
+        };
+        historicalCounts?: {
+            completed: number;
+            failed: number;
+            cancelled: number;
+        };
+        activeAssignments?: Array<{
+            id: string;
+            nodeId?: string;
+            sessionId?: string;
+            message: string;
+        }>;
     };
 }
 /**
@@ -337,10 +356,29 @@ export interface CompactSessionEntry {
     summaryMetadata?: ProviderSummaryMetadata;
     settings?: Record<string, any>;
     meshQueueStats?: {
+        total?: number;
+        active?: number;
+        historical?: number;
         pending: number;
         assigned: number;
         completed: number;
         failed: number;
+        cancelled?: number;
+        activeCounts?: {
+            pending: number;
+            assigned: number;
+        };
+        historicalCounts?: {
+            completed: number;
+            failed: number;
+            cancelled: number;
+        };
+        activeAssignments?: Array<{
+            id: string;
+            nodeId?: string;
+            sessionId?: string;
+            message: string;
+        }>;
     };
 }
 export type VersionUpdateReason = 'force_update_below' | 'major_minor_mismatch' | 'patch_mismatch' | 'daemon_ahead';

package/package.json

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

package/src/boot/daemon-lifecycle.ts

@@ -83,6 +83,9 @@ export interface DaemonInitConfig {
 
     /** Fired before send_chat is dispatched — used for turn snapshot hooks */
     onBeforeSendChat?: (params: { workspace: string; sessionId: string }) => void;
+
+    /** Relays a command to a remote mesh node daemon */
+    dispatchMeshCommand?: (daemonId: string, command: string, args: Record<string, unknown>) => Promise<any>;
 }
 
 // ─── Result ───
@@ -100,6 +103,7 @@ export interface DaemonComponents {
     sessionRegistry: SessionRegistry;
     detectedIdes: { value: IDEInfo[] };
     refreshProviderAvailability: (providerType?: string) => Promise<void>;
+    dispatchMeshCommand?: (daemonId: string, command: string, args: Record<string, unknown>) => Promise<any>;
 }
 
 export interface DaemonDevSupportOptions {
@@ -331,6 +335,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         sessionRegistry,
         detectedIdes: detectedIdesRef,
         refreshProviderAvailability,
+        dispatchMeshCommand: config.dispatchMeshCommand,
     };
 
     // 11. Setup Mesh Event Forwarding