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

package/dist/providers/spec/driver.d.ts

@@ -135,7 +135,15 @@ export declare class SpecDriver {
      *  explicit wake-up there's nothing to trigger the busy → idle
      *  downshift. */
     private busyExpiryTimer;
+    /** Pending idle-commit timer. Armed when the evaluator first returns idle;
+     *  fires after idle_hold_ms if no non-idle reading has cancelled it. */
+    private idleHoldTimer;
+    /** State snapshot captured when the idle hold was armed — emitted on commit. */
+    private pendingIdleState;
     private specWatcher;
+    /** Ring buffer of committed state transitions (max 50). */
+    private stateHistory;
+    private prevStateAt;
     constructor(opts: SpecDriverOpts);
     /** Subscribe to outbound events. Returns an unsubscribe fn. */
     subscribe(listener: (ev: DashboardEvent) => void): () => void;
@@ -147,6 +155,17 @@ export declare class SpecDriver {
         col: number;
     };
     shutdown(): void;
+    private cancelIdleHold;
+    private pushHistory;
+    getStateHistory(): ReadonlyArray<{
+        stateId: string;
+        label: string;
+        at: number;
+        durationMs: number;
+    }>;
+    getLastBusyAt(): number;
+    hasIdleHoldPending(): boolean;
+    getSpecPath(): string;
     private loadSpecOrThrow;
     private buildAdapterOpts;
     private armSpecWatcher;

package/dist/providers/spec/types.d.ts

@@ -249,6 +249,12 @@ export interface CliSpec {
          *  Absorbs per-frame flicker in TUIs that stream output through
          *  the same region as the spinner. */
         busy_hold_ms?: number;
+        /** Min time the idle state must remain matched before it is
+         *  committed. Filters transient idle flickers that appear during
+         *  approval dismissals, layout reflows, or brief spinner gaps.
+         *  Any non-idle reading within the window cancels the transition.
+         *  When omitted the idle transition is immediate (legacy behaviour). */
+        idle_hold_ms?: number;
         /** Min time after start() before a send_message is allowed to
          *  reach the PTY. Banner paints + auth flows + skill listings
          *  can keep the agent unable to accept input for several seconds

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.197",
+  "version": "0.9.82-rc.198",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/router.ts

@@ -4178,6 +4178,25 @@ export class DaemonCommandRouter {
                 };
             }
 
+            case 'get_spec_debug': {
+                const sessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim()
+                    : typeof args?.sessionId === 'string' ? args.sessionId.trim() : '';
+                if (!sessionId) return { success: false, error: 'targetSessionId required' };
+                const target = this.deps.sessionRegistry.get(sessionId);
+                if (!target) return { success: false, error: 'Session not found', sessionId };
+                const adapter = this.deps.cliManager.findAdapter(target.providerType, { instanceKey: sessionId })?.adapter;
+                const snapshot = (adapter && typeof (adapter as any).getDebugSnapshot === 'function')
+                    ? (adapter as any).getDebugSnapshot()
+                    : null;
+                return {
+                    success: true,
+                    sessionId,
+                    providerType: target.providerType,
+                    isSpecProvider: snapshot !== null,
+                    snapshot,
+                };
+            }
+
             // ── User-level coordinator-prompt files (~/.adhdev/coordinator-prompts/).
             //    These live on this daemon's filesystem and never sync to the
             //    cloud / other daemons — they're per-machine config. The

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

@@ -349,6 +349,10 @@ export class SpecCliAdapter implements CliAdapter {
             exited: this.exited,
             screen,
             sections,
+            stateHistory: this.driver.getStateHistory(),
+            idleHoldPending: this.driver.hasIdleHoldPending(),
+            lastBusyAt: this.driver.getLastBusyAt(),
+            specPath: this.driver.getSpecPath(),
         };
     }
     getRuntimeMetadata(): unknown {

package/src/providers/spec/driver.ts

@@ -218,7 +218,15 @@ export class SpecDriver {
      *  explicit wake-up there's nothing to trigger the busy → idle
      *  downshift. */
     private busyExpiryTimer: ReturnType<typeof setTimeout> | null = null;
+    /** Pending idle-commit timer. Armed when the evaluator first returns idle;
+     *  fires after idle_hold_ms if no non-idle reading has cancelled it. */
+    private idleHoldTimer: ReturnType<typeof setTimeout> | null = null;
+    /** State snapshot captured when the idle hold was armed — emitted on commit. */
+    private pendingIdleState: SpecEvaluation['state'] | null = null;
     private specWatcher: fs.FSWatcher | null = null;
+    /** Ring buffer of committed state transitions (max 50). */
+    private stateHistory: Array<{ stateId: string; label: string; at: number; durationMs: number }> = [];
+    private prevStateAt = 0;
 
     constructor(private readonly opts: SpecDriverOpts) {
         this.loadSpecOrThrow();
@@ -277,10 +285,33 @@ export class SpecDriver {
     shutdown(): void {
         for (const t of this.delegateTimers.values()) clearTimeout(t);
         this.delegateTimers.clear();
+        this.cancelIdleHold();
+        if (this.busyExpiryTimer) { clearTimeout(this.busyExpiryTimer); this.busyExpiryTimer = null; }
         this.specWatcher?.close();
         this.adapter.kill();
     }
 
+    private cancelIdleHold(): void {
+        if (this.idleHoldTimer) { clearTimeout(this.idleHoldTimer); this.idleHoldTimer = null; }
+        this.pendingIdleState = null;
+    }
+
+    private pushHistory(stateId: string, label: string): void {
+        const now = Date.now();
+        const durationMs = this.prevStateAt > 0 ? now - this.prevStateAt : 0;
+        this.prevStateAt = now;
+        this.stateHistory.push({ stateId, label, at: now, durationMs });
+        if (this.stateHistory.length > 50) this.stateHistory.shift();
+    }
+
+    getStateHistory(): ReadonlyArray<{ stateId: string; label: string; at: number; durationMs: number }> {
+        return this.stateHistory;
+    }
+
+    getLastBusyAt(): number { return this.lastBusyAt; }
+    hasIdleHoldPending(): boolean { return this.idleHoldTimer !== null; }
+    getSpecPath(): string { return this.opts.specPath; }
+
     // ────────────────────────────────────────────────────────────────────
     // Loading & adapter wiring
     // ────────────────────────────────────────────────────────────────────
@@ -307,9 +338,13 @@ export class SpecDriver {
 
     private armSpecWatcher(): void {
         try {
-            this.specWatcher = fs.watch(this.opts.specPath, { persistent: false }, () => {
-                // Re-read; if it parses, replace and re-evaluate. Errors are
-                // surfaced to the dashboard so the spec author sees them live.
+            // Watch the parent directory so we catch atomic replacements
+            // (cp, install scripts) that create a new inode — a file-level
+            // watch misses those on macOS because the original inode is gone.
+            const dir = path.dirname(this.opts.specPath);
+            const base = path.basename(this.opts.specPath);
+            this.specWatcher = fs.watch(dir, { persistent: false }, (_event, filename) => {
+                if (filename && filename !== base) return;
                 const res = loadSpec(this.opts.specPath);
                 if (!res.ok) { this.emit({ kind: 'spec_error', errors: res.errors }); return; }
                 this.spec = res.spec;
@@ -411,12 +446,58 @@ export class SpecDriver {
         if (evState.id === 'busy') {
             this.lastBusyAt = Date.now();
             this.lastBusyState = evState;
+            // Cancel any pending idle commit — non-idle reading invalidates it.
+            this.cancelIdleHold();
             // 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
             // never wakes up to downshift to idle and the dashboard sees
             // status stuck at generating long after the turn ended.
             this.scheduleBusyExpiry(busyWakeMs);
+        } else if (evState.id !== this.currentStateId && evState.id !== 'busy') {
+            // Non-busy modal states (approval, picker, signing_in) also cancel
+            // any in-flight idle hold — they are higher-priority than idle.
+            if (evState.id !== (this.spec.default_state ?? 'idle')) {
+                this.cancelIdleHold();
+            }
+        }
+
+        // Idle hold: if idle_hold_ms is set, don't commit idle immediately.
+        // Arm a timer; if a non-idle reading arrives before it fires, cancel.
+        const idleHoldMs = this.spec.debounce?.idle_hold_ms ?? 0;
+        const isIdleState = evState.id === (this.spec.default_state ?? 'idle');
+        if (isIdleState && idleHoldMs > 0 && this.currentStateId !== evState.id) {
+            if (!this.idleHoldTimer) {
+                this.pendingIdleState = evState;
+                this.idleHoldTimer = setTimeout(() => {
+                    this.idleHoldTimer = null;
+                    const committed = this.pendingIdleState;
+                    this.pendingIdleState = null;
+                    if (!committed) return;
+                    LOG.debug('SpecDriver', `[${this.opts.specPath.split('/').slice(-3).join('/')}] idleHold committed after ${idleHoldMs}ms`);
+                    this.currentStateId = committed.id;
+                    this.currentEval = ev;
+                    this.pushHistory(committed.id, committed.label);
+                    this.emit({
+                        kind: 'state_changed',
+                        state: committed,
+                        modal: null,
+                        controls: ev.controls.map(c => ({ id: c.id, label: c.label, action_type: c.actionType })),
+                    });
+                    this.armOrCancelDelegateTimers(committed.id);
+                    if (this.opts.emitTrace) this.emit({ kind: 'spec_trace', entries: ev.trace });
+                }, idleHoldMs);
+            }
+            // Don't fall through to the normal changed/emit path for idle.
+            this.currentEval = ev;
+            const graceMs2 = this.spec.debounce?.startup_grace_ms ?? STARTUP_GRACE_MS;
+            if (!this.idleSeenOnce && Date.now() - this.startedAtMs >= graceMs2) {
+                this.idleSeenOnce = true;
+                const queued = this.pendingSends.splice(0);
+                for (const text of queued) setTimeout(() => this.actuallySendMessage(text), 50);
+            }
+            if (this.pickerInProgress) this.tryAdvancePicker(screen);
+            return;
         }
 
         const changed = forceEmit
@@ -449,6 +530,7 @@ export class SpecDriver {
         }
         if (changed) {
             this.currentStateId = evState.id;
+            this.pushHistory(evState.id, evState.label);
             this.emit({
                 kind: 'state_changed',
                 state: evState,

package/src/providers/spec/types.ts

@@ -268,6 +268,12 @@ export interface CliSpec {
          *  Absorbs per-frame flicker in TUIs that stream output through
          *  the same region as the spinner. */
         busy_hold_ms?: number;
+        /** Min time the idle state must remain matched before it is
+         *  committed. Filters transient idle flickers that appear during
+         *  approval dismissals, layout reflows, or brief spinner gaps.
+         *  Any non-idle reading within the window cancels the transition.
+         *  When omitted the idle transition is immediate (legacy behaviour). */
+        idle_hold_ms?: number;
         /** Min time after start() before a send_message is allowed to
          *  reach the PTY. Banner paints + auth flows + skill listings
          *  can keep the agent unable to accept input for several seconds