@cyber-dash-tech/revela 0.17.23 → 0.18.2

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

@@ -207,7 +207,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 +236,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,7 +245,7 @@ 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.",
@@ -254,18 +254,17 @@ function buildDeckPlanRequirements(narrativeHash: string): DeckPlanRequirements
       "Preserve evidence ids, source trace, supported scope, unsupported scope, caveats, and strength 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, URLs, and caveats; do not use canonical ## Relations in deck-plan files.",
     ],
     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,13 +273,13 @@ 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.",

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,13 +19,12 @@ 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"
 import { runNarrativeMarkdownQa, type MarkdownQaOptions } from "../narrative-vault/markdown-qa"
 import { formatArtifactQaUserNotice, formatMarkdownQaUserNotice } from "../hook-notifications"
-import { readDeckPlanArtifact } from "../narrative-state/deck-plan-artifact"
+import { deckPlanDesignDiagnostics, readDeckPlanArtifact, upsertDeckPlanSlideArtifact, type DeckPlanSlideUpsertInput } from "../narrative-state/deck-plan-artifact"
 import { extractDesignClasses } from "../design/designs"
 import { recordRenderedArtifact, workspaceRelative } from "../workspace-state/rendered-artifacts"
 import { checkMaterialIntake, extractMaterial, materialIntakeNoticeForCommand, prepareLocalMaterials, recordMaterialReview } from "../material-intake"
@@ -76,6 +75,10 @@ export interface RuntimeDesignComponentReadInput {
   component: string | string[]
 }
 
+export interface RuntimeDeckPlanSlideUpsertInput extends RuntimeWorkspaceInput, DeckPlanSlideUpsertInput {
+  designName?: string
+}
+
 export interface RuntimeDesignCreateInput {
   name: string
   base?: string
@@ -147,12 +150,39 @@ 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
-  return readDeckPlanArtifact(workspaceRoot, {
-    narrativeHash: compiled.narrative ? computeNarrativeHash(compiled.narrative) : undefined,
-    knownNodeIds,
+  const read = readDeckPlanArtifact(workspaceRoot)
+  if (read.projection) {
+    try {
+      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))
+    } catch {
+      // Design diagnostics are advisory; deck-plan reading remains available.
+    }
+  }
+  return read
+}
+
+export function upsertDeckPlanSlide(input: RuntimeDeckPlanSlideUpsertInput) {
+  const workspaceRoot = root(input.workspaceRoot)
+  const designName = input.designName || activeDesign()
+  const inventory = getDesignInventory(designName)
+  const result = upsertDeckPlanSlideArtifact(workspaceRoot, input, {
+    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,
+  }
 }
 
 export function createDeckFoundation(input: RuntimeDeckFoundationInput) {
@@ -218,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.23",
+  "version": "0.18.2",
   "description": "OpenCode plugin for trusted narrative artifacts from local sources, research, and evidence",
   "type": "module",
   "main": "./index.ts",