@adhdev/daemon-core 0.9.82-rc.491 → 0.9.82-rc.492

package/dist/cli-adapters/cli-state-engine.d.ts

@@ -48,6 +48,16 @@ export interface CliStateEngineCallbacks {
     onStatusChange(): void;
     onApplyParsedSession(session: ParsedSession): void;
     onTurnCompleted(): void;
+    /**
+     * FALSE-IDLE (Fix 2): true when the owning session is inside the post-approval
+     * resume grace — an autonomous auto-approving mesh session that resolved a modal
+     * within the resume-grace window. The engine cannot decide this on its own (it has
+     * no mesh/auto-approve awareness); the instance answers using the SAME
+     * `inApprovalResumeGrace` judgment Fix 1 uses, so the two fixes stay in lockstep.
+     * Optional: absent ⇒ treated as false (no hysteresis) so any non-instance embedder
+     * keeps the pre-fix behavior.
+     */
+    isInApprovalResumeGrace?(): boolean;
 }
 export declare class CliStateEngine {
     private readonly provider;
@@ -113,6 +123,8 @@ export declare class CliStateEngine {
     pendingScriptStatusSince: number;
     private pendingScriptStatusTimer;
     private idleFinishCandidate;
+    private approvalResumeDeferSince;
+    private approvalResumeDeferEpoch;
     /**
      * `finishResponse` produces the `generating → idle` transition that
      * coordinators interpret as "task complete". Some providers (antigravity-
@@ -201,6 +213,20 @@ export declare class CliStateEngine {
     private applyError;
     private maybeScheduleProviderErrorRetry;
     private applyIdle;
+    /**
+     * FALSE-IDLE (Fix 2): should applyIdle suppress the idle/finish for the current
+     * turn because we are inside the post-approval resume grace?
+     *
+     * True only when: (a) the owning instance reports it is an autonomous auto-approving
+     * mesh session that resolved a modal within the resume-grace window
+     * (isInApprovalResumeGrace callback — the SAME judgment Fix 1 uses), AND (b) the defer
+     * for THIS response epoch has not yet exceeded APPROVAL_RESUME_IDLE_DEFER_CAP_MS.
+     * The cap guarantees no infinite defer: a turn that genuinely ended right after an
+     * approval and stays silent past the cap stops being suppressed and finishes normally.
+     * The per-epoch anchor means a fresh turn/response restarts the clock.
+     */
+    private shouldDeferIdleForApprovalResume;
+    private clearApprovalResumeDefer;
     finishResponse(): void;
     private scheduleIdleFinish;
     private cancelPendingIdleFinish;

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

@@ -32,6 +32,7 @@ export declare class ProviderCliAdapter implements CliAdapter {
     private ptyProcess;
     private transportFactory;
     private onStatusChange;
+    private inApprovalResumeGraceProbe;
     readonly engine: CliStateEngine;
     private responseBuffer;
     private recentOutputBuffer;
@@ -137,6 +138,7 @@ export declare class ProviderCliAdapter implements CliAdapter {
     updateRuntimeSettings(settings: Record<string, any>): void;
     setServerConn(serverConn: any): void;
     setOnStatusChange(callback: () => void): void;
+    setInApprovalResumeGraceProbe(probe: () => boolean): void;
     setOnPtyData(callback: (data: string) => void): void;
     private flushPendingOutputParse;
     spawn(): Promise<void>;

package/dist/index.js

@@ -414,10 +414,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "5b9e1774e6eb6318b6484d9adc6c510e9d96ea8a" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "5b9e1774" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.491" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-10T06:22:30.442Z" : void 0);
+  const commit = readInjected(true ? "d3ef86c2b3332b1ce289eb8d4193c7c945d39401" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "d3ef86c2" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.492" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-10T07:51:20.549Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -24501,7 +24501,7 @@ var init_provider_cli_parse = __esm({
 });
 
 // src/cli-adapters/cli-state-engine.ts
-var SCRIPT_STATUS_DEBOUNCE_MS, MAX_FINISH_RETRIES, FINISH_RETRY_DELAY_MS, MAX_TRACE_ENTRIES, APPROVAL_EXIT_TIMEOUT_MS, IDLE_CONFIRMATION_GRACE_MS, CliStateEngine;
+var SCRIPT_STATUS_DEBOUNCE_MS, MAX_FINISH_RETRIES, FINISH_RETRY_DELAY_MS, MAX_TRACE_ENTRIES, APPROVAL_EXIT_TIMEOUT_MS, IDLE_CONFIRMATION_GRACE_MS, APPROVAL_RESUME_IDLE_DEFER_CAP_MS, CliStateEngine;
 var init_cli_state_engine = __esm({
   "src/cli-adapters/cli-state-engine.ts"() {
     "use strict";
@@ -24514,6 +24514,7 @@ var init_cli_state_engine = __esm({
     MAX_TRACE_ENTRIES = 250;
     APPROVAL_EXIT_TIMEOUT_MS = 6e4;
     IDLE_CONFIRMATION_GRACE_MS = 2e3;
+    APPROVAL_RESUME_IDLE_DEFER_CAP_MS = 18e3;
     CliStateEngine = class {
       constructor(provider, runner, transport, callbacks, timeouts) {
         this.provider = provider;
@@ -24603,6 +24604,12 @@ var init_cli_state_engine = __esm({
       pendingScriptStatusTimer = null;
       // ── Idle candidate ───────────────────────────────
       idleFinishCandidate = null;
+      // FALSE-IDLE (Fix 2): wall-clock when the current post-approval resume-grace idle
+      // defer began, scoped to a responseEpoch. Zero when not deferring. Bounds the defer
+      // to APPROVAL_RESUME_IDLE_DEFER_CAP_MS so a turn that genuinely ended right after an
+      // approval eventually finishes. Reset whenever a new turn/response starts or completes.
+      approvalResumeDeferSince = 0;
+      approvalResumeDeferEpoch = -1;
       // ── Idle confirmation grace ──────────────────────
       /**
        * `finishResponse` produces the `generating → idle` transition that
@@ -24816,6 +24823,8 @@ var init_cli_state_engine = __esm({
         this.activeModal = null;
         this.pendingScriptStatus = null;
         this.pendingScriptStatusSince = 0;
+        this.approvalResumeDeferSince = 0;
+        this.approvalResumeDeferEpoch = -1;
       }
       clearIdleFinishCandidate(reason) {
         if (!this.idleFinishCandidate) return;
@@ -25237,6 +25246,14 @@ var init_cli_state_engine = __esm({
         const idleReady = !modal && hasAssistantTurn && quietForMs >= idleQuietThresholdMs && screenStableMs >= idleFinishConfirmMs;
         const candidate = this.idleFinishCandidate;
         const candidateQuiet = !!candidate && candidate.responseEpoch === this.responseEpoch && candidate.lastOutputAt === snap.lastOutputAt && candidate.lastScreenChangeAt === snap.lastScreenChangeAt && assistantLength >= candidate.assistantLength && now - candidate.armedAt >= idleFinishConfirmMs;
+        if (this.shouldDeferIdleForApprovalResume(now)) {
+          this.clearIdleFinishCandidate("approval_resume_grace_defer");
+          if (this.idleTimeout) clearTimeout(this.idleTimeout);
+          this.idleTimeout = setTimeout(() => {
+            if (this.isWaitingForResponse) this.evaluateSettled(this.transport.getSnapshot());
+          }, this.timeouts.idleFinish);
+          return;
+        }
         if (idleReady && candidateQuiet) {
           this.clearIdleFinishCandidate("finish_response");
           if (this.idleTimeout) clearTimeout(this.idleTimeout);
@@ -25254,6 +25271,12 @@ var init_cli_state_engine = __esm({
         if (this.idleTimeout) clearTimeout(this.idleTimeout);
         this.idleTimeout = setTimeout(() => {
           if (this.isWaitingForResponse && !this.hasActionableApproval()) {
+            if (this.shouldDeferIdleForApprovalResume(Date.now())) {
+              this.idleTimeout = setTimeout(() => {
+                if (this.isWaitingForResponse) this.evaluateSettled(this.transport.getSnapshot());
+              }, this.timeouts.idleFinish);
+              return;
+            }
             if (this.shouldDeferIdleTimeoutFinish()) return;
             const parsed = this.runParseSession(this.transport.getSnapshot());
             if (this.shouldDeferFinishForTranscript(parsed)) {
@@ -25265,6 +25288,47 @@ var init_cli_state_engine = __esm({
           }
         }, this.timeouts.idleFinish);
       }
+      /**
+       * FALSE-IDLE (Fix 2): should applyIdle suppress the idle/finish for the current
+       * turn because we are inside the post-approval resume grace?
+       *
+       * True only when: (a) the owning instance reports it is an autonomous auto-approving
+       * mesh session that resolved a modal within the resume-grace window
+       * (isInApprovalResumeGrace callback — the SAME judgment Fix 1 uses), AND (b) the defer
+       * for THIS response epoch has not yet exceeded APPROVAL_RESUME_IDLE_DEFER_CAP_MS.
+       * The cap guarantees no infinite defer: a turn that genuinely ended right after an
+       * approval and stays silent past the cap stops being suppressed and finishes normally.
+       * The per-epoch anchor means a fresh turn/response restarts the clock.
+       */
+      shouldDeferIdleForApprovalResume(now) {
+        if (typeof this.callbacks.isInApprovalResumeGrace !== "function") {
+          this.clearApprovalResumeDefer();
+          return false;
+        }
+        let inGrace = false;
+        try {
+          inGrace = this.callbacks.isInApprovalResumeGrace() === true;
+        } catch {
+          inGrace = false;
+        }
+        if (!inGrace) {
+          this.clearApprovalResumeDefer();
+          return false;
+        }
+        if (this.approvalResumeDeferEpoch !== this.responseEpoch || this.approvalResumeDeferSince === 0) {
+          this.approvalResumeDeferEpoch = this.responseEpoch;
+          this.approvalResumeDeferSince = now;
+          return true;
+        }
+        if (now - this.approvalResumeDeferSince >= APPROVAL_RESUME_IDLE_DEFER_CAP_MS) {
+          return false;
+        }
+        return true;
+      }
+      clearApprovalResumeDefer() {
+        this.approvalResumeDeferSince = 0;
+        this.approvalResumeDeferEpoch = -1;
+      }
       finishResponse() {
         if (this.submitPendingUntil > Date.now()) return;
         if (this.responseSettleIgnoreUntil > Date.now()) return;
@@ -25707,7 +25771,8 @@ var init_provider_cli_adapter = __esm({
             },
             onTurnCompleted: () => {
               this.responseBuffer = "";
-            }
+            },
+            isInApprovalResumeGrace: () => this.inApprovalResumeGraceProbe?.() === true
           },
           resolvedConfig.timeouts
         );
@@ -25739,6 +25804,9 @@ var init_provider_cli_adapter = __esm({
       ptyProcess = null;
       transportFactory;
       onStatusChange = null;
+      // FALSE-IDLE (Fix 2): probe the owning instance for the post-approval resume grace.
+      // Null until the instance registers it; the engine treats absence as "not in grace".
+      inApprovalResumeGraceProbe = null;
       // ─── State machine engine ─────────────────────────
       engine;
       responseBuffer = "";
@@ -25982,6 +26050,12 @@ ${lastSnapshot}`;
       setOnStatusChange(callback) {
         this.onStatusChange = callback;
       }
+      // FALSE-IDLE (Fix 2): the instance registers its inApprovalResumeGrace judgment so the
+      // engine's applyIdle hysteresis can scope itself to autonomous auto-approving sessions
+      // without the engine needing any mesh/auto-approve awareness of its own.
+      setInApprovalResumeGraceProbe(probe) {
+        this.inApprovalResumeGraceProbe = probe;
+      }
       setOnPtyData(callback) {
         this.onPtyDataCallback = callback;
       }
@@ -45618,6 +45692,28 @@ var CliProviderInstance = class _CliProviderInstance {
    * the nudge was NOT deferred) and leaked to the coordinator.
    */
   static AUTO_APPROVE_MASK_STALL_MS = 10500;
+  /**
+   * FALSE-IDLE (inter-approval quiet valley): grace window after an auto-approve
+   * (or mesh_approve) RESOLVES a modal during which a subsequent generating→idle
+   * quiet valley must NOT be treated as turn completion.
+   *
+   * The RCA: auto-approve resolves a modal → the agent resumes the same turn →
+   * between resolving that approval and preparing the next tool/approval the agent
+   * falls briefly silent. The FSM sees idle + a recorded mid-turn assistant bubble
+   * and fires an early agent:generating_completed even though the turn is still in
+   * flight. Live evidence showed the same session resuming waiting_approval ~13s
+   * after a "clean" completion emit.
+   *
+   * The window must be comfortably larger than the observed resume gap (~13s) so
+   * the valley is bridged, but not so large that a turn that genuinely ended right
+   * after an approval is held for an annoying stretch. 18s clears 13s with margin
+   * while capping the worst-case extra hold on a truly-finished turn at 18s (still
+   * well under COMPLETED_FINALIZATION_MAX_WAIT_MS's 30s hard bound). The recency is
+   * measured from the engine's lastApprovalResolvedAt, which is stamped ONLY by
+   * resolveModal (auto-approve fire / dashboard / mesh_approve) — so a plain turn
+   * with no approval never carries recency and is never held (no regression).
+   */
+  static APPROVAL_RESUME_GRACE_MS = 18e3;
   adapter;
   context = null;
   events = [];
@@ -45765,6 +45861,9 @@ var CliProviderInstance = class _CliProviderInstance {
     this.adapter.setOnStatusChange(() => {
       this.detectStatusTransition();
     });
+    if (typeof this.adapter.setInApprovalResumeGraceProbe === "function") {
+      this.adapter.setInApprovalResumeGraceProbe(() => this.inApprovalResumeGrace());
+    }
     await this.adapter.spawn();
     await this.enforceFreshSessionLaunchIfNeeded();
     await this.applyInitialThinkingLevelViaControl();
@@ -46653,6 +46752,9 @@ var CliProviderInstance = class _CliProviderInstance {
     if (adapterAny?.isWaitingForResponse === true) return { reason: "adapter_waiting_for_response", terminal: !approvalResolvedIdle };
     if (adapterAny?.currentTurnScope) return { reason: "adapter_turn_scope_active", terminal: !approvalResolvedIdle };
     if (this.hasAdapterPendingResponse()) return { reason: "adapter_pending_response", terminal: !approvalResolvedIdle };
+    if (!approvalResolvedIdle && this.inApprovalResumeGrace()) {
+      return { reason: "approval_resume_grace", terminal: false };
+    }
     const partial = typeof this.adapter.getPartialResponse === "function" ? this.adapter.getPartialResponse() : "";
     if (typeof partial === "string" && partial.trim()) return { reason: "partial_response_pending", terminal: true };
     let parsed;
@@ -46814,6 +46916,24 @@ var CliProviderInstance = class _CliProviderInstance {
   isAutonomousMeshSession() {
     return this.isMeshWorkerSession() || !!this.settings.meshCoordinatorFor;
   }
+  /**
+   * FALSE-IDLE: are we inside the post-approval resume grace window? True when this
+   * is an autonomous auto-approving mesh session AND the engine resolved a modal
+   * (auto-approve / mesh_approve) within APPROVAL_RESUME_GRACE_MS. This is the single
+   * "auto-approve recency" judgment shared by Fix 1 (the SETTLE-VALLEY completion
+   * hold below) and Fix 2 (the FSM-level applyIdle hysteresis in cli-state-engine).
+   *
+   * Scoped to autonomous auto-approving sessions so a foreground/attended session,
+   * or a session with auto-approve off (whose approvals a human answers), is never
+   * held. The recency clock (adapter.lastApprovalResolvedAt) is 0 until the first
+   * resolveModal, so a plain turn that never saw an approval always returns false.
+   */
+  inApprovalResumeGrace(now = Date.now()) {
+    if (!this.isAutonomousMeshSession() || !this.shouldAutoApprove()) return false;
+    const resolvedAt = typeof this.adapter?.lastApprovalResolvedAt === "number" ? this.adapter.lastApprovalResolvedAt : 0;
+    if (resolvedAt <= 0) return false;
+    return now - resolvedAt < _CliProviderInstance.APPROVAL_RESUME_GRACE_MS;
+  }
   /**
    * ARCH-REFACTOR R1: the taskId to attribute the CURRENTLY-completing turn to.
    * Prefers the per-turn binding (engine.currentTurnTaskId, set when the turn was
@@ -47125,7 +47245,14 @@ var CliProviderInstance = class _CliProviderInstance {
     this.autoApproveLastModalSeenAt = now;
     const modalKind = typeof modal?.kind === "string" ? modal.kind : "approval";
     if (modalKind !== "approval") {
-      return autoApproveActive;
+      const modalText = `${String(modal?.title || "")}
+${String(modal?.message || "")}
+${buttons.join("\n")}`;
+      const looksLikeSelectionPicker = /Select (?:a |an )?(?:model|mode|option)\b|Switch between/i.test(modalText);
+      const looksLikeConsent = looksLikeActiveApprovalPromptText(modalText) || /Do you want to (?:proceed|create|make|edit|apply|run|delete|modify|allow)\b|allow all edits\b|don'?t ask again\b/i.test(modalText) || hasNegativeApprovalOption(buttons) || hasReliableApprovalAffirmative(buttons);
+      if (looksLikeSelectionPicker && !looksLikeConsent) {
+        return autoApproveActive;
+      }
     }
     const { index: buttonIndex, label: buttonLabel } = pickApprovalButton(buttons, this.provider);
     const hasReliableConsentAnchor = hasNegativeApprovalOption(buttons) || hasReliableApprovalAffirmative(buttons);