@kitn.ai/ui 0.30.0 → 0.31.0

package/dist/mcp.es.js

@@ -9505,8 +9505,15 @@ function isSafeUrl(url) {
   const scheme = schemeOf(url);
   return scheme !== void 0 && SAFE_SCHEMES.includes(scheme);
 }
+const CHAT_MESSAGE_ACTIONS = ["copy", "like", "dislike", "regenerate", "edit", "speak"];
+const BUTTON_VARIANT_NAMES = ["default", "ghost", "subtle", "outline", "destructive"];
 const CONSTRUCT_SCHEMA_URL = "https://ui.kitn.ai/schemas/construct/v1.json";
 const TAG_RE = /^[a-z][a-z0-9]*-[a-z0-9-]+$/;
+const TriggerEntrySchema = z$1.object({
+  id: z$1.string().min(1),
+  label: z$1.string().min(1),
+  description: z$1.string().min(1).optional()
+}).strict();
 const ProviderSchema = z$1.discriminatedUnion("mode", [
   z$1.object({ mode: z$1.literal("mock") }).strict(),
   z$1.object({
@@ -9575,7 +9582,26 @@ const ConstructSchema = z$1.object({
     /** Rendered in ChatThread's built-in header bar (left side). Construct-
      *  authored/untrusted text, like theme.accent/provider.url — JSON.stringify'd
      *  at its one emit site, never a raw JSX attribute string. */
-    title: z$1.string().min(1).optional()
+    title: z$1.string().min(1).optional(),
+    /** Renders a theme-toggle Button in ChatThread's header-end region,
+     *  flipping the host's `theme` attribute (the attribute
+     *  defineWebComponent already owns) via the facade's ctx.element —
+     *  codegen work, no new kit surface (B-10). */
+    themeToggle: z$1.boolean().optional(),
+    /** Header action buttons (label + kit Button variant), rendered in
+     *  the header-end region. Vocabulary-never-logic: the construct
+     *  cannot say what an action DOES, so each click dispatches a
+     *  non-bubbling `kai-header-action` CustomEvent on the host with
+     *  `detail: { label }` — the consumer's listening seam (B-10).
+     *  `variant` derives from the kit Button's own list
+     *  (BUTTON_VARIANT_NAMES — B-6a), never restated. `label` is
+     *  construct-authored untrusted text, JSON.stringify'd at emit. */
+    actions: z$1.array(
+      z$1.object({
+        label: z$1.string().min(1),
+        variant: z$1.enum(BUTTON_VARIANT_NAMES).optional()
+      }).strict()
+    ).min(1).optional()
   }).strict().optional(),
   /** Greeting shown while the thread is empty (no messages yet) — the
    *  proven "welcome screen" pattern (Intercom-class): title + optional
@@ -9684,7 +9710,28 @@ const ConstructSchema = z$1.object({
      *  vocabulary; HOW it persists (the ConversationStore adapter,
      *  localStorage vs. a fetch endpoint) is codegen's call, never
      *  vocabulary here (C-3 — no transport-layer vocabulary). */
-    conversations: z$1.literal(true).optional()
+    conversations: z$1.literal(true).optional(),
+    /** Role-scoped default action bars, threaded onto ChatThread's
+     *  `userActions`/`assistantActions` props (B-3/B-7b). Ordered
+     *  arrays; enum ids ONLY, read off the ONE const
+     *  (CHAT_MESSAGE_ACTIONS — B-6): a CustomAction is an id the APP
+     *  must handle, a construct has no app code, so emitting one is a
+     *  dead affordance. Duplicates within one array rejected below
+     *  (superRefine, the slots pattern). min(1): an empty list IS the
+     *  absent key. */
+    messageActions: z$1.object({
+      user: z$1.array(z$1.enum(CHAT_MESSAGE_ACTIONS)).min(1).optional(),
+      assistant: z$1.array(z$1.enum(CHAT_MESSAGE_ACTIONS)).min(1).optional()
+    }).strict().optional(),
+    /** The citations STRIP (the `part="citations"` row consecutive
+     *  `source` parts already collapse into — message.tsx). `strip:
+     *  false` hides it (emits ChatThread's `hideSources`); `strip:
+     *  true` or the key absent emits NOTHING — the row already renders,
+     *  the kit default IS the on state, the same anchored-on-the-
+     *  default convention as `reasoning: 'full'` (B-4). */
+    sources: z$1.object({
+      strip: z$1.boolean().optional()
+    }).strict().optional()
   }).strict().optional(),
   /** Named generative-UI card definitions the model can emit as tool calls,
    *  rendered in the thread. Top-level (not a capability): a card is
@@ -9731,109 +9778,245 @@ const ConstructSchema = z$1.object({
     /** Seed Dock's open state at mount. Uncontrolled — never steals focus (Dock's
      *  own focus contract, dock.tsx). Omitted keeps Dock's own default (closed). */
     defaultOpen: z$1.boolean().optional()
+  }).strict().optional(),
+  /** Layout-scoped aside geometry, `layout: 'aside'` only (superRefine
+   *  below, mirroring `widget`'s scoping exactly). `position` picks the
+   *  docked inline edge (default 'end', today's hardcoded behavior);
+   *  `width` overrides codegen's 380px default. `width` is construct-
+   *  authored untrusted text: it lands as a JSON.stringify'd VALUE inside
+   *  the emitted Solid `style={{ }}` object — property assignment, the
+   *  same no-CSS-text-interpolation guarantee as setProperty — never
+   *  concatenated into a CSS string (B-2). */
+  aside: z$1.object({
+    position: z$1.enum(["start", "end"]).optional(),
+    width: z$1.string().min(1).optional()
+  }).strict().optional(),
+  /** Construct-wide shell chrome (10a): both members reuse REAL kit
+   *  pieces — command.tsx's CommandList behind a codegen-emitted overlay
+   *  (opened on Mod+K; entries DERIVE from what this construct enables —
+   *  menu-honesty against dead entries), and the documented Dropdown+
+   *  Avatar user-menu recipe. `name`/`plan` are construct-authored
+   *  untrusted text, JSON.stringify'd at emit like every sibling.
+   *  `commandPalette` is presence-only `z.literal(true)`, matching
+   *  `conversations`' pattern. */
+  shell: z$1.object({
+    commandPalette: z$1.literal(true).optional(),
+    userMenu: z$1.object({
+      name: z$1.string().min(1),
+      plan: z$1.string().min(1).optional()
+    }).strict().optional()
+  }).strict().optional(),
+  /** Composer chrome — NOT a capability: chrome on the medium, like
+   *  `header` (B-5). `triggers` maps onto ChatThread's real, shipped
+   *  `triggers` prop: `slash` → `{ char: '/', kind: 'command', items }`,
+   *  `mention` → `{ char: '@', kind: 'mention', items }` at emit. */
+  composer: z$1.object({
+    triggers: z$1.object({
+      slash: z$1.array(TriggerEntrySchema).min(1).optional(),
+      mention: z$1.array(TriggerEntrySchema).min(1).optional()
+    }).strict().optional()
   }).strict().optional()
 }).strict().superRefine((construct, ctx) => {
-  if (construct.slots) {
-    const seen = /* @__PURE__ */ new Set();
-    construct.slots.forEach((name, i) => {
-      if (seen.has(name)) {
+  for (const rule of CROSS_FIELD_RULES) rule.check(construct, ctx);
+});
+const CROSS_FIELD_RULES = [
+  {
+    id: "slots-unique",
+    paths: ["slots"],
+    check: (construct, ctx) => {
+      if (!construct.slots) return;
+      const seen = /* @__PURE__ */ new Set();
+      construct.slots.forEach((name, i) => {
+        if (seen.has(name)) {
+          ctx.addIssue({
+            code: z$1.ZodIssueCode.custom,
+            path: ["slots", i],
+            message: `duplicate slot name "${name}"`
+          });
+        }
+        seen.add(name);
+      });
+    }
+  },
+  {
+    id: "custom-layout-needs-slots",
+    paths: ["layout", "slots"],
+    check: (construct, ctx) => {
+      if (construct.layout === "custom" && (!construct.slots || construct.slots.length === 0)) {
         ctx.addIssue({
           code: z$1.ZodIssueCode.custom,
-          path: ["slots", i],
-          message: `duplicate slot name "${name}"`
+          path: ["slots"],
+          message: '"custom" layout requires at least one declared slot — custom IS the slots grain'
         });
       }
-      seen.add(name);
-    });
-  }
-  if (construct.layout === "custom" && (!construct.slots || construct.slots.length === 0)) {
-    ctx.addIssue({
-      code: z$1.ZodIssueCode.custom,
-      path: ["slots"],
-      message: '"custom" layout requires at least one declared slot — custom IS the slots grain'
-    });
-  }
-  if (construct.layout === "split" && construct.slots) {
-    const i = construct.slots.indexOf("pane");
-    if (i !== -1) {
-      ctx.addIssue({
-        code: z$1.ZodIssueCode.custom,
-        path: ["slots", i],
-        message: `"pane" collides with the "split" layout's own fixed <slot name="pane"> — choose a different slot name`
-      });
     }
-  }
-  if (construct.widget && construct.layout !== "widget") {
-    ctx.addIssue({
-      code: z$1.ZodIssueCode.custom,
-      path: ["widget"],
-      message: '"widget" is only valid on layout: "widget"'
-    });
-  }
-  if (construct.widget?.launcherIcon && !isSafeUrl(construct.widget.launcherIcon)) {
-    ctx.addIssue({
-      code: z$1.ZodIssueCode.custom,
-      path: ["widget", "launcherIcon"],
-      message: "launcherIcon must be an http(s)/mailto or relative URL — no javascript:/data: schemes"
-    });
-  }
-  if (construct.empty?.icon && !isSafeUrl(construct.empty.icon)) {
-    ctx.addIssue({
-      code: z$1.ZodIssueCode.custom,
-      path: ["empty", "icon"],
-      message: "icon must be an http(s)/mailto or relative URL — no javascript:/data: schemes"
-    });
-  }
-  const reasoning = construct.capabilities?.reasoning;
-  const reasoningOpen = construct.capabilities?.reasoningOpen;
-  if (reasoningOpen !== void 0 && (reasoning === "compact" || reasoning === "off")) {
-    ctx.addIssue({
-      code: z$1.ZodIssueCode.custom,
-      path: ["capabilities", "reasoningOpen"],
-      message: '"reasoningOpen" only applies when reasoning is "full" or omitted — "compact"/"off" have no disclosure to open'
-    });
-  }
-  const history = construct.capabilities?.history;
-  if (construct.capabilities?.conversations && (!history || history.persistence === "none")) {
-    ctx.addIssue({
-      code: z$1.ZodIssueCode.custom,
-      path: ["capabilities", "conversations"],
-      message: '"conversations" requires capabilities.history.persistence to be "local" or "endpoint" — a conversation list needs somewhere to persist conversations'
-    });
-  }
-  const URL_SHAPED = /^[a-zA-Z][a-zA-Z0-9+.-]*:|^\/\//;
-  for (const [i, link] of (construct.home?.links ?? []).entries()) {
-    if (link.href && !isSafeUrl(link.href)) {
-      ctx.addIssue({
-        code: z$1.ZodIssueCode.custom,
-        path: ["home", "links", i, "href"],
-        message: "href must be an http(s)/mailto or relative URL — no javascript:/data: schemes"
-      });
+  },
+  {
+    id: "split-pane-slot-collision",
+    paths: ["layout", "slots"],
+    check: (construct, ctx) => {
+      if (construct.layout === "split" && construct.slots) {
+        const i = construct.slots.indexOf("pane");
+        if (i !== -1) {
+          ctx.addIssue({
+            code: z$1.ZodIssueCode.custom,
+            path: ["slots", i],
+            message: `"pane" collides with the "split" layout's own fixed <slot name="pane"> — choose a different slot name`
+          });
+        }
+      }
     }
-    if (link.icon && URL_SHAPED.test(link.icon) && !isSafeUrl(link.icon)) {
-      ctx.addIssue({
-        code: z$1.ZodIssueCode.custom,
-        path: ["home", "links", i, "icon"],
-        message: "icon must be a kit icon name or an http(s)/relative URL — no javascript:/data: schemes"
-      });
+  },
+  {
+    id: "widget-layout-scope",
+    paths: ["layout", "widget"],
+    check: (construct, ctx) => {
+      if (construct.widget && construct.layout !== "widget") {
+        ctx.addIssue({
+          code: z$1.ZodIssueCode.custom,
+          path: ["widget"],
+          message: '"widget" is only valid on layout: "widget"'
+        });
+      }
+    }
+  },
+  {
+    id: "aside-layout-scope",
+    paths: ["layout", "aside"],
+    check: (construct, ctx) => {
+      if (construct.aside && construct.layout !== "aside") {
+        ctx.addIssue({
+          code: z$1.ZodIssueCode.custom,
+          path: ["aside"],
+          message: '"aside" is only valid on layout: "aside"'
+        });
+      }
+    }
+  },
+  {
+    id: "message-actions-unique",
+    paths: ["capabilities.messageActions.user", "capabilities.messageActions.assistant"],
+    check: (construct, ctx) => {
+      const messageActions = construct.capabilities?.messageActions;
+      if (!messageActions) return;
+      for (const role of ["user", "assistant"]) {
+        const list = messageActions[role];
+        if (!list) continue;
+        const seen = /* @__PURE__ */ new Set();
+        list.forEach((id, i) => {
+          if (seen.has(id)) {
+            ctx.addIssue({
+              code: z$1.ZodIssueCode.custom,
+              path: ["capabilities", "messageActions", role, i],
+              message: `duplicate action id "${id}"`
+            });
+          }
+          seen.add(id);
+        });
+      }
+    }
+  },
+  {
+    id: "launcher-icon-url",
+    paths: ["widget.launcherIcon"],
+    check: (construct, ctx) => {
+      if (construct.widget?.launcherIcon && !isSafeUrl(construct.widget.launcherIcon)) {
+        ctx.addIssue({
+          code: z$1.ZodIssueCode.custom,
+          path: ["widget", "launcherIcon"],
+          message: "launcherIcon must be an http(s)/mailto or relative URL — no javascript:/data: schemes"
+        });
+      }
+    }
+  },
+  {
+    id: "empty-icon-url",
+    paths: ["empty.icon"],
+    check: (construct, ctx) => {
+      if (construct.empty?.icon && !isSafeUrl(construct.empty.icon)) {
+        ctx.addIssue({
+          code: z$1.ZodIssueCode.custom,
+          path: ["empty", "icon"],
+          message: "icon must be an http(s)/mailto or relative URL — no javascript:/data: schemes"
+        });
+      }
+    }
+  },
+  {
+    id: "reasoning-open-scope",
+    paths: ["capabilities.reasoning", "capabilities.reasoningOpen"],
+    check: (construct, ctx) => {
+      const reasoning = construct.capabilities?.reasoning;
+      const reasoningOpen = construct.capabilities?.reasoningOpen;
+      if (reasoningOpen !== void 0 && (reasoning === "compact" || reasoning === "off")) {
+        ctx.addIssue({
+          code: z$1.ZodIssueCode.custom,
+          path: ["capabilities", "reasoningOpen"],
+          message: '"reasoningOpen" only applies when reasoning is "full" or omitted — "compact"/"off" have no disclosure to open'
+        });
+      }
+    }
+  },
+  {
+    id: "conversations-need-history",
+    paths: ["capabilities.conversations", "capabilities.history"],
+    check: (construct, ctx) => {
+      const history = construct.capabilities?.history;
+      if (construct.capabilities?.conversations && (!history || history.persistence === "none")) {
+        ctx.addIssue({
+          code: z$1.ZodIssueCode.custom,
+          path: ["capabilities", "conversations"],
+          message: '"conversations" requires capabilities.history.persistence to be "local" or "endpoint" — a conversation list needs somewhere to persist conversations'
+        });
+      }
+    }
+  },
+  {
+    id: "home-link-urls",
+    paths: ["home.links"],
+    check: (construct, ctx) => {
+      const URL_SHAPED = /^[a-zA-Z][a-zA-Z0-9+.-]*:|^\/\//;
+      for (const [i, link] of (construct.home?.links ?? []).entries()) {
+        if (link.href && !isSafeUrl(link.href)) {
+          ctx.addIssue({
+            code: z$1.ZodIssueCode.custom,
+            path: ["home", "links", i, "href"],
+            message: "href must be an http(s)/mailto or relative URL — no javascript:/data: schemes"
+          });
+        }
+        if (link.icon && URL_SHAPED.test(link.icon) && !isSafeUrl(link.icon)) {
+          ctx.addIssue({
+            code: z$1.ZodIssueCode.custom,
+            path: ["home", "links", i, "icon"],
+            message: "icon must be a kit icon name or an http(s)/relative URL — no javascript:/data: schemes"
+          });
+        }
+      }
+    }
+  },
+  {
+    id: "history-endpoint-url",
+    paths: ["capabilities.history.persistence", "capabilities.history.url"],
+    check: (construct, ctx) => {
+      const history = construct.capabilities?.history;
+      if (!history) return;
+      if (history.persistence === "endpoint" && !history.url) {
+        ctx.addIssue({
+          code: z$1.ZodIssueCode.custom,
+          path: ["capabilities", "history", "url"],
+          message: '"endpoint" persistence requires a url'
+        });
+      }
+      if (history.persistence !== "endpoint" && history.url !== void 0) {
+        ctx.addIssue({
+          code: z$1.ZodIssueCode.custom,
+          path: ["capabilities", "history", "url"],
+          message: 'url is only valid with "endpoint" persistence'
+        });
+      }
     }
   }
-  if (!history) return;
-  if (history.persistence === "endpoint" && !history.url) {
-    ctx.addIssue({
-      code: z$1.ZodIssueCode.custom,
-      path: ["capabilities", "history", "url"],
-      message: '"endpoint" persistence requires a url'
-    });
-  }
-  if (history.persistence !== "endpoint" && history.url !== void 0) {
-    ctx.addIssue({
-      code: z$1.ZodIssueCode.custom,
-      path: ["capabilities", "history", "url"],
-      message: 'url is only valid with "endpoint" persistence'
-    });
-  }
-});
+];
 function validateConstruct(input) {
   const parsed = ConstructSchema.safeParse(input);
   if (parsed.success) return { ok: true, construct: parsed.data };
@@ -9855,25 +10038,314 @@ function validateConstruct(input) {
     })
   };
 }
+const IDENTITY = { id: "identity", paths: ["name"] };
+const THEME = { id: "theme", paths: ["theme.accent", "theme.mode", "theme.unreadColor"] };
+const HEADER = { id: "header", paths: ["header.title"] };
+const HEADER_CHROME = {
+  id: "header",
+  paths: ["header.title", "header.themeToggle", "header.actions"]
+};
+const EMPTY = { id: "empty", paths: ["empty.title", "empty.description", "empty.icon"] };
+const HOME = { id: "home", paths: ["home"] };
+const CAPABILITIES = {
+  id: "capabilities",
+  paths: [
+    "capabilities.starters",
+    "capabilities.attachments",
+    "capabilities.history",
+    "capabilities.conversations",
+    "capabilities.reasoning",
+    "capabilities.reasoningOpen"
+  ]
+};
+const MESSAGE_ACTIONS = {
+  id: "messageActions",
+  paths: ["capabilities.messageActions.user", "capabilities.messageActions.assistant"]
+};
+const SOURCES = { id: "sources", paths: ["capabilities.sources.strip"] };
+const WIDGET_CHROME = {
+  id: "widget",
+  paths: ["widget.position", "widget.launcherIcon", "widget.defaultOpen"]
+};
+const ASIDE = { id: "aside", paths: ["aside.position", "aside.width"] };
+const COMPOSER_TRIGGERS = {
+  id: "composerTriggers",
+  paths: ["composer.triggers.slash", "composer.triggers.mention"]
+};
+const SHELL = { id: "shell", paths: ["shell.commandPalette", "shell.userMenu"] };
+const CARDS = { id: "cards", paths: ["cards"] };
+const PROVIDER = { id: "provider", paths: ["provider"] };
+const widgetStarter = {
+  $schema: CONSTRUCT_SCHEMA_URL,
+  name: "support-widget",
+  layout: "widget",
+  provider: { mode: "mock" },
+  header: { title: "Support" },
+  theme: { unreadColor: "#38BDF8", mode: "system" },
+  empty: {
+    title: "Hi, we're here to help",
+    description: "Ask us about orders, refunds, and more."
+  },
+  home: {
+    greeting: { title: "How can we help? 👋", subtitle: "Orders, refunds, anything." },
+    recentConversation: true,
+    links: [
+      { label: "Help center", href: "https://ui.kitn.ai", description: "Guides and FAQs", icon: "book-open" }
+    ]
+  },
+  // States the kit default loudly (the anchored-on-the-default convention,
+  // same as research's sources.strip) so the template's chrome fact is
+  // visible/editable in its own JSON.
+  widget: { position: "bottom-end" },
+  capabilities: {
+    starters: ["Where's my order?", "Request a refund"],
+    attachments: { accept: ["image/*", "application/pdf"] },
+    history: { persistence: "local" },
+    conversations: true
+  }
+};
+const inAppAssistantStarter = {
+  $schema: CONSTRUCT_SCHEMA_URL,
+  name: "in-app-assistant",
+  layout: "aside",
+  provider: { mode: "mock" },
+  header: { title: "Assistant" },
+  // Dark-by-default (owner ruling, dark round): every buildable starter
+  // EXCEPT widget ships mode: 'dark' — widget is embedded in a host site and
+  // follows IT, not its own preference (T-3: this is registry data, not a
+  // schema default; 'system' stays the schema's own default for anyone
+  // hand-authoring a construct).
+  theme: { accent: "#0ea5e9", mode: "dark" },
+  // codegen's own defaults, stated so the geometry is visible/editable.
+  aside: { position: "end", width: "380px" },
+  capabilities: {
+    starters: ["Deploy payments to production", "Check the canary status"],
+    attachments: { accept: ["image/*", "application/pdf"] },
+    history: { persistence: "local" }
+  }
+};
+const assistantStarter = {
+  $schema: CONSTRUCT_SCHEMA_URL,
+  name: "daily-assistant",
+  layout: "fullscreen",
+  provider: { mode: "mock" },
+  header: { title: "Assistant" },
+  // Dark-by-default (owner ruling, dark round) — see inAppAssistantStarter's
+  // note above.
+  theme: { accent: "#7c3aed", mode: "dark" },
+  empty: {
+    title: "What can I help with?",
+    description: "Ask anything, or start from a suggestion below."
+  },
+  capabilities: {
+    starters: ["Draft the Q3 board update", "Summarize a document", "Compare two options"],
+    attachments: { accept: ["image/*", "application/pdf"] },
+    history: { persistence: "local" },
+    conversations: true
+  }
+};
+const researchStarter = {
+  $schema: CONSTRUCT_SCHEMA_URL,
+  name: "research-assistant",
+  layout: "fullscreen",
+  provider: { mode: "mock" },
+  header: { title: "Research" },
+  // Dark-by-default (owner ruling, dark round) — see inAppAssistantStarter's
+  // note above.
+  theme: { accent: "#0f766e", mode: "dark" },
+  capabilities: {
+    starters: ["How does the wire adapter work?", "What are message parts?"],
+    attachments: { accept: ["application/pdf"] },
+    history: { persistence: "local" },
+    // The template's defining fact, stated even though it matches the emit
+    // default (B-4): the row already renders; strip: true is the visible
+    // switch this template exists around.
+    sources: { strip: true },
+    // "assistant-style actions" (B-13) — the owner's A3 default matrix
+    // (builder-message-actions.tsx: user Edit on; assistant
+    // Copy/Like/Dislike on).
+    messageActions: { user: ["edit"], assistant: ["copy", "like", "dislike"] }
+  }
+};
+const workspaceTriggers = {
+  triggers: {
+    slash: [
+      { id: "summarize", label: "summarize", description: "Summarize the thread so far" },
+      { id: "translate", label: "translate", description: "Translate the last message" }
+    ],
+    mention: [
+      { id: "researcher", label: "researcher", description: "Hands off to the research agent" },
+      { id: "coder", label: "coder", description: "Hands off to the coding agent" }
+    ]
+  }
+};
+const workspaceBase = {
+  $schema: CONSTRUCT_SCHEMA_URL,
+  name: "build-workspace",
+  layout: "split",
+  provider: { mode: "mock" },
+  header: {
+    title: "Workspace",
+    themeToggle: true,
+    // The story's Share/Deploy rows, mapped onto the kit Button's real
+    // variant names (B-6a's enum): 'secondary' → outline, 'primary' → default.
+    actions: [
+      { label: "Share", variant: "outline" },
+      { label: "Deploy", variant: "default" }
+    ]
+  },
+  // Dark-by-default (owner ruling, dark round) — see inAppAssistantStarter's
+  // note above. Both variants below spread ...workspaceBase without
+  // overriding theme, so this covers artifactPreview and appPreview too.
+  theme: { accent: "#ea580c", mode: "dark" },
+  shell: { commandPalette: true, userMenu: { name: "Ada", plan: "Pro" } },
+  composer: workspaceTriggers,
+  capabilities: {
+    starters: ["Build a pricing table", "Add a dark mode toggle"],
+    attachments: { accept: ["image/*"] },
+    history: { persistence: "local" }
+  }
+};
+const workspaceArtifactPreview = {
+  ...workspaceBase,
+  name: "artifact-workspace"
+};
+const workspaceAppPreview = {
+  ...workspaceBase,
+  name: "app-workspace",
+  capabilities: {
+    ...workspaceBase.capabilities,
+    starters: ["Build a landing page for a coffee shop", "Make the hero work on mobile"]
+  }
+};
+const TEMPLATES = [
+  {
+    id: "widget",
+    name: "Support widget",
+    description: "A floating chat that lives in the corner of your site.",
+    availability: "buildable",
+    starter: widgetStarter,
+    controls: [IDENTITY, THEME, HEADER, HOME, CAPABILITIES, WIDGET_CHROME, PROVIDER]
+  },
+  {
+    id: "inAppAssistant",
+    name: "In-app assistant",
+    description: "An assistant docked inside your existing app.",
+    availability: "buildable",
+    starter: inAppAssistantStarter,
+    // Design-parity fix wave (2026-08-29 audit): the story's In-app
+    // assistant panel shows Composer triggers, Message actions and a
+    // read-only Cards list, none of which were wired here even though the
+    // vocabulary and the panel machinery both already exist (proven working
+    // on Workspace/Assistant/Research). Voice/Reveal-mode/Rail-placement
+    // stay absent — those are the story's own labeled preview-only,
+    // T-5-deferred fields with no construct vocabulary at all.
+    controls: [IDENTITY, THEME, HEADER, ASIDE, COMPOSER_TRIGGERS, CAPABILITIES, MESSAGE_ACTIONS, CARDS, PROVIDER]
+  },
+  {
+    id: "assistant",
+    name: "Assistant",
+    description: "A full-page assistant with a history of past conversations.",
+    availability: "buildable",
+    starter: assistantStarter,
+    // Design-parity fix wave: the story's Assistant panel shows an App
+    // chrome / Shell section (Command palette toggle, User menu) that
+    // wasn't wired here — same already-working vocabulary as Workspace's
+    // SHELL section.
+    controls: [IDENTITY, THEME, HEADER, SHELL, EMPTY, CAPABILITIES, MESSAGE_ACTIONS, PROVIDER]
+  },
+  {
+    id: "research",
+    name: "Research",
+    description: "Search-first answers with cited sources.",
+    availability: "buildable",
+    starter: researchStarter,
+    controls: [IDENTITY, THEME, HEADER, CAPABILITIES, SOURCES, MESSAGE_ACTIONS, PROVIDER]
+  },
+  {
+    id: "workspace",
+    name: "Workspace",
+    description: "Chat drives a live work surface: previews, code, and artifacts build beside the conversation.",
+    availability: "buildable",
+    starter: workspaceBase,
+    variants: [
+      {
+        id: "artifactPreview",
+        name: "Artifact preview beside chat",
+        description: "A code or rendered-output pane grows beside the conversation as you build.",
+        starter: workspaceArtifactPreview
+      },
+      {
+        id: "appPreview",
+        name: "App preview with device toggles",
+        description: "A full browser-chrome preview of the running app, with desktop, tablet, and mobile views.",
+        starter: workspaceAppPreview
+      }
+    ],
+    controls: [
+      IDENTITY,
+      THEME,
+      HEADER_CHROME,
+      SHELL,
+      COMPOSER_TRIGGERS,
+      CAPABILITIES,
+      MESSAGE_ACTIONS,
+      PROVIDER
+    ]
+  },
+  {
+    id: "voice",
+    name: "Voice",
+    description: "A voice-first assistant you talk to, push-to-talk and all.",
+    availability: "story-only"
+  }
+];
+function buildableTemplates() {
+  return TEMPLATES.filter((t) => t.availability === "buildable");
+}
 const inputSchema = z$1.object({
   intent: z$1.string().min(1).optional().describe("What the author wants, in their words. Alone: returns a starter construct."),
   construct: z$1.record(z$1.string(), z$1.unknown()).optional().describe("The FULL construct JSON for this turn. The harness owns the file; send all of it every turn.")
 }).strict();
+const INTENT_PATTERNS = [
+  { id: "widget", re: /\b(?:widget|embed|bubble|corner|launcher)\b/i },
+  { id: "research", re: /\b(?:research|search|cite|citation|sources?)\b/i },
+  { id: "workspace", re: /\b(?:workspace|split|pane|artifact|side.?by.?side|preview)\b/i },
+  { id: "inAppAssistant", re: /\b(?:aside|dock|in.?app|copilot|console|sidebar)\b/i },
+  { id: "assistant", re: /\b(?:assistant|chat\s*(?:app|bot)|full.?screen)\b/i }
+];
 function starterFor(intent) {
-  const impliesWidget = /widget|embed|bubble|corner|launcher/i.test(intent);
+  const templates = buildableTemplates();
   const name = "my-chat";
+  const tagQuestion = `What should the element tag be? (kebab-case, e.g. "acme-support"; using "${name}" until you say)`;
+  const match = INTENT_PATTERNS.find((p) => p.re.test(intent));
+  const template = match ? templates.find((t) => t.id === match.id) : void 0;
+  if (!template) {
+    return {
+      construct: {
+        $schema: CONSTRUCT_SCHEMA_URL,
+        name,
+        layout: "fullscreen",
+        provider: { mode: "mock" }
+      },
+      stated: [
+        "no template implied — starting from a bare fullscreen construct. Templates available:",
+        ...templates.map((t) => `  · ${t.id} — ${t.name}: ${t.description}`)
+      ],
+      questions: [
+        tagQuestion,
+        "Which template fits? (name one of the ids above, or keep the bare construct)"
+      ]
+    };
+  }
+  const construct = structuredClone(template.starter);
+  construct.name = name;
   return {
-    construct: {
-      $schema: CONSTRUCT_SCHEMA_URL,
-      name,
-      layout: "widget",
-      provider: { mode: "mock" }
-    },
-    stated: impliesWidget ? ["layout: widget (implied by your request)"] : [],
-    questions: [
-      `What should the element tag be? (kebab-case, e.g. "acme-support"; using "${name}" until you say)`,
-      ...impliesWidget ? [] : ["Layout: widget, fullscreen, aside, split, or custom?"]
-    ]
+    construct,
+    stated: [
+      `template: ${template.id} (${template.name}) — implied by your request; every field below is yours to edit`
+    ],
+    questions: [tagQuestion]
   };
 }
 const constructTool = {