@cyber-dash-tech/revela 0.13.0 → 0.15.0

package/lib/inspection-context/result.ts

@@ -4,6 +4,8 @@ import type { InspectionPromptProjection } from "./project"
 export type InspectionResultStatus = "success" | "no_match"
 export type InspectionPurposeStatus = "clear" | "weak" | "misplaced" | "unknown"
 export type InspectionSourceStatus = "supported" | "weak" | "unsupported" | "not_needed" | "unknown"
+export type NarrativeReadingStatus = "matched" | "no_match"
+export type ExploratoryReadingStatus = "available" | "limited" | "unavailable"
 
 export interface InspectionResult {
   version: 1
@@ -16,6 +18,8 @@ export interface InspectionResult {
   }
   matchConfidence: InspectionMatchConfidence
   cards: {
+    reading?: NarrativeReadingCard
+    exploratory?: ExploratoryReadingCard
     purpose: PurposeCard
     source: SourceCard
   }
@@ -53,6 +57,47 @@ export interface SourceCard {
   rationale: string
 }
 
+export interface NarrativeReadingCard {
+  status: NarrativeReadingStatus
+  claimId?: string
+  canonicalClaimId?: string
+  claimText?: string
+  evidenceStatus?: string
+  evidenceBindingIds: string[]
+  supportedScope?: string
+  unsupportedScope?: string
+  caveats: string[]
+  relatedObjections: string[]
+  relatedRisks: string[]
+  artifactCoverage: NarrativeReadingArtifactCoverage[]
+  rationale: string
+}
+
+export interface NarrativeReadingArtifactCoverage {
+  artifactId: string
+  type: string
+  outputPath?: string
+  coverageStatus: "current" | "stale" | "partial" | "missing"
+  containsClaim: boolean
+  stale: boolean
+  staleReason?: string
+  locations: string[]
+  note?: string
+}
+
+export interface ExploratoryReadingCard {
+  status: ExploratoryReadingStatus
+  official: false
+  audience?: string
+  claimFocus?: string
+  objectionPrompts: string[]
+  audienceReframe: string
+  appendixLeads: string[]
+  meetingPrep: string[]
+  boundaries: string[]
+  rationale: string
+}
+
 export function buildDeterministicInspectionResult(
   projection: InspectionPromptProjection,
   options: { requestId?: string; staleReason?: string } = {},
@@ -72,6 +117,8 @@ export function buildDeterministicInspectionResult(
     slide: slide ? { index: slide.index, title: slide.title } : undefined,
     matchConfidence: projection.match.confidence,
     cards: {
+      reading: narrativeReadingCard(projection, noMatch),
+      exploratory: exploratoryReadingCard(projection, noMatch),
       purpose: {
         status: purposeStatus(projection, noMatch),
         role: projection.cards.objective.narrativeRole,
@@ -101,6 +148,126 @@ export function buildDeterministicInspectionResult(
   }
 }
 
+function exploratoryReadingCard(projection: InspectionPromptProjection, noMatch: boolean): ExploratoryReadingCard {
+  const claimText = projection.match.claim?.text ?? projection.cards.evidence.matchedClaim
+  const caveats = projection.cards.caveats.caveats
+  const unsupportedScope = projection.match.claim?.unsupportedScope ?? firstPresent(projection.cards.evidence.traces.map((item) => item.unsupportedScope))
+  const objectionPrompts = exploratoryObjections(projection, unsupportedScope)
+  const appendixLeads = exploratoryAppendixLeads(projection)
+  const meetingPrep = exploratoryMeetingPrep(projection, unsupportedScope)
+  return {
+    status: noMatch ? "unavailable" : claimText ? "available" : "limited",
+    official: false,
+    audience: projection.cards.objective.audience,
+    claimFocus: claimText,
+    objectionPrompts,
+    audienceReframe: exploratoryAudienceFrame(projection, claimText),
+    appendixLeads,
+    meetingPrep,
+    boundaries: exploratoryBoundaries(projection, noMatch),
+    rationale: exploratoryRationale(projection, noMatch, objectionPrompts.length + appendixLeads.length + meetingPrep.length),
+  }
+}
+
+function exploratoryObjections(projection: InspectionPromptProjection, unsupportedScope: string | undefined): string[] {
+  const items = projection.cards.appendix.relatedObjections.map((item) => `Prepare for this objection using recorded support only: ${item}`)
+  if (unsupportedScope) items.push(`Expect questions about unsupported scope: ${unsupportedScope}`)
+  for (const gap of projection.cards.evidence.gaps) items.push(`Treat this as an evidence gap, not as support: ${gap.message}`)
+  return dedupe(items).slice(0, 4)
+}
+
+function exploratoryAudienceFrame(projection: InspectionPromptProjection, claimText: string | undefined): string {
+  const audience = projection.cards.objective.audience
+  const beliefAfter = projection.cards.objective.audienceBeliefAfter
+  const decision = projection.cards.objective.decisionOrAction
+  if (!claimText) return "No specific claim is matched, so audience reframing is limited to the selected slide context."
+  if (audience && beliefAfter) return `For ${audience}, frame this claim as support for the desired belief: ${beliefAfter}`
+  if (audience && decision) return `For ${audience}, connect this claim to the recorded decision or action: ${decision}`
+  if (audience) return `For ${audience}, keep the wording inside the recorded claim boundary: ${claimText}`
+  return "Audience-specific reframing is limited because no audience is recorded in the projection."
+}
+
+function exploratoryAppendixLeads(projection: InspectionPromptProjection): string[] {
+  const sourceLeads = projection.cards.evidence.traces.map((trace) => {
+    const where = trace.location || trace.page || trace.url || trace.sourcePath || trace.findingsFile
+    return where ? `${trace.source}: ${where}` : trace.source
+  })
+  const appendixCandidates = projection.cards.appendix.candidates.map((candidate) => `Slide ${candidate.slideIndex}: ${candidate.slideTitle} (${candidate.reason})`)
+  return dedupe([...sourceLeads, ...appendixCandidates]).slice(0, 5)
+}
+
+function exploratoryMeetingPrep(projection: InspectionPromptProjection, unsupportedScope: string | undefined): string[] {
+  const items: string[] = []
+  for (const risk of projection.cards.appendix.relatedRisks) items.push(`Risk to be ready for: ${risk}`)
+  for (const caveat of projection.cards.caveats.caveats) items.push(`Caveat to say plainly: ${caveat}`)
+  if (unsupportedScope) items.push(`Do not overstate beyond: ${unsupportedScope}`)
+  for (const warning of projection.cards.source.weakSourceGaps) items.push(`Source trace is weak: ${warning.message}`)
+  for (const gap of projection.cards.source.missingSourceGaps) items.push(`Missing support: ${gap.message}`)
+  return dedupe(items).slice(0, 5)
+}
+
+function exploratoryBoundaries(projection: InspectionPromptProjection, noMatch: boolean): string[] {
+  const boundaries = [
+    "Exploratory reading is non-official and does not change canonical narrative state or artifact content.",
+    "Use only recorded claims, evidence, caveats, risks, objections, and artifact coverage from this inspection projection.",
+  ]
+  if (noMatch) boundaries.push("No matched slide or claim is available, so exploratory reading cannot infer support.")
+  if (projection.cards.evidence.gaps.length > 0) boundaries.push("Evidence gaps must remain visible and cannot be filled by generated reading text.")
+  return boundaries
+}
+
+function exploratoryRationale(projection: InspectionPromptProjection, noMatch: boolean, signalCount: number): string {
+  if (noMatch) return "Exploratory reading is unavailable because the selection did not match a slide or claim."
+  if (signalCount > 0) return "This bounded reading layer derives objection, audience, appendix, and meeting-prep cues from recorded inspection context only."
+  if (projection.match.claim) return "A matched claim exists, but little supporting exploratory context is recorded beyond the claim itself."
+  return "Exploratory reading is limited because the selection maps to slide context but not to a specific claim."
+}
+
+function narrativeReadingCard(projection: InspectionPromptProjection, noMatch: boolean): NarrativeReadingCard {
+  const claim = projection.match.claim
+  const evidenceBindingIds = dedupe([
+    ...(claim?.evidenceBindingIds ?? []),
+    ...projection.cards.evidence.traces.map((item) => item.evidenceBindingId).filter((item): item is string => Boolean(item)),
+  ])
+  return {
+    status: noMatch ? "no_match" : "matched",
+    claimId: claim?.id,
+    canonicalClaimId: claim?.canonicalClaimId,
+    claimText: claim?.text ?? projection.cards.evidence.matchedClaim,
+    evidenceStatus: claim?.evidenceSupport ?? projection.cards.evidence.evidenceSupport,
+    evidenceBindingIds,
+    supportedScope: claim?.supportedScope ?? firstPresent(projection.cards.evidence.traces.map((item) => item.supportScope)),
+    unsupportedScope: claim?.unsupportedScope ?? firstPresent(projection.cards.evidence.traces.map((item) => item.unsupportedScope)),
+    caveats: projection.cards.caveats.caveats,
+    relatedObjections: projection.cards.appendix.relatedObjections,
+    relatedRisks: projection.cards.appendix.relatedRisks,
+    artifactCoverage: artifactCoverage(projection),
+    rationale: narrativeReadingRationale(projection, noMatch),
+  }
+}
+
+function artifactCoverage(projection: InspectionPromptProjection): NarrativeReadingArtifactCoverage[] {
+  return projection.cards.artifacts.artifacts.map((artifact) => ({
+    artifactId: artifact.artifactId,
+    type: artifact.type,
+    outputPath: artifact.outputPath,
+    coverageStatus: artifact.coverageStatus,
+    containsClaim: artifact.containsClaim,
+    stale: artifact.stale,
+    staleReason: artifact.staleReason,
+    locations: artifact.locations.map((location) => `Slide ${location.slideIndex}: ${location.slideTitle} (${location.role}, ${location.match}:${location.location})`),
+    note: artifact.note ?? artifact.staleReasons[0],
+  }))
+}
+
+function narrativeReadingRationale(projection: InspectionPromptProjection, noMatch: boolean): string {
+  if (noMatch) return "No matched slide or claim is available for narrative reading."
+  const claim = projection.match.claim
+  if (claim?.canonicalClaimId) return "The selection resolves to a canonical narrative claim, so Refine can show claim, evidence-boundary, caveat, objection, and risk context before any generated judgment."
+  if (claim) return "The selection resolves to a slide claim candidate. Canonical narrative linkage is not recorded for this element, so reading context falls back to slide claim and source trace."
+  return "The selection resolves to a slide but not a specific claim; narrative reading is limited to slide purpose, role, and surrounding evidence context."
+}
+
 function purposeStatus(projection: InspectionPromptProjection, noMatch: boolean): InspectionPurposeStatus {
   if (noMatch) return "unknown"
   if (projection.cards.objective.narrativeRole || projection.cards.objective.slidePurpose) return "clear"
@@ -158,3 +325,19 @@ function sourceCaveats(projection: InspectionPromptProjection): string[] {
     ...projection.cards.appendix.relatedObjections,
   ].slice(0, 10)
 }
+
+function firstPresent(values: Array<string | undefined>): string | undefined {
+  return values.find((value) => Boolean(value?.trim()))
+}
+
+function dedupe(values: string[]): string[] {
+  const seen = new Set<string>()
+  const result: string[] = []
+  for (const value of values) {
+    const key = value.trim()
+    if (!key || seen.has(key)) continue
+    seen.add(key)
+    result.push(key)
+  }
+  return result
+}

package/lib/narrative-state/queries.ts

@@ -352,6 +352,7 @@ function pushSlideRef(refs: ClaimSlideRef[], seen: Set<string>, claim: Narrative
 function claimSlideRefsForTarget(target: RenderTarget, currentHtmlRefs: ClaimSlideRef[], htmlCoverageByPath: Map<string, ClaimSlideRef[]>): ClaimSlideRef[] {
   const stored = parseStoredClaimSlideRefs(target)
   if (stored.length > 0) return stored
+  if (target.type === "brief" || target.type === "executive_brief") return []
   if (target.type === "html_deck") return currentHtmlRefs
   const sourceOutputPath = typeof target.data?.sourceOutputPath === "string" ? target.data.sourceOutputPath : undefined
   if (sourceOutputPath) return htmlCoverageByPath.get(sourceOutputPath) ?? currentHtmlRefs

package/lib/refine/server.ts

@@ -459,6 +459,7 @@ async function handleInspect(req: Request, session: EditSession): Promise<Respon
   }
 
   const snapshot = normalizeSnapshot(body?.snapshot ?? body)
+  const language = normalizeInspectLanguage(body?.language)
   const requestId = typeof body?.requestId === "string" && body.requestId.trim() ? body.requestId.trim() : randomBytes(10).toString("base64url")
   const version = readDeckVersion(session).version
   const staleReason = typeof body?.deckVersion === "string" && body.deckVersion !== version
@@ -480,6 +481,7 @@ async function handleInspect(req: Request, session: EditSession): Promise<Respon
           text: buildInspectionPrompt({
             requestId,
             file: session.file,
+            language,
             projection: staleReason
               ? { ...projection, stale: { stale: true, reason: staleReason } } as any
               : projection,
@@ -491,7 +493,7 @@ async function handleInspect(req: Request, session: EditSession): Promise<Respon
       failInspectRequest(requestId, message)
     })
 
-    return jsonResponse({ ok: true, requestId, deckVersion: version, status: "pending", preprocess })
+    return jsonResponse({ ok: true, requestId, deckVersion: version, status: "pending", language, preprocess })
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error)
     failInspectRequest(requestId, message)
@@ -510,6 +512,11 @@ function handleInspectResult(requestId: string | null, session: EditSession): Re
   return jsonResponse({ ok: true, requestId, status: request.status, deckVersion: request.deckVersion })
 }
 
+function normalizeInspectLanguage(input: unknown): string {
+  const value = typeof input === "string" ? input.trim() : ""
+  return value || "Auto"
+}
+
 function normalizeSnapshot(input: any): InspectionElementSnapshot {
   return {
     scope: input?.scope === "selection" || input?.scope === "slide" || input?.scope === "element" ? input.scope : undefined,
@@ -657,6 +664,9 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
     .comment-bubble.stale .comment-bubble-state { color: #a16207; }
     .comment-bubble.failed .comment-bubble-state { color: #b91c1c; }
     .inspect-actions { display: flex; flex-direction: column; gap: 8px; }
+    .inspect-options { display: flex; flex-direction: column; gap: 5px; }
+    .inspect-options label { color: #64748b; font-size: 11px; font-weight: 800; text-transform: uppercase; letter-spacing: .05em; }
+    .inspect-select { width: 100%; padding: 10px 11px; border: 1px solid #d7e0ea; border-radius: 12px; background: #fff; color: #0f172a; font-weight: 700; }
     .inspect-cards { display: flex; flex-direction: column; gap: 12px; }
     .inspect-card { border: 1px solid #d7e0ea; border-radius: 16px; background: #fff; padding: 13px; box-shadow: 0 10px 24px rgba(15,23,42,.05); }
     .inspect-card-head { display: flex; align-items: center; justify-content: space-between; gap: 8px; margin-bottom: 8px; }
@@ -681,7 +691,7 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
     <aside>
       <div>
         <h1><span class="wordmark">REVELA</span> Refine</h1>
-        <p class="hint">Cmd/Ctrl-click slide elements once, then use Edit for fast changes or Inspect for Source/Purpose review.</p>
+        <p class="hint">Cmd/Ctrl-click slide elements once, then use Edit for fast changes or Inspect for Narrative Reading, Exploratory Reading, Source, and Purpose review.</p>
       </div>
       <div id="selectionSummary" class="selection-summary"><strong>Selection</strong><span>No references selected.</span><div id="selectionChips" class="selection-chips"></div></div>
       <div class="tabs" role="tablist" aria-label="Refine mode">
@@ -698,10 +708,11 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
       </div>
       <div id="inspectPanel" class="tab-panel">
         <div class="inspect-actions">
+          <div class="inspect-options"><label for="inspectLanguage">Display Language</label><select id="inspectLanguage" class="inspect-select"><option>Auto</option><option>English</option><option>简体中文</option><option>繁體中文</option><option>日本語</option><option>Deutsch</option><option>Français</option><option>Español</option><option>Português</option><option>Arabic</option></select></div>
           <button id="inspectButton" disabled>Inspect Selection</button>
           <div id="inspectStale"></div>
         </div>
-        <div id="inspectCards" class="inspect-cards"><div class="inspect-empty">Select one or more deck elements, then inspect them for Source and Purpose. This does not edit the deck.</div></div>
+        <div id="inspectCards" class="inspect-cards"><div class="inspect-empty">Select one or more deck elements, then inspect them for Narrative Reading, Exploratory Reading, Source, and Purpose. This does not edit the deck.</div></div>
       </div>
       <div id="status" class="status"></div>
     </aside>
@@ -744,6 +755,8 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
         mode: defaultMode === 'inspect' ? 'inspect' : 'edit',
         inspecting: false,
         activeInspectRequestId: '',
+        inspectLanguage: 'Auto',
+        inspectFallback: null,
       };
       const els = {
         frame: null,
@@ -759,6 +772,7 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
         commentThread: null,
         send: null,
         inspectButton: null,
+        inspectLanguage: null,
         inspectCards: null,
         inspectStale: null,
         status: null,
@@ -792,7 +806,9 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
           els.inspectStale = document.getElementById('inspectStale');
           els.status = document.getElementById('status');
 
-          if (!els.frame || !els.hitbox || !els.resizeHandle || !els.selectionSummary || !els.selectionChips || !els.editTab || !els.inspectTab || !els.editPanel || !els.inspectPanel || !els.comment || !els.commentThread || !els.send || !els.inspectButton || !els.inspectCards || !els.inspectStale || !els.status) {
+          els.inspectLanguage = document.getElementById('inspectLanguage');
+
+          if (!els.frame || !els.hitbox || !els.resizeHandle || !els.selectionSummary || !els.selectionChips || !els.editTab || !els.inspectTab || !els.editPanel || !els.inspectPanel || !els.comment || !els.commentThread || !els.send || !els.inspectButton || !els.inspectLanguage || !els.inspectCards || !els.inspectStale || !els.status) {
             throw new Error('Editor boot failed: required DOM nodes are missing.');
           }
 
@@ -840,6 +856,9 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
         els.resizeHandle.addEventListener('dblclick', resetEditorWidth);
         els.send.addEventListener('click', sendComment);
         els.inspectButton.addEventListener('click', inspectCurrentSelection);
+        els.inspectLanguage.addEventListener('change', () => {
+          state.inspectLanguage = els.inspectLanguage.value || 'Auto';
+        });
         els.editTab.addEventListener('click', () => setMode('edit'));
         els.inspectTab.addEventListener('click', () => setMode('inspect'));
       }
@@ -1075,7 +1094,7 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
         renderReferenceOutlines();
         updateSendState();
         renderSelectionSummary();
-        resetInspectCards('References ready. Open Inspect and click Inspect Selection when you want Source/Purpose review.');
+        resetInspectCards('References ready. Open Inspect and click Inspect Selection when you want Narrative Reading, Exploratory Reading, Source, and Purpose review.');
         setStatus('Inserted @' + label + '. ' + state.references.length + ' reference' + (state.references.length === 1 ? '' : 's') + ' will be sent.');
       }
 
@@ -1286,22 +1305,28 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
         updateSendState();
         setMode('inspect');
         els.inspectStale.innerHTML = '';
-        els.inspectCards.innerHTML = '<div class="inspect-loading"><b>Preparing inspection...</b><br>Deterministic Source/Purpose appears first; generated cards update lazily.</div>';
+        state.inspectFallback = null;
+        els.inspectCards.innerHTML = '<div class="inspect-loading"><b>Reading selection...</b><br>Sending grounded selection context to OpenCode. Deterministic context is kept as fallback if generation fails.</div>';
         try {
           const res = await fetch('/api/inspect?token=' + encodeURIComponent(token), {
             method: 'POST',
             headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({ snapshot, deckVersion: state.deckVersion }),
+            body: JSON.stringify({ snapshot, deckVersion: state.deckVersion, language: state.inspectLanguage }),
           });
           const body = await res.json().catch(() => ({}));
           if (!res.ok || !body.ok) throw new Error(body.error || 'Inspection failed');
           state.deckVersion = body.deckVersion || state.deckVersion;
           state.activeInspectRequestId = body.requestId;
-          if (body.preprocess) renderInspectResult(body.preprocess, 'Preprocessed');
-          els.inspectCards.insertAdjacentHTML('beforeend', '<div class="inspect-loading"><b>Generating lazy inspection...</b><br>Waiting for structured result from OpenCode.</div>');
+          state.inspectFallback = body.preprocess || null;
+          els.inspectCards.innerHTML = '<div class="inspect-loading"><b>Reading selection...</b><br>Waiting for localized structured reading cards.</div>';
           await pollInspectResult(body.requestId);
         } catch (error) {
-          resetInspectCards(error && error.message ? error.message : String(error));
+          if (state.inspectFallback) {
+            renderInspectResult(state.inspectFallback, 'Deterministic fallback');
+            els.inspectCards.insertAdjacentHTML('afterbegin', '<div class="inspect-warning">Generated inspection failed or timed out. Showing deterministic fallback context only.</div>');
+          } else {
+            resetInspectCards(error && error.message ? error.message : String(error));
+          }
         } finally {
           state.inspecting = false;
           updateSendState();
@@ -1309,7 +1334,7 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
       }
 
       async function pollInspectResult(requestId) {
-        for (;;) {
+        for (let attempt = 0; attempt < 80; attempt++) {
           await delay(900);
           const res = await fetch('/api/inspect-result?token=' + encodeURIComponent(token) + '&requestId=' + encodeURIComponent(requestId));
           const body = await res.json().catch(() => ({}));
@@ -1321,6 +1346,7 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
           }
           if (body.status === 'failed' || body.status === 'expired') throw new Error(body.error || 'Inspection failed');
         }
+        throw new Error('Inspection timed out while waiting for OpenCode result');
       }
 
       function collectReferenceSnapshot() {
@@ -1351,6 +1377,8 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
         else els.inspectStale.innerHTML = '';
         els.inspectCards.innerHTML = [
           '<div class="status">' + escapeHtml(phase || 'Inspection') + '</div>',
+          result.cards.reading ? renderInspectCard('Narrative Reading', result.cards.reading.status, result.cards.reading.rationale, renderReading(result.cards.reading)) : '',
+          result.cards.exploratory ? renderInspectCard('Exploratory Reading', result.cards.exploratory.status, result.cards.exploratory.rationale, renderExploratory(result.cards.exploratory)) : '',
           renderInspectCard('Purpose', result.cards.purpose.status, result.cards.purpose.rationale, renderPurpose(result.cards.purpose)),
           renderInspectCard('Source', result.cards.source.status, result.cards.source.rationale, renderSource(result.cards.source)),
         ].join('');
@@ -1364,6 +1392,49 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
         return '<div class="inspect-item">' + field('Role', card.role) + field('Why it matters', card.whyItMatters) + '</div>';
       }
 
+      function renderReading(card) {
+        return '<div class="inspect-item">'
+          + field('Claim ID', card.claimId)
+          + field('Canonical claim ID', card.canonicalClaimId)
+          + field('Claim', card.claimText)
+          + field('Evidence status', card.evidenceStatus)
+          + field('Evidence bindings', card.evidenceBindingIds && card.evidenceBindingIds.length ? card.evidenceBindingIds.join(', ') : '')
+          + field('Supported scope', card.supportedScope)
+          + field('Unsupported scope', card.unsupportedScope)
+          + '</div>'
+          + renderSectionList('Caveats', card.caveats)
+          + renderSectionList('Objections', card.relatedObjections)
+          + renderSectionList('Risks', card.relatedRisks)
+          + renderArtifactCoverage(card.artifactCoverage);
+      }
+
+      function renderArtifactCoverage(items) {
+        if (!items || !items.length) return '';
+        return '<div class="label">Artifact Coverage</div>' + items.map((item) => {
+          const title = (item.type || 'artifact') + (item.outputPath ? ' · ' + item.outputPath : '');
+          const status = (item.coverageStatus || 'unknown') + (item.containsClaim ? ' · contains claim' : ' · claim not rendered');
+          return '<div class="inspect-item"><b>' + escapeHtml(title) + '</b>'
+            + field('Coverage', status)
+            + field('Stale', item.stale ? (item.staleReason || 'stale') : '')
+            + field('Note', item.note)
+            + renderSectionList('Locations', item.locations)
+            + '</div>';
+        }).join('');
+      }
+
+      function renderExploratory(card) {
+        return '<div class="inspect-item"><b>Non-official reading aid</b>'
+          + field('Official artifact content', card.official === false ? 'No' : '')
+          + field('Audience', card.audience)
+          + field('Claim focus', card.claimFocus)
+          + field('Audience reframe boundary', card.audienceReframe)
+          + '</div>'
+          + renderSectionList('Objection Prep', card.objectionPrompts)
+          + renderSectionList('Appendix Leads', card.appendixLeads)
+          + renderSectionList('Meeting Prep', card.meetingPrep)
+          + renderSectionList('Boundaries', card.boundaries);
+      }
+
       function renderSource(card) {
         return renderSources(card.sources) + renderWarnings(card.warnings) + renderSectionList('Gaps', card.gaps) + renderSectionList('Caveats', card.caveats);
       }
@@ -1422,7 +1493,7 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
         state.references = [];
         if (removeChips) els.comment.querySelectorAll('.ref-chip').forEach((chip) => chip.remove());
         renderSelectionSummary();
-        resetInspectCards('Select one or more deck elements, then inspect them for Source and Purpose. This does not edit the deck.');
+        resetInspectCards('Select one or more deck elements, then inspect them for Narrative Reading, Exploratory Reading, Source, and Purpose. This does not edit the deck.');
       }
 
       function getCommentText() {
@@ -1525,10 +1596,17 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
       }
 
       function findSlide(node) {
-        return node.closest('.slide, [slide-qa], .slide-canvas, .page');
+        if (!node || !node.closest) return null;
+        return node.closest('.slide[data-slide-index]')
+          || node.closest('.slide')
+          || node.closest('[slide-qa]')
+          || node.closest('.slide-canvas')
+          || node.closest('.page');
       }
 
       function getSlides(doc) {
+        const canonicalSlides = Array.from(doc.querySelectorAll('.slide[data-slide-index]'));
+        if (canonicalSlides.length) return canonicalSlides;
         const slides = Array.from(doc.querySelectorAll('.slide'));
         if (slides.length) return slides;
         const qaSlides = Array.from(doc.querySelectorAll('[slide-qa]'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyber-dash-tech/revela",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "OpenCode plugin that turns AI into an HTML slide deck generator",
   "type": "module",
   "main": "./index.ts",