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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.117",
+  "version": "0.9.82-rc.118",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/chat-commands.ts

@@ -402,11 +402,13 @@ function buildNativeHistoryFallbackReason(args: {
     provider?: ProviderModule;
     nativeSource?: string;
     nativeHistoryCoverage?: string;
+    unavailableReason?: string;
     nativeMessageCount: number;
     safeMapping: boolean;
     freshEnough: boolean;
 }): string {
     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';
@@ -509,6 +511,15 @@ function readCliProviderNativeHistory(agentStr: string, args: {
     scripts?: ProviderScripts;
     exactSessionScoped?: boolean;
 }): ReturnType<typeof readProviderChatHistory> & { lookup: 'session' | 'workspace' } {
+    if (!args.historySessionId) {
+        return {
+            messages: [],
+            hasMore: false,
+            source: 'native-unavailable',
+            unavailableReason: 'native_history_workspace_only_lookup_unsafe',
+            lookup: 'session',
+        } as ReturnType<typeof readProviderChatHistory> & { lookup: 'session' | 'workspace' };
+    }
     const sessionHistory = readProviderChatHistory(agentStr, {
         canonicalHistory: args.canonicalHistory,
         historySessionId: args.historySessionId,
@@ -519,24 +530,10 @@ function readCliProviderNativeHistory(agentStr: string, args: {
         historyBehavior: args.historyBehavior,
         scripts: args.scripts as any,
     });
-    // Exact runtime/provider transcript reads must not silently fall back to the
-    // workspace's active or most recent native transcript: multiple Hermes/Gemini/
-    // Codex sessions can run in the same workspace, and workspace fallback can make
-    // read_chat/completion evidence point at a different runtime's prompt.
-    if ((sessionHistory as any).source !== 'native-unavailable' || args.exactSessionScoped || !args.historySessionId || !args.workspace) {
-        return { ...(sessionHistory as any), lookup: args.historySessionId ? 'session' : 'workspace' };
-    }
-    const workspaceHistory = readProviderChatHistory(agentStr, {
-        canonicalHistory: args.canonicalHistory,
-        historySessionId: undefined,
-        workspace: args.workspace,
-        offset: args.offset,
-        limit: args.limit,
-        excludeRecentCount: args.excludeRecentCount,
-        historyBehavior: args.historyBehavior,
-        scripts: args.scripts as any,
-    });
-    return { ...(workspaceHistory as any), lookup: 'workspace' };
+    // Native transcripts are keyed by provider/runtime session identity. Falling
+    // back to workspace makes concurrent local Codex/Hermes sessions alias each
+    // other when they share the same cwd.
+    return { ...(sessionHistory as any), lookup: 'session' };
 }
 
 function isNativeHistoryFreshEnough(args: {
@@ -1446,11 +1443,12 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                         const fallbackReason = buildNativeHistoryFallbackReason({
                             providerType,
                             provider,
-                            nativeSource: (nativeHistory as any).source,
-                            nativeHistoryCoverage,
-                            nativeMessageCount: nativeMessages.length,
-                            safeMapping,
-                            freshEnough,
+                        nativeSource: (nativeHistory as any).source,
+                        nativeHistoryCoverage,
+                        unavailableReason,
+                        nativeMessageCount: nativeMessages.length,
+                        safeMapping,
+                        freshEnough,
                         });
                         messageSource = buildCliMessageSourceProvenance({
                             selected: 'pty-parser',
@@ -1581,6 +1579,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                         provider,
                         nativeSource: (history as any).source,
                         nativeHistoryCoverage,
+                        unavailableReason,
                         nativeMessageCount: historyMessages.length,
                         safeMapping,
                         freshEnough: true,

package/src/commands/router.ts

@@ -1079,9 +1079,12 @@ function summarizeMeshSessionRecord(record: any): Record<string, unknown> {
     };
 }
 
-function liveSessionRecordMatchesMeshNode(record: any, meshId: string, nodeId: string): boolean {
+function liveSessionRecordMatchesMeshNode(record: any, meshId: string, nodeId: string, nodeWorkspace = '', nodeIsMissingLocalWorktree = false): boolean {
     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;
 }
@@ -1130,9 +1133,15 @@ function collectLiveMeshSessionRecords(args: {
     liveSessionRecords: any[];
     allowCoordinatorSession?: boolean;
 }): any[] {
+    const nodeWorkspace = readStringValue(args.node?.workspace);
+    const nodeIsMissingLocalWorktree = args.node?.isLocalWorktree === true
+        && !!nodeWorkspace
+        && !fs.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);
     });
 
@@ -1155,11 +1164,15 @@ function buildHistoricalMeshSessions(args: {
 }): { count: number; sessions: Record<string, unknown>[]; instruction: string } | undefined {
     const liveNodeIds = new Set<string>();
     const liveWorkspaces = new Set<string>();
+    const missingLocalWorktreeNodeIds = new Set<string>();
     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 && !fs.existsSync(workspace)) {
+            missingLocalWorktreeNodeIds.add(nodeId);
+        }
     }
 
     const sessions: Record<string, unknown>[] = [];
@@ -1169,7 +1182,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({
@@ -5636,12 +5649,22 @@ export class DaemonCommandRouter {
                     for (const [nodeIndex, node] of (mesh.nodes || []).entries()) {
                         const nodeId = String(node.id || node.nodeId || '');
                         const daemonId = readStringValue(node.daemonId);
+                        const nodeMachineId = readMeshNodeMachineId(node as Record<string, unknown>);
+                        const nodeHostname = readMeshNodeHostname(node as Record<string, unknown>);
                         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 as Record<string, unknown>, {
                             localMachineId,
                             localDaemonId: this.deps.statusInstanceId,
@@ -5660,7 +5683,7 @@ export class DaemonCommandRouter {
                             worktreeBranch: node.worktreeBranch,
                             role: normalizeMeshDaemonRole(node.role) || (meshHost.hostNodeId && nodeId === meshHost.hostNodeId ? 'host' : undefined),
                             daemonId,
-                            machineId: readMeshNodeMachineId(node as Record<string, unknown>) || node.machineId,
+                            machineId: nodeMachineId || node.machineId,
                             machine: machineIdentity,
                             machineStatus: node.machineStatus,
                             health: 'unknown',