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

feat(scan): show current findings for each repository (#346)

ianw-oai8487e0938079
diff --git a/README.md b/README.md
index 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 that
directory cannot be written, set `CODEX_SECURITY_STATE_DIR` to a writable
directory 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 by
root cause, reuses saved matches, and identifies new, persisting, reopened,
resolved, or unknown findings. Missing findings remain unknown when coverage is
diff --git a/sdk/typescript/README.md b/sdk/typescript/README.md
index 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 a
scan.
+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 reproduction
steps. Keep result directories and saved reports outside the repository and
limit access to authorized reviewers.
@@ -223,6 +227,7 @@ npx @openai/codex-security scans rerun SCAN_ID
npx @openai/codex-security scans match PREVIOUS_SCAN_ID CURRENT_SCAN_ID
npx @openai/codex-security scans match --all
npx @openai/codex-security scans compare PREVIOUS_SCAN_ID CURRENT_SCAN_ID
+npx @openai/codex-security findings list /path/to/repository
npx @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.sarif
npx @openai/codex-security export /path/outside/repository/results --export-format csv --output /path/outside/repository/findings.csv
diff --git a/sdk/typescript/_bundled_plugin/scripts/workbench_native_indexes.py b/sdk/typescript/_bundled_plugin/scripts/workbench_native_indexes.py
index 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_path
FROM finding_locations AS locations
- WHERE locations.occurrence_id = selected_findings.occurrence_id
+ WHERE locations.occurrence_id = occurrences.id
ORDER BY
CASE WHEN locations.role = 'root_control' THEN 0 ELSE 1 END,
locations.sort_order
LIMIT 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 findings
def list_repositories(
diff --git a/sdk/typescript/src/api.ts b/sdk/typescript/src/api.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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(