@adhdev/daemon-core 0.9.82-rc.195 → 0.9.82-rc.197

package/src/providers/spec/driver.ts

@@ -41,6 +41,7 @@ import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
 import { evaluate, type SpecEvaluation, type TraceEntry } from './evaluator.js';
 import { loadSpec } from './loader.js';
 import type { CliSpec, Control, DelegateTrigger } from './types.js';
+import { LOG } from '../../logging/logger.js';
 
 export type DashboardEvent =
     | { kind: 'pty_data'; chunk: string }
@@ -148,10 +149,32 @@ export function matchesCompletionIdleRule(spec: CliSpec, ev: SpecEvaluation, scr
     }
 }
 
-export function matchesCompletionIdleTargetState(spec: CliSpec, ev: SpecEvaluation, screen: string): boolean {
+export function matchesCompletionIdleTargetState(
+    spec: CliSpec,
+    ev: SpecEvaluation,
+    screen: string,
+    cursor?: { row: number; col: number },
+): 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;
+    if (!target?.when) return false;
+
+    // Cursor-only idle: if the target state has cursor guards but no regex,
+    // treat a cursor match alone as sufficient.
+    const hasCursorGuard = target.when.cursor_row_min !== undefined
+        || target.when.cursor_row_max !== undefined
+        || target.when.cursor_col_min !== undefined
+        || target.when.cursor_col_max !== undefined;
+    if (hasCursorGuard && cursor !== undefined) {
+        const { cursor_row_min, cursor_row_max, cursor_col_min, cursor_col_max } = target.when;
+        const cursorOk = (cursor_row_min === undefined || cursor.row >= cursor_row_min)
+            && (cursor_row_max === undefined || cursor.row <= cursor_row_max)
+            && (cursor_col_min === undefined || cursor.col >= cursor_col_min)
+            && (cursor_col_max === undefined || cursor.col <= cursor_col_max);
+        if (cursorOk) return true;
+    }
+
+    if (!target.when.regex) return false;
     const haystack = target.when.section
         ? ev.sections.find(section => section.id === target.when.section)?.text ?? ''
         : screen;
@@ -314,6 +337,7 @@ export class SpecDriver {
         if (this.busyExpiryTimer) clearTimeout(this.busyExpiryTimer);
         this.busyExpiryTimer = setTimeout(() => {
             this.busyExpiryTimer = null;
+            LOG.debug('SpecDriver', `[${this.opts.specPath.split('/').slice(-3).join('/')}] busyExpiry fired holdMs=${holdMs}`);
             this.reevaluate();
         }, Math.max(holdMs + 50, 100));
     }
@@ -352,11 +376,18 @@ export class SpecDriver {
                 if (completionKey !== this.completionIdleKey) {
                     this.completionIdleKey = completionKey;
                     this.completionIdleFirstSeenAt = now;
+                    LOG.debug('SpecDriver', `[${this.opts.specPath.split('/').slice(-3).join('/')}] completion_idle_after matched: key="${completionKey}"`);
                 }
                 const holdMs = Math.max(0, completionIdleRule.hold_ms || 0);
+                const forceAfterMs = typeof completionIdleRule.force_after_ms === 'number'
+                    ? completionIdleRule.force_after_ms
+                    : null;
                 const ageMs = now - this.completionIdleFirstSeenAt;
                 if (ageMs >= holdMs) {
-                    if (matchesCompletionIdleTargetState(this.spec, ev, screen)) {
+                    const targetMatches = matchesCompletionIdleTargetState(this.spec, ev, screen, cursor);
+                    const forced = !targetMatches && forceAfterMs !== null && ageMs >= holdMs + forceAfterMs;
+                    LOG.debug('SpecDriver', `[${this.opts.specPath.split('/').slice(-3).join('/')}] completion_idle_after hold expired ageMs=${ageMs} targetState=${targetMatches} forced=${forced} screenTail="${screen.split(/\r?\n/).slice(-3).join('\\n').slice(-200)}"`);
+                    if (targetMatches || forced) {
                         const idle = this.spec.states.find(state => state.id === this.spec.default_state)
                             ?? this.spec.states.find(state => state.id === 'idle');
                         evState = idle

package/src/providers/spec/evaluator.ts

@@ -84,10 +84,39 @@ function resolveSections(spec: CliSpec, lines: string[]): ResolvedSection[] {
     for (const sec of spec.layout.sections) {
         let from = 0;
         let to = total;
-        if (sec.from_top !== undefined) {
+        if (sec.anchor_regex !== undefined) {
+            try {
+                const re = new RegExp(sec.anchor_regex, sec.anchor_flags ?? '');
+                const prevRe = sec.anchor_context?.prev !== undefined
+                    ? new RegExp(sec.anchor_context.prev, sec.anchor_context.prev_flags ?? '') : null;
+                const nextRe = sec.anchor_context?.next !== undefined
+                    ? new RegExp(sec.anchor_context.next, sec.anchor_context.next_flags ?? '') : null;
+                const matches = (i: number) => re.test(lines[i])
+                    && (prevRe === null || (i > 0 && prevRe.test(lines[i - 1])))
+                    && (nextRe === null || (i < total - 1 && nextRe.test(lines[i + 1])));
+                let idx = -1;
+                if (sec.anchor_last) {
+                    for (let i = total - 1; i >= 0; i--) { if (matches(i)) { idx = i; break; } }
+                } else {
+                    for (let i = 0; i < total; i++) { if (matches(i)) { idx = i; break; } }
+                }
+                if (idx !== -1) {
+                    from = idx;
+                    to = total;
+                    if (sec.until_regex !== undefined) {
+                        try {
+                            const ure = new RegExp(sec.until_regex, sec.until_regex_flags ?? '');
+                            const end = lines.findIndex((l, i) => i > idx && ure.test(l));
+                            if (end !== -1) to = end;
+                        } catch { /* bad until_regex — extend to end */ }
+                    } else if (sec.lines !== undefined) {
+                        to = Math.min(total, from + sec.lines);
+                    }
+                }
+            } catch { /* bad anchor_regex — fall through to defaults */ }
+        } else if (sec.from_top !== undefined) {
             from = resolveSize(sec.from_top, total);
-        }
-        if (sec.from_bottom !== undefined) {
+        } else if (sec.from_bottom !== undefined) {
             const sz = resolveSize(sec.from_bottom, total);
             from = total - sz;
             to = total;

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

@@ -125,6 +125,9 @@ export const SCHEMA = {
             "type": "string",
             "minLength": 1
         },
+        "requiresFinalAssistantBeforeIdle": {
+            "type": "boolean"
+        },
         "debounce": {
             "type": "object",
             "additionalProperties": false,
@@ -139,7 +142,8 @@ export const SCHEMA = {
                         "section": { "type": "string", "minLength": 1 },
                         "regex": { "type": "string", "minLength": 1 },
                         "flags": { "type": "string" },
-                        "hold_ms": { "type": "integer", "minimum": 0 }
+                        "hold_ms": { "type": "integer", "minimum": 0 },
+                        "force_after_ms": { "type": "integer", "minimum": 0 }
                     }
                 }
             }
@@ -187,7 +191,23 @@ export const SCHEMA = {
                             "type": "string"
                         }
                     }
-                }
+                },
+                "anchor_regex": { "type": "string", "minLength": 1 },
+                "anchor_flags": { "type": "string" },
+                "anchor_last": { "type": "boolean" },
+                "anchor_context": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "properties": {
+                        "prev": { "type": "string" },
+                        "prev_flags": { "type": "string" },
+                        "next": { "type": "string" },
+                        "next_flags": { "type": "string" }
+                    }
+                },
+                "lines": { "type": "integer", "minimum": 1 },
+                "until_regex": { "type": "string", "minLength": 1 },
+                "until_regex_flags": { "type": "string" }
             }
         },
         "sectionRegex": {

package/src/providers/spec/schema.json

@@ -61,6 +61,7 @@
         },
         "native_history": { "$ref": "#/definitions/nativeHistory" },
         "cli_version_range": { "type": "string", "minLength": 1 },
+        "requiresFinalAssistantBeforeIdle": { "type": "boolean" },
         "debounce": {
             "type": "object",
             "additionalProperties": false,

package/src/providers/spec/types.ts

@@ -13,6 +13,33 @@ export interface Section {
     from_top?: Size;
     from_bottom?: Size;
     until?: { section: string };
+    /** Scan the screen for the first (or last, if anchor_last=true) line
+     *  matching this regex and use that line as the section start.
+     *  Combine with `lines`, `until_regex`, or leave alone (defaults to
+     *  end-of-screen) to control how far it extends. */
+    anchor_regex?: string;
+    anchor_flags?: string;
+    /** If true, use the LAST matching line instead of the first. Useful
+     *  when the anchor pattern appears multiple times (e.g. separator
+     *  lines) and you want the one closest to the bottom. */
+    anchor_last?: boolean;
+    /** Optional neighbouring-line guards that must also match for the
+     *  anchor to be accepted. Reduces false positives when the anchor
+     *  pattern could appear elsewhere on screen (e.g. `>` in body text).
+     *  `prev` checks the line immediately above; `next` the line below. */
+    anchor_context?: {
+        prev?: string;
+        prev_flags?: string;
+        next?: string;
+        next_flags?: string;
+    };
+    /** When used with anchor_regex: take at most this many lines from the
+     *  anchor point. */
+    lines?: number;
+    /** When used with anchor_regex: extend until the first line matching
+     *  this regex (exclusive). Takes precedence over `lines`. */
+    until_regex?: string;
+    until_regex_flags?: string;
 }
 
 export interface SectionRegex {
@@ -224,6 +251,13 @@ export interface CliSpec {
     notifications?: NotificationRule[];
     delegate?: DelegateTrigger[];
     native_history?: NativeHistoryConfig;
+    /**
+     * When true, the daemon's completed-finalization gate will not emit
+     * `generating_completed` until native history confirms the last message
+     * role is `assistant`. Prevents PTY quiet-period from triggering idle
+     * before the CLI has finished writing its response to disk.
+     */
+    requiresFinalAssistantBeforeIdle?: boolean;
     /**
      * Per-spec debounce knobs. Defaults are conservative (busy_hold_ms
      * 6000) and live in SpecDriver. Spec authors override here when a
@@ -251,6 +285,11 @@ export interface CliSpec {
             regex: string;
             flags?: string;
             hold_ms: number;
+            /** If the target-state check still fails this many ms after hold_ms
+             *  expired, force an idle transition anyway. Guards against TUIs that
+             *  show transient UI (pickers, option lists) after the completion
+             *  marker appears, keeping the target-state regex from matching. */
+            force_after_ms?: number;
         };
     };
 }

package/src/providers/types/interactive-prompt.ts

@@ -349,15 +349,29 @@ export function buildClaudeInteractiveTuiAnswerSteps(
     if (question.multiSelect) throw new Error('Claude TUI multi-select prompts are not supported yet');
     const answer = response.answers[question.questionId];
     if (!answer) throw new Error(`Missing answer for ${question.questionId}`);
-    if (answer.freeformText) throw new Error('Claude TUI freeform answers are not supported yet');
-    if (answer.selectedLabels.length !== 1) throw new Error(`Expected one selected label for ${question.questionId}`);
-    const selectedIndex = question.options.findIndex(option => option.label === answer.selectedLabels[0]);
-    if (selectedIndex < 0) throw new Error(`Unknown option for ${question.questionId}: ${answer.selectedLabels[0]}`);
-    for (let i = 0; i < selectedIndex; i += 1) {
-      steps.push('\x1b[B');
+    const freeformText = answer.freeformText?.trim() ?? '';
+    if (freeformText) {
+      // Freeform: select the "Type something." option (always the last visible
+      // option before "Chat about this"), then type the text and confirm.
+      const typeOptionIndex = question.options.findIndex(o => /^Type something\.?$/i.test(o.label));
+      const optionNumber = typeOptionIndex >= 0 ? typeOptionIndex + 1 : question.options.length;
+      steps.push(String(optionNumber));
+      // Type the text character by character, then Enter to confirm.
+      for (const ch of freeformText) steps.push(ch);
+      steps.push('\r');
+    } else {
+      if (answer.selectedLabels.length !== 1) throw new Error(`Expected one selected label for ${question.questionId}`);
+      const selectedIndex = question.options.findIndex(option => option.label === answer.selectedLabels[0]);
+      if (selectedIndex < 0) throw new Error(`Unknown option for ${question.questionId}: ${answer.selectedLabels[0]}`);
+      // Use numeric key (1-based) to jump directly to the option. This avoids
+      // cursor-position drift between questions that arrow-key navigation suffers
+      // from — the TUI accepts a digit key to jump straight to that option index.
+      steps.push(String(selectedIndex + 1));
     }
-    steps.push('\r');
   }
+  // After all questions are answered, Claude TUI shows a final confirm screen
+  // ("Submit answers" / "Cancel"). The first option is pre-selected, so a
+  // single Enter confirms and submits.
   steps.push('\r');
   return steps;
 }

package/src/shared-types-extra.ts

@@ -21,7 +21,7 @@ export interface RuntimeAttachedClient {
 }
 
 /** Session status union (used by SessionEntry.status, legacy recent-launch metadata, etc.) */
-export type SessionStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
+export type SessionStatus = 'idle' | 'generating' | 'waiting_approval' | 'waiting_choice' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
 
 /** Inbox bucket categories for recent sessions */
 export type RecentSessionBucket = 'needs_attention' | 'working' | 'task_complete' | 'idle';

package/src/status/normalize.ts

@@ -5,6 +5,7 @@ export type ManagedStatus =
     | 'idle'
     | 'generating'
     | 'waiting_approval'
+    | 'waiting_choice'
     | 'error'
     | 'stopped'
     | 'starting'
@@ -151,6 +152,7 @@ export function normalizeManagedStatus(
 
     const normalized = String(status || 'idle').trim().toLowerCase();
     if (normalized === 'waiting_approval') return 'waiting_approval';
+    if (normalized === 'waiting_choice') return 'waiting_choice';
     if (WORKING_STATUSES.has(normalized)) return 'generating';
     if (normalized === 'error') return 'error';
     if (normalized === 'stopped') return 'stopped';