@probelabs/probe 0.6.0-rc278 → 0.6.0-rc280

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc278",
+  "version": "0.6.0-rc280",
   "description": "Node.js wrapper for the probe code search tool",
   "main": "src/index.js",
   "module": "src/index.js",

package/src/agent/ProbeAgent.js

@@ -125,6 +125,27 @@ const MAX_HISTORY_MESSAGES = 100;
 // Maximum image file size (20MB) to prevent OOM attacks
 const MAX_IMAGE_FILE_SIZE = 20 * 1024 * 1024;
 
+/**
+ * Truncate a string for debug logging, showing first and last portion.
+ */
+export function debugTruncate(s, limit = 200) {
+  if (s.length <= limit) return s;
+  const half = Math.floor(limit / 2);
+  return s.substring(0, half) + ` ... [${s.length} chars] ... ` + s.substring(s.length - half);
+}
+
+/**
+ * Log tool results details for debug output.
+ */
+export function debugLogToolResults(toolResults) {
+  if (!toolResults || toolResults.length === 0) return;
+  for (const tr of toolResults) {
+    const argsStr = JSON.stringify(tr.args || {});
+    const resultStr = typeof tr.result === 'string' ? tr.result : JSON.stringify(tr.result || '');
+    console.log(`[DEBUG]   tool: ${tr.toolName} | args: ${debugTruncate(argsStr)} | result: ${debugTruncate(resultStr)}`);
+  }
+}
+
 /**
  * ProbeAgent class to handle AI interactions with code search capabilities
  */
@@ -193,6 +214,7 @@ export class ProbeAgent {
     this.enableExecutePlan = !!options.enableExecutePlan;
     this.debug = options.debug || process.env.DEBUG === '1';
     this.cancelled = false;
+    this._abortController = new AbortController();
     this.tracer = options.tracer || null;
     this.outline = !!options.outline;
     this.searchDelegate = options.searchDelegate !== undefined ? !!options.searchDelegate : true;
@@ -232,6 +254,7 @@ export class ProbeAgent {
     // Supports exclusion with '!' prefix: ['*', '!bash'] = all tools except bash
     // disableTools is a convenience flag that overrides allowedTools to []
     const effectiveAllowedTools = options.disableTools ? [] : options.allowedTools;
+    this._rawAllowedTools = options.allowedTools; // Keep raw value for explicit tool checks
     this.allowedTools = this._parseAllowedTools(effectiveAllowedTools);
 
     // Storage adapter (defaults to in-memory)
@@ -459,6 +482,17 @@ export class ProbeAgent {
     return mcpToolNames.filter(toolName => this._isMcpToolAllowed(toolName));
   }
 
+  /**
+   * Check if query tool was explicitly listed in allowedTools (not via wildcard).
+   * Query (ast-grep) is excluded by default because models struggle with AST pattern syntax.
+   * @returns {boolean}
+   * @private
+   */
+  _isQueryExplicitlyAllowed() {
+    if (!this._rawAllowedTools) return false;
+    return Array.isArray(this._rawAllowedTools) && this._rawAllowedTools.includes('query');
+  }
+
   /**
    * Check if tracer is AppTracer (expects sessionId as first param) vs SimpleAppTracer
    * @returns {boolean} - True if tracer is AppTracer style (requires sessionId)
@@ -792,6 +826,7 @@ export class ProbeAgent {
       searchDelegateProvider: this.searchDelegateProvider,
       searchDelegateModel: this.searchDelegateModel,
       delegationManager: this.delegationManager,  // Per-instance delegation limits
+      parentAbortSignal: this._abortController.signal,  // Propagate cancellation to delegations
       outputBuffer: this._outputBuffer,
       concurrencyLimiter: this.concurrencyLimiter,  // Global AI concurrency limiter
       isToolAllowed,
@@ -814,7 +849,9 @@ export class ProbeAgent {
     if (wrappedTools.searchToolInstance && isToolAllowed('search')) {
       this.toolImplementations.search = wrappedTools.searchToolInstance;
     }
-    if (wrappedTools.queryToolInstance && isToolAllowed('query')) {
+    // query tool (ast-grep) is not exposed to AI by default — models struggle with AST pattern syntax.
+    // Only register it when explicitly listed in allowedTools (not via wildcard '*').
+    if (wrappedTools.queryToolInstance && isToolAllowed('query') && this._isQueryExplicitlyAllowed()) {
       this.toolImplementations.query = wrappedTools.queryToolInstance;
     }
     if (wrappedTools.extractToolInstance && isToolAllowed('extract')) {
@@ -1362,6 +1399,19 @@ export class ProbeAgent {
     const controller = new AbortController();
     const timeoutState = { timeoutId: null };
 
+    // Link agent-level abort to this operation's controller
+    // so that cancel() / cleanup() stops the current streamText call
+    if (this._abortController.signal.aborted) {
+      controller.abort();
+    } else {
+      const onAgentAbort = () => controller.abort();
+      this._abortController.signal.addEventListener('abort', onAgentAbort, { once: true });
+      // Clean up listener when this controller aborts (from any source)
+      controller.signal.addEventListener('abort', () => {
+        this._abortController.signal.removeEventListener('abort', onAgentAbort);
+      }, { once: true });
+    }
+
     // Set up overall operation timeout (default 5 minutes)
     if (this.maxOperationTimeout && this.maxOperationTimeout > 0) {
       timeoutState.timeoutId = setTimeout(() => {
@@ -1729,7 +1779,8 @@ export class ProbeAgent {
                 allowEdit: this.allowEdit,
                 allowedTools: allowedToolsForDelegate,
                 debug: this.debug,
-                tracer: this.tracer
+                tracer: this.tracer,
+                parentAbortSignal: this._abortController.signal
               };
 
               if (this.debug) {
@@ -1971,12 +2022,15 @@ export class ProbeAgent {
     const toolMap = {
       search: {
         schema: searchSchema,
-        description: 'Search code in the repository using keyword queries with Elasticsearch syntax.'
-      },
-      query: {
-        schema: querySchema,
-        description: 'Search code using ast-grep structural pattern matching.'
+        description: this.searchDelegate
+          ? 'Search code in the repository by asking a question. Accepts natural language questions — a subagent breaks them into targeted keyword searches and returns extracted code blocks. Do NOT formulate keyword queries yourself.'
+          : 'Search code in the repository using keyword queries with Elasticsearch syntax. Handles stemming, case-insensitive matching, and camelCase/snake_case splitting automatically — do NOT try keyword variations manually.'
       },
+      // query tool (ast-grep) removed from AI-facing tools — models struggle with pattern syntax
+      // query: {
+      //   schema: querySchema,
+      //   description: 'Search code using ast-grep structural pattern matching.'
+      // },
       extract: {
         schema: extractSchema,
         description: 'Extract code blocks from files based on file paths and optional line numbers.'
@@ -2812,10 +2866,12 @@ export class ProbeAgent {
     }
 
     // Add high-level instructions about when to use tools
+    const searchToolDesc1 = this.searchDelegate
+      ? '- search: Ask natural language questions to find code (e.g., "How does authentication work?"). A subagent handles keyword searches and returns extracted code blocks. Do NOT formulate keyword queries — just ask questions.'
+      : '- search: Find code patterns using keyword queries with Elasticsearch syntax. Handles stemming and case variations automatically — do NOT try manual keyword variations.';
     systemPrompt += `You have access to powerful code search and analysis tools through MCP:
-- search: Find code patterns using semantic search
+${searchToolDesc1}
 - extract: Extract specific code sections with context
-- query: Use AST patterns for structural code matching
 - listFiles: Browse directory contents
 - searchFiles: Find files by name patterns`;
 
@@ -2823,19 +2879,21 @@ export class ProbeAgent {
       systemPrompt += `\n- bash: Execute bash commands for system operations`;
     }
 
-    const searchGuidance = this.searchDelegate
-      ? '1. Start with search to retrieve extracted code blocks'
-      : '1. Start with search to find relevant code patterns';
-    const extractGuidance = this.searchDelegate
+    const searchGuidance1 = this.searchDelegate
+      ? '1. Start with search — ask a question about what you want to understand. It returns extracted code blocks directly.'
+      : '1. Start with search to find relevant code patterns. One search per concept is usually enough — probe handles stemming and case variations.';
+    const extractGuidance1 = this.searchDelegate
       ? '2. Use extract only if you need more context or a full file'
       : '2. Use extract to get detailed context when needed';
 
     systemPrompt += `\n
 When exploring code:
-${searchGuidance}
-${extractGuidance}
+${searchGuidance1}
+${extractGuidance1}
 3. Prefer focused, specific searches over broad queries
-4. Combine multiple tools to build complete understanding`;
+4. Do NOT repeat the same search or try trivial keyword variations — probe handles stemming and case variations automatically
+5. If 2-3 consecutive searches return no results for a concept, stop searching for it — the term likely does not exist in that codebase
+6. Combine multiple tools to build complete understanding`;
 
     // Add workspace context
     if (this.allowedFolders && this.allowedFolders.length > 0) {
@@ -2874,10 +2932,12 @@ ${extractGuidance}
     }
 
     // Add high-level instructions about when to use tools
+    const searchToolDesc2 = this.searchDelegate
+      ? '- search: Ask natural language questions to find code (e.g., "How does authentication work?"). A subagent handles keyword searches and returns extracted code blocks. Do NOT formulate keyword queries — just ask questions.'
+      : '- search: Find code patterns using keyword queries with Elasticsearch syntax. Handles stemming and case variations automatically — do NOT try manual keyword variations.';
     systemPrompt += `You have access to powerful code search and analysis tools through MCP:
-- search: Find code patterns using semantic search
+${searchToolDesc2}
 - extract: Extract specific code sections with context
-- query: Use AST patterns for structural code matching
 - listFiles: Browse directory contents
 - searchFiles: Find files by name patterns`;
 
@@ -2885,19 +2945,21 @@ ${extractGuidance}
       systemPrompt += `\n- bash: Execute bash commands for system operations`;
     }
 
-    const searchGuidance = this.searchDelegate
-      ? '1. Start with search to retrieve extracted code blocks'
-      : '1. Start with search to find relevant code patterns';
-    const extractGuidance = this.searchDelegate
+    const searchGuidance2 = this.searchDelegate
+      ? '1. Start with search — ask a question about what you want to understand. It returns extracted code blocks directly.'
+      : '1. Start with search to find relevant code patterns. One search per concept is usually enough — probe handles stemming and case variations.';
+    const extractGuidance2 = this.searchDelegate
       ? '2. Use extract only if you need more context or a full file'
       : '2. Use extract to get detailed context when needed';
 
     systemPrompt += `\n
 When exploring code:
-${searchGuidance}
-${extractGuidance}
+${searchGuidance2}
+${extractGuidance2}
 3. Prefer focused, specific searches over broad queries
-4. Combine multiple tools to build complete understanding`;
+4. Do NOT repeat the same search or try trivial keyword variations — probe handles stemming and case variations automatically
+5. If 2-3 consecutive searches return no results for a concept, stop searching for it — the term likely does not exist in that codebase
+6. Combine multiple tools to build complete understanding`;
 
     // Add workspace context
     if (this.allowedFolders && this.allowedFolders.length > 0) {
@@ -2953,10 +3015,10 @@ ${extractGuidance}
 Follow these instructions carefully:
 1. Analyze the user's request.
 2. Use the available tools step-by-step to fulfill the request.
-3. You should always prefer the search tool for code-related questions.${this.searchDelegate ? ' It already returns extracted code blocks; use extract only to expand context or read full files.' : ' Read full files only if really necessary.'}
+3. You should always prefer the search tool for code-related questions.${this.searchDelegate ? ' Ask natural language questions — the search subagent handles keyword formulation and returns extracted code blocks. Use extract only to expand context or read full files.' : ' Search handles stemming and case variations automatically — do NOT try keyword variations manually. Read full files only if really necessary.'}
 4. Ensure to get really deep and understand the full picture before answering.
 5. Once the task is fully completed, use the attempt_completion tool to provide the final result.
-6. Prefer concise and focused search queries. Use specific keywords and phrases to narrow down results.${this.allowEdit ? `
+6. ${this.searchDelegate ? 'Ask clear, specific questions when searching. Each search should target a distinct concept or question.' : 'Prefer concise and focused search queries. Use specific keywords and phrases to narrow down results.'}${this.allowEdit ? `
 7. When modifying files, choose the appropriate tool:
     - Use 'edit' for all code modifications:
       * PREFERRED: Use start_line (and optionally end_line) for line-targeted editing — this is the safest and most precise approach.${this.hashLines ? ' Use the line:hash references from extract/search output (e.g. "42:ab") for integrity verification.' : ''} Always use extract first to see line numbers${this.hashLines ? ' and hashes' : ''}, then edit by line reference.
@@ -3369,6 +3431,11 @@ Follow these instructions carefully:
         completionAttempted = true;
       }, toolContext);
 
+      if (this.debug) {
+        const toolNames = Object.keys(tools);
+        console.log(`[DEBUG] Agent tools registered (${toolNames.length}): ${toolNames.join(', ')}`);
+      }
+
       let maxResponseTokens = this.maxResponseTokens;
       if (!maxResponseTokens) {
         maxResponseTokens = 4000;
@@ -3418,6 +3485,7 @@ Follow these instructions carefully:
 
               if (this.debug) {
                 console.log(`[DEBUG] Step ${currentIteration}/${maxIterations} finished (reason: ${finishReason}, tools: ${toolResults?.length || 0})`);
+                debugLogToolResults(toolResults);
               }
             }
           };
@@ -3629,6 +3697,7 @@ Double-check your response based on the criteria above. If everything looks good
               }
               if (this.debug) {
                 console.log(`[DEBUG] Completion prompt step finished (reason: ${finishReason}, tools: ${toolResults?.length || 0})`);
+                debugLogToolResults(toolResults);
               }
             }
           };
@@ -4545,6 +4614,11 @@ Convert your previous response content into actual JSON data that follows this s
    * Clean up resources (including MCP connections)
    */
   async cleanup() {
+    // Abort any in-flight operations (delegations, streaming, etc.)
+    if (!this._abortController.signal.aborted) {
+      this._abortController.abort();
+    }
+
     // Clean up MCP bridge
     if (this.mcpBridge) {
       try {
@@ -4574,12 +4648,24 @@ Convert your previous response content into actual JSON data that follows this s
   }
 
   /**
-   * Cancel the current request
+   * Cancel the current request and all in-flight delegations.
+   * Aborts the internal AbortController so streamText, subagents,
+   * and any code checking the signal will stop.
    */
   cancel() {
     this.cancelled = true;
+    this._abortController.abort();
     if (this.debug) {
       console.log(`[DEBUG] Agent cancelled for session ${this.sessionId}`);
     }
   }
+
+  /**
+   * Get the abort signal for this agent.
+   * Delegations and subagents should check this signal.
+   * @returns {AbortSignal}
+   */
+  get abortSignal() {
+    return this._abortController.signal;
+  }
 }

package/src/agent/dsl/environment.js

@@ -284,6 +284,7 @@ export function generateSandboxGlobals(options) {
       results.push(p);
 
       if (executing.size >= mapConcurrency) {
+        console.error(`[map] Concurrency limit reached (${executing.size}/${mapConcurrency}), waiting for a slot...`);
         await Promise.race(executing);
       }
     }

package/src/delegate.js

@@ -122,20 +122,20 @@ class DelegationManager {
 		}
 
 		// Need to wait in queue
-		if (debug) {
-			console.error(`[DelegationManager] Slot unavailable (${this.globalActive}/${this.maxConcurrent}), queuing... (queue size: ${this.waitQueue.length}, timeout: ${effectiveTimeout}ms)`);
-		}
+		console.error(`[DelegationManager] Slot unavailable (${this.globalActive}/${this.maxConcurrent}), queuing... (queue size: ${this.waitQueue.length + 1}, timeout: ${effectiveTimeout}ms)`);
 
 		// Create a promise that will be resolved when a slot becomes available
 		// or rejected if session limit is exceeded or queue timeout expires
 		return new Promise((resolve, reject) => {
+			const queuedAt = Date.now();
 			const entry = {
 				resolve: null,  // Will be wrapped below
 				reject: null,   // Will be wrapped below
 				parentSessionId,
 				debug,
-				queuedAt: Date.now(),
-				timeoutId: null
+				queuedAt,
+				timeoutId: null,
+				reminderId: null
 			};
 
 			// Wrap resolve/reject to clear timeout and prevent double-settling
@@ -144,12 +144,14 @@ class DelegationManager {
 				if (settled) return;
 				settled = true;
 				if (entry.timeoutId) clearTimeout(entry.timeoutId);
+				if (entry.reminderId) clearInterval(entry.reminderId);
 				resolve(value);
 			};
 			entry.reject = (error) => {
 				if (settled) return;
 				settled = true;
 				if (entry.timeoutId) clearTimeout(entry.timeoutId);
+				if (entry.reminderId) clearInterval(entry.reminderId);
 				reject(error);
 			};
 
@@ -165,6 +167,15 @@ class DelegationManager {
 				}, effectiveTimeout);
 			}
 
+			// Always emit periodic wait visibility while queued.
+			entry.reminderId = setInterval(() => {
+				const waitedSeconds = Math.round((Date.now() - queuedAt) / 1000);
+				console.error(`[DelegationManager] Still waiting for slot (${waitedSeconds}s). ${this.globalActive}/${this.maxConcurrent} active, ${this.waitQueue.length} queued.`);
+			}, 15000);
+			if (entry.reminderId.unref) {
+				entry.reminderId.unref();
+			}
+
 			this.waitQueue.push(entry);
 		});
 	}
@@ -221,9 +232,7 @@ class DelegationManager {
 				if (sessionCount >= this.maxPerSession) {
 					// Session limit reached - reject with error (consistent with tryAcquire behavior)
 					// This is a hard limit, not something that will resolve by waiting longer
-					if (debug) {
-						console.error(`[DelegationManager] Session limit (${this.maxPerSession}) reached for queued item, rejecting`);
-					}
+					console.error(`[DelegationManager] Session limit (${this.maxPerSession}) reached for queued item, rejecting`);
 					toReject.push({ reject, error: new Error(`Maximum delegations per session (${this.maxPerSession}) reached for session ${parentSessionId}`) });
 					// Continue to process next item in queue
 					continue;
@@ -233,10 +242,8 @@ class DelegationManager {
 			// Grant the slot
 			this._incrementCounters(parentSessionId);
 
-			if (debug) {
-				const waitTime = Date.now() - queuedAt;
-				console.error(`[DelegationManager] Granted slot from queue (waited ${waitTime}ms). Active: ${this.globalActive}/${this.maxConcurrent}`);
-			}
+			const waitTime = Date.now() - queuedAt;
+			console.error(`[DelegationManager] Granted slot from queue (waited ${waitTime}ms). Active: ${this.globalActive}/${this.maxConcurrent}`);
 
 			toResolve.push(resolve);
 		}
@@ -296,6 +303,9 @@ class DelegationManager {
 			if (entry.timeoutId) {
 				clearTimeout(entry.timeoutId);
 			}
+			if (entry.reminderId) {
+				clearInterval(entry.reminderId);
+			}
 			// Reject pending entries so they don't hang
 			if (entry.reject) {
 				entry.reject(new Error('DelegationManager was cleaned up'));
@@ -386,12 +396,18 @@ export async function delegate({
 	mcpConfig = null,
 	mcpConfigPath = null,
 	delegationManager = null,  // Optional per-instance manager, falls back to default singleton
-	concurrencyLimiter = null  // Optional global AI concurrency limiter
+	concurrencyLimiter = null,  // Optional global AI concurrency limiter
+	parentAbortSignal = null   // Optional AbortSignal from parent to cancel this delegation
 }) {
 	if (!task || typeof task !== 'string') {
 		throw new Error('Task parameter is required and must be a string');
 	}
 
+	// Check if parent has already been cancelled
+	if (parentAbortSignal?.aborted) {
+		throw new Error('Delegation cancelled: parent operation was aborted');
+	}
+
 	// Support runtime timeout override via environment variables when timeout not explicitly passed
 	// This allows operators to configure delegation timeouts without code changes
 	// Priority: DELEGATION_TIMEOUT_MS (milliseconds) > DELEGATION_TIMEOUT_SECONDS > DELEGATION_TIMEOUT (seconds)
@@ -481,24 +497,47 @@ export async function delegate({
 			console.error(`[DELEGATE] Subagent config: promptType=${promptType}, enableDelegate=false, maxIterations=${remainingIterations}`);
 		}
 
-		// Set up timeout with proper cleanup
-		// TODO: Implement AbortController support in ProbeAgent.answer() for proper cancellation
-		// Current limitation: When timeout occurs, subagent.answer() continues running in background
-		// This is acceptable since:
-		// 1. The promise will eventually resolve/reject and be garbage collected
-		// 2. The delegation slot is properly released on timeout
-		// 3. The parent receives timeout error and can handle it
-		// Future improvement: Add signal parameter to ProbeAgent.answer(task, [], { signal })
+		// Set up timeout and parent abort handling.
+		// When timeout fires or parent aborts, we cancel the subagent so it
+		// stops making API calls and releases resources promptly.
 		const timeoutPromise = new Promise((_, reject) => {
 			timeoutId = setTimeout(() => {
+				subagent.cancel();
 				reject(new Error(`Delegation timed out after ${timeout} seconds`));
 			}, timeout * 1000);
 		});
 
-		// Execute the task with timeout
+		// Listen for parent abort signal
+		let parentAbortHandler;
+		const parentAbortPromise = new Promise((_, reject) => {
+			if (parentAbortSignal) {
+				if (parentAbortSignal.aborted) {
+					subagent.cancel();
+					reject(new Error('Delegation cancelled: parent operation was aborted'));
+					return;
+				}
+				parentAbortHandler = () => {
+					subagent.cancel();
+					reject(new Error('Delegation cancelled: parent operation was aborted'));
+				};
+				parentAbortSignal.addEventListener('abort', parentAbortHandler, { once: true });
+			}
+		});
+
+		// Execute the task with timeout and parent abort
 		const answerOptions = schema ? { schema } : undefined;
 		const answerPromise = answerOptions ? subagent.answer(task, [], answerOptions) : subagent.answer(task);
-		const response = await Promise.race([answerPromise, timeoutPromise]);
+		const racers = [answerPromise, timeoutPromise];
+		if (parentAbortSignal) racers.push(parentAbortPromise);
+		let response;
+		try {
+			response = await Promise.race(racers);
+		} finally {
+			// Clean up parent abort listener to prevent memory leaks
+			if (parentAbortHandler && parentAbortSignal) {
+				parentAbortSignal.removeEventListener('abort', parentAbortHandler);
+			}
+		}
 
 		// Clear timeout immediately after race completes to prevent memory leak
 		// Note: timeoutId is always set by this point (synchronous in Promise constructor)

package/src/downloader.js

@@ -95,9 +95,7 @@ async function acquireFileLock(lockPath, version) {
 	try {
 		// Try to create lock file atomically (fails if already exists)
 		await fs.writeFile(lockPath, JSON.stringify(lockData), { flag: 'wx' });
-		if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
-			console.log(`Acquired file lock: ${lockPath}`);
-		}
+		console.log(`Acquired file lock: ${lockPath}`);
 		return true;
     } catch (error) {
 		if (error.code === 'EEXIST') {
@@ -108,17 +106,13 @@ async function acquireFileLock(lockPath, version) {
 
 				if (lockAge > LOCK_TIMEOUT_MS) {
 					// Lock is stale, remove it
-					if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
-						console.log(`Removing stale lock file (age: ${Math.round(lockAge / 1000)}s, pid: ${existingLock.pid})`);
-					}
+					console.log(`Removing stale lock file (age: ${Math.round(lockAge / 1000)}s, pid: ${existingLock.pid})`);
 					await fs.remove(lockPath);
 					return false; // Caller should retry
 				}
 
 				// Lock is fresh, another process is downloading
-				if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
-					console.log(`Download in progress by process ${existingLock.pid}, waiting...`);
-				}
+				console.log(`Download in progress by process ${existingLock.pid}, waiting...`);
 				return false;
 			} catch (readError) {
 				// Can't read lock file, might be corrupted - remove it
@@ -180,23 +174,23 @@ async function releaseFileLock(lockPath) {
  */
 async function waitForFileLock(lockPath, binaryPath) {
 	const startTime = Date.now();
+	let lastStatusTime = startTime;
+
+	console.log(`Waiting for file lock to clear: ${lockPath}`);
 
 	// Poll in a loop until binary appears, lock expires, or we timeout
 	while (Date.now() - startTime < MAX_LOCK_WAIT_MS) {
 		// Check #1: Is the binary now available?
 		if (await fs.pathExists(binaryPath)) {
-			if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
-				console.log(`Binary now available at ${binaryPath}, download completed by another process`);
-			}
+			const waitedSeconds = Math.round((Date.now() - startTime) / 1000);
+			console.log(`Binary now available at ${binaryPath}, download completed by another process (waited ${waitedSeconds}s)`);
 			return true;
 		}
 
 		// Check #2: Is the lock file gone? (download finished or failed)
 		const lockExists = await fs.pathExists(lockPath);
 		if (!lockExists) {
-			if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
-				console.log(`Lock file removed but binary not found - download may have failed`);
-			}
+			console.log(`Lock file removed but binary not found - download may have failed`);
 			return false;
 		}
 
@@ -205,22 +199,24 @@ async function waitForFileLock(lockPath, binaryPath) {
 			const lockData = JSON.parse(await fs.readFile(lockPath, 'utf-8'));
 			const lockAge = Date.now() - lockData.timestamp;
 			if (lockAge > LOCK_TIMEOUT_MS) {
-				if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
-					console.log(`Lock expired (age: ${Math.round(lockAge / 1000)}s), will retry download`);
-				}
+				console.log(`Lock expired (age: ${Math.round(lockAge / 1000)}s), will retry download`);
 				return false;
 			}
 		} catch {
 			// Ignore errors reading lock file - will retry on next poll
 		}
 
+		if (Date.now() - lastStatusTime >= 15000) {
+			const elapsedSeconds = Math.round((Date.now() - startTime) / 1000);
+			console.log(`Still waiting for file lock (${elapsedSeconds}s/${MAX_LOCK_WAIT_MS / 1000}s max)`);
+			lastStatusTime = Date.now();
+		}
+
 		// Wait 1 second before checking again
 		await new Promise(resolve => setTimeout(resolve, LOCK_POLL_INTERVAL_MS));
 	}
 
-	if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
-		console.log(`Timeout waiting for file lock`);
-	}
+	console.log(`Timeout waiting for file lock after ${MAX_LOCK_WAIT_MS / 1000}s`);
 	return false;
 }
 
@@ -247,9 +243,7 @@ async function withDownloadLock(version, downloadFn) {
 			}
 			downloadLocks.delete(lockKey);
 		} else {
-			if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
-				console.log(`Download already in progress in this process for version ${lockKey}, waiting...`);
-			}
+			console.log(`Download already in progress in this process for version ${lockKey}, waiting...`);
 			try {
 				return await lock.promise;
 			} catch (error) {
@@ -262,10 +256,16 @@ async function withDownloadLock(version, downloadFn) {
 	}
 
 	// Create new download promise with timeout protection
+	let timeoutId = null;
 	const downloadPromise = Promise.race([
 		downloadFn(),
 		new Promise((_, reject) =>
-			setTimeout(() => reject(new Error(`Download timeout after ${LOCK_TIMEOUT_MS / 1000}s`)), LOCK_TIMEOUT_MS)
+			{
+				timeoutId = setTimeout(() => reject(new Error(`Download timeout after ${LOCK_TIMEOUT_MS / 1000}s`)), LOCK_TIMEOUT_MS);
+				if (timeoutId.unref) {
+					timeoutId.unref();
+				}
+			}
 		)
 	]);
 
@@ -278,6 +278,9 @@ async function withDownloadLock(version, downloadFn) {
 		const result = await downloadPromise;
 		return result;
 	} finally {
+		if (timeoutId) {
+			clearTimeout(timeoutId);
+		}
 		// Clean up lock after download completes (success or failure)
 		downloadLocks.delete(lockKey);
 	}