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

package/src/mesh/worktree-bootstrap-config.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from 'fs';
 import { join, resolve as pathResolve } from 'path';
 import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { promisify } from 'node:util';
 import * as yaml from 'js-yaml';
 import {
@@ -31,6 +32,15 @@ export interface WorktreeBootstrapState extends MeshAsyncJobLifecycle {
     exitCode?: number | null;
     commandsRun?: Array<Record<string, unknown>>;
     staleInputs?: string[];
+    /**
+     * M2-1: sha256 per staleInputs path recorded when the bootstrap reached
+     * 'ready'. evaluateWorktreeBootstrapState compares current file hashes
+     * against this to detect staleness (e.g. base merge changed a lockfile).
+     * Missing files hash to the literal 'absent'.
+     */
+    staleInputsDigest?: Record<string, string>;
+    /** M2-1: why an evaluated state resolved to stale (digest_mismatch | never_ran). */
+    staleReason?: string;
 }
 
 export interface WorktreeBootstrapConfigLoadResult {
@@ -151,6 +161,70 @@ export function loadMeshWorktreeBootstrapConfig(mesh: any, workspace: string): W
     return { source: 'unavailable', sourceType: 'unavailable', error: `No worktree bootstrap config found. Checked: ${MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS.join(', ')}` };
 }
 
+/** M2-1: hash staleInputs files so 'ready' can be invalidated when they change. */
+export function computeStaleInputsDigest(workspace: string, staleInputs: string[] | undefined): Record<string, string> {
+    const digest: Record<string, string> = {};
+    for (const relative of staleInputs ?? []) {
+        const filePath = join(workspace, relative);
+        try {
+            digest[relative] = createHash('sha256').update(readFileSync(filePath)).digest('hex');
+        } catch {
+            digest[relative] = 'absent';
+        }
+    }
+    return digest;
+}
+
+/**
+ * M2-1: the official bootstrap state contract. Resolves the effective state
+ * for a node workspace from config presence + the persisted last-run state +
+ * a staleInputs digest comparison. Read-only — never runs commands.
+ *
+ *   ready          — last run succeeded and staleInputs are unchanged
+ *   stale          — never ran, or a staleInputs file changed since 'ready'
+ *   running/failed — persisted lifecycle state passes through
+ *   not_configured / disabled / (invalid → failed) — from config resolution
+ */
+export function evaluateWorktreeBootstrapState(mesh: any, workspace: string, persisted?: WorktreeBootstrapState | null): WorktreeBootstrapState {
+    const loaded = loadMeshWorktreeBootstrapConfig(mesh, workspace);
+    if (!loaded.config) {
+        return { status: 'not_configured', required: false, configSource: loaded.source, configSourceType: loaded.sourceType, error: loaded.error };
+    }
+    const required = loaded.config.required !== false;
+    if (loaded.config.enabled === false || loaded.config.runOnClone === false) {
+        return { status: 'disabled', required, configSource: loaded.path || loaded.source, configSourceType: loaded.sourceType };
+    }
+    if (loaded.sourceType === 'invalid') {
+        return { status: 'failed', required, configSource: loaded.path || loaded.source, configSourceType: 'invalid', error: loaded.error };
+    }
+    if (persisted?.status === 'running') return { ...persisted, required };
+    if (persisted?.status === 'failed') return { ...persisted, required };
+    if (persisted?.status === 'ready') {
+        const staleInputs = loaded.config.staleInputs ?? persisted.staleInputs ?? [];
+        if (staleInputs.length > 0 && persisted.staleInputsDigest) {
+            const current = computeStaleInputsDigest(workspace, staleInputs);
+            const changed = staleInputs.filter(p => current[p] !== persisted.staleInputsDigest![p]);
+            if (changed.length > 0) {
+                return {
+                    ...persisted,
+                    status: 'stale',
+                    required,
+                    staleReason: `digest_mismatch: ${changed.join(', ')}`,
+                };
+            }
+        }
+        return { ...persisted, required };
+    }
+    return {
+        status: 'stale',
+        required,
+        configSource: loaded.path || loaded.source,
+        configSourceType: loaded.sourceType,
+        staleInputs: loaded.config.staleInputs,
+        staleReason: 'never_ran',
+    };
+}
+
 export async function runMeshWorktreeBootstrap(mesh: any, workspace: string): Promise<WorktreeBootstrapState> {
     const loaded = loadMeshWorktreeBootstrapConfig(mesh, workspace);
     if (!loaded.config) {
@@ -243,5 +317,10 @@ export async function runMeshWorktreeBootstrap(mesh: any, workspace: string): Pr
     state.status = 'ready';
     state.exitCode = 0;
     state.completedAt = new Date().toISOString();
+    // M2-1: record staleInputs hashes so evaluateWorktreeBootstrapState can
+    // invalidate this 'ready' when an input (e.g. lockfile) changes later.
+    if (staleInputPaths.length > 0) {
+        state.staleInputsDigest = computeStaleInputsDigest(workspace, staleInputPaths);
+    }
     return state;
 }

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

@@ -287,6 +287,8 @@ export class AcpProviderInstance implements ProviderInstance {
     private partialBlocks: ContentBlock[] = [];
     /** Tool calls collected during current turn */
     private turnToolCalls: ToolCallInfo[] = [];
+ /** Guard: prevent concurrent sendPrompt calls from racing on shared state */
+    private _sendPromptInFlight = false;
 
  // Error tracking
     private errorMessage: string | null = null;
@@ -1002,7 +1004,11 @@ export class AcpProviderInstance implements ProviderInstance {
             }
         } catch (e: any) {
             this.log.warn(`[${this.type}] session/new failed: ${e?.message}`);
-            this.currentStatus = 'idle';
+            if (!this.errorReason) {
+                this.errorReason = 'init_failed';
+                this.errorMessage = `ACP session creation failed: ${e?.message}`;
+            }
+            this.currentStatus = 'error';
         }
     }
 
@@ -1012,6 +1018,12 @@ export class AcpProviderInstance implements ProviderInstance {
             return;
         }
 
+        if (this._sendPromptInFlight) {
+            this.log.warn(`[${this.type}] sendPrompt already in flight — dropping concurrent request`);
+            throw new Error('ACP sendPrompt already in flight');
+        }
+        this._sendPromptInFlight = true;
+
  // Build prompt content
         const promptParts: any[] = contentBlocks && contentBlocks.length > 0
             ? contentBlocks.map((b) => {
@@ -1098,6 +1110,8 @@ export class AcpProviderInstance implements ProviderInstance {
             this.finalizeAssistantMessage();
             this.currentStatus = 'idle';
             this.detectStatusTransition();
+        } finally {
+            this._sendPromptInFlight = false;
         }
     }
 

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

@@ -1561,6 +1561,15 @@ export class CliProviderInstance implements ProviderInstance {
                 }
             } else if (newStatus === 'idle' && (this.lastStatus === 'generating' || this.lastStatus === 'waiting_approval')) {
                 const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1000) : 0;
+                // Guard: if generatingStartedAt===0 and no debounce pending, the generating phase
+                // was entered from 'starting' state (startup PTY noise), not from a real idle→generating
+                // task dispatch. The idle→generating handler is the only code path that sets
+                // generatingStartedAt and generatingDebouncePending, so both being absent means no
+                // task was ever dispatched. Suppress the spurious completion event and fall through
+                // to a simple lastStatus update.
+                if (!this.generatingStartedAt && !this.generatingDebouncePending) {
+                    LOG.debug('CLI', `[${this.type}] suppressed startup-phase generating→idle blip (generatingStartedAt=0, no debounce pending)`);
+                } else
                 // If debounce still pending (generating lasted < 1s), cancel both UI events.
                 // Still emit agent:generating_completed so mesh orchestration can record
                 // task_completed for direct dispatches that complete faster than the debounce.
@@ -1589,19 +1598,31 @@ export class CliProviderInstance implements ProviderInstance {
                     if (missingEvidence) {
                         LOG.warn('CLI', `[${this.type}] short completion missing final assistant evidence (source=${shortEvidenceSource})`);
                     }
-                    this.pushEvent({
-                        event: 'agent:generating_completed',
-                        chatTitle,
-                        duration: 0,
-                        timestamp: now,
-                        finalSummary: shortFinalSummary,
-                        completionDiagnostic: {
-                            reason: 'short_generating_suppressed',
-                            shortDurationMs,
-                            finalAssistantEvidenceSource: shortEvidenceSource,
-                            ...(missingEvidence ? { blockReason: 'missing_final_assistant' } : {}),
-                        },
-                    });
+                    // When evidence is missing and there is no active mesh task context, suppress
+                    // the completion event. Providers with requiresFinalAssistantBeforeIdle or
+                    // external-native history must confirm a final assistant message before the
+                    // coordinator records task_completed. Only emit here if a mesh task is active
+                    // so the coordinator can apply its own timeout/retry logic.
+                    const hasMeshContext = !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.launchedByCoordinator);
+                    if (missingEvidence && !hasMeshContext) {
+                        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.
+                    } else {
+                        this.pushEvent({
+                            event: 'agent:generating_completed',
+                            chatTitle,
+                            duration: 0,
+                            timestamp: now,
+                            finalSummary: shortFinalSummary,
+                            completionDiagnostic: {
+                                reason: 'short_generating_suppressed',
+                                shortDurationMs,
+                                finalAssistantEvidenceSource: shortEvidenceSource,
+                                ...(missingEvidence ? { blockReason: 'missing_final_assistant' } : {}),
+                            },
+                        });
+                    }
                 } else {
                     // Debounce completed, then require the rich transcript path that read_chat
                     // uses to show an idle turn whose last user-facing message is assistant.

package/src/providers/spec/driver.ts

@@ -41,7 +41,7 @@ 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';
+import type { CliSpec, Control, DelegateTrigger, SectionDef } from './types.js';
 import { LOG } from '../../logging/logger.js';
 
 export type DashboardEvent =
@@ -161,32 +161,27 @@ export function matchesCompletionIdleTargetState(
     screen: string,
     cursor?: { row: number; col: number },
 ): boolean {
-    const target = spec.states.find(state => state.id === spec.default_state)
+    // Test whether the idle/default state's when-condition actually matches
+    // the current screen, WITHOUT the default fallback. We don't want to
+    // return true just because no other state matched (which is what
+    // evaluate() does via its default_state fallback).
+    const targetId = spec.default_state ?? 'idle';
+    const target = spec.states.find(state => state.id === targetId)
         ?? spec.states.find(state => state.id === 'idle');
-    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;
-    if (!haystack) return false;
+    if (!target) return false;
+
+    // Re-use the resolved sections already computed by evaluate().
+    const sections = ev.sections;
+    const cleanScreen = screen.split('\n').map(l => l.endsWith('\r') ? l.slice(0, -1) : l).join('\n');
+
     try {
-        return new RegExp(target.when.regex, target.when.flags || 'i').test(haystack);
+        // Import the condition evaluator — but we need it as a module-level fn.
+        // Instead, call evaluate() and check: if the evaluator chose the target
+        // via an *explicit* state match (not fallback), return true.
+        // We detect a fallback via trace: the fallback emits "(no state matched".
+        const result = evaluate(spec, screen, cursor);
+        const wasFallback = result.trace.some(t => t.text.startsWith('(no state matched'));
+        return result.state.id === targetId && !wasFallback;
     } catch {
         return false;
     }
@@ -225,8 +220,16 @@ export class SpecDriver {
     private lastModalAt = 0;
     /** The modal state snapshot held across busy blips. */
     private lastModalState: SpecEvaluation['state'] | null = null;
+    /** Timestamp of when we last *exited* a modal state (approval/picker → idle
+     *  or directly via completion_idle_after).  Used to suppress completion_idle_after
+     *  firings that were queued before the modal appeared and expire immediately
+     *  after the modal is dismissed — without this the agent appears idle even
+     *  though it is still generating. */
+    private lastModalExitAt = 0;
     private completionIdleFirstSeenAt = 0;
     private completionIdleKey = '';
+    /** Previous screen lines — passed to evaluate() for `changed` condition detection. */
+    private prevScreenLines: string[] = [];
     /** 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
@@ -457,7 +460,9 @@ export class SpecDriver {
     private reevaluate(forceEmit = false): void {
         const screen = this.adapter.snapshot();
         const cursor = this.adapter.getCursorPosition();
-        const ev = evaluate(this.spec, screen, cursor);
+        const ev = evaluate(this.spec, screen, cursor, this.prevScreenLines.length > 0 ? this.prevScreenLines : undefined);
+        // Update prevScreenLines for next evaluation's `changed` condition detection.
+        this.prevScreenLines = screen.split('\n').map(l => l.endsWith('\r') ? l.slice(0, -1) : l);
 
         // Busy hold: many TUIs flicker between busy and idle every frame
         // (claude in particular — its token counter appears and disappears
@@ -499,7 +504,18 @@ export class SpecDriver {
         }
         const completionIdleRule = this.spec.debounce?.completion_idle_after;
         let busyWakeMs = busyHoldMs;
-        if (evState.id === 'busy' && completionIdleRule) {
+        // Don't fire completion_idle_after while in a modal state (approval,
+        // picker, etc.) or within a grace period after leaving one.  Two cases:
+        // 1. Modal still active: the hold window may have expired so evState
+        //    resolves to busy, but the user is still looking at the approval screen.
+        // 2. Modal just dismissed: the timer may have been queued *before* the
+        //    approval appeared and its hold expires immediately after dismissal,
+        //    causing a false-idle even though the agent is still generating.
+        const postModalGraceMs = busyHoldMs;
+        const now = Date.now();
+        const recentlyInModal = isModalState(this.currentStateId) || (this.lastModalAt > 0 && now - this.lastModalAt < postModalGraceMs);
+        const recentlyLeftModal = !recentlyInModal && this.lastModalExitAt > 0 && now - this.lastModalExitAt < postModalGraceMs;
+        if (evState.id === 'busy' && completionIdleRule && !recentlyInModal && !recentlyLeftModal) {
             const completionKey = matchesCompletionIdleRule(this.spec, ev, screen);
             if (completionKey) {
                 const now = Date.now();
@@ -551,7 +567,15 @@ export class SpecDriver {
             // 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) {
+            //
+            // Also reset on busy re-entry (transitioning back from a non-busy
+            // state). The previous generation may have set completionIdleKey
+            // and firstSeenAt; without this reset the hold window appears
+            // instantly expired on the new generation's first PTY frame that
+            // re-matches the same completion regex key, causing a false-idle
+            // before the new generation has a chance to run.
+            if (!this.completionIdleKey || this.currentStateId !== 'busy') {
+                this.completionIdleKey = '';
                 this.completionIdleFirstSeenAt = 0;
             }
             // Schedule a re-evaluation when the hold window expires. PTYs
@@ -572,7 +596,10 @@ export class SpecDriver {
                 this.lastModalAt = Date.now();
                 this.lastModalState = evState;
             } else {
-                // Leaving modal territory (going to idle) — clear the hold.
+                // Leaving modal territory (going to idle) — clear the hold,
+                // but record the exit time so completion_idle_after can be
+                // suppressed during the grace period after dismissal.
+                if (this.lastModalAt > 0) this.lastModalExitAt = Date.now();
                 this.lastModalAt = 0;
                 this.lastModalState = null;
             }
@@ -819,6 +846,7 @@ export class SpecDriver {
         const action = picker.spec.action;
         if (action.type !== 'open_picker') return;
         const hay = sectionTextFromSnapshot(this.spec, screen, action.wait_for.section) ?? screen;
+        if (!action.wait_for.regex) return;
         const re = new RegExp(action.wait_for.regex, action.wait_for.flags ?? 'i');
         if (!re.test(hay)) return;
         // Cue arrived — the dashboard now sees the picker modal via