Persist thread runtime mode and handle mode-switch session restarts

- Add `thread.runtime-mode.set` -> `thread.runtime-mode-set` flow in decider/reactors/projectors
- Persist runtime mode on thread/session projections with new DB migrations
- Update provider and Codex integration tests to verify thread continuity across mode changes
Co-authored-by: codex <codex@users.noreply.github.com>

Author: juliusmarminge

apps/server/integration/OrchestrationEngineHarness.integration.ts

@@ -37,6 +37,8 @@ import { ProviderUnsupportedError } from "../src/provider/Errors.ts";
 import{ProviderAdapterRegistry}from"../src/provider/Services/ProviderAdapterRegistry.ts";
 import{ProviderSessionDirectoryLive}from"../src/provider/Layers/ProviderSessionDirectory.ts";
 import{makeProviderServiceLive}from"../src/provider/Layers/ProviderService.ts";
+import{makeCodexAdapterLive}from"../src/provider/Layers/CodexAdapter.ts";
+import{CodexAdapter}from"../src/provider/Services/CodexAdapter.ts";
 import{ProviderService}from"../src/provider/Services/ProviderService.ts";
 import{CheckpointReactorLive}from"../src/orchestration/Layers/CheckpointReactor.ts";
 import{OrchestrationEngineLive}from"../src/orchestration/Layers/OrchestrationEngine.ts";
@@ -187,6 +189,7 @@ export interface OrchestrationIntegrationHarness {
 
 interfaceMakeOrchestrationIntegrationHarnessOptions{
 readonlyprovider?: "codex"|"claudeCode";
+readonlyrealCodex?: boolean;
 }
 
 exportconstmakeOrchestrationIntegrationHarness=(
@@ -195,10 +198,21 @@ export const makeOrchestrationIntegrationHarness = (
 Effect.gen(function*(){
 constsleep=(ms: number)=>Effect.sleep(ms);
 constprovider=options?.provider??"codex";
-constadapterHarness=yield*makeTestProviderAdapterHarness({
- provider,
-});
-
+constuseRealCodex=options?.realCodex===true;
+constadapterHarness=useRealCodex
+ ? null
+ : yield*makeTestProviderAdapterHarness({
+ provider,
+});
+constfakeRegistry=adapterHarness
+ ? Layer.succeed(ProviderAdapterRegistry,{
+getByProvider: (resolvedProvider)=>
+resolvedProvider===adapterHarness.provider
+ ? Effect.succeed(adapterHarness.adapter)
+ : Effect.fail(newProviderUnsupportedError({provider: resolvedProvider})),
+listProviders: ()=>Effect.succeed([adapterHarness.provider]),
+}astypeofProviderAdapterRegistry.Service)
+ : null;
 constrootDir=fs.mkdtempSync(path.join(os.tmpdir(),"t3-orchestration-integration-"));
 constworkspaceDir=path.join(rootDir,"workspace");
 conststateDir=path.join(rootDir,"state");
@@ -207,14 +221,6 @@ export const makeOrchestrationIntegrationHarness = (
 fs.mkdirSync(stateDir,{recursive: true});
 initializeGitWorkspace(workspaceDir);
 
-constregistry: typeofProviderAdapterRegistry.Service={
-getByProvider: (provider)=>
-provider===adapterHarness.provider
- ? Effect.succeed(adapterHarness.adapter)
- : Effect.fail(newProviderUnsupportedError({ provider })),
-listProviders: ()=>Effect.succeed([adapterHarness.provider]),
-};
-
 constpersistenceLayer=makeSqlitePersistenceLive(dbPath);
 constorchestrationLayer=OrchestrationEngineLive.pipe(
 Layer.provide(OrchestrationProjectionPipelineLive),
@@ -224,10 +230,33 @@ export const makeOrchestrationIntegrationHarness = (
 constproviderSessionDirectoryLayer=ProviderSessionDirectoryLive.pipe(
 Layer.provide(ProviderSessionRuntimeRepositoryLive),
 );
-constproviderLayer=makeProviderServiceLive().pipe(
-Layer.provide(providerSessionDirectoryLayer),
-Layer.provide(Layer.succeed(ProviderAdapterRegistry,registry)),
+constrealCodexRegistry=Layer.effect(
+ProviderAdapterRegistry,
+Effect.gen(function*(){
+constcodexAdapter=yield*CodexAdapter;
+return{
+getByProvider: (resolvedProvider)=>
+resolvedProvider==="codex"
+ ? Effect.succeed(codexAdapter)
+ : Effect.fail(newProviderUnsupportedError({provider: resolvedProvider})),
+listProviders: ()=>Effect.succeed(["codex"]asconst),
+}astypeofProviderAdapterRegistry.Service;
+}),
+).pipe(
+Layer.provide(makeCodexAdapterLive()),
+Layer.provideMerge(ServerConfig.layerTest(workspaceDir,stateDir)),
+Layer.provideMerge(NodeServices.layer),
+Layer.provideMerge(providerSessionDirectoryLayer),
 );
+constproviderLayer=useRealCodex
+ ? makeProviderServiceLive().pipe(
+Layer.provide(providerSessionDirectoryLayer),
+Layer.provide(realCodexRegistry),
+)
+ : makeProviderServiceLive().pipe(
+Layer.provide(providerSessionDirectoryLayer),
+Layer.provide(fakeRegistry!),
+);
 
 construntimeServicesLayer=Layer.mergeAll(
 orchestrationLayer,
@@ -407,8 +436,8 @@ export const makeOrchestrationIntegrationHarness = (
 return{
  rootDir,
  workspaceDir,
- dbPath,
- adapterHarness,
+dbPath,
+adapterHarness: adapterHarnessasTestProviderAdapterHarness,
  engine,
  snapshotQuery,
  providerService,

apps/server/integration/TestProviderAdapter.integration.ts

@@ -264,6 +264,7 @@ export const makeTestProviderAdapterHarness = (options?: MakeTestProviderAdapter
  sessionId,
  provider,
 status: "ready",
+runtimeMode: input.runtimeMode,
  threadId,
 cwd: input.cwd,
 resumeCursor: input.resumeCursor??{ sessionId },

apps/server/integration/orchestrationEngine.integration.test.ts

@@ -97,6 +97,16 @@ function withHarness<A, E>(
 );
 }
 
+functionwithRealCodexHarness<A,E>(
+use: (harness: OrchestrationIntegrationHarness)=>Effect.Effect<A,E>,
+){
+returnEffect.acquireUseRelease(
+makeOrchestrationIntegrationHarness({provider: "codex",realCodex: true}),
+use,
+(harness)=>harness.dispose,
+);
+}
+
 constseedProjectAndThread=(harness: OrchestrationIntegrationHarness)=>
 Effect.gen(function*(){
 constcreatedAt=nowIso();
@@ -118,6 +128,7 @@ const seedProjectAndThread = (harness: OrchestrationIntegrationHarness) =>
 projectId: PROJECT_ID,
 title: "Integration Thread",
 model: "gpt-5-codex",
+runtimeMode: "approval-required",
 branch: null,
 worktreePath: harness.workspaceDir,
  createdAt,
@@ -216,6 +227,97 @@ it.live("runs a single turn end-to-end and persists checkpoint state in sqlite +
 ),
 );
 
+it.live.skipIf(!process.env.CODEX_BINARY_PATH)(
+"keeps the same Codex provider thread across runtime mode switches",
+()=>
+withRealCodexHarness((harness)=>
+Effect.gen(function*(){
+constcreatedAt=nowIso();
+
+yield*harness.engine.dispatch({
+type: "project.create",
+commandId: CommandId.makeUnsafe("cmd-project-create-real-codex"),
+projectId: PROJECT_ID,
+title: "Integration Project",
+workspaceRoot: harness.workspaceDir,
+defaultModel: "gpt-5.3-codex",
+ createdAt,
+});
+
+yield*harness.engine.dispatch({
+type: "thread.create",
+commandId: CommandId.makeUnsafe("cmd-thread-create-real-codex"),
+threadId: THREAD_ID,
+projectId: PROJECT_ID,
+title: "Integration Thread",
+model: "gpt-5.3-codex",
+runtimeMode: "full-access",
+branch: null,
+worktreePath: harness.workspaceDir,
+ createdAt,
+});
+
+yield*harness.engine.dispatch({
+type: "thread.turn.start",
+commandId: CommandId.makeUnsafe("cmd-turn-start-real-codex-1"),
+threadId: THREAD_ID,
+message: {
+messageId: asMessageId("msg-real-codex-1"),
+role: "user",
+text: "Reply with exactly ALPHA.",
+attachments: [],
+},
+runtimeMode: "full-access",
+createdAt: nowIso(),
+});
+
+constfirstThread=yield*harness.waitForThread(
+THREAD_ID,
+(entry)=>
+entry.session?.status==="ready"&&
+entry.session.providerName==="codex"&&
+entry.session.providerThreadId!==null&&
+entry.messages.some(
+(message)=>message.role==="assistant"&&message.streaming===false,
+),
+180_000,
+);
+
+constoriginalProviderThreadId=firstThread.session?.providerThreadId;
+assert.isNotNull(originalProviderThreadId);
+
+yield*harness.engine.dispatch({
+type: "thread.turn.start",
+commandId: CommandId.makeUnsafe("cmd-turn-start-real-codex-2"),
+threadId: THREAD_ID,
+message: {
+messageId: asMessageId("msg-real-codex-2"),
+role: "user",
+text: "Reply with exactly BETA.",
+attachments: [],
+},
+runtimeMode: "approval-required",
+createdAt: nowIso(),
+});
+
+constsecondThread=yield*harness.waitForThread(
+THREAD_ID,
+(entry)=>
+entry.session?.status==="ready"&&
+entry.session.providerName==="codex"&&
+entry.session.providerThreadId!==null&&
+entry.session.runtimeMode==="approval-required"&&
+entry.messages.some(
+(message)=>message.role==="assistant"&&message.text.includes("BETA"),
+),
+180_000,
+);
+
+assert.equal(secondThread.session?.providerThreadId,originalProviderThreadId);
+}),
+),
+);
+
 it.live("runs multi-turn file edits and persists checkpoint diffs",()=>
 withHarness((harness)=>
 Effect.gen(function*(){

apps/server/integration/providerService.integration.test.ts

@@ -122,6 +122,7 @@ it.effect("replays typed runtime fixture events", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -155,6 +156,7 @@ it.effect("replays file-changing fixture turn events", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -192,6 +194,7 @@ it.effect("runs multi-turn tool/approval flow", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -244,6 +247,7 @@ it.effect("rolls back provider conversation state only", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);

apps/server/src/checkpointing/Layers/CheckpointDiffQuery.test.ts

@@ -43,6 +43,7 @@ function makeSnapshot(input: {
 projectId: input.projectId,
 title: "Thread",
 model: "gpt-5-codex",
+runtimeMode: "full-access",
 branch: null,
 worktreePath: input.worktreePath,
 latestTurn: {

apps/server/src/codexAppServerManager.test.ts

@@ -1,4 +1,8 @@
 import{describe,expect,it,vi}from"vitest";
+import{randomUUID}from"node:crypto";
+import{mkdtempSync,rmSync,writeFileSync}from"node:fs";
+importosfrom"node:os";
+importpathfrom"node:path";
 import{ProviderSessionId}from"@t3tools/contracts";
 
 import{
@@ -165,6 +169,7 @@ describe("startSession", () => {
 awaitexpect(
 manager.startSession({
 provider: "codex",
+runtimeMode: "full-access",
 }),
 ).rejects.toThrow("cwd missing");
 expect(events).toHaveLength(1);
@@ -347,3 +352,84 @@ describe("thread checkpoint control", () => {
 });
 });
 });
+
+describe.skipIf(!process.env.CODEX_BINARY_PATH)("startSession live Codex resume",()=>{
+it(
+"keeps prior thread history when resuming with a changed runtime mode",
+async()=>{
+constworkspaceDir=mkdtempSync(path.join(os.tmpdir(),"codex-live-resume-"));
+writeFileSync(path.join(workspaceDir,"README.md"),"hello\n","utf8");
+
+constmanager=newCodexAppServerManager();
+
+try{
+constfirstSession=awaitmanager.startSession({
+provider: "codex",
+cwd: workspaceDir,
+runtimeMode: "full-access",
+providerOptions: {
+codex: {
+binaryPath: process.env.CODEX_BINARY_PATH,
+ ...(process.env.CODEX_HOME_PATH
+ ? {homePath: process.env.CODEX_HOME_PATH}
+ : {}),
+},
+},
+});
+
+constfirstTurn=awaitmanager.sendTurn({
+sessionId: firstSession.sessionId,
+input: `Reply with exactly the word ALPHA ${randomUUID()}`,
+});
+
+expect(firstTurn.threadId).toBe(firstSession.threadId);
+
+awaitvi.waitFor(async()=>{
+constsnapshot=awaitmanager.readThread(firstSession.sessionId);
+expect(snapshot.turns.length).toBeGreaterThan(0);
+},{timeout: 120_000,interval: 1_000});
+
+constfirstSnapshot=awaitmanager.readThread(firstSession.sessionId);
+constoriginalThreadId=firstSnapshot.threadId;
+constoriginalTurnCount=firstSnapshot.turns.length;
+
+manager.stopSession(firstSession.sessionId);
+
+constresumedSession=awaitmanager.startSession({
+provider: "codex",
+cwd: workspaceDir,
+runtimeMode: "approval-required",
+resumeCursor: firstSession.resumeCursor,
+providerOptions: {
+codex: {
+binaryPath: process.env.CODEX_BINARY_PATH,
+ ...(process.env.CODEX_HOME_PATH
+ ? {homePath: process.env.CODEX_HOME_PATH}
+ : {}),
+},
+},
+});
+
+expect(resumedSession.threadId).toBe(originalThreadId);
+
+constresumedSnapshotBeforeTurn=awaitmanager.readThread(resumedSession.sessionId);
+expect(resumedSnapshotBeforeTurn.threadId).toBe(originalThreadId);
+expect(resumedSnapshotBeforeTurn.turns.length).toBeGreaterThanOrEqual(originalTurnCount);
+
+awaitmanager.sendTurn({
+sessionId: resumedSession.sessionId,
+input: `Reply with exactly the word BETA ${randomUUID()}`,
+});
+
+awaitvi.waitFor(async()=>{
+constsnapshot=awaitmanager.readThread(resumedSession.sessionId);
+expect(snapshot.turns.length).toBeGreaterThan(originalTurnCount);
+},{timeout: 120_000,interval: 1_000});
+}finally{
+manager.stopAll();
+rmSync(workspaceDir,{recursive: true,force: true});
+}
+},
+180_000,
+);
+});

apps/server/src/codexAppServerManager.ts

@@ -204,6 +204,7 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
  sessionId,
 provider: "codex",
 status: "connecting",
+runtimeMode: input.runtimeMode,
 model: normalizeCodexModelSlug(input.model),
 cwd: resolvedCwd,
 createdAt: now,

apps/server/integration/OrchestrationEngineHarness.integration.ts

@@ -37,6 +37,8 @@ import { ProviderUnsupportedError } from "../src/provider/Errors.ts";
 import{ProviderAdapterRegistry}from"../src/provider/Services/ProviderAdapterRegistry.ts";
 import{ProviderSessionDirectoryLive}from"../src/provider/Layers/ProviderSessionDirectory.ts";
 import{makeProviderServiceLive}from"../src/provider/Layers/ProviderService.ts";
+import{makeCodexAdapterLive}from"../src/provider/Layers/CodexAdapter.ts";
+import{CodexAdapter}from"../src/provider/Services/CodexAdapter.ts";
 import{ProviderService}from"../src/provider/Services/ProviderService.ts";
 import{CheckpointReactorLive}from"../src/orchestration/Layers/CheckpointReactor.ts";
 import{OrchestrationEngineLive}from"../src/orchestration/Layers/OrchestrationEngine.ts";
@@ -187,6 +189,7 @@ export interface OrchestrationIntegrationHarness {
 
 interfaceMakeOrchestrationIntegrationHarnessOptions{
 readonlyprovider?: "codex"|"claudeCode";
+readonlyrealCodex?: boolean;
 }
 
 exportconstmakeOrchestrationIntegrationHarness=(
@@ -195,10 +198,21 @@ export const makeOrchestrationIntegrationHarness = (
 Effect.gen(function*(){
 constsleep=(ms: number)=>Effect.sleep(ms);
 constprovider=options?.provider??"codex";
-constadapterHarness=yield*makeTestProviderAdapterHarness({
- provider,
-});
-
+constuseRealCodex=options?.realCodex===true;
+constadapterHarness=useRealCodex
+ ? null
+ : yield*makeTestProviderAdapterHarness({
+ provider,
+});
+constfakeRegistry=adapterHarness
+ ? Layer.succeed(ProviderAdapterRegistry,{
+getByProvider: (resolvedProvider)=>
+resolvedProvider===adapterHarness.provider
+ ? Effect.succeed(adapterHarness.adapter)
+ : Effect.fail(newProviderUnsupportedError({provider: resolvedProvider})),
+listProviders: ()=>Effect.succeed([adapterHarness.provider]),
+}astypeofProviderAdapterRegistry.Service)
+ : null;
 constrootDir=fs.mkdtempSync(path.join(os.tmpdir(),"t3-orchestration-integration-"));
 constworkspaceDir=path.join(rootDir,"workspace");
 conststateDir=path.join(rootDir,"state");
@@ -207,14 +221,6 @@ export const makeOrchestrationIntegrationHarness = (
 fs.mkdirSync(stateDir,{recursive: true});
 initializeGitWorkspace(workspaceDir);
 
-constregistry: typeofProviderAdapterRegistry.Service={
-getByProvider: (provider)=>
-provider===adapterHarness.provider
- ? Effect.succeed(adapterHarness.adapter)
- : Effect.fail(newProviderUnsupportedError({ provider })),
-listProviders: ()=>Effect.succeed([adapterHarness.provider]),
-};
-
 constpersistenceLayer=makeSqlitePersistenceLive(dbPath);
 constorchestrationLayer=OrchestrationEngineLive.pipe(
 Layer.provide(OrchestrationProjectionPipelineLive),
@@ -224,10 +230,33 @@ export const makeOrchestrationIntegrationHarness = (
 constproviderSessionDirectoryLayer=ProviderSessionDirectoryLive.pipe(
 Layer.provide(ProviderSessionRuntimeRepositoryLive),
 );
-constproviderLayer=makeProviderServiceLive().pipe(
-Layer.provide(providerSessionDirectoryLayer),
-Layer.provide(Layer.succeed(ProviderAdapterRegistry,registry)),
+constrealCodexRegistry=Layer.effect(
+ProviderAdapterRegistry,
+Effect.gen(function*(){
+constcodexAdapter=yield*CodexAdapter;
+return{
+getByProvider: (resolvedProvider)=>
+resolvedProvider==="codex"
+ ? Effect.succeed(codexAdapter)
+ : Effect.fail(newProviderUnsupportedError({provider: resolvedProvider})),
+listProviders: ()=>Effect.succeed(["codex"]asconst),
+}astypeofProviderAdapterRegistry.Service;
+}),
+).pipe(
+Layer.provide(makeCodexAdapterLive()),
+Layer.provideMerge(ServerConfig.layerTest(workspaceDir,stateDir)),
+Layer.provideMerge(NodeServices.layer),
+Layer.provideMerge(providerSessionDirectoryLayer),
 );
+constproviderLayer=useRealCodex
+ ? makeProviderServiceLive().pipe(
+Layer.provide(providerSessionDirectoryLayer),
+Layer.provide(realCodexRegistry),
+)
+ : makeProviderServiceLive().pipe(
+Layer.provide(providerSessionDirectoryLayer),
+Layer.provide(fakeRegistry!),
+);
 
 construntimeServicesLayer=Layer.mergeAll(
 orchestrationLayer,
@@ -407,8 +436,8 @@ export const makeOrchestrationIntegrationHarness = (
 return{
  rootDir,
  workspaceDir,
- dbPath,
- adapterHarness,
+dbPath,
+adapterHarness: adapterHarnessasTestProviderAdapterHarness,
  engine,
  snapshotQuery,
  providerService,

apps/server/integration/TestProviderAdapter.integration.ts

@@ -264,6 +264,7 @@ export const makeTestProviderAdapterHarness = (options?: MakeTestProviderAdapter
  sessionId,
  provider,
 status: "ready",
+runtimeMode: input.runtimeMode,
  threadId,
 cwd: input.cwd,
 resumeCursor: input.resumeCursor??{ sessionId },

apps/server/integration/orchestrationEngine.integration.test.ts

@@ -97,6 +97,16 @@ function withHarness<A, E>(
 );
 }
 
+functionwithRealCodexHarness<A,E>(
+use: (harness: OrchestrationIntegrationHarness)=>Effect.Effect<A,E>,
+){
+returnEffect.acquireUseRelease(
+makeOrchestrationIntegrationHarness({provider: "codex",realCodex: true}),
+use,
+(harness)=>harness.dispose,
+);
+}
+
 constseedProjectAndThread=(harness: OrchestrationIntegrationHarness)=>
 Effect.gen(function*(){
 constcreatedAt=nowIso();
@@ -118,6 +128,7 @@ const seedProjectAndThread = (harness: OrchestrationIntegrationHarness) =>
 projectId: PROJECT_ID,
 title: "Integration Thread",
 model: "gpt-5-codex",
+runtimeMode: "approval-required",
 branch: null,
 worktreePath: harness.workspaceDir,
  createdAt,
@@ -216,6 +227,97 @@ it.live("runs a single turn end-to-end and persists checkpoint state in sqlite +
 ),
 );
 
+it.live.skipIf(!process.env.CODEX_BINARY_PATH)(
+"keeps the same Codex provider thread across runtime mode switches",
+()=>
+withRealCodexHarness((harness)=>
+Effect.gen(function*(){
+constcreatedAt=nowIso();
+
+yield*harness.engine.dispatch({
+type: "project.create",
+commandId: CommandId.makeUnsafe("cmd-project-create-real-codex"),
+projectId: PROJECT_ID,
+title: "Integration Project",
+workspaceRoot: harness.workspaceDir,
+defaultModel: "gpt-5.3-codex",
+ createdAt,
+});
+
+yield*harness.engine.dispatch({
+type: "thread.create",
+commandId: CommandId.makeUnsafe("cmd-thread-create-real-codex"),
+threadId: THREAD_ID,
+projectId: PROJECT_ID,
+title: "Integration Thread",
+model: "gpt-5.3-codex",
+runtimeMode: "full-access",
+branch: null,
+worktreePath: harness.workspaceDir,
+ createdAt,
+});
+
+yield*harness.engine.dispatch({
+type: "thread.turn.start",
+commandId: CommandId.makeUnsafe("cmd-turn-start-real-codex-1"),
+threadId: THREAD_ID,
+message: {
+messageId: asMessageId("msg-real-codex-1"),
+role: "user",
+text: "Reply with exactly ALPHA.",
+attachments: [],
+},
+runtimeMode: "full-access",
+createdAt: nowIso(),
+});
+
+constfirstThread=yield*harness.waitForThread(
+THREAD_ID,
+(entry)=>
+entry.session?.status==="ready"&&
+entry.session.providerName==="codex"&&
+entry.session.providerThreadId!==null&&
+entry.messages.some(
+(message)=>message.role==="assistant"&&message.streaming===false,
+),
+180_000,
+);
+
+constoriginalProviderThreadId=firstThread.session?.providerThreadId;
+assert.isNotNull(originalProviderThreadId);
+
+yield*harness.engine.dispatch({
+type: "thread.turn.start",
+commandId: CommandId.makeUnsafe("cmd-turn-start-real-codex-2"),
+threadId: THREAD_ID,
+message: {
+messageId: asMessageId("msg-real-codex-2"),
+role: "user",
+text: "Reply with exactly BETA.",
+attachments: [],
+},
+runtimeMode: "approval-required",
+createdAt: nowIso(),
+});
+
+constsecondThread=yield*harness.waitForThread(
+THREAD_ID,
+(entry)=>
+entry.session?.status==="ready"&&
+entry.session.providerName==="codex"&&
+entry.session.providerThreadId!==null&&
+entry.session.runtimeMode==="approval-required"&&
+entry.messages.some(
+(message)=>message.role==="assistant"&&message.text.includes("BETA"),
+),
+180_000,
+);
+
+assert.equal(secondThread.session?.providerThreadId,originalProviderThreadId);
+}),
+),
+);
+
 it.live("runs multi-turn file edits and persists checkpoint diffs",()=>
 withHarness((harness)=>
 Effect.gen(function*(){

apps/server/integration/providerService.integration.test.ts

@@ -122,6 +122,7 @@ it.effect("replays typed runtime fixture events", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -155,6 +156,7 @@ it.effect("replays file-changing fixture turn events", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -192,6 +194,7 @@ it.effect("runs multi-turn tool/approval flow", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -244,6 +247,7 @@ it.effect("rolls back provider conversation state only", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);

apps/server/src/checkpointing/Layers/CheckpointDiffQuery.test.ts

@@ -43,6 +43,7 @@ function makeSnapshot(input: {
 projectId: input.projectId,
 title: "Thread",
 model: "gpt-5-codex",
+runtimeMode: "full-access",
 branch: null,
 worktreePath: input.worktreePath,
 latestTurn: {

apps/server/src/codexAppServerManager.test.ts

@@ -1,4 +1,8 @@
 import{describe,expect,it,vi}from"vitest";
+import{randomUUID}from"node:crypto";
+import{mkdtempSync,rmSync,writeFileSync}from"node:fs";
+importosfrom"node:os";
+importpathfrom"node:path";
 import{ProviderSessionId}from"@t3tools/contracts";
 
 import{
@@ -165,6 +169,7 @@ describe("startSession", () => {
 awaitexpect(
 manager.startSession({
 provider: "codex",
+runtimeMode: "full-access",
 }),
 ).rejects.toThrow("cwd missing");
 expect(events).toHaveLength(1);
@@ -347,3 +352,84 @@ describe("thread checkpoint control", () => {
 });
 });
 });
+
+describe.skipIf(!process.env.CODEX_BINARY_PATH)("startSession live Codex resume",()=>{
+it(
+"keeps prior thread history when resuming with a changed runtime mode",
+async()=>{
+constworkspaceDir=mkdtempSync(path.join(os.tmpdir(),"codex-live-resume-"));
+writeFileSync(path.join(workspaceDir,"README.md"),"hello\n","utf8");
+
+constmanager=newCodexAppServerManager();
+
+try{
+constfirstSession=awaitmanager.startSession({
+provider: "codex",
+cwd: workspaceDir,
+runtimeMode: "full-access",
+providerOptions: {
+codex: {
+binaryPath: process.env.CODEX_BINARY_PATH,
+ ...(process.env.CODEX_HOME_PATH
+ ? {homePath: process.env.CODEX_HOME_PATH}
+ : {}),
+},
+},
+});
+
+constfirstTurn=awaitmanager.sendTurn({
+sessionId: firstSession.sessionId,
+input: `Reply with exactly the word ALPHA ${randomUUID()}`,
+});
+
+expect(firstTurn.threadId).toBe(firstSession.threadId);
+
+awaitvi.waitFor(async()=>{
+constsnapshot=awaitmanager.readThread(firstSession.sessionId);
+expect(snapshot.turns.length).toBeGreaterThan(0);
+},{timeout: 120_000,interval: 1_000});
+
+constfirstSnapshot=awaitmanager.readThread(firstSession.sessionId);
+constoriginalThreadId=firstSnapshot.threadId;
+constoriginalTurnCount=firstSnapshot.turns.length;
+
+manager.stopSession(firstSession.sessionId);
+
+constresumedSession=awaitmanager.startSession({
+provider: "codex",
+cwd: workspaceDir,
+runtimeMode: "approval-required",
+resumeCursor: firstSession.resumeCursor,
+providerOptions: {
+codex: {
+binaryPath: process.env.CODEX_BINARY_PATH,
+ ...(process.env.CODEX_HOME_PATH
+ ? {homePath: process.env.CODEX_HOME_PATH}
+ : {}),
+},
+},
+});
+
+expect(resumedSession.threadId).toBe(originalThreadId);
+
+constresumedSnapshotBeforeTurn=awaitmanager.readThread(resumedSession.sessionId);
+expect(resumedSnapshotBeforeTurn.threadId).toBe(originalThreadId);
+expect(resumedSnapshotBeforeTurn.turns.length).toBeGreaterThanOrEqual(originalTurnCount);
+
+awaitmanager.sendTurn({
+sessionId: resumedSession.sessionId,
+input: `Reply with exactly the word BETA ${randomUUID()}`,
+});
+
+awaitvi.waitFor(async()=>{
+constsnapshot=awaitmanager.readThread(resumedSession.sessionId);
+expect(snapshot.turns.length).toBeGreaterThan(originalTurnCount);
+},{timeout: 120_000,interval: 1_000});
+}finally{
+manager.stopAll();
+rmSync(workspaceDir,{recursive: true,force: true});
+}
+},
+180_000,
+);
+});

apps/server/src/codexAppServerManager.ts

@@ -204,6 +204,7 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
  sessionId,
 provider: "codex",
 status: "connecting",
+runtimeMode: input.runtimeMode,
 model: normalizeCodexModelSlug(input.model),
 cwd: resolvedCwd,
 createdAt: now,

apps/server/integration/OrchestrationEngineHarness.integration.ts

@@ -37,6 +37,8 @@ import { ProviderUnsupportedError } from "../src/provider/Errors.ts";
 import{ProviderAdapterRegistry}from"../src/provider/Services/ProviderAdapterRegistry.ts";
 import{ProviderSessionDirectoryLive}from"../src/provider/Layers/ProviderSessionDirectory.ts";
 import{makeProviderServiceLive}from"../src/provider/Layers/ProviderService.ts";
+import{makeCodexAdapterLive}from"../src/provider/Layers/CodexAdapter.ts";
+import{CodexAdapter}from"../src/provider/Services/CodexAdapter.ts";
 import{ProviderService}from"../src/provider/Services/ProviderService.ts";
 import{CheckpointReactorLive}from"../src/orchestration/Layers/CheckpointReactor.ts";
 import{OrchestrationEngineLive}from"../src/orchestration/Layers/OrchestrationEngine.ts";
@@ -187,6 +189,7 @@ export interface OrchestrationIntegrationHarness {
 
 interfaceMakeOrchestrationIntegrationHarnessOptions{
 readonlyprovider?: "codex"|"claudeCode";
+readonlyrealCodex?: boolean;
 }
 
 exportconstmakeOrchestrationIntegrationHarness=(
@@ -195,10 +198,21 @@ export const makeOrchestrationIntegrationHarness = (
 Effect.gen(function*(){
 constsleep=(ms: number)=>Effect.sleep(ms);
 constprovider=options?.provider??"codex";
-constadapterHarness=yield*makeTestProviderAdapterHarness({
- provider,
-});
-
+constuseRealCodex=options?.realCodex===true;
+constadapterHarness=useRealCodex
+ ? null
+ : yield*makeTestProviderAdapterHarness({
+ provider,
+});
+constfakeRegistry=adapterHarness
+ ? Layer.succeed(ProviderAdapterRegistry,{
+getByProvider: (resolvedProvider)=>
+resolvedProvider===adapterHarness.provider
+ ? Effect.succeed(adapterHarness.adapter)
+ : Effect.fail(newProviderUnsupportedError({provider: resolvedProvider})),
+listProviders: ()=>Effect.succeed([adapterHarness.provider]),
+}astypeofProviderAdapterRegistry.Service)
+ : null;
 constrootDir=fs.mkdtempSync(path.join(os.tmpdir(),"t3-orchestration-integration-"));
 constworkspaceDir=path.join(rootDir,"workspace");
 conststateDir=path.join(rootDir,"state");
@@ -207,14 +221,6 @@ export const makeOrchestrationIntegrationHarness = (
 fs.mkdirSync(stateDir,{recursive: true});
 initializeGitWorkspace(workspaceDir);
 
-constregistry: typeofProviderAdapterRegistry.Service={
-getByProvider: (provider)=>
-provider===adapterHarness.provider
- ? Effect.succeed(adapterHarness.adapter)
- : Effect.fail(newProviderUnsupportedError({ provider })),
-listProviders: ()=>Effect.succeed([adapterHarness.provider]),
-};
-
 constpersistenceLayer=makeSqlitePersistenceLive(dbPath);
 constorchestrationLayer=OrchestrationEngineLive.pipe(
 Layer.provide(OrchestrationProjectionPipelineLive),
@@ -224,10 +230,33 @@ export const makeOrchestrationIntegrationHarness = (
 constproviderSessionDirectoryLayer=ProviderSessionDirectoryLive.pipe(
 Layer.provide(ProviderSessionRuntimeRepositoryLive),
 );
-constproviderLayer=makeProviderServiceLive().pipe(
-Layer.provide(providerSessionDirectoryLayer),
-Layer.provide(Layer.succeed(ProviderAdapterRegistry,registry)),
+constrealCodexRegistry=Layer.effect(
+ProviderAdapterRegistry,
+Effect.gen(function*(){
+constcodexAdapter=yield*CodexAdapter;
+return{
+getByProvider: (resolvedProvider)=>
+resolvedProvider==="codex"
+ ? Effect.succeed(codexAdapter)
+ : Effect.fail(newProviderUnsupportedError({provider: resolvedProvider})),
+listProviders: ()=>Effect.succeed(["codex"]asconst),
+}astypeofProviderAdapterRegistry.Service;
+}),
+).pipe(
+Layer.provide(makeCodexAdapterLive()),
+Layer.provideMerge(ServerConfig.layerTest(workspaceDir,stateDir)),
+Layer.provideMerge(NodeServices.layer),
+Layer.provideMerge(providerSessionDirectoryLayer),
 );
+constproviderLayer=useRealCodex
+ ? makeProviderServiceLive().pipe(
+Layer.provide(providerSessionDirectoryLayer),
+Layer.provide(realCodexRegistry),
+)
+ : makeProviderServiceLive().pipe(
+Layer.provide(providerSessionDirectoryLayer),
+Layer.provide(fakeRegistry!),
+);
 
 construntimeServicesLayer=Layer.mergeAll(
 orchestrationLayer,
@@ -407,8 +436,8 @@ export const makeOrchestrationIntegrationHarness = (
 return{
  rootDir,
  workspaceDir,
- dbPath,
- adapterHarness,
+dbPath,
+adapterHarness: adapterHarnessasTestProviderAdapterHarness,
  engine,
  snapshotQuery,
  providerService,

apps/server/integration/TestProviderAdapter.integration.ts

@@ -264,6 +264,7 @@ export const makeTestProviderAdapterHarness = (options?: MakeTestProviderAdapter
  sessionId,
  provider,
 status: "ready",
+runtimeMode: input.runtimeMode,
  threadId,
 cwd: input.cwd,
 resumeCursor: input.resumeCursor??{ sessionId },

apps/server/integration/orchestrationEngine.integration.test.ts

@@ -97,6 +97,16 @@ function withHarness<A, E>(
 );
 }
 
+functionwithRealCodexHarness<A,E>(
+use: (harness: OrchestrationIntegrationHarness)=>Effect.Effect<A,E>,
+){
+returnEffect.acquireUseRelease(
+makeOrchestrationIntegrationHarness({provider: "codex",realCodex: true}),
+use,
+(harness)=>harness.dispose,
+);
+}
+
 constseedProjectAndThread=(harness: OrchestrationIntegrationHarness)=>
 Effect.gen(function*(){
 constcreatedAt=nowIso();
@@ -118,6 +128,7 @@ const seedProjectAndThread = (harness: OrchestrationIntegrationHarness) =>
 projectId: PROJECT_ID,
 title: "Integration Thread",
 model: "gpt-5-codex",
+runtimeMode: "approval-required",
 branch: null,
 worktreePath: harness.workspaceDir,
  createdAt,
@@ -216,6 +227,97 @@ it.live("runs a single turn end-to-end and persists checkpoint state in sqlite +
 ),
 );
 
+it.live.skipIf(!process.env.CODEX_BINARY_PATH)(
+"keeps the same Codex provider thread across runtime mode switches",
+()=>
+withRealCodexHarness((harness)=>
+Effect.gen(function*(){
+constcreatedAt=nowIso();
+
+yield*harness.engine.dispatch({
+type: "project.create",
+commandId: CommandId.makeUnsafe("cmd-project-create-real-codex"),
+projectId: PROJECT_ID,
+title: "Integration Project",
+workspaceRoot: harness.workspaceDir,
+defaultModel: "gpt-5.3-codex",
+ createdAt,
+});
+
+yield*harness.engine.dispatch({
+type: "thread.create",
+commandId: CommandId.makeUnsafe("cmd-thread-create-real-codex"),
+threadId: THREAD_ID,
+projectId: PROJECT_ID,
+title: "Integration Thread",
+model: "gpt-5.3-codex",
+runtimeMode: "full-access",
+branch: null,
+worktreePath: harness.workspaceDir,
+ createdAt,
+});
+
+yield*harness.engine.dispatch({
+type: "thread.turn.start",
+commandId: CommandId.makeUnsafe("cmd-turn-start-real-codex-1"),
+threadId: THREAD_ID,
+message: {
+messageId: asMessageId("msg-real-codex-1"),
+role: "user",
+text: "Reply with exactly ALPHA.",
+attachments: [],
+},
+runtimeMode: "full-access",
+createdAt: nowIso(),
+});
+
+constfirstThread=yield*harness.waitForThread(
+THREAD_ID,
+(entry)=>
+entry.session?.status==="ready"&&
+entry.session.providerName==="codex"&&
+entry.session.providerThreadId!==null&&
+entry.messages.some(
+(message)=>message.role==="assistant"&&message.streaming===false,
+),
+180_000,
+);
+
+constoriginalProviderThreadId=firstThread.session?.providerThreadId;
+assert.isNotNull(originalProviderThreadId);
+
+yield*harness.engine.dispatch({
+type: "thread.turn.start",
+commandId: CommandId.makeUnsafe("cmd-turn-start-real-codex-2"),
+threadId: THREAD_ID,
+message: {
+messageId: asMessageId("msg-real-codex-2"),
+role: "user",
+text: "Reply with exactly BETA.",
+attachments: [],
+},
+runtimeMode: "approval-required",
+createdAt: nowIso(),
+});
+
+constsecondThread=yield*harness.waitForThread(
+THREAD_ID,
+(entry)=>
+entry.session?.status==="ready"&&
+entry.session.providerName==="codex"&&
+entry.session.providerThreadId!==null&&
+entry.session.runtimeMode==="approval-required"&&
+entry.messages.some(
+(message)=>message.role==="assistant"&&message.text.includes("BETA"),
+),
+180_000,
+);
+
+assert.equal(secondThread.session?.providerThreadId,originalProviderThreadId);
+}),
+),
+);
+
 it.live("runs multi-turn file edits and persists checkpoint diffs",()=>
 withHarness((harness)=>
 Effect.gen(function*(){

apps/server/integration/providerService.integration.test.ts

@@ -122,6 +122,7 @@ it.effect("replays typed runtime fixture events", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -155,6 +156,7 @@ it.effect("replays file-changing fixture turn events", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -192,6 +194,7 @@ it.effect("runs multi-turn tool/approval flow", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -244,6 +247,7 @@ it.effect("rolls back provider conversation state only", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);

apps/server/src/checkpointing/Layers/CheckpointDiffQuery.test.ts

@@ -43,6 +43,7 @@ function makeSnapshot(input: {
 projectId: input.projectId,
 title: "Thread",
 model: "gpt-5-codex",
+runtimeMode: "full-access",
 branch: null,
 worktreePath: input.worktreePath,
 latestTurn: {

apps/server/src/codexAppServerManager.test.ts

@@ -1,4 +1,8 @@
 import{describe,expect,it,vi}from"vitest";
+import{randomUUID}from"node:crypto";
+import{mkdtempSync,rmSync,writeFileSync}from"node:fs";
+importosfrom"node:os";
+importpathfrom"node:path";
 import{ProviderSessionId}from"@t3tools/contracts";
 
 import{
@@ -165,6 +169,7 @@ describe("startSession", () => {
 awaitexpect(
 manager.startSession({
 provider: "codex",
+runtimeMode: "full-access",
 }),
 ).rejects.toThrow("cwd missing");
 expect(events).toHaveLength(1);
@@ -347,3 +352,84 @@ describe("thread checkpoint control", () => {
 });
 });
 });
+
+describe.skipIf(!process.env.CODEX_BINARY_PATH)("startSession live Codex resume",()=>{
+it(
+"keeps prior thread history when resuming with a changed runtime mode",
+async()=>{
+constworkspaceDir=mkdtempSync(path.join(os.tmpdir(),"codex-live-resume-"));
+writeFileSync(path.join(workspaceDir,"README.md"),"hello\n","utf8");
+
+constmanager=newCodexAppServerManager();
+
+try{
+constfirstSession=awaitmanager.startSession({
+provider: "codex",
+cwd: workspaceDir,
+runtimeMode: "full-access",
+providerOptions: {
+codex: {
+binaryPath: process.env.CODEX_BINARY_PATH,
+ ...(process.env.CODEX_HOME_PATH
+ ? {homePath: process.env.CODEX_HOME_PATH}
+ : {}),
+},
+},
+});
+
+constfirstTurn=awaitmanager.sendTurn({
+sessionId: firstSession.sessionId,
+input: `Reply with exactly the word ALPHA ${randomUUID()}`,
+});
+
+expect(firstTurn.threadId).toBe(firstSession.threadId);
+
+awaitvi.waitFor(async()=>{
+constsnapshot=awaitmanager.readThread(firstSession.sessionId);
+expect(snapshot.turns.length).toBeGreaterThan(0);
+},{timeout: 120_000,interval: 1_000});
+
+constfirstSnapshot=awaitmanager.readThread(firstSession.sessionId);
+constoriginalThreadId=firstSnapshot.threadId;
+constoriginalTurnCount=firstSnapshot.turns.length;
+
+manager.stopSession(firstSession.sessionId);
+
+constresumedSession=awaitmanager.startSession({
+provider: "codex",
+cwd: workspaceDir,
+runtimeMode: "approval-required",
+resumeCursor: firstSession.resumeCursor,
+providerOptions: {
+codex: {
+binaryPath: process.env.CODEX_BINARY_PATH,
+ ...(process.env.CODEX_HOME_PATH
+ ? {homePath: process.env.CODEX_HOME_PATH}
+ : {}),
+},
+},
+});
+
+expect(resumedSession.threadId).toBe(originalThreadId);
+
+constresumedSnapshotBeforeTurn=awaitmanager.readThread(resumedSession.sessionId);
+expect(resumedSnapshotBeforeTurn.threadId).toBe(originalThreadId);
+expect(resumedSnapshotBeforeTurn.turns.length).toBeGreaterThanOrEqual(originalTurnCount);
+
+awaitmanager.sendTurn({
+sessionId: resumedSession.sessionId,
+input: `Reply with exactly the word BETA ${randomUUID()}`,
+});
+
+awaitvi.waitFor(async()=>{
+constsnapshot=awaitmanager.readThread(resumedSession.sessionId);
+expect(snapshot.turns.length).toBeGreaterThan(originalTurnCount);
+},{timeout: 120_000,interval: 1_000});
+}finally{
+manager.stopAll();
+rmSync(workspaceDir,{recursive: true,force: true});
+}
+},
+180_000,
+);
+});

apps/server/src/codexAppServerManager.ts

@@ -204,6 +204,7 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
  sessionId,
 provider: "codex",
 status: "connecting",
+runtimeMode: input.runtimeMode,
 model: normalizeCodexModelSlug(input.model),
 cwd: resolvedCwd,
 createdAt: now,

apps/server/integration/OrchestrationEngineHarness.integration.ts

@@ -37,6 +37,8 @@ import { ProviderUnsupportedError } from "../src/provider/Errors.ts";
 import{ProviderAdapterRegistry}from"../src/provider/Services/ProviderAdapterRegistry.ts";
 import{ProviderSessionDirectoryLive}from"../src/provider/Layers/ProviderSessionDirectory.ts";
 import{makeProviderServiceLive}from"../src/provider/Layers/ProviderService.ts";
+import{makeCodexAdapterLive}from"../src/provider/Layers/CodexAdapter.ts";
+import{CodexAdapter}from"../src/provider/Services/CodexAdapter.ts";
 import{ProviderService}from"../src/provider/Services/ProviderService.ts";
 import{CheckpointReactorLive}from"../src/orchestration/Layers/CheckpointReactor.ts";
 import{OrchestrationEngineLive}from"../src/orchestration/Layers/OrchestrationEngine.ts";
@@ -187,6 +189,7 @@ export interface OrchestrationIntegrationHarness {
 
 interfaceMakeOrchestrationIntegrationHarnessOptions{
 readonlyprovider?: "codex"|"claudeCode";
+readonlyrealCodex?: boolean;
 }
 
 exportconstmakeOrchestrationIntegrationHarness=(
@@ -195,10 +198,21 @@ export const makeOrchestrationIntegrationHarness = (
 Effect.gen(function*(){
 constsleep=(ms: number)=>Effect.sleep(ms);
 constprovider=options?.provider??"codex";
-constadapterHarness=yield*makeTestProviderAdapterHarness({
- provider,
-});
-
+constuseRealCodex=options?.realCodex===true;
+constadapterHarness=useRealCodex
+ ? null
+ : yield*makeTestProviderAdapterHarness({
+ provider,
+});
+constfakeRegistry=adapterHarness
+ ? Layer.succeed(ProviderAdapterRegistry,{
+getByProvider: (resolvedProvider)=>
+resolvedProvider===adapterHarness.provider
+ ? Effect.succeed(adapterHarness.adapter)
+ : Effect.fail(newProviderUnsupportedError({provider: resolvedProvider})),
+listProviders: ()=>Effect.succeed([adapterHarness.provider]),
+}astypeofProviderAdapterRegistry.Service)
+ : null;
 constrootDir=fs.mkdtempSync(path.join(os.tmpdir(),"t3-orchestration-integration-"));
 constworkspaceDir=path.join(rootDir,"workspace");
 conststateDir=path.join(rootDir,"state");
@@ -207,14 +221,6 @@ export const makeOrchestrationIntegrationHarness = (
 fs.mkdirSync(stateDir,{recursive: true});
 initializeGitWorkspace(workspaceDir);
 
-constregistry: typeofProviderAdapterRegistry.Service={
-getByProvider: (provider)=>
-provider===adapterHarness.provider
- ? Effect.succeed(adapterHarness.adapter)
- : Effect.fail(newProviderUnsupportedError({ provider })),
-listProviders: ()=>Effect.succeed([adapterHarness.provider]),
-};
-
 constpersistenceLayer=makeSqlitePersistenceLive(dbPath);
 constorchestrationLayer=OrchestrationEngineLive.pipe(
 Layer.provide(OrchestrationProjectionPipelineLive),
@@ -224,10 +230,33 @@ export const makeOrchestrationIntegrationHarness = (
 constproviderSessionDirectoryLayer=ProviderSessionDirectoryLive.pipe(
 Layer.provide(ProviderSessionRuntimeRepositoryLive),
 );
-constproviderLayer=makeProviderServiceLive().pipe(
-Layer.provide(providerSessionDirectoryLayer),
-Layer.provide(Layer.succeed(ProviderAdapterRegistry,registry)),
+constrealCodexRegistry=Layer.effect(
+ProviderAdapterRegistry,
+Effect.gen(function*(){
+constcodexAdapter=yield*CodexAdapter;
+return{
+getByProvider: (resolvedProvider)=>
+resolvedProvider==="codex"
+ ? Effect.succeed(codexAdapter)
+ : Effect.fail(newProviderUnsupportedError({provider: resolvedProvider})),
+listProviders: ()=>Effect.succeed(["codex"]asconst),
+}astypeofProviderAdapterRegistry.Service;
+}),
+).pipe(
+Layer.provide(makeCodexAdapterLive()),
+Layer.provideMerge(ServerConfig.layerTest(workspaceDir,stateDir)),
+Layer.provideMerge(NodeServices.layer),
+Layer.provideMerge(providerSessionDirectoryLayer),
 );
+constproviderLayer=useRealCodex
+ ? makeProviderServiceLive().pipe(
+Layer.provide(providerSessionDirectoryLayer),
+Layer.provide(realCodexRegistry),
+)
+ : makeProviderServiceLive().pipe(
+Layer.provide(providerSessionDirectoryLayer),
+Layer.provide(fakeRegistry!),
+);
 
 construntimeServicesLayer=Layer.mergeAll(
 orchestrationLayer,
@@ -407,8 +436,8 @@ export const makeOrchestrationIntegrationHarness = (
 return{
  rootDir,
  workspaceDir,
- dbPath,
- adapterHarness,
+dbPath,
+adapterHarness: adapterHarnessasTestProviderAdapterHarness,
  engine,
  snapshotQuery,
  providerService,

apps/server/integration/TestProviderAdapter.integration.ts

@@ -264,6 +264,7 @@ export const makeTestProviderAdapterHarness = (options?: MakeTestProviderAdapter
  sessionId,
  provider,
 status: "ready",
+runtimeMode: input.runtimeMode,
  threadId,
 cwd: input.cwd,
 resumeCursor: input.resumeCursor??{ sessionId },

apps/server/integration/orchestrationEngine.integration.test.ts

@@ -97,6 +97,16 @@ function withHarness<A, E>(
 );
 }
 
+functionwithRealCodexHarness<A,E>(
+use: (harness: OrchestrationIntegrationHarness)=>Effect.Effect<A,E>,
+){
+returnEffect.acquireUseRelease(
+makeOrchestrationIntegrationHarness({provider: "codex",realCodex: true}),
+use,
+(harness)=>harness.dispose,
+);
+}
+
 constseedProjectAndThread=(harness: OrchestrationIntegrationHarness)=>
 Effect.gen(function*(){
 constcreatedAt=nowIso();
@@ -118,6 +128,7 @@ const seedProjectAndThread = (harness: OrchestrationIntegrationHarness) =>
 projectId: PROJECT_ID,
 title: "Integration Thread",
 model: "gpt-5-codex",
+runtimeMode: "approval-required",
 branch: null,
 worktreePath: harness.workspaceDir,
  createdAt,
@@ -216,6 +227,97 @@ it.live("runs a single turn end-to-end and persists checkpoint state in sqlite +
 ),
 );
 
+it.live.skipIf(!process.env.CODEX_BINARY_PATH)(
+"keeps the same Codex provider thread across runtime mode switches",
+()=>
+withRealCodexHarness((harness)=>
+Effect.gen(function*(){
+constcreatedAt=nowIso();
+
+yield*harness.engine.dispatch({
+type: "project.create",
+commandId: CommandId.makeUnsafe("cmd-project-create-real-codex"),
+projectId: PROJECT_ID,
+title: "Integration Project",
+workspaceRoot: harness.workspaceDir,
+defaultModel: "gpt-5.3-codex",
+ createdAt,
+});
+
+yield*harness.engine.dispatch({
+type: "thread.create",
+commandId: CommandId.makeUnsafe("cmd-thread-create-real-codex"),
+threadId: THREAD_ID,
+projectId: PROJECT_ID,
+title: "Integration Thread",
+model: "gpt-5.3-codex",
+runtimeMode: "full-access",
+branch: null,
+worktreePath: harness.workspaceDir,
+ createdAt,
+});
+
+yield*harness.engine.dispatch({
+type: "thread.turn.start",
+commandId: CommandId.makeUnsafe("cmd-turn-start-real-codex-1"),
+threadId: THREAD_ID,
+message: {
+messageId: asMessageId("msg-real-codex-1"),
+role: "user",
+text: "Reply with exactly ALPHA.",
+attachments: [],
+},
+runtimeMode: "full-access",
+createdAt: nowIso(),
+});
+
+constfirstThread=yield*harness.waitForThread(
+THREAD_ID,
+(entry)=>
+entry.session?.status==="ready"&&
+entry.session.providerName==="codex"&&
+entry.session.providerThreadId!==null&&
+entry.messages.some(
+(message)=>message.role==="assistant"&&message.streaming===false,
+),
+180_000,
+);
+
+constoriginalProviderThreadId=firstThread.session?.providerThreadId;
+assert.isNotNull(originalProviderThreadId);
+
+yield*harness.engine.dispatch({
+type: "thread.turn.start",
+commandId: CommandId.makeUnsafe("cmd-turn-start-real-codex-2"),
+threadId: THREAD_ID,
+message: {
+messageId: asMessageId("msg-real-codex-2"),
+role: "user",
+text: "Reply with exactly BETA.",
+attachments: [],
+},
+runtimeMode: "approval-required",
+createdAt: nowIso(),
+});
+
+constsecondThread=yield*harness.waitForThread(
+THREAD_ID,
+(entry)=>
+entry.session?.status==="ready"&&
+entry.session.providerName==="codex"&&
+entry.session.providerThreadId!==null&&
+entry.session.runtimeMode==="approval-required"&&
+entry.messages.some(
+(message)=>message.role==="assistant"&&message.text.includes("BETA"),
+),
+180_000,
+);
+
+assert.equal(secondThread.session?.providerThreadId,originalProviderThreadId);
+}),
+),
+);
+
 it.live("runs multi-turn file edits and persists checkpoint diffs",()=>
 withHarness((harness)=>
 Effect.gen(function*(){

apps/server/integration/providerService.integration.test.ts

@@ -122,6 +122,7 @@ it.effect("replays typed runtime fixture events", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -155,6 +156,7 @@ it.effect("replays file-changing fixture turn events", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -192,6 +194,7 @@ it.effect("runs multi-turn tool/approval flow", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -244,6 +247,7 @@ it.effect("rolls back provider conversation state only", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);

apps/server/src/checkpointing/Layers/CheckpointDiffQuery.test.ts

@@ -43,6 +43,7 @@ function makeSnapshot(input: {
 projectId: input.projectId,
 title: "Thread",
 model: "gpt-5-codex",
+runtimeMode: "full-access",
 branch: null,
 worktreePath: input.worktreePath,
 latestTurn: {

apps/server/src/codexAppServerManager.test.ts

@@ -1,4 +1,8 @@
 import{describe,expect,it,vi}from"vitest";
+import{randomUUID}from"node:crypto";
+import{mkdtempSync,rmSync,writeFileSync}from"node:fs";
+importosfrom"node:os";
+importpathfrom"node:path";
 import{ProviderSessionId}from"@t3tools/contracts";
 
 import{
@@ -165,6 +169,7 @@ describe("startSession", () => {
 awaitexpect(
 manager.startSession({
 provider: "codex",
+runtimeMode: "full-access",
 }),
 ).rejects.toThrow("cwd missing");
 expect(events).toHaveLength(1);
@@ -347,3 +352,84 @@ describe("thread checkpoint control", () => {
 });
 });
 });
+
+describe.skipIf(!process.env.CODEX_BINARY_PATH)("startSession live Codex resume",()=>{
+it(
+"keeps prior thread history when resuming with a changed runtime mode",
+async()=>{
+constworkspaceDir=mkdtempSync(path.join(os.tmpdir(),"codex-live-resume-"));
+writeFileSync(path.join(workspaceDir,"README.md"),"hello\n","utf8");
+
+constmanager=newCodexAppServerManager();
+
+try{
+constfirstSession=awaitmanager.startSession({
+provider: "codex",
+cwd: workspaceDir,
+runtimeMode: "full-access",
+providerOptions: {
+codex: {
+binaryPath: process.env.CODEX_BINARY_PATH,
+ ...(process.env.CODEX_HOME_PATH
+ ? {homePath: process.env.CODEX_HOME_PATH}
+ : {}),
+},
+},
+});
+
+constfirstTurn=awaitmanager.sendTurn({
+sessionId: firstSession.sessionId,
+input: `Reply with exactly the word ALPHA ${randomUUID()}`,
+});
+
+expect(firstTurn.threadId).toBe(firstSession.threadId);
+
+awaitvi.waitFor(async()=>{
+constsnapshot=awaitmanager.readThread(firstSession.sessionId);
+expect(snapshot.turns.length).toBeGreaterThan(0);
+},{timeout: 120_000,interval: 1_000});
+
+constfirstSnapshot=awaitmanager.readThread(firstSession.sessionId);
+constoriginalThreadId=firstSnapshot.threadId;
+constoriginalTurnCount=firstSnapshot.turns.length;
+
+manager.stopSession(firstSession.sessionId);
+
+constresumedSession=awaitmanager.startSession({
+provider: "codex",
+cwd: workspaceDir,
+runtimeMode: "approval-required",
+resumeCursor: firstSession.resumeCursor,
+providerOptions: {
+codex: {
+binaryPath: process.env.CODEX_BINARY_PATH,
+ ...(process.env.CODEX_HOME_PATH
+ ? {homePath: process.env.CODEX_HOME_PATH}
+ : {}),
+},
+},
+});
+
+expect(resumedSession.threadId).toBe(originalThreadId);
+
+constresumedSnapshotBeforeTurn=awaitmanager.readThread(resumedSession.sessionId);
+expect(resumedSnapshotBeforeTurn.threadId).toBe(originalThreadId);
+expect(resumedSnapshotBeforeTurn.turns.length).toBeGreaterThanOrEqual(originalTurnCount);
+
+awaitmanager.sendTurn({
+sessionId: resumedSession.sessionId,
+input: `Reply with exactly the word BETA ${randomUUID()}`,
+});
+
+awaitvi.waitFor(async()=>{
+constsnapshot=awaitmanager.readThread(resumedSession.sessionId);
+expect(snapshot.turns.length).toBeGreaterThan(originalTurnCount);
+},{timeout: 120_000,interval: 1_000});
+}finally{
+manager.stopAll();
+rmSync(workspaceDir,{recursive: true,force: true});
+}
+},
+180_000,
+);
+});

apps/server/src/codexAppServerManager.ts

@@ -204,6 +204,7 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
  sessionId,
 provider: "codex",
 status: "connecting",
+runtimeMode: input.runtimeMode,
 model: normalizeCodexModelSlug(input.model),
 cwd: resolvedCwd,
 createdAt: now,

apps/server/integration/OrchestrationEngineHarness.integration.ts

@@ -37,6 +37,8 @@ import { ProviderUnsupportedError } from "../src/provider/Errors.ts";
 import{ProviderAdapterRegistry}from"../src/provider/Services/ProviderAdapterRegistry.ts";
 import{ProviderSessionDirectoryLive}from"../src/provider/Layers/ProviderSessionDirectory.ts";
 import{makeProviderServiceLive}from"../src/provider/Layers/ProviderService.ts";
+import{makeCodexAdapterLive}from"../src/provider/Layers/CodexAdapter.ts";
+import{CodexAdapter}from"../src/provider/Services/CodexAdapter.ts";
 import{ProviderService}from"../src/provider/Services/ProviderService.ts";
 import{CheckpointReactorLive}from"../src/orchestration/Layers/CheckpointReactor.ts";
 import{OrchestrationEngineLive}from"../src/orchestration/Layers/OrchestrationEngine.ts";
@@ -187,6 +189,7 @@ export interface OrchestrationIntegrationHarness {
 
 interfaceMakeOrchestrationIntegrationHarnessOptions{
 readonlyprovider?: "codex"|"claudeCode";
+readonlyrealCodex?: boolean;
 }
 
 exportconstmakeOrchestrationIntegrationHarness=(
@@ -195,10 +198,21 @@ export const makeOrchestrationIntegrationHarness = (
 Effect.gen(function*(){
 constsleep=(ms: number)=>Effect.sleep(ms);
 constprovider=options?.provider??"codex";
-constadapterHarness=yield*makeTestProviderAdapterHarness({
- provider,
-});
-
+constuseRealCodex=options?.realCodex===true;
+constadapterHarness=useRealCodex
+ ? null
+ : yield*makeTestProviderAdapterHarness({
+ provider,
+});
+constfakeRegistry=adapterHarness
+ ? Layer.succeed(ProviderAdapterRegistry,{
+getByProvider: (resolvedProvider)=>
+resolvedProvider===adapterHarness.provider
+ ? Effect.succeed(adapterHarness.adapter)
+ : Effect.fail(newProviderUnsupportedError({provider: resolvedProvider})),
+listProviders: ()=>Effect.succeed([adapterHarness.provider]),
+}astypeofProviderAdapterRegistry.Service)
+ : null;
 constrootDir=fs.mkdtempSync(path.join(os.tmpdir(),"t3-orchestration-integration-"));
 constworkspaceDir=path.join(rootDir,"workspace");
 conststateDir=path.join(rootDir,"state");
@@ -207,14 +221,6 @@ export const makeOrchestrationIntegrationHarness = (
 fs.mkdirSync(stateDir,{recursive: true});
 initializeGitWorkspace(workspaceDir);
 
-constregistry: typeofProviderAdapterRegistry.Service={
-getByProvider: (provider)=>
-provider===adapterHarness.provider
- ? Effect.succeed(adapterHarness.adapter)
- : Effect.fail(newProviderUnsupportedError({ provider })),
-listProviders: ()=>Effect.succeed([adapterHarness.provider]),
-};
-
 constpersistenceLayer=makeSqlitePersistenceLive(dbPath);
 constorchestrationLayer=OrchestrationEngineLive.pipe(
 Layer.provide(OrchestrationProjectionPipelineLive),
@@ -224,10 +230,33 @@ export const makeOrchestrationIntegrationHarness = (
 constproviderSessionDirectoryLayer=ProviderSessionDirectoryLive.pipe(
 Layer.provide(ProviderSessionRuntimeRepositoryLive),
 );
-constproviderLayer=makeProviderServiceLive().pipe(
-Layer.provide(providerSessionDirectoryLayer),
-Layer.provide(Layer.succeed(ProviderAdapterRegistry,registry)),
+constrealCodexRegistry=Layer.effect(
+ProviderAdapterRegistry,
+Effect.gen(function*(){
+constcodexAdapter=yield*CodexAdapter;
+return{
+getByProvider: (resolvedProvider)=>
+resolvedProvider==="codex"
+ ? Effect.succeed(codexAdapter)
+ : Effect.fail(newProviderUnsupportedError({provider: resolvedProvider})),
+listProviders: ()=>Effect.succeed(["codex"]asconst),
+}astypeofProviderAdapterRegistry.Service;
+}),
+).pipe(
+Layer.provide(makeCodexAdapterLive()),
+Layer.provideMerge(ServerConfig.layerTest(workspaceDir,stateDir)),
+Layer.provideMerge(NodeServices.layer),
+Layer.provideMerge(providerSessionDirectoryLayer),
 );
+constproviderLayer=useRealCodex
+ ? makeProviderServiceLive().pipe(
+Layer.provide(providerSessionDirectoryLayer),
+Layer.provide(realCodexRegistry),
+)
+ : makeProviderServiceLive().pipe(
+Layer.provide(providerSessionDirectoryLayer),
+Layer.provide(fakeRegistry!),
+);
 
 construntimeServicesLayer=Layer.mergeAll(
 orchestrationLayer,
@@ -407,8 +436,8 @@ export const makeOrchestrationIntegrationHarness = (
 return{
  rootDir,
  workspaceDir,
- dbPath,
- adapterHarness,
+dbPath,
+adapterHarness: adapterHarnessasTestProviderAdapterHarness,
  engine,
  snapshotQuery,
  providerService,

apps/server/integration/TestProviderAdapter.integration.ts

@@ -264,6 +264,7 @@ export const makeTestProviderAdapterHarness = (options?: MakeTestProviderAdapter
  sessionId,
  provider,
 status: "ready",
+runtimeMode: input.runtimeMode,
  threadId,
 cwd: input.cwd,
 resumeCursor: input.resumeCursor??{ sessionId },

apps/server/integration/orchestrationEngine.integration.test.ts

@@ -97,6 +97,16 @@ function withHarness<A, E>(
 );
 }
 
+functionwithRealCodexHarness<A,E>(
+use: (harness: OrchestrationIntegrationHarness)=>Effect.Effect<A,E>,
+){
+returnEffect.acquireUseRelease(
+makeOrchestrationIntegrationHarness({provider: "codex",realCodex: true}),
+use,
+(harness)=>harness.dispose,
+);
+}
+
 constseedProjectAndThread=(harness: OrchestrationIntegrationHarness)=>
 Effect.gen(function*(){
 constcreatedAt=nowIso();
@@ -118,6 +128,7 @@ const seedProjectAndThread = (harness: OrchestrationIntegrationHarness) =>
 projectId: PROJECT_ID,
 title: "Integration Thread",
 model: "gpt-5-codex",
+runtimeMode: "approval-required",
 branch: null,
 worktreePath: harness.workspaceDir,
  createdAt,
@@ -216,6 +227,97 @@ it.live("runs a single turn end-to-end and persists checkpoint state in sqlite +
 ),
 );
 
+it.live.skipIf(!process.env.CODEX_BINARY_PATH)(
+"keeps the same Codex provider thread across runtime mode switches",
+()=>
+withRealCodexHarness((harness)=>
+Effect.gen(function*(){
+constcreatedAt=nowIso();
+
+yield*harness.engine.dispatch({
+type: "project.create",
+commandId: CommandId.makeUnsafe("cmd-project-create-real-codex"),
+projectId: PROJECT_ID,
+title: "Integration Project",
+workspaceRoot: harness.workspaceDir,
+defaultModel: "gpt-5.3-codex",
+ createdAt,
+});
+
+yield*harness.engine.dispatch({
+type: "thread.create",
+commandId: CommandId.makeUnsafe("cmd-thread-create-real-codex"),
+threadId: THREAD_ID,
+projectId: PROJECT_ID,
+title: "Integration Thread",
+model: "gpt-5.3-codex",
+runtimeMode: "full-access",
+branch: null,
+worktreePath: harness.workspaceDir,
+ createdAt,
+});
+
+yield*harness.engine.dispatch({
+type: "thread.turn.start",
+commandId: CommandId.makeUnsafe("cmd-turn-start-real-codex-1"),
+threadId: THREAD_ID,
+message: {
+messageId: asMessageId("msg-real-codex-1"),
+role: "user",
+text: "Reply with exactly ALPHA.",
+attachments: [],
+},
+runtimeMode: "full-access",
+createdAt: nowIso(),
+});
+
+constfirstThread=yield*harness.waitForThread(
+THREAD_ID,
+(entry)=>
+entry.session?.status==="ready"&&
+entry.session.providerName==="codex"&&
+entry.session.providerThreadId!==null&&
+entry.messages.some(
+(message)=>message.role==="assistant"&&message.streaming===false,
+),
+180_000,
+);
+
+constoriginalProviderThreadId=firstThread.session?.providerThreadId;
+assert.isNotNull(originalProviderThreadId);
+
+yield*harness.engine.dispatch({
+type: "thread.turn.start",
+commandId: CommandId.makeUnsafe("cmd-turn-start-real-codex-2"),
+threadId: THREAD_ID,
+message: {
+messageId: asMessageId("msg-real-codex-2"),
+role: "user",
+text: "Reply with exactly BETA.",
+attachments: [],
+},
+runtimeMode: "approval-required",
+createdAt: nowIso(),
+});
+
+constsecondThread=yield*harness.waitForThread(
+THREAD_ID,
+(entry)=>
+entry.session?.status==="ready"&&
+entry.session.providerName==="codex"&&
+entry.session.providerThreadId!==null&&
+entry.session.runtimeMode==="approval-required"&&
+entry.messages.some(
+(message)=>message.role==="assistant"&&message.text.includes("BETA"),
+),
+180_000,
+);
+
+assert.equal(secondThread.session?.providerThreadId,originalProviderThreadId);
+}),
+),
+);
+
 it.live("runs multi-turn file edits and persists checkpoint diffs",()=>
 withHarness((harness)=>
 Effect.gen(function*(){

apps/server/integration/providerService.integration.test.ts

@@ -122,6 +122,7 @@ it.effect("replays typed runtime fixture events", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -155,6 +156,7 @@ it.effect("replays file-changing fixture turn events", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -192,6 +194,7 @@ it.effect("runs multi-turn tool/approval flow", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -244,6 +247,7 @@ it.effect("rolls back provider conversation state only", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);

apps/server/src/checkpointing/Layers/CheckpointDiffQuery.test.ts

@@ -43,6 +43,7 @@ function makeSnapshot(input: {
 projectId: input.projectId,
 title: "Thread",
 model: "gpt-5-codex",
+runtimeMode: "full-access",
 branch: null,
 worktreePath: input.worktreePath,
 latestTurn: {

apps/server/src/codexAppServerManager.test.ts

@@ -1,4 +1,8 @@
 import{describe,expect,it,vi}from"vitest";
+import{randomUUID}from"node:crypto";
+import{mkdtempSync,rmSync,writeFileSync}from"node:fs";
+importosfrom"node:os";
+importpathfrom"node:path";
 import{ProviderSessionId}from"@t3tools/contracts";
 
 import{
@@ -165,6 +169,7 @@ describe("startSession", () => {
 awaitexpect(
 manager.startSession({
 provider: "codex",
+runtimeMode: "full-access",
 }),
 ).rejects.toThrow("cwd missing");
 expect(events).toHaveLength(1);
@@ -347,3 +352,84 @@ describe("thread checkpoint control", () => {
 });
 });
 });
+
+describe.skipIf(!process.env.CODEX_BINARY_PATH)("startSession live Codex resume",()=>{
+it(
+"keeps prior thread history when resuming with a changed runtime mode",
+async()=>{
+constworkspaceDir=mkdtempSync(path.join(os.tmpdir(),"codex-live-resume-"));
+writeFileSync(path.join(workspaceDir,"README.md"),"hello\n","utf8");
+
+constmanager=newCodexAppServerManager();
+
+try{
+constfirstSession=awaitmanager.startSession({
+provider: "codex",
+cwd: workspaceDir,
+runtimeMode: "full-access",
+providerOptions: {
+codex: {
+binaryPath: process.env.CODEX_BINARY_PATH,
+ ...(process.env.CODEX_HOME_PATH
+ ? {homePath: process.env.CODEX_HOME_PATH}
+ : {}),
+},
+},
+});
+
+constfirstTurn=awaitmanager.sendTurn({
+sessionId: firstSession.sessionId,
+input: `Reply with exactly the word ALPHA ${randomUUID()}`,
+});
+
+expect(firstTurn.threadId).toBe(firstSession.threadId);
+
+awaitvi.waitFor(async()=>{
+constsnapshot=awaitmanager.readThread(firstSession.sessionId);
+expect(snapshot.turns.length).toBeGreaterThan(0);
+},{timeout: 120_000,interval: 1_000});
+
+constfirstSnapshot=awaitmanager.readThread(firstSession.sessionId);
+constoriginalThreadId=firstSnapshot.threadId;
+constoriginalTurnCount=firstSnapshot.turns.length;
+
+manager.stopSession(firstSession.sessionId);
+
+constresumedSession=awaitmanager.startSession({
+provider: "codex",
+cwd: workspaceDir,
+runtimeMode: "approval-required",
+resumeCursor: firstSession.resumeCursor,
+providerOptions: {
+codex: {
+binaryPath: process.env.CODEX_BINARY_PATH,
+ ...(process.env.CODEX_HOME_PATH
+ ? {homePath: process.env.CODEX_HOME_PATH}
+ : {}),
+},
+},
+});
+
+expect(resumedSession.threadId).toBe(originalThreadId);
+
+constresumedSnapshotBeforeTurn=awaitmanager.readThread(resumedSession.sessionId);
+expect(resumedSnapshotBeforeTurn.threadId).toBe(originalThreadId);
+expect(resumedSnapshotBeforeTurn.turns.length).toBeGreaterThanOrEqual(originalTurnCount);
+
+awaitmanager.sendTurn({
+sessionId: resumedSession.sessionId,
+input: `Reply with exactly the word BETA ${randomUUID()}`,
+});
+
+awaitvi.waitFor(async()=>{
+constsnapshot=awaitmanager.readThread(resumedSession.sessionId);
+expect(snapshot.turns.length).toBeGreaterThan(originalTurnCount);
+},{timeout: 120_000,interval: 1_000});
+}finally{
+manager.stopAll();
+rmSync(workspaceDir,{recursive: true,force: true});
+}
+},
+180_000,
+);
+});

apps/server/src/codexAppServerManager.ts

@@ -204,6 +204,7 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
  sessionId,
 provider: "codex",
 status: "connecting",
+runtimeMode: input.runtimeMode,
 model: normalizeCodexModelSlug(input.model),
 cwd: resolvedCwd,
 createdAt: now,

apps/server/integration/OrchestrationEngineHarness.integration.ts

@@ -37,6 +37,8 @@ import { ProviderUnsupportedError } from "../src/provider/Errors.ts";
 import{ProviderAdapterRegistry}from"../src/provider/Services/ProviderAdapterRegistry.ts";
 import{ProviderSessionDirectoryLive}from"../src/provider/Layers/ProviderSessionDirectory.ts";
 import{makeProviderServiceLive}from"../src/provider/Layers/ProviderService.ts";
+import{makeCodexAdapterLive}from"../src/provider/Layers/CodexAdapter.ts";
+import{CodexAdapter}from"../src/provider/Services/CodexAdapter.ts";
 import{ProviderService}from"../src/provider/Services/ProviderService.ts";
 import{CheckpointReactorLive}from"../src/orchestration/Layers/CheckpointReactor.ts";
 import{OrchestrationEngineLive}from"../src/orchestration/Layers/OrchestrationEngine.ts";
@@ -187,6 +189,7 @@ export interface OrchestrationIntegrationHarness {
 
 interfaceMakeOrchestrationIntegrationHarnessOptions{
 readonlyprovider?: "codex"|"claudeCode";
+readonlyrealCodex?: boolean;
 }
 
 exportconstmakeOrchestrationIntegrationHarness=(
@@ -195,10 +198,21 @@ export const makeOrchestrationIntegrationHarness = (
 Effect.gen(function*(){
 constsleep=(ms: number)=>Effect.sleep(ms);
 constprovider=options?.provider??"codex";
-constadapterHarness=yield*makeTestProviderAdapterHarness({
- provider,
-});
-
+constuseRealCodex=options?.realCodex===true;
+constadapterHarness=useRealCodex
+ ? null
+ : yield*makeTestProviderAdapterHarness({
+ provider,
+});
+constfakeRegistry=adapterHarness
+ ? Layer.succeed(ProviderAdapterRegistry,{
+getByProvider: (resolvedProvider)=>
+resolvedProvider===adapterHarness.provider
+ ? Effect.succeed(adapterHarness.adapter)
+ : Effect.fail(newProviderUnsupportedError({provider: resolvedProvider})),
+listProviders: ()=>Effect.succeed([adapterHarness.provider]),
+}astypeofProviderAdapterRegistry.Service)
+ : null;
 constrootDir=fs.mkdtempSync(path.join(os.tmpdir(),"t3-orchestration-integration-"));
 constworkspaceDir=path.join(rootDir,"workspace");
 conststateDir=path.join(rootDir,"state");
@@ -207,14 +221,6 @@ export const makeOrchestrationIntegrationHarness = (
 fs.mkdirSync(stateDir,{recursive: true});
 initializeGitWorkspace(workspaceDir);
 
-constregistry: typeofProviderAdapterRegistry.Service={
-getByProvider: (provider)=>
-provider===adapterHarness.provider
- ? Effect.succeed(adapterHarness.adapter)
- : Effect.fail(newProviderUnsupportedError({ provider })),
-listProviders: ()=>Effect.succeed([adapterHarness.provider]),
-};
-
 constpersistenceLayer=makeSqlitePersistenceLive(dbPath);
 constorchestrationLayer=OrchestrationEngineLive.pipe(
 Layer.provide(OrchestrationProjectionPipelineLive),
@@ -224,10 +230,33 @@ export const makeOrchestrationIntegrationHarness = (
 constproviderSessionDirectoryLayer=ProviderSessionDirectoryLive.pipe(
 Layer.provide(ProviderSessionRuntimeRepositoryLive),
 );
-constproviderLayer=makeProviderServiceLive().pipe(
-Layer.provide(providerSessionDirectoryLayer),
-Layer.provide(Layer.succeed(ProviderAdapterRegistry,registry)),
+constrealCodexRegistry=Layer.effect(
+ProviderAdapterRegistry,
+Effect.gen(function*(){
+constcodexAdapter=yield*CodexAdapter;
+return{
+getByProvider: (resolvedProvider)=>
+resolvedProvider==="codex"
+ ? Effect.succeed(codexAdapter)
+ : Effect.fail(newProviderUnsupportedError({provider: resolvedProvider})),
+listProviders: ()=>Effect.succeed(["codex"]asconst),
+}astypeofProviderAdapterRegistry.Service;
+}),
+).pipe(
+Layer.provide(makeCodexAdapterLive()),
+Layer.provideMerge(ServerConfig.layerTest(workspaceDir,stateDir)),
+Layer.provideMerge(NodeServices.layer),
+Layer.provideMerge(providerSessionDirectoryLayer),
 );
+constproviderLayer=useRealCodex
+ ? makeProviderServiceLive().pipe(
+Layer.provide(providerSessionDirectoryLayer),
+Layer.provide(realCodexRegistry),
+)
+ : makeProviderServiceLive().pipe(
+Layer.provide(providerSessionDirectoryLayer),
+Layer.provide(fakeRegistry!),
+);
 
 construntimeServicesLayer=Layer.mergeAll(
 orchestrationLayer,
@@ -407,8 +436,8 @@ export const makeOrchestrationIntegrationHarness = (
 return{
  rootDir,
  workspaceDir,
- dbPath,
- adapterHarness,
+dbPath,
+adapterHarness: adapterHarnessasTestProviderAdapterHarness,
  engine,
  snapshotQuery,
  providerService,

apps/server/integration/TestProviderAdapter.integration.ts

@@ -264,6 +264,7 @@ export const makeTestProviderAdapterHarness = (options?: MakeTestProviderAdapter
  sessionId,
  provider,
 status: "ready",
+runtimeMode: input.runtimeMode,
  threadId,
 cwd: input.cwd,
 resumeCursor: input.resumeCursor??{ sessionId },

apps/server/integration/orchestrationEngine.integration.test.ts

@@ -97,6 +97,16 @@ function withHarness<A, E>(
 );
 }
 
+functionwithRealCodexHarness<A,E>(
+use: (harness: OrchestrationIntegrationHarness)=>Effect.Effect<A,E>,
+){
+returnEffect.acquireUseRelease(
+makeOrchestrationIntegrationHarness({provider: "codex",realCodex: true}),
+use,
+(harness)=>harness.dispose,
+);
+}
+
 constseedProjectAndThread=(harness: OrchestrationIntegrationHarness)=>
 Effect.gen(function*(){
 constcreatedAt=nowIso();
@@ -118,6 +128,7 @@ const seedProjectAndThread = (harness: OrchestrationIntegrationHarness) =>
 projectId: PROJECT_ID,
 title: "Integration Thread",
 model: "gpt-5-codex",
+runtimeMode: "approval-required",
 branch: null,
 worktreePath: harness.workspaceDir,
  createdAt,
@@ -216,6 +227,97 @@ it.live("runs a single turn end-to-end and persists checkpoint state in sqlite +
 ),
 );
 
+it.live.skipIf(!process.env.CODEX_BINARY_PATH)(
+"keeps the same Codex provider thread across runtime mode switches",
+()=>
+withRealCodexHarness((harness)=>
+Effect.gen(function*(){
+constcreatedAt=nowIso();
+
+yield*harness.engine.dispatch({
+type: "project.create",
+commandId: CommandId.makeUnsafe("cmd-project-create-real-codex"),
+projectId: PROJECT_ID,
+title: "Integration Project",
+workspaceRoot: harness.workspaceDir,
+defaultModel: "gpt-5.3-codex",
+ createdAt,
+});
+
+yield*harness.engine.dispatch({
+type: "thread.create",
+commandId: CommandId.makeUnsafe("cmd-thread-create-real-codex"),
+threadId: THREAD_ID,
+projectId: PROJECT_ID,
+title: "Integration Thread",
+model: "gpt-5.3-codex",
+runtimeMode: "full-access",
+branch: null,
+worktreePath: harness.workspaceDir,
+ createdAt,
+});
+
+yield*harness.engine.dispatch({
+type: "thread.turn.start",
+commandId: CommandId.makeUnsafe("cmd-turn-start-real-codex-1"),
+threadId: THREAD_ID,
+message: {
+messageId: asMessageId("msg-real-codex-1"),
+role: "user",
+text: "Reply with exactly ALPHA.",
+attachments: [],
+},
+runtimeMode: "full-access",
+createdAt: nowIso(),
+});
+
+constfirstThread=yield*harness.waitForThread(
+THREAD_ID,
+(entry)=>
+entry.session?.status==="ready"&&
+entry.session.providerName==="codex"&&
+entry.session.providerThreadId!==null&&
+entry.messages.some(
+(message)=>message.role==="assistant"&&message.streaming===false,
+),
+180_000,
+);
+
+constoriginalProviderThreadId=firstThread.session?.providerThreadId;
+assert.isNotNull(originalProviderThreadId);
+
+yield*harness.engine.dispatch({
+type: "thread.turn.start",
+commandId: CommandId.makeUnsafe("cmd-turn-start-real-codex-2"),
+threadId: THREAD_ID,
+message: {
+messageId: asMessageId("msg-real-codex-2"),
+role: "user",
+text: "Reply with exactly BETA.",
+attachments: [],
+},
+runtimeMode: "approval-required",
+createdAt: nowIso(),
+});
+
+constsecondThread=yield*harness.waitForThread(
+THREAD_ID,
+(entry)=>
+entry.session?.status==="ready"&&
+entry.session.providerName==="codex"&&
+entry.session.providerThreadId!==null&&
+entry.session.runtimeMode==="approval-required"&&
+entry.messages.some(
+(message)=>message.role==="assistant"&&message.text.includes("BETA"),
+),
+180_000,
+);
+
+assert.equal(secondThread.session?.providerThreadId,originalProviderThreadId);
+}),
+),
+);
+
 it.live("runs multi-turn file edits and persists checkpoint diffs",()=>
 withHarness((harness)=>
 Effect.gen(function*(){

apps/server/integration/providerService.integration.test.ts

@@ -122,6 +122,7 @@ it.effect("replays typed runtime fixture events", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -155,6 +156,7 @@ it.effect("replays file-changing fixture turn events", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -192,6 +194,7 @@ it.effect("runs multi-turn tool/approval flow", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -244,6 +247,7 @@ it.effect("rolls back provider conversation state only", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);

apps/server/src/checkpointing/Layers/CheckpointDiffQuery.test.ts

@@ -43,6 +43,7 @@ function makeSnapshot(input: {
 projectId: input.projectId,
 title: "Thread",
 model: "gpt-5-codex",
+runtimeMode: "full-access",
 branch: null,
 worktreePath: input.worktreePath,
 latestTurn: {

apps/server/src/codexAppServerManager.test.ts

@@ -1,4 +1,8 @@
 import{describe,expect,it,vi}from"vitest";
+import{randomUUID}from"node:crypto";
+import{mkdtempSync,rmSync,writeFileSync}from"node:fs";
+importosfrom"node:os";
+importpathfrom"node:path";
 import{ProviderSessionId}from"@t3tools/contracts";
 
 import{
@@ -165,6 +169,7 @@ describe("startSession", () => {
 awaitexpect(
 manager.startSession({
 provider: "codex",
+runtimeMode: "full-access",
 }),
 ).rejects.toThrow("cwd missing");
 expect(events).toHaveLength(1);
@@ -347,3 +352,84 @@ describe("thread checkpoint control", () => {
 });
 });
 });
+
+describe.skipIf(!process.env.CODEX_BINARY_PATH)("startSession live Codex resume",()=>{
+it(
+"keeps prior thread history when resuming with a changed runtime mode",
+async()=>{
+constworkspaceDir=mkdtempSync(path.join(os.tmpdir(),"codex-live-resume-"));
+writeFileSync(path.join(workspaceDir,"README.md"),"hello\n","utf8");
+
+constmanager=newCodexAppServerManager();
+
+try{
+constfirstSession=awaitmanager.startSession({
+provider: "codex",
+cwd: workspaceDir,
+runtimeMode: "full-access",
+providerOptions: {
+codex: {
+binaryPath: process.env.CODEX_BINARY_PATH,
+ ...(process.env.CODEX_HOME_PATH
+ ? {homePath: process.env.CODEX_HOME_PATH}
+ : {}),
+},
+},
+});
+
+constfirstTurn=awaitmanager.sendTurn({
+sessionId: firstSession.sessionId,
+input: `Reply with exactly the word ALPHA ${randomUUID()}`,
+});
+
+expect(firstTurn.threadId).toBe(firstSession.threadId);
+
+awaitvi.waitFor(async()=>{
+constsnapshot=awaitmanager.readThread(firstSession.sessionId);
+expect(snapshot.turns.length).toBeGreaterThan(0);
+},{timeout: 120_000,interval: 1_000});
+
+constfirstSnapshot=awaitmanager.readThread(firstSession.sessionId);
+constoriginalThreadId=firstSnapshot.threadId;
+constoriginalTurnCount=firstSnapshot.turns.length;
+
+manager.stopSession(firstSession.sessionId);
+
+constresumedSession=awaitmanager.startSession({
+provider: "codex",
+cwd: workspaceDir,
+runtimeMode: "approval-required",
+resumeCursor: firstSession.resumeCursor,
+providerOptions: {
+codex: {
+binaryPath: process.env.CODEX_BINARY_PATH,
+ ...(process.env.CODEX_HOME_PATH
+ ? {homePath: process.env.CODEX_HOME_PATH}
+ : {}),
+},
+},
+});
+
+expect(resumedSession.threadId).toBe(originalThreadId);
+
+constresumedSnapshotBeforeTurn=awaitmanager.readThread(resumedSession.sessionId);
+expect(resumedSnapshotBeforeTurn.threadId).toBe(originalThreadId);
+expect(resumedSnapshotBeforeTurn.turns.length).toBeGreaterThanOrEqual(originalTurnCount);
+
+awaitmanager.sendTurn({
+sessionId: resumedSession.sessionId,
+input: `Reply with exactly the word BETA ${randomUUID()}`,
+});
+
+awaitvi.waitFor(async()=>{
+constsnapshot=awaitmanager.readThread(resumedSession.sessionId);
+expect(snapshot.turns.length).toBeGreaterThan(originalTurnCount);
+},{timeout: 120_000,interval: 1_000});
+}finally{
+manager.stopAll();
+rmSync(workspaceDir,{recursive: true,force: true});
+}
+},
+180_000,
+);
+});

apps/server/src/codexAppServerManager.ts

@@ -204,6 +204,7 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
  sessionId,
 provider: "codex",
 status: "connecting",
+runtimeMode: input.runtimeMode,
 model: normalizeCodexModelSlug(input.model),
 cwd: resolvedCwd,
 createdAt: now,

apps/server/integration/OrchestrationEngineHarness.integration.ts

@@ -37,6 +37,8 @@ import { ProviderUnsupportedError } from "../src/provider/Errors.ts";
 import{ProviderAdapterRegistry}from"../src/provider/Services/ProviderAdapterRegistry.ts";
 import{ProviderSessionDirectoryLive}from"../src/provider/Layers/ProviderSessionDirectory.ts";
 import{makeProviderServiceLive}from"../src/provider/Layers/ProviderService.ts";
+import{makeCodexAdapterLive}from"../src/provider/Layers/CodexAdapter.ts";
+import{CodexAdapter}from"../src/provider/Services/CodexAdapter.ts";
 import{ProviderService}from"../src/provider/Services/ProviderService.ts";
 import{CheckpointReactorLive}from"../src/orchestration/Layers/CheckpointReactor.ts";
 import{OrchestrationEngineLive}from"../src/orchestration/Layers/OrchestrationEngine.ts";
@@ -187,6 +189,7 @@ export interface OrchestrationIntegrationHarness {
 
 interfaceMakeOrchestrationIntegrationHarnessOptions{
 readonlyprovider?: "codex"|"claudeCode";
+readonlyrealCodex?: boolean;
 }
 
 exportconstmakeOrchestrationIntegrationHarness=(
@@ -195,10 +198,21 @@ export const makeOrchestrationIntegrationHarness = (
 Effect.gen(function*(){
 constsleep=(ms: number)=>Effect.sleep(ms);
 constprovider=options?.provider??"codex";
-constadapterHarness=yield*makeTestProviderAdapterHarness({
- provider,
-});
-
+constuseRealCodex=options?.realCodex===true;
+constadapterHarness=useRealCodex
+ ? null
+ : yield*makeTestProviderAdapterHarness({
+ provider,
+});
+constfakeRegistry=adapterHarness
+ ? Layer.succeed(ProviderAdapterRegistry,{
+getByProvider: (resolvedProvider)=>
+resolvedProvider===adapterHarness.provider
+ ? Effect.succeed(adapterHarness.adapter)
+ : Effect.fail(newProviderUnsupportedError({provider: resolvedProvider})),
+listProviders: ()=>Effect.succeed([adapterHarness.provider]),
+}astypeofProviderAdapterRegistry.Service)
+ : null;
 constrootDir=fs.mkdtempSync(path.join(os.tmpdir(),"t3-orchestration-integration-"));
 constworkspaceDir=path.join(rootDir,"workspace");
 conststateDir=path.join(rootDir,"state");
@@ -207,14 +221,6 @@ export const makeOrchestrationIntegrationHarness = (
 fs.mkdirSync(stateDir,{recursive: true});
 initializeGitWorkspace(workspaceDir);
 
-constregistry: typeofProviderAdapterRegistry.Service={
-getByProvider: (provider)=>
-provider===adapterHarness.provider
- ? Effect.succeed(adapterHarness.adapter)
- : Effect.fail(newProviderUnsupportedError({ provider })),
-listProviders: ()=>Effect.succeed([adapterHarness.provider]),
-};
-
 constpersistenceLayer=makeSqlitePersistenceLive(dbPath);
 constorchestrationLayer=OrchestrationEngineLive.pipe(
 Layer.provide(OrchestrationProjectionPipelineLive),
@@ -224,10 +230,33 @@ export const makeOrchestrationIntegrationHarness = (
 constproviderSessionDirectoryLayer=ProviderSessionDirectoryLive.pipe(
 Layer.provide(ProviderSessionRuntimeRepositoryLive),
 );
-constproviderLayer=makeProviderServiceLive().pipe(
-Layer.provide(providerSessionDirectoryLayer),
-Layer.provide(Layer.succeed(ProviderAdapterRegistry,registry)),
+constrealCodexRegistry=Layer.effect(
+ProviderAdapterRegistry,
+Effect.gen(function*(){
+constcodexAdapter=yield*CodexAdapter;
+return{
+getByProvider: (resolvedProvider)=>
+resolvedProvider==="codex"
+ ? Effect.succeed(codexAdapter)
+ : Effect.fail(newProviderUnsupportedError({provider: resolvedProvider})),
+listProviders: ()=>Effect.succeed(["codex"]asconst),
+}astypeofProviderAdapterRegistry.Service;
+}),
+).pipe(
+Layer.provide(makeCodexAdapterLive()),
+Layer.provideMerge(ServerConfig.layerTest(workspaceDir,stateDir)),
+Layer.provideMerge(NodeServices.layer),
+Layer.provideMerge(providerSessionDirectoryLayer),
 );
+constproviderLayer=useRealCodex
+ ? makeProviderServiceLive().pipe(
+Layer.provide(providerSessionDirectoryLayer),
+Layer.provide(realCodexRegistry),
+)
+ : makeProviderServiceLive().pipe(
+Layer.provide(providerSessionDirectoryLayer),
+Layer.provide(fakeRegistry!),
+);
 
 construntimeServicesLayer=Layer.mergeAll(
 orchestrationLayer,
@@ -407,8 +436,8 @@ export const makeOrchestrationIntegrationHarness = (
 return{
  rootDir,
  workspaceDir,
- dbPath,
- adapterHarness,
+dbPath,
+adapterHarness: adapterHarnessasTestProviderAdapterHarness,
  engine,
  snapshotQuery,
  providerService,

apps/server/integration/TestProviderAdapter.integration.ts

@@ -264,6 +264,7 @@ export const makeTestProviderAdapterHarness = (options?: MakeTestProviderAdapter
  sessionId,
  provider,
 status: "ready",
+runtimeMode: input.runtimeMode,
  threadId,
 cwd: input.cwd,
 resumeCursor: input.resumeCursor??{ sessionId },

apps/server/integration/orchestrationEngine.integration.test.ts

@@ -97,6 +97,16 @@ function withHarness<A, E>(
 );
 }
 
+functionwithRealCodexHarness<A,E>(
+use: (harness: OrchestrationIntegrationHarness)=>Effect.Effect<A,E>,
+){
+returnEffect.acquireUseRelease(
+makeOrchestrationIntegrationHarness({provider: "codex",realCodex: true}),
+use,
+(harness)=>harness.dispose,
+);
+}
+
 constseedProjectAndThread=(harness: OrchestrationIntegrationHarness)=>
 Effect.gen(function*(){
 constcreatedAt=nowIso();
@@ -118,6 +128,7 @@ const seedProjectAndThread = (harness: OrchestrationIntegrationHarness) =>
 projectId: PROJECT_ID,
 title: "Integration Thread",
 model: "gpt-5-codex",
+runtimeMode: "approval-required",
 branch: null,
 worktreePath: harness.workspaceDir,
  createdAt,
@@ -216,6 +227,97 @@ it.live("runs a single turn end-to-end and persists checkpoint state in sqlite +
 ),
 );
 
+it.live.skipIf(!process.env.CODEX_BINARY_PATH)(
+"keeps the same Codex provider thread across runtime mode switches",
+()=>
+withRealCodexHarness((harness)=>
+Effect.gen(function*(){
+constcreatedAt=nowIso();
+
+yield*harness.engine.dispatch({
+type: "project.create",
+commandId: CommandId.makeUnsafe("cmd-project-create-real-codex"),
+projectId: PROJECT_ID,
+title: "Integration Project",
+workspaceRoot: harness.workspaceDir,
+defaultModel: "gpt-5.3-codex",
+ createdAt,
+});
+
+yield*harness.engine.dispatch({
+type: "thread.create",
+commandId: CommandId.makeUnsafe("cmd-thread-create-real-codex"),
+threadId: THREAD_ID,
+projectId: PROJECT_ID,
+title: "Integration Thread",
+model: "gpt-5.3-codex",
+runtimeMode: "full-access",
+branch: null,
+worktreePath: harness.workspaceDir,
+ createdAt,
+});
+
+yield*harness.engine.dispatch({
+type: "thread.turn.start",
+commandId: CommandId.makeUnsafe("cmd-turn-start-real-codex-1"),
+threadId: THREAD_ID,
+message: {
+messageId: asMessageId("msg-real-codex-1"),
+role: "user",
+text: "Reply with exactly ALPHA.",
+attachments: [],
+},
+runtimeMode: "full-access",
+createdAt: nowIso(),
+});
+
+constfirstThread=yield*harness.waitForThread(
+THREAD_ID,
+(entry)=>
+entry.session?.status==="ready"&&
+entry.session.providerName==="codex"&&
+entry.session.providerThreadId!==null&&
+entry.messages.some(
+(message)=>message.role==="assistant"&&message.streaming===false,
+),
+180_000,
+);
+
+constoriginalProviderThreadId=firstThread.session?.providerThreadId;
+assert.isNotNull(originalProviderThreadId);
+
+yield*harness.engine.dispatch({
+type: "thread.turn.start",
+commandId: CommandId.makeUnsafe("cmd-turn-start-real-codex-2"),
+threadId: THREAD_ID,
+message: {
+messageId: asMessageId("msg-real-codex-2"),
+role: "user",
+text: "Reply with exactly BETA.",
+attachments: [],
+},
+runtimeMode: "approval-required",
+createdAt: nowIso(),
+});
+
+constsecondThread=yield*harness.waitForThread(
+THREAD_ID,
+(entry)=>
+entry.session?.status==="ready"&&
+entry.session.providerName==="codex"&&
+entry.session.providerThreadId!==null&&
+entry.session.runtimeMode==="approval-required"&&
+entry.messages.some(
+(message)=>message.role==="assistant"&&message.text.includes("BETA"),
+),
+180_000,
+);
+
+assert.equal(secondThread.session?.providerThreadId,originalProviderThreadId);
+}),
+),
+);
+
 it.live("runs multi-turn file edits and persists checkpoint diffs",()=>
 withHarness((harness)=>
 Effect.gen(function*(){

apps/server/integration/providerService.integration.test.ts

@@ -122,6 +122,7 @@ it.effect("replays typed runtime fixture events", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -155,6 +156,7 @@ it.effect("replays file-changing fixture turn events", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -192,6 +194,7 @@ it.effect("runs multi-turn tool/approval flow", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -244,6 +247,7 @@ it.effect("rolls back provider conversation state only", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);

apps/server/src/checkpointing/Layers/CheckpointDiffQuery.test.ts

@@ -43,6 +43,7 @@ function makeSnapshot(input: {
 projectId: input.projectId,
 title: "Thread",
 model: "gpt-5-codex",
+runtimeMode: "full-access",
 branch: null,
 worktreePath: input.worktreePath,
 latestTurn: {

apps/server/src/codexAppServerManager.test.ts

@@ -1,4 +1,8 @@
 import{describe,expect,it,vi}from"vitest";
+import{randomUUID}from"node:crypto";
+import{mkdtempSync,rmSync,writeFileSync}from"node:fs";
+importosfrom"node:os";
+importpathfrom"node:path";
 import{ProviderSessionId}from"@t3tools/contracts";
 
 import{
@@ -165,6 +169,7 @@ describe("startSession", () => {
 awaitexpect(
 manager.startSession({
 provider: "codex",
+runtimeMode: "full-access",
 }),
 ).rejects.toThrow("cwd missing");
 expect(events).toHaveLength(1);
@@ -347,3 +352,84 @@ describe("thread checkpoint control", () => {
 });
 });
 });
+
+describe.skipIf(!process.env.CODEX_BINARY_PATH)("startSession live Codex resume",()=>{
+it(
+"keeps prior thread history when resuming with a changed runtime mode",
+async()=>{
+constworkspaceDir=mkdtempSync(path.join(os.tmpdir(),"codex-live-resume-"));
+writeFileSync(path.join(workspaceDir,"README.md"),"hello\n","utf8");
+
+constmanager=newCodexAppServerManager();
+
+try{
+constfirstSession=awaitmanager.startSession({
+provider: "codex",
+cwd: workspaceDir,
+runtimeMode: "full-access",
+providerOptions: {
+codex: {
+binaryPath: process.env.CODEX_BINARY_PATH,
+ ...(process.env.CODEX_HOME_PATH
+ ? {homePath: process.env.CODEX_HOME_PATH}
+ : {}),
+},
+},
+});
+
+constfirstTurn=awaitmanager.sendTurn({
+sessionId: firstSession.sessionId,
+input: `Reply with exactly the word ALPHA ${randomUUID()}`,
+});
+
+expect(firstTurn.threadId).toBe(firstSession.threadId);
+
+awaitvi.waitFor(async()=>{
+constsnapshot=awaitmanager.readThread(firstSession.sessionId);
+expect(snapshot.turns.length).toBeGreaterThan(0);
+},{timeout: 120_000,interval: 1_000});
+
+constfirstSnapshot=awaitmanager.readThread(firstSession.sessionId);
+constoriginalThreadId=firstSnapshot.threadId;
+constoriginalTurnCount=firstSnapshot.turns.length;
+
+manager.stopSession(firstSession.sessionId);
+
+constresumedSession=awaitmanager.startSession({
+provider: "codex",
+cwd: workspaceDir,
+runtimeMode: "approval-required",
+resumeCursor: firstSession.resumeCursor,
+providerOptions: {
+codex: {
+binaryPath: process.env.CODEX_BINARY_PATH,
+ ...(process.env.CODEX_HOME_PATH
+ ? {homePath: process.env.CODEX_HOME_PATH}
+ : {}),
+},
+},
+});
+
+expect(resumedSession.threadId).toBe(originalThreadId);
+
+constresumedSnapshotBeforeTurn=awaitmanager.readThread(resumedSession.sessionId);
+expect(resumedSnapshotBeforeTurn.threadId).toBe(originalThreadId);
+expect(resumedSnapshotBeforeTurn.turns.length).toBeGreaterThanOrEqual(originalTurnCount);
+
+awaitmanager.sendTurn({
+sessionId: resumedSession.sessionId,
+input: `Reply with exactly the word BETA ${randomUUID()}`,
+});
+
+awaitvi.waitFor(async()=>{
+constsnapshot=awaitmanager.readThread(resumedSession.sessionId);
+expect(snapshot.turns.length).toBeGreaterThan(originalTurnCount);
+},{timeout: 120_000,interval: 1_000});
+}finally{
+manager.stopAll();
+rmSync(workspaceDir,{recursive: true,force: true});
+}
+},
+180_000,
+);
+});

apps/server/src/codexAppServerManager.ts

@@ -204,6 +204,7 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
  sessionId,
 provider: "codex",
 status: "connecting",
+runtimeMode: input.runtimeMode,
 model: normalizeCodexModelSlug(input.model),
 cwd: resolvedCwd,
 createdAt: now,

apps/server/integration/OrchestrationEngineHarness.integration.ts

@@ -37,6 +37,8 @@ import { ProviderUnsupportedError } from "../src/provider/Errors.ts";
 import{ProviderAdapterRegistry}from"../src/provider/Services/ProviderAdapterRegistry.ts";
 import{ProviderSessionDirectoryLive}from"../src/provider/Layers/ProviderSessionDirectory.ts";
 import{makeProviderServiceLive}from"../src/provider/Layers/ProviderService.ts";
+import{makeCodexAdapterLive}from"../src/provider/Layers/CodexAdapter.ts";
+import{CodexAdapter}from"../src/provider/Services/CodexAdapter.ts";
 import{ProviderService}from"../src/provider/Services/ProviderService.ts";
 import{CheckpointReactorLive}from"../src/orchestration/Layers/CheckpointReactor.ts";
 import{OrchestrationEngineLive}from"../src/orchestration/Layers/OrchestrationEngine.ts";
@@ -187,6 +189,7 @@ export interface OrchestrationIntegrationHarness {
 
 interfaceMakeOrchestrationIntegrationHarnessOptions{
 readonlyprovider?: "codex"|"claudeCode";
+readonlyrealCodex?: boolean;
 }
 
 exportconstmakeOrchestrationIntegrationHarness=(
@@ -195,10 +198,21 @@ export const makeOrchestrationIntegrationHarness = (
 Effect.gen(function*(){
 constsleep=(ms: number)=>Effect.sleep(ms);
 constprovider=options?.provider??"codex";
-constadapterHarness=yield*makeTestProviderAdapterHarness({
- provider,
-});
-
+constuseRealCodex=options?.realCodex===true;
+constadapterHarness=useRealCodex
+ ? null
+ : yield*makeTestProviderAdapterHarness({
+ provider,
+});
+constfakeRegistry=adapterHarness
+ ? Layer.succeed(ProviderAdapterRegistry,{
+getByProvider: (resolvedProvider)=>
+resolvedProvider===adapterHarness.provider
+ ? Effect.succeed(adapterHarness.adapter)
+ : Effect.fail(newProviderUnsupportedError({provider: resolvedProvider})),
+listProviders: ()=>Effect.succeed([adapterHarness.provider]),
+}astypeofProviderAdapterRegistry.Service)
+ : null;
 constrootDir=fs.mkdtempSync(path.join(os.tmpdir(),"t3-orchestration-integration-"));
 constworkspaceDir=path.join(rootDir,"workspace");
 conststateDir=path.join(rootDir,"state");
@@ -207,14 +221,6 @@ export const makeOrchestrationIntegrationHarness = (
 fs.mkdirSync(stateDir,{recursive: true});
 initializeGitWorkspace(workspaceDir);
 
-constregistry: typeofProviderAdapterRegistry.Service={
-getByProvider: (provider)=>
-provider===adapterHarness.provider
- ? Effect.succeed(adapterHarness.adapter)
- : Effect.fail(newProviderUnsupportedError({ provider })),
-listProviders: ()=>Effect.succeed([adapterHarness.provider]),
-};
-
 constpersistenceLayer=makeSqlitePersistenceLive(dbPath);
 constorchestrationLayer=OrchestrationEngineLive.pipe(
 Layer.provide(OrchestrationProjectionPipelineLive),
@@ -224,10 +230,33 @@ export const makeOrchestrationIntegrationHarness = (
 constproviderSessionDirectoryLayer=ProviderSessionDirectoryLive.pipe(
 Layer.provide(ProviderSessionRuntimeRepositoryLive),
 );
-constproviderLayer=makeProviderServiceLive().pipe(
-Layer.provide(providerSessionDirectoryLayer),
-Layer.provide(Layer.succeed(ProviderAdapterRegistry,registry)),
+constrealCodexRegistry=Layer.effect(
+ProviderAdapterRegistry,
+Effect.gen(function*(){
+constcodexAdapter=yield*CodexAdapter;
+return{
+getByProvider: (resolvedProvider)=>
+resolvedProvider==="codex"
+ ? Effect.succeed(codexAdapter)
+ : Effect.fail(newProviderUnsupportedError({provider: resolvedProvider})),
+listProviders: ()=>Effect.succeed(["codex"]asconst),
+}astypeofProviderAdapterRegistry.Service;
+}),
+).pipe(
+Layer.provide(makeCodexAdapterLive()),
+Layer.provideMerge(ServerConfig.layerTest(workspaceDir,stateDir)),
+Layer.provideMerge(NodeServices.layer),
+Layer.provideMerge(providerSessionDirectoryLayer),
 );
+constproviderLayer=useRealCodex
+ ? makeProviderServiceLive().pipe(
+Layer.provide(providerSessionDirectoryLayer),
+Layer.provide(realCodexRegistry),
+)
+ : makeProviderServiceLive().pipe(
+Layer.provide(providerSessionDirectoryLayer),
+Layer.provide(fakeRegistry!),
+);
 
 construntimeServicesLayer=Layer.mergeAll(
 orchestrationLayer,
@@ -407,8 +436,8 @@ export const makeOrchestrationIntegrationHarness = (
 return{
  rootDir,
  workspaceDir,
- dbPath,
- adapterHarness,
+dbPath,
+adapterHarness: adapterHarnessasTestProviderAdapterHarness,
  engine,
  snapshotQuery,
  providerService,

apps/server/integration/TestProviderAdapter.integration.ts

@@ -264,6 +264,7 @@ export const makeTestProviderAdapterHarness = (options?: MakeTestProviderAdapter
  sessionId,
  provider,
 status: "ready",
+runtimeMode: input.runtimeMode,
  threadId,
 cwd: input.cwd,
 resumeCursor: input.resumeCursor??{ sessionId },

apps/server/integration/orchestrationEngine.integration.test.ts

@@ -97,6 +97,16 @@ function withHarness<A, E>(
 );
 }
 
+functionwithRealCodexHarness<A,E>(
+use: (harness: OrchestrationIntegrationHarness)=>Effect.Effect<A,E>,
+){
+returnEffect.acquireUseRelease(
+makeOrchestrationIntegrationHarness({provider: "codex",realCodex: true}),
+use,
+(harness)=>harness.dispose,
+);
+}
+
 constseedProjectAndThread=(harness: OrchestrationIntegrationHarness)=>
 Effect.gen(function*(){
 constcreatedAt=nowIso();
@@ -118,6 +128,7 @@ const seedProjectAndThread = (harness: OrchestrationIntegrationHarness) =>
 projectId: PROJECT_ID,
 title: "Integration Thread",
 model: "gpt-5-codex",
+runtimeMode: "approval-required",
 branch: null,
 worktreePath: harness.workspaceDir,
  createdAt,
@@ -216,6 +227,97 @@ it.live("runs a single turn end-to-end and persists checkpoint state in sqlite +
 ),
 );
 
+it.live.skipIf(!process.env.CODEX_BINARY_PATH)(
+"keeps the same Codex provider thread across runtime mode switches",
+()=>
+withRealCodexHarness((harness)=>
+Effect.gen(function*(){
+constcreatedAt=nowIso();
+
+yield*harness.engine.dispatch({
+type: "project.create",
+commandId: CommandId.makeUnsafe("cmd-project-create-real-codex"),
+projectId: PROJECT_ID,
+title: "Integration Project",
+workspaceRoot: harness.workspaceDir,
+defaultModel: "gpt-5.3-codex",
+ createdAt,
+});
+
+yield*harness.engine.dispatch({
+type: "thread.create",
+commandId: CommandId.makeUnsafe("cmd-thread-create-real-codex"),
+threadId: THREAD_ID,
+projectId: PROJECT_ID,
+title: "Integration Thread",
+model: "gpt-5.3-codex",
+runtimeMode: "full-access",
+branch: null,
+worktreePath: harness.workspaceDir,
+ createdAt,
+});
+
+yield*harness.engine.dispatch({
+type: "thread.turn.start",
+commandId: CommandId.makeUnsafe("cmd-turn-start-real-codex-1"),
+threadId: THREAD_ID,
+message: {
+messageId: asMessageId("msg-real-codex-1"),
+role: "user",
+text: "Reply with exactly ALPHA.",
+attachments: [],
+},
+runtimeMode: "full-access",
+createdAt: nowIso(),
+});
+
+constfirstThread=yield*harness.waitForThread(
+THREAD_ID,
+(entry)=>
+entry.session?.status==="ready"&&
+entry.session.providerName==="codex"&&
+entry.session.providerThreadId!==null&&
+entry.messages.some(
+(message)=>message.role==="assistant"&&message.streaming===false,
+),
+180_000,
+);
+
+constoriginalProviderThreadId=firstThread.session?.providerThreadId;
+assert.isNotNull(originalProviderThreadId);
+
+yield*harness.engine.dispatch({
+type: "thread.turn.start",
+commandId: CommandId.makeUnsafe("cmd-turn-start-real-codex-2"),
+threadId: THREAD_ID,
+message: {
+messageId: asMessageId("msg-real-codex-2"),
+role: "user",
+text: "Reply with exactly BETA.",
+attachments: [],
+},
+runtimeMode: "approval-required",
+createdAt: nowIso(),
+});
+
+constsecondThread=yield*harness.waitForThread(
+THREAD_ID,
+(entry)=>
+entry.session?.status==="ready"&&
+entry.session.providerName==="codex"&&
+entry.session.providerThreadId!==null&&
+entry.session.runtimeMode==="approval-required"&&
+entry.messages.some(
+(message)=>message.role==="assistant"&&message.text.includes("BETA"),
+),
+180_000,
+);
+
+assert.equal(secondThread.session?.providerThreadId,originalProviderThreadId);
+}),
+),
+);
+
 it.live("runs multi-turn file edits and persists checkpoint diffs",()=>
 withHarness((harness)=>
 Effect.gen(function*(){

apps/server/integration/providerService.integration.test.ts

@@ -122,6 +122,7 @@ it.effect("replays typed runtime fixture events", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -155,6 +156,7 @@ it.effect("replays file-changing fixture turn events", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -192,6 +194,7 @@ it.effect("runs multi-turn tool/approval flow", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);
@@ -244,6 +247,7 @@ it.effect("rolls back provider conversation state only", () =>
 {
 provider: "codex",
 cwd: fixture.cwd,
+runtimeMode: "full-access",
 },
 );
 assert.equal((session.threadId??"").length>0,true);

apps/server/src/checkpointing/Layers/CheckpointDiffQuery.test.ts

@@ -43,6 +43,7 @@ function makeSnapshot(input: {
 projectId: input.projectId,
 title: "Thread",
 model: "gpt-5-codex",
+runtimeMode: "full-access",
 branch: null,
 worktreePath: input.worktreePath,
 latestTurn: {

apps/server/src/codexAppServerManager.test.ts

@@ -1,4 +1,8 @@
 import{describe,expect,it,vi}from"vitest";
+import{randomUUID}from"node:crypto";
+import{mkdtempSync,rmSync,writeFileSync}from"node:fs";
+importosfrom"node:os";
+importpathfrom"node:path";
 import{ProviderSessionId}from"@t3tools/contracts";
 
 import{
@@ -165,6 +169,7 @@ describe("startSession", () => {
 awaitexpect(
 manager.startSession({
 provider: "codex",
+runtimeMode: "full-access",
 }),
 ).rejects.toThrow("cwd missing");
 expect(events).toHaveLength(1);
@@ -347,3 +352,84 @@ describe("thread checkpoint control", () => {
 });
 });
 });
+
+describe.skipIf(!process.env.CODEX_BINARY_PATH)("startSession live Codex resume",()=>{
+it(
+"keeps prior thread history when resuming with a changed runtime mode",
+async()=>{
+constworkspaceDir=mkdtempSync(path.join(os.tmpdir(),"codex-live-resume-"));
+writeFileSync(path.join(workspaceDir,"README.md"),"hello\n","utf8");
+
+constmanager=newCodexAppServerManager();
+
+try{
+constfirstSession=awaitmanager.startSession({
+provider: "codex",
+cwd: workspaceDir,
+runtimeMode: "full-access",
+providerOptions: {
+codex: {
+binaryPath: process.env.CODEX_BINARY_PATH,
+ ...(process.env.CODEX_HOME_PATH
+ ? {homePath: process.env.CODEX_HOME_PATH}
+ : {}),
+},
+},
+});
+
+constfirstTurn=awaitmanager.sendTurn({
+sessionId: firstSession.sessionId,
+input: `Reply with exactly the word ALPHA ${randomUUID()}`,
+});
+
+expect(firstTurn.threadId).toBe(firstSession.threadId);
+
+awaitvi.waitFor(async()=>{
+constsnapshot=awaitmanager.readThread(firstSession.sessionId);
+expect(snapshot.turns.length).toBeGreaterThan(0);
+},{timeout: 120_000,interval: 1_000});
+
+constfirstSnapshot=awaitmanager.readThread(firstSession.sessionId);
+constoriginalThreadId=firstSnapshot.threadId;
+constoriginalTurnCount=firstSnapshot.turns.length;
+
+manager.stopSession(firstSession.sessionId);
+
+constresumedSession=awaitmanager.startSession({
+provider: "codex",
+cwd: workspaceDir,
+runtimeMode: "approval-required",
+resumeCursor: firstSession.resumeCursor,
+providerOptions: {
+codex: {
+binaryPath: process.env.CODEX_BINARY_PATH,
+ ...(process.env.CODEX_HOME_PATH
+ ? {homePath: process.env.CODEX_HOME_PATH}
+ : {}),
+},
+},
+});
+
+expect(resumedSession.threadId).toBe(originalThreadId);
+
+constresumedSnapshotBeforeTurn=awaitmanager.readThread(resumedSession.sessionId);
+expect(resumedSnapshotBeforeTurn.threadId).toBe(originalThreadId);
+expect(resumedSnapshotBeforeTurn.turns.length).toBeGreaterThanOrEqual(originalTurnCount);
+
+awaitmanager.sendTurn({
+sessionId: resumedSession.sessionId,
+input: `Reply with exactly the word BETA ${randomUUID()}`,
+});
+
+awaitvi.waitFor(async()=>{
+constsnapshot=awaitmanager.readThread(resumedSession.sessionId);
+expect(snapshot.turns.length).toBeGreaterThan(originalTurnCount);
+},{timeout: 120_000,interval: 1_000});
+}finally{
+manager.stopAll();
+rmSync(workspaceDir,{recursive: true,force: true});
+}
+},
+180_000,
+);
+});

apps/server/src/codexAppServerManager.ts

@@ -204,6 +204,7 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
  sessionId,
 provider: "codex",
 status: "connecting",
+runtimeMode: input.runtimeMode,
 model: normalizeCodexModelSlug(input.model),
 cwd: resolvedCwd,
 createdAt: now,