OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security
TypeScript ai-securityapplication-securityclicode-scanningcodexcodex-securitycybersecuritydevsecopsnodejsnpmopenaisdksecuritytypescriptvulnerability-scanning
feat(scan): show current findings for each repository (#346)
ianw-oai8487e0938079
diff --git a/README.md b/README.mdindex c35caeebf..0b11ac5ea 100644--- a/README.md+++ b/README.md@@ -67,6 +67,9 @@ Scan history is stored in the Codex Security workbench state directory. If thatdirectory cannot be written, set `CODEX_SECURITY_STATE_DIR` to a writabledirectory outside the repository.+`findings list [repository]` shows open findings across a repository's scans+and identifies findings not confirmed in its latest scan.+`scans compare BEFORE_SCAN_ID AFTER_SCAN_ID` automatically matches findings byroot cause, reuses saved matches, and identifies new, persisting, reopened,resolved, or unknown findings. Missing findings remain unknown when coverage isdiff --git a/sdk/typescript/README.md b/sdk/typescript/README.mdindex bf53e453f..fbc0245f4 100644--- a/sdk/typescript/README.md+++ b/sdk/typescript/README.md@@ -53,6 +53,10 @@ Use `security.preflight()` to validate local inputs, `onWorkerStatus` and`onReconnect` to observe long-running scans, and an `AbortSignal` to cancel ascan.+Successful results include open repository findings in `repositoryFindings`,+when available; `findings` remains the current scan. Matching earlier findings+can make one additional model call, including with a scan cost limit.+Results can contain source excerpts, vulnerability details, and reproductionsteps. Keep result directories and saved reports outside the repository andlimit access to authorized reviewers.@@ -223,6 +227,7 @@ npx @openai/codex-security scans rerun SCAN_IDnpx @openai/codex-security scans match PREVIOUS_SCAN_ID CURRENT_SCAN_IDnpx @openai/codex-security scans match --allnpx @openai/codex-security scans compare PREVIOUS_SCAN_ID CURRENT_SCAN_ID+npx @openai/codex-security findings list /path/to/repositorynpx @openai/codex-security findings false-positive OCCURRENCE_ID --reason "The route already checks permissions"npx @openai/codex-security export /path/outside/repository/results --export-format sarif --output /path/outside/repository/results.sarifnpx @openai/codex-security export /path/outside/repository/results --export-format csv --output /path/outside/repository/findings.csvdiff --git a/sdk/typescript/_bundled_plugin/scripts/workbench_native_indexes.py b/sdk/typescript/_bundled_plugin/scripts/workbench_native_indexes.pyindex 80e825fe6..8ce2492bc 100644--- a/sdk/typescript/_bundled_plugin/scripts/workbench_native_indexes.py+++ b/sdk/typescript/_bundled_plugin/scripts/workbench_native_indexes.py@@ -47,9 +47,13 @@ def list_global_findings(return {"findings": [{+ "confirmedInLatestScan": row["confirmed_in_latest_scan"],"createdAt": row["created_at"],"findingId": row["finding_id"],+ "knownSince": row["known_since"],+ "knownScanIds": row["known_scan_ids"],"locationPath": row["location_path"],+ "matchedFindingIds": row["matched_finding_ids"],"occurrenceCount": row["occurrence_count"],"occurrenceId": row["occurrence_id"],"scanId": row["scan_id"],@@ -70,64 +74,117 @@ def list_global_findings(}-def _indexed_findings(connection: sqlite3.Connection) -> Iterator[sqlite3.Row]:- yield from connection.execute(+def _indexed_findings(connection: sqlite3.Connection) -> Iterator[dict[str, Any]]:+ parents: dict[tuple[str, str], tuple[str, str]] = {}++ def group(identity: tuple[str, str]) -> tuple[str, str]:+ while identity in parents:+ identity = parents[identity]+ return identity++ for match in connection.execute("""- WITH ranked_findings AS (- SELECT- occurrences.id AS occurrence_id,- occurrences.finding_id,- occurrences.severity,- occurrences.created_at,- scans.id AS scan_id,- scans.target_id,- targets.current_path AS target_path,- scans.scope,- MAX(scans.updated_at, COALESCE(triage.updated_at, '')) AS updated_at,- COALESCE(triage.status, 'open') AS status,- COUNT(*) OVER (- PARTITION BY scans.target_id, occurrences.finding_id- ) AS occurrence_count,- ROW_NUMBER() OVER (- PARTITION BY scans.target_id, occurrences.finding_id- ORDER BY occurrences.created_at DESC, occurrences.id DESC- ) AS occurrence_rank- FROM finding_occurrences AS occurrences- JOIN scans ON scans.id = occurrences.scan_id- JOIN security_targets AS targets ON targets.id = scans.target_id- LEFT JOIN finding_triage AS triage ON triage.occurrence_id = occurrences.id+ SELECT before_scans.target_id, before.finding_id AS before_finding_id,+ after.finding_id AS after_finding_id+ FROM scan_comparison_matches AS matches+ JOIN finding_occurrences AS before ON before.id = matches.before_occurrence_id+ JOIN scans AS before_scans ON before_scans.id = before.scan_id+ JOIN finding_occurrences AS after ON after.id = matches.after_occurrence_id+ JOIN scans AS after_scans ON after_scans.id = after.scan_id+ WHERE before_scans.target_id = after_scans.target_id+ """+ ):+ before = group((match["target_id"], match["before_finding_id"]))+ after = group((match["target_id"], match["after_finding_id"]))+ if before != after:+ parents[after] = before++ latest_scan_by_target = dict(+ connection.execute(+ "SELECT target_id, id FROM scans "+ "WHERE status = 'complete' ORDER BY started_at, id")+ )++ grouped: dict[tuple[str, str], list[sqlite3.Row]] = {}+ for row in connection.execute(+ """SELECT- selected_findings.*,+ occurrences.id AS occurrence_id,+ occurrences.finding_id,+ occurrences.severity,+ occurrences.created_at,+ scans.id AS scan_id,+ scans.started_at AS scan_started_at,+ scans.target_id,+ targets.current_path AS target_path,+ scans.scope,+ MAX(scans.updated_at, COALESCE(triage.updated_at, '')) AS updated_at,+ triage.status AS decision_status,+ triage.close_reason,+ triage.updated_at AS decision_updated_at,occurrences.title,occurrences.summary,(SELECT locations.relative_pathFROM finding_locations AS locations- WHERE locations.occurrence_id = selected_findings.occurrence_id+ WHERE locations.occurrence_id = occurrences.idORDER BYCASE WHEN locations.role = 'root_control' THEN 0 ELSE 1 END,locations.sort_orderLIMIT 1) AS location_path- FROM ranked_findings AS selected_findings- JOIN finding_occurrences AS occurrences- ON occurrences.id = selected_findings.occurrence_id- WHERE selected_findings.occurrence_rank = 1- ORDER BY- CASE selected_findings.status WHEN 'open' THEN 0 ELSE 1 END,- CASE selected_findings.severity- WHEN 'critical' THEN 0- WHEN 'high' THEN 1- WHEN 'medium' THEN 2- WHEN 'low' THEN 3- WHEN 'informational' THEN 4- ELSE 5- END,- selected_findings.created_at DESC,- selected_findings.occurrence_id+ FROM finding_occurrences AS occurrences+ JOIN scans ON scans.id = occurrences.scan_id+ JOIN security_targets AS targets ON targets.id = scans.target_id+ LEFT JOIN finding_triage AS triage ON triage.occurrence_id = occurrences.id""",+ ):+ grouped.setdefault(group((row["target_id"], row["finding_id"])), []).append(row)++ findings = []+ for occurrences in grouped.values():+ latest = max(occurrences, key=lambda row: (row["created_at"], row["occurrence_id"]))+ decision = max(+ (row for row in occurrences if row["decision_status"] is not None),+ key=lambda row: (row["decision_updated_at"], row["occurrence_id"]),+ default=None,+ )+ status = decision["decision_status"] if decision is not None else "open"+ if (+ status == "closed"+ and decision["close_reason"] == "already_fixed"+ and latest["created_at"] > decision["decision_updated_at"]+ ):+ status = "open"+ scans = sorted({(row["scan_started_at"], row["scan_id"]) for row in occurrences})+ findings.append(+ {+ **dict(latest),+ "confirmed_in_latest_scan": latest_scan_by_target.get(latest["target_id"])+ == latest["scan_id"],+ "known_since": scans[0][0],+ "known_scan_ids": [scan_id for _, scan_id in scans],+ "matched_finding_ids": sorted({row["finding_id"] for row in occurrences}),+ "occurrence_count": len(occurrences),+ "status": status,+ "updated_at": max(+ latest["updated_at"],+ decision["decision_updated_at"] if decision is not None else "",+ ),+ }+ )++ findings.sort(key=lambda finding: finding["occurrence_id"])+ findings.sort(+ key=lambda finding: (+ finding["status"] == "open",+ -scan_history.SEVERITY_ORDER.get(finding["severity"], 5),+ finding["created_at"],+ ),+ reverse=True,)+ yield from findingsdef list_repositories(diff --git a/sdk/typescript/src/api.ts b/sdk/typescript/src/api.tsindex a15b6ee6f..4220befa5 100644--- a/sdk/typescript/src/api.ts+++ b/sdk/typescript/src/api.ts@@ -57,9 +57,17 @@ import {prepareKnowledgeBase,type PreparedKnowledgeBase,} from "./knowledge-base.js";-import { ScanResult, type TurnResultMetadata } from "./result.js";+import {+ ScanResult,+ type RepositoryFinding,+ type TurnResultMetadata,+} from "./result.js";import type { SeverityLevel } from "./models.js";import { scanActivitiesFromEvent, type ScanActivity } from "./scan-activity.js";+import {+ matchCompletedScan,+ type matchScanFindings,+} from "./scan-comparison.js";import {scanProgressUpdatesFromEvent,workerStatusFromEvent,@@ -277,6 +285,7 @@ interface ClientDependencies {repositoryRevision?: typeof repositoryRevision;resolveCodexCommand?: () => CodexCommand;runWorkbench?: typeof runWorkbench;+ matchFindings?: typeof matchScanFindings;}const DEFAULT_DEPENDENCIES: ClientDependencies = {@@ -1133,6 +1142,44 @@ export class CodexSecurity {});checkOpen();}+ try {+ const runWorkbench = (args: readonly string[]) =>+ workbench(workbenchOptions, args);+ const previousFindings = await listRepositoryFindings(+ runWorkbench,+ targetId,+ "all",+ );+ if (previousFindings !== undefined) {+ await matchCompletedScan({+ scanId,+ repository: repo,+ previousFindings: previousFindings.filter(+ (finding) =>+ finding["scanId"] !== scanId &&+ finding["targetId"] === targetId,+ ),+ falsePositives: falsePositiveExamples as Record<string, unknown>[],+ findings: result.findings.findings,+ workbench: runWorkbench,+ matchFindings: this.#dependencies.matchFindings,+ environment,+ model,+ signal,+ });+ result.repositoryFindings = (await listRepositoryFindings(+ runWorkbench,+ targetId,+ )) as RepositoryFinding[] | undefined;+ }+ } catch (error) {+ notifyObserver(+ "onWarning",+ options.onWarning,+ options.onObserverError,+ `Could not update repository findings: ${errorMessage(error)}`,+ );+ }return result;} catch (error) {// Recorded first: everything below can throw a different error for this same failed@@ -1633,6 +1680,29 @@ export class CodexSecurity {}}+export async function listRepositoryFindings(+ workbench: (args: readonly string[]) => Promise<JsonObject>,+ targetId: string,+ status: "open" | "all" = "open",+): Promise<JsonObject[] | undefined> {+ const findings: JsonObject[] = [];+ let offset: number | undefined;+ do {+ const page = await workbench([+ "list-global-findings",+ "--target-id",+ targetId,+ ...(status === "open" ? ["--status", "open"] : []),+ ...(offset === undefined ? [] : ["--offset", String(offset)]),+ ]);+ if (!Array.isArray(page["findings"])) return undefined;+ findings.push(...(page["findings"] as JsonObject[]));+ offset =+ typeof page["nextOffset"] === "number" ? page["nextOffset"] : undefined;+ } while (offset !== undefined);+ return findings;+}+function deepScanOptions(options: ScanOptions): DeepScanOptions {const selected: DeepScanOptions = {};for (const [name, , minimum] of DEEP_SCAN_SETTINGS) {diff --git a/sdk/typescript/src/cli.ts b/sdk/typescript/src/cli.tsindex d25484340..2b276affa 100644--- a/sdk/typescript/src/cli.ts+++ b/sdk/typescript/src/cli.ts@@ -33,6 +33,7 @@ import {classifyConnectionFailure,CodexSecurity,createSecurityInternal,+ listRepositoryFindings,scanAuthentication,type DeepScanOptions,type ScanAuthMode,@@ -824,6 +825,44 @@ export async function main(]);},});+ findingFeedback.command("list", {+ description: "List open findings for a repository across its scans.",+ mcp: false,+ args: z.object({+ repository: z+ .string()+ .optional()+ .describe("Repository to inspect (default: current directory)."),+ }),+ output: z.record(z.string(), z.unknown()).optional(),+ async run({ args, format }) {+ const repository = resolve(+ dependencies.currentDirectory(),+ args.repository ?? ".",+ );+ return presentHistory(+ await history(+ ["list-repositories"],+ async (value): Promise<JsonObject> => {+ const target = (value["repositories"] as JsonObject[]).find(+ (entry) => entry["targetPath"] === repository,+ );+ const findings =+ target === undefined+ ? []+ : await listRepositoryFindings(+ dependencies.runWorkbench,+ target["targetId"] as string,+ );+ return { repository, findings: findings ?? [] };+ },+ ),+ "findings",+ format,+ { repository },+ );+ },+ });const scanHistory = Cli.create("scans", {description:"List, inspect, rerun, match, and compare saved Codex Security scans.",@@ -3360,8 +3399,10 @@ function printScanSummary(): void {const paint = (value: string, code: number | string): string =>color ? `\u001B[${code}m${value}\u001B[0m` : value;+ const repositoryFindings = result.repositoryFindings;+ const findings = repositoryFindings ?? result.findings.findings;const severities = new Map<SeverityLevel, number>();- for (const finding of result.findings.findings) {+ for (const finding of findings) {severities.set(finding.severity.level,(severities.get(finding.severity.level) ?? 0) + 1,@@ -3386,7 +3427,13 @@ function printScanSummary(elapsed < 60? `${elapsed}s`: `${Math.floor(elapsed / 60)}m ${elapsed % 60}s`;- const findingCount = result.findings.findings.length;+ const findingCount = findings.length;+ const confirmedCount =+ repositoryFindings?.filter((finding) => finding.confirmedInLatestScan)+ .length ?? 0;+ const findingSummary = repositoryFindings?.length+ ? `${confirmedCount} confirmed this scan; ${findingCount - confirmedCount} previously found; ${severitySummary}`+ : severitySummary;const findingColor =findingCount === 0? 32@@ -3397,7 +3444,7 @@ function printScanSummary(: 36;errorOutput.write(`\n ${paint("REPORT", "1;36")} ${paint(errorMessage(result.reportPath), 4)}\n\n` +- ` ${paint("FINDINGS", 1)} ${paint(`${findingCount}${severitySummary === "" ? "" : ` (${severitySummary})`}`, findingColor)}\n` ++ ` ${paint("FINDINGS", 1)} ${paint(`${findingCount}${findingSummary === "" ? "" : ` (${findingSummary})`}`, findingColor)}\n` +` ${paint("COVERAGE", 1)} ${result.coverage.completeness}\n` +` ${paint("ELAPSED", 1)} ${duration}\n`,);diff --git a/sdk/typescript/src/index.ts b/sdk/typescript/src/index.tsindex 154867eb5..883a77cd2 100644--- a/sdk/typescript/src/index.ts+++ b/sdk/typescript/src/index.ts@@ -47,7 +47,11 @@ export { loadContract, requireScanFile } from "./contract.js";export type { LoadedContract, ScanExpectation } from "./contract.js";export type * from "./models.js";export { ScanResult } from "./result.js";-export type { ScanResultOptions, TurnResultMetadata } from "./result.js";+export type {+ RepositoryFinding,+ ScanResultOptions,+ TurnResultMetadata,+} from "./result.js";export {bootstrapPlugin,bundledPluginRoot,diff --git a/sdk/typescript/src/result.ts b/sdk/typescript/src/result.tsindex 467c520d1..e871e23c8 100644--- a/sdk/typescript/src/result.ts+++ b/sdk/typescript/src/result.ts@@ -2,6 +2,7 @@ import { statSync } from "node:fs";import { join } from "node:path";import type {CoverageDocument,+ Finding,FindingsDocument,ScanManifest,} from "./models.js";@@ -17,6 +18,21 @@ export interface TurnResultMetadata {[key: string]: unknown;}+export interface RepositoryFinding+ extends Pick<+ Finding,+ "findingId" | "occurrenceId" | "title" | "summary" | "severity"+ > {+ scanId: string;+ targetId: string;+ status: "open" | "closed";+ confirmedInLatestScan: boolean;+ knownSince?: string;+ knownScanIds?: string[];+ matchedFindingIds?: string[];+ [key: string]: unknown;+}+export interface ScanResultOptions {manifest: ScanManifest;findings: FindingsDocument;@@ -25,6 +41,7 @@ export interface ScanResultOptions {threadId: string;turnResult: TurnResultMetadata;sarifPath?: string | null;+ repositoryFindings?: readonly RepositoryFinding[];}export class ScanResult {@@ -36,6 +53,7 @@ export class ScanResult {public readonly turnResult: Readonly<TurnResultMetadata>;public readonly cost: Readonly<ScanCost> | null;public readonly sarifPath: string | null;+ public repositoryFindings: readonly RepositoryFinding[] | undefined;public constructor(options: ScanResultOptions) {this.manifest = options.manifest;@@ -44,6 +62,7 @@ export class ScanResult {this.scanDir = options.scanDir;this.threadId = options.threadId;this.turnResult = options.turnResult;+ this.repositoryFindings = options.repositoryFindings;this.cost = estimateScanCost(options.turnResult.model,options.turnResult.usage,@@ -95,6 +114,7 @@ export class ScanResult {public toJSON(): Record<string, unknown> {return {manifest: this.manifest,+ repositoryFindings: this.repositoryFindings,findings: this.findings,coverage: this.coverage,scanDir: this.scanDir,diff --git a/sdk/typescript/src/scan-comparison.ts b/sdk/typescript/src/scan-comparison.tsindex 80eb97ea4..3d2cd09b0 100644--- a/sdk/typescript/src/scan-comparison.ts+++ b/sdk/typescript/src/scan-comparison.ts@@ -43,6 +43,17 @@ export interface ScanComparisonOptions {workingDirectory?: string;}+interface CompletedScanMatchingOptions+ extends Pick<ScanComparisonOptions, "environment" | "model" | "signal"> {+ scanId: string;+ repository: string;+ previousFindings: readonly Record<string, unknown>[];+ falsePositives: readonly Record<string, unknown>[];+ findings: readonly Finding[];+ workbench(args: readonly string[]): Promise<Record<string, unknown>>;+ matchFindings?: typeof matchScanFindings;+}+const reason = z.string().min(1)@@ -143,6 +154,122 @@ export async function matchScanFindingsInternal();}+export async function matchCompletedScan(+ options: CompletedScanMatchingOptions,+): Promise<void> {+ if (+ options.findings.length === 0 ||+ (options.previousFindings.length === 0 &&+ options.falsePositives.length === 0)+ ) {+ return;+ }+ const openOccurrences = new Set(+ options.previousFindings.map(({ occurrenceId }) => occurrenceId),+ );+ const falsePositiveScans = new Map(+ options.falsePositives.map(+ ({ findingId, sourceScanId }) => [findingId, sourceScanId] as const,+ ),+ );++ const { batches } = (await options.workbench([+ "list-unmatched-scan-pairs",+ "--repository",+ options.repository,+ ])) as {+ batches?: {+ afterScanId: string;+ afterFindings: Finding[];+ beforeScans: { scanId: string; findings: Finding[] }[];+ }[];+ };+ const batch = batches?.find(+ ({ afterScanId }) => afterScanId === options.scanId,+ );+ if (batch === undefined) return;++ const historical = new Map<string, { scanId: string; finding: Finding }>();+ for (const { scanId, findings } of batch.beforeScans) {+ for (const finding of findings) {+ const findingId = finding["findingId"] as string;+ if (+ openOccurrences.has(finding.occurrenceId) ||+ falsePositiveScans.get(findingId) === scanId+ ) {+ historical.set(findingId, { scanId, finding });+ }+ }+ }+ if (historical.size === 0) return;++ const groups = Map.groupBy(historical.values(), ({ scanId }) => scanId);+ const matches: ScanComparisonResult["matches"] = [];+ const after = batch.afterFindings.filter((finding) => {+ const previous = historical.get(finding["findingId"] as string);+ if (previous === undefined) return true;+ matches.push({+ beforeOccurrenceIds: [previous.finding.occurrenceId],+ afterOccurrenceIds: [finding.occurrenceId],+ confidence: "high",+ reason: "The findings have the same stable identity.",+ });+ historical.delete(finding["findingId"] as string);+ return false;+ });++ let semanticComparison: ScanComparisonResult | undefined;+ if (historical.size > 0 && after.length > 0) {+ semanticComparison = await (options.matchFindings ?? matchScanFindings)(+ {+ before: [...historical.values()].map(({ finding }) => finding),+ after,+ },+ {+ allowHistoricalUncertainty: true,+ environment: options.environment,+ model: options.model,+ signal: options.signal,+ workingDirectory: options.repository,+ },+ );+ matches.push(...semanticComparison.matches);+ }++ for (const [scanId, previous] of groups) {+ const beforeIds = new Set(+ previous.map(({ finding }) => finding.occurrenceId),+ );+ const scanMatches = matches.flatMap((match) => {+ const beforeOccurrenceIds = match.beforeOccurrenceIds.filter((id) =>+ beforeIds.has(id),+ );+ return beforeOccurrenceIds.length === 0+ ? []+ : [{ ...match, beforeOccurrenceIds }];+ });+ const matchedAfter = new Set(+ scanMatches.flatMap(({ afterOccurrenceIds }) => afterOccurrenceIds),+ );+ const scanUncertain =+ semanticComparison?.uncertain.filter(+ ({ beforeOccurrenceId, afterOccurrenceId }) =>+ beforeIds.has(beforeOccurrenceId) &&+ !matchedAfter.has(afterOccurrenceId),+ ) ?? [];+ if (semanticComparison === undefined && scanMatches.length === 0) continue;+ await options.workbench([+ "save-scan-comparison",+ "--before-scan-id",+ scanId,+ "--after-scan-id",+ options.scanId,+ "--matches-json",+ JSON.stringify({ matches: scanMatches, uncertain: scanUncertain }),+ ]);+ }+}+function comparisonPrompt(input: ScanComparisonInput): string {return ["Compare every finding from one or more earlier scans against a later scan of the same repository.",@@ -167,6 +294,7 @@ export async function comparisonEnvironment((entry): entry is [string, string] => entry[1] !== undefined,),);+ if (environment["CODEX_SECURITY_SCAN_ID"] !== undefined) return environment;if (Object.entries(environment).some(([name, value]) =>diff --git a/sdk/typescript/src/scan-history-renderer.ts b/sdk/typescript/src/scan-history-renderer.tsindex f8d2fe6da..a95ebe9b8 100644--- a/sdk/typescript/src/scan-history-renderer.ts+++ b/sdk/typescript/src/scan-history-renderer.ts@@ -1,7 +1,12 @@import { basename, relative } from "node:path";import type { JsonObject } from "./config.js";-export type HistoryCommand = "list" | "show" | "compare" | "match-all";+export type HistoryCommand =+ | "list"+ | "show"+ | "findings"+ | "compare"+ | "match-all";type RendererOptions = {columns?: number;color?: boolean;@@ -65,6 +70,7 @@ export function renderScanHistory(const labels: Record<HistoryCommand, string> = {list: "SCAN HISTORY",show: "SCAN DETAILS",+ findings: "REPOSITORY FINDINGS",compare: "SCAN COMPARISON","match-all": "MATCH RESULTS",};@@ -115,6 +121,7 @@ export function renderScanHistory(const location = (entry["locations"] as JsonObject[] | undefined)?.[0];const path =entry["path"] ??+ entry["locationPath"] ??`${location?.["path"]}${location?.["startLine"] ? `:${location["startLine"]}` : ""}`;lines.push(` ${dim(clean(path))}${grouped}${knownSince}`);const showLinkedFindings = command !== "show" || options.showLinkedFindings;@@ -202,6 +209,18 @@ export function renderScanHistory();}}+ } else if (command === "findings") {+ const findings = result["findings"] as JsonObject[];+ lines.push(+ ` ${strong(clean(basename(result["repository"] as string)))} ${accent("·")} ${findings.length} open finding${findings.length === 1 ? "" : "s"}`,+ );+ for (const entry of findings) {+ lines.push(+ "",+ ` ${strong(entry["confirmedInLatestScan"] ? "Seen this scan" : "Not confirmed in latest scan")}`,+ );+ finding(entry);+ }} else if (command === "show") {const status = clean((result["progress"] as JsonObject)["status"]);const statusColor =diff --git a/sdk/typescript/tests-ts/api.test.ts b/sdk/typescript/tests-ts/api.test.tsindex eba3dab6e..97b05e6c9 100644--- a/sdk/typescript/tests-ts/api.test.ts+++ b/sdk/typescript/tests-ts/api.test.ts@@ -2556,12 +2556,18 @@ describe("CodexSecurity orchestration", () => {reason,ruleId: "auth-boundary",};- const feedbackPath = join(- scanDir,- "artifacts",- "01_context",- "false_positive_feedback.json",- );+ const previousFinding = {+ findingId: "previous_finding",+ occurrenceId: "previous_occurrence",+ scanId: "prior_scan",+ targetId: "target_sha256_example",+ title: "Missing authorization check",+ summary: "An attacker can access another account.",+ locations: [{ path: "src/accounts.ts", startLine: 8, endLine: 12 }],+ };+ const contextDir = join(scanDir, "artifacts", "01_context");+ const feedbackPath = join(contextDir, "false_positive_feedback.json");+ const previousFindingsPath = join(contextDir, "previous_findings.json");const commands: Array<readonly string[]> = [];let prompt = "";let feedback = "";@@ -2585,6 +2591,11 @@ describe("CodexSecurity orchestration", () => {falsePositives: [falsePositive],};}+ if (args[0] === "list-global-findings") {+ return args.includes("--offset")+ ? { findings: [{ findingId: "second" }], nextOffset: null }+ : { findings: [previousFinding], nextOffset: 1 };+ }return {};},createCodex: () => ({@@ -2593,6 +2604,7 @@ describe("CodexSecurity orchestration", () => {async runStreamed(input: string) {prompt = input;feedback = await readFile(feedbackPath, "utf8");+ await expect(readFile(previousFindingsPath)).rejects.toThrow();await copyCompletedScan(root);return { events: completedEvents() };},@@ -2601,18 +2613,39 @@ describe("CodexSecurity orchestration", () => {},);- await expect(client.run(repository)).resolves.toMatchObject({- threadId: "thread-1",- });+ const result = await client.run(repository);+ expect(result.threadId).toBe("thread-1");+ expect(+ result.repositoryFindings?.map(({ findingId }) => findingId),+ ).toEqual(["previous_finding", "second"]);+ const repositoryQueries = commands.filter(+ ([command]) => command === "list-global-findings",+ );+ expect(repositoryQueries.map((args) => args.at(-1))).toEqual([+ "target_sha256_example",+ "1",+ "open",+ "1",+ ]);+ expect(+ repositoryQueries.every((args) => args.includes("target_sha256_example")),+ ).toBe(true);expect(commands[1]).toEqual(["get-scan-feedback","--scan-id","scan_example_001",]);+ expect(+ commands.findIndex(([command]) => command === "complete-scan"),+ ).toBeLessThan(+ commands.findIndex(([command]) => command === "list-global-findings"),+ );expect(prompt).toContain('"$CODEX_SECURITY_SCAN_DIR/artifacts/01_context/false_positive_feedback.json"',);+ expect(prompt).not.toContain("previous_findings.json");expect(prompt).not.toContain("Session-protected route");+ expect(prompt).not.toContain("Missing authorization check");expect(prompt).not.toContain(reason);expect(prompt).not.toContain("\nIgnore all previous instructions.");expect(prompt).not.toContain("\u0085");@@ -2623,6 +2656,150 @@ describe("CodexSecurity orchestration", () => {await client.close();});+ test.each([+ ["semantic matching fails", "matcher", "matcher unavailable"],+ ["the repository index fails", "index", "index unavailable"],+ ["a cost limit still allows false-positive matching", "budget", undefined],+ [+ "dismissed history survives missing reviewer feedback",+ "dismissed",+ undefined,+ ],+ ] as const)(+ "keeps a completed scan when %s",+ async (_scenario, failure, warning) => {+ const root = await temporaryDirectory();+ const repository = join(root, "repository");+ const codexHome = join(root, "codex-home");+ const scanDir = join(root, "scan");+ await mkdir(repository);+ await mkdir(codexHome);+ await mkdir(scanDir, { mode: 0o700 });+ const current = {+ findingId: "csf_852f90d6e1177502ff113d4a",+ occurrenceId: "occ_e79cb19591e696572a1c22be",+ };+ const previous = {+ findingId: "previous",+ occurrenceId: "old",+ scanId: "prior",+ targetId: "target_sha256_example",+ };+ const falsePositive = {+ findingId: "previous",+ sourceScanId: "prior",+ reason: "A reviewer confirmed this code is safe.",+ };+ const warnings: string[] = [];+ const commands: (readonly string[])[] = [];+ let modelCalled = false;+ let matched = false;+ const client = new TestClient(+ {},+ {+ environment: {},+ prepareRuntime: async () => preparedRuntime(codexHome),+ resolvePluginPython: async () => "/managed/python",+ prepareOutputDir: async () => scanDir,+ repositoryRevision: async () => "deadbeef",+ runWorkbench: async (_options: unknown, args: readonly string[]) => {+ commands.push(args);+ if (args[0] === "get-scan-feedback") {+ return {+ scanId: "scan_example_001",+ targetId: "target_sha256_example",+ falsePositives: failure === "budget" ? [falsePositive] : [],+ };+ }+ if (args[0] === "list-unmatched-scan-pairs") {+ return {+ batches: [+ {+ afterScanId: "scan_example_001",+ afterFindings: [current],+ beforeScans: [{ scanId: "prior", findings: [previous] }],+ },+ ],+ };+ }+ if (args[0] === "list-global-findings") {+ if (failure === "index") throw new Error("index unavailable");+ if (failure === "dismissed") {+ return {+ findings: args.includes("--status")+ ? matched+ ? []+ : [current]+ : [{ ...previous, status: "closed" }, current],+ };+ }+ return {+ findings:+ failure === "matcher"+ ? [previous]+ : [{ findingId: "another-open-finding" }],+ };+ }+ if (args[0] === "save-scan-comparison") matched = true;+ return mockWorkbench(args);+ },+ async matchFindings() {+ modelCalled = true;+ if (failure === "matcher") throw new Error("matcher unavailable");+ return {+ matches: [+ {+ beforeOccurrenceIds: [previous.occurrenceId],+ afterOccurrenceIds: [current.occurrenceId],+ confidence: "high",+ reason: "Same dismissed root cause.",+ },+ ],+ uncertain: [],+ };+ },+ createCodex: () => ({+ startThread: () => ({+ id: null,+ async runStreamed() {+ await copyCompletedScan(root);+ return { events: completedEvents() };+ },+ }),+ }),+ },+ );++ const result = await client.run(repository, {+ ...(failure === "budget" ? { maxCostUsd: 1 } : {}),+ onWarning: (message) => warnings.push(message),+ });+ expect(result.threadId).toBe("thread-1");+ expect(+ result.repositoryFindings?.map(({ findingId }) => findingId),+ ).toEqual(+ failure === "budget"+ ? ["another-open-finding"]+ : failure === "dismissed"+ ? []+ : undefined,+ );+ expect(warnings).toEqual(+ warning === undefined+ ? []+ : [`Could not update repository findings: ${warning}`],+ );+ expect(modelCalled).toBe(failure !== "index");+ expect(commands.some(([command]) => command === "complete-scan")).toBe(+ true,+ );+ expect(+ commands.some(([command]) => command === "list-global-findings"),+ ).toBe(true);+ await client.close();+ },+ );+test("rejects feedback from another scan or invalid reviewer feedback", async () => {const scanId = "scan_example_001";const targetId = "target_sha256_example";@@ -3110,6 +3287,7 @@ describe("CodexSecurity orchestration", () => {"set-scan-thread","prepare-scan-completion","complete-scan",+ "list-global-findings",]);expect(commands.some((args) => args[0] === "fail-scan")).toBe(false);await client.close();@@ -5491,7 +5669,7 @@ if (args === "login --with-api-key") {credentialsAvailable: false,}),resolveCodexCommand: () => ({- command: process.execPath,+ command: "node",prefixArgs: [fakeCodex],}),resolvePluginPython: async () => "/managed/python",diff --git a/sdk/typescript/tests-ts/cli-workbench.test.ts b/sdk/typescript/tests-ts/cli-workbench.test.tsindex 66f6ece58..c4e3b93cd 100644--- a/sdk/typescript/tests-ts/cli-workbench.test.ts+++ b/sdk/typescript/tests-ts/cli-workbench.test.ts@@ -5,9 +5,76 @@ import { describe, expect, test } from "bun:test";import type { CodexSecurityConfig, JsonObject } from "../src/index.js";import { DiffTarget } from "../src/index.js";import { main } from "../src/cli.js";-import { capture, dependencies, SYNTHETIC_CREDENTIALS } from "./support/cli.js";+import {+ capture,+ dependencies,+ fakeResult,+ SYNTHETIC_CREDENTIALS,+} from "./support/cli.js";describe("CLI workbench", () => {+ test("lists and summarizes open findings for the current repository", async () => {+ const repository = resolve("/current/repository");+ const stdout = capture();+ const calls: Array<readonly string[]> = [];+ const responses: JsonObject[] = [+ {+ repositories: [+ { targetId: "other", targetPath: `${repository}-clone` },+ { targetId: "selected", targetPath: repository },+ ],+ },+ { findings: [{ title: "Finding 1" }], nextOffset: 1 },+ { findings: [{ title: "Finding 2" }], nextOffset: null },+ ];+ expect(+ await main(+ ["findings", "list", "--json"],+ stdout.stream,+ capture().stream,+ dependencies({+ onWorkbench: (args) => responses[calls.push(args) - 1]!,+ }),+ ),+ ).toBe(0);+ expect(calls[0]).toEqual(["list-repositories"]);+ expect(calls[1]).toEqual([+ "list-global-findings",+ "--target-id",+ "selected",+ "--status",+ "open",+ ]);+ expect(calls[2]).toEqual([...calls[1]!, "--offset", "1"]);+ expect(JSON.parse(stdout.text())).toEqual({+ repository,+ findings: [{ title: "Finding 1" }, { title: "Finding 2" }],+ });+ for (const confirmed of [[true, false], []]) {+ const result = fakeResult(["high"]);+ Object.assign(result, {+ repositoryFindings: confirmed.map((confirmedInLatestScan) => ({+ severity: { level: "high" },+ confirmedInLatestScan,+ })),+ });+ const stderr = capture();+ expect(+ await main(+ ["scan"],+ capture().stream,+ stderr.stream,+ dependencies({ result }),+ ),+ ).toBe(0);+ expect(stderr.text()).toContain(+ confirmed.length+ ? "FINDINGS 2 (1 confirmed this scan; 1 previously found; 2 high)"+ : "FINDINGS 0\n",+ );+ }+ });+test("lists repository and scan-root history without starting Codex", async () => {const repository = resolve("/current/repository");const cases: Array<[string[], string[]]> = [diff --git a/sdk/typescript/tests-ts/repository-findings.test.ts b/sdk/typescript/tests-ts/repository-findings.test.tsnew file mode 100644index 000000000..1a001995c--- /dev/null+++ b/sdk/typescript/tests-ts/repository-findings.test.ts@@ -0,0 +1,116 @@+import { spawnSync } from "node:child_process";+import { join } from "node:path";+import { expect, test } from "bun:test";+import { PLUGIN_ROOT } from "./plugin-root.js";++test("combines repository findings without reviving dismissed aliases", () => {+ const python = (Bun.which("python3") ?? Bun.which("python"))!;++ const probe = `+import argparse, json, sqlite3, sys+sys.path.insert(0, sys.argv[1])+import workbench_native_indexes as indexes++connection = sqlite3.connect(":memory:")+connection.row_factory = sqlite3.Row+connection.executescript("""+CREATE TABLE security_targets(id TEXT, current_path TEXT, display_name TEXT);+CREATE TABLE scans(id TEXT, target_id TEXT, scope TEXT, updated_at TEXT, status TEXT, started_at TEXT);+CREATE TABLE finding_occurrences(id TEXT, finding_id TEXT, severity TEXT, created_at TEXT, scan_id TEXT, title TEXT, summary TEXT);+CREATE TABLE finding_triage(occurrence_id TEXT, status TEXT, updated_at TEXT, close_reason TEXT);+CREATE TABLE finding_locations(occurrence_id TEXT, relative_path TEXT, role TEXT, sort_order INTEGER);+CREATE TABLE scan_comparison_matches(before_occurrence_id TEXT, after_occurrence_id TEXT);+INSERT INTO security_targets VALUES('first', '/first', 'First'), ('second', '/second', 'Second');+""")+def add_scan(scan_id, target, day):+ timestamp = f"2026-01-{day:02d}T00:00:00Z"+ connection.execute("INSERT INTO scans VALUES (?, ?, ?, ?, ?, ?)", (scan_id, target, "repository", timestamp, "complete", timestamp))++def add_finding(occurrence, finding, scan):+ started = connection.execute("SELECT started_at FROM scans WHERE id = ?", (scan,)).fetchone()[0]+ connection.execute("INSERT INTO finding_occurrences VALUES (?, ?, ?, ?, ?, ?, ?)", (occurrence, finding, "high", started, scan, finding, "Summary"))+ connection.execute("INSERT INTO finding_locations VALUES (?, ?, ?, ?)", (occurrence, "src/auth.py", "root_control", 0))++for scan_id, target, day in [("old", "first", 1), ("same", "first", 2), ("renamed", "first", 3), ("latest", "first", 4), ("other", "second", 4)]:+ add_scan(scan_id, target, day)+for occurrence, finding, scan in [("old-occurrence", "dismissed", "old"), ("same-occurrence", "dismissed", "same"), ("renamed-occurrence", "renamed", "renamed"), ("latest-occurrence", "renamed-again", "latest"), ("historical-occurrence", "historical", "old"), ("other-occurrence", "dismissed", "other")]:+ add_finding(occurrence, finding, scan)+connection.executemany("INSERT INTO scan_comparison_matches VALUES (?, ?)", [("same-occurrence", "renamed-occurrence"), ("renamed-occurrence", "latest-occurrence"), ("latest-occurrence", "other-occurrence")])+connection.execute("INSERT INTO finding_triage VALUES (?, ?, ?, ?)", ("old-occurrence", "closed", "2026-01-01T12:00:00Z", "false_positive"))++def findings(target, status="open"):+ arguments = argparse.Namespace(limit=20, offset=0, query=None, severity=None, status=status, target_id=target)+ return indexes.list_global_findings(connection, arguments)["findings"]++result = {"dismissed": findings("first"), "other": findings("second"), "closed": findings("first", None)}+connection.execute("INSERT INTO finding_triage VALUES (?, ?, ?, ?)", ("latest-occurrence", "open", "2026-01-06T00:00:00Z", None))+result["reopened"] = findings("first")+add_scan("clean", "first", 7)+result["not_revalidated"] = findings("first")+connection.execute("UPDATE finding_triage SET close_reason = ?, updated_at = ? WHERE occurrence_id = ?", ("wont_fix", "2026-01-08T00:00:00Z", "old-occurrence"))+result["wont_fix"] = findings("first")+connection.execute("UPDATE finding_triage SET close_reason = ?, updated_at = ? WHERE occurrence_id = ?", ("already_fixed", "2026-01-09T00:00:00Z", "old-occurrence"))+add_scan("rediscovered", "first", 10)+add_finding("rediscovered-occurrence", "renamed-again", "rediscovered")+result["rediscovered"] = findings("first")+add_scan("tied", "first", 11)+add_finding("z-occurrence", "z-finding", "tied")+add_finding("a-occurrence", "a-finding", "tied")+connection.execute("UPDATE finding_occurrences SET severity = 'critical' WHERE id = 'historical-occurrence'")+result["ordered"] = findings("first")+print(json.dumps(result))+`;++ const execution = spawnSync(+ python,+ ["-I", "-B", "-c", probe, join(PLUGIN_ROOT, "scripts")],+ { encoding: "utf8", timeout: 10_000 },+ );+ expect(execution.status, execution.stderr).toBe(0);++ const result = JSON.parse(execution.stdout) as Record<+ string,+ Array<Record<string, unknown>>+ >;+ expect(result).toMatchObject({+ dismissed: [+ {+ findingId: "historical",+ confirmedInLatestScan: false,+ knownScanIds: ["old"],+ },+ ],+ other: [{ findingId: "dismissed", targetId: "second", status: "open" }],+ closed: [+ { findingId: "historical", status: "open" },+ { findingId: "renamed-again", status: "closed" },+ ],+ wont_fix: [{ findingId: "historical" }],+ });+ expect(result["reopened"]?.[0]).toMatchObject({+ findingId: "renamed-again",+ status: "open",+ confirmedInLatestScan: true,+ knownSince: "2026-01-01T00:00:00Z",+ knownScanIds: ["old", "same", "renamed", "latest"],+ matchedFindingIds: ["dismissed", "renamed", "renamed-again"],+ occurrenceCount: 4,+ });+ expect(result["not_revalidated"]?.[0]).toMatchObject({+ findingId: "renamed-again",+ status: "open",+ confirmedInLatestScan: false,+ });+ expect(result["rediscovered"]?.[0]).toMatchObject({+ findingId: "renamed-again",+ status: "open",+ confirmedInLatestScan: true,+ occurrenceCount: 5,+ });+ expect(result["ordered"]?.map((finding) => finding["findingId"])).toEqual([+ "historical",+ "a-finding",+ "z-finding",+ "renamed-again",+ ]);+});diff --git a/sdk/typescript/tests-ts/result.test.ts b/sdk/typescript/tests-ts/result.test.tsindex 6566e5228..e8cb7d592 100644--- a/sdk/typescript/tests-ts/result.test.ts+++ b/sdk/typescript/tests-ts/result.test.ts@@ -6,6 +6,7 @@ import { ScanResult } from "../src/index.js";import type {CoverageDocument,FindingsDocument,+ RepositoryFinding,ScanManifest,} from "../src/index.js";@@ -50,6 +51,17 @@ const coverage = {describe("ScanResult", () => {test("exposes canonical paths and machine serialization", () => {+ const repositoryFinding = {+ findingId: "finding",+ occurrenceId: "occurrence",+ scanId: "scan",+ targetId: "id",+ title: "Unsafe route",+ summary: "The route is not protected.",+ severity: { level: "high" },+ status: "open",+ confirmedInLatestScan: true,+ } satisfies RepositoryFinding;const result = new ScanResult({manifest,findings,@@ -57,6 +69,7 @@ describe("ScanResult", () => {scanDir: "/scan",threadId: "thread",turnResult: { id: "turn", status: "completed" },+ repositoryFindings: [repositoryFinding],});expect(result.pluginVersion).toBe("0.1.14");expect(result.manifestPath).toBe(join("/scan", "scan-manifest.json"));@@ -65,7 +78,9 @@ describe("ScanResult", () => {scanDir: "/scan",threadId: "thread",cost: null,+ repositoryFindings: [repositoryFinding],});+ expect(result.findings).toBe(findings);});test("includes the model and estimated cost in machine-readable results", () => {diff --git a/sdk/typescript/tests-ts/scan-comparison.test.ts b/sdk/typescript/tests-ts/scan-comparison.test.tsindex b3db112c9..3300242ae 100644--- a/sdk/typescript/tests-ts/scan-comparison.test.ts+++ b/sdk/typescript/tests-ts/scan-comparison.test.ts@@ -5,6 +5,7 @@ import type { ThreadOptions, TurnOptions } from "@openai/codex-sdk";import { afterEach, describe, expect, test } from "bun:test";import {comparisonEnvironment,+ matchCompletedScan,matchScanFindings,type ScanComparisonInput,type ScanComparisonOptions,@@ -59,6 +60,10 @@ describe("semantic scan comparison", () => {const credentialHome = join(stateDirectory, "codex-home");await mkdir(credentialHome, { recursive: true, mode: 0o700 });let statusProbed = false;+ const account = async () => {+ statusProbed = true;+ return { authenticated: true, details: "Logged in using ChatGPT" };+ };const environment = await comparisonEnvironment({@@ -66,13 +71,7 @@ describe("semantic scan comparison", () => {OPENAI_API_KEY: "synthetic-key-must-not-be-used",CODEX_API_KEY: "synthetic-secondary-must-not-be-used",},- async () => {- statusProbed = true;- return {- authenticated: true,- details: "Logged in using ChatGPT",- };- },+ account,);expect(environment["CODEX_SECURITY_STATE_DIR"]).toBe(stateDirectory);@@ -83,6 +82,13 @@ describe("semantic scan comparison", () => {"synthetic-secondary-must-not-be-used",);expect(environment["CODEX_HOME"]).toBeUndefined();+ const provider = {+ CODEX_SECURITY_STATE_DIR: stateDirectory,+ CODEX_SECURITY_SCAN_ID: "scan",+ CODEX_HOME: "/provider-home",+ FIREWORKS_API_KEY: "provider-key",+ };+ expect(await comparisonEnvironment(provider, account)).toEqual(provider);expect(statusProbed).toBe(false);});@@ -249,6 +255,135 @@ describe("semantic scan comparison", () => {expect(calls.prompt).toContain(JSON.stringify(input));});+ test("matches open and dismissed findings from the same target", async () => {+ const open = { findingId: "open", occurrenceId: "old-open" };+ const dismissed = { findingId: "dismissed", occurrenceId: "old-dismissed" };+ const after = { findingId: "renamed", occurrenceId: "new-renamed" };+ const commands: (readonly string[])[] = [];+ let input: ScanComparisonInput | undefined;+ await matchCompletedScan({+ scanId: "current",+ repository: "/repository",+ previousFindings: [open],+ falsePositives: [{ findingId: "dismissed", sourceScanId: "prior" }],+ findings: [after],+ environment: {+ CODEX_HOME: "/provider-home",+ CODEX_SECURITY_SCAN_ID: "current",+ FIREWORKS_API_KEY: "synthetic-provider-key",+ },+ async workbench(args) {+ commands.push(args);+ return args[0] === "list-unmatched-scan-pairs"+ ? {+ batches: [+ {+ afterScanId: "current",+ afterFindings: [after],+ beforeScans: [+ {+ scanId: "another-target",+ findings: [{ ...dismissed, occurrenceId: "foreign" }],+ },+ { scanId: "prior", findings: [open, dismissed] },+ ],+ },+ ],+ }+ : {};+ },+ async matchFindings(value, options) {+ input = value;+ expect(options).toMatchObject({+ environment: {+ CODEX_HOME: "/provider-home",+ CODEX_SECURITY_SCAN_ID: "current",+ },+ });+ return {+ matches: [+ {+ beforeOccurrenceIds: ["old-dismissed"],+ afterOccurrenceIds: ["new-renamed"],+ confidence: "high",+ reason: "Same dismissed root cause.",+ },+ ],+ uncertain: [+ {+ beforeOccurrenceId: "old-open",+ afterOccurrenceId: "new-renamed",+ reason: "Possible match.",+ },+ ],+ };+ },+ });+ expect(input).toEqual({ before: [open, dismissed], after: [after] });+ expect(commands.map(([command]) => command)).toEqual([+ "list-unmatched-scan-pairs",+ "save-scan-comparison",+ ]);+ const saved = JSON.parse(commands[1]!.at(-1)!) as ScanComparisonResult;+ expect(+ saved.matches.map(({ beforeOccurrenceIds }) => beforeOccurrenceIds),+ ).toEqual([["old-dismissed"]]);+ expect(saved.uncertain).toEqual([]);+ });++ test.each([+ ["no history", false, false, false, 0, false],+ ["a stable identity", true, false, true, 2, false],+ ["a renamed dismissed identity", false, true, false, 2, true],+ ] as const)(+ "only starts a model turn when needed for %s",+ async (+ _scenario,+ open,+ dismissed,+ stable,+ expectedCalls,+ expectedModel,+ ) => {+ const before = { findingId: "previous", occurrenceId: "old" };+ const after = {+ findingId: stable ? "previous" : "new",+ occurrenceId: "new",+ };+ let calls = 0;+ let modelCalled = false;+ await matchCompletedScan({+ scanId: "current",+ repository: "/repository",+ previousFindings: open ? [before] : [],+ falsePositives: dismissed+ ? [{ findingId: "previous", sourceScanId: "prior" }]+ : [],+ findings: [after],+ async workbench(args) {+ calls += 1;+ return args[0] === "list-unmatched-scan-pairs"+ ? {+ batches: [+ {+ afterScanId: "current",+ afterFindings: [after],+ beforeScans: [{ scanId: "prior", findings: [before] }],+ },+ ],+ }+ : {};+ },+ async matchFindings() {+ modelCalled = true;+ return { matches: [], uncertain: [] };+ },+ });+ expect(calls).toBe(expectedCalls);+ expect(modelCalled).toBe(expectedModel);+ },+ );+test("rejects malformed model JSON", async () => {const { codex } = fakeCodex("not-json");await expect(diff --git a/sdk/typescript/tests-ts/scan-history-renderer.test.ts b/sdk/typescript/tests-ts/scan-history-renderer.test.tsindex fe0a3e3be..169550c43 100644--- a/sdk/typescript/tests-ts/scan-history-renderer.test.ts+++ b/sdk/typescript/tests-ts/scan-history-renderer.test.ts@@ -3,6 +3,25 @@ import { describe, expect, test } from "bun:test";import { renderScanHistory } from "../src/scan-history-renderer.js";describe("scan history renderer", () => {+ test("separates current repository findings from earlier observations", () => {+ const text = renderScanHistory(+ {+ repository: "/repo",+ findings: [true, false].map((confirmed) => ({+ title: confirmed ? "Current finding" : "Earlier finding",+ severity: { level: "high" },+ locationPath: "source.ts",+ confirmedInLatestScan: confirmed,+ })),+ },+ "findings",+ { color: false },+ );+ expect(text).toMatch(+ /Seen this scan[\s\S]*Current finding[\s\S]*Not confirmed in latest scan[\s\S]*Earlier finding/,+ );+ });+test("leads comparisons with the outcome and groups root causes", () => {const text = stripVTControlCharacters(renderScanHistory(