Skip to content

OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security

fix: preserve Daybreak settings across scans and remediation (#1740)

Michael D'Angelo04df406934b8
diff --git a/README.md b/README.md
index 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.md
index 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 nested
alias 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 TypeScript
source. 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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 = 1
max_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.md
index 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 worker
configuration support. Older custom plugins fail before scan execution; update
diff --git a/sdk/typescript/docs/cli.md b/sdk/typescript/docs/cli.md
index 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 key
The [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:
```bash
diff --git a/sdk/typescript/scripts/package-dist-files.mjs b/sdk/typescript/scripts/package-dist-files.mjs
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 5088c5d5c..a6894a1b4 100644
--- a/sdk/typescript/src/cli.ts
+++ b/sdk/typescript/src/cli.ts
@@ -1,6 +1,8 @@
#!/usr/bin/env node
import { 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.mjs
index 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.mjs
index 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.mjs
index 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.mjs
index 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.mjs
new file mode 100644
index 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.ts
index 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.ts
index 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,
},