@cyber-dash-tech/revela 0.13.0 → 0.15.0

package/lib/commands/review.ts

@@ -18,7 +18,7 @@ Goal:
 - Treat this as a narrative readiness review, not a deck HTML write-readiness review.
 - Do not write, patch, or directly edit ${DECKS_STATE_FILE}. Use the \`revela-decks\` tool for all state changes.
 - Call \`revela-decks\` action \`reviewNarrative\` as the authoritative deterministic readiness engine.
-- Do not call \`revela-decks\` action \`review\` here. That action is the deck/artifact gate and belongs to \`/revela deck --review\`.
+- Do not call \`revela-decks\` action \`review\` here. That action is the deck/artifact gate and belongs to \`/revela make deck --review\`.
 - Do not treat legacy \`writeReadiness.status\`, old review snapshots, or an existing HTML deck as narrative approval.
 - Do not write or overwrite \`decks/*.html\` during narrative review.
 - If the narrative is \`ready_for_approval\`, ask whether the user wants to approve it or revise it. Do not approve automatically.
@@ -50,7 +50,7 @@ Report format:
 - If warnings exist, list them after blockers as residual risks.
 - If approval is missing, ask whether the user wants to approve the narrative or revise it.
 - If approval is stale, say the prior approval no longer matches the current narrative hash.
-- Keep deck/artifact readiness separate. If the user wants to review slide-writing readiness, tell them to run \`/revela deck --review\`.
+- Keep deck/artifact readiness separate. If the user wants to review slide-writing readiness, tell them to run \`/revela make deck --review\`.
 
 Rules:
 - Do not write or overwrite \`decks/*.html\` during narrative review.
@@ -128,7 +128,7 @@ export function buildDeckReviewPrompt({
 
 Goal:
 - Use ${DECKS_STATE_FILE} as the source of truth for whether the current workspace deck is ready to be written to \`decks/*.html\`.
-- Treat this as an artifact gate for deck rendering, not strategic narrative approval. Narrative readiness is reviewed by \`/revela review\`.
+- Treat this as an artifact gate for deck rendering, not strategic narrative approval. Narrative readiness reports are reviewed by \`/revela review\`.
 - Preserve the deck spec for future sessions: every slide's content, layout, components, evidence, visuals, production status, and the 0.9 narrative compiler brief when available.
 - Do not write, patch, or directly edit ${DECKS_STATE_FILE}. Use the \`revela-decks\` tool for all state changes.
 - Let \`revela-decks\` action \`review\` compute writeReadiness; do not manually set readiness to ready.

package/lib/decks-state.ts

@@ -564,7 +564,7 @@ export function evaluateDeckStateWriteReadiness(state: DecksState, filePath: str
       type: "missing_slide_spec",
       severity: "blocker",
       message,
-      suggestedAction: "Run /revela review and resolve all readiness blockers before writing deck HTML.",
+      suggestedAction: "Run /revela make deck --review and resolve all readiness blockers before writing deck HTML.",
     })
   }
   if (deck.writeReadiness.blockers.length > 0) {
@@ -574,7 +574,7 @@ export function evaluateDeckStateWriteReadiness(state: DecksState, filePath: str
       type: "missing_slide_spec",
       severity: "blocker",
       message,
-      suggestedAction: "Resolve the stored writeReadiness blockers and rerun /revela review.",
+      suggestedAction: "Resolve the stored writeReadiness blockers and rerun /revela make deck --review.",
     })
   }
   if (normalized.reviews.length > 0) {
@@ -587,7 +587,7 @@ export function evaluateDeckStateWriteReadiness(state: DecksState, filePath: str
         type: "missing_slide_spec",
         severity: "blocker",
         message,
-        suggestedAction: "Run /revela review so readiness is recorded against the current active render target.",
+        suggestedAction: "Run /revela make deck --review so readiness is recorded against the current active render target.",
       })
     } else if (!isReviewSnapshotCurrent(normalized, snapshot, deck.slug)) {
       const message = "Latest review snapshot is stale for the current deck, sources, evidence, narrative state, or render target"
@@ -596,7 +596,7 @@ export function evaluateDeckStateWriteReadiness(state: DecksState, filePath: str
         type: "missing_slide_spec",
         severity: "blocker",
         message,
-        suggestedAction: "Run /revela review again after the latest state changes before writing deck HTML.",
+        suggestedAction: "Run /revela make deck --review again after the latest state changes before writing deck HTML.",
       })
     } else if (snapshot.status !== "ready") {
       const message = `Latest review snapshot is ${snapshot.status}, not ready`
@@ -605,7 +605,7 @@ export function evaluateDeckStateWriteReadiness(state: DecksState, filePath: str
         type: "missing_slide_spec",
         severity: "blocker",
         message,
-        suggestedAction: "Resolve review blockers and rerun /revela review before writing deck HTML.",
+        suggestedAction: "Resolve review blockers and rerun /revela make deck --review before writing deck HTML.",
       })
     }
   }

package/lib/inspect/prompt.ts

@@ -4,23 +4,31 @@ export function buildInspectionPrompt(input: {
   requestId: string
   file: string
   projection: InspectionPromptProjection
+  language?: string
 }): string {
+  const language = normalizeInspectLanguage(input.language)
   return `A user selected slide content in Revela Evidence Inspector. The selection may contain one referenced element, a whole slide, or multiple referenced elements selected with Cmd/Ctrl-click.
 
 Target file: ${input.file}
 Inspection request id: ${input.requestId}
+Display language: ${language}
 
-Use the structured projection below to produce the final inspector cards. This is LLM judgment with grounded boundaries: answer the selected object's purpose and source credibility only. Do not edit files. Do not mutate DECKS.json. Do not invent sources, quotes, URLs, page references, caveats, or evidence not present in the projection.
+Use the structured projection below to produce the final inspector cards. This is LLM judgment with grounded boundaries: explain the selected object's narrative reading context, bounded exploratory reading context, purpose, and source credibility only. Do not edit files. Do not mutate DECKS.json. Do not invent claim ids, evidence binding ids, sources, quotes, URLs, page references, caveats, objections, risks, artifact coverage, or evidence not present in the projection.
+
+Language boundary: the selected display language affects only human-readable card copy. Preserve all claim ids, canonical claim ids, evidence binding ids, source paths, findings files, URLs, numbers, quoted/source facts, caveats, artifact ids, and coverage statuses exactly as grounded in the projection. If the display language is Auto, use projection.deck.language when available; otherwise follow the user's/browser context or default to English.
 
 Return the result only by calling the \`revela-inspection-result\` tool with this request id. Do not answer in chat.
 
 Required card model:
+- Narrative Reading: when the projection includes a matched claim, preserve its claim id, canonical claim id, evidence binding ids, supported scope, unsupported scope, caveats, related objections, related risks, and artifact coverage. Artifact coverage must come only from projection.cards.artifacts; do not invent where a claim appears or whether an artifact is stale/current/partial/missing. If canonical narrative linkage is missing, say so and fall back to the matched slide claim; do not invent canonical ids.
+- Candidate boundary: when projection.match.claim is absent but projection.match.candidateClaims is present, explain the selected child element only within those candidate claim boundaries. You may describe that the child element functions as a detail, prerequisite, source note, risk cue, or evidence cue inside the slide, but you must not select one candidate claim id by semantic guess. If projection.match.confidence is none or candidateClaims is empty, explain the mapping gap instead of inventing a plausible claim.
+- Exploratory Reading: provide bounded, non-official reading cues for objection prep, audience reframing, appendix leads, and meeting prep only from the projection. Mark official as false. Keep missing evidence, caveats, unsupported scope, and stale artifacts visible. Do not make exploratory text sound like approved artifact content, and do not turn this into chat or a fix plan.
 - Purpose: explain why this selected content appears here, what job it serves in the slide purpose, narrative role, deck goal, audience, or narrative brief, and why it matters.
 - Source: if the selection contains a factual claim, number, comparison, conclusion, or recommendation, judge source credibility. Use not_needed for structural, transitional, or purely explanatory content that does not need evidence. Include source trace, warnings, gaps, and caveats here.
 
 Boundaries:
 - Do not hunt for problems. If it works, say it works.
-- Do not recommend edits or fixes; this inspector view only explains purpose and source credibility.
+- Do not recommend edits or fixes; this inspector view only explains narrative context, bounded exploratory reading context, purpose, and source credibility.
 - Do not turn every caveat into a problem.
 - If confidence is low, use unclear or unknown instead of pretending certainty.
 
@@ -30,3 +38,8 @@ Projection JSON:
 ${JSON.stringify(input.projection, null, 2)}
 \`\`\``
 }
+
+function normalizeInspectLanguage(language: string | undefined): string {
+  const value = typeof language === "string" ? language.trim() : ""
+  return value || "Auto"
+}

package/lib/inspect/requests.ts

@@ -1,5 +1,5 @@
 import type { InspectionPromptProjection } from "../inspection-context/project"
-import type { InspectionResult } from "../inspection-context/result"
+import { buildDeterministicInspectionResult, type InspectionResult } from "../inspection-context/result"
 
 export type InspectRequestStatus = "pending" | "completed" | "failed" | "expired"
 
@@ -53,11 +53,30 @@ export function completeInspectRequest(requestId: string, result: InspectionResu
   if (!request) throw new Error(`Unknown inspection request: ${requestId}`)
   if (request.status !== "pending") throw new Error(`Inspection request is not pending: ${request.status}`)
   request.status = "completed"
-  request.result = { ...result, requestId }
+  request.result = normalizeInspectionResult(request.projection, result, requestId)
   request.updatedAt = Date.now()
   return request
 }
 
+function normalizeInspectionResult(
+  projection: InspectionPromptProjection,
+  result: InspectionResult,
+  requestId: string,
+): InspectionResult {
+  const deterministic = buildDeterministicInspectionResult(projection, { requestId })
+  return {
+    ...result,
+    requestId,
+    cards: {
+      reading: result.cards.reading ?? deterministic.cards.reading,
+      exploratory: result.cards.exploratory ?? deterministic.cards.exploratory,
+      purpose: result.cards.purpose,
+      source: result.cards.source,
+    },
+    stale: result.stale ?? deterministic.stale,
+  }
+}
+
 export function failInspectRequest(requestId: string, error: string): PendingInspectRequest | undefined {
   const request = getInspectRequest(requestId)
   if (!request || request.status !== "pending") return request

package/lib/inspection-context/compile.ts

@@ -1,4 +1,5 @@
 import type { DeckSpec, DecksState, EvidenceRef, NarrativeBrief, NarrativeRole, SlideSpec, SourceMaterial } from "../decks-state"
+import { getArtifactClaimRefs, type ArtifactClaimRef, type ClaimSlideRef } from "../narrative-state/queries"
 import type { NarrativeClaim, NarrativeEvidenceBinding, NarrativeStateV1 } from "../narrative-state/types"
 
 export type InspectionClaimOrigin = "narrative" | "title" | "headline" | "body" | "bullet" | "purpose"
@@ -20,6 +21,7 @@ export interface InspectionContext {
   appendixCandidates: InspectionAppendixCandidate[]
   objectionContext: InspectionNarrativeContext[]
   riskContext: InspectionNarrativeContext[]
+  artifactCoverage: InspectionArtifactCoverage[]
 }
 
 export interface InspectionNarrativeStateContext {
@@ -98,11 +100,35 @@ export interface InspectionAppendixCandidate {
 
 export interface InspectionNarrativeContext {
   text: string
-  source: "narrativeBrief" | "slide"
+  source: "narrative" | "narrativeBrief" | "slide"
   slideIndex?: number
   slideTitle?: string
 }
 
+export interface InspectionArtifactCoverage {
+  artifactId: string
+  type: ArtifactClaimRef["type"]
+  outputPath?: string
+  coverageStatus: ArtifactClaimRef["coverageStatus"]
+  claimIds: string[]
+  affectedClaimIds: string[]
+  missingClaimIds: string[]
+  stale: boolean
+  staleReason?: string
+  staleReasons: string[]
+  note?: string
+  slideRefs: InspectionArtifactSlideRef[]
+}
+
+export interface InspectionArtifactSlideRef {
+  claimId: string
+  slideIndex: number
+  slideTitle: string
+  role: ClaimSlideRef["role"]
+  match: ClaimSlideRef["match"]
+  location: string
+}
+
 export function compileInspectionContext(state: DecksState, slug?: string): InspectionContext {
   const deck = activeDeck(state, slug)
   const narrative = state.narrative
@@ -127,11 +153,36 @@ export function compileInspectionContext(state: DecksState, slug?: string): Insp
     slides,
     gaps,
     appendixCandidates: compileAppendixCandidates(slides),
-    objectionContext: compileNarrativeList(deck, "objections"),
-    riskContext: compileNarrativeList(deck, "risks"),
+    objectionContext: compileNarrativeList(deck, "objections", narrative),
+    riskContext: compileNarrativeList(deck, "risks", narrative),
+    artifactCoverage: compileArtifactCoverage(state),
   }
 }
 
+function compileArtifactCoverage(state: DecksState): InspectionArtifactCoverage[] {
+  return getArtifactClaimRefs(state).map((artifact) => ({
+    artifactId: artifact.artifactId,
+    type: artifact.type,
+    outputPath: artifact.outputPath,
+    coverageStatus: artifact.coverageStatus,
+    claimIds: artifact.claimIds,
+    affectedClaimIds: artifact.affectedClaimIds,
+    missingClaimIds: artifact.missingClaimIds,
+    stale: artifact.stale,
+    staleReason: artifact.staleReason,
+    staleReasons: artifact.staleReasons,
+    note: artifact.note,
+    slideRefs: artifact.slideRefs.map((ref) => ({
+      claimId: ref.claimId,
+      slideIndex: ref.slideIndex,
+      slideTitle: ref.slideTitle,
+      role: ref.role,
+      match: ref.match,
+      location: ref.location,
+    })),
+  }))
+}
+
 function activeDeck(state: DecksState, slug?: string): DeckSpec {
   const key = slug || state.activeDeck || (Object.keys(state.decks).length === 1 ? Object.keys(state.decks)[0] : undefined)
   if (!key || !state.decks[key]) throw new Error("No active deck is available for inspection context compilation.")
@@ -389,7 +440,10 @@ function appendixReason(slide: InspectionSlideContext): string {
   return "Slide has recorded evidence that may be useful for source excerpts or backup detail."
 }
 
-function compileNarrativeList(deck: DeckSpec, key: "objections" | "risks"): InspectionNarrativeContext[] {
+function compileNarrativeList(deck: DeckSpec, key: "objections" | "risks", narrative: NarrativeStateV1 | undefined): InspectionNarrativeContext[] {
+  const fromNarrative = key === "objections"
+    ? (narrative?.objections ?? []).map((item) => ({ text: item.text, source: "narrative" as const }))
+    : (narrative?.risks ?? []).map((item) => ({ text: item.text, source: "narrative" as const }))
   const fromBrief = (deck.narrativeBrief?.[key] ?? []).map((text) => ({ text, source: "narrativeBrief" as const }))
   const role = key === "risks" ? "risk" : undefined
   const fromSlides = deck.slides
@@ -400,7 +454,19 @@ function compileNarrativeList(deck: DeckSpec, key: "objections" | "risks"): Insp
       slideIndex: slide.index,
       slideTitle: slide.title,
     })))
-  return [...fromBrief, ...fromSlides]
+  return dedupeNarrativeContext([...fromNarrative, ...fromBrief, ...fromSlides])
+}
+
+function dedupeNarrativeContext(values: InspectionNarrativeContext[]): InspectionNarrativeContext[] {
+  const seen = new Set<string>()
+  const result: InspectionNarrativeContext[] = []
+  for (const value of values) {
+    const key = `${normalizeText(value.text)}:${value.slideIndex ?? "global"}`
+    if (seen.has(key)) continue
+    seen.add(key)
+    result.push(value)
+  }
+  return result
 }
 
 function slideTextList(slide: SlideSpec): string[] {

package/lib/inspection-context/match.ts

@@ -45,6 +45,7 @@ export interface InspectionElementSnapshot {
 export interface InspectionElementMatch {
   slide?: InspectionSlideContext
   claim?: InspectionClaimCandidate
+  candidateClaims?: InspectionClaimCandidate[]
   evidence: InspectionEvidenceTrace[]
   gaps: InspectionGap[]
   caveats: string[]
@@ -55,8 +56,12 @@ export interface InspectionElementMatch {
 
 export function matchInspectionElement(context: InspectionContext, snapshot: InspectionElementSnapshot): InspectionElementMatch {
   const selectedText = normalizeText(snapshot.text)
+  const surroundingText = normalizeText(snapshot.nearbyText || snapshot.outerHTMLExcerpt)
   const candidateSlides = candidateSlidesForSnapshot(context, snapshot)
 
+  const anchoredClaim = findAnchoredClaimMatch(candidateSlides, snapshot)
+  if (anchoredClaim) return claimMatch(context, anchoredClaim.slide, anchoredClaim.claim, "high", "Matched explicit claim anchor from selection snapshot.")
+
   if (selectedText) {
     const exactClaim = findClaimMatch(candidateSlides, selectedText, "exact")
     if (exactClaim) return claimMatch(context, exactClaim.slide, exactClaim.claim, "high", "Exact normalized text match.")
@@ -77,8 +82,27 @@ export function matchInspectionElement(context: InspectionContext, snapshot: Ins
     }
   }
 
+  if (surroundingText && surroundingText !== selectedText) {
+    const contextualClaim = findClaimMatch(candidateSlides, surroundingText, "contains")
+    if (contextualClaim) return claimMatch(context, contextualClaim.slide, contextualClaim.claim, "medium", "Matched claim using surrounding slide context.")
+  }
+
   const slide = candidateSlides[0]
-  if (slide) return slideMatch(context, slide, snapshot.slideIndex ? "medium" : "low", snapshot.slideIndex ? "Matched by slideIndex only." : "No claim text matched; returning first candidate slide.")
+  if (slide) {
+    const canonicalClaims = slide.claims.filter((claim) => claim.canonicalClaimId || claim.origin === "narrative")
+    if (canonicalClaims.length === 1) {
+      return claimMatch(context, slide, canonicalClaims[0], "medium", "Selected element matched the slide; the slide has one canonical narrative claim candidate.", canonicalClaims)
+    }
+    return slideMatch(
+      context,
+      slide,
+      snapshot.slideIndex ? "medium" : "low",
+      canonicalClaims.length > 1
+        ? "Matched slide only; multiple canonical claim candidates are available, so no claim id was chosen by semantic guess."
+        : snapshot.slideIndex ? "Matched by slideIndex only." : "No claim text matched; returning first candidate slide.",
+      canonicalClaims,
+    )
+  }
 
   return {
     evidence: [],
@@ -114,6 +138,37 @@ function findClaimMatch(
   return undefined
 }
 
+function findAnchoredClaimMatch(
+  slides: InspectionSlideContext[],
+  snapshot: InspectionElementSnapshot,
+): { slide: InspectionSlideContext; claim: InspectionClaimCandidate } | undefined {
+  const claimIds = explicitClaimIds(snapshot)
+  if (claimIds.length === 0) return undefined
+  for (const slide of slides) {
+    for (const claim of slide.claims) {
+      const ids = [claim.id, claim.canonicalClaimId].filter((item): item is string => Boolean(item))
+      if (ids.some((id) => claimIds.includes(id))) return { slide, claim }
+    }
+  }
+  return undefined
+}
+
+function explicitClaimIds(snapshot: InspectionElementSnapshot): string[] {
+  const values = [
+    snapshot.selector,
+    snapshot.domPath,
+    snapshot.outerHTMLExcerpt,
+    ...(snapshot.elements ?? []).flatMap((item) => [item.selector, item.domPath, item.outerHTMLExcerpt]),
+  ]
+  const ids: string[] = []
+  for (const value of values) {
+    if (!value) continue
+    for (const match of value.matchAll(/data-claim-id\s*=\s*["']([^"']+)["']/gi)) ids.push(match[1])
+    for (const match of value.matchAll(/data-claim-id=([^\]\s>"']+)/gi)) ids.push(match[1])
+  }
+  return dedupe(ids.map((item) => item.trim()).filter(Boolean))
+}
+
 function conservativeContains(claimText: string, selectedText: string): boolean {
   if (selectedText.length < 12 && claimText.length < 12) return false
   return claimText.includes(selectedText) || selectedText.includes(claimText)
@@ -125,10 +180,12 @@ function claimMatch(
   claim: InspectionClaimCandidate,
   confidence: InspectionMatchConfidence,
   reason: string,
+  candidateClaims: InspectionClaimCandidate[] = [],
 ): InspectionElementMatch {
   return {
     slide,
     claim,
+    candidateClaims: candidateClaims.length ? candidateClaims : [claim],
     evidence: claim.evidence,
     gaps: claim.gaps,
     caveats: slide.caveats,
@@ -143,9 +200,11 @@ function slideMatch(
   slide: InspectionSlideContext,
   confidence: InspectionMatchConfidence,
   reason: string,
+  candidateClaims: InspectionClaimCandidate[] = [],
 ): InspectionElementMatch {
   return {
     slide,
+    candidateClaims,
     evidence: slide.evidence,
     gaps: slide.claims.flatMap((claim) => claim.gaps),
     caveats: slide.caveats,
@@ -167,3 +226,14 @@ function normalizeText(text: string | undefined): string {
     .trim()
     .toLowerCase()
 }
+
+function dedupe(values: string[]): string[] {
+  const seen = new Set<string>()
+  const result: string[] = []
+  for (const value of values) {
+    if (seen.has(value)) continue
+    seen.add(value)
+    result.push(value)
+  }
+  return result
+}

package/lib/inspection-context/project.ts

@@ -1,5 +1,5 @@
 import type { NarrativeBrief, NarrativeRole } from "../decks-state"
-import type { InspectionContext, InspectionEvidenceTrace, InspectionGap } from "./compile"
+import type { InspectionClaimCandidate, InspectionContext, InspectionEvidenceTrace, InspectionGap } from "./compile"
 import type { InspectionElementMatch, InspectionElementSnapshot, InspectionMatchConfidence } from "./match"
 
 export interface InspectionPromptProjection {
@@ -13,6 +13,7 @@ export interface InspectionPromptProjection {
     caveats: InspectionCaveatsProjection
     objective: InspectionObjectiveProjection
     appendix: InspectionAppendixProjection
+    artifacts: InspectionArtifactCoverageProjection
   }
 }
 
@@ -28,11 +29,15 @@ export interface InspectionProjectionElement {
   scope?: "element" | "selection" | "slide"
   slideIndex?: number
   text?: string
+  nearbyText?: string
+  outerHTMLExcerpt?: string
   elements?: Array<{
     text?: string
     tagName?: string
     classList: string[]
     role?: string
+    nearbyText?: string
+    outerHTMLExcerpt?: string
   }>
   tagName?: string
   classList: string[]
@@ -60,6 +65,20 @@ export interface InspectionProjectionMatch {
     unsupportedScope?: string
     caveats: string[]
   }
+  candidateClaims?: InspectionProjectionClaimCandidate[]
+}
+
+export interface InspectionProjectionClaimCandidate {
+  id: string
+  canonicalClaimId?: string
+  origin: string
+  text: string
+  evidenceSensitive: boolean
+  evidenceSupport: string
+  evidenceBindingIds: string[]
+  supportedScope?: string
+  unsupportedScope?: string
+  caveats: string[]
 }
 
 export interface InspectionSourceProjection {
@@ -100,6 +119,32 @@ export interface InspectionAppendixProjection {
   relatedObjections: string[]
 }
 
+export interface InspectionArtifactCoverageProjection {
+  selectedClaimId?: string
+  artifacts: InspectionArtifactCoverageProjectionItem[]
+}
+
+export interface InspectionArtifactCoverageProjectionItem {
+  artifactId: string
+  type: string
+  outputPath?: string
+  coverageStatus: "current" | "stale" | "partial" | "missing"
+  containsClaim: boolean
+  stale: boolean
+  staleReason?: string
+  staleReasons: string[]
+  affectedClaimIds: string[]
+  missingClaimIds: string[]
+  note?: string
+  locations: Array<{
+    slideIndex: number
+    slideTitle: string
+    role: string
+    match: string
+    location: string
+  }>
+}
+
 export interface InspectionEvidenceProjectionTrace {
   source: string
   evidenceBindingId?: string
@@ -132,6 +177,7 @@ export function projectInspectionMatch(
 ): InspectionPromptProjection {
   const slide = match.slide
   const claim = match.claim
+  const candidateClaims = dedupeClaims(match.candidateClaims ?? [])
   const traces = match.evidence.map(projectEvidenceTrace)
   const gaps = match.gaps.map(projectGap)
   const narrativeBrief = context.narrativeBrief
@@ -149,11 +195,15 @@ export function projectInspectionMatch(
       slideIndex: snapshot.slideIndex,
       scope: snapshot.scope,
       text: truncateOptional(snapshot.selectedText || snapshot.text, 700),
+      nearbyText: truncateOptional(snapshot.nearbyText, 900),
+      outerHTMLExcerpt: truncateOptional(snapshot.outerHTMLExcerpt, 900),
       elements: snapshot.elements?.slice(0, 12).map((item) => ({
         text: truncateOptional(item.text, 320),
         tagName: truncateOptional(item.tagName, 40),
         classList: (item.classList ?? []).slice(0, 8).map((className) => truncate(className, 80)),
         role: truncateOptional(item.role, 80),
+        nearbyText: truncateOptional(item.nearbyText, 420),
+        outerHTMLExcerpt: truncateOptional(item.outerHTMLExcerpt, 420),
       })),
       tagName: truncateOptional(snapshot.tagName, 40),
       classList: (snapshot.classList ?? []).slice(0, 12).map((item) => truncate(item, 80)),
@@ -171,19 +221,9 @@ export function projectInspectionMatch(
           }
         : undefined,
       claim: claim
-        ? {
-            id: claim.id,
-            canonicalClaimId: claim.canonicalClaimId,
-            origin: claim.origin,
-            text: truncate(claim.text, 500),
-            evidenceSensitive: claim.evidenceSensitive,
-            evidenceSupport: claim.evidenceSupport,
-            evidenceBindingIds: claim.evidenceBindingIds,
-            supportedScope: truncateOptional(claim.supportedScope, 280),
-            unsupportedScope: truncateOptional(claim.unsupportedScope, 280),
-            caveats: claim.caveats.map((item) => truncate(item, 280)).slice(0, 8),
-          }
+        ? projectClaimCandidate(claim)
         : undefined,
+      candidateClaims: candidateClaims.map(projectClaimCandidate).slice(0, 8),
     },
     cards: {
       source: {
@@ -219,10 +259,73 @@ export function projectInspectionMatch(
         relatedRisks: relatedNarrativeText(context.riskContext, slide?.index),
         relatedObjections: relatedNarrativeText(context.objectionContext, slide?.index),
       },
+      artifacts: projectArtifactCoverage(context, claim?.canonicalClaimId ?? claim?.id),
     },
   }
 }
 
+function projectClaimCandidate(claim: InspectionClaimCandidate): InspectionProjectionClaimCandidate {
+  return {
+    id: claim.id,
+    canonicalClaimId: claim.canonicalClaimId,
+    origin: claim.origin,
+    text: truncate(claim.text, 500),
+    evidenceSensitive: claim.evidenceSensitive,
+    evidenceSupport: claim.evidenceSupport,
+    evidenceBindingIds: claim.evidenceBindingIds,
+    supportedScope: truncateOptional(claim.supportedScope, 280),
+    unsupportedScope: truncateOptional(claim.unsupportedScope, 280),
+    caveats: claim.caveats.map((item) => truncate(item, 280)).slice(0, 8),
+  }
+}
+
+function dedupeClaims(claims: InspectionClaimCandidate[]): InspectionClaimCandidate[] {
+  const seen = new Set<string>()
+  const result: InspectionClaimCandidate[] = []
+  for (const claim of claims) {
+    const key = claim.canonicalClaimId || claim.id
+    if (seen.has(key)) continue
+    seen.add(key)
+    result.push(claim)
+  }
+  return result
+}
+
+function projectArtifactCoverage(context: InspectionContext, selectedClaimId: string | undefined): InspectionArtifactCoverageProjection {
+  return {
+    selectedClaimId,
+    artifacts: context.artifactCoverage.map((artifact) => {
+      const locations = selectedClaimId
+        ? artifact.slideRefs
+          .filter((ref) => ref.claimId === selectedClaimId)
+          .slice(0, 8)
+          .map((ref) => ({
+            slideIndex: ref.slideIndex,
+            slideTitle: truncate(ref.slideTitle, 180),
+            role: ref.role,
+            match: ref.match,
+            location: truncate(ref.location, 120),
+          }))
+        : []
+      const containsClaim = Boolean(selectedClaimId && (artifact.claimIds.includes(selectedClaimId) || locations.length > 0))
+      return {
+        artifactId: truncate(artifact.artifactId, 180),
+        type: artifact.type,
+        outputPath: truncateOptional(artifact.outputPath, 220),
+        coverageStatus: artifact.coverageStatus,
+        containsClaim,
+        stale: artifact.stale,
+        staleReason: truncateOptional(artifact.staleReason, 240),
+        staleReasons: artifact.staleReasons.map((item) => truncate(item, 240)).slice(0, 5),
+        affectedClaimIds: artifact.affectedClaimIds.map((item) => truncate(item, 160)).slice(0, 8),
+        missingClaimIds: artifact.missingClaimIds.map((item) => truncate(item, 160)).slice(0, 8),
+        note: truncateOptional(artifact.note, 240),
+        locations,
+      }
+    }).slice(0, 8),
+  }
+}
+
 function projectEvidenceTrace(trace: InspectionEvidenceTrace): InspectionEvidenceProjectionTrace {
   return {
     source: truncate(trace.source, 180),