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

package/package.json

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

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 && (
@@ -4971,60 +4978,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) {

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 {