fix(examples-chat): retry checkpoint push only on 409, capped (review)

Address final-review findings: the retry now discriminates — only a mid-run
409 (conflict) is retried, and only up to MAX_PUSH_RETRIES, so a persistently
failing thread (404/auth/500) can't spin an unbounded background loop. Track
the retry timer, and correct the now-stale run-gated/500ms comment. Adds
isConflict unit tests.

Author: blove

examples/chat/angular/src/app/shell/demo-shell.component.spec.ts

@@ -9,7 +9,7 @@ import {
   FakeStreamTransport,
   type AgentTransport,
 } from '@threadplane/langgraph';
-import { DemoShell, shouldSyncCheckpoint, extractItinerary } from './demo-shell.component';
+import { DemoShell, shouldSyncCheckpoint, extractItinerary, isConflict } from './demo-shell.component';
 import { DEMO_AGENT_REF } from './agent-ref';
 import { ItineraryStore, type ItineraryStop } from '../itinerary-store';
 
@@ -543,6 +543,22 @@ describe('shouldSyncCheckpoint — push-gate predicate', () => {
   });
 });
 
+describe('isConflict — retry only the mid-run 409', () => {
+  it('is true for a 409 status', () => {
+    expect(isConflict({ status: 409 })).toBe(true);
+  });
+
+  it('is true when the message mentions 409/conflict', () => {
+    expect(isConflict(new Error('Request failed: 409 Conflict'))).toBe(true);
+  });
+
+  it('is false for other errors (terminal — do not retry)', () => {
+    expect(isConflict({ status: 404 })).toBe(false);
+    expect(isConflict(new Error('Unauthorized'))).toBe(false);
+    expect(isConflict(null)).toBe(false);
+  });
+});
+
 describe('extractItinerary — value → stops', () => {
   it('returns the itinerary array from a state value', () => {
     const stops: ItineraryStop[] = [{ id: 'x', day: 1, place: 'Louvre' }];

examples/chat/angular/src/app/shell/demo-shell.component.ts

@@ -112,6 +112,19 @@ export function extractItinerary(value: unknown): ItineraryStop[] | null {
   return null;
 }
 
+/** Cap on checkpoint-push retries — a backstop so a persistently-failing thread
+ *  can't spin an unbounded background retry loop. */
+export const MAX_PUSH_RETRIES = 20;
+
+/** A mid-run `updateState` returns HTTP 409 (the client-tool resume loop is
+ *  streaming); that is the ONLY error worth retrying. Any other failure
+ *  (404/auth/500) is terminal for this best-effort sync. */
+export function isConflict(err: unknown): boolean {
+  const status = (err as { status?: number })?.status;
+  if (status === 409) return true;
+  return /\b409\b|conflict/i.test(String((err as { message?: string })?.message ?? err));
+}
+
 @Component({
   selector: 'demo-shell',
   standalone: true,
@@ -272,31 +285,34 @@ export class DemoShell {
       this.itinerary.hydrate(incoming);
     });
 
-    // (3) Push the working copy to the checkpoint at run-settle and on user
-    // edits between runs. Run-gated (never mid-run) + debounced (~500ms).
-    // Depends on stops(), isLoading() (so it re-fires when a run SETTLES), and
-    // threadIdState(). Errors are swallowed — this is a best-effort sync.
+    // (3) Push the working copy to the durable checkpoint on every change.
+    // NOT run-gated: the client-tool resume loop keeps the agent loading for
+    // the whole plan, so a mid-run write returns 409 — retry ONLY that (bounded
+    // by MAX_PUSH_RETRIES) until the run settles so the final itinerary always
+    // lands. Debounced ~1200ms; onCleanup cancels a superseded attempt. Any
+    // non-conflict error is terminal — this is a best-effort sync, not a queue.
     effect((onCleanup) => {
       const stops = this.itinerary.stops();
       const tid = threadIdState();
       const json = JSON.stringify(stops);
       if (!shouldSyncCheckpoint(tid, json, this.lastSyncedItinerary)) return;
-      // Debounce, then push. A mid-run write returns 409 (the client-tool resume
-      // loop is streaming); retry until the run settles so the FINAL itinerary
-      // always lands in the checkpoint. onCleanup cancels a superseded attempt.
       let cancelled = false;
+      let retries = 0;
+      let timer: ReturnType<typeof setTimeout>;
       const attempt = async (): Promise<void> => {
         if (cancelled) return;
         try {
           await this.lgClient.threads.updateState(tid as string, {
             values: { itinerary: stops },
           });
           this.lastSyncedItinerary = json;
-        } catch {
-          if (!cancelled) setTimeout(() => void attempt(), 1500);
+        } catch (err) {
+          if (!cancelled && isConflict(err) && retries++ < MAX_PUSH_RETRIES) {
+            timer = setTimeout(() => void attempt(), 1500);
+          }
         }
       };
-      const timer = setTimeout(() => void attempt(), 1200);
+      timer = setTimeout(() => void attempt(), 1200);
       onCleanup(() => {
         cancelled = true;
         clearTimeout(timer);