@probelabs/probe 0.6.0-rc292 → 0.6.0-rc294

package/build/agent/ProbeAgent.js

@@ -1341,9 +1341,16 @@ export class ProbeAgent {
     // Use fallback manager with retry for each provider
     return await this.fallbackManager.executeWithFallback(
       async (provider, model, config) => {
+        // Wrap fallback model with per-call concurrency limiter if configured.
+        // The original options.model was wrapped in streamTextWithRetryAndFallback,
+        // but fallback replaces it with a new model that needs wrapping too.
+        let fallbackModel = provider(model);
+        if (this.concurrencyLimiter) {
+          fallbackModel = ProbeAgent._wrapModelWithLimiter(fallbackModel, this.concurrencyLimiter, this.debug);
+        }
         const fallbackOptions = {
           ...options,
-          model: provider(model),
+          model: fallbackModel,
           abortSignal: controller.signal
         };
 
@@ -1377,6 +1384,143 @@ export class ProbeAgent {
     );
   }
 
+  /**
+   * Wrap a LanguageModelV1 model so each doStream/doGenerate call acquires and
+   * releases a concurrency limiter slot. This gates individual LLM API calls
+   * (seconds each) instead of entire multi-step agent sessions (minutes).
+   *
+   * @param {Object} model - LanguageModelV1 model instance
+   * @param {Object} limiter - Concurrency limiter with acquire/release/getStats
+   * @param {boolean} debug - Enable debug logging
+   * @returns {Object} Wrapped model with per-call concurrency gating
+   * @private
+   */
+  static _wrapModelWithLimiter(model, limiter, debug) {
+    return new Proxy(model, {
+      get(target, prop) {
+        if (prop === 'doStream') {
+          return async function (...args) {
+            await limiter.acquire(null);
+            if (debug) {
+              const stats = limiter.getStats();
+              console.log(`[DEBUG] Acquired AI slot for LLM call (${stats.globalActive}/${stats.maxConcurrent}, queue: ${stats.queueSize})`);
+            }
+            try {
+              const result = await target.doStream(...args);
+
+              // Wrap the ReadableStream to release the slot when it completes,
+              // errors, or is cancelled — covering all stream termination paths.
+              // Guard against double-release: if cancel() races with an in-flight
+              // pull() that is awaiting originalReader.read(), both paths could
+              // try to release. The flag ensures exactly one release.
+              const originalStream = result.stream;
+              const originalReader = originalStream.getReader();
+              let released = false;
+              const releaseOnce = () => {
+                if (released) return;
+                released = true;
+                limiter.release(null);
+              };
+              const wrappedStream = new ReadableStream({
+                async pull(controller) {
+                  try {
+                    const { done, value } = await originalReader.read();
+                    if (done) {
+                      controller.close();
+                      releaseOnce();
+                      if (debug) {
+                        const stats = limiter.getStats();
+                        console.log(`[DEBUG] Released AI slot after LLM stream complete (${stats.globalActive}/${stats.maxConcurrent})`);
+                      }
+                    } else {
+                      controller.enqueue(value);
+                    }
+                  } catch (err) {
+                    releaseOnce();
+                    if (debug) {
+                      console.log(`[DEBUG] Released AI slot on LLM stream error`);
+                    }
+                    controller.error(err);
+                  }
+                },
+                cancel() {
+                  releaseOnce();
+                  if (debug) {
+                    console.log(`[DEBUG] Released AI slot on LLM stream cancel`);
+                  }
+                  originalReader.cancel();
+                }
+              });
+
+              return { ...result, stream: wrappedStream };
+            } catch (err) {
+              limiter.release(null);
+              if (debug) {
+                console.log(`[DEBUG] Released AI slot on doStream error`);
+              }
+              throw err;
+            }
+          };
+        }
+
+        if (prop === 'doGenerate') {
+          return async function (...args) {
+            await limiter.acquire(null);
+            if (debug) {
+              const stats = limiter.getStats();
+              console.log(`[DEBUG] Acquired AI slot for LLM generate (${stats.globalActive}/${stats.maxConcurrent})`);
+            }
+            try {
+              const result = await target.doGenerate(...args);
+              return result;
+            } finally {
+              limiter.release(null);
+              if (debug) {
+                const stats = limiter.getStats();
+                console.log(`[DEBUG] Released AI slot after LLM generate (${stats.globalActive}/${stats.maxConcurrent})`);
+              }
+            }
+          };
+        }
+
+        const value = target[prop];
+        return typeof value === 'function' ? value.bind(target) : value;
+      }
+    });
+  }
+
+  /**
+   * Wrap an engine stream result so its textStream async generator acquires
+   * and releases a concurrency limiter slot. Acquire happens when iteration
+   * begins; release happens in finally (completion, error, or break).
+   *
+   * @param {Object} result - Engine result with { textStream, usage, ... }
+   * @param {Object} limiter - Concurrency limiter with acquire/release/getStats
+   * @param {boolean} debug - Enable debug logging
+   * @returns {Object} Result with wrapped textStream
+   * @private
+   */
+  static _wrapEngineStreamWithLimiter(result, limiter, debug) {
+    const originalStream = result.textStream;
+    async function* gatedStream() {
+      await limiter.acquire(null);
+      if (debug) {
+        const stats = limiter.getStats();
+        console.log(`[DEBUG] Acquired AI slot for engine stream (${stats.globalActive}/${stats.maxConcurrent}, queue: ${stats.queueSize})`);
+      }
+      try {
+        yield* originalStream;
+      } finally {
+        limiter.release(null);
+        if (debug) {
+          const stats = limiter.getStats();
+          console.log(`[DEBUG] Released AI slot after engine stream (${stats.globalActive}/${stats.maxConcurrent})`);
+        }
+      }
+    }
+    return { ...result, textStream: gatedStream() };
+  }
+
   /**
    * Execute streamText with retry and fallback support
    * @param {Object} options - streamText options
@@ -1384,14 +1528,12 @@ export class ProbeAgent {
    * @private
    */
   async streamTextWithRetryAndFallback(options) {
-    // Acquire global concurrency slot if limiter is configured
+    // Wrap the model with per-call concurrency gating if limiter is configured.
+    // This acquires/releases the slot around each individual LLM API call (doStream/doGenerate)
+    // instead of holding it for the entire multi-step agent session.
     const limiter = this.concurrencyLimiter;
-    if (limiter) {
-      await limiter.acquire(null);
-      if (this.debug) {
-        const stats = limiter.getStats();
-        console.log(`[DEBUG] Acquired global AI concurrency slot (${stats.globalActive}/${stats.maxConcurrent}, queue: ${stats.queueSize})`);
-      }
+    if (limiter && options.model) {
+      options = { ...options, model: ProbeAgent._wrapModelWithLimiter(options.model, limiter, this.debug) };
     }
 
     // Create AbortController for overall operation timeout
@@ -1430,6 +1572,12 @@ export class ProbeAgent {
       if (useClaudeCode || useCodex) {
         try {
           result = await this._tryEngineStreamPath(options, controller, timeoutState);
+          // Gate engine stream with concurrency limiter if configured.
+          // Engine paths bypass the Vercel model wrapper, so we wrap the
+          // textStream async generator with acquire/release instead.
+          if (result && limiter) {
+            result = ProbeAgent._wrapEngineStreamWithLimiter(result, limiter, this.debug);
+          }
         } catch (error) {
           if (this.debug) {
             const engineType = useClaudeCode ? 'Claude Code' : 'Codex';
@@ -1444,47 +1592,7 @@ export class ProbeAgent {
         result = await this._executeWithVercelProvider(options, controller);
       }
 
-      // Wrap textStream so limiter slot is held until stream completes.
-      // result.textStream is a read-only getter on DefaultStreamTextResult,
-      // so we wrap the result in a Proxy that intercepts the textStream property.
-      if (limiter && result.textStream) {
-        const originalStream = result.textStream;
-        const debug = this.debug;
-        const wrappedStream = (async function* () {
-          try {
-            for await (const chunk of originalStream) {
-              yield chunk;
-            }
-          } finally {
-            limiter.release(null);
-            if (debug) {
-              const stats = limiter.getStats();
-              console.log(`[DEBUG] Released global AI concurrency slot (${stats.globalActive}/${stats.maxConcurrent}, queue: ${stats.queueSize})`);
-            }
-          }
-        })();
-        return new Proxy(result, {
-          get(target, prop) {
-            if (prop === 'textStream') return wrappedStream;
-            const value = target[prop];
-            return typeof value === 'function' ? value.bind(target) : value;
-          }
-        });
-      } else if (limiter) {
-        // No textStream (shouldn't happen, but release just in case)
-        limiter.release(null);
-      }
-
       return result;
-    } catch (error) {
-      // Release on error if limiter was acquired
-      if (limiter) {
-        limiter.release(null);
-        if (this.debug) {
-          console.log(`[DEBUG] Released global AI concurrency slot on error`);
-        }
-      }
-      throw error;
     } finally {
       // Clean up timeout (for non-engine paths; engine paths clean up in the generator)
       if (timeoutState.timeoutId) {

package/build/agent/shared/prompts.js

@@ -90,9 +90,9 @@ If the solution is clear, you can jump to implementation right away. If not, ask
 - Do not add code comments unless the logic is genuinely complex and non-obvious.
 
 # Before Implementation
-- Focus on high-level design patterns and system organization
-- Identify architectural patterns and component relationships
-- Evaluate system structure and suggest architectural improvements
+- Read tests first — find existing test files for the module you're changing. They reveal expected behavior, edge cases, and the project's testing patterns.
+- Read neighboring files — understand naming conventions, error handling patterns, import style, and existing utilities before creating new ones.
+- Trace the call chain — follow how the code you're changing is called and what depends on it. Check interfaces, types, and consumers.
 - Focus on backward compatibility
 - Consider scalability, maintainability, and extensibility in your analysis
 
@@ -117,6 +117,20 @@ Before building or testing, determine the project's toolchain:
 - Read README for build/test instructions if the above are unclear
 - Common patterns: \`make build\`/\`make test\`, \`npm run build\`/\`npm test\`, \`cargo build\`/\`cargo test\`, \`go build ./...\`/\`go test ./...\`, \`python -m pytest\`
 
+# File Editing Rules
+You have access to the \`edit\`, \`create\`, and \`multi_edit\` tools for modifying files. You MUST use these tools for ALL code changes. They are purpose-built, atomic, and safe.
+
+DO NOT use sed, awk, echo/cat redirection, or heredocs to modify source code. These commands cause real damage in practice: truncated lines, duplicate code blocks, broken syntax. Every bad edit wastes iterations on fix-up commits.
+
+Use the right tool:
+1. To MODIFY existing code → \`edit\` tool (old_string → new_string, or start_line/end_line)
+2. To CREATE a new file → \`create\` tool
+3. To CHANGE multiple files at once → \`multi_edit\` tool
+4. To READ code → \`extract\` or \`search\` tools
+5. If \`edit\` fails with "file has not been read yet" → use \`extract\` with the EXACT same file path you will pass to \`edit\`. Relative vs absolute path mismatch causes this error. Use the same path format consistently. If it still fails, use bash \`cat\` to read the file, then use \`create\` to write the entire modified file. Do NOT fall back to sed.
+
+Bash is fine for: formatters (gofmt, prettier, black), build/test/lint commands, git operations, and read-only file inspection (cat, head, tail). sed/awk should ONLY be used for trivial non-code tasks (e.g., config file tweaks) where the replacement is a simple literal string swap.
+
 # During Implementation
 - Always create a new branch before making changes to the codebase.
 - Fix problems at the root cause, not with surface-level patches. Prefer general solutions over special cases.
@@ -143,6 +157,22 @@ Before committing or creating a PR, run through this checklist:
 
 Do NOT skip verification. Do NOT proceed to PR creation with a broken build or failing tests.
 
+# Output Integrity
+Your final output MUST accurately reflect what ACTUALLY happened. Do NOT fabricate, hallucinate, or report aspirational results.
+
+- Only report PR URLs you actually created or updated with \`gh pr create\` or \`git push\`. If you checked out an existing PR but did NOT push changes to it, do NOT claim you updated it.
+- Describe what you ACTUALLY DID, not what you planned or intended to do. If you ran out of iterations, say so. If tests failed, say so.
+- Only list files you actually modified AND committed.
+- If you could not complete the task — ran out of iterations, tests failed, build broken, push rejected — report the real reason honestly.
+
+NEVER claim success when:
+- You did not run \`git push\` successfully
+- Tests failed and you did not fix them
+- You hit the iteration limit before completing the work
+- You only analyzed/investigated but did not implement changes
+
+A false success report is WORSE than an honest failure — it misleads the user into thinking work is done when it is not.
+
 # GitHub Integration
 - Use the \`gh\` CLI for all GitHub operations: issues, pull requests, checks, releases.
 - To view issues or PRs: \`gh issue view <number>\`, \`gh pr view <number>\`.

package/build/tools/fileTracker.js

@@ -12,9 +12,22 @@
  */
 
 import { createHash } from 'crypto';
-import { resolve, isAbsolute } from 'path';
+import { resolve, isAbsolute, normalize } from 'path';
 import { findSymbol } from './symbolEdit.js';
 
+/**
+ * Normalize a file path for consistent storage and lookup.
+ * Resolves '.', '..', double slashes, and ensures absolute paths are canonical.
+ * Does NOT resolve symlinks (that would be expensive and might fail for non-existent files).
+ * @param {string} filePath - Path to normalize
+ * @returns {string} Normalized path
+ */
+function normalizePath(filePath) {
+  if (!filePath) return filePath;
+  // resolve() handles '.', '..', double slashes, and makes the path absolute
+  return resolve(filePath);
+}
+
 /**
  * Compute a SHA-256 content hash for a code block.
  * Normalizes trailing whitespace per line for robustness against editor formatting.
@@ -106,10 +119,11 @@ export class FileTracker {
    * @param {string} resolvedPath - Absolute path to the file
    */
   markFileSeen(resolvedPath) {
-    this._seenFiles.add(resolvedPath);
-    this._textEditCounts.set(resolvedPath, 0);
+    const normalized = normalizePath(resolvedPath);
+    this._seenFiles.add(normalized);
+    this._textEditCounts.set(normalized, 0);
     if (this.debug) {
-      console.error(`[FileTracker] Marked as seen: ${resolvedPath}`);
+      console.error(`[FileTracker] Marked as seen: ${normalized}`);
     }
   }
 
@@ -119,7 +133,7 @@ export class FileTracker {
    * @returns {boolean}
    */
   isFileSeen(resolvedPath) {
-    return this._seenFiles.has(resolvedPath);
+    return this._seenFiles.has(normalizePath(resolvedPath));
   }
 
   /**
@@ -132,7 +146,7 @@ export class FileTracker {
    * @param {string} [source='extract'] - How the content was obtained
    */
   trackSymbolContent(resolvedPath, symbolName, code, startLine, endLine, source = 'extract') {
-    const key = `${resolvedPath}#${symbolName}`;
+    const key = `${normalizePath(resolvedPath)}#${symbolName}`;
     const contentHash = computeContentHash(code);
     this._contentRecords.set(key, {
       contentHash,
@@ -154,7 +168,7 @@ export class FileTracker {
    * @returns {Object|null} The stored record or null
    */
   getSymbolRecord(resolvedPath, symbolName) {
-    return this._contentRecords.get(`${resolvedPath}#${symbolName}`) || null;
+    return this._contentRecords.get(`${normalizePath(resolvedPath)}#${symbolName}`) || null;
   }
 
   /**
@@ -165,7 +179,7 @@ export class FileTracker {
    * @returns {{ok: boolean, reason?: string, message?: string}}
    */
   checkSymbolContent(resolvedPath, symbolName, currentCode) {
-    const key = `${resolvedPath}#${symbolName}`;
+    const key = `${normalizePath(resolvedPath)}#${symbolName}`;
     const record = this._contentRecords.get(key);
 
     if (!record) {
@@ -253,7 +267,7 @@ export class FileTracker {
    * @returns {{ok: boolean, reason?: string, message?: string}}
    */
   checkBeforeEdit(resolvedPath) {
-    if (!this._seenFiles.has(resolvedPath)) {
+    if (!this._seenFiles.has(normalizePath(resolvedPath))) {
       return {
         ok: false,
         reason: 'untracked',
@@ -269,8 +283,9 @@ export class FileTracker {
    * @param {string} resolvedPath - Absolute path to the file
    */
   async trackFileAfterWrite(resolvedPath) {
-    this._seenFiles.add(resolvedPath);
-    this.invalidateFileRecords(resolvedPath);
+    const normalized = normalizePath(resolvedPath);
+    this._seenFiles.add(normalized);
+    this.invalidateFileRecords(normalized);
   }
 
   /**
@@ -279,10 +294,11 @@ export class FileTracker {
    * @param {string} resolvedPath - Absolute path to the file
    */
   recordTextEdit(resolvedPath) {
-    const count = (this._textEditCounts.get(resolvedPath) || 0) + 1;
-    this._textEditCounts.set(resolvedPath, count);
+    const normalized = normalizePath(resolvedPath);
+    const count = (this._textEditCounts.get(normalized) || 0) + 1;
+    this._textEditCounts.set(normalized, count);
     if (this.debug) {
-      console.error(`[FileTracker] Text edit #${count} for ${resolvedPath}`);
+      console.error(`[FileTracker] Text edit #${count} for ${normalized}`);
     }
   }
 
@@ -292,7 +308,7 @@ export class FileTracker {
    * @returns {{ok: boolean, editCount?: number, message?: string}}
    */
   checkTextEditStaleness(resolvedPath) {
-    const count = this._textEditCounts.get(resolvedPath) || 0;
+    const count = this._textEditCounts.get(normalizePath(resolvedPath)) || 0;
     if (count >= this.maxConsecutiveTextEdits) {
       return {
         ok: false,
@@ -323,7 +339,7 @@ export class FileTracker {
    * @param {string} resolvedPath - Absolute path to the file
    */
   invalidateFileRecords(resolvedPath) {
-    const prefix = resolvedPath + '#';
+    const prefix = normalizePath(resolvedPath) + '#';
     for (const key of this._contentRecords.keys()) {
       if (key.startsWith(prefix)) {
         this._contentRecords.delete(key);
@@ -340,7 +356,7 @@ export class FileTracker {
    * @returns {boolean}
    */
   isTracked(resolvedPath) {
-    return this.isFileSeen(resolvedPath);
+    return this.isFileSeen(normalizePath(resolvedPath));
   }
 
   /**

package/build/tools/vercel.js

@@ -385,7 +385,7 @@ export const searchTool = (options = {}) => {
 			? searchDelegateDescription
 			: searchDescription,
 		inputSchema: searchSchema,
-		execute: async ({ query: searchQuery, path, allow_tests, exact, maxTokens: paramMaxTokens, language, session, nextPage }) => {
+		execute: async ({ query: searchQuery, path, allow_tests, exact, maxTokens: paramMaxTokens, language, session, nextPage, workingDirectory }) => {
 			// Auto-quote mixed-case and underscore terms to prevent unwanted stemming/splitting
 			// Skip when exact=true since that already preserves the literal string
 			if (!exact && searchQuery) {
@@ -399,15 +399,18 @@ export const searchTool = (options = {}) => {
 			// Use parameter maxTokens if provided, otherwise use the default
 			const effectiveMaxTokens = paramMaxTokens || maxTokens;
 
+			// Use workingDirectory (injected by _buildNativeTools at runtime) > cwd from config > fallback
+			const effectiveSearchCwd = workingDirectory || options.cwd || '.';
+
 			// Parse and resolve paths (supports comma-separated and relative paths)
 			let searchPaths;
 			if (path) {
-				searchPaths = parseAndResolvePaths(path, options.cwd);
+				searchPaths = parseAndResolvePaths(path, effectiveSearchCwd);
 			}
 
 			// Default to cwd or '.' if no paths provided
 			if (!searchPaths || searchPaths.length === 0) {
-				searchPaths = [options.cwd || '.'];
+				searchPaths = [effectiveSearchCwd];
 			}
 
 			// Join paths with space for CLI (probe search supports multiple paths)
@@ -416,7 +419,7 @@ export const searchTool = (options = {}) => {
 			const searchOptions = {
 				query: searchQuery,
 				path: searchPath,
-				cwd: options.cwd, // Working directory for resolving relative paths
+				cwd: effectiveSearchCwd, // Working directory for resolving relative paths
 				allowTests: allow_tests ?? true,
 				exact,
 				json: false,
@@ -473,7 +476,7 @@ export const searchTool = (options = {}) => {
 					const result = maybeAnnotate(await runRawSearch());
 					// Track files found in search results for staleness detection
 					if (options.fileTracker && typeof result === 'string') {
-						options.fileTracker.trackFilesFromOutput(result, options.cwd || '.').catch(() => {});
+						options.fileTracker.trackFilesFromOutput(result, effectiveSearchCwd).catch(() => {});
 					}
 					return result;
 				} catch (error) {
@@ -532,7 +535,7 @@ export const searchTool = (options = {}) => {
 					}
 					const fallbackResult = maybeAnnotate(await runRawSearch());
 					if (options.fileTracker && typeof fallbackResult === 'string') {
-						options.fileTracker.trackFilesFromOutput(fallbackResult, options.cwd || '.').catch(() => {});
+						options.fileTracker.trackFilesFromOutput(fallbackResult, effectiveSearchCwd).catch(() => {});
 					}
 					return fallbackResult;
 				}
@@ -614,7 +617,7 @@ export const searchTool = (options = {}) => {
 				try {
 					const fallbackResult2 = maybeAnnotate(await runRawSearch());
 					if (options.fileTracker && typeof fallbackResult2 === 'string') {
-						options.fileTracker.trackFilesFromOutput(fallbackResult2, options.cwd || '.').catch(() => {});
+						options.fileTracker.trackFilesFromOutput(fallbackResult2, effectiveSearchCwd).catch(() => {});
 					}
 					return fallbackResult2;
 				} catch (fallbackError) {
@@ -693,10 +696,10 @@ export const extractTool = (options = {}) => {
 		name: 'extract',
 		description: extractDescription,
 		inputSchema: extractSchema,
-		execute: async ({ targets, input_content, line, end_line, allow_tests, context_lines, format }) => {
+		execute: async ({ targets, input_content, line, end_line, allow_tests, context_lines, format, workingDirectory }) => {
 			try {
-				// Use the cwd from config for working directory
-				const effectiveCwd = options.cwd || '.';
+				// Use workingDirectory (injected by _buildNativeTools at runtime) > cwd from config > fallback
+				const effectiveCwd = workingDirectory || options.cwd || '.';
 
 				if (debug) {
 					if (targets) {