@mcptoolshop/research-os 0.2.0 → 0.3.1

package/dist/cli.js

@@ -106,11 +106,12 @@ __export(schema_exports, {
   ReviewProfilePresetSchema: () => ReviewProfilePresetSchema,
   SectionBudgetGateSchema: () => SectionBudgetGateSchema,
   SectionSchema: () => SectionSchema,
+  SectionScopedWaiverSchema: () => SectionScopedWaiverSchema,
   SectionStatusSchema: () => SectionStatusSchema,
   SourceFloorGateSchema: () => SourceFloorGateSchema
 });
 import { z } from "zod";
-var SectionStatusSchema, SectionSchema, SourceFloorGateSchema, ClaimIntegrityGateSchema, FreshnessGateSchema, ContradictionGateSchema, SectionBudgetGateSchema, GateConfigSchema, PrimarySourceWaiverSchema, FreshnessRequirementsSchema, ReviewProfilePresetSchema, DEFAULT_REVIEW_PROFILES, ResearchYamlSchema;
+var SectionStatusSchema, SectionSchema, SourceFloorGateSchema, ClaimIntegrityGateSchema, FreshnessGateSchema, ContradictionGateSchema, SectionBudgetGateSchema, GateConfigSchema, SectionScopedWaiverSchema, PrimarySourceWaiverSchema, FreshnessRequirementsSchema, ReviewProfilePresetSchema, DEFAULT_REVIEW_PROFILES, ResearchYamlSchema;
 var init_schema = __esm({
   "src/intake/schema.ts"() {
     "use strict";
@@ -160,10 +161,20 @@ var init_schema = __esm({
       contradiction: ContradictionGateSchema.default({}),
       section_budget: SectionBudgetGateSchema.default({})
     });
+    SectionScopedWaiverSchema = z.object({
+      section_id: z.string().regex(/^[0-9]{2}-[a-z0-9-]+$/, 'Section id must look like "01-landscape"'),
+      scope: z.enum(["min_independent_publishers", "primary_sources_required"]),
+      reason: z.string().min(1),
+      compensating_controls: z.array(z.string()).min(1)
+    });
     PrimarySourceWaiverSchema = z.object({
       status: z.enum(["none", "requested", "granted"]).default("none"),
       reason: z.string().optional(),
-      compensating_controls: z.array(z.string()).default([])
+      compensating_controls: z.array(z.string()).default([]),
+      // Section-scoped waivers; each entry is its own waiver record. Independent
+      // of the pack-level status/reason/compensating_controls fields above.
+      // Defaults to [] for backward compatibility — existing packs unaffected.
+      section_waivers: z.array(SectionScopedWaiverSchema).default([])
     });
     FreshnessRequirementsSchema = z.object({
       required: z.boolean().default(true),
@@ -2774,9 +2785,6 @@ Hard rules:
 });
 
 // src/contradictions/detectors/index.ts
-function defaultContradictionDetectors() {
-  return [new OllamaInternContradictionDetector(), new HeuristicContradictionDetector()];
-}
 async function pickContradictionDetector(detectors) {
   for (const d of detectors) {
     if (await d.available()) return d;
@@ -3250,6 +3258,48 @@ function buildContradiction(args) {
     created_at: (/* @__PURE__ */ new Date()).toISOString()
   });
 }
+async function resolveDetector(options) {
+  const mode = options.detectorMode ?? "auto";
+  if (!VALID_DETECTOR_MODES.includes(mode)) {
+    throw new Error(
+      `contradict map: invalid --detector value "${mode}"; valid values are: auto, heuristic, ollama-intern`
+    );
+  }
+  if (mode === "heuristic") {
+    return {
+      detector: new HeuristicContradictionDetector(),
+      announcement: "contradict map: using heuristic detector"
+    };
+  }
+  if (mode === "ollama-intern") {
+    const d = new OllamaInternContradictionDetector(options.ollamaConfig ?? {});
+    if (!await d.available()) {
+      throw new Error(
+        `contradict map: ollama-intern detector requested but model ${d.model} is unavailable; aborting (use --detector heuristic to bypass)`
+      );
+    }
+    return {
+      detector: d,
+      announcement: `contradict map: using ollama-intern detector with model ${d.model}`
+    };
+  }
+  const detectors = options.detectors ?? [
+    new OllamaInternContradictionDetector(options.ollamaConfig ?? {}),
+    new HeuristicContradictionDetector()
+  ];
+  const detector = await pickContradictionDetector(detectors);
+  if (detector.name === "ollama-intern") {
+    const modelName = detector instanceof OllamaInternContradictionDetector ? detector.model : process.env.OLLAMA_INTERN_MODEL ?? "hermes3:8b";
+    return {
+      detector,
+      announcement: `contradict map: using ollama-intern detector with model ${modelName}`
+    };
+  }
+  return {
+    detector,
+    announcement: "contradict map: ollama-intern unavailable; using heuristic detector"
+  };
+}
 async function map(options) {
   const packPath = options.packPath ? resolve7(options.packPath) : process.cwd();
   if (!existsSync9(join10(packPath, "research.yaml"))) throw new PackNotFoundError(packPath);
@@ -3261,8 +3311,7 @@ async function map(options) {
     const allowed = await readTriagedClaimIds2(packPath, options.sectionId);
     candidateClaims = candidateClaims.filter((c) => allowed.has(c.claim_id));
   }
-  const adapters = options.detectors ?? defaultContradictionDetectors();
-  const detector = await pickContradictionDetector(adapters);
+  const { detector, announcement } = await resolveDetector(options);
   const summary = {
     sectionId: options.sectionId,
     detector: detector.name,
@@ -3272,7 +3321,8 @@ async function map(options) {
     contradictionsAdded: 0,
     contradictionsDeduped: 0,
     contradictionIds: [],
-    detectorError: null
+    detectorError: null,
+    detectorAnnouncement: announcement
   };
   const ledgerPath = join10(sectionDir, "contradictions.jsonl");
   const mdPath = join10(sectionDir, "contradictions.md");
@@ -3336,7 +3386,7 @@ async function map(options) {
   await writeFile9(mdPath, md, "utf8");
   return summary;
 }
-var DETECTOR_ID_PART;
+var DETECTOR_ID_PART, VALID_DETECTOR_MODES;
 var init_map = __esm({
   "src/contradictions/map.ts"() {
     "use strict";
@@ -3344,11 +3394,14 @@ var init_map = __esm({
     init_schema5();
     init_schema7();
     init_detectors();
+    init_heuristic3();
+    init_ollama_intern3();
     init_markdown();
     DETECTOR_ID_PART = {
       heuristic: "heuristic",
       "ollama-intern": "ollama_intern"
     };
+    VALID_DETECTOR_MODES = ["auto", "heuristic", "ollama-intern"];
   }
 });
 
@@ -4165,9 +4218,28 @@ function applyWaivers(input, results) {
   const updated = results.map((r) => ({ ...r }));
   const applied = [];
   const validationFailures = [];
-  if (waiver.status !== "granted") {
-    return { updatedResults: updated, waivers_applied: applied, waiver_validation_failures: validationFailures };
+  applyPackLevelWaiver({
+    waiver,
+    cfg,
+    updated,
+    applied,
+    validationFailures
+  });
+  for (const sw of waiver.section_waivers ?? []) {
+    if (sw.section_id !== input.section.id) continue;
+    applySectionScopedWaiver({
+      waiver: sw,
+      cfg,
+      updated,
+      applied,
+      validationFailures
+    });
   }
+  return { updatedResults: updated, waivers_applied: applied, waiver_validation_failures: validationFailures };
+}
+function applyPackLevelWaiver(args) {
+  const { waiver, cfg, updated, applied, validationFailures } = args;
+  if (waiver.status !== "granted") return;
   if (!waiver.reason || waiver.reason.trim().length === 0) {
     validationFailures.push({
       family: "waivers",
@@ -4177,7 +4249,7 @@ function applyWaivers(input, results) {
       evidence: [],
       blocks_synthesis: true
     });
-    return { updatedResults: updated, waivers_applied: applied, waiver_validation_failures: validationFailures };
+    return;
   }
   if (waiver.compensating_controls.length === 0) {
     validationFailures.push({
@@ -4188,7 +4260,7 @@ function applyWaivers(input, results) {
       evidence: [],
       blocks_synthesis: true
     });
-    return { updatedResults: updated, waivers_applied: applied, waiver_validation_failures: validationFailures };
+    return;
   }
   if (!cfg.primary_source_waiver_allowed) {
     validationFailures.push({
@@ -4199,7 +4271,7 @@ function applyWaivers(input, results) {
       evidence: [],
       blocks_synthesis: true
     });
-    return { updatedResults: updated, waivers_applied: applied, waiver_validation_failures: validationFailures };
+    return;
   }
   for (let i = 0; i < updated.length; i += 1) {
     const r = updated[i];
@@ -4221,7 +4293,62 @@ function applyWaivers(input, results) {
       });
     }
   }
-  return { updatedResults: updated, waivers_applied: applied, waiver_validation_failures: validationFailures };
+}
+function applySectionScopedWaiver(args) {
+  const { waiver, cfg, updated, applied, validationFailures } = args;
+  if (!waiver.reason || waiver.reason.trim().length === 0) {
+    validationFailures.push({
+      family: "waivers",
+      check: "section_scoped_waiver_reason_required",
+      status: "fail",
+      detail: `Section-scoped waiver for ${waiver.section_id}/${waiver.scope} is missing a reason. Waiver is invalid; original failure stands.`,
+      evidence: [waiver.section_id],
+      blocks_synthesis: true
+    });
+    return;
+  }
+  if (waiver.compensating_controls.length === 0) {
+    validationFailures.push({
+      family: "waivers",
+      check: "section_scoped_waiver_compensating_controls_required",
+      status: "fail",
+      detail: `Section-scoped waiver for ${waiver.section_id}/${waiver.scope} has empty compensating_controls. Waiver is invalid; original failure stands.`,
+      evidence: [waiver.section_id],
+      blocks_synthesis: true
+    });
+    return;
+  }
+  if (!cfg.primary_source_waiver_allowed) {
+    validationFailures.push({
+      family: "waivers",
+      check: "section_scoped_waiver_allowed_by_pack",
+      status: "fail",
+      detail: `Pack policy gates.source_floor.primary_source_waiver_allowed=false; section-scoped waiver for ${waiver.section_id}/${waiver.scope} cannot be applied.`,
+      evidence: [waiver.section_id],
+      blocks_synthesis: true
+    });
+    return;
+  }
+  for (let i = 0; i < updated.length; i += 1) {
+    const r = updated[i];
+    if (r.family === "source_floor" && r.check === waiver.scope && r.status === "fail") {
+      const original = r.status;
+      updated[i] = {
+        ...r,
+        status: "pass_with_waiver",
+        detail: `${r.detail} Section-scoped waiver granted for ${waiver.section_id} with ${waiver.compensating_controls.length} compensating control(s); converted from fail to pass_with_waiver.`,
+        blocks_synthesis: false
+      };
+      applied.push({
+        family: "source_floor",
+        check: waiver.scope,
+        reason: waiver.reason,
+        compensating_controls: waiver.compensating_controls,
+        original_status: original,
+        new_status: "pass_with_waiver"
+      });
+    }
+  }
 }
 var init_waivers = __esm({
   "src/gates/checks/waivers.ts"() {
@@ -5478,9 +5605,11 @@ function pickHighestPriority(decisions) {
   return "accepted_for_synthesis";
 }
 function deriveClaimReviews(args) {
-  const { claims, findings, reviewer, reviewMethod } = args;
+  const { claims, findings, reviewer, reviewMethod, activeSectionWaivers } = args;
   const reviews = [];
   const now = (/* @__PURE__ */ new Date()).toISOString();
+  const monopolyWaived = Array.isArray(activeSectionWaivers) && activeSectionWaivers.some((w) => w.scope === "min_independent_publishers");
+  const isWaivedFinding = (f) => monopolyWaived && f.category === "source_cluster_monopoly";
   for (const claim of claims) {
     const claimFindings = findings.filter((f) => f.claim_ids.includes(claim.claim_id));
     if (claimFindings.length === 0) {
@@ -5497,6 +5626,7 @@ function deriveClaimReviews(args) {
     }
     let decisions = [];
     for (const f of claimFindings) {
+      if (isWaivedFinding(f)) continue;
       if (f.severity === "block") {
         decisions.push(BLOCK_TO_DECISION[f.category] ?? "rejected");
       } else if (f.severity === "warn") {
@@ -5513,7 +5643,9 @@ function deriveClaimReviews(args) {
       );
     }
     const decision = pickHighestPriority(decisions);
-    const reasonParts = claimFindings.filter((f) => f.severity !== "info").map((f) => `${f.category} (${f.severity})`);
+    const reasonParts = claimFindings.filter((f) => f.severity !== "info").map(
+      (f) => isWaivedFinding(f) ? `${f.category} (${f.severity}, waived)` : `${f.category} (${f.severity})`
+    );
     const reason = reasonParts.length > 0 ? `Findings: ${reasonParts.join("; ")}.` : "Only info-level findings; accepted.";
     reviews.push({
       claim_id: claim.claim_id,
@@ -5894,7 +6026,8 @@ async function review(options) {
     candidateClaims,
     drafts: acceptedDrafts,
     llmFindingsRejected,
-    profile: options.profile ?? DEFAULT_PROFILE
+    profile: options.profile ?? DEFAULT_PROFILE,
+    research
   });
 }
 async function runMultiPassReview(args) {
@@ -5956,7 +6089,8 @@ async function runMultiPassReview(args) {
     candidateClaims: args.candidateClaims,
     drafts: merged,
     llmFindingsRejected,
-    profile: args.options.profile ?? DEFAULT_PROFILE
+    profile: args.options.profile ?? DEFAULT_PROFILE,
+    research: args.research
   });
 }
 async function reviewWithSpecificReviewer(args) {
@@ -5984,7 +6118,8 @@ async function reviewWithSpecificReviewer(args) {
     candidateClaims: args.candidateClaims,
     drafts: result.drafts,
     llmFindingsRejected: 0,
-    profile: args.options.profile ?? DEFAULT_PROFILE
+    profile: args.options.profile ?? DEFAULT_PROFILE,
+    research: args.research
   });
 }
 async function finalizeReview(args) {
@@ -6007,11 +6142,15 @@ async function finalizeReview(args) {
     seen.add(f.finding_id);
     dedupedFindings.push(f);
   }
+  const activeSectionWaivers = args.research.primary_source_waiver.section_waivers.filter(
+    (w) => w.section_id === args.sectionId
+  );
   const claimReviews = deriveClaimReviews({
     claims: args.candidateClaims,
     findings: dedupedFindings,
     reviewer: args.reviewer,
-    reviewMethod: args.reviewMethod
+    reviewMethod: args.reviewMethod,
+    activeSectionWaivers
   });
   const decisionCounts = {
     accepted_for_synthesis: 0,
@@ -8738,6 +8877,19 @@ function buildStaleSources(input) {
   }
   return out;
 }
+function findSectionWaiver(research, sectionId, scope) {
+  return (research.primary_source_waiver.section_waivers ?? []).find(
+    (w) => w.section_id === sectionId && w.scope === scope
+  );
+}
+function annotateWeakSource(row, waiver) {
+  if (!waiver) return row;
+  return { ...row, waived: true, waiver_reason: waiver.reason };
+}
+function annotateDiversityGap(row, waiver) {
+  if (!waiver) return row;
+  return { ...row, waived: true, waiver_reason: waiver.reason };
+}
 function buildWeakSources(input) {
   const out = [];
   const cfg = input.research.gates.source_floor;
@@ -8747,33 +8899,50 @@ function buildWeakSources(input) {
     const publishers = new Set(
       sectionSources.map((c) => c.publisher).filter((p) => typeof p === "string")
     );
+    const monopolyWaiver = findSectionWaiver(input.research, sid, "min_independent_publishers");
+    const primaryWaiver = findSectionWaiver(input.research, sid, "primary_sources_required");
     if (publishers.size === 1 && sectionSources.length >= 2) {
-      out.push({
-        reason: "source_cluster_monopoly",
-        section_id: sid,
-        details: `Every source in this section traces to a single publisher (${[...publishers][0]}).`,
-        evidence_ids: sectionSources.map((s) => s.source_id),
-        artifact_path: `sections/${sid}/sources.jsonl`
-      });
+      out.push(
+        annotateWeakSource(
+          {
+            reason: "source_cluster_monopoly",
+            section_id: sid,
+            details: `Every source in this section traces to a single publisher (${[...publishers][0]}).`,
+            evidence_ids: sectionSources.map((s) => s.source_id),
+            artifact_path: `sections/${sid}/sources.jsonl`
+          },
+          monopolyWaiver
+        )
+      );
     }
     if (publishers.size < cfg.min_independent_publishers) {
-      out.push({
-        reason: "low_independent_publishers",
-        section_id: sid,
-        details: `${publishers.size} independent publisher(s) \u2014 pack policy requires at least ${cfg.min_independent_publishers}.`,
-        evidence_ids: [...publishers],
-        artifact_path: `sections/${sid}/sources.jsonl`
-      });
+      out.push(
+        annotateWeakSource(
+          {
+            reason: "low_independent_publishers",
+            section_id: sid,
+            details: `${publishers.size} independent publisher(s) \u2014 pack policy requires at least ${cfg.min_independent_publishers}.`,
+            evidence_ids: [...publishers],
+            artifact_path: `sections/${sid}/sources.jsonl`
+          },
+          monopolyWaiver
+        )
+      );
     }
     const primary = sectionSources.filter((c) => c.source_type === "primary").length;
     if (primary < cfg.primary_sources_required) {
-      out.push({
-        reason: "missing_primary_source",
-        section_id: sid,
-        details: `${primary} primary source(s) \u2014 pack policy requires at least ${cfg.primary_sources_required}.`,
-        evidence_ids: sectionSources.filter((c) => c.source_type === "primary").map((c) => c.source_id),
-        artifact_path: `sections/${sid}/sources.jsonl`
-      });
+      out.push(
+        annotateWeakSource(
+          {
+            reason: "missing_primary_source",
+            section_id: sid,
+            details: `${primary} primary source(s) \u2014 pack policy requires at least ${cfg.primary_sources_required}.`,
+            evidence_ids: sectionSources.filter((c) => c.source_type === "primary").map((c) => c.source_id),
+            artifact_path: `sections/${sid}/sources.jsonl`
+          },
+          primaryWaiver
+        )
+      );
     }
     const types = /* @__PURE__ */ new Map();
     for (const c of sectionSources) types.set(c.source_type, (types.get(c.source_type) ?? 0) + 1);
@@ -8888,20 +9057,31 @@ function buildSourceDiversityGaps(input) {
       });
       continue;
     }
+    const monopolyWaiver = findSectionWaiver(input.research, sid, "min_independent_publishers");
     if (publishers.size === 1 && sectionSources.length >= 2) {
-      out.push({
-        reason: "section_publisher_monopoly",
-        section_id: sid,
-        details: `Section sources monopolized by ${[...publishers][0]}.`,
-        evidence_ids: sectionSources.map((s) => s.source_id)
-      });
+      out.push(
+        annotateDiversityGap(
+          {
+            reason: "section_publisher_monopoly",
+            section_id: sid,
+            details: `Section sources monopolized by ${[...publishers][0]}.`,
+            evidence_ids: sectionSources.map((s) => s.source_id)
+          },
+          monopolyWaiver
+        )
+      );
     } else if (publishers.size < cfg.min_independent_publishers) {
-      out.push({
-        reason: "low_section_publisher_count",
-        section_id: sid,
-        details: `${publishers.size} publisher(s); pack policy requires ${cfg.min_independent_publishers}.`,
-        evidence_ids: [...publishers]
-      });
+      out.push(
+        annotateDiversityGap(
+          {
+            reason: "low_section_publisher_count",
+            section_id: sid,
+            details: `${publishers.size} publisher(s); pack policy requires ${cfg.min_independent_publishers}.`,
+            evidence_ids: [...publishers]
+          },
+          monopolyWaiver
+        )
+      );
     }
   }
   const pubSectionCount = /* @__PURE__ */ new Map();
@@ -11692,7 +11872,7 @@ var init_src = __esm({
     init_triage();
     init_discover();
     init_errors();
-    RESEARCH_OS_VERSION = "0.2.0";
+    RESEARCH_OS_VERSION = "0.3.1";
   }
 });
 
@@ -12123,7 +12303,7 @@ init_synth();
 init_audit();
 init_freeze();
 init_invalidate();
-import { Command } from "commander";
+import { Command, Option } from "commander";
 
 // src/pack/publish/index.ts
 import { existsSync as existsSync30, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
@@ -13054,13 +13234,21 @@ contradictCmd.command("map").description("Detect contradiction candidates among
   "--triaged-only",
   "Only consider claims that triage selected_for_review; reduces N\xB2 pair classification on dense sections",
   false
+).addOption(
+  new Option(
+    "--detector <mode>",
+    "Detector to use: auto (default, env-var-driven), heuristic (always fast, no LLM), ollama-intern (require LLM, fail visibly if unavailable)"
+  ).choices(["auto", "heuristic", "ollama-intern"]).default("auto")
 ).action(async (section, opts) => {
   try {
     const result = await map({
       sectionId: section,
       packPath: opts.pack,
-      triagedOnly: opts.triagedOnly
+      triagedOnly: opts.triagedOnly,
+      detectorMode: opts.detector
     });
+    process.stdout.write(`${result.detectorAnnouncement}
+`);
     process.stdout.write(`contradiction map complete
 `);
     process.stdout.write(`  section:                 ${result.sectionId}