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

package/dist/index.mjs

@@ -404,10 +404,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "1fb9559b573b07e5386c80329057766b4822dddb" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "1fb9559b" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.465" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-05T07:20:34.545Z" : void 0);
+  const commit = readInjected(true ? "e0f04b7d54855e0f0d5ed4200078d95596ab9f6f" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "e0f04b7d" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.467" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-05T10:01:33.435Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -5144,7 +5144,8 @@ var init_mesh_ledger = __esm({
       "task_completed",
       "task_failed",
       "task_stalled",
-      "recovery_attempted"
+      "recovery_attempted",
+      "session_auto_launch"
     ]);
     DEFAULT_LEDGER_SLICE_LIMIT = 100;
     MAX_LEDGER_SLICE_LIMIT = 500;
@@ -7337,6 +7338,10 @@ var init_mesh_runtime_store = __esm({
       }
       // ── G2: Event Ledger ────────────────────────────────────────────────────
       appendLedgerEntry(entry) {
+        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)
@@ -7471,6 +7476,7 @@ var init_mesh_runtime_store = __esm({
         );
         this.db.transaction(() => {
           for (const e of entries) {
+            if (!e.kind || !String(e.kind).trim()) continue;
             const result = stmt.run(
               e.id,
               e.meshId,
@@ -7765,6 +7771,41 @@ var init_mesh_runtime_store = __esm({
           `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) {
+        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;
+      }
     };
   }
 });
@@ -11764,6 +11805,21 @@ function reconcilePendingMeshCoordinatorEvents(meshId, events) {
   const reconciled = terminalJobIds.size === 0 ? events : events.filter((event) => !(event.event === "refine:accepted" && terminalJobIds.has(readRefineJobId2(event))));
   return backfilled.length === 0 ? reconciled : [...reconciled, ...backfilled];
 }
+function prunePendingMeshCoordinatorEventsRetention() {
+  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) {
+    LOG.warn("MeshEvents", `Pending-event retention prune failed: ${e?.message || e}`);
+    return 0;
+  }
+}
 function trimPendingEventsIfNeeded(path45) {
   try {
     if (!existsSync15(path45)) return;
@@ -12134,7 +12190,7 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
     }
   }
 }
-var REFINE_TERMINAL_EVENTS, meshV2DrainCounters, warnedV2Violations, TERMINAL_COMPLETION_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
+var REFINE_TERMINAL_EVENTS, meshV2DrainCounters, warnedV2Violations, TERMINAL_COMPLETION_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP, PENDING_EVENTS_DRAINED_RETENTION_MS, PENDING_EVENTS_UNDRAINED_RETENTION_MS;
 var init_mesh_events_pending = __esm({
   "src/mesh/mesh-events-pending.ts"() {
     "use strict";
@@ -12175,6 +12231,8 @@ var init_mesh_events_pending = __esm({
     TERMINAL_COMPLETION_EVENTS = /* @__PURE__ */ new Set(["agent:generating_completed", "agent:stopped"]);
     MAX_PENDING_EVENTS_BYTES = 100 * 1024;
     MAX_PENDING_EVENTS_KEEP = 50;
+    PENDING_EVENTS_DRAINED_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+    PENDING_EVENTS_UNDRAINED_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
   }
 });
 
@@ -17235,6 +17293,11 @@ function sweepExpiredRemoteIdleSessions() {
     MeshRuntimeStore.getInstance().pruneExpiredRemoteIdleSessions();
   } catch {
   }
+  const now = Date.now();
+  if (now - lastPendingEventsPruneAt >= PENDING_EVENTS_PRUNE_INTERVAL_MS) {
+    lastPendingEventsPruneAt = now;
+    prunePendingMeshCoordinatorEventsRetention();
+  }
 }
 function isIntentionalCleanupStopMetadata(event) {
   return event.intentional === true || event.intentionalStop === true || event.operatorCleanup === true || event.reason === "operator_cleanup" || event.stopReason === "operator_cleanup" || event.cleanupReason === "operator_cleanup" || event.source === "mesh_cleanup_sessions" || event.source === "mesh_remove_node";
@@ -18293,7 +18356,7 @@ function setupMeshEventForwarding(components) {
     flushPendingForMeshIdleCoordinators(components, routing.meshId);
   });
 }
-var REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, RECONCILED_COMPLETION_SOURCES, coordinatorForwardLanes;
+var REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, lastPendingEventsPruneAt, PENDING_EVENTS_PRUNE_INTERVAL_MS, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, RECONCILED_COMPLETION_SOURCES, coordinatorForwardLanes;
 var init_mesh_event_forwarding = __esm({
   "src/mesh/mesh-event-forwarding.ts"() {
     "use strict";
@@ -18320,6 +18383,8 @@ var init_mesh_event_forwarding = __esm({
     REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1e3;
     meshByWorkspaceCache = /* @__PURE__ */ new Map();
     MESH_WORKSPACE_CACHE_TTL_MS = 5e3;
+    lastPendingEventsPruneAt = 0;
+    PENDING_EVENTS_PRUNE_INTERVAL_MS = 60 * 60 * 1e3;
     INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS = 30 * 60 * 1e3;
     RECENT_COMPLETION_FINGERPRINT_TTL_MS = 10 * 60 * 1e3;
     RECONCILED_COMPLETION_SOURCES = /* @__PURE__ */ new Set([
@@ -42299,6 +42364,33 @@ var CliProviderInstance = class _CliProviderInstance {
    * from scratch rather than firing on a stale timestamp.
    */
   static 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.
+   */
+  static AUTO_APPROVE_FLAP_CONTINUITY_MS = 4e3;
   /**
    * 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
@@ -42373,9 +42465,22 @@ var CliProviderInstance = class _CliProviderInstance {
   pendingAutoApprovalSince = 0;
   autoApproveSettleTimer = 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.
   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.
+  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
@@ -43338,6 +43443,20 @@ var CliProviderInstance = class _CliProviderInstance {
   isMeshWorkerSession() {
     return !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || 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.
+   */
+  autoApproveContinuityWindowMs() {
+    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
@@ -43573,6 +43692,7 @@ var CliProviderInstance = class _CliProviderInstance {
       this.autoApproveInactiveSince = 0;
       this.autoApproveMaskSince = 0;
       this.stalledApprovalNudgeEpisode = 0;
+      this.autoApproveLastModalSeenAt = 0;
       if (this.autoApproveSettleTimer) clearTimeout(this.autoApproveSettleTimer);
       this.autoApproveSettleTimer = setTimeout(() => {
         this.autoApproveSettleTimer = null;
@@ -43586,12 +43706,13 @@ var CliProviderInstance = class _CliProviderInstance {
       if (this.pendingAutoApprovalSince) {
         if (!this.autoApproveInactiveSince) this.autoApproveInactiveSince = now;
         const goneForMs = now - this.autoApproveInactiveSince;
-        if (goneForMs < _CliProviderInstance.AUTO_APPROVE_GATE_HYSTERESIS_MS) {
+        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;
         }
       }
@@ -43600,6 +43721,7 @@ var CliProviderInstance = class _CliProviderInstance {
       this.autoApproveInactiveSince = 0;
       this.autoApproveMaskSince = 0;
       this.stalledApprovalNudgeEpisode = 0;
+      this.autoApproveLastModalSeenAt = 0;
       if (this.autoApproveSettleTimer) {
         clearTimeout(this.autoApproveSettleTimer);
         this.autoApproveSettleTimer = null;
@@ -43612,8 +43734,22 @@ var CliProviderInstance = class _CliProviderInstance {
     const modal = adapterStatus.activeModal;
     const buttons = Array.isArray(modal?.buttons) ? modal.buttons.map((b) => String(b || "").trim()).filter(Boolean) : [];
     if (!modal || buttons.length === 0) {
+      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()) {
+        this.pendingAutoApprovalSignature = "";
+        this.pendingAutoApprovalSince = 0;
+      }
       return autoApproveActive;
     }
+    this.autoApproveLastModalSeenAt = now;
     const modalKind = typeof modal?.kind === "string" ? modal.kind : "approval";
     if (modalKind !== "approval") {
       return autoApproveActive;
@@ -43657,6 +43793,7 @@ var CliProviderInstance = class _CliProviderInstance {
     this.autoApproveInactiveSince = 0;
     this.autoApproveMaskSince = 0;
     this.stalledApprovalNudgeEpisode = 0;
+    this.autoApproveLastModalSeenAt = 0;
     if (this.autoApproveBusyTimer) clearTimeout(this.autoApproveBusyTimer);
     this.autoApproveBusyTimer = setTimeout(() => {
       this.autoApproveBusy = false;
@@ -44302,6 +44439,8 @@ ${effect.notification.body || ""}`.trim();
     if (!this.isMeshWorkerSession()) return;
     if (adapterStatus?.status !== "waiting_approval") return;
     if (!this.autoApproveMaskStalled(now)) return;
+    const modalButtons = Array.isArray(adapterStatus.activeModal?.buttons) ? adapterStatus.activeModal.buttons.map((b) => String(b || "").trim()).filter(Boolean) : [];
+    if (this.pendingAutoApprovalSince && modalButtons.length > 0) return;
     if (this.stalledApprovalNudgeEpisode === this.autoApproveMaskSince) return;
     this.stalledApprovalNudgeEpisode = this.autoApproveMaskSince;
     const modal = adapterStatus.activeModal;