@startsimpli/integrations 0.2.33 → 0.2.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/integrations",
-  "version": "0.2.33",
+  "version": "0.2.34",
   "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",

package/src/__tests__/connection-activity.test.tsx

@@ -0,0 +1,160 @@
+/**
+ * THE CONNECTION CARD SAYS WHY A RUN FAILED (bd startsim-ei8gm.2, part 2).
+ *
+ * `ConnectionRun.error_message` has been DECLARED in this package's own types
+ * for as long as the endpoint has existed, and no component in
+ * `packages/integrations` or `apps/foundry` has ever read it. `connectionRuns`
+ * is likewise required on both api interfaces and called by nothing. So the
+ * activity endpoint that `#375` just taught to answer a real reason for source
+ * runs has no reader at all: a failed run does not render as a status word — it
+ * does not render.
+ *
+ * ONE COMPOSER, TWO SURFACES. `ConnectionsPage` is mounted by the control plane
+ * (`apps/foundry`'s `<ConnectionsPage api={api.foundry} foundrySlug={slug} />`)
+ * and by a tenant member's own screen in `personal` mode. The disclosure is
+ * gated on the VERB EXISTING — the rule the file already applies to Workflows
+ * and Settings — so an app pinned to an older `@startsimpli/api` degrades to no
+ * control rather than to a button whose handler is `undefined`.
+ *
+ * NOTHING IS SCRUBBED HERE. The text arrives already redacted against that
+ * connection's stored credential plus the platform app_secret
+ * (`apps/connectors/services/surface.py::_reason_reader` ->
+ * `dispatch.redaction_list`), and a run whose reason could not be proven clean
+ * arrives as a sentence saying so. A second redaction path in the browser would
+ * be a second thing to get wrong, and the browser does not hold the secrets to
+ * do it with.
+ */
+import { describe, expect, it, vi } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+import { ConnectionsPage } from '../components/pages/ConnectionsPage';
+import type { ConnectionsApi, ConnectionRun } from '../components/pages/types';
+
+const CATALOG = {
+  results: [
+    {
+      key: 'granola', name: 'Granola', description: 'Meeting notes',
+      logo_url: '', docs_url: '', capabilities: ['poll'], auth_mode: 'api_key',
+      credential_schema: { version: 1, fields: [] },
+      config_schema: { version: 1, fields: [] },
+      record_types: [], supports_webhooks: false,
+      availability: { available: true, reason: '' },
+    },
+  ],
+};
+
+const CONNECTED = {
+  results: [
+    {
+      id: 'c1', public_id: 'pub1', name: 'Tandem Granola',
+      connector_key: 'granola', connector_name: 'Granola',
+      external_account_id: '', account_label: 'tandem',
+      capabilities_enabled: ['poll'], config: {}, status: 'connected',
+      health: 'ok', auth_mode: 'api_key',
+    },
+  ],
+  permissions: { view: true, manage: true, issue_tokens: true },
+};
+
+/** What production held, verbatim, for each of the twenty failed polls. */
+const THE_REAL_REASON =
+  'connector_granola poll failed on page 1: [config_error] the response '
+  + 'exceeded the 262144-byte cap and was aborted [granola]';
+
+const RUNS: ConnectionRun[] = [
+  {
+    id: 'r-new', kind: 'destination_run', object_id: 'd1', name: 'Corpus delivery',
+    status: 'completed', run_type: 'scheduled',
+    occurred_at: '2026-08-27T04:24:08Z', error_message: '',
+  },
+  {
+    id: 'r-old', kind: 'source_run', object_id: 's1', name: 'granola-poll',
+    status: 'failed', run_type: 'incremental',
+    occurred_at: '2026-08-12T20:21:46Z', error_message: THE_REAL_REASON,
+  },
+];
+
+function stubApi(overrides: Partial<ConnectionsApi> = {}): ConnectionsApi {
+  return {
+    connectorCatalog: vi.fn().mockResolvedValue(CATALOG),
+    connections: vi.fn().mockResolvedValue(CONNECTED),
+    connect: vi.fn(),
+    checkConnection: vi.fn().mockResolvedValue({ ok: true, account_label: '', detail: '' }),
+    disconnect: vi.fn(),
+    connectionChoices: vi.fn(),
+    wireTarget: vi.fn(),
+    confirmTarget: vi.fn(),
+    connectionActions: vi.fn(),
+    invokeConnectionAction: vi.fn(),
+    connectionRuns: vi.fn().mockResolvedValue({ results: RUNS }),
+    updateConnection: vi.fn(),
+    rotateCredential: vi.fn(),
+    ...overrides,
+  } as unknown as ConnectionsApi;
+}
+
+async function openActivity(api: ConnectionsApi = stubApi()) {
+  render(<ConnectionsPage api={api} foundrySlug="tandem" />);
+  const button = await screen.findByRole('button', { name: /activity/i });
+  await userEvent.click(button);
+  return api;
+}
+
+describe('ConnectionCard — recent activity', () => {
+  it('has a control at all, which is the whole of the gap', async () => {
+    render(<ConnectionsPage api={stubApi()} foundrySlug="tandem" />);
+
+    expect(await screen.findByRole('button', { name: /activity/i })).toBeInTheDocument();
+  });
+
+  it('reads the runs endpoint that nothing has ever called', async () => {
+    const api = await openActivity();
+
+    await waitFor(() => expect(api.connectionRuns).toHaveBeenCalledWith('tandem', 'c1'));
+  });
+
+  it('renders the reason a failed run gives, not only its status word', async () => {
+    await openActivity();
+
+    expect(await screen.findByText(/262144-byte cap/)).toBeInTheDocument();
+  });
+
+  it('names which leg the run belongs to, since the card merges three tables', async () => {
+    await openActivity();
+
+    const activity = await screen.findByRole('group', { name: /recent activity/i });
+    expect(activity).toHaveTextContent(/granola-poll/);
+    expect(activity).toHaveTextContent(/Corpus delivery/);
+  });
+
+  it('invents no reason for a run that succeeded', async () => {
+    await openActivity(stubApi({
+      connectionRuns: vi.fn().mockResolvedValue({ results: [RUNS[0]] }),
+    }) as ConnectionsApi);
+
+    const activity = await screen.findByRole('group', { name: /recent activity/i });
+    expect(activity).not.toHaveTextContent(/262144/);
+  });
+
+  it('says so when there is no activity, rather than rendering an empty box', async () => {
+    await openActivity(stubApi({
+      connectionRuns: vi.fn().mockResolvedValue({ results: [] }),
+    }) as ConnectionsApi);
+
+    const activity = await screen.findByRole('group', { name: /recent activity/i });
+    expect(activity).toHaveTextContent(/no runs yet/i);
+  });
+
+  it('offers no control when the client is too old to have the verb', async () => {
+    // Apps consume `@startsimpli/*` as PUBLISHED packages, so a client pinned
+    // to an older `@startsimpli/api` is a normal state of the world. The gate
+    // is the verb existing — the same rule Workflows and Settings use.
+    const api = stubApi();
+    delete (api as Partial<ConnectionsApi>).connectionRuns;
+    render(<ConnectionsPage api={api} foundrySlug="tandem" />);
+
+    await screen.findByText('Tandem Granola');
+    expect(screen.queryByRole('button', { name: /activity/i })).not.toBeInTheDocument();
+  });
+});

package/src/__tests__/library-failure-reason.test.tsx

@@ -0,0 +1,178 @@
+/**
+ * A CARD THAT COUNTS TWENTY FAILURES AND NAMES NONE (bd startsim-ei8gm.2).
+ *
+ * THE SIXTEEN DAYS. The Tandem Library's Granola card read *"Failing — 20 syncs
+ * in a row failed, synced 16d ago"* from 2026-08-12 to 2026-08-27 and nothing a
+ * human could open said why. It was our own 256 KiB egress cap: the per-note
+ * detail response peaked at 351 KB. Diagnosable in minutes by anyone who could
+ * read the error text; sixteen days for someone who could not.
+ *
+ * `#375` fixed the SERVER half. `SubtreeConnectionsView` now derives the newest
+ * failed run's reason and sends it as `last_error`, and `surface.recent_runs`
+ * answers a real `error_message` for source runs instead of the `""` that a
+ * `getattr` default had returned for every source run ever recorded. Both
+ * facts are on prod. Nothing renders either of them, which is this bead.
+ *
+ * WHY `check_error` COULD NEVER HAVE ANSWERED IT, which is what makes this a
+ * missing field rather than a missing render. `listSources` composes its
+ * `detail` from `check_error` alone, and `check_error` is empty BY
+ * CONSTRUCTION for this class of failure: `check()` and `poll()` are different
+ * requests. Granola's check asks for `page_size=1` and passes; its poll asks
+ * for thirty notes with transcripts and aborts. The credential was fine the
+ * whole time, which is exactly why a reader re-entered a key that was never the
+ * problem.
+ *
+ * BOTH SPELLINGS, and not as a courtesy. `@startsimpli/api` camelCases response
+ * keys in the browser while a plain server-side fetch does not — the trap the
+ * three timestamps in this adapter already carry a comment about, and one that
+ * is invisible until somebody's Library quietly lies.
+ */
+import { describe, expect, it } from 'vitest';
+import { render, screen } from '@testing-library/react';
+
+import { LibraryPage } from '../components/pages/LibraryPage';
+import { createCorpusApi } from '../corpus/client';
+import type { CorpusHttp } from '../corpus/client';
+import { FIXTURE_ORG } from '../corpus/fixtures';
+
+const SCOPE = { orgId: FIXTURE_ORG };
+const EMPTY_PAGE = { count: 0, next: null, previous: null, results: [] };
+
+const NOW = Date.now();
+const ago = (ms: number) => new Date(NOW - ms).toISOString();
+const SIXTEEN_DAYS_AGO = ago(16 * 24 * 60 * 60_000);
+const TEN_MINUTES_AGO = ago(10 * 60_000);
+
+/** What production held, verbatim: the connector taxonomy's own code and text. */
+const THE_REAL_REASON =
+  'connector_granola poll failed on page 1: [config_error] the response '
+  + 'exceeded the 262144-byte cap and was aborted [granola]';
+
+/**
+ * The WIRE, not the contract — rows go in exactly as central serialises them,
+ * the same convention `corpus-source-strip.test.tsx` keeps and for the same
+ * reason: a fixture must never be more generous than the server that feeds it.
+ */
+function httpOver(rows: Array<Record<string, unknown>>): CorpusHttp {
+  return {
+    async get<T>(path: string): Promise<T> {
+      if (path.includes('connections')) {
+        return { count: rows.length, next: null, previous: null, results: rows } as T;
+      }
+      return EMPTY_PAGE as T;
+    },
+  };
+}
+
+const sourcesFrom = (rows: Array<Record<string, unknown>>) =>
+  createCorpusApi({ http: httpOver(rows), scope: SCOPE }).listSources();
+
+/**
+ * THE LIVE ROW, as `/api/v1/subtree/connections/` served it on 2026-08-27.
+ * `check_error` empty, `status` connected, twenty failures counted, and — since
+ * #375 — a reason.
+ */
+const TANDEM_GRANOLA = {
+  id: 'shared-granola',
+  connector_key: 'granola',
+  connector_name: 'Granola',
+  status: 'connected',
+  check_error: '',
+  last_synced_at: SIXTEEN_DAYS_AGO,
+  last_attempt_at: TEN_MINUTES_AGO,
+  last_checked_at: TEN_MINUTES_AGO,
+  consecutive_failures: 20,
+  last_error: THE_REAL_REASON,
+};
+
+describe('listSources — the strip carries the reason central sends', () => {
+  it('reads last_error onto the card', async () => {
+    const [granola] = await sourcesFrom([TANDEM_GRANOLA]);
+
+    expect(granola.lastError).toBe(THE_REAL_REASON);
+  });
+
+  it('reads it in the camelCase spelling the browser sees', async () => {
+    const [granola] = await sourcesFrom([
+      { ...TANDEM_GRANOLA, last_error: undefined, lastError: THE_REAL_REASON },
+    ]);
+
+    expect(granola.lastError).toBe(THE_REAL_REASON);
+  });
+
+  it('says WHY rather than only how many times', async () => {
+    const [granola] = await sourcesFrom([TANDEM_GRANOLA]);
+
+    expect(granola.status).toBe('error');
+    // The count survives — "one blip" and "sixteen days" are different
+    // problems — but it is no longer the whole sentence.
+    expect(granola.detail).toMatch(/20 syncs in a row failed/);
+    expect(granola.detail).toContain('262144-byte cap');
+  });
+
+  it('still counts alone when the server sent no reason', async () => {
+    const [granola] = await sourcesFrom([{ ...TANDEM_GRANOLA, last_error: '' }]);
+
+    expect(granola.status).toBe('error');
+    expect(granola.detail).toMatch(/20 syncs in a row failed/);
+    expect(granola.lastError).toBeUndefined();
+  });
+
+  it('calls a source failing when its newest run failed, even at a zero streak', async () => {
+    // `consecutive_failures` and `last_error` have different writers: the
+    // counter lives on the connection and the reason is derived from the newest
+    // RUN. Central sends `last_error` only while that newest run is the failed
+    // one, so a reason with no streak behind it is still a failing source —
+    // and the old branch, which turned only on the counter, called it `stale`.
+    const [granola] = await sourcesFrom([
+      { ...TANDEM_GRANOLA, consecutive_failures: 0 },
+    ]);
+
+    expect(granola.status).toBe('error');
+    expect(granola.detail).toContain('262144-byte cap');
+  });
+
+  it('leaves the credential’s own verdict in charge when there is one', async () => {
+    // Two different facts and never substitutes (bd startsim-1cow). A rejected
+    // key is what the reader must act on; the run reason is the sentence for
+    // when the key is FINE and the data still is not arriving.
+    const [granola] = await sourcesFrom([
+      {
+        ...TANDEM_GRANOLA,
+        status: 'needs_reauth',
+        check_error: 'The vendor rejected this key (401). Reconnect Granola.',
+      },
+    ]);
+
+    expect(granola.detail).toBe('The vendor rejected this key (401). Reconnect Granola.');
+  });
+
+  it('never reports a reason on a source that is fine', async () => {
+    const [granola] = await sourcesFrom([
+      {
+        ...TANDEM_GRANOLA,
+        last_synced_at: ago(60_000),
+        consecutive_failures: 0,
+        last_error: '',
+      },
+    ]);
+
+    expect(granola.status).toBe('ok');
+    expect(granola.detail).toBeUndefined();
+  });
+});
+
+describe('the Library strip, rendered', () => {
+  it('prints the reason next to the corpus it was supposed to fill', async () => {
+    // The bug was VISIBLE, so the assertion is made where the reader would have
+    // seen it — not on the adapter's return value alone.
+    render(
+      <LibraryPage
+        api={createCorpusApi({ http: httpOver([TANDEM_GRANOLA]), scope: SCOPE })}
+        scope={SCOPE}
+      />,
+    );
+
+    expect(await screen.findByText(/262144-byte cap/)).toBeInTheDocument();
+  });
+});

package/src/components/pages/ConnectionsPage.tsx

@@ -47,6 +47,7 @@ import type {
   ConnectionChoicePage,
   ConnectionInvokeResult,
   ConnectionPermissions,
+  ConnectionRun,
   ConnectionTarget,
   ConnectorAction,
   ConnectorCatalogEntry,
@@ -135,6 +136,16 @@ interface BoundApi {
   invokeConnectionAction?(id: string, action: string, input: {
     destination_id: string; record_type?: string; records?: unknown[];
   }): Promise<ConnectionInvokeResult>;
+  /**
+   * RECENT ACTIVITY on both legs (bd startsim-ei8gm.2). Required on both
+   * injected interfaces and, until this bead, called by nothing — so the reason
+   * a run failed reached the payload and never a pixel.
+   *
+   * Optional HERE for the reason every other verb on this type is: an app
+   * pinned to an older `@startsimpli/api` keeps type-checking, and the card
+   * renders no control rather than a button whose handler is `undefined`.
+   */
+  connectionRuns?(id: string): Promise<{ results: ConnectionRun[] }>;
   /** Per-member governance (bd startsim-768w.22.25.8). Foundry mode only, and
       absent on an api that predates the endpoints — see `ConnectionsApi`. */
   /** The OAuth hand-off (bd startsim-768w.22.25.14/.23). Optional: an app on an
@@ -179,7 +190,16 @@ function bindApi(props: ConnectionsPageProps): BoundApi {
     ? { disconnectMemberConnection: (id: string) =>
       api.disconnectMemberConnection!(slug, id) }
     : {};
+  // Bound only when the injected client HAS it, even though `ConnectionsApi`
+  // declares it required: apps consume `@startsimpli/*` as PUBLISHED packages,
+  // so a runtime object that predates the verb is a real state the TYPE cannot
+  // see (bd startsim-ei8gm.2). Same rule as the four above — a wrapper that
+  // always exists and throws inside would render the control and fail on click.
+  const runs = api.connectionRuns
+    ? { connectionRuns: (id: string) => api.connectionRuns(slug, id) }
+    : {};
   return {
+    ...runs,
     ...memberPolicy,
     ...oauth,
     ...roster,
@@ -216,6 +236,21 @@ const DEFAULTS = {
   error: 'text-sm text-red-600',
 };
 
+/**
+ * WHICH LEG A RUN BELONGS TO, in a reader's words (bd startsim-ei8gm.2).
+ *
+ * The card merges three tables — `SourceRun`, `DestinationRun` and
+ * `DestinationWebhookEvent` — into one list, and "failed" means a different
+ * thing and needs a different action on each. Data with a fall-through to the
+ * raw key, the same rule `CAPABILITY_COPY` below states: a `kind` this bundle
+ * has never heard of renders as itself rather than vanishing from the list.
+ */
+const RUN_KIND_COPY: Record<string, string> = {
+  source_run: 'Fetched in',
+  destination_run: 'Sent out',
+  webhook_event: 'Received',
+};
+
 /**
  * WHAT AN ADMIN IS AGREEING TO, in their words rather than the wire's.
  *
@@ -1088,6 +1123,10 @@ function ConnectionCard({
   const [replacing, setReplacing] = React.useState(false);
   const [settingsOpen, setSettingsOpen] = React.useState(false);
   const [confirmingDisconnect, setConfirmingDisconnect] = React.useState(false);
+  const [activityOpen, setActivityOpen] = React.useState(false);
+  /** `null` is NOT LOADED YET, which reads differently from a connection that
+      has never run — the distinction the empty state below turns on. */
+  const [runs, setRuns] = React.useState<ConnectionRun[] | null>(null);
 
   const declared = entry?.capabilities;
   const enabled = React.useMemo(
@@ -1138,102 +1177,169 @@ function ConnectionCard({
             <p className={cn.error}>{connection.check_error}</p>
           ) : null}
         </div>
-        {canManage ? (
-          <div className="flex flex-wrap justify-end gap-2">
-            <button
-              type="button"
-              className={cn.button}
-              disabled={Boolean(busy)}
-              onClick={() => void guard('check', async () => {
-                const res = await api.checkConnection(connection.id);
-                setNotice(res.detail || (res.ok ? 'Connection is healthy.' : ''));
-                onChanged();
-              })}
-            >
-              Test
-            </button>
-            {/* THE CONTROL THIS PAGE WAS MISSING. A vendor key gets rotated —
-                that is normal operations, not an exception — and the only place
-                to put the new one was a form that creates a second account. */}
+        <div className="flex flex-wrap justify-end gap-2">
+          {/* ACTIVITY IS OUTSIDE THE MANAGE GATE, and deliberately. Reading the
+              run ledger needs `view_connections` server-side, which is what put
+              this card on the screen at all — and the person who most needs to
+              know WHY a connection is failing is often the one who cannot fix
+              it themselves. Gating the answer behind the permission to act
+              would leave them with the word "Failing" and nothing else, which
+              is the sixteen days this bead is about. */}
+          {api.connectionRuns ? (
             <button
               type="button"
               className={cn.button}
               disabled={Boolean(busy)}
               onClick={() => {
-                setConfirmingDisconnect(false);
-                setError('');
-                setReplacing((v) => !v);
+                const opening = !activityOpen;
+                setActivityOpen(opening);
+                if (!opening) return;
+                void guard('activity', async () => {
+                  const page = await api.connectionRuns!(connection.id);
+                  setRuns(page.results ?? []);
+                });
               }}
             >
-              {replacing ? 'Cancel' : 'Replace key'}
+              {activityOpen ? 'Hide activity' : 'Activity'}
             </button>
-            {/* DISCOVER -> WIRE -> FIRE is foundry-level and stays there. The
-                member router serves no choices, targets or actions at all, so
-                the control is gated on the verb EXISTING rather than on a mode
-                flag — there is no way to render a button here whose handler is
-                undefined. */}
-            {api.connectionChoices && api.connectionActions ? (
+          ) : null}
+          {canManage ? (
+            <>
               <button
                 type="button"
                 className={cn.button}
                 disabled={Boolean(busy)}
-                onClick={() => void guard('discover', async () => {
-                  const page = await api.connectionChoices!(connection.id);
-                  setChoices(page.results ?? []);
-                  const available = await api.connectionActions!(connection.id);
-                  setActions(available.results ?? []);
+                onClick={() => void guard('check', async () => {
+                  const res = await api.checkConnection(connection.id);
+                  setNotice(res.detail || (res.ok ? 'Connection is healthy.' : ''));
+                  onChanged();
                 })}
               >
-                {busy === 'discover' ? 'Loading…' : 'Workflows'}
+                Test
               </button>
-            ) : null}
-            {/* SETTINGS, which this card has never had. A connector's
-                `config_schema` ships on every catalog row and was rendered
-                exactly once — on the connect form, before the account existed.
-                After that a setting could not be changed from the product at
-                all, which for Granola means the switch deciding whether verbatim
-                recordings of people's conversations are stored was reachable
-                only by editing the database. `ReplaceKeyForm` already pointed at
-                "the connection's own settings" as if this existed.
+              {/* THE CONTROL THIS PAGE WAS MISSING. A vendor key gets rotated —
+                  that is normal operations, not an exception — and the only place
+                  to put the new one was a form that creates a second account. */}
+              <button
+                type="button"
+                className={cn.button}
+                disabled={Boolean(busy)}
+                onClick={() => {
+                  setConfirmingDisconnect(false);
+                  setError('');
+                  setReplacing((v) => !v);
+                }}
+              >
+                {replacing ? 'Cancel' : 'Replace key'}
+              </button>
+              {/* DISCOVER -> WIRE -> FIRE is foundry-level and stays there. The
+                  member router serves no choices, targets or actions at all, so
+                  the control is gated on the verb EXISTING rather than on a mode
+                  flag — there is no way to render a button here whose handler is
+                  undefined. */}
+              {api.connectionChoices && api.connectionActions ? (
+                <button
+                  type="button"
+                  className={cn.button}
+                  disabled={Boolean(busy)}
+                  onClick={() => void guard('discover', async () => {
+                    const page = await api.connectionChoices!(connection.id);
+                    setChoices(page.results ?? []);
+                    const available = await api.connectionActions!(connection.id);
+                    setActions(available.results ?? []);
+                  })}
+                >
+                  {busy === 'discover' ? 'Loading…' : 'Workflows'}
+                </button>
+              ) : null}
+              {/* SETTINGS, which this card has never had. A connector's
+                  `config_schema` ships on every catalog row and was rendered
+                  exactly once — on the connect form, before the account existed.
+                  After that a setting could not be changed from the product at
+                  all, which for Granola means the switch deciding whether verbatim
+                  recordings of people's conversations are stored was reachable
+                  only by editing the database. `ReplaceKeyForm` already pointed at
+                  "the connection's own settings" as if this existed.
 
-                GATED ON THE SETTINGS VERB, not on the general one (bd
-                startsim-sfms2). The member surface has `updateConnectionConfig`
-                and deliberately not `updateConnection`, because a personal
-                connection's config is the MEMBER's privacy boundary while its
-                name and what it may do stay the foundry's. One gate for both
-                would have made opening this control open the capability Save
-                beside it, which is a decision this change did not make. */}
-            {configFields.length && api.updateConnectionConfig ? (
+                  GATED ON THE SETTINGS VERB, not on the general one (bd
+                  startsim-sfms2). The member surface has `updateConnectionConfig`
+                  and deliberately not `updateConnection`, because a personal
+                  connection's config is the MEMBER's privacy boundary while its
+                  name and what it may do stay the foundry's. One gate for both
+                  would have made opening this control open the capability Save
+                  beside it, which is a decision this change did not make. */}
+              {configFields.length && api.updateConnectionConfig ? (
+                <button
+                  type="button"
+                  className={cn.button}
+                  disabled={Boolean(busy) || confirmingDisconnect}
+                  onClick={() => {
+                    setReplacing(false);
+                    setError('');
+                    setSettingsOpen((v) => !v);
+                  }}
+                >
+                  {settingsOpen ? 'Close settings' : 'Settings'}
+                </button>
+              ) : null}
               <button
                 type="button"
                 className={cn.button}
                 disabled={Boolean(busy) || confirmingDisconnect}
                 onClick={() => {
                   setReplacing(false);
+                  setSettingsOpen(false);
                   setError('');
-                  setSettingsOpen((v) => !v);
+                  setConfirmingDisconnect(true);
                 }}
               >
-                {settingsOpen ? 'Close settings' : 'Settings'}
+                Disconnect
               </button>
-            ) : null}
-            <button
-              type="button"
-              className={cn.button}
-              disabled={Boolean(busy) || confirmingDisconnect}
-              onClick={() => {
-                setReplacing(false);
-                setSettingsOpen(false);
-                setError('');
-                setConfirmingDisconnect(true);
-              }}
-            >
-              Disconnect
-            </button>
-          </div>
-        ) : null}
+            </>
+          ) : null}
+        </div>
       </div>
 
+      {activityOpen ? (
+        <div className="mt-3 space-y-2 border-t pt-3" role="group"
+             aria-label="Recent activity">
+          {/* THE FIELD NOTHING HAS EVER READ. `ConnectionRun.error_message` has
+              been declared in this package's types since the endpoint existed;
+              until #375 the server answered `""` for every source run ever
+              recorded, and even after it did not, no component asked. A failed
+              run rendered as a status word, which is a fact the reader already
+              had from the card above it.
+
+              RENDERED AS THE SERVER WROTE IT. The text is scrubbed against this
+              connection's stored credential and the platform app_secret before
+              it leaves Django (`surface.py::_reason_reader`), and a reason that
+              could not be scrubbed arrives as a sentence saying so. There is
+              one redaction path in this estate and it is not in the browser —
+              which does not hold the secrets to run it. */}
+          {busy === 'activity' && runs === null ? (
+            <p className={cn.muted}>Loading recent activity…</p>
+          ) : null}
+          {runs !== null && runs.length === 0 ? (
+            <p className={cn.muted}>No runs yet for this connection.</p>
+          ) : null}
+          {(runs ?? []).map((run) => (
+            <div key={run.id} data-run={run.id}>
+              <p className={cn.muted}>
+                <span className="font-medium text-gray-900">
+                  {RUN_KIND_COPY[run.kind] ?? run.kind}
+                </span>
+                {run.name ? ` · ${run.name}` : ''}
+                {` · ${run.status}`}
+                {run.occurred_at ? ` · ${new Date(run.occurred_at).toLocaleString()}` : ''}
+              </p>
+              {run.error_message ? (
+                <p className={cn.error}>{run.error_message}</p>
+              ) : null}
+            </div>
+          ))}
+        </div>
+      ) : null}
+
       {settingsOpen ? (
         <ConnectionSettingsForm
           api={api}

package/src/corpus/client.ts

@@ -940,6 +940,11 @@ export function createCorpusApi(
           Number(connection.consecutive_failures ?? connection.consecutiveFailures ?? 0) || 0;
         const documentCount = counts.get(key) ?? null;
         const error = String(connection.check_error ?? connection.checkError ?? '');
+        // WHY THE LAST POLL FAILED — not why the credential did (bd
+        // startsim-ei8gm.2). Both spellings for the same reason the three
+        // timestamps above read both: `@startsimpli/api` camelCases response
+        // keys in the browser and a plain server-side fetch does not.
+        const lastError = String(connection.last_error ?? connection.lastError ?? '');
         const status = connection.status ?? '';
 
         let health: SourceFreshness['status'] = 'ok';
@@ -947,7 +952,7 @@ export function createCorpusApi(
         if (error || status === 'error' || status === 'needs_reauth') {
           health = 'error';
           detail = error || `Connection status is ${String(status)}.`;
-        } else if (failures > 0 || (lastAttemptAt && !lastSyncedAt)) {
+        } else if (failures > 0 || lastError || (lastAttemptAt && !lastSyncedAt)) {
           // IT TRIED AND IT FAILED. Central's view exists partly so that "a card
           // cannot read 'nothing yet' while it is in fact failing on a
           // schedule" — a run that FINISHED while nothing has ever finished well
@@ -955,12 +960,33 @@ export function createCorpusApi(
           // when an older sync did land. Note what does NOT appear in this
           // condition: `lastCheckedAt`. A verified key is not a delivered
           // record, in either direction.
+          //
+          // `lastError` JOINS THAT CONDITION, because the two facts have
+          // different writers: `consecutive_failures` is a counter on the
+          // CONNECTION and the reason is derived from the newest RUN. Central
+          // sends a reason only while that newest run is the failed one, so a
+          // reason with a zero streak behind it is still a source whose last
+          // sync failed — and turning only on the counter reported that as
+          // `stale`, which reads as "nothing to do yet".
           health = 'error';
-          detail =
+          // THE COUNT SURVIVES; IT IS NO LONGER THE WHOLE SENTENCE. "One blip"
+          // and "sixteen days" are different problems, so the streak stays —
+          // what was missing was the half a reader can act on. Composed here
+          // rather than server-side because the streak is a connection field
+          // and the reason is a run field, and central sends them separately
+          // on purpose (bd startsim-1cow: conflating two facts is how a
+          // freshness strip lies).
+          const streak =
             failures > 0
-              ? `${failures} sync${failures === 1 ? '' : 's'} in a row failed` +
-                `${lastSyncedAt ? '' : ' and nothing has arrived yet'}.`
-              : 'A sync ran but nothing arrived.';
+              ? `${failures} sync${failures === 1 ? '' : 's'} in a row failed`
+              : lastError
+                ? 'The last sync failed'
+                : 'A sync ran but nothing arrived';
+          const nothingYet =
+            failures > 0 && !lastSyncedAt ? ' and nothing has arrived yet' : '';
+          // An em dash, not a colon: the server's reason usually contains its
+          // own colons ("[config_error] ...") and a second one reads as a typo.
+          detail = lastError ? `${streak}${nothingYet} — ${lastError}` : `${streak}${nothingYet}.`;
         } else if (!lastSyncedAt) {
           // `never` regardless of `lastCheckedAt`, which is the whole bead.
           health = 'never';
@@ -982,6 +1008,10 @@ export function createCorpusApi(
           consecutiveFailures: failures,
           status: health,
           ...(detail ? { detail } : {}),
+          // Carried separately as well as folded into `detail`, so a surface
+          // that wants the reason on its own — a tooltip, a copy button, the
+          // control plane's card — does not have to unpick a composed sentence.
+          ...(lastError ? { lastError } : {}),
         };
       });
     },

package/src/corpus/types.ts

@@ -222,6 +222,34 @@ export interface SourceFreshness {
   status: 'ok' | 'stale' | 'error' | 'never';
   /** Why it is not `ok`, in the words the server used. */
   detail?: string;
+  /**
+   * WHY THE LAST SYNC FAILED, in the vendor's own words, and a DIFFERENT FACT
+   * FROM THE CREDENTIAL'S VERDICT (bd startsim-ei8gm.2).
+   *
+   * The Tandem Granola card read "Failing — 20 syncs in a row failed, synced
+   * 16d ago" for sixteen days and nothing said why. It was our own 256 KiB
+   * egress cap — the per-note detail response peaked at 351 KB — which is a
+   * minutes-long diagnosis for anyone who could see the text and sixteen days
+   * for anyone who could not.
+   *
+   * `check_error` COULD NOT HAVE ANSWERED IT, which is why this is its own
+   * field rather than a wider read of that one. `check()` and `poll()` are
+   * different requests: Granola's check asks for `page_size=1` and passes,
+   * while its poll asks for thirty notes with transcripts and aborts. The
+   * credential verified cleanly throughout, so a strip built on `check_error`
+   * alone can count twenty failures and name none of them — and it sends the
+   * reader to re-enter a key that was never the problem.
+   *
+   * Central sends it only while the connection's NEWEST run is the failed one
+   * (`SubtreeConnectionsView._last_failure_reasons`), so it is never last
+   * Tuesday's error quoted over a fix that has already landed. It is SCRUBBED
+   * server-side against that connection's own stored credential plus the
+   * platform app_secret — a vendor can quote our key back inside its own error
+   * body — and a reason that could not be scrubbed arrives as a sentence saying
+   * so rather than as the raw text. Nothing here re-checks it; there is exactly
+   * one redaction path and it is not in the browser.
+   */
+  lastError?: string;
 }
 
 /** DRF PageNumberPagination, which is what the tenant data API speaks. */