Skip to content

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

refactor(schemas): define compact artifact contracts in Zod (#1575)

Michael D'Angelo65c46ead931d
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 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 validation
commands.
+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 finding
normalization from the plugin source into the SDK. Edit the plugin helper, then
regenerate 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.json
index 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.mjs
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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 = z
path: 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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": false
diff --git a/plugins/codex-security/schemas/tools/scan-draft.schema.json b/plugins/codex-security/schemas/tools/scan-draft.schema.json
index 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.ts
index 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);