fix(artifacts): keep saved findings consistent through recovery

plugins/codex-security/mcp-app/tests/scan-draft-recovery-fixture.ts

@@ -36,11 +36,33 @@ export async function recordCodexSecurityScanDraft(
     input,
     async (args: string[]) => {
       const draft = await readJson(args[args.indexOf("--draft-path") + 1]);
-      const rawContents = await fs.readFile(
+      let rawContents = await fs.readFile(
         args[args.indexOf("--checkpoint-path") + 1],
         "utf8",
       );
       const checkpoint = JSON.parse(rawContents);
+      const { complete, scope, threatModel } = draft.manifest.scan;
+      const projected = {
+        scanId: checkpoint.scanId,
+        ...(complete === undefined ? {} : { complete }),
+        ...(scope === undefined ? {} : { scope }),
+        ...(threatModel === undefined ? {} : { threatModel }),
+        findings: draft.findings.findings,
+        coverage: draft.coverage,
+      };
+      if (context.mode === "deep") {
+        const head = await readJson(context.root, "checkpoint-head.json").catch(
+          (error) => {
+            if (error.code !== "ENOENT") throw error;
+            return undefined;
+          },
+        );
+        checkpoint.publication = {
+          previousCheckpoint: head?.checkpoint ?? null,
+          previousInputCheckpoint: head?.inputCheckpoint ?? null,
+        };
+        rawContents = JSON.stringify(checkpoint);
+      }
       const rawName =
         createHash("sha256").update(rawContents).digest("hex") + ".json";
       await replaceArtifactText(
@@ -51,16 +73,23 @@ export async function recordCodexSecurityScanDraft(
         ),
         rawContents,
       );
-      const { complete, scope, threatModel } = draft.manifest.scan;
       await draftApi.saveScanDraftCheckpoint(
         { ...context, layout: "worker" },
+        projected,
+        false,
+      );
+      await replaceArtifactJson(
+        await artifactDestination(
+          context,
+          ["checkpoint-head.json"],
+          "scan checkpoint head",
+        ),
         {
-          scanId: checkpoint.scanId,
-          ...(complete === undefined ? {} : { complete }),
-          ...(scope === undefined ? {} : { scope }),
-          ...(threatModel === undefined ? {} : { threatModel }),
-          findings: draft.findings.findings,
-          coverage: draft.coverage,
+          checkpoint:
+            createHash("sha256")
+              .update(JSON.stringify(projected))
+              .digest("hex") + ".json",
+          ...(checkpoint.publication ? { inputCheckpoint: rawName } : {}),
         },
       );
       for (const [key, name] of [
@@ -182,3 +211,23 @@ export const surfaceDisposition = ({
   id: string;
   disposition: string;
 }) => ({ id, disposition });
+
+/** Stop after the admitted raw checkpoint and before the projected checkpoint. */
+export async function interruptDraftAfterRaw(action: () => Promise<unknown>) {
+  const rename = fs.rename;
+  let checkpoints = 0;
+  fs.rename = async (source, destination) => {
+    if (
+      path.basename(path.dirname(String(destination))) === "checkpoints" &&
+      ++checkpoints === 2
+    )
+      throw new Error("interrupted projected checkpoint");
+    return rename(source, destination);
+  };
+  try {
+    await assert.rejects(action(), /interrupted projected checkpoint/);
+    assert.equal(checkpoints, 2);
+  } finally {
+    fs.rename = rename;
+  }
+}

plugins/codex-security/mcp-app/tests/scan-identity-recovery-fixture.ts

@@ -0,0 +1,109 @@
+import { execFile } from "node:child_process";
+import { readdir, utimes } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import type { draftFixture } from "./scan-draft-recovery-fixture.ts";
+
+const execFileAsync = promisify(execFile);
+export type FixtureFinding = Record<string, unknown> & {
+  title: string;
+  summary: string;
+  severity: { level: string };
+  locations: Array<{ path: string; startLine: number }>;
+  provenance: Record<string, unknown>;
+  extensions?: Record<string, unknown>;
+  identity?: { anchor?: string; instance?: string; [key: string]: unknown };
+};
+export type RecoveredFinding = FixtureFinding & {
+  identity: { anchor: string; instance?: string; [key: string]: unknown };
+  findingId: string;
+};
+export type DraftFixture = ReturnType<typeof draftFixture>;
+export const finding = (
+  title: string,
+  metadata: Record<string, unknown> = {},
+): FixtureFinding => ({
+  ruleId: "fixture.review",
+  title,
+  summary: "Synthetic saved evidence must retain its identity.",
+  severity: { level: "low" },
+  confidence: { level: "high", rationale: "Synthetic persistence fixture." },
+  taxonomy: { category: "other", cwe: [] },
+  locations: [{ path: "src/example.py", startLine: 1 }],
+  remediation: "Complete the review.",
+  provenance: { source: "local_plugin" },
+  ...metadata,
+});
+
+export async function recoverAndFinalize(
+  normal: DraftFixture,
+  recovered: DraftFixture,
+  workers: Record<string, unknown>[] = [],
+  details = false,
+  replay = false,
+  provenanceDetails = false,
+  source: "saved" | "published" = "saved",
+): Promise<{
+  normal: RecoveredFinding[];
+  recovered: RecoveredFinding[];
+  warnings: unknown[];
+  historySummaries: string[];
+  preservedIdentities: unknown[][];
+  normalCoverage: Record<string, unknown>;
+  recoveredCoverage: Record<string, unknown>;
+}> {
+  const { stdout } = await execFileAsync(
+    process.env.PYTHON?.trim() || "python3",
+    [
+      "-c",
+      `import json,sys
+from pathlib import Path
+sys.path.insert(0,sys.argv[1])
+from workbench_saved_results import merge_saved_results
+from finalize_scan_contract import _prepare_scan_finalization
+normal,recovered=map(Path,sys.argv[2:4])
+scan_id=sys.argv[4]
+manifest=json.loads((normal/'scan-manifest.json').read_text())
+coverage=json.loads((normal/'coverage.json').read_text())
+binding={'status':'failed','allowedTargetKinds':[manifest['scan']['target']['kind']],'target':manifest['scan']['target'],'scope':manifest['scan']['scope'],'coverageMode':coverage['mode']}
+warnings=[]
+recovery=merge_saved_results(recovered,scan_id,binding,json.loads(sys.argv[5]),warnings,stopped=True,reason='Synthetic interruption',scan_mode=sys.argv[10]) if sys.argv[9]=='saved' else tuple(json.loads((recovered/name).read_text()) for name in ['scan-manifest.json','findings.json','coverage.json'])
+if json.loads(sys.argv[7]):
+ replayed=merge_saved_results(recovered,scan_id,binding,json.loads(sys.argv[5]),[],stopped=True,reason='Synthetic interruption',frozen_source_digests=recovery[0]['scan']['preservedSources'],scan_mode=sys.argv[10])
+ assert replayed == recovery, 'Frozen recovery changed the retained documents'
+ordinary=(manifest,json.loads((normal/'findings.json').read_text()),coverage)
+results=[]
+preserved_identities=[]
+for root,documents in [(normal,ordinary),(recovered,recovery)]:
+ documents[0]['scan'].update(id=scan_id,producer={'name':'codex-security-plugin','version':'0.1.0'},status='failed',startedAt='2026-05-31T18:00:00Z',completedAt='2026-05-31T18:09:00Z')
+ for document in documents[1:]: document['scanId']=scan_id
+ prepared=_prepare_scan_finalization(root,completion_warnings=warnings,draft_documents=documents)
+ preserved_identities.append([row.get('provenance',{}).get('preservedIdentity') for row in prepared[3]['findings']])
+ results.append([{'title':row['title'],'identity':row['identity'],'fingerprints':row['fingerprints'],'findingId':row['findingId'],'occurrenceId':row['occurrenceId'],'workerMetadata':row.get('provenance',{}).get('workerId'),**({'evidenceProvenance':{key:row.get('provenance',{}).get(key,[]) for key in ['sourceFindingIds','sourceFindings','previousFindings','originalCandidates']}} if json.loads(sys.argv[8]) else {}),**({'summary':row['summary'],'locations':row['locations'],'severity':row['severity'],'candidateMetadata':{'provenance':row.get('provenance',{}).get('candidateId'),'extensions':row.get('extensions')}} if json.loads(sys.argv[6]) else {})} for row in prepared[3]['findings']])
+print(json.dumps({'normal':results[0],'recovered':results[1],'warnings':warnings,'normalCoverage':ordinary[2],'recoveredCoverage':recovery[2],'preservedIdentities':preserved_identities,'historySummaries':[previous.get('summary') for row in recovery[1]['findings'] for previous in row.get('provenance',{}).get('previousFindings',[]) if isinstance(previous,dict)]}))`,
+      fileURLToPath(new URL("../../scripts", import.meta.url)),
+      normal.root,
+      recovered.root,
+      normal.context.scanId!,
+      JSON.stringify(workers),
+      JSON.stringify(details),
+      JSON.stringify(replay),
+      JSON.stringify(provenanceDetails),
+      source,
+      normal.context.mode!,
+    ],
+  );
+  return JSON.parse(stdout);
+}
+
+export async function dateDraftFiles(
+  root: string,
+  time: number,
+): Promise<void> {
+  for (const entry of await readdir(root, { withFileTypes: true })) {
+    const target = path.join(root, entry.name);
+    if (entry.isDirectory()) await dateDraftFiles(target, time);
+    else await utimes(target, time, time);
+  }
+}

plugins/codex-security/mcp-app/tests/test_artifact_scan_draft.ts

@@ -268,19 +268,19 @@ try {
     "checkpoints",
     acceptedHead.checkpoint,
   );
-  assert.notEqual(
+  assert.equal(
     acceptedHeadDraft.complete,
     false,
-    "a rejected incomplete write must not become the authoritative checkpoint head",
+    "new late work must remain incomplete in the authoritative checkpoint",
   );
   assert.deepEqual(acceptedHeadDraft.findings, [finding]);
   const acceptedResult = await readJson(rejectedIncompleteRoot, "result.json");
   assert.equal(
     acceptedResult.coverage.deferred.some(
       (item: FixtureFinding) => item.candidateId === "late-incomplete-review",
     ),
-    false,
-    "a rejected incomplete write must not change the completed result",
+    true,
+    "new late work must survive alongside the completed candidate",
   );
 
   const deferredDoesNotRejectContext = await createWorkerContext(
@@ -2377,13 +2377,13 @@ try {
     ),
     [
       { anchor: "candidate-authored-instance", instance: "dss-147-a" },
-      { anchor: "candidate-authored-instance", instance: "dss-147-a" },
+      { anchor: "candidate-authored-instance", instance: "dss-147-a-2" },
       {
         anchor: "candidate-authored-instance",
         instance: "ledger-row-c",
       },
     ],
-    "duplicate stable instance sources remain collisions for finalization",
+    "generated instances avoid an existing authored identity",
   );
 
   const collisionFindings = [
@@ -2450,10 +2450,17 @@ try {
     assert.deepEqual(
       standardFindings.map((item: FixtureFinding) => item.identity),
       collisionCase.findings.map(
-        (item: FixtureFinding) =>
-          item.identity ?? collisionCase.originalIdentity,
+        (item: FixtureFinding, index) =>
+          item.identity ?? {
+            ...collisionCase.originalIdentity,
+            ...(index === 0
+              ? {}
+              : {
+                  instance: `${(collisionCase.originalIdentity as { instance?: string }).instance}-${index + 1}`,
+                }),
+          },
       ),
-      `${collisionCase.label} identity collisions retain the existing Standard shape`,
+      `${collisionCase.label} identities preserve authored values and split generated collisions`,
     );
     assert.deepEqual(
       standardFindings.map((item: FixtureFinding) => item.provenance),
@@ -2487,7 +2494,7 @@ try {
     assert.deepEqual(
       deepFindings.map((item: FixtureFinding) => item.provenance),
       collisionCase.findings.map((item: FixtureFinding, index) =>
-        index === 1 || index === 2
+        item.identity !== undefined && (index === 1 || index === 2)
           ? {
               ...item.provenance,
               preservedIdentity: collisionCase.originalIdentity,