@mcptoolshop/research-os 0.3.2 → 0.4.0

package/dist/index.js

@@ -999,17 +999,244 @@ var init_schema3 = __esm({
       scope: z3.string().nullable(),
       not: z3.string().nullable(),
       extracted_by: ExtractorNameSchema,
-      extracted_at: z3.string()
+      extracted_at: z3.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(),
+      /** 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()
     });
   }
 });
 
+// src/sources/canonical-vendors.ts
+var CANONICAL_VENDORS;
+var init_canonical_vendors = __esm({
+  "src/sources/canonical-vendors.ts"() {
+    "use strict";
+    CANONICAL_VENDORS = [
+      // ── Protocol-foundation vendors → primary ────────────────────────────────
+      {
+        slug: "xrpl-foundation",
+        hosts: ["xrpl.org", "xls.xrpl.org"],
+        github_orgs: ["XRPLF"],
+        source_type: "primary",
+        description: "XRPL Foundation \u2014 canonical authority for the XRPL protocol + XLS standards."
+      },
+      {
+        slug: "ipfs-foundation",
+        hosts: ["docs.ipfs.tech", "ipfs.tech"],
+        source_type: "primary",
+        description: "IPFS protocol canonical surface."
+      },
+      {
+        slug: "arweave",
+        hosts: ["docs.arweave.org", "arweave.org"],
+        source_type: "primary",
+        description: "Arweave protocol canonical surface."
+      },
+      {
+        slug: "anthropic",
+        hosts: ["docs.anthropic.com", "anthropic.com", "claude.com"],
+        source_type: "primary",
+        description: "Claude API + Anthropic models \u2014 vendor owns the API surface. Resolves F-47: docs.anthropic.com is primary, not docs."
+      },
+      // ── Platform/engine vendors → docs ───────────────────────────────────────
+      {
+        slug: "godot-foundation",
+        hosts: ["docs.godotengine.org", "godotengine.org"],
+        github_orgs: ["godotengine"],
+        source_type: "docs",
+        description: "Godot engine docs. NB: api.github.com/repos/godotengine/godot/releases matches L4 as canonical-releases \u2192 primary."
+      },
+      {
+        slug: "apple",
+        hosts: ["developer.apple.com", "docs.developer.apple.com"],
+        source_type: "docs",
+        description: "Apple platform docs. developer.apple.com/documentation/* is JS-shell (F-42); docs.developer.apple.com/tutorials/data/*.md is the text-stable alternate."
+      },
+      {
+        slug: "microsoft",
+        hosts: ["learn.microsoft.com"],
+        github_orgs: ["MicrosoftDocs"],
+        source_type: "docs",
+        description: "MS Learn + MicrosoftDocs raw GitHub."
+      },
+      {
+        slug: "mozilla",
+        hosts: ["developer.mozilla.org"],
+        source_type: "docs",
+        description: "MDN web platform docs."
+      },
+      {
+        slug: "google-android",
+        hosts: ["developer.android.com"],
+        source_type: "docs",
+        description: "Android platform docs."
+      },
+      {
+        slug: "google-play",
+        hosts: [],
+        hostPaths: ["support.google.com/googleplay"],
+        source_type: "docs",
+        description: "Play Store policy/help docs. Matched on host+path-prefix to avoid classifying all of support.google.com as docs."
+      },
+      {
+        slug: "itch-io",
+        hosts: [],
+        hostPaths: ["itch.io/docs"],
+        source_type: "docs",
+        description: "itch.io creator docs (not storefront chrome). Matched on host+path-prefix so itch.io/<creator>/<game> does not match L3."
+      }
+    ];
+  }
+});
+
+// src/sources/source-type-classifier.ts
+import { URL as URL4 } from "url";
+function classifySourceType(input) {
+  let parsed;
+  try {
+    parsed = new URL4(input.url);
+  } catch {
+    return { source_type: "unknown", rule_hint: "no-rule-match", precedence_level: 6 };
+  }
+  const host = parsed.hostname.toLowerCase();
+  const pathname = parsed.pathname;
+  if (host === "github.com" && /^\/[^/]+\/[^/]+/.test(pathname)) {
+    return { source_type: "unknown", rule_hint: "flagged:github-ui-html", precedence_level: 2 };
+  }
+  for (const vendor of CANONICAL_VENDORS) {
+    if (vendor.hosts.includes(host)) {
+      return {
+        source_type: vendor.source_type,
+        rule_hint: `canonical-vendor:${vendor.slug}`,
+        precedence_level: 3
+      };
+    }
+    for (const hp of vendor.hostPaths ?? []) {
+      const slashIdx = hp.indexOf("/");
+      const hpHost = slashIdx === -1 ? hp : hp.slice(0, slashIdx);
+      const hpPath = slashIdx === -1 ? "" : "/" + hp.slice(slashIdx + 1);
+      if (host === hpHost && (hpPath === "" || pathname === hpPath || pathname.startsWith(hpPath + "/"))) {
+        return {
+          source_type: vendor.source_type,
+          rule_hint: `canonical-vendor:${vendor.slug}`,
+          precedence_level: 3
+        };
+      }
+    }
+  }
+  if (host === "api.github.com") {
+    if (pathname.startsWith("/search/issues")) {
+      return { source_type: "forum", rule_hint: "github-api:search-issues", precedence_level: 4 };
+    }
+    const releasesMatch = pathname.match(/^\/repos\/([^/]+)\/([^/]+)\/releases(?:\/|$|\?)/);
+    if (releasesMatch) {
+      const org = releasesMatch[1].toLowerCase();
+      if (CANONICAL_GITHUB_ORGS.has(org)) {
+        return {
+          source_type: "primary",
+          rule_hint: "github-api:canonical-releases",
+          precedence_level: 4
+        };
+      }
+      return {
+        source_type: "secondary",
+        rule_hint: "github-api:releases-noncanonical",
+        precedence_level: 4
+      };
+    }
+    if (pathname.match(/^\/repos\/[^/]+\/[^/]+\/issues\/\d+(?:\/|$|\?)/)) {
+      return { source_type: "forum", rule_hint: "github-api:issue-thread", precedence_level: 4 };
+    }
+    if (pathname.match(/^\/repos\/[^/]+\/[^/]+\/issues(?:\/|$|\?)/)) {
+      return { source_type: "forum", rule_hint: "github-api:issues-list", precedence_level: 4 };
+    }
+    if (pathname.match(/^\/repos\/[^/]+\/[^/]+\/tags(?:\/|$|\?)/)) {
+      return { source_type: "secondary", rule_hint: "github-api:tags", precedence_level: 4 };
+    }
+  }
+  if (host === "raw.githubusercontent.com") {
+    const rawMatch = pathname.match(/^\/([^/]+)\/([^/]+)\/([^/]+)\/(.*)/);
+    if (rawMatch) {
+      const [, org, repo, , filePath] = rawMatch;
+      const isCanonicalOrg = CANONICAL_GITHUB_ORGS.has(org.toLowerCase());
+      const isDocsShapedRepo = /-docs$/.test(repo) || /-documentation$/.test(repo);
+      const isDocFile = /\.(rst|md)$/i.test(filePath);
+      if (isDocFile && (isCanonicalOrg || isDocsShapedRepo)) {
+        return {
+          source_type: "docs",
+          rule_hint: "raw-github:project-docs",
+          precedence_level: 5
+        };
+      }
+      if (/(?:^|\/)README\.md$/i.test(filePath)) {
+        return {
+          source_type: "secondary",
+          rule_hint: "raw-github:plugin-readme",
+          precedence_level: 5
+        };
+      }
+      return { source_type: "secondary", rule_hint: "raw-github:other", precedence_level: 5 };
+    }
+    return { source_type: "secondary", rule_hint: "raw-github:other", precedence_level: 5 };
+  }
+  if (host.startsWith("docs.")) {
+    return {
+      source_type: "docs",
+      rule_hint: "fallback:docs-host-prefix",
+      precedence_level: 6
+    };
+  }
+  const KNOWN_FORUM_HOSTS = ["stackoverflow.com", "reddit.com", "news.ycombinator.com"];
+  if (KNOWN_FORUM_HOSTS.some((fh) => host === fh || host.endsWith("." + fh))) {
+    return { source_type: "forum", rule_hint: "fallback:known-forum", precedence_level: 6 };
+  }
+  return { source_type: "unknown", rule_hint: "no-rule-match", precedence_level: 6 };
+}
+var CANONICAL_GITHUB_ORGS;
+var init_source_type_classifier = __esm({
+  "src/sources/source-type-classifier.ts"() {
+    "use strict";
+    init_canonical_vendors();
+    CANONICAL_GITHUB_ORGS = new Set(
+      CANONICAL_VENDORS.flatMap((v) => (v.github_orgs ?? []).map((o) => o.toLowerCase()))
+    );
+  }
+});
+
+// src/sources/effective-card.ts
+function getEffectiveSourceType(card, overrides) {
+  const matched = overrides.filter((o) => o.source_id === card.source_id && o.new_source_type != null).sort((a, b) => a.created_at > b.created_at ? -1 : a.created_at < b.created_at ? 1 : 0);
+  return matched.length > 0 ? matched[0].new_source_type : card.source_type;
+}
+function getEffectivePublisher(card, overrides) {
+  const matched = overrides.filter((o) => o.source_id === card.source_id && o.new_publisher !== void 0).sort((a, b) => a.created_at > b.created_at ? -1 : a.created_at < b.created_at ? 1 : 0);
+  if (matched.length === 0) return card.publisher;
+  return matched[0].new_publisher ?? null;
+}
+var init_effective_card = __esm({
+  "src/sources/effective-card.ts"() {
+    "use strict";
+  }
+});
+
 // src/sources/cards.ts
 import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4, appendFile } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
 import { join as join4 } from "path";
 function buildCard(args) {
   const { receipt, extraction, extractedBy } = args;
+  const overrides = args.overrides ?? [];
+  const classification = classifySourceType({ url: receipt.requested_url });
+  const classifiedSourceType = classification.rule_hint === "no-rule-match" ? extraction.source_type : classification.source_type;
+  const baseForEffective = {
+    source_id: receipt.source_id,
+    source_type: classifiedSourceType,
+    publisher: extraction.publisher
+  };
+  const resolvedSourceType = getEffectiveSourceType(baseForEffective, overrides);
+  const resolvedPublisher = getEffectivePublisher(baseForEffective, overrides);
   const card = SourceCardSchema.parse({
     source_id: receipt.source_id,
     receipt_id: receipt.receipt_id,
@@ -1017,10 +1244,10 @@ function buildCard(args) {
     url: receipt.requested_url,
     final_url: receipt.final_url,
     fetched_at: receipt.fetched_at,
-    publisher: extraction.publisher,
+    publisher: resolvedPublisher,
     published_at: extraction.published_at,
     title: extraction.title,
-    source_type: extraction.source_type,
+    source_type: resolvedSourceType,
     relevance: extraction.relevance,
     key_points: extraction.key_points,
     limitations: extraction.limitations,
@@ -1028,7 +1255,9 @@ function buildCard(args) {
     scope: extraction.scope,
     not: extraction.not,
     extracted_by: extractedBy,
-    extracted_at: (/* @__PURE__ */ new Date()).toISOString()
+    extracted_at: (/* @__PURE__ */ new Date()).toISOString(),
+    rule_hint: classification.rule_hint,
+    precedence_level: classification.precedence_level
   });
   return card;
 }
@@ -1065,21 +1294,106 @@ var init_cards = __esm({
   "src/sources/cards.ts"() {
     "use strict";
     init_schema3();
+    init_source_type_classifier();
+    init_effective_card();
   }
 });
 
-// src/sources/gather.ts
+// src/sources/source-card-overrides-schema.ts
+import { z as z4 } from "zod";
+function validateSourceCardOverride(input) {
+  return SourceCardOverrideSchema.parse(input);
+}
+var SourceCardOverrideSchema;
+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(),
+      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)), {
+        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")
+    }).refine(
+      (obj) => obj.new_source_type != null && obj.new_source_type !== void 0 || obj.new_publisher != null && obj.new_publisher !== void 0,
+      {
+        message: "At least one of new_source_type or new_publisher must be present and non-null"
+      }
+    );
+  }
+});
+
+// src/sources/source-card-overrides.ts
+import { readFile as readFile5, appendFile as appendFile2, mkdir as mkdir5 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import { join as join5, resolve as resolve3 } from "path";
+import { join as join5, dirname as dirname2 } from "path";
+function overridesPath(packPath) {
+  return join5(packPath, "evidence", OVERRIDES_FILE);
+}
+async function readOverrides(packPath) {
+  const filePath = overridesPath(packPath);
+  if (!existsSync4(filePath)) return [];
+  const content = await readFile5(filePath, "utf8");
+  const lines = content.split(/\r?\n/).filter(Boolean);
+  return lines.map((line, idx) => {
+    const lineNum = idx + 1;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      throw new Error(
+        `source-card-overrides.jsonl: malformed JSON at line ${lineNum}: ${line.slice(0, 120)}`
+      );
+    }
+    try {
+      return validateSourceCardOverride(parsed);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `source-card-overrides.jsonl: invalid override at line ${lineNum}: ${msg}
+  Content: ${line.slice(0, 120)}`,
+        { cause: err }
+      );
+    }
+  });
+}
+async function appendOverride(packPath, override) {
+  validateSourceCardOverride(override);
+  const filePath = overridesPath(packPath);
+  await mkdir5(dirname2(filePath), { recursive: true });
+  await appendFile2(filePath, JSON.stringify(override) + "\n", "utf8");
+}
+var OVERRIDES_FILE;
+var init_source_card_overrides = __esm({
+  "src/sources/source-card-overrides.ts"() {
+    "use strict";
+    init_source_card_overrides_schema();
+    OVERRIDES_FILE = "source-card-overrides.jsonl";
+  }
+});
+
+// src/sources/gather.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join6, resolve as resolve3 } from "path";
 async function gather(options) {
   const packPath = options.packPath ? resolve3(options.packPath) : process.cwd();
-  if (!existsSync4(join5(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
-  if (!existsSync4(join5(packPath, "sections", options.sectionId)))
+  if (!existsSync5(join6(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
+  if (!existsSync5(join6(packPath, "sections", options.sectionId)))
     throw new SectionNotFoundError(options.sectionId);
   const { urls } = await collectUrls({ urls: options.urls, urlsFile: options.urlsFile });
   if (urls.length === 0) throw new NoUrlsProvidedError();
   const extractorList = options.extractors ?? defaultExtractors();
   const extractor = await pickExtractor(extractorList);
+  const overrides = await readOverrides(packPath);
   const summary = {
     sectionId: options.sectionId,
     attempted: urls.length,
@@ -1114,7 +1428,7 @@ async function gather(options) {
           extraction_extractor: extractor.name,
           extraction_error: null
         };
-        const card = buildCard({ receipt: receiptToWrite, extraction: result, extractedBy: extractor.name });
+        const card = buildCard({ receipt: receiptToWrite, extraction: result, extractedBy: extractor.name, overrides });
         await writeSourceCard(packPath, card);
         await appendSectionSourceId(packPath, options.sectionId, card.source_id);
         summary.cardsWritten += 1;
@@ -1144,27 +1458,28 @@ var init_gather = __esm({
     init_url_input();
     init_extractors();
     init_cards();
+    init_source_card_overrides();
   }
 });
 
 // src/sources/excerpts/schema.ts
-import { z as z4 } from "zod";
+import { z as z5 } 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 = z4.enum(["raw_text", "key_point"]);
-    ExcerptSchema = z4.object({
-      excerpt_id: z4.string().regex(EXCERPT_ID_PATTERN),
-      source_id: z4.string().regex(/^src_[a-f0-9]{12}$/),
-      source_hash: z4.string().regex(/^[a-f0-9]{64}$/).nullable(),
-      text: z4.string().min(1),
-      location_hint: z4.string().nullable(),
-      char_start: z4.number().int().nonnegative(),
-      char_end: z4.number().int().nonnegative(),
+    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(),
       origin: ExcerptOriginSchema,
-      created_at: z4.string()
+      created_at: z5.string()
     });
   }
 });
@@ -1293,11 +1608,11 @@ var init_chunk = __esm({
 });
 
 // src/sources/excerpts/ledger.ts
-import { existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname2, join as join6 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname3, join as join7 } from "path";
 function ledgerPathFor(packPath, sourceId) {
-  return join6(packPath, "evidence", "excerpts", `${sourceId}.jsonl`);
+  return join7(packPath, "evidence", "excerpts", `${sourceId}.jsonl`);
 }
 function makeExcerptId(sourceId, index) {
   const idx = String(index).padStart(3, "0");
@@ -1305,7 +1620,7 @@ function makeExcerptId(sourceId, index) {
   return `ex_${hex}_${idx}`;
 }
 async function readLedger(path) {
-  const text = await readFile5(path, "utf8");
+  const text = await readFile6(path, "utf8");
   const out = [];
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -1317,7 +1632,7 @@ async function readLedger(path) {
   return out;
 }
 async function writeLedger(path, excerpts) {
-  await mkdir5(dirname2(path), { recursive: true });
+  await mkdir6(dirname3(path), { recursive: true });
   const body = excerpts.map((e) => JSON.stringify(e)).join("\n") + (excerpts.length > 0 ? "\n" : "");
   await writeFile5(path, body, "utf8");
 }
@@ -1325,7 +1640,7 @@ async function loadOrBuildLedger(args) {
   const { packPath, sourceCard, sourceHash, rawText } = args;
   const now = args.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const path = ledgerPathFor(packPath, sourceCard.source_id);
-  if (existsSync5(path)) {
+  if (existsSync6(path)) {
     const excerpts2 = await readLedger(path);
     if (excerpts2.length > 0) {
       const origins = new Set(excerpts2.map((e) => e.origin));
@@ -1394,6 +1709,9 @@ var init_sources = __esm({
     init_extractors();
     init_ollama_intern();
     init_cards();
+    init_source_card_overrides();
+    init_source_card_overrides_schema();
+    init_effective_card();
     init_schema3();
     init_excerpts();
   }
@@ -1704,50 +2022,50 @@ var init_extractors2 = __esm({
 });
 
 // src/claims/schema.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var ConfidenceSchema, ClaimExtractorSchema, ReviewStateSchema, ClaimSchema;
 var init_schema5 = __esm({
   "src/claims/schema.ts"() {
     "use strict";
     init_schema4();
-    ConfidenceSchema = z5.enum(["low", "medium", "high"]);
-    ClaimExtractorSchema = z5.enum(["heuristic", "ollama-intern"]);
-    ReviewStateSchema = z5.enum([
+    ConfidenceSchema = z6.enum(["low", "medium", "high"]);
+    ClaimExtractorSchema = z6.enum(["heuristic", "ollama-intern"]);
+    ReviewStateSchema = z6.enum([
       "candidate",
       "gated",
       "reviewed",
       "rejected",
       "accepted"
     ]);
-    ClaimSchema = z5.object({
-      claim_id: z5.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/),
-      section_id: z5.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      source_ids: z5.array(z5.string().regex(/^src_[a-f0-9]{12}$/)).min(1, "every claim must reference at least one source_id"),
-      source_hashes: z5.array(z5.string().regex(/^[a-f0-9]{64}$/)),
-      asserts: z5.string().min(1),
-      scope: z5.string().nullable(),
-      not: z5.string().nullable(),
+    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(),
       // 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: z5.array(z5.string().regex(EXCERPT_ID_PATTERN)).default([]),
-      evidence_excerpt: z5.string().min(1),
-      evidence_location: z5.string().nullable(),
+      evidence_excerpt_ids: z6.array(z6.string().regex(EXCERPT_ID_PATTERN)).default([]),
+      evidence_excerpt: z6.string().min(1),
+      evidence_location: z6.string().nullable(),
       confidence: ConfidenceSchema,
       extractor: ClaimExtractorSchema,
-      extraction_method: z5.string().min(1),
-      created_at: z5.string(),
+      extraction_method: z6.string().min(1),
+      created_at: z6.string(),
       review_state: ReviewStateSchema
     });
   }
 });
 
 // src/claims/extract.ts
-import { existsSync as existsSync6 } from "fs";
-import { appendFile as appendFile2, mkdir as mkdir6, readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
-import { join as join7, resolve as resolve4 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { appendFile as appendFile3, mkdir as mkdir7, readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
+import { join as join8, resolve as resolve4 } from "path";
 function normalize2(text) {
   return text.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").toLowerCase().trim();
 }
@@ -1758,9 +2076,9 @@ function evidenceGrounded(excerpt, rawText) {
   return normalize2(rawText).includes(e);
 }
 async function readSectionSourceIds(packPath, sectionId) {
-  const path = join7(packPath, "sections", sectionId, "sources.jsonl");
-  if (!existsSync6(path)) return [];
-  const text = await readFile6(path, "utf8");
+  const path = join8(packPath, "sections", sectionId, "sources.jsonl");
+  if (!existsSync7(path)) return [];
+  const text = await readFile7(path, "utf8");
   const ids = [];
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -1773,15 +2091,15 @@ async function readSectionSourceIds(packPath, sectionId) {
   return ids;
 }
 async function readSourceCard(packPath, sourceId) {
-  const path = join7(packPath, "evidence", "source-cards", `${sourceId}.json`);
-  if (!existsSync6(path)) return null;
-  const text = await readFile6(path, "utf8");
+  const path = join8(packPath, "evidence", "source-cards", `${sourceId}.json`);
+  if (!existsSync7(path)) return null;
+  const text = await readFile7(path, "utf8");
   return SourceCardSchema.parse(JSON.parse(text));
 }
 async function findLatestReceipt(packPath, sourceId) {
-  const path = join7(packPath, "evidence", "fetch-log.jsonl");
-  if (!existsSync6(path)) return null;
-  const text = await readFile6(path, "utf8");
+  const path = join8(packPath, "evidence", "fetch-log.jsonl");
+  if (!existsSync7(path)) return null;
+  const text = await readFile7(path, "utf8");
   let latest = null;
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -1796,9 +2114,9 @@ async function findLatestReceipt(packPath, sourceId) {
   return latest;
 }
 async function readExistingClaimIds(packPath, sectionId) {
-  const path = join7(packPath, "sections", sectionId, "claims.jsonl");
-  if (!existsSync6(path)) return /* @__PURE__ */ new Set();
-  const text = await readFile6(path, "utf8");
+  const path = join8(packPath, "sections", sectionId, "claims.jsonl");
+  if (!existsSync7(path)) return /* @__PURE__ */ new Set();
+  const text = await readFile7(path, "utf8");
   const set = /* @__PURE__ */ new Set();
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -1873,14 +2191,14 @@ function buildClaim(args) {
 }
 async function extract(options) {
   const packPath = options.packPath ? resolve4(options.packPath) : process.cwd();
-  if (!existsSync6(join7(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
-  if (!existsSync6(join7(packPath, "sections", options.sectionId)))
+  if (!existsSync7(join8(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
+  if (!existsSync7(join8(packPath, "sections", options.sectionId)))
     throw new SectionNotFoundError(options.sectionId);
   const sourceIds = await readSectionSourceIds(packPath, options.sectionId);
   if (sourceIds.length === 0) throw new NoSourcesGatheredError(options.sectionId);
   const adapters = options.extractors ?? defaultClaimExtractors();
   const extractor = await pickClaimExtractor(adapters);
-  const claimsPath = join7(packPath, "sections", options.sectionId, "claims.jsonl");
+  const claimsPath = join8(packPath, "sections", options.sectionId, "claims.jsonl");
   const existingIds = await readExistingClaimIds(packPath, options.sectionId);
   const summary = {
     sectionId: options.sectionId,
@@ -1909,9 +2227,9 @@ async function extract(options) {
     const receipt2 = await findLatestReceipt(packPath, sourceId);
     let rawText = null;
     if (receipt2?.raw_text_path) {
-      const raw = join7(packPath, receipt2.raw_text_path);
-      if (existsSync6(raw)) {
-        rawText = await readFile6(raw, "utf8");
+      const raw = join8(packPath, receipt2.raw_text_path);
+      if (existsSync7(raw)) {
+        rawText = await readFile7(raw, "utf8");
       }
     }
     const ledger = await loadOrBuildLedger({
@@ -1967,7 +2285,7 @@ async function extract(options) {
         summary.claimsDeduped += 1;
         continue;
       }
-      await appendFile2(claimsPath, JSON.stringify(claim) + "\n", "utf8");
+      await appendFile3(claimsPath, JSON.stringify(claim) + "\n", "utf8");
       existingIds.add(claim.claim_id);
       summary.claimsAdded += 1;
       summary.claimIds.push(claim.claim_id);
@@ -1996,10 +2314,10 @@ async function extract(options) {
       kind: /not valid JSON/i.test(f.reason) ? "extractor_invalid_json" : /aborted|timeout/i.test(f.reason) ? "extractor_timeout" : /HTTP \d{3}/i.test(f.reason) ? "extractor_http_error" : "extractor_other"
     }))
   };
-  const auditsDir = join7(packPath, "audits");
-  await mkdir6(auditsDir, { recursive: true });
+  const auditsDir = join8(packPath, "audits");
+  await mkdir7(auditsDir, { recursive: true });
   await writeFile6(
-    join7(auditsDir, `${options.sectionId}-claim-extract.json`),
+    join8(auditsDir, `${options.sectionId}-claim-extract.json`),
     JSON.stringify(receipt, null, 2),
     "utf8"
   );
@@ -2026,61 +2344,61 @@ var init_extract = __esm({
 });
 
 // src/claims/density/schema.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var PerSourceDensitySchema, NearDuplicateClusterSchema, DensityFlagSchema, ClaimDensityAuditSchema;
 var init_schema6 = __esm({
   "src/claims/density/schema.ts"() {
     "use strict";
-    PerSourceDensitySchema = z6.object({
-      source_id: z6.string().regex(/^src_[a-f0-9]{12}$/),
-      publisher: z6.string().nullable(),
-      source_word_count: z6.number().int().nonnegative(),
-      claim_count: z6.number().int().nonnegative(),
-      claims_per_1k_words: z6.number(),
-      share_of_section: z6.number(),
+    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(),
       // 0..1
-      weak_scope_count: z6.number().int().nonnegative(),
-      generic_scope_count: z6.number().int().nonnegative()
+      weak_scope_count: z7.number().int().nonnegative(),
+      generic_scope_count: z7.number().int().nonnegative()
     });
-    NearDuplicateClusterSchema = z6.object({
-      representative_assert: z6.string(),
-      member_count: z6.number().int().nonnegative(),
-      claim_ids: z6.array(z6.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/))
+    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+$/))
     });
-    DensityFlagSchema = z6.object({
-      type: z6.enum([
+    DensityFlagSchema = z7.object({
+      type: z7.enum([
         "source_dominance",
         "high_per_word_density",
         "large_near_duplicate_cluster",
         "weak_scope_majority"
       ]),
-      severity: z6.enum(["info", "warn", "block"]),
-      message: z6.string(),
-      affects_source_ids: z6.array(z6.string().regex(/^src_[a-f0-9]{12}$/)).default([]),
-      affects_claim_ids: z6.array(z6.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/)).default([])
+      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([])
     });
-    ClaimDensityAuditSchema = z6.object({
-      audit_id: z6.string().regex(/^cda_[0-9]+_[a-z0-9-]+$/),
-      section_id: z6.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      audited_at: z6.string(),
-      research_os_version: z6.string(),
-      candidate_claim_count: z6.number().int().nonnegative(),
-      source_count: z6.number().int().nonnegative(),
-      total_source_word_count: z6.number().int().nonnegative(),
-      claims_per_1k_words: z6.number(),
-      weak_scope_count: z6.number().int().nonnegative(),
-      generic_scope_count: z6.number().int().nonnegative(),
-      per_source: z6.array(PerSourceDensitySchema),
-      near_duplicate_clusters: z6.array(NearDuplicateClusterSchema),
-      flags: z6.array(DensityFlagSchema)
+    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)
     });
   }
 });
 
 // src/claims/density/run.ts
-import { existsSync as existsSync7 } from "fs";
-import { mkdir as mkdir7, readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
-import { join as join8, resolve as resolve5 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { mkdir as mkdir8, readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
+import { join as join9, resolve as resolve5 } from "path";
 function normalize3(s) {
   return s.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").toLowerCase().replace(/[^a-z0-9 ]+/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -2089,9 +2407,9 @@ function countWords(text) {
   return normalize3(text).split(" ").filter((w) => w.length > 0).length;
 }
 async function readClaims(packPath, sectionId) {
-  const path = join8(packPath, "sections", sectionId, "claims.jsonl");
-  if (!existsSync7(path)) return [];
-  const text = await readFile7(path, "utf8");
+  const path = join9(packPath, "sections", sectionId, "claims.jsonl");
+  if (!existsSync8(path)) return [];
+  const text = await readFile8(path, "utf8");
   const out = [];
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -2105,10 +2423,10 @@ async function readClaims(packPath, sectionId) {
 async function readSourceCards(packPath, sourceIds) {
   const out = /* @__PURE__ */ new Map();
   for (const sid of sourceIds) {
-    const p = join8(packPath, "evidence", "source-cards", `${sid}.json`);
-    if (!existsSync7(p)) continue;
+    const p = join9(packPath, "evidence", "source-cards", `${sid}.json`);
+    if (!existsSync8(p)) continue;
     try {
-      out.set(sid, SourceCardSchema.parse(JSON.parse(await readFile7(p, "utf8"))));
+      out.set(sid, SourceCardSchema.parse(JSON.parse(await readFile8(p, "utf8"))));
     } catch {
     }
   }
@@ -2116,9 +2434,9 @@ async function readSourceCards(packPath, sourceIds) {
 }
 async function readLatestReceipts(packPath) {
   const out = /* @__PURE__ */ new Map();
-  const path = join8(packPath, "evidence", "fetch-log.jsonl");
-  if (!existsSync7(path)) return out;
-  const text = await readFile7(path, "utf8");
+  const path = join9(packPath, "evidence", "fetch-log.jsonl");
+  if (!existsSync8(path)) return out;
+  const text = await readFile8(path, "utf8");
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
     try {
@@ -2133,9 +2451,9 @@ async function readLatestReceipts(packPath) {
 }
 async function readRawText(packPath, receipt) {
   if (!receipt.raw_text_path) return null;
-  const p = join8(packPath, receipt.raw_text_path);
-  if (!existsSync7(p)) return null;
-  return await readFile7(p, "utf8");
+  const p = join9(packPath, receipt.raw_text_path);
+  if (!existsSync8(p)) return null;
+  return await readFile8(p, "utf8");
 }
 function isWeakScope(claim) {
   return claim.scope === null && claim.not === null && claim.asserts.length > 40;
@@ -2268,8 +2586,8 @@ function buildMarkdown(audit2) {
 }
 async function auditDensity(options) {
   const packPath = options.packPath ? resolve5(options.packPath) : process.cwd();
-  if (!existsSync7(join8(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
-  if (!existsSync7(join8(packPath, "sections", options.sectionId)))
+  if (!existsSync8(join9(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
+  if (!existsSync8(join9(packPath, "sections", options.sectionId)))
     throw new SectionNotFoundError(options.sectionId);
   const claims = await readClaims(packPath, options.sectionId);
   const allSourceIds = Array.from(
@@ -2342,10 +2660,10 @@ async function auditDensity(options) {
   }));
   const flags = [...buildFlags(partial), ...clusterFlags];
   const audit2 = ClaimDensityAuditSchema.parse({ ...partial, flags });
-  const auditsDir = join8(packPath, "audits");
-  await mkdir7(auditsDir, { recursive: true });
-  const jsonPath = join8(auditsDir, `${options.sectionId}-claim-density.json`);
-  const markdownPath = join8(auditsDir, `${options.sectionId}-claim-density.md`);
+  const auditsDir = join9(packPath, "audits");
+  await mkdir8(auditsDir, { recursive: true });
+  const jsonPath = join9(auditsDir, `${options.sectionId}-claim-density.json`);
+  const markdownPath = join9(auditsDir, `${options.sectionId}-claim-density.md`);
   await writeFile7(jsonPath, JSON.stringify(audit2, null, 2), "utf8");
   await writeFile7(markdownPath, buildMarkdown(audit2), "utf8");
   return { audit: audit2, jsonPath, markdownPath };
@@ -2389,12 +2707,12 @@ var init_claims = __esm({
 });
 
 // src/contradictions/schema.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var ContradictionTypeSchema, SeveritySchema, OverlapAssessmentSchema, ContradictionDetectorSchema, ContradictionStatusSchema, ContradictionConfidenceSchema, ContradictionSchema;
 var init_schema7 = __esm({
   "src/contradictions/schema.ts"() {
     "use strict";
-    ContradictionTypeSchema = z7.enum([
+    ContradictionTypeSchema = z8.enum([
       "direct_conflict",
       "scope_conflict",
       "temporal_conflict",
@@ -2402,37 +2720,37 @@ var init_schema7 = __esm({
       "evidence_conflict",
       "overgeneralization_risk"
     ]);
-    SeveritySchema = z7.enum(["low", "medium", "high", "blocking"]);
-    OverlapAssessmentSchema = z7.enum([
+    SeveritySchema = z8.enum(["low", "medium", "high", "blocking"]);
+    OverlapAssessmentSchema = z8.enum([
       "fully_overlapping",
       "partially_overlapping",
       "non_overlapping",
       "unknown"
     ]);
-    ContradictionDetectorSchema = z7.enum(["heuristic", "ollama-intern"]);
-    ContradictionStatusSchema = z7.enum([
+    ContradictionDetectorSchema = z8.enum(["heuristic", "ollama-intern"]);
+    ContradictionStatusSchema = z8.enum([
       "unresolved",
       "reconciled",
       "preserved_deliberately",
       "rejected"
     ]);
-    ContradictionConfidenceSchema = z7.enum(["low", "medium", "high"]);
-    ContradictionSchema = z7.object({
-      contradiction_id: z7.string().regex(/^cnt_[a-f0-9]{12}_(heuristic|ollama_intern)$/),
-      section_id: z7.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      claim_ids: z7.array(z7.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/)).length(2, "contradictions are pair-wise in v0.1"),
-      source_ids: z7.array(z7.string().regex(/^src_[a-f0-9]{12}$/)).min(1),
+    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),
       type: ContradictionTypeSchema,
-      summary: z7.string().min(1),
-      scope_analysis: z7.string(),
+      summary: z8.string().min(1),
+      scope_analysis: z8.string(),
       overlap_assessment: OverlapAssessmentSchema,
       severity: SeveritySchema,
       confidence: ContradictionConfidenceSchema,
       detector: ContradictionDetectorSchema,
-      detection_method: z7.string().min(1),
-      evidence: z7.string(),
+      detection_method: z8.string().min(1),
+      evidence: z8.string(),
       status: ContradictionStatusSchema,
-      created_at: z7.string()
+      created_at: z8.string()
     });
   }
 });
@@ -2877,12 +3195,12 @@ var init_markdown = __esm({
 });
 
 // src/triage/schema.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var TriageDecisionSchema, ClaimTriageSchema, TriageSummarySchema;
 var init_schema8 = __esm({
   "src/triage/schema.ts"() {
     "use strict";
-    TriageDecisionSchema = z8.enum([
+    TriageDecisionSchema = z9.enum([
       // Passes triage and is forwarded to review.
       "selected_for_review",
       // Parked: kept on the canonical ledger as research truth, but not advanced.
@@ -2894,36 +3212,36 @@ var init_schema8 = __esm({
       "needs_scope_repair",
       "needs_human_review"
     ]);
-    ClaimTriageSchema = z8.object({
-      triage_id: z8.string().regex(/^tri_[a-f0-9]{12}$/),
-      claim_id: z8.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/),
-      section_id: z8.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+    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-]+$/),
       decision: TriageDecisionSchema,
-      reason: z8.string().min(1),
+      reason: z9.string().min(1),
       // Rank among selected_for_review claims (1 = highest priority). null for
       // any non-selected decision.
-      rank: z8.number().int().positive().nullable(),
+      rank: z9.number().int().positive().nullable(),
       // Quality score [0..1] used to sort. Stable. Higher = better.
-      quality_score: z8.number().min(0).max(1),
-      triage_method: z8.string().min(1),
-      created_at: z8.string()
-    });
-    TriageSummarySchema = z8.object({
-      summary_id: z8.string().regex(/^tris_[0-9]+_[a-z0-9-]+$/),
-      section_id: z8.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      triaged_at: z8.string(),
-      research_os_version: z8.string(),
-      triage_method: z8.string(),
-      candidate_claims: z8.number().int().nonnegative(),
-      decisions: z8.record(TriageDecisionSchema, z8.number().int().nonnegative()),
-      per_source_cap: z8.number().int().positive(),
-      duplicate_clusters_collapsed: z8.number().int().nonnegative(),
-      selected_count: z8.number().int().nonnegative(),
-      selected_per_source: z8.array(
-        z8.object({
-          source_id: z8.string().regex(/^src_[a-f0-9]{12}$/),
-          selected: z8.number().int().nonnegative(),
-          total: z8.number().int().nonnegative()
+      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()
         })
       )
     });
@@ -2936,10 +3254,10 @@ __export(run_exports, {
   readTriagedClaimIds: () => readTriagedClaimIds,
   triage: () => triage
 });
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { createHash as createHash2 } from "crypto";
-import { mkdir as mkdir8, readFile as readFile8, writeFile as writeFile8 } from "fs/promises";
-import { join as join9, resolve as resolve6 } from "path";
+import { mkdir as mkdir9, readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
+import { join as join10, resolve as resolve6 } from "path";
 function normaliseAssert(s) {
   return s.toLowerCase().replace(/[^a-z0-9 ]+/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -2959,9 +3277,9 @@ function makeTriageId(claimId) {
   return "tri_" + createHash2("sha256").update(claimId).digest("hex").slice(0, 12);
 }
 async function readClaims2(packPath, sectionId) {
-  const path = join9(packPath, "sections", sectionId, "claims.jsonl");
-  if (!existsSync8(path)) return [];
-  const text = await readFile8(path, "utf8");
+  const path = join10(packPath, "sections", sectionId, "claims.jsonl");
+  if (!existsSync9(path)) return [];
+  const text = await readFile9(path, "utf8");
   const out = [];
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -2974,8 +3292,8 @@ async function readClaims2(packPath, sectionId) {
 }
 async function triage(options) {
   const packPath = options.packPath ? resolve6(options.packPath) : process.cwd();
-  if (!existsSync8(join9(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
-  if (!existsSync8(join9(packPath, "sections", options.sectionId)))
+  if (!existsSync9(join10(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
+  if (!existsSync9(join10(packPath, "sections", options.sectionId)))
     throw new SectionNotFoundError(options.sectionId);
   const perSourceCap = options.perSourceCap ?? DEFAULT_PER_SOURCE_CAP;
   const minAssertChars = options.minAssertChars ?? DEFAULT_MIN_ASSERT_CHARS;
@@ -3109,13 +3427,13 @@ async function triage(options) {
       total
     })).sort((a, b) => b.total - a.total)
   });
-  const sectionDir = join9(packPath, "sections", options.sectionId);
-  const auditsDir = join9(packPath, "audits");
-  await mkdir8(sectionDir, { recursive: true });
-  await mkdir8(auditsDir, { recursive: true });
-  const triageJsonlPath = join9(sectionDir, "claim-triage.jsonl");
-  const triageMarkdownPath = join9(sectionDir, "claim-triage.md");
-  const summaryJsonPath = join9(auditsDir, `${options.sectionId}-claim-triage.json`);
+  const sectionDir = join10(packPath, "sections", options.sectionId);
+  const auditsDir = join10(packPath, "audits");
+  await mkdir9(sectionDir, { recursive: true });
+  await mkdir9(auditsDir, { recursive: true });
+  const triageJsonlPath = join10(sectionDir, "claim-triage.jsonl");
+  const triageMarkdownPath = join10(sectionDir, "claim-triage.md");
+  const summaryJsonPath = join10(auditsDir, `${options.sectionId}-claim-triage.json`);
   await writeFile8(triageJsonlPath, records.map((r) => JSON.stringify(r)).join("\n") + "\n", "utf8");
   await writeFile8(triageMarkdownPath, buildMarkdown2(records, summary), "utf8");
   await writeFile8(summaryJsonPath, JSON.stringify(summary, null, 2), "utf8");
@@ -3135,10 +3453,10 @@ async function triage(options) {
   };
 }
 async function readTriagedClaimIds(packPath, sectionId) {
-  const path = join9(packPath, "sections", sectionId, "claim-triage.jsonl");
+  const path = join10(packPath, "sections", sectionId, "claim-triage.jsonl");
   const out = /* @__PURE__ */ new Set();
-  if (!existsSync8(path)) return out;
-  const text = await readFile8(path, "utf8");
+  if (!existsSync9(path)) return out;
+  const text = await readFile9(path, "utf8");
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
     try {
@@ -3212,13 +3530,13 @@ var init_run2 = __esm({
 
 // src/contradictions/map.ts
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync9 } from "fs";
-import { appendFile as appendFile3, readFile as readFile9, writeFile as writeFile9 } from "fs/promises";
-import { join as join10, resolve as resolve7 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { appendFile as appendFile4, readFile as readFile10, writeFile as writeFile9 } from "fs/promises";
+import { join as join11, resolve as resolve7 } from "path";
 async function readCandidateClaims(packPath, sectionId) {
-  const path = join10(packPath, "sections", sectionId, "claims.jsonl");
-  if (!existsSync9(path)) return [];
-  const text = await readFile9(path, "utf8");
+  const path = join11(packPath, "sections", sectionId, "claims.jsonl");
+  if (!existsSync10(path)) return [];
+  const text = await readFile10(path, "utf8");
   const claims = [];
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -3229,9 +3547,9 @@ async function readCandidateClaims(packPath, sectionId) {
   return claims;
 }
 async function readExistingContradictions(packPath, sectionId) {
-  const path = join10(packPath, "sections", sectionId, "contradictions.jsonl");
-  if (!existsSync9(path)) return [];
-  const text = await readFile9(path, "utf8");
+  const path = join11(packPath, "sections", sectionId, "contradictions.jsonl");
+  if (!existsSync10(path)) return [];
+  const text = await readFile10(path, "utf8");
   const list = [];
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -3316,9 +3634,9 @@ async function resolveDetector(options) {
 }
 async function map(options) {
   const packPath = options.packPath ? resolve7(options.packPath) : process.cwd();
-  if (!existsSync9(join10(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
-  const sectionDir = join10(packPath, "sections", options.sectionId);
-  if (!existsSync9(sectionDir)) throw new SectionNotFoundError(options.sectionId);
+  if (!existsSync10(join11(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
+  const sectionDir = join11(packPath, "sections", options.sectionId);
+  if (!existsSync10(sectionDir)) throw new SectionNotFoundError(options.sectionId);
   let candidateClaims = await readCandidateClaims(packPath, options.sectionId);
   if (options.triagedOnly) {
     const { readTriagedClaimIds: readTriagedClaimIds2 } = await Promise.resolve().then(() => (init_run2(), run_exports));
@@ -3338,8 +3656,8 @@ async function map(options) {
     detectorError: null,
     detectorAnnouncement: announcement
   };
-  const ledgerPath = join10(sectionDir, "contradictions.jsonl");
-  const mdPath = join10(sectionDir, "contradictions.md");
+  const ledgerPath = join11(sectionDir, "contradictions.jsonl");
+  const mdPath = join11(sectionDir, "contradictions.md");
   const existingContradictions = await readExistingContradictions(
     packPath,
     options.sectionId
@@ -3384,7 +3702,7 @@ async function map(options) {
       summary.contradictionsDeduped += 1;
       continue;
     }
-    await appendFile3(ledgerPath, JSON.stringify(c) + "\n", "utf8");
+    await appendFile4(ledgerPath, JSON.stringify(c) + "\n", "utf8");
     existingIds.add(c.contradiction_id);
     existingContradictions.push(c);
     summary.contradictionsAdded += 1;
@@ -3420,31 +3738,31 @@ var init_map = __esm({
 });
 
 // src/contradictions/resolution-schema.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var ResolutionStatusSchema, ContradictionResolutionSchema;
 var init_resolution_schema = __esm({
   "src/contradictions/resolution-schema.ts"() {
     "use strict";
-    ResolutionStatusSchema = z9.enum([
+    ResolutionStatusSchema = z10.enum([
       "unresolved",
       "resolved",
       "preserved",
       "rejected"
     ]);
-    ContradictionResolutionSchema = z9.object({
-      contradiction_id: z9.string().min(1),
+    ContradictionResolutionSchema = z10.object({
+      contradiction_id: z10.string().min(1),
       status: ResolutionStatusSchema,
-      reason: z9.string().min(4),
-      resolved_at: z9.string().min(1),
-      resolved_by: z9.string().min(1)
+      reason: z10.string().min(4),
+      resolved_at: z10.string().min(1),
+      resolved_by: z10.string().min(1)
     });
   }
 });
 
 // src/contradictions/resolve.ts
-import { appendFile as appendFile4, readFile as readFile10 } from "fs/promises";
-import { existsSync as existsSync10 } from "fs";
-import { join as join11 } from "path";
+import { appendFile as appendFile5, readFile as readFile11 } from "fs/promises";
+import { existsSync as existsSync11 } from "fs";
+import { join as join12 } from "path";
 function latestEffectiveStatuses(ledgerPath, text) {
   const entries = [];
   for (const line of text.split(/\r?\n/)) {
@@ -3471,15 +3789,15 @@ async function resolve8(options) {
   if (reason.length < 4) {
     throw new Error("reason must be at least 4 characters");
   }
-  const sectionDir = join11(packPath, "sections", sectionId);
-  if (!existsSync10(sectionDir)) {
+  const sectionDir = join12(packPath, "sections", sectionId);
+  if (!existsSync11(sectionDir)) {
     throw new SectionNotFoundError(sectionId);
   }
-  const candidatesPath2 = join11(sectionDir, "contradictions.jsonl");
-  const ledgerPath = join11(sectionDir, "contradiction-resolutions.jsonl");
+  const candidatesPath2 = join12(sectionDir, "contradictions.jsonl");
+  const ledgerPath = join12(sectionDir, "contradiction-resolutions.jsonl");
   const candidates = [];
-  if (existsSync10(candidatesPath2)) {
-    const text = await readFile10(candidatesPath2, "utf8");
+  if (existsSync11(candidatesPath2)) {
+    const text = await readFile11(candidatesPath2, "utf8");
     for (const line of text.split(/\r?\n/)) {
       if (!line.trim()) continue;
       try {
@@ -3494,7 +3812,7 @@ async function resolve8(options) {
       }
     }
   }
-  const existingResolutions = existsSync10(ledgerPath) ? latestEffectiveStatuses(ledgerPath, await readFile10(ledgerPath, "utf8")) : /* @__PURE__ */ new Map();
+  const existingResolutions = existsSync11(ledgerPath) ? latestEffectiveStatuses(ledgerPath, await readFile11(ledgerPath, "utf8")) : /* @__PURE__ */ new Map();
   const knownIds = new Set(candidates.map((c) => c.contradiction_id));
   let targetIds;
   if (all) {
@@ -3526,7 +3844,7 @@ async function resolve8(options) {
     applied++;
   }
   if (lines.length > 0) {
-    await appendFile4(ledgerPath, lines.join("\n") + "\n", "utf8");
+    await appendFile5(ledgerPath, lines.join("\n") + "\n", "utf8");
   }
   return { sectionId, applied, skipped, ledgerPath };
 }
@@ -3553,12 +3871,12 @@ var init_contradictions = __esm({
 });
 
 // src/review/schema.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var FindingCategorySchema, FindingSeveritySchema, ReviewerNameSchema, ReviewDecisionSchema, ReviewConfidenceSchema, ReviewFindingSchema, ClaimReviewSchema, ReviewSnapshotSchema;
 var init_schema9 = __esm({
   "src/review/schema.ts"() {
     "use strict";
-    FindingCategorySchema = z10.enum([
+    FindingCategorySchema = z11.enum([
       "unsupported_claim",
       "ungrounded_excerpt",
       "stale_claim",
@@ -3585,9 +3903,9 @@ var init_schema9 = __esm({
       // a low-value claim can appear in a perfectly-sized section.
       "valid_but_low_value"
     ]);
-    FindingSeveritySchema = z10.enum(["info", "warn", "block"]);
-    ReviewerNameSchema = z10.enum(["heuristic", "ollama-intern"]);
-    ReviewDecisionSchema = z10.enum([
+    FindingSeveritySchema = z11.enum(["info", "warn", "block"]);
+    ReviewerNameSchema = z11.enum(["heuristic", "ollama-intern"]);
+    ReviewDecisionSchema = z11.enum([
       "accepted_for_synthesis",
       "rejected",
       "needs_scope_repair",
@@ -3595,43 +3913,43 @@ var init_schema9 = __esm({
       "needs_contradiction_mapping",
       "needs_human_review"
     ]);
-    ReviewConfidenceSchema = z10.enum(["low", "medium", "high"]);
-    ReviewFindingSchema = z10.object({
-      finding_id: z10.string().regex(/^fnd_[a-f0-9]{12}$/),
-      section_id: z10.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      claim_ids: z10.array(z10.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/)),
-      source_ids: z10.array(z10.string().regex(/^src_[a-f0-9]{12}$/)),
+    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}$/)),
       category: FindingCategorySchema,
       severity: FindingSeveritySchema,
-      summary: z10.string().min(1),
-      evidence: z10.string(),
-      required_action: z10.string(),
+      summary: z11.string().min(1),
+      evidence: z11.string(),
+      required_action: z11.string(),
       reviewer: ReviewerNameSchema,
-      review_method: z10.string().min(1),
+      review_method: z11.string().min(1),
       confidence: ReviewConfidenceSchema,
-      created_at: z10.string()
+      created_at: z11.string()
     });
-    ClaimReviewSchema = z10.object({
-      claim_id: z10.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/),
+    ClaimReviewSchema = z11.object({
+      claim_id: z11.string().regex(/^clm_[a-f0-9]{12}_(heuristic|ollama_intern)_\d+$/),
       decision: ReviewDecisionSchema,
-      reason: z10.string().min(1),
-      finding_ids: z10.array(z10.string()),
+      reason: z11.string().min(1),
+      finding_ids: z11.array(z11.string()),
       reviewer: ReviewerNameSchema,
-      review_method: z10.string().min(1),
-      created_at: z10.string()
+      review_method: z11.string().min(1),
+      created_at: z11.string()
     });
-    ReviewSnapshotSchema = z10.object({
-      section_id: z10.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+    ReviewSnapshotSchema = z11.object({
+      section_id: z11.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
       reviewer: ReviewerNameSchema,
-      review_method: z10.string(),
-      reviewed_at: z10.string(),
-      candidate_claims: z10.number().int().nonnegative(),
-      findings: z10.array(ReviewFindingSchema),
-      claim_reviews: z10.array(ClaimReviewSchema),
-      decision_counts: z10.record(ReviewDecisionSchema, z10.number().int().nonnegative()),
-      severity_counts: z10.record(FindingSeveritySchema, z10.number().int().nonnegative()),
-      llm_findings_rejected_ungrounded: z10.number().int().nonnegative(),
-      promoted_to_reviewed: z10.boolean()
+      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()
     });
   }
 });
@@ -3641,6 +3959,7 @@ function checkSourceFloor(input) {
   const cfg = input.research.gates.source_floor;
   const results = [];
   const cards = input.sources;
+  const sectionCards = cards.filter((c) => c.section_id === input.section.id);
   const sourceCount = cards.length;
   if (sourceCount < cfg.min_sources) {
     results.push({
@@ -3664,12 +3983,15 @@ function checkSourceFloor(input) {
   const publishers = new Set(
     cards.map((c) => c.publisher).filter((p) => typeof p === "string")
   );
+  const sectionPublishers = new Set(
+    sectionCards.map((c) => c.publisher).filter((p) => typeof p === "string")
+  );
   if (publishers.size < cfg.min_independent_publishers) {
     results.push({
       family: "source_floor",
       check: "min_independent_publishers",
       status: "fail",
-      detail: `Found ${publishers.size} independent publisher(s); minimum ${cfg.min_independent_publishers} required.`,
+      detail: `Found ${publishers.size} independent publisher(s); minimum ${cfg.min_independent_publishers} required. (pack-wide=${publishers.size}, section-scoped=${sectionPublishers.size})`,
       evidence: [...publishers],
       blocks_synthesis: true
     });
@@ -3678,18 +4000,19 @@ function checkSourceFloor(input) {
       family: "source_floor",
       check: "min_independent_publishers",
       status: "pass",
-      detail: `${publishers.size} independent publisher(s) >= minimum ${cfg.min_independent_publishers}.`,
+      detail: `${publishers.size} independent publisher(s) >= minimum ${cfg.min_independent_publishers}. (pack-wide=${publishers.size}, section-scoped=${sectionPublishers.size})`,
       evidence: [],
       blocks_synthesis: false
     });
   }
   const primaryCount = cards.filter((c) => c.source_type === "primary").length;
+  const sectionPrimaryCount = sectionCards.filter((c) => c.source_type === "primary").length;
   if (primaryCount < cfg.primary_sources_required) {
     results.push({
       family: "source_floor",
       check: "primary_sources_required",
       status: "fail",
-      detail: `Found ${primaryCount} primary source(s); minimum ${cfg.primary_sources_required} required. Pre-waiver.`,
+      detail: `Found ${primaryCount} primary source(s); minimum ${cfg.primary_sources_required} required. Pre-waiver. (pack-wide=${primaryCount}, section-scoped=${sectionPrimaryCount})`,
       evidence: cards.filter((c) => c.source_type === "primary").map((c) => c.source_id),
       blocks_synthesis: true
     });
@@ -3698,7 +4021,7 @@ function checkSourceFloor(input) {
       family: "source_floor",
       check: "primary_sources_required",
       status: "pass",
-      detail: `${primaryCount} primary source(s) >= minimum ${cfg.primary_sources_required}.`,
+      detail: `${primaryCount} primary source(s) >= minimum ${cfg.primary_sources_required}. (pack-wide=${primaryCount}, section-scoped=${sectionPrimaryCount})`,
       evidence: [],
       blocks_synthesis: false
     });
@@ -3852,25 +4175,14 @@ function checkClaimIntegrity(input) {
         monoClaims.push(claim.claim_id);
       }
     }
-    if (monoClaims.length > claims.length / 2) {
-      results.push({
-        family: "claim_integrity",
-        check: "no_source_cluster_monopoly",
-        status: "warn",
-        detail: `${monoClaims.length}/${claims.length} claim(s) source from a single publisher. Independent corroboration recommended before synthesis.`,
-        evidence: monoClaims,
-        blocks_synthesis: false
-      });
-    } else {
-      results.push({
-        family: "claim_integrity",
-        check: "no_source_cluster_monopoly",
-        status: "pass",
-        detail: `${monoClaims.length}/${claims.length} claim(s) source from a single publisher (within tolerance).`,
-        evidence: [],
-        blocks_synthesis: false
-      });
-    }
+    results.push({
+      family: "claim_integrity",
+      check: "no_source_cluster_monopoly",
+      status: "pass",
+      detail: `${monoClaims.length}/${claims.length} claim(s) are single-source by architecture (each claim references exactly one source). Publisher diversity is enforced at source-card level via min_independent_publishers.`,
+      evidence: [],
+      blocks_synthesis: false
+    });
   }
   return results;
 }
@@ -4525,12 +4837,12 @@ var init_markdown2 = __esm({
 });
 
 // src/gates/schema.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var GateFamilySchema, GateCheckStatusSchema, VerdictSchema, GateCheckResultSchema, WaiverApplicationSchema, SectionGateResultSchema;
 var init_schema10 = __esm({
   "src/gates/schema.ts"() {
     "use strict";
-    GateFamilySchema = z11.enum([
+    GateFamilySchema = z12.enum([
       "source_floor",
       "claim_integrity",
       "scope_integrity",
@@ -4540,96 +4852,98 @@ var init_schema10 = __esm({
       "waivers",
       "accepted_claim_floor"
     ]);
-    GateCheckStatusSchema = z11.enum([
+    GateCheckStatusSchema = z12.enum([
       "pass",
       "warn",
       "fail",
       "pass_with_waiver",
       "warn_with_waiver"
     ]);
-    VerdictSchema = z11.enum(["pass", "warn", "fail", "blocked"]);
-    GateCheckResultSchema = z11.object({
+    VerdictSchema = z12.enum(["pass", "warn", "fail", "blocked"]);
+    GateCheckResultSchema = z12.object({
       family: GateFamilySchema,
-      check: z11.string().min(1),
+      check: z12.string().min(1),
       status: GateCheckStatusSchema,
-      detail: z11.string(),
-      evidence: z11.array(z11.string()),
-      blocks_synthesis: z11.boolean()
+      detail: z12.string(),
+      evidence: z12.array(z12.string()),
+      blocks_synthesis: z12.boolean()
     });
-    WaiverApplicationSchema = z11.object({
+    WaiverApplicationSchema = z12.object({
       family: GateFamilySchema,
-      check: z11.string().min(1),
-      reason: z11.string().min(1),
-      compensating_controls: z11.array(z11.string()),
+      check: z12.string().min(1),
+      reason: z12.string().min(1),
+      compensating_controls: z12.array(z12.string()),
       original_status: GateCheckStatusSchema,
       new_status: GateCheckStatusSchema
     });
-    SectionGateResultSchema = z11.object({
-      section_id: z11.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+    SectionGateResultSchema = z12.object({
+      section_id: z12.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
       verdict: VerdictSchema,
-      summary: z11.string(),
-      checked_at: z11.string(),
-      synthesis_eligible: z11.boolean(),
-      gate_results: z11.array(GateCheckResultSchema),
-      failures: z11.array(GateCheckResultSchema),
-      warnings: z11.array(GateCheckResultSchema),
-      waivers_applied: z11.array(WaiverApplicationSchema),
-      blocking_reasons: z11.array(z11.string()),
-      claim_counts: z11.object({
-        total: z11.number().int().nonnegative(),
-        candidate: z11.number().int().nonnegative(),
-        with_evidence_excerpt: z11.number().int().nonnegative(),
-        with_source_hashes: z11.number().int().nonnegative(),
-        with_scope: z11.number().int().nonnegative(),
-        with_not: z11.number().int().nonnegative(),
-        universal_scope_null: z11.number().int().nonnegative(),
-        orphans: z11.number().int().nonnegative()
+      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()
       }),
-      source_counts: z11.object({
-        total: z11.number().int().nonnegative(),
-        primary: z11.number().int().nonnegative(),
-        secondary: z11.number().int().nonnegative(),
-        forum: z11.number().int().nonnegative(),
-        benchmark: z11.number().int().nonnegative(),
-        docs: z11.number().int().nonnegative(),
-        unknown: z11.number().int().nonnegative(),
-        independent_publishers: z11.number().int().nonnegative(),
-        failed_fetches: z11.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()
       }),
-      contradiction_counts: z11.object({
-        total: z11.number().int().nonnegative(),
-        unresolved: z11.number().int().nonnegative(),
-        blocking: z11.number().int().nonnegative(),
-        by_type: z11.record(z11.string(), z11.number().int().nonnegative())
+      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())
       }),
-      freshness_summary: z11.object({
-        policy_required: z11.boolean(),
-        max_source_age_months: z11.number().int().nullable(),
-        stale_source_policy: z11.enum(["warn", "fail"]),
-        stale_count: z11.number().int().nonnegative(),
-        unknown_date_count: z11.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()
       }),
-      scope_integrity_summary: z11.object({
-        universal_claims: z11.number().int().nonnegative(),
-        scoped_claims: z11.number().int().nonnegative(),
-        with_not_constraint: z11.number().int().nonnegative(),
-        overgen_risks_total: z11.number().int().nonnegative(),
-        overgen_risks_blocking: z11.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()
       }),
-      next_actions: z11.array(z11.string())
+      next_actions: z12.array(z12.string())
     });
   }
 });
 
 // src/gates/run.ts
-import { existsSync as existsSync11 } from "fs";
-import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile10 } from "fs/promises";
-import { join as join12, resolve as resolve9 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { mkdir as mkdir10, readFile as readFile12, writeFile as writeFile10 } from "fs/promises";
+import { join as join13, resolve as resolve9 } from "path";
 import { parse as yamlParse2, stringify as yamlStringify3 } from "yaml";
 async function readJsonl(packPath, rel, parse) {
-  const path = join12(packPath, rel);
-  if (!existsSync11(path)) return [];
-  const text = await readFile11(path, "utf8");
+  const path = join13(packPath, rel);
+  if (!existsSync12(path)) return [];
+  const text = await readFile12(path, "utf8");
   const out = [];
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -4638,14 +4952,14 @@ async function readJsonl(packPath, rel, parse) {
   return out;
 }
 async function readSourceCards2(packPath) {
-  const dir = join12(packPath, "evidence", "source-cards");
-  if (!existsSync11(dir)) return [];
+  const dir = join13(packPath, "evidence", "source-cards");
+  if (!existsSync12(dir)) return [];
   const { readdir: readdir4 } = await import("fs/promises");
   const entries = await readdir4(dir);
   const cards = [];
   for (const entry of entries) {
     if (!entry.endsWith(".json")) continue;
-    const text = await readFile11(join12(dir, entry), "utf8");
+    const text = await readFile12(join13(dir, entry), "utf8");
     cards.push(SourceCardSchema.parse(JSON.parse(text)));
   }
   return cards;
@@ -4667,10 +4981,14 @@ function summarizeClaimCounts(input) {
 }
 function summarizeSourceCounts(input) {
   const cards = input.sources;
+  const sectionCards = cards.filter((c) => c.section_id === input.section.id);
   const failed = input.receipts.filter((r) => r.fetch_outcome !== "ok").length;
   const publishers = new Set(
     cards.map((c) => c.publisher).filter((p) => typeof p === "string")
   );
+  const sectionPublishers = new Set(
+    sectionCards.map((c) => c.publisher).filter((p) => typeof p === "string")
+  );
   return {
     total: cards.length,
     primary: cards.filter((c) => c.source_type === "primary").length,
@@ -4680,7 +4998,9 @@ function summarizeSourceCounts(input) {
     docs: cards.filter((c) => c.source_type === "docs").length,
     unknown: cards.filter((c) => c.source_type === "unknown").length,
     independent_publishers: publishers.size,
-    failed_fetches: failed
+    failed_fetches: failed,
+    section_primary: sectionCards.filter((c) => c.source_type === "primary").length,
+    section_independent_publishers: sectionPublishers.size
   };
 }
 function buildEffectiveStatuses3(resolutions) {
@@ -4814,14 +5134,14 @@ function buildNextActions(results) {
   return Array.from(new Set(actions));
 }
 async function loadResearchYaml2(packPath) {
-  const yamlPath = join12(packPath, "research.yaml");
-  if (!existsSync11(yamlPath)) throw new PackNotFoundError(packPath);
-  const text = await readFile11(yamlPath, "utf8");
+  const yamlPath = join13(packPath, "research.yaml");
+  if (!existsSync12(yamlPath)) throw new PackNotFoundError(packPath);
+  const text = await readFile12(yamlPath, "utf8");
   return ResearchYamlSchema.parse(yamlParse2(text));
 }
 async function updateSectionStatus(packPath, sectionId, synthesisEligible) {
-  const yamlPath = join12(packPath, "research.yaml");
-  const text = await readFile11(yamlPath, "utf8");
+  const yamlPath = join13(packPath, "research.yaml");
+  const text = await readFile12(yamlPath, "utf8");
   const research = ResearchYamlSchema.parse(yamlParse2(text));
   const idx = research.sections.findIndex((s) => s.id === sectionId);
   if (idx < 0) return;
@@ -4838,9 +5158,9 @@ async function updateSectionStatus(packPath, sectionId, synthesisEligible) {
 }
 async function gate(options) {
   const packPath = options.packPath ? resolve9(options.packPath) : process.cwd();
-  if (!existsSync11(join12(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
-  const sectionDir = join12(packPath, "sections", options.sectionId);
-  if (!existsSync11(sectionDir)) throw new SectionNotFoundError(options.sectionId);
+  if (!existsSync12(join13(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
+  const sectionDir = join13(packPath, "sections", options.sectionId);
+  if (!existsSync12(sectionDir)) throw new SectionNotFoundError(options.sectionId);
   const research = await loadResearchYaml2(packPath);
   const section = research.sections.find((s) => s.id === options.sectionId);
   if (!section) throw new SectionNotFoundError(options.sectionId);
@@ -4894,15 +5214,15 @@ async function gate(options) {
     scope_integrity_summary: summarizeScopeIntegrity(input),
     next_actions: buildNextActions(finalResults)
   });
-  const auditsDir = join12(packPath, "audits");
-  await mkdir9(auditsDir, { recursive: true });
+  const auditsDir = join13(packPath, "audits");
+  await mkdir10(auditsDir, { recursive: true });
   await writeFile10(
-    join12(auditsDir, `${options.sectionId}-gate.json`),
+    join13(auditsDir, `${options.sectionId}-gate.json`),
     JSON.stringify(result, null, 2),
     "utf8"
   );
   await writeFile10(
-    join12(auditsDir, `${options.sectionId}-gate.md`),
+    join13(auditsDir, `${options.sectionId}-gate.md`),
     renderGateMarkdown(result),
     "utf8"
   );
@@ -4944,21 +5264,21 @@ var init_gates = __esm({
 });
 
 // src/review/profiles.ts
-import { existsSync as existsSync12 } from "fs";
-import { mkdir as mkdir10, readFile as readFile12, writeFile as writeFile11 } from "fs/promises";
-import { join as join13 } from "path";
-import { z as z12 } from "zod";
+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";
 function reviewActivePath(packPath, sectionId) {
-  return join13(packPath, "sections", sectionId, "review-active.json");
+  return join14(packPath, "sections", sectionId, "review-active.json");
 }
 function profileDir(packPath, sectionId, profile) {
-  return join13(packPath, "sections", sectionId, "reviews", profile);
+  return join14(packPath, "sections", sectionId, "reviews", profile);
 }
 async function readActiveProfile(packPath, sectionId) {
   const path = reviewActivePath(packPath, sectionId);
-  if (!existsSync12(path)) return DEFAULT_PROFILE;
+  if (!existsSync13(path)) return DEFAULT_PROFILE;
   try {
-    const parsed = ReviewActiveSchema.parse(JSON.parse(await readFile12(path, "utf8")));
+    const parsed = ReviewActiveSchema.parse(JSON.parse(await readFile13(path, "utf8")));
     return parsed.active_profile;
   } catch {
     return DEFAULT_PROFILE;
@@ -4966,7 +5286,7 @@ async function readActiveProfile(packPath, sectionId) {
 }
 async function writeActiveProfile(packPath, sectionId, active) {
   const path = reviewActivePath(packPath, sectionId);
-  await mkdir10(join13(packPath, "sections", sectionId), { recursive: true });
+  await mkdir11(join14(packPath, "sections", sectionId), { recursive: true });
   await writeFile11(path, JSON.stringify(ReviewActiveSchema.parse(active), null, 2), "utf8");
 }
 function isValidProfileName(name) {
@@ -4977,22 +5297,22 @@ var init_profiles = __esm({
   "src/review/profiles.ts"() {
     "use strict";
     DEFAULT_PROFILE = "default";
-    PromotionCalibrationSummarySchema = z12.object({
-      fixture: z12.string().nullable().default(null),
-      good_false_positive_rate: z12.string().nullable().default(null),
-      bad_any_flag_recall: z12.string().nullable().default(null),
-      strict_category_recall: z12.string().nullable().default(null),
-      unsupported_claim_recall: z12.string().nullable().default(null),
-      notes: z12.string().nullable().default(null)
-    });
-    ReviewActiveSchema = z12.object({
-      active_profile: z12.string().min(1),
-      promoted_at: z12.string(),
-      promoted_method: z12.string(),
-      promoted_reviewer: z12.string(),
+    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(),
       // Free-text reason the profile was promoted. Recorded once at promotion
       // time; not derived from artifacts. Required.
-      promotion_reason: z12.string().min(8).default("promoted via review-promote without an explicit reason"),
+      promotion_reason: z13.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)
@@ -5813,14 +6133,14 @@ var init_markdown3 = __esm({
 
 // src/review/run.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync13 } from "fs";
-import { appendFile as appendFile5, mkdir as mkdir11, readFile as readFile13, writeFile as writeFile12 } from "fs/promises";
-import { join as join14, resolve as resolve10 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { appendFile as appendFile6, mkdir as mkdir12, readFile as readFile14, writeFile as writeFile12 } from "fs/promises";
+import { join as join15, resolve as resolve10 } from "path";
 import { parse as yamlParse3, stringify as yamlStringify4 } from "yaml";
 async function readJsonl2(packPath, rel, parse) {
-  const path = join14(packPath, rel);
-  if (!existsSync13(path)) return [];
-  const text = await readFile13(path, "utf8");
+  const path = join15(packPath, rel);
+  if (!existsSync14(path)) return [];
+  const text = await readFile14(path, "utf8");
   const out = [];
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -5829,37 +6149,37 @@ async function readJsonl2(packPath, rel, parse) {
   return out;
 }
 async function readSourceCards3(packPath) {
-  const dir = join14(packPath, "evidence", "source-cards");
-  if (!existsSync13(dir)) return [];
+  const dir = join15(packPath, "evidence", "source-cards");
+  if (!existsSync14(dir)) return [];
   const { readdir: readdir4 } = await import("fs/promises");
   const entries = await readdir4(dir);
   const cards = [];
   for (const entry of entries) {
     if (!entry.endsWith(".json")) continue;
-    const text = await readFile13(join14(dir, entry), "utf8");
+    const text = await readFile14(join15(dir, entry), "utf8");
     cards.push(SourceCardSchema.parse(JSON.parse(text)));
   }
   return cards;
 }
 async function readGateResult(packPath, sectionId) {
-  const path = join14(packPath, "audits", `${sectionId}-gate.json`);
-  if (!existsSync13(path)) return null;
-  const text = await readFile13(path, "utf8");
+  const path = join15(packPath, "audits", `${sectionId}-gate.json`);
+  if (!existsSync14(path)) return null;
+  const text = await readFile14(path, "utf8");
   return SectionGateResultSchema.parse(JSON.parse(text));
 }
 async function readBriefText(packPath, sectionId) {
-  const path = join14(packPath, "sections", sectionId, "brief.md");
-  if (!existsSync13(path)) return null;
-  return readFile13(path, "utf8");
+  const path = join15(packPath, "sections", sectionId, "brief.md");
+  if (!existsSync14(path)) return null;
+  return readFile14(path, "utf8");
 }
 async function readRawTextBySource(packPath, receipts) {
   const map2 = /* @__PURE__ */ new Map();
   for (const r of receipts) {
     if (r.fetch_outcome !== "ok" || !r.raw_text_path) continue;
-    const path = join14(packPath, r.raw_text_path);
-    if (!existsSync13(path)) continue;
+    const path = join15(packPath, r.raw_text_path);
+    if (!existsSync14(path)) continue;
     if (map2.has(r.source_id)) continue;
-    map2.set(r.source_id, await readFile13(path, "utf8"));
+    map2.set(r.source_id, await readFile14(path, "utf8"));
   }
   return map2;
 }
@@ -5869,8 +6189,8 @@ async function readExcerptsBySource(packPath, claims) {
   for (const c of claims) for (const sid of c.source_ids) sourceIds.add(sid);
   for (const sid of sourceIds) {
     const path = ledgerPathFor(packPath, sid);
-    if (!existsSync13(path)) continue;
-    const text = await readFile13(path, "utf8");
+    if (!existsSync14(path)) continue;
+    const text = await readFile14(path, "utf8");
     const index = /* @__PURE__ */ new Map();
     for (const line of text.split(/\r?\n/)) {
       if (!line.trim()) continue;
@@ -5923,15 +6243,15 @@ function buildFinding(args) {
   });
 }
 async function loadResearchYaml3(packPath) {
-  const yamlPath = join14(packPath, "research.yaml");
-  if (!existsSync13(yamlPath)) throw new PackNotFoundError(packPath);
-  const text = await readFile13(yamlPath, "utf8");
+  const yamlPath = join15(packPath, "research.yaml");
+  if (!existsSync14(yamlPath)) throw new PackNotFoundError(packPath);
+  const text = await readFile14(yamlPath, "utf8");
   return ResearchYamlSchema.parse(yamlParse3(text));
 }
 async function maybePromoteToReviewed(packPath, sectionId, allAccepted) {
   if (!allAccepted) return false;
-  const yamlPath = join14(packPath, "research.yaml");
-  const text = await readFile13(yamlPath, "utf8");
+  const yamlPath = join15(packPath, "research.yaml");
+  const text = await readFile14(yamlPath, "utf8");
   const research = ResearchYamlSchema.parse(yamlParse3(text));
   const idx = research.sections.findIndex((s) => s.id === sectionId);
   if (idx < 0) return false;
@@ -5943,9 +6263,9 @@ async function maybePromoteToReviewed(packPath, sectionId, allAccepted) {
 }
 async function review(options) {
   const packPath = options.packPath ? resolve10(options.packPath) : process.cwd();
-  if (!existsSync13(join14(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
-  const sectionDir = join14(packPath, "sections", options.sectionId);
-  if (!existsSync13(sectionDir)) throw new SectionNotFoundError(options.sectionId);
+  if (!existsSync14(join15(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
+  const sectionDir = join15(packPath, "sections", options.sectionId);
+  if (!existsSync14(sectionDir)) throw new SectionNotFoundError(options.sectionId);
   const research = await loadResearchYaml3(packPath);
   const section = research.sections.find((s) => s.id === options.sectionId);
   if (!section) throw new SectionNotFoundError(options.sectionId);
@@ -6195,39 +6515,39 @@ async function finalizeReview(args) {
     promoted_to_reviewed: promoted
   });
   const profDir = profileDir(args.packPath, args.sectionId, args.profile);
-  await mkdir11(profDir, { recursive: true });
-  await writeFile12(join14(profDir, "review.json"), JSON.stringify(snapshot, null, 2), "utf8");
-  await writeFile12(join14(profDir, "review.md"), renderReviewMarkdown(snapshot), "utf8");
-  const profileFindingsPath = join14(profDir, "findings.jsonl");
+  await mkdir12(profDir, { recursive: true });
+  await writeFile12(join15(profDir, "review.json"), JSON.stringify(snapshot, null, 2), "utf8");
+  await writeFile12(join15(profDir, "review.md"), renderReviewMarkdown(snapshot), "utf8");
+  const profileFindingsPath = join15(profDir, "findings.jsonl");
   for (const f of dedupedFindings) {
-    await appendFile5(profileFindingsPath, JSON.stringify(f) + "\n", "utf8");
+    await appendFile6(profileFindingsPath, JSON.stringify(f) + "\n", "utf8");
   }
-  const profileReviewsPath = join14(profDir, "claim-reviews.jsonl");
+  const profileReviewsPath = join15(profDir, "claim-reviews.jsonl");
   for (const r of claimReviews) {
-    await appendFile5(profileReviewsPath, JSON.stringify(ClaimReviewSchema.parse(r)) + "\n", "utf8");
+    await appendFile6(profileReviewsPath, JSON.stringify(ClaimReviewSchema.parse(r)) + "\n", "utf8");
   }
   const activeProfile = await readActiveProfile(args.packPath, args.sectionId);
   const isActive = args.profile === activeProfile || activeProfile === DEFAULT_PROFILE && args.profile === DEFAULT_PROFILE;
   if (isActive) {
-    const auditsDir = join14(args.packPath, "audits");
-    await mkdir11(auditsDir, { recursive: true });
+    const auditsDir = join15(args.packPath, "audits");
+    await mkdir12(auditsDir, { recursive: true });
     await writeFile12(
-      join14(auditsDir, `${args.sectionId}-review.json`),
+      join15(auditsDir, `${args.sectionId}-review.json`),
       JSON.stringify(snapshot, null, 2),
       "utf8"
     );
     await writeFile12(
-      join14(auditsDir, `${args.sectionId}-review.md`),
+      join15(auditsDir, `${args.sectionId}-review.md`),
       renderReviewMarkdown(snapshot),
       "utf8"
     );
-    const findingsPath = join14(auditsDir, `${args.sectionId}-findings.jsonl`);
+    const findingsPath = join15(auditsDir, `${args.sectionId}-findings.jsonl`);
     for (const f of dedupedFindings) {
-      await appendFile5(findingsPath, JSON.stringify(f) + "\n", "utf8");
+      await appendFile6(findingsPath, JSON.stringify(f) + "\n", "utf8");
     }
-    const reviewsPath = join14(args.packPath, "sections", args.sectionId, "claim-reviews.jsonl");
+    const reviewsPath = join15(args.packPath, "sections", args.sectionId, "claim-reviews.jsonl");
     for (const r of claimReviews) {
-      await appendFile5(reviewsPath, JSON.stringify(ClaimReviewSchema.parse(r)) + "\n", "utf8");
+      await appendFile6(reviewsPath, JSON.stringify(ClaimReviewSchema.parse(r)) + "\n", "utf8");
     }
   }
   return {
@@ -6264,14 +6584,14 @@ var init_run4 = __esm({
 });
 
 // src/review/promote.ts
-import { existsSync as existsSync14 } from "fs";
-import { copyFile, mkdir as mkdir12, readFile as readFile14, writeFile as writeFile13, appendFile as appendFile6 } from "fs/promises";
-import { join as join15, resolve as resolve11 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { copyFile, mkdir as mkdir13, readFile as readFile15, writeFile as writeFile13, appendFile as appendFile7 } from "fs/promises";
+import { join as join16, resolve as resolve11 } from "path";
 import { parse as yamlParse4, stringify as yamlStringify5 } from "yaml";
 async function promote(options) {
   const packPath = options.packPath ? resolve11(options.packPath) : process.cwd();
-  if (!existsSync14(join15(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
-  if (!existsSync14(join15(packPath, "sections", options.sectionId)))
+  if (!existsSync15(join16(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
+  if (!existsSync15(join16(packPath, "sections", options.sectionId)))
     throw new SectionNotFoundError(options.sectionId);
   if (!isValidProfileName(options.profile)) {
     throw new Error(
@@ -6279,39 +6599,39 @@ async function promote(options) {
     );
   }
   const dir = profileDir(packPath, options.sectionId, options.profile);
-  const reviewJsonPath = join15(dir, "review.json");
-  if (!existsSync14(reviewJsonPath)) {
+  const reviewJsonPath = join16(dir, "review.json");
+  if (!existsSync15(reviewJsonPath)) {
     throw new Error(
       `Profile "${options.profile}" not found at ${dir}. Run \`research-os review --profile ${options.profile}\` first.`
     );
   }
   const snapshot = ReviewSnapshotSchema.parse(
-    JSON.parse(await readFile14(reviewJsonPath, "utf8"))
+    JSON.parse(await readFile15(reviewJsonPath, "utf8"))
   );
-  const auditsDir = join15(packPath, "audits");
-  await mkdir12(auditsDir, { recursive: true });
-  const canonicalReviewJson = join15(auditsDir, `${options.sectionId}-review.json`);
-  const canonicalReviewMd = join15(auditsDir, `${options.sectionId}-review.md`);
+  const auditsDir = join16(packPath, "audits");
+  await mkdir13(auditsDir, { recursive: true });
+  const canonicalReviewJson = join16(auditsDir, `${options.sectionId}-review.json`);
+  const canonicalReviewMd = join16(auditsDir, `${options.sectionId}-review.md`);
   await copyFile(reviewJsonPath, canonicalReviewJson);
   await writeFile13(canonicalReviewMd, renderReviewMarkdown(snapshot), "utf8");
-  const canonicalFindings = join15(auditsDir, `${options.sectionId}-findings.jsonl`);
-  const profileFindings = join15(dir, "findings.jsonl");
+  const canonicalFindings = join16(auditsDir, `${options.sectionId}-findings.jsonl`);
+  const profileFindings = join16(dir, "findings.jsonl");
   const writtenFindings = [];
-  if (existsSync14(profileFindings)) {
-    const text = await readFile14(profileFindings, "utf8");
+  if (existsSync15(profileFindings)) {
+    const text = await readFile15(profileFindings, "utf8");
     for (const line of text.split(/\r?\n/)) {
       if (!line.trim()) continue;
-      await appendFile6(canonicalFindings, line + "\n", "utf8");
+      await appendFile7(canonicalFindings, line + "\n", "utf8");
       writtenFindings.push(line);
     }
   }
-  const canonicalReviews = join15(packPath, "sections", options.sectionId, "claim-reviews.jsonl");
-  const profileReviews = join15(dir, "claim-reviews.jsonl");
-  if (existsSync14(profileReviews)) {
-    const text = await readFile14(profileReviews, "utf8");
+  const canonicalReviews = join16(packPath, "sections", options.sectionId, "claim-reviews.jsonl");
+  const profileReviews = join16(dir, "claim-reviews.jsonl");
+  if (existsSync15(profileReviews)) {
+    const text = await readFile15(profileReviews, "utf8");
     for (const line of text.split(/\r?\n/)) {
       if (!line.trim()) continue;
-      await appendFile6(canonicalReviews, line + "\n", "utf8");
+      await appendFile7(canonicalReviews, line + "\n", "utf8");
     }
   }
   const stamp = (options.now ?? (() => /* @__PURE__ */ new Date()))();
@@ -6325,8 +6645,8 @@ async function promote(options) {
   });
   let sectionStatusBumped = false;
   if (options.promoteSectionStatus) {
-    const yamlPath = join15(packPath, "research.yaml");
-    const research = ResearchYamlSchema.parse(yamlParse4(await readFile14(yamlPath, "utf8")));
+    const yamlPath = join16(packPath, "research.yaml");
+    const research = ResearchYamlSchema.parse(yamlParse4(await readFile15(yamlPath, "utf8")));
     const idx = research.sections.findIndex((s) => s.id === options.sectionId);
     if (idx >= 0 && research.sections[idx].status === "gated") {
       const allAccepted = snapshot.candidate_claims > 0 && snapshot.claim_reviews.every((r) => r.decision === "accepted_for_synthesis");
@@ -6531,16 +6851,16 @@ var init_schema11 = __esm({
 });
 
 // src/indexer/db.ts
-import { mkdirSync, writeFileSync, existsSync as existsSync15 } from "fs";
-import { dirname as dirname3, join as join16 } from "path";
+import { mkdirSync, writeFileSync, existsSync as existsSync16 } from "fs";
+import { dirname as dirname4, join as join17 } from "path";
 import Database from "better-sqlite3";
 function indexDbPath(packPath) {
-  return join16(packPath, ".research-os", "index.sqlite");
+  return join17(packPath, ".research-os", "index.sqlite");
 }
 function ensureGitIgnore(packPath) {
-  const dir = join16(packPath, ".research-os");
-  const gi = join16(dir, ".gitignore");
-  if (!existsSync15(gi)) {
+  const dir = join17(packPath, ".research-os");
+  const gi = join17(dir, ".gitignore");
+  if (!existsSync16(gi)) {
     mkdirSync(dir, { recursive: true });
     writeFileSync(gi, "*\n", "utf8");
   }
@@ -6548,7 +6868,7 @@ function ensureGitIgnore(packPath) {
 function openIndexDb(opts) {
   const dbPath = indexDbPath(opts.packPath);
   if (!opts.readonly) {
-    mkdirSync(dirname3(dbPath), { recursive: true });
+    mkdirSync(dirname4(dbPath), { recursive: true });
     ensureGitIgnore(opts.packPath);
   }
   const db = new Database(dbPath, { readonly: opts.readonly ?? false, fileMustExist: opts.readonly ?? false });
@@ -6563,18 +6883,18 @@ var init_db = __esm({
 });
 
 // src/indexer/build.ts
-import { existsSync as existsSync16 } from "fs";
-import { readFile as readFile15 } from "fs/promises";
-import { join as join17, resolve as resolve12, relative as relative2 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { readFile as readFile16 } from "fs/promises";
+import { join as join18, resolve as resolve12, relative as relative2 } from "path";
 import { createHash as createHash5 } from "crypto";
 import { parse as yamlParse5 } from "yaml";
 function relPath(packPath, abs) {
   return relative2(packPath, abs).split("\\").join("/");
 }
 async function tryReadJsonl(packPath, rel, parse) {
-  const path = join17(packPath, rel);
-  if (!existsSync16(path)) return [];
-  const text = await readFile15(path, "utf8");
+  const path = join18(packPath, rel);
+  if (!existsSync17(path)) return [];
+  const text = await readFile16(path, "utf8");
   const out = [];
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -6583,22 +6903,22 @@ async function tryReadJsonl(packPath, rel, parse) {
   return out;
 }
 async function readSourceCards4(packPath) {
-  const dir = join17(packPath, "evidence", "source-cards");
-  if (!existsSync16(dir)) return [];
+  const dir = join18(packPath, "evidence", "source-cards");
+  if (!existsSync17(dir)) return [];
   const { readdir: readdir4 } = await import("fs/promises");
   const entries = await readdir4(dir);
   const cards = [];
   for (const entry of entries) {
     if (!entry.endsWith(".json")) continue;
-    const text = await readFile15(join17(dir, entry), "utf8");
+    const text = await readFile16(join18(dir, entry), "utf8");
     cards.push(SourceCardSchema.parse(JSON.parse(text)));
   }
   return cards;
 }
 async function readGateResult2(packPath, sectionId) {
-  const path = join17(packPath, "audits", `${sectionId}-gate.json`);
-  if (!existsSync16(path)) return null;
-  const text = await readFile15(path, "utf8");
+  const path = join18(packPath, "audits", `${sectionId}-gate.json`);
+  if (!existsSync17(path)) return null;
+  const text = await readFile16(path, "utf8");
   return SectionGateResultSchema.parse(JSON.parse(text));
 }
 function fileSha256(text) {
@@ -6608,8 +6928,8 @@ async function indexSection(args) {
   const { db, packPath, research, sectionId, now, counts } = args;
   const section = research.sections.find((s) => s.id === sectionId);
   if (!section) throw new SectionNotFoundError(sectionId);
-  const sectionDir = join17(packPath, "sections", sectionId);
-  if (!existsSync16(sectionDir)) throw new SectionNotFoundError(sectionId);
+  const sectionDir = join18(packPath, "sections", sectionId);
+  if (!existsSync17(sectionDir)) throw new SectionNotFoundError(sectionId);
   db.prepare("DELETE FROM sources WHERE section_id = ?").run(sectionId);
   db.prepare("DELETE FROM claims WHERE section_id = ?").run(sectionId);
   db.prepare("DELETE FROM contradictions WHERE section_id = ?").run(sectionId);
@@ -6648,9 +6968,9 @@ async function indexSection(args) {
   };
   const allCards = await readSourceCards4(packPath);
   const sectionSourceIds = /* @__PURE__ */ new Set();
-  const sourcesJsonlPath = join17(sectionDir, "sources.jsonl");
-  if (existsSync16(sourcesJsonlPath)) {
-    const text = await readFile15(sourcesJsonlPath, "utf8");
+  const sourcesJsonlPath = join18(sectionDir, "sources.jsonl");
+  if (existsSync17(sourcesJsonlPath)) {
+    const text = await readFile16(sourcesJsonlPath, "utf8");
     recordArtifact("sources_jsonl", relPath(packPath, sourcesJsonlPath), text);
     for (const line of text.split(/\r?\n/)) {
       if (!line.trim()) continue;
@@ -6660,7 +6980,7 @@ async function indexSection(args) {
   }
   for (const card of allCards) {
     if (!sectionSourceIds.has(card.source_id) && card.section_id !== sectionId) continue;
-    const cardPath = relPath(packPath, join17(packPath, "evidence", "source-cards", `${card.source_id}.json`));
+    const cardPath = relPath(packPath, join18(packPath, "evidence", "source-cards", `${card.source_id}.json`));
     db.prepare(
       `INSERT OR REPLACE INTO sources(
         source_id, section_id, url, publisher, source_type, relevance,
@@ -6694,9 +7014,9 @@ ${card.key_points.join("\n")}`;
     `sections/${sectionId}/claims.jsonl`,
     (r) => ClaimSchema.parse(r)
   );
-  const claimsArtifact = relPath(packPath, join17(sectionDir, "claims.jsonl"));
-  if (existsSync16(join17(sectionDir, "claims.jsonl"))) {
-    const text = await readFile15(join17(sectionDir, "claims.jsonl"), "utf8");
+  const claimsArtifact = relPath(packPath, join18(sectionDir, "claims.jsonl"));
+  if (existsSync17(join18(sectionDir, "claims.jsonl"))) {
+    const text = await readFile16(join18(sectionDir, "claims.jsonl"), "utf8");
     recordArtifact("claims_jsonl", claimsArtifact, text);
   }
   for (const claim of claims) {
@@ -6733,9 +7053,9 @@ ${claim.evidence_excerpt}`;
     `sections/${sectionId}/contradictions.jsonl`,
     (r) => ContradictionSchema.parse(r)
   );
-  const contradictionsArtifact = relPath(packPath, join17(sectionDir, "contradictions.jsonl"));
-  if (existsSync16(join17(sectionDir, "contradictions.jsonl"))) {
-    const text = await readFile15(join17(sectionDir, "contradictions.jsonl"), "utf8");
+  const contradictionsArtifact = relPath(packPath, join18(sectionDir, "contradictions.jsonl"));
+  if (existsSync17(join18(sectionDir, "contradictions.jsonl"))) {
+    const text = await readFile16(join18(sectionDir, "contradictions.jsonl"), "utf8");
     recordArtifact("contradictions_jsonl", contradictionsArtifact, text);
   }
   for (const c of contradictions) {
@@ -6771,10 +7091,10 @@ ${c.severity}`;
     `audits/${sectionId}-findings.jsonl`,
     (r) => ReviewFindingSchema.parse(r)
   );
-  const findingsArtifact = relPath(packPath, join17(packPath, "audits", `${sectionId}-findings.jsonl`));
-  const findingsAbs = join17(packPath, "audits", `${sectionId}-findings.jsonl`);
-  if (existsSync16(findingsAbs)) {
-    const text = await readFile15(findingsAbs, "utf8");
+  const findingsArtifact = relPath(packPath, join18(packPath, "audits", `${sectionId}-findings.jsonl`));
+  const findingsAbs = join18(packPath, "audits", `${sectionId}-findings.jsonl`);
+  if (existsSync17(findingsAbs)) {
+    const text = await readFile16(findingsAbs, "utf8");
     recordArtifact("findings_jsonl", findingsArtifact, text);
   }
   const findingById = /* @__PURE__ */ new Map();
@@ -6811,10 +7131,10 @@ ${f.evidence}`;
     `sections/${sectionId}/claim-reviews.jsonl`,
     (r) => ClaimReviewSchema.parse(r)
   );
-  const reviewsArtifact = relPath(packPath, join17(sectionDir, "claim-reviews.jsonl"));
-  const reviewsAbs = join17(sectionDir, "claim-reviews.jsonl");
-  if (existsSync16(reviewsAbs)) {
-    const text = await readFile15(reviewsAbs, "utf8");
+  const reviewsArtifact = relPath(packPath, join18(sectionDir, "claim-reviews.jsonl"));
+  const reviewsAbs = join18(sectionDir, "claim-reviews.jsonl");
+  if (existsSync17(reviewsAbs)) {
+    const text = await readFile16(reviewsAbs, "utf8");
     recordArtifact("claim_reviews_jsonl", reviewsArtifact, text);
   }
   for (const r of reviews) {
@@ -6839,8 +7159,8 @@ ${r.reason}`;
   }
   const gate2 = await readGateResult2(packPath, sectionId);
   if (gate2) {
-    const gateArtifact = relPath(packPath, join17(packPath, "audits", `${sectionId}-gate.json`));
-    const gateText = await readFile15(join17(packPath, "audits", `${sectionId}-gate.json`), "utf8");
+    const gateArtifact = relPath(packPath, join18(packPath, "audits", `${sectionId}-gate.json`));
+    const gateText = await readFile16(join18(packPath, "audits", `${sectionId}-gate.json`), "utf8");
     recordArtifact("gate_json", gateArtifact, gateText);
     db.prepare(
       `INSERT OR REPLACE INTO gate_results(
@@ -6873,9 +7193,9 @@ ${gate2.next_actions.join("\n")}`;
     "evidence/fetch-log.jsonl",
     (r) => FetchReceiptSchema.parse(r)
   );
-  const fetchLogAbs = join17(packPath, "evidence", "fetch-log.jsonl");
-  if (existsSync16(fetchLogAbs)) {
-    const text = await readFile15(fetchLogAbs, "utf8");
+  const fetchLogAbs = join18(packPath, "evidence", "fetch-log.jsonl");
+  if (existsSync17(fetchLogAbs)) {
+    const text = await readFile16(fetchLogAbs, "utf8");
     recordArtifact("fetch_log_jsonl", relPath(packPath, fetchLogAbs), text);
   }
   for (const receipt of allReceipts.filter((r) => r.section_id === sectionId)) {
@@ -6911,9 +7231,9 @@ async function indexPackAuditRollups(db, packPath, _now) {
     db.prepare(`DELETE FROM facts_fts WHERE record_type = ? AND record_id = ?`).run(f.recordType, f.recordId);
   }
   for (const f of ROLLUP_FILES) {
-    const abs = join17(packPath, "audits", f.filename);
-    if (!existsSync16(abs)) continue;
-    const text = await readFile15(abs, "utf8");
+    const abs = join18(packPath, "audits", f.filename);
+    if (!existsSync17(abs)) continue;
+    const text = await readFile16(abs, "utf8");
     insertFts.run(
       f.recordType,
       f.recordId,
@@ -6925,8 +7245,8 @@ async function indexPackAuditRollups(db, packPath, _now) {
 }
 async function build(options) {
   const packPath = options.packPath ? resolve12(options.packPath) : process.cwd();
-  if (!existsSync16(join17(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
-  const research = ResearchYamlSchema.parse(yamlParse5(await readFile15(join17(packPath, "research.yaml"), "utf8")));
+  if (!existsSync17(join18(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
+  const research = ResearchYamlSchema.parse(yamlParse5(await readFile16(join18(packPath, "research.yaml"), "utf8")));
   const targets = options.sectionId ? [options.sectionId] : options.all ? research.sections.map((s) => s.id) : research.sections.map((s) => s.id);
   if (targets.length === 0) {
     throw new Error("No sections to index. Add at least one section to the pack.");
@@ -6983,7 +7303,7 @@ var init_build = __esm({
 });
 
 // src/indexer/query.ts
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 import { resolve as resolve13 } from "path";
 function escapeFtsTerm(term) {
   const trimmed = term.trim();
@@ -6994,8 +7314,8 @@ function escapeFtsTerm(term) {
 function query(options) {
   const packPath = options.packPath ? resolve13(options.packPath) : process.cwd();
   const dbPath = indexDbPath(packPath);
-  if (!existsSync17(packPath)) throw new PackNotFoundError(packPath);
-  if (!existsSync17(dbPath)) throw new IndexNotBuiltError(dbPath);
+  if (!existsSync18(packPath)) throw new PackNotFoundError(packPath);
+  if (!existsSync18(dbPath)) throw new IndexNotBuiltError(dbPath);
   const db = openIndexDb({ packPath, readonly: true });
   const limit = options.limit ?? 25;
   const ftsTerm = escapeFtsTerm(options.term);
@@ -7069,16 +7389,16 @@ var init_query = __esm({
 });
 
 // src/indexer/export.ts
-import { existsSync as existsSync18 } from "fs";
-import { mkdir as mkdir13, writeFile as writeFile14 } from "fs/promises";
-import { dirname as dirname4, join as join18, resolve as resolve14 } from "path";
+import { existsSync as existsSync19 } from "fs";
+import { mkdir as mkdir14, writeFile as writeFile14 } from "fs/promises";
+import { dirname as dirname5, join as join19, resolve as resolve14 } from "path";
 async function exportRepoKnowledge(options) {
   const packPath = options.packPath ? resolve14(options.packPath) : process.cwd();
-  if (!existsSync18(packPath)) throw new PackNotFoundError(packPath);
+  if (!existsSync19(packPath)) throw new PackNotFoundError(packPath);
   const dbPath = indexDbPath(packPath);
-  if (!existsSync18(dbPath)) throw new IndexNotBuiltError(dbPath);
-  const outPath = options.outPath ? resolve14(options.outPath) : join18(packPath, "evidence", "repo-knowledge", "research-os-facts.jsonl");
-  await mkdir13(dirname4(outPath), { recursive: true });
+  if (!existsSync19(dbPath)) throw new IndexNotBuiltError(dbPath);
+  const outPath = options.outPath ? resolve14(options.outPath) : join19(packPath, "evidence", "repo-knowledge", "research-os-facts.jsonl");
+  await mkdir14(dirname5(outPath), { recursive: true });
   const db = openIndexDb({ packPath, readonly: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const facts = [];
@@ -7237,8 +7557,8 @@ async function syncRepoKnowledge(options) {
     };
   }
   const exportResult = await exportRepoKnowledge({ packPath });
-  const { readFile: readFile24 } = await import("fs/promises");
-  const text = await readFile24(exportResult.outPath, "utf8");
+  const { readFile: readFile25 } = await import("fs/promises");
+  const text = await readFile25(exportResult.outPath, "utf8");
   const facts = text.split(/\r?\n/).filter((l) => l.trim().length > 0).map((l) => JSON.parse(l));
   try {
     const r = await rk.ingestFacts({ facts, namespace: "research-os" });
@@ -7278,26 +7598,26 @@ var init_indexer = __esm({
 });
 
 // src/dispositions/schema.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var ClaimSynthesisDispositionStatusSchema, ClaimSynthesisDispositionSchema;
 var init_schema12 = __esm({
   "src/dispositions/schema.ts"() {
     "use strict";
-    ClaimSynthesisDispositionStatusSchema = z13.enum([
+    ClaimSynthesisDispositionStatusSchema = z14.enum([
       "parked_not_for_synthesis",
       "preserved_for_human_note",
       "needs_human_review_excluded",
       "out_of_bounds_regression_fixture"
     ]);
-    ClaimSynthesisDispositionSchema = z13.object({
-      claim_id: z13.string().min(1),
-      section_id: z13.string().min(1),
+    ClaimSynthesisDispositionSchema = z14.object({
+      claim_id: z14.string().min(1),
+      section_id: z14.string().min(1),
       status: ClaimSynthesisDispositionStatusSchema,
-      reason: z13.string().min(4),
-      decided_by: z13.string().min(1),
-      authorized_by: z13.string().min(1),
-      source: z13.string().min(1),
-      created_at: z13.string().min(1)
+      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)
     });
   }
 });
@@ -7628,91 +7948,91 @@ var init_derive = __esm({
 });
 
 // src/cowork/schema.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var HandoffModeSchema, IndexStatusSchema, ProvenanceSummarySchema, SectionStateSchema, WaiverEntrySchema, GateVerdictEntrySchema, ReviewDecisionCountSchema, CoworkHandoffPayloadSchema;
 var init_schema13 = __esm({
   "src/cowork/schema.ts"() {
     "use strict";
-    HandoffModeSchema = z14.enum([
+    HandoffModeSchema = z15.enum([
       "repair_required",
       "synthesis_ready",
       "human_review_required"
     ]);
-    IndexStatusSchema = z14.enum(["present", "missing"]);
-    ProvenanceSummarySchema = z14.object({
-      accepted_count: z14.number().int().nonnegative(),
-      rejected_count: z14.number().int().nonnegative(),
-      triage_parked_count: z14.number().int().nonnegative(),
-      needs_review_undispositioned_count: z14.number().int().nonnegative(),
-      dispositioned_count: z14.number().int().nonnegative(),
-      dispositioned_breakdown: z14.object({
-        parked_not_for_synthesis: z14.number().int().nonnegative(),
-        preserved_for_human_note: z14.number().int().nonnegative(),
-        needs_human_review_excluded: z14.number().int().nonnegative(),
-        out_of_bounds_regression_fixture: z14.number().int().nonnegative()
+    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()
       }),
-      active_repair_blockers: z14.number().int().nonnegative(),
-      active_unresolved_contradictions: z14.number().int().nonnegative(),
-      waivers_active: z14.array(z14.string()),
-      overrides_applied_count: z14.number().int().nonnegative()
-    });
-    SectionStateSchema = z14.object({
-      section_id: z14.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      purpose: z14.string(),
-      status: z14.string(),
-      has_gate_run: z14.boolean(),
-      has_review_run: z14.boolean(),
-      gate_verdict: z14.string().nullable(),
-      synthesis_eligible: z14.boolean(),
-      accepted_claim_ids: z14.array(z14.string()),
-      repair_claim_ids: z14.array(z14.string()),
-      rejected_claim_ids: z14.array(z14.string()),
-      dispositioned_claim_ids: z14.array(z14.string()).default([]),
-      candidate_claims_total: z14.number().int().nonnegative(),
-      unresolved_contradiction_ids: z14.array(z14.string()),
-      blocking_reasons: z14.array(z14.string()),
-      active_blockers: z14.array(z14.string()).default([]),
-      blocking_contradictions_unresolved: z14.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(),
       provenance_summary: ProvenanceSummarySchema.optional()
     });
-    WaiverEntrySchema = z14.object({
-      scope: z14.enum(["pack", "gate"]),
-      family: z14.string(),
-      reason: z14.string(),
-      compensating_controls: z14.array(z14.string()),
-      applied_to: z14.string()
-    });
-    GateVerdictEntrySchema = z14.object({
-      section_id: z14.string(),
-      verdict: z14.string(),
-      synthesis_eligible: z14.boolean()
-    });
-    ReviewDecisionCountSchema = z14.object({
-      section_id: z14.string(),
-      decision: z14.string(),
-      count: z14.number().int().nonnegative()
-    });
-    CoworkHandoffPayloadSchema = z14.object({
-      pack_id: z14.string(),
-      pack_topic: z14.string(),
-      generated_at: z14.string(),
+    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(),
       mode: HandoffModeSchema,
-      synthesis_allowed: z14.boolean(),
-      summary: z14.string(),
-      sections: z14.array(SectionStateSchema),
-      accepted_claim_ids: z14.array(z14.string()),
-      repair_claim_ids: z14.array(z14.string()),
-      blocked_claim_ids: z14.array(z14.string()),
-      dispositioned_claim_ids: z14.array(z14.string()).default([]),
-      unresolved_contradiction_ids: z14.array(z14.string()),
-      waivers: z14.array(WaiverEntrySchema),
-      gate_verdicts: z14.array(GateVerdictEntrySchema),
-      review_decisions: z14.array(ReviewDecisionCountSchema),
-      recommended_next_actions: z14.array(z14.string()),
-      allowed_write_paths: z14.array(z14.string()),
-      forbidden_actions: z14.array(z14.string()),
+      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()),
       index_status: IndexStatusSchema,
-      warnings: z14.array(z14.string())
+      warnings: z15.array(z15.string())
     });
   }
 });
@@ -7891,19 +8211,19 @@ var init_markdown4 = __esm({
 });
 
 // src/cowork/run.ts
-import { existsSync as existsSync19 } from "fs";
-import { mkdir as mkdir14, readFile as readFile16, writeFile as writeFile15 } from "fs/promises";
-import { join as join19, resolve as resolve16 } from "path";
+import { existsSync as existsSync20 } from "fs";
+import { mkdir as mkdir15, readFile as readFile17, writeFile as writeFile15 } from "fs/promises";
+import { join as join20, resolve as resolve16 } from "path";
 import { parse as yamlParse6 } from "yaml";
 async function loadResearchYaml4(packPath) {
-  const yamlPath = join19(packPath, "research.yaml");
-  if (!existsSync19(yamlPath)) throw new PackNotFoundError(packPath);
-  const text = await readFile16(yamlPath, "utf8");
+  const yamlPath = join20(packPath, "research.yaml");
+  if (!existsSync20(yamlPath)) throw new PackNotFoundError(packPath);
+  const text = await readFile17(yamlPath, "utf8");
   return ResearchYamlSchema.parse(yamlParse6(text));
 }
 async function readJsonl3(path, parse, warnings) {
-  if (!existsSync19(path)) return [];
-  const text = await readFile16(path, "utf8");
+  if (!existsSync20(path)) return [];
+  const text = await readFile17(path, "utf8");
   const out = [];
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -7917,10 +8237,10 @@ async function readJsonl3(path, parse, warnings) {
   return out;
 }
 async function readGate(packPath, sectionId, warnings) {
-  const path = join19(packPath, "audits", `${sectionId}-gate.json`);
-  if (!existsSync19(path)) return null;
+  const path = join20(packPath, "audits", `${sectionId}-gate.json`);
+  if (!existsSync20(path)) return null;
   try {
-    const text = await readFile16(path, "utf8");
+    const text = await readFile17(path, "utf8");
     return SectionGateResultSchema.parse(JSON.parse(text));
   } catch (err) {
     warnings.push(`malformed gate result at audits/${sectionId}-gate.json: ${err instanceof Error ? err.message : err}`);
@@ -7935,35 +8255,35 @@ async function handoff(options) {
   for (const section of research.sections) {
     const sid = section.id;
     const claims = await readJsonl3(
-      join19(packPath, "sections", sid, "claims.jsonl"),
+      join20(packPath, "sections", sid, "claims.jsonl"),
       (r) => ClaimSchema.parse(r),
       warnings
     );
     const candidateClaims = claims.filter((c) => c.review_state === "candidate");
     const claimReviews = await readJsonl3(
-      join19(packPath, "sections", sid, "claim-reviews.jsonl"),
+      join20(packPath, "sections", sid, "claim-reviews.jsonl"),
       (r) => ClaimReviewSchema.parse(r),
       warnings
     );
     const contradictions = await readJsonl3(
-      join19(packPath, "sections", sid, "contradictions.jsonl"),
+      join20(packPath, "sections", sid, "contradictions.jsonl"),
       (r) => ContradictionSchema.parse(r),
       warnings
     );
     const resolutions = await readJsonl3(
-      join19(packPath, "sections", sid, "contradiction-resolutions.jsonl"),
+      join20(packPath, "sections", sid, "contradiction-resolutions.jsonl"),
       (r) => ContradictionResolutionSchema.parse(r),
       warnings
     );
     const dispositions = await readJsonl3(
-      join19(packPath, "sections", sid, "claim-synthesis-dispositions.jsonl"),
+      join20(packPath, "sections", sid, "claim-synthesis-dispositions.jsonl"),
       (r) => ClaimSynthesisDispositionSchema.parse(r),
       warnings
     );
     const gate2 = await readGate(packPath, sid, warnings);
     perSection.set(sid, { gate: gate2, candidateClaims, claimReviews, contradictions, resolutions, dispositions });
   }
-  const indexExists = existsSync19(indexDbPath(packPath));
+  const indexExists = existsSync20(indexDbPath(packPath));
   if (!indexExists) {
     warnings.push(
       "Pack-local index missing at .research-os/index.sqlite \u2014 Cowork can still operate from canonical artifacts, but `research-os query` will refuse until you run `research-os index build --all`."
@@ -7979,10 +8299,10 @@ async function handoff(options) {
       warnings
     })
   );
-  const handoffsDir = join19(packPath, "handoffs");
-  await mkdir14(handoffsDir, { recursive: true });
-  const jsonPath = join19(handoffsDir, "cowork-handoff.json");
-  const mdPath = join19(handoffsDir, "cowork-master.md");
+  const handoffsDir = join20(packPath, "handoffs");
+  await mkdir15(handoffsDir, { recursive: true });
+  const jsonPath = join20(handoffsDir, "cowork-handoff.json");
+  const mdPath = join20(handoffsDir, "cowork-master.md");
   await writeFile15(jsonPath, JSON.stringify(payload, null, 2), "utf8");
   await writeFile15(mdPath, renderCoworkMaster(payload), "utf8");
   return {
@@ -8262,86 +8582,86 @@ var init_derive2 = __esm({
 });
 
 // src/synth/schema.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var SectionAcceptedSummarySchema, ClaimClusterSchema, SharedSourceSchema, ScopeOverlapSchema, CrossSectionContradictionRefSchema, WaiverDependencySchema, AllowedSynthesisInputSchema, ForbiddenInputSchema, CrossSectionMapSchema;
 var init_schema14 = __esm({
   "src/synth/schema.ts"() {
     "use strict";
-    SectionAcceptedSummarySchema = z15.object({
-      section_id: z15.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      purpose: z15.string(),
-      status: z15.string(),
-      accepted_claim_ids: z15.array(z15.string()),
-      excluded_reason: z15.string().nullable()
-    });
-    ClaimClusterSchema = z15.object({
-      cluster_id: z15.string(),
-      shared_source_ids: z15.array(z15.string()),
-      member_claim_ids: z15.array(z15.string()).min(1),
-      spans_sections: z15.array(z15.string())
-    });
-    SharedSourceSchema = z15.object({
-      source_id: z15.string(),
-      publisher: z15.string().nullable(),
-      source_type: z15.string(),
-      used_by_claim_ids: z15.array(z15.string()),
-      spans_sections: z15.array(z15.string())
-    });
-    ScopeOverlapSchema = z15.object({
-      claim_a: z15.string(),
-      claim_b: z15.string(),
-      scope_a: z15.string().nullable(),
-      scope_b: z15.string().nullable(),
-      jaccard: z15.number().min(0).max(1),
-      cross_section: z15.boolean(),
-      warning: z15.string()
-    });
-    CrossSectionContradictionRefSchema = z15.object({
-      contradiction_id: z15.string(),
-      claim_ids: z15.array(z15.string()),
-      sections: z15.array(z15.string()),
-      type: z15.string(),
-      severity: z15.string(),
-      status: z15.string()
-    });
-    WaiverDependencySchema = z15.object({
-      scope: z15.enum(["pack", "gate"]),
-      family: z15.string(),
-      reason: z15.string(),
-      compensating_controls: z15.array(z15.string()),
-      applied_to: z15.string(),
-      must_disclose_in: z15.enum(["decision-brief.md", "final-report.md", "both"])
+    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()
     });
-    AllowedSynthesisInputSchema = z15.object({
-      claim_id: z15.string(),
-      section_id: z15.string(),
-      artifact_path: z15.string(),
-      asserts: z15.string(),
-      scope: z15.string().nullable(),
-      not: z15.string().nullable(),
-      source_ids: z15.array(z15.string())
-    });
-    ForbiddenInputSchema = z15.object({
-      claim_id: z15.string(),
-      section_id: z15.string(),
-      decision: z15.string(),
-      reason: z15.string()
+    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())
     });
-    CrossSectionMapSchema = z15.object({
-      pack_id: z15.string(),
-      pack_topic: z15.string(),
-      pack_decision: z15.string(),
-      generated_at: z15.string(),
-      accepted_claim_ids: z15.array(z15.string()),
-      sections: z15.array(SectionAcceptedSummarySchema),
-      claim_clusters: z15.array(ClaimClusterSchema),
-      shared_sources: z15.array(SharedSourceSchema),
-      scope_overlaps: z15.array(ScopeOverlapSchema),
-      cross_section_contradictions: z15.array(CrossSectionContradictionRefSchema),
-      waiver_dependencies: z15.array(WaiverDependencySchema),
-      open_questions: z15.array(z15.string()),
-      allowed_synthesis_inputs: z15.array(AllowedSynthesisInputSchema),
-      forbidden_inputs: z15.array(ForbiddenInputSchema)
+    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"])
+    });
+    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()
+    });
+    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)
     });
   }
 });
@@ -8601,13 +8921,13 @@ var init_markdown5 = __esm({
 });
 
 // src/synth/run.ts
-import { existsSync as existsSync20 } from "fs";
-import { mkdir as mkdir15, readFile as readFile17, writeFile as writeFile16 } from "fs/promises";
-import { join as join20, resolve as resolve17 } from "path";
+import { existsSync as existsSync21 } from "fs";
+import { mkdir as mkdir16, readFile as readFile18, writeFile as writeFile16 } from "fs/promises";
+import { join as join21, resolve as resolve17 } from "path";
 import { parse as yamlParse7 } from "yaml";
 async function readJsonl4(path, parse) {
-  if (!existsSync20(path)) return [];
-  const text = await readFile17(path, "utf8");
+  if (!existsSync21(path)) return [];
+  const text = await readFile18(path, "utf8");
   const out = [];
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -8616,27 +8936,27 @@ async function readJsonl4(path, parse) {
   return out;
 }
 async function readSourceCards5(packPath) {
-  const dir = join20(packPath, "evidence", "source-cards");
-  if (!existsSync20(dir)) return [];
+  const dir = join21(packPath, "evidence", "source-cards");
+  if (!existsSync21(dir)) return [];
   const { readdir: readdir4 } = await import("fs/promises");
   const entries = await readdir4(dir);
   const cards = [];
   for (const entry of entries) {
     if (!entry.endsWith(".json")) continue;
-    const text = await readFile17(join20(dir, entry), "utf8");
+    const text = await readFile18(join21(dir, entry), "utf8");
     cards.push(SourceCardSchema.parse(JSON.parse(text)));
   }
   return cards;
 }
 async function workspace(options) {
   const packPath = options.packPath ? resolve17(options.packPath) : process.cwd();
-  const yamlPath = join20(packPath, "research.yaml");
-  if (!existsSync20(yamlPath)) throw new PackNotFoundError(packPath);
-  const research = ResearchYamlSchema.parse(yamlParse7(await readFile17(yamlPath, "utf8")));
-  const handoffPath = join20(packPath, "handoffs", "cowork-handoff.json");
-  if (!existsSync20(handoffPath)) throw new HandoffNotFoundError();
+  const yamlPath = join21(packPath, "research.yaml");
+  if (!existsSync21(yamlPath)) throw new PackNotFoundError(packPath);
+  const research = ResearchYamlSchema.parse(yamlParse7(await readFile18(yamlPath, "utf8")));
+  const handoffPath = join21(packPath, "handoffs", "cowork-handoff.json");
+  if (!existsSync21(handoffPath)) throw new HandoffNotFoundError();
   const handoff2 = CoworkHandoffPayloadSchema.parse(
-    JSON.parse(await readFile17(handoffPath, "utf8"))
+    JSON.parse(await readFile18(handoffPath, "utf8"))
   );
   if (handoff2.mode !== "synthesis_ready") {
     return {
@@ -8658,21 +8978,21 @@ async function workspace(options) {
     claimsBySection.set(
       section.id,
       await readJsonl4(
-        join20(packPath, "sections", section.id, "claims.jsonl"),
+        join21(packPath, "sections", section.id, "claims.jsonl"),
         (r) => ClaimSchema.parse(r)
       )
     );
     reviewsBySection.set(
       section.id,
       await readJsonl4(
-        join20(packPath, "sections", section.id, "claim-reviews.jsonl"),
+        join21(packPath, "sections", section.id, "claim-reviews.jsonl"),
         (r) => ClaimReviewSchema.parse(r)
       )
     );
     contradictionsBySection.set(
       section.id,
       await readJsonl4(
-        join20(packPath, "sections", section.id, "contradictions.jsonl"),
+        join21(packPath, "sections", section.id, "contradictions.jsonl"),
         (r) => ContradictionSchema.parse(r)
       )
     );
@@ -8689,17 +9009,17 @@ async function workspace(options) {
       generatedAt: (/* @__PURE__ */ new Date()).toISOString()
     })
   );
-  const synthDir = join20(packPath, "synthesis");
-  await mkdir15(synthDir, { recursive: true });
+  const synthDir = join21(packPath, "synthesis");
+  await mkdir16(synthDir, { recursive: true });
   const filesWritten = [];
   const writeIfAbsent = async (relPath2, content) => {
-    const abs = join20(synthDir, relPath2);
-    if (existsSync20(abs)) return;
+    const abs = join21(synthDir, relPath2);
+    if (existsSync21(abs)) return;
     await writeFile16(abs, content, "utf8");
     filesWritten.push(abs);
   };
   const writeAlways = async (relPath2, content) => {
-    const abs = join20(synthDir, relPath2);
+    const abs = join21(synthDir, relPath2);
     await writeFile16(abs, content, "utf8");
     filesWritten.push(abs);
   };
@@ -9509,179 +9829,179 @@ var init_aggregate = __esm({
 });
 
 // src/audit/schema.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var PackVerdictSchema, HandoffModeSchema2, OrphanClaimRowSchema, StaleSourceRowSchema, WeakSourceRowSchema, UnresolvedContradictionRowSchema, ScopeWideningRiskRowSchema, SourceDiversityGapRowSchema, SynthesisReadinessRowSchema, PackAuditPayloadSchema;
 var init_schema15 = __esm({
   "src/audit/schema.ts"() {
     "use strict";
-    PackVerdictSchema = z16.enum([
+    PackVerdictSchema = z17.enum([
       "ready_for_synthesis",
       "repair_required",
       "human_review_required",
       "blocked"
     ]);
-    HandoffModeSchema2 = z16.enum([
+    HandoffModeSchema2 = z17.enum([
       "repair_required",
       "synthesis_ready",
       "human_review_required",
       "unknown"
     ]);
-    OrphanClaimRowSchema = z16.object({
-      claim_id: z16.string(),
-      section_id: z16.string(),
-      reason: z16.enum([
+    OrphanClaimRowSchema = z17.object({
+      claim_id: z17.string(),
+      section_id: z17.string(),
+      reason: z17.enum([
         "missing_source_card",
         "missing_source_hash",
         "missing_evidence_excerpt",
         "unresolvable_source_id"
       ]),
-      details: z16.string(),
-      artifact_path: z16.string()
-    });
-    StaleSourceRowSchema = z16.object({
-      source_id: z16.string(),
-      section_id: z16.string(),
-      publisher: z16.string().nullable(),
-      reason: z16.enum(["too_old", "missing_date", "unparseable_date"]),
-      details: z16.string(),
-      artifact_path: z16.string(),
-      policy: z16.object({
-        required: z16.boolean(),
-        max_source_age_months: z16.number().int().nullable(),
-        stale_source_policy: z16.enum(["warn", "fail"])
+      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"])
       })
     });
-    WeakSourceRowSchema = z16.object({
-      reason: z16.enum([
+    WeakSourceRowSchema = z17.object({
+      reason: z17.enum([
         "source_cluster_monopoly",
         "low_independent_publishers",
         "missing_primary_source",
         "excessive_type_imbalance",
         "failed_fetches_reducing_floor"
       ]),
-      section_id: z16.string(),
-      details: z16.string(),
-      evidence_ids: z16.array(z16.string()),
-      artifact_path: z16.string()
-    });
-    UnresolvedContradictionRowSchema = z16.object({
-      contradiction_id: z16.string(),
-      section_id: z16.string(),
-      type: z16.string(),
-      severity: z16.string(),
-      status: z16.string(),
-      claim_ids: z16.array(z16.string()),
-      artifact_path: z16.string()
-    });
-    ScopeWideningRiskRowSchema = z16.object({
-      reason: z16.enum([
+      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([
         "overgeneralization_finding",
         "scope_null_in_use",
         "missing_not_flagged",
         "contextual_to_universal_risk"
       ]),
-      claim_id: z16.string(),
-      section_id: z16.string(),
-      details: z16.string(),
-      artifact_path: z16.string()
+      claim_id: z17.string(),
+      section_id: z17.string(),
+      details: z17.string(),
+      artifact_path: z17.string()
     });
-    SourceDiversityGapRowSchema = z16.object({
-      reason: z16.enum([
+    SourceDiversityGapRowSchema = z17.object({
+      reason: z17.enum([
         "section_publisher_monopoly",
         "low_section_publisher_count",
         "cross_section_publisher_overlap",
         "section_has_no_sources"
       ]),
-      section_id: z16.string(),
-      details: z16.string(),
-      evidence_ids: z16.array(z16.string())
-    });
-    SynthesisReadinessRowSchema = z16.object({
-      section_id: z16.string(),
-      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(),
-      candidate_claims: z16.number().int().nonnegative(),
-      accepted_claims: z16.number().int().nonnegative(),
-      repair_claims: z16.number().int().nonnegative(),
-      rejected_claims: z16.number().int().nonnegative(),
-      dispositioned_claims: z16.number().int().nonnegative(),
-      blocking_reasons: z16.array(z16.string()),
+      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()),
       cowork_handoff_mode: HandoffModeSchema2,
-      workspace_allowed: z16.boolean()
+      workspace_allowed: z17.boolean()
     });
-    PackAuditPayloadSchema = z16.object({
-      pack_id: z16.string(),
-      pack_topic: z16.string(),
-      generated_at: z16.string(),
+    PackAuditPayloadSchema = z17.object({
+      pack_id: z17.string(),
+      pack_topic: z17.string(),
+      generated_at: z17.string(),
       verdict: PackVerdictSchema,
-      synthesis_allowed: z16.boolean(),
-      section_summaries: z16.array(SynthesisReadinessRowSchema),
-      claim_summary: z16.object({
-        total: z16.number().int().nonnegative(),
-        candidate: z16.number().int().nonnegative(),
-        accepted_for_synthesis: z16.number().int().nonnegative(),
-        rejected: z16.number().int().nonnegative(),
-        needs_repair: z16.number().int().nonnegative(),
-        dispositioned: z16.number().int().nonnegative(),
-        no_review: z16.number().int().nonnegative(),
-        with_evidence_excerpt: z16.number().int().nonnegative(),
-        with_source_hashes: z16.number().int().nonnegative(),
-        scope_null: z16.number().int().nonnegative(),
-        not_null: z16.number().int().nonnegative(),
-        orphans: z16.number().int().nonnegative()
+      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()
       }),
-      source_summary: z16.object({
-        total: z16.number().int().nonnegative(),
-        primary: z16.number().int().nonnegative(),
-        secondary: z16.number().int().nonnegative(),
-        forum: z16.number().int().nonnegative(),
-        benchmark: z16.number().int().nonnegative(),
-        docs: z16.number().int().nonnegative(),
-        unknown: z16.number().int().nonnegative(),
-        independent_publishers: z16.number().int().nonnegative(),
-        failed_fetches: z16.number().int().nonnegative(),
-        sections_with_sources: z16.number().int().nonnegative(),
-        sections_without_sources: z16.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()
       }),
-      contradiction_summary: z16.object({
-        total: z16.number().int().nonnegative(),
-        unresolved: z16.number().int().nonnegative(),
-        blocking: z16.number().int().nonnegative(),
-        reconciled: z16.number().int().nonnegative(),
-        preserved_deliberately: z16.number().int().nonnegative(),
-        rejected: z16.number().int().nonnegative(),
-        by_type: z16.record(z16.string(), z16.number().int().nonnegative()),
-        sections_with_clean_ledger: z16.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()
       }),
-      review_summary: z16.object({
-        sections_with_review_run: z16.number().int().nonnegative(),
-        sections_without_review_run: z16.number().int().nonnegative(),
-        decision_counts: z16.record(z16.string(), z16.number().int().nonnegative()),
-        blocking_findings: z16.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()
       }),
-      waiver_summary: z16.object({
-        total: z16.number().int().nonnegative(),
-        invalid: z16.number().int().nonnegative(),
-        by_family: z16.record(z16.string(), z16.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())
       }),
-      readiness_summary: z16.object({
-        total_sections: z16.number().int().nonnegative(),
-        ready_sections: z16.number().int().nonnegative(),
-        repair_sections: z16.number().int().nonnegative(),
-        blocked_sections: z16.number().int().nonnegative(),
-        no_gate_sections: z16.number().int().nonnegative(),
-        no_review_sections: z16.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(),
         cowork_handoff_mode: HandoffModeSchema2,
-        workspace_allowed: z16.boolean()
+        workspace_allowed: z17.boolean()
       }),
-      audit_files: z16.array(z16.string()),
-      blocking_reasons: z16.array(z16.string()),
-      warnings: z16.array(z16.string()),
-      next_actions: z16.array(z16.string())
+      audit_files: z17.array(z17.string()),
+      blocking_reasons: z17.array(z17.string()),
+      warnings: z17.array(z17.string()),
+      next_actions: z17.array(z17.string())
     });
   }
 });
@@ -9903,13 +10223,13 @@ var init_markdown6 = __esm({
 });
 
 // src/audit/run.ts
-import { existsSync as existsSync21 } from "fs";
-import { mkdir as mkdir16, readFile as readFile18, writeFile as writeFile17 } from "fs/promises";
-import { join as join21, resolve as resolve18 } from "path";
+import { existsSync as existsSync22 } from "fs";
+import { mkdir as mkdir17, readFile as readFile19, writeFile as writeFile17 } from "fs/promises";
+import { join as join22, resolve as resolve18 } from "path";
 import { parse as yamlParse8 } from "yaml";
 async function readJsonl5(path, parse, warnings) {
-  if (!existsSync21(path)) return [];
-  const text = await readFile18(path, "utf8");
+  if (!existsSync22(path)) return [];
+  const text = await readFile19(path, "utf8");
   const out = [];
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -9922,15 +10242,15 @@ async function readJsonl5(path, parse, warnings) {
   return out;
 }
 async function readSourceCards6(packPath, warnings) {
-  const dir = join21(packPath, "evidence", "source-cards");
-  if (!existsSync21(dir)) return [];
+  const dir = join22(packPath, "evidence", "source-cards");
+  if (!existsSync22(dir)) return [];
   const { readdir: readdir4 } = await import("fs/promises");
   const entries = await readdir4(dir);
   const cards = [];
   for (const entry of entries) {
     if (!entry.endsWith(".json")) continue;
     try {
-      const text = await readFile18(join21(dir, entry), "utf8");
+      const text = await readFile19(join22(dir, entry), "utf8");
       cards.push(SourceCardSchema.parse(JSON.parse(text)));
     } catch (err) {
       warnings.push(`malformed source card ${entry}: ${err instanceof Error ? err.message : "parse error"}`);
@@ -9939,29 +10259,29 @@ async function readSourceCards6(packPath, warnings) {
   return cards;
 }
 async function readGate2(packPath, sectionId, warnings) {
-  const path = join21(packPath, "audits", `${sectionId}-gate.json`);
-  if (!existsSync21(path)) return null;
+  const path = join22(packPath, "audits", `${sectionId}-gate.json`);
+  if (!existsSync22(path)) return null;
   try {
-    return SectionGateResultSchema.parse(JSON.parse(await readFile18(path, "utf8")));
+    return SectionGateResultSchema.parse(JSON.parse(await readFile19(path, "utf8")));
   } catch (err) {
     warnings.push(`malformed gate result for ${sectionId}: ${err instanceof Error ? err.message : "parse error"}`);
     return null;
   }
 }
 async function readHandoff(packPath, warnings) {
-  const path = join21(packPath, "handoffs", "cowork-handoff.json");
-  if (!existsSync21(path)) return null;
+  const path = join22(packPath, "handoffs", "cowork-handoff.json");
+  if (!existsSync22(path)) return null;
   try {
-    return CoworkHandoffPayloadSchema.parse(JSON.parse(await readFile18(path, "utf8")));
+    return CoworkHandoffPayloadSchema.parse(JSON.parse(await readFile19(path, "utf8")));
   } catch (err) {
     warnings.push(`malformed handoff: ${err instanceof Error ? err.message : "parse error"}`);
     return null;
   }
 }
 async function readSourceIdsForSection(packPath, sectionId) {
-  const path = join21(packPath, "sections", sectionId, "sources.jsonl");
-  if (!existsSync21(path)) return [];
-  const text = await readFile18(path, "utf8");
+  const path = join22(packPath, "sections", sectionId, "sources.jsonl");
+  if (!existsSync22(path)) return [];
+  const text = await readFile19(path, "utf8");
   const ids = [];
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -9975,41 +10295,41 @@ async function readSourceIdsForSection(packPath, sectionId) {
 }
 async function audit(options) {
   const packPath = options.packPath ? resolve18(options.packPath) : process.cwd();
-  const yamlPath = join21(packPath, "research.yaml");
-  if (!existsSync21(yamlPath)) throw new PackNotFoundError(packPath);
-  const research = ResearchYamlSchema.parse(yamlParse8(await readFile18(yamlPath, "utf8")));
+  const yamlPath = join22(packPath, "research.yaml");
+  if (!existsSync22(yamlPath)) throw new PackNotFoundError(packPath);
+  const research = ResearchYamlSchema.parse(yamlParse8(await readFile19(yamlPath, "utf8")));
   const warnings = [];
   const perSection = /* @__PURE__ */ new Map();
   for (const section of research.sections) {
     const sid = section.id;
     const claims = await readJsonl5(
-      join21(packPath, "sections", sid, "claims.jsonl"),
+      join22(packPath, "sections", sid, "claims.jsonl"),
       (r) => ClaimSchema.parse(r),
       warnings
     );
     const candidateClaims = claims.filter((c) => c.review_state === "candidate");
     const claimReviews = await readJsonl5(
-      join21(packPath, "sections", sid, "claim-reviews.jsonl"),
+      join22(packPath, "sections", sid, "claim-reviews.jsonl"),
       (r) => ClaimReviewSchema.parse(r),
       warnings
     );
     const contradictions = await readJsonl5(
-      join21(packPath, "sections", sid, "contradictions.jsonl"),
+      join22(packPath, "sections", sid, "contradictions.jsonl"),
       (r) => ContradictionSchema.parse(r),
       warnings
     );
     const resolutions = await readJsonl5(
-      join21(packPath, "sections", sid, "contradiction-resolutions.jsonl"),
+      join22(packPath, "sections", sid, "contradiction-resolutions.jsonl"),
       (r) => ContradictionResolutionSchema.parse(r),
       warnings
     );
     const dispositions = await readJsonl5(
-      join21(packPath, "sections", sid, "claim-synthesis-dispositions.jsonl"),
+      join22(packPath, "sections", sid, "claim-synthesis-dispositions.jsonl"),
       (r) => ClaimSynthesisDispositionSchema.parse(r),
       warnings
     );
     const findings = await readJsonl5(
-      join21(packPath, "audits", `${sid}-findings.jsonl`),
+      join22(packPath, "audits", `${sid}-findings.jsonl`),
       (r) => ReviewFindingSchema.parse(r),
       warnings
     );
@@ -10029,7 +10349,7 @@ async function audit(options) {
   }
   const sources = await readSourceCards6(packPath, warnings);
   const receipts = await readJsonl5(
-    join21(packPath, "evidence", "fetch-log.jsonl"),
+    join22(packPath, "evidence", "fetch-log.jsonl"),
     (r) => FetchReceiptSchema.parse(r),
     warnings
   );
@@ -10045,11 +10365,11 @@ async function audit(options) {
     warnings
   });
   const payload = PackAuditPayloadSchema.parse(result.payload);
-  const auditsDir = join21(packPath, "audits");
-  await mkdir16(auditsDir, { recursive: true });
+  const auditsDir = join22(packPath, "audits");
+  await mkdir17(auditsDir, { recursive: true });
   const filesWritten = [];
   const writeFileAndTrack = async (rel, content) => {
-    const abs = join21(packPath, rel);
+    const abs = join22(packPath, rel);
     await writeFile17(abs, content, "utf8");
     filesWritten.push(abs);
   };
@@ -10133,18 +10453,18 @@ var init_audit = __esm({
 });
 
 // src/freeze/checks.ts
-import { existsSync as existsSync22 } from "fs";
-import { readFile as readFile19, stat as stat2 } from "fs/promises";
+import { existsSync as existsSync23 } from "fs";
+import { readFile as readFile20, stat as stat2 } from "fs/promises";
 import { createHash as createHash8 } from "crypto";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 async function fileSha2562(absPath) {
-  const buf = await readFile19(absPath);
+  const buf = await readFile20(absPath);
   const sha = createHash8("sha256").update(buf).digest("hex");
   return { path: absPath, sha256: sha, bytes: buf.byteLength };
 }
 async function hashArtifact(ctx, rel) {
-  const abs = join22(ctx.packPath, rel);
-  if (!existsSync22(abs)) {
+  const abs = join23(ctx.packPath, rel);
+  if (!existsSync23(abs)) {
     ctx.missingArtifacts.push(rel);
     return null;
   }
@@ -10355,88 +10675,88 @@ var init_markdown7 = __esm({
 });
 
 // src/freeze/schema.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var ArtifactHashSchema, IntegrityCheckSchema, FreezeReceiptPayloadSchema, FreezeRefusalPayloadSchema;
 var init_schema16 = __esm({
   "src/freeze/schema.ts"() {
     "use strict";
-    ArtifactHashSchema = z17.object({
-      path: z17.string(),
-      sha256: z17.string().regex(/^[a-f0-9]{64}$/),
-      bytes: z17.number().int().nonnegative()
-    });
-    IntegrityCheckSchema = z17.object({
-      name: z17.string().min(1),
-      passed: z17.boolean(),
-      detail: z17.string()
-    });
-    FreezeReceiptPayloadSchema = z17.object({
-      pack_id: z17.string(),
-      pack_topic: z17.string(),
-      frozen_at: z17.string(),
-      verdict: z17.literal("frozen"),
-      pack_audit_hash: z17.string().regex(/^[a-f0-9]{64}$/),
-      handoff_hash: z17.string().regex(/^[a-f0-9]{64}$/),
-      synthesis_hashes: z17.array(ArtifactHashSchema),
-      canonical_artifact_hashes: z17.array(ArtifactHashSchema),
-      accepted_claim_ids: z17.array(z17.string()),
-      cited_claim_ids: z17.array(z17.string()),
-      uncited_accepted_claim_ids: z17.array(z17.string()),
-      unresolved_contradictions: z17.array(
-        z17.object({
-          contradiction_id: z17.string(),
-          section_id: z17.string(),
-          type: z17.string(),
-          severity: z17.string(),
-          status: z17.string(),
-          disclosed_in: z17.array(z17.string())
+    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())
         })
       ),
-      waivers_disclosed: z17.array(
-        z17.object({
-          family: z17.string(),
-          applied_to: z17.string(),
-          reason: z17.string(),
-          compensating_controls: z17.array(z17.string()),
-          disclosed_in: z17.array(z17.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())
         })
       ),
-      sections: z17.array(
-        z17.object({
-          section_id: z17.string(),
-          status: z17.string(),
-          accepted_claims: z17.number().int().nonnegative(),
-          sources: z17.number().int().nonnegative(),
-          contradictions: z17.number().int().nonnegative()
+      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()
         })
       ),
-      source_count: z17.number().int().nonnegative(),
-      claim_count: z17.number().int().nonnegative(),
-      contradiction_count: z17.number().int().nonnegative(),
-      review_finding_count: z17.number().int().nonnegative(),
-      gate_result_count: z17.number().int().nonnegative(),
-      integrity_checks: z17.array(IntegrityCheckSchema)
-    });
-    FreezeRefusalPayloadSchema = z17.object({
-      pack_id: z17.string(),
-      pack_topic: z17.string(),
-      checked_at: z17.string(),
-      verdict: z17.literal("refused"),
-      reasons: z17.array(z17.string()),
-      blocking_reasons: z17.array(z17.string()),
-      missing_artifacts: z17.array(z17.string()),
-      invalid_artifacts: z17.array(z17.object({ path: z17.string(), error: z17.string() })),
-      next_actions: z17.array(z17.string()),
-      would_freeze: z17.literal(false)
+      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)
     });
   }
 });
 
 // src/freeze/run.ts
-import { existsSync as existsSync23 } from "fs";
-import { mkdir as mkdir17, readFile as readFile20, readdir as readdir2, unlink, writeFile as writeFile18 } from "fs/promises";
+import { existsSync as existsSync24 } from "fs";
+import { mkdir as mkdir18, readFile as readFile21, readdir as readdir2, unlink, writeFile as writeFile18 } from "fs/promises";
 import { createHash as createHash9 } from "crypto";
-import { join as join23, resolve as resolve19 } from "path";
+import { join as join24, resolve as resolve19 } from "path";
 import { parse as yamlParse9, stringify as yamlStringify6 } from "yaml";
 function packId3(research) {
   const fingerprint = `${research.topic}|${research.created_at}`;
@@ -10455,10 +10775,10 @@ function noteRefusal(ctx, reason, blocking = true) {
   if (blocking) ctx.blockingReasons.push(reason);
 }
 async function tryReadJson(packPath, rel, parse, invalid) {
-  const abs = join23(packPath, rel);
-  if (!existsSync23(abs)) return null;
+  const abs = join24(packPath, rel);
+  if (!existsSync24(abs)) return null;
   try {
-    return parse(JSON.parse(await readFile20(abs, "utf8")));
+    return parse(JSON.parse(await readFile21(abs, "utf8")));
   } catch (err) {
     invalid.push({ path: rel, error: err instanceof Error ? err.message : "parse error" });
     return null;
@@ -10466,8 +10786,8 @@ async function tryReadJson(packPath, rel, parse, invalid) {
 }
 async function freeze(options) {
   const packPath = options.packPath ? resolve19(options.packPath) : process.cwd();
-  const yamlPath = join23(packPath, "research.yaml");
-  if (!existsSync23(yamlPath)) throw new PackNotFoundError(packPath);
+  const yamlPath = join24(packPath, "research.yaml");
+  if (!existsSync24(yamlPath)) throw new PackNotFoundError(packPath);
   const refusal = {
     reasons: [],
     blockingReasons: [],
@@ -10476,7 +10796,7 @@ async function freeze(options) {
   };
   let research;
   try {
-    research = ResearchYamlSchema.parse(yamlParse9(await readFile20(yamlPath, "utf8")));
+    research = ResearchYamlSchema.parse(yamlParse9(await readFile21(yamlPath, "utf8")));
   } catch (err) {
     refusal.invalidArtifacts.push({ path: "research.yaml", error: err instanceof Error ? err.message : "parse error" });
     return writeRefusal({
@@ -10488,13 +10808,13 @@ async function freeze(options) {
   }
   const pid = packId3(research);
   for (const rel of REQUIRED_PACK_ARTIFACTS) {
-    if (!existsSync23(join23(packPath, rel))) {
+    if (!existsSync24(join24(packPath, rel))) {
       refusal.missingArtifacts.push(rel);
       noteRefusal(refusal, `Required artifact missing: ${rel}.`);
     }
   }
   for (const rel of SYNTHESIS_FILES) {
-    if (!existsSync23(join23(packPath, rel))) {
+    if (!existsSync24(join24(packPath, rel))) {
       refusal.missingArtifacts.push(rel);
       noteRefusal(refusal, `Synthesis artifact missing: ${rel}. Run \`research-os synth workspace\` after the pack reaches synthesis_ready.`);
     }
@@ -10528,22 +10848,22 @@ async function freeze(options) {
   if (handoff2 && handoff2.mode !== "synthesis_ready") {
     noteRefusal(refusal, `Cowork handoff mode is "${handoff2.mode}", not "synthesis_ready".`);
   }
-  const finalReportAbs = join23(packPath, "synthesis/final-report.md");
-  const decisionBriefAbs = join23(packPath, "synthesis/decision-brief.md");
-  const workingReportAbs = join23(packPath, "synthesis/working-report.md");
+  const finalReportAbs = join24(packPath, "synthesis/final-report.md");
+  const decisionBriefAbs = join24(packPath, "synthesis/decision-brief.md");
+  const workingReportAbs = join24(packPath, "synthesis/working-report.md");
   let finalReportText = "";
   let decisionBriefText = "";
   let workingReportText = "";
-  if (existsSync23(finalReportAbs)) finalReportText = await readFile20(finalReportAbs, "utf8");
-  if (existsSync23(decisionBriefAbs)) decisionBriefText = await readFile20(decisionBriefAbs, "utf8");
-  if (existsSync23(workingReportAbs)) workingReportText = await readFile20(workingReportAbs, "utf8");
+  if (existsSync24(finalReportAbs)) finalReportText = await readFile21(finalReportAbs, "utf8");
+  if (existsSync24(decisionBriefAbs)) decisionBriefText = await readFile21(decisionBriefAbs, "utf8");
+  if (existsSync24(workingReportAbs)) workingReportText = await readFile21(workingReportAbs, "utf8");
   const livePackClaimIds = /* @__PURE__ */ new Set();
   const liveLatestDecisionByClaim = /* @__PURE__ */ new Map();
   const liveLatestCreatedAtByClaim = /* @__PURE__ */ new Map();
   for (const section of research.sections) {
-    const claimsFile = join23(packPath, "sections", section.id, "claims.jsonl");
-    if (existsSync23(claimsFile)) {
-      const text = await readFile20(claimsFile, "utf8");
+    const claimsFile = join24(packPath, "sections", section.id, "claims.jsonl");
+    if (existsSync24(claimsFile)) {
+      const text = await readFile21(claimsFile, "utf8");
       for (const line of text.split(/\r?\n/)) {
         if (!line.trim()) continue;
         try {
@@ -10557,9 +10877,9 @@ async function freeze(options) {
         }
       }
     }
-    const reviewsFile = join23(packPath, "sections", section.id, "claim-reviews.jsonl");
-    if (existsSync23(reviewsFile)) {
-      const text = await readFile20(reviewsFile, "utf8");
+    const reviewsFile = join24(packPath, "sections", section.id, "claim-reviews.jsonl");
+    if (existsSync24(reviewsFile)) {
+      const text = await readFile21(reviewsFile, "utf8");
       const reviews = [];
       for (const line of text.split(/\r?\n/)) {
         if (!line.trim()) continue;
@@ -10601,7 +10921,7 @@ async function freeze(options) {
   const unknownCitations = allCited.filter((c) => isWellFormedClaimId(c) && !allClaimIds.has(c));
   const repairCitations = allCited.filter((c) => repairOrRejected.has(c));
   const uncitedAccepted = acceptedClaimIds.filter((c) => !allCitedSet.has(c));
-  if (existsSync23(finalReportAbs) && finalReportText.trim().length > 0) {
+  if (existsSync24(finalReportAbs) && finalReportText.trim().length > 0) {
     if (citationsInFinal.length === 0 && acceptedClaimIds.length > 0) {
       noteRefusal(refusal, "final-report.md contains no [claim:...] citations even though accepted claims exist.");
     }
@@ -10653,7 +10973,7 @@ async function freeze(options) {
     }
   }
   for (const section of research.sections) {
-    if (!existsSync23(join23(packPath, "audits", `${section.id}-gate.json`))) {
+    if (!existsSync24(join24(packPath, "audits", `${section.id}-gate.json`))) {
       noteRefusal(refusal, `Section ${section.id} has no gate result on file.`);
       refusal.missingArtifacts.push(`audits/${section.id}-gate.json`);
     }
@@ -10693,16 +11013,16 @@ async function freeze(options) {
   }
   canonicalPaths.push("evidence/fetch-log.jsonl");
   canonicalPaths.push("evidence/citation-ledger.jsonl");
-  if (existsSync23(join23(packPath, "evidence", "source-cards"))) {
-    const entries = await readdir2(join23(packPath, "evidence", "source-cards"));
+  if (existsSync24(join24(packPath, "evidence", "source-cards"))) {
+    const entries = await readdir2(join24(packPath, "evidence", "source-cards"));
     for (const e of entries) {
       if (e.endsWith(".json")) canonicalPaths.push(`evidence/source-cards/${e}`);
     }
   }
   const canonicalHashes = [];
   for (const rel of canonicalPaths) {
-    const abs = join23(packPath, rel);
-    if (!existsSync23(abs)) continue;
+    const abs = join24(packPath, rel);
+    if (!existsSync24(abs)) continue;
     const h = await hashArtifact(ctx, rel);
     if (h) canonicalHashes.push(h);
   }
@@ -10756,7 +11076,7 @@ async function freeze(options) {
     claim_count: acceptedClaimIds.length,
     contradiction_count: unresolvedContradictionRefs.length,
     review_finding_count: 0,
-    gate_result_count: research.sections.filter((s) => existsSync23(join23(packPath, "audits", `${s.id}-gate.json`))).length,
+    gate_result_count: research.sections.filter((s) => existsSync24(join24(packPath, "audits", `${s.id}-gate.json`))).length,
     integrity_checks: checks
   });
   const frozenResearch = {
@@ -10765,14 +11085,14 @@ async function freeze(options) {
     sections: research.sections.map((s) => ({ ...s, status: "frozen" }))
   };
   await writeFile18(yamlPath, yamlStringify6(frozenResearch, { lineWidth: 0 }), "utf8");
-  const auditsDir = join23(packPath, "audits");
-  await mkdir17(auditsDir, { recursive: true });
+  const auditsDir = join24(packPath, "audits");
+  await mkdir18(auditsDir, { recursive: true });
   for (const stale of ["freeze-refusal.json", "freeze-refusal.md"]) {
-    const p = join23(auditsDir, stale);
-    if (existsSync23(p)) await unlink(p);
+    const p = join24(auditsDir, stale);
+    if (existsSync24(p)) await unlink(p);
   }
-  const jsonPath = join23(auditsDir, "freeze-receipt.json");
-  const mdPath = join23(auditsDir, "freeze-receipt.md");
+  const jsonPath = join24(auditsDir, "freeze-receipt.json");
+  const mdPath = join24(auditsDir, "freeze-receipt.md");
   await writeFile18(jsonPath, JSON.stringify(receipt, null, 2), "utf8");
   await writeFile18(mdPath, renderFreezeReceiptMarkdown(receipt), "utf8");
   return {
@@ -10802,14 +11122,14 @@ async function writeRefusal(args) {
     next_actions: nextActions,
     would_freeze: false
   });
-  const auditsDir = join23(args.packPath, "audits");
-  await mkdir17(auditsDir, { recursive: true });
+  const auditsDir = join24(args.packPath, "audits");
+  await mkdir18(auditsDir, { recursive: true });
   for (const stale of ["freeze-receipt.json", "freeze-receipt.md"]) {
-    const p = join23(auditsDir, stale);
-    if (existsSync23(p)) await unlink(p);
+    const p = join24(auditsDir, stale);
+    if (existsSync24(p)) await unlink(p);
   }
-  const jsonPath = join23(auditsDir, "freeze-refusal.json");
-  const mdPath = join23(auditsDir, "freeze-refusal.md");
+  const jsonPath = join24(auditsDir, "freeze-refusal.json");
+  const mdPath = join24(auditsDir, "freeze-refusal.md");
   await writeFile18(jsonPath, JSON.stringify(payload, null, 2), "utf8");
   await writeFile18(mdPath, renderFreezeRefusalMarkdown(payload), "utf8");
   return {
@@ -10901,43 +11221,43 @@ var init_freeze = __esm({
 });
 
 // src/invalidate/schema.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var ArchivedArtifactSchema, SectionStatusChangeSchema, InvalidationReceiptSchema;
 var init_schema17 = __esm({
   "src/invalidate/schema.ts"() {
     "use strict";
-    ArchivedArtifactSchema = z18.object({
-      src: z18.string(),
+    ArchivedArtifactSchema = z19.object({
+      src: z19.string(),
       // path relative to packPath, before archival
-      dst: z18.string()
+      dst: z19.string()
       // path relative to packPath, after archival
     });
-    SectionStatusChangeSchema = z18.object({
-      section_id: z18.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      before: z18.string(),
-      after: z18.string()
-    });
-    InvalidationReceiptSchema = z18.object({
-      receipt_id: z18.string().regex(/^inv_[0-9]+_[a-z0-9-]+$/),
-      contract_label: z18.string().min(1),
-      superseded_contract: z18.string().min(1).nullable(),
-      new_contract: z18.string().min(1),
-      reason: z18.string().min(8),
-      invalidated_at: z18.string(),
-      research_os_version: z18.string(),
-      affected_sections: z18.array(z18.string().regex(/^[0-9]{2}-[a-z0-9-]+$/)),
-      archived_artifacts: z18.array(ArchivedArtifactSchema),
-      section_status_changes: z18.array(SectionStatusChangeSchema),
-      frozen_at_cleared: z18.boolean(),
-      notes: z18.string().nullable()
+    SectionStatusChangeSchema = z19.object({
+      section_id: z19.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+      before: z19.string(),
+      after: z19.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()
     });
   }
 });
 
 // src/invalidate/run.ts
-import { existsSync as existsSync24 } from "fs";
-import { mkdir as mkdir18, readFile as readFile21, readdir as readdir3, rename, writeFile as writeFile19 } from "fs/promises";
-import { dirname as dirname5, join as join24, posix, relative as relative3, resolve as resolve20, sep } from "path";
+import { existsSync as existsSync25 } from "fs";
+import { mkdir as mkdir19, readFile as readFile22, readdir as readdir3, rename, writeFile as writeFile19 } from "fs/promises";
+import { dirname as dirname6, join as join25, posix, relative as relative3, resolve as resolve20, sep } from "path";
 import { parse as yamlParse10, stringify as yamlStringify7 } from "yaml";
 function posixify(p) {
   return p.split(sep).join("/");
@@ -10955,15 +11275,15 @@ function isLegacyClaimLine(line) {
   }
 }
 async function detectLegacyClaimSections(packPath) {
-  const sectionsDir = join24(packPath, "sections");
-  if (!existsSync24(sectionsDir)) return [];
+  const sectionsDir = join25(packPath, "sections");
+  if (!existsSync25(sectionsDir)) return [];
   const entries = await readdir3(sectionsDir, { withFileTypes: true });
   const affected = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const claimsPath = join24(sectionsDir, entry.name, "claims.jsonl");
-    if (!existsSync24(claimsPath)) continue;
-    const text = await readFile21(claimsPath, "utf8");
+    const claimsPath = join25(sectionsDir, entry.name, "claims.jsonl");
+    if (!existsSync25(claimsPath)) continue;
+    const text = await readFile22(claimsPath, "utf8");
     let hasLegacy = false;
     for (const line of text.split(/\r?\n/)) {
       if (isLegacyClaimLine(line)) {
@@ -10976,16 +11296,16 @@ async function detectLegacyClaimSections(packPath) {
   return affected.sort();
 }
 async function moveIfExists(packPath, archiveRel, rel) {
-  const src = join24(packPath, rel);
-  if (!existsSync24(src)) return null;
-  const dst = join24(packPath, archiveRel, rel);
-  await mkdir18(dirname5(dst), { recursive: true });
+  const src = join25(packPath, rel);
+  if (!existsSync25(src)) return null;
+  const dst = join25(packPath, archiveRel, rel);
+  await mkdir19(dirname6(dst), { recursive: true });
   await rename(src, dst);
-  return { src: posixify(rel), dst: posixify(join24(archiveRel, rel)) };
+  return { src: posixify(rel), dst: posixify(join25(archiveRel, rel)) };
 }
 async function moveDirContentsIfExists(packPath, archiveRel, relDir, skipPrefix) {
-  const fullDir = join24(packPath, relDir);
-  if (!existsSync24(fullDir)) return [];
+  const fullDir = join25(packPath, relDir);
+  if (!existsSync25(fullDir)) return [];
   const entries = await readdir3(fullDir, { withFileTypes: true });
   const moved = [];
   for (const entry of entries) {
@@ -11063,8 +11383,8 @@ function buildReceiptMarkdown(receipt) {
 }
 async function invalidateExtraction(options) {
   const packPath = options.packPath ? resolve20(options.packPath) : process.cwd();
-  const yamlPath = join24(packPath, "research.yaml");
-  if (!existsSync24(yamlPath)) throw new PackNotFoundError(packPath);
+  const yamlPath = join25(packPath, "research.yaml");
+  if (!existsSync25(yamlPath)) throw new PackNotFoundError(packPath);
   const reason = options.reason.trim();
   if (reason.length < 8) {
     throw new Error("invalidation reason must be at least 8 characters");
@@ -11082,13 +11402,13 @@ async function invalidateExtraction(options) {
   const stampPath = stampIso.replace(/[:]/g, "").replace(/\.\d+Z$/, "Z");
   const archiveRel = posix.join("audits", "legacy", label, stampPath);
   const affectedSections = await detectLegacyClaimSections(packPath);
-  const research = ResearchYamlSchema.parse(yamlParse10(await readFile21(yamlPath, "utf8")));
+  const research = ResearchYamlSchema.parse(yamlParse10(await readFile22(yamlPath, "utf8")));
   const packLevelDirs = ["handoffs", "synthesis", "audits"];
   let probeArtifactsExist = affectedSections.length > 0;
   if (!probeArtifactsExist) {
     for (const d of packLevelDirs) {
-      const full = join24(packPath, d);
-      if (!existsSync24(full)) continue;
+      const full = join25(packPath, d);
+      if (!existsSync25(full)) continue;
       const entries = await readdir3(full, { withFileTypes: true });
       const meaningful = entries.some(
         (e) => !(d === "audits" && e.isDirectory() && e.name === "legacy")
@@ -11110,7 +11430,7 @@ async function invalidateExtraction(options) {
       message: "No legacy artifacts found. Pack is on the current extraction contract."
     };
   }
-  await mkdir18(join24(packPath, archiveRel), { recursive: true });
+  await mkdir19(join25(packPath, archiveRel), { recursive: true });
   const archived = [];
   for (const sectionId of affectedSections) {
     for (const filename of [
@@ -11159,14 +11479,14 @@ async function invalidateExtraction(options) {
     frozen_at_cleared: frozenAtCleared,
     notes: options.notes ?? null
   });
-  const receiptDir = join24(packPath, archiveRel);
+  const receiptDir = join25(packPath, archiveRel);
   await writeFile19(
-    join24(receiptDir, "invalidation.json"),
+    join25(receiptDir, "invalidation.json"),
     JSON.stringify(receipt, null, 2),
     "utf8"
   );
   await writeFile19(
-    join24(receiptDir, "invalidation.md"),
+    join25(receiptDir, "invalidation.md"),
     buildReceiptMarkdown(receipt),
     "utf8"
   );
@@ -11192,20 +11512,20 @@ var init_run9 = __esm({
 });
 
 // src/invalidate/review.ts
-import { existsSync as existsSync25 } from "fs";
-import { mkdir as mkdir19, rename as rename2, writeFile as writeFile20 } from "fs/promises";
-import { dirname as dirname6, join as join25, posix as posix2, relative as relative4, resolve as resolve21, sep as sep2 } from "path";
-import { z as z19 } from "zod";
+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";
 function posixify2(p) {
   return p.split(sep2).join("/");
 }
 async function moveIfExists2(packPath, archiveRel, rel) {
-  const src = join25(packPath, rel);
-  if (!existsSync25(src)) return null;
-  const dst = join25(packPath, archiveRel, rel);
-  await mkdir19(dirname6(dst), { recursive: true });
+  const src = join26(packPath, rel);
+  if (!existsSync26(src)) return null;
+  const dst = join26(packPath, archiveRel, rel);
+  await mkdir20(dirname7(dst), { recursive: true });
   await rename2(src, dst);
-  return { src: posixify2(rel), dst: posixify2(join25(archiveRel, rel)) };
+  return { src: posixify2(rel), dst: posixify2(join26(archiveRel, rel)) };
 }
 function buildReceiptMarkdown2(receipt) {
   const lines = [];
@@ -11247,8 +11567,8 @@ function buildReceiptMarkdown2(receipt) {
 }
 async function invalidateReview(options) {
   const packPath = options.packPath ? resolve21(options.packPath) : process.cwd();
-  if (!existsSync25(join25(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
-  if (!existsSync25(join25(packPath, "sections", options.sectionId)))
+  if (!existsSync26(join26(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
+  if (!existsSync26(join26(packPath, "sections", options.sectionId)))
     throw new SectionNotFoundError(options.sectionId);
   const reason = options.reason.trim();
   if (reason.length < 8) {
@@ -11271,7 +11591,7 @@ async function invalidateReview(options) {
     // Also clear review-active.json so the next review run is unambiguous.
     posix2.join("sections", options.sectionId, "review-active.json")
   ];
-  const present = candidatePaths.filter((rel) => existsSync25(join25(packPath, rel)));
+  const present = candidatePaths.filter((rel) => existsSync26(join26(packPath, rel)));
   if (present.length === 0) {
     return {
       performed: false,
@@ -11283,7 +11603,7 @@ async function invalidateReview(options) {
       message: "No canonical review artifacts found to invalidate. Section has no active review state."
     };
   }
-  await mkdir19(join25(packPath, archiveRel), { recursive: true });
+  await mkdir20(join26(packPath, archiveRel), { recursive: true });
   const archived = [];
   for (const rel of present) {
     const a = await moveIfExists2(packPath, archiveRel, rel);
@@ -11299,14 +11619,14 @@ async function invalidateReview(options) {
     archived_artifacts: archived,
     notes: options.notes ?? null
   });
-  const receiptDir = join25(packPath, archiveRel);
+  const receiptDir = join26(packPath, archiveRel);
   await writeFile20(
-    join25(receiptDir, "invalidation.json"),
+    join26(receiptDir, "invalidation.json"),
     JSON.stringify(receipt, null, 2),
     "utf8"
   );
   await writeFile20(
-    join25(receiptDir, "invalidation.md"),
+    join26(receiptDir, "invalidation.md"),
     buildReceiptMarkdown2(receipt),
     "utf8"
   );
@@ -11327,15 +11647,15 @@ var init_review2 = __esm({
     init_errors();
     init_src();
     init_schema17();
-    ReviewInvalidationReceiptSchema = z19.object({
-      receipt_id: z19.string().regex(/^invr_[0-9]+_[a-z0-9-]+$/),
-      section_id: z19.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      contract_label: z19.string().min(1),
-      reason: z19.string().min(8),
-      invalidated_at: z19.string(),
-      research_os_version: z19.string(),
-      archived_artifacts: z19.array(ArchivedArtifactSchema),
-      notes: z19.string().nullable()
+    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()
     });
   }
 });
@@ -11351,103 +11671,103 @@ var init_invalidate = __esm({
 });
 
 // src/section_report/schema.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var SectionReportSourcesSchema, SectionReportExtractionSchema, SectionReportContradictionsSchema, SectionReportReviewSchema, SectionReportAcceptanceSchema, SectionReportSchema;
 var init_schema18 = __esm({
   "src/section_report/schema.ts"() {
     "use strict";
-    SectionReportSourcesSchema = z20.object({
-      fetched_ok: z20.number().int().nonnegative(),
-      source_cards: z20.number().int().nonnegative(),
-      publishers: z20.array(z20.string()),
-      primary_source_waiver: z20.object({
-        status: z20.enum(["none", "requested", "granted"]),
-        reason: z20.string().nullable(),
-        compensating_controls: z20.array(z20.string())
+    SectionReportSourcesSchema = z21.object({
+      fetched_ok: z21.number().int().nonnegative(),
+      source_cards: z21.number().int().nonnegative(),
+      publishers: z21.array(z21.string()),
+      primary_source_waiver: z21.object({
+        status: z21.enum(["none", "requested", "granted"]),
+        reason: z21.string().nullable(),
+        compensating_controls: z21.array(z21.string())
       })
     });
-    SectionReportExtractionSchema = z20.object({
-      candidate_claims: z20.number().int().nonnegative(),
-      claims_per_source: z20.array(
-        z20.object({
-          source_id: z20.string(),
-          claims: z20.number().int().nonnegative()
+    SectionReportExtractionSchema = z21.object({
+      candidate_claims: z21.number().int().nonnegative(),
+      claims_per_source: z21.array(
+        z21.object({
+          source_id: z21.string(),
+          claims: z21.number().int().nonnegative()
         })
       ),
-      claims_per_1k_words: z20.number(),
-      excerpt_pages_processed: z20.number().int().nonnegative().nullable(),
-      excerpt_id_failures: z20.number().int().nonnegative().nullable(),
-      malformed_extractor_outputs: z20.number().int().nonnegative().nullable(),
-      near_duplicate_clusters: z20.number().int().nonnegative(),
-      weak_scope_count: z20.number().int().nonnegative(),
-      generic_scope_count: z20.number().int().nonnegative(),
-      density_flags: z20.number().int().nonnegative()
-    });
-    SectionReportContradictionsSchema = z20.object({
-      pairs_compared: z20.number().int().nonnegative().nullable(),
-      contradiction_candidates: z20.number().int().nonnegative(),
-      overgeneralization_risks: z20.number().int().nonnegative()
-    });
-    SectionReportReviewSchema = z20.object({
-      reviewed: z20.boolean(),
-      accepted_for_synthesis: z20.number().int().nonnegative(),
-      needs_scope_repair: z20.number().int().nonnegative(),
-      needs_source_repair: z20.number().int().nonnegative(),
-      needs_contradiction_mapping: z20.number().int().nonnegative(),
-      rejected: z20.number().int().nonnegative(),
-      needs_human_review: z20.number().int().nonnegative(),
-      rejection_or_repair_by_category: z20.array(
-        z20.object({
-          category: z20.string(),
-          count: z20.number().int().nonnegative()
+      claims_per_1k_words: z21.number(),
+      excerpt_pages_processed: z21.number().int().nonnegative().nullable(),
+      excerpt_id_failures: z21.number().int().nonnegative().nullable(),
+      malformed_extractor_outputs: z21.number().int().nonnegative().nullable(),
+      near_duplicate_clusters: z21.number().int().nonnegative(),
+      weak_scope_count: z21.number().int().nonnegative(),
+      generic_scope_count: z21.number().int().nonnegative(),
+      density_flags: z21.number().int().nonnegative()
+    });
+    SectionReportContradictionsSchema = z21.object({
+      pairs_compared: z21.number().int().nonnegative().nullable(),
+      contradiction_candidates: z21.number().int().nonnegative(),
+      overgeneralization_risks: z21.number().int().nonnegative()
+    });
+    SectionReportReviewSchema = z21.object({
+      reviewed: z21.boolean(),
+      accepted_for_synthesis: z21.number().int().nonnegative(),
+      needs_scope_repair: z21.number().int().nonnegative(),
+      needs_source_repair: z21.number().int().nonnegative(),
+      needs_contradiction_mapping: z21.number().int().nonnegative(),
+      rejected: z21.number().int().nonnegative(),
+      needs_human_review: z21.number().int().nonnegative(),
+      rejection_or_repair_by_category: z21.array(
+        z21.object({
+          category: z21.string(),
+          count: z21.number().int().nonnegative()
         })
       )
     });
-    SectionReportAcceptanceSchema = z20.object({
-      candidate_claims: z20.number().int().nonnegative(),
-      accepted_for_synthesis: z20.number().int().nonnegative(),
-      acceptance_ratio: z20.number(),
+    SectionReportAcceptanceSchema = z21.object({
+      candidate_claims: z21.number().int().nonnegative(),
+      accepted_for_synthesis: z21.number().int().nonnegative(),
+      acceptance_ratio: z21.number(),
       // 0..1
-      accepted_per_source: z20.number(),
+      accepted_per_source: z21.number(),
       // accepted / source_count, 0 if no sources
-      accepted_per_1k_words: z20.number(),
-      top_rejection_category: z20.string().nullable(),
-      claim_overproduction_fired: z20.boolean(),
-      synthesis_ready: z20.boolean()
+      accepted_per_1k_words: z21.number(),
+      top_rejection_category: z21.string().nullable(),
+      claim_overproduction_fired: z21.boolean(),
+      synthesis_ready: z21.boolean()
     });
-    SectionReportSchema = z20.object({
-      report_id: z20.string().regex(/^secrep_[0-9]+_[a-z0-9-]+$/),
-      section_id: z20.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
-      reported_at: z20.string(),
-      research_os_version: z20.string(),
-      status: z20.string(),
+    SectionReportSchema = z21.object({
+      report_id: z21.string().regex(/^secrep_[0-9]+_[a-z0-9-]+$/),
+      section_id: z21.string().regex(/^[0-9]{2}-[a-z0-9-]+$/),
+      reported_at: z21.string(),
+      research_os_version: z21.string(),
+      status: z21.string(),
       sources: SectionReportSourcesSchema,
       extraction: SectionReportExtractionSchema,
       contradictions: SectionReportContradictionsSchema,
       review: SectionReportReviewSchema,
       acceptance: SectionReportAcceptanceSchema,
-      gate_verdict: z20.string().nullable(),
-      gate_synthesis_eligible: z20.boolean().nullable()
+      gate_verdict: z21.string().nullable(),
+      gate_synthesis_eligible: z21.boolean().nullable()
     });
   }
 });
 
 // src/section_report/run.ts
-import { existsSync as existsSync26 } from "fs";
-import { mkdir as mkdir20, readFile as readFile22, writeFile as writeFile21 } from "fs/promises";
-import { join as join26, resolve as resolve22 } from "path";
+import { existsSync as existsSync27 } from "fs";
+import { mkdir as mkdir21, readFile as readFile23, writeFile as writeFile21 } from "fs/promises";
+import { join as join27, resolve as resolve22 } from "path";
 import { parse as yamlParse11 } from "yaml";
 async function readJson(path, parser) {
-  if (!existsSync26(path)) return null;
+  if (!existsSync27(path)) return null;
   try {
-    return parser(JSON.parse(await readFile22(path, "utf8")));
+    return parser(JSON.parse(await readFile23(path, "utf8")));
   } catch {
     return null;
   }
 }
 async function readJsonl6(path, parse) {
-  if (!existsSync26(path)) return [];
-  const text = await readFile22(path, "utf8");
+  if (!existsSync27(path)) return [];
+  const text = await readFile23(path, "utf8");
   const out = [];
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -11464,15 +11784,15 @@ function countWords2(text) {
 }
 async function reportSection(options) {
   const packPath = options.packPath ? resolve22(options.packPath) : process.cwd();
-  if (!existsSync26(join26(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
-  if (!existsSync26(join26(packPath, "sections", options.sectionId)))
+  if (!existsSync27(join27(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
+  if (!existsSync27(join27(packPath, "sections", options.sectionId)))
     throw new SectionNotFoundError(options.sectionId);
   const research = ResearchYamlSchema.parse(
-    yamlParse11(await readFile22(join26(packPath, "research.yaml"), "utf8"))
+    yamlParse11(await readFile23(join27(packPath, "research.yaml"), "utf8"))
   );
   const section = research.sections.find((s) => s.id === options.sectionId);
   const allReceipts = await readJsonl6(
-    join26(packPath, "evidence", "fetch-log.jsonl"),
+    join27(packPath, "evidence", "fetch-log.jsonl"),
     (raw) => FetchReceiptSchema.parse(raw)
   );
   const okReceipts = /* @__PURE__ */ new Map();
@@ -11483,9 +11803,9 @@ async function reportSection(options) {
     if (!prev || prev.fetched_at < r.fetched_at) okReceipts.set(r.source_id, r);
   }
   const sectionSourceIds = [];
-  const sourcesPath = join26(packPath, "sections", options.sectionId, "sources.jsonl");
-  if (existsSync26(sourcesPath)) {
-    const text = await readFile22(sourcesPath, "utf8");
+  const sourcesPath = join27(packPath, "sections", options.sectionId, "sources.jsonl");
+  if (existsSync27(sourcesPath)) {
+    const text = await readFile23(sourcesPath, "utf8");
     for (const line of text.split(/\r?\n/)) {
       if (!line.trim()) continue;
       try {
@@ -11497,10 +11817,10 @@ async function reportSection(options) {
   }
   const cards = /* @__PURE__ */ new Map();
   for (const sid of sectionSourceIds) {
-    const cardPath = join26(packPath, "evidence", "source-cards", `${sid}.json`);
-    if (!existsSync26(cardPath)) continue;
+    const cardPath = join27(packPath, "evidence", "source-cards", `${sid}.json`);
+    if (!existsSync27(cardPath)) continue;
     try {
-      cards.set(sid, SourceCardSchema.parse(JSON.parse(await readFile22(cardPath, "utf8"))));
+      cards.set(sid, SourceCardSchema.parse(JSON.parse(await readFile23(cardPath, "utf8"))));
     } catch {
     }
   }
@@ -11511,12 +11831,12 @@ async function reportSection(options) {
   for (const sid of sectionSourceIds) {
     const r = okReceipts.get(sid);
     if (!r?.raw_text_path) continue;
-    const p = join26(packPath, r.raw_text_path);
-    if (!existsSync26(p)) continue;
-    totalWords += countWords2(await readFile22(p, "utf8"));
+    const p = join27(packPath, r.raw_text_path);
+    if (!existsSync27(p)) continue;
+    totalWords += countWords2(await readFile23(p, "utf8"));
   }
   const claims = await readJsonl6(
-    join26(packPath, "sections", options.sectionId, "claims.jsonl"),
+    join27(packPath, "sections", options.sectionId, "claims.jsonl"),
     (raw) => ClaimSchema.parse(raw)
   );
   const claimsBySrc = /* @__PURE__ */ new Map();
@@ -11528,11 +11848,11 @@ async function reportSection(options) {
     }
   }
   const density = await readJson(
-    join26(packPath, "audits", `${options.sectionId}-claim-density.json`),
+    join27(packPath, "audits", `${options.sectionId}-claim-density.json`),
     (raw) => raw
   );
   const extractReceipt = await readJson(
-    join26(packPath, "audits", `${options.sectionId}-claim-extract.json`),
+    join27(packPath, "audits", `${options.sectionId}-claim-extract.json`),
     (raw) => raw
   );
   let excerptPagesProcessed = null;
@@ -11550,7 +11870,7 @@ async function reportSection(options) {
     ).length;
   }
   const contradictions = await readJsonl6(
-    join26(packPath, "sections", options.sectionId, "contradictions.jsonl"),
+    join27(packPath, "sections", options.sectionId, "contradictions.jsonl"),
     (raw) => ContradictionSchema.parse(raw)
   );
   let pairsCompared = null;
@@ -11559,7 +11879,7 @@ async function reportSection(options) {
     (c) => c.type === "overgeneralization_risk"
   ).length;
   const reviews = await readJsonl6(
-    join26(packPath, "sections", options.sectionId, "claim-reviews.jsonl"),
+    join27(packPath, "sections", options.sectionId, "claim-reviews.jsonl"),
     (raw) => ClaimReviewSchema.parse(raw)
   );
   const latestReviewByClaim = /* @__PURE__ */ new Map();
@@ -11568,7 +11888,7 @@ async function reportSection(options) {
     if (!prev || prev.created_at < r.created_at) latestReviewByClaim.set(r.claim_id, r);
   }
   const findings = await readJsonl6(
-    join26(packPath, "audits", `${options.sectionId}-findings.jsonl`),
+    join27(packPath, "audits", `${options.sectionId}-findings.jsonl`),
     (raw) => ReviewFindingSchema.parse(raw)
   );
   const decisionCounts = {
@@ -11593,7 +11913,7 @@ async function reportSection(options) {
   const topRejectionCategory = rejectionByCategory[0]?.category ?? null;
   const claimOverproductionFired = (categoryCounts.get("claim_overproduction") ?? 0) > 0;
   const gate2 = await readJson(
-    join26(packPath, "audits", `${options.sectionId}-gate.json`),
+    join27(packPath, "audits", `${options.sectionId}-gate.json`),
     (raw) => raw
   );
   const candidate = claims.length;
@@ -11729,10 +12049,10 @@ async function reportSection(options) {
   md.push("---");
   md.push("");
   md.push("_This report is read-only \u2014 it does not mutate any canonical artifact. Re-run after any pipeline step to refresh._");
-  const auditsDir = join26(packPath, "audits");
-  await mkdir20(auditsDir, { recursive: true });
-  const jsonPath = join26(auditsDir, `${options.sectionId}-section-report.json`);
-  const markdownPath = join26(auditsDir, `${options.sectionId}-section-report.md`);
+  const auditsDir = join27(packPath, "audits");
+  await mkdir21(auditsDir, { recursive: true });
+  const jsonPath = join27(auditsDir, `${options.sectionId}-section-report.json`);
+  const markdownPath = join27(auditsDir, `${options.sectionId}-section-report.md`);
   await writeFile21(jsonPath, JSON.stringify(report, null, 2), "utf8");
   await writeFile21(markdownPath, md.join("\n"), "utf8");
   return { report, jsonPath, markdownPath };
@@ -11770,17 +12090,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_schema19 = __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",
@@ -11790,36 +12110,36 @@ var init_schema19 = __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)
-    });
-    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())
+      discovered_by: z22.string().min(1),
+      reason: z22.string().nullable().default(null)
+    });
+    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())
     });
   }
 });
@@ -11971,10 +12291,10 @@ Propose source-URL candidates for this section. Quality over quantity.`;
 });
 
 // src/discover/run.ts
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import { createHash as createHash10 } from "crypto";
-import { mkdir as mkdir21, readFile as readFile23, writeFile as writeFile22, appendFile as appendFile7 } from "fs/promises";
-import { join as join27, resolve as resolve23 } from "path";
+import { mkdir as mkdir22, readFile as readFile24, writeFile as writeFile22, appendFile as appendFile8 } from "fs/promises";
+import { join as join28, resolve as resolve23 } from "path";
 import { parse as yamlParse12 } from "yaml";
 function makeCandidateId(sectionId, url) {
   const hex = createHash10("sha256").update(`${sectionId}|${url}`).digest("hex").slice(0, 12);
@@ -11989,21 +12309,21 @@ function isHttpsUrl(s) {
   }
 }
 function candidatesPath(packPath, sectionId) {
-  return join27(packPath, "sections", sectionId, "discovery-candidates.jsonl");
+  return join28(packPath, "sections", sectionId, "discovery-candidates.jsonl");
 }
 function reportPath(packPath, sectionId) {
-  return join27(packPath, "sections", sectionId, "discovery-report.md");
+  return join28(packPath, "sections", sectionId, "discovery-report.md");
 }
 function summaryPath(packPath, sectionId) {
-  return join27(packPath, "audits", `${sectionId}-discovery.json`);
+  return join28(packPath, "audits", `${sectionId}-discovery.json`);
 }
 function approvedUrlsPath(packPath, sectionId) {
-  return join27(packPath, "sections", sectionId, "urls.approved.txt");
+  return join28(packPath, "sections", sectionId, "urls.approved.txt");
 }
 async function readCandidates(packPath, sectionId) {
   const path = candidatesPath(packPath, sectionId);
-  if (!existsSync27(path)) return [];
-  const text = await readFile23(path, "utf8");
+  if (!existsSync28(path)) return [];
+  const text = await readFile24(path, "utf8");
   const out = [];
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -12033,7 +12353,7 @@ async function pickProvider(providers) {
 }
 async function loadSectionPurpose(packPath, sectionId) {
   const research = ResearchYamlSchema.parse(
-    yamlParse12(await readFile23(join27(packPath, "research.yaml"), "utf8"))
+    yamlParse12(await readFile24(join28(packPath, "research.yaml"), "utf8"))
   );
   const section = research.sections.find((s) => s.id === sectionId);
   return section?.purpose ?? "";
@@ -12071,8 +12391,8 @@ function buildReportMarkdown(args) {
 }
 async function discover(options) {
   const packPath = options.packPath ? resolve23(options.packPath) : process.cwd();
-  if (!existsSync27(join27(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
-  if (!existsSync27(join27(packPath, "sections", options.sectionId)))
+  if (!existsSync28(join28(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
+  if (!existsSync28(join28(packPath, "sections", options.sectionId)))
     throw new SectionNotFoundError(options.sectionId);
   const query2 = options.query.trim();
   if (query2.length < 4) throw new Error("discover query must be at least 4 characters");
@@ -12132,9 +12452,9 @@ async function discover(options) {
     newCandidates.push(candidate);
   }
   const ledgerPath = candidatesPath(packPath, options.sectionId);
-  await mkdir21(join27(packPath, "sections", options.sectionId), { recursive: true });
+  await mkdir22(join28(packPath, "sections", options.sectionId), { recursive: true });
   for (const c of newCandidates) {
-    await appendFile7(ledgerPath, JSON.stringify(c) + "\n", "utf8");
+    await appendFile8(ledgerPath, JSON.stringify(c) + "\n", "utf8");
   }
   const all = await readCandidates(packPath, options.sectionId);
   const latest = Array.from(latestPerCandidate(all).values());
@@ -12158,7 +12478,7 @@ async function discover(options) {
     candidates_rejected_invalid_url: invalidCount,
     warnings
   });
-  await mkdir21(join27(packPath, "audits"), { recursive: true });
+  await mkdir22(join28(packPath, "audits"), { recursive: true });
   await writeFile22(summaryPath(packPath, options.sectionId), JSON.stringify(summary, null, 2), "utf8");
   return {
     candidatesAdded: newCandidates.length,
@@ -12178,13 +12498,13 @@ async function appendStatusUpdate(packPath, sectionId, candidate, newStatus, rea
     reason,
     discovered_at: stampIso
   });
-  await appendFile7(candidatesPath(packPath, sectionId), JSON.stringify(updated) + "\n", "utf8");
+  await appendFile8(candidatesPath(packPath, sectionId), JSON.stringify(updated) + "\n", "utf8");
   return updated;
 }
 async function approve(options) {
   const packPath = options.packPath ? resolve23(options.packPath) : process.cwd();
-  if (!existsSync27(join27(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
-  if (!existsSync27(join27(packPath, "sections", options.sectionId)))
+  if (!existsSync28(join28(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
+  if (!existsSync28(join28(packPath, "sections", options.sectionId)))
     throw new SectionNotFoundError(options.sectionId);
   const all = await readCandidates(packPath, options.sectionId);
   const latest = latestPerCandidate(all);
@@ -12217,8 +12537,8 @@ async function approve(options) {
 }
 async function reject(options) {
   const packPath = options.packPath ? resolve23(options.packPath) : process.cwd();
-  if (!existsSync27(join27(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
-  if (!existsSync27(join27(packPath, "sections", options.sectionId)))
+  if (!existsSync28(join28(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
+  if (!existsSync28(join28(packPath, "sections", options.sectionId)))
     throw new SectionNotFoundError(options.sectionId);
   if (options.reason.trim().length < 4) {
     throw new Error("reject requires --reason of at least 4 characters");
@@ -12246,15 +12566,15 @@ async function reject(options) {
 }
 async function exportUrls(options) {
   const packPath = options.packPath ? resolve23(options.packPath) : process.cwd();
-  if (!existsSync27(join27(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
-  if (!existsSync27(join27(packPath, "sections", options.sectionId)))
+  if (!existsSync28(join28(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
+  if (!existsSync28(join28(packPath, "sections", options.sectionId)))
     throw new SectionNotFoundError(options.sectionId);
   const all = await readCandidates(packPath, options.sectionId);
   const latest = latestPerCandidate(all);
   const approved = Array.from(latest.values()).filter((c) => c.status === "approved").sort((a, b) => a.rank - b.rank);
   const lines = approved.map((c) => c.url).join("\n");
   const path = approvedUrlsPath(packPath, options.sectionId);
-  await mkdir21(join27(packPath, "sections", options.sectionId), { recursive: true });
+  await mkdir22(join28(packPath, "sections", options.sectionId), { recursive: true });
   await writeFile22(path, lines + (lines.length > 0 ? "\n" : ""), "utf8");
   return { exportPath: path, approvedCount: approved.length };
 }
@@ -12302,7 +12622,7 @@ var init_src = __esm({
     init_triage();
     init_discover();
     init_errors();
-    RESEARCH_OS_VERSION = "0.3.2";
+    RESEARCH_OS_VERSION = "0.4.0";
   }
 });
 init_src();
@@ -12409,6 +12729,7 @@ export {
   SectionStatusChangeSchema,
   SeveritySchema,
   SharedSourceSchema,
+  SourceCardOverrideSchema,
   SourceCardSchema,
   SourceDiversityGapRowSchema,
   SourceTypeGuessSchema,
@@ -12428,6 +12749,7 @@ export {
   add,
   aggregate,
   appendFetchLog,
+  appendOverride,
   appendSectionSourceId,
   applySchema,
   applyWaivers,
@@ -12468,6 +12790,8 @@ export {
   freeze,
   gate,
   gather,
+  getEffectivePublisher,
+  getEffectiveSourceType,
   handoff,
   hasNegation,
   indexDbPath,
@@ -12492,6 +12816,7 @@ export {
   promote,
   query,
   readActiveProfile,
+  readOverrides,
   readTriagedClaimIds,
   readUrlsFile,
   reject,
@@ -12522,6 +12847,7 @@ export {
   syncRepoKnowledge,
   tokenize,
   triage,
+  validateSourceCardOverride,
   workspace,
   writeActiveProfile,
   writeSourceCard