@startsimpli/integrations 0.2.5 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/integrations",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "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__/corpus-extract.test.ts

@@ -507,6 +507,53 @@ describe('extractCommitments', () => {
     expect(second.nextOffset).toBeNull();
   });
 
+  it('writes only what it CHANGED, not the whole corpus', async () => {
+    // Not a micro-optimisation. The tenant has no bulk upsert, so every row is a
+    // request; rewriting untouched rows makes a one-document slice cost one
+    // request per row in the workspace. On the live tenant that pushed a
+    // single-document run past the 60-second gateway at ninety-eight rows.
+    const corpus = createFixtureCorpusApi({ scope: TANDEM, documents: FIXTURE_TRACKED_DOCUMENTS });
+    const tracked: Commitment[] = [];
+    const writes: number[] = [];
+    (corpus as { listCommitments?: unknown }).listCommitments = async () => ({
+      count: tracked.length, next: null, previous: null, results: tracked,
+    });
+    (corpus as { saveCommitments?: unknown }).saveCommitments = async (items: Commitment[]) => {
+      writes.push(items.length);
+      const byId = new Map(tracked.map((item) => [item.externalId, item]));
+      for (const item of items) byId.set(item.externalId, item);
+      tracked.splice(0, tracked.length, ...byId.values());
+    };
+    const extractor = createFixtureExtractor();
+
+    await extractCommitments(
+      { scope: TANDEM, documentIds: [FIXTURE_TRACKED_DOCUMENTS[0].id] },
+      { corpus, extractor },
+    );
+    const afterFirst = tracked.length;
+    await extractCommitments(
+      { scope: TANDEM, documentIds: [FIXTURE_TRACKED_DOCUMENTS[1].id] },
+      { corpus, extractor },
+    );
+
+    // The second slice never rewrites the first slice's untouched rows.
+    expect(writes[1]).toBeLessThan(tracked.length);
+    expect(afterFirst).toBeGreaterThan(0);
+  });
+
+  it('marks NOTHING dirty when a pass changes nothing', () => {
+    // The guarantee stated where it is unambiguous — on the pure reconciler,
+    // with no extractor in the way. Identical input, second time: zero writes.
+    const drafts = mergeDrafts(FIXTURE_TRACKED_DOCUMENTS.flatMap(rulesExtract));
+    const context = { scope: TANDEM, documents: FIXTURE_TRACKED_DOCUMENTS };
+    const first = reconcile([], drafts, context);
+    expect(first.touched.length).toBe(first.commitments.length);
+
+    const second = reconcile(first.commitments, drafts, context);
+    expect(second.created).toBe(0);
+    expect(second.touched).toEqual([]);
+  });
+
   it('refuses outright when the session carries no workspace claim', async () => {
     const corpus = createFixtureCorpusApi({ leakScope: true, documents: FIXTURE_TRACKED_DOCUMENTS });
     const listDocuments = vi.spyOn(corpus, 'listDocuments');

package/src/corpus/commitments.ts

@@ -246,6 +246,15 @@ export interface ReconcileResult {
   commitments: Commitment[];
   created: number;
   merged: number;
+  /**
+   * The `externalId`s this pass actually changed.
+   *
+   * A run must write what it CHANGED, not what it holds. Rewriting the whole
+   * corpus on every pass is one request per row per slice — O(corpus) writes for
+   * O(slice) work — and on the live tenant that alone pushed a single-document
+   * run past the 60-second gateway once there were ninety-eight rows.
+   */
+  touched: string[];
 }
 
 export function reconcile(
@@ -255,6 +264,7 @@ export function reconcile(
 ): ReconcileResult {
   const byId = new Map(context.documents.map((document) => [document.id, document]));
   const out = existing.map(cloneCommitment);
+  const touched = new Set<string>();
   let created = 0;
   let merged = 0;
 
@@ -269,6 +279,7 @@ export function reconcile(
 
     if (match) {
       merged += 1;
+      const before = signature(match);
       applyMentions(match, mentions);
       // The extractor NEVER overwrites a status, an owner or a due date that is
       // already recorded. A person ticking something off on the screen must
@@ -276,6 +287,11 @@ export function reconcile(
       if (!match.ownerName && lead.ownerName) match.ownerName = lead.ownerName;
       if (!match.dueAt && lead.dueAt) match.dueAt = lead.dueAt;
       if (!match.detail && lead.detail) match.detail = lead.detail;
+      // Only a row that ACTUALLY changed is written. Marking every match dirty
+      // would make a repeat run rewrite the corpus for no reason, which is the
+      // difference between "running it twice is a no-op" as a claim and as a
+      // fact you can watch on the network tab.
+      if (signature(match) !== before) touched.add(match.externalId);
       continue;
     }
 
@@ -308,9 +324,10 @@ export function reconcile(
     };
     applyMentions(fresh, mentions);
     out.push(fresh);
+    touched.add(fresh.externalId);
   }
 
-  return { commitments: out, created, merged };
+  return { commitments: out, created, merged, touched: [...touched] };
 }
 
 /**
@@ -335,6 +352,22 @@ function applyMentions(commitment: Commitment, mentions: CommitmentMention[]) {
 
 const mentionKey = (mention: CommitmentMention) => `${mention.documentId}::${mention.originKey}`;
 
+/** Everything a re-run could legitimately change, as one comparable string. */
+function signature(commitment: Commitment): string {
+  return [
+    commitment.title,
+    commitment.detail,
+    commitment.status,
+    commitment.statusReason ?? '',
+    commitment.ownerName ?? '',
+    commitment.dueAt ?? '',
+    commitment.resolvedBy ?? '',
+    commitment.firstSeenAt ?? '',
+    commitment.lastSeenAt ?? '',
+    commitment.mentions.map((mention) => `${mentionKey(mention)}|${mention.quote}`).join('~'),
+  ].join('\u0000');
+}
+
 function toMention(draft: CommitmentDraft, document: SourceDocument): CommitmentMention {
   return {
     documentId: draft.documentId,
@@ -361,6 +394,8 @@ function identityOf(commitment: Commitment): CommitmentIdentity {
 
 export interface ResolutionResult {
   commitments: Commitment[];
+  /** The `externalId`s this pass closed. Same reasoning as `ReconcileResult`. */
+  touched: string[];
   resolved: number;
   needsReview: Array<{ commitmentId: string; documentId: string; quote: string }>;
 }
@@ -389,6 +424,7 @@ export function applyResolutions(
   const byId = new Map(context.documents.map((document) => [document.id, document]));
   const out = commitments.map(cloneCommitment);
   const needsReview: ResolutionResult['needsReview'] = [];
+  const touched = new Set<string>();
   let resolved = 0;
 
   for (const claim of claims) {
@@ -421,6 +457,7 @@ export function applyResolutions(
       best.commitment.statusReason = claim.quote || claim.statement;
       best.commitment.resolvedBy = claim.documentId;
       best.commitment.resolvedAt = at;
+      touched.add(best.commitment.externalId);
       resolved += 1;
     } else {
       // ONE review row per claim — its single best candidate. Listing every open
@@ -433,7 +470,7 @@ export function applyResolutions(
     }
   }
 
-  return { commitments: out, resolved, needsReview };
+  return { commitments: out, touched: [...touched], resolved, needsReview };
 }
 
 // ---------------------------------------------------------------------------

package/src/corpus/extract.ts

@@ -349,9 +349,16 @@ export async function extractCommitments(
   // 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);
+  // 7. write WHAT CHANGED, keyed on `external_id`.
+  //
+  // Not the whole corpus. The tenant has no bulk upsert (a list body is
+  // rejected — see bd startsim-768w.38.12), so every row is a request, and
+  // rewriting untouched rows makes a one-document slice cost one request per row
+  // in the workspace. On the live tenant that took a single-document run past
+  // the 60-second gateway once there were ninety-eight of them.
+  const changed = new Set([...reconciled.touched, ...resolutions.touched]);
+  if (corpus.saveCommitments && changed.size) {
+    await corpus.saveCommitments(resolutions.commitments.filter((item) => changed.has(item.externalId)));
   }
 
   return {