@adhdev/daemon-core 0.9.82-rc.6 → 0.9.82-rc.61

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

@@ -0,0 +1,48 @@
+import type { MeshLedgerEntry } from './mesh-ledger.js';
+import type { MeshWorkQueueEntry } from './mesh-work-queue.js';
+export type MeshActiveWorkSource = 'queue' | 'direct';
+export type MeshActiveWorkStatus = 'pending' | 'assigned' | 'generating' | 'idle' | 'failed' | 'awaiting_approval';
+export interface MeshActiveWorkRecord {
+    taskId: string;
+    source: MeshActiveWorkSource;
+    status: MeshActiveWorkStatus;
+    nodeId?: string;
+    sessionId?: string;
+    providerType?: string;
+    taskTitle: string;
+    taskSummary: string;
+    message?: string;
+    taskMode?: string;
+    createdAt: string;
+    updatedAt: string;
+    dispatchedAt?: string;
+    elapsedMs: number;
+    terminal?: boolean;
+    terminalKind?: string;
+    terminalAt?: string;
+}
+export interface MeshActiveWorkSummary {
+    totalActiveCount: number;
+    queueActiveCount: number;
+    directActiveCount: number;
+    awaitingApprovalCount: number;
+    generatingCount: number;
+    failedCount: number;
+    idleCount: number;
+    sourceCounts: Record<MeshActiveWorkSource, number>;
+    statusCounts: Record<MeshActiveWorkStatus, number>;
+}
+export interface BuildMeshActiveWorkOptions {
+    meshId: string;
+    queue?: MeshWorkQueueEntry[];
+    ledgerEntries?: MeshLedgerEntry[];
+    nodes?: any[];
+    now?: number;
+    /** Include terminal direct rows (idle/failed) for handoff/recent-work surfaces. Defaults false. */
+    includeTerminalDirect?: boolean;
+}
+export declare function buildMeshActiveWorkSummary(activeWork: MeshActiveWorkRecord[]): MeshActiveWorkSummary;
+export declare function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): {
+    activeWork: MeshActiveWorkRecord[];
+    summary: MeshActiveWorkSummary;
+};

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

@@ -3,15 +3,18 @@ export interface PendingMeshCoordinatorEvent {
     event: string;
     meshId: string;
     nodeLabel: string;
+    nodeId?: string;
+    workspace?: string;
     metadataEvent: Record<string, unknown>;
     queuedAt: number;
 }
-/** Drain and return all pending coordinator events, clearing the queue. */
-export declare function drainPendingMeshCoordinatorEvents(): PendingMeshCoordinatorEvent[];
+export declare function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEvent): boolean;
+/** Drain and return all pending coordinator events for meshId, removing them from disk. */
+export declare function drainPendingMeshCoordinatorEvents(meshId?: string): PendingMeshCoordinatorEvent[];
 /** 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 getPendingMeshCoordinatorEvents(meshId?: string): readonly PendingMeshCoordinatorEvent[];
+/** Explicitly clear all pending coordinator events for a mesh. */
+export declare function clearPendingMeshCoordinatorEvents(meshId?: string): 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.
@@ -23,12 +26,21 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     forwarded: number;
     suppressed: boolean;
     intentionalCleanupStop: boolean;
+    duplicateCompletion?: undefined;
+    error?: undefined;
+} | {
+    success: boolean;
+    forwarded: number;
+    suppressed: boolean;
+    duplicateCompletion: boolean;
+    intentionalCleanupStop?: undefined;
     error?: undefined;
 } | {
     success: boolean;
     forwarded: number;
     suppressed?: undefined;
     intentionalCleanupStop?: undefined;
+    duplicateCompletion?: undefined;
     error?: undefined;
 } | {
     success: boolean;

package/dist/mesh/mesh-fast-forward.d.ts

@@ -0,0 +1,39 @@
+import type { GitRepoStatus } from '../git/git-types.js';
+export interface MeshFastForwardNodeArgs {
+    nodeId?: string;
+    meshId?: string;
+    workspace: string;
+    branch?: string;
+    execute?: boolean;
+    dryRun?: boolean;
+    updateSubmodules?: boolean;
+    submoduleIgnorePaths?: string[];
+    timeoutMs?: number;
+}
+export interface MeshFastForwardPlannedStep {
+    operation: 'refresh_upstream' | 'verify_clean_worktree' | 'verify_fast_forward' | 'merge_ff_only' | 'submodule_update' | 'verify_post_status';
+    description: string;
+    safe: true;
+    willMutateWorktree: boolean;
+}
+export interface MeshFastForwardResult {
+    success: boolean;
+    code: string;
+    nodeId?: string;
+    meshId?: string;
+    workspace: string;
+    allowed: boolean;
+    dryRun: boolean;
+    willRun: boolean;
+    executed: boolean;
+    updateSubmodules: boolean;
+    blockingReasons: string[];
+    plannedSteps: MeshFastForwardPlannedStep[];
+    current?: GitRepoStatus;
+    preStatus?: GitRepoStatus;
+    postStatus?: GitRepoStatus;
+    finalBranchConvergenceState?: Record<string, unknown>;
+    operationError?: string;
+    ledgerError?: string;
+}
+export declare function fastForwardMeshNode(args: MeshFastForwardNodeArgs): Promise<MeshFastForwardResult>;

package/dist/mesh/mesh-host-ownership.d.ts

@@ -0,0 +1,9 @@
+import type { RepoMeshDaemonRole, RepoMeshHostMetadata, RepoMeshHostStatus } from '../repo-mesh-types.js';
+export declare function normalizeMeshDaemonRole(value: unknown): RepoMeshDaemonRole | undefined;
+export declare function resolveMeshHostStatus(mesh: unknown): RepoMeshHostStatus;
+export declare function isMeshHostOwner(mesh: unknown): boolean;
+export declare function buildMeshHostRequiredFailure(mesh: unknown, operation: string): Record<string, unknown>;
+export declare function requireMeshHostQueueOwner(opts?: {
+    ownerRole?: RepoMeshDaemonRole;
+}): void;
+export declare function createDefaultMeshHostMetadata(): RepoMeshHostMetadata;

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' | 'ledger_replicated' | 'ledger_reconciled';
+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_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;
@@ -25,6 +25,40 @@ export interface MeshLedgerEntry {
     payload: Record<string, unknown>;
 }
 export declare function isIntentionalCleanupStopEntry(entry: Pick<MeshLedgerEntry, 'kind' | 'payload'>): boolean;
+export type MeshWorkerResultStatus = 'completed' | 'failed' | 'blocked' | 'partial' | 'unknown';
+export type MeshProcessArtifactKind = 'process' | 'log' | 'port' | 'window' | 'session' | 'file' | 'url' | 'other';
+export interface MeshValidationResultArtifact {
+    command?: string;
+    status: 'passed' | 'failed' | 'skipped' | 'unknown';
+    durationMs?: number;
+    outputPath?: string;
+    summary?: string;
+}
+export interface MeshProcessArtifact {
+    kind: MeshProcessArtifactKind;
+    id?: string;
+    label?: string;
+    locator?: string;
+    pid?: number;
+    port?: number;
+    url?: string;
+    path?: string;
+    sessionId?: string;
+    keepRunning?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface MeshWorkerResultArtifact {
+    status: MeshWorkerResultStatus;
+    classification?: string;
+    changedFiles: string[];
+    validationResults: MeshValidationResultArtifact[];
+    gitStatus?: Record<string, unknown>;
+    processArtifacts: MeshProcessArtifact[];
+    errors: string[];
+    nextAction?: string;
+    requiresUserAction: boolean;
+    source: 'explicit_metadata' | 'final_summary_json' | 'default';
+}
 export interface MeshTaskCompletionEvidence {
     source: 'agent_status_event';
     event: 'agent:generating_completed' | 'agent:ready';
@@ -38,6 +72,7 @@ export interface MeshTaskCompletionEvidence {
         providerSessionId?: string;
         finalSummaryAvailable: boolean;
     };
+    workerResult: MeshWorkerResultArtifact;
     git: {
         status: 'deferred';
         reason: string;
@@ -59,6 +94,7 @@ export interface BuildTaskCompletionEvidenceOptions {
     providerType?: string;
     providerSessionId?: string;
     finalSummary?: string;
+    workerResult?: Record<string, unknown>;
     completedAt?: string;
 }
 export interface MeshLedgerSummary {
@@ -115,6 +151,7 @@ export interface AppendRemoteLedgerResult {
 }
 export declare const MAX_LEDGER_SLICE_LIMIT = 500;
 export declare function getLedgerDir(): string;
+export declare function normalizeMeshWorkerResult(input?: Record<string, unknown>, source?: MeshWorkerResultArtifact['source']): MeshWorkerResultArtifact;
 export declare function buildTaskCompletionEvidence(opts: BuildTaskCompletionEvidenceOptions): MeshTaskCompletionEvidence;
 /**
  * Append a new entry to the mesh ledger.

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

@@ -1,13 +1,25 @@
+import type { RepoMeshDaemonRole } from '../repo-mesh-types.js';
 export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | 'cancelled';
 export type MeshActiveTaskStatus = Extract<MeshTaskStatus, 'pending' | 'assigned'>;
 export type MeshHistoricalTaskStatus = Extract<MeshTaskStatus, 'completed' | 'failed' | 'cancelled'>;
+export type MeshTaskMode = 'code_change' | 'validation' | 'live_debug_readonly' | 'launch_app' | 'convergence';
 export declare const ACTIVE_MESH_QUEUE_STATUSES: MeshActiveTaskStatus[];
 export declare const HISTORICAL_MESH_QUEUE_STATUSES: MeshHistoricalTaskStatus[];
+export declare const MESH_TASK_MODES: MeshTaskMode[];
+export interface MeshTaskModeValidationResult {
+    valid: boolean;
+    taskMode?: MeshTaskMode;
+    violations: string[];
+    allowedOperations?: string[];
+}
+export declare function normalizeMeshTaskMode(value: unknown): MeshTaskMode | undefined;
+export declare function validateMeshTaskModeRequest(mode: unknown, message: string): MeshTaskModeValidationResult;
 export interface MeshWorkQueueEntry {
     id: string;
     meshId: string;
     message: string;
     status: MeshTaskStatus;
+    taskMode?: MeshTaskMode;
     /** 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 */
@@ -37,13 +49,17 @@ export interface MeshWorkQueueEntry {
     createdAt: string;
     updatedAt: string;
 }
+export interface MeshQueueMutationOptions {
+    ownerRole?: RepoMeshDaemonRole;
+}
 /**
  * Add a new task to the mesh queue.
  */
 export declare function enqueueTask(meshId: string, message: string, opts?: {
     targetNodeId?: string;
     targetSessionId?: string;
-}): MeshWorkQueueEntry;
+    taskMode?: MeshTaskMode | string;
+} & MeshQueueMutationOptions): MeshWorkQueueEntry;
 /**
  * Get all tasks in the queue, optionally filtered by status.
  */
@@ -58,14 +74,14 @@ export declare function claimNextTask(meshId: string, nodeId: string, sessionId:
  * Update the status of a specific task.
  * Used when a session completes, fails, or stalls.
  */
-export declare function updateTaskStatus(meshId: string, taskId: string, status: MeshTaskStatus): MeshWorkQueueEntry | null;
+export declare function updateTaskStatus(meshId: string, taskId: string, status: MeshTaskStatus, opts?: MeshQueueMutationOptions): 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;
+} & MeshQueueMutationOptions): 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.
@@ -76,11 +92,13 @@ export declare function requeueTask(meshId: string, taskId: string, opts?: {
     targetSessionId?: string;
     clearTargetNode?: boolean;
     clearTargetSession?: boolean;
-}): MeshWorkQueueEntry | null;
+} & MeshQueueMutationOptions): 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 declare function updateSessionTaskStatus(meshId: string, sessionId: string, status: MeshTaskStatus, opts?: {
+    occurredAt?: string;
+}): MeshWorkQueueEntry | null;
 export interface MeshWorkQueueStats {
     total: number;
     active: number;

package/dist/mesh/refine-config.d.ts

@@ -0,0 +1,119 @@
+export declare const MESH_REFINE_VALIDATION_CATEGORIES: readonly ["typecheck", "test", "lint", "build"];
+export type MeshRefineValidationCategory = typeof MESH_REFINE_VALIDATION_CATEGORIES[number];
+export interface RepoMeshRefineValidationCommandConfig {
+    /** Executable name or a whitespace-tokenized command string. Never executed through a shell. */
+    command: string;
+    /** Optional explicit argv. Prefer this over shell-like command strings. */
+    args?: string[];
+    category?: MeshRefineValidationCategory;
+    cwd?: string;
+    timeoutMs?: number;
+    env?: Record<string, string>;
+}
+export interface RepoMeshRefineConfig {
+    version: 1;
+    validation?: {
+        required?: boolean;
+        commands?: RepoMeshRefineValidationCommandConfig[];
+    };
+}
+export interface MeshRefineValidationCommandPlan {
+    command: string;
+    args: string[];
+    displayCommand: string;
+    category: MeshRefineValidationCategory | 'custom';
+    source: string;
+    cwd?: string;
+    timeoutMs?: number;
+    env?: Record<string, string>;
+}
+export interface MeshRefineConfigLoadResult {
+    config?: RepoMeshRefineConfig;
+    source: string;
+    sourceType: 'mesh_policy' | 'repo_file' | 'unavailable' | 'invalid';
+    path?: string;
+    error?: string;
+}
+export interface MeshRefineValidationPlan {
+    source: string;
+    sourceType: MeshRefineConfigLoadResult['sourceType'];
+    commands: MeshRefineValidationCommandPlan[];
+    rejectedCommands: Array<Record<string, unknown>>;
+    suggestions: RepoMeshRefineValidationCommandConfig[];
+    suggestedConfig?: RepoMeshRefineConfig;
+    unavailableReason?: string;
+}
+export declare const MESH_REFINE_CONFIG_LOCATIONS: string[];
+export declare const MESH_REFINE_CONFIG_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly title: "ADHDev Repo Mesh Refinery Config";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["version"];
+    readonly properties: {
+        readonly version: {
+            readonly const: 1;
+        };
+        readonly validation: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly required: {
+                    readonly type: "boolean";
+                    readonly default: true;
+                };
+                readonly commands: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly maxItems: 8;
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["command"];
+                        readonly properties: {
+                            readonly command: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly args: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                            };
+                            readonly category: {
+                                readonly enum: readonly ["typecheck", "test", "lint", "build", "custom"];
+                            };
+                            readonly cwd: {
+                                readonly type: "string";
+                            };
+                            readonly timeoutMs: {
+                                readonly type: "number";
+                                readonly minimum: 1000;
+                                readonly maximum: 600000;
+                            };
+                            readonly env: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export declare function validateMeshRefineConfig(config: unknown, source?: string): {
+    valid: boolean;
+    errors: string[];
+    commands: MeshRefineValidationCommandPlan[];
+    rejectedCommands: Array<Record<string, unknown>>;
+};
+export declare function loadMeshRefineConfig(mesh: any, workspace: string): MeshRefineConfigLoadResult;
+export declare function suggestMeshRefineConfig(mesh: any, workspace: string): {
+    suggestions: RepoMeshRefineValidationCommandConfig[];
+    suggestedConfig?: RepoMeshRefineConfig;
+};
+export declare function resolveMeshRefineValidationPlan(mesh: any, workspace: string): MeshRefineValidationPlan;

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

@@ -1,4 +1,5 @@
 import type { ChatMessage } from '../types.js';
+export declare const DEFAULT_FINAL_SUMMARY_MAX_CHARS = 4000;
 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];

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

@@ -101,6 +101,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private completedDebouncePending;
     private enforceFreshSessionLaunchIfNeeded;
     private completionHasFinalAssistantMessage;
+    private buildCompletedFinalizationDiagnostic;
     private hasAdapterPendingResponse;
     private shouldSuppressStaleParsedBusyStatus;
     private getCompletedFinalizationBlockReason;

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

@@ -19,10 +19,37 @@ export interface RepoMesh {
     defaultBranch?: string;
     policy: RepoMeshPolicy;
     coordinator: RepoMeshCoordinatorConfig;
+    meshHost?: RepoMeshHostMetadata;
     projectContext: ProjectContextSnapshot;
     nodes: RepoMeshNode[];
     status: 'active' | 'archived' | 'deleted';
 }
+export type RepoMeshDaemonRole = 'host' | 'member';
+export interface RepoMeshHostPairingMetadata {
+    status: 'not_configured' | 'pairing' | 'paired' | 'rejected' | 'revoked';
+    tokenId?: string;
+    joinedAt?: string;
+    lastPairedAt?: string;
+    lastRejectedAt?: string;
+    expiresAt?: string;
+}
+export interface RepoMeshHostMetadata {
+    /** Local daemon role for this mesh. Missing metadata defaults to host for standalone compatibility. */
+    role: RepoMeshDaemonRole;
+    /** Daemon that owns mesh truth/status/git/queue/session/ledger/coordinator ownership. */
+    hostDaemonId?: string;
+    /** Mesh node that represents the host daemon, when known. */
+    hostNodeId?: string;
+    /** Future standalone manual pairing endpoint entered by member daemons. */
+    hostAddress?: string;
+    /** Redacted pairing state only; raw join tokens must not be persisted here. */
+    pairing?: RepoMeshHostPairingMetadata;
+}
+export interface RepoMeshHostStatus extends RepoMeshHostMetadata {
+    canOwnCoordinator: boolean;
+    canOwnQueue: boolean;
+    defaulted: boolean;
+}
 export interface RepoMeshNode {
     id: string;
     daemonId: string;
@@ -37,6 +64,7 @@ export interface RepoMeshNode {
     effectiveCapabilities: RepoMeshNodeCapabilities;
     policy: RepoMeshNodePolicy;
     health: RepoMeshNodeHealth;
+    role?: RepoMeshDaemonRole;
     status: 'enabled' | 'disabled' | 'removed';
 }
 export type RepoMeshNodeHealth = 'online' | 'offline' | 'degraded' | 'dirty' | 'wrong_branch' | 'unknown';
@@ -185,6 +213,7 @@ export interface LocalMeshEntry {
     defaultBranch?: string;
     policy: RepoMeshPolicy;
     coordinator: RepoMeshCoordinatorConfig;
+    meshHost?: RepoMeshHostMetadata;
     nodes: LocalMeshNodeEntry[];
     createdAt: string;
     updatedAt: string;
@@ -206,21 +235,152 @@ export interface LocalMeshNodeEntry {
     clonedFromNodeId?: string;
     /** Optional associated/external repos configured as node metadata. */
     relatedRepos?: RepoMeshRelatedRepo[];
+    role?: RepoMeshDaemonRole;
 }
 export interface RepoMeshStatus {
     meshId: string;
     meshName: string;
     repoIdentity: string;
+    defaultBranch?: string;
     refreshedAt: string;
+    meshHost?: RepoMeshHostStatus;
     nodes: RepoMeshNodeStatus[];
+    queue?: RepoMeshQueueStatus;
+    ledger?: RepoMeshLedgerStatus;
+}
+export interface RepoMeshSessionStatus {
+    sessionId: string;
+    providerType?: string;
+    state?: string;
+    lifecycle?: 'starting' | 'running' | 'stopping' | 'stopped' | 'failed' | 'interrupted';
+    surfaceKind?: 'live_runtime' | 'recovery_snapshot' | 'inactive_record';
+    recoveryState?: string | null;
+    workspace?: string | null;
+    title?: string | null;
+    lastActivityAt?: string | null;
+    isCached?: boolean;
+}
+export type RepoMeshPeerConnectionState = 'self' | 'connected' | 'connecting' | 'disconnected' | 'failed' | 'closed' | 'unknown';
+export type RepoMeshPeerConnectionTransport = 'local' | 'direct' | 'relay' | 'unknown';
+export interface RepoMeshPeerConnectionStatus {
+    perspective: 'selected_coordinator';
+    source: 'mesh_peer_status' | 'not_reported';
+    state: RepoMeshPeerConnectionState;
+    transport: RepoMeshPeerConnectionTransport;
+    reported: boolean;
+    reason?: string;
+    lastStateChangeAt?: string;
+    lastConnectedAt?: string;
+    lastCommandAt?: string;
 }
 export interface RepoMeshNodeStatus {
     nodeId: string;
     machineLabel: string;
     workspace: string;
+    repoRoot?: string;
+    daemonId?: string;
+    machineId?: string;
+    role?: RepoMeshDaemonRole;
+    machineStatus?: string;
+    isLocalWorktree?: boolean;
+    worktreeBranch?: string;
     health: RepoMeshNodeHealth;
     git?: GitRepoStatus;
+    /**
+     * True when the selected coordinator has evidence that a peer git probe is still
+     * in flight or just timed out during initial mesh handshake, so callers should
+     * treat missing git data as pending instead of authoritative absence.
+     */
+    gitProbePending?: boolean;
     providers: string[];
     activeSessions: string[];
+    activeSessionDetails?: RepoMeshSessionStatus[];
+    providerPriority?: string[];
+    launchReady?: boolean;
+    lastSeenAt?: string;
+    updatedAt?: string;
+    connection?: RepoMeshPeerConnectionStatus;
     error?: string;
 }
+export type RepoMeshQueueTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | 'cancelled';
+export interface RepoMeshQueueTask {
+    id: string;
+    meshId: string;
+    message: string;
+    status: RepoMeshQueueTaskStatus;
+    targetNodeId?: string;
+    targetSessionId?: string;
+    assignedNodeId?: string;
+    assignedSessionId?: string;
+    cancelReason?: string;
+    cancelledAt?: string;
+    requeueReason?: string;
+    requeuedAt?: string;
+    requeueCount?: number;
+    autoLaunch?: {
+        status: 'skipped' | 'started' | 'failed' | 'completed';
+        reason?: string;
+        nodeId?: string;
+        providerType?: string;
+        sessionId?: string;
+        updatedAt: string;
+    };
+    dispatchTimestamp?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RepoMeshQueueSummary {
+    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 interface RepoMeshQueueStatus {
+    tasks: RepoMeshQueueTask[];
+    summary: RepoMeshQueueSummary;
+}
+export interface RepoMeshLedgerEntryStatus {
+    id: string;
+    meshId: string;
+    timestamp: string;
+    kind: string;
+    nodeId?: string;
+    sessionId?: string;
+    providerType?: string;
+    payload: Record<string, unknown>;
+}
+export interface RepoMeshLedgerSummaryStatus {
+    meshId: string;
+    totalEntries: number;
+    taskDispatched: number;
+    taskCompleted: number;
+    taskFailed: number;
+    taskStalled: number;
+    sessionLaunched: number;
+    checkpointCreated: number;
+    lastActivityAt: string | null;
+    recentFailures: number;
+}
+export interface RepoMeshLedgerStatus {
+    entries: RepoMeshLedgerEntryStatus[];
+    summary: RepoMeshLedgerSummaryStatus;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.6",
+  "version": "0.9.82-rc.61",
   "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

@@ -86,6 +86,8 @@ export interface DaemonInitConfig {
 
     /** Relays a command to a remote mesh node daemon */
     dispatchMeshCommand?: (daemonId: string, command: string, args: Record<string, unknown>) => Promise<any>;
+    /** Returns selected-coordinator mesh peer telemetry for a target daemon when available. */
+    getMeshPeerConnectionStatus?: (daemonId: string) => Record<string, unknown> | null;
 }
 
 // ─── Result ───
@@ -306,6 +308,8 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         sessionHostControl: config.sessionHostControl,
         statusInstanceId: config.statusInstanceId,
         statusVersion: config.statusVersion,
+        getMeshPeerConnectionStatus: config.getMeshPeerConnectionStatus,
+        dispatchMeshCommand: config.dispatchMeshCommand,
         getCdpLogFn: config.getCdpLogFn || ((ideType: string) => LOG.forComponent(`CDP:${ideType}`).asLogFn()),
     });
 

package/src/cli-adapters/provider-cli-runtime.ts

@@ -36,7 +36,9 @@ export function resolveCliSpawnPlan(options: {
         : spawnConfig.command;
     const binaryPath = findBinary(configuredCommand);
     const isWin = os.platform() === 'win32';
-    const allArgs = [...spawnConfig.args, ...extraArgs];
+    const allArgs = [...spawnConfig.args, ...extraArgs].map((arg) =>
+        typeof arg === 'string' ? arg.replace(/\{\{workingDir\}\}/g, workingDir) : arg,
+    );
 
     let shellCmd: string;
     let shellArgs: string[];