@adhdev/daemon-core 0.9.82-rc.565 → 0.9.82-rc.567

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

@@ -13,6 +13,19 @@ export interface CliAdapterStatus {
     activeModal?: {
         message: string;
         buttons: string[];
+        /**
+         * BUTTON-INDEX-MISMAP (Fix C.1): each button's label paired with its real FSM
+         * DISPLAYED index (evaluator's Number(m[1])). `buttons` above is the label-only list
+         * every existing consumer reads (array position === pick order); `buttonMeta` preserves
+         * the index → label mapping so a partial / non-contiguous modal (display indices [1,3,4]
+         * at array positions [0,1,2]) does not lose its true indices once the modal leaves the
+         * adapter. Present only on spec/FSM adapters; absent for adapters that surface labels
+         * alone.
+         */
+        buttonMeta?: {
+            index: number;
+            label: string;
+        }[];
         /**
          * Semantic modal class, when the adapter knows it (spec/FSM path):
          * 'approval' = tool/command/trust consent (auto-approve may fire);
@@ -155,6 +168,7 @@ export interface CliAdapter {
     resolveAction?(data: unknown): Promise<void>;
     setInteractivePromptResponse?(response: InteractivePromptResponse): Promise<void>;
     resolveModal?(buttonIndex: number): void;
+    resolveModalMatched?(buttonIndex: number): boolean;
     isApprovalRecentlyResolved?(): boolean;
     setOnPtyData?(callback: (data: string) => void): void;
     writeRaw?(data: string): void;

package/dist/index.js

@@ -428,10 +428,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "7e94d6ed1034781a2d3b9857c3217eff63a8cbfd" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "7e94d6ed" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.565" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-18T04:28:04.680Z" : void 0);
+  const commit = readInjected(true ? "86f8d403efe203d7ff1d9b6997ede5f30620a485" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "86f8d403" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.567" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-18T09:04:16.210Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -14974,12 +14974,16 @@ function buildMeshActiveWork(opts) {
   for (const task of opts.queue || []) {
     if (task.status !== "pending" && task.status !== "assigned") continue;
     const { title, summary: summary2 } = summarizeMessage(task.message || "");
+    const queueNodeId = task.assignedNodeId || task.targetNodeId;
+    const queueSessionId = task.assignedSessionId || task.targetSessionId;
+    const queueLive = task.status === "assigned" ? sessionStatusFromNodes(opts.nodes, queueNodeId ?? void 0, queueSessionId ?? void 0) : {};
+    const queueStatus = queueLive.status === "awaiting_approval" || queueLive.status === "generating" ? queueLive.status : task.status;
     records.push({
       taskId: task.id,
       source: "queue",
-      status: task.status,
-      nodeId: task.assignedNodeId || task.targetNodeId,
-      sessionId: task.assignedSessionId || task.targetSessionId,
+      status: queueStatus,
+      nodeId: queueNodeId,
+      sessionId: queueSessionId,
       taskTitle: title,
       taskSummary: summary2,
       message: task.message,
@@ -20562,12 +20566,15 @@ function evaluateMeshEventSuppression(args, ctx) {
   }
   return null;
 }
-function sourceWorkerAutoApproves(components, sessionId) {
+function shouldSuppressAutoApprovingWorkerApproval(components, sessionId) {
   if (!sessionId) return false;
   try {
-    const state = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
+    const instance = components.instanceManager?.getInstance?.(sessionId);
+    const state = instance?.getState?.();
     const settings = state?.settings || {};
-    return settings.autoApprove === true;
+    if (settings.autoApprove !== true) return false;
+    const resolvedLocally = instance?.approvalRecentlyResolvedLocally;
+    return typeof resolvedLocally === "function" ? resolvedLocally.call(instance) === true : false;
   } catch {
     return false;
   }
@@ -20712,8 +20719,8 @@ function injectMeshSystemMessage(components, args) {
     }
   }
   const eventTimestamp = readEventTimestamp(args.metadataEvent.timestamp);
-  if (args.event === "agent:waiting_approval" && sourceWorkerAutoApproves(components, eventSessionId)) {
-    LOG.info("MeshEvents", `Suppressed agent:waiting_approval for auto-approving worker session ${eventSessionId || "(unknown)"} (mesh ${args.meshId}) \u2014 modal is resolved locally, coordinator not notified`);
+  if (args.event === "agent:waiting_approval" && shouldSuppressAutoApprovingWorkerApproval(components, eventSessionId)) {
+    LOG.info("MeshEvents", `Suppressed agent:waiting_approval for auto-approving worker session ${eventSessionId || "(unknown)"} (mesh ${args.meshId}) \u2014 modal resolved locally within cooldown, coordinator not notified`);
     traceMeshEventDrop("waiting_approval_auto_approving_worker", traceCtx);
     return { success: true, forwarded: 0, suppressed: true, autoApprovingWorkerApproval: true };
   }
@@ -22412,6 +22419,14 @@ function drainAndDeliverApprovalNudges(meshId, drainDaemonIds, localDaemonId, me
   }
   return delivered;
 }
+function assignedRowLiveStatusIsAwaitingApproval(mesh, nodeId, sessionId) {
+  if (!nodeId || !sessionId) return false;
+  try {
+    return sessionStatusFromNodes(mesh.nodes, nodeId, sessionId).status === "awaiting_approval";
+  } catch {
+    return false;
+  }
+}
 async function recoverStrandedAssignedDispatches(components, mesh, store) {
   const meshId = mesh.id;
   const assigned = getQueue(meshId, { status: ["assigned"] });
@@ -22443,6 +22458,15 @@ async function recoverStrandedAssignedDispatches(components, mesh, store) {
       } else {
         if (verdict === "IDLE_CONFIRMED") {
           deliveredUnconsumedUnknownStreak.delete(shortStreakKey);
+        } else if (assignedRowLiveStatusIsAwaitingApproval(mesh, row.assignedNodeId, row.assignedSessionId)) {
+          traceMeshEventDrop("short_redrive_deferred_awaiting_approval", {
+            taskId: row.id,
+            sessionId: row.assignedSessionId,
+            nodeId: row.assignedNodeId,
+            meshId,
+            event: "agent:waiting_approval"
+          }, "live_awaiting_approval");
+          continue;
         } else {
           const streak = (deliveredUnconsumedUnknownStreak.get(shortStreakKey) ?? 0) + 1;
           deliveredUnconsumedUnknownStreak.set(shortStreakKey, streak);
@@ -22505,6 +22529,15 @@ async function recoverStrandedAssignedDispatches(components, mesh, store) {
       if (verdict === "IDLE_CONFIRMED") {
         deliveredNoTurnUnknownStreak.delete(streakKey);
         reclaimReason = "delivered_no_turn_deadline";
+      } else if (assignedRowLiveStatusIsAwaitingApproval(mesh, row.assignedNodeId, row.assignedSessionId)) {
+        traceMeshEventDrop("reclaim_deferred_awaiting_approval", {
+          taskId: row.id,
+          sessionId: row.assignedSessionId,
+          nodeId: row.assignedNodeId,
+          meshId,
+          event: "agent:waiting_approval"
+        }, "live_awaiting_approval");
+        continue;
       } else {
         const streak = (deliveredNoTurnUnknownStreak.get(streakKey) ?? 0) + 1;
         deliveredNoTurnUnknownStreak.set(streakKey, streak);
@@ -23072,6 +23105,7 @@ var init_mesh_reconcile_loop = __esm({
     init_mesh_reconcile_config();
     init_mesh_remote_event_pull();
     init_mesh_completion_synthesis();
+    init_mesh_active_work();
     init_mesh_reconcile_v2_backstop();
     init_mesh_reconcile_acked_hold();
     coordinatorModalParkState = /* @__PURE__ */ new Map();
@@ -39441,7 +39475,13 @@ async function handleResolveAction(h, args) {
       LOG.info("Command", `[resolveAction] CLI PTY \u2192 stale_prompt (already resolved within cooldown)`);
       return { success: true, stalePrompt: true, buttonIndex, button: buttons[buttonIndex] ?? button };
     }
-    if (typeof adapter.resolveModal === "function") {
+    if (typeof adapter.resolveModalMatched === "function") {
+      const matched = adapter.resolveModalMatched(buttonIndex);
+      if (!matched) {
+        LOG.warn("Command", `[resolveAction] CLI PTY \u2192 no button matched for buttonIndex=${buttonIndex} "${buttons[buttonIndex] ?? "?"}" (modal not resolved)`);
+        return { success: false, error: "Approval button index did not map to a visible modal button", buttonIndex, button: buttons[buttonIndex] ?? button };
+      }
+    } else if (typeof adapter.resolveModal === "function") {
       adapter.resolveModal(buttonIndex);
     } else {
       const keys = "\x1B[B".repeat(Math.max(0, buttonIndex)) + "\r";
@@ -44034,7 +44074,7 @@ var FsmDriver = class {
         this.handleClickControl(cmd.control_id, cmd.payload);
         return;
       case "click_modal_button":
-        this.handleClickModalButton(cmd.index);
+        this.clickModalButton(cmd.index);
         return;
       case "attach_image":
         this.handleAttachImage(cmd.blob, cmd.mime);
@@ -44777,11 +44817,24 @@ var FsmDriver = class {
       }
     }
   }
+  /**
+   * BUTTON-INDEX-MISMAP (Fix C.3): public modal-click entry that returns whether a button
+   * matching the requested FSM display index was actually found and its confirm keys were
+   * dispatched. The old private handleClickModalButton silently `return`ed on a miss (no
+   * modal captured, or no button whose `.index` equals the requested display index), so a
+   * mis-mapped index looked identical to a successful press. Callers that need to know
+   * whether the click landed (mesh_approve → resolveModal) can now observe the miss instead
+   * of reporting success into the void. The generic `dispatch('click_modal_button')` path
+   * keeps ignoring the return (fire-and-forget UI clicks).
+   */
+  clickModalButton(index) {
+    return this.handleClickModalButton(index);
+  }
   handleClickModalButton(index) {
     const m = this.currentEval?.modal;
-    if (!m) return;
+    if (!m) return false;
     const btn = m.buttons.find((b) => b.index === index);
-    if (!btn) return;
+    if (!btn) return false;
     const rule = stateById(this.spec, this.currentStateId)?.extract?.buttons;
     if (rule?.select_mode === "arrow_keys") {
       const from = m.buttons.find((b) => b.current)?.index ?? 1;
@@ -44793,9 +44846,10 @@ var FsmDriver = class {
       const confirm = (rule.key_for_index || "\r").replace(/\{index\}/g, "") || "\r";
       if (nav) this.adapter.send_keys(nav);
       this.submitModalConfirm(confirm);
-      return;
+      return true;
     }
     this.submitModalConfirm(btn.key);
+    return true;
   }
   /**
    * Submit a modal-confirm key sequence (the choice key + its trailing CR).
@@ -46227,7 +46281,20 @@ var SpecCliAdapter = class _SpecCliAdapter {
         // modal this frame still stays waiting_approval (no activeModal yet).
         // `kind` carries the semantic modal class through to the auto-approve
         // gate so a /model picker (kind='picker') is never auto-answered.
-        activeModal: modal ? { message: modal.title ?? state.label, buttons: modal.buttons.map((b) => b.label), kind: modal.kind ?? null } : null,
+        // BUTTON-INDEX-MISMAP (Fix C.1): keep `buttons` as the label list every
+        // existing consumer (pickApprovalButton, mesh_approve, auto-approve) reads,
+        // but ALSO surface `buttonMeta` carrying each button's real FSM display index
+        // alongside its label. A partial/non-contiguous modal (display indices [1,3,4]
+        // at array positions [0,1,2]) then no longer loses the index → label mapping
+        // once it leaves the adapter: a consumer that has an array position can recover
+        // the true FSM index without re-parsing. resolveModal() below relies on the same
+        // ordered list to translate an array position to the correct FSM index.
+        activeModal: modal ? {
+          message: modal.title ?? state.label,
+          buttons: modal.buttons.map((b) => b.label),
+          buttonMeta: modal.buttons.map((b) => ({ index: b.index, label: b.label })),
+          kind: modal.kind ?? null
+        } : null,
         activeInteractivePrompt: this.activeInteractivePrompt,
         ...sessionFields
       };
@@ -46399,7 +46466,12 @@ var SpecCliAdapter = class _SpecCliAdapter {
     this.driver.dispatch({ kind: "resize", cols, rows });
   }
   resolveModal(buttonIndex) {
-    this.driver.dispatch({ kind: "click_modal_button", index: buttonIndex + 1 });
+    this.resolveModalMatched(buttonIndex);
+  }
+  resolveModalMatched(buttonIndex) {
+    const buttons = this.latestModal?.buttons ?? [];
+    const target = buttonIndex >= 0 && buttonIndex < buttons.length ? buttons[buttonIndex].index : buttonIndex + 1;
+    return this.driver.clickModalButton(target);
   }
   async resolveAction(data) {
     const args = data && typeof data === "object" ? data : {};
@@ -47559,6 +47631,15 @@ var CliProviderInstance = class _CliProviderInstance {
    * keystroke until the modal *content* has settled.
    */
   static AUTO_APPROVE_SETTLE_MS = 600;
+  /**
+   * APPROVAL-INBOX-BLINDSPOT (Fix A): how long after a LOCAL auto-approve fire the mesh
+   * event forwarder still treats the modal as "being resolved locally" and suppresses the
+   * coordinator notification. Chosen to comfortably cover the resolveModal → PTY absorb →
+   * status-leaves-approval round trip (incl. the win32 CR-resend loop) while staying short
+   * enough that a modal which auto-approve fired at but did NOT resolve re-surfaces to the
+   * coordinator on the next event. Aligned with the adapter's own approval cooldown scale.
+   */
+  static APPROVAL_LOCAL_RESOLUTION_COOLDOWN_MS = 8e3;
   /**
    * Busy-side hysteresis for the settle gate. A momentary `generating` flip
    * while the SAME approval modal's button block is still on screen (its
@@ -47831,6 +47912,16 @@ var CliProviderInstance = class _CliProviderInstance {
   // signature) while a genuinely closed modal — buttons empty continuously past
   // the continuity window — is still recognised and resets the gate.
   autoApproveLastModalSeenAt = 0;
+  // APPROVAL-INBOX-BLINDSPOT (Fix A): wall-clock of the last time this session actually
+  // FIRED a local auto-approve resolveModal (the settle gate passed → resolveModal
+  // dispatched). The mesh event forwarder keys its agent:waiting_approval suppression on
+  // this + a cooldown so it only drops the coordinator notification when we can positively
+  // confirm the modal was (or is being) resolved LOCALLY. If auto-approve is merely
+  // *configured* on but has NOT recently fired for this modal, the raw waiting_approval is
+  // forwarded so a task_approval_needed ledger row is created and the coordinator/inbox is
+  // told — closing the blind spot where a never-resolving worker approval was silently
+  // dropped just because settings.autoApprove===true.
+  lastAutoApproveFiredAt = 0;
   // AUTOAPPROVE-FLAP-INBOX-MISSING sticky-approval overlay (see APPROVAL_STICKY_FLAP_MS).
   // The wall-clock of the last frame where the RAW adapter reported waiting_approval with
   // a CONCRETE modal (buttons present), the cached modal to re-present across a busy blip,
@@ -48316,6 +48407,33 @@ var CliProviderInstance = class _CliProviderInstance {
     }
     return null;
   }
+  /**
+   * APPROVAL-INBOX-BLINDSPOT (Fix A): true when this session's approval modal was — or is
+   * being — resolved LOCALLY within the recent cooldown. Two independent positive signals:
+   *   (1) auto-approve fired its resolveModal within APPROVAL_LOCAL_RESOLUTION_COOLDOWN_MS
+   *       (lastAutoApproveFiredAt), or
+   *   (2) the underlying adapter reports isApprovalRecentlyResolved() — its own resolve
+   *       cooldown, which also covers a dashboard / mesh_approve resolution.
+   * The mesh event forwarder uses this to decide whether an agent:waiting_approval from an
+   * auto-approving worker can be safely SUPPRESSED (a local resolution is in flight) or must
+   * be FORWARDED (auto-approve is configured but has NOT actually resolved this modal, so the
+   * coordinator/inbox must be told). Keying suppression on real resolution — not just the
+   * autoApprove *intent* — is the blind-spot fix: a never-resolving worker approval is no
+   * longer silently dropped.
+   */
+  approvalRecentlyResolvedLocally(now = Date.now()) {
+    if (this.lastAutoApproveFiredAt && now - this.lastAutoApproveFiredAt < _CliProviderInstance.APPROVAL_LOCAL_RESOLUTION_COOLDOWN_MS) {
+      return true;
+    }
+    try {
+      const adapter = this.adapter;
+      if (typeof adapter.isApprovalRecentlyResolved === "function") {
+        return adapter.isApprovalRecentlyResolved() === true;
+      }
+    } catch {
+    }
+    return false;
+  }
   /**
    * NOTIF-HELD-DRAIN: true when this `waiting_approval` is a routine, transient tool-consent
    * of an autonomously-progressing mesh session rather than a genuine human-await modal —
@@ -49666,8 +49784,18 @@ ${buttons.join("\n")}`;
       this.lastAutoApprovalSignature = "";
     }, 5e3);
     this.recordAutoApproval(modal?.message, buttonLabel, now);
+    this.lastAutoApproveFiredAt = now;
     setTimeout(() => {
-      this.adapter.resolveModal(buttonIndex);
+      const adapter = this.adapter;
+      if (typeof adapter.resolveModalMatched === "function") {
+        const matched = adapter.resolveModalMatched(buttonIndex);
+        if (!matched) {
+          if (this.lastAutoApproveFiredAt === now) this.lastAutoApproveFiredAt = 0;
+          LOG.warn("CLI", `[${this.type}] auto-approve resolveModal matched no button (index ${buttonIndex}) \u2014 surfacing approval to coordinator`);
+        }
+      } else {
+        adapter.resolveModal?.(buttonIndex);
+      }
     }, 0);
     return autoApproveActive;
   }