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

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}` : ""}`];
@@ -38942,6 +38946,7 @@ ${effect.notification.body || ""}`.trim();
     }
     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";
@@ -39016,6 +39021,15 @@ ${effect.notification.body || ""}`.trim();
       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,
@@ -39026,20 +39040,7 @@ ${effect.notification.body || ""}`.trim();
         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);
@@ -39782,6 +39783,7 @@ ${effect.notification.body || ""}`.trim();
                   provider,
                   nativeSource: nativeHistory.source,
                   nativeHistoryCoverage,
+                  unavailableReason,
                   nativeMessageCount: nativeMessages.length,
                   safeMapping,
                   freshEnough
@@ -39881,6 +39883,7 @@ ${effect.notification.body || ""}`.trim();
               provider,
               nativeSource: history.source,
               nativeHistoryCoverage,
+              unavailableReason,
               nativeMessageCount: historyMessages.length,
               safeMapping,
               freshEnough: true
@@ -49831,6 +49834,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);
@@ -49931,9 +49940,12 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         isCached: false
       };
     }
-    function liveSessionRecordMatchesMeshNode(record2, meshId, nodeId) {
+    function liveSessionRecordMatchesMeshNode(record2, meshId, nodeId, nodeWorkspace = "", nodeIsMissingLocalWorktree = false) {
       const recordNodeId = readStringValue(record2?.meta?.meshNodeId);
       if (!recordNodeId || recordNodeId !== nodeId) return false;
+      if (nodeIsMissingLocalWorktree) return false;
+      const recordWorkspace = readStringValue(record2?.workspace);
+      if (nodeWorkspace && recordWorkspace && recordWorkspace !== nodeWorkspace) return false;
       const recordMeshId = readStringValue(record2?.meta?.meshNodeFor);
       return !recordMeshId || recordMeshId === meshId;
     }
@@ -49958,9 +49970,13 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       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((record2) => {
-        const nodeWorkspace = readStringValue(args.node?.workspace);
-        if (liveSessionRecordMatchesMeshNode(record2, args.meshId, args.nodeId)) return true;
+        const recordNodeId = readStringValue(record2?.meta?.meshNodeId);
+        if (recordNodeId && recordNodeId !== args.nodeId) return false;
+        if (liveSessionRecordMatchesMeshNode(record2, args.meshId, args.nodeId, nodeWorkspace || "", nodeIsMissingLocalWorktree)) return true;
+        if (nodeIsMissingLocalWorktree) return false;
         return !!nodeWorkspace && liveSessionRecordMatchesMeshWorkspace(record2, args.meshId, nodeWorkspace);
       });
       if (args.allowCoordinatorSession) {
@@ -49976,11 +49992,15 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     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 record2 of args.liveSessionRecords || []) {
@@ -49989,7 +50009,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         if (recordMeshId !== args.meshId) continue;
         const recordNodeId = readStringValue(meta3.meshNodeId);
         const workspace = readStringValue(record2?.workspace);
-        const removedNode = !!recordNodeId && !liveNodeIds.has(recordNodeId);
+        const removedNode = !!recordNodeId && (!liveNodeIds.has(recordNodeId) || missingLocalWorktreeNodeIds.has(recordNodeId));
         const orphanedWorkspace = !!workspace && !liveWorkspaces.has(workspace) && meta3.meshCoordinatorFor !== args.meshId;
         if (!removedNode && !orphanedWorkspace) continue;
         sessions.push({
@@ -53180,56 +53200,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) {
@@ -53686,12 +53763,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,
@@ -53708,7 +53791,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",