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(mcp): use workbench for parent draft publication (#1487)

mldangelo-oai95b7f659121e
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 56ac7e563..01d011a04 100644
--- a/plugins/codex-security/mcp-app/src/artifact-scan-draft.ts
+++ b/plugins/codex-security/mcp-app/src/artifact-scan-draft.ts
@@ -64,12 +64,6 @@ interface SavedScanDraft {
attempt?: string;
}
-type PublishScanDraft = (
- draft: PreparedScanDraft,
- expectedDigest: string | undefined,
- checkpoint: ScanDraftInput,
-) => Promise<string[] | void>;
-
const schemaDocuments = [commonSchema, scanDraftDocument] as SchemaDocument[];
export const scanDraftInputSchema = loadArtifactZodSchema(
@@ -84,11 +78,11 @@ export const completedScanInputSchema = loadArtifactZodSchema(
"completedScanInput",
) as z.ZodType<CompletedScanInput>;
-/** Replace the three existing final-input documents without completing or sealing a scan. */
-export async function recordCodexSecurityScanDraft(
+/** Stage a parent draft, then publish it under the workbench completion lock. */
+export async function recordCodexSecurityScanDraftViaWorkbench(
context: ArtifactContext,
input: ScanDraftInput,
- publishDraft?: PublishScanDraft,
+ runWorkbench: RunArtifactWorkbench,
signal?: AbortSignal,
): Promise<ScanDraftResult> {
const parsed = parseScanDraft(input);
@@ -99,8 +93,6 @@ export async function recordCodexSecurityScanDraft(
"scan draft: terminal Deep drafts cannot resolve child deferred work.",
);
}
- if (finalDeepDraft && !publishDraft)
- await saveScanDraftCheckpoint(context, parsed);
for (;;) {
signal?.throwIfAborted();
@@ -108,10 +100,8 @@ export async function recordCodexSecurityScanDraft(
// Do not merge older review work into them.
const preserved = finalDeepDraft
? await preserveDeepThreatModel(context, parsed)
- : await preserveScanDraft(context, parsed, !publishDraft);
+ : await preserveScanDraft(context, parsed, false);
const reconciled = preserved.input;
- if (finalDeepDraft && !publishDraft && reconciled !== parsed)
- await saveScanDraftCheckpoint(context, reconciled);
const contract = requireObject(
context.targetContract,
"scan draft: authoritative target contract",
@@ -145,129 +135,73 @@ export async function recordCodexSecurityScanDraft(
...(hardening === undefined ? {} : { hardening }),
};
+ const draft = {
+ findings: { findings },
+ coverage,
+ manifest: { scan: manifestScan },
+ };
+ const checkpoint = finalDeepDraft ? reconciled : parsed;
+ const expectedDigest = preserved.previousDigest;
+ let documentWarnings: string[] | undefined;
+ const checkpointPath = await artifactDestination(
+ context,
+ ["drafts", `${randomUUID()}.checkpoint.json`],
+ "staged scan checkpoint",
+ );
+ const draftPath = await artifactDestination(
+ context,
+ ["drafts", `${randomUUID()}.json`],
+ "staged scan draft",
+ );
try {
- const draft = {
- findings: { findings },
- coverage,
- manifest: { scan: manifestScan },
- };
- let documentWarnings: string[] | void = undefined;
- if (publishDraft) {
- documentWarnings = await publishDraft(
- draft,
- preserved.previousDigest,
- finalDeepDraft ? reconciled : parsed,
- );
- } else {
- const destinations = await Promise.all([
- artifactDestination(
- context,
- ["findings.json"],
- "scan draft findings",
- ),
- artifactDestination(
- context,
- ["coverage.json"],
- "scan draft coverage",
- ),
- artifactDestination(
- context,
- ["scan-manifest.json"],
- "scan draft manifest",
- ),
- ]);
- await replaceArtifactJson(destinations[0], { findings });
- await replaceArtifactJson(destinations[1], coverage);
- await replaceArtifactJson(destinations[2], { scan: manifestScan });
- const warning = await saveThreatModelDocument(
- context,
- reconciled.threatModel,
- );
- if (warning !== undefined) documentWarnings = [warning];
+ const { handoffClaimToken: _claim, ...snapshot } = checkpoint;
+ await Promise.all([
+ replaceArtifactJson(checkpointPath, snapshot),
+ replaceArtifactJson(draftPath, draft),
+ ]);
+ const arguments_ = [
+ "write-scan-draft",
+ "--scan-id",
+ input.scanId,
+ "--draft-path",
+ draftPath,
+ "--checkpoint-path",
+ checkpointPath,
+ ];
+ if (expectedDigest !== undefined) {
+ arguments_.push("--expected-draft-digest", expectedDigest);
+ }
+ if (context.handoffClaimToken) {
+ arguments_.push("--claim-token", context.handoffClaimToken);
}
- return {
- scanId: reconciled.scanId,
- findingCount: findings.length,
- surfaceCount: (coverage.surfaces as unknown[]).length,
- coverage,
- operation: "replace",
- status: "draft_written",
- ...(documentWarnings?.length ? { warnings: documentWarnings } : {}),
- };
- } catch (error) {
- if (!isScanDraftConflict(error)) throw error;
- signal?.throwIfAborted();
- }
- }
-}
-
-/** Stage a parent draft, then publish it under the workbench completion lock. */
-export async function recordCodexSecurityScanDraftViaWorkbench(
- context: ArtifactContext,
- input: ScanDraftInput,
- runWorkbench: RunArtifactWorkbench,
- signal?: AbortSignal,
-): Promise<ScanDraftResult> {
- return recordCodexSecurityScanDraft(
- context,
- input,
- async (draft, expectedDigest, checkpoint) => {
- const checkpointPath = await artifactDestination(
- context,
- ["drafts", `${randomUUID()}.checkpoint.json`],
- "staged scan checkpoint",
- );
- const draftPath = await artifactDestination(
- context,
- ["drafts", `${randomUUID()}.json`],
- "staged scan draft",
- );
try {
- const { handoffClaimToken: _claim, ...snapshot } = checkpoint;
- await Promise.all([
- replaceArtifactJson(checkpointPath, snapshot),
- replaceArtifactJson(draftPath, draft),
- ]);
- const arguments_ = [
- "write-scan-draft",
- "--scan-id",
- input.scanId,
- "--draft-path",
- draftPath,
- "--checkpoint-path",
- checkpointPath,
- ];
- if (expectedDigest !== undefined) {
- arguments_.push("--expected-draft-digest", expectedDigest);
- }
- if (context.handoffClaimToken) {
- arguments_.push("--claim-token", context.handoffClaimToken);
- }
- try {
- const result = await runWorkbench(arguments_);
- return Array.isArray(result?.warnings)
- ? result.warnings.filter(
- (warning): warning is string => typeof warning === "string",
- )
- : undefined;
- } catch (error) {
- if (!workbenchScanDraftConflict(error)) throw error;
- throw Object.assign(
- new Error(
- "The canonical scan draft changed while this checkpoint was being reconciled.",
- ),
- { code: "scan_draft_conflict" },
- );
- }
- } finally {
- await Promise.all([
- fs.rm(checkpointPath, { force: true }),
- fs.rm(draftPath, { force: true }),
- ]);
+ const result = await runWorkbench(arguments_);
+ documentWarnings = Array.isArray(result?.warnings)
+ ? result.warnings.filter(
+ (warning): warning is string => typeof warning === "string",
+ )
+ : undefined;
+ } catch (error) {
+ if (!workbenchScanDraftConflict(error)) throw error;
+ signal?.throwIfAborted();
+ continue;
}
- },
- signal,
- );
+ } finally {
+ await Promise.all([
+ fs.rm(checkpointPath, { force: true }),
+ fs.rm(draftPath, { force: true }),
+ ]);
+ }
+ return {
+ scanId: reconciled.scanId,
+ findingCount: findings.length,
+ surfaceCount: (coverage.surfaces as unknown[]).length,
+ coverage,
+ operation: "replace",
+ status: "draft_written",
+ ...(documentWarnings?.length ? { warnings: documentWarnings } : {}),
+ };
+ }
}
/** Save a Standard worker draft in its assigned output directory. */
@@ -1486,14 +1420,6 @@ function draftDigest(
return digest.digest("hex");
}
-function isScanDraftConflict(error: unknown): boolean {
- return (
- error instanceof Error &&
- "code" in error &&
- error.code === "scan_draft_conflict"
- );
-}
-
function workbenchScanDraftConflict(error: unknown): boolean {
if (!(error instanceof Error)) return false;
const stderr =
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 67cf7c82a..8f1822b9e 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
@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
import { temporaryDirectory } from "./support/temporary-directories.ts";
import { readJson } from "./support/json.ts";
import assert from "node:assert/strict";
@@ -7,10 +8,77 @@ import path from "node:path";
import type { TestContext } from "node:test";
import type { ScanDraftInput } from "../src/artifact-scan-draft.js";
import type { ArtifactContext } from "../src/artifact-io.js";
-import { importSource } from "./import-module.ts";
+import { importModule, importSource } from "./import-module.ts";
export const draftApi = await importSource("../src/artifact-scan-draft.ts", {
absWorkingDir: import.meta.dirname,
});
+
+const {
+ artifactDestination,
+ replaceArtifactJson,
+ replaceArtifactText,
+ saveThreatModelDocument,
+} = await importModule({
+ stdin: {
+ contents:
+ 'export * from "./artifact-io.ts"; export * from "./threat-model-document.ts";',
+ resolveDir: path.join(import.meta.dirname, "../src"),
+ },
+});
+
+// Unit publication boundary; real lock/binding behavior is covered by the workbench integration suite.
+export async function recordCodexSecurityScanDraft(
+ context: ArtifactContext,
+ input: unknown,
+) {
+ return draftApi.recordCodexSecurityScanDraftViaWorkbench(
+ context,
+ input,
+ async (args: string[]) => {
+ const draft = await readJson(args[args.indexOf("--draft-path") + 1]);
+ const rawContents = await fs.readFile(
+ args[args.indexOf("--checkpoint-path") + 1],
+ "utf8",
+ );
+ const checkpoint = JSON.parse(rawContents);
+ const rawName =
+ createHash("sha256").update(rawContents).digest("hex") + ".json";
+ await replaceArtifactText(
+ await artifactDestination(
+ context,
+ ["checkpoints", rawName],
+ "raw checkpoint",
+ ),
+ rawContents,
+ );
+ const { complete, scope, threatModel } = draft.manifest.scan;
+ await draftApi.saveScanDraftCheckpoint(
+ { ...context, layout: "worker" },
+ {
+ scanId: checkpoint.scanId,
+ ...(complete === undefined ? {} : { complete }),
+ ...(scope === undefined ? {} : { scope }),
+ ...(threatModel === undefined ? {} : { threatModel }),
+ findings: draft.findings.findings,
+ coverage: draft.coverage,
+ },
+ );
+ for (const [key, name] of [
+ ["findings", "findings.json"],
+ ["coverage", "coverage.json"],
+ ["manifest", "scan-manifest.json"],
+ ]) {
+ await replaceArtifactJson(
+ await artifactDestination(context, [name], "scan draft"),
+ draft[key],
+ );
+ }
+ const warning = await saveThreatModelDocument(context, threatModel);
+ return warning === undefined ? {} : { warnings: [warning] };
+ },
+ );
+}
+
export const scanId = "7b95abf2-dc04-47a9-9950-53b5c2057f49";
export const claimToken = "19bfba38-0913-4bd7-86ef-134e9a4d9a42";
@@ -70,7 +138,7 @@ export function draftFixture(root: string, layout: Layout) {
write: (input: ScanDraftInput) =>
layout === "worker"
? draftApi.recordCodexSecurityWorkerScanDraft(context, input)
- : draftApi.recordCodexSecurityScanDraft(context, input),
+ : recordCodexSecurityScanDraft(context, input),
read: async () =>
layout === "worker"
? (await readJson(root, "result.json")).coverage
@@ -91,12 +159,17 @@ export async function interruptDraftWrite(
action: () => Promise<unknown>,
) {
const rename = fs.rename;
+ let interrupted = false;
fs.rename = async (source, target) => {
- if (target === destination) throw new Error("interrupted draft write");
+ if (target === destination) {
+ interrupted = true;
+ throw new Error("interrupted draft write");
+ }
return rename(source, target);
};
try {
await assert.rejects(action(), /interrupted draft write/);
+ assert.equal(interrupted, true);
} finally {
fs.rename = rename;
}
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 242058145..ab020ec89 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
@@ -27,6 +27,7 @@ import {
claimToken,
draftApi,
draftFixture,
+ recordCodexSecurityScanDraft,
scanId,
surfaceDisposition,
} from "./scan-draft-recovery-fixture.ts";
@@ -34,7 +35,6 @@ import {
const {
completedScanInputSchema,
getCodexSecurityCompletedScan,
- recordCodexSecurityScanDraft,
recordCodexSecurityScanDraftViaWorkbench,
recordCodexSecurityWorkerScanDraft,
saveScanDraftCheckpoint,
@@ -515,11 +515,15 @@ try {
{ ...context, root: parentCheckpointRoot },
{ ...input, complete: false },
);
- const parentSnapshot = await readJson(
- parentCheckpointRoot,
- "checkpoints",
- (await readdir(path.join(parentCheckpointRoot, "checkpoints")))[0],
+ const parentSnapshots = await Promise.all(
+ (await readdir(path.join(parentCheckpointRoot, "checkpoints"))).map(
+ (name) => readJson(parentCheckpointRoot, "checkpoints", name),
+ ),
);
+ const parentSnapshot = parentSnapshots.find(
+ (snapshot) => !snapshot.findings[0].identity,
+ );
+ assert.ok(parentSnapshot);
assert.equal(parentSnapshot.handoffClaimToken, undefined);
assert.equal(parentSnapshot.complete, false);
assert.deepEqual(parentSnapshot.findings, [finding]);
@@ -1561,7 +1565,7 @@ try {
assert.deepEqual(await readdir(path.join(root, "drafts")), []);
let conflictAttempts = 0;
- const retried = await recordCodexSecurityScanDraft(
+ const retried = await recordCodexSecurityScanDraftViaWorkbench(
context,
input,
async () => {
@@ -1575,6 +1579,7 @@ try {
);
assert.equal(conflictAttempts, 10);
assert.equal(retried.status, "draft_written");
+ assert.deepEqual(await readdir(path.join(root, "drafts")), []);
const conflictAbort = new AbortController();
const abortedConflictAttempts = mock.fn(async () => {
@@ -1584,15 +1589,16 @@ try {
});
});
await assert.rejects(
- recordCodexSecurityScanDraft(
+ recordCodexSecurityScanDraftViaWorkbench(
context,
input,
abortedConflictAttempts,
conflictAbort.signal,
),
- /draft publication canceled/,
+ (error) => error === conflictAbort.signal.reason,
);
assert.equal(abortedConflictAttempts.mock.callCount(), 1);
+ assert.deepEqual(await readdir(path.join(root, "drafts")), []);
const monotonicRoot = path.join(root, "monotonic-final-draft");
await mkdir(monotonicRoot);
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 38181c09a..548b29c53 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
@@ -936,7 +936,12 @@ for (const layout of ["standard", "diff", "worker"] as const) {
}
for (const name of layout === "worker"
? ["result.json", "checkpoint-head.json"]
- : ["coverage.json", "scan-manifest.json", "findings.json"])
+ : [
+ "coverage.json",
+ "scan-manifest.json",
+ "findings.json",
+ "checkpoint-head.json",
+ ])
await utimes(path.join(f.root, name), 2, 2);
const before = new Set(await readdir(checkpoints));
const followUp = {
@@ -1012,12 +1017,18 @@ for (const layout of ["standard", "diff", "worker"] as const) {
assert.deepEqual((await f.read()).deferred, []);
assert.deepEqual((await f.read()).resolvedDeferred, [close(pending.id)]);
const checkpointRoot = path.join(f.root, "checkpoints");
- const originalClosures: [string, number][] = [];
+ const originalClosures: [string, number, Buffer, boolean][] = [];
for (const name of await readdir(checkpointRoot)) {
const file = path.join(checkpointRoot, name);
const saved = await readJson(file);
if (saved.coverage.resolvedDeferred?.length)
- originalClosures.push([file, (await stat(file)).mtimeMs]);
+ originalClosures.push([
+ file,
+ (await stat(file)).mtimeMs,
+ await readFile(file),
+ // Raw scopes forbid bound paths; normalized snapshots have them.
+ layout === "worker" || Array.isArray(saved.scope?.includePaths),
+ ]);
}
const reopened = {
...pending,
@@ -1030,11 +1041,12 @@ for (const layout of ["standard", "diff", "worker"] as const) {
assert.deepEqual(saved.deferred, [reopened]);
assert.deepEqual(saved.resolvedDeferred ?? [], []);
await fail(closing);
- for (const [file, modified] of originalClosures)
- assert.equal((await stat(file)).mtimeMs, modified);
+ for (const [file, modified, bytes, fixedTime] of originalClosures) {
+ assert.deepEqual(await readFile(file), bytes);
+ if (fixedTime) assert.equal((await stat(file)).mtimeMs, modified);
+ }
await f.write(f.draft({}, true));
- const accepted =
- destination === "result.json" || destination === "scan-manifest.json";
+ const accepted = layout !== "worker" || destination === "result.json";
assert.deepEqual((await f.read()).deferred, accepted ? [] : [reopened]);
await f.write(closing);
await f.write(f.draft({}, true));
diff --git a/plugins/codex-security/mcp-app/tests/test_threat_model_document.ts b/plugins/codex-security/mcp-app/tests/test_threat_model_document.ts
index 9de025692..4d4c9584f 100644
--- a/plugins/codex-security/mcp-app/tests/test_threat_model_document.ts
+++ b/plugins/codex-security/mcp-app/tests/test_threat_model_document.ts
@@ -15,11 +15,13 @@ import { join } from "node:path";
import { PassThrough, Writable } from "node:stream";
import { test } from "node:test";
import { importModule } from "./import-module.ts";
-import { draftFixture } from "./scan-draft-recovery-fixture.ts";
+import {
+ draftFixture,
+ recordCodexSecurityScanDraft,
+} from "./scan-draft-recovery-fixture.ts";
const pluginRoot = join(import.meta.dirname, "../../");
const {
- recordCodexSecurityScanDraft,
recordCodexSecurityScanDraftViaWorkbench,
recordCodexSecurityWorkerScanDraft,
saveThreatModelDocument,
@@ -48,91 +50,64 @@ const threatModel = {
};
for (const complete of [true, undefined]) {
- for (const publication of ["direct", "workbench"]) {
- test(`terminal Deep ${publication} drafts retain an omitted model (${complete})`, async () => {
- const root = await temporaryDirectory("threatmodel-deep-final-");
- try {
- const { context, draft } = draftFixture(root, "deep");
- context.pluginRoot = pluginRoot;
- const target = context.targetContract!.target as Record<
- string,
- unknown
- >;
- target.requiredSnapshotDigest =
- "codex-security-snapshot/v1:sha256:" + "a".repeat(64);
- await recordCodexSecurityScanDraft(context, {
- ...draft({ deferred: [{ reason: "Earlier unfinished review." }] }),
- threatModel,
- });
+ test(`terminal Deep drafts retain an omitted model (${complete})`, async () => {
+ const root = await temporaryDirectory("threatmodel-deep-final-");
+ try {
+ const { context, draft } = draftFixture(root, "deep");
+ context.pluginRoot = pluginRoot;
+ const target = context.targetContract!.target as Record<string, unknown>;
+ target.requiredSnapshotDigest =
+ "codex-security-snapshot/v1:sha256:" + "a".repeat(64);
+ await recordCodexSecurityScanDraft(context, {
+ ...draft({ deferred: [{ reason: "Earlier unfinished review." }] }),
+ threatModel,
+ });
+ assert.ok(
+ (await readFile(join(root, "threatmodel.md"), "utf8")).includes(
+ `Snapshot: ${target.requiredSnapshotDigest}`,
+ ),
+ );
+ // A final Deep result replaces old review documents without parsing them.
+ await writeFile(join(root, "findings.json"), "unfinished findings");
+ await writeFile(join(root, "coverage.json"), "unfinished coverage");
+ const replacement = {
+ format: "markdown",
+ content: "# Replacement model\n",
+ };
+ for (const model of [undefined, replacement]) {
+ const terminal = draft({}, true);
+ if (complete === undefined) delete terminal.complete;
+ if (model !== undefined) terminal.threatModel = model;
+ const expectedModel = model ?? threatModel;
+ const before = new Set(await readdir(join(root, "checkpoints")));
+ await recordCodexSecurityScanDraft(context, terminal);
+ const manifest = await readJson(root, "scan-manifest.json");
+ assert.deepEqual(manifest.scan.threatModel, expectedModel);
+ const checkpoints = await Promise.all(
+ (await readdir(join(root, "checkpoints")))
+ .filter((name) => !before.has(name))
+ .map(async (name) => await readJson(root, "checkpoints", name)),
+ );
+ assert.ok(checkpoints.length > 0);
+ for (const checkpoint of checkpoints) {
+ assert.notEqual(checkpoint.complete, false);
+ assert.deepEqual(checkpoint.threatModel, expectedModel);
+ assert.deepEqual(checkpoint.coverage.deferred, []);
+ }
+ const savedCoverage = await readJson(root, "coverage.json");
+ assert.deepEqual(savedCoverage.deferred, []);
assert.ok(
- (await readFile(join(root, "threatmodel.md"), "utf8")).includes(
- `Snapshot: ${target.requiredSnapshotDigest}`,
+ (await readFile(join(root, "threatmodel.md"), "utf8")).startsWith(
+ expectedModel.content,
),
);
- // A final Deep result replaces old review documents without parsing them.
- await writeFile(join(root, "findings.json"), "unfinished findings");
- await writeFile(join(root, "coverage.json"), "unfinished coverage");
- const replacement = {
- format: "markdown",
- content: "# Replacement model\n",
- };
- for (const model of [undefined, replacement]) {
- const terminal = draft({}, true);
- if (complete === undefined) delete terminal.complete;
- if (model !== undefined) terminal.threatModel = model;
- const expectedModel = model ?? threatModel;
- if (publication === "direct") {
- await recordCodexSecurityScanDraft(context, terminal);
- const manifest = await readJson(root, "scan-manifest.json");
- assert.deepEqual(manifest.scan.threatModel, expectedModel);
- const checkpoints = await Promise.all(
- (await readdir(join(root, "checkpoints"))).map(
- async (name) => await readJson(root, "checkpoints", name),
- ),
- );
- assert.ok(
- checkpoints.some(
- (checkpoint) =>
- checkpoint.complete !== false &&
- checkpoint.threatModel?.content === expectedModel.content &&
- checkpoint.coverage.deferred.length === 0,
- ),
- );
- const savedCoverage = await readJson(root, "coverage.json");
- assert.deepEqual(savedCoverage.deferred, []);
- assert.ok(
- (await readFile(join(root, "threatmodel.md"), "utf8")).startsWith(
- expectedModel.content,
- ),
- );
- } else {
- await recordCodexSecurityScanDraftViaWorkbench(
- context,
- terminal,
- async (args: string[]) => {
- const staged = await readJson(
- args[args.indexOf("--draft-path") + 1],
- );
- const checkpoint = await readJson(
- args[args.indexOf("--checkpoint-path") + 1],
- );
- assert.deepEqual(
- staged.manifest.scan.threatModel,
- expectedModel,
- );
- assert.deepEqual(checkpoint.threatModel, expectedModel);
- assert.deepEqual(staged.coverage.deferred, []);
- assert.deepEqual(staged.findings.findings, []);
- },
- );
- }
- assert.equal(terminal.threatModel, model);
- }
- } finally {
- await rm(root, { recursive: true, force: true });
+ assert.deepEqual((await readJson(root, "findings.json")).findings, []);
+ assert.equal(terminal.threatModel, model);
}
- });
- }
+ } finally {
+ await rm(root, { recursive: true, force: true });
+ }
+ });
}
for (const kind of ["working_tree", "commit", "range"]) {
@@ -201,26 +176,6 @@ test("terminal Deep model inheritance retries a changed canonical draft", async
}
});
-test("terminal Deep input remains checkpointed when reading the previous model fails", async () => {
- const root = await temporaryDirectory("threatmodel-deep-read-failure-");
- try {
- const { context, draft } = draftFixture(root, "deep");
- await writeFile(join(root, "scan-manifest.json"), "unfinished manifest");
- await assert.rejects(
- recordCodexSecurityScanDraft(context, draft({}, true)),
- /previous scan draft manifest/,
- );
- const checkpoints = await readdir(join(root, "checkpoints"));
- assert.equal(checkpoints.length, 1);
- const saved = await readJson(root, "checkpoints", checkpoints[0]);
- assert.equal(saved.complete, true);
- assert.deepEqual(saved.findings, []);
- assert.deepEqual(saved.coverage.deferred, []);
- } finally {
- await rm(root, { recursive: true, force: true });
- }
-});
-
test("model-only worker checkpoints save Markdown before findings and retain it on retry", async () => {
const root = await temporaryDirectory("threatmodel-worker-");
try {