@cyber-dash-tech/revela 0.17.24 → 0.18.3

package/lib/narrative-state/render-plan.ts

@@ -93,6 +93,7 @@ export interface RenderPlanWritingBatch {
   label: string
   chapterTitle: string
   slideIndexes: number[]
+  maxSlides: number
   instructions: string
 }
 
@@ -112,6 +113,7 @@ export interface RenderPlanContract {
 
 type VisualIntentKind = "hero" | "toc" | "metric-stat" | "evidence-table" | "comparison-grid" | "risk-matrix" | "steps" | "text-only"
 type ClaimChapterSlideKind = "framing" | "evidence" | "implication"
+const MAX_HTML_SLIDES_PER_BATCH = 5
 
 interface VisualIntent {
   kind: VisualIntentKind
@@ -207,7 +209,7 @@ export function compileDeckPlanFromNarrative(state: DecksState, options: Compile
         compiled: true,
         skipped: false,
         narrativeHash,
-        planArtifactPath: "deck-plan/index.md",
+        planArtifactPath: "deck-plan.md",
         slideCount: 0,
         slides: [],
         chapters: [],
@@ -236,8 +238,8 @@ function buildDeckPlanningPacket(narrative: NarrativeStateV1, narrativeHash: str
 
 function buildDeckPlanRequirements(narrativeHash: string): DeckPlanRequirements {
   return {
-    planArtifactPath: "deck-plan/index.md",
-    slidePlanDir: "deck-plan/slides",
+    planArtifactPath: "deck-plan.md",
+    slidePlanDir: "",
     defaultProfile: "executive decision deck, usually 12-18 slides unless the user confirms otherwise",
     userConfirmations: [
       "Confirm target slide count or acceptable range when it is unclear.",
@@ -245,27 +247,27 @@ function buildDeckPlanRequirements(narrativeHash: string): DeckPlanRequirements
       "Confirm language, emphasis, or visual style only when needed before writing the plan.",
     ],
     authoringRules: [
-      "LLM writes deck-plan/index.md and deck-plan/slides/*.md from the planning packet; compileDeckPlan does not generate the final slide list.",
+      "LLM writes canonical deck-plan.md from the planning packet; compileDeckPlan does not generate the final slide list.",
       "Use 3-5 chapters for normal executive decks.",
       "Cover every central claim, but group related central claims into chapters instead of giving each claim its own chapter.",
       "Each substantive chapter should have framing, proof, and implication/boundary coverage.",
       "Chapter divider or chapter TOC slides may use the toc component as structural wayfinding.",
       "Do not create filler slides, repeated thesis pages, or generic bridge slides.",
-      "Preserve evidence ids, source trace, supported scope, unsupported scope, caveats, and strength where available.",
+      "Preserve evidence ids, source trace, source limitations, unresolved inputs, and user review notes where available.",
       "Do not render internal labels such as Evidence gap:, Unsupported scope:, Caveat:, Missing Data, or Evidence Boundary in executive body copy.",
       "Do not infer plan structure from DECKS.json slides[]; it is compatibility cache only.",
-      "Use ## Narrative Links in slide files for [[claim-id]], [[evidence-id]], [[risk-id]], [[objection-id]], or [[gap-id]] references; do not use canonical ## Relations in deck-plan files.",
+      "Use sourceLinks in slide blocks for materials, findings, assets, and URLs; do not use canonical ## Relations in deck-plan files.",
+      "Use `---` slide separators under ## Slides with slide-local metadata, followed by #### Content Plan, #### Source Links, and #### Design Plan.",
     ],
     requiredSections: [
+      "Goal",
+      "Audience",
+      "Design",
       "Source Authority",
-      "Audience / Goal / Decision",
-      "Deck Parameters",
       "Chapter Map",
-      "Slide Plan",
-      "Evidence Trace",
-      "Boundary / Risk Treatment",
-      "Chapter Writing Batches",
-      "HTML Identity Contract",
+      "Slides",
+      "Unresolved Inputs",
+      "HTML Contract",
     ],
   }
 }
@@ -274,17 +276,17 @@ export function buildRenderPlanContract(deck: DeckSpec, chapters: DeckPlanChapte
   return {
     sourceAuthority: {
       meaning: "revela-narrative/ canonical narrative state",
-      renderPlan: "deck-plan/ projection workspace plus compileDeckPlan planning packet",
+      renderPlan: "deck-plan.md plus compileDeckPlan planning packet",
       state: "DECKS.json compatibility/render state only; slides[] is cached projection data",
       htmlIdentity: "positive 1-based data-slide-index values, unique and strictly increasing in DOM order",
     },
     renderRules: [
       "Do not infer deck structure, slide count, or chapter substance from DECKS.json slides[].",
-      "Use the compileDeckPlan planning packet plus deck-plan/ projection Markdown as the render-plan contract.",
+      "Use the compileDeckPlan planning packet plus deck-plan.md as the render-plan contract.",
       "Render chapter divider slides with the toc component when slideKind is chapter-divider.",
       "Chapter divider and global TOC slides are structural wayfinding and do not count toward central-claim substance.",
       "Each central claim chapter needs non-structural framing, proof, and implication/boundary slides unless the current deck-plan projection explicitly says otherwise.",
-      "Generate HTML chapter by chapter, preserving valid HTML and already-written slides after every batch.",
+      `Generate HTML in chapter-bounded batches of at most ${MAX_HTML_SLIDES_PER_BATCH} slides, preserving valid HTML and already-written slides after every batch.`,
     ],
     htmlIdentityContract: [
       "Every written slide section uses class slide and a positive 1-based data-slide-index.",
@@ -307,18 +309,38 @@ export function buildRenderPlanContract(deck: DeckSpec, chapters: DeckPlanChapte
         allowedStructuralSlides: chapter.sourceClaimId ? ["chapter-divider", "toc"] : ["cover", "toc", "ask"],
       }
     }),
-    chapterWritingBatches: chapters.map((chapter, index) => ({
-      label: index === 0 ? "Initial shell and first chapter" : `Chapter batch ${index + 1}`,
-      chapterTitle: chapter.title,
-      slideIndexes: chapter.slideIndexes,
-      instructions: index === 0
-        ? "Create the stable HTML shell, required structural slides, and this first chapter range only."
-        : "Patch exactly this chapter range, preserve previously written slides, and keep the file valid after the patch.",
-    })),
+    chapterWritingBatches: chapterWritingBatches(chapters),
     slideRenderMetadata: deck.slides.map((slide) => slideRenderMetadata(slide, chapters)),
   }
 }
 
+function chapterWritingBatches(chapters: DeckPlanChapter[]): RenderPlanWritingBatch[] {
+  const batches: RenderPlanWritingBatch[] = []
+  for (const chapter of chapters) {
+    const chunks = chunkNumbers(chapter.slideIndexes, MAX_HTML_SLIDES_PER_BATCH)
+    for (let index = 0; index < chunks.length; index += 1) {
+      const chunk = chunks[index]
+      const chapterSuffix = chunks.length > 1 ? ` part ${index + 1}` : ""
+      batches.push({
+        label: batches.length === 0 ? `Initial shell and ${chapter.title}${chapterSuffix}` : `${chapter.title}${chapterSuffix}`,
+        chapterTitle: chapter.title,
+        slideIndexes: chunk,
+        maxSlides: MAX_HTML_SLIDES_PER_BATCH,
+        instructions: batches.length === 0
+          ? `Create the stable HTML shell if needed, then write only slide sections ${formatSlideRange(chunk)}. Do not add or rewrite more than ${MAX_HTML_SLIDES_PER_BATCH} slide sections in this write.`
+          : `Patch only slide sections ${formatSlideRange(chunk)}, preserve previously written slides, and keep the file valid after the patch. Do not add or rewrite more than ${MAX_HTML_SLIDES_PER_BATCH} slide sections in this write.`,
+      })
+    }
+  }
+  return batches
+}
+
+function chunkNumbers(values: number[], size: number): number[][] {
+  const chunks: number[][] = []
+  for (let index = 0; index < values.length; index += size) chunks.push(values.slice(index, index + size))
+  return chunks
+}
+
 function slideRenderMetadata(slide: SlideSpec, chapters: DeckPlanChapter[]): RenderPlanSlideMetadata {
   const chapter = chapters.find((item) => item.slideIndexes.includes(slide.index))
   const slideKind = renderPlanSlideKind(slide, chapter)
@@ -1116,6 +1138,13 @@ function claimChapterTitle(claim: NarrativeClaim): string {
   return title.endsWith(".") ? title.slice(0, -1) : title
 }
 
+function formatSlideRange(indexes: number[]): string {
+  if (indexes.length === 0) return "none"
+  const sorted = [...indexes].sort((a, b) => a - b)
+  if (sorted.length === 1) return String(sorted[0])
+  return `${sorted[0]}-${sorted[sorted.length - 1]}`
+}
+
 function hasCurrentApprovalOrOverride(narrative: NarrativeStateV1, narrativeHash: string): boolean {
   return narrative.approvals.some((approval) => approval.narrativeHash === narrativeHash && (approval.scope === "narrative" && approval.approvedBy === "user" || approval.scope === "render_override" || approval.approvedBy === "override"))
 }

package/lib/pdf/export.ts

@@ -226,6 +226,18 @@ export interface ExportResult {
   warnings?: string[]
 }
 
+export interface ExportPngResult {
+  outputDir: string
+  files: string[]
+  slideCount: number
+  durationMs: number
+  exportMode: "deck"
+}
+
+export interface ExportPngOptions {
+  outputDir?: string
+}
+
 /**
  * Export an HTML slide deck to PDF.
  *
@@ -268,8 +280,78 @@ export async function exportDeckToPdf(htmlFilePath: string): Promise<Omit<Export
 
   const outputPath = derivePdfPath(abs)
 
+  const screenshots = await screenshotDeckSlides(abs, "pdf")
+
+  // ── Step 3: Assemble PDF with pdf-lib ─────────────────────────────────────
+  const pdfDoc = await PDFDocument.create()
+
+  for (const pngBuf of screenshots) {
+    const pngImage = await pdfDoc.embedPng(new Uint8Array(pngBuf))
+    // Each page is exactly the canvas size (points = pixels at 1:1 for screen PDF)
+    const page = pdfDoc.addPage([CANVAS_W, CANVAS_H])
+    page.drawImage(pngImage, {
+      x: 0,
+      y: 0,
+      width: CANVAS_W,
+      height: CANVAS_H,
+    })
+  }
+
+  const pdfBytes = await pdfDoc.save()
+  writeFileSync(outputPath, pdfBytes)
+
+  return {
+    outputPath,
+    slideCount: screenshots.length,
+    durationMs: Date.now() - startMs,
+  }
+}
+
+export async function exportDeckToPng(htmlFilePath: string, options: ExportPngOptions = {}): Promise<ExportPngResult> {
+  const startMs = Date.now()
+  const abs = resolve(htmlFilePath)
+
+  if (!existsSync(abs)) {
+    throw new Error(`File not found: ${abs}`)
+  }
+
+  if (!/\.html?$/i.test(abs)) {
+    throw new Error(`Not an HTML file: ${abs}`)
+  }
+
+  const outputDir = options.outputDir ?? join(dirname(abs), `${basename(abs).replace(/\.html?$/i, "")}-png`)
+  mkdirSync(outputDir, { recursive: true })
+  const screenshots = await screenshotDeckSlides(abs, "png")
+  const files: string[] = []
+
+  screenshots.forEach((pngBuf, index) => {
+    const outputPath = join(outputDir, `slide-${String(index + 1).padStart(3, "0")}.png`)
+    writeFileSync(outputPath, new Uint8Array(pngBuf))
+    files.push(outputPath)
+  })
+
+  return {
+    outputDir,
+    files,
+    slideCount: screenshots.length,
+    durationMs: Date.now() - startMs,
+    exportMode: "deck",
+  }
+}
+
+async function screenshotDeckSlides(htmlFilePath: string, label: "pdf" | "png"): Promise<Buffer[]> {
+  const abs = resolve(htmlFilePath)
+
+  if (!existsSync(abs)) {
+    throw new Error(`File not found: ${abs}`)
+  }
+
+  if (!/\.html?$/i.test(abs)) {
+    throw new Error(`Not an HTML file: ${abs}`)
+  }
+
   // ── Step 1: Download external images and rewrite HTML ─────────────────────
-  const tmpDir = join("/tmp", `revela-pdf-${randomBytes(6).toString("hex")}`)
+  const tmpDir = join("/tmp", `revela-${label}-${randomBytes(6).toString("hex")}`)
   mkdirSync(tmpDir, { recursive: true })
 
   let tmpHtmlPath: string
@@ -373,27 +455,5 @@ export async function exportDeckToPdf(htmlFilePath: string): Promise<Omit<Export
     }
   }
 
-  // ── Step 3: Assemble PDF with pdf-lib ─────────────────────────────────────
-  const pdfDoc = await PDFDocument.create()
-
-  for (const pngBuf of screenshots) {
-    const pngImage = await pdfDoc.embedPng(new Uint8Array(pngBuf))
-    // Each page is exactly the canvas size (points = pixels at 1:1 for screen PDF)
-    const page = pdfDoc.addPage([CANVAS_W, CANVAS_H])
-    page.drawImage(pngImage, {
-      x: 0,
-      y: 0,
-      width: CANVAS_W,
-      height: CANVAS_H,
-    })
-  }
-
-  const pdfBytes = await pdfDoc.save()
-  writeFileSync(outputPath, pdfBytes)
-
-  return {
-    outputPath,
-    slideCount: screenshots.length,
-    durationMs: Date.now() - startMs,
-  }
+  return screenshots
 }

package/lib/refine/server.ts

@@ -217,19 +217,19 @@ async function handleRequest(req: Request): Promise<Response> {
   if (url.pathname === "/api/inspect" && req.method === "POST") {
     const session = validateSession(url.searchParams.get("token"))
     if (!session.ok) return session.response
-    return handleInspect(req, session.value)
+    return jsonResponse({ ok: false, error: "Review Insight/Inspect was removed in Revela 0.18. Use Comment for deck edits." }, 410)
   }
 
   if (url.pathname === "/api/inspect-result" && req.method === "GET") {
     const session = validateSession(url.searchParams.get("token"))
     if (!session.ok) return session.response
-    return handleInspectResult(url.searchParams.get("requestId"), session.value)
+    return jsonResponse({ ok: false, error: "Review Insight/Inspect was removed in Revela 0.18." }, 410)
   }
 
   if (url.pathname === "/api/inspect-events" && req.method === "GET") {
     const session = validateSession(url.searchParams.get("token"))
     if (!session.ok) return session.response
-    return handleInspectEvents(url.searchParams.get("requestId"), session.value)
+    return jsonResponse({ ok: false, error: "Review Insight/Inspect was removed in Revela 0.18." }, 410)
   }
 
   if (url.pathname === "/api/deck-version" && req.method === "GET") {
@@ -1133,6 +1133,7 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
     .tab.active { position: relative; top: 1px; background: #fbfaf7; border-color: #d8d2c6; color: #111827; box-shadow: 0 -7px 16px rgba(31,41,51,.05); }
     .tab-panel { display: none; flex-direction: column; gap: 12px; padding-top: 12px; }
     .tab-panel.active { display: flex; }
+    #inspectTab, #inspectPanel { display: none !important; }
     .sr-only { position: absolute !important; width: 1px !important; height: 1px !important; padding: 0 !important; margin: -1px !important; overflow: hidden !important; clip: rect(0,0,0,0) !important; white-space: nowrap !important; border: 0 !important; }
     .selection-summary { padding: 10px 12px; border: 1px solid #d8d2c6; border-radius: 14px; background: #fbfaf7; color: #3f3a33; font-size: 13px; line-height: 1.45; box-shadow: 0 8px 22px rgba(31,41,51,.05); }
     .selection-summary strong { display: block; margin-bottom: 7px; color: #756f66; font-size: 11px; letter-spacing: .09em; text-transform: uppercase; }

package/lib/runtime/index.ts

@@ -19,7 +19,6 @@ import {
 } from "../design/designs"
 import { createDeckFoundation as createDeckFoundationShell } from "../deck-html/foundation"
 import { activeDomain, activateDomain, createDomainDraftPackage, createDomainPackage, getDomainSkillMd, installDomainDraftPackage, listDomains, seedBuiltinDomains, validateDomainDraftPackage, validateDomainPackage } from "../domain/domains"
-import { computeNarrativeHash } from "../narrative-state/hash"
 import { compileNarrativeVault } from "../narrative-vault/compile"
 import { autoCompileNarrativeVault } from "../narrative-vault/auto-compile"
 import { extractNarrativeVaultMarkdownTargetsFromPatch } from "../narrative-vault/hook-targets"
@@ -151,18 +150,15 @@ export { formatArtifactQaUserNotice, formatMarkdownQaUserNotice }
 
 export function readDeckPlan(input: RuntimeWorkspaceInput = {}) {
   const workspaceRoot = root(input.workspaceRoot)
-  const compiled = compileNarrativeVault(workspaceRoot)
-  const knownNodeIds = compiled.graph ? new Set(compiled.graph.nodes.map((node) => node.id)) : undefined
-  const read = readDeckPlanArtifact(workspaceRoot, {
-    narrativeHash: compiled.narrative ? computeNarrativeHash(compiled.narrative) : undefined,
-    knownNodeIds,
-  })
+  const read = readDeckPlanArtifact(workspaceRoot)
   if (read.projection) {
     try {
-      const inventory = getDesignInventory(activeDesign())
+      const inventory = getDesignInventory(read.projection.designName || activeDesign())
       const diagnostics = deckPlanDesignDiagnostics(read.projection, {
         layouts: inventory.layouts.map((layout) => layout.name),
         components: inventory.components.map((component) => component.name),
+        layoutSlots: Object.fromEntries(inventory.layouts.map((layout) => [layout.name, layout.slots])),
+        componentNesting: Object.fromEntries(inventory.components.map((component) => [component.name, component.nesting])),
       })
       read.projection.diagnostics.push(...diagnostics)
       read.warnings.push(...diagnostics.map((diagnostic) => diagnostic.message))
@@ -177,19 +173,15 @@ export function upsertDeckPlanSlide(input: RuntimeDeckPlanSlideUpsertInput) {
   const workspaceRoot = root(input.workspaceRoot)
   const designName = input.designName || activeDesign()
   const inventory = getDesignInventory(designName)
-  const compiled = compileNarrativeVault(workspaceRoot)
-  const knownNodeIds = compiled.graph ? new Set(compiled.graph.nodes.map((node) => node.id)) : undefined
-  const narrativeHash = compiled.narrative ? computeNarrativeHash(compiled.narrative) : undefined
   const result = upsertDeckPlanSlideArtifact(workspaceRoot, input, {
-    narrativeHash,
-    knownNodeIds,
     designLayouts: inventory.layouts.map((layout) => layout.name),
     designComponents: inventory.components.map((component) => component.name),
+    layoutSlots: Object.fromEntries(inventory.layouts.map((layout) => [layout.name, layout.slots])),
+    componentNesting: Object.fromEntries(inventory.components.map((component) => [component.name, component.nesting])),
   })
   return {
     ...result,
     designName,
-    narrativeHash,
   }
 }
 
@@ -256,6 +248,21 @@ export async function exportPptx(input: RuntimeFileInput & { speakerNotes?: Arra
   return { ok: true, ...result }
 }
 
+export async function exportPng(input: RuntimeFileInput & { outputDir?: string }) {
+  const { exportDeckToPng } = await import("../pdf/export")
+  const workspaceRoot = root(input.workspaceRoot)
+  const filePath = resolve(workspaceRoot, input.file)
+  const outputDir = input.outputDir ? resolve(workspaceRoot, input.outputDir) : undefined
+  const result = await exportDeckToPng(filePath, { outputDir })
+  recordRenderedArtifact(workspaceRoot, {
+    sourceHtmlPath: workspaceRelative(resolve(workspaceRoot), filePath),
+    outputPath: result.outputDir,
+    type: "png",
+    actor: "revela-codex-mcp",
+  })
+  return { ok: true, ...result }
+}
+
 export async function reviewDeckRead(input: ReviewDeckReadInput) {
   const review = await import("./review")
   return review.reviewDeckRead(input)

package/lib/runtime/review.ts

@@ -1,12 +1,7 @@
 import { existsSync } from "fs"
 import { resolve } from "path"
-import { DECKS_STATE_FILE, hasDecksState, normalizeWorkspaceDeckState, readDecksState } from "../decks-state"
 import { extractDesignClasses } from "../design/designs"
-import { compileInspectionContext, type InspectionContext } from "../inspection-context/compile"
-import { computeNarrativeHash } from "../narrative-state/hash"
 import { readDeckPlanArtifact } from "../narrative-state/deck-plan-artifact"
-import { compileNarrativeVault } from "../narrative-vault/compile"
-import { formatVaultDiagnosticMarkdown, formatVaultDiagnosticReport } from "../narrative-vault/diagnostic-report"
 import { formatArtifactQAReport, runArtifactQA } from "../qa/artifact"
 import { openRefineDeck } from "../refine/open"
 import { createCodexExecReviewPromptBridge } from "../refine/prompt-bridge"
@@ -24,13 +19,6 @@ export interface ReviewDeckOpenInput extends ReviewDeckReadInput {
   openUrl?: (url: string) => void
 }
 
-export interface ReviewDeckInspectionContextResult {
-  ok: boolean
-  skipped: boolean
-  reason?: string
-  context?: InspectionContext
-}
-
 export async function reviewDeckRead(input: ReviewDeckReadInput): Promise<any> {
   const workspaceRoot = root(input.workspaceRoot)
   const requestedFile = input.file?.trim()
@@ -55,20 +43,13 @@ export async function reviewDeckRead(input: ReviewDeckReadInput): Promise<any> {
   }
 
   const artifactQa = await readArtifactQa(workspaceRoot, filePath)
-  const narrativeRead = readNarrative(workspaceRoot)
-  const deckPlan = readDeckPlan(workspaceRoot, narrativeRead.knownNodeIds, narrativeRead.narrativeHash)
-  const { knownNodeIds: _knownNodeIds, ...narrative } = narrativeRead
-  const inspectionContext = readInspectionContext(workspaceRoot, file)
+  const deckPlan = readDeckPlan(workspaceRoot)
   const diagnostics = {
     artifactQa: artifactQa.summary,
     deckPlan: summarizeDeckPlan(deckPlan),
-    narrative: narrative.summary,
-    inspectionContext: inspectionContext.ok
-      ? { ok: true, skipped: false }
-      : { ok: false, skipped: true, reason: inspectionContext.reason },
   }
   const markdown = input.format === "markdown"
-    ? formatReviewDeckReadMarkdown({ file, artifactQa, deckPlan, narrative, inspectionContext })
+    ? formatReviewDeckReadMarkdown({ file, artifactQa, deckPlan })
     : undefined
 
   return {
@@ -76,11 +57,7 @@ export async function reviewDeckRead(input: ReviewDeckReadInput): Promise<any> {
     file,
     artifactQa,
     deckPlan,
-    narrative,
     diagnostics,
-    inspectionContext,
-    artifactCoverage: inspectionContext.context?.artifactCoverage ?? [],
-    evidenceTrace: inspectionContext.context?.slides.flatMap((slide) => slide.evidence) ?? narrative.evidenceTrace,
     markdown,
   }
 }
@@ -158,76 +135,8 @@ async function readArtifactQa(workspaceRoot: string, filePath: string) {
   }
 }
 
-function readNarrative(workspaceRoot: string): any {
-  if (!existsSync(resolve(workspaceRoot, "revela-narrative"))) {
-    return {
-      ok: false,
-      skipped: true,
-      reason: "No revela-narrative/ vault exists; narrative diagnostics skipped.",
-      summary: { ok: false, skipped: true, reason: "No revela-narrative/ vault exists; narrative diagnostics skipped." },
-      evidenceTrace: [],
-    }
-  }
-
-  const compiled = compileNarrativeVault(workspaceRoot)
-  const report = formatVaultDiagnosticReport(compiled.diagnostics)
-  const narrative = compiled.narrative
-  return {
-    ok: compiled.ok,
-    skipped: false,
-    narrativeHash: narrative ? computeNarrativeHash(narrative) : undefined,
-    summary: report,
-    diagnostics: compiled.diagnostics,
-    diagnosticsMarkdown: formatVaultDiagnosticMarkdown(report),
-    evidenceTrace: narrative?.evidenceBindings.map((binding) => ({
-      id: binding.id,
-      claimId: binding.claimId,
-      source: binding.source,
-      sourcePath: binding.sourcePath,
-      findingsFile: binding.findingsFile,
-      quote: binding.quote,
-      location: binding.location,
-      url: binding.url,
-      supportScope: binding.supportScope,
-      unsupportedScope: binding.unsupportedScope,
-      caveat: binding.caveat,
-      strength: binding.strength,
-    })) ?? [],
-    knownNodeIds: compiled.graph ? new Set(compiled.graph.nodes.map((node) => node.id)) : undefined,
-  }
-}
-
-function readDeckPlan(workspaceRoot: string, knownNodeIds: Set<string> | undefined, narrativeHash: string | undefined) {
-  return readDeckPlanArtifact(workspaceRoot, { knownNodeIds, narrativeHash })
-}
-
-function readInspectionContext(workspaceRoot: string, file: string): ReviewDeckInspectionContextResult {
-  if (!hasDecksState(workspaceRoot)) {
-    return {
-      ok: false,
-      skipped: true,
-      reason: `No ${DECKS_STATE_FILE} exists; legacy inspection context skipped for file-native deck.`,
-    }
-  }
-
-  try {
-    const state = normalizeWorkspaceDeckState(readDecksState(workspaceRoot), workspaceRoot)
-    const slug = Object.entries(state.decks).find(([, deck]) => normalizePath(deck.outputPath) === normalizePath(file))?.[0]
-    if (!slug) {
-      return {
-        ok: false,
-        skipped: true,
-        reason: `No ${DECKS_STATE_FILE} deck outputPath matches ${file}; legacy inspection context skipped.`,
-      }
-    }
-    return { ok: true, skipped: false, context: compileInspectionContext(state, slug) }
-  } catch (e) {
-    return {
-      ok: false,
-      skipped: true,
-      reason: `Could not compile legacy inspection context: ${e instanceof Error ? e.message : String(e)}`,
-    }
-  }
+function readDeckPlan(workspaceRoot: string) {
+  return readDeckPlanArtifact(workspaceRoot)
 }
 
 function summarizeDeckPlan(deckPlan: ReturnType<typeof readDeckPlanArtifact>) {
@@ -243,8 +152,6 @@ function formatReviewDeckReadMarkdown(input: {
   file: string
   artifactQa: Awaited<ReturnType<typeof readArtifactQa>>
   deckPlan: ReturnType<typeof readDeckPlanArtifact>
-  narrative: ReturnType<typeof readNarrative>
-  inspectionContext: ReviewDeckInspectionContextResult
 }): string {
   const lines = [
     "# Review Deck Read",
@@ -253,19 +160,12 @@ function formatReviewDeckReadMarkdown(input: {
     "",
     `Artifact QA: ${input.artifactQa.summary.passed ? "passed" : "failed"} (${input.artifactQa.summary.errors} hard error(s), ${input.artifactQa.summary.warnings} warning(s))`,
     `Deck-plan: ${input.deckPlan.ok ? "read" : `skipped/diagnostic - ${input.deckPlan.reason ?? "not available"}`}`,
-    `Narrative: ${input.narrative.skipped ? input.narrative.reason : input.narrative.summary.summary}`,
-    `Inspection context: ${input.inspectionContext.ok ? "read" : `skipped - ${input.inspectionContext.reason}`}`,
     "",
     input.artifactQa.markdown,
   ]
-  if (!input.narrative.skipped && input.narrative.diagnosticsMarkdown) lines.push("", input.narrative.diagnosticsMarkdown)
   return lines.join("\n")
 }
 
-function normalizePath(value: string): string {
-  return value.replace(/\\/g, "/").replace(/^\.\/+/, "")
-}
-
 function root(workspaceRoot: string | undefined): string {
   return resolve(workspaceRoot || process.cwd())
 }

package/lib/workspace-state/render-targets.ts

@@ -47,7 +47,7 @@ export function upsertRenderTarget(state: DecksState, target: RenderTarget): Dec
   return state
 }
 
-export function deriveExportRenderTarget(htmlTarget: RenderTarget, type: "pdf" | "pptx", outputPath: string): RenderTarget {
+export function deriveExportRenderTarget(htmlTarget: RenderTarget, type: "pdf" | "pptx" | "png", outputPath: string): RenderTarget {
   const normalizedOutput = normalizeWorkspacePath(outputPath)
   return cleanRenderTarget({
     id: renderTargetId(type, normalizedOutput),
@@ -64,7 +64,7 @@ export function deriveExportRenderTarget(htmlTarget: RenderTarget, type: "pdf" |
 
 export function recordArtifactRenderTarget(
   state: DecksState,
-  input: { sourceHtmlPath: string; type: "pdf" | "pptx"; outputPath: string; artifactVersion?: string },
+  input: { sourceHtmlPath: string; type: "pdf" | "pptx" | "png"; outputPath: string; artifactVersion?: string },
 ): RenderTarget {
   const normalizedSource = normalizeWorkspacePath(input.sourceHtmlPath)
   const activeTarget = ensureActiveHtmlDeckRenderTarget(state)

package/lib/workspace-state/rendered-artifacts.ts

@@ -8,7 +8,7 @@ export function recordRenderedArtifact(
   input: {
     sourceHtmlPath: string
     outputPath: string
-    type: "pdf" | "pptx"
+    type: "pdf" | "pptx" | "png"
     actor: string
     artifactVersion?: string
   },

package/lib/workspace-state/types.ts

@@ -108,7 +108,7 @@ export type WorkspaceActionType =
 
 export interface RenderTarget {
   id: string
-  type: "html_deck" | "pdf" | "pptx" | "brief" | "executive_brief" | "appendix" | "qa_view" | "interactive_page"
+  type: "html_deck" | "pdf" | "pptx" | "png" | "brief" | "executive_brief" | "appendix" | "qa_view" | "interactive_page"
   outputPath?: string
   sourceNodeIds: string[]
   artifactVersion?: string

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyber-dash-tech/revela",
-  "version": "0.17.24",
+  "version": "0.18.3",
   "description": "OpenCode plugin for trusted narrative artifacts from local sources, research, and evidence",
   "type": "module",
   "main": "./index.ts",