@adhdev/daemon-core 0.9.82-rc.384 → 0.9.82-rc.386

package/dist/cli-adapter-types.d.ts

@@ -26,6 +26,18 @@ export interface CliAdapterStatus {
     providerSessionId?: string;
     errorMessage?: string;
     errorReason?: string;
+    /**
+     * FSM-spec adapters only: true once the driver has observed its first
+     * non-initial idle state (the prompt is genuinely drawn — see
+     * FsmDriver.maybeMarkReady / readySeenOnce). Used by CliProviderInstance to
+     * re-arm the queue-claim `agent:ready` event on the first genuine ready,
+     * independent of the boot-time starting→idle one-shot. That one-shot is
+     * consumed too early for providers whose INITIAL FSM state already reports
+     * status 'idle' (e.g. antigravity-cli), so without this re-arm the worker
+     * never claims its queued task and the coordinator relaunch-loops. Absent
+     * (undefined) for non-FSM adapters — they keep the boot one-shot behavior.
+     */
+    fsmReadySeen?: boolean;
 }
 export interface AcpAdapterHandle {
     onEvent(event: string, data?: unknown): void;

package/dist/cli-adapters/provider-cli-shared.d.ts

@@ -58,6 +58,17 @@ export interface CliSessionStatus {
     errorMessage?: string;
     errorReason?: string;
     providerSessionId?: string;
+    /**
+     * Spec/FSM adapters only (SpecCliAdapter): true once the driver has observed
+     * its first non-initial idle state — the prompt is genuinely drawn. The
+     * legacy ProviderCliAdapter never sets it (undefined). CliProviderInstance
+     * uses it to re-arm the queue-claim agent:ready on the first genuine ready,
+     * independent of the boot-time starting→idle one-shot (which is consumed too
+     * early for specs whose initial state already reports status 'idle', e.g.
+     * antigravity-cli — without the re-arm the worker never claims its queued
+     * task and the coordinator relaunch-loops).
+     */
+    fsmReadySeen?: boolean;
     /**
      * Timestamp (ms) of the most recent raw PTY output chunk. Advances on every
      * byte the process emits, including tool/build output that produces no

package/dist/index.js

@@ -383,10 +383,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "6cca365bcea9757dd350c6bac460ca5a169a9280" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "6cca365b" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.384" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-25T15:21:26.360Z" : void 0);
+  const commit = readInjected(true ? "fad1d175ca84a75f52bd0c1d88125fbb783ad241" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "fad1d175" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.386" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-26T00:12:44.100Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -14972,6 +14972,32 @@ function findLiveCoordinators(components) {
   }
   return out;
 }
+function resolveCoordinatorDrainDeliverability(components, meshId) {
+  const coordinators = findLiveCoordinators(components).filter((c) => c.meshId === meshId);
+  if (coordinators.length === 0) {
+    return { hasLiveCliCoordinator: false, deliverableNow: false, holdForReconcile: false };
+  }
+  const hasIdle = coordinators.some((c) => c.idle);
+  return {
+    hasLiveCliCoordinator: true,
+    deliverableNow: hasIdle,
+    // A live CLI coordinator exists but none is idle → the reconcile loop is
+    // holding the events; the poll must not steal them.
+    holdForReconcile: !hasIdle
+  };
+}
+function shouldHoldPendingDrainForBusyLocalCoordinator(components, meshId, requestedCoordinatorDaemonId) {
+  if (!meshId) return false;
+  const deliverability = resolveCoordinatorDrainDeliverability(components, meshId);
+  if (!deliverability.holdForReconcile) return false;
+  const requested = readNonEmptyString2(requestedCoordinatorDaemonId);
+  if (!requested) return true;
+  const localIds = expandDaemonIdForms([
+    readNonEmptyString2(components.statusInstanceId),
+    readNonEmptyString2(loadConfig().machineId)
+  ]);
+  return localIds.some((id) => daemonIdsEquivalent(id, requested));
+}
 function injectPendingIntoCoordinator(coordinator, pending) {
   if (!coordinator || !pending.coordinatorMessage) return;
   const force = shouldForceInjectMeshEvent(pending.event);
@@ -15688,9 +15714,11 @@ __export(mesh_events_exports, {
   isMeshCoordinatorEvent: () => isMeshCoordinatorEvent,
   queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
   reconcileDirectDispatchCompletionFromTranscript: () => reconcileDirectDispatchCompletionFromTranscript,
+  resolveCoordinatorDrainDeliverability: () => resolveCoordinatorDrainDeliverability,
   runMeshReconcileTick: () => runMeshReconcileTick,
   setupMeshEventForwarding: () => setupMeshEventForwarding,
   setupMeshReconcileLoop: () => setupMeshReconcileLoop,
+  shouldHoldPendingDrainForBusyLocalCoordinator: () => shouldHoldPendingDrainForBusyLocalCoordinator,
   triggerMeshQueue: () => triggerMeshQueue,
   tryAssignQueueTask: () => tryAssignQueueTask
 });
@@ -36186,6 +36214,17 @@ var FsmDriver = class {
   hasIdleHoldPending() {
     return (this.lastFsmEval?.transitions ?? []).some((t) => !t.holdSatisfied && t.condResult);
   }
+  /**
+   * True once the machine has reached its first non-initial idle state (the
+   * prompt is genuinely drawn — see maybeMarkReady). The cli-adapter surfaces
+   * this on its idle status so CliProviderInstance can re-arm the queue-claim
+   * agent:ready on the first genuine ready, independent of the boot-time
+   * starting→idle one-shot (which is consumed too early for specs whose
+   * initial state already reports idle).
+   */
+  hasSeenReady() {
+    return this.readySeenOnce;
+  }
   getCompletionIdleDebounceState() {
     const out = outgoingTransitions(this.spec, this.currentStateId);
     const toReady = this.lastFsmEval?.transitions.find((t, i) => {
@@ -37852,7 +37891,7 @@ var SpecCliAdapter = class _SpecCliAdapter {
     if (state.status === "generating") {
       return { status: "generating", messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, ...sessionFields };
     }
-    return { status: "idle", messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, ...sessionFields };
+    return { status: "idle", messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, fsmReadySeen: this.driver.hasSeenReady?.() ?? false, ...sessionFields };
   }
   maybeRefreshNativeHistory() {
   }
@@ -38897,6 +38936,14 @@ var CliProviderInstance = class _CliProviderInstance {
   context = null;
   events = [];
   lastStatus = "starting";
+  // Idempotency guard for the queue-claim agent:ready event. agent:ready is the
+  // sole signal the mesh coordinator's tryAssignQueueTask waits on to hand a
+  // queued task to this worker. It is emitted in two places: the boot-time
+  // starting→idle one-shot, and the readySeen re-arm below. This flag makes the
+  // event fire AT MOST ONCE per session so a worker is never claimed twice and a
+  // queued task is never double-dispatched/double-injected. Whichever path fires
+  // first sets it; the other becomes a no-op.
+  agentReadyEmitted = false;
   generatingStartedAt = 0;
   settings = {};
   monitor;
@@ -39977,6 +40024,17 @@ var CliProviderInstance = class _CliProviderInstance {
     } catch {
     }
   }
+  /**
+   * Emit the queue-claim agent:ready event at most once per session. Both the
+   * boot-time starting→idle one-shot and the fsmReadySeen re-arm call this; the
+   * agentReadyEmitted guard ensures the second caller is a no-op so a worker is
+   * never claimed twice and a queued task is never double-dispatched.
+   */
+  emitAgentReadyOnce(chatTitle, now) {
+    if (this.agentReadyEmitted) return;
+    this.agentReadyEmitted = true;
+    this.pushEvent({ event: "agent:ready", chatTitle, timestamp: now });
+  }
   detectStatusTransition() {
     const now = Date.now();
     const adapterStatus = this.adapter.getStatus({ allowParse: false });
@@ -40129,7 +40187,7 @@ var CliProviderInstance = class _CliProviderInstance {
           this.scheduleCompletedDebounceFlush(flushDelay);
         }
       } else if (newStatus === "idle" && this.lastStatus === "starting") {
-        this.pushEvent({ event: "agent:ready", chatTitle, timestamp: now });
+        this.emitAgentReadyOnce(chatTitle, now);
       } else if (newStatus === "error") {
         if (this.generatingDebounceTimer) {
           clearTimeout(this.generatingDebounceTimer);
@@ -40168,6 +40226,9 @@ var CliProviderInstance = class _CliProviderInstance {
       }
       this.lastStatus = newStatus;
     }
+    if (newStatus === "idle" && adapterStatus.fsmReadySeen === true && !this.agentReadyEmitted) {
+      this.emitAgentReadyOnce(chatTitle, now);
+    }
     this.applyProviderResponse(parsedStatus, {
       phase: newStatus === "idle" && (previousStatus === "generating" || previousStatus === "waiting_approval") ? "turn_completed" : "immediate"
     });
@@ -48514,9 +48575,12 @@ var meshEventsHandlers = {
   mesh_forward_event: async (ctx, args) => {
     return handleMeshForwardEvent({ instanceManager: ctx.deps.instanceManager }, args);
   },
-  get_pending_mesh_events: async (_ctx, args) => {
+  get_pending_mesh_events: async (ctx, args) => {
     const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
     const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : void 0;
+    if (meshId && shouldHoldPendingDrainForBusyLocalCoordinator(ctx.deps, meshId, coordinatorDaemonId)) {
+      return { success: true, events: [], heldForBusyLocalCoordinator: true };
+    }
     const events = drainPendingMeshCoordinatorEvents(meshId || void 0, coordinatorDaemonId);
     return { success: true, events };
   },