V48 Gate 3 (implementation-only): stitch-repair validation errors stream as in-band 'repair', not terminal 'error' — stop marking actively-repairing runs failed

Run 61c3b0cf: the synthesis agent's plan step returned output missing the
required 'options' array; StitchUntilComplete recorded the zod error
(store('validation','error', …)) and began its bounded repair — exactly its
job. But ExecutionStreamAdapter.inferEventType typed any key==='error' store
as a terminal 'error' event, so: the SSE tail closed (usePipelineExecution
sawTerminal), the activity builder surfaced the zod message as the run error,
and /deposit flipped to failed — while the pipeline repaired and kept running
(sidecar shows it deep in validation and a second fail-closed iteration,
zero errors, 18+ minutes past the false verdict).

- ExecutionStreamAdapter: new REPAIR='repair' stream type;
  'validation'/'error' stores (the stitch loop's about-to-repair record, its
  only producer) classify as REPAIR. Genuine terminals are unchanged:
  namespace 'error' stores, the route catch's explicit error emitEvent, and
  stitching/error (stored immediately before the stitch-exceeded throw).
- Legacy-row hardening (rows persisted before this fix are typed 'error' with
  namespace 'validation'): usePipelineExecution no longer treats them as
  terminal, buildTerminalRunActivityFromEvents no longer surfaces them as the
  run error, and the /api/executions/stream tail no longer closes on them —
  so reloading a mid-repair run resumes tailing to its real outcome.

Verified: execution-generics adapter suite 15 green (incl. new repair
classification test); uapi full suite 155 suites / 599 tests green (incl.
new tail-past-repair and run-error regression tests); pipelines-generics
streaming 46 green; tsc clean.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: geraldarthurdavis

packages/execution-generics/src/__tests__/execution-stream-adapter.test.ts

@@ -108,6 +108,15 @@ describe('ExecutionStreamAdapter — event type inference', () => {
     expect(await inferredType('misc', 'completion')).toBe('completion');
     expect(await inferredType('misc', 'anything')).toBe('status');
   });
+
+  it("classifies the stitch failsafe's validation error as in-band 'repair', not terminal 'error'", async () => {
+    // The stitch loop stores the schema error it is ABOUT TO REPAIR
+    // (store('validation','error', …)); typing it 'error' made stream
+    // consumers mark an actively-repairing run as failed.
+    expect(await inferredType('validation', 'error', 'options: Required')).toBe('repair');
+    // Other validation stores stay status.
+    expect(await inferredType('validation', 'result', { passed: true })).toBe('status');
+  });
 });
 
 describe('ExecutionStreamAdapter — event payload shape', () => {

packages/execution-generics/src/storage/ExecutionStreamAdapter.ts

@@ -24,6 +24,9 @@ export enum ExecutionStreamEventType {
   COMPLETION = 'completion',
   STATUS = 'status',
   WORK_UPDATE = 'work-update',
+  // In-band failsafe repair work (e.g. the stitch loop recording the
+  // validation error it is about to repair) — NOT a terminal failure.
+  REPAIR = 'repair',
 }
 
 /**
@@ -189,6 +192,16 @@ export class ExecutionStreamAdapter {
       return ExecutionStreamEventType.THINKING;
     }
 
+    // Failsafe repair context: the stitch loop stores the schema-validation
+    // error it is ABOUT TO REPAIR ('validation'/'error') before running its
+    // bounded repair generations. That is in-band failsafe work, not a
+    // terminal failure — typing it 'error' made stream consumers treat an
+    // actively-repairing run as failed (tail closed, run marked failed) while
+    // the pipeline kept working.
+    if (namespace === 'validation' && key === 'error') {
+      return ExecutionStreamEventType.REPAIR;
+    }
+
     // Errors
     if (namespace === 'error' || key === 'error') {
       return ExecutionStreamEventType.ERROR;

uapi/app/api/executions/stream/route.ts

@@ -9,6 +9,22 @@ const MAX_TAIL_MS = 5 * 60 * 1000;
 const TERMINAL_EVENT_TYPES = new Set(['completion', 'error']);
 const TERMINAL_EXECUTION_STATUSES = new Set(['completed', 'failed', 'cancelled']);
 
+/**
+ * A 'validation'-namespace error row is the stitch failsafe recording the
+ * schema error it is actively repairing — in-band failsafe work, not a
+ * terminal failure. New events stream as type 'repair' (ExecutionStreamAdapter),
+ * but rows persisted before that fix are still typed 'error' and must not end
+ * the tail of a run that is still working.
+ */
+function isLegacyRepairErrorRow(eventType: string, eventData: unknown): boolean {
+  return (
+    eventType === 'error' &&
+    Boolean(eventData) &&
+    typeof eventData === 'object' &&
+    (eventData as Record<string, unknown>).namespace === 'validation'
+  );
+}
+
 /**
  * Row-backed frames carry the execution_events row's insert-time `created_at`
  * as the standard SSE `id:` line. The tail filters rows with
@@ -119,7 +135,10 @@ export async function GET(request: Request) {
             for (const event of events || []) {
               cursor = event.created_at;
               send((event.event_data as Record<string, unknown>) || { type: event.event_type }, event.created_at);
-              if (TERMINAL_EVENT_TYPES.has(String(event.event_type))) {
+              if (
+                TERMINAL_EVENT_TYPES.has(String(event.event_type)) &&
+                !isLegacyRepairErrorRow(String(event.event_type), event.event_data)
+              ) {
                 sawTerminalEvent = true;
               }
             }

uapi/app/terminal/terminal-run-activity.ts

@@ -186,7 +186,14 @@ export function buildTerminalRunActivityFromEvents(
   const normalizedIterationUpdates = new Map<number | string, any>();
   const statusEvents = events.filter((entry) => entry.event?.type === 'status');
   const completionEvent = events.find((entry) => entry.event?.type === 'completion');
-  const errorEvent = events.find((entry) => entry.event?.type === 'error');
+  // The run error is a GENUINE terminal error only. A 'validation'-namespace
+  // error is the stitch failsafe recording the schema error it is actively
+  // repairing (streamed as type 'repair' since the ExecutionStreamAdapter fix;
+  // rows persisted before it are still typed 'error') — surfacing it as the
+  // run error marked an actively-repairing run as failed.
+  const errorEvent = events.find(
+    (entry) => entry.event?.type === 'error' && entry.event?.namespace !== 'validation',
+  );
 
   for (const update of iterationUpdates || []) {
     if (update && typeof update.iteration !== 'undefined') {

uapi/hooks/usePipelineExecution.ts

@@ -159,7 +159,16 @@ export function usePipelineExecution(runId: string | null): UsePipelineExecution
                     if (payload.type === 'work-update') {
                       recordWorkUpdate(payload);
                     }
-                    if (payload.type === 'completion' || payload.type === 'error') {
+                    // Terminal detection: completion, or a genuine error. A
+                    // 'validation'-namespace error is the stitch failsafe
+                    // recording the schema error it is actively repairing —
+                    // new events stream as type 'repair', but rows persisted
+                    // before that fix are still typed 'error' and must not
+                    // close the tail of a run that is still working.
+                    if (
+                      payload.type === 'completion' ||
+                      (payload.type === 'error' && payload.namespace !== 'validation')
+                    ) {
                       sawTerminal = true;
                     }
                     const createdAt =

uapi/tests/terminalTransactionActivity.test.ts

@@ -299,6 +299,44 @@ describe('terminal-run-activity helpers', () => {
     expect(snapshot.iterationUpdates.find((u: any) => u.iteration === 2)?.confidence).toBe(0.8);
   });
 
+  it("ignores a legacy 'error'-typed validation repair event as the run error, but keeps genuine errors", () => {
+    // Rows persisted before the ExecutionStreamAdapter repair fix: the stitch
+    // failsafe's validation error arrived typed 'error' with namespace
+    // 'validation' — the run was still actively repairing, not failed.
+    const repairOnly = buildTerminalRunActivityFromEvents(
+      [
+        {
+          id: 'e1',
+          created_at: '2026-07-03T19:12:29.447Z',
+          event: {
+            type: 'error',
+            namespace: 'validation',
+            key: 'error',
+            message: '[{"path":["options"],"message":"Required"}]',
+          },
+        },
+      ] as any,
+      null,
+      [],
+      null,
+    );
+    expect(repairOnly.error).toBeNull();
+
+    const genuine = buildTerminalRunActivityFromEvents(
+      [
+        {
+          id: 'e2',
+          created_at: '2026-07-03T19:13:00.000Z',
+          event: { type: 'error', message: 'synthesis failed' },
+        },
+      ] as any,
+      null,
+      [],
+      null,
+    );
+    expect(genuine.error).toBe('synthesis failed');
+  });
+
   it('uses explicit stream error and mock snapshots', () => {
     const liveErrorSnapshot = buildTerminalRunActivityFromEvents([], null, [], 'Stream failed');
     expect(liveErrorSnapshot.error).toBe('Stream failed');

uapi/tests/usePipelineExecution.test.tsx

@@ -247,6 +247,49 @@ describe('usePipelineExecution', () => {
     expect(streamUrls.length).toBe(1);
   });
 
+  it("keeps tailing past a legacy 'error'-typed validation repair event (stitch failsafe at work)", async () => {
+    const historyResponse = {
+      run: { id: 'r5b', user_id: 'user-1', created_at: '2026-07-01T00:00:00.000Z', items: [], context: {} },
+      events: [],
+    };
+    const streamUrls: string[] = [];
+
+    global.fetch = jest.fn((request: RequestInfo) => {
+      const url = typeof request === 'string' ? request : (request as Request)?.url ?? '';
+      if (url.startsWith('/api/executions/history/')) {
+        return Promise.resolve({ ok: true, json: async () => historyResponse } as any);
+      }
+      if (url.startsWith('/api/executions/stream')) {
+        streamUrls.push(url);
+        if (streamUrls.length === 1) {
+          // Rows persisted before the ExecutionStreamAdapter repair fix: the
+          // stitch loop's validation error arrived typed 'error' with
+          // namespace 'validation' — the run is still actively repairing.
+          return Promise.resolve(
+            sseResponse([
+              'id: 2026-07-01T00:00:01.000Z\ndata: {"type":"error","namespace":"validation","key":"error","message":"options: Required","timestamp":"2026-07-01T00:00:01.000Z"}\n\n',
+            ]),
+          );
+        }
+        // The tail reconnects and receives the run's real completion.
+        return Promise.resolve(
+          sseResponse([
+            'id: 2026-07-01T00:00:02.000Z\ndata: {"type":"completion","message":"done","timestamp":"2026-07-01T00:00:02.000Z"}\n\n',
+          ]),
+        );
+      }
+      throw new Error(`Unexpected fetch: ${url}`);
+    }) as any;
+
+    let latest: any;
+    render(<Harness runId="r5b" onResult={(state) => (latest = state)} />);
+
+    await waitFor(() =>
+      expect(latest?.events.some((e: any) => e.event?.type === 'completion')).toBe(true),
+    );
+    expect(streamUrls.length).toBeGreaterThanOrEqual(2);
+  });
+
   it('bounds the reconnect loop after repeated empty tail windows', async () => {
     const historyResponse = {
       run: { id: 'r6', user_id: 'user-1', created_at: '2026-07-01T00:00:00.000Z', items: [], context: {} },