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

package/dist/index.js

@@ -38946,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";
@@ -39020,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,
@@ -39030,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);
@@ -39786,6 +39783,7 @@ ${effect.notification.body || ""}`.trim();
                   provider,
                   nativeSource: nativeHistory.source,
                   nativeHistoryCoverage,
+                  unavailableReason,
                   nativeMessageCount: nativeMessages.length,
                   safeMapping,
                   freshEnough
@@ -39885,6 +39883,7 @@ ${effect.notification.body || ""}`.trim();
               provider,
               nativeSource: history.source,
               nativeHistoryCoverage,
+              unavailableReason,
               nativeMessageCount: historyMessages.length,
               safeMapping,
               freshEnough: true
@@ -49941,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;
     }
@@ -49968,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) {
@@ -49986,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 || []) {
@@ -49999,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({
@@ -53753,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,
@@ -53775,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",