@frockbot/kernel-do 0.3.4 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/kernel-do",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "private": false,
   "type": "module",
   "exports": {
@@ -12,8 +12,8 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@frockbot/kernel-composition": "0.3.4",
-    "@frockbot/kernel-contracts": "0.3.4",
+    "@frockbot/kernel-composition": "0.3.5",
+    "@frockbot/kernel-contracts": "0.3.5",
     "cordis": "4.0.0-rc.8"
   },
   "devDependencies": {

package/src/authority.ts

@@ -34,11 +34,13 @@ import {
   eventsForFailedRun,
   latestModelRequestJournalState,
   planBotRunRecovery,
+  repairOrphanedOpenTurnV1,
   unresolvedModelRequestFailure,
 } from "./run-recovery.js";
 import {
   BotTurnReconciliationRequiredError,
   BotTurnRecoveryRequiredError,
+  BotTurnRefusedError,
 } from "./turn-errors.js";
 import {
   ACTIVE_RUN_KEY,
@@ -150,6 +152,22 @@ export const SUPERSEDED_TURN_REASON_V1 = "superseded by a new user message";
 /** How many times a queued Turn retries the object before giving up. */
 const MAX_QUEUED_RUN_START_ATTEMPTS = 8;
 
+/**
+ * True when this object has already durably decided to throw the Turn away.
+ *
+ * Reconciliation exists to retrieve an external outcome the Turn still needs.
+ * A Turn a Stop or a supersede has already discarded needs nothing: its
+ * provider outcome cannot change what it settles as, and parking it would keep
+ * the active-run marker — and so refuse every later message — over an answer
+ * nobody is waiting for. The intent the User expressed wins, and the run
+ * settles `cancelled` or `superseded` with everything it had already said.
+ */
+function runWasDiscardedV1(
+  run: { stopRequestedAt?: string; supersededAt?: string } | undefined,
+): boolean {
+  return Boolean(run?.stopRequestedAt || run?.supersededAt);
+}
+
 export interface BotDurableAuthorityOptions<Snapshot> {
   state: DurableObjectState;
   codec: StoredRunCodecV1<Snapshot>;
@@ -193,7 +211,14 @@ export class BotDurableAuthority<Snapshot> {
 
   async run(command: OwnedBotTurnCommand): Promise<BotTurnCompletion> {
     await this.assertMatchingRunCommand(command);
-    await this.recoverActiveRun();
+    // Recovering whatever this object was left holding must never decide the
+    // fate of a new command. `recoverActiveRun` executes the *previous* Turn
+    // inline and rethrows, so a recovery that failed — an uncertain effect, a
+    // mount failure, a provider that was down — threw before the new message
+    // was ever admitted, and the person's message was simply lost. The old
+    // Turn is durable either way and the alarm retries it; admission now
+    // refuses or supersedes on its own terms.
+    await this.recoverActiveRun().catch(() => undefined);
     const replay = await this.settledRunResult(command);
     if (replay) return replay;
     const admission = await this.acceptRun(command);
@@ -240,8 +265,10 @@ export class BotDurableAuthority<Snapshot> {
         const promoted = await this.promoteQueuedRun(command.runId);
         if (promoted === "blocked") {
           // Another Turn holds the object. Recovery drives it to its own
-          // durable terminal or resumable state, and this one tries again.
-          await this.recoverActiveRun();
+          // durable terminal or resumable state, and this one tries again —
+          // including when that recovery fails, which is the other Turn's
+          // problem and not this one's.
+          await this.recoverActiveRun().catch(() => undefined);
           // Unless what holds the object is an uncertain effect. That is
           // settled by an explicit reconciliation the User asks for, on their
           // own clock, and retrying against it would only burn this caller's
@@ -249,11 +276,14 @@ export class BotDurableAuthority<Snapshot> {
           // run is durable: it stays queued, and the reconciliation's own
           // settlement — or the recovery alarm — starts it.
           if (await this.activeRunAwaitsReconciliation()) {
-            return {
-              runId: command.runId,
-              text: "",
-              events: [],
-            } satisfies BotTurnCompletion;
+            // A Turn that has not run is not a completed Turn. Answering with
+            // an empty completion made the browser render the person's new
+            // message as answered with silence; the durable queue entry stays,
+            // and the refusal says why nothing has happened yet.
+            throw new BotTurnRefusedError(
+              "reconciliation-required",
+              `run "${command.runId}" is queued: the active run requires reconciliation before another Turn can be admitted`,
+            );
           }
           continue;
         }
@@ -369,12 +399,22 @@ export class BotDurableAuthority<Snapshot> {
         (await transaction.get<SessionEvent[]>(LATEST_EVENTS_KEY)) ?? []
       ).map(decodeSessionEvent);
       const settings = run.configurationSnapshot;
-      await transaction.put(key, {
-        ...run,
-        status: "running",
-        phase: "executing",
-        failure: undefined,
-      } satisfies StoredRunV1<Snapshot>);
+      // The failure is *removed*, not set to `undefined`: a running run that
+      // carries a `failure` key is a shape the run record does not allow, and
+      // writing one turned "resolve this Turn" into a record nothing could
+      // read afterwards. `require` checks it here, where the write is, rather
+      // than leaving the projector to fail on every later read.
+      const { failure: _failure, ...resumed } = run;
+      await transaction.put(
+        key,
+        structuredClone(
+          this.codec.require({
+            ...resumed,
+            status: "running",
+            phase: "executing",
+          } satisfies StoredRunV1<Snapshot>),
+        ),
+      );
       await this.refreshRecoveryAlarm(transaction);
       return { run, latest, settings };
     });
@@ -480,8 +520,9 @@ export class BotDurableAuthority<Snapshot> {
       }
       const modelState = latestModelRequestJournalState(events);
       if (
-        error instanceof BotTurnReconciliationRequiredError ||
-        modelState.status === "unresolved"
+        (error instanceof BotTurnReconciliationRequiredError ||
+          modelState.status === "unresolved") &&
+        !runWasDiscardedV1(durableRun)
       ) {
         await this.requireRunReconciliation(
           command.runId,
@@ -612,8 +653,9 @@ export class BotDurableAuthority<Snapshot> {
       }
       const modelState = latestModelRequestJournalState(events);
       if (
-        error instanceof BotTurnReconciliationRequiredError ||
-        modelState.status === "unresolved"
+        (error instanceof BotTurnReconciliationRequiredError ||
+          modelState.status === "unresolved") &&
+        !runWasDiscardedV1(durableRun)
       ) {
         await this.requireRunReconciliation(
           run.runId,
@@ -659,7 +701,8 @@ export class BotDurableAuthority<Snapshot> {
     );
     if (!run) return undefined;
     if (run.commandFingerprint !== botTurnCommandFingerprintV1(command)) {
-      throw new Error(
+      throw new BotTurnRefusedError(
+        "duplicate",
         `Turn idempotency key "${runId}" was reused for a different command`,
       );
     }
@@ -674,7 +717,8 @@ export class BotDurableAuthority<Snapshot> {
       };
     }
     if (run.status !== "completed") {
-      throw new Error(
+      throw new BotTurnRefusedError(
+        "duplicate",
         `run "${runId}" already exists with status ${run.status}`,
       );
     }
@@ -702,7 +746,8 @@ export class BotDurableAuthority<Snapshot> {
       run &&
       run.commandFingerprint !== botTurnCommandFingerprintV1(command)
     ) {
-      throw new Error(
+      throw new BotTurnRefusedError(
+        "duplicate",
         `Turn idempotency key "${command.runId}" was reused for a different command`,
       );
     }
@@ -788,7 +833,16 @@ export class BotDurableAuthority<Snapshot> {
         this.ctx.storage.get<BotIdentity>(IDENTITY_KEY),
       ]);
       const run = this.codec.optional(storedRun);
-      if (run?.status === "reconciliation-required" && identity) return;
+      if (run?.status === "reconciliation-required" && identity) {
+        // A parked run is not this alarm's to settle — only an explicit
+        // reconciliation settles it — but returning without rescheduling
+        // dropped the object's *other* deadlines with it: a Routine due while
+        // a Bot sat parked never fired, and nothing set the alarm again.
+        await this.ctx.storage.transaction((transaction) =>
+          this.refreshRecoveryAlarm(transaction),
+        );
+        return;
+      }
     }
     await this.recoverActiveRun();
   }
@@ -855,17 +909,15 @@ export class BotDurableAuthority<Snapshot> {
         const storedFences = storedRunAdmissionFences(
           await transaction.get<unknown>(RUN_ADMISSION_FENCE_INDEX_KEY),
         );
-        if (
-          !storedFences.includes(runId) &&
-          storedFences.length >= MAX_RUN_ADMISSION_FENCES
-        ) {
-          throw new Error("Run admission fence capacity reached");
-        }
+        // A bounded FIFO, not a cliff. Nothing ever evicted an entry, so a Bot
+        // that had refused 256 sends over its life answered every later fence
+        // with a 500 and left the client retrying "Turn admission lookup
+        // failed" forever. A run id old enough to age out here can no longer
+        // be admitted by any live caller.
+        const kept = storedFences.filter((fenced) => fenced !== runId);
+        while (kept.length >= MAX_RUN_ADMISSION_FENCES) kept.shift();
         await transaction.put({
-          [RUN_ADMISSION_FENCE_INDEX_KEY]: [
-            ...storedFences.filter((fenced) => fenced !== runId),
-            runId,
-          ],
+          [RUN_ADMISSION_FENCE_INDEX_KEY]: [...kept, runId],
           [IDENTITY_KEY]: durableIdentity ?? identity,
         });
         await transaction.delete(`${RUN_ADMISSION_FENCE_PREFIX}${runId}`);
@@ -932,7 +984,10 @@ export class BotDurableAuthority<Snapshot> {
       fences.includes(command.runId) ||
       (await this.ctx.storage.get(fenceKey))
     ) {
-      throw new Error(`run "${command.runId}" admission was fenced`);
+      throw new BotTurnRefusedError(
+        "fenced",
+        `run "${command.runId}" admission was fenced`,
+      );
     }
     const settings = await this.hooks.resolveAdmissionSnapshot(command);
     // Materialized before the transaction; the pin itself is read inside it.
@@ -944,20 +999,30 @@ export class BotDurableAuthority<Snapshot> {
         if (
           existing.commandFingerprint !== botTurnCommandFingerprintV1(command)
         ) {
-          throw new Error(
+          throw new BotTurnRefusedError(
+            "duplicate",
             `Turn idempotency key "${command.runId}" was reused for a different command`,
           );
         }
         if (existing.status === "completed") {
-          throw new Error(`run "${command.runId}" already completed`);
+          throw new BotTurnRefusedError(
+            "duplicate",
+            `run "${command.runId}" already completed`,
+          );
         }
-        throw new Error(`run "${command.runId}" already exists`);
+        throw new BotTurnRefusedError(
+          "duplicate",
+          `run "${command.runId}" already exists`,
+        );
       }
       const fences = storedRunAdmissionFences(
         await transaction.get<unknown>(RUN_ADMISSION_FENCE_INDEX_KEY),
       );
       if (fences.includes(command.runId) || (await transaction.get(fenceKey))) {
-        throw new Error(`run "${command.runId}" admission was fenced`);
+        throw new BotTurnRefusedError(
+          "fenced",
+          `run "${command.runId}" admission was fenced`,
+        );
       }
       const identity = await transaction.get<BotIdentity>(IDENTITY_KEY);
       if (
@@ -970,9 +1035,25 @@ export class BotDurableAuthority<Snapshot> {
       const supersede = activeRunId
         ? await this.planSupersede(transaction, command, activeRunId)
         : undefined;
-      const latestEvents = (
+      const storedEvents = (
         (await transaction.get<SessionEvent[]>(LATEST_EVENTS_KEY)) ?? []
       ).map(decodeSessionEvent);
+      // A Turn that died between `turn/start` and `turn/end` — an event the
+      // encoder refused, a durable write that failed — left the log open, and
+      // every later Turn failed validation with "turn N started while turn
+      // N-1 is open". Nothing owned that repair, because the run that would
+      // have closed it is already terminal, so admission does: with nothing
+      // executing, an open Turn is one nobody is going to finish.
+      const repairs = activeRunId
+        ? []
+        : repairOrphanedOpenTurnV1(command.sessionId, storedEvents);
+      const latestEvents = [...storedEvents, ...repairs];
+      if (repairs.length > 0) {
+        await transaction.put(
+          LATEST_EVENTS_KEY,
+          structuredClone(latestEvents.map(decodeSessionEvent)),
+        );
+      }
       const admittedSettings = await this.hooks.admittedSnapshot(
         transaction,
         settings,
@@ -1060,21 +1141,23 @@ export class BotDurableAuthority<Snapshot> {
     // no run when the person pressed send — supersedes exactly as a named one
     // does; only an absent field is "no intent", and that is still refused.
     if (lane !== "user" || !command.supersedes) {
-      throw new Error("bot already has an active run");
+      throw new BotTurnRefusedError("busy", "bot already has an active run");
     }
     const active = this.codec.optional(
       await transaction.get<unknown>(`${RUN_PREFIX}${activeRunId}`),
     );
-    if (!active) throw new Error("bot already has an active run");
+    if (!active)
+      throw new BotTurnRefusedError("busy", "bot already has an active run");
     if (active.status === "reconciliation-required") {
       // An uncertain external effect is never abandoned to admit something
       // else: the outcome has to be retrieved before this object runs again.
-      throw new Error(
+      throw new BotTurnRefusedError(
+        "reconciliation-required",
         `run "${activeRunId}" requires reconciliation before another Turn can be admitted`,
       );
     }
     if (active.status !== "running") {
-      throw new Error("bot already has an active run");
+      throw new BotTurnRefusedError("busy", "bot already has an active run");
     }
     const pendingRunId = await transaction.get<string>(PENDING_RUN_KEY);
     // A Turn that has not dispatched a model request has no durable work to
@@ -1400,6 +1483,22 @@ export class BotDurableAuthority<Snapshot> {
         await this.refreshRecoveryAlarm(transaction);
         return { kind: "resume" as const, run, latest, settings };
       }
+      if (runWasDiscardedV1(run)) {
+        // Recovery of a Turn Stop or supersede already discarded settles it on
+        // that intent rather than parking it: nothing is owed the answer.
+        await failStoredRun(
+          this.codec,
+          transaction,
+          this.terminalKeys(run.runId),
+          run.runId,
+          latest.slice(0, run.previousEventCount),
+          [...run.events, ...plan.repairs],
+          "Execution outcome requires reconciliation before it can resume",
+          this.supersededPackageRecords(),
+        );
+        await this.refreshRecoveryAlarm(transaction);
+        return undefined;
+      }
       await transaction.put({
         [key]: {
           ...run,

package/src/run-recovery.ts

@@ -182,6 +182,46 @@ export function planBotRunRecovery<Snapshot>(
   return { kind: "reconcile", repairs: session.reconcileForResume() };
 }
 
+/** True when the durable log ends inside a Turn nothing is going to finish. */
+export function hasOrphanedOpenTurnV1(
+  events: readonly SessionEvent[],
+): boolean {
+  let openTurn: number | undefined;
+  for (const event of events) {
+    if (event.type === "turn/start") openTurn = event.turn;
+    if (event.type === "turn/end" && event.turn === openTurn) {
+      openTurn = undefined;
+    }
+  }
+  return openTurn !== undefined;
+}
+
+/**
+ * Closes a Turn the log was left inside, so the next one can start.
+ *
+ * A Turn that threw between `turn/start` and `turn/end` — an event the
+ * encoder refused, a durable write that failed — leaves an open turn in the
+ * durable log, and the next Turn on that Bot fails validation with "turn N
+ * started while turn N-1 is open". Forever: nothing owned the repair, because
+ * the run that would have written the `turn/end` is already terminal. This is
+ * that repair, applied when no run is executing, so an interrupted Turn is
+ * recorded as interrupted rather than wedging the Bot.
+ *
+ * A log too malformed to reconcile is left exactly as it is: repairing it
+ * blindly would invent history.
+ */
+export function repairOrphanedOpenTurnV1(
+  sessionId: string,
+  latest: readonly SessionEvent[],
+): SessionEvent[] {
+  if (!hasOrphanedOpenTurnV1(latest)) return [];
+  try {
+    return new Session(sessionId, () => {}, latest).reconcileInterrupted();
+  } catch {
+    return [];
+  }
+}
+
 export function eventsForFailedRun(
   durableRun: { events: SessionEvent[] } | undefined,
   error: unknown,

package/src/turn-errors.ts

@@ -25,6 +25,50 @@ export class BotTurnReconciliationRequiredError extends Error {
   }
 }
 
+/** Why the Bot declined to admit a Turn. */
+export type BotTurnRefusalCodeV1 =
+  "busy" | "reconciliation-required" | "fenced" | "duplicate";
+
+const BOT_TURN_REFUSAL_PREFIX_V1 = "BotTurnRefusedError:";
+
+/**
+ * An admission the Bot declined, as a typed error rather than a sentence.
+ *
+ * A refusal crosses a Durable Object RPC boundary, which preserves an error's
+ * `name` and `message` and drops everything else — so the code rides on the
+ * name, the way the gateway already relies on `name` for `BotNotFoundError`.
+ * Classifying these by matching prose against `error.message` meant any
+ * reword silently turned an ordinary 409 into a 500, and two real messages
+ * already fell through.
+ */
+export class BotTurnRefusedError extends Error {
+  constructor(
+    readonly code: BotTurnRefusalCodeV1,
+    message: string,
+  ) {
+    super(message);
+    this.name = `${BOT_TURN_REFUSAL_PREFIX_V1}${code}`;
+  }
+}
+
+/** The refusal an error carries, or `undefined` when it is not one. */
+export function botTurnRefusalCodeV1(
+  error: unknown,
+): BotTurnRefusalCodeV1 | undefined {
+  const name =
+    typeof error === "object" && error !== null && "name" in error
+      ? String((error as { name: unknown }).name)
+      : "";
+  if (!name.startsWith(BOT_TURN_REFUSAL_PREFIX_V1)) return undefined;
+  const code = name.slice(BOT_TURN_REFUSAL_PREFIX_V1.length);
+  return code === "busy" ||
+    code === "reconciliation-required" ||
+    code === "fenced" ||
+    code === "duplicate"
+    ? code
+    : undefined;
+}
+
 export class BotTurnRecoveryRequiredError extends Error {
   constructor(readonly events: SessionEvent[]) {
     super("Bot turn has a durable outcome settlement pending");

package/src/turn-supersede.test.ts

@@ -12,6 +12,10 @@ import {
   type OwnedBotTurnCommand,
 } from "./authority.ts";
 import { MemoryStorage } from "./memory-storage.fixture.ts";
+import {
+  BotTurnReconciliationRequiredError,
+  BotTurnRecoveryRequiredError,
+} from "./turn-errors.ts";
 import {
   createStoredRunCodecV1,
   storedRunLaneV1,
@@ -108,7 +112,23 @@ function deferred<T>(): Deferred<T> {
  */
 function createAuthority(
   storage: MemoryStorage,
-  options: { dispatch?(runId: string): boolean } = {},
+  options: {
+    dispatch?(runId: string): boolean;
+    /**
+     * Ends the named Turn the way the Agent loop ends one whose model stream
+     * was aborted mid-flight: a journaled `model/request` with no durable
+     * provider outcome, and a reconciliation demand.
+     */
+    uncertain?(runId: string): boolean;
+    /**
+     * Parks the named Turn when it is released: the provider call it had
+     * dispatched by then has no durable outcome, and nothing but an explicit
+     * reconciliation can settle it.
+     */
+    parkOnRelease?(runId: string): boolean;
+    /** Fails the recovery of an evicted Turn, leaving it active and owed. */
+    failRecovery?(runId: string): boolean;
+  } = {},
 ): Probe {
   const observed: BotTurnExecutionInput<undefined>[] = [];
   const interrupts: { runId: string; reason: string }[] = [];
@@ -138,6 +158,9 @@ function createAuthority(
     executeTurn: async (input) => {
       observed.push(input);
       const runId = input.command.runId;
+      if (input.resume && options.failRecovery?.(runId)) {
+        throw new BotTurnRecoveryRequiredError([]);
+      }
       const turn = observed.length;
       const handle = handleFor(runId);
       let seq = input.previousEvents.length;
@@ -166,7 +189,22 @@ function createAuthority(
           text: input.command.text,
         } as never,
       );
-      if (options.dispatch?.(runId) ?? true) {
+      const uncertain = options.uncertain?.(runId) ?? false;
+      if (uncertain) {
+        await persist({
+          type: "model/request",
+          turn,
+          step: 1,
+          request: {
+            requestId: `request-${runId}`,
+            provider: "foundation",
+            model: "foundation-model",
+            system: "system",
+            messages: [{ role: "user", content: input.command.text }],
+            tools: [],
+          },
+        } as never);
+      } else if (options.dispatch?.(runId) ?? true) {
         await persist(
           {
             type: "model/request",
@@ -193,6 +231,43 @@ function createAuthority(
       }
       handle.started.resolve();
       const outcome = await handle.settled.promise;
+      if (outcome.interrupted === undefined && options.parkOnRelease?.(runId)) {
+        const reason = `Model request "request-${runId}" has no durable provider outcome`;
+        await persist(
+          {
+            type: "model/request",
+            turn,
+            step: 1,
+            request: {
+              requestId: `request-${runId}`,
+              provider: "foundation",
+              model: "foundation-model",
+              system: "system",
+              messages: [{ role: "user", content: input.command.text }],
+              tools: [],
+            },
+          } as never,
+          {
+            type: "model/reconciliation-required",
+            turn,
+            step: 1,
+            requestId: `request-${runId}`,
+            reason,
+          } as never,
+        );
+        throw new BotTurnReconciliationRequiredError(reason, appended);
+      }
+      if (outcome.interrupted !== undefined && uncertain) {
+        const reason = `Model response outcome is uncertain after cancellation: ${outcome.interrupted}`;
+        await persist({
+          type: "model/reconciliation-required",
+          turn,
+          step: 1,
+          requestId: `request-${runId}`,
+          reason,
+        } as never);
+        throw new BotTurnReconciliationRequiredError(reason, appended);
+      }
       if (outcome.interrupted !== undefined) {
         await persist({
           type: "turn/end",
@@ -576,3 +651,179 @@ describe("eviction between the two Turns", () => {
     expect(restarted.observed).toHaveLength(1);
   });
 });
+
+describe("a durable log left inside a Turn", () => {
+  test("is repaired at admission instead of refusing every later Turn", async () => {
+    const storage = new MemoryStorage();
+    // Exactly what a Turn that threw between `turn/start` and `turn/end`
+    // leaves behind: an open Turn, and no run to close it.
+    storage.values.set("latest-events", [
+      {
+        type: "session/created",
+        createdAt: "2026-09-03T00:00:00.000Z",
+        seq: 0,
+        timestamp: "2026-09-03T00:00:00.000Z",
+      },
+      {
+        type: "turn/start",
+        turn: 1,
+        seq: 1,
+        timestamp: "2026-09-03T00:00:01.000Z",
+      },
+    ]);
+    const probe = createAuthority(storage);
+
+    const run = probe.authority.run(command("run-1", "hello"));
+    await probe.handle("run-1").started;
+    probe.handle("run-1").finish();
+    await run;
+
+    const events = storage.values.get("latest-events") as Array<{
+      type: string;
+      turn?: number;
+    }>;
+    // The orphaned Turn is closed, so the new one starts.
+    expect(events[2]).toMatchObject({
+      type: "turn/end",
+      turn: 1,
+      outcome: "interrupted",
+    });
+    expect(storedRun(storage, "run-1").status).toBe("completed");
+  });
+});
+
+describe("a failing recovery of an older Turn", () => {
+  test("does not swallow the message the User just sent", async () => {
+    const storage = new MemoryStorage();
+    const probe = createAuthority(storage);
+    const first = probe.authority.run(command("run-1", "first"));
+    await probe.handle("run-1").started;
+    // Evicted mid-Turn: run-1 stays active and durable, and the object that
+    // comes back recovers it — badly.
+    const restarted = createAuthority(storage, {
+      failRecovery: (runId) => runId === "run-1",
+    });
+    const second = restarted.authority
+      .run(
+        command("run-2", "second", {
+          lane: "user",
+          supersedes: { runId: "run-1" },
+        }),
+      )
+      .catch(() => undefined);
+    await admitted();
+
+    // The new message is durable regardless of what happened to the old Turn.
+    // Before this, the recovery's own error threw out of `run()` before
+    // admission was ever attempted and the message was simply gone.
+    expect(storedRun(storage, "run-2").runId).toBe("run-2");
+    expect(storedRun(storage, "run-2").input).toBe("second");
+    probe.handle("run-1").finish();
+    await first.catch(() => undefined);
+    restarted.handle("run-2").finish();
+    await second;
+  });
+});
+
+describe("the run admission fence index", () => {
+  test("ages the oldest entry out rather than refusing the operation", async () => {
+    const storage = new MemoryStorage();
+    const probe = createAuthority(storage);
+    for (let index = 0; index < 300; index += 1) {
+      await probe.authority.fenceRunAdmission(identity, `fence-${index}`);
+    }
+    const fences = storage.values.get("run-admission-fences") as string[];
+    expect(fences.length).toBeLessThanOrEqual(256);
+    // The newest fence is the one that still matters; the oldest aged out.
+    expect(fences.at(-1)).toBe("fence-299");
+    expect(fences).not.toContain("fence-0");
+  });
+});
+
+describe("a Turn queued behind a parked run", () => {
+  test("is refused rather than answered with an empty completion", async () => {
+    const storage = new MemoryStorage();
+    // The first Turn has not dispatched when the second arrives, so it is left
+    // to finish and the second queues behind it. It then parks on a provider
+    // outcome only a User can retrieve.
+    const probe = createAuthority(storage, {
+      dispatch: () => false,
+      parkOnRelease: (runId) => runId === "run-1",
+    });
+
+    const first = probe.authority.run(command("run-1", "first"));
+    await probe.handle("run-1").started;
+    const second = probe.authority.run(
+      command("run-2", "second", {
+        lane: "user",
+        supersedes: { runId: "run-1" },
+      }),
+    );
+    await admitted();
+    probe.handle("run-1").finish();
+    await first.catch(() => undefined);
+
+    await expect(second).rejects.toThrow(
+      /is queued: the active run requires reconciliation/,
+    );
+    // And it is still owed a Turn: durable, queued, and started by the
+    // reconciliation's own settlement or by the recovery alarm.
+    const queued = storedRun(storage, "run-2");
+    expect(queued.status).toBe("running");
+    expect(queued.phase).toBe("queued");
+    expect(storage.values.get("pending-run")).toBe("run-2");
+  });
+});
+
+describe("an interrupt while the model is streaming", () => {
+  test("a superseded Turn settles superseded rather than parking the Bot", async () => {
+    const storage = new MemoryStorage();
+    const probe = createAuthority(storage, { uncertain: () => true });
+
+    const first = probe.authority.run(command("run-1", "first"));
+    await probe.handle("run-1").started;
+    const second = probe.authority.run(
+      command("run-2", "second", {
+        lane: "user",
+        supersedes: { runId: "run-1" },
+      }),
+    );
+    await first.catch(() => undefined);
+    probe.handle("run-2").finish();
+    const result = await second;
+
+    // The provider outcome of a Turn nobody is waiting for is worthless: the
+    // intent the User expressed is what settles it.
+    const superseded = storedRun(storage, "run-1");
+    expect(superseded.status).toBe("superseded");
+    expect(superseded.supersededBy).toBe("run-2");
+    expect(storage.values.get("active-run")).toBeUndefined();
+    expect(result.text).toBe("done: second");
+  });
+
+  test("a stopped Turn settles cancelled and the next message is admitted", async () => {
+    const storage = new MemoryStorage();
+    const probe = createAuthority(storage, { uncertain: () => true });
+
+    const first = probe.authority.run(command("run-1", "first"));
+    await probe.handle("run-1").started;
+    // What an authenticated Stop writes before it signals the Agent.
+    const stopped = storedRun(storage, "run-1");
+    storage.values.set("run:run-1", {
+      ...stopped,
+      stopRequestedAt: "2026-09-03T00:00:05.000Z",
+    });
+    probe.handle("run-1").interrupt("stopped by an authenticated Stop command");
+    await first.catch(() => undefined);
+
+    expect(storedRun(storage, "run-1").status).toBe("cancelled");
+    expect(storage.values.get("active-run")).toBeUndefined();
+
+    // And the Bot takes the next message straight away, with no
+    // reconciliation standing between the User and their Bot.
+    const next = probe.authority.run(command("run-2", "second"));
+    await probe.handle("run-2").started;
+    probe.handle("run-2").finish();
+    expect((await next).text).toBe("done: second");
+  });
+});