@adhdev/daemon-core 0.9.82-rc.353 → 0.9.82-rc.355

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

@@ -21,6 +21,7 @@ import type { PtyRuntimeMetadata, PtyTransportFactory } from '../cli-adapters/pt
 import { StatusMonitor } from './status-monitor.js';
 import { ChatHistoryWriter, isNativeSourceCanonicalHistory, materializeProviderNativeHistory, readChatHistory, readProviderChatHistory } from '../config/chat-history.js';
 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, pickAutoApprovalButton, looksLikeActiveApprovalPromptText } from './approval-utils.js';
@@ -29,6 +30,7 @@ import { mergeProviderPatchState, resolveProviderStateSurface } from './provider
 import { normalizeProviderSessionId } from './provider-session-id.js';
 import { buildChatMessage, buildRuntimeSystemChatMessage, isUserFacingChatMessage, normalizeChatMessages, resolveChatMessageKind, extractFinalSummaryFromMessages } from './chat-message-normalization.js';
 import { workingDirBasename } from './working-dir.js';
+import { ManualAttendanceTracker } from './manual-attendance.js';
 
 type PersistableCliHistoryMessage = {
     role: string;
@@ -416,6 +418,11 @@ export class CliProviderInstance implements ProviderInstance {
     // a settle gate was in progress. Drives AUTO_APPROVE_GATE_HYSTERESIS_MS so a
     // brief generating flip does not immediately wipe the settle clock.
     private autoApproveInactiveSince = 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
+    // is unaffected.
+    private readonly manualAttendance = new ManualAttendanceTracker();
     private controlValues: Record<string, string | number | boolean> = {};
     private summaryMetadata: unknown = undefined;
     private appliedEffectKeys = new Set<string>();
@@ -828,7 +835,7 @@ export class CliProviderInstance implements ProviderInstance {
 
     getHotChatSessionState(): HotChatSessionState {
         const adapterStatus = this.adapter.getStatus({ allowParse: false });
-        const autoApproveActive = adapterStatus.status === 'waiting_approval' && this.shouldAutoApprove();
+        const autoApproveActive = this.autoApproveEffectivelyActive(adapterStatus.status);
         const autoApproveHoldIdle = this.autoApproveBusy && adapterStatus.status === 'idle';
         const visibleStatus = autoApproveActive || autoApproveHoldIdle ? 'generating' : adapterStatus.status;
         const runtime = this.adapter.getRuntimeMetadata();
@@ -844,7 +851,7 @@ export class CliProviderInstance implements ProviderInstance {
 
     getSessionModalState(sessionId?: string): SessionModalState {
         const adapterStatus = this.adapter.getStatus({ allowParse: true });
-        const autoApproveActive = adapterStatus.status === 'waiting_approval' && this.shouldAutoApprove();
+        const autoApproveActive = this.autoApproveEffectivelyActive(adapterStatus.status);
         const autoApproveHoldIdle = this.autoApproveBusy && adapterStatus.status === 'idle';
         const visibleStatus = autoApproveActive || autoApproveHoldIdle ? 'generating' : adapterStatus.status;
         const dirName = workingDirBasename(this.workingDir);
@@ -947,7 +954,10 @@ export class CliProviderInstance implements ProviderInstance {
         } catch {
             return null;
         }
-        if (adapterStatus.status === 'waiting_approval' && !this.shouldAutoApprove()) {
+        // A session whose auto-approve is held by manual attendance IS parked on a
+        // modal awaiting the human — autoApproveEffectivelyActive folds that in, so
+        // the mesh force-inject guard correctly treats it as modal-parked.
+        if (adapterStatus.status === 'waiting_approval' && !this.autoApproveEffectivelyActive(adapterStatus.status)) {
             return 'waiting_approval';
         }
         return null;
@@ -1402,6 +1412,26 @@ export class CliProviderInstance implements ProviderInstance {
         this.completedDebounceTimer = setTimeout(() => this.flushCompletedDebounceIfFinalized(), delayMs);
     }
 
+    // EVTTRACE (observation-only): is this a mesh worker session whose completion
+    // events must route to a coordinator? Used purely to gate trace logging so a
+    // non-mesh CLI session's completions don't add EvtTrace noise. No decision logic.
+    private isMeshWorkerSession(): boolean {
+        return !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId
+            || this.settings.meshNodeId || this.settings.launchedByCoordinator);
+    }
+
+    // EVTTRACE correlation context for this session's completion lifecycle. taskId is
+    // the primary grep anchor; instanceId is the session fallback.
+    private meshTraceCtx(event = 'agent:generating_completed'): Record<string, unknown> {
+        return {
+            taskId: this.settings.meshActiveTaskId,
+            sessionId: this.instanceId,
+            nodeId: this.settings.meshNodeId,
+            meshId: this.settings.meshNodeFor,
+            event,
+        };
+    }
+
     private flushCompletedDebounceIfFinalized(): void {
         const pending = this.completedDebouncePending;
         if (!pending) {
@@ -1424,24 +1454,55 @@ export class CliProviderInstance implements ProviderInstance {
         if (block) {
             const blockReason = block.reason;
             const waitedMs = Date.now() - pending.firstObservedAt;
-            LOG.debug('CLI', `[${this.type}] finalization block: reason=${blockReason} terminal=${block.terminal} waitedMs=${waitedMs} maxWait=${COMPLETED_FINALIZATION_MAX_WAIT_MS}`);
-            if ((block.terminal && !block.allowTimeout) || waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS) {
+            // CANON-C (completion-gate decouple): a block carrying `allowTimeout` is the
+            // transcript-evidence gate — the worker FSM has ALREADY reached idle and the only
+            // thing missing is the append-only transcript's final assistant turn (a native-source
+            // race: claude-cli owns its history externally and the file write trails the idle
+            // transition). `allowTimeout` is set ONLY on the missing_final_assistant block, and
+            // ONLY for mesh worker sessions (meshNodeFor / meshActiveTaskId / launchedByCoordinator).
+            // The coordinator's sole path to learn this session is idle is agent:generating_completed,
+            // so holding it up to COMPLETED_FINALIZATION_MAX_WAIT_MS (30s) leaves the coordinator
+            // false-generating while the worker is done. Decouple the idle NOTIFICATION from the
+            // transcript evidence: emit the completion immediately, marked weak
+            // (completionDiagnostic.blockReason=missing_final_assistant, finalAssistantPresent=false).
+            // The finalSummary is enriched on a SEPARATE path — the mesh reconcile loop reads the
+            // transcript once written and re-emits a GENUINE completion (CANON-B weak→genuine
+            // upgrade; buildPendingEventFingerprint keeps weak and genuine distinct so the enriched
+            // one still surfaces, and isFalseIdleCompletion keeps the direct dispatch active until
+            // then). All OTHER blocks (genuinely-busy adapter/partial/parsed states, transient
+            // parse_error) keep the existing terminal-hold / 30s-retry behavior unchanged.
+            const isTranscriptEvidenceGate = block.allowTimeout === true;
+            LOG.debug('CLI', `[${this.type}] finalization block: reason=${blockReason} terminal=${block.terminal} allowTimeout=${isTranscriptEvidenceGate} waitedMs=${waitedMs} maxWait=${COMPLETED_FINALIZATION_MAX_WAIT_MS}`);
+            if (!isTranscriptEvidenceGate && (block.terminal || waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS)) {
                 if (pending.loggedBlockReason !== blockReason) {
                     LOG.info('CLI', `[${this.type}] waiting to emit completed until transcript finalizes (${blockReason})`);
+                    // EVTTRACE: completion held by the finalization gate (CANON-C). Observation
+                    // only — does not change the hold decision above.
+                    if (this.isMeshWorkerSession()) {
+                        traceMeshEventDrop('completion_gate_hold', this.meshTraceCtx(), `${blockReason} waited=${waitedMs}ms`);
+                    }
                     pending.loggedBlockReason = blockReason;
                 }
                 this.scheduleCompletedDebounceFlush(COMPLETED_FINALIZATION_RETRY_MS);
                 return;
             }
+            const emittedAfterFinalizationTimeout = waitedMs >= COMPLETED_FINALIZATION_MAX_WAIT_MS;
             const completionDiagnostic = this.buildCompletedFinalizationDiagnostic({
                 blockReason,
                 latestStatus,
                 latestVisibleStatus,
                 waitedMs,
                 pending,
-                emittedAfterFinalizationTimeout: true,
+                emittedAfterFinalizationTimeout,
             });
-            LOG.warn('CLI', `[${this.type}] emitting completed event after ${waitedMs}ms without finalized assistant turn (${blockReason})`);
+            // Surface the CANON-C immediate-emit path distinctly so a delegated worker's idle
+            // notification (transcript still pending) is not mistaken for a 30s-timeout fallback.
+            (completionDiagnostic as Record<string, unknown>).decoupledImmediateEmit = isTranscriptEvidenceGate && !emittedAfterFinalizationTimeout;
+            LOG.warn('CLI', `[${this.type}] emitting completed event (${isTranscriptEvidenceGate && !emittedAfterFinalizationTimeout ? 'CANON-C decoupled-immediate, transcript pending' : `after ${waitedMs}ms`}) without finalized assistant turn (${blockReason})`);
+            // EVTTRACE: completion fired (forced past the finalization timeout / CANON-C decoupled-immediate).
+            if (this.isMeshWorkerSession()) {
+                traceMeshEventStage('fired', this.meshTraceCtx(), `forced after ${waitedMs}ms (${blockReason})`);
+            }
             this.pushEvent({
                 event: 'agent:generating_completed',
                 chatTitle: pending.chatTitle,
@@ -1467,6 +1528,10 @@ export class CliProviderInstance implements ProviderInstance {
         }
 
         LOG.info('CLI', `[${this.type}] completed in ${pending.duration}s`);
+        // EVTTRACE: completion fired (transcript finalized cleanly).
+        if (this.isMeshWorkerSession()) {
+            traceMeshEventStage('fired', this.meshTraceCtx(), `duration=${pending.duration}s`);
+        }
         this.pushEvent({
             event: 'agent:generating_completed',
             chatTitle: pending.chatTitle,
@@ -1481,6 +1546,29 @@ export class CliProviderInstance implements ProviderInstance {
     }
 
     private maybeAutoApproveStatus(adapterStatus: any, now = Date.now()): boolean {
+        // Manual-attendance suppression (provider-common): when a human is
+        // actively driving this session from the dashboard, hold auto-approve so
+        // the modal stays visible and they can pick a button / use the controlbar
+        // themselves. Return false (NOT auto-approving) so getState keeps the
+        // modal surfaced. Clear any in-progress settle gate — a genuine fire
+        // after the window lapses must re-settle from scratch — and arm a
+        // re-check for the lapse moment, because the PTY may have gone silent and
+        // would otherwise never re-drive this decision. Background mesh workers
+        // are never attended, so their delegated auto-approve is untouched.
+        if (adapterStatus?.status === 'waiting_approval'
+            && this.shouldAutoApprove()
+            && this.manualAttendance.isAttended(now)) {
+            this.lastAutoApprovalSignature = '';
+            this.pendingAutoApprovalSignature = '';
+            this.pendingAutoApprovalSince = 0;
+            this.autoApproveInactiveSince = 0;
+            if (this.autoApproveSettleTimer) clearTimeout(this.autoApproveSettleTimer);
+            this.autoApproveSettleTimer = setTimeout(() => {
+                this.autoApproveSettleTimer = null;
+                this.recheckAutoApproveSettled();
+            }, this.manualAttendance.remainingMs(now) + 20);
+            return false;
+        }
         const autoApproveActive = adapterStatus?.status === 'waiting_approval' && this.shouldAutoApprove();
         // Guard re-entry: onStatusChange/getState can observe the same modal multiple
         // times while the PTY absorbs the approval key. Without this flag, repeated
@@ -1805,7 +1893,12 @@ export class CliProviderInstance implements ProviderInstance {
                         LOG.info('CLI', `[${this.type}] short completion suppressed: missing final assistant evidence, no mesh context (source=${shortEvidenceSource})`);
                         // completedDebouncePending intentionally left null — the session is now idle
                         // with no confirmed turn, matching the startup-blip suppression semantics.
+                        // (No EvtTrace: not a mesh session, so nothing routes to a coordinator.)
                     } else {
+                        // EVTTRACE: completion fired (short-generating idle path).
+                        if (this.isMeshWorkerSession()) {
+                            traceMeshEventStage('fired', this.meshTraceCtx(), `short-generating idle (source=${shortEvidenceSource})`);
+                        }
                         this.pushEvent({
                             event: 'agent:generating_completed',
                             chatTitle,
@@ -1886,6 +1979,10 @@ export class CliProviderInstance implements ProviderInstance {
                 && !this.hasAdapterPendingResponse()
                 && !hasNonEmptyCliModalButtons(monitorParsedStatus?.activeModal ?? monitorParsedStatus?.modal)
             ) {
+                // EVTTRACE: completion fired (no-progress monitor reconciled to completion).
+                if (this.isMeshWorkerSession()) {
+                    traceMeshEventStage('fired', this.meshTraceCtx(), 'no_progress_monitor_final_summary');
+                }
                 this.pushEvent({
                     event: 'agent:generating_completed',
                     chatTitle,
@@ -2096,6 +2193,25 @@ export class CliProviderInstance implements ProviderInstance {
         return false;
     }
 
+    /** @see ProviderInstance.noteManualInteraction */
+    noteManualInteraction(now = Date.now()): void {
+        this.manualAttendance.note(now);
+    }
+
+    /**
+     * Whether auto-approve should be treated as active *right now* for display
+     * and firing decisions: the configured intent AND the user is not currently
+     * attending this session by hand. When a human is attending, auto-approve is
+     * held so the modal stays visible and they can drive it via the controlbar.
+     * Provider-agnostic — the attendance signal is the command set, never any
+     * CLI-specific modal text.
+     */
+    private autoApproveEffectivelyActive(status: string | undefined, now = Date.now()): boolean {
+        return status === 'waiting_approval'
+            && this.shouldAutoApprove()
+            && !this.manualAttendance.isAttended(now);
+    }
+
     private recordAutoApproval(modalMessage?: string, buttonLabel?: string, now = Date.now()): void {
         this.appendRuntimeSystemMessage(
             formatAutoApprovalMessage(modalMessage, buttonLabel),

package/src/providers/manual-attendance.ts

@@ -0,0 +1,85 @@
+/**
+ * ManualAttendanceTracker — provider-agnostic "is a human driving this session
+ * right now" signal, used to suppress auto-approve while the user is taking
+ * manual control of a session from the dashboard.
+ *
+ * Why this exists
+ * ---------------
+ * When `autoApprove` is on, an approval modal is auto-dismissed within a few
+ * hundred ms of appearing. For a background mesh worker that is exactly the
+ * desired delegated behavior. But for a session the user is actively watching
+ * and operating (a base-node / foreground session), the auto-fire closes the
+ * modal before the human can pick a button — and likewise fights their use of
+ * the controlbar. The fix is to give the human a short quiet window: while they
+ * are attending the session by hand, auto-approve holds; once they go idle it
+ * resumes.
+ *
+ * The tracker holds only a timestamp. The *signal* — which commands count as
+ * "a human attending" — is decided by the caller (the command handler), and is
+ * the same set for every provider: foreground tab selection (select_session /
+ * open_panel), controlbar use (invoke_provider_script / set_mode / change_model
+ * / set_thought_level), manual approval (resolve_action) and manual terminal
+ * input (pty_input). Notably NOT send_chat, which is also how a coordinator
+ * delegates a task to a worker — counting it would wrongly suppress the
+ * worker's delegated auto-approve.
+ *
+ * Because a background worker never receives any of those attending commands,
+ * it is never "attended", so its delegated auto-approve is unaffected. The
+ * mechanism is therefore provider-common AND preserves worker auto-approve
+ * without any per-provider branching.
+ */
+
+/**
+ * How long after the last manual interaction auto-approve stays suppressed.
+ *
+ * Trade-off: long enough that after foregrounding a session's tab the user has
+ * a realistic chance to act on an incoming approval (the auto-approve settle
+ * window is only ~600ms, so a human cannot out-race it), yet short enough that
+ * a session left unattended — e.g. a worker tab the user briefly peeked at —
+ * resumes auto-approving within about a minute. Re-armed on every attending
+ * command, so a user who keeps interacting keeps the window fresh.
+ */
+export const AUTO_APPROVE_MANUAL_ATTENDANCE_SUPPRESS_MS = 60_000;
+
+export class ManualAttendanceTracker {
+    private lastInteractionAt = 0;
+
+    constructor(private readonly suppressMs: number = AUTO_APPROVE_MANUAL_ATTENDANCE_SUPPRESS_MS) {}
+
+    /** Record that a human just drove this session by hand. */
+    note(now = Date.now()): void {
+        this.lastInteractionAt = now;
+    }
+
+    /** True while a manual interaction is recent enough to suppress auto-approve. */
+    isAttended(now = Date.now()): boolean {
+        return this.lastInteractionAt > 0 && (now - this.lastInteractionAt) < this.suppressMs;
+    }
+
+    /**
+     * Milliseconds remaining in the current suppression window, or 0 when not
+     * attended. Used to re-arm a re-check timer so auto-approve fires the moment
+     * the window lapses even if the PTY/agent has since gone silent.
+     */
+    remainingMs(now = Date.now()): number {
+        if (this.lastInteractionAt <= 0) return 0;
+        return Math.max(0, this.suppressMs - (now - this.lastInteractionAt));
+    }
+}
+
+/**
+ * The session-scoped commands that count as "a human is attending this session
+ * by hand". Shared so the command handler and any forward path agree on one
+ * definition. Deliberately excludes send_chat (coordinator task delegation) and
+ * pure read commands (read_chat / list_chats — passive polling, not driving).
+ */
+export const MANUAL_ATTENDANCE_COMMANDS: ReadonlySet<string> = new Set([
+    'select_session',
+    'open_panel',
+    'invoke_provider_script',
+    'set_mode',
+    'change_model',
+    'set_thought_level',
+    'resolve_action',
+    'pty_input',
+]);

package/src/providers/provider-instance.ts

@@ -226,6 +226,15 @@ export interface ProviderInstance {
     /** Refresh static provider definition/scripts without restarting the live runtime. */
     refreshProviderDefinition?(provider: ProviderModule): void;
 
+    /**
+     * Record that a human is actively attending this session by hand right now
+     * (foreground tab selection, controlbar use, manual approval, terminal
+     * 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.
+     */
+    noteManualInteraction?(now?: number): void;
+
  /** cleanup */
     dispose(): void;
 }

package/src/providers/spec/adapter.ts

@@ -51,6 +51,43 @@ export interface TerminalAdapterHandlers {
     tick?(): void;
 }
 
+/**
+ * One entry in the PTY input/output event timeline (debug-only). Captured at
+ * the single common point every spec@4 provider funnels through — this adapter
+ * — so the Spec Debug Snapshot can answer "what input / output preceded a status
+ * transition?". Observation only; nothing here feeds the FSM decision.
+ */
+export interface SpecPtyEvent {
+    /** Wall-clock ms. */
+    ts: number;
+    kind: 'spawn' | 'input' | 'output' | 'resize' | 'cursor' | 'exit';
+    /** Human-readable, control-char-escaped, length-capped preview. */
+    content: string;
+    /** Raw byte length before truncation (output/input only). */
+    bytes?: number;
+}
+
+const MAX_PTY_EVENTS = 300;
+const EVENT_CONTENT_CAP = 240;
+
+/** Escape control characters into a visible form so the timeline is readable
+ *  (CR/LF/ESC/tab become \r \n \x1b \t; other C0 controls become \xNN). */
+function escapeControl(text: string): string {
+    // eslint-disable-next-line no-control-regex
+    return String(text).replace(/[\x00-\x1f\x7f]/g, (ch) => {
+        const code = ch.charCodeAt(0);
+        if (ch === '\r') return '\\r';
+        if (ch === '\n') return '\\n';
+        if (ch === '\t') return '\\t';
+        if (code === 0x1b) return '\\x1b';
+        return '\\x' + code.toString(16).padStart(2, '0');
+    });
+}
+
+function capPreview(text: string): string {
+    return text.length > EVENT_CONTENT_CAP ? text.slice(0, EVENT_CONTENT_CAP) + `…(+${text.length - EVENT_CONTENT_CAP})` : text;
+}
+
 export class TerminalAdapter {
     private rows: number;
     private cols: number;
@@ -62,6 +99,9 @@ export class TerminalAdapter {
     private screenTimer: ReturnType<typeof setTimeout> | null = null;
     private tickTimer: ReturnType<typeof setInterval> | null = null;
     private lastScreen = '';
+    /** Debug-only ring buffer of PTY input/output/resize/cursor events. */
+    private events: SpecPtyEvent[] = [];
+    private lastCursorKey = '';
 
     constructor(
         private readonly opts: TerminalAdapterOpts,
@@ -95,10 +135,12 @@ export class TerminalAdapter {
             cols: this.cols,
             rows: this.rows,
         });
+        this.recordEvent('spawn', `${this.opts.binary} (${this.cols}x${this.rows})`);
         this.handlers.init?.({ pid: this.pty.pid });
         this.pty.onData((chunk) => this.onChunk(chunk));
         this.pty.onExit((info) => {
             this.stopTimers();
+            this.recordEvent('exit', `exitCode=${typeof info.exitCode === 'number' ? info.exitCode : 0}`);
             this.handlers.on_exit?.({ exitCode: typeof info.exitCode === 'number' ? info.exitCode : 0 });
             this.pty = null;
         });
@@ -109,6 +151,7 @@ export class TerminalAdapter {
 
     resize(cols: number, rows: number): void {
         this.cols = cols; this.rows = rows;
+        this.recordEvent('resize', `${cols}x${rows}`);
         this.pty?.resize(cols, rows);
         this.screen.resize(rows, cols);
     }
@@ -133,9 +176,24 @@ export class TerminalAdapter {
     }
 
     send_keys(text: string): void {
+        this.recordEvent('input', capPreview(escapeControl(text)), text.length);
         this.pty?.write(text);
     }
 
+    /** Debug-only: most-recent PTY input/output/resize/cursor events, oldest
+     *  first. Pure observation — never consulted by the FSM. */
+    getEventTimeline(limit = MAX_PTY_EVENTS): SpecPtyEvent[] {
+        const n = Math.max(0, Math.min(limit, this.events.length));
+        return this.events.slice(this.events.length - n);
+    }
+
+    private recordEvent(kind: SpecPtyEvent['kind'], content: string, bytes?: number): void {
+        const ev: SpecPtyEvent = { ts: Date.now(), kind, content };
+        if (typeof bytes === 'number') ev.bytes = bytes;
+        this.events.push(ev);
+        if (this.events.length > MAX_PTY_EVENTS) this.events.splice(0, this.events.length - MAX_PTY_EVENTS);
+    }
+
     kill(): void {
         this.stopTimers();
         try { this.pty?.kill(); } catch { /* ignore */ }
@@ -144,6 +202,7 @@ export class TerminalAdapter {
     }
 
     private onChunk(chunk: string): void {
+        this.recordEvent('output', capPreview(escapeControl(chunk)), chunk.length);
         try { this.handlers.on_pty_data?.(chunk); } catch { /* user side */ }
         this.screen.write(chunk);
         // Coalesce snapshot emission — rapid bursts shouldn't fire 200x.
@@ -151,6 +210,14 @@ export class TerminalAdapter {
         this.screenTimer = setTimeout(() => {
             this.screenTimer = null;
             const snap = this.computeScreen();
+            // Record cursor movement at the (debounced) screen-change boundary
+            // rather than per output chunk, so the timeline isn't flooded.
+            const cur = this.screen.getCursorPosition();
+            const curKey = `${cur.row},${cur.col}`;
+            if (curKey !== this.lastCursorKey) {
+                this.lastCursorKey = curKey;
+                this.recordEvent('cursor', `(${cur.row},${cur.col})`);
+            }
             if (snap === this.lastScreen) return;
             this.lastScreen = snap;
             try { this.handlers.on_screen_changed?.(snap); } catch { /* user side */ }

package/src/providers/spec/cli-adapter.ts

@@ -552,6 +552,10 @@ export class SpecCliAdapter implements CliAdapter {
             // answers "why did this rule fire" after the fact, unlike the live
             // `fsm` field which only reflects the current instant.
             fsmHistory: this.driver.getFsmSnapshotHistory?.() ?? null,
+            // PTY input/output/resize/cursor event timeline (debug-only) so the
+            // snapshot shows what we typed / what the PTY printed around each
+            // status transition. Null for drivers without the timeline.
+            eventTimeline: this.driver.getEventTimeline?.() ?? null,
             // Extended fields
             name: this.cliName,
             status: this.getStatus().status,
@@ -962,6 +966,8 @@ export class SpecCliAdapter implements CliAdapter {
             // v4 FSM transition snapshot history — the captured pre-transition
             // evaluation table at each transition (null for v3 specs).
             fsmHistory: this.driver.getFsmSnapshotHistory?.() ?? null,
+            // PTY input/output/resize/cursor event timeline (debug-only).
+            eventTimeline: this.driver.getEventTimeline?.() ?? null,
             messages,
             committedMessages: messages,
         };

package/src/providers/spec/evaluator.ts

@@ -55,12 +55,24 @@ export function resolveSections(
                 // Normalize anchor + context into parallel candidate lists. A
                 // scalar anchor becomes a single-entry array; a single context
                 // object applies to every entry; an array context is positional.
-                // Candidates are tried IN ORDER as independent passes: the first
-                // pattern that finds any line wins. This keeps a scalar anchor's
-                // behavior identical, and lets an array express a preferred shape
-                // (e.g. a box divider) with later entries as fallbacks (e.g. a
-                // divider-less modal anchored on its question line) — the
-                // fallback only takes over when the preferred pattern is absent.
+                // Each candidate resolves its own anchor line independently
+                // (anchor_last → that candidate's LAST matching line, else its
+                // FIRST). Across candidates we then pick the TOPMOST resolved
+                // line, because a section's anchor marks the TOP of the block:
+                // among several recognized landmark shapes, the highest one
+                // bounds the whole block. This keeps a scalar anchor identical
+                // (one candidate), preserves a genuine box-top divider (it sits
+                // ABOVE the question line, so it still wins), and — crucially —
+                // stops a stray lower landmark from clipping the block: e.g. a
+                // claude approval whose numbered choices sit ABOVE the input-box
+                // `────` rule. anchor_last on the bare-divider pattern alone
+                // would latch that LOWER chrome rule and strand the buttons
+                // above it (deriveModal sees < min_count → auto-approve never
+                // fires); preferring the topmost landmark (here the question
+                // line just above the choices, matched by the fallback context)
+                // captures the whole modal. The fallback still only contributes
+                // when its own pattern matches, so non-modal screens are
+                // unaffected.
                 const anchorPatterns = Array.isArray(sec.anchor) ? sec.anchor : [sec.anchor];
                 const sharedCtx: AnchorContext | null = Array.isArray(sec.anchor_context)
                     ? null
@@ -84,12 +96,15 @@ export function resolveSections(
                     && (c.nextRe === null || (i < total - 1 && c.nextRe.test(lines[i + 1])));
                 let idx = -1;
                 for (const c of candidates) {
+                    let candIdx = -1;
                     if (sec.anchor_last) {
-                        for (let i = total - 1; i >= 0; i--) { if (matchesCandidate(c, i)) { idx = i; break; } }
+                        for (let i = total - 1; i >= 0; i--) { if (matchesCandidate(c, i)) { candIdx = i; break; } }
                     } else {
-                        for (let i = 0; i < total; i++) { if (matchesCandidate(c, i)) { idx = i; break; } }
+                        for (let i = 0; i < total; i++) { if (matchesCandidate(c, i)) { candIdx = i; break; } }
                     }
-                    if (idx !== -1) break;
+                    // Topmost resolved anchor across candidates wins (see note
+                    // above): keep the smallest matching line index.
+                    if (candIdx !== -1 && (idx === -1 || candIdx < idx)) idx = candIdx;
                 }
                 if (idx !== -1) {
                     from = idx;