@mcptoolshop/research-os 0.5.0 → 0.6.0

package/dist/cli.js

@@ -92,6 +92,23 @@ var init_errors = __esm({
   }
 });
 
+// src/review/reviewer-options-schema.ts
+import { z } from "zod";
+var ReviewerOptionsSchema;
+var init_reviewer_options_schema = __esm({
+  "src/review/reviewer-options-schema.ts"() {
+    "use strict";
+    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/intake/schema.ts
 var schema_exports = {};
 __export(schema_exports, {
@@ -110,83 +127,85 @@ __export(schema_exports, {
   SectionStatusSchema: () => SectionStatusSchema,
   SourceFloorGateSchema: () => SourceFloorGateSchema
 });
-import { z } from "zod";
+import { z as z2 } from "zod";
 var SectionStatusSchema, SectionSchema, SourceFloorGateSchema, ClaimIntegrityGateSchema, FreshnessGateSchema, ContradictionGateSchema, SectionBudgetGateSchema, GateConfigSchema, SectionScopedWaiverSchema, PrimarySourceWaiverSchema, FreshnessRequirementsSchema, ReviewProfilePresetSchema, DEFAULT_REVIEW_PROFILES, ResearchYamlSchema;
 var init_schema = __esm({
   "src/intake/schema.ts"() {
     "use strict";
-    SectionStatusSchema = z.enum([
+    init_reviewer_options_schema();
+    SectionStatusSchema = z2.enum([
       "draft",
       "gathering",
       "gated",
       "reviewed",
       "frozen"
     ]);
-    SectionSchema = z.object({
-      id: z.string().regex(/^[0-9]{2}-[a-z0-9-]+$/, 'Section id must look like "01-landscape"'),
-      purpose: z.string().min(1),
-      max_time_minutes: z.number().int().positive().default(45),
-      min_sources: z.number().int().nonnegative().default(8),
-      primary_sources_required: z.number().int().nonnegative().default(2),
-      contradictions_required: z.boolean().default(true),
+    SectionSchema = z2.object({
+      id: z2.string().regex(/^[0-9]{2}-[a-z0-9-]+$/, 'Section id must look like "01-landscape"'),
+      purpose: z2.string().min(1),
+      max_time_minutes: z2.number().int().positive().default(45),
+      min_sources: z2.number().int().nonnegative().default(8),
+      primary_sources_required: z2.number().int().nonnegative().default(2),
+      contradictions_required: z2.boolean().default(true),
       status: SectionStatusSchema.default("draft")
     });
-    SourceFloorGateSchema = z.object({
-      min_sources: z.number().int().nonnegative().default(8),
-      min_independent_publishers: z.number().int().nonnegative().default(4),
-      primary_sources_required: z.number().int().nonnegative().default(2),
-      primary_source_waiver_allowed: z.boolean().default(true)
+    SourceFloorGateSchema = z2.object({
+      min_sources: z2.number().int().nonnegative().default(8),
+      min_independent_publishers: z2.number().int().nonnegative().default(4),
+      primary_sources_required: z2.number().int().nonnegative().default(2),
+      primary_source_waiver_allowed: z2.boolean().default(true)
     });
-    ClaimIntegrityGateSchema = z.object({
-      every_claim_needs_source: z.boolean().default(true),
-      no_orphan_claims: z.boolean().default(true),
-      no_source_cluster_monopoly: z.boolean().default(true)
+    ClaimIntegrityGateSchema = z2.object({
+      every_claim_needs_source: z2.boolean().default(true),
+      no_orphan_claims: z2.boolean().default(true),
+      no_source_cluster_monopoly: z2.boolean().default(true)
     });
-    FreshnessGateSchema = z.object({
-      required_for_current_topics: z.boolean().default(true),
-      stale_source_policy: z.enum(["warn", "fail"]).default("warn")
+    FreshnessGateSchema = z2.object({
+      required_for_current_topics: z2.boolean().default(true),
+      stale_source_policy: z2.enum(["warn", "fail"]).default("warn")
     });
-    ContradictionGateSchema = z.object({
-      required: z.boolean().default(true),
-      unresolved_contradictions_block_synthesis: z.boolean().default(true)
+    ContradictionGateSchema = z2.object({
+      required: z2.boolean().default(true),
+      unresolved_contradictions_block_synthesis: z2.boolean().default(true)
     });
-    SectionBudgetGateSchema = z.object({
-      max_time_minutes: z.number().int().positive().default(45),
-      extension_requires_evidence: z.boolean().default(true)
+    SectionBudgetGateSchema = z2.object({
+      max_time_minutes: z2.number().int().positive().default(45),
+      extension_requires_evidence: z2.boolean().default(true)
     });
-    GateConfigSchema = z.object({
+    GateConfigSchema = z2.object({
       source_floor: SourceFloorGateSchema.default({}),
       claim_integrity: ClaimIntegrityGateSchema.default({}),
       freshness: FreshnessGateSchema.default({}),
       contradiction: ContradictionGateSchema.default({}),
       section_budget: SectionBudgetGateSchema.default({})
     });
-    SectionScopedWaiverSchema = z.object({
-      section_id: z.string().regex(/^[0-9]{2}-[a-z0-9-]+$/, 'Section id must look like "01-landscape"'),
-      scope: z.enum(["min_independent_publishers", "primary_sources_required"]),
-      reason: z.string().min(1),
-      compensating_controls: z.array(z.string()).min(1)
-    });
-    PrimarySourceWaiverSchema = z.object({
-      status: z.enum(["none", "requested", "granted"]).default("none"),
-      reason: z.string().optional(),
-      compensating_controls: z.array(z.string()).default([]),
+    SectionScopedWaiverSchema = z2.object({
+      section_id: z2.string().regex(/^[0-9]{2}-[a-z0-9-]+$/, 'Section id must look like "01-landscape"'),
+      scope: z2.enum(["min_independent_publishers", "primary_sources_required"]),
+      reason: z2.string().min(1),
+      compensating_controls: z2.array(z2.string()).min(1)
+    });
+    PrimarySourceWaiverSchema = z2.object({
+      status: z2.enum(["none", "requested", "granted"]).default("none"),
+      reason: z2.string().optional(),
+      compensating_controls: z2.array(z2.string()).default([]),
       // Section-scoped waivers; each entry is its own waiver record. Independent
       // of the pack-level status/reason/compensating_controls fields above.
       // Defaults to [] for backward compatibility — existing packs unaffected.
-      section_waivers: z.array(SectionScopedWaiverSchema).default([])
+      section_waivers: z2.array(SectionScopedWaiverSchema).default([])
     });
-    FreshnessRequirementsSchema = z.object({
-      required: z.boolean().default(true),
-      max_source_age_months: z.number().int().positive().nullable().default(null)
+    FreshnessRequirementsSchema = z2.object({
+      required: z2.boolean().default(true),
+      max_source_age_months: z2.number().int().positive().nullable().default(null)
     });
-    ReviewProfilePresetSchema = z.object({
-      general_model: z.string().nullable().default(null),
-      critic_model: z.string().nullable().default(null),
-      review_window: z.number().int().positive().nullable().default(null),
-      mode: z.enum(["general", "two_pass"]).default("two_pass"),
-      status: z.enum(["calibrated_baseline", "experimental", "deprecated"]).default("experimental"),
-      notes: z.string().nullable().default(null)
+    ReviewProfilePresetSchema = z2.object({
+      general_model: z2.string().nullable().default(null),
+      critic_model: z2.string().nullable().default(null),
+      review_window: z2.number().int().positive().nullable().default(null),
+      mode: z2.enum(["general", "two_pass"]).default("two_pass"),
+      status: z2.enum(["calibrated_baseline", "experimental", "deprecated"]).default("experimental"),
+      notes: z2.string().nullable().default(null),
+      reviewer_options: ReviewerOptionsSchema.optional()
     });
     DEFAULT_REVIEW_PROFILES = {
       // The dogfood-validated baseline. Section 03 of research-os-spec is the
@@ -200,27 +219,36 @@ var init_schema = __esm({
         mode: "two_pass",
         status: "calibrated_baseline",
         notes: "Calibrated baseline as of v0.1. 0% good-claim FPR on the seeded fixture; bad-claim any-flag recall 9/13 (69%). Smaller window required because hermes3:8b at 4-bit on a 5080 cannot complete 25-claim windows within a 3-minute budget."
+      },
+      "hermes-two-pass-deterministic": {
+        general_model: "hermes3:8b",
+        critic_model: "hermes3:8b",
+        review_window: 30,
+        mode: "two_pass",
+        status: "experimental",
+        notes: "Deterministic Hermes baseline (temperature=0, seed=7). seeded-v1 canonical receipt: failed (recurring per_category_any_flag_floor + decision_vocab_completeness \u2014 F-52, F-49). See calibration/reviewer-profiles/hermes-two-pass-deterministic/seeded-v1.md.",
+        reviewer_options: { temperature: 0, seed: 7 }
       }
     };
-    ResearchYamlSchema = z.object({
-      research_os_version: z.string(),
-      created_at: z.string(),
-      topic: z.string().min(10, "Topic must be at least 10 characters"),
-      decision: z.string().default(""),
-      audience: z.string().default("self"),
-      desired_output: z.string().default(""),
-      max_runtime_minutes: z.number().int().positive().default(240),
+    ResearchYamlSchema = z2.object({
+      research_os_version: z2.string(),
+      created_at: z2.string(),
+      topic: z2.string().min(10, "Topic must be at least 10 characters"),
+      decision: z2.string().default(""),
+      audience: z2.string().default("self"),
+      desired_output: z2.string().default(""),
+      max_runtime_minutes: z2.number().int().positive().default(240),
       freshness: FreshnessRequirementsSchema.default({}),
-      excluded_sources: z.array(z.string()).default([]),
+      excluded_sources: z2.array(z2.string()).default([]),
       primary_source_waiver: PrimarySourceWaiverSchema.default({}),
-      sections: z.array(SectionSchema).default([]),
+      sections: z2.array(SectionSchema).default([]),
       gates: GateConfigSchema.default({}),
       // Reviewer-profile presets baked into the pack so future review runs
       // (across any section in this pack) inherit the calibrated configuration
       // without rediscovering rig-specific timeouts and context issues. Override
       // with `--preset <name>` on `research-os review`.
-      review_profiles: z.record(z.string(), ReviewProfilePresetSchema).default(() => ({ ...DEFAULT_REVIEW_PROFILES })),
-      frozen_at: z.string().nullable().default(null)
+      review_profiles: z2.record(z2.string(), ReviewProfilePresetSchema).default(() => ({ ...DEFAULT_REVIEW_PROFILES })),
+      frozen_at: z2.string().nullable().default(null)
     });
   }
 });
@@ -364,21 +392,21 @@ var init_intake = __esm({
 });
 
 // src/sections/schema.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var SectionGatesYamlSchema;
 var init_schema2 = __esm({
   "src/sections/schema.ts"() {
     "use strict";
     init_schema();
-    SectionGatesYamlSchema = z2.object({
-      section_id: z2.string().regex(/^[0-9]{2}-[a-z0-9-]+$/, 'Section id must look like "01-landscape"'),
-      purpose: z2.string().min(1),
+    SectionGatesYamlSchema = z3.object({
+      section_id: z3.string().regex(/^[0-9]{2}-[a-z0-9-]+$/, 'Section id must look like "01-landscape"'),
+      purpose: z3.string().min(1),
       status: SectionStatusSchema,
-      created_at: z2.string(),
-      max_time_minutes: z2.number().int().positive(),
-      min_sources: z2.number().int().nonnegative(),
-      primary_sources_required: z2.number().int().nonnegative(),
-      contradictions_required: z2.boolean()
+      created_at: z3.string(),
+      max_time_minutes: z3.number().int().positive(),
+      min_sources: z3.number().int().nonnegative(),
+      primary_sources_required: z3.number().int().nonnegative(),
+      contradictions_required: z3.boolean()
     });
   }
 });
@@ -945,12 +973,12 @@ var init_extractors = __esm({
 });
 
 // src/sources/schema.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var SourceTypeSchema, RelevanceSchema, ExtractorNameSchema, FetchReceiptSchema, SourceCardSchema;
 var init_schema3 = __esm({
   "src/sources/schema.ts"() {
     "use strict";
-    SourceTypeSchema = z3.enum([
+    SourceTypeSchema = z4.enum([
       "primary",
       "secondary",
       "forum",
@@ -958,51 +986,51 @@ var init_schema3 = __esm({
       "docs",
       "unknown"
     ]);
-    RelevanceSchema = z3.enum(["high", "medium", "low", "unknown"]);
-    ExtractorNameSchema = z3.enum(["heuristic", "ollama-intern"]);
-    FetchReceiptSchema = z3.object({
-      receipt_id: z3.string().regex(/^rcpt_[a-z0-9]+_\d+$/),
-      source_id: z3.string().regex(/^src_[a-f0-9]{12}$/),
-      section_id: z3.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      requested_url: z3.string().url(),
-      final_url: z3.string().url().nullable(),
-      status: z3.number().int().nullable(),
-      status_text: z3.string().nullable(),
-      content_type: z3.string().nullable(),
-      fetched_at: z3.string(),
-      byte_count: z3.number().int().nonnegative().nullable(),
-      sha256: z3.string().regex(/^[a-f0-9]{64}$/).nullable(),
-      title: z3.string().nullable(),
-      raw_text_path: z3.string().nullable(),
-      fetch_outcome: z3.enum(["ok", "http_error", "network_error"]),
-      fetch_error: z3.string().nullable(),
-      extraction_outcome: z3.enum(["ok", "failed", "skipped"]),
+    RelevanceSchema = z4.enum(["high", "medium", "low", "unknown"]);
+    ExtractorNameSchema = z4.enum(["heuristic", "ollama-intern"]);
+    FetchReceiptSchema = z4.object({
+      receipt_id: z4.string().regex(/^rcpt_[a-z0-9]+_\d+$/),
+      source_id: z4.string().regex(/^src_[a-f0-9]{12}$/),
+      section_id: z4.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+      requested_url: z4.string().url(),
+      final_url: z4.string().url().nullable(),
+      status: z4.number().int().nullable(),
+      status_text: z4.string().nullable(),
+      content_type: z4.string().nullable(),
+      fetched_at: z4.string(),
+      byte_count: z4.number().int().nonnegative().nullable(),
+      sha256: z4.string().regex(/^[a-f0-9]{64}$/).nullable(),
+      title: z4.string().nullable(),
+      raw_text_path: z4.string().nullable(),
+      fetch_outcome: z4.enum(["ok", "http_error", "network_error"]),
+      fetch_error: z4.string().nullable(),
+      extraction_outcome: z4.enum(["ok", "failed", "skipped"]),
       extraction_extractor: ExtractorNameSchema.nullable(),
-      extraction_error: z3.string().nullable()
-    });
-    SourceCardSchema = z3.object({
-      source_id: z3.string().regex(/^src_[a-f0-9]{12}$/),
-      receipt_id: z3.string().regex(/^rcpt_[a-z0-9]+_\d+$/),
-      section_id: z3.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      url: z3.string().url(),
-      final_url: z3.string().url().nullable(),
-      fetched_at: z3.string(),
-      publisher: z3.string().nullable(),
-      published_at: z3.string().nullable(),
-      title: z3.string().min(1),
+      extraction_error: z4.string().nullable()
+    });
+    SourceCardSchema = z4.object({
+      source_id: z4.string().regex(/^src_[a-f0-9]{12}$/),
+      receipt_id: z4.string().regex(/^rcpt_[a-z0-9]+_\d+$/),
+      section_id: z4.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+      url: z4.string().url(),
+      final_url: z4.string().url().nullable(),
+      fetched_at: z4.string(),
+      publisher: z4.string().nullable(),
+      published_at: z4.string().nullable(),
+      title: z4.string().min(1),
       source_type: SourceTypeSchema,
       relevance: RelevanceSchema,
-      key_points: z3.array(z3.string()),
-      limitations: z3.array(z3.string()),
-      asserts: z3.string().min(1),
-      scope: z3.string().nullable(),
-      not: z3.string().nullable(),
+      key_points: z4.array(z4.string()),
+      limitations: z4.array(z4.string()),
+      asserts: z4.string().min(1),
+      scope: z4.string().nullable(),
+      not: z4.string().nullable(),
       extracted_by: ExtractorNameSchema,
-      extracted_at: z3.string(),
+      extracted_at: z4.string(),
       /** Rule that classified the URL. Added by Component B (v0.4). Optional for back-compat with pre-v0.4 cards. */
-      rule_hint: z3.string().optional(),
+      rule_hint: z4.string().optional(),
       /** Precedence level of the rule that fired (2–6). Optional for back-compat with pre-v0.4 cards. */
-      precedence_level: z3.union([z3.literal(2), z3.literal(3), z3.literal(4), z3.literal(5), z3.literal(6)]).optional()
+      precedence_level: z4.union([z4.literal(2), z4.literal(3), z4.literal(4), z4.literal(5), z4.literal(6)]).optional()
     });
   }
 });
@@ -1299,7 +1327,7 @@ var init_cards = __esm({
 });
 
 // src/sources/source-card-overrides-schema.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 function validateSourceCardOverride(input) {
   return SourceCardOverrideSchema.parse(input);
 }
@@ -1308,20 +1336,20 @@ var init_source_card_overrides_schema = __esm({
   "src/sources/source-card-overrides-schema.ts"() {
     "use strict";
     init_schema3();
-    SourceCardOverrideSchema = z4.object({
-      source_id: z4.string().min(1, "source_id must be non-empty"),
-      url: z4.string().min(1, "url must be non-empty"),
-      previous_source_type: z4.string().nullable().optional(),
+    SourceCardOverrideSchema = z5.object({
+      source_id: z5.string().min(1, "source_id must be non-empty"),
+      url: z5.string().min(1, "url must be non-empty"),
+      previous_source_type: z5.string().nullable().optional(),
       new_source_type: SourceTypeSchema.nullable().optional(),
-      previous_publisher: z4.string().nullable().optional(),
-      new_publisher: z4.string().nullable().optional(),
-      reason: z4.string().refine((v) => v.trim().length > 0, { message: "reason must be non-empty after trim" }),
-      operator: z4.string().min(1, "operator must be non-empty"),
-      created_at: z4.string().refine((v) => isFinite(Date.parse(v)), {
+      previous_publisher: z5.string().nullable().optional(),
+      new_publisher: z5.string().nullable().optional(),
+      reason: z5.string().refine((v) => v.trim().length > 0, { message: "reason must be non-empty after trim" }),
+      operator: z5.string().min(1, "operator must be non-empty"),
+      created_at: z5.string().refine((v) => isFinite(Date.parse(v)), {
         message: "created_at must be a valid ISO 8601 timestamp"
       }),
-      rule_hint: z4.string().nullable().optional(),
-      pack_version: z4.string().min(1, "pack_version must be non-empty")
+      rule_hint: z5.string().nullable().optional(),
+      pack_version: z5.string().min(1, "pack_version must be non-empty")
     }).refine(
       (obj) => obj.new_source_type != null && obj.new_source_type !== void 0 || obj.new_publisher != null && obj.new_publisher !== void 0,
       {
@@ -1462,23 +1490,23 @@ var init_gather = __esm({
 });
 
 // src/sources/excerpts/schema.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var EXCERPT_ID_PATTERN, ExcerptOriginSchema, ExcerptSchema;
 var init_schema4 = __esm({
   "src/sources/excerpts/schema.ts"() {
     "use strict";
     EXCERPT_ID_PATTERN = /^ex_[a-f0-9]{12}_\d{3,}$/;
-    ExcerptOriginSchema = z5.enum(["raw_text", "key_point"]);
-    ExcerptSchema = z5.object({
-      excerpt_id: z5.string().regex(EXCERPT_ID_PATTERN),
-      source_id: z5.string().regex(/^src_[a-f0-9]{12}$/),
-      source_hash: z5.string().regex(/^[a-f0-9]{64}$/).nullable(),
-      text: z5.string().min(1),
-      location_hint: z5.string().nullable(),
-      char_start: z5.number().int().nonnegative(),
-      char_end: z5.number().int().nonnegative(),
+    ExcerptOriginSchema = z6.enum(["raw_text", "key_point"]);
+    ExcerptSchema = z6.object({
+      excerpt_id: z6.string().regex(EXCERPT_ID_PATTERN),
+      source_id: z6.string().regex(/^src_[a-f0-9]{12}$/),
+      source_hash: z6.string().regex(/^[a-f0-9]{64}$/).nullable(),
+      text: z6.string().min(1),
+      location_hint: z6.string().nullable(),
+      char_start: z6.number().int().nonnegative(),
+      char_end: z6.number().int().nonnegative(),
       origin: ExcerptOriginSchema,
-      created_at: z5.string()
+      created_at: z6.string()
     });
   }
 });
@@ -2021,41 +2049,41 @@ var init_extractors2 = __esm({
 });
 
 // src/claims/schema.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var ConfidenceSchema, ClaimExtractorSchema, ReviewStateSchema, ClaimSchema;
 var init_schema5 = __esm({
   "src/claims/schema.ts"() {
     "use strict";
     init_schema4();
-    ConfidenceSchema = z6.enum(["low", "medium", "high"]);
-    ClaimExtractorSchema = z6.enum(["heuristic", "ollama-intern"]);
-    ReviewStateSchema = z6.enum([
+    ConfidenceSchema = z7.enum(["low", "medium", "high"]);
+    ClaimExtractorSchema = z7.enum(["heuristic", "ollama-intern"]);
+    ReviewStateSchema = z7.enum([
       "candidate",
       "gated",
       "reviewed",
       "rejected",
       "accepted"
     ]);
-    ClaimSchema = z6.object({
-      claim_id: z6.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/),
-      section_id: z6.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      source_ids: z6.array(z6.string().regex(/^src_[a-f0-9]{12}$/)).min(1, "every claim must reference at least one source_id"),
-      source_hashes: z6.array(z6.string().regex(/^[a-f0-9]{64}$/)),
-      asserts: z6.string().min(1),
-      scope: z6.string().nullable(),
-      not: z6.string().nullable(),
+    ClaimSchema = z7.object({
+      claim_id: z7.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/),
+      section_id: z7.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+      source_ids: z7.array(z7.string().regex(/^src_[a-f0-9]{12}$/)).min(1, "every claim must reference at least one source_id"),
+      source_hashes: z7.array(z7.string().regex(/^[a-f0-9]{64}$/)),
+      asserts: z7.string().min(1),
+      scope: z7.string().nullable(),
+      not: z7.string().nullable(),
       // Span-first extraction: the model picks excerpt IDs from the deterministic
       // ledger; research-os copies the literal text into evidence_excerpt. Models
       // may interpret source spans; they may not author evidence spans.
       // Allowed empty for legacy claims that pre-date span-first extraction —
       // those should be re-extracted; new writes always populate at least one ID.
-      evidence_excerpt_ids: z6.array(z6.string().regex(EXCERPT_ID_PATTERN)).default([]),
-      evidence_excerpt: z6.string().min(1),
-      evidence_location: z6.string().nullable(),
+      evidence_excerpt_ids: z7.array(z7.string().regex(EXCERPT_ID_PATTERN)).default([]),
+      evidence_excerpt: z7.string().min(1),
+      evidence_location: z7.string().nullable(),
       confidence: ConfidenceSchema,
       extractor: ClaimExtractorSchema,
-      extraction_method: z6.string().min(1),
-      created_at: z6.string(),
+      extraction_method: z7.string().min(1),
+      created_at: z7.string(),
       review_state: ReviewStateSchema
     });
   }
@@ -2333,53 +2361,53 @@ var init_extract = __esm({
 });
 
 // src/claims/density/schema.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var PerSourceDensitySchema, NearDuplicateClusterSchema, DensityFlagSchema, ClaimDensityAuditSchema;
 var init_schema6 = __esm({
   "src/claims/density/schema.ts"() {
     "use strict";
-    PerSourceDensitySchema = z7.object({
-      source_id: z7.string().regex(/^src_[a-f0-9]{12}$/),
-      publisher: z7.string().nullable(),
-      source_word_count: z7.number().int().nonnegative(),
-      claim_count: z7.number().int().nonnegative(),
-      claims_per_1k_words: z7.number(),
-      share_of_section: z7.number(),
+    PerSourceDensitySchema = z8.object({
+      source_id: z8.string().regex(/^src_[a-f0-9]{12}$/),
+      publisher: z8.string().nullable(),
+      source_word_count: z8.number().int().nonnegative(),
+      claim_count: z8.number().int().nonnegative(),
+      claims_per_1k_words: z8.number(),
+      share_of_section: z8.number(),
       // 0..1
-      weak_scope_count: z7.number().int().nonnegative(),
-      generic_scope_count: z7.number().int().nonnegative()
+      weak_scope_count: z8.number().int().nonnegative(),
+      generic_scope_count: z8.number().int().nonnegative()
     });
-    NearDuplicateClusterSchema = z7.object({
-      representative_assert: z7.string(),
-      member_count: z7.number().int().nonnegative(),
-      claim_ids: z7.array(z7.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/))
+    NearDuplicateClusterSchema = z8.object({
+      representative_assert: z8.string(),
+      member_count: z8.number().int().nonnegative(),
+      claim_ids: z8.array(z8.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/))
     });
-    DensityFlagSchema = z7.object({
-      type: z7.enum([
+    DensityFlagSchema = z8.object({
+      type: z8.enum([
         "source_dominance",
         "high_per_word_density",
         "large_near_duplicate_cluster",
         "weak_scope_majority"
       ]),
-      severity: z7.enum(["info", "warn", "block"]),
-      message: z7.string(),
-      affects_source_ids: z7.array(z7.string().regex(/^src_[a-f0-9]{12}$/)).default([]),
-      affects_claim_ids: z7.array(z7.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/)).default([])
+      severity: z8.enum(["info", "warn", "block"]),
+      message: z8.string(),
+      affects_source_ids: z8.array(z8.string().regex(/^src_[a-f0-9]{12}$/)).default([]),
+      affects_claim_ids: z8.array(z8.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/)).default([])
     });
-    ClaimDensityAuditSchema = z7.object({
-      audit_id: z7.string().regex(/^cda_[0-9]+_[a-z0-9-]+$/),
-      section_id: z7.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      audited_at: z7.string(),
-      research_os_version: z7.string(),
-      candidate_claim_count: z7.number().int().nonnegative(),
-      source_count: z7.number().int().nonnegative(),
-      total_source_word_count: z7.number().int().nonnegative(),
-      claims_per_1k_words: z7.number(),
-      weak_scope_count: z7.number().int().nonnegative(),
-      generic_scope_count: z7.number().int().nonnegative(),
-      per_source: z7.array(PerSourceDensitySchema),
-      near_duplicate_clusters: z7.array(NearDuplicateClusterSchema),
-      flags: z7.array(DensityFlagSchema)
+    ClaimDensityAuditSchema = z8.object({
+      audit_id: z8.string().regex(/^cda_[0-9]+_[a-z0-9-]+$/),
+      section_id: z8.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+      audited_at: z8.string(),
+      research_os_version: z8.string(),
+      candidate_claim_count: z8.number().int().nonnegative(),
+      source_count: z8.number().int().nonnegative(),
+      total_source_word_count: z8.number().int().nonnegative(),
+      claims_per_1k_words: z8.number(),
+      weak_scope_count: z8.number().int().nonnegative(),
+      generic_scope_count: z8.number().int().nonnegative(),
+      per_source: z8.array(PerSourceDensitySchema),
+      near_duplicate_clusters: z8.array(NearDuplicateClusterSchema),
+      flags: z8.array(DensityFlagSchema)
     });
   }
 });
@@ -2696,12 +2724,12 @@ var init_claims = __esm({
 });
 
 // src/contradictions/schema.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var ContradictionTypeSchema, SeveritySchema, OverlapAssessmentSchema, ContradictionDetectorSchema, ContradictionStatusSchema, ContradictionConfidenceSchema, ContradictionSchema;
 var init_schema7 = __esm({
   "src/contradictions/schema.ts"() {
     "use strict";
-    ContradictionTypeSchema = z8.enum([
+    ContradictionTypeSchema = z9.enum([
       "direct_conflict",
       "scope_conflict",
       "temporal_conflict",
@@ -2709,37 +2737,37 @@ var init_schema7 = __esm({
       "evidence_conflict",
       "overgeneralization_risk"
     ]);
-    SeveritySchema = z8.enum(["low", "medium", "high", "blocking"]);
-    OverlapAssessmentSchema = z8.enum([
+    SeveritySchema = z9.enum(["low", "medium", "high", "blocking"]);
+    OverlapAssessmentSchema = z9.enum([
       "fully_overlapping",
       "partially_overlapping",
       "non_overlapping",
       "unknown"
     ]);
-    ContradictionDetectorSchema = z8.enum(["heuristic", "ollama-intern"]);
-    ContradictionStatusSchema = z8.enum([
+    ContradictionDetectorSchema = z9.enum(["heuristic", "ollama-intern"]);
+    ContradictionStatusSchema = z9.enum([
       "unresolved",
       "reconciled",
       "preserved_deliberately",
       "rejected"
     ]);
-    ContradictionConfidenceSchema = z8.enum(["low", "medium", "high"]);
-    ContradictionSchema = z8.object({
-      contradiction_id: z8.string().regex(/^cnt_[a-f0-9]{12}_(heuristic|ollama_intern)$/),
-      section_id: z8.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      claim_ids: z8.array(z8.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/)).length(2, "contradictions are pair-wise in v0.1"),
-      source_ids: z8.array(z8.string().regex(/^src_[a-f0-9]{12}$/)).min(1),
+    ContradictionConfidenceSchema = z9.enum(["low", "medium", "high"]);
+    ContradictionSchema = z9.object({
+      contradiction_id: z9.string().regex(/^cnt_[a-f0-9]{12}_(heuristic|ollama_intern)$/),
+      section_id: z9.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+      claim_ids: z9.array(z9.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/)).length(2, "contradictions are pair-wise in v0.1"),
+      source_ids: z9.array(z9.string().regex(/^src_[a-f0-9]{12}$/)).min(1),
       type: ContradictionTypeSchema,
-      summary: z8.string().min(1),
-      scope_analysis: z8.string(),
+      summary: z9.string().min(1),
+      scope_analysis: z9.string(),
       overlap_assessment: OverlapAssessmentSchema,
       severity: SeveritySchema,
       confidence: ContradictionConfidenceSchema,
       detector: ContradictionDetectorSchema,
-      detection_method: z8.string().min(1),
-      evidence: z8.string(),
+      detection_method: z9.string().min(1),
+      evidence: z9.string(),
       status: ContradictionStatusSchema,
-      created_at: z8.string()
+      created_at: z9.string()
     });
   }
 });
@@ -3181,12 +3209,12 @@ var init_markdown = __esm({
 });
 
 // src/triage/schema.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var TriageDecisionSchema, ClaimTriageSchema, TriageSummarySchema;
 var init_schema8 = __esm({
   "src/triage/schema.ts"() {
     "use strict";
-    TriageDecisionSchema = z9.enum([
+    TriageDecisionSchema = z10.enum([
       // Passes triage and is forwarded to review.
       "selected_for_review",
       // Parked: kept on the canonical ledger as research truth, but not advanced.
@@ -3198,36 +3226,36 @@ var init_schema8 = __esm({
       "needs_scope_repair",
       "needs_human_review"
     ]);
-    ClaimTriageSchema = z9.object({
-      triage_id: z9.string().regex(/^tri_[a-f0-9]{12}$/),
-      claim_id: z9.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/),
-      section_id: z9.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+    ClaimTriageSchema = z10.object({
+      triage_id: z10.string().regex(/^tri_[a-f0-9]{12}$/),
+      claim_id: z10.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/),
+      section_id: z10.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
       decision: TriageDecisionSchema,
-      reason: z9.string().min(1),
+      reason: z10.string().min(1),
       // Rank among selected_for_review claims (1 = highest priority). null for
       // any non-selected decision.
-      rank: z9.number().int().positive().nullable(),
+      rank: z10.number().int().positive().nullable(),
       // Quality score [0..1] used to sort. Stable. Higher = better.
-      quality_score: z9.number().min(0).max(1),
-      triage_method: z9.string().min(1),
-      created_at: z9.string()
-    });
-    TriageSummarySchema = z9.object({
-      summary_id: z9.string().regex(/^tris_[0-9]+_[a-z0-9-]+$/),
-      section_id: z9.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      triaged_at: z9.string(),
-      research_os_version: z9.string(),
-      triage_method: z9.string(),
-      candidate_claims: z9.number().int().nonnegative(),
-      decisions: z9.record(TriageDecisionSchema, z9.number().int().nonnegative()),
-      per_source_cap: z9.number().int().positive(),
-      duplicate_clusters_collapsed: z9.number().int().nonnegative(),
-      selected_count: z9.number().int().nonnegative(),
-      selected_per_source: z9.array(
-        z9.object({
-          source_id: z9.string().regex(/^src_[a-f0-9]{12}$/),
-          selected: z9.number().int().nonnegative(),
-          total: z9.number().int().nonnegative()
+      quality_score: z10.number().min(0).max(1),
+      triage_method: z10.string().min(1),
+      created_at: z10.string()
+    });
+    TriageSummarySchema = z10.object({
+      summary_id: z10.string().regex(/^tris_[0-9]+_[a-z0-9-]+$/),
+      section_id: z10.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+      triaged_at: z10.string(),
+      research_os_version: z10.string(),
+      triage_method: z10.string(),
+      candidate_claims: z10.number().int().nonnegative(),
+      decisions: z10.record(TriageDecisionSchema, z10.number().int().nonnegative()),
+      per_source_cap: z10.number().int().positive(),
+      duplicate_clusters_collapsed: z10.number().int().nonnegative(),
+      selected_count: z10.number().int().nonnegative(),
+      selected_per_source: z10.array(
+        z10.object({
+          source_id: z10.string().regex(/^src_[a-f0-9]{12}$/),
+          selected: z10.number().int().nonnegative(),
+          total: z10.number().int().nonnegative()
         })
       )
     });
@@ -3724,23 +3752,23 @@ var init_map = __esm({
 });
 
 // src/contradictions/resolution-schema.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var ResolutionStatusSchema, ContradictionResolutionSchema;
 var init_resolution_schema = __esm({
   "src/contradictions/resolution-schema.ts"() {
     "use strict";
-    ResolutionStatusSchema = z10.enum([
+    ResolutionStatusSchema = z11.enum([
       "unresolved",
       "resolved",
       "preserved",
       "rejected"
     ]);
-    ContradictionResolutionSchema = z10.object({
-      contradiction_id: z10.string().min(1),
+    ContradictionResolutionSchema = z11.object({
+      contradiction_id: z11.string().min(1),
       status: ResolutionStatusSchema,
-      reason: z10.string().min(4),
-      resolved_at: z10.string().min(1),
-      resolved_by: z10.string().min(1)
+      reason: z11.string().min(4),
+      resolved_at: z11.string().min(1),
+      resolved_by: z11.string().min(1)
     });
   }
 });
@@ -3857,12 +3885,13 @@ var init_contradictions = __esm({
 });
 
 // src/review/schema.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var FindingCategorySchema, FindingSeveritySchema, ReviewerNameSchema, ReviewDecisionSchema, ReviewConfidenceSchema, ReviewFindingSchema, ClaimReviewSchema, ReviewSnapshotSchema;
 var init_schema9 = __esm({
   "src/review/schema.ts"() {
     "use strict";
-    FindingCategorySchema = z11.enum([
+    init_reviewer_options_schema();
+    FindingCategorySchema = z12.enum([
       "unsupported_claim",
       "ungrounded_excerpt",
       "stale_claim",
@@ -3889,9 +3918,9 @@ var init_schema9 = __esm({
       // a low-value claim can appear in a perfectly-sized section.
       "valid_but_low_value"
     ]);
-    FindingSeveritySchema = z11.enum(["info", "warn", "block"]);
-    ReviewerNameSchema = z11.enum(["heuristic", "ollama-intern"]);
-    ReviewDecisionSchema = z11.enum([
+    FindingSeveritySchema = z12.enum(["info", "warn", "block"]);
+    ReviewerNameSchema = z12.enum(["heuristic", "ollama-intern"]);
+    ReviewDecisionSchema = z12.enum([
       "accepted_for_synthesis",
       "rejected",
       "needs_scope_repair",
@@ -3899,47 +3928,48 @@ var init_schema9 = __esm({
       "needs_contradiction_mapping",
       "needs_human_review"
     ]);
-    ReviewConfidenceSchema = z11.enum(["low", "medium", "high"]);
-    ReviewFindingSchema = z11.object({
-      finding_id: z11.string().regex(/^fnd_[a-f0-9]{12}$/),
-      section_id: z11.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      claim_ids: z11.array(z11.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/)),
-      source_ids: z11.array(z11.string().regex(/^src_[a-f0-9]{12}$/)),
+    ReviewConfidenceSchema = z12.enum(["low", "medium", "high"]);
+    ReviewFindingSchema = z12.object({
+      finding_id: z12.string().regex(/^fnd_[a-f0-9]{12}$/),
+      section_id: z12.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+      claim_ids: z12.array(z12.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/)),
+      source_ids: z12.array(z12.string().regex(/^src_[a-f0-9]{12}$/)),
       category: FindingCategorySchema,
       severity: FindingSeveritySchema,
-      summary: z11.string().min(1),
-      evidence: z11.string(),
-      required_action: z11.string(),
+      summary: z12.string().min(1),
+      evidence: z12.string(),
+      required_action: z12.string(),
       reviewer: ReviewerNameSchema,
-      review_method: z11.string().min(1),
+      review_method: z12.string().min(1),
       confidence: ReviewConfidenceSchema,
-      created_at: z11.string()
+      created_at: z12.string()
     });
-    ClaimReviewSchema = z11.object({
-      claim_id: z11.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/),
+    ClaimReviewSchema = z12.object({
+      claim_id: z12.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/),
       decision: ReviewDecisionSchema,
-      reason: z11.string().min(1),
-      finding_ids: z11.array(z11.string()),
+      reason: z12.string().min(1),
+      finding_ids: z12.array(z12.string()),
       reviewer: ReviewerNameSchema,
-      review_method: z11.string().min(1),
-      created_at: z11.string(),
+      review_method: z12.string().min(1),
+      created_at: z12.string(),
       // v0.5: optional profile lineage. Additive-optional — pre-v0.5 records
       // without this field parse cleanly. Frozen packs unaffected (Zod .optional()
       // with no .default() leaves absent keys absent on round-trip).
-      profile: z11.string().optional()
+      profile: z12.string().optional()
     });
-    ReviewSnapshotSchema = z11.object({
-      section_id: z11.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+    ReviewSnapshotSchema = z12.object({
+      section_id: z12.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
       reviewer: ReviewerNameSchema,
-      review_method: z11.string(),
-      reviewed_at: z11.string(),
-      candidate_claims: z11.number().int().nonnegative(),
-      findings: z11.array(ReviewFindingSchema),
-      claim_reviews: z11.array(ClaimReviewSchema),
-      decision_counts: z11.record(ReviewDecisionSchema, z11.number().int().nonnegative()),
-      severity_counts: z11.record(FindingSeveritySchema, z11.number().int().nonnegative()),
-      llm_findings_rejected_ungrounded: z11.number().int().nonnegative(),
-      promoted_to_reviewed: z11.boolean()
+      review_method: z12.string(),
+      reviewed_at: z12.string(),
+      candidate_claims: z12.number().int().nonnegative(),
+      findings: z12.array(ReviewFindingSchema),
+      claim_reviews: z12.array(ClaimReviewSchema),
+      decision_counts: z12.record(ReviewDecisionSchema, z12.number().int().nonnegative()),
+      severity_counts: z12.record(FindingSeveritySchema, z12.number().int().nonnegative()),
+      llm_findings_rejected_ungrounded: z12.number().int().nonnegative(),
+      promoted_to_reviewed: z12.boolean(),
+      reviewer_options: ReviewerOptionsSchema.optional()
     });
   }
 });
@@ -4827,12 +4857,12 @@ var init_markdown2 = __esm({
 });
 
 // src/gates/schema.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var GateFamilySchema, GateCheckStatusSchema, VerdictSchema, GateCheckResultSchema, WaiverApplicationSchema, SectionGateResultSchema;
 var init_schema10 = __esm({
   "src/gates/schema.ts"() {
     "use strict";
-    GateFamilySchema = z12.enum([
+    GateFamilySchema = z13.enum([
       "source_floor",
       "claim_integrity",
       "scope_integrity",
@@ -4842,85 +4872,85 @@ var init_schema10 = __esm({
       "waivers",
       "accepted_claim_floor"
     ]);
-    GateCheckStatusSchema = z12.enum([
+    GateCheckStatusSchema = z13.enum([
       "pass",
       "warn",
       "fail",
       "pass_with_waiver",
       "warn_with_waiver"
     ]);
-    VerdictSchema = z12.enum(["pass", "warn", "fail", "blocked"]);
-    GateCheckResultSchema = z12.object({
+    VerdictSchema = z13.enum(["pass", "warn", "fail", "blocked"]);
+    GateCheckResultSchema = z13.object({
       family: GateFamilySchema,
-      check: z12.string().min(1),
+      check: z13.string().min(1),
       status: GateCheckStatusSchema,
-      detail: z12.string(),
-      evidence: z12.array(z12.string()),
-      blocks_synthesis: z12.boolean()
+      detail: z13.string(),
+      evidence: z13.array(z13.string()),
+      blocks_synthesis: z13.boolean()
     });
-    WaiverApplicationSchema = z12.object({
+    WaiverApplicationSchema = z13.object({
       family: GateFamilySchema,
-      check: z12.string().min(1),
-      reason: z12.string().min(1),
-      compensating_controls: z12.array(z12.string()),
+      check: z13.string().min(1),
+      reason: z13.string().min(1),
+      compensating_controls: z13.array(z13.string()),
       original_status: GateCheckStatusSchema,
       new_status: GateCheckStatusSchema
     });
-    SectionGateResultSchema = z12.object({
-      section_id: z12.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+    SectionGateResultSchema = z13.object({
+      section_id: z13.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
       verdict: VerdictSchema,
-      summary: z12.string(),
-      checked_at: z12.string(),
-      synthesis_eligible: z12.boolean(),
-      gate_results: z12.array(GateCheckResultSchema),
-      failures: z12.array(GateCheckResultSchema),
-      warnings: z12.array(GateCheckResultSchema),
-      waivers_applied: z12.array(WaiverApplicationSchema),
-      blocking_reasons: z12.array(z12.string()),
-      claim_counts: z12.object({
-        total: z12.number().int().nonnegative(),
-        candidate: z12.number().int().nonnegative(),
-        with_evidence_excerpt: z12.number().int().nonnegative(),
-        with_source_hashes: z12.number().int().nonnegative(),
-        with_scope: z12.number().int().nonnegative(),
-        with_not: z12.number().int().nonnegative(),
-        universal_scope_null: z12.number().int().nonnegative(),
-        orphans: z12.number().int().nonnegative()
+      summary: z13.string(),
+      checked_at: z13.string(),
+      synthesis_eligible: z13.boolean(),
+      gate_results: z13.array(GateCheckResultSchema),
+      failures: z13.array(GateCheckResultSchema),
+      warnings: z13.array(GateCheckResultSchema),
+      waivers_applied: z13.array(WaiverApplicationSchema),
+      blocking_reasons: z13.array(z13.string()),
+      claim_counts: z13.object({
+        total: z13.number().int().nonnegative(),
+        candidate: z13.number().int().nonnegative(),
+        with_evidence_excerpt: z13.number().int().nonnegative(),
+        with_source_hashes: z13.number().int().nonnegative(),
+        with_scope: z13.number().int().nonnegative(),
+        with_not: z13.number().int().nonnegative(),
+        universal_scope_null: z13.number().int().nonnegative(),
+        orphans: z13.number().int().nonnegative()
       }),
-      source_counts: z12.object({
-        total: z12.number().int().nonnegative(),
-        primary: z12.number().int().nonnegative(),
-        secondary: z12.number().int().nonnegative(),
-        forum: z12.number().int().nonnegative(),
-        benchmark: z12.number().int().nonnegative(),
-        docs: z12.number().int().nonnegative(),
-        unknown: z12.number().int().nonnegative(),
-        independent_publishers: z12.number().int().nonnegative(),
-        failed_fetches: z12.number().int().nonnegative(),
-        section_primary: z12.number().int().nonnegative(),
-        section_independent_publishers: z12.number().int().nonnegative()
+      source_counts: z13.object({
+        total: z13.number().int().nonnegative(),
+        primary: z13.number().int().nonnegative(),
+        secondary: z13.number().int().nonnegative(),
+        forum: z13.number().int().nonnegative(),
+        benchmark: z13.number().int().nonnegative(),
+        docs: z13.number().int().nonnegative(),
+        unknown: z13.number().int().nonnegative(),
+        independent_publishers: z13.number().int().nonnegative(),
+        failed_fetches: z13.number().int().nonnegative(),
+        section_primary: z13.number().int().nonnegative().optional().default(0),
+        section_independent_publishers: z13.number().int().nonnegative().optional().default(0)
       }),
-      contradiction_counts: z12.object({
-        total: z12.number().int().nonnegative(),
-        unresolved: z12.number().int().nonnegative(),
-        blocking: z12.number().int().nonnegative(),
-        by_type: z12.record(z12.string(), z12.number().int().nonnegative())
+      contradiction_counts: z13.object({
+        total: z13.number().int().nonnegative(),
+        unresolved: z13.number().int().nonnegative(),
+        blocking: z13.number().int().nonnegative(),
+        by_type: z13.record(z13.string(), z13.number().int().nonnegative())
       }),
-      freshness_summary: z12.object({
-        policy_required: z12.boolean(),
-        max_source_age_months: z12.number().int().nullable(),
-        stale_source_policy: z12.enum(["warn", "fail"]),
-        stale_count: z12.number().int().nonnegative(),
-        unknown_date_count: z12.number().int().nonnegative()
+      freshness_summary: z13.object({
+        policy_required: z13.boolean(),
+        max_source_age_months: z13.number().int().nullable(),
+        stale_source_policy: z13.enum(["warn", "fail"]),
+        stale_count: z13.number().int().nonnegative(),
+        unknown_date_count: z13.number().int().nonnegative()
       }),
-      scope_integrity_summary: z12.object({
-        universal_claims: z12.number().int().nonnegative(),
-        scoped_claims: z12.number().int().nonnegative(),
-        with_not_constraint: z12.number().int().nonnegative(),
-        overgen_risks_total: z12.number().int().nonnegative(),
-        overgen_risks_blocking: z12.number().int().nonnegative()
+      scope_integrity_summary: z13.object({
+        universal_claims: z13.number().int().nonnegative(),
+        scoped_claims: z13.number().int().nonnegative(),
+        with_not_constraint: z13.number().int().nonnegative(),
+        overgen_risks_total: z13.number().int().nonnegative(),
+        overgen_risks_blocking: z13.number().int().nonnegative()
       }),
-      next_actions: z12.array(z12.string())
+      next_actions: z13.array(z13.string())
     });
   }
 });
@@ -5257,7 +5287,7 @@ var init_gates = __esm({
 import { existsSync as existsSync13 } from "fs";
 import { mkdir as mkdir11, readFile as readFile13, writeFile as writeFile11 } from "fs/promises";
 import { join as join14 } from "path";
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 function reviewActivePath(packPath, sectionId) {
   return join14(packPath, "sections", sectionId, "review-active.json");
 }
@@ -5287,22 +5317,22 @@ var init_profiles = __esm({
   "src/review/profiles.ts"() {
     "use strict";
     DEFAULT_PROFILE = "default";
-    PromotionCalibrationSummarySchema = z13.object({
-      fixture: z13.string().nullable().default(null),
-      good_false_positive_rate: z13.string().nullable().default(null),
-      bad_any_flag_recall: z13.string().nullable().default(null),
-      strict_category_recall: z13.string().nullable().default(null),
-      unsupported_claim_recall: z13.string().nullable().default(null),
-      notes: z13.string().nullable().default(null)
-    });
-    ReviewActiveSchema = z13.object({
-      active_profile: z13.string().min(1),
-      promoted_at: z13.string(),
-      promoted_method: z13.string(),
-      promoted_reviewer: z13.string(),
+    PromotionCalibrationSummarySchema = z14.object({
+      fixture: z14.string().nullable().default(null),
+      good_false_positive_rate: z14.string().nullable().default(null),
+      bad_any_flag_recall: z14.string().nullable().default(null),
+      strict_category_recall: z14.string().nullable().default(null),
+      unsupported_claim_recall: z14.string().nullable().default(null),
+      notes: z14.string().nullable().default(null)
+    });
+    ReviewActiveSchema = z14.object({
+      active_profile: z14.string().min(1),
+      promoted_at: z14.string(),
+      promoted_method: z14.string(),
+      promoted_reviewer: z14.string(),
       // Free-text reason the profile was promoted. Recorded once at promotion
       // time; not derived from artifacts. Required.
-      promotion_reason: z13.string().min(8).default("promoted via review-promote without an explicit reason"),
+      promotion_reason: z14.string().min(8).default("promoted via review-promote without an explicit reason"),
       // Optional calibration evidence captured at promotion time so downstream
       // consumers can see WHY the reviewer was trusted.
       calibration_summary: PromotionCalibrationSummarySchema.nullable().default(null)
@@ -5650,6 +5680,7 @@ var init_ollama_intern4 = __esm({
   "src/review/reviewers/ollama-intern.ts"() {
     "use strict";
     init_ollama_intern();
+    init_reviewer_options_schema();
     DEFAULT_HOST4 = "http://localhost:11434";
     DEFAULT_MODEL4 = "hermes3:8b";
     DEFAULT_TIMEOUT_MS3 = 18e4;
@@ -5738,6 +5769,7 @@ Return ONE JSON object: {"findings": [...]}.`;
       timeoutMs;
       claimsPerWindow;
       fetchImpl;
+      reviewerOptions;
       constructor(config = {}) {
         this.host = normalizeOllamaHost(config.host ?? process.env.OLLAMA_HOST ?? DEFAULT_HOST4);
         this.model = config.model ?? process.env.OLLAMA_INTERN_MODEL ?? DEFAULT_MODEL4;
@@ -5746,6 +5778,7 @@ Return ONE JSON object: {"findings": [...]}.`;
         const envWindow = process.env.OLLAMA_INTERN_REVIEW_WINDOW;
         this.claimsPerWindow = config.claimsPerWindow ?? (envWindow ? parseInt(envWindow, 10) || DEFAULT_CLAIMS_PER_WINDOW : DEFAULT_CLAIMS_PER_WINDOW);
         this.fetchImpl = config.fetchImpl ?? globalThis.fetch;
+        this.reviewerOptions = config.reviewer_options ? ReviewerOptionsSchema.parse(config.reviewer_options) : void 0;
       }
       async available() {
         try {
@@ -5798,7 +5831,17 @@ ${claimsBlock}`;
               // native window; review prompts with 20+ claims exceed that and
               // get silently truncated, which drops claim_ids and confuses the
               // model. Explicitly request 8K so paged windows fit cleanly.
-              options: { num_ctx: 8192 },
+              // Additional sampling params (temperature, seed, etc.) are merged
+              // from reviewerOptions when set. Use !== undefined throughout —
+              // temperature: 0 is valid and must not be dropped by truthiness.
+              options: {
+                num_ctx: this.reviewerOptions?.num_ctx ?? 8192,
+                ...this.reviewerOptions?.temperature !== void 0 && { temperature: this.reviewerOptions.temperature },
+                ...this.reviewerOptions?.seed !== void 0 && { seed: this.reviewerOptions.seed },
+                ...this.reviewerOptions?.top_p !== void 0 && { top_p: this.reviewerOptions.top_p },
+                ...this.reviewerOptions?.top_k !== void 0 && { top_k: this.reviewerOptions.top_k },
+                ...this.reviewerOptions?.repeat_penalty !== void 0 && { repeat_penalty: this.reviewerOptions.repeat_penalty }
+              },
               messages: [
                 {
                   role: "system",
@@ -6049,6 +6092,16 @@ function renderReviewMarkdown(snapshot) {
   lines.push("");
   lines.push("> Adversarial review judges research integrity. It does not synthesize, rewrite source truth, or erase extraction history. Decisions below are review truth \u2014 claims.jsonl is unchanged.");
   lines.push("");
+  const opts = snapshot.reviewer_options;
+  if (opts && Object.keys(opts).length > 0) {
+    lines.push("## Reviewer options");
+    lines.push("");
+    const KEY_ORDER = ["num_ctx", "temperature", "seed", "top_p", "top_k", "repeat_penalty"];
+    for (const key of KEY_ORDER) {
+      if (opts[key] !== void 0) lines.push(`- ${key}: ${opts[key]}`);
+    }
+    lines.push("");
+  }
   lines.push("## Effective decisions");
   lines.push("");
   const decisions = snapshot.decision_counts;
@@ -6416,7 +6469,8 @@ async function runMultiPassReview(args) {
     drafts: merged,
     llmFindingsRejected,
     profile: args.options.profile ?? DEFAULT_PROFILE,
-    research: args.research
+    research: args.research,
+    reviewer_options: args.options.reviewer_options
   });
 }
 async function reviewWithSpecificReviewer(args) {
@@ -6445,7 +6499,8 @@ async function reviewWithSpecificReviewer(args) {
     drafts: result.drafts,
     llmFindingsRejected: 0,
     profile: args.options.profile ?? DEFAULT_PROFILE,
-    research: args.research
+    research: args.research,
+    reviewer_options: args.options.reviewer_options
   });
 }
 async function finalizeReview(args) {
@@ -6505,7 +6560,8 @@ async function finalizeReview(args) {
     decision_counts: decisionCounts,
     severity_counts: severityCounts,
     llm_findings_rejected_ungrounded: args.llmFindingsRejected,
-    promoted_to_reviewed: promoted
+    promoted_to_reviewed: promoted,
+    reviewer_options: args.reviewer_options
   });
   const profDir = profileDir(args.packPath, args.sectionId, args.profile);
   await mkdir12(profDir, { recursive: true });
@@ -7591,26 +7647,26 @@ var init_indexer = __esm({
 });
 
 // src/dispositions/schema.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var ClaimSynthesisDispositionStatusSchema, ClaimSynthesisDispositionSchema;
 var init_schema12 = __esm({
   "src/dispositions/schema.ts"() {
     "use strict";
-    ClaimSynthesisDispositionStatusSchema = z14.enum([
+    ClaimSynthesisDispositionStatusSchema = z15.enum([
       "parked_not_for_synthesis",
       "preserved_for_human_note",
       "needs_human_review_excluded",
       "out_of_bounds_regression_fixture"
     ]);
-    ClaimSynthesisDispositionSchema = z14.object({
-      claim_id: z14.string().min(1),
-      section_id: z14.string().min(1),
+    ClaimSynthesisDispositionSchema = z15.object({
+      claim_id: z15.string().min(1),
+      section_id: z15.string().min(1),
       status: ClaimSynthesisDispositionStatusSchema,
-      reason: z14.string().min(4),
-      decided_by: z14.string().min(1),
-      authorized_by: z14.string().min(1),
-      source: z14.string().min(1),
-      created_at: z14.string().min(1)
+      reason: z15.string().min(4),
+      decided_by: z15.string().min(1),
+      authorized_by: z15.string().min(1),
+      source: z15.string().min(1),
+      created_at: z15.string().min(1)
     });
   }
 });
@@ -7941,91 +7997,91 @@ var init_derive = __esm({
 });
 
 // src/cowork/schema.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var HandoffModeSchema, IndexStatusSchema, ProvenanceSummarySchema, SectionStateSchema, WaiverEntrySchema, GateVerdictEntrySchema, ReviewDecisionCountSchema, CoworkHandoffPayloadSchema;
 var init_schema13 = __esm({
   "src/cowork/schema.ts"() {
     "use strict";
-    HandoffModeSchema = z15.enum([
+    HandoffModeSchema = z16.enum([
       "repair_required",
       "synthesis_ready",
       "human_review_required"
     ]);
-    IndexStatusSchema = z15.enum(["present", "missing"]);
-    ProvenanceSummarySchema = z15.object({
-      accepted_count: z15.number().int().nonnegative(),
-      rejected_count: z15.number().int().nonnegative(),
-      triage_parked_count: z15.number().int().nonnegative(),
-      needs_review_undispositioned_count: z15.number().int().nonnegative(),
-      dispositioned_count: z15.number().int().nonnegative(),
-      dispositioned_breakdown: z15.object({
-        parked_not_for_synthesis: z15.number().int().nonnegative(),
-        preserved_for_human_note: z15.number().int().nonnegative(),
-        needs_human_review_excluded: z15.number().int().nonnegative(),
-        out_of_bounds_regression_fixture: z15.number().int().nonnegative()
+    IndexStatusSchema = z16.enum(["present", "missing"]);
+    ProvenanceSummarySchema = z16.object({
+      accepted_count: z16.number().int().nonnegative(),
+      rejected_count: z16.number().int().nonnegative(),
+      triage_parked_count: z16.number().int().nonnegative(),
+      needs_review_undispositioned_count: z16.number().int().nonnegative(),
+      dispositioned_count: z16.number().int().nonnegative(),
+      dispositioned_breakdown: z16.object({
+        parked_not_for_synthesis: z16.number().int().nonnegative(),
+        preserved_for_human_note: z16.number().int().nonnegative(),
+        needs_human_review_excluded: z16.number().int().nonnegative(),
+        out_of_bounds_regression_fixture: z16.number().int().nonnegative()
       }),
-      active_repair_blockers: z15.number().int().nonnegative(),
-      active_unresolved_contradictions: z15.number().int().nonnegative(),
-      waivers_active: z15.array(z15.string()),
-      overrides_applied_count: z15.number().int().nonnegative()
-    });
-    SectionStateSchema = z15.object({
-      section_id: z15.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      purpose: z15.string(),
-      status: z15.string(),
-      has_gate_run: z15.boolean(),
-      has_review_run: z15.boolean(),
-      gate_verdict: z15.string().nullable(),
-      synthesis_eligible: z15.boolean(),
-      accepted_claim_ids: z15.array(z15.string()),
-      repair_claim_ids: z15.array(z15.string()),
-      rejected_claim_ids: z15.array(z15.string()),
-      dispositioned_claim_ids: z15.array(z15.string()).default([]),
-      candidate_claims_total: z15.number().int().nonnegative(),
-      unresolved_contradiction_ids: z15.array(z15.string()),
-      blocking_reasons: z15.array(z15.string()),
-      active_blockers: z15.array(z15.string()).default([]),
-      blocking_contradictions_unresolved: z15.number().int().nonnegative(),
+      active_repair_blockers: z16.number().int().nonnegative(),
+      active_unresolved_contradictions: z16.number().int().nonnegative(),
+      waivers_active: z16.array(z16.string()),
+      overrides_applied_count: z16.number().int().nonnegative()
+    });
+    SectionStateSchema = z16.object({
+      section_id: z16.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+      purpose: z16.string(),
+      status: z16.string(),
+      has_gate_run: z16.boolean(),
+      has_review_run: z16.boolean(),
+      gate_verdict: z16.string().nullable(),
+      synthesis_eligible: z16.boolean(),
+      accepted_claim_ids: z16.array(z16.string()),
+      repair_claim_ids: z16.array(z16.string()),
+      rejected_claim_ids: z16.array(z16.string()),
+      dispositioned_claim_ids: z16.array(z16.string()).default([]),
+      candidate_claims_total: z16.number().int().nonnegative(),
+      unresolved_contradiction_ids: z16.array(z16.string()),
+      blocking_reasons: z16.array(z16.string()),
+      active_blockers: z16.array(z16.string()).default([]),
+      blocking_contradictions_unresolved: z16.number().int().nonnegative(),
       provenance_summary: ProvenanceSummarySchema.optional()
     });
-    WaiverEntrySchema = z15.object({
-      scope: z15.enum(["pack", "gate"]),
-      family: z15.string(),
-      reason: z15.string(),
-      compensating_controls: z15.array(z15.string()),
-      applied_to: z15.string()
-    });
-    GateVerdictEntrySchema = z15.object({
-      section_id: z15.string(),
-      verdict: z15.string(),
-      synthesis_eligible: z15.boolean()
-    });
-    ReviewDecisionCountSchema = z15.object({
-      section_id: z15.string(),
-      decision: z15.string(),
-      count: z15.number().int().nonnegative()
-    });
-    CoworkHandoffPayloadSchema = z15.object({
-      pack_id: z15.string(),
-      pack_topic: z15.string(),
-      generated_at: z15.string(),
+    WaiverEntrySchema = z16.object({
+      scope: z16.enum(["pack", "gate"]),
+      family: z16.string(),
+      reason: z16.string(),
+      compensating_controls: z16.array(z16.string()),
+      applied_to: z16.string()
+    });
+    GateVerdictEntrySchema = z16.object({
+      section_id: z16.string(),
+      verdict: z16.string(),
+      synthesis_eligible: z16.boolean()
+    });
+    ReviewDecisionCountSchema = z16.object({
+      section_id: z16.string(),
+      decision: z16.string(),
+      count: z16.number().int().nonnegative()
+    });
+    CoworkHandoffPayloadSchema = z16.object({
+      pack_id: z16.string(),
+      pack_topic: z16.string(),
+      generated_at: z16.string(),
       mode: HandoffModeSchema,
-      synthesis_allowed: z15.boolean(),
-      summary: z15.string(),
-      sections: z15.array(SectionStateSchema),
-      accepted_claim_ids: z15.array(z15.string()),
-      repair_claim_ids: z15.array(z15.string()),
-      blocked_claim_ids: z15.array(z15.string()),
-      dispositioned_claim_ids: z15.array(z15.string()).default([]),
-      unresolved_contradiction_ids: z15.array(z15.string()),
-      waivers: z15.array(WaiverEntrySchema),
-      gate_verdicts: z15.array(GateVerdictEntrySchema),
-      review_decisions: z15.array(ReviewDecisionCountSchema),
-      recommended_next_actions: z15.array(z15.string()),
-      allowed_write_paths: z15.array(z15.string()),
-      forbidden_actions: z15.array(z15.string()),
+      synthesis_allowed: z16.boolean(),
+      summary: z16.string(),
+      sections: z16.array(SectionStateSchema),
+      accepted_claim_ids: z16.array(z16.string()),
+      repair_claim_ids: z16.array(z16.string()),
+      blocked_claim_ids: z16.array(z16.string()),
+      dispositioned_claim_ids: z16.array(z16.string()).default([]),
+      unresolved_contradiction_ids: z16.array(z16.string()),
+      waivers: z16.array(WaiverEntrySchema),
+      gate_verdicts: z16.array(GateVerdictEntrySchema),
+      review_decisions: z16.array(ReviewDecisionCountSchema),
+      recommended_next_actions: z16.array(z16.string()),
+      allowed_write_paths: z16.array(z16.string()),
+      forbidden_actions: z16.array(z16.string()),
       index_status: IndexStatusSchema,
-      warnings: z15.array(z15.string())
+      warnings: z16.array(z16.string())
     });
   }
 });
@@ -8575,86 +8631,86 @@ var init_derive2 = __esm({
 });
 
 // src/synth/schema.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var SectionAcceptedSummarySchema, ClaimClusterSchema, SharedSourceSchema, ScopeOverlapSchema, CrossSectionContradictionRefSchema, WaiverDependencySchema, AllowedSynthesisInputSchema, ForbiddenInputSchema, CrossSectionMapSchema;
 var init_schema14 = __esm({
   "src/synth/schema.ts"() {
     "use strict";
-    SectionAcceptedSummarySchema = z16.object({
-      section_id: z16.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      purpose: z16.string(),
-      status: z16.string(),
-      accepted_claim_ids: z16.array(z16.string()),
-      excluded_reason: z16.string().nullable()
-    });
-    ClaimClusterSchema = z16.object({
-      cluster_id: z16.string(),
-      shared_source_ids: z16.array(z16.string()),
-      member_claim_ids: z16.array(z16.string()).min(1),
-      spans_sections: z16.array(z16.string())
-    });
-    SharedSourceSchema = z16.object({
-      source_id: z16.string(),
-      publisher: z16.string().nullable(),
-      source_type: z16.string(),
-      used_by_claim_ids: z16.array(z16.string()),
-      spans_sections: z16.array(z16.string())
-    });
-    ScopeOverlapSchema = z16.object({
-      claim_a: z16.string(),
-      claim_b: z16.string(),
-      scope_a: z16.string().nullable(),
-      scope_b: z16.string().nullable(),
-      jaccard: z16.number().min(0).max(1),
-      cross_section: z16.boolean(),
-      warning: z16.string()
-    });
-    CrossSectionContradictionRefSchema = z16.object({
-      contradiction_id: z16.string(),
-      claim_ids: z16.array(z16.string()),
-      sections: z16.array(z16.string()),
-      type: z16.string(),
-      severity: z16.string(),
-      status: z16.string()
-    });
-    WaiverDependencySchema = z16.object({
-      scope: z16.enum(["pack", "gate"]),
-      family: z16.string(),
-      reason: z16.string(),
-      compensating_controls: z16.array(z16.string()),
-      applied_to: z16.string(),
-      must_disclose_in: z16.enum(["decision-brief.md", "final-report.md", "both"])
+    SectionAcceptedSummarySchema = z17.object({
+      section_id: z17.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+      purpose: z17.string(),
+      status: z17.string(),
+      accepted_claim_ids: z17.array(z17.string()),
+      excluded_reason: z17.string().nullable()
     });
-    AllowedSynthesisInputSchema = z16.object({
-      claim_id: z16.string(),
-      section_id: z16.string(),
-      artifact_path: z16.string(),
-      asserts: z16.string(),
-      scope: z16.string().nullable(),
-      not: z16.string().nullable(),
-      source_ids: z16.array(z16.string())
-    });
-    ForbiddenInputSchema = z16.object({
-      claim_id: z16.string(),
-      section_id: z16.string(),
-      decision: z16.string(),
-      reason: z16.string()
+    ClaimClusterSchema = z17.object({
+      cluster_id: z17.string(),
+      shared_source_ids: z17.array(z17.string()),
+      member_claim_ids: z17.array(z17.string()).min(1),
+      spans_sections: z17.array(z17.string())
     });
-    CrossSectionMapSchema = z16.object({
-      pack_id: z16.string(),
-      pack_topic: z16.string(),
-      pack_decision: z16.string(),
-      generated_at: z16.string(),
-      accepted_claim_ids: z16.array(z16.string()),
-      sections: z16.array(SectionAcceptedSummarySchema),
-      claim_clusters: z16.array(ClaimClusterSchema),
-      shared_sources: z16.array(SharedSourceSchema),
-      scope_overlaps: z16.array(ScopeOverlapSchema),
-      cross_section_contradictions: z16.array(CrossSectionContradictionRefSchema),
-      waiver_dependencies: z16.array(WaiverDependencySchema),
-      open_questions: z16.array(z16.string()),
-      allowed_synthesis_inputs: z16.array(AllowedSynthesisInputSchema),
-      forbidden_inputs: z16.array(ForbiddenInputSchema)
+    SharedSourceSchema = z17.object({
+      source_id: z17.string(),
+      publisher: z17.string().nullable(),
+      source_type: z17.string(),
+      used_by_claim_ids: z17.array(z17.string()),
+      spans_sections: z17.array(z17.string())
+    });
+    ScopeOverlapSchema = z17.object({
+      claim_a: z17.string(),
+      claim_b: z17.string(),
+      scope_a: z17.string().nullable(),
+      scope_b: z17.string().nullable(),
+      jaccard: z17.number().min(0).max(1),
+      cross_section: z17.boolean(),
+      warning: z17.string()
+    });
+    CrossSectionContradictionRefSchema = z17.object({
+      contradiction_id: z17.string(),
+      claim_ids: z17.array(z17.string()),
+      sections: z17.array(z17.string()),
+      type: z17.string(),
+      severity: z17.string(),
+      status: z17.string()
+    });
+    WaiverDependencySchema = z17.object({
+      scope: z17.enum(["pack", "gate"]),
+      family: z17.string(),
+      reason: z17.string(),
+      compensating_controls: z17.array(z17.string()),
+      applied_to: z17.string(),
+      must_disclose_in: z17.enum(["decision-brief.md", "final-report.md", "both"])
+    });
+    AllowedSynthesisInputSchema = z17.object({
+      claim_id: z17.string(),
+      section_id: z17.string(),
+      artifact_path: z17.string(),
+      asserts: z17.string(),
+      scope: z17.string().nullable(),
+      not: z17.string().nullable(),
+      source_ids: z17.array(z17.string())
+    });
+    ForbiddenInputSchema = z17.object({
+      claim_id: z17.string(),
+      section_id: z17.string(),
+      decision: z17.string(),
+      reason: z17.string()
+    });
+    CrossSectionMapSchema = z17.object({
+      pack_id: z17.string(),
+      pack_topic: z17.string(),
+      pack_decision: z17.string(),
+      generated_at: z17.string(),
+      accepted_claim_ids: z17.array(z17.string()),
+      sections: z17.array(SectionAcceptedSummarySchema),
+      claim_clusters: z17.array(ClaimClusterSchema),
+      shared_sources: z17.array(SharedSourceSchema),
+      scope_overlaps: z17.array(ScopeOverlapSchema),
+      cross_section_contradictions: z17.array(CrossSectionContradictionRefSchema),
+      waiver_dependencies: z17.array(WaiverDependencySchema),
+      open_questions: z17.array(z17.string()),
+      allowed_synthesis_inputs: z17.array(AllowedSynthesisInputSchema),
+      forbidden_inputs: z17.array(ForbiddenInputSchema)
     });
   }
 });
@@ -9822,179 +9878,179 @@ var init_aggregate = __esm({
 });
 
 // src/audit/schema.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var PackVerdictSchema, HandoffModeSchema2, OrphanClaimRowSchema, StaleSourceRowSchema, WeakSourceRowSchema, UnresolvedContradictionRowSchema, ScopeWideningRiskRowSchema, SourceDiversityGapRowSchema, SynthesisReadinessRowSchema, PackAuditPayloadSchema;
 var init_schema15 = __esm({
   "src/audit/schema.ts"() {
     "use strict";
-    PackVerdictSchema = z17.enum([
+    PackVerdictSchema = z18.enum([
       "ready_for_synthesis",
       "repair_required",
       "human_review_required",
       "blocked"
     ]);
-    HandoffModeSchema2 = z17.enum([
+    HandoffModeSchema2 = z18.enum([
       "repair_required",
       "synthesis_ready",
       "human_review_required",
       "unknown"
     ]);
-    OrphanClaimRowSchema = z17.object({
-      claim_id: z17.string(),
-      section_id: z17.string(),
-      reason: z17.enum([
+    OrphanClaimRowSchema = z18.object({
+      claim_id: z18.string(),
+      section_id: z18.string(),
+      reason: z18.enum([
         "missing_source_card",
         "missing_source_hash",
         "missing_evidence_excerpt",
         "unresolvable_source_id"
       ]),
-      details: z17.string(),
-      artifact_path: z17.string()
-    });
-    StaleSourceRowSchema = z17.object({
-      source_id: z17.string(),
-      section_id: z17.string(),
-      publisher: z17.string().nullable(),
-      reason: z17.enum(["too_old", "missing_date", "unparseable_date"]),
-      details: z17.string(),
-      artifact_path: z17.string(),
-      policy: z17.object({
-        required: z17.boolean(),
-        max_source_age_months: z17.number().int().nullable(),
-        stale_source_policy: z17.enum(["warn", "fail"])
+      details: z18.string(),
+      artifact_path: z18.string()
+    });
+    StaleSourceRowSchema = z18.object({
+      source_id: z18.string(),
+      section_id: z18.string(),
+      publisher: z18.string().nullable(),
+      reason: z18.enum(["too_old", "missing_date", "unparseable_date"]),
+      details: z18.string(),
+      artifact_path: z18.string(),
+      policy: z18.object({
+        required: z18.boolean(),
+        max_source_age_months: z18.number().int().nullable(),
+        stale_source_policy: z18.enum(["warn", "fail"])
       })
     });
-    WeakSourceRowSchema = z17.object({
-      reason: z17.enum([
+    WeakSourceRowSchema = z18.object({
+      reason: z18.enum([
         "source_cluster_monopoly",
         "low_independent_publishers",
         "missing_primary_source",
         "excessive_type_imbalance",
         "failed_fetches_reducing_floor"
       ]),
-      section_id: z17.string(),
-      details: z17.string(),
-      evidence_ids: z17.array(z17.string()),
-      artifact_path: z17.string()
-    });
-    UnresolvedContradictionRowSchema = z17.object({
-      contradiction_id: z17.string(),
-      section_id: z17.string(),
-      type: z17.string(),
-      severity: z17.string(),
-      status: z17.string(),
-      claim_ids: z17.array(z17.string()),
-      artifact_path: z17.string()
-    });
-    ScopeWideningRiskRowSchema = z17.object({
-      reason: z17.enum([
+      section_id: z18.string(),
+      details: z18.string(),
+      evidence_ids: z18.array(z18.string()),
+      artifact_path: z18.string()
+    });
+    UnresolvedContradictionRowSchema = z18.object({
+      contradiction_id: z18.string(),
+      section_id: z18.string(),
+      type: z18.string(),
+      severity: z18.string(),
+      status: z18.string(),
+      claim_ids: z18.array(z18.string()),
+      artifact_path: z18.string()
+    });
+    ScopeWideningRiskRowSchema = z18.object({
+      reason: z18.enum([
         "overgeneralization_finding",
         "scope_null_in_use",
         "missing_not_flagged",
         "contextual_to_universal_risk"
       ]),
-      claim_id: z17.string(),
-      section_id: z17.string(),
-      details: z17.string(),
-      artifact_path: z17.string()
+      claim_id: z18.string(),
+      section_id: z18.string(),
+      details: z18.string(),
+      artifact_path: z18.string()
     });
-    SourceDiversityGapRowSchema = z17.object({
-      reason: z17.enum([
+    SourceDiversityGapRowSchema = z18.object({
+      reason: z18.enum([
         "section_publisher_monopoly",
         "low_section_publisher_count",
         "cross_section_publisher_overlap",
         "section_has_no_sources"
       ]),
-      section_id: z17.string(),
-      details: z17.string(),
-      evidence_ids: z17.array(z17.string())
-    });
-    SynthesisReadinessRowSchema = z17.object({
-      section_id: z17.string(),
-      purpose: z17.string(),
-      status: z17.string(),
-      has_gate_run: z17.boolean(),
-      has_review_run: z17.boolean(),
-      gate_verdict: z17.string().nullable(),
-      synthesis_eligible: z17.boolean(),
-      candidate_claims: z17.number().int().nonnegative(),
-      accepted_claims: z17.number().int().nonnegative(),
-      repair_claims: z17.number().int().nonnegative(),
-      rejected_claims: z17.number().int().nonnegative(),
-      dispositioned_claims: z17.number().int().nonnegative(),
-      blocking_reasons: z17.array(z17.string()),
+      section_id: z18.string(),
+      details: z18.string(),
+      evidence_ids: z18.array(z18.string())
+    });
+    SynthesisReadinessRowSchema = z18.object({
+      section_id: z18.string(),
+      purpose: z18.string(),
+      status: z18.string(),
+      has_gate_run: z18.boolean(),
+      has_review_run: z18.boolean(),
+      gate_verdict: z18.string().nullable(),
+      synthesis_eligible: z18.boolean(),
+      candidate_claims: z18.number().int().nonnegative(),
+      accepted_claims: z18.number().int().nonnegative(),
+      repair_claims: z18.number().int().nonnegative(),
+      rejected_claims: z18.number().int().nonnegative(),
+      dispositioned_claims: z18.number().int().nonnegative(),
+      blocking_reasons: z18.array(z18.string()),
       cowork_handoff_mode: HandoffModeSchema2,
-      workspace_allowed: z17.boolean()
+      workspace_allowed: z18.boolean()
     });
-    PackAuditPayloadSchema = z17.object({
-      pack_id: z17.string(),
-      pack_topic: z17.string(),
-      generated_at: z17.string(),
+    PackAuditPayloadSchema = z18.object({
+      pack_id: z18.string(),
+      pack_topic: z18.string(),
+      generated_at: z18.string(),
       verdict: PackVerdictSchema,
-      synthesis_allowed: z17.boolean(),
-      section_summaries: z17.array(SynthesisReadinessRowSchema),
-      claim_summary: z17.object({
-        total: z17.number().int().nonnegative(),
-        candidate: z17.number().int().nonnegative(),
-        accepted_for_synthesis: z17.number().int().nonnegative(),
-        rejected: z17.number().int().nonnegative(),
-        needs_repair: z17.number().int().nonnegative(),
-        dispositioned: z17.number().int().nonnegative(),
-        no_review: z17.number().int().nonnegative(),
-        with_evidence_excerpt: z17.number().int().nonnegative(),
-        with_source_hashes: z17.number().int().nonnegative(),
-        scope_null: z17.number().int().nonnegative(),
-        not_null: z17.number().int().nonnegative(),
-        orphans: z17.number().int().nonnegative()
+      synthesis_allowed: z18.boolean(),
+      section_summaries: z18.array(SynthesisReadinessRowSchema),
+      claim_summary: z18.object({
+        total: z18.number().int().nonnegative(),
+        candidate: z18.number().int().nonnegative(),
+        accepted_for_synthesis: z18.number().int().nonnegative(),
+        rejected: z18.number().int().nonnegative(),
+        needs_repair: z18.number().int().nonnegative(),
+        dispositioned: z18.number().int().nonnegative(),
+        no_review: z18.number().int().nonnegative(),
+        with_evidence_excerpt: z18.number().int().nonnegative(),
+        with_source_hashes: z18.number().int().nonnegative(),
+        scope_null: z18.number().int().nonnegative(),
+        not_null: z18.number().int().nonnegative(),
+        orphans: z18.number().int().nonnegative()
       }),
-      source_summary: z17.object({
-        total: z17.number().int().nonnegative(),
-        primary: z17.number().int().nonnegative(),
-        secondary: z17.number().int().nonnegative(),
-        forum: z17.number().int().nonnegative(),
-        benchmark: z17.number().int().nonnegative(),
-        docs: z17.number().int().nonnegative(),
-        unknown: z17.number().int().nonnegative(),
-        independent_publishers: z17.number().int().nonnegative(),
-        failed_fetches: z17.number().int().nonnegative(),
-        sections_with_sources: z17.number().int().nonnegative(),
-        sections_without_sources: z17.number().int().nonnegative()
+      source_summary: z18.object({
+        total: z18.number().int().nonnegative(),
+        primary: z18.number().int().nonnegative(),
+        secondary: z18.number().int().nonnegative(),
+        forum: z18.number().int().nonnegative(),
+        benchmark: z18.number().int().nonnegative(),
+        docs: z18.number().int().nonnegative(),
+        unknown: z18.number().int().nonnegative(),
+        independent_publishers: z18.number().int().nonnegative(),
+        failed_fetches: z18.number().int().nonnegative(),
+        sections_with_sources: z18.number().int().nonnegative(),
+        sections_without_sources: z18.number().int().nonnegative()
       }),
-      contradiction_summary: z17.object({
-        total: z17.number().int().nonnegative(),
-        unresolved: z17.number().int().nonnegative(),
-        blocking: z17.number().int().nonnegative(),
-        reconciled: z17.number().int().nonnegative(),
-        preserved_deliberately: z17.number().int().nonnegative(),
-        rejected: z17.number().int().nonnegative(),
-        by_type: z17.record(z17.string(), z17.number().int().nonnegative()),
-        sections_with_clean_ledger: z17.number().int().nonnegative()
+      contradiction_summary: z18.object({
+        total: z18.number().int().nonnegative(),
+        unresolved: z18.number().int().nonnegative(),
+        blocking: z18.number().int().nonnegative(),
+        reconciled: z18.number().int().nonnegative(),
+        preserved_deliberately: z18.number().int().nonnegative(),
+        rejected: z18.number().int().nonnegative(),
+        by_type: z18.record(z18.string(), z18.number().int().nonnegative()),
+        sections_with_clean_ledger: z18.number().int().nonnegative()
       }),
-      review_summary: z17.object({
-        sections_with_review_run: z17.number().int().nonnegative(),
-        sections_without_review_run: z17.number().int().nonnegative(),
-        decision_counts: z17.record(z17.string(), z17.number().int().nonnegative()),
-        blocking_findings: z17.number().int().nonnegative()
+      review_summary: z18.object({
+        sections_with_review_run: z18.number().int().nonnegative(),
+        sections_without_review_run: z18.number().int().nonnegative(),
+        decision_counts: z18.record(z18.string(), z18.number().int().nonnegative()),
+        blocking_findings: z18.number().int().nonnegative()
       }),
-      waiver_summary: z17.object({
-        total: z17.number().int().nonnegative(),
-        invalid: z17.number().int().nonnegative(),
-        by_family: z17.record(z17.string(), z17.number().int().nonnegative())
+      waiver_summary: z18.object({
+        total: z18.number().int().nonnegative(),
+        invalid: z18.number().int().nonnegative(),
+        by_family: z18.record(z18.string(), z18.number().int().nonnegative())
       }),
-      readiness_summary: z17.object({
-        total_sections: z17.number().int().nonnegative(),
-        ready_sections: z17.number().int().nonnegative(),
-        repair_sections: z17.number().int().nonnegative(),
-        blocked_sections: z17.number().int().nonnegative(),
-        no_gate_sections: z17.number().int().nonnegative(),
-        no_review_sections: z17.number().int().nonnegative(),
+      readiness_summary: z18.object({
+        total_sections: z18.number().int().nonnegative(),
+        ready_sections: z18.number().int().nonnegative(),
+        repair_sections: z18.number().int().nonnegative(),
+        blocked_sections: z18.number().int().nonnegative(),
+        no_gate_sections: z18.number().int().nonnegative(),
+        no_review_sections: z18.number().int().nonnegative(),
         cowork_handoff_mode: HandoffModeSchema2,
-        workspace_allowed: z17.boolean()
+        workspace_allowed: z18.boolean()
       }),
-      audit_files: z17.array(z17.string()),
-      blocking_reasons: z17.array(z17.string()),
-      warnings: z17.array(z17.string()),
-      next_actions: z17.array(z17.string())
+      audit_files: z18.array(z18.string()),
+      blocking_reasons: z18.array(z18.string()),
+      warnings: z18.array(z18.string()),
+      next_actions: z18.array(z18.string())
     });
   }
 });
@@ -10661,79 +10717,79 @@ var init_markdown7 = __esm({
 });
 
 // src/freeze/schema.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var ArtifactHashSchema, IntegrityCheckSchema, FreezeReceiptPayloadSchema, FreezeRefusalPayloadSchema;
 var init_schema16 = __esm({
   "src/freeze/schema.ts"() {
     "use strict";
-    ArtifactHashSchema = z18.object({
-      path: z18.string(),
-      sha256: z18.string().regex(/^[a-f0-9]{64}$/),
-      bytes: z18.number().int().nonnegative()
-    });
-    IntegrityCheckSchema = z18.object({
-      name: z18.string().min(1),
-      passed: z18.boolean(),
-      detail: z18.string()
-    });
-    FreezeReceiptPayloadSchema = z18.object({
-      pack_id: z18.string(),
-      pack_topic: z18.string(),
-      frozen_at: z18.string(),
-      verdict: z18.literal("frozen"),
-      pack_audit_hash: z18.string().regex(/^[a-f0-9]{64}$/),
-      handoff_hash: z18.string().regex(/^[a-f0-9]{64}$/),
-      synthesis_hashes: z18.array(ArtifactHashSchema),
-      canonical_artifact_hashes: z18.array(ArtifactHashSchema),
-      accepted_claim_ids: z18.array(z18.string()),
-      cited_claim_ids: z18.array(z18.string()),
-      uncited_accepted_claim_ids: z18.array(z18.string()),
-      unresolved_contradictions: z18.array(
-        z18.object({
-          contradiction_id: z18.string(),
-          section_id: z18.string(),
-          type: z18.string(),
-          severity: z18.string(),
-          status: z18.string(),
-          disclosed_in: z18.array(z18.string())
+    ArtifactHashSchema = z19.object({
+      path: z19.string(),
+      sha256: z19.string().regex(/^[a-f0-9]{64}$/),
+      bytes: z19.number().int().nonnegative()
+    });
+    IntegrityCheckSchema = z19.object({
+      name: z19.string().min(1),
+      passed: z19.boolean(),
+      detail: z19.string()
+    });
+    FreezeReceiptPayloadSchema = z19.object({
+      pack_id: z19.string(),
+      pack_topic: z19.string(),
+      frozen_at: z19.string(),
+      verdict: z19.literal("frozen"),
+      pack_audit_hash: z19.string().regex(/^[a-f0-9]{64}$/),
+      handoff_hash: z19.string().regex(/^[a-f0-9]{64}$/),
+      synthesis_hashes: z19.array(ArtifactHashSchema),
+      canonical_artifact_hashes: z19.array(ArtifactHashSchema),
+      accepted_claim_ids: z19.array(z19.string()),
+      cited_claim_ids: z19.array(z19.string()),
+      uncited_accepted_claim_ids: z19.array(z19.string()),
+      unresolved_contradictions: z19.array(
+        z19.object({
+          contradiction_id: z19.string(),
+          section_id: z19.string(),
+          type: z19.string(),
+          severity: z19.string(),
+          status: z19.string(),
+          disclosed_in: z19.array(z19.string())
         })
       ),
-      waivers_disclosed: z18.array(
-        z18.object({
-          family: z18.string(),
-          applied_to: z18.string(),
-          reason: z18.string(),
-          compensating_controls: z18.array(z18.string()),
-          disclosed_in: z18.array(z18.string())
+      waivers_disclosed: z19.array(
+        z19.object({
+          family: z19.string(),
+          applied_to: z19.string(),
+          reason: z19.string(),
+          compensating_controls: z19.array(z19.string()),
+          disclosed_in: z19.array(z19.string())
         })
       ),
-      sections: z18.array(
-        z18.object({
-          section_id: z18.string(),
-          status: z18.string(),
-          accepted_claims: z18.number().int().nonnegative(),
-          sources: z18.number().int().nonnegative(),
-          contradictions: z18.number().int().nonnegative()
+      sections: z19.array(
+        z19.object({
+          section_id: z19.string(),
+          status: z19.string(),
+          accepted_claims: z19.number().int().nonnegative(),
+          sources: z19.number().int().nonnegative(),
+          contradictions: z19.number().int().nonnegative()
         })
       ),
-      source_count: z18.number().int().nonnegative(),
-      claim_count: z18.number().int().nonnegative(),
-      contradiction_count: z18.number().int().nonnegative(),
-      review_finding_count: z18.number().int().nonnegative(),
-      gate_result_count: z18.number().int().nonnegative(),
-      integrity_checks: z18.array(IntegrityCheckSchema)
-    });
-    FreezeRefusalPayloadSchema = z18.object({
-      pack_id: z18.string(),
-      pack_topic: z18.string(),
-      checked_at: z18.string(),
-      verdict: z18.literal("refused"),
-      reasons: z18.array(z18.string()),
-      blocking_reasons: z18.array(z18.string()),
-      missing_artifacts: z18.array(z18.string()),
-      invalid_artifacts: z18.array(z18.object({ path: z18.string(), error: z18.string() })),
-      next_actions: z18.array(z18.string()),
-      would_freeze: z18.literal(false)
+      source_count: z19.number().int().nonnegative(),
+      claim_count: z19.number().int().nonnegative(),
+      contradiction_count: z19.number().int().nonnegative(),
+      review_finding_count: z19.number().int().nonnegative(),
+      gate_result_count: z19.number().int().nonnegative(),
+      integrity_checks: z19.array(IntegrityCheckSchema)
+    });
+    FreezeRefusalPayloadSchema = z19.object({
+      pack_id: z19.string(),
+      pack_topic: z19.string(),
+      checked_at: z19.string(),
+      verdict: z19.literal("refused"),
+      reasons: z19.array(z19.string()),
+      blocking_reasons: z19.array(z19.string()),
+      missing_artifacts: z19.array(z19.string()),
+      invalid_artifacts: z19.array(z19.object({ path: z19.string(), error: z19.string() })),
+      next_actions: z19.array(z19.string()),
+      would_freeze: z19.literal(false)
     });
   }
 });
@@ -11207,35 +11263,35 @@ var init_freeze = __esm({
 });
 
 // src/invalidate/schema.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var ArchivedArtifactSchema, SectionStatusChangeSchema, InvalidationReceiptSchema;
 var init_schema17 = __esm({
   "src/invalidate/schema.ts"() {
     "use strict";
-    ArchivedArtifactSchema = z19.object({
-      src: z19.string(),
+    ArchivedArtifactSchema = z20.object({
+      src: z20.string(),
       // path relative to packPath, before archival
-      dst: z19.string()
+      dst: z20.string()
       // path relative to packPath, after archival
     });
-    SectionStatusChangeSchema = z19.object({
-      section_id: z19.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      before: z19.string(),
-      after: z19.string()
+    SectionStatusChangeSchema = z20.object({
+      section_id: z20.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+      before: z20.string(),
+      after: z20.string()
     });
-    InvalidationReceiptSchema = z19.object({
-      receipt_id: z19.string().regex(/^inv_[0-9]+_[a-z0-9-]+$/),
-      contract_label: z19.string().min(1),
-      superseded_contract: z19.string().min(1).nullable(),
-      new_contract: z19.string().min(1),
-      reason: z19.string().min(8),
-      invalidated_at: z19.string(),
-      research_os_version: z19.string(),
-      affected_sections: z19.array(z19.string().regex(/^[0-9]{2}-[a-z0-9-]+$/)),
-      archived_artifacts: z19.array(ArchivedArtifactSchema),
-      section_status_changes: z19.array(SectionStatusChangeSchema),
-      frozen_at_cleared: z19.boolean(),
-      notes: z19.string().nullable()
+    InvalidationReceiptSchema = z20.object({
+      receipt_id: z20.string().regex(/^inv_[0-9]+_[a-z0-9-]+$/),
+      contract_label: z20.string().min(1),
+      superseded_contract: z20.string().min(1).nullable(),
+      new_contract: z20.string().min(1),
+      reason: z20.string().min(8),
+      invalidated_at: z20.string(),
+      research_os_version: z20.string(),
+      affected_sections: z20.array(z20.string().regex(/^[0-9]{2}-[a-z0-9-]+$/)),
+      archived_artifacts: z20.array(ArchivedArtifactSchema),
+      section_status_changes: z20.array(SectionStatusChangeSchema),
+      frozen_at_cleared: z20.boolean(),
+      notes: z20.string().nullable()
     });
   }
 });
@@ -11501,7 +11557,7 @@ var init_run9 = __esm({
 import { existsSync as existsSync26 } from "fs";
 import { mkdir as mkdir20, rename as rename2, writeFile as writeFile20 } from "fs/promises";
 import { dirname as dirname7, join as join26, posix as posix2, relative as relative4, resolve as resolve21, sep as sep2 } from "path";
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 function posixify2(p) {
   return p.split(sep2).join("/");
 }
@@ -11633,15 +11689,15 @@ var init_review2 = __esm({
     init_errors();
     init_src();
     init_schema17();
-    ReviewInvalidationReceiptSchema = z20.object({
-      receipt_id: z20.string().regex(/^invr_[0-9]+_[a-z0-9-]+$/),
-      section_id: z20.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      contract_label: z20.string().min(1),
-      reason: z20.string().min(8),
-      invalidated_at: z20.string(),
-      research_os_version: z20.string(),
-      archived_artifacts: z20.array(ArchivedArtifactSchema),
-      notes: z20.string().nullable()
+    ReviewInvalidationReceiptSchema = z21.object({
+      receipt_id: z21.string().regex(/^invr_[0-9]+_[a-z0-9-]+$/),
+      section_id: z21.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+      contract_label: z21.string().min(1),
+      reason: z21.string().min(8),
+      invalidated_at: z21.string(),
+      research_os_version: z21.string(),
+      archived_artifacts: z21.array(ArchivedArtifactSchema),
+      notes: z21.string().nullable()
     });
   }
 });
@@ -11666,17 +11722,17 @@ var init_triage = __esm({
 });
 
 // src/discover/schema.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var DiscoveryCandidateStatusSchema, SourceTypeGuessSchema, DiscoveryCandidateSchema, DiscoverySummarySchema;
 var init_schema18 = __esm({
   "src/discover/schema.ts"() {
     "use strict";
-    DiscoveryCandidateStatusSchema = z21.enum([
+    DiscoveryCandidateStatusSchema = z22.enum([
       "candidate",
       "approved",
       "rejected"
     ]);
-    SourceTypeGuessSchema = z21.enum([
+    SourceTypeGuessSchema = z22.enum([
       "primary",
       "docs",
       "paper",
@@ -11686,36 +11742,36 @@ var init_schema18 = __esm({
       "benchmark",
       "unknown"
     ]);
-    DiscoveryCandidateSchema = z21.object({
-      candidate_id: z21.string().regex(/^disc_[a-f0-9]{12}$/),
-      section_id: z21.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      url: z21.string().url(),
-      title: z21.string().min(1),
-      publisher: z21.string().nullable(),
+    DiscoveryCandidateSchema = z22.object({
+      candidate_id: z22.string().regex(/^disc_[a-f0-9]{12}$/),
+      section_id: z22.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+      url: z22.string().url(),
+      title: z22.string().min(1),
+      publisher: z22.string().nullable(),
       source_type_guess: SourceTypeGuessSchema,
-      why_relevant: z21.string().min(1),
+      why_relevant: z22.string().min(1),
       // The free-text query that produced this candidate (for traceability).
-      query: z21.string().min(1),
+      query: z22.string().min(1),
       // Lower rank = more central. Stable per-(query, provider) ordering.
-      rank: z21.number().int().positive(),
-      discovered_at: z21.string(),
+      rank: z22.number().int().positive(),
+      discovered_at: z22.string(),
       // 'candidate' | 'approved' | 'rejected'. Append-only: new entries with
       // same candidate_id supersede older ones; the latest entry's status wins.
       status: DiscoveryCandidateStatusSchema,
-      discovered_by: z21.string().min(1),
-      reason: z21.string().nullable().default(null)
+      discovered_by: z22.string().min(1),
+      reason: z22.string().nullable().default(null)
     });
-    DiscoverySummarySchema = z21.object({
-      summary_id: z21.string().regex(/^disum_[0-9]+_[a-z0-9-]+$/),
-      section_id: z21.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      ran_at: z21.string(),
-      research_os_version: z21.string(),
-      query: z21.string().min(1),
-      provider: z21.string().min(1),
-      candidates_proposed: z21.number().int().nonnegative(),
-      candidates_validated: z21.number().int().nonnegative(),
-      candidates_rejected_invalid_url: z21.number().int().nonnegative(),
-      warnings: z21.array(z21.string())
+    DiscoverySummarySchema = z22.object({
+      summary_id: z22.string().regex(/^disum_[0-9]+_[a-z0-9-]+$/),
+      section_id: z22.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+      ran_at: z22.string(),
+      research_os_version: z22.string(),
+      query: z22.string().min(1),
+      provider: z22.string().min(1),
+      candidates_proposed: z22.number().int().nonnegative(),
+      candidates_validated: z22.number().int().nonnegative(),
+      candidates_rejected_invalid_url: z22.number().int().nonnegative(),
+      warnings: z22.array(z22.string())
     });
   }
 });
@@ -12199,88 +12255,88 @@ var init_src = __esm({
     init_triage();
     init_discover();
     init_errors();
-    RESEARCH_OS_VERSION = "0.5.0";
+    RESEARCH_OS_VERSION = "0.6.0";
   }
 });
 
 // src/section_report/schema.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var SectionReportSourcesSchema, SectionReportExtractionSchema, SectionReportContradictionsSchema, SectionReportReviewSchema, SectionReportAcceptanceSchema, SectionReportSchema;
 var init_schema19 = __esm({
   "src/section_report/schema.ts"() {
     "use strict";
-    SectionReportSourcesSchema = z22.object({
-      fetched_ok: z22.number().int().nonnegative(),
-      source_cards: z22.number().int().nonnegative(),
-      publishers: z22.array(z22.string()),
-      primary_source_waiver: z22.object({
-        status: z22.enum(["none", "requested", "granted"]),
-        reason: z22.string().nullable(),
-        compensating_controls: z22.array(z22.string())
+    SectionReportSourcesSchema = z23.object({
+      fetched_ok: z23.number().int().nonnegative(),
+      source_cards: z23.number().int().nonnegative(),
+      publishers: z23.array(z23.string()),
+      primary_source_waiver: z23.object({
+        status: z23.enum(["none", "requested", "granted"]),
+        reason: z23.string().nullable(),
+        compensating_controls: z23.array(z23.string())
       })
     });
-    SectionReportExtractionSchema = z22.object({
-      candidate_claims: z22.number().int().nonnegative(),
-      claims_per_source: z22.array(
-        z22.object({
-          source_id: z22.string(),
-          claims: z22.number().int().nonnegative()
+    SectionReportExtractionSchema = z23.object({
+      candidate_claims: z23.number().int().nonnegative(),
+      claims_per_source: z23.array(
+        z23.object({
+          source_id: z23.string(),
+          claims: z23.number().int().nonnegative()
         })
       ),
-      claims_per_1k_words: z22.number(),
-      excerpt_pages_processed: z22.number().int().nonnegative().nullable(),
-      excerpt_id_failures: z22.number().int().nonnegative().nullable(),
-      malformed_extractor_outputs: z22.number().int().nonnegative().nullable(),
-      near_duplicate_clusters: z22.number().int().nonnegative(),
-      weak_scope_count: z22.number().int().nonnegative(),
-      generic_scope_count: z22.number().int().nonnegative(),
-      density_flags: z22.number().int().nonnegative()
-    });
-    SectionReportContradictionsSchema = z22.object({
-      pairs_compared: z22.number().int().nonnegative().nullable(),
-      contradiction_candidates: z22.number().int().nonnegative(),
-      overgeneralization_risks: z22.number().int().nonnegative()
-    });
-    SectionReportReviewSchema = z22.object({
-      reviewed: z22.boolean(),
-      accepted_for_synthesis: z22.number().int().nonnegative(),
-      needs_scope_repair: z22.number().int().nonnegative(),
-      needs_source_repair: z22.number().int().nonnegative(),
-      needs_contradiction_mapping: z22.number().int().nonnegative(),
-      rejected: z22.number().int().nonnegative(),
-      needs_human_review: z22.number().int().nonnegative(),
-      rejection_or_repair_by_category: z22.array(
-        z22.object({
-          category: z22.string(),
-          count: z22.number().int().nonnegative()
+      claims_per_1k_words: z23.number(),
+      excerpt_pages_processed: z23.number().int().nonnegative().nullable(),
+      excerpt_id_failures: z23.number().int().nonnegative().nullable(),
+      malformed_extractor_outputs: z23.number().int().nonnegative().nullable(),
+      near_duplicate_clusters: z23.number().int().nonnegative(),
+      weak_scope_count: z23.number().int().nonnegative(),
+      generic_scope_count: z23.number().int().nonnegative(),
+      density_flags: z23.number().int().nonnegative()
+    });
+    SectionReportContradictionsSchema = z23.object({
+      pairs_compared: z23.number().int().nonnegative().nullable(),
+      contradiction_candidates: z23.number().int().nonnegative(),
+      overgeneralization_risks: z23.number().int().nonnegative()
+    });
+    SectionReportReviewSchema = z23.object({
+      reviewed: z23.boolean(),
+      accepted_for_synthesis: z23.number().int().nonnegative(),
+      needs_scope_repair: z23.number().int().nonnegative(),
+      needs_source_repair: z23.number().int().nonnegative(),
+      needs_contradiction_mapping: z23.number().int().nonnegative(),
+      rejected: z23.number().int().nonnegative(),
+      needs_human_review: z23.number().int().nonnegative(),
+      rejection_or_repair_by_category: z23.array(
+        z23.object({
+          category: z23.string(),
+          count: z23.number().int().nonnegative()
         })
       )
     });
-    SectionReportAcceptanceSchema = z22.object({
-      candidate_claims: z22.number().int().nonnegative(),
-      accepted_for_synthesis: z22.number().int().nonnegative(),
-      acceptance_ratio: z22.number(),
+    SectionReportAcceptanceSchema = z23.object({
+      candidate_claims: z23.number().int().nonnegative(),
+      accepted_for_synthesis: z23.number().int().nonnegative(),
+      acceptance_ratio: z23.number(),
       // 0..1
-      accepted_per_source: z22.number(),
+      accepted_per_source: z23.number(),
       // accepted / source_count, 0 if no sources
-      accepted_per_1k_words: z22.number(),
-      top_rejection_category: z22.string().nullable(),
-      claim_overproduction_fired: z22.boolean(),
-      synthesis_ready: z22.boolean()
-    });
-    SectionReportSchema = z22.object({
-      report_id: z22.string().regex(/^secrep_[0-9]+_[a-z0-9-]+$/),
-      section_id: z22.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      reported_at: z22.string(),
-      research_os_version: z22.string(),
-      status: z22.string(),
+      accepted_per_1k_words: z23.number(),
+      top_rejection_category: z23.string().nullable(),
+      claim_overproduction_fired: z23.boolean(),
+      synthesis_ready: z23.boolean()
+    });
+    SectionReportSchema = z23.object({
+      report_id: z23.string().regex(/^secrep_[0-9]+_[a-z0-9-]+$/),
+      section_id: z23.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+      reported_at: z23.string(),
+      research_os_version: z23.string(),
+      status: z23.string(),
       sources: SectionReportSourcesSchema,
       extraction: SectionReportExtractionSchema,
       contradictions: SectionReportContradictionsSchema,
       review: SectionReportReviewSchema,
       acceptance: SectionReportAcceptanceSchema,
-      gate_verdict: z22.string().nullable(),
-      gate_synthesis_eligible: z22.boolean().nullable()
+      gate_verdict: z23.string().nullable(),
+      gate_synthesis_eligible: z23.boolean().nullable()
     });
   }
 });
@@ -12643,7 +12699,7 @@ import { createHash as createHash11 } from "crypto";
 import { readFileSync, existsSync as existsSync29 } from "fs";
 import { join as join29 } from "path";
 import { parse as parseYaml } from "yaml";
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 
 // src/closure-ledger/effective-accepted.ts
 function getEffectiveDecisionMap(reviews) {
@@ -12688,38 +12744,38 @@ function findIncompatibleDecisions(reviews) {
 }
 
 // src/pack/publish/schema.ts
-import { z as z23 } from "zod";
-var SectionSummarySchema = z23.object({
-  id: z23.string().min(1),
-  accepted_claims: z23.number().int().min(0),
-  gate: z23.enum(["pass", "warn", "fail", "blocked", "pass_with_waiver"]),
-  synthesis_eligible: z23.boolean()
-});
-var TotalsSchema = z23.object({
-  sections: z23.number().int().min(1),
-  accepted_claims: z23.number().int().min(0),
-  dispositioned: z23.number().int().min(0),
-  unresolved_contradictions: z23.number().int().min(0),
-  preserved_contradiction_records: z23.number().int().min(0).optional()
-});
-var PackManifestSchema = z23.object({
-  name: z23.string().min(1),
-  topic: z23.string().min(1),
-  frozen_at: z23.string().datetime(),
-  research_os_version: z23.string().min(1),
-  sections: z23.array(SectionSummarySchema).min(1),
+import { z as z24 } from "zod";
+var SectionSummarySchema = z24.object({
+  id: z24.string().min(1),
+  accepted_claims: z24.number().int().min(0),
+  gate: z24.enum(["pass", "warn", "fail", "blocked", "pass_with_waiver"]),
+  synthesis_eligible: z24.boolean()
+});
+var TotalsSchema = z24.object({
+  sections: z24.number().int().min(1),
+  accepted_claims: z24.number().int().min(0),
+  dispositioned: z24.number().int().min(0),
+  unresolved_contradictions: z24.number().int().min(0),
+  preserved_contradiction_records: z24.number().int().min(0).optional()
+});
+var PackManifestSchema = z24.object({
+  name: z24.string().min(1),
+  topic: z24.string().min(1),
+  frozen_at: z24.string().datetime(),
+  research_os_version: z24.string().min(1),
+  sections: z24.array(SectionSummarySchema).min(1),
   totals: TotalsSchema,
-  freeze_receipt_sha256: z23.string().regex(/^[a-f0-9]{64}$/, "Must be a 64-char hex sha256"),
-  operator_notes: z23.string().default("")
+  freeze_receipt_sha256: z24.string().regex(/^[a-f0-9]{64}$/, "Must be a 64-char hex sha256"),
+  operator_notes: z24.string().default("")
 });
 
 // src/pack/publish/manifest.ts
 init_src();
-var GateResultMinimalSchema = z24.object({
-  verdict: z24.enum(["pass", "warn", "fail", "blocked"]),
-  synthesis_eligible: z24.boolean()
+var GateResultMinimalSchema = z25.object({
+  verdict: z25.enum(["pass", "warn", "fail", "blocked"]),
+  synthesis_eligible: z25.boolean()
 });
-var ClaimIdOnlySchema = z24.object({ claim_id: z24.string() });
+var ClaimIdOnlySchema = z25.object({ claim_id: z25.string() });
 function sha256Bytes(buf) {
   return createHash11("sha256").update(buf).digest("hex");
 }
@@ -13420,62 +13476,64 @@ import { readFile as readFile26 } from "fs/promises";
 import { join as join34 } from "path";
 
 // src/calibration/receipt-schema.ts
-import { z as z25 } from "zod";
-var StatusLabelSchema = z25.enum([
+init_reviewer_options_schema();
+import { z as z26 } from "zod";
+var StatusLabelSchema = z26.enum([
   "trusted_baseline",
   "conditional_pass",
   "failed",
   "comparison_only"
 ]);
-var ArchitectureSchema = z25.enum(["single-pass", "two-pass"]);
-var RecallSchema = z25.object({
-  matched: z25.number().int().nonnegative(),
-  total: z25.number().int().nonnegative(),
-  ratio: z25.number().min(0).max(1)
-});
-var PerCategoryRecallSchema = z25.record(z25.string(), RecallSchema);
-var PassFailSchema = z25.object({
-  fp_ceiling: z25.enum(["PASS", "FAIL"]),
-  any_flag_recall_floor: z25.enum(["PASS", "FAIL"]),
-  per_category_any_flag_floor: z25.enum(["PASS", "FAIL"]),
-  strict_recall_floor: z25.enum(["PASS", "FAIL"]),
-  decision_vocab_completeness: z25.enum(["PASS", "FAIL"]),
-  latency_soft: z25.enum(["PASS", "WARN"]),
-  latency_hard: z25.enum(["PASS", "FAIL"]),
-  empty_or_malformed: z25.enum(["PASS", "FAIL"]),
-  overall: z25.enum(["PASS", "FAIL"])
-});
-var DecisionVocabBarSchema = z25.object({
+var ArchitectureSchema = z26.enum(["single-pass", "two-pass"]);
+var RecallSchema = z26.object({
+  matched: z26.number().int().nonnegative(),
+  total: z26.number().int().nonnegative(),
+  ratio: z26.number().min(0).max(1)
+});
+var PerCategoryRecallSchema = z26.record(z26.string(), RecallSchema);
+var PassFailSchema = z26.object({
+  fp_ceiling: z26.enum(["PASS", "FAIL"]),
+  any_flag_recall_floor: z26.enum(["PASS", "FAIL"]),
+  per_category_any_flag_floor: z26.enum(["PASS", "FAIL"]),
+  strict_recall_floor: z26.enum(["PASS", "FAIL"]),
+  decision_vocab_completeness: z26.enum(["PASS", "FAIL"]),
+  latency_soft: z26.enum(["PASS", "WARN"]),
+  latency_hard: z26.enum(["PASS", "FAIL"]),
+  empty_or_malformed: z26.enum(["PASS", "FAIL"]),
+  overall: z26.enum(["PASS", "FAIL"])
+});
+var DecisionVocabBarSchema = z26.object({
   architecture: ArchitectureSchema,
-  required: z25.number().int().positive(),
-  produced: z25.number().int().nonnegative(),
-  passed: z25.boolean()
+  required: z26.number().int().positive(),
+  produced: z26.number().int().nonnegative(),
+  passed: z26.boolean()
 });
-var CalibrationReceiptSchema = z25.object({
-  schema_version: z25.literal(1),
-  profile_name: z25.string(),
+var CalibrationReceiptSchema = z26.object({
+  schema_version: z26.literal(1),
+  profile_name: z26.string(),
   status: StatusLabelSchema,
-  model: z25.string(),
+  model: z26.string(),
   architecture: ArchitectureSchema,
-  fixture: z25.string(),
-  fixture_total_claims: z25.number().int().positive(),
-  fixture_good_claims: z25.number().int().nonnegative(),
-  fixture_bad_claims: z25.number().int().nonnegative(),
-  calibrated_at: z25.string(),
-  research_os_version: z25.string(),
-  runtime_ms: z25.number().int().nonnegative(),
-  good_fp_count: z25.number().int().nonnegative(),
+  fixture: z26.string(),
+  fixture_total_claims: z26.number().int().positive(),
+  fixture_good_claims: z26.number().int().nonnegative(),
+  fixture_bad_claims: z26.number().int().nonnegative(),
+  calibrated_at: z26.string(),
+  research_os_version: z26.string(),
+  runtime_ms: z26.number().int().nonnegative(),
+  good_fp_count: z26.number().int().nonnegative(),
   any_flag_recall: RecallSchema,
   strict_recall: RecallSchema,
   per_category_any_flag: PerCategoryRecallSchema,
   per_category_strict: PerCategoryRecallSchema,
-  decision_vocabulary: z25.record(z25.string(), z25.number().int().nonnegative()),
-  decisions_produced_count: z25.number().int().nonnegative(),
+  decision_vocabulary: z26.record(z26.string(), z26.number().int().nonnegative()),
+  decisions_produced_count: z26.number().int().nonnegative(),
   decision_vocab_bar: DecisionVocabBarSchema,
-  unreachable_decisions: z25.array(z25.string()),
-  empty_or_malformed_responses: z25.number().int().nonnegative(),
+  unreachable_decisions: z26.array(z26.string()),
+  empty_or_malformed_responses: z26.number().int().nonnegative(),
   pass_fail: PassFailSchema,
-  notes: z25.array(z25.string())
+  notes: z26.array(z26.string()),
+  reviewer_options: ReviewerOptionsSchema.optional()
 });
 
 // src/calibration/receipt.ts
@@ -14136,22 +14194,26 @@ program.command("review").description("Run the adversarial reviewer pass; emits
     const criticModel = opts.criticModel ?? baseModel ?? preset?.critic_model ?? void 0;
     const reviewWindow = opts.reviewWindow ?? preset?.review_window ?? void 0;
     const twoPass = Boolean(opts.twoPassLlm) || (preset?.mode === "two_pass" ? true : false);
+    const reviewerOptions = preset?.reviewer_options ?? void 0;
     const reviewers = opts.heuristicOnly ? [new HeuristicReviewer()] : twoPass ? [
       new OllamaInternReviewer({
         mode: "general",
         model: generalModel ?? void 0,
-        claimsPerWindow: reviewWindow
+        claimsPerWindow: reviewWindow,
+        reviewer_options: reviewerOptions
       }),
       new OllamaInternReviewer({
         mode: "narrow_critic",
         model: criticModel ?? void 0,
-        claimsPerWindow: reviewWindow
+        claimsPerWindow: reviewWindow,
+        reviewer_options: reviewerOptions
       }),
       new HeuristicReviewer()
     ] : reviewWindow || opts.llmPaged || baseModel || generalModel ? [
       new OllamaInternReviewer({
         model: generalModel ?? void 0,
-        claimsPerWindow: reviewWindow
+        claimsPerWindow: reviewWindow,
+        reviewer_options: reviewerOptions
       }),
       new HeuristicReviewer()
     ] : void 0;
@@ -14161,7 +14223,8 @@ program.command("review").description("Run the adversarial reviewer pass; emits
       reviewers,
       triagedOnly: opts.triagedOnly,
       multiPass: twoPass,
-      profile: opts.profile
+      profile: opts.profile,
+      reviewer_options: reviewerOptions
     });
     process.stdout.write(`review complete
 `);