@adhdev/daemon-standalone 0.9.82-rc.329 → 0.9.82-rc.330

package/dist/index.js

@@ -30033,10 +30033,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "9277ba79593a0feae0e17de0204856825a199ebe" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "9277ba79" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.329" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-19T15:57:13.250Z" : void 0);
+      const commit = readInjected(true ? "ae30dde113f601dc80d6396a625c1dafb3dbaddd" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "ae30dde1" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.330" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-19T17:21:17.821Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -40040,7 +40040,11 @@ Next step: ${nextStep}`;
             event: args.event,
             meshId: args.meshId,
             nodeId: eventNodeId || void 0,
-            ...args.metadataEvent
+            ...args.metadataEvent,
+            // Ensure a `workspace` field reaches updateMeshOwnedSession even when the
+            // worker provider event only carried `workspaceName`. The merge spread of
+            // metadataEvent above wins when it already has a non-empty `workspace`.
+            workspace: readNonEmptyString2(args.metadataEvent.workspace) || readNonEmptyString2(args.metadataEvent.workspaceName) || void 0
           });
         } catch {
         }
@@ -40399,7 +40403,7 @@ Next step: ${nextStep}`;
         meshId: args.meshId,
         nodeLabel: args.nodeLabel,
         nodeId: args.nodeId || void 0,
-        workspace: readNonEmptyString2(args.metadataEvent.workspace),
+        workspace: readNonEmptyString2(args.metadataEvent.workspace) || readNonEmptyString2(args.metadataEvent.workspaceName),
         metadataEvent: {
           ...args.metadataEvent,
           ...recoveryContext ? { recoveryContext } : {}
@@ -46951,6 +46955,13 @@ ${lastSnapshot}`;
           if (typeof t.key !== "string" || !t.key) errs.push("pre_launch_trust.key is required");
         }
       }
+      if (spec.refocus_when_stalled_ms !== void 0) {
+        if (typeof spec.refocus_when_stalled_ms !== "number" || !(spec.refocus_when_stalled_ms > 0)) {
+          errs.push("refocus_when_stalled_ms must be a positive number");
+        } else if (!Array.isArray(spec.send_on_spawn) || spec.send_on_spawn.length === 0) {
+          errs.push("refocus_when_stalled_ms requires send_on_spawn (the wake sequence to re-inject)");
+        }
+      }
       if (!Array.isArray(spec.states) || spec.states.length === 0) {
         errs.push("states[] must be a non-empty array");
         return errs;
@@ -61493,6 +61504,14 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       /** Timer that re-runs evaluate() when a time-condition would flip true
        *  with no PTY frame to trigger it. */
       wakeTimer = null;
+      /** Timer driving the focus-gated stall watchdog (refocus_when_stalled_ms).
+       *  Re-arms itself while the machine is generating so a re-prime can fire
+       *  even when the PTY has gone completely quiet. */
+      stallTimer = null;
+      /** Wall-clock time the last stall re-prime was injected. The cooldown gate:
+       *  after a re-prime we don't re-inject until the screen changes (which
+       *  resets the stall reference) or another full stall window lapses. */
+      lastRefocusAt = 0;
       currentEval = null;
       stateHistory = [];
       prevStateAt = 0;
@@ -61533,11 +61552,18 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         const seqs = this.spec.send_on_spawn;
         if (!Array.isArray(seqs) || seqs.length === 0) return;
         const delay2 = Math.max(0, this.spec.send_on_spawn_delay_ms ?? 250);
-        setTimeout(() => {
-          for (const seq of seqs) {
-            if (typeof seq === "string" && seq.length > 0) this.adapter.send_keys(seq);
-          }
-        }, delay2);
+        setTimeout(() => this.sendSpawnPrime(), delay2);
+      }
+      /** Write the declared `send_on_spawn` sequences to the PTY once. Used both
+       *  at spawn (scheduleSpawnPrime) and, for focus-gated TUIs, by the stall
+       *  watchdog to re-inject the focus-in wake mid-turn. No-op when the spec
+       *  declares no prime, so non-focus-gated CLIs are never poked. */
+      sendSpawnPrime() {
+        const seqs = this.spec.send_on_spawn;
+        if (!Array.isArray(seqs) || seqs.length === 0) return;
+        for (const seq of seqs) {
+          if (typeof seq === "string" && seq.length > 0) this.adapter.send_keys(seq);
+        }
       }
       dispatch(cmd) {
         switch (cmd.kind) {
@@ -61598,6 +61624,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           clearTimeout(this.wakeTimer);
           this.wakeTimer = null;
         }
+        if (this.stallTimer) {
+          clearTimeout(this.stallTimer);
+          this.stallTimer = null;
+        }
         this.specWatcher?.close();
         this.adapter.kill();
       }
@@ -61738,11 +61768,13 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           this.commitTransition(ev.fired, now, ev);
           this.emitStateChanged(forceEmit);
           this.scheduleWakeForState();
+          this.scheduleStallWatchdog();
           this.maybeMarkReady();
           return;
         }
         this.emitStateChanged(forceEmit);
         this.scheduleWakeForState();
+        this.scheduleStallWatchdog();
         this.maybeMarkReady();
       }
       commitTransition(fired, now, ev) {
@@ -61890,6 +61922,67 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           this.reevaluate();
         }, Math.max(soonest + 30, 50));
       }
+      // ── Focus-gated stall watchdog (refocus_when_stalled_ms) ──────────────────
+      //
+      // A focus-event TUI (antigravity's `agy`) freezes its render loop the moment
+      // it thinks it has lost focus mid-turn: the screen stops updating and only
+      // repaints on the next keypress, which the daemon never sends. The output
+      // pump is wired entirely to PTY onData (no PTY data → no reevaluate, no
+      // on_screen_changed), so a normal time-wake that only re-reads the screen
+      // can't help — there is nothing new to read. The fix is to re-inject the
+      // focus-in wake (`send_on_spawn`) so the CLI flushes the held output itself.
+      /** True when this spec opts into stall recovery (declares a positive
+       *  refocus window AND a wake sequence to re-inject). */
+      stallRecoveryEnabled() {
+        const ms = this.spec.refocus_when_stalled_ms;
+        return typeof ms === "number" && ms > 0 && Array.isArray(this.spec.send_on_spawn) && this.spec.send_on_spawn.length > 0;
+      }
+      /** Wall-clock time the screen last changed in the current state, falling
+       *  back to state entry when it has not changed since (i.e. fully stalled
+       *  from the start of the state). */
+      lastScreenChangeAt() {
+        return this.regionLastChangedAt.get(-1) ?? this.stateEnteredAt;
+      }
+      /** Arm a timer to re-inject the focus-in prime if the screen stays frozen
+       *  through a `generating` state. Only active for opted-in focus-gated specs;
+       *  a no-op (and cleared) for every other CLI and every non-generating state.
+       *  Re-arms itself so it keeps watching while the PTY is quiet. */
+      scheduleStallWatchdog() {
+        if (this.stallTimer) {
+          clearTimeout(this.stallTimer);
+          this.stallTimer = null;
+        }
+        if (!this.stallRecoveryEnabled()) return;
+        const st = stateById(this.spec, this.currentStateId);
+        if (!st || statusForState(st) !== "generating") return;
+        const windowMs = this.spec.refocus_when_stalled_ms;
+        const since = Math.max(this.lastScreenChangeAt(), this.lastRefocusAt);
+        const remaining = windowMs - (Date.now() - since);
+        this.stallTimer = setTimeout(
+          () => {
+            this.stallTimer = null;
+            this.onStallTick();
+          },
+          Math.max(remaining + 30, 50)
+        );
+      }
+      /** Fire when the stall window elapses: if the screen is still frozen and we
+       *  are still generating, re-inject the focus-in wake once, then re-arm. */
+      onStallTick() {
+        if (!this.stallRecoveryEnabled()) return;
+        const st = stateById(this.spec, this.currentStateId);
+        if (!st || statusForState(st) !== "generating") return;
+        const windowMs = this.spec.refocus_when_stalled_ms;
+        const now = Date.now();
+        const stalledFor = now - this.lastScreenChangeAt();
+        const sinceLastRefocus = now - this.lastRefocusAt;
+        if (stalledFor >= windowMs && sinceLastRefocus >= windowMs) {
+          LOG2.info("FsmDriver", `[${this.specTag()}] stall detected (${stalledFor}ms quiet, generating) \u2014 re-injecting focus-in`);
+          this.sendSpawnPrime();
+          this.lastRefocusAt = now;
+        }
+        this.scheduleStallWatchdog();
+      }
       maybeMarkReady() {
         if (this.readySeenOnce) return;
         const st = stateById(this.spec, this.currentStateId);
@@ -65120,6 +65213,12 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           targetSessionId: typeof event.targetSessionId === "string" && event.targetSessionId.trim() ? event.targetSessionId : this.instanceId,
           providerType: typeof event.providerType === "string" && event.providerType.trim() ? event.providerType : this.type,
           workspaceName: typeof event.workspaceName === "string" && event.workspaceName.trim() ? event.workspaceName : this.workingDir,
+          // Carry the workspace under BOTH `workspace` and `workspaceName` so the
+          // downstream mesh forward/merge path — which reads `workspace` — can
+          // propagate it to the coordinator snapshot. Without `workspace` the live
+          // event path delivers an empty workspace and the dashboard falls back to
+          // the generic "Terminal (Mesh Node)" title.
+          workspace: typeof event.workspace === "string" && event.workspace.trim() ? event.workspace : this.workingDir,
           providerSessionId: typeof event.providerSessionId === "string" && event.providerSessionId.trim() ? event.providerSessionId : this.providerSessionId
         };
         if (this.context?.emitProviderEvent) {