fix(tui): quit-abort ordering, phantom folds, reset generation guard (#1130)

Abort before shutdown on quit; gate onFolded/telemetry on abort;
generation counter for stale settles; reloadIfIdle reset guard.
CL-8570, CL-8571.

Author: TheGreatAxios

src/session/compaction-lifecycle.test.ts

@@ -361,4 +361,52 @@ describe("createCompactionLifecycle", () => {
     expect(seen).toHaveLength(1);
     expect(seen[0]?.aborted).toBe(true);
   });
+
+  test("a stale settle cannot clear a newer compact's flag or emit its end", async () => {
+    const ends: string[] = [];
+    const lifecycle = createCompactionLifecycle({
+      onCompactionStart: () => ends.push("start"),
+      onCompactionEnd: (info) => ends.push(`end:${info.aborted}`),
+    });
+    let releaseStale!: (result: StrategyResult<ConversationTurn[]>) => void;
+    let releaseCurrent!: (result: StrategyResult<ConversationTurn[]>) => void;
+    let calls = 0;
+    const inner: Compactor = {
+      name: "inner",
+      version: "0",
+      apply: () => {
+        calls += 1;
+        if (calls === 1) {
+          return new Promise<StrategyResult<ConversationTurn[]>>((resolve) => {
+            releaseStale = resolve;
+          });
+        }
+        return new Promise<StrategyResult<ConversationTurn[]>>((resolve) => {
+          releaseCurrent = resolve;
+        });
+      },
+    };
+    const wrapped = lifecycle.wrapCompactor(inner);
+    const input = turns(8);
+    const stale = wrapped.apply(input, ctx);
+    expect(lifecycle.isCompacting()).toBe(true);
+    // A rebuild lands mid-compact: the replacement agent gets a fresh signal
+    // while the old compact is still in flight.
+    lifecycle.reset();
+    expect(lifecycle.isCompacting()).toBe(false);
+    const current = wrapped.apply(input, ctx);
+    expect(lifecycle.isCompacting()).toBe(true);
+    // The stale compact settles late: the flag stays up for the newer compact
+    // and no end event fires for the already-reset generation.
+    releaseStale(okResult(input));
+    await stale;
+    expect(lifecycle.isCompacting()).toBe(true);
+    expect(ends).toEqual(["start", "start"]);
+    // The newer compact still settles normally.
+    releaseCurrent(okResult(input));
+    const settled = await current;
+    expect(settled.record.reason).toBe("folded");
+    expect(lifecycle.isCompacting()).toBe(false);
+    expect(ends).toEqual(["start", "start", "end:false"]);
+  });
 });

src/session/compaction-lifecycle.ts

@@ -88,6 +88,13 @@ export function createCompactionLifecycle(
 ): CompactionLifecycle {
   let controller = new AbortController();
   let compacting = false;
+  // Settle generation: every started compact and every reset mints a new
+  // generation, and a settle only clears the flag / emits the end event when
+  // its generation is still current. Without this, a stale settle (an aborted
+  // compact whose loser promise resolves after abort + reset + a newer
+  // compact started) would clear the newer compact's in-flight flag and emit
+  // a duplicate end event for a compact that is already over.
+  let generation = 0;
 
   return {
     getSignal: () => controller.signal,
@@ -98,6 +105,7 @@ export function createCompactionLifecycle(
     reset: (): void => {
       controller = new AbortController();
       compacting = false;
+      generation += 1;
     },
     wrapCompactor: (inner: Compactor): Compactor => ({
       name: inner.name,
@@ -108,6 +116,8 @@ export function createCompactionLifecycle(
         // compact): skip the inner run entirely, without lifecycle events —
         // the interrupting path already told the operator what happened.
         if (signal.aborted) return abortedResult(inner, turns);
+        generation += 1;
+        const settledGeneration = generation;
         compacting = true;
         events.onCompactionStart?.();
         let aborted = false;
@@ -139,8 +149,13 @@ export function createCompactionLifecycle(
               signal.removeEventListener("abort", onAbort);
           }
         } finally {
-          compacting = false;
-          events.onCompactionEnd?.({ aborted });
+          // A stale settle (abort + reset + a newer compact started while
+          // this one was still in flight) must not clear the newer compact's
+          // flag or emit an end event for a compact that is already over.
+          if (settledGeneration === generation) {
+            compacting = false;
+            events.onCompactionEnd?.({ aborted });
+          }
         }
       },
     }),

src/session/runtime-assembly.test.ts

@@ -31,6 +31,7 @@ import {
 } from "./runtime-assembly.js";
 import type { SubAgentSourcesConfig } from "./runtime-assembly.js";
 import type { Settings } from "../config/settings.js";
+import type { Telemetry } from "../telemetry/index.js";
 import { generateSessionId, initSessionDir, sessionDir } from "./index.js";
 import type { PluginModule } from "../plugins/loader.js";
 
@@ -522,6 +523,53 @@ describe("createSessionPruningCompactor", () => {
     await noop.apply(few as never, { state: {} as never, trigger: "test" });
     expect(silent).toEqual([]);
   });
+
+  test("a discarded fold emits no telemetry and no onFolded", async () => {
+    const captured: { event: string }[] = [];
+    const folds: { turnsBefore: number; turnsAfter: number }[] = [];
+    const telemetry: Telemetry = {
+      enabled: true,
+      installationId: "test",
+      capture: (event) => {
+        captured.push({ event });
+      },
+      captureIntentional: () => false,
+      flush: async () => undefined,
+      discard: () => undefined,
+    };
+    // Bound to the lifecycle signal in production: true once the outer abort
+    // race has discarded (or will discard) this run's output.
+    let aborted = false;
+    const compactor = createSessionPruningCompactor({
+      summarize: async () => "summary",
+      telemetry,
+      onFolded: (info) => folds.push(info),
+      isAborted: () => aborted,
+    });
+    const now = Date.now();
+    const many = Array.from({ length: 8 }, (_, i) => ({
+      role: i % 2 === 0 ? "user" : "assistant",
+      content: [{ type: "text", text: `t${i}` }],
+      timestamp: now,
+    }));
+    // A live fold still reports…
+    const folded = await compactor.apply(many as never, {
+      state: {} as never,
+      trigger: "test",
+    });
+    expect(folds).toHaveLength(1);
+    expect(captured.map((entry) => entry.event)).toEqual(["compaction"]);
+    // …but a fold the lifecycle discarded reports nothing, while the output
+    // itself still passes through untouched (fold semantics unchanged).
+    aborted = true;
+    const discarded = await compactor.apply(many as never, {
+      state: {} as never,
+      trigger: "test",
+    });
+    expect(discarded.output).toEqual(folded.output);
+    expect(folds).toHaveLength(1);
+    expect(captured.map((entry) => entry.event)).toEqual(["compaction"]);
+  });
 });
 
 describe("buildCompactionContinuationMessage", () => {

src/session/runtime-assembly.ts

@@ -57,6 +57,7 @@ import {
 } from "./compactor.js";
 import type { SummaryContext } from "./summarizer.js";
 import { NOOP_TELEMETRY, type Telemetry } from "../telemetry/index.js";
+import { COMPACTION_ABORTED_REASON } from "./compaction-lifecycle.js";
 
 // ---------------------------------------------------------------------------
 // 1. Sub-agent provider literal
@@ -380,6 +381,13 @@ export interface SessionPruningCompactorArgs {
   telemetry?: Telemetry;
   /** Fires only when turns were actually folded away — not on no-ops. */
   onFolded?: (info: { turnsBefore: number; turnsAfter: number }) => void;
+  /**
+   * True when the lifecycle has discarded (or will discard) the in-flight
+   * compact — e.g. bound to the session compaction lifecycle's signal. A
+   * fold the outer abort race threw away must report nothing: no telemetry,
+   * no onFolded side effects for work that never landed.
+   */
+  isAborted?: () => boolean;
 }
 
 /** Shared pruning-compactor defaults for the main session agent. */
@@ -399,6 +407,16 @@ export function createSessionPruningCompactor(
       const turnsBefore = turns.length;
       const startedAt = Date.now();
       const result = await compactor.apply(turns, ctx);
+      // A discarded compact reports nothing. When the lifecycle abort wins
+      // the outer race, this inner run may still complete with a genuine
+      // fold — but the reactor threw that output away, so emitting telemetry
+      // or onFolded would describe work that never landed (phantom fold).
+      if (
+        args.isAborted?.() === true ||
+        result.record.reason === COMPACTION_ABORTED_REASON
+      ) {
+        return result;
+      }
       // summarizedTurnCount is only set on the branch that actually folded
       // turns away. The other branch is a no-op (or image aging alone), and
       // reporting it as compaction would drag the duration and turn-count