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

package/package.json

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

@@ -55,6 +55,7 @@ import {
 import {
     MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS,
     MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA,
+    loadMeshWorktreeBootstrapConfig,
     runMeshWorktreeBootstrap,
     type WorktreeBootstrapState,
 } from '../mesh/worktree-bootstrap-config.js';
@@ -934,6 +935,12 @@ function finalizeMeshNodeStatus(args: {
                 || '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 && (
@@ -1072,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;
 }
@@ -1123,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);
     });
 
@@ -1148,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>[] = [];
@@ -1162,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({
@@ -4971,60 +4991,120 @@ export class DaemonCommandRouter {
                         this.invalidateAggregateMeshStatus(meshId);
                     }
 
-                    // Initialize submodules if policy allows (default: true)
-                    const initSubmodules = (sourceNode.policy as any)?.initSubmodulesOnClone !== false;
-                    if (initSubmodules) {
-                        try {
-                            const { runGit } = await import('../git/git-executor.js');
-                            await runGit(
-                                { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true },
-                                ['submodule', 'update', '--init', '--recursive'],
-                                { timeoutMs: 120000 },
-                            );
-                        } catch (subErr: any) {
-                            // Submodule init is best-effort; don't fail the clone
-                            console.warn('[mesh] Submodule init failed for worktree:', subErr.message);
+                    const persistWorktreeSetupState = async (bootstrapState: WorktreeBootstrapState): Promise<void> => {
+                        node.worktreeBootstrap = bootstrapState;
+                        if (meshRecord.inline) {
+                            this.updateInlineMeshNode(meshId, mesh, node);
+                            return;
                         }
-                    }
-
-                    const bootstrapState: WorktreeBootstrapState = await runMeshWorktreeBootstrap(mesh, result.worktreePath);
-                    node.worktreeBootstrap = bootstrapState;
-                    if (!meshRecord.inline) {
                         try {
                             const { updateNode } = await import('../config/mesh-config.js');
                             updateNode(meshId, node.id, { worktreeBootstrap: bootstrapState });
                             this.invalidateAggregateMeshStatus(meshId);
                         } catch { /* bootstrap status persistence is best-effort */ }
-                    }
+                    };
 
-                    // Record in task ledger
-                    try {
-                        const { appendLedgerEntry } = await import('../mesh/mesh-ledger.js');
-                        appendLedgerEntry(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 (initSubmodules: boolean, bootstrapState: WorktreeBootstrapState): Promise<void> => {
+                        try {
+                            const { appendLedgerEntry } = await import('../mesh/mesh-ledger.js');
+                            appendLedgerEntry(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,
+                                    },
                                 },
-                            },
+                            });
+                        } catch { /* ledger append is best-effort */ }
+                    };
+
+                    const initSubmodules = (sourceNode.policy as any)?.initSubmodulesOnClone !== false;
+                    const loadedBootstrap = loadMeshWorktreeBootstrapConfig(mesh, result.worktreePath);
+                    const runningBootstrapState: WorktreeBootstrapState = {
+                        status: 'running',
+                        required: loadedBootstrap.config?.required !== false,
+                        configSource: loadedBootstrap.path || loadedBootstrap.source,
+                        configSourceType: loadedBootstrap.sourceType,
+                        startedAt: new Date().toISOString(),
+                    };
+                    await persistWorktreeSetupState(runningBootstrapState);
+
+                    const finishWorktreeSetup = async (): Promise<{ submodulesInitialized: boolean; bootstrapState: WorktreeBootstrapState }> => {
+                        let submodulesInitialized = false;
+                        if (initSubmodules) {
+                            try {
+                                const { runGit } = await import('../git/git-executor.js');
+                                await runGit(
+                                    { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true },
+                                    ['submodule', 'update', '--init', '--recursive'],
+                                    { timeoutMs: 120000 },
+                                );
+                                submodulesInitialized = true;
+                            } catch (subErr: any) {
+                                // Submodule init is best-effort; don't fail the clone
+                                console.warn('[mesh] Submodule init failed for worktree:', subErr.message);
+                            }
+                        }
+                        const bootstrapState: WorktreeBootstrapState = await runMeshWorktreeBootstrap(mesh, result.worktreePath);
+                        await persistWorktreeSetupState(bootstrapState);
+                        await appendCloneLedger(submodulesInitialized, bootstrapState);
+                        return { submodulesInitialized, bootstrapState };
+                    };
+
+                    const requestedSetupWaitMs = Number(args?.setupWaitMs ?? args?.bootstrapWaitMs ?? 8000);
+                    const setupWaitMs = Number.isFinite(requestedSetupWaitMs)
+                        ? Math.min(Math.max(requestedSetupWaitMs, 0), 14000)
+                        : 8000;
+                    const setupPromise = finishWorktreeSetup();
+                    const setupResult = await Promise.race([
+                        setupPromise.then((value) => ({ completed: true as const, value })),
+                        new Promise<{ completed: false }>((resolve) => setTimeout(() => resolve({ completed: false }), setupWaitMs)),
+                    ]);
+
+                    if (!setupResult.completed) {
+                        setupPromise.catch((error: any) => {
+                            const failedState: WorktreeBootstrapState = {
+                                ...runningBootstrapState,
+                                status: 'failed',
+                                completedAt: new Date().toISOString(),
+                                error: error?.message || String(error),
+                            };
+                            void persistWorktreeSetupState(failedState);
+                            void appendCloneLedger(false, failedState);
                         });
-                    } catch { /* ledger append is best-effort */ }
+                        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: any) {
@@ -5569,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,
@@ -5593,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',

package/src/providers/approval-utils.ts

@@ -24,6 +24,13 @@ function normalizeApprovalLabel(value: string): string {
         .trim();
 }
 
+function isNegativeApprovalLabel(value: string): boolean {
+    const label = normalizeApprovalLabel(value);
+    return /^(no|deny|reject|cancel|skip|exit|stop)\b/.test(label)
+        || /\bwithout\b/.test(label)
+        || /\bdo not\b/.test(label);
+}
+
 export function getApprovalPositiveHints(provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): string[] {
     const customHints = Array.isArray(provider?.approvalPositiveHints)
         ? provider.approvalPositiveHints
@@ -39,24 +46,24 @@ export function pickApprovalButton(
 ): { index: number; label: string } {
     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: '' };
 }
 
 export function formatAutoApprovalMessage(modalMessage?: string, buttonLabel?: string): string {