@mcptoolshop/research-os 0.4.0 → 0.5.0

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

@@ -0,0 +1,317 @@
+import { z } from 'zod';
+
+declare const StatusLabelSchema: z.ZodEnum<["trusted_baseline", "conditional_pass", "failed", "comparison_only"]>;
+declare const ArchitectureSchema: z.ZodEnum<["single-pass", "two-pass"]>;
+declare const RecallSchema: z.ZodObject<{
+    matched: z.ZodNumber;
+    total: z.ZodNumber;
+    ratio: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    matched: number;
+    total: number;
+    ratio: number;
+}, {
+    matched: number;
+    total: number;
+    ratio: number;
+}>;
+declare const PerCategoryRecallSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    matched: z.ZodNumber;
+    total: z.ZodNumber;
+    ratio: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    matched: number;
+    total: number;
+    ratio: number;
+}, {
+    matched: number;
+    total: number;
+    ratio: number;
+}>>;
+declare const PassFailSchema: 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 DecisionVocabBarSchema: z.ZodObject<{
+    architecture: z.ZodEnum<["single-pass", "two-pass"]>;
+    required: z.ZodNumber;
+    produced: z.ZodNumber;
+    passed: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    required: number;
+    architecture: "single-pass" | "two-pass";
+    produced: number;
+    passed: boolean;
+}, {
+    required: number;
+    architecture: "single-pass" | "two-pass";
+    produced: number;
+    passed: boolean;
+}>;
+declare const CalibrationReceiptSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    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;
+    calibrated_at: z.ZodString;
+    research_os_version: z.ZodString;
+    runtime_ms: z.ZodNumber;
+    good_fp_count: z.ZodNumber;
+    any_flag_recall: z.ZodObject<{
+        matched: z.ZodNumber;
+        total: z.ZodNumber;
+        ratio: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        matched: number;
+        total: number;
+        ratio: number;
+    }, {
+        matched: number;
+        total: number;
+        ratio: number;
+    }>;
+    strict_recall: z.ZodObject<{
+        matched: z.ZodNumber;
+        total: z.ZodNumber;
+        ratio: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        matched: number;
+        total: number;
+        ratio: number;
+    }, {
+        matched: number;
+        total: number;
+        ratio: number;
+    }>;
+    per_category_any_flag: z.ZodRecord<z.ZodString, z.ZodObject<{
+        matched: z.ZodNumber;
+        total: z.ZodNumber;
+        ratio: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        matched: number;
+        total: number;
+        ratio: number;
+    }, {
+        matched: number;
+        total: number;
+        ratio: number;
+    }>>;
+    per_category_strict: z.ZodRecord<z.ZodString, z.ZodObject<{
+        matched: z.ZodNumber;
+        total: z.ZodNumber;
+        ratio: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        matched: number;
+        total: number;
+        ratio: number;
+    }, {
+        matched: number;
+        total: number;
+        ratio: number;
+    }>>;
+    decision_vocabulary: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    decisions_produced_count: z.ZodNumber;
+    decision_vocab_bar: z.ZodObject<{
+        architecture: z.ZodEnum<["single-pass", "two-pass"]>;
+        required: z.ZodNumber;
+        produced: z.ZodNumber;
+        passed: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        required: number;
+        architecture: "single-pass" | "two-pass";
+        produced: number;
+        passed: boolean;
+    }, {
+        required: number;
+        architecture: "single-pass" | "two-pass";
+        produced: number;
+        passed: boolean;
+    }>;
+    unreachable_decisions: z.ZodArray<z.ZodString, "many">;
+    empty_or_malformed_responses: z.ZodNumber;
+    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";
+    }>;
+    notes: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    research_os_version: string;
+    status: "trusted_baseline" | "conditional_pass" | "failed" | "comparison_only";
+    notes: string[];
+    schema_version: 1;
+    profile_name: string;
+    model: string;
+    architecture: "single-pass" | "two-pass";
+    fixture: string;
+    fixture_total_claims: number;
+    fixture_good_claims: number;
+    fixture_bad_claims: number;
+    calibrated_at: string;
+    runtime_ms: number;
+    good_fp_count: number;
+    any_flag_recall: {
+        matched: number;
+        total: number;
+        ratio: number;
+    };
+    strict_recall: {
+        matched: number;
+        total: number;
+        ratio: number;
+    };
+    per_category_any_flag: Record<string, {
+        matched: number;
+        total: number;
+        ratio: number;
+    }>;
+    per_category_strict: Record<string, {
+        matched: number;
+        total: number;
+        ratio: number;
+    }>;
+    decision_vocabulary: Record<string, number>;
+    decisions_produced_count: number;
+    decision_vocab_bar: {
+        required: number;
+        architecture: "single-pass" | "two-pass";
+        produced: number;
+        passed: boolean;
+    };
+    unreachable_decisions: string[];
+    empty_or_malformed_responses: number;
+    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";
+    };
+}, {
+    research_os_version: string;
+    status: "trusted_baseline" | "conditional_pass" | "failed" | "comparison_only";
+    notes: string[];
+    schema_version: 1;
+    profile_name: string;
+    model: string;
+    architecture: "single-pass" | "two-pass";
+    fixture: string;
+    fixture_total_claims: number;
+    fixture_good_claims: number;
+    fixture_bad_claims: number;
+    calibrated_at: string;
+    runtime_ms: number;
+    good_fp_count: number;
+    any_flag_recall: {
+        matched: number;
+        total: number;
+        ratio: number;
+    };
+    strict_recall: {
+        matched: number;
+        total: number;
+        ratio: number;
+    };
+    per_category_any_flag: Record<string, {
+        matched: number;
+        total: number;
+        ratio: number;
+    }>;
+    per_category_strict: Record<string, {
+        matched: number;
+        total: number;
+        ratio: number;
+    }>;
+    decision_vocabulary: Record<string, number>;
+    decisions_produced_count: number;
+    decision_vocab_bar: {
+        required: number;
+        architecture: "single-pass" | "two-pass";
+        produced: number;
+        passed: boolean;
+    };
+    unreachable_decisions: string[];
+    empty_or_malformed_responses: number;
+    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";
+    };
+}>;
+type StatusLabel = z.infer<typeof StatusLabelSchema>;
+type Architecture = z.infer<typeof ArchitectureSchema>;
+type Recall = z.infer<typeof RecallSchema>;
+type PerCategoryRecall = z.infer<typeof PerCategoryRecallSchema>;
+type PassFail = z.infer<typeof PassFailSchema>;
+type DecisionVocabBar = z.infer<typeof DecisionVocabBarSchema>;
+type CalibrationReceipt = z.infer<typeof CalibrationReceiptSchema>;
+
+export { type Architecture, ArchitectureSchema, type CalibrationReceipt, CalibrationReceiptSchema, type DecisionVocabBar, DecisionVocabBarSchema, type PassFail, PassFailSchema, type PerCategoryRecall, PerCategoryRecallSchema, type Recall, RecallSchema, type StatusLabel, StatusLabelSchema };

package/dist/calibration/receipt-schema.js

@@ -0,0 +1,68 @@
+// 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())
+});
+export {
+  ArchitectureSchema,
+  CalibrationReceiptSchema,
+  DecisionVocabBarSchema,
+  PassFailSchema,
+  PerCategoryRecallSchema,
+  RecallSchema,
+  StatusLabelSchema
+};
+//# sourceMappingURL=receipt-schema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/calibration/receipt-schema.ts"],"sourcesContent":["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":";AAAA,SAAS,SAAS;AAEX,IAAM,oBAAoB,EAAE,KAAK;AAAA,EACtC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAEM,IAAM,qBAAqB,EAAE,KAAK,CAAC,eAAe,UAAU,CAAC;AAE7D,IAAM,eAAe,EAAE,OAAO;AAAA,EACnC,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY;AAAA,EACtC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY;AAAA,EACpC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC;AAChC,CAAC;AAEM,IAAM,0BAA0B,EAAE,OAAO,EAAE,OAAO,GAAG,YAAY;AAEjE,IAAM,iBAAiB,EAAE,OAAO;AAAA,EACrC,YAAY,EAAE,KAAK,CAAC,QAAQ,MAAM,CAAC;AAAA,EACnC,uBAAuB,EAAE,KAAK,CAAC,QAAQ,MAAM,CAAC;AAAA,EAC9C,6BAA6B,EAAE,KAAK,CAAC,QAAQ,MAAM,CAAC;AAAA,EACpD,qBAAqB,EAAE,KAAK,CAAC,QAAQ,MAAM,CAAC;AAAA,EAC5C,6BAA6B,EAAE,KAAK,CAAC,QAAQ,MAAM,CAAC;AAAA,EACpD,cAAc,EAAE,KAAK,CAAC,QAAQ,MAAM,CAAC;AAAA,EACrC,cAAc,EAAE,KAAK,CAAC,QAAQ,MAAM,CAAC;AAAA,EACrC,oBAAoB,EAAE,KAAK,CAAC,QAAQ,MAAM,CAAC;AAAA,EAC3C,SAAS,EAAE,KAAK,CAAC,QAAQ,MAAM,CAAC;AAClC,CAAC;AAEM,IAAM,yBAAyB,EAAE,OAAO;AAAA,EAC7C,cAAc;AAAA,EACd,UAAU,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS;AAAA,EACpC,UAAU,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY;AAAA,EACvC,QAAQ,EAAE,QAAQ;AACpB,CAAC;AAEM,IAAM,2BAA2B,EAAE,OAAO;AAAA,EAC/C,gBAAgB,EAAE,QAAQ,CAAC;AAAA,EAC3B,cAAc,EAAE,OAAO;AAAA,EACvB,QAAQ;AAAA,EACR,OAAO,EAAE,OAAO;AAAA,EAChB,cAAc;AAAA,EACd,SAAS,EAAE,OAAO;AAAA,EAClB,sBAAsB,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS;AAAA,EAChD,qBAAqB,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY;AAAA,EAClD,oBAAoB,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY;AAAA,EACjD,eAAe,EAAE,OAAO;AAAA,EACxB,qBAAqB,EAAE,OAAO;AAAA,EAC9B,YAAY,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY;AAAA,EACzC,eAAe,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY;AAAA,EAC5C,iBAAiB;AAAA,EACjB,eAAe;AAAA,EACf,uBAAuB;AAAA,EACvB,qBAAqB;AAAA,EACrB,qBAAqB,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,CAAC;AAAA,EACxE,0BAA0B,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY;AAAA,EACvD,oBAAoB;AAAA,EACpB,uBAAuB,EAAE,MAAM,EAAE,OAAO,CAAC;AAAA,EACzC,8BAA8B,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY;AAAA,EAC3D,WAAW;AAAA,EACX,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC;AAC3B,CAAC;","names":[]}

package/dist/calibration/receipt.d.ts

@@ -0,0 +1,31 @@
+import { CalibrationReceipt, Architecture, DecisionVocabBar, Recall, PerCategoryRecall, PassFail, StatusLabel } from './receipt-schema.js';
+import 'zod';
+
+declare function computeDecisionVocabBar(architecture: Architecture, decisionsProducedCount: number): DecisionVocabBar;
+declare function computePassFail(input: {
+    good_fp_count: number;
+    any_flag_recall: Recall;
+    per_category_any_flag: PerCategoryRecall;
+    strict_recall: Recall;
+    decision_vocab_bar: DecisionVocabBar;
+    runtime_ms: number;
+    empty_or_malformed_responses: number;
+}): PassFail;
+declare function computeStatusLabel(input: {
+    profileName: string;
+    architecture: Architecture;
+    passFail: PassFail;
+    goodFpCount: number;
+    modeOverride?: 'comparison_only';
+}): StatusLabel;
+declare function receiptToCalibrationSummary(receipt: CalibrationReceipt): {
+    fixture: string | null;
+    good_false_positive_rate: string | null;
+    bad_any_flag_recall: string | null;
+    strict_category_recall: string | null;
+    unsupported_claim_recall: string | null;
+    notes: string | null;
+};
+declare function buildReceiptMarkdown(r: CalibrationReceipt): string;
+
+export { buildReceiptMarkdown, computeDecisionVocabBar, computePassFail, computeStatusLabel, receiptToCalibrationSummary };

package/dist/calibration/receipt.js

@@ -0,0 +1,151 @@
+// src/calibration/receipt.ts
+function computeDecisionVocabBar(architecture, decisionsProducedCount) {
+  const required = architecture === "two-pass" ? 3 : 4;
+  return {
+    architecture,
+    required,
+    produced: decisionsProducedCount,
+    passed: decisionsProducedCount >= required
+  };
+}
+function computePerCategoryFloor(perCategoryAnyFlag) {
+  for (const [, recall] of Object.entries(perCategoryAnyFlag)) {
+    if (recall.total >= 2 && recall.ratio < 0.5) return "FAIL";
+  }
+  return "PASS";
+}
+function computePassFail(input) {
+  const fp_ceiling = input.good_fp_count <= 1 ? "PASS" : "FAIL";
+  const any_flag_recall_floor = input.any_flag_recall.ratio >= 0.65 ? "PASS" : "FAIL";
+  const per_category_any_flag_floor = computePerCategoryFloor(input.per_category_any_flag);
+  const strict_recall_floor = input.strict_recall.ratio >= 0.2 ? "PASS" : "FAIL";
+  const decision_vocab_completeness = input.decision_vocab_bar.passed ? "PASS" : "FAIL";
+  const latency_soft = input.runtime_ms <= 6e5 ? "PASS" : "WARN";
+  const latency_hard = input.runtime_ms <= 12e5 ? "PASS" : "FAIL";
+  const empty_or_malformed = input.empty_or_malformed_responses === 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 computeStatusLabel(input) {
+  if (input.modeOverride === "comparison_only") return "comparison_only";
+  if (input.architecture === "single-pass" && /hermes/i.test(input.profileName)) {
+    return "comparison_only";
+  }
+  if (input.passFail.overall === "FAIL") return "failed";
+  const isHermesTwoPass = /hermes/i.test(input.profileName) && input.architecture === "two-pass";
+  if (isHermesTwoPass && input.goodFpCount === 0) return "trusted_baseline";
+  return "conditional_pass";
+}
+function receiptToCalibrationSummary(receipt) {
+  const fp = receipt.good_fp_count;
+  const fpTotal = receipt.fixture_good_claims;
+  const fpPct = fpTotal > 0 ? Math.round(fp / fpTotal * 100) : 0;
+  const af = receipt.any_flag_recall;
+  const sr = receipt.strict_recall;
+  const unsupported = receipt.per_category_any_flag["unsupported_claim"];
+  return {
+    fixture: receipt.fixture,
+    good_false_positive_rate: `${fp}/${fpTotal} (${fpPct}%)`,
+    bad_any_flag_recall: `${af.matched}/${af.total} (${Math.round(af.ratio * 100)}%)`,
+    strict_category_recall: `${sr.matched}/${sr.total} (${Math.round(sr.ratio * 100)}%)`,
+    unsupported_claim_recall: unsupported ? `${unsupported.matched}/${unsupported.total} (${Math.round(unsupported.ratio * 100)}%)` : null,
+    notes: `status=${receipt.status} model=${receipt.model} arch=${receipt.architecture} overall=${receipt.pass_fail.overall} decisions=${receipt.decisions_produced_count}/6`
+  };
+}
+function buildReceiptMarkdown(r) {
+  const pct = (ratio) => `${Math.round(ratio * 100)}%`;
+  const runtimeSec = (r.runtime_ms / 1e3).toFixed(1);
+  const perCatRows = Object.entries(r.per_category_any_flag).map(([cat, af]) => {
+    const st = r.per_category_strict[cat] ?? { matched: 0, total: af.total, ratio: 0 };
+    return `| ${cat} | ${af.matched}/${af.total} (${pct(af.ratio)}) | ${st.matched}/${st.total} (${pct(st.ratio)}) |`;
+  }).join("\n");
+  const dvRows = [
+    "accepted_for_synthesis",
+    "rejected",
+    "needs_scope_repair",
+    "needs_source_repair",
+    "needs_contradiction_mapping",
+    "needs_human_review"
+  ].map((d) => {
+    const count = r.decision_vocabulary[d] ?? 0;
+    const unreachable = r.unreachable_decisions.includes(d) ? ` (unreachable from ${r.fixture})` : "";
+    return `| ${d} | ${count}${unreachable} |`;
+  }).join("\n");
+  const pf = r.pass_fail;
+  const bar = r.decision_vocab_bar;
+  const notesSection = r.notes.length > 0 ? `
+## Notes
+
+${r.notes.map((n) => `- ${n}`).join("\n")}
+` : "";
+  return `# Calibration Receipt \u2014 ${r.profile_name}
+
+- **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)
+- **Calibrated at:** ${r.calibrated_at}
+- **Research-OS version:** ${r.research_os_version}
+- **Runtime:** ${runtimeSec} seconds
+
+## Headline metrics
+
+- FP: ${r.good_fp_count} / ${r.fixture_good_claims}
+- Any-flag recall: ${r.any_flag_recall.matched} / ${r.any_flag_recall.total} (${pct(r.any_flag_recall.ratio)})
+- Strict recall: ${r.strict_recall.matched} / ${r.strict_recall.total} (${pct(r.strict_recall.ratio)})
+- Decisions produced: ${r.decisions_produced_count} / 6
+
+## PASS / FAIL
+
+| Bar | Result |
+|---|---|
+| FP ceiling (\u22641) | ${pf.fp_ceiling} |
+| Any-flag recall (\u226565%) | ${pf.any_flag_recall_floor} |
+| Per-category any-flag (\u226550%) | ${pf.per_category_any_flag_floor} |
+| Strict recall (\u226520%) | ${pf.strict_recall_floor} |
+| Decision vocab (${bar.architecture} \u2265 ${bar.required}) | ${pf.decision_vocab_completeness} |
+| Latency soft (\u226410 min) | ${pf.latency_soft} |
+| Latency hard (\u226420 min) | ${pf.latency_hard} |
+| Empty/malformed (=0) | ${pf.empty_or_malformed} |
+| **OVERALL** | **${pf.overall}** |
+
+## Per-category recall
+
+| Category | Any-flag | Strict |
+|---|---|---|
+${perCatRows}
+
+## Decision vocabulary
+
+| Decision | Count |
+|---|---:|
+${dvRows}
+${notesSection}`;
+}
+export {
+  buildReceiptMarkdown,
+  computeDecisionVocabBar,
+  computePassFail,
+  computeStatusLabel,
+  receiptToCalibrationSummary
+};
+//# sourceMappingURL=receipt.js.map

package/dist/calibration/receipt.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/calibration/receipt.ts"],"sourcesContent":["import type {\n  Architecture,\n  CalibrationReceipt,\n  DecisionVocabBar,\n  PassFail,\n  PerCategoryRecall,\n  Recall,\n  StatusLabel,\n} from './receipt-schema.js';\n\n// Architecture-aware decision-vocab bar.\n// single-pass: narrow_critic pass is absent, so model uses full 6-decision\n// vocabulary. Bar: >= 4.\n// two-pass: narrow_critic collapses needs_human_review into harder decisions,\n// reducing diversity. Bar: >= 3 (F-49 resolution).\nexport function computeDecisionVocabBar(\n  architecture: Architecture,\n  decisionsProducedCount: number,\n): DecisionVocabBar {\n  const required = architecture === 'two-pass' ? 3 : 4;\n  return {\n    architecture,\n    required,\n    produced: decisionsProducedCount,\n    passed: decisionsProducedCount >= required,\n  };\n}\n\n// Per-category any-flag floor: seeded categories with total >= 2 must have\n// ratio >= 0.50. Categories with fewer than 2 seeds are excluded (not enough\n// signal to enforce a floor — e.g. a 1-seed category with 0 misses is fine).\nfunction computePerCategoryFloor(perCategoryAnyFlag: PerCategoryRecall): 'PASS' | 'FAIL' {\n  for (const [, recall] of Object.entries(perCategoryAnyFlag)) {\n    if (recall.total >= 2 && recall.ratio < 0.5) return 'FAIL';\n  }\n  return 'PASS';\n}\n\nexport function computePassFail(input: {\n  good_fp_count: number;\n  any_flag_recall: Recall;\n  per_category_any_flag: PerCategoryRecall;\n  strict_recall: Recall;\n  decision_vocab_bar: DecisionVocabBar;\n  runtime_ms: number;\n  empty_or_malformed_responses: number;\n}): PassFail {\n  const fp_ceiling = input.good_fp_count <= 1 ? 'PASS' : 'FAIL';\n  const any_flag_recall_floor = input.any_flag_recall.ratio >= 0.65 ? 'PASS' : 'FAIL';\n  const per_category_any_flag_floor = computePerCategoryFloor(input.per_category_any_flag);\n  const strict_recall_floor = input.strict_recall.ratio >= 0.2 ? 'PASS' : 'FAIL';\n  const decision_vocab_completeness = input.decision_vocab_bar.passed ? 'PASS' : 'FAIL';\n  // Latency soft: warn-only, never FAIL\n  const latency_soft = input.runtime_ms <= 600_000 ? 'PASS' : 'WARN';\n  const latency_hard = input.runtime_ms <= 1_200_000 ? 'PASS' : 'FAIL';\n  const empty_or_malformed = input.empty_or_malformed_responses === 0 ? 'PASS' : 'FAIL';\n\n  const hardBars: Array<'PASS' | 'FAIL'> = [\n    fp_ceiling,\n    any_flag_recall_floor,\n    per_category_any_flag_floor,\n    strict_recall_floor,\n    decision_vocab_completeness,\n    latency_hard,\n    empty_or_malformed,\n  ];\n  const overall = hardBars.every((v) => v === 'PASS') ? 'PASS' : 'FAIL';\n\n  return {\n    fp_ceiling,\n    any_flag_recall_floor,\n    per_category_any_flag_floor,\n    strict_recall_floor,\n    decision_vocab_completeness,\n    latency_soft,\n    latency_hard,\n    empty_or_malformed,\n    overall,\n  };\n}\n\n// Status-label assignment (advisor-locked predicates).\n//\n// Priority order:\n//   1. comparison_only — explicit flag OR single-pass Hermes (architectural side-run)\n//   2. failed          — any hard bar FAIL\n//   3. trusted_baseline — canonical Hermes two-pass with PASS + FP=0\n//   4. conditional_pass — everything else that passes bars\n//\n// trusted_baseline encodes the canonical Hermes two-pass admission: the profile\n// is a named Hermes model run in two-pass architecture, all bars pass, and FP=0.\n// Hermes family is detected by case-insensitive substring match on profile name.\n//\n// conditional_pass is the admission status for non-baseline profiles that pass\n// all hard bars but carry a caution (FP at ceiling, non-hermes model, etc.).\n// mistral-nemo:12b two-pass = conditional_pass (FP=1, passes recalibrated bars).\nexport function computeStatusLabel(input: {\n  profileName: string;\n  architecture: Architecture;\n  passFail: PassFail;\n  goodFpCount: number;\n  modeOverride?: 'comparison_only';\n}): StatusLabel {\n  // comparison_only: explicit operator flag\n  if (input.modeOverride === 'comparison_only') return 'comparison_only';\n\n  // comparison_only: single-pass Hermes is an architectural side-run by design\n  // (the canonical profile is two-pass; single-pass exists only for comparison)\n  if (input.architecture === 'single-pass' && /hermes/i.test(input.profileName)) {\n    return 'comparison_only';\n  }\n\n  // failed: any hard bar fails (latency_soft is WARN-only, never blocks)\n  if (input.passFail.overall === 'FAIL') return 'failed';\n\n  // trusted_baseline: canonical Hermes two-pass profile with perfect FP\n  // Predicate: profile name contains \"hermes\" (case-insensitive) AND\n  //            architecture is two-pass AND all bars pass AND FP = 0\n  const isHermesTwoPass =\n    /hermes/i.test(input.profileName) && input.architecture === 'two-pass';\n  if (isHermesTwoPass && input.goodFpCount === 0) return 'trusted_baseline';\n\n  // conditional_pass: passes all bars but carries caution\n  // (FP at ceiling, non-baseline profile, or non-hermes model)\n  return 'conditional_pass';\n}\n\n// Map a receipt to the PromotionCalibrationSummary string shape used by\n// review-active.json. Called by the review-promote CLI when auto-populating\n// calibration_summary from a persisted receipt.\nexport function receiptToCalibrationSummary(receipt: CalibrationReceipt): {\n  fixture: string | null;\n  good_false_positive_rate: string | null;\n  bad_any_flag_recall: string | null;\n  strict_category_recall: string | null;\n  unsupported_claim_recall: string | null;\n  notes: string | null;\n} {\n  const fp = receipt.good_fp_count;\n  const fpTotal = receipt.fixture_good_claims;\n  const fpPct = fpTotal > 0 ? Math.round((fp / fpTotal) * 100) : 0;\n\n  const af = receipt.any_flag_recall;\n  const sr = receipt.strict_recall;\n  const unsupported = receipt.per_category_any_flag['unsupported_claim'];\n\n  return {\n    fixture: receipt.fixture,\n    good_false_positive_rate: `${fp}/${fpTotal} (${fpPct}%)`,\n    bad_any_flag_recall: `${af.matched}/${af.total} (${Math.round(af.ratio * 100)}%)`,\n    strict_category_recall: `${sr.matched}/${sr.total} (${Math.round(sr.ratio * 100)}%)`,\n    unsupported_claim_recall: unsupported\n      ? `${unsupported.matched}/${unsupported.total} (${Math.round(unsupported.ratio * 100)}%)`\n      : null,\n    notes: `status=${receipt.status} model=${receipt.model} arch=${receipt.architecture} overall=${receipt.pass_fail.overall} decisions=${receipt.decisions_produced_count}/6`,\n  };\n}\n\n// Render a compact Markdown receipt. Operator proof artifact — no prose.\nexport function buildReceiptMarkdown(r: CalibrationReceipt): string {\n  const pct = (ratio: number) => `${Math.round(ratio * 100)}%`;\n  const runtimeSec = (r.runtime_ms / 1000).toFixed(1);\n\n  const perCatRows = Object.entries(r.per_category_any_flag)\n    .map(([cat, af]) => {\n      const st = r.per_category_strict[cat] ?? { matched: 0, total: af.total, ratio: 0 };\n      return `| ${cat} | ${af.matched}/${af.total} (${pct(af.ratio)}) | ${st.matched}/${st.total} (${pct(st.ratio)}) |`;\n    })\n    .join('\\n');\n\n  const dvRows = [\n    'accepted_for_synthesis',\n    'rejected',\n    'needs_scope_repair',\n    'needs_source_repair',\n    'needs_contradiction_mapping',\n    'needs_human_review',\n  ]\n    .map((d) => {\n      const count = r.decision_vocabulary[d] ?? 0;\n      const unreachable = r.unreachable_decisions.includes(d) ? ` (unreachable from ${r.fixture})` : '';\n      return `| ${d} | ${count}${unreachable} |`;\n    })\n    .join('\\n');\n\n  const pf = r.pass_fail;\n  const bar = r.decision_vocab_bar;\n\n  const notesSection =\n    r.notes.length > 0 ? `\\n## Notes\\n\\n${r.notes.map((n) => `- ${n}`).join('\\n')}\\n` : '';\n\n  return `# Calibration Receipt — ${r.profile_name}\n\n- **Model:** ${r.model}\n- **Architecture:** ${r.architecture}\n- **Status:** ${r.status}\n- **Fixture:** ${r.fixture} (${r.fixture_total_claims} claims = ${r.fixture_good_claims} good + ${r.fixture_bad_claims} bad)\n- **Calibrated at:** ${r.calibrated_at}\n- **Research-OS version:** ${r.research_os_version}\n- **Runtime:** ${runtimeSec} seconds\n\n## Headline metrics\n\n- FP: ${r.good_fp_count} / ${r.fixture_good_claims}\n- Any-flag recall: ${r.any_flag_recall.matched} / ${r.any_flag_recall.total} (${pct(r.any_flag_recall.ratio)})\n- Strict recall: ${r.strict_recall.matched} / ${r.strict_recall.total} (${pct(r.strict_recall.ratio)})\n- Decisions produced: ${r.decisions_produced_count} / 6\n\n## PASS / FAIL\n\n| Bar | Result |\n|---|---|\n| FP ceiling (≤1) | ${pf.fp_ceiling} |\n| Any-flag recall (≥65%) | ${pf.any_flag_recall_floor} |\n| Per-category any-flag (≥50%) | ${pf.per_category_any_flag_floor} |\n| Strict recall (≥20%) | ${pf.strict_recall_floor} |\n| Decision vocab (${bar.architecture} ≥ ${bar.required}) | ${pf.decision_vocab_completeness} |\n| Latency soft (≤10 min) | ${pf.latency_soft} |\n| Latency hard (≤20 min) | ${pf.latency_hard} |\n| Empty/malformed (=0) | ${pf.empty_or_malformed} |\n| **OVERALL** | **${pf.overall}** |\n\n## Per-category recall\n\n| Category | Any-flag | Strict |\n|---|---|---|\n${perCatRows}\n\n## Decision vocabulary\n\n| Decision | Count |\n|---|---:|\n${dvRows}\n${notesSection}`;\n}\n"],"mappings":"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","names":[]}