@var-ia/cli 0.1.0 → 0.3.0

package/src/commands/analyze.ts

@@ -1,7 +1,39 @@
+import { readFileSync } from "node:fs";
 import { MediaWikiClient } from "@var-ia/ingestion";
+import type { RevisionOptions } from "@var-ia/ingestion";
 import { sectionDiffer, citationTracker, revertDetector, templateTracker } from "@var-ia/analyzers";
-import type { EvidenceEvent, EvidenceLayer, Revision } from "@var-ia/evidence-graph";
+import type { TemplateType } from "@var-ia/analyzers";
+import type { EvidenceEvent, EvidenceLayer, Revision, DeterministicFact } from "@var-ia/evidence-graph";
+import { createAdapter } from "@var-ia/interpreter";
+import type { ModelConfig } from "@var-ia/interpreter";
 import { loadCachedRevisions, saveRevisions } from "./cache.js";
+import { stripWikitext, fuzzyFindClaim, findSectionForText } from "./claim.js";
+
+interface BatchPageResult {
+  pageTitle: string;
+  pageId: number;
+  eventCount: number;
+  events: EvidenceEvent[];
+}
+
+interface BatchResult {
+  mode: "batch";
+  batchSize: number;
+  pages: BatchPageResult[];
+  totalEvents: number;
+  generatedAt: string;
+}
+
+function templateTypeToPolicyDimension(type: TemplateType): string | null {
+  switch (type) {
+    case "citation": return "verifiability";
+    case "neutrality": return "npov";
+    case "blp": return "blp";
+    case "dispute": return "due_weight";
+    case "protection": return "protection";
+    default: return null;
+  }
+}
 
 export async function runAnalyze(
   pageTitle: string,
@@ -9,8 +41,14 @@ export async function runAnalyze(
   fromRevId?: number,
   _toRevId?: number,
   useCache = false,
-): Promise<EvidenceEvent[]> {
-  const client = new MediaWikiClient();
+  modelConfig?: ModelConfig,
+  apiUrl?: string,
+  pagesFile?: string,
+): Promise<{ events: EvidenceEvent[]; revisions: Revision[] }> {
+  if (pagesFile) {
+    return runBatch(pagesFile, depth, fromRevId, _toRevId, useCache, modelConfig, apiUrl);
+  }
+  const client = new MediaWikiClient(apiUrl ? { apiUrl } : undefined);
   console.log(`Analyzing "${pageTitle}" at depth: ${depth}...`);
 
   let revisions: Revision[] = [];
@@ -25,8 +63,16 @@ export async function runAnalyze(
 
   if (revisions.length === 0) {
     console.log(`Fetching revisions from Wikipedia...`);
-    const options: { limit?: number; direction?: "newer" | "older" } = { limit: 20, direction: "newer" };
-    void fromRevId;
+    const options: RevisionOptions = { direction: "newer" };
+    if (fromRevId) {
+      options.startRevId = fromRevId;
+    }
+    if (_toRevId) {
+      options.endRevId = _toRevId;
+    }
+    if (!fromRevId && !_toRevId) {
+      options.limit = 20;
+    }
     revisions = await client.fetchRevisions(pageTitle, options);
     console.log(`Fetched ${revisions.length} revisions.`);
 
@@ -38,7 +84,7 @@ export async function runAnalyze(
 
   if (revisions.length < 2) {
     console.log("Need at least 2 revisions to analyze.");
-    return [];
+    return { events: [], revisions: [] };
   }
 
   const events: EvidenceEvent[] = [];
@@ -46,10 +92,21 @@ export async function runAnalyze(
     (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
   );
 
+  const allSeenSentences = new Set<string>();
+
   for (let i = 1; i < sortedRevs.length; i++) {
     const before = sortedRevs[i - 1];
     const after = sortedRevs[i];
 
+    const isBrief = depth === "brief";
+    const isForensic = depth === "forensic";
+    const extraFacts: DeterministicFact[] = isForensic
+      ? [
+          { fact: "full_wikitext_before", detail: before.content },
+          { fact: "full_wikitext_after", detail: after.content },
+        ]
+      : [];
+
     const beforeSections = sectionDiffer.extractSections(before.content);
     const afterSections = sectionDiffer.extractSections(after.content);
     const sectionChanges = sectionDiffer.diffSections(beforeSections, afterSections);
@@ -72,10 +129,11 @@ export async function runAnalyze(
         fromRevisionId: before.revId,
         toRevisionId: after.revId,
         section: "body",
-        before: cit.before?.raw ?? "",
-        after: cit.after?.raw ?? "",
+        before: isBrief ? "" : (cit.before?.raw ?? ""),
+        after: isBrief ? "" : (cit.after?.raw ?? ""),
         deterministicFacts: [
           { fact: "citation_changed", detail: `type=${cit.type}` },
+          ...extraFacts,
         ],
         layer,
         timestamp: after.timestamp,
@@ -84,17 +142,40 @@ export async function runAnalyze(
 
     for (const tpl of templateChanges) {
       if (tpl.type === "unchanged") continue;
+
+      if (tpl.template.type === "protection") {
+        events.push({
+          eventType: "protection_changed",
+          fromRevisionId: before.revId,
+          toRevisionId: after.revId,
+          section: "body",
+          before: tpl.type === "removed" ? tpl.template.name : "",
+          after: tpl.type === "added" ? tpl.template.name : "",
+          deterministicFacts: [
+            { fact: "protection_changed", detail: `name=${tpl.template.name} type=${tpl.type}` },
+            ...extraFacts,
+          ],
+          layer: "policy_coded",
+          timestamp: after.timestamp,
+        });
+        continue;
+      }
+
+      const policyDimension = templateTypeToPolicyDimension(tpl.template.type);
+      const layer: EvidenceLayer = policyDimension ? "policy_coded" : "observed";
       events.push({
         eventType: tpl.type === "added" ? "template_added" : "template_removed",
         fromRevisionId: before.revId,
         toRevisionId: after.revId,
         section: "body",
         before: "",
-        after: tpl.template.name,
+        after: isBrief ? "" : tpl.template.name,
         deterministicFacts: [
           { fact: "template_changed", detail: `name=${tpl.template.name} type=${tpl.type}` },
+          ...(policyDimension ? [{ fact: "policy_signal", detail: `dimension=${policyDimension} signal=${tpl.template.name.toLowerCase().replace(/\s+/g, "_")}` }] : []),
+          ...extraFacts,
         ],
-        layer: "observed",
+        layer,
         timestamp: after.timestamp,
       });
     }
@@ -106,10 +187,11 @@ export async function runAnalyze(
         fromRevisionId: before.revId,
         toRevisionId: after.revId,
         section: sc.section,
-        before: sc.fromContent ?? "",
-        after: sc.toContent ?? "",
+        before: isBrief ? "" : (sc.fromContent ?? ""),
+        after: isBrief ? "" : (sc.toContent ?? ""),
         deterministicFacts: [
           { fact: "section_changed", detail: `change=${sc.changeType}` },
+          ...extraFacts,
         ],
         layer: "observed",
         timestamp: after.timestamp,
@@ -123,15 +205,209 @@ export async function runAnalyze(
         toRevisionId: after.revId,
         section: "",
         before: "",
-        after: after.comment,
+        after: isBrief ? "" : after.comment,
         deterministicFacts: [
           { fact: "revert_detected", detail: after.comment },
+          { fact: "policy_signal", detail: "dimension=edit_warring signal=revert_detected" },
+          ...extraFacts,
         ],
-        layer: "observed",
+        layer: "policy_coded",
         timestamp: after.timestamp,
       });
     }
+
+    const leadChange = sectionChanges.find(
+      sc => sc.section === "(lead)" && sc.changeType === "modified"
+    );
+    if (leadChange) {
+      const fromLen = leadChange.fromContent?.length ?? 0;
+      const toLen = leadChange.toContent?.length ?? 0;
+      const contentMovedOut = fromLen > toLen && toLen < fromLen * 0.5;
+      const contentMovedIn = toLen > fromLen && fromLen < toLen * 0.5;
+
+      if (contentMovedOut) {
+        const targetSection = sectionChanges.find(
+          sc => sc.section !== "(lead)" && (sc.changeType === "added" || sc.changeType === "modified")
+        );
+        if (targetSection) {
+          events.push({
+            eventType: "lead_demotion",
+            fromRevisionId: before.revId,
+            toRevisionId: after.revId,
+            section: targetSection.section,
+            before: isBrief ? "" : (leadChange.fromContent ?? ""),
+            after: isBrief ? "" : (leadChange.toContent ?? ""),
+            deterministicFacts: [
+              { fact: "lead_content_moved", detail: `from=lead to=${targetSection.section}` },
+              ...extraFacts,
+            ],
+            layer: "observed",
+            timestamp: after.timestamp,
+          });
+        }
+      } else if (contentMovedIn) {
+        const sourceSection = sectionChanges.find(
+          sc => sc.section !== "(lead)" && (sc.changeType === "removed" || sc.changeType === "modified")
+        );
+        if (sourceSection) {
+          events.push({
+            eventType: "lead_promotion",
+            fromRevisionId: before.revId,
+            toRevisionId: after.revId,
+            section: sourceSection.section,
+            before: isBrief ? "" : (leadChange.fromContent ?? ""),
+            after: isBrief ? "" : (leadChange.toContent ?? ""),
+            deterministicFacts: [
+              { fact: "lead_content_moved", detail: `from=${sourceSection.section} to=lead` },
+              ...extraFacts,
+            ],
+            layer: "observed",
+            timestamp: after.timestamp,
+          });
+        }
+      }
+    }
+
+    const beforePlain = stripWikitext(before.content);
+    const afterPlain = stripWikitext(after.content);
+
+    const beforeSentences = beforePlain.split(/[.!?]\s+/).filter(s => s.trim().length > 20);
+    const afterSentences = afterPlain.split(/[.!?]\s+/).filter(s => s.trim().length > 20);
+
+    for (const sentence of afterSentences) {
+      const trimmed = sentence.trim();
+      if (!trimmed) continue;
+      const foundInBefore = fuzzyFindClaim(trimmed, beforePlain);
+      if (!foundInBefore) {
+        const normalized = trimmed.toLowerCase().replace(/\s+/g, " ");
+        const wasSeenBefore = allSeenSentences.has(normalized);
+        const section = findSectionForText(after.content, trimmed);
+        events.push({
+          eventType: wasSeenBefore ? "claim_reintroduced" : "claim_first_seen",
+          fromRevisionId: before.revId,
+          toRevisionId: after.revId,
+          section,
+          before: "",
+          after: isBrief ? "" : trimmed,
+          deterministicFacts: [
+            { fact: "claim_detected", detail: `sentence_length=${trimmed.length}` },
+            ...extraFacts,
+          ],
+          layer: "observed",
+          timestamp: after.timestamp,
+        });
+      } else {
+        const oldLen = foundInBefore.length;
+        const newLen = trimmed.length;
+        if (Math.abs(newLen - oldLen) > oldLen * 0.2) {
+          const section = findSectionForText(after.content, trimmed);
+          events.push({
+            eventType: "claim_reworded",
+            fromRevisionId: before.revId,
+            toRevisionId: after.revId,
+            section,
+            before: isBrief ? "" : foundInBefore,
+            after: isBrief ? "" : trimmed,
+            deterministicFacts: [
+              { fact: "claim_reworded", detail: `old_length=${oldLen} new_length=${newLen}` },
+              ...extraFacts,
+            ],
+            layer: "observed",
+            timestamp: after.timestamp,
+          });
+        }
+      }
+    }
+
+    for (const sentence of beforeSentences) {
+      const trimmed = sentence.trim();
+      if (!trimmed) continue;
+      const foundInAfter = fuzzyFindClaim(trimmed, afterPlain);
+      if (!foundInAfter) {
+        const section = findSectionForText(before.content, trimmed);
+        events.push({
+          eventType: "claim_removed",
+          fromRevisionId: before.revId,
+          toRevisionId: after.revId,
+          section,
+          before: isBrief ? "" : trimmed,
+          after: "",
+          deterministicFacts: [
+            { fact: "claim_removed", detail: `sentence_length=${trimmed.length}` },
+            ...extraFacts,
+          ],
+          layer: "observed",
+          timestamp: after.timestamp,
+        });
+      }
+    }
+
+    for (const s of afterSentences) {
+      const normalized = s.trim().toLowerCase().replace(/\s+/g, " ");
+      if (normalized) allSeenSentences.add(normalized);
+    }
+  }
+
+  if (modelConfig && events.length > 0) {
+    const adapter = createAdapter(modelConfig);
+    console.log(`Interpreting ${events.length} events with ${modelConfig.provider}...`);
+    const interpreted = await adapter.interpret(events);
+    for (let i = 0; i < interpreted.length; i++) {
+      interpreted[i].layer = events[i].layer;
+    }
+    console.log("Interpretation complete.");
+    return { events: interpreted, revisions: sortedRevs };
+  }
+
+  return { events, revisions: sortedRevs };
+}
+
+async function runBatch(
+  pagesFile: string,
+  depth: string,
+  fromRevId?: number,
+  toRevId?: number,
+  useCache = false,
+  modelConfig?: ModelConfig,
+  apiUrl?: string,
+): Promise<{ events: EvidenceEvent[]; revisions: Revision[] }> {
+  const content = readFileSync(pagesFile, "utf-8");
+  const titles = content
+    .split("\n")
+    .map(l => l.trim())
+    .filter(l => l.length > 0 && !l.startsWith("#"));
+
+  console.log(`Batch mode: ${titles.length} pages from ${pagesFile}\n`);
+
+  const pages: BatchPageResult[] = [];
+  const allEvents: EvidenceEvent[] = [];
+
+  for (const title of titles) {
+    console.log(`--- Page ${pages.length + 1}/${titles.length}: ${title} ---`);
+    const { events } = await runAnalyze(title, depth, fromRevId, toRevId, useCache, modelConfig, apiUrl, undefined);
+    pages.push({
+      pageTitle: title,
+      pageId: 0,
+      eventCount: events.length,
+      events,
+    });
+    allEvents.push(...events);
+  }
+
+  const result: BatchResult = {
+    mode: "batch",
+    batchSize: titles.length,
+    pages,
+    totalEvents: allEvents.length,
+    generatedAt: new Date().toISOString(),
+  };
+
+  console.log(`\n=== Batch Results ===`);
+  console.log(`Pages processed: ${result.batchSize}`);
+  console.log(`Total events: ${result.totalEvents}\n`);
+  for (const p of result.pages) {
+    console.log(`  ${p.pageTitle}: ${p.eventCount} events`);
   }
 
-  return events;
+  return { events: allEvents, revisions: [] };
 }

package/src/commands/cache.ts

@@ -1,4 +1,5 @@
 import { Persistence } from "@var-ia/persistence";
+import type { PersistenceAdapter } from "@var-ia/persistence";
 import type { Revision } from "@var-ia/evidence-graph";
 import { existsSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
@@ -7,9 +8,9 @@ import { join } from "node:path";
 const CACHE_DIR = join(homedir(), ".wikihistory");
 const DB_PATH = join(CACHE_DIR, "varia.db");
 
-let _instance: Persistence | null = null;
+let _instance: PersistenceAdapter | null = null;
 
-export function getPersistence(): Persistence {
+export function getPersistence(): PersistenceAdapter {
   if (!_instance) {
     if (!existsSync(CACHE_DIR)) {
       mkdirSync(CACHE_DIR, { recursive: true });

package/src/commands/claim.ts

@@ -1,14 +1,18 @@
 import { MediaWikiClient } from "@var-ia/ingestion";
 import { createClaimIdentity } from "@var-ia/evidence-graph";
-import type { ClaimState, Revision } from "@var-ia/evidence-graph";
+import type { ClaimState, EvidenceEvent, Revision } from "@var-ia/evidence-graph";
+import { createAdapter } from "@var-ia/interpreter";
+import type { ModelConfig } from "@var-ia/interpreter";
 import { loadCachedRevisions, saveRevisions } from "./cache.js";
 
 export async function runClaim(
   pageTitle: string,
   claimText: string,
   useCache = false,
+  modelConfig?: ModelConfig,
+  apiUrl?: string,
 ): Promise<void> {
-  const client = new MediaWikiClient();
+  const client = new MediaWikiClient(apiUrl ? { apiUrl } : undefined);
   console.log(`Tracking claim in "${pageTitle}"...`);
   console.log(`Claim text: "${claimText}"\n`);
 
@@ -97,6 +101,36 @@ export async function runClaim(
     return;
   }
 
+  if (modelConfig && variants.length >= 2) {
+    const adapter = createAdapter(modelConfig);
+    const comparisonEvents: EvidenceEvent[] = [];
+    for (let i = 1; i < variants.length; i++) {
+      comparisonEvents.push({
+        eventType: "claim_reworded",
+        fromRevisionId: variants[i - 1].revisionId,
+        toRevisionId: variants[i].revisionId,
+        section: variants[i].section,
+        before: variants[i - 1].text,
+        after: variants[i].text,
+        deterministicFacts: [
+          { fact: "claim_variant_compared", detail: `pair=${i}` },
+        ],
+        layer: "observed",
+        timestamp: variants[i].observedAt,
+      });
+    }
+
+    if (comparisonEvents.length > 0) {
+      console.log(`\nSemantically comparing ${comparisonEvents.length} claim variant pairs with ${modelConfig.provider}...`);
+      const interpreted = await adapter.interpret(comparisonEvents);
+      for (const ie of interpreted) {
+        const conf = ie.modelInterpretation.confidence;
+        const label = conf >= 0.7 ? "similar" : conf >= 0.4 ? "moderate change" : "substantial change";
+        console.log(`[rev ${ie.fromRevisionId}→${ie.toRevisionId}] ${label} (confidence: ${conf.toFixed(2)}) — ${ie.modelInterpretation.semanticChange}`);
+      }
+    }
+  }
+
   if (currentState !== "absent" && currentState !== "deleted") {
     currentState = "stabilizing";
   }
@@ -112,7 +146,7 @@ export async function runClaim(
 
 export { runClaim as runClaimCommand };
 
-function stripWikitext(wikitext: string): string {
+export function stripWikitext(wikitext: string): string {
   let text = wikitext;
   text = text.replace(/<!--[\s\S]*?-->/g, "");
   text = text.replace(/<ref\b[^>]*\/\s*>/gi, "");
@@ -127,7 +161,7 @@ function stripWikitext(wikitext: string): string {
   return text.trim();
 }
 
-function fuzzyFindClaim(claimText: string, plainText: string): string {
+export function fuzzyFindClaim(claimText: string, plainText: string): string {
   const normalized = claimText.toLowerCase().replace(/\s+/g, " ").trim();
   const searchText = plainText.toLowerCase().replace(/\s+/g, " ");
 
@@ -147,7 +181,7 @@ function fuzzyFindClaim(claimText: string, plainText: string): string {
   return "";
 }
 
-function findSectionForText(wikitext: string, plainText: string): string {
+export function findSectionForText(wikitext: string, plainText: string): string {
   const headerRegex = /^(=+)\s*([^=]+?)\s*\1$/gm;
   const lines = wikitext.split("\n");
   let currentSection = "(lead)";

package/src/commands/eval.ts

@@ -0,0 +1,41 @@
+import { createEvalHarness } from "@var-ia/eval";
+import { runAnalyze } from "./analyze.js";
+
+export async function runEval(pageTitleOverride?: string): Promise<void> {
+  const harness = createEvalHarness();
+  const testCases = harness.benchmarkPages();
+
+  const filtered = pageTitleOverride
+    ? testCases.filter(t => t.pageTitle === pageTitleOverride)
+    : testCases;
+
+  console.log(`Running ${filtered.length} benchmark tests...\n`);
+
+  const results = [];
+  for (const test of filtered) {
+    console.log(`[${test.id}] ${test.description}...`);
+    try {
+      const { events } = await runAnalyze(test.pageTitle, "detailed");
+      const result = harness.evaluate(test, events);
+      results.push(result);
+      const icon = result.passed ? "PASS" : "FAIL";
+      console.log(`  ${icon} precision=${result.precision.toFixed(2)} events=${result.eventCount.actual}/${result.eventCount.expected}`);
+    } catch (err) {
+      console.log(`  ERROR: ${err}`);
+      results.push({
+        testId: test.id,
+        passed: false,
+        precision: 0,
+        eventCount: { expected: test.expectedEvents.length, actual: 0 },
+        matches: [],
+        misses: test.expectedEvents.map(e => ({ expected: e })),
+        falsePositives: [],
+      });
+    }
+  }
+
+  const summary = harness.computeScores(results);
+  console.log(`\n=== Eval Summary ===`);
+  console.log(`Passed: ${summary.testsPassed}/${summary.totalTests}`);
+  console.log(`Overall precision: ${(summary.overallPrecision * 100).toFixed(1)}%`);
+}

package/src/commands/export.ts

@@ -1,11 +1,34 @@
+import { createHash } from "node:crypto";
 import { runAnalyze } from "./analyze.js";
-import type { EvidenceEvent, Report } from "@var-ia/evidence-graph";
+import { createEventIdentity } from "@var-ia/evidence-graph";
+import type { EvidenceEvent, Report, PolicySignal, Revision } from "@var-ia/evidence-graph";
+import type { ModelConfig } from "@var-ia/interpreter";
+
+interface EvidenceBundle {
+  format: "varia-evidence-bundle/v1";
+  generatedAt: string;
+  pageTitle: string;
+  revisionRange: { from: number; to: number };
+  inputRevisions: Revision[];
+  outputEvents: EvidenceEvent[];
+  bundleHash: string;
+}
 
 export async function runExport(
   pageTitle: string,
   format: string,
+  modelConfig?: ModelConfig,
+  apiUrl?: string,
+  bundle?: boolean,
 ): Promise<void> {
-  const events = await runAnalyze(pageTitle, "detailed");
+  if (bundle) {
+    const { events, revisions } = await runAnalyze(pageTitle, "detailed", undefined, undefined, false, modelConfig, apiUrl);
+    const bundleData = buildBundle(pageTitle, events, revisions);
+    console.log(JSON.stringify(bundleData, null, 2));
+    return;
+  }
+
+  const { events } = await runAnalyze(pageTitle, "detailed", undefined, undefined, false, modelConfig, apiUrl);
 
   if (events.length === 0) {
     console.log("No events to export.");
@@ -22,10 +45,49 @@ export async function runExport(
   }
 }
 
+function buildBundle(pageTitle: string, events: EvidenceEvent[], revisions: Revision[]): EvidenceBundle {
+  const from = revisions[0]?.revId ?? 0;
+  const to = revisions[revisions.length - 1]?.revId ?? 0;
+
+  const taggedEvents = events.map((e) => ({
+    ...e,
+    eventId: e.eventId ?? createEventIdentity(e),
+  }));
+
+  const bundle = {
+    format: "varia-evidence-bundle/v1" as const,
+    generatedAt: new Date().toISOString(),
+    pageTitle,
+    revisionRange: { from, to },
+    inputRevisions: revisions,
+    outputEvents: taggedEvents,
+  };
+
+  const bundleHash = createHash("sha256")
+    .update(JSON.stringify(bundle))
+    .digest("hex");
+
+  return { ...bundle, bundleHash };
+}
+
 function buildReport(pageTitle: string, events: EvidenceEvent[]): Report {
   const sortedRevs = events.map((e) => e.toRevisionId).sort((a, b) => a - b);
   const timestamps = events.map((e) => e.timestamp).sort();
 
+  const observedCount = events.length;
+  const policyCount = events.filter((e) => e.layer === "policy_coded").length;
+  const modelCount = events.filter((e) => e.modelInterpretation != null).length;
+
+  const layers: Report["layers"] = [{ label: "observed", description: "Deterministic", events: observedCount, reproducible: true }];
+  if (policyCount > 0) {
+    layers.push({ label: "policy_coded", description: "Wikipedia policy signals", events: policyCount, reproducible: true });
+  }
+  if (modelCount > 0) {
+    layers.push({ label: "model_interpretation", description: "Model-assisted semantic interpretation", events: modelCount, reproducible: false });
+  }
+
+  const hasModel = modelCount > 0;
+
   return {
     pageTitle,
     pageId: 0,
@@ -35,9 +97,7 @@ function buildReport(pageTitle: string, events: EvidenceEvent[]): Report {
     },
     generatedAt: new Date().toISOString(),
     depth: "detailed",
-    layers: [
-      { label: "observed", description: "Deterministic", events: events.length, reproducible: true },
-    ],
+    layers,
     timeline: {
       totalRevisions: sortedRevs.length,
       analyzedRevisions: sortedRevs.length,
@@ -50,17 +110,56 @@ function buildReport(pageTitle: string, events: EvidenceEvent[]): Report {
         timestamp: e.timestamp,
         eventType: e.eventType,
         summary: e.deterministicFacts.map((f) => f.fact).join("; "),
-        layer: e.layer,
+        layer: e.modelInterpretation ? "model_interpretation" : e.layer,
       })),
     },
     claims: [],
     sources: [],
-    policySignals: [],
-    caveats: ["Deterministic analysis only — no model interpretation applied."],
+    policySignals: extractPolicySignals(events),
+    caveats: hasModel
+      ? ["Model-assisted interpretation applied — confidence scores are per-event and may vary between runs."]
+      : ["Deterministic analysis only — no model interpretation applied."],
     phase: "Phase 1b",
   };
 }
 
+function extractPolicySignals(events: EvidenceEvent[]): PolicySignal[] {
+  const signalMap = new Map<string, PolicySignal>();
+  const sortedEvents = [...events].sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime(),
+  );
+
+  for (const event of sortedEvents) {
+    if (event.layer !== "policy_coded") continue;
+    const signalFact = event.deterministicFacts.find((f) => f.fact === "policy_signal");
+    if (!signalFact?.detail) continue;
+
+    const parts = signalFact.detail.split(" ");
+    const dimMatch = parts.find((p) => p.startsWith("dimension="));
+    const sigMatch = parts.find((p) => p.startsWith("signal="));
+    if (!dimMatch || !sigMatch) continue;
+
+    const dimension = dimMatch.slice("dimension=".length);
+    const signal = sigMatch.slice("signal=".length);
+    const key = `${dimension}:${signal}`;
+
+    if (signalMap.has(key)) {
+      const existing = signalMap.get(key)!;
+      existing.lastSeenRevisionId = event.toRevisionId;
+      existing.active = true;
+    } else {
+      signalMap.set(key, {
+        dimension,
+        signal,
+        firstSeenRevisionId: event.toRevisionId,
+        active: true,
+      });
+    }
+  }
+
+  return [...signalMap.values()];
+}
+
 function toCSV(events: EvidenceEvent[]): string {
   const header = "timestamp,eventType,fromRevisionId,toRevisionId,section,before,after,facts";
   const rows = events.map((e) => {