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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.117",
+  "version": "0.9.82-rc.119",
   "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

@@ -26,6 +26,11 @@ const RECENT_SEND_WINDOW_MS = 1200;
 export const READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS = 25_000;
 const HERMES_CLI_STARTING_SEND_SETTLE_MS = 2_000;
 const CLI_NATIVE_HISTORY_FRESH_MS = 5 * 60_000;
+// Fallback list for supportsCliNativeTranscript() when the ProviderModule is
+// unavailable (e.g. provider config not yet loaded). The authoritative check is
+// provider.canonicalHistory via isNativeSourceCanonicalHistory(). New providers
+// with native transcripts should set canonicalHistory in their provider.json
+// rather than adding entries here.
 const CLI_NATIVE_TRANSCRIPT_PROVIDERS = new Set(['codex-cli', 'claude-cli', 'hermes-cli', 'antigravity-cli']);
 const recentSendByTarget = new Map<string, number>();
 
@@ -402,11 +407,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';
@@ -469,15 +476,20 @@ function hasSafeNativeHistoryMapping(args: {
             return messageSessionIds.some((id) => id === explicitSessionId);
         }
 
+        // Messages carry no historySessionId — cannot confirm they belong to the requested session.
+        // Only allow a coordinator transcript that is also confirmed by the PTY side; otherwise
+        // fail closed so a same-workspace session's history is never silently accepted.
         if (isCoordinatorTranscript && args.ptyMessages && args.ptyMessages.length > 0) {
             const ptyHasCoordinator = args.ptyMessages.some((m: any) => {
                 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;
-            }
+            return ptyHasCoordinator;
         }
+
+        // No historySessionId in messages and no coordinator cross-check: fail closed.
+        // Workspace-only matching must not override an explicit session identity.
+        return false;
     }
     const workspace = String(args.workspace || '').trim();
     if (!workspace) return false;
@@ -498,6 +510,11 @@ function hasSafeNativeHistoryMapping(args: {
     return hasOverlappingVisibleConversationText(args.nativeMessages, args.ptyMessages || []);
 }
 
+// Provenance boundary: workspace-only native history lookup is never safe
+// because multiple concurrent sessions sharing the same cwd would alias each
+// other. historySessionId (the provider-native session key) is required to
+// establish ownership. hasSafeNativeHistoryMapping() enforces the same
+// invariant after the read; both guards must hold for native history to be used.
 function readCliProviderNativeHistory(agentStr: string, args: {
     canonicalHistory?: ProviderModule['canonicalHistory'];
     historySessionId?: string;
@@ -507,8 +524,16 @@ function readCliProviderNativeHistory(agentStr: string, args: {
     excludeRecentCount: number;
     historyBehavior?: ProviderModule['historyBehavior'];
     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 +544,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: {
@@ -1223,7 +1234,6 @@ export async function handleChatHistory(h: CommandHelpers, args: any): Promise<C
                 excludeRecentCount,
                 historyBehavior: provider?.historyBehavior,
                 scripts: provider?.scripts as any,
-                exactSessionScoped: exactNativeHistoryScope,
             })
             : readProviderChatHistory(agentStr, {
                 canonicalHistory: provider?.canonicalHistory,
@@ -1363,7 +1373,6 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                         excludeRecentCount: 0,
                         historyBehavior: provider?.historyBehavior,
                         scripts: provider?.scripts as any,
-                        exactSessionScoped: exactNativeHistoryScope,
                     });
                 } catch (error: any) {
                     const fallbackReason = `native_history_error:${error?.message || String(error)}`;
@@ -1446,11 +1455,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',
@@ -1528,7 +1538,6 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                     excludeRecentCount: 0,
                     historyBehavior: provider?.historyBehavior,
                     scripts: provider?.scripts as any,
-                    exactSessionScoped: exactNativeHistoryScope,
                 })
                 : readProviderChatHistory(agentStr, {
                 canonicalHistory: provider?.canonicalHistory,
@@ -1581,6 +1590,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',