@startsimpli/integrations 0.2.13 → 0.2.16

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

@@ -0,0 +1,476 @@
+/**
+ * TRANSCRIPT-BACKED EXTRACTION (bd startsim-768w.38.31).
+ *
+ * THE MEASUREMENT THAT PRODUCED THIS FILE. Extraction recall on the live tandem
+ * tenant is capped around 60%, and it is not the extractor's fault: every one of
+ * the sixteen real `source_document` rows carries a `summary` and NOTHING else —
+ * 54,534 characters of Granola's own AI summary, zero characters of body. The
+ * commitments the evaluation scores as "missed" were discarded by the summariser
+ * before this package ever saw the record. No prompt recovers text that was
+ * never fetched.
+ *
+ * The transcript is at the vendor and the connector already knows how to ask for
+ * it (`GET /v1/notes/{id}?include=transcript`, gated on
+ * `SourceInstance.config["ingest_transcripts"]`, default false by the Q4 privacy
+ * posture). This file is the DOWNSTREAM half: everything that has to be true
+ * before that flag is worth flipping.
+ *
+ * WHAT IT PINS, in the order the pipeline runs:
+ *
+ *  1. THE SUMMARY SURVIVES THE TRANSCRIPT. The canonical schema declares
+ *     `summary` and `body` as two attributes precisely so "the transcript
+ *     clobbers the summary the first time both arrive" cannot happen — and the
+ *     mapper collapsed them anyway. That single `pick()` would have deleted the
+ *     95.8%-precision rules pass on the day transcripts were switched on.
+ *  2. THE MODEL PASS ACTUALLY READS THE VERBATIM TEXT, and is told what the
+ *     rules pass already found so it reports only the remainder.
+ *  3. TRIMMING KEEPS THE END OF THE MEETING. Commitments are made in the last
+ *     five minutes; a head-first truncation deletes exactly the half worth
+ *     reading.
+ *  4. VERIFICATION. More text raises recall and drops precision — measured, 65.9%
+ *     recall at 67.5% precision on summaries alone, and a transcript is ten times
+ *     the text. Every model candidate has to be confirmed against the source with
+ *     a supporting quote, in ONE batched call, and anything unconfirmed is
+ *     dropped rather than shipped to someone's to-do list.
+ */
+import { describe, expect, it, vi } from 'vitest';
+
+import { toSourceDocument } from '../corpus/entities';
+import type { TenantEntity } from '../corpus/entities';
+import { documentText, extractCommitments, rulesExtract } from '../corpus/extract';
+import type {
+  CommitmentDraft,
+  CorpusExtractorLlm,
+  CorpusScope,
+  ExtractionDraft,
+  SourceDocument,
+  VerificationRequest,
+} from '../corpus/types';
+
+const SCOPE: CorpusScope = { orgId: 'tandem' };
+
+/**
+ * The summariser's own output, in the shape all sixteen real records have: `##`
+ * headings per topic, the last of them an outcome block of bolded imperatives
+ * with the owner in parentheses.
+ */
+const SUMMARY = [
+  '## Discussion',
+  'We went through the Rexford paperwork and the parking lot quote.',
+  '',
+  '## Next Steps',
+  '- **Send the signed Rexford lease to Michelle** (Kate)',
+  '- **Get a second quote for the Hadley lot** (Jonathan)',
+].join('\n');
+
+/**
+ * The same meeting as the vendor's ASR heard it. Two commitments in here never
+ * reached the summary — which is the entire finding this file exists for.
+ */
+const TRANSCRIPT = [
+  'Jonathan: Alright, Rexford. Kate, the lease came back signed this morning.',
+  'Kate: I saw it. I will send it over to Michelle today so she can file it.',
+  'Jonathan: Good. On the Hadley lot, the number they gave us is high.',
+  'Kate: Get a second quote before you agree to anything.',
+  'Jonathan: I will. Separately — I still owe Rae the insurance certificate for the Lamar building.',
+  'Kate: Right, and somebody has to cancel the old Pigoso QuickBooks seat before we get billed again.',
+  'Jonathan: I will take the certificate. Put the QuickBooks seat on Megan.',
+].join('\n');
+
+/** The raw tenant row exactly as the corpus delivery writes it. */
+function row(data: Record<string, unknown>): TenantEntity {
+  return {
+    id: 'doc_rexford',
+    entity_type: 'source_document',
+    external_id: 'granola:not_6IARYTobc9AwLI',
+    name: 'Rexford paperwork and Hadley parking lot',
+    data: {
+      subtype: 'meeting',
+      title: 'Rexford paperwork and Hadley parking lot',
+      source: 'granola',
+      source_ref: 'not_6IARYTobc9AwLI',
+      occurred_at: '2026-08-05T15:00:00Z',
+      ...data,
+    },
+    created_at: '2026-08-05T16:00:00Z',
+    org_id: 'tandem',
+  };
+}
+
+const summaryOnly = () => toSourceDocument(row({ summary: SUMMARY }), SCOPE);
+/**
+ * WHAT THE CONNECTOR REALLY WRITES once `ingest_transcripts` is on: the
+ * `meeting_transcript` record `merge_into`s the note's own document and fills the
+ * canonical `body` attribute with the verbatim text
+ * (`granola.declare_canonical()`), alongside the `summary` that was already
+ * there. Not a `transcript` key — the fixture corpus used one of those, which is
+ * exactly why no existing test caught the collapse below.
+ */
+const withTranscript = () => toSourceDocument(row({ summary: SUMMARY, body: TRANSCRIPT }), SCOPE);
+
+describe('a transcript must not delete the summary', () => {
+  it('keeps the summary as its own field when the verbatim body arrives', () => {
+    const document = withTranscript();
+    expect(document.summary).toContain('## Next Steps');
+    expect(document.body).toContain('Jonathan: Alright, Rexford');
+  });
+
+  it('still parses the vendor outcome block when a transcript is present', () => {
+    // THE REGRESSION THIS FILE WAS WRITTEN FOR. `pick(data,'body',...,'summary')`
+    // returns the FIRST present key, so a document carrying both returned only
+    // the transcript, `outcomeSections` found no `## Next Steps` in it, and the
+    // rules pass — 95.8% precision, 100% owner accuracy — produced zero.
+    const before = rulesExtract(summaryOnly());
+    const after = rulesExtract(withTranscript());
+    expect(before).toHaveLength(2);
+    expect(after.map((draft) => draft.title)).toEqual(before.map((draft) => draft.title));
+    expect(after.map((draft) => draft.ownerName)).toEqual(['Kate', 'Jonathan']);
+  });
+
+  it('reads the summary on a corpus that has no body at all', () => {
+    // Every row on the live tenant today. `body` has to keep answering for the
+    // summary or every existing consumer of it goes blank on the same deploy.
+    const document = summaryOnly();
+    expect(document.body).toContain('## Next Steps');
+    expect(document.summary).toContain('## Next Steps');
+  });
+});
+
+describe('the text handed to the model', () => {
+  it('carries the verbatim transcript, not just the summary', () => {
+    const text = documentText(withTranscript(), 12_000);
+    expect(text).toContain('## Next Steps');
+    expect(text).toContain('insurance certificate for the Lamar building');
+  });
+
+  it('does not repeat the summary twice when body fell back to it', () => {
+    const text = documentText(summaryOnly(), 12_000);
+    expect(text.match(/## Next Steps/g)).toHaveLength(1);
+  });
+
+  it('keeps the END of a long transcript, where the commitments are', () => {
+    // A head-first `slice(0, maxChars)` deletes the last five minutes of the
+    // meeting, which is the only part where anyone says who is doing what.
+    const filler = Array.from({ length: 400 }, (_, index) => `Speaker: filler line ${index}`).join('\n');
+    const long = toSourceDocument(row({ summary: SUMMARY, body: `${filler}\n${TRANSCRIPT}` }), SCOPE);
+    const text = documentText(long, 4_000);
+    expect(text.length).toBeLessThanOrEqual(6_000);
+    // The summary is small and structured: it is never the thing that gets cut.
+    expect(text).toContain('## Next Steps');
+    expect(text).toContain('Put the QuickBooks seat on Megan');
+  });
+});
+
+// ---------------------------------------------------------------------------
+//  verification
+// ---------------------------------------------------------------------------
+
+interface StubOptions {
+  items?: ExtractionDraft['items'];
+  verdicts?: Array<{ id: string; confirmed: boolean; quote?: string }>;
+  onVerify?: (input: VerificationRequest) => void;
+  verifyThrows?: boolean;
+  omitVerify?: boolean;
+}
+
+function stubExtractor(options: StubOptions = {}): CorpusExtractorLlm {
+  const verify = async (input: VerificationRequest) => {
+    options.onVerify?.(input);
+    if (options.verifyThrows) throw new Error('provider unreachable');
+    return {
+      verdicts: (options.verdicts ?? input.candidates.map((candidate) => ({
+        id: candidate.id,
+        confirmed: true,
+        quote: candidate.quote,
+      }))),
+    };
+  };
+  return {
+    async extract() {
+      return { items: options.items ?? [], resolutions: [] };
+    },
+    ...(options.omitVerify ? {} : { verify }),
+    describe: () => ({ provider: 'anthropic', model: 'claude-sonnet-5', live: true }),
+  };
+}
+
+/** A corpus of exactly one document, with a capture of what got written. */
+function stubCorpus(document: SourceDocument, saved: CommitmentDraft[][] = []) {
+  return {
+    listDocuments: async () => ({ count: 1, next: null, previous: null, results: [document] }),
+    getDocument: async () => document,
+    listParties: async () => ({ count: 0, next: null, previous: null, results: [] }),
+    listSources: async () => [],
+    listCommitments: async () => ({ count: 0, next: null, previous: null, results: [] }),
+    saveCommitments: async (commitments: unknown[]) => {
+      saved.push(commitments as CommitmentDraft[]);
+    },
+  };
+}
+
+const modelItem = (title: string, quote: string) => ({
+  documentId: 'doc_rexford',
+  subtype: 'action',
+  title,
+  detail: '',
+  status: 'open',
+  quote,
+});
+
+describe('the verification pass', () => {
+  it('drops a candidate the verifier refuses to confirm', async () => {
+    const document = withTranscript();
+    const saved: CommitmentDraft[][] = [];
+    const result = await extractCommitments(
+      { scope: SCOPE },
+      {
+        corpus: stubCorpus(document, saved),
+        extractor: stubExtractor({
+          items: [
+            modelItem('Send Rae the Lamar insurance certificate', 'I still owe Rae the insurance certificate'),
+            modelItem('Buy the Hadley lot outright this quarter', 'the number they gave us is high'),
+          ],
+          verdicts: [
+            { id: 'c1', confirmed: true, quote: 'I still owe Rae the insurance certificate' },
+            { id: 'c2', confirmed: false },
+          ],
+        }),
+      },
+    );
+    expect(result.fromModel).toBe(1);
+    expect(result.unconfirmed).toBe(1);
+    expect(result.verified).toBe(true);
+    const titles = saved.flat().map((item) => (item as unknown as { title: string }).title);
+    expect(titles).toContain('Send Rae the Lamar insurance certificate');
+    expect(titles).not.toContain('Buy the Hadley lot outright this quarter');
+  });
+
+  it('drops a candidate whose quote is not in the source, with no model call at all', async () => {
+    // The free half of verification. A quote that does not appear in the record
+    // is the signature of an invented commitment, and catching it costs nothing.
+    const document = withTranscript();
+    const result = await extractCommitments(
+      { scope: SCOPE },
+      {
+        corpus: stubCorpus(document),
+        extractor: stubExtractor({
+          items: [modelItem('Wire the deposit to the title company', 'Kate confirmed the wire went out')],
+        }),
+      },
+    );
+    expect(result.fromModel).toBe(0);
+    expect(result.ungrounded).toBe(1);
+  });
+
+  it('verifies every candidate in ONE call, with echoed ids', async () => {
+    const document = withTranscript();
+    const calls: VerificationRequest[] = [];
+    await extractCommitments(
+      { scope: SCOPE },
+      {
+        corpus: stubCorpus(document),
+        extractor: stubExtractor({
+          items: [
+            modelItem('Send Rae the Lamar insurance certificate', 'I still owe Rae the insurance certificate'),
+            modelItem('Cancel the old Pigoso QuickBooks seat', 'cancel the old Pigoso QuickBooks seat'),
+          ],
+          onVerify: (input) => calls.push(input),
+        }),
+      },
+    );
+    expect(calls).toHaveLength(1);
+    expect(calls[0].candidates).toHaveLength(2);
+    expect(new Set(calls[0].candidates.map((candidate) => candidate.id)).size).toBe(2);
+  });
+
+  it('never spends a verification call on the rules pass', async () => {
+    // The rules pass quotes the vendor's own bullet verbatim. Paying a model to
+    // confirm a deterministic transcription of a line we can print is money for
+    // a chance to lose a correct item.
+    const document = withTranscript();
+    const calls: VerificationRequest[] = [];
+    await extractCommitments(
+      { scope: SCOPE },
+      { corpus: stubCorpus(document), extractor: stubExtractor({ onVerify: (input) => calls.push(input) }) },
+    );
+    expect(calls).toHaveLength(0);
+  });
+
+  it('drops the model half rather than shipping it unverified when the verifier fails', async () => {
+    const document = withTranscript();
+    const result = await extractCommitments(
+      { scope: SCOPE },
+      {
+        corpus: stubCorpus(document),
+        extractor: stubExtractor({
+          items: [modelItem('Send Rae the Lamar insurance certificate', 'I still owe Rae the insurance certificate')],
+          verifyThrows: true,
+        }),
+      },
+    );
+    expect(result.fromModel).toBe(0);
+    expect(result.verified).toBe(false);
+    // The deterministic half is untouched by a provider outage, one level up
+    // from `extract` being wrapped for the same reason.
+    expect(result.fromRules).toBe(2);
+    expect(result.created).toBe(2);
+  });
+
+  it('says so rather than claiming verification when the extractor cannot verify', async () => {
+    const document = withTranscript();
+    const result = await extractCommitments(
+      { scope: SCOPE },
+      {
+        corpus: stubCorpus(document),
+        extractor: stubExtractor({
+          omitVerify: true,
+          items: [modelItem('Send Rae the Lamar insurance certificate', 'I still owe Rae the insurance certificate')],
+        }),
+      },
+    );
+    expect(result.verified).toBe(false);
+    // Grounded, so it is not invented — but nothing confirmed it is a commitment.
+    expect(result.fromModel).toBe(1);
+  });
+});
+
+describe('the two passes have different jobs', () => {
+  it('tells the model what the rules pass already found, per document', async () => {
+    const document = withTranscript();
+    const seen: string[][] = [];
+    const extractor: CorpusExtractorLlm = {
+      async extract(input) {
+        seen.push(input.documents[0].alreadyFound);
+        return { items: [], resolutions: [] };
+      },
+      describe: () => ({ provider: 'anthropic', model: 'claude-sonnet-5', live: true }),
+    };
+    await extractCommitments({ scope: SCOPE }, { corpus: stubCorpus(document), extractor });
+    expect(seen[0]).toEqual([
+      'Send the signed Rexford lease to Michelle',
+      'Get a second quote for the Hadley lot',
+    ]);
+  });
+
+  it('sends the transcript to the model, not the summary the rules pass already read', async () => {
+    const document = withTranscript();
+    const texts: string[] = [];
+    const extractor: CorpusExtractorLlm = {
+      async extract(input) {
+        texts.push(input.documents[0].text);
+        return { items: [], resolutions: [] };
+      },
+      describe: () => ({ provider: 'anthropic', model: 'claude-sonnet-5', live: true }),
+    };
+    await extractCommitments({ scope: SCOPE }, { corpus: stubCorpus(document), extractor });
+    expect(texts[0]).toContain('Put the QuickBooks seat on Megan');
+  });
+
+  it('does not regress the rules pass when there is no transcript', async () => {
+    const document = summaryOnly();
+    const result = await extractCommitments(
+      { scope: SCOPE },
+      { corpus: stubCorpus(document), extractor: stubExtractor() },
+    );
+    expect(result.fromRules).toBe(2);
+    expect(result.created).toBe(2);
+  });
+});
+
+describe('one run stays inside a request', () => {
+  it('processes fewer documents per call when they carry transcripts', async () => {
+    // bd startsim-768w.38.28: the tenant gateway closes a request at 60 seconds
+    // and a transcript is roughly ten times the text of a summary. A fixed
+    // document count per call is the wrong axis; a TEXT budget is the right one.
+    const long = (id: string) =>
+      toSourceDocument(
+        { ...row({ summary: SUMMARY, body: TRANSCRIPT.repeat(60) }), id },
+        SCOPE,
+      );
+    const documents = ['d1', 'd2', 'd3', 'd4'].map(long);
+    const seen: number[] = [];
+    const extractor: CorpusExtractorLlm = {
+      async extract(input) {
+        seen.push(input.documents.length);
+        return { items: [], resolutions: [] };
+      },
+      describe: () => ({ provider: 'anthropic', model: 'claude-sonnet-5', live: true }),
+    };
+    const result = await extractCommitments(
+      { scope: SCOPE },
+      {
+        corpus: {
+          ...stubCorpus(documents[0]),
+          listDocuments: async () => ({ count: 4, next: null, previous: null, results: documents }),
+        },
+        extractor,
+      },
+      { maxCharsPerRun: 20_000 },
+    );
+    expect(seen).toHaveLength(1);
+    expect(seen[0]).toBeLessThan(4);
+    // And it SAYS it did not finish, so the caller resumes rather than believing
+    // a partial sweep was the whole corpus.
+    expect(result.nextOffset).not.toBeNull();
+    expect(result.totalDocuments).toBe(4);
+  });
+
+  it('still does the whole corpus in one call when the documents are summaries', async () => {
+    const documents = ['d1', 'd2', 'd3', 'd4'].map((id) =>
+      toSourceDocument({ ...row({ summary: SUMMARY }), id }, SCOPE),
+    );
+    const seen: number[] = [];
+    const extractor: CorpusExtractorLlm = {
+      async extract(input) {
+        seen.push(input.documents.length);
+        return { items: [], resolutions: [] };
+      },
+      describe: () => ({ provider: 'anthropic', model: 'claude-sonnet-5', live: true }),
+    };
+    const result = await extractCommitments(
+      { scope: SCOPE },
+      {
+        corpus: {
+          ...stubCorpus(documents[0]),
+          listDocuments: async () => ({ count: 4, next: null, previous: null, results: documents }),
+        },
+        extractor,
+      },
+    );
+    expect(seen).toEqual([4]);
+    expect(result.nextOffset).toBeNull();
+  });
+});
+
+describe('the extraction result reports the shape of the run', () => {
+  it('counts what each stage kept and dropped', async () => {
+    const document = withTranscript();
+    const result = await extractCommitments(
+      { scope: SCOPE },
+      {
+        corpus: stubCorpus(document),
+        extractor: stubExtractor({
+          items: [
+            modelItem('Send Rae the Lamar insurance certificate', 'I still owe Rae the insurance certificate'),
+            modelItem('Wire the deposit to the title company', 'a quote that is not in the record'),
+            modelItem('Cancel the old Pigoso QuickBooks seat', 'cancel the old Pigoso QuickBooks seat'),
+          ],
+          verdicts: [
+            { id: 'c1', confirmed: true },
+            { id: 'c3', confirmed: false },
+          ],
+        }),
+      },
+    );
+    expect(result.fromRules).toBe(2);
+    expect(result.fromModel).toBe(1);
+    expect(result.ungrounded).toBe(1);
+    expect(result.unconfirmed).toBe(1);
+    expect(result.verified).toBe(true);
+  });
+});
+
+/** Kept honest: nothing in this file may reach a real provider. */
+it('never constructs a provider client', () => {
+  expect(vi.isMockFunction(globalThis.fetch)).toBe(false);
+});

package/src/components/CredentialSchemaForm.tsx

@@ -23,9 +23,17 @@ import type { ConnectorFieldSpec, ConnectorSchemaLike } from './pages/types';
 export interface CredentialSchemaFormProps {
   /** The catalog's own schema, rendered in DECLARED ORDER. */
   fields: ConnectorFieldSpec[];
-  /** Current values, keyed by field key. Secrets are never read back from here. */
-  values: Record<string, string>;
-  onChange: (key: string, value: string) => void;
+  /**
+   * Current values, keyed by field key. Secrets are never read back from here.
+   *
+   * `unknown` and not `string`, because a config schema has booleans and numbers
+   * in it. This was `Record<string, string>` with a `string` `onChange`, which
+   * made it structurally impossible for the component to emit a JSON boolean —
+   * so a checkbox could only ever have produced the string "true"/"false", and
+   * `bool("false")` is `true`.
+   */
+  values: Record<string, unknown>;
+  onChange: (key: string, value: string | boolean) => void;
   /** Per-field messages. A `pattern` miss WARNS; only `required` blocks submit. */
   errors?: Record<string, string>;
   warnings?: Record<string, string>;
@@ -43,6 +51,32 @@ export interface CredentialSchemaFormProps {
 /** Field types this build renders natively. Anything else becomes text. */
 const NATIVE_TYPES = new Set(['text', 'url', 'email', 'number', 'select', 'textarea']);
 
+/**
+ * A boolean is a CHECKBOX, and this is not a cosmetic preference.
+ *
+ * `boolean` has been in the server's `FIELD_TYPES` since the field grammar was
+ * written, and this component has never rendered one — it fell through to a text
+ * input. The most consequential setting the platform has is Granola's
+ * `ingest_transcripts`, which decides whether verbatim recordings of people's
+ * conversations are stored, and in a text box the way you turn it off is to type
+ * the word "false" — which `bool()` reads as ON.
+ */
+const BOOLEAN_TYPES = new Set(['boolean', 'checkbox', 'bool']);
+
+export function isBoolean(spec: ConnectorFieldSpec): boolean {
+  return !isSecret(spec) && BOOLEAN_TYPES.has(String(spec.type || '').toLowerCase());
+}
+
+/** The spellings of "off" that can arrive from a stored config or a form. */
+export function asBoolean(value: unknown): boolean {
+  if (typeof value === 'string') {
+    return !['', '0', 'false', 'no', 'off', 'none', 'null', 'undefined'].includes(
+      value.trim().toLowerCase(),
+    );
+  }
+  return Boolean(value);
+}
+
 /**
  * Is this field a secret? `type: "secret"` is the server's spelling and
  * `write_only` is the flag it enforces alongside it; `secret: true` is accepted
@@ -91,9 +125,14 @@ export function CredentialSchemaForm({
         // a value for it somehow reached this component. A masked input holding
         // the real key is one devtools panel away from being the leak the whole
         // credential surface is built to prevent.
+        const stored = values[spec.key];
+        // The DECLARED DEFAULT fills an unset field, so an untouched form shows
+        // what will actually happen rather than an empty box the admin has to
+        // guess at. `??` and not `||`: a stored `false` or `0` is a value.
         const value = isSecret(spec)
-          ? (values[`${spec.key}__draft`] ?? '')
-          : (values[spec.key] ?? spec.default ?? '');
+          ? String(values[`${spec.key}__draft`] ?? '')
+          : String(stored ?? spec.default ?? '');
+        const checked = asBoolean(stored ?? spec.default ?? false);
         const error = errors[spec.key];
         const warning = warnings[spec.key];
 
@@ -104,7 +143,15 @@ export function CredentialSchemaForm({
               {spec.required ? <span aria-hidden="true"> *</span> : null}
             </label>
 
-            {type === 'select' ? (
+            {isBoolean(spec) ? (
+              <input
+                id={id}
+                type="checkbox"
+                checked={checked}
+                onChange={(e) => onChange(spec.key, e.target.checked)}
+                className={classNames.input ?? 'mt-1 h-4 w-4 rounded border-gray-300'}
+              />
+            ) : type === 'select' ? (
               <select
                 id={id}
                 value={value}
@@ -164,7 +211,7 @@ export function CredentialSchemaForm({
  */
 export function missingRequired(
   fields: ConnectorFieldSpec[],
-  values: Record<string, string>,
+  values: Record<string, unknown>,
 ): string[] {
   return fields
     .filter((spec) => spec.required)
@@ -175,7 +222,7 @@ export function missingRequired(
 /** Fields whose value does not match a declared `pattern`. WARNS, never blocks. */
 export function patternWarnings(
   fields: ConnectorFieldSpec[],
-  values: Record<string, string>,
+  values: Record<string, unknown>,
 ): Record<string, string> {
   const out: Record<string, string> = {};
   for (const spec of fields) {

package/src/components/pages/AskPage.tsx

@@ -260,6 +260,17 @@ function AnswerPanel({
         </p>
       ) : null}
 
+      {/* An answer built from a partly-withheld record has to say so
+          (bd startsim-768w.38.33) — otherwise "your corpus has nothing about
+          that" and "you were not shown the part that does" are the same
+          sentence, and the second one is the dangerous one to believe. */}
+      {result.withheldFields?.length ? (
+        <p className={cn.warning} role="status">
+          Some records were only partly shared with you ({result.withheldFields.join(', ')}),
+          so this answer may be incomplete.
+        </p>
+      ) : null}
+
       {/* A model asked for prose answers in Markdown. Rendering it as literal
           text puts "**$4,800**" on the screen, which reads as the product
           failing rather than as the model emphasising the number. */}