pi-crew 0.9.50 → 0.9.51

package/dist/index.mjs

@@ -42584,7 +42584,7 @@ var init_tool_renderers = __esm({
 });
 
 // src/ui/render-scheduler.ts
-var DEFAULT_EVENTS, RenderScheduler;
+var DEFAULT_EVENTS, CAP_BACKOFF_MAX_EXP, RenderScheduler;
 var init_render_scheduler = __esm({
   "src/ui/render-scheduler.ts"() {
     "use strict";
@@ -42599,6 +42599,7 @@ var init_render_scheduler = __esm({
       "crew.mailbox.updated",
       "crew.mailbox.message"
     ];
+    CAP_BACKOFF_MAX_EXP = 5;
     RenderScheduler = class {
       render;
       onInvalidate;
@@ -42606,6 +42607,7 @@ var init_render_scheduler = __esm({
       fallbackProvider;
       fallbackMs;
       invalidateCoalesceMs;
+      maxIdleFallbackRenders;
       debounceTimer;
       fallbackTimer;
       invalidateTimer;
@@ -42615,6 +42617,10 @@ var init_render_scheduler = __esm({
       lastEventAt = 0;
       rendering = false;
       pendingRender = false;
+      /** R1: consecutive idle fallback renders since the last real event. */
+      idleFallbackRenders = 0;
+      /** R4: consecutive re-entrancy cap-hits — drives exponential backoff. */
+      consecutiveCapHits = 0;
       unsubs = [];
       constructor(events, render, options = {}) {
         this.render = render;
@@ -42624,6 +42630,7 @@ var init_render_scheduler = __esm({
         this.fallbackProvider = typeof fallback2 === "function" ? fallback2 : () => fallback2;
         this.fallbackMs = typeof fallback2 === "number" ? fallback2 : 750;
         this.invalidateCoalesceMs = options.invalidateCoalesceMs ?? 50;
+        this.maxIdleFallbackRenders = options.maxIdleFallbackRenders ?? 8;
         for (const event of options.events ?? DEFAULT_EVENTS) this.subscribe(events, event);
         this.fallbackTimer = setTimeout(() => this.fallbackLoop(), this.currentFallbackMs());
         this.fallbackTimer.unref();
@@ -42652,25 +42659,44 @@ var init_render_scheduler = __esm({
         if (this.disposed) return;
         const fallbackMs = this.currentFallbackMs();
         if (Date.now() - this.lastEventAt < fallbackMs) {
-          if (this.disposed) return;
+          this.idleFallbackRenders = 0;
           this.fallbackTimer = setTimeout(() => this.fallbackLoop(), fallbackMs);
           this.fallbackTimer.unref();
           return;
         }
-        this.schedule();
-        if (this.disposed) return;
+        if (this.idleFallbackRenders >= this.maxIdleFallbackRenders) {
+          this.fallbackTimer = void 0;
+          return;
+        }
+        this.armDebouncedRender();
+        this.idleFallbackRenders += 1;
         this.fallbackTimer = setTimeout(() => this.fallbackLoop(), this.currentFallbackMs());
         this.fallbackTimer.unref();
       }
       schedule(payload) {
         if (this.disposed) return;
         this.lastEventAt = Date.now();
+        this.idleFallbackRenders = 0;
+        this.consecutiveCapHits = 0;
         this.invalidate(payload);
+        this.armDebouncedRender();
+        if (!this.fallbackTimer) {
+          this.fallbackTimer = setTimeout(() => this.fallbackLoop(), this.currentFallbackMs());
+          this.fallbackTimer.unref();
+        }
+      }
+      /**
+       * Arm (or re-arm) the debounce timer that triggers a single flush. Shared by
+       * real-event schedules, the fallback path, and the re-entrancy cap drain.
+       * `delay` lets the cap apply exponential backoff (R4) without touching
+       * `lastEventAt` or `onInvalidate` (those belong to real external events).
+       */
+      armDebouncedRender(delay = this.debounceMs) {
         if (this.debounceTimer) clearTimeout(this.debounceTimer);
         this.debounceTimer = setTimeout(() => {
           this.debounceTimer = void 0;
           this.flush();
-        }, this.debounceMs);
+        }, delay);
         this.debounceTimer.unref();
       }
       /**
@@ -42737,7 +42763,11 @@ var init_render_scheduler = __esm({
         } finally {
           this.rendering = false;
           if (iterations >= 5 && this.pendingRender && !this.disposed) {
-            this.schedule();
+            this.consecutiveCapHits += 1;
+            const exp = Math.min(this.consecutiveCapHits - 1, CAP_BACKOFF_MAX_EXP);
+            this.armDebouncedRender(this.debounceMs * 2 ** exp);
+          } else {
+            this.consecutiveCapHits = 0;
           }
         }
       }
@@ -42763,6 +42793,69 @@ var init_render_scheduler = __esm({
   }
 });
 
+// src/ui/shared-overlay-scheduler.ts
+function ensureShared() {
+  if (shared) return shared;
+  const renderers = /* @__PURE__ */ new Set();
+  const invalidators = /* @__PURE__ */ new Set();
+  const scheduler = new RenderScheduler(
+    runEventBusAsRenderScheduler([...CHANNELS]),
+    () => {
+      for (const render of renderers) {
+        try {
+          render();
+        } catch (error) {
+          logInternalError("shared-overlay-scheduler.render", error);
+        }
+      }
+    },
+    {
+      debounceMs: 75,
+      fallbackMs: 750,
+      events: [...CHANNELS],
+      onInvalidate: (payload) => {
+        for (const invalidate of invalidators) {
+          try {
+            invalidate(payload);
+          } catch (error) {
+            logInternalError("shared-overlay-scheduler.invalidate", error);
+          }
+        }
+      }
+    }
+  );
+  shared = { scheduler, renderers, invalidators };
+  return shared;
+}
+function registerOverlayScheduler(render, onInvalidate) {
+  const state = ensureShared();
+  state.renderers.add(render);
+  if (onInvalidate) state.invalidators.add(onInvalidate);
+  return {
+    schedule: () => {
+      state.scheduler.schedule();
+    },
+    dispose: () => {
+      state.renderers.delete(render);
+      if (onInvalidate) state.invalidators.delete(onInvalidate);
+      if (state.renderers.size === 0) {
+        state.scheduler.dispose();
+        if (shared === state) shared = void 0;
+      }
+    }
+  };
+}
+var CHANNELS, shared;
+var init_shared_overlay_scheduler = __esm({
+  "src/ui/shared-overlay-scheduler.ts"() {
+    "use strict";
+    init_internal_error();
+    init_render_scheduler();
+    init_run_event_bus();
+    CHANNELS = ["run:state", "worker:lifecycle", "ui:invalidate"];
+  }
+});
+
 // src/runtime/stale-reconciler.ts
 import * as fs67 from "node:fs";
 import * as os14 from "node:os";
@@ -44047,15 +44140,14 @@ function stopCrewWidget(ctx, state, config) {
     requestRender(ctx);
   }
 }
-var MAX_LINES_DEFAULT, LEGACY_WIDGET_KEY, WIDGET_KEY, STATUS_KEY, resizeListenerInstalled, activeResizeTarget, CrewWidgetComponent;
+var MAX_LINES_DEFAULT, LEGACY_WIDGET_KEY, WIDGET_KEY, STATUS_KEY, SIGNATURE_CACHE_TTL_MS, resizeListenerInstalled, activeResizeTarget, CrewWidgetComponent;
 var init_widget = __esm({
   "src/ui/widget/index.ts"() {
     "use strict";
     init_defaults();
     init_visual();
     init_pi_ui_compat();
-    init_render_scheduler();
-    init_run_event_bus();
+    init_shared_overlay_scheduler();
     init_spinner();
     init_theme_adapter();
     init_widget_model();
@@ -44068,18 +44160,22 @@ var init_widget = __esm({
     LEGACY_WIDGET_KEY = "pi-crew";
     WIDGET_KEY = "pi-crew-active";
     STATUS_KEY = "pi-crew";
+    SIGNATURE_CACHE_TTL_MS = 100;
     resizeListenerInstalled = false;
     CrewWidgetComponent = class {
       model;
       theme;
       cacheSignature = "";
+      /** C4 — invalidate-on-write cache for the buildSignature() result. */
+      cachedBuildSignature = "";
+      cachedBuildSignatureAt = 0;
       cachedWidth = 0;
       cachedLines = [];
       cachedBaseLines = [];
       cachedTheme;
       tui;
       unsubscribeTheme;
-      renderScheduler;
+      schedulerHandle;
       constructor(model, themeLike, tui) {
         this.model = model;
         this.theme = asCrewTheme(themeLike);
@@ -44088,13 +44184,11 @@ var init_widget = __esm({
         activeResizeTarget = this;
         installResizeListener();
         this.unsubscribeTheme = subscribeThemeChange(themeLike, () => this.invalidate());
-        this.renderScheduler = new RenderScheduler(
-          runEventBusAsRenderScheduler(["run:state", "worker:lifecycle", "ui:invalidate"]),
+        this.schedulerHandle = registerOverlayScheduler(
           () => this.invalidate(),
-          {
-            debounceMs: 75,
-            fallbackMs: 750,
-            events: ["run:state", "worker:lifecycle", "ui:invalidate"]
+          () => {
+            this.cachedBuildSignature = "";
+            this.cachedBuildSignatureAt = 0;
           }
         );
       }
@@ -44130,6 +44224,8 @@ var init_widget = __esm({
         this.cacheSignature = "";
         this.cachedBaseLines = [];
         this.cachedLines = [];
+        this.cachedBuildSignature = "";
+        this.cachedBuildSignatureAt = 0;
       }
       /** Poke the host TUI to repaint immediately (defensive: no-op if unavailable). */
       requestRepaint() {
@@ -44137,12 +44233,21 @@ var init_widget = __esm({
       }
       dispose() {
         this.unsubscribeTheme();
-        this.renderScheduler.dispose();
+        this.schedulerHandle.dispose();
         if (activeResizeTarget === this) activeResizeTarget = void 0;
       }
       render(width) {
         const runs = activeWidgetRuns(this.model.cwd, this.model.manifestCache, this.model.snapshotCache, this.model.preloadManifests);
-        const signature = `${this.buildSignature(runs)}:${this.model.notificationCount ?? 0}`;
+        const now = Date.now();
+        let sigBase;
+        if (this.cachedBuildSignature !== "" && now - this.cachedBuildSignatureAt < SIGNATURE_CACHE_TTL_MS) {
+          sigBase = this.cachedBuildSignature;
+        } else {
+          sigBase = this.buildSignature(runs);
+          this.cachedBuildSignature = sigBase;
+          this.cachedBuildSignatureAt = now;
+        }
+        const signature = `${sigBase}:${this.model.notificationCount ?? 0}`;
         const runningGlyph = spinnerFrame("widget-header");
         if (this.cacheSignature !== signature || width !== this.cachedWidth || this.cachedTheme !== this.theme) {
           this.cachedBaseLines = buildWidgetLines(
@@ -60928,7 +61033,7 @@ function groupedRuns(runs, snapshotCache) {
 function selectedRunFromGrouped(runs, selected, snapshotCache) {
   return groupedRuns(runs, snapshotCache).filter((row) => row.run)[selected]?.run;
 }
-var lastActivePane, TASK_READ_TTL_MS2, RUN_LIST_MAX, SIGNATURE_CACHE_TTL_MS, STALE_SNAPSHOT_MS, RunDashboard;
+var lastActivePane, TASK_READ_TTL_MS2, RUN_LIST_MAX, SIGNATURE_CACHE_TTL_MS2, STALE_SNAPSHOT_MS, RunDashboard;
 var init_run_dashboard = __esm({
   "src/ui/run-dashboard.ts"() {
     "use strict";
@@ -60950,8 +61055,7 @@ var init_run_dashboard = __esm({
     init_dynamic_border();
     init_keybinding_map();
     init_help_overlay();
-    init_render_scheduler();
-    init_run_event_bus();
+    init_shared_overlay_scheduler();
     init_spinner();
     init_status_colors();
     init_theme_adapter();
@@ -60959,7 +61063,7 @@ var init_run_dashboard = __esm({
     lastActivePane = "agents";
     TASK_READ_TTL_MS2 = 1e3;
     RUN_LIST_MAX = 8;
-    SIGNATURE_CACHE_TTL_MS = 100;
+    SIGNATURE_CACHE_TTL_MS2 = 100;
     STALE_SNAPSHOT_MS = 15e3;
     RunDashboard = class _RunDashboard {
       // TEMP DIAGNOSTIC (remove after verifying keybind fix on Pi 0.81.1)
@@ -60983,7 +61087,7 @@ var init_run_dashboard = __esm({
       cachedSignatureAt = 0;
       cachedSignature = "";
       unsubscribeTheme;
-      renderScheduler;
+      schedulerHandle;
       constructor(runs, done, theme = {}, options = {}) {
         this._instanceId = ++_RunDashboard._instanceCounter;
         try {
@@ -61001,19 +61105,10 @@ var init_run_dashboard = __esm({
         const renderTick = () => {
           this.invalidateAndRender();
         };
-        this.renderScheduler = new RenderScheduler(
-          runEventBusAsRenderScheduler(["run:state", "worker:lifecycle", "ui:invalidate"]),
-          renderTick,
-          {
-            debounceMs: 75,
-            fallbackMs: 750,
-            events: ["run:state", "worker:lifecycle", "ui:invalidate"],
-            onInvalidate: () => {
-              this.cachedSignature = "";
-              this.cachedSignatureAt = 0;
-            }
-          }
-        );
+        this.schedulerHandle = registerOverlayScheduler(renderTick, () => {
+          this.cachedSignature = "";
+          this.cachedSignatureAt = 0;
+        });
         this.unsubscribeTheme = subscribeThemeChange(theme, () => this.scheduleRender());
       }
       /**
@@ -61027,8 +61122,8 @@ var init_run_dashboard = __esm({
        * (defensive — currently always created in the constructor).
        */
       scheduleRender() {
-        if (this.renderScheduler) {
-          this.renderScheduler.schedule();
+        if (this.schedulerHandle) {
+          this.schedulerHandle.schedule();
           return;
         }
         this.invalidateAndRender();
@@ -61098,7 +61193,7 @@ var init_run_dashboard = __esm({
       }
       buildSignature() {
         const now = Date.now();
-        if (this.cachedSignature && now - this.cachedSignatureAt < SIGNATURE_CACHE_TTL_MS) {
+        if (this.cachedSignature && now - this.cachedSignatureAt < SIGNATURE_CACHE_TTL_MS2) {
           return this.cachedSignature;
         }
         let hasRunning = false;
@@ -61125,7 +61220,7 @@ var init_run_dashboard = __esm({
       }
       dispose() {
         this.unsubscribeTheme();
-        this.renderScheduler?.dispose();
+        this.schedulerHandle?.dispose();
       }
       selectedRunId() {
         return selectedRunFromGrouped(this.runs, this.selected, this.options.snapshotCache)?.runId;
@@ -62075,6 +62170,7 @@ var init_mascot = __esm({
       currentArminGrid;
       effectState = {};
       effectDone = false;
+      visible = true;
       frame = 0;
       effectPhase = 0;
       gridVersion = 0;
@@ -62170,7 +62266,7 @@ var init_mascot = __esm({
           this.gridVersion++;
         }
         this.invalidate();
-        this.requestRender?.();
+        if (this.visible) this.requestRender?.();
       }
       tickArminEffect() {
         switch (this.effect) {
@@ -62377,6 +62473,14 @@ var init_mascot = __esm({
           this.close();
         }
       }
+      /**
+       * Set whether the mascot is currently visible (not obscured by another
+       * overlay).  When invisible, tick() skips requestRender so the animation
+       * does not trigger needless repaints while hidden.
+       */
+      setVisible(visible) {
+        this.visible = visible;
+      }
       dispose() {
         this.doneGuard.called = true;
         if (this.interval) clearInterval(this.interval);
@@ -64895,8 +64999,7 @@ var init_live_run_sidebar = __esm({
     init_usage();
     init_file_coalescer();
     init_visual();
-    init_render_scheduler();
-    init_run_event_bus();
+    init_shared_overlay_scheduler();
     init_spinner();
     init_status_colors();
     init_theme_adapter();
@@ -64909,7 +65012,7 @@ var init_live_run_sidebar = __esm({
       theme;
       config;
       unsubscribeTheme;
-      renderScheduler;
+      schedulerHandle;
       snapshotCache;
       cachedLines = [];
       cachedWidth = 0;
@@ -64924,15 +65027,7 @@ var init_live_run_sidebar = __esm({
         this.config = input.config ?? {};
         this.snapshotCache = input.snapshotCache;
         this.unsubscribeTheme = subscribeThemeChange(input.theme, () => this.invalidate());
-        this.renderScheduler = new RenderScheduler(
-          runEventBusAsRenderScheduler(["run:state", "worker:lifecycle", "ui:invalidate"]),
-          () => this.invalidate(),
-          {
-            debounceMs: 75,
-            fallbackMs: 750,
-            events: ["run:state", "worker:lifecycle", "ui:invalidate"]
-          }
-        );
+        this.schedulerHandle = registerOverlayScheduler(() => this.invalidate());
       }
       buildSignature(manifestStatus, tasks, agents, waitingCount, snapshot) {
         const animation = agents.some((agent) => agent.status === "running") ? `:spin=${spinnerBucket()}` : "";
@@ -64970,7 +65065,7 @@ var init_live_run_sidebar = __esm({
           this.autoCloseTimeout = void 0;
         }
         this.unsubscribeTheme();
-        this.renderScheduler.dispose();
+        this.schedulerHandle.dispose();
       }
       render(width) {
         const w = Math.max(36, width);