@adhdev/daemon-core 0.9.82-rc.207 → 0.9.82-rc.209

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

@@ -360,6 +360,8 @@ export class SpecCliAdapter implements CliAdapter {
             idleHoldPending: this.driver.hasIdleHoldPending(),
             lastBusyAt: this.driver.getLastBusyAt(),
             specPath: this.driver.getSpecPath(),
+            cursorPosition: this.driver.getCursorPosition(),
+            completionIdleDebounce: this.driver.getCompletionIdleDebounceState(),
             // Extended fields
             name: this.cliName,
             status: this.getStatus().status,

package/src/providers/spec/driver.ts

@@ -38,6 +38,7 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { TerminalAdapter, type TerminalAdapterOpts } from './adapter.js';
 import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
+import { DEFAULT_SESSION_HOST_COLS, DEFAULT_SESSION_HOST_ROWS } from '@adhdev/session-host-core';
 import { evaluate, type SpecEvaluation, type TraceEntry } from './evaluator.js';
 import { loadSpec } from './loader.js';
 import type { CliSpec, Control, DelegateTrigger } from './types.js';
@@ -142,8 +143,13 @@ export function matchesCompletionIdleRule(spec: CliSpec, ev: SpecEvaluation, scr
     if (!haystack) return null;
     try {
         const regex = new RegExp(rule.regex, rule.flags || '');
-        const match = haystack.match(regex);
-        return match?.[0] || null;
+        const matched = regex.test(haystack);
+        // Return the regex pattern as the stable key rather than the match
+        // text. The match text often contains a live counter (e.g. "Compacted
+        // for 1m 6s") that changes every second, which would reset
+        // completionIdleFirstSeenAt on every PTY frame and prevent the hold
+        // window from ever expiring.
+        return matched ? rule.regex : null;
     } catch {
         return null;
     }
@@ -211,6 +217,14 @@ export class SpecDriver {
      *  because the evaluator already moved past busy by the time the hold
      *  kicks in. */
     private lastBusyState: SpecEvaluation['state'] | null = null;
+    /** Timestamp of the last time we entered a modal state (approval/picker or
+     *  any non-busy non-idle state). Used to suppress brief busy blips that
+     *  appear while the modal is still on screen — Claude Code streams body
+     *  text that transiently shows a spinner even while an approval modal is
+     *  visible, causing rapid approval→busy→approval flicker on the dashboard. */
+    private lastModalAt = 0;
+    /** The modal state snapshot held across busy blips. */
+    private lastModalState: SpecEvaluation['state'] | null = null;
     private completionIdleFirstSeenAt = 0;
     private completionIdleKey = '';
     /** Timer that re-runs evaluate() once the hold window expires. Needed
@@ -353,6 +367,17 @@ export class SpecDriver {
     getLastBusyAt(): number { return this.lastBusyAt; }
     hasIdleHoldPending(): boolean { return this.idleHoldTimer !== null; }
     getSpecPath(): string { return this.opts.specPath; }
+    getCompletionIdleDebounceState(): { active: boolean; ageMs: number; holdMs: number; forceAfterMs: number } | null {
+        if (!this.completionIdleKey || !this.completionIdleFirstSeenAt) return null;
+        const rule = this.spec.debounce?.completion_idle_after;
+        if (!rule) return null;
+        return {
+            active: true,
+            ageMs: Date.now() - this.completionIdleFirstSeenAt,
+            holdMs: rule.hold_ms ?? 0,
+            forceAfterMs: typeof rule.force_after_ms === 'number' ? rule.force_after_ms : 0,
+        };
+    }
     getScreen(): string { return this.adapter.snapshot(); }
     getSections(): Array<{ id: string; text: string }> | null {
         try {
@@ -380,8 +405,8 @@ export class SpecDriver {
             args: [...baseArgs, ...extra],
             cwd: this.opts.workingDir,
             env: { ...(this.spec.env ?? {}), ...(this.opts.extraEnv ?? {}) },
-            cols: this.opts.cols ?? 100,
-            rows: this.opts.rows ?? 30,
+            cols: this.opts.cols ?? DEFAULT_SESSION_HOST_COLS,
+            rows: this.opts.rows ?? DEFAULT_SESSION_HOST_ROWS,
             transportFactory: this.opts.transportFactory,
         };
     }
@@ -454,6 +479,24 @@ export class SpecDriver {
                 evState = this.lastBusyState ?? evState;
             }
         }
+        // Modal hold: when in a modal state (approval, picker, etc.) a brief
+        // busy reading should not interrupt the modal. Claude Code streams
+        // body content while the approval modal is visible, causing a spinner
+        // to appear transiently — without this hold, the dashboard sees a
+        // rapid modal→busy→modal flicker and the approval UI disappears and
+        // reappears every few seconds. Apply the same busy_hold_ms window:
+        // if the modal was entered recently and the evaluator now returns
+        // busy, stay in the modal state until the hold expires or a non-busy
+        // non-modal reading arrives.
+        const idleStateId = this.spec.default_state ?? 'idle';
+        const isModalState = (id: string | null) =>
+            id !== null && id !== 'busy' && id !== idleStateId;
+        if (isModalState(this.currentStateId) && evState.id === 'busy') {
+            const ageMs = Date.now() - this.lastModalAt;
+            if (ageMs < busyHoldMs && this.lastModalState) {
+                evState = this.lastModalState;
+            }
+        }
         const completionIdleRule = this.spec.debounce?.completion_idle_after;
         let busyWakeMs = busyHoldMs;
         if (evState.id === 'busy' && completionIdleRule) {
@@ -500,6 +543,17 @@ export class SpecDriver {
             this.lastBusyState = evState;
             // Cancel any pending idle commit — non-idle reading invalidates it.
             this.cancelIdleHold();
+            // Reset completion_idle_after tracking only when the completion
+            // marker is NOT present. If the marker is on screen (key is set
+            // by the block above), clearing it here would restart the hold
+            // window on every PTY frame and the hold would never expire.
+            // Only reset when the marker disappeared (key is empty), meaning
+            // a new tool-output burst arrived that pushed the marker off
+            // screen — in that case the old firstSeenAt is stale and should
+            // restart when the marker reappears.
+            if (!this.completionIdleKey) {
+                this.completionIdleFirstSeenAt = 0;
+            }
             // Schedule a re-evaluation when the hold window expires. PTYs
             // typically stop emitting once the agent stops printing (the
             // footer settles), so without an explicit timer the driver
@@ -512,6 +566,16 @@ export class SpecDriver {
             if (evState.id !== (this.spec.default_state ?? 'idle')) {
                 this.cancelIdleHold();
             }
+            // Track the modal entry timestamp so the modal-hold above can
+            // suppress brief busy blips while the modal is still on screen.
+            if (isModalState(evState.id)) {
+                this.lastModalAt = Date.now();
+                this.lastModalState = evState;
+            } else {
+                // Leaving modal territory (going to idle) — clear the hold.
+                this.lastModalAt = 0;
+                this.lastModalState = null;
+            }
         }
 
         // Idle hold: if idle_hold_ms is set, don't commit idle immediately.
@@ -813,8 +877,8 @@ function guessExt(mime: string): string {
 
 function extractMatchedRules(ev: SpecEvaluation): string[] {
     if (!Array.isArray(ev.trace)) return [];
-    return (ev.trace as any[])
-        .filter(t => t.matched === true || t.kind === 'state_match')
-        .map(t => t.rule ?? t.stateId ?? t.id ?? String(t))
+    return ev.trace
+        .filter(t => t.kind === 'state_match')
+        .map(t => t.text)
         .filter(Boolean);
 }

package/src/providers/spec/evaluator.ts

@@ -212,18 +212,15 @@ function matchState(
     return { matched: true, title };
 }
 
-function extractModal(
-    state: SpecState,
-    sections: ResolvedSection[],
-    fullScreen: string,
-    title: string | null,
-    trace: TraceEntry[],
-): ModalSnapshot | null {
-    if (!state.modal_buttons) return null;
-    const hay = sectionText(sections, state.modal_buttons.section, fullScreen);
+function extractButtonsWithPattern(
+    rule: { pattern: string; flags?: string },
+    hay: string,
+    keyTemplate: string,
+    continuationLines: boolean,
+): { index: number; label: string; key: string }[] {
     const buttons: { index: number; label: string; key: string }[] = [];
-    if (state.modal_buttons.continuation_lines) {
-        const re = compileLinePattern(state.modal_buttons);
+    if (continuationLines) {
+        const re = compileLinePattern(rule);
         const lines = hay.split('\n');
         for (let i = 0; i < lines.length; i += 1) {
             const m = re.exec(lines[i]);
@@ -241,24 +238,57 @@ function extractModal(
                 j += 1;
             }
             if (buttons.some(b => b.index === idx)) continue;
-            const key = state.modal_buttons.key_for_index.replace(/\{index\}/g, String(idx));
+            const key = keyTemplate.replace(/\{index\}/g, String(idx));
             buttons.push({ index: idx, label, key });
             i = j - 1;
         }
     } else {
-        const re = compilePattern(state.modal_buttons);
+        const re = compilePattern(rule);
         let m: RegExpExecArray | null;
         while ((m = re.exec(hay)) !== null) {
             const idx = Number(m[1]);
             const label = String(m[2] ?? '').trim();
             if (!Number.isFinite(idx) || idx <= 0 || !label) continue;
             if (buttons.some(b => b.index === idx)) continue;
-            const key = state.modal_buttons.key_for_index.replace(/\{index\}/g, String(idx));
+            const key = keyTemplate.replace(/\{index\}/g, String(idx));
             buttons.push({ index: idx, label, key });
         }
     }
     buttons.sort((a, b) => a.index - b.index);
+    return buttons;
+}
+
+function extractModal(
+    state: SpecState,
+    sections: ResolvedSection[],
+    fullScreen: string,
+    title: string | null,
+    trace: TraceEntry[],
+): ModalSnapshot | null {
+    if (!state.modal_buttons) return null;
+    const hay = sectionText(sections, state.modal_buttons.section, fullScreen);
     const minCount = state.modal_buttons.min_count ?? 2;
+    const keyTemplate = state.modal_buttons.key_for_index;
+    const continuationLines = state.modal_buttons.continuation_lines ?? false;
+
+    // Build ordered list of pattern candidates: `patterns` array takes precedence,
+    // falling back to the single `pattern` field.
+    const candidates: Array<{ pattern: string; flags?: string }> =
+        state.modal_buttons.patterns?.length
+            ? state.modal_buttons.patterns
+            : state.modal_buttons.pattern
+              ? [{ pattern: state.modal_buttons.pattern, flags: state.modal_buttons.flags }]
+              : [];
+
+    let buttons: { index: number; label: string; key: string }[] = [];
+    for (const candidate of candidates) {
+        const result = extractButtonsWithPattern(candidate, hay, keyTemplate, continuationLines);
+        if (result.length >= minCount) {
+            buttons = result;
+            break;
+        }
+    }
+
     if (buttons.length < minCount) {
         trace.push({ kind: 'modal', text: `modal_buttons matched ${buttons.length}/${minCount} required — discarded` });
         return null;

package/src/providers/spec/loader.ts

@@ -77,7 +77,12 @@ function validateRefs(spec: CliSpec): string[] {
             if (s.modal_buttons.section && !sectionIds.has(s.modal_buttons.section)) {
                 errs.push(`states[${s.id}].modal_buttons.section "${s.modal_buttons.section}" unknown`);
             }
-            compileRegex(s.modal_buttons.pattern, s.modal_buttons.flags ?? 'm', `states[${s.id}].modal_buttons.pattern`, errs);
+            if (s.modal_buttons.pattern) {
+                compileRegex(s.modal_buttons.pattern, s.modal_buttons.flags ?? 'm', `states[${s.id}].modal_buttons.pattern`, errs);
+            }
+            for (const [pi, p] of (s.modal_buttons.patterns ?? []).entries()) {
+                compileRegex(p.pattern, p.flags ?? 'm', `states[${s.id}].modal_buttons.patterns[${pi}]`, errs);
+            }
         }
     }
 

package/src/providers/spec/schema.gen.ts

@@ -295,9 +295,12 @@ export const SCHEMA = {
                     "type": "object",
                     "additionalProperties": false,
                     "required": [
-                        "pattern",
                         "key_for_index"
                     ],
+                    "oneOf": [
+                        { "required": ["pattern"] },
+                        { "required": ["patterns"] }
+                    ],
                     "properties": {
                         "section": {
                             "type": "string"
@@ -309,6 +312,19 @@ export const SCHEMA = {
                         "flags": {
                             "type": "string"
                         },
+                        "patterns": {
+                            "type": "array",
+                            "minItems": 1,
+                            "items": {
+                                "type": "object",
+                                "additionalProperties": false,
+                                "required": ["pattern"],
+                                "properties": {
+                                    "pattern": { "type": "string", "minLength": 1 },
+                                    "flags": { "type": "string" }
+                                }
+                            }
+                        },
                         "key_for_index": {
                             "type": "string",
                             "minLength": 1

package/src/providers/spec/types.ts

@@ -71,8 +71,12 @@ export interface SectionPattern {
 
 export interface ModalButtonsRule {
     section?: string;
-    pattern: string;
+    /** Single pattern (original). Use `patterns` for multi-format fallback. */
+    pattern?: string;
     flags?: string;
+    /** Ordered list of pattern alternatives. Evaluated in order; first that
+     *  yields >= min_count buttons wins. Mutually exclusive with `pattern`. */
+    patterns?: Array<{ pattern: string; flags?: string }>;
     key_for_index: string;
     min_count?: number;
     continuation_lines?: boolean;

package/src/shared-types-extra.ts

@@ -28,7 +28,5 @@ export type RecentSessionBucket = 'needs_attention' | 'working' | 'task_complete
 
 /** Terminal backend status */
 export interface TerminalBackendStatus {
-    backend: 'xterm' | 'ghostty-vt';
-    preference: 'auto' | 'xterm' | 'ghostty-vt';
-    ghosttyAvailable: boolean;
+    backend: 'ghostty-vt';
 }

package/dist/cli-adapters/terminal-backends/xterm-backend.d.ts

@@ -1,17 +0,0 @@
-import type { TerminalViewportBackend, TerminalViewportBackendOptions } from './types.js';
-export declare class XtermTerminalBackend implements TerminalViewportBackend {
-    readonly kind: "xterm";
-    private rows;
-    private cols;
-    private terminal;
-    constructor(options: TerminalViewportBackendOptions);
-    resize(rows: number, cols: number): void;
-    write(data: string): void;
-    getText(): string;
-    getCursorPosition(): {
-        col: number;
-        row: number;
-    };
-    dispose(): void;
-    private createTerminal;
-}

package/src/cli-adapters/terminal-backends/ghostty-vt-backend.d.ts

@@ -1,16 +0,0 @@
-import type { TerminalViewportBackend, TerminalViewportBackendOptions, TerminalViewportBackendPreference } from './types.js';
-export declare function resolveTerminalBackendPreference(): TerminalViewportBackendPreference;
-export declare function isGhosttyVtBackendAvailable(): boolean;
-export declare class GhosttyVtTerminalBackend implements TerminalViewportBackend {
-    readonly kind: "ghostty-vt";
-    private terminal;
-    constructor(options: TerminalViewportBackendOptions);
-    resize(rows: number, cols: number): void;
-    write(data: string): void;
-    getText(): string;
-    getCursorPosition(): {
-        col: number;
-        row: number;
-    };
-    dispose(): void;
-}

package/src/cli-adapters/terminal-backends/xterm-backend.ts

@@ -1,104 +0,0 @@
-import type { TerminalViewportBackend, TerminalViewportBackendOptions } from './types.js';
-
-type XtermBufferLine = {
-    translateToString(trimRight?: boolean): string;
-};
-
-type XtermBuffer = {
-    length: number;
-    viewportY: number;
-    cursorX?: number;
-    cursorY?: number;
-    getLine(index: number): XtermBufferLine | undefined;
-};
-
-type XtermTerminal = {
-    buffer: { active: XtermBuffer };
-    write(data: string, callback?: () => void): void;
-    resize(cols: number, rows: number): void;
-    dispose(): void;
-};
-
-let TerminalCtor: (new (options: { cols: number; rows: number; scrollback: number }) => XtermTerminal) | null = null;
-
-function loadTerminalCtor(): new (options: { cols: number; rows: number; scrollback: number }) => XtermTerminal {
-    if (!TerminalCtor) {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const mod = require('@xterm/xterm');
-        TerminalCtor = mod.Terminal || mod.default?.Terminal || mod.default;
-        if (!TerminalCtor) {
-            throw new Error('@xterm/xterm Terminal export not found');
-        }
-    }
-    return TerminalCtor;
-}
-
-export class XtermTerminalBackend implements TerminalViewportBackend {
-    readonly kind = 'xterm' as const;
-    private rows: number;
-    private cols: number;
-    private terminal: XtermTerminal;
-
-    constructor(options: TerminalViewportBackendOptions) {
-        this.rows = Math.max(1, options.rows | 0);
-        this.cols = Math.max(1, options.cols | 0);
-        this.terminal = this.createTerminal(options.scrollback);
-    }
-
-    resize(rows: number, cols: number): void {
-        this.rows = Math.max(1, rows | 0);
-        this.cols = Math.max(1, cols | 0);
-        this.terminal.resize(this.cols, this.rows);
-    }
-
-    write(data: string): void {
-        if (!data) return;
-        this.terminal.write(data);
-    }
-
-    getText(): string {
-        const buffer = this.terminal.buffer.active;
-        const start = Math.max(0, buffer.viewportY || 0);
-        const end = Math.max(start, Math.min(buffer.length || 0, start + this.rows));
-        const lines: string[] = [];
-
-        for (let i = start; i < end; i++) {
-            const line = buffer.getLine(i);
-            // (fix) translateToString(true) strips trailing whitespace per row
-            // AND collapses cells touched only by cursor-forward (ESC[<n>C),
-            // so Claude Code's "Do you want to proceed?" arrives as
-            // "Doyouwanttoproceed?" — every downstream approval/prompt regex
-            // misses. Use false to preserve inter-word padding; we trim each
-            // row's trailing whitespace ourselves below.
-            const raw = line ? line.translateToString(false) : '';
-            lines.push(raw.replace(/\s+$/, ''));
-        }
-
-        let first = 0;
-        let last = lines.length;
-        while (first < last && !lines[first]?.trim()) first++;
-        while (last > first && !lines[last - 1]?.trim()) last--;
-        return lines.slice(first, last).join('\n');
-    }
-
-    getCursorPosition(): { col: number; row: number } {
-        const buffer = this.terminal.buffer.active;
-        return {
-            col: Math.max(0, buffer.cursorX || 0),
-            row: Math.max(0, buffer.cursorY || 0),
-        };
-    }
-
-    dispose(): void {
-        this.terminal.dispose();
-    }
-
-    private createTerminal(scrollback: number): XtermTerminal {
-        const Terminal = loadTerminalCtor();
-        return new Terminal({
-            cols: this.cols,
-            rows: this.rows,
-            scrollback,
-        });
-    }
-}