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

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

@@ -66,6 +66,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private context;
     private events;
     private lastStatus;
+    private agentReadyEmitted;
     private generatingStartedAt;
     private settings;
     private monitor;
@@ -220,6 +221,13 @@ export declare class CliProviderInstance implements ProviderInstance {
      * the approval decision; the next real PTY frame refreshes visible status.
      */
     private recheckAutoApproveSettled;
+    /**
+     * 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.
+     */
+    private emitAgentReadyOnce;
     private detectStatusTransition;
     private pushEvent;
     private flushEvents;

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

@@ -134,6 +134,7 @@ export interface ISpecDriver {
     }> | null;
     getLastBusyAt(): number;
     hasIdleHoldPending(): boolean;
+    hasSeenReady(): boolean;
     getCompletionIdleDebounceState(): {
         active: boolean;
         ageMs: number;
@@ -264,6 +265,15 @@ export declare class FsmDriver implements ISpecDriver {
      *  working without branching on driver type. */
     getLastBusyAt(): number;
     hasIdleHoldPending(): boolean;
+    /**
+     * 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(): boolean;
     getCompletionIdleDebounceState(): {
         active: boolean;
         ageMs: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.385",
+  "version": "0.9.82-rc.386",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.385",
+    "@adhdev/mesh-shared": "0.9.82-rc.386",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/cli-adapter-types.ts

@@ -28,6 +28,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 {

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

@@ -60,6 +60,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/src/providers/cli-provider-instance.ts

@@ -430,6 +430,14 @@ export class CliProviderInstance implements ProviderInstance {
     private context: InstanceContext | null = null;
     private events: ProviderEvent[] = [];
     private lastStatus: string = '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.
+    private agentReadyEmitted = false;
     private generatingStartedAt: number = 0;
     private settings: Record<string, any> = {};
     private monitor: StatusMonitor;
@@ -1920,6 +1928,18 @@ export class CliProviderInstance implements ProviderInstance {
         } catch { /* adapter gone / transient — next frame retries */ }
     }
 
+    /**
+     * 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.
+     */
+    private emitAgentReadyOnce(chatTitle: string, now: number): void {
+        if (this.agentReadyEmitted) return;
+        this.agentReadyEmitted = true;
+        this.pushEvent({ event: 'agent:ready', chatTitle, timestamp: now });
+    }
+
     private detectStatusTransition(): void {
         const now = Date.now();
         // Status-change handling is a hot path: PTY output can fire it many times
@@ -2142,7 +2162,7 @@ export class CliProviderInstance implements ProviderInstance {
                     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); this.generatingDebounceTimer = null; }
                 this.generatingDebouncePending = null;
@@ -2171,6 +2191,28 @@ export class CliProviderInstance implements ProviderInstance {
             this.lastStatus = newStatus;
         }
 
+        // Re-arm the queue-claim agent:ready on the FSM's first GENUINE ready.
+        //
+        // The boot-time starting→idle one-shot above is the historical claim
+        // trigger, but it is consumed too early for FSM-spec providers whose
+        // INITIAL state already reports status 'idle' (e.g. antigravity-cli): the
+        // adapter reports idle before maybeMarkReady has fired, so lastStatus
+        // advances starting→idle while the prompt is not yet drawn and the worker
+        // cannot yet claim. Subsequent state-driven idle frames are idle→idle (no
+        // status change), so the one-shot never re-fires and the worker strands its
+        // queued task — the coordinator then relaunch-loops every ~90s.
+        //
+        // The adapter surfaces fsmReadySeen=true exactly when the FSM reaches its
+        // first non-initial idle (the prompt is genuinely up). On that signal we
+        // emit agent:ready once more. emitAgentReadyOnce is idempotent (guarded by
+        // agentReadyEmitted), so providers whose boot one-shot already landed on a
+        // real ready (claude-cli / codex-cli / hermes-cli, which use a startup
+        // grace and whose initial state is not idle) treat this as a no-op — no
+        // double claim, no double task injection.
+        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'

package/src/providers/spec/cli-adapter.ts

@@ -206,7 +206,12 @@ export class SpecCliAdapter implements CliAdapter {
         if (state.status === 'generating') {
             return { status: 'generating', messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, ...sessionFields };
         }
-        return { status: 'idle', messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, ...sessionFields };
+        // fsmReadySeen lets CliProviderInstance re-arm the queue-claim agent:ready
+        // on the first genuine ready (prompt drawn), independent of the boot-time
+        // starting→idle one-shot that the provider-instance otherwise relies on.
+        // Surfaced only on idle so the provider-instance fires agent:ready exactly
+        // when the worker is actually ready to claim.
+        return { status: 'idle', messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, fsmReadySeen: this.driver.hasSeenReady?.() ?? false, ...sessionFields };
     }
 
     private maybeRefreshNativeHistory(): void {

package/src/providers/spec/fsm-driver.ts

@@ -125,6 +125,7 @@ export interface ISpecDriver {
     getSections(): Array<{ id: string; text: string }> | null;
     getLastBusyAt(): number;
     hasIdleHoldPending(): boolean;
+    hasSeenReady(): boolean;
     getCompletionIdleDebounceState(): { active: boolean; ageMs: number; holdMs: number; forceAfterMs: number } | null;
     getFsmDebug?(): unknown;
     getFsmSnapshotHistory?(): ReadonlyArray<FsmSnapshotEntry>;
@@ -466,6 +467,17 @@ export class FsmDriver implements ISpecDriver {
         // Report true while any outgoing transition is hold-blocked.
         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(): boolean {
+        return this.readySeenOnce;
+    }
     getCompletionIdleDebounceState(): { active: boolean; ageMs: number; holdMs: number; forceAfterMs: number } | null {
         // Surface the busy→ready transition's stable countdown, if any, so the
         // existing panel field stays meaningful.