@adhdev/daemon-core 0.9.82-rc.187 → 0.9.82-rc.189

package/src/providers/spec/driver.ts

@@ -132,6 +132,37 @@ export function resolveSubmitDelayMs(specBeforeSubmit: number | undefined, text:
     return Math.max(spec, SUBMIT_DELAY_FLOOR_MS + linesBonus);
 }
 
+export function matchesCompletionIdleRule(spec: CliSpec, ev: SpecEvaluation, screen: string): string | null {
+    const rule = spec.debounce?.completion_idle_after;
+    if (!rule?.regex) return null;
+    const haystack = rule.section
+        ? ev.sections.find(section => section.id === rule.section)?.text ?? ''
+        : screen;
+    if (!haystack) return null;
+    try {
+        const regex = new RegExp(rule.regex, rule.flags || '');
+        const match = haystack.match(regex);
+        return match?.[0] || null;
+    } catch {
+        return null;
+    }
+}
+
+export function matchesCompletionIdleTargetState(spec: CliSpec, ev: SpecEvaluation, screen: string): boolean {
+    const target = spec.states.find(state => state.id === spec.default_state)
+        ?? spec.states.find(state => state.id === 'idle');
+    if (!target?.when?.regex) return false;
+    const haystack = target.when.section
+        ? ev.sections.find(section => section.id === target.when.section)?.text ?? ''
+        : screen;
+    if (!haystack) return false;
+    try {
+        return new RegExp(target.when.regex, target.when.flags || 'i').test(haystack);
+    } catch {
+        return false;
+    }
+}
+
 export class SpecDriver {
     private spec!: CliSpec;
     private adapter!: TerminalAdapter;
@@ -157,6 +188,8 @@ export class SpecDriver {
      *  because the evaluator already moved past busy by the time the hold
      *  kicks in. */
     private lastBusyState: SpecEvaluation['state'] | null = null;
+    private completionIdleFirstSeenAt = 0;
+    private completionIdleKey = '';
     /** Timer that re-runs evaluate() once the hold window expires. Needed
      *  because the PTY stops emitting once the agent finishes; without an
      *  explicit wake-up there's nothing to trigger the busy → idle
@@ -214,6 +247,10 @@ export class SpecDriver {
         return this.adapter.snapshot();
     }
 
+    getCursorPosition(): { row: number; col: number } {
+        return this.adapter.getCursorPosition();
+    }
+
     shutdown(): void {
         for (const t of this.delegateTimers.values()) clearTimeout(t);
         this.delegateTimers.clear();
@@ -283,7 +320,8 @@ export class SpecDriver {
 
     private reevaluate(forceEmit = false): void {
         const screen = this.adapter.snapshot();
-        const ev = evaluate(this.spec, screen);
+        const cursor = this.adapter.getCursorPosition();
+        const ev = evaluate(this.spec, screen, cursor);
 
         // Busy hold: many TUIs flicker between busy and idle every frame
         // (claude in particular — its token counter appears and disappears
@@ -305,6 +343,40 @@ export class SpecDriver {
                 evState = this.lastBusyState ?? evState;
             }
         }
+        const completionIdleRule = this.spec.debounce?.completion_idle_after;
+        let busyWakeMs = busyHoldMs;
+        if (evState.id === 'busy' && completionIdleRule) {
+            const completionKey = matchesCompletionIdleRule(this.spec, ev, screen);
+            if (completionKey) {
+                const now = Date.now();
+                if (completionKey !== this.completionIdleKey) {
+                    this.completionIdleKey = completionKey;
+                    this.completionIdleFirstSeenAt = now;
+                }
+                const holdMs = Math.max(0, completionIdleRule.hold_ms || 0);
+                const ageMs = now - this.completionIdleFirstSeenAt;
+                if (ageMs >= holdMs) {
+                    if (matchesCompletionIdleTargetState(this.spec, ev, screen)) {
+                        const idle = this.spec.states.find(state => state.id === this.spec.default_state)
+                            ?? this.spec.states.find(state => state.id === 'idle');
+                        evState = idle
+                            ? { id: idle.id, label: idle.label, title: null }
+                            : { id: 'idle', label: 'Ready', title: null };
+                    } else {
+                        busyWakeMs = Math.min(busyWakeMs, 1000);
+                    }
+                } else {
+                    busyWakeMs = Math.min(busyWakeMs, Math.max(holdMs - ageMs, 0));
+                }
+            } else {
+                this.completionIdleKey = '';
+                this.completionIdleFirstSeenAt = 0;
+            }
+        } else if (evState.id !== 'busy') {
+            this.completionIdleKey = '';
+            this.completionIdleFirstSeenAt = 0;
+        }
+
         if (evState.id === 'busy') {
             this.lastBusyAt = Date.now();
             this.lastBusyState = evState;
@@ -313,7 +385,7 @@ export class SpecDriver {
             // footer settles), so without an explicit timer the driver
             // never wakes up to downshift to idle and the dashboard sees
             // status stuck at generating long after the turn ended.
-            this.scheduleBusyExpiry(busyHoldMs);
+            this.scheduleBusyExpiry(busyWakeMs);
         }
 
         const changed = forceEmit

package/src/providers/spec/evaluator.ts

@@ -139,6 +139,7 @@ function matchState(
     sections: ResolvedSection[],
     fullScreen: string,
     trace: TraceEntry[],
+    cursor?: { row: number; col: number },
 ): { matched: boolean; title: string | null } {
     const haystack = sectionText(sections, state.when.section, fullScreen);
     const re = compileRegex(state.when);
@@ -146,7 +147,31 @@ function matchState(
         trace.push({ kind: 'state_skip', text: `state[${state.id}] when ${state.when.section ?? '*'}~/${state.when.regex}/ no match` });
         return { matched: false, title: null };
     }
-    trace.push({ kind: 'state_match', text: `state[${state.id}] matched via ${state.when.section ?? '*'}~/${state.when.regex}/` });
+
+    // Cursor-position guards: check row/col bounds when the state declares them.
+    // Guards are skipped entirely when the caller did not supply a cursor position
+    // (cursor === undefined) so existing pure-text evaluation is unaffected.
+    if (cursor !== undefined) {
+        const w = state.when;
+        if (w.cursor_row_min !== undefined && cursor.row < w.cursor_row_min) {
+            trace.push({ kind: 'state_skip', text: `state[${state.id}] cursor row ${cursor.row} < cursor_row_min ${w.cursor_row_min}` });
+            return { matched: false, title: null };
+        }
+        if (w.cursor_row_max !== undefined && cursor.row > w.cursor_row_max) {
+            trace.push({ kind: 'state_skip', text: `state[${state.id}] cursor row ${cursor.row} > cursor_row_max ${w.cursor_row_max}` });
+            return { matched: false, title: null };
+        }
+        if (w.cursor_col_min !== undefined && cursor.col < w.cursor_col_min) {
+            trace.push({ kind: 'state_skip', text: `state[${state.id}] cursor col ${cursor.col} < cursor_col_min ${w.cursor_col_min}` });
+            return { matched: false, title: null };
+        }
+        if (w.cursor_col_max !== undefined && cursor.col > w.cursor_col_max) {
+            trace.push({ kind: 'state_skip', text: `state[${state.id}] cursor col ${cursor.col} > cursor_col_max ${w.cursor_col_max}` });
+            return { matched: false, title: null };
+        }
+    }
+
+    trace.push({ kind: 'state_match', text: `state[${state.id}] matched via ${state.when.section ?? '*'}~/${state.when.regex}/${cursor !== undefined ? ` cursor=(${cursor.row},${cursor.col})` : ''}` });
 
     let title: string | null = null;
     if (state.extract_title) {
@@ -217,19 +242,30 @@ function extractModal(
 // Public evaluator
 // ────────────────────────────────────────────────────────────────────────────
 
-export function evaluate(spec: CliSpec, screenText: string): SpecEvaluation {
+export function evaluate(
+    spec: CliSpec,
+    screenText: string,
+    /** Optional cursor position (0-based row and col). When supplied, states
+     *  with cursor_row_min/max or cursor_col_min/max predicates are filtered.
+     *  When omitted, cursor predicates are ignored and evaluation is text-only
+     *  (backward-compatible with all existing specs and call sites). */
+    cursor?: { row: number; col: number },
+): SpecEvaluation {
     const trace: TraceEntry[] = [];
     const lines = screenText.split('\n');
     const sections = resolveSections(spec, lines);
     for (const s of sections) {
         trace.push({ kind: 'section', text: `section[${s.id}] lines [${s.fromLine}, ${s.toLine}) (${s.toLine - s.fromLine} lines)` });
     }
+    if (cursor !== undefined) {
+        trace.push({ kind: 'section', text: `cursor (${cursor.row}, ${cursor.col})` });
+    }
 
     let activeState: { id: string; label: string; title: string | null } | null = null;
     let modal: ModalSnapshot | null = null;
 
     for (const st of spec.states) {
-        const { matched, title } = matchState(st, sections, screenText, trace);
+        const { matched, title } = matchState(st, sections, screenText, trace, cursor);
         if (!matched) continue;
         const extractedModal = extractModal(st, sections, screenText, title, trace);
         // If the state declares modal_buttons but extraction failed (button

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

@@ -130,7 +130,18 @@ export const SCHEMA = {
             "additionalProperties": false,
             "properties": {
                 "busy_hold_ms": { "type": "integer", "minimum": 0 },
-                "startup_grace_ms": { "type": "integer", "minimum": 0 }
+                "startup_grace_ms": { "type": "integer", "minimum": 0 },
+                "completion_idle_after": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": ["regex", "hold_ms"],
+                    "properties": {
+                        "section": { "type": "string", "minLength": 1 },
+                        "regex": { "type": "string", "minLength": 1 },
+                        "flags": { "type": "string" },
+                        "hold_ms": { "type": "integer", "minimum": 0 }
+                    }
+                }
             }
         }
     },
@@ -196,6 +207,22 @@ export const SCHEMA = {
                 "flags": {
                     "type": "string",
                     "default": "i"
+                },
+                "cursor_row_min": {
+                    "type": "integer",
+                    "minimum": 0
+                },
+                "cursor_row_max": {
+                    "type": "integer",
+                    "minimum": 0
+                },
+                "cursor_col_min": {
+                    "type": "integer",
+                    "minimum": 0
+                },
+                "cursor_col_max": {
+                    "type": "integer",
+                    "minimum": 0
                 }
             }
         },

package/src/providers/spec/schema.json

@@ -59,7 +59,27 @@
             "default": [],
             "items": { "$ref": "#/definitions/delegateTrigger" }
         },
-        "native_history": { "$ref": "#/definitions/nativeHistory" }
+        "native_history": { "$ref": "#/definitions/nativeHistory" },
+        "cli_version_range": { "type": "string", "minLength": 1 },
+        "debounce": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "busy_hold_ms": { "type": "integer", "minimum": 0 },
+                "startup_grace_ms": { "type": "integer", "minimum": 0 },
+                "completion_idle_after": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": ["regex", "hold_ms"],
+                    "properties": {
+                        "section": { "type": "string", "minLength": 1 },
+                        "regex": { "type": "string", "minLength": 1 },
+                        "flags": { "type": "string" },
+                        "hold_ms": { "type": "integer", "minimum": 0 }
+                    }
+                }
+            }
+        }
     },
     "definitions": {
         "size": {
@@ -91,7 +111,11 @@
             "properties": {
                 "section": { "type": "string" },
                 "regex": { "type": "string", "minLength": 1 },
-                "flags": { "type": "string", "default": "i" }
+                "flags": { "type": "string", "default": "i" },
+                "cursor_row_min": { "type": "integer", "minimum": 0 },
+                "cursor_row_max": { "type": "integer", "minimum": 0 },
+                "cursor_col_min": { "type": "integer", "minimum": 0 },
+                "cursor_col_max": { "type": "integer", "minimum": 0 }
             }
         },
         "sectionPattern": {

package/src/providers/spec/types.ts

@@ -19,6 +19,21 @@ export interface SectionRegex {
     section?: string;
     regex: string;
     flags?: string;
+    /**
+     * Optional cursor-position guards. When present, the state is only
+     * considered matched if the terminal cursor row/column satisfies the
+     * bounds (0-based, inclusive). Missing or undefined means "no constraint".
+     *
+     * Use case: distinguish modal zone from body zone for TUIs that use
+     * cursor position rather than distinct text to locate the active prompt
+     * (e.g. Antigravity cursor lands in modal_zone rows 8-31 when approval
+     * is visible, never in body rows 0-7). Without this guard, body text
+     * containing "Do you want to proceed?" could false-positive a modal match.
+     */
+    cursor_row_min?: number;
+    cursor_row_max?: number;
+    cursor_col_min?: number;
+    cursor_col_max?: number;
 }
 
 export interface SectionPattern {
@@ -227,5 +242,15 @@ export interface CliSpec {
          *  once the window passes and an idle state has actually been
          *  observed. */
         startup_grace_ms?: number;
+        /** Treat a provider-specific completion marker as idle after it has
+         *  remained visible for hold_ms. This handles TUIs that leave their
+         *  last spinner glyph next to a completed timer, causing the normal
+         *  busy regex to keep matching after the turn is done. */
+        completion_idle_after?: {
+            section?: string;
+            regex: string;
+            flags?: string;
+            hold_ms: number;
+        };
     };
 }

package/src/repo-mesh-types.ts

@@ -359,11 +359,17 @@ export interface RepoMeshSessionStatus {
     sessionId: string;
     providerType?: string;
     state?: string;
+    chatStatus?: string;
     lifecycle?: 'starting' | 'running' | 'stopping' | 'stopped' | 'failed' | 'interrupted';
     surfaceKind?: 'live_runtime' | 'recovery_snapshot' | 'inactive_record';
     recoveryState?: string | null;
     workspace?: string | null;
     title?: string | null;
+    role?: string | null;
+    isSelfCoordinator?: boolean;
+    statusNote?: string | null;
+    createdAt?: string | null;
+    startedAt?: string | null;
     lastActivityAt?: string | null;
     isCached?: boolean;
 }