salmon-loop 0.2.13 → 0.2.16

package/dist/core/grizzco/engine/outcome/loop-result-mapper.js

@@ -3,8 +3,35 @@ import { getBudgetRunSummary } from '../../../context/budget/integration.js';
 import { getAuthorizationDecisionsFromAuditTrail } from '../../../observability/authorization-decisions.js';
 import { buildFailureEnvelope } from '../../../observability/error-envelope.js';
 import { getTokenUsageFromAuditTrail } from '../../../observability/token-usage.js';
+import { resolveExecutionProfile } from '../../../runtime/execution-profile.js';
 import { ErrorType, Phase } from '../../../types/runtime.js';
+const ROOT_CAUSE_CODES = [
+    'LLM_RATE_LIMITED',
+    'LLM_UPSTREAM_5XX',
+    'LLM_NETWORK_UNREACHABLE',
+    'LLM_REQUEST_TIMEOUT',
+    'PLAN_OUTPUT_NOT_JSON',
+    'PLAN_SCHEMA_INVALID',
+    'STDOUT_CONTRACT_VIOLATION',
+    'RESOURCE_LIMIT_CONFIRMED',
+];
+function toRootCauseCode(code) {
+    if (typeof code !== 'string')
+        return undefined;
+    return ROOT_CAUSE_CODES.includes(code)
+        ? code
+        : undefined;
+}
 export function buildLoopResultFromTransaction({ executionReport, flowMode, options, telemetry, auditPath, }) {
+    const profile = resolveExecutionProfile(flowMode);
+    const rootCause = toRootCauseCode(executionReport.lastErrorCode);
+    const terminalReason = executionReport.retryExhausted
+        ? 'RETRY_BUDGET_EXHAUSTED'
+        : executionReport.terminalReasonCode === 'AWAITING_INPUT'
+            ? undefined
+            : executionReport.success
+                ? undefined
+                : 'NON_RETRYABLE_FAILURE';
     const ctx = executionReport.lastContext ??
         executionReport.flowReport.data;
     const contextHash = (() => {
@@ -19,11 +46,35 @@ export function buildLoopResultFromTransaction({ executionReport, flowMode, opti
     const verifyArtifact = ctx && typeof ctx === 'object' && 'verifyArtifact' in ctx
         ? ctx.verifyArtifact
         : executionReport.lastVerifyArtifact;
-    const assistantMessage = flowMode === 'answer'
-        ? ctx?.report?.summary?.trim?.()
-            ? String(ctx.report.summary).trim()
-            : ''
-        : undefined;
+    const artifactHints = (() => {
+        const hints = {
+            verifyArtifact,
+            subAgentPatchArtifacts: executionReport.lastSubAgentPatchArtifacts?.length
+                ? executionReport.lastSubAgentPatchArtifacts
+                : undefined,
+            subAgentAuditArtifacts: executionReport.lastSubAgentAuditArtifacts?.length
+                ? executionReport.lastSubAgentAuditArtifacts
+                : undefined,
+            recentReadArtifacts: executionReport.lastRecentReadArtifacts?.length
+                ? executionReport.lastRecentReadArtifacts
+                : undefined,
+            toolResultPreviewArtifacts: executionReport.lastToolResultPreviewArtifacts?.length
+                ? executionReport.lastToolResultPreviewArtifacts
+                : undefined,
+        };
+        if (!hints.verifyArtifact &&
+            !hints.subAgentPatchArtifacts &&
+            !hints.subAgentAuditArtifacts &&
+            !hints.recentReadArtifacts &&
+            !hints.toolResultPreviewArtifacts) {
+            return undefined;
+        }
+        return hints;
+    })();
+    const assistantMessage = ((flowMode === 'answer' || profile.driver === 'agent') &&
+        ctx?.report?.summary?.trim?.()
+        ? String(ctx.report.summary).trim()
+        : undefined) ?? undefined;
     const finalPatch = ctx && typeof ctx === 'object' && 'diff' in ctx ? ctx.diff : undefined;
     const changedFiles = ctx && typeof ctx === 'object' && 'changedFiles' in ctx ? ctx.changedFiles : undefined;
     const authorizationDecisions = (() => {
@@ -36,14 +87,12 @@ export function buildLoopResultFromTransaction({ executionReport, flowMode, opti
         const attempts = executionReport.attempts;
         const usage = getTokenUsageFromAuditTrail() ?? undefined;
         const budgetSummary = getBudgetRunSummary() ?? undefined;
-        if (options.dryRun ||
-            flowMode === 'review' ||
-            flowMode === 'research' ||
-            flowMode === 'answer') {
+        if (options.dryRun || profile.readOnly) {
             return {
                 success: true,
                 reason: text.loop.operationCompleted,
                 reasonCode: options.dryRun ? 'DRY_RUN' : 'SUCCESS',
+                terminalReason,
                 attempts,
                 contextHash,
                 logs: telemetry.getLogs(),
@@ -55,6 +104,7 @@ export function buildLoopResultFromTransaction({ executionReport, flowMode, opti
                 assistantMessage,
                 auditPath,
                 verifyArtifact,
+                artifactHints,
                 authorizationSummary: executionReport.authorizationSummary || undefined,
                 strategyName: executionReport.flowReport.strategyName ?? flowMode,
                 fsMode: executionReport.flowReport.fsMode ?? flowMode,
@@ -65,6 +115,7 @@ export function buildLoopResultFromTransaction({ executionReport, flowMode, opti
             success: true,
             reason: text.loop.operationCompleted,
             reasonCode: 'SUCCESS',
+            terminalReason,
             attempts,
             contextHash,
             logs: telemetry.getLogs(),
@@ -76,6 +127,7 @@ export function buildLoopResultFromTransaction({ executionReport, flowMode, opti
             assistantMessage,
             auditPath,
             verifyArtifact,
+            artifactHints,
             authorizationSummary: executionReport.authorizationSummary || undefined,
             strategyName: executionReport.flowReport.strategyName ?? flowMode,
             fsMode: executionReport.flowReport.fsMode ?? flowMode,
@@ -107,6 +159,8 @@ export function buildLoopResultFromTransaction({ executionReport, flowMode, opti
         success: false,
         reason: safeHint,
         reasonCode,
+        terminalReason,
+        rootCause,
         diagnosticCode: executionReport.terminalDiagnosticCode ?? reasonCode,
         safeHint,
         remediationSteps,
@@ -122,6 +176,7 @@ export function buildLoopResultFromTransaction({ executionReport, flowMode, opti
         errorCode: executionReport.lastErrorCode,
         auditPath,
         verifyArtifact,
+        artifactHints,
         authorizationSummary: executionReport.authorizationSummary || undefined,
         strategyName: executionReport.flowReport.strategyName ?? flowMode,
         fsMode: executionReport.flowReport.fsMode ?? flowMode,
@@ -138,6 +193,7 @@ export function buildLoopFailureResult({ message, flowMode, telemetry, auditPath
         const decisions = getAuthorizationDecisionsFromAuditTrail();
         return decisions.length > 0 ? decisions : undefined;
     })();
+    const rootCause = toRootCauseCode(errorCode);
     const errorEnvelope = buildFailureEnvelope({
         phase: failurePhase,
         fallbackMessage: message,
@@ -146,6 +202,8 @@ export function buildLoopFailureResult({ message, flowMode, telemetry, auditPath
         success: false,
         reason: message,
         reasonCode,
+        terminalReason: 'NON_RETRYABLE_FAILURE',
+        rootCause,
         diagnosticCode: reasonCode,
         safeHint: message,
         remediationSteps: [],

package/dist/core/grizzco/engine/pipeline/pipeline.js

@@ -300,19 +300,23 @@ export class Pipeline {
     async execute() {
         try {
             const data = await this.promise;
+            const lastExecutedStep = [...this.traces].reverse().find((trace) => !trace.name.endsWith(':recovery'))?.name ??
+                this.lastStepName;
             return {
                 success: true,
                 duration: Date.now() - this.startTime,
-                lastStep: this.lastStepName,
+                lastStep: lastExecutedStep,
                 data,
                 traces: this.traces,
             };
         }
         catch (error) {
+            const lastExecutedStep = [...this.traces].reverse().find((trace) => !trace.name.endsWith(':recovery'))?.name ??
+                this.lastStepName;
             return {
                 success: false,
                 error: error instanceof Error ? error : new Error(String(error)),
-                lastStep: this.lastStepName,
+                lastStep: lastExecutedStep,
                 duration: Date.now() - this.startTime,
                 data: this.ctxRef.current,
                 traces: this.traces,

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

@@ -2,6 +2,8 @@ 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 { resolveExecutionProfile } from '../../../runtime/execution-profile.js';
+import { isRecoverableToolInputErrorCode } from '../../../tools/recoverable-tool-errors.js';
 import { EXECUTION_PHASES } from '../../../types/runtime.js';
 import { classifyError, isRetryable } from '../../../verification/runner.js';
 const RETRYABLE_PHASES = new Set([
@@ -19,6 +21,7 @@ const NON_RETRYABLE_PERMISSION_CODES = new Set([
     'PERMISSION_REQUIRED_CONTEXT_CACHE_OUTSIDE_ROOT',
     'PERMISSION_DENIED_CONTEXT_CACHE_OUTSIDE_ROOT',
 ]);
+const NON_RETRYABLE_LLM_CODES = new Set(['LLM_AUTHENTICATION_FAILED']);
 function inferFailurePhase(flowReport) {
     const failedTrace = [...flowReport.traces].reverse().find((trace) => Boolean(trace.error));
     if (failedTrace && EXECUTION_PHASES.includes(failedTrace.name)) {
@@ -67,6 +70,7 @@ function extractInterrupt(error) {
 }
 export function resolveAttemptFailure(params) {
     const { flowReport, context, flowMode } = params;
+    const profile = resolveExecutionProfile(flowMode);
     const interrupt = extractInterrupt(flowReport.error);
     const interruptCode = extractErrorCode(flowReport.error);
     if (interruptCode === 'INTERRUPT_REQUIRED' && interrupt?.type === 'awaiting_input') {
@@ -87,23 +91,19 @@ export function resolveAttemptFailure(params) {
             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 autopilotCompletion = flowMode === 'autopilot' && context && 'completion' in context ? context.completion : undefined;
+    const verifyOk = profile.verifyPolicy === 'never' ? true : context?.verifyResult?.ok !== false;
+    const applyBackResult = context && 'applyBackResult' in context ? context.applyBackResult : undefined;
+    const applyBackFailed = profile.failurePolicy === 'rollback' &&
+        applyBackResult?.success === false &&
+        !applyBackResult.skipped;
     const environmentMode = context?.options?.environmentMode;
     if (applyBackFailed) {
-        const fallbackReason = context.applyBackResult?.safeMessage ||
-            context.applyBackResult?.error ||
-            text.loop.applyBackFailed;
+        const fallbackReason = applyBackResult?.safeMessage || applyBackResult?.error || text.loop.applyBackFailed;
         const guidance = buildFailureGuidance({
             reasonCode: 'APPLY_BACK_FAILED',
             failurePhase: 'APPLY_BACK',
-            errorCode: context.applyBackResult?.errorCode || 'APPLY_BACK_FAILED',
+            errorCode: applyBackResult?.errorCode || 'APPLY_BACK_FAILED',
             environmentMode,
             fallbackReason,
         });
@@ -112,16 +112,51 @@ export function resolveAttemptFailure(params) {
             reasonCode: 'APPLY_BACK_FAILED',
             failurePhase: 'APPLY_BACK',
             retryable: false,
-            errorCode: context.applyBackResult?.errorCode || 'APPLY_BACK_FAILED',
+            errorCode: applyBackResult?.errorCode || 'APPLY_BACK_FAILED',
             diagnosticCode: guidance.diagnosticCode,
             safeHint: guidance.safeHint,
             remediationSteps: guidance.remediationSteps,
         };
     }
-    if (flowReport.success && verifyOk) {
+    if (flowReport.success && verifyOk && !autopilotCompletion) {
         return undefined;
     }
     const errorCode = extractErrorCode(flowReport.error) ?? extractErrorCodeFromTraces(flowReport);
+    if (flowMode === 'autopilot' && autopilotCompletion) {
+        if (autopilotCompletion.status === 'changed' ||
+            autopilotCompletion.status === 'read_only_answer') {
+            if (flowReport.success && verifyOk)
+                return undefined;
+        }
+        const reasonCode = autopilotCompletion.status === 'verification_missing'
+            ? 'VERIFY_COMMAND_MISSING'
+            : autopilotCompletion.status === 'tool_failure' &&
+                isRecoverableToolInputErrorCode(autopilotCompletion.errorCode)
+                ? 'TOOL_CORRECTION_REQUIRED'
+                : 'LOOP_FAILED';
+        const failurePhase = autopilotCompletion.status === 'verification_missing' ? 'VERIFY' : 'AUTOPILOT';
+        const fallbackReason = autopilotCompletion.reason ||
+            (autopilotCompletion.status === 'no_effect'
+                ? 'Autopilot completed without changing files or producing an answer.'
+                : text.loop.loopExecutionFailed);
+        const guidance = buildFailureGuidance({
+            reasonCode,
+            failurePhase,
+            errorCode: autopilotCompletion.errorCode,
+            environmentMode,
+            fallbackReason,
+        });
+        return {
+            reason: guidance.safeHint,
+            reasonCode,
+            failurePhase,
+            retryable: reasonCode === 'TOOL_CORRECTION_REQUIRED' || autopilotCompletion.status === 'no_effect',
+            errorCode: autopilotCompletion.errorCode,
+            diagnosticCode: guidance.diagnosticCode,
+            safeHint: guidance.safeHint,
+            remediationSteps: guidance.remediationSteps,
+        };
+    }
     if (errorCode === 'PREFLIGHT_NOT_GIT') {
         const fallbackReason = sanitizeReason(flowReport.error);
         const guidance = buildFailureGuidance({
@@ -182,7 +217,28 @@ export function resolveAttemptFailure(params) {
             remediationSteps: guidance.remediationSteps,
         };
     }
-    if (flowMode !== 'review' && context?.verifyResult?.ok === false) {
+    if (errorCode && NON_RETRYABLE_LLM_CODES.has(errorCode)) {
+        const failurePhase = inferFailurePhase(flowReport);
+        const fallbackReason = sanitizeReason(flowReport.error);
+        const guidance = buildFailureGuidance({
+            reasonCode: 'LOOP_FAILED',
+            failurePhase,
+            errorCode,
+            environmentMode,
+            fallbackReason,
+        });
+        return {
+            reason: guidance.safeHint,
+            reasonCode: 'LOOP_FAILED',
+            failurePhase,
+            retryable: false,
+            errorCode,
+            diagnosticCode: guidance.diagnosticCode,
+            safeHint: guidance.safeHint,
+            remediationSteps: guidance.remediationSteps,
+        };
+    }
+    if (profile.verifyPolicy !== 'never' && context?.verifyResult?.ok === false) {
         const verifyOutput = context.verifyResult.output || text.loop.loopExecutionFailed;
         const errorType = classifyError(verifyOutput);
         const fallbackReason = sanitizeReason(context.lastError || verifyOutput);
@@ -207,6 +263,25 @@ export function resolveAttemptFailure(params) {
     }
     const failurePhase = inferFailurePhase(flowReport);
     const fallbackReason = sanitizeReason(context?.lastError || flowReport.error);
+    if (isRecoverableToolInputErrorCode(errorCode)) {
+        const guidance = buildFailureGuidance({
+            reasonCode: 'TOOL_CORRECTION_REQUIRED',
+            failurePhase,
+            errorCode,
+            environmentMode,
+            fallbackReason,
+        });
+        return {
+            reason: guidance.safeHint,
+            reasonCode: 'TOOL_CORRECTION_REQUIRED',
+            failurePhase,
+            retryable: RETRYABLE_PHASES.has(failurePhase),
+            errorCode,
+            diagnosticCode: guidance.diagnosticCode,
+            safeHint: guidance.safeHint,
+            remediationSteps: guidance.remediationSteps,
+        };
+    }
     const guidance = buildFailureGuidance({
         reasonCode: failurePhase === 'ROLLBACK' ? 'ROLLBACK_FAILED' : 'LOOP_FAILED',
         failurePhase,

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

@@ -1,5 +1,5 @@
 export function mapSuccessReport(params) {
-    const { attempt, flowReport, history, authorizationSummary, lastContext, lastVerifyArtifact, lastErrorCode, } = params;
+    const { attempt, flowReport, history, authorizationSummary, lastContext, lastVerifyArtifact, lastSubAgentPatchArtifacts, lastSubAgentAuditArtifacts, lastRecentReadArtifacts, lastToolResultPreviewArtifacts, lastErrorCode, } = params;
     return {
         success: true,
         attempts: attempt,
@@ -10,10 +10,14 @@ export function mapSuccessReport(params) {
         retryExhausted: false,
         lastContext,
         lastVerifyArtifact,
+        lastSubAgentPatchArtifacts,
+        lastSubAgentAuditArtifacts,
+        lastRecentReadArtifacts,
+        lastToolResultPreviewArtifacts,
     };
 }
 export function mapTerminalFailureReport(params) {
-    const { attempt, flowReport, history, authorizationSummary, lastContext, lastVerifyArtifact, failure, lastErrorCode, } = params;
+    const { attempt, flowReport, history, authorizationSummary, lastContext, lastVerifyArtifact, lastSubAgentPatchArtifacts, lastSubAgentAuditArtifacts, lastRecentReadArtifacts, lastToolResultPreviewArtifacts, failure, lastErrorCode, } = params;
     return {
         success: false,
         attempts: attempt,
@@ -24,6 +28,10 @@ export function mapTerminalFailureReport(params) {
         retryExhausted: false,
         lastContext,
         lastVerifyArtifact,
+        lastSubAgentPatchArtifacts,
+        lastSubAgentAuditArtifacts,
+        lastRecentReadArtifacts,
+        lastToolResultPreviewArtifacts,
         terminalReason: failure.reason,
         terminalReasonCode: failure.reasonCode,
         terminalFailurePhase: failure.failurePhase,
@@ -34,7 +42,7 @@ export function mapTerminalFailureReport(params) {
     };
 }
 export function mapRetryExhaustedReport(params) {
-    const { attempts, flowReport, history, authorizationSummary, lastErrorCode, lastContext, lastVerifyArtifact, } = params;
+    const { attempts, flowReport, history, authorizationSummary, failure, lastErrorCode, lastContext, lastVerifyArtifact, lastSubAgentPatchArtifacts, lastSubAgentAuditArtifacts, lastRecentReadArtifacts, lastToolResultPreviewArtifacts, } = params;
     return {
         success: false,
         attempts,
@@ -45,6 +53,12 @@ export function mapRetryExhaustedReport(params) {
         retryExhausted: true,
         lastContext,
         lastVerifyArtifact,
+        lastSubAgentPatchArtifacts,
+        lastSubAgentAuditArtifacts,
+        lastRecentReadArtifacts,
+        lastToolResultPreviewArtifacts,
+        terminalFailurePhase: failure?.failurePhase,
+        terminalDiagnosticCode: failure?.diagnosticCode,
     };
 }
 //# sourceMappingURL=report-mapper.js.map

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

@@ -1,7 +1,8 @@
 import { recordAuditEvent } from '../../../observability/audit-trail.js';
 import { mapErrorForAudit } from '../../../observability/error-mapping.js';
 import { ReflectionEngine } from '../../../reflection/engine.js';
-import { executeSalmonLoopFlow } from '../../flows/SalmonLoopFlow.js';
+import { resolveExecutionProfile } from '../../../runtime/execution-profile.js';
+import { executeFlowAttempt } from '../../flows/flow-dispatch.js';
 import { resolveAttemptFailure } from './attempt-failure.js';
 import { buildAuthorizationSummary } from './authorization-summary.js';
 import { mapRetryExhaustedReport, mapSuccessReport, mapTerminalFailureReport, } from './report-mapper.js';
@@ -12,6 +13,108 @@ export class FlowTransactionCancelledError extends Error {
         this.name = 'FlowTransactionCancelledError';
     }
 }
+function isArtifactHandle(value) {
+    return (Boolean(value) &&
+        typeof value === 'object' &&
+        typeof value.handle === 'string');
+}
+function mergeArtifactHandles(existing, incoming, limit = 4) {
+    const merged = [...existing];
+    const seen = new Set(existing.map((artifact) => artifact.handle));
+    for (const artifact of incoming) {
+        if (seen.has(artifact.handle))
+            continue;
+        merged.push(artifact);
+        seen.add(artifact.handle);
+    }
+    if (merged.length <= limit)
+        return merged;
+    return merged.slice(merged.length - limit);
+}
+function extractSubAgentArtifacts(entries) {
+    if (!Array.isArray(entries) || entries.length === 0) {
+        return { patchArtifacts: [], auditArtifacts: [] };
+    }
+    const patchArtifacts = [];
+    const auditArtifacts = [];
+    for (const entry of entries) {
+        if (entry?.toolName !== 'agent_dispatch' || entry.toolResultStatus !== 'ok')
+            continue;
+        if (isArtifactHandle(entry.toolResultPatchArtifact)) {
+            patchArtifacts.push(entry.toolResultPatchArtifact);
+        }
+        if (isArtifactHandle(entry.toolResultAuditArtifact)) {
+            auditArtifacts.push(entry.toolResultAuditArtifact);
+        }
+    }
+    return { patchArtifacts, auditArtifacts };
+}
+function extractRecentReadArtifacts(entries) {
+    if (!Array.isArray(entries) || entries.length === 0) {
+        return [];
+    }
+    const recentReads = [];
+    for (const entry of entries) {
+        if (entry.toolIntent !== 'READ' || entry.toolResultStatus !== 'ok')
+            continue;
+        if (typeof entry.toolResultReadArtifactPath !== 'string')
+            continue;
+        if (!isArtifactHandle(entry.toolResultReadArtifact))
+            continue;
+        recentReads.push({
+            path: entry.toolResultReadArtifactPath,
+            artifact: entry.toolResultReadArtifact,
+        });
+    }
+    return recentReads;
+}
+function mergeReadArtifacts(existing, incoming, limit = 6) {
+    const merged = [];
+    const seen = new Set();
+    for (const item of [...existing, ...incoming]) {
+        const key = `${item.path}::${item.artifact.handle}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(item);
+    }
+    if (merged.length <= limit)
+        return merged;
+    return merged.slice(merged.length - limit);
+}
+function extractToolResultPreviewArtifacts(entries) {
+    if (!Array.isArray(entries) || entries.length === 0) {
+        return [];
+    }
+    const previews = [];
+    for (const entry of entries) {
+        if (entry.toolResultStatus !== 'ok')
+            continue;
+        if (typeof entry.toolResultPreviewLabel !== 'string')
+            continue;
+        if (!isArtifactHandle(entry.toolResultPreviewArtifact))
+            continue;
+        previews.push({
+            label: entry.toolResultPreviewLabel,
+            artifact: entry.toolResultPreviewArtifact,
+        });
+    }
+    return previews;
+}
+function mergePreviewArtifacts(existing, incoming, limit = 6) {
+    const merged = [];
+    const seen = new Set();
+    for (const item of [...existing, ...incoming]) {
+        const key = `${item.label}::${item.artifact.handle}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(item);
+    }
+    if (merged.length <= limit)
+        return merged;
+    return merged.slice(merged.length - limit);
+}
 export class FlowTransactionRunner {
     params;
     historyEntries = [];
@@ -20,8 +123,25 @@ export class FlowTransactionRunner {
     authorizationSummary = null;
     lastContext;
     lastVerifyArtifact;
+    lastSubAgentPatchArtifacts;
+    lastSubAgentAuditArtifacts;
+    lastRecentReadArtifacts;
+    lastToolResultPreviewArtifacts;
+    lastReplacementState;
     constructor(params) {
         this.params = params;
+        this.lastVerifyArtifact = params.options.artifactHints?.verifyArtifact;
+        this.lastSubAgentPatchArtifacts = [
+            ...(params.options.artifactHints?.subAgentPatchArtifacts ?? []),
+        ];
+        this.lastSubAgentAuditArtifacts = [
+            ...(params.options.artifactHints?.subAgentAuditArtifacts ?? []),
+        ];
+        this.lastRecentReadArtifacts = [...(params.options.artifactHints?.recentReadArtifacts ?? [])];
+        this.lastToolResultPreviewArtifacts = [
+            ...(params.options.artifactHints?.toolResultPreviewArtifacts ?? []),
+        ];
+        this.lastReplacementState = params.options.replacementState;
     }
     isShrinkCtx(ctx) {
         return Boolean(ctx && 'verifyResult' in ctx);
@@ -29,13 +149,15 @@ export class FlowTransactionRunner {
     async execute() {
         let retries = 0;
         let lastReport;
+        let lastAttemptFailure;
+        const profile = resolveExecutionProfile(this.params.flowMode);
         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({
+            const result = await executeFlowAttempt({
                 workspace: this.params.env.workspace,
                 options: this.params.options,
                 mode: this.params.flowMode,
@@ -46,6 +168,20 @@ export class FlowTransactionRunner {
                 shadowInitialRef: this.params.env.shadowInitialRef,
                 attempt,
                 initialContext: this.currentContext,
+                artifactHints: {
+                    verifyArtifact: this.lastVerifyArtifact,
+                    subAgentPatchArtifacts: this.lastSubAgentPatchArtifacts.length > 0
+                        ? this.lastSubAgentPatchArtifacts
+                        : undefined,
+                    subAgentAuditArtifacts: this.lastSubAgentAuditArtifacts.length > 0
+                        ? this.lastSubAgentAuditArtifacts
+                        : undefined,
+                    recentReadArtifacts: this.lastRecentReadArtifacts.length > 0 ? this.lastRecentReadArtifacts : undefined,
+                    toolResultPreviewArtifacts: this.lastToolResultPreviewArtifacts.length > 0
+                        ? this.lastToolResultPreviewArtifacts
+                        : undefined,
+                },
+                replacementState: this.lastReplacementState,
                 lastError: this.currentLastError,
                 applyBackRuntime: {
                     activeRepoPath: this.params.env.activeRepoPath,
@@ -64,11 +200,18 @@ export class FlowTransactionRunner {
             if (shrinkCtx?.verifyArtifact) {
                 this.lastVerifyArtifact = shrinkCtx.verifyArtifact;
             }
+            const subAgentArtifacts = extractSubAgentArtifacts(terminalCtx?.toolCallingAudit);
+            this.lastSubAgentPatchArtifacts = mergeArtifactHandles(this.lastSubAgentPatchArtifacts, subAgentArtifacts.patchArtifacts);
+            this.lastSubAgentAuditArtifacts = mergeArtifactHandles(this.lastSubAgentAuditArtifacts, subAgentArtifacts.auditArtifacts);
+            this.lastRecentReadArtifacts = mergeReadArtifacts(this.lastRecentReadArtifacts, extractRecentReadArtifacts(terminalCtx?.toolCallingAudit));
+            this.lastToolResultPreviewArtifacts = mergePreviewArtifacts(this.lastToolResultPreviewArtifacts, extractToolResultPreviewArtifacts(terminalCtx?.toolCallingAudit));
+            this.lastReplacementState = terminalCtx?.replacementState ?? this.lastReplacementState;
             const attemptFailure = resolveAttemptFailure({
                 flowReport: result,
                 context: shrinkCtx,
                 flowMode: this.params.flowMode,
             });
+            lastAttemptFailure = attemptFailure;
             const entry = {
                 attempt,
                 plan: shrinkCtx?.plan ?? null,
@@ -82,9 +225,11 @@ export class FlowTransactionRunner {
             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';
+                const successPhase = profile.failurePolicy === 'preserve'
+                    ? profile.entryPhase
+                    : profile.readOnly
+                        ? '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) {
@@ -107,8 +252,12 @@ export class FlowTransactionRunner {
                     history: this.historyEntries,
                     authorizationSummary: this.authorizationSummary,
                     lastErrorCode: this.extractErrorCode(result.error),
-                    lastContext: shrinkCtx,
+                    lastContext: terminalCtx,
                     lastVerifyArtifact: this.lastVerifyArtifact,
+                    lastSubAgentPatchArtifacts: this.lastSubAgentPatchArtifacts,
+                    lastSubAgentAuditArtifacts: this.lastSubAgentAuditArtifacts,
+                    lastRecentReadArtifacts: this.lastRecentReadArtifacts,
+                    lastToolResultPreviewArtifacts: this.lastToolResultPreviewArtifacts,
                 });
             }
             if (attemptFailure.reasonCode === 'AWAITING_INPUT') {
@@ -160,8 +309,12 @@ export class FlowTransactionRunner {
                     history: this.historyEntries,
                     authorizationSummary: this.authorizationSummary,
                     lastErrorCode: attemptFailure.errorCode ?? this.extractErrorCode(result.error),
-                    lastContext: shrinkCtx,
+                    lastContext: terminalCtx,
                     lastVerifyArtifact: this.lastVerifyArtifact,
+                    lastSubAgentPatchArtifacts: this.lastSubAgentPatchArtifacts,
+                    lastSubAgentAuditArtifacts: this.lastSubAgentAuditArtifacts,
+                    lastRecentReadArtifacts: this.lastRecentReadArtifacts,
+                    lastToolResultPreviewArtifacts: this.lastToolResultPreviewArtifacts,
                     failure: attemptFailure,
                 });
             }
@@ -184,9 +337,14 @@ export class FlowTransactionRunner {
             flowReport: lastReport,
             history: this.historyEntries,
             authorizationSummary: this.authorizationSummary,
+            failure: lastAttemptFailure,
             lastErrorCode: this.extractErrorCode(lastReport.error),
             lastContext: this.lastContext,
             lastVerifyArtifact: this.lastVerifyArtifact,
+            lastSubAgentPatchArtifacts: this.lastSubAgentPatchArtifacts,
+            lastSubAgentAuditArtifacts: this.lastSubAgentAuditArtifacts,
+            lastRecentReadArtifacts: this.lastRecentReadArtifacts,
+            lastToolResultPreviewArtifacts: this.lastToolResultPreviewArtifacts,
         });
     }
     extractErrorCode(error) {

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