@cyber-dash-tech/revela 0.15.2 → 0.15.4

package/plugin.ts

@@ -1,7 +1,7 @@
 /**
  * revela — Core OpenCode Plugin
  *
- * Architecture: enable/disable mode + single /revela command (DCP style)
+ * Architecture: single /revela command surface (DCP style)
  *
  * Responsibilities:
  * 1. On load: seed built-in designs/domains + build initial _active-prompt.md
@@ -30,8 +30,6 @@ import { extractPdfText } from "./lib/read-hooks/extractors/pdf"
 import { createOfficeReadView } from "./lib/read-hooks/office-read-view"
 import { OFFICE_EXTENSIONS, IMAGE_EXTENSIONS, formatExtractedText } from "./lib/read-hooks/dispatch"
 import { handleHelp } from "./lib/commands/help"
-import { handleEnable } from "./lib/commands/enable"
-import { handleDisable } from "./lib/commands/disable"
 import {
   handleDesignsList,
   handleDesignsActivate,
@@ -46,8 +44,6 @@ import {
 } from "./lib/commands/domains"
 import { handlePdf } from "./lib/commands/pdf"
 import { buildPptxNotesPrompt, handlePptx, parsePptxArgs, resolvePptxDeck } from "./lib/commands/pptx"
-import { handleEdit } from "./lib/commands/edit"
-import { handleInspect } from "./lib/commands/inspect"
 import { handleRefine } from "./lib/commands/refine"
 import { formatArtifactQAReport, runArtifactQA } from "./lib/qa/artifact"
 import { ensureRefineDeckOpenForChange } from "./lib/refine/open"
@@ -61,9 +57,8 @@ import {
 import { buildInitPrompt } from "./lib/commands/init"
 import { buildResearchPrompt } from "./lib/commands/research"
 import { handleBrief, parseBriefArgs } from "./lib/commands/brief"
-import { buildNarrativeViewPrompt, handleNarrative, parseNarrativeArgs, parseStoryArgs } from "./lib/commands/narrative"
-import { parseRememberArgs, buildRememberPrompt } from "./lib/commands/remember"
-import { buildDeckPrompt, buildDeckReviewPrompt, buildReviewPrompt } from "./lib/commands/review"
+import { buildNarrativeViewPrompt, parseStoryArgs } from "./lib/commands/narrative"
+import { buildDeckPrompt } from "./lib/commands/review"
 import {
   extractDeckHtmlTargetsFromPatch,
   extractPatchTextArg,
@@ -235,7 +230,7 @@ const server: Plugin = (async (pluginCtx) => {
       opencodeConfig.command ??= {}
       opencodeConfig.command["revela"] = {
         template: "",
-        description: "Revela — narrative artifact workspace (init, research, story, make, refine, design)",
+        description: "show REVELA help",
       }
 
       // Register the research subagent.
@@ -316,277 +311,131 @@ const server: Plugin = (async (pluginCtx) => {
         await handleHelp(send)
         throw new Error("__REVELA_STATUS_HANDLED__")
       }
-      if (sub === "enable") {
-        await handleEnable(send)
-        throw new Error("__REVELA_ENABLE_HANDLED__")
-      }
-      if (sub === "disable") {
-        await handleDisable(send)
-        throw new Error("__REVELA_DISABLE_HANDLED__")
-      }
-      if (sub === "init") {
-        queueWorkflowCommand({
-          sessionID,
-          name: "init",
-          mode: "narrative",
-          visibleText: "Initialize Revela workspace.",
-          hiddenPrompt: buildInitPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot }),
-          output,
-        })
-        return
-      }
-      if (sub === "remember") {
-        const parsed = parseRememberArgs(param)
-        if (!parsed.ok) {
-          await send(parsed.error)
-          throw new Error("__REVELA_REMEMBER_USAGE_HANDLED__")
-        }
-        queueWorkflowCommand({
-          sessionID,
-          name: "remember",
-          mode: "narrative",
-          visibleText: "Remember Revela workspace preference.",
-          hiddenPrompt: buildRememberPrompt({ memory: parsed.memory, exists: hasDecksState(workspaceRoot) }),
-          output,
-        })
-        return
-      }
-      if (sub === "research") {
-        if (param) {
-          await send("`/revela research` does not accept arguments yet. Add the research question in normal chat, or run it to work from open story gaps.")
-          throw new Error("__REVELA_RESEARCH_USAGE_HANDLED__")
-        }
-        queueWorkflowCommand({
-          sessionID,
-          name: "research",
-          mode: "narrative",
-          visibleText: "Research Revela story gaps.",
-          hiddenPrompt: buildResearchPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot }),
-          output,
-        })
-        return
-      }
-      if (sub === "review") {
-        if (param) {
-          await send("`/revela review` no longer accepts a deck name. It is a compatibility alias for `/revela story`. Use `/revela make deck --review` for deck/artifact readiness.")
-          throw new Error("__REVELA_REVIEW_USAGE_HANDLED__")
-        }
-        queueWorkflowCommand({
-          sessionID,
-          name: "review",
-          mode: "narrative",
-          visibleText: "Review Revela story readiness.",
-          hiddenPrompt: buildReviewPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot }),
-          output,
-        })
-        return
-      }
-      if (sub === "story") {
-        const parsed = parseStoryArgs(param)
-        if (!parsed.ok) {
-          await send(parsed.error)
-          throw new Error("__REVELA_STORY_USAGE_HANDLED__")
-        }
-        queueWorkflowCommand({
-          sessionID,
-          name: "story",
-          mode: "narrative",
-          visibleText: "Open Revela story workspace.",
-          hiddenPrompt: buildNarrativeViewPrompt({ workspaceRoot, language: parsed.args.language }),
-          output,
-        })
-        return
-      }
-      if (sub === "narrative") {
-        if (!param) {
-          queueWorkflowCommand({
-            sessionID,
-            name: "narrative",
-            mode: "narrative",
-            visibleText: "Open Revela story workspace.",
-            hiddenPrompt: buildNarrativeViewPrompt({ workspaceRoot, language: "en" }),
-            output,
-          })
-          return
-        }
-        const parsed = parseNarrativeArgs(param)
-        if (!parsed.ok) {
-          await send(parsed.error)
-          throw new Error("__REVELA_NARRATIVE_USAGE_HANDLED__")
-        }
-        if (parsed.args.raw) {
-          await handleNarrative({ workspaceRoot, openBrowser: true, language: parsed.args.language }, send)
-          throw new Error("__REVELA_NARRATIVE_HANDLED__")
-        }
-        queueWorkflowCommand({
-          sessionID,
-          name: "narrative view",
-          mode: "narrative",
-          visibleText: "Open read-only Revela narrative map.",
-          hiddenPrompt: buildNarrativeViewPrompt({ workspaceRoot, language: parsed.args.language }),
-          output,
-        })
-        return
-      }
-      if (sub === "brief") {
-        const parsed = parseBriefArgs(param)
-        if (!parsed.ok) {
-          await send(parsed.error)
-          throw new Error("__REVELA_BRIEF_USAGE_HANDLED__")
-        }
-        await handleBrief({ workspaceRoot, outputPath: parsed.args.outputPath }, send)
-        throw new Error("__REVELA_BRIEF_HANDLED__")
-      }
       if (sub === "make") {
         const target = args[1]?.toLowerCase() ?? ""
         const makeParam = args.slice(2).join(" ")
-        if (target === "deck") {
-          if (makeParam && makeParam !== "--review") {
-            await send("Usage: `/revela make deck` starts approved-narrative deck handoff; `/revela make deck --review` reviews deck/artifact readiness.")
+        if (target === "--deck") {
+          if (makeParam) {
+            await send("Usage: `/revela make --deck`.")
             throw new Error("__REVELA_MAKE_DECK_USAGE_HANDLED__")
           }
           queueWorkflowCommand({
             sessionID,
-            name: makeParam ? "make deck --review" : "make deck",
+            name: "make --deck",
             mode: "deck-render",
-            visibleText: makeParam ? "Review Revela deck artifact readiness." : "Make Revela deck from approved story.",
-            hiddenPrompt: makeParam
-              ? buildDeckReviewPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot })
-              : buildDeckPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot }),
+            visibleText: "Make Revela deck from approved story.",
+            hiddenPrompt: buildDeckPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot }),
             output,
           })
           return
         }
-        if (target === "brief") {
+        if (target === "--brief") {
           const parsed = parseBriefArgs(makeParam)
           if (!parsed.ok) {
-            await send(parsed.error.replace("/revela brief", "/revela make brief"))
+            await send(parsed.error.replace("/revela brief", "/revela make --brief"))
             throw new Error("__REVELA_MAKE_BRIEF_USAGE_HANDLED__")
           }
           await handleBrief({ workspaceRoot, outputPath: parsed.args.outputPath }, send)
           throw new Error("__REVELA_MAKE_BRIEF_HANDLED__")
         }
-        await send("Usage: `/revela make deck [--review]` or `/revela make brief [workspace-relative-output.md]`.")
+        await send("Usage: `/revela make --deck` or `/revela make --brief [workspace-relative-output.md]`.")
         throw new Error("__REVELA_MAKE_USAGE_HANDLED__")
       }
-      if (sub === "deck") {
-        if (param && param !== "--review") {
-          await send("Usage: `/revela deck` starts approved-narrative deck handoff; `/revela deck --review` reviews deck/artifact readiness. These are compatibility aliases for `/revela make deck`.")
-          throw new Error("__REVELA_DECK_USAGE_HANDLED__")
-        }
-        if (!param) {
-          queueWorkflowCommand({
-            sessionID,
-            name: "deck",
-            mode: "deck-render",
-            visibleText: "Make Revela deck from approved story.",
-            hiddenPrompt: buildDeckPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot }),
-            output,
-          })
-          return
+      if (sub === "review") {
+        if (param !== "--deck") {
+          await send("Usage: `/revela review --deck`.")
+          throw new Error("__REVELA_REVIEW_USAGE_HANDLED__")
         }
-        queueWorkflowCommand({
-          sessionID,
-          name: "deck --review",
-          mode: "deck-render",
-          visibleText: "Review Revela deck artifact readiness.",
-          hiddenPrompt: buildDeckReviewPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot }),
-          output,
-        })
-        return
+        await handleRefine({ client, sessionID, workspaceRoot }, send)
+        throw new Error("__REVELA_REVIEW_HANDLED__")
       }
       if (sub === "refine") {
-        if (param) {
-          await send("`/revela refine` does not accept a target. It opens the only HTML deck in `decks/`.")
+        if (param !== "--deck") {
+          await send("Usage: `/revela review --deck`.")
           throw new Error("__REVELA_REFINE_USAGE_HANDLED__")
         }
+        await send("`/revela refine --deck` is deprecated. Use `/revela review --deck`.")
         await handleRefine({ client, sessionID, workspaceRoot }, send)
         throw new Error("__REVELA_REFINE_HANDLED__")
       }
-      if (sub === "edit") {
-        if (param) {
-          await send("`/revela edit` has been removed. Use `/revela refine` for the unified reading, inspection, and editing workspace.")
-          throw new Error("__REVELA_EDIT_USAGE_HANDLED__")
-        }
-        await handleEdit({ client, sessionID, workspaceRoot }, send)
-        throw new Error("__REVELA_EDIT_HANDLED__")
-      }
-      if (sub === "inspect") {
-        if (param) {
-          await send("`/revela inspect` is deprecated and does not accept a target. Use `/revela refine` for the unified reading and refinement workspace.")
-          throw new Error("__REVELA_INSPECT_USAGE_HANDLED__")
+      if (sub === "export") {
+        const target = args[1]?.toLowerCase() ?? ""
+        const format = args[2]?.toLowerCase() ?? ""
+        const exportParam = args.slice(3).join(" ")
+        if (target !== "--deck" || (format !== "pdf" && format !== "pptx")) {
+          await send("Usage: `/revela export --deck pdf [file.html]` or `/revela export --deck pptx [file.html] [--notes]`.")
+          throw new Error("__REVELA_EXPORT_USAGE_HANDLED__")
+        }
+        if (format === "pdf") {
+          await handlePdf(exportParam, send, workspaceRoot)
+          throw new Error("__REVELA_EXPORT_PDF_HANDLED__")
+        }
+        const pptxArgs = parsePptxArgs(exportParam)
+        if (pptxArgs.notes) {
+          try {
+            const deck = resolvePptxDeck(workspaceRoot, pptxArgs.filePath)
+            queueWorkflowCommand({
+              sessionID,
+              name: "export --deck pptx --notes",
+              mode: "deck-render",
+              visibleText: "Export Revela deck to PPTX with speaker notes.",
+              hiddenPrompt: buildPptxNotesPrompt(deck),
+              output,
+            })
+            return
+          } catch (e) {
+            const msg = e instanceof Error ? e.message : String(e)
+            await send(`**PPTX export failed**\n\n\`\`\`\n${msg}\n\`\`\``)
+            throw new Error("__REVELA_EXPORT_PPTX_HANDLED__")
+          }
         }
-        await handleInspect({ client, sessionID, workspaceRoot }, send)
-        throw new Error("__REVELA_INSPECT_HANDLED__")
-      }
-      if (sub === "designs" && !param) {
-        await handleDesignsList(send)
-        throw new Error("__REVELA_DESIGNS_LIST_HANDLED__")
-      }
-      if (sub === "designs" && param) {
-        await handleDesignsActivate(param, send)
-        throw new Error("__REVELA_DESIGNS_ACTIVATE_HANDLED__")
-      }
-      if (sub === "domains" && !param) {
-        await handleDomainsList(send)
-        throw new Error("__REVELA_DOMAINS_LIST_HANDLED__")
-      }
-      if (sub === "domains" && param) {
-        await handleDomainsActivate(param, send)
-        throw new Error("__REVELA_DOMAINS_ACTIVATE_HANDLED__")
-      }
-      if (sub === "designs-add") {
-        await handleDesignsAdd(param, send)
-        throw new Error("__REVELA_DESIGNS_ADD_HANDLED__")
+        await handlePptx(exportParam, send, workspaceRoot)
+        throw new Error("__REVELA_EXPORT_PPTX_HANDLED__")
       }
       if (sub === "design") {
-        const designAction = args[1]?.toLowerCase() ?? "list"
+        const designAction = args[1]?.toLowerCase() ?? ""
         const designParam = args.slice(2).join(" ")
-        if (designAction === "list") {
-          if (designParam) {
-            await send("Usage: `/revela design list`.")
-            throw new Error("__REVELA_DESIGN_LIST_USAGE_HANDLED__")
-          }
+        if (!designAction) {
           await handleDesignsList(send)
           throw new Error("__REVELA_DESIGN_LIST_HANDLED__")
         }
-        if (designAction === "use") {
+        if (designAction === "--use") {
           if (!designParam) {
-            await send("Usage: `/revela design use <name>`.")
+            await send("Usage: `/revela design --use <name>`.")
             throw new Error("__REVELA_DESIGN_USE_USAGE_HANDLED__")
           }
           await handleDesignsActivate(designParam, send)
           throw new Error("__REVELA_DESIGN_USE_HANDLED__")
         }
-        if (designAction === "add") {
+        if (designAction === "--add") {
           if (!designParam) {
-            await send("Usage: `/revela design add <url|github:user/repo|local-path>`.")
+            await send("Usage: `/revela design --add <url|github:user/repo|local-path>`.")
             throw new Error("__REVELA_DESIGN_ADD_USAGE_HANDLED__")
           }
           await handleDesignsAdd(designParam, send)
           throw new Error("__REVELA_DESIGN_ADD_HANDLED__")
         }
-        if (designAction === "rm" || designAction === "remove") {
+        if (designAction === "--rm") {
           if (!designParam) {
-            await send("Usage: `/revela design rm <name>`.")
+            await send("Usage: `/revela design --rm <name>`.")
             throw new Error("__REVELA_DESIGN_RM_USAGE_HANDLED__")
           }
           await handleDesignsRemove(designParam, send)
           throw new Error("__REVELA_DESIGN_RM_HANDLED__")
         }
-        if (designAction === "preview") {
+        if (designAction === "--preview") {
           await handleDesignsPreview(designParam, send)
           throw new Error("__REVELA_DESIGN_PREVIEW_HANDLED__")
         }
-        if (designAction === "new") {
+        if (designAction === "--new") {
           const parsed = parseDesignsNewArgs(designParam)
           if (!parsed.ok) {
-            await send(parsed.error.replaceAll("/revela designs-new", "/revela design new"))
+            await send(parsed.error)
             throw new Error("__REVELA_DESIGN_NEW_USAGE_HANDLED__")
           }
           queueWorkflowCommand({
             sessionID,
-            name: `design new ${parsed.name}`,
+            name: `design --new ${parsed.name}`,
             mode: "deck-render",
             visibleText: `Create Revela design ${parsed.name}.`,
             hiddenPrompt: buildDesignsNewPrompt({ name: parsed.name, base: parsed.base }),
@@ -594,15 +443,15 @@ const server: Plugin = (async (pluginCtx) => {
           })
           return
         }
-        if (designAction === "edit") {
+        if (designAction === "--edit") {
           const parsed = parseDesignsEditArgs(designParam)
           if (!parsed.ok) {
-            await send(parsed.error.replaceAll("/revela designs-edit", "/revela design edit"))
+            await send(parsed.error)
             throw new Error("__REVELA_DESIGN_EDIT_USAGE_HANDLED__")
           }
           queueWorkflowCommand({
             sessionID,
-            name: `design edit ${parsed.name}`,
+            name: `design --edit ${parsed.name}`,
             mode: "deck-render",
             visibleText: `Edit Revela design ${parsed.name}.`,
             hiddenPrompt: buildDesignsEditPrompt({ name: parsed.name }),
@@ -610,83 +459,93 @@ const server: Plugin = (async (pluginCtx) => {
           })
           return
         }
-        await send("Usage: `/revela design [list|use <name>|new <name>|edit <name>|preview [name]|add <source>|rm <name>]`.")
+        await send("Usage: `/revela design [--use <name>|--preview [name]|--new <name>|--edit <name>|--add <source>|--rm <name>]`.")
         throw new Error("__REVELA_DESIGN_USAGE_HANDLED__")
       }
-      if (sub === "designs-new") {
-        const parsed = parseDesignsNewArgs(param)
-        if (!parsed.ok) {
-          await send(parsed.error)
-          throw new Error("__REVELA_DESIGNS_NEW_USAGE_HANDLED__")
+      if (sub === "domain") {
+        const domainAction = args[1]?.toLowerCase() ?? ""
+        const domainParam = args.slice(2).join(" ")
+        if (!domainAction) {
+          await handleDomainsList(send)
+          throw new Error("__REVELA_DOMAIN_LIST_HANDLED__")
+        }
+        if (domainAction === "--use") {
+          if (!domainParam) {
+            await send("Usage: `/revela domain --use <name>`.")
+            throw new Error("__REVELA_DOMAIN_USE_USAGE_HANDLED__")
+          }
+          await handleDomainsActivate(domainParam, send)
+          throw new Error("__REVELA_DOMAIN_USE_HANDLED__")
+        }
+        if (domainAction === "--add") {
+          if (!domainParam) {
+            await send("Usage: `/revela domain --add <url|github:user/repo|local-path>`.")
+            throw new Error("__REVELA_DOMAIN_ADD_USAGE_HANDLED__")
+          }
+          await handleDomainsAdd(domainParam, send)
+          throw new Error("__REVELA_DOMAIN_ADD_HANDLED__")
         }
+        if (domainAction === "--rm") {
+          if (!domainParam) {
+            await send("Usage: `/revela domain --rm <name>`.")
+            throw new Error("__REVELA_DOMAIN_RM_USAGE_HANDLED__")
+          }
+          await handleDomainsRemove(domainParam, send)
+          throw new Error("__REVELA_DOMAIN_RM_HANDLED__")
+        }
+        await send("Usage: `/revela domain [--use <name>|--add <source>|--rm <name>]`.")
+        throw new Error("__REVELA_DOMAIN_USAGE_HANDLED__")
+      }
+      const legacyCommands = new Set([
+        "enable", "disable", "review", "narrative", "deck", "brief", "edit", "inspect", "remember",
+        "designs", "designs-new", "designs-edit", "designs-preview", "designs-add", "designs-rm",
+        "domains", "domains-add", "domains-rm", "pdf", "pptx",
+      ])
+      if (legacyCommands.has(sub)) {
+        await send(`\`/revela ${sub}\` is no longer a public command. Run \`/revela\` to see the current REVELA help.`)
+        throw new Error("__REVELA_LEGACY_COMMAND_HANDLED__")
+      }
+      if (sub === "init") {
         queueWorkflowCommand({
           sessionID,
-          name: `designs-new ${parsed.name}`,
-          mode: "deck-render",
-          visibleText: `Create Revela design ${parsed.name}.`,
-          hiddenPrompt: buildDesignsNewPrompt({ name: parsed.name, base: parsed.base }),
+          name: "init",
+          mode: "narrative",
+          visibleText: "Initialize Revela workspace.",
+          hiddenPrompt: buildInitPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot }),
           output,
         })
         return
       }
-      if (sub === "designs-edit") {
-        const parsed = parseDesignsEditArgs(param)
-        if (!parsed.ok) {
-          await send(parsed.error)
-          throw new Error("__REVELA_DESIGNS_EDIT_USAGE_HANDLED__")
+      if (sub === "research") {
+        if (param) {
+          await send("`/revela research` does not accept arguments yet. Add the research question in normal chat, or run it to work from open story gaps.")
+          throw new Error("__REVELA_RESEARCH_USAGE_HANDLED__")
         }
         queueWorkflowCommand({
           sessionID,
-          name: `designs-edit ${parsed.name}`,
-          mode: "deck-render",
-          visibleText: `Edit Revela design ${parsed.name}.`,
-          hiddenPrompt: buildDesignsEditPrompt({ name: parsed.name }),
+          name: "research",
+          mode: "narrative",
+          visibleText: "Research Revela story gaps.",
+          hiddenPrompt: buildResearchPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot }),
           output,
         })
         return
       }
-      if (sub === "designs-preview") {
-        await handleDesignsPreview(param, send)
-        throw new Error("__REVELA_DESIGNS_PREVIEW_HANDLED__")
-      }
-      if (sub === "domains-add") {
-        await handleDomainsAdd(param, send)
-        throw new Error("__REVELA_DOMAINS_ADD_HANDLED__")
-      }
-      if (sub === "designs-rm") {
-        await handleDesignsRemove(param, send)
-        throw new Error("__REVELA_DESIGNS_RM_HANDLED__")
-      }
-      if (sub === "domains-rm") {
-        await handleDomainsRemove(param, send)
-        throw new Error("__REVELA_DOMAINS_RM_HANDLED__")
-      }
-      if (sub === "pdf") {
-        await handlePdf(param, send, workspaceRoot)
-        throw new Error("__REVELA_PDF_HANDLED__")
-      }
-      if (sub === "pptx") {
-        const args = parsePptxArgs(param)
-        if (args.notes) {
-          try {
-            const deck = resolvePptxDeck(workspaceRoot, args.filePath)
-            queueWorkflowCommand({
-              sessionID,
-              name: "pptx --notes",
-              mode: "deck-render",
-              visibleText: "Export Revela deck to PPTX with speaker notes.",
-              hiddenPrompt: buildPptxNotesPrompt(deck),
-              output,
-            })
-            return
-          } catch (e) {
-            const msg = e instanceof Error ? e.message : String(e)
-            await send(`**PPTX export failed**\n\n\`\`\`\n${msg}\n\`\`\``)
-            throw new Error("__REVELA_PPTX_HANDLED__")
-          }
+      if (sub === "story") {
+        const parsed = parseStoryArgs(param)
+        if (!parsed.ok) {
+          await send(parsed.error)
+          throw new Error("__REVELA_STORY_USAGE_HANDLED__")
         }
-        await handlePptx(param, send, workspaceRoot)
-        throw new Error("__REVELA_PPTX_HANDLED__")
+        queueWorkflowCommand({
+          sessionID,
+          name: "story",
+          mode: "narrative",
+          visibleText: "Open Revela story workspace.",
+          hiddenPrompt: buildNarrativeViewPrompt({ workspaceRoot, language: parsed.args.language }),
+          output,
+        })
+        return
       }
 
       await send(`**Unknown sub-command:** \`${sub}\`\nRun \`/revela\` to see available commands.`)
@@ -817,7 +676,7 @@ const server: Plugin = (async (pluginCtx) => {
         // This prevents a silent "revela enabled but not working" scenario.
         output.system.push(
           "\n\n[REVELA ERROR: Failed to load the slide generation prompt. " +
-          "Run /revela disable then /revela enable to reinitialize.]"
+          "Run /revela to confirm the plugin is available, then retry the workflow command.]"
         )
       }
     },

package/skill/NARRATIVE_SKILL.md

@@ -10,7 +10,7 @@ You help the user turn source materials, research, data, and intent into trusted
 
 Decks are important, but they are render targets. The durable source of truth is the canonical narrative state: audience, decision, thesis, claims, evidence boundaries, objections, risks, research gaps, approval provenance, and artifact coverage.
 
-Default mode is narrative-first. Do not generate HTML slides, choose layouts, fetch design CSS/components, or ask for slide count unless the user explicitly enters a make-deck workflow or asks for design work.
+Default mode is narrative-first. Do not generate HTML slides, choose layouts, fetch design CSS/components, or ask for slide count unless the user explicitly enters `/revela make --deck` or asks for design work.
 
 ## Workflow Model
 
@@ -20,24 +20,22 @@ Use the same phase semantics whether the user invokes a slash command or asks in
 - `Research` runs closed loops to fill open story gaps, bind supported findings into canonical evidence, narrow overbroad claims/relations, and reduce caveats without crossing evidence boundaries.
 - `Story` opens the read-only story workspace UI for inspecting claim flow, evidence strength, unsupported scope, caveats, objections, risks, research gaps, approval state, and affected artifacts.
 - `Make` renders an artifact from approved or explicitly overridden narrative state. Supported 0.15 targets are deck and executive brief.
-- `Refine` is the post-artifact workspace for reading, inspection, and targeted editing. Pure visual polish may patch artifacts; meaning changes must update narrative first and then remake the artifact.
+- `Review` is the post-artifact workspace for reading, insight, and targeted commenting. Pure visual polish may patch artifacts; meaning changes must update narrative first and then remake the artifact.
 
 Public command surface:
 
 - `/revela init`
 - `/revela research`
 - `/revela story`
-- `/revela make deck`
-- `/revela make brief`
-- `/revela refine`
+- `/revela make --deck`
+- `/revela make --brief`
+- `/revela review --deck`
+- `/revela export --deck pdf`
+- `/revela export --deck pptx`
 - `/revela design`
+- `/revela domain`
 
-Compatibility aliases:
-
-- `/revela review` means a legacy story readiness report
-- `/revela narrative` means `/revela story`
-- `/revela deck` means `/revela make deck`
-- `/revela brief` means `/revela make brief`
+Deprecated compatibility aliases such as `/revela review`, `/revela narrative`, `/revela deck`, `/revela brief`, `/revela inspect`, `/revela edit`, `/revela pdf`, `/revela pptx`, `/revela designs*`, and `/revela domains*` are no longer public commands. Direct users to `/revela` for current REVELA Help.
 
 ## Workspace State
 
@@ -87,7 +85,7 @@ During research:
 
 When the user invokes `/revela story`, open the read-only story workspace UI. Do not turn that command into a blocking readiness report.
 
-When the user invokes `/revela review` or explicitly asks for a readiness report, call `revela-decks` action `reviewNarrative` and report the tool result as authoritative.
+When the user explicitly asks for a readiness report, call `revela-decks` action `reviewNarrative` and report the tool result as authoritative.
 
 Use this report shape:
 
@@ -104,7 +102,7 @@ If the narrative is ready for approval, ask the user whether to approve or revis
 
 ## Make Rules
 
-For `/revela make deck` and compatible deck handoff:
+For `/revela make --deck` deck handoff:
 
 - switch to deck-render mode through the command workflow
 - check narrative readiness and current approval before compiling deck specs
@@ -113,22 +111,22 @@ For `/revela make deck` and compatible deck handoff:
 - fetch design layouts/components only after narrative handoff is valid
 - keep the HTML deck contract valid: one `<section class="slide">` per slide, canonical 1-based `data-slide-index`, and matching `DECKS.json` slide specs
 
-For `/revela make brief`, render the executive brief from canonical narrative state and graph-backed claim/evidence relationships, not from a deck summary.
+For `/revela make --brief`, render the executive brief from canonical narrative state and graph-backed claim/evidence relationships, not from a deck summary.
 
-If story readiness, approval, evidence, or artifact blockers remain, report the blocker and suggest `/revela review`, `/revela research`, or a targeted user answer. Do not bypass with invented state.
+If story readiness, approval, evidence, or artifact blockers remain, report the blocker and suggest `/revela story`, `/revela research`, or a targeted user answer. Do not bypass with invented state.
 
-## Refine Rules
+## Review Rules
 
-Use `/revela refine` for post-artifact reading, inspection, and editing.
+Use `/revela review --deck` for post-artifact reading, insight, and commenting.
 
 - Reading should explain source, support strength, caveat, unsupported scope, narrative purpose, related risks/objections, research gaps, and artifact coverage.
 - Pure artifact polish may stay artifact-level: layout, typography, spacing, crop, visual hierarchy, export mechanics, and deck contract fixes.
 - Meaning-changing edits must update canonical narrative first, then run story readiness/approval or explicit override, then remake affected artifacts.
-- `/revela edit` has been removed; use `/revela refine`. Deprecated `/revela inspect` routes to Refine.
+- `/revela edit` and `/revela inspect` have been removed from the public surface; use `/revela review --deck`.
 
 ## Design Surface
 
-Use `/revela design` for visual-system work: list/use/new/edit/preview/install/remove designs.
+Use `/revela design` for visual-system work: list, `--use`, `--new`, `--edit`, `--preview`, `--add`, and `--rm` designs. Use `/revela domain` for domain list, `--use`, `--add`, and `--rm`.
 
 Do not inject design CSS, layout catalogs, component indexes, chart rules, or deck HTML skeletons during init, research, or story. Fetch design context only for make-deck or explicit design-authoring workflows.