@adhdev/daemon-core 0.9.82-rc.1 → 0.9.82-rc.100

package/src/cli-adapters/provider-cli-adapter.ts

@@ -110,6 +110,14 @@ interface SendMessageCompletion {
     rejectOnce: (error: unknown) => void;
 }
 
+interface PendingOutboundMessage {
+    id: string;
+    role: 'user';
+    content: string;
+    queuedAt: number;
+    source: 'sendMessage';
+}
+
 export function appendBoundedText(current: string, chunk: string, maxChars: number): string {
     if (!chunk) return current.length <= maxChars ? current : current.slice(-maxChars);
     if (maxChars <= 0) return '';
@@ -186,6 +194,9 @@ export class ProviderCliAdapter implements CliAdapter {
     private idleFinishCandidate: IdleFinishCandidate | null = null;
     private finishRetryTimer: NodeJS.Timeout | null = null;
     private finishRetryCount = 0;
+    private pendingOutboundQueue: PendingOutboundMessage[] = [];
+    private pendingOutboundFlushTimer: NodeJS.Timeout | null = null;
+    private pendingOutboundFlushInFlight = false;
 
  // Resize redraw suppression
     private resizeSuppressUntil: number = 0;
@@ -761,6 +772,17 @@ export class ProviderCliAdapter implements CliAdapter {
         if (stableMs < 2000) return;
 
         const startupModal = this.runParseApproval(this.recentOutputBuffer);
+        const startupStatus = this.runDetectStatus(screenText || this.recentOutputBuffer);
+        if (!startupModal && startupStatus !== 'idle') {
+            this.recordTrace('startup_settle_deferred', {
+                trigger,
+                startupStatus,
+                stableMs,
+                screenText: summarizeCliTraceText(screenText, 500),
+            });
+            this.scheduleStartupSettleCheck();
+            return;
+        }
         this.startupParseGate = false;
         if (this.startupSettleTimer) {
             clearTimeout(this.startupSettleTimer);
@@ -956,6 +978,38 @@ export class ProviderCliAdapter implements CliAdapter {
         return true;
     }
 
+    private clearParsedIdleResponseGuard(reason: string, parsedStatus: any): boolean {
+        const parsedRawStatus = typeof parsedStatus?.status === 'string' ? parsedStatus.status.trim() : '';
+        const parsedModal = parsedStatus?.activeModal ?? parsedStatus?.modal ?? null;
+        const blockingModal = this.activeModal || this.runParseApproval(this.recentOutputBuffer);
+        if (
+            !this.isWaitingForResponse
+            || parsedRawStatus !== 'idle'
+            || !!parsedModal
+            || !!blockingModal
+            || !this.parsedStatusHasFinalAssistantMessage(parsedStatus)
+        ) {
+            return false;
+        }
+        this.clearAllTimers();
+        this.clearIdleFinishCandidate(reason);
+        this.responseBuffer = '';
+        this.isWaitingForResponse = false;
+        this.responseSettleIgnoreUntil = 0;
+        this.submitRetryUsed = false;
+        this.submitRetryPromptSnippet = '';
+        this.finishRetryCount = 0;
+        this.currentTurnScope = null;
+        this.activeModal = null;
+        this.setStatus('idle', reason);
+        this.recordTrace('parsed_idle_response_cleared', {
+            reason,
+            parsedStatus: parsedRawStatus,
+            parsedMessageCount: Array.isArray(parsedStatus?.messages) ? parsedStatus.messages.length : 0,
+        });
+        return true;
+    }
+
     private hasMeaningfulResponseBuffer(promptSnippet: string): boolean {
         const raw = String(this.responseBuffer || '').trim();
         if (!raw) return false;
@@ -1372,6 +1426,7 @@ export class ProviderCliAdapter implements CliAdapter {
         this.activeModal = null;
         this.setStatus('idle', 'response_finished');
         this.onStatusChange?.();
+        this.schedulePendingOutboundFlush();
     }
 
     private maybeCommitVisibleIdleTranscript(session: ParsedSession, parsedMessages: CliChatMessage[]): boolean {
@@ -1402,6 +1457,7 @@ export class ProviderCliAdapter implements CliAdapter {
         this.activeModal = null;
         this.setStatus('idle', 'script_idle_commit');
         this.onStatusChange?.();
+        this.schedulePendingOutboundFlush();
         this.recordTrace('script_idle_commit', {
             messageCount: parsedMessages.length,
             lastAssistant: summarizeCliTraceText(visibleAssistant.content, 320),
@@ -1489,6 +1545,7 @@ export class ProviderCliAdapter implements CliAdapter {
                 accumulatedRawBuffer: this.accumulatedRawBuffer,
                 recentOutputBuffer: this.recentOutputBuffer,
                 terminalScreenText: parseScreenText,
+                workingDir: this.workingDir,
                 baseMessages: [],
                 partialResponse: this.responseBuffer,
                 isWaitingForResponse: this.isWaitingForResponse,
@@ -1552,6 +1609,15 @@ export class ProviderCliAdapter implements CliAdapter {
         return !!(startupModal || this.activeModal);
     }
 
+    private parsedStatusHasFinalAssistantMessage(parsed: any): boolean {
+        const messages = Array.isArray(parsed?.messages) ? parsed.messages : [];
+        const lastAssistant = [...messages].reverse().find((message: any) => {
+            if (!message || message.role !== 'assistant') return false;
+            return typeof message.content === 'string' && message.content.trim().length > 0;
+        });
+        return !!lastAssistant;
+    }
+
     private projectEffectiveStatus(startupModal: { message: string; buttons: string[] } | null = null): CliSessionStatus['status'] {
         if (this.parseErrorMessage) return 'error';
         if (this.hasActionableApproval(startupModal)) return 'waiting_approval';
@@ -1564,8 +1630,16 @@ export class ProviderCliAdapter implements CliAdapter {
     getStatus(options: { allowParse?: boolean } = {}): CliSessionStatus {
         const allowParse = options.allowParse !== false;
         const startupModal = allowParse && this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
+        const startupDetectedStatus = allowParse && this.startupParseGate && !startupModal
+            ? this.runDetectStatus(this.recentOutputBuffer || this.terminalScreen.getText())
+            : null;
         let effectiveStatus = this.projectEffectiveStatus(startupModal);
         let effectiveModal = startupModal || this.activeModal;
+        if (startupDetectedStatus === 'waiting_approval') {
+            effectiveStatus = 'waiting_approval';
+        } else if (startupDetectedStatus === 'idle' && !startupModal && !effectiveModal) {
+            effectiveStatus = 'idle';
+        }
         if (allowParse && !startupModal && !effectiveModal) {
             const parsed = this.getFreshParsedStatusCache();
             const parsedModal = parsed?.activeModal && Array.isArray(parsed.activeModal.buttons)
@@ -1575,6 +1649,18 @@ export class ProviderCliAdapter implements CliAdapter {
             if (parsed?.status === 'waiting_approval' && parsedModal) {
                 effectiveStatus = 'waiting_approval';
                 effectiveModal = parsedModal;
+            } else if (
+                effectiveStatus === 'idle'
+                && parsed?.status === 'generating'
+                && !this.parsedStatusHasFinalAssistantMessage(parsed)
+            ) {
+                effectiveStatus = 'generating';
+            } else if (
+                effectiveStatus === 'generating'
+                && parsed?.status === 'idle'
+                && this.parsedStatusHasFinalAssistantMessage(parsed)
+            ) {
+                effectiveStatus = 'idle';
             }
         }
         const bufferState = this.getBufferState();
@@ -1583,6 +1669,14 @@ export class ProviderCliAdapter implements CliAdapter {
             messages: [],
             workingDir: this.workingDir,
             activeModal: effectiveModal,
+            pendingOutboundCount: this.pendingOutboundQueue.length,
+            pendingOutboundMessages: this.pendingOutboundQueue.map((message) => ({
+                id: message.id,
+                role: message.role,
+                content: message.content,
+                queuedAt: message.queuedAt,
+                source: message.source,
+            })),
             errorMessage: this.parseErrorMessage || undefined,
             errorReason: this.parseErrorMessage ? 'parse_error' : undefined,
             ...(bufferState ? { bufferState } : {}),
@@ -1600,7 +1694,8 @@ export class ProviderCliAdapter implements CliAdapter {
         const cached = this.parsedStatusCache;
         const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
         if (
-            cached
+            !this.providerOwnsTranscript()
+            && cached
             && cached.responseBuffer === this.responseBuffer
             && cached.currentTurnScope === this.currentTurnScope
             && cached.recentOutputBuffer === this.recentOutputBuffer
@@ -1665,6 +1760,7 @@ export class ProviderCliAdapter implements CliAdapter {
             accumulatedRawBuffer: this.accumulatedRawBuffer,
             recentOutputBuffer: this.recentOutputBuffer,
             terminalScreenText: this.getParseScreenText(this.terminalScreen.getText()),
+            workingDir: this.workingDir,
             baseMessages: [],
             partialResponse: this.responseBuffer,
             isWaitingForResponse: this.isWaitingForResponse,
@@ -1925,6 +2021,104 @@ export class ProviderCliAdapter implements CliAdapter {
     }
 
     async sendMessage(text: string): Promise<void> {
+        await this.sendMessageNow(text, true);
+    }
+
+    private enqueuePendingOutboundMessage(text: string, reason: string): void {
+        const content = String(text || '');
+        const duplicate = this.pendingOutboundQueue.some((message) => message.content === content);
+        if (duplicate) {
+            this.recordTrace('send_message_queued_duplicate_suppressed', {
+                reason,
+                queueLength: this.pendingOutboundQueue.length,
+                text: summarizeCliTraceText(content, 500),
+            });
+            return;
+        }
+        const queuedAt = Date.now();
+        const message: PendingOutboundMessage = {
+            id: `${queuedAt}:${this.pendingOutboundQueue.length}:${Math.random().toString(36).slice(2, 10)}`,
+            role: 'user',
+            content,
+            queuedAt,
+            source: 'sendMessage',
+        };
+        this.pendingOutboundQueue.push(message);
+        this.recordTrace('send_message_queued', {
+            reason,
+            queueLength: this.pendingOutboundQueue.length,
+            queuedAt,
+            text: summarizeCliTraceText(content, 500),
+        });
+        LOG.info('CLI', `[${this.cliType}] queued outbound message while busy (${reason}); queue=${this.pendingOutboundQueue.length}`);
+        this.onStatusChange?.();
+    }
+
+    private shouldQueuePendingOutboundMessage(parsedStatusBeforeSend: any | null = null): string | null {
+        if (this.provider.allowInputDuringGeneration === true) return null;
+        if (this.hasActionableApproval()) return null;
+        const parsedSessionStatus = typeof parsedStatusBeforeSend?.status === 'string'
+            ? String(parsedStatusBeforeSend.status)
+            : '';
+        if (parsedSessionStatus === 'idle' && this.parsedStatusHasFinalAssistantMessage(parsedStatusBeforeSend)) return null;
+        if (this.currentStatus === 'generating') return 'current_status_generating';
+        if (parsedSessionStatus === 'generating' || parsedSessionStatus === 'long_generating') {
+            const parsedModal = parsedStatusBeforeSend?.activeModal ?? parsedStatusBeforeSend?.modal ?? null;
+            const parsedHasActionableModal = Boolean(
+                parsedModal
+                && Array.isArray(parsedModal.buttons)
+                && parsedModal.buttons.some((candidate: unknown) => typeof candidate === 'string' && candidate.trim()),
+            );
+            const terminalLooksIdle = this.currentStatus === 'idle'
+                && this.runDetectStatus(this.recentOutputBuffer) === 'idle'
+                && !this.isWaitingForResponse
+                && !this.currentTurnScope
+                && !this.hasActionableApproval()
+                && !parsedHasActionableModal;
+            return terminalLooksIdle ? null : `parsed_status_${parsedSessionStatus}`;
+        }
+        if (this.isWaitingForResponse && this.currentTurnScope) return 'active_turn_in_progress';
+        return null;
+    }
+
+    private schedulePendingOutboundFlush(delayMs = 0): void {
+        if (this.pendingOutboundFlushTimer) clearTimeout(this.pendingOutboundFlushTimer);
+        this.pendingOutboundFlushTimer = setTimeout(() => {
+            this.pendingOutboundFlushTimer = null;
+            void this.flushPendingOutboundQueue();
+        }, Math.max(0, delayMs));
+    }
+
+    private async flushPendingOutboundQueue(): Promise<void> {
+        if (this.pendingOutboundFlushInFlight || this.pendingOutboundQueue.length === 0) return;
+        if (this.currentStatus !== 'idle' || this.isWaitingForResponse || this.hasActionableApproval()) return;
+        this.pendingOutboundFlushInFlight = true;
+        try {
+            while (this.pendingOutboundQueue.length > 0) {
+                if (this.currentStatus !== 'idle' || this.isWaitingForResponse || this.hasActionableApproval()) break;
+                const next = this.pendingOutboundQueue[0];
+                this.recordTrace('send_message_queue_flush', {
+                    id: next.id,
+                    queuedAt: next.queuedAt,
+                    queueLength: this.pendingOutboundQueue.length,
+                    text: summarizeCliTraceText(next.content, 500),
+                });
+                try {
+                    await this.sendMessageNow(next.content, false);
+                    this.pendingOutboundQueue.shift();
+                    this.onStatusChange?.();
+                } catch (error: any) {
+                    LOG.warn('CLI', `[${this.cliType}] queued outbound flush failed: ${error?.message || error}`);
+                    this.schedulePendingOutboundFlush(1000);
+                    break;
+                }
+            }
+        } finally {
+            this.pendingOutboundFlushInFlight = false;
+        }
+    }
+
+    private async sendMessageNow(text: string, allowQueue: boolean): Promise<void> {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
         const allowInputDuringGeneration = this.provider.allowInputDuringGeneration === true;
         const allowInterventionPrompt = allowInputDuringGeneration
@@ -1937,27 +2131,33 @@ export class ProviderCliAdapter implements CliAdapter {
                 await new Promise(resolve => setTimeout(resolve, 50));
             }
         }
+        const parsedStatusBeforeSend = !allowInputDuringGeneration
+            ? (() => {
+                try {
+                    return this.getScriptParsedStatus?.() || null;
+                } catch {
+                    return null;
+                }
+            })()
+            : null;
+        const queueReason = this.shouldQueuePendingOutboundMessage(parsedStatusBeforeSend);
+        if (allowQueue && queueReason) {
+            this.enqueuePendingOutboundMessage(text, queueReason);
+            return;
+        }
         if (!allowInterventionPrompt) {
             await this.waitForInteractivePrompt();
         }
         if (!this.ready) {
             this.resolveStartupState('send_precheck');
-            if (this.runDetectStatus(this.recentOutputBuffer) === 'idle' && this.currentStatus === 'idle') {
+            if (this.runDetectStatus(this.recentOutputBuffer) === 'idle') {
                 this.ready = true;
                 this.startupParseGate = false;
+                this.setStatus('idle', 'send_message_idle_prompt_recovery');
                 LOG.info('CLI', `[${this.cliType}] sendMessage recovered idle prompt readiness`);
             }
         }
         if (!this.ready) throw new Error(`${this.cliName} not ready (status: ${this.currentStatus})`);
-        const parsedStatusBeforeSend = !allowInputDuringGeneration
-            ? (() => {
-                try {
-                    return this.getScriptParsedStatus?.() || null;
-                } catch {
-                    return null;
-                }
-            })()
-            : null;
         const parsedSessionStatus = typeof parsedStatusBeforeSend?.status === 'string'
             ? String(parsedStatusBeforeSend.status)
             : '';
@@ -1975,11 +2175,22 @@ export class ProviderCliAdapter implements CliAdapter {
                 && !this.hasActionableApproval()
                 && !parsedHasActionableModal;
             if (!terminalLooksIdle) {
+                if (allowQueue) {
+                    this.enqueuePendingOutboundMessage(text, `parsed_status_${parsedSessionStatus}`);
+                    return;
+                }
                 throw new Error(`${this.cliName} is still processing the previous prompt`);
             }
         }
         if (this.isWaitingForResponse && !allowInputDuringGeneration) {
-            if (!this.clearStaleIdleResponseGuard('send_message_guard')) {
+            if (
+                !this.clearStaleIdleResponseGuard('send_message_guard')
+                && !this.clearParsedIdleResponseGuard('send_message_parsed_idle_guard', parsedStatusBeforeSend)
+            ) {
+                if (allowQueue) {
+                    this.enqueuePendingOutboundMessage(text, 'waiting_for_response');
+                    return;
+                }
                 throw new Error(`${this.cliName} is still processing the previous prompt`);
             }
         }
@@ -2230,6 +2441,9 @@ export class ProviderCliAdapter implements CliAdapter {
         this.pendingTerminalQueryTail = '';
         this.ptyOutputChunks = [];
         this.finishRetryCount = 0;
+        if (this.pendingOutboundFlushTimer) { clearTimeout(this.pendingOutboundFlushTimer); this.pendingOutboundFlushTimer = null; }
+        this.pendingOutboundQueue = [];
+        this.pendingOutboundFlushInFlight = false;
         if (this.ptyProcess) {
             this.ptyProcess.write('\x03');
             setTimeout(() => {
@@ -2251,6 +2465,9 @@ export class ProviderCliAdapter implements CliAdapter {
         this.pendingTerminalQueryTail = '';
         this.ptyOutputChunks = [];
         this.finishRetryCount = 0;
+        if (this.pendingOutboundFlushTimer) { clearTimeout(this.pendingOutboundFlushTimer); this.pendingOutboundFlushTimer = null; }
+        this.pendingOutboundQueue = [];
+        this.pendingOutboundFlushInFlight = false;
         if (this.ptyProcess) {
             try {
                 if (typeof this.ptyProcess.detach === 'function') {
@@ -2281,6 +2498,9 @@ export class ProviderCliAdapter implements CliAdapter {
         this.ptyOutputChunks = [];
         if (this.finishRetryTimer) { clearTimeout(this.finishRetryTimer); this.finishRetryTimer = null; }
         this.finishRetryCount = 0;
+        if (this.pendingOutboundFlushTimer) { clearTimeout(this.pendingOutboundFlushTimer); this.pendingOutboundFlushTimer = null; }
+        this.pendingOutboundQueue = [];
+        this.pendingOutboundFlushInFlight = false;
         this.resetTerminalScreen();
         this.ptyProcess?.clearBuffer?.();
         this.onStatusChange?.();
@@ -2369,10 +2589,23 @@ export class ProviderCliAdapter implements CliAdapter {
     getDebugState(): Record<string, any> {
         const screenText = sanitizeTerminalText(this.terminalScreen.getText());
         const startupModal = this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
-        const effectiveStatus = this.projectEffectiveStatus(startupModal);
-        const effectiveReady = this.ready || !!startupModal;
+        const startupDetectedStatus = this.startupParseGate && !startupModal
+            ? this.runDetectStatus(this.recentOutputBuffer || screenText)
+            : null;
+        const effectiveReady = this.ready || !!startupModal || startupDetectedStatus === 'waiting_approval';
         const parsedDebugState = this.getParsedDebugState();
         const parsedMessages = Array.isArray(parsedDebugState?.messages) ? parsedDebugState.messages : [];
+        let effectiveStatus = this.projectEffectiveStatus(startupModal);
+        if (startupDetectedStatus === 'waiting_approval') {
+            effectiveStatus = 'waiting_approval';
+        }
+        if (
+            effectiveStatus === 'idle'
+            && parsedDebugState?.status === 'generating'
+            && !this.parsedStatusHasFinalAssistantMessage(parsedDebugState)
+        ) {
+            effectiveStatus = 'generating';
+        }
         return {
             type: this.cliType,
             name: this.cliName,
@@ -2407,6 +2640,14 @@ export class ProviderCliAdapter implements CliAdapter {
             rawBufferPreview: this.accumulatedRawBuffer.slice(-1000),
             sanitizedRawPreview: sanitizeTerminalText(this.accumulatedRawBuffer).slice(-1000),
             responseBuffer: this.responseBuffer.slice(-1000),
+            pendingOutboundQueue: this.pendingOutboundQueue.map((message) => ({
+                id: message.id,
+                role: message.role,
+                content: message.content,
+                queuedAt: message.queuedAt,
+                source: message.source,
+            })),
+            pendingOutboundCount: this.pendingOutboundQueue.length,
             lastOutputAt: this.lastOutputAt,
             lastNonEmptyOutputAt: this.lastNonEmptyOutputAt,
             lastScreenChangeAt: this.lastScreenChangeAt,

package/src/cli-adapters/provider-cli-parse.d.ts

@@ -15,6 +15,7 @@ export declare function buildCliParseInput(options: {
     accumulatedRawBuffer: string;
     recentOutputBuffer: string;
     terminalScreenText: string;
+    workingDir?: string;
     baseMessages: CliChatMessage[];
     partialResponse: string;
     isWaitingForResponse?: boolean;

package/src/cli-adapters/provider-cli-parse.ts

@@ -35,6 +35,7 @@ export function buildCliParseInput(options: {
     accumulatedRawBuffer: string;
     recentOutputBuffer: string;
     terminalScreenText: string;
+    workingDir?: string;
     baseMessages: CliChatMessage[];
     partialResponse: string;
     isWaitingForResponse?: boolean;
@@ -46,6 +47,7 @@ export function buildCliParseInput(options: {
         accumulatedRawBuffer,
         recentOutputBuffer,
         terminalScreenText,
+        workingDir,
         baseMessages,
         partialResponse,
         isWaitingForResponse,
@@ -66,6 +68,8 @@ export function buildCliParseInput(options: {
         rawBuffer,
         recentBuffer,
         screenText,
+        workspace: workingDir,
+        workingDir,
         screen: buildCliScreenSnapshot(screenText),
         bufferScreen: buildCliScreenSnapshot(buffer),
         recentScreen: buildCliScreenSnapshot(recentBuffer),

package/src/cli-adapters/provider-cli-runtime.ts

@@ -36,7 +36,9 @@ export function resolveCliSpawnPlan(options: {
         : spawnConfig.command;
     const binaryPath = findBinary(configuredCommand);
     const isWin = os.platform() === 'win32';
-    const allArgs = [...spawnConfig.args, ...extraArgs];
+    const allArgs = [...spawnConfig.args, ...extraArgs].map((arg) =>
+        typeof arg === 'string' ? arg.replace(/\{\{workingDir\}\}/g, workingDir) : arg,
+    );
 
     let shellCmd: string;
     let shellArgs: string[];

package/src/cli-adapters/provider-cli-shared.d.ts

@@ -55,6 +55,8 @@ export interface CliScriptInput {
     rawBuffer: string;
     recentBuffer: string;
     screenText: string;
+    workspace?: string;
+    workingDir?: string;
     screen: CliScreenSnapshot;
     bufferScreen: CliScreenSnapshot;
     recentScreen: CliScreenSnapshot;

package/src/cli-adapters/provider-cli-shared.ts

@@ -28,6 +28,14 @@ export interface CliSessionStatus {
     messages: CliChatMessage[];
     workingDir: string;
     activeModal: { message: string; buttons: string[] } | null;
+    pendingOutboundCount?: number;
+    pendingOutboundMessages?: Array<{
+        id: string;
+        role: 'user';
+        content: string;
+        queuedAt: number;
+        source: string;
+    }>;
     errorMessage?: string;
     errorReason?: string;
     bufferState?: {
@@ -94,6 +102,8 @@ export interface CliScriptInput {
     rawBuffer: string;
     recentBuffer: string;
     screenText: string;
+    workspace?: string;
+    workingDir?: string;
     screen: CliScreenSnapshot;
     bufferScreen: CliScreenSnapshot;
     recentScreen: CliScreenSnapshot;
@@ -484,17 +494,25 @@ export function findBinary(name: string): string {
         return path.isAbsolute(expanded) ? expanded : path.resolve(expanded);
     }
     const isWin = os.platform() === 'win32';
-    try {
-        const cmd = isWin ? `where ${trimmed}` : `which ${trimmed}`;
-        return execSync(cmd, {
-            encoding: 'utf-8',
-            timeout: 5000,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            ...(isWin ? { windowsHide: true } : {}),
-        }).trim().split('\n')[0].trim();
-    } catch {
-        return isWin ? `${trimmed}.cmd` : trimmed;
+    const paths = (process.env.PATH || '').split(path.delimiter);
+    const exes = isWin ? ['.exe', '.cmd', '.bat', ''] : [''];
+    
+    for (const p of paths) {
+        if (!p) continue;
+        for (const ext of exes) {
+            const fullPath = path.join(p, trimmed + ext);
+            try {
+                const fs = require('fs');
+                if (fs.existsSync(fullPath)) {
+                    const stat = fs.statSync(fullPath);
+                    if (stat.isFile() && (isWin || (stat.mode & 0o111))) {
+                        return fullPath;
+                    }
+                }
+            } catch { }
+        }
     }
+    return isWin ? `${trimmed}.cmd` : trimmed;
 }
 
 export function isScriptBinary(binaryPath: string): boolean {