@ai-sdk/harness-codex 1.0.93 → 1.0.95

package/dist/bridge/package.json

@@ -4,7 +4,7 @@
   "private": true,
   "type": "module",
   "dependencies": {
-    "@openai/codex-sdk": "0.144.5",
+    "@openai/codex-sdk": "0.149.1",
     "ws": "8.21.0"
   }
 }

package/dist/bridge/pnpm-lock.yaml

@@ -9,55 +9,55 @@ importers:
   .:
     dependencies:
       '@openai/codex-sdk':
-        specifier: 0.144.5
-        version: 0.144.5
+        specifier: 0.149.1
+        version: 0.149.1
       ws:
         specifier: 8.21.0
         version: 8.21.0
 
 packages:
 
-  '@openai/codex-sdk@0.144.5':
-    resolution: {integrity: sha512-90wHPEGyk74On6gwQPNtw+wzuDJ2zYpiVADDxw43S1cWn3QbBh/21zFS2xlAWWCrdY0gE90yXfmmrzwdUDlBGw==}
+  '@openai/codex-sdk@0.149.1':
+    resolution: {integrity: sha512-R00Rz5327LefZggAxl28r7vFQq1vxa91OxtjZJOsQfAM/MyH8InW5qwwRu6pzUmRGp1E29XrOzm7u1TeV5Yz2A==}
     engines: {node: '>=18'}
 
-  '@openai/codex@0.144.5':
-    resolution: {integrity: sha512-jjB+K+OMv572mKhS+2QuLxWXDJNdpwbPenf+V+8bdq7wg4Scqt3cn6WEekD8wPqDVZqck0HSX17K9rD9kbDJQA==}
+  '@openai/codex@0.149.1':
+    resolution: {integrity: sha512-6q5pbcpFbJbqOpkubSDBwXmktQ55aD8eUzGzBF1zASob2DjwhBKDSNGtdZKalfrNJUdTDTPDMmzCXEXs5tMBYA==}
     engines: {node: '>=16'}
     hasBin: true
 
-  '@openai/codex@0.144.5-darwin-arm64':
-    resolution: {integrity: sha512-zcT6NfBCqLFt+BReNSETTZW6v6PdbH0dzNtm9j7l7mDGqwPbKZDGJdnpkBao2389I0ZacyIKgSZoI0vez1d4Dw==}
+  '@openai/codex@0.149.1-darwin-arm64':
+    resolution: {integrity: sha512-6X84kTCbnTgPIJ2EdcPsrvwS0Wxsqpa+bCswGmRf4BjhcQ5nPMnBC6yCAaCMj+vrbXQHj+L6sa9FaR4QkmA1qw==}
     engines: {node: '>=16'}
     cpu: [arm64]
     os: [darwin]
 
-  '@openai/codex@0.144.5-darwin-x64':
-    resolution: {integrity: sha512-//Mo0m1MwaoT6psu5xsmofXpKx4/0irIkeq10xJvk59+886EG355ibjA+ZmlRcKhE3bLjsKD7p81nTbAdRL/bw==}
+  '@openai/codex@0.149.1-darwin-x64':
+    resolution: {integrity: sha512-MfLBQLfcElJL9tvj6y45qVHHMGSXCPnQOixuD3/Zq0g1BW/eFizkrGLdn48cFpc+l8cK+gt5nYG5pQYwVs6g4A==}
     engines: {node: '>=16'}
     cpu: [x64]
     os: [darwin]
 
-  '@openai/codex@0.144.5-linux-arm64':
-    resolution: {integrity: sha512-zAHggxVwR2TBxKmybXY7ZMiB0G8DMonY2YPdwNNjwXcf+LOIqNGgswwNCDMbP/HEe6r8j+R9ZX/yYoo8f+n/RQ==}
+  '@openai/codex@0.149.1-linux-arm64':
+    resolution: {integrity: sha512-OqxUfZ1TVvHd18zHPKK/8ZRlpk8Vy11mg5CMHaLxNWldTbwVImDKtSLWT+m8m4NM5Sz4PbjtZMrVT/RfpBW/mQ==}
     engines: {node: '>=16'}
     cpu: [arm64]
     os: [linux]
 
-  '@openai/codex@0.144.5-linux-x64':
-    resolution: {integrity: sha512-FalLJlBQGFdK8Gc3kj9sa/ekNdgkHhUawLaKkvy5CtB18JaP2YxtTP/Pe1pD2iBiq8mMUliRnafpF6AdBdQMbg==}
+  '@openai/codex@0.149.1-linux-x64':
+    resolution: {integrity: sha512-Of5fGYgr7tAMsyj6vhXb4/RM/UoA3Zq8BLegUBDC09UNy1XTLGYP/2XD+UX8z3qh0NDwxYdCjFIWdDNijKZggQ==}
     engines: {node: '>=16'}
     cpu: [x64]
     os: [linux]
 
-  '@openai/codex@0.144.5-win32-arm64':
-    resolution: {integrity: sha512-0Pj7iqjEOEvPQPO3kFfCy9vGX4BTu76ChFFZHr2eNNIfVc3FOENAv/X98u4L+iIUtDOK9DbqmfUudW3DPapshg==}
+  '@openai/codex@0.149.1-win32-arm64':
+    resolution: {integrity: sha512-5K0DmOKGK9Bos627p8sK8ATHjovPK0sDyT6h9Cb+4v+5CW5SGw1HLgjGxoLfJ8g3cg6mtg/pRCXXo2L/j71UVA==}
     engines: {node: '>=16'}
     cpu: [arm64]
     os: [win32]
 
-  '@openai/codex@0.144.5-win32-x64':
-    resolution: {integrity: sha512-DnsSTlnnzleTxvLwIGnBitKInscxn2I7qASqosS8Fv+qysBygd+ZiBn/SQsRCgQ28PAlsNzmd3Gf3ZTecolAmg==}
+  '@openai/codex@0.149.1-win32-x64':
+    resolution: {integrity: sha512-G3QXGAg7nyyhqOeooAMUekBCeHd8a1QByhKcVAFyzNBaI06t6Ft7nsF+1SzFS0spuIdU4YyMi5YD26ukADBQUQ==}
     engines: {node: '>=16'}
     cpu: [x64]
     os: [win32]
@@ -76,35 +76,35 @@ packages:
 
 snapshots:
 
-  '@openai/codex-sdk@0.144.5':
+  '@openai/codex-sdk@0.149.1':
     dependencies:
-      '@openai/codex': 0.144.5
+      '@openai/codex': 0.149.1
 
-  '@openai/codex@0.144.5':
+  '@openai/codex@0.149.1':
     optionalDependencies:
-      '@openai/codex-darwin-arm64': '@openai/codex@0.144.5-darwin-arm64'
-      '@openai/codex-darwin-x64': '@openai/codex@0.144.5-darwin-x64'
-      '@openai/codex-linux-arm64': '@openai/codex@0.144.5-linux-arm64'
-      '@openai/codex-linux-x64': '@openai/codex@0.144.5-linux-x64'
-      '@openai/codex-win32-arm64': '@openai/codex@0.144.5-win32-arm64'
-      '@openai/codex-win32-x64': '@openai/codex@0.144.5-win32-x64'
-
-  '@openai/codex@0.144.5-darwin-arm64':
+      '@openai/codex-darwin-arm64': '@openai/codex@0.149.1-darwin-arm64'
+      '@openai/codex-darwin-x64': '@openai/codex@0.149.1-darwin-x64'
+      '@openai/codex-linux-arm64': '@openai/codex@0.149.1-linux-arm64'
+      '@openai/codex-linux-x64': '@openai/codex@0.149.1-linux-x64'
+      '@openai/codex-win32-arm64': '@openai/codex@0.149.1-win32-arm64'
+      '@openai/codex-win32-x64': '@openai/codex@0.149.1-win32-x64'
+
+  '@openai/codex@0.149.1-darwin-arm64':
     optional: true
 
-  '@openai/codex@0.144.5-darwin-x64':
+  '@openai/codex@0.149.1-darwin-x64':
     optional: true
 
-  '@openai/codex@0.144.5-linux-arm64':
+  '@openai/codex@0.149.1-linux-arm64':
     optional: true
 
-  '@openai/codex@0.144.5-linux-x64':
+  '@openai/codex@0.149.1-linux-x64':
     optional: true
 
-  '@openai/codex@0.144.5-win32-arm64':
+  '@openai/codex@0.149.1-win32-arm64':
     optional: true
 
-  '@openai/codex@0.144.5-win32-x64':
+  '@openai/codex@0.149.1-win32-x64':
     optional: true
 
   ws@8.21.0: {}

package/dist/index.d.ts

@@ -1,33 +1,10 @@
 import * as _ai_sdk_harness from '@ai-sdk/harness';
-import { HarnessV1CredentialForwarding, HarnessV1PortEndpoint, HarnessV1, HarnessV1BuiltinTool } from '@ai-sdk/harness';
+import { HarnessV1Authentication, HarnessV1CredentialForwarding, HarnessV1PortEndpoint, HarnessV1, HarnessV1BuiltinTool } from '@ai-sdk/harness';
 
-type CodexResolvedAuthenticationMode = 'direct' | 'ai-gateway';
-type CodexAuthenticationMode = CodexResolvedAuthenticationMode | 'auto';
-/**
- * @deprecated Passing an object to auth options is deprecated. Use a `CodexAuthenticationMode` string value ("auto" | "direct" | "ai-gateway") instead, and pass credentials via environment variables.
- */
-type LegacyCodexAuthOptions = {
-    readonly openaiCompatible?: {
-        readonly apiKey?: string;
-        readonly baseUrl?: string;
-        readonly modelProviderName?: string;
-        readonly queryParamsJson?: string;
-    };
-    readonly openai?: {
-        readonly apiKey?: string;
-        readonly baseUrl?: string;
-        readonly organization?: string;
-        readonly project?: string;
-    };
-    readonly gateway?: {
-        readonly apiKey?: string;
-        readonly baseUrl?: string;
-    };
-};
-type CodexAuthOptions = CodexAuthenticationMode | LegacyCodexAuthOptions;
+type CodexAuthenticationMode = HarnessV1Authentication;
 
 type CodexHarnessSettings = {
-    readonly auth?: CodexAuthOptions;
+    readonly auth?: CodexAuthenticationMode;
     /**
      * Customizes each credential value before it is forwarded into a sandbox
      * process. This does not restrict which credentials the harness adapter can
@@ -48,6 +25,8 @@ type CodexHarnessSettings = {
     /**
      * OpenAI model id the underlying `codex` CLI should use. Leaving this unset
      * pins the adapter default (`DEFAULT_CODEX_MODEL`).
+     *
+     * @deprecated Use `model` on `HarnessAgent` instead.
      */
     readonly model?: string;
     /**
@@ -105,4 +84,4 @@ declare const codex: _ai_sdk_harness.HarnessV1<{
     }, unknown>;
 }>;
 
-export { type CodexAuthOptions, type CodexAuthenticationMode, type CodexHarnessSettings, VERSION, codex, createCodex };
+export { type CodexAuthenticationMode, type CodexHarnessSettings, VERSION, codex, createCodex };

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/codex-harness.ts
-import { randomBytes } from "crypto";
+import { createHash, randomBytes } from "crypto";
 import path from "path";
 import {
   commonTool,
@@ -76,7 +76,8 @@ async function readBridgeAsset(name) {
 // src/codex-auth.ts
 import {
   createCredentialRequestTransformation,
-  getAiGatewayAuthFromEnv
+  getAiGatewayAuthFromEnv,
+  isHarnessAuthenticationEnvironment
 } from "@ai-sdk/harness/utils";
 var DEFAULT_AI_GATEWAY_BASE_URL = "https://ai-gateway.vercel.sh/v1";
 var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
@@ -105,95 +106,50 @@ function createCodexRequestTransformations({
   ];
 }
 function resolveCodexEnv(auth, processEnv = process.env) {
-  const normalizedAuth = normalizeCodexAuthToLegacyAuth(auth);
-  if (normalizedAuth?.openaiCompatible) {
-    return pickOpenAICompatible(normalizedAuth.openaiCompatible, processEnv);
-  }
-  if (normalizedAuth?.openai) {
-    return pickOpenAI({ explicit: normalizedAuth.openai, processEnv });
+  const suppliedEnvironment = isHarnessAuthenticationEnvironment(auth);
+  const authenticationEnvironment = suppliedEnvironment ? auth : processEnv;
+  if (auth === "direct") {
+    return pickOpenAI({ processEnv: authenticationEnvironment });
   }
   const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({
-    env: processEnv
+    env: authenticationEnvironment
   });
-  if (normalizedAuth?.gateway) {
-    return pickGateway({
-      explicit: normalizedAuth.gateway,
-      gatewayAuthFromEnv
-    });
-  }
-  if (gatewayAuthFromEnv.apiKey) {
-    return pickGateway({
-      explicit: {},
-      gatewayAuthFromEnv
-    });
+  if (auth === "ai-gateway" || gatewayAuthFromEnv.apiKey) {
+    return pickGateway({ gatewayAuthFromEnv });
   }
-  return pickOpenAI({ processEnv });
+  return pickOpenAI({ processEnv: authenticationEnvironment });
 }
 function resolveCodexAuthenticationMode(auth, processEnv = process.env) {
-  if (typeof auth !== "string" && auth?.openaiCompatible) {
-    return "direct";
+  if (isHarnessAuthenticationEnvironment(auth)) {
+    return getAiGatewayAuthFromEnv({ env: auth }).apiKey ? "ai-gateway" : "direct";
   }
-  if (auth === "direct" || typeof auth !== "string" && auth?.openai) {
+  if (auth === "direct") {
     return "direct";
   }
-  if (auth === "ai-gateway" || typeof auth !== "string" && auth?.gateway) {
+  if (auth === "ai-gateway") {
     return "ai-gateway";
   }
   return getAiGatewayAuthFromEnv({ env: processEnv }).apiKey ? "ai-gateway" : "direct";
 }
-function normalizeCodexAuthToLegacyAuth(auth) {
-  if (auth == null || auth === "auto") {
-    return void 0;
-  }
-  if (typeof auth === "string") {
-    switch (auth) {
-      case "direct":
-        return { openai: {} };
-      case "ai-gateway":
-        return { gateway: {} };
-      default:
-        return void 0;
-    }
-  }
-  console.warn(
-    '[codex] Passing an object to auth options is deprecated. Use a string mode ("auto" | "direct" | "ai-gateway") instead, and pass credentials via environment variables.'
-  );
-  return auth;
-}
-function pickOpenAICompatible(explicit, processEnv) {
-  const env = {};
-  const apiKey = explicit.apiKey ?? processEnv.OPENAI_API_KEY ?? processEnv.CODEX_API_KEY;
-  if (apiKey) env.CODEX_API_KEY = apiKey;
-  if (explicit.baseUrl) env.OPENAI_BASE_URL = explicit.baseUrl;
-  if (explicit.modelProviderName)
-    env.CODEX_MODEL_PROVIDER_NAME = explicit.modelProviderName;
-  if (explicit.queryParamsJson)
-    env.OPENAI_QUERY_PARAMS_JSON = explicit.queryParamsJson;
-  return env;
-}
 function pickOpenAI({
-  explicit,
   processEnv
 }) {
   const env = {};
-  const apiKey = explicit?.apiKey ?? processEnv.OPENAI_API_KEY ?? processEnv.CODEX_API_KEY;
+  const apiKey = processEnv.OPENAI_API_KEY ?? processEnv.CODEX_API_KEY;
   if (apiKey) env.CODEX_API_KEY = apiKey;
-  const baseUrl = explicit?.baseUrl ?? processEnv.OPENAI_BASE_URL;
+  const baseUrl = processEnv.OPENAI_BASE_URL;
   if (baseUrl) env.OPENAI_BASE_URL = baseUrl;
-  const organization = explicit?.organization ?? processEnv.OPENAI_ORGANIZATION;
+  const organization = processEnv.OPENAI_ORGANIZATION;
   if (organization) env.OPENAI_ORGANIZATION = organization;
-  const project = explicit?.project ?? processEnv.OPENAI_PROJECT;
+  const project = processEnv.OPENAI_PROJECT;
   if (project) env.OPENAI_PROJECT = project;
   return env;
 }
 function pickGateway({
-  explicit,
   gatewayAuthFromEnv
 }) {
-  const apiKey = explicit.apiKey ?? gatewayAuthFromEnv.apiKey;
-  const baseUrl = toCodexGatewayBaseUrl(
-    explicit.baseUrl ?? gatewayAuthFromEnv.baseUrl
-  );
+  const apiKey = gatewayAuthFromEnv.apiKey;
+  const baseUrl = toCodexGatewayBaseUrl(gatewayAuthFromEnv.baseUrl);
   const env = {};
   if (apiKey) {
     env.AI_GATEWAY_API_KEY = apiKey;
@@ -227,7 +183,8 @@ var startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
   // `codex.resumeThread(resumeThreadId, …)` instead of starting a fresh thread.
   // The host sources the id from lifecycle state `data` cached from a prior
   // `agent.detach`.
-  resumeThreadId: z.string().optional()
+  resumeThreadId: z.string().optional(),
+  restartThread: z.boolean().optional()
 });
 var inboundMessageSchema = z.discriminatedUnion("type", [
   startMessageSchema,
@@ -238,7 +195,7 @@ var inboundMessageSchema = z.discriminatedUnion("type", [
 var CLI_SHIM_FILENAME = "harness-tool.mjs";
 
 // src/version.ts
-var VERSION = true ? "1.0.93" : "0.0.0-test";
+var VERSION = true ? "1.0.95" : "0.0.0-test";
 
 // src/codex-harness.ts
 var DEFAULT_CODEX_MODEL = "gpt-5.5";
@@ -265,6 +222,7 @@ var codexBridgeCoordsSchema = z2.object({
 });
 var codexResumeStateSchema = z2.object({
   threadId: z2.string().optional(),
+  turnConfigurationFingerprint: z2.string().optional(),
   bridge: codexBridgeCoordsSchema.optional(),
   sandboxCredentialEnvironment: z2.record(z2.string(), z2.string()).optional()
 });
@@ -277,6 +235,7 @@ function createCodex(settings = {}) {
     lifecycleStateSchema: codexResumeStateSchema,
     getBootstrap: getCodexBootstrap,
     doStart: async (startOpts) => {
+      const model = startOpts.model ?? settings.model ?? DEFAULT_CODEX_MODEL;
       if (startOpts.builtinToolFiltering != null) {
         throw new HarnessCapabilityUnsupportedError({
           message: "Harness 'codex' does not support built-in tool filtering controls.",
@@ -313,6 +272,7 @@ function createCodex(settings = {}) {
       const resumeData = isResume && typeof lifecycleState?.data === "object" ? lifecycleState.data : void 0;
       const resumeThreadId = resumeData?.threadId;
       const resumeThreadIdString = typeof resumeThreadId === "string" && resumeThreadId.length > 0 ? resumeThreadId : void 0;
+      const turnConfigurationFingerprint = typeof resumeData?.turnConfigurationFingerprint === "string" ? resumeData.turnConfigurationFingerprint : void 0;
       const coords = resumeData?.bridge;
       const authenticationMode = resolveCodexAuthenticationMode(settings.auth);
       const resolvedAuthEnvironment = resolveCodexEnv(settings.auth);
@@ -351,6 +311,10 @@ function createCodex(settings = {}) {
         CODEX_BOOTSTRAP_DIR
       );
       const workDir = startOpts.sessionWorkDir;
+      const sandboxHomeDir = await resolveSandboxHomeDir({
+        sandbox: toolSafeSandboxSession,
+        abortSignal: startOpts.abortSignal
+      });
       const sessionDataDir = `${defaultWorkingDirectory}/.agent-runs/${startOpts.sessionId}`;
       const bridgeStateDir = `${sessionDataDir}/bridge`;
       const cliShimDir = `${sessionDataDir}/codex`;
@@ -392,7 +356,7 @@ function createCodex(settings = {}) {
             cliShimPath,
             // The live bridge was spawned by another process; no process handle.
             proc: void 0,
-            model: settings.model ?? DEFAULT_CODEX_MODEL,
+            model,
             reasoningEffort: settings.reasoningEffort,
             webSearch: settings.webSearch,
             codexConfig: settings.codexConfig,
@@ -406,7 +370,10 @@ function createCodex(settings = {}) {
             sandboxId,
             sandboxCredentialEnvironment,
             debug: startOpts.observability?.debug,
-            permissionMode: startOpts.permissionMode
+            permissionMode: startOpts.permissionMode,
+            sandbox: toolSafeSandboxSession,
+            sandboxHomeDir,
+            turnConfigurationFingerprint
           });
         } catch {
         }
@@ -433,20 +400,11 @@ function createCodex(settings = {}) {
         credentialEnvironmentVariables: CODEX_CREDENTIAL_ENVIRONMENT_VARIABLES,
         credentialForwarding: settings.credentialForwarding
       });
-      const codexSkillSetup = startOpts.skills && startOpts.skills.length > 0 ? await writeCodexSkills({
-        sandbox: toolSafeSandboxSession,
-        skills: startOpts.skills,
-        abortSignal: startOpts.abortSignal
-      }) : void 0;
       const env = {
         ...forwardedAuthEnvironment,
         AI_SDK_HARNESS_CLIENT_APP: CODEX_CLIENT_APP,
         BRIDGE_CHANNEL_TOKEN: token,
         BRIDGE_WS_PORT: String(port),
-        ...codexSkillSetup ? {
-          HOME: codexSkillSetup.homeDir,
-          CODEX_HOME: codexSkillSetup.codexHomeDir
-        } : {},
         ...respawnStrategy === "replay" ? { BRIDGE_REPLAY_FROM_DISK: "1" } : {}
       };
       if (respawnStrategy === void 0) {
@@ -520,7 +478,7 @@ function createCodex(settings = {}) {
         channel,
         cliShimPath,
         proc,
-        model: settings.model ?? DEFAULT_CODEX_MODEL,
+        model,
         reasoningEffort: settings.reasoningEffort,
         webSearch: settings.webSearch,
         codexConfig: settings.codexConfig,
@@ -534,7 +492,10 @@ function createCodex(settings = {}) {
         sandboxId,
         sandboxCredentialEnvironment,
         debug: startOpts.observability?.debug,
-        permissionMode: startOpts.permissionMode
+        permissionMode: startOpts.permissionMode,
+        sandbox: toolSafeSandboxSession,
+        sandboxHomeDir,
+        turnConfigurationFingerprint
       });
     }
   };
@@ -587,17 +548,12 @@ async function resolveBridgeEndpoint({
 }
 async function writeCodexSkills({
   sandbox,
+  sandboxHomeDir,
   skills,
   abortSignal
 }) {
-  const homeDir = await resolveSandboxHomeDir({ sandbox, abortSignal });
-  const codexHomeDir = path.posix.join(homeDir, ".codex");
-  await sandbox.run({
-    command: `mkdir -p ${shellQuote(codexHomeDir)}`,
-    abortSignal
-  });
-  const rootDir = path.posix.join(homeDir, ".agents", "skills");
-  await writeHarnessSkills({
+  const rootDir = path.posix.join(sandboxHomeDir, ".agents", "skills");
+  return writeHarnessSkills({
     sandbox,
     rootDir,
     skills,
@@ -605,10 +561,6 @@ async function writeCodexSkills({
     invalidSkillNameMessage: ({ name }) => `Invalid Codex skill name: ${name}`,
     invalidSkillFilePathMessage: ({ skillName, filePath }) => `Invalid Codex skill file path for ${skillName}: ${filePath}`
   });
-  return {
-    homeDir,
-    codexHomeDir
-  };
 }
 function openWebSocket({
   url,
@@ -657,16 +609,44 @@ function createSession({
   sandboxId,
   sandboxCredentialEnvironment,
   debug,
-  permissionMode
+  permissionMode,
+  sandbox,
+  sandboxHomeDir,
+  turnConfigurationFingerprint
 }) {
   let stopped = false;
   let stopPromise;
   let pendingResumeThreadId = seedResumeThreadOnFirstPrompt ? resumeThreadId : void 0;
   let initialPromptGuidanceApplied = isResume;
   let latestThreadId = resumeThreadId;
+  let latestTurnConfigurationFingerprint = turnConfigurationFingerprint;
   channel.on("bridge-thread", (msg) => {
     latestThreadId = msg.threadId;
   });
+  const synchronizeTurnConfiguration = async ({
+    skills,
+    instructions,
+    tools,
+    abortSignal
+  }) => {
+    const skillsResult = await writeCodexSkills({
+      sandbox,
+      sandboxHomeDir,
+      skills,
+      abortSignal
+    });
+    const nextFingerprint = fingerprintCodexTurnConfiguration({
+      instructions,
+      tools
+    });
+    const restartThread = latestThreadId != null && (skillsResult.changed || latestTurnConfigurationFingerprint != null && latestTurnConfigurationFingerprint !== nextFingerprint);
+    latestTurnConfigurationFingerprint = nextFingerprint;
+    if (restartThread) {
+      initialPromptGuidanceApplied = false;
+      pendingResumeThreadId = void 0;
+    }
+    return { restartThread };
+  };
   const wireTurn = (turnOpts) => {
     let pendingResolve;
     let pendingReject;
@@ -801,15 +781,21 @@ function createSession({
           harnessId: "codex"
         });
       }
-      const turn = wireTurn({
-        emit: promptOpts.emit,
-        abortSignal: promptOpts.abortSignal
-      });
       const tools = (promptOpts.tools ?? []).map((t) => ({
         name: t.name,
         description: t.description,
         inputSchema: t.inputSchema
       }));
+      const { restartThread } = await synchronizeTurnConfiguration({
+        skills: promptOpts.skills,
+        instructions: promptOpts.instructions,
+        tools,
+        abortSignal: promptOpts.abortSignal
+      });
+      const turn = wireTurn({
+        emit: promptOpts.emit,
+        abortSignal: promptOpts.abortSignal
+      });
       let promptText = extractUserText(promptOpts.prompt);
       if (!initialPromptGuidanceApplied) {
         promptText = frameInitialPromptGuidance({
@@ -834,6 +820,7 @@ function createSession({
         ...mcpServers == null ? {} : { mcpServers },
         ...permissionMode ? { permissionMode } : {},
         ...pendingResumeThreadId ? { resumeThreadId: pendingResumeThreadId } : {},
+        ...restartThread ? { restartThread: true } : {},
         ...debug ? { debug } : {}
       };
       pendingResumeThreadId = void 0;
@@ -847,6 +834,17 @@ function createSession({
           harnessId: "codex"
         });
       }
+      const tools = (continueOpts.tools ?? []).map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema
+      }));
+      const { restartThread } = await synchronizeTurnConfiguration({
+        skills: continueOpts.skills,
+        instructions: continueOpts.instructions,
+        tools,
+        abortSignal: continueOpts.abortSignal
+      });
       const turn = wireTurn({
         emit: continueOpts.emit,
         abortSignal: continueOpts.abortSignal
@@ -865,11 +863,7 @@ function createSession({
              * empty text block trips the Anthropic API's `cache_control` rule).
              */
             prompt: "Continue.",
-            tools: (continueOpts.tools ?? []).map((t) => ({
-              name: t.name,
-              description: t.description,
-              inputSchema: t.inputSchema
-            })),
+            tools,
             ...continueOpts.responseFormat == null ? {} : { responseFormat: continueOpts.responseFormat },
             ...continueOpts.instructions ? { instructions: continueOpts.instructions } : {},
             model,
@@ -879,6 +873,7 @@ function createSession({
             ...mcpServers == null ? {} : { mcpServers },
             ...permissionMode ? { permissionMode } : {},
             ...threadId ? { resumeThreadId: threadId } : {},
+            ...restartThread ? { restartThread: true } : {},
             ...debug ? { debug } : {}
           })
         );
@@ -905,6 +900,9 @@ function createSession({
         specificationVersion: "harness-v1",
         data: {
           ...latestThreadId ? { threadId: latestThreadId } : {},
+          ...latestTurnConfigurationFingerprint ? {
+            turnConfigurationFingerprint: latestTurnConfigurationFingerprint
+          } : {},
           ...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment },
           bridge: {
             port: bridgePort,
@@ -1006,6 +1004,9 @@ function createSession({
         specificationVersion: "harness-v1",
         data: {
           ...lifecycleData,
+          ...latestTurnConfigurationFingerprint ? {
+            turnConfigurationFingerprint: latestTurnConfigurationFingerprint
+          } : {},
           ...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment }
         }
       };
@@ -1025,6 +1026,9 @@ function createSession({
         specificationVersion: "harness-v1",
         data: {
           ...latestThreadId ? { threadId: latestThreadId } : {},
+          ...latestTurnConfigurationFingerprint ? {
+            turnConfigurationFingerprint: latestTurnConfigurationFingerprint
+          } : {},
           ...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment },
           bridge: {
             port: bridgePort,
@@ -1038,6 +1042,12 @@ function createSession({
     }
   };
 }
+function fingerprintCodexTurnConfiguration({
+  instructions,
+  tools
+}) {
+  return createHash("sha256").update(JSON.stringify({ instructions: instructions ?? null, tools })).digest("hex");
+}
 function frameInitialPromptGuidance({
   toolUsageBlock,
   userText