@adhdev/daemon-core 0.9.82-rc.222 → 0.9.82-rc.224

package/dist/index.js

@@ -25116,7 +25116,9 @@ async function handleReadChat(h, args) {
     const historyLimit = normalizeReadChatTailLimit(args);
     try {
       const agentStr = provider?.type || args?.agentType || getCurrentProviderType(h);
-      const workspace = typeof h.currentSession?.workspace === "string" ? h.currentSession.workspace : void 0;
+      const targetSid = typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : "";
+      const registrySessionWorkspace = targetSid ? h.ctx?.sessionRegistry?.get?.(targetSid)?.workspace : void 0;
+      const workspace = typeof h.currentSession?.workspace === "string" ? h.currentSession.workspace : typeof registrySessionWorkspace === "string" ? registrySessionWorkspace : void 0;
       const intendedWorkspace = typeof args?.workspace === "string" ? args.workspace : void 0;
       const supportsNative = supportsCliNativeTranscript(agentStr, provider) && isNativeSourceCanonicalHistory(provider?.nativeHistory);
       const history = supportsNative ? readCliProviderNativeHistory(agentStr, {
@@ -39671,7 +39673,12 @@ function applyInlineMeshBranchConvergence(mesh, node, status) {
   }
 }
 function summarizeInlineMeshBranchConvergence(nodes) {
-  const followUps = nodes.filter((node) => readObjectRecord(node.branchConvergence).needsConvergence === true).map((node) => {
+  const followUps = nodes.filter((node) => {
+    if (readObjectRecord(node.branchConvergence).needsConvergence !== true) return false;
+    const workspace = typeof node.workspace === "string" ? node.workspace : "";
+    if (workspace && !fs23.existsSync(workspace)) return false;
+    return true;
+  }).map((node) => {
     const convergence = readObjectRecord(node.branchConvergence);
     return {
       nodeId: node.nodeId,
@@ -41182,7 +41189,66 @@ var DaemonCommandRouter = class {
     } catch (e) {
       const message = String(e?.message || e || "worktree cleanup failed");
       const dirty = message.includes("dirty worktree") || message.includes("local changes");
-      const submoduleForceBlocked = /working trees containing submodules cannot be moved or removed/i.test(message) && !forceFallbackConvergence.allow;
+      const isSubmoduleGuard = /working trees containing submodules cannot be moved or removed/i.test(message);
+      const submoduleForceBlocked = isSubmoduleGuard && !forceFallbackConvergence.allow;
+      if (isSubmoduleGuard && forceFallbackConvergence.allow) {
+        const { execFile: execFile4 } = await import("child_process");
+        const { promisify: promisify7 } = await import("util");
+        const execFileAsync3 = promisify7(execFile4);
+        const GIT_TIMEOUT_CLEANUP = 3e4;
+        const GIT_MAX_BUFFER_CLEANUP = 4 * 1024 * 1024;
+        try {
+          await execFileAsync3("git", ["-C", workspace, "submodule", "deinit", "--all", "-f"], {
+            encoding: "utf8",
+            timeout: GIT_TIMEOUT_CLEANUP,
+            maxBuffer: GIT_MAX_BUFFER_CLEANUP,
+            windowsHide: true
+          });
+          await execFileAsync3("git", ["worktree", "remove", "--force", workspace], {
+            cwd: repoRoot,
+            encoding: "utf8",
+            timeout: GIT_TIMEOUT_CLEANUP,
+            maxBuffer: GIT_MAX_BUFFER_CLEANUP,
+            windowsHide: true
+          });
+          return {
+            success: true,
+            removedPath: workspace,
+            repoRoot,
+            fallback: "git_worktree_remove_submodule_deinit",
+            forced: true,
+            reason: "working_trees_containing_submodules",
+            convergence: forceFallbackConvergence
+          };
+        } catch (deinitError) {
+          try {
+            fs23.rmSync(workspace, { recursive: true, force: true });
+            await execFileAsync3("git", ["worktree", "prune"], {
+              cwd: repoRoot,
+              encoding: "utf8",
+              timeout: GIT_TIMEOUT_CLEANUP,
+              maxBuffer: GIT_MAX_BUFFER_CLEANUP,
+              windowsHide: true
+            });
+            return {
+              success: true,
+              removedPath: workspace,
+              repoRoot,
+              fallback: "fs_rm_worktree_prune",
+              forced: true,
+              reason: "working_trees_containing_submodules",
+              convergence: forceFallbackConvergence
+            };
+          } catch (rmError) {
+            return {
+              success: false,
+              code: "mesh_worktree_cleanup_failed",
+              error: `All removal fallbacks exhausted. deinit+remove: ${deinitError?.message || deinitError}; rmSync+prune: ${rmError?.message || rmError}`,
+              recoveryHint: "Manually remove the worktree directory and run git worktree prune from the source repo."
+            };
+          }
+        }
+      }
       return {
         success: false,
         code: dirty ? "mesh_worktree_cleanup_dirty" : submoduleForceBlocked ? "mesh_worktree_cleanup_force_fallback_blocked" : "mesh_worktree_cleanup_failed",
@@ -41194,9 +41260,13 @@ var DaemonCommandRouter = class {
   }
   async getWorktreeForceCleanupConvergence(args) {
     const metadataStatus = typeof args.node?.branchConvergence?.status === "string" ? args.node.branchConvergence.status : "";
-    if (metadataStatus === "merged_to_main" || metadataStatus === "cleanup_candidate") {
+    if (metadataStatus === "merged_to_main" || metadataStatus === "cleanup_candidate" || metadataStatus === "merged_pushed") {
       return { allow: true, status: metadataStatus, source: "node_branch_convergence" };
     }
+    const refinedConvergence = typeof args.node?.refineState?.finalBranchConvergenceState?.status === "string" ? args.node.refineState.finalBranchConvergenceState.status : typeof args.node?.lastRefineResult?.finalBranchConvergenceState?.status === "string" ? args.node.lastRefineResult.finalBranchConvergenceState.status : "";
+    if (refinedConvergence === "merged_pushed" || refinedConvergence === "merged_to_main") {
+      return { allow: true, status: refinedConvergence, source: "node_refine_state" };
+    }
     const { execFile: execFile4 } = await import("child_process");
     const { promisify: promisify7 } = await import("util");
     const execFileAsync3 = promisify7(execFile4);
@@ -41682,11 +41752,24 @@ var DaemonCommandRouter = class {
       if (!branch) return { success: false, error: "Could not determine branch of the worktree node", refineStages };
       const { stdout: baseBranchStdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });
       const baseBranch = baseBranchStdout.trim();
-      const { stdout: baseHeadStdout } = await execFileAsync3("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8" });
+      let fetchWarning;
+      try {
+        await execFileAsync3("git", ["fetch", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8" });
+      } catch (e) {
+        fetchWarning = `git fetch origin ${baseBranch} failed (proceeding with local HEAD): ${e?.message}`;
+      }
+      let baseHeadRaw;
+      try {
+        const { stdout } = await execFileAsync3("git", ["rev-parse", `origin/${baseBranch}`], { cwd: repoRoot, encoding: "utf8" });
+        baseHeadRaw = stdout.trim();
+      } catch {
+        const { stdout: localHead } = await execFileAsync3("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8" });
+        baseHeadRaw = localHead.trim();
+      }
       const { stdout: branchHeadStdout } = await execFileAsync3("git", ["rev-parse", branch], { cwd: node.workspace, encoding: "utf8" });
-      const baseHead = baseHeadStdout.trim();
+      const baseHead = baseHeadRaw;
       let branchHead = branchHeadStdout.trim();
-      recordMeshRefineStage(refineStages, "resolve_refs", "passed", resolveStarted, { branch, baseBranch, baseHead, branchHead });
+      recordMeshRefineStage(refineStages, "resolve_refs", "passed", resolveStarted, { branch, baseBranch, baseHead, branchHead, ...fetchWarning ? { fetchWarning } : {} });
       const validationStarted = Date.now();
       const validationSummary = await runMeshRefineValidationGate(mesh, node.workspace, {
         // M2-2: consume the node's persisted bootstrap state; persist re-runs.
@@ -41705,11 +41788,25 @@ var DaemonCommandRouter = class {
         { validationStatus: validationSummary.status, commandsRun: validationSummary.commandsRun.length }
       );
       if (validationSummary.status === "failed") {
+        const firstFailedCmd = Array.isArray(validationSummary.commandsRun) ? validationSummary.commandsRun.find((c) => c.success === false) : void 0;
+        const buildValidationFailedError = () => {
+          const base = validationSummary.failureCode === "missing_dependencies" ? "Refinery validation dependencies are missing; merge/refine was not attempted. Configure validation.bootstrapCommands if Refinery should bootstrap dependencies before validation." : validationSummary.failureCode === "dependency_bootstrap_failed" ? "Refinery dependency/bootstrap command failed; merge/refine was not attempted." : "Refinery validation gate failed; merge/refine was not attempted.";
+          if (!firstFailedCmd) return base;
+          const cmdName = typeof firstFailedCmd.displayCommand === "string" ? firstFailedCmd.displayCommand : typeof firstFailedCmd.command === "string" ? [firstFailedCmd.command, ...Array.isArray(firstFailedCmd.args) ? firstFailedCmd.args : []].join(" ").trim() : typeof firstFailedCmd.cmd === "string" ? firstFailedCmd.cmd : "";
+          const rawOutput = [firstFailedCmd.stdout, firstFailedCmd.stderr, firstFailedCmd.output].filter((s) => typeof s === "string" && s.length > 0).join("\n");
+          const tail = rawOutput.length > 800 ? rawOutput.slice(-800) : rawOutput;
+          return [
+            base,
+            cmdName ? `First failing command: ${cmdName}` : "",
+            tail ? `Output (tail):
+${tail}` : ""
+          ].filter(Boolean).join("\n");
+        };
         return {
           success: false,
           code: validationSummary.failureCode || "validation_failed",
           convergenceStatus: "blocked_review",
-          error: validationSummary.failureCode === "missing_dependencies" ? "Refinery validation dependencies are missing; merge/refine was not attempted. Configure validation.bootstrapCommands if Refinery should bootstrap dependencies before validation." : validationSummary.failureCode === "dependency_bootstrap_failed" ? "Refinery dependency/bootstrap command failed; merge/refine was not attempted." : "Refinery validation gate failed; merge/refine was not attempted.",
+          error: buildValidationFailedError(),
           branch,
           into: baseBranch,
           validationSummary,
@@ -42311,13 +42408,54 @@ var DaemonCommandRouter = class {
         this.deps.instanceManager.sendEvent(sessionId, "interactive_prompt_response", response);
         return { success: true };
       }
-      case "launch_cli":
+      case "launch_cli": {
+        const launchResult = await this.deps.cliManager.handleCliCommand(cmd, args);
+        const meshNodeId = readStringValue(args?.settings?.meshNodeId);
+        const meshId = readStringValue(args?.settings?.meshNodeFor);
+        if (meshNodeId && meshId && launchResult?.success !== false) {
+          try {
+            const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+            const meshObj = getMesh2(meshId) ?? this.getCachedInlineMesh(meshId);
+            const nodeObj = Array.isArray(meshObj?.nodes) ? meshObj.nodes.find((n) => n.id === meshNodeId || n.nodeId === meshNodeId) : void 0;
+            const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
+            if (bootstrapStatus === "running") {
+              return { success: true, ...launchResult, bootstrapPending: true };
+            }
+          } catch {
+          }
+        }
+        return launchResult;
+      }
       case "stop_cli":
       case "set_cli_view_mode":
-      case "record_provider_pty":
-      case "agent_command": {
+      case "record_provider_pty": {
         return this.deps.cliManager.handleCliCommand(cmd, args);
       }
+      case "agent_command": {
+        const agentResult = await this.deps.cliManager.handleCliCommand(cmd, args);
+        const meshCtx = args?.meshContext;
+        const dispatchNodeId = readStringValue(meshCtx?.nodeId);
+        const dispatchMeshId = readStringValue(meshCtx?.meshId);
+        if (dispatchNodeId && dispatchMeshId && agentResult?.success !== false) {
+          try {
+            const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+            const meshObj = getMesh2(dispatchMeshId) ?? this.getCachedInlineMesh(dispatchMeshId);
+            const nodeObj = Array.isArray(meshObj?.nodes) ? meshObj.nodes.find((n) => n.id === dispatchNodeId || n.nodeId === dispatchNodeId) : void 0;
+            const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
+            if (bootstrapStatus === "running") {
+              return {
+                success: true,
+                ...agentResult,
+                dispatchAcknowledgementRisk: true,
+                dispatchAcknowledgementRiskReason: "bootstrap_still_running",
+                nextAction: "Wait for worktree_bootstrap_complete event before dispatching work to this node."
+              };
+            }
+          } catch {
+          }
+        }
+        return agentResult;
+      }
       // ─── Logs ───
       case "get_logs": {
         const count = parseInt(args?.count) || parseInt(args?.lines) || 100;
@@ -43702,9 +43840,11 @@ var DaemonCommandRouter = class {
           if (meshRecord?.inline) {
             removed = this.removeInlineMeshNode(meshId, mesh, nodeId);
             if (removed) this.invalidateAggregateMeshStatus(meshId);
+            if (!removed && !node) removed = true;
           } else {
             const { removeNode: removeNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
             removed = removeNode2(meshId, nodeId);
+            if (!removed && !node) removed = true;
             if (removed) this.invalidateAggregateMeshStatus(meshId);
           }
           if (removed) {
@@ -43888,8 +44028,37 @@ var DaemonCommandRouter = class {
             setupPromise.then((value) => ({ completed: true, value })),
             new Promise((resolve23) => setTimeout(() => resolve23({ completed: false }), setupWaitMs))
           ]);
+          const emitBootstrapEvent = (eventStatus2, bootstrapState2, startedAtMs, extraPayload) => {
+            try {
+              const durationMs = Date.now() - startedAtMs;
+              const eventPayload = {
+                event: `worktree_${eventStatus2}`,
+                meshId,
+                nodeLabel: node.id,
+                nodeId: node.id,
+                workspace: result.worktreePath,
+                metadataEvent: {
+                  source: "clone_mesh_node_bootstrap",
+                  nodeId: node.id,
+                  status: eventStatus2,
+                  worktreePath: result.worktreePath,
+                  durationMs,
+                  bootstrapStatus: bootstrapState2.status,
+                  ...bootstrapState2.error ? { error: bootstrapState2.error } : {},
+                  ...bootstrapState2.exitCode !== void 0 ? { exitCode: bootstrapState2.exitCode } : {},
+                  ...extraPayload || {}
+                },
+                queuedAt: Date.now()
+              };
+              queuePendingMeshCoordinatorEvent(eventPayload);
+            } catch {
+            }
+          };
+          const bootstrapStartedMs = Date.now();
           if (!setupResult.completed) {
-            setupPromise.catch((error) => {
+            setupPromise.then(({ bootstrapState: bootstrapState2 }) => {
+              emitBootstrapEvent("bootstrap_complete", bootstrapState2, bootstrapStartedMs);
+            }).catch((error) => {
               const failedState = {
                 ...runningBootstrapState,
                 status: "failed",
@@ -43898,6 +44067,7 @@ var DaemonCommandRouter = class {
               };
               void persistWorktreeSetupState(failedState);
               void appendCloneLedger(false, failedState);
+              emitBootstrapEvent("bootstrap_failed", failedState, bootstrapStartedMs, { error: error?.message || String(error) });
             });
             return {
               success: true,
@@ -43915,6 +44085,7 @@ var DaemonCommandRouter = class {
             };
           }
           const { submodulesInitialized, bootstrapState } = setupResult.value;
+          emitBootstrapEvent("bootstrap_complete", bootstrapState, bootstrapStartedMs);
           return {
             success: true,
             node,
@@ -43982,7 +44153,34 @@ var DaemonCommandRouter = class {
         const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "queue trigger");
         if (ownerFailure) return ownerFailure;
         try {
-          const { triggerMeshQueue: triggerMeshQueue2 } = await Promise.resolve().then(() => (init_mesh_events(), mesh_events_exports));
+          const { triggerMeshQueue: triggerMeshQueue2, tryAssignQueueTask: tryAssignQueueTask2 } = await Promise.resolve().then(() => (init_mesh_events(), mesh_events_exports));
+          const preferredNodeId = typeof args?.preferredNodeId === "string" ? args.preferredNodeId.trim() : "";
+          if (preferredNodeId) {
+            const cliInstances = this.deps.instanceManager.getByCategory("cli");
+            const sorted = [...cliInstances].sort((a, b) => {
+              const aSettings = a.getState().settings || {};
+              const bSettings = b.getState().settings || {};
+              const aNode = readStringValue(aSettings.meshNodeId, aSettings.nodeId);
+              const bNode = readStringValue(bSettings.meshNodeId, bSettings.nodeId);
+              return (aNode === preferredNodeId ? -1 : 0) - (bNode === preferredNodeId ? -1 : 0);
+            });
+            for (const inst of sorted) {
+              const state = inst.getState();
+              const settings = state.settings || {};
+              const nodeId = readStringValue(settings.meshNodeId, settings.nodeId);
+              if (!nodeId || nodeId !== preferredNodeId) continue;
+              const meshNodeFor = readStringValue(settings.meshNodeFor);
+              if (meshNodeFor !== meshId) continue;
+              const status = (readStringValue(state.status) || "").toLowerCase();
+              if (status !== "idle") continue;
+              const sessionId = typeof state.instanceId === "string" ? state.instanceId : "";
+              const providerType = readStringValue(state.type, settings.providerType) || "";
+              if (sessionId && providerType) {
+                tryAssignQueueTask2(this.deps, meshId, nodeId, sessionId, providerType);
+                break;
+              }
+            }
+          }
           const trigger = await triggerMeshQueue2(this.deps, meshId);
           return { success: true, trigger };
         } catch (e) {