@adhdev/daemon-core 0.9.82-rc.186 → 0.9.82-rc.188

package/dist/mesh/beads-db.d.ts

@@ -68,5 +68,6 @@ export declare class BeadsDB {
     }>;
     updateDirectDispatchStatus(meshId: string, sessionId: string, status: 'acked' | 'completed' | 'failed' | 'stale'): void;
     cleanupTerminalDirectDispatches(olderThanMs: number): void;
+    deleteDirectDispatches(meshId: string): void;
     markStaleDirectDispatches(meshId: string, olderThanMs: number): void;
 }

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

@@ -1,4 +1,5 @@
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+import type { MeshLedgerKind } from './mesh-ledger.js';
 export declare function __resetIdleAutoFastForwardForTests(): void;
 export interface PendingMeshCoordinatorEvent {
     event: string;
@@ -23,12 +24,56 @@ export declare function drainPendingMeshCoordinatorEvents(meshId?: string, coord
 export declare function getPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string): readonly PendingMeshCoordinatorEvent[];
 /** Explicitly clear all pending coordinator events for a mesh (and coordinator if scoped). */
 export declare function clearPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string): void;
+export declare function reconcileDirectDispatchCompletionFromTranscript(args: {
+    meshId: string;
+    nodeId?: string;
+    sessionId: string;
+    providerType?: string;
+    providerSessionId?: string;
+    taskId: string;
+    finalSummary: string;
+    transcriptMessageAt?: string;
+    completedAt?: string;
+    targetCoordinatorDaemonId?: string;
+    source?: string;
+}): {
+    reconciled: boolean;
+    kind?: MeshLedgerKind;
+    alreadyTerminal?: boolean;
+    workerResult?: unknown;
+    ledgerEntryId?: string;
+    reason?: string;
+};
 export declare function tryAssignQueueTask(components: DaemonComponents, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
+export interface MeshQueueTriggerResult {
+    success: true;
+    meshId: string;
+    pendingBefore: number;
+    assignedBefore: number;
+    pendingAfter: number;
+    assignedAfter: number;
+    claimed: boolean;
+    newlyAssignedTasks: Array<{
+        id: string;
+        nodeId?: string;
+        sessionId?: string;
+    }>;
+    localIdleSessionsChecked: number;
+    remoteIdleSessionsChecked: number;
+    skippedSessions: Array<{
+        nodeId?: string;
+        sessionId?: string;
+        reason: string;
+        status?: string;
+    }>;
+    autoLaunchStarted: boolean;
+    noIdleMeshSessionAvailable?: 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: DaemonComponents, meshId: string): Promise<void>;
+export declare function triggerMeshQueue(components: DaemonComponents, meshId: string): Promise<MeshQueueTriggerResult>;
 export declare function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>): {
     success: boolean;
     forwarded: number;

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

@@ -136,6 +136,7 @@ export interface MeshWorkQueueStats {
 export declare function getMeshQueueStats(meshId: string): MeshWorkQueueStats;
 export declare function __replaceMeshQueueForTests(meshId: string, queue: MeshWorkQueueEntry[]): void;
 export declare function __clearMeshQueueForTests(meshId: string): void;
+export declare function __clearDirectDispatchesForTests(meshId: string): void;
 export declare function __resetBeadsDBForTests(): void;
 export type DirectDispatchRecord = ReturnType<BeadsDB['getActiveDirectDispatches']>[number];
 export declare function insertDirectDispatch(meshId: string, data: {

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

@@ -55,6 +55,8 @@ export declare class CliProviderInstance implements ProviderInstance {
     private historyWriter;
     private runtimeMessages;
     private lastPersistedHistoryMessages;
+    private lastAcknowledgedUserInputAt;
+    private externalBusyIdleFingerprint;
     private lastNativeSourceCanonicalCheckAt;
     private lastNativeSourceCanonicalCacheKey;
     private cachedSqliteDb;
@@ -130,6 +132,8 @@ export declare class CliProviderInstance implements ProviderInstance {
     private readExternalCompletionMessages;
     private completionFinalAssistantEvidence;
     private completionFinalSummary;
+    private externalNativeFinalFingerprint;
+    private getExternalNativeFinalReconciliation;
     private buildCompletedFinalizationDiagnostic;
     private hasAdapterPendingResponse;
     private shouldSuppressStaleParsedBusyStatus;

package/dist/providers/contracts.d.ts

@@ -302,7 +302,7 @@ export interface ProviderMeshCoordinatorConfig {
         requiresRestart?: boolean;
         /** User-facing setup explanation for manual modes. */
         instructions?: string;
-        /** Copyable setup template. Supports {{meshId}}, {{adhdevMcpCommand}}, {{workspace}}, {{serverName}}. */
+        /** Copyable setup template. Supports {{meshId}}, {{adhdevMcpCommand}}, {{adhdevMcpArgs}}, {{workspace}}, {{serverName}}. */
         template?: string;
     };
     /**
@@ -315,7 +315,38 @@ export interface ProviderMeshCoordinatorConfig {
      * the CLI doesn't recognize).
      */
     systemPromptInjection?: MeshCoordinatorSystemPromptInjection;
+    /**
+     * How coordinator-launched worker sessions are isolated from coordinator-only
+     * MCP/tools/config. Provider-specific CLI quirks belong here, not in daemon
+     * launch code.
+     */
+    delegatedWorkerIsolation?: MeshCoordinatorDelegatedWorkerIsolation;
+}
+export interface MeshCoordinatorDelegatedWorkerIsolation {
+    /** Environment variables to unset for delegated worker sessions. */
+    env?: {
+        unset?: string[];
+    };
+    /** Spawn-argument rules applied before launching a delegated worker. */
+    args?: MeshCoordinatorDelegatedWorkerArgRule[];
 }
+export type MeshCoordinatorDelegatedWorkerArgRule = {
+    mode: 'empty_mcp_config';
+    /** CLI flag that points at an MCP config file, e.g. '--mcp-config'. */
+    flag: string;
+    /** Optional CLI flag that forces only the provided MCP config to be used. */
+    strictFlag?: string;
+} | {
+    mode: 'config_override';
+    /** CLI config flag, e.g. '-c' or '--config'. */
+    flag: string;
+    /** Config key to set for worker isolation. */
+    key: string;
+    /** Config value to set. */
+    value: string;
+    /** Optional broader key prefix used for duplicate detection. */
+    dedupeKey?: string;
+};
 /**
  * Declarative description of how a CLI accepts a session-scoped system prompt.
  *

package/dist/providers/native-history/dispatcher.d.ts

@@ -5,6 +5,7 @@ export interface NativeHistoryInput {
     providerSessionId?: string;
     historySessionId?: string;
     workspace?: string;
+    sessionStartedAtMs?: number;
     format?: string;
     watchPath?: string;
     forceRefresh?: boolean;
@@ -16,6 +17,7 @@ export interface NativeHistoryResult {
         content: string;
         receivedAt?: number;
         kind?: string;
+        workspace?: string;
     }>;
     providerSessionId?: string;
     sourcePath: string;

package/dist/providers/sdk/v1/types/common/index.d.ts

@@ -138,7 +138,41 @@ export interface McpConfigDef {
 export interface MeshCoordinatorDef {
     supported: boolean;
     mcpConfig?: McpConfigDef;
-}
+    systemPromptInjection?: MeshCoordinatorSystemPromptInjectionDef;
+    delegatedWorkerIsolation?: MeshCoordinatorDelegatedWorkerIsolationDef;
+}
+export type MeshCoordinatorSystemPromptInjectionDef = {
+    mode: 'cli_arg';
+    flag: string;
+} | {
+    mode: 'config_override';
+    flag: string;
+    template: string;
+} | {
+    mode: 'context_file';
+    path: string;
+    wrapper?: string;
+} | {
+    mode: 'env_var';
+    name: string;
+};
+export interface MeshCoordinatorDelegatedWorkerIsolationDef {
+    env?: {
+        unset?: ReadonlyArray<string>;
+    };
+    args?: ReadonlyArray<MeshCoordinatorDelegatedWorkerArgRuleDef>;
+}
+export type MeshCoordinatorDelegatedWorkerArgRuleDef = {
+    mode: 'empty_mcp_config';
+    flag: string;
+    strictFlag?: string;
+} | {
+    mode: 'config_override';
+    flag: string;
+    key: string;
+    value: string;
+    dedupeKey?: string;
+};
 export interface CompatibilityEntryDef {
     /** SemVer range against the agent's own version. Optional. */
     ideVersion?: string;

package/dist/providers/spec/cli-adapter.d.ts

@@ -90,6 +90,7 @@ export declare class SpecCliAdapter implements CliAdapter {
     private handleEvent;
     private detectInteractivePromptFromPtyChunk;
     private readCurrentScreenSections;
+    private extractProviderSessionIdFromScreen;
     private readClaudeScreenAssistantMessages;
     private maybeCaptureClaudeTuiPrompt;
     private readClaudeTuiHeaders;

package/dist/providers/spec/driver.d.ts

@@ -1,5 +1,6 @@
 import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
-import { type TraceEntry } from './evaluator.js';
+import { type SpecEvaluation, type TraceEntry } from './evaluator.js';
+import type { CliSpec } from './types.js';
 export type DashboardEvent = {
     kind: 'pty_data';
     chunk: string;
@@ -96,6 +97,8 @@ export interface SpecDriverOpts {
  * embedded `\n`.
  */
 export declare function resolveSubmitDelayMs(specBeforeSubmit: number | undefined, text: string): number;
+export declare function matchesCompletionIdleRule(spec: CliSpec, ev: SpecEvaluation, screen: string): string | null;
+export declare function matchesCompletionIdleTargetState(spec: CliSpec, ev: SpecEvaluation, screen: string): boolean;
 export declare class SpecDriver {
     private readonly opts;
     private spec;
@@ -122,6 +125,8 @@ export declare class SpecDriver {
      *  because the evaluator already moved past busy by the time the hold
      *  kicks in. */
     private lastBusyState;
+    private completionIdleFirstSeenAt;
+    private completionIdleKey;
     /** Timer that re-runs evaluate() once the hold window expires. Needed
      *  because the PTY stops emitting once the agent finishes; without an
      *  explicit wake-up there's nothing to trigger the busy → idle

package/dist/providers/spec/native-history-executor.d.ts

@@ -28,6 +28,7 @@ export interface NativeHistoryMessage {
     content: string;
     receivedAt: number;
     kind?: string;
+    workspace?: string;
 }
 export interface NativeHistoryResult {
     messages: NativeHistoryMessage[];
@@ -35,5 +36,6 @@ export interface NativeHistoryResult {
     sourcePath: string;
     sourceMtimeMs: number;
     nativeHistoryCoverage?: 'full' | 'partial' | 'best-effort';
+    workspace?: string;
 }
 export declare function executeNativeHistory(cfg: NativeHistoryConfig, input: NativeHistoryInput): NativeHistoryResult | null;

package/dist/providers/spec/schema.gen.d.ts

@@ -124,6 +124,28 @@ export declare const SCHEMA: {
                     readonly type: "integer";
                     readonly minimum: 0;
                 };
+                readonly completion_idle_after: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["regex", "hold_ms"];
+                    readonly properties: {
+                        readonly section: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly regex: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly flags: {
+                            readonly type: "string";
+                        };
+                        readonly hold_ms: {
+                            readonly type: "integer";
+                            readonly minimum: 0;
+                        };
+                    };
+                };
             };
         };
     };

package/dist/providers/spec/types.d.ts

@@ -208,5 +208,15 @@ export interface CliSpec {
          *  once the window passes and an idle state has actually been
          *  observed. */
         startup_grace_ms?: number;
+        /** Treat a provider-specific completion marker as idle after it has
+         *  remained visible for hold_ms. This handles TUIs that leave their
+         *  last spinner glyph next to a completed timer, causing the normal
+         *  busy regex to keep matching after the turn is done. */
+        completion_idle_after?: {
+            section?: string;
+            regex: string;
+            flags?: string;
+            hold_ms: number;
+        };
     };
 }

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

@@ -305,11 +305,17 @@ export interface RepoMeshSessionStatus {
     sessionId: string;
     providerType?: string;
     state?: string;
+    chatStatus?: string;
     lifecycle?: 'starting' | 'running' | 'stopping' | 'stopped' | 'failed' | 'interrupted';
     surfaceKind?: 'live_runtime' | 'recovery_snapshot' | 'inactive_record';
     recoveryState?: string | null;
     workspace?: string | null;
     title?: string | null;
+    role?: string | null;
+    isSelfCoordinator?: boolean;
+    statusNote?: string | null;
+    createdAt?: string | null;
+    startedAt?: string | null;
     lastActivityAt?: string | null;
     isCached?: boolean;
 }

package/package.json

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

@@ -63,6 +63,7 @@ export interface DaemonInitConfig {
 
     /** Router transport-specific callbacks */
     onStatusChange?: () => void;
+    onMeshStateChange?: (meshId: string) => void;
     onPostChatCommand?: () => void;
     sessionHostControl?: SessionHostControlPlane | null;
     getCdpLogFn?: (ideType: string) => (msg: string) => void;
@@ -310,6 +311,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         },
         onIdeConnected: () => poller?.start(),
         onStatusChange: config.onStatusChange,
+        onMeshStateChange: config.onMeshStateChange,
         onPostChatCommand: config.onPostChatCommand,
         sessionHostControl: config.sessionHostControl,
         statusInstanceId: config.statusInstanceId,