@vellumai/assistant 0.8.7-dev.202606052232.2ddc989 → 0.8.8

package/src/acp/auto-install.test.ts

@@ -1,196 +0,0 @@
-/**
- * Tests for the silent ACP adapter auto-installer.
- *
- * `execFile` is stubbed via the shared `installExecFileStub` helper: a
- * process-global `mock.module("node:child_process", ...)` driven by per-call
- * scripted responses keyed on `${command} ${args[0]}`. The
- * `resolveAgentWithAutoInstall` ordering suite additionally stubs the ACP
- * config and `Bun.which` so it can flip bun / adapter-binary presence.
- */
-
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { installAcpConfigStub } from "./__tests__/helpers/acp-config-stub.js";
-import { installExecFileStub } from "./__tests__/helpers/exec-file-stub.js";
-import { installWhichStub } from "./__tests__/helpers/which-stub.js";
-
-const { execScripts, execFileMock, reset } = installExecFileStub();
-const config = await installAcpConfigStub();
-const which = installWhichStub();
-
-afterAll(() => {
-  which.restore();
-});
-
-// Spread the real module so other test files that load logger consumers
-// (e.g. `truncateForLog` importers) after this process-global mock still
-// resolve every named export.
-const realLogger = await import("../util/logger.js");
-mock.module("../util/logger.js", () => ({
-  ...realLogger,
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-const {
-  ensureAdapterInstalled,
-  resolveAgentWithAutoInstall,
-  _resetAdapterInstallCacheForTests,
-} = await import("./auto-install.js");
-
-beforeEach(() => {
-  reset();
-  _resetAdapterInstallCacheForTests();
-  config.setConfig({ agents: {} });
-  which.setWhich({});
-});
-
-describe("ensureAdapterInstalled", () => {
-  test("known command: runs `npm i -g <pkg>` and reports installed", async () => {
-    execScripts.set("npm i", { stdout: "" });
-
-    const result = await ensureAdapterInstalled("claude-agent-acp");
-
-    expect(result).toEqual({ installed: true });
-    expect(execFileMock).toHaveBeenCalledTimes(1);
-    const [command, args] = execFileMock.mock.calls[0];
-    expect(command).toBe("npm");
-    expect(args).toEqual([
-      "i",
-      "-g",
-      "@agentclientprotocol/claude-agent-acp",
-    ]);
-  });
-
-  test("unknown command: never invokes npm (security allowlist)", async () => {
-    const result = await ensureAdapterInstalled("some-arbitrary-binary");
-
-    expect(result.installed).toBe(false);
-    expect(result.error).toBeUndefined();
-    expect(execFileMock).not.toHaveBeenCalled();
-  });
-
-  test("npm failure: reports the error and does not install", async () => {
-    execScripts.set("npm i", {
-      error: new Error("EACCES: permission denied"),
-    });
-
-    const result = await ensureAdapterInstalled("codex-acp");
-
-    expect(result.installed).toBe(false);
-    expect(result.error).toContain("EACCES");
-  });
-
-  test("failed install is retried on the next call", async () => {
-    execScripts.set("npm i", { error: new Error("network down") });
-    const first = await ensureAdapterInstalled("claude-agent-acp");
-    expect(first.installed).toBe(false);
-
-    execScripts.set("npm i", { stdout: "" });
-    const second = await ensureAdapterInstalled("claude-agent-acp");
-    expect(second.installed).toBe(true);
-    expect(execFileMock).toHaveBeenCalledTimes(2);
-  });
-
-  test("successful install is cached for the process lifetime", async () => {
-    execScripts.set("npm i", { stdout: "" });
-
-    await ensureAdapterInstalled("claude-agent-acp");
-    await ensureAdapterInstalled("claude-agent-acp");
-
-    expect(execFileMock).toHaveBeenCalledTimes(1);
-  });
-
-  test("concurrent calls dedupe to exactly one `npm i -g`", async () => {
-    execScripts.set("npm i", { stdout: "" });
-
-    const [a, b, c] = await Promise.all([
-      ensureAdapterInstalled("claude-agent-acp"),
-      ensureAdapterInstalled("claude-agent-acp"),
-      ensureAdapterInstalled("claude-agent-acp"),
-    ]);
-
-    expect(a.installed).toBe(true);
-    expect(b.installed).toBe(true);
-    expect(c.installed).toBe(true);
-    expect(execFileMock).toHaveBeenCalledTimes(1);
-  });
-
-  test("different commands install independently", async () => {
-    execScripts.set("npm i", { stdout: "" });
-
-    const [claude, codex] = await Promise.all([
-      ensureAdapterInstalled("claude-agent-acp"),
-      ensureAdapterInstalled("codex-acp"),
-    ]);
-
-    expect(claude.installed).toBe(true);
-    expect(codex.installed).toBe(true);
-    expect(execFileMock).toHaveBeenCalledTimes(2);
-    const installedPackages = execFileMock.mock.calls.map(
-      (call) => (call[1] as string[])[2],
-    );
-    expect(installedPackages.sort()).toEqual([
-      "@agentclientprotocol/claude-agent-acp",
-      "@zed-industries/codex-acp",
-    ]);
-  });
-});
-
-describe("resolveAgentWithAutoInstall - resolution order", () => {
-  test("binary missing + bun present: resolves via bunx without invoking npm", async () => {
-    which.setWhich({ bun: "/usr/local/bin/bun" });
-
-    const result = await resolveAgentWithAutoInstall("claude");
-
-    expect(result.resolved.ok).toBe(true);
-    if (!result.resolved.ok) return;
-    expect(result.resolved.agent.command).toBe("bun");
-    expect(result.resolved.agent.adapterCommand).toBe("claude-agent-acp");
-    expect(result.autoInstalledPackage).toBeUndefined();
-    expect(result.failureMessage).toBeUndefined();
-    expect(execFileMock).not.toHaveBeenCalled();
-  });
-
-  test("binary + bun missing, npm install succeeds: falls back to the npm flow", async () => {
-    let installed = false;
-    which.setWhich((cmd) =>
-      installed && cmd === "claude-agent-acp"
-        ? "/usr/local/bin/claude-agent-acp"
-        : null,
-    );
-    execScripts.set("npm i", {
-      stdout: "",
-      onCall: () => {
-        installed = true;
-      },
-    });
-
-    const result = await resolveAgentWithAutoInstall("claude");
-
-    expect(result.resolved.ok).toBe(true);
-    if (!result.resolved.ok) return;
-    expect(result.resolved.agent.command).toBe("claude-agent-acp");
-    expect(result.autoInstalledPackage).toBe(
-      "@agentclientprotocol/claude-agent-acp",
-    );
-    expect(execFileMock).toHaveBeenCalledTimes(1);
-  });
-
-  test("binary, bun, and npm all missing: failure message carries the hint and install error", async () => {
-    execScripts.set("npm i", { error: new Error("spawn npm ENOENT") });
-
-    const result = await resolveAgentWithAutoInstall("claude");
-
-    expect(result.resolved.ok).toBe(false);
-    expect(result.failureMessage).toContain(
-      "claude-agent-acp is not on PATH",
-    );
-    expect(result.failureMessage).toContain(
-      "npm i -g @agentclientprotocol/claude-agent-acp",
-    );
-    expect(result.failureMessage).toContain("ENOENT");
-  });
-});

package/src/acp/auto-install.ts

@@ -1,177 +0,0 @@
-/**
- * Silent auto-install for known ACP adapter binaries.
- *
- * Fallback path: the resolver (`resolve-agent.ts`) already rewrites missing
- * allowlisted adapters to run via `bun x` when `bun` is on PATH, so
- * `binary_not_found` only reaches this module when bun is absent (or the
- * command has no package mapping). When a spawn does fail preflight with
- * `binary_not_found`, callers (the `acp_spawn` tool and the `/v1/acp/spawn`
- * route) call `resolveAgentWithAutoInstall(agentId)`, which tries a global
- * npm install of the mapped adapter package, then re-resolves and continues.
- * On failure they fall back to the existing actionable install hint.
- *
- * Security boundary: only commands present in `DEFAULT_AGENT_NPM_PACKAGES`
- * are ever installed. The package names are vendored constants, NOT user
- * input: an arbitrary command from user config must never be turned into
- * an `npm i -g <attacker-controlled-name>` execution.
- */
-
-import { execFile } from "node:child_process";
-
-import { DEFAULT_AGENT_NPM_PACKAGES } from "../config/acp-defaults.js";
-import { getLogger } from "../util/logger.js";
-import {
-  resolveAcpAgent,
-  type ResolveAcpAgentResult,
-} from "./resolve-agent.js";
-
-const log = getLogger("acp:auto-install");
-
-/** Per-install timeout for `npm i -g`. Generous: cold npm caches are slow. */
-const NPM_INSTALL_TIMEOUT_MS = 120_000;
-
-export interface AdapterInstallResult {
-  installed: boolean;
-  error?: string;
-}
-
-/**
- * Per-command install promises. Concurrent spawns for the same missing
- * binary dedupe to a single `npm i -g`; successful results are cached for
- * the process lifetime. Failed installs are evicted so a later spawn can
- * retry (e.g. after the user fixes network or npm permissions).
- */
-const installPromises = new Map<string, Promise<AdapterInstallResult>>();
-
-/**
- * Run `execFile` with an AbortController-driven timeout. Returns the stdout
- * on success; throws on error or timeout. Shared by the adapter installer
- * here and the version probes in `tools/acp/spawn.ts`.
- */
-export function execFileWithTimeout(
-  command: string,
-  args: string[],
-  timeoutMs: number,
-): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    execFile(
-      command,
-      args,
-      { signal: controller.signal, encoding: "utf8" },
-      (err, stdout) => {
-        clearTimeout(timer);
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve(stdout);
-      },
-    );
-  });
-}
-
-/**
- * Install the npm package mapped to `command` if (and only if) the command
- * is a known adapter binary. Unknown commands resolve to
- * `{ installed: false }` without ever invoking npm (see the security
- * boundary note in the module doc).
- */
-export function ensureAdapterInstalled(
-  command: string,
-): Promise<AdapterInstallResult> {
-  const packageName = DEFAULT_AGENT_NPM_PACKAGES[command];
-  if (!packageName) {
-    return Promise.resolve({ installed: false });
-  }
-
-  const inFlight = installPromises.get(command);
-  if (inFlight) return inFlight;
-
-  const promise = runInstall(command, packageName).then((result) => {
-    if (!result.installed) installPromises.delete(command);
-    return result;
-  });
-  installPromises.set(command, promise);
-  return promise;
-}
-
-async function runInstall(
-  command: string,
-  packageName: string,
-): Promise<AdapterInstallResult> {
-  log.info({ command, packageName }, "Auto-installing missing ACP adapter");
-  try {
-    await execFileWithTimeout(
-      "npm",
-      ["i", "-g", packageName],
-      NPM_INSTALL_TIMEOUT_MS,
-    );
-    log.info({ command, packageName }, "ACP adapter auto-install succeeded");
-    return { installed: true };
-  } catch (err) {
-    const error = err instanceof Error ? err.message : String(err);
-    log.warn(
-      { err, command, packageName },
-      "ACP adapter auto-install failed (falling back to install hint)",
-    );
-    return { installed: false, error };
-  }
-}
-
-export interface ResolveWithAutoInstallResult {
-  /** The final resolver outcome (post-install re-resolve when applicable). */
-  resolved: ResolveAcpAgentResult;
-  /** Set when a missing adapter binary was silently installed via npm. */
-  autoInstalledPackage?: string;
-  /**
-   * Set when the auto-install itself failed: the original install hint
-   * augmented with the npm failure reason. Callers should surface this
-   * instead of re-deriving a message from `resolved`.
-   */
-  failureMessage?: string;
-}
-
-/**
- * Resolve an ACP agent id, silently auto-installing the mapped adapter
- * package when (and only when) the failure is a missing allowlisted binary.
- * Shared by the `acp_spawn` tool and the `/v1/acp/spawn` route so the
- * resolve-install-re-resolve flow has a single implementation; callers map
- * the result to their transport (tool error result vs. HTTP error class).
- */
-export async function resolveAgentWithAutoInstall(
-  agentId: string,
-): Promise<ResolveWithAutoInstallResult> {
-  const resolved = resolveAcpAgent(agentId);
-  if (resolved.ok || resolved.reason !== "binary_not_found") {
-    return { resolved };
-  }
-
-  const { command, hint } = resolved;
-  const install = await ensureAdapterInstalled(command);
-  if (install.installed) {
-    const retried = resolveAcpAgent(agentId);
-    if (retried.ok) {
-      log.info(
-        { agentId, command },
-        "Auto-installed missing ACP adapter binary",
-      );
-      return {
-        resolved: retried,
-        autoInstalledPackage: DEFAULT_AGENT_NPM_PACKAGES[command],
-      };
-    }
-  } else if (install.error) {
-    return {
-      resolved,
-      failureMessage: `${command} is not on PATH. ${hint} (auto-install failed: ${install.error})`,
-    };
-  }
-  return { resolved };
-}
-
-/** @internal: exposed for tests only. */
-export function _resetAdapterInstallCacheForTests(): void {
-  installPromises.clear();
-}

package/src/acp/feature-gate.test.ts

@@ -1,48 +0,0 @@
-/**
- * Tests for the ACP feature gate.
- *
- * `isAcpEnabled` is an OR of the `acp` feature flag and the legacy
- * `config.acp.enabled` field: either switch enables the subsystem, and
- * neither implicitly flips the other.
- */
-
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { setOverridesForTesting } from "../__tests__/feature-flag-test-helpers.js";
-import type { AssistantConfig } from "../config/schema.js";
-import { ACP_FLAG_KEY, isAcpEnabled } from "./feature-gate.js";
-
-beforeEach(() => {
-  setOverridesForTesting({});
-});
-
-afterEach(() => {
-  setOverridesForTesting({});
-});
-
-/** Minimal AssistantConfig carrying only the `acp` section the gate reads. */
-function makeConfig(acpEnabled: boolean): AssistantConfig {
-  return {
-    acp: { enabled: acpEnabled, maxConcurrentSessions: 4, agents: {} },
-  } as AssistantConfig;
-}
-
-describe("isAcpEnabled", () => {
-  test("returns false when both the flag and config.acp.enabled are off", () => {
-    expect(isAcpEnabled(makeConfig(false))).toBe(false);
-  });
-
-  test("returns true when config.acp.enabled is true and the flag is off", () => {
-    expect(isAcpEnabled(makeConfig(true))).toBe(true);
-  });
-
-  test("returns true when the flag is on and config.acp.enabled is false", () => {
-    setOverridesForTesting({ [ACP_FLAG_KEY]: true });
-    expect(isAcpEnabled(makeConfig(false))).toBe(true);
-  });
-
-  test("explicit flag-off override does not defeat config.acp.enabled", () => {
-    setOverridesForTesting({ [ACP_FLAG_KEY]: false });
-    expect(isAcpEnabled(makeConfig(true))).toBe(true);
-  });
-});

package/src/acp/feature-gate.ts

@@ -1,34 +0,0 @@
-/**
- * ACP (Agent Client Protocol) feature gate.
- *
- * Single source of truth for whether the ACP subsystem is enabled. Modeled
- * on `credential-execution/feature-gates.ts`: the flag key is declared in
- * `meta/feature-flags/feature-flag-registry.json` and resolved through the
- * unified feature-flag resolver.
- *
- * The gate is an OR of two independent switches:
- *   1. `config.acp.enabled` — the original workspace config field. Preserved
- *      so existing workspaces with `acp.enabled: true` keep working without
- *      any migration.
- *   2. The `acp` feature flag — adds a UI toggle. Flag state is persisted by
- *      the gateway and hot-refreshed in the daemon via the
- *      `feature_flags_changed` SSE event, so toggling it takes effect
- *      without a restart or config-file edit.
- */
-
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
-import type { AssistantConfig } from "../config/schema.js";
-
-/** Gate for the ACP coding-agent subsystem (must match the registry). */
-export const ACP_FLAG_KEY = "acp" as const;
-
-/**
- * Whether ACP agent spawning/steering is enabled, via either the legacy
- * `acp.enabled` config field or the `acp` feature flag (see module doc).
- */
-export function isAcpEnabled(config: AssistantConfig): boolean {
-  return (
-    config.acp?.enabled === true ||
-    isAssistantFeatureFlagEnabled(ACP_FLAG_KEY, config)
-  );
-}

package/src/acp/resume-hint.ts

@@ -1,25 +0,0 @@
-/**
- * Shared `claude --resume` hint for ACP sessions.
- *
- * `claude --resume <id>` is Claude Code-specific (the claude-agent-acp
- * adapter binary). Other adapters resume differently or not at all, so the
- * hint is gated by the resolved adapter, not the agent id - this stays
- * correct when a user aliases an id to a different binary. Callers pass the
- * CANONICAL adapter command (`adapterCommandOf` in `resolve-agent.ts`), not
- * the raw spawn command, so the hint still fires when the claude adapter is
- * run via `bun x` (spawn command "bun").
- *
- * Used by the `acp_spawn` tool's success payload and the session manager's
- * completion notification so both surfaces render identical copy. Returns
- * an empty string for non-claude adapters; callers add their own
- * surrounding separators.
- */
-export function claudeResumeHint(
-  command: string,
-  cwd: string,
-  sessionId: string,
-): string {
-  return command === "claude-agent-acp"
-    ? `To resume: cd ${cwd} && claude --resume ${sessionId}`
-    : "";
-}

package/src/config/bundled-skills/app-builder/references/DESIGN_SYSTEM.md

@@ -1,48 +0,0 @@
-# Design System
-
-A design system CSS is auto-injected inside a `@layer`, so your styles always take priority. It provides element defaults and automatic light/dark mode switching via `prefers-color-scheme`.
-
-**Use `--v-*` variables and `.v-*` classes** — they handle light/dark mode automatically. No manual dark mode CSS needed.
-
----
-
-## Design tokens
-
-| Category        | Tokens                                                                                                                                                         |
-| --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Backgrounds** | `--v-bg`, `--v-surface`, `--v-surface-border`                                                                                                                  |
-| **Text**        | `--v-text`, `--v-text-secondary`, `--v-text-muted`                                                                                                             |
-| **Accent**      | `--v-accent`, `--v-accent-hover`                                                                                                                               |
-| **Status**      | `--v-success`, `--v-danger`, `--v-warning`                                                                                                                     |
-| **Spacing**     | `--v-spacing-xxs` (2px) / `-xs` (4px) / `-sm` (8px) / `-md` (12px) / `-lg` (16px) / `-xl` (24px) / `-xxl` (32px) / `-xxxl` (48px)                              |
-| **Radius**      | `--v-radius-xs` (2px) / `-sm` (4px) / `-md` (8px) / `-lg` (12px) / `-xl` (16px) / `-pill` (999px)                                                              |
-| **Shadows**     | `--v-shadow-sm`, `--v-shadow-md`, `--v-shadow-lg`                                                                                                              |
-| **Typography**  | `--v-font-family`, `--v-font-mono`, `--v-font-size-xs` (10px) / `-sm` (11px) / `-base` (14px) / `-lg` (17px) / `-xl` (22px) / `-2xl` (26px), `--v-line-height` |
-| **Animation**   | `--v-duration-fast` (0.15s) / `-standard` (0.25s) / `-slow` (0.4s)                                                                                             |
-| **Palettes**    | `--v-slate-{950..50}`, `--v-emerald-*`, `--v-violet-*`, `--v-indigo-*`, `--v-rose-*`, `--v-amber-*`                                                            |
-| **Constant**    | `--v-aux-white` (always `#FFFFFF` in both modes — use for text on filled/accent backgrounds)                                                                    |
-
----
-
-## Utility classes
-
-`.v-button` (`.secondary` / `.danger` / `.ghost`), `.v-card`, `.v-list` / `.v-list-item`, `.v-badge` (`.success` / `.warning` / `.danger`), `.v-input-row`, `.v-empty-state`, `.v-toggle`.
-
-⚠️ **Never hardcode `color: white` or `color: #fff`.** Use `var(--v-aux-white)` for text on filled/accent backgrounds, or `var(--v-text)` / `var(--v-text-secondary)` for text on surface backgrounds. Hardcoded white causes invisible text on light surfaces.
-
----
-
-## Custom themes
-
-When the user wants a specific branded look, write complete CSS with hardcoded colors and `@media (prefers-color-scheme: dark)` for dark variants. Don't mix `--v-*` auto-switching variables with hardcoded colors in the same element.
-
----
-
-## Theme detection in JavaScript
-
-```javascript
-console.log(window.vellum.theme.mode); // 'light' or 'dark'
-window.addEventListener("vellum-theme-change", (e) => {
-  console.log("Theme:", e.detail.mode);
-});
-```

package/src/config/bundled-skills/app-builder/references/RESPONSIVE.md

@@ -1,57 +0,0 @@
-# Responsive Baseline & Mobile-First Mode
-
-Every app must work across phone (~360px) to desktop (~1400px+).
-
-## Mode selection
-
-The conversation context's `<turn_context>` block carries an `interface:` field.
-
-**If `interface: ios`** (or any future mobile-web / android identifier):
-  → Mobile-first build. Design the narrow viewport first, enhance upward.
-
-**If `interface: macos` or `web`**:
-  → Desktop-first build. Design larger composition first; narrow fallback still meets the universal baseline below.
-
-**If field is absent or ambiguous**:
-  → Default to desktop-first unless the request implies phone use ("for my iPhone", "a tap-tracker I'll use on the go").
-
----
-
-## Universal baseline (every build, regardless of interface)
-
-### Viewport & safe areas
-
-- Set viewport meta: `<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">`. Never set `user-scalable=no` — it blocks accessibility zoom.
-- Pad the root container with `env(safe-area-inset-*)` so content clears the notch: `padding-top: max(var(--v-spacing-lg), env(safe-area-inset-top))`, mirrored for `-bottom` / `-left` / `-right`.
-- Use `100dvh` (dynamic viewport height), not `100vh`, for full-height containers.
-
-### Form controls
-
-- `<input>`, `<textarea>`, `<select>` must be `font-size: 16px` or larger, or iOS Safari will zoom on focus and break the layout. This applies to every build.
-- Add `inputmode` to text fields with structured input: `numeric` for integers, `decimal` for amounts, `email`, `tel`, `url`.
-
-### Touch & hover
-
-- Interactive elements must be ≥44×44pt. `.v-button` already meets this; for custom controls, set `min-height: 44px` explicitly.
-- Gate hover affordances behind `@media (hover: hover)` so they don't stick on touch devices.
-- Disable text selection on app chrome with `user-select: none; -webkit-user-select: none`.
-
-### Layout fluidity
-
-- Use fluid widths only. No fixed-pixel layouts. Prefer `%`, `fr`, `minmax`, `clamp()` over `px` on container widths.
-- At narrow widths, collapse tables into stacked cards with labels and values arranged vertically.
-- Size `vellum.widgets.*` chart containers in `vw` / `%`, not fixed `px`.
-
----
-
-## Mobile-first priorities (`interface: ios`)
-
-- Default body text to `--v-font-size-lg` (17px), not `--v-font-size-base` (14px).
-- Bump default vertical rhythm one step (e.g. `--v-spacing-md` → `--v-spacing-lg`).
-- One column as the default, not a fallback. Opt into multi-column only above `@media (min-width: 720px)`.
-- Bottom-anchor the primary action: `position: sticky; bottom: env(safe-area-inset-bottom)`.
-- Replace side modals and popovers with bottom sheets.
-
-## Desktop-first priorities (`interface: macos` / `web`)
-
-Multi-column composition, hover-rich affordances, denser information, side modals, inline primary actions. The universal baseline above is still the floor — narrow view must still work.

package/src/config/bundled-skills/app-builder/references/SLIDES.md

@@ -1,38 +0,0 @@
-# Presentation Slide Design
-
-Slides are a different domain from apps. Skip app-specific patterns (contextual headers, search/filter, toast notifications, form validation, custom routes). Slides are static content — build navigation and layouts with custom HTML/CSS.
-
-## Key principles
-
-- One idea per slide — understood in 3 seconds
-- Layout variety — 3+ different types per deck, never consecutive same-type
-- 8 layout types: Title, Stats, Bullets, Quote, Comparison, Timeline, Visual/Immersive, Closing/CTA
-- Bold backgrounds — dark, gradient, or strongly tinted
-- Max 6 bullets per slide, max 3 sentences body text
-- Never go below 15px for any visible text
-
-## Navigation
-
-Build slide navigation as your own component. Common patterns:
-- Keyboard: `ArrowLeft` / `ArrowRight` / `Space` / `Escape`
-- Click affordances at left/right edges
-- Slide counter pill in a corner (e.g. `3 / 12`)
-- Optional progress bar at the top
-
-## Layout templates
-
-- **Title** — Centered headline, optional subtitle, no body. Full-bleed background or gradient.
-- **Stats** — One huge number, label below, supporting paragraph optional.
-- **Bullets** — Heading + 3–6 short bullets. Avoid wall-of-text.
-- **Quote** — Pull quote in large italic type, attribution below, contrasting background.
-- **Comparison** — Two columns (before/after, us/them, problem/solution). Visual symmetry matters.
-- **Timeline** — Horizontal or vertical sequence with dates and milestones.
-- **Visual/Immersive** — Full-bleed image, gradient, or generated graphic with minimal text overlay.
-- **Closing/CTA** — Headline + single call to action. Mirror the title slide aesthetic.
-
-## What to avoid
-
-- Generic Keynote / PowerPoint aesthetic (default white background, sans-serif body, bullet lists everywhere)
-- Tiny text below 15px — slides are read across rooms
-- Same layout type used 3+ times in a row — vary the rhythm
-- Body paragraphs longer than 3 sentences — split into multiple slides