@guuey/chat 0.16.8 → 0.16.10

package/src/react/guuey-chat.tsx

@@ -60,6 +60,7 @@ import {
   createUiActionRelay,
   createUiResourceReader,
   createWebAdapters,
+  deleteThread,
   type AgentInvokeAdapters,
 } from "@guuey/agent-client";
 import type { AgHitlAnswer, AgPausedAsk } from "@silverprotocol/core";
@@ -93,7 +94,10 @@ import { oauthPromptAction, useOAuthReturn } from "./oauth-return.js";
 export function viewPropsWithThemeAnnounce(
   viewProps: TranscriptItemContext["viewProps"],
   mode: ThemeMode,
-  defaults: Pick<ViewSlotProps, "onCallTool" | "onUpdateModelContext" | "onUserMessage"> = {},
+  defaults: Pick<
+    ViewSlotProps,
+    "onCallTool" | "onUpdateModelContext" | "onUserMessage" | "onOpenLink"
+  > = {},
 ): TranscriptItemContext["viewProps"] {
   const themed = (base: ViewSlotProps | undefined): ViewSlotProps => ({
     // Kit-default host wires (guuey#335): the ACTION RELAY (Confirm inside
@@ -166,6 +170,28 @@ export interface GuueyChatHandle {
    * to the transcript).
    */
   viewSlotProps(): ViewSlotProps;
+  /**
+   * Forget this conversation (guuey#526 — the public-computer story).
+   *
+   * Local half, unconditional and immediate: aborts any in-flight turn
+   * FIRST (a completing turn can re-persist its own rows), drops the
+   * durable thread pointer AND its persisted storage key, wipes the
+   * visible transcript, clears the typed draft and any pending link ask —
+   * the next send mints a fresh thread.
+   *
+   * Server half, best-effort: when the surface has a platform door
+   * (`apiBaseUrl`) and a minted thread, fires
+   * `DELETE /v1/threads/:threadId` with the SAME identity the thread was
+   * created under (captured before any rotation) — real, child-first
+   * server-side erasure. A denied or failed delete still clears the
+   * device (the contract's unlinkability fallback) and surfaces nothing
+   * louder than the `thread-delete` debug event.
+   *
+   * Afterwards `onGuestSecretRotate` fires (when wired), so the identity
+   * owner mints a fresh guest secret — even an orphaned server row is
+   * unreachable from a rotated identity.
+   */
+  clearConversation(): void;
 }
 
 export interface GuueyChatProps {
@@ -214,6 +240,19 @@ export interface GuueyChatProps {
   strings?: Partial<ChatStrings>;
   theme?: GuueyChatTheme;
   mode?: ThemeMode;
+  /**
+   * Message-surface presentation (guuey#521). `"card"` (default) keeps
+   * assistant text on its own card; `"bare"` sits the transcript directly
+   * on the host's background so the embed reads native to the page.
+   */
+  surface?: "card" | "bare";
+  /**
+   * Render the built-in composer (default `true`). `false` hides it for
+   * hosts that drive the conversation through the imperative handle
+   * (guuey#210 `ask`/`compose`) or their own input — pairs with the
+   * handle instead of forcing a CSS hide (guuey#521).
+   */
+  composer?: boolean;
   /** DOM windowing (§3.2). `false` renders everything. */
   window?: TranscriptWindowing | false;
   /**
@@ -222,6 +261,39 @@ export interface GuueyChatProps {
    * pod door) when omitted; an explicit reader always wins.
    */
   reader?: UiResourceReader;
+  /**
+   * The forget-this-device affordance (guuey#526 — the public-computer
+   * story): a quiet "Clear conversation" control with a two-tap confirm,
+   * wired to {@link GuueyChatHandle.clearConversation}. Default: ON when
+   * the surface runs GUEST identity (`getGuestSecret` present — the
+   * founder's seamless principle; a signed-in surface has account-level
+   * recourse), OFF otherwise; pass a boolean to override either way.
+   */
+  clearAffordance?: boolean;
+  /**
+   * Guest-secret rotation hook (guuey#526): called at the END of every
+   * {@link GuueyChatHandle.clearConversation} — after the server delete
+   * has been dispatched with the OLD identity — so the owner of the
+   * secret's storage (the kit never stores it; `getGuestSecret` is a
+   * getter) mints a fresh one. Rotation is what makes even an orphaned
+   * server row unreachable: the new identity is a stranger to it. Guest
+   * KV state is (user,mcp)-scoped and is orphaned by rotation, by design.
+   */
+  onGuestSecretRotate?: () => void;
+  /**
+   * Suggestion chips (guuey#533 — declared content, the one-truth design):
+   * rendered on the EMPTY transcript only (they retire the moment a
+   * message exists — live send or restored history both count), one tap
+   * SENDS the chip text verbatim through exactly the Send button's gate.
+   * Default-ON when content exists; `false` opts the surface out. The kit
+   * mirrors the card projection's caps render-side (4 shown, ≤80 chars
+   * each, blank-rejected) — a direct consumer bypassing the platform's
+   * emit gate gets the same bounds. Content is the host's (the widget
+   * passes the card's `suggestions`; a direct consumer passes its own);
+   * the kit never invents chips — an honest empty state beats invented
+   * questions in the builder's voice.
+   */
+  suggestions?: readonly string[] | false;
   /** The debug sink (spec §5) — fires only under the debug policy. */
   onDebugEvent?: (event: ChatDebugEvent) => void;
   /** R6 pass-through (relay hook, sandbox page/flags, host context…). */
@@ -323,6 +395,8 @@ export const GuueyChat = forwardRef<GuueyChatHandle, GuueyChatProps>(function Gu
     strings: stringOverrides,
     theme = DEFAULT_CHAT_THEME,
     mode = "light",
+    surface = "card",
+    composer = true,
     window: windowing,
     reader,
     onDebugEvent,
@@ -335,6 +409,9 @@ export const GuueyChat = forwardRef<GuueyChatHandle, GuueyChatProps>(function Gu
     oauthReturnTo,
     onOAuthAuthorize,
     onErrorAction,
+    clearAffordance,
+    onGuestSecretRotate,
+    suggestions,
     onActivity,
     onReady,
     onThread,
@@ -352,8 +429,14 @@ export const GuueyChat = forwardRef<GuueyChatHandle, GuueyChatProps>(function Gu
   // host back → setState → re-render → "Maximum update depth exceeded".
   const getAccessTokenRef = useRef(getAccessToken);
   getAccessTokenRef.current = getAccessToken;
+  // The handle is created once ([] deps) but must read the LIVE base —
+  // same ref discipline as every other handle-read value in this file.
+  const apiBaseUrlRef = useRef(apiBaseUrl);
+  apiBaseUrlRef.current = apiBaseUrl;
   const getGuestSecretRef = useRef(getGuestSecret);
   getGuestSecretRef.current = getGuestSecret;
+  const onGuestSecretRotateRef = useRef(onGuestSecretRotate);
+  onGuestSecretRotateRef.current = onGuestSecretRotate;
   const hasAccessToken = getAccessToken !== undefined;
   const hasGuestSecret = getGuestSecret !== undefined;
 
@@ -621,14 +704,64 @@ export const GuueyChat = forwardRef<GuueyChatHandle, GuueyChatProps>(function Gu
     void live.invoke.send(next).catch(() => {});
   }, [busy]);
 
+  // guuey#522: the kit default for `ui/open-link` NEVER navigates
+  // sight-unseen — the ask surfaces as a disclosure affordance (host +
+  // full URL + Open/Dismiss) and the OPEN is the human's own anchor
+  // click, so the browser's activation gate and the review posture agree
+  // by construction. ONE pending ask at a time, newest replaces (a
+  // card spamming asks can never grow an unbounded stack).
+  const [pendingLink, setPendingLink] = useState<string | null>(null);
+  // guuey#526: the two-tap confirm window for the clear affordance (an
+  // accidental tap must not nuke a conversation; a second tap within the
+  // window does — the state auto-expires).
+  const [clearArmed, setClearArmed] = useState(false);
+  useEffect(() => {
+    if (!clearArmed) return;
+    const timer = setTimeout(() => setClearArmed(false), 4000);
+    return () => clearTimeout(timer);
+  }, [clearArmed]);
+  const showClearAffordance = clearAffordance ?? getGuestSecret !== undefined;
+  // guuey#533: the render-side mirror of the card projection's emit caps
+  // (4 shown / <=80 chars / blank-rejected) — same defense posture as the
+  // table normalizer: the kit is public npm and cannot assume every host
+  // routed content through platform's write gate.
+  const chips = useMemo<readonly string[]>(() => {
+    if (suggestions === false || suggestions === undefined) return [];
+    return suggestions
+      .map((c) => c.trim())
+      .filter((c) => c.length > 0 && c.length <= 80)
+      .slice(0, 4);
+  }, [suggestions]);
+  const sendSuggestion = useCallback((text: string): void => {
+    const live = liveRef.current;
+    // Exactly the Send button's gate (the #210 rule): unavailable, busy,
+    // or blank -> the tap is a no-op, never a bypass. The typed draft is
+    // left untouched (a chip send must not eat a half-typed message).
+    if (!live.available || live.busy || text.trim() === "") return;
+    void live.invoke.send(text).catch(() => {
+      // Same contract as submit: the hook owns failure surfacing.
+    });
+  }, []);
+  const defaultOnOpenLink = useCallback((url: string) => {
+    setPendingLink(url);
+  }, []);
+
   const effectiveViewProps = useMemo<TranscriptItemContext["viewProps"]>(
     () =>
       viewPropsWithThemeAnnounce(viewProps, mode, {
         ...(stagedDefaultOnCallTool !== undefined ? { onCallTool: stagedDefaultOnCallTool } : {}),
         onUpdateModelContext: defaultOnUpdateModelContext,
         onUserMessage: defaultOnUserMessage,
+        onOpenLink: defaultOnOpenLink,
       }),
-    [viewProps, mode, stagedDefaultOnCallTool, defaultOnUpdateModelContext, defaultOnUserMessage],
+    [
+      viewProps,
+      mode,
+      stagedDefaultOnCallTool,
+      defaultOnUpdateModelContext,
+      defaultOnUserMessage,
+      defaultOnOpenLink,
+    ],
   );
 
   // The canvas-host door (guuey#335): a host mounting views DIRECTLY from
@@ -644,6 +777,7 @@ export const GuueyChat = forwardRef<GuueyChatHandle, GuueyChatProps>(function Gu
           ...(stagedDefaultOnCallTool !== undefined ? { onCallTool: stagedDefaultOnCallTool } : {}),
           onUpdateModelContext: defaultOnUpdateModelContext,
           onUserMessage: defaultOnUserMessage,
+          onOpenLink: defaultOnOpenLink,
           hostContext: { theme: mode },
         }
       : (effectiveViewProps ?? {});
@@ -671,6 +805,48 @@ export const GuueyChat = forwardRef<GuueyChatHandle, GuueyChatProps>(function Gu
       focusComposer: (): void => {
         inputRef.current?.focus();
       },
+      clearConversation: (): void => {
+        const live = liveRef.current;
+        // Contract ordering (guuey#526, platform's frozen comment): abort
+        // FIRST — a completing turn can re-persist its own rows after the
+        // delete. Capture the id + guest secret BEFORE anything clears or
+        // rotates them: the delete must authenticate as the identity that
+        // OWNS the thread.
+        live.invoke.abort();
+        const threadId = threadIdRef.current;
+        const getGuest = getGuestSecretRef.current;
+        const guestSecret = getGuest !== undefined ? getGuest() : null;
+        if (apiBaseUrlRef.current !== undefined && threadId !== null) {
+          // Best-effort server erasure — fire-and-forget, never blocks the
+          // local clear. 200 and 404 are both "deleted" (idempotent by
+          // contract); denied/failed still cleared locally below (the
+          // unlinkability fallback) and surface ONLY as a debug line.
+          void deleteThread({
+            apiBaseUrl: apiBaseUrlRef.current,
+            threadId,
+            ...(getAccessTokenRef.current !== undefined
+              ? { getAccessToken: getAccessTokenRef.current }
+              : {}),
+            guestSecret,
+          }).then((outcome) => {
+            onDebugEventRef.current?.({ type: "thread-delete", threadId, outcome });
+          });
+        } else {
+          onDebugEventRef.current?.({ type: "thread-delete", threadId, outcome: "skipped" });
+        }
+        // The hook's reset owns the durable local half (pointer + storage
+        // key, transcript/fold/cards); the kit clears ITS OWN residue —
+        // the typed draft, a pending link ask, queued doorbells — so the
+        // device holds nothing of the conversation.
+        live.invoke.reset();
+        setInput("");
+        setPendingLink(null);
+        pendingDoorbellsRef.current = [];
+        // Rotation LAST: the delete above already captured the old
+        // identity, so the fresh secret is a stranger to even an orphaned
+        // server row.
+        onGuestSecretRotateRef.current?.();
+      },
       // A getter, not a captured value: the handle is created once, but the
       // thread hydrates after mount and can change — reads go through the
       // same ref the default reader uses, so it is always the live id.
@@ -777,6 +953,7 @@ export const GuueyChat = forwardRef<GuueyChatHandle, GuueyChatProps>(function Gu
         strings={strings}
         theme={theme}
         mode={mode}
+        surface={surface}
         {...(windowing !== undefined ? { window: windowing } : {})}
         {...(components !== undefined ? { components } : {})}
         onToggle={toggle}
@@ -789,6 +966,62 @@ export const GuueyChat = forwardRef<GuueyChatHandle, GuueyChatProps>(function Gu
         {...(onViewRef !== undefined ? { onViewRef } : {})}
         viewProps={effectiveViewProps}
       />
+      {chips.length > 0 && inputs.messages.length === 0 && (
+        <nav className="guuey-chat-chips-row" aria-label={strings.suggestionsLabel}>
+          {chips.map((chip) => (
+            <button
+              key={chip}
+              type="button"
+              className="guuey-chat-chip"
+              onClick={() => sendSuggestion(chip)}
+            >
+              {chip}
+            </button>
+          ))}
+        </nav>
+      )}
+      {showClearAffordance && inputs.messages.length > 0 && (
+        <div className="guuey-chat-clear-row">
+          <button
+            type="button"
+            className={`guuey-chat-clear${clearArmed ? " guuey-chat-clear-armed" : ""}`}
+            onClick={() => {
+              if (clearArmed) {
+                setClearArmed(false);
+                handle.clearConversation();
+              } else {
+                setClearArmed(true);
+              }
+            }}
+          >
+            {clearArmed ? strings.clearConversationConfirm : strings.clearConversationLabel}
+          </button>
+        </div>
+      )}
+      {pendingLink !== null && (
+        <div role="status" className="guuey-chat-link-ask">
+          <span className="guuey-chat-link-ask-label">
+            {strings.linkAskLabel(new URL(pendingLink).host)}
+          </span>
+          <span className="guuey-chat-link-ask-url">{pendingLink}</span>
+          <a
+            className="guuey-chat-link-ask-open"
+            href={pendingLink}
+            target="_blank"
+            rel="noopener noreferrer"
+            onClick={() => setPendingLink(null)}
+          >
+            {strings.linkOpen}
+          </a>
+          <button
+            type="button"
+            className="guuey-chat-link-ask-dismiss"
+            onClick={() => setPendingLink(null)}
+          >
+            {strings.linkDismiss}
+          </button>
+        </div>
+      )}
       {oauthReturn.notice !== null && (
         <p
           role="status"
@@ -802,6 +1035,7 @@ export const GuueyChat = forwardRef<GuueyChatHandle, GuueyChatProps>(function Gu
           </button>
         </p>
       )}
+      {composer && (
       <form
         className="guuey-chat-composer"
         onSubmit={(e) => {
@@ -843,6 +1077,7 @@ export const GuueyChat = forwardRef<GuueyChatHandle, GuueyChatProps>(function Gu
           </button>
         )}
       </form>
+      )}
     </div>
   );
 });

package/src/react/markdown.tsx

@@ -24,6 +24,7 @@
  * Streaming-tolerant by upstream design: unclosed emphasis mid-delta
  * renders as formatted-so-far.
  */
+import { useState } from "react";
 import type { ReactNode } from "react";
 import {
   parseRichText,
@@ -32,11 +33,75 @@ import {
 } from "@silverprotocol/richtext";
 import { normalizeTableRow, type RichTextTableBlock } from "../richtext-table.js";
 
+/**
+ * Bare-URL autolink (guuey#515): richtext mints `link` nodes only from
+ * explicit `[text](url)` markdown, so a plain "https://…" in agent prose
+ * parses as a text node and rendered as untappable static text — on a
+ * phone that means retyping a URL out of a chat bubble. Linkify at the
+ * render boundary, conservatively:
+ *  - the scheme is part of the match (http/https only), so no
+ *    `javascript:`/`data:` target can ever qualify — the SAFE_HREF
+ *    property holds by construction;
+ *  - built as React elements (no HTML string exists to inject into),
+ *    same `rel`/`target` contract as explicit links;
+ *  - trailing punctuation stays prose ("see https://guuey.com." must not
+ *    link the dot), while a balanced closing paren/bracket stays in the
+ *    URL (wiki-style paths);
+ *  - schemeless "www.foo.com" is deliberately NOT linkified — guessing
+ *    schemes is how autolinkers start lying;
+ *  - code spans are untouched (they render `node.code`, not this path).
+ */
+const BARE_URL = /https?:\/\/[^\s<>]+/g;
+
+function trimTrailingPunctuation(url: string): string {
+  for (;;) {
+    const last = url[url.length - 1];
+    if (last === undefined) return url;
+    if (last === ")" || last === "]") {
+      const open = last === ")" ? "(" : "[";
+      const opens = url.split(open).length - 1;
+      const closes = url.split(last).length - 1;
+      if (closes > opens) {
+        url = url.slice(0, -1);
+        continue;
+      }
+      return url;
+    }
+    if (".,;:!?'\"»›".includes(last)) {
+      url = url.slice(0, -1);
+      continue;
+    }
+    return url;
+  }
+}
+
+function linkify(text: string): ReactNode {
+  if (!text.includes("http")) return text;
+  const out: ReactNode[] = [];
+  let consumed = 0;
+  for (const match of text.matchAll(BARE_URL)) {
+    const start = match.index;
+    if (start === undefined) continue;
+    const url = trimTrailingPunctuation(match[0]);
+    if (url.length === 0) continue;
+    if (start > consumed) out.push(text.slice(consumed, start));
+    out.push(
+      <a key={`url-${start}`} href={url} target="_blank" rel="noopener noreferrer">
+        {url}
+      </a>,
+    );
+    consumed = start + url.length;
+  }
+  if (out.length === 0) return text;
+  if (consumed < text.length) out.push(text.slice(consumed));
+  return out;
+}
+
 function Inline({ nodes }: { nodes: RichTextInline[] }): ReactNode {
   return nodes.map((node, i) => {
     switch (node.type) {
       case "text":
-        return <span key={i}>{node.text}</span>;
+        return <span key={i}>{linkify(node.text)}</span>;
       case "break":
         return <br key={i} />;
       case "strong":
@@ -124,7 +189,7 @@ function Block({ block }: { block: RichTextBlock }): ReactNode {
         </p>
       );
     case "code-fence":
-      return <pre className="guuey-chat-code-fence">{block.code}</pre>;
+      return <CodeFence code={block.code} />;
     case "list": {
       const Tag = block.ordered ? "ol" : "ul";
       return (
@@ -140,6 +205,43 @@ function Block({ block }: { block: RichTextBlock }): ReactNode {
   }
 }
 
+/**
+ * A fenced code block with its copy affordance (guuey#529 — the
+ * seamless-default family: every embedder's visitors get it with zero
+ * setup). The button lives in a wrapper DIV so the `<pre>` holds ONLY the
+ * code (select-all inside the fence never picks up UI text); the
+ * transcript's sibling-margin rules name the wrapper class alongside
+ * `pre`. Copy failure is shown truthfully: the label simply stays "Copy"
+ * (clipboard access needs a secure context + the iframe's
+ * clipboard-write grant — manual selection always still works).
+ */
+function CodeFence({ code }: { code: string }): ReactNode {
+  const [copied, setCopied] = useState(false);
+  return (
+    <div className="guuey-chat-code-wrap">
+      <pre className="guuey-chat-code-fence">{code}</pre>
+      <button
+        type="button"
+        className="guuey-chat-code-copy"
+        aria-label={copied ? "Copied" : "Copy code"}
+        onClick={() => {
+          const clipboard = navigator.clipboard;
+          if (clipboard === undefined) return;
+          clipboard.writeText(code).then(
+            () => {
+              setCopied(true);
+              setTimeout(() => setCopied(false), 1600);
+            },
+            () => setCopied(false),
+          );
+        }}
+      >
+        {copied ? "Copied" : "Copy"}
+      </button>
+    </div>
+  );
+}
+
 /** Sanitized markdown → React elements (see the module docblock). */
 export function Markdown({ text }: { text: string }): ReactNode {
   return (

package/src/react/theme-css.ts

@@ -24,27 +24,38 @@ const DENSITY_GAP: Record<GuueyChatTheme["shape"]["density"], string> = {
  * One mode's tokens as inline custom properties for the transcript root.
  * Returned as a plain record so callers can spread it into `style` or emit
  * a stylesheet from it.
+ *
+ * Stamped under INTERNAL names (`--_guuey-chat-*`), never the documented
+ * `--guuey-chat-*` channel (guuey#521): the stylesheet reads every token
+ * as `var(--guuey-chat-<t>, var(--_guuey-chat-<t>))`, so a host CSS
+ * variable — set on any ancestor — wins per-token over the resolved
+ * theme, and the two theming channels COMPOSE instead of the inline
+ * stamp silently shadowing the documented one (the trap the landing
+ * home-hero embed hit four rounds of).
  */
 export function themeCssVars(theme: GuueyChatTheme, mode: ThemeMode): Record<string, string> {
   const palette = theme.colors[mode];
   const vars: Record<string, string> = {
-    "--guuey-chat-accent": palette.accent,
-    "--guuey-chat-on-accent": palette.onAccent,
-    "--guuey-chat-ink": palette.ink,
-    "--guuey-chat-ink-muted": palette.inkMuted,
-    "--guuey-chat-surface": palette.surface,
-    "--guuey-chat-canvas": palette.canvas,
-    "--guuey-chat-canvas-muted": palette.canvasMuted,
-    "--guuey-chat-error": palette.error,
-    "--guuey-chat-radius": RADIUS_PX[theme.shape.radius],
-    "--guuey-chat-gap": DENSITY_GAP[theme.shape.density],
-    "--guuey-chat-scale": String(theme.typography.scale ?? 1),
+    "--_guuey-chat-accent": palette.accent,
+    "--_guuey-chat-on-accent": palette.onAccent,
+    "--_guuey-chat-ink": palette.ink,
+    "--_guuey-chat-ink-muted": palette.inkMuted,
+    "--_guuey-chat-surface": palette.surface,
+    "--_guuey-chat-canvas": palette.canvas,
+    "--_guuey-chat-canvas-muted": palette.canvasMuted,
+    "--_guuey-chat-error": palette.error,
+    "--_guuey-chat-radius": RADIUS_PX[theme.shape.radius],
+    "--_guuey-chat-gap": DENSITY_GAP[theme.shape.density],
+    "--_guuey-chat-scale": String(theme.typography.scale ?? 1),
   };
+  if (palette.link !== undefined) {
+    vars["--_guuey-chat-link"] = palette.link;
+  }
   if (theme.typography.fontFamily !== undefined) {
-    vars["--guuey-chat-font"] = theme.typography.fontFamily;
+    vars["--_guuey-chat-font"] = theme.typography.fontFamily;
   }
   if (theme.typography.monoFontFamily !== undefined) {
-    vars["--guuey-chat-mono-font"] = theme.typography.monoFontFamily;
+    vars["--_guuey-chat-mono-font"] = theme.typography.monoFontFamily;
   }
   return vars;
 }

package/src/react/transcript.tsx

@@ -63,6 +63,14 @@ export interface TranscriptProps
   strings?: ChatStrings;
   theme?: GuueyChatTheme;
   mode?: ThemeMode;
+  /**
+   * Message-surface presentation (guuey#521). `"card"` (default) renders
+   * assistant text on its own surface-tinted, hairline-bordered card;
+   * `"bare"` sits the transcript directly on the host's background — the
+   * embed disappears into the page it lives on. The user pill stays a
+   * bubble in both.
+   */
+  surface?: "card" | "bare";
   /** DOM windowing (§3.2). `false` renders everything. Default tail 80. */
   window?: TranscriptWindowing | false;
   className?: string;
@@ -76,6 +84,7 @@ export function Transcript(props: TranscriptProps): ReactNode {
     strings = defaultChatStrings,
     theme = DEFAULT_CHAT_THEME,
     mode = "light",
+    surface = "card",
     window: windowing = { tail: 80 },
     className,
     style,
@@ -169,7 +178,7 @@ export function Transcript(props: TranscriptProps): ReactNode {
 
   return (
     <div
-      className={`guuey-chat${className !== undefined ? ` ${className}` : ""}`}
+      className={`guuey-chat${surface === "bare" ? " guuey-chat--bare" : ""}${className !== undefined ? ` ${className}` : ""}`}
       style={rootStyle}
       data-guuey-chat-mode={mode}
     >

package/src/strings.ts

@@ -128,6 +128,28 @@ export interface ChatStrings {
   /** R16 — the notice row's label (provenance shows only under debug). */
   noticeLabel: string;
 
+  /**
+   * The `ui/open-link` disclosure affordance (guuey#522): a card asked to
+   * open a URL — the kit shows WHERE before anything navigates, and the
+   * human's own click on `linkOpen` is the only door out.
+   */
+  linkAskLabel: (host: string) => string;
+  linkOpen: string;
+  linkDismiss: string;
+
+  /**
+   * The forget-this-device affordance (guuey#526): the quiet clear
+   * control and its two-tap confirm face.
+   */
+  clearConversationLabel: string;
+  clearConversationConfirm: string;
+
+  /**
+   * The suggestion-chip row's accessible name (guuey#533) — the chips
+   * themselves are declared content (the app's own words), never kit copy.
+   */
+  suggestionsLabel: string;
+
   /** The 3c composer (`<GuueyChat>`). */
   composerPlaceholder: string;
   composerUnavailable: string;
@@ -233,6 +255,14 @@ export const defaultChatStrings: ChatStrings = {
 
   noticeLabel: "Note",
 
+  linkAskLabel: (host) => `This card wants to open ${host}`,
+  linkOpen: "Open",
+  linkDismiss: "Dismiss",
+
+  clearConversationLabel: "Clear conversation",
+  suggestionsLabel: "Suggestions",
+  clearConversationConfirm: "Tap again to clear this device",
+
   composerPlaceholder: "Message the agent…",
   composerUnavailable: "Chat is unavailable.",
   composerLabel: "Message",