diff --git a/README.md b/README.md
index 65ddc9c..4dfa069 100644
--- a/README.md
+++ b/README.md
@@ -138,9 +138,10 @@ See [`docs/public-deployment.md`](docs/public-deployment.md) for the store check
 
 V2 builds one compact `ArticleIndex`, creates an adaptive `AnalysisPlan`, and runs a global
 `RetrievalCoordinator` against a shared source ledger and evidence graph. Fast, balanced, and deep
-modes change passage, mission, concurrency, deadline, and output budgets. Evidence is validated
-once before it can serve any report section, and sections only project the ledger; the side panel
-never reconciles sources itself.
+modes change passage, mission, concurrency, deadline, and output budgets. Providers return
+candidate sources only; a bounded adjudication step maps exact candidate IDs to article claims and
+relationships, and centralized validation is required before an assertion can serve any report
+section. The side panel only projects validated ledger assertions.
 
 Exa uses bounded search requests with returned text/highlights. Native ChatGPT web search is one
 bounded global search workflow: its URL-attributed results are `search-summary` evidence and are
diff --git a/apps/extension/entrypoints/offscreen/main.ts b/apps/extension/entrypoints/offscreen/main.ts
index 15ac297..812ec15 100644
--- a/apps/extension/entrypoints/offscreen/main.ts
+++ b/apps/extension/entrypoints/offscreen/main.ts
@@ -2,6 +2,7 @@ import { createChatGPT } from "@opencoredev/loginwithchatgpt-ai";
 import type { ChatGPTTokens, ReasoningEffort } from "@opencoredev/loginwithchatgpt-core";
 import {
   analyzeArticle,
+  createModelEvidenceAdjudicator,
   retryArticleSections,
   type AnalysisArtifacts,
   type PipelineTelemetry,
@@ -199,7 +200,7 @@ async function testSearchProvider(
       controller.signal,
     );
     const first = await iterator[Symbol.asyncIterator]().next();
-    const sourceCount = first.done ? 0 : first.value.cards.length;
+    const sourceCount = first.done ? 0 : first.value.candidates.length;
     if (sourceCount === 0)
       throw new Error("ChatGPT completed the request but did not return a web source.");
     return { available: true, sourceCount };
@@ -236,6 +237,7 @@ async function runJob(
       article: command.request.article,
       retriever,
       model,
+      adjudicator: createModelEvidenceAdjudicator(model),
       modelVersion: preferences.model,
       reasoningEffort: preferences.reasoningEffort,
       mode: preferences.mode,
@@ -340,7 +342,7 @@ async function runRetryJob(
       reasoningEffort: "medium" as const,
       mode: "balanced" as const,
     };
-    const { retriever } = await createRetriever(
+    const { model, retriever } = await createRetriever(
       jobId,
       preferences.model,
       preferences.reasoningEffort,
@@ -349,6 +351,7 @@ async function runRetryJob(
     for await (const event of retryArticleSections({
       artifacts,
       retriever,
+      adjudicator: createModelEvidenceAdjudicator(model),
       sections: command.sections,
       signal: controller.signal,
       onTelemetry: (telemetry) => logTelemetry(jobId, telemetry),
diff --git a/apps/extension/entrypoints/sidepanel/AnalysisProgress.test.ts b/apps/extension/entrypoints/sidepanel/AnalysisProgress.test.ts
index 37dd0df..6af23f3 100644
--- a/apps/extension/entrypoints/sidepanel/AnalysisProgress.test.ts
+++ b/apps/extension/entrypoints/sidepanel/AnalysisProgress.test.ts
@@ -14,6 +14,7 @@ describe("analysis pipeline progress", () => {
         ...state,
         phase: "retrieval",
         research: {
+          candidateCount: 3,
           completedMissions: 2,
           totalMissions: 4,
           acceptedSources: 3,
diff --git a/apps/extension/entrypoints/sidepanel/App.tsx b/apps/extension/entrypoints/sidepanel/App.tsx
index 9d755c8..6d8cfdf 100644
--- a/apps/extension/entrypoints/sidepanel/App.tsx
+++ b/apps/extension/entrypoints/sidepanel/App.tsx
@@ -1,4 +1,5 @@
 import {
+  memo,
   useCallback,
   useEffect,
   useRef,
@@ -37,6 +38,7 @@ import {
   isAnalysisActive,
 } from "./report-state";
 import { ReportStore } from "./report-store";
+import type { ReportSectionKey } from "./report-store";
 import {
   extensionMode,
   clearAnalysisLogs,
@@ -359,6 +361,136 @@ export function ProvisionalCompassWarning() {
   );
 }
 
+function useReportSection<K extends ReportSectionKey>(store: ReportStore, section: K) {
+  const subscribe = useCallback(
+    (listener: () => void) => store.subscribeSection(section, listener),
+    [section, store],
+  );
+  const getSnapshot = useCallback(() => store.getSectionSnapshot(section), [section, store]);
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+
+const ConnectedCompass = memo(function ConnectedCompass({ store }: { store: ReportStore }) {
+  const section = useReportSection(store, "compass");
+  return section.data ? (
+    <>
+      <Compass result={section.data} />
+      {section.status === "error" ? <ProvisionalCompassWarning /> : null}
+    </>
+  ) : (
+    <div className="compass-placeholder">
+      <TargetIcon />
+      <span>
+        <small>Political Spectrum</small>
+        <strong>{section.status === "error" ? "Unavailable" : "Finding placement…"}</strong>
+      </span>
+    </div>
+  );
+});
+
+const ConnectedBias = memo(function ConnectedBias({ store }: { store: ReportStore }) {
+  const section = useReportSection(store, "bias");
+  const data = section.data;
+  return (
+    <Section id="bias" title="Bias" status={section.status} error={section.error}>
+      {data ? (
+        data.readerCopy ? (
+          <ReaderCopyBody
+            copy={data.readerCopy}
+            labels={new Map(data.findings.map((finding) => [finding.id, finding.displayName]))}
+            citations={
+              new Map(
+                (data.citations ?? []).map((citation: ReaderCitation) => [citation.id, citation]),
+              )
+            }
+          />
+        ) : (
+          <>
+            <p>
+              <ProgressiveText text={data.summary} />
+            </p>
+            {data.findings.map((finding) => (
+              <div className="finding" key={finding.id}>
+                <h3>{finding.displayName}</h3>
+                <blockquote>
+                  <ProgressiveText text={`“${finding.excerpt}”`} />
+                </blockquote>
+                <p>
+                  <ProgressiveText text={finding.explanation} />
+                </p>
+              </div>
+            ))}
+          </>
+        )
+      ) : null}
+    </Section>
+  );
+});
+
+const ConnectedJournalistContext = memo(function ConnectedJournalistContext({
+  store,
+}: {
+  store: ReportStore;
+}) {
+  const section = useReportSection(store, "journalistContext");
+  return (
+    <Section
+      id="journalist-context"
+      title="Journalist Context"
+      status={section.status}
+      error={section.error}
+    >
+      {section.data ? <JournalistBody result={section.data} /> : null}
+    </Section>
+  );
+});
+
+const ConnectedEvidence = memo(function ConnectedEvidence({
+  store,
+  section: sectionKey,
+  title,
+  id,
+}: {
+  store: ReportStore;
+  section: "supporting" | "contradicting";
+  title: string;
+  id: string;
+}) {
+  const section = useReportSection(store, sectionKey);
+  return (
+    <Section id={id} title={title} status={section.status} error={section.error}>
+      {section.data ? <EvidenceBody result={section.data} /> : null}
+    </Section>
+  );
+});
+
+const ConnectedAdditionalContext = memo(function ConnectedAdditionalContext({
+  store,
+}: {
+  store: ReportStore;
+}) {
+  const section = useReportSection(store, "additionalContext");
+  return (
+    <Section
+      id="additional-context"
+      title="Additional Context"
+      status={section.status}
+      error={section.error}
+    >
+      {section.data ? <AdditionalContextBody result={section.data} /> : null}
+    </Section>
+  );
+});
+
+const ConnectedSourceList = memo(function ConnectedSourceList({ store }: { store: ReportStore }) {
+  const section = useReportSection(store, "sourceList");
+  return (
+    <Section id="sources" title="Works Cited" status={section.status} error={section.error}>
+      {section.data ? <SourceListBody result={section.data} /> : null}
+    </Section>
+  );
+});
+
 function AnalysisReport({ preferences, onOpenSettings }: AnalysisReportProps) {
   const reportStoreRef = useRef<ReportStore | null>(null);
   reportStoreRef.current ??= new ReportStore();
@@ -558,111 +690,28 @@ function AnalysisReport({ preferences, onOpenSettings }: AnalysisReportProps) {
           <PartialReportNotice onRetry={retryIncompleteSections} />
         ) : null}
 
-        {state.compass.data ? (
-          <>
-            <Compass result={state.compass.data} />
-            {state.compass.status === "error" ? <ProvisionalCompassWarning /> : null}
-          </>
-        ) : (
-          <div className="compass-placeholder">
-            <TargetIcon />
-            <span>
-              <small>Political Spectrum</small>
-              <strong>
-                {state.compass.status === "error" ? "Unavailable" : "Finding placement…"}
-              </strong>
-            </span>
-          </div>
-        )}
-
-        <Section id="bias" title="Bias" status={state.bias.status} error={state.bias.error}>
-          {state.bias.data ? (
-            state.bias.data.readerCopy ? (
-              <ReaderCopyBody
-                copy={state.bias.data.readerCopy}
-                labels={
-                  new Map(
-                    state.bias.data.findings.map((finding) => [finding.id, finding.displayName]),
-                  )
-                }
-                citations={
-                  new Map(
-                    (state.bias.data.citations ?? []).map((citation: ReaderCitation) => [
-                      citation.id,
-                      citation,
-                    ]),
-                  )
-                }
-              />
-            ) : (
-              <>
-                <p>
-                  <ProgressiveText text={state.bias.data.summary} />
-                </p>
-                {state.bias.data.findings.map((finding) => (
-                  <div className="finding" key={finding.id}>
-                    <h3>{finding.displayName}</h3>
-                    <blockquote>
-                      <ProgressiveText text={`“${finding.excerpt}”`} />
-                    </blockquote>
-                    <p>
-                      <ProgressiveText text={finding.explanation} />
-                    </p>
-                  </div>
-                ))}
-              </>
-            )
-          ) : null}
-        </Section>
-
-        <Section
-          id="journalist-context"
-          title="Journalist Context"
-          status={state.journalistContext.status}
-          error={state.journalistContext.error}
-        >
-          {state.journalistContext.data ? (
-            <JournalistBody result={state.journalistContext.data} />
-          ) : null}
-        </Section>
-
-        <Section
+        <ConnectedCompass store={reportStore} />
+        <ConnectedBias store={reportStore} />
+        <ConnectedJournalistContext store={reportStore} />
+        <ConnectedEvidence
+          store={reportStore}
+          section="supporting"
           id="supporting"
           title="Supporting Information"
-          status={state.supporting.status}
-          error={state.supporting.error}
-        >
-          {state.supporting.data ? <EvidenceBody result={state.supporting.data} /> : null}
-        </Section>
-
-        <Section
+        />
+        <ConnectedEvidence
+          store={reportStore}
+          section="contradicting"
           id="contradicting"
           title="Contradicting Information"
-          status={state.contradicting.status}
-          error={state.contradicting.error}
-        >
-          {state.contradicting.data ? <EvidenceBody result={state.contradicting.data} /> : null}
-        </Section>
-
-        <Section
-          id="additional-context"
-          title="Additional Context"
-          status={state.additionalContext.status}
-          error={state.additionalContext.error}
-        >
-          {state.additionalContext.data ? (
-            <AdditionalContextBody result={state.additionalContext.data} />
-          ) : null}
-        </Section>
+        />
+        <ConnectedAdditionalContext store={reportStore} />
+        <ConnectedSourceList store={reportStore} />
 
-        <Section
-          id="sources"
-          title="Works Cited"
-          status={state.sourceList.status}
-          error={state.sourceList.error}
-        >
-          {state.sourceList.data ? <SourceListBody result={state.sourceList.data} /> : null}
-        </Section>
+        {/* Legacy section markup removed in favor of connected sections.
+                {state.compass.status === "error" ? "Unavailable" : "Finding placement…"}
+                      <ProgressiveText text={`“${finding.excerpt}”`} />
+        */}
 
         <footer className="telemetry-footer">
           <button
@@ -783,24 +832,39 @@ function ChatGptApp() {
     };
   }, []);
 
-  const updatePreferences = (next: SettingsPreferences) => {
-    if (!runtime) return;
+  const updatePreferences = async (next: SettingsPreferences): Promise<void> => {
+    if (!runtime) throw new Error("Perspectica settings are still loading.");
+    const previous = runtime;
     const updated: ExtensionPreferences = {
       ...runtime.preferences,
       ...next,
     };
     setRuntime({ ...runtime, preferences: updated });
-    void updateExtensionPreferences(updated);
+    try {
+      const saved = await updateExtensionPreferences(updated);
+      setRuntime((current) => (current ? { ...current, preferences: saved } : current));
+    } catch (error) {
+      setRuntime(previous);
+      throw error;
+    }
   };
 
   const updateSearchProvider = async (provider: SearchProviderKind) => {
     if (!runtime) throw new Error("Perspectica settings are still loading.");
+    const previous = runtime;
     const test = await testSearchProvider(provider);
     if (!test.available) throw new Error(`${provider} search is not available.`);
     const updated = { ...runtime.preferences, searchProvider: provider };
     setRuntime({ ...runtime, preferences: updated });
     setProviderReady(true);
-    await updateExtensionPreferences(updated);
+    try {
+      const saved = await updateExtensionPreferences(updated);
+      setRuntime((current) => (current ? { ...current, preferences: saved } : current));
+    } catch (error) {
+      setRuntime(previous);
+      setProviderReady(previous.preferences.searchProvider === "chatgpt" || previous.hasExaKey);
+      throw error;
+    }
   };
 
   let page: ReactNode;
diff --git a/apps/extension/entrypoints/sidepanel/ChatGptConnection.tsx b/apps/extension/entrypoints/sidepanel/ChatGptConnection.tsx
index 772c3a8..e318a64 100644
--- a/apps/extension/entrypoints/sidepanel/ChatGptConnection.tsx
+++ b/apps/extension/entrypoints/sidepanel/ChatGptConnection.tsx
@@ -79,13 +79,27 @@ export function usePerspecticaChatGpt(): PerspecticaChatGptConnection {
           setAuth(result.state);
           setDevice(null);
           setConnecting(false);
+          setError(null);
           return;
         }
         timer = setTimeout(poll, Math.max(1_500, device.intervalMs));
       } catch (cause) {
         if (cancelled) return;
-        setError(cause instanceof Error ? cause.message : "ChatGPT sign-in did not finish.");
-        setConnecting(false);
+        if (Date.now() >= device.expiresAt) {
+          setAuth((current) => ({
+            ...current,
+            status: "expired",
+            error: "The one-time sign-in code expired. Start a new Login with ChatGPT flow.",
+          }));
+          setDevice(null);
+          setConnecting(false);
+          return;
+        }
+        // Polling errors are transient (the browser may briefly lose access
+        // to OpenAI). Keep the device authorization alive and schedule the
+        // next poll instead of leaving the UI permanently pending.
+        setError(cause instanceof Error ? cause.message : "ChatGPT sign-in is still pending.");
+        timer = setTimeout(poll, Math.max(1_500, device.intervalMs));
       }
     };
     timer = setTimeout(poll, Math.max(500, device.intervalMs));
diff --git a/apps/extension/entrypoints/sidepanel/SettingsScreen.tsx b/apps/extension/entrypoints/sidepanel/SettingsScreen.tsx
index 1375686..3b79c46 100644
--- a/apps/extension/entrypoints/sidepanel/SettingsScreen.tsx
+++ b/apps/extension/entrypoints/sidepanel/SettingsScreen.tsx
@@ -18,7 +18,7 @@ export type SettingsPreferences = AnalysisPreferences & { mode: AnalysisMode };
 interface SettingsScreenProps {
   authenticated: boolean;
   preferences: SettingsPreferences;
-  onChange: (preferences: SettingsPreferences) => void;
+  onChange: (preferences: SettingsPreferences) => Promise<void> | void;
   onClose: () => void;
   onDisconnect: () => Promise<void>;
   availableModels?: string[];
@@ -46,6 +46,7 @@ export function SettingsScreen({
   const [exaKey, setExaKey] = useState("");
   const [providerStatus, setProviderStatus] = useState<string | null>(null);
   const [cacheStatus, setCacheStatus] = useState<string | null>(null);
+  const [saveStatus, setSaveStatus] = useState<"idle" | "saving" | "saved" | "error">("idle");
   const dialogRef = useRef<HTMLDivElement | null>(null);
   const onCloseRef = useRef(onClose);
   const titleId = useId();
@@ -116,6 +117,14 @@ export function SettingsScreen({
     }
   };
 
+  const savePreferences = (next: SettingsPreferences) => {
+    setSaveStatus("saving");
+    void Promise.resolve(onChange(next)).then(
+      () => setSaveStatus("saved"),
+      () => setSaveStatus("error"),
+    );
+  };
+
   return (
     <div
       ref={dialogRef}
@@ -149,7 +158,7 @@ export function SettingsScreen({
                 type="button"
                 aria-pressed={preferences.mode === mode}
                 className={preferences.mode === mode ? "selected" : undefined}
-                onClick={() => onChange({ ...preferences, mode })}
+                onClick={() => savePreferences({ ...preferences, mode })}
                 key={mode}
               >
                 {label}
@@ -194,7 +203,7 @@ export function SettingsScreen({
               id="analysis-model"
               value={preferences.model}
               onChange={(event) =>
-                onChange({
+                savePreferences({
                   ...preferences,
                   model: event.target.value as AnalysisModel,
                 })
@@ -319,7 +328,7 @@ export function SettingsScreen({
                 aria-pressed={preferences.reasoningEffort === effort.value}
                 className={preferences.reasoningEffort === effort.value ? "selected" : undefined}
                 onClick={() =>
-                  onChange({
+                  savePreferences({
                     ...preferences,
                     reasoningEffort: effort.value,
                   })
@@ -362,7 +371,15 @@ export function SettingsScreen({
           ) : null}
         </section>
 
-        <p className="settings-saved">Changes are saved automatically.</p>
+        <p className="settings-saved" role="status" aria-live="polite">
+          {saveStatus === "saving"
+            ? "Saving changes…"
+            : saveStatus === "saved"
+              ? "Changes saved."
+              : saveStatus === "error"
+                ? "Could not save changes. Your previous settings were restored."
+                : "Changes save automatically."}
+        </p>
       </main>
     </div>
   );
diff --git a/apps/extension/entrypoints/sidepanel/api.test.ts b/apps/extension/entrypoints/sidepanel/api.test.ts
index 02f795e..31a674a 100644
--- a/apps/extension/entrypoints/sidepanel/api.test.ts
+++ b/apps/extension/entrypoints/sidepanel/api.test.ts
@@ -302,6 +302,81 @@ describe("V2 append-only stream replay", () => {
     expect(received).toHaveLength(1);
   });
 
+  it("replays the exact missing range before applying an out-of-order live event", async () => {
+    const initial = job();
+    const stream = setup(initial);
+    let replayCount = 0;
+    runtime.sendRuntimeRequest.mockImplementation(
+      async (request: { type: string; lastSequence?: number }) => {
+        if (request.type === "runtime.getState")
+          return {
+            runtimeProtocol: 6,
+            auth: {
+              status: "authenticated",
+              account: null,
+              remembered: true,
+              models: [],
+              error: null,
+            },
+            preferences: {
+              ...preferences,
+              mode: "balanced",
+              searchProvider: "chatgpt",
+              rememberChatGpt: true,
+            },
+            activeJob: initial,
+            hasExaKey: false,
+          };
+        if (request.type === "analysis.start") return initial;
+        if (request.type === "analysis.getEventsSince") {
+          replayCount += 1;
+          return replayCount === 1
+            ? { jobId: initial.id, lastSequence: 0, events: [], complete: false }
+            : {
+                jobId: initial.id,
+                lastSequence: 2,
+                events: [
+                  {
+                    jobId: initial.id,
+                    runToken: "run-1",
+                    sequence: 1,
+                    revision: 1,
+                    event: event("metadata.ready", 1),
+                  },
+                  {
+                    jobId: initial.id,
+                    runToken: "run-1",
+                    sequence: 2,
+                    revision: 2,
+                    event: event("phase.changed", 2),
+                  },
+                ],
+                complete: false,
+              };
+        }
+        return initial;
+      },
+    );
+    const received: PipelineEvent[] = [];
+    const pending = streamAnalysis(received.push.bind(received), undefined, preferences);
+    await vi.waitFor(() => expect(replayCount).toBe(1));
+    stream.emit({
+      type: "analysis.eventDelta",
+      jobId: initial.id,
+      runToken: "run-1",
+      revision: 3,
+      sequence: 3,
+      event: event("analysis.completed", 3),
+    });
+
+    await expect(pending).resolves.toBeUndefined();
+    expect(received.map((value) => value.type)).toEqual([
+      "metadata.ready",
+      "phase.changed",
+      "analysis.completed",
+    ]);
+  });
+
   it("rejects terminal failure and sends one cancellation on abort", async () => {
     const initial = job();
     const stream = setup(initial);
diff --git a/apps/extension/entrypoints/sidepanel/api.ts b/apps/extension/entrypoints/sidepanel/api.ts
index 223d805..6d790b4 100644
--- a/apps/extension/entrypoints/sidepanel/api.ts
+++ b/apps/extension/entrypoints/sidepanel/api.ts
@@ -157,8 +157,18 @@ export async function streamAnalysis(
         },
   );
   let deliveredSequence = options?.retrySections?.length ? job.lastEventSequence : 0;
-  let deliveredRevision = 0;
   let settled = false;
+  let replayInFlight: Promise<void> | null = null;
+  let replayRequested = false;
+  let connectedReplayStarted = false;
+  type StreamEnvelope = {
+    jobId: string;
+    runToken: string;
+    sequence: number;
+    revision: number;
+    event: PipelineEvent;
+  };
+  const pendingEnvelopes = new Map<number, StreamEnvelope>();
   let resolveDone: (() => void) | undefined;
   let rejectDone: ((error: Error) => void) | undefined;
   let unsubscribe: () => void = () => {};
@@ -203,50 +213,80 @@ export async function streamAnalysis(
       rejectDone?.(abortError());
     }
   };
-  const applyEnvelope = (envelope: {
-    jobId: string;
-    runToken: string;
-    sequence: number;
-    revision: number;
-    event: PipelineEvent;
-  }) => {
+  const applyEnvelope = (envelope: StreamEnvelope, fromReplay = false) => {
     if (settled || envelope.jobId !== job.id || envelope.runToken !== (job.runToken ?? "")) return;
     if (envelope.sequence <= deliveredSequence) return;
+    if (envelope.sequence !== deliveredSequence + 1) {
+      pendingEnvelopes.set(envelope.sequence, envelope);
+      if (!fromReplay) void replay();
+      return;
+    }
     deliveredSequence = envelope.sequence;
-    deliveredRevision = Math.max(deliveredRevision, envelope.revision);
     onEvent(envelope.event);
     finishFromEvent(envelope.event);
+    while (!settled) {
+      const next = pendingEnvelopes.get(deliveredSequence + 1);
+      if (!next) break;
+      pendingEnvelopes.delete(next.sequence);
+      applyEnvelope(next, true);
+    }
   };
   const replay = async () => {
     if (settled) return;
-    const response = await sendRuntimeRequest<{
-      jobId: string;
-      lastSequence: number;
-      events: Array<{
-        jobId: string;
-        runToken: string;
-        sequence: number;
-        revision: number;
-        event: PipelineEvent;
-      }>;
-      complete: boolean;
-    }>({ type: "analysis.getEventsSince", jobId: job.id, lastSequence: deliveredSequence });
-    for (const envelope of response.events) applyEnvelope(envelope);
-    deliveredRevision = Math.max(deliveredRevision, job.revision ?? 0);
-    const finalJob = response.complete
-      ? await sendRuntimeRequest<AnalysisJob>({ type: "analysis.getJob", jobId: job.id })
-      : null;
-    if (!settled && finalJob && terminal(finalJob.status)) {
-      settled = true;
-      cleanup();
-      if (finalJob.status === "failed") {
-        rejectDone?.(new Error(finalJob.error ?? "The analysis failed."));
-      } else if (finalJob.status === "cancelled") {
-        rejectDone?.(abortError());
-      } else {
-        resolveDone?.();
-      }
+    if (replayInFlight) {
+      replayRequested = true;
+      return replayInFlight;
     }
+    replayInFlight = (async () => {
+      do {
+        replayRequested = false;
+        let hasMore = true;
+        while (!settled && hasMore) {
+          const response = await sendRuntimeRequest<{
+            jobId: string;
+            lastSequence: number;
+            hasMore?: boolean;
+            events: StreamEnvelope[];
+            complete: boolean;
+          }>({ type: "analysis.getEventsSince", jobId: job.id, lastSequence: deliveredSequence });
+          const events = [...response.events].sort((left, right) => left.sequence - right.sequence);
+          if (
+            events.length === 0 &&
+            response.lastSequence > deliveredSequence &&
+            !response.complete
+          )
+            throw new Error(
+              "The analysis journal has a missing event gap. Reconnect and try again.",
+            );
+          for (const envelope of events) applyEnvelope(envelope, true);
+          const lastReturned = events.at(-1)?.sequence ?? deliveredSequence;
+          hasMore = Boolean(response.hasMore) || lastReturned < response.lastSequence;
+          if (hasMore && events.length === 0)
+            throw new Error("The analysis journal could not replay its next event.");
+          if (!hasMore && response.lastSequence > deliveredSequence)
+            throw new Error(
+              "The analysis journal has a missing event gap. Reconnect and try again.",
+            );
+        }
+        const finalJob =
+          !settled &&
+          (await sendRuntimeRequest<AnalysisJob>({ type: "analysis.getJob", jobId: job.id }));
+        if (!settled && finalJob && terminal(finalJob.status)) {
+          settled = true;
+          cleanup();
+          if (finalJob.status === "failed") {
+            rejectDone?.(new Error(finalJob.error ?? "The analysis failed."));
+          } else if (finalJob.status === "cancelled") {
+            rejectDone?.(abortError());
+          } else {
+            resolveDone?.();
+          }
+        }
+      } while (!settled && replayRequested);
+    })().finally(() => {
+      replayInFlight = null;
+    });
+    return replayInFlight;
   };
   unsubscribe = subscribeRuntimePushWithStatus(
     (message) => {
@@ -267,15 +307,21 @@ export async function streamAnalysis(
     },
     (status) => {
       onStatus?.(status);
-      if (status === "connected" && deliveredSequence > 0) void replay();
+      if (status === "connected") {
+        connectedReplayStarted = true;
+        void replay();
+      }
     },
   );
-  onStatus?.("connected");
   if (signal) {
     signal.addEventListener("abort", onAbort, { once: true });
     abortListenerAttached = true;
     if (signal.aborted) onAbort();
   }
-  await abortable(replay(), signal);
+  if (!connectedReplayStarted) {
+    connectedReplayStarted = true;
+    void replay();
+  }
+  await abortable(replayInFlight ?? Promise.resolve(), signal);
   if (!settled) await done;
 }
diff --git a/apps/extension/entrypoints/sidepanel/report-state.test.ts b/apps/extension/entrypoints/sidepanel/report-state.test.ts
index a347116..eb90cd3 100644
--- a/apps/extension/entrypoints/sidepanel/report-state.test.ts
+++ b/apps/extension/entrypoints/sidepanel/report-state.test.ts
@@ -56,6 +56,7 @@ describe("reducePipelineEvent", () => {
       event({
         type: "research.progress",
         data: {
+          candidateCount: 0,
           completedMissions: 1,
           totalMissions: 3,
           acceptedSources: 2,
diff --git a/apps/extension/entrypoints/sidepanel/report-state.ts b/apps/extension/entrypoints/sidepanel/report-state.ts
index f820fda..dd97df9 100644
--- a/apps/extension/entrypoints/sidepanel/report-state.ts
+++ b/apps/extension/entrypoints/sidepanel/report-state.ts
@@ -45,6 +45,7 @@ export interface IndexedArticleSummary {
 }
 
 export interface ResearchProgress {
+  candidateCount: number;
   completedMissions: number;
   totalMissions: number;
   acceptedSources: number;
diff --git a/apps/extension/src/providers/chatgpt-evidence.ts b/apps/extension/src/providers/chatgpt-evidence.ts
index 5f57d6d..31c72a7 100644
--- a/apps/extension/src/providers/chatgpt-evidence.ts
+++ b/apps/extension/src/providers/chatgpt-evidence.ts
@@ -1,29 +1,23 @@
 import type { ChatGPTProvider } from "@opencoredev/loginwithchatgpt-ai";
 import { generateText } from "ai";
+import { EvidenceBatchSchema } from "@perspectica/contracts/evidence";
 import type {
+  EvidenceCandidate,
   EvidenceBatch,
-  EvidenceCard,
   EvidenceRetriever,
   RetrievalPlan,
 } from "@perspectica/contracts/evidence";
 import { normalizeCanonicalUrl } from "@perspectica/contracts/url";
+import { sourceIdFor } from "@perspectica/intelligence";
 import type { EvidenceResultCache } from "../storage/evidence-cache";
 
 type GeneratedSource = Awaited<ReturnType<typeof generateText>>["sources"][number];
 type GeneratedUrlSource = Extract<GeneratedSource, { sourceType: "url" }>;
 
-function sourceType(url: string): EvidenceCard["sourceType"] {
+function sourceType(url: string): EvidenceCandidate["sourceType"] {
   return /\.(?:gov|mil|edu)(?:\.|\/|$)/i.test(url) ? "primary-record" : "independent-reporting";
 }
 
-function relationship(plan: RetrievalPlan["missions"][number]): EvidenceCard["relationship"] {
-  return plan.purpose === "correction-or-qualification"
-    ? "qualifies"
-    : plan.purpose === "comparable-coverage"
-      ? "adds-context"
-      : "supports";
-}
-
 function hostname(url: string): string {
   try {
     return new URL(url).hostname.replace(/^www\./, "");
@@ -69,25 +63,21 @@ export class NativeChatGptEvidenceRetriever implements EvidenceRetriever {
         })),
       });
       const cached = await this.persistentCache?.get<EvidenceBatch[]>(cacheKey);
-      if (cached?.length) {
+      const cachedBatches = (cached ?? [])
+        .map((batch) => EvidenceBatchSchema.safeParse(batch))
+        .flatMap((parsed) => (parsed.success ? [parsed.data] : []));
+      if (cachedBatches.length) {
         this.onDiagnostics?.({
           missionCount: plan.missions.length,
           durationMs: Date.now() - startedAt,
-          sourceCount: cached.reduce((total, batch) => total + batch.cards.length, 0),
+          sourceCount: cachedBatches.reduce((total, batch) => total + batch.candidates.length, 0),
           cacheHit: true,
           outcome: "ready",
         });
-        for (const [index, batch] of cached.entries()) {
-          const mission = plan.missions[index];
-          if (!mission) continue;
+        for (const batch of cachedBatches) {
           yield {
             ...batch,
-            missionId: mission.id,
-            cards: batch.cards.map((card) => ({
-              ...card,
-              missionId: mission.id,
-              claimId: mission.claimIds[0] ?? null,
-            })),
+            coveredMissionIds: plan.missions.map((mission) => mission.id),
             searched: false,
             cacheHit: true,
             durationMs: 0,
@@ -117,7 +107,7 @@ export class NativeChatGptEvidenceRetriever implements EvidenceRetriever {
         prompt,
         maxRetries: 1,
         timeout: {
-          totalMs: Math.min(60_000, Math.max(20_000, plan.deadlineAt - Date.now())),
+          totalMs: Math.min(60_000, Math.max(1_000, plan.deadlineAt - Date.now())),
           firstChunkMs: 45_000,
           chunkMs: 30_000,
         },
@@ -130,41 +120,40 @@ export class NativeChatGptEvidenceRetriever implements EvidenceRetriever {
           return [{ source, url }];
         });
       const unique = [...new Map(sources.map((item) => [item.url, item])).values()];
-      const cardsByMission = new Map<string, EvidenceCard[]>();
-      unique.forEach(({ source, url }, index) => {
-        const mission = plan.missions[index % plan.missions.length]!;
-        const statement = `Native ChatGPT web search surfaced ${source.title?.trim() || hostname(url)} as a relevant source for this mission. The linked page was not fetched as a transcript.`;
-        const card: EvidenceCard = {
-          missionId: mission.id,
-          claimId: mission.claimIds[0] ?? null,
-          sourceUrl: url,
-          title: source.title?.trim() || hostname(url),
-          publication: hostname(url),
-          publishedAt: null,
-          statement,
-          excerpt: null,
-          content: statement,
-          contentKind: "search-summary",
-          relationship: relationship(mission),
-          sourceType: sourceType(url),
-          confidence: 0.42,
-          provider: "chatgpt",
-        };
-        cardsByMission.set(mission.id, [...(cardsByMission.get(mission.id) ?? []), card]);
-      });
-      const batches = plan.missions.map((mission) => ({
-        missionId: mission.id,
-        provider: "chatgpt" as const,
-        cards: cardsByMission.get(mission.id) ?? [],
-        searched: true,
-        cacheHit: false,
-        durationMs: Date.now() - startedAt,
+      const discoveryContext = result.text.trim().slice(0, 20_000) || null;
+      const candidates: EvidenceCandidate[] = unique.map(({ source, url }) => ({
+        id: sourceIdFor(url, "candidate"),
+        missionId: null,
+        sourceUrl: url,
+        title: source.title?.trim() || hostname(url),
+        publication: hostname(url),
+        publishedAt: null,
+        content: discoveryContext ?? `Native web search returned ${hostname(url)}.`,
+        contentKind: "search-summary",
+        sourceType: sourceType(url),
+        discoveryContext,
+        discoveryExcerpt: null,
+        providerScore: null,
+        provider: "chatgpt",
       }));
+      const batches: EvidenceBatch[] = [
+        {
+          missionId: "global-search",
+          provider: "chatgpt" as const,
+          candidates,
+          coveredMissionIds: plan.missions.map((mission) => mission.id),
+          status: "completed",
+          error: null,
+          searched: true,
+          cacheHit: false,
+          durationMs: Date.now() - startedAt,
+        },
+      ];
       await this.persistentCache?.set(cacheKey, batches, 30 * 60_000);
       this.onDiagnostics?.({
         missionCount: plan.missions.length,
         durationMs: Date.now() - startedAt,
-        sourceCount: unique.length,
+        sourceCount: candidates.length,
         cacheHit: false,
         outcome: "ready",
       });
@@ -177,7 +166,18 @@ export class NativeChatGptEvidenceRetriever implements EvidenceRetriever {
         outcome: "failed",
         error: error instanceof Error ? error.message : String(error),
       });
-      throw error;
+      if (signal.aborted) throw error;
+      yield {
+        missionId: "global-search",
+        provider: "chatgpt",
+        candidates: [],
+        coveredMissionIds: plan.missions.map((mission) => mission.id),
+        status: "failed",
+        error: error instanceof Error ? error.message : String(error),
+        searched: true,
+        cacheHit: false,
+        durationMs: Date.now() - startedAt,
+      };
     }
   }
 }
diff --git a/apps/extension/src/providers/evidence.test.ts b/apps/extension/src/providers/evidence.test.ts
index 5aaa62d..5e06aae 100644
--- a/apps/extension/src/providers/evidence.test.ts
+++ b/apps/extension/src/providers/evidence.test.ts
@@ -56,11 +56,13 @@ describe("V2 evidence providers", () => {
       batches.push(batch);
 
     expect(fetchImplementation).toHaveBeenCalledTimes(1);
-    expect(batches[0]?.cards[0]).toMatchObject({
+    expect(batches[0]?.candidates[0]).toMatchObject({
       sourceUrl: "https://city.gov/record",
       contentKind: "source-text",
-      excerpt: "The council approved the housing plan.",
+      discoveryExcerpt: "The council approved the housing plan.",
     });
+    expect(batches[0]?.candidates[0]).not.toHaveProperty("relationship");
+    expect(batches[0]?.candidates[0]).not.toHaveProperty("statement");
   });
 
   it("makes one native global search call and emits non-quoteable summaries", async () => {
@@ -78,10 +80,12 @@ describe("V2 evidence providers", () => {
       batches.push(batch);
 
     expect(generateText).toHaveBeenCalledTimes(1);
-    expect(batches[0]?.cards[0]).toMatchObject({
+    expect(batches[0]?.candidates[0]).toMatchObject({
       contentKind: "search-summary",
-      excerpt: null,
       sourceUrl: "https://city.gov/record",
+      missionId: null,
     });
+    expect(batches[0]?.candidates[0]).not.toHaveProperty("relationship");
+    expect(batches[0]?.candidates[0]).not.toHaveProperty("excerpt");
   });
 });
diff --git a/apps/extension/src/providers/exa-evidence.ts b/apps/extension/src/providers/exa-evidence.ts
index baf9a32..759a18a 100644
--- a/apps/extension/src/providers/exa-evidence.ts
+++ b/apps/extension/src/providers/exa-evidence.ts
@@ -1,12 +1,12 @@
+import { EvidenceCandidateSchema } from "@perspectica/contracts/evidence";
 import type {
+  EvidenceCandidate,
   EvidenceBatch,
   EvidenceRetriever,
   RetrievalPlan,
-  RetrievalMission,
-  EvidenceCard,
 } from "@perspectica/contracts/evidence";
 import { normalizeCanonicalUrl } from "@perspectica/contracts/url";
-import { runPriorityTasks } from "@perspectica/intelligence";
+import { runPriorityTasksStream, sourceIdFor } from "@perspectica/intelligence";
 import type { EvidenceResultCache } from "../storage/evidence-cache";
 import { z } from "zod";
 
@@ -37,15 +37,7 @@ function publication(url: string): string {
   }
 }
 
-function relationship(mission: RetrievalMission): EvidenceCard["relationship"] {
-  if (mission.purpose === "correction-or-qualification") return "qualifies";
-  if (mission.purpose === "primary-record" || mission.purpose === "independent-verification")
-    return "supports";
-  if (mission.purpose === "comparable-coverage") return "adds-context";
-  return "adds-context";
-}
-
-function sourceType(url: string): EvidenceCard["sourceType"] {
+function sourceType(url: string): EvidenceCandidate["sourceType"] {
   return /\.(?:gov|mil|edu)(?:\.|\/|$)/i.test(url) ||
     /(?:record|filing|bill|data|report|pdf)/i.test(url)
     ? "primary-record"
@@ -59,7 +51,7 @@ function publishedAt(value: string | null | undefined): string | null {
 }
 
 export class ExaEvidenceRetriever implements EvidenceRetriever {
-  private readonly cache = new Map<string, { expiresAt: number; results: EvidenceCard[] }>();
+  private readonly cache = new Map<string, { expiresAt: number; results: EvidenceCandidate[] }>();
 
   constructor(
     private readonly apiKey: string,
@@ -68,7 +60,14 @@ export class ExaEvidenceRetriever implements EvidenceRetriever {
     private readonly persistentCache?: EvidenceResultCache,
   ) {}
 
-  private async search(mission: RetrievalMission, signal: AbortSignal): Promise<EvidenceBatch> {
+  private async search(
+    mission: RetrievalPlan["missions"][number],
+    signal: AbortSignal,
+  ): Promise<EvidenceBatch> {
+    if (signal.aborted)
+      throw signal.reason instanceof Error
+        ? signal.reason
+        : new DOMException("Evidence retrieval deadline reached.", "TimeoutError");
     const startedAt = Date.now();
     const query = mission.queryVariants[0] ?? "independent context";
     const cacheKey = JSON.stringify({
@@ -79,23 +78,33 @@ export class ExaEvidenceRetriever implements EvidenceRetriever {
     });
     const cached = this.cache.get(cacheKey);
     if (cached && cached.expiresAt > Date.now()) {
+      const candidates = cached.results.map((candidate) => ({
+        ...candidate,
+        missionId: mission.id,
+      }));
       this.onDiagnostics?.({
         missionId: mission.id,
         durationMs: Date.now() - startedAt,
-        resultCount: cached.results.length,
+        resultCount: candidates.length,
         cacheHit: true,
         outcome: "ready",
       });
       return {
         missionId: mission.id,
         provider: "exa",
-        cards: cached.results,
+        candidates,
+        coveredMissionIds: [mission.id],
+        status: "completed",
+        error: null,
         searched: true,
         cacheHit: true,
         durationMs: Date.now() - startedAt,
       };
     }
-    const persisted = await this.persistentCache?.get<EvidenceCard[]>(cacheKey);
+    const persistedRaw = await this.persistentCache?.get<unknown[]>(cacheKey);
+    const persisted = (persistedRaw ?? [])
+      .map((candidate) => EvidenceCandidateSchema.safeParse(candidate))
+      .flatMap((parsed) => (parsed.success ? [{ ...parsed.data, missionId: mission.id }] : []));
     if (persisted?.length) {
       this.cache.set(cacheKey, { expiresAt: Date.now() + 24 * 60 * 60_000, results: persisted });
       this.onDiagnostics?.({
@@ -108,7 +117,10 @@ export class ExaEvidenceRetriever implements EvidenceRetriever {
       return {
         missionId: mission.id,
         provider: "exa",
-        cards: persisted,
+        candidates: persisted,
+        coveredMissionIds: [mission.id],
+        status: "completed",
+        error: null,
         searched: false,
         cacheHit: true,
         durationMs: Date.now() - startedAt,
@@ -133,7 +145,7 @@ export class ExaEvidenceRetriever implements EvidenceRetriever {
     });
     if (!response.ok) throw new Error(`Exa search failed (${response.status}).`);
     const parsed = ExaResponseSchema.parse(await response.json());
-    const cards: EvidenceCard[] = parsed.results.flatMap((raw) => {
+    const candidates: EvidenceCandidate[] = parsed.results.flatMap((raw) => {
       const result = ExaResultSchema.safeParse(raw);
       if (!result.success) return [];
       const url = normalizeCanonicalUrl(result.data.url);
@@ -149,37 +161,40 @@ export class ExaEvidenceRetriever implements EvidenceRetriever {
       const excerpt = (result.data.highlights?.[0] ?? content.slice(0, 360)).trim();
       return [
         {
+          id: sourceIdFor(url, "candidate"),
           missionId: mission.id,
-          claimId: mission.claimIds[0] ?? null,
           sourceUrl: url,
           title: result.data.title?.trim() || publication(url),
           publication: publication(url),
           publishedAt: publishedAt(result.data.publishedDate),
-          statement: excerpt,
-          excerpt,
           content,
           contentKind: "source-text",
-          relationship: relationship(mission),
           sourceType: sourceType(url),
-          confidence: Math.max(0.35, Math.min(0.95, result.data.score ?? 0.65)),
+          discoveryContext: null,
+          discoveryExcerpt: excerpt,
+          providerScore:
+            result.data.score == null ? null : Math.max(0, Math.min(1, result.data.score)),
           provider: "exa",
-        } satisfies EvidenceCard,
+        } satisfies EvidenceCandidate,
       ];
     });
-    this.cache.set(cacheKey, { expiresAt: Date.now() + 24 * 60 * 60_000, results: cards });
-    await this.persistentCache?.set(cacheKey, cards, 24 * 60 * 60_000);
+    this.cache.set(cacheKey, { expiresAt: Date.now() + 24 * 60 * 60_000, results: candidates });
+    await this.persistentCache?.set(cacheKey, candidates, 24 * 60 * 60_000);
     if (this.cache.size > 96) this.cache.delete(this.cache.keys().next().value ?? "");
     this.onDiagnostics?.({
       missionId: mission.id,
       durationMs: Date.now() - startedAt,
-      resultCount: cards.length,
+      resultCount: candidates.length,
       cacheHit: false,
       outcome: "ready",
     });
     return {
       missionId: mission.id,
       provider: "exa",
-      cards,
+      candidates,
+      coveredMissionIds: [mission.id],
+      status: "completed",
+      error: null,
       searched: true,
       cacheHit: false,
       durationMs: Date.now() - startedAt,
@@ -187,6 +202,19 @@ export class ExaEvidenceRetriever implements EvidenceRetriever {
   }
 
   async *retrieve(plan: RetrievalPlan, signal: AbortSignal): AsyncIterable<EvidenceBatch> {
+    const controller = new AbortController();
+    const abortFromParent = () => controller.abort(signal.reason);
+    if (signal.aborted) abortFromParent();
+    else signal.addEventListener("abort", abortFromParent, { once: true });
+    const deadlineTimer = setTimeout(
+      () => {
+        if (!controller.signal.aborted)
+          controller.abort(
+            new DOMException("Evidence retrieval deadline reached.", "TimeoutError"),
+          );
+      },
+      Math.max(0, plan.deadlineAt - Date.now()),
+    );
     const tasks = [...plan.missions]
       .sort((left, right) => right.priority - left.priority)
       .map((mission) => ({
@@ -194,7 +222,11 @@ export class ExaEvidenceRetriever implements EvidenceRetriever {
         run: async (): Promise<EvidenceBatch> => {
           const startedAt = Date.now();
           try {
-            return await this.search(mission, signal);
+            if (controller.signal.aborted)
+              throw controller.signal.reason instanceof Error
+                ? controller.signal.reason
+                : new DOMException("Evidence retrieval deadline reached.", "TimeoutError");
+            return await this.search(mission, controller.signal);
           } catch (error) {
             if (signal.aborted) throw error;
             this.onDiagnostics?.({
@@ -208,7 +240,10 @@ export class ExaEvidenceRetriever implements EvidenceRetriever {
             return {
               missionId: mission.id,
               provider: "exa",
-              cards: [],
+              candidates: [],
+              coveredMissionIds: [mission.id],
+              status: "failed",
+              error: error instanceof Error ? error.message : String(error),
               searched: true,
               cacheHit: false,
               durationMs: Date.now() - startedAt,
@@ -216,10 +251,14 @@ export class ExaEvidenceRetriever implements EvidenceRetriever {
           }
         },
       }));
-    const batches = await runPriorityTasks(tasks, plan.maxConcurrency, signal);
-    for (const batch of batches) {
-      yield batch;
-      if (Date.now() >= plan.deadlineAt) break;
+    try {
+      for await (const batch of runPriorityTasksStream(tasks, plan.maxConcurrency, signal)) {
+        yield batch;
+      }
+    } finally {
+      clearTimeout(deadlineTimer);
+      signal.removeEventListener("abort", abortFromParent);
+      controller.abort();
     }
   }
 }
diff --git a/apps/extension/src/runtime/background-controller.ts b/apps/extension/src/runtime/background-controller.ts
index 999e680..5ab722e 100644
--- a/apps/extension/src/runtime/background-controller.ts
+++ b/apps/extension/src/runtime/background-controller.ts
@@ -1,5 +1,5 @@
 import { ArticleDocumentSchema } from "@perspectica/contracts";
-import type { AnalysisEnvelope, PipelineEvent } from "@perspectica/contracts/events";
+import type { PipelineEvent } from "@perspectica/contracts/events";
 import type { ReportSection } from "@perspectica/contracts/report";
 import { ChatGptSessionManager } from "../auth/chatgpt-session";
 import { ChromeJsonStorageArea, restrictExtensionStorage } from "../storage/areas";
@@ -660,6 +660,7 @@ export class BackgroundController {
           return ok(request.requestId, {
             jobId: request.jobId,
             lastSequence: job.lastEventSequence,
+            hasMore: events.length > 0 && events.at(-1)!.sequence < job.lastEventSequence,
             events,
             complete: terminal(job.status),
           });
@@ -709,55 +710,28 @@ export class BackgroundController {
           return ok(request.requestId, {});
         }
         case "internal.analysis.event": {
-          let envelope: AnalysisEnvelope | null = null;
-          const updated = await this.jobs.update(request.jobId, (job) => {
-            if (
-              !job.runToken ||
-              job.runToken !== request.runToken ||
-              terminal(job.status) ||
-              request.sequence <= job.lastEventSequence
-            ) {
-              return undefined;
-            }
-            const completed =
-              request.event.type === "analysis.completed"
-                ? request.event.data.status
-                : request.event.type === "analysis.failed"
-                  ? "failed"
-                  : request.event.type === "analysis.cancelled"
-                    ? "cancelled"
-                    : null;
-            const revision = job.revision + 1;
-            envelope = {
-              protocol: 2,
-              jobId: request.jobId,
-              runToken: request.runToken,
-              sequence: request.sequence,
-              revision,
-              event: request.event,
-            };
-            return {
-              ...job,
-              events: [],
-              status: completed ?? "analyzing",
-              revision,
-              lastEventSequence: request.sequence,
-              updatedAt: now(),
-              error: null,
-            };
+          const committed = await this.jobs.commitEvent({
+            jobId: request.jobId,
+            runToken: request.runToken,
+            sequence: request.sequence,
+            event: request.event,
           });
-          if (!updated) return ok(request.requestId, { ignored: true });
-          if (envelope) await this.jobs.appendEvent(envelope);
-          await this.publish({ type: "analysis.jobChanged", job: updated });
+          if (committed.gap) throw new Error("The analysis event sequence contained a gap.");
+          if (!committed.accepted || !committed.job || !committed.envelope)
+            return ok(request.requestId, {
+              ignored: true,
+              duplicate: committed.duplicate ?? false,
+            });
+          await this.publish({ type: "analysis.jobChanged", job: committed.job });
           await this.publish({
             type: "analysis.eventDelta",
             jobId: request.jobId,
             runToken: request.runToken,
-            revision: updated.revision,
+            revision: committed.job.revision,
             sequence: request.sequence,
             event: request.event,
           });
-          return ok(request.requestId, { accepted: true, revision: updated.revision });
+          return ok(request.requestId, { accepted: true, revision: committed.job.revision });
         }
         case "internal.analysis.log": {
           const job = await this.jobs.get(request.jobId);
@@ -779,7 +753,6 @@ export class BackgroundController {
               ...job,
               status: "failed",
               revision: job.revision + 1,
-              lastEventSequence: request.sequence,
               updatedAt: now(),
               error: "The analysis ended before it produced a completion event. Try again.",
             };
@@ -801,7 +774,6 @@ export class BackgroundController {
               ...job,
               status: "failed",
               revision: job.revision + 1,
-              lastEventSequence: request.sequence,
               updatedAt: now(),
               error: request.error,
             };
diff --git a/apps/extension/src/storage/job-journal.ts b/apps/extension/src/storage/job-journal.ts
index 05bcb86..14124f8 100644
--- a/apps/extension/src/storage/job-journal.ts
+++ b/apps/extension/src/storage/job-journal.ts
@@ -43,15 +43,37 @@ export class AnalysisJournal {
 
   async appendEvent(envelope: AnalysisEnvelope): Promise<void> {
     const parsed = structuredClone(envelope);
-    this.eventMemory.set(memoryKey(envelope.jobId, envelope.sequence), parsed);
     const db = await this.open();
-    if (!db) return;
+    if (!db) {
+      this.eventMemory.set(memoryKey(envelope.jobId, envelope.sequence), parsed);
+      return;
+    }
     await new Promise<void>((resolve, reject) => {
       const tx = db.transaction(EVENT_STORE, "readwrite");
       tx.objectStore(EVENT_STORE).put(parsed);
       tx.oncomplete = () => resolve();
       tx.onerror = () => reject(tx.error ?? new Error("Could not append analysis event."));
     });
+    this.eventMemory.set(memoryKey(envelope.jobId, envelope.sequence), parsed);
+  }
+
+  async getEvent(jobId: string, sequence: number): Promise<AnalysisEnvelope | undefined> {
+    const cached = this.eventMemory.get(memoryKey(jobId, sequence));
+    if (cached) return structuredClone(cached);
+    const db = await this.open();
+    if (!db) return undefined;
+    return new Promise((resolve) => {
+      const request = db
+        .transaction(EVENT_STORE, "readonly")
+        .objectStore(EVENT_STORE)
+        .get([jobId, sequence]);
+      request.onerror = () => resolve(undefined);
+      request.onsuccess = () => {
+        const value = request.result as AnalysisEnvelope | undefined;
+        if (value) this.eventMemory.set(memoryKey(jobId, sequence), structuredClone(value));
+        resolve(value ? structuredClone(value) : undefined);
+      };
+    });
   }
 
   async eventsSince(
diff --git a/apps/extension/src/storage/job-store.ts b/apps/extension/src/storage/job-store.ts
index f304d7a..b9fb118 100644
--- a/apps/extension/src/storage/job-store.ts
+++ b/apps/extension/src/storage/job-store.ts
@@ -8,7 +8,7 @@ import {
   type AnalysisLogInput,
   type AnalysisResumeData,
 } from "../runtime/messages";
-import type { AnalysisEnvelope } from "@perspectica/contracts/events";
+import type { AnalysisEnvelope, PipelineEvent } from "@perspectica/contracts/events";
 import type { JsonStorageArea } from "./areas";
 import { AnalysisJournal } from "./job-journal";
 
@@ -18,6 +18,14 @@ const LOG_PREFIX = "perspectica.jobs.logs.v1.";
 const RESUME_PREFIX = "perspectica.jobs.resume.v1.";
 const MAX_LOG_ENTRIES = 400;
 
+export interface EventCommitResult {
+  accepted: boolean;
+  duplicate?: boolean;
+  gap?: boolean;
+  job?: AnalysisJob;
+  envelope?: AnalysisEnvelope;
+}
+
 export class JobStore {
   private readonly logTails = new Map<string, Promise<void>>();
   private mutationTail: Promise<void> = Promise.resolve();
@@ -135,8 +143,79 @@ export class JobStore {
     await this.storage.remove(`${LOG_PREFIX}${id}`);
   }
 
-  async appendEvent(envelope: AnalysisEnvelope): Promise<void> {
-    await this.journal.appendEvent(envelope);
+  /**
+   * Persist the journal row before advancing the job cursor. If storage fails
+   * after the row is durable, a retry of the same request finds the row and
+   * completes the cursor update idempotently instead of losing the event.
+   */
+  async commitEvent(input: {
+    jobId: string;
+    runToken: string;
+    sequence: number;
+    event: PipelineEvent;
+  }): Promise<EventCommitResult> {
+    return this.enqueueMutation(async () => {
+      const current = await this.get(input.jobId);
+      if (!current || current.runToken !== input.runToken) {
+        return { accepted: false };
+      }
+      const existing = await this.journal.getEvent(input.jobId, input.sequence);
+      if (existing) {
+        if (
+          existing.runToken !== input.runToken ||
+          JSON.stringify(existing.event) !== JSON.stringify(input.event)
+        )
+          return { accepted: false };
+        if (current.lastEventSequence >= input.sequence)
+          return { accepted: false, duplicate: true, envelope: existing };
+        if (terminalStatus(current.status)) return { accepted: false, envelope: existing };
+        if (input.sequence !== current.lastEventSequence + 1)
+          return { accepted: false, gap: true, envelope: existing };
+        const updated = await this.setCommittedEvent(current, existing);
+        return { accepted: true, job: updated, envelope: existing };
+      }
+      if (terminalStatus(current.status)) return { accepted: false };
+      if (input.sequence <= current.lastEventSequence) return { accepted: false };
+      if (input.sequence !== current.lastEventSequence + 1) return { accepted: false, gap: true };
+      const envelope: AnalysisEnvelope = {
+        protocol: 2,
+        jobId: input.jobId,
+        runToken: input.runToken,
+        sequence: input.sequence,
+        revision: current.revision + 1,
+        event: input.event,
+      };
+      // This write is intentionally before setUnsafe. A failed job write can
+      // be repaired by the same request after a service-worker restart.
+      await this.journal.appendEvent(envelope);
+      const updated = await this.setCommittedEvent(current, envelope);
+      return { accepted: true, job: updated, envelope };
+    });
+  }
+
+  private async setCommittedEvent(
+    current: AnalysisJob,
+    envelope: AnalysisEnvelope,
+  ): Promise<AnalysisJob> {
+    const terminal =
+      envelope.event.type === "analysis.completed"
+        ? envelope.event.data.status
+        : envelope.event.type === "analysis.failed"
+          ? "failed"
+          : envelope.event.type === "analysis.cancelled"
+            ? "cancelled"
+            : null;
+    const updated = AnalysisJobSchema.parse({
+      ...current,
+      events: [],
+      status: terminal ?? "analyzing",
+      revision: envelope.revision,
+      lastEventSequence: envelope.sequence,
+      updatedAt: new Date().toISOString(),
+      error: null,
+    });
+    await this.setUnsafe(updated);
+    return updated;
   }
 
   async getEventsSince(id: string, sequence: number): Promise<AnalysisEnvelope[]> {
@@ -147,3 +226,7 @@ export class JobStore {
     await this.journal.clearEvents(id);
   }
 }
+
+function terminalStatus(status: AnalysisJob["status"]): boolean {
+  return ["complete", "partial", "failed", "cancelled"].includes(status);
+}
diff --git a/apps/extension/src/storage/stores.test.ts b/apps/extension/src/storage/stores.test.ts
index 76ce715..7993353 100644
--- a/apps/extension/src/storage/stores.test.ts
+++ b/apps/extension/src/storage/stores.test.ts
@@ -20,6 +20,18 @@ class MemoryStorage implements JsonStorageArea {
   }
 }
 
+class FailJobWriteStorage extends MemoryStorage {
+  failNextJobWrite = false;
+
+  override async set<T>(key: string, value: T): Promise<void> {
+    if (this.failNextJobWrite && key === "perspectica.jobs.v1.job-1") {
+      this.failNextJobWrite = false;
+      throw new Error("simulated job write failure");
+    }
+    await super.set(key, value);
+  }
+}
+
 function job(id: string): AnalysisJob {
   return {
     id,
@@ -171,25 +183,86 @@ describe("extension stores", () => {
         contentType: "news" as const,
       },
     };
-    await store.appendEvent({
-      protocol: 2,
-      jobId: "job-1",
-      runToken: "run-job-1",
-      sequence: 1,
-      revision: 1,
-      event,
-    });
-    await store.appendEvent({
-      protocol: 2,
-      jobId: "job-1",
-      runToken: "run-job-1",
-      sequence: 2,
-      revision: 2,
-      event,
-    });
+    await store.commitEvent({ jobId: "job-1", runToken: "run-job-1", sequence: 1, event });
+    await store.commitEvent({ jobId: "job-1", runToken: "run-job-1", sequence: 2, event });
 
     await expect(store.getEventsSince("job-1", 1)).resolves.toEqual([
       expect.objectContaining({ sequence: 2, event }),
     ]);
   });
+
+  it("commits event rows before the job cursor and repairs a failed cursor write idempotently", async () => {
+    const storage = new FailJobWriteStorage();
+    const store = new JobStore(storage);
+    await store.set(job("job-1"));
+    const event = {
+      type: "metadata.ready" as const,
+      analysisId: "analysis-1",
+      emittedAt: "2026-07-29T12:00:00.000Z",
+      data: {
+        title: "Example",
+        author: null,
+        publication: "Example News",
+        publishedAt: null,
+        contentType: "news" as const,
+      },
+    };
+
+    storage.failNextJobWrite = true;
+    await expect(
+      store.commitEvent({
+        jobId: "job-1",
+        runToken: "run-job-1",
+        sequence: 1,
+        event,
+      }),
+    ).rejects.toThrow("simulated job write failure");
+    await expect(store.getEventsSince("job-1", 0)).resolves.toHaveLength(1);
+    await expect(store.get("job-1")).resolves.toMatchObject({ lastEventSequence: 0 });
+
+    await expect(
+      store.commitEvent({
+        jobId: "job-1",
+        runToken: "run-job-1",
+        sequence: 1,
+        event,
+      }),
+    ).resolves.toMatchObject({ accepted: true, job: { lastEventSequence: 1 } });
+    await expect(
+      store.commitEvent({
+        jobId: "job-1",
+        runToken: "run-job-1",
+        sequence: 1,
+        event,
+      }),
+    ).resolves.toMatchObject({ accepted: false, duplicate: true });
+  });
+
+  it("rejects a cursor gap instead of making an unreplayable journal", async () => {
+    const storage = new MemoryStorage();
+    const store = new JobStore(storage);
+    await store.set(job("job-1"));
+    const event = {
+      type: "metadata.ready" as const,
+      analysisId: "analysis-1",
+      emittedAt: "2026-07-29T12:00:00.000Z",
+      data: {
+        title: "Example",
+        author: null,
+        publication: "Example News",
+        publishedAt: null,
+        contentType: "news" as const,
+      },
+    };
+
+    await expect(
+      store.commitEvent({
+        jobId: "job-1",
+        runToken: "run-job-1",
+        sequence: 2,
+        event,
+      }),
+    ).resolves.toMatchObject({ accepted: false, gap: true });
+    await expect(store.getEventsSince("job-1", 0)).resolves.toEqual([]);
+  });
 });
diff --git a/docs/architecture-v2.md b/docs/architecture-v2.md
index 8958589..2207c5b 100644
--- a/docs/architecture-v2.md
+++ b/docs/architecture-v2.md
@@ -33,16 +33,24 @@ not weakened to make that move.
 3. One `RetrievalCoordinator` schedules bounded missions against a shared `EvidenceLedger`.
    Fast, balanced, and deep modes control context, mission, source, concurrency, deadline, and
    model-output limits.
-4. Evidence is normalized, canonical-URL deduplicated, validated, and added to a shared graph.
-   Source text requires an exact excerpt match. Search summaries cannot carry excerpts or be
-   rendered as quotations. The current article is always rejected as its own independent source.
-5. Perspective and report sections are projected from the same ledger. Contradicting or qualifying
+4. Providers return only bounded `EvidenceCandidate` discovery records. A provider never assigns a
+   claim, relationship, reader-facing statement, or context signal. One bounded adjudication step
+   maps exact candidate IDs to planned claims and relationships; the centralized validator then
+   checks mission/claim boundaries, canonical provenance, claim anchors, source excerpts, source
+   kind, and context-subject identity before the `EvidenceLedger` can create an assertion.
+   Source text requires an exact excerpt match. Search summaries cannot establish support,
+   contradiction, or qualification and cannot be rendered as quotations. The current article is
+   always rejected as its own independent source.
+5. Perspective and report sections are projected from the same validated ledger. Article-owned
+   framing remains the compass anchor; accepted publication, journalist, comparable-coverage, and
+   topic-context signals may provide a bounded contextual refinement. Contradicting or qualifying
    sources are claimed first, then supporting sources, then additional context, so one source is
    not silently duplicated across lanes.
 
 The intelligence package also exposes `retryMissingSections`. It reuses the existing index, plan,
-accepted sources, and graph, then reruns only missions that can serve the requested empty sections;
-it never restarts the full article run.
+accepted sources, and graph, then reruns only missions that can serve requested sections whose
+provider lane actually failed; an honestly completed empty lane is not treated as a retry failure.
+It never restarts the full article run.
 
 Pipeline phases are explicit: `indexed`, `planning`, `retrieving`, `adjudicating`, `composing`,
 and a terminal `complete`, `partial`, `failed`, or `cancelled` phase. Section applicability is
@@ -50,14 +58,15 @@ part of the plan; empty or not-applicable sections are rendered as honest states
 
 ## Retrieval policy
 
-Exa is a bounded search provider. Its response text/highlights are carried as `source-text` only
-when the excerpt is present in the returned content. Results are cached by canonical query and
-mission shape for 24 hours. Native ChatGPT search summaries use a separate 30-minute cache
-because their search index can change more quickly.
+Exa is a bounded search provider. Its response text/highlights are carried as candidate discovery
+content and can become `source-text` evidence only after adjudication and exact-excerpt validation.
+Results are cached by canonical query and mission shape for 24 hours. Native ChatGPT search
+summaries use a separate 30-minute cache because their search index can change more quickly.
 
 Native ChatGPT research is one global web-search workflow for the whole plan. It does not launch
-one model read per URL. URL-attributed results are stored as `search-summary` cards with no
-quoteable excerpt. The UI labels them accordingly.
+one model read per URL or round-robin URLs into missions. URL-attributed results are stored as
+`search-summary` candidates with no quoteable excerpt; they can only become clearly labeled
+context/search-summary assertions when the adjudicator and validator support that use.
 
 ## Auth and storage
 
@@ -68,8 +77,10 @@ encrypted provider secret; it is not an auth provider or account identity.
 
 Jobs and event payloads are bounded. `chrome.storage.local` retains preferences and the compact
 job snapshot. IndexedDB `perspectica-analysis-v2` stores append-only event envelopes and bounded
-logs. New jobs keep `events: []`; the side panel asks `analysis.getEventsSince(jobId, sequence)`
-after reconnect and ignores duplicate or stale sequences. `perspectica-analysis-artifacts-v1`
+logs. Event delivery appends the envelope before advancing the job cursor; same-sequence retries
+are idempotent and sequence gaps are rejected. New jobs keep `events: []`; the side panel asks
+`analysis.getEventsSince(jobId, sequence)` in pages, requires contiguous sequences, and replays
+the missing range after reconnect before applying live deltas. `perspectica-analysis-artifacts-v1`
 keeps only the current run's bounded index/plan/ledger snapshot for 24 hours so a targeted retry
 can survive an offscreen document restart; it contains no credentials. A healthy port does not
 use polling.
@@ -78,36 +89,44 @@ use polling.
 
 The side panel owns a custom `ReportStore` whose state is section-isolated. Each `section.ready`
 event replaces only that section snapshot, while metadata, progress, source list, and terminal
-status remain separate fields. The UI never merges, reorders, or reconciles evidence cards. Motion
-is limited to CSS opacity/height transitions and respects reduced-motion preferences; report text
-is inserted as complete bounded nodes rather than animated per word.
+status remain separate fields. The rendered report sections subscribe to their own snapshots, so
+progress and ledger counters do not reconcile or rerender every evidence section. The UI never
+merges, reorders, or reconciles evidence assertions. Motion is limited to CSS opacity/height
+transitions and respects reduced-motion preferences; report text is inserted as complete bounded
+nodes rather than animated per word.
 
 ## Verification and measured baseline
 
-The pre-V2 baseline was recorded before the migration on the clean `main` commit:
+The benchmark is a structural build/regression check, not proof of live provider latency, token
+usage, first-grounded-result time, DOM rerender count, or reader-facing quality. No authenticated
+provider run is implied by this table. Run `pnpm bench:v2` and `pnpm test` to refresh the local
+snapshot:
 
 | Measurement        |                              Before V2 |              V2 target/measurement |
 | ------------------ | -------------------------------------: | ---------------------------------: |
-| Unit tests         |                            205 passing |         97 passing across 22 files |
-| Test wall time     |                                 9.16 s |                             8.70 s |
+| Unit tests         |                            205 passing |        107 passing across 25 files |
+| Test wall time     |                                 9.16 s |            local command dependent |
 | Typecheck          |                                passing |                            passing |
-| Production build   |                                1.23 MB |                    1,122,389 bytes |
-| Build JavaScript   |                                    n/a |                    1,016,840 bytes |
+| Production build   |                                1.23 MB |                    1,142,549 bytes |
+| Build JavaScript   |                                    n/a |                    1,037,000 bytes |
 | Build CSS          |                                    n/a |                       25,146 bytes |
 | Build files        |                                    n/a |                                 15 |
-| Source files       |                                    n/a |                                 98 |
+| Source files       |                                    n/a |                                102 |
 | Legacy production  |                                    n/a |                              false |
 | Production engines | six specialist/legacy package surfaces | one Article Lens + one coordinator |
 
 `pnpm bench:v2` reports current unpacked build bytes, JavaScript/CSS bytes, source file counts,
-and whether removed legacy packages are present in production sources. The measured V2 snapshot
-above is from the final local build.
+and whether removed legacy packages are present in production sources. Those numbers describe
+the packaged surface only; performance and evidence quality require authenticated end-to-end
+measurements and adversarial source/claim fixtures.
 
 ## Known limits
 
 - Native ChatGPT URL sources are search summaries, not independent page transcripts; they cannot
-  support verbatim quotations.
-- Exa result text is provider-returned text/highlights, not a browser re-read of the page.
+  support, contradict, or qualify a claim or support verbatim quotations without an independently
+  retrieved source-text candidate.
+- Exa result text is provider-returned text/highlights, not a browser re-read of the page. It is
+  still only a candidate until the bounded adjudicator and centralized validator accept it.
 - Article compass and bias signals are bounded article-owned heuristics when the lens model is
   unavailable; they are not permanent publisher or person labels.
 - Chrome can suspend or deny access to protected pages. The extractor reports that boundary rather
diff --git a/packages/contracts/src/events.ts b/packages/contracts/src/events.ts
index 3feac23..b79dfff 100644
--- a/packages/contracts/src/events.ts
+++ b/packages/contracts/src/events.ts
@@ -71,6 +71,7 @@ export const PipelineEventSchema = z.discriminatedUnion("type", [
   event(
     "research.progress",
     z.object({
+      candidateCount: z.number().int().nonnegative().default(0),
       completedMissions: z.number().int().nonnegative(),
       totalMissions: z.number().int().nonnegative(),
       acceptedSources: z.number().int().nonnegative(),
diff --git a/packages/contracts/src/evidence.ts b/packages/contracts/src/evidence.ts
index 2ad5e73..ac7022c 100644
--- a/packages/contracts/src/evidence.ts
+++ b/packages/contracts/src/evidence.ts
@@ -26,6 +26,62 @@ export const EvidenceRelationshipV2Schema = z.enum([
 ]);
 export type EvidenceRelationshipV2 = z.infer<typeof EvidenceRelationshipV2Schema>;
 
+export const EvidenceContextSourceKindSchema = z.enum([
+  "publication-history",
+  "journalist-work",
+  "comparable-coverage",
+  "topic-context",
+]);
+export type EvidenceContextSourceKind = z.infer<typeof EvidenceContextSourceKindSchema>;
+
+/**
+ * A provider result is discovery input, not reader-facing evidence. Providers
+ * may attach the retrieval mission that produced a result, but they may not
+ * decide which article claim it supports or contradicts.
+ */
+export const EvidenceCandidateSchema = z.object({
+  id: text.max(160),
+  missionId: text.max(160).nullable(),
+  sourceUrl: z.string().url(),
+  title: text.max(1_000),
+  publication: text.max(500),
+  publishedAt: z.string().datetime({ offset: true }).nullable(),
+  sourceType: SourceTypeV2Schema,
+  contentKind: ContentKindSchema,
+  content: text.max(20_000),
+  /** Provider discovery context is never rendered as a source quotation. */
+  discoveryContext: text.max(20_000).nullable(),
+  discoveryExcerpt: text.max(4_000).nullable(),
+  providerScore: z.number().min(0).max(1).nullable(),
+  provider: EvidenceProviderSchema,
+});
+export type EvidenceCandidate = z.infer<typeof EvidenceCandidateSchema>;
+
+const EvidenceContextSignalSchema = z.object({
+  sourceKind: EvidenceContextSourceKindSchema,
+  subject: text.max(500),
+  score: z.number().min(-3).max(3),
+  direction: z.enum(["left", "center", "right"]),
+  strength: z.number().min(0).max(1),
+  relevance: z.number().min(0).max(1),
+  explanation: text.max(1_000),
+});
+export type EvidenceContextSignal = z.infer<typeof EvidenceContextSignalSchema>;
+
+/** The only shape allowed to cross from adjudication into the evidence ledger. */
+export const EvidenceAdjudicationSchema = z.object({
+  candidateId: text.max(160),
+  missionId: text.max(160),
+  claimId: text.max(160).nullable(),
+  relationship: EvidenceRelationshipV2Schema,
+  statement: text.max(1_200),
+  excerpt: text.max(4_000).nullable(),
+  confidence: z.number().min(0).max(1),
+  relevance: z.number().min(0).max(1),
+  context: EvidenceContextSignalSchema.nullable(),
+});
+export type EvidenceAdjudication = z.infer<typeof EvidenceAdjudicationSchema>;
+
 export const SourceRecordSchema = z.object({
   id: text.max(160),
   canonicalUrl: z.string().url(),
@@ -45,6 +101,8 @@ export const EvidenceValidationSchema = z.object({
   accepted: z.boolean(),
   provenance: z.enum(["verified-url", "article-link", "unknown"]),
   excerptMatches: z.boolean(),
+  claimRelevant: z.boolean().default(false),
+  relationshipChecked: z.boolean().default(false),
   reason: text.max(500),
 });
 export type EvidenceValidation = z.infer<typeof EvidenceValidationSchema>;
@@ -60,9 +118,11 @@ export const EvidenceAssertionSchema = z.object({
   articleParagraphIds: z.array(text.max(128)).max(12),
   confidence: z.number().min(0).max(1),
   validation: EvidenceValidationSchema,
+  context: EvidenceContextSignalSchema.nullable().default(null),
 });
 export type EvidenceAssertion = z.infer<typeof EvidenceAssertionSchema>;
 
+/** Legacy reader-card shape kept only for migration/tests; providers use candidates. */
 export const EvidenceCardSchema = z.object({
   missionId: text.max(160),
   claimId: text.max(160).nullable(),
@@ -84,7 +144,10 @@ export type EvidenceCard = z.infer<typeof EvidenceCardSchema>;
 export const EvidenceBatchSchema = z.object({
   missionId: text.max(160),
   provider: EvidenceProviderSchema,
-  cards: z.array(EvidenceCardSchema).max(32),
+  candidates: z.array(EvidenceCandidateSchema).max(32),
+  coveredMissionIds: z.array(text.max(160)).max(32).default([]),
+  status: z.enum(["completed", "failed"]).default("completed"),
+  error: text.max(500).nullable().default(null),
   searched: z.boolean(),
   cacheHit: z.boolean(),
   durationMs: z.number().int().nonnegative(),
@@ -112,6 +175,7 @@ export const SufficiencySnapshotSchema = z.object({
   totalClaims: z.number().int().nonnegative(),
   meaningfulContradiction: z.boolean(),
   exhaustedMissions: z.number().int().nonnegative(),
+  candidateCount: z.number().int().nonnegative().default(0),
   stop: z.boolean(),
   reason: text.max(500),
 });
@@ -127,6 +191,7 @@ export const SourceLedgerSnapshotSchema = z.object({
   sufficiency: SufficiencySnapshotSchema,
   servedSections: z.record(ReportSectionSchema, z.array(text.max(160)).max(32)),
   completedMissionIds: z.array(text.max(160)).max(32).default([]),
+  failedMissionIds: z.array(text.max(160)).max(32).default([]),
 });
 export type SourceLedgerSnapshot = z.infer<typeof SourceLedgerSnapshotSchema>;
 
diff --git a/packages/contracts/src/index.ts b/packages/contracts/src/index.ts
index b407cbf..6ad0b76 100644
--- a/packages/contracts/src/index.ts
+++ b/packages/contracts/src/index.ts
@@ -155,8 +155,9 @@ export type PoliticalContextSourceKind = z.infer<typeof PoliticalContextSourceKi
  *
  * `source-excerpt` is copied from retrieved page text and may be rendered as a
  * quotation. `search-summary` is a provider-generated, URL-attributed search
- * note. It may support a cautious paraphrase, but must never be displayed as a
- * quotation or described as page text.
+ * note. It may provide a clearly labeled contextual paraphrase, but cannot
+ * establish support, contradiction, or qualification and must never be displayed
+ * as a quotation or described as page text.
  *
  * The field remains optional on exact-excerpt variants so stored reports from
  * older builds stay wire-compatible.
diff --git a/packages/contracts/src/report.ts b/packages/contracts/src/report.ts
index 358103e..5569339 100644
--- a/packages/contracts/src/report.ts
+++ b/packages/contracts/src/report.ts
@@ -2,6 +2,23 @@ import { z } from "zod";
 
 const text = z.string().trim().min(1);
 
+export const ArticleBiasTechniqueSchema = z.enum([
+  "word-choice",
+  "speculation",
+  "unsubstantiated-claims",
+  "cherry-picking",
+  "source-selection",
+  "whataboutism",
+  "false-balance",
+  "false-dichotomy",
+  "flawed-comparison",
+  "generalization",
+  "ad-hominem",
+  "emotional-sensationalism",
+  "straw-man",
+]);
+export type ArticleBiasTechnique = z.infer<typeof ArticleBiasTechniqueSchema>;
+
 export const ReportSectionSchema = z.enum([
   "compass",
   "bias",
@@ -33,7 +50,7 @@ export type ArticleCompassSignal = z.infer<typeof ArticleCompassSignalSchema>;
 
 export const ArticleBiasSignalSchema = z.object({
   id: text.max(160),
-  technique: text.max(120),
+  technique: ArticleBiasTechniqueSchema,
   paragraphId: text.max(128),
   sentenceId: text.max(160).nullable(),
   excerpt: text.max(4_000),
diff --git a/packages/intelligence/src/compass/calculate.ts b/packages/intelligence/src/compass/calculate.ts
index cede07a..7ab6432 100644
--- a/packages/intelligence/src/compass/calculate.ts
+++ b/packages/intelligence/src/compass/calculate.ts
@@ -43,11 +43,14 @@ export function projectArticleCompass(index: ArticleIndex, plan: AnalysisPlan):
     .slice(0, 12)
     .map((signal, position) => {
       const paragraph = index.paragraphs[signal.paragraphIds[0]!];
+      const sentence = signal.sentenceIds
+        .map((sentenceId) => index.sentences[sentenceId])
+        .find((value) => value && signal.paragraphIds.includes(value.paragraphId));
       return {
         id: `article-signal-${position + 1}`,
         paragraphId: signal.paragraphIds[0]!,
-        excerpt: paragraph?.text.slice(0, 600) ?? "Article signal",
-        speaker: paragraph?.speaker ?? null,
+        excerpt: sentence?.text ?? paragraph?.text.slice(0, 600) ?? "Article signal",
+        speaker: sentence?.speaker ?? paragraph?.speaker ?? null,
         endorsedByArticle: !signal.attributed,
         score: signal.score,
         direction: signal.direction,
@@ -122,3 +125,56 @@ export function projectArticleCompass(index: ArticleIndex, plan: AnalysisPlan):
     },
   });
 }
+
+export function projectCompassWithContext(
+  index: ArticleIndex,
+  plan: AnalysisPlan,
+  context: PoliticalContextResult,
+): CompassResult {
+  const article = projectArticleCompass(index, plan);
+  if (context.status !== "ready" || context.signals.length === 0 || article.score === null) {
+    return CompassResultSchema.parse({ ...article, context });
+  }
+  const weightedContext = context.signals.reduce(
+    (total, signal) => total + signal.score * signal.strength * signal.relevance,
+    0,
+  );
+  const contextWeight = context.signals.reduce(
+    (total, signal) => total + signal.strength * signal.relevance,
+    0,
+  );
+  if (contextWeight <= 0) return CompassResultSchema.parse({ ...article, context });
+  const score =
+    Math.round(clamp(article.score * 0.6 + (weightedContext / contextWeight) * 0.4, -3, 3) * 100) /
+    100;
+  const placement = label(score);
+  const counts = {
+    publication: context.signals.filter((signal) => signal.sourceKind === "publication-history")
+      .length,
+    journalist: context.signals.filter((signal) => signal.sourceKind === "journalist-work").length,
+    comparableCoverage: context.signals.filter(
+      (signal) => signal.sourceKind === "comparable-coverage",
+    ).length,
+    topicContext: context.signals.filter((signal) => signal.sourceKind === "topic-context").length,
+  };
+  const total = Math.max(1, context.signals.length);
+  return CompassResultSchema.parse({
+    ...article,
+    label: placement,
+    displayLabel: display[placement],
+    score,
+    confidenceScore: Math.min(0.86, Math.round((article.confidenceScore * 0.7 + 0.16) * 100) / 100),
+    confidence:
+      article.confidenceScore >= 0.7 ? "high" : article.confidenceScore >= 0.42 ? "medium" : "low",
+    explanation: `${article.explanation} Bounded publication, journalist, comparable-coverage, and topic-context evidence shifted the contextual estimate cautiously toward ${display[placement].toLocaleLowerCase("en-US")}.`,
+    basis: "context-assisted",
+    context,
+    influence: {
+      article: 0.6,
+      publication: (0.4 * counts.publication) / total,
+      journalist: (0.4 * counts.journalist) / total,
+      comparableCoverage: (0.4 * counts.comparableCoverage) / total,
+      topicContext: (0.4 * counts.topicContext) / total,
+    },
+  });
+}
diff --git a/packages/intelligence/src/evidence/adjudication.ts b/packages/intelligence/src/evidence/adjudication.ts
new file mode 100644
index 0000000..b566df8
--- /dev/null
+++ b/packages/intelligence/src/evidence/adjudication.ts
@@ -0,0 +1,115 @@
+import { generateText, Output, type LanguageModel } from "ai";
+import { z } from "zod";
+import type { ArticleIndex } from "@perspectica/contracts/article";
+import {
+  EvidenceAdjudicationSchema,
+  type EvidenceAdjudication,
+  type EvidenceCandidate,
+} from "@perspectica/contracts/evidence";
+import type { AnalysisPlan } from "@perspectica/contracts/report";
+import type { AnalysisBudget } from "../budgets";
+
+const AdjudicationOutputSchema = z.object({
+  decisions: z.array(EvidenceAdjudicationSchema).max(96),
+});
+
+export interface EvidenceAdjudicationInput {
+  article: ArticleIndex;
+  plan: AnalysisPlan;
+  candidates: readonly EvidenceCandidate[];
+  budget: AnalysisBudget;
+  signal?: AbortSignal;
+}
+
+export interface EvidenceAdjudicator {
+  adjudicate(input: EvidenceAdjudicationInput): Promise<EvidenceAdjudication[]>;
+}
+
+function compact(value: string, max: number): string {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length > max ? `${normalized.slice(0, max - 1).trim()}…` : normalized;
+}
+
+function buildPrompt(input: EvidenceAdjudicationInput): string {
+  const claims = input.plan.claims
+    .map((claim) => {
+      const passages = claim.paragraphIds
+        .map((paragraphId) => input.article.paragraphs[paragraphId]?.text)
+        .filter((value): value is string => Boolean(value))
+        .map((value) => compact(value, 700))
+        .join(" | ");
+      return `CLAIM ${claim.id} [paragraphs=${claim.paragraphIds.join(",")}] ${compact(claim.text, 700)}\nARTICLE PASSAGES: ${passages}`;
+    })
+    .join("\n");
+  const missions = input.plan.missions
+    .map(
+      (mission) =>
+        `MISSION ${mission.id} purpose=${mission.purpose} claims=${mission.claimIds.join(",") || "none"} queries=${mission.queryVariants.join("; ")}`,
+    )
+    .join("\n");
+  const candidates = input.candidates
+    .slice(0, Math.max(input.budget.maxSources * 4, 24))
+    .map(
+      (candidate) =>
+        `CANDIDATE ${candidate.id} mission=${candidate.missionId ?? "global-search"} url=${candidate.sourceUrl} title=${compact(candidate.title, 300)} kind=${candidate.contentKind} sourceType=${candidate.sourceType}\nCONTENT: ${compact(candidate.content, 4_000)}\nDISCOVERY: ${compact(candidate.discoveryContext ?? "", 2_000)}`,
+    )
+    .join("\n\n");
+  return [
+    "ARTICLE CLAIMS",
+    claims,
+    "RESEARCH MISSIONS",
+    missions,
+    "RETRIEVED CANDIDATES",
+    candidates,
+  ].join("\n\n");
+}
+
+const SYSTEM_PROMPT = [
+  "You are Perspectica's evidence adjudicator. You receive an article claim plan and provider discovery candidates.",
+  "A provider candidate is not evidence by itself. Decide only when the candidate content directly supports the decision.",
+  "Never assign a source to a claim or relationship because of mission purpose, array position, URL order, or provider score.",
+  "For source-text candidates, return an exact contiguous excerpt copied from CONTENT. The statement must be a cautious source-backed paraphrase.",
+  "For search-summary candidates, excerpt must be null. They may only produce adds-context or a contextual signal; never supports, contradicts, or qualifies.",
+  "Supports, contradicts, and qualifies require an exact planned claim and a clear source-content anchor.",
+  "Use context only for journalist-work, publication-history, comparable-coverage, or topic-context that is explicitly present in the candidate.",
+  "Return no decision for irrelevant, ambiguous, self-referential, or discovery-only candidates. Do not write generic discovery prose such as 'surfaced a relevant source'.",
+  "Every candidateId and missionId must be copied exactly from the input. Do not invent IDs.",
+].join(" ");
+
+export function createModelEvidenceAdjudicator(
+  model: LanguageModel,
+  onUsage?: (usage: { inputCharacters: number; outputCharacters: number }) => void,
+): EvidenceAdjudicator {
+  return {
+    async adjudicate(input) {
+      const prompt = buildPrompt(input);
+      const result = await generateText({
+        model,
+        abortSignal: input.signal,
+        output: Output.object({ schema: AdjudicationOutputSchema }),
+        system: SYSTEM_PROMPT,
+        prompt,
+        maxRetries: 1,
+        maxOutputTokens: Math.min(3_200, Math.max(1_200, input.budget.modelOutputTokens)),
+        timeout: {
+          totalMs: Math.min(45_000, input.budget.totalDeadlineMs),
+          firstChunkMs: 30_000,
+          chunkMs: 15_000,
+        },
+      });
+      const decisions = result.output?.decisions ?? [];
+      onUsage?.({
+        inputCharacters: prompt.length,
+        outputCharacters: JSON.stringify(decisions).length,
+      });
+      return decisions;
+    },
+  };
+}
+
+export async function adjudicateEvidence(
+  input: EvidenceAdjudicationInput & { adjudicator?: EvidenceAdjudicator },
+): Promise<EvidenceAdjudication[]> {
+  if (!input.adjudicator || input.candidates.length === 0) return [];
+  return input.adjudicator.adjudicate(input);
+}
diff --git a/packages/intelligence/src/evidence/normalization.ts b/packages/intelligence/src/evidence/normalization.ts
index 3800af7..9cfb19c 100644
--- a/packages/intelligence/src/evidence/normalization.ts
+++ b/packages/intelligence/src/evidence/normalization.ts
@@ -2,10 +2,10 @@ import { normalizeCanonicalUrl, normalizeEvidenceText } from "@perspectica/contr
 
 export { normalizeCanonicalUrl, normalizeEvidenceText };
 
-export function sourceIdFor(url: string, provider: string): string {
+export function sourceIdFor(url: string, namespace = "source"): string {
   const canonical = normalizeCanonicalUrl(url) ?? url;
   let hash = 0x811c9dc5;
-  const value = `${provider}:${canonical}`;
+  const value = `${namespace}:${canonical}`;
   for (let index = 0; index < value.length; index += 1) {
     hash ^= value.charCodeAt(index);
     hash = Math.imul(hash, 0x01000193);
diff --git a/packages/intelligence/src/evidence/source-ledger.ts b/packages/intelligence/src/evidence/source-ledger.ts
index b4338e7..79454e1 100644
--- a/packages/intelligence/src/evidence/source-ledger.ts
+++ b/packages/intelligence/src/evidence/source-ledger.ts
@@ -1,20 +1,28 @@
 import {
   SourceLedgerSnapshotSchema,
+  type EvidenceAdjudication,
   type EvidenceAssertion,
   type EvidenceBatch,
+  type EvidenceCandidate,
   type SourceLedgerSnapshot,
   type SourceRecord,
 } from "@perspectica/contracts/evidence";
 import { MAX_EVIDENCE_ASSERTIONS } from "@perspectica/contracts/limits";
-import type { AnalysisPlan } from "@perspectica/contracts/report";
+import type { AnalysisPlan, ReportSection } from "@perspectica/contracts/report";
 import type { ArticleIndex } from "@perspectica/contracts/article";
 import type { AnalysisBudget } from "../budgets";
-import { assertionIdFor, contentSignature, normalizeCanonicalUrl } from "./normalization";
+import {
+  assertionIdFor,
+  contentSignature,
+  normalizeCanonicalUrl,
+  sourceIdFor,
+} from "./normalization";
 import { buildEvidenceGraph } from "./evidence-graph";
-import { validateEvidenceCard, mergeSource } from "./validation";
+import { mergeSource, validateEvidenceAdjudication } from "./validation";
 import { evaluateSufficiency } from "./sufficiency";
 
 export interface LedgerAcceptResult {
+  acceptedCandidates: number;
   acceptedSources: number;
   acceptedAssertions: number;
   rejected: number;
@@ -22,9 +30,11 @@ export interface LedgerAcceptResult {
 }
 
 export class EvidenceLedger {
+  private readonly candidates = new Map<string, EvidenceCandidate>();
   private readonly sources = new Map<string, SourceRecord>();
   private readonly assertions = new Map<string, EvidenceAssertion>();
   private readonly completedMissions = new Set<string>();
+  private readonly failedMissions = new Set<string>();
   private readonly rejectedReasons: string[] = [];
 
   constructor(
@@ -43,71 +53,110 @@ export class EvidenceLedger {
     for (const source of snapshot.sources) ledger.sources.set(source.id, source);
     for (const assertion of snapshot.assertions) ledger.assertions.set(assertion.id, assertion);
     for (const missionId of snapshot.completedMissionIds) ledger.completedMissions.add(missionId);
-    if (snapshot.completedMissionIds.length === 0) {
+    for (const missionId of snapshot.failedMissionIds) ledger.failedMissions.add(missionId);
+    if (snapshot.completedMissionIds.length === 0 && snapshot.failedMissionIds.length === 0) {
       for (const assertion of snapshot.assertions)
         ledger.completedMissions.add(assertion.missionId);
     }
     return ledger;
   }
 
+  /** Store provider discovery without allowing it to become reader evidence. */
   accept(batch: EvidenceBatch): LedgerAcceptResult {
+    let acceptedCandidates = 0;
+    const maxCandidates = Math.max(24, this.budget.maxSources * 4);
+    for (const candidate of batch.candidates) {
+      if (!this.candidates.has(candidate.id)) {
+        if (this.candidates.size >= maxCandidates) continue;
+        this.candidates.set(candidate.id, candidate);
+        acceptedCandidates += 1;
+      }
+    }
+    const plannedMissionIds = new Set(this.plan.missions.map((mission) => mission.id));
+    const coveredMissionIds = (
+      batch.coveredMissionIds.length > 0 ? batch.coveredMissionIds : [batch.missionId]
+    ).filter((missionId) => plannedMissionIds.has(missionId));
+    if (batch.status === "failed") {
+      for (const missionId of coveredMissionIds) this.failedMissions.add(missionId);
+    } else {
+      for (const missionId of coveredMissionIds) {
+        this.completedMissions.add(missionId);
+        this.failedMissions.delete(missionId);
+      }
+    }
+    if (batch.error) this.rejectedReasons.push(batch.error);
+    return {
+      acceptedCandidates,
+      acceptedSources: this.sources.size,
+      acceptedAssertions: this.assertions.size,
+      rejected: batch.candidates.length - acceptedCandidates,
+      reasons: this.rejectedReasons.slice(-8),
+    };
+  }
+
+  /**
+   * Accept only decisions produced by the bounded adjudicator. Every source
+   * identity and reader-facing assertion is reconstructed from the candidate
+   * and the validated decision rather than copied from a provider card.
+   */
+  acceptAdjudications(decisions: readonly EvidenceAdjudication[]): LedgerAcceptResult {
     let acceptedSources = 0;
     let acceptedAssertions = 0;
     let rejected = 0;
-    for (const card of batch.cards) {
-      const validation = validateEvidenceCard(card, this.article.meta.canonicalUrl);
+    for (const decision of decisions) {
+      const candidate = this.candidates.get(decision.candidateId);
+      if (!candidate) {
+        rejected += 1;
+        this.rejectedReasons.push("The adjudicator referenced a candidate that was not retrieved.");
+        continue;
+      }
+      const validation = validateEvidenceAdjudication(decision, candidate, this.article, this.plan);
       if (!validation.accepted || !validation.canonicalUrl) {
         rejected += 1;
         this.rejectedReasons.push(validation.reason);
         continue;
       }
-      // Canonical URL is the source identity. Provider is provenance metadata,
-      // not a reason to duplicate one URL in the graph.
-      const sourceId = `source-${contentSignature(validation.canonicalUrl).slice(-8)}`;
+      const sourceId = sourceIdFor(validation.canonicalUrl);
       const source: SourceRecord = {
         id: sourceId,
         canonicalUrl: validation.canonicalUrl,
-        title: card.title,
-        publication: card.publication,
-        publishedAt: card.publishedAt,
-        sourceType: card.sourceType,
-        contentKind: card.contentKind,
-        content: card.content,
-        contentSignature: contentSignature(card.content),
+        title: candidate.title,
+        publication: candidate.publication,
+        publishedAt: candidate.publishedAt,
+        sourceType: candidate.sourceType,
+        contentKind: candidate.contentKind,
+        content: candidate.content,
+        contentSignature: contentSignature(candidate.content),
         retrievedAt: new Date().toISOString(),
-        provider: card.provider,
+        provider: candidate.provider,
       };
       const previous = this.sources.get(sourceId);
       if (!previous && this.sources.size >= this.budget.maxSources) continue;
       if (!previous) acceptedSources += 1;
       this.sources.set(sourceId, mergeSource(previous, source));
       if (this.assertions.size >= MAX_EVIDENCE_ASSERTIONS) continue;
-      const assertionId = assertionIdFor(sourceId, card.missionId, card.statement);
+      const assertionId = assertionIdFor(sourceId, decision.missionId, decision.statement);
       if (this.assertions.has(assertionId)) continue;
-      const assertion: EvidenceAssertion = {
+      const claim = decision.claimId
+        ? this.plan.claims.find((value) => value.id === decision.claimId)
+        : undefined;
+      this.assertions.set(assertionId, {
         id: assertionId,
         sourceId,
-        missionId: card.missionId,
-        claimId: card.claimId,
-        relationship: card.relationship,
-        statement: card.statement,
-        excerpt: card.contentKind === "source-text" ? card.excerpt : null,
-        articleParagraphIds: card.claimId
-          ? (this.plan.claims.find((claim) => claim.id === card.claimId)?.paragraphIds ?? [])
-          : [],
-        confidence: card.confidence,
-        validation: {
-          accepted: true,
-          provenance: "verified-url",
-          excerptMatches: validation.excerptMatches,
-          reason: validation.reason,
-        },
-      };
-      this.assertions.set(assertionId, assertion);
+        missionId: decision.missionId,
+        claimId: decision.claimId,
+        relationship: decision.relationship,
+        statement: decision.statement,
+        excerpt: candidate.contentKind === "source-text" ? decision.excerpt : null,
+        articleParagraphIds: claim?.paragraphIds ?? [],
+        confidence: Math.min(decision.confidence, decision.relevance),
+        validation,
+        context: decision.context,
+      });
       acceptedAssertions += 1;
     }
-    this.completedMissions.add(batch.missionId);
     return {
+      acceptedCandidates: this.candidates.size,
       acceptedSources,
       acceptedAssertions,
       rejected,
@@ -121,8 +170,9 @@ export class EvidenceLedger {
     const sufficiency = evaluateSufficiency(
       this.plan,
       assertions,
-      this.completedMissions.size,
+      this.completedMissionCount(),
       this.budget,
+      this.candidates.size,
     );
     const servedSections: Record<string, string[]> = {
       compass: [],
@@ -133,15 +183,11 @@ export class EvidenceLedger {
       "additional-context": [],
       "works-cited": [],
     };
-    for (const mission of this.plan.missions) {
-      const missionAssertions = assertions
-        .filter((assertion) => assertion.missionId === mission.id)
-        .map((assertion) => assertion.id);
+    for (const assertion of assertions) {
+      const mission = this.plan.missions.find((value) => value.id === assertion.missionId);
+      if (!mission) continue;
       for (const section of mission.canServeSections) {
-        servedSections[section] = [...(servedSections[section] ?? []), ...missionAssertions].slice(
-          0,
-          32,
-        );
+        servedSections[section] = [...(servedSections[section] ?? []), assertion.id].slice(0, 32);
       }
     }
     return SourceLedgerSnapshotSchema.parse({
@@ -151,9 +197,13 @@ export class EvidenceLedger {
       sufficiency,
       servedSections,
       completedMissionIds: [...this.completedMissions],
+      failedMissionIds: [...this.failedMissions],
     });
   }
 
+  getCandidates(): EvidenceCandidate[] {
+    return [...this.candidates.values()];
+  }
   getSources(): SourceRecord[] {
     return [...this.sources.values()];
   }
@@ -161,7 +211,13 @@ export class EvidenceLedger {
     return [...this.assertions.values()];
   }
   completedMissionCount(): number {
-    return this.completedMissions.size;
+    return new Set([...this.completedMissions, ...this.failedMissions]).size;
+  }
+  failedMissionIds(): string[] {
+    return [...this.failedMissions];
+  }
+  isMissionFailed(missionId: string): boolean {
+    return this.failedMissions.has(missionId);
   }
   isSufficient(): boolean {
     return this.snapshot().sufficiency.stop;
@@ -169,6 +225,9 @@ export class EvidenceLedger {
   hasEvidenceForClaim(claimId: string): boolean {
     return this.getAssertions().some((assertion) => assertion.claimId === claimId);
   }
+  hasEvidenceForSection(section: ReportSection): boolean {
+    return this.snapshot().servedSections[section]?.length > 0;
+  }
   articleLinkSource(url: string): boolean {
     return normalizeCanonicalUrl(url) === normalizeCanonicalUrl(this.article.meta.canonicalUrl);
   }
diff --git a/packages/intelligence/src/evidence/sufficiency.ts b/packages/intelligence/src/evidence/sufficiency.ts
index c0ceefb..a603ced 100644
--- a/packages/intelligence/src/evidence/sufficiency.ts
+++ b/packages/intelligence/src/evidence/sufficiency.ts
@@ -11,6 +11,7 @@ export function evaluateSufficiency(
   assertions: readonly EvidenceAssertion[],
   completedMissions: number,
   budget: AnalysisBudget,
+  candidateCount = 0,
 ): SufficiencySnapshot {
   const covered = new Set(
     assertions.flatMap((assertion) => (assertion.claimId ? [assertion.claimId] : [])),
@@ -32,6 +33,7 @@ export function evaluateSufficiency(
     totalClaims: plan.claims.length,
     meaningfulContradiction,
     exhaustedMissions: completedMissions,
+    candidateCount,
     stop,
     reason: stop
       ? coverage >= 0.75
diff --git a/packages/intelligence/src/evidence/validation.test.ts b/packages/intelligence/src/evidence/validation.test.ts
new file mode 100644
index 0000000..d9071aa
--- /dev/null
+++ b/packages/intelligence/src/evidence/validation.test.ts
@@ -0,0 +1,273 @@
+import type { ArticleIndex } from "@perspectica/contracts/article";
+import type { EvidenceAdjudication, EvidenceCandidate } from "@perspectica/contracts/evidence";
+import type { AnalysisPlan } from "@perspectica/contracts/report";
+import { describe, expect, it } from "vitest";
+import { resolveAnalysisBudget } from "../budgets";
+import { EvidenceLedger } from "./source-ledger";
+import { validateEvidenceAdjudication } from "./validation";
+
+function article(): ArticleIndex {
+  return {
+    version: "index-v2",
+    fingerprint: "article-fingerprint",
+    meta: {
+      title: "River County approves 12 projects",
+      author: "Alex Reporter",
+      publication: "Example News",
+      publishedAt: null,
+      canonicalUrl: "https://example.com/article",
+      contentType: "news",
+      language: "en",
+    },
+    outline: [],
+    paragraphs: {
+      p1: {
+        id: "p1",
+        index: 0,
+        kind: "paragraph",
+        text: "River County approved 12 projects in 2024.",
+        preview: "River County approved 12 projects in 2024.",
+        speaker: null,
+        sentenceIds: ["s1"],
+        headingPath: [],
+        linkIds: [],
+        position: 0,
+        tokenCount: 8,
+      },
+    },
+    paragraphOrder: ["p1"],
+    sentences: {
+      s1: {
+        id: "s1",
+        paragraphId: "p1",
+        index: 0,
+        start: 0,
+        end: 44,
+        text: "River County approved 12 projects in 2024.",
+        speaker: null,
+        attributionVerb: null,
+        isQuoted: false,
+      },
+    },
+    entities: [
+      {
+        text: "River County",
+        normalized: "river county",
+        kind: "place",
+        paragraphId: "p1",
+        sentenceId: "s1",
+      },
+    ],
+    quantities: [
+      {
+        text: "12",
+        normalized: "12",
+        kind: "number",
+        paragraphId: "p1",
+        sentenceId: "s1",
+      },
+    ],
+    dates: [
+      {
+        text: "2024",
+        normalized: "2024",
+        paragraphId: "p1",
+        sentenceId: "s1",
+      },
+    ],
+    links: [],
+    claimSeeds: [],
+    extraction: {
+      extractorVersion: "test",
+      indexedAt: "2026-08-02T12:00:00.000Z",
+      wordCount: 8,
+      contentChars: 45,
+      paragraphCount: 1,
+      sentenceCount: 1,
+      linkCount: 0,
+      contentTruncated: false,
+      articleStatus: "article",
+    },
+  };
+}
+
+function plan(): AnalysisPlan {
+  return {
+    id: "plan-1",
+    overview: "One claim.",
+    claims: [
+      {
+        id: "claim-1",
+        text: "River County approved 12 projects in 2024.",
+        paragraphIds: ["p1"],
+        sentenceIds: ["s1"],
+        importance: 0.9,
+        uncertainty: 0.6,
+        researchValue: 0.9,
+        queryHints: ["River County 12 projects 2024"],
+      },
+    ],
+    articleSignals: { compass: [], bias: [] },
+    missions: [
+      {
+        id: "mission-verify",
+        claimIds: ["claim-1"],
+        purpose: "independent-verification",
+        queryVariants: ["River County 12 projects 2024"],
+        priority: 0.9,
+        estimatedCost: 1,
+        freshness: "recent",
+        preferredSourceTypes: ["independent-reporting"],
+        includeDomains: [],
+        excludeDomains: [],
+        canServeSections: ["supporting", "contradicting"],
+      },
+    ],
+    applicability: {
+      compass: { applicable: false, confidence: 0.8, reason: "Not needed." },
+      bias: { applicable: false, confidence: 0.8, reason: "Not needed." },
+      "journalist-context": { applicable: false, confidence: 0.8, reason: "Not needed." },
+      supporting: { applicable: true, confidence: 0.9, reason: "Claim exists." },
+      contradicting: { applicable: true, confidence: 0.7, reason: "Claim is uncertain." },
+      "additional-context": { applicable: false, confidence: 0.8, reason: "Not needed." },
+      "works-cited": { applicable: true, confidence: 1, reason: "Article links." },
+    },
+    unresolvedQuestions: [],
+    requestedParagraphIds: [],
+    contextCharacters: 0,
+  };
+}
+
+function candidate(overrides: Partial<EvidenceCandidate> = {}): EvidenceCandidate {
+  return {
+    id: "candidate-1",
+    missionId: "mission-verify",
+    sourceUrl: "https://evidence.example/record",
+    title: "Independent record",
+    publication: "Evidence Daily",
+    publishedAt: null,
+    sourceType: "independent-reporting",
+    contentKind: "source-text",
+    content: "The record says River County approved 12 projects in 2024.",
+    discoveryContext: null,
+    discoveryExcerpt: "The record says River County approved 12 projects in 2024.",
+    providerScore: 0.9,
+    provider: "exa",
+    ...overrides,
+  };
+}
+
+function decision(overrides: Partial<EvidenceAdjudication> = {}): EvidenceAdjudication {
+  return {
+    candidateId: "candidate-1",
+    missionId: "mission-verify",
+    claimId: "claim-1",
+    relationship: "supports",
+    statement: "The record reports the same approval and quantity described by the article.",
+    excerpt: "River County approved 12 projects in 2024.",
+    confidence: 0.9,
+    relevance: 0.85,
+    context: null,
+    ...overrides,
+  };
+}
+
+describe("semantic evidence boundary", () => {
+  it("keeps provider candidates out of the ledger until an adjudication is validated", () => {
+    const articleIndex = article();
+    const analysisPlan = plan();
+    const ledger = new EvidenceLedger(
+      articleIndex,
+      analysisPlan,
+      resolveAnalysisBudget("fast", "low"),
+    );
+
+    ledger.accept({
+      missionId: "mission-verify",
+      provider: "exa",
+      candidates: [candidate()],
+      coveredMissionIds: ["mission-verify"],
+      status: "completed",
+      error: null,
+      searched: true,
+      cacheHit: false,
+      durationMs: 10,
+    });
+    expect(ledger.getSources()).toHaveLength(0);
+    expect(ledger.getAssertions()).toHaveLength(0);
+
+    const accepted = ledger.acceptAdjudications([decision()]);
+    expect(accepted.acceptedAssertions).toBe(1);
+    expect(ledger.getAssertions()[0]).toMatchObject({
+      relationship: "supports",
+      claimId: "claim-1",
+      validation: { claimRelevant: true, relationshipChecked: true },
+    });
+  });
+
+  it("rejects search summaries from becoming support or contradiction claims", () => {
+    const checked = validateEvidenceAdjudication(
+      decision({
+        relationship: "contradicts",
+        excerpt: null,
+      }),
+      candidate({
+        contentKind: "search-summary",
+        content: "A search summary mentions River County and 12 projects in 2024.",
+        discoveryExcerpt: null,
+      }),
+      article(),
+      plan(),
+    );
+    expect(checked).toMatchObject({
+      accepted: false,
+      claimRelevant: false,
+      relationshipChecked: false,
+    });
+    expect(checked.reason).toContain("search summary");
+  });
+
+  it("rejects cross-mission and ungrounded claim mappings", () => {
+    const articleIndex = article();
+    const analysisPlan = plan();
+    expect(
+      validateEvidenceAdjudication(
+        decision({ missionId: "mission-unknown" }),
+        candidate(),
+        articleIndex,
+        analysisPlan,
+      ).accepted,
+    ).toBe(false);
+    expect(
+      validateEvidenceAdjudication(
+        decision({ excerpt: "A different event happened elsewhere." }),
+        candidate(),
+        articleIndex,
+        analysisPlan,
+      ).accepted,
+    ).toBe(false);
+  });
+
+  it("does not let ordinary claim missions manufacture political-context signals", () => {
+    const checked = validateEvidenceAdjudication(
+      decision({
+        relationship: "adds-context",
+        claimId: null,
+        context: {
+          sourceKind: "topic-context",
+          subject: "River County",
+          score: 1,
+          direction: "right",
+          strength: 0.6,
+          relevance: 0.8,
+          explanation: "The source frames the topic in a right-leaning direction.",
+        },
+      }),
+      candidate(),
+      article(),
+      plan(),
+    );
+    expect(checked.accepted).toBe(false);
+    expect(checked.reason).toContain("context missions");
+  });
+});
diff --git a/packages/intelligence/src/evidence/validation.ts b/packages/intelligence/src/evidence/validation.ts
index ada9de9..5eb6f42 100644
--- a/packages/intelligence/src/evidence/validation.ts
+++ b/packages/intelligence/src/evidence/validation.ts
@@ -1,68 +1,373 @@
 import type {
+  EvidenceAdjudication,
+  EvidenceCandidate,
   EvidenceCard,
   EvidenceValidation,
   SourceRecord,
 } from "@perspectica/contracts/evidence";
-import { normalizeCanonicalUrl } from "./normalization";
+import type { ArticleIndex } from "@perspectica/contracts/article";
+import type { AnalysisPlan } from "@perspectica/contracts/report";
+import { normalizeCanonicalUrl, normalizeEvidenceText } from "./normalization";
 import { excerptMatchesContent } from "./normalization";
 
-export function validateEvidenceCard(
-  card: EvidenceCard,
+function result(
+  accepted: boolean,
+  provenance: EvidenceValidation["provenance"],
+  excerptMatches: boolean,
+  reason: string,
+  claimRelevant = false,
+  relationshipChecked = false,
+): EvidenceValidation {
+  return {
+    accepted,
+    provenance,
+    excerptMatches,
+    claimRelevant,
+    relationshipChecked,
+    reason,
+  };
+}
+
+function words(value: string): string[] {
+  return normalizeEvidenceText(value)
+    .toLocaleLowerCase("en-US")
+    .split(/[^a-z0-9]+/)
+    .filter((word) => word.length >= 4);
+}
+
+function containsSubject(haystack: string, subject: string): boolean {
+  const source = normalizeEvidenceText(haystack).toLocaleLowerCase("en-US");
+  const expected = words(subject);
+  return (
+    expected.length > 0 &&
+    expected.filter((word) => source.includes(word)).length >= expected.length
+  );
+}
+
+function claimAnchorMatches(
+  candidate: EvidenceCandidate,
+  claim: AnalysisPlan["claims"][number],
+  article: ArticleIndex,
+): boolean {
+  const haystack = normalizeEvidenceText(
+    `${candidate.content} ${candidate.discoveryContext ?? ""} ${candidate.title}`,
+  ).toLocaleLowerCase("en-US");
+  const referencedParagraphs = new Set(claim.paragraphIds);
+  const anchors = [
+    ...article.entities
+      .filter((entity) => referencedParagraphs.has(entity.paragraphId))
+      .map((entity) => entity.text),
+    ...article.quantities
+      .filter((quantity) => referencedParagraphs.has(quantity.paragraphId))
+      .map((quantity) => quantity.text),
+    ...article.dates
+      .filter((date) => referencedParagraphs.has(date.paragraphId))
+      .map((date) => date.text),
+  ];
+  if (
+    anchors.some((anchor) =>
+      haystack.includes(normalizeEvidenceText(anchor).toLocaleLowerCase("en-US")),
+    )
+  )
+    return true;
+  const claimWords = words(claim.text);
+  const overlap = claimWords.filter((word) => haystack.includes(word)).length;
+  return overlap >= Math.min(3, Math.max(1, Math.ceil(claimWords.length * 0.2)));
+}
+
+function expectedContextSubject(
+  mission: AnalysisPlan["missions"][number],
+  article: ArticleIndex,
+): string | null {
+  if (mission.purpose === "journalist-context") return article.meta.author;
+  if (mission.purpose === "publication-context") return article.meta.publication;
+  if (mission.purpose === "comparable-coverage") return article.meta.title;
+  return null;
+}
+
+function expectedContextKind(
+  mission: AnalysisPlan["missions"][number],
+): "publication-history" | "journalist-work" | "comparable-coverage" | "topic-context" | null {
+  switch (mission.purpose) {
+    case "journalist-context":
+      return "journalist-work";
+    case "publication-context":
+      return "publication-history";
+    case "comparable-coverage":
+      return "comparable-coverage";
+    case "missing-background":
+      return "topic-context";
+    default:
+      return null;
+  }
+}
+
+function basicUrlValidation(
+  card: Pick<EvidenceCard, "sourceUrl" | "contentKind" | "content" | "excerpt">,
   articleUrl: string,
-): EvidenceValidation & { canonicalUrl: string | null } {
+) {
   const canonicalUrl = normalizeCanonicalUrl(card.sourceUrl);
   if (!canonicalUrl)
     return {
-      accepted: false,
-      provenance: "unknown",
-      excerptMatches: false,
-      reason: "The provider returned an invalid URL.",
       canonicalUrl: null,
+      validation: result(false, "unknown", false, "The provider returned an invalid URL."),
     };
-  const articleCanonical = normalizeCanonicalUrl(articleUrl);
-  if (articleCanonical === canonicalUrl)
+  if (normalizeCanonicalUrl(articleUrl) === canonicalUrl)
     return {
-      accepted: false,
-      provenance: "article-link",
-      excerptMatches: false,
-      reason: "The current article cannot independently verify itself.",
       canonicalUrl,
+      validation: result(
+        false,
+        "article-link",
+        false,
+        "The current article cannot independently verify itself.",
+      ),
     };
   if (card.contentKind === "source-text") {
     if (!card.content.trim())
       return {
-        accepted: false,
-        provenance: "verified-url",
-        excerptMatches: false,
-        reason: "Source text was empty.",
         canonicalUrl,
+        validation: result(false, "verified-url", false, "Source text was empty."),
       };
-    if (card.excerpt && !excerptMatchesContent(card.excerpt, card.content))
+    if (!card.excerpt || !excerptMatchesContent(card.excerpt, card.content))
       return {
-        accepted: false,
-        provenance: "verified-url",
-        excerptMatches: false,
-        reason: "The exact excerpt was not found in the source text.",
         canonicalUrl,
+        validation: result(
+          false,
+          "verified-url",
+          false,
+          "The exact excerpt was not found in the source text.",
+        ),
       };
   }
   if (card.contentKind === "search-summary" && card.excerpt)
     return {
-      accepted: false,
-      provenance: "verified-url",
-      excerptMatches: false,
-      reason: "Search summaries cannot carry quoteable excerpts.",
       canonicalUrl,
+      validation: result(
+        false,
+        "verified-url",
+        false,
+        "Search summaries cannot carry quoteable excerpts.",
+      ),
     };
   return {
-    accepted: true,
-    provenance: "verified-url",
-    excerptMatches: card.contentKind === "search-summary" ? false : Boolean(card.excerpt),
-    reason: "Provider URL and content provenance validated.",
     canonicalUrl,
+    validation: result(
+      true,
+      "verified-url",
+      card.contentKind === "source-text",
+      "Provider URL and content mechanics validated.",
+    ),
+  };
+}
+
+/**
+ * Validate the semantic handoff from the bounded adjudicator into the ledger.
+ * The provider's mission purpose is never treated as a relationship decision.
+ */
+export function validateEvidenceAdjudication(
+  decision: EvidenceAdjudication,
+  candidate: EvidenceCandidate,
+  article: ArticleIndex,
+  plan: AnalysisPlan,
+): EvidenceValidation & { canonicalUrl: string | null } {
+  const basic = basicUrlValidation(
+    {
+      sourceUrl: candidate.sourceUrl,
+      contentKind: candidate.contentKind,
+      content: candidate.content,
+      excerpt: decision.excerpt,
+    },
+    article.meta.canonicalUrl,
+  );
+  if (!basic.validation.accepted || !basic.canonicalUrl)
+    return { ...basic.validation, canonicalUrl: basic.canonicalUrl };
+
+  if (decision.candidateId !== candidate.id)
+    return {
+      ...result(false, "verified-url", false, "The adjudicator referenced an unknown candidate."),
+      canonicalUrl: basic.canonicalUrl,
+    };
+  // A provider mission is discovery provenance only. The bounded adjudicator
+  // may map a candidate to any planned mission when the source actually
+  // matches that mission's claim boundary.
+  const mission = plan.missions.find((value) => value.id === decision.missionId);
+  if (!mission)
+    return {
+      ...result(false, "verified-url", false, "The adjudicator referenced an unknown mission."),
+      canonicalUrl: basic.canonicalUrl,
+    };
+
+  const claim = decision.claimId
+    ? plan.claims.find((value) => value.id === decision.claimId)
+    : undefined;
+  if (decision.claimId && !claim)
+    return {
+      ...result(false, "verified-url", false, "The adjudicator referenced an unknown claim."),
+      canonicalUrl: basic.canonicalUrl,
+    };
+  if (claim && !mission.claimIds.includes(claim.id))
+    return {
+      ...result(false, "verified-url", false, "The claim is outside the mission boundary."),
+      canonicalUrl: basic.canonicalUrl,
+    };
+  if (["supports", "contradicts", "qualifies"].includes(decision.relationship) && !claim)
+    return {
+      ...result(
+        false,
+        "verified-url",
+        false,
+        "Claim relationships require an exact planned claim.",
+      ),
+      canonicalUrl: basic.canonicalUrl,
+    };
+  if (
+    candidate.contentKind === "search-summary" &&
+    ["supports", "contradicts", "qualifies"].includes(decision.relationship)
+  )
+    return {
+      ...result(
+        false,
+        "verified-url",
+        false,
+        "A search summary cannot independently establish support or contradiction.",
+      ),
+      canonicalUrl: basic.canonicalUrl,
+    };
+  if (claim && !claimAnchorMatches(candidate, claim, article))
+    return {
+      ...result(
+        false,
+        "verified-url",
+        basic.validation.excerptMatches,
+        "The source does not contain a validated claim anchor.",
+      ),
+      canonicalUrl: basic.canonicalUrl,
+    };
+
+  const expectedKind = expectedContextKind(mission);
+  const subject = expectedContextSubject(mission, article);
+  if (expectedKind && ["journalist-work", "publication-history"].includes(expectedKind) && !subject)
+    return {
+      ...result(
+        false,
+        "verified-url",
+        basic.validation.excerptMatches,
+        "Context identity is unavailable in the article metadata.",
+      ),
+      canonicalUrl: basic.canonicalUrl,
+    };
+  if (decision.context && !expectedKind)
+    return {
+      ...result(
+        false,
+        "verified-url",
+        basic.validation.excerptMatches,
+        "Political context signals are restricted to context missions.",
+      ),
+      canonicalUrl: basic.canonicalUrl,
+    };
+  if (expectedKind && !decision.context)
+    return {
+      ...result(
+        false,
+        "verified-url",
+        basic.validation.excerptMatches,
+        "Context missions require a source-backed context signal.",
+      ),
+      canonicalUrl: basic.canonicalUrl,
+    };
+  if (decision.context && decision.context.sourceKind !== expectedKind && expectedKind)
+    return {
+      ...result(
+        false,
+        "verified-url",
+        basic.validation.excerptMatches,
+        "The context signal does not match the mission purpose.",
+      ),
+      canonicalUrl: basic.canonicalUrl,
+    };
+  if (decision.context) {
+    const expectedDirection =
+      decision.context.score < -0.2 ? "left" : decision.context.score > 0.2 ? "right" : "center";
+    if (decision.context.direction !== expectedDirection)
+      return {
+        ...result(
+          false,
+          "verified-url",
+          basic.validation.excerptMatches,
+          "The context direction does not match its bounded score.",
+        ),
+        canonicalUrl: basic.canonicalUrl,
+      };
+  }
+  if (
+    subject &&
+    decision.context &&
+    !containsSubject(`${decision.context.subject} ${decision.statement}`, subject)
+  )
+    return {
+      ...result(
+        false,
+        "verified-url",
+        basic.validation.excerptMatches,
+        "The source-backed context did not identify the requested subject.",
+      ),
+      canonicalUrl: basic.canonicalUrl,
+    };
+  if (
+    expectedKind &&
+    subject &&
+    !containsSubject(
+      `${candidate.title} ${candidate.content} ${candidate.discoveryContext ?? ""} ${decision.statement}`,
+      subject,
+    )
+  )
+    return {
+      ...result(
+        false,
+        "verified-url",
+        basic.validation.excerptMatches,
+        "The candidate does not identify the requested context subject.",
+      ),
+      canonicalUrl: basic.canonicalUrl,
+    };
+  if (
+    /\b(?:surfaced|relevant source|not fetched as a transcript|returned this url)\b/i.test(
+      decision.statement,
+    )
+  )
+    return {
+      ...result(
+        false,
+        "verified-url",
+        basic.validation.excerptMatches,
+        "The adjudicator returned discovery prose instead of source-backed evidence.",
+      ),
+      canonicalUrl: basic.canonicalUrl,
+    };
+
+  return {
+    ...result(
+      true,
+      "verified-url",
+      basic.validation.excerptMatches,
+      "Candidate URL, claim anchor, exact excerpt, and adjudicated relationship validated.",
+      Boolean(claim) || Boolean(expectedKind),
+      true,
+    ),
+    canonicalUrl: basic.canonicalUrl,
   };
 }
 
+/** Compatibility boundary for callers that still validate a fully formed card. */
+export function validateEvidenceCard(
+  card: EvidenceCard,
+  articleUrl: string,
+): EvidenceValidation & { canonicalUrl: string | null } {
+  const checked = basicUrlValidation(card, articleUrl);
+  return { ...checked.validation, canonicalUrl: checked.canonicalUrl };
+}
+
 export function mergeSource(existing: SourceRecord | undefined, next: SourceRecord): SourceRecord {
   if (!existing) return next;
   if (existing.contentKind === "search-summary" && next.contentKind === "source-text") return next;
diff --git a/packages/intelligence/src/index.ts b/packages/intelligence/src/index.ts
index a8ea043..743b945 100644
--- a/packages/intelligence/src/index.ts
+++ b/packages/intelligence/src/index.ts
@@ -8,6 +8,8 @@ export * from "./retrieval/coordinator";
 export * from "./retrieval/scheduler";
 export * from "./evidence/source-ledger";
 export * from "./evidence/validation";
+export * from "./evidence/normalization";
+export * from "./evidence/adjudication";
 export * from "./evidence/sufficiency";
 export * from "./synthesis/perspective";
 export * from "./synthesis/evidence-sections";
diff --git a/packages/intelligence/src/pipeline.test.ts b/packages/intelligence/src/pipeline.test.ts
index c56e398..737d146 100644
--- a/packages/intelligence/src/pipeline.test.ts
+++ b/packages/intelligence/src/pipeline.test.ts
@@ -7,6 +7,7 @@ import {
   retryArticleSections,
   type AnalysisArtifacts,
 } from "./index";
+import type { EvidenceAdjudicator } from "./evidence/adjudication";
 
 function article() {
   return ArticleDocumentSchema.parse({
@@ -59,32 +60,33 @@ function retriever() {
   return {
     async *retrieve(plan: RetrievalPlan, _signal: AbortSignal): AsyncIterable<EvidenceBatch> {
       for (const [index, mission] of plan.missions.entries()) {
-        const content = `Independent record ${index + 1} confirms the bounded claim tested by ${mission.id}.`;
+        const content = `Independent record ${index + 1} confirms: The city council approved a public housing investment after a 2026 vote.`;
         yield {
           missionId: mission.id,
           provider: "exa",
           searched: true,
           cacheHit: false,
           durationMs: 2,
-          cards: [
+          candidates: [
             {
+              id: `candidate-${index + 1}`,
               missionId: mission.id,
-              claimId: mission.claimIds[0] ?? null,
               sourceUrl: `https://evidence.example/source-${index + 1}`,
               title: `Evidence ${index + 1}`,
               publication: "Evidence Daily",
               publishedAt: null,
-              statement: content,
-              excerpt: content,
               content,
               contentKind: "source-text",
-              relationship:
-                mission.purpose === "correction-or-qualification" ? "qualifies" : "supports",
               sourceType: "independent-reporting",
-              confidence: 0.8,
+              discoveryContext: null,
+              discoveryExcerpt: content,
+              providerScore: 0.8,
               provider: "exa",
             },
           ],
+          coveredMissionIds: [mission.id],
+          status: "completed",
+          error: null,
         };
       }
     },
@@ -92,6 +94,29 @@ function retriever() {
 }
 
 describe("V2 intelligence pipeline", () => {
+  const adjudicator: EvidenceAdjudicator = {
+    async adjudicate({ candidates, plan }) {
+      return candidates.flatMap((candidate) => {
+        const mission = plan.missions.find((value) => value.id === candidate.missionId);
+        if (!mission?.claimIds[0]) return [];
+        return [
+          {
+            candidateId: candidate.id,
+            missionId: mission.id,
+            claimId: mission.claimIds[0],
+            relationship:
+              mission.purpose === "correction-or-qualification" ? "qualifies" : "supports",
+            statement: "The source reports the same central claim tested in the article.",
+            excerpt: candidate.content,
+            confidence: 0.8,
+            relevance: 0.85,
+            context: null,
+          },
+        ];
+      });
+    },
+  };
+
   it("uses one index, bounded planning, a shared ledger, and explicit phases", async () => {
     const events = [];
     for await (const event of analyzeArticle({
@@ -101,6 +126,7 @@ describe("V2 intelligence pipeline", () => {
       reasoningEffort: "low",
       now: () => new Date("2026-08-02T12:00:00.000Z"),
       createId: () => "plan-fixture",
+      adjudicator,
     }))
       events.push(event);
 
@@ -142,6 +168,7 @@ describe("V2 intelligence pipeline", () => {
     for await (const event of analyzeArticle({
       article: article(),
       retriever: retriever(),
+      adjudicator,
       signal: controller.signal,
     }))
       events.push(event);
@@ -156,7 +183,10 @@ describe("V2 intelligence pipeline", () => {
           yield {
             missionId: mission.id,
             provider: "exa" as const,
-            cards: [],
+            candidates: [],
+            coveredMissionIds: [mission.id],
+            status: "failed",
+            error: "provider unavailable",
             searched: true,
             cacheHit: false,
             durationMs: 1,
@@ -191,5 +221,45 @@ describe("V2 intelligence pipeline", () => {
     expect(retryEvents.some((event) => event.type === "lens.ready")).toBe(false);
     expect(retryEvents.some((event) => event.type === "research.progress")).toBe(true);
     expect(retryEvents.some((event) => event.type === "section.ready")).toBe(true);
+
+    let emptyArtifacts: AnalysisArtifacts | undefined;
+    const honestlyEmptyRetriever = {
+      async *retrieve(plan: RetrievalPlan): AsyncIterable<EvidenceBatch> {
+        for (const mission of plan.missions) {
+          yield {
+            missionId: mission.id,
+            provider: "exa" as const,
+            candidates: [],
+            coveredMissionIds: [mission.id],
+            status: "completed" as const,
+            error: null,
+            searched: true,
+            cacheHit: false,
+            durationMs: 1,
+          };
+        }
+      },
+    };
+    for await (const _event of analyzeArticle({
+      article: article(),
+      retriever: honestlyEmptyRetriever,
+      mode: "fast",
+      reasoningEffort: "low",
+      onArtifacts: (value) => {
+        emptyArtifacts = value;
+      },
+    })) {
+      // Drain the complete empty run before checking targeted retry behavior.
+    }
+    expect(emptyArtifacts).toBeDefined();
+    if (!emptyArtifacts) return;
+    const emptyRetryEvents = [];
+    for await (const event of retryArticleSections({
+      artifacts: emptyArtifacts,
+      retriever: retriever(),
+      sections: ["contradicting"],
+    }))
+      emptyRetryEvents.push(event);
+    expect(emptyRetryEvents.some((event) => event.type === "research.progress")).toBe(false);
   });
 });
diff --git a/packages/intelligence/src/pipeline.ts b/packages/intelligence/src/pipeline.ts
index eb6ed5b..0c2acbe 100644
--- a/packages/intelligence/src/pipeline.ts
+++ b/packages/intelligence/src/pipeline.ts
@@ -16,6 +16,7 @@ import { projectBias, projectReport, projectSourceList } from "./report/projecto
 import { synthesizePerspective } from "./synthesis/perspective";
 import { createTelemetry, noteTelemetry, type PipelineTelemetry } from "./telemetry";
 import type { LanguageModel } from "ai";
+import { adjudicateEvidence, type EvidenceAdjudicator } from "./evidence/adjudication";
 
 export interface AnalysisInput {
   article: ArticleDocument;
@@ -30,6 +31,7 @@ export interface AnalysisInput {
   createId?: () => string;
   onTelemetry?: (telemetry: PipelineTelemetry) => void;
   onArtifacts?: (artifacts: AnalysisArtifacts) => void | Promise<void>;
+  adjudicator?: EvidenceAdjudicator;
 }
 
 export interface AnalysisArtifacts {
@@ -49,6 +51,7 @@ export interface TargetedRetryInput {
   signal?: AbortSignal;
   now?: () => Date;
   onTelemetry?: (telemetry: PipelineTelemetry) => void;
+  adjudicator?: EvidenceAdjudicator;
 }
 
 function randomId(prefix: string): string {
@@ -132,7 +135,7 @@ export async function* analyzeArticle(input: AnalysisInput): AsyncGenerator<Pipe
       publishedAt: index.meta.publishedAt,
       contentType: index.meta.contentType,
     });
-    yield emit("worksCited.ready", projectSourceList(input.article));
+    yield emit("worksCited.ready", projectSourceList(index));
     yield emit("phase.changed", {
       phase: "planning",
       message: "Planning global research missions.",
@@ -151,7 +154,7 @@ export async function* analyzeArticle(input: AnalysisInput): AsyncGenerator<Pipe
     yield emit("lens.ready", {
       plan,
       provisionalCompass: plan.applicability.compass.applicable
-        ? projectReport(index, input.article, plan, preliminaryLedger).compass
+        ? projectReport(index, plan, preliminaryLedger).compass
         : null,
       provisionalBias: projectBias(plan),
       missionCount: plan.missions.length,
@@ -161,6 +164,7 @@ export async function* analyzeArticle(input: AnalysisInput): AsyncGenerator<Pipe
       message: `Checking ${plan.missions.length} evidence missions.`,
     });
     const ledger = preliminaryLedger;
+    const candidates = [];
     for await (const progress of runRetrieval({
       retriever: input.retriever,
       plan,
@@ -171,8 +175,10 @@ export async function* analyzeArticle(input: AnalysisInput): AsyncGenerator<Pipe
     })) {
       telemetry.searchCalls += progress.batch.searched ? 1 : 0;
       telemetry.cacheHits += progress.batch.cacheHit ? 1 : 0;
+      candidates.push(...progress.batch.candidates);
       const snapshot = ledger.snapshot();
       yield emit("research.progress", {
+        candidateCount: progress.candidateCount,
         completedMissions: progress.completedMissions,
         totalMissions: progress.totalMissions,
         acceptedSources: snapshot.sufficiency.acceptedSources,
@@ -183,9 +189,26 @@ export async function* analyzeArticle(input: AnalysisInput): AsyncGenerator<Pipe
         sourceCount: snapshot.sources.length,
         assertionCount: snapshot.assertions.length,
       });
-      if (snapshot.sufficiency.stop) break;
     }
     throwIfAborted(input.signal);
+    yield emit("phase.changed", {
+      phase: "adjudicating",
+      message: "Adjudicating candidate sources against exact article claims.",
+    });
+    const decisions = await adjudicateEvidence({
+      article: index,
+      plan,
+      candidates,
+      budget,
+      signal: input.signal,
+      adjudicator: input.adjudicator,
+    });
+    ledger.acceptAdjudications(decisions);
+    yield emit("ledger.updated", {
+      sourceCount: ledger.getSources().length,
+      assertionCount: ledger.getAssertions().length,
+      snapshot: ledger.snapshot(),
+    });
     await input.onArtifacts?.({
       analysisId,
       article: input.article,
@@ -195,10 +218,6 @@ export async function* analyzeArticle(input: AnalysisInput): AsyncGenerator<Pipe
       budget,
       telemetry,
     });
-    yield emit("phase.changed", {
-      phase: "adjudicating",
-      message: "Comparing article framing with accepted evidence.",
-    });
     const perspective = synthesizePerspective(index, plan, ledger);
     yield emit("perspective.ready", {
       compass: perspective.compass,
@@ -208,7 +227,7 @@ export async function* analyzeArticle(input: AnalysisInput): AsyncGenerator<Pipe
       phase: "composing",
       message: "Writing the report from the shared evidence graph.",
     });
-    const projected = projectReport(index, input.article, plan, ledger);
+    const projected = projectReport(index, plan, ledger);
     yield emit("section.ready", { section: "bias", data: projected.bias });
     yield emit("section.ready", {
       section: "journalist-context",
@@ -225,9 +244,18 @@ export async function* analyzeArticle(input: AnalysisInput): AsyncGenerator<Pipe
     });
     yield emit("worksCited.ready", projected.sourceList);
     const completedAt = now();
-    const failedSections: ReportSection[] = [];
-    const status =
-      ledger.getAssertions().length === 0 && plan.missions.length > 0 ? "partial" : "complete";
+    const failedSections = failedSectionsForReport(
+      [
+        "compass",
+        "bias",
+        "journalist-context",
+        "supporting",
+        "contradicting",
+        "additional-context",
+      ],
+      ledger,
+    );
+    const status = failedSections.length > 0 ? "partial" : "complete";
     yield emit("phase.changed", {
       phase: status === "complete" ? "complete" : "partial",
       message:
@@ -259,26 +287,13 @@ export async function* analyzeArticle(input: AnalysisInput): AsyncGenerator<Pipe
 
 function failedSectionsForReport(
   sections: readonly ReportSection[],
-  projected: ReturnType<typeof projectReport>,
+  ledger: EvidenceLedger,
 ): ReportSection[] {
-  return sections.filter((section) => {
-    switch (section) {
-      case "compass":
-        return projected.compass === null;
-      case "bias":
-        return projected.bias.status === "empty";
-      case "journalist-context":
-        return projected.journalistContext.status === "empty";
-      case "supporting":
-        return projected.evidence.supporting.status === "empty";
-      case "contradicting":
-        return projected.evidence.contradicting.status === "empty";
-      case "additional-context":
-        return projected.evidence.additionalContext.status === "empty";
-      case "works-cited":
-        return projected.sourceList.status === "empty";
-    }
-  });
+  return sections.filter((section) =>
+    ledger.plan.missions.some(
+      (mission) => ledger.isMissionFailed(mission.id) && mission.canServeSections.includes(section),
+    ),
+  );
 }
 
 /** Retry only requested report lanes against the existing evidence graph. */
@@ -297,6 +312,7 @@ export async function* retryArticleSections(
       phase: "retrieving",
       message: "Retrying only the incomplete research lanes.",
     });
+    const candidates = [];
     for await (const progress of retryRetrieval({
       retriever: input.retriever,
       plan: artifacts.plan,
@@ -307,8 +323,10 @@ export async function* retryArticleSections(
       now: () => now().valueOf(),
     })) {
       throwIfAborted(signal);
+      candidates.push(...progress.batch.candidates);
       const snapshot = artifacts.ledger.snapshot();
       yield emit("research.progress", {
+        candidateCount: progress.candidateCount,
         completedMissions: progress.completedMissions,
         totalMissions: progress.totalMissions,
         acceptedSources: snapshot.sufficiency.acceptedSources,
@@ -323,8 +341,17 @@ export async function* retryArticleSections(
     throwIfAborted(signal);
     yield emit("phase.changed", {
       phase: "adjudicating",
-      message: "Re-evaluating the requested lanes against accepted evidence.",
+      message: "Re-evaluating candidate sources against the requested lanes.",
     });
+    const decisions = await adjudicateEvidence({
+      article: artifacts.index,
+      plan: artifacts.plan,
+      candidates,
+      budget: artifacts.budget,
+      signal,
+      adjudicator: input.adjudicator,
+    });
+    artifacts.ledger.acceptAdjudications(decisions);
     const perspective = synthesizePerspective(artifacts.index, artifacts.plan, artifacts.ledger);
     yield emit("perspective.ready", {
       compass: perspective.compass,
@@ -334,12 +361,7 @@ export async function* retryArticleSections(
       phase: "composing",
       message: "Updating only the requested report sections.",
     });
-    const projected = projectReport(
-      artifacts.index,
-      artifacts.article,
-      artifacts.plan,
-      artifacts.ledger,
-    );
+    const projected = projectReport(artifacts.index, artifacts.plan, artifacts.ledger);
     const requestedSet = new Set(requested);
     if (requestedSet.has("bias"))
       yield emit("section.ready", { section: "bias", data: projected.bias });
@@ -366,7 +388,7 @@ export async function* retryArticleSections(
     }
     if (input.sections.includes("works-cited"))
       yield emit("worksCited.ready", projected.sourceList);
-    const failedSections = failedSectionsForReport(input.sections, projected).filter(
+    const failedSections = failedSectionsForReport(input.sections, artifacts.ledger).filter(
       (section) => section !== "works-cited",
     );
     const completedAt = now();
diff --git a/packages/intelligence/src/planning/lens.test.ts b/packages/intelligence/src/planning/lens.test.ts
new file mode 100644
index 0000000..5d187b3
--- /dev/null
+++ b/packages/intelligence/src/planning/lens.test.ts
@@ -0,0 +1,146 @@
+import type { ArticleIndex } from "@perspectica/contracts/article";
+import type { ArticleBiasSignal, ArticleCompassSignal } from "@perspectica/contracts/report";
+import { describe, expect, it } from "vitest";
+import { groundedArticleSignals } from "./lens";
+
+function article(): ArticleIndex {
+  return {
+    version: "index-v2",
+    fingerprint: "article-fingerprint",
+    meta: {
+      title: "A grounded article",
+      author: null,
+      publication: "Example News",
+      publishedAt: null,
+      canonicalUrl: "https://example.com/article",
+      contentType: "news",
+      language: "en",
+    },
+    outline: [],
+    paragraphs: {
+      p1: {
+        id: "p1",
+        index: 0,
+        kind: "paragraph",
+        text: "The proposal is obviously expensive.",
+        preview: "The proposal is obviously expensive.",
+        speaker: null,
+        sentenceIds: ["s1"],
+        headingPath: [],
+        linkIds: [],
+        position: 0,
+        tokenCount: 6,
+      },
+      p2: {
+        id: "p2",
+        index: 1,
+        kind: "quote",
+        text: "Maya Chen said the proposal is affordable.",
+        preview: "Maya Chen said the proposal is affordable.",
+        speaker: "Maya Chen",
+        sentenceIds: ["s2"],
+        headingPath: [],
+        linkIds: [],
+        position: 0.5,
+        tokenCount: 7,
+      },
+    },
+    paragraphOrder: ["p1", "p2"],
+    sentences: {
+      s1: {
+        id: "s1",
+        paragraphId: "p1",
+        index: 0,
+        start: 0,
+        end: 37,
+        text: "The proposal is obviously expensive.",
+        speaker: null,
+        attributionVerb: null,
+        isQuoted: false,
+      },
+      s2: {
+        id: "s2",
+        paragraphId: "p2",
+        index: 0,
+        start: 0,
+        end: 44,
+        text: "Maya Chen said the proposal is affordable.",
+        speaker: "Maya Chen",
+        attributionVerb: "said",
+        isQuoted: true,
+      },
+    },
+    entities: [],
+    quantities: [],
+    dates: [],
+    links: [],
+    claimSeeds: [],
+    extraction: {
+      extractorVersion: "test",
+      indexedAt: "2026-08-02T12:00:00.000Z",
+      wordCount: 13,
+      contentChars: 82,
+      paragraphCount: 2,
+      sentenceCount: 2,
+      linkCount: 0,
+      contentTruncated: false,
+      articleStatus: "article",
+    },
+  };
+}
+
+describe("article signal grounding", () => {
+  it("drops cross-paragraph bias excerpts and repairs compass direction and attribution", () => {
+    const compass: ArticleCompassSignal = {
+      paragraphIds: ["p1"],
+      sentenceIds: ["s2"],
+      score: -2,
+      direction: "right",
+      strength: 0.8,
+      explanation: "The signal is left-coded.",
+      attributed: true,
+    };
+    const bias: ArticleBiasSignal = {
+      id: "bias-1",
+      technique: "word-choice",
+      paragraphId: "p1",
+      sentenceId: "s2",
+      excerpt: "Maya Chen said the proposal is affordable.",
+      explanation: "The wording is evaluative.",
+      confidence: 0.8,
+      attributed: true,
+    };
+
+    const grounded = groundedArticleSignals({ compass: [compass], bias: [bias] }, article());
+
+    expect(grounded.compass[0]).toMatchObject({
+      paragraphIds: ["p1"],
+      sentenceIds: ["s1"],
+      direction: "left",
+      attributed: false,
+    });
+    expect(grounded.bias).toEqual([]);
+  });
+
+  it("requires an exact article substring for a bias signal", () => {
+    const grounded = groundedArticleSignals(
+      {
+        compass: [],
+        bias: [
+          {
+            id: "bias-2",
+            technique: "word-choice",
+            paragraphId: "p1",
+            sentenceId: "s1",
+            excerpt: "not present in the article",
+            explanation: "Unsupported.",
+            confidence: 0.8,
+            attributed: false,
+          },
+        ],
+      },
+      article(),
+    );
+    expect(grounded.bias).toEqual([]);
+  });
+});
diff --git a/packages/intelligence/src/planning/lens.ts b/packages/intelligence/src/planning/lens.ts
index 0f0dfe1..bbdcd01 100644
--- a/packages/intelligence/src/planning/lens.ts
+++ b/packages/intelligence/src/planning/lens.ts
@@ -117,6 +117,75 @@ function planClaims(index: ArticleIndex, budget: AnalysisBudget): PlannedClaim[]
     }));
 }
 
+function signalAttribution(
+  index: ArticleIndex,
+  paragraphIds: string[],
+  sentenceIds: string[],
+): boolean {
+  const sentences = sentenceIds.flatMap((id) => (index.sentences[id] ? [index.sentences[id]] : []));
+  if (sentences.length > 0)
+    return sentences.some((sentence) =>
+      Boolean(sentence.speaker || sentence.attributionVerb || sentence.isQuoted),
+    );
+  return paragraphIds.some((id) => Boolean(index.paragraphs[id]?.speaker));
+}
+
+export function groundedArticleSignals(
+  signals: AnalysisPlan["articleSignals"],
+  index: ArticleIndex,
+): AnalysisPlan["articleSignals"] {
+  const compass = signals.compass
+    .flatMap((signal) => {
+      const paragraphIds = signal.paragraphIds.filter((id) => Boolean(index.paragraphs[id]));
+      if (paragraphIds.length === 0) return [];
+      const allowedSentenceIds = new Set(
+        paragraphIds.flatMap((paragraphId) => index.paragraphs[paragraphId]?.sentenceIds ?? []),
+      );
+      const sentenceIds = signal.sentenceIds.filter((id) => allowedSentenceIds.has(id));
+      const groundedSentenceIds = sentenceIds.length
+        ? sentenceIds
+        : (index.paragraphs[paragraphIds[0]!]?.sentenceIds.slice(0, 4) ?? []);
+      if (groundedSentenceIds.length === 0) return [];
+      const score = Math.max(-3, Math.min(3, signal.score));
+      return [
+        {
+          ...signal,
+          paragraphIds: paragraphIds.slice(0, 8),
+          sentenceIds: groundedSentenceIds.slice(0, 8),
+          score,
+          direction: score < -0.2 ? "left" : score > 0.2 ? "right" : "center",
+          attributed: signalAttribution(index, paragraphIds, groundedSentenceIds),
+        } satisfies ArticleCompassSignal,
+      ];
+    })
+    .slice(0, 8);
+  const bias = signals.bias
+    .flatMap((signal) => {
+      const paragraph = index.paragraphs[signal.paragraphId];
+      if (!paragraph) return [];
+      const sentence = signal.sentenceId ? index.sentences[signal.sentenceId] : undefined;
+      if (sentence && sentence.paragraphId !== signal.paragraphId) return [];
+      const excerpt = signal.excerpt.trim();
+      if (
+        !excerpt ||
+        !new RegExp(excerpt.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i").test(paragraph.text)
+      )
+        return [];
+      const sentenceIds = sentence ? [sentence.id] : paragraph.sentenceIds.slice(0, 1);
+      return [
+        {
+          ...signal,
+          paragraphId: paragraph.id,
+          sentenceId: sentence?.id ?? sentenceIds[0] ?? null,
+          excerpt,
+          attributed: signalAttribution(index, [paragraph.id], sentenceIds),
+        } satisfies ArticleBiasSignal,
+      ];
+    })
+    .slice(0, 6);
+  return { compass, bias };
+}
+
 function mission(
   idValue: string,
   claimIds: string[],
@@ -297,11 +366,19 @@ function normalizePlan(
   const paragraphIds = new Set(index.paragraphOrder);
   const sentenceIds = new Set(Object.keys(index.sentences));
   const claims = candidate.claims
-    .map((claim) => ({
-      ...claim,
-      paragraphIds: claim.paragraphIds.filter((value) => paragraphIds.has(value)),
-      sentenceIds: claim.sentenceIds.filter((value) => sentenceIds.has(value)),
-    }))
+    .map((claim) => {
+      const groundedParagraphIds = claim.paragraphIds.filter((value) => paragraphIds.has(value));
+      const groundedParagraphSet = new Set(groundedParagraphIds);
+      return {
+        ...claim,
+        paragraphIds: groundedParagraphIds,
+        sentenceIds: claim.sentenceIds.filter(
+          (value) =>
+            sentenceIds.has(value) &&
+            groundedParagraphSet.has(index.sentences[value]?.paragraphId ?? ""),
+        ),
+      };
+    })
     .filter((claim) => claim.paragraphIds.length > 0 && claim.sentenceIds.length > 0)
     .slice(0, budget.maxClaims);
   if (claims.length === 0) return fallback;
@@ -318,10 +395,16 @@ function normalizePlan(
         missionValue.purpose === "publication-context",
     )
     .slice(0, budget.maxMissions);
+  const articleSignals = groundedArticleSignals(candidate.articleSignals, index);
+  const fallbackSignals = groundedArticleSignals(fallback.articleSignals, index);
   return AnalysisPlanSchema.parse({
     ...candidate,
     id: candidate.id || fallback.id,
     claims,
+    articleSignals: {
+      compass: articleSignals.compass.length ? articleSignals.compass : fallbackSignals.compass,
+      bias: articleSignals.bias.length ? articleSignals.bias : fallbackSignals.bias,
+    },
     missions: missions.length > 0 ? missions : fallback.missions,
     requestedParagraphIds: candidate.requestedParagraphIds
       .filter((value) => paragraphIds.has(value))
diff --git a/packages/intelligence/src/report/projector.test.ts b/packages/intelligence/src/report/projector.test.ts
new file mode 100644
index 0000000..e2e29ac
--- /dev/null
+++ b/packages/intelligence/src/report/projector.test.ts
@@ -0,0 +1,70 @@
+import type { ArticleIndex } from "@perspectica/contracts/article";
+import { describe, expect, it } from "vitest";
+import { projectSourceList } from "./projector";
+
+describe("report source projection", () => {
+  it("excludes navigation, social, promotional, and unclassified links", () => {
+    const result = projectSourceList({
+      links: [
+        {
+          id: "external",
+          label: "External record",
+          url: "https://source.example/record",
+          paragraphId: "p1",
+          classification: "external",
+          host: "source.example",
+        },
+        {
+          id: "primary",
+          label: "Primary record",
+          url: "https://gov.example/record",
+          paragraphId: "p1",
+          classification: "likely-primary",
+          host: "gov.example",
+        },
+        {
+          id: "same",
+          label: "Related reporting",
+          url: "https://example.com/related",
+          paragraphId: "p2",
+          classification: "same-publication",
+          host: "example.com",
+        },
+        {
+          id: "nav",
+          label: "Home",
+          url: "https://example.com/",
+          paragraphId: null,
+          classification: "navigation",
+          host: "example.com",
+        },
+        {
+          id: "social",
+          label: "Share",
+          url: "https://social.example/share",
+          paragraphId: null,
+          classification: "social",
+          host: "social.example",
+        },
+        {
+          id: "promo",
+          label: "Subscribe",
+          url: "https://example.com/subscribe",
+          paragraphId: null,
+          classification: "promotional",
+          host: "example.com",
+        },
+        {
+          id: "unknown",
+          label: "Unclassified",
+          url: "https://unknown.example/link",
+          paragraphId: null,
+          classification: "unknown",
+          host: "unknown.example",
+        },
+      ],
+    } as ArticleIndex);
+
+    expect(result.sources.map((source) => source.id)).toEqual(["external", "primary", "same"]);
+  });
+});
diff --git a/packages/intelligence/src/report/projector.ts b/packages/intelligence/src/report/projector.ts
index 935d275..f5a9514 100644
--- a/packages/intelligence/src/report/projector.ts
+++ b/packages/intelligence/src/report/projector.ts
@@ -1,11 +1,11 @@
 import {
   BiasResultSchema,
   SourceListResultSchema,
-  type ArticleDocument,
   type BiasResult,
   type SourceListResult,
 } from "@perspectica/contracts";
 import type { ArticleIndex } from "@perspectica/contracts/article";
+import { normalizeCanonicalUrl } from "@perspectica/contracts/url";
 import type { AnalysisPlan } from "@perspectica/contracts/report";
 import { EvidenceLedger } from "../evidence/source-ledger";
 import {
@@ -63,30 +63,39 @@ export function projectBias(plan: AnalysisPlan): BiasResult {
   });
 }
 
-export function projectSourceList(article: ArticleDocument | ArticleIndex): SourceListResult {
-  const links =
-    "meta" in article
-      ? article.links
-      : article.links.map((link) => ({
-          id: link.id,
-          label: link.label,
-          url: link.url,
-          paragraphId: link.paragraphId,
-        }));
-  return SourceListResultSchema.parse({
-    status: "ready",
-    sources: links.slice(0, 20).map((link) => ({
+export function projectSourceList(article: ArticleIndex): SourceListResult {
+  const links = article.links
+    .filter((link) =>
+      ["external", "likely-primary", "same-publication"].includes(link.classification),
+    )
+    .filter((link) => link.classification !== "same-publication" || Boolean(link.paragraphId))
+    .map((link) => ({
       id: link.id,
       label: link.label,
-      url: link.url,
-      paragraphId: link.paragraphId ?? null,
-    })),
+      url: normalizeCanonicalUrl(link.url) ?? link.url,
+      paragraphId: link.paragraphId,
+    }));
+  const seen = new Set<string>();
+  return SourceListResultSchema.parse({
+    status: "ready",
+    sources: links
+      .filter((link) => {
+        if (seen.has(link.url)) return false;
+        seen.add(link.url);
+        return true;
+      })
+      .slice(0, 20)
+      .map((link) => ({
+        id: link.id,
+        label: link.label,
+        url: link.url,
+        paragraphId: link.paragraphId ?? null,
+      })),
   });
 }
 
 export function projectReport(
   index: ArticleIndex,
-  article: ArticleDocument,
   plan: AnalysisPlan,
   ledger: EvidenceLedger,
 ): ProjectedReport {
@@ -96,6 +105,6 @@ export function projectReport(
     bias: projectBias(plan),
     journalistContext: perspective.journalistContext,
     evidence: synthesizeEvidenceSections(ledger),
-    sourceList: projectSourceList(article),
+    sourceList: projectSourceList(index),
   };
 }
diff --git a/packages/intelligence/src/retrieval/coordinator.ts b/packages/intelligence/src/retrieval/coordinator.ts
index c116b75..c384348 100644
--- a/packages/intelligence/src/retrieval/coordinator.ts
+++ b/packages/intelligence/src/retrieval/coordinator.ts
@@ -9,6 +9,7 @@ import { EvidenceLedger } from "../evidence/source-ledger";
 
 export interface RetrievalProgress {
   batch: EvidenceBatch;
+  candidateCount: number;
   completedMissions: number;
   totalMissions: number;
   ledger: EvidenceLedger;
@@ -51,13 +52,18 @@ export async function* runRetrieval(
         ? options.signal.reason
         : new DOMException("Aborted", "AbortError");
     options.ledger.accept(batch);
+    const candidateCount = options.ledger.getCandidates().length;
     yield {
       batch,
+      candidateCount,
       completedMissions: options.ledger.completedMissionCount(),
       totalMissions: options.plan.missions.length,
       ledger: options.ledger,
     };
-    if (options.ledger.isSufficient()) break;
+    // Retrieval remains streaming, but every planned mission is allowed to
+    // settle before adjudication so an unattempted lane is never reported as
+    // an honestly empty section. Provider-level deadlines and concurrency
+    // still bound the work.
   }
 }
 
@@ -75,23 +81,10 @@ export async function* retryMissingSections(
   options: TargetedRetryOptions,
 ): AsyncGenerator<RetrievalProgress> {
   const requested = new Set(options.sections);
-  const snapshot = options.ledger.snapshot();
-  const coveredMissionIds = new Set<string>();
-  for (const section of requested) {
-    if ((snapshot.servedSections[section] ?? []).length > 0) continue;
-    for (const mission of options.plan.missions) {
-      if (
-        mission.canServeSections.includes(section) &&
-        options.ledger.getAssertions().some((assertion) => assertion.missionId === mission.id)
-      ) {
-        coveredMissionIds.add(mission.id);
-      }
-    }
-  }
   const missions = options.plan.missions.filter(
     (mission) =>
       mission.canServeSections.some((section) => requested.has(section)) &&
-      !coveredMissionIds.has(mission.id),
+      options.ledger.isMissionFailed(mission.id),
   );
   if (missions.length === 0) return;
   yield* runRetrieval({ ...options, plan: { ...options.plan, missions } });
diff --git a/packages/intelligence/src/retrieval/scheduler.ts b/packages/intelligence/src/retrieval/scheduler.ts
index ecbb3d3..a3124f6 100644
--- a/packages/intelligence/src/retrieval/scheduler.ts
+++ b/packages/intelligence/src/retrieval/scheduler.ts
@@ -3,29 +3,66 @@ export interface SchedulerTask<T> {
   run: () => Promise<T>;
 }
 
-export async function runPriorityTasks<T>(
+function abortError(signal: AbortSignal): Error {
+  return signal.reason instanceof Error ? signal.reason : new DOMException("Aborted", "AbortError");
+}
+
+/**
+ * Start bounded work in priority order and yield each completed task as soon
+ * as it settles. Returning from the consumer aborts the scheduler so a
+ * provider can cancel in-flight network work instead of waiting for the
+ * entire queue to drain.
+ */
+export async function* runPriorityTasksStream<T>(
   tasks: readonly SchedulerTask<T>[],
   maxConcurrency: number,
   signal: AbortSignal,
-): Promise<T[]> {
+): AsyncGenerator<T> {
   const queue = [...tasks].sort((left, right) => right.priority - left.priority);
-  const results: T[] = [];
+  const controller = new AbortController();
+  const abortFromParent = () => controller.abort(signal.reason);
+  if (signal.aborted) abortFromParent();
+  else signal.addEventListener("abort", abortFromParent, { once: true });
+
   let cursor = 0;
-  const worker = async () => {
-    while (cursor < queue.length) {
-      if (signal.aborted)
-        throw signal.reason instanceof Error
-          ? signal.reason
-          : new DOMException("Aborted", "AbortError");
-      const task = queue[cursor++];
-      if (!task) return;
-      results.push(await task.run());
-    }
+  const inFlight = new Map<number, Promise<{ id: number; value?: T; error?: unknown }>>();
+  let taskId = 0;
+  const start = () => {
+    const task = queue[cursor++];
+    if (!task) return;
+    const id = taskId++;
+    const promise = task
+      .run()
+      .then((value) => ({ id, value }))
+      .catch((error) => ({ id, error }));
+    inFlight.set(id, promise);
   };
-  await Promise.all(
-    Array.from({ length: Math.max(1, Math.min(maxConcurrency, queue.length || 1)) }, () =>
-      worker(),
-    ),
-  );
+
+  try {
+    const concurrency = Math.max(1, Math.min(maxConcurrency, queue.length || 1));
+    while (inFlight.size < concurrency && cursor < queue.length) start();
+    while (inFlight.size > 0) {
+      if (controller.signal.aborted) throw abortError(controller.signal);
+      const result = await Promise.race(inFlight.values());
+      inFlight.delete(result.id);
+      if (result.error !== undefined) throw result.error;
+      if (result.value !== undefined) yield result.value;
+      while (inFlight.size < concurrency && cursor < queue.length) start();
+    }
+  } finally {
+    signal.removeEventListener("abort", abortFromParent);
+    controller.abort();
+  }
+}
+
+export async function runPriorityTasks<T>(
+  tasks: readonly SchedulerTask<T>[],
+  maxConcurrency: number,
+  signal: AbortSignal,
+): Promise<T[]> {
+  const results: T[] = [];
+  for await (const result of runPriorityTasksStream(tasks, maxConcurrency, signal)) {
+    results.push(result);
+  }
   return results;
 }
diff --git a/packages/intelligence/src/retrieval/types.ts b/packages/intelligence/src/retrieval/types.ts
index 60e93ef..83afc2c 100644
--- a/packages/intelligence/src/retrieval/types.ts
+++ b/packages/intelligence/src/retrieval/types.ts
@@ -1,6 +1,6 @@
 export type {
   EvidenceBatch,
-  EvidenceCard,
+  EvidenceCandidate,
   EvidenceProvider,
   EvidenceRetriever,
   RetrievalMission,
diff --git a/packages/intelligence/src/synthesis/perspective.ts b/packages/intelligence/src/synthesis/perspective.ts
index 9592e46..e69f259 100644
--- a/packages/intelligence/src/synthesis/perspective.ts
+++ b/packages/intelligence/src/synthesis/perspective.ts
@@ -1,12 +1,13 @@
 import {
   JournalistContextResultSchema,
+  PoliticalContextResultSchema,
   type JournalistContextResult,
   type PoliticalContextResult,
 } from "@perspectica/contracts";
 import type { AnalysisPlan } from "@perspectica/contracts/report";
 import type { ArticleIndex } from "@perspectica/contracts/article";
 import { EvidenceLedger } from "../evidence/source-ledger";
-import { projectArticleCompass } from "../compass/calculate";
+import { projectArticleCompass, projectCompassWithContext } from "../compass/calculate";
 
 export interface PerspectiveResult {
   compass: ReturnType<typeof projectArticleCompass>;
@@ -53,13 +54,72 @@ export function synthesizePerspective(
     }),
     emptyReason: journalistAssertions.length > 0 ? undefined : "no-verified-evidence",
   });
+  const contextAssertions = ledger.getAssertions().filter((assertion) => assertion.context);
+  const contextSources = new Map(ledger.getSources().map((source) => [source.id, source]));
+  const politicalContext: PoliticalContextResult = PoliticalContextResultSchema.parse(
+    contextAssertions.length === 0
+      ? {
+          status: "empty",
+          summary:
+            "No source-backed publication, journalist, or comparable-coverage signal was verified.",
+          signals: [],
+        }
+      : {
+          status: "ready",
+          summary:
+            "The article-led placement was checked against bounded source-backed context. Context signals describe coverage history, not an author's identity or motive.",
+          signals: contextAssertions.slice(0, 8).flatMap((assertion) => {
+            const context = assertion.context;
+            const source = contextSources.get(assertion.sourceId);
+            if (!context || !source) return [];
+            return [
+              {
+                id: assertion.id,
+                sourceKind: context.sourceKind,
+                subject: context.subject,
+                score: context.score,
+                direction: context.direction,
+                strength: context.strength,
+                relevance: context.relevance,
+                explanation: context.explanation,
+                sourceTitle: source.title,
+                publication: source.publication,
+                url: source.canonicalUrl,
+                ...(source.contentKind === "source-text"
+                  ? {
+                      citationKind: "source-excerpt" as const,
+                      excerpt: assertion.excerpt ?? source.content.slice(0, 400),
+                    }
+                  : { citationKind: "search-summary" as const, excerpt: null }),
+              },
+            ];
+          }),
+          weighting: {
+            articleWeight: 0.6,
+            publicationHistory:
+              contextAssertions.filter(
+                (assertion) => assertion.context?.sourceKind === "publication-history",
+              ).length / Math.max(contextAssertions.length, 1),
+            journalistWork:
+              contextAssertions.filter(
+                (assertion) => assertion.context?.sourceKind === "journalist-work",
+              ).length / Math.max(contextAssertions.length, 1),
+            comparableCoverage:
+              contextAssertions.filter(
+                (assertion) => assertion.context?.sourceKind === "comparable-coverage",
+              ).length / Math.max(contextAssertions.length, 1),
+            topicContext:
+              contextAssertions.filter(
+                (assertion) => assertion.context?.sourceKind === "topic-context",
+              ).length / Math.max(contextAssertions.length, 1),
+            rationale:
+              "Article-owned signals remain the anchor; accepted contextual signals contribute no more than forty percent.",
+          },
+        },
+  );
   return {
-    compass: projectArticleCompass(index, plan),
-    politicalContext: {
-      status: "empty",
-      summary: "Article-owned evidence remains the primary spectrum basis in this bounded pass.",
-      signals: [],
-    },
+    compass: projectCompassWithContext(index, plan, politicalContext),
+    politicalContext,
     journalistContext,
   };
 }