@mcptoolshop/research-os 0.4.0 → 0.6.0

package/dist/calibration/aggregate-receipt-schema.d.ts

@@ -0,0 +1,547 @@
+import { z } from 'zod';
+
+declare const AggregateMetricSchema: z.ZodObject<{
+    median: z.ZodNumber;
+    min: z.ZodNumber;
+    max: z.ZodNumber;
+    values: z.ZodArray<z.ZodNumber, "many">;
+}, "strip", z.ZodTypeAny, {
+    median: number;
+    min: number;
+    max: number;
+    values: number[];
+}, {
+    median: number;
+    min: number;
+    max: number;
+    values: number[];
+}>;
+declare const PerCategoryAggregateEntrySchema: z.ZodObject<{
+    median_ratio: z.ZodNumber;
+    min_ratio: z.ZodNumber;
+    max_ratio: z.ZodNumber;
+    total: z.ZodNumber;
+    per_run_ratios: z.ZodArray<z.ZodNumber, "many">;
+}, "strip", z.ZodTypeAny, {
+    median_ratio: number;
+    min_ratio: number;
+    max_ratio: number;
+    total: number;
+    per_run_ratios: number[];
+}, {
+    median_ratio: number;
+    min_ratio: number;
+    max_ratio: number;
+    total: number;
+    per_run_ratios: number[];
+}>;
+declare const PerCategoryAggregateSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    median_ratio: z.ZodNumber;
+    min_ratio: z.ZodNumber;
+    max_ratio: z.ZodNumber;
+    total: z.ZodNumber;
+    per_run_ratios: z.ZodArray<z.ZodNumber, "many">;
+}, "strip", z.ZodTypeAny, {
+    median_ratio: number;
+    min_ratio: number;
+    max_ratio: number;
+    total: number;
+    per_run_ratios: number[];
+}, {
+    median_ratio: number;
+    min_ratio: number;
+    max_ratio: number;
+    total: number;
+    per_run_ratios: number[];
+}>>;
+declare const AggregatePassFailSchema: z.ZodObject<{
+    fp_ceiling: z.ZodEnum<["PASS", "FAIL"]>;
+    any_flag_recall_floor: z.ZodEnum<["PASS", "FAIL"]>;
+    per_category_any_flag_floor: z.ZodEnum<["PASS", "FAIL"]>;
+    strict_recall_floor: z.ZodEnum<["PASS", "FAIL"]>;
+    decision_vocab_completeness: z.ZodEnum<["PASS", "FAIL"]>;
+    latency_soft: z.ZodEnum<["PASS", "WARN"]>;
+    latency_hard: z.ZodEnum<["PASS", "FAIL"]>;
+    empty_or_malformed: z.ZodEnum<["PASS", "FAIL"]>;
+    overall: z.ZodEnum<["PASS", "FAIL"]>;
+}, "strip", z.ZodTypeAny, {
+    fp_ceiling: "PASS" | "FAIL";
+    any_flag_recall_floor: "PASS" | "FAIL";
+    per_category_any_flag_floor: "PASS" | "FAIL";
+    strict_recall_floor: "PASS" | "FAIL";
+    decision_vocab_completeness: "PASS" | "FAIL";
+    latency_soft: "PASS" | "WARN";
+    latency_hard: "PASS" | "FAIL";
+    empty_or_malformed: "PASS" | "FAIL";
+    overall: "PASS" | "FAIL";
+}, {
+    fp_ceiling: "PASS" | "FAIL";
+    any_flag_recall_floor: "PASS" | "FAIL";
+    per_category_any_flag_floor: "PASS" | "FAIL";
+    strict_recall_floor: "PASS" | "FAIL";
+    decision_vocab_completeness: "PASS" | "FAIL";
+    latency_soft: "PASS" | "WARN";
+    latency_hard: "PASS" | "FAIL";
+    empty_or_malformed: "PASS" | "FAIL";
+    overall: "PASS" | "FAIL";
+}>;
+declare const AggregateDecisionVocabBarSchema: z.ZodObject<{
+    architecture: z.ZodEnum<["single-pass", "two-pass"]>;
+    required: z.ZodNumber;
+    median_produced: z.ZodNumber;
+    passed: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    required: number;
+    architecture: "single-pass" | "two-pass";
+    median_produced: number;
+    passed: boolean;
+}, {
+    required: number;
+    architecture: "single-pass" | "two-pass";
+    median_produced: number;
+    passed: boolean;
+}>;
+declare const AggregateCalibrationReceiptSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    receipt_kind: z.ZodLiteral<"aggregate">;
+    profile_name: z.ZodString;
+    status: z.ZodEnum<["trusted_baseline", "conditional_pass", "failed", "comparison_only"]>;
+    model: z.ZodString;
+    architecture: z.ZodEnum<["single-pass", "two-pass"]>;
+    fixture: z.ZodString;
+    fixture_total_claims: z.ZodNumber;
+    fixture_good_claims: z.ZodNumber;
+    fixture_bad_claims: z.ZodNumber;
+    runs_count: z.ZodNumber;
+    run_files: z.ZodArray<z.ZodString, "many">;
+    aggregated_at: z.ZodString;
+    research_os_version: z.ZodString;
+    good_fp_count: z.ZodObject<{
+        median: z.ZodNumber;
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+        values: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    }, {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    }>;
+    any_flag_recall_ratio: z.ZodObject<{
+        median: z.ZodNumber;
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+        values: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    }, {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    }>;
+    strict_recall_ratio: z.ZodObject<{
+        median: z.ZodNumber;
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+        values: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    }, {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    }>;
+    decisions_produced_count: z.ZodObject<{
+        median: z.ZodNumber;
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+        values: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    }, {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    }>;
+    runtime_ms: z.ZodObject<{
+        median: z.ZodNumber;
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+        values: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    }, {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    }>;
+    empty_or_malformed_responses: z.ZodObject<{
+        median: z.ZodNumber;
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+        values: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    }, {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    }>;
+    per_category_any_flag: z.ZodRecord<z.ZodString, z.ZodObject<{
+        median_ratio: z.ZodNumber;
+        min_ratio: z.ZodNumber;
+        max_ratio: z.ZodNumber;
+        total: z.ZodNumber;
+        per_run_ratios: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+        median_ratio: number;
+        min_ratio: number;
+        max_ratio: number;
+        total: number;
+        per_run_ratios: number[];
+    }, {
+        median_ratio: number;
+        min_ratio: number;
+        max_ratio: number;
+        total: number;
+        per_run_ratios: number[];
+    }>>;
+    per_category_strict: z.ZodRecord<z.ZodString, z.ZodObject<{
+        median_ratio: z.ZodNumber;
+        min_ratio: z.ZodNumber;
+        max_ratio: z.ZodNumber;
+        total: z.ZodNumber;
+        per_run_ratios: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+        median_ratio: number;
+        min_ratio: number;
+        max_ratio: number;
+        total: number;
+        per_run_ratios: number[];
+    }, {
+        median_ratio: number;
+        min_ratio: number;
+        max_ratio: number;
+        total: number;
+        per_run_ratios: number[];
+    }>>;
+    decision_vocabulary: z.ZodRecord<z.ZodString, z.ZodObject<{
+        median: z.ZodNumber;
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+        values: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    }, {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    }>>;
+    decision_vocab_bar: z.ZodObject<{
+        architecture: z.ZodEnum<["single-pass", "two-pass"]>;
+        required: z.ZodNumber;
+        median_produced: z.ZodNumber;
+        passed: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        required: number;
+        architecture: "single-pass" | "two-pass";
+        median_produced: number;
+        passed: boolean;
+    }, {
+        required: number;
+        architecture: "single-pass" | "two-pass";
+        median_produced: number;
+        passed: boolean;
+    }>;
+    unreachable_decisions: z.ZodArray<z.ZodString, "many">;
+    pass_fail: z.ZodObject<{
+        fp_ceiling: z.ZodEnum<["PASS", "FAIL"]>;
+        any_flag_recall_floor: z.ZodEnum<["PASS", "FAIL"]>;
+        per_category_any_flag_floor: z.ZodEnum<["PASS", "FAIL"]>;
+        strict_recall_floor: z.ZodEnum<["PASS", "FAIL"]>;
+        decision_vocab_completeness: z.ZodEnum<["PASS", "FAIL"]>;
+        latency_soft: z.ZodEnum<["PASS", "WARN"]>;
+        latency_hard: z.ZodEnum<["PASS", "FAIL"]>;
+        empty_or_malformed: z.ZodEnum<["PASS", "FAIL"]>;
+        overall: z.ZodEnum<["PASS", "FAIL"]>;
+    }, "strip", z.ZodTypeAny, {
+        fp_ceiling: "PASS" | "FAIL";
+        any_flag_recall_floor: "PASS" | "FAIL";
+        per_category_any_flag_floor: "PASS" | "FAIL";
+        strict_recall_floor: "PASS" | "FAIL";
+        decision_vocab_completeness: "PASS" | "FAIL";
+        latency_soft: "PASS" | "WARN";
+        latency_hard: "PASS" | "FAIL";
+        empty_or_malformed: "PASS" | "FAIL";
+        overall: "PASS" | "FAIL";
+    }, {
+        fp_ceiling: "PASS" | "FAIL";
+        any_flag_recall_floor: "PASS" | "FAIL";
+        per_category_any_flag_floor: "PASS" | "FAIL";
+        strict_recall_floor: "PASS" | "FAIL";
+        decision_vocab_completeness: "PASS" | "FAIL";
+        latency_soft: "PASS" | "WARN";
+        latency_hard: "PASS" | "FAIL";
+        empty_or_malformed: "PASS" | "FAIL";
+        overall: "PASS" | "FAIL";
+    }>;
+    recurring_bar_failures: z.ZodArray<z.ZodString, "many">;
+    notes: z.ZodArray<z.ZodString, "many">;
+    reviewer_options: z.ZodOptional<z.ZodObject<{
+        num_ctx: z.ZodOptional<z.ZodNumber>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        seed: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        top_k: z.ZodOptional<z.ZodNumber>;
+        repeat_penalty: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        num_ctx?: number | undefined;
+        temperature?: number | undefined;
+        seed?: number | undefined;
+        top_p?: number | undefined;
+        top_k?: number | undefined;
+        repeat_penalty?: number | undefined;
+    }, {
+        num_ctx?: number | undefined;
+        temperature?: number | undefined;
+        seed?: number | undefined;
+        top_p?: number | undefined;
+        top_k?: number | undefined;
+        repeat_penalty?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    status: "trusted_baseline" | "conditional_pass" | "failed" | "comparison_only";
+    architecture: "single-pass" | "two-pass";
+    schema_version: 1;
+    receipt_kind: "aggregate";
+    profile_name: string;
+    model: string;
+    fixture: string;
+    fixture_total_claims: number;
+    fixture_good_claims: number;
+    fixture_bad_claims: number;
+    runs_count: number;
+    run_files: string[];
+    aggregated_at: string;
+    research_os_version: string;
+    good_fp_count: {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    };
+    any_flag_recall_ratio: {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    };
+    strict_recall_ratio: {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    };
+    decisions_produced_count: {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    };
+    runtime_ms: {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    };
+    empty_or_malformed_responses: {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    };
+    per_category_any_flag: Record<string, {
+        median_ratio: number;
+        min_ratio: number;
+        max_ratio: number;
+        total: number;
+        per_run_ratios: number[];
+    }>;
+    per_category_strict: Record<string, {
+        median_ratio: number;
+        min_ratio: number;
+        max_ratio: number;
+        total: number;
+        per_run_ratios: number[];
+    }>;
+    decision_vocabulary: Record<string, {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    }>;
+    decision_vocab_bar: {
+        required: number;
+        architecture: "single-pass" | "two-pass";
+        median_produced: number;
+        passed: boolean;
+    };
+    unreachable_decisions: string[];
+    pass_fail: {
+        fp_ceiling: "PASS" | "FAIL";
+        any_flag_recall_floor: "PASS" | "FAIL";
+        per_category_any_flag_floor: "PASS" | "FAIL";
+        strict_recall_floor: "PASS" | "FAIL";
+        decision_vocab_completeness: "PASS" | "FAIL";
+        latency_soft: "PASS" | "WARN";
+        latency_hard: "PASS" | "FAIL";
+        empty_or_malformed: "PASS" | "FAIL";
+        overall: "PASS" | "FAIL";
+    };
+    recurring_bar_failures: string[];
+    notes: string[];
+    reviewer_options?: {
+        num_ctx?: number | undefined;
+        temperature?: number | undefined;
+        seed?: number | undefined;
+        top_p?: number | undefined;
+        top_k?: number | undefined;
+        repeat_penalty?: number | undefined;
+    } | undefined;
+}, {
+    status: "trusted_baseline" | "conditional_pass" | "failed" | "comparison_only";
+    architecture: "single-pass" | "two-pass";
+    schema_version: 1;
+    receipt_kind: "aggregate";
+    profile_name: string;
+    model: string;
+    fixture: string;
+    fixture_total_claims: number;
+    fixture_good_claims: number;
+    fixture_bad_claims: number;
+    runs_count: number;
+    run_files: string[];
+    aggregated_at: string;
+    research_os_version: string;
+    good_fp_count: {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    };
+    any_flag_recall_ratio: {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    };
+    strict_recall_ratio: {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    };
+    decisions_produced_count: {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    };
+    runtime_ms: {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    };
+    empty_or_malformed_responses: {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    };
+    per_category_any_flag: Record<string, {
+        median_ratio: number;
+        min_ratio: number;
+        max_ratio: number;
+        total: number;
+        per_run_ratios: number[];
+    }>;
+    per_category_strict: Record<string, {
+        median_ratio: number;
+        min_ratio: number;
+        max_ratio: number;
+        total: number;
+        per_run_ratios: number[];
+    }>;
+    decision_vocabulary: Record<string, {
+        median: number;
+        min: number;
+        max: number;
+        values: number[];
+    }>;
+    decision_vocab_bar: {
+        required: number;
+        architecture: "single-pass" | "two-pass";
+        median_produced: number;
+        passed: boolean;
+    };
+    unreachable_decisions: string[];
+    pass_fail: {
+        fp_ceiling: "PASS" | "FAIL";
+        any_flag_recall_floor: "PASS" | "FAIL";
+        per_category_any_flag_floor: "PASS" | "FAIL";
+        strict_recall_floor: "PASS" | "FAIL";
+        decision_vocab_completeness: "PASS" | "FAIL";
+        latency_soft: "PASS" | "WARN";
+        latency_hard: "PASS" | "FAIL";
+        empty_or_malformed: "PASS" | "FAIL";
+        overall: "PASS" | "FAIL";
+    };
+    recurring_bar_failures: string[];
+    notes: string[];
+    reviewer_options?: {
+        num_ctx?: number | undefined;
+        temperature?: number | undefined;
+        seed?: number | undefined;
+        top_p?: number | undefined;
+        top_k?: number | undefined;
+        repeat_penalty?: number | undefined;
+    } | undefined;
+}>;
+type AggregateMetric = z.infer<typeof AggregateMetricSchema>;
+type PerCategoryAggregateEntry = z.infer<typeof PerCategoryAggregateEntrySchema>;
+type PerCategoryAggregate = z.infer<typeof PerCategoryAggregateSchema>;
+type AggregatePassFail = z.infer<typeof AggregatePassFailSchema>;
+type AggregateDecisionVocabBar = z.infer<typeof AggregateDecisionVocabBarSchema>;
+type AggregateCalibrationReceipt = z.infer<typeof AggregateCalibrationReceiptSchema>;
+
+export { type AggregateCalibrationReceipt, AggregateCalibrationReceiptSchema, type AggregateDecisionVocabBar, AggregateDecisionVocabBarSchema, type AggregateMetric, AggregateMetricSchema, type AggregatePassFail, AggregatePassFailSchema, type PerCategoryAggregate, type PerCategoryAggregateEntry, PerCategoryAggregateEntrySchema, PerCategoryAggregateSchema };

package/dist/calibration/aggregate-receipt-schema.js

@@ -0,0 +1,160 @@
+// src/calibration/aggregate-receipt-schema.ts
+import { z as z3 } from "zod";
+
+// src/calibration/receipt-schema.ts
+import { z as z2 } from "zod";
+
+// src/review/reviewer-options-schema.ts
+import { z } from "zod";
+var ReviewerOptionsSchema = z.object({
+  num_ctx: z.number().int().positive().optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  seed: z.number().int().optional(),
+  top_p: z.number().min(0).max(1).optional(),
+  top_k: z.number().int().nonnegative().optional(),
+  repeat_penalty: z.number().min(0).optional()
+});
+
+// src/calibration/receipt-schema.ts
+var StatusLabelSchema = z2.enum([
+  "trusted_baseline",
+  "conditional_pass",
+  "failed",
+  "comparison_only"
+]);
+var ArchitectureSchema = z2.enum(["single-pass", "two-pass"]);
+var RecallSchema = z2.object({
+  matched: z2.number().int().nonnegative(),
+  total: z2.number().int().nonnegative(),
+  ratio: z2.number().min(0).max(1)
+});
+var PerCategoryRecallSchema = z2.record(z2.string(), RecallSchema);
+var PassFailSchema = z2.object({
+  fp_ceiling: z2.enum(["PASS", "FAIL"]),
+  any_flag_recall_floor: z2.enum(["PASS", "FAIL"]),
+  per_category_any_flag_floor: z2.enum(["PASS", "FAIL"]),
+  strict_recall_floor: z2.enum(["PASS", "FAIL"]),
+  decision_vocab_completeness: z2.enum(["PASS", "FAIL"]),
+  latency_soft: z2.enum(["PASS", "WARN"]),
+  latency_hard: z2.enum(["PASS", "FAIL"]),
+  empty_or_malformed: z2.enum(["PASS", "FAIL"]),
+  overall: z2.enum(["PASS", "FAIL"])
+});
+var DecisionVocabBarSchema = z2.object({
+  architecture: ArchitectureSchema,
+  required: z2.number().int().positive(),
+  produced: z2.number().int().nonnegative(),
+  passed: z2.boolean()
+});
+var CalibrationReceiptSchema = z2.object({
+  schema_version: z2.literal(1),
+  profile_name: z2.string(),
+  status: StatusLabelSchema,
+  model: z2.string(),
+  architecture: ArchitectureSchema,
+  fixture: z2.string(),
+  fixture_total_claims: z2.number().int().positive(),
+  fixture_good_claims: z2.number().int().nonnegative(),
+  fixture_bad_claims: z2.number().int().nonnegative(),
+  calibrated_at: z2.string(),
+  research_os_version: z2.string(),
+  runtime_ms: z2.number().int().nonnegative(),
+  good_fp_count: z2.number().int().nonnegative(),
+  any_flag_recall: RecallSchema,
+  strict_recall: RecallSchema,
+  per_category_any_flag: PerCategoryRecallSchema,
+  per_category_strict: PerCategoryRecallSchema,
+  decision_vocabulary: z2.record(z2.string(), z2.number().int().nonnegative()),
+  decisions_produced_count: z2.number().int().nonnegative(),
+  decision_vocab_bar: DecisionVocabBarSchema,
+  unreachable_decisions: z2.array(z2.string()),
+  empty_or_malformed_responses: z2.number().int().nonnegative(),
+  pass_fail: PassFailSchema,
+  notes: z2.array(z2.string()),
+  reviewer_options: ReviewerOptionsSchema.optional()
+});
+
+// src/calibration/aggregate-receipt-schema.ts
+var AggregateMetricSchema = z3.object({
+  median: z3.number(),
+  min: z3.number(),
+  max: z3.number(),
+  values: z3.array(z3.number())
+  // per-run values in run order (run-001, run-002, ...)
+});
+var PerCategoryAggregateEntrySchema = z3.object({
+  median_ratio: z3.number().min(0).max(1),
+  min_ratio: z3.number().min(0).max(1),
+  max_ratio: z3.number().min(0).max(1),
+  total: z3.number().int().nonnegative(),
+  // seed count — same across all runs
+  per_run_ratios: z3.array(z3.number())
+});
+var PerCategoryAggregateSchema = z3.record(z3.string(), PerCategoryAggregateEntrySchema);
+var AggregatePassFailSchema = z3.object({
+  fp_ceiling: z3.enum(["PASS", "FAIL"]),
+  any_flag_recall_floor: z3.enum(["PASS", "FAIL"]),
+  per_category_any_flag_floor: z3.enum(["PASS", "FAIL"]),
+  strict_recall_floor: z3.enum(["PASS", "FAIL"]),
+  decision_vocab_completeness: z3.enum(["PASS", "FAIL"]),
+  latency_soft: z3.enum(["PASS", "WARN"]),
+  latency_hard: z3.enum(["PASS", "FAIL"]),
+  empty_or_malformed: z3.enum(["PASS", "FAIL"]),
+  overall: z3.enum(["PASS", "FAIL"])
+});
+var AggregateDecisionVocabBarSchema = z3.object({
+  architecture: ArchitectureSchema,
+  required: z3.number().int().positive(),
+  median_produced: z3.number(),
+  // float — median of per-run decisions_produced_count
+  passed: z3.boolean()
+});
+var AggregateCalibrationReceiptSchema = z3.object({
+  schema_version: z3.literal(1),
+  receipt_kind: z3.literal("aggregate"),
+  // discriminates from single-run receipt
+  profile_name: z3.string(),
+  status: StatusLabelSchema,
+  model: z3.string(),
+  architecture: ArchitectureSchema,
+  fixture: z3.string(),
+  fixture_total_claims: z3.number().int().positive(),
+  fixture_good_claims: z3.number().int().nonnegative(),
+  fixture_bad_claims: z3.number().int().nonnegative(),
+  runs_count: z3.number().int().min(2),
+  run_files: z3.array(z3.string()),
+  // relative paths: runs/run-001.json, etc.
+  aggregated_at: z3.string(),
+  // ISO 8601
+  research_os_version: z3.string(),
+  // Aggregate metrics — median + min + max + per-run values in run order
+  good_fp_count: AggregateMetricSchema,
+  any_flag_recall_ratio: AggregateMetricSchema,
+  strict_recall_ratio: AggregateMetricSchema,
+  decisions_produced_count: AggregateMetricSchema,
+  runtime_ms: AggregateMetricSchema,
+  empty_or_malformed_responses: AggregateMetricSchema,
+  per_category_any_flag: PerCategoryAggregateSchema,
+  per_category_strict: PerCategoryAggregateSchema,
+  // Decision vocabulary — union of all decisions seen across runs, median count each
+  decision_vocabulary: z3.record(z3.string(), AggregateMetricSchema),
+  decision_vocab_bar: AggregateDecisionVocabBarSchema,
+  unreachable_decisions: z3.array(z3.string()),
+  pass_fail: AggregatePassFailSchema,
+  // Bars that FAILed in >= ceil(runs_count/2) individual runs.
+  // Non-empty list demotes trusted_baseline to conditional_pass.
+  recurring_bar_failures: z3.array(z3.string()),
+  notes: z3.array(z3.string()),
+  // schema_version: 1 — additive-optional (Exp6 Session 2):
+  //   Same options object stamped on every per-run receipt. Absent = stochastic run.
+  reviewer_options: ReviewerOptionsSchema.optional()
+});
+export {
+  AggregateCalibrationReceiptSchema,
+  AggregateDecisionVocabBarSchema,
+  AggregateMetricSchema,
+  AggregatePassFailSchema,
+  PerCategoryAggregateEntrySchema,
+  PerCategoryAggregateSchema
+};
+//# sourceMappingURL=aggregate-receipt-schema.js.map