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: exclude same-millisecond replayed usage from scan budgets (#631)

mldangelo-oaib04dd3f3748d
diff --git a/plugins/codex-security/.codex-plugin/plugin.json b/plugins/codex-security/.codex-plugin/plugin.json
index 43fa0c2a9..056258dc9 100644
--- a/plugins/codex-security/.codex-plugin/plugin.json
+++ b/plugins/codex-security/.codex-plugin/plugin.json
@@ -1,6 +1,6 @@
{
"name": "codex-security",
- "version": "0.1.94",
+ "version": "0.1.95",
"description": "Codex Security workflows for security scans, analysis, and investigation.",
"author": {
"name": "OpenAI"
diff --git a/plugins/codex-security/scripts/workbench_scan_usage.py b/plugins/codex-security/scripts/workbench_scan_usage.py
index a9f2afeda..3322cb187 100644
--- a/plugins/codex-security/scripts/workbench_scan_usage.py
+++ b/plugins/codex-security/scripts/workbench_scan_usage.py
@@ -501,19 +501,20 @@ def _is_owned_task_start(
turn_id = payload.get("turn_id")
if not isinstance(turn_id, str) or not turn_id:
return False
- thread_timestamp = _uuid7_timestamp(thread_id)
- turn_timestamp = _uuid7_timestamp(turn_id)
- if thread_timestamp is None:
+ # Fresh Codex worker thread/turn IDs use a same-process monotonic UUIDv7 generator.
+ thread_order = _uuid7_order(thread_id)
+ turn_order = _uuid7_order(turn_id)
+ if thread_order is None:
return True
- return turn_timestamp is not None and turn_timestamp >= thread_timestamp
+ return turn_order is not None and turn_order >= thread_order
-def _uuid7_timestamp(value: str) -> int | None:
+def _uuid7_order(value: str) -> int | None:
try:
parsed = uuid.UUID(value)
except ValueError:
return None
- return parsed.int >> 80 if parsed.version == 7 else None
+ return parsed.int if parsed.version == 7 else None
def _token_snapshot(payload: Mapping[str, Any]) -> dict[str, int] | None:
diff --git a/sdk/typescript/src/cost.ts b/sdk/typescript/src/cost.ts
index 8db94b604..81247c072 100644
--- a/sdk/typescript/src/cost.ts
+++ b/sdk/typescript/src/cost.ts
@@ -497,14 +497,20 @@ function readSessionEvent(
const usage = tokenUsage(payload["info"]["total_token_usage"]);
if (usage !== null) session.inheritedUsage = usage;
}
- if (
- payload["type"] === "task_started" &&
- typeof payload["started_at"] === "number" &&
- session.startedAt !== null &&
- payload["started_at"] >= Math.floor(session.startedAt / 1_000)
- ) {
- session.replaying = false;
- session.events?.push(event);
+ if (payload["type"] === "task_started") {
+ // Fresh Codex worker thread/turn IDs share a same-process monotonic UUIDv7 generator.
+ const threadOrder = uuid7Order(session.threadId);
+ const turnOrder = uuid7Order(payload["turn_id"]);
+ const owned =
+ threadOrder === null
+ ? typeof payload["started_at"] === "number" &&
+ session.startedAt !== null &&
+ payload["started_at"] >= Math.floor(session.startedAt / 1_000)
+ : turnOrder !== null && turnOrder >= threadOrder;
+ if (owned) {
+ session.replaying = false;
+ session.events?.push(event);
+ }
}
return;
}
@@ -649,6 +655,18 @@ function readSessionEvent(
if (ownUsage !== null) session.usage = ownUsage;
}
+function uuid7Order(value: unknown): bigint | null {
+ if (
+ typeof value !== "string" ||
+ !/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(
+ value,
+ )
+ ) {
+ return null;
+ }
+ return BigInt(`0x${value.replaceAll("-", "")}`);
+}
+
function readSessionReasoning(
event: Readonly<Record<string, unknown>>,
payload: Readonly<Record<string, unknown>>,
diff --git a/sdk/typescript/src/version.ts b/sdk/typescript/src/version.ts
index 51643cf9b..2d16eab8d 100644
--- a/sdk/typescript/src/version.ts
+++ b/sdk/typescript/src/version.ts
@@ -9,7 +9,7 @@ const PACKAGE_VERSIONS = packageVersions(
export const VERSION = PACKAGE_VERSIONS.package;
export const CODEX_SDK_VERSION = PACKAGE_VERSIONS.sdk;
export const CODEX_EXECUTABLE_VERSION = PACKAGE_VERSIONS.executable;
-export const BUNDLED_PLUGIN_VERSION = "0.1.94" as const;
+export const BUNDLED_PLUGIN_VERSION = "0.1.95" as const;
const PACKAGE_NAME = "@openai/codex-security";
diff --git a/sdk/typescript/tests-ts/cost.test.ts b/sdk/typescript/tests-ts/cost.test.ts
index 81628dc68..c04c6fa07 100644
--- a/sdk/typescript/tests-ts/cost.test.ts
+++ b/sdk/typescript/tests-ts/cost.test.ts
@@ -19,6 +19,17 @@ import type { ScanActivity } from "../src/scan-activity.js";
import { readScanLogs } from "../src/scan-logs.js";
import { sessionParentThreadId } from "../src/scan-sessions.js";
import type { ScanProgress } from "../src/worker-progress.js";
+import { PLUGIN_ROOT as BUNDLED_PLUGIN_ROOT } from "./plugin-root.js";
+import {
+ childUuid7Thread,
+ higherUuid7Turn,
+ lowerUuid7Turn,
+ ownedPythonUsage,
+ ownedSdkUsage,
+ ownershipRollout,
+ readPythonRolloutUsage,
+ scanThreadId,
+} from "./support/usage-rollout.js";
const temporaryDirectories: string[] = [];
const parentFields = ["source", "parent_thread_id", "forked_from_id"] as const;
@@ -1107,6 +1118,65 @@ describe("live scan cost tracking", () => {
},
);
+ test.each([
+ [
+ "keeps a same-millisecond lower UUIDv7 turn in inherited history",
+ [lowerUuid7Turn],
+ ],
+ ["accepts a same-millisecond higher UUIDv7 turn as child-owned", []],
+ ] as const)("%s", async (_name, replayedTurnIds) => {
+ const home = await codexHome();
+ const rolloutPath = await writeSession(
+ home,
+ childUuid7Thread,
+ { input_tokens: 1_100, output_tokens: 110 },
+ scanThreadId,
+ );
+ const rollout = ownershipRollout(replayedTurnIds);
+ await writeFile(
+ rolloutPath,
+ rollout.map((event) => JSON.stringify(event)).join("\n") + "\n",
+ );
+
+ const maxCostUsd = 0.001;
+ const observedCosts: number[] = [];
+ const forwardedEvents: ScanSessionEvent[] = [];
+ const tracker = new ScanCostTracker({
+ codexHome: home,
+ model: "gpt-5.6-sol",
+ maxCostUsd,
+ onCost: ({ estimatedUsd }) => observedCosts.push(estimatedUsd),
+ onSessionEvent: (event) => forwardedEvents.push(event),
+ });
+ tracker.start(scanThreadId);
+ const tracked = await tracker.stop();
+ const python = readPythonRolloutUsage(BUNDLED_PLUGIN_ROOT, rolloutPath);
+
+ expect({
+ trackedUsage: tracked.usage,
+ estimatedUsd: tracked.cost?.estimatedUsd,
+ python,
+ }).toEqual({
+ trackedUsage: ownedSdkUsage,
+ estimatedUsd: 0.0008,
+ python: {
+ usage: ownedPythonUsage,
+ warnings: [],
+ },
+ });
+ expect(observedCosts.length).toBeGreaterThan(0);
+ expect(observedCosts.every((cost) => cost < maxCostUsd)).toBe(true);
+ const forwardedTurnIds = forwardedEvents.flatMap(({ event }) => {
+ const payload = event["payload"];
+ return typeof payload === "object" &&
+ payload !== null &&
+ (payload as Record<string, unknown>)["type"] === "task_started"
+ ? [(payload as Record<string, unknown>)["turn_id"]]
+ : [];
+ });
+ expect(forwardedTurnIds).toEqual([higherUuid7Turn]);
+ });
+
test("forwards actions from this scan's delegated workers only", async () => {
const home = await codexHome();
const usage = { input_tokens: 100, output_tokens: 10 };
diff --git a/sdk/typescript/tests-ts/runtime.test.ts b/sdk/typescript/tests-ts/runtime.test.ts
index d090bc1d2..8c418e39c 100644
--- a/sdk/typescript/tests-ts/runtime.test.ts
+++ b/sdk/typescript/tests-ts/runtime.test.ts
@@ -86,6 +86,12 @@ import {
} from "../src/runtime.js";
import { loadBundledRuntime, PLUGIN_ROOT } from "./plugin-root.js";
import { runTestInSubprocess } from "./support/test-subprocess.js";
+import {
+ lowerUuid7Turn,
+ ownedPythonUsage,
+ ownershipRollout,
+ readPythonRolloutUsage,
+} from "./support/usage-rollout.js";
const temporaryDirectories: string[] = [];
const testPosix = process.platform === "win32" ? test.skip : test;
@@ -1969,6 +1975,7 @@ describe("plugin runtime preparation", () => {
"0.1.79",
"0.1.92",
"0.1.93",
+ "0.1.94",
])(
"upgrades a cached %s plugin and restores with the SDK-owned helper",
async (previousVersion) => {
@@ -1986,6 +1993,10 @@ describe("plugin runtime preparation", () => {
join(PLUGIN_ROOT, "scripts", "workbench_target.py"),
join(previous, "scripts", "workbench_target.py"),
);
+ await writeFile(
+ join(previous, "scripts", "workbench_scan_usage.py"),
+ "raise RuntimeError('stale collector must be replaced')\n",
+ );
const home = join(root, "home");
const unrelatedProject = join(root, "unrelated-project");
await mkdir(home, { mode: 0o700 });
@@ -2030,6 +2041,7 @@ describe("plugin runtime preparation", () => {
"workbench_target.py",
"finalize_scan_contract.py",
"workbench_scan_history.py",
+ "workbench_scan_usage.py",
]) {
expect(await readFile(join(pluginRoot, "scripts", script))).toEqual(
await readFile(join(PLUGIN_ROOT, "scripts", script)),
@@ -2082,6 +2094,20 @@ describe("plugin runtime preparation", () => {
await writeFile(join(scanDir, artifact), Buffer.from([9, 0, 8]));
await restorer.restore(artifact, expected);
expect(await readFile(join(scanDir, artifact))).toEqual(expected);
+
+ const rolloutPath = join(root, "cached-rollout.jsonl");
+ await writeFile(
+ rolloutPath,
+ ownershipRollout([lowerUuid7Turn])
+ .map((event) => JSON.stringify(event))
+ .join("\n") + "\n",
+ );
+ expect(
+ readPythonRolloutUsage(upgraded.installedRoot, rolloutPath),
+ ).toEqual({
+ usage: ownedPythonUsage,
+ warnings: [],
+ });
},
);
diff --git a/sdk/typescript/tests-ts/support/usage-rollout.ts b/sdk/typescript/tests-ts/support/usage-rollout.ts
new file mode 100644
index 000000000..6b53157de
--- /dev/null
+++ b/sdk/typescript/tests-ts/support/usage-rollout.ts
@@ -0,0 +1,127 @@
+import { spawnSync } from "node:child_process";
+import { join } from "node:path";
+import { expect } from "bun:test";
+
+export const scanThreadId = "scan-thread";
+export const lowerUuid7Turn = "019f9e4d-b3ba-7000-8000-000000000001";
+export const childUuid7Thread = "019f9e4d-b3ba-7000-8000-000000000002";
+export const higherUuid7Turn = "019f9e4d-b3ba-7000-8000-000000000003";
+const uuid7EventTimestamp = "2026-07-26T12:02:00.250Z";
+export const ownedSdkUsage = {
+ input_tokens: 100,
+ cached_input_tokens: 0,
+ cache_write_input_tokens: 0,
+ output_tokens: 10,
+ reasoning_output_tokens: 0,
+ total_tokens: 110,
+};
+export const ownedPythonUsage = {
+ inputTokens: 100,
+ cachedInputTokens: 0,
+ cacheWriteInputTokens: 0,
+ outputTokens: 10,
+ reasoningOutputTokens: 0,
+ totalTokens: 110,
+};
+
+function uuid7TaskStarted(turnId: string): Record<string, unknown> {
+ return {
+ type: "event_msg",
+ timestamp: uuid7EventTimestamp,
+ payload: {
+ type: "task_started",
+ turn_id: turnId,
+ started_at: 1_785_067_320,
+ },
+ };
+}
+
+function uuid7TokenSnapshot(
+ inputTokens: number,
+ outputTokens: number,
+): Record<string, unknown> {
+ return {
+ type: "event_msg",
+ timestamp: uuid7EventTimestamp,
+ payload: {
+ type: "token_count",
+ info: {
+ total_token_usage: {
+ ...ownedSdkUsage,
+ input_tokens: inputTokens,
+ output_tokens: outputTokens,
+ total_tokens: inputTokens + outputTokens,
+ },
+ },
+ },
+ };
+}
+
+export function ownershipRollout(
+ replayedTurnIds: readonly string[],
+): Record<string, unknown>[] {
+ return [
+ {
+ type: "session_meta",
+ payload: {
+ id: childUuid7Thread,
+ timestamp: uuid7EventTimestamp,
+ source: {
+ subagent: { thread_spawn: { parent_thread_id: scanThreadId } },
+ },
+ },
+ },
+ {
+ type: "session_meta",
+ payload: {
+ id: scanThreadId,
+ timestamp: "2026-07-26T12:00:00.000Z",
+ source: "exec",
+ },
+ },
+ ...replayedTurnIds.map(uuid7TaskStarted),
+ uuid7TokenSnapshot(1_000, 100),
+ uuid7TaskStarted(higherUuid7Turn),
+ uuid7TokenSnapshot(1_100, 110),
+ ];
+}
+
+export function readPythonRolloutUsage(
+ pluginRoot: string,
+ rolloutPath: string,
+): unknown {
+ const python = Bun.which("python3") ?? Bun.which("python");
+ expect(python).not.toBeNull();
+ const probe = [
+ "import json, sys",
+ "from datetime import datetime, timezone",
+ "from pathlib import Path",
+ "sys.path.insert(0, sys.argv[1])",
+ "import workbench_scan_usage",
+ "session = workbench_scan_usage.RolloutSession(sys.argv[3], sys.argv[4], Path(sys.argv[2]))",
+ "usage, warnings = workbench_scan_usage._read_rollout_usage(",
+ " session,",
+ " started_at=datetime(2026, 7, 26, 12, tzinfo=timezone.utc),",
+ " completed_at=None,",
+ ")",
+ "print(json.dumps({'usage': usage, 'warnings': sorted(warnings)}, sort_keys=True))",
+ ].join("\n");
+ const result = spawnSync(
+ python!,
+ [
+ "-I",
+ "-B",
+ "-c",
+ probe,
+ join(pluginRoot, "scripts"),
+ rolloutPath,
+ childUuid7Thread,
+ scanThreadId,
+ ],
+ { encoding: "utf8" },
+ );
+
+ expect(result.error).toBeUndefined();
+ expect(result.status, result.stderr).toBe(0);
+ return JSON.parse(result.stdout) as unknown;
+}