@cyber-dash-tech/revela 0.14.0 → 0.15.0

package/lib/commands/enable.ts

@@ -1,7 +1,7 @@
 /**
  * lib/commands/enable.ts
  *
- * Handler for `/revela enable` — activates Revela narrative/artifact mode.
+ * Handler for `/revela enable` — activates Revela ambient narrative mode.
  */
 
 import { existsSync } from "fs"
@@ -19,7 +19,7 @@ export async function handleEnable(
   const design = activeDesign()
   const domain = activeDomain()
 
-  // Always rebuild narrative mode on enable. A prior `/revela deck` handoff may
+  // Always rebuild narrative mode on enable. A prior `/revela make deck` handoff may
   // have intentionally switched the active prompt to deck-render mode.
   if (!existsSync(ACTIVE_PROMPT_FILE)) {
     log.warn("active prompt file missing on enable — rebuilding", { promptFile: ACTIVE_PROMPT_FILE })
@@ -30,7 +30,7 @@ export async function handleEnable(
   } catch (e) {
     log.error("prompt rebuild failed on enable", { error: e instanceof Error ? e.message : String(e) })
     await send(
-      `**Revela enabled (with warnings).** Narrative/artifact mode is active, ` +
+      `**Revela ambient mode enabled (with warnings).** Narrative mode is active for normal chat, ` +
       `but the prompt file could not be built. ` +
       `Try \`/revela disable\` then \`/revela enable\` again, or check that the package is correctly installed.\n\n` +
       `Design: \`${design}\` · Domain: \`${domain}\``
@@ -40,9 +40,9 @@ export async function handleEnable(
 
   log.info("revela enabled", { design, domain })
   await send(
-    `**Revela enabled.** Narrative/artifact mode is now active.\n` +
+    `**Revela ambient mode enabled.** Normal chat will stay in Revela narrative mode.\n` +
     `Design: \`${design}\` · Domain: \`${domain}\`\n\n` +
-    `The narrative-first prompt will be injected into every message. ` +
-    `Use \`/revela deck\` when you are ready to enter deck-render mode.`
+    `Explicit workflow commands like \`/revela init\`, \`/revela story\`, and \`/revela make deck\` work without enabling first. ` +
+    `Use \`/revela disable\` to return normal chat to plain OpenCode mode.`
   )
 }

package/lib/commands/help.ts

@@ -24,18 +24,27 @@ export async function handleHelp(
     `🟠 **Domain:** \`${domain}\`\n\n` +
     `---\n\n` +
     `**Commands**\n\n` +
-    `\`/revela enable\`              — enable Revela narrative/artifact mode\n` +
-    `\`/revela disable\`             — disable Revela mode\n` +
+    `\`/revela enable\`              — optional ambient narrative mode for normal chat\n` +
+    `\`/revela disable\`             — disable ambient Revela mode\n` +
     `\`/revela init\`                — initialize or refresh workspace DECKS.json\n` +
-    `\`/revela review\`              — review narrative readiness and approval state\n` +
-    `\`/revela narrative\`           — open read-only narrative workspace map\n` +
-    `\`/revela brief [file.md]\`      — render executive brief from approved narrative\n` +
-    `\`/revela deck\`                — start deck handoff from approved narrative\n` +
-    `\`/revela deck --review\`       — review deck/artifact readiness before writing HTML\n` +
+    `\`/revela research\`            — research, bind evidence, and reduce story gaps\n` +
+    `\`/revela story\`               — open the read-only story workspace UI\n` +
+    `\`/revela review\`              — legacy readiness report for story state\n` +
+    `\`/revela narrative\`           — compatibility alias for /revela story\n` +
+    `\`/revela make deck\`           — make a deck from approved story state\n` +
+    `\`/revela make deck --review\`  — review deck/artifact readiness before writing HTML\n` +
+    `\`/revela make brief [file.md]\` — render executive brief from approved story\n` +
+    `\`/revela deck\`                — compatibility alias for /revela make deck\n` +
+    `\`/revela brief [file.md]\`      — compatibility alias for /revela make brief\n` +
     `\`/revela refine\`              — open unified reading, inspection, and editing workspace\n` +
     `\`/revela edit\`                — deprecated compatibility shim to /revela refine Edit\n` +
     `\`/revela inspect\`             — deprecated compatibility shim to /revela refine Inspect\n` +
     `\`/revela remember <text>\`     — save an explicit preference to DECKS.json\n` +
+    `\`/revela design\`              — list installed designs\n` +
+    `\`/revela design use <name>\`   — activate a design\n` +
+    `\`/revela design new <name>\`   — create a custom design with AI\n` +
+    `\`/revela design edit <name>\`  — refine an existing custom design with AI\n` +
+    `\`/revela design preview [name]\` — open a design preview in browser\n` +
     `\`/revela designs\`             — list installed designs\n` +
     `\`/revela designs <name>\`      — activate a design\n` +
     `\`/revela designs-new <name>\`  — create a new custom design with AI\n` +

package/lib/commands/init.ts

@@ -17,7 +17,7 @@ Goal:
 - Build or update ${DECKS_STATE_FILE}, the workspace-level machine-readable state file for Revela narrative and artifact work.
 - Use the \`revela-decks\` tool for state updates. Do not write or patch ${DECKS_STATE_FILE} directly.
 - Capture stable narrative context first: primary audience, belief before, belief after, decision/action, thesis, central claims, evidence availability, objections, risks, available source materials, existing artifact history, and open questions.
-- Do not treat initialization as permission to write a deck. Narrative readiness is reviewed later by \`/revela review\`; deck/artifact readiness is reviewed by \`/revela deck --review\`.
+- Do not treat initialization as permission to write a deck. Narrative readiness is reviewed later by \`/revela story\`; deck/artifact readiness is reviewed by \`/revela make deck --review\`.
 - Do not require slide count, visual style, design selection, output path, layout choices, or component choices during narrative initialization unless the user explicitly asks to render a deck now.
 - ${DECKS_STATE_FILE} is the compatibility workspace-state file. Deck specs are render-target projections, not the center of initialization.
 

package/lib/commands/research.ts

@@ -0,0 +1,66 @@
+import { DECKS_STATE_FILE } from "../decks-state"
+
+export function buildResearchPrompt({
+  exists,
+  workspaceRoot,
+}: {
+  exists: boolean
+  workspaceRoot?: string
+}): string {
+  const state = exists
+    ? `${DECKS_STATE_FILE} exists. Read it through the revela-decks tool before researching.`
+    : `${DECKS_STATE_FILE} does not exist yet. Do not start broad internet research; initialize the workspace first with /revela init unless the user supplied a specific research question in chat.`
+
+  return `Run Revela closed-loop research.
+
+Goal:
+- Reduce open gaps, unsupported scope, weak evidence, unattached findings, and overextended relation rationale for the current story.
+- Drive research from canonical narrative gaps: unsupported central claims, objections, risks, decision questions, explicit researchGaps, and claim_chain_gap warnings.
+- Treat /revela research as authorization to bind clearly supported findings into canonical evidence without asking for item-by-item user confirmation.
+- Preserve evidence boundaries: eliminate caveats only when evidence or narrower wording actually resolves them; otherwise keep precise caveats visible.
+- Do not write decks, briefs, or design artifacts during research.
+
+Current state:
+- ${state}
+${workspaceRoot ? `- Current workspace root: \`${workspaceRoot}\`` : ""}
+
+Closed-loop workflow:
+1. Call \`revela-decks\` action \`read\`, then \`reviewNarrative\`.
+2. If current research gaps are missing or stale, call \`deriveResearchGaps\` when useful. Do not invent gaps that are not tied to a claim, objection, risk, decision, or narrative issue.
+3. Run up to 3 research loops unless the stop conditions below are met earlier.
+4. At the start of each loop, choose the highest-value 2-3 targets: open/in-progress high-priority gaps, unattached saved findings, unsupported central claims, weak evidence, high-priority objections/risks, and claim_chain_gap relations. Prefer targets that can improve readiness or materially reduce caveats. Do not repeat searches for claims already strongly supported.
+5. If a target already has saved findings, prioritize binding/narrowing before doing more external search.
+6. For targets needing external evidence, mark matching gaps \`in_progress\` with \`revela-decks updateResearchGap\`, then delegate search to the \`revela-research\` subagent. Ask it for source URLs, quotes/snippets, dates or locations when available, caveats, remaining gaps, and a \`## Recommended evidence bindings\` section with claimId, quote, source, supportScope, unsupportedScope, caveat, and strength. Save findings with \`revela-research-save\` under \`researches/{topic}/{axis}.md\` using \`## Data\`, \`## Cases\`, \`## Images\`, and \`## Gaps\` sections as applicable.
+7. After findings are saved or existing findings are selected, read or inspect the findings file. Attach it with \`revela-decks attachResearchFindings\` when it maps to an existing research axis.
+8. Automatically bind evidence when all binding criteria are met. Use \`revela-decks applyEvidenceCandidates\` for concrete candidate ids when available, or \`upsertNarrative\` to preserve canonical evidence bindings with exact source, URL/path, quote/snippet, support scope, unsupported scope, caveat, and strength.
+9. Binding criteria: claimId exists; quote/snippet is traceable to the source and is not invented; source URL or workspace source path is present; supportScope and unsupportedScope are explicit; strength is strong or useful partial; caveat is preserved; binding does not expand the claim beyond the evidence.
+10. If a claim or relation is broader than the evidence, narrow the claim text, supportedScope, unsupportedScope, or relation rationale through \`upsertNarrative\` only when the narrower wording preserves the user's strategic meaning and source boundaries. Do not silently change the decision ask, central recommendation, or approval meaning.
+11. Update matching gaps after binding: use \`evidence_bound\` when canonical evidence was added, \`closed\` when the gap is resolved or non-researchable, \`findings_saved\` only when findings exist but binding criteria are not met, and \`open\` with notes when more external research is still warranted.
+12. Re-run \`reviewNarrative\` after each loop. Compare against the previous loop: fewer open gaps, fewer unattached findings, stronger evidence, narrower unsupported scope, or clearer internal-data caveats should count as progress.
+
+Stop conditions:
+- No open externally researchable gaps remain.
+- All useful saved findings have been attached or evidence-bound.
+- A full loop produces no new bindable evidence, narrower wording, or gap status improvement.
+- Remaining gaps require internal user/company data, confidential sources, or strategic judgment.
+- 3 loops have completed.
+
+Report format:
+- Start with \`Research loop completed after <n> round(s).\`
+- List bound evidence by claim id and count.
+- List gaps closed or moved to evidence_bound.
+- List claims or relations narrowed, with the remaining unsupported scope.
+- List remaining caveats only as one of: \`internal_data_needed\`, \`not_publicly_researchable\`, \`source_quality_limit\`, or \`still_open\`.
+- If no binding happened, say why binding criteria failed and what exact source type is needed next.
+- End with the next smallest story action, not a generic request for user confirmation.
+
+Rules:
+- Do not use primary-agent broad websearch. Use the \`revela-research\` subagent for external search.
+- Do not invent quotes, source paths, URLs, page references, locations, or caveats.
+- Do not treat \`researches/**/*.md\` as canonical evidence until attached or evidence-bound, but do not stop at findings_saved when binding criteria are met.
+- Do not mutate canonical claims merely to fit a source; narrow only to preserve evidence boundaries and avoid overstated claims.
+- Do not ask the user to approve each evidence binding. Ask only when binding would change strategic meaning, downgrade a central claim, rely on suspicious sources, or require narrative approval.
+- Do not store secrets, credentials, tokens, or sensitive personal information.
+
+Start now by reading ${DECKS_STATE_FILE} through \`revela-decks\`, reviewing current readiness, and running the first research/binding loop.`
+}

package/lib/commands/review.ts

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

package/lib/decks-state.ts

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

package/package.json

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

package/plugin.ts

@@ -23,6 +23,7 @@ import { seedBuiltinDomains } from "./lib/domain/domains"
 import { buildPrompt } from "./lib/prompt-builder"
 import { ACTIVE_PROMPT_FILE } from "./lib/config"
 import { ctx } from "./lib/ctx"
+import { formatCommandIntentSystemBlock, setPendingCommandIntent, takePendingCommandIntent } from "./lib/command-intent"
 import { preRead } from "./lib/read-hooks"
 import { postRead } from "./lib/read-hooks"
 import { extractPdfText } from "./lib/read-hooks/extractors/pdf"
@@ -59,6 +60,7 @@ import {
   buildDesignsEditPrompt,
 } from "./lib/commands/designs-new"
 import { buildInitPrompt } from "./lib/commands/init"
+import { buildResearchPrompt } from "./lib/commands/research"
 import { handleBrief, parseBriefArgs } from "./lib/commands/brief"
 import { buildNarrativeViewPrompt, handleNarrative, parseNarrativeArgs } from "./lib/commands/narrative"
 import { parseRememberArgs, buildRememberPrompt } from "./lib/commands/remember"
@@ -206,6 +208,27 @@ const server: Plugin = (async (pluginCtx) => {
     return input?.sessionID ?? input?.session?.id ?? input?.context?.sessionID ?? ""
   }
 
+  function queueWorkflowCommand(input: {
+    sessionID: string
+    name: string
+    mode: "narrative" | "deck-render"
+    visibleText: string
+    hiddenPrompt: string
+    output: any
+  }): void {
+    ctx.enabled = true
+    buildPrompt({ mode: input.mode })
+    setPendingCommandIntent({
+      sessionID: input.sessionID,
+      name: input.name,
+      mode: input.mode,
+      visibleText: input.visibleText,
+      hiddenPrompt: input.hiddenPrompt,
+    })
+    input.output.parts.length = 0
+    input.output.parts.push({ type: "text", text: input.visibleText } as any)
+  }
+
   function ensureEditorOpenAfterDeckChange(filePath: string, sessionID: string): void {
     if (!isDeckHtmlPath(filePath) || !sessionID) return
 
@@ -239,7 +262,7 @@ const server: Plugin = (async (pluginCtx) => {
       opencodeConfig.command ??= {}
       opencodeConfig.command["revela"] = {
         template: "",
-        description: "Revela — AI slide deck generator (enable/disable, manage designs & domains)",
+        description: "Revela — narrative artifact workspace (init, research, story, make, refine, design)",
       }
 
       // Register the research subagent.
@@ -329,12 +352,14 @@ const server: Plugin = (async (pluginCtx) => {
         throw new Error("__REVELA_DISABLE_HANDLED__")
       }
       if (sub === "init") {
-        buildPrompt({ mode: "narrative" })
-        output.parts.length = 0
-        output.parts.push({
-          type: "text",
-          text: buildInitPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot }),
-        } as any)
+        queueWorkflowCommand({
+          sessionID,
+          name: "init",
+          mode: "narrative",
+          visibleText: "Initialize Revela workspace.",
+          hiddenPrompt: buildInitPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot }),
+          output,
+        })
         return
       }
       if (sub === "remember") {
@@ -343,28 +368,73 @@ const server: Plugin = (async (pluginCtx) => {
           await send(parsed.error)
           throw new Error("__REVELA_REMEMBER_USAGE_HANDLED__")
         }
-        buildPrompt({ mode: "narrative" })
-        output.parts.length = 0
-        output.parts.push({
-          type: "text",
-          text: buildRememberPrompt({ memory: parsed.memory, exists: hasDecksState(workspaceRoot) }),
-        } as any)
+        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 reviews the current workspace narrative. Use `/revela deck --review` for deck/artifact readiness.")
+          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__")
         }
-        buildPrompt({ mode: "narrative" })
-        output.parts.length = 0
-        output.parts.push({
-          type: "text",
-          text: buildReviewPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot }),
-        } as any)
+        queueWorkflowCommand({
+          sessionID,
+          name: "review",
+          mode: "narrative",
+          visibleText: "Review Revela story readiness.",
+          hiddenPrompt: buildReviewPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot }),
+          output,
+        })
+        return
+      }
+      if (sub === "story") {
+        if (param) {
+          await send("`/revela story` does not accept arguments yet. It opens the current workspace story UI. Use `/revela review` for a readiness report.")
+          throw new Error("__REVELA_STORY_USAGE_HANDLED__")
+        }
+        queueWorkflowCommand({
+          sessionID,
+          name: "story",
+          mode: "narrative",
+          visibleText: "Open Revela story workspace.",
+          hiddenPrompt: buildNarrativeViewPrompt({ workspaceRoot, language: "en" }),
+          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)
@@ -374,12 +444,14 @@ const server: Plugin = (async (pluginCtx) => {
           await handleNarrative({ workspaceRoot, openBrowser: true, language: parsed.args.language }, send)
           throw new Error("__REVELA_NARRATIVE_HANDLED__")
         }
-        buildPrompt({ mode: "narrative" })
-        output.parts.length = 0
-        output.parts.push({
-          type: "text",
-          text: buildNarrativeViewPrompt({ workspaceRoot, language: parsed.args.language }),
-        } as any)
+        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") {
@@ -391,26 +463,62 @@ const server: Plugin = (async (pluginCtx) => {
         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.")
+            throw new Error("__REVELA_MAKE_DECK_USAGE_HANDLED__")
+          }
+          queueWorkflowCommand({
+            sessionID,
+            name: makeParam ? "make deck --review" : "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 }),
+            output,
+          })
+          return
+        }
+        if (target === "brief") {
+          const parsed = parseBriefArgs(makeParam)
+          if (!parsed.ok) {
+            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]`.")
+        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.")
+          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) {
-          buildPrompt({ mode: "deck-render" })
-          output.parts.length = 0
-          output.parts.push({
-            type: "text",
-            text: buildDeckPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot }),
-          } as any)
+          queueWorkflowCommand({
+            sessionID,
+            name: "deck",
+            mode: "deck-render",
+            visibleText: "Make Revela deck from approved story.",
+            hiddenPrompt: buildDeckPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot }),
+            output,
+          })
           return
         }
-        buildPrompt({ mode: "deck-render" })
-        output.parts.length = 0
-        output.parts.push({
-          type: "text",
-          text: buildDeckReviewPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot }),
-        } as any)
+        queueWorkflowCommand({
+          sessionID,
+          name: "deck --review",
+          mode: "deck-render",
+          visibleText: "Review Revela deck artifact readiness.",
+          hiddenPrompt: buildDeckReviewPrompt({ exists: hasDecksState(workspaceRoot), workspaceRoot }),
+          output,
+        })
         return
       }
       if (sub === "refine") {
@@ -457,17 +565,94 @@ const server: Plugin = (async (pluginCtx) => {
         await handleDesignsAdd(param, send)
         throw new Error("__REVELA_DESIGNS_ADD_HANDLED__")
       }
+      if (sub === "design") {
+        const designAction = args[1]?.toLowerCase() ?? "list"
+        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__")
+          }
+          await handleDesignsList(send)
+          throw new Error("__REVELA_DESIGN_LIST_HANDLED__")
+        }
+        if (designAction === "use") {
+          if (!designParam) {
+            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 (!designParam) {
+            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 (!designParam) {
+            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") {
+          await handleDesignsPreview(designParam, send)
+          throw new Error("__REVELA_DESIGN_PREVIEW_HANDLED__")
+        }
+        if (designAction === "new") {
+          const parsed = parseDesignsNewArgs(designParam)
+          if (!parsed.ok) {
+            await send(parsed.error.replaceAll("/revela designs-new", "/revela design new"))
+            throw new Error("__REVELA_DESIGN_NEW_USAGE_HANDLED__")
+          }
+          queueWorkflowCommand({
+            sessionID,
+            name: `design new ${parsed.name}`,
+            mode: "deck-render",
+            visibleText: `Create Revela design ${parsed.name}.`,
+            hiddenPrompt: buildDesignsNewPrompt({ name: parsed.name, base: parsed.base }),
+            output,
+          })
+          return
+        }
+        if (designAction === "edit") {
+          const parsed = parseDesignsEditArgs(designParam)
+          if (!parsed.ok) {
+            await send(parsed.error.replaceAll("/revela designs-edit", "/revela design edit"))
+            throw new Error("__REVELA_DESIGN_EDIT_USAGE_HANDLED__")
+          }
+          queueWorkflowCommand({
+            sessionID,
+            name: `design edit ${parsed.name}`,
+            mode: "deck-render",
+            visibleText: `Edit Revela design ${parsed.name}.`,
+            hiddenPrompt: buildDesignsEditPrompt({ name: parsed.name }),
+            output,
+          })
+          return
+        }
+        await send("Usage: `/revela design [list|use <name>|new <name>|edit <name>|preview [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__")
         }
-        output.parts.length = 0
-        output.parts.push({
-          type: "text",
-          text: buildDesignsNewPrompt({ name: parsed.name, base: parsed.base }),
-        } as any)
+        queueWorkflowCommand({
+          sessionID,
+          name: `designs-new ${parsed.name}`,
+          mode: "deck-render",
+          visibleText: `Create Revela design ${parsed.name}.`,
+          hiddenPrompt: buildDesignsNewPrompt({ name: parsed.name, base: parsed.base }),
+          output,
+        })
         return
       }
       if (sub === "designs-edit") {
@@ -476,11 +661,14 @@ const server: Plugin = (async (pluginCtx) => {
           await send(parsed.error)
           throw new Error("__REVELA_DESIGNS_EDIT_USAGE_HANDLED__")
         }
-        output.parts.length = 0
-        output.parts.push({
-          type: "text",
-          text: buildDesignsEditPrompt({ name: parsed.name }),
-        } as any)
+        queueWorkflowCommand({
+          sessionID,
+          name: `designs-edit ${parsed.name}`,
+          mode: "deck-render",
+          visibleText: `Edit Revela design ${parsed.name}.`,
+          hiddenPrompt: buildDesignsEditPrompt({ name: parsed.name }),
+          output,
+        })
         return
       }
       if (sub === "designs-preview") {
@@ -508,8 +696,14 @@ const server: Plugin = (async (pluginCtx) => {
         if (args.notes) {
           try {
             const deck = resolvePptxDeck(workspaceRoot, args.filePath)
-            output.parts.length = 0
-            output.parts.push({ type: "text", text: buildPptxNotesPrompt(deck) } as any)
+            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)
@@ -633,6 +827,11 @@ const server: Plugin = (async (pluginCtx) => {
             error: e instanceof Error ? e.message : String(e),
           })
         }
+        const sessionID = extractSessionID(input)
+        const commandIntent = takePendingCommandIntent(sessionID)
+        if (commandIntent) {
+          prompt += "\n\n" + formatCommandIntentSystemBlock(commandIntent)
+        }
         if (output.system.length > 0) {
           output.system[output.system.length - 1] += "\n\n" + prompt
         } else {