salmon-loop 0.3.2 → 0.5.0

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

@@ -2,6 +2,7 @@ import { recordAuditEvent, setAuditContext } from '../../../observability/audit-
 import { getLogger } from '../../../observability/logger.js';
 import { appendPlanNote } from '../../../plan/index.js';
 import { EXECUTION_PHASES, } from '../../../types/runtime.js';
+import { isRecord } from '../../../utils/serialize.js';
 /**
  * Typed Async Pipeline Container
  */
@@ -28,271 +29,179 @@ export class Pipeline {
      * Add a step to the pipeline
      */
     step(name, action) {
-        const nextPromise = this.promise.then(async (ctx) => {
-            const start = Date.now();
-            let phaseStarted = false;
-            let errorStr;
-            let errorMeta;
-            let result;
-            const emit = ctx.emit;
-            const isPhase = (value) => EXECUTION_PHASES.includes(value);
-            const planRuntime = ctx?.planRuntime;
-            const persistenceRoot = ctx?.workspace?.baseRepoPath || ctx?.workspace?.workPath;
-            const attempt = ctx?.attempt ?? 1;
-            const tryAppendPlanNote = async (note) => {
-                if (!planRuntime || !persistenceRoot)
-                    return;
-                try {
-                    await appendPlanNote({
-                        persistenceRoot,
-                        sessionId: planRuntime.sessionId,
-                        note,
-                    });
-                    recordAuditEvent('plan.runtime.note.append', { note, ok: true }, { source: 'plan', severity: 'low', scope: 'session', phase: name });
-                    return true;
-                }
-                catch (e) {
-                    const msg = e instanceof Error ? e.message : String(e);
-                    recordAuditEvent('plan.runtime.note.append.failed', { note, error: msg }, { source: 'plan', severity: 'low', scope: 'session', phase: name });
-                    getLogger().debug(`[PlanRuntime] Failed to append note: ${msg}`);
-                    return false;
-                }
-            };
-            try {
-                this.ctxRef.current = ctx;
-                const signal = ctx?.options?.signal;
-                const strategy = ctx?.workspace?.strategy ?? ctx?.options?.strategy;
-                if (signal?.aborted && strategy === 'worktree') {
-                    throw new Error('Operation cancelled by user');
-                }
-                setAuditContext({ phase: name });
-                if (emit && isPhase(name)) {
-                    emit({ type: 'phase.start', phase: name, timestamp: new Date() });
-                    phaseStarted = true;
-                    const ok = await tryAppendPlanNote(`Attempt ${attempt}: phase.start ${name}`);
-                    if (planRuntime && ok !== undefined) {
-                        emit({
-                            type: 'plan.runtime.journal',
-                            sessionId: planRuntime.sessionId,
-                            phase: name,
-                            kind: 'start',
-                            attempt,
-                            ok,
-                            timestamp: new Date(),
-                        });
-                    }
-                }
-                result = await action(ctx);
-                this.ctxRef.current = result;
-                // APPLY_BACK failure is represented as a structured result (not an exception) to preserve context.
-                // The pipeline must still treat it as a phase failure for progress reporting and plan journaling.
-                if (name === 'APPLY_BACK' &&
-                    result &&
-                    typeof result === 'object' &&
-                    result.applyBackResult &&
-                    typeof result.applyBackResult === 'object') {
-                    const applyBackResult = result.applyBackResult;
-                    if (applyBackResult.success === false && !applyBackResult.skipped) {
-                        errorStr = applyBackResult.safeMessage || applyBackResult.error || 'Apply-back failed';
-                        errorMeta = {
+        const nextPromise = this.executeStep(name, action, async () => {
+            // No recovery for plain steps — check for APPLY_BACK structured failure
+            const result = this.ctxRef.current;
+            if (name === 'APPLY_BACK' && isRecord(result) && isRecord(result.applyBackResult)) {
+                const applyBackResult = result.applyBackResult;
+                if (applyBackResult.success === false && !applyBackResult.skipped) {
+                    return {
+                        errorStr: applyBackResult.safeMessage || applyBackResult.error || 'Apply-back failed',
+                        errorMeta: {
                             name: 'ApplyBackFailure',
                             code: applyBackResult.errorCode || 'APPLY_BACK_FAILED',
-                        };
-                    }
+                        },
+                    };
                 }
-                return result;
             }
-            catch (error) {
-                errorStr = error instanceof Error ? error.message : String(error);
-                errorMeta =
-                    typeof error === 'object' && error !== null
-                        ? {
-                            name: error.name,
-                            code: error.code,
-                            llmCode: error.llmCode,
-                        }
-                        : undefined;
-                throw error;
+            return null;
+        });
+        return new Pipeline(nextPromise, this.startTime, name, this.traces, this.ctxRef);
+    }
+    /**
+     * Add a step with error recovery
+     */
+    stepWithRecovery(name, action, recovery) {
+        const nextPromise = this.executeStep(name, action, async (ctx, errorStr) => {
+            // Only run recovery when the step actually failed
+            if (!errorStr)
+                return null;
+            const recStart = Date.now();
+            try {
+                await recovery(ctx);
+                this.traces.push({
+                    name: `${name}:recovery`,
+                    start: recStart,
+                    end: Date.now(),
+                    duration: Date.now() - recStart,
+                    metadata: { success: true },
+                });
             }
-            finally {
-                if (emit && isPhase(name) && phaseStarted) {
-                    emit({
-                        type: 'phase.end',
-                        phase: name,
-                        success: !errorStr,
-                        timestamp: new Date(),
-                    });
-                    const ok = await tryAppendPlanNote(`Attempt ${attempt}: phase.end ${name} (success=${String(!errorStr)})`);
-                    if (planRuntime && ok !== undefined) {
-                        emit({
-                            type: 'plan.runtime.journal',
-                            sessionId: planRuntime.sessionId,
-                            phase: name,
-                            kind: 'end',
-                            attempt,
-                            ok,
-                            timestamp: new Date(),
-                        });
-                    }
-                }
-                setAuditContext({ phase: undefined });
-                const end = Date.now();
+            catch (recError) {
+                const recEnd = Date.now();
+                const errorDetail = recError instanceof Error ? recError.message : String(recError);
                 this.traces.push({
-                    name,
-                    start,
-                    end,
-                    duration: end - start,
-                    error: errorStr,
-                    metadata: errorMeta,
+                    name: `${name}:recovery`,
+                    start: recStart,
+                    end: recEnd,
+                    duration: recEnd - recStart,
+                    error: errorDetail,
+                    metadata: { success: false, phase: 'RECOVERY_FAILURE' },
                 });
+                getLogger().audit('PIPELINE_RECOVERY_FAILED', { step: name, originalError: errorStr, recoveryError: errorDetail }, { source: 'system', severity: 'high', scope: 'session' });
             }
+            return null; // Always re-throw original error
         });
         return new Pipeline(nextPromise, this.startTime, name, this.traces, this.ctxRef);
     }
     /**
-     * Add a step with error recovery
+     * Core step execution shared by step() and stepWithRecovery().
+     * Handles: abort check, phase events, plan journaling, tracing.
+     * The onError callback runs recovery/post-processing; return non-null to inject error metadata.
      */
-    stepWithRecovery(name, action, recovery) {
-        const nextPromise = this.promise.then(async (ctx) => {
-            const start = Date.now();
-            let phaseStarted = false;
-            let abortedBeforeAction = false;
-            let errorStr;
-            let errorMeta;
-            let result;
-            const emit = ctx.emit;
-            const isPhase = (value) => EXECUTION_PHASES.includes(value);
-            const planRuntime = ctx?.planRuntime;
-            const persistenceRoot = ctx?.workspace?.baseRepoPath || ctx?.workspace?.workPath;
-            const attempt = ctx?.attempt ?? 1;
-            const tryAppendPlanNote = async (note) => {
-                if (!planRuntime || !persistenceRoot)
-                    return;
-                try {
-                    await appendPlanNote({
-                        persistenceRoot,
-                        sessionId: planRuntime.sessionId,
-                        note,
-                    });
-                    recordAuditEvent('plan.runtime.note.append', { note, ok: true }, { source: 'plan', severity: 'low', scope: 'session', phase: name });
-                    return true;
-                }
-                catch (e) {
-                    const msg = e instanceof Error ? e.message : String(e);
-                    recordAuditEvent('plan.runtime.note.append.failed', { note, error: msg }, { source: 'plan', severity: 'low', scope: 'session', phase: name });
-                    getLogger().debug(`[PlanRuntime] Failed to append note: ${msg}`);
-                    return false;
-                }
-            };
+    async executeStep(name, action, onError) {
+        const start = Date.now();
+        let phaseStarted = false;
+        let errorStr;
+        let errorMeta;
+        let result;
+        const ctx = await this.promise;
+        const emit = ctx.emit;
+        const isPhase = (value) => EXECUTION_PHASES.includes(value);
+        const ctxObj = isRecord(ctx) ? ctx : null;
+        const planRuntime = ctxObj?.planRuntime;
+        const workspace = isRecord(ctxObj?.workspace) ? ctxObj.workspace : null;
+        const persistenceRoot = (typeof workspace?.baseRepoPath === 'string' ? workspace.baseRepoPath : undefined) ||
+            (typeof workspace?.workPath === 'string' ? workspace.workPath : undefined);
+        const attempt = typeof ctxObj?.attempt === 'number' ? ctxObj.attempt : 1;
+        const tryAppendPlanNote = async (note) => {
+            if (!planRuntime || !persistenceRoot)
+                return;
             try {
-                this.ctxRef.current = ctx;
-                const signal = ctx?.options?.signal;
-                const strategy = ctx?.workspace?.strategy ?? ctx?.options?.strategy;
-                if (signal?.aborted && strategy === 'worktree') {
-                    abortedBeforeAction = true;
-                    throw new Error('Operation cancelled by user');
-                }
-                setAuditContext({ phase: name });
-                if (emit && isPhase(name)) {
-                    emit({ type: 'phase.start', phase: name, timestamp: new Date() });
-                    phaseStarted = true;
-                    const ok = await tryAppendPlanNote(`Attempt ${attempt}: phase.start ${name}`);
-                    if (planRuntime && ok !== undefined) {
-                        emit({
-                            type: 'plan.runtime.journal',
-                            sessionId: planRuntime.sessionId,
-                            phase: name,
-                            kind: 'start',
-                            attempt,
-                            ok,
-                            timestamp: new Date(),
-                        });
-                    }
-                }
-                result = await action(ctx);
-                this.ctxRef.current = result;
-                return result;
+                await appendPlanNote({ persistenceRoot, sessionId: planRuntime.sessionId, note });
+                recordAuditEvent('plan.runtime.note.append', { note, ok: true }, { source: 'plan', severity: 'low', scope: 'session', phase: name });
+                return true;
             }
-            catch (error) {
-                errorStr = error instanceof Error ? error.message : String(error);
-                errorMeta =
-                    typeof error === 'object' && error !== null
-                        ? {
-                            name: error.name,
-                            code: error.code,
-                            llmCode: error.llmCode,
-                        }
-                        : undefined;
-                if (abortedBeforeAction) {
-                    throw error;
-                }
-                // Trigger Recovery
-                const recStart = Date.now();
-                try {
-                    await recovery(ctx);
-                    this.traces.push({
-                        name: `${name}:recovery`,
-                        start: recStart,
-                        end: Date.now(),
-                        duration: Date.now() - recStart,
-                        metadata: { success: true },
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                recordAuditEvent('plan.runtime.note.append.failed', { note, error: msg }, { source: 'plan', severity: 'low', scope: 'session', phase: name });
+                getLogger().debug(`[PlanRuntime] Failed to append note: ${msg}`);
+                return false;
+            }
+        };
+        try {
+            this.ctxRef.current = ctx;
+            const options = isRecord(ctxObj?.options) ? ctxObj.options : null;
+            const signal = options?.signal;
+            const strategy = (workspace?.strategy ?? options?.strategy);
+            if (signal?.aborted && strategy === 'worktree') {
+                throw new Error('Operation cancelled by user');
+            }
+            setAuditContext({ phase: name });
+            if (emit && isPhase(name)) {
+                emit({ type: 'phase.start', phase: name, timestamp: new Date() });
+                phaseStarted = true;
+                const ok = await tryAppendPlanNote(`Attempt ${attempt}: phase.start ${name}`);
+                if (planRuntime && ok !== undefined) {
+                    emit({
+                        type: 'plan.runtime.journal',
+                        sessionId: planRuntime.sessionId,
+                        phase: name,
+                        kind: 'start',
+                        attempt,
+                        ok,
+                        timestamp: new Date(),
                     });
                 }
-                catch (recError) {
-                    const recEnd = Date.now();
-                    const errorDetail = recError instanceof Error ? recError.message : String(recError);
-                    // 1. Record recovery failure to internal traces
-                    this.traces.push({
-                        name: `${name}:recovery`,
-                        start: recStart,
-                        end: recEnd,
-                        duration: recEnd - recStart,
-                        error: errorDetail,
-                        metadata: { success: false, phase: 'RECOVERY_FAILURE' },
-                    });
-                    // 2. Force audit log to disk (persistent storage)
-                    getLogger().audit('PIPELINE_RECOVERY_FAILED', {
-                        step: name,
-                        originalError: errorStr,
-                        recoveryError: errorDetail,
-                    }, { source: 'system', severity: 'high', scope: 'session' });
+            }
+            result = await action(ctx);
+            this.ctxRef.current = result;
+            // Check for structured failures (e.g., APPLY_BACK)
+            const postResult = await onError(ctx, '');
+            if (postResult) {
+                errorStr = postResult.errorStr;
+                errorMeta = postResult.errorMeta;
+            }
+            return result;
+        }
+        catch (error) {
+            errorStr = error instanceof Error ? error.message : String(error);
+            errorMeta =
+                typeof error === 'object' && error !== null
+                    ? {
+                        name: error.name,
+                        code: error.code,
+                        llmCode: error.llmCode,
+                    }
+                    : undefined;
+            // Skip recovery on abort - the operation was cancelled, not failed
+            if (errorStr !== 'Operation cancelled by user') {
+                // Run recovery/post-processing
+                const postResult = await onError(ctx, errorStr);
+                if (postResult?.errorStr) {
+                    errorStr = postResult.errorStr;
+                    errorMeta = postResult.errorMeta;
                 }
-                throw error; // Propagate original error
             }
-            finally {
-                if (emit && isPhase(name) && phaseStarted) {
+            throw error;
+        }
+        finally {
+            if (emit && isPhase(name) && phaseStarted) {
+                emit({ type: 'phase.end', phase: name, success: !errorStr, timestamp: new Date() });
+                const ok = await tryAppendPlanNote(`Attempt ${attempt}: phase.end ${name} (success=${String(!errorStr)})`);
+                if (planRuntime && ok !== undefined) {
                     emit({
-                        type: 'phase.end',
+                        type: 'plan.runtime.journal',
+                        sessionId: planRuntime.sessionId,
                         phase: name,
-                        success: !errorStr,
+                        kind: 'end',
+                        attempt,
+                        ok,
                         timestamp: new Date(),
                     });
-                    const ok = await tryAppendPlanNote(`Attempt ${attempt}: phase.end ${name} (success=${String(!errorStr)})`);
-                    if (planRuntime && ok !== undefined) {
-                        emit({
-                            type: 'plan.runtime.journal',
-                            sessionId: planRuntime.sessionId,
-                            phase: name,
-                            kind: 'end',
-                            attempt,
-                            ok,
-                            timestamp: new Date(),
-                        });
-                    }
                 }
-                setAuditContext({ phase: undefined });
-                const end = Date.now();
-                this.traces.push({
-                    name,
-                    start,
-                    end,
-                    duration: end - start,
-                    error: errorStr,
-                    metadata: errorMeta,
-                });
             }
-        });
-        return new Pipeline(nextPromise, this.startTime, name, this.traces, this.ctxRef);
+            setAuditContext({ phase: undefined });
+            const end = Date.now();
+            this.traces.push({
+                name,
+                start,
+                end,
+                duration: end - start,
+                error: errorStr,
+                metadata: errorMeta,
+            });
+        }
     }
     /**
      * Execute the pipeline and get the final result

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

@@ -5,7 +5,10 @@ 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 { isRecord } from '../../../utils/serialize.js';
 import { classifyError, isRetryable } from '../../../verification/runner.js';
+// Used by non-autopilot modes to determine retry eligibility.
+// Autopilot overrides via finalize() — this set has no effect there.
 const RETRYABLE_PHASES = new Set([
     'CONTEXT',
     'EXPLORE',
@@ -29,7 +32,7 @@ function inferFailurePhase(flowReport) {
     }
     return 'VERIFY';
 }
-function extractErrorCode(error) {
+export function extractErrorCode(error) {
     if (typeof error === 'object' && error !== null) {
         const err = error;
         // Prioritize code (from SalmonError) for better specificity
@@ -49,28 +52,52 @@ function sanitizeReason(value) {
     return mapErrorForDisplay({ message: sanitized }).message;
 }
 function extractInputRequired(error) {
-    if (!error || typeof error !== 'object')
+    if (!isRecord(error))
         return undefined;
     const value = 'inputRequired' in error ? error.inputRequired : error;
-    if (!value || typeof value !== 'object')
+    if (!isRecord(value))
         return undefined;
     if (typeof value.prompt !== 'string' || typeof value.type !== 'string')
         return undefined;
-    return value;
+    const result = { type: value.type, prompt: value.prompt };
+    if (value.reason === 'approval' ||
+        value.reason === 'clarification' ||
+        value.reason === 'reopen') {
+        result.reason = value.reason;
+    }
+    if (Array.isArray(value.questions)) {
+        result.questions = value.questions;
+    }
+    if (typeof value.responseFormat === 'string') {
+        result.responseFormat = value.responseFormat;
+    }
+    return result;
 }
 function extractInterrupt(error) {
-    if (!error || typeof error !== 'object')
+    if (!isRecord(error))
         return undefined;
     const value = error.interrupt;
-    if (!value || typeof value !== 'object')
+    if (!isRecord(value))
         return undefined;
     if (typeof value.type !== 'string')
         return undefined;
-    return value;
+    const result = {
+        type: value.type,
+    };
+    if (typeof value.reason === 'string')
+        result.reason = value.reason;
+    if (typeof value.prompt === 'string')
+        result.prompt = value.prompt;
+    if (isRecord(value.data))
+        result.data = value.data;
+    return result;
 }
 export function resolveAttemptFailure(params) {
     const { flowReport, context, flowMode } = params;
     const profile = resolveExecutionProfile(flowMode);
+    // Autopilot is one-shot: never retry at the transaction-runner level.
+    const finalize = (failure) => flowMode === 'autopilot' ? { ...failure, retryable: false } : failure;
+    const effectiveVerifyPolicy = params.verifyPolicy ?? profile.verifyPolicy;
     const interrupt = extractInterrupt(flowReport.error);
     const interruptCode = extractErrorCode(flowReport.error);
     if (interruptCode === 'INTERRUPT_REQUIRED' && interrupt?.type === 'awaiting_input') {
@@ -92,7 +119,7 @@ export function resolveAttemptFailure(params) {
         };
     }
     const autopilotCompletion = flowMode === 'autopilot' && context && 'completion' in context ? context.completion : undefined;
-    const verifyOk = profile.verifyPolicy === 'never' ? true : context?.verifyResult?.ok !== false;
+    const verifyOk = effectiveVerifyPolicy === 'never' ? true : context?.verifyResult?.ok !== false;
     const applyBackResult = context && 'applyBackResult' in context ? context.applyBackResult : undefined;
     const applyBackFailed = profile.failurePolicy === 'rollback' &&
         applyBackResult?.success === false &&
@@ -122,7 +149,7 @@ export function resolveAttemptFailure(params) {
         return undefined;
     }
     const errorCode = extractErrorCode(flowReport.error) ?? extractErrorCodeFromTraces(flowReport);
-    if (profile.verifyPolicy !== 'never' && context?.verifyResult?.ok === false) {
+    if (effectiveVerifyPolicy !== 'never' && context?.verifyResult?.ok === false) {
         const verifyOutput = context.verifyResult.output || text.loop.loopExecutionFailed;
         const errorType = classifyError(verifyOutput);
         const fallbackReason = sanitizeReason(context.lastError || verifyOutput);
@@ -134,7 +161,7 @@ export function resolveAttemptFailure(params) {
             environmentMode,
             fallbackReason,
         });
-        return {
+        return finalize({
             reason: guidance.safeHint,
             reasonCode: 'VERIFY_FAILED',
             failurePhase: 'VERIFY',
@@ -143,7 +170,7 @@ export function resolveAttemptFailure(params) {
             diagnosticCode: guidance.diagnosticCode,
             safeHint: guidance.safeHint,
             remediationSteps: guidance.remediationSteps,
-        };
+        });
     }
     if (flowMode === 'autopilot' && autopilotCompletion) {
         if (autopilotCompletion.status === 'changed' ||
@@ -151,13 +178,11 @@ export function resolveAttemptFailure(params) {
             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 reasonCode = autopilotCompletion.status === 'tool_failure' &&
+            isRecoverableToolInputErrorCode(autopilotCompletion.errorCode)
+            ? 'TOOL_CORRECTION_REQUIRED'
+            : 'LOOP_FAILED';
+        const failurePhase = 'AUTOPILOT';
         const fallbackReason = autopilotCompletion.reason ||
             (autopilotCompletion.status === 'no_effect'
                 ? 'Autopilot completed without changing files or producing an answer.'
@@ -169,7 +194,7 @@ export function resolveAttemptFailure(params) {
             environmentMode,
             fallbackReason,
         });
-        return {
+        return finalize({
             reason: guidance.safeHint,
             reasonCode,
             failurePhase,
@@ -178,7 +203,7 @@ export function resolveAttemptFailure(params) {
             diagnosticCode: guidance.diagnosticCode,
             safeHint: guidance.safeHint,
             remediationSteps: guidance.remediationSteps,
-        };
+        });
     }
     if (errorCode === 'PREFLIGHT_NOT_GIT') {
         const fallbackReason = sanitizeReason(flowReport.error);
@@ -271,7 +296,7 @@ export function resolveAttemptFailure(params) {
             environmentMode,
             fallbackReason,
         });
-        return {
+        return finalize({
             reason: guidance.safeHint,
             reasonCode: 'TOOL_CORRECTION_REQUIRED',
             failurePhase,
@@ -280,7 +305,7 @@ export function resolveAttemptFailure(params) {
             diagnosticCode: guidance.diagnosticCode,
             safeHint: guidance.safeHint,
             remediationSteps: guidance.remediationSteps,
-        };
+        });
     }
     const guidance = buildFailureGuidance({
         reasonCode: failurePhase === 'ROLLBACK' ? 'ROLLBACK_FAILED' : 'LOOP_FAILED',
@@ -303,7 +328,7 @@ export function resolveAttemptFailure(params) {
             remediationSteps: guidance.remediationSteps,
         };
     }
-    return {
+    return finalize({
         reason: guidance.safeHint,
         reasonCode: 'LOOP_FAILED',
         failurePhase,
@@ -312,6 +337,6 @@ export function resolveAttemptFailure(params) {
         diagnosticCode: guidance.diagnosticCode,
         safeHint: guidance.safeHint,
         remediationSteps: guidance.remediationSteps,
-    };
+    });
 }
 //# sourceMappingURL=attempt-failure.js.map

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

@@ -1,3 +1,4 @@
+import { isRecord } from '../../../utils/serialize.js';
 export function buildAuthorizationSummary(logs) {
     if (!logs || logs.length === 0)
         return null;
@@ -11,7 +12,7 @@ export function buildAuthorizationSummary(logs) {
     };
     let hasEntries = false;
     for (const entry of logs) {
-        if (!entry || entry.eventType !== 'authorization')
+        if (!isRecord(entry) || entry.eventType !== 'authorization')
             continue;
         const source = entry.authSource;
         if (source === 'auto') {