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

package/dist/providers/approval-utils.d.ts

@@ -6,6 +6,31 @@ import type { ProviderModule } from './contracts.js';
  * decline, which distinguishes it from a generic numbered menu or prose list.
  */
 export declare function hasNegativeApprovalOption(buttons: string[] | null | undefined): boolean;
+/**
+ * True when a button reliably identifies a tool-CONSENT modal on its own — a
+ * scoped permission-grant affirmative such as:
+ *   - "Yes, allow all edits in tmp/ during this session"
+ *   - "Yes, and don't ask again for example.com"
+ *   - "Yes, allow reading from etc/ from this project"
+ *   - "Always allow"
+ *
+ * These options only ever appear in a genuine approval/permission prompt; a
+ * /model or /mode picker ("1. Default  2. Opus  3. Sonnet") never offers a
+ * "grant this scope" choice. They therefore serve as a SECOND reliable
+ * structural anchor alongside {@link hasNegativeApprovalOption}.
+ *
+ * Why this exists (tall-diff fallback, #137): when a Write/Edit diff is tall,
+ * the trailing decline option ("3. No") can scroll off the bottom of the
+ * captured PTY frame, leaving only "1. Yes" + "2. Yes, allow … this session".
+ * hasNegativeApprovalOption then reads false and the auto-approve gate bails —
+ * a delegated worker sits forever on a modal it could safely have approved. The
+ * grant-scope affirmative lets the gate recognize the consent modal WITHOUT
+ * seeing the off-frame decline. The gate still selects the plain "Yes"
+ * (allow-once) via pickApprovalButton, never the broader grant, and the settle
+ * gate still requires a stable modal — so a half-rendered frame never fires.
+ * Kept deliberately narrow so no picker/confirm modal can trip it.
+ */
+export declare function hasReliableApprovalAffirmative(buttons: string[] | null | undefined): boolean;
 export declare function getApprovalPositiveHints(provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): string[];
 export declare function pickApprovalButton(buttons: string[] | null | undefined, provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): {
     index: number;

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

@@ -115,6 +115,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private autoApproveSettleTimer;
     private autoApproveInactiveSince;
     private autoApproveMaskSince;
+    private stalledApprovalNudgeEpisode;
     private readonly manualAttendance;
     private controlValues;
     private summaryMetadata;
@@ -355,7 +356,9 @@ export declare class CliProviderInstance implements ProviderInstance {
     get cliName(): string;
     private shouldAutoApprove;
     /** @see ProviderInstance.noteManualInteraction */
-    noteManualInteraction(now?: number): void;
+    noteManualInteraction(now?: number, opts?: {
+        passive?: boolean;
+    }): void;
     /**
      * Whether auto-approve should be treated as active *right now* for display
      * and firing decisions: the configured intent AND the user is not currently
@@ -366,6 +369,28 @@ export declare class CliProviderInstance implements ProviderInstance {
      */
     private autoApproveEffectivelyActive;
     private autoApproveMaskStalled;
+    /**
+     * 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;
     private recordAutoApproval;
     recordApprovalSelection(buttonText: string): void;
     private formatMarkerTimestamp;

package/dist/providers/manual-attendance.d.ts

@@ -61,3 +61,19 @@ export declare class ManualAttendanceTracker {
  * pure read commands (read_chat / list_chats — passive polling, not driving).
  */
 export declare const MANUAL_ATTENDANCE_COMMANDS: ReadonlySet<string>;
+/**
+ * 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 declare const MANUAL_ATTENDANCE_PASSIVE_VIEW_COMMANDS: ReadonlySet<string>;

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

@@ -200,8 +200,15 @@ 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/package.json

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

package/src/commands/handler.ts

@@ -26,7 +26,7 @@ import { reconcileIdeRuntimeSessions } from '../sessions/reconcile.js';
 import { LOG } from '../logging/logger.js';
 import { resolveLegacyProviderScript, type LegacyStringScript } from './provider-script-resolver.js';
 import { sha256Hex } from '../system/hash.js';
-import { MANUAL_ATTENDANCE_COMMANDS } from '../providers/manual-attendance.js';
+import { MANUAL_ATTENDANCE_COMMANDS, MANUAL_ATTENDANCE_PASSIVE_VIEW_COMMANDS } from '../providers/manual-attendance.js';
 
 // Sub-module imports
 import * as Chat from './chat-commands.js';
@@ -393,15 +393,18 @@ export class DaemonCommandHandler implements CommandHelpers {
      */
     private noteManualAttendanceIfApplicable(cmd: string, args: any): void {
         if (!MANUAL_ATTENDANCE_COMMANDS.has(cmd)) return;
+        // Passive view-only actions (select_session / open_panel) attend a
+        // foreground session but NOT a delegated worker — the instance decides.
+        const passive = MANUAL_ATTENDANCE_PASSIVE_VIEW_COMMANDS.has(cmd);
         const sessionId = this._currentRoute.session?.sessionId
             || (typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : '');
         if (!sessionId) return;
         const session = this._ctx.sessionRegistry?.get(sessionId);
         const instanceKey = session?.adapterKey || session?.instanceKey || sessionId;
         const instance = this._ctx.instanceManager?.getInstance(instanceKey) as
-            { noteManualInteraction?: (now?: number) => void } | undefined;
+            { noteManualInteraction?: (now?: number, opts?: { passive?: boolean }) => void } | undefined;
         try {
-            instance?.noteManualInteraction?.();
+            instance?.noteManualInteraction?.(undefined, { passive });
         } catch {
             // attendance is best-effort — never block command dispatch
         }

package/src/providers/approval-utils.ts

@@ -41,6 +41,48 @@ export function hasNegativeApprovalOption(buttons: string[] | null | undefined):
     return (buttons || []).some((button) => isNegativeApprovalLabel(String(button || '')));
 }
 
+/**
+ * True when a button reliably identifies a tool-CONSENT modal on its own — a
+ * scoped permission-grant affirmative such as:
+ *   - "Yes, allow all edits in tmp/ during this session"
+ *   - "Yes, and don't ask again for example.com"
+ *   - "Yes, allow reading from etc/ from this project"
+ *   - "Always allow"
+ *
+ * These options only ever appear in a genuine approval/permission prompt; a
+ * /model or /mode picker ("1. Default  2. Opus  3. Sonnet") never offers a
+ * "grant this scope" choice. They therefore serve as a SECOND reliable
+ * structural anchor alongside {@link hasNegativeApprovalOption}.
+ *
+ * Why this exists (tall-diff fallback, #137): when a Write/Edit diff is tall,
+ * the trailing decline option ("3. No") can scroll off the bottom of the
+ * captured PTY frame, leaving only "1. Yes" + "2. Yes, allow … this session".
+ * hasNegativeApprovalOption then reads false and the auto-approve gate bails —
+ * a delegated worker sits forever on a modal it could safely have approved. The
+ * grant-scope affirmative lets the gate recognize the consent modal WITHOUT
+ * seeing the off-frame decline. The gate still selects the plain "Yes"
+ * (allow-once) via pickApprovalButton, never the broader grant, and the settle
+ * gate still requires a stable modal — so a half-rendered frame never fires.
+ * Kept deliberately narrow so no picker/confirm modal can trip it.
+ */
+export function hasReliableApprovalAffirmative(buttons: string[] | null | undefined): boolean {
+    return (buttons || []).some((button) => {
+        const label = normalizeApprovalLabel(String(button || ''));
+        if (!label) return false;
+        // "always allow …" as a standalone grant option.
+        if (/^always allow\b/.test(label)) return true;
+        // "yes, …" scoped grants: allow / always allow / don't ask again / etc.
+        // (normalizeApprovalLabel strips the apostrophe, so "don't" → "don t").
+        if (/^yes\b/.test(label)) {
+            if (/\ballow\b/.test(label)) return true;
+            if (/\bask again\b/.test(label)) return true;
+            if (/\bduring this session\b/.test(label)) return true;
+            if (/\bfrom this project\b/.test(label)) return true;
+        }
+        return false;
+    });
+}
+
 export function getApprovalPositiveHints(provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): string[] {
     const customHints = Array.isArray(provider?.approvalPositiveHints)
         ? provider.approvalPositiveHints

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.