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

package/dist/index.js

@@ -36903,6 +36903,10 @@ ${effect.notification.body || ""}`.trim();
     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;
@@ -36910,19 +36914,19 @@ ${effect.notification.body || ""}`.trim();
     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}` : ""}`];
@@ -38979,16 +38983,39 @@ ${effect.notification.body || ""}`.trim();
       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 || []);
     }
@@ -49808,6 +49835,12 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           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);
@@ -53157,56 +53190,113 @@ ${e?.stderr || ""}`
                 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((error48) => {
+                  const failedState = {
+                    ...runningBootstrapState,
+                    status: "failed",
+                    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                    error: error48?.message || String(error48)
+                  };
+                  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) {