@mcptoolshop/research-os 0.4.0 → 0.6.0

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

@@ -0,0 +1,356 @@
+import { z } from 'zod';
+export { R as ReviewerOptions, a as ReviewerOptionsSchema } from '../reviewer-options-schema-PZacF_MO.js';
+
+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">;
+    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;
+    profile_name: string;
+    model: string;
+    fixture: string;
+    fixture_total_claims: number;
+    fixture_good_claims: number;
+    fixture_bad_claims: number;
+    calibrated_at: string;
+    research_os_version: 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";
+    };
+    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;
+    profile_name: string;
+    model: string;
+    fixture: string;
+    fixture_total_claims: number;
+    fixture_good_claims: number;
+    fixture_bad_claims: number;
+    calibrated_at: string;
+    research_os_version: 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";
+    };
+    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 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,83 @@
+// 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()
+});
+export {
+  ArchitectureSchema,
+  CalibrationReceiptSchema,
+  DecisionVocabBarSchema,
+  PassFailSchema,
+  PerCategoryRecallSchema,
+  RecallSchema,
+  ReviewerOptionsSchema,
+  StatusLabelSchema
+};
+//# sourceMappingURL=receipt-schema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/calibration/receipt-schema.ts","../../src/review/reviewer-options-schema.ts"],"sourcesContent":["import { z } from 'zod';\nimport { ReviewerOptionsSchema } from '../review/reviewer-options-schema.js';\nexport { ReviewerOptionsSchema };\nexport type { ReviewerOptions } from '../review/reviewer-options-schema.js';\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\n// schema_version: 1 — additive-optional additions (Exp6 Session 2):\n//   reviewer_options: optional sampling params used during this calibration run.\n//   Absent = stochastic run (pre-v0.6 compat preserved). Present = keys explicitly set.\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  reviewer_options: ReviewerOptionsSchema.optional(),\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","import { z } from 'zod';\n\n// Sampling parameters passed verbatim to the Ollama /api/chat `options` field.\n// Used by OllamaInternReviewer to control determinism. All fields optional —\n// omitted keys fall back to Ollama/model defaults. Introduced in Experiment 6\n// Session 2 to make reviewer conditions explicit in calibration receipts.\n//\n// LOAD-BEARING: temperature: 0 is valid and must not be dropped. All merges\n// in OllamaInternReviewer use `!== undefined` checks, NOT truthiness.\nexport const ReviewerOptionsSchema = z.object({\n  num_ctx: z.number().int().positive().optional(),\n  temperature: z.number().min(0).max(2).optional(),\n  seed: z.number().int().optional(),\n  top_p: z.number().min(0).max(1).optional(),\n  top_k: z.number().int().nonnegative().optional(),\n  repeat_penalty: z.number().min(0).optional(),\n});\n\nexport type ReviewerOptions = z.infer<typeof ReviewerOptionsSchema>;\n"],"mappings":"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","names":["z","z"]}

package/dist/calibration/receipt.d.ts

@@ -0,0 +1,32 @@
+import { CalibrationReceipt, Architecture, DecisionVocabBar, Recall, PerCategoryRecall, PassFail, StatusLabel } from './receipt-schema.js';
+import 'zod';
+import '../reviewer-options-schema-PZacF_MO.js';
+
+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,170 @@
+// 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`
+  };
+}
+var REVIEWER_OPTIONS_KEY_ORDER = [
+  "num_ctx",
+  "temperature",
+  "seed",
+  "top_p",
+  "top_k",
+  "repeat_penalty"
+];
+function buildReviewerOptionsSection(opts) {
+  if (!opts) return "";
+  const lines = REVIEWER_OPTIONS_KEY_ORDER.filter((k) => opts[k] !== void 0).map((k) => `- ${k}: ${opts[k]}`);
+  if (lines.length === 0) return "";
+  return `
+## Reviewer options
+
+${lines.join("\n")}
+`;
+}
+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")}
+` : "";
+  const reviewerOptionsSection = buildReviewerOptionsSection(r.reviewer_options);
+  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
+${reviewerOptionsSection}
+## 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