@adhdev/daemon-core 0.9.82-rc.339 → 0.9.82-rc.340

package/dist/commands/router.d.ts

@@ -310,6 +310,25 @@ export declare class DaemonCommandRouter {
     private getCachedAggregateMeshStatus;
     private rememberAggregateMeshStatus;
     getCachedInlineMeshNodes(): any[];
+    /**
+     * Resolve the REMOTE worker daemonId that owns a given session, when the session
+     * belongs to a mesh node hosted on a DIFFERENT daemon than this coordinator.
+     *
+     * The coordinator does not host remote-worker session instances in its own
+     * instanceManager/sessionRegistry — only their cached mesh-node metadata. A
+     * dashboard-issued session-scoped command (invoke_provider_script / resolve_action /
+     * set_mode / …) lands on the coordinator with a targetSessionId the coordinator can't
+     * find locally, and without forwarding it dies as "Live session not found". send_chat
+     * happens to survive (its target resolves to the worker by another route), but the
+     * controlbar commands do not — so the controlbar buttons appear to do nothing.
+     *
+     * Mirror the existing node-level remote-forward pattern (fast_forward_mesh_node etc.):
+     * scan the cached inline-mesh nodes for the one whose active session matches the
+     * targetSessionId, and return its daemonId when that daemonId is a remote daemon (i.e.
+     * not this coordinator's own statusInstanceId). Returns undefined for a locally-hosted
+     * session (no forward — execute locally as before) or when ownership can't be resolved.
+     */
+    resolveRemoteMeshSessionOwnerDaemonId(sessionId: string): string | undefined;
     getCachedInlineMesh(meshId: string, inlineMesh?: unknown): any | undefined;
     private warmInlineMeshCache;
     private getMeshForCommand;

package/dist/index.js

@@ -316,10 +316,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "042075899bbd2feb9c22f9ccd01990408323443d" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "04207589" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.339" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-20T12:40:45.079Z" : void 0);
+  const commit = readInjected(true ? "4208ff17576c4e0d480e0773908bb522545f006f" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "4208ff17" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.340" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-20T14:30:26.030Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -44442,6 +44442,16 @@ function readCachedInlineMeshActiveSessionDetails(node) {
     startedAt: readStringValue(fallbackSession.startedAt, fallbackSession.started_at) ?? null,
     lastActivityAt: readStringValue(fallbackSession.lastActivityAt, fallbackSession.last_activity_at) ?? null,
     recoveryState: readStringValue(fallbackSession.recoveryState, fallbackSession.recovery_state) ?? null,
+    // [T2] Carry the worker-computed last-message preview through the cached inline-mesh
+    // active-session entry. The worker's get_status_metadata slim now ships these
+    // (mesh-tools.ts), and this is the surface the coordinator's inbox-preview path reads
+    // (buildDaemonMetadataUpdateForSubscription → stampLocalAssistantPreviewOnCachedEntry).
+    // Without carrying them here, the coordinator could only derive the preview from a live
+    // in-process instance it doesn't host for a remote worker, so the inbox stuck on the
+    // dispatched user task. Only present when the worker reported them.
+    ...readStringValue(fallbackSession.lastMessagePreview, fallbackSession.last_message_preview) ? { lastMessagePreview: readStringValue(fallbackSession.lastMessagePreview, fallbackSession.last_message_preview) } : {},
+    ...readStringValue(fallbackSession.lastMessageRole, fallbackSession.last_message_role) ? { lastMessageRole: readStringValue(fallbackSession.lastMessageRole, fallbackSession.last_message_role) } : {},
+    ...readNumberValue(fallbackSession.lastMessageAt, fallbackSession.last_message_at) !== void 0 ? { lastMessageAt: readNumberValue(fallbackSession.lastMessageAt, fallbackSession.last_message_at) } : {},
     isCached: true
   }];
 }
@@ -45931,6 +45941,13 @@ var CHAT_COMMANDS = [
   "set_mode",
   "change_model"
 ];
+var MESH_FORWARDABLE_SESSION_COMMANDS = /* @__PURE__ */ new Set([
+  "invoke_provider_script",
+  "resolve_action",
+  "set_mode",
+  "change_model",
+  "set_thought_level"
+]);
 var READ_DEBUG_ENABLED2 = process.argv.includes("--dev") || process.env.ADHDEV_READ_DEBUG === "1";
 function normalizeCommandSource(source) {
   switch (source) {
@@ -46247,6 +46264,38 @@ var DaemonCommandRouter = class {
     }
     return nodes;
   }
+  /**
+   * Resolve the REMOTE worker daemonId that owns a given session, when the session
+   * belongs to a mesh node hosted on a DIFFERENT daemon than this coordinator.
+   *
+   * The coordinator does not host remote-worker session instances in its own
+   * instanceManager/sessionRegistry — only their cached mesh-node metadata. A
+   * dashboard-issued session-scoped command (invoke_provider_script / resolve_action /
+   * set_mode / …) lands on the coordinator with a targetSessionId the coordinator can't
+   * find locally, and without forwarding it dies as "Live session not found". send_chat
+   * happens to survive (its target resolves to the worker by another route), but the
+   * controlbar commands do not — so the controlbar buttons appear to do nothing.
+   *
+   * Mirror the existing node-level remote-forward pattern (fast_forward_mesh_node etc.):
+   * scan the cached inline-mesh nodes for the one whose active session matches the
+   * targetSessionId, and return its daemonId when that daemonId is a remote daemon (i.e.
+   * not this coordinator's own statusInstanceId). Returns undefined for a locally-hosted
+   * session (no forward — execute locally as before) or when ownership can't be resolved.
+   */
+  resolveRemoteMeshSessionOwnerDaemonId(sessionId) {
+    const trimmed = typeof sessionId === "string" ? sessionId.trim() : "";
+    if (!trimmed) return void 0;
+    const selfDaemonId = this.deps.statusInstanceId;
+    for (const node of this.getCachedInlineMeshNodes()) {
+      const nodeSessions = readCachedInlineMeshActiveSessions(node);
+      if (!nodeSessions.includes(trimmed)) continue;
+      const nodeDaemonId = readMeshNodeDaemonId(readObjectRecord(node));
+      if (!nodeDaemonId) return void 0;
+      if (selfDaemonId && nodeDaemonId === selfDaemonId) return void 0;
+      return nodeDaemonId;
+    }
+    return void 0;
+  }
   getCachedInlineMesh(meshId, inlineMesh) {
     if (inlineMesh && typeof inlineMesh === "object") {
       return this.warmInlineMeshCache(meshId, inlineMesh);
@@ -48192,6 +48241,24 @@ ${hintLines.join("\n")}` : "",
    * Returns null if not handled at this level → caller delegates to CommandHandler.
    */
   async executeDaemonCommand(cmd, args) {
+    if (MESH_FORWARDABLE_SESSION_COMMANDS.has(cmd) && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+      const targetSessionId = readStringValue(args?.targetSessionId, args?.sessionId, args?.instanceId);
+      if (targetSessionId) {
+        const localInstance = this.deps.instanceManager?.getInstance(targetSessionId);
+        const localRegistry = this.deps.sessionRegistry?.get?.(targetSessionId);
+        if (!localInstance && !localRegistry) {
+          const ownerDaemonId = this.resolveRemoteMeshSessionOwnerDaemonId(targetSessionId);
+          if (ownerDaemonId) {
+            LOG.info("Mesh", `[Mesh] Forwarding session-scoped '${cmd}' for remote worker session ${targetSessionId.split("_")[0]} \u2192 daemon ${ownerDaemonId.slice(0, 12)}`);
+            const forwarded = await this.deps.dispatchMeshCommand(ownerDaemonId, cmd, {
+              ...typeof args === "object" && args !== null ? args : {},
+              _meshDirectDispatch: true
+            });
+            return forwarded ?? { success: false, error: "no response from remote worker daemon" };
+          }
+        }
+      }
+    }
     switch (cmd) {
       // ─── CLI / ACP commands ───
       case "mesh_forward_event": {