@adhdev/daemon-core 0.9.82-rc.116 → 0.9.82-rc.118

package/dist/index.mjs

@@ -14577,6 +14577,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;
@@ -14584,19 +14588,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}` : ""}`];
@@ -16650,6 +16654,7 @@ function buildCliMessageSourceProvenance(args) {
 }
 function buildNativeHistoryFallbackReason(args) {
   if (!supportsCliNativeTranscript(args.providerType, args.provider)) return "provider_native_transcript_not_supported";
+  if (args.unavailableReason) return `native_history_unavailable:${args.unavailableReason}`;
   if (args.nativeSource === "native-unavailable") return "native_history_unavailable";
   if (args.nativeHistoryCoverage === "partial") return "native_history_partial";
   if (args.nativeHistoryCoverage === "unavailable") return "native_history_unavailable";
@@ -16724,6 +16729,15 @@ function hasSafeNativeHistoryMapping(args) {
   return hasOverlappingVisibleConversationText(args.nativeMessages, args.ptyMessages || []);
 }
 function readCliProviderNativeHistory(agentStr, args) {
+  if (!args.historySessionId) {
+    return {
+      messages: [],
+      hasMore: false,
+      source: "native-unavailable",
+      unavailableReason: "native_history_workspace_only_lookup_unsafe",
+      lookup: "session"
+    };
+  }
   const sessionHistory = readProviderChatHistory(agentStr, {
     canonicalHistory: args.canonicalHistory,
     historySessionId: args.historySessionId,
@@ -16734,20 +16748,7 @@ function readCliProviderNativeHistory(agentStr, args) {
     historyBehavior: args.historyBehavior,
     scripts: args.scripts
   });
-  if (sessionHistory.source !== "native-unavailable" || args.exactSessionScoped || !args.historySessionId || !args.workspace) {
-    return { ...sessionHistory, lookup: args.historySessionId ? "session" : "workspace" };
-  }
-  const workspaceHistory = readProviderChatHistory(agentStr, {
-    canonicalHistory: args.canonicalHistory,
-    historySessionId: void 0,
-    workspace: args.workspace,
-    offset: args.offset,
-    limit: args.limit,
-    excludeRecentCount: args.excludeRecentCount,
-    historyBehavior: args.historyBehavior,
-    scripts: args.scripts
-  });
-  return { ...workspaceHistory, lookup: "workspace" };
+  return { ...sessionHistory, lookup: "session" };
 }
 function isNativeHistoryFreshEnough(args) {
   const nativeNewest = getMessageNewestReceivedAt(args.nativeMessages);
@@ -17490,6 +17491,7 @@ async function handleReadChat(h, args) {
               provider,
               nativeSource: nativeHistory.source,
               nativeHistoryCoverage,
+              unavailableReason,
               nativeMessageCount: nativeMessages.length,
               safeMapping,
               freshEnough
@@ -17589,6 +17591,7 @@ async function handleReadChat(h, args) {
           provider,
           nativeSource: history.source,
           nativeHistoryCoverage,
+          unavailableReason,
           nativeMessageCount: historyMessages.length,
           safeMapping,
           freshEnough: true
@@ -27604,6 +27607,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);
@@ -27704,9 +27713,12 @@ function summarizeMeshSessionRecord(record) {
     isCached: false
   };
 }
-function liveSessionRecordMatchesMeshNode(record, meshId, nodeId) {
+function liveSessionRecordMatchesMeshNode(record, meshId, nodeId, nodeWorkspace = "", nodeIsMissingLocalWorktree = false) {
   const recordNodeId = readStringValue(record?.meta?.meshNodeId);
   if (!recordNodeId || recordNodeId !== nodeId) return false;
+  if (nodeIsMissingLocalWorktree) return false;
+  const recordWorkspace = readStringValue(record?.workspace);
+  if (nodeWorkspace && recordWorkspace && recordWorkspace !== nodeWorkspace) return false;
   const recordMeshId = readStringValue(record?.meta?.meshNodeFor);
   return !recordMeshId || recordMeshId === meshId;
 }
@@ -27731,9 +27743,13 @@ function readLiveMeshNodeWorkspace(args) {
   return "";
 }
 function collectLiveMeshSessionRecords(args) {
+  const nodeWorkspace = readStringValue(args.node?.workspace);
+  const nodeIsMissingLocalWorktree = args.node?.isLocalWorktree === true && !!nodeWorkspace && !fs11.existsSync(nodeWorkspace);
   const matches = args.liveSessionRecords.filter((record) => {
-    const nodeWorkspace = readStringValue(args.node?.workspace);
-    if (liveSessionRecordMatchesMeshNode(record, args.meshId, args.nodeId)) return true;
+    const recordNodeId = readStringValue(record?.meta?.meshNodeId);
+    if (recordNodeId && recordNodeId !== args.nodeId) return false;
+    if (liveSessionRecordMatchesMeshNode(record, args.meshId, args.nodeId, nodeWorkspace || "", nodeIsMissingLocalWorktree)) return true;
+    if (nodeIsMissingLocalWorktree) return false;
     return !!nodeWorkspace && liveSessionRecordMatchesMeshWorkspace(record, args.meshId, nodeWorkspace);
   });
   if (args.allowCoordinatorSession) {
@@ -27749,11 +27765,15 @@ function collectLiveMeshSessionRecords(args) {
 function buildHistoricalMeshSessions(args) {
   const liveNodeIds = /* @__PURE__ */ new Set();
   const liveWorkspaces = /* @__PURE__ */ new Set();
+  const missingLocalWorktreeNodeIds = /* @__PURE__ */ new Set();
   for (const node of args.nodes || []) {
     const nodeId = readStringValue(node?.id, node?.nodeId);
     const workspace = readStringValue(node?.workspace);
     if (nodeId) liveNodeIds.add(nodeId);
     if (workspace) liveWorkspaces.add(workspace);
+    if (nodeId && node?.isLocalWorktree === true && workspace && !fs11.existsSync(workspace)) {
+      missingLocalWorktreeNodeIds.add(nodeId);
+    }
   }
   const sessions = [];
   for (const record of args.liveSessionRecords || []) {
@@ -27762,7 +27782,7 @@ function buildHistoricalMeshSessions(args) {
     if (recordMeshId !== args.meshId) continue;
     const recordNodeId = readStringValue(meta.meshNodeId);
     const workspace = readStringValue(record?.workspace);
-    const removedNode = !!recordNodeId && !liveNodeIds.has(recordNodeId);
+    const removedNode = !!recordNodeId && (!liveNodeIds.has(recordNodeId) || missingLocalWorktreeNodeIds.has(recordNodeId));
     const orphanedWorkspace = !!workspace && !liveWorkspaces.has(workspace) && meta.meshCoordinatorFor !== args.meshId;
     if (!removedNode && !orphanedWorkspace) continue;
     sessions.push({
@@ -30953,56 +30973,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) {
@@ -31459,12 +31536,18 @@ ${block2}`);
           for (const [nodeIndex, node] of (mesh.nodes || []).entries()) {
             const nodeId = String(node.id || node.nodeId || "");
             const daemonId = readStringValue(node.daemonId);
+            const nodeMachineId = readMeshNodeMachineId(node);
+            const nodeHostname = readMeshNodeHostname(node);
             const providerPriority = readProviderPriorityFromPolicy(node.policy);
+            const configuredCoordinatorNode = Boolean(
+              nodeId && selectedCoordinatorNodeId && nodeId === selectedCoordinatorNodeId
+            );
+            const sparseConfiguredCoordinatorNode = configuredCoordinatorNode && !daemonId && !nodeMachineId && !nodeHostname;
             const isSelfNode = Boolean(
               nodeId && inlineCoordinatorNodeId && nodeId === inlineCoordinatorNodeId
             ) || Boolean(
               daemonId && (daemonId === localMachineId || daemonId === this.deps.statusInstanceId)
-            ) || Boolean(meshRecord?.inline && nodeIndex === 0);
+            ) || Boolean(meshRecord?.inline && nodeIndex === 0) || sparseConfiguredCoordinatorNode;
             const machineIdentity = buildMeshNodeMachineIdentity(node, {
               localMachineId,
               localDaemonId: this.deps.statusInstanceId,
@@ -31481,7 +31564,7 @@ ${block2}`);
               worktreeBranch: node.worktreeBranch,
               role: normalizeMeshDaemonRole(node.role) || (meshHost.hostNodeId && nodeId === meshHost.hostNodeId ? "host" : void 0),
               daemonId,
-              machineId: readMeshNodeMachineId(node) || node.machineId,
+              machineId: nodeMachineId || node.machineId,
               machine: machineIdentity,
               machineStatus: node.machineStatus,
               health: "unknown",