@adhdev/daemon-standalone 0.9.77-rc.3 → 0.9.77-rc.31

package/dist/index.js

@@ -32202,6 +32202,7 @@ Follow these recovery rules:
         message,
         status: "pending",
         targetNodeId: opts?.targetNodeId,
+        targetSessionId: opts?.targetSessionId,
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
@@ -32219,9 +32220,12 @@ Follow these recovery rules:
     }
     function claimNextTask(meshId, nodeId, sessionId) {
       const queue = readQueue(meshId);
-      let targetIdx = queue.findIndex((q2) => q2.status === "pending" && q2.targetNodeId === nodeId);
+      let targetIdx = queue.findIndex((q2) => q2.status === "pending" && q2.targetSessionId === sessionId);
       if (targetIdx === -1) {
-        targetIdx = queue.findIndex((q2) => q2.status === "pending" && !q2.targetNodeId);
+        targetIdx = queue.findIndex((q2) => q2.status === "pending" && q2.targetNodeId === nodeId && !q2.targetSessionId);
+      }
+      if (targetIdx === -1) {
+        targetIdx = queue.findIndex((q2) => q2.status === "pending" && !q2.targetNodeId && !q2.targetSessionId);
       }
       if (targetIdx === -1) return null;
       const entry = queue[targetIdx];
@@ -32530,22 +32534,47 @@ Follow these recovery rules:
       ].filter(Boolean);
       return parts.length > 0 ? ` (${parts.join("; ")})` : "";
     }
+    function getMeshWithCache(components, meshId) {
+      const localMesh = getMesh(meshId);
+      if (localMesh) return localMesh;
+      return components.router?.getCachedInlineMesh(meshId);
+    }
     function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType) {
       const task = claimNextTask(meshId, nodeId, sessionId);
-      if (!task) return false;
+      if (!task) {
+        return false;
+      }
       LOG2.info("MeshQueue", `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
+      const mesh = getMeshWithCache(components, meshId);
+      const node = mesh?.nodes.find((n) => n.id === nodeId);
+      if (node?.daemonId && components.dispatchMeshCommand) {
+        const isLocalNode = components.cliManager.adapters.has(sessionId);
+        if (!isLocalNode) {
+          components.dispatchMeshCommand(node.daemonId, "agent_command", {
+            targetSessionId: sessionId,
+            cliType: providerType,
+            action: "send_chat",
+            message: task.message
+          }).catch((e) => {
+            LOG2.error("MeshQueue", `Failed to dispatch task via P2P to remote node ${nodeId}: ${e?.message}`);
+            updateTaskStatus(meshId, task.id, "failed");
+          });
+          return true;
+        }
+      }
       components.cliManager.handleCliCommand("agent_command", {
         targetSessionId: sessionId,
         cliType: providerType,
         action: "send_chat",
-        input: task.message
+        message: task.message
       }).catch((e) => {
-        LOG2.error("MeshQueue", `Failed to dispatch task to node ${nodeId}: ${e?.message}`);
+        LOG2.error("MeshQueue", `Failed to dispatch task locally to node ${nodeId}: ${e?.message}`);
+        updateTaskStatus(meshId, task.id, "failed");
       });
       return true;
     }
     function triggerMeshQueue(components, meshId) {
-      const mesh = getMesh(meshId);
+      const mesh = getMeshWithCache(components, meshId);
       if (!mesh) return;
       const cliInstances = components.instanceManager.getByCategory("cli");
       for (const inst of cliInstances) {
@@ -32562,6 +32591,15 @@ Follow these recovery rules:
           tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType);
         }
       }
+      for (const [key, idle] of remoteIdleSessions.entries()) {
+        const node = mesh.nodes.find((n) => n.id === idle.nodeId);
+        if (node) {
+          const assigned = tryAssignQueueTask(components, meshId, idle.nodeId, idle.sessionId, idle.providerType);
+          if (assigned) {
+            remoteIdleSessions.delete(key);
+          }
+        }
+      }
     }
     function buildMeshSystemMessage(args) {
       const metadata = formatCompletionMetadata(args.metadataEvent);
@@ -32610,7 +32648,7 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
     function injectMeshSystemMessage(components, args) {
       if (args.event === "agent:generating_completed") {
         const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
-        const nodeId = readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+        const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         const providerType = readNonEmptyString(args.metadataEvent.providerType);
         if (sessionId) {
           updateSessionTaskStatus(args.meshId, sessionId, "completed");
@@ -32620,8 +32658,31 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
             }, 500);
           }
         }
+      } else if (args.event === "agent:ready") {
+        const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
+        const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+        const providerType = readNonEmptyString(args.metadataEvent.providerType);
+        if (sessionId && nodeId && providerType) {
+          remoteIdleSessions.set(`${nodeId}:${sessionId}`, { nodeId, sessionId, providerType });
+          setTimeout(() => {
+            const assigned = tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
+            if (assigned) {
+              remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+            }
+          }, 500);
+        }
+      } else if (args.event === "agent:generating_started") {
+        const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
+        const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+        if (sessionId && nodeId) {
+          remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+        }
       } else if (args.event === "agent:stopped") {
         const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
+        const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+        if (sessionId && nodeId) {
+          remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+        }
         if (sessionId) {
           updateSessionTaskStatus(args.meshId, sessionId, "failed");
         }
@@ -32631,7 +32692,7 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
         try {
           appendLedgerEntry(args.meshId, {
             kind: ledgerKind,
-            nodeId: readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || void 0,
+            nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || void 0,
             sessionId: readNonEmptyString(args.metadataEvent.targetSessionId) || void 0,
             providerType: readNonEmptyString(args.metadataEvent.providerType) || void 0,
             payload: {
@@ -32651,7 +32712,7 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
           const maxRetries = mesh?.policy?.maxTaskRetries ?? 1;
           recoveryContext = getSessionRecoveryContext(args.meshId, {
             sessionId: readNonEmptyString(args.metadataEvent.targetSessionId) || void 0,
-            nodeId: readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || void 0,
+            nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || void 0,
             maxRetries
           });
           recoveryContext.failedProviderType = readNonEmptyString(args.metadataEvent.providerType) || null;
@@ -32746,6 +32807,7 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
       const nodeLabel = nodeId ? `Node '${nodeId}'` : workspace ? `Agent at ${workspace}` : "Remote agent";
       return injectMeshSystemMessage(components, {
         meshId,
+        nodeId,
         nodeLabel,
         event: eventName,
         metadataEvent: {
@@ -32770,21 +32832,24 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
         const meshIdFromRuntime = readNonEmptyString(settings.meshNodeFor);
         const isMeshDelegate = Boolean(meshIdFromRuntime || settings.launchedByCoordinator);
         if (!isMeshDelegate) return;
-        const mesh = meshIdFromRuntime ? getMesh(meshIdFromRuntime) : getMeshByRepo(workspace);
+        const mesh = meshIdFromRuntime ? getMeshWithCache(components, meshIdFromRuntime) : getMeshByRepo(workspace);
         const meshId = meshIdFromRuntime || readNonEmptyString(mesh?.id);
         if (!meshId) return;
         const targetNode = mesh?.nodes?.find((n) => n.workspace === workspace);
         const runtimeNodeId = readNonEmptyString(settings.meshNodeId);
+        const resolvedNodeId = targetNode?.id || runtimeNodeId;
         const nodeLabel = targetNode ? `Node '${targetNode.id}'` : runtimeNodeId ? `Node '${runtimeNodeId}'` : `Agent at ${workspace}`;
         injectMeshSystemMessage(components, {
           meshId,
           sourceInstanceId: instanceId,
+          nodeId: resolvedNodeId,
           nodeLabel,
           event: event.event,
           metadataEvent: event
         });
       });
     }
+    var remoteIdleSessions;
     var MAX_PENDING_EVENTS;
     var pendingMeshCoordinatorEvents;
     var MESH_COORDINATOR_EVENTS;
@@ -32796,12 +32861,14 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
         init_logger();
         init_mesh_ledger();
         init_mesh_work_queue();
+        remoteIdleSessions = /* @__PURE__ */ new Map();
         MAX_PENDING_EVENTS = 50;
         pendingMeshCoordinatorEvents = [];
         MESH_COORDINATOR_EVENTS = /* @__PURE__ */ new Set([
           "agent:generating_completed",
           "agent:waiting_approval",
           "agent:stopped",
+          "agent:ready",
           "monitor:long_generating"
         ]);
         EVENT_TO_LEDGER_KIND = {
@@ -33914,6 +33981,8 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
           statusHistory = [];
           // ─── CLI Scripts (script-based parsing) ───
           cliScripts;
+          /** Per-session opaque state object created by cliScripts.createState(), reset on stop. */
+          scriptState = null;
           runtimeSettings = {};
           /** Full accumulated rendered PTY transcript for parser/readback use */
           accumulatedBuffer = "";
@@ -34095,6 +34164,7 @@ ${lastSnapshot}`;
             this.cliScripts = scripts;
             this.parsedStatusCache = null;
             this.parseErrorMessage = null;
+            this.scriptState = typeof scripts.createState === "function" ? scripts.createState() : null;
             const scriptNames = listCliScriptNames(scripts);
             LOG2.info("CLI", `[${this.cliType}] CLI scripts injected: [${scriptNames.join(", ")}]`);
           }
@@ -34212,6 +34282,7 @@ ${lastSnapshot}`;
               this.ready = false;
               this.startupParseGate = false;
               this.spawnAt = 0;
+              this.scriptState = null;
               this.onStatusChange?.();
             });
             this.spawnAt = Date.now();
@@ -34985,7 +35056,7 @@ ${lastSnapshot}`;
                 scope: this.currentTurnScope,
                 runtimeSettings: this.runtimeSettings
               });
-              const session = this.cliScripts.parseSession({ ...input, tail, tailScreen: buildCliScreenSnapshot(tail) });
+              const session = this.cliScripts.parseSession(this.scriptState, { ...input, tail, tailScreen: buildCliScreenSnapshot(tail) });
               this.parseErrorMessage = null;
               return session && typeof session === "object" ? session : null;
             } catch (e) {
@@ -34999,7 +35070,7 @@ ${lastSnapshot}`;
             if (!this.cliScripts?.detectStatus) return null;
             try {
               const screenText = this.terminalScreen.getText();
-              const status = this.cliScripts.detectStatus({
+              const status = this.cliScripts.detectStatus(this.scriptState, {
                 tail: text.slice(-500),
                 screenText,
                 rawBuffer: this.accumulatedRawBuffer,
@@ -35018,7 +35089,7 @@ ${lastSnapshot}`;
             try {
               const screenText = this.terminalScreen.getText();
               const buffer = screenText || this.accumulatedBuffer;
-              return this.cliScripts.parseApproval({
+              return this.cliScripts.parseApproval(this.scriptState, {
                 buffer,
                 screenText,
                 rawBuffer: this.accumulatedRawBuffer,
@@ -35126,7 +35197,7 @@ ${lastSnapshot}`;
               scope: this.currentTurnScope,
               runtimeSettings: this.runtimeSettings
             });
-            return await Promise.resolve(fn2({
+            return await Promise.resolve(fn2(this.scriptState, {
               ...input,
               args: args && typeof args === "object" ? { ...args } : {}
             }));
@@ -46296,11 +46367,13 @@ ${effect.notification.body || ""}`.trim();
     async function handlePtyInput(h, args) {
       const { cliType, data, targetSessionId } = args || {};
       if (!data) return { success: false, error: "data required" };
+      const cleanData = typeof data === "string" ? data.replace(/\x1b\[[?>][0-9;]*c/g, "") : data;
+      if (!cleanData) return { success: true };
       const adapter = h.getCliAdapter(targetSessionId || cliType);
       if (!adapter || typeof adapter.writeRaw !== "function") {
         return { success: false, error: `CLI adapter not found: ${targetSessionId || cliType || "unknown"}` };
       }
-      await adapter.writeRaw(data);
+      await adapter.writeRaw(cleanData);
       return { success: true };
     }
     function handlePtyResize(_h, args) {
@@ -47918,6 +47991,8 @@ ${effect.notification.body || ""}`.trim();
                 this.completedDebounceTimer = null;
               }, 3e3);
             }
+          } else if (newStatus === "idle" && this.lastStatus === "starting") {
+            this.pushEvent({ event: "agent:ready", chatTitle, timestamp: now });
           } else if (newStatus === "stopped") {
             if (this.generatingDebounceTimer) {
               clearTimeout(this.generatingDebounceTimer);
@@ -49653,9 +49728,6 @@ ${rawInput}` : rawInput;
       const cliType = String(input.cliType || "").trim();
       const cliArgs = Array.isArray(input.cliArgs) ? [...input.cliArgs] : [];
       const env2 = { ...input.env || {}, ...COORDINATOR_DELEGATED_ENV_UNSETS };
-      if (cliType === "hermes-cli" && !hasCliArg(cliArgs, "--ignore-user-config")) {
-        cliArgs.unshift("--ignore-user-config");
-      }
       if (cliType === "claude-cli" && !hasCliArg(cliArgs, "--mcp-config")) {
         cliArgs.unshift("--mcp-config", ensureEmptyDelegatedMcpConfig(input.workspace));
       }
@@ -52970,6 +53042,22 @@ Run 'adhdev doctor' for detailed diagnostics.`
         if (!instructions || !template?.trim()) {
           return { kind: "unsupported", reason: "Provider manual MCP setup is missing instructions or template" };
         }
+        const renderedTemplate = renderMeshCoordinatorTemplate(template, {
+          meshId,
+          workspace,
+          serverName,
+          adhdevMcpCommand: options.adhdevMcpCommand || DEFAULT_ADHDEV_MCP_COMMAND
+        });
+        const isCliCommand = !renderedTemplate.trim().includes("\n") && !renderedTemplate.trim().startsWith("{");
+        if (isCliCommand) {
+          return {
+            kind: "cli_command",
+            serverName,
+            command: renderedTemplate.trim(),
+            requiresRestart: mcpConfig.requiresRestart === true,
+            instructions
+          };
+        }
         return {
           kind: "manual",
           serverName,
@@ -52977,12 +53065,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           configPathCommand: mcpConfig.configPathCommand,
           requiresRestart: mcpConfig.requiresRestart === true,
           instructions,
-          template: renderMeshCoordinatorTemplate(template, {
-            meshId,
-            workspace,
-            serverName,
-            adhdevMcpCommand: options.adhdevMcpCommand || DEFAULT_ADHDEV_MCP_COMMAND
-          })
+          template: renderedTemplate
         };
       }
       return {
@@ -55156,6 +55239,93 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                   meshCoordinatorSetup: coordinatorSetup
                 };
               }
+              if (coordinatorSetup.kind === "cli_command") {
+                let cliCmdSystemPrompt = "";
+                try {
+                  cliCmdSystemPrompt = buildCoordinatorSystemPrompt2({ mesh, coordinatorCliType: cliType });
+                } catch (error48) {
+                  const message = error48?.message || String(error48);
+                  LOG2.error("MeshCoordinator", `Failed to build coordinator prompt: ${message}`);
+                  return {
+                    success: false,
+                    code: "mesh_coordinator_prompt_failed",
+                    error: `Failed to build Repo Mesh coordinator prompt: ${message}`,
+                    meshId,
+                    cliType,
+                    workspace
+                  };
+                }
+                try {
+                  const { execFileSync: execCmdSync } = await import("child_process");
+                  const cmdParts = coordinatorSetup.command.trim().split(/\s+/);
+                  const [regCmd, ...regArgs] = cmdParts;
+                  LOG2.info("MeshCoordinator", `Running MCP registration: ${coordinatorSetup.command}`);
+                  execCmdSync(regCmd, regArgs, { stdio: "pipe", timeout: 15e3 });
+                } catch (error48) {
+                  LOG2.warn("MeshCoordinator", `MCP registration command failed (may be pre-registered): ${error48?.message || error48}`);
+                }
+                const cliCmdArgs = [];
+                const cliCmdEnv = {};
+                if (cliCmdSystemPrompt) {
+                  if (cliType === "codex-cli") {
+                    cliCmdArgs.push("-c", `developer_instructions=${JSON.stringify(cliCmdSystemPrompt)}`);
+                  } else if (cliType === "gemini-cli") {
+                    try {
+                      const { writeFileSync: wfs, existsSync: efs, readFileSync: rfs } = await import("fs");
+                      const geminiMdPath = `${workspace}/GEMINI.md`;
+                      const marker = "<!-- adhdev-mesh-coordinator-prompt -->";
+                      const markerEnd = "<!-- /adhdev-mesh-coordinator-prompt -->";
+                      const block = `${marker}
+${cliCmdSystemPrompt}
+${markerEnd}`;
+                      if (efs(geminiMdPath)) {
+                        const existing = rfs(geminiMdPath, "utf-8");
+                        const replaced = existing.replace(
+                          new RegExp(`${marker}[\\s\\S]*?${markerEnd}`, "g"),
+                          block
+                        );
+                        wfs(geminiMdPath, replaced.includes(marker) ? replaced : `${existing}
+
+${block}`);
+                      } else {
+                        wfs(geminiMdPath, block);
+                      }
+                      LOG2.info("MeshCoordinator", `Wrote coordinator prompt to ${workspace}/GEMINI.md`);
+                    } catch (e) {
+                      LOG2.warn("MeshCoordinator", `Could not write GEMINI.md: ${e?.message || e}`);
+                    }
+                  }
+                }
+                const cliCmdLaunch = await this.deps.cliManager.handleCliCommand("launch_cli", {
+                  cliType,
+                  dir: workspace,
+                  cliArgs: cliCmdArgs.length > 0 ? cliCmdArgs : void 0,
+                  env: Object.keys(cliCmdEnv).length > 0 ? cliCmdEnv : void 0,
+                  settings: { meshCoordinatorFor: meshId }
+                });
+                if (!cliCmdLaunch?.success) {
+                  return { success: false, error: cliCmdLaunch?.error || "Failed to launch CLI session" };
+                }
+                LOG2.info("MeshCoordinator", `Launched ${cliType} coordinator (cli_command) for mesh ${meshId}`);
+                try {
+                  const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+                  appendLedgerEntry2(meshId, {
+                    kind: "coordinator_started",
+                    sessionId: cliCmdLaunch.sessionId || cliCmdLaunch.id,
+                    providerType: cliType,
+                    payload: { workspace }
+                  });
+                } catch {
+                }
+                return {
+                  success: true,
+                  meshId,
+                  cliType,
+                  workspace,
+                  sessionId: cliCmdLaunch.sessionId || cliCmdLaunch.id,
+                  mcpRegistered: true
+                };
+              }
               const configFormat = coordinatorSetup.configFormat;
               if (configFormat !== "claude_mcp_json" && configFormat !== "hermes_config_yaml") {
                 return {
@@ -63202,7 +63372,8 @@ data: ${JSON.stringify(msg.data)}
         cdpManagers,
         sessionRegistry,
         detectedIdes: detectedIdesRef,
-        refreshProviderAvailability
+        refreshProviderAvailability,
+        dispatchMeshCommand: config2.dispatchMeshCommand
       };
       setupMeshEventForwarding(components);
       return components;