@mcptoolshop/research-os 0.3.3 → 0.5.0

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

@@ -0,0 +1,143 @@
+// src/calibration/aggregate-receipt-schema.ts
+import { z as z2 } from "zod";
+
+// src/calibration/receipt-schema.ts
+import { z } from "zod";
+var StatusLabelSchema = z.enum([
+  "trusted_baseline",
+  "conditional_pass",
+  "failed",
+  "comparison_only"
+]);
+var ArchitectureSchema = z.enum(["single-pass", "two-pass"]);
+var RecallSchema = z.object({
+  matched: z.number().int().nonnegative(),
+  total: z.number().int().nonnegative(),
+  ratio: z.number().min(0).max(1)
+});
+var PerCategoryRecallSchema = z.record(z.string(), RecallSchema);
+var PassFailSchema = z.object({
+  fp_ceiling: z.enum(["PASS", "FAIL"]),
+  any_flag_recall_floor: z.enum(["PASS", "FAIL"]),
+  per_category_any_flag_floor: z.enum(["PASS", "FAIL"]),
+  strict_recall_floor: z.enum(["PASS", "FAIL"]),
+  decision_vocab_completeness: z.enum(["PASS", "FAIL"]),
+  latency_soft: z.enum(["PASS", "WARN"]),
+  latency_hard: z.enum(["PASS", "FAIL"]),
+  empty_or_malformed: z.enum(["PASS", "FAIL"]),
+  overall: z.enum(["PASS", "FAIL"])
+});
+var DecisionVocabBarSchema = z.object({
+  architecture: ArchitectureSchema,
+  required: z.number().int().positive(),
+  produced: z.number().int().nonnegative(),
+  passed: z.boolean()
+});
+var CalibrationReceiptSchema = z.object({
+  schema_version: z.literal(1),
+  profile_name: z.string(),
+  status: StatusLabelSchema,
+  model: z.string(),
+  architecture: ArchitectureSchema,
+  fixture: z.string(),
+  fixture_total_claims: z.number().int().positive(),
+  fixture_good_claims: z.number().int().nonnegative(),
+  fixture_bad_claims: z.number().int().nonnegative(),
+  calibrated_at: z.string(),
+  research_os_version: z.string(),
+  runtime_ms: z.number().int().nonnegative(),
+  good_fp_count: z.number().int().nonnegative(),
+  any_flag_recall: RecallSchema,
+  strict_recall: RecallSchema,
+  per_category_any_flag: PerCategoryRecallSchema,
+  per_category_strict: PerCategoryRecallSchema,
+  decision_vocabulary: z.record(z.string(), z.number().int().nonnegative()),
+  decisions_produced_count: z.number().int().nonnegative(),
+  decision_vocab_bar: DecisionVocabBarSchema,
+  unreachable_decisions: z.array(z.string()),
+  empty_or_malformed_responses: z.number().int().nonnegative(),
+  pass_fail: PassFailSchema,
+  notes: z.array(z.string())
+});
+
+// src/calibration/aggregate-receipt-schema.ts
+var AggregateMetricSchema = z2.object({
+  median: z2.number(),
+  min: z2.number(),
+  max: z2.number(),
+  values: z2.array(z2.number())
+  // per-run values in run order (run-001, run-002, ...)
+});
+var PerCategoryAggregateEntrySchema = z2.object({
+  median_ratio: z2.number().min(0).max(1),
+  min_ratio: z2.number().min(0).max(1),
+  max_ratio: z2.number().min(0).max(1),
+  total: z2.number().int().nonnegative(),
+  // seed count — same across all runs
+  per_run_ratios: z2.array(z2.number())
+});
+var PerCategoryAggregateSchema = z2.record(z2.string(), PerCategoryAggregateEntrySchema);
+var AggregatePassFailSchema = 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 AggregateDecisionVocabBarSchema = z2.object({
+  architecture: ArchitectureSchema,
+  required: z2.number().int().positive(),
+  median_produced: z2.number(),
+  // float — median of per-run decisions_produced_count
+  passed: z2.boolean()
+});
+var AggregateCalibrationReceiptSchema = z2.object({
+  schema_version: z2.literal(1),
+  receipt_kind: z2.literal("aggregate"),
+  // discriminates from single-run receipt
+  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(),
+  runs_count: z2.number().int().min(2),
+  run_files: z2.array(z2.string()),
+  // relative paths: runs/run-001.json, etc.
+  aggregated_at: z2.string(),
+  // ISO 8601
+  research_os_version: z2.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: z2.record(z2.string(), AggregateMetricSchema),
+  decision_vocab_bar: AggregateDecisionVocabBarSchema,
+  unreachable_decisions: z2.array(z2.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: z2.array(z2.string()),
+  notes: z2.array(z2.string())
+});
+export {
+  AggregateCalibrationReceiptSchema,
+  AggregateDecisionVocabBarSchema,
+  AggregateMetricSchema,
+  AggregatePassFailSchema,
+  PerCategoryAggregateEntrySchema,
+  PerCategoryAggregateSchema
+};
+//# sourceMappingURL=aggregate-receipt-schema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/calibration/aggregate-receipt-schema.ts","../../src/calibration/receipt-schema.ts"],"sourcesContent":["import { z } from 'zod';\nimport { StatusLabelSchema, ArchitectureSchema } from './receipt-schema.js';\n\nexport const AggregateMetricSchema = z.object({\n  median: z.number(),\n  min: z.number(),\n  max: z.number(),\n  values: z.array(z.number()), // per-run values in run order (run-001, run-002, ...)\n});\n\nexport const PerCategoryAggregateEntrySchema = z.object({\n  median_ratio: z.number().min(0).max(1),\n  min_ratio: z.number().min(0).max(1),\n  max_ratio: z.number().min(0).max(1),\n  total: z.number().int().nonnegative(), // seed count — same across all runs\n  per_run_ratios: z.array(z.number()),\n});\n\nexport const PerCategoryAggregateSchema = z.record(z.string(), PerCategoryAggregateEntrySchema);\n\nexport const AggregatePassFailSchema = z.object({\n  fp_ceiling: z.enum(['PASS', 'FAIL']),\n  any_flag_recall_floor: z.enum(['PASS', 'FAIL']),\n  per_category_any_flag_floor: z.enum(['PASS', 'FAIL']),\n  strict_recall_floor: z.enum(['PASS', 'FAIL']),\n  decision_vocab_completeness: z.enum(['PASS', 'FAIL']),\n  latency_soft: z.enum(['PASS', 'WARN']),\n  latency_hard: z.enum(['PASS', 'FAIL']),\n  empty_or_malformed: z.enum(['PASS', 'FAIL']),\n  overall: z.enum(['PASS', 'FAIL']),\n});\n\nexport const AggregateDecisionVocabBarSchema = z.object({\n  architecture: ArchitectureSchema,\n  required: z.number().int().positive(),\n  median_produced: z.number(), // float — median of per-run decisions_produced_count\n  passed: z.boolean(),\n});\n\nexport const AggregateCalibrationReceiptSchema = z.object({\n  schema_version: z.literal(1),\n  receipt_kind: z.literal('aggregate'), // discriminates from single-run receipt\n  profile_name: z.string(),\n  status: StatusLabelSchema,\n  model: z.string(),\n  architecture: ArchitectureSchema,\n  fixture: z.string(),\n  fixture_total_claims: z.number().int().positive(),\n  fixture_good_claims: z.number().int().nonnegative(),\n  fixture_bad_claims: z.number().int().nonnegative(),\n  runs_count: z.number().int().min(2),\n  run_files: z.array(z.string()), // relative paths: runs/run-001.json, etc.\n  aggregated_at: z.string(), // ISO 8601\n  research_os_version: z.string(),\n\n  // Aggregate metrics — median + min + max + per-run values in run order\n  good_fp_count: AggregateMetricSchema,\n  any_flag_recall_ratio: AggregateMetricSchema,\n  strict_recall_ratio: AggregateMetricSchema,\n  decisions_produced_count: AggregateMetricSchema,\n  runtime_ms: AggregateMetricSchema,\n  empty_or_malformed_responses: AggregateMetricSchema,\n\n  per_category_any_flag: PerCategoryAggregateSchema,\n  per_category_strict: PerCategoryAggregateSchema,\n\n  // Decision vocabulary — union of all decisions seen across runs, median count each\n  decision_vocabulary: z.record(z.string(), AggregateMetricSchema),\n  decision_vocab_bar: AggregateDecisionVocabBarSchema,\n  unreachable_decisions: z.array(z.string()),\n\n  pass_fail: AggregatePassFailSchema,\n  // Bars that FAILed in >= ceil(runs_count/2) individual runs.\n  // Non-empty list demotes trusted_baseline to conditional_pass.\n  recurring_bar_failures: z.array(z.string()),\n\n  notes: z.array(z.string()),\n});\n\nexport type AggregateMetric = z.infer<typeof AggregateMetricSchema>;\nexport type PerCategoryAggregateEntry = z.infer<typeof PerCategoryAggregateEntrySchema>;\nexport type PerCategoryAggregate = z.infer<typeof PerCategoryAggregateSchema>;\nexport type AggregatePassFail = z.infer<typeof AggregatePassFailSchema>;\nexport type AggregateDecisionVocabBar = z.infer<typeof AggregateDecisionVocabBarSchema>;\nexport type AggregateCalibrationReceipt = z.infer<typeof AggregateCalibrationReceiptSchema>;\n","import { z } from 'zod';\n\nexport const StatusLabelSchema = z.enum([\n  'trusted_baseline',\n  'conditional_pass',\n  'failed',\n  'comparison_only',\n]);\n\nexport const ArchitectureSchema = z.enum(['single-pass', 'two-pass']);\n\nexport const RecallSchema = z.object({\n  matched: z.number().int().nonnegative(),\n  total: z.number().int().nonnegative(),\n  ratio: z.number().min(0).max(1),\n});\n\nexport const PerCategoryRecallSchema = z.record(z.string(), RecallSchema);\n\nexport const PassFailSchema = z.object({\n  fp_ceiling: z.enum(['PASS', 'FAIL']),\n  any_flag_recall_floor: z.enum(['PASS', 'FAIL']),\n  per_category_any_flag_floor: z.enum(['PASS', 'FAIL']),\n  strict_recall_floor: z.enum(['PASS', 'FAIL']),\n  decision_vocab_completeness: z.enum(['PASS', 'FAIL']),\n  latency_soft: z.enum(['PASS', 'WARN']),\n  latency_hard: z.enum(['PASS', 'FAIL']),\n  empty_or_malformed: z.enum(['PASS', 'FAIL']),\n  overall: z.enum(['PASS', 'FAIL']),\n});\n\nexport const DecisionVocabBarSchema = z.object({\n  architecture: ArchitectureSchema,\n  required: z.number().int().positive(),\n  produced: z.number().int().nonnegative(),\n  passed: z.boolean(),\n});\n\nexport const CalibrationReceiptSchema = z.object({\n  schema_version: z.literal(1),\n  profile_name: z.string(),\n  status: StatusLabelSchema,\n  model: z.string(),\n  architecture: ArchitectureSchema,\n  fixture: z.string(),\n  fixture_total_claims: z.number().int().positive(),\n  fixture_good_claims: z.number().int().nonnegative(),\n  fixture_bad_claims: z.number().int().nonnegative(),\n  calibrated_at: z.string(),\n  research_os_version: z.string(),\n  runtime_ms: z.number().int().nonnegative(),\n  good_fp_count: z.number().int().nonnegative(),\n  any_flag_recall: RecallSchema,\n  strict_recall: RecallSchema,\n  per_category_any_flag: PerCategoryRecallSchema,\n  per_category_strict: PerCategoryRecallSchema,\n  decision_vocabulary: z.record(z.string(), z.number().int().nonnegative()),\n  decisions_produced_count: z.number().int().nonnegative(),\n  decision_vocab_bar: DecisionVocabBarSchema,\n  unreachable_decisions: z.array(z.string()),\n  empty_or_malformed_responses: z.number().int().nonnegative(),\n  pass_fail: PassFailSchema,\n  notes: z.array(z.string()),\n});\n\nexport type StatusLabel = z.infer<typeof StatusLabelSchema>;\nexport type Architecture = z.infer<typeof ArchitectureSchema>;\nexport type Recall = z.infer<typeof RecallSchema>;\nexport type PerCategoryRecall = z.infer<typeof PerCategoryRecallSchema>;\nexport type PassFail = z.infer<typeof PassFailSchema>;\nexport type DecisionVocabBar = z.infer<typeof DecisionVocabBarSchema>;\nexport type CalibrationReceipt = z.infer<typeof CalibrationReceiptSchema>;\n"],"mappings":"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","names":["z","z"]}

package/dist/calibration/aggregate.d.ts

@@ -0,0 +1,35 @@
+import { PerCategoryRecall, CalibrationReceipt, Architecture, StatusLabel, PassFail } from './receipt-schema.js';
+import { AggregateMetric, PerCategoryAggregate, AggregateCalibrationReceipt, AggregatePassFail } from './aggregate-receipt-schema.js';
+import 'zod';
+
+declare function median(values: number[]): number;
+declare function aggregateMetric(values: number[]): AggregateMetric;
+declare function aggregatePerCategoryRecall(perRunBuckets: PerCategoryRecall[]): PerCategoryAggregate;
+declare function aggregateDecisionVocabulary(perRunDicts: Record<string, number>[]): Record<string, AggregateMetric>;
+declare function computeAggregatePassFail(input: {
+    good_fp_count: AggregateMetric;
+    any_flag_recall_ratio: AggregateMetric;
+    per_category_any_flag: PerCategoryAggregate;
+    strict_recall_ratio: AggregateMetric;
+    decisions_produced_count: AggregateMetric;
+    architecture: Architecture;
+    runtime_ms: AggregateMetric;
+    empty_or_malformed_responses: AggregateMetric;
+}): AggregatePassFail;
+declare function computeRecurringBarFailures(perRunPassFails: PassFail[], totalRuns: number): string[];
+declare function computeAggregateStatusLabel(input: {
+    profileName: string;
+    architecture: Architecture;
+    aggregatePassFail: AggregatePassFail;
+    medianGoodFpCount: number;
+    recurringBarFailures: string[];
+    modeOverride?: 'comparison_only';
+}): StatusLabel;
+declare function aggregateReceipts(runs: CalibrationReceipt[], opts: {
+    runFiles: string[];
+    modeOverride?: 'comparison_only';
+    aggregatedAt?: string;
+}): AggregateCalibrationReceipt;
+declare function buildAggregateReceiptMarkdown(r: AggregateCalibrationReceipt): string;
+
+export { aggregateDecisionVocabulary, aggregateMetric, aggregatePerCategoryRecall, aggregateReceipts, buildAggregateReceiptMarkdown, computeAggregatePassFail, computeAggregateStatusLabel, computeRecurringBarFailures, median };

package/dist/calibration/aggregate.js

@@ -0,0 +1,454 @@
+// src/calibration/aggregate-receipt-schema.ts
+import { z as z2 } from "zod";
+
+// src/calibration/receipt-schema.ts
+import { z } from "zod";
+var StatusLabelSchema = z.enum([
+  "trusted_baseline",
+  "conditional_pass",
+  "failed",
+  "comparison_only"
+]);
+var ArchitectureSchema = z.enum(["single-pass", "two-pass"]);
+var RecallSchema = z.object({
+  matched: z.number().int().nonnegative(),
+  total: z.number().int().nonnegative(),
+  ratio: z.number().min(0).max(1)
+});
+var PerCategoryRecallSchema = z.record(z.string(), RecallSchema);
+var PassFailSchema = z.object({
+  fp_ceiling: z.enum(["PASS", "FAIL"]),
+  any_flag_recall_floor: z.enum(["PASS", "FAIL"]),
+  per_category_any_flag_floor: z.enum(["PASS", "FAIL"]),
+  strict_recall_floor: z.enum(["PASS", "FAIL"]),
+  decision_vocab_completeness: z.enum(["PASS", "FAIL"]),
+  latency_soft: z.enum(["PASS", "WARN"]),
+  latency_hard: z.enum(["PASS", "FAIL"]),
+  empty_or_malformed: z.enum(["PASS", "FAIL"]),
+  overall: z.enum(["PASS", "FAIL"])
+});
+var DecisionVocabBarSchema = z.object({
+  architecture: ArchitectureSchema,
+  required: z.number().int().positive(),
+  produced: z.number().int().nonnegative(),
+  passed: z.boolean()
+});
+var CalibrationReceiptSchema = z.object({
+  schema_version: z.literal(1),
+  profile_name: z.string(),
+  status: StatusLabelSchema,
+  model: z.string(),
+  architecture: ArchitectureSchema,
+  fixture: z.string(),
+  fixture_total_claims: z.number().int().positive(),
+  fixture_good_claims: z.number().int().nonnegative(),
+  fixture_bad_claims: z.number().int().nonnegative(),
+  calibrated_at: z.string(),
+  research_os_version: z.string(),
+  runtime_ms: z.number().int().nonnegative(),
+  good_fp_count: z.number().int().nonnegative(),
+  any_flag_recall: RecallSchema,
+  strict_recall: RecallSchema,
+  per_category_any_flag: PerCategoryRecallSchema,
+  per_category_strict: PerCategoryRecallSchema,
+  decision_vocabulary: z.record(z.string(), z.number().int().nonnegative()),
+  decisions_produced_count: z.number().int().nonnegative(),
+  decision_vocab_bar: DecisionVocabBarSchema,
+  unreachable_decisions: z.array(z.string()),
+  empty_or_malformed_responses: z.number().int().nonnegative(),
+  pass_fail: PassFailSchema,
+  notes: z.array(z.string())
+});
+
+// src/calibration/aggregate-receipt-schema.ts
+var AggregateMetricSchema = z2.object({
+  median: z2.number(),
+  min: z2.number(),
+  max: z2.number(),
+  values: z2.array(z2.number())
+  // per-run values in run order (run-001, run-002, ...)
+});
+var PerCategoryAggregateEntrySchema = z2.object({
+  median_ratio: z2.number().min(0).max(1),
+  min_ratio: z2.number().min(0).max(1),
+  max_ratio: z2.number().min(0).max(1),
+  total: z2.number().int().nonnegative(),
+  // seed count — same across all runs
+  per_run_ratios: z2.array(z2.number())
+});
+var PerCategoryAggregateSchema = z2.record(z2.string(), PerCategoryAggregateEntrySchema);
+var AggregatePassFailSchema = 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 AggregateDecisionVocabBarSchema = z2.object({
+  architecture: ArchitectureSchema,
+  required: z2.number().int().positive(),
+  median_produced: z2.number(),
+  // float — median of per-run decisions_produced_count
+  passed: z2.boolean()
+});
+var AggregateCalibrationReceiptSchema = z2.object({
+  schema_version: z2.literal(1),
+  receipt_kind: z2.literal("aggregate"),
+  // discriminates from single-run receipt
+  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(),
+  runs_count: z2.number().int().min(2),
+  run_files: z2.array(z2.string()),
+  // relative paths: runs/run-001.json, etc.
+  aggregated_at: z2.string(),
+  // ISO 8601
+  research_os_version: z2.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: z2.record(z2.string(), AggregateMetricSchema),
+  decision_vocab_bar: AggregateDecisionVocabBarSchema,
+  unreachable_decisions: z2.array(z2.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: z2.array(z2.string()),
+  notes: z2.array(z2.string())
+});
+
+// src/calibration/aggregate.ts
+function median(values) {
+  if (values.length === 0) throw new Error("median: empty array");
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 1) return sorted[mid];
+  return (sorted[mid - 1] + sorted[mid]) / 2;
+}
+function aggregateMetric(values) {
+  const m = median(values);
+  return {
+    median: m,
+    min: Math.min(...values),
+    max: Math.max(...values),
+    values
+  };
+}
+function aggregatePerCategoryRecall(perRunBuckets) {
+  const cats = /* @__PURE__ */ new Set();
+  for (const run of perRunBuckets) {
+    for (const cat of Object.keys(run)) cats.add(cat);
+  }
+  const result = {};
+  for (const cat of cats) {
+    const ratios = perRunBuckets.map((run) => run[cat]?.ratio ?? 0);
+    const total = perRunBuckets.find((run) => run[cat] !== void 0)?.[cat]?.total ?? 0;
+    result[cat] = {
+      median_ratio: median(ratios),
+      min_ratio: Math.min(...ratios),
+      max_ratio: Math.max(...ratios),
+      total,
+      per_run_ratios: ratios
+    };
+  }
+  return result;
+}
+function aggregateDecisionVocabulary(perRunDicts) {
+  const decisions = /* @__PURE__ */ new Set();
+  for (const run of perRunDicts) {
+    for (const d of Object.keys(run)) decisions.add(d);
+  }
+  const result = {};
+  for (const d of decisions) {
+    const values = perRunDicts.map((run) => run[d] ?? 0);
+    result[d] = aggregateMetric(values);
+  }
+  return result;
+}
+function computeAggregatePassFail(input) {
+  const fp_ceiling = input.good_fp_count.median <= 1 && input.good_fp_count.max <= 2 ? "PASS" : "FAIL";
+  const any_flag_recall_floor = input.any_flag_recall_ratio.median >= 0.65 ? "PASS" : "FAIL";
+  let per_category_any_flag_floor = "PASS";
+  for (const entry of Object.values(input.per_category_any_flag)) {
+    if (entry.total >= 2 && entry.median_ratio < 0.5) {
+      per_category_any_flag_floor = "FAIL";
+      break;
+    }
+  }
+  const strict_recall_floor = input.strict_recall_ratio.median >= 0.2 ? "PASS" : "FAIL";
+  const dvRequired = input.architecture === "two-pass" ? 3 : 4;
+  const decision_vocab_completeness = input.decisions_produced_count.median >= dvRequired ? "PASS" : "FAIL";
+  const latency_soft = input.runtime_ms.median <= 6e5 ? "PASS" : "WARN";
+  const latency_hard = input.runtime_ms.max <= 12e5 ? "PASS" : "FAIL";
+  const empty_or_malformed = input.empty_or_malformed_responses.max === 0 ? "PASS" : "FAIL";
+  const hardBars = [
+    fp_ceiling,
+    any_flag_recall_floor,
+    per_category_any_flag_floor,
+    strict_recall_floor,
+    decision_vocab_completeness,
+    latency_hard,
+    empty_or_malformed
+  ];
+  const overall = hardBars.every((v) => v === "PASS") ? "PASS" : "FAIL";
+  return {
+    fp_ceiling,
+    any_flag_recall_floor,
+    per_category_any_flag_floor,
+    strict_recall_floor,
+    decision_vocab_completeness,
+    latency_soft,
+    latency_hard,
+    empty_or_malformed,
+    overall
+  };
+}
+function computeRecurringBarFailures(perRunPassFails, totalRuns) {
+  const threshold = Math.ceil(totalRuns / 2);
+  const HARD_BARS = [
+    "fp_ceiling",
+    "any_flag_recall_floor",
+    "per_category_any_flag_floor",
+    "strict_recall_floor",
+    "decision_vocab_completeness",
+    "latency_hard",
+    "empty_or_malformed"
+  ];
+  const recurring = [];
+  for (const bar of HARD_BARS) {
+    const failCount = perRunPassFails.filter((pf) => pf[bar] === "FAIL").length;
+    if (failCount >= threshold) recurring.push(bar);
+  }
+  return recurring;
+}
+function computeAggregateStatusLabel(input) {
+  if (input.modeOverride === "comparison_only") return "comparison_only";
+  if (input.architecture === "single-pass" && /hermes/i.test(input.profileName)) {
+    return "comparison_only";
+  }
+  if (input.aggregatePassFail.overall === "FAIL") return "failed";
+  const isHermesTwoPass = /hermes/i.test(input.profileName) && input.architecture === "two-pass";
+  if (isHermesTwoPass && input.medianGoodFpCount === 0 && input.recurringBarFailures.length === 0) {
+    return "trusted_baseline";
+  }
+  return "conditional_pass";
+}
+function aggregateReceipts(runs, opts) {
+  if (runs.length === 0) throw new Error("aggregateReceipts: no runs provided");
+  const first = runs[0];
+  const fpMetric = aggregateMetric(runs.map((r) => r.good_fp_count));
+  const anyFlagRatioMetric = aggregateMetric(runs.map((r) => r.any_flag_recall.ratio));
+  const strictRatioMetric = aggregateMetric(runs.map((r) => r.strict_recall.ratio));
+  const decisionsMetric = aggregateMetric(runs.map((r) => r.decisions_produced_count));
+  const runtimeMetric = aggregateMetric(runs.map((r) => r.runtime_ms));
+  const emptyOrMalformedMetric = aggregateMetric(
+    runs.map((r) => r.empty_or_malformed_responses)
+  );
+  const perCatAnyFlag = aggregatePerCategoryRecall(runs.map((r) => r.per_category_any_flag));
+  const perCatStrict = aggregatePerCategoryRecall(runs.map((r) => r.per_category_strict));
+  const decisionVocab = aggregateDecisionVocabulary(runs.map((r) => r.decision_vocabulary));
+  const dvRequired = first.architecture === "two-pass" ? 3 : 4;
+  const decisionVocabBar = {
+    architecture: first.architecture,
+    required: dvRequired,
+    median_produced: decisionsMetric.median,
+    passed: decisionsMetric.median >= dvRequired
+  };
+  const aggregatePassFail = computeAggregatePassFail({
+    good_fp_count: fpMetric,
+    any_flag_recall_ratio: anyFlagRatioMetric,
+    per_category_any_flag: perCatAnyFlag,
+    strict_recall_ratio: strictRatioMetric,
+    decisions_produced_count: decisionsMetric,
+    architecture: first.architecture,
+    runtime_ms: runtimeMetric,
+    empty_or_malformed_responses: emptyOrMalformedMetric
+  });
+  const recurringBarFailures = computeRecurringBarFailures(
+    runs.map((r) => r.pass_fail),
+    runs.length
+  );
+  const status = computeAggregateStatusLabel({
+    profileName: first.profile_name,
+    architecture: first.architecture,
+    aggregatePassFail,
+    medianGoodFpCount: fpMetric.median,
+    recurringBarFailures,
+    modeOverride: opts.modeOverride
+  });
+  const notes = [];
+  if (aggregatePassFail.latency_soft === "WARN") {
+    notes.push(
+      `Latency warning: median ${(runtimeMetric.median / 1e3).toFixed(1)}s exceeds soft limit of 600s`
+    );
+  }
+  if (fpMetric.median > 0) {
+    notes.push(`FP at ceiling: median ${fpMetric.median} false positive(s) on good claims`);
+  }
+  if (recurringBarFailures.length > 0) {
+    notes.push(`Recurring bar failures (>= ceil(N/2) runs): ${recurringBarFailures.join(", ")}`);
+  }
+  if (status === "comparison_only") {
+    notes.push(
+      "comparison_only: architectural side-run, not a production admission candidate"
+    );
+  }
+  if (status === "conditional_pass") {
+    notes.push("conditional_pass: passes all bars but carries a production caution");
+  }
+  return AggregateCalibrationReceiptSchema.parse({
+    schema_version: 1,
+    receipt_kind: "aggregate",
+    profile_name: first.profile_name,
+    status,
+    model: first.model,
+    architecture: first.architecture,
+    fixture: first.fixture,
+    fixture_total_claims: first.fixture_total_claims,
+    fixture_good_claims: first.fixture_good_claims,
+    fixture_bad_claims: first.fixture_bad_claims,
+    runs_count: runs.length,
+    run_files: opts.runFiles,
+    aggregated_at: opts.aggregatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    research_os_version: first.research_os_version,
+    good_fp_count: fpMetric,
+    any_flag_recall_ratio: anyFlagRatioMetric,
+    strict_recall_ratio: strictRatioMetric,
+    decisions_produced_count: decisionsMetric,
+    runtime_ms: runtimeMetric,
+    empty_or_malformed_responses: emptyOrMalformedMetric,
+    per_category_any_flag: perCatAnyFlag,
+    per_category_strict: perCatStrict,
+    decision_vocabulary: decisionVocab,
+    decision_vocab_bar: decisionVocabBar,
+    unreachable_decisions: first.unreachable_decisions,
+    pass_fail: aggregatePassFail,
+    recurring_bar_failures: recurringBarFailures,
+    notes
+  });
+}
+function buildAggregateReceiptMarkdown(r) {
+  const pct = (ratio) => `${Math.round(ratio * 100)}%`;
+  const secRounded = (ms) => `${(ms / 1e3).toFixed(1)}s`;
+  const af = r.any_flag_recall_ratio;
+  const sr = r.strict_recall_ratio;
+  const fp = r.good_fp_count;
+  const dec = r.decisions_produced_count;
+  const rt = r.runtime_ms;
+  const pf = r.pass_fail;
+  const bar = r.decision_vocab_bar;
+  const runFileList = r.run_files.length > 0 ? `${r.run_files[0]} \u2026 ${r.run_files[r.run_files.length - 1]}` : "(none)";
+  const perCatAnyFlagRows = Object.entries(r.per_category_any_flag).map(([cat, entry]) => {
+    const st = r.per_category_strict[cat];
+    return `| ${cat} | ${pct(entry.median_ratio)} | ${pct(entry.min_ratio)}\u2013${pct(entry.max_ratio)} | ${entry.total} |` + (st ? ` ${pct(st.median_ratio)} | ${pct(st.min_ratio)}\u2013${pct(st.max_ratio)} |` : " \u2014 | \u2014 |");
+  }).join("\n");
+  const ALL_DECISIONS = [
+    "accepted_for_synthesis",
+    "rejected",
+    "needs_scope_repair",
+    "needs_source_repair",
+    "needs_contradiction_mapping",
+    "needs_human_review"
+  ];
+  const dvRows = ALL_DECISIONS.map((d) => {
+    const metric = r.decision_vocabulary[d];
+    const unreachable = r.unreachable_decisions.includes(d) ? ` (unreachable from ${r.fixture})` : "";
+    if (!metric) return `| ${d} | \u2014 | \u2014 |${unreachable}`;
+    return `| ${d} | ${metric.median.toFixed(1)} | ${metric.min}\u2013${metric.max}${unreachable} |`;
+  }).join("\n");
+  const perRunRows = r.any_flag_recall_ratio.values.map((afr, i) => {
+    const fp_i = r.good_fp_count.values[i] ?? "?";
+    const sr_i = r.strict_recall_ratio.values[i] ?? "?";
+    const dec_i = r.decisions_produced_count.values[i] ?? "?";
+    const rt_i = r.runtime_ms.values[i] ?? "?";
+    return `| ${i + 1} | ${fp_i}/${r.fixture_good_claims} | ${typeof afr === "number" ? pct(afr) : "?"} | ${typeof sr_i === "number" ? pct(sr_i) : "?"} | ${dec_i}/6 | ${typeof rt_i === "number" ? secRounded(rt_i) : "?"} |`;
+  }).join("\n");
+  const recurringSection = r.recurring_bar_failures.length > 0 ? r.recurring_bar_failures.map((b) => `- ${b}`).join("\n") : "None.";
+  const notesSection = r.notes.length > 0 ? `
+## Notes
+
+${r.notes.map((n) => `- ${n}`).join("\n")}
+` : "";
+  return `# Calibration Receipt \u2014 ${r.profile_name} (aggregate, N=${r.runs_count} runs)
+
+- **Model:** ${r.model}
+- **Architecture:** ${r.architecture}
+- **Status:** ${r.status}
+- **Fixture:** ${r.fixture} (${r.fixture_total_claims} claims = ${r.fixture_good_claims} good + ${r.fixture_bad_claims} bad)
+- **Aggregated at:** ${r.aggregated_at}
+- **Research-OS version:** ${r.research_os_version}
+- **Run count:** ${r.runs_count}
+- **Run files:** ${runFileList}
+
+## Headline metrics (median across runs)
+
+- FP: median ${fp.median} / ${r.fixture_good_claims} (range ${fp.min}\u2013${fp.max})
+- Any-flag recall: median ${pct(af.median)} (range ${pct(af.min)}\u2013${pct(af.max)})
+- Strict recall: median ${pct(sr.median)} (range ${pct(sr.min)}\u2013${pct(sr.max)})
+- Decisions produced: median ${dec.median} / 6 (range ${dec.min}\u2013${dec.max})
+
+## PASS / FAIL (aggregate)
+
+| Bar | Rule | Result |
+|---|---|---|
+| FP ceiling | median=${fp.median}, max=${fp.max} (median \u22641 AND max \u22642) | ${pf.fp_ceiling} |
+| Any-flag recall | median=${pct(af.median)} (\u226565%) | ${pf.any_flag_recall_floor} |
+| Per-category any-flag | median \u226550% per cat (see below) | ${pf.per_category_any_flag_floor} |
+| Strict recall | median=${pct(sr.median)} (\u226520%) | ${pf.strict_recall_floor} |
+| Decision vocab | median=${dec.median} / 6 (${bar.architecture} \u2265${bar.required}) | ${pf.decision_vocab_completeness} |
+| Latency soft | median=${secRounded(rt.median)} (\u2264600s, WARN only) | ${pf.latency_soft} |
+| Latency hard | max=${secRounded(rt.max)} (every run \u22641200s) | ${pf.latency_hard} |
+| Empty/malformed | max=${r.empty_or_malformed_responses.max} (every run =0) | ${pf.empty_or_malformed} |
+| **OVERALL** | | **${pf.overall}** |
+
+## Recurring hard-bar failures
+
+${recurringSection}
+
+## Per-category recall (median across runs)
+
+| Category | Any-flag median | Any-flag range | Total | Strict median | Strict range |
+|---|---|---|---|---|---|
+${perCatAnyFlagRows}
+
+## Decision vocabulary (median count across runs)
+
+| Decision | Median | Range |
+|---|---|---|
+${dvRows}
+
+## Per-run summary
+
+| Run | FP | Any-flag | Strict | Decisions | Runtime |
+|---|---|---|---|---|---|
+${perRunRows}
+${notesSection}`;
+}
+export {
+  aggregateDecisionVocabulary,
+  aggregateMetric,
+  aggregatePerCategoryRecall,
+  aggregateReceipts,
+  buildAggregateReceiptMarkdown,
+  computeAggregatePassFail,
+  computeAggregateStatusLabel,
+  computeRecurringBarFailures,
+  median
+};
+//# sourceMappingURL=aggregate.js.map