const activeContextEngine = isActiveHarnessContextEngine(params.contextEngine)

? params.contextEngine

: undefined;

const isInactiveThreadBootstrapBinding = (binding: CodexAppServerThreadBinding | undefined) =>

!activeContextEngine && binding?.contextEngine?.projection?.mode === "thread_bootstrap";

let startupBinding = await readCodexAppServerBinding(params.sessionFile);

preDynamicStartupStages.mark("read-binding");

const startupBindingAuthProfileId = startupBinding?.authProfileId;

const initialStartupBindingHadInactiveContextEngine =

!activeContextEngine && Boolean(startupBinding?.contextEngine);

const initialStartupBindingHadInactiveThreadBootstrap =

isInactiveThreadBootstrapBinding(startupBinding);

startupBinding = await rotateOversizedCodexAppServerStartupBinding({

binding: startupBinding,

sessionFile: params.sessionFile,

config: params.config,

contextEngineActive: Boolean(activeContextEngine),

});

const initialInactiveContextEngineBindingForcedFreshStart =

initialStartupBindingHadInactiveContextEngine && !startupBinding?.threadId;

const initialInactiveThreadBootstrapBindingForcedFreshStart =

initialStartupBindingHadInactiveThreadBootstrap && !startupBinding?.threadId;

preDynamicStartupStages.mark("rotate-binding");

const startupAuthProfileCandidate =

params.runtimePlan?.auth.forwardedAuthProfileId ??

let contextEngineProjection: CodexContextEngineThreadBootstrapProjection | undefined;

let precomputedStaleBindingContinuityProjectionApplied = false;

let staleBindingContinuityForcedFreshStart = false;

let inactiveContextEngineBindingForcedFreshStart =

initialInactiveContextEngineBindingForcedFreshStart;

let inactiveThreadBootstrapBindingForcedFreshStart =

initialInactiveThreadBootstrapBindingForcedFreshStart;

const applyFreshThreadContinuityProjection = () => {

const projection = projectContextEngineAssemblyForCodex({

assembledMessages: historyMessages,

if (activeContextEngine || !binding?.threadId) {

return false;

}

if (binding.contextEngine) {

inactiveContextEngineBindingForcedFreshStart = true;

if (isInactiveThreadBootstrapBinding(binding)) {

inactiveThreadBootstrapBindingForcedFreshStart = true;

return false;

}

const projected = applyResumeStaleBindingContinuityProjection(binding);

const applyNoContextEngineContinuityProjection = (

action: "started" | "resumed",

binding?: CodexAppServerThreadBinding,

rotatedContextEngineBinding = false,

) => {

if (activeContextEngine || !historyMessages.some((message) => message.role === "user")) {

return false;

if (action === "started" && staleBindingContinuityForcedFreshStart) {

return true;

}

if (

action === "started" &&

(inactiveContextEngineBindingForcedFreshStart || rotatedContextEngineBinding)

) {

// A retired or changed context-engine binding already forced Codex onto a

// clean native thread; without the engine active, mirrored history would

if (action === "started" && inactiveThreadBootstrapBindingForcedFreshStart) {

// A retired thread-bootstrap context engine already forced Codex onto a

// clean native thread; without that engine active, mirrored history would

// re-inject stale bootstrap context as a new user turn.

return false;

}

return;

}

const previousThreadId = startupBinding.threadId;

const hadInactiveContextEngineBinding =

!activeContextEngine && Boolean(startupBinding.contextEngine);

const hadInactiveThreadBootstrapBinding = isInactiveThreadBootstrapBinding(startupBinding);

const projectedTurnTokens = estimateCodexAppServerProjectedTurnTokens({

prompt: codexTurnPromptText,

developerInstructions: buildRenderedCodexDeveloperInstructions(),

if (startupBinding?.threadId) {

return;

}

inactiveContextEngineBindingForcedFreshStart = hadInactiveContextEngineBinding;

inactiveThreadBootstrapBindingForcedFreshStart = hadInactiveThreadBootstrapBinding;

staleBindingContinuityForcedFreshStart =

precomputedStaleBindingContinuityProjectionApplied &&

!inactiveContextEngineBindingForcedFreshStart;

!inactiveThreadBootstrapBindingForcedFreshStart;

if (activeContextEngine) {

contextEngineProjection = undefined;

try {

params.abortSignal?.removeEventListener("abort", abortFromUpstream);

throw error;

}

if (

applyNoContextEngineContinuityProjection(

thread.lifecycle.action,

thread,

thread.lifecycle.rotatedContextEngineBinding === true,

)

) {

if (applyNoContextEngineContinuityProjection(thread.lifecycle.action, thread)) {

await rebuildCodexTurnPromptTextFromCurrentProjection();

}

trajectoryRecorder?.recordEvent("session.started", {