slidemind 0.3.20 → 0.4.0

package/README.md

@@ -298,6 +298,9 @@ slidemind new <name>             Scaffold ./decks/<name>/ (auto-binds to the ope
 slidemind plan <deck>            Plan sign-off gate on <deck>/plan.md; blocks for approve/comments (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)
+                                 A deck connected to SharePoint (the file you opened, or a folder you
+                                 connected in the workspace) is saved there right after the build;
+                                 --no-publish keeps a build local
                                  --pack <dir> for an explicit fill-template pack
 slidemind inspect-template-deck <deck>  Emit a normalized template-deck model for pack validation
                                  --pack <dir> --json [--allow-unrendered-freeform]
@@ -317,10 +320,61 @@ slidemind add-slide [opts]       Fold slide(s) into a deck as native .pptx — f
                                  --from <file.pptx> --pick <n[,n,...]> --deck <deck> [--at <N>]   (local file; host-free; not with --search)
 slidemind download-result [opts] Download image/icon result(s) into a deck's assets/ (host required)
                                  --search <id> --pick <n[,n,...]> --deck <deck> --to <presId> [--icon-color <hex[,hex,...]>]
+slidemind assets <sub>           The deck's registry of images you supplied. Importing records the bytes;
+                                 what the picture is FOR is approved in the plan, not here
+                                 import <deck> <file>   copy a file in and identify it by its own digest
+                                                        (file paths only — never a URL)
+                                 list <deck>            what this deck has registered
+                                 --json on both
 slidemind adopt <file.pptx>      Rebuild a deck workspace from a .pptx — slidemind-authored slides come back
                                  as their original jsx, foreign ones are converted to editable jsx where the
                                  add-in offers it, the rest fold in native
                                  --deck <slug> --brand <presFP> --no-convert
+                                 --slides 2,7 | 2-4 | all   hydrate only those slides to editable jsx;
+                                 every other slide stays a lossless native slide with its notes, comments,
+                                 animations and embeddings intact. Re-running is safe: the same file again
+                                 changes nothing, a wider --slides hydrates just the new slides, and a
+                                 different file is reconciled onto the deck
+slidemind revision <sub> <deck>  Ownership and acceptance for an adopted deck
+                                 begin   take the deck for a whole edit session; export the printed token
+                                         as SLIDEMIND_OWNER so every command under it re-enters
+                                 status  accepted base, generation, changed slides, candidates, conflicts
+                                 accept  --candidate <id> — make a build the deck's new accepted base
+                                 finish  release the session (your work and candidates are kept)
+slidemind rebase <deck>          Move an adopted deck onto a newer copy of the same .pptx — their changes
+                                 apply, your unpublished edits stay yours, and anything both sides touched
+                                 stops for you to decide (nothing is applied until you do)
+                                 --incoming <file.pptx|revisionId> [--dry-run] [--json]
+                                 --resolve <resolution.json>  apply the skeleton a conflict wrote for you
+slidemind open <link|file.pptx>  Open a SharePoint presentation as a deck: the LINK picks the file, one
+                                 consistent snapshot is adopted, and the deck is bound to that item.
+                                 A local path adopts only — it never guesses where to publish
+                                 --deck <slug> --slides 2,7|all
+                                 --rebind   point an already-bound deck at this item instead
+                                 --keep | --detach   local file, on a deck that is already bound
+slidemind pull <deck>            Check the bound file and every linked input it names. Unchanged costs one
+                                 metadata call and downloads nothing. A newer save is kept aside until your
+                                 own work is published, then applied
+                                 --check    report freshness only (never stages, never changes anything)
+slidemind publish <deck>         Save the deck back to the file you opened. It pulls and reconciles first,
+                                 runs every required check on the bytes it is actually about to upload, and
+                                 replaces the file only if nobody saved in the meantime — if somebody did,
+                                 their save is kept and yours is not lost. build-pptx does this for you;
+                                 run it to retry a save that did not go through
+                                 --candidate <id> --manual --shared-workbook --json
+slidemind rename <deck> --name <file>  Rename the file you are bound to. Same file, nothing re-rendered
+slidemind record <sub>           Share ONE JSON file so several people and their agents can edit it at
+                                 once; the backend merges, so different fields combine instead of
+                                 overwriting. The CLI never reads what is in the file
+                                 create <deck> --folder <link> --name <file.json> --file <path>
+                                                    share it and print the permanent link
+                                 open <link> --deck <slug> --file <path>
+                                                    fetch a shared record into a (new) deck
+                                 sync <deck> --file <path> [--approval] [--resolve <file>]
+                                                    send yours, get everyone's back merged; a same-field
+                                                    clash writes state/record-conflicts.json and exits 3
+                                 status <deck>      current | behind (v…) | local edits
+                                 --json on every subcommand
 slidemind download-bundle [deck] Materialize the active corporate design locally (host required; lower-level — `ready` covers this)
 slidemind read [presId|file.pptx] Read an open presentation (presId; host required) or a local .pptx on disk (file path; host-free)
                                  --mode summary|raw (default raw) [--to <presId>] [--json]
@@ -328,7 +382,8 @@ slidemind setup <claim>          One-command onboarding: connect + global instal
                                  --for <target> --no-install --no-ready --json
 slidemind login [--backend <e>]  Sign in to Microsoft 365 (opens your browser) so SharePoint-backed
                                  downloads and slide extractions work without an open PowerPoint window
-slidemind whoami                 Show connected environment(s) and their Microsoft 365 sign-in state
+slidemind whoami [--json]        Show connected environment(s) and their Microsoft 365 sign-in state,
+                                 named as the account that signed in
 slidemind logout [url|env]       Unpair an environment (--all unpairs every one; drops its Microsoft 365 sign-in too)
 slidemind init --for <target>    Install the skill into a harness (clears the bundle cache)
                                  <target> = claude | codex | opencode | all | auto (every harness found here)
@@ -345,19 +400,67 @@ slidemind --version              Print version
 
 | Command | Output | When to use |
 |---|---|---|
-| `slidemind view-draft <deck>` | `decks/<deck>/.draft-preview/*.png` (+ `presentation.html`) | Look at each slide before anyone else does (offline) |
+| `slidemind view-draft <deck>` | `decks/<deck>/.slidemind/preview/draft/*.png` (+ `preview/presentation.html`) | Look at each slide before anyone else does (offline) |
 | `slidemind build-pptx <deck>` | `decks/<deck>/<deck>.pptx` | An editable native PowerPoint file |
 | `slidemind push <deck>` | (streamed via the add-in) | Live insertion into an open PowerPoint window |
 
+### What a deck directory looks like
+
+A deck keeps the two halves apart. The root holds what you asked for; everything
+the CLI works with sits in a hidden `.slidemind/` beside it:
+
+```
+decks/my-deck/
+├── my-deck.pptx        the built deck
+├── plan.html           the saved plan page (open it any time; `slidemind plan my-deck` to edit)
+└── .slidemind/
+    ├── plan.md         the plan record
+    ├── slides/         one .jsx per slide (filename order IS slide order)
+    ├── assets/         images and icons this deck downloaded
+    ├── conversions/    identity records for adopted PowerPoint slides
+    ├── concepts/       the concept mockups
+    ├── state/          gate decisions, slide identity, the design binding
+    └── preview/        presentation.html, fonts/, draft/, build/ — all regenerable
+```
+
+You never need to name `.slidemind/` — every command takes the deck directory and
+finds it. One command manages the directory itself:
+
+```bash
+slidemind clean <deck>     # drop preview/ and abandoned downloads; a build recreates them
+```
+
+`clean` touches nothing a build cannot reproduce: gate decisions, concepts and a
+download still in flight all stay.
+
+`plan.html` has one owner, recorded in `.slidemind/state/plan-owner.json`. The CLI
+renders it from `plan.md`; an extension pack renders
+its own from its own record. Whoever does not own it leaves it alone and names the
+command that opens it, so a pack deck's plan page survives a generic `slidemind
+plan` or `build` untouched.
+
 ### Reviewing before you export
 
-`slidemind review <deck>` opens the HTML preview in your browser with a comment overlay and **waits** until you decide:
+Your agent asks you to review in the **slidemind workspace** — a page on your computer (`127.0.0.1`) that `slidemind setup` starts and keeps running from every login. The agent ends its turn with a link; click it. In the Codex app it opens in Codex's own browser pane, next to the chat; elsewhere in your browser.
+
+- **Plan:** read and edit the storyline, comment on any slide (press Enter to add each comment), then **Send** your comments or **Approve plan**. Approve is off while a comment is waiting to be sent.
+- **Preview:** click any element on a slide to pin a comment to that spot — each is anchored to the exact slide source (`slides/<file>.jsx:line:col`) — then **Send** your comments or **Approve**. On the next round your earlier notes come back as faded "ghost" pins so you can confirm each was addressed.
+- **Then paste.** Your answer is saved and a message is copied to your clipboard. Paste it into the chat with your agent and send it. That is the one thing to do after every answer: nothing can reach an agent whose turn has ended, so the message — which names the deck and the command that receives your answer — brings it back, in the same chat or a new one.
+
+It runs entirely offline (no open PowerPoint needed) — review happens *before* the native render.
 
-- **Click any element** on a slide to leave a comment pinned to that spot. Each comment is anchored to the exact slide source (`slides/<file>.jsx:line:col`), so your agent knows precisely what to change.
-- **Approve & continue** when it looks right — the command unblocks and your agent proceeds to the export you asked for (`push` / `build-pptx`).
-- **Send comments** to hand your notes back to the agent; it edits the cited files and re-runs `review`, where your previous notes appear as faded "ghost" pins so you can confirm each was addressed.
+### The workspace
 
-It runs entirely offline (no open PowerPoint needed) — review happens *before* the native render. There's no copy-paste: the moment you approve or send comments in the browser, your coding agent picks up where it left off.
+One page for everything you answer: a library of your decks, the plan editor, the preview, and an inbox of what your agents asked you to decide. Close the browser — the page and the questions stay; it restarts by itself after a reboot.
+
+- **Add a folder** (or `slidemind workspace add <path>` / `discover <root>`) to see a deck. Nothing is rendered or uploaded because you looked at it.
+- **Paste a SharePoint link** (or `slidemind workspace open-remote <url>`) to open a presentation, a shared plan, or a folder; a folder shows its children and you pick.
+- **Local vs remote saving.** Every edit is saved locally at once. A plan that is shared on SharePoint syncs in the background afterwards; the status reads *Saved → Saving to SharePoint… → Saved to SharePoint*, and *Action needed* when the backend refused, you are signed out, or writes are disabled. Selecting a folder with `connect` only records a destination; the plan is *shared* once it actually exists there.
+- **Conflicts** are shown as mine / theirs / merged with the exact fields; nothing is sent until you resolve them.
+- **Access** is per person: the page uses your own Microsoft 365 sign-in for remote work, and the daemon answers only this machine's browser.
+- **Running it yourself.** `slidemind workspace` prints its link (and opens it in a terminal); `slidemind workspace stop` ends it and keeps everything queued. `SLIDEMIND_WORKSPACE=0` brings back the old standalone review pages.
+
+Both commands are documented in `slidemind --help`; the design is in `docs/slidemind-cli-connect/21-persistent-workspace.md`.
 
 ---
 
@@ -449,3 +552,95 @@ So an open PowerPoint host with the slidemind add-in and an active corporate des
 ---
 
 slidemind is published by **statworx**. Source lives in a private repository; the npm tarball is the install artifact. License: `UNLICENSED` (publicly installable, proprietary).
+
+
+### Concept-based authoring and existing-slide edits
+
+After plan approval, run `slidemind concepts <deck>` then `slidemind transcribe <deck>`.
+Concepts are read into compact specifications; transcription creates editable JSX, settles
+initial geometry and fetches requested assets. Compare the concept and draft images, repair
+`slides/*.jsx`, then run the usual draft, review and delivery commands. Missing assets stay
+explicit. `SLIDEMIND_SPEC_SCHEMA=legacy` supports an older reader deployment.
+
+Existing-slide edits patch current JSX directly. Imported PowerPoint slides retain the
+PPTX → JSX conversion and native-object preservation workflow; they do not need concepts.
+`transcribe --only NN` can settle a generated slide during reconstruction, but may move
+neighbouring content. Do not use it as an automatic step for a small edit or converted slide.
+
+Existing-slide edits are not limited to changing words: adding elements and restructuring
+them is supported. What is protected is what the slide promised to keep.
+
+If a generated slide is right in substance but slightly off in layout, `slidemind transcribe
+<deck> --repair` nudges it back rather than rebuilding it. It runs inside a scope you open first
+(`slidemind revision begin <deck> --operation repair --slides <sel>`), and that scope is what
+authorizes it — the file's own contents never do. What you are agreeing to is bounded and
+measured from the original slide, not from the previous attempt: at most three passes, at most a
+few slot-pixels of movement and a ten-percent size change per element, and **no** change to text,
+images, the number of elements, or what a connector joins. It refuses an imported slide, a slide
+it has no transcription record for, and a slide it cannot parse — each before touching anything.
+
+**Edits cannot quietly drop things.** A deck rebuilt from a PowerPoint file (`slidemind adopt`)
+records, per slide, the elements that have to survive an edit — connectors and what they join,
+images and the file each points at, tables, and preserved native objects. If an edit loses one,
+`slidemind view-draft` names it:
+
+```
+[preserve:warn] 04-pricing — #conn-tier-a-tier-b: missing — is required on this slide and is
+  not in the evidence — restore it in slides/04-pricing.jsx, or supersede the obligation
+  explicitly (`slidemind revision begin pricing --operation targeted-edit`); a final
+  replacement refuses while it stands.
+```
+
+`view-draft` only reports it; `slidemind build-pptx` and `slidemind push` refuse until it is
+resolved. You do **not** have to start a session for this — an adopted deck is protected from
+the moment it is adopted, and a deck you authored from scratch is never gated by it. If you
+meant to remove the element, say so once with
+`slidemind revision begin <deck> --operation targeted-edit --slides <sel>`; that scope is what
+authorizes the removal.
+
+Evidence a draft cannot give is *unknown*, never a pass, and whether it stops the build
+depends on the slide — one deck can hold both kinds:
+
+- **A slide that came from a PowerPoint file** can be checked against that file. Things like a
+  connector's endpoints and a native object's embedded package normally resolve and the build goes
+  ahead. If one of them could have been checked and was not, the build **stops**, the same as for a
+  `[preserve:warn]`.
+- **A slide you authored from scratch** has no original file to check against, so some obligations
+  cannot be proved either way. Those **ship**, with one line naming exactly what was not proved.
+  Stopping there would demand evidence that cannot exist.
+
+The build also stops if you changed a slide and have not run `slidemind view-draft` since, because
+then nothing has checked the bytes you are about to ship.
+
+Both places you can use slidemind follow the same rule — proof is demanded where proof is possible —
+and on most decks they behave identically. A deck you authored has no original file on either side,
+so the same slides ship with the same note whether you build from the command line or the PowerPoint
+add-in. They differ on one case only: a slide that came from a PowerPoint file, which the command
+line can check and the add-in currently cannot. So the add-in is not a way around a refusal — if the
+command line stopped on such a slide, that slide has something to fix.
+
+### Images you supply
+
+An image you hand the agent — a screenshot, a diagram, a photo — is kept as itself. Two steps,
+deliberately separate:
+
+1. **Import the bytes.** `slidemind assets import <deck> <file>` copies the file into the deck and
+   identifies it by its own digest. It takes file paths, never URLs, and it promises nothing about
+   where the picture goes.
+2. **Approve what it is for.** The agent records a *use* on a slide in `plan.md`, and you see it on
+   that slide's card at the plan gate: `original` (place exactly this file), `reconstruct` (rebuild
+   it as editable slide content — the whole slide, or one element inside it), or `reference` (it
+   guides the look; no picture required). One file can have several uses, on several slides.
+
+An `original` is never searched for, regenerated, recoloured or swapped for something similar. If
+its file goes missing or its bytes change, `slidemind view-draft` says so per slide, and
+`slidemind build-pptx` / `slidemind push` refuse until it is restored — including when the add-in
+returned no verdict at all, because a skipped check is not a pass.
+
+This needs a slidemind add-in that supports image intent. On an older deployment a deck with
+approved image uses stops **before** anything is generated, names the capability, and leaves your
+plan and your files exactly as they were. Decks with no image uses are unaffected.
+
+What the checks prove is structural: the right bytes, on the right slide, once, inside the slide,
+not hidden. They cannot prove the picture is visible — something drawn over it would still pass —
+so the draft preview and the review gate remain the place that is caught.

package/bin/slidemind.mjs

@@ -30,19 +30,27 @@ import fs from "node:fs";
 import { register as registerSecret, scrub } from "../src/bridge/secrets.mjs";
 import { announceUpdate } from "../src/update-check.mjs";
 import { readPackageJson, fail } from "../src/cli/common.mjs";
+import { cmdAssets } from "../src/cli/assets.mjs";
 import { cmdConceptImages } from "../src/cli/concepts.mjs";
+import { cmdTranscribe } from "../src/cli/transcribe.mjs";
 import { cmdPlan, cmdReview, cmdImagen, cmdInspectTemplateDeck, cmdBuildPptx, cmdViewDraft } from "../src/cli/deck.mjs";
 import { cmdDownloadBundle } from "../src/cli/download-bundle.mjs";
 import { cmdViewSlide, cmdReadSource, cmdDownloadResult } from "../src/cli/engine-results.mjs";
 import { printHelp } from "../src/cli/help.mjs";
 import { cmdInstall, cmdUninstall, cmdUpdate } from "../src/cli/install.mjs";
+import { cmdClean } from "../src/cli/maintenance.mjs";
 import { cmdRead } from "../src/cli/read.mjs";
+import { cmdRecord } from "../src/cli/record.mjs";
 import { cmdReady } from "../src/cli/ready.mjs";
 import { cmdSearch, cmdLs } from "../src/cli/search.mjs";
 import { cmdLogin, cmdWhoami, cmdLogout } from "../src/cli/session.mjs";
 import { cmdSetup } from "../src/cli/setup.mjs";
 import { cmdInsertSlide, cmdAddSlide } from "../src/cli/slide-reuse.mjs";
 import { cmdAdopt, cmdPush, cmdNew } from "../src/cli/workspace.mjs";
+import { cmdWorkspace } from "../src/cli/workspace-ui.mjs";
+import { cmdTasks } from "../src/cli/tasks.mjs";
+import { cmdRebase, cmdRevision } from "../src/cli/revision.mjs";
+import { cmdOpen, cmdPull, cmdPublish, cmdRename } from "../src/cli/remote.mjs";
 
 // Pull a global `--backend <url|env>` out of argv (it may appear anywhere) and
 // expose it as SLIDEMIND_BACKEND, which scopes the fan-out across paired
@@ -182,9 +190,15 @@ async function main(rawArgv) {
     case "download-result":
       await cmdDownloadResult(rest);
       return 0;
+    case "assets":
+      await cmdAssets(rest);
+      return 0;
     case "concepts":
       await cmdConceptImages(rest);
       return 0;
+    case "transcribe":
+      await cmdTranscribe(rest);
+      return 0;
     case "download-bundle":
       await cmdDownloadBundle(rest);
       return 0;
@@ -209,12 +223,45 @@ async function main(rawArgv) {
     case "read":
       await cmdRead(rest);
       return 0;
+    case "record":
+      await cmdRecord(rest);
+      return 0;
     case "adopt":
       await cmdAdopt(rest);
       return 0;
+    case "workspace":
+      // The persistent local workspace (src/cli/workspace-ui.mjs); sets its own
+      // exit code (0/1/2/3) on process.exitCode instead of throwing.
+      await cmdWorkspace(rest);
+      return 0;
+    case "tasks":
+      // Durable tasks (src/cli/tasks.mjs); exit code on process.exitCode like `workspace`.
+      await cmdTasks(rest);
+      return 0;
+    case "revision":
+      await cmdRevision(rest);
+      return 0;
+    case "rebase":
+      await cmdRebase(rest);
+      return 0;
+    case "open":
+      await cmdOpen(rest);
+      return 0;
+    case "pull":
+      await cmdPull(rest);
+      return 0;
+    case "publish":
+      await cmdPublish(rest);
+      return 0;
+    case "rename":
+      await cmdRename(rest);
+      return 0;
     case "push":
       await cmdPush(rest);
-      return 0;
+      break;
+    case "clean":
+      await cmdClean(rest);
+      break;
     case "init":
     case "install":
       // Set slidemind up in a coding harness (deploy the skill).
@@ -255,6 +302,7 @@ main(rawArgv)
     });
     if (err) {
       process.stderr.write(`slidemind: ${err.message || err}\n`);
-      process.exit(1);
+      // a script that ran under us keeps its exit code (runNode): 2 = blocked
+      process.exit(Number.isInteger(err.exitCode) && err.exitCode > 0 ? err.exitCode : 1);
     }
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slidemind",
-  "version": "0.3.20",
+  "version": "0.4.0",
   "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": {
@@ -32,7 +32,7 @@
     "build-pptx": "node bin/slidemind.mjs build-pptx",
     "lint:parity": "node scripts/check-skill-parity.mjs",
     "release": "node scripts/release.mjs",
-    "test": "node --test"
+    "test": "node --test --import ./test/support/isolate-config.mjs 'test/*.test.mjs'"
   },
   "dependencies": {
     "@clack/prompts": "^1.3.0",