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
refactor(schemas): define compact artifact contracts in Zod (#1575)
Michael D'Angelo65c46ead931d
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.mdindex 50ac46466..7ec16ce32 100644--- a/CONTRIBUTING.md+++ b/CONTRIBUTING.md@@ -15,6 +15,13 @@ packages and releases. Do not edit or commit files in that directory. See the[SDK testing guide](sdk/typescript/TESTING.md) for the generation and validationcommands.+Compact artifact contracts are authored in `plugins/codex-security/mcp-app/src/artifact-contracts.ts`,+with shared finding and threat-model definitions in `finding-detail-schemas.ts` and+`threat-model-schema.ts`. The JSON files under `schemas/definitions` and `schemas/tools`+are generated compatibility resources for JSON consumers. After editing the contracts,+run `node plugins/codex-security/mcp-app/scripts/generate-artifact-schemas.mjs`.+The MCP `typecheck` command checks that the generated resources are current.+`pnpm --dir sdk/typescript run generate:models` also copies shared findingnormalization from the plugin source into the SDK. Edit the plugin helper, thenregenerate its SDK copy. `pnpm --dir sdk/typescript run types` checks freshness.diff --git a/plugins/codex-security/mcp-app/package.json b/plugins/codex-security/mcp-app/package.jsonindex 0fd2a83e4..8fb80482f 100644--- a/plugins/codex-security/mcp-app/package.json+++ b/plugins/codex-security/mcp-app/package.json@@ -4,10 +4,10 @@"type": "module","private": true,"scripts": {- "build": "tsc --noEmit",+ "build": "node scripts/generate-artifact-schemas.mjs && tsc --noEmit","build:mcp": "node scripts/build_mcp_app.mjs --output .preview/mcp","test:mcp": "node --experimental-strip-types --test --test-concurrency=2 --test-reporter=./scripts/test_reporter.mts \"tests/test_*.ts\"",- "typecheck": "tsc --noEmit"+ "typecheck": "node scripts/generate-artifact-schemas.mjs --check && tsc --noEmit"},"dependencies": {"@modelcontextprotocol/sdk": "^1.32.1",diff --git a/plugins/codex-security/mcp-app/scripts/generate-artifact-schemas.mjs b/plugins/codex-security/mcp-app/scripts/generate-artifact-schemas.mjsnew file mode 100644index 000000000..35c8c3d47--- /dev/null+++ b/plugins/codex-security/mcp-app/scripts/generate-artifact-schemas.mjs@@ -0,0 +1,102 @@+import { randomUUID } from "node:crypto";+import { readFile, rename, rm, writeFile } from "node:fs/promises";+import { fileURLToPath } from "node:url";+import { build } from "esbuild";+import { format } from "prettier";+import * as z from "zod/v4";++const bundled = await build({+ stdin: {+ contents: `export * from "../src/artifact-contracts.ts";`,+ resolveDir: fileURLToPath(new URL(".", import.meta.url)),+ },+ bundle: true,+ platform: "node",+ format: "esm",+ write: false,+});+const { artifactSchemaDocuments, artifactJsonMetadata } = await import(+ `data:text/javascript;base64,${Buffer.from(bundled.outputFiles[0].contents).toString("base64")}`+);+const registry = z.registry();+const documentId = (path) => `codex-security://schemas/${path}.schema.json`;+for (const [path, { $defs }] of Object.entries(artifactSchemaDocuments)) {+ for (const [name, schema] of Object.entries($defs)) {+ if (!schema._zod || registry.has(schema)) continue;+ const id = `${documentId(path)}#/$defs/${name}`;+ registry.add(schema, { id });+ }+}+const artifactJsonOptions = {+ io: "input",+ override: ({ zodSchema, jsonSchema }) => {+ if (jsonSchema.const !== undefined || jsonSchema.enum)+ delete jsonSchema.type;+ Object.assign(jsonSchema, artifactJsonMetadata.get(zodSchema));+ if (JSON.stringify(jsonSchema.additionalProperties) === "{}")+ jsonSchema.additionalProperties = true;+ },+};+const { schemas } = z.toJSONSchema(registry, {+ ...artifactJsonOptions,+ uri: (id) => id,+});+function body({ $schema, $id, ...schema }) {+ return schema;+}+function definition(schema, id) {+ const registeredId = registry.get(schema)?.id;+ if (registeredId !== id) return { $ref: registeredId };+ return body(schemas[id] ?? z.toJSONSchema(schema, artifactJsonOptions));+}+for (const [path, { $defs, ...header }] of Object.entries(+ artifactSchemaDocuments,+)) {+ const id = documentId(path);+ const definitions = Object.fromEntries(+ Object.entries($defs).map(([name, schema]) => [+ name,+ schema._zod+ ? definition(schema, `${id}#/$defs/${name}`)+ : // attackPathFields is a field map retained for existing JSON pointers.+ Object.fromEntries(+ Object.entries(schema).map(([field, value]) => [+ field,+ definition(value),+ ]),+ ),+ ]),+ );+ await save(+ path,+ {+ $schema: "https://json-schema.org/draft/2020-12/schema",+ $id: id,+ ...header,+ $defs: definitions,+ },+ (_key, schema) =>+ JSON.stringify(schema) === '{"not":{}}' ? false : schema,+ );+}+async function save(path, schema, replacer) {+ const contents = await format(JSON.stringify(schema, replacer), {+ parser: "json",+ });+ const output = new URL(`../../schemas/${path}.schema.json`, import.meta.url);+ if (process.argv.includes("--check")) {+ if ((await readFile(output, "utf8")).replaceAll("\r\n", "\n") !== contents)+ throw new Error(+ `Artifact schema ${path} is out of date. Run node scripts/generate-artifact-schemas.mjs from mcp-app.`,+ );+ } else {+ // Concurrent runtime builds must always read a complete schema document.+ const temporary = `${fileURLToPath(output)}.${randomUUID()}.tmp`;+ try {+ await writeFile(temporary, contents);+ await rename(temporary, output);+ } finally {+ await rm(temporary, { force: true });+ }+ }+}diff --git a/plugins/codex-security/mcp-app/src/artifact-candidate-ledger.ts b/plugins/codex-security/mcp-app/src/artifact-candidate-ledger.tsindex e811f7797..215d39931 100644--- a/plugins/codex-security/mcp-app/src/artifact-candidate-ledger.ts+++ b/plugins/codex-security/mcp-app/src/artifact-candidate-ledger.ts@@ -1,8 +1,5 @@import { asRecord } from "./record.js";import type * as z from "zod/v4";-import commonSchema from "../../schemas/definitions/artifact-common.schema.json";-import validationSchema from "../../schemas/tools/candidate-validations.schema.json";-import attackPathSchema from "../../schemas/tools/candidate-attack-paths.schema.json";import { candidateSchemaV1 } from "./deep-scan/artifact-contracts.js";import {artifactDestination,@@ -10,48 +7,18 @@ import {replaceArtifactJsonl,type ArtifactContext,} from "./artifact-io.js";-import {- loadArtifactZodSchema,- type SchemaDocument,-} from "./artifact-schema-loader.js";--const documents = [- commonSchema,- validationSchema,- attackPathSchema,-] as SchemaDocument[];--export interface CandidateValidationRecord {- disposition: "reportable" | "suppressed" | "not_applicable" | "deferred";- method: string;- confidence: "high" | "medium" | "low";- confidence_rationale: string;- rubric:- string | Record<string, unknown> | Array<string | Record<string, unknown>>;- evidence: string | string[];- counterevidence_or_proof_gap: string;- remaining_uncertainty: string;- artifact_paths?: string[];- source?: string;- control?: string;- sink?: string;- preconditions?: string | string[];- [field: string]: unknown;-}--interface CandidateValidationUpdates {- validations: {- candidateId: string;- validation: CandidateValidationRecord;- }[];-}--/** Public workbench input; the bound context, never the caller, selects the artifact. */-export const candidateValidationsInputSchema = loadArtifactZodSchema(- documents,- validationSchema.$id,- "input",-) as z.ZodType<CandidateValidationUpdates & { scanId: string }>;+import { artifactSchemaDocuments } from "./artifact-contracts.js";++const validationDefinitions =+ artifactSchemaDocuments["tools/candidate-validations"].$defs;+export const candidateValidationsInputSchema = validationDefinitions.input;+export type CandidateValidationRecord = z.infer<+ typeof validationDefinitions.validationRecord+>;+type CandidateValidationUpdates = Pick<+ z.infer<typeof candidateValidationsInputSchema>,+ "validations"+>;/** Complete one existing validation phase without changing discovery or attack-path data. */export async function recordCodexSecurityCandidateValidations(@@ -109,41 +76,16 @@ export async function recordCodexSecurityCandidateValidations(};}-type ImpactLevel = "high" | "medium" | "low" | "ignore" | "unknown";-type ReportableSeverity = "critical" | "high" | "medium" | "low";--export type CandidateAttackPathRecord = {- dataflow: string;- reachability: string;- counterevidence: string;- impact: ImpactLevel;- likelihood: ImpactLevel;- severity_rationale: string;- change_conditions: string;- [field: string]: unknown;-} & (- | { decision: "reportable"; severity: ReportableSeverity }- | { decision: "ignore"; severity: "ignore" }- | {- decision: "deferred";- severity: ReportableSeverity | "unknown";- proof_gap: string;- }-);--interface CandidateAttackPathsPayload {- attackPaths: {- candidateId: string;- attackPath: CandidateAttackPathRecord;- }[];-}--/** The checked-in public schema controls both tools/list and call validation. */-export const candidateAttackPathsInputSchema = loadArtifactZodSchema(- documents,- attackPathSchema.$id,- "input",-) as z.ZodType<CandidateAttackPathsPayload & { scanId: string }>;+const attackPathDefinitions =+ artifactSchemaDocuments["tools/candidate-attack-paths"].$defs;+export const candidateAttackPathsInputSchema = attackPathDefinitions.input;+export type CandidateAttackPathRecord = z.infer<+ typeof attackPathDefinitions.attackPath+>;+type CandidateAttackPathsPayload = Pick<+ z.infer<typeof candidateAttackPathsInputSchema>,+ "attackPaths"+>;/** Add attack-path judgments to eligible canonical Deep candidate rows. */export async function recordCodexSecurityCandidateAttackPaths(diff --git a/plugins/codex-security/mcp-app/src/artifact-contracts.ts b/plugins/codex-security/mcp-app/src/artifact-contracts.tsnew file mode 100644index 000000000..1c2638165--- /dev/null+++ b/plugins/codex-security/mcp-app/src/artifact-contracts.ts@@ -0,0 +1,529 @@+import { threatModelSchemas } from "./threat-model-schema.ts";+import { discoveryLocationRoles } from "./discovery-location-roles.js";+import * as z from "zod/v4";+import { findingDetailSchemas } from "./finding-detail-schemas.ts";++// JSON consumers historically apply formats and integer bounds differently from+// live tools. Keep compatibility-export metadata separate from tools/list.+export const artifactJsonMetadata = z.registry<Record<string, unknown>>();+function integer(minimum: number, maximum?: number) {+ const schema = z.number().int().min(minimum);+ return (maximum === undefined ? schema : schema.max(maximum)).register(+ artifactJsonMetadata,+ { maximum },+ );+}++function pattern(schema: z.ZodString, source: string) {+ return schema.regex(new RegExp(source)).register(artifactJsonMetadata, {+ pattern: source,+ });+}++const nonEmptyText = z.string().min(1).regex(/\S/);++const scanId = z+ .string()+ .check(z.uuid())+ .register(artifactJsonMetadata, { pattern: undefined });++const repositoryPath = pattern(+ z.string().min(1).max(4096),+ "^(?:\\./)?(?!/)(?![A-Za-z]:)(?!.*\\\\)(?!.*(?:^|/)\\.\\.?(/|$))(?!.*//)(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$",+);++const candidateId = z+ .string()+ .min(1)+ .max(512)+ .regex(+ new RegExp(+ "^(?!\\.{1,2}$)(?!.*[\\u0000-\\u001f\\u007f])(?=.*\\S)[^/\\\\]+$",+ ),+ );++const page = z.strictObject({+ cursor: z.string().regex(new RegExp("^(?:0|[1-9][0-9]*)$")).optional(),+ limit: integer(1, 1000).optional(),+});++const nonEmptyTextWithoutMinimum = z.string().regex(new RegExp("\\S"));++const cweId = z+ .string()+ .regex(new RegExp("^\\s*[Cc][Ww][Ee]-0*[1-9][0-9]*\\s*$"));++const locationRole = z.enum(discoveryLocationRoles);++const rawDiscoveryLocation = z.strictObject({+ path: nonEmptyTextWithoutMinimum,+ start_line: integer(1),+ end_line: integer(1).optional(),+ role: locationRole,+});++const normalizedDiscoveryLocation = rawDiscoveryLocation.extend({+ end_line: integer(1),+});++const rawDiscoveryCandidate = z.strictObject({+ cwe_ids: z.array(cweId),+ locations: z.array(rawDiscoveryLocation).min(1),+ summary: nonEmptyTextWithoutMinimum,+ evidence: nonEmptyTextWithoutMinimum,+ context: nonEmptyTextWithoutMinimum.optional(),+ instance: nonEmptyTextWithoutMinimum.optional(),+});++const discoveryCandidate = z.looseObject({+ candidate_id: z.string().regex(new RegExp("^(?!\\.{1,2}$)[^/\\\\]+$")),+ ...rawDiscoveryCandidate.shape,+ cwe_ids: z.array(z.string().regex(new RegExp("^CWE-[1-9][0-9]*$"))),+ locations: z.array(normalizedDiscoveryLocation).min(1),+});++const recordDiscoveryCandidatesInput = z.strictObject({+ candidates: z.array(rawDiscoveryCandidate),+});++const attackPath_attackPathFields = {+ dataflow: nonEmptyText,+ reachability: nonEmptyText,+ counterevidence: nonEmptyText,+ impact: z.enum(["high", "medium", "low", "ignore", "unknown"]),+ likelihood: z.enum(["high", "medium", "low", "ignore", "unknown"]),+ severity_rationale: nonEmptyText,+ change_conditions: nonEmptyText,+};+const { severity_rationale, change_conditions, ...attackPathEvidence } =+ attackPath_attackPathFields;++const attackPath_reportableAttackPath = z.looseObject({+ decision: z.literal("reportable"),+ ...attackPathEvidence,+ severity: z.enum(["critical", "high", "medium", "low"]),+ severity_rationale,+ change_conditions,+});+const attackPath_ignoredAttackPath = attackPath_reportableAttackPath.extend({+ decision: z.literal("ignore"),+ severity: z.literal("ignore"),+});+const attackPath_deferredAttackPath = attackPath_reportableAttackPath.extend({+ decision: z.literal("deferred"),+ severity: z.enum(["critical", "high", "medium", "low", "unknown"]),+ proof_gap: nonEmptyText,+});++const attackPath_attackPath = z.xor([+ attackPath_reportableAttackPath,+ attackPath_ignoredAttackPath,+ attackPath_deferredAttackPath,+]);++const attackPath_attackPathUpdate = z.strictObject({+ candidateId: candidateId,+ attackPath: attackPath_attackPath,+});++const validation_validationRecord = z.looseObject({+ disposition: z+ .enum(["reportable", "suppressed", "not_applicable", "deferred"])+ .register(artifactJsonMetadata, { type: "string" }),+ method: nonEmptyText,+ confidence: z+ .enum(["high", "medium", "low"])+ .register(artifactJsonMetadata, { type: "string" }),+ confidence_rationale: nonEmptyText,+ rubric: z.union([+ nonEmptyText,+ z.looseObject({}),+ z.array(z.union([nonEmptyText, z.looseObject({})])).min(1),+ ]),+ evidence: z.union([nonEmptyText, z.array(nonEmptyText).min(1)]),+ counterevidence_or_proof_gap: z.string(),+ remaining_uncertainty: z.string(),+ artifact_paths: z.array(nonEmptyText).optional(),+ source: nonEmptyText.optional(),+ control: nonEmptyText.optional(),+ sink: nonEmptyText.optional(),+ preconditions: z+ .union([nonEmptyText, z.array(nonEmptyText).min(1)])+ .optional(),+});++const validation_validationUpdate = z.strictObject({+ candidateId: candidateId,+ validation: validation_validationRecord,+});++const prepareInput = z.strictObject({+ scanId: scanId,+ handoffClaimToken: nonEmptyText.optional(),+});++const reviewItem = z.strictObject({+ path: repositoryPath,+});++const {+ textList: draft_textList,+ slug,+ identity: draft_identity,+ severity: draft_severity,+ confidence: draft_confidence,+ location: draft_location,+ codeEvidence,+ legacyCodeEvidence: draft_legacyCodeEvidence,+ findingAssessment: draft_findingAssessment,+ textOrSummary: draft_textOrSummary,+ findingReachability: draft_findingReachability,+ findingValidation: draft_findingValidation,+ findingAttackPath: draft_findingAttackPath,+} = findingDetailSchemas(nonEmptyText, repositoryPath, integer(1));++const draft_handoffClaimToken = z+ .string()+ .regex(+ new RegExp(+ "^(?:[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}|recovery_[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$",+ ),+ );++const draft_taxonomy = z.looseObject({+ category: nonEmptyText.describe(+ "The actual primary broken security control, not a CWE identifier.",+ ),+ cwe: draft_textList.describe(+ "Copy the reviewed candidate's exact cwe_ids array. Use an empty array when no CWE is established; do not invent one.",+ ),+});++const draft_codeEvidence = codeEvidence.extend({+ code: nonEmptyText.describe(+ "The genuine, nonempty source snippet at this evidence location.",+ ),+});++// Zod applies uniqueItems to raw input before parsing each item.+const uniqueArray = z.fromJSONSchema({ type: "array", uniqueItems: true });++const draft_finding = z.looseObject({+ findingId: z.never().optional(),+ occurrenceId: z.never().optional(),+ fingerprints: z.never().optional(),+ ruleId: slug.describe(+ "A stable lowercase vulnerability-family slug, such as prototype-pollution.json-patch; a CWE is taxonomy, not a rule ID.",+ ),+ identity: draft_identity.optional(),+ title: nonEmptyText,+ summary: nonEmptyText,+ severity: draft_severity,+ confidence: draft_confidence,+ taxonomy: draft_taxonomy,+ locations: z.array(draft_location).min(1),+ writeup: z+ .looseObject({+ reportPath: pattern(+ z.string(),+ "^findings/([a-z0-9][a-z0-9._-]*)/\\1\\.md$",+ ),+ })+ .optional(),+ codeEvidence: z.array(draft_codeEvidence).optional(),+ code_evidence: z.array(draft_legacyCodeEvidence).optional(),+ rootCause: z+ .union([+ nonEmptyText,+ z.looseObject({+ summary: nonEmptyText,+ code: nonEmptyText.optional(),+ language: nonEmptyText.optional(),+ evidenceRefs: draft_textList.optional(),+ }),+ ])+ .optional(),+ root_cause: z+ .union([+ nonEmptyText,+ z.looseObject({+ summary: nonEmptyText.optional(),+ code: nonEmptyText.optional(),+ language: nonEmptyText.optional(),+ evidenceRefs: draft_textList.optional(),+ evidence_refs: draft_textList.optional(),+ }),+ ])+ .optional(),+ remediation: nonEmptyText,+ validation: z.union([draft_findingValidation, z.null()]).optional(),+ attackPath: z.union([draft_findingAttackPath, z.null()]).optional(),+ remediationTests: draft_textList.optional(),+ preventiveControls: draft_textList.optional(),+ provenance: z.looseObject({+ sourceFindingIds: z+ .transform((value, context) => {+ const result = uniqueArray.safeParse(value);+ if (!result.success)+ for (const issue of result.error.issues)+ context.addIssue({ ...issue });+ return value;+ })+ .pipe(+ z+ .array(nonEmptyText)+ .meta({ uniqueItems: true })+ .describe(+ "Host-provided source finding references represented by this Deep reduction. Preserve every assigned reference exactly once.",+ ),+ )+ .optional(),+ sourceFindings: z+ .array(z.strictObject({ id: nonEmptyText, finding: z.looseObject({}) }))+ .describe(+ "Original source payloads retained by the host for lossless semantic merges.",+ )+ .optional(),+ source: nonEmptyText.describe(+ "The actual finding producer. Use local_plugin only for a finding discovered by this plugin.",+ ),+ }),+ extensions: z.looseObject({}).optional(),+});++const draft_scope = z.looseObject({+ includePaths: z.never().optional(),+ excludePaths: z.never().optional(),+ summary: nonEmptyText.optional(),+ artifactsReviewed: draft_textList.optional(),+ runtimeStatus: nonEmptyText.optional(),+ validationMode: nonEmptyText.optional(),+ context: nonEmptyText.optional(),+ limitations: draft_textList.optional(),+});++const { schema: draft_threatModel } = threatModelSchemas(draft_textList);++export const surfaceDispositionSchema = z.enum([+ "reported",+ "no_issue_found",+ "rejected",+ "not_applicable",+ "needs_follow_up",+]);++const draft_surface = z.looseObject({+ id: z.string().regex(new RegExp("^[a-z0-9][a-z0-9._/-]*$")).optional(),+ label: nonEmptyText.describe(+ "The meaningful name of the reviewed security surface.",+ ),+ disposition: surfaceDispositionSchema.describe(+ "The evidence-supported review result for this surface.",+ ),+ receiptRefs: z+ .array(+ pattern(+ z.string().min(1),+ "^(?!.*(?:^|/)\\.\\.(?:/|$))(?!.*\\\\)artifacts/.+$",+ ),+ )+ .optional(),+ riskArea: nonEmptyText.optional(),+ notes: nonEmptyText.optional(),+});++const draft_coverage = z.looseObject({+ documentType: z.never().optional(),+ schemaVersion: z.never().optional(),+ scanId: z.never().optional(),+ mode: z.never().optional(),+ includePaths: z.never().optional(),+ excludePaths: z.never().optional(),+ receiptRefs: z.never().optional(),+ completeness: z+ .enum(["complete", "partial", "unknown"])+ .describe(+ "Use partial if any work is deferred or any surface needs follow-up; use complete only when no such work remains.",+ ),+ inventoryStrategy: z.never().optional(),+ surfaces: z.array(draft_surface),+ explicitExclusions: z.array(+ z.looseObject({ pattern: nonEmptyText, reason: nonEmptyText }),+ ),+ deferred: z+ .array(+ z.looseObject({+ id: nonEmptyText.optional(),+ candidateId: candidateId.optional(),+ reason: nonEmptyText,+ paths: draft_textList.optional(),+ surfaceIds: draft_textList.optional(),+ }),+ )+ .describe(+ "Each supplied id identifies one task and must be unique within this draft. Reuse saved IDs in later updates.",+ ),+ resolvedDeferred: z+ .array(z.strictObject({ id: nonEmptyText, reason: nonEmptyText }))+ .describe(+ "On final Standard or diff drafts, close generic tasks by saved ID and completion reason. Reuse saved surface IDs for updates. Candidate tasks need findings or dispositions; redundant closure entries for those outcomes are ignored.",+ )+ .optional(),+ openQuestions: z+ .array(+ z.union([+ nonEmptyText,+ z.looseObject({+ question: nonEmptyText,+ followUpPrompt: nonEmptyText.optional(),+ }),+ ]),+ )+ .optional(),+});++const draft_scanDraftInput = z.strictObject({+ complete: z+ .boolean()+ .describe(+ "Set false to save progress without declaring this worker or parent audit finished. Omit or set true only for the terminal result. Put provisional candidates in coverage.deferred, not findings.",+ )+ .optional(),+ scanId: scanId,+ handoffClaimToken: draft_handoffClaimToken.optional(),+ scope: draft_scope.optional(),+ threatModel: draft_threatModel.optional(),+ findings: z.array(draft_finding),+ coverage: draft_coverage,+});++/** Native tool contracts; JSON resources are generated compatibility exports. */+export const artifactSchemaDocuments = {+ "definitions/artifact-common": {+ $defs: {+ nonEmptyText: nonEmptyText,+ scanId: scanId,+ repositoryPath: repositoryPath,+ candidateId: candidateId,+ },+ },+ "definitions/discovery-candidate": {+ $defs: {+ nonEmptyText: nonEmptyTextWithoutMinimum,+ cweId: cweId,+ locationRole: locationRole,+ rawDiscoveryLocation: rawDiscoveryLocation,+ normalizedDiscoveryLocation: normalizedDiscoveryLocation,+ rawDiscoveryCandidate: rawDiscoveryCandidate,+ discoveryCandidate: discoveryCandidate,+ },+ },+ "tools/discovery-candidates": {+ $defs: {+ workbenchRecordDiscoveryCandidatesInput: z.strictObject({+ scanId: nonEmptyTextWithoutMinimum,+ ...recordDiscoveryCandidatesInput.shape,+ }),+ workbenchListCandidatesInput: z.strictObject({+ scanId: nonEmptyTextWithoutMinimum,+ ...page.shape,+ }),+ },+ },+ "tools/candidate-attack-paths": {+ title: "Record Codex Security candidate attack paths",+ $ref: "#/$defs/input",+ $defs: {+ input: z.strictObject({+ scanId: scanId,+ attackPaths: z.array(attackPath_attackPathUpdate),+ }),+ attackPathUpdate: attackPath_attackPathUpdate,+ attackPath: attackPath_attackPath,+ attackPathFields: attackPath_attackPathFields,+ reportableAttackPath: attackPath_reportableAttackPath,+ ignoredAttackPath: attackPath_ignoredAttackPath,+ deferredAttackPath: attackPath_deferredAttackPath,+ },+ },+ "tools/candidate-validations": {+ title: "Record compact Codex Security candidate validations",+ $ref: "#/$defs/input",+ $defs: {+ input: z.strictObject({+ scanId: scanId,+ validations: z.array(validation_validationUpdate),+ }),+ validationUpdate: validation_validationUpdate,+ validationRecord: validation_validationRecord,+ },+ },+ "tools/review-items": {+ $defs: {+ prepareInput: prepareInput,+ reviewItemsInput: prepareInput.extend(page.shape),+ reviewItem: reviewItem,+ },+ },+ "tools/scan-draft": {+ title: "Codex Security semantic scan draft",+ $ref: "#/$defs/scanDraftInput",+ $defs: {+ text: nonEmptyText,+ textList: draft_textList,+ scanId: scanId,+ handoffClaimToken: draft_handoffClaimToken,+ repositoryPath: repositoryPath,+ location: draft_location,+ identity: draft_identity,+ severity: draft_severity,+ confidence: draft_confidence,+ taxonomy: draft_taxonomy,+ codeEvidence: draft_codeEvidence,+ legacyCodeEvidence: draft_legacyCodeEvidence,+ findingAssessment: draft_findingAssessment,+ textOrSummary: draft_textOrSummary,+ findingReachability: draft_findingReachability,+ findingValidation: draft_findingValidation,+ findingAttackPath: draft_findingAttackPath,+ finding: draft_finding,+ scope: draft_scope,+ threatModel: draft_threatModel,+ surface: draft_surface,+ coverage: draft_coverage,+ scanDraftInput: draft_scanDraftInput,+ completedScanInput: z.strictObject({+ scanId: scanId,+ handoffClaimToken: draft_handoffClaimToken.optional(),+ }),+ },+ },+ "tools/deep-reducer": {+ title: "Codex Security Deep Scan semantic reducer operations",+ $ref: "#/$defs/reductionInput",+ $defs: {+ reducerInputs: z.strictObject({+ cursor: z+ .string()+ .regex(new RegExp("^(0|[1-9][0-9]*)$"))+ .describe("Continue the same document from its returned nextCursor.")+ .optional(),+ maxBytes: integer(1, 9007199254740991).describe(+ "Caller-selected byte budget for the serialized MCP response. Choose below the transport and output budgets; reduce it if transport reports an oversized response.",+ ),+ findingRef: z+ .string()+ .describe(+ "Omit to page assigned findings and the previous aggregate without retained provenance bodies. Use source:<sourceFindingId> to fetch a complete original, or previous:<zero-based index> to fetch a complete previous aggregate finding, including its retained history.",+ )+ .optional(),+ }),+ reductionInput: draft_scanDraftInput.omit({ coverage: true }).extend({+ complete: z+ .boolean()+ .describe("Omit or set true when submitting the finished aggregate.")+ .optional(),+ }),+ },+ },+};diff --git a/plugins/codex-security/mcp-app/src/artifact-deep-reducer-pages.ts b/plugins/codex-security/mcp-app/src/artifact-deep-reducer-pages.tsindex 66230d59b..2ae39ddce 100644--- a/plugins/codex-security/mcp-app/src/artifact-deep-reducer-pages.ts+++ b/plugins/codex-security/mcp-app/src/artifact-deep-reducer-pages.ts@@ -1,3 +1,4 @@+import type * as z from "zod/v4";import type { ArtifactContext } from "./artifact-context.js";import {deepReducerInputsInputSchema,@@ -8,11 +9,7 @@ import type {DeepReductionSources,} from "./deep-scan/artifact-validation.js";-export interface DeepReducerPageInput {- cursor?: string;- maxBytes: number;- findingRef?: string;-}+export type DeepReducerPageInput = z.infer<typeof deepReducerInputsInputSchema>;/** Concatenate every json fragment for one document before parsing it. */export interface DeepReducerPage {@@ -111,7 +108,7 @@ function projectFinding(finding: Finding, refs?: string[]): Finding {previousFindings: _previous,originalCandidates: _candidates,...provenance- } = finding.provenance as Record<string, unknown>;+ } = finding.provenance;return {...finding,provenance: {diff --git a/plugins/codex-security/mcp-app/src/artifact-deep-reducer.ts b/plugins/codex-security/mcp-app/src/artifact-deep-reducer.tsindex 5c30ae859..4735c6569 100644--- a/plugins/codex-security/mcp-app/src/artifact-deep-reducer.ts+++ b/plugins/codex-security/mcp-app/src/artifact-deep-reducer.ts@@ -1,18 +1,11 @@import { join } from "node:path";-import type { ZodType } from "zod/v4";-import commonSchema from "../../schemas/definitions/artifact-common.schema.json";-import reducerSchema from "../../schemas/tools/deep-reducer.schema.json";-import scanDraftSchema from "../../schemas/tools/scan-draft.schema.json";import type { ArtifactContext } from "./artifact-context.js";-import type { DeepReducerPageInput } from "./artifact-deep-reducer-pages.js";import {parsePersistedScanDraft,saveScanDraftCheckpoint,} from "./artifact-scan-draft.js";-import {- loadArtifactZodSchema,- type SchemaDocument,-} from "./artifact-schema-loader.js";+import { artifactSchemaDocuments } from "./artifact-contracts.js";+import { projectArtifactToolSchema } from "./artifact-schema-loader.js";import { saveThreatModelDocument } from "./threat-model-document.js";import {createDeepScanArtifacts,@@ -28,23 +21,11 @@ import {type DeepReductionSources,} from "./deep-scan/artifact-validation.js";-const schemaDocuments = [- commonSchema,- scanDraftSchema,- reducerSchema,-] as SchemaDocument[];--export const deepReducerInputsInputSchema = loadArtifactZodSchema(- schemaDocuments,- reducerSchema.$id,- "reducerInputs",-) as ZodType<DeepReducerPageInput>;--export const deepReductionInputSchema = loadArtifactZodSchema(- schemaDocuments,- reducerSchema.$id,- "reductionInput",-) as ZodType<DeepReductionInput>;+const reducerDefinitions = artifactSchemaDocuments["tools/deep-reducer"].$defs;+export const deepReducerInputsInputSchema = reducerDefinitions.reducerInputs;+export const deepReductionInputSchema = projectArtifactToolSchema(+ reducerDefinitions.reductionInput,+);/** Read the findings and scan context assigned to this reducer. */export async function getCodexSecurityDeepReducerInputs(diff --git a/plugins/codex-security/mcp-app/src/artifact-discovery.ts b/plugins/codex-security/mcp-app/src/artifact-discovery.tsindex 0d736551c..300f0e68c 100644--- a/plugins/codex-security/mcp-app/src/artifact-discovery.ts+++ b/plugins/codex-security/mcp-app/src/artifact-discovery.ts@@ -13,8 +13,6 @@ import {type normalizeCandidateBatch,} from "./helpers/normalize-candidates.js";import type * as z from "zod/v4";-import discoveryCandidateDefinitions from "../../schemas/definitions/discovery-candidate.schema.json";-import discoveryCandidatesToolSchema from "../../schemas/tools/discovery-candidates.schema.json";import type { ArtifactContext } from "./artifact-context.js";import {artifactDestination,@@ -24,70 +22,33 @@ import {artifactSourcePath,replaceArtifactText,} from "./artifact-io.js";-import {- loadArtifactZodSchema,- type SchemaDocument,-} from "./artifact-schema-loader.js";+import { artifactSchemaDocuments } from "./artifact-contracts.js";import { candidateSchemaV1 } from "./deep-scan/artifact-contracts.js";const discoveryComponents = ["artifacts", "02_discovery"] as const;const discoveryLabel = "discovery candidates";-const discoverySchemaDocuments = [- discoveryCandidateDefinitions,- discoveryCandidatesToolSchema,-] as SchemaDocument[];--export type RawDiscoveryLocationRole =- | "entrypoint"- | "entrypoint/wrapper"- | "source"- | "root_control"- | "sink"- | "concrete_implementation"- | "evidence";--export interface RawDiscoveryLocation {- path: string;- start_line: number;- end_line?: number;- role: RawDiscoveryLocationRole;-}--export interface RawDiscoveryCandidate {- cwe_ids: string[];- locations: RawDiscoveryLocation[];- summary: string;- evidence: string;- context?: string;- instance?: string;-}--export interface DiscoveryCandidatesInput {- candidates: RawDiscoveryCandidate[];-}--export type CompactDiscoveryCandidate = z.infer<typeof candidateSchemaV1> &- Record<string, unknown>;--/** Every exposed validator is derived from the checked-in JSON Schema source. */-export const compactDiscoveryCandidateSchema = loadArtifactZodSchema(- discoverySchemaDocuments,- discoveryCandidateDefinitions.$id,- "discoveryCandidate",-) as z.ZodType<CompactDiscoveryCandidate>;--export const workbenchDiscoveryCandidatesInputSchema = loadArtifactZodSchema(- discoverySchemaDocuments,- discoveryCandidatesToolSchema.$id,- "workbenchRecordDiscoveryCandidatesInput",-) as z.ZodType<DiscoveryCandidatesInput & { scanId: string }>;--export const workbenchListCodexSecurityCandidatesInputSchema =- loadArtifactZodSchema(- discoverySchemaDocuments,- discoveryCandidatesToolSchema.$id,- "workbenchListCandidatesInput",- ) as z.ZodType<ArtifactPage & { scanId: string }>;+const definitions =+ artifactSchemaDocuments["definitions/discovery-candidate"].$defs;+export type RawDiscoveryLocationRole = z.infer<typeof definitions.locationRole>;+export type RawDiscoveryLocation = z.infer<+ typeof definitions.rawDiscoveryLocation+>;+export type RawDiscoveryCandidate = z.infer<+ typeof definitions.rawDiscoveryCandidate+>;+export const compactDiscoveryCandidateSchema = definitions.discoveryCandidate;+export type CompactDiscoveryCandidate = z.infer<+ typeof compactDiscoveryCandidateSchema+>;+export const {+ workbenchRecordDiscoveryCandidatesInput:+ workbenchDiscoveryCandidatesInputSchema,+ workbenchListCandidatesInput: workbenchListCodexSecurityCandidatesInputSchema,+} = artifactSchemaDocuments["tools/discovery-candidates"].$defs;+export type DiscoveryCandidatesInput = Pick<+ z.infer<typeof workbenchDiscoveryCandidatesInputSchema>,+ "candidates"+>;/*** Normalize in memory and replace the bound canonical candidate ledger.diff --git a/plugins/codex-security/mcp-app/src/artifact-inventory.ts b/plugins/codex-security/mcp-app/src/artifact-inventory.tsindex 23d92a107..0ce3ac300 100644--- a/plugins/codex-security/mcp-app/src/artifact-inventory.ts+++ b/plugins/codex-security/mcp-app/src/artifact-inventory.ts@@ -3,8 +3,6 @@ import { readFile } from "node:fs/promises";import { join } from "node:path";import { promisify } from "node:util";import * as z from "zod/v4";-import commonSchema from "../../schemas/definitions/artifact-common.schema.json";-import reviewItemsSchema from "../../schemas/tools/review-items.schema.json";import {artifactDestination,artifactSourcePath,@@ -12,10 +10,7 @@ import {type ArtifactContext,type ArtifactPage,} from "./artifact-io.js";-import {- loadArtifactZodSchema,- type SchemaDocument,-} from "./artifact-schema-loader.js";+import { artifactSchemaDocuments } from "./artifact-contracts.js";import {missingPythonHelperMessage,resolvePythonCommand,@@ -24,31 +19,16 @@ import { decodeUtf8 } from "./helpers/utf8.js";import { decodePosixBytes } from "./helpers/posix-path.js";const execFile = promisify(nodeExecFile);-const documents = [commonSchema, reviewItemsSchema] as SchemaDocument[];const inventoryComponents = ["artifacts", "02_discovery", "in_scope_files.txt"];const label = "review_items";-export interface ReviewItem {- path: string;-}--export const prepareReviewItemsInputSchema = loadArtifactZodSchema(- documents,- reviewItemsSchema.$id,- "prepareInput",-) as z.ZodType<{ scanId: string; handoffClaimToken?: string }>;--export const reviewItemsReaderInputSchema = loadArtifactZodSchema(- documents,- reviewItemsSchema.$id,- "reviewItemsInput",-) as z.ZodType<{ scanId: string; handoffClaimToken?: string } & ArtifactPage>;--const reviewItemSchema = loadArtifactZodSchema(- documents,- reviewItemsSchema.$id,- "reviewItem",-) as z.ZodType<ReviewItem>;+const definitions = artifactSchemaDocuments["tools/review-items"].$defs;+export type ReviewItem = z.infer<typeof definitions.reviewItem>;+export const {+ prepareInput: prepareReviewItemsInputSchema,+ reviewItemsInput: reviewItemsReaderInputSchema,+ reviewItem: reviewItemSchema,+} = definitions;/** Build the selected repository or diff inventory from host-bound scan context. */export async function prepareCodexSecurityReviewItems(diff --git a/plugins/codex-security/mcp-app/src/artifact-scan-draft.ts b/plugins/codex-security/mcp-app/src/artifact-scan-draft.tsindex 716d00905..9a53c45ac 100644--- a/plugins/codex-security/mcp-app/src/artifact-scan-draft.ts+++ b/plugins/codex-security/mcp-app/src/artifact-scan-draft.ts@@ -20,26 +20,22 @@ import {readArtifactTextWithMetadata,replaceArtifactJson,} from "./artifact-io.js";+import { artifactSchemaDocuments } from "./artifact-contracts.js";import {loadArtifactZodSchema,+ projectArtifactToolSchema,type SchemaDocument,} from "./artifact-schema-loader.js";import { saveThreatModelDocument } from "./threat-model-document.js";-export interface ScanDraftInput {- scanId: string;- complete?: boolean;- handoffClaimToken?: string;- scope?: JsonObject;- threatModel?: JsonObject;- findings: JsonObject[];- coverage: JsonObject;-}--export interface CompletedScanInput {- scanId: string;- handoffClaimToken?: string;-}+const draftDefinitions = artifactSchemaDocuments["tools/scan-draft"].$defs;+export const scanDraftInputSchema = projectArtifactToolSchema(+ draftDefinitions.scanDraftInput,+);+export const completedScanInputSchema = draftDefinitions.completedScanInput;+export type ScanDraftInput = z.infer<typeof scanDraftInputSchema>;+type DraftCoverage = ScanDraftInput["coverage"];+export type CompletedScanInput = z.infer<typeof completedScanInputSchema>;export interface ScanDraftResult {scanId: string;@@ -74,15 +70,8 @@ interface SavedScanDraft {attempt?: string;}-const schemaDocuments = [commonSchema, scanDraftDocument] as SchemaDocument[];--export const scanDraftInputSchema = loadArtifactZodSchema(- schemaDocuments,- scanDraftDocument.$id,- "scanDraftInput",-) as z.ZodType<ScanDraftInput>;--// Keep draft completion/host-field handling, using canonical persisted field rules.+// Canonical persisted JSON contracts remain authoritative for saved artifacts.+// Live compact tools continue to use the native Zod contracts above.const canonicalScanDraftInputSchema = loadArtifactZodSchema([commonSchema,@@ -92,7 +81,13 @@ const canonicalScanDraftInputSchema = loadArtifactZodSchema(...scanManifestDocument.$defs,...findingsDocument.$defs,...scanDraftDocument.$defs,- scanId: scanManifestDocument.properties.scan.properties.id,+ scanDraftInput: {+ ...scanDraftDocument.$defs.scanDraftInput,+ properties: {+ ...scanDraftDocument.$defs.scanDraftInput.properties,+ scanId: scanManifestDocument.properties.scan.properties.id,+ },+ },scope: {...scanDraftDocument.$defs.scope,properties:@@ -144,16 +139,10 @@ const canonicalScanDraftInputSchema = loadArtifactZodSchema("scanDraftInput",) as z.ZodType<ScanDraftInput>;-export const completedScanInputSchema = loadArtifactZodSchema(- schemaDocuments,- scanDraftDocument.$id,- "completedScanInput",-) as z.ZodType<CompletedScanInput>;-/** Stage a parent draft, then publish it under the workbench completion lock. */export async function recordCodexSecurityScanDraftViaWorkbench(context: ArtifactContext,- input: ScanDraftInput,+ input: unknown,runWorkbench: RunArtifactWorkbench,signal?: AbortSignal,publication?: DeepScanPublication,@@ -250,7 +239,7 @@ export async function recordCodexSecurityScanDraftViaWorkbench(const arguments_ = ["write-scan-draft","--scan-id",- input.scanId,+ checkpoint.scanId,"--draft-path",draftPath,"--checkpoint-path",@@ -295,7 +284,7 @@ export async function recordCodexSecurityScanDraftViaWorkbench(/** Save a Standard worker draft in its assigned output directory. */export async function recordCodexSecurityWorkerScanDraft(context: ArtifactContext,- input: ScanDraftInput,+ input: unknown,): Promise<ScanDraftResult> {const parsed = parseScanDraft(input);if (context.layout !== "worker") {@@ -348,11 +337,11 @@ export async function recordCodexSecurityWorkerScanDraft(}/** Keep findings with at least one location in the host's requested paths. */-export function findingsWithinScope(- findings: JsonObject[],+export function findingsWithinScope<Finding extends JsonObject>(+ findings: Finding[],includePaths: readonly string[],filePaths: readonly string[] = [],-): JsonObject[] {+): Finding[] {const scopes = includePaths.map((scope) =>posix.normalize(scope).replace(/\/$/u, ""),);@@ -446,19 +435,15 @@ async function preserveScanDraft(const savedSources = [...current, ...archived];const sources = savedSources.map(({ input }) => input);// Older checkpoints can omit IDs already assigned in their published output.- const savedDeferred = sources.flatMap(- (source) => source.coverage.deferred as JsonObject[],- );- const savedSurfaces = sources.flatMap(- (source) => source.coverage.surfaces as JsonObject[],- );+ const savedDeferred = sources.flatMap((source) => source.coverage.deferred);+ const savedSurfaces = sources.flatMap((source) => source.coverage.surfaces);for (const source of sources) {const reservedSurfaceIds = new Set(- (source.coverage.surfaces as JsonObject[]).flatMap((row) =>+ source.coverage.surfaces.flatMap((row) =>typeof row.id === "string" ? [row.id] : [],),);- const surfaces = (source.coverage.surfaces as JsonObject[]).map((row) => {+ const surfaces = source.coverage.surfaces.map((row) => {if (typeof row.id === "string") return row;const matching = savedSurfaces.find(({ id, ...content }) =>@@ -480,12 +465,12 @@ async function preserveScanDraft(typeof row.id === "string" ? row : normalizedSurfaces[index]!,);const reservedIds = new Set(- (source.coverage.deferred as JsonObject[]).flatMap((row) =>+ source.coverage.deferred.flatMap((row) =>typeof row.id === "string" ? [row.id] : [],),);source.coverage.deferred = normalizeDeferred(- (source.coverage.deferred as JsonObject[]).map((row) => {+ source.coverage.deferred.map((row) => {if (typeof row.id === "string" ||"candidateId" in row ||@@ -530,7 +515,7 @@ async function preserveScanDraft(const reopenedSurfaces = new Set<JsonObject>();if (retainedFinal) {const terminalOutcomeIds = completedCandidateIds(retainedFinal.input);- for (const surface of result.coverage.surfaces as JsonObject[]) {+ for (const surface of result.coverage.surfaces) {if (terminalOutcomeIds.has((surface.candidateId ?? surface.id) as string) &&typeof surface.id === "string"@@ -556,7 +541,7 @@ async function preserveScanDraft(for (const observation of progressSources) {const progress = structuredClone(observation);const reopenedIds = new Set(- (progress.coverage.deferred as JsonObject[]).flatMap((row) =>+ progress.coverage.deferred.flatMap((row) =>[row.id, row.candidateId].filter((id): id is string => typeof id === "string" && closedIds.has(id),),@@ -577,12 +562,12 @@ async function preserveScanDraft(result.coverage = preserveScanCoverage({...result.coverage,- deferred: (progress.coverage.deferred as JsonObject[]).filter(+ deferred: progress.coverage.deferred.filter((row) =>keepsGenericWork(row) ||!terminalOutcomeIds.has((row.candidateId ?? row.id) as string),),- surfaces: (progress.coverage.surfaces as JsonObject[]).filter(+ surfaces: progress.coverage.surfaces.filter((surface) =>keepsGenericWork(surface) ||(!terminalOutcomeIds.has(surface.id as string) &&@@ -611,7 +596,7 @@ async function preserveScanDraft(await saveScanDraftCheckpoint(context, input, false);const resolvedFollowUpSurfaces = sources.flatMap((source) => {- const pending = source.coverage.deferred as JsonObject[];+ const pending = source.coverage.deferred;if (pending.length === 0 ||pending.some((item) => {@@ -624,21 +609,21 @@ async function preserveScanDraft(}))return [];- return (source.coverage.surfaces as JsonObject[]).filter(+ return source.coverage.surfaces.filter((surface) => surface.disposition === "needs_follow_up",);});for (const source of sources) {- const deferred = result.coverage.deferred as JsonObject[];- const dispositions = (result.coverage.surfaces as JsonObject[]).filter(+ const deferred = result.coverage.deferred;+ const dispositions = result.coverage.surfaces.filter((surface) =>(surface.disposition === "rejected" ||surface.disposition === "not_applicable") &&typeof surface.candidateId === "string",);const candidateRows = [...deferred, ...dispositions];- for (const pending of source.coverage.deferred as JsonObject[]) {+ for (const pending of source.coverage.deferred) {const candidateId = pending.candidateId ?? pending.id;if (typeof candidateId !== "string") continue;const finding = result.findings.find(@@ -706,7 +691,7 @@ async function preserveScanDraft();const previousCoverage = {...source.coverage,- deferred: (source.coverage.deferred as JsonObject[]).filter((item) => {+ deferred: source.coverage.deferred.filter((item) => {const candidateId = item.candidateId ?? item.id;return ((keepsGenericWork(item) ||@@ -715,7 +700,7 @@ async function preserveScanDraft(!closedDeferredIds.has(item.id as string));}),- surfaces: (source.coverage.surfaces as JsonObject[]).filter((surface) => {+ surfaces: source.coverage.surfaces.filter((surface) => {if (resolvedSurfaces.has(surface)) return false;const candidateId = surface.candidateId ?? surface.id;return (@@ -735,20 +720,17 @@ async function preserveScanDraft(}),openQuestions:result.complete === false- ? (- (source.coverage.openQuestions as unknown[] | undefined) ?? []- ).filter(+ ? (source.coverage.openQuestions ?? []).filter((question) =>!coverageEntryPresent(- (result.coverage.openQuestions as unknown[] | undefined) ??- [],+ result.coverage.openQuestions ?? [],question,),): [],};result.coverage.surfaces = exactUnion(- result.coverage.surfaces as JsonObject[],+ result.coverage.surfaces,previousCoverage.surfaces,);result.coverage = preserveScanCoverage(@@ -757,12 +739,8 @@ async function preserveScanDraft(ambiguousDeferredIds,);}- result.coverage.deferred = normalizeDeferred(- result.coverage.deferred as JsonObject[],- );- result.coverage.surfaces = normalizeSurfaces(- result.coverage.surfaces as JsonObject[],- );+ result.coverage.deferred = normalizeDeferred(result.coverage.deferred);+ result.coverage.surfaces = normalizeSurfaces(result.coverage.surfaces);if (saveCheckpoint) await saveScanDraftCheckpoint(context, result);return { input: result, previousDigest: previousState.digest };}@@ -778,7 +756,7 @@ function completedCandidateIds(const id = findingCandidateId(finding);if (id !== undefined) completed.add(id);}- const dispositions = (source.coverage.surfaces as JsonObject[]).filter(+ const dispositions = source.coverage.surfaces.filter((surface) =>surface.disposition === "rejected" ||surface.disposition === "not_applicable",@@ -787,10 +765,7 @@ function completedCandidateIds(const id = surface.candidateId;if (typeof id === "string" && !observed.has(id)) completed.add(id);}- for (const row of [- ...(source.coverage.deferred as JsonObject[]),- ...dispositions,- ]) {+ for (const row of [...source.coverage.deferred, ...dispositions]) {const id = row.candidateId ?? row.id;if (typeof id === "string") observed.add(id);}@@ -798,8 +773,8 @@ function completedCandidateIds(return completed;}-function resolvedDeferred(coverage: JsonObject): JsonObject[] {- return (coverage.resolvedDeferred as JsonObject[] | undefined) ?? [];+function resolvedDeferred(coverage: DraftCoverage) {+ return coverage.resolvedDeferred ?? [];}function genericDeferred(row: JsonObject): boolean {@@ -822,7 +797,7 @@ function ambiguousGenericEntry(function ambiguousGenericDeferredIds(sources: ScanDraftInput[]): Set<string> {const ambiguous = new Set<string>();for (const source of sources) {- const rows = source.coverage.deferred as JsonObject[];+ const rows = source.coverage.deferred;const candidateIds = new Set(rows.filter((row) => !genericDeferred(row))@@ -849,18 +824,18 @@ function ambiguousGenericDeferredIds(sources: ScanDraftInput[]): Set<string> {function reconcileResolvedDeferred(result: ScanDraftInput,- requestedClosures: JsonObject[],+ requestedClosures: NonNullable<DraftCoverage["resolvedDeferred"]>,sources: ScanDraftInput[],savedSources: SavedScanDraft[],resolvedCandidateIds: Set<string>,ambiguousIds: Set<string>,retainedFinal?: ScanDraftInput,): { closedDeferredIds: Set<string>; resolvedSurfaces: Set<JsonObject> } {- const activeDeferred = result.coverage.deferred as JsonObject[];+ const activeDeferred = result.coverage.deferred;// Legacy aliases cannot identify which independent task was completed.// Keep generic work separate from candidate outcomes and ambiguous closures.for (const source of sources) {- for (const row of source.coverage.deferred as JsonObject[]) {+ for (const row of source.coverage.deferred) {if (ambiguousGenericEntry(row, ambiguousIds) &&!activeDeferred.some((current) => isDeepStrictEqual(current, row))@@ -881,16 +856,14 @@ function reconcileResolvedDeferred(for (const source of savedSources) {const key = JSON.stringify([source.attempt, source.modifiedMs]);const pending = pendingByTime.get(key) ?? new Set<string>();- for (const row of source.input.coverage.deferred as JsonObject[]) {+ for (const row of source.input.coverage.deferred) {pending.add(row.id as string);if (typeof row.candidateId === "string") pending.add(row.candidateId);}pendingByTime.set(key, pending);tiedPending.set(source.input, pending);}- const historical = sources.flatMap(- (source) => source.coverage.deferred as JsonObject[],- );+ const historical = sources.flatMap((source) => source.coverage.deferred);const candidateRows = historical.filter((row) =>typeof row.candidateId === "string" ||@@ -904,12 +877,15 @@ function reconcileResolvedDeferred(),),);- const closures = new Map<string, JsonObject>();+ const closures = new Map<+ string,+ NonNullable<DraftCoverage["resolvedDeferred"]>[number]+ >();const previouslyClosed = new Set<string>();const closureSources = new Map<string, ScanDraftInput>();for (const source of sources) {// Keep the first saved state for each ID so reopened work stays pending.- for (const row of source.coverage.deferred as JsonObject[]) {+ for (const row of source.coverage.deferred) {observedIds.add(row.id as string);if (typeof row.candidateId === "string") observedIds.add(row.candidateId);}@@ -991,7 +967,7 @@ function reconcileResolvedDeferred(...new Set([...closureSources.values(),...sources.filter((source) =>- (source.coverage.deferred as JsonObject[]).some((row) =>+ source.coverage.deferred.some((row) =>reopenedIds.has(row.id as string),),),@@ -1027,7 +1003,7 @@ function reconcileDeferredSurfaces(if (workIds.size === 0) return resolved;const current = coverage.surfaces as JsonObject[];const inheritedSurfaces = inherited.flatMap((source) =>- (source.coverage.surfaces as JsonObject[]).map((surface) => ({+ source.coverage.surfaces.map((surface) => ({surface,source,})),@@ -1039,7 +1015,7 @@ function reconcileDeferredSurfaces("candidateId" in surface || "candidate" in surface || "finding" in surface;const latestDeferred = [...(coverage.deferred as JsonObject[])];for (const source of sources) {- for (const row of source.coverage.deferred as JsonObject[]) {+ for (const row of source.coverage.deferred) {if (!deferredEntryPresent(latestDeferred, row, ambiguousDeferredIds))latestDeferred.push(row);}@@ -1067,8 +1043,8 @@ function reconcileDeferredSurfaces(continue;const matches = sources.map((source) => ({source,- surfaces: (source.coverage.surfaces as JsonObject[]).filter(sameSurface),- deferred: source.coverage.deferred as JsonObject[],+ surfaces: source.coverage.surfaces.filter(sameSurface),+ deferred: source.coverage.deferred,}));if (matches.some(@@ -1699,10 +1675,10 @@ function coverageEntryIdentities(entry: JsonObject): string[] {/** Reducers cannot resolve source review by omitting its coverage records. */function preserveScanCoverage(- coverage: JsonObject,- previous: JsonObject,+ coverage: DraftCoverage,+ previous: DraftCoverage,ambiguousDeferredIds = new Set<string>(),-): JsonObject {+): DraftCoverage {const result = structuredClone(coverage);for (const field of ["surfaces",@@ -1731,7 +1707,7 @@ function preserveScanCoverage(values.length > 0 ||result[field] !== undefined)- result[field] = values;+ Object.assign(result, { [field]: values });}if (coverageHasOutstandingWork(result)) result.completeness = "partial";return result;@@ -1916,11 +1892,11 @@ function parseCanonicalCheckpoint(return parsed;}-export function parseScanDraft(input: ScanDraftInput): ScanDraftInput {+export function parseScanDraft(input: unknown): ScanDraftInput {const parsed = parseSemanticScanDraft(input, scanDraftInputSchema);const deferredIds = new Set<string>();const ambiguousIds = ambiguousGenericDeferredIds([parsed]);- for (const row of parsed.coverage.deferred as JsonObject[]) {+ for (const row of parsed.coverage.deferred) {if (typeof row.id !== "string") continue;if (deferredIds.has(row.id) || ambiguousIds.has(row.id))throw new Error(`scan draft: coverage.deferred repeats ${row.id}.`);@@ -1930,12 +1906,8 @@ export function parseScanDraft(input: ScanDraftInput): ScanDraftInput {throw new Error("scan draft: coverage.resolvedDeferred is allowed only on a terminal draft.",);- parsed.coverage.deferred = normalizeDeferred(- parsed.coverage.deferred as JsonObject[],- );- parsed.coverage.surfaces = normalizeSurfaces(- parsed.coverage.surfaces as JsonObject[],- );+ parsed.coverage.deferred = normalizeDeferred(parsed.coverage.deferred);+ parsed.coverage.surfaces = normalizeSurfaces(parsed.coverage.surfaces);return parsed;}@@ -1973,7 +1945,7 @@ function parsePersistedDraft(function parsePersistedCheckpoint(input: Record<string, unknown>,- schema = scanDraftInputSchema,+ schema: z.ZodType<ScanDraftInput> = scanDraftInputSchema,): ScanDraftInput {const compatible = structuredClone(input);if (isObject(compatible.scope)) {@@ -2271,7 +2243,9 @@ function buildCoverage(};}-function normalizeSurfaces(surfaces: JsonObject[]): JsonObject[] {+function normalizeSurfaces(+ surfaces: DraftCoverage["surfaces"],+): DraftCoverage["surfaces"] {const reservedSurfaceIds = new Set(surfaces.flatMap((surface) =>[surface.id, surface.candidateId].filter(@@ -2301,7 +2275,9 @@ function normalizeSurfaces(surfaces: JsonObject[]): JsonObject[] {});}-function normalizeDeferred(rows: JsonObject[]): JsonObject[] {+function normalizeDeferred(+ rows: DraftCoverage["deferred"],+): DraftCoverage["deferred"] {// Reserve later owned identities before deriving any earlier missing ones.const ids = new Set(rows.flatMap((item) => (typeof item.id === "string" ? [item.id] : [])),diff --git a/plugins/codex-security/mcp-app/src/artifact-schema-loader.ts b/plugins/codex-security/mcp-app/src/artifact-schema-loader.tsindex 46b254e80..1f7e06dc2 100644--- a/plugins/codex-security/mcp-app/src/artifact-schema-loader.ts+++ b/plugins/codex-security/mcp-app/src/artifact-schema-loader.ts@@ -113,6 +113,15 @@ export function loadArtifactZodSchema(return validator.meta(modelFacingSchema(schema));}+/** Project a native contract for tools/list while preserving its validator and type. */+export function projectArtifactToolSchema<Schema extends z.ZodType>(+ schema: Schema,+): Schema {+ return schema.meta(+ modelFacingSchema(z.toJSONSchema(schema, { io: "input" })),+ );+}+/** Keep forbidden fields out of native tool declarations without allowing them. */function modelFacingSchema(schema: ArtifactSchemaObject): ArtifactSchemaObject {function visit(value: unknown): unknown {@@ -134,7 +143,7 @@ function modelFacingSchema(schema: ArtifactSchemaObject): ArtifactSchemaObject {)return object;const forbidden = Object.entries(properties)- .filter(([, property]) => property === false)+ .filter(([, property]) => forbiddenProperty(property)).map(([name]) => name);if (forbidden.length === 0) return object;@@ -142,7 +151,9 @@ function modelFacingSchema(schema: ArtifactSchemaObject): ArtifactSchemaObject {// projects as optional unknown fields. Exclude their names instead. This// is equivalent JSON Schema; the original validator remains unchanged.object.properties = Object.fromEntries(- Object.entries(properties).filter(([, property]) => property !== false),+ Object.entries(properties).filter(+ ([, property]) => !forbiddenProperty(property),+ ),);const names = { not: { enum: forbidden } };object.propertyNames =@@ -154,6 +165,20 @@ function modelFacingSchema(schema: ArtifactSchemaObject): ArtifactSchemaObject {return visit(schema) as ArtifactSchemaObject;}+function forbiddenProperty(property: unknown): boolean {+ if (property === false) return true;+ if (!property || typeof property !== "object" || Array.isArray(property))+ return false;+ const not = (property as ArtifactSchemaObject).not;+ return (+ Object.keys(property).length === 1 &&+ not !== null &&+ typeof not === "object" &&+ !Array.isArray(not) &&+ Object.keys(not).length === 0+ );+}+function readSchemaPointer(document: SchemaDocument, pointer: string): unknown {if (!pointer) return document;if (!pointer.startsWith("/")) {diff --git a/plugins/codex-security/mcp-app/src/deep-scan/artifact-contracts.ts b/plugins/codex-security/mcp-app/src/deep-scan/artifact-contracts.tsindex 596e4d4f2..ddddbd798 100644--- a/plugins/codex-security/mcp-app/src/deep-scan/artifact-contracts.ts+++ b/plugins/codex-security/mcp-app/src/deep-scan/artifact-contracts.ts@@ -1,4 +1,5 @@import { z } from "zod";+import { discoveryLocationRoles } from "../discovery-location-roles.js";const nonEmptyString = z.string()@@ -9,15 +10,7 @@ const candidateLocationSchemaV1 = zpath: nonEmptyString,start_line: z.number().int().positive(),end_line: z.number().int().positive(),- role: z.enum([- "entrypoint",- "entrypoint/wrapper",- "source",- "root_control",- "sink",- "concrete_implementation",- "evidence",- ]),+ role: z.enum(discoveryLocationRoles),}).refine((location) => location.end_line >= location.start_line, {message: "end_line must be greater than or equal to start_line",diff --git a/plugins/codex-security/mcp-app/src/deep-scan/artifact-validation.ts b/plugins/codex-security/mcp-app/src/deep-scan/artifact-validation.tsindex d3bdd6ee8..90e3fd3e0 100644--- a/plugins/codex-security/mcp-app/src/deep-scan/artifact-validation.ts+++ b/plugins/codex-security/mcp-app/src/deep-scan/artifact-validation.ts@@ -190,7 +190,7 @@ export function reconcileDeepReduction(const sourceValues = [...discoveries.map((discovery) => discovery.result[field]),previous?.[field],- ].filter((value): value is Record<string, unknown> => value !== undefined);+ ].filter((value) => value !== undefined);if (sourceValues.some((value) => !isDeepStrictEqual(sourceValues[0], value))) {@@ -199,7 +199,7 @@ export function reconcileDeepReduction();}if (sourceValues[0] !== undefined) {- result[field] = structuredClone(sourceValues[0]);+ Object.assign(result, { [field]: structuredClone(sourceValues[0]) });}}return result;diff --git a/plugins/codex-security/mcp-app/src/deep-scan/coordinator.ts b/plugins/codex-security/mcp-app/src/deep-scan/coordinator.tsindex 5f66e30aa..67cafde97 100644--- a/plugins/codex-security/mcp-app/src/deep-scan/coordinator.ts+++ b/plugins/codex-security/mcp-app/src/deep-scan/coordinator.ts@@ -362,7 +362,7 @@ export class DeepScanCoordinator {// Readers require coverage.json. The coordinator has accepted this// result, so mark it complete and leave review notes empty.coverage: {- completeness: "complete",+ completeness: "complete" as const,surfaces: [],explicitExclusions: [],deferred: [],diff --git a/plugins/codex-security/mcp-app/src/discovery-location-roles.ts b/plugins/codex-security/mcp-app/src/discovery-location-roles.tsnew file mode 100644index 000000000..5aff90d57--- /dev/null+++ b/plugins/codex-security/mcp-app/src/discovery-location-roles.ts@@ -0,0 +1,9 @@+export const discoveryLocationRoles = [+ "entrypoint",+ "entrypoint/wrapper",+ "source",+ "root_control",+ "sink",+ "concrete_implementation",+ "evidence",+] as const;diff --git a/plugins/codex-security/mcp-app/src/finding-detail-schemas.ts b/plugins/codex-security/mcp-app/src/finding-detail-schemas.tsnew file mode 100644index 000000000..728a258d3--- /dev/null+++ b/plugins/codex-security/mcp-app/src/finding-detail-schemas.ts@@ -0,0 +1,119 @@+import * as z from "zod/v4";++export function findingDetailSchemas(+ text: z.ZodString,+ path: z.ZodString,+ line: z.ZodNumber,+) {+ const slug = z.string().regex(new RegExp("^[a-z0-9][a-z0-9._/-]*$"));+ const textList = z.array(text);+ const findingAssessment = z.union([+ text,+ z.looseObject({+ level: text.optional(),+ rationale: text.optional(),+ why: text.optional(),+ }),+ ]);++ const textOrSummary = z.union([+ text,+ z.looseObject({+ summary: text.optional(),+ source: text.optional(),+ sink: text.optional(),+ outcome: text.optional(),+ transformations: textList.optional(),+ evidenceRefs: textList.optional(),+ evidence_refs: textList.optional(),+ }),+ ]);++ const findingReachability = z.union([+ text,+ z.looseObject({+ summary: text.optional(),+ attacker: text.optional(),+ entrypoint: text.optional(),+ source: text.optional(),+ sink: text.optional(),+ outcome: text.optional(),+ preconditions: textList.optional(),+ evidenceRefs: textList.optional(),+ evidence_refs: textList.optional(),+ }),+ ]);++ const findingValidation = z.looseObject({+ assertions: textList.optional(),+ counterEvidence: textList.optional(),+ evidence: z.union([text, textList]).optional(),+ evidenceRefs: textList.optional(),+ evidence_refs: textList.optional(),+ limitations: textList.optional(),+ method: text.optional(),+ status: z.union([text, z.null()]).optional(),+ summary: text.optional(),+ disposition: z.union([text, z.null()]).optional(),+ result: z.union([text, z.null()]).optional(),+ });++ const findingAttackPath = z.looseObject({+ assumptions: textList.optional(),+ blindspots: textList.optional(),+ controls: textList.optional(),+ dataFlow: textOrSummary.optional(),+ data_flow: textOrSummary.optional(),+ dataflow: textOrSummary.optional(),+ evidenceRefs: textList.optional(),+ evidence_refs: textList.optional(),+ impact: z.union([findingAssessment, z.null()]).optional(),+ likelihood: z.union([findingAssessment, z.null()]).optional(),+ limitations: textList.optional(),+ preconditions: textList.optional(),+ reachability: findingReachability.optional(),+ steps: textList.optional(),+ summary: text.optional(),+ });++ return {+ textList,+ slug,+ identity: z.looseObject({ anchor: slug, instance: slug.optional() }),+ severity: z.looseObject({+ level: z.enum(["critical", "high", "medium", "low", "informational"]),+ score: z.number().min(0).max(10).optional(),+ scoringSystem: text.optional(),+ vector: text.optional(),+ rationale: text.optional(),+ changeConditions: text.optional(),+ }),+ confidence: z.looseObject({+ level: z.enum(["high", "medium", "low"]),+ rationale: text,+ }),+ location: z.looseObject({+ path,+ startLine: line,+ endLine: line.optional(),+ role: text.optional(),+ }),+ codeEvidence: z.looseObject({+ id: slug,+ label: text,+ path,+ startLine: line,+ endLine: line.optional(),+ language: text.optional(),+ role: text.optional(),+ code: text,+ explanation: text,+ }),+ legacyCodeEvidence: z.looseObject({ id: text, code: text }),+ findingAssessment,+ textOrSummary,+ findingReachability,+ findingValidation,+ findingAttackPath,+ };+}diff --git a/plugins/codex-security/mcp-app/src/helpers/normalize-candidates.ts b/plugins/codex-security/mcp-app/src/helpers/normalize-candidates.tsindex 6b784beb3..d0d6fec16 100644--- a/plugins/codex-security/mcp-app/src/helpers/normalize-candidates.ts+++ b/plugins/codex-security/mcp-app/src/helpers/normalize-candidates.ts@@ -1,3 +1,4 @@+import { discoveryLocationRoles } from "../discovery-location-roles.js";import { isRecord as object } from "../record.js";import { decodeUtf8 } from "./utf8";import { createHash, randomBytes } from "node:crypto";@@ -22,15 +23,7 @@ import {} from "./resolve-security-md";import { pathText, widePath } from "../../../native/windows-files.mjs";-const roles = [- "entrypoint",- "entrypoint/wrapper",- "source",- "root_control",- "sink",- "concrete_implementation",- "evidence",-];+const roles: readonly string[] = discoveryLocationRoles;const fields = new Set(["candidate_id","cwe_ids",diff --git a/plugins/codex-security/mcp-app/src/threat-model-schema.ts b/plugins/codex-security/mcp-app/src/threat-model-schema.tsnew file mode 100644index 000000000..cc3c50b6f--- /dev/null+++ b/plugins/codex-security/mcp-app/src/threat-model-schema.ts@@ -0,0 +1,41 @@+import * as z from "zod/v4";++export function threatModelSchemas(+ textList: z.ZodArray<z.ZodString>,+ content = textList.element,+) {+ const scopeText = z.string().min(1);+ const scope = z+ .looseObject({+ includePaths: z.array(scopeText),+ excludePaths: z.array(scopeText).optional(),+ summary: scopeText.optional(),+ })+ .describe(+ "The modeled source scope, which may differ from the scan scope. Omit when unknown.",+ );+ const markdown = z.looseObject({+ format: z.literal("markdown"),+ content,+ scope: scope.optional(),+ origin: z+ .enum(["generated", "provided", "reconciled", "recovered"])+ .optional(),+ });+ const schema = z+ .union([+ z.looseObject({+ summary: textList.element,+ assets: textList.optional(),+ trustBoundaries: textList.optional(),+ attackerCapabilities: textList.optional(),+ securityObjectives: textList.optional(),+ assumptions: textList.optional(),+ }),+ markdown,+ ])+ .describe(+ "Retained threat-model content. Existing structured models remain supported; Markdown documents preserve their complete original body.",+ );+ return { schema, markdown, scope };+}diff --git a/plugins/codex-security/mcp-app/tests/scan-draft-fixture.ts b/plugins/codex-security/mcp-app/tests/scan-draft-fixture.tsindex 4ac21d338..af6b75377 100644--- a/plugins/codex-security/mcp-app/tests/scan-draft-fixture.ts+++ b/plugins/codex-security/mcp-app/tests/scan-draft-fixture.ts@@ -8,7 +8,7 @@ export function workerDraft<Finding extends Record<string, unknown>>(scanId,findings,coverage: {- completeness: "complete",+ completeness: "complete" as const,surfaces: [],explicitExclusions: [],deferred: [],@@ -23,9 +23,9 @@ export function finding(id: string, repositoryPath: string) {identity: { anchor: id },title: "Unsafe request output " + id,summary: "A request-controlled value reaches an HTML response.",- severity: { level: "high" },+ severity: { level: "high" as const },confidence: {- level: "high",+ level: "high" as const,rationale: "The source establishes reachability.",},taxonomy: { category: "cross-site-scripting", cwe: ["CWE-79"] },diff --git a/plugins/codex-security/mcp-app/tests/scan-draft-recovery-fixture.ts b/plugins/codex-security/mcp-app/tests/scan-draft-recovery-fixture.tsindex 8f1822b9e..8d6960e45 100644--- a/plugins/codex-security/mcp-app/tests/scan-draft-recovery-fixture.ts+++ b/plugins/codex-security/mcp-app/tests/scan-draft-recovery-fixture.ts@@ -84,6 +84,16 @@ export const claimToken = "19bfba38-0913-4bd7-86ef-134e9a4d9a42";type Layout = "standard" | "diff" | "deep" | "worker";+// Fixtures also exercise malformed and legacy inputs before runtime validation.+type DraftFixture = Omit<+ ScanDraftInput,+ "findings" | "coverage" | "threatModel"+> & {+ findings: Record<string, unknown>[];+ coverage: Record<string, unknown>;+ threatModel?: Record<string, unknown>;+};+export function draftFixture(root: string, layout: Layout) {const context: ArtifactContext = {root,@@ -117,7 +127,7 @@ export function draftFixture(root: string, layout: Layout) {const draft = (coverage: { deferred?: unknown[]; [key: string]: unknown } = {},complete = false,- ): ScanDraftInput => ({+ ): DraftFixture => ({scanId,...(layout === "worker" ? {} : { handoffClaimToken: claimToken }),complete,@@ -135,7 +145,7 @@ export function draftFixture(root: string, layout: Layout) {root,context,draft,- write: (input: ScanDraftInput) =>+ write: (input: unknown) =>layout === "worker"? draftApi.recordCodexSecurityWorkerScanDraft(context, input): recordCodexSecurityScanDraft(context, input),diff --git a/plugins/codex-security/mcp-app/tests/test_artifact_contracts.ts b/plugins/codex-security/mcp-app/tests/test_artifact_contracts.tsnew file mode 100644index 000000000..687340ca7--- /dev/null+++ b/plugins/codex-security/mcp-app/tests/test_artifact_contracts.ts@@ -0,0 +1,158 @@+import path from "node:path";+import assert from "node:assert/strict";+import Ajv2020 from "ajv/dist/2020.js";+import { importSource } from "./import-module.ts";+import { readJson } from "./support/json.ts";++const { artifactSchemaDocuments } = await importSource(+ path.join(import.meta.dirname, "../src/artifact-contracts.ts"),+);+const ajv = new Ajv2020({ strict: false, validateFormats: false });+for (const path of Object.keys(artifactSchemaDocuments)) {+ ajv.addSchema(+ await readJson(import.meta.dirname, `../../schemas/${path}.schema.json`),+ );+}+function jsonSchema(path: string, name: string) {+ return ajv.getSchema(+ `codex-security://schemas/${path}.schema.json#/$defs/${name}`,+ )!;+}++// Ledger readers expose only the first issue; preserve field precedence.+const attackPaths =+ artifactSchemaDocuments["tools/candidate-attack-paths"].$defs;+const attackPath = {+ dataflow: "Request reaches the operation.",+ reachability: "The public handler calls it.",+ counterevidence: "No intervening control.",+ impact: "high",+ likelihood: "high",+};+for (const [schema, input, field] of [+ [+ artifactSchemaDocuments["definitions/discovery-candidate"].$defs+ .discoveryCandidate,+ {},+ "candidate_id",+ ],+ [+ artifactSchemaDocuments["tools/discovery-candidates"].$defs+ .workbenchListCandidatesInput,+ { scanId: 42, cursor: "bad" },+ "scanId",+ ],+ ...[+ [attackPaths.reportableAttackPath, "reportable"],+ [attackPaths.ignoredAttackPath, "ignore"],+ [attackPaths.deferredAttackPath, "deferred"],+ ].map(([schema, decision]) => [+ schema,+ { ...attackPath, decision },+ "severity",+ ]),+] as const) {+ const result = schema.safeParse(input);+ assert.equal(result.success, false);+ assert.deepEqual(result.error?.issues[0]?.path, [field]);+}++// Custom validation exposes JSON-schema diagnostics, including legacy keywords.+for (const [path, name, value, message] of [+ [+ "tools/scan-draft",+ "severity/properties/level",+ null,+ "must be equal to one of the allowed values",+ ],+ ...["disposition", "confidence"].map(+ (field) =>+ [+ "tools/candidate-validations",+ `validationRecord/properties/${field}`,+ null,+ "must be string",+ ] as const,+ ),+ [+ "tools/scan-draft",+ "finding/properties/findingId",+ "invented",+ "boolean schema is false",+ ],+ [+ "tools/scan-draft",+ "finding/properties/writeup/properties/reportPath",+ "invalid",+ 'must match pattern "^findings/([a-z0-9][a-z0-9._-]*)/\\1\\.md$"',+ ],+] as const) {+ const validate = jsonSchema(path, name);+ assert.equal(validate(value), false);+ assert.equal(validate.errors?.[0]?.message, message);+}++// SDK JSON consumers disable formats; native tools retain Zod's UUID and safe+// integer validation. Generated exports must preserve both existing contracts.+const common = artifactSchemaDocuments["definitions/artifact-common"].$defs;+const uuid = "61a20957-1be8-4ccf-8de8-eab4061e8cc3";+for (const [value, valid] of [+ [uuid, true],+ ["not-a-uuid", false],+] as const) {+ assert.equal(common.scanId.safeParse(value).success, valid);+ assert.equal(+ jsonSchema("definitions/artifact-common", "scanId")(value),+ true,+ );+ assert.equal(jsonSchema("tools/scan-draft", "scanId")(value), true);+}+const location = artifactSchemaDocuments["tools/scan-draft"].$defs.location;+for (const [startLine, runtime, json] of [+ [1, true, true],+ [0, false, false],+ [1.5, false, false],+ [Number.MAX_SAFE_INTEGER + 1, false, true],+] as const) {+ const value = { path: "src/file.ts", startLine, endLine: startLine };+ assert.equal(location.safeParse(value).success, runtime);+ assert.equal(jsonSchema("tools/scan-draft", "location")(value), json);+}+const reducer =+ artifactSchemaDocuments["tools/deep-reducer"].$defs.reducerInputs;+const excessiveBudget = { maxBytes: Number.MAX_SAFE_INTEGER + 1 };+assert.equal(reducer.safeParse(excessiveBudget).success, false);+assert.equal(+ jsonSchema("tools/deep-reducer", "reducerInputs")(excessiveBudget),+ false,+);++// Uniqueness is checked on raw values before parsing the text items.+const sourceFindingIds =+ artifactSchemaDocuments["tools/scan-draft"].$defs.finding.shape.provenance+ .shape.sourceFindingIds;+for (const values of [+ [null, null],+ [" ", " "],+]) {+ const result = sourceFindingIds.safeParse(values);+ assert.equal(result.success, false);+ assert.deepEqual(result.error?.issues, [+ {+ code: "custom",+ path: [1],+ message:+ "Array items must be unique: element at index 1 duplicates the one at index 0",+ },+ ]);+}++// Named legacy definitions and cross-document aliases remain addressable.+for (const [path, { $defs }] of Object.entries(+ artifactSchemaDocuments,+) as Array<[string, { $defs: Record<string, unknown> }]>) {+ for (const name of Object.keys($defs)) {+ if (name !== "attackPathFields")+ assert.ok(jsonSchema(path, name), `${path}: ${name}`);+ }+}diff --git a/plugins/codex-security/mcp-app/tests/test_artifact_foundation.ts b/plugins/codex-security/mcp-app/tests/test_artifact_foundation.tsindex bf0288776..ed9976bd4 100644--- a/plugins/codex-security/mcp-app/tests/test_artifact_foundation.ts+++ b/plugins/codex-security/mcp-app/tests/test_artifact_foundation.ts@@ -1,3 +1,4 @@+import * as z from "zod/v4";import { readJson } from "./support/json.ts";import assert from "node:assert/strict";import { spawn } from "node:child_process";@@ -41,7 +42,7 @@ const writerApi = await importSource(},);const schemas = await importSource(- path.join(import.meta.dirname, "../src/artifact-schema-loader.ts"),+ path.join(import.meta.dirname, "../src/artifact-contracts.ts"),);const fixture = await realpath(await mkdtemp(path.join(tmpdir(), "codex-security-artifact-foundation-")),@@ -70,38 +71,12 @@ try {console.log("Codex Security compact artifact foundation tests passed");async function testSchemaSourceOfTruth() {- const common = await readJson(- import.meta.dirname,- "../../schemas/definitions/artifact-common.schema.json",- );- const fixtureDocument = {- $id: "codex-security://schemas/tools/artifact-foundation-fixture.schema.json",- $defs: {- request: {- type: "object",- properties: {- path: { $ref: common.$id + "#/$defs/repositoryPath" },- candidateId: { $ref: common.$id + "#/$defs/candidateId" },- },- required: ["path", "candidateId"],- additionalProperties: false,- },- },- };- const bundled = schemas.bundleArtifactSchema(- [common, fixtureDocument],- fixtureDocument.$id,- "request",- );- assert.equal(JSON.stringify(bundled).includes("$ref"), false);- assert.equal(bundled.properties.path.type, "string");- assert.equal(bundled.properties.candidateId.type, "string");-- const validator = schemas.loadArtifactZodSchema(- [common, fixtureDocument],- fixtureDocument.$id,- "request",- );+ const common =+ schemas.artifactSchemaDocuments["definitions/artifact-common"].$defs;+ const validator = z.strictObject({+ path: common.repositoryPath,+ candidateId: common.candidateId,+ });for (const repositoryPath of ["src/index.ts","./src/index.ts",@@ -145,19 +120,6 @@ async function testSchemaSourceOfTruth() {candidateId,);}- assert.throws(- () => schemas.bundleArtifactSchema([common], "missing", "request"),- /Unknown Codex Security schema document/,- );- assert.throws(- () =>- schemas.bundleArtifactSchema(- [common, common],- common.$id,- "repositoryPath",- ),- /Duplicate Codex Security schema document/,- );}async function testScanContext() {diff --git a/plugins/codex-security/mcp-app/tests/test_artifact_scan_draft.ts b/plugins/codex-security/mcp-app/tests/test_artifact_scan_draft.tsindex 21826c0cd..5b3fd73d8 100644--- a/plugins/codex-security/mcp-app/tests/test_artifact_scan_draft.ts+++ b/plugins/codex-security/mcp-app/tests/test_artifact_scan_draft.ts@@ -3,7 +3,6 @@ import { readJson, snapshotScanDraft, writeJsonLine } from "./support/json.ts";import { mock } from "node:test";import { temporaryDirectory } from "./support/temporary-directories.ts";import type { ArtifactContext } from "../src/artifact-context.js";-import type { ScanDraftInput } from "../src/artifact-scan-draft.js";type FixtureFinding = Record<string, unknown> & {provenance: Record<string, unknown>;identity?: { anchor: string; instance?: string };@@ -104,7 +103,7 @@ try {});const rejectsDraft = (- input: ScanDraftInput,+ input: unknown,error: RegExp,boundContext: ArtifactContext = context,) => assert.rejects(recordCodexSecurityScanDraft(boundContext, input), error);@@ -3030,10 +3029,7 @@ async function archiveFirstWorkerAttempt(output: string) {}// Projection cases below use the same fixture root but model independent scans.-async function recordFreshScanDraft(- context: ArtifactContext,- input: ScanDraftInput,-) {+async function recordFreshScanDraft(context: ArtifactContext, input: unknown) {await Promise.all([...["scan-manifest.json",diff --git a/plugins/codex-security/mcp-app/tests/test_artifact_scan_draft_recovery.ts b/plugins/codex-security/mcp-app/tests/test_artifact_scan_draft_recovery.tsindex c70919fe5..33a8b7097 100644--- a/plugins/codex-security/mcp-app/tests/test_artifact_scan_draft_recovery.ts+++ b/plugins/codex-security/mcp-app/tests/test_artifact_scan_draft_recovery.ts@@ -1,5 +1,4 @@import { readJson, writeJson } from "./support/json.ts";-import type { ScanDraftInput } from "../src/artifact-scan-draft.js";import assert from "node:assert/strict";import { execFile } from "node:child_process";import { hash } from "node:crypto";@@ -1088,7 +1087,7 @@ for (const layout of ["standard", "diff", "worker"] as const) {);const pending = { id: "review", ...generic };const closing = f.draft({ resolvedDeferred: [close(pending.id)] }, true);- const fail = (input: ScanDraftInput) =>+ const fail = (input: unknown) =>interruptDraftWrite(path.join(f.root, destination), () =>f.write(input),);diff --git a/plugins/codex-security/mcp-app/tests/test_deep_scan_artifact_validation.ts b/plugins/codex-security/mcp-app/tests/test_deep_scan_artifact_validation.tsindex 6fafbfb3f..30de7057a 100644--- a/plugins/codex-security/mcp-app/tests/test_deep_scan_artifact_validation.ts+++ b/plugins/codex-security/mcp-app/tests/test_deep_scan_artifact_validation.ts@@ -390,7 +390,10 @@ async function testReducerValidation(root: string) {),[previousCollisionA.summary, previousCollisionB.summary],);- const referenced = (original: Record<string, unknown>, refs: string[]) => ({+ const referenced = <Finding extends Record<string, unknown>>(+ original: Finding,+ refs: string[],+ ) => ({...original,provenance: { source: "local_plugin", sourceFindingIds: refs },});diff --git a/plugins/codex-security/mcp-app/tests/test_deep_scan_coordinator.ts b/plugins/codex-security/mcp-app/tests/test_deep_scan_coordinator.tsindex d8f0567f2..dbcef1ec5 100644--- a/plugins/codex-security/mcp-app/tests/test_deep_scan_coordinator.ts+++ b/plugins/codex-security/mcp-app/tests/test_deep_scan_coordinator.ts@@ -3888,8 +3888,7 @@ async function testPublicationUsesAcceptedReducerSnapshot() {);assert.equal(terminal?.status, "succeeded", terminal?.error);assert.equal(- (completed[0].findings[0].provenance as { candidateId: string })- .candidateId,+ completed[0].findings[0].provenance.candidateId,"accepted-finding",);assert.equal(completed[0].coverage.completeness, "complete");diff --git a/plugins/codex-security/mcp-app/tests/test_deep_scan_publication_integration.ts b/plugins/codex-security/mcp-app/tests/test_deep_scan_publication_integration.tsindex d2804ddb9..9d67415d9 100644--- a/plugins/codex-security/mcp-app/tests/test_deep_scan_publication_integration.ts+++ b/plugins/codex-security/mcp-app/tests/test_deep_scan_publication_integration.ts@@ -66,7 +66,7 @@ const pluginRoot = path.resolve(mcpAppRoot, "..");const workbenchPath = path.join(pluginRoot, "scripts", "workbench_db.py");const python = process.env.PYTHON?.trim() || "python3";const owner = "publication-test-owner";-const coverage = {+const coverage: ScanDraftInput["coverage"] = {completeness: "complete",surfaces: [],explicitExclusions: [],diff --git a/plugins/codex-security/schemas/definitions/artifact-common.schema.json b/plugins/codex-security/schemas/definitions/artifact-common.schema.jsonindex 6a286b8fc..f2dcd094e 100644--- a/plugins/codex-security/schemas/definitions/artifact-common.schema.json+++ b/plugins/codex-security/schemas/definitions/artifact-common.schema.json@@ -2,15 +2,8 @@"$schema": "https://json-schema.org/draft/2020-12/schema","$id": "codex-security://schemas/definitions/artifact-common.schema.json","$defs": {- "nonEmptyText": {- "type": "string",- "minLength": 1,- "pattern": "\\S"- },- "scanId": {- "type": "string",- "format": "uuid"- },+ "nonEmptyText": { "type": "string", "minLength": 1, "pattern": "\\S" },+ "scanId": { "type": "string", "format": "uuid" },"repositoryPath": {"type": "string","minLength": 1,diff --git a/plugins/codex-security/schemas/definitions/discovery-candidate.schema.json b/plugins/codex-security/schemas/definitions/discovery-candidate.schema.jsonindex 7e128fb29..b30d7371b 100644--- a/plugins/codex-security/schemas/definitions/discovery-candidate.schema.json+++ b/plugins/codex-security/schemas/definitions/discovery-candidate.schema.json@@ -2,10 +2,7 @@"$schema": "https://json-schema.org/draft/2020-12/schema","$id": "codex-security://schemas/definitions/discovery-candidate.schema.json","$defs": {- "nonEmptyText": {- "type": "string",- "pattern": "\\S"- },+ "nonEmptyText": { "type": "string", "pattern": "\\S" },"cweId": {"type": "string","pattern": "^\\s*[Cc][Ww][Ee]-0*[1-9][0-9]*\\s*$"@@ -24,34 +21,61 @@"rawDiscoveryLocation": {"type": "object","properties": {- "path": { "$ref": "#/$defs/nonEmptyText" },+ "path": {+ "$ref": "codex-security://schemas/definitions/discovery-candidate.schema.json#/$defs/nonEmptyText"+ },"start_line": { "type": "integer", "minimum": 1 },"end_line": { "type": "integer", "minimum": 1 },- "role": { "$ref": "#/$defs/locationRole" }+ "role": {+ "$ref": "codex-security://schemas/definitions/discovery-candidate.schema.json#/$defs/locationRole"+ }},"required": ["path", "start_line", "role"],"additionalProperties": false},"normalizedDiscoveryLocation": {- "$ref": "#/$defs/rawDiscoveryLocation",- "required": ["path", "start_line", "end_line", "role"]+ "type": "object",+ "properties": {+ "path": {+ "$ref": "codex-security://schemas/definitions/discovery-candidate.schema.json#/$defs/nonEmptyText"+ },+ "start_line": { "type": "integer", "minimum": 1 },+ "end_line": { "type": "integer", "minimum": 1 },+ "role": {+ "$ref": "codex-security://schemas/definitions/discovery-candidate.schema.json#/$defs/locationRole"+ }+ },+ "required": ["path", "start_line", "end_line", "role"],+ "additionalProperties": false},"rawDiscoveryCandidate": {"type": "object","properties": {"cwe_ids": {"type": "array",- "items": { "$ref": "#/$defs/cweId" }+ "items": {+ "$ref": "codex-security://schemas/definitions/discovery-candidate.schema.json#/$defs/cweId"+ }},"locations": {- "type": "array","minItems": 1,- "items": { "$ref": "#/$defs/rawDiscoveryLocation" }+ "type": "array",+ "items": {+ "$ref": "codex-security://schemas/definitions/discovery-candidate.schema.json#/$defs/rawDiscoveryLocation"+ }+ },+ "summary": {+ "$ref": "codex-security://schemas/definitions/discovery-candidate.schema.json#/$defs/nonEmptyText"+ },+ "evidence": {+ "$ref": "codex-security://schemas/definitions/discovery-candidate.schema.json#/$defs/nonEmptyText"},- "summary": { "$ref": "#/$defs/nonEmptyText" },- "evidence": { "$ref": "#/$defs/nonEmptyText" },- "context": { "$ref": "#/$defs/nonEmptyText" },- "instance": { "$ref": "#/$defs/nonEmptyText" }+ "context": {+ "$ref": "codex-security://schemas/definitions/discovery-candidate.schema.json#/$defs/nonEmptyText"+ },+ "instance": {+ "$ref": "codex-security://schemas/definitions/discovery-candidate.schema.json#/$defs/nonEmptyText"+ }},"required": ["cwe_ids", "locations", "summary", "evidence"],"additionalProperties": false@@ -65,20 +89,27 @@},"cwe_ids": {"type": "array",- "items": {- "type": "string",- "pattern": "^CWE-[1-9][0-9]*$"- }+ "items": { "type": "string", "pattern": "^CWE-[1-9][0-9]*$" }},"locations": {- "type": "array","minItems": 1,- "items": { "$ref": "#/$defs/normalizedDiscoveryLocation" }+ "type": "array",+ "items": {+ "$ref": "codex-security://schemas/definitions/discovery-candidate.schema.json#/$defs/normalizedDiscoveryLocation"+ }+ },+ "summary": {+ "$ref": "codex-security://schemas/definitions/discovery-candidate.schema.json#/$defs/nonEmptyText"+ },+ "evidence": {+ "$ref": "codex-security://schemas/definitions/discovery-candidate.schema.json#/$defs/nonEmptyText"+ },+ "context": {+ "$ref": "codex-security://schemas/definitions/discovery-candidate.schema.json#/$defs/nonEmptyText"},- "summary": { "$ref": "#/$defs/nonEmptyText" },- "evidence": { "$ref": "#/$defs/nonEmptyText" },- "context": { "$ref": "#/$defs/nonEmptyText" },- "instance": { "$ref": "#/$defs/nonEmptyText" }+ "instance": {+ "$ref": "codex-security://schemas/definitions/discovery-candidate.schema.json#/$defs/nonEmptyText"+ }},"required": ["candidate_id",diff --git a/plugins/codex-security/schemas/tools/candidate-attack-paths.schema.json b/plugins/codex-security/schemas/tools/candidate-attack-paths.schema.jsonindex 122edcb13..7610cab07 100644--- a/plugins/codex-security/schemas/tools/candidate-attack-paths.schema.json+++ b/plugins/codex-security/schemas/tools/candidate-attack-paths.schema.json@@ -6,8 +6,6 @@"$defs": {"input": {"type": "object",- "additionalProperties": false,- "required": ["scanId", "attackPaths"],"properties": {"scanId": {"$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/scanId"@@ -15,34 +13,36 @@"attackPaths": {"type": "array","items": {- "$ref": "#/$defs/attackPathUpdate"+ "$ref": "codex-security://schemas/tools/candidate-attack-paths.schema.json#/$defs/attackPathUpdate"}}- }+ },+ "required": ["scanId", "attackPaths"],+ "additionalProperties": false},"attackPathUpdate": {"type": "object",- "additionalProperties": false,- "required": ["candidateId", "attackPath"],"properties": {"candidateId": {"$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/candidateId"},"attackPath": {- "$ref": "#/$defs/attackPath"+ "$ref": "codex-security://schemas/tools/candidate-attack-paths.schema.json#/$defs/attackPath"}- }+ },+ "required": ["candidateId", "attackPath"],+ "additionalProperties": false},"attackPath": {"oneOf": [{- "$ref": "#/$defs/reportableAttackPath"+ "$ref": "codex-security://schemas/tools/candidate-attack-paths.schema.json#/$defs/reportableAttackPath"},{- "$ref": "#/$defs/ignoredAttackPath"+ "$ref": "codex-security://schemas/tools/candidate-attack-paths.schema.json#/$defs/ignoredAttackPath"},{- "$ref": "#/$defs/deferredAttackPath"+ "$ref": "codex-security://schemas/tools/candidate-attack-paths.schema.json#/$defs/deferredAttackPath"}]},@@ -56,12 +56,8 @@"counterevidence": {"$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},- "impact": {- "enum": ["high", "medium", "low", "ignore", "unknown"]- },- "likelihood": {- "enum": ["high", "medium", "low", "ignore", "unknown"]- },+ "impact": { "enum": ["high", "medium", "low", "ignore", "unknown"] },+ "likelihood": { "enum": ["high", "medium", "low", "ignore", "unknown"] },"severity_rationale": {"$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},@@ -71,7 +67,29 @@},"reportableAttackPath": {"type": "object",- "additionalProperties": true,+ "properties": {+ "decision": { "const": "reportable" },+ "dataflow": {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ },+ "reachability": {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ },+ "counterevidence": {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ },+ "impact": { "enum": ["high", "medium", "low", "ignore", "unknown"] },+ "likelihood": {+ "enum": ["high", "medium", "low", "ignore", "unknown"]+ },+ "severity": { "enum": ["critical", "high", "medium", "low"] },+ "severity_rationale": {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ },+ "change_conditions": {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ }+ },"required": ["decision","dataflow",@@ -83,21 +101,33 @@"severity_rationale","change_conditions"],- "properties": {- "decision": { "const": "reportable" },- "dataflow": { "$ref": "#/$defs/attackPathFields/dataflow" },- "reachability": { "$ref": "#/$defs/attackPathFields/reachability" },- "counterevidence": { "$ref": "#/$defs/attackPathFields/counterevidence" },- "impact": { "$ref": "#/$defs/attackPathFields/impact" },- "likelihood": { "$ref": "#/$defs/attackPathFields/likelihood" },- "severity": { "enum": ["critical", "high", "medium", "low"] },- "severity_rationale": { "$ref": "#/$defs/attackPathFields/severity_rationale" },- "change_conditions": { "$ref": "#/$defs/attackPathFields/change_conditions" }- }+ "additionalProperties": true},"ignoredAttackPath": {"type": "object",- "additionalProperties": true,+ "properties": {+ "decision": { "const": "ignore" },+ "dataflow": {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ },+ "reachability": {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ },+ "counterevidence": {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ },+ "impact": { "enum": ["high", "medium", "low", "ignore", "unknown"] },+ "likelihood": {+ "enum": ["high", "medium", "low", "ignore", "unknown"]+ },+ "severity": { "const": "ignore" },+ "severity_rationale": {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ },+ "change_conditions": {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ }+ },"required": ["decision","dataflow",@@ -109,21 +139,38 @@"severity_rationale","change_conditions"],- "properties": {- "decision": { "const": "ignore" },- "dataflow": { "$ref": "#/$defs/attackPathFields/dataflow" },- "reachability": { "$ref": "#/$defs/attackPathFields/reachability" },- "counterevidence": { "$ref": "#/$defs/attackPathFields/counterevidence" },- "impact": { "$ref": "#/$defs/attackPathFields/impact" },- "likelihood": { "$ref": "#/$defs/attackPathFields/likelihood" },- "severity": { "const": "ignore" },- "severity_rationale": { "$ref": "#/$defs/attackPathFields/severity_rationale" },- "change_conditions": { "$ref": "#/$defs/attackPathFields/change_conditions" }- }+ "additionalProperties": true},"deferredAttackPath": {"type": "object",- "additionalProperties": true,+ "properties": {+ "decision": { "const": "deferred" },+ "dataflow": {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ },+ "reachability": {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ },+ "counterevidence": {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ },+ "impact": { "enum": ["high", "medium", "low", "ignore", "unknown"] },+ "likelihood": {+ "enum": ["high", "medium", "low", "ignore", "unknown"]+ },+ "severity": {+ "enum": ["critical", "high", "medium", "low", "unknown"]+ },+ "severity_rationale": {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ },+ "change_conditions": {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ },+ "proof_gap": {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ }+ },"required": ["decision","dataflow",@@ -136,20 +183,7 @@"change_conditions","proof_gap"],- "properties": {- "decision": { "const": "deferred" },- "dataflow": { "$ref": "#/$defs/attackPathFields/dataflow" },- "reachability": { "$ref": "#/$defs/attackPathFields/reachability" },- "counterevidence": { "$ref": "#/$defs/attackPathFields/counterevidence" },- "impact": { "$ref": "#/$defs/attackPathFields/impact" },- "likelihood": { "$ref": "#/$defs/attackPathFields/likelihood" },- "severity": { "enum": ["critical", "high", "medium", "low", "unknown"] },- "severity_rationale": { "$ref": "#/$defs/attackPathFields/severity_rationale" },- "change_conditions": { "$ref": "#/$defs/attackPathFields/change_conditions" },- "proof_gap": {- "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"- }- }+ "additionalProperties": true}}}diff --git a/plugins/codex-security/schemas/tools/candidate-validations.schema.json b/plugins/codex-security/schemas/tools/candidate-validations.schema.jsonindex 6135af5c9..87c27fa97 100644--- a/plugins/codex-security/schemas/tools/candidate-validations.schema.json+++ b/plugins/codex-security/schemas/tools/candidate-validations.schema.json@@ -6,8 +6,6 @@"$defs": {"input": {"type": "object",- "additionalProperties": false,- "required": ["scanId", "validations"],"properties": {"scanId": {"$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/scanId"@@ -15,49 +13,37 @@"validations": {"type": "array","items": {- "$ref": "#/$defs/validationUpdate"+ "$ref": "codex-security://schemas/tools/candidate-validations.schema.json#/$defs/validationUpdate"}}- }+ },+ "required": ["scanId", "validations"],+ "additionalProperties": false},"validationUpdate": {"type": "object",- "additionalProperties": false,- "required": ["candidateId", "validation"],"properties": {"candidateId": {"$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/candidateId"},"validation": {- "$ref": "#/$defs/validationRecord"+ "$ref": "codex-security://schemas/tools/candidate-validations.schema.json#/$defs/validationRecord"}- }+ },+ "required": ["candidateId", "validation"],+ "additionalProperties": false},"validationRecord": {"type": "object",- "additionalProperties": true,- "required": [- "disposition",- "method",- "confidence",- "confidence_rationale",- "rubric",- "evidence",- "counterevidence_or_proof_gap",- "remaining_uncertainty"- ],"properties": {"disposition": {- "type": "string",- "enum": ["reportable", "suppressed", "not_applicable", "deferred"]+ "enum": ["reportable", "suppressed", "not_applicable", "deferred"],+ "type": "string"},"method": {"$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},- "confidence": {- "type": "string",- "enum": ["high", "medium", "low"]- },+ "confidence": { "enum": ["high", "medium", "low"], "type": "string" },"confidence_rationale": {"$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},@@ -67,18 +53,22 @@"$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},{- "type": "object"+ "type": "object",+ "properties": {},+ "additionalProperties": true},{- "type": "array","minItems": 1,+ "type": "array","items": {"anyOf": [{"$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},{- "type": "object"+ "type": "object",+ "properties": {},+ "additionalProperties": true}]}@@ -91,20 +81,16 @@"$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},{- "type": "array","minItems": 1,+ "type": "array","items": {"$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"}}]},- "counterevidence_or_proof_gap": {- "type": "string"- },- "remaining_uncertainty": {- "type": "string"- },+ "counterevidence_or_proof_gap": { "type": "string" },+ "remaining_uncertainty": { "type": "string" },"artifact_paths": {"type": "array","items": {@@ -121,9 +107,31 @@"$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"preconditions": {- "$ref": "#/$defs/validationRecord/properties/evidence"+ "anyOf": [+ {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ },+ {+ "minItems": 1,+ "type": "array",+ "items": {+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"+ }+ }+ ]}- }+ },+ "required": [+ "disposition",+ "method",+ "confidence",+ "confidence_rationale",+ "rubric",+ "evidence",+ "counterevidence_or_proof_gap",+ "remaining_uncertainty"+ ],+ "additionalProperties": true}}}diff --git a/plugins/codex-security/schemas/tools/deep-reducer.schema.json b/plugins/codex-security/schemas/tools/deep-reducer.schema.jsonindex e459e9762..eea8bf7fc 100644--- a/plugins/codex-security/schemas/tools/deep-reducer.schema.json+++ b/plugins/codex-security/schemas/tools/deep-reducer.schema.json@@ -34,7 +34,7 @@"description": "Omit or set true when submitting the finished aggregate."},"scanId": {- "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/scanId"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/scanId"},"handoffClaimToken": {"$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/handoffClaimToken"@@ -46,7 +46,10 @@"$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/threatModel"},"findings": {- "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/scanDraftInput/properties/findings"+ "type": "array",+ "items": {+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/finding"+ }}},"required": ["scanId", "findings"],diff --git a/plugins/codex-security/schemas/tools/discovery-candidates.schema.json b/plugins/codex-security/schemas/tools/discovery-candidates.schema.jsonindex d758a4374..2f2f2e78f 100644--- a/plugins/codex-security/schemas/tools/discovery-candidates.schema.json+++ b/plugins/codex-security/schemas/tools/discovery-candidates.schema.json@@ -5,7 +5,9 @@"workbenchRecordDiscoveryCandidatesInput": {"type": "object","properties": {- "scanId": { "type": "string", "pattern": "\\S" },+ "scanId": {+ "$ref": "codex-security://schemas/definitions/discovery-candidate.schema.json#/$defs/nonEmptyText"+ },"candidates": {"type": "array","items": {@@ -19,11 +21,10 @@"workbenchListCandidatesInput": {"type": "object","properties": {- "scanId": { "type": "string", "pattern": "\\S" },- "cursor": {- "type": "string",- "pattern": "^(?:0|[1-9][0-9]*)$"+ "scanId": {+ "$ref": "codex-security://schemas/definitions/discovery-candidate.schema.json#/$defs/nonEmptyText"},+ "cursor": { "type": "string", "pattern": "^(?:0|[1-9][0-9]*)$" },"limit": { "type": "integer", "minimum": 1, "maximum": 1000 }},"required": ["scanId"],diff --git a/plugins/codex-security/schemas/tools/review-items.schema.json b/plugins/codex-security/schemas/tools/review-items.schema.jsonindex f94e37db6..04496b827 100644--- a/plugins/codex-security/schemas/tools/review-items.schema.json+++ b/plugins/codex-security/schemas/tools/review-items.schema.json@@ -24,15 +24,8 @@"handoffClaimToken": {"$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},- "cursor": {- "type": "string",- "pattern": "^(?:0|[1-9][0-9]*)$"- },- "limit": {- "type": "integer",- "minimum": 1,- "maximum": 1000- }+ "cursor": { "type": "string", "pattern": "^(?:0|[1-9][0-9]*)$" },+ "limit": { "type": "integer", "minimum": 1, "maximum": 1000 }},"required": ["scanId"],"additionalProperties": falsediff --git a/plugins/codex-security/schemas/tools/scan-draft.schema.json b/plugins/codex-security/schemas/tools/scan-draft.schema.jsonindex 283925401..c22d37577 100644--- a/plugins/codex-security/schemas/tools/scan-draft.schema.json+++ b/plugins/codex-security/schemas/tools/scan-draft.schema.json@@ -2,6 +2,7 @@"$schema": "https://json-schema.org/draft/2020-12/schema","$id": "codex-security://schemas/tools/scan-draft.schema.json","title": "Codex Security semantic scan draft",+ "$ref": "#/$defs/scanDraftInput","$defs": {"text": {"$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"@@ -9,7 +10,7 @@"textList": {"type": "array","items": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"}},"scanId": {@@ -26,18 +27,12 @@"type": "object","properties": {"path": {- "$ref": "#/$defs/repositoryPath"- },- "startLine": {- "type": "integer",- "minimum": 1- },- "endLine": {- "type": "integer",- "minimum": 1+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/repositoryPath"},+ "startLine": { "type": "integer", "minimum": 1 },+ "endLine": { "type": "integer", "minimum": 1 },"role": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"}},"required": ["path", "startLine"],@@ -46,14 +41,8 @@"identity": {"type": "object","properties": {- "anchor": {- "type": "string",- "pattern": "^[a-z0-9][a-z0-9._/-]*$"- },- "instance": {- "type": "string",- "pattern": "^[a-z0-9][a-z0-9._/-]*$"- }+ "anchor": { "type": "string", "pattern": "^[a-z0-9][a-z0-9._/-]*$" },+ "instance": { "type": "string", "pattern": "^[a-z0-9][a-z0-9._/-]*$" }},"required": ["anchor"],"additionalProperties": true@@ -64,22 +53,18 @@"level": {"enum": ["critical", "high", "medium", "low", "informational"]},- "score": {- "type": "number",- "minimum": 0,- "maximum": 10- },+ "score": { "type": "number", "minimum": 0, "maximum": 10 },"scoringSystem": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"vector": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"rationale": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"changeConditions": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"}},"required": ["level"],@@ -88,11 +73,9 @@"confidence": {"type": "object","properties": {- "level": {- "enum": ["high", "medium", "low"]- },+ "level": { "enum": ["high", "medium", "low"] },"rationale": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"}},"required": ["level", "rationale"],@@ -102,12 +85,12 @@"type": "object","properties": {"category": {- "$ref": "#/$defs/text",- "description": "The actual primary broken security control, not a CWE identifier."+ "description": "The actual primary broken security control, not a CWE identifier.",+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"cwe": {- "$ref": "#/$defs/textList",- "description": "Copy the reviewed candidate's exact cwe_ids array. Use an empty array when no CWE is established; do not invent one."+ "description": "Copy the reviewed candidate's exact cwe_ids array. Use an empty array when no CWE is established; do not invent one.",+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"}},"required": ["category", "cwe"],@@ -116,36 +99,27 @@"codeEvidence": {"type": "object","properties": {- "id": {- "type": "string",- "pattern": "^[a-z0-9][a-z0-9._/-]*$"- },+ "id": { "type": "string", "pattern": "^[a-z0-9][a-z0-9._/-]*$" },"label": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"path": {- "$ref": "#/$defs/repositoryPath"- },- "startLine": {- "type": "integer",- "minimum": 1- },- "endLine": {- "type": "integer",- "minimum": 1+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/repositoryPath"},+ "startLine": { "type": "integer", "minimum": 1 },+ "endLine": { "type": "integer", "minimum": 1 },"language": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"role": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"code": {- "$ref": "#/$defs/text",- "description": "The genuine, nonempty source snippet at this evidence location."+ "description": "The genuine, nonempty source snippet at this evidence location.",+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"explanation": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"}},"required": ["id", "label", "path", "startLine", "code", "explanation"],@@ -155,10 +129,10 @@"type": "object","properties": {"id": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"code": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"}},"required": ["id", "code"],@@ -167,19 +141,19 @@"findingAssessment": {"anyOf": [{- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},{"type": "object","properties": {"level": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"rationale": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"why": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"}},"additionalProperties": true@@ -189,31 +163,31 @@"textOrSummary": {"anyOf": [{- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},{"type": "object","properties": {"summary": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"source": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"sink": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"outcome": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"transformations": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"evidenceRefs": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"evidence_refs": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"}},"additionalProperties": true@@ -223,37 +197,37 @@"findingReachability": {"anyOf": [{- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},{"type": "object","properties": {"summary": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"attacker": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"entrypoint": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"source": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"sink": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"outcome": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"preconditions": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"evidenceRefs": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"evidence_refs": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"}},"additionalProperties": true@@ -264,64 +238,58 @@"type": "object","properties": {"assertions": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"counterEvidence": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"evidence": {"anyOf": [{- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},{- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"}]},"evidenceRefs": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"evidence_refs": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"limitations": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"method": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"status": {"anyOf": [{- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},- {- "type": "null"- }+ { "type": "null" }]},"summary": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"disposition": {"anyOf": [{- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},- {- "type": "null"- }+ { "type": "null" }]},"result": {"anyOf": [{- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},- {- "type": "null"- }+ { "type": "null" }]}},@@ -331,63 +299,59 @@"type": "object","properties": {"assumptions": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"blindspots": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"controls": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"dataFlow": {- "$ref": "#/$defs/textOrSummary"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textOrSummary"},"data_flow": {- "$ref": "#/$defs/textOrSummary"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textOrSummary"},"dataflow": {- "$ref": "#/$defs/textOrSummary"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textOrSummary"},"evidenceRefs": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"evidence_refs": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"impact": {"anyOf": [{- "$ref": "#/$defs/findingAssessment"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/findingAssessment"},- {- "type": "null"- }+ { "type": "null" }]},"likelihood": {"anyOf": [{- "$ref": "#/$defs/findingAssessment"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/findingAssessment"},- {- "type": "null"- }+ { "type": "null" }]},"limitations": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"preconditions": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"reachability": {- "$ref": "#/$defs/findingReachability"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/findingReachability"},"steps": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"summary": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"}},"additionalProperties": true@@ -404,28 +368,28 @@"description": "A stable lowercase vulnerability-family slug, such as prototype-pollution.json-patch; a CWE is taxonomy, not a rule ID."},"identity": {- "$ref": "#/$defs/identity"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/identity"},"title": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"summary": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"severity": {- "$ref": "#/$defs/severity"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/severity"},"confidence": {- "$ref": "#/$defs/confidence"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/confidence"},"taxonomy": {- "$ref": "#/$defs/taxonomy"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/taxonomy"},"locations": {- "type": "array","minItems": 1,+ "type": "array","items": {- "$ref": "#/$defs/location"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/location"}},"writeup": {@@ -442,34 +406,34 @@"codeEvidence": {"type": "array","items": {- "$ref": "#/$defs/codeEvidence"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/codeEvidence"}},"code_evidence": {"type": "array","items": {- "$ref": "#/$defs/legacyCodeEvidence"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/legacyCodeEvidence"}},"rootCause": {"anyOf": [{- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},{"type": "object","properties": {"summary": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"code": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"language": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"evidenceRefs": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"}},"required": ["summary"],@@ -480,25 +444,25 @@"root_cause": {"anyOf": [{- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},{"type": "object","properties": {"summary": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"code": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"language": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"evidenceRefs": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"evidence_refs": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"}},"additionalProperties": true@@ -506,33 +470,29 @@]},"remediation": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"validation": {"anyOf": [{- "$ref": "#/$defs/findingValidation"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/findingValidation"},- {- "type": "null"- }+ { "type": "null" }]},"attackPath": {"anyOf": [{- "$ref": "#/$defs/findingAttackPath"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/findingAttackPath"},- {- "type": "null"- }+ { "type": "null" }]},"remediationTests": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"preventiveControls": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"provenance": {"type": "object",@@ -540,7 +500,7 @@"sourceFindingIds": {"type": "array","items": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"uniqueItems": true,"description": "Host-provided source finding references represented by this Deep reduction. Preserve every assigned reference exactly once."@@ -551,10 +511,11 @@"type": "object","properties": {"id": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"finding": {"type": "object",+ "properties": {},"additionalProperties": true}},@@ -564,8 +525,8 @@"description": "Original source payloads retained by the host for lossless semantic merges."},"source": {- "$ref": "#/$defs/text",- "description": "The actual finding producer. Use local_plugin only for a finding discovered by this plugin."+ "description": "The actual finding producer. Use local_plugin only for a finding discovered by this plugin.",+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"}},"required": ["source"],@@ -573,6 +534,7 @@},"extensions": {"type": "object",+ "properties": {},"additionalProperties": true}},@@ -595,49 +557,48 @@"includePaths": false,"excludePaths": false,"summary": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"artifactsReviewed": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"runtimeStatus": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"validationMode": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"context": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"limitations": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"}},"additionalProperties": true},"threatModel": {- "description": "Retained threat-model content. Existing structured models remain supported; Markdown documents preserve their complete original body.","anyOf": [{"type": "object","properties": {"summary": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"assets": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"trustBoundaries": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"attackerCapabilities": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"securityObjectives": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"assumptions": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"}},"required": ["summary"],@@ -646,37 +607,26 @@{"type": "object","properties": {- "format": {- "const": "markdown"- },+ "format": { "const": "markdown" },"content": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"scope": {"type": "object",- "description": "The modeled source scope, which may differ from the scan scope. Omit when unknown.","properties": {"includePaths": {"type": "array",- "items": {- "type": "string",- "minLength": 1- }+ "items": { "type": "string", "minLength": 1 }},"excludePaths": {"type": "array",- "items": {- "type": "string",- "minLength": 1- }+ "items": { "type": "string", "minLength": 1 }},- "summary": {- "type": "string",- "minLength": 1- }+ "summary": { "type": "string", "minLength": 1 }},"required": ["includePaths"],- "additionalProperties": true+ "additionalProperties": true,+ "description": "The modeled source scope, which may differ from the scan scope. Omit when unknown."},"origin": {"enum": ["generated", "provided", "reconciled", "recovered"]@@ -685,28 +635,26 @@"required": ["format", "content"],"additionalProperties": true}- ]+ ],+ "description": "Retained threat-model content. Existing structured models remain supported; Markdown documents preserve their complete original body."},"surface": {"type": "object","properties": {- "id": {- "type": "string",- "pattern": "^[a-z0-9][a-z0-9._/-]*$"- },+ "id": { "type": "string", "pattern": "^[a-z0-9][a-z0-9._/-]*$" },"label": {- "$ref": "#/$defs/text",- "description": "The meaningful name of the reviewed security surface."+ "description": "The meaningful name of the reviewed security surface.",+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"disposition": {- "description": "The evidence-supported review result for this surface.","enum": ["reported","no_issue_found","rejected","not_applicable","needs_follow_up"- ]+ ],+ "description": "The evidence-supported review result for this surface."},"receiptRefs": {"type": "array",@@ -717,10 +665,10 @@}},"riskArea": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"notes": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"}},"required": ["label", "disposition"],@@ -737,14 +685,14 @@"excludePaths": false,"receiptRefs": false,"completeness": {- "description": "Use partial if any work is deferred or any surface needs follow-up; use complete only when no such work remains.",- "enum": ["complete", "partial", "unknown"]+ "enum": ["complete", "partial", "unknown"],+ "description": "Use partial if any work is deferred or any surface needs follow-up; use complete only when no such work remains."},"inventoryStrategy": false,"surfaces": {"type": "array","items": {- "$ref": "#/$defs/surface"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/surface"}},"explicitExclusions": {@@ -753,10 +701,10 @@"type": "object","properties": {"pattern": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"reason": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"}},"required": ["pattern", "reason"],@@ -764,66 +712,63 @@}},"deferred": {- "description": "Each supplied id identifies one task and must be unique within this draft. Reuse saved IDs in later updates.","type": "array","items": {"type": "object","properties": {"id": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"candidateId": {"$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/candidateId"},"reason": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"paths": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"},"surfaceIds": {- "$ref": "#/$defs/textList"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/textList"}},"required": ["reason"],"additionalProperties": true- }+ },+ "description": "Each supplied id identifies one task and must be unique within this draft. Reuse saved IDs in later updates."},"resolvedDeferred": {- "description": "On final Standard or diff drafts, close generic tasks by saved ID and completion reason. Reuse saved surface IDs for updates. Candidate tasks need findings or dispositions; redundant closure entries for those outcomes are ignored.","type": "array","items": {"type": "object","properties": {"id": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"reason": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"}},- "required": [- "id",- "reason"- ],+ "required": ["id", "reason"],"additionalProperties": false- }+ },+ "description": "On final Standard or diff drafts, close generic tasks by saved ID and completion reason. Reuse saved surface IDs for updates. Candidate tasks need findings or dispositions; redundant closure entries for those outcomes are ignored."},"openQuestions": {"type": "array","items": {"anyOf": [{- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},{"type": "object","properties": {"question": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"},"followUpPrompt": {- "$ref": "#/$defs/text"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/nonEmptyText"}},"required": ["question"],@@ -849,25 +794,25 @@"description": "Set false to save progress without declaring this worker or parent audit finished. Omit or set true only for the terminal result. Put provisional candidates in coverage.deferred, not findings."},"scanId": {- "$ref": "#/$defs/scanId"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/scanId"},"handoffClaimToken": {- "$ref": "#/$defs/handoffClaimToken"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/handoffClaimToken"},"scope": {- "$ref": "#/$defs/scope"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/scope"},"threatModel": {- "$ref": "#/$defs/threatModel"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/threatModel"},"findings": {"type": "array","items": {- "$ref": "#/$defs/finding"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/finding"}},"coverage": {- "$ref": "#/$defs/coverage"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/coverage"}},"required": ["scanId", "findings", "coverage"],@@ -877,15 +822,14 @@"type": "object","properties": {"scanId": {- "$ref": "#/$defs/scanId"+ "$ref": "codex-security://schemas/definitions/artifact-common.schema.json#/$defs/scanId"},"handoffClaimToken": {- "$ref": "#/$defs/handoffClaimToken"+ "$ref": "codex-security://schemas/tools/scan-draft.schema.json#/$defs/handoffClaimToken"}},"required": ["scanId"],"additionalProperties": false}- },- "$ref": "#/$defs/scanDraftInput"+ }}diff --git a/sdk/typescript/tests-ts/plugin-finding-detail-contract.test.ts b/sdk/typescript/tests-ts/plugin-finding-detail-contract.test.tsindex 75966a531..5162159b4 100644--- a/sdk/typescript/tests-ts/plugin-finding-detail-contract.test.ts+++ b/sdk/typescript/tests-ts/plugin-finding-detail-contract.test.ts@@ -1,6 +1,6 @@import { join } from "node:path";import { describe, expect, test } from "bun:test";-import Ajv, { type ValidateFunction } from "ajv";+import type { ValidateFunction } from "ajv";import Ajv2020 from "ajv/dist/2020.js";import { PLUGIN_ROOT } from "./plugin-root.js";import { readJson as readJsonFile } from "./support/json.js";@@ -157,7 +157,7 @@ describe("bundled plugin finding detail contracts", () => {);expect(tool).toBeDefined();- const validator = new Ajv({ strict: false });+ const validator = new Ajv2020({ strict: false });validator.addFormat("uuid", /^[0-9a-f-]{36}$/iu);const validate = validator.compile(tool!["inputSchema"] as JsonObject);