Expire error recovery on reinject the same as interrupt

Reinject still stops the run before sending. Clear the one-event
handoff there too, and keep reinject rows if a rollback still fires.

Author: TheGreatAxios

src/tui/runtime-bridge.test.ts

@@ -1014,6 +1014,42 @@ describe("same-turn failover after inference.error", () => {
     );
   });
 
+  test("reinject interrupt keeps the prompt and the classified error", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 80, rows: 24 },
+          wireKeys: false,
+          run: "idle",
+        });
+        const bridge = attachSessionBridge(shell, createRecordingPort());
+        try {
+          bridge.handle({ type: "inference.start", data: {} });
+          bridge.handle({
+            type: "inference.error",
+            data: {
+              error: { category: "credential_failure", message: "Forbidden", statusCode: 403 },
+            },
+          });
+          bridge.submit("restart from here", "reinject");
+          bridge.handle({ type: "inference.start", data: {} });
+          bridge.handle({ type: "inference.text.delta", data: { token: "recovered" } });
+          bridge.handle({ type: "inference.done", data: {} });
+          bridge.handle({ type: "reactor.done", data: {} });
+
+          const text = shell.streamLog.map((r) => r.text).join("\n");
+          expect(text).toContain("restart from here");
+          expect(text).toContain("stop — restarting from your message");
+          expect(errorRows(shell)).toContain("Session expired — re-authenticating…");
+        } finally {
+          bridge.dispose();
+          shell.dispose();
+        }
+      },
+      { width: 80, height: 24 },
+    );
+  });
+
   test("a terminal inference.error with no recovery still surfaces", async () => {
     await withTestRenderer(
       async (h) => {

src/tui/runtime-bridge.ts

@@ -704,21 +704,22 @@ function syncToolElapsed(shell: AppShell, bag: BridgeBag, nowMs: number): void {
   }
 }
 
-/**
- * Retract everything the failed attempt painted, then forget the row
- * bookkeeping that pointed into it — a rolled-back tool call has no row left
- * to resolve, and a rolled-back reasoning row is no longer there to fold into.
- */
 function isLocallyQueuedUserRow(row: StreamRow): boolean {
   return (
     row.role === "user" &&
     (row.meta === "queue" ||
       row.meta === "steer" ||
       row.meta === "steering" ||
-      row.meta === "following-up")
+      row.meta === "following-up" ||
+      row.meta === "reinject")
   );
 }
 
+/**
+ * Retract everything the failed attempt painted, then forget the row
+ * bookkeeping that pointed into it — a rolled-back tool call has no row left
+ * to resolve, and a rolled-back reasoning row is no longer there to fold into.
+ */
 function rollbackAttempt(shell: AppShell, bag: BridgeBag): void {
   const boundary = bag.attemptRow;
   bag.attemptRow = null;
@@ -1138,6 +1139,8 @@ export function attachSessionBridge(
       if (shell.session.run !== "busy") return;
       closeOpenRow(shell, bag);
       bag.pendingEchoes.length = 0;
+      bag.mapCtx.errorRollbackArmed = false;
+      bag.attemptRow = null;
       shell.session = interrupt(shell.session);
       appendStreamRow(shell, {
         role: "system",