@open-cr-agent/core 0.1.2 → 0.3.0

package/dist/pipeline/imports.js

@@ -0,0 +1,126 @@
+import { anchorFinding } from "../anchor/anchor.js";
+import { sarifCandidates } from "../sarif/candidates.js";
+import { toFinding } from "./findings.js";
+import { boundFinding } from "./task.js";
+import { emptyUsage } from "./usage.js";
+// A hostile log could carry thousands of results on the change.
+export const MAX_IMPORTED_PER_RUN = 200;
+export async function importSarif(logs, plan, emit) {
+    const windows = changedLines(plan.selected);
+    const imported = { findings: [], outcomes: [], warnings: [] };
+    const counts = new Map();
+    for (const log of logs) {
+        for (const run of log.runs) {
+            const { tool, candidates, skipped } = sarifCandidates(run);
+            const n = (counts.get(tool.slug) ?? 0) + 1;
+            counts.set(tool.slug, n);
+            const taskId = `sarif-${tool.slug}-${n}`;
+            const started = Date.now();
+            const onChange = candidates.filter((c) => touches(windows, c));
+            const kept = onChange.slice(0, MAX_IMPORTED_PER_RUN);
+            const files = [...new Set(kept.map((c) => c.file))];
+            emit({ type: "task_started", taskId, reviewer: tool.slug, bundle: "sarif", files });
+            let noCode = 0;
+            const findings = [];
+            for (const candidate of kept) {
+                const finding = await toImportedFinding(candidate, tool.slug, taskId, plan);
+                if (!finding) {
+                    noCode += 1;
+                    continue;
+                }
+                findings.push(finding);
+                emit({ type: "finding", taskId, finding });
+            }
+            const outcome = {
+                taskId,
+                reviewer: tool.slug,
+                bundle: "sarif",
+                files,
+                status: "completed",
+                findings: findings.length,
+                durationMs: Date.now() - started,
+                usage: emptyUsage(),
+            };
+            emit({ type: "task_finished", outcome });
+            imported.findings.push(...findings);
+            imported.outcomes.push(outcome);
+            imported.warnings.push(...importWarnings(tool.name, {
+                imported: findings.length,
+                outside: candidates.length - onChange.length,
+                overLimit: onChange.length - kept.length,
+                noCode,
+                ...skipped,
+            }));
+        }
+    }
+    return imported;
+}
+async function toImportedFinding(candidate, reviewer, taskId, plan) {
+    const content = await plan.context.readFile(candidate.file).catch(() => undefined);
+    const existingCode = candidate.snippet ?? quoteFrom(content, candidate.lines);
+    if (!existingCode)
+        return undefined;
+    const reported = boundFinding({
+        category: reviewer,
+        severity: candidate.severity,
+        file: candidate.file,
+        existingCode,
+        title: candidate.title,
+        body: candidate.body,
+        evidence: [],
+    });
+    // The tool's lines are not trusted over the quote: the same anchoring as
+    // for a model's finding decides where the comment lands.
+    const anchor = await anchorFinding(reported, {
+        diffs: plan.selected,
+        readNewFile: plan.context.readFile,
+    });
+    return toFinding(reported, reviewer, { task: taskId }, anchor, content);
+}
+function quoteFrom(content, lines) {
+    if (content === undefined)
+        return undefined;
+    const quote = content
+        .split("\n")
+        .slice(lines.start - 1, lines.end)
+        .join("\n")
+        .trim();
+    return quote || undefined;
+}
+// The new-side lines each hunk covers, context included.
+function changedLines(diffs) {
+    const windows = new Map();
+    for (const diff of diffs) {
+        const ranges = diff.hunks
+            .filter((h) => h.newLines > 0)
+            .map((h) => ({ start: h.newStart, end: h.newStart + h.newLines - 1 }));
+        if (ranges.length > 0)
+            windows.set(diff.newPath, ranges);
+    }
+    return windows;
+}
+function touches(windows, candidate) {
+    const ranges = windows.get(candidate.file);
+    if (!ranges)
+        return false;
+    return ranges.some((r) => candidate.lines.start <= r.end && candidate.lines.end >= r.start);
+}
+function importWarnings(tool, c) {
+    const left = [];
+    if (c.outside > 0)
+        left.push(`${c.outside} outside the change`);
+    if (c.overLimit > 0)
+        left.push(`${c.overLimit} over the limit of ${MAX_IMPORTED_PER_RUN} per run`);
+    if (c.noCode > 0)
+        left.push(`${c.noCode} on lines that could not be read`);
+    if (c.noLocation > 0)
+        left.push(`${c.noLocation} without a file and lines`);
+    if (c.unsupportedUri > 0)
+        left.push(`${c.unsupportedUri} on paths outside the repository`);
+    if (c.noMessage > 0)
+        left.push(`${c.noMessage} without a message`);
+    if (left.length === 0)
+        return [];
+    return [`${tool}: imported ${c.imported} result(s); left out ${left.join(", ")}`];
+}
+//# sourceMappingURL=imports.js.map

package/dist/pipeline/matrix.d.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import type { Bundle } from "../bundle/bundle.js";
 import type { RiskTier } from "../domain.js";
 import type { ReviewerDefinition } from "../review/reviewer.js";
@@ -12,7 +13,14 @@ export interface MatrixCell {
     reviewer: ReviewerDefinition;
     bundle: Bundle;
 }
-export type SkipReason = "disabled" | "below_tier" | "no_matching_files" | "no_guidelines" | "task_limit";
+export declare const skipReasonSchema: z.ZodEnum<{
+    below_tier: "below_tier";
+    disabled: "disabled";
+    no_guidelines: "no_guidelines";
+    no_matching_files: "no_matching_files";
+    task_limit: "task_limit";
+}>;
+export type SkipReason = z.infer<typeof skipReasonSchema>;
 export interface SkippedCell {
     reviewer: string;
     bundle: string;

package/dist/pipeline/matrix.js

@@ -1,5 +1,13 @@
 import picomatch from "picomatch";
+import { z } from "zod";
 export const RISK_TIERS = ["trivial", "lite", "full"];
+export const skipReasonSchema = z.enum([
+    "disabled",
+    "below_tier",
+    "no_matching_files",
+    "no_guidelines",
+    "task_limit",
+]);
 // Deterministic: which reviewer runs on which bundle, so cost grows with the
 // risk of the change instead of bundles × reviewers.
 export function planMatrix(bundles, reviewers, tier, overrides = {}, options = {}) {

package/dist/pipeline/output-schema.d.ts

@@ -0,0 +1,326 @@
+import { z } from "zod";
+import { type ReportOutput } from "./output.js";
+export declare const outputFindingSchema: z.ZodObject<{
+    fingerprint: z.ZodString;
+    reviewer: z.ZodString;
+    category: z.ZodString;
+    severity: z.ZodEnum<{
+        critical: "critical";
+        suggestion: "suggestion";
+        warning: "warning";
+    }>;
+    verification: z.ZodEnum<{
+        confirmed: "confirmed";
+        uncertain: "uncertain";
+        unchecked: "unchecked";
+    }>;
+    file: z.ZodString;
+    lines: z.ZodOptional<z.ZodObject<{
+        start: z.ZodInt;
+        end: z.ZodInt;
+    }, z.core.$strict>>;
+    inDiff: z.ZodBoolean;
+    status: z.ZodEnum<{
+        new: "new";
+        unfixed: "unfixed";
+    }>;
+    title: z.ZodString;
+    body: z.ZodString;
+    suggestion: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodArray<z.ZodString>;
+    code: z.ZodString;
+    lowConfidence: z.ZodOptional<z.ZodLiteral<true>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        task: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const reportOutputSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    runId: z.ZodOptional<z.ZodString>;
+    changeRequest: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        baseSha: z.ZodString;
+        headSha: z.ZodString;
+        override: z.ZodOptional<z.ZodObject<{
+            by: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    tier: z.ZodEnum<{
+        full: "full";
+        lite: "lite";
+        trivial: "trivial";
+    }>;
+    verdict: z.ZodEnum<{
+        approved: "approved";
+        approved_with_comments: "approved_with_comments";
+        minor_issues: "minor_issues";
+        significant_concerns: "significant_concerns";
+    }>;
+    summary: z.ZodString;
+    scope: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"incremental">;
+        since: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"full">;
+        reason: z.ZodString;
+    }, z.core.$strict>], "mode">>;
+    coverage: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        path: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            reviewed: "reviewed";
+            unchanged: "unchanged";
+            unreviewed: "unreviewed";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        path: z.ZodString;
+        status: z.ZodLiteral<"excluded">;
+        reason: z.ZodEnum<{
+            binary: "binary";
+            deleted: "deleted";
+            extension: "extension";
+            generated: "generated";
+            secret: "secret";
+            too_large: "too_large";
+            user_exclude: "user_exclude";
+        }>;
+    }, z.core.$strict>], "status">>;
+    findings: z.ZodArray<z.ZodObject<{
+        fingerprint: z.ZodString;
+        reviewer: z.ZodString;
+        category: z.ZodString;
+        severity: z.ZodEnum<{
+            critical: "critical";
+            suggestion: "suggestion";
+            warning: "warning";
+        }>;
+        verification: z.ZodEnum<{
+            confirmed: "confirmed";
+            uncertain: "uncertain";
+            unchecked: "unchecked";
+        }>;
+        file: z.ZodString;
+        lines: z.ZodOptional<z.ZodObject<{
+            start: z.ZodInt;
+            end: z.ZodInt;
+        }, z.core.$strict>>;
+        inDiff: z.ZodBoolean;
+        status: z.ZodEnum<{
+            new: "new";
+            unfixed: "unfixed";
+        }>;
+        title: z.ZodString;
+        body: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodArray<z.ZodString>;
+        code: z.ZodString;
+        lowConfidence: z.ZodOptional<z.ZodLiteral<true>>;
+        provenance: z.ZodOptional<z.ZodObject<{
+            task: z.ZodString;
+            model: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    unverifiedCriticals: z.ZodInt;
+    refuted: z.ZodArray<z.ZodObject<{
+        fingerprint: z.ZodString;
+        file: z.ZodString;
+        title: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+    remembered: z.ZodArray<z.ZodObject<{
+        fingerprint: z.ZodString;
+        file: z.ZodString;
+        title: z.ZodString;
+        reason: z.ZodString;
+        added: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    judgement: z.ZodOptional<z.ZodObject<{
+        merged: z.ZodArray<z.ZodObject<{
+            kept: z.ZodString;
+            merged: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        dropped: z.ZodArray<z.ZodObject<{
+            fingerprint: z.ZodString;
+            file: z.ZodString;
+            title: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+        recalibrated: z.ZodArray<z.ZodObject<{
+            fingerprint: z.ZodString;
+            from: z.ZodEnum<{
+                critical: "critical";
+                suggestion: "suggestion";
+                warning: "warning";
+            }>;
+            to: z.ZodEnum<{
+                critical: "critical";
+                suggestion: "suggestion";
+                warning: "warning";
+            }>;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    rereview: z.ZodOptional<z.ZodObject<{
+        fixed: z.ZodArray<z.ZodObject<{
+            fingerprint: z.ZodString;
+            title: z.ZodString;
+            file: z.ZodString;
+            severity: z.ZodEnum<{
+                critical: "critical";
+                suggestion: "suggestion";
+                warning: "warning";
+            }>;
+            verification: z.ZodEnum<{
+                confirmed: "confirmed";
+                uncertain: "uncertain";
+                unchecked: "unchecked";
+            }>;
+        }, z.core.$strict>>;
+        notReproduced: z.ZodArray<z.ZodObject<{
+            fingerprint: z.ZodString;
+            title: z.ZodString;
+            file: z.ZodString;
+            severity: z.ZodEnum<{
+                critical: "critical";
+                suggestion: "suggestion";
+                warning: "warning";
+            }>;
+            verification: z.ZodEnum<{
+                confirmed: "confirmed";
+                uncertain: "uncertain";
+                unchecked: "unchecked";
+            }>;
+        }, z.core.$strict>>;
+        notRechecked: z.ZodArray<z.ZodObject<{
+            fingerprint: z.ZodString;
+            title: z.ZodString;
+            file: z.ZodString;
+            severity: z.ZodEnum<{
+                critical: "critical";
+                suggestion: "suggestion";
+                warning: "warning";
+            }>;
+            verification: z.ZodEnum<{
+                confirmed: "confirmed";
+                uncertain: "uncertain";
+                unchecked: "unchecked";
+            }>;
+        }, z.core.$strict>>;
+        unchanged: z.ZodArray<z.ZodObject<{
+            fingerprint: z.ZodString;
+            title: z.ZodString;
+            file: z.ZodString;
+            severity: z.ZodEnum<{
+                critical: "critical";
+                suggestion: "suggestion";
+                warning: "warning";
+            }>;
+            verification: z.ZodEnum<{
+                confirmed: "confirmed";
+                uncertain: "uncertain";
+                unchecked: "unchecked";
+            }>;
+        }, z.core.$strict>>;
+        dismissed: z.ZodArray<z.ZodObject<{
+            fingerprint: z.ZodString;
+            title: z.ZodString;
+            file: z.ZodString;
+            severity: z.ZodEnum<{
+                critical: "critical";
+                suggestion: "suggestion";
+                warning: "warning";
+            }>;
+            verification: z.ZodEnum<{
+                confirmed: "confirmed";
+                uncertain: "uncertain";
+                unchecked: "unchecked";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    tasks: z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        reviewer: z.ZodString;
+        bundle: z.ZodString;
+        files: z.ZodArray<z.ZodString>;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            failed: "failed";
+            timed_out: "timed_out";
+        }>;
+        error: z.ZodOptional<z.ZodString>;
+        findings: z.ZodInt;
+        durationMs: z.ZodNumber;
+        usage: z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            reasoningTokens: z.ZodNumber;
+            cachedTokens: z.ZodNumber;
+            costUsd: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    skipped: z.ZodArray<z.ZodObject<{
+        reviewer: z.ZodString;
+        bundle: z.ZodString;
+        reason: z.ZodEnum<{
+            below_tier: "below_tier";
+            disabled: "disabled";
+            no_guidelines: "no_guidelines";
+            no_matching_files: "no_matching_files";
+            task_limit: "task_limit";
+        }>;
+    }, z.core.$strict>>;
+    bundles: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        files: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    anchoring: z.ZodOptional<z.ZodObject<{
+        byMethod: z.ZodRecord<z.ZodEnum<{
+            cross_file: "cross_file";
+            file: "file";
+            file_level: "file_level";
+            hunk: "hunk";
+            relocated: "relocated";
+        }>, z.ZodInt>;
+        ambiguous: z.ZodInt;
+        relocationCalls: z.ZodInt;
+    }, z.core.$strict>>;
+    spendLimit: z.ZodOptional<z.ZodObject<{
+        usd: z.ZodNumber;
+        reached: z.ZodOptional<z.ZodEnum<{
+            review: "review";
+            total: "total";
+        }>>;
+    }, z.core.$strict>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        ocraVersion: z.ZodString;
+        promptHash: z.ZodString;
+        configHash: z.ZodString;
+        sampling: z.ZodObject<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            seed: z.ZodOptional<z.ZodInt>;
+            notApplied: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                seed: "seed";
+                temperature: "temperature";
+            }>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    usage: z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        reasoningTokens: z.ZodNumber;
+        cachedTokens: z.ZodNumber;
+        costUsd: z.ZodNumber;
+    }, z.core.$strict>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+type OutputFromSchema = z.output<typeof reportOutputSchema>;
+export declare function asSchemaOutput(output: ReportOutput): OutputFromSchema;
+export declare const REPORT_SCHEMA_ID = "https://ocra.majincheng.com/schema/report.v1.json";
+export declare function reportJsonSchema(): Record<string, unknown>;
+export {};
+//# sourceMappingURL=output-schema.d.ts.map

package/dist/pipeline/output-schema.js

@@ -0,0 +1,173 @@
+import { z } from "zod";
+import { anchorMethodSchema, riskTierSchema, severitySchema, verdictSchema, verificationSchema, } from "../domain.js";
+import { memoryEntrySchema } from "../memory/memory.js";
+import { exclusionReasonSchema } from "../select/select.js";
+import { skipReasonSchema } from "./matrix.js";
+import { REPORT_VERSION } from "./output.js";
+import { taskStatusSchema } from "./report.js";
+// The JSON report as a schema: what `toReportOutput` writes, no more. Every
+// object is strict, so a field added to the output without a schema change
+// fails the tests, and the published JSON Schema (docs/schema/report.v1.json)
+// is generated from here, never written by hand.
+const usageSchema = z.strictObject({
+    inputTokens: z.number(),
+    outputTokens: z.number(),
+    reasoningTokens: z.number(),
+    cachedTokens: z.number(),
+    costUsd: z.number(),
+});
+const changeRequestSchema = z.strictObject({
+    id: z.string(),
+    title: z.string(),
+    description: z.string(),
+    baseSha: z.string(),
+    headSha: z.string(),
+    override: z.strictObject({ by: z.string(), reason: z.string() }).optional(),
+});
+const coverageEntrySchema = z.discriminatedUnion("status", [
+    z.strictObject({
+        path: z.string(),
+        status: z.enum(["reviewed", "failed", "unreviewed", "unchanged"]),
+    }),
+    z.strictObject({
+        path: z.string(),
+        status: z.literal("excluded"),
+        reason: exclusionReasonSchema,
+    }),
+]);
+const linesSchema = z.strictObject({ start: z.int().positive(), end: z.int().positive() });
+export const outputFindingSchema = z.strictObject({
+    fingerprint: z.string(),
+    reviewer: z.string(),
+    category: z.string(),
+    severity: severitySchema,
+    verification: verificationSchema,
+    file: z.string(),
+    lines: linesSchema.optional(),
+    inDiff: z.boolean(),
+    status: z.enum(["new", "unfixed"]),
+    title: z.string(),
+    body: z.string(),
+    suggestion: z.string().optional(),
+    evidence: z.array(z.string()),
+    code: z.string(),
+    lowConfidence: z.literal(true).optional(),
+    provenance: z.strictObject({ task: z.string(), model: z.string().optional() }).optional(),
+});
+const outputPriorFindingSchema = z.strictObject({
+    fingerprint: z.string(),
+    title: z.string(),
+    file: z.string(),
+    severity: severitySchema,
+    verification: verificationSchema,
+});
+const refutedFindingSchema = z.strictObject({
+    fingerprint: z.string(),
+    file: z.string(),
+    title: z.string(),
+    reason: z.string(),
+});
+const judgeDecisionsSchema = z.strictObject({
+    merged: z.array(z.strictObject({ kept: z.string(), merged: z.array(z.string()) })),
+    dropped: z.array(z.strictObject({
+        fingerprint: z.string(),
+        file: z.string(),
+        title: z.string(),
+        reason: z.string(),
+    })),
+    recalibrated: z.array(z.strictObject({
+        fingerprint: z.string(),
+        from: severitySchema,
+        to: severitySchema,
+        reason: z.string(),
+    })),
+});
+const taskOutcomeSchema = z.strictObject({
+    taskId: z.string(),
+    reviewer: z.string(),
+    bundle: z.string(),
+    files: z.array(z.string()),
+    status: taskStatusSchema,
+    error: z.string().optional(),
+    findings: z.int().nonnegative(),
+    durationMs: z.number(),
+    usage: usageSchema,
+});
+const skippedCellSchema = z.strictObject({
+    reviewer: z.string(),
+    bundle: z.string(),
+    reason: skipReasonSchema,
+});
+const anchoringSummarySchema = z.strictObject({
+    byMethod: z.record(anchorMethodSchema, z.int().nonnegative()),
+    ambiguous: z.int().nonnegative(),
+    relocationCalls: z.int().nonnegative(),
+});
+const scopeSchema = z.discriminatedUnion("mode", [
+    z.strictObject({ mode: z.literal("incremental"), since: z.string() }),
+    z.strictObject({ mode: z.literal("full"), reason: z.string() }),
+]);
+const priorList = z.array(outputPriorFindingSchema);
+const samplingSchema = z.strictObject({
+    temperature: z.number().optional(),
+    seed: z.int().optional(),
+    notApplied: z.array(z.enum(["temperature", "seed"])).optional(),
+});
+const provenanceSchema = z.strictObject({
+    ocraVersion: z.string(),
+    promptHash: z.string(),
+    configHash: z.string(),
+    sampling: samplingSchema,
+});
+export const reportOutputSchema = z.strictObject({
+    version: z.literal(REPORT_VERSION),
+    runId: z.string().optional(),
+    changeRequest: changeRequestSchema,
+    tier: riskTierSchema,
+    verdict: verdictSchema,
+    summary: z.string(),
+    scope: scopeSchema.optional(),
+    coverage: z.array(coverageEntrySchema),
+    findings: z.array(outputFindingSchema),
+    unverifiedCriticals: z.int().nonnegative(),
+    refuted: z.array(refutedFindingSchema),
+    remembered: z.array(memoryEntrySchema),
+    judgement: judgeDecisionsSchema.optional(),
+    rereview: z
+        .strictObject({
+        fixed: priorList,
+        notReproduced: priorList,
+        notRechecked: priorList,
+        unchanged: priorList,
+        dismissed: priorList,
+    })
+        .optional(),
+    tasks: z.array(taskOutcomeSchema),
+    skipped: z.array(skippedCellSchema),
+    bundles: z.array(z.strictObject({ label: z.string(), files: z.array(z.string()) })),
+    anchoring: anchoringSummarySchema.optional(),
+    spendLimit: z
+        .strictObject({ usd: z.number(), reached: z.enum(["review", "total"]).optional() })
+        .optional(),
+    provenance: provenanceSchema.optional(),
+    usage: usageSchema,
+    warnings: z.array(z.string()),
+});
+export function asSchemaOutput(output) {
+    return output;
+}
+export const REPORT_SCHEMA_ID = "https://ocra.majincheng.com/schema/report.v1.json";
+// JSON Schema (draft 2020-12) for `--format json` and a session's
+// report.json, for validators and code generators outside this codebase.
+export function reportJsonSchema() {
+    const generated = z.toJSONSchema(reportOutputSchema, { target: "draft-2020-12", io: "output" });
+    const { $schema, ...rest } = generated;
+    return {
+        $schema,
+        $id: REPORT_SCHEMA_ID,
+        title: "ocra review report",
+        description: `The report ocra writes with --format json and as a session's report.json (version ${REPORT_VERSION}). A version only gains optional fields; anything else is a new version.`,
+        ...rest,
+    };
+}
+//# sourceMappingURL=output-schema.js.map

package/dist/pipeline/output.d.ts

@@ -5,6 +5,7 @@ import type { MemoryEntry } from "../memory/memory.js";
 import type { RefutedFinding } from "../verify/verify.js";
 import type { SkippedCell } from "./matrix.js";
 import type { ReviewPreview } from "./preview.js";
+import type { RunProvenance } from "./provenance.js";
 import type { AnchoringSummary, CoverageEntry, ReviewReport, TaskOutcome } from "./report.js";
 export declare const REPORT_VERSION = 1;
 export interface OutputFinding {
@@ -26,6 +27,10 @@ export interface OutputFinding {
     evidence: string[];
     code: string;
     lowConfidence?: true;
+    provenance?: {
+        task: string;
+        model?: string;
+    };
 }
 export interface OutputPriorFinding {
     fingerprint: string;
@@ -36,6 +41,7 @@ export interface OutputPriorFinding {
 }
 export interface ReportOutput {
     version: typeof REPORT_VERSION;
+    runId?: string;
     changeRequest: ChangeRequest;
     tier: RiskTier;
     verdict: Verdict;
@@ -55,6 +61,8 @@ export interface ReportOutput {
         files: string[];
     }[];
     anchoring?: AnchoringSummary;
+    spendLimit?: ReviewReport["spendLimit"];
+    provenance?: RunProvenance;
     usage: Usage;
     warnings: string[];
 }