salmon-loop 0.2.13 → 0.3.0

package/dist/core/adapters/fs/file-adapter.js

@@ -73,6 +73,12 @@ export class FileAdapter {
     async stat(filePath) {
         return fs.stat(filePath);
     }
+    /**
+     * Get file stats without following symlinks.
+     */
+    async lstat(filePath) {
+        return fs.lstat(filePath);
+    }
     /**
      * Create directory recursively
      */

package/dist/core/adapters/fs/filesystem.js

@@ -1,3 +1,4 @@
+import { resolveExecutionProfile } from '../../runtime/execution-profile.js';
 import { FileAdapter } from './file-adapter.js';
 import { ReadOnlyFileSystem } from './readonly-filesystem.js';
 class FileAdapterFileSystem {
@@ -23,7 +24,7 @@ class FileAdapterFileSystem {
  * Review mode returns a ReadOnlyFileSystem to block writes.
  */
 export function createFileSystemAdapter(mode, realFs = new FileAdapterFileSystem()) {
-    if (mode === 'review' || mode === 'research' || mode === 'answer') {
+    if (resolveExecutionProfile(mode).readOnly) {
         return new ReadOnlyFileSystem(realFs);
     }
     return realFs;

package/dist/core/adapters/git/git-adapter.js

@@ -8,7 +8,7 @@ import { LIMITS } from '../../config/limits.js';
 import { logIgnoredError } from '../../observability/ignored-error.js';
 import { getLogger } from '../../observability/logger.js';
 import { GitError } from '../../types/index.js';
-import { isPathWithinDirectory, normalizePath } from '../../utils/path.js';
+import { isPathWithinDirectory, isSafeRelativePath, normalizePath } from '../../utils/path.js';
 import { runGitCommand } from './git-runner.js';
 import { FileHandleManager } from './lock-manager.js';
 // Singleton map to ensure one lock manager per repository path
@@ -126,6 +126,32 @@ export class GitAdapter {
         this.assertQueryAllowed(args);
         return this.exec(args, options);
     }
+    /**
+     * Generate a git-formatted patch for one repo-relative file that is not in
+     * the index, without staging or otherwise mutating repository state.
+     */
+    async diffUntrackedFileAgainstNull(relativePath, options = {}) {
+        const normalizedPath = normalizePath(relativePath);
+        if (!isSafeRelativePath(normalizedPath)) {
+            throw new Error(text.git.securityViolation('diff --no-index'));
+        }
+        return this.execMeta([
+            'diff',
+            '--no-index',
+            '--binary',
+            '--no-color',
+            '--no-ext-diff',
+            '--src-prefix=a/',
+            '--dst-prefix=b/',
+            '--',
+            '/dev/null',
+            normalizedPath,
+        ], {
+            cwd: options.cwd,
+            limits: options.limits,
+            timeoutMs: options.timeoutMs,
+        });
+    }
     // ==================== Business Layer ====================
     /**
      * Generates a blob hash for the given content without writing to the object database.
@@ -363,6 +389,54 @@ export class GitAdapter {
             await this.lockManager.releaseLock(this.repoPath);
         }
     }
+    async checkPatchApplyability(diffText, options = {}) {
+        const tempFile = path.join(tmpdir(), `salmon-patch-check-${Date.now()}-${randomBytes(4).toString('hex')}.patch`);
+        const tempIndex = path.join(tmpdir(), `salmon-patch-check-index-${Date.now()}-${randomBytes(4).toString('hex')}`);
+        await fs.writeFile(tempFile, diffText, 'utf8');
+        try {
+            const readTree = await this.execMeta(['read-tree', 'HEAD'], {
+                env: { ...options.env, GIT_INDEX_FILE: tempIndex },
+                limits: { maxStdoutBytes: LIMITS.maxToolOutputBytes, maxStderrChars: 16_384 },
+                timeoutMs: LIMITS.gitTimeoutMs,
+            });
+            if (!readTree.ok) {
+                const output = [readTree.stdout.toString('utf8'), readTree.stderr]
+                    .filter(Boolean)
+                    .join('\n')
+                    .trim();
+                return {
+                    ok: false,
+                    exitCode: readTree.code,
+                    output,
+                };
+            }
+            const args = ['apply', '--cached', '--check', '--recount'];
+            if (options.ignoreWhitespace)
+                args.push('--ignore-whitespace');
+            if (options.contextLines)
+                args.push(`-C${options.contextLines}`);
+            args.push(tempFile);
+            const res = await this.execMeta(args, {
+                env: { ...options.env, GIT_INDEX_FILE: tempIndex },
+                limits: { maxStdoutBytes: LIMITS.maxToolOutputBytes, maxStderrChars: 16_384 },
+                timeoutMs: LIMITS.gitTimeoutMs,
+            });
+            const output = [res.stdout.toString('utf8'), res.stderr].filter(Boolean).join('\n').trim();
+            return {
+                ok: res.ok,
+                exitCode: res.code,
+                output,
+            };
+        }
+        finally {
+            await fs
+                .unlink(tempFile)
+                .catch((error) => logIgnoredError(`[GitAdapter] cleanup ${tempFile}`, error));
+            await fs
+                .unlink(tempIndex)
+                .catch((error) => logIgnoredError(`[GitAdapter] cleanup ${tempIndex}`, error));
+        }
+    }
     /**
      * Precision rollback protecting staged changes.
      */
@@ -407,6 +481,9 @@ export class GitAdapter {
             }
         }
         catch (error) {
+            if (!this.isShadowWorktreePath()) {
+                throw error;
+            }
             try {
                 await this.resolveConflicts();
             }

package/dist/core/backends/salmon-loop/task-executor.js

@@ -31,6 +31,7 @@ export function createSalmonTaskExecutor(deps) {
                     authorizationProvider: options?.authorizationProvider,
                     authorizationMode: options?.authorizationMode,
                     fileSystemOverride: options?.fileSystemOverride,
+                    extensions: task.request.extensions,
                 });
             });
             if (result.reasonCode === 'AWAITING_INPUT' && result.inputRequired) {

package/dist/core/benchmark/patch-artifact.js

@@ -0,0 +1,124 @@
+import { createHash } from 'crypto';
+import { EOL } from 'os';
+import path from 'path';
+import { FileAdapter } from '../adapters/fs/file-adapter.js';
+import { GitAdapter } from '../adapters/git/git-adapter.js';
+import { LIMITS } from '../config/limits.js';
+import { isPathWithinDirectory, isSafeRelativePath, normalizePath } from '../utils/path.js';
+export class BenchmarkPatchArtifactError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'BenchmarkPatchArtifactError';
+    }
+}
+const DIFF_ARGS = [
+    'diff',
+    '--binary',
+    '--no-color',
+    '--no-ext-diff',
+    '--src-prefix=a/',
+    '--dst-prefix=b/',
+    'HEAD',
+    '--',
+    '.',
+];
+function normalizeGitPatch(text) {
+    const normalized = text.replace(/\r\n/g, '\n').replace(/\s+$/, '');
+    return normalized.length > 0 ? `${normalized}\n` : '';
+}
+function splitLines(text) {
+    return text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+async function buildUntrackedFilePatch(params) {
+    if (!isSafeRelativePath(params.relativePath) || params.relativePath.startsWith('.salmonloop/')) {
+        throw new BenchmarkPatchArtifactError(`Unsafe untracked patch path: ${params.relativePath}`);
+    }
+    const result = await params.git.diffUntrackedFileAgainstNull(params.relativePath, {
+        cwd: params.repoPath,
+        limits: { maxStdoutBytes: LIMITS.maxToolOutputBytes },
+    });
+    if (result.code !== 0 && result.code !== 1) {
+        throw new BenchmarkPatchArtifactError(result.stderr || 'Failed to diff untracked file.');
+    }
+    return normalizeGitPatch(result.stdout.toString('utf8'));
+}
+function parseChangedFilesFromPatch(patch) {
+    const files = new Set();
+    for (const line of patch.split('\n')) {
+        const match = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+        if (!match)
+            continue;
+        const next = match[2];
+        if (next !== '/dev/null')
+            files.add(next);
+    }
+    return Array.from(files).sort();
+}
+export async function buildBenchmarkPatchArtifact(params) {
+    const git = new GitAdapter(params.repoPath);
+    const fileAdapter = new FileAdapter();
+    const excluded = await resolveRepoRelativeExcludes(params.repoPath, params.excludePaths ?? []);
+    const pathspecs = buildPatchPathspecs(excluded);
+    const trackedPatch = normalizeGitPatch(await git.query([...DIFF_ARGS, ...pathspecs], {
+        trim: false,
+        limits: { maxStdoutBytes: LIMITS.maxToolOutputBytes },
+    }));
+    const candidateUntracked = new Set([
+        ...splitLines(await git.query(['ls-files', '--others', '--exclude-standard'])),
+        ...(params.changedFilesHint ?? []),
+    ]);
+    const untrackedPatches = [];
+    for (const relativePath of Array.from(candidateUntracked).sort()) {
+        const normalizedPath = normalizePath(relativePath);
+        if (!normalizedPath || normalizedPath.startsWith('.salmonloop/'))
+            continue;
+        if (excluded.has(normalizedPath))
+            continue;
+        const status = await git.getStatusForPath(normalizedPath);
+        if (!status?.untracked)
+            continue;
+        if (!(await fileAdapter.exists(path.join(params.repoPath, normalizedPath))))
+            continue;
+        untrackedPatches.push(await buildUntrackedFilePatch({
+            repoPath: params.repoPath,
+            git,
+            relativePath: normalizedPath,
+        }));
+    }
+    const patch = normalizeGitPatch([trackedPatch, ...untrackedPatches].filter(Boolean).join(EOL));
+    const bytes = Buffer.byteLength(patch, 'utf8');
+    return {
+        patch,
+        bytes,
+        sha256: createHash('sha256').update(patch, 'utf8').digest('hex'),
+        changedFiles: parseChangedFilesFromPatch(patch),
+        isEmpty: patch.length === 0,
+    };
+}
+function buildPatchPathspecs(excluded) {
+    return Array.from(excluded)
+        .sort()
+        .map((relativePath) => `:(top,literal,exclude)${relativePath}`);
+}
+async function resolveRepoRelativeExcludes(repoPath, paths) {
+    const resolvedRepoPath = path.resolve(repoPath);
+    const excluded = new Set();
+    for (const candidate of paths) {
+        if (!candidate)
+            continue;
+        const absolutePath = path.isAbsolute(candidate)
+            ? path.resolve(candidate)
+            : path.resolve(resolvedRepoPath, candidate);
+        const relativePath = normalizePath(path.relative(resolvedRepoPath, absolutePath));
+        if (!isSafeRelativePath(relativePath))
+            continue;
+        if (!isPathWithinDirectory(resolvedRepoPath, absolutePath))
+            continue;
+        excluded.add(relativePath);
+    }
+    return excluded;
+}
+//# sourceMappingURL=patch-artifact.js.map

package/dist/core/benchmark/swe-bench.js

@@ -0,0 +1,25 @@
+export function buildSweBenchPrediction(input) {
+    return {
+        instance_id: input.instanceId,
+        model_name_or_path: input.modelNameOrPath,
+        model_patch: input.modelPatch,
+    };
+}
+export function encodeSweBenchPredictionJsonl(input) {
+    return `${JSON.stringify(buildSweBenchPrediction(input))}\n`;
+}
+export function parseSweBenchInstance(raw) {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('SWE-bench instance must be a JSON object.');
+    }
+    const instance = parsed;
+    if (typeof instance.instance_id !== 'string' || !instance.instance_id.trim()) {
+        throw new Error('SWE-bench instance requires a non-empty instance_id.');
+    }
+    return {
+        ...instance,
+        instance_id: instance.instance_id,
+    };
+}
+//# sourceMappingURL=swe-bench.js.map

package/dist/core/config/load.js

@@ -4,25 +4,32 @@ import { parseConfigText } from './file-format.js';
 import { getDefaultRepoConfigPaths, getDefaultUserConfigPaths, resolveConfigPath, } from './paths.js';
 import { validateConfigFileV1 } from './validate.js';
 async function loadFromCandidates(candidatePaths, required) {
-    for (let i = 0; i < candidatePaths.length; i++) {
-        const absPath = candidatePaths[i];
+    const results = await Promise.all(candidatePaths.map(async (absPath) => {
         try {
             const raw = await readFile(absPath, 'utf8');
             const parsed = parseConfigText(raw, absPath);
             const config = validateConfigFileV1(parsed);
-            return { path: absPath, config };
+            return { ok: true, absPath, loaded: { path: absPath, config } };
         }
         catch (e) {
-            if ((e && typeof e === 'object' && 'code' in e ? e.code : undefined) ===
-                'ENOENT') {
-                const isLast = i === candidatePaths.length - 1;
-                if (required && isLast) {
-                    throw new ConfigError('CONFIG_FILE_NOT_FOUND', { path: absPath });
-                }
-                continue;
+            return { ok: false, absPath, error: e };
+        }
+    }));
+    for (const [i, result] of results.entries()) {
+        if (result.ok) {
+            return result.loaded;
+        }
+        const code = result.error && typeof result.error === 'object' && 'code' in result.error
+            ? result.error.code
+            : undefined;
+        if (code === 'ENOENT') {
+            const isLast = i === results.length - 1;
+            if (required && isLast) {
+                throw new ConfigError('CONFIG_FILE_NOT_FOUND', { path: result.absPath });
             }
-            throw e;
+            continue;
         }
+        throw result.error;
     }
     return null;
 }

package/dist/core/config/resolve-llm.js

@@ -1,6 +1,14 @@
 import { resolveBaseUrl } from '../llm/base-url.js';
 import { ConfigError } from './errors.js';
 import { firstProviderRef, resolveApiKey, resolveModelId } from './resolve-env.js';
+function mergeCapabilities(providerCapabilities, modelCapabilities) {
+    if (!providerCapabilities && !modelCapabilities)
+        return undefined;
+    return {
+        ...providerCapabilities,
+        ...modelCapabilities,
+    };
+}
 export function resolveLlmFromConfig(raw) {
     const llm = raw?.llm;
     const providers = llm?.providers || {};
@@ -49,6 +57,7 @@ export function resolveLlmFromConfig(raw) {
     const apiKeyResolution = resolveApiKey(provider.api?.apiKey);
     const baseUrl = resolveBaseUrl(provider.api?.baseUrl);
     const selectedModelId = resolveModelId(activeProfile.id);
+    const activeCapabilities = mergeCapabilities(provider.capabilities, activeProfile.capabilities);
     const routing = llm?.routing;
     const phaseToProviderModel = routing?.phaseToModel && typeof routing.phaseToModel === 'object'
         ? Object.fromEntries(Object.entries(routing.phaseToModel)
@@ -76,6 +85,7 @@ export function resolveLlmFromConfig(raw) {
                 });
             }
             const phaseKey = resolveApiKey(phaseProvider.api?.apiKey);
+            const capabilities = mergeCapabilities(phaseProvider.capabilities, profile.capabilities);
             return [
                 phase,
                 {
@@ -93,6 +103,7 @@ export function resolveLlmFromConfig(raw) {
                         id: resolveModelId(profile.id),
                         slot: profileSlot,
                     },
+                    capabilities,
                 },
             ];
         })
@@ -124,6 +135,7 @@ export function resolveLlmFromConfig(raw) {
             selectedModelId,
             selectedModelSlot: activeModelSlot,
         },
+        capabilities: activeCapabilities,
         routing: resolvedRouting,
     };
 }

package/dist/core/config/resolvers/server.js

@@ -10,12 +10,6 @@ export function resolveServerConfig(raw) {
             tokens: serverRaw.a2a.tokens,
         };
     }
-    if (serverRaw.sidecar) {
-        server.sidecar = {
-            socket: serverRaw.sidecar.socket,
-            allowConditional: serverRaw.sidecar.allowConditional,
-        };
-    }
     if (serverRaw.acp) {
         server.acp = {
             sessionStore: {

package/dist/core/config/validate.js

@@ -26,6 +26,59 @@ function isValidMarkdownTheme(value) {
 function isValidMarkdownRenderMode(value) {
     return typeof value === 'string' && MARKDOWN_RENDER_MODES.includes(value);
 }
+function validateLlmCapabilities(input, context) {
+    if (input === undefined)
+        return undefined;
+    if (!isRecord(input)) {
+        throw new ConfigError('CONFIG_INVALID_LLM_CAPABILITIES', {
+            ...context,
+            expected: 'object',
+        });
+    }
+    const allowedKeys = new Set(['toolCalling', 'responseFormatJsonObject', 'streaming']);
+    for (const key of Object.keys(input)) {
+        if (!allowedKeys.has(key)) {
+            throw new ConfigError('CONFIG_INVALID_LLM_CAPABILITY', {
+                ...context,
+                capability: key,
+                expected: 'toolCalling|responseFormatJsonObject|streaming',
+            });
+        }
+    }
+    const cfg = {};
+    for (const key of ['toolCalling', 'responseFormatJsonObject', 'streaming']) {
+        if (input[key] !== undefined && !isBoolean(input[key])) {
+            throw new ConfigError('CONFIG_INVALID_LLM_CAPABILITY', {
+                ...context,
+                capability: key,
+                expected: 'boolean',
+            });
+        }
+        if (input[key] !== undefined) {
+            cfg[key] = input[key];
+        }
+    }
+    return cfg;
+}
+function normalizeLlmModelParams(input, context) {
+    if (!isRecord(input))
+        return undefined;
+    for (const key of [
+        'capabilities',
+        'toolCalling',
+        'responseFormatJsonObject',
+        'streaming',
+    ]) {
+        if (input[key] !== undefined) {
+            throw new ConfigError('CONFIG_INVALID_LLM_CAPABILITY_LOCATION', {
+                ...context,
+                capability: key,
+                expected: 'model.capabilities',
+            });
+        }
+    }
+    return input;
+}
 export function validateConfigFileV1(input) {
     if (!isRecord(input)) {
         throw new ConfigError('CONFIG_INVALID_ROOT', { expected: 'object' });
@@ -164,6 +217,11 @@ export function validateConfigFileV1(input) {
         if (!isRecord(serverRaw)) {
             throw new ConfigError('CONFIG_INVALID_SERVER', { expected: 'object' });
         }
+        for (const key of Object.keys(serverRaw)) {
+            if (key !== 'a2a' && key !== 'acp') {
+                throw new ConfigError('CONFIG_INVALID_SERVER_UNKNOWN_KEY', { key });
+            }
+        }
         const server = {};
         if (serverRaw.a2a !== undefined) {
             if (!isRecord(serverRaw.a2a)) {
@@ -187,24 +245,6 @@ export function validateConfigFileV1(input) {
                 tokens: a2aRaw.tokens,
             };
         }
-        if (serverRaw.sidecar !== undefined) {
-            if (!isRecord(serverRaw.sidecar)) {
-                throw new ConfigError('CONFIG_INVALID_SERVER_SIDECAR', { expected: 'object' });
-            }
-            const sidecarRaw = serverRaw.sidecar;
-            if (sidecarRaw.socket !== undefined && !isString(sidecarRaw.socket)) {
-                throw new ConfigError('CONFIG_INVALID_SERVER_SIDECAR_SOCKET', { expected: 'string' });
-            }
-            if (sidecarRaw.allowConditional !== undefined && !isBoolean(sidecarRaw.allowConditional)) {
-                throw new ConfigError('CONFIG_INVALID_SERVER_SIDECAR_ALLOW_CONDITIONAL', {
-                    expected: 'boolean',
-                });
-            }
-            server.sidecar = {
-                socket: sidecarRaw.socket,
-                allowConditional: sidecarRaw.allowConditional,
-            };
-        }
         if (serverRaw.acp !== undefined) {
             if (!isRecord(serverRaw.acp)) {
                 throw new ConfigError('CONFIG_INVALID_SERVER_ACP', { expected: 'object' });
@@ -561,6 +601,12 @@ export function validateConfigFileV1(input) {
                         hint: 'use llm.models with provider references',
                     });
                 }
+                const providerCapabilities = validateLlmCapabilities(rawProvider.capabilities, {
+                    provider: id,
+                });
+                if (providerCapabilities) {
+                    p.capabilities = providerCapabilities;
+                }
                 cfg.llm.providers[id] = p;
             }
         }
@@ -590,12 +636,18 @@ export function validateConfigFileV1(input) {
                         expected: 'non_empty_string',
                     });
                 }
+                const params = normalizeLlmModelParams(rawModel.params, {
+                    model: slot,
+                    location: 'params',
+                });
+                const capabilities = validateLlmCapabilities(rawModel.capabilities, {
+                    model: slot,
+                });
                 cfg.llm.models[slot] = {
                     provider: provider,
                     id: rawModel.id,
-                    params: isRecord(rawModel.params)
-                        ? rawModel.params
-                        : undefined,
+                    params,
+                    capabilities,
                 };
             }
         }

package/dist/core/context/gatherers/metadata-gatherer.js

@@ -38,6 +38,7 @@ export class MetadataGatherer {
             'tsconfig.json',
             'eslint.config.js',
             '.prettierrc',
+            '.oxfmtrc.json',
             'vitest.config.ts',
             'jest.config.js',
             'bun.lock',

package/dist/core/context/gatherers/ripgrep-gatherer.js

@@ -1,8 +1,89 @@
+import { FileAdapter } from '../../adapters/fs/file-adapter.js';
 import { LIMITS } from '../../config/limits.js';
 import { getLogger } from '../../observability/logger.js';
 import { spawnCommand } from '../../runtime/process-runner.js';
-import { normalizePath } from '../../utils/path.js';
+import { ensureInSandbox, normalizePath, safeJoin, safeRelative } from '../../utils/path.js';
+const FALLBACK_EXCLUDED_DIRS = new Set(['.git', 'node_modules']);
+const FALLBACK_MAX_FILES = 2000;
+const FALLBACK_MAX_FILE_BYTES = Math.max(LIMITS.largeFileThresholdBytes, 64 * 1024);
+const fileAdapter = new FileAdapter();
+function isHiddenPathSegment(name) {
+    return name.startsWith('.');
+}
+function isBinaryLike(content) {
+    return content.includes('\0');
+}
 export class RipgrepGatherer {
+    async searchFileSystem(query, cwd, signal) {
+        const needle = query.toLowerCase();
+        if (!needle)
+            return [];
+        const results = [];
+        let scannedFiles = 0;
+        const pending = ['.'];
+        while (pending.length > 0 && scannedFiles < FALLBACK_MAX_FILES) {
+            if (signal?.aborted)
+                throw new Error('Operation cancelled by user');
+            const current = pending.shift();
+            const absoluteCurrent = ensureInSandbox(cwd, safeJoin(cwd, current));
+            let entries;
+            try {
+                entries = await fileAdapter.readdirWithTypes(absoluteCurrent);
+            }
+            catch {
+                continue;
+            }
+            entries.sort((a, b) => a.name.localeCompare(b.name));
+            for (const entry of entries) {
+                if (signal?.aborted)
+                    throw new Error('Operation cancelled by user');
+                if (isHiddenPathSegment(entry.name))
+                    continue;
+                if (entry.isSymbolicLink())
+                    continue;
+                const relativePath = normalizePath(safeJoin(current, entry.name)).replace(/^(\.\/|\/)+/, '');
+                if (!relativePath)
+                    continue;
+                if (entry.isDirectory()) {
+                    if (FALLBACK_EXCLUDED_DIRS.has(entry.name))
+                        continue;
+                    pending.push(relativePath);
+                    continue;
+                }
+                if (!entry.isFile())
+                    continue;
+                scannedFiles += 1;
+                if (scannedFiles > FALLBACK_MAX_FILES)
+                    break;
+                const absoluteFile = ensureInSandbox(cwd, safeJoin(cwd, relativePath));
+                try {
+                    const stat = await fileAdapter.stat(absoluteFile);
+                    if (!stat.isFile() || stat.size > FALLBACK_MAX_FILE_BYTES)
+                        continue;
+                    const content = await fileAdapter.readFile(absoluteFile, 'utf-8');
+                    if (isBinaryLike(content))
+                        continue;
+                    const lines = content.split(/\r?\n/);
+                    for (let index = 0; index < lines.length; index += 1) {
+                        const line = lines[index] ?? '';
+                        if (!line.toLowerCase().includes(needle))
+                            continue;
+                        results.push({
+                            file: normalizePath(safeRelative(cwd, absoluteFile)),
+                            line: index + 1,
+                            content: line,
+                        });
+                        if (results.length >= LIMITS.defaultSearchMatches)
+                            return results;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        return results;
+    }
     async runRipgrep(query, cwd, signal) {
         getLogger().trace(`  [RG] Searching for: "${query}" in ${cwd}`);
         if (signal?.aborted) {
@@ -38,7 +119,8 @@ export class RipgrepGatherer {
         getLogger().trace(`  [RG] Process closed with code ${result.code}. Output length: ${output.length}`);
         if (result.error) {
             if (result.error.code === 'ENOENT') {
-                getLogger().error('Error: ripgrep (rg) not found in PATH. Context gathering may be incomplete.');
+                getLogger().error('Error: ripgrep (rg) not found in PATH. Falling back to bounded filesystem search.');
+                return await this.searchFileSystem(query, cwd, signal);
             }
             else {
                 getLogger().error(`Error running ripgrep: ${result.error.message}`);