salmon-loop 0.2.3 → 0.2.16

package/dist/core/config/load.js

@@ -1,34 +1,55 @@
 import { readFile } from '../adapters/fs/node-fs.js';
 import { ConfigError } from './errors.js';
 import { parseConfigText } from './file-format.js';
-import { getDefaultRepoConfigPaths, resolveConfigPath } from './paths.js';
+import { getDefaultRepoConfigPaths, getDefaultUserConfigPaths, resolveConfigPath, } from './paths.js';
 import { validateConfigFileV1 } from './validate.js';
-export async function tryLoadConfigFile(opts) {
-    if (!opts.enabled)
-        return null;
-    const candidatePaths = opts.configPath
-        ? [resolveConfigPath(opts.repoRoot, opts.configPath)]
-        : getDefaultRepoConfigPaths(opts.repoRoot);
-    for (let i = 0; i < candidatePaths.length; i++) {
-        const absPath = candidatePaths[i];
+async function loadFromCandidates(candidatePaths, required) {
+    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 (opts.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;
 }
+export async function tryLoadConfigFile(opts) {
+    if (!opts.enabled)
+        return null;
+    const candidatePaths = opts.configPath
+        ? [resolveConfigPath(opts.repoRoot, opts.configPath)]
+        : getDefaultRepoConfigPaths(opts.repoRoot);
+    return loadFromCandidates(candidatePaths, opts.required);
+}
+export async function loadConfigStack(opts) {
+    if (!opts.enabled)
+        return {};
+    if (opts.configPath) {
+        const loaded = await tryLoadConfigFile(opts);
+        return loaded ? { repo: loaded } : {};
+    }
+    const repo = await loadFromCandidates(getDefaultRepoConfigPaths(opts.repoRoot), false);
+    const user = await loadFromCandidates(getDefaultUserConfigPaths(), false);
+    return { repo: repo ?? undefined, user: user ?? undefined };
+}
 //# sourceMappingURL=load.js.map

package/dist/core/config/merge.js

@@ -0,0 +1,27 @@
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function mergeValues(userValue, repoValue) {
+    if (repoValue === undefined)
+        return userValue;
+    if (userValue === undefined)
+        return repoValue;
+    if (isPlainObject(userValue) && isPlainObject(repoValue)) {
+        const merged = { ...userValue };
+        for (const [key, value] of Object.entries(repoValue)) {
+            merged[key] = mergeValues(userValue[key], value);
+        }
+        return merged;
+    }
+    return repoValue;
+}
+export function mergeConfigFiles(userConfig, repoConfig) {
+    if (!userConfig && !repoConfig)
+        return undefined;
+    if (!userConfig)
+        return repoConfig;
+    if (!repoConfig)
+        return userConfig;
+    return mergeValues(userConfig, repoConfig);
+}
+//# sourceMappingURL=merge.js.map

package/dist/core/config/paths.js

@@ -1,4 +1,11 @@
-import { join, resolve } from 'path';
+import { homedir } from 'os';
+import { defaultPathAdapter } from '../adapters/path/path-adapter.js';
+function resolveUserConfigHome() {
+    const override = (process.env.SALMONLOOP_USER_CONFIG_HOME || '').trim();
+    if (override)
+        return defaultPathAdapter.resolve(override);
+    return homedir();
+}
 /**
  * Repo-local configuration lives under ".salmonloop/" and is expected to be gitignored.
  * Runtime state is stored under ".salmonloop/runtime/" (audit, rejections, tmp, locks).
@@ -7,14 +14,26 @@ export function getDefaultRepoConfigPath(repoRoot) {
     return getDefaultRepoConfigPaths(repoRoot)[0];
 }
 export function getDefaultRepoConfigPaths(repoRoot) {
-    const base = join(resolve(repoRoot), '.salmonloop', 'config');
-    return [join(base, 'config.yaml'), join(base, 'config.yml'), join(base, 'config.json')];
+    const base = defaultPathAdapter.join(defaultPathAdapter.resolve(repoRoot), '.salmonloop', 'config');
+    return [
+        defaultPathAdapter.join(base, 'config.yaml'),
+        defaultPathAdapter.join(base, 'config.yml'),
+        defaultPathAdapter.join(base, 'config.json'),
+    ];
+}
+export function getDefaultUserConfigPaths() {
+    const base = defaultPathAdapter.join(resolveUserConfigHome(), '.salmonloop', 'config');
+    return [
+        defaultPathAdapter.join(base, 'config.yaml'),
+        defaultPathAdapter.join(base, 'config.yml'),
+        defaultPathAdapter.join(base, 'config.json'),
+    ];
 }
 export function resolveConfigPath(repoRoot, configPath) {
     // Relative paths are resolved against the target repo root (not the CLI's cwd).
-    return resolve(repoRoot, configPath);
+    return defaultPathAdapter.resolve(repoRoot, configPath);
 }
 export function getDefaultIndexPath(repoRoot) {
-    return join(resolve(repoRoot), '.salmonloop', 'index');
+    return defaultPathAdapter.join(defaultPathAdapter.resolve(repoRoot), '.salmonloop', 'index');
 }
 //# sourceMappingURL=paths.js.map

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/resolve.js

@@ -1,5 +1,6 @@
 import { resolveLlmOutputPolicy } from '../llm/output-policy.js';
-import { tryLoadConfigFile } from './load.js';
+import { loadConfigStack } from './load.js';
+import { mergeConfigFiles } from './merge.js';
 import { getDefaultRepoConfigPath } from './paths.js';
 import { resolveLlmFromConfig } from './resolve-llm.js';
 import { resolveAstValidationStrictness } from './resolvers/ast-validation.js';
@@ -15,20 +16,21 @@ export async function resolveConfig(opts) {
     const enabled = opts.enableConfigFile !== false;
     const path = opts.configFilePath;
     const required = Boolean(opts.configFilePath);
-    const loaded = await tryLoadConfigFile({
+    const loaded = await loadConfigStack({
         repoRoot: opts.repoRoot,
         configPath: path,
         enabled,
         required,
     });
-    const raw = loaded?.config;
+    const raw = mergeConfigFiles(loaded.user?.config, loaded.repo?.config);
     const uiLogMode = resolveUiLogMode(raw);
     const permissionMode = resolvePermissionMode(raw);
+    const sourcePath = loaded.repo?.path || loaded.user?.path || path || getDefaultRepoConfigPath(opts.repoRoot);
     return {
         source: {
             enabled,
-            path: loaded?.path || path || getDefaultRepoConfigPath(opts.repoRoot),
-            used: Boolean(loaded),
+            path: sourcePath,
+            used: Boolean(loaded.repo || loaded.user),
         },
         raw,
         permissionMode,

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' });
@@ -471,6 +511,27 @@ export function validateConfigFileV1(input) {
         }
         if (input.llm.activeModel !== undefined)
             cfg.llm.activeModel = input.llm.activeModel;
+        const llmAny = input.llm;
+        if (llmAny.simpleModel !== undefined && !isString(llmAny.simpleModel)) {
+            throw new ConfigError('CONFIG_INVALID_LLM_SIMPLE_MODEL', { expected: 'string' });
+        }
+        if (llmAny.simpleModel !== undefined)
+            cfg.llm.simpleModel = llmAny.simpleModel;
+        if (llmAny.mediumModel !== undefined && !isString(llmAny.mediumModel)) {
+            throw new ConfigError('CONFIG_INVALID_LLM_MEDIUM_MODEL', { expected: 'string' });
+        }
+        if (llmAny.mediumModel !== undefined)
+            cfg.llm.mediumModel = llmAny.mediumModel;
+        if (llmAny.complexModel !== undefined && !isString(llmAny.complexModel)) {
+            throw new ConfigError('CONFIG_INVALID_LLM_COMPLEX_MODEL', { expected: 'string' });
+        }
+        if (llmAny.complexModel !== undefined)
+            cfg.llm.complexModel = llmAny.complexModel;
+        if (llmAny.reasoningModel !== undefined && !isString(llmAny.reasoningModel)) {
+            throw new ConfigError('CONFIG_INVALID_LLM_REASONING_MODEL', { expected: 'string' });
+        }
+        if (llmAny.reasoningModel !== undefined)
+            cfg.llm.reasoningModel = llmAny.reasoningModel;
         if (input.llm.providers !== undefined) {
             if (!isRecord(input.llm.providers)) {
                 throw new ConfigError('CONFIG_INVALID_LLM_PROVIDERS', { expected: 'object' });
@@ -540,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;
             }
         }
@@ -569,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}`);

package/dist/core/context/keywords.js

@@ -85,7 +85,7 @@ function extractPathLikeTokens(input) {
 }
 function extractBacktickedTokens(input) {
     const matches = [];
-    const re = /`([^`]{1,64})`/g;
+    const re = /(?<!`)`([^`\n]{1,64})`(?!`)/g;
     let m;
     while ((m = re.exec(input)) !== null) {
         const val = m[1]?.trim();
@@ -106,7 +106,7 @@ function extractErrorLikeTokens(input) {
 }
 function extractIdentifierTokens(input) {
     const matches = [];
-    const re = /\b[A-Za-z_][A-Za-z0-9_]{2,}\b/g;
+    const re = /\b(?:[A-Z][A-Z0-9_]{1,}\d+[A-Z0-9_]*|[A-Za-z_][A-Za-z0-9_]{2,})\b/g;
     let m;
     while ((m = re.exec(input)) !== null) {
         if (m[0])
@@ -114,6 +114,17 @@ function extractIdentifierTokens(input) {
     }
     return matches;
 }
+function extractQuotedPhrases(input) {
+    const matches = [];
+    const re = /["“”]([^"“”\n]{8,96})["“”]/g;
+    let m;
+    while ((m = re.exec(input)) !== null) {
+        const val = m[1]?.trim();
+        if (val)
+            matches.push(val);
+    }
+    return matches;
+}
 function isCjk(char) {
     return /\p{Script=Han}|\p{Script=Hiragana}|\p{Script=Katakana}|\p{Script=Hangul}/u.test(char);
 }
@@ -143,9 +154,11 @@ export function extractKeywords(instruction) {
     const backticked = extractBacktickedTokens(raw);
     // Priority 3: Error-like tokens (strong signal)
     const errorLike = extractErrorLikeTokens(raw);
-    // Priority 4: Identifiers (code-related)
+    // Priority 4: Quoted diagnostics and messages (strong signal in bug reports)
+    const quotedPhrases = extractQuotedPhrases(raw);
+    // Priority 5: Identifiers (code-related)
     const identifiers = extractIdentifierTokens(raw);
-    // Priority 5: Word tokens
+    // Priority 6: Word tokens
     const wordTokens = raw
         .toLowerCase()
         .split(/[^\p{L}\p{N}_-]+/u)
@@ -155,6 +168,7 @@ export function extractKeywords(instruction) {
         ...pathLike,
         ...backticked,
         ...errorLike,
+        ...quotedPhrases,
         ...identifiers,
         ...wordTokens,
     ]);

package/dist/core/context/service-deps.js

@@ -1,5 +1,5 @@
 import { DefaultPromptAssembler } from './assembly/default-prompt-assembler.js';
-import { PromptCachingManager } from './cache/prompt-caching.js';
+import { getPromptCachingManager } from './cache/prompt-caching.js';
 import { ArchitectureGatherer } from './gatherers/architecture-gatherer.js';
 import { ArtifactGatherer } from './gatherers/artifact-gatherer.js';
 import { AstGatherer } from './gatherers/ast-gatherer.js';
@@ -26,7 +26,7 @@ export function defaultContextServiceDeps() {
         ghostDependencyGatherer: new GhostDependencyGatherer(ripgrepGatherer),
         targetResolver: new TargetResolver(),
         assembler: new DefaultPromptAssembler(),
-        promptCachingManager: new PromptCachingManager(),
+        promptCachingManager: getPromptCachingManager(),
     };
 }
 //# sourceMappingURL=service-deps.js.map

package/dist/core/context/service.js

@@ -147,6 +147,14 @@ export class ContextService {
             if (target.path)
                 deduped.add(target.path);
         }
+        for (const file of result.context.relatedFiles ?? []) {
+            if (file.path)
+                deduped.add(file.path);
+        }
+        for (const snippet of result.context.rgSnippets ?? []) {
+            if (snippet.file)
+                deduped.add(snippet.file);
+        }
         return [...deduped].sort().slice(0, ContextService.MAX_CACHE_TRACKED_FILES);
     }
     async computeTrackedFilesSignature(repoPath, files) {

package/dist/core/context/steps/context-gather.js

@@ -1,7 +1,27 @@
+import { FileAdapter } from '../../adapters/fs/file-adapter.js';
+import { LIMITS } from '../../config/limits.js';
+import { ensureInSandbox, normalizePath, safeJoin } from '../../utils/path.js';
+import { outlineSource } from '../ast/source-outline.js';
 import { CONTEXT_AUDIT_ACTION, CONTEXT_AUDIT_PHASE } from '../audit-constants.js';
 import { recordContextAuditEvent } from '../audit.js';
 import { extractKeywords } from '../keywords.js';
 import { assertNotAborted } from '../service-helpers.js';
+const fileAdapter = new FileAdapter();
+async function readMatchedFileContent(req, file) {
+    if (req.snapshotHash && req.checkpointManager) {
+        return req.checkpointManager.readSnapshotFile(req.repoPath, req.snapshotHash, file);
+    }
+    try {
+        const fullPath = ensureInSandbox(req.repoPath, safeJoin(req.repoPath, file));
+        const stat = await fileAdapter.stat(fullPath);
+        if (!stat.isFile() || stat.size > LIMITS.largeFileThresholdBytes)
+            return null;
+        return await fileAdapter.readFile(fullPath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
 export function buildContextGatherStep(deps) {
     return async ({ req, diffScope, primaryText }) => {
         assertNotAborted(req.signal);
@@ -24,6 +44,24 @@ export function buildContextGatherStep(deps) {
         if (ghostFiles.length > 0) {
             astRes.relatedFiles.push(...ghostFiles);
         }
+        const relatedSeen = new Set(astRes.relatedFiles.map((file) => file.path));
+        const primaryPath = req.primaryFile
+            ? normalizePath(req.primaryFile).replace(/^(\.\/|\/)+/, '')
+            : undefined;
+        for (const snippet of rgSnippets) {
+            const file = normalizePath(snippet.file).replace(/^(\.\/|\/)+/, '');
+            if (!file || file === primaryPath || relatedSeen.has(file))
+                continue;
+            relatedSeen.add(file);
+            const content = await readMatchedFileContent(req, file);
+            astRes.relatedFiles.push({
+                path: file,
+                kind: 'dependency',
+                mode: content ? 'full' : 'outline',
+                content: content ?? `ripgrep match at line ${snippet.line}: ${snippet.content}`,
+                outline: content ? outlineSource(content) : undefined,
+            });
+        }
         recordContextAuditEvent(CONTEXT_AUDIT_ACTION.gatherCompleted, {
             rgSnippets: rgSnippets.length,
             includedFiles: diffRes.includedFiles.length,