Omniscio

Decks (AI presentation builder)

Decks is the AI presentation builder in Omniscio: describe a deck in plain language, approve the outline it returns, then get editable cards with real layouts, images and speaker notes that you can reorder, present, publish as a web link, or download as PDF, HTML or PowerPoint.

On this page

What it is

Decks is a Gamma-style AI presentation builder inside Omniscio, surfaced as a virtual project in the sidebar. You describe a deck in plain language; Claude returns an editable outline (titles + one-line summaries); you approve it; then Claude generates each card — real rich content plus a chosen layout from a fixed library — with a real narrative arc and auto speaker notes. The result is an ordered list of cards you can reorder, edit, present, publish to a shareable web link, and download as PDF, HTML, or PowerPoint (.pptx).

Slides show real images when the model supplies one, over a deterministic generative-art base (so nothing ever looks empty) — see Real images + generative art. A presenter view (notes + next slide + timer) and a static PDF / HTML / PowerPoint export round it out.

A deck is an ordered list of cards. Each card holds normal rich content (headings, paragraphs, bullets, image) plus two presentation attributes: a layout name (from the finite registry) and an optional style (accent-image position, full-bleed, vertical alignment). This is the unit the generator emits and the editor renders.

Status

Ships the data model, the two-stage AI generation pipeline (idempotent, with a cost cap + progress + resilient parsing + atomic insert; now narrative-arc prompts + auto speaker notes), the context pull (build a deck FROM a picked session/project/board: read, clean, bound, distill into an editable grounded brief, with durable source provenance), an optional pre-outline interview (a bounded Q&A that synthesizes a brief to seed the outline), the 13-layout registry + 7 themes, the Decks app (deck list, create flow, card editor with reorder, inline edit + notes editing, add / delete / restore card, export menu), real images + deterministic generative art, a presenter overlay (notes + next slide + timer), publish-to-web (the deck-render canonical viewer via the shared slide engine), and PDF / HTML export (static print render → htmlToPdf, desktop-only). Still tracked as follow-ups: paid AI image generation (a non-Anthropic image provider), a WYSIWYG canvas editor, and editable-outline-affects-generation. Decks itself is no longer hidden behind a Lab flag: it is a Marketplace plugin (see "How it is gated" below).

Where to find it

Decks lives in the left sidebar as its own virtual project once you have installed it from the Marketplace, so there is no panel to hunt for — installing it adds the row, and switching it off removes it. This section covers how it is installed and switched on, what the row opens, and what the Decks app can and cannot do compared with the older built-in panel it replaced.

How it is gated

Decks is a first-party plugin delivered through the Marketplace (src/plugins/decks/manifest.json, plugin.id: 'decks'). Omniscio never registers the copy in its own source tree as a built-in plugin (decks is listed in BUILTIN_EXCLUDED_PLUGIN_IDS), so it is off until you install it (enabledPlugins starts empty), installing it from the Marketplace also switches it on, and it is NOT gated by an unreleased-feature flag.

Enabling it creates the __plugin_decks__ sidebar row (via the standard ensurePluginSidebarRow); disabling it hides the row. The main-process CLI routes resolve the same state through the plugin loader, so "not installed" and "switched off" are refused with different messages naming what to do, and neither answers with an empty list. They read and write only the plugin's own collections, the same place the Decks app keeps your decks. The first time they set those collections up, they copy in any decks still in the app's older tables, so an agent never sees an empty library. The row always opens the Decks app (the sandboxed plugin screen), the same way any plugin with a screen opens. The Decks plugin is desktop-only for now: its manifest declares "mobile": false at the top level (next to permissions), so a phone shows the standard only available on the desktop app notice. Phone support for store plugins waits on the host's product decision (on hold since 6 November); Decks turns it back on when that lands. The manifest declares a ui.entryPoint but no island bundle is committed in this repo (see the bundle note below); the packaged app carries it. Invariants: .claude/memory/contracts/decks-plugin-contract.md.

One Decks app (since 2026-11-19). There is no longer a switch between two Decks screens. The Decks as a webview app switch that used to sit in Settings → Lab, and the older built-in panel it could bring back, were removed on 2026-11-19. Decks always opens in the Decks app. Your decks are not lost: Omniscio copies any decks still in its older storage into the Decks app each time it starts, when you switch the plugin on, and the first time an agent reads your decks.

What the plugin path can and cannot do (feature parity, 2026-07-29). When this was written the island was NOT yet a like-for-like replacement for the old built-in panel, and the gap matters if Decks is published to the marketplace. SIX host capabilities are exposed to it as bridge calls, so it WRAPS the host implementation instead of re-implementing it: decks.measureArtifact (the deterministic overflow gate that repairs text clipped past the slide frame — but only up to a point, see below), decks.renderHtml (the deck→HTML renderers — what makes Export PDF / Export HTML / Publish work at all; before it landed all three threw, while their mocked tests stayed green), decks.exportPptx (PowerPoint export, added 2026-07-29), decks.assembleFile (extract + distill a document), decks.researchTopic (the web-search grounding pass) and decks.assembleBoardContext (read + distill a shared board, added 2026-07-29). All six answer a discriminated { ok: true, … } | { ok: false, reason } so a failure can never be misread as a clean result — see .claude/memory/contracts/plugin-bridge-hardening-contract.md measureartifact-reports-whether-it-measured / renderhtml-reports-whether-it-rendered and .claude/memory/contracts/decks-plugin-contract.md the-host-writes-the-powerpoint-file (I34, in the export/publish contract) / I35.

exportPptx is the one that SAVES rather than returning data — a .pptx is a binary zip and the generic export.saveFile writes utf-8 only, so the host pops the Save dialog and writes the file, exactly as export.savePdf does. It carries a THIRD arm the others do not need: a user who cancels the dialog gets { ok: true, saved: false }, because a cancel genuinely ran and genuinely did not fail. On a real save it reports rendered / total, and the plugin tells you when the saved deck came back SHORT of real slides — the per-slide render is fail-open by design, so a deck carrying placeholders is a real outcome, not an exotic edge.

assembleFile and researchTopic are the CREATE-side pair. Office extraction is main-process code and a PDF rides to Claude as a native document block, neither of which the text-only AI door can express; and research is a tool_choice: auto call carrying the web_search SERVER tool, which the forced-tool AI door structurally cannot issue. Both are bridged for that reason and no other.

So the island now starts a deck ALL FOUR ways — a typed prompt, from a file, a guided interview, and from your work (a past session, project or board you have shared with it) — each optionally grounded by web research, and it reaches all three export formats (PDF, web page, PowerPoint). The interview needed no new bridge method at all: it is a forced structured-output tool call, exactly the shape the existing AI door already serves.

Boards needed a SEPARATE method rather than a third value on assembleContext's sourceKind, and the reason is worth knowing because it looks like extra work for nothing: the host gates permissions per method, not per argument. A board accepted by assembleContext would have been read under the session-history permission — so a plugin holding only that permission could have read your boards. One method, one permission, one honest sentence.

"From your work" behaves differently from the old built-in panel, and that difference IS the privacy model, not a limitation. The old panel could list every session and project you had, because it was the app. The plugin can only list what you have explicitly shared with it — so its picker starts empty, with a "Choose what Decks can read" button that opens Omniscio's own picker. You choose there; Decks never browses your work to offer it to you. Two consequences worth knowing:

  • Sharing a project shares its sessions, but sharing one session does NOT share its project. The asymmetry is deliberate.
  • Sharing a board shares only that board. Boards sit inside a workspace, and sharing one does NOT share the others — a workspace is far wider than the thing you actually pointed at.
  • Decks never sees your messages, or your board's items. It hands Omniscio an id and gets back only a distilled summary, so the underlying content never enters the plugin. That is structural — there is no path for it, not merely a rule being followed.
  • Boards asked separately, and on purpose. Decks requests a distinct "read your boards" permission rather than reusing the session-history one, because a board is project-management data and not a conversation. Agreeing to share past sessions should never quietly hand over something else.
  • You can withdraw any of it later in Settings → Plugins, where every grant is listed together — sessions, projects and boards in one place, each labelled for what it is. A grant whose target you have since deleted still appears there, so you can always withdraw it.

ONE capability remains host-only:

  1. The AI visual-review pass is STRUCTURALLY BLOCKED. The bridge's AI door is text-only (no image parameter), and there is an unanswered spend question on top. It cannot be built as things stand, so a published listing must say so: a deck made through the plugin does not get the visual-review pass the old built-in panel's decks got.

Two things about the plugin's create path differed from the old built-in panel, and both are deliberate. First, the plugin refuses a larger file than the old panel did (~24 MB vs 25 MB): a file crosses the plugin bridge as base64 inside a 32 MiB-capped payload, so the honest ceiling is lower, and the plugin says so up front rather than failing after the read. Second, web research bills a different budget from the slides: research and file distillation come out of the deck budget, while the outline and cards come out of the plugin's AI budget. Those two can run out independently — so if research is skipped because its budget is gone, the plugin tells you at the outline review, before it spends anything on slides, and tells you again on the finished deck. "Budget used up", "found nothing useful" and "couldn't run" are three different messages, not one.

The overflow gate guarantees a MEASURED slide, not a FITTING one (2026-07-28). Its repair is bounded on purpose — 6% per pass, two passes — so it rescues a slide that is slightly too full and deliberately leaves a badly overflowing one alone. Treat it as a safety net for near-misses, not a guarantee every slide fits. This was proven on a real render, and proving it exposed a defect worth knowing about: because the bridge used to infer its violation count from "did the card change?", an unfixable slide came back unchanged and reported violations: 0 — "measured and clean", for the worst slides in the deck — while the gate logged nothing at all in that case. The host now REPORTS { status, violations, repaired } and nothing downstream infers it; the unfixable case logs; and the island tells the AUTHOR (a line on the deck-ready panel, attention-toned, non-blocking, fired only for measured-and-not-fixed). Details in .claude/memory/contracts/decks-plugin-marketplace-publish-preconditions-detach-build-deck-contract.md's "the NATIVE panel does not tell its author about an unfixable slide" section. The old built-in panel discarded those counts and never told its author; it was removed on 2026-11-19, so the Decks app is now the only place a deck is made.

Users who had the older Decks Lab toggle (decksEnabled) on are carried over to the enabled plugin by a one-time startup migration (decksEnabled → enabledPlugins), so nobody loses access on upgrade.

How it behaves

Decks speaks your language

Decks shows its screens in the language Omniscio is set to, in all 34 languages the app offers (since 2026-11, T-225). Change the language in Omniscio and Decks switches at once, with no reload, and keeps anything you were typing. Dates, times, numbers and prices follow your region's format. What Decks sends to the AI stays English, so changing the screen language never changes how a deck is built. Things to know:

  • A message already on screen keeps the language it appeared in; the next one follows the new language.
  • Your slides are written in whatever language you describe the deck in. The screen language does not translate your content.
  • On an Omniscio version older than the language update, Tagalog, both Chinese scripts and Brazilian Portuguese show in English, and a language change needs Decks reopened.
  • Right-to-left languages (Arabic, Urdu, Persian) are translated, but the layout still reads left to right.

Decks keeps you in control in two ways: it settles a plan before it draws anything (with you, or by itself while you watch if you choose Decide for me), and it stops for your approval once the first three slides are ready, before the rest of the deck is added. A deck can start from a typed description, a file you insert, or work you have already done.

How a deck is built

  1. The New deck form. New deck opens one form (since 2026-10-02; it used to start on three tiles). Fill in what the deck is about, optionally build it on a file (Attach a file) or on past work you have shared with Decks (Use past work), then three optional fields: who it is for, how it should look (six starting points are offered, or write your own; leave it blank and the deck chooses) and anything else to honour. The topic box grows with its text from two lines to eight and Anything else? from three to fourteen before either scrolls, and near its 2,000-character limit Anything else? shows a count; the topic stops at its 6,000-character limit (TOPIC_MAX, the same cut every send makes) and from 4,800 says how much is used, ending "Limit reached." at the cap, or "The rest of what you pasted was left out." only when a paste was cut (detected on paste against the room left); the count is the box's description and a separate always-mounted live region announces only crossing 95% and reaching the cap; a seeded topic (a rebuild seed or a material title) is clipped to the cap (T-169). Under How it gets built, four switches control speaker notes (on by default), photographs for picture slides (on by default), a fact check against Wikipedia before each slide is written (off by default) and a web research pass first (off by default; it uses some of your daily deck budget). On a pane about 960 px wide or more, How it gets built and a What happens next card (interview or autopilot, three slides to approve before the rest is paid for, the rest of the deck, ready) sit in a column beside the questions; on a narrower pane they sit underneath. Last, pick the mode: Decide for me, I will watch or Ask me as we go (Ctrl+Enter / Cmd+Enter from any field starts the latter); when neither can start, the line beside them says why.
  2. The planning steps. Decks runs fourteen steps, each shown as "Step N of 14". The first ten are a conversation with the AI that will build the deck: what the deck is, its goal and outcome, which facts are worth checking, the audience and where it will be seen, the narrative arc, what each slide says (one sentence per slide), how each slide is treated, the subject's world, the palette, and composition, type and ornament. In Ask me as we go each step asks its questions one at a time (each step allows two to four rounds), with suggested answers you can pick or replace with your own words. The screen shows only the question, its answers, at most one short sentence under a question that needs it, and, when the step asks you to approve a list it wrote (what each slide says), that list numbered above the questions; the AI's own reasoning is never shown, the title says "Step N of 14", a line above the question says "Question n of N", and there is no round counter. Text that had to be shortened ends in " […]" rather than being cut silently. The step stops for you to accept ("Looks right, keep going") after the audience step, the step that agrees what each slide says, the treatment step, the palette step and the design step. In Decide for me, I will watch the AI makes those decisions itself and lists each one as it is made. The separate "Interview me" choice older versions offered was folded into these steps in plugin 0.21.0. The audience step settles the slide count (a deck holds at most 20 slides; an agreed count above that builds 20 and the step says so) and, for a deck presented live, how long the talk runs ("Running time: 15 minutes"), which every slide's speaker notes are paced to fill.
  3. Building the slides. Step 11 plans the slides (the outline) and produces the first three, then Decks stops: "Here is how the deck is coming out. Nothing past slide three gets built until you say so." This checkpoint stops every deck, including one on Decide for me. Accepting it ("Good, build the rest") adds the remaining slides and runs a final pass over the deck; in Ask me as we go Decks then shows every slide once more ("Good, hand it over") before the deck is handed over.

Designer mode is the way every deck is built since Decks 1.3.7, and the author cannot turn it off. Lite mode (off by default) is the way to the standard slide-by-slide build: switch it on with Lite mode on the Decks card in Settings → Plugins or under Deck settings inside Decks. Every install is reset to Designer with Lite off on that update, and the old Designer toggle is not carried over. A deck build records the choice when it starts and keeps it when it is picked up again, so changing the setting or updating Decks never flips a build that is already under way; a build started before 1.3.7 has no recorded choice and carries on in Lite mode. Since Decks 1.3.11, Designer mode works in text only, because Decks declares no sessionTools and every Decks session is therefore locked to no tools. One fresh AI session is created from the distilled design brief (the interview is not handed over; its id is kept as brief.designerSessionId), and each group of slides comes back as html in the reply: the first three before the checkpoint and then groups of five after you accept them. Decks reads the slides out of the reply, measures each one in its own frame, and sends a slide with a critical or high finding back once, in words, keeping the redraw only if it measures better. A reply with a slide missing, or in plain words, stops the run with a plain message and stores nothing for that group; Try again reads the designer's transcript first, so an answered group is collected and never asked twice. The designer never sees a picture of its slides, so it is asked in words for one design system, varied neighbouring slides and a deck-level read in the last group, which can only fix slides in that group. The earlier file-and-browser route is kept in the source, unreached, until a real run has compared the text route with Lite mode. With designer mode switched off, slides are built one at a time from the plan: title, section, quote and picture slides use template layouts and the rest are designed. Part 2 describes what each slide is told in each case.

If Decks cannot start an AI session (for example, it was not allowed the sessions permission), it falls back to an older route on your stored API key: it writes an outline for you to review, and Generate deck builds the slides from it.

Back, without stopping this deck leaves a deck running and returns to the deck list, where the running deck's row brings you back to it, and Stop this deck… ends one (it asks first, and says what is kept). Every settled planning step offers Not quite, let me change it beside Looks right, keep going: the words go down the step's own session and the step settles again (one more AI question). The first three slides offer Change something first, which redraws the slides named in the words (all three when none is named) through the same redraw the editor uses, reading and writing only the run's own deck, and leaves a slide alone if the author changed it meanwhile, has its editor open, or is already redrawing it (it says which slides it skipped). It counts toward the deck's spending stop: each redrawn slide's usage is added to the run's total before the session is closed, and a stop reached between slides pauses the rest, with Continue returning to the same gate rather than building the remaining slides. Stop this deck during a redraw ends it after the slide in progress: no further slide is paid for and nothing is written into the kept deck. A kept redraw does not move which slide Undo targets. A spending stop shows the stop, the used amount (an estimate) and what continuing allows, with Continue, Stop here and keep what is built and a note that the stop is changed in Omniscio Settings, on the Decks card. A stopped planning session says in plain words that nothing settled was lost, and shows its DECK code only as a "Details for support" footnote. New deck opens a blank form, so Back never leaves a filled-in form to start a second deck from. Several decks can build at once, and the deck list shows what each is doing.

Reliability: what is kept and what is salvaged

  • Resilient parsing (one bad block never kills the deck). The AI's slide output is salvaged, not strictly rejected: an unknown layout falls back to text, a bad or over-long block is dropped or truncated to the schema caps, and a slide that comes back empty becomes an explicit placeholder so the build always finishes. A deck with an empty or missing slide is saved as a draft rather than ready, and the finished screen says why.
  • Slides are saved as they land. Each slide is written to the deck as soon as it is generated, so an interruption does not lose the slides already made, and a retry carries on from the slides the deck already holds instead of drawing them again. Since the October 2026 fix this includes the first three slides: the deck is created, and linked to the run, when the first slide lands, where before it was written only once all three were done.
  • A failure stops paying (Decks 1.3.2). When one slide of a batch fails, no further slide of that batch is started, and slides are saved strictly in outline order (nothing past the failed one is kept), so the deck always holds a gap-free run of slides and Try that again draws exactly the missing ones. A timed-out step is sent again at most once. The picture search before the first slide stops after one minute and keeps what it found. Once a question of the optional quality check goes unanswered, or its session is held longer than two minutes, that session is asked nothing more for the rest of the deck and no slide is redrawn on its advice. A reply that lands while its session is held is taken only once it carries its full answer block, and a drawn slide too large to store is treated as unreadable (retried once, then a placeholder) rather than saved cut off. A rescued deck ends at its final gate or as done, and a run more than a week old whose session no longer exists is recorded as stopped.
  • What is not kept (Decks 1.3.3). Deleting a slide removes it and its version history from storage for good (a slide carried in from Omniscio's old built-in Decks panel stays only as an emptied placeholder, so Omniscio cannot copy it back), and nothing that finishes for that slide afterwards, a save or a slide animation, puts anything back. A build stopped before it had a deck is removed, with its brief, its answers and the material read from an uploaded file, the first time Decks opens a day or more later; a stopped build that made a deck goes when the deck is deleted. When that clean-up cannot read storage, the next time the deck list loads tries again. Deleting a deck for good also stops a slide animation or video run still working on it before anything is erased, and withdraws every share link Decks published for it, the deck's own and its video's (each link is remembered on the deck when it is made; a deck shared before this was recorded has none to withdraw). A copy of a deck starts with none of the original's links, so deleting the copy leaves the original's links working.
  • A half-typed New deck form comes back. Clicking a deck in the list while New deck is open closes the form; pressing New deck again brings back what was typed, the switches and any attached file or work. Back still clears it, a rebuild starts from the deck being rebuilt instead, and it is kept only while the panel stays loaded, so a reload, a pop-out or signing in as someone else starts empty.
  • Every AI session a build opens counts toward its spending stop, while it is open and once when it closes: the build's own steps, a rescue build of a deck kept part way, a slide the designer hands back, and planning the outline. What has been banked is saved with the build, so closing and reopening the panel does not reset it. Each of those sessions is counted once even when one takes over from another: while the slide-drawing session is being swapped both are counted, and if the new one could not be saved it is counted and closed while the old one stays in use; closing the panel in the middle of a swap, even while the new session is still being saved, counts each session once, because the old session's cost is saved in the same step that records the new one (only if the panel is closed before that step finishes is the new session's own cost left out); and when Try that again moves a deck onto a new planning session, the old session's cost stays in the total and the old session is closed (Decks 1.3.12).
  • What is kept when the panel closes or a save fails. Words being edited when the Decks panel closes or reloads (on a slide, in a field, in the Cards panel or in the notes under a slide) go out as one write before anything else, so a reload or quit keeps them; that last edit gets no undo step. A slide text save that fails keeps the typed words on the slide and says "That change could not be saved. Your words are still on the slide. Press Enter to try again." Keep on a redrawn slide that was changed while the redraw ran keeps the change and says "You changed this slide while it was being redrawn, so the redraw was not kept. The slide stays as you had it." Export and Publish save an edit still waiting first, so the file carries it. One failed deck open no longer freezes the deck on screen. The Enter that confirms a Japanese, Chinese or Korean word never submits a step answer, a redraw request or a rename, a Stop ask never carries over to another live deck, and the same file can be attached again after removing it.
  • A run survives its panel closing. In the Decks plugin, opening another plugin's panel closes the Decks panel, while the deck's own session keeps working. Reopening Decks picks the run back up where it is: a whole-deck design still running is shown in progress (with any usage-limit or balance pause and its clock) and its slides are collected when it finishes, never sent again, and a design that finished while the panel was closed (or after its 45-minute wait gave up) is collected on reopen. Since 1.0.19 the slide plan the first-slides step asks for just before the design is picked up the same way: the request is recorded on the run before it is sent, so a plan that arrived while the panel was closed is collected, and one still being written is waited for, never asked for again. Before 1.0.19 that plan was lost and the reopen offered DECK-E34, whose retry paid for it a second time; with nothing to collect it still does. The interview is picked up the same way: a round the author already answered is never asked again. Reopening shows the step still thinking, with its clock counting from the answer, and the next round appears when it arrives, collected once and never sent again. Before the October 2026 fix the answered round came back with no spinner and could be answered twice. One exception: a facts step whose fact lookup may have been cut off when the panel closed comes back with DECK-E37 and runs nothing until the author presses the button, because a second lookup is paid for again. Slides are picked up the same way: each slide request is recorded before it is sent, so Try that again collects a slide the session finished while the panel was closed instead of asking (and paying) for it again, and draws the rest from the plan already stored, never planning the deck again. With no slide saved yet, the reopen says DECK-E38 ("Its plan is kept") rather than claiming slides were kept. When a step has nothing running and nothing to answer, Check on this deck looks at the run again, exactly as reopening does.
  • The panel stays open while it works (Decks 1.3.8). Each build step, motion run and video run asks the host to keep the Decks screen loaded through AgentMC.runs (start, a heartbeat on the interval the host answers, finish when the work ends however it ends), in src/plugins/decks/src/lib/decks-host-runs.ts; a host without runs, or one that declines, changes nothing. An autopilot deck reopened part way through its remaining slides or final check, with its session idle and no turn in flight, carries on by itself exactly as Try that again would, once per stored slide count (recorded on the run as autoResumedAt); the first-slides gate, a guided deck and every other case still show DECK-E35 and the button. While Decks is loaded it checks the active build once a minute, one check at a time: a build step still running in the screen is never touched (and Try that again refuses while one is live), and otherwise no progress for 15 minutes with an idle session resumes an autopilot deck once in the same way, or stops the build with DECK-E27 and the button, never stopping, messaging or deleting the session. Stopping spends nothing; a resume carries on its normal spending. Each hold is its own host run, so a late finish from an earlier hold never ends a newer one. The first-slides inbox alert is posted before the screen is let go, recorded on the run as gateAlertPostedAt only when the host accepts it, and posted once on reopen when it never landed.
  • A spending stop and the editor's own AI work survive it too. Since the October 2026 fix a deck stopped at the author's spending limit comes back at that same stop, with the same choice, instead of the step the author had already approved (or DECK-E35 between batches of slides), and Continue goes on once. In the editor, a Write with AI or Rewrite with AI of a slide's notes, or an Improve slide or Start over, left running when the panel closed is picked up the next time that deck is opened: the slide shows it working (its notes stay locked until they land, and a new version that was already waiting comes back first), the answer is collected from the session that was already asked (never sent, or paid for, again), and a new version still waiting for Keep the new one comes back beside the slide. A press whose AI stopped while the panel was closed says so and leaves the slide as it was. One exception: a press that ran on the stored API key, because a session could not be started, cannot be collected later.

Which AI builds the deck

Decks ships an engine picker as a manifest select, keyed deckEngine. Since 1.1.0 it is read by readSessionEnginePick in the plugin's lib/decks-engine-host.ts, and the "Deck settings" screen (src/plugins/decks/src/screens/DeckSettingsPane.tsx, opened from the ⋯ button beside the Decks title at the top of the deck list) draws its rows from the host's LIVE engine list (ai.listEngines) whenever the host lists the ai-engine-choice capability: "Use Omniscio's default" is pinned first and says what it resolves to, each engine is a group with its models, an engine that is not set up is greyed, and the line under the picker says where the picked engine keeps your topic, files and slides (China, Alibaba from Singapore, a service that passes them on, or no record). A host without the capability is offered the default only, plus a saved choice marked "(not used on this version of Omniscio)", and the line under the picker reads "On this version of Omniscio, Decks uses Omniscio's default AI." The value is empty (the host default), a bare provider id, or provider:model; the manifest's 167 static options stay declared so a stored value is always valid. The pick is sent only to a host that honours it, to every decksSession.create the pipeline makes (the planning session, the critic, the one-shot leases), so one deck is built by one engine end to end.

Why the options are engine+model PAIRS and not two controls. The host validates the two together (assertModelBelongsToProvider in bridge-method-schemas.ts) and refuses a mismatch. Two independent controls make a refused pair reachable in one keystroke, and the ids are not guessable, so a typed model box would reject most honest guesses. One field whose every option is a pair the host already accepts removes the class by construction. The list is generated from the provider registry, and tests/unit/lint/05/decks-engine-options-match-host-registry.test.ts runs every shipped option through the host’s real arg schema so a retired model is a red test.

The pick steers the SESSION route; the rest stays on Claude, and Decks says so. Web research, reading scanned files and pictures, reading past work, and the keyed ai-bridge fallback (reached only when a session cannot be created) run on Claude by host construction and follow the Claude model when the pick names one; the setting description and the picker say this rather than implying the picker governs them.

A rejected pick STOPS rather than falling back. startPipelineRun and resolveTransport both drop to that Anthropic-only route on a refused create, which is correct when the session route is unavailable and wrong when the author’s own pick was rejected: it would build the deck on Claude while the settings still read otherwise. A fifth refusal kind (engine-pick, DECK-E15) is classified first and excluded from both fallbacks. The needles live in src/plugins/decks/src/lib/decks-engine-refusal.ts so the repo-level guard can re-derive the host’s wording from its real schema and fail if a reword would silently reclassify the refusal. The host's no-tools refusal on an engine it cannot keep tool-free ("...can only run on an AI engine the app can keep tool-free") is one of the needles (Decks 1.3.6): the author reads the engine message and the build stops at no cost, instead of "check that Omniscio is signed in". The Delete question and the Share and web page notices name the deck they are about and stay tied to it: they are cleared when another deck opens, and what you confirm is always the deck you were asked about (Decks 1.3.6).

Telling you while a deck builds: inbox alerts and the sidebar number

A deck takes minutes and often stops part way for its author, so Decks says so outside its own panel in two ways. Inbox alerts: "Your deck is ready" when a deck finishes, and "Your deck needs you" for every stop after the long unattended part of the build (since 1.0.19; 1.0.18 raised it only for a failure with no automatic retry left): the first slides are ready for approval, a finished deck waits for approval (runs started with "Ask me as we go"), the author's spending limit is reached, the AI balance runs out, or a step fails and Decks will not retry it. A question while the deck is being planned raises no row; the sidebar number counts it. Each stop is its own row, keyed per run, step and stop, so dismissing one never swallows a later one, and the same stop reached twice stays one row (raiseNeedsYou in src/plugins/decks/src/decks-store.ts, postDeckAlert in src/plugins/decks/src/lib/decks-inbox.ts, governed by .claude/memory/contracts/decks-inbox-alerts-contract.md). The setting Send inbox alerts (inboxAlerts, on by default) turns every Decks row off, and the panel still shows each stop. The rows need the manifest's inbox permission; 1.0.17 shipped without it, so none arrived until 1.0.18. A blank message falls back to the title, the deck title's link, picture and HTML syntax is escaped because the inbox renders a plugin alert's body as markdown, and since 1.0.19 a working title the model wrapped in quotes is stored without them, so the ready row no longer reads ""Title"". The sidebar number: the Decks row shows how many decks are stopped and waiting on the author (a design gate, a retry on offer, a spending stop, a balance hold, or a question on screen), sent through sidebar.setBadge with the notifications permission by src/plugins/decks/src/lib/decks-sidebar-badge.ts and governed by .claude/memory/contracts/decks-sidebar-counter-contract.md. Decks has no background worker, so the number changes, and the inbox rows are raised, only while Decks is loaded (from when it is opened until another plugin is opened, or longer while a build holds the screen open, since 1.3.8); a deck that stops while Decks is unloaded says so when Decks is opened again. The host keeps the last number across restarts. The setting Count decks waiting for you (countWaitingDecks, on by default) turns it off.

Showing progress inside the panel: the highlight, the percentage and the clock

Three signals show a deck is still moving; their rules are the on-screen status contract (.claude/memory/contracts/decks-onscreen-status-contract.md).

  • The highlight follows the screen. The deck list highlights the deck the main area shows, including one still building; the New deck form, the finished-deck screen, settings and the empty screen highlight nothing.
  • The deck list folds to a strip (Decks 1.3.4). Fold deck list in the ⋯ menu at the top of the deck list, or Ctrl+Shift+E (Cmd+Shift+E on a Mac), folds it to a 48 px strip so the slides gain about 240 px. The strip keeps New deck, Search, the list and Needs you, with an orange count when decks need you; Decks remembers the fold. A phone-width window keeps the list unfolded.
  • A percentage only while slides are drawn. The row's tag reads "Building 40%", and the build screen shows the same number: slides drawn out of slides planned, rounded down. Planning, designing, checking and pauses show none, as they cannot be counted.
  • The motion panel. While motion is designed the panel says "Slide 5 of 14" once, draws one block per slide (done, kept, skipped, now, still to do), and shows three facts: time spent, time left (or when it will be known) and the AI cost so far (or when it will be known). Slides that already had motion are kept, not redone. It says what to do next in each state: still working, picked up after a stop, gone quiet, a skipped slide (Retry in the list once the run ends), finished (Watch it) and stopped by you (Continue from slide N). When it ends it counts "13 of 14 slides have motion".
  • A clock for every other wait. "Working for 2:15", or "Waiting so far" under a pause with its reason, counts from when the wait began and survives leaving Decks. A screen reader is not told the time every second; a slide being redrawn shows its own clock under the canvas.

Each deck's row also has a Deck actions button (the ellipsis) that pins, duplicates or archives it, the same menu a right-click opens, and the list is one Tab stop: the arrow keys, Home and End move between decks.

A pinned deck sits under the Pinned heading at the top of the list and shows no pin icon, so a row carries only its name, its thumbnail and, when it has one, a Building, Needs you or Error tag; the date it was last edited is in the row's hover text and is read out by a screen reader. The tag's reason opens on a press or from the keyboard, and Escape or a press elsewhere closes it. The row stays tall enough for its name and tag at any text size.

Build from a file or from your work

Two buttons under the topic on the New deck form, Attach a file and Use past work, let a deck start from material you already have instead of a blank description. Whichever is chosen last is the material (a file replaces past work and past work a file), shown as a chip with its own remove button. Either way the material becomes a brief that seeds the planning steps, and the brief is shown on the form as one folded line, What the deck will be built on with its word count. Show displays it formatted (headings, lists, tables, code; links and pictures as plain text, so nothing in it can run), and Edit opens the raw text to correct before you start: Save writes it back as the brief the deck is built on, Discard drops the change, and while an edit is open the start buttons wait.

  • Attach a file. Choose a PDF, Word, Excel, PowerPoint, CSV or text-like file (up to about 24 MB), or a picture (PNG, JPEG, WebP or GIF). Decks reads the file on your computer and the deck's AI turns its text into the brief, so the file's text goes to the AI that builds your deck. A scan or a picture cannot be read that way, so it goes whole to Claude on your API key. The form says both under its two buttons before you pick anything. Since Decks 1.3.3 a file is read on your computer only when it really is what it says: an Office file that would unpack to more than 32 MB a part, 64 MB in all or 5,000 parts, or that packs more than 8 MB into one part or 16 MB into all of them, or a "text" file that holds binary bytes (a renamed picture), is passed to Omniscio's own reader instead; a UTF-16 text or CSV export is read as UTF-16; and the lines that frame the document for the AI carry a code made fresh for each file, so a line in the document that imitates them cannot end it.
  • Use past work. Choose a past session, a project or a Mission Control board that you have shared with Decks. Its picker (titled Use past work; Back returns to the form with everything kept) starts empty and lists only what you shared; part 3 explains what that means for privacy. Omniscio reads the work and turns it into the brief in four stages. It reads the transcript or transcripts (or the board's groups, items and columns). It cleans agent noise out of them. It bounds them to a token budget (the decksContextTokenBudget setting, 20,000 tokens by default): a long session keeps its start and its end and drops the middle behind an omission marker, a project is read newest session first until the budget runs low, and a board is capped at 200 items. A board's email, phone and location columns are dropped before anything reaches the AI, while its owner (people) column is kept so the brief can say who owns what. Then it distils the result with one metered call (cost label decks-context, on the same daily budget) into a suggested title, a suggested audience and a brief of at most 8,000 characters. A summary that cannot be used falls back to a brief made without AI, and an empty or unknown source is a plain error before any paid call.

The deck remembers where it came from (a source_ref holding the kind, which is session, project, file or board, plus the id, the title and the time), and the editor shows it as a quiet "from title" chip beside the deck's title.

Pre-outline interview (removed)

The old built-in panel offered an Interview me first step before the outline. It went with that panel (2026-11-19) and its host channel (2026-11-20). In the Decks app the same questions are part of its planning steps (see the New deck form above), with no separate interview button.

The layout registry

The plugin keeps a finite, named layout library in src/plugins/decks/src/deck-model/layout-registry.ts (DECK_LAYOUTS). The slide renderer, src/plugins/decks/src/card-layouts.tsx, maps each name to a React component and falls back to text for a name it does not know, and the layout picker in the editor lists every layout by its display name.

Layouts (14): title, section, text, text-image-split, bullets, two-column, stat (big-number), full-bleed-image, gallery (image grid), icon-grid, timeline, comparison, quote, and artifact, the freeform layout that shows an AI-written HTML document (a designed slide) in a sandboxed frame. Each carries an intentAffinity (which content intents it suits).

In designer mode every slide is a designed (artifact) slide. In Lite mode, each planned slide has an archetype that decides its layout: title, section, quote, showcase (a gallery) and spotlight (a text-image-split) use template layouts, and the other archetypes (content, chart, timeline, big-number, comparison and closing) are designed slides. Adding a layout takes one registry entry and a component in the renderer's map, and the PDF, the web page and Share render template slides through that same renderer (src/plugins/decks/src/lib/decks-template-render.ts).

Omniscio also keeps its own copy of the registry (src/shared/decks/layout-registry.ts) and its own slide renderer (src/main/services/decks/deck-render.ts), which PowerPoint export captures slides through. A lint test, tests/unit/lint/0b/deck-layout-registry-completeness.test.ts, keeps that renderer in step with the host registry, and the plugin's own suite renders every layout in its registry (src/plugins/decks/tests/decks-web-render.test.tsx).

A gallery card holds at most DECK_GALLERY_CELLS (4) images. That constant (src/plugins/decks/src/deck-model/deck-visuals.ts, with an identical copy in the host's deck-visuals.ts) is the single source of the cap. The card-generation prompt QUOTES it to the model, the renderer sizes its tiles from deckGalleryArts, and the host renderer derives its own cell count from its copy. It has to reach the model, because a gallery handed more images than the cap renders the first 4 and silently drops the rest, so an untold generator writes image prompts you pay for and nobody can ever see (real deck 912f2b95 emitted 7). The cap governs the COUNT only: the 2×2 grid is a deliberate visual constant, so raising it is not a one-line change. On the host side, deck-gallery-cap.test.ts in the always-on guard lane locks every reader of the host copy to it (gallery-cell-cap in the decks invariants (.claude/memory/contracts/decks-invariants-contract.md)), and src/plugins/decks/tests/decks-web-picture-prompts.test.ts checks that the plugin's gallery request quotes the plugin's constant.

The editor header

The header above the slide is one row that never wraps. On the left are Back, the deck title (click it to rename; hover it to read all of a long title) and a small Saved note that reads Unsaved changes while typing on a slide has not been saved. In the middle is a switcher with Canvas, Cards and How it was made, and in Cards view the zoom buttons sit beside it. On the right are Motion & video, Share, Present and a More menu. Present is the only filled button; its arrow opens Fullscreen and Presenter view.

Share holds Share to the web…, which still asks first because the notes go with it, and under Download a copy the PDF, the PowerPoint and the web page. A row that is switched off says why on the row, for example Add a slide first. on an empty deck. More holds Rename deck and, after a divider, Delete deck… in red, which asks before it deletes; Escape closes that question.

When the editor is narrow, controls move into More in a fixed order: Motion & video first, then Share, then the switcher. A phone keeps Back, the title, Present and More, and More opens a bottom sheet of four rows (View, Share, Motion & video, How this deck was made; Zoom joins them in the Cards view) where all but the last open their own sheet, with Presenter view, Rename deck and Delete deck under dividers. Nothing is removed. Large text folds sooner, because the width is counted in text sizes, not pixels. On a phone (an editor narrower than 480 pixels) the slide tools show undo and redo, a divider and five icon tools (edit text, improve, move earlier, move later, backdrop), then New slide across the width with More beside it, and the speaker notes and the slide strip each fold to one line that opens on a tap; in present mode below 640 pixels the bar keeps previous, the slide count, next and Notes, a button opens the While presenting sheet (zoom, draw, motion, timer, fullscreen), and Notes opens Presenter view as a half-height sheet.

The deck list

The tabs above the list are All, Needs you and Ready, each with a count (Archived joins them once something is archived). Needs you means a failed deck or a run that is waiting on the author, and the row says what, for example Waiting for your OK or Stopped: needs a look. A run waiting for an answer and a build paused on the account balance share the blue Needs you chip; a pause that needs nothing from the author (a rate limit) keeps the grey Waiting chip (T-85). A row's date reads Today, 2:10 PM, Yesterday or Oct 11. When the list cannot be read the list shows We could not load your decks. They are safe. Nothing was deleted. with Try again; it never shows the empty welcome instead. A failed save or download shows one plain sentence and never the host's raw error, which is logged for support (src/plugins/decks/src/lib/decks-storage-failure.ts).

The Sessions tab: one place for the AI work

The deck rail has two tabs, Decks and Sessions (Edo approved the design on 19 Nov 2026, T-527). Decks holds the deck list exactly as before. Sessions is the plugin's one home for its AI work; the host's own Sessions pane stays off for Decks.

  • One line per AI action you start. Each build (Autopilot or Guided), slide redraw, notes rewrite, motion design or narrated video adds one line under its deck, in Needs you, This deck, Other decks or Ended (Recent with no deck open). A build's line appears the moment it starts, before its deck exists, follows it while it waits in the background, and closes when it finishes or is stopped. Helper work inside a build, such as the critic, a rescue or Designer mode, never adds a line. Each section folds and remembers it.
  • Needs you, in one place. The tab shows an amber count with an icon and the number. A build waiting at the first three slides says so and offers Review slides. Other gates, the spending stop and a stopped plan offer Open, which opens the same screen as before. A Guided build's questions can be answered right inside the line. A redraw or notes rewrite that couldn't finish offers Try again. Running work shows a quiet dot.
  • Start a deck from Sessions. With no deck open, type an idea and pick Decide for me, I will watch or Ask me as we go. Options holds the same build switches as the form. The full form is still under New deck.
  • Talk about it. Discuss on a line opens a chat about that action, and Ask about this deck… opens one chat for the deck. Chats are filed under the deck, named like Redraw: Q4 board update or Discuss: Q4 board update, and reused the next time, never started twice. A message that couldn't be sent stays in its box, a draft stays with the deck it was typed on, and an open chat shows new answers on its own. They need an Omniscio version that can file a chat under an item (the host change in commit fe17ff44); until then both stay hidden and everything else works.
  • Folding. The fold button beside the tabs, Ctrl+\, folds the rail; Ctrl+Shift+E still works from the More menu. The folded strip's search and Needs you open the Decks tab.
  • Show slide asks before leaving a slide with unsaved typing, like any other move.

The rules are in .claude/memory/contracts/decks-sessions-home-contract.md and the parts in .claude/memory/decks-sessions-home-map.md. Deferred from the approved mockup (follow-up T-18): answer chips, outline compare, a compact question card inside a line, and drag-resize of the rail.

The keyboard

Creating, editing and presenting a deck work with the keyboard alone, and focus is never left on nothing. The deck list and the slide strip are each one Tab stop, and the arrow keys, Home and End move inside them. A slide picture that is only there to look at (the previews at the first-three-slides step) is not a Tab stop. After Good, build the other 5 slides focus lands on the step's heading; the finished-deck screen puts it on Your deck is ready.; Open deck puts it on Back to decks; and saving a slide's title or body hands it back to Edit text. Focus is only moved this way when it was left on nothing or on the control that just closed, never away from a control the author chose. A recorded Tab-only run proves it: node scripts/verify-keyboard.mjs in src/plugins/decks (create, edit and present, one JSON line and one screenshot per Tab stop, a self-test of six known faults first), described in src/plugins/decks/docs/DEVELOPMENT.md. It covers the Decks screens in a plain browser, not the host's own entry into the plugin window.

Decks are kept per account

Decks keeps each deck under the Omniscio account that made it. A phone cannot open Decks: it is desktop-only, so the phone shows the desktop-only notice. When a second person signs in to their own account on the same computer, they see only their own decks; another account's decks are not listed and cannot be opened, changed, downloaded, shared or deleted from the Decks app or the CLI. The same goes for a backup export and for erase all local data. Restoring a backup leaves decks as they are, and the import says Decks were not restored from this backup.

Decks made in the app's older storage, before owners were recorded, have no owner yet, because the app cannot tell which account made them. When you open Decks and there are such decks, Decks asks once: Make these decks yours?, with how many there are. Make them yours gives every one of them to the signed-in account, and they appear in your deck list straight away; Not now changes nothing, and Decks asks again the next time Omniscio starts. In the Decks app, deleting such a deck asks Claim this deck first?; Claim it gives the deck to the signed-in account and deletes it for good, and Cancel keeps it. Claiming at first edit arrives with Decks 1.3.12; on an older Decks, a deck is claimed by deleting it. A deck someone else has already claimed cannot be claimed again, and the command line refuses to publish or export a deck whose older copy still has no owner until someone claims it. (The older built-in panel had its own claim button and banner. It was removed on 2026-11-19, along with the Lab switch that brought it back.)

Erase all local data deletes only the signed-in account's own decks. It keeps decks with no owner and a notice says how many it kept. With nobody signed in, decks made signed out stay in their own space and no signed-in account sees them; old decks still show as unowned, and they can be claimed only where the sign-in gate is switched off.

Agent session keys cannot read your slides (partly closed)

Every collection the Decks plugin stores (decks, deck_cards, deck_card_versions, deck_motion_runs, deck_videos, deck_video_clips, deck_runs) is marked agentReadable: false in its manifest. A caller using an agent session's own key that asks the control server for one of them through /plugins/decks/db/... is refused with PLUGIN_COLLECTION_NOT_AGENT_READABLE and storage is never read. The panel reads over its own bridge, so nothing changes on screen. A test (decks-agent-read-fence.test.ts) fails if a new Decks collection is added without the mark or an explicit not-personal reason.

Decks' own AI sessions are unaffected: the panel hands them the slide content as turn text and reads their replies, and no Decks prompt sends a session to these routes.

This closes the session-key path and the install-wide-key path into plugin storage. Two paths stay open until the host adds its rule allowing only the sessions the person has allowed:

  • The install-wide key, with no session named, is refused since 19 November 2026 (the host's plugin command trust contract, the-install-wide-key-is-refused-hidden-data). On a host older than that change the read fence still admits the install-wide key when the call carries no X-AMC-Source-Session-Id, which a caller can arrange with the helper's --no-session flag.
  • The host's Decks CLI and export routes (decks-cli-store.ts). They always read the plugin's collections directly, outside the fence.

Driving Decks without the screen (for an AI agent)

An AI agent can read and edit decks through the control server with no window open. Every route, its limits and its approval rules are in the omniscio-control skill's decks page (.claude/skills/omniscio-control/decks.md); this section keeps the rules that stay true.

  • Finding it. GET /capabilities/search?q= with words such as slides, slideshow, PowerPoint, speaker notes or deck lands on the Decks entry. Until Decks is installed and switched on, every Decks route answers 403 and names which of the two is missing.
  • What an agent can do. List, read, create, rename, retheme, delete and restore decks; add, reorder, edit (layout, content, style, speaker notes), delete and restore slides; export a deck as PDF, PowerPoint or HTML. Reads are limited to 60 a minute and writes to 10.
  • What it cannot do. Decks declares no plugin actions (its manifest has no cli section), so GET /decks/:id/actions answers an empty list and no route builds slides or starts a motion or video run. POST /decks makes an empty deck; the person builds the slides in the Decks panel.
  • Export is free and headless. It returns the file as base64 with no dialog and no AI call, and refuses a deck that has no slides.
  • Publishing asks the person first. By default POST /decks/:id/publish raises one approval card and answers 202 with no link; the link exists only after the person approves, and editing the deck while the card waits cancels it. A deck with no slides is refused, and the request takes no body.
  • Deleting is soft. A deleted deck can be restored until the Decks screen next loads and finishes removing it.
  • Run records are private. The deck's runs, motion runs and video answer 403 to an agent session's own key, for the reason given in the section above.

Editing a slide

The editor shows one slide at a time, large, with every slide of the deck in a strip underneath: a small picture of each slide with its number in the corner. An ordinary mouse wheel scrolls the strip sideways and hands the scroll back to the page at either end; a fade at an edge means more slides continue that way; the slide being edited has a full outline; and a New slide tile at the end adds a slide after the last one and opens it. Beside the strip Decks says which slide you are on and its section (for example Slide 4 of 12), and a small gap marks where each section starts.

The editor frames each slide in a colour taken from the deck itself: a light deck sits on its own dark ink and a dark deck on a deeper shade of its background, while a deck without colours of its own keeps its style's colour. The round colour button at the right end of the toolbar under the slide picks another for that deck: one of the deck's colours, a neutral or any colour, or Automatic to go back. It only changes the editor; slides, downloads, shares and presenting look the same. It is set in the editor only, with no command-line route to it.

In the Cards view the slides can be zoomed (the zoom sets the minimum tile width of the grid, so tiles re-lay-out rather than being magnified; the canvas view is untouched and each deck opens at 100%): Ctrl (Cmd on a Mac) with the mouse wheel, Ctrl+= and Ctrl+-, or the zoom buttons, and Ctrl+0 or the percentage between them goes back to 100%. The slides are laid out again at the new size rather than enlarged like a picture, and a plain wheel still scrolls. Text in a drawn slide cannot be selected with the mouse except while typing on it, which is what lets the wheel, and a click in present mode, reach Decks over a drawn slide.

On a designed (drawn) slide the author changes words by typing on the slide itself, the way Canva and PowerPoint work. Pointing at words marks them, clicking puts the caret there, and Edit text (or F2) starts at the first words. Enter or Esc finishes, Tab moves to the next text, and a label inside a chart or diagram opens in a small box beside it. Each finished piece of text is saved at once as one step in the slide's history, so Undo takes it back, and quick edits and speaker notes written in between are saved in order.

Only the words change: the slide's design, its embedded pictures and any hand adjustments survive, and the slide shows exactly what will be saved. A slide whose words cannot be matched to its design safely says so and is left alone, and a save that fails says so and shows the saved words again. The editing view runs no script from the slide, like every other view of it. The slide's code is still reachable, but only through Edit slide code (advanced) in the slide tools, and a picture still on the slide stays embedded after a code edit.

Beyond typing on the slide, the slide tools cover the rest of editing. Undo and Redo (Ctrl+Z, and Ctrl+Shift+Z or Ctrl+Y) step through each change to a slide, and each card's Version history lists earlier versions you can preview and restore. Move puts a slide earlier or later, and the Layout list changes a template slide's layout. The cards view is a grid of slide tiles (number, title, Drawn and No notes tags; the zoom sets the tile size) with one panel for the selected slide: Edit (Edit text, Improve with AI), Order (Move earlier, Move later), History (Undo, Redo, Version history) and More for this slide (Move things by hand, Switch layout…, Edit slide code, Delete this slide…). Every greyed button shows its reason as text, Delete asks "Delete slide N, “title”?" first, Improve and notes rewrites say they use AI, and below about 48rem of pane the panel sits under the grid. A text editor stays open with what was typed when a save fails, and a half-typed note is saved when the panel goes away. A designed slide has no layout to switch, because its document is the whole slide: the cards view greys out Switch layout… with the reason "Only for slides made from a layout.", and the store refuses the change for any caller. Saving a slide's notes or words never changes a layout it did not touch; a save re-derives the layout only when it changes which blocks the slide holds. Improve slide sends the slide back to the AI with what you want changed (leave the note blank for a general improvement), while Start over draws a fresh version from the plan; either way the new version is shown beside the old one and nothing replaces the slide until you press Keep the new one. Move things by hand lets you select an element on a designed slide and move it, resize it, or change its text size, colour and weight. Speaker notes are edited in the strip under each slide, where Write with AI (Rewrite with AI once there are notes) asks the AI to write them. When the box already holds text, it first asks Replace your notes with AI-written ones? (Replace saves your words and rewrites from them, Keep mine asks nothing), and every box holding that slide's notes is locked ("Locked while the AI writes these notes.") until the AI's notes land. Improve slide and Start over never change a slide's notes, so use Rewrite with AI after a change you want the talk to follow. Deleting a slide asks first and cannot be undone.

Publish to the web

A Share button in the deck editor publishes the deck as one self-contained web page anyone can open on any device. The editor asks first, because a shared deck carries every slide and its speaker notes and anyone with the link can read the notes. The command line asks too: over the CLI, publishing raises one approval card naming the deck and saying the link is public and carries the notes, and the link exists only after you approve it — so an agent can build and arrange a deck but only you decide it becomes a web page. Editing the deck while that card waits cancels it, because the approval is tied to the slides you were shown. The approval is on by default; you can turn Publish a deck to the web off in Settings → CLI Control, and only you can change that switch. Sharing rides the existing Share Artifacts pipeline, so a published deck also appears in the Shares panel (revoke / expire / manage like any other share), and that pipeline reuses an existing share when the content is identical, so sharing an unchanged deck again normally gives the same link rather than a duplicate.

  • One viewer document, built by the plugin. The plugin assembles the page itself (src/plugins/decks/src/deck-model/deck-viewer-document.ts), and the HTML download saves that same page. It carries each slide as its own 1280x720 document in a sandboxed frame, scaled to fit the screen at 16:9 on a black surround, with the arrow keys, Space, PageUp, PageDown, Home and End, click zones on the slide, a dock, a fullscreen present mode (F), a presenter view (S: the next slide, your notes and a clock) and a help card (?). It has no theme switcher, and nothing in it can recolour a slide. It does not use Omniscio's own deck renderer (deck-render.ts), which PowerPoint export still captures slides through.
  • Security. Every slide is shown in a sandboxed frame (sandbox="") that runs no script, and the deck's data is embedded with every < escaped, so a slide containing </script> cannot break out of the page's own script. Fullscreen is requested and, where the sandbox refuses it, the viewer still works.
  • Handler. The plugin calls the bridge's share.publishArtifact with the finished document and fullBleed: true so the page fills the tab (it needs the manifest's firebase permission), and Omniscio publishes it through shareArtifactService with the source type plugin-publish. The editor refuses a deck with no slides, turns a failure into a plain sentence, and blocks a second click while a publish is running.

Real images + generative art

Image blocks now produce pixels, not an empty placeholder:

  • Real photos. When a block carries a valid http(s) url, the published viewer emits a real <img> (object-cover, lazy, alt-labelled). The URL is escaped via the viewer's esc() so a stray quote can't break out of the attribute, and an onerror removes a broken image so the art beneath shows through.
  • Generative art (the always-present base). src/shared/decks/deck-visuals.ts is a deterministic, seeded mesh-gradient generator — deckArtBackground(seed) returns a plain CSS background value; the seed comes from the card's content (deckArtSeed). It is theme-independent on purpose (real media doesn't recolour when you switch deck theme) and pure (no Date/Math.random), so the published render stays byte-deterministic. Used behind image / cover / section slides, always under a scrim that keeps overlaid text legible — a deck looks designed even with zero photos. The gallery layout seeds one art per tile via deckGalleryArts(seed) (shared by the published viewer + the PDF so they can't drift).

Image generation (a paid image model) is still deferred — this wave renders real URLs + procedural art; wiring an image provider is a follow-up.

What Decks costs the app (speed and size)

What Decks costs Omniscio, measured rather than estimated, except the two parts marked as read from the code. The figures below were measured on 8 November 2026 on Windows, on a development build of Decks 1.3.8, in a throwaway worktree. Two full production builds, one after the other, produced byte-identical output, so the numbers are stable rather than one build's accident. A full build took 28 seconds (the panel step alone 11.6 s). They describe that build on that machine; the translation catalogs, the re-embedded video player and any later change move them, so quote none of them without these conditions and measure again after the next release.

What it ships. Gzipped sizes are Node zlib.gzipSync at level 9 on each file separately.

part files raw gzipped
JavaScript 3 3,153,929 B 1,007,433 B
CSS 1 72,495 B 12,476 B
fonts 2 56,648 B 56,704 B
HTML 1 1,261 B 639 B
panel total 7 3,284,333 B 1,077,252 B
backend bundle 1 3,008 B 1,123 B

The JavaScript is the cost (96.0 percent of the panel), not the fonts (1.7 percent).

The biggest contributors. The PDF reader library pdfjs-dist is 1,757,006 B raw, 53.5 percent of the panel by itself (53.9 percent counting its whole file, 1,770,038 B), and it sits in its own file that loads only when an author attaches a file other than a picture. The rest of the main file is Decks' own code (1,072,811 B, 77.8 percent of that file), then react-dom (202,205 B), zod (55,914 B) and lucide-react (29,747 B). The two largest single Decks files are the vendored video player (73,394 B) and deck-generate.ts (48,330 B).

What loads when.

  • At app start: only the backend, 3,008 B, which registers five request handlers and starts no timer, no network call and no file work.
  • When the panel opens: index.html, the main script and the stylesheet, 1,452,390 B raw and 466,642 B gzipped (44.2 percent of the panel by raw size). The two fonts come in as screens use them (read from the code of that build, not measured).
  • Only when an author attaches a non-picture file: the PDF reader file, 1,770,038 B raw and 551,423 B gzipped.
  • Only when a Designer-route build runs: a 5,257 B file.

What it costs while closed or hidden (read from the code of that build, not measured). The backend does nothing recurring and keeps one session id and at most 200 remembered run ids in memory. The host mounts a plugin panel only while it is the active screen, keeps it mounted but hidden while it is the last active plugin screen or a run is holding it busy (at most three plugin screens at once), and unmounts any other. A hidden panel keeps running its JavaScript, subject to the browser's background throttling. The timers inside the panel (a build watchdog once a minute while a build is armed, a keep-open heartbeat while a build, motion render or video holds the screen, progress pulses during renders and one-second clocks on screens that show elapsed time) run only during a deck build or on an open screen.

NOT MEASURED. The app's own running cost with and without Decks (heartbeat lag, memory of the app and its process tree), the panel's open time, the machine cost of a real deck build and the size of the release archive were not measured, and this page gives no figure for them. The recipe approved on 12 November 2026 has not yet run and covers only idle heartbeat lag, process-tree memory and panel open time: an isolated Electron end-to-end harness started through launchElectronGated() on a throwaway profile, never the owner's live app or login and never a dev copy of the app; seven runs of the app with Decks installed and seven without; for each run the heartbeat lag and the memory of the whole process tree after 5 minutes idle, and for the panel the time from mount to first paint over seven opens; report the medians with their spread, the commit and the machine. This recipe does not measure the machine cost of a real deck build or the size of the release archive.

Measuring it again. Bundle bytes: run npm run build inside src/plugins/decks twice, then size and hash every file under ui/ and dist/backend/ (both folders are gitignored). Contributors: vite build --sourcemap --outDir <a folder outside the repo> with NODE_ENV=production, then credit each stretch of output to its source file through the source maps.

This page is split across four parts: part 2 covers what each card is told when it is generated, the theme colour, presenter mode and speaker notes, PDF / HTML / PowerPoint export, and the data model, IPC surface and key files behind it all; part 3 covers installing Decks, the plugin panel and what it reaches, and deleting a deck; part 4 covers motion design and the narrated video. The virtual-project row itself behaves like any other sidebar entry, which is covered on the projects sidebar page, and a published deck is managed with everything else you have shared — see share artifacts.

Last verified 2026-11-05