@startsimpli/integrations 0.2.13 → 0.2.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/integrations",
-  "version": "0.2.13",
+  "version": "0.2.16",
   "description": "Provider-agnostic types, API clients, hooks, and UI primitives for email + calendar integrations across StartSimpli apps.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -48,7 +48,7 @@
     "react-dom": "^19.0.0",
     "typescript": "^6.0.0",
     "vitest": "^3.0.0",
-    "@startsimpli/llm": "0.4.15"
+    "@startsimpli/llm": "0.4.16"
   },
   "scripts": {
     "type-check": "tsc --noEmit",

package/src/__tests__/connections.test.tsx

@@ -627,3 +627,168 @@ describe('no per-vendor components', () => {
     expect(offenders).toEqual([]);
   });
 });
+
+// --------------------------------------------------------------------------
+//  settings on a CONNECTED card (bd startsim-768w.38.31)
+// --------------------------------------------------------------------------
+//
+// A connector's `config_schema` has always shipped on every catalog row and has
+// always been rendered — but only on the CONNECT form, once, before the account
+// exists. After that there was no way to change a setting from the product at
+// all. `ReplaceKeyForm` even says so, pointing at "the connection's own
+// settings" as though that surface existed.
+//
+// It has to exist for `ingest_transcripts`, because the whole privacy posture is
+// that transcripts are off until an admin deliberately turns them on — and a
+// switch nobody can reach is not a decision anybody gets to make.
+
+/** The Granola shape: a boolean, a number and a free-text list. */
+const TRANSCRIPT_CONFIG = [
+  {
+    key: 'ingest_transcripts',
+    label: 'Store what was said, not just the summary',
+    type: 'boolean',
+    required: false,
+    default: false,
+    help: 'On: the full word-for-word transcript is stored too.',
+  },
+  {
+    key: 'transcript_retention_days',
+    label: 'Delete stored transcripts after (days)',
+    type: 'number',
+    required: false,
+    default: 90,
+  },
+];
+
+const CONFIGURABLE_CATALOG = {
+  results: [
+    {
+      ...CATALOG.results[0],
+      config_schema: { version: 1, fields: TRANSCRIPT_CONFIG },
+    },
+  ],
+};
+
+function configurableApi(overrides: Partial<ConnectionsApi> = {}): ConnectionsApi {
+  return stubApi({
+    connectorCatalog: vi.fn().mockResolvedValue(CONFIGURABLE_CATALOG),
+    connections: vi.fn().mockResolvedValue({
+      ...CONNECTED,
+      results: [{ ...CONNECTED.results[0], config: { transcript_retention_days: 90 } }],
+    }),
+    ...overrides,
+  });
+}
+
+async function openSettings(api: ConnectionsApi) {
+  render(<ConnectionsPage api={api} foundrySlug="acme" />);
+  const card = await screen.findByText('Ops n8n');
+  const section = card.closest('div[data-connection]') ?? card.parentElement!;
+  await userEvent.click(await within(section as HTMLElement).findByRole('button', { name: /Settings/i }));
+  return section as HTMLElement;
+}
+
+describe('CredentialSchemaForm — a boolean is a checkbox', () => {
+  it('renders a declared boolean as a checkbox, not a text box', () => {
+    // `bool("false")` is `True`. A privacy switch rendered as somewhere to type
+    // the word "false" is a switch that is on when the admin believes it is off.
+    renderForm(TRANSCRIPT_CONFIG);
+    const input = screen.getByLabelText(/Store what was said/i);
+    expect(input).toHaveAttribute('type', 'checkbox');
+  });
+
+  it('reports a boolean edit as a real boolean, not a string', () => {
+    const { onChange } = renderForm(TRANSCRIPT_CONFIG);
+    screen.getByLabelText(/Store what was said/i).click();
+    expect(onChange).toHaveBeenCalledWith('ingest_transcripts', true);
+  });
+
+  it('shows the declared default so an untouched field is not a guess', () => {
+    renderForm(TRANSCRIPT_CONFIG);
+    expect(screen.getByLabelText(/Store what was said/i)).not.toBeChecked();
+    expect(screen.getByLabelText(/Delete stored transcripts/i)).toHaveValue(90);
+  });
+
+  it('renders the help text, which is where the consequence is stated', () => {
+    renderForm(TRANSCRIPT_CONFIG);
+    expect(screen.getByText(/word-for-word transcript is stored/i)).toBeInTheDocument();
+  });
+});
+
+describe('ConnectionCard — a connected account has settings', () => {
+  it('renders the connector’s config schema for an existing connection', async () => {
+    const section = await openSettings(configurableApi());
+    expect(within(section).getByLabelText(/Store what was said/i)).toBeInTheDocument();
+    // The STORED value, not the declared default — a form that shows the default
+    // over a stored setting tells the admin their last change did not take.
+    expect(within(section).getByLabelText(/Delete stored transcripts/i)).toHaveValue(90);
+  });
+
+  it('does not offer settings for a connector that declares none', async () => {
+    render(<ConnectionsPage api={stubApi()} foundrySlug="acme" />);
+    const card = await screen.findByText('Ops n8n');
+    const section = (card.closest('div[data-connection]') ?? card.parentElement!) as HTMLElement;
+    expect(within(section).queryByRole('button', { name: /Settings/i })).toBeNull();
+  });
+
+  it('saves through updateConnection, sending only the fields it changed', async () => {
+    const updateConnection = vi.fn().mockResolvedValue(CONNECTED.results[0]);
+    const section = await openSettings(configurableApi({ updateConnection }));
+
+    await userEvent.click(within(section).getByLabelText(/Store what was said/i));
+    await userEvent.click(within(section).getByRole('button', { name: /^Save settings$/i }));
+
+    await waitFor(() => expect(updateConnection).toHaveBeenCalled());
+    const [, , payload] = updateConnection.mock.calls[0];
+    expect(payload.config).toEqual({ ingest_transcripts: true });
+    // The API merges, so an untouched field must NOT be echoed back — resending
+    // it turns "I changed one thing" into "I reassert everything", and races an
+    // edit made in another tab.
+    expect(payload.config).not.toHaveProperty('transcript_retention_days');
+  });
+
+  it('sends false when a checkbox is turned OFF, rather than omitting it', async () => {
+    // The connect form drops falsy values (`if (v) config[k] = v`), which for a
+    // checkbox means "off" is indistinguishable from "untouched" — and with a
+    // merging API that makes the off position unreachable.
+    const updateConnection = vi.fn().mockResolvedValue(CONNECTED.results[0]);
+    const section = await openSettings(
+      configurableApi({
+        updateConnection,
+        connections: vi.fn().mockResolvedValue({
+          ...CONNECTED,
+          results: [{ ...CONNECTED.results[0], config: { ingest_transcripts: true } }],
+        }),
+      }),
+    );
+
+    await userEvent.click(within(section).getByLabelText(/Store what was said/i));
+    await userEvent.click(within(section).getByRole('button', { name: /^Save settings$/i }));
+
+    await waitFor(() => expect(updateConnection).toHaveBeenCalled());
+    expect(updateConnection.mock.calls[0][2].config).toEqual({ ingest_transcripts: false });
+  });
+
+  it('warns, before saving, what turning transcripts on will do', async () => {
+    const section = await openSettings(configurableApi());
+    await userEvent.click(within(section).getByLabelText(/Store what was said/i));
+    expect(
+      within(section).getByText(/word-for-word transcript is stored/i),
+    ).toBeInTheDocument();
+  });
+
+  it('surfaces the API’s refusal rather than looking saved', async () => {
+    // The connector refuses `transcript_retention_days: 0` with nobody's name
+    // against it. That 400 has to land on the form, next to the field.
+    const updateConnection = vi.fn().mockRejectedValue(
+      Object.assign(new Error('transcript_retention_days=0 means keeping verbatim meeting speech forever'), {
+        status: 400,
+      }),
+    );
+    const section = await openSettings(configurableApi({ updateConnection }));
+    await userEvent.click(within(section).getByLabelText(/Store what was said/i));
+    await userEvent.click(within(section).getByRole('button', { name: /^Save settings$/i }));
+    expect(await within(section).findByText(/keeping verbatim meeting speech forever/i)).toBeInTheDocument();
+  });
+});

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

@@ -89,7 +89,25 @@ describe('batching — N documents, ONE call', () => {
     };
     const text = documentText(long, 500);
     expect(text.length).toBeLessThan(700);
-    expect(text).toContain('[truncated]');
+    // The marker now names the size of the cut, because "…[truncated]" told a
+    // reader that something was missing without telling them whether it was a
+    // sentence or forty minutes.
+    expect(text).toMatch(/\[truncated \d+ characters\]/);
+  });
+
+  it('spends the budget on the summary before the transcript', () => {
+    // A prefix cut over `body` + sections is what this used to be, and once
+    // `ingest_transcripts` lands `body` IS the transcript — so the entire 6,000
+    // character per-document budget would have gone on the opening minutes of
+    // the meeting and the summary would never have reached the model at all.
+    const long = {
+      ...FIXTURE_DOCUMENTS[0],
+      summary: FIXTURE_DOCUMENTS[0].summary,
+      body: `${'x'.repeat(50_000)} the last thing anybody said`,
+    };
+    const text = documentText(long, 800);
+    expect(text).toContain('Agreed to ship the connector RED suite first');
+    expect(text).toContain('the last thing anybody said');
   });
 });
 

package/src/__tests__/corpus-copy.test.tsx

@@ -106,7 +106,10 @@ describe('Markdown is rendered, not printed', () => {
 describe('LibraryPage renders a document’s own Markdown', () => {
   it('shows the summary as prose, not as source', async () => {
     const user = userEvent.setup();
-    const document: SourceDocument = { ...FIXTURE_DOCUMENTS[0], body: MARKDOWN_BODY };
+    // The SUMMARY is the field rendered as prose under the heading "Summary".
+    // It used to be `body`, which was only ever the summary because nothing had
+    // delivered a full text yet.
+    const document: SourceDocument = { ...FIXTURE_DOCUMENTS[0], summary: MARKDOWN_BODY };
     const api = createFixtureCorpusApi({ scope: SCOPE, documents: [document], moneyEvents: [] });
     render(<LibraryPage api={api} scope={SCOPE} />);
 

package/src/__tests__/corpus-field-gate.test.ts

@@ -0,0 +1,246 @@
+/**
+ * THE FIELD READ GATE, from the client's side (bd startsim-768w.38.33).
+ *
+ * `corpus-scope.test.ts` next door asks "can the pipeline be made to read
+ * another WORKSPACE's records". This asks the narrower and, on the tandem
+ * tenant, more likely question: can it be made to read a part of its OWN
+ * workspace's record that the server withheld from this reader.
+ *
+ * SAME ADVERSARIAL POSTURE, DELIBERATELY. Every case runs against a tenant that
+ * is LEAKING — it names `body` in `redacted_fields` and then sends `body`
+ * anyway, which is what a half-rolled deploy, a response cached from an admin's
+ * session, or a serializer edited without its gate looks like from out here. If
+ * the pipeline is only safe because the server is, these fail. That is the
+ * point; a test against a correctly-behaving server proves the server, not the
+ * client.
+ *
+ * THE BAIT is `doc_checkin`: a document whose SUMMARY is anodyne and whose
+ * withheld `body` contains the verbatim sentence that answers the question best.
+ * A mapper that reads `data.body` without checking `redacted_fields` puts that
+ * sentence into the prompt, the model quotes it, and the leak arrives in the
+ * most convincing possible format — cited, fluent, and attributed to the user's
+ * own corpus.
+ */
+import { describe, expect, it } from 'vitest';
+
+import { askCorpus } from '../corpus/ask';
+import { createCorpusApi } from '../corpus/client';
+import { toSourceDocument, withheldFieldsOf } from '../corpus/entities';
+import type { TenantEntity } from '../corpus/entities';
+import { createFixtureCorpusHttp, createFixtureLlm, FIXTURE_ORG } from '../corpus/fixtures';
+import type { CorpusHttp, CorpusLlm, CorpusScope } from '../corpus/types';
+
+const SCOPE: CorpusScope = { orgId: FIXTURE_ORG };
+
+/** The sentence nobody consented to re-host in a third system. */
+const VERBATIM = 'Dana: I relapsed in March and I have been in therapy weekly since.';
+const ANODYNE = 'Personal check-in. Agreed to revisit the lease in Q3.';
+
+/**
+ * A tenant row as the LEAKING server sends it: the gate ran (it named what it
+ * withheld) and the payload came anyway.
+ */
+function leakingEntity(overrides: Partial<TenantEntity> = {}): TenantEntity {
+  return {
+    id: 'doc_checkin',
+    entity_type: 'source_document',
+    external_id: 'granola:not_checkin',
+    name: 'Personal check-in — therapy, substance use, and relationship progress',
+    org_id: FIXTURE_ORG,
+    created_at: '2026-08-01T10:00:00Z',
+    data: {
+      source: 'granola',
+      subtype: 'meeting',
+      title: 'Personal check-in',
+      summary: ANODYNE,
+      body: VERBATIM,
+      occurred_at: '2026-08-01T09:00:00Z',
+    },
+    redacted_fields: ['body'],
+    ...overrides,
+  };
+}
+
+/** The same row as a CORRECT server sends it: stripped, and saying so. */
+function gatedEntity(): TenantEntity {
+  const row = leakingEntity();
+  const { body: _dropped, ...rest } = row.data as Record<string, unknown>;
+  return { ...row, data: rest };
+}
+
+function httpFor(entities: TenantEntity[]): CorpusHttp {
+  return createFixtureCorpusHttp({ entities, relationships: [] }).http as CorpusHttp;
+}
+
+function apiFor(entities: TenantEntity[]) {
+  return createCorpusApi({ http: httpFor(entities), scope: SCOPE, supportedFilters: [] });
+}
+
+describe('the mapper honours the server’s own declaration', () => {
+  it('drops a withheld key even when the server sent it anyway', () => {
+    const document = toSourceDocument(leakingEntity(), SCOPE);
+    expect(document.body).not.toContain('relapsed');
+    expect(JSON.stringify(document)).not.toContain('relapsed');
+  });
+
+  it('falls back to the summary rather than rendering an empty record', () => {
+    // A blank document would be the other failure: safe, and useless. The
+    // meeting is still a meeting, and its summary was never restricted.
+    const document = toSourceDocument(leakingEntity(), SCOPE);
+    expect(document.body).toBe(ANODYNE);
+    expect(document.summary).toBe(ANODYNE);
+  });
+
+  it('says WHICH field was withheld, so absence is not mistaken for emptiness', () => {
+    // The distinction the whole gate turns on: "this meeting has no transcript"
+    // and "you were not shown this meeting's transcript" are different facts,
+    // and only one of them is an answer.
+    expect(toSourceDocument(leakingEntity(), SCOPE).withheldFields).toEqual(['body']);
+    expect(withheldFieldsOf(leakingEntity())).toEqual(['body']);
+  });
+
+  it('accepts the camelCase spelling the api client produces', () => {
+    const row = leakingEntity();
+    const camel: TenantEntity = { ...row, redacted_fields: undefined, redactedFields: ['body'] };
+    expect(toSourceDocument(camel, SCOPE).body).not.toContain('relapsed');
+  });
+
+  it('leaves a record with nothing withheld exactly as it was', () => {
+    // The migration property, from this side: a corpus with no policy anywhere
+    // must map identically to how it mapped before this existed.
+    const open = leakingEntity({ redacted_fields: undefined });
+    const document = toSourceDocument(open, SCOPE);
+    expect(document.body).toBe(VERBATIM);
+    expect(document.withheldFields).toBeUndefined();
+  });
+
+  it('withholds a section as readily as a top-level field', () => {
+    const row = leakingEntity({
+      data: {
+        source: 'granola',
+        summary: ANODYNE,
+        transcript: VERBATIM,
+      },
+      redacted_fields: ['transcript'],
+    });
+    const document = toSourceDocument(row, SCOPE);
+    expect(JSON.stringify(document.sections)).not.toContain('relapsed');
+  });
+});
+
+describe('the corpus client never surfaces a withheld field', () => {
+  it('keeps it out of a listed document', async () => {
+    const page = await apiFor([leakingEntity()]).listDocuments({ page: 1, pageSize: 50 });
+    expect(page.results).toHaveLength(1);
+    expect(JSON.stringify(page.results)).not.toContain('relapsed');
+    expect(page.results[0]?.withheldFields).toEqual(['body']);
+  });
+
+  it('keeps it out of a fetched document', async () => {
+    const document = await apiFor([leakingEntity()]).getDocument('doc_checkin');
+    expect(JSON.stringify(document)).not.toContain('relapsed');
+  });
+});
+
+describe('askCorpus — the withheld text 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(JSON.stringify(input.documents));
+          return inner.answer(input);
+        },
+      },
+    };
+  }
+
+  /**
+   * A question answerable from the SUMMARY, so the document really is retrieved
+   * and really does reach the prompt. Asking something only the withheld text
+   * could answer would prove nothing: an empty prompt keeps every secret.
+   */
+  const question = 'What did we agree about the lease?';
+
+  it('puts the document in the prompt WITHOUT the withheld text', async () => {
+    const { llm, seen } = spyLlm();
+    await askCorpus({ question, mode: 'ask', scope: SCOPE }, { corpus: apiFor([leakingEntity()]), llm });
+
+    expect(seen).toHaveLength(1); // ONE call, not one per document
+    expect(seen[0]).toContain('lease'); // the record DID reach the model...
+    expect(seen[0]).not.toContain('relapsed'); // ...without the part it may not read
+  });
+
+  it('never quotes it back in the answer or a citation', async () => {
+    const result = await askCorpus(
+      { question, mode: 'ask', scope: SCOPE },
+      { corpus: apiFor([leakingEntity()]), llm: createFixtureLlm() },
+    );
+
+    expect(result.status).toBe('answered');
+    expect(result.answer).not.toContain('relapsed');
+    expect(JSON.stringify(result.citations)).not.toContain('relapsed');
+  });
+
+  it('reports that something was withheld rather than absorbing it', async () => {
+    // Same contract as `droppedOutOfScope`: an answer built from a partial
+    // record has to say so. Otherwise "your corpus has nothing about that" and
+    // "you were not shown the part that does" are the same sentence.
+    const result = await askCorpus(
+      { question, mode: 'ask', scope: SCOPE },
+      { corpus: apiFor([leakingEntity()]), llm: createFixtureLlm() },
+    );
+    expect(result.withheldFields).toEqual(['body']);
+  });
+
+  it('tells the MODEL the record is partly withheld, so it cannot answer a confident no', async () => {
+    const { llm, seen } = spyLlm();
+    await askCorpus({ question, mode: 'ask', scope: SCOPE }, { corpus: apiFor([leakingEntity()]), llm });
+    expect(seen[0]).toContain('withheldFields');
+  });
+
+  it('does not retrieve on a term that exists ONLY in the withheld text', async () => {
+    // The client-side half of the search oracle the tenant API closes. If the
+    // withheld words were still rankable here, a reader could confirm what a
+    // transcript contains by watching which records come back — an answer about
+    // somebody's private speech, delivered without ever printing it.
+    const result = await askCorpus(
+      { question: 'relapsed', mode: 'ask', scope: SCOPE },
+      { corpus: apiFor([leakingEntity()]), llm: createFixtureLlm() },
+    );
+    expect(result.status).toBe('no_evidence');
+    expect(result.citations).toHaveLength(0);
+    expect(result.answer).not.toContain('relapsed');
+  });
+
+  it('answers identically whether the server leaked or behaved', async () => {
+    // The falsifiable version of "the client does not depend on the server
+    // getting it right": same question, one API stripping the field and one
+    // not, and the two answers must not differ.
+    const ask = (entity: TenantEntity) =>
+      askCorpus(
+        { question, mode: 'ask', scope: SCOPE },
+        { corpus: apiFor([entity]), llm: createFixtureLlm() },
+      );
+    const [leaked, gated] = await Promise.all([ask(leakingEntity()), ask(gatedEntity())]);
+    expect(leaked.answer).toBe(gated.answer);
+    expect(leaked.withheldFields).toEqual(gated.withheldFields);
+  });
+
+  it('still answers from the parts the reader IS allowed to see', async () => {
+    // Over-blocking would be the other way to fail: the summary was never
+    // restricted, and a corpus that goes silent because one field is gated has
+    // taken the product away in order to protect it.
+    const result = await askCorpus(
+      { question, mode: 'ask', scope: SCOPE },
+      { corpus: apiFor([leakingEntity()]), llm: createFixtureLlm() },
+    );
+    expect(result.status).toBe('answered');
+    expect(result.citations.length).toBeGreaterThan(0);
+    expect(result.answer).toContain('lease');
+  });
+});

package/src/__tests__/corpus-pages.test.tsx

@@ -107,7 +107,7 @@ describe('LibraryPage — the only connected source is Dropbox', () => {
 });
 
 describe('LibraryPage — the same screen, Granola only', () => {
-  it('renders long-form under Granola’s word for it, from the same code', async () => {
+  it('renders the verbatim text separately from the summary, collapsed', async () => {
     const user = userEvent.setup();
     const { api } = singleSourceCorpus('granola', {
       source: 'granola', label: 'Granola', documentCount: 4,
@@ -117,7 +117,16 @@ describe('LibraryPage — the same screen, Granola only', () => {
 
     await user.click(await screen.findByText('Acme <> StartSimpli weekly sync'));
     const detail = await screen.findByRole('region', { name: 'Record detail' });
-    expect(within(detail).getByText('Transcript')).toBeInTheDocument();
+    // "Full text" and not "Transcript", because the canonical mapping puts a
+    // meeting transcript in the SAME field a PDF's extracted text goes in — the
+    // corpus is source-agnostic and this screen must stay that way. A source
+    // that wants its own word for it contributes a named `section`, which the
+    // Dropbox row above proves still works.
+    expect(within(detail).getByText('Full text')).toBeInTheDocument();
+    // The summary is still the thing rendered as prose, and the verbatim text
+    // is behind a disclosure rather than in front of whoever opened the record.
+    expect(within(detail).getByText('Summary')).toBeInTheDocument();
+    expect(within(detail).getByText(/Agreed to ship the connector RED suite/)).toBeInTheDocument();
   });
 });
 
@@ -302,6 +311,53 @@ function askApiOver(api: CorpusApi, extra: Partial<CorpusAskApi> = {}): CorpusAs
   };
 }
 
+describe('a withheld field is SHOWN as withheld, not as empty', () => {
+  // bd startsim-768w.38.33. The tenant strips a restricted attribute and names
+  // it back; if the screen renders the gap silently, the reader concludes the
+  // meeting had no transcript — which is a stronger, and wrong, claim than the
+  // gate ever made.
+
+  it('LibraryPage names what was held back on the open record', async () => {
+    const withheld: SourceDocument = {
+      ...ownDocuments()[0],
+      id: 'doc_withheld',
+      title: 'Personal check-in',
+      withheldFields: ['body'],
+    };
+    const api = createFixtureCorpusApi({
+      scope: SCOPE, documents: [withheld], moneyEvents: [],
+    });
+    render(<LibraryPage api={api} scope={SCOPE} initialDocumentId="doc_withheld" />);
+
+    expect(await screen.findByText(/not shared with you/i)).toBeInTheDocument();
+    expect(screen.getByText(/body/)).toBeInTheDocument();
+  });
+
+  it('AskPage says the answer may be incomplete', async () => {
+    const user = userEvent.setup();
+    const api: CorpusAskApi = {
+      async ask() {
+        return {
+          status: 'answered',
+          answer: 'They agreed to revisit the lease in Q3.',
+          citations: [],
+          considered: [],
+          unresolvedCitations: [],
+          droppedOutOfScope: 0,
+          withheldFields: ['body'],
+          provider: { provider: 'fixture', model: 'fixture-echo', live: false },
+        };
+      },
+    };
+    render(<AskPage api={api} scope={SCOPE} />);
+    await user.type(screen.getByRole('textbox'), 'lease');
+    await user.click(screen.getByRole('button', { name: 'Ask' }));
+
+    const answer = await screen.findByRole('region', { name: 'Answer' });
+    expect(within(answer).getByText(/only partly shared with you/i)).toBeInTheDocument();
+  });
+});
+
 describe('AskPage — an answer is only an answer when it is traceable', () => {
   it('renders the answer with a citation per record, clickable through to it', async () => {
     const user = userEvent.setup();

package/src/__tests__/corpus-tracker.test.tsx

@@ -283,6 +283,9 @@ describe('TrackerPage — running the extraction', () => {
     nextOffset: null,
     fromRules: 24,
     fromModel: 11,
+    ungrounded: 2,
+    unconfirmed: 3,
+    verified: true,
     created: 30,
     merged: 5,
     resolved: 2,
@@ -333,3 +336,43 @@ describe('TrackerPage — running the extraction', () => {
     expect(screen.queryByRole('button', { name: 'Pull from meetings' })).not.toBeInTheDocument();
   });
 });
+
+// ---------------------------------------------------------------------------
+//  the run says what the verification threw away (bd startsim-768w.38.31)
+// ---------------------------------------------------------------------------
+
+describe('TrackerPage — the run reports its own precision work', () => {
+  const BASE = {
+    documentsProcessed: 16, totalDocuments: 16, nextOffset: null,
+    fromRules: 67, fromModel: 35, ungrounded: 2, unconfirmed: 59, verified: true,
+    created: 102, merged: 0, resolved: 0, needsReview: [], droppedOutOfScope: 0,
+    provider: { provider: 'anthropic', model: 'claude-sonnet-5', live: true },
+  };
+
+  async function runWith(result: Record<string, unknown>) {
+    const api = makeApi({ extract: vi.fn(async () => result) as never });
+    render(<TrackerPage api={api} scope={SCOPE} />);
+    await userEvent.click(await screen.findByRole('button', { name: /Pull from meetings/i }));
+    return screen;
+  }
+
+  it('says how many proposed items were dropped, and why', async () => {
+    // Measured over the sixteen real meetings, two thirds of what the model
+    // proposes does not survive the check. Hiding that would make the model look
+    // better than it is and the list less arguable than it should be.
+    await runWith(BASE);
+    expect(await screen.findByText(/61 more were proposed and dropped/)).toBeInTheDocument();
+    expect(screen.getByText(/2 quoted something the record does not say/)).toBeInTheDocument();
+    expect(screen.getByText(/59 could not be confirmed/)).toBeInTheDocument();
+  });
+
+  it('says the check did not run rather than implying it did', async () => {
+    await runWith({ ...BASE, verified: false, unconfirmed: 0, ungrounded: 0 });
+    expect(await screen.findByText(/were NOT checked against the meetings/)).toBeInTheDocument();
+  });
+
+  it('stays quiet when the model contributed nothing at all', async () => {
+    await runWith({ ...BASE, fromModel: 0, ungrounded: 0, unconfirmed: 0 });
+    expect(screen.queryByText(/proposed and dropped/)).toBeNull();
+  });
+});