import {

clearAutoFallbackPrimaryProbeSelection,

entryMatchesAutoFallbackPrimaryProbe,

hasLegacyAutoFallbackWithoutOrigin,

hasSessionAutoModelFallbackProvenance,

listAgentIds,

markAutoFallbackPrimaryProbe,

import { prepareInternalSessionEffectsTranscript } from "./internal-session-effects.js";

import { AGENT_LANE_SUBAGENT } from "./lanes.js";

import { LiveSessionModelSwitchError } from "./live-model-switch.js";

import { normalizeConfiguredProviderCatalogModelId } from "./model-ref-shared.js";

import { loadManifestModelCatalog } from "./model-catalog.js";

import { runWithModelFallback } from "./model-fallback.js";

import { normalizeConfiguredProviderCatalogModelId } from "./model-ref-shared.js";

import type { ModelManifestNormalizationContext } from "./model-selection-normalize.js";

import {

buildConfiguredModelCatalog,

: undefined;

const hasStoredAutoFallbackProvenance =

hasStoredOverride && hasSessionAutoModelFallbackProvenance(sessionEntry);

const hasLegacyAutoFallbackOverrideWithoutOrigin =

hasStoredOverride && hasLegacyAutoFallbackWithoutOrigin(sessionEntry);

const explicitProviderOverride =

typeof opts.provider === "string"

? normalizeExplicitOverrideInput(opts.provider, "provider")

!suppressVisibleSessionEffects

) {

const entry = sessionEntry;

if (hasLegacyAutoFallbackOverrideWithoutOrigin) {

const { updated } = applyModelOverrideToSessionEntry({

entry,

selection: { provider: defaultProvider, model: defaultModel, isDefault: true },

});

if (updated) {

storedModelOverrideSource = undefined;

await persistSessionEntry({

sessionStore,

sessionKey,

storePath,

entry,

});

}

}

const repaired = repairProviderWrappedModelOverride({

entry,

defaultProvider,

}

}

const storedProviderOverride = sessionEntry?.providerOverride?.trim();

let storedModelOverride = sessionEntry?.modelOverride?.trim();

const storedProviderOverride = hasLegacyAutoFallbackOverrideWithoutOrigin

? undefined

: sessionEntry?.providerOverride?.trim();

let storedModelOverride = hasLegacyAutoFallbackOverrideWithoutOrigin

? undefined

: sessionEntry?.modelOverride?.trim();

if (storedModelOverride) {

const candidateProvider = storedProviderOverride || defaultProvider;

const normalizedStored = normalizeAgentCommandModelRef(

)

: parseAgentCommandModelRef(cfg, explicitModelOverride, provider, modelManifestContext)

: explicitProviderOverride

? normalizeAgentCommandModelRef(cfg, explicitProviderOverride, model, modelManifestContext)

? normalizeAgentCommandModelRef(

cfg,

explicitProviderOverride,

model,

modelManifestContext,

)

: null;

if (!explicitRef) {

throw new Error("Invalid model override.");