@startsimpli/integrations 0.1.6 → 0.2.2

package/src/corpus/extract.ts

@@ -0,0 +1,438 @@
+/**
+ * EXTRACTION — conversations in, trackable commitments out (bd startsim-768w.38.25).
+ *
+ * The pipeline, server-side, in one function:
+ *
+ *   1. read documents from the tenant data API, already org-scoped by the
+ *      server and narrowed the same way the Library narrows;
+ *   2. run the SCOPE GUARD over them — a third check, before anything is read
+ *      into a prompt (see ./retrieval for why this is not a convenience);
+ *   3. RULES PASS: parse the commitments the summariser ALREADY wrote down.
+ *      No model, deterministic, byte-stable between runs;
+ *   4. ONE model call over every document, told what the rules already found so
+ *      it ADDS rather than restates (feedback_batch_llm_calls — never a loop);
+ *   5. resolve IDENTITY, dedupe within the run and against what is stored;
+ *   6. apply RESOLUTIONS from later meetings, conservatively;
+ *   7. write the result back with `external_id` doing the idempotency.
+ *
+ * STEP 3 IS THE ONE PEOPLE SKIP. The source material here is Granola's own AI
+ * summaries, and on all sixteen real documents on the live tandem tenant the
+ * last heading is `## Next Steps`, under which sit bolded imperatives with the
+ * owner in parentheses. That is an action list the vendor already produced and
+ * already paid for. Sending the document to a model and asking it to find the
+ * action items redoes that work, less reliably, at a per-token price, and then
+ * has to be deduped against the version the vendor wrote. The rules pass takes
+ * it verbatim; the model's job is what the summariser did NOT promote — items
+ * stated in the body, blockers, decisions, and the subject each one is about.
+ *
+ * A PROVIDER OUTAGE COSTS THE EXTRAS, NOT THE LIST. Step 4 is wrapped: if the
+ * model is unreachable the run still produces every commitment the vendor's own
+ * structure carried, and says so in `fromModel: 0`.
+ */
+import { EXTRACTOR_VERSION, applyResolutions, mergeDrafts, reconcile } from './commitments';
+import { enforceScope } from './retrieval';
+import { outcomeSections } from './text';
+import type {
+  Commitment,
+  CommitmentApi,
+  CommitmentDraft,
+  CommitmentStatus,
+  CorpusApi,
+  CorpusExtractorLlm,
+  CorpusScope,
+  ExtractionDraft,
+  ExtractionResult,
+  ResolutionClaim,
+  SourceDocument,
+} from './types';
+
+export interface ExtractCommitmentsOptions {
+  /** How many documents to read before extracting. */
+  documentLimit?: number;
+  /** Pages of the data API this run may read. Bounds one run's cost. */
+  maxPages?: number;
+  /** Characters of each document's text sent to the model. */
+  maxCharsPerDocument?: number;
+}
+
+const DEFAULTS: Required<ExtractCommitmentsOptions> = {
+  documentLimit: 200,
+  maxPages: 10,
+  maxCharsPerDocument: 12_000,
+};
+
+// ---------------------------------------------------------------------------
+//  3. the rules pass — the vendor already did this
+// ---------------------------------------------------------------------------
+
+/** `- **Do the thing** (Owner)` — a bullet in an outcome section. */
+const BULLET = /^\s{0,3}[-*]\s+(\S.*)$/;
+
+/**
+ * THE BOLD IS REQUIRED, and that is the single most important line in the rules
+ * pass.
+ *
+ * Measured on the sixteen real records: accepting bare bullets took precision
+ * from 94% to 75%, because headings like "Action Items Review" and "Open Issues
+ * and Follow-ups" match the outcome regex while the bullets under them are
+ * DISCUSSION, not commitments — "Matter is on the responsible attorney's radar"
+ * is a status note and putting it on a to-do list is a lie about what was
+ * agreed. The summariser marks a real commitment by bolding it. Trusting that
+ * marker is what makes this pass worth having; guessing past it is what makes a
+ * to-do list nobody believes.
+ */
+const LEADING_BOLD = /^\*\*(.+?)\*\*/;
+
+/**
+ * A trailing parenthetical that is plausibly a person or a short list of them.
+ *
+ * Deliberately narrow, and it rejects ALL-CAPS: `(Jonathan, Kevin)` and `(Kate)`
+ * are owners, `(CTO)` is a job title inside the sentence and `(4 5 AC
+ * eight-plex)` is part of the sentence. Reading either of the last two as an
+ * owner puts junk in the column the whole screen is sorted by. Anything that
+ * fails this stays in the title and the model pass gets a chance at the owner.
+ */
+const TRAILING_PAREN = /^(.*?)\s*\(([^()]{2,60})\)\s*$/;
+const OWNER_SHAPE = /^[A-Z][A-Za-z.'’-]*(?:\s+[A-Za-z.'’-]+)*(?:\s*,\s*[A-Z][A-Za-z.'’-]*(?:\s+[A-Za-z.'’-]+)*)*$/;
+const ACRONYM = /^[A-Z][A-Z0-9.\s,&-]*$/;
+
+/**
+ * The commitments the source document already states as commitments.
+ *
+ * NO MODEL. Given the same text this returns the same drafts with the same
+ * `originKey`s forever, which is what makes the majority of the corpus perfectly
+ * idempotent rather than merely usually idempotent.
+ */
+export function rulesExtract(document: SourceDocument): CommitmentDraft[] {
+  const text = [document.body, ...document.sections.map((section) => section.text)]
+    .filter(Boolean)
+    .join('\n\n');
+
+  const drafts: CommitmentDraft[] = [];
+  for (const section of outcomeSections(text)) {
+    let current: { line: string; detail: string[] } | null = null;
+    const flush = () => {
+      if (!current) return;
+      const draft = toDraft(document, current.line, current.detail.join('\n'));
+      if (draft) drafts.push(draft);
+      current = null;
+    };
+    for (const line of section.body.split('\n')) {
+      const bullet = BULLET.exec(line);
+      if (bullet) {
+        flush();
+        current = { line: line.trim(), detail: [] };
+      } else if (current && line.trim()) {
+        current.detail.push(line.trim());
+      }
+    }
+    flush();
+  }
+  return drafts;
+}
+
+function toDraft(document: SourceDocument, line: string, detail: string): CommitmentDraft | null {
+  const content = line.replace(BULLET, '$1').trim();
+  const bold = LEADING_BOLD.exec(content);
+  if (!bold || bold[1].trim().split(/\s+/).length < 3) return null;
+
+  // The owner is read from the LAST trailing parenthetical, whether the
+  // summariser wrote it inside the bold — `**Email Michelle … (Kate)**` — or
+  // after it — `**Complete the equity item** (Jonathan)`. Both spellings are
+  // present in the real corpus and there is no principled reason to honour one;
+  // measured across the sixteen records, reading only the outside form cost six
+  // of eighteen owners on a single document.
+  const flat = content.replace(/\*\*/g, '').trim();
+  const trailing = TRAILING_PAREN.exec(flat);
+  const candidate = trailing?.[2]?.trim() ?? '';
+  const isOwner =
+    Boolean(candidate) && OWNER_SHAPE.test(candidate) && !ACRONYM.test(candidate) && !/\d/.test(candidate);
+
+  const ownerName = isOwner ? candidate : undefined;
+  let title = isOwner ? trailing![1] : flat;
+
+  title = title.replace(/\s+/g, ' ').trim();
+  // Two words is a fragment, not a commitment. The model pass sees the whole
+  // document anyway, so nothing is lost by being strict here.
+  if (title.split(/\s+/).length < 3) return null;
+
+  return {
+    documentId: document.id,
+    // Byte-stable: derived from the vendor's own words, never from a model.
+    originKey: `rules:${slug(title)}`,
+    subtype: 'action',
+    title,
+    detail: detail.trim(),
+    status: 'open',
+    ...(ownerName ? { ownerName } : {}),
+    // The bullet exactly as written, so every row on the screen can be checked
+    // against the record without opening it.
+    quote: line.trim(),
+    extractor: 'rules',
+  };
+}
+
+const slug = (text: string) =>
+  text.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 60);
+
+// ---------------------------------------------------------------------------
+//  the prompt
+// ---------------------------------------------------------------------------
+
+/**
+ * Every rule in here is also enforced in code, because a prompt is a request and
+ * a check is a guarantee. What the prompt uniquely buys is the two things code
+ * cannot derive: what a statement is ABOUT, and whether a later meeting settled
+ * an earlier one.
+ */
+export function extractSystemPrompt(): string {
+  return [
+    'You read meeting records for one company and turn them into trackable items.',
+    'You are given documents that ALREADY have some items extracted from them, listed under ALREADY_FOUND. Do NOT repeat those. Find what they missed.',
+    'An item is something a person now owes, has decided, needs, is at risk from, or has asked. It must be stated in the document — never inferred, never invented.',
+    'For every item, copy a short verbatim "quote" from the document it came from, and echo that document\'s exact id.',
+    'Set "subject" to what the item is ABOUT — a matter or case number, a property, a client, a system, a person. Copy an identifier verbatim when the text has one.',
+    'Set "owner" only to a name the document actually names. Leave it out otherwise.',
+    'Set "dueAt" only when the document states a date. Never estimate one.',
+    'Also report RESOLUTIONS: statements that something previously outstanding is now done or abandoned. Give the subject, what happened, and a verbatim quote.',
+    'Respond with JSON only: {"items":[{"documentId":string,"subtype":"action"|"decision"|"need"|"risk"|"question","title":string,"detail":string,"status":"open"|"done"|"blocked","owner":string,"subject":string,"dueAt":string|null,"quote":string}],"resolutions":[{"documentId":string,"subject":string,"statement":string,"quote":string,"outcome":"done"|"dropped"}]}',
+    '"title" must be one short imperative line.',
+  ].join('\n');
+}
+
+/** ONE payload carrying every document, each tagged with the id to echo. */
+export function renderExtractPrompt(input: {
+  documents: Array<{
+    id: string; title: string; source: string; occurredAt: string | null;
+    participants: string[]; text: string; alreadyFound: string[];
+  }>;
+}): string {
+  const blocks = input.documents.map((document) =>
+    [
+      `<document id="${document.id}">`,
+      `title: ${document.title}`,
+      `source: ${document.source}`,
+      `occurred_at: ${document.occurredAt ?? 'unknown'}`,
+      document.participants.length ? `participants: ${document.participants.join(', ')}` : '',
+      document.alreadyFound.length
+        ? `ALREADY_FOUND (do not repeat these):\n${document.alreadyFound.map((title) => `- ${title}`).join('\n')}`
+        : 'ALREADY_FOUND: none',
+      '',
+      document.text,
+      '</document>',
+    ]
+      .filter((line) => line !== '')
+      .join('\n'),
+  );
+  return [`DOCUMENTS (${input.documents.length}):`, blocks.join('\n\n')].join('\n');
+}
+
+// ---------------------------------------------------------------------------
+//  the pipeline
+// ---------------------------------------------------------------------------
+
+export interface ExtractRequest {
+  scope: CorpusScope;
+  /** Narrow the run to specific records. Omit to sweep the corpus. */
+  documentIds?: string[];
+}
+
+export interface ExtractDeps {
+  corpus: CorpusApi & Partial<CommitmentApi>;
+  extractor: CorpusExtractorLlm;
+}
+
+export async function extractCommitments(
+  request: ExtractRequest,
+  deps: ExtractDeps,
+  options: ExtractCommitmentsOptions = {},
+): Promise<ExtractionResult> {
+  const { documentLimit, maxPages, maxCharsPerDocument } = { ...DEFAULTS, ...options };
+  const { corpus, extractor } = deps;
+
+  // An empty scope grants nothing (`isInScope`). Refusing here rather than
+  // downstream means an unscoped read is never MADE, not made and then filtered.
+  if (!request.scope?.orgId) {
+    return empty(extractor, 'no scope');
+  }
+
+  const { documents: candidates, matched } = await readDocuments(corpus, documentLimit, maxPages);
+  const { kept, dropped } = enforceScope(candidates, request.scope);
+  const documents = request.documentIds?.length
+    ? kept.filter((document) => request.documentIds!.includes(document.id))
+    : kept;
+
+  if (documents.length === 0) {
+    return { ...empty(extractor, 'nothing in scope'), droppedOutOfScope: dropped.length };
+  }
+
+  // 3. rules first, so the model can be told what not to repeat.
+  const ruleDrafts = documents.flatMap(rulesExtract);
+  const foundByDocument = new Map<string, string[]>();
+  for (const draft of ruleDrafts) {
+    foundByDocument.set(draft.documentId, [...(foundByDocument.get(draft.documentId) ?? []), draft.title]);
+  }
+
+  // 4. ONE call, every document, ids echoed.
+  let draft: ExtractionDraft = { items: [], resolutions: [] };
+  try {
+    draft = await extractor.extract({
+      documents: documents.map((document) => ({
+        id: document.id,
+        title: document.title,
+        source: document.sourceLabel || document.source,
+        occurredAt: document.occurredAt,
+        participants: document.participants.map((party) => party.name),
+        text: documentText(document, maxCharsPerDocument),
+        alreadyFound: foundByDocument.get(document.id) ?? [],
+      })),
+    });
+  } catch {
+    // The deterministic half does not depend on the probabilistic half.
+    draft = { items: [], resolutions: [] };
+  }
+
+  const allowed = new Set(documents.map((document) => document.id));
+  const modelDrafts = normaliseItems(draft.items ?? [], allowed);
+  const claims = normaliseResolutions(draft.resolutions ?? [], allowed);
+
+  // 5. identity, dedupe within the run, then against what is stored.
+  const existing = corpus.listCommitments
+    ? await corpus
+        .listCommitments({ pageSize: 500 })
+        .then((page) => page.results)
+        .catch(() => [] as Commitment[])
+    : [];
+
+  const groups = mergeDrafts([...ruleDrafts, ...modelDrafts]);
+  const reconciled = reconcile(existing, groups, { scope: request.scope, documents });
+
+  // 6. resolutions, against the documents the scope guard approved and nothing else.
+  const resolutions = applyResolutions(reconciled.commitments, claims, { documents });
+
+  // 7. write. ONE call carrying every row, keyed on `external_id`.
+  if (corpus.saveCommitments) {
+    await corpus.saveCommitments(resolutions.commitments);
+  }
+
+  return {
+    documentsProcessed: documents.length,
+    fromRules: ruleDrafts.length,
+    fromModel: modelDrafts.length,
+    created: reconciled.created,
+    merged: reconciled.merged,
+    resolved: resolutions.resolved,
+    needsReview: resolutions.needsReview,
+    droppedOutOfScope: dropped.length,
+    provider: extractor.describe(),
+    ...(matched > candidates.length ? { } : {}),
+  };
+}
+
+/**
+ * Read the corpus, PAST THE FIRST PAGE.
+ *
+ * The tenant's `EntityViewSet` pages with DRF's default and ignores `page_size`
+ * (verified on the wire against the live tandem tenant: asking for 3 returns
+ * all sixteen), so a caller that reads one page and calls it the corpus silently
+ * stops seeing older records at whatever `PAGE_SIZE` happens to be. Extraction
+ * over "the most recent page" would quietly stop extracting.
+ */
+async function readDocuments(
+  corpus: CorpusApi,
+  limit: number,
+  maxPages: number,
+): Promise<{ documents: SourceDocument[]; matched: number }> {
+  const documents: SourceDocument[] = [];
+  let matched = 0;
+  for (let page = 1; page <= maxPages && documents.length < limit; page += 1) {
+    const response = await corpus.listDocuments({ page, pageSize: limit });
+    matched = response.count ?? response.results.length;
+    documents.push(...response.results);
+    if (!response.next || response.results.length === 0) break;
+  }
+  return { documents: documents.slice(0, limit), matched };
+}
+
+function documentText(document: SourceDocument, maxChars: number): string {
+  const parts = [document.body, ...document.sections.map((section) => `## ${section.label}\n${section.text}`)];
+  const joined = parts.filter(Boolean).join('\n\n');
+  return joined.length > maxChars ? `${joined.slice(0, maxChars)}\n…[truncated]` : joined;
+}
+
+const SUBTYPES = new Set(['action', 'decision', 'need', 'risk', 'question']);
+const STATUSES = new Set<CommitmentStatus>(['open', 'done', 'blocked', 'dropped']);
+
+/**
+ * Shape-check what the model returned.
+ *
+ * An item naming a document the run never supplied is DROPPED, not repaired:
+ * the document id is the one field that could carry a reference into another
+ * workspace, and a plausible-looking id is exactly what a model produces when it
+ * is guessing.
+ */
+function normaliseItems(
+  items: ExtractionDraft['items'],
+  allowed: Set<string>,
+): CommitmentDraft[] {
+  const out: CommitmentDraft[] = [];
+  for (const item of items) {
+    const documentId = String(item?.documentId ?? '').trim();
+    const title = String(item?.title ?? '').replace(/\s+/g, ' ').trim();
+    if (!allowed.has(documentId) || title.split(/\s+/).length < 3) continue;
+    const subtype = String(item.subtype ?? 'action').toLowerCase();
+    const status = String(item.status ?? 'open').toLowerCase() as CommitmentStatus;
+    const owner = String(item.owner ?? '').trim();
+    out.push({
+      documentId,
+      originKey: `model:${slug(title)}`,
+      subtype: SUBTYPES.has(subtype) ? subtype : 'action',
+      title,
+      detail: String(item.detail ?? '').trim(),
+      status: STATUSES.has(status) ? status : 'open',
+      ...(owner && owner.length <= 60 ? { ownerName: owner } : {}),
+      ...(item.subject ? { subject: String(item.subject).trim() } : {}),
+      ...(item.dueAt ? { dueAt: String(item.dueAt) } : {}),
+      quote: String(item.quote ?? '').trim(),
+      extractor: 'model',
+    });
+  }
+  return out;
+}
+
+function normaliseResolutions(
+  resolutions: NonNullable<ExtractionDraft['resolutions']>,
+  allowed: Set<string>,
+): ResolutionClaim[] {
+  const out: ResolutionClaim[] = [];
+  for (const claim of resolutions) {
+    const documentId = String(claim?.documentId ?? '').trim();
+    const statement = String(claim?.statement ?? '').trim();
+    if (!allowed.has(documentId) || !statement) continue;
+    out.push({
+      documentId,
+      ...(claim.subject ? { subject: String(claim.subject).trim() } : {}),
+      statement,
+      quote: String(claim.quote ?? '').trim(),
+      outcome: claim.outcome === 'dropped' ? 'dropped' : 'done',
+    });
+  }
+  return out;
+}
+
+function empty(extractor: CorpusExtractorLlm, _why: string): ExtractionResult {
+  void _why;
+  return {
+    documentsProcessed: 0,
+    fromRules: 0,
+    fromModel: 0,
+    created: 0,
+    merged: 0,
+    resolved: 0,
+    needsReview: [],
+    droppedOutOfScope: 0,
+    provider: extractor.describe(),
+  };
+}
+
+export { EXTRACTOR_VERSION };

package/src/corpus/fixtures.ts

@@ -43,6 +43,7 @@ import {
   toSourceDocument,
 } from './entities';
 import type { TenantEntity, TenantRelationship } from './entities';
+import { splitSections } from './text';
 import type {
   CorpusApi,
   CorpusPage,
@@ -311,6 +312,116 @@ export const FIXTURE_TENANT_DOCUMENTS: TenantEntity[] = [
   }),
 ];
 
+/**
+ * `source_document` rows in the shape THE TRACKED CORPUS REALLY HAS
+ * (bd startsim-768w.38.25).
+ *
+ * These exist because the rows above, faithful as they are to the canonical
+ * attributes, are not faithful to the TEXT. On the live tandem tenant every one
+ * of the sixteen real records carries its whole content as MARKDOWN under
+ * `data.summary` — `##` headings, one per topic of the meeting, and a final
+ * `## Next Steps` block of bolded imperatives with the owner in parentheses.
+ * There is no `body`, there are no `sections`, and there is no transcript.
+ *
+ * That structure is not incidental: it is the input the rules pass reads, and a
+ * fixture that omitted it would let the extractor pass its tests against a shape
+ * production has never once produced — which is the exact failure bd
+ * startsim-768w.38.22 was filed for. The content below is invented; the SHAPE is
+ * copied from the wire.
+ *
+ * Three documents, arranged so the hard cases are present rather than assumed:
+ *   • `mtg_a` and `mtg_b` both raise the SAME commitment in different words —
+ *     that is the cross-meeting dedupe;
+ *   • `mtg_c` states that one of them came back — that is the resolution;
+ *   • two different matters carry near-identical wording, which is the merge
+ *     that must NOT happen.
+ */
+export const FIXTURE_TENANT_TRACKED: TenantEntity[] = [
+  row({
+    type: 'source_document', id: 'mtg_a', source: 'granola', vendorId: 'not_TrackA0001',
+    name: 'Matter review — 2148, 2198, billing numbers',
+    ownerSub: OWNER_A, createdAt: '2026-08-01T16:10:00Z',
+    data: {
+      subtype: 'meeting',
+      title: 'Matter review — 2148, 2198, billing numbers',
+      occurred_at: '2026-08-01T15:00:00Z',
+      participant_count: 3,
+      summary: [
+        '## Matter Status',
+        '',
+        '- **2148:** waiting on comments from the primary inventor before drafting continues',
+        '- **2198:** substantial feedback received in several rounds; nearly ready to return',
+        '',
+        '## Billing Numbers',
+        '',
+        '- Client asked for matter numbers on every report; no field exists for them today',
+        '- Proposal is a custom field plus a one-time backfill',
+        '',
+        '## Next Steps',
+        '',
+        '- **Chase the primary inventor for comments on 2148** (Rae)',
+        '',
+        '  Status in the system reads "comments received", which is misleading.',
+        '- **Add a billing number field and backfill it once** (Ola)',
+        '',
+        '  One-time manual entry, automated after that.',
+      ].join('\n'),
+    },
+  }),
+  row({
+    type: 'source_document', id: 'mtg_b', source: 'granola', vendorId: 'not_TrackB0002',
+    name: 'Weekly catch-up — outstanding items',
+    ownerSub: OWNER_A, createdAt: '2026-08-04T16:10:00Z',
+    data: {
+      subtype: 'meeting',
+      title: 'Weekly catch-up — outstanding items',
+      occurred_at: '2026-08-04T15:00:00Z',
+      participant_count: 2,
+      summary: [
+        '## Open Threads',
+        '',
+        '- 2148 is still blocked on the inventor; nothing has come back yet',
+        '- The parking lot quote arrived with a phased payment breakdown',
+        '',
+        '## Next Steps',
+        '',
+        // Same commitment as mtg_a's first bullet, in different words. The
+        // dedupe has to see through the rewording or the list doubles.
+        '- **Comments on 2148 still need chasing with the inventor** (Rae)',
+        '',
+        '  Second week running.',
+        // Same VERB, different matter. The dedupe must NOT collapse these.
+        '- **Chase the primary inventor for comments on 2198**',
+        '',
+        '  Different matter, same person.',
+      ].join('\n'),
+    },
+  }),
+  row({
+    type: 'source_document', id: 'mtg_c', source: 'granola', vendorId: 'not_TrackC0003',
+    name: 'Matter review — 2148 back from the inventor',
+    ownerSub: OWNER_A, createdAt: '2026-08-07T16:10:00Z',
+    data: {
+      subtype: 'meeting',
+      title: 'Matter review — 2148 back from the inventor',
+      occurred_at: '2026-08-07T15:00:00Z',
+      participant_count: 3,
+      summary: [
+        '## Matter Status',
+        '',
+        '- 2148: comments came back from the primary inventor, drafting resumes this week',
+        '- 2198: no change',
+        '',
+        '## Next Steps',
+        '',
+        '- **Resume drafting on 2148 now that comments are in** (Rae)',
+        '',
+        '  Target a first pass by the end of the week.',
+      ].join('\n'),
+    },
+  }),
+];
+
 /** `money_event` rows — amounts in MINOR units, under the declared attribute. */
 export const FIXTURE_TENANT_MONEY_EVENTS: TenantEntity[] = [
   row({
@@ -398,6 +509,12 @@ export const FIXTURE_DOCUMENTS: SourceDocument[] = FIXTURE_TENANT_DOCUMENTS.map(
   ),
 );
 
+/** Derived through the SAME mapper, so the markdown arrives as `body` exactly the
+ *  way `data.summary` does on the wire. */
+export const FIXTURE_TRACKED_DOCUMENTS: SourceDocument[] = FIXTURE_TENANT_TRACKED.map((entity) =>
+  toSourceDocument(entity, FALLBACK_SCOPE, FIXTURE_SOURCE_LABELS, []),
+);
+
 export const FIXTURE_MONEY_EVENTS: MoneyEvent[] = FIXTURE_TENANT_MONEY_EVENTS.map((entity) =>
   toMoneyEvent(
     entity,
@@ -698,6 +815,65 @@ export function createFixtureCorpusHttp(options: {
  * `live: false` from `describe()`, and every surface renders that, so a run
  * powered by this can never be mistaken on screen for a run powered by a model.
  */
+/**
+ * A `CorpusExtractorLlm` that extracts WITHOUT a provider, deterministically.
+ *
+ * It stands in for the model's actual job — reading the parts of a document the
+ * summariser did not promote into its own Next Steps list — by taking the first
+ * substantial bullet under each non-outcome heading. That is not what a model
+ * does, and it is not meant to be: what it has to be is DETERMINISTIC and to
+ * echo the ids it was given, so the identity, dedupe, resolution and scope
+ * machinery can be driven end to end in vitest with no API key and no variance.
+ *
+ * It reports `live: false`, and every surface renders that, so a run powered by
+ * this can never be mistaken on screen for a run powered by a model.
+ */
+export function createFixtureExtractor(): import('./types').CorpusExtractorLlm {
+  return {
+    describe: () => ({ provider: 'fixture', model: 'fixture-rules', live: false }),
+    async extract(input) {
+      const items: import('./types').ExtractionDraft['items'] = [];
+      const resolutions: NonNullable<import('./types').ExtractionDraft['resolutions']> = [];
+
+      for (const document of input.documents) {
+        const already = new Set(input.documents.flatMap((entry) => entry.alreadyFound));
+        for (const section of splitSections(document.text)) {
+          if (!section.heading || /next\s*steps?|action\s*items?|follow/i.test(section.heading)) continue;
+          const bullet = section.body
+            .split('\n')
+            .map((line) => line.replace(/^\s{0,3}[-*]\s+/, '').replace(/\*\*/g, '').trim())
+            .find((line) => line.split(/\s+/).length >= 5 && !already.has(line));
+          if (!bullet) continue;
+
+          // A statement that something has come back is a RESOLUTION, not a new
+          // item — which is the one distinction the model exists to make.
+          if (/came back|now (?:in|complete|done)|has landed/i.test(bullet)) {
+            resolutions.push({
+              documentId: document.id,
+              subject: /\b\d{4}(?:-\d{2})?\b/.exec(bullet)?.[0] ?? section.heading,
+              statement: bullet,
+              quote: bullet,
+              outcome: 'done',
+            });
+            continue;
+          }
+
+          items.push({
+            documentId: document.id,
+            subtype: 'decision',
+            title: bullet.slice(0, 120),
+            detail: '',
+            status: 'open',
+            subject: /\b\d{4}(?:-\d{2})?\b/.exec(bullet)?.[0] ?? section.heading,
+            quote: bullet,
+          });
+        }
+      }
+      return { items, resolutions };
+    },
+  };
+}
+
 export function createFixtureLlm(): import('./types').CorpusLlm {
   return {
     describe: () => ({ provider: 'fixture', model: 'fixture-echo', live: false }),