@genesislcap/ai-assistant 15.19.0 → 15.19.1

package/src/main/file-attachments.test.ts

@@ -1,215 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { FoundationAiAssistant } from './main';
-
-// Hold a reference so the custom-element registration isn't tree-shaken.
-FoundationAiAssistant;
-
-// GENC-1508 — image files become IMAGE attachments, not text.
-//
-// `processFiles` read every accepted file with `readAsText`, so an accepted .png
-// arrived as mojibake the model "read" as prose — an accepted image was worse than a
-// rejected one. The layout-apply flow attaches the picked mockup's PNG beside its
-// spec, which is what forced the branch: images now read as base64 and ship as
-// `{kind:'image'}`, the shape the transports render as real image blocks.
-//
-// Unconnected elements (createElement upgrades but does not connect), same as
-// blocked-state.test.ts — processFiles touches no session state.
-
-const Suite = createLogicSuite('FoundationAiAssistant file attachments');
-
-type ProcessFiles = {
-  processFiles(
-    files: File[],
-    existingBytes?: number,
-  ): Promise<{ attachments: unknown[]; errors: string[] }>;
-};
-
-function element(acceptedFiles: string): ProcessFiles {
-  const el = document.createElement('foundation-ai-assistant') as FoundationAiAssistant;
-  el.chatConfig = { ui: { acceptedFiles } };
-  return el as unknown as ProcessFiles;
-}
-
-/** A tiny valid PNG header is unnecessary — processFiles never parses pixels. */
-const PNG_BYTES = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
-
-Suite('an accepted image file becomes a kind:image attachment with raw base64', async () => {
-  const el = element('.md,image/*');
-  const { attachments, errors } = await el.processFiles([
-    new File([PNG_BYTES], 'layout-mockup.png', { type: 'image/png' }),
-  ]);
-  assert.equal(errors, []);
-  const [img] = attachments as Array<{
-    kind?: string;
-    name: string;
-    mimeType: string;
-    data?: string;
-  }>;
-  assert.is(img.kind, 'image');
-  assert.is(img.name, 'layout-mockup.png');
-  assert.is(img.mimeType, 'image/png');
-  // RAW base64 — a `data:` prefix left on would be sent to the vendor inside the payload.
-  assert.ok(img.data && !img.data.startsWith('data:'), 'data must be bare base64');
-  assert.is(atob(img.data!).length, PNG_BYTES.length);
-});
-
-Suite('a text file on the same submit stays a text attachment', async () => {
-  const el = element('.md,image/*');
-  const { attachments } = await el.processFiles([
-    new File(['# spec'], 'layout-spec.md', { type: 'text/markdown' }),
-    new File([PNG_BYTES], 'layout-mockup.png', { type: 'image/png' }),
-  ]);
-  const [text, img] = attachments as Array<{ kind?: string; content?: string; data?: string }>;
-  assert.is(text.kind, undefined);
-  assert.is(text.content, '# spec');
-  assert.is(img.kind, 'image');
-});
-
-Suite('an image type the host did not accept is still refused', async () => {
-  const el = element('.md,.txt');
-  const { attachments, errors } = await el.processFiles([
-    new File([PNG_BYTES], 'layout-mockup.png', { type: 'image/png' }),
-  ]);
-  assert.equal(attachments, []);
-  assert.is(errors.length, 1);
-  assert.match(errors[0], /not an accepted file type/);
-});
-
-// A ~70KB image: the base64 loop's chunk size is 32768, so this crosses the boundary twice.
-// The 8-byte fixture above executes the loop body exactly once, which would not notice an
-// off-by-one in the subarray bounds.
-Suite('a multi-chunk image round-trips byte-for-byte across the base64 loop', async () => {
-  const big = new Uint8Array(70_000);
-  // A non-trivial pattern — an all-zero buffer survives most encoding mistakes.
-  for (let i = 0; i < big.length; i += 1) big[i] = (i * 31 + (i >> 8)) & 0xff;
-  const el = element('image/*');
-  const { attachments, errors } = await el.processFiles([
-    new File([big], 'wide.png', { type: 'image/png' }),
-  ]);
-  assert.equal(errors, []);
-  const [img] = attachments as Array<{ data: string }>;
-  const back = atob(img.data);
-  assert.is(back.length, big.length);
-  let mismatch = -1;
-  for (let i = 0; i < big.length; i += 1) {
-    if (back.charCodeAt(i) !== big[i]) {
-      mismatch = i;
-      break;
-    }
-  }
-  assert.is(mismatch, -1, 'every byte must survive the chunked encode');
-});
-
-Suite(
-  'an image over the size cap is refused by NAME and size, not sent to the vendor',
-  async () => {
-    // Refused here rather than at the API: a vendor 400 lands after the user has waited out the
-    // turn, and the encoded blob is persisted meanwhile — one oversized image can blow the storage
-    // quota and silently stop the session autosaving.
-    const el = element('image/*');
-    const { attachments, errors } = await el.processFiles([
-      new File([new Uint8Array(4_000_000)], 'huge.png', { type: 'image/png' }),
-    ]);
-    assert.equal(attachments, []);
-    assert.is(errors.length, 1);
-    assert.match(errors[0], /huge\.png/);
-    assert.match(errors[0], /limited to/);
-  },
-);
-
-Suite(
-  'an image type the vendors do not accept falls back to TEXT, never a failed turn',
-  async () => {
-    // `image/*` covers HEIC, BMP, TIFF, SVG — none of which the APIs take, and sending one fails
-    // the whole turn. SVG especially: it IS text, so the text branch gives the model something it
-    // can actually read.
-    const el = element('image/*');
-    const { attachments, errors } = await el.processFiles([
-      new File(['<svg xmlns="http://www.w3.org/2000/svg"><rect /></svg>'], 'icon.svg', {
-        type: 'image/svg+xml',
-      }),
-      new File([new Uint8Array([0, 1, 2, 3])], 'photo.heic', { type: 'image/heic' }),
-    ]);
-    assert.equal(errors, []);
-    const [svg, heic] = attachments as Array<{ kind?: string; content?: string; mimeType: string }>;
-    assert.is(svg.kind, undefined, 'SVG stays text — a model can read it');
-    assert.match(svg.content!, /<rect/);
-    assert.is(heic.kind, undefined, 'an unsupported binary degrades rather than failing the turn');
-  },
-);
-
-Suite('every supported spelling takes the image branch, including image/jpg', async () => {
-  const el = element('image/*');
-  const { attachments } = await el.processFiles(
-    ['image/png', 'image/jpeg', 'image/jpg', 'image/gif', 'image/webp'].map(
-      (type, i) => new File([PNG_BYTES], `f${i}`, { type }),
-    ),
-  );
-  assert.equal(
-    (attachments as Array<{ kind?: string }>).map((a) => a.kind),
-    ['image', 'image', 'image', 'image', 'image'],
-  );
-});
-
-// The TOTAL, not just each file. `loadSelectedFiles` appends across successive picks and the
-// per-file check is blind to what is already attached, so ten files each just under the per-image
-// ceiling used to be ten passes and one ~34MB request — assembled entirely out of files that each
-// passed. Reviewer catch on #2474.
-
-Suite('the file that crosses the total is refused; the ones that fit are kept', async () => {
-  const el = element('image/*');
-  const mb = (n: number) => new Uint8Array(n * 1_000_000);
-  const { attachments, errors } = await el.processFiles([
-    new File([mb(3)], 'a.png', { type: 'image/png' }),
-    new File([mb(3)], 'b.png', { type: 'image/png' }),
-    new File([mb(3)], 'c.png', { type: 'image/png' }), // 9MB total — past the 8MB ceiling
-  ]);
-  assert.is(attachments.length, 2, 'the two that fit are accepted');
-  assert.is(errors.length, 1);
-  assert.match(errors[0], /c\.png/);
-  assert.match(errors[0], /attachment limit/);
-});
-
-Suite('the budget counts what is ALREADY attached, not just this pick', async () => {
-  // The picker's second pick has to see the first one's bytes, or "under the limit" is measured
-  // against zero every time and the limit means nothing.
-  const el = element('image/*');
-  const fresh = await el.processFiles([
-    new File([new Uint8Array(3_000_000)], 'a.png', { type: 'image/png' }),
-  ]);
-  assert.is(fresh.attachments.length, 1, 'fits on its own');
-
-  const withHistory = await el.processFiles(
-    [new File([new Uint8Array(3_000_000)], 'b.png', { type: 'image/png' })],
-    6_000_000,
-  );
-  assert.is(
-    withHistory.attachments.length,
-    0,
-    'the same file is refused once 6MB is already committed',
-  );
-  assert.match(withHistory.errors[0], /6\.0MB already attached/);
-});
-
-Suite('a refusal skips only the offending file — a later one that still fits is kept', async () => {
-  // Budgeted synchronously off `file.size`, in the user's own pick order, before anything is read
-  // (deciding inside the parallel reads would hand the last slot to whichever finished first).
-  // A file that does not fit is refused and the budget carries on, so a smaller one behind it is
-  // not punished for its neighbour.
-  const el = element('image/*');
-  const mb = (n: number) => new Uint8Array(n * 1_000_000);
-  const { attachments, errors } = await el.processFiles([
-    new File([mb(3)], 'a.png', { type: 'image/png' }), // running 3
-    new File([mb(3)], 'b.png', { type: 'image/png' }), // running 6
-    new File([mb(3)], 'big.png', { type: 'image/png' }), // 9 > 8 — refused
-    new File([mb(1)], 'small.png', { type: 'image/png' }), // 7 — still fits
-  ]);
-  assert.equal(
-    (attachments as Array<{ name: string }>).map((a) => a.name),
-    ['a.png', 'b.png', 'small.png'],
-  );
-  assert.is(errors.length, 1);
-  assert.match(errors[0], /big\.png/);
-});
-
-Suite.run();

package/src/main/index.ts

@@ -1,3 +0,0 @@
-export * from './main.template';
-export * from './main';
-export * from './main.types';

package/src/main/interaction-cost.test.ts

@@ -1,140 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { getSessionStore } from '../state/session-store';
-import { FoundationAiAssistant } from './main';
-
-// Hold a reference so the custom-element registration isn't tree-shaken.
-FoundationAiAssistant;
-
-// GENC-1508 — the host hop of the post-resolve cost channel.
-//
-// The driver method and the orchestrator delegation both have tests; this pins the hop
-// between them, which is the one most likely to break silently: a rename on either side of
-// `handleInteractionCost` is a no-op that every other test still passes, and the "no spinner"
-// guarantee is a design promise stated only in a comment.
-//
-// Unconnected element (createElement upgrades but does not connect), same as
-// blocked-state.test.ts — this handler touches no session state.
-
-const Suite = createLogicSuite('FoundationAiAssistant interaction cost');
-
-type CostHost = {
-  handleInteractionCost(e: Event): void;
-  driver: unknown;
-  startLoadingTimer(): void;
-};
-
-function host(): { el: CostHost; calls: Array<[string, number]>; spinners: number } {
-  const el = document.createElement('foundation-ai-assistant') as unknown as CostHost;
-  const calls: Array<[string, number]> = [];
-  const state = { spinners: 0 };
-  el.driver = {
-    recordExternalCost: (id: string, cost: number) => {
-      calls.push([id, cost]);
-      return true;
-    },
-  };
-  el.startLoadingTimer = () => {
-    state.spinners += 1;
-  };
-  return {
-    el,
-    calls,
-    get spinners() {
-      return state.spinners;
-    },
-  };
-}
-
-const costEvent = (detail: unknown) => new CustomEvent('interaction-cost', { detail });
-
-Suite('a cost report reaches the driver', () => {
-  const h = host();
-  h.el.handleInteractionCost(costEvent({ interactionId: 'abc', costUsd: 0.42 }));
-  assert.equal(h.calls, [['abc', 0.42]]);
-});
-
-Suite('reporting cost NEVER starts the loading spinner', () => {
-  // The whole point of the channel: this is bookkeeping about a turn that already finished, so
-  // it must be invisible. A spinner would tell the user the assistant is working when nothing
-  // is pending — the one thing `handleInteractionCompleted` does that this must not copy.
-  const h = host();
-  h.el.handleInteractionCost(costEvent({ interactionId: 'abc', costUsd: 0.42 }));
-  assert.is(h.spinners, 0);
-});
-
-Suite('an event with no interactionId is ignored', () => {
-  const h = host();
-  h.el.handleInteractionCost(costEvent({ costUsd: 0.42 }));
-  h.el.handleInteractionCost(costEvent(undefined));
-  assert.equal(h.calls, []);
-});
-
-Suite('a driver that does not implement the optional method is not called into', () => {
-  // `recordExternalCost` is optional on `AiDriver`, so a driver predating this — or one that
-  // simply does not track spend — must be ignored rather than throw.
-  const h = host();
-  h.el.driver = {};
-  assert.not.throws(() =>
-    h.el.handleInteractionCost(costEvent({ interactionId: 'a', costUsd: 1 })),
-  );
-  h.el.driver = undefined;
-  assert.not.throws(() =>
-    h.el.handleInteractionCost(costEvent({ interactionId: 'a', costUsd: 1 })),
-  );
-});
-
-Suite('a driver without the method leaves a TRACE, not a silent no-op', () => {
-  // Reviewer catch on #2474: every other hop traces its drops. A driver predating
-  // `recordExternalCost` made this one a silent no-op — money gone, nothing recorded — which is
-  // the invisible gap the whole channel exists to close, reintroduced at the last hop.
-  const h = host();
-  const meta: Array<[string, Record<string, unknown>]> = [];
-  (h.el as unknown as { logMeta(t: string, d: Record<string, unknown>): void }).logMeta = (
-    t,
-    d,
-  ) => {
-    meta.push([t, d]);
-  };
-  h.el.driver = {};
-  h.el.handleInteractionCost(costEvent({ interactionId: 'abc', costUsd: 0.42 }));
-  assert.is(meta.length, 1);
-  assert.is(meta[0][0], 'interaction.external-cost-dropped');
-  assert.is(meta[0][1].costUsd, 0.42);
-  assert.is(meta[0][1].interactionId, 'abc');
-});
-
-// The OUTBOUND half: the driver announced, and the host has to turn that into a moved number.
-// Tested because it is the same shape of hop as the one that already went wrong — the wrapper
-// forward that was missing — and because it deliberately reads the DRIVER's history rather than
-// `this.messages`, which is the part a reader would most likely "simplify" back.
-
-let storeSeq = 0;
-
-/** An element wired to its own real session store, so `sessionUsage` round-trips. */
-function costHost(): FoundationAiAssistant {
-  const el = document.createElement('foundation-ai-assistant') as FoundationAiAssistant;
-  storeSeq += 1;
-  (el as unknown as { _sessionRef: unknown })._sessionRef = getSessionStore(
-    `cost-test-${(storeSeq += 1)}`,
-    false,
-  );
-  return el;
-}
-
-Suite('the recorded spend reaches the session total from the DRIVER history', () => {
-  const el = costHost();
-  const sync = (el as unknown as { syncUsageTotals(m: unknown[]): void }).syncUsageTotals.bind(el);
-
-  sync([{ role: 'assistant', content: 'a', cost: 0.1, model: 'claude-sonnet-5' }]);
-  assert.is(el.sessionCostUsd, 0.1);
-
-  // The post-resolve delta lands on the interaction message as `externalCostUsd`; the total has
-  // to fold it in, or every hop before this one was wasted.
-  sync([
-    { role: 'assistant', content: 'a', cost: 0.1, model: 'claude-sonnet-5' },
-    { role: 'assistant', content: 'b', externalCostUsd: 0.25 },
-  ]);
-  assert.is(el.sessionCostUsd, 0.35);
-});
-
-Suite.run();

package/src/main/main.styles.test.ts

@@ -1,216 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { foregroundOnAccentRest, neutralLayer2 } from '@genesislcap/foundation-ui';
-import { styles } from './main.styles';
-
-// CSS is not otherwise unit-tested in this package, so this covers the two
-// properties of the BLOCKED BANNER that are cheap to assert from the generated
-// text and that a reviewer had to catch by eye:
-//
-//   1. Design-system tokens are consumed UNFALLBACKED, as every other rule in the
-//      file does. A `var(--token, fallback)` here is dead code at best — both
-//      tokens below ship with defaults — and actively wrong at worst: the blocked
-//      banner's old `var(--neutral-layer-2, transparent)` would, if it ever fired,
-//      have produced a banner with no surface at all.
-//   2. The blocked banner's visual treatment hangs off `.is-visible`, not the bare
-//      class, because the container stays mounted while unblocked so that its
-//      `role="status"` region is registered before the text arrives (see
-//      main.template.ts). Collapsing the empty container would undo that.
-//
-// Scope: the banner's own rules, and nothing else. Both negative assertions were
-// written for one component, but an earlier version grepped the WHOLE stylesheet
-// — quietly turning a banner test into a global style policy nobody agreed to, so
-// any future rule anywhere in an 800-line sheet that legitimately wanted a
-// fallback on either token would have failed a test named after the banner.
-//
-// A second suite at the bottom covers the user bubble's fill/foreground token
-// pairing, which failed the same way a reviewer's eye does (GENC-1491).
-
-const suite = createLogicSuite('main.styles blocked-banner rules');
-
-/**
- * The generated stylesheet text. `css` composes nested `ElementStyles` (this file
- * builds the sheet from several partials), so flatten recursively rather than
- * only reading the top level — a shallow read silently returns almost nothing,
- * which would make every `assert.not.ok` below pass vacuously. The first test
- * guards exactly that.
- */
-const flatten = (value: unknown): string => {
-  if (typeof value === 'string') return value;
-  if (Array.isArray(value)) return value.map(flatten).join('\n');
-  const nested = (value as { styles?: unknown } | null | undefined)?.styles;
-  return nested ? flatten(nested) : '';
-};
-
-const cssText = flatten(styles);
-
-/**
- * Every declaration block whose selector mentions `.blocked-banner`, joined.
- *
- * Deliberately crude — one regex over the generated text, no CSS parser — but
- * enough to keep these assertions about the banner rather than about the whole
- * sheet, which was the only thing wrong with them. It matches
- * `<selector> { <declarations> }` for any selector containing `.blocked-banner`,
- * so it picks up the bare class, the `.is-visible` / `.is-partial` modifiers, the
- * shared composer-width group and the copy inside the container query alike.
- */
-const bannerRules = (cssText.match(/[^{}]*\.blocked-banner[^{}]*\{[^}]*\}/g) ?? []).join('\n');
-
-/** Declarations of the bare-class rule — the one that applies while empty. */
-const emptyStateRule = cssText.match(/[\s{}](\.blocked-banner)\s*\{([^}]*)\}/)?.[2] ?? '';
-
-suite('the banner rules were extracted as text (guards the assertions below)', () => {
-  assert.ok(cssText.includes('.blocked-banner'), 'the banner rules are in the sheet');
-  assert.ok(bannerRules.includes('.is-visible'), 'the extraction found the modifier rules');
-  assert.ok(emptyStateRule.length > 0, 'and isolated the bare-class rule');
-});
-
-suite('the banner consumes design-system tokens without dead fallbacks', () => {
-  assert.not.ok(
-    bannerRules.includes('var(--neutral-layer-2,'),
-    '--neutral-layer-2 has a DS default and is used unfallbacked everywhere else here',
-  );
-  assert.not.ok(
-    bannerRules.includes('var(--warning-color,'),
-    '--warning-color has a DS default and is used unfallbacked by toast/badge styles',
-  );
-});
-
-suite('the blocked banner keeps its unblocked container visually inert', () => {
-  // `::part(blocked-banner)` matches at all times, so the empty state must set
-  // nothing that reserves space — and must not remove the container from the
-  // accessibility tree, which is where the `role="status"` region is registered.
-  //
-  // Asserted against the bare-class rule's own declarations rather than by
-  // grepping for a `:empty` selector nobody wrote: this catches the mistake as it
-  // would actually be made — a padding or border creeping onto the always-present
-  // container — instead of one specific spelling of it.
-  //
-  // `margin-block` rather than `margin`: the shared composer-width group sets
-  // `margin-inline: auto` on the banner along with the rest of the composer
-  // column, which centres it and reserves nothing.
-  assert.ok(cssText.includes('.blocked-banner.is-visible'), 'visuals hang off is-visible');
-  for (const property of ['display: none', 'padding', 'border', 'background', 'margin-block']) {
-    assert.not.ok(
-      emptyStateRule.includes(property),
-      `the always-present container must not set ${property} — that is .is-visible's job`,
-    );
-  }
-});
-
-suite('the visible banner hands its end margin to the resize handle', () => {
-  // Reviewer's manual-testing note: the banner's block-end margin plus the 7px
-  // handle stacked into a gap the hover pill was NOT centred in (it centres in
-  // the handle alone). The adjacency rule collapses the two so the handle IS
-  // the gap. What gets pinned is the INVARIANT, not the selector's existence:
-  // both rules must read the ONE shared token, because the cancellation only
-  // works while the banner's margin and the handle's pull are equal-and-
-  // opposite — two hand-kept magnitudes ~80 lines apart regress silently, and
-  // an existence-only assertion stayed green while they did.
-  assert.ok(
-    /:host\s*\{[^}]*--blocked-banner-gap:/.test(cssText),
-    'the shared gap token is declared on the host (a sibling cannot read one on the banner)',
-  );
-  assert.ok(
-    /\.blocked-banner\.is-visible\s*\{[^}]*margin-block:\s*var\(--blocked-banner-gap\)/.test(
-      cssText,
-    ),
-    "the banner's block margin IS the token",
-  );
-  assert.ok(
-    /\.blocked-banner\.is-visible \+ \.composer-resize-handle\s*\{[^}]*margin-block-start:\s*calc\(var\(--blocked-banner-gap\) \* -1\)/.test(
-      cssText,
-    ),
-    'and the handle pulls up by exactly that token, negated — equal and opposite by construction',
-  );
-});
-
-suite('partial exhaustion has its own modifier, layered on the visible state', () => {
-  // `.is-visible` carries the layout and surface for BOTH states; `.is-partial`
-  // only softens it. Additive, never a replacement — so host CSS keyed on the
-  // visible state needs to know nothing about partial exhaustion.
-  assert.ok(cssText.includes('.blocked-banner.is-partial'), 'the partial modifier exists');
-});
-
-suite.run();
-
-// ─── User message bubble ──────────────────────────────────────────────────────
-
-const bubble = createLogicSuite('main.styles user-message colour pairing');
-
-/** Declarations of the `.message.user` rule — the accent-filled bubble. */
-const userMessageRule = cssText.match(/\.message\.user\s*\{([^}]*)\}/)?.[1] ?? '';
-
-bubble('the user bubble pairs its accent fill with the on-accent foreground', () => {
-  // The bubble fills with --accent-fill-rest, so its text MUST come from the
-  // design system's paired on-accent token. This shipped as
-  // `--accent-foreground-on-accent-rest` — a name nothing defines — and the
-  // failure was invisible in review and in dark mode: `color` is inherited, so an
-  // undefined custom property with no fallback is invalid at computed-value time
-  // and quietly leaves the text at the inherited neutral foreground. That reads
-  // white-ish on a dark app (looks intentional) and near-black on a light one,
-  // where it landed at ~1.3:1 against the fill (GENC-1491).
-  //
-  // Asserted against the token object's OWN cssCustomProperty rather than a
-  // repeated string literal: a typo here cannot agree with itself, and a rename
-  // in the design system fails this test instead of silently reintroducing the
-  // inherit.
-  assert.ok(userMessageRule.length > 0, 'the .message.user rule is in the sheet');
-  assert.ok(
-    userMessageRule.includes('var(--accent-fill-rest)'),
-    'the bubble is filled from the accent token (the premise of the pairing)',
-  );
-  assert.ok(
-    userMessageRule.includes(`color: var(${foregroundOnAccentRest.cssCustomProperty})`),
-    `the text colour is ${foregroundOnAccentRest.cssCustomProperty}, which the design system defines`,
-  );
-});
-
-bubble.run();
-
-// ─── Composer divider ─────────────────────────────────────────────────────────
-
-const divider = createLogicSuite('main.styles composer divider');
-
-/** Declarations of the `.composer-bar` rule — the hairline between input and controls. */
-const composerBarRule = cssText.match(/\.composer-bar\s*\{([^}]*)\}/)?.[1] ?? '';
-
-divider('the divider is opt-in, and its default hides it without collapsing it', () => {
-  // Two things have to hold together, and only one of them is visible in review.
-  //
-  // 1. The line is always DRAWN — a host enabling `--ai-composer-divider` must get
-  //    a colour change, not a 1px reflow of the whole control bar. So the rule
-  //    declares a real border and hides it by painting it the composer's own
-  //    surface colour, rather than omitting the border and adding it back later.
-  //
-  // 2. That default colour has to name a token the design system actually
-  //    defines. An earlier revision reached for `--neutral-stroke-divider`, which
-  //    nothing defines: with no fallback the declaration is invalid at
-  //    computed-value time, the whole shorthand is dropped, and the divider silently
-  //    does not render — identically in both themes, which is why it survived review.
-  //    (The user bubble suite above documents the same failure, GENC-1491.)
-  //
-  // Asserted against the token object's own cssCustomProperty rather than a repeated
-  // string literal: a typo cannot agree with itself, and a design-system rename fails
-  // here instead of quietly deleting the line again.
-  assert.ok(composerBarRule.length > 0, 'the .composer-bar rule is in the sheet');
-  assert.ok(
-    composerBarRule.includes(
-      `border-top: 1px solid var(--ai-composer-divider, var(${neutralLayer2.cssCustomProperty}))`,
-    ),
-    `the divider is declared, opt-in via --ai-composer-divider, defaulting to ${neutralLayer2.cssCustomProperty}`,
-  );
-});
-
-divider('the invisible default matches the surface it sits on', () => {
-  // The hiding trick only works while the fallback colour IS the composer's
-  // background. If one moves off --neutral-layer-2 and the other doesn't, the
-  // "invisible" divider becomes a visible line nobody asked for.
-  const composerRule = cssText.match(/[\s{}]\.composer\s*\{([^}]*)\}/)?.[1] ?? '';
-  assert.ok(composerRule.length > 0, 'the .composer rule is in the sheet');
-  assert.ok(
-    composerRule.includes(`background-color: var(${neutralLayer2.cssCustomProperty})`),
-    'the composer surface is the same token the divider defaults to',
-  );
-});
-
-divider.run();