salmon-loop 0.2.3

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

@@ -0,0 +1,75 @@
+import { composeChatMessages } from '../../llm/message-composition.js';
+import { emitLlmOutput } from '../../llm/output-policy.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');
+}
+export async function generateAnswer(ctx) {
+    const instruction = String(ctx.options.instruction ?? '').trim();
+    if (!instruction) {
+        return {
+            ...ctx,
+            report: { kind: 'answer', summary: '', timestamp: Date.now() },
+        };
+    }
+    const messages = composeChatMessages({
+        system: buildSystemPrompt(),
+        user: instruction,
+        conversationContext: ctx.options.conversationContext,
+    });
+    const llmClient = ctx.options.llm;
+    const supportsTools = Boolean(ctx.toolstack);
+    const assistant = supportsTools
+        ? await chatWithTools(messages, { temperature: 0.2, signal: ctx.options.signal }, {
+            phase: Phase.EXPLORE,
+            llm: llmClient,
+            runtime: {
+                repoRoot: ctx.workspace.workPath,
+                persistenceRoot: ctx.workspace.baseRepoPath || ctx.workspace.workPath,
+                attemptId: ctx.attempt ?? 1,
+                dryRun: Boolean(ctx.options?.dryRun),
+                model: llmClient.getModelId?.(),
+                languagePlugins: ctx.options.languagePlugins,
+                subAgentController: ctx.options.subAgentController,
+            },
+            toolstack: ctx.toolstack,
+            emit: ctx.emit,
+            llmOutput: {
+                policy: ctx.options.llmOutput,
+                kind: 'assistant_message',
+                step: 'REPORT',
+            },
+        })
+        : await llmClient.chat(messages, {
+            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,
+        });
+    }
+    return {
+        ...ctx,
+        report: {
+            kind: 'answer',
+            summary: content,
+            timestamp: Date.now(),
+        },
+    };
+}
+//# sourceMappingURL=answer.js.map

package/dist/core/grizzco/steps/apply-back.js

@@ -0,0 +1,46 @@
+import { text } from '../../../locales/index.js';
+import { runApplyBackPhase } from '../runtime/apply-back-runtime.js';
+function buildSkippedResult() {
+    return {
+        success: true,
+        skipped: true,
+        telemetry: {},
+    };
+}
+export const runApplyBack = async (ctx) => {
+    if (!ctx.verifyResult.ok || ctx.options.dryRun) {
+        return {
+            ...ctx,
+            applyBackResult: buildSkippedResult(),
+        };
+    }
+    const runtime = ctx.applyBackRuntime;
+    if (!runtime || ctx.options.strategy !== 'worktree') {
+        return {
+            ...ctx,
+            applyBackResult: buildSkippedResult(),
+        };
+    }
+    const applyBackResult = await runApplyBackPhase({
+        attempt: ctx.attempt ?? 1,
+        options: ctx.options,
+        checkpointRef: runtime.checkpointRef,
+        initialSnapshotHash: runtime.initialSnapshotHash,
+        synchronizer: runtime.synchronizer,
+        activeRepoPath: runtime.activeRepoPath,
+        shadowTaskId: runtime.shadowTaskId,
+        diff: ctx.diff,
+        changedFiles: ctx.changedFiles ?? [],
+        emit: ctx.emit,
+    });
+    return {
+        ...ctx,
+        applyBackResult,
+        ...(applyBackResult.success
+            ? {}
+            : {
+                lastError: applyBackResult.safeMessage || applyBackResult.error || text.loop.applyBackFailed,
+            }),
+    };
+};
+//# sourceMappingURL=apply-back.js.map

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

@@ -0,0 +1,136 @@
+import { text } from '../../../locales/index.js';
+import { recordAuditEvent } from '../../observability/audit-trail.js';
+import { convertDiffToShadowOperations } from '../../patch/diff.js';
+import { getRejectionsDir } from '../../runtime/paths.js';
+import { FileStatus, } from '../domain/grizzco-types.js';
+import { MicroTaskRunner } from '../dsl/MicroTaskRunner.js';
+import { StandardStrategy } from '../dsl/strategies.js';
+import { Executor } from '../execution/Executor.js';
+import { WorkerFactory } from '../execution/WorkerFactory.js';
+import { CachedService } from '../services/CachedService.js';
+import { GitConfigService } from '../services/implementations/default/GitConfigService.js';
+import { MockLockService } from '../services/implementations/mock/MockLockService.js';
+import { MockUserQuotaService } from '../services/implementations/mock/MockUserQuotaService.js';
+import { registry } from '../services/registry.js';
+/**
+ * Bootstraps the service registry with required providers.
+ */
+export function bootstrapRegistry() {
+    if (!registry.has('remote_lock'))
+        registry.register(new MockLockService());
+    if (!registry.has('user_quota'))
+        registry.register(new MockUserQuotaService());
+    if (!registry.has('git_config'))
+        registry.register(new CachedService(new GitConfigService()));
+}
+export const runApply = async (ctx) => {
+    const { workspace, diff, fileStateResolver, emit } = ctx;
+    bootstrapRegistry();
+    const workerFactory = new WorkerFactory(workspace.workPath);
+    const repoRoot = workspace.baseRepoPath || workspace.workPath;
+    const executor = new Executor(workerFactory, getRejectionsDir(repoRoot));
+    const operations = await convertDiffToShadowOperations(diff);
+    const paths = operations.map((op) => op.path);
+    const stateMap = await fileStateResolver.getWorkspaceMap(paths);
+    const executionResults = [];
+    const allDecisions = [];
+    let successCount = 0;
+    const dslOptions = {
+        force: false,
+        allowMM: ctx.options.applyBackOnDirty === '3way',
+        safeMode: true,
+        rejectDir: getRejectionsDir(repoRoot),
+        dryRun: Boolean(ctx.options.dryRun),
+        maxFileSize: Number.MAX_SAFE_INTEGER,
+        verbose: ctx.options.verbose,
+    };
+    const processOperation = async (op) => {
+        const fileState = stateMap.get(op.path);
+        const fileInfo = fileState
+            ? { ...fileState, hasConflict: fileState.status === FileStatus.CONFLICT }
+            : {
+                path: op.path,
+                status: FileStatus.CLEAN,
+                isBinary: false,
+                isSymlink: false,
+                isIgnored: false,
+                hasConflict: false,
+                size: 0,
+            };
+        const dslCtx = {
+            repoRoot: workspace.workPath,
+            file: fileInfo,
+            operation: op,
+            options: dslOptions,
+            // NOTE:
+            // - In worktree strategy, ctx.shadowInitialRef is a real snapshot commit hash (T0) and is required
+            //   for MM (double-dirty) merges.
+            // - In direct strategy (anchor deferred), we fall back to HEAD as a best-effort base revision
+            //   so workers never attempt to resolve an invalid revision like "T0".
+            snapshot: {
+                exists: true,
+                id: ctx.shadowInitialRef || 'HEAD',
+                timestamp: Date.now(),
+                path: '',
+            },
+            runtime: { needsRollback: false },
+            data: {},
+        };
+        const microTaskRunner = new MicroTaskRunner({
+            strategy: StandardStrategy,
+            debugLabel: op.path,
+            maxRounds: 10,
+            resolveData: async (_microCtx, key) => {
+                const service = registry.get(key);
+                if (!service)
+                    throw new Error(text.grizzco.unknownDataDependency(key));
+                return service.fetch(ctx, op.path);
+            },
+        });
+        const microResult = await microTaskRunner.decide(dslCtx);
+        const plan = microResult.plan;
+        allDecisions.push({
+            path: op.path,
+            decisions: microResult.decisions,
+        });
+        recordAuditEvent('grizzco.apply.execution_plan', {
+            path: op.path,
+            workerId: plan.workerId || null,
+            shouldAbort: plan.shouldAbort,
+            actions: plan.actions,
+            decisionTree: plan.decisionTree,
+        }, { source: 'grizzco', severity: 'low', scope: 'session', phase: 'APPLY' });
+        if (plan.shouldAbort) {
+            throw new Error(text.grizzco.planAborted(op.path, plan.abortReason || 'Unknown reason'));
+        }
+        const execResult = await executor.execute(plan, dslCtx);
+        executionResults.push(execResult);
+        if (!execResult.success) {
+            throw new Error(text.grizzco.executionFailed(op.path, execResult.error || 'Unknown error'));
+        }
+        if (execResult.actionTaken.startsWith('MERGE'))
+            successCount++;
+    };
+    const CONCURRENCY = 5;
+    for (let i = 0; i < operations.length; i += CONCURRENCY) {
+        const batch = operations.slice(i, i + CONCURRENCY);
+        await Promise.all(batch.map((op) => processOperation(op)));
+    }
+    emit({
+        type: 'log',
+        level: 'info',
+        message: text.grizzco.transactionCompleted(successCount, operations.length),
+        timestamp: new Date(),
+    });
+    return {
+        ...ctx,
+        applyResult: {
+            success: true,
+            results: executionResults,
+            successCount,
+            totalFiles: operations.length,
+            decisions: allDecisions,
+        },
+    };
+};
+//# sourceMappingURL=apply.js.map

package/dist/core/grizzco/steps/ast-validate.js

@@ -0,0 +1,37 @@
+import { text } from '../../../locales/index.js';
+import { resolveAstValidationStrictness } from '../validation/ast-validation-policy.js';
+import { AstValidationService } from '../validation/AstValidationService.js';
+export const validateAst = async (ctx) => {
+    const service = new AstValidationService();
+    const strictness = resolveAstValidationStrictness({
+        mode: ctx.mode,
+        options: ctx.options,
+    });
+    const result = await service.validate({
+        workPath: ctx.workspace.workPath,
+        diff: ctx.diff,
+        strictness,
+    });
+    if (!result.ok) {
+        ctx.emit({
+            type: 'log',
+            level: 'error',
+            message: text.loop.astValidationFailed(result.error || 'Unknown error'),
+            timestamp: new Date(),
+        });
+        // We choose to abort pipeline if AST is invalid
+        throw new Error(result.error || text.loop.astValidationFailed('Unknown error'));
+    }
+    ctx.emit({
+        type: 'log',
+        level: 'info',
+        message: text.loop.astValidationPassed,
+        timestamp: new Date(),
+    });
+    return {
+        ...ctx,
+        astValid: true,
+        astError: undefined,
+    };
+};
+//# sourceMappingURL=ast-validate.js.map

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

@@ -0,0 +1,311 @@
+import { createHash } from 'crypto';
+import path from 'path';
+import * as fs from '../../adapters/fs/node-fs.js';
+import { LIMITS } from '../../config/limits.js';
+import { truncateOutput } from '../../context/truncation/index.js';
+import { getAuditTrail, recordAuditEvent } from '../../observability/audit-trail.js';
+import { mapErrorForDisplay } from '../../observability/error-mapping.js';
+import { getLogger } from '../../observability/logger.js';
+import { getAuditDir } from '../../runtime/paths.js';
+import { SalmonError } from '../../types/errors.js';
+function replaceRedactedTokens(value) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value === 'string')
+        return mapErrorForDisplay({ message: value }).message;
+    if (Array.isArray(value))
+        return value.map((item) => replaceRedactedTokens(item));
+    if (typeof value === 'object') {
+        const result = {};
+        for (const [key, entry] of Object.entries(value)) {
+            result[key] = replaceRedactedTokens(entry);
+        }
+        return result;
+    }
+    return value;
+}
+export async function saveAudit(report, _options) {
+    try {
+        const auditScope = _options?.auditScope ?? 'repo';
+        const auditDir = getAuditDir(_options?.repoPath || process.cwd(), auditScope);
+        await fs.mkdir(auditDir, { recursive: true });
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const filename = `audit-${timestamp}.json`;
+        // Sanitize context data to be JSON friendly
+        const ctx = report.data;
+        const sanitizedData = sanitizeContext(report.data);
+        const mappedData = replaceRedactedTokens(sanitizedData);
+        try {
+            await externalizeVerifyOutput({
+                auditDir,
+                timestamp,
+                sanitizedContext: mappedData,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            getLogger().warn(`[Audit] Failed to externalize verify output: ${msg}`);
+            recordAuditEvent('audit.blob.externalize.failed', { target: 'verifyResult.output', error: msg.slice(0, 500) }, { source: 'saveAudit', severity: 'low', scope: 'session', phase: 'AUDIT' });
+        }
+        try {
+            await externalizeToolAuditTextFields({
+                auditDir,
+                timestamp,
+                sanitizedContext: mappedData,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            getLogger().warn(`[Audit] Failed to externalize tool audit summaries: ${msg}`);
+            recordAuditEvent('audit.blob.externalize.failed', { target: 'toolAuditLogs.*', error: msg.slice(0, 500) }, { source: 'saveAudit', severity: 'low', scope: 'session', phase: 'AUDIT' });
+        }
+        const errorInfo = report.error;
+        const errorMeta = report.error && report.error instanceof Error
+            ? {
+                name: report.error.name,
+                message: report.error.message,
+                stack: report.error.stack,
+                code: report.error instanceof SalmonError
+                    ? report.error.code
+                    : errorInfo?.code || errorInfo?.llmCode,
+            }
+            : report.error
+                ? { name: 'UnknownError', message: String(report.error), stack: undefined }
+                : undefined;
+        const mappedErrorMeta = replaceRedactedTokens(errorMeta);
+        const errorDisplay = mapErrorForDisplay({
+            message: mappedErrorMeta?.message,
+            code: mappedErrorMeta?.code,
+        });
+        const toolAuditLogs = ctx?.toolAuditLogger?.getLogs?.() || [];
+        const authorizationIndex = toolAuditLogs
+            .filter((entry) => entry.eventType === 'authorization')
+            .reduce((acc, entry) => {
+            acc[entry.callId] = {
+                outcome: entry.authOutcome,
+                reason: entry.authReason,
+                source: entry.authSource,
+                riskLevel: entry.authRiskLevel,
+                sideEffects: entry.authSideEffects,
+                ttlMs: entry.authTtlMs,
+            };
+            return acc;
+        }, {});
+        const trail = getAuditTrail();
+        const eventsFilename = filename.replace(/\.json$/, '.events.jsonl');
+        const eventsPath = path.join(auditDir, eventsFilename);
+        const eventsPayload = trail.length === 0 ? '' : `${trail.map((event) => JSON.stringify(event)).join('\n')}\n`;
+        const auditData = {
+            meta: {
+                timestamp: new Date().toISOString(),
+                duration: report.duration,
+                success: report.success,
+                lastStep: report.lastStep,
+                // Keep a stable, human-friendly message for backwards compatibility.
+                error: errorDisplay.message,
+                errorName: mappedErrorMeta?.name,
+                errorCode: mappedErrorMeta?.code,
+                errorStack: mappedErrorMeta?.stack,
+                errorRedacted: errorDisplay.redacted || undefined,
+            },
+            traces: report.traces,
+            context: {
+                ...mappedData,
+                eventsRef: {
+                    path: eventsFilename,
+                    count: trail.length,
+                    firstTs: trail[0]?.timestamp,
+                    lastTs: trail[trail.length - 1]?.timestamp,
+                },
+            },
+            authorizationIndex,
+            environment: {
+                cwd: process.cwd(),
+                nodeVersion: process.version,
+            },
+        };
+        await fs.writeFile(eventsPath, eventsPayload, 'utf8');
+        await fs.writeFile(`${auditDir}/${filename}`, JSON.stringify(auditData, null, 2));
+        getLogger().debug(`[Audit] Saved structured audit log to ${filename}`);
+        return `${auditDir}/${filename}`;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        getLogger().error(`[Audit] Failed to save audit log: ${msg}`);
+        return undefined;
+    }
+}
+function buildVerifyOutputPreview(output, typeHint) {
+    if (output.length <= LIMITS.auditVerifyOutputMaxInlineChars)
+        return output;
+    // Use semantic truncation for better output preservation
+    const result = truncateOutput(output, LIMITS.auditVerifyOutputMaxInlineChars, typeHint);
+    return result.content;
+}
+function buildToolSummaryPreview(output, typeHint) {
+    if (output.length <= LIMITS.auditToolSummaryMaxInlineChars)
+        return output;
+    // Use semantic truncation for better output preservation
+    const result = truncateOutput(output, LIMITS.auditToolSummaryMaxInlineChars, typeHint);
+    return result.content;
+}
+function sha256Hex(text) {
+    return createHash('sha256').update(text, 'utf8').digest('hex');
+}
+async function writeBlobBestEffort(args) {
+    const { blobDir, blobName, content, auditTarget } = args;
+    const sha256 = sha256Hex(content);
+    const blobPath = path.join(blobDir, blobName);
+    try {
+        await fs.mkdir(blobDir, { recursive: true });
+        await fs.writeFile(blobPath, content, 'utf8');
+        return { path: path.join('blobs', blobName), sha256, chars: content.length };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        getLogger().warn(`[Audit] Failed to write blob ${blobName}: ${msg}`);
+        recordAuditEvent('audit.blob.write.failed', {
+            target: auditTarget,
+            blobName,
+            sha256,
+            chars: content.length,
+            error: msg.slice(0, 500),
+        }, { source: 'saveAudit', severity: 'low', scope: 'session', phase: 'AUDIT' });
+        return undefined;
+    }
+}
+async function externalizeVerifyOutput(args) {
+    const { auditDir, timestamp, sanitizedContext } = args;
+    if (!sanitizedContext)
+        return;
+    const verifyResult = sanitizedContext.verifyResult;
+    if (!verifyResult || typeof verifyResult !== 'object')
+        return;
+    const output = verifyResult.output;
+    if (typeof output !== 'string')
+        return;
+    if (output.length <= LIMITS.auditVerifyOutputMaxInlineChars)
+        return;
+    const blobDir = path.join(auditDir, 'blobs');
+    verifyResult.output = buildVerifyOutputPreview(output);
+    verifyResult.outputTruncated = true;
+    const sha256 = sha256Hex(output);
+    const blobName = `verify-output-${timestamp}-${sha256.slice(0, 8)}.log`;
+    const blob = await writeBlobBestEffort({
+        blobDir,
+        blobName,
+        content: output,
+        auditTarget: 'verifyResult.output',
+    });
+    if (blob) {
+        verifyResult.outputBlob = blob;
+    }
+}
+async function externalizeToolAuditTextFields(args) {
+    const { auditDir, timestamp, sanitizedContext } = args;
+    if (!sanitizedContext)
+        return;
+    const toolAuditLogs = sanitizedContext.toolAuditLogs;
+    if (!Array.isArray(toolAuditLogs) || toolAuditLogs.length === 0)
+        return;
+    const blobDir = path.join(auditDir, 'blobs');
+    for (const entry of toolAuditLogs) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        await externalizeToolAuditTextField({
+            blobDir,
+            timestamp,
+            entry,
+            field: 'inputSummary',
+            blobPrefix: 'tool-inputSummary',
+            auditTarget: 'toolAuditLogs.inputSummary',
+        });
+        await externalizeToolAuditTextField({
+            blobDir,
+            timestamp,
+            entry,
+            field: 'outputSummary',
+            blobPrefix: 'tool-outputSummary',
+            auditTarget: 'toolAuditLogs.outputSummary',
+        });
+    }
+}
+async function externalizeToolAuditTextField(args) {
+    const { blobDir, timestamp, entry, field, blobPrefix, auditTarget } = args;
+    const raw = entry[field];
+    if (typeof raw !== 'string')
+        return;
+    if (raw.length <= LIMITS.auditToolSummaryMaxInlineChars)
+        return;
+    entry[field] = buildToolSummaryPreview(raw);
+    entry[`${field}Truncated`] = true;
+    const sha256 = sha256Hex(raw);
+    const blobName = `${blobPrefix}-${timestamp}-${sha256.slice(0, 8)}.log`;
+    const blob = await writeBlobBestEffort({ blobDir, blobName, content: raw, auditTarget });
+    if (blob) {
+        entry[`${field}Blob`] = blob;
+    }
+}
+function sanitizeContext(ctx) {
+    if (!ctx || typeof ctx !== 'object')
+        return null;
+    const safe = {};
+    const typed = ctx;
+    // Extract key fields that are serializable
+    if (typed.preflightResult)
+        safe.preflightResult = typed.preflightResult;
+    if (typed.plan)
+        safe.plan = typed.plan; // plan object usually serializable
+    if (typed.planRuntime)
+        safe.planRuntime = typed.planRuntime;
+    if (typed.diffMeta)
+        safe.diffMeta = typed.diffMeta;
+    if (typed.isValid !== undefined)
+        safe.isValid = typed.isValid;
+    if (typed.astValid !== undefined)
+        safe.astValid = typed.astValid;
+    if (typed.astError)
+        safe.astError = typed.astError;
+    if (typed.applyResult) {
+        safe.applyResult = {
+            success: typed.applyResult.success,
+            successCount: typed.applyResult.successCount,
+            totalFiles: typed.applyResult.totalFiles,
+            // decisions are already JSON objects
+            decisions: typed.applyResult.decisions,
+            // results might contain errors
+            results: typed.applyResult.results?.map((r) => ({
+                success: r.success,
+                actionTaken: r.actionTaken,
+                error: r.error,
+            })),
+        };
+    }
+    if (typed.verifyResult)
+        safe.verifyResult = typed.verifyResult;
+    if (typed.verifyArtifact)
+        safe.verifyArtifact = typed.verifyArtifact;
+    if (typed.rolledBack !== undefined)
+        safe.rolledBack = typed.rolledBack;
+    if (typed.shrunk !== undefined)
+        safe.shrunk = typed.shrunk;
+    if (typed.applyBackResult)
+        safe.applyBackResult = typed.applyBackResult;
+    if (typed.toolCallingAudit && Array.isArray(typed.toolCallingAudit)) {
+        safe.toolCallingAudit = typed.toolCallingAudit.map((entry) => {
+            if (!entry || typeof entry !== 'object')
+                return entry;
+            const typedEntry = entry;
+            const keepArgsPreview = typedEntry.toolResultErrorCode === 'INVALID_INPUT';
+            if (keepArgsPreview)
+                return entry;
+            const { rawArgsPreview: _rawArgsPreview, parsedArgsPreview: _parsedArgsPreview, toolResultErrorMessage: _toolResultErrorMessage, ...rest } = typedEntry;
+            return rest;
+        });
+    }
+    if (typed.toolAuditLogger?.getLogs) {
+        safe.toolAuditLogs = typed.toolAuditLogger.getLogs();
+    }
+    return safe;
+}
+//# sourceMappingURL=audit.js.map

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

@@ -0,0 +1,74 @@
+import { resolveConfig } from '../../config/resolve.js';
+import { applyBudgetAdjustment } from '../../context/budget/integration.js';
+import { ContextBuilder } from '../../context/builder.js';
+import { setChurnRankingPolicy } from '../../context/targeting/churn-policy.js';
+import { recordAuditEvent } from '../../observability/audit-trail.js';
+import { CheckpointManager } from '../../strata/checkpoint/manager.js';
+export const buildContext = async (ctx) => {
+    if (ctx.initialContext) {
+        ctx.emit({
+            type: 'log',
+            level: 'debug',
+            message: 'Using existing context (retry mode)',
+            timestamp: new Date(),
+        });
+        return {
+            ...ctx,
+            context: ctx.initialContext,
+        };
+    }
+    // In worktree strategy, build context from the shadow workspace to ensure the patch is generated
+    // against the exact state that will be modified (prevents "patch does not apply" due to drift).
+    const contextOptions = ctx.workspace?.strategy === 'worktree'
+        ? {
+            ...ctx.options,
+            repoPath: ctx.workspace.workPath,
+            snapshotHash: ctx.shadowInitialRef,
+            checkpointManager: new CheckpointManager(),
+        }
+        : ctx.options;
+    // Apply dynamic budget adjustment if enabled and on retry
+    const config = await resolveConfig({ repoRoot: ctx.options.repoPath });
+    setChurnRankingPolicy({
+        primaryBoost: config.raw?.context?.churn?.weight?.primary,
+        rerankWeight: config.raw?.context?.churn?.weight?.rerank,
+        tieBreakWeight: config.raw?.context?.churn?.weight?.tiebreak,
+    });
+    if (config.context.dynamicBudget.enabled && (ctx.attempt ?? 0) > 1) {
+        const currentBudget = contextOptions.budgetChars ?? 30000;
+        const adjustment = applyBudgetAdjustment(currentBudget);
+        if (adjustment) {
+            contextOptions.budgetChars = adjustment.newBudget;
+            ctx.emit({
+                type: 'log',
+                level: 'info',
+                message: `Budget adjusted: ${currentBudget} → ${adjustment.newBudget} (${adjustment.reason})`,
+                timestamp: new Date(),
+            });
+            recordAuditEvent('context.budget.adjusted', {
+                oldBudget: currentBudget,
+                newBudget: adjustment.newBudget,
+                reason: adjustment.reason,
+                attempt: ctx.attempt,
+            }, {
+                source: 'context',
+                severity: 'low',
+                scope: 'session',
+                phase: 'CONTEXT',
+            });
+        }
+    }
+    const contextResult = await ContextBuilder.build(contextOptions);
+    ctx.emit({
+        type: 'log',
+        level: 'debug',
+        message: `Context built: ${contextResult.context.rgSnippets.length} snippets, ${contextResult.context.gitDiff ? 'with' : 'without'} git diff`,
+        timestamp: new Date(),
+    });
+    return {
+        ...ctx,
+        context: contextResult.context,
+        contextResult,
+    };
+};
+//# sourceMappingURL=context.js.map

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

@@ -0,0 +1,6 @@
+import { displayReport } from './display-report.js';
+export async function displayAnswer(ctx) {
+    await displayReport(ctx);
+    return ctx;
+}
+//# sourceMappingURL=display-answer.js.map