slidemind 0.3.20 → 0.4.1

package/LICENSE

@@ -0,0 +1,4 @@
+Copyright (c) 2026 statworx GmbH. All rights reserved.
+
+Third-party components included in this package are licensed under their own
+terms; see THIRD-PARTY-NOTICES.md.

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`.
 
 ---
 
@@ -448,4 +551,96 @@ 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).
+slidemind is published by **statworx**. Source lives in a private repository; the npm tarball is the install artifact. Proprietary, © statworx GmbH, all rights reserved: publicly installable, but not to be modified or redistributed — see [`LICENSE`](LICENSE) and [`THIRD-PARTY-NOTICES.md`](THIRD-PARTY-NOTICES.md).
+
+
+### 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/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,201 @@
+# Third-party notices
+
+The slidemind package contains the following third-party material. It is
+licensed under its own terms, reproduced below; the package's own LICENSE does
+not restrict the rights those terms grant.
+
+## DrawingML preset shape definitions
+
+- **File:** `src/builders/preset-definitions.json` (derived; converted by
+  `scripts/convert-preset-definitions.mjs`, which is not shipped)
+- **Source:** Apache POI,
+  `poi/src/main/resources/org/apache/poi/sl/draw/geom/presetShapeDefinitions.xml`
+  — Apache POI's redistribution of the ECMA-376 Part 1 (5th edition) §20.1.9
+  DrawingML preset shape geometry definitions
+- **Copyright:** The Apache Software Foundation; the definitions are published
+  by Ecma International as part of the ECMA-376 standard
+- **License:** Apache License, Version 2.0 (text below)
+- **Modifications:** the XML definitions were converted to a compact JSON form
+  (adjust values, guides, paths and connection sites); no source XML is
+  included
+
+## Apache License, Version 2.0
+
+```
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+```

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.1",
   "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": {
@@ -25,14 +25,16 @@
     "install.sh",
     "install.ps1",
     "AGENTS.md",
-    "README.md"
+    "README.md",
+    "LICENSE",
+    "THIRD-PARTY-NOTICES.md"
   ],
   "scripts": {
     "build": "node bin/slidemind.mjs build",
     "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 scripts/run-tests.mjs"
   },
   "dependencies": {
     "@clack/prompts": "^1.3.0",