@adhdev/daemon-core 0.9.82-rc.454 → 0.9.82-rc.456

package/src/providers/cli-provider-instance.ts

@@ -25,7 +25,7 @@ import { LOG } from '../logging/logger.js';
 import { traceMeshEventStage, traceMeshEventDrop } from '../mesh/mesh-event-trace.js';
 import type { ChatMessage } from '../types.js';
 import { buildPersistedProviderEffectMessage, normalizeProviderEffects } from './control-effects.js';
-import { formatAutoApprovalMessage, pickApprovalButton, hasNegativeApprovalOption, looksLikeActiveApprovalPromptText } from './approval-utils.js';
+import { formatAutoApprovalMessage, pickApprovalButton, hasNegativeApprovalOption, hasReliableApprovalAffirmative, looksLikeActiveApprovalPromptText } from './approval-utils.js';
 import { getCliScriptCommand, parseCliScriptResult } from './cli-script-results.js';
 import { mergeProviderPatchState, resolveProviderStateSurface } from './provider-patch-state.js';
 import { normalizeProviderSessionId } from './provider-session-id.js';
@@ -572,6 +572,13 @@ export class CliProviderInstance implements ProviderInstance {
     // mask is dropped so the real waiting_approval surfaces. Cleared when the episode ends
     // (modal genuinely gone, manual attendance takes over, or auto-approve fires).
     private autoApproveMaskSince = 0;
+    // NOTIF-APPROVAL-MASKED (Q1b): the autoApproveMaskSince episode value for which a
+    // stalled-approval coordinator nudge has already been emitted, so the nudge fires
+    // exactly once per stalled auto-approve episode (0 = none emitted). Reusing the
+    // per-episode mask-clock value as the key makes it provider-agnostic (no reliance on
+    // approvalEntrySeq) and self-resetting: each new episode gets a fresh
+    // autoApproveMaskSince timestamp, and the episode-end reset zeroes it.
+    private stalledApprovalNudgeEpisode = 0;
     // Provider-common manual-attendance signal: while a human is actively driving
     // this session from the dashboard, auto-approve holds so they can take manual
     // control. Background mesh workers are never attended → delegated auto-approve
@@ -2056,6 +2063,7 @@ export class CliProviderInstance implements ProviderInstance {
             // Manual attendance takes over — the modal stays surfaced (maybeAutoApproveStatus
             // returns false), so end the mask episode.
             this.autoApproveMaskSince = 0;
+            this.stalledApprovalNudgeEpisode = 0;
             if (this.autoApproveSettleTimer) clearTimeout(this.autoApproveSettleTimer);
             this.autoApproveSettleTimer = setTimeout(() => {
                 this.autoApproveSettleTimer = null;
@@ -2100,6 +2108,7 @@ export class CliProviderInstance implements ProviderInstance {
             // Modal has genuinely been gone past the hysteresis window → the episode ended;
             // end the mask episode too (a later approval starts a fresh stall clock).
             this.autoApproveMaskSince = 0;
+            this.stalledApprovalNudgeEpisode = 0;
             if (this.autoApproveSettleTimer) { clearTimeout(this.autoApproveSettleTimer); this.autoApproveSettleTimer = null; }
             return autoApproveActive;
         }
@@ -2110,6 +2119,12 @@ export class CliProviderInstance implements ProviderInstance {
         // when zero so it survives modal-signature changes and hysteresis blips — it measures
         // the true age of the unresolved auto-approve, not the per-signature settle window.
         if (!this.autoApproveMaskSince) this.autoApproveMaskSince = now;
+        // NOTIF-APPROVAL-MASKED (Q1b): once this episode has stalled past the mask threshold,
+        // surface the raw waiting_approval to the mesh coordinator (decoupled from the dashboard
+        // mask). Placed on the active-approval path here — the single choke point that owns the
+        // mask-stall clock and is re-driven throughout a silent stall (getState heartbeat,
+        // detectStatusTransition, recheckAutoApproveSettled). No-op until the stall threshold trips.
+        this.maybeEmitStalledApprovalNudge(adapterStatus, now);
         const modal = adapterStatus.activeModal;
         // (fix) Do not auto-approve when no concrete modal/buttons are present.
         // Claude TUI flaps between paints; without this guard adapterStatus
@@ -2147,10 +2162,22 @@ export class CliProviderInstance implements ProviderInstance {
             return autoApproveActive;
         }
         const { index: buttonIndex, label: buttonLabel } = pickApprovalButton(buttons, this.provider);
-        if (buttonIndex < 0 || !hasNegativeApprovalOption(buttons)) {
-            // No affirmative matched, or no decline option present (→ not a real
-            // consent prompt, e.g. a picker that slipped past the kind gate).
-            // Surface the modal so the user decides; never pick blindly.
+        // Structural decline anchor. A real approval offers BOTH an affirmative
+        // and a decline — but on a TALL Write/Edit diff the trailing "3. No"
+        // scrolls off the captured frame, leaving only "1. Yes" + "2. Yes, allow
+        // … this session" so hasNegativeApprovalOption reads false (#137). A
+        // scoped grant-affirmative ("Yes, allow … during this session" / "…don't
+        // ask again") ONLY appears in a genuine consent modal (never a picker),
+        // so it stands in for the off-frame decline as a reliable second anchor.
+        // Conservative by construction: a picker without a grant-scope option
+        // still bails here, and the fire below still picks the plain allow-once
+        // "Yes" via pickApprovalButton, not the broader grant.
+        const hasReliableConsentAnchor = hasNegativeApprovalOption(buttons)
+            || hasReliableApprovalAffirmative(buttons);
+        if (buttonIndex < 0 || !hasReliableConsentAnchor) {
+            // No affirmative matched, or no decline / reliable grant option present
+            // (→ not a real consent prompt, e.g. a picker that slipped past the
+            // kind gate). Surface the modal so the user decides; never pick blindly.
             return autoApproveActive;
         }
         // Modal *identity* signature — the question/button set only, NO volatile
@@ -2215,6 +2242,7 @@ export class CliProviderInstance implements ProviderInstance {
         this.autoApproveInactiveSince = 0;
         // Fired (resolveModal in flight) — the episode resolved; end the mask-stall clock.
         this.autoApproveMaskSince = 0;
+        this.stalledApprovalNudgeEpisode = 0;
         if (this.autoApproveBusyTimer) clearTimeout(this.autoApproveBusyTimer);
         this.autoApproveBusyTimer = setTimeout(() => {
             this.autoApproveBusy = false;
@@ -3124,7 +3152,16 @@ export class CliProviderInstance implements ProviderInstance {
     }
 
     /** @see ProviderInstance.noteManualInteraction */
-    noteManualInteraction(now = Date.now()): void {
+    noteManualInteraction(now = Date.now(), opts?: { passive?: boolean }): void {
+        // P1b (#137 secondary): a DELEGATED worker session must not treat a
+        // passive dashboard view (foreground tab selection / panel open) as
+        // manual attendance. A coordinator merely peeking at a worker's panel
+        // would otherwise suppress that worker's delegated auto-approve for the
+        // whole 60s window. Only explicit input/intervention (controlbar,
+        // resolve_action, pty_input) attends a worker. Non-worker (foreground)
+        // sessions keep noting on passive views so a user foregrounding their own
+        // session still holds auto-approve to act on the modal themselves.
+        if (opts?.passive && this.isMeshWorkerSession()) return;
         this.manualAttendance.note(now);
     }
 
@@ -3154,6 +3191,50 @@ export class CliProviderInstance implements ProviderInstance {
             && now - this.autoApproveMaskSince > CliProviderInstance.AUTO_APPROVE_MASK_STALL_MS;
     }
 
+    /**
+     * NOTIF-APPROVAL-MASKED (Q1b): surface a delegated worker's STALLED auto-approve modal
+     * to the mesh COORDINATOR, decoupled from the dashboard visible-status mask.
+     *
+     * When auto-approve is configured but the episode never settles (modal parse miss / the
+     * settle gate never satisfied), getState()/detectStatusTransition() fold the raw
+     * `waiting_approval` into `generating` to suppress dashboard flicker — so
+     * detectStatusTransition()'s `waiting_approval` arm never runs and NO agent:waiting_approval
+     * event is emitted. The coordinator's real-time approval-nudge delivery then has no input and
+     * the worker's stuck modal is never surfaced (the live ~25s stall). The dashboard mask is
+     * intentional and stays; this emits the coordinator nudge exactly ONCE, gated on the SAME
+     * raw-waiting_approval + mask-stalled signal resolveModalParkStatus() distinguishes, the
+     * instant the mask-stall threshold trips (the same moment getState un-folds the mask).
+     *
+     * Only delegated worker sessions qualify: a foreground session has no coordinator to notify,
+     * and its own dashboard mask already reveals the modal on stall. A normally-resolving
+     * auto-approve never reaches AUTO_APPROVE_MASK_STALL_MS, so it emits nothing here; and if a
+     * masked approval clears just as this fires, rc.455's isApprovalNudgeResolved stale-drop
+     * discards the nudge coordinator-side without noise. Dedup is per-episode (keyed on the
+     * mask-clock value) so a modal that flaps between parsed/unparsed states is announced once.
+     */
+    private maybeEmitStalledApprovalNudge(adapterStatus: any, now: number): void {
+        if (!this.isMeshWorkerSession()) return;
+        if (adapterStatus?.status !== 'waiting_approval') return;
+        if (!this.autoApproveMaskStalled(now)) return;
+        // Exactly once per stalled episode (autoApproveMaskSince uniquely identifies it).
+        if (this.stalledApprovalNudgeEpisode === this.autoApproveMaskSince) return;
+        this.stalledApprovalNudgeEpisode = this.autoApproveMaskSince;
+        const modal = adapterStatus.activeModal;
+        const dirName = workingDirBasename(this.workingDir);
+        const chatTitle = `${this.provider.name} · ${dirName}`;
+        this.appendRuntimeSystemMessage(
+            this.formatApprovalRequestMessage(modal?.message, modal?.buttons),
+            `approval_request:${now}`,
+            now,
+        );
+        this.pushEvent({
+            event: 'agent:waiting_approval', chatTitle, timestamp: now,
+            modalMessage: modal?.message,
+            modalButtons: modal?.buttons,
+        });
+        LOG.info('CLI', `[${this.type}] stalled auto-approve nudge → coordinator (masked ${Math.round((now - this.autoApproveMaskSince) / 1000)}s)`);
+    }
+
     private recordAutoApproval(modalMessage?: string, buttonLabel?: string, now = Date.now()): void {
         this.appendRuntimeSystemMessage(
             formatAutoApprovalMessage(modalMessage, buttonLabel),

package/src/providers/manual-attendance.ts

@@ -83,3 +83,23 @@ export const MANUAL_ATTENDANCE_COMMANDS: ReadonlySet<string> = new Set([
     'resolve_action',
     'pty_input',
 ]);
+
+/**
+ * The subset of {@link MANUAL_ATTENDANCE_COMMANDS} that are PASSIVE view-only
+ * actions — foregrounding a session's tab / opening its panel. They convey "I am
+ * looking at this session", not "I am driving it", and carry no user input.
+ *
+ * For a foreground (base-node) session these still attend: a user who
+ * foregrounds their own session should get the quiet window so an incoming
+ * approval stays visible for them to act on. But for a DELEGATED worker session
+ * a passive peek must NOT attend — a coordinator merely opening a worker's panel
+ * to watch progress would otherwise suppress that worker's delegated
+ * auto-approve for the whole window (secondary cause, #137). The per-instance
+ * hook decides: it drops a passive stamp only when the session is a delegated
+ * worker, so explicit input (controlbar / resolve_action / pty_input) still
+ * attends a worker and a foreground session is unaffected.
+ */
+export const MANUAL_ATTENDANCE_PASSIVE_VIEW_COMMANDS: ReadonlySet<string> = new Set([
+    'select_session',
+    'open_panel',
+]);

package/src/providers/provider-instance.ts

@@ -232,8 +232,13 @@ export interface ProviderInstance {
      * input). Provider-common signal that suppresses auto-approve for a short
      * window so the user can drive the session manually; background mesh worker
      * sessions never receive it, so their delegated auto-approve is unaffected.
+     *
+     * `opts.passive` marks a view-only action (select_session / open_panel). A
+     * delegated worker session ignores passive stamps so a coordinator merely
+     * watching its panel does not suppress its delegated auto-approve; explicit
+     * input still attends. Foreground sessions attend on passive views too.
      */
-    noteManualInteraction?(now?: number): void;
+    noteManualInteraction?(now?: number, opts?: { passive?: boolean }): void;
 
  /** cleanup */
     dispose(): void;

package/src/providers/sdk/v1/builders/cli/parse-approval.ts

@@ -63,7 +63,12 @@ export interface ModalTuiSpec {
 
 // ─── Helpers ───────────────────────────────────────────────────────────
 
-const SEPARATOR_RE = /^(?:─|━|═|━){10,}\s*$/;
+// A horizontal rule line. Covers solid box-drawing rules (─ ━ ═) AND the dashed
+// variants (╌ ╍ ┄ ┅ ┈ ┉) that Claude Code draws as the INNER separators around a
+// Write/Edit diff body. This matches the coverage of the claude-cli v4 FSM spec
+// anchor `^[─╌]+$` (issue #137) so the SDK-v1 parser recognizes the same modal
+// frames the FSM does — a dashed rule is a separator, not modal content.
+const SEPARATOR_RE = /^[─━═╌╍┄┅┈┉]{10,}\s*$/;
 
 function compile(re: string, flags?: string): RegExp {
   try {
@@ -119,7 +124,13 @@ function scopeLines(
       }
     }
   }
-  if (lastSep >= 0 && prevSep >= 0) {
+  // Only scope to the separator frame when it actually BRACKETS the question
+  // line. Claude Write/Edit modals draw dashed (╌) inner rules around the diff
+  // body, so the last two separators can enclose the file diff while the
+  // question + button block sit BELOW the lower dashed rule. Scoping to that
+  // inner frame would drop every button (→ null → missed auto-approve, #137).
+  // When the question is outside the frame, fall through to a window around it.
+  if (lastSep >= 0 && prevSep >= 0 && questionIndex >= prevSep && questionIndex < lastSep + 1) {
     return { start: prevSep, end: lastSep + 1 };
   }
   // Fallback: window around question line.