@noodleseed/one 0.141.2 → 0.142.0

package/node_modules/@noodle-borg/agent-kit/dist/skill-embedded-assistant-ref.js

@@ -56,7 +56,7 @@ export function renderEmbeddedAssistantReference() {
         '  access: authenticatedWebsite({',
         '    origins: ["http://localhost:3000", "https://app.example.com"],',
         '  }),',
-        '  layout: { mode: "floating", position: "bottom-right" },',
+        '  layout: { mode: "floating", position: "bottom-center" },',
         '}),',
         '```',
         '',
@@ -145,13 +145,15 @@ export function renderEmbeddedAssistantReference() {
         '',
         '```ts',
         'assistant: embeddedAssistant({',
-        '  model, allowedOrigins,',
-        '  layout: { panelWidth: 520, panelMinHeight: 540, panelMaxHeight: 740, edgeOffset: 24 },',
-        '  behavior: { showTimestamps: true },',
-        '  labels: { composerPlaceholder: "Message Acme Support…", sessionReady: "Acme support is online" },',
+        '  model,',
+        '  access: authenticatedWebsite({ origins: ["https://app.example.com"] }),',
+        '  theme: "invert",',
+        '  layout: { position: "bottom-right", panelWidth: 520, panelMinHeight: 540, panelMaxHeight: 740, edgeOffset: 24 },',
+        '  behavior: { showTimestamps: true, showPoweredBy: false },',
+        '  labels: { launcherPlaceholder: "Ask Acme anything", composerPlaceholder: "Message Acme Support…", sessionReady: "Acme support is online" },',
         '  presentation: {',
         '    panel: { surface: "solid", elevation: "dramatic", border: "strong", radius: 20 },',
-        '    launcher: { icon: "chat", size: "lg", status: "session", effect: "pulse" },',
+        '    launcher: { style: "bubble", icon: "chat", size: "lg", status: "session", effect: "pulse" },',
         '    header: {',
         '      mark: "status",',
         '      badge: { text: "Online", tone: "success", indicator: true },',
@@ -162,9 +164,9 @@ export function renderEmbeddedAssistantReference() {
         '}),',
         '```',
         '',
-        'The Atlas-style product treatment above is the maximum deployment-configurable presentation. The bounded surface covers panel treatment, launcher icon/size/session pulse, header mark/status badge, composer controls, and message treatment; it does not accept custom header actions, structured empty-state layouts, footers, spectacle variants/effects, or tenant code.',
+        'The Atlas-style product treatment above is the maximum deployment-configurable presentation. The bounded surface covers panel treatment, pill/bubble launcher style plus icon/size/session pulse, header mark/status badge, composer controls, and message treatment; it does not accept custom header actions, structured empty-state layouts, footers, tenant-defined launcher variants/effects, or tenant code.',
         '',
-        'Omitted fields retain the quiet premium baseline. For exact application-owned color roles, pass the typed React `appearance={{ light: { panel: { surface, text, border }, composer: {...}, confirmation: {...}, primaryButton: {...} }, dark: {...} }}` prop or assign the same object to `element.appearance`. CSS custom properties inherit through the assistant host, so those values may reuse existing application tokens such as `surface: "var(--app-surface)"` without copying literals. The appearance surface covers canvas, panel, header, messages, composer, suggestions, confirmation, buttons, launcher, code, and the MCP App frame; the package README publishes the complete role-to-`--ns-assistant-*` map. Exact parseable literal colors are preserved and low contrast emits `assistant-appearance-warning`; contrast for unresolved CSS references remains host-owned. Precedence is host appearance object, host slots/public variables, deployed semantic presentation, then defaults. Prefer `server.ts` configuration first so every embedding app receives the same assistant after redeploy.',
+        'Omitted UI fields retain the complete managed baseline: a bottom-center frosted prompt pill, 970px outer desktop shell with 20px side padding, 85vh/1025px height bounds, 24px panel with built-in `#F8F8F8` light and `#0C0A09` dark surfaces, bottom prompt chips and pill composer, plain assistant messages, 85%-wide user bubbles, Noodle Seed attribution, and mobile fullscreen. The pill morphs into an input before opening; `launcher.style: "bubble"` opens directly, while `panel.surface: "glass"` remains an explicit translucent alternative. `theme: "auto"` follows the host page and `"invert"` selects its opposite. The generic suggestions are defaults; an authored list, including `[]`, replaces them. The ChatGPT promotion is intentionally absent. For exact application-owned color roles, pass the typed React `appearance={{ light: { panel: { surface, text, border }, composer: {...}, confirmation: {...}, primaryButton: {...} }, dark: {...} }}` prop or assign the same object to `element.appearance`. CSS custom properties inherit through the assistant host, so those values may reuse existing application tokens such as `surface: "var(--app-surface)"` without copying literals. The appearance surface covers canvas, panel, header, messages, composer, suggestions, confirmation, buttons, launcher, code, and the MCP App frame; the package README publishes the complete role-to-`--ns-assistant-*` map. Exact parseable literal colors are preserved and low contrast emits `assistant-appearance-warning`; contrast for unresolved CSS references remains host-owned. Precedence is host appearance object, host slots/public variables, saved environment operator override, deployed semantic presentation, then defaults. Prefer reusable `server.ts` defaults; use the Console Assistant tab or `noodle assistant appearance show|apply|reset` for environment-owned changes that should reach existing embeds without a redeploy.',
         '',
         'Give every business action a portable `tool(..., { title: "Complete task", description: "This will mark the task complete for everyone.", input: z.object({ task: z.string().meta({ title: "Task" }) }) })` title. The standard confirmation uses the tool title/description plus schema field `title`, `description`, and `format`; it shows Confirm and Don\'t proceed and keeps technical action details secondary. Do not put JSON or implementation names in business-facing copy.',
         '',
@@ -322,12 +324,15 @@ export function renderEmbeddedAssistantReference() {
         '',
         '```ts',
         'assistant: embeddedAssistant({',
-        '  model, allowedOrigins,',
-        '  sessionClaims: {',
-        '    displayName: { exposeToModel: true },',
-        '    accountTier: { exposeToModel: true },',
-        '    region: {}, // tools only, never in the prompt',
-        '  },',
+        '  model,',
+        '  access: authenticatedWebsite({',
+        '    origins: ["https://app.example.com"],',
+        '    sessionClaims: {',
+        '      displayName: { exposeToModel: true },',
+        '      accountTier: { exposeToModel: true },',
+        '      region: {}, // tools only, never in the prompt',
+        '    },',
+        '  }),',
         '}),',
         '```',
         '',
@@ -383,7 +388,9 @@ export function renderEmbeddedAssistantReference() {
         '',
         'Or import the package root once and mount `<noodle-assistant session-endpoint="/api/assistant/session" theme="auto"></noodle-assistant>`. Mount only inside the authenticated application surface.',
         '',
-        '`theme="auto"` follows the browser operating-system preference. If the SaaS application owns a theme toggle, obtain its resolved application theme (`"light"` or `"dark"`), pass `theme={resolvedTheme}` to `NoodleAssistant`, and update the custom element\'s `theme` attribute when that value changes.',
+        'That custom element is the complete managed assistant in Vue, Angular, or plain DOM; it has no React runtime requirement. Configure the framework to accept `noodle-assistant` as a custom element. If the session exchange needs an authenticated fetch wrapper, create the element imperatively, assign `element.fetch` and then `element.sessionEndpoint`, and append it only after both properties are set.',
+        '',
+        '`theme="auto"` follows an explicit host-page light/dark class or data attribute, then the browser operating-system preference; `theme="invert"` selects the opposite. If the SaaS application owns a theme toggle, obtain its resolved application theme (`"light"` or `"dark"`), pass `theme={resolvedTheme}` to `NoodleAssistant`, and update the custom element\'s `theme` attribute when that value changes.',
         '',
         'The component renders a custom element and must mount client-side. In a Next.js App Router tree, put the mount in a `"use client"` component; from a server component or the Pages Router, load it with `next/dynamic` and `ssr: false`.',
         '',
@@ -638,7 +645,7 @@ export function renderEmbeddedAssistantReference() {
         '',
         '- Signed-out session exchange returns `401`.',
         '- The browser network/DOM/storage contains no client secret or model key.',
-        '- The local and production origins match `allowedOrigins` character-for-character.',
+        '- The local and production origins match the authored `access.origins` character-for-character.',
         '- At the manifest/runtime boundary and in TypeScript action helpers, only `confirm: true` enables confirmation; omitted or `false` preserves direct execution. Action hints alone never enforce approval; `annotations.action({ confirm: false })` is equivalent to omission.',
         '- An expired turn re-exchanges once; interaction decisions never auto-retry. An explicit same-decision repeat returns the stored outcome without executing again.',
         '- Accept, decline, and cancel are single-use. Only accept executes; the server ignores replacement tool arguments.',
@@ -656,9 +663,9 @@ export function renderEmbeddedAssistantReference() {
         '| `assistant-error` with code `invalid_response` | The turn endpoint returned HTML or non-SSE content (auth redirect, proxy page) | Check the backend session route path and any middleware/rewrites on the embedding app |',
         '| Build error `Package path ./react is not exported` | Outdated package version with import-only export conditions | Update `@noodleseed/assistant`; do not add webpack aliases or type shims |',
         '| Deploy fails with `server_auth_required` | `--access customers` without `server.auth` | Add direct/federated OIDC or a built-in Firebase/Microsoft adapter |',
-        '| Validate rejects an origin | Non-loopback HTTP origin in `allowedOrigins` | Use the exact HTTPS production origin; HTTP is only for `localhost`/`127.0.0.1` |',
+        '| Validate rejects an origin | Non-loopback HTTP origin in `access.origins` | Use the exact HTTPS production origin; HTTP is only for `localhost`/`127.0.0.1` |',
         '| Session exchange returns 404 | `serviceUrl` points at the deployment MCP endpoint | Use the control-plane service URL printed by `noodle assistant clients create` |',
-        '| Session exchange returns 403 `origin is not allowed` | Request origin differs from `allowedOrigins` character-for-character | Align the exact scheme/host/port on both sides and redeploy |',
+        '| Session exchange returns 403 `origin is not allowed` | Request origin differs from the authored `access.origins` character-for-character | Align the exact scheme/host/port on both sides and redeploy |',
         '| Session exchange returns `400` with `invalid assistant routing` | The authenticated backend supplied an unknown endpoint name or a malformed/policy-disallowed URL | Resolve the route from server-owned membership, use the exact authored endpoint name, and ensure the canonical HTTPS URL satisfies its active `customerEndpoint` policy; the error never reflects the URL |',
         '| A routed assistant tool returns `connector_route_unavailable` | The authenticated backend omitted that endpoint during session exchange | Pass the server-verified route as `routing.endpoints.<name>` when minting a new session; keep it out of browser input |',
         '| Host session 503 | A required backend environment name is absent or mapped into the wrong deployment environment | Run `noodle assistant embed --check --json`, repair the host CI mapping, then probe the session route again |',

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-appearance-store.d.ts

@@ -0,0 +1,34 @@
+import type { AssistantAppearanceOverride } from './assistant-appearance.js';
+import type { TenantRef } from './tenant-ref.js';
+export interface AssistantAppearanceSettingsRecord {
+    readonly tenant: TenantRef;
+    /** Undefined is a durable reset tombstone, not a missing row. */
+    readonly override?: AssistantAppearanceOverride;
+    readonly revision: number;
+    readonly updatedAt: Date;
+    readonly updatedBy: string;
+}
+export type AssistantAppearanceReplaceResult = {
+    readonly ok: true;
+    readonly record: AssistantAppearanceSettingsRecord;
+} | {
+    readonly ok: false;
+    readonly currentRevision: number;
+};
+export interface AssistantAppearanceSettingsStore {
+    get(tenant: TenantRef): Promise<AssistantAppearanceSettingsRecord | undefined>;
+    /**
+     * Full replacement with compare-and-swap. Revision zero means no row has ever been written;
+     * `override: undefined` records a reset without reopening stale-write races.
+     */
+    replace(input: {
+        readonly tenant: TenantRef;
+        readonly expectedRevision: number;
+        readonly override: AssistantAppearanceOverride | undefined;
+        readonly updatedAt: Date;
+        readonly updatedBy: string;
+    }): Promise<AssistantAppearanceReplaceResult>;
+}
+export declare function appearanceTenantKey(tenant: TenantRef): string;
+export declare function cloneAssistantAppearanceSettingsRecord(record: AssistantAppearanceSettingsRecord): AssistantAppearanceSettingsRecord;
+//# sourceMappingURL=assistant-appearance-store.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-appearance-store.js

@@ -0,0 +1,12 @@
+export function appearanceTenantKey(tenant) {
+    return `${tenant.org}/${tenant.app}/${tenant.env}`;
+}
+export function cloneAssistantAppearanceSettingsRecord(record) {
+    return {
+        ...record,
+        tenant: { ...record.tenant },
+        ...(record.override === undefined ? {} : { override: structuredClone(record.override) }),
+        updatedAt: new Date(record.updatedAt),
+    };
+}
+//# sourceMappingURL=assistant-appearance-store.js.map

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-appearance.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { AssistantSessionRecord } from './assistant-store.js';
+/**
+ * Browser-safe environment override. It deliberately has no model, origin, capability, claim, HTML,
+ * CSS, callback, or arbitrary-token field: appearance cannot grow assistant authority.
+ */
+export type AssistantAppearanceOverride = NonNullable<AssistantSessionRecord['configuration']>;
+export declare const assistantAppearanceOverrideSchema: z.ZodType<AssistantAppearanceOverride>;
+export type AssistantAppearanceProvenance = Readonly<Record<string, 'developer' | 'operator'>>;
+export interface ResolvedAssistantAppearanceConfiguration {
+    readonly effective: AssistantAppearanceOverride | undefined;
+    readonly fallback: 'halo';
+    /** Dot paths not present here inherit the renderer-owned built-in baseline. */
+    readonly provenance: AssistantAppearanceProvenance;
+}
+/** Operator values win leaf-by-leaf; arrays replace and omitted fields retain developer intent. */
+export declare function resolveAssistantAppearanceConfiguration(developer: AssistantAppearanceOverride | undefined, operator: AssistantAppearanceOverride | undefined): ResolvedAssistantAppearanceConfiguration;
+//# sourceMappingURL=assistant-appearance.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-appearance.js

@@ -0,0 +1,228 @@
+import { z } from 'zod';
+const hexColorSchema = z.string().regex(/^#[0-9A-Fa-f]{6}$/, 'must be a 6-digit hex color');
+const browserAssetUrlSchema = z
+    .string()
+    .trim()
+    .url()
+    .refine(isSecureBrowserAssetUrl, 'must use https (http is allowed only for loopback testing)');
+const brandAssetSchema = z
+    .object({
+    uri: browserAssetUrlSchema,
+    darkUri: browserAssetUrlSchema.optional(),
+    alt: z.string().trim().min(1).max(240),
+})
+    .strict();
+const brandThemeSchema = z
+    .object({
+    surface: hexColorSchema.optional(),
+    surfaceRaised: hexColorSchema.optional(),
+    surfaceMuted: hexColorSchema.optional(),
+    text: hexColorSchema.optional(),
+    textMuted: hexColorSchema.optional(),
+    accent: hexColorSchema.optional(),
+    accentText: hexColorSchema.optional(),
+    link: hexColorSchema.optional(),
+    border: hexColorSchema.optional(),
+    borderStrong: hexColorSchema.optional(),
+    focus: hexColorSchema.optional(),
+    success: hexColorSchema.optional(),
+    warning: hexColorSchema.optional(),
+    danger: hexColorSchema.optional(),
+    code: hexColorSchema.optional(),
+})
+    .strict();
+const brandingSchema = z
+    .object({
+    name: z.string().trim().min(1).max(160).optional(),
+    accent: hexColorSchema.optional(),
+    surface: hexColorSchema.optional(),
+    surfaceDark: hexColorSchema.optional(),
+    logo: brandAssetSchema.optional(),
+    mark: brandAssetSchema.optional(),
+    avatar: brandAssetSchema.optional(),
+    theme: z
+        .object({ light: brandThemeSchema.optional(), dark: brandThemeSchema.optional() })
+        .strict()
+        .optional(),
+    radius: z.enum(['none', 'sm', 'md', 'lg']).optional(),
+    density: z.enum(['compact', 'comfortable']).optional(),
+    typography: z.enum(['system', 'serif', 'mono']).optional(),
+    colorScheme: z.enum(['auto', 'light', 'dark']).optional(),
+})
+    .strict();
+const labelsSchema = z
+    .object({
+    welcomeHeading: z.string().trim().min(1).max(160).optional(),
+    welcomeMessage: z.string().max(1000).optional(),
+    launcherPlaceholder: z.string().trim().min(1).max(160).optional(),
+    composerPlaceholder: z.string().trim().min(1).max(160).optional(),
+    thinking: z.string().trim().min(1).max(80).optional(),
+    send: z.string().trim().min(1).max(80).optional(),
+    stop: z.string().trim().min(1).max(80).optional(),
+    close: z.string().trim().min(1).max(80).optional(),
+    open: z.string().trim().min(1).max(80).optional(),
+    confirm: z.string().trim().min(1).max(80).optional(),
+    decline: z.string().trim().min(1).max(80).optional(),
+    cancel: z.string().trim().min(1).max(80).optional(),
+    confirmationHeading: z.string().trim().min(1).max(120).optional(),
+    additionalDetails: z.string().trim().min(1).max(120).optional(),
+    redacted: z.string().trim().min(1).max(120).optional(),
+    completed: z.string().trim().min(1).max(80).optional(),
+    stopped: z.string().trim().min(1).max(80).optional(),
+    copy: z.string().trim().min(1).max(80).optional(),
+    newMessages: z.string().trim().min(1).max(80).optional(),
+    reconnect: z.string().trim().min(1).max(80).optional(),
+    retry: z.string().trim().min(1).max(80).optional(),
+    unavailable: z.string().trim().min(1).max(240).optional(),
+    sessionExpired: z.string().trim().min(1).max(240).optional(),
+    sessionIdle: z.string().trim().min(1).max(120).optional(),
+    sessionLoading: z.string().trim().min(1).max(120).optional(),
+    sessionReady: z.string().trim().min(1).max(120).optional(),
+    sessionError: z.string().trim().min(1).max(120).optional(),
+})
+    .strict();
+const presentationSchema = z
+    .object({
+    panel: z
+        .object({
+        surface: z.enum(['solid', 'glass']).optional(),
+        elevation: z.enum(['soft', 'dramatic']).optional(),
+        border: z.enum(['subtle', 'strong']).optional(),
+        radius: z.number().int().min(0).max(64).optional(),
+    })
+        .strict()
+        .optional(),
+    launcher: z
+        .object({
+        style: z.enum(['pill', 'bubble']).optional(),
+        icon: z.enum(['brand-mark', 'chat', 'none']).optional(),
+        size: z.enum(['md', 'lg']).optional(),
+        status: z.enum(['none', 'session']).optional(),
+        effect: z.enum(['none', 'pulse']).optional(),
+    })
+        .strict()
+        .optional(),
+    header: z
+        .object({
+        mark: z.enum(['none', 'brand-mark', 'status']).optional(),
+        badge: z
+            .object({
+            text: z.string().trim().min(1).max(80),
+            tone: z.enum(['neutral', 'success', 'warning', 'danger']).optional(),
+            indicator: z.boolean().optional(),
+        })
+            .strict()
+            .optional(),
+    })
+        .strict()
+        .optional(),
+    composer: z
+        .object({
+        leadingIcon: z.enum(['none', 'brand-mark']).optional(),
+        sendIcon: z.enum(['arrow-up', 'paper-plane']).optional(),
+        shape: z.enum(['rounded', 'pill']).optional(),
+    })
+        .strict()
+        .optional(),
+    messages: z
+        .object({
+        userStyle: z.enum(['bubble', 'accent']).optional(),
+        assistantStyle: z.enum(['plain', 'bubble']).optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+const assistantUiSchema = z
+    .object({
+    theme: z.enum(['auto', 'light', 'dark', 'invert']).optional(),
+    layout: z
+        .object({
+        mode: z.enum(['floating', 'inline', 'drawer']).optional(),
+        position: z.enum(['bottom-left', 'bottom-center', 'bottom-right']).optional(),
+        panelWidth: z.number().int().min(280).max(1200).optional(),
+        panelMinHeight: z.number().int().min(240).max(1600).optional(),
+        panelMaxHeight: z.number().int().min(320).max(2400).optional(),
+        edgeOffset: z.number().int().min(0).max(96).optional(),
+        zIndex: z.number().int().min(0).max(2_147_483_647).optional(),
+        density: z.enum(['compact', 'comfortable']).optional(),
+        mobileFullscreen: z.boolean().optional(),
+    })
+        .strict()
+        .optional(),
+    behavior: z
+        .object({
+        startOpen: z.boolean().optional(),
+        closeOnEscape: z.boolean().optional(),
+        closeOnOutsideClick: z.boolean().optional(),
+        showLauncher: z.boolean().optional(),
+        showHeader: z.boolean().optional(),
+        showAvatars: z.boolean().optional(),
+        showTimestamps: z.boolean().optional(),
+        showPoweredBy: z.boolean().optional(),
+    })
+        .strict()
+        .optional(),
+    labels: labelsSchema.optional(),
+    presentation: presentationSchema.optional(),
+    suggestedPrompts: z.array(z.string().trim().min(1).max(240)).max(8).optional(),
+    privacyUrl: z.string().url().refine(isHttpsUrl, 'must use https').optional(),
+    termsUrl: z.string().url().refine(isHttpsUrl, 'must use https').optional(),
+    locale: z.string().trim().min(2).max(35).optional(),
+    direction: z.enum(['ltr', 'rtl', 'auto']).optional(),
+})
+    .strict();
+export const assistantAppearanceOverrideSchema = z
+    .object({ branding: brandingSchema.optional(), assistant: assistantUiSchema.optional() })
+    .strict()
+    .refine(hasLeafValue, 'appearance override must contain at least one setting');
+/** Operator values win leaf-by-leaf; arrays replace and omitted fields retain developer intent. */
+export function resolveAssistantAppearanceConfiguration(developer, operator) {
+    if (developer === undefined && operator === undefined) {
+        return { effective: undefined, fallback: 'halo', provenance: {} };
+    }
+    const effective = mergeObjects(developer ?? {}, operator ?? {});
+    const provenance = {};
+    collectLeafPaths(developer, '', 'developer', provenance);
+    collectLeafPaths(operator, '', 'operator', provenance);
+    return { effective, fallback: 'halo', provenance };
+}
+function mergeObjects(base, override) {
+    const merged = structuredClone(base);
+    for (const [key, value] of Object.entries(override)) {
+        const current = merged[key];
+        merged[key] =
+            isPlainObject(current) && isPlainObject(value)
+                ? mergeObjects(current, value)
+                : structuredClone(value);
+    }
+    return merged;
+}
+function collectLeafPaths(value, path, source, output) {
+    if (!isPlainObject(value)) {
+        if (path)
+            output[path] = source;
+        return;
+    }
+    for (const [key, child] of Object.entries(value)) {
+        collectLeafPaths(child, path ? `${path}.${key}` : key, source, output);
+    }
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function hasLeafValue(value) {
+    return Object.values(value).some((child) => isPlainObject(child) ? hasLeafValue(child) : child !== undefined);
+}
+function isHttpsUrl(value) {
+    return new URL(value).protocol === 'https:';
+}
+function isSecureBrowserAssetUrl(value) {
+    const url = new URL(value);
+    if (url.protocol === 'https:')
+        return true;
+    if (url.protocol !== 'http:')
+        return false;
+    return url.hostname === 'localhost' || url.hostname === '127.0.0.1' || url.hostname === '[::1]';
+}
+//# sourceMappingURL=assistant-appearance.js.map

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-configuration.d.ts

@@ -0,0 +1,31 @@
+import type { ArtifactServer } from '@noodle-borg/compiler';
+import { type AssistantAppearanceOverride } from './assistant-appearance.js';
+import type { AssistantAppearanceSettingsStore } from './assistant-appearance-store.js';
+import { ASSISTANT_BROWSER_UI_FIELDS } from './assistant-store.js';
+import type { TenantRef } from './tenant-ref.js';
+/**
+ * What the browser is allowed to see.
+ *
+ * The session response's `configuration` crosses to the browser, and its wire schema is
+ * `z.record(z.unknown())` — it validates nothing. This was previously "everything on `server.assistant`
+ * except `model` and `allowedOrigins`", which is a denylist: it already shipped `sessionClaims` key
+ * names to every embed, and it would ship a public page the server's internal capability allowlist.
+ *
+ * An explicit allowlist inverts the default. A field reaches a customer's page because it is named
+ * in `ASSISTANT_BROWSER_UI_FIELDS`, not because nobody remembered to exclude it — so growth in the
+ * manifest cannot silently grow the browser payload. That list is owned by the gateway, beside the
+ * record type it produces, so this projection and the type it satisfies cannot disagree.
+ */
+export declare function assistantBrowserConfiguration(server: ArtifactServer): AssistantAppearanceOverride | undefined;
+/** Resolve environment operator state above the immutable deployment projection. */
+export declare function effectiveAssistantBrowserConfiguration(server: ArtifactServer, tenant: TenantRef, store: AssistantAppearanceSettingsStore | undefined): Promise<{
+    effective: AssistantAppearanceOverride | undefined;
+    fallback: "halo";
+    provenance: import("./assistant-appearance.js").AssistantAppearanceProvenance;
+    developer: {
+        readonly branding?: ArtifactServer["branding"];
+        readonly assistant?: Pick<NonNullable<ArtifactServer["assistant"]>, (typeof ASSISTANT_BROWSER_UI_FIELDS)[number]>;
+    } | undefined;
+    record: import("./assistant-appearance-store.js").AssistantAppearanceSettingsRecord | undefined;
+}>;
+//# sourceMappingURL=assistant-configuration.d.ts.map

package/node_modules/@noodle-borg/{service/dist/routes → assistant-gateway/dist}/assistant-configuration.js

@@ -1,4 +1,5 @@
-import { ASSISTANT_BROWSER_UI_FIELDS, } from '@noodle-borg/assistant-gateway/portable';
+import { resolveAssistantAppearanceConfiguration, } from './assistant-appearance.js';
+import { ASSISTANT_BROWSER_UI_FIELDS } from './assistant-store.js';
 /**
  * What the browser is allowed to see.
  *
@@ -28,4 +29,14 @@ export function assistantBrowserConfiguration(server) {
         ? configuration
         : undefined;
 }
+/** Resolve environment operator state above the immutable deployment projection. */
+export async function effectiveAssistantBrowserConfiguration(server, tenant, store) {
+    const developer = assistantBrowserConfiguration(server);
+    const record = await store?.get(tenant);
+    return {
+        developer,
+        record,
+        ...resolveAssistantAppearanceConfiguration(developer, record?.override),
+    };
+}
 //# sourceMappingURL=assistant-configuration.js.map

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-delegated-projection.d.ts

@@ -0,0 +1,12 @@
+import type { ArtifactTool, RuntimeArtifact } from '@noodle-borg/compiler';
+import type { ConnectorCompileError, SecretBinding } from '@noodle-borg/connector-defs';
+/** Join keys for caller-derived bindings: `connectorId|operation`, `connectorId|*` for defaults. */
+export declare function delegatedAuthOperationKeys(bindings: readonly SecretBinding[]): ReadonlySet<string>;
+/** Whether any operation this tool fulfils through is bound to caller-derived connector auth. */
+export declare function toolTouchesDelegatedAuth(tool: Pick<ArtifactTool, 'fulfilment'>, keys: ReadonlySet<string>): boolean;
+/**
+ * Reject delegated-auth tools projected to `public` surfaces. A `mixed` surface deliberately
+ * projects them — reaching one raises the sign-in card — so only pure `public` is an error.
+ */
+export declare function publicSurfaceDelegatedAuthErrors(artifact: Pick<RuntimeArtifact, 'tools' | 'server'>, bindings: readonly SecretBinding[]): readonly ConnectorCompileError[];
+//# sourceMappingURL=assistant-delegated-projection.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-store.d.ts

@@ -14,7 +14,7 @@ export declare const ASSISTANT_SESSION_IDLE_MS: number;
  * that lies — it once admitted `sessionClaims` key names, and would now admit the public surface's
  * capability allowlist — so growth in the manifest must not be able to grow the browser payload.
  */
-export declare const ASSISTANT_BROWSER_UI_FIELDS: readonly ["layout", "behavior", "labels", "presentation", "suggestedPrompts", "privacyUrl", "termsUrl", "locale", "direction"];
+export declare const ASSISTANT_BROWSER_UI_FIELDS: readonly ["theme", "layout", "behavior", "labels", "presentation", "suggestedPrompts", "privacyUrl", "termsUrl", "locale", "direction"];
 export interface AssistantClientRecord {
     readonly id: string;
     readonly name: string;

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-store.js

@@ -12,6 +12,7 @@ export const ASSISTANT_SESSION_IDLE_MS = 30 * 60 * 1000;
  * capability allowlist — so growth in the manifest must not be able to grow the browser payload.
  */
 export const ASSISTANT_BROWSER_UI_FIELDS = [
+    'theme',
     'layout',
     'behavior',
     'labels',

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-view-availability.d.ts

@@ -0,0 +1,38 @@
+import type { RuntimeArtifact } from '@noodle-borg/compiler';
+/** Safe renderer-facing identity for a completed tool that has a linked MCP App resource. */
+export interface AssistantViewAvailableData {
+    readonly id: string;
+    readonly tool: string;
+    readonly resourceUri: string;
+    readonly title?: string;
+    /** Already bounded/redacted public tool output. Never pass a raw runtime result here. */
+    readonly result: unknown;
+    readonly arguments?: unknown;
+    /** Self-contained MCP App document, with the standard bridge injected by the protocol runtime. */
+    readonly html: string;
+    readonly resourceMeta?: Readonly<Record<string, unknown>>;
+    readonly allowedOpenDomains?: readonly string[];
+    readonly replayed?: true;
+}
+/** A declared widget the completed tool could not surface — reported so the drop is never silent. */
+export interface AssistantViewUnresolved {
+    readonly tool: string;
+    readonly resourceUri: string;
+    readonly reason: 'resource_not_found' | 'resource_not_renderable';
+}
+/**
+ * Resolve a self-contained, statically compiled MCP App document for the embedded host. The linked
+ * resource must be present in the same compiled artifact and carry the MCP App MIME type; arbitrary
+ * tool metadata therefore cannot turn this event into a browser navigation. A tool with no declared
+ * `ui.resourceUri` resolves to `undefined` silently (no widget intended); a *declared* widget that
+ * cannot be resolved additionally invokes `onUnresolved` so callers can log the drop — a blank or
+ * missing widget must never be signal-free.
+ */
+export declare function assistantViewAvailableData(artifact: RuntimeArtifact, input: {
+    readonly id: string;
+    readonly tool: string;
+    readonly result: unknown;
+    readonly arguments?: unknown;
+    readonly replayed?: true;
+}, onUnresolved?: (failure: AssistantViewUnresolved) => void): AssistantViewAvailableData | undefined;
+//# sourceMappingURL=assistant-view-availability.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/embed-store.d.ts

@@ -32,6 +32,8 @@ export interface PublicEmbedRecord {
     readonly turnsPerDay?: number;
     readonly mintsPerDay?: number;
 }
+/** Project the non-secret embed coordinate onto the shared assistant tenant shape. */
+export declare function publicEmbedTenant(embed: PublicEmbedRecord): TenantRef;
 /** What an operator may change about a surface. An omitted field leaves that cap as it was. */
 export interface PublicEmbedBudget {
     readonly turnsPerDay?: number;
@@ -70,4 +72,5 @@ export interface PublicEmbedStore {
  */
 export declare const PUBLIC_EMBED_ID_PREFIX = "pub_";
 export declare function isPublicEmbedId(value: string): boolean;
+import type { TenantRef } from './tenant-ref.js';
 //# sourceMappingURL=embed-store.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/embed-store.js

@@ -11,6 +11,10 @@
  * projection underneath a page that never changes. Origins, capabilities, and UI therefore come from the
  * *active* deployment at mint time, never from the embed record.
  */
+/** Project the non-secret embed coordinate onto the shared assistant tenant shape. */
+export function publicEmbedTenant(embed) {
+    return { org: embed.org, app: embed.app, env: embed.env };
+}
 /**
  * `pub_` prefixed so it is self-describing in page source, logs, and support threads — someone reading a
  * customer's HTML can tell at a glance that it is not a secret that leaked.

package/node_modules/@noodle-borg/assistant-gateway/dist/in-memory-assistant-appearance-store.d.ts

@@ -0,0 +1,8 @@
+import { type AssistantAppearanceReplaceResult, type AssistantAppearanceSettingsRecord, type AssistantAppearanceSettingsStore } from './assistant-appearance-store.js';
+/** Process-local appearance settings for local development and tests. */
+export declare class InMemoryAssistantAppearanceSettingsStore implements AssistantAppearanceSettingsStore {
+    #private;
+    get(tenant: AssistantAppearanceSettingsRecord['tenant']): Promise<AssistantAppearanceSettingsRecord | undefined>;
+    replace(input: Parameters<AssistantAppearanceSettingsStore['replace']>[0]): Promise<AssistantAppearanceReplaceResult>;
+}
+//# sourceMappingURL=in-memory-assistant-appearance-store.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/in-memory-assistant-appearance-store.js

@@ -0,0 +1,26 @@
+import { appearanceTenantKey, cloneAssistantAppearanceSettingsRecord, } from './assistant-appearance-store.js';
+/** Process-local appearance settings for local development and tests. */
+export class InMemoryAssistantAppearanceSettingsStore {
+    #records = new Map();
+    async get(tenant) {
+        const record = this.#records.get(appearanceTenantKey(tenant));
+        return record === undefined ? undefined : cloneAssistantAppearanceSettingsRecord(record);
+    }
+    async replace(input) {
+        const key = appearanceTenantKey(input.tenant);
+        const current = this.#records.get(key);
+        const currentRevision = current?.revision ?? 0;
+        if (currentRevision !== input.expectedRevision)
+            return { ok: false, currentRevision };
+        const record = {
+            tenant: { ...input.tenant },
+            ...(input.override === undefined ? {} : { override: structuredClone(input.override) }),
+            revision: currentRevision + 1,
+            updatedAt: new Date(input.updatedAt),
+            updatedBy: input.updatedBy,
+        };
+        this.#records.set(key, record);
+        return { ok: true, record: cloneAssistantAppearanceSettingsRecord(record) };
+    }
+}
+//# sourceMappingURL=in-memory-assistant-appearance-store.js.map

package/node_modules/@noodle-borg/assistant-gateway/dist/portable.d.ts

@@ -1,8 +1,12 @@
 /** Assistant gateway contracts and in-memory adapters safe for the published CLI runtime. */
 export * from './artifact-projection.js';
+export * from './assistant-appearance.js';
+export * from './assistant-appearance-store.js';
+export * from './assistant-configuration.js';
 export * from './assistant-context.js';
 export * from './assistant-customer-issuer.js';
 export * from './assistant-customer-routing.js';
+export * from './assistant-delegated-projection.js';
 export * from './assistant-guide.js';
 export * from './assistant-interaction-state.js';
 export * from './assistant-interactive.js';
@@ -10,12 +14,15 @@ export * from './assistant-presentation.js';
 export * from './assistant-sensitive-values.js';
 export * from './assistant-store.js';
 export * from './assistant-transcript.js';
+export * from './assistant-view-availability.js';
 export * from './elevation.js';
 export * from './elevation-store.js';
 export * from './embed-script.js';
 export * from './embed-store.js';
+export * from './in-memory-assistant-appearance-store.js';
 export * from './in-memory-elevation-store.js';
 export * from './in-memory-embed-store.js';
+export * from './public-configuration.js';
 export * from './public-session.js';
 export * from './public-surface.js';
 export * from './public-turn.js';