@startsimpli/integrations 0.2.16 → 0.2.18

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

@@ -18,6 +18,7 @@ import type {
   CommitmentQuery,
   CommitmentTrackerApi,
   CorpusPage,
+  ExtractionRun,
 } from '../corpus/types';
 
 const NOW = Date.parse('2026-08-10T12:00:00Z');
@@ -74,6 +75,8 @@ function makeApi(options: {
   appliedFilters?: string[];
   onQuery?: (query: CommitmentQuery) => void;
   extract?: CommitmentTrackerApi['extract'];
+  startExtraction?: CommitmentTrackerApi['startExtraction'];
+  getExtractionRun?: CommitmentTrackerApi['getExtractionRun'];
 } = {}): CommitmentTrackerApi {
   const rows = options.rows ?? ROWS;
   return {
@@ -90,6 +93,8 @@ function makeApi(options: {
       };
     },
     ...(options.extract ? { extract: options.extract } : {}),
+    ...(options.startExtraction ? { startExtraction: options.startExtraction } : {}),
+    ...(options.getExtractionRun ? { getExtractionRun: options.getExtractionRun } : {}),
   };
 }
 
@@ -279,6 +284,8 @@ describe('TrackerPage — what is outstanding', () => {
 describe('TrackerPage — running the extraction', () => {
   const RESULT = {
     documentsProcessed: 16,
+    documentIds: [],
+    modelFailure: null,
     totalDocuments: 16,
     nextOffset: null,
     fromRules: 24,
@@ -343,7 +350,7 @@ describe('TrackerPage — running the extraction', () => {
 
 describe('TrackerPage — the run reports its own precision work', () => {
   const BASE = {
-    documentsProcessed: 16, totalDocuments: 16, nextOffset: null,
+    documentsProcessed: 16, documentIds: [], modelFailure: null, 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 },
@@ -376,3 +383,249 @@ describe('TrackerPage — the run reports its own precision work', () => {
     expect(screen.queryByText(/proposed and dropped/)).toBeNull();
   });
 });
+
+// ---------------------------------------------------------------------------
+//  a sweep is a JOB, and the screen watches it (bd startsim-768w.38.28)
+// ---------------------------------------------------------------------------
+
+/**
+ * The button used to block on a synchronous call that could not possibly finish.
+ * Now it starts a run and watches it, so the four things a person needs while a
+ * six-minute job is going have to be on screen: that it started, how far it has
+ * got, that it can be left alone, and — the one that was missing — whether the
+ * model actually answered.
+ */
+describe('TrackerPage — watching a queued sweep', () => {
+  const TOTALS = {
+    documentsProcessed: 0, fromRules: 0, fromModel: 0, ungrounded: 0, unconfirmed: 0,
+    created: 0, merged: 0, resolved: 0, droppedOutOfScope: 0, modelCalls: 0, modelFailures: 0,
+  };
+
+  function run(overrides: Partial<ExtractionRun> = {}): ExtractionRun {
+    return {
+      runId: 'sweep-1',
+      scope: SCOPE,
+      status: 'running',
+      cursor: 0,
+      totalDocuments: 17,
+      totals: { ...TOTALS },
+      processedIds: [],
+      modelIncompleteIds: [],
+      needsReview: [],
+      provider: { provider: 'anthropic', model: 'claude-sonnet-5', live: true },
+      startedAt: '2026-08-10T12:00:00Z',
+      updatedAt: '2026-08-10T12:00:00Z',
+      finishedAt: null,
+      leaseOwner: 'driver-a',
+      leaseUntil: '2026-08-10T12:05:00Z',
+      error: null,
+      lastModelFailure: null,
+      history: [],
+      ...overrides,
+    };
+  }
+
+  it('starts a run and says what it is doing, without waiting for it', async () => {
+    // Nothing is running when the page opens, which is the only state in which
+    // the control is a START rather than a watch.
+    let started = false;
+    const startExtraction = vi.fn(async () => {
+      started = true;
+      return run({ status: 'queued' });
+    });
+    const getExtractionRun = vi.fn(async () =>
+      started ? run({ status: 'running', cursor: 4, totals: { ...TOTALS, documentsProcessed: 4 } }) : null,
+    );
+    render(
+      <TrackerPage
+        api={makeApi({ startExtraction, getExtractionRun })}
+        scope={SCOPE}
+        now={NOW}
+      />,
+    );
+    await userEvent.click(await screen.findByRole('button', { name: /Pull from meetings/i }));
+
+    expect(startExtraction).toHaveBeenCalledWith({ scope: SCOPE });
+    // A fraction of something real, not a spinner. Six minutes of nothing is
+    // indistinguishable from a hang.
+    expect(await screen.findByText(/4 of 17 meetings/)).toBeInTheDocument();
+  });
+
+  it('says the work carries on if you leave, because it does', async () => {
+    render(
+      <TrackerPage
+        api={makeApi({
+          startExtraction: async () => run({ status: 'queued' }),
+          getExtractionRun: async () => run({ cursor: 2 }),
+        })}
+        scope={SCOPE}
+        now={NOW}
+      />,
+    );
+    await userEvent.click(await screen.findByRole('button', { name: /Pull from meetings/i }));
+    expect(await screen.findByText(/keeps going if you close this page/i)).toBeInTheDocument();
+  });
+
+  it('picks up a sweep that was already running when the page opened', async () => {
+    render(
+      <TrackerPage
+        api={makeApi({
+          startExtraction: async () => run(),
+          getExtractionRun: async () => run({ cursor: 9 }),
+        })}
+        scope={SCOPE}
+        now={NOW}
+      />,
+    );
+    // Nobody pressed anything. The run exists, so the screen shows it.
+    expect(await screen.findByText(/9 of 17 meetings/)).toBeInTheDocument();
+  });
+
+  it('SAYS the model did not answer, instead of reporting nothing found', async () => {
+    // The lie this bead exists to kill: `fromModel: 0` with no explanation reads
+    // exactly like "the model had nothing to add", and that is how a week of
+    // rules-only runs got reported as model runs.
+    render(
+      <TrackerPage
+        api={makeApi({
+          startExtraction: async () => run(),
+          getExtractionRun: async () =>
+            run({
+              status: 'succeeded',
+              cursor: 17,
+              finishedAt: '2026-08-10T12:06:00Z',
+              leaseUntil: null,
+              totals: { ...TOTALS, documentsProcessed: 17, fromRules: 61, fromModel: 0, created: 61, modelCalls: 5, modelFailures: 12 },
+              modelIncompleteIds: Array.from({ length: 12 }, (_, index) => `doc_${index}`),
+              lastModelFailure: { stage: 'extract', message: 'Request timed out after 60000ms', timedOut: true },
+            }),
+        })}
+        scope={SCOPE}
+        now={NOW}
+      />,
+    );
+    expect(await screen.findByText(/the model did not answer/i)).toBeInTheDocument();
+    expect(screen.getByText(/timed out/i)).toBeInTheDocument();
+    expect(screen.getByText(/12 meetings/)).toBeInTheDocument();
+  });
+
+  it('offers to resume a sweep whose driver went away, rather than spinning', async () => {
+    render(
+      <TrackerPage
+        api={makeApi({
+          startExtraction: async () => run(),
+          getExtractionRun: async () =>
+            run({ status: 'running', cursor: 9, leaseUntil: '2026-08-10T11:00:00Z' }),
+        })}
+        scope={SCOPE}
+        now={NOW}
+      />,
+    );
+    expect(await screen.findByText(/stopped/i)).toBeInTheDocument();
+    expect(await screen.findByRole('button', { name: /Resume/i })).toBeInTheDocument();
+  });
+
+  it('picks a stalled sweep back up without anybody pressing anything', async () => {
+    // A sweep is about ten minutes and the token that starts it lives thirty, so
+    // a run begun late in a session stops mid-way with its cursor intact. All it
+    // needs is a live bearer, and asking a person to click for that is asking
+    // them to do the machine's bookkeeping. The SERVER still owns the cursor —
+    // this only re-presents a credential.
+    const startExtraction = vi.fn(async () => run({ cursor: 9 }));
+    render(
+      <TrackerPage
+        api={makeApi({
+          startExtraction,
+          getExtractionRun: async () =>
+            run({ status: 'running', cursor: 9, leaseUntil: '2026-08-10T11:00:00Z' }),
+        })}
+        scope={SCOPE}
+        now={NOW}
+        pollMs={5}
+        maxAutoResumes={2}
+      />,
+    );
+    await screen.findByText(/stopped/i);
+    await new Promise((resolve) => setTimeout(resolve, 120));
+    // Bounded: two, not one per poll for ever.
+    expect(startExtraction.mock.calls.length).toBe(2);
+  });
+
+  it('does NOT auto-resume a sweep that failed — it said why, and that should be read', async () => {
+    const startExtraction = vi.fn(async () => run());
+    render(
+      <TrackerPage
+        api={makeApi({
+          startExtraction,
+          getExtractionRun: async () =>
+            run({ status: 'failed', cursor: 9, leaseUntil: null, error: 'entities responded 502' }),
+        })}
+        scope={SCOPE}
+        now={NOW}
+        pollMs={5}
+      />,
+    );
+    await screen.findByText(/502/);
+    await new Promise((resolve) => setTimeout(resolve, 80));
+    expect(startExtraction).not.toHaveBeenCalled();
+  });
+
+  it('reports a sweep that failed, with the reason and what it kept', async () => {
+    render(
+      <TrackerPage
+        api={makeApi({
+          startExtraction: async () => run(),
+          getExtractionRun: async () =>
+            run({
+              status: 'failed',
+              cursor: 9,
+              leaseUntil: null,
+              finishedAt: '2026-08-10T12:04:00Z',
+              error: 'api/v1/entities responded 502',
+              totals: { ...TOTALS, documentsProcessed: 9, created: 31 },
+            }),
+        })}
+        scope={SCOPE}
+        now={NOW}
+      />,
+    );
+    expect(await screen.findByText(/502/)).toBeInTheDocument();
+    // Partial progress is progress and the screen has to say so, or somebody
+    // starts over by hand.
+    expect(screen.getByText(/9 of 17/)).toBeInTheDocument();
+  });
+
+  it('stops polling once the run is over, and does not loop', async () => {
+    // The same failure this component already shipped once, in a new place: a
+    // poll whose dependencies churn is a request every render. A finished run is
+    // a record, not a subscription.
+    const getExtractionRun = vi.fn(async () =>
+      run({ status: 'succeeded', cursor: 17, finishedAt: '2026-08-10T12:06:00Z', leaseUntil: null }),
+    );
+    render(
+      <TrackerPage
+        api={makeApi({ startExtraction: async () => run(), getExtractionRun })}
+        scope={SCOPE}
+        now={NOW}
+        pollMs={5}
+      />,
+    );
+    await screen.findByText('Chase the inventor for comments on 2148');
+    await new Promise((resolve) => setTimeout(resolve, 120));
+    // 24 polls would have happened at 5ms if it had not stopped.
+    expect(getExtractionRun.mock.calls.length).toBeLessThanOrEqual(2);
+  });
+
+  it('still works on a deployment that only has the synchronous call', async () => {
+    const extract = vi.fn(async () => ({
+      documentsProcessed: 1, documentIds: ['doc_1'], modelFailure: null, totalDocuments: 1,
+      nextOffset: null, fromRules: 1, fromModel: 0, ungrounded: 0, unconfirmed: 0, verified: true,
+      created: 1, merged: 0, resolved: 0, needsReview: [], droppedOutOfScope: 0,
+      provider: { provider: 'anthropic', model: 'claude-sonnet-5', live: true },
+    }));
+    render(<TrackerPage api={makeApi({ extract })} scope={SCOPE} now={NOW} />);
+    await userEvent.click(await screen.findByRole('button', { name: /Pull from meetings/i }));
+    expect(extract).toHaveBeenCalled();
+    expect(await screen.findByText(/Read 1 meeting/)).toBeInTheDocument();
+  });
+});