@adhdev/daemon-core 0.9.82-rc.566 → 0.9.82-rc.568

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 ? "d0d245e6363e5bdeee369f7e28132ff8ca989184" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "d0d245e6" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.566" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-18T07:10:36.457Z" : void 0);
+  const commit = readInjected(true ? "39e0687342226d334e36c982bd8988802f43dd3e" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "39e06873" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.568" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-18T14:18:06.483Z" : 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 —
@@ -48673,18 +48791,30 @@ var CliProviderInstance = class _CliProviderInstance {
    * the dashboard tail-repair cache — a display value, not a completion decision.
    */
   lastVisibleAssistantSummary(messages) {
-    if (!Array.isArray(messages)) return "";
+    return this.lastVisibleAssistantSummaryDetail(messages).content;
+  }
+  // Like lastVisibleAssistantSummary but also returns the source bubble's own
+  // timestamp (ms), so a cached summary can later be turn-scoped: the display
+  // cache is populated from an UNSCOPED tail read (it must show the answer as
+  // soon as native-history has it), so it can hold a bubble that predates the
+  // current turn. Recording the bubble's timestamp lets the weak-completion
+  // fallback reject a turn-stale cached summary instead of re-leaking the exact
+  // stale bubble the turn-boundary gate already rejected (FALSE-IDLE Defect 1c).
+  lastVisibleAssistantSummaryDetail(messages) {
+    if (!Array.isArray(messages)) return { content: "" };
     for (let i = messages.length - 1; i >= 0; i -= 1) {
       const m = messages[i];
       const role = typeof m?.role === "string" ? m.role : "";
       const kind = typeof m?.kind === "string" ? m.kind : "";
       if (role === "system") continue;
       if (kind === "tool" || kind === "activity") continue;
-      if (role === "user" || role === "human") return "";
-      if (role === "assistant") return flattenContent(m.content).trim();
-      return "";
+      if (role === "user" || role === "human") return { content: "" };
+      if (role === "assistant") {
+        return { content: flattenContent(m.content).trim(), timestampMs: readChatMessageTimestampMs(m) };
+      }
+      return { content: "" };
     }
-    return "";
+    return { content: "" };
   }
   /**
    * NOTIF Defect-B: the final assistant summary this instance ALREADY parsed and
@@ -48705,6 +48835,28 @@ var CliProviderInstance = class _CliProviderInstance {
     const content = typeof cached3?.content === "string" ? cached3.content.trim() : "";
     return content;
   }
+  // FALSE-IDLE Defect 1c: turn-scoped view of the cached completion summary.
+  // The cache is populated from an UNSCOPED tail read (lastVisibleAssistant‑
+  // SummaryDetail) so the dashboard can show the answer the instant native-history
+  // has it — which means it can hold a bubble that PREDATES the producing turn.
+  // The weak-completion (missing_final_assistant) emit path falls back to the cache
+  // for finalSummary; without turn-scoping it would re-surface the exact stale
+  // mid-turn bubble the turn-boundary gate already rejected as evidence, freezing
+  // that stale text as the completion's finalSummary. Consult the cache only when
+  // its source bubble is proven in-turn (timestamp at/after turnStartedAt). When no
+  // boundary is known (turnStartedAt falsy) or the cache carries no source timestamp
+  // (legacy writes), behaviour is identical to the unscoped read.
+  cachedInTurnCompletionSummaryContent(turnStartedAt) {
+    const cached3 = this.lastCompletionSummary;
+    const content = typeof cached3?.content === "string" ? cached3.content.trim() : "";
+    if (!content) return "";
+    const hasBoundary = typeof turnStartedAt === "number" && Number.isFinite(turnStartedAt) && turnStartedAt > 0;
+    const ts2 = cached3?.sourceTimestampMs;
+    if (hasBoundary && typeof ts2 === "number" && Number.isFinite(ts2) && ts2 < turnStartedAt) {
+      return "";
+    }
+    return content;
+  }
   completionFinalAssistantEvidence(parsedMessages, turnStartedAt) {
     const turnClosed = !this.hasAdapterPendingResponse();
     if (this.completionHasFinalAssistantMessage(parsedMessages, turnStartedAt)) {
@@ -48718,9 +48870,9 @@ var CliProviderInstance = class _CliProviderInstance {
     if (externalMessages) {
       const injectedTaskGenerating = this.injectedTaskHasStartedGenerating();
       const present = injectedTaskGenerating && turnClosed && this.completionHasFinalAssistantMessage(externalMessages, turnStartedAt);
-      const lastVisibleAssistant = this.lastVisibleAssistantSummary(externalMessages);
-      if (lastVisibleAssistant) {
-        this.lastCompletionSummary = { content: lastVisibleAssistant, receivedAt: Date.now() };
+      const lastVisibleAssistant = this.lastVisibleAssistantSummaryDetail(externalMessages);
+      if (lastVisibleAssistant.content) {
+        this.lastCompletionSummary = { content: lastVisibleAssistant.content, receivedAt: Date.now(), sourceTimestampMs: lastVisibleAssistant.timestampMs };
       }
       return {
         present,
@@ -48744,7 +48896,7 @@ var CliProviderInstance = class _CliProviderInstance {
       const externalMessages = this.readExternalCompletionMessages();
       const externalSummary = externalMessages ? extractFinalSummaryFromMessagesAfter(externalMessages, turnStartedAt) : "";
       if (externalSummary) {
-        this.lastCompletionSummary = { content: externalSummary, receivedAt: Date.now() };
+        this.lastCompletionSummary = { content: externalSummary, receivedAt: Date.now(), sourceTimestampMs: typeof turnStartedAt === "number" ? turnStartedAt : void 0 };
         return externalSummary;
       }
       return parsedSummary || void 0;
@@ -48759,7 +48911,7 @@ var CliProviderInstance = class _CliProviderInstance {
     } catch (error) {
       parseError = error?.message || String(error);
     }
-    const evidence = this.completionFinalAssistantEvidence(parsed?.messages);
+    const evidence = this.completionFinalAssistantEvidence(parsed?.messages, args.pending.turnStartedAt);
     if (evidence.source === "external-native") {
       this.recordPendingTranscriptProbe(args.pending);
     }
@@ -48768,7 +48920,7 @@ var CliProviderInstance = class _CliProviderInstance {
     const lastVisibleRole = typeof lastVisible?.role === "string" ? lastVisible.role.trim().toLowerCase() : null;
     const lastVisibleKind = typeof lastVisible?.kind === "string" ? lastVisible.kind : null;
     const lastVisibleContentLength = lastVisible ? flattenContent(lastVisible.content).trim().length : 0;
-    const cachedSummary = evidence.present ? "" : this.cachedCompletionSummaryContent();
+    const cachedSummary = evidence.present ? "" : this.cachedInTurnCompletionSummaryContent(args.pending.turnStartedAt);
     const creditedFromCache = !evidence.present && cachedSummary.length > 0;
     const finalAssistantPresent = evidence.present || creditedFromCache;
     const finalAssistantEvidenceSource = evidence.present ? evidence.source : creditedFromCache ? "cached-summary" : evidence.source;
@@ -49432,7 +49584,7 @@ var CliProviderInstance = class _CliProviderInstance {
         // real answer (lastCompletionSummary). Fall back to the cache so the notification
         // carries the summary that mesh_read_chat.summary already shows — consistent with
         // completionDiagnostic.finalAssistantPresent being credited from the same cache.
-        finalSummary: this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages, pending.turnStartedAt) || this.cachedCompletionSummaryContent() || (blockReason.startsWith("parsed_status:") ? "" : void 0),
+        finalSummary: this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages, pending.turnStartedAt) || this.cachedInTurnCompletionSummaryContent(pending.turnStartedAt) || (blockReason.startsWith("parsed_status:") ? "" : void 0),
         completionDiagnostic
       });
       this.completedDebouncePending = null;
@@ -49666,8 +49818,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;
   }