salmon-loop 0.2.13 → 0.3.0

package/dist/core/grizzco/flows/AutopilotFlow.js

@@ -0,0 +1,18 @@
+import { Pipeline } from '../engine/pipeline/pipeline.js';
+import { saveAudit } from '../steps/audit.js';
+import { runAutopilot, runAutopilotVerifyGate } from '../steps/autopilot.js';
+import { displayReport } from '../steps/display-report.js';
+import { runPreflight } from '../steps/preflight.js';
+export async function executeAutopilotFlow(initCtx) {
+    const pipeline = Pipeline.of(initCtx)
+        .step('PREFLIGHT', runPreflight)
+        .step('AUTOPILOT', runAutopilot)
+        .step('VERIFY_GATE', runAutopilotVerifyGate)
+        .step('REPORT', displayReport);
+    const report = await pipeline.execute();
+    report.auditPath = await saveAudit(report, initCtx.options);
+    report.strategyName = initCtx.mode;
+    report.fsMode = initCtx.mode;
+    return report;
+}
+//# sourceMappingURL=AutopilotFlow.js.map

package/dist/core/grizzco/flows/flow-dispatch.js

@@ -0,0 +1,11 @@
+import { resolveExecutionProfile } from '../../runtime/execution-profile.js';
+import { executeAutopilotFlow } from './AutopilotFlow.js';
+import { executeSalmonLoopFlow } from './SalmonLoopFlow.js';
+export async function executeFlowAttempt(initCtx) {
+    const profile = resolveExecutionProfile(initCtx.mode);
+    if (profile.driver === 'agent') {
+        return executeAutopilotFlow(initCtx);
+    }
+    return executeSalmonLoopFlow(initCtx);
+}
+//# sourceMappingURL=flow-dispatch.js.map

package/dist/core/grizzco/steps/answer.js

@@ -1,16 +1,8 @@
-import { composeChatMessages } from '../../llm/message-composition.js';
 import { emitLlmOutput } from '../../llm/output-policy.js';
+import { getAnswerSystemPrompt } from '../../prompts/runtime.js';
 import { chatWithTools } from '../../tools/session.js';
 import { Phase } from '../../types/index.js';
-function buildSystemPrompt() {
-    return [
-        'You are a coding assistant in "answer" mode.',
-        'You may use read-only tools to inspect the repository when helpful.',
-        'Never write files, never apply patches, and never run shell commands.',
-        'If repository inspection is not required, answer directly without tools.',
-        'Answer in the same language as the user.',
-    ].join('\n');
-}
+import { buildSharedRequestEnvelope } from './request-assembly.js';
 export async function generateAnswer(ctx) {
     const instruction = String(ctx.options.instruction ?? '').trim();
     if (!instruction) {
@@ -19,15 +11,21 @@ export async function generateAnswer(ctx) {
             report: { kind: 'answer', summary: '', timestamp: Date.now() },
         };
     }
-    const messages = composeChatMessages({
-        system: buildSystemPrompt(),
-        user: instruction,
+    const shared = buildSharedRequestEnvelope({
+        defaultNamespace: 'answer',
+        systemPrompt: await getAnswerSystemPrompt(),
+        userPrompt: instruction,
         conversationContext: ctx.options.conversationContext,
     });
+    const messages = shared.baseMessages;
     const llmClient = ctx.options.llm;
     const supportsTools = Boolean(ctx.toolstack);
     const assistant = supportsTools
-        ? await chatWithTools(messages, { temperature: 0.2, signal: ctx.options.signal }, {
+        ? await chatWithTools(messages, {
+            providerHints: shared.envelope.providerHints,
+            temperature: 0.2,
+            signal: ctx.options.signal,
+        }, {
             phase: Phase.EXPLORE,
             llm: llmClient,
             runtime: {
@@ -48,6 +46,7 @@ export async function generateAnswer(ctx) {
             },
         })
         : await llmClient.chat(messages, {
+            providerHints: shared.envelope.providerHints,
             temperature: 0.2,
             signal: ctx.options.signal,
             tools: [],

package/dist/core/grizzco/steps/autopilot.js

@@ -0,0 +1,396 @@
+import { createHash } from 'crypto';
+import { join } from 'path';
+import { text } from '../../../locales/index.js';
+import { lstat, readlink } from '../../adapters/fs/node-fs.js';
+import { GitAdapter } from '../../adapters/git/git-adapter.js';
+import { LIMITS } from '../../config/limits.js';
+import { supportsLlmStreaming } from '../../llm/capabilities.js';
+import { emitLlmOutput } from '../../llm/output-policy.js';
+import { getAutopilotSystemPrompt } from '../../prompts/runtime.js';
+import { SessionReplacementPreviewProvider } from '../../session/replacement-preview-provider.js';
+import { chatWithTools, chatWithToolsStreaming } from '../../tools/session.js';
+import { Phase } from '../../types/runtime.js';
+import { resolveLlmToolCallingPolicy } from '../dsl/llm-strategy.js';
+import { buildAugmentedRequestEnvelope } from './request-assembly.js';
+import { buildPhaseToolRuntimeContext, buildToolVisibilityRuntime } from './tool-runtime.js';
+import { executeVerifyForWorkspace } from './verify-shared.js';
+const AUTOPILOT_TOOL_PHASE = Phase.AUTOPILOT;
+const WORKSPACE_SAMPLE_LIMITS = {
+    maxStdoutBytes: LIMITS.maxToolOutputBytes,
+    maxStderrChars: 16_384,
+};
+const GIT_HASH_OUTPUT_LIMITS = {
+    maxStdoutBytes: 256,
+    maxStderrChars: 4_096,
+};
+function hashFingerprintValue(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function hashFingerprintBuffer(buffer) {
+    return createHash('sha256').update(buffer).digest('hex');
+}
+function decodeNulSeparatedRecords(buffer) {
+    return buffer
+        .toString('utf8')
+        .split('\0')
+        .filter((value) => value.length > 0);
+}
+function readSpaceDelimitedField(record, fieldIndex) {
+    let fieldStart = 0;
+    let currentField = 0;
+    for (let index = 0; index <= record.length; index += 1) {
+        const atSeparator = index === record.length || record[index] === ' ';
+        if (!atSeparator) {
+            continue;
+        }
+        if (currentField === fieldIndex) {
+            return record.slice(fieldStart, index);
+        }
+        currentField += 1;
+        fieldStart = index + 1;
+    }
+    throw new Error(`Malformed status record: ${record}`);
+}
+function readPathAfterFieldCount(record, fieldCount) {
+    let spacesSeen = 0;
+    for (let index = 0; index < record.length; index += 1) {
+        if (record[index] !== ' ') {
+            continue;
+        }
+        spacesSeen += 1;
+        if (spacesSeen === fieldCount) {
+            return record.slice(index + 1);
+        }
+    }
+    throw new Error(`Malformed status record: ${record}`);
+}
+function collectWorkspaceStatusEntries(statusOutput) {
+    const records = decodeNulSeparatedRecords(statusOutput);
+    const entries = [];
+    for (let index = 0; index < records.length; index += 1) {
+        const record = records[index];
+        const kind = record[0];
+        if (kind === '?') {
+            entries.push({
+                path: readPathAfterFieldCount(record, 1),
+                statusFingerprint: hashFingerprintValue(record),
+                hashable: true,
+            });
+            continue;
+        }
+        if (kind === '!') {
+            continue;
+        }
+        if (kind === '1') {
+            entries.push({
+                path: readPathAfterFieldCount(record, 8),
+                statusFingerprint: hashFingerprintValue(record),
+                hashable: readSpaceDelimitedField(record, 5) !== '000000',
+            });
+            continue;
+        }
+        if (kind === '2') {
+            const path = readPathAfterFieldCount(record, 9);
+            const originalPath = records[index + 1] ?? '';
+            const statusFingerprint = hashFingerprintValue(`${record}\0${originalPath}`);
+            entries.push({
+                path,
+                statusFingerprint,
+                hashable: readSpaceDelimitedField(record, 5) !== '000000',
+            });
+            if (originalPath) {
+                entries.push({
+                    path: originalPath,
+                    statusFingerprint: hashFingerprintValue(`rename-source:${record}\0${originalPath}`),
+                    hashable: false,
+                });
+            }
+            index += 1;
+            continue;
+        }
+        if (kind === 'u') {
+            entries.push({
+                path: readPathAfterFieldCount(record, 10),
+                statusFingerprint: hashFingerprintValue(record),
+                hashable: readSpaceDelimitedField(record, 6) !== '000000',
+            });
+            continue;
+        }
+        throw new Error(`Unsupported status record: ${record}`);
+    }
+    return entries;
+}
+async function runBoundedGit(git, workspacePath, args, limits) {
+    const result = await git.execMeta(args, {
+        cwd: workspacePath,
+        limits,
+        timeoutMs: LIMITS.gitTimeoutMs,
+    });
+    if (result.stdoutTruncated) {
+        throw new Error(text.git.outputTruncated(limits.maxStdoutBytes));
+    }
+    if (!result.ok) {
+        throw new Error(result.error?.message || result.stderr.trim() || `git ${args.join(' ')} failed`);
+    }
+    return result.stdout;
+}
+async function hashWorkingPath(git, workspacePath, filePath) {
+    const output = await runBoundedGit(git, workspacePath, ['hash-object', '--no-filters', '--', filePath], GIT_HASH_OUTPUT_LIMITS);
+    return output.toString('utf8').trim();
+}
+async function fingerprintWorkingPath(git, workspacePath, filePath) {
+    const absolutePath = join(workspacePath, filePath);
+    const stats = await lstat(absolutePath);
+    if (stats.isSymbolicLink()) {
+        return `symlink:${hashFingerprintValue(await readlink(absolutePath))}`;
+    }
+    return `file:${await hashWorkingPath(git, workspacePath, filePath)}`;
+}
+async function captureWorkspaceFingerprint(workspacePath) {
+    const git = new GitAdapter(workspacePath);
+    const head = (await runBoundedGit(git, workspacePath, ['rev-parse', 'HEAD'], GIT_HASH_OUTPUT_LIMITS))
+        .toString('utf8')
+        .trim();
+    const index = (await runBoundedGit(git, workspacePath, ['write-tree'], GIT_HASH_OUTPUT_LIMITS))
+        .toString('utf8')
+        .trim();
+    const statusOutput = await runBoundedGit(git, workspacePath, ['status', '--porcelain=v2', '-z', '--untracked-files=all', '--ignored=no'], WORKSPACE_SAMPLE_LIMITS);
+    const statusEntries = collectWorkspaceStatusEntries(statusOutput);
+    const workingEntries = [];
+    for (const entry of statusEntries) {
+        if (!entry.hashable) {
+            continue;
+        }
+        workingEntries.push([entry.path, await fingerprintWorkingPath(git, workspacePath, entry.path)]);
+    }
+    const workingContent = hashFingerprintValue(workingEntries.map(([path, fingerprint]) => `${path}:${fingerprint}`).join('\n'));
+    return {
+        head,
+        index,
+        statusMetadata: hashFingerprintBuffer(statusOutput),
+        workingContent,
+        statusEntries: statusEntries.map(({ path, statusFingerprint }) => [path, statusFingerprint]),
+        workingEntries,
+    };
+}
+function collectChangedWorkspacePaths(before, after) {
+    const beforeStatusEntries = new Map(before.statusEntries);
+    const afterStatusEntries = new Map(after.statusEntries);
+    const beforeEntries = new Map(before.workingEntries);
+    const afterEntries = new Map(after.workingEntries);
+    const paths = new Set([
+        ...beforeStatusEntries.keys(),
+        ...afterStatusEntries.keys(),
+        ...beforeEntries.keys(),
+        ...afterEntries.keys(),
+    ]);
+    return [...paths]
+        .filter((path) => beforeStatusEntries.get(path) !== afterStatusEntries.get(path) ||
+        beforeEntries.get(path) !== afterEntries.get(path))
+        .filter((path) => !isRuntimeGeneratedPath(path))
+        .sort((left, right) => left.localeCompare(right));
+}
+function isRuntimeGeneratedPath(path) {
+    if (path === '.salmonloop' || path.startsWith('.salmonloop/'))
+        return true;
+    if (path === 'headless.jsonl' || path === 'headless.stderr')
+        return true;
+    return false;
+}
+function lastFailedToolAuditEntry(entries) {
+    if (!Array.isArray(entries))
+        return undefined;
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (entry?.toolResultStatus && entry.toolResultStatus !== 'ok') {
+            return entry;
+        }
+    }
+    return undefined;
+}
+function resolveAutopilotCompletion(params) {
+    if (params.mutated)
+        return { status: 'changed' };
+    const failedTool = lastFailedToolAuditEntry(params.localAudit);
+    if (failedTool) {
+        const reason = failedTool.toolResultErrorMessage
+            ? `Tool ${failedTool.toolName} failed: ${failedTool.toolResultErrorMessage}`
+            : `Tool ${failedTool.toolName} failed.`;
+        return {
+            status: 'tool_failure',
+            reason,
+            errorCode: failedTool.toolResultErrorCode,
+        };
+    }
+    if (params.content.trim()) {
+        return { status: 'read_only_answer' };
+    }
+    return {
+        status: 'no_effect',
+        reason: 'Autopilot completed without changing files or producing an answer.',
+    };
+}
+function buildAutopilotRequestContext(ctx, instruction) {
+    const maybeContext = ctx.context;
+    if (maybeContext?.repoPath && Array.isArray(maybeContext.rgSnippets)) {
+        return maybeContext;
+    }
+    return {
+        repoPath: ctx.workspace.workPath,
+        instruction,
+        contextHash: `autopilot:${ctx.workspace.workPath}`,
+        rgSnippets: [],
+    };
+}
+export async function runAutopilot(ctx) {
+    const instruction = String(ctx.options.instruction ?? '').trim();
+    if (!instruction) {
+        return {
+            ...ctx,
+            mutated: false,
+            report: { kind: 'answer', summary: '', timestamp: Date.now() },
+        };
+    }
+    const toolVisibility = buildToolVisibilityRuntime(ctx);
+    const requestContext = buildAutopilotRequestContext(ctx, instruction);
+    const shared = await buildAugmentedRequestEnvelope({
+        phase: AUTOPILOT_TOOL_PHASE,
+        defaultNamespace: 'autopilot',
+        systemPrompt: await getAutopilotSystemPrompt(),
+        context: requestContext,
+        baseContextPrompt: instruction,
+        buildUserPrompt: async (contextPrompt) => contextPrompt,
+        conversationContext: ctx.options.conversationContext,
+        artifactHints: ctx.artifactHints,
+        toolCallingAudit: ctx.toolCallingAudit,
+        previewProvider: new SessionReplacementPreviewProvider(ctx.replacementState),
+        toolVisibility: {
+            toolstack: ctx.toolstack,
+            runtime: toolVisibility,
+            worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
+            flowMode: ctx.mode,
+        },
+    });
+    const llmClient = ctx.options.llm;
+    const toolPolicy = resolveLlmToolCallingPolicy(AUTOPILOT_TOOL_PHASE, llmClient);
+    const localAudit = [];
+    const supportsStreaming = supportsLlmStreaming(llmClient, AUTOPILOT_TOOL_PHASE);
+    const supportsTools = Boolean(ctx.toolstack && toolPolicy.enabled);
+    let workspaceFingerprintBefore = null;
+    let samplingFailedClosed = false;
+    if (supportsTools) {
+        try {
+            workspaceFingerprintBefore = await captureWorkspaceFingerprint(ctx.workspace.workPath);
+        }
+        catch {
+            samplingFailedClosed = true;
+        }
+    }
+    const assistant = supportsTools
+        ? await (supportsStreaming ? chatWithToolsStreaming : chatWithTools)(shared.baseMessages, {
+            phase: AUTOPILOT_TOOL_PHASE,
+            providerHints: shared.envelope.providerHints,
+            temperature: 0.2,
+            signal: ctx.options.signal,
+        }, {
+            phase: AUTOPILOT_TOOL_PHASE,
+            llm: llmClient,
+            runtime: buildPhaseToolRuntimeContext(ctx, AUTOPILOT_TOOL_PHASE, shared.cacheSurface),
+            toolVisibility,
+            toolstack: ctx.toolstack,
+            eventPayload: ctx.options.eventPayload,
+            toolCallingAudit: {
+                event: (entry) => {
+                    localAudit.push(entry);
+                },
+            },
+            maxRounds: toolPolicy.maxRounds,
+            llmOutput: {
+                policy: ctx.options.llmOutput,
+                kind: 'assistant_message',
+                step: 'REPORT',
+            },
+            emit: (event) => ctx.emit({ ...event, timestamp: event.timestamp ?? new Date() }),
+        })
+        : await llmClient.chat(shared.baseMessages, {
+            phase: 'AUTOPILOT',
+            providerHints: shared.envelope.providerHints,
+            temperature: 0.2,
+            signal: ctx.options.signal,
+            tools: [],
+            toolChoice: 'none',
+        });
+    const content = String(assistant?.content ?? '').trim();
+    if (!supportsTools) {
+        emitLlmOutput({
+            emit: ctx.emit,
+            policy: ctx.options.llmOutput,
+            kind: 'assistant_message',
+            step: 'REPORT',
+            content,
+        });
+    }
+    const mergedAudit = localAudit.length > 0 ? [...(ctx.toolCallingAudit ?? []), ...localAudit] : ctx.toolCallingAudit;
+    let mutated = false;
+    let changedFiles;
+    if (supportsTools) {
+        if (samplingFailedClosed || !workspaceFingerprintBefore) {
+            mutated = true;
+        }
+        else {
+            try {
+                const workspaceFingerprintAfter = await captureWorkspaceFingerprint(ctx.workspace.workPath);
+                changedFiles = collectChangedWorkspacePaths(workspaceFingerprintBefore, workspaceFingerprintAfter);
+                mutated =
+                    changedFiles.length > 0 ||
+                        workspaceFingerprintBefore.head !== workspaceFingerprintAfter.head ||
+                        workspaceFingerprintBefore.index !== workspaceFingerprintAfter.index;
+            }
+            catch {
+                mutated = true;
+            }
+        }
+    }
+    return {
+        ...ctx,
+        mutated,
+        changedFiles: changedFiles && changedFiles.length > 0 ? changedFiles : undefined,
+        completion: resolveAutopilotCompletion({ content, mutated, localAudit }),
+        toolCallingAudit: mergedAudit,
+        report: {
+            kind: 'answer',
+            summary: content,
+            timestamp: Date.now(),
+        },
+    };
+}
+export async function runAutopilotVerifyGate(ctx) {
+    if (!ctx.mutated) {
+        return {
+            ...ctx,
+            verifyResult: undefined,
+        };
+    }
+    if (!ctx.options.verify) {
+        return {
+            ...ctx,
+            completion: {
+                status: 'verification_missing',
+                reason: 'Autopilot changed the workspace but no verification command was configured.',
+                errorCode: 'VERIFY_COMMAND_MISSING',
+            },
+            verifyResult: undefined,
+        };
+    }
+    const { verifyResult, verifyArtifact } = await executeVerifyForWorkspace({
+        workspacePath: ctx.workspace.workPath,
+        verify: ctx.options.verify,
+        signal: ctx.options.signal,
+    });
+    const nextCtx = {
+        ...ctx,
+        verifyResult,
+    };
+    return verifyArtifact ? { ...nextCtx, verifyArtifact } : nextCtx;
+}
+//# sourceMappingURL=autopilot.js.map

package/dist/core/grizzco/steps/cache-sharing.js

@@ -0,0 +1,29 @@
+export function resolveCacheSharingSurface(args) {
+    const namespace = args.cacheSharing?.namespace ?? args.defaultNamespace;
+    const sharedContextHash = args.cacheSharing?.contextHash;
+    const localContextHash = args.localContextHash;
+    const mismatchPolicy = args.mismatchPolicy ?? 'prefer_local';
+    if (typeof localContextHash === 'string' &&
+        localContextHash.length > 0 &&
+        typeof sharedContextHash === 'string' &&
+        sharedContextHash.length > 0 &&
+        sharedContextHash !== localContextHash) {
+        args.onMismatch?.({
+            phase: args.phase,
+            namespace,
+            localContextHash,
+            sharedContextHash,
+        });
+        if (mismatchPolicy === 'prefer_local') {
+            return {
+                namespace: args.defaultNamespace,
+                contextHash: localContextHash,
+            };
+        }
+    }
+    return {
+        namespace,
+        contextHash: sharedContextHash ?? localContextHash,
+    };
+}
+//# sourceMappingURL=cache-sharing.js.map

package/dist/core/grizzco/steps/explore.js

@@ -1,14 +1,17 @@
 import path from 'path';
 import { text } from '../../../locales/index.js';
-import { composeChatMessages } from '../../llm/message-composition.js';
-import { formatContextForPrompt } from '../../llm/utils.js';
+import { supportsLlmStreaming } from '../../llm/capabilities.js';
+import { recordAuditEvent } from '../../observability/audit-trail.js';
 import { getExplorePrompt, getExploreSystemPrompt } from '../../prompts/runtime.js';
+import { SessionReplacementPreviewProvider } from '../../session/replacement-preview-provider.js';
 import { chatWithTools, chatWithToolsStreaming } from '../../tools/session.js';
 import { SalmonError } from '../../types/errors.js';
 import { Phase } from '../../types/runtime.js';
 import { ensureInSandbox, isSafeRelativePath, normalizePath } from '../../utils/path.js';
 import { resolveLlmToolCallingPolicy } from '../dsl/llm-strategy.js';
 import { ContextValidator } from '../validation/ContextValidator.js';
+import { buildPhaseRequestEnvelope } from './request-assembly.js';
+import { buildPhaseToolRuntimeContext, buildToolVisibilityRuntime } from './tool-runtime.js';
 const SAFE_INFERRED_EXTENSIONS = new Set([
     '.ts',
     '.tsx',
@@ -76,9 +79,8 @@ export const exploreCodebase = async (ctx) => {
         });
         return { ...ctx };
     }
-    const prompt = await getExplorePrompt(formatContextForPrompt(ctx.context), ctx.options.instruction, ctx.lastError);
-    const systemPrompt = await getExploreSystemPrompt(toolstack.registry, { plan: ctx.planRuntime });
-    const supportsStreaming = typeof ctx.options.llm.chatStream === 'function';
+    const systemPrompt = await getExploreSystemPrompt({ plan: ctx.planRuntime });
+    const supportsStreaming = supportsLlmStreaming(ctx.options.llm, Phase.EXPLORE);
     const llmOutput = {
         policy: ctx.options.llmOutput,
         kind: 'explore',
@@ -128,29 +130,43 @@ export const exploreCodebase = async (ctx) => {
         router: proxiedRouter,
     };
     const localAudit = [];
-    const baseMessages = composeChatMessages({
-        system: systemPrompt,
-        user: prompt,
+    const toolVisibility = buildToolVisibilityRuntime(ctx);
+    const requestEnvelope = await buildPhaseRequestEnvelope({
+        phase: Phase.EXPLORE,
+        defaultNamespace: 'explore',
+        context: ctx.context,
+        contextResult: ctx.contextResult,
+        cacheSharing: ctx.cacheSharing,
+        onCacheMismatch: (mismatch) => {
+            recordAuditEvent('request.cache_sharing_hash_mismatch', mismatch, {
+                source: 'llm',
+                severity: 'low',
+                scope: 'session',
+                phase: Phase.EXPLORE,
+            });
+        },
+        systemPrompt,
+        buildUserPrompt: (contextPrompt) => getExplorePrompt(contextPrompt, ctx.options.instruction, ctx.lastError),
         conversationContext: ctx.options.conversationContext,
+        artifactHints: ctx.artifactHints,
+        toolCallingAudit: ctx.toolCallingAudit,
+        previewProvider: new SessionReplacementPreviewProvider(ctx.replacementState),
+        toolVisibility: {
+            toolstack,
+            runtime: toolVisibility,
+            worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
+            flowMode: ctx.mode,
+        },
     });
+    const { cacheSurface, envelope, baseMessages } = requestEnvelope;
     await (supportsStreaming ? chatWithToolsStreaming : chatWithTools)(baseMessages, {
+        providerHints: envelope.providerHints,
         signal: ctx.options.signal,
     }, {
         phase: Phase.EXPLORE,
         llm: ctx.options.llm,
-        runtime: {
-            repoRoot: ctx.workspace.workPath,
-            persistenceRoot: ctx.workspace.baseRepoPath || ctx.workspace.workPath,
-            worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
-            attemptId: ctx.attempt ?? 1,
-            dryRun: Boolean(ctx.options?.dryRun),
-            llm: ctx.options.llm,
-            model: ctx.options.llm.getModelId?.() || process.env.SALMONLOOP_MODEL || process.env.S8P_MODEL,
-            userInputProvider: ctx.options.userInputProvider,
-            agentKind: ctx.options.agentKind ?? 'primary',
-            languagePlugins: ctx.options.languagePlugins,
-            subAgentController: ctx.options.subAgentController,
-        },
+        runtime: buildPhaseToolRuntimeContext(ctx, Phase.EXPLORE, cacheSurface),
+        toolVisibility,
         toolstack: proxiedToolstack,
         eventPayload: ctx.options.eventPayload,
         toolCallingAudit: {

package/dist/core/grizzco/steps/generateReview.js

@@ -1,9 +1,6 @@
 import { text } from '../../../locales/index.js';
 import { emitLlmOutput } from '../../llm/output-policy.js';
-function buildReviewPrompt(context) {
-    const summary = JSON.stringify(context, null, 2);
-    return `Please review the following context and provide suggestions for improvement:\n\n${summary}`;
-}
+import { getReviewPrompt } from '../../prompts/runtime.js';
 function normalizeReviewSuggestions(value) {
     if (value == null)
         return null;
@@ -31,7 +28,7 @@ function parseReviewResponse(content) {
     }
 }
 export async function generateReview(ctx) {
-    const reviewPrompt = buildReviewPrompt(ctx.context);
+    const reviewPrompt = await getReviewPrompt(JSON.stringify(ctx.context, null, 2));
     const llmClient = ctx.options.llm;
     const response = await llmClient.chat([{ role: 'user', content: reviewPrompt }], {
         tools: [],

package/dist/core/grizzco/steps/patch/apply-check.js

@@ -0,0 +1,10 @@
+import { GitAdapter } from '../../../adapters/git/git-adapter.js';
+export async function checkPatchApplies(args, deps) {
+    const git = deps?.createGitAdapter?.(args.repoRoot) ?? new GitAdapter(args.repoRoot);
+    return git.execMeta(['apply', '--check', '--recount', '--ignore-whitespace', '--whitespace=nowarn', '-'], {
+        input: Buffer.from(args.diff, 'utf8'),
+        timeoutMs: 15000,
+        limits: { maxStdoutBytes: 0, maxStderrChars: 4000 },
+    });
+}
+//# sourceMappingURL=apply-check.js.map