OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security
TypeScript ai-securityapplication-securityclicode-scanningcodexcodex-securitycybersecuritydevsecopsnodejsnpmopenaisdksecuritytypescriptvulnerability-scanning
fix: preserve Daybreak settings across scans and remediation (#1740)
Michael D'Angelo04df406934b8
diff --git a/README.md b/README.mdindex 108e45e6f..d70ee6d75 100644--- a/README.md+++ b/README.md@@ -63,6 +63,10 @@ If you have Daybreak Blue access, add `--cyber-access-program daybreak_blue`to the scan command. Otherwise, omit the flag or use`--cyber-access-program standard`.+To use Codex's Daybreak toggle, pass `--codex daybreak=true`. It defaults off+and requires compatible access. See [Daybreak configuration](sdk/typescript/docs/cli.md#daybreak-opt-in)+for SDK and plugin usage, including Deep Scan workers.+Scans use your existing `SECURITY.md` guidance. To define or update it,optionally [draft a policy](#generate-securitymd):diff --git a/docs/project-configuration.md b/docs/project-configuration.mdindex 327921345..9e1651d67 100644--- a/docs/project-configuration.md+++ b/docs/project-configuration.md@@ -58,6 +58,12 @@ keep their native spelling; names and values are not converted.YAML anchors are supported; the parser retains its guard against excessive nestedalias expansion.+For Daybreak on Codex 0.163.0 or later, set `codex.daybreak` to `true`; the toggle+defaults off. This native setting is retained in scan recipes and passed to+Deep Scan discovery and reducer workers, including resumes. An explicit+`scan.cyber_access_program` takes precedence for each turn. See+[Daybreak opt-in](../sdk/typescript/docs/cli.md#daybreak-opt-in).+The [YAML example](examples/codex-security.yaml) and equivalent[JSON example](examples/codex-security.json) select this repository's TypeScriptsource. After [setting up the source checkout](../sdk/typescript/TESTING.md), try:diff --git a/plugins/codex-security/mcp-app/server.ts b/plugins/codex-security/mcp-app/server.tsindex b334c7984..1a7bb1d3f 100644--- a/plugins/codex-security/mcp-app/server.ts+++ b/plugins/codex-security/mcp-app/server.ts@@ -24,6 +24,7 @@ import {AsyncLock,} from "./src/deep-scan/registry.js";import { startDeepScanEngine } from "./src/deep-scan/engine.js";+import type { DeepScanParentTurn } from "./src/deep-scan/permission-profile-preflight.js";import {CODEX_SANDBOX_STATE_META_CAPABILITY,resolveDeepWorkerParentSandbox,@@ -970,6 +971,7 @@ export function createCodexSecurityServer(): McpServer {runWorkbench,...modelSettings,parentSandbox,+ parentTurn: codexParentTurnFromExtra(extra),pythonCommand: await resolvePythonCommand(),pluginRoot: PLUGIN_ROOT,log: logDeepScanEvent,@@ -2194,6 +2196,20 @@ function codexTurnMetadataFromExtra(extra: unknown): JsonObject | undefined {: undefined;}+function codexParentTurnFromExtra(+ extra: unknown,+): DeepScanParentTurn | undefined {+ const metadata = codexTurnMetadataFromExtra(extra);+ const threadId = metadata?.thread_id;+ const turnId = metadata?.turn_id;+ return typeof threadId === "string" &&+ threadId &&+ typeof turnId === "string" &&+ turnId+ ? { threadId, turnId }+ : undefined;+}+function codexModelSettingsFromExtra(extra: unknown): {model?: string;reasoningEffort?: string;diff --git a/plugins/codex-security/mcp-app/src/deep-scan/engine.ts b/plugins/codex-security/mcp-app/src/deep-scan/engine.tsindex 0316ab8bb..fed55951a 100644--- a/plugins/codex-security/mcp-app/src/deep-scan/engine.ts+++ b/plugins/codex-security/mcp-app/src/deep-scan/engine.ts@@ -2,6 +2,7 @@ import { createScanArtifactContext } from "../artifact-context.js";import { recordCodexSecurityScanDraftViaWorkbench } from "../artifact-scan-draft.js";import { CodexSdkWorkerExecutor } from "./executor.js";import type { DeepWorkerParentSandbox } from "./parent-sandbox.js";+import type { DeepScanParentTurn } from "./permission-profile-preflight.js";import {DeepScanCoordinatorRegistry,startOrJoinDeepScanCoordinator,@@ -18,6 +19,7 @@ export function startDeepScanEngine(options: {pluginRoot: string;pythonCommand: string;parentSandbox: DeepWorkerParentSandbox;+ parentTurn?: DeepScanParentTurn;threadId: string;handoffClaimToken?: string;model?: string;@@ -35,6 +37,7 @@ export function startDeepScanEngine(options: {model: options.model,reasoningEffort: options.reasoningEffort,parentSandbox: options.parentSandbox,+ parentTurn: options.parentTurn,artifactContext: {pluginRoot,repoRoot: run.targetPath,diff --git a/plugins/codex-security/mcp-app/src/deep-scan/executor.ts b/plugins/codex-security/mcp-app/src/deep-scan/executor.tsindex 87a46dedc..f1aedfa7c 100644--- a/plugins/codex-security/mcp-app/src/deep-scan/executor.ts+++ b/plugins/codex-security/mcp-app/src/deep-scan/executor.ts@@ -42,6 +42,8 @@ import {DEEP_SCAN_WORKER_PERMISSION_PROFILE_ID,deepScanPermissionProfileFallbackError,preflightDeepScanWorkerPermissionProfile,+ readDeepScanParentCyberAccessProgram,+ type DeepScanParentTurn,} from "./permission-profile-preflight.js";import type { DeepWorkerParentSandbox } from "./parent-sandbox.js";import type {@@ -56,6 +58,7 @@ export interface CodexSdkWorkerModelSettings {reasoningEffort?: string;artifactContext?: CodexSdkWorkerArtifactContext;parentSandbox?: DeepWorkerParentSandbox;+ parentTurn?: DeepScanParentTurn;}/** The coordinator supplies scan identity; worker tools never choose paths. */@@ -79,6 +82,7 @@ interface CodexSdkWorkerRuntimeSettings {export class CodexSdkWorkerExecutor implements CodexWorkerExecutor {private runtimeSettings?: Promise<CodexSdkWorkerRuntimeSettings>;+ private parentCyberAccessProgram?: Promise<CyberAccessProgram | undefined>;constructor(private readonly modelSettings: CodexSdkWorkerModelSettings = {},@@ -158,16 +162,39 @@ export class CodexSdkWorkerExecutor implements CodexWorkerExecutor {process.arch,originalCwd,);+ const preflightOptions = {+ codexPath,+ cwd: request.workingDirectory,+ configOverrides,+ providerConfigOverrides: runtimeSettings.preflightProviderOverrides,+ env: childEnv,+ signal: request.signal,+ };+ const parentProgram = this.modelSettings.parentTurn+ ? await (this.parentCyberAccessProgram ??=+ readDeepScanParentCyberAccessProgram({+ ...preflightOptions,+ parentTurn: this.modelSettings.parentTurn,+ }).catch((error: unknown) => {+ this.parentCyberAccessProgram = undefined;+ throw error;+ }))+ : undefined;+ const workerFeatures = runtimeSettings.config.features;+ if (+ parentProgram !== undefined &&+ (!isRecord(workerFeatures) ||+ workerFeatures.api_key_cyber_access_programs === undefined)+ ) {+ // Transmitting the inherited program requires this gate for API-key auth.+ // Explicit per-scan feature settings remain authoritative.+ configOverrides.push("features.api_key_cyber_access_programs=true");+ }const { useOpenAiApiKey } =await preflightDeepScanWorkerPermissionProfile({- codexPath,- cwd: request.workingDirectory,- configOverrides,- providerConfigOverrides: runtimeSettings.preflightProviderOverrides,+ ...preflightOptions,expectedProfile: workerProfile,- env: childEnv,allowOpenAiApiKeyFallback: Boolean(openAiApiKey && !codexApiKey),- signal: request.signal,});const prompt = await fs.readFile(request.promptPath, "utf8");const codexOptions = {@@ -215,7 +242,8 @@ export class CodexSdkWorkerExecutor implements CodexWorkerExecutor {try {const { events } = await thread.runStreamed(input, {signal: controller.signal,- cyberAccessProgram: runtimeSettings.cyberAccessProgram,+ cyberAccessProgram:+ parentProgram ?? runtimeSettings.cyberAccessProgram,});const diagnostics: CodexWorkerDiagnostic[] = [];const turn = await readCodexSessionTurn({diff --git a/plugins/codex-security/mcp-app/src/deep-scan/permission-profile-preflight.ts b/plugins/codex-security/mcp-app/src/deep-scan/permission-profile-preflight.tsindex 1a4d8999c..af19bb370 100644--- a/plugins/codex-security/mcp-app/src/deep-scan/permission-profile-preflight.ts+++ b/plugins/codex-security/mcp-app/src/deep-scan/permission-profile-preflight.ts@@ -1,4 +1,5 @@import type { JsonObject as JsonRecord } from "../types.js";+import type { CyberAccessProgram } from "@openai/codex-sdk";import { asRecord as record } from "../record.js";import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";import { createInterface, type Interface } from "node:readline";@@ -49,6 +50,8 @@ type RuntimeConfigReadOptions = Pick<"codexPath" | "cwd" | "configOverrides" | "env" | "signal" | "context"> & {readonly commandArgs?: readonly string[];+ /** Full app-server invocation for callers that already constructed its arguments. */+ readonly appServerArgs?: readonly string[];readonly providerConfigOverrides?: readonly string[];};@@ -67,6 +70,74 @@ export async function readDeepScanRuntimeConfig(});}+/** Read native origins and ordered layers without starting a thread. */+export async function readDeepScanRuntimeConfigWithOrigins(+ options: RuntimeConfigReadOptions,+): Promise<JsonRecord> {+ return withPreflightClient(options, (client) =>+ client.request("config/read", { cwd: options.cwd, includeLayers: true }),+ );+}++export interface DeepScanParentTurn {+ readonly threadId: string;+ readonly turnId: string;+}++/** Read the program of the exact parent turn that invoked the plugin. */+export async function readDeepScanParentCyberAccessProgram(+ options: RuntimeConfigReadOptions & {+ readonly parentTurn: DeepScanParentTurn;+ },+): Promise<CyberAccessProgram | undefined> {+ return withPreflightClient(options, async (client) => {+ let response: JsonRecord;+ try {+ response = await client.request("thread/read", {+ threadId: options.parentTurn.threadId,+ includeTurns: false,+ });+ } catch (error) {+ const nativeError = record(+ error instanceof Error ? error.cause : undefined,+ );+ // Ephemeral parent threads have no persisted rollout for this separate client.+ if (+ nativeError?.code === -32600 &&+ nativeError.message ===+ `thread not loaded: ${options.parentTurn.threadId}`+ )+ return undefined;+ throw error;+ }+ const thread = record(response.thread);+ if (+ thread?.id !== options.parentTurn.threadId ||+ typeof thread.path !== "string"+ )+ return undefined;+ const input = createReadStream(thread.path, { encoding: "utf8" });+ const lines = createInterface({ input, crlfDelay: Infinity });+ try {+ for await (const line of lines) {+ if (!line.trim()) continue;+ const entry = record(JSON.parse(line));+ if (entry?.type !== "turn_context") continue;+ const context = record(entry.payload);+ if (context?.turn_id !== options.parentTurn.turnId) continue;+ const program = context.cyber_access_program;+ return typeof program === "string"+ ? (program as CyberAccessProgram)+ : undefined;+ }+ return undefined;+ } finally {+ lines.close();+ input.destroy();+ }+ });+}+/** Persist the owning session and obtain native permissions without a model turn. */export async function prepareCliDeepScanSession(options: RuntimeConfigReadOptions & {@@ -237,15 +308,19 @@ class AppServerPreflightClient {};constructor(private readonly options: RuntimeConfigReadOptions) {- const args: string[] = [...(options.commandArgs ?? [])];- for (const override of options.configOverrides) {- args.push("--config", override);- }- // App-server loads credential-free metadata; exec reads private provider profiles.- for (const override of options.providerConfigOverrides ?? []) {- args.push("--config", override);+ const args: string[] = [+ ...(options.appServerArgs ?? options.commandArgs ?? []),+ ];+ if (options.appServerArgs === undefined) {+ for (const override of options.configOverrides) {+ args.push("--config", override);+ }+ // App-server loads credential-free metadata; exec reads private provider profiles.+ for (const override of options.providerConfigOverrides ?? []) {+ args.push("--config", override);+ }+ args.push("app-server", "--stdio");}- args.push("app-server", "--stdio");this.child = spawn(executablePathForSpawn(options.codexPath), args, {cwd: options.cwd,@@ -648,6 +723,7 @@ function jsonRpcPreflightError(subject(context) +" did not run." +(typeof error?.message === "string" ? "\n" + error.message : ""),+ { cause: value },);}diff --git a/plugins/codex-security/mcp-app/tests/deep_scan_worker_settings_cases.ts b/plugins/codex-security/mcp-app/tests/deep_scan_worker_settings_cases.tsnew file mode 100644index 000000000..8f06be4fc--- /dev/null+++ b/plugins/codex-security/mcp-app/tests/deep_scan_worker_settings_cases.ts@@ -0,0 +1,488 @@+import assert from "node:assert/strict";+import childProcess, { type SpawnOptions } from "node:child_process";+import { writeFile } from "node:fs/promises";+import { syncBuiltinESMExports } from "node:module";+import path from "node:path";+import { stringify as stringifyToml } from "smol-toml";+import type { CodexSdkWorkerExecutor as Executor } from "../src/deep-scan/executor.js";+import type { DeepWorkerParentSandbox } from "../src/deep-scan/parent-sandbox.js";+import type { CodexWorkerRequest } from "../src/deep-scan/types.js";+import { assertFlagPair } from "./assertions.ts";+import { readJson } from "./support/json.ts";++export async function testWorkerCyberAccessSettings({+ CodexSdkWorkerExecutor,+ fakeCodexFixture,+ parentSandbox,+ workerRequest,+ assertConfigOverrides,+ assertReadOnlyWorkerPolicy,+ assertWorkerSubagentPolicy,+ restoreEnv,+}: {+ CodexSdkWorkerExecutor: typeof Executor;+ fakeCodexFixture: () => Promise<{ root: string; executablePath: string }>;+ parentSandbox: DeepWorkerParentSandbox;+ workerRequest: (+ promptPath: string,+ workingDirectory: string,+ options: Partial<CodexWorkerRequest>,+ ) => CodexWorkerRequest;+ assertConfigOverrides: (+ args: readonly string[],+ values: Record<string, string | number | boolean | undefined>,+ ) => void;+ assertReadOnlyWorkerPolicy: (args: readonly string[]) => void;+ assertWorkerSubagentPolicy: (+ args: readonly string[],+ subagents: number,+ ) => void;+ restoreEnv: (name: string, value: string | undefined) => void;+}) {+ const cases: {+ name: string;+ configuration?: string;+ workerFeatures?: Record<string, boolean>;+ daybreak?: boolean;+ workerDaybreak?: boolean;+ nativeProfile?: string;+ program?: string;+ parentProgram?: string;+ parentTurn?: { threadId: string; turnId: string };+ missingParentTurn?: boolean;+ failParentReadOnce?: boolean;+ serviceTier?: string;+ features?: Record<string, boolean>;+ configPath?: string;+ workerConfigPath?: string;+ executor?: import("../src/deep-scan/executor.js").CodexSdkWorkerExecutor;+ }[] = [+ { name: "unset", configuration: "" },+ {+ name: "blue",+ configuration:+ 'daybreak = true\nservice_tier = "fast"\n[codex_security]\ncyber_access_program = "daybreak_blue"\n[features]\ncli_daybreak = true\napi_key_cyber_access_programs = true\napi_key_model_discovery = true\n',+ daybreak: true,+ serviceTier: "fast",+ program: "daybreak_blue",+ features: {+ cli_daybreak: true,+ api_key_cyber_access_programs: true,+ api_key_model_discovery: true,+ },+ },+ {+ name: "explicit-false",+ configuration:+ 'daybreak = false\nservice_tier = "flex"\n[codex_security]\ncyber_access_program = "daybreak_blue"\n[features]\ncli_daybreak = false\napi_key_cyber_access_programs = false\napi_key_model_discovery = false\n',+ daybreak: false,+ serviceTier: "flex",+ program: "daybreak_blue",+ features: {+ cli_daybreak: false,+ api_key_cyber_access_programs: false,+ api_key_model_discovery: false,+ },+ },+ {+ name: "other-program",+ configuration:+ 'daybreak = true\nservice_tier = "flex"\nprofile = "cloud.production"\n[profiles."cloud.production"]\ndaybreak = false\nservice_tier = "fast"\n[codex_security]\ncyber_access_program = "standard"\n[features]\napi_key_cyber_access_programs = true\napi_key_model_discovery = false\n',+ daybreak: false,+ serviceTier: "fast",+ program: "standard",+ features: {+ api_key_cyber_access_programs: true,+ api_key_model_discovery: false,+ },+ },+ {+ name: "features-only",+ configuration:+ 'daybreak = true\nservice_tier = "fast"\nprofile = "selected"\n[profiles.selected]\nmodel = "fixture-model"\n[features]\ncli_daybreak = false\napi_key_cyber_access_programs = false\napi_key_model_discovery = true\n',+ daybreak: true,+ serviceTier: "fast",+ features: {+ cli_daybreak: false,+ api_key_cyber_access_programs: false,+ api_key_model_discovery: true,+ },+ },+ {+ name: "parent-standard",+ configuration:+ 'daybreak = true\n[codex_security]\ncyber_access_program = "daybreak_blue"\n',+ daybreak: true,+ program: "standard",+ parentProgram: "standard",+ parentTurn: { threadId: "parent-standard", turnId: "active-standard" },+ features: { api_key_cyber_access_programs: true },+ },+ {+ name: "parent-blue",+ configuration:+ 'daybreak = false\n[codex_security]\ncyber_access_program = "daybreak_red"\n',+ daybreak: false,+ program: "daybreak_blue",+ parentProgram: "daybreak_blue",+ parentTurn: { threadId: "parent-blue", turnId: "active-blue" },+ features: { api_key_cyber_access_programs: true },+ failParentReadOnce: true,+ },+ {+ name: "parent-red",+ configuration:+ 'daybreak = false\n[codex_security]\ncyber_access_program = "standard"\n',+ daybreak: false,+ workerDaybreak: false,+ nativeProfile: "parent_profile_fixture",+ program: "daybreak_red",+ parentProgram: "daybreak_red",+ parentTurn: { threadId: "parent-red", turnId: "active-red" },+ features: { api_key_cyber_access_programs: true },+ },+ {+ name: "parent-native-home",+ program: "standard",+ parentProgram: "standard",+ parentTurn: { threadId: "parent-native-home", turnId: "active-native" },+ features: { api_key_cyber_access_programs: true },+ },+ {+ name: "parent-gate-disabled",+ configuration: "[features]\napi_key_cyber_access_programs = false\n",+ program: "daybreak_blue",+ parentProgram: "daybreak_blue",+ parentTurn: { threadId: "parent-disabled", turnId: "active-disabled" },+ features: { api_key_cyber_access_programs: false },+ },+ ...[true, false].map((enabled) => ({+ name: `parent-snapshot-gate-${enabled}`,+ configuration: `[features]\napi_key_cyber_access_programs = ${!enabled}\n`,+ workerFeatures: { api_key_cyber_access_programs: enabled },+ program: "daybreak_red",+ parentProgram: "daybreak_red",+ parentTurn: {+ threadId: `parent-snapshot-${enabled}`,+ turnId: `active-snapshot-${enabled}`,+ },+ features: { api_key_cyber_access_programs: enabled },+ })),+ {+ name: "parent-turn-unavailable",+ configuration:+ 'daybreak = false\n[codex_security]\ncyber_access_program = "daybreak_blue"\n',+ daybreak: false,+ program: "daybreak_blue",+ parentProgram: "daybreak_red",+ parentTurn: { threadId: "parent-unavailable", turnId: "active-missing" },+ missingParentTurn: true,+ },+ {+ name: "snapshot-enabled",+ configuration: "daybreak = false\n",+ daybreak: true,+ workerDaybreak: true,+ },+ {+ name: "snapshot-disabled",+ configuration: "daybreak = true\n",+ daybreak: false,+ workerDaybreak: false,+ nativeProfile: "daybreak_fixture",+ },+ ];+ const saved = [+ "CODEX_CLI_PATH",+ "CODEX_HOME",+ "CODEX_SECURITY_CONFIG_PATH",+ "CODEX_SECURITY_DEEP_SCAN_CONFIG_PATH",+ "OPENAI_API_KEY",+ "CODEX_API_KEY",+ ].map((name) => [name, process.env[name]] as const);+ const originalSpawn = childProcess.spawn;+ const fixture = await fakeCodexFixture();+ const writeParentTurn = (threadId: string, turnId: string, program: string) =>+ writeFile(+ path.join(fixture.root, `${threadId}.jsonl`),+ [+ { type: "session_meta", payload: { id: threadId } },+ {+ type: "turn_context",+ payload: { turn_id: turnId, cyber_access_program: program },+ },+ ]+ .map((record) => JSON.stringify(record))+ .join("\n") + "\n",+ );+ const promptPath = path.join(fixture.root, "prompt.md");+ const launches: {+ args: readonly string[];+ markerPath: string;+ configPath: string | undefined;+ }[] = [];+ try {+ delete process.env.OPENAI_API_KEY;+ process.env.CODEX_API_KEY = "synthetic-worker-api-key";+ process.env.CODEX_CLI_PATH = process.execPath;+ process.env.CODEX_HOME = fixture.root;+ await writeFile(promptPath, "CAPTURE_SYNTHETIC_OPENAI_AUTH");+ await writeFile(+ path.join(fixture.root, "config.toml"),+ "[features]\napi_key_cyber_access_programs = false\n",+ );+ childProcess.spawn = ((+ command: string,+ args: readonly string[],+ options: SpawnOptions,+ ) => {+ const markerPath = path.join(+ fixture.root,+ `cyber-${launches.length}.json`,+ );+ const environment = {+ ...options!.env,+ FAKE_CODEX_MARKER: markerPath,+ FAKE_CODEX_PREFLIGHT_MARKER: markerPath,+ };+ launches.push({+ args,+ markerPath,+ configPath: options.env?.CODEX_SECURITY_CONFIG_PATH,+ });+ return originalSpawn(command, [fixture.executablePath, ...args], {+ ...options,+ env: environment,+ });+ }) as typeof childProcess.spawn;+ syncBuiltinESMExports();+ for (const testCase of cases) {+ if (testCase.configuration !== undefined) {+ testCase.configPath = path.join(fixture.root, `${testCase.name}.toml`);+ await writeFile(testCase.configPath, testCase.configuration);+ }+ if (+ testCase.workerDaybreak !== undefined ||+ testCase.workerFeatures !== undefined+ ) {+ testCase.workerConfigPath = `${testCase.configPath}.deep`;+ await writeFile(+ testCase.workerConfigPath,+ stringifyToml({+ worker_runtime: {+ ...(testCase.workerDaybreak === undefined+ ? {}+ : { daybreak: testCase.workerDaybreak }),+ ...(testCase.workerFeatures === undefined+ ? {}+ : { features: testCase.workerFeatures }),+ ...(testCase.nativeProfile === undefined+ ? {}+ : { native_profile: testCase.nativeProfile }),+ },+ }),+ );+ }+ if (testCase.nativeProfile !== undefined) {+ await writeFile(+ path.join(fixture.root, `${testCase.nativeProfile}.config.toml`),+ "",+ );+ }+ if (testCase.parentTurn !== undefined) {+ await writeParentTurn(+ testCase.parentTurn.threadId,+ testCase.missingParentTurn+ ? "different-turn"+ : testCase.parentTurn.turnId,+ testCase.parentProgram!,+ );+ }+ testCase.executor = new CodexSdkWorkerExecutor({+ model: testCase.name,+ parentSandbox,+ parentTurn: testCase.parentTurn,+ });+ }+ for (const testCase of cases.filter(+ ({ failParentReadOnce }) => failParentReadOnce,+ )) {+ await writeFile(+ path.join(+ fixture.root,+ `${testCase.parentTurn!.threadId}.read-fails-once`,+ ),+ "",+ );+ restoreEnv("CODEX_SECURITY_CONFIG_PATH", testCase.configPath);+ restoreEnv(+ "CODEX_SECURITY_DEEP_SCAN_CONFIG_PATH",+ testCase.workerConfigPath,+ );+ await assert.rejects(+ testCase.executor!.run(workerRequest(promptPath, fixture.root, {})),+ /synthetic parent read temporary failure/,+ );+ assert.equal(+ launches.some(({ args }) => args[0] === "exec"),+ false,+ );+ const failedParentReads = (+ await Promise.all(+ launches.map(({ markerPath }) => readJson(markerPath)),+ )+ ).flatMap((launch) =>+ launch.requests.filter(+ (request: { method: string }) => request.method === "thread/read",+ ),+ );+ assert.deepEqual(failedParentReads, [+ { method: "thread/read", threadId: testCase.parentTurn!.threadId },+ ]);+ }+ for (const kind of ["discovery", "dedup"] as const) {+ for (const resumeThreadId of [undefined, "fixture-resumed-thread"]) {+ launches.length = 0;+ await Promise.all(+ cases.map((testCase) => {+ // Each scan captures its own config before its asynchronous launch.+ restoreEnv("CODEX_SECURITY_CONFIG_PATH", testCase.configPath);+ restoreEnv(+ "CODEX_SECURITY_DEEP_SCAN_CONFIG_PATH",+ testCase.workerConfigPath,+ );+ return testCase.executor!.run(+ workerRequest(promptPath, fixture.root, { kind, resumeThreadId }),+ );+ }),+ );+ const workerLaunches = launches.filter(+ ({ args }) => args[0] === "exec",+ );+ assert.equal(workerLaunches.length, cases.length);+ const preflights = await Promise.all(+ launches+ .filter(({ args }) => args.includes("app-server"))+ .map(async (launch) => ({+ ...launch,+ invocation: await readJson(launch.markerPath),+ })),+ );+ for (const {+ name,+ daybreak,+ program,+ serviceTier,+ features = {},+ configPath,+ } of cases) {+ const preflight = preflights.find(+ (entry) =>+ entry.configPath === configPath &&+ entry.invocation.requests.some(+ (request: { method: string }) =>+ request.method === "config/read",+ ),+ );+ assert.ok(preflight);+ assertConfigOverrides(preflight.args, {+ daybreak,+ "features.cli_daybreak": features.cli_daybreak,+ "features.api_key_cyber_access_programs":+ features.api_key_cyber_access_programs,+ "features.api_key_model_discovery":+ features.api_key_model_discovery,+ });+ const launch = workerLaunches.find(+ ({ args }) => args[args.indexOf("--model") + 1] === name,+ );+ const invocation = await readJson(launch!.markerPath);+ assert.deepEqual(+ invocation.argv.filter((arg: string) =>+ arg.startsWith("service_tier="),+ ),+ serviceTier === undefined+ ? []+ : [`service_tier=${JSON.stringify(serviceTier)}`],+ );+ if (program === undefined) {+ assert.equal(+ invocation.argv.includes("--cyber-access-program"),+ false,+ );+ } else {+ assertFlagPair(invocation.argv, "--cyber-access-program", program);+ }+ assertConfigOverrides(invocation.argv, {+ daybreak,+ "features.cli_daybreak": features.cli_daybreak,+ "features.api_key_cyber_access_programs":+ features.api_key_cyber_access_programs,+ "features.api_key_model_discovery":+ features.api_key_model_discovery,+ });+ assert.equal(+ invocation.openaiAuthentication.CODEX_API_KEY,+ "synthetic-worker-api-key",+ );+ assert.equal(+ invocation.argv.includes("resume"),+ resumeThreadId !== undefined,+ );+ assertReadOnlyWorkerPolicy(invocation.argv);+ assertWorkerSubagentPolicy(invocation.argv, 0);+ }+ const parentReads = preflights.flatMap(({ invocation }) =>+ invocation.requests.filter(+ (request: { method: string }) => request.method === "thread/read",+ ),+ );+ assert.deepEqual(+ parentReads+ .map((request: { threadId: string }) => request.threadId)+ .sort(),+ kind === "discovery" && resumeThreadId === undefined+ ? cases+ .flatMap(({ parentTurn }) =>+ parentTurn ? [parentTurn.threadId] : [],+ )+ .sort()+ : [],+ );+ // Running coordinators and their resumed workers retain their own settings.+ for (const {+ configPath,+ workerConfigPath,+ daybreak,+ features,+ parentTurn,+ parentProgram,+ } of cases) {+ if (parentTurn !== undefined) {+ await writeParentTurn(+ parentTurn.threadId,+ parentTurn.turnId,+ parentProgram === "standard" ? "daybreak_blue" : "standard",+ );+ }+ if (configPath !== undefined) {+ await writeFile(+ configPath,+ `daybreak = ${!daybreak}\n[codex_security]\ncyber_access_program = "daybreak_red"\n[features]\ncli_daybreak = ${!features?.cli_daybreak}\napi_key_cyber_access_programs = false\napi_key_model_discovery = false\n`,+ );+ }+ if (workerConfigPath !== undefined) {+ await writeFile(+ workerConfigPath,+ stringifyToml({ worker_runtime: { daybreak: !daybreak } }),+ );+ }+ }+ }+ }+ } finally {+ childProcess.spawn = originalSpawn;+ syncBuiltinESMExports();+ for (const [name, value] of saved) restoreEnv(name, value);+ }+}diff --git a/plugins/codex-security/mcp-app/tests/support/fake-codex-source.ts b/plugins/codex-security/mcp-app/tests/support/fake-codex-source.tsindex 29528944b..66668d75a 100644--- a/plugins/codex-security/mcp-app/tests/support/fake-codex-source.ts+++ b/plugins/codex-security/mcp-app/tests/support/fake-codex-source.ts@@ -7,7 +7,7 @@ export function fakeCodexSource(preflightMarkerPath: string,) {return `#!/usr/bin/env node-import { readFileSync, readdirSync, writeFileSync } from "node:fs";+import { existsSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";import { spawnSync } from "node:child_process";import { join } from "node:path";const preflightProfile = process.env.FAKE_CODEX_PREFLIGHT_PROFILE ? JSON.parse(process.env.FAKE_CODEX_PREFLIGHT_PROFILE) : ${JSON.stringify(preflightProfile)};@@ -25,6 +25,16 @@ ${jsonLineInputSource(` if (message.method === 'initialized') continue;let result;if (message.method === 'initialize') {result = { userAgent: 'fixture', codexHome: '/fixture', platformFamily: 'unix', platformOs: 'macos' };+ } else if (message.method === 'thread/read') {+ preflight.requests.push({ method: message.method, threadId: message.params.threadId });+ writeFileSync(preflightMarkerPath, JSON.stringify(preflight));+ const failOncePath = join(process.env.CODEX_HOME, message.params.threadId + '.read-fails-once');+ if (existsSync(failOncePath)) {+ unlinkSync(failOncePath);+ process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: message.id, error: { code: -32603, message: 'synthetic parent read temporary failure' } }) + '\\n');+ continue;+ }+ result = { thread: { id: message.params.threadId, path: join(process.env.CODEX_HOME, message.params.threadId + '.jsonl') } };} else if (message.method === 'config/read') {result = { config: { default_permissions: 'codex_security_deep_scan_worker', permissions: { codex_security_deep_scan_worker: preflightProfile } }, origins: {}, layers: null };} else if (message.method === 'permissionProfile/list') {diff --git a/plugins/codex-security/mcp-app/tests/test_deep_scan_executor.ts b/plugins/codex-security/mcp-app/tests/test_deep_scan_executor.tsindex 8804bfccc..3233fbc3c 100644--- a/plugins/codex-security/mcp-app/tests/test_deep_scan_executor.ts+++ b/plugins/codex-security/mcp-app/tests/test_deep_scan_executor.ts@@ -44,6 +44,7 @@ import type {} from "../src/deep-scan/types.js";import { testConcurrentWorkerExecutableAliases } from "./deep_scan_executable_alias_cases.ts";import { testDeepScanContextSnapshots } from "./deep_scan_context_snapshot_cases.ts";+import { testWorkerCyberAccessSettings } from "./deep_scan_worker_settings_cases.ts";const executorSource = new URL("../src/deep-scan/executor.ts", import.meta.url);const { bundledCodexSdkEnvironment } = await importModule({@@ -101,7 +102,16 @@ try {await testWorkerTerminalEvents();await testWorkerRuntimeSettings();await testUnsupportedProviderSnapshotFailsBeforeLaunch();- await testWorkerCyberAccessSettings();+ await testWorkerCyberAccessSettings({+ CodexSdkWorkerExecutor,+ fakeCodexFixture,+ parentSandbox: trustedParentSandbox,+ workerRequest,+ assertConfigOverrides,+ assertReadOnlyWorkerPolicy,+ assertWorkerSubagentPolicy,+ restoreEnv,+ });await testCompletedWorkerSettlesWithoutWaitingForProcessExit();if (process.platform !== "win32") {await testDeepScanContextSnapshots({@@ -2391,177 +2401,6 @@ env_key = "SYNTHETIC_GATEWAY_KEY"`,}}-async function testWorkerCyberAccessSettings() {- const cases: {- name: string;- configuration: string;- program?: string;- serviceTier?: string;- features?: Record<string, boolean>;- configPath?: string;- executor?: import("../src/deep-scan/executor.js").CodexSdkWorkerExecutor;- }[] = [- { name: "unset", configuration: "" },- {- name: "blue",- configuration:- 'service_tier = "fast"\n[codex_security]\ncyber_access_program = "daybreak_blue"\n[features]\napi_key_cyber_access_programs = true\napi_key_model_discovery = true\n',- serviceTier: "fast",- program: "daybreak_blue",- features: {- api_key_cyber_access_programs: true,- api_key_model_discovery: true,- },- },- {- name: "explicit-false",- configuration:- 'service_tier = "flex"\n[codex_security]\ncyber_access_program = "daybreak_blue"\n[features]\napi_key_cyber_access_programs = false\napi_key_model_discovery = false\n',- serviceTier: "flex",- program: "daybreak_blue",- features: {- api_key_cyber_access_programs: false,- api_key_model_discovery: false,- },- },- {- name: "other-program",- configuration:- 'service_tier = "flex"\nprofile = "cloud.production"\n[profiles."cloud.production"]\nservice_tier = "fast"\n[codex_security]\ncyber_access_program = "standard"\n[features]\napi_key_cyber_access_programs = true\napi_key_model_discovery = false\n',- serviceTier: "fast",- program: "standard",- features: {- api_key_cyber_access_programs: true,- api_key_model_discovery: false,- },- },- {- name: "features-only",- configuration:- 'service_tier = "fast"\nprofile = "selected"\n[profiles.selected]\nmodel = "fixture-model"\n[features]\napi_key_cyber_access_programs = false\napi_key_model_discovery = true\n',- serviceTier: "fast",- features: {- api_key_cyber_access_programs: false,- api_key_model_discovery: true,- },- },- ];- const saved = [- "CODEX_CLI_PATH",- "CODEX_HOME",- "CODEX_SECURITY_CONFIG_PATH",- "OPENAI_API_KEY",- "CODEX_API_KEY",- ].map((name) => [name, process.env[name]] as const);- const originalSpawn = childProcess.spawn;- const fixture = await fakeCodexFixture();- const promptPath = path.join(fixture.root, "prompt.md");- const launches: { args: readonly string[]; markerPath: string }[] = [];- try {- delete process.env.OPENAI_API_KEY;- process.env.CODEX_API_KEY = "synthetic-worker-api-key";- process.env.CODEX_CLI_PATH = process.execPath;- process.env.CODEX_HOME = fixture.root;- await writeFile(promptPath, "CAPTURE_SYNTHETIC_OPENAI_AUTH");- childProcess.spawn = ((- command: string,- args: readonly string[],- options: SpawnOptions,- ) => {- const markerPath = path.join(- fixture.root,- `cyber-${launches.length}.json`,- );- const environment = {- ...options!.env,- FAKE_CODEX_MARKER: markerPath,- FAKE_CODEX_PREFLIGHT_MARKER: markerPath,- };- launches.push({ args, markerPath });- return originalSpawn(command, [fixture.executablePath, ...args], {- ...options,- env: environment,- });- }) as typeof childProcess.spawn;- syncBuiltinESMExports();- for (const testCase of cases) {- testCase.configPath = path.join(fixture.root, `${testCase.name}.toml`);- await writeFile(testCase.configPath, testCase.configuration);- testCase.executor = new CodexSdkWorkerExecutor({- model: testCase.name,- parentSandbox: trustedParentSandbox,- });- }- for (const kind of ["discovery", "dedup"] as const) {- for (const resumeThreadId of [undefined, "fixture-resumed-thread"]) {- launches.length = 0;- await Promise.all(- cases.map((testCase) => {- // Each scan captures its own config before its asynchronous launch.- process.env.CODEX_SECURITY_CONFIG_PATH = testCase.configPath;- return testCase.executor!.run(- workerRequest(promptPath, fixture.root, { kind, resumeThreadId }),- );- }),- );- const workerLaunches = launches.filter(- ({ args }) => args[0] === "exec",- );- assert.equal(workerLaunches.length, cases.length);- for (const { name, program, serviceTier, features = {} } of cases) {- const launch = workerLaunches.find(- ({ args }) => args[args.indexOf("--model") + 1] === name,- );- const invocation = await readJson(launch!.markerPath);- assert.deepEqual(- invocation.argv.filter((arg: string) =>- arg.startsWith("service_tier="),- ),- serviceTier === undefined- ? []- : [`service_tier=${JSON.stringify(serviceTier)}`],- );- if (program === undefined) {- assert.equal(- invocation.argv.includes("--cyber-access-program"),- false,- );- } else {- assertFlagPair(invocation.argv, "--cyber-access-program", program);- }- assertConfigOverrides(invocation.argv, {- "features.api_key_cyber_access_programs":- features.api_key_cyber_access_programs,- "features.api_key_model_discovery":- features.api_key_model_discovery,- });- assert.equal(- invocation.openaiAuthentication.CODEX_API_KEY,- "synthetic-worker-api-key",- );- assert.equal(- invocation.argv.includes("resume"),- resumeThreadId !== undefined,- );- assertReadOnlyWorkerPolicy(invocation.argv);- assertWorkerSubagentPolicy(invocation.argv, 0);- }- // Running coordinators and their resumed workers retain their own settings.- for (const { configPath } of cases) {- await writeFile(- configPath!,- '[codex_security]\ncyber_access_program = "daybreak_red"\n[features]\napi_key_cyber_access_programs = false\napi_key_model_discovery = false\n',- );- }- }- }- } finally {- childProcess.spawn = originalSpawn;- syncBuiltinESMExports();- for (const [name, value] of saved) restoreEnv(name, value);- }-}-async function testBedrockCredentialsReachWorker(credentials: "all" | "oidc" = "all",) {diff --git a/plugins/codex-security/mcp-app/tests/test_deep_scan_permission_profile_preflight.ts b/plugins/codex-security/mcp-app/tests/test_deep_scan_permission_profile_preflight.tsindex cf9d4c94d..9d00b4220 100644--- a/plugins/codex-security/mcp-app/tests/test_deep_scan_permission_profile_preflight.ts+++ b/plugins/codex-security/mcp-app/tests/test_deep_scan_permission_profile_preflight.ts@@ -36,6 +36,7 @@ const {deepScanPermissionProfileFallbackError,preflightDeepScanWorkerPermissionProfile,readDeepScanRuntimeConfig,+ readDeepScanParentCyberAccessProgram,prepareCliDeepScanSession,} = await importSource(path.join(@@ -87,6 +88,105 @@ await testMissingWorkerDirectoryRemainsRetryable();await testAbortKillsPreflightChild();await testAbortPreservesCallerReason();await testDirectScanSession();+await testParentTurnCyberAccessProgram();++async function testParentTurnCyberAccessProgram() {+ const parentTurn = {+ threadId: "fixture-parent-thread",+ turnId: "fixture-current-turn",+ };+ const context = (turnId: string, program: unknown) => ({+ type: "turn_context",+ payload: {+ turn_id: turnId,+ ...(program === undefined ? {} : { cyber_access_program: program }),+ },+ });+ const read = (fixture: PreflightFixture) =>+ readDeepScanParentCyberAccessProgram({+ codexPath: fixture.codexPath,+ cwd: fixture.cwd,+ configOverrides: rawOverrides,+ parentTurn,+ signal: new AbortController().signal,+ });+ for (const program of [+ "standard",+ "daybreak_blue",+ "daybreak_red",+ "future_program",+ null,+ undefined,+ ]) {+ await withFakeCodex(+ {+ parentRollout: [+ context("fixture-older-turn", "daybreak_blue"),+ context(parentTurn.turnId, program),+ context("fixture-newer-turn", "daybreak_red"),+ ],+ },+ async (fixture) => {+ assert.equal(await read(fixture), program ?? undefined);+ const calls = await readJsonLines(fixture.callsPath);+ assert.deepEqual(+ calls.map((call) => call.method),+ ["initialize", "initialized", "thread/read"],+ );+ assert.deepEqual(calls[2].params, {+ threadId: parentTurn.threadId,+ includeTurns: false,+ });+ },+ );+ }+ for (const scenario of [+ { parentRollout: [context("fixture-other-turn", "daybreak_blue")] },+ { parentPathUnavailable: true },+ {+ returnedParentThreadId: "fixture-other-thread",+ parentRollout: [context(parentTurn.turnId, "daybreak_blue")],+ },+ ]) {+ await withFakeCodex(scenario, async (fixture) => {+ assert.equal(await read(fixture), undefined);+ });+ }+ await withFakeCodex(+ {+ methodErrors: {+ "thread/read": {+ code: -32600,+ message: `thread not loaded: ${parentTurn.threadId}`,+ },+ },+ },+ async (fixture) => {+ assert.equal(await read(fixture), undefined);+ },+ );+ await withFakeCodex(+ {+ methodErrors: {+ "thread/read": {+ code: -32000,+ message: "Synthetic native read failure",+ },+ },+ stderr: "Synthetic native stderr detail",+ },+ async (fixture) => {+ await assert.rejects(read(fixture), (error: Error) => {+ assert.match(error.message, /Synthetic native read failure/);+ assert.match(error.message, /Synthetic native stderr detail/);+ return true;+ });+ },+ );+ await withFakeCodex({}, async (fixture) => {+ await assert.rejects(read(fixture), { code: "ENOENT" });+ });+}async function testDirectScanSession() {const permissionProfile = {@@ -1171,6 +1271,17 @@ function handle(message) {});return;}+ if (message.method === "thread/read") {+ const path = scenario.callsPath + '.parent.jsonl';+ if (scenario.parentRollout !== undefined) {+ writeFileSync(path, scenario.parentRollout.map((item) => JSON.stringify(item)).join("\\n") + "\\n");+ }+ send(message.id, { thread: {+ id: scenario.returnedParentThreadId ?? message.params.threadId,+ path: scenario.parentPathUnavailable ? null : path,+ } });+ return;+ }if (message.method === "thread/inject_items") {writeFileSync(scenario.callsPath + '.session.jsonl', JSON.stringify({type: 'turn_context', payload: scenario.parentPermissionProfile ? { permission_profile: scenario.parentPermissionProfile } : {},diff --git a/plugins/codex-security/mcp-app/tests/test_deep_scan_stdio_lifecycle.ts b/plugins/codex-security/mcp-app/tests/test_deep_scan_stdio_lifecycle.tsindex 3345f8474..bb3845559 100644--- a/plugins/codex-security/mcp-app/tests/test_deep_scan_stdio_lifecycle.ts+++ b/plugins/codex-security/mcp-app/tests/test_deep_scan_stdio_lifecycle.ts@@ -119,6 +119,28 @@ stop_after_no_new = 1max_discovery_runs = 2`,);+ await writeFile(+ path.join(codexHome, `${threadId}.jsonl`),+ [+ { type: "session_meta", payload: { id: threadId } },+ {+ type: "turn_context",+ payload: {+ turn_id: "active-parent-turn",+ cyber_access_program: "daybreak_red",+ },+ },+ {+ type: "turn_context",+ payload: {+ turn_id: "another-parent-turn",+ cyber_access_program: "standard",+ },+ },+ ]+ .map((record) => JSON.stringify(record))+ .join("\n") + "\n",+ );await writeFakeCodex(fakeCodexPath);await writeFile(runtimeConfigPath,@@ -230,7 +252,12 @@ model_reasoning_summary = "none""start_codex_security_deep_scan",{ targetPath, scope: ".", userContext: "stdio lifecycle fixture" },threadId,- { model: "gpt-5.5", reasoning_effort: "xhigh" },+ {+ model: "gpt-5.5",+ reasoning_effort: "xhigh",+ thread_id: threadId,+ turn_id: "active-parent-turn",+ },),);@@ -274,6 +301,11 @@ model_reasoning_summary = "none"{ code: "ENOENT" },);assertFlagPair(startedWorker.argv, "--model", "gpt-5.5");+ assertFlagPair(+ startedWorker.argv,+ "--cyber-access-program",+ "daybreak_red",+ );assert.equal(startedWorker.argv.includes('model_reasoning_effort="xhigh"'),true,@@ -1274,7 +1306,12 @@ function toolCall(name: string,args: Record<string, unknown>,threadId: string,- turnMetadata?: { model: string; reasoning_effort: string },+ turnMetadata?: {+ model: string;+ reasoning_effort: string;+ thread_id?: string;+ turn_id?: string;+ },sandboxState: unknown = parentSandboxState,) {return {@@ -1432,6 +1469,8 @@ ${jsonLineInputSource(` if (message.method === 'initialized') continue;let result;if (message.method === 'initialize') {result = { userAgent: 'fixture', codexHome: '/fixture', platformFamily: 'unix', platformOs: 'macos' };+ } else if (message.method === 'thread/read') {+ result = { thread: { id: message.params.threadId, path: path.join(process.env.CODEX_HOME, message.params.threadId + '.jsonl') } };} else if (message.method === 'config/read') {result = { config: { default_permissions: 'codex_security_deep_scan_worker', permissions: { codex_security_deep_scan_worker: { extends: ':read-only', filesystem: { ':root': 'read', [process.env.FAKE_CODEX_DENIED_HOME]: { '.': 'deny' } }, network: { enabled: false } } } }, origins: {}, layers: null };} else if (message.method === 'permissionProfile/list') {diff --git a/sdk/typescript/README.md b/sdk/typescript/README.mdindex a537ca694..acaa4ed04 100644--- a/sdk/typescript/README.md+++ b/sdk/typescript/README.md@@ -265,6 +265,13 @@ Constructor options are `codexOverrides`, `pythonPath`, and `pluginPath`.The bundled runtime and plugin are used by default. `pythonPath` overrides the`PYTHON` environment variable. To choose a model, set `codexOverrides.model`.+To enable Daybreak on Codex 0.163.0 or later, set `codexOverrides.daybreak: true`.+The toggle defaults off; an explicit `false` keeps it off. The setting reaches+Deep Scan discovery and reducer workers, including resumed workers. Scans use+isolated configuration, so a desktop toggle or personal Codex configuration does+not configure an SDK scan. See [Daybreak opt-in](docs/cli.md#daybreak-opt-in) for+CLI, project-file, and direct plugin configuration.+New and resumed Deep Scans require a current plugin with`directDeepScanEngine: 1`, `workerProviderSnapshot: 4`, and isolated workerconfiguration support. Older custom plugins fail before scan execution; updatediff --git a/sdk/typescript/docs/cli.md b/sdk/typescript/docs/cli.mdindex a9f0f640d..e2c4f58f1 100644--- a/sdk/typescript/docs/cli.md+++ b/sdk/typescript/docs/cli.md@@ -105,6 +105,40 @@ changed; otherwise run `logout`, then `login`.Some cybersecurity requests and protected findings require[Trusted Access for Cyber](https://chatgpt.com/cyber).+### Daybreak opt-in++Codex 0.163.0 and later default the Daybreak toggle to off. Enable it through+the existing native configuration override:++```bash+codex-security scan . --codex daybreak=true+codex-security scan . --mode deep --codex daybreak=true+```++In the SDK, use `new CodexSecurity({ codexOverrides: { daybreak: true } })`.+In project files, set `daybreak: true` inside the `codex` mapping. Use `false`+to explicitly turn it off.+The setting carries through saved scan recipes, resumed scans, Deep Scan+discovery and reducer workers, and `scan --patch`. Standalone `validate`,+`patch`, and `verify-fix` accept the same `--codex daybreak=true` override.+Threads created by these commands retain the setting when resumed in Codex.+Scans use isolated configuration, so set it on the CLI, SDK client, or project+file even if it is enabled in your personal Codex configuration.++For the plugin inside Codex, use the desktop Daybreak toggle or `/daybreak` in+an interactive CLI session. For headless Codex, use `codex exec -c daybreak=true`+or set top-level `daybreak = true` in the configuration loaded by the runner.+Deep Scan inherits the active turn's effective access program from its saved+Codex session, including an explicit Standard selection. Discovery and reducer+workers retain that selection when resumed. If the host does not supply a+persisted turn context, workers use their runner configuration; CLI and SDK scans+use the explicit scan settings above.++Daybreak requires the built-in OpenAI provider and compatible account or API+project access. Codex selects the available program; this setting does not+grant access. An explicit [Cyber access program](#select-a-cyber-access-program)+takes precedence over the toggle for that turn.+### Daybreak Blue with an API keyThe [Responses API defaults](https://developers.openai.com/api/docs/guides/daybreak#understand-defaults-when-omitted)@@ -757,7 +791,7 @@ or Windows MCP launcher. Saved reports remain readable.Multi-agent v2 must remain enabled; `agents.max_threads` is unsupported.`validate`, `patch`, and `verify-fix` limit native overrides to `model`,-`model_reasoning_effort`, `model_provider`, `model_providers`, and+`model_reasoning_effort`, `model_provider`, `model_providers`, `daybreak`, and`analytics.enabled`. For a custom provider:```bashdiff --git a/sdk/typescript/scripts/package-dist-files.mjs b/sdk/typescript/scripts/package-dist-files.mjsindex b3721af7c..13e0346a4 100644--- a/sdk/typescript/scripts/package-dist-files.mjs+++ b/sdk/typescript/scripts/package-dist-files.mjs@@ -8,6 +8,7 @@ const distModules = ["auth","bulk-scan-discovery","cli",+ "cli-daybreak","cli-help","cli-scan-logs-json","cli-signals",diff --git a/sdk/typescript/src/api.ts b/sdk/typescript/src/api.tsindex a49618569..063236bac 100644--- a/sdk/typescript/src/api.ts+++ b/sdk/typescript/src/api.ts@@ -5425,6 +5425,7 @@ export function scanPreflightCodexConfig(config: JsonObject): JsonObject {"goals","multi_agent","enable_fanout",+ "cli_daybreak","api_key_cyber_access_programs","api_key_model_discovery",]) {@@ -5450,6 +5451,9 @@ export function scanPreflightCodexConfig(config: JsonObject): JsonObject {};const executionConfig = (source: JsonObject): JsonObject => {const result: JsonObject = {};+ if (typeof source["daybreak"] === "boolean") {+ result["daybreak"] = source["daybreak"];+ }for (const key of ["model","model_reasoning_effort",@@ -5500,8 +5504,12 @@ export function scanPreflightCodexConfig(config: JsonObject): JsonObject {const value = resolved[key];if (safeString(value)) result[key] = value;}+ if (typeof resolved["daybreak"] === "boolean") {+ result["daybreak"] = resolved["daybreak"];+ }const resolvedFeatures = capabilityFeatures(resolved["features"]);for (const key of [+ "cli_daybreak","api_key_cyber_access_programs","api_key_model_discovery",]) {diff --git a/sdk/typescript/src/cli-daybreak.ts b/sdk/typescript/src/cli-daybreak.tsnew file mode 100644index 000000000..29f472a8c--- /dev/null+++ b/sdk/typescript/src/cli-daybreak.ts@@ -0,0 +1,100 @@+import type { JsonObject } from "./config.js";+import { isRecord } from "./record.js";++type CyberAccessProgram = "standard" | "daybreakBlue" | "daybreakRed";++// App-server clients resolve Daybreak from the catalog before starting a turn,+// just as native Codex exec does; the config key alone does not select a program.+export async function appServerCyberAccessProgram(+ config: JsonObject,+ model: string,+ provider: string,+ threadId: string,+ request: (method: string, params: JsonObject) => Promise<JsonObject>,+): Promise<CyberAccessProgram | undefined> {+ const features = new Map<string, unknown>();+ let featureCursor: string | undefined;+ do {+ const result = await request("experimentalFeature/list", {+ threadId,+ ...(featureCursor === undefined ? {} : { cursor: featureCursor }),+ });+ const flags = result["data"];+ if (Array.isArray(flags)) {+ for (const flag of flags) {+ if (isRecord(flag) && typeof flag["name"] === "string")+ features.set(flag["name"], flag["enabled"]);+ }+ }+ if (features.get("cli_daybreak") === false) return undefined;+ if (+ features.has("cli_daybreak") &&+ features.has("api_key_cyber_access_programs")+ ) {+ break;+ }+ featureCursor =+ typeof result["nextCursor"] === "string"+ ? result["nextCursor"]+ : undefined;+ } while (featureCursor !== undefined);+ if (!features.has("cli_daybreak")) {+ throw new Error("Codex did not report the effective cli_daybreak feature");+ }+ const enabled = config["daybreak"] === true;+ if (provider !== "openai") {+ if (enabled) throw new Error("Daybreak requires the OpenAI model provider");+ return undefined;+ }++ const accountType = async (): Promise<unknown> => {+ const result = await request("account/read", { refreshToken: false });+ return isRecord(result["account"]) ? result["account"]["type"] : undefined;+ };+ if (enabled) {+ const account = await accountType();+ if (account !== "chatgpt" && account !== "apiKey") {+ throw new Error(+ "Daybreak requires a signed-in ChatGPT account or an OpenAI API key",+ );+ }+ }++ let cursor: string | undefined;+ do {+ const result = await request("model/list", {+ includeHidden: true,+ ...(cursor === undefined ? {} : { cursor }),+ }).catch(() => undefined);+ if (result === undefined) return undefined;+ const models = result["data"];+ const selected = Array.isArray(models)+ ? models.find((entry) => isRecord(entry) && entry["model"] === model)+ : undefined;+ if (isRecord(selected)) {+ const access = selected["availableAccessPrograms"];+ const programs = isRecord(access) ? access["cyber"] : undefined;+ if (!Array.isArray(programs) || programs.length === 0) return undefined;+ if (enabled) {+ for (const program of ["daybreakBlue", "daybreakRed"] as const) {+ if (programs.includes(program)) return program;+ }+ throw new Error(+ `Daybreak is unavailable for model ${model}; turn it off or choose a compatible model`,+ );+ }+ if (!programs.includes("standard")) return undefined;+ const account = await accountType().catch(() => undefined);+ return account === "chatgpt" ||+ (account === "apiKey" &&+ features.get("api_key_cyber_access_programs") === true)+ ? "standard"+ : undefined;+ }+ cursor =+ typeof result["nextCursor"] === "string"+ ? result["nextCursor"]+ : undefined;+ } while (cursor !== undefined);+ return undefined;+}diff --git a/sdk/typescript/src/cli.ts b/sdk/typescript/src/cli.tsindex 5088c5d5c..a6894a1b4 100644--- a/sdk/typescript/src/cli.ts+++ b/sdk/typescript/src/cli.ts@@ -1,6 +1,8 @@#!/usr/bin/env nodeimport { workbenchArgs } from "./workbench-arguments.js";import { listenForAbort } from "./cli-signals.js";+import { appServerCyberAccessProgram } from "./cli-daybreak.js";+import { withCodexPreflightLock } from "./provider-profile.js";import { isNonEmptyString, parseJson } from "./value.js";import {@@ -45,7 +47,11 @@ import { cwd } from "node:process";import { createInterface } from "node:readline";import { Readable, Writable as NodeWritable } from "node:stream";import { fileURLToPath, pathToFileURL } from "node:url";-import { promisify, stripVTControlCharacters } from "node:util";+import {+ isDeepStrictEqual,+ promisify,+ stripVTControlCharacters,+} from "node:util";import { Cli, z } from "incur";import Ajv2020, { type ValidateFunction } from "ajv/dist/2020.js";import { formatCliHelp } from "./cli-help.js";@@ -352,7 +358,7 @@ const MATCHING_MODEL_OPTIONS = modelOptions("Matching reasoning effort (default: medium).",);const SKILL_CODEX_OVERRIDE_DESCRIPTION =- 'Repeat TOML model="gpt-5.6-terra", model_reasoning_effort="high", model_provider="gateway", model_providers.<name>.<key>=VALUE, or analytics.enabled=false.';+ 'Repeat TOML model="gpt-5.6-terra", model_reasoning_effort="high", model_provider="gateway", model_providers.<name>.<key>=VALUE, daybreak=true, or analytics.enabled=false.';const SKILL_CONFIG_OPTIONS = MODEL_OPTIONS.extend({codex: z.array(optionValue("--codex"))@@ -1041,6 +1047,7 @@ interface SkillCommandOutput {readonly threadSource: SkillThreadSource;readonly sandbox?: "read-only" | "workspace-write";readonly externalSandbox?: boolean;+ readonly cyberAccessProgram?: ScanOptions["cyberAccessProgram"];readonly onEvent?: (event: Readonly<Record<string, unknown>>) => void;};}@@ -1083,6 +1090,8 @@ interface SkillRunOptions {externalSandbox?: boolean;readonly auth?: ScanAuthMode;serviceTier?: JsonValue;+ daybreakFeatures?: JsonObject;+ cyberAccessProgram?: ScanOptions["cyberAccessProgram"];safetyIdentifier?: string;directory?: string;findings?: readonly Finding[];@@ -1335,7 +1344,7 @@ export async function runCodexSkillCommand(const overrides = parseToml(stringifyToml(output.codexOverrides ?? {}),) as JsonObject;- const config = deepMerge(ambientConfig, overrides);+ const config = deepMerge(structuredClone(ambientConfig), overrides);const provider = output.modelProvider ?? scanModelProvider(config);// Native Codex ignores configured tables for these built-in providers.const providerConfiguration =@@ -1462,7 +1471,7 @@ export async function runCodexSkillCommand(releaseCredentialHome =await acquireCodexSecurityCredentialHomeLock(codexHome);let credentialsAvailable: boolean;- const ambientConfig = await readCodexHomeConfig(selected);+ const ambientAuthConfig = await readCodexHomeConfig(selected);credentialConfig = await readCodexHomeConfig({...selected,CODEX_HOME: codexHome,@@ -1473,7 +1482,7 @@ export async function runCodexSkillCommand("projects","project_root_markers",]) {- const value = ambientConfig[key];+ const value = ambientAuthConfig[key];if (value === undefined) delete credentialConfig[key];else credentialConfig[key] = value;}@@ -1513,6 +1522,32 @@ export async function runCodexSkillCommand(output.auth,provider,);+ if (output.appServer !== undefined) {+ const controller = new AbortController();+ const removeSignals = listenForAbort(+ DEFAULT_DEPENDENCIES,+ controller,+ );+ try {+ args = [+ ...args,+ ...(await skillDaybreakConfigOverrides(+ args,+ command,+ selected,+ directory,+ ambientConfig,+ controller.signal,+ )),+ ];+ } catch (error) {+ if (controller.signal.aborted)+ return controller.signal.reason === "SIGINT" ? 130 : 143;+ throw error;+ } finally {+ removeSignals();+ }+ }} else if (authentication.method === "api_key" && requiresOpenAiAuth) {apiKey = environmentValue(selected, authentication.source)?.trim();// Match the SDK's key selection for native and nested plugin workers.@@ -1632,16 +1667,11 @@ export async function runCodexSkillCommand(output.appServer === undefined? undefined: {+ ...output.appServer,apiKey,modelProvider,onThreadStarted: releaseCredentialHome,- directory: output.appServer.directory,- prompt: output.appServer.prompt,- threadSource: output.appServer.threadSource,input: invocation.stdin!,- sandbox: output.appServer.sandbox,- externalSandbox: output.appServer.externalSandbox,- onEvent: output.appServer.onEvent,},),new Promise<undefined>((resolve) => {@@ -1731,6 +1761,97 @@ export async function runCodexSkillCommand(}}+/**+ * Stored auth switches homes. Native origins preserve ambient settings at+ * app-server startup, where model discovery gates cannot be set per thread.+ */+async function skillDaybreakConfigOverrides(+ args: readonly string[],+ command: CodexCommand,+ environment: NodeJS.ProcessEnv,+ directory: string,+ ambientConfig: JsonObject,+ signal: AbortSignal,+): Promise<string[]> {+ const ambientFeatures = isJsonObject(ambientConfig["features"])+ ? ambientConfig["features"]+ : {};+ const settings: [string, JsonValue | undefined][] = [+ ["daybreak", ambientConfig["daybreak"]],+ ...[+ "cli_daybreak",+ "api_key_cyber_access_programs",+ "api_key_model_discovery",+ ].map((key): [string, JsonValue | undefined] => [+ `features.${key}`,+ ambientFeatures[key],+ ]),+ ];+ if (settings.every(([, value]) => value === undefined)) return [];+ const nativeEnvironment = Object.fromEntries(+ Object.entries(environment).filter(+ (entry): entry is [string, string] => entry[1] !== undefined,+ ),+ );+ const native = await import(+ pathToFileURL(+ join(+ await bundledPluginRoot(),+ "mcp",+ "permission-profile-preflight.mjs",+ ),+ ).href+ );+ const response = (await withCodexPreflightLock(+ nativeEnvironment,+ signal,+ () =>+ native.readDeepScanRuntimeConfigWithOrigins({+ codexPath: command.command,+ appServerArgs: args,+ cwd: directory,+ configOverrides: [],+ env: nativeEnvironment,+ signal,+ context: "helper",+ }),+ )) as JsonObject;+ const origins = response["origins"];+ const layers = response["layers"];+ const malformed = () =>+ new CodexSecurityError(+ "Codex did not return configuration origins for Daybreak settings.",+ );+ if (!isJsonObject(origins) || !Array.isArray(layers)) throw malformed();+ const userLayer = layers.findIndex((layer) => {+ const name = isJsonObject(layer) ? layer["name"] : undefined;+ return (+ isJsonObject(name) && name["type"] === "user" && name["profile"] == null+ );+ });+ if (userLayer === -1) throw malformed();+ const overrides: string[] = [];+ for (const [key, value] of settings) {+ if (value === undefined) continue;+ const origin = origins[key];+ if (origin !== undefined) {+ if (!isJsonObject(origin) || !isJsonObject(origin["name"]))+ throw malformed();+ const layer = layers.findIndex(+ (entry) =>+ isJsonObject(entry) &&+ isDeepStrictEqual(entry["name"], origin["name"]),+ );+ if (layer === -1) throw malformed();+ // Native returns layers from highest to lowest priority. Ambient values+ // replace the user-home fallback without overriding project or CLI choices.+ if (layer < userLayer) continue;+ }+ overrides.push("--config", `${key}=${inlineToml(value)}`);+ }+ return overrides;+}+export async function main(argv: readonly string[] = process.argv.slice(2),output: Writable = process.stdout,@@ -7545,6 +7666,7 @@ async function runSkill(key !== "model_reasoning_effort" &&key !== "model_provider" &&key !== "model_providers" &&+ key !== "daybreak" &&!(key === "analytics" &&isJsonObject(value) &&@@ -7553,7 +7675,7 @@ async function runSkill()) {throw new CodexSecurityError(- "Skill commands only support model, model_reasoning_effort, model_provider, model_providers, and analytics.enabled overrides.",+ "Skill commands only support model, model_reasoning_effort, model_provider, model_providers, daybreak, and analytics.enabled overrides.",);}if (options.serviceTier !== undefined)@@ -7788,6 +7910,12 @@ async function runSkill(...(options.serviceTier === undefined? []: ["--config", `service_tier=${JSON.stringify(options.serviceTier)}`]),+ ...(overrides["daybreak"] === undefined+ ? []+ : ["--config", `daybreak=${inlineToml(overrides["daybreak"])}`]),+ ...Object.entries(options.daybreakFeatures ?? {}).flatMap(+ ([key, value]) => ["--config", `features.${key}=${inlineToml(value)}`],+ ),...codex.filter((value) =>@@ -7861,6 +7989,9 @@ async function runSkill(prompt,threadSource,...(options.externalSandbox ? { externalSandbox: true } : {}),+ ...(options.cyberAccessProgram === undefined+ ? {}+ : { cyberAccessProgram: options.cyberAccessProgram }),...(verify || assess ? { sandbox: "read-only" as const } : {}),...(options.onEvent === undefined? {}@@ -7886,6 +8017,7 @@ export async function readSkillCommandOutput(readonly input: NodeJS.WritableStream;readonly sandbox?: "read-only" | "workspace-write";readonly externalSandbox?: boolean;+ readonly cyberAccessProgram?: ScanOptions["cyberAccessProgram"];readonly onEvent?: (event: Readonly<Record<string, unknown>>) => void;},): Promise<{@@ -7900,6 +8032,17 @@ export async function readSkillCommandOutput(let turnId: string | undefined;let completed = false;let sandboxUnavailable = false;+ let config: JsonObject = {};+ let model: string;+ let provider: string;+ let daybreakRequestId = 0;+ let daybreakRequest:+ | {+ id: string;+ resolve: (result: JsonObject) => void;+ reject: (error: Error) => void;+ }+ | undefined;const externalSandbox = appServer?.externalSandbox? { type: "externalSandbox", networkAccess: "enabled" }: undefined;@@ -7907,17 +8050,50 @@ export async function readSkillCommandOutput(appServer?.input.write(`${JSON.stringify(request)}\n`);};const startTurn = (): void => {- send({- id: 3,- method: "turn/start",- params: {- threadId: threadId!,- ...(externalSandbox ? { sandboxPolicy: externalSandbox } : {}),- input: [{ type: "text", text: appServer!.prompt, text_elements: [] }],+ const selected = appServer?.cyberAccessProgram;+ const program =+ selected === undefined+ ? appServerCyberAccessProgram(+ config,+ model,+ provider,+ threadId!,+ (method, params) =>+ new Promise<JsonObject>((resolve, reject) => {+ const id = `daybreak-${daybreakRequestId++}`;+ daybreakRequest = { id, resolve, reject };+ send({ id, method, params });+ }),+ )+ : Promise.resolve(+ selected === "daybreak_blue"+ ? "daybreakBlue"+ : selected === "daybreak_red"+ ? "daybreakRed"+ : selected,+ );+ void program.then(+ (cyberAccessProgram) => {+ send({+ id: 3,+ method: "turn/start",+ params: {+ threadId: threadId!,+ ...(cyberAccessProgram === undefined ? {} : { cyberAccessProgram }),+ ...(externalSandbox ? { sandboxPolicy: externalSandbox } : {}),+ input: [+ { type: "text", text: appServer!.prompt, text_elements: [] },+ ],+ },+ });},- });+ (failure: unknown) => {+ error = errorMessage(failure);+ appServer?.input.end();+ },+ );};- const startThread = (config?: JsonObject): void => {+ const startThread = (threadConfig?: JsonObject): void => {if (appServer === undefined) return;send({id: 2,@@ -7932,7 +8108,8 @@ export async function readSkillCommandOutput(approvalPolicy:appServer?.sandbox === "read-only" ? "on-request" : "never",sandbox: appServer?.sandbox ?? "workspace-write",- ...(config === undefined ? {} : { config }),+ ...(config["daybreak"] === true ? { daybreakEnabled: true } : {}),+ ...(threadConfig === undefined ? {} : { config: threadConfig }),},});};@@ -7940,7 +8117,10 @@ export async function readSkillCommandOutput(send({id: 1,method: "initialize",- params: { clientInfo: { name: "codex-security", version: VERSION } },+ params: {+ clientInfo: { name: "codex-security", version: VERSION },+ capabilities: { experimentalApi: true },+ },});}@@ -7966,6 +8146,18 @@ export async function readSkillCommandOutput(} catch {}}if (value["id"] !== undefined) {+ if (value["id"] === daybreakRequest?.id) {+ const pending = daybreakRequest;+ daybreakRequest = undefined;+ if (value["error"] !== undefined) {+ pending.reject(+ new Error((value["error"] as { message: string }).message),+ );+ } else {+ pending.resolve(value["result"] as JsonObject);+ }+ continue;+ }if (typeof value["method"] === "string") {send({id: value["id"] as string | number,@@ -7987,26 +8179,35 @@ export async function readSkillCommandOutput(continue;}}- if (appServer.sandbox === "read-only") {- if (appServer.directory === undefined) {- error =- "Codex did not receive the repository directory required for read-only verification.";- appServer.input.end();- continue;- }- send({- id: 4,- method: "config/read",- params: {- cwd: appServer.directory,- includeLayers: true,- },- });- } else {- startThread();+ if (+ appServer.sandbox === "read-only" &&+ appServer.directory === undefined+ ) {+ error =+ "Codex did not receive the repository directory required for read-only verification.";+ appServer.input.end();+ continue;}- } else if (value["id"] === 4 && appServer.sandbox === "read-only") {+ send({+ id: 4,+ method: "config/read",+ params: {+ ...(appServer.directory === undefined+ ? {}+ : { cwd: appServer.directory }),+ includeLayers: appServer.sandbox === "read-only",+ },+ });+ } else if (value["id"] === 4) {const result = value["result"];+ config =+ isJsonObject(result) && isJsonObject(result["config"])+ ? (result["config"] as JsonObject)+ : {};+ if (appServer.sandbox !== "read-only") {+ startThread();+ continue;+ }const layers =typeof result === "object" && result !== null && "layers" in result? result.layers@@ -8069,8 +8270,12 @@ export async function readSkillCommandOutput(const result = value["result"] as {thread: { id: string };sandbox: JsonObject;+ model: string;+ modelProvider: string;};threadId = result.thread.id;+ model = result.model;+ provider = result.modelProvider;if (appServer.threadSource === CODEX_SECURITY_THREAD_SOURCES.remediation) {@@ -8419,6 +8624,8 @@ async function executeScan(let auth: ScanAuthMode | undefined = arguments_.auth;let patchAnalyticsOverride: string | undefined;let patchServiceTier: JsonValue | undefined;+ let patchDaybreak: JsonValue = false;+ let patchDaybreakFeatures: JsonObject = {};let selectedAuthentication: ScanAuthentication | null = null;let repository = "";let failed = false;@@ -8445,8 +8652,20 @@ async function executeScan(};({ model: effectiveModel, reasoningEffort: effectiveReasoningEffort } =scanModelConfiguration(effectiveConfiguration));- patchServiceTier =- resolveCodexProfile(effectiveConfiguration)["service_tier"] ?? "default";+ const resolvedConfiguration = resolveCodexProfile(effectiveConfiguration);+ patchServiceTier = resolvedConfiguration["service_tier"] ?? "default";+ patchDaybreak = resolvedConfiguration["daybreak"] ?? false;+ const features = resolvedConfiguration["features"];+ patchDaybreakFeatures = Object.fromEntries(+ [+ "cli_daybreak",+ "api_key_cyber_access_programs",+ "api_key_model_discovery",+ ].map((key) => [+ key,+ isJsonObject(features) ? (features[key] ?? true) : true,+ ]),+ );const provider = scanModelProvider(effectiveConfiguration);const analytics = effectiveConfiguration["analytics"];if (isJsonObject(analytics) && analytics["enabled"] !== undefined) {@@ -9187,6 +9406,7 @@ async function executeScan(codex: [`model=${JSON.stringify(effectiveModel)}`,`model_reasoning_effort=${JSON.stringify(effectiveReasoningEffort)}`,+ `daybreak=${inlineToml(patchDaybreak)}`,...(patchAnalyticsOverride === undefined? []: [patchAnalyticsOverride]),@@ -9197,6 +9417,8 @@ async function executeScan({...providerOptions,serviceTier: patchServiceTier,+ daybreakFeatures: patchDaybreakFeatures,+ cyberAccessProgram: arguments_.cyberAccessProgram,safetyIdentifier: arguments_.safetyIdentifier,auth,findingInstructions: patchSelection?.instructions,diff --git a/sdk/typescript/src/scan-comparison.ts b/sdk/typescript/src/scan-comparison.tsindex 43769ea6a..8609f62ab 100644--- a/sdk/typescript/src/scan-comparison.ts+++ b/sdk/typescript/src/scan-comparison.ts@@ -615,6 +615,7 @@ async function startReadOnlyCodexThread(allow_login_shell: false,project_doc_max_bytes: 0,features: {+ cli_daybreak: effectiveFeatures?.["cli_daybreak"],api_key_cyber_access_programs:effectiveFeatures?.["api_key_cyber_access_programs"],api_key_model_discovery: effectiveFeatures?.["api_key_model_discovery"],diff --git a/sdk/typescript/tests-ts/api-attribution-concurrency.test.ts b/sdk/typescript/tests-ts/api-attribution-concurrency.test.tsindex dc9f5e414..1f02e0072 100644--- a/sdk/typescript/tests-ts/api-attribution-concurrency.test.ts+++ b/sdk/typescript/tests-ts/api-attribution-concurrency.test.ts@@ -54,6 +54,8 @@ describe("delegated scan attribution", () => {: "gpt-5.6-sol": undefined;const program = surface === "cli" ? programs[0] : programs[1];+ const daybreak =+ endpointSource === "unset" ? undefined : surface === "cli";const endpoint =endpointSource === "unset"? undefined@@ -93,6 +95,14 @@ describe("delegated scan attribution", () => {{pluginPath: PLUGIN_ROOT,codexOverrides: {+ ...(daybreak === undefined || endpointSource === "profile-only"+ ? {}+ : {+ daybreak:+ endpointSource === "profile-override"+ ? !daybreak+ : daybreak,+ }),analytics: { enabled: surface === "sdk" },responses_api_metadata: {custom_attribution: surface,@@ -107,10 +117,15 @@ describe("delegated scan attribution", () => {? {profile: "selected",profiles: {- selected:- profileEndpoint === undefined+ selected: {+ ...(profileEndpoint === undefined? {}- : { openai_base_url: profileEndpoint },+ : { openai_base_url: profileEndpoint }),+ ...(endpointSource === "profile-only" ||+ endpointSource === "profile-override"+ ? { daybreak }+ : {}),+ },unselected: {openai_base_url: "https://unused.example.test/v1",},@@ -199,6 +214,7 @@ describe("delegated scan attribution", () => {expect(options.config?.["openai_base_url"]).toBe(endpoint,);+ expect(options.config?.["daybreak"]).toBe(daybreak);expect(options.config).toMatchObject({features,...(model === undefined ? {} : { model }),@@ -247,6 +263,7 @@ describe("delegated scan attribution", () => {const workerRuntime = deepConfig["worker_runtime"] as Record<string, unknown>;+ expect(workerRuntime["daybreak"]).toBe(daybreak);if (endpoint === undefined)expect(workerRuntime).not.toHaveProperty("openai_base_url",@@ -260,6 +277,7 @@ describe("delegated scan attribution", () => {features,...(model === undefined ? {} : { model }),});+ expect(runtimeConfig["daybreak"]).toBe(daybreak);expect(initialConfig).not.toContain("openai_base_url");expect(initialConfig).not.toContain("synthetic-password");if (program === undefined) {diff --git a/sdk/typescript/tests-ts/api-cyber-access.test.ts b/sdk/typescript/tests-ts/api-cyber-access.test.tsindex f274e483a..b07b54975 100644--- a/sdk/typescript/tests-ts/api-cyber-access.test.ts+++ b/sdk/typescript/tests-ts/api-cyber-access.test.ts@@ -21,6 +21,37 @@ test.each([["standard", {}],["daybreak_blue", {}],["daybreak_red", {}],+ [undefined, { daybreak: true }],+ [undefined, { daybreak: false }],+ ["standard", { daybreak: true }],+ ["daybreak_blue", { daybreak: false }],+ [undefined, { daybreak: true, features: { cli_daybreak: false } }],+ [+ undefined,+ {+ daybreak: true,+ features: { cli_daybreak: true },+ profile: "selected",+ profiles: { selected: { features: { cli_daybreak: false } } },+ },+ ],+ [+ undefined,+ {+ daybreak: false,+ features: { cli_daybreak: false },+ profile: "selected",+ profiles: { selected: { features: { cli_daybreak: true } } },+ },+ ],+ [+ undefined,+ {+ daybreak: false,+ profile: "selected",+ profiles: { selected: { daybreak: true } },+ },+ ],["daybreak_blue", { features: { api_key_cyber_access_programs: false } }],["daybreak_blue",@@ -81,6 +112,24 @@ test.each([expect(recipe?.["cyberAccessProgram"]).toBe(program);expect(clientOptions?.apiKey).toBe("synthetic-api-key");const config = parseToml(await readFile(runtime.configPath, "utf8"));+ const resolved = resolveCodexProfile(overrides as JsonObject);+ const daybreak = resolved["daybreak"] as boolean | undefined;+ expect(config["daybreak"]).toBe(daybreak);+ expect(clientOptions?.config?.["daybreak"]).toBe(daybreak);+ expect((recipe?.["config"] as JsonObject | undefined)?.["daybreak"]).toBe(+ daybreak,+ );+ for (const snapshot of [+ config,+ clientOptions?.config,+ recipe?.["config"] as JsonObject,+ ]) {+ expect(+ (snapshot?.["features"] as JsonObject | undefined)?.["cli_daybreak"],+ ).toBe(+ (resolved["features"] as JsonObject | undefined)?.["cli_daybreak"],+ );+ }if (program === undefined) {expect(config).not.toHaveProperty("codex_security");expect(config["features"]).not.toHaveProperty(diff --git a/sdk/typescript/tests-ts/cli-authentication.test.ts b/sdk/typescript/tests-ts/cli-authentication.test.tsindex 371e2bed2..6fa3f9082 100644--- a/sdk/typescript/tests-ts/cli-authentication.test.ts+++ b/sdk/typescript/tests-ts/cli-authentication.test.ts@@ -2063,8 +2063,12 @@ describe("skill authentication", () => {"initialize","initialized",...(usesSessionKey ? ["account/login/start"] : []),- ...(loginFailure && usesSessionKey ? [] : ["thread/start"]),- ...(loginFailure ? [] : ["command/exec", "turn/start"]),+ ...(loginFailure && usesSessionKey+ ? []+ : ["config/read", "thread/start"]),+ ...(loginFailure+ ? []+ : ["command/exec", "experimentalFeature/list", "turn/start"]),]);expect(await readFile(join(credentialHome, "auth.json"), "utf8")).toBe(stored,diff --git a/sdk/typescript/tests-ts/cli-daybreak.test.ts b/sdk/typescript/tests-ts/cli-daybreak.test.tsnew file mode 100644index 000000000..eb8b77568--- /dev/null+++ b/sdk/typescript/tests-ts/cli-daybreak.test.ts@@ -0,0 +1,317 @@+import { expect, test } from "bun:test";+import { appServerCyberAccessProgram } from "../src/cli-daybreak.js";+import type { JsonObject } from "../src/config.js";++const featureResponse = (enabled = true, apiKeyGate = true): JsonObject => ({+ data: [+ { name: "cli_daybreak", enabled },+ { name: "api_key_cyber_access_programs", enabled: apiKeyGate },+ ],+ nextCursor: null,+});++function withFeature(+ request: Parameters<typeof appServerCyberAccessProgram>[4],+ apiKeyGate = true,+): Parameters<typeof appServerCyberAccessProgram>[4] {+ return async (method, params) =>+ method === "experimentalFeature/list"+ ? featureResponse(true, apiKeyGate)+ : request(method, params);+}++test("resolves the selected model across catalog pages and prefers Blue", async () => {+ const requests: Array<{ method: string; params: JsonObject }> = [];+ const program = await appServerCyberAccessProgram(+ { daybreak: true, features: { cli_daybreak: false } },+ "selected-model",+ "openai",+ "selected-thread",+ async (method, params): Promise<JsonObject> => {+ requests.push({ method, params });+ if (method === "experimentalFeature/list") return featureResponse();+ if (method === "account/read") return { account: { type: "apiKey" } };+ return params["cursor"] === "next-page"+ ? {+ data: [+ {+ model: "selected-model",+ availableAccessPrograms: {+ cyber: ["standard", "daybreakRed", "daybreakBlue"],+ },+ },+ ],+ }+ : {+ data: [+ {+ model: "other-model",+ availableAccessPrograms: { cyber: ["daybreakRed"] },+ },+ ],+ nextCursor: "next-page",+ };+ },+ );+ expect(program).toBe("daybreakBlue");+ expect(requests).toEqual([+ {+ method: "experimentalFeature/list",+ params: { threadId: "selected-thread" },+ },+ { method: "account/read", params: { refreshToken: false } },+ { method: "model/list", params: { includeHidden: true } },+ {+ method: "model/list",+ params: { includeHidden: true, cursor: "next-page" },+ },+ ]);+});++test.each([+ [true, "apiKey", true, ["daybreakRed"], "daybreakRed"],+ [false, "apiKey", true, ["standard"], "standard"],+ [false, "apiKey", false, ["standard"], undefined],+ [false, "chatgpt", false, ["standard"], "standard"],+ [false, "apiKey", true, ["daybreakBlue"], undefined],+ [true, "apiKey", true, [], undefined],+ [true, "apiKey", true, undefined, undefined],+] as const)(+ "resolves native treatment enabled=%p account=%s gate=%p programs=%j",+ async (daybreak, account, apiKeyGate, programs, expected) => {+ expect(+ await appServerCyberAccessProgram(+ { daybreak, features: { api_key_cyber_access_programs: apiKeyGate } },+ "selected-model",+ "openai",+ "selected-thread",+ withFeature(+ async (method): Promise<JsonObject> =>+ method === "account/read"+ ? { account: { type: account } }+ : {+ data: [+ {+ model: "selected-model",+ ...(programs === undefined+ ? {}+ : {+ availableAccessPrograms: { cyber: [...programs] },+ }),+ },+ ],+ },+ apiKeyGate,+ ),+ ),+ ).toBe(expected);+ },+);++test.each([+ [undefined, false, undefined],+ [true, false, undefined],+ [false, true, "standard"],+] as const)(+ "uses the effective API-key gate when raw=%p and effective=%p",+ async (raw, effective, expected) => {+ const program = await appServerCyberAccessProgram(+ {+ features:+ raw === undefined ? {} : { api_key_cyber_access_programs: raw },+ },+ "selected-model",+ "openai",+ "selected-thread",+ withFeature(+ async (method): Promise<JsonObject> =>+ method === "account/read"+ ? { account: { type: "apiKey" } }+ : {+ data: [+ {+ model: "selected-model",+ availableAccessPrograms: { cyber: ["standard"] },+ },+ ],+ },+ effective,+ ),+ );+ expect(program).toBe(expected);+ },+);++test("reads the API-key gate on a later native feature page", async () => {+ const featureRequests: JsonObject[] = [];+ const program = await appServerCyberAccessProgram(+ { features: { api_key_cyber_access_programs: true } },+ "selected-model",+ "openai",+ "selected-thread",+ async (method, params): Promise<JsonObject> => {+ if (method === "experimentalFeature/list") {+ featureRequests.push(params);+ return params["cursor"] === "api-key-page"+ ? {+ data: [{ name: "api_key_cyber_access_programs", enabled: false }],+ nextCursor: null,+ }+ : {+ data: [{ name: "cli_daybreak", enabled: true }],+ nextCursor: "api-key-page",+ };+ }+ if (method === "account/read") return { account: { type: "apiKey" } };+ return {+ data: [+ {+ model: "selected-model",+ availableAccessPrograms: { cyber: ["standard"] },+ },+ ],+ };+ },+ );+ expect(program).toBeUndefined();+ expect(featureRequests).toEqual([+ { threadId: "selected-thread" },+ { threadId: "selected-thread", cursor: "api-key-page" },+ ]);+});++test.each(["openai", "custom"])(+ "honors a managed feature disable for provider %s across native feature pages",+ async (provider) => {+ const requests: Array<{ method: string; params: JsonObject }> = [];+ const program = await appServerCyberAccessProgram(+ { daybreak: true, features: { cli_daybreak: true } },+ "selected-model",+ provider,+ "selected-thread",+ async (method, params) => {+ requests.push({ method, params });+ return params["cursor"] === "feature-page"+ ? featureResponse(false)+ : {+ data: [{ name: "other_feature", enabled: true }],+ nextCursor: "feature-page",+ };+ },+ );+ expect(program).toBeUndefined();+ expect(requests).toEqual([+ {+ method: "experimentalFeature/list",+ params: { threadId: "selected-thread" },+ },+ {+ method: "experimentalFeature/list",+ params: { threadId: "selected-thread", cursor: "feature-page" },+ },+ ]);+ },+);++test("preserves custom-provider behavior when Daybreak is available", async () => {+ const unexpectedRequest = async (): Promise<JsonObject> => {+ throw new Error("No native request expected");+ };+ expect(+ await appServerCyberAccessProgram(+ {},+ "selected-model",+ "custom",+ "selected-thread",+ withFeature(unexpectedRequest),+ ),+ ).toBeUndefined();+ await expect(+ appServerCyberAccessProgram(+ { daybreak: true },+ "selected-model",+ "custom",+ "selected-thread",+ withFeature(unexpectedRequest),+ ),+ ).rejects.toThrow("Daybreak requires the OpenAI model provider");+});++test("reports unavailable accounts and advertised models without Daybreak", async () => {+ await expect(+ appServerCyberAccessProgram(+ { daybreak: true },+ "selected-model",+ "openai",+ "selected-thread",+ withFeature(async () => ({ account: null })),+ ),+ ).rejects.toThrow(+ "Daybreak requires a signed-in ChatGPT account or an OpenAI API key",+ );+ await expect(+ appServerCyberAccessProgram(+ { daybreak: true },+ "selected-model",+ "openai",+ "selected-thread",+ withFeature(async (method): Promise<JsonObject> =>+ method === "account/read"+ ? { account: { type: "apiKey" } }+ : {+ data: [+ {+ model: "selected-model",+ availableAccessPrograms: { cyber: ["standard"] },+ },+ ],+ },+ ),+ ),+ ).rejects.toThrow("Daybreak is unavailable for model selected-model");+});++test("preserves account diagnostics and native catalog-failure behavior", async () => {+ const failure = new Error(+ "Synthetic native account failure with diagnostic detail",+ );+ await expect(+ appServerCyberAccessProgram(+ { daybreak: true },+ "selected-model",+ "openai",+ "selected-thread",+ withFeature(async () => {+ throw failure;+ }),+ ),+ ).rejects.toBe(failure);+ expect(+ await appServerCyberAccessProgram(+ {},+ "selected-model",+ "openai",+ "selected-thread",+ withFeature(async () => {+ throw new Error("Synthetic catalog unavailable");+ }),+ ),+ ).toBeUndefined();+});++test("preserves native feature-query diagnostics", async () => {+ const failure = new Error(+ "Synthetic native feature failure with diagnostic detail",+ );+ await expect(+ appServerCyberAccessProgram(+ { daybreak: true },+ "selected-model",+ "openai",+ "selected-thread",+ async () => {+ throw failure;+ },+ ),+ ).rejects.toBe(failure);+});diff --git a/sdk/typescript/tests-ts/cli-patch-results.test.ts b/sdk/typescript/tests-ts/cli-patch-results.test.tsindex 8b46995f0..0be923c65 100644--- a/sdk/typescript/tests-ts/cli-patch-results.test.ts+++ b/sdk/typescript/tests-ts/cli-patch-results.test.ts@@ -80,7 +80,8 @@ const lines = require("node:readline").createInterface({ input: process.stdin })const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n");lines.on("line", (line) => {const request = JSON.parse(line);- if (request.method === "initialize" || request.method === "account/login/start") send({ id: request.id, result: {} });+ if (["initialize", "account/login/start", "config/read"].includes(request.method)) send({ id: request.id, result: {} });+ if (request.method === "experimentalFeature/list") send({ id: request.id, result: { data: [{ name: "cli_daybreak", enabled: true }, { name: "api_key_cyber_access_programs", enabled: true }], nextCursor: null } });if (request.method === "thread/start") {assert.equal(request.params.sandbox, "workspace-write");send({ id: request.id, result: { thread: { id: "thread" }, sandbox: { type: "workspaceWrite" } } });@@ -262,7 +263,7 @@ const lines = require("node:readline").createInterface({ input: process.stdin })const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n");lines.on("line", (line) => {const request = JSON.parse(line);- if (request.method === "initialize" || request.method === "account/login/start") send({ id: request.id, result: {} });+ if (["initialize", "account/login/start", "config/read"].includes(request.method)) send({ id: request.id, result: {} });if (request.method === "thread/start") send({ id: request.id, result: { thread: { id: "thread" }, sandbox: { type: "workspaceWrite", writableRoots: [], networkAccess: false, excludeTmpdirEnvVar: false, excludeSlashTmp: false } } });if (request.method === "command/exec") {assert.equal(request.params.sandboxPolicy.type, "workspaceWrite");diff --git a/sdk/typescript/tests-ts/cli-patch.test.ts b/sdk/typescript/tests-ts/cli-patch.test.tsindex 8dc1aaa88..3c1a0548a 100644--- a/sdk/typescript/tests-ts/cli-patch.test.ts+++ b/sdk/typescript/tests-ts/cli-patch.test.ts@@ -797,6 +797,8 @@ describe("scan and patch workflow", () => {"--codex","analytics.enabled=false","--codex",+ "daybreak=true",+ "--codex",'model_provider="synthetic.gateway"',"--codex",'model_providers={"synthetic.gateway"={name="Synthetic",base_url="https://gateway.example.test/v1",wire_api="responses",env_key="SYNTHETIC_KEY"}}',@@ -807,6 +809,7 @@ describe("scan and patch workflow", () => {expect(args).toContain('model="gpt-6.1-sol"');expect(args).toContain('model_reasoning_effort="max"');expect(args).toContain("analytics.enabled=false");+ expect(args).toContain("daybreak=true");expect(args).toContain('model_provider="synthetic.gateway"');expect(output?.modelProvider).toBe("synthetic.gateway");expect(output?.codexOverrides).toMatchObject({diff --git a/sdk/typescript/tests-ts/cli-scan-patch-settings.test.ts b/sdk/typescript/tests-ts/cli-scan-patch-settings.test.tsindex 8098f1fbf..12c5759b4 100644--- a/sdk/typescript/tests-ts/cli-scan-patch-settings.test.ts+++ b/sdk/typescript/tests-ts/cli-scan-patch-settings.test.ts@@ -14,18 +14,43 @@ import { createInterface } from "node:readline";let homeConfig = "";try { homeConfig = readFileSync(join(process.env.CODEX_HOME, "config.toml"), "utf8"); }catch (error) { if (error.code !== "ENOENT") throw error; }-const receipt = { argv: process.argv.slice(2), homeTier: homeConfig.match(/^service_tier\\s*=\\s*(.*)$/m)?.[1] ?? null };+const receipt = {+ argv: process.argv.slice(2),+ homeTier: homeConfig.match(/^service_tier\\s*=\\s*(.*)$/m)?.[1] ?? null,+ homeDaybreak: homeConfig.match(/^daybreak\\s*=\\s*(.*)$/m)?.[1] ?? null,+};for await (const line of createInterface({ input: process.stdin })) {const request = JSON.parse(line);+ if (request.method === "initialize") receipt.experimentalApi = request.params.capabilities?.experimentalApi;if (request.method === "account/login/start") receipt.loginType = request.params.type;- if (request.method === "thread/start") {+ if (request.method === "config/read") {+ const daybreak = receipt.argv.find((value) => value.startsWith("daybreak="))?.slice("daybreak=".length) ?? receipt.homeDaybreak;+ const features = Object.fromEntries(["cli_daybreak", "api_key_cyber_access_programs", "api_key_model_discovery"].map((name) => {+ const prefix = "features." + name + "=";+ const value = receipt.argv.find((arg) => arg.startsWith(prefix))?.slice(prefix.length);+ return [name, value === undefined ? !homeConfig.includes("features." + name + " = false") : JSON.parse(value)];+ }));+ receipt.features = features;+ send({ id: request.id, result: { config: {+ ...(daybreak === null ? {} : { daybreak: JSON.parse(daybreak) }),+ features,+ }, layers: [] } });+ } else if (request.method === "experimentalFeature/list") {+ send({ id: request.id, result: { data: [{ name: "cli_daybreak", enabled: receipt.features.cli_daybreak }, { name: "api_key_cyber_access_programs", enabled: receipt.features.api_key_cyber_access_programs !== false }], nextCursor: null } });+ } else if (request.method === "account/read") {+ send({ id: request.id, result: { account: { type: "apiKey" } } });+ } else if (request.method === "model/list") {+ send({ id: request.id, result: { data: [{ model: "gpt-6.1-sol", availableAccessPrograms: { cyber: JSON.parse(process.env.SYNTHETIC_CYBER_PROGRAMS) } }], nextCursor: null } });+ } else if (request.method === "thread/start") {+ receipt.daybreakEnabled = request.params.daybreakEnabled ?? null;receipt.approvalPolicy = request.params.approvalPolicy;receipt.sandbox = request.params.sandbox;- send({ id: request.id, result: { thread: { id: "synthetic-thread" }, sandbox: { type: "workspaceWrite" } } });+ send({ id: request.id, result: { thread: { id: "synthetic-thread" }, model: "gpt-6.1-sol", modelProvider: "openai", sandbox: { type: "workspaceWrite" } } });} else if (request.method === "command/exec") {receipt.preflightSandbox = request.params.sandboxPolicy.type;send({ id: request.id, result: { exitCode: 0 } });} else if (request.method === "turn/start") {+ receipt.cyberAccessProgram = request.params.cyberAccessProgram ?? null;writeFileSync(process.env.SYNTHETIC_PATCH_RECEIPT, JSON.stringify(receipt));completeTurn(request, () => JSON.stringify({ patches: [{ occurrenceId: "occ_1", status: "no_change", files: [], verification: "Synthetic child-process fixture completed." }] }), "synthetic-thread");} else if (request.id !== undefined) send({ id: request.id, result: {} });@@ -35,16 +60,25 @@ for await (const line of createInterface({ input: process.stdin })) {interface ChildReceipt {argv: string[];homeTier: string | null;+ homeDaybreak: string | null;loginType: string;approvalPolicy: string;sandbox: string;preflightSandbox: string;+ cyberAccessProgram: string | null;+ daybreakEnabled: boolean | null;+ experimentalApi: boolean;+ features: Record<string, boolean>;}-async function inlinePatch(+async function patchSettings(settings: string[],- beforeChild?: () => Promise<void>,- homeConfig?: string,+ options: {+ beforeChild?: () => Promise<void>;+ homeConfig?: string;+ standalone?: boolean;+ programs?: string[];+ } = {},): Promise<ChildReceipt> {const root = await temporaryDirectory("inline-patch-settings-");const repository = join(root, "repository");@@ -71,25 +105,29 @@ async function inlinePatch(CODEX_HOME: join(root, "home"),CODEX_SECURITY_STATE_DIR: join(root, "state"),SYNTHETIC_PATCH_RECEIPT: receipt,+ SYNTHETIC_CYBER_PROGRAMS: JSON.stringify(+ options.programs ?? ["standard", "daybreakRed", "daybreakBlue"],+ ),};- if (homeConfig !== undefined) {+ if (options.homeConfig !== undefined) {await mkdir(environment.CODEX_HOME, { recursive: true });- await writeFile(join(environment.CODEX_HOME, "config.toml"), homeConfig);+ await writeFile(+ join(environment.CODEX_HOME, "config.toml"),+ options.homeConfig,+ );}const { stderr, runCli } = createCliTest(main);const status = await runCli([- "scan",- repository,- "--patch",+ ...(options.standalone+ ? ["patch", "Synthetic finding"]+ : ["scan", repository, "--patch", "--codex", "features.goals=false"]),"--auth","api-key","--model","gpt-6.1-sol","--effort","low",- "--codex",- "features.goals=false",...settings,"--json",],@@ -103,7 +141,7 @@ async function inlinePatch(reasoningEffort: "low",},onCodex: async (args, output, selectedEnvironment) => {- await beforeChild?.();+ await options.beforeChild?.();return runCodexSkillCommand([child, ...args],output,@@ -156,7 +194,7 @@ describe("inline patch service tier", () => {] as const)("preserves %s at the child-process boundary",async (_, settings, tier) => {- const child = await inlinePatch([...settings]);+ const child = await patchSettings([...settings]);expect(child.argv.filter((value) => value.startsWith("service_tier=")),).toEqual([`service_tier=${JSON.stringify(tier)}`]);@@ -172,7 +210,9 @@ describe("inline patch service tier", () => {);test("preserves the scan native default over an ambient fast tier", async () => {- const child = await inlinePatch([], undefined, 'service_tier = "fast"\n');+ const child = await patchSettings([], {+ homeConfig: 'service_tier = "fast"\n',+ });expect(child.argv).toContain('service_tier="default"');expect(child.homeTier).toBe('"fast"');expect(child.loginType).toBe("apiKey");@@ -180,7 +220,7 @@ describe("inline patch service tier", () => {expect(child.sandbox).toBe("workspace-write");});- test("keeps overlapping scan tiers isolated", async () => {+ test("keeps overlapping scan tiers and Daybreak settings isolated", async () => {let arrivals = 0;const { promise: ready, resolve: release } = Promise.withResolvers<void>();const beforeChild = async () => {@@ -188,19 +228,34 @@ describe("inline patch service tier", () => {await ready;};const children = await Promise.all([- inlinePatch(- ["--codex", 'service_tier="fast"'],- beforeChild,- 'service_tier = "standard"\n',+ patchSettings(+ ["--codex", 'service_tier="fast"', "--codex", "daybreak=true"],+ {+ beforeChild,+ homeConfig: 'service_tier = "standard"\ndaybreak = false\n',+ },),- inlinePatch([], beforeChild, 'service_tier = "fast"\n'),+ patchSettings([], {+ beforeChild,+ homeConfig: 'service_tier = "fast"\ndaybreak = true\n',+ }),]);expect(children[0]!.argv).toContain('service_tier="fast"');expect(children[1]!.argv).toContain('service_tier="default"');+ expect(children[0]!.argv).toContain("daybreak=true");+ expect(children[1]!.argv).toContain("daybreak=false");+ expect(children.map((child) => child.cyberAccessProgram)).toEqual([+ "daybreakBlue",+ "standard",+ ]);expect(children.map((child) => child.homeTier)).toEqual(['"standard"','"fast"',]);+ expect(children.map((child) => child.homeDaybreak)).toEqual([+ "false",+ "true",+ ]);});test("retains standalone patch override compatibility", async () => {@@ -219,3 +274,138 @@ describe("inline patch service tier", () => {expect(invoked).toBe(false);});});++describe("patch Daybreak configuration", () => {+ test.each([true, false, undefined])(+ "preserves standalone native configuration (override: %p)",+ async (daybreak) => {+ const child = await patchSettings(+ daybreak === undefined ? [] : ["--codex", `daybreak = ${daybreak}`],+ { standalone: true, homeConfig: "daybreak = true\n" },+ );+ expect(+ child.argv.filter((value) => value.startsWith("daybreak=")),+ ).toEqual(daybreak === undefined ? [] : [`daybreak=${daybreak}`]);+ expect(child.homeDaybreak).toBe("true");+ expect(child.cyberAccessProgram).toBe(+ daybreak === false ? "standard" : "daybreakBlue",+ );+ expect(child.daybreakEnabled).toBe(daybreak === false ? null : true);+ expect(child.experimentalApi).toBe(true);+ },+ );++ test.each([+ ["explicit true", ["daybreak=true"], true],+ ["explicit false", ["daybreak=false"], false],+ [+ "selected profile true",+ [+ "daybreak=false",+ 'profile="synthetic"',+ "profiles.synthetic.daybreak=true",+ ],+ true,+ ],+ [+ "selected profile false",+ [+ "daybreak=true",+ 'profile="synthetic"',+ "profiles.synthetic.daybreak=false",+ ],+ false,+ ],+ ["default over ambient true", [], false],+ ] as const)(+ "preserves inline scan %s at the child-process boundary",+ async (_, overrides, daybreak) => {+ const child = await patchSettings(+ overrides.flatMap((override) => ["--codex", override]),+ { homeConfig: "daybreak = true\n" },+ );+ expect(+ child.argv.filter((value) => value.startsWith("daybreak=")),+ ).toEqual([`daybreak=${daybreak}`]);+ expect(child.homeDaybreak).toBe("true");+ expect(child.cyberAccessProgram).toBe(+ daybreak ? "daybreakBlue" : "standard",+ );+ expect(child.daybreakEnabled).toBe(daybreak ? true : null);+ },+ );++ test("selects advertised Red when Blue is unavailable", async () => {+ const child = await patchSettings(["--codex", "daybreak=true"], {+ programs: ["standard", "daybreakRed"],+ });+ expect(child.cyberAccessProgram).toBe("daybreakRed");+ });++ test("honors the native Daybreak feature disable", async () => {+ const child = await patchSettings(["--codex", "daybreak=true"], {+ homeConfig: "features.cli_daybreak = false\n",+ standalone: true,+ });+ expect(child.cyberAccessProgram).toBeNull();+ expect(child.daybreakEnabled).toBe(true);+ });++ test("defaults a standalone turn to advertised standard", async () => {+ const child = await patchSettings([], { standalone: true });+ expect(child.cyberAccessProgram).toBe("standard");+ expect(child.daybreakEnabled).toBeNull();+ });++ test.each([+ ["standard", true, "standard"],+ ["daybreak_blue", false, "daybreakBlue"],+ ["daybreak_red", false, "daybreakRed"],+ ] as const)(+ "preserves the scan's explicit %s program over Daybreak %p",+ async (program, daybreak, expected) => {+ const child = await patchSettings(+ [+ "--cyber-access-program",+ program,+ "--codex",+ `daybreak=${daybreak}`,+ "--codex",+ "features.cli_daybreak=false",+ ],+ { homeConfig: "features.cli_daybreak = false\n" },+ );+ expect(child.cyberAccessProgram).toBe(expected);+ expect(child.daybreakEnabled).toBe(daybreak ? true : null);+ },+ );++ test.each([+ "cli_daybreak",+ "api_key_cyber_access_programs",+ "api_key_model_discovery",+ ])(+ "preserves the scan's %s feature gate over ambient settings",+ async (feature) => {+ const overridden = await patchSettings([+ "--codex",+ 'profile="synthetic"',+ "--codex",+ `features.${feature}=true`,+ "--codex",+ `profiles.synthetic.features.${feature}=false`,+ ]);+ expect(overridden.argv).toContain(`features.${feature}=false`);+ expect(overridden.features[feature]).toBe(false);+ if (feature !== "api_key_model_discovery")+ expect(overridden.cyberAccessProgram).toBeNull();++ const defaulted = await patchSettings([], {+ homeConfig: `features.${feature} = false\n`,+ });+ expect(defaulted.argv).toContain(`features.${feature}=true`);+ expect(defaulted.features[feature]).toBe(true);+ expect(defaulted.cyberAccessProgram).toBe("standard");+ },+ );+});diff --git a/sdk/typescript/tests-ts/cli-skill-native-config.test.ts b/sdk/typescript/tests-ts/cli-skill-native-config.test.tsindex e01a74744..90a7e9c79 100644--- a/sdk/typescript/tests-ts/cli-skill-native-config.test.ts+++ b/sdk/typescript/tests-ts/cli-skill-native-config.test.ts@@ -1,11 +1,17 @@-import { execFileSync } from "node:child_process";+import { execFileSync, spawn } from "node:child_process";+import { once } from "node:events";import { mkdir, mkdtemp, realpath, rm, writeFile } from "node:fs/promises";import { tmpdir } from "node:os";import { join } from "node:path";import { fileURLToPath } from "node:url";+import { createInterface } from "node:readline";import { expect, test } from "bun:test";import { runCodexSkillCommand } from "../src/cli.js";-import { writeCodexConfig } from "../src/config.js";+import {+ inlineToml,+ writeCodexConfig,+ type JsonObject,+} from "../src/config.js";import {prepareCodexSecurityCredentialHome,resolveCodexCommand,@@ -104,7 +110,7 @@ test.each([environment,);expect(status, stderr.text()).toBe(0);- expect(JSON.parse(stdout.text())).toEqual({+ expect(JSON.parse(stdout.text())).toMatchObject({modelProvider: "openai",projectServerConfigured: trust === "trusted",});@@ -113,3 +119,381 @@ test.each([}},);++const disabledDaybreakFeatures = {+ cli_daybreak: false,+ api_key_cyber_access_programs: false,+ api_key_model_discovery: false,+};++async function withStoredApiKey(+ command: "patch" | "verify-fix",+ check: (fixture: {+ root: string;+ environment: Record<string, string>;+ ambientHome: string;+ sharedHome: string;+ repository: string;+ run: (overrides?: JsonObject) => Promise<{+ daybreak: boolean | null;+ daybreakEnabled: boolean | null;+ daybreakFeatures: Record<string, boolean | null>;+ }>;+ }) => Promise<void>,+): Promise<void> {+ const root = await realpath(+ await mkdtemp(join(tmpdir(), "codex-security-stored-daybreak-")),+ );+ const repository = join(root, "repository");+ const ambientHome = join(root, "ambient");+ const environment = {+ ...Object.fromEntries(+ Object.entries(process.env).filter(([name]) =>+ /^(path|systemroot|comspec|temp|tmp|tmpdir)$/iu.test(name),+ ),+ ),+ CODEX_HOME: ambientHome,+ CODEX_SECURITY_STATE_DIR: join(root, "state"),+ SYNTHETIC_NATIVE_CODEX: resolveCodexCommand({}).command,+ };+ try {+ await mkdir(repository);+ execFileSync("git", ["init", "--quiet", repository]);+ const sharedHome = await prepareCodexSecurityCredentialHome(environment);+ await writeFile(+ join(sharedHome, "auth.json"),+ JSON.stringify({+ auth_mode: "apikey",+ OPENAI_API_KEY: "SYNTHETIC_KEY",+ }),+ { mode: 0o600 },+ );+ await check({+ root,+ environment,+ ambientHome,+ sharedHome,+ repository,+ run: async (overrides = {}) => {+ const stdout = capture();+ const stderr = capture();+ const status = await runCodexSkillCommand(+ [+ fileURLToPath(+ new URL("./fixtures/skill-native-config.mjs", import.meta.url),+ ),+ "app-server",+ "--disable",+ "plugins",+ "--config",+ "analytics.enabled=false",+ ...Object.entries(overrides).flatMap(([key, value]) => [+ "--config",+ `${key}=${inlineToml(value)}`,+ ]),+ ],+ {+ command,+ auth: "auto",+ codexOverrides: overrides,+ directory: repository,+ stdout: stdout.stream,+ stderr: stderr.stream,+ appServer: {+ directory: repository,+ prompt: "Synthetic finding",+ threadSource:+ command === "patch"+ ? "security_remediation"+ : "security_validation",+ ...(command === "verify-fix"+ ? { sandbox: "read-only" as const }+ : {}),+ },+ },+ { command: process.execPath },+ environment,+ );+ expect(status, stderr.text()).toBe(0);+ return JSON.parse(stdout.text());+ },+ });+ } finally {+ await rm(root, { recursive: true, force: true });+ }+}++test.each(+ (["patch", "verify-fix"] as const).flatMap((command) =>+ [true, false].map((daybreak) => [command, daybreak] as const),+ ),+)(+ "%s preserves ambient Daybreak %p with a stored API key",+ async (command, daybreak) => {+ await withStoredApiKey(+ command,+ async ({ ambientHome, sharedHome, run }) => {+ await writeCodexConfig(join(ambientHome, "config.toml"), { daybreak });+ await writeCodexConfig(join(sharedHome, "config.toml"), {+ daybreak: !daybreak,+ });+ expect(await run()).toMatchObject({+ daybreak,+ daybreakEnabled: daybreak ? true : null,+ });+ },+ );+ },+);++test.each(["patch", "verify-fix"] as const)(+ "%s preserves the Daybreak opt-out with an explicit toggle and a stored API key",+ async (command) => {+ await withStoredApiKey(command, async ({ ambientHome, run }) => {+ await writeCodexConfig(join(ambientHome, "config.toml"), {+ daybreak: false,+ features: { cli_daybreak: false },+ });+ expect(await run({ daybreak: true })).toMatchObject({+ daybreak: true,+ daybreakEnabled: true,+ daybreakFeatures: { cli_daybreak: false },+ });+ });+ },+);++test.each(["patch", "verify-fix"] as const)(+ "%s forwards wrapper-resolved ambient Daybreak profiles with a stored API key",+ async (command) => {+ await withStoredApiKey(command, async ({ ambientHome, run }) => {+ await writeCodexConfig(join(ambientHome, "config.toml"), {+ daybreak: false,+ features: { cli_daybreak: true },+ profile: "selected",+ profiles: {+ selected: { daybreak: true, features: disabledDaybreakFeatures },+ },+ });+ expect(await run()).toMatchObject({+ daybreak: true,+ daybreakEnabled: true,+ daybreakFeatures: disabledDaybreakFeatures,+ });+ });+ },+);++test.each(["patch", "verify-fix"] as const)(+ "%s clears removed ambient Daybreak settings on the next stored API-key launch",+ async (command) => {+ await withStoredApiKey(command, async ({ ambientHome, run }) => {+ const configPath = join(ambientHome, "config.toml");+ await writeCodexConfig(configPath, {});+ const baseline = await run();+ await writeCodexConfig(configPath, {+ daybreak: true,+ features: disabledDaybreakFeatures,+ });+ expect(await run()).toMatchObject({+ daybreak: true,+ daybreakEnabled: true,+ daybreakFeatures: disabledDaybreakFeatures,+ });+ await writeCodexConfig(configPath, {});+ expect(await run()).toEqual(baseline);+ });+ },+);++test.each(["patch", "verify-fix"] as const)(+ "%s preserves native project and explicit Daybreak precedence with a stored API key",+ async (command) => {+ await withStoredApiKey(+ command,+ async ({ ambientHome, repository, run }) => {+ await writeCodexConfig(join(ambientHome, "config.toml"), {+ daybreak: true,+ features: { cli_daybreak: true },+ projects: { [repository]: { trust_level: "trusted" } },+ });+ await writeCodexConfig(join(repository, ".codex", "config.toml"), {+ daybreak: false,+ features: { cli_daybreak: false },+ });+ expect(await run()).toMatchObject({+ daybreak: false,+ daybreakEnabled: null,+ daybreakFeatures: { cli_daybreak: false },+ });+ expect(await run({ daybreak: true })).toMatchObject({+ daybreak: true,+ daybreakEnabled: true,+ daybreakFeatures: { cli_daybreak: false },+ });+ },+ );+ },+);++test.each(["omitted", "omitted with changed gates", "explicit"] as const)(+ "stored API-key patches preserve %s settings for an active scan's later workers",+ async (settings) => {+ await withStoredApiKey(+ "patch",+ async ({+ root,+ environment,+ ambientHome,+ sharedHome,+ repository,+ run,+ }) => {+ await writeCodexConfig(join(ambientHome, "config.toml"), {});+ const scanConfig = join(root, "scan.toml");+ const workerConfig = join(root, "workers.toml");+ const workerRuntime: JsonObject =+ settings !== "explicit"+ ? {}+ : {+ daybreak: false,+ features: {+ cli_daybreak: true,+ api_key_cyber_access_programs: true,+ api_key_model_discovery: true,+ },+ };+ await writeCodexConfig(scanConfig, {});+ await writeCodexConfig(workerConfig, { worker_runtime: workerRuntime });+ const prompt = join(root, "prompt.md");+ await writeFile(prompt, "Synthetic worker request.");+ const executor = new URL(+ "../../../plugins/codex-security/mcp-app/src/deep-scan/executor.ts",+ import.meta.url,+ );+ const catalog = join(root, "catalog.json");+ await writeFile(+ catalog,+ JSON.stringify({+ models: [+ {+ slug: "gpt-test",+ display_name: "Synthetic",+ base_instructions: "Synthetic instructions",+ supported_reasoning_levels: [],+ shell_type: "disabled",+ visibility: "list",+ supported_in_api: true,+ priority: 0,+ support_verbosity: false,+ truncation_policy: { mode: "tokens", limit: 10000 },+ experimental_supported_tools: [],+ available_access_programs: {+ cyber: ["standard", "daybreak_red", "daybreak_blue"],+ },+ },+ ],+ }),+ );+ const child = spawn(+ process.execPath,+ [+ fileURLToPath(+ new URL(+ "./fixtures/stored-daybreak-workers.mjs",+ import.meta.url,+ ),+ ),+ fileURLToPath(executor),+ prompt,+ ],+ {+ cwd: repository,+ env: {+ ...environment,+ CODEX_HOME: sharedHome,+ CODEX_CLI_PATH: environment["SYNTHETIC_NATIVE_CODEX"],+ CODEX_API_KEY: "SYNTHETIC_KEY",+ CODEX_SECURITY_CONFIG_PATH: scanConfig,+ CODEX_SECURITY_DEEP_SCAN_CONFIG_PATH: workerConfig,+ },+ stdio: ["pipe", "pipe", "pipe"],+ windowsHide: true,+ },+ );+ const closed = once(child, "close");+ let stderr = "";+ child.stderr.on("data", (chunk) => {+ stderr += chunk;+ });+ const lines = createInterface({ input: child.stdout });+ const responses = lines[Symbol.asyncIterator]();+ const response = async () => {+ const next = await responses.next();+ expect(next.done, stderr).toBe(false);+ return JSON.parse(next.value!);+ };+ const worker = async (+ kind: "discovery" | "dedup",+ resumeThreadId?: string,+ ) => {+ child.stdin.write(JSON.stringify({ kind, resumeThreadId }) + "\n");+ return await response();+ };+ try {+ const { baseUrl } = await response();+ await writeCodexConfig(join(sharedHome, "config.toml"), {+ model_catalog_json: catalog,+ openai_base_url: baseUrl,+ cli_auth_credentials_store: "file",+ features: { plugins: false },+ analytics: { enabled: false },+ });+ // The first worker initializes the executor's per-scan snapshot.+ const { threadId, resumed, ...baseline } = await worker("discovery");+ expect(threadId).toBeString();+ expect(resumed).toBe(false);+ expect(baseline.program).toBe("standard");+ expect(baseline.daybreak).toBe(+ settings === "explicit" ? false : null,+ );+ if (settings === "explicit")+ expect(baseline.daybreakFeatures).toEqual(+ workerRuntime["features"],+ );+ const reducer = await worker("dedup");+ expect(reducer).toMatchObject({ ...baseline, resumed: false });+ const previousThreads = {+ discovery: threadId,+ dedup: reducer.threadId,+ };+ const features =+ settings === "omitted" ? undefined : disabledDaybreakFeatures;+ await writeCodexConfig(join(ambientHome, "config.toml"), {+ daybreak: true,+ ...(features === undefined ? {} : { features }),+ });+ expect(await run()).toMatchObject({+ daybreak: true,+ ...(features === undefined ? {} : { daybreakFeatures: features }),+ });+ for (const kind of ["discovery", "dedup"] as const) {+ for (const resume of [false, true]) {+ const receipt = await worker(+ kind,+ resume ? previousThreads[kind] : undefined,+ );+ expect(receipt).toMatchObject({ ...baseline, resumed: resume });+ if (resume) expect(receipt.threadId).toBe(previousThreads[kind]);+ }+ }+ } finally {+ lines.close();+ child.stdin.end();+ child.kill();+ await closed;+ }+ },+ );+ },+);diff --git a/sdk/typescript/tests-ts/cli-skills.test.ts b/sdk/typescript/tests-ts/cli-skills.test.tsindex b696cda29..157567aa2 100644--- a/sdk/typescript/tests-ts/cli-skills.test.ts+++ b/sdk/typescript/tests-ts/cli-skills.test.ts@@ -356,6 +356,7 @@ describe("CLI skill commands", () => {expect(help.text()).toContain("--codex <key=value>");expect(help.text()).toContain('model="gpt-5.6-terra"');expect(help.text()).toContain('model_reasoning_effort="high"');+ expect(help.text()).toContain("daybreak=true");expect(help.text()).toContain("analytics.enabled=false");expect(help.text()).not.toContain("--provider");}@@ -1092,13 +1093,15 @@ describe("CLI skill commands", () => {);test.each(["validate", "patch", "verify-fix"] as const)(- "passes explicit analytics settings to %s",+ "passes explicit native settings to %s",async (command) => {- for (const override of [- "analytics.enabled=false",- "analytics.enabled=true",- "analytics={enabled=false}",- ]) {+ for (const [override, forwarded] of [+ ["analytics.enabled=false", "analytics.enabled=false"],+ ["analytics.enabled=true", "analytics.enabled=true"],+ ["analytics={enabled=false}", "analytics={enabled=false}"],+ ["daybreak = true", "daybreak=true"],+ ["daybreak=false", "daybreak=false"],+ ] as const) {let invocation: readonly string[] = [];const stderr = captureCli(main, "stderr");expect(@@ -1133,7 +1136,7 @@ describe("CLI skill commands", () => {),stderr.text(),).toBe(0);- expect(invocation).toContain(override);+ expect(invocation).toContain(forwarded);expect(invocation).toContain('model_reasoning_effort="high"');}@@ -1644,6 +1647,11 @@ lines.on("line", (line) => {send({ id: 1, result: {} });} else if (request.method === "initialized") {initialized = true;+ } else if (request.method === "config/read") {+ send({ id: request.id, result: { config: {} } });+ } else if (request.method === "experimentalFeature/list") {+ assert.deepEqual(request.params, { threadId: "parent" });+ send({ id: request.id, result: { data: [{ name: "cli_daybreak", enabled: true }, { name: "api_key_cyber_access_programs", enabled: true }], nextCursor: null } });} else if (request.method === "thread/start") {assert.equal(initialized, true);assert.equal(process.cwd(), ${JSON.stringify(process.cwd())});@@ -1694,7 +1702,7 @@ lines.on("line", (line) => {expect(stderr.text()).toBe("");});- test("starts verification app-server threads with a read-only sandbox", async () => {+ test("preserves Daybreak when sandboxing verification app-server threads", async () => {const source = `const assert = require("node:assert/strict");const lines = require("node:readline").createInterface({ input: process.stdin });@@ -1707,7 +1715,7 @@ lines.on("line", (line) => {cwd: ${JSON.stringify(process.cwd())},includeLayers: true,});- send({ id: 4, result: { layers: [+ send({ id: 4, result: { config: { daybreak: true }, layers: [{ name: { type: "project" }, config: { mcp_servers: { repository: { command: "untrusted" } } } },{ name: { type: "user" }, config: { mcp_servers: { trusted: { command: "trusted" } } } },] } });@@ -1717,11 +1725,13 @@ lines.on("line", (line) => {threadSource: "security_validation",approvalPolicy: "on-request",sandbox: "read-only",+ daybreakEnabled: true,config: { mcp_servers: { repository: { enabled: false } } },});send({ id: 2, result: { thread: { id: "verification" } } });}if (request.method === "turn/start") {+ assert.equal(request.params.cyberAccessProgram, "standard");send({ id: 3, result: { turn: { id: "verification-turn" } } });send({ method: "item/started", params: {threadId: "another-thread", turnId: "verification-turn",@@ -1762,6 +1772,7 @@ lines.on("line", (line) => {"Verify the synthetic finding without editing the repository",threadSource: "security_validation",sandbox: "read-only",+ cyberAccessProgram: "standard",onEvent: (event) => activity.push(event),},},@@ -1815,6 +1826,8 @@ const send = (message) => process.stdout.write(JSON.stringify(message) + "\\n");lines.on("line", (line) => {const request = JSON.parse(line);if (request.method === "initialize") send({ id: 1, result: {} });+ if (request.method === "config/read") send({ id: request.id, result: { config: {} } });+ if (request.method === "experimentalFeature/list") send({ id: request.id, result: { data: [{ name: "cli_daybreak", enabled: true }, { name: "api_key_cyber_access_programs", enabled: true }], nextCursor: null } });if (request.method === "thread/start") send({ id: 2, result: { thread: { id: "parent" } } });if (request.method === "command/exec") send({ id: request.id, result: { exitCode: 0 } });if (request.method === "turn/start") process.stdout.write(${JSON.stringify(events.map((event) => JSON.stringify(event)).join("\n") + "\n")}, () => process.exit(0));diff --git a/sdk/typescript/tests-ts/fixtures/inherited-codex-pipes.mjs b/sdk/typescript/tests-ts/fixtures/inherited-codex-pipes.mjsindex 49aaf4949..7453e4197 100644--- a/sdk/typescript/tests-ts/fixtures/inherited-codex-pipes.mjs+++ b/sdk/typescript/tests-ts/fixtures/inherited-codex-pipes.mjs@@ -84,7 +84,11 @@ if (role === "holder") {for await (const line of createInterface({ input: process.stdin })) {if (mode === "active") continue;const message = JSON.parse(line);- if (["initialize", "account/login/start"].includes(message.method)) {+ if (+ ["initialize", "account/login/start", "config/read"].includes(+ message.method,+ )+ ) {send({ id: message.id, result: {} });} else if (message.method === "feedback/upload") {send(diff --git a/sdk/typescript/tests-ts/fixtures/skill-auth.mjs b/sdk/typescript/tests-ts/fixtures/skill-auth.mjsindex 6dadf32c6..44e67b235 100644--- a/sdk/typescript/tests-ts/fixtures/skill-auth.mjs+++ b/sdk/typescript/tests-ts/fixtures/skill-auth.mjs@@ -32,6 +32,20 @@ for await (const line of createInterface({ input: process.stdin })) {loggedIn = true;send({ id: request.id, result: { type: "apiKey" } });}+ } else if (request.method === "config/read") {+ send({ id: request.id, result: { config: {} } });+ } else if (request.method === "experimentalFeature/list") {+ assert.deepEqual(request.params, { threadId: "synthetic-thread" });+ send({+ id: request.id,+ result: {+ data: [+ { name: "cli_daybreak", enabled: true },+ { name: "api_key_cyber_access_programs", enabled: true },+ ],+ nextCursor: null,+ },+ });} else if (request.method === "thread/start") {if (process.env.SYNTHETIC_CHECK_STARTUP_LOCK) {assert.equal(diff --git a/sdk/typescript/tests-ts/fixtures/skill-native-config.mjs b/sdk/typescript/tests-ts/fixtures/skill-native-config.mjsindex 3c0c4bf12..9b2c525bf 100644--- a/sdk/typescript/tests-ts/fixtures/skill-native-config.mjs+++ b/sdk/typescript/tests-ts/fixtures/skill-native-config.mjs@@ -2,6 +2,7 @@ import { send, completeTurn } from "./app-server-messages.mjs";import { spawn } from "node:child_process";import { createInterface } from "node:readline";+const methods = new Map();const child = spawn(process.env.SYNTHETIC_NATIVE_CODEX, process.argv.slice(2), {env: process.env,stdio: ["pipe", "pipe", "pipe"],@@ -10,12 +11,20 @@ const child = spawn(process.env.SYNTHETIC_NATIVE_CODEX, process.argv.slice(2), {child.stderr.pipe(process.stderr);let turnRequest;let modelProvider;+let initialConfig;+let daybreakEnabled;await Promise.all([(async () => {for await (const line of createInterface({ input: process.stdin })) {const request = JSON.parse(line);+ if (request.id !== undefined) methods.set(request.id, request.method);+ if (request.method === "thread/start") {+ daybreakEnabled = request.params.daybreakEnabled ?? null;+ }if (request.method === "command/exec") {send({ id: request.id, result: { exitCode: 0 } });+ } else if (request.method === "model/list") {+ send({ id: request.id, result: { data: [], nextCursor: null } });} else if (request.method === "turn/start") {turnRequest = request;child.stdin.write(@@ -32,7 +41,10 @@ await Promise.all([(async () => {for await (const line of createInterface({ input: child.stdout })) {const response = JSON.parse(line);- if (response.id === 2) modelProvider = response.result?.modelProvider;+ if (methods.get(response.id) === "thread/start")+ modelProvider = response.result?.modelProvider;+ if (methods.get(response.id) === "config/read")+ initialConfig = response.result?.config;if (response.id !== "inspect-config") {process.stdout.write(line + "\n");continue;@@ -46,6 +58,15 @@ await Promise.all([modelProvider,projectServerConfigured:config.mcp_servers?.synthetic !== undefined,+ daybreak: initialConfig?.daybreak ?? null,+ daybreakEnabled,+ daybreakFeatures: Object.fromEntries(+ [+ "cli_daybreak",+ "api_key_cyber_access_programs",+ "api_key_model_discovery",+ ].map((key) => [key, initialConfig?.features?.[key] ?? null]),+ ),}),threadId,);diff --git a/sdk/typescript/tests-ts/fixtures/skill-provider-auth.mjs b/sdk/typescript/tests-ts/fixtures/skill-provider-auth.mjsindex 5bb912e49..b9b73fb32 100644--- a/sdk/typescript/tests-ts/fixtures/skill-provider-auth.mjs+++ b/sdk/typescript/tests-ts/fixtures/skill-provider-auth.mjs@@ -34,6 +34,17 @@ if (process.env.SYNTHETIC_SKILL_COMMAND === "validate") {send({ id: request.id, result: { type: "apiKey" } });} else if (request.method === "config/read") {send({ id: request.id, result: { layers: [] } });+ } else if (request.method === "experimentalFeature/list") {+ send({+ id: request.id,+ result: {+ data: [+ { name: "cli_daybreak", enabled: true },+ { name: "api_key_cyber_access_programs", enabled: true },+ ],+ nextCursor: null,+ },+ });} else if (request.method === "thread/start") {send({id: request.id,diff --git a/sdk/typescript/tests-ts/fixtures/stored-daybreak-workers.mjs b/sdk/typescript/tests-ts/fixtures/stored-daybreak-workers.mjsnew file mode 100644index 000000000..34c0145b1--- /dev/null+++ b/sdk/typescript/tests-ts/fixtures/stored-daybreak-workers.mjs@@ -0,0 +1,86 @@+import childProcess from "node:child_process";+import { mock } from "bun:test";+import { createInterface } from "node:readline";+import { pathToFileURL } from "node:url";++const spawn = childProcess.spawn;+let workerArgs;+// Capture actual worker arguments in this isolated coordinator process.+const recordedSpawn = (command, args, options) => {+ if (args[0] === "exec") workerArgs = args;+ return spawn(command, args, options);+};+for (const name of ["node:child_process", "child_process"])+ mock.module(name, () => ({ ...childProcess, spawn: recordedSpawn }));+const executorSource = pathToFileURL(process.argv[2]);+const { CodexSdkWorkerExecutor } = await import(executorSource.href);+const { readDeepScanRuntimeConfig } = await import(+ new URL("./permission-profile-preflight.ts", executorSource).href+);+const requests = [];+const server = Bun.serve({+ hostname: "127.0.0.1",+ port: 0,+ async fetch(request) {+ if (new URL(request.url).pathname !== "/v1/responses")+ return Response.json({});+ if (request.method !== "POST") return new Response(null, { status: 426 });+ requests.push(await request.json());+ return new Response(+ 'event: response.completed\ndata: {"type":"response.completed","response":{"id":"synthetic-response","output":[],"usage":{"input_tokens":0,"output_tokens":0,"total_tokens":0}}}\n\n',+ { headers: { "content-type": "text/event-stream" } },+ );+ },+});+process.env.OPENAI_BASE_URL = `${server.url}v1`;+const executor = new CodexSdkWorkerExecutor({+ model: "gpt-test",+ parentSandbox: { filesystemDenies: [] },+});+process.stdout.write(+ JSON.stringify({ baseUrl: process.env.OPENAI_BASE_URL }) + "\n",+);+try {+ for await (const line of createInterface({ input: process.stdin })) {+ const request = JSON.parse(line);+ const requestCount = requests.length;+ workerArgs = undefined;+ const result = await executor.run({+ ...request,+ promptPath: process.argv[3],+ workingDirectory: process.cwd(),+ subagents: 0,+ signal: new AbortController().signal,+ });+ if (!workerArgs)+ throw new Error("Native worker arguments were not captured");+ if (requests.length === requestCount)+ throw new Error("Worker completed without a synthetic Responses request");+ const config = await readDeepScanRuntimeConfig({+ codexPath: process.env.CODEX_CLI_PATH,+ cwd: process.cwd(),+ configOverrides: workerArgs.flatMap((arg, index) =>+ arg === "--config" || arg === "-c" ? [workerArgs[index + 1]] : [],+ ),+ env: process.env,+ signal: new AbortController().signal,+ });+ process.stdout.write(+ JSON.stringify({+ threadId: result.threadId,+ resumed: workerArgs.includes("resume"),+ program: requests.at(-1)?.access_programs?.cyber,+ daybreak: config.daybreak ?? null,+ daybreakFeatures: Object.fromEntries(+ [+ "cli_daybreak",+ "api_key_cyber_access_programs",+ "api_key_model_discovery",+ ].map((key) => [key, config.features?.[key] ?? null]),+ ),+ }) + "\n",+ );+ }+} finally {+ server.stop(true);+}diff --git a/sdk/typescript/tests-ts/scan-comparison.test.ts b/sdk/typescript/tests-ts/scan-comparison.test.tsindex ae56318d7..fe3ca535c 100644--- a/sdk/typescript/tests-ts/scan-comparison.test.ts+++ b/sdk/typescript/tests-ts/scan-comparison.test.ts@@ -1005,27 +1005,38 @@ describe("semantic scan comparison", () => {},);- test.each(["unselected", "default", "home", "overrides", "override-profile"])(+ test.each([+ "unselected",+ "default",+ "home",+ "overrides",+ "override-profile",+ "toggle-only",+ ])("preserves Cyber selection and %s feature gates at read-only SDK boundaries",async (selection) => {const home = await temporaryDirectory("codex-security-cyber-helper-");const disabled = {+ cli_daybreak: false,api_key_cyber_access_programs: false,api_key_model_discovery: false,shell_tool: true,};const profile = {+ daybreak: true,profile: "selected",- features: { api_key_cyber_access_programs: true },- profiles: { selected: { features: disabled } },+ features: { cli_daybreak: true, api_key_cyber_access_programs: true },+ profiles: { selected: { daybreak: false, features: disabled } },};await writeFile(join(home, "config.toml"),stringify(selection === "home" ? { features: disabled } : {}),);- const options = {+ const options: ScanComparisonOptions = {cyberAccessProgram:- selection === "unselected" ? undefined : ("daybreak_blue" as const),+ selection === "unselected" || selection === "toggle-only"+ ? undefined+ : ("daybreak_blue" as const),environment: {PATH: process.env["PATH"],SystemRoot: process.env["SystemRoot"],@@ -1034,11 +1045,17 @@ describe("semantic scan comparison", () => {OPENAI_API_KEY: "synthetic-key",},workingDirectory: home,- ...(selection === "overrides"- ? { config: { codexOverrides: { features: disabled } } }- : selection === "override-profile"- ? { config: { codexOverrides: profile } }- : {}),+ ...(selection === "home"+ ? { config: { codexOverrides: { daybreak: true } } }+ : selection === "overrides" || selection === "toggle-only"+ ? {+ config: {+ codexOverrides: { daybreak: true, features: disabled },+ },+ }+ : selection === "override-profile"+ ? { config: { codexOverrides: profile } }+ : {}),};let captured: CodexOptions | undefined;const { codex, calls } = fakeCodex({ matches: [], uncertain: [] });@@ -1066,6 +1083,16 @@ describe("semantic scan comparison", () => {string,unknown>;+ expect(captured?.config?.["daybreak"]).toBe(+ selection === "unselected" || selection === "default"+ ? undefined+ : selection !== "override-profile",+ );+ expect(features["cli_daybreak"]).toBe(+ selection === "unselected" || selection === "default"+ ? undefined+ : false,+ );expect(features["api_key_cyber_access_programs"]).toBe(selection === "unselected" ? undefined : selection === "default",);diff --git a/sdk/typescript/tests-ts/scan-resume.test.ts b/sdk/typescript/tests-ts/scan-resume.test.tsindex b2369021f..868b4005e 100644--- a/sdk/typescript/tests-ts/scan-resume.test.ts+++ b/sdk/typescript/tests-ts/scan-resume.test.ts@@ -988,6 +988,7 @@ test.each([const selected = {model: `synthetic-${auth ?? "auto"}-model`,model_reasoning_effort: "high",+ daybreak: auth === "api-key",features: { goals: false },};const settings = {@@ -1066,7 +1067,10 @@ test.each([max_discovery_runs: 5,max_time_hours: 1.5,},- worker_runtime: { features: { goals: false } },+ worker_runtime: {+ daybreak: selected.daybreak,+ features: { goals: false },+ },});const workerConfigPath =options.env?.["CODEX_SECURITY_CONFIG_PATH"];@@ -1077,6 +1081,7 @@ test.each([await readFile(workerConfigPath!, "utf8"),);expect(workerConfig).toMatchObject({+ daybreak: selected.daybreak,codex_security: {cyber_access_program: settings.cyberAccessProgram,},