@open-cr-agent/core 0.4.0 → 0.6.0

package/dist/{pipeline → report}/output-schema.d.ts

@@ -1,50 +1,37 @@
 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";
-    }>;
+export declare const REPORT_VERSION = 1;
+export declare const changeRequestSchema: z.ZodObject<{
+    id: z.ZodString;
     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>;
+    description: z.ZodString;
+    baseSha: z.ZodString;
+    headSha: z.ZodString;
+    override: z.ZodExactOptional<z.ZodObject<{
+        by: z.ZodString;
+        reason: z.ZodString;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+export declare const skippedCellSchema: 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>;
 export declare const reportOutputSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
-    runId: z.ZodOptional<z.ZodString>;
+    runId: z.ZodExactOptional<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<{
+        override: z.ZodExactOptional<z.ZodObject<{
             by: z.ZodString;
             reason: z.ZodString;
         }, z.core.$strict>>;
@@ -61,7 +48,7 @@ export declare const reportOutputSchema: z.ZodObject<{
         significant_concerns: "significant_concerns";
     }>;
     summary: z.ZodString;
-    scope: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    scope: z.ZodExactOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         mode: z.ZodLiteral<"incremental">;
         since: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
@@ -104,7 +91,7 @@ export declare const reportOutputSchema: z.ZodObject<{
             unchecked: "unchecked";
         }>;
         file: z.ZodString;
-        lines: z.ZodOptional<z.ZodObject<{
+        lines: z.ZodExactOptional<z.ZodObject<{
             start: z.ZodInt;
             end: z.ZodInt;
         }, z.core.$strict>>;
@@ -115,13 +102,18 @@ export declare const reportOutputSchema: z.ZodObject<{
         }>;
         title: z.ZodString;
         body: z.ZodString;
-        suggestion: z.ZodOptional<z.ZodString>;
+        suggestion: z.ZodExactOptional<z.ZodString>;
+        fix: z.ZodExactOptional<z.ZodObject<{
+            startLine: z.ZodInt;
+            endLine: z.ZodInt;
+            replacement: z.ZodString;
+        }, z.core.$strict>>;
         evidence: z.ZodArray<z.ZodString>;
         code: z.ZodString;
-        lowConfidence: z.ZodOptional<z.ZodLiteral<true>>;
-        provenance: z.ZodOptional<z.ZodObject<{
+        lowConfidence: z.ZodExactOptional<z.ZodLiteral<true>>;
+        provenance: z.ZodExactOptional<z.ZodObject<{
             task: z.ZodString;
-            model: z.ZodOptional<z.ZodString>;
+            model: z.ZodExactOptional<z.ZodString>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
     unverifiedCriticals: z.ZodInt;
@@ -137,8 +129,12 @@ export declare const reportOutputSchema: z.ZodObject<{
         title: z.ZodString;
         reason: z.ZodString;
         added: z.ZodOptional<z.ZodString>;
+        source: z.ZodExactOptional<z.ZodEnum<{
+            account: "account";
+            repository: "repository";
+        }>>;
     }, z.core.$strip>>;
-    judgement: z.ZodOptional<z.ZodObject<{
+    judgement: z.ZodExactOptional<z.ZodObject<{
         merged: z.ZodArray<z.ZodObject<{
             kept: z.ZodString;
             merged: z.ZodArray<z.ZodString>;
@@ -164,7 +160,7 @@ export declare const reportOutputSchema: z.ZodObject<{
             reason: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
-    rereview: z.ZodOptional<z.ZodObject<{
+    rereview: z.ZodExactOptional<z.ZodObject<{
         fixed: z.ZodArray<z.ZodObject<{
             fingerprint: z.ZodString;
             title: z.ZodString;
@@ -179,6 +175,7 @@ export declare const reportOutputSchema: z.ZodObject<{
                 uncertain: "uncertain";
                 unchecked: "unchecked";
             }>;
+            reviewer: z.ZodExactOptional<z.ZodString>;
         }, z.core.$strict>>;
         notReproduced: z.ZodArray<z.ZodObject<{
             fingerprint: z.ZodString;
@@ -194,6 +191,7 @@ export declare const reportOutputSchema: z.ZodObject<{
                 uncertain: "uncertain";
                 unchecked: "unchecked";
             }>;
+            reviewer: z.ZodExactOptional<z.ZodString>;
         }, z.core.$strict>>;
         notRechecked: z.ZodArray<z.ZodObject<{
             fingerprint: z.ZodString;
@@ -209,6 +207,7 @@ export declare const reportOutputSchema: z.ZodObject<{
                 uncertain: "uncertain";
                 unchecked: "unchecked";
             }>;
+            reviewer: z.ZodExactOptional<z.ZodString>;
         }, z.core.$strict>>;
         unchanged: z.ZodArray<z.ZodObject<{
             fingerprint: z.ZodString;
@@ -224,6 +223,7 @@ export declare const reportOutputSchema: z.ZodObject<{
                 uncertain: "uncertain";
                 unchecked: "unchecked";
             }>;
+            reviewer: z.ZodExactOptional<z.ZodString>;
         }, z.core.$strict>>;
         dismissed: z.ZodArray<z.ZodObject<{
             fingerprint: z.ZodString;
@@ -239,6 +239,7 @@ export declare const reportOutputSchema: z.ZodObject<{
                 uncertain: "uncertain";
                 unchecked: "unchecked";
             }>;
+            reviewer: z.ZodExactOptional<z.ZodString>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
     tasks: z.ZodArray<z.ZodObject<{
@@ -252,7 +253,7 @@ export declare const reportOutputSchema: z.ZodObject<{
             failed: "failed";
             timed_out: "timed_out";
         }>;
-        error: z.ZodOptional<z.ZodString>;
+        error: z.ZodExactOptional<z.ZodString>;
         findings: z.ZodInt;
         durationMs: z.ZodNumber;
         usage: z.ZodObject<{
@@ -278,7 +279,7 @@ export declare const reportOutputSchema: z.ZodObject<{
         label: z.ZodString;
         files: z.ZodArray<z.ZodString>;
     }, z.core.$strict>>;
-    anchoring: z.ZodOptional<z.ZodObject<{
+    anchoring: z.ZodExactOptional<z.ZodObject<{
         byMethod: z.ZodRecord<z.ZodEnum<{
             cross_file: "cross_file";
             file: "file";
@@ -289,44 +290,58 @@ export declare const reportOutputSchema: z.ZodObject<{
         ambiguous: z.ZodInt;
         relocationCalls: z.ZodInt;
     }, z.core.$strict>>;
-    spendLimit: z.ZodOptional<z.ZodObject<{
+    spendLimit: z.ZodExactOptional<z.ZodObject<{
         usd: z.ZodNumber;
-        reached: z.ZodOptional<z.ZodEnum<{
+        reached: z.ZodExactOptional<z.ZodEnum<{
             review: "review";
             total: "total";
         }>>;
     }, z.core.$strict>>;
-    provenance: z.ZodOptional<z.ZodObject<{
+    provenance: z.ZodExactOptional<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<{
+            temperature: z.ZodExactOptional<z.ZodNumber>;
+            seed: z.ZodExactOptional<z.ZodInt>;
+            notApplied: z.ZodExactOptional<z.ZodArray<z.ZodEnum<{
                 seed: "seed";
                 temperature: "temperature";
             }>>>;
         }, z.core.$strict>;
-        agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        agents: z.ZodExactOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             tier: z.ZodEnum<{
                 light: "light";
                 standard: "standard";
                 top: "top";
             }>;
-            effort: z.ZodOptional<z.ZodEnum<{
+            models: z.ZodExactOptional<z.ZodArray<z.ZodString>>;
+            effort: z.ZodExactOptional<z.ZodEnum<{
                 high: "high";
                 low: "low";
                 medium: "medium";
                 minimal: "minimal";
                 none: "none";
             }>>;
-            applied: z.ZodOptional<z.ZodBoolean>;
-            notApplied: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            applied: z.ZodExactOptional<z.ZodBoolean>;
+            notApplied: z.ZodExactOptional<z.ZodArray<z.ZodEnum<{
                 seed: "seed";
                 temperature: "temperature";
             }>>>;
         }, z.core.$strict>>>;
+        rules: z.ZodExactOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodArray<z.ZodString>;
+            rule: z.ZodString;
+            source: z.ZodExactOptional<z.ZodEnum<{
+                account: "account";
+                plugin: "plugin";
+                repository: "repository";
+                shared: "shared";
+            }>>;
+        }, z.core.$strict>>>;
+        accountSettings: z.ZodExactOptional<z.ZodObject<{
+            version: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     usage: z.ZodObject<{
         inputTokens: z.ZodNumber;
@@ -337,9 +352,6 @@ export declare const reportOutputSchema: z.ZodObject<{
     }, 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 → report}/output-schema.js

@@ -1,15 +1,22 @@
 import { z } from "zod";
+import { EFFORT_LEVELS } from "../agent/settings.js";
+import { MODEL_TIERS } from "../contracts.js";
 import { anchorMethodSchema, riskTierSchema, severitySchema, verdictSchema, verificationSchema, } from "../domain.js";
 import { memoryEntrySchema } from "../memory/memory.js";
+import { skipReasonSchema } from "../pipeline/matrix.js";
 import { exclusionReasonSchema } from "../select/select.js";
-import { EFFORT_LEVELS } from "./agents.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.
+// The published shape of a review: `--format json` and a session's
+// report.json. It is a contract with scripts and CI, so it carries a version
+// and only what a reader can rely on; internal fields (per-run ids, how each
+// finding was anchored, code signatures, platform state) stay out, though the
+// anchoring counts of the whole run are in. Change it only by adding optional
+// fields, or by a new version.
+export const REPORT_VERSION = 1;
+// The JSON report as a schema, the one definition of its shape: the
+// `ReportOutput` type is derived from it, and the published JSON Schema
+// (docs/schema/report.v1.json) is generated from it. Every object is strict,
+// so a field `toReportOutput` writes without a schema change fails the tests.
 const usageSchema = z.strictObject({
     inputTokens: z.number(),
     outputTokens: z.number(),
@@ -17,13 +24,13 @@ const usageSchema = z.strictObject({
     cachedTokens: z.number(),
     costUsd: z.number(),
 });
-const changeRequestSchema = z.strictObject({
+export 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(),
+    override: z.strictObject({ by: z.string(), reason: z.string() }).exactOptional(),
 });
 const coverageEntrySchema = z.discriminatedUnion("status", [
     z.strictObject({
@@ -37,23 +44,33 @@ const coverageEntrySchema = z.discriminatedUnion("status", [
     }),
 ]);
 const linesSchema = z.strictObject({ start: z.int().positive(), end: z.int().positive() });
-export const outputFindingSchema = z.strictObject({
+const fixSchema = z
+    .strictObject({
+    startLine: z.int().positive(),
+    endLine: z.int().positive(),
+    replacement: z.string(),
+})
+    .refine((f) => f.endLine >= f.startLine, { message: "endLine is before startLine" });
+const outputFindingSchema = z.strictObject({
     fingerprint: z.string(),
     reviewer: z.string(),
     category: z.string(),
     severity: severitySchema,
     verification: verificationSchema,
     file: z.string(),
-    lines: linesSchema.optional(),
+    lines: linesSchema.exactOptional(),
     inDiff: z.boolean(),
     status: z.enum(["new", "unfixed"]),
     title: z.string(),
     body: z.string(),
-    suggestion: z.string().optional(),
+    suggestion: z.string().exactOptional(),
+    fix: fixSchema.exactOptional(),
     evidence: z.array(z.string()),
     code: z.string(),
-    lowConfidence: z.literal(true).optional(),
-    provenance: z.strictObject({ task: z.string(), model: z.string().optional() }).optional(),
+    lowConfidence: z.literal(true).exactOptional(),
+    provenance: z
+        .strictObject({ task: z.string(), model: z.string().exactOptional() })
+        .exactOptional(),
 });
 const outputPriorFindingSchema = z.strictObject({
     fingerprint: z.string(),
@@ -61,6 +78,7 @@ const outputPriorFindingSchema = z.strictObject({
     file: z.string(),
     severity: severitySchema,
     verification: verificationSchema,
+    reviewer: z.string().exactOptional(),
 });
 const refutedFindingSchema = z.strictObject({
     fingerprint: z.string(),
@@ -89,12 +107,12 @@ const taskOutcomeSchema = z.strictObject({
     bundle: z.string(),
     files: z.array(z.string()),
     status: taskStatusSchema,
-    error: z.string().optional(),
+    error: z.string().exactOptional(),
     findings: z.int().nonnegative(),
     durationMs: z.number(),
     usage: usageSchema,
 });
-const skippedCellSchema = z.strictObject({
+export const skippedCellSchema = z.strictObject({
     reviewer: z.string(),
     bundle: z.string(),
     reason: skipReasonSchema,
@@ -110,37 +128,46 @@ const scopeSchema = z.discriminatedUnion("mode", [
 ]);
 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(),
+    temperature: z.number().exactOptional(),
+    seed: z.int().exactOptional(),
+    notApplied: z.array(z.enum(["temperature", "seed"])).exactOptional(),
 });
 const agentProvenanceSchema = z.strictObject({
-    tier: z.enum(["top", "standard", "light"]),
-    effort: z.enum(EFFORT_LEVELS).optional(),
-    applied: z.boolean().optional(),
-    notApplied: z.array(z.enum(["temperature", "seed"])).optional(),
+    tier: z.enum(MODEL_TIERS),
+    models: z.array(z.string()).exactOptional(),
+    effort: z.enum(EFFORT_LEVELS).exactOptional(),
+    applied: z.boolean().exactOptional(),
+    notApplied: z.array(z.enum(["temperature", "seed"])).exactOptional(),
 });
 const provenanceSchema = z.strictObject({
     ocraVersion: z.string(),
     promptHash: z.string(),
     configHash: z.string(),
     sampling: samplingSchema,
-    agents: z.record(z.string(), agentProvenanceSchema).optional(),
+    agents: z.record(z.string(), agentProvenanceSchema).exactOptional(),
+    rules: z
+        .array(z.strictObject({
+        path: z.array(z.string()),
+        rule: z.string(),
+        source: z.enum(["repository", "shared", "account", "plugin"]).exactOptional(),
+    }))
+        .exactOptional(),
+    accountSettings: z.strictObject({ version: z.string().nullable() }).exactOptional(),
 });
 export const reportOutputSchema = z.strictObject({
     version: z.literal(REPORT_VERSION),
-    runId: z.string().optional(),
+    runId: z.string().exactOptional(),
     changeRequest: changeRequestSchema,
     tier: riskTierSchema,
     verdict: verdictSchema,
     summary: z.string(),
-    scope: scopeSchema.optional(),
+    scope: scopeSchema.exactOptional(),
     coverage: z.array(coverageEntrySchema),
     findings: z.array(outputFindingSchema),
     unverifiedCriticals: z.int().nonnegative(),
     refuted: z.array(refutedFindingSchema),
-    remembered: z.array(memoryEntrySchema),
-    judgement: judgeDecisionsSchema.optional(),
+    remembered: z.array(memoryEntrySchema.extend({ source: z.enum(["repository", "account"]).exactOptional() })),
+    judgement: judgeDecisionsSchema.exactOptional(),
     rereview: z
         .strictObject({
         fixed: priorList,
@@ -149,21 +176,18 @@ export const reportOutputSchema = z.strictObject({
         unchanged: priorList,
         dismissed: priorList,
     })
-        .optional(),
+        .exactOptional(),
     tasks: z.array(taskOutcomeSchema),
     skipped: z.array(skippedCellSchema),
     bundles: z.array(z.strictObject({ label: z.string(), files: z.array(z.string()) })),
-    anchoring: anchoringSummarySchema.optional(),
+    anchoring: anchoringSummarySchema.exactOptional(),
     spendLimit: z
-        .strictObject({ usd: z.number(), reached: z.enum(["review", "total"]).optional() })
-        .optional(),
-    provenance: provenanceSchema.optional(),
+        .strictObject({ usd: z.number(), reached: z.enum(["review", "total"]).exactOptional() })
+        .exactOptional(),
+    provenance: provenanceSchema.exactOptional(),
     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.

package/dist/report/output.d.ts

@@ -0,0 +1,8 @@
+import type { z } from "zod";
+import { type reportOutputSchema } from "./output-schema.js";
+import type { ReviewReport } from "./report.js";
+export type ReportOutput = z.output<typeof reportOutputSchema>;
+export type OutputFinding = ReportOutput["findings"][number];
+export type OutputPriorFinding = NonNullable<ReportOutput["rereview"]>["fixed"][number];
+export declare function toReportOutput(report: ReviewReport): ReportOutput;
+//# sourceMappingURL=output.d.ts.map

package/dist/report/output.js

@@ -0,0 +1,211 @@
+import { REPORT_VERSION } from "./output-schema.js";
+export function toReportOutput(report) {
+    const output = {
+        version: REPORT_VERSION,
+        runId: report.runId,
+        changeRequest: outputChangeRequest(report.changeRequest),
+        tier: report.tier,
+        verdict: report.verdict,
+        summary: report.summary,
+        coverage: report.coverage.map(outputCoverage),
+        findings: report.findings.map(outputFinding),
+        unverifiedCriticals: report.unverifiedCriticals,
+        refuted: report.refuted.map(outputRefuted),
+        remembered: report.remembered.map(outputRemembered),
+        tasks: report.tasks.map(outputTask),
+        skipped: report.skipped.map(outputSkipped),
+        bundles: report.bundles.map((b) => ({ label: b.label, files: [...b.files] })),
+        usage: outputUsage(report.usage),
+        warnings: [...report.warnings],
+    };
+    if (report.scope)
+        output.scope = outputScope(report.scope);
+    if (report.judgement)
+        output.judgement = outputJudgement(report.judgement);
+    if (report.anchoring)
+        output.anchoring = outputAnchoring(report.anchoring);
+    if (report.spendLimit)
+        output.spendLimit = outputSpendLimit(report.spendLimit);
+    if (report.provenance)
+        output.provenance = outputProvenance(report.provenance);
+    if (report.rereview) {
+        const r = report.rereview;
+        output.rereview = {
+            fixed: r.fixed.map(outputPrior),
+            notReproduced: r.notReproduced.map(outputPrior),
+            notRechecked: r.notRechecked.map(outputPrior),
+            unchanged: r.unchanged.map(outputPrior),
+            dismissed: r.dismissed.map(outputPrior),
+        };
+    }
+    return output;
+}
+function outputChangeRequest(c) {
+    return {
+        id: c.id,
+        title: c.title,
+        description: c.description,
+        baseSha: c.baseSha,
+        headSha: c.headSha,
+        ...(c.override ? { override: { by: c.override.by, reason: c.override.reason } } : {}),
+    };
+}
+function outputCoverage(c) {
+    return c.status === "excluded"
+        ? { path: c.path, status: c.status, reason: c.reason }
+        : { path: c.path, status: c.status };
+}
+function outputFinding(f) {
+    const output = {
+        fingerprint: f.fingerprint,
+        reviewer: f.reviewer,
+        category: f.category,
+        severity: f.severity,
+        verification: f.verification ?? "unchecked",
+        file: f.file,
+        inDiff: f.anchor.inDiff,
+        status: f.status === "unfixed" ? "unfixed" : "new",
+        title: f.title,
+        body: f.body,
+        evidence: f.evidence,
+        code: f.existingCode,
+    };
+    if (f.lineRange)
+        output.lines = { start: f.lineRange.start, end: f.lineRange.end };
+    if (f.suggestion !== undefined)
+        output.suggestion = f.suggestion;
+    if (f.fix) {
+        output.fix = {
+            startLine: f.fix.startLine,
+            endLine: f.fix.endLine,
+            replacement: f.fix.replacement,
+        };
+    }
+    if (f.lowConfidence)
+        output.lowConfidence = true;
+    output.provenance =
+        f.provenance.model === undefined
+            ? { task: f.provenance.task }
+            : { task: f.provenance.task, model: f.provenance.model };
+    return output;
+}
+function outputRefuted(r) {
+    return { fingerprint: r.fingerprint, file: r.file, title: r.title, reason: r.reason };
+}
+function outputRemembered(e) {
+    return {
+        fingerprint: e.fingerprint,
+        file: e.file,
+        title: e.title,
+        reason: e.reason,
+        ...(e.added === undefined ? {} : { added: e.added }),
+        source: e.source,
+    };
+}
+function outputTask(t) {
+    return {
+        taskId: t.taskId,
+        reviewer: t.reviewer,
+        bundle: t.bundle,
+        files: [...t.files],
+        status: t.status,
+        findings: t.findings,
+        durationMs: t.durationMs,
+        usage: outputUsage(t.usage),
+        ...(t.error === undefined ? {} : { error: t.error }),
+    };
+}
+function outputSkipped(s) {
+    return { reviewer: s.reviewer, bundle: s.bundle, reason: s.reason };
+}
+function outputUsage(u) {
+    return {
+        inputTokens: u.inputTokens,
+        outputTokens: u.outputTokens,
+        reasoningTokens: u.reasoningTokens,
+        cachedTokens: u.cachedTokens,
+        costUsd: u.costUsd,
+    };
+}
+function outputScope(s) {
+    return s.mode === "incremental"
+        ? { mode: s.mode, since: s.since }
+        : { mode: s.mode, reason: s.reason };
+}
+function outputJudgement(j) {
+    return {
+        merged: j.merged.map((m) => ({ kept: m.kept, merged: [...m.merged] })),
+        dropped: j.dropped.map((d) => ({
+            fingerprint: d.fingerprint,
+            file: d.file,
+            title: d.title,
+            reason: d.reason,
+        })),
+        recalibrated: j.recalibrated.map((r) => ({
+            fingerprint: r.fingerprint,
+            from: r.from,
+            to: r.to,
+            reason: r.reason,
+        })),
+    };
+}
+function outputAnchoring(a) {
+    return {
+        byMethod: { ...a.byMethod },
+        ambiguous: a.ambiguous,
+        relocationCalls: a.relocationCalls,
+    };
+}
+function outputSpendLimit(s) {
+    return s.reached === undefined ? { usd: s.usd } : { usd: s.usd, reached: s.reached };
+}
+function outputProvenance(p) {
+    return {
+        ocraVersion: p.ocraVersion,
+        promptHash: p.promptHash,
+        configHash: p.configHash,
+        sampling: outputSampling(p.sampling),
+        ...(p.agents
+            ? {
+                agents: Object.fromEntries(Object.entries(p.agents).map(([id, agent]) => [id, outputAgent(agent)])),
+            }
+            : {}),
+        ...(p.rules
+            ? {
+                rules: p.rules.map((r) => ({
+                    path: [...r.path],
+                    rule: r.rule,
+                    ...(r.source ? { source: r.source } : {}),
+                })),
+            }
+            : {}),
+        ...(p.accountSettings ? { accountSettings: { version: p.accountSettings.version } } : {}),
+    };
+}
+function outputSampling(s) {
+    return {
+        ...(s.temperature === undefined ? {} : { temperature: s.temperature }),
+        ...(s.seed === undefined ? {} : { seed: s.seed }),
+        ...(s.notApplied ? { notApplied: [...s.notApplied] } : {}),
+    };
+}
+function outputAgent(a) {
+    return {
+        tier: a.tier,
+        ...(a.models ? { models: [...a.models] } : {}),
+        ...(a.effort === undefined ? {} : { effort: a.effort }),
+        ...(a.applied === undefined ? {} : { applied: a.applied }),
+        ...(a.notApplied ? { notApplied: [...a.notApplied] } : {}),
+    };
+}
+function outputPrior(f) {
+    return {
+        fingerprint: f.fingerprint,
+        title: f.title,
+        file: f.file,
+        severity: f.severity,
+        verification: f.verification ?? "unchecked",
+        ...(f.reviewer ? { reviewer: f.reviewer } : {}),
+    };
+}
+//# sourceMappingURL=output.js.map