salmon-loop 0.2.3

package/dist/core/grizzco/engine/transaction/attempt-failure.js

@@ -0,0 +1,242 @@
+import { text } from '../../../../locales/index.js';
+import { buildFailureGuidance } from '../../../failure/diagnostics.js';
+import { sanitizeError } from '../../../llm/errors.js';
+import { mapErrorForDisplay } from '../../../observability/error-mapping.js';
+import { EXECUTION_PHASES } from '../../../types/runtime.js';
+import { classifyError, isRetryable } from '../../../verification/runner.js';
+const RETRYABLE_PHASES = new Set([
+    'CONTEXT',
+    'EXPLORE',
+    'PLAN',
+    'PATCH',
+    'VALIDATE',
+    'AST_VALIDATE',
+    'APPLY',
+    'VERIFY',
+    'SHRINK',
+]);
+const NON_RETRYABLE_PERMISSION_CODES = new Set([
+    'PERMISSION_REQUIRED_CONTEXT_CACHE_OUTSIDE_ROOT',
+    'PERMISSION_DENIED_CONTEXT_CACHE_OUTSIDE_ROOT',
+]);
+function inferFailurePhase(flowReport) {
+    const failedTrace = [...flowReport.traces].reverse().find((trace) => Boolean(trace.error));
+    if (failedTrace && EXECUTION_PHASES.includes(failedTrace.name)) {
+        return failedTrace.name;
+    }
+    return 'VERIFY';
+}
+function extractErrorCode(error) {
+    if (typeof error === 'object' && error !== null) {
+        const err = error;
+        // Prioritize code (from SalmonError) for better specificity
+        // SalmonError stores the error code in the 'code' property
+        return err.llmCode ?? err.code ?? err.errorCode ?? err.name;
+    }
+    return undefined;
+}
+function extractErrorCodeFromTraces(flowReport) {
+    const traceWithError = [...flowReport.traces].reverse().find((trace) => Boolean(trace.error));
+    if (!traceWithError)
+        return undefined;
+    return extractErrorCode(traceWithError.error);
+}
+function sanitizeReason(value) {
+    const sanitized = sanitizeError(value) || text.loop.loopExecutionFailed;
+    return mapErrorForDisplay({ message: sanitized }).message;
+}
+function extractInputRequired(error) {
+    if (!error || typeof error !== 'object')
+        return undefined;
+    const value = 'inputRequired' in error ? error.inputRequired : error;
+    if (!value || typeof value !== 'object')
+        return undefined;
+    if (typeof value.prompt !== 'string' || typeof value.type !== 'string')
+        return undefined;
+    return value;
+}
+function extractInterrupt(error) {
+    if (!error || typeof error !== 'object')
+        return undefined;
+    const value = error.interrupt;
+    if (!value || typeof value !== 'object')
+        return undefined;
+    if (typeof value.type !== 'string')
+        return undefined;
+    return value;
+}
+export function resolveAttemptFailure(params) {
+    const { flowReport, context, flowMode } = params;
+    const interrupt = extractInterrupt(flowReport.error);
+    const interruptCode = extractErrorCode(flowReport.error);
+    if (interruptCode === 'INTERRUPT_REQUIRED' && interrupt?.type === 'awaiting_input') {
+        const inputRequired = extractInputRequired(interrupt.data?.inputRequired);
+        if (!inputRequired)
+            return undefined;
+        const failurePhase = inferFailurePhase(flowReport);
+        const reason = interrupt.prompt || inputRequired.prompt || text.tools.askUserPromptDefault;
+        return {
+            reason,
+            reasonCode: 'AWAITING_INPUT',
+            failurePhase,
+            retryable: false,
+            errorCode: 'INTERRUPT_REQUIRED',
+            diagnosticCode: 'INTERRUPT_REQUIRED',
+            safeHint: reason,
+            remediationSteps: [],
+            inputRequired,
+        };
+    }
+    const verifyOk = flowMode === 'review' || flowMode === 'research' || flowMode === 'answer'
+        ? true
+        : context?.verifyResult?.ok !== false;
+    const applyBackFailed = flowMode !== 'review' &&
+        flowMode !== 'research' &&
+        flowMode !== 'answer' &&
+        context?.applyBackResult?.success === false &&
+        !context.applyBackResult.skipped;
+    const environmentMode = context?.options?.environmentMode;
+    if (applyBackFailed) {
+        const fallbackReason = context.applyBackResult?.safeMessage ||
+            context.applyBackResult?.error ||
+            text.loop.applyBackFailed;
+        const guidance = buildFailureGuidance({
+            reasonCode: 'APPLY_BACK_FAILED',
+            failurePhase: 'APPLY_BACK',
+            errorCode: context.applyBackResult?.errorCode || 'APPLY_BACK_FAILED',
+            environmentMode,
+            fallbackReason,
+        });
+        return {
+            reason: guidance.safeHint,
+            reasonCode: 'APPLY_BACK_FAILED',
+            failurePhase: 'APPLY_BACK',
+            retryable: false,
+            errorCode: context.applyBackResult?.errorCode || 'APPLY_BACK_FAILED',
+            diagnosticCode: guidance.diagnosticCode,
+            safeHint: guidance.safeHint,
+            remediationSteps: guidance.remediationSteps,
+        };
+    }
+    if (flowReport.success && verifyOk) {
+        return undefined;
+    }
+    const errorCode = extractErrorCode(flowReport.error) ?? extractErrorCodeFromTraces(flowReport);
+    if (errorCode === 'PREFLIGHT_NOT_GIT') {
+        const fallbackReason = sanitizeReason(flowReport.error);
+        const guidance = buildFailureGuidance({
+            reasonCode: 'PREFLIGHT_NOT_GIT',
+            failurePhase: 'PREFLIGHT',
+            errorCode,
+            environmentMode,
+            fallbackReason,
+        });
+        return {
+            reason: guidance.safeHint,
+            reasonCode: 'PREFLIGHT_NOT_GIT',
+            failurePhase: 'PREFLIGHT',
+            retryable: false,
+            errorCode,
+            diagnosticCode: guidance.diagnosticCode,
+            safeHint: guidance.safeHint,
+            remediationSteps: guidance.remediationSteps,
+        };
+    }
+    if (errorCode === 'PREFLIGHT_DIRTY') {
+        const fallbackReason = sanitizeReason(flowReport.error);
+        const guidance = buildFailureGuidance({
+            reasonCode: 'PREFLIGHT_DIRTY',
+            failurePhase: 'PREFLIGHT',
+            errorCode,
+            environmentMode,
+            fallbackReason,
+        });
+        return {
+            reason: guidance.safeHint,
+            reasonCode: 'PREFLIGHT_DIRTY',
+            failurePhase: 'PREFLIGHT',
+            retryable: false,
+            errorCode,
+            diagnosticCode: guidance.diagnosticCode,
+            safeHint: guidance.safeHint,
+            remediationSteps: guidance.remediationSteps,
+        };
+    }
+    if (errorCode && NON_RETRYABLE_PERMISSION_CODES.has(errorCode)) {
+        const fallbackReason = sanitizeReason(flowReport.error);
+        const guidance = buildFailureGuidance({
+            reasonCode: 'LOOP_FAILED',
+            failurePhase: 'CONTEXT',
+            errorCode,
+            environmentMode,
+            fallbackReason,
+        });
+        return {
+            reason: guidance.safeHint,
+            reasonCode: 'LOOP_FAILED',
+            failurePhase: 'CONTEXT',
+            retryable: false,
+            errorCode,
+            diagnosticCode: guidance.diagnosticCode,
+            safeHint: guidance.safeHint,
+            remediationSteps: guidance.remediationSteps,
+        };
+    }
+    if (flowMode !== 'review' && context?.verifyResult?.ok === false) {
+        const verifyOutput = context.verifyResult.output || text.loop.loopExecutionFailed;
+        const errorType = classifyError(verifyOutput);
+        const fallbackReason = sanitizeReason(context.lastError || verifyOutput);
+        const guidance = buildFailureGuidance({
+            reasonCode: 'VERIFY_FAILED',
+            failurePhase: 'VERIFY',
+            errorCode: String(errorType),
+            verifyOutput,
+            environmentMode,
+            fallbackReason,
+        });
+        return {
+            reason: guidance.safeHint,
+            reasonCode: 'VERIFY_FAILED',
+            failurePhase: 'VERIFY',
+            retryable: isRetryable(errorType),
+            errorCode: String(errorType),
+            diagnosticCode: guidance.diagnosticCode,
+            safeHint: guidance.safeHint,
+            remediationSteps: guidance.remediationSteps,
+        };
+    }
+    const failurePhase = inferFailurePhase(flowReport);
+    const fallbackReason = sanitizeReason(context?.lastError || flowReport.error);
+    const guidance = buildFailureGuidance({
+        reasonCode: failurePhase === 'ROLLBACK' ? 'ROLLBACK_FAILED' : 'LOOP_FAILED',
+        failurePhase,
+        errorCode,
+        environmentMode,
+        fallbackReason,
+    });
+    const hasStructuredFailureTrace = flowReport.traces.some((trace) => Boolean(trace.error));
+    const retryableByPhase = hasStructuredFailureTrace && RETRYABLE_PHASES.has(failurePhase);
+    if (failurePhase === 'ROLLBACK') {
+        return {
+            reason: guidance.safeHint,
+            reasonCode: 'ROLLBACK_FAILED',
+            failurePhase,
+            retryable: false,
+            errorCode,
+            diagnosticCode: guidance.diagnosticCode,
+            safeHint: guidance.safeHint,
+            remediationSteps: guidance.remediationSteps,
+        };
+    }
+    return {
+        reason: guidance.safeHint,
+        reasonCode: 'LOOP_FAILED',
+        failurePhase,
+        retryable: retryableByPhase,
+        errorCode,
+        diagnosticCode: guidance.diagnosticCode,
+        safeHint: guidance.safeHint,
+        remediationSteps: guidance.remediationSteps,
+    };
+}
+//# sourceMappingURL=attempt-failure.js.map

package/dist/core/grizzco/engine/transaction/authorization-summary.js

@@ -0,0 +1,44 @@
+export function buildAuthorizationSummary(logs) {
+    if (!logs || logs.length === 0)
+        return null;
+    const summary = {
+        auto: 0,
+        allowlist: 0,
+        user: 0,
+        cache: 0,
+        cli: 0,
+        hook: 0,
+    };
+    let hasEntries = false;
+    for (const entry of logs) {
+        if (!entry || entry.eventType !== 'authorization')
+            continue;
+        const source = entry.authSource;
+        if (source === 'auto') {
+            summary.auto += 1;
+            hasEntries = true;
+        }
+        else if (source === 'allowlist') {
+            summary.allowlist += 1;
+            hasEntries = true;
+        }
+        else if (source === 'user') {
+            summary.user += 1;
+            hasEntries = true;
+        }
+        else if (source === 'cache') {
+            summary.cache += 1;
+            hasEntries = true;
+        }
+        else if (source === 'cli') {
+            summary.cli += 1;
+            hasEntries = true;
+        }
+        else if (source === 'hook') {
+            summary.hook += 1;
+            hasEntries = true;
+        }
+    }
+    return hasEntries ? summary : null;
+}
+//# sourceMappingURL=authorization-summary.js.map

package/dist/core/grizzco/engine/transaction/index.js

@@ -0,0 +1,3 @@
+export { buildFlowTransactionRunner } from './runner-builder.js';
+export { runFlowSession } from './session.js';
+//# sourceMappingURL=index.js.map

package/dist/core/grizzco/engine/transaction/report-mapper.js

@@ -0,0 +1,50 @@
+export function mapSuccessReport(params) {
+    const { attempt, flowReport, history, authorizationSummary, lastContext, lastVerifyArtifact, lastErrorCode, } = params;
+    return {
+        success: true,
+        attempts: attempt,
+        flowReport,
+        history: [...history],
+        authorizationSummary,
+        lastErrorCode,
+        retryExhausted: false,
+        lastContext,
+        lastVerifyArtifact,
+    };
+}
+export function mapTerminalFailureReport(params) {
+    const { attempt, flowReport, history, authorizationSummary, lastContext, lastVerifyArtifact, failure, lastErrorCode, } = params;
+    return {
+        success: false,
+        attempts: attempt,
+        flowReport,
+        history: [...history],
+        authorizationSummary,
+        lastErrorCode,
+        retryExhausted: false,
+        lastContext,
+        lastVerifyArtifact,
+        terminalReason: failure.reason,
+        terminalReasonCode: failure.reasonCode,
+        terminalFailurePhase: failure.failurePhase,
+        terminalDiagnosticCode: failure.diagnosticCode,
+        terminalSafeHint: failure.safeHint,
+        terminalRemediationSteps: [...failure.remediationSteps],
+        terminalInputRequired: failure.inputRequired,
+    };
+}
+export function mapRetryExhaustedReport(params) {
+    const { attempts, flowReport, history, authorizationSummary, lastErrorCode, lastContext, lastVerifyArtifact, } = params;
+    return {
+        success: false,
+        attempts,
+        flowReport,
+        history: [...history],
+        authorizationSummary,
+        lastErrorCode,
+        retryExhausted: true,
+        lastContext,
+        lastVerifyArtifact,
+    };
+}
+//# sourceMappingURL=report-mapper.js.map

package/dist/core/grizzco/engine/transaction/retry-policy.js

@@ -0,0 +1,19 @@
+import { LIMITS } from '../../../config/limits.js';
+export function evaluateRetryPolicy(params) {
+    const { retries, failure, maxRetries = LIMITS.maxRetries } = params;
+    if (!failure.retryable) {
+        return {
+            retries,
+            shouldRetry: false,
+            retryExhausted: false,
+        };
+    }
+    const nextRetries = retries + 1;
+    const retryExhausted = nextRetries > maxRetries;
+    return {
+        retries: nextRetries,
+        shouldRetry: !retryExhausted,
+        retryExhausted,
+    };
+}
+//# sourceMappingURL=retry-policy.js.map

package/dist/core/grizzco/engine/transaction/runner-builder.js

@@ -0,0 +1,45 @@
+import { GitAdapter } from '../../../adapters/git/git-adapter.js';
+import { FileStateResolver } from '../../../strata/layers/file-state-resolver.js';
+import { WorkspaceSynchronizer } from '../../../strata/runtime/synchronizer.js';
+import { FlowTransactionRunner } from './transaction-runner.js';
+function requireWorkspace(workspace) {
+    if (!workspace) {
+        throw new Error('Runtime environment missing workspace after setup');
+    }
+    return workspace;
+}
+function resolveShadowInitialRef(params) {
+    return params.initialSnapshotHash || params.optionsShadowInitialRef || '';
+}
+export function buildFlowTransactionRunner(params) {
+    const { env, flowMode, fsAdapter, activeRepoPath, planRuntime, options, emitFlow, now, telemetry, shadowTaskId, } = params;
+    const checkpointManager = env.checkpointManager;
+    const workspace = requireWorkspace(env.workspace);
+    const shadowInitialRef = resolveShadowInitialRef({
+        initialSnapshotHash: env.initialSnapshotHash,
+        optionsShadowInitialRef: options.shadowInitialRef,
+    });
+    const synchronizer = new WorkspaceSynchronizer(checkpointManager);
+    const git = new GitAdapter(activeRepoPath);
+    const resolver = new FileStateResolver(git, activeRepoPath);
+    return new FlowTransactionRunner({
+        options,
+        flowMode,
+        emit: emitFlow,
+        now,
+        fsAdapter,
+        env: {
+            workspace,
+            shadowInitialRef,
+            initialSnapshotHash: env.initialSnapshotHash,
+            checkpointRef: env.checkpointRef,
+            activeRepoPath,
+        },
+        synchronizer,
+        shadowTaskId,
+        planRuntime,
+        fileStateResolver: resolver,
+        telemetry,
+    });
+}
+//# sourceMappingURL=runner-builder.js.map

package/dist/core/grizzco/engine/transaction/session.js

@@ -0,0 +1,58 @@
+import { sanitizeError } from '../../../llm/errors.js';
+import { extractErrorCode } from '../../../observability/error-envelope.js';
+import { Phase } from '../../../types/runtime.js';
+import { buildLoopFailureResult, buildLoopResultFromTransaction, } from '../outcome/loop-result-mapper.js';
+import { FlowTransactionCancelledError } from './transaction-runner.js';
+export async function runFlowSession(params) {
+    const { runner, flowMode, options, telemetry, now, emitSanitized } = params;
+    let auditPath = params.auditPath;
+    try {
+        const executionReport = await runner.execute();
+        auditPath = executionReport.flowReport.auditPath ?? auditPath;
+        return {
+            result: buildLoopResultFromTransaction({
+                executionReport,
+                flowMode,
+                options,
+                telemetry,
+                auditPath,
+            }),
+            auditPath,
+        };
+    }
+    catch (error) {
+        if (error instanceof FlowTransactionCancelledError) {
+            const message = error.message;
+            telemetry.recordLog('error', message, false);
+            emitSanitized({ type: 'log', level: 'error', message, timestamp: now() });
+            return {
+                result: buildLoopFailureResult({
+                    message,
+                    flowMode,
+                    telemetry,
+                    auditPath,
+                    reasonCode: 'LOOP_CRASH',
+                }),
+                auditPath,
+            };
+        }
+        const message = sanitizeError(error);
+        const extractedCode = extractErrorCode(error);
+        const errorCode = extractedCode && extractedCode !== 'Error' ? extractedCode : undefined;
+        telemetry.recordLog('error', message, false);
+        emitSanitized({ type: 'log', level: 'error', message, timestamp: now() });
+        return {
+            result: buildLoopFailureResult({
+                message,
+                flowMode,
+                telemetry,
+                auditPath,
+                reasonCode: 'LOOP_CRASH',
+                failurePhase: Phase.VERIFY,
+                errorCode,
+            }),
+            auditPath,
+        };
+    }
+}
+//# sourceMappingURL=session.js.map

package/dist/core/grizzco/engine/transaction/transaction-runner.js

@@ -0,0 +1,193 @@
+import { recordAuditEvent } from '../../../observability/audit-trail.js';
+import { ReflectionEngine } from '../../../reflection/engine.js';
+import { executeSalmonLoopFlow } from '../../flows/SalmonLoopFlow.js';
+import { resolveAttemptFailure } from './attempt-failure.js';
+import { buildAuthorizationSummary } from './authorization-summary.js';
+import { mapRetryExhaustedReport, mapSuccessReport, mapTerminalFailureReport, } from './report-mapper.js';
+import { evaluateRetryPolicy } from './retry-policy.js';
+export class FlowTransactionCancelledError extends Error {
+    constructor() {
+        super('Operation cancelled by user');
+        this.name = 'FlowTransactionCancelledError';
+    }
+}
+export class FlowTransactionRunner {
+    params;
+    historyEntries = [];
+    currentContext;
+    currentLastError;
+    authorizationSummary = null;
+    lastContext;
+    lastVerifyArtifact;
+    constructor(params) {
+        this.params = params;
+    }
+    isShrinkCtx(ctx) {
+        return Boolean(ctx && 'verifyResult' in ctx);
+    }
+    async execute() {
+        let retries = 0;
+        let lastReport;
+        while (true) {
+            if (this.params.options.signal?.aborted) {
+                throw new FlowTransactionCancelledError();
+            }
+            const attempt = retries + 1;
+            recordAuditEvent('loop.attempt.start', { attempt, flowMode: this.params.flowMode }, { phase: 'PREFLIGHT', scope: 'session' });
+            const result = await executeSalmonLoopFlow({
+                workspace: this.params.env.workspace,
+                options: this.params.options,
+                mode: this.params.flowMode,
+                fs: this.params.fsAdapter,
+                emit: this.params.emit,
+                fileStateResolver: this.params.fileStateResolver,
+                planRuntime: this.params.planRuntime,
+                shadowInitialRef: this.params.env.shadowInitialRef,
+                attempt,
+                initialContext: this.currentContext,
+                lastError: this.currentLastError,
+                applyBackRuntime: {
+                    activeRepoPath: this.params.env.activeRepoPath,
+                    shadowTaskId: this.params.shadowTaskId,
+                    checkpointRef: this.params.env.checkpointRef,
+                    initialSnapshotHash: this.params.env.initialSnapshotHash,
+                    synchronizer: this.params.synchronizer,
+                },
+            });
+            lastReport = result;
+            const terminalCtx = result.data;
+            if (terminalCtx) {
+                this.lastContext = terminalCtx;
+            }
+            const shrinkCtx = this.isShrinkCtx(terminalCtx) ? terminalCtx : undefined;
+            if (shrinkCtx?.verifyArtifact) {
+                this.lastVerifyArtifact = shrinkCtx.verifyArtifact;
+            }
+            const attemptFailure = resolveAttemptFailure({
+                flowReport: result,
+                context: shrinkCtx,
+                flowMode: this.params.flowMode,
+            });
+            const entry = {
+                attempt,
+                plan: shrinkCtx?.plan ?? null,
+                patch: shrinkCtx?.diff ?? null,
+                error: attemptFailure?.reason,
+                contextSummary: shrinkCtx?.context
+                    ? `Snippets: ${shrinkCtx.context.rgSnippets.length}`
+                    : 'No context',
+            };
+            this.historyEntries.push(entry);
+            this.params.telemetry.addHistory(entry);
+            this.authorizationSummary = buildAuthorizationSummary(shrinkCtx?.toolAuditLogger?.getLogs?.());
+            if (!attemptFailure) {
+                const successPhase = this.params.flowMode === 'review' || this.params.flowMode === 'research'
+                    ? 'SHRINK'
+                    : 'APPLY_BACK';
+                recordAuditEvent('loop.attempt.success', { attempt, flowMode: this.params.flowMode }, { phase: successPhase, severity: 'low', scope: 'session' });
+                // Reflection Mechanism: trigger when multiple attempts were needed
+                if (attempt > 1 && this.params.options.llm) {
+                    const reflectionEngine = new ReflectionEngine(this.params.options.llm);
+                    const reflectionInput = {
+                        instruction: this.params.options.instruction,
+                        history: this.historyEntries,
+                        success: true,
+                        metadata: shrinkCtx?.context?.projectMetadata,
+                        finalPlan: shrinkCtx?.plan,
+                        finalPatch: shrinkCtx?.diff,
+                    };
+                    reflectionEngine
+                        .reflect(reflectionInput, this.params.options.repoPath)
+                        .catch((e) => recordAuditEvent('reflection.error', { error: String(e) }, { severity: 'medium' }));
+                }
+                return mapSuccessReport({
+                    attempt,
+                    flowReport: result,
+                    history: this.historyEntries,
+                    authorizationSummary: this.authorizationSummary,
+                    lastErrorCode: this.extractErrorCode(result.error),
+                    lastContext: shrinkCtx,
+                    lastVerifyArtifact: this.lastVerifyArtifact,
+                });
+            }
+            if (attemptFailure.reasonCode === 'AWAITING_INPUT') {
+                const inputRequired = attemptFailure.inputRequired;
+                this.params.emit({
+                    type: 'task.awaiting_input',
+                    reason: inputRequired?.reason ?? 'clarification',
+                    prompt: inputRequired?.prompt ?? attemptFailure.reason,
+                    inputRequired,
+                    timestamp: this.params.now(),
+                });
+            }
+            recordAuditEvent('loop.attempt.failure', {
+                attempt,
+                flowMode: this.params.flowMode,
+                reason: attemptFailure.reason,
+                reasonCode: attemptFailure.reasonCode,
+                diagnosticCode: attemptFailure.diagnosticCode,
+                safeHint: attemptFailure.safeHint,
+                remediationSteps: attemptFailure.remediationSteps,
+                failurePhase: attemptFailure.failurePhase,
+                retryable: attemptFailure.retryable,
+                errorCode: attemptFailure.errorCode,
+                lastStep: result.lastStep,
+            }, {
+                phase: attemptFailure.failurePhase,
+                severity: attemptFailure.failurePhase === 'APPLY_BACK' ? 'high' : 'medium',
+                scope: 'session',
+            });
+            const retryDecision = evaluateRetryPolicy({
+                retries,
+                failure: attemptFailure,
+            });
+            retries = retryDecision.retries;
+            if (!retryDecision.shouldRetry) {
+                if (retryDecision.retryExhausted) {
+                    break;
+                }
+                return mapTerminalFailureReport({
+                    attempt,
+                    flowReport: result,
+                    history: this.historyEntries,
+                    authorizationSummary: this.authorizationSummary,
+                    lastErrorCode: attemptFailure.errorCode ?? this.extractErrorCode(result.error),
+                    lastContext: shrinkCtx,
+                    lastVerifyArtifact: this.lastVerifyArtifact,
+                    failure: attemptFailure,
+                });
+            }
+            this.currentContext = shrinkCtx?.context;
+            this.currentLastError = attemptFailure.reason;
+            this.params.emit({
+                type: 'retry',
+                fromAttempt: attempt,
+                toAttempt: attempt + 1,
+                reason: attemptFailure.reason,
+                failedFiles: [],
+                timestamp: this.params.now(),
+            });
+        }
+        if (!lastReport) {
+            throw new Error('SalmonLoop execution terminated without a FlowReport');
+        }
+        return mapRetryExhaustedReport({
+            attempts: retries,
+            flowReport: lastReport,
+            history: this.historyEntries,
+            authorizationSummary: this.authorizationSummary,
+            lastErrorCode: this.extractErrorCode(lastReport.error),
+            lastContext: this.lastContext,
+            lastVerifyArtifact: this.lastVerifyArtifact,
+        });
+    }
+    extractErrorCode(error) {
+        if (typeof error === 'object' && error !== null) {
+            return (error.llmCode ??
+                error.code ??
+                error.name);
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=transaction-runner.js.map

package/dist/core/grizzco/engine/transaction/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map