agentwrangler 0.1.0

package/dist/evidence/cond1/prepare.js

@@ -0,0 +1,295 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { EXTRACTOR_VERSIONS, extractDeferralFindings, projectDiffMarkerCandidates, projectReviewThreadFindings, } from "../../outcomes/finding-extractors.js";
+import { loadApprovedEvidenceInput, publishApprovedOutput } from "../common/approved-input.js";
+import { EvidenceBoundaryError } from "../common/boundary.js";
+import { canonicalJson, sha256Canonical } from "../common/canonical.js";
+import { redactEvidenceExcerpt } from "../common/redaction.js";
+import { COND1_RUNNER_VERSION, canonicalAnswerKeySha256 } from "./score.js";
+function fail(code) {
+    throw new Error(code);
+}
+function binaryCompare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function validateIdentity(identity) {
+    const asOf = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.\d{1,9})?Z$/u.exec(identity.asOf);
+    const asOfDate = asOf === null ? Number.NaN : Date.parse(`${asOf[1]}Z`);
+    if (Object.keys(identity).sort().join("|") !==
+        [
+            "sourceCommit",
+            "runnerVersion",
+            "findingsModuleSha256",
+            "extractorVersions",
+            "packetVersion",
+            "scorerVersion",
+            "asOf",
+        ]
+            .sort()
+            .join("|") ||
+        Object.keys(identity.extractorVersions).sort().join("|") !== "E1|E2|E3" ||
+        !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u.test(identity.sourceCommit) ||
+        identity.runnerVersion !== COND1_RUNNER_VERSION ||
+        !/^[0-9a-f]{64}$/u.test(identity.findingsModuleSha256) ||
+        identity.packetVersion !== "cond1-blinded-v1" ||
+        identity.scorerVersion !== "cond1-precision-v1" ||
+        identity.extractorVersions.E1 !== EXTRACTOR_VERSIONS.E1 ||
+        identity.extractorVersions.E2 !== EXTRACTOR_VERSIONS.E2 ||
+        identity.extractorVersions.E3 !== EXTRACTOR_VERSIONS.E3 ||
+        !Number.isFinite(asOfDate) ||
+        new Date(asOfDate).toISOString().slice(0, 19) !== asOf?.[1]) {
+        fail("cond1_identity_invalid");
+    }
+}
+function privatePrKey(pr) {
+    return `${pr.reportAlias}#${pr.number}`;
+}
+function utcKey(value) {
+    const match = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,9}))?Z$/u.exec(value);
+    if (match?.[1] === undefined)
+        return null;
+    const milliseconds = Date.parse(`${match[1]}Z`);
+    if (!Number.isFinite(milliseconds) ||
+        new Date(milliseconds).toISOString().slice(0, 19) !== match[1]) {
+        return null;
+    }
+    return `${match[1]}.${(match[2] ?? "").padEnd(9, "0")}Z`;
+}
+function normalizeInventory(inventory, repositoryAliases, asOf) {
+    const asOfKey = utcKey(asOf) ?? fail("cond1_as_of_invalid");
+    const seen = new Set();
+    const rows = inventory.map((row) => {
+        const mergedAtKey = utcKey(row.mergedAt);
+        if (!repositoryAliases.has(row.reportAlias) ||
+            !Number.isSafeInteger(row.number) ||
+            row.number <= 0 ||
+            mergedAtKey === null ||
+            mergedAtKey > asOfKey) {
+            fail("cond1_inventory_row_invalid");
+        }
+        const key = privatePrKey(row);
+        if (seen.has(key))
+            fail("cond1_inventory_duplicate");
+        seen.add(key);
+        return { reportAlias: row.reportAlias, number: row.number, mergedAt: row.mergedAt };
+    });
+    return rows.sort((left, right) => binaryCompare(left.reportAlias, right.reportAlias) || left.number - right.number);
+}
+async function safeRead(read) {
+    try {
+        const result = await read();
+        return result.ok ? result.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function acquireCorpus(github, repositories, prs) {
+    const byAlias = new Map(repositories.map((repo) => [repo.reportAlias, repo]));
+    const raw = [];
+    const succeeded = { E1: 0, E2: 0, E3: 0 };
+    let fullyReadPrN = 0;
+    for (const pr of prs) {
+        const repo = byAlias.get(pr.reportAlias);
+        if (repo === undefined)
+            fail("cond1_inventory_repository_unknown");
+        const [threads, body, diff] = await Promise.all([
+            safeRead(() => github.getReviewThreads(repo.owner, repo.repo, pr.number)),
+            safeRead(() => github.getPRBody(repo.owner, repo.repo, pr.number)),
+            safeRead(() => github.getPRDiff(repo.owner, repo.repo, pr.number)),
+        ]);
+        if (threads !== undefined)
+            succeeded.E1++;
+        if (body !== undefined)
+            succeeded.E2++;
+        if (diff !== undefined)
+            succeeded.E3++;
+        if (threads !== undefined && body !== undefined && diff !== undefined)
+            fullyReadPrN++;
+        raw.push({
+            pr,
+            ...(threads === undefined ? {} : { threads }),
+            ...(body === undefined ? {} : { body: body ?? "" }),
+            ...(diff === undefined ? {} : { diff }),
+        });
+    }
+    const requiredN = prs.length;
+    return {
+        raw,
+        readCompletion: {
+            E1: { requiredN, succeededN: succeeded.E1, failedN: requiredN - succeeded.E1 },
+            E2: { requiredN, succeededN: succeeded.E2, failedN: requiredN - succeeded.E2 },
+            E3: { requiredN, succeededN: succeeded.E3, failedN: requiredN - succeeded.E3 },
+        },
+        fullyReadPrN,
+    };
+}
+function extractCorpus(raw) {
+    const findings = [];
+    for (const { pr, threads, body, diff } of raw) {
+        const corpusPrKey = privatePrKey(pr);
+        for (const projected of projectReviewThreadFindings(corpusPrKey, threads ?? [])) {
+            findings.push({
+                extractor: "E1",
+                extractorVersion: EXTRACTOR_VERSIONS.E1,
+                sourceFindingId: projected.sourceFindingId,
+                corpusPrKey,
+                repoAlias: pr.reportAlias,
+                evidenceKind: "REVIEW_THREAD_STATE",
+                evidence: projected.evidence,
+                evidenceSufficient: true,
+                projectionFailure: null,
+            });
+        }
+        for (const projected of extractDeferralFindings(body ?? "", corpusPrKey)) {
+            const excerpt = redactEvidenceExcerpt(projected.evidenceText);
+            findings.push({
+                extractor: "E2",
+                extractorVersion: EXTRACTOR_VERSIONS.E2,
+                sourceFindingId: projected.sourceFindingId,
+                corpusPrKey,
+                repoAlias: pr.reportAlias,
+                evidenceKind: "DEFERRAL_LIST_ITEM",
+                evidence: excerpt === null ? {} : { boundedExcerpt: excerpt },
+                evidenceSufficient: excerpt !== null,
+                projectionFailure: excerpt === null ? "REDACTION_FAILED" : null,
+            });
+        }
+        for (const [index, projected] of projectDiffMarkerCandidates(diff ?? "").entries()) {
+            const excerpt = redactEvidenceExcerpt(projected.evidenceText);
+            findings.push({
+                extractor: "E3",
+                extractorVersion: EXTRACTOR_VERSIONS.E3,
+                sourceFindingId: `e3:${corpusPrKey}:${index}`,
+                corpusPrKey,
+                repoAlias: pr.reportAlias,
+                evidenceKind: "ADDED_DIFF_MARKER",
+                evidence: {
+                    ...(excerpt === null ? {} : { boundedExcerpt: excerpt }),
+                    locationAlias: `loc-${sha256Canonical([projected.filePath, projected.lineNumber]).slice(0, 20)}`,
+                },
+                evidenceSufficient: excerpt !== null,
+                projectionFailure: excerpt === null ? "REDACTION_FAILED" : null,
+            });
+        }
+    }
+    return findings.sort((a, b) => binaryCompare(a.extractor, b.extractor) ||
+        binaryCompare(a.corpusPrKey, b.corpusPrKey) ||
+        binaryCompare(a.sourceFindingId, b.sourceFindingId));
+}
+function answerMaterial(findings) {
+    return findings.map((finding) => ({
+        findingAlias: "",
+        extractor: finding.extractor,
+        extractorVersion: finding.extractorVersion,
+        sourceFindingId: finding.sourceFindingId,
+        corpusPrKey: finding.corpusPrKey,
+        evidenceSufficient: finding.evidenceSufficient,
+        projectionFailure: finding.projectionFailure,
+    }));
+}
+function preflightOutputs(loaded, outputs) {
+    const state = path.resolve(loaded.scratchStatePath);
+    const resolved = outputs.map((output) => path.resolve(output));
+    if (new Set(resolved).size !== resolved.length)
+        fail("cond1_output_paths_duplicate");
+    for (const output of resolved) {
+        if (path.dirname(output) !== state)
+            fail("cond1_output_not_direct_state_child");
+        try {
+            fs.lstatSync(output);
+            fail("cond1_output_already_exists");
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === "cond1_output_already_exists")
+                throw error;
+            if (error.code !== "ENOENT")
+                fail("cond1_output_preflight_failed");
+        }
+    }
+}
+export async function prepareCond1(input) {
+    validateIdentity(input.identity);
+    if (!input.github.enabled)
+        fail("cond1_github_disabled");
+    const loaded = await loadApprovedEvidenceInput(input.approvedInput);
+    preflightOutputs(loaded, [input.preparedOutPath, input.manifestOutPath]);
+    const scratch = loaded.openVerifiedScratchDb();
+    try {
+        scratch.prepare("SELECT 1").get();
+    }
+    finally {
+        scratch.close();
+    }
+    const repositories = loaded.repositories.map(({ owner, repo, reportAlias }) => ({
+        owner,
+        repo,
+        reportAlias,
+    }));
+    const inventory = await input.github.listMergedPRs(repositories, input.identity.asOf);
+    if (!inventory.ok)
+        fail("cond1_inventory_failed");
+    const orderedInventory = normalizeInventory(inventory.data, new Set(repositories.map(({ reportAlias }) => reportAlias)), input.identity.asOf);
+    // A second pure extraction pass detects nondeterministic projection before any artifact write.
+    const acquired = await acquireCorpus(input.github, repositories, orderedInventory);
+    const first = extractCorpus(acquired.raw);
+    const second = extractCorpus(acquired.raw);
+    if (sha256Canonical(first) !== sha256Canonical(second))
+        fail("cond1_extraction_nondeterministic");
+    const answers = answerMaterial(first);
+    const answerCanonicalSha256 = canonicalAnswerKeySha256(answers);
+    const campaignId = `cond1-${sha256Canonical({
+        identity: input.identity,
+        scratchDbSha256: loaded.scratchDbSha256,
+        repoMapSha256: loaded.repoMapSha256,
+        inventory: orderedInventory,
+    }).slice(0, 32)}`;
+    const prepared = {
+        version: "cond1-prepared-v1",
+        campaignId,
+        identity: input.identity,
+        scratchDbSha256: loaded.scratchDbSha256,
+        repoMapSha256: loaded.repoMapSha256,
+        eligiblePrN: orderedInventory.length,
+        findings: first,
+    };
+    const publish = input.publishOutput ?? publishApprovedOutput;
+    const preparedPublication = publish(loaded, input.preparedOutPath, `${canonicalJson(prepared)}\n`);
+    const counts = {
+        E1: first.filter((finding) => finding.extractor === "E1").length,
+        E2: first.filter((finding) => finding.extractor === "E2").length,
+        E3: first.filter((finding) => finding.extractor === "E3").length,
+    };
+    const manifest = {
+        version: "cond1-corpus-manifest-v1",
+        campaignId,
+        identity: input.identity,
+        scratchDbSha256: loaded.scratchDbSha256,
+        repoMapSha256: loaded.repoMapSha256,
+        eligiblePrN: orderedInventory.length,
+        readCompletion: acquired.readCompletion,
+        corpusReadSummary: {
+            fullyReadPrN: acquired.fullyReadPrN,
+            failedPrN: orderedInventory.length - acquired.fullyReadPrN,
+        },
+        emittedFindingN: counts,
+        preparedArtifactSha256: preparedPublication.sha256,
+        answerCanonicalSha256,
+    };
+    let manifestPublication;
+    try {
+        manifestPublication = publish(loaded, input.manifestOutPath, `${canonicalJson(manifest)}\n`);
+    }
+    catch (error) {
+        const code = error instanceof EvidenceBoundaryError ? error.code : "unexpected_failure";
+        fail(`cond1_manifest_publication_failed_prepared_output_retained_${code}`);
+    }
+    return {
+        campaignId,
+        eligiblePrN: orderedInventory.length,
+        emittedFindingN: counts,
+        preparedArtifactSha256: preparedPublication.sha256,
+        manifestSha256: manifestPublication.sha256,
+        answerCanonicalSha256,
+    };
+}

package/dist/evidence/cond1/score.js

@@ -0,0 +1,349 @@
+import { createHash } from "node:crypto";
+import { EXTRACTOR_VERSIONS } from "../../outcomes/finding-extractors.js";
+const EXTRACTORS = ["E1", "E2", "E3"];
+const VERDICTS = new Set(["TRUE_POSITIVE", "FALSE_POSITIVE", "UNCERTAIN"]);
+const REASON_CODES = new Set([
+    "EVIDENCE_SUPPORTS",
+    "CONTEXT_NEGATES",
+    "NOT_A_DEFERRAL",
+    "NOT_AN_ADDED_MARKER",
+    "WRONG_THREAD_STATE",
+    "INSUFFICIENT_EVIDENCE",
+]);
+const MIN_INFORMATIVE_FINDINGS = 20;
+const PRECISION_THRESHOLD = 0.8;
+export const COND1_RUNNER_VERSION = "cond1-runner-v1";
+const SHA256_RE = /^[0-9a-f]{64}$/;
+const GIT_COMMIT_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+const UTC_RFC3339_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?Z$/;
+const IDENTITY_KEYS = [
+    "sourceCommit",
+    "runnerVersion",
+    "findingsModuleSha256",
+    "extractorVersions",
+    "packetVersion",
+    "scorerVersion",
+    "asOf",
+];
+function canonicalJson(value) {
+    if (value === null || typeof value === "boolean" || typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new Error("canonical JSON rejects non-finite numbers");
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`)
+            .join(",")}}`;
+    }
+    throw new Error(`canonical JSON rejects ${typeof value}`);
+}
+export function canonicalSha256(value) {
+    return createHash("sha256").update(canonicalJson(value), "utf8").digest("hex");
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+export function canonicalAnswerKeySha256(answers) {
+    const stableIdentities = answers
+        .map(({ extractor, extractorVersion, sourceFindingId, corpusPrKey, evidenceSufficient, projectionFailure, }) => ({
+        extractor,
+        extractorVersion,
+        sourceFindingId,
+        corpusPrKey,
+        evidenceSufficient,
+        projectionFailure,
+    }))
+        .sort((left, right) => {
+        return (compareText(left.extractor, right.extractor) ||
+            compareText(left.corpusPrKey, right.corpusPrKey) ||
+            compareText(left.sourceFindingId, right.sourceFindingId) ||
+            compareText(left.extractorVersion, right.extractorVersion));
+    });
+    return canonicalSha256(stableIdentities);
+}
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+function isStrictUtcRfc3339(value) {
+    const match = UTC_RFC3339_RE.exec(value);
+    if (match === null)
+        return false;
+    const [, yearText, monthText, dayText, hourText, minuteText, secondText] = match;
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime()))
+        return false;
+    return (parsed.getUTCFullYear() === Number(yearText) &&
+        parsed.getUTCMonth() + 1 === Number(monthText) &&
+        parsed.getUTCDate() === Number(dayText) &&
+        parsed.getUTCHours() === Number(hourText) &&
+        parsed.getUTCMinutes() === Number(minuteText) &&
+        parsed.getUTCSeconds() === Number(secondText));
+}
+function frozenIdentity(identity) {
+    return {
+        sourceCommit: identity.sourceCommit,
+        runnerVersion: COND1_RUNNER_VERSION,
+        findingsModuleSha256: identity.findingsModuleSha256,
+        extractorVersions: {
+            E1: identity.extractorVersions.E1,
+            E2: identity.extractorVersions.E2,
+            E3: identity.extractorVersions.E3,
+        },
+        packetVersion: identity.packetVersion,
+        scorerVersion: identity.scorerVersion,
+        asOf: identity.asOf,
+    };
+}
+function isNonNegativeInteger(value) {
+    return Number.isInteger(value) && value >= 0;
+}
+function isVerdict(value) {
+    return typeof value === "string" && VERDICTS.has(value);
+}
+function isValidVerdictRow(value) {
+    return (typeof value.findingAlias === "string" &&
+        value.findingAlias.length > 0 &&
+        isVerdict(value.verdict) &&
+        typeof value.adjudicatorAlias === "string" &&
+        value.adjudicatorAlias.length > 0 &&
+        typeof value.reasonCode === "string" &&
+        REASON_CODES.has(value.reasonCode));
+}
+function scoreStatus(precision, limitation) {
+    if (limitation !== "NONE")
+        return "DATA_INSUFFICIENT";
+    return precision !== null && precision >= PRECISION_THRESHOLD ? "PASS" : "FAIL";
+}
+function overallStatus(scores) {
+    const statuses = EXTRACTORS.map((extractor) => scores[extractor].status);
+    if (statuses.includes("DATA_INSUFFICIENT"))
+        return "DATA_INSUFFICIENT";
+    if (statuses.includes("FAIL"))
+        return "FAIL";
+    return "PASS";
+}
+/**
+ * Score a complete COND-1 answer key and verdict set. The function has no I/O
+ * and returns only the approved durable aggregate shape.
+ */
+export function scoreCond1(input) {
+    const { manifest, answers, verdicts } = input;
+    const { corpusReadSummary } = manifest;
+    const durableIdentity = frozenIdentity(manifest.identity);
+    const answerKeyCanonicalSha256 = canonicalAnswerKeySha256(answers);
+    let globalIdentityMismatch = !SHA256_RE.test(input.corpusManifestFileSha256) ||
+        manifest.version !== "cond1-corpus-manifest-v1" ||
+        answerKeyCanonicalSha256 !== manifest.answerCanonicalSha256 ||
+        manifest.identity.packetVersion !== "cond1-blinded-v1" ||
+        manifest.identity.scorerVersion !== "cond1-precision-v1" ||
+        manifest.campaignId.length === 0 ||
+        manifest.identity.runnerVersion !== COND1_RUNNER_VERSION ||
+        !GIT_COMMIT_RE.test(manifest.identity.sourceCommit) ||
+        !SHA256_RE.test(manifest.identity.findingsModuleSha256) ||
+        !SHA256_RE.test(manifest.scratchDbSha256) ||
+        !SHA256_RE.test(manifest.repoMapSha256) ||
+        !SHA256_RE.test(manifest.preparedArtifactSha256) ||
+        !SHA256_RE.test(manifest.answerCanonicalSha256) ||
+        !isStrictUtcRfc3339(manifest.identity.asOf) ||
+        !hasExactKeys(manifest.identity, IDENTITY_KEYS) ||
+        !hasExactKeys(manifest.identity.extractorVersions, EXTRACTORS) ||
+        EXTRACTORS.some((extractor) => manifest.identity.extractorVersions[extractor] !== EXTRACTOR_VERSIONS[extractor]);
+    const countsAreValid = isNonNegativeInteger(manifest.eligiblePrN) &&
+        isNonNegativeInteger(corpusReadSummary.fullyReadPrN) &&
+        isNonNegativeInteger(corpusReadSummary.failedPrN) &&
+        corpusReadSummary.fullyReadPrN + corpusReadSummary.failedPrN === manifest.eligiblePrN &&
+        corpusReadSummary.failedPrN <=
+            EXTRACTORS.reduce((sum, extractor) => sum + manifest.readCompletion[extractor].failedN, 0);
+    if (!countsAreValid)
+        globalIdentityMismatch = true;
+    const answersByAlias = new Map();
+    const answerAliasesByExtractor = {
+        E1: new Set(),
+        E2: new Set(),
+        E3: new Set(),
+    };
+    const duplicateAnswerExtractors = new Set();
+    const sourceIdentities = new Set();
+    for (const answer of answers) {
+        if (!EXTRACTORS.includes(answer.extractor) ||
+            answer.extractorVersion !== EXTRACTOR_VERSIONS[answer.extractor] ||
+            answer.findingAlias.length === 0 ||
+            answer.sourceFindingId.length === 0 ||
+            answer.corpusPrKey.length === 0 ||
+            typeof answer.evidenceSufficient !== "boolean" ||
+            !(answer.projectionFailure === null || answer.projectionFailure === "REDACTION_FAILED") ||
+            answer.evidenceSufficient === (answer.projectionFailure !== null)) {
+            globalIdentityMismatch = true;
+            continue;
+        }
+        if (answersByAlias.has(answer.findingAlias)) {
+            duplicateAnswerExtractors.add(answer.extractor);
+            globalIdentityMismatch = true;
+        }
+        const sourceIdentity = canonicalSha256([
+            answer.extractor,
+            answer.corpusPrKey,
+            answer.sourceFindingId,
+        ]);
+        if (sourceIdentities.has(sourceIdentity))
+            globalIdentityMismatch = true;
+        sourceIdentities.add(sourceIdentity);
+        answersByAlias.set(answer.findingAlias, answer);
+        answerAliasesByExtractor[answer.extractor].add(answer.findingAlias);
+    }
+    const verdictsByAlias = new Map();
+    const duplicateVerdictExtractors = new Set();
+    const adjudicatorAliases = new Set();
+    let invalidAdjudicatorAlias = false;
+    let unknownVerdictAlias = false;
+    for (const verdict of verdicts) {
+        if (typeof verdict.adjudicatorAlias !== "string" || verdict.adjudicatorAlias.length === 0) {
+            invalidAdjudicatorAlias = true;
+        }
+        else {
+            adjudicatorAliases.add(verdict.adjudicatorAlias);
+        }
+        const answer = answersByAlias.get(verdict.findingAlias);
+        if (answer === undefined) {
+            unknownVerdictAlias = true;
+            continue;
+        }
+        if (verdictsByAlias.has(verdict.findingAlias))
+            duplicateVerdictExtractors.add(answer.extractor);
+        verdictsByAlias.set(verdict.findingAlias, verdict);
+    }
+    if (unknownVerdictAlias)
+        globalIdentityMismatch = true;
+    if (invalidAdjudicatorAlias || adjudicatorAliases.size !== 1)
+        globalIdentityMismatch = true;
+    const extractorScores = {};
+    for (const extractor of EXTRACTORS) {
+        const read = manifest.readCompletion[extractor];
+        const emittedN = manifest.emittedFindingN[extractor];
+        let extractorIdentityMismatch = globalIdentityMismatch ||
+            duplicateAnswerExtractors.has(extractor) ||
+            duplicateVerdictExtractors.has(extractor) ||
+            !isNonNegativeInteger(emittedN) ||
+            !isNonNegativeInteger(read.requiredN) ||
+            !isNonNegativeInteger(read.succeededN) ||
+            !isNonNegativeInteger(read.failedN) ||
+            read.requiredN !== manifest.eligiblePrN ||
+            read.succeededN + read.failedN !== read.requiredN ||
+            answerAliasesByExtractor[extractor].size !== emittedN;
+        if (countsAreValid &&
+            (read.succeededN < corpusReadSummary.fullyReadPrN ||
+                read.failedN > corpusReadSummary.failedPrN)) {
+            extractorIdentityMismatch = true;
+        }
+        const counts = { truePositiveN: 0, falsePositiveN: 0, uncertainN: 0 };
+        let adjudicatedN = 0;
+        let invalidVerdict = false;
+        let unsupportedProjectionVerdict = false;
+        for (const alias of answerAliasesByExtractor[extractor]) {
+            const verdict = verdictsByAlias.get(alias);
+            if (verdict === undefined)
+                continue;
+            if (!isValidVerdictRow(verdict)) {
+                invalidVerdict = true;
+                continue;
+            }
+            const answer = answersByAlias.get(alias);
+            if (answer !== undefined &&
+                !answer.evidenceSufficient &&
+                (verdict.verdict !== "UNCERTAIN" || verdict.reasonCode !== "INSUFFICIENT_EVIDENCE")) {
+                unsupportedProjectionVerdict = true;
+                continue;
+            }
+            adjudicatedN++;
+            if (verdict.verdict === "TRUE_POSITIVE")
+                counts.truePositiveN++;
+            else if (verdict.verdict === "FALSE_POSITIVE")
+                counts.falsePositiveN++;
+            else
+                counts.uncertainN++;
+        }
+        const unadjudicatedN = Math.max(emittedN - adjudicatedN, 0);
+        const precisionDenominator = counts.truePositiveN + counts.falsePositiveN;
+        const completeReads = read.failedN === 0 && read.succeededN === read.requiredN;
+        const completeAdjudication = !invalidVerdict &&
+            !unsupportedProjectionVerdict &&
+            adjudicatedN === emittedN &&
+            unadjudicatedN === 0 &&
+            !duplicateVerdictExtractors.has(extractor);
+        const precision = extractor !== "E1" &&
+            emittedN > 0 &&
+            completeReads &&
+            completeAdjudication &&
+            counts.uncertainN === 0
+            ? counts.truePositiveN / precisionDenominator
+            : null;
+        const sparse = emittedN < MIN_INFORMATIVE_FINDINGS;
+        let limitation = "NONE";
+        if (extractorIdentityMismatch)
+            limitation = "IDENTITY_MISMATCH";
+        else if (!completeReads)
+            limitation = "INCOMPLETE_READS";
+        else if (emittedN === 0)
+            limitation = "ZERO_EMISSIONS";
+        else if (!completeAdjudication)
+            limitation = "INCOMPLETE_ADJUDICATION";
+        else if (counts.uncertainN > 0)
+            limitation = "UNCERTAIN_VERDICTS";
+        else if (extractor === "E1")
+            limitation = "CURRENT_STATE_ONLY";
+        else if (sparse)
+            limitation = "SPARSE_LT_20";
+        extractorScores[extractor] = {
+            extractor,
+            corpusPrN: manifest.eligiblePrN,
+            emittedN,
+            requiredAdjudicationN: emittedN,
+            adjudicatedN,
+            truePositiveN: counts.truePositiveN,
+            falsePositiveN: counts.falsePositiveN,
+            uncertainN: counts.uncertainN,
+            unadjudicatedN,
+            precisionNumerator: counts.truePositiveN,
+            precisionDenominator,
+            precision,
+            threshold: PRECISION_THRESHOLD,
+            sparse,
+            status: scoreStatus(precision, limitation),
+            limitation,
+        };
+    }
+    return {
+        campaign: "COND1_FINDINGS_PRECISION",
+        identity: {
+            sourceCommit: durableIdentity.sourceCommit,
+            runnerVersion: durableIdentity.runnerVersion,
+            findingsModuleSha256: durableIdentity.findingsModuleSha256,
+            extractorVersions: durableIdentity.extractorVersions,
+            packetVersion: durableIdentity.packetVersion,
+            scorerVersion: durableIdentity.scorerVersion,
+            asOf: durableIdentity.asOf,
+            scratchDbSha256: manifest.scratchDbSha256,
+            repoMapSha256: manifest.repoMapSha256,
+            corpusManifestSha256: input.corpusManifestFileSha256,
+            answerKeyCanonicalSha256,
+        },
+        corpus: {
+            eligiblePrN: manifest.eligiblePrN,
+            fullyReadPrN: corpusReadSummary.fullyReadPrN,
+            failedPrN: corpusReadSummary.failedPrN,
+        },
+        extractors: extractorScores,
+        overallStatus: overallStatus(extractorScores),
+        durablePrivacy: { rawEvidenceN: 0, evidenceRefN: 0, pathN: 0, tokenN: 0 },
+    };
+}

package/dist/evidence/cond1/types.js

@@ -0,0 +1 @@
+export {};