slidemind 0.1.4 → 0.1.6

package/CLAUDE.md

@@ -64,7 +64,7 @@ slidemind/
 ├── .claude-plugin/
 │   └── plugin.json               Claude Code plugin manifest
 ├── bin/
-│   └── slidemind.mjs             CLI dispatcher (presentations, download-bundle, init, build, build-pptx, push, ls engines, search, insert-slide, add-slide, install, pair/whoami/use/logout)
+│   └── slidemind.mjs             CLI dispatcher (presentations, read, download-bundle, init, build, build-pptx, view-draft, push, ls engines, search, insert-slide, add-slide, install, pair/whoami/use/logout)
 ├── skills/                       canonical, installable skill payload — thin CLI workflow glue only
 │   ├── create-slides/
 │   │   └── SKILL.md              authoring skill: host gate + intake/plan + create flow + CLI⇄in-app command map.
@@ -77,7 +77,7 @@ slidemind/
 ├── src/                          implementation of the slidemind CLI
 │   ├── bridge/                   add-in local-bridge: client.mjs, bundle.mjs (materialize), build-and-push.mjs (server render; native-slide splicing)
 │   ├── builders/                 build.mjs (HTML preview), review.mjs (spatial preview-review gate + local server), resolve-skill.mjs (→ bundle), lint.mjs (runs the add-in's engine)
-│   ├── mcp/                      MCP server: list/push + list_engines/search_engine/view_slide/insert_slide/add_slide_to_deck/download_result
+│   ├── mcp/                      MCP server: list/read/push + list_engines/search_engine/view_slide/insert_slide/add_slide_to_deck/download_result
 │   └── installers/               per-harness installers: claude.mjs, codex.mjs, opencode.mjs, lib.mjs
 ├── archive/                      retired code/assets (local exporter, icon library, brand design files) — NOT shipped
 ├── decks/                        the user's working decks; sources are slides/*.jsx, design via .bundle-ref.json
@@ -93,11 +93,13 @@ We **do not** ship separate slash commands. Earlier versions had a top-level `co
 
 ```bash
 slidemind presentations            # list PowerPoint windows registered with the add-in
+slidemind read [presId]            # pull the current content of an open presentation (--mode summary|raw) (HOST REQUIRED)
 slidemind download-bundle [deck]   # materialize the active corporate design's bundle locally
 slidemind new <name>               # scaffold ./decks/<name>/
 slidemind build <deck>             # build self-contained HTML preview
 slidemind review <deck>            # spatial preview-review gate; blocks for approve/comments (host-free)
 slidemind build-pptx <deck>        # render native .pptx via the add-in (HOST REQUIRED)
+slidemind view-draft <deck>        # render the deck's slides to per-slide PNGs so the agent can look before review; no push, no .pptx (host-free once the bundle is materialized)
 slidemind push <deck>              # render + push slides into a running PowerPoint (HOST REQUIRED)
 slidemind ls engines               # list the live engine catalog (image + slide; --type/--subtype) (HOST REQUIRED)
 slidemind search "<query>"         # search an engine for imagery or slides (--engine/--intent/--top) (HOST REQUIRED)
@@ -144,7 +146,9 @@ slidemind build <deck>            # HTML preview (reads the materialized bundle)
 slidemind build <deck> --open     # HTML + open in browser
 slidemind review <deck>           # spatial preview-review gate; blocks until approve/comments (host-free)
 slidemind build-pptx <deck>       # native PPTX rendered server-side via the add-in (host required)
+slidemind view-draft <deck>       # per-slide PNG draft preview, no push/no .pptx — the agent's look-before-review self-check (host-free once the bundle is cached)
 slidemind push <deck>             # render + push into a running PowerPoint (host required)
+slidemind read [presId]           # pull current content of an open presentation (--mode summary|raw) (host required)
 slidemind ls engines             # list the live engine catalog (image + slide) (host required)
 slidemind search "<query>"        # search an engine for imagery or slides (host required)
 slidemind insert-slide [opts]     # reuse found slide(s) live into a window (host required)

package/README.md

@@ -128,21 +128,23 @@ npx slidemind <command>
 
 The CLI talks to PowerPoint through the add-in's cloud relay, so you pair once per machine.
 
-1. In PowerPoint, open the **slidemind add-in** task pane and click **"Connect CLI"**.
-2. It shows a one-time command. Copy and run it:
+1. In PowerPoint, open the **slidemind add-in** task pane → **Settings → General → Connect CLI**, and press **Pair**.
+2. It shows a one-time command (it expires in ~10 min — press **Pair** again for a fresh one). Copy and run it:
 
    ```bash
    slidemind pair <code>
    ```
 
-3. Verify the link:
+3. **Restart the add-in once.** Pairing turns CLI integration on, but the task pane that's already running may not pick up the connection — so close the slidemind task pane and reopen it from the ribbon (if needed, reopen the presentation). The wizard doesn't prompt for this, but a freshly-booted pane is what registers your window with the CLI.
+
+4. Verify the link:
 
    ```bash
    slidemind whoami          # lists the paired environment(s)
    slidemind presentations   # lists open PowerPoint windows the add-in sees
    ```
 
-If `slidemind presentations` is empty, the add-in isn't reachable — open PowerPoint with the slidemind add-in and an active corporate design, then retry.
+If `slidemind presentations` is empty even though PowerPoint is open with the add-in and an active corporate design, restart the add-in (step 3) and retry.
 
 ```bash
 slidemind logout            # unpair this machine
@@ -158,6 +160,7 @@ slidemind build my-deck           # build a self-contained HTML preview (offline
 slidemind review my-deck          # spatial preview review: leave comments / approve in the browser (offline)
 slidemind build-pptx my-deck      # render a native .pptx via the add-in (host required)
 slidemind push my-deck            # stream slides straight into an open PowerPoint (host required)
+slidemind read <presId>           # pull the current content of an open presentation (host required)
 slidemind ls engines              # list the active design's image + slide engines (host required)
 slidemind search "shield"         # search an engine for imagery or slides (host required)
 slidemind insert-slide ...        # reuse a found slide live into an open PowerPoint (host required)
@@ -191,6 +194,8 @@ slidemind new <name>             Scaffold ./decks/<name>/
 slidemind build <deck>           Build a self-contained HTML preview (offline)
 slidemind review <deck>          Spatial preview review; blocks for approve/comments (offline)
 slidemind build-pptx <deck>      Render a native .pptx via the add-in        (host required)
+slidemind view-draft <deck>      Render slides to per-slide PNGs, no push — look before review (offline once cached)
+                                 --to <presId> --out <dir> --open
 slidemind push <deck>            Build + push slides into an open PowerPoint  (host required)
 slidemind ls engines             List the live engine catalog (image + slide) (host required)
 slidemind search "<query>"       Search an engine for imagery or slides       (host required)
@@ -201,6 +206,8 @@ slidemind add-slide [opts]       Fold reused slide results into a deck as native
                                  --search <id> --pick <n[,n,...]> --deck <deck> [--to <presId>] [--at <N>]
 slidemind download-bundle [deck] Materialize the active corporate design locally (host required)
 slidemind presentations          List PowerPoint windows registered with the add-in
+slidemind read [presId]          Pull the current content of an open presentation (host required)
+                                 --mode summary|raw (default raw) [--to <presId>] [--json]
 slidemind pair <code>            Pair with an add-in (copy the code from "Connect CLI")
 slidemind whoami                 Show paired environment(s)
 slidemind use <url|env>          Set the default environment
@@ -287,7 +294,8 @@ Equivalently: `npm install -g slidemind@latest && slidemind init --for all`.
 | `slidemind: command not found` (or not recognized) | The npm global bin isn't on your `PATH`. Run `npm prefix -g` and add its `bin` (Windows: `%APPDATA%\npm`) to `PATH`, or use `npx slidemind`. |
 | PowerShell: *running scripts is disabled* | npm's `.ps1` shim hit the execution policy. Use `slidemind.cmd <command>`, or `Set-ExecutionPolicy -Scope CurrentUser RemoteSigned`. |
 | `slidemind presentations` is empty | The add-in isn't reachable. Open PowerPoint with the slidemind add-in and an active corporate design; click the task pane once to re-register, then retry. |
-| `Not paired` | Run `slidemind pair <code>` using the code from the add-in's **"Connect CLI"**. Codes are one-time and expire — generate a fresh one if it's stale. |
+| `slidemind presentations` is empty right after pairing (PowerPoint + add-in already open) | The just-paired task pane never registered. **Restart the add-in** — close the slidemind task pane and reopen it from the ribbon (or reopen the presentation). The pairing wizard doesn't prompt for this. |
+| `Not paired` | In the add-in, open **Settings → General → Connect CLI**, press **Pair**, and run the shown `slidemind pair <code>`. Codes are one-time and expire — generate a fresh one if it's stale. |
 | `build-pptx` / `push` / `search` error about no host | These require an open PowerPoint host with an active corporate design. `slidemind build` (HTML) is the only fully-offline preview. |
 | `EACCES` on `npm install -g` (macOS/Linux) | Don't `sudo npm`. Use a user-owned Node via [nvm](https://github.com/nvm-sh/nvm) or Homebrew, or set a user-writable npm prefix. |
 

package/bin/slidemind.mjs

@@ -10,6 +10,7 @@
 //   slidemind build <deck>            build self-contained HTML deck
 //   slidemind review <deck>           spatial preview-review gate (blocks for approve/comments)
 //   slidemind build-pptx <deck>       render the deck as native .pptx (via the add-in)
+//   slidemind view-draft <deck>       render the deck's slides to per-slide PNGs (no push)
 //   slidemind uninstall --for <target>
 //   slidemind update [--for <target>] [--ref <version>]
 //                                       npm install -g slidemind@latest + redeploy
@@ -52,6 +53,12 @@ function printHelp() {
       `  slidemind build-pptx <deck>      Export native .pptx via the add-in (requires an open host)\n` +
       `                                     --to <presId>   target a specific window (required if >1 open)\n` +
       `                                     --out <path>    output path (default <deck>/<deck>.pptx)\n` +
+      `  slidemind view-draft <deck>      Render the deck's slides to per-slide PNGs (no push, no .pptx)\n` +
+      `                                     so the agent can look before review; host-free once the\n` +
+      `                                     bundle is materialized\n` +
+      `                                     --to <presId>   window to fetch the bundle from (only if not cached)\n` +
+      `                                     --out <dir>     output dir (default <deck>/.draft-preview/)\n` +
+      `                                     --open          open each rendered PNG\n` +
       `  slidemind search "<query>"       Search an engine for images or slides (requires an open host)\n` +
       `                                     --engine <id>   engine to search (default: first image engine; required for slides)\n` +
       `                                     --intent <i>    auto | content | visual (slide engines)\n` +
@@ -77,6 +84,12 @@ function printHelp() {
       `                                     --to <presId>   target a specific window\n` +
       `                                     --force         re-download even if the cached bundle is current\n` +
       `  slidemind presentations          List PowerPoint windows registered with the add-in\n` +
+      `  slidemind doctor                 Diagnose CLI/add-in pairing, backend, and pane readiness\n` +
+      `                                     --json          print machine-readable status\n` +
+      `  slidemind read [presId]          Pull the current content of an open presentation (requires a host)\n` +
+      `                                     --mode <m>      summary | raw (default: raw)\n` +
+      `                                     --to <presId>   target a specific window (required if >1 open)\n` +
+      `                                     --json          print the raw content payload\n` +
       `  slidemind push <deck> [opts]     Build deck and push slides into a running PowerPoint\n` +
       `                                     --to <presId>   target a specific window (required if >1 open)\n` +
       `                                     --at <index>    insert after slide N (0-based); default = append\n` +
@@ -247,6 +260,87 @@ async function cmdBuildPptx(rest) {
   }
 }
 
+function dataUriToPng(dataUri) {
+  const m = /^data:image\/png;base64,(.+)$/.exec(dataUri || "");
+  return m ? Buffer.from(m[1], "base64") : null;
+}
+
+async function cmdViewDraft(rest) {
+  const { deck, passthrough } = splitDeckArg(rest, "view-draft");
+  let to = null;
+  let outDir = null;
+  let open = false;
+  for (let i = 0; i < passthrough.length; i++) {
+    const a = passthrough[i];
+    if (a === "--to") {
+      to = passthrough[++i];
+      if (!to) fail("--to expects a presId");
+    } else if (a === "--out" || a === "-o") {
+      outDir = passthrough[++i];
+      if (!outDir) fail("--out expects a directory");
+    } else if (a === "--open") {
+      open = true;
+    } else if (a.startsWith("-")) {
+      fail(`unknown flag: ${a}`);
+    } else {
+      fail(`unexpected argument: ${a}`);
+    }
+  }
+  const deckDir = resolveDeckArg(deck);
+  if (!fs.existsSync(path.join(deckDir, "slides"))) {
+    fail(`expected 'slides/' folder in ${deckDir}`);
+  }
+  // Draft previews are produced locally by the add-in's shipped capture engine
+  // (no push, no .pptx) — the same module that hosts the render+push path.
+  const mod = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "build-and-push.mjs")).href
+  );
+  const result = await mod.viewDraft(deckDir, {
+    presentationId: to,
+    onProgress: renderProgressPrinter(),
+  });
+
+  const previewDir = outDir
+    ? path.resolve(process.cwd(), outDir)
+    : path.join(deckDir, ".draft-preview");
+  fs.mkdirSync(previewDir, { recursive: true });
+
+  const written = [];
+  for (const slide of result.slides ?? []) {
+    const png = slide.dataUri ? dataUriToPng(slide.dataUri) : null;
+    if (png) {
+      const stem = slide.fileName.replace(/\.[^.]+$/, "");
+      const file = path.join(previewDir, `${stem}.png`);
+      fs.writeFileSync(file, png);
+      written.push(file);
+      const flag = slide.status === "degraded" ? " (DEGRADED)" : "";
+      process.stdout.write(`  ${slide.fileName}${flag} → ${file}\n`);
+      if (slide.note) process.stderr.write(`    note: ${slide.note}\n`);
+    } else {
+      process.stdout.write(`  ${slide.fileName} — ${slide.note ?? slide.status}\n`);
+    }
+  }
+  if (written.length === 0) {
+    process.stdout.write(
+      "No draft preview images were produced (no freeform slides to capture).\n",
+    );
+  } else {
+    process.stdout.write(
+      `Wrote ${written.length} draft preview${written.length === 1 ? "" : "s"} to ${previewDir} — NOT pushed. ` +
+        "Fix anything visibly wrong in the JSX, then re-run, or 'slidemind review' / 'push' when sound.\n",
+    );
+  }
+  for (const w of result.warnings ?? []) {
+    process.stderr.write(`  warning: ${w}\n`);
+  }
+  if (open && written.length > 0) {
+    const { openInBrowser } = await import(
+      pathToFileURL(path.join(BUILDERS_DIR, "build.mjs")).href
+    );
+    for (const file of written) openInBrowser(file);
+  }
+}
+
 async function cmdSearch(rest) {
   let asJson = false;
   let to = null;
@@ -298,7 +392,7 @@ async function cmdSearch(rest) {
   const bundle = await import(
     pathToFileURL(path.join(SRC_DIR, "bridge", "bundle.mjs")).href
   );
-  const registry = await client.requireHost();
+  const registry = await client.requirePaneHost();
   // The engine is per-user, not window-bound — so search just attaches to any
   // connected window (preferring a live one). No "which window?" prompt; pass
   // --to only to pin a specific one. The chosen window is printed below so
@@ -336,15 +430,20 @@ async function cmdSearch(rest) {
     subtype = "image";
   }
 
-  const res = await client.engineSearch({
-    presId,
+  // Window-agnostic: tries the picked pane, then fails over to any other live
+  // window on the same backend if it's suspended/frozen. The answering window
+  // (res.presId) is what reuse must target — the searchId is bound to it.
+  const res = await client.engineSearchAnyPane({
+    registry,
+    explicitPresId: to,
     engineId,
     query,
     subtype,
     intent: intent ?? null,
     top: top ?? null,
-    backendURL,
   });
+  const ranPresId = res?.presId ?? presId;
+  const ranEntry = registry.find((p) => p.presId === ranPresId) ?? entry;
   if (asJson) {
     process.stdout.write(`${JSON.stringify(res, null, 2)}\n`);
     return;
@@ -387,14 +486,14 @@ async function cmdSearch(rest) {
   // add-ins that don't echo a top-level subtype.
   const isSlideResults =
     res.subtype === "slide" || results.some((r) => r.kind === "slide");
-  const envTag = entry.env ? ` [${entry.env}]` : "";
+  const envTag = ranEntry.env ? ` [${ranEntry.env}]` : "";
   if (isSlideResults) {
     // The searchId is bound to the window the search ran on — reuse must target
     // that same window, so spell out its presId in the next-step commands.
     process.stdout.write(
-      `searchId ${res.searchId} ran on window ${presId}${envTag} — reuse from THIS window:\n` +
-        `  slidemind insert-slide --search ${res.searchId} --pick <n> --to ${presId}\n` +
-        `  slidemind add-slide --search ${res.searchId} --pick <n> --deck <deck> --to ${presId}\n`,
+      `searchId ${res.searchId} ran on window ${ranPresId}${envTag} — reuse from THIS window:\n` +
+        `  slidemind insert-slide --search ${res.searchId} --pick <n> --to ${ranPresId}\n` +
+        `  slidemind add-slide --search ${res.searchId} --pick <n> --deck <deck> --to ${ranPresId}\n`,
     );
   } else {
     process.stdout.write(
@@ -517,7 +616,7 @@ async function cmdInsertSlide(rest) {
   const client = await import(
     pathToFileURL(path.join(SRC_DIR, "bridge", "client.mjs")).href
   );
-  const registry = await client.requireHost();
+  const registry = await client.requirePaneHost();
   const entry = client.pickPresentationEntry(registry, to);
   const res = await client.insertSlideLive({
     presId: entry.presId,
@@ -578,7 +677,7 @@ async function cmdAddSlide(rest) {
   const client = await import(
     pathToFileURL(path.join(SRC_DIR, "bridge", "client.mjs")).href
   );
-  const registry = await client.requireHost();
+  const registry = await client.requirePaneHost();
   // The searchId is presentation-scoped, so --to targets the window the search
   // ran on. Without it, a registry with >1 open window is a dead-end.
   const entry = client.pickPresentationEntry(registry, to);
@@ -651,7 +750,7 @@ async function cmdDownloadBundle(rest) {
   const deckRef = positional[0]
     ? bundle.readDeckBundleRef(resolveDeckArg(positional[0]))
     : null;
-  const registry = await client.requireHost();
+  const registry = await client.requireRenderHost();
   const entry = client.pickPresentationEntry(registry, to, {
     preferBrandId: deckRef?.presFP ?? null,
   });
@@ -709,7 +808,185 @@ async function cmdPresentations(rest) {
   for (const p of list) {
     const label = p.title || p.fileName || "(untitled)";
     const env = p.env ? `[${p.env}]\t` : "";
-    process.stdout.write(`${p.presId}\t${env}${label}\n`);
+    const state =
+      p.connectionState ||
+      (p.connected === false || p.suspendedAt ? "suspended" : "connected");
+    const design = p.designState ? `\tcd:${p.designState}` : "";
+    process.stdout.write(`${p.presId}\t${env}${label}\t${state}${design}\n`);
+  }
+}
+
+function publicConnectionStatus(status, client) {
+  return {
+    paired: status.paired,
+    backendCount: status.backendCount,
+    backends: (status.backends ?? []).map((b) => ({
+      env: b.env,
+      ok: b.ok,
+      readinessV1: b.readinessV1 === true,
+      capabilities: b.capabilities ?? null,
+      error: b.error,
+      summary: b.summary ?? null,
+      presentations: (b.presentations ?? []).map(client.toPublicPresentation),
+    })),
+    presentations: (status.presentations ?? []).map(client.toPublicPresentation),
+  };
+}
+
+function connectionNextAction(pub) {
+  if (!pub.paired) {
+    return 'Not paired. In the add-in open Settings → General → Connect CLI, press Pair, then run the shown `slidemind pair <code>`.';
+  }
+  if ((pub.backends ?? []).every((b) => !b.ok)) {
+    return "Every paired backend is unreachable. Check network/VPN/backend status, or re-pair if the environment moved.";
+  }
+  if ((pub.presentations ?? []).length === 0) {
+    return "No PowerPoint window is registered. Open PowerPoint, load the slidemind add-in, and activate or create a corporate design.";
+  }
+  const renderReady = pub.presentations.some(
+    (p) =>
+      p.capabilities?.render === true ||
+      (!p.connectionState && p.connected !== false) ||
+      p.designState === "ready",
+  );
+  if (!renderReady) {
+    return "PowerPoint is connected, but no window is render-ready. Wait for corporate design matching or activate/create a corporate design.";
+  }
+  const paneReady = pub.presentations.some(
+    (p) =>
+      p.capabilities?.paneOps === true ||
+      ((!p.connectionState || p.connectionState === "connected") &&
+        p.connected !== false &&
+        !p.suspendedAt),
+  );
+  if (!paneReady) {
+    return "Rendering is available, but pane operations are suspended. Bring PowerPoint forward and click/reopen the slidemind pane before push/search/read.";
+  }
+  return "Ready.";
+}
+
+async function cmdDoctor(rest) {
+  const asJson = rest.includes("--json");
+  const cfg = await loadBridgeModule("config");
+  const sessions = cfg.readSessions();
+  const client = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "client.mjs")).href
+  );
+  if (sessions.length === 0) {
+    const pub = {
+      paired: false,
+      backendCount: 0,
+      backends: [],
+      presentations: [],
+      nextAction: connectionNextAction({ paired: false }),
+    };
+    process[asJson ? "stdout" : "stderr"].write(
+      asJson ? `${JSON.stringify(pub, null, 2)}\n` : `${pub.nextAction}\n`,
+    );
+    return;
+  }
+  const status = publicConnectionStatus(await client.connectionStatus(), client);
+  status.nextAction = connectionNextAction(status);
+  if (asJson) {
+    process.stdout.write(`${JSON.stringify(status, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`Paired backends: ${status.backendCount}\n`);
+  for (const b of status.backends) {
+    process.stdout.write(
+      `  ${b.env}: ${b.ok ? "reachable" : `unreachable — ${b.error}`}` +
+        (b.readinessV1 ? " (readiness)" : " (legacy)") +
+        `\n`,
+    );
+  }
+  if (status.presentations.length === 0) {
+    process.stdout.write("Open presentations: none\n");
+  } else {
+    process.stdout.write("Open presentations:\n");
+    for (const p of status.presentations) {
+      const label = p.title || p.fileName || "(untitled)";
+      const state =
+        p.connectionState ||
+        (p.connected === false || p.suspendedAt ? "suspended" : "connected");
+      const design = p.designState || (p.brandId ? "ready" : "unknown");
+      const caps = p.capabilities
+        ? ` render:${p.capabilities.render === true ? "yes" : "no"} pane:${p.capabilities.paneOps === true ? "yes" : "no"}`
+        : "";
+      process.stdout.write(
+        `  ${p.presId}\t${p.env ? `[${p.env}] ` : ""}${label}\t${state}\tcd:${design}${caps}\n`,
+      );
+    }
+  }
+  process.stdout.write(`Next action: ${status.nextAction}\n`);
+}
+
+// Pull the current content of an open presentation. Content is window-bound, so
+// pick exactly one window (positional presId or --to; pickPresentationEntry errors
+// listing the windows if several are open and none was named). `--mode summary`
+// prints a per-slide outline; default `raw` prints each slide's plain text.
+async function cmdRead(rest) {
+  let presId = null;
+  let mode = "raw";
+  let asJson = false;
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === "--mode") {
+      const next = rest[++i];
+      if (next !== "summary" && next !== "raw") {
+        fail(`--mode expects 'summary' or 'raw', got '${next ?? ""}'`);
+      }
+      mode = next;
+    } else if (a === "--to") {
+      presId = rest[++i];
+      if (!presId) fail("--to expects a presId");
+    } else if (a === "--json") {
+      asJson = true;
+    } else if (a.startsWith("-")) {
+      fail(`unknown flag: ${a}`);
+    } else if (!presId) {
+      presId = a; // positional presId
+    } else {
+      fail(`unexpected argument: ${a}`);
+    }
+  }
+  const client = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "client.mjs")).href
+  );
+  const registry = await client.requirePaneHost();
+  const entry = client.pickPresentationEntry(registry, presId);
+  const res = await client.getPresentationContent({
+    presId: entry.presId,
+    mode,
+    backendURL: entry.backendURL ?? null,
+  });
+  if (!res?.ok) {
+    fail(`read failed: ${res?.error ?? "unknown error"}`);
+  }
+  if (asJson) {
+    process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+    return;
+  }
+  const slides = Array.isArray(res.slides) ? res.slides : [];
+  if (slides.length === 0) {
+    process.stderr.write("(presentation has no slides)\n");
+    return;
+  }
+  if (res.mode === "summary") {
+    for (const s of slides) {
+      const label = s.title || "(untitled)";
+      const sub = s.subtitle ? ` — ${s.subtitle}` : "";
+      const layout = s.layout ? `  [${s.layout}]` : "";
+      process.stdout.write(
+        `${String(s.index).padStart(3)}.${layout}  ${label}${sub}\n`,
+      );
+    }
+  } else {
+    slides.forEach((s, i) => {
+      if (i > 0) process.stdout.write("\n");
+      const layout = s.layout ? ` (${s.layout})` : "";
+      process.stdout.write(`── Slide ${s.index}${layout} ──\n`);
+      process.stdout.write(`${s.text && s.text.length ? s.text : "(no text)"}\n`);
+    });
   }
 }
 
@@ -760,8 +1037,30 @@ async function cmdPair(rest) {
     others > 0
       ? ` (${sessions.length} environments connected — commands now fan out across all of them)`
       : "";
+  let verify = "";
+  try {
+    const client = await import(
+      pathToFileURL(path.join(SRC_DIR, "bridge", "client.mjs")).href
+    );
+    const deadline = Date.now() + 8000;
+    for (;;) {
+      const status = await client.connectionStatus();
+      if ((status.presentations ?? []).length > 0) {
+        verify = " Pane is registered.";
+        break;
+      }
+      if (Date.now() >= deadline) {
+        verify =
+          " No pane is registered yet; if PowerPoint is already open, reopen or click the slidemind task pane, then run 'slidemind doctor'.";
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+  } catch {
+    // Pairing itself succeeded; diagnostics remain available via doctor.
+  }
   process.stdout.write(
-    `Paired with ${label || env}${suffix}. Run 'slidemind presentations' to verify.\n`,
+    `Paired with ${label || env}${suffix}.${verify} Run 'slidemind doctor' to verify.\n`,
   );
 }
 
@@ -1187,6 +1486,9 @@ async function main(rawArgv) {
     case "build-pptx":
       await cmdBuildPptx(rest);
       return 0;
+    case "view-draft":
+      await cmdViewDraft(rest);
+      return 0;
     case "search":
       await cmdSearch(rest);
       return 0;
@@ -1220,6 +1522,14 @@ async function main(rawArgv) {
     case "presentations":
       await cmdPresentations(rest);
       return 0;
+    case "doctor":
+    case "connection":
+    case "status":
+      await cmdDoctor(rest);
+      return 0;
+    case "read":
+      await cmdRead(rest);
+      return 0;
     case "push":
       await cmdPush(rest);
       return 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slidemind",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Connect Claude Code, Codex & opencode to the slidemind PowerPoint add-in — let your coding agent build and edit native, on-brand PowerPoint decks against your active corporate design, from the terminal.",
   "type": "module",
   "bin": {