@adhdev/daemon-core 0.9.82-rc.465 → 0.9.82-rc.467

package/dist/mesh/mesh-events-pending.d.ts

@@ -115,6 +115,14 @@ export declare function readRefineJobId(event: {
 } | Record<string, unknown>): string;
 export declare function buildPendingEventFingerprint(event: PendingMeshCoordinatorEvent): string;
 export declare function hasPendingCoordinatorEventDuplicate(event: PendingMeshCoordinatorEvent): boolean;
+/**
+ * Retention sweep for the SQLite mesh_pending_events inbox. Deletes long-drained
+ * rows (past the idempotency-useful window) and long-orphaned undrained rows (a
+ * coordinator identity that never returned). Best-effort and idempotent: a store
+ * failure or an empty table is a cheap no-op. Called from the periodic mesh-event
+ * maintenance sweep. Returns the number of rows pruned (0 when nothing to do).
+ */
+export declare function prunePendingMeshCoordinatorEventsRetention(): number;
 /**
  * Stamp the v2 protocol envelope onto a pending event at emit time (B2a).
  *

package/dist/mesh/mesh-runtime-store.d.ts

@@ -490,4 +490,30 @@ export declare class MeshRuntimeStore {
      * for the same task could be re-queued later. Returns the number of rows deleted.
      */
     deletePendingEventsById(ids: ReadonlyArray<string>): number;
+    /**
+     * Retention prune for mesh_pending_events. This table has no lifecycle GC of its
+     * own: a drained row is soft-marked (drained=1) and RETAINED — deliberately, so
+     * drainedEventIdsForMesh() has a durable v2-eventId dedup baseline — and an
+     * undrained row queued for a coordinator that never returned (a dead/evicted
+     * coordinator identity) stays drained=0 forever. Both accumulate without bound
+     * (observed: tens of thousands of rows, mostly stale). This is the missing
+     * retention step. Two independent windows:
+     *
+     *   - drained rows older than `drainedOlderThanMs`: the coordinator consumed them
+     *     long ago; the only thing they still back is the eventId re-delivery guard,
+     *     which is only meaningful for the recent past (a re-delivery of a week-old
+     *     event cannot occur — its producer session is long gone). Safe to delete.
+     *   - UNDRAINED rows older than `undrainedOlderThanMs` (a much wider window):
+     *     these are orphaned events for a coordinator identity that never drained
+     *     them. Kept wide so a genuinely-offline-but-returning coordinator still
+     *     receives its backlog; only genuinely unrecoverable orphans are swept.
+     *
+     * Both windows key off `queued_at` (always present) — `drained_at` can be NULL on
+     * legacy rows. Returns the number of rows deleted. Best-effort / idempotent:
+     * running it repeatedly with nothing to prune is a cheap no-op.
+     */
+    prunePendingEvents(opts: {
+        drainedOlderThanMs: number;
+        undrainedOlderThanMs: number;
+    }): number;
 }

package/dist/providers/cli-provider-instance.d.ts

@@ -44,6 +44,33 @@ export declare class CliProviderInstance implements ProviderInstance {
      * from scratch rather than firing on a stale timestamp.
      */
     private static readonly AUTO_APPROVE_GATE_HYSTERESIS_MS;
+    /**
+     * AUTOAPPROVE-FLAP-RECUR (Fix B): extended busy-side continuity window for a
+     * DELEGATED-WORKER auto-approve episode that is genuinely still cycling.
+     *
+     * The default AUTO_APPROVE_GATE_HYSTERESIS_MS (1500) absorbs a *momentary*
+     * `generating` blip. But a delegated worker running a Bash approval observed
+     * the FSM cycle the FULL state waiting_approval → busy → waiting_approval on a
+     * 2–5s period (the button set scrolls in/out AND the modal question repaints,
+     * so the adapter genuinely reports status=generating for whole seconds between
+     * approval frames). Each busy phase outran the 1500ms hysteresis, so the
+     * settle clock was WIPED (the genuine-resolution branch), the 600ms settle
+     * window never accumulated across the flap, resolveModal never fired
+     * (resolveModal count 0), and the mask-stall clock instead tripped at 4500ms →
+     * coordinator nudge → the flap the coordinator observed.
+     *
+     * A genuine resolution and a flap both start with a busy phase; they diverge
+     * only in whether waiting_approval RETURNS. So we cannot simply lengthen the
+     * blanket hysteresis (that would make every real resolution hold the gate
+     * open for seconds). Instead this longer window applies ONLY while an active
+     * mask episode is alive (autoApproveMaskSince > 0) AND the session is a
+     * delegated worker — i.e. exactly the never-resolving-flap case. A foreground
+     * / attended session keeps the tight 1500ms window unchanged. The mask-stall
+     * bound below still caps the episode, so a worker whose approval truly never
+     * returns is surfaced to the coordinator within AUTO_APPROVE_MASK_STALL_MS
+     * rather than held forever.
+     */
+    private static readonly AUTO_APPROVE_FLAP_CONTINUITY_MS;
     /**
      * STATUS-MISMATCH: upper bound on how long the auto-approve→`generating` SURFACE
      * mask may hide a worker's `waiting_approval` (status + activeModal) before we give
@@ -83,6 +110,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private pendingAutoApprovalSince;
     private autoApproveSettleTimer;
     private autoApproveInactiveSince;
+    private autoApproveLastModalSeenAt;
     private autoApproveMaskSince;
     private stalledApprovalNudgeEpisode;
     private readonly manualAttendance;
@@ -272,6 +300,18 @@ export declare class CliProviderInstance implements ProviderInstance {
     private approvalResolutionFinalizationBlock;
     private scheduleCompletedDebounceFlush;
     private isMeshWorkerSession;
+    /**
+     * AUTOAPPROVE-FLAP-RECUR (Fix A+B): how long a busy blip / modal scroll-out may
+     * persist before the in-progress settle gate is torn down. For a delegated
+     * worker whose auto-approve episode is genuinely still cycling (mask clock
+     * alive), the FSM's full waiting_approval → busy → waiting_approval flap runs
+     * on a multi-second period, so the settle continuity window is extended to
+     * AUTO_APPROVE_FLAP_CONTINUITY_MS to bridge it (still bounded, and still capped
+     * by AUTO_APPROVE_MASK_STALL_MS). Every other case — foreground/attended
+     * session, or no active mask episode — keeps the tight default hysteresis so a
+     * genuine resolution frees the gate promptly.
+     */
+    private autoApproveContinuityWindowMs;
     private isAutonomousMeshSession;
     /**
      * ARCH-REFACTOR R1: the taskId to attribute the CURRENTLY-completing turn to.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.465",
+  "version": "0.9.82-rc.467",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,8 +47,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.465",
-    "@adhdev/session-host-core": "0.9.82-rc.465",
+    "@adhdev/mesh-shared": "0.9.82-rc.467",
+    "@adhdev/session-host-core": "0.9.82-rc.467",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/mesh/mesh-event-forwarding.ts

@@ -7,7 +7,7 @@ import type { SessionRecoveryContext } from './mesh-ledger.js';
 import { updateSessionTaskStatus, enqueueTask, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, getActiveDirectDispatches, hasPendingDependents, getQueue } from './mesh-work-queue.js';
 import { markSessionDeliveriesTerminal, updateSessionDeliveryStatus, recordCompletionConflict } from './mesh-delivery-policy.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, readV2EnvelopeFromWire, type PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
+import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, prunePendingMeshCoordinatorEventsRetention, readV2EnvelopeFromWire, type PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import type { ProviderInstance } from '../providers/provider-instance.js';
 import { resolveWorkerDelegateRouting, recordUnroutableDelegateEvent, isUnroutableDelegateRejection } from './mesh-routing.js';
 import { resolveMeshHostStatus } from './mesh-host-ownership.js';
@@ -178,10 +178,25 @@ export function __resetMeshWorkspaceCacheForTests(): void {
     meshByWorkspaceCache.clear();
 }
 
+// Throttle the pending-event retention DELETE so it runs at most hourly — the
+// remote-idle sweep below fires on every completion/idle transition, but a table
+// scan + DELETE should not. In-process timestamp; a restart re-arms it, which only
+// means one prune shortly after boot (harmless, idempotent).
+let lastPendingEventsPruneAt = 0;
+const PENDING_EVENTS_PRUNE_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+
 function sweepExpiredRemoteIdleSessions(): void {
     try {
         MeshRuntimeStore.getInstance().pruneExpiredRemoteIdleSessions();
     } catch { /* best-effort */ }
+    // Piggyback the pending-event retention prune on the same periodic sweep, but
+    // hourly — this is the maintenance hook that keeps mesh_pending_events from
+    // accumulating stale drained/orphaned rows without bound.
+    const now = Date.now();
+    if (now - lastPendingEventsPruneAt >= PENDING_EVENTS_PRUNE_INTERVAL_MS) {
+        lastPendingEventsPruneAt = now;
+        prunePendingMeshCoordinatorEventsRetention();
+    }
 }
 
 const INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS = 30 * 60 * 1000;

package/src/mesh/mesh-events-pending.ts

@@ -675,6 +675,42 @@ function reconcilePendingMeshCoordinatorEvents(meshId: string, events: PendingMe
 const MAX_PENDING_EVENTS_BYTES = 100 * 1024; // 100 KB — keep the pending file small
 const MAX_PENDING_EVENTS_KEEP = 50;           // keep the last 50 events when trimming
 
+// ─── SQLite pending-event retention ─────────────────────────────────────────
+// mesh_pending_events had no lifecycle GC: drained rows are retained forever (the
+// durable v2-eventId dedup baseline drainedEventIdsForMesh reads them), and an
+// undrained row for a coordinator identity that never returns stays queued forever.
+// Both accumulate without bound. These windows bound that growth while preserving
+// the two things the rows exist for — recent-re-delivery idempotency and delivery
+// to a returning coordinator. A drained event older than the drained window cannot
+// be re-delivered (its producer session is long gone), so keeping it buys nothing;
+// an undrained event is kept far longer so a genuinely-offline coordinator's backlog
+// survives, and only unrecoverable orphans are swept.
+const PENDING_EVENTS_DRAINED_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;   // 7 days
+const PENDING_EVENTS_UNDRAINED_RETENTION_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
+
+/**
+ * Retention sweep for the SQLite mesh_pending_events inbox. Deletes long-drained
+ * rows (past the idempotency-useful window) and long-orphaned undrained rows (a
+ * coordinator identity that never returned). Best-effort and idempotent: a store
+ * failure or an empty table is a cheap no-op. Called from the periodic mesh-event
+ * maintenance sweep. Returns the number of rows pruned (0 when nothing to do).
+ */
+export function prunePendingMeshCoordinatorEventsRetention(): number {
+    try {
+        const removed = MeshRuntimeStore.getInstance().prunePendingEvents({
+            drainedOlderThanMs: PENDING_EVENTS_DRAINED_RETENTION_MS,
+            undrainedOlderThanMs: PENDING_EVENTS_UNDRAINED_RETENTION_MS,
+        });
+        if (removed > 0) {
+            LOG.info('MeshEvents', `Pruned ${removed} stale pending-event row(s) (drained >7d / undrained >30d)`);
+        }
+        return removed;
+    } catch (e: any) {
+        LOG.warn('MeshEvents', `Pending-event retention prune failed: ${e?.message || e}`);
+        return 0;
+    }
+}
+
 function trimPendingEventsIfNeeded(path: string): void {
     try {
         if (!existsSync(path)) return;

package/src/mesh/mesh-ledger.ts

@@ -255,11 +255,21 @@ const RECENT_FAILURE_WINDOW_MS = 30 * 60 * 1000; // 30 minutes
 
 // Kinds that accumulate indefinitely and are safe to archive after ARCHIVE_TERMINAL_OLDER_THAN_MS.
 // Non-terminal kinds (dispatched, sessions, nodes, checkpoints) are always kept in the active file.
+//
+// session_auto_launch is telemetry, NOT audit: it records the queue-assignment
+// decision on each tick (mostly phase:'skipped' — nothing was launched). No reader
+// consults it back from the ledger (unlike task_dispatched, which getSessionRecoveryContext
+// scans and which therefore MUST stay non-archivable). It is the single largest
+// avoidable ledger consumer after node/dispatch history, so archiving it after the
+// 7-day window is the volume fix — recent entries still surface for diagnosis (and the
+// per-tick dedup keeps live volume bounded), old ones move to the archive JSONL and out
+// of the runtime store. This preserves observability while removing the standing bulk.
 const ARCHIVABLE_KINDS: ReadonlySet<MeshLedgerKind> = new Set([
     'task_completed',
     'task_failed',
     'task_stalled',
     'recovery_attempted',
+    'session_auto_launch',
 ] as MeshLedgerKind[]);
 const DEFAULT_LEDGER_SLICE_LIMIT = 100;
 export const MAX_LEDGER_SLICE_LIMIT = 500;

package/src/mesh/mesh-runtime-store.ts

@@ -1551,6 +1551,18 @@ export class MeshRuntimeStore {
         providerType?: string | null;
         payload?: unknown;
     }): void {
+        // Ledger `kind` is a mandatory schema invariant (mesh_event_ledger.kind is
+        // NOT NULL; every MeshLedgerKind is a non-empty tag). A blank kind would be a
+        // structurally-broken entry — reject it here rather than write an unqueryable
+        // row. NOTE: pending-event JSONL files (`*.pending-events.jsonl`) are a
+        // SEPARATE shape that intentionally has NO `kind` field (they key off `.event`);
+        // a generic audit that scans the whole ledger DIRECTORY and reads `.kind` off
+        // those rows sees "kind=None", which is an artifact of mixing the two files, not
+        // a ledger defect. This guard makes the ledger-side invariant explicit.
+        if (!entry.kind || !String(entry.kind).trim()) {
+            LOG.warn('MeshRuntimeStore', `Refusing to append ledger entry with empty kind for mesh ${entry.meshId} (id ${entry.id})`);
+            return;
+        }
         this.db.prepare(
             `INSERT OR IGNORE INTO mesh_event_ledger
              (id, mesh_id, timestamp, kind, node_id, session_id, provider_type, payload)
@@ -1693,6 +1705,11 @@ export class MeshRuntimeStore {
         );
         this.db.transaction(() => {
             for (const e of entries) {
+                // Skip structurally-broken entries with a blank kind (see appendLedgerEntry):
+                // mesh_event_ledger.kind is NOT NULL and every kind is a non-empty tag, so an
+                // empty-kind row is unqueryable noise. Mirrors readLedgerFile's `entry.id && entry.kind`
+                // JSONL guard, keeping the import path from re-introducing what the read path filters.
+                if (!e.kind || !String(e.kind).trim()) continue;
                 const result = stmt.run(
                     e.id, e.meshId, e.timestamp, e.kind,
                     e.nodeId ?? null, e.sessionId ?? null, e.providerType ?? null,
@@ -2053,4 +2070,40 @@ export class MeshRuntimeStore {
             `DELETE FROM mesh_pending_events WHERE id IN (${idList.map(() => '?').join(',')})`
         ).run(...idList).changes;
     }
+
+    /**
+     * Retention prune for mesh_pending_events. This table has no lifecycle GC of its
+     * own: a drained row is soft-marked (drained=1) and RETAINED — deliberately, so
+     * drainedEventIdsForMesh() has a durable v2-eventId dedup baseline — and an
+     * undrained row queued for a coordinator that never returned (a dead/evicted
+     * coordinator identity) stays drained=0 forever. Both accumulate without bound
+     * (observed: tens of thousands of rows, mostly stale). This is the missing
+     * retention step. Two independent windows:
+     *
+     *   - drained rows older than `drainedOlderThanMs`: the coordinator consumed them
+     *     long ago; the only thing they still back is the eventId re-delivery guard,
+     *     which is only meaningful for the recent past (a re-delivery of a week-old
+     *     event cannot occur — its producer session is long gone). Safe to delete.
+     *   - UNDRAINED rows older than `undrainedOlderThanMs` (a much wider window):
+     *     these are orphaned events for a coordinator identity that never drained
+     *     them. Kept wide so a genuinely-offline-but-returning coordinator still
+     *     receives its backlog; only genuinely unrecoverable orphans are swept.
+     *
+     * Both windows key off `queued_at` (always present) — `drained_at` can be NULL on
+     * legacy rows. Returns the number of rows deleted. Best-effort / idempotent:
+     * running it repeatedly with nothing to prune is a cheap no-op.
+     */
+    prunePendingEvents(opts: { drainedOlderThanMs: number; undrainedOlderThanMs: number }): number {
+        const now = Date.now();
+        const drainedCutoff = now - Math.max(0, opts.drainedOlderThanMs);
+        const undrainedCutoff = now - Math.max(0, opts.undrainedOlderThanMs);
+        let removed = 0;
+        removed += this.db.prepare(
+            'DELETE FROM mesh_pending_events WHERE drained = 1 AND queued_at < ?'
+        ).run(drainedCutoff).changes;
+        removed += this.db.prepare(
+            'DELETE FROM mesh_pending_events WHERE drained = 0 AND queued_at < ?'
+        ).run(undrainedCutoff).changes;
+        return removed;
+    }
 }

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

@@ -221,6 +221,34 @@ export class CliProviderInstance implements ProviderInstance {
      */
     private static readonly AUTO_APPROVE_GATE_HYSTERESIS_MS = 1500;
 
+    /**
+     * AUTOAPPROVE-FLAP-RECUR (Fix B): extended busy-side continuity window for a
+     * DELEGATED-WORKER auto-approve episode that is genuinely still cycling.
+     *
+     * The default AUTO_APPROVE_GATE_HYSTERESIS_MS (1500) absorbs a *momentary*
+     * `generating` blip. But a delegated worker running a Bash approval observed
+     * the FSM cycle the FULL state waiting_approval → busy → waiting_approval on a
+     * 2–5s period (the button set scrolls in/out AND the modal question repaints,
+     * so the adapter genuinely reports status=generating for whole seconds between
+     * approval frames). Each busy phase outran the 1500ms hysteresis, so the
+     * settle clock was WIPED (the genuine-resolution branch), the 600ms settle
+     * window never accumulated across the flap, resolveModal never fired
+     * (resolveModal count 0), and the mask-stall clock instead tripped at 4500ms →
+     * coordinator nudge → the flap the coordinator observed.
+     *
+     * A genuine resolution and a flap both start with a busy phase; they diverge
+     * only in whether waiting_approval RETURNS. So we cannot simply lengthen the
+     * blanket hysteresis (that would make every real resolution hold the gate
+     * open for seconds). Instead this longer window applies ONLY while an active
+     * mask episode is alive (autoApproveMaskSince > 0) AND the session is a
+     * delegated worker — i.e. exactly the never-resolving-flap case. A foreground
+     * / attended session keeps the tight 1500ms window unchanged. The mask-stall
+     * bound below still caps the episode, so a worker whose approval truly never
+     * returns is surfaced to the coordinator within AUTO_APPROVE_MASK_STALL_MS
+     * rather than held forever.
+     */
+    private static readonly AUTO_APPROVE_FLAP_CONTINUITY_MS = 4000;
+
     /**
      * STATUS-MISMATCH: upper bound on how long the auto-approve→`generating` SURFACE
      * mask may hide a worker's `waiting_approval` (status + activeModal) before we give
@@ -296,9 +324,22 @@ export class CliProviderInstance implements ProviderInstance {
     private pendingAutoApprovalSince = 0;
     private autoApproveSettleTimer: NodeJS.Timeout | null = null;
     // Wall-clock when auto-approve first observed status!=waiting_approval while
-    // a settle gate was in progress. Drives AUTO_APPROVE_GATE_HYSTERESIS_MS so a
+    // a settle gate was in progress. Drives AUTO_APPROVE_GATE_HYSTERESIS_MS (or,
+    // for a delegated-worker flap episode, AUTO_APPROVE_FLAP_CONTINUITY_MS) so a
     // brief generating flip does not immediately wipe the settle clock.
     private autoApproveInactiveSince = 0;
+    // AUTOAPPROVE-FLAP-RECUR (Fix A): wall-clock when the CURRENT waiting_approval
+    // episode last presented a concrete, captured modal (buttons.length > 0). The
+    // Claude TUI momentarily reports status=waiting_approval with activeModal=null
+    // / an empty button block while the button block scrolls out of the captured
+    // frame; the raw guard below (buttons.length===0) used to bail on that frame,
+    // never advancing the settle gate and leaving no re-check armed — so a modal
+    // that flapped modal=none ↔ N-buttons around the settle boundary never
+    // accumulated its 600ms. This tracks the last GOOD-modal frame so a short
+    // scroll-out blip is absorbed (settle keeps running against the last captured
+    // signature) while a genuinely closed modal — buttons empty continuously past
+    // the continuity window — is still recognised and resets the gate.
+    private autoApproveLastModalSeenAt = 0;
     // STATUS-MISMATCH: wall-clock when the CURRENT auto-approve episode (waiting_approval
     // + shouldAutoApprove) first began wanting to mask. Unlike pendingAutoApprovalSince it
     // is NOT reset when the modal signature changes (a still-streaming/flapping prompt) and
@@ -1640,6 +1681,23 @@ export class CliProviderInstance implements ProviderInstance {
             || this.settings.meshNodeId || this.settings.launchedByCoordinator);
     }
 
+    /**
+     * AUTOAPPROVE-FLAP-RECUR (Fix A+B): how long a busy blip / modal scroll-out may
+     * persist before the in-progress settle gate is torn down. For a delegated
+     * worker whose auto-approve episode is genuinely still cycling (mask clock
+     * alive), the FSM's full waiting_approval → busy → waiting_approval flap runs
+     * on a multi-second period, so the settle continuity window is extended to
+     * AUTO_APPROVE_FLAP_CONTINUITY_MS to bridge it (still bounded, and still capped
+     * by AUTO_APPROVE_MASK_STALL_MS). Every other case — foreground/attended
+     * session, or no active mask episode — keeps the tight default hysteresis so a
+     * genuine resolution frees the gate promptly.
+     */
+    private autoApproveContinuityWindowMs(): number {
+        return this.autoApproveMaskSince > 0 && this.isMeshWorkerSession()
+            ? CliProviderInstance.AUTO_APPROVE_FLAP_CONTINUITY_MS
+            : CliProviderInstance.AUTO_APPROVE_GATE_HYSTERESIS_MS;
+    }
+
     // FALSE-IDLE (self-coordinator settle): an autonomously-progressing mesh session
     // is either a delegated worker (isMeshWorkerSession) OR the coordinator's OWN
     // claude-cli session (meshCoordinatorFor). Both run auto-approved tool turns whose
@@ -1946,6 +2004,7 @@ export class CliProviderInstance implements ProviderInstance {
             // returns false), so end the mask episode.
             this.autoApproveMaskSince = 0;
             this.stalledApprovalNudgeEpisode = 0;
+            this.autoApproveLastModalSeenAt = 0;
             if (this.autoApproveSettleTimer) clearTimeout(this.autoApproveSettleTimer);
             this.autoApproveSettleTimer = setTimeout(() => {
                 this.autoApproveSettleTimer = null;
@@ -1973,12 +2032,20 @@ export class CliProviderInstance implements ProviderInstance {
             if (this.pendingAutoApprovalSince) {
                 if (!this.autoApproveInactiveSince) this.autoApproveInactiveSince = now;
                 const goneForMs = now - this.autoApproveInactiveSince;
-                if (goneForMs < CliProviderInstance.AUTO_APPROVE_GATE_HYSTERESIS_MS) {
+                // AUTOAPPROVE-FLAP-RECUR (Fix B): a delegated-worker flap cycles the
+                // FULL waiting_approval → busy → waiting_approval state on a
+                // multi-second period, outrunning the tight default hysteresis and
+                // wiping the settle clock before 600ms ever accumulates. For an
+                // active worker mask episode the continuity window is widened (still
+                // capped by AUTO_APPROVE_MASK_STALL_MS) so the settle clock survives
+                // the busy phase and the returning approval keeps accruing settle time.
+                const continuityMs = this.autoApproveContinuityWindowMs();
+                if (goneForMs < continuityMs) {
                     if (this.autoApproveSettleTimer) clearTimeout(this.autoApproveSettleTimer);
                     this.autoApproveSettleTimer = setTimeout(() => {
                         this.autoApproveSettleTimer = null;
                         this.recheckAutoApproveSettled();
-                    }, CliProviderInstance.AUTO_APPROVE_GATE_HYSTERESIS_MS - goneForMs + 20);
+                    }, continuityMs - goneForMs + 20);
                     return autoApproveActive;
                 }
             }
@@ -1991,6 +2058,7 @@ export class CliProviderInstance implements ProviderInstance {
             // end the mask episode too (a later approval starts a fresh stall clock).
             this.autoApproveMaskSince = 0;
             this.stalledApprovalNudgeEpisode = 0;
+            this.autoApproveLastModalSeenAt = 0;
             if (this.autoApproveSettleTimer) { clearTimeout(this.autoApproveSettleTimer); this.autoApproveSettleTimer = null; }
             return autoApproveActive;
         }
@@ -2018,8 +2086,40 @@ export class CliProviderInstance implements ProviderInstance {
             ? modal.buttons.map((b: any) => String(b || '').trim()).filter(Boolean)
             : [];
         if (!modal || buttons.length === 0) {
+            // AUTOAPPROVE-FLAP-RECUR (Fix A): the button block momentarily scrolled
+            // out of the captured frame (status is still waiting_approval — we are
+            // on the active path). Do NOT tear the settle gate down on this frame:
+            // if a concrete modal was captured within the continuity window and a
+            // settle gate is in progress, this is a short scroll-out blip — keep the
+            // gate warm against the last-captured signature and arm a re-check so a
+            // silent PTY still re-drives the decision when the buttons repaint. Only
+            // once the modal has stayed empty PAST the continuity window is it a
+            // genuine close, and the gate is cleared here so a later approval
+            // re-settles from scratch (never fires on a stale timestamp).
+            const blipForMs = this.autoApproveLastModalSeenAt ? now - this.autoApproveLastModalSeenAt : Infinity;
+            if (this.pendingAutoApprovalSince && blipForMs < this.autoApproveContinuityWindowMs()) {
+                if (this.autoApproveSettleTimer) clearTimeout(this.autoApproveSettleTimer);
+                this.autoApproveSettleTimer = setTimeout(() => {
+                    this.autoApproveSettleTimer = null;
+                    this.recheckAutoApproveSettled();
+                }, this.autoApproveContinuityWindowMs() - blipForMs + 20);
+                return autoApproveActive;
+            }
+            if (blipForMs >= this.autoApproveContinuityWindowMs()) {
+                // Buttons empty continuously past the window → the modal genuinely
+                // closed (or never captured). Reset the per-signature settle gate so
+                // a later approval re-settles cleanly. The mask-stall clock keeps
+                // running underneath so a never-captured worker modal still surfaces
+                // to the coordinator within AUTO_APPROVE_MASK_STALL_MS.
+                this.pendingAutoApprovalSignature = '';
+                this.pendingAutoApprovalSince = 0;
+            }
             return autoApproveActive;
         }
+        // Concrete modal captured this frame — mark the last-good-modal timestamp so
+        // a subsequent scroll-out blip (buttons.length===0) can be told apart from a
+        // genuine close by how long it persists (Fix A above).
+        this.autoApproveLastModalSeenAt = now;
         // Picker/confirm exclusion (provider-common). A /model or /mode picker is
         // surfaced with status=waiting_approval so the dashboard shows it, but it
         // has no "correct" answer to auto-pick — blindly selecting the first
@@ -2137,6 +2237,7 @@ export class CliProviderInstance implements ProviderInstance {
         // Fired (resolveModal in flight) — the episode resolved; end the mask-stall clock.
         this.autoApproveMaskSince = 0;
         this.stalledApprovalNudgeEpisode = 0;
+        this.autoApproveLastModalSeenAt = 0;
         if (this.autoApproveBusyTimer) clearTimeout(this.autoApproveBusyTimer);
         this.autoApproveBusyTimer = setTimeout(() => {
             this.autoApproveBusy = false;
@@ -3162,6 +3263,18 @@ export class CliProviderInstance implements ProviderInstance {
         if (!this.isMeshWorkerSession()) return;
         if (adapterStatus?.status !== 'waiting_approval') return;
         if (!this.autoApproveMaskStalled(now)) return;
+        // AUTOAPPROVE-FLAP-RECUR (Fix C): the mask-stall bound tripped, but if a
+        // concrete approvable modal is on screen RIGHT NOW and the settle gate is
+        // already in progress, auto-approve is about to fire on its own (the same
+        // call runs the settle evaluation just below this nudge). Defer to the fire
+        // rather than paging the coordinator — the nudge would race a resolveModal
+        // that lands milliseconds later, producing the coordinator flap this fix
+        // targets. A genuinely stuck episode (no captured modal, or settle never
+        // engaged) still has pendingAutoApprovalSince === 0 here and pages normally.
+        const modalButtons = Array.isArray(adapterStatus.activeModal?.buttons)
+            ? adapterStatus.activeModal.buttons.map((b: any) => String(b || '').trim()).filter(Boolean)
+            : [];
+        if (this.pendingAutoApprovalSince && modalButtons.length > 0) return;
         // Exactly once per stalled episode (autoApproveMaskSince uniquely identifies it).
         if (this.stalledApprovalNudgeEpisode === this.autoApproveMaskSince) return;
         this.stalledApprovalNudgeEpisode = this.autoApproveMaskSince;