OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security
TypeScript ai-securityapplication-securityclicode-scanningcodexcodex-securitycybersecuritydevsecopsnodejsnpmopenaisdksecuritytypescriptvulnerability-scanning
feat(plugin): add Daybreak access advisory (#826)
Soyeon Park668119553254
diff --git a/plugins/codex-security/.app.json b/plugins/codex-security/.app.jsonindex 31d160e6a..97b2cdb35 100644--- a/plugins/codex-security/.app.json+++ b/plugins/codex-security/.app.json@@ -1,10 +1,5 @@{"apps": {- "codex-security-access": {- "id": "connector_openai_codex_security_access",- "category": "Security",- "required": false- },"linear": {"id": "asdk_app_69a089a326dc8191b32a3f2553f5be2c","category": "Work Tracking & Coordination"diff --git a/plugins/codex-security/mcp-app/package.json b/plugins/codex-security/mcp-app/package.jsonindex 6dfeb1cd7..a08f6242d 100644--- a/plugins/codex-security/mcp-app/package.json+++ b/plugins/codex-security/mcp-app/package.json@@ -1,6 +1,6 @@{"name": "codex-security-mcp-app",- "version": "0.1.158",+ "version": "0.1.159","type": "module","private": true,"scripts": {diff --git a/plugins/codex-security/mcp-app/server.ts b/plugins/codex-security/mcp-app/server.tsindex 520f1a774..52367ccff 100644--- a/plugins/codex-security/mcp-app/server.ts+++ b/plugins/codex-security/mcp-app/server.ts@@ -48,6 +48,37 @@ let workbenchStateSelectionTail: Promise<void> = Promise.resolve();const userContextSchema = z.string().trim().min(1);const editableUserContextSchema = z.string().trim();+const verifiedAccessGrantSchema = z.object({+ level: z.enum(["tac1", "tac2", "tac3", "government"]),+ source: z.enum(["user", "project", "current_account"])+}).strict().refine(({ level, source }) =>+ level === "tac1" || (level === "tac2" ? source === "user" : source === "current_account"),+ "Unsupported Daybreak grant source."+);+const verifiedAccessSnapshotSchema = z.object({+ schemaVersion: z.literal(1),+ status: z.enum(["granted", "not_granted", "unknown"]),+ grants: z.array(verifiedAccessGrantSchema),+ checkedAt: z.iso.datetime({ offset: true }).optional(),+ stale: z.boolean(),+ enrollmentUrl: z.url().optional()+}).strict().superRefine((snapshot, context) => {+ if (snapshot.status === "granted" && snapshot.grants.length === 0) {+ context.addIssue({ code: "custom", message: "Granted Daybreak access requires a grant." });+ }+ if (snapshot.status !== "granted" && snapshot.grants.length !== 0) {+ context.addIssue({ code: "custom", message: "Only granted Daybreak access may include grants." });+ }+}).transform((snapshot) => ({+ ...snapshot,+ checkedAt: snapshot.checkedAt ?? new Date().toISOString()+}));+const daybreakEntitlementContextSchema = z.object({+ schemaVersion: z.literal(1),+ entitlements: z.object({+ cyber_trusted_access: verifiedAccessSnapshotSchema+ })+});function scanRoot(): Promise<string> {if (CONFIGURED_SCAN_ROOT) return Promise.resolve(CONFIGURED_SCAN_ROOT);@@ -361,6 +392,54 @@ export function createCodexSecurityServer(): McpServer {const appMeta = { ui: { visibility: ["app"] as const } };const modelActionMeta = { ui: { visibility: ["model"] as const } };+ server.registerTool("get_codex_security_daybreak_access", {+ title: "Check Codex Security Daybreak Access",+ description: "Check this account's Daybreak access and available Daybreak programs. This check is advisory and never authorizes or blocks a scan.",+ inputSchema: z.object({}).strict(),+ annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },+ _meta: {+ ...modelActionMeta,+ "openai/requestedEntitlements": ["cyber_trusted_access"]+ }+ }, (_input, extra) => {+ const metadata = requestMetadataFromExtra(extra);+ const threadId = typeof metadata?.threadId === "string" && metadata.threadId.trim()+ ? metadata.threadId.trim()+ : undefined;+ const parsed = threadId+ ? daybreakEntitlementContextSchema.safeParse(metadata?.["openai/entitlementContext"])+ : undefined;+ const snapshot = parsed?.success ? parsed.data.entitlements.cyber_trusted_access : {+ schemaVersion: 1 as const,+ status: "unknown" as const,+ grants: [],+ checkedAt: new Date().toISOString(),+ stale: false+ };+ const status = snapshot.stale ? "unknown" : snapshot.status;+ const programs = status === "granted" ? [...new Set(snapshot.grants.map(({ level }) =>+ level === "tac3" || level === "government" ? "Daybreak Red" : "Daybreak Blue"+ ))] : [];+ const access = {+ schemaVersion: snapshot.schemaVersion,+ status,+ programs,+ checkedAt: snapshot.checkedAt,+ stale: snapshot.stale,+ ...(snapshot.enrollmentUrl ? { enrollmentUrl: snapshot.enrollmentUrl } : {})+ };+ const warning = access.status === "granted"+ ? ""+ : " This check is advisory: a scan may run, but protected results may not be displayable.";+ return {+ content: [{+ type: "text" as const,+ text: `Codex Security Daybreak access: status=${access.status}; programs=${programs.join(", ") || "none"}; checkedAt=${access.checkedAt}; stale=${access.stale}.${warning}`+ }],+ structuredContent: access+ };+ });+server.registerTool("start_codex_security_standard_scan", {title: "Start or Join Codex Security Standard Scan",description: "Headless and CLI only. Start or rejoin a Standard security scan. Do not use for desktop scans, Review changes, Deep Scan, or an existing SDK-owned scan. Use the returned authoritative scanId, scanDir, and handoffClaimToken throughout preflight, reporting, and completion.",@@ -1721,14 +1800,18 @@ function isJsonObject(value: unknown): value is JsonObject {return Boolean(value && typeof value === "object" && !Array.isArray(value));}-function threadIdFromExtra(extra: unknown): string | undefined {+function requestMetadataFromExtra(extra: unknown): JsonObject | undefined {if (!isJsonObject(extra)) return undefined;const requestInfo = isJsonObject(extra.requestInfo) ? extra.requestInfo : undefined;- const metadata = isJsonObject(requestInfo?._meta)+ return isJsonObject(requestInfo?._meta)? requestInfo._meta: isJsonObject(extra._meta)? extra._meta: undefined;+}++function threadIdFromExtra(extra: unknown): string | undefined {+ const metadata = requestMetadataFromExtra(extra);for (const key of ["openai/threadId", "openai/thread_id", "codexThreadId", "codex_thread_id", "threadId", "thread_id"]) {const value = metadata?.[key];if (typeof value === "string" && value.trim()) return value.trim();@@ -1742,13 +1825,7 @@ function codexModelSettingsFromExtra(extra: unknown): {model?: string;reasoningEffort?: string;} {- if (!isJsonObject(extra)) return {};- const requestInfo = isJsonObject(extra.requestInfo) ? extra.requestInfo : undefined;- const metadata = isJsonObject(requestInfo?._meta)- ? requestInfo._meta- : isJsonObject(extra._meta)- ? extra._meta- : undefined;+ const metadata = requestMetadataFromExtra(extra);// Codex supplies the already-resolved runtime model and effective effort on every MCP call.const turnMetadata = isJsonObject(metadata?.["x-codex-turn-metadata"])? metadata["x-codex-turn-metadata"]diff --git a/plugins/codex-security/mcp-app/tests/test_mcp_app_smoke.mjs b/plugins/codex-security/mcp-app/tests/test_mcp_app_smoke.mjsindex e776ebd5b..09583cb6d 100644--- a/plugins/codex-security/mcp-app/tests/test_mcp_app_smoke.mjs+++ b/plugins/codex-security/mcp-app/tests/test_mcp_app_smoke.mjs@@ -1080,6 +1080,336 @@ try {);assert.deepEqual(initialized.result.capabilities.extensions["com.openai"], {});assert.deepEqual(initialized.result.capabilities.logging, {});++ const trustedAccessToolList = await requestAndWait(9600, "tools/list");+ assertNoError(trustedAccessToolList);+ const trustedAccessTool = trustedAccessToolList.result.tools.find(+ (tool) => tool.name === "get_codex_security_daybreak_access",+ );+ assert.ok(trustedAccessTool, "Expected the plugin-owned Daybreak access tool.");+ assert.doesNotMatch(+ JSON.stringify({+ name: trustedAccessTool.name,+ title: trustedAccessTool.title,+ description: trustedAccessTool.description,+ }),+ /\btac(?:[123])?\b/i,+ );+ assert.deepEqual(trustedAccessTool.inputSchema.properties, {});+ assert.deepEqual(trustedAccessTool.inputSchema.required ?? [], []);+ assert.deepEqual(trustedAccessTool._meta.ui.visibility, ["model"]);+ assert.deepEqual(trustedAccessTool._meta["openai/requestedEntitlements"], [+ "cyber_trusted_access",+ ]);+ assert.equal(trustedAccessTool.annotations.readOnlyHint, true);+ assert.equal(trustedAccessTool.annotations.destructiveHint, false);+ assert.equal(trustedAccessTool.annotations.openWorldHint, false);++ const unknownTrustedAccess = await requestAndWait(9601, "tools/call", {+ name: "get_codex_security_daybreak_access",+ arguments: {},+ });+ assertNoError(unknownTrustedAccess);+ assert.equal(unknownTrustedAccess.result._meta, undefined);+ assert.deepEqual(+ {+ ...unknownTrustedAccess.result.structuredContent,+ checkedAt: undefined,+ },+ {+ schemaVersion: 1,+ status: "unknown",+ programs: [],+ checkedAt: undefined,+ stale: false,+ },+ );+ assert.ok(+ Number.isFinite(+ Date.parse(unknownTrustedAccess.result.structuredContent.checkedAt),+ ),+ );++ const grantedTrustedAccess = {+ schemaVersion: 1,+ status: "granted",+ grants: [+ { level: "tac1", source: "user" },+ { level: "tac3", source: "current_account" },+ { level: "tac2", source: "user" },+ { level: "tac1", source: "project" },+ { level: "government", source: "current_account" },+ ],+ checkedAt: "2026-07-13T12:00:00.000Z",+ stale: false,+ };+ const grantedDaybreakAccess = {+ schemaVersion: 1,+ status: "granted",+ programs: ["Daybreak Blue", "Daybreak Red"],+ checkedAt: "2026-07-13T12:00:00.000Z",+ stale: false,+ };+ const hostedTrustedAccess = await requestAndWait(9602, "tools/call", {+ name: "get_codex_security_daybreak_access",+ arguments: {},+ _meta: {+ threadId: "fixture-trusted-access-thread",+ "openai/entitlementContext": {+ schemaVersion: 1,+ entitlements: {+ cyber_trusted_access: grantedTrustedAccess,+ },+ },+ },+ });+ assertNoError(hostedTrustedAccess);+ assert.equal(hostedTrustedAccess.result._meta, undefined);+ assert.deepEqual(+ hostedTrustedAccess.result.structuredContent,+ grantedDaybreakAccess,+ );+ assert.doesNotMatch(JSON.stringify(hostedTrustedAccess.result), /\btac(?:[123])?\b/i);+ assert.match(hostedTrustedAccess.result.content[0].text, /Daybreak Blue/);+ assert.match(hostedTrustedAccess.result.content[0].text, /Daybreak Red/);++ const invalidGrantPairs = [+ { level: "tac2", source: "project" },+ { level: "tac2", source: "current_account" },+ { level: "tac3", source: "user" },+ { level: "tac3", source: "project" },+ { level: "government", source: "user" },+ { level: "government", source: "project" },+ ];+ for (const [index, invalidGrant] of invalidGrantPairs.entries()) {+ const response = await requestAndWait(9620 + index, "tools/call", {+ name: "get_codex_security_daybreak_access",+ arguments: {},+ _meta: {+ threadId: "fixture-invalid-grant-thread",+ "openai/entitlementContext": {+ schemaVersion: 1,+ entitlements: {+ cyber_trusted_access: {+ ...grantedTrustedAccess,+ grants: [{ level: "tac1", source: "user" }, invalidGrant],+ },+ },+ },+ },+ });+ assertNoError(response);+ assert.equal(response.result.structuredContent.status, "unknown");+ assert.deepEqual(response.result.structuredContent.programs, []);+ }++ const staleGrantedAccess = await requestAndWait(9626, "tools/call", {+ name: "get_codex_security_daybreak_access",+ arguments: {},+ _meta: {+ threadId: "fixture-stale-granted-thread",+ "openai/entitlementContext": {+ schemaVersion: 1,+ entitlements: {+ cyber_trusted_access: { ...grantedTrustedAccess, stale: true },+ },+ },+ },+ });+ assertNoError(staleGrantedAccess);+ assert.deepEqual(staleGrantedAccess.result.structuredContent, {+ schemaVersion: 1,+ status: "unknown",+ programs: [],+ checkedAt: grantedTrustedAccess.checkedAt,+ stale: true,+ });+ assert.match(staleGrantedAccess.result.content[0].text, /protected results may not be displayable/);++ const untrustedReplay = await requestAndWait(9603, "tools/call", {+ name: "get_codex_security_daybreak_access",+ arguments: {},+ _meta: { threadId: "fixture-trusted-access-thread" },+ });+ assertNoError(untrustedReplay);+ assert.equal(untrustedReplay.result._meta, undefined);+ assert.equal(untrustedReplay.result.structuredContent.status, "unknown");++ const deniedTrustedAccess = {+ schemaVersion: 1,+ status: "not_granted",+ grants: [],+ checkedAt: "2026-07-13T12:01:00.000Z",+ stale: false,+ enrollmentUrl: "https://chatgpt.com/cyber",+ };+ const refreshedTrustedAccess = await requestAndWait(9604, "tools/call", {+ name: "get_codex_security_daybreak_access",+ arguments: {},+ _meta: {+ threadId: "fixture-trusted-access-thread",+ "openai/entitlementContext": {+ schemaVersion: 1,+ entitlements: {+ cyber_trusted_access: deniedTrustedAccess,+ },+ },+ },+ });+ assertNoError(refreshedTrustedAccess);+ assert.equal(refreshedTrustedAccess.result._meta, undefined);+ assert.deepEqual(+ refreshedTrustedAccess.result.structuredContent,+ {+ schemaVersion: 1,+ status: "not_granted",+ programs: [],+ checkedAt: "2026-07-13T12:01:00.000Z",+ stale: false,+ enrollmentUrl: "https://chatgpt.com/cyber",+ },+ );+ assert.doesNotMatch(JSON.stringify(refreshedTrustedAccess.result), /\btac(?:[123])?\b/i);++ const timestampedTrustedAccess = await requestAndWait(9608, "tools/call", {+ name: "get_codex_security_daybreak_access",+ arguments: {},+ _meta: {+ threadId: "fixture-timestamped-trusted-access-thread",+ "openai/entitlementContext": {+ schemaVersion: 1,+ entitlements: {+ cyber_trusted_access: {+ schemaVersion: 1,+ status: "granted",+ grants: [{ level: "tac2", source: "user" }],+ stale: false,+ },+ },+ },+ },+ });+ assertNoError(timestampedTrustedAccess);+ assert.equal(timestampedTrustedAccess.result.structuredContent.status, "granted");+ assert.deepEqual(timestampedTrustedAccess.result.structuredContent.programs, [+ "Daybreak Blue",+ ]);+ assert.ok(+ Number.isFinite(+ Date.parse(timestampedTrustedAccess.result.structuredContent.checkedAt),+ ),+ );++ const unownedTrustedAccess = await requestAndWait(9605, "tools/call", {+ name: "get_codex_security_daybreak_access",+ arguments: {},+ _meta: {+ "openai/threadId": "fixture-spoofed-missing-canonical-thread",+ "openai/entitlementContext": {+ schemaVersion: 1,+ entitlements: {+ cyber_trusted_access: grantedTrustedAccess,+ },+ },+ },+ });+ assertNoError(unownedTrustedAccess);+ assert.equal(unownedTrustedAccess.result.structuredContent.status, "unknown");++ const malformedTrustedAccess = await requestAndWait(9606, "tools/call", {+ name: "get_codex_security_daybreak_access",+ arguments: {},+ _meta: {+ threadId: "fixture-malformed-trusted-access-thread",+ "openai/entitlementContext": {+ schemaVersion: 1,+ entitlements: {+ cyber_trusted_access: {+ ...grantedTrustedAccess,+ grants: [],+ },+ },+ },+ },+ });+ assertNoError(malformedTrustedAccess);+ assert.equal(malformedTrustedAccess.result.structuredContent.status, "unknown");++ const argumentTrustedAccess = await requestAndWait(9607, "tools/call", {+ name: "get_codex_security_daybreak_access",+ arguments: {+ "openai/entitlementContext": {+ schemaVersion: 1,+ entitlements: {+ cyber_trusted_access: grantedTrustedAccess,+ },+ },+ },+ _meta: { threadId: "fixture-argument-trusted-access-thread" },+ });+ assert.equal(argumentTrustedAccess.result.isError, true);++ const replayedTrustedAccess = await requestAndWait(9609, "tools/call", {+ name: "get_codex_security_daybreak_access",+ arguments: {},+ _meta: { threadId: "fixture-trusted-access-thread" },+ });+ assertNoError(replayedTrustedAccess);+ assert.equal(replayedTrustedAccess.result.structuredContent.status, "unknown");++ const spoofedThreadTrustedAccess = await requestAndWait(9610, "tools/call", {+ name: "get_codex_security_daybreak_access",+ arguments: {},+ _meta: {+ threadId: "fixture-trusted-access-owner",+ "openai/threadId": "fixture-spoofed-trusted-access-owner",+ "openai/entitlementContext": {+ schemaVersion: 1,+ entitlements: {+ cyber_trusted_access: grantedTrustedAccess,+ },+ },+ },+ });+ assertNoError(spoofedThreadTrustedAccess);+ assert.deepEqual(+ spoofedThreadTrustedAccess.result.structuredContent,+ grantedDaybreakAccess,+ );+ const canonicalThreadTrustedAccess = await requestAndWait(9611, "tools/call", {+ name: "get_codex_security_daybreak_access",+ arguments: {},+ _meta: { threadId: "fixture-trusted-access-owner" },+ });+ assertNoError(canonicalThreadTrustedAccess);+ assert.equal(canonicalThreadTrustedAccess.result.structuredContent.status, "unknown");++ const isolatedHostedTrustedAccess = await requestAndWait(9612, "tools/call", {+ name: "get_codex_security_daybreak_access",+ arguments: {},+ _meta: {+ threadId: "fixture-isolated-trusted-access-owner",+ "openai/entitlementContext": {+ schemaVersion: 1,+ entitlements: {+ cyber_trusted_access: grantedTrustedAccess,+ },+ },+ },+ });+ assertNoError(isolatedHostedTrustedAccess);+ assert.deepEqual(+ isolatedHostedTrustedAccess.result.structuredContent,+ grantedDaybreakAccess,+ );+ const isolatedOtherTrustedAccess = await requestAndWait(9613, "tools/call", {+ name: "get_codex_security_daybreak_access",+ arguments: {},+ _meta: { threadId: "fixture-isolated-trusted-access-other" },+ });+ assertNoError(isolatedOtherTrustedAccess);+ assert.equal(isolatedOtherTrustedAccess.result.structuredContent.status, "unknown");+await assertBundledNodeLauncher();await assertBundledPythonRuntime();await assertMissingPythonError();diff --git a/plugins/codex-security/references/config-preflight.md b/plugins/codex-security/references/config-preflight.mdindex 6870b1925..28545afac 100644--- a/plugins/codex-security/references/config-preflight.md+++ b/plugins/codex-security/references/config-preflight.md@@ -84,6 +84,6 @@ Present applicable remediation in the Codex thread. Ask before editing persistenCodex CLI and other hosts use the same prompt-based preflight before substantive work. Explain the exact reasons and remediation in chat. Interactive CLI sessions ask before editing persistent config; non-interactive CLI sessions use the narrow automatic-remediation path above and continue only after a `ready` rerun.-## TAC Status Advisory+## Daybreak Access Advisory-After capability preflight is `ready` and immediately before the workflow's first substantive scan action, use the hosted Codex Security Access app [$codex-security-access](app://connector_openai_codex_security_access) to call its `get_tac_status` action exactly once as the automatic pre-scan advisory. For Deep Security Scan, make this call immediately before `start_codex_security_deep_scan`. If this scan already performed the automatic advisory in an earlier continuation, reuse that result instead of calling it again. Report its exact `status` and TAC grant levels. When `status` is `not_granted`, before any other scan-start progress, present a separate, prominent warning that TAC access is not granted for this account and protected scan outputs may not be displayable. Include the returned `enrollmentUrl` as a clickable application link; if that field is absent, use `https://chatgpt.com/cyber`. Do not bury this warning in a routine status summary. When `status` is `unknown`, or the app or action is unavailable, instead warn that TAC access could not be verified and protected scan outputs may not be displayable. Then continue regardless. This result is advisory and must never authorize or gate the scan. Do not poll it or repeat it between scan phases. If the user explicitly asks to re-check after an account or TAC access change, call the action again for a fresh result; this user-requested refresh is the only repeat.+After capability preflight is `ready` and immediately before the workflow's first substantive scan action, call the plugin's `get_codex_security_daybreak_access` tool exactly once when available as the automatic pre-scan advisory. ChatGPT-authenticated desktop and CLI sessions both support this advisory; API-key-only sessions cannot verify account access. For Deep Security Scan, make this call immediately before `start_codex_security_deep_scan`. If this scan already performed the automatic advisory in an earlier continuation, reuse that result instead of calling it again. Report its exact `status` and available Daybreak programs. When `status` is `not_granted`, before any other scan-start progress, present a separate, prominent warning that Daybreak access is not granted for this account and protected scan outputs may not be displayable. Include the returned `enrollmentUrl` as a clickable application link; if that field is absent, use `https://chatgpt.com/cyber`. Do not bury this warning in a routine status summary. When `status` is `unknown`, `stale` is `true`, or the tool is unavailable or fails, instead warn that Daybreak access could not be verified and protected scan outputs may not be displayable. Then continue regardless. This result is advisory and must never authorize or gate the scan. Do not poll it or repeat it between scan phases. If the user explicitly asks to re-check after an account or Daybreak access change, call the tool again when available for a fresh result; this user-requested refresh is the only repeat.diff --git a/plugins/codex-security/skills/deep-security-scan/SKILL.md b/plugins/codex-security/skills/deep-security-scan/SKILL.mdindex ef9b63035..d9f8e9e10 100644--- a/plugins/codex-security/skills/deep-security-scan/SKILL.md+++ b/plugins/codex-security/skills/deep-security-scan/SKILL.md@@ -37,9 +37,9 @@ Do not repeat this guard after it passes, on later context loads, or after the sAfter preserving any native continuation's scan context and applying its one-time concurrent-scan guard, read `../../references/scan-prologue.md` once. Deep scans do not run a capability helper, inspect runtime tools, request configuration remediation, or publish preflight checks. The coordinator validates its own ownership, target, scope, and sandbox and manages its workers independently of this thread's delegation runtime and subagent allowance.-## TAC Status Advisory+## Daybreak Access Advisory-Immediately before the first `start_codex_security_deep_scan` call, the top-level parent uses the hosted Codex Security Access app [$codex-security-access](app://connector_openai_codex_security_access) to call `get_tac_status` once; workers never perform this advisory. Reuse an existing result when continuing the same scan. Report the exact `status` and TAC grant levels. If `status` is `not_granted`, prominently warn before scan-start progress that TAC access is not granted and protected outputs may not be displayable, and include the returned `enrollmentUrl` as a clickable application link, falling back to `https://chatgpt.com/cyber` when it is absent. If `status` is `unknown` or the app or action is unavailable, warn that access could not be verified and protected outputs may not be displayable. Then continue regardless: the advisory never authorizes, gates, or becomes a capability preflight for the scan. Do not poll or repeat it between phases; recheck only when the user explicitly requests a fresh result after an account or TAC access change.+Immediately before the first `start_codex_security_deep_scan` call, the top-level parent calls the plugin's `get_codex_security_daybreak_access` tool once when available; workers never perform this advisory. ChatGPT-authenticated desktop and CLI sessions both support this advisory; API-key-only sessions cannot verify account access. Reuse an existing result when continuing the same scan. Report the exact `status` and available Daybreak programs. If `status` is `not_granted`, prominently warn before scan-start progress that Daybreak access is not granted and protected outputs may not be displayable, and include the returned `enrollmentUrl` as a clickable application link, falling back to `https://chatgpt.com/cyber` when it is absent. If `status` is `unknown`, `stale` is `true`, or the tool is unavailable or fails, warn that access could not be verified and protected outputs may not be displayable. Then continue regardless: the advisory never authorizes, gates, or becomes a capability preflight for the scan. Do not poll or repeat it between phases; recheck only when the user explicitly requests a fresh result after an account or Daybreak access change.## Run Independent Standard Scansdiff --git a/plugins/codex-security/tests/test_plugin_contract.py b/plugins/codex-security/tests/test_plugin_contract.pyindex 244e1146b..838873c87 100644--- a/plugins/codex-security/tests/test_plugin_contract.py+++ b/plugins/codex-security/tests/test_plugin_contract.py@@ -8,8 +8,8 @@ from typing import Anyimport yamlPLUGIN_ROOT = Path(__file__).resolve().parents[1]-CODEX_SECURITY_ACCESS_APP_NAME = "codex-security-access"-CODEX_SECURITY_ACCESS_CONNECTOR_ID = "connector_openai_codex_security_access"+LEGACY_CODEX_SECURITY_ACCESS_APP_NAME = "codex-security-access"+LEGACY_CODEX_SECURITY_ACCESS_CONNECTOR_ID = "connector_openai_codex_security_access"def read_json(path: Path) -> dict[str, Any]:@@ -104,16 +104,14 @@ def test_plugin_manifest_references_existing_assets_and_skills() -> None:assert (PLUGIN_ROOT / relative_path).is_file(), relative_path-def test_codex_security_access_app_contract() -> None:+def test_daybreak_access_uses_plugin_mcp() -> None:apps = read_json(PLUGIN_ROOT / ".app.json")["apps"]mcp_servers = read_json(PLUGIN_ROOT / ".mcp.json")["mcpServers"]- assert apps[CODEX_SECURITY_ACCESS_APP_NAME] == {- "id": CODEX_SECURITY_ACCESS_CONNECTOR_ID,- "category": "Security",- "required": False,- }- assert CODEX_SECURITY_ACCESS_APP_NAME not in mcp_servers+ assert LEGACY_CODEX_SECURITY_ACCESS_APP_NAME not in apps+ assert all(app["id"] != LEGACY_CODEX_SECURITY_ACCESS_CONNECTOR_ID for app in apps.values())+ assert "codex-security" in mcp_servers+ assert LEGACY_CODEX_SECURITY_ACCESS_APP_NAME not in mcp_serversdef test_deep_scan_config_override_is_forwarded_to_mcp_server() -> None:diff --git a/sdk/typescript/tests-ts/plugin-apps.test.ts b/sdk/typescript/tests-ts/plugin-apps.test.tsindex 7a0eb9ad5..05dece4f6 100644--- a/sdk/typescript/tests-ts/plugin-apps.test.ts+++ b/sdk/typescript/tests-ts/plugin-apps.test.ts@@ -3,7 +3,7 @@ import { join } from "node:path";import { expect, test } from "bun:test";import { PLUGIN_ROOT } from "./plugin-root.js";-test("registers security access as an optional hosted app, not a local MCP server", async () => {+test("registers security access through the Codex Security MCP, not a hosted app", async () => {const [appConfiguration, mcpConfiguration] = await Promise.all([readFile(join(PLUGIN_ROOT, ".app.json"), "utf8"),readFile(join(PLUGIN_ROOT, ".mcp.json"), "utf8"),@@ -15,10 +15,14 @@ test("registers security access as an optional hosted app, not a local MCP serve"mcpServers"] as Record<string, unknown>;- expect(apps["codex-security-access"]).toEqual({- id: "connector_openai_codex_security_access",- category: "Security",- required: false,- });+ expect(apps).not.toHaveProperty("codex-security-access");+ expect(+ Object.values(apps).some(+ (app) =>+ (app as Record<string, unknown>)["id"] ===+ "connector_openai_codex_security_access",+ ),+ ).toBe(false);+ expect(mcpServers).toHaveProperty("codex-security");expect(mcpServers).not.toHaveProperty("codex-security-access");});