refactor(runtime): drop the boundary-revision backend watcher (#3349)

Review finding: the boundary revision is not a backend-composition
fingerprint — an approved sandbox expansion increments it too, and
expansions are consumed live per dispatch by design, changing neither
model nor backend-composed configuration. The watcher therefore paid a
durable read on every activation and rebuilt backend, transport and
composer state after every valid expansion, while defending against a
writer that does not exist: configuration transitions already own their
backend disposal and invalidation.

Remove boundaryRevision, readBoundaryRevision and
resolveReusableGeneration (ensureActive returns to plain reuse), the two
forced-revision self-heal tests, and the fixed-seed sweep — its
interleaving classes stay covered by the direct deterministic tests:
claim/run waiting, successor admission, the admission-gate deadlock,
immediate tightening at the current dispatch, shell lineage fencing, and
the mixed-configuration regression.

Generated-by: ZCode (Z.ai GLM)

Author: chinawch007

packages/runtime/src/__tests__/session-manager.test.ts

@@ -5123,93 +5123,7 @@ describe('SessionManager permission mode updates', () => {
     expect(builtPermissionModes).toEqual(['ask', 'bypass']);
   });
 
-  test('a boundary revision bump without backend disposal rebuilds on the next activation', async () => {
-    const store = new MemorySessionStore();
-    const runStore = new MemoryAgentRunStore();
-    const backends = new BackendRegistry();
-    let builds = 0;
-    backends.register('ai-sdk', (ctx) => {
-      builds += 1;
-      return new TestBackend(ctx);
-    });
-    const manager = new SessionManager({
-      store,
-      runStore,
-      runtimeEventStore: runStore,
-      backends,
-      newId: nextId(),
-      now: nextNow(8_000),
-    });
-    const session = await manager.createSession(makeInput({ permissionMode: 'ask' }));
-
-    await drain(manager.sendMessage(session.id, { turnId: 'turn-1', text: 'one' }));
-    expect(builds).toBe(1);
-
-    // A write path that skips backend disposal bumps the durable boundary
-    // while the generation stays alive.
-    store.forceExecutionBoundary(session.id, { kind: 'bypass', revision: 5 });
-
-    await drain(manager.sendMessage(session.id, { turnId: 'turn-2', text: 'two' }));
-    expect(builds).toBe(2);
-    expect(store.disposeCount).toBe(1);
-
-    // Once rebuilt against the current revision, the generation is reused again.
-    await drain(manager.sendMessage(session.id, { turnId: 'turn-3', text: 'three' }));
-    expect(builds).toBe(2);
-  });
-
-  test('a stale generation with live runs flushes after they exit instead of disposing underneath them', async () => {
-    const store = new MemorySessionStore();
-    const runStore = new MemoryAgentRunStore();
-    const backends = new BackendRegistry();
-    const gates: Gate[] = [];
-    let builds = 0;
-    backends.register('ai-sdk', (ctx) => {
-      builds += 1;
-      const gate = makeGate();
-      gates.push(gate);
-      return new TestBackend(ctx, gate);
-    });
-    const manager = new SessionManager({
-      store,
-      runStore,
-      runtimeEventStore: runStore,
-      backends,
-      newId: nextId(),
-      now: nextNow(8_000),
-    });
-    const session = await manager.createSession(makeInput({ permissionMode: 'ask' }));
-
-    const first = manager
-      .sendMessage(session.id, { turnId: 'turn-1', text: 'one' })
-      [Symbol.asyncIterator]();
-    expect((await first.next()).value?.type).toBe('text_delta');
-    expect(builds).toBe(1);
 
-    store.forceExecutionBoundary(session.id, { kind: 'bypass', revision: 5 });
-
-    // An overlapping activation while turn 1 is live must not dispose the
-    // generation underneath it: the generation is marked, reused for this
-    // turn, and flushed once both runs exit. Both turns share the reused
-    // backend, so a single gate holds them both.
-    const second = manager
-      .sendMessage(session.id, { turnId: 'turn-2', text: 'two' })
-      [Symbol.asyncIterator]();
-    expect((await second.next()).value?.type).toBe('text_delta');
-    expect(builds).toBe(1);
-
-    gates[0]!.release();
-    while (!(await first.next()).done) {}
-    while (!(await second.next()).done) {}
-
-    const third = manager
-      .sendMessage(session.id, { turnId: 'turn-3', text: 'three' })
-      [Symbol.asyncIterator]();
-    expect((await third.next()).value?.type).toBe('text_delta');
-    gates[1]!.release();
-    while (!(await third.next()).done) {}
-    expect(builds).toBe(2);
-  });
 
   test('narrowing with an active descendant commits promptly and fences the lineage shells', async () => {
     const store = new MemorySessionStore();
@@ -5519,88 +5433,6 @@ describe('SessionManager permission mode updates', () => {
     expect(dispatch.permissionMode).toBe('bypass');
   });
 
-  test('seeded switch/turn interleavings always observe the committed mode', async () => {
-    // A fixed-seed PRNG picks the interleaving class per iteration; every
-    // checkpoint awaits a deterministic event, so the sweep is reproducible.
-    let seed = 0x3349;
-    const random = (): number => {
-      seed = (seed * 1_103_515_245 + 12_345) % 2_147_483_648;
-      return seed / 2_147_483_648;
-    };
-
-    const store = new MemorySessionStore();
-    const runStore = new MemoryAgentRunStore();
-    const backends = new BackendRegistry();
-    const gates: Gate[] = [];
-    const composedModes: SessionHeader['permissionMode'][] = [];
-    backends.register('ai-sdk', (ctx) => {
-      const gate = makeGate();
-      gates.push(gate);
-      composedModes.push(ctx.header.permissionMode);
-      return new TestBackend(ctx, gate);
-    });
-    const manager = new SessionManager({
-      store,
-      runStore,
-      runtimeEventStore: runStore,
-      backends,
-      // Narrowing (bypass → ask) fences shell runs through this authority.
-      shellRuns: {
-        async terminateSession() {
-          return undefined;
-        },
-        async commitSessionClose() {},
-        rollbackSessionClose() {},
-        resumeSession() {},
-      } as never,
-      newId: nextId(),
-      now: nextNow(9_000),
-    });
-    const session = await manager.createSession(makeInput({ permissionMode: 'ask' }));
-
-    let expected: 'ask' | 'bypass' = 'ask';
-    let turnCount = 0;
-    for (let iteration = 0; iteration < 100; iteration += 1) {
-      const nextMode: 'ask' | 'bypass' = random() < 0.5 ? 'bypass' : 'ask';
-      const interleaving = Math.floor(random() * 3);
-
-      if (interleaving === 0) {
-        // Switch while the session is idle.
-        await manager.setPermissionMode(session.id, nextMode);
-        expected = nextMode;
-      } else {
-        // Switch requested while a turn is running; the queued commit lands
-        // in the gap as the turn settles (class 1 requests it mid-flight,
-        // class 2 races it with the gate release).
-        turnCount += 1;
-        const turn = manager
-          .sendMessage(session.id, { turnId: `turn-${turnCount}`, text: `t${turnCount}` })
-          [Symbol.asyncIterator]();
-        expect((await turn.next()).value?.type).toBe('text_delta');
-        const switching = manager.setPermissionMode(session.id, nextMode);
-        if (interleaving === 2) gates[gates.length - 1]!.release();
-        if (interleaving === 1) gates[gates.length - 1]!.release();
-        while (!(await turn.next()).done) {}
-        await switching;
-        expected = nextMode;
-      }
-
-      // Invariant: every turn started after the switch resolved is composed
-      // from the committed mode, and a tool call against the committed store
-      // derives the same mode.
-      turnCount += 1;
-      const verify = manager
-        .sendMessage(session.id, { turnId: `turn-${turnCount}`, text: `t${turnCount}` })
-        [Symbol.asyncIterator]();
-      expect((await verify.next()).value?.type).toBe('text_delta');
-      expect(composedModes[composedModes.length - 1]).toBe(expected);
-      const dispatch = await dispatchProbeTool(store, session.id);
-      expect(dispatch.boundaryKind).toBe(expected === 'bypass' ? 'bypass' : 'managed');
-      expect(dispatch.permissionMode).toBe(expected);
-      gates[gates.length - 1]!.release();
-      while (!(await verify.next()).done) {}
-    }
-  });
 
   test('leaving explore clears the deep research label so visible read-only copy stays truthful', async () => {
     const store = new MemorySessionStore();
@@ -17218,11 +17050,6 @@ class MemorySessionStore implements SessionStore {
     return boundary;
   }
 
-  /** Simulates a config write path that bumps the boundary without disposing backends. */
-  forceExecutionBoundary(sessionId: string, boundary: ExecutionBoundary): void {
-    this.executionBoundaries.set(sessionId, boundary);
-  }
-
   async createSandboxBoundaryRequest(
     input: CreateSandboxBoundaryRequest,
   ): Promise<SandboxBoundaryRequest> {

packages/runtime/src/runtime-kernel.ts

@@ -319,13 +319,6 @@ interface BackendGeneration extends AgentRunActiveSession {
     | { kind: 'failed'; error: unknown };
   disposal?: Promise<BackendDisposalOutcome>;
   disposalFailure?: Error;
-  /**
-   * The durable boundary revision this generation was composed against.
-   * `ensureActive` compares it against the store to rebuild when a config
-   * write skipped backend disposal; `undefined` (unreadable at build) keeps
-   * the guard dormant for this generation.
-   */
-  boundaryRevision?: number;
   cachedHeader: SessionHeader;
   activeRuns: Map<string, AgentRun>;
   turnToRunId: Map<string, string>;
@@ -2844,27 +2837,16 @@ export class RuntimeKernel implements RuntimeKernelLike {
     execution: PendingExecutionClaim,
   ): Promise<BackendGeneration> {
     await this.clearBackendQuarantineForActivation(sessionId, execution);
-    // The boundary revision this activation is composed against. Recorded on
-    // the generation so a later activation can detect a config write that
-    // skipped backend disposal (#3349). An unreadable boundary leaves the
-    // guard dormant rather than blocking activation.
-    const boundaryRevision = await this.readBoundaryRevision(sessionId);
     let existing = this.active.get(sessionId);
     if (existing) {
-      const reusable = await this.resolveReusableGeneration(sessionId, existing, boundaryRevision);
-      if (reusable) {
-        reusable.cachedHeader = header;
-        return reusable;
-      }
+      existing.cachedHeader = header;
+      return existing;
     }
     await this.waitForBackendDisposal(sessionId);
     existing = this.active.get(sessionId);
     if (existing) {
-      const reusable = await this.resolveReusableGeneration(sessionId, existing, boundaryRevision);
-      if (reusable) {
-        reusable.cachedHeader = header;
-        return reusable;
-      }
+      existing.cachedHeader = header;
+      return existing;
     }
     const entry = await this.shareBackendActivation(`parent:${sessionId}`, async () => {
       const current = this.active.get(sessionId);
@@ -2898,54 +2880,10 @@ export class RuntimeKernel implements RuntimeKernelLike {
       this.active.set(sessionId, generation);
       return generation;
     });
-    // Concurrent activations share one build; the first to arrive stamps the
-    // revision it read. That stamp may trail the revision actually composed
-    // against (the reader ran before the builder) — safe direction: a later
-    // activation rebuilds once more, never reuses a newer composition blindly.
-    entry.boundaryRevision ??= boundaryRevision;
     entry.cachedHeader = header;
     return entry;
   }
 
-  private async readBoundaryRevision(sessionId: string): Promise<number | undefined> {
-    // One dedicated store read per activation: cheaper than widening the
-    // session header read the turn already performs, and the guard is optional
-    // defense in depth — an unreadable boundary simply leaves it dormant.
-    try {
-      return (await this.deps.store.readExecutionBoundary(sessionId)).revision;
-    } catch {
-      return undefined;
-    }
-  }
-
-  /**
-   * Defense in depth against a config write that bumped the durable boundary
-   * without disposing the backend generation it was composed against: dispose
-   * and rebuild now when nothing executes on the generation, and when runs are
-   * still live, mark the generation for invalidation instead — it flushes when
-   * they exit, and the next activation composes fresh. Tools are unaffected
-   * meanwhile: they read the boundary live on every call.
-   */
-  private async resolveReusableGeneration(
-    sessionId: string,
-    existing: BackendGeneration,
-    boundaryRevision: number | undefined,
-  ): Promise<BackendGeneration | undefined> {
-    if (
-      boundaryRevision === undefined ||
-      existing.boundaryRevision === undefined ||
-      existing.boundaryRevision === boundaryRevision
-    ) {
-      return existing;
-    }
-    if (this.hasActiveRuns(sessionId)) {
-      this.ensureBackendInvalidation(sessionId);
-      return existing;
-    }
-    await this.disposeBackend(sessionId);
-    return undefined;
-  }
-
   private async shareBackendActivation(
     activationKey: string,
     activate: () => Promise<BackendGeneration>,

packages/runtime/src/session-manager.ts

@@ -1751,8 +1751,8 @@ export class SessionManager {
    * already reads the narrower authority, and background shell authority
    * across the lineage is fenced at once. Backend disposal is deferred: a
    * live run keeps executing on its generation (tools read the boundary live
-   * on every call), idle generations dispose through invalidation now, and
-   * the boundary-revision guard rebuilds stale ones on their next activation.
+   * on every call), and idle-time invalidation disposes and rebuilds stale
+   * generations — configuration transitions own their backend lifecycle.
    */
   private async commitTighteningTransition<T>(
     sessionId: string,