@startsimpli/integrations 0.1.4 → 0.1.5

package/src/__tests__/corpus-scope.test.ts

@@ -0,0 +1,216 @@
+/**
+ * SCOPE ISOLATION — the test bd startsim-768w.38.7 asks for by name.
+ *
+ * "An AI that retrieves across a scope boundary leaks data in the most
+ * convincing possible format. Write a deliberate test for this — do not just
+ * assume the query layer handles it."
+ *
+ * So this file assumes the query layer DOES NOT handle it. Every case below runs
+ * against a corpus API deliberately configured to leak (`leakScope: true`),
+ * which is what a mis-scoped serializer, a forgotten `org_id` filter or a
+ * cached response would look like from the client's side. If the pipeline is
+ * only safe because the server is, these tests fail — which is the point.
+ *
+ * The bait is `nw_contract_44` in `FIXTURE_OTHER_ORG`: a document that answers
+ * the tandem question BETTER than anything tandem owns. A ranker with no guard
+ * puts it first.
+ */
+import { describe, expect, it, vi } from 'vitest';
+
+import { askCorpus } from '../corpus/ask';
+import {
+  createFixtureCorpusApi,
+  createFixtureLlm,
+  FIXTURE_DOCUMENTS,
+  FIXTURE_ORG,
+  FIXTURE_OTHER_ORG,
+} from '../corpus/fixtures';
+import { enforceScope, isInScope, rankDocuments, retrieveForQuestion } from '../corpus/retrieval';
+import type { AskRequest, CorpusLlm, SourceDocument } from '../corpus/types';
+
+const TANDEM = { orgId: FIXTURE_ORG };
+const NORTHWIND = { orgId: FIXTURE_OTHER_ORG };
+
+/** The question whose most attractive answer lives in the OTHER workspace. */
+const BAIT = 'What did we agree with Acme Robotics on renewal rate and seats?';
+
+function foreignDocuments(documents: SourceDocument[], orgId: string) {
+  return documents.filter((document) => document.scope.orgId !== orgId);
+}
+
+describe('isInScope — the boundary itself', () => {
+  const row = { scope: { orgId: 'tandem', ownerSub: 'usr_dana' } };
+
+  it('admits a row from the same workspace', () => {
+    expect(isInScope(row, { orgId: 'tandem' })).toBe(true);
+  });
+
+  it('refuses a row from another workspace', () => {
+    expect(isInScope(row, { orgId: 'northwind' })).toBe(false);
+  });
+
+  it('refuses everything when the scope carries no org claim', () => {
+    // A principal with no org_id must read NOTHING, not everything. This is the
+    // failure mode where a missing claim reads as "unscoped" and returns the world.
+    expect(isInScope(row, { orgId: '' })).toBe(false);
+  });
+
+  it('enforces the per-row owner only when the caller asked for it', () => {
+    expect(isInScope(row, { orgId: 'tandem', ownerSub: 'usr_dana' })).toBe(true);
+    expect(isInScope(row, { orgId: 'tandem', ownerSub: 'usr_sam' })).toBe(false);
+    // Not asking for an owner is the tenant API's real posture (org + readable
+    // type), so the guard must not silently claim a narrower one.
+    expect(isInScope(row, { orgId: 'tandem' })).toBe(true);
+  });
+
+  it('refuses a row whose org is a PREFIX of the caller’s, not a match', () => {
+    // Guards written with startsWith leak between `acme` and `acme-eu`.
+    expect(isInScope({ scope: { orgId: 'tandem-eu' } }, { orgId: 'tandem' })).toBe(false);
+    expect(isInScope({ scope: { orgId: 'tandem' } }, { orgId: 'tandem-eu' })).toBe(false);
+  });
+});
+
+describe('enforceScope — nothing is dropped silently', () => {
+  it('partitions a mixed set and reports what it removed', () => {
+    const { kept, dropped } = enforceScope(FIXTURE_DOCUMENTS, TANDEM);
+    expect(kept.length + dropped.length).toBe(FIXTURE_DOCUMENTS.length);
+    expect(dropped.length).toBe(foreignDocuments(FIXTURE_DOCUMENTS, FIXTURE_ORG).length);
+    expect(dropped.every((document) => document.scope.orgId === FIXTURE_OTHER_ORG)).toBe(true);
+  });
+});
+
+describe('retrieval refuses the bait', () => {
+  it('ranks the foreign document FIRST when the guard is removed', () => {
+    // Establishes that the guard is doing real work: without it, the leak wins.
+    const unguarded = rankDocuments(FIXTURE_DOCUMENTS, BAIT, { limit: 5 });
+    expect(unguarded[0]?.document.id).toBe('nw_contract_44');
+  });
+
+  it('never returns it once the guard runs', () => {
+    const { retrieved, droppedOutOfScope } = retrieveForQuestion(FIXTURE_DOCUMENTS, BAIT, TANDEM, {
+      limit: 5,
+    });
+    expect(retrieved.length).toBeGreaterThan(0);
+    expect(retrieved.map((item) => item.document.id)).not.toContain('nw_contract_44');
+    expect(retrieved.every((item) => item.document.scope.orgId === FIXTURE_ORG)).toBe(true);
+    expect(droppedOutOfScope).toBeGreaterThan(0);
+  });
+});
+
+describe('askCorpus — the leak never reaches the model', () => {
+  /** A model that records exactly what it was shown. */
+  function spyLlm(): { llm: CorpusLlm; seen: string[][] } {
+    const seen: string[][] = [];
+    const inner = createFixtureLlm();
+    return {
+      seen,
+      llm: {
+        describe: inner.describe,
+        async answer(input) {
+          seen.push(input.documents.map((document) => document.id));
+          return inner.answer(input);
+        },
+      },
+    };
+  }
+
+  const request = (question = BAIT): AskRequest => ({ question, mode: 'ask', scope: TANDEM });
+
+  it('does not put a foreign document in the prompt even when the API returns one', async () => {
+    const corpus = createFixtureCorpusApi({ scope: TANDEM, leakScope: true });
+    const { llm, seen } = spyLlm();
+
+    const result = await askCorpus(request(), { corpus, llm });
+
+    expect(seen).toHaveLength(1); // ONE call, not one per document
+    expect(seen[0]).not.toContain('nw_contract_44');
+    expect(result.droppedOutOfScope).toBeGreaterThan(0);
+    expect(result.citations.every((citation) => citation.document.scope.orgId === FIXTURE_ORG)).toBe(true);
+  });
+
+  it('never cites a foreign document, and says the API returned some', async () => {
+    const corpus = createFixtureCorpusApi({ scope: TANDEM, leakScope: true });
+    const result = await askCorpus(request(), { corpus, llm: createFixtureLlm() });
+
+    expect(result.answer).not.toContain('Northwind');
+    expect(result.answer).not.toContain('2,750');
+    expect(result.citations.map((citation) => citation.documentId)).not.toContain('nw_contract_44');
+    // The count is surfaced so a leaking API is visible rather than absorbed.
+    expect(result.droppedOutOfScope).toBeGreaterThan(0);
+  });
+
+  it('answers a cross-scope question with NOTHING rather than someone else’s records', async () => {
+    // "Northwind" is the one term in the fixture set that appears ONLY in the
+    // other workspace's document, so a question built on it has no honest answer
+    // inside tandem. The wrong outcome here is not an error — it is a fluent,
+    // confident, correctly-formatted answer sourced from another customer.
+    const corpus = createFixtureCorpusApi({ scope: TANDEM, leakScope: true });
+    const result = await askCorpus(
+      { question: 'Northwind', mode: 'ask', scope: TANDEM },
+      { corpus, llm: createFixtureLlm() },
+    );
+
+    expect(result.status).toBe('no_evidence');
+    expect(result.citations).toHaveLength(0);
+    expect(result.considered).toHaveLength(0);
+    expect(result.answer).not.toMatch(/2,?750|unlimited/i);
+  });
+
+  it('answers a shared-term question from its OWN records, never the other workspace’s', async () => {
+    // The subtler half: the question is answerable in both workspaces. Silence
+    // would be over-blocking; the requirement is that the answer is tandem's.
+    const corpus = createFixtureCorpusApi({ scope: TANDEM, leakScope: true });
+    const result = await askCorpus(
+      { question: 'What notice period do we have for termination for convenience?', mode: 'ask', scope: TANDEM },
+      { corpus, llm: createFixtureLlm() },
+    );
+
+    expect(result.status).toBe('answered');
+    expect(result.citations.length).toBeGreaterThan(0);
+    expect(result.citations.every((citation) => citation.document.scope.orgId === FIXTURE_ORG)).toBe(true);
+    expect(result.considered.every((item) => item.document.scope.orgId === FIXTURE_ORG)).toBe(true);
+    expect(result.answer).not.toMatch(/2,?750|unlimited|Northwind/i);
+  });
+
+  it('gives the OTHER workspace its own answer — isolation, not blanket denial', async () => {
+    const corpus = createFixtureCorpusApi({ scope: NORTHWIND, leakScope: true });
+    const result = await askCorpus(
+      { question: 'What renewal rate did we agree with Acme Robotics?', mode: 'ask', scope: NORTHWIND },
+      { corpus, llm: createFixtureLlm() },
+    );
+
+    expect(result.status).toBe('answered');
+    expect(result.citations.map((citation) => citation.documentId)).toEqual(['nw_contract_44']);
+    expect(result.citations.every((citation) => citation.document.scope.orgId === FIXTURE_OTHER_ORG)).toBe(true);
+  });
+
+  it('refuses outright when the session carries no workspace claim', async () => {
+    const corpus = createFixtureCorpusApi({ leakScope: true });
+    const listDocuments = vi.spyOn(corpus, 'listDocuments');
+
+    const result = await askCorpus(
+      { question: BAIT, mode: 'ask', scope: { orgId: '' } },
+      { corpus, llm: createFixtureLlm() },
+    );
+
+    expect(result.status).toBe('no_evidence');
+    expect(result.citations).toHaveLength(0);
+    // It does not even ASK — an unscoped read is not made and then filtered.
+    expect(listDocuments).not.toHaveBeenCalled();
+  });
+
+  it('honours a per-owner scope when one is supplied', async () => {
+    const corpus = createFixtureCorpusApi({ scope: TANDEM, leakScope: true });
+    const result = await askCorpus(
+      {
+        question: 'ad-hoc call with no calendar invite',
+        mode: 'ask',
+        scope: { orgId: FIXTURE_ORG, ownerSub: 'usr_dana' },
+      },
+      { corpus, llm: createFixtureLlm() },
+    );
+
+    // `not_Pd9wLs3EhY6cQz` is owned by usr_sam and is the only match.
+    expect(result.citations.map((citation) => citation.documentId)).not.toContain('not_Pd9wLs3EhY6cQz');
+  });
+});

package/src/components/index.ts

@@ -24,3 +24,8 @@ export type {
   ConnectionInvokeResult,
   ConnectionRun,
 } from './pages/types';
+
+// The corpus layer (bd startsim-768w.38.6, startsim-768w.38.7): the READ side of
+// connections. Same rule as above — the page composers ship, not just the parts.
+export * from './pages/LibraryPage';
+export * from './pages/AskPage';

package/src/components/pages/AskPage.tsx

@@ -0,0 +1,384 @@
+/**
+ * Ask & Generate — AI over your own documents, with citations back to the
+ * records (bd startsim-768w.38.7). The headline surface of the epic.
+ *
+ * `<AskPage api={askApi} scope={scope} />`, same injected shape as
+ * `ConnectionsPage` and `LibraryPage`. The app owns theme classNames and a
+ * wrapper; the LLM call happens behind `api.ask`, server-side, where the key is.
+ * Nothing in this file imports a provider.
+ *
+ * TWO MODES, ONE SURFACE. ASK answers a question from the corpus. GENERATE
+ * drafts a document — a contract, a follow-up, a summary — from a prompt plus
+ * the corpus. Same retrieval, same citation rules; the only difference is what
+ * the model is asked to emit and whether the result can be saved back as a
+ * record, so that the draft is part of the corpus next time.
+ *
+ * CITATIONS ARE NOT A NICE-TO-HAVE, AND THIS FILE IS WHERE THAT IS ENFORCED
+ * VISIBLY:
+ *
+ *   • every answer renders the records it used, each one clicking through to
+ *     that record's detail in the Library;
+ *   • an answer with NO resolvable citation renders under a warning and is
+ *     never presented as sourced — an answer you cannot trace is one you cannot
+ *     trust with a contract;
+ *   • an id the model cited that retrieval never supplied is displayed as an
+ *     invented source rather than dropped quietly;
+ *   • the provider that actually answered is named, and a run that came from a
+ *     stub says so, because a fake model behind real-looking citations is worse
+ *     than no answer at all;
+ *   • stale or failing sources are repeated here, because the honest caveat on
+ *     any answer is "…from a corpus that last synced on Tuesday".
+ */
+import * as React from 'react';
+
+import type {
+  AskMode,
+  AskRequest,
+  AskResult,
+  CorpusAskApi,
+  CorpusScope,
+  SourceFreshness,
+} from '../../corpus/types';
+
+export interface AskPageProps {
+  api: CorpusAskApi;
+  scope: CorpusScope;
+  /** Click-through from a citation to the record, normally the Library route. */
+  onOpenDocument?: (documentId: string) => void;
+  /** Prefill, e.g. from a `?q=` param. */
+  initialQuestion?: string;
+  initialMode?: AskMode;
+  classNames?: Partial<Record<AskSlot, string>>;
+}
+
+type AskSlot =
+  | 'root' | 'section' | 'heading' | 'card' | 'badge' | 'button' | 'secondaryButton'
+  | 'input' | 'textarea' | 'muted' | 'error' | 'warning' | 'answer';
+
+const DEFAULTS: Record<AskSlot, string> = {
+  root: 'space-y-6',
+  section: 'space-y-3',
+  heading: 'text-lg font-semibold text-gray-900',
+  card: 'rounded-lg border border-gray-200 p-4',
+  badge: 'inline-flex items-center rounded-full border border-gray-300 px-2 py-0.5 text-xs text-gray-700',
+  button: 'rounded-md bg-gray-900 px-3 py-1.5 text-sm font-medium text-white disabled:opacity-50',
+  secondaryButton: 'rounded-md border border-gray-300 px-3 py-1.5 text-sm font-medium text-gray-800 disabled:opacity-50',
+  input: 'w-full rounded-md border border-gray-300 px-3 py-2 text-sm',
+  textarea: 'w-full rounded-md border border-gray-300 px-3 py-2 text-sm',
+  muted: 'text-sm text-gray-500',
+  error: 'text-sm text-red-600',
+  warning: 'rounded-md border border-amber-300 bg-amber-50 p-3 text-sm text-amber-900',
+  answer: 'whitespace-pre-wrap rounded-md bg-gray-50 p-3 text-sm text-gray-900',
+};
+
+const MODE_LABELS: Record<AskMode, { tab: string; prompt: string; action: string; placeholder: string }> = {
+  ask: {
+    tab: 'Ask',
+    prompt: 'Question',
+    action: 'Ask',
+    placeholder: 'What did we agree with Acme Robotics on renewal?',
+  },
+  generate: {
+    tab: 'Generate',
+    prompt: 'What should be drafted',
+    action: 'Generate draft',
+    placeholder: 'Draft a renewal letter for Acme Robotics using the agreed terms.',
+  },
+};
+
+function failureMessage(err: unknown): string {
+  const status = (err as { status?: number })?.status;
+  if (status === 403) return 'You do not have access to this workspace’s records.';
+  if (status === 401) return 'Your session has expired. Sign in again.';
+  return (err as { message?: string })?.message || 'That question could not be answered right now.';
+}
+
+export function AskPage({
+  api,
+  scope,
+  onOpenDocument,
+  initialQuestion = '',
+  initialMode = 'ask',
+  classNames = {},
+}: AskPageProps) {
+  const cn = { ...DEFAULTS, ...classNames };
+
+  const [mode, setMode] = React.useState<AskMode>(initialMode);
+  const [question, setQuestion] = React.useState(initialQuestion);
+  const [instructions, setInstructions] = React.useState('');
+  const [result, setResult] = React.useState<AskResult | null>(null);
+  const [busy, setBusy] = React.useState(false);
+  const [error, setError] = React.useState('');
+  const [saveState, setSaveState] = React.useState<'idle' | 'saving' | 'saved'>('idle');
+
+  const submit = React.useCallback(async () => {
+    const trimmed = question.trim();
+    if (!trimmed) return;
+    setBusy(true);
+    setError('');
+    setSaveState('idle');
+    try {
+      const request: AskRequest = {
+        question: trimmed,
+        mode,
+        scope,
+        ...(mode === 'generate' && instructions.trim() ? { instructions: instructions.trim() } : {}),
+      };
+      setResult(await api.ask(request));
+    } catch (err) {
+      setResult(null);
+      setError(failureMessage(err));
+    } finally {
+      setBusy(false);
+    }
+  }, [api, instructions, mode, question, scope]);
+
+  const canSave = Boolean(api.saveDraft) && mode === 'generate' && result?.status === 'answered';
+
+  return (
+    <div className={cn.root}>
+      <section className={cn.section}>
+        <div className="flex gap-2" role="tablist" aria-label="Ask or generate">
+          {(['ask', 'generate'] as const).map((value) => (
+            <button
+              key={value}
+              type="button"
+              role="tab"
+              aria-selected={mode === value}
+              className={mode === value ? cn.button : cn.secondaryButton}
+              onClick={() => { setMode(value); setResult(null); setError(''); }}
+            >
+              {MODE_LABELS[value].tab}
+            </button>
+          ))}
+        </div>
+
+        <form
+          className="space-y-2"
+          onSubmit={(event) => { event.preventDefault(); void submit(); }}
+        >
+          <label className="block space-y-1">
+            <span className="text-sm font-medium text-gray-900">{MODE_LABELS[mode].prompt}</span>
+            <textarea
+              className={cn.textarea}
+              rows={3}
+              value={question}
+              placeholder={MODE_LABELS[mode].placeholder}
+              onChange={(event) => setQuestion(event.target.value)}
+            />
+          </label>
+
+          {mode === 'generate' ? (
+            <label className="block space-y-1">
+              <span className="text-sm font-medium text-gray-900">Tone or format (optional)</span>
+              <input
+                className={cn.input}
+                value={instructions}
+                placeholder="Formal letter, one page, ready to sign"
+                onChange={(event) => setInstructions(event.target.value)}
+              />
+            </label>
+          ) : null}
+
+          <button type="submit" className={cn.button} disabled={busy || !question.trim()}>
+            {busy ? 'Reading your records…' : MODE_LABELS[mode].action}
+          </button>
+        </form>
+
+        {error ? <p className={cn.error} role="alert">{error}</p> : null}
+      </section>
+
+      {result ? (
+        <AnswerPanel
+          result={result}
+          classNames={cn}
+          onOpenDocument={onOpenDocument}
+          canSave={canSave}
+          saveState={saveState}
+          onSave={async () => {
+            if (!api.saveDraft || !result) return;
+            setSaveState('saving');
+            try {
+              await api.saveDraft({
+                title: question.trim().slice(0, 120) || 'Generated draft',
+                body: result.answer,
+                citations: result.citations.map((citation) => citation.documentId),
+                scope,
+              });
+              setSaveState('saved');
+            } catch (err) {
+              setSaveState('idle');
+              setError(failureMessage(err));
+            }
+          }}
+        />
+      ) : null}
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+
+function AnswerPanel({
+  result, classNames: cn, onOpenDocument, canSave, saveState, onSave,
+}: {
+  result: AskResult;
+  classNames: Record<AskSlot, string>;
+  onOpenDocument?: (documentId: string) => void;
+  canSave: boolean;
+  saveState: 'idle' | 'saving' | 'saved';
+  onSave: () => void;
+}) {
+  const unhealthy = (result.freshness ?? []).filter((source) => source.status !== 'ok');
+
+  if (result.status === 'no_evidence') {
+    return (
+      <section className={cn.card} aria-label="Answer">
+        <h2 className={cn.heading}>No answer from your records</h2>
+        {/* The correct outcome of a cross-workspace question. Saying "nothing"
+            is the whole point: the alternative is someone else's documents. */}
+        <p className="mt-2 text-sm text-gray-700">{result.answer}</p>
+        <ProvenanceFooter result={result} classNames={cn} />
+      </section>
+    );
+  }
+
+  return (
+    <section className={cn.card} aria-label="Answer">
+      {result.status === 'uncited' ? (
+        <p className={cn.warning} role="alert">
+          This answer could not be traced to any of your records, so it is shown as unsourced.
+          Do not rely on it for anything you would sign.
+        </p>
+      ) : null}
+
+      {unhealthy.length ? (
+        <p className={cn.warning} role="status">
+          Answered from a corpus that is not fully current:{' '}
+          {unhealthy.map((source) => `${source.label} (${source.status})`).join(', ')}.
+        </p>
+      ) : null}
+
+      <div className={`mt-3 ${cn.answer}`}>{result.answer}</div>
+
+      {canSave ? (
+        <button
+          type="button"
+          className={`mt-3 ${cn.button}`}
+          disabled={saveState !== 'idle'}
+          onClick={onSave}
+        >
+          {/* Saving the draft back makes it part of the corpus next time — the
+              output of the system is also an input to it. */}
+          {saveState === 'saved' ? 'Saved to your library' : saveState === 'saving' ? 'Saving…' : 'Save to library'}
+        </button>
+      ) : null}
+
+      <div className="mt-4 space-y-2">
+        <h3 className="text-sm font-medium text-gray-900">
+          {result.citations.length} source{result.citations.length === 1 ? '' : 's'}
+        </h3>
+        {result.citations.map((citation) => (
+          <div key={citation.documentId} className="border-t pt-2">
+            <div className="flex flex-wrap items-center gap-2">
+              <span className={cn.badge}>
+                {citation.document.sourceLabel || citation.document.source}
+              </span>
+              <button
+                type="button"
+                className="text-sm font-medium text-blue-700 underline"
+                onClick={() => onOpenDocument?.(citation.documentId)}
+              >
+                {citation.document.title}
+              </button>
+              <span className={cn.muted}>
+                {citation.document.occurredAt
+                  ? new Date(citation.document.occurredAt).toLocaleDateString()
+                  : 'No date'}
+              </span>
+            </div>
+            {/* The model's own quote, so the claim can be checked against the
+                record without opening it. */}
+            {citation.quote ? (
+              <p className="mt-1 text-sm italic text-gray-600">“{citation.quote}”</p>
+            ) : null}
+          </div>
+        ))}
+      </div>
+
+      {result.unresolvedCitations.length ? (
+        <p className={`mt-3 ${cn.warning}`} role="alert">
+          The model also cited {result.unresolvedCitations.length} record
+          {result.unresolvedCitations.length === 1 ? '' : 's'} that were never given to it
+          ({result.unresolvedCitations.join(', ')}). Those were discarded — treat the answer with care.
+        </p>
+      ) : null}
+
+      <ConsideredList result={result} classNames={cn} onOpenDocument={onOpenDocument} />
+      <ProvenanceFooter result={result} classNames={cn} />
+    </section>
+  );
+}
+
+/**
+ * Everything retrieval offered the model, cited or not — so "why did it not use
+ * the contract?" is answerable without reading a log.
+ */
+function ConsideredList({
+  result, classNames: cn, onOpenDocument,
+}: {
+  result: AskResult;
+  classNames: Record<AskSlot, string>;
+  onOpenDocument?: (documentId: string) => void;
+}) {
+  const cited = new Set(result.citations.map((citation) => citation.documentId));
+  const unused = result.considered.filter((item) => !cited.has(item.document.id));
+  if (unused.length === 0) return null;
+  return (
+    <details className="mt-3">
+      <summary className="cursor-pointer text-sm text-gray-600">
+        {unused.length} more record{unused.length === 1 ? '' : 's'} were searched but not cited
+      </summary>
+      <div className="mt-2 space-y-1">
+        {unused.map((item) => (
+          <div key={item.document.id} className="flex flex-wrap items-center gap-2">
+            <span className={cn.badge}>{item.document.sourceLabel || item.document.source}</span>
+            <button
+              type="button"
+              className="text-sm text-blue-700 underline"
+              onClick={() => onOpenDocument?.(item.document.id)}
+            >
+              {item.document.title}
+            </button>
+            {item.matchedTerms.length ? (
+              <span className={cn.muted}>matched: {item.matchedTerms.join(', ')}</span>
+            ) : null}
+          </div>
+        ))}
+      </div>
+    </details>
+  );
+}
+
+function ProvenanceFooter({
+  result, classNames: cn,
+}: { result: AskResult; classNames: Record<AskSlot, string> }) {
+  return (
+    <div className="mt-4 border-t pt-2">
+      <p className={cn.muted}>
+        {result.provider.live
+          ? `Answered by ${result.provider.provider} · ${result.provider.model}`
+          : `Answered by a ${result.provider.provider} stub (${result.provider.model}) — no live model was called`}
+      </p>
+      {/* A non-zero drop means something upstream returned rows from another
+          workspace. It is stated rather than swallowed, because the guard
+          catching it is good news about the guard and bad news about the API. */}
+      {result.droppedOutOfScope > 0 ? (
+        <p className={cn.error} role="status">
+          {result.droppedOutOfScope} record{result.droppedOutOfScope === 1 ? '' : 's'} from another
+          workspace were returned by the data API and excluded before answering.
+        </p>
+      ) : null}
+    </div>
+  );
+}