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

package/dist/index.mjs

@@ -308,10 +308,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "9277ba79593a0feae0e17de0204856825a199ebe" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "9277ba79" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = 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:56:44.269Z" : 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 version = 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:20:52.196Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -10261,7 +10261,11 @@ function injectMeshSystemMessage(components, args) {
         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 {
     }
@@ -10620,7 +10624,7 @@ function injectMeshSystemMessage(components, args) {
     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 } : {}
@@ -17159,6 +17163,13 @@ function validateFsmSpec(raw) {
       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;
@@ -31494,6 +31505,14 @@ var FsmDriver = class {
   /** 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;
@@ -31534,11 +31553,18 @@ var FsmDriver = class {
     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) {
@@ -31599,6 +31625,10 @@ var FsmDriver = class {
       clearTimeout(this.wakeTimer);
       this.wakeTimer = null;
     }
+    if (this.stallTimer) {
+      clearTimeout(this.stallTimer);
+      this.stallTimer = null;
+    }
     this.specWatcher?.close();
     this.adapter.kill();
   }
@@ -31739,11 +31769,13 @@ var FsmDriver = class {
       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) {
@@ -31891,6 +31923,67 @@ var FsmDriver = class {
       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) {
+      LOG.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);
@@ -35137,6 +35230,12 @@ var CliProviderInstance = class _CliProviderInstance {
       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) {