@adhdev/daemon-standalone 0.9.82-rc.223 → 0.9.82-rc.224

package/dist/index.js

@@ -54748,7 +54748,9 @@ ${effect.notification.body || ""}`.trim();
         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, {
@@ -69215,7 +69217,12 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       }
     }
     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,
@@ -70726,7 +70733,66 @@ ${e?.stderr || ""}`
         } 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",
@@ -70738,9 +70804,13 @@ ${e?.stderr || ""}`
       }
       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);
@@ -71226,11 +71296,24 @@ ${e?.stderr || ""}`
           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.
@@ -71249,11 +71332,25 @@ ${e?.stderr || ""}`
             { 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,
@@ -71855,13 +71952,54 @@ ${e?.stderr || ""}`
             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;
@@ -73246,9 +73384,11 @@ ${e?.stderr || ""}`
               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) {
@@ -73432,8 +73572,37 @@ ${e?.stderr || ""}`
                 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((error48) => {
+                setupPromise.then(({ bootstrapState: bootstrapState2 }) => {
+                  emitBootstrapEvent("bootstrap_complete", bootstrapState2, bootstrapStartedMs);
+                }).catch((error48) => {
                   const failedState = {
                     ...runningBootstrapState,
                     status: "failed",
@@ -73442,6 +73611,7 @@ ${e?.stderr || ""}`
                   };
                   void persistWorktreeSetupState(failedState);
                   void appendCloneLedger(false, failedState);
+                  emitBootstrapEvent("bootstrap_failed", failedState, bootstrapStartedMs, { error: error48?.message || String(error48) });
                 });
                 return {
                   success: true,
@@ -73459,6 +73629,7 @@ ${e?.stderr || ""}`
                 };
               }
               const { submodulesInitialized, bootstrapState } = setupResult.value;
+              emitBootstrapEvent("bootstrap_complete", bootstrapState, bootstrapStartedMs);
               return {
                 success: true,
                 node,
@@ -73526,7 +73697,34 @@ ${e?.stderr || ""}`
             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) {