@adhdev/daemon-core 0.9.82-rc.49 → 0.9.82-rc.490

package/src/providers/spec/pre-launch-trust.ts

@@ -0,0 +1,104 @@
+/**
+ * pre_launch_trust — generic, declarative "trust this folder before spawn"
+ * step for spec-backed CLI providers.
+ *
+ * Some agent CLIs (the canonical case is antigravity's `agy`) gate the first
+ * run in any new folder behind an interactive "Do you trust the files in this
+ * folder?" prompt. Under the v4 FSM spec path the daemon spawns the binary
+ * directly in the worktree (`cwd = workingDir`), so every fresh worktree —
+ * every delegated mesh task running in its own clone — hits that prompt and
+ * stalls until something clicks through it. (The legacy bash-wrapper symlink
+ * trick in provider.v1.json's `spawn` block is not used by SpecCliAdapter.)
+ *
+ * These CLIs persist their trusted folders in a JSON settings file as a string
+ * array. If we add the workspace path to that array *before* spawning, the
+ * prompt never appears. That is the most robust fix: the agent runs trusted
+ * from the first frame instead of relying on the FSM to detect and auto-click
+ * a modal whose wording or position could drift.
+ *
+ * The mechanism is intentionally data-driven and CLI-agnostic. A spec declares
+ * the settings file and the array key; the engine does the rest. CLIs that do
+ * not have a folder-trust gate simply omit `pre_launch_trust` and this code
+ * never runs for them — so other providers (claude/codex/hermes) are untouched.
+ */
+'use strict';
+
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import type { PreLaunchTrust } from './fsm-types.js';
+import { LOG } from '../../logging/logger.js';
+
+/** Expand a leading `~` to the user's home directory. */
+function expandHome(p: string): string {
+    if (p === '~') return os.homedir();
+    if (p.startsWith('~/')) return path.join(os.homedir(), p.slice(2));
+    return p;
+}
+
+/**
+ * Resolve the canonical, real (symlink-followed) absolute form of the
+ * workspace path. Trust files store realpaths, and matching has to be exact, so
+ * we normalise the same way the CLI does. Falls back to the raw path if the
+ * directory can't be stat'd (e.g. it does not exist yet).
+ */
+function realWorkspacePath(workingDir: string): string {
+    try {
+        return fs.realpathSync(workingDir);
+    } catch {
+        return path.resolve(workingDir);
+    }
+}
+
+/**
+ * Idempotently add `workingDir` (realpath) to the trusted-folders array named
+ * by `trust.key` inside the JSON settings file at `trust.settings_path`.
+ *
+ * - Creates the file (and parent dir) if missing.
+ * - Preserves all other settings; only the trust array is touched.
+ * - No-ops if the path is already present.
+ * - Best-effort: any failure is logged and swallowed. A failed pre-trust must
+ *   not block the launch — the worst case is the old behavior (the FSM still
+ *   detects the trust modal as an approval state), not a crash.
+ *
+ * Returns the path that was added (realpath), or null if nothing changed /
+ * an error occurred — purely so callers/tests can assert the effect.
+ */
+export function applyPreLaunchTrust(trust: PreLaunchTrust, workingDir: string): string | null {
+    const settingsPath = expandHome(trust.settings_path);
+    const key = trust.key;
+    const real = realWorkspacePath(workingDir);
+    try {
+        let parsed: Record<string, unknown> = {};
+        if (fs.existsSync(settingsPath)) {
+            const text = fs.readFileSync(settingsPath, 'utf8');
+            if (text.trim().length > 0) {
+                const json = JSON.parse(text);
+                if (json && typeof json === 'object' && !Array.isArray(json)) {
+                    parsed = json as Record<string, unknown>;
+                }
+            }
+        }
+
+        const existing = parsed[key];
+        const list: string[] = Array.isArray(existing)
+            ? existing.filter((v): v is string => typeof v === 'string')
+            : [];
+
+        if (list.includes(real)) {
+            LOG.debug('pre-launch-trust', `[${trust.settings_path}] ${real} already trusted — no change`);
+            return null;
+        }
+
+        list.push(real);
+        parsed[key] = list;
+
+        fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+        fs.writeFileSync(settingsPath, `${JSON.stringify(parsed, null, 2)}\n`, 'utf8');
+        LOG.info('pre-launch-trust', `pre-trusted workspace in ${trust.settings_path} (key="${key}")`);
+        return real;
+    } catch (err) {
+        LOG.warn('pre-launch-trust', `failed to pre-trust workspace in ${trust.settings_path}: ${(err as Error).message}`);
+        return null;
+    }
+}

package/src/providers/spec/route.ts

@@ -0,0 +1,51 @@
+/**
+ * Routing — given a CLI provider definition, decide whether to drive
+ * it via the legacy ProviderCliAdapter (scripts/v1/*.js parsers +
+ * cli-state-engine) or via SpecCliAdapter (single spec.json +
+ * SpecDriver). The gate is the presence of spec.json in the resolved
+ * provider directory.
+ *
+ * This is the only place in the daemon that knows which path a given
+ * provider takes. Providers can be migrated one at a time by adding
+ * a spec.json next to their scripts/v1/, then deleting scripts/v1/.
+ */
+'use strict';
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ProviderCliAdapter } from '../../cli-adapters/provider-cli-adapter.js';
+import type { CliProviderModule } from '../../cli-adapters/provider-cli-adapter.js';
+import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
+import type { CliAdapter } from '../../cli-adapter-types.js';
+import { SpecCliAdapter } from './cli-adapter.js';
+import { LOG } from '../../logging/logger.js';
+
+export function createCliAdapter(
+    provider: CliProviderModule,
+    workingDir: string,
+    cliArgs: string[],
+    extraEnv: Record<string, string>,
+    transportFactory?: PtyTransportFactory,
+): CliAdapter {
+    // Prefer the path provider-loader already resolved (it walks the
+    // compatibility[i].spec → specs/default.json → spec.json chain).
+    // Fall back to the legacy spec.json-in-provider-dir lookup if the
+    // loader didn't attach one — keeps out-of-tree providers that still
+    // use the original layout working.
+    const resolvedSpecPath = (provider as unknown as { _resolvedSpecPath?: string })._resolvedSpecPath;
+    const dir = (provider as unknown as { _resolvedProviderDir?: string })._resolvedProviderDir;
+    let specPath: string | undefined = resolvedSpecPath && fs.existsSync(resolvedSpecPath) ? resolvedSpecPath : undefined;
+    if (!specPath && dir) {
+        const legacy = path.join(dir, 'spec.json');
+        if (fs.existsSync(legacy)) specPath = legacy;
+    }
+    if (specPath) {
+        try {
+            LOG.info('spec-route', `[${provider.type}] routing through SpecCliAdapter (${path.relative(dir || '', specPath) || specPath})`);
+            return new SpecCliAdapter(specPath, workingDir, cliArgs, extraEnv, transportFactory);
+        } catch (err) {
+            LOG.warn('spec-route', `[${provider.type}] spec invalid, falling back to ProviderCliAdapter: ${(err as Error).message}`);
+        }
+    }
+    return new ProviderCliAdapter(provider, workingDir, cliArgs, extraEnv, transportFactory) as unknown as CliAdapter;
+}

package/src/providers/spec/types.ts

@@ -0,0 +1,284 @@
+/**
+ * Shared types for the adhdev:cli/spec@4 FSM spec system.
+ *
+ * These are the building blocks reused by fsm-types.ts, evaluator.ts, and
+ * the rest of the spec stack. v3/v1 types have been removed — all providers
+ * are on v4.
+ */
+'use strict';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Shared / layout types
+// ─────────────────────────────────────────────────────────────────────────────
+
+export type Size = number | string;
+
+export interface SectionPattern {
+    section?: string;
+    pattern: string;
+    flags?: string;
+}
+
+/** Inline wait_for shape used by open_picker control actions. */
+export interface WaitForCondition {
+    section?: string;
+    regex?: string;
+    flags?: string;
+}
+
+export type ControlAction =
+    | { type: 'send_keys'; keys: string }
+    | {
+          type: 'open_picker';
+          trigger_keys: string;
+          wait_for: WaitForCondition;
+          extract_choices: SectionPattern;
+          submit_key: string;
+          /**
+           * How a parsed choice is committed once the picker is open.
+           *   'index' (default) — type the on-screen number then `submit_key`
+           *     (`{index}\r`). Correct for CLIs whose picker is number-selectable
+           *     (codex-cli, hermes-cli).
+           *   'arrow_keys' — the picker is a cursor list that ignores number keys
+           *     (claude-cli /model): move the cursor from its current row to the
+           *     target row with up/down arrows, then confirm with the `submit_key`
+           *     tail (the `\r` left after stripping `{index}`). Requires the
+           *     extracted choices to flag the current cursor row.
+           */
+          select_mode?: 'index' | 'arrow_keys';
+          /** Arrow byte sequences for `select_mode: 'arrow_keys'`. Defaults to
+           *  ANSI cursor up/down (`` / ``) when omitted. */
+          cursor_keys?: { up: string; down: string };
+      }
+    | {
+          type: 'attach_image';
+          method: 'tempfile_then_keys';
+          keys_template: string;
+      };
+
+export interface Control {
+    id: string;
+    label: string;
+    visible_when_state?: string[];
+    action: ControlAction;
+}
+
+export interface NotificationRule {
+    id: string;
+    when_state: string;
+    title: string;
+    body?: string;
+}
+
+export interface DelegateTrigger {
+    id: string;
+    when_state: string;
+    after_duration_ms?: number;
+    task_template: string;
+}
+
+export interface NativeHistoryConfig {
+    reader?: 'claude-cli' | 'codex-cli' | 'antigravity-cli' | 'hermes-cli';
+    source?: NativeHistorySource;
+    override_path?: string;
+}
+
+export type NativeHistorySource =
+    | NativeHistoryJsonlSource
+    | NativeHistorySqliteSource;
+
+export interface NativeHistoryJsonlSource {
+    kind: 'jsonl';
+    path: string;
+    file_pattern?: string;
+    recent_window_ms?: number;
+    session_id_from?: 'filename_uuid' | 'first_record';
+    session_id_path?: string;
+    message_filter?: { where: string };
+    message_map: NativeHistoryMessageMap;
+}
+
+export interface NativeHistorySqliteSource {
+    kind: 'sqlite';
+    path: string;
+    session_query: string;
+    message_query: string;
+    /**
+     * Optional sub-session cluster expansion. Some agents (hermes ≥0.14) split
+     * a SINGLE logical turn across several `sessions` rows linked by a parent
+     * pointer, and the turn's final assistant message lands in a DIFFERENT row
+     * than the one `session_query` / the daemon's pin resolves. Reading only
+     * the anchor session then surfaces zero (or stale) assistant bubbles even
+     * though the answer is physically present in a sibling/descendant row —
+     * `read_chat` returns no final assistant and the completion gate false-fires
+     * `missing_final_assistant`.
+     *
+     * When present, the executor treats the resolved session id as an ANCHOR
+     * and runs this query (bound `?` = anchor id) to expand it to every session
+     * id in the same logical cluster (typically a `WITH RECURSIVE` walk over the
+     * parent pointer, up to the root and back down through all descendants).
+     * `message_query` is then run once per cluster id and the rows merged and
+     * re-sorted by their mapped timestamp, so the turn's final assistant — in
+     * whichever sub-session it was written — is always included. Each returned
+     * row's first column is a cluster session id.
+     *
+     * Absent → single-session behaviour is unchanged (anchor session only).
+     */
+    session_cluster_query?: string;
+    message_map: NativeHistoryMessageMap;
+}
+
+export interface NativeHistoryMessageMap {
+    role: string;
+    content: string;
+    content_strip?: string[];
+    content_unwrap?: string[];
+    timestamp_ms?: string;
+    kind?: string;
+    /**
+     * Declarative tool-bubble extraction. Without it the executor only emits
+     * the text-bearing parts of each record, so a turn that is purely a tool
+     * call or tool result (no prose) is dropped — the restored transcript
+     * loses every tool interaction. When present, the executor walks each
+     * record's content blocks and emits an extra `kind:'tool'` message for
+     * any block whose `$.type` matches a tool shape.
+     *
+     * Defaults target the Anthropic-style content-block shape that claude-cli
+     * and codex-cli persist (blocks of `{ type: 'tool_use' | 'tool_result',
+     * name, input, content }`); a provider with a different on-disk shape
+     * overrides the field paths. Set `tools: {}` to opt in with the defaults.
+     */
+    tools?: NativeHistoryToolMap;
+}
+
+/**
+ * How to surface tool-call / tool-result blocks as `kind:'tool'` bubbles.
+ * Every field is optional — the defaults read the Anthropic block shape.
+ * Paths are jsonpath-lite evaluated against a single content block (the
+ * element of `$.message.content[]`), not the whole record.
+ */
+export interface NativeHistoryToolMap {
+    /** Path to a block's discriminator. Default `$.type`. */
+    block_type?: string;
+    /** Block-type values that mean "a tool was invoked". Default
+     *  `['tool_use', 'function_call', 'custom_tool_call']`. */
+    call_types?: string[];
+    /** Block-type values that mean "a tool returned". Default
+     *  `['tool_result', 'function_call_output', 'custom_tool_call_output']`. */
+    result_types?: string[];
+    /** Path to the tool name on a call block. Default `$.name`. */
+    call_name?: string;
+    /** Path to the tool arguments on a call block. Default `$.input`. */
+    call_args?: string;
+    /** Path to the result payload on a result block. Default `$.content`. */
+    result_content?: string;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Section definition
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface AnchorContext {
+    prev?: string;
+    next?: string;
+    prev_flags?: string;
+    next_flags?: string;
+}
+
+export interface SectionDef {
+    from_top?: Size;
+    from_bottom?: Size;
+    until?: string;             // section id OR regex (starts with ^)
+    /**
+     * Anchor regex(es). A single string anchors on the first/last matching line
+     * (per `anchor_last`). An array is an OR-set of candidate shapes: each
+     * candidate resolves its OWN anchor line independently (anchor_last → that
+     * candidate's last matching line, else its first), then the TOPMOST resolved
+     * line across candidates wins — a section's anchor marks the top of its
+     * block, so the highest recognized landmark bounds the whole block. This
+     * lets one section capture two shapes — e.g. a box-divider modal AND a
+     * divider-less modal whose only stable landmark is the question line above
+     * its numbered choices — while preventing a stray LOWER landmark (e.g. an
+     * input-box `────` rule below the choices) from clipping the block.
+     */
+    anchor?: string | string[];
+    anchor_flags?: string;
+    anchor_last?: boolean;
+    /**
+     * Context guard(s) for the anchor. A single object applies to every anchor
+     * pattern. An array is matched positionally against an `anchor` array (entry
+     * i guards anchor i); a positional `undefined`/null entry means "no guard"
+     * for that anchor. A scalar `anchor` ignores array form beyond index 0.
+     */
+    anchor_context?: AnchorContext | (AnchorContext | null)[];
+    lines?: number;
+    until_regex?: string;
+    until_regex_flags?: string;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Conditions (shared with fsm-types.ts FsmCondition leaves)
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface RegexCondition {
+    section?: string;
+    matches: string;
+    flags?: string;
+    cursor_row_min?: number;
+    cursor_row_max?: number;
+    cursor_col_min?: number;
+    cursor_col_max?: number;
+}
+
+export interface ChangedCondition {
+    cursor_above: number;
+    changed: boolean;
+    stable_ms?: number;
+}
+
+export interface AllCondition {
+    all: Condition[];
+}
+
+export interface AnyCondition {
+    any: Condition[];
+}
+
+export type Condition = RegexCondition | ChangedCondition | AllCondition | AnyCondition;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Extraction helpers
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface ExtractTitle {
+    section?: string;
+    regex?: string;
+    flags?: string;
+    first_line?: true;
+}
+
+export interface ExtractButtons {
+    section?: string;
+    pattern: string;
+    flags?: string;
+    key_for_index: string;
+    min_count?: number;
+    continuation_lines?: boolean;
+    /**
+     * How a button is committed when its modal is resolved (auto-approve or an
+     * explicit dashboard click).
+     *   'index' (default) — send `key_for_index` with `{index}` filled in
+     *     (`{index}\r` → `1\r`). Correct for modals whose buttons are
+     *     number-selectable (codex, hermes, antigravity number rows).
+     *   'arrow_keys' — the modal is a cursor list that IGNORES number keys
+     *     (claude-cli's new TUI approval modal): a typed `1` leaks into the
+     *     composer as literal text and `\r` submits it. Instead move the cursor
+     *     from its current row to the target row with up/down arrows, then
+     *     confirm with the `key_for_index` tail (the `\r` left after stripping
+     *     `{index}`). Mirrors the `open_picker` `select_mode` of the same name.
+     */
+    select_mode?: 'index' | 'arrow_keys';
+    /** Arrow byte sequences for `select_mode: 'arrow_keys'`. Defaults to ANSI
+     *  cursor up/down (`[A` / `[B`) when omitted. */
+    cursor_keys?: { up: string; down: string };
+}

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();