Abandon prior turn on every inference.start

Interrupt mid-inference or mid-tool must not nest the next call under a
stale turn or leave orphan tool spans. Route all turn-close paths through
one closeTurn helper (closeOpenTools + end turn) and cover abandon
restart paths in tests.

Author: TheGreatAxios

src/perf/reactor-spans.test.ts

@@ -175,6 +175,80 @@ describe("createPerfReactorObserver", () => {
     obs.observe(inferenceDone());
     expect(byName(completed(snapshot()), "turn")).toHaveLength(2);
   });
+
+  test("abandon mid-inference then new start closes prior turn with no orphans", () => {
+    const obs = createPerfReactorObserver();
+
+    obs.observe(event("inference.start", { model: "test-model" }));
+    obs.observe(event("inference.text.delta", { token: "partial", partial: { text: "partial" } }));
+    // Interrupt: no inference.done / error — next start must abandon.
+    obs.observe(event("inference.start", { model: "test-model" }));
+    obs.observe(inferenceDone());
+
+    const spans = snapshot();
+    expect(spans.every((s) => s.endNs !== undefined)).toBe(true);
+
+    const turns = byName(completed(spans), "turn");
+    const inferences = byName(completed(spans), "inference");
+    expect(turns).toHaveLength(2);
+    expect(inferences).toHaveLength(2);
+    expect(inferences[0]!.parentId).toBe(turns[0]!.id);
+    expect(inferences[1]!.parentId).toBe(turns[1]!.id);
+    // First turn abandoned before second opened — not nested.
+    expect(turns[0]!.endNs! <= turns[1]!.startNs).toBe(true);
+  });
+
+  test("abandon mid-tool then new start closes open tools and prior turn", () => {
+    const obs = createPerfReactorObserver();
+
+    obs.observe(event("inference.start", { model: "test-model" }));
+    obs.observe(
+      inferenceDone([
+        { type: "tool_call", id: "call-1", name: "run_shell", arguments: {} },
+      ]),
+    );
+    obs.observe(event("tool.start", { call: { id: "call-1", name: "run_shell", arguments: {} } }));
+    // Interrupt mid-tool: no tool.done — next inference.start must not nest.
+    obs.observe(event("inference.start", { model: "next-model" }));
+    obs.observe(inferenceDone());
+
+    const spans = snapshot();
+    expect(spans.every((s) => s.endNs !== undefined)).toBe(true);
+
+    const turns = byName(completed(spans), "turn");
+    const tools = byName(completed(spans), "tool");
+    const inferences = byName(completed(spans), "inference");
+
+    expect(turns).toHaveLength(2);
+    expect(tools).toHaveLength(1);
+    expect(tools[0]!.parentId).toBe(turns[0]!.id);
+    expect(inferences).toHaveLength(2);
+    expect(inferences[0]!.parentId).toBe(turns[0]!.id);
+    expect(inferences[1]!.parentId).toBe(turns[1]!.id);
+    // Second inference must not nest under the abandoned turn.
+    expect(inferences[1]!.parentId).not.toBe(turns[0]!.id);
+    expect(turns[0]!.endNs! <= turns[1]!.startNs).toBe(true);
+  });
+
+  test("inference.error mid-turn then new start leaves no open spans", () => {
+    const obs = createPerfReactorObserver();
+
+    obs.observe(event("inference.start", { model: "test-model" }));
+    obs.observe(event("inference.text.delta", { token: "x", partial: { text: "x" } }));
+    obs.observe(event("inference.error", { error: { message: "timeout" } }));
+
+    // Error with no pending tools closes the turn.
+    expect(snapshot().every((s) => s.endNs !== undefined)).toBe(true);
+
+    obs.observe(event("inference.start", { model: "retry-model" }));
+    obs.observe(inferenceDone());
+
+    const spans = snapshot();
+    expect(spans.every((s) => s.endNs !== undefined)).toBe(true);
+    const turns = byName(completed(spans), "turn");
+    expect(turns).toHaveLength(2);
+    expect(byName(completed(spans), "inference")[1]!.parentId).toBe(turns[1]!.id);
+  });
 });
 
 describe("turn collector durationMs unchanged with perf observer", () => {

src/perf/reactor-spans.ts

@@ -136,14 +136,23 @@ export function createPerfReactorObserver(): PerfReactorObserver {
     state.openTools.clear();
   }
 
+  /**
+   * Single exit for ending a turn: close orphan tool spans, then the turn.
+   * Inference tree must already be closed (or will be via abandonTurn).
+   */
   function closeTurn(): void {
-    closeInferenceTree();
     closeOpenTools();
     endIfOpen(state.turnId);
     state.turnId = null;
     state.pendingTools = 0;
   }
 
+  /** Abandon the whole open tree (inference + tools + turn). */
+  function abandonTurn(): void {
+    closeInferenceTree();
+    closeTurn();
+  }
+
   function ensureTurn(): string {
     if (state.turnId === null) {
       state.turnId = start("turn");
@@ -163,17 +172,10 @@ export function createPerfReactorObserver(): PerfReactorObserver {
     const type = event.type;
 
     if (type === "inference.start") {
-      // Close a prior inference that never got done/error (defensive).
-      if (state.inferenceId !== null) {
-        closeInferenceTree();
-      }
-      // New model call after a fully finished turn: open a fresh top-level turn.
-      // If tools are still pending, nest under the open turn (should not happen
-      // under DefaultDirector, which re-infers only after all tool.done).
-      if (state.turnId !== null && state.pendingTools === 0) {
-        endIfOpen(state.turnId);
-        state.turnId = null;
-      }
+      // Always abandon any prior turn before opening a new one. Interrupt mid-
+      // inference or mid-tool must not nest the next call under a stale turn or
+      // leave orphan tool spans in the process-wide open map.
+      abandonTurn();
       const turnId = ensureTurn();
       const tags = modelTags(event);
       state.inferenceId = start("inference", {
@@ -195,8 +197,7 @@ export function createPerfReactorObserver(): PerfReactorObserver {
       closeInferenceTree(tags);
       state.pendingTools = toolCallCount(event);
       if (state.pendingTools === 0) {
-        endIfOpen(state.turnId);
-        state.turnId = null;
+        closeTurn();
       }
       return;
     }
@@ -206,8 +207,7 @@ export function createPerfReactorObserver(): PerfReactorObserver {
       // Drop the turn if nothing is waiting on tools; otherwise keep it open
       // so in-flight tool spans can still close under it.
       if (state.pendingTools === 0) {
-        endIfOpen(state.turnId);
-        state.turnId = null;
+        closeTurn();
       }
       return;
     }
@@ -246,16 +246,14 @@ export function createPerfReactorObserver(): PerfReactorObserver {
         state.pendingTools -= 1;
       }
       if (state.pendingTools === 0 && state.inferenceId === null && state.turnId !== null) {
-        closeOpenTools();
-        endIfOpen(state.turnId);
-        state.turnId = null;
+        closeTurn();
       }
       return;
     }
   }
 
   function reset(): void {
-    closeTurn();
+    abandonTurn();
     state = emptyState();
   }