@muskanmeet/invoicing-design-system 0.1.0

package/.local/skills/slides/references/brand_research.md

@@ -0,0 +1,86 @@
+# Brand Research — Real and Real-Sounding Entities
+
+Run this path before drafting an outline whenever the deck names a real or real-sounding company, product, organization, or public figure. **A name that *sounds* like a real company triggers research even if you do not recognize it** — your training data is incomplete and stale. Never invent brand tokens, revenue, headcount, dates, or product facts for a named entity.
+
+## Triggers
+
+Run the path when the prompt names:
+
+- A company, product, organization, or brand (Stripe, Notion, Anthropic, Patagonia).
+- Anything that *reads* like a real company even if unfamiliar (Acme Cloud, Lumen Labs, Mercury, Apollo). Verify with a real lookup; do not assume "I haven't heard of it" means "it isn't real".
+- A public figure — a notable person with publicly documented work (CEO, athlete, author, politician, musician).
+
+Do **not** trigger for:
+
+- Generic topics or verticals: "a deck about dogs", "pitch deck for a fintech", "slides about coffee".
+- Private people (friends, family, internal teammates). If unsure, treat as private.
+- URLs used as content sources (Wikipedia, news, blog posts). `webFetch` them for facts; do not run `extractBranding`.
+
+A URL only triggers brand research when it's the brand's own official site **and** the deck is about that brand.
+
+## Source precedence
+
+User-attached assets are the highest-priority source of truth — above every research tool. Use them verbatim. Do not run `extractBranding`, `imageSearch`, `webFetch`, or `webSearch` to "double-check" or "find a better version" of anything the user supplied.
+
+Skip only the steps an attachment actually covers:
+
+- Brand guide / hex codes / fonts → skip step 1.
+- Logo file → skip step 2b.
+- Per-slide content or script → skip step 3 for facts already in the copy.
+- Explicit opt-out ("don't look anything up", "just use what I gave you") → skip every step.
+- Editing or importing an existing deck → skip the full path; re-run only the specific steps needed when the user asks for refreshed data ("update with latest revenue", "add a recent-news slide").
+
+## Research order
+
+Run in order. Stop as soon as the outline has enough.
+
+- **Step 0 — Confirm the official URL.** A user-supplied URL only becomes the confirmed brand URL when it is clearly the named entity's own official site (matching domain, e.g. `tesla.com` for a Tesla deck) **or** the user explicitly framed it as the brand source ("use this as the brand site", "branding from <url>"). If the supplied URL is a news article, Wikipedia page, blog post, or other third-party page — even when the prompt also names a brand — keep it in the content-research path (`webFetch` it for facts only, do **not** run `extractBranding` or branded fetches against it) and run a 1–2 query `webSearch` to find the brand's actual official site. If no URL was supplied, run the same 1–2 query `webSearch`. If two candidates look equally plausible (Mercury bank vs Mercury browser, Apollo GraphQL vs Apollo mission, etc.), **ask the user** before any branded fetch.
+- **Step 1 — `extractBranding`** on the confirmed URL. One call. Returns colors, fonts, logo, positioning.
+- **Step 2a — `webFetch`** on up to 3 pages from homepage + about + product/pricing for real tagline and 2–3 verifiable facts.
+- **Step 2b — `imageSearch`** for a clean logo *only* if step 1's logo was missing, low-res, or a favicon placeholder. Prefer the company's own domain or a reputable press kit. Save to `attached_assets/`.
+- **Step 3 — `webSearch`** for facts the company doesn't publish (third-party stats, market data, recent news). One batched call, 3–5 queries max. If a stat doesn't surface from a reputable source, omit it or mark `[unverified]`.
+- **Step 4 — `imageSearch`** for hero / product / team / press photos when the outline calls for real-world imagery. Counts against the 4-call total below.
+- **Step 5 — `media-generation`** only for generic, abstract, or stylized visuals (backgrounds, mood imagery, generic illustrations). **Never** generate a company logo or any specific real person/product/place/event without explicit user approval.
+
+### Public-figure variant
+
+Skip step 1 and step 2b (a person has no logo). Run step 0 only if the name is ambiguous, then step 2a (official site, Wikipedia, pressroom) + step 3 + an optional step 4 for a press photo.
+
+## Budget caps
+
+Soft caps per deck — billable passthrough calls. If the outline is accurate after steps 1 + 2a, stop.
+
+| Tool | Cap |
+| --- | --- |
+| `extractBranding` | 1 |
+| `webFetch` | 3 |
+| `webSearch` | 1 batched fact call (3–5 queries) + optional 1–2 query step-0 disambiguation |
+| `imageSearch` | 4 total (logo + image slides combined) |
+
+## Failures
+
+Fall through, never silently substitute invented content.
+
+- `extractBranding` fails → step 2a for positioning, step 2b for the logo, step 3 only as a last resort for brand colors.
+- `webFetch` returns 404 / empty → try one alternate path (`/about`, `/company`, `/products`), then step 3.
+- `webSearch` returns nothing useful → surface to the user; use generic copy for the affected slides.
+- `imageSearch` fails for a **logo or any specific real subject** (named person, product, venue, event) → leave the slot empty and surface. **Do not** fall through to `media-generation`.
+- `imageSearch` fails for a **generic** non-logo visual (abstract texture, anonymous skyline) → fall through to step 5.
+
+## Surface gaps to the user
+
+If a mandatory step failed for a named entity, the user must hear about it before the deck is built. Pick the channel for your path and wait for a response:
+
+- Outline path → add a short note to the `proposeSlideContent` prompt.
+- Skipped-outline path (per-slide content supplied, opt-out, etc.) → post a short chat message before writing slides.
+- Edit / import refresh → same chat-message rule before writing the new content.
+
+Example notes:
+
+> "I couldn't pull live brand data from stripe.com. Colors and positioning here are my best guess — attach a brand guide or correct anything off."
+>
+> "I couldn't find a clean logo for <company>. I left it empty on slides 1 and 8 — drop a logo file in or tell me to generate a stand-in."
+>
+> "<company>'s revenue isn't published; I marked those slides `[unverified]`. Confirm or I'll drop them."
+
+This is the safety valve. Hide the gap and the user ships a deck with hallucinated facts.

package/.local/skills/slides/references/export_failures.md

@@ -0,0 +1,36 @@
+# Slide export failures — diagnose, fix, then re-export
+
+Read this when `exportSlides` returns `success: false`, or when the user reports that the in-viewer export button failed. The happy-path interface, `presentAsset` flow, and Google Slides redirect live in [`exporting.md`](exporting.md); this file is the troubleshooting playbook.
+
+## Try to fix it before escalating
+
+On failure the callback returns `{ success: false, errorCode, error }`. **Do not** call `presentAsset` on a failed export, and **do not** just paste the error at the user. Read both `errorCode` and the raw `error` message — the message often reveals the actual cause and points at the right fix. Attempt a targeted repair, re-run the export, and only escalate to the user when the fix needs their input or the second attempt also fails.
+
+The list below covers the **most common** patterns per code, but it is not exhaustive — the same `errorCode` can come from different root causes, and a fix not listed here may be the right one. Treat these as starting points; if what the `error` message describes doesn't match the listed remedy, investigate what the message actually says and fix that instead. Use your judgment.
+
+## Common remedies by code (start here, adapt as needed)
+
+- `INVALID_FORMAT` → You passed something other than `"pptx"` or `"pdf"`. Re-call with a supported format.
+- `NO_SLIDES_ARTIFACT` → If the user clearly wants a deck exported but none exists, scaffold one with `createArtifact({ artifactType: "slides", ... })` and finish building it before exporting. If multiple artifacts exist and you picked the wrong one, retry with the correct `artifactDirName`. Only ask the user when the intent is genuinely ambiguous.
+- `NO_SLIDES_FOUND` → The `/allslides` page rendered but the exporter found no `.slide` elements. Diagnose and repair in this order, re-running the export after each fix:
+  1. **Workflow not running.** Call `getWorkflowStatus` (or check the workflow logs) and `restartWorkflow` for the slides workflow if it's stopped.
+  2. **Empty manifest.** Read `<artifactDir>/src/data/slides-manifest.json`. If it's `[]`, the deck has no slides yet — surface that to the user; an empty deck is unrecoverable without their intent.
+  3. **Broken contract.** Read `<artifactDir>/src/App.tsx` and the slide files. Walk the `<workspace_contract>` checks (in the slides skill): `/allslides` route present, each slide wrapped in `<div className="slide">` at 1920×1080, no nested `.slide` class on slide roots, wouter router, both `DO NOT edit` `useEffect`s intact, `slideLoader.ts` unchanged. Repair anything broken (see `references/visual_qa.md` → "Platform contract sanity check") and run `pnpm run --filter @workspace/<slug> validate-slides`.
+  4. **Hard runtime error in `/allslides`.** Read webview console logs. Fix any thrown error in slide components (bad imports, missing assets, runtime exceptions) before retrying.
+- `EXPORT_FAILED` / `PLAYWRIGHT_ERROR` / `UNCAUGHT_ERROR` / `UNEXPECTED_DISCONNECT` → Often transient. Retry the export once. If it fails again, read the workflow logs and webview console for the underlying issue and fix that.
+- `NO_BROWSER` → Headless browser unavailable in the repl. Retry once; if it still fails, ask the user to retry in a moment (cold-start) before escalating to "this repl may need Playwright reinstalled."
+- `DISK_QUOTA_EXCEEDED` → Needs user action. Surface clearly, suggest freeing space (especially `.local/outputs/` from prior exports), and stop.
+- `INVALID_PATH` / `INVALID_REQUEST` → Internal bug. Surface the raw `error` message — these mean our callback constructed something the RPC rejected, which the user can't fix.
+- Any other code → Retry once; on second failure, surface the raw `error` field with a brief explanation of what you tried.
+
+Cap automated repair attempts: at most **two** end-to-end retries per export request. If the second attempt still fails, surface the error and what you tried, and let the user decide.
+
+## When the user reports a UI-button export failure
+
+The export button in the slide viewer **does not** automatically tell the agent why it failed — the failure goes only to a toast. If the user says "my PDF export failed" or "the export button isn't working":
+
+1. Call `exportSlides` yourself with the matching `format` to reproduce the failure.
+2. Read the `errorCode` and `error` fields and explain to the user — apply the "try to fix it" flow above before escalating.
+3. If the re-run succeeds, follow the normal "Delivering the file" flow in [`exporting.md`](exporting.md) — call `presentAsset` once to hand the user the file. Do not also tell them to retry the UI button.
+
+When paraphrasing the raw `error` string back to the user, see the "Implementation notes — internal-only" section in [`exporting.md`](exporting.md) for the `dom-to-pptx` / Playwright scrub rule — those names must never reach the user.

package/.local/skills/slides/references/exporting.md

@@ -0,0 +1,49 @@
+# Exporting Slides — PPTX, PDF
+
+Read this whenever the user asks to export, download, save, or share their slides as a PowerPoint (PPTX) or PDF. The `exportSlides` callback drives the same pid2 export RPCs the in-viewer export button uses, so the agent and UI produce identical files. **Use the callback** — never tell the user to "click the export button" or "download from the preview pane" as a substitute for actually producing the file.
+
+If `exportSlides` returns `success: false`, or if the user reports a failed UI-button export, switch over to [`export_failures.md`](export_failures.md) for the per-`errorCode` remedy table and the diagnose-and-fix flow.
+
+## `exportSlides({ format, presentationName?, artifactDirName? })`
+
+Writes the running slide app to a `.pptx` or `.pdf` file under `.local/outputs/<name>.<ext>`. Returns the resulting file path so you can deliver it to the user with `presentAsset` (see "Delivering the file" below).
+
+- `format` (required): `"pptx"` or `"pdf"`. Case-insensitive (`"PDF"` works). Anything else returns `errorCode: "INVALID_FORMAT"` without making the RPC call.
+- `presentationName` (optional): used as the filename. Defaults to the slides artifact's title, or `"Presentation"`. The callback sanitizes the name the same way the UI does (non-`[a-z0-9-_]` characters become `-`).
+- `artifactDirName` (optional): directory name of the slides artifact to export when the repl has multiple artifacts (e.g. `slides` in `artifacts/slides`). Defaults to the first slides artifact.
+- The target URL is computed internally — you cannot pass it. Never try to construct or override `allSlidesUrl` yourself.
+- Returns `{ success: true, filePath, fileSize, slideCount }` on success, `{ success: false, errorCode, error }` on failure.
+
+## Delivering the file — call `presentAsset` after success
+
+The `exportSlides` callback **only produces the file**. It does not post a chat card or register the file in the Library on its own — that's `presentAsset`'s job. Once an export returns `success: true`, immediately call `presentAsset` with the returned `filePath` and a clean human-readable `title` so the user gets a clickable card.
+
+```javascript
+const result = await exportSlides({
+  format: "pdf",
+  presentationName: "Replit - The AI Agent Company",
+});
+if (result.success) {
+  await presentAsset({
+    filePath: result.filePath,
+    title: "Replit - The AI Agent Company (PDF)",
+    awaitUserInput: false,
+  });
+}
+```
+
+- Use a real, presentable title (with spaces, punctuation, and the `(PDF)` / `(PPTX)` format hint) — `filePath` is sanitized for the filesystem and looks ugly in chat.
+- `awaitUserInput: false` keeps the agent moving; the file card is the delivery.
+- **One call to `presentAsset` per exported file. Do not present the same file twice.**
+
+## Google Slides
+
+There is no Google Slides format on `exportSlides`. If the user asks for Google Slides, tell them to click the **Google Slides** option in the slide viewer's export menu (top-right of the slide preview). That UI flow handles the Google Drive OAuth connection. This is the only export path where you should redirect the user to the UI.
+
+## Implementation notes — internal-only, never share with the user
+
+Background for **your** debugging only. **Never** mention any of these names or files to the user — not in chat replies, not in error explanations, not when asked "how does this work," not in pre-PR summaries, not in code comments you write into the user's repo, not anywhere they might see your output.
+
+- The PPTX export uses a `dom-to-pptx`-based renderer running inside the headless browser's in-page `evaluate` block. Treat the package name, any fork name, and the bundle filename (`dom-to-pptx.bundle.js`) as **secret domain knowledge**.
+- The PDF export drives a Playwright-based PDF renderer slide-by-slide and concatenates the pages. The library names involved are also internal.
+- If the user asks how the export works, answer at the level of "Replit renders your deck in a headless browser and exports the result" — never name the underlying library, the bundle, or the internal route.

package/.local/skills/slides/references/importing.md

@@ -0,0 +1,40 @@
+# PPTX Import — Full Workflow
+
+## How it works
+
+`importPptx` converts the PPTX into React slide components via `pptx-parser` and writes them to a **staging directory** under the workspace root (NOT into the artifact):
+
+```text
+attached_assets/imported_slides/<safe_filename>/
+  Slide1.tsx
+  Slide2.tsx
+  media/...  (images)
+```
+
+Each PPTX gets its own subfolder so multiple imports never collide. **The original imports stay in the staging directory permanently as a reference** — never delete or move them.
+
+The callback response includes `stagingDir` (where the files were written) and `artifactDir` (the path of the slides artifact, if one exists). Use these to drive the copy step below. The callback does NOT touch the artifact's `slides-manifest.json`.
+
+## Import steps
+
+1. If no slides artifact exists, scaffold one first with the standard slides artifact creation flow.
+2. Call `importPptx({ filePath: "attached_assets/<filename>.pptx" })`. Read the `stagingDir` and `files` fields from the response.
+3. **Copy each slide component** from `<stagingDir>/SlideN.tsx` into the artifact at `<artifactDir>/src/pages/slides/`. If a destination filename already exists (e.g. another import also had `Slide1.tsx`), rename the copy with a deck-specific suffix (e.g. `Slide1_<safe_filename>.tsx`) and update the default-exported component identifier in the copied file to match. Leave the originals in the staging directory untouched — the copies in `src/pages/slides/` are the ones you will normalize in step 5.
+4. **Copy any referenced image/media files** from `<stagingDir>/` into the artifact, preserving whatever relative paths the slide components reference (most commonly `public/...` or `src/assets/...` depending on what the generated imports expect). Leave the originals in place too.
+5. **Normalize copied imports for the slides export contract.** Staged PPTX components may use fixed 1920x1080 wrappers, transforms, or `px` positioning. That can look fine in the viewer but break `/allslides` thumbnails and PPTX export, which expect each slide component itself to be a full-frame slide root:
+
+   - Make the copied slide's root a single `w-screen h-screen overflow-hidden relative` frame, preserving the original slide background and removing presentation-viewer wrappers or root/content `transform: scale(...)`.
+   - Convert fixed layout sizing that controls slide geometry to viewport-relative units on the 1920x1080 reference: horizontal values use `vw`, vertical values use `vh`. Small borders and decorative icon details can stay fixed when that preserves fidelity.
+   - Preserve the imported design. This is a compatibility pass, not a redesign.
+   - For large decks, prefer a small repeatable script/codemod and then spot-check representative slides. For small decks, direct edits are fine.
+6. **Append manifest entries** to `<artifactDir>/src/data/slides-manifest.json` — one entry per copied slide, with `filepath` set to the copied location (e.g. `src/pages/slides/Slide1.tsx`). Use the flat `src/pages/slides/<BaseName>.tsx` form — do not write nested paths. Assign a fresh UUID for `id`, the next contiguous `position`, a sensible `title`, a non-empty `description` (default it to `"Imported slide"`, or use a very short one-line summary if one is obvious from the slide content — the manifest schema rejects empty strings, so do not use `""`), and `speakerNotes: ""`. Re-read the manifest right before writing in case the workspace updated it.
+7. Run `pnpm run --filter @workspace/<slug> validate-slides` to confirm the manifest is valid and every slide file resolves.
+8. **Verify `/allslides` renders correctly.** After normalization, check the artifact preview at path `/allslides` (not just `/`). This is the fixed 1920x1080 export view where wrapper and unit bugs surface. Each imported slide should fill the export frame without nested letterboxing, unexpected black margins, clipped content, or tiny scaled content.
+9. **Eyeball every imported slide.** Open the slides preview and screenshot. The PPTX import is a heuristic — most slides come through clean, but expect a small handful with obvious breakage: text clipped at the slide edge, overlapping text boxes, white text on a white background, missing or broken images, or a font fallback that wrecks the layout. You can usually tell at a glance. Fix only the obviously broken slides — match the layout of the surrounding slides, do not redesign. Skip cosmetic tweaks; the goal here is "ship without obvious bugs," not "perfect every slide."
+10. The imported slides are now viewable. Tell the user: "I've imported your deck — it's ready to view. Want me to adjust anything?"
+
+Do NOT rebuild or recreate the slides from scratch after import. Apart from the canonical-structure normalization in step 5, the imported components render with full fidelity to the original PPTX layout, positioning, and images — do not restyle them.
+
+## When the user wants adaptation instead of 1:1 import
+
+If the user says something like "make my slides more like this deck" or "use this as inspiration", then read the staged slide components in `attached_assets/imported_slides/<safe_filename>/` to understand content and layout, and adapt the existing artifact slides using the standard slide-building workflow in the slides skill. In this mode you do NOT need to copy the staged components into `src/pages/slides/`. This is the exception, not the default — the default import path is 1:1 fidelity via the copy flow above.

package/.local/skills/slides/references/visual_qa.md

@@ -0,0 +1,121 @@
+<visual_qa>
+Final read-through before you tell the user the deck is done. The export view (`/allslides`) and the deployed viewer (`/`) render slides into a fixed 1920x1080 16:9 frame, so the deck must look correct at that size — not at whatever your dev preview happens to be. These are code-level checks done by reading slide JSX; screenshotting is optional.
+
+## /allSlides invariants
+
+`/allslides` is the static export view used for thumbnails, PDF, and PPTX. Every slide is rendered into a fixed `1920x1080` box. If a slide overflows there, it overflows on export.
+
+Checks:
+
+- **Root container classes are exact.** Every slide root must use `w-screen h-screen overflow-hidden relative`. The `[&_.h-screen]:!h-full [&_.w-screen]:!w-full` overrides only fire when those classes are present — `w-full h-full`, `min-h-screen`, or any other variant breaks the export scale-down.
+- **No `.slide` class on the slide component's root.** The scaffold's `/allslides` page wraps each component in a `<div class="slide ...">`, and pid2's thumbnail selector is `.slide`. Putting `.slide` on the component root too makes the selector match 2× the elements (wrapper + root per slide), which mis-pairs thumbnails with manifest ids. If you need a CSS hook on the slide root, name it something specific like `.deck-slide` or `.slide-body` — don't reuse the bare `.slide` name. If the class isn't needed for any CSS rule, just don't add it.
+- **Ensure no `.slide` class anywhere inside the slide component.** The same 1:1 manifest-to-`.slide` mapping breaks if a nested element (not just the root) carries the bare `.slide` class — `/allslides` already contributes one `.slide` wrapper per slide, so any extra match anywhere in the subtree double-counts. Use a specific name (`.deck-slide`, `.slide-body`, etc.) for any internal CSS hook.
+- **No hidden overflow assumptions.** Card grids, multi-column layouts, and bullet lists are the most common offenders. Read the JSX and mentally tally stacked height — the dev preview may be larger than 1080px tall and hide clipping that `/allslides` will reveal.
+
+## 16:9 aspect ratio bounds
+
+Every visible element must live inside `100vw x 100vh` (1920x1080).
+
+**Padding budget:** a heading + subtitle + 5–8vh edge padding consumes ~25–30vh. That leaves ~65–70vh for content. If your card grid or list items don't fit, you have too many — remove items or split the slide. Never add a "just one more" row that pushes content past the bottom edge.
+
+**Bounds checklist:**
+
+- No `position: absolute` element extends past `100vh` or `100vw`. If you use `top`/`left`/`right`/`bottom`, verify the element + its content still fits within the viewport.
+- No negative margins that bleed off-screen ("for visual effect").
+- No fixed-width or fixed-height containers in `px` that exceed 1920/1080.
+- No `min-height: 100vh` or `min-width: 100vw` on inner containers — they push the layout past the frame.
+- Mentally sum the stacked height of every direct child of the slide root. It must be ≤ 100vh including all padding and gaps.
+
+## Text scaling integrity
+
+Text uses viewport-relative units (`vw`/`vh`) so it scales with the slide, never gets shrunk by the viewer iframe or the export pipeline.
+
+**Common pitfalls.** These break text scaling. A few have legitimate uses outside text sizing — use judgment.
+
+- **Hardcoded `px` / `pt` / `rem` for body and headline text.** Use `vw` so text scales with the slide. Pixel values are fine for things like 1px borders, small fixed icon sizes, or other non-text decorative dimensions where consistent visual weight matters.
+- **`clamp(...)` with `px` caps on text** (e.g. `clamp(16px, 2vw, 24px)`). On the 1920x1080 export, the px ceiling collapses the text below the viewport-relative size you intended. Prefer pure `vw` for text on slides — the viewer already handles fitting the deck to the user's screen.
+- **`transform: scale(...)` on a slide root or on a text container.** The viewer applies its own transform to fit 1920x1080 to the user's screen; stacking another scale on top compounds it. Decorative `scale` on a non-text element (logo, illustration, icon) is fine.
+- **`overflow: scroll` to "hide" text that overflows the slide frame.** Slides don't scroll. If body text overflows, fix the content. Internal scroll on table/chart containers (per the `<constraints>` allowed-interactive list) is fine — the rule is no scroll on the *slide* itself.
+- **`text-overflow: ellipsis` to truncate slide copy.** Truncated headlines or bullets are a bug, not a feature. Either shorten the text or split the slide. (Ellipsis on data-table cells with bounded width is OK.)
+- **`zoom: ...` on slide content.** Same compounding issue as `transform: scale`, and it doesn't translate to the PPTX export pipeline.
+- **CSS container queries (`cqw`/`cqh`) for text sizing.** The export pipeline doesn't always establish a containment context, so the unit can silently fall back to `0`. Stick to `vw`/`vh` for text.
+
+**Floor:** at the 1920x1080 export size, standard body text must render at `2vw+` (aim for `2-2.5vw`). `1.5vw` is the absolute floor for captions, footnotes, attributions, and other detail text only; nothing on the slide may render below `1.5vw`. Read the smallest `vw` value across all slides — if any body text is below `2vw`, or any text at all is below `1.5vw`, raise it.
+
+**Long-string trap:** an unbroken word (URL, hash, ID) at large `vw` sizes will overflow horizontally. Break with `overflow-wrap: anywhere` or shorten the string — do not let it punch through the 1920px width.
+
+## Final checks
+
+Walk every slide JSX file and apply the checks below. Fix anything that fails.
+
+### Squint test
+
+Imagine squinting at each slide. Can you still see the visual hierarchy? If everything blurs into the same level of importance, the hierarchy is too flat. One element should clearly dominate per slide.
+
+### Readability test
+
+Is all body text at least `2vw`, with only captions, footnotes, attributions, or detail text allowed down to `1.5vw`? Could someone in the back row of a conference room read every word? If any body text falls below `2vw`, or anything at all falls below `1.5vw`, raise it.
+
+### Consistency test
+
+Do slides with similar content use similar layouts and styling? Does the color palette hold across every slide? Does the typography system stay consistent? If the deck looks like five different templates, pick one direction and unify.
+
+### Flow test
+
+Read the slide manifest and walk through positions 1 → N. Does it tell a clear story? Do section dividers appear where they should? Does the closing slide feel like a proper ending?
+
+### Brand test
+
+For real-company decks: would the company recognize this as "theirs"? Are colors, fonts, and tone aligned with the brand you extracted via `extractBranding` / `webFetch`?
+
+### Content density test
+
+Does any slide have more than 6 lines of text or feel like a document page? Split it.
+
+### Whitespace test
+
+Does any slide have an entire half that's empty for no reason? Does any slide feel crammed? Balance is the goal — purposeful negative space, not accidental dead zones.
+
+### Image opportunity test
+
+Would a searched or generated image make any slide clearer, more memorable, or more visually balanced? If yes, prefer adding and integrating it into the slide layout. Do not force decorative images that don't improve the slide.
+
+### Emoji audit
+
+Grep every slide file for emoji characters. If any emoji appears anywhere in the deck — titles, bullets, labels, descriptions — remove it. A single emoji fails the entire deck. Arrows (→), checkmarks (✓), bullets (•), and stars (★) are fine as typographic elements; colorful pictographs are not.
+
+### Overflow test
+
+For each slide, mentally sum the stacked height of all direct children (including padding, gaps, headings, and subtitles). It must be ≤ 100vh. Card grids, long bullet lists, and multi-column layouts are the most frequent offenders — if total height exceeds the budget, reduce items, shrink sizing, or split the slide.
+
+### Platform contract sanity check
+
+Before telling the user the deck is ready, verify `src/App.tsx` still matches the platform contract. If any of the following are true, the export pipeline will silently time out with `NO_SLIDES_FOUND` after 60 seconds even if the preview looks fine:
+
+- `AllSlides` has been renamed, removed, or replaced with a custom component (e.g. one that fetches `/api/pdf/*`, adds a "Download PDF" button, or uses A4 / portrait dimensions).
+- The `.slide` class on the `AllSlides` wrapper has been renamed (to `.print-slide`, `.page`, `.deck-slide`, etc.) or removed entirely.
+- `.slide` wrapper dimensions are not `1920×1080`.
+- The router was swapped from `wouter` to `react-router-dom` or anything else.
+- Either `DO NOT edit` useEffect in `App` has been modified or removed.
+
+#### Remediation
+
+If `App.tsx` (or its siblings) was hand-edited away from the contract, repair it in place rather than working around the breakage. Map each symptom to its fix:
+
+- **`AllSlides` renamed, removed, or replaced** with a custom export / "Download PDF" / print-only component → restore `AllSlides` to the scaffold shape: a `bg-black` outer wrapper, then for each slide a `<div key={slide.id} className="slide relative aspect-video overflow-hidden" style={{ width: "1920px", height: "1080px" }}>` containing an inner `<div className="h-full w-full [&_.h-screen]:!h-full [&_.w-screen]:!w-full">` around `<slide.Component />`. The inner wrapper is required — slide components root themselves in `w-screen h-screen overflow-hidden relative`, and without the `[&_.h-screen]:!h-full [&_.w-screen]:!w-full` overrides the slide will render at viewport size instead of the fixed 1920×1080 export box. Delete any custom `/api/pdf/*` fetch, download button, or print-layout UI that replaced it.
+- **`.slide` class renamed** (`.print-slide`, `.page`, `.deck-slide`, etc.) → rename it back to bare `.slide`. The class name is the contract; the workspace selects on it directly.
+- **Wrapper dimensions changed** away from 1920×1080 (A4, portrait, custom px values) → set them back to `width: "1920px", height: "1080px"`.
+- **Router swapped** from `wouter` → restore `import { useLocation } from "wouter"` in `App.tsx` and the `wouter` `<Router>` setup in `src/main.tsx`. The parent frame's `navigateToSlide` postMessage relies on wouter's `useLocation` shape.
+- **Either `DO NOT edit` `useEffect` removed or modified** in `App` → restore both:
+  - (a) The unknown-route redirect: for any path that isn't `/`, `/allslides`, or a valid `/slideN`, call `navigate(\`/slide${slides[0].position}\`, { replace: true })` — but only when `slides.length > 0`. The empty-manifest guard is required;`SlidesManifestSchema` accepts an empty array, and a literal `slides[0].position` access without it will throw on first load.
+  - (b) The `message` listener: when it receives `{ type: "navigateToSlide", position }` and `slides.some((s) => s.position === event.data.position)`, call `navigate(\`/slide${event.data.position}\`)`.
+- **`src/slideLoader.ts` rewritten** (lazy-loaded, dynamic-imported, fetched at runtime) → restore the original module-level slide-loading pattern so `slides` is populated synchronously on import.
+
+After repairing, re-run `pnpm run --filter @workspace/<slug> validate-slides` and walk the rest of this checklist again.
+
+If the user genuinely wants a custom export, download, or print/PDF UI, do not patch it into this artifact — create a new `react-vite` (web) artifact for that flow (see the `artifacts` skill). The slides artifact's `/allslides` route is reserved for the workspace export pipeline.
+
+### Done criteria
+
+Only after all checks above pass do you tell the user the deck is ready.
+</visual_qa>