@adhdev/daemon-core 0.9.82-rc.327 → 0.9.82-rc.329

package/src/mesh/mesh-reconcile-loop.ts

@@ -55,7 +55,9 @@ import {
     expireStaleUnresolvedDelegateForwards,
 } from './mesh-unresolved-forward-outbox.js';
 import { readNonEmptyString } from './mesh-events-utils.js';
-import { getActiveDirectDispatches } from './mesh-work-queue.js';
+import { getActiveDirectDispatches, getQueue } from './mesh-work-queue.js';
+import { readLedgerEntries } from './mesh-ledger.js';
+import { pruneStaleDirectDispatches } from './mesh-active-work.js';
 import { reconcileDirectDispatchCompletionFromTranscript } from './mesh-events-stale.js';
 import { extractFinalAssistantSummaryEvidence } from '../providers/chat-message-normalization.js';
 import type { ChatMessage } from '../types.js';
@@ -64,6 +66,25 @@ import type { ChatMessage } from '../types.js';
 // coordinator land within at most one interval. Overridable via env for tuning.
 const DEFAULT_RECONCILE_INTERVAL_MS = 4_000;
 
+// PHASE 5 (auto-prune) conservative age gate. A direct dispatch whose node/session is
+// orphaned (no longer in the live mesh) is only auto-pruned once it is at least this old,
+// measured from its dispatch time. This protects against a node/session that is only
+// *transiently* invisible (a momentary probe failure, a daemon restart) being pruned the
+// instant it disappears. The MANUAL prune (mesh_prune_stale_direct) has no age gate — an
+// operator pruning explicitly wants the orphan gone now. Overridable via env for tuning.
+const DEFAULT_AUTO_PRUNE_MIN_AGE_MS = 24 * 60 * 60_000; // 24h
+
+function resolveAutoPruneMinAgeMs(): number {
+    const raw = readNonEmptyString(process.env.MESH_AUTO_PRUNE_MIN_AGE_MS);
+    if (raw) {
+        const parsed = Number.parseInt(raw, 10);
+        // Clamp to [1h, 30d] so a mis-set env can't make the gate pathologically aggressive
+        // (prune the moment something blinks) or effectively disable it forever.
+        if (Number.isFinite(parsed) && parsed >= 60 * 60_000 && parsed <= 30 * 24 * 60 * 60_000) return parsed;
+    }
+    return DEFAULT_AUTO_PRUNE_MIN_AGE_MS;
+}
+
 function resolveReconcileIntervalMs(): number {
     const raw = readNonEmptyString(process.env.MESH_RECONCILE_INTERVAL_MS);
     if (raw) {
@@ -310,6 +331,36 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
         }
     }
 
+    // ── PHASE 5: auto-prune orphaned direct dispatch records ───────────────────
+    // staleDirectWork (orphaned direct-dispatch rows whose node/session is no longer in the
+    // live mesh) otherwise accumulates indefinitely: a removed worktree node or a cleanly
+    // terminated session leaves its direct-dispatch row behind, stuck in a non-terminal status
+    // (e.g. generating) for days. This is NOT a false-idle bug — it is the separate problem of
+    // orphaned records that the only existing cleanup path (manual MCP mesh_prune_stale_direct)
+    // never reaches unless an operator runs it by hand.
+    //
+    // This phase runs the SAME prune core the manual tool calls (pruneStaleDirectDispatches),
+    // in execute mode, on the daemon timer. The only difference from the manual path is a
+    // conservative age gate (DEFAULT_AUTO_PRUNE_MIN_AGE_MS): a freshly-orphaned record is held
+    // back until it is provably stale, so a transient probe miss never auto-prunes live work.
+    // Every other safety rule is inherited unchanged from the core — active/pending/generating
+    // work and fresh unacknowledged dispatch failures are never pruned, ledger-only audit entries
+    // are preserved, and the prune itself is recorded with a direct_dispatch_pruned ledger entry.
+    // Idempotent: a pruned row is gone from getActiveDirectDispatches, so the next tick finds
+    // nothing to re-prune. Isolated in its own try/catch per mesh so it can never kill the tick.
+    {
+        const minAgeMs = resolveAutoPruneMinAgeMs();
+        for (const mesh of listMeshes()) {
+            const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
+            if (!daemonHostsMesh(mesh, selfIds)) continue;
+            try {
+                await autoPruneStaleDirectDispatches(components, mesh, selfIds, localDaemonId, minAgeMs);
+            } catch (e: any) {
+                LOG.warn('MeshReconcile', `Auto-prune stale direct failed for mesh ${mesh.id}: ${e?.message || e}`);
+            }
+        }
+    }
+
     // ── PHASE 2: inject into live CLI coordinators on this daemon ──────────────
     const coordinators = findLiveCoordinators(components);
     if (coordinators.length === 0) {
@@ -592,6 +643,98 @@ async function reconcileUnterminatedDirectDispatches(
     }
 }
 
+// PHASE 5 helper. Build the live-node view (mesh.nodes decorated with each node's live
+// session list) and run the shared prune core in execute mode with the conservative age gate.
+//
+// Orphan detection needs the SAME live-session evidence the manual MCP prune uses: a node still
+// in mesh.nodes whose session list no longer contains the dispatched sessionId is "session not
+// present" (prunable); a node missing from mesh.nodes entirely is "node no longer in live mesh"
+// (prunable). We obtain live sessions per node via get_status_metadata — local nodes through the
+// local commandHandler, remote nodes over P2P (dispatchMeshCommand) — exactly the transports
+// PHASE 4 already uses. A node we cannot probe (offline) keeps an empty session list; combined
+// with the age gate that only matters once the orphan is genuinely old.
+//
+// O(1) fast exit: when there are no active direct dispatches at all there is nothing to prune,
+// so we skip the (per-node) status probes entirely — an idle mesh costs one indexed query.
+async function autoPruneStaleDirectDispatches(
+    components: DaemonComponents,
+    mesh: LocalMeshEntry,
+    selfIds: string[],
+    localDaemonId: string | undefined,
+    minAgeMs: number,
+): Promise<void> {
+    const directDispatches = getActiveDirectDispatches(mesh.id);
+    if (directDispatches.length === 0) return; // nothing dispatched → nothing to prune
+
+    const liveNodes = await collectLiveNodesWithSessions(components, mesh, selfIds, localDaemonId);
+
+    const result = pruneStaleDirectDispatches({
+        meshId: mesh.id,
+        queue: getQueue(mesh.id),
+        ledgerEntries: readLedgerEntries(mesh.id, { tail: 500 }),
+        directDispatches,
+        nodes: liveNodes,
+        execute: true,
+        minAgeMs,
+        source: 'daemon_reconcile_auto_prune',
+    });
+
+    // Log only when something was actually pruned — silence on the common no-op tick.
+    if (result.prunedCount > 0) {
+        LOG.info('MeshReconcile', `Auto-pruned ${result.prunedCount} orphaned direct dispatch record(s) for mesh ${mesh.id}`);
+    }
+}
+
+// Probe each node for its live session list (get_status_metadata) and return mesh.nodes
+// decorated with a `sessions` array — the shape buildMeshActiveWork / sessionStatusFromNodes
+// consume to decide whether a dispatched session is still present. Best-effort: an unreachable
+// node yields an empty session list rather than throwing.
+async function collectLiveNodesWithSessions(
+    components: DaemonComponents,
+    mesh: LocalMeshEntry,
+    selfIds: string[],
+    localDaemonId: string | undefined,
+): Promise<any[]> {
+    const dispatchMeshCommand = components.dispatchMeshCommand;
+    return Promise.all(mesh.nodes.map(async (node) => {
+        const nodeDaemonId = readNonEmptyString(node.daemonId);
+        const isLocalNode = !nodeDaemonId
+            || selfIds.includes(nodeDaemonId)
+            || (localDaemonId !== undefined && nodeDaemonId === localDaemonId);
+        let statusResult: unknown;
+        try {
+            if (isLocalNode) {
+                statusResult = await components.commandHandler.handle('get_status_metadata', {});
+            } else if (dispatchMeshCommand) {
+                statusResult = await dispatchMeshCommand(nodeDaemonId, 'get_status_metadata', {});
+            } else {
+                return node; // remote node, no P2P transport — leave undecorated
+            }
+        } catch {
+            return node; // unreachable — leave undecorated (empty session list)
+        }
+        const sessions = extractStatusMetadataSessions(statusResult);
+        return sessions.length > 0 ? { ...node, sessions } : node;
+    }));
+}
+
+// Pull the live session list out of a get_status_metadata result, tolerating the same
+// envelope shapes unwrapReadChatPayload handles (direct CommandResult or { payload }/{ result }).
+function extractStatusMetadataSessions(raw: unknown): any[] {
+    let cursor: unknown = raw;
+    for (let depth = 0; depth < 4 && cursor && typeof cursor === 'object'; depth++) {
+        const record = cursor as Record<string, unknown>;
+        const status = record.status && typeof record.status === 'object' ? record.status as Record<string, unknown> : undefined;
+        if (status && Array.isArray(status.sessions)) return status.sessions;
+        if (Array.isArray(record.sessions)) return record.sessions;
+        if (record.payload && typeof record.payload === 'object') { cursor = record.payload; continue; }
+        if (record.result && typeof record.result === 'object') { cursor = record.result; continue; }
+        if (record.data && typeof record.data === 'object') { cursor = record.data; continue; }
+        break;
+    }
+    return [];
+}
+
 function extractPendingEvents(raw: unknown): any[] {
     if (Array.isArray(raw)) return raw;
     if (raw && typeof raw === 'object') {

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

@@ -329,8 +329,8 @@ export class AcpProviderInstance implements ProviderInstance {
         this.settings = context.settings || {};
         this.monitor.updateConfig({
             approvalAlert: this.settings.approvalAlert !== false,
-            longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-            longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180,
+            noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+            noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180,
         });
 
         await this.spawnAgent();
@@ -674,8 +674,8 @@ export class AcpProviderInstance implements ProviderInstance {
         this.settings = { ...this.settings, ...newSettings };
         this.monitor.updateConfig({
             approvalAlert: this.settings.approvalAlert !== false,
-            longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-            longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180,
+            noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+            noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180,
         });
         this.log.info(`[${this.type}] Settings updated: ${Object.keys(newSettings).join(', ')}`);
     }
@@ -1533,7 +1533,8 @@ export class AcpProviderInstance implements ProviderInstance {
 
  // Monitor check
         const agentKey = `${this.type}:acp`;
-        const monitorEvents = this.monitor.check(agentKey, newStatus, now, progressFingerprint);
+        const approvalPending = newStatus === 'waiting_approval';
+        const monitorEvents = this.monitor.check(agentKey, newStatus, now, progressFingerprint, approvalPending);
         for (const me of monitorEvents) {
             this.pushEvent({ event: me.type, agentKey: me.agentKey, message: me.message, elapsedSec: me.elapsedSec, timestamp: me.timestamp });
         }

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

@@ -183,7 +183,7 @@ function hasNonEmptyCliModalButtons(activeModal: unknown): boolean {
 }
 
 function isCliGeneratingLikeStatus(status: unknown): boolean {
-    return status === 'generating' || status === 'streaming' || status === 'long_generating' || status === 'starting';
+    return status === 'generating' || status === 'streaming' || status === 'no_progress' || status === 'long_generating' || status === 'starting';
 }
 
 export function buildCliStructuredInputPrompt(
@@ -479,8 +479,8 @@ export class CliProviderInstance implements ProviderInstance {
         this.adapter.updateRuntimeSettings?.(this.settings);
         this.monitor.updateConfig({
             approvalAlert: this.settings.approvalAlert !== false,
-            longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-            longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180,
+            noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+            noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180,
         });
 
  // Server connection
@@ -698,7 +698,7 @@ export class CliProviderInstance implements ProviderInstance {
                 && adapterStatus.status === 'idle'
                 && parsedStatus?.status === 'idle';
             let messagesToSave = parsedMessages;
-            if (!suppressStaleParsedBusyStatus && (parsedChatStatus === 'generating' || parsedChatStatus === 'long_generating')) {
+            if (!suppressStaleParsedBusyStatus && (parsedChatStatus === 'generating' || parsedChatStatus === 'no_progress' || parsedChatStatus === 'long_generating')) {
                 const lastIdx = messagesToSave.length - 1;
                 if (lastIdx >= 0 && messagesToSave[lastIdx]?.role === 'assistant') {
                     messagesToSave = messagesToSave.slice(0, lastIdx);
@@ -866,8 +866,8 @@ export class CliProviderInstance implements ProviderInstance {
         this.adapter.updateRuntimeSettings?.(this.settings);
         this.monitor.updateConfig({
             approvalAlert: this.settings.approvalAlert !== false,
-            longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-            longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180,
+            noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+            noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180,
         });
     }
 
@@ -1545,7 +1545,7 @@ export class CliProviderInstance implements ProviderInstance {
         const dirName = workingDirBasename(this.workingDir);
         const chatTitle = `${this.provider.name} · ${dirName}`;
         const partial = this.adapter.getPartialResponse();
-        // Liveness fingerprint for the long-generating watchdog. The parsed
+        // Liveness fingerprint for the no-progress watchdog. The parsed
         // assistant buffer (`partial`) alone goes static while a tool/build runs
         // — the assistant emits no tokens even though the PTY is actively
         // printing tool output — which made the watchdog false-fire a "stuck"
@@ -1764,11 +1764,15 @@ export class CliProviderInstance implements ProviderInstance {
 
  // Monitor check (cooldown based notification, IDE/CLI common)
         const agentKey = `${this.type}:cli`;
-        const monitorEvents = this.monitor.check(agentKey, newStatus, now, progressFingerprint);
+        // Approval pending is detected from the raw adapter status, not `newStatus`:
+        // auto-approve synthesizes `waiting_approval` → 'generating', which would
+        // otherwise let the no-progress watchdog accumulate the approval wait.
+        const approvalPending = rawStatus === 'waiting_approval';
+        const monitorEvents = this.monitor.check(agentKey, newStatus, now, progressFingerprint, approvalPending);
         const monitorParsedStatus: any = parsedStatus;
         for (const me of monitorEvents) {
             if (
-                me.type === 'monitor:long_generating'
+                me.type === 'monitor:no_progress'
                 && this.completionHasFinalAssistantMessage(monitorParsedStatus?.messages)
                 && !this.hasAdapterPendingResponse()
                 && !hasNonEmptyCliModalButtons(monitorParsedStatus?.activeModal ?? monitorParsedStatus?.modal)
@@ -1783,7 +1787,7 @@ export class CliProviderInstance implements ProviderInstance {
                         providerType: this.type,
                         sessionId: this.instanceId,
                         providerSessionId: this.providerSessionId || null,
-                        reconciliationReason: 'long_generating_monitor_final_summary',
+                        reconciliationReason: 'no_progress_monitor_final_summary',
                         finalAssistantPresent: true,
                     },
                 });

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

@@ -63,8 +63,8 @@ export class ExtensionProviderInstance implements ProviderInstance {
         this.settings = context.settings || {};
         this.monitor.updateConfig({
             approvalAlert: this.settings.approvalAlert !== false,
-            longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-            longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180,
+            noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+            noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180,
         });
     }
 
@@ -178,8 +178,8 @@ export class ExtensionProviderInstance implements ProviderInstance {
         this.settings = { ...this.settings, ...newSettings };
         this.monitor.updateConfig({
             approvalAlert: this.settings.approvalAlert !== false,
-            longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-            longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180,
+            noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+            noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180,
         });
     }
 
@@ -251,9 +251,10 @@ export class ExtensionProviderInstance implements ProviderInstance {
                 : 'immediate',
         });
 
- // Monitor check (cooldown based notification) — keep monitor events (long_generating etc)
+ // Monitor check (cooldown based notification) — keep monitor events (no_progress etc)
         const agentKey = `${this.type}:ext`;
-        const monitorEvents = this.monitor.check(agentKey, agentStatus, now, progressFingerprint);
+        const approvalPending = agentStatus === 'waiting_approval';
+        const monitorEvents = this.monitor.check(agentKey, agentStatus, now, progressFingerprint, approvalPending);
         for (const me of monitorEvents) {
             this.pushEvent({ event: me.type, agentKey: me.agentKey, message: me.message, elapsedSec: me.elapsedSec, timestamp: me.timestamp });
         }

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

@@ -105,8 +105,8 @@ export class IdeProviderInstance implements ProviderInstance {
  // Sync Monitor config
         this.monitor.updateConfig({
             approvalAlert: this.settings.approvalAlert !== false,
-            longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-            longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180,
+            noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+            noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180,
         });
     }
 
@@ -267,8 +267,8 @@ export class IdeProviderInstance implements ProviderInstance {
         this.settings = { ...this.settings, ...newSettings };
         this.monitor.updateConfig({
             approvalAlert: this.settings.approvalAlert !== false,
-            longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-            longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180,
+            noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+            noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180,
         });
     }
 
@@ -417,7 +417,7 @@ export class IdeProviderInstance implements ProviderInstance {
             const persistedMessages = chat.messages || messages;
             if (persistedMessages.length > 0) {
                 let toSave = persistedMessages;
-                if (chat.status === 'generating' || chat.status === 'long_generating') {
+                if (chat.status === 'generating' || chat.status === 'no_progress' || chat.status === 'long_generating') {
  // Find and exclude last assistant message
                     const lastIdx = toSave.length - 1;
                     if (lastIdx >= 0 && toSave[lastIdx].role === 'assistant') {
@@ -508,7 +508,11 @@ export class IdeProviderInstance implements ProviderInstance {
         }
 
  // Monitor check (cooldown based notification)
-        const monitorEvents = this.monitor.check(agentKey, agentStatus, now, progressFingerprint);
+        // Approval pending is detected from the raw status: auto-approve synthesizes
+        // `waiting_approval` → 'generating', so the no-progress watchdog must be told
+        // to hold its timer during the wait rather than count it as a stall.
+        const approvalPending = rawAgentStatus === 'waiting_approval';
+        const monitorEvents = this.monitor.check(agentKey, agentStatus, now, progressFingerprint, approvalPending);
         for (const me of monitorEvents) {
             this.pushEvent({ event: me.type, agentKey: me.agentKey, message: me.message, elapsedSec: me.elapsedSec, timestamp: me.timestamp });
         }

package/src/providers/read-chat-contract.ts

@@ -10,7 +10,7 @@ import {
   type ReadChatResultV2,
 } from './transcript-v2.js'
 
-const VALID_STATUSES = ['idle', 'generating', 'waiting_approval', 'error', 'panel_hidden', 'starting', 'streaming', 'long_generating'] as const
+const VALID_STATUSES = ['idle', 'generating', 'waiting_approval', 'error', 'panel_hidden', 'starting', 'streaming', 'no_progress', 'long_generating'] as const
 const VALID_ROLES = ['user', 'assistant', 'system', 'human'] as const
 const VALID_BUBBLE_STATES = ['draft', 'streaming', 'final', 'removed'] as const
 const VALID_TURN_STATUSES = ['open', 'waiting_approval', 'complete', 'error'] as const

package/src/providers/status-monitor.d.ts

@@ -3,16 +3,16 @@
  *
  * Common across all Provider categories (IDE/Extension/CLI/ACP).
  * - Approval waiting (waiting_approval) notification
- * - Notification when generating persists for extended duration
+ * - No-progress watchdog: alert when an active turn makes no progress for a while
  * - All config toggleable via Provider Settings
  */
 export interface MonitorConfig {
     /** Enable awaiting-approval notification */
     approvalAlert: boolean;
-    /** Prolonged generating notification enabled */
-    longGeneratingAlert: boolean;
-    /** Prolonged threshold (seconds) */
-    longGeneratingThresholdSec: number;
+    /** No-progress watchdog notification enabled */
+    noProgressAlert: boolean;
+    /** No-progress threshold (seconds) */
+    noProgressThresholdSec: number;
     /** Repeat notification cooldown (seconds) */
     alertCooldownSec: number;
 }
@@ -28,7 +28,7 @@ export declare class StatusMonitor {
     private config;
     private lastAlertTime;
     private generatingStartTimes;
-    private longGeneratingAlerted;
+    private noProgressAlerted;
     private lastProgressFingerprint;
     private lastProgressChangeAt;
     constructor(config?: Partial<MonitorConfig>);
@@ -40,7 +40,7 @@ export declare class StatusMonitor {
      * Check status transition → return notification event array.
      * Called from each onTick() or detectStatusTransition().
      */
-    check(agentKey: string, status: string, now: number, progressFingerprint?: string): MonitorEvent[];
+    check(agentKey: string, status: string, now: number, progressFingerprint?: string, approvalPending?: boolean): MonitorEvent[];
     /** Cooldown check — prevent sending the same notification too frequently */
     private shouldAlert;
     /** Reset (on agent terminate/restart) */

package/src/providers/status-monitor.ts

@@ -3,26 +3,26 @@
  *
  * Common across all Provider categories (IDE/Extension/CLI/ACP).
  * - Approval waiting (waiting_approval) notification
- * - Notification when generating persists for extended duration
+ * - No-progress watchdog: alert when an active turn makes no progress for a while
  * - All config toggleable via Provider Settings
  */
 
 export interface MonitorConfig {
  /** Enable awaiting-approval notification */
     approvalAlert: boolean;
- /** Prolonged generating notification enabled */
-    longGeneratingAlert: boolean;
- /** Prolonged threshold (seconds) */
-    longGeneratingThresholdSec: number;
+ /** No-progress watchdog notification enabled */
+    noProgressAlert: boolean;
+ /** No-progress threshold (seconds) */
+    noProgressThresholdSec: number;
  /** Repeat notification cooldown (seconds) */
     alertCooldownSec: number;
 }
 
 export const DEFAULT_MONITOR_CONFIG: MonitorConfig = {
     approvalAlert: true,
-    longGeneratingAlert: true,
-    longGeneratingThresholdSec: 180,   // 3 minutes
-    alertCooldownSec: 60,              // 1 minute cooldown
+    noProgressAlert: true,
+    noProgressThresholdSec: 180,   // 3 minutes
+    alertCooldownSec: 60,          // 1 minute cooldown
 };
 
 export interface MonitorEvent {
@@ -37,7 +37,7 @@ export class StatusMonitor {
     private config: MonitorConfig;
     private lastAlertTime = new Map<string, number>();
     private generatingStartTimes = new Map<string, number>();
-    private longGeneratingAlerted = new Map<string, boolean>();
+    private noProgressAlerted = new Map<string, boolean>();
     private lastProgressFingerprint = new Map<string, string>();
     private lastProgressChangeAt = new Map<string, number>();
 
@@ -59,7 +59,7 @@ export class StatusMonitor {
   * Check status transition → return notification event array.
   * Called from each onTick() or detectStatusTransition().
   */
-    check(agentKey: string, status: string, now: number, progressFingerprint?: string): MonitorEvent[] {
+    check(agentKey: string, status: string, now: number, progressFingerprint?: string, approvalPending?: boolean): MonitorEvent[] {
         const events: MonitorEvent[] = [];
 
  // 1. Approval waiting notification
@@ -74,11 +74,26 @@ export class StatusMonitor {
             }
         }
 
- // 2. Detect prolonged generating (identical for IDE/Extension/CLI/ACP)
+ // 2. No-progress watchdog (identical for IDE/Extension/CLI/ACP)
         if (status === 'generating' || status === 'streaming') {
+            // While an approval modal is pending we must NOT count the wait as
+            // no-progress. The assistant emits no tokens and the screen is frozen
+            // on the modal, so the progress fingerprint goes static — but this is
+            // a user action wait, not a freeze. Some callers (CLI/IDE auto-approve)
+            // also synthesize the reported status to 'generating' during the wait,
+            // so the plain `waiting_approval` branch below cannot catch it. Hold the
+            // progress anchor at `now` so the elapsed timer restarts the moment the
+            // approval clears and real generating resumes.
+            if (approvalPending) {
+                this.generatingStartTimes.set(agentKey, now);
+                this.lastProgressFingerprint.set(agentKey, progressFingerprint ?? '');
+                this.lastProgressChangeAt.set(agentKey, now);
+                this.noProgressAlerted.set(agentKey, false);
+                return events;
+            }
             if (!this.generatingStartTimes.has(agentKey)) {
                 this.generatingStartTimes.set(agentKey, now);
-                this.longGeneratingAlerted.set(agentKey, false);
+                this.noProgressAlerted.set(agentKey, false);
                 const initialFingerprint = progressFingerprint ?? '';
                 this.lastProgressFingerprint.set(agentKey, initialFingerprint);
                 this.lastProgressChangeAt.set(agentKey, now);
@@ -88,17 +103,17 @@ export class StatusMonitor {
             if (previousFingerprint !== currentFingerprint) {
                 this.lastProgressFingerprint.set(agentKey, currentFingerprint);
                 this.lastProgressChangeAt.set(agentKey, now);
-                this.longGeneratingAlerted.set(agentKey, false);
+                this.noProgressAlerted.set(agentKey, false);
             }
-            if (this.config.longGeneratingAlert) {
+            if (this.config.noProgressAlert) {
                 const progressChangedAt = this.lastProgressChangeAt.get(agentKey) || this.generatingStartTimes.get(agentKey)!;
                 const elapsedSec = Math.round((now - progressChangedAt) / 1000);
-                const alreadyAlerted = this.longGeneratingAlerted.get(agentKey) === true;
-                if (elapsedSec > this.config.longGeneratingThresholdSec && !alreadyAlerted) {
-                    if (this.shouldAlert(agentKey + ':long_gen', now)) {
-                        this.longGeneratingAlerted.set(agentKey, true);
+                const alreadyAlerted = this.noProgressAlerted.get(agentKey) === true;
+                if (elapsedSec > this.config.noProgressThresholdSec && !alreadyAlerted) {
+                    if (this.shouldAlert(agentKey + ':no_progress', now)) {
+                        this.noProgressAlerted.set(agentKey, true);
                         events.push({
-                            type: 'monitor:long_generating',
+                            type: 'monitor:no_progress',
                             agentKey,
                             elapsedSec,
                             timestamp: now,
@@ -110,7 +125,7 @@ export class StatusMonitor {
         } else {
  // Reset timer when switching to non-generating status
             this.generatingStartTimes.delete(agentKey);
-            this.longGeneratingAlerted.delete(agentKey);
+            this.noProgressAlerted.delete(agentKey);
             this.lastProgressFingerprint.delete(agentKey);
             this.lastProgressChangeAt.delete(agentKey);
         }
@@ -132,7 +147,7 @@ export class StatusMonitor {
     reset(agentKey?: string): void {
         if (agentKey) {
             this.generatingStartTimes.delete(agentKey);
-            this.longGeneratingAlerted.delete(agentKey);
+            this.noProgressAlerted.delete(agentKey);
             this.lastProgressFingerprint.delete(agentKey);
             this.lastProgressChangeAt.delete(agentKey);
  // Delete all cooldowns for this key
@@ -141,7 +156,7 @@ export class StatusMonitor {
             }
         } else {
             this.generatingStartTimes.clear();
-            this.longGeneratingAlerted.clear();
+            this.noProgressAlerted.clear();
             this.lastProgressFingerprint.clear();
             this.lastProgressChangeAt.clear();
             this.lastAlertTime.clear();

package/src/shared-types.ts

@@ -740,6 +740,9 @@ export type DaemonStatusEventName =
     | 'agent:waiting_approval'
     | 'agent:generating_completed'
     | 'agent:stopped'
+    | 'monitor:no_progress'
+    // Legacy alias for 'monitor:no_progress' — kept so older daemons that still
+    // emit it remain type-compatible with consumers during rollout.
     | 'monitor:long_generating';
 
 /** Minimal daemon-originated event payload relayed through the server. */

package/src/status/reporter.ts

@@ -120,7 +120,7 @@ export class DaemonStatusReporter {
             case 'agent:waiting_approval':
             case 'agent:generating_completed':
             case 'agent:stopped':
-            case 'monitor:long_generating':
+            case 'monitor:no_progress':
                 return value;
             default:
                 return null;