@adhdev/daemon-core 0.9.82-rc.115 → 0.9.82-rc.117

package/dist/index.js

@@ -14843,6 +14843,10 @@ var DEFAULT_APPROVAL_POSITIVE_HINTS = [
 function normalizeApprovalLabel(value) {
   return String(value || "").toLowerCase().replace(/^[\s\[(<{]*\d+(?:\s*[.)\]}>:-]|\s)+/, "").replace(/[^\p{L}\p{N}]+/gu, " ").trim();
 }
+function isNegativeApprovalLabel(value) {
+  const label = normalizeApprovalLabel(value);
+  return /^(no|deny|reject|cancel|skip|exit|stop)\b/.test(label) || /\bwithout\b/.test(label) || /\bdo not\b/.test(label);
+}
 function getApprovalPositiveHints(provider) {
   const customHints = Array.isArray(provider?.approvalPositiveHints) ? provider.approvalPositiveHints.map((hint) => normalizeApprovalLabel(String(hint || ""))).filter(Boolean) : [];
   return customHints.length > 0 ? customHints : DEFAULT_APPROVAL_POSITIVE_HINTS;
@@ -14850,19 +14854,19 @@ function getApprovalPositiveHints(provider) {
 function pickApprovalButton(buttons, provider) {
   const labels = (buttons || []).map((button) => String(button || "").trim()).filter(Boolean);
   if (labels.length === 0) {
-    return { index: 0, label: "Approve" };
+    return { index: -1, label: "" };
   }
   const normalizedButtons = labels.map((label) => normalizeApprovalLabel(label));
   const hints = getApprovalPositiveHints(provider);
   for (const hint of hints) {
-    const exactIndex = normalizedButtons.findIndex((label) => label === hint);
+    const exactIndex = normalizedButtons.findIndex((label, index) => label === hint && !isNegativeApprovalLabel(labels[index]));
     if (exactIndex >= 0) return { index: exactIndex, label: labels[exactIndex] };
-    const prefixIndex = normalizedButtons.findIndex((label) => label.startsWith(hint));
+    const prefixIndex = normalizedButtons.findIndex((label, index) => label.startsWith(hint) && !isNegativeApprovalLabel(labels[index]));
     if (prefixIndex >= 0) return { index: prefixIndex, label: labels[prefixIndex] };
-    const includeIndex = normalizedButtons.findIndex((label) => label.includes(hint));
+    const includeIndex = normalizedButtons.findIndex((label, index) => label.includes(hint) && !isNegativeApprovalLabel(labels[index]));
     if (includeIndex >= 0) return { index: includeIndex, label: labels[includeIndex] };
   }
-  return { index: 0, label: labels[0] };
+  return { index: -1, label: "" };
 }
 function formatAutoApprovalMessage(modalMessage, buttonLabel) {
   const lines = [`Auto-approved${buttonLabel ? `: ${buttonLabel}` : ""}`];
@@ -16953,16 +16957,39 @@ function hasOverlappingVisibleConversationText(nativeMessages, ptyMessages) {
   return false;
 }
 function hasSafeNativeHistoryMapping(args) {
+  const isCoordinatorTranscript = args.nativeMessages.some((m) => {
+    const text = typeof m?.content === "string" ? m.content : JSON.stringify(m?.content || "");
+    return text.includes("mesh_send_task") || text.includes("mesh_status") || text.includes("mesh_read_chat") || text.includes("mesh_launch_session");
+  });
   const explicitSessionId = String(args.historySessionId || args.providerSessionId || "").trim();
   if (explicitSessionId) {
     const messageSessionIds = args.nativeMessages.map((message) => typeof message?.historySessionId === "string" ? message.historySessionId.trim() : "").filter(Boolean);
-    if (messageSessionIds.length === 0) return true;
-    return messageSessionIds.some((id) => id === explicitSessionId);
+    if (messageSessionIds.length > 0) {
+      return messageSessionIds.some((id) => id === explicitSessionId);
+    }
+    if (isCoordinatorTranscript && args.ptyMessages && args.ptyMessages.length > 0) {
+      const ptyHasCoordinator = args.ptyMessages.some((m) => {
+        const text = typeof m?.content === "string" ? m.content : JSON.stringify(m?.content || "");
+        return text.includes("mesh_send_task") || text.includes("mesh_status") || text.includes("mesh_read_chat");
+      });
+      if (!ptyHasCoordinator) {
+        return false;
+      }
+    }
   }
   const workspace = String(args.workspace || "").trim();
   if (!workspace) return false;
   const workspaceMatches = args.nativeMessages.some((message) => String(message?.workspace || "").trim() === workspace);
   if (!workspaceMatches) return false;
+  if (isCoordinatorTranscript && args.ptyMessages && args.ptyMessages.length > 0) {
+    const ptyHasCoordinator = args.ptyMessages.some((m) => {
+      const text = typeof m?.content === "string" ? m.content : JSON.stringify(m?.content || "");
+      return text.includes("mesh_send_task") || text.includes("mesh_status") || text.includes("mesh_read_chat");
+    });
+    if (!ptyHasCoordinator) {
+      return false;
+    }
+  }
   if (!args.requireWorkspaceContentOverlap) return true;
   return hasOverlappingVisibleConversationText(args.nativeMessages, args.ptyMessages || []);
 }
@@ -27842,6 +27869,12 @@ function finalizeMeshNodeStatus(args) {
       status.launchBlockedMessage = readStringValue(bootstrap.error) || "Required worktree bootstrap failed; resolve it before launching an agent into this node.";
       return;
     }
+    if (bootstrap.status === "running" && bootstrap.required !== false) {
+      status.launchReady = false;
+      status.launchBlockedReason = "worktree_bootstrap_running";
+      status.launchBlockedMessage = "Required worktree bootstrap is still running; wait for it to finish before launching an agent into this node.";
+      return;
+    }
   }
   const connectionState = readStringValue(readObjectRecord(status.connection).state);
   status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || connectionState === "connected" || isSelfNode);
@@ -31191,56 +31224,113 @@ var DaemonCommandRouter = class {
             if (!node) return { success: false, error: "Failed to register worktree node" };
             this.invalidateAggregateMeshStatus(meshId);
           }
-          const initSubmodules = sourceNode.policy?.initSubmodulesOnClone !== false;
-          if (initSubmodules) {
-            try {
-              const { runGit: runGit3 } = await Promise.resolve().then(() => (init_git_executor(), git_executor_exports));
-              await runGit3(
-                { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true },
-                ["submodule", "update", "--init", "--recursive"],
-                { timeoutMs: 12e4 }
-              );
-            } catch (subErr) {
-              console.warn("[mesh] Submodule init failed for worktree:", subErr.message);
+          const persistWorktreeSetupState = async (bootstrapState2) => {
+            node.worktreeBootstrap = bootstrapState2;
+            if (meshRecord.inline) {
+              this.updateInlineMeshNode(meshId, mesh, node);
+              return;
             }
-          }
-          const bootstrapState = await runMeshWorktreeBootstrap(mesh, result.worktreePath);
-          node.worktreeBootstrap = bootstrapState;
-          if (!meshRecord.inline) {
             try {
               const { updateNode: updateNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              updateNode2(meshId, node.id, { worktreeBootstrap: bootstrapState });
+              updateNode2(meshId, node.id, { worktreeBootstrap: bootstrapState2 });
               this.invalidateAggregateMeshStatus(meshId);
             } catch {
             }
-          }
-          try {
-            const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
-            appendLedgerEntry2(meshId, {
-              kind: "node_cloned",
-              nodeId: node.id,
-              payload: {
-                sourceNodeId,
-                branch: result.branch,
-                worktreePath: result.worktreePath,
-                submodulesInitialized: initSubmodules,
-                worktreeBootstrap: {
-                  status: bootstrapState.status,
-                  required: bootstrapState.required,
-                  configSource: bootstrapState.configSource,
-                  configSourceType: bootstrapState.configSourceType,
-                  lastCommand: bootstrapState.lastCommand,
-                  exitCode: bootstrapState.exitCode
+          };
+          const appendCloneLedger = async (initSubmodules2, bootstrapState2) => {
+            try {
+              const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+              appendLedgerEntry2(meshId, {
+                kind: "node_cloned",
+                nodeId: node.id,
+                payload: {
+                  sourceNodeId,
+                  branch: result.branch,
+                  worktreePath: result.worktreePath,
+                  submodulesInitialized: initSubmodules2,
+                  worktreeBootstrap: {
+                    status: bootstrapState2.status,
+                    required: bootstrapState2.required,
+                    configSource: bootstrapState2.configSource,
+                    configSourceType: bootstrapState2.configSourceType,
+                    lastCommand: bootstrapState2.lastCommand,
+                    exitCode: bootstrapState2.exitCode
+                  }
                 }
+              });
+            } catch {
+            }
+          };
+          const initSubmodules = sourceNode.policy?.initSubmodulesOnClone !== false;
+          const loadedBootstrap = loadMeshWorktreeBootstrapConfig(mesh, result.worktreePath);
+          const runningBootstrapState = {
+            status: "running",
+            required: loadedBootstrap.config?.required !== false,
+            configSource: loadedBootstrap.path || loadedBootstrap.source,
+            configSourceType: loadedBootstrap.sourceType,
+            startedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          await persistWorktreeSetupState(runningBootstrapState);
+          const finishWorktreeSetup = async () => {
+            let submodulesInitialized2 = false;
+            if (initSubmodules) {
+              try {
+                const { runGit: runGit3 } = await Promise.resolve().then(() => (init_git_executor(), git_executor_exports));
+                await runGit3(
+                  { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true },
+                  ["submodule", "update", "--init", "--recursive"],
+                  { timeoutMs: 12e4 }
+                );
+                submodulesInitialized2 = true;
+              } catch (subErr) {
+                console.warn("[mesh] Submodule init failed for worktree:", subErr.message);
               }
+            }
+            const bootstrapState2 = await runMeshWorktreeBootstrap(mesh, result.worktreePath);
+            await persistWorktreeSetupState(bootstrapState2);
+            await appendCloneLedger(submodulesInitialized2, bootstrapState2);
+            return { submodulesInitialized: submodulesInitialized2, bootstrapState: bootstrapState2 };
+          };
+          const requestedSetupWaitMs = Number(args?.setupWaitMs ?? args?.bootstrapWaitMs ?? 8e3);
+          const setupWaitMs = Number.isFinite(requestedSetupWaitMs) ? Math.min(Math.max(requestedSetupWaitMs, 0), 14e3) : 8e3;
+          const setupPromise = finishWorktreeSetup();
+          const setupResult = await Promise.race([
+            setupPromise.then((value) => ({ completed: true, value })),
+            new Promise((resolve17) => setTimeout(() => resolve17({ completed: false }), setupWaitMs))
+          ]);
+          if (!setupResult.completed) {
+            setupPromise.catch((error) => {
+              const failedState = {
+                ...runningBootstrapState,
+                status: "failed",
+                completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                error: error?.message || String(error)
+              };
+              void persistWorktreeSetupState(failedState);
+              void appendCloneLedger(false, failedState);
             });
-          } catch {
+            return {
+              success: true,
+              async: true,
+              status: "accepted",
+              node,
+              worktreePath: result.worktreePath,
+              branch: result.branch,
+              worktreeBootstrap: runningBootstrapState,
+              worktreeSetup: {
+                status: "running",
+                setupWaitMs,
+                message: "Worktree node is registered; submodule/bootstrap setup is continuing in the background."
+              }
+            };
           }
+          const { submodulesInitialized, bootstrapState } = setupResult.value;
           return {
             success: true,
             node,
             worktreePath: result.worktreePath,
             branch: result.branch,
+            submodulesInitialized,
             worktreeBootstrap: bootstrapState
           };
         } catch (e) {