🤖 perf: replay synthetic session tapes through the desktop app with egress blocked (T3)

Makefile

@@ -88,7 +88,7 @@ include fmt.mk
 .PHONY: all build dev start clean help
 .PHONY: build-renderer version build-icons build-static build-docker-runtime verify-docker-runtime-artifacts
 .PHONY: lint lint-fix typecheck static-check static-check-full
-.PHONY: test test-unit test-unit-ci test-integration test-watch test-coverage test-e2e test-e2e-perf smoke-test
+.PHONY: test test-unit test-unit-ci test-integration test-watch test-coverage test-e2e test-e2e-perf perf-tape-replay smoke-test
 .PHONY: dist dist-mac dist-win dist-linux install-mac-arm64 ensure-mac-sharp-runtime-deps check-appimage-icons check-mac-attach-file-runtime
 .PHONY: vscode-ext vscode-ext-install
 .PHONY: docs-server check-docs-links
@@ -549,6 +549,10 @@ test-e2e-perf: ## Run automated performance profiling scenarios
 	@# One worker: parallel Electron apps contend on CPU, so a scenario measures its neighbours' startup (#5209).
 	@XUM_E2E_RUN_PERF=1 XUM_PROFILE_REACT=1 XUM_E2E_LOAD_DIST=1 XUM_E2E_SKIP_BUILD=1 PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 bun x playwright test --project=electron tests/e2e/scenarios/perf*.spec.ts --workers 1 $(PLAYWRIGHT_ARGS)
 
+perf-tape-replay: ## Replay a synthetic session tape through the desktop app (perf.tapeReplay)
+	@$(MAKE) build
+	@XUM_E2E_RUN_PERF=1 XUM_PROFILE_REACT=1 XUM_E2E_LOAD_DIST=1 XUM_E2E_SKIP_BUILD=1 PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 bun x playwright test --project=electron tests/e2e/scenarios/perf.tapeReplay.spec.ts --workers 1 $(PLAYWRIGHT_ARGS)
+
 ## Distribution
 dist: build ## Build distributable packages
 	@bun x electron-builder --publish never

scripts/perf/generateTapeReplayFixture.ts

@@ -0,0 +1,23 @@
+/**
+ * Regenerate the synthetic session tape fixture of the `perf.tapeReplay` e2e scenario:
+ *   bun scripts/perf/generateTapeReplayFixture.ts
+ */
+import { writeFileSync } from "node:fs";
+import * as path from "node:path";
+import {
+  buildTapeReplayFixtureTape,
+  TAPE_REPLAY_FIXTURE_FILE_NAME,
+} from "../../tests/e2e/fixtures/sessionTapes/tapeReplayFixture";
+
+const target = path.join(
+  import.meta.dir,
+  "..",
+  "..",
+  "tests",
+  "e2e",
+  "fixtures",
+  "sessionTapes",
+  TAPE_REPLAY_FIXTURE_FILE_NAME
+);
+writeFileSync(target, buildTapeReplayFixtureTape());
+console.log(`Wrote ${path.relative(process.cwd(), target)}`);

scripts/perf/tapeReplayFixture.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import * as path from "node:path";
+import { hashSessionTapeWorkspaceId } from "@/node/services/sessionTapes/sessionTapeRecorder";
+import { readSessionTapeFile } from "@/node/services/sessionTapes/sessionTapeFile";
+import {
+  TAPE_REPLAY_FIXTURE_FILE_NAME,
+  TAPE_REPLAY_FIXTURE_WORKSPACE_ID,
+} from "../../tests/e2e/fixtures/sessionTapes/tapeReplayFixture";
+
+const FIXTURE_PATH = path.join(
+  import.meta.dir,
+  "..",
+  "..",
+  "tests",
+  "e2e",
+  "fixtures",
+  "sessionTapes",
+  TAPE_REPLAY_FIXTURE_FILE_NAME
+);
+
+describe("perf.tapeReplay fixture tape", () => {
+  test("loads as a complete tape recorded for the scenario's workspace id", async () => {
+    const result = await readSessionTapeFile(FIXTURE_PATH);
+    expect(result.status).toBe("ok");
+    if (result.status !== "ok") return;
+    // The replay source refuses a tape whose hash does not match the mapped workspace.
+    expect(result.header.workspaceIdHash).toBe(
+      hashSessionTapeWorkspaceId(TAPE_REPLAY_FIXTURE_WORKSPACE_ID)
+    );
+  });
+});

src/browser/components/StartHereModal/StartHereModal.tsx

@@ -10,6 +10,7 @@ import {
 import { Button } from "@/browser/components/Button/Button";
 import { stopKeyboardPropagation } from "@/browser/utils/events";
 import { isEditableElement, KEYBINDS, matchesKeybind } from "@/browser/utils/ui/keybinds";
+import { getErrorMessage } from "@/common/utils/errors";
 
 interface StartHereModalProps {
   isOpen: boolean;
@@ -30,21 +31,26 @@ export const StartHereModal: React.FC<StartHereModalProps> = ({
   confirmDisabled = false,
 }) => {
   const [isExecuting, setIsExecuting] = useState(false);
+  // Why the last confirmation was refused; shown until the next attempt or cancel.
+  const [error, setError] = useState<string | undefined>(undefined);
 
   const handleCancel = useCallback(() => {
     if (!isExecuting) {
+      setError(undefined);
       onClose();
     }
   }, [isExecuting, onClose]);
 
   const handleConfirm = useCallback(async () => {
     if (isExecuting || confirmDisabled) return;
     setIsExecuting(true);
+    setError(undefined);
     try {
       await onConfirm();
       onClose();
-    } catch (error) {
-      console.error("Start Here error:", error);
+    } catch (confirmError) {
+      setError(getErrorMessage(confirmError));
+    } finally {
       setIsExecuting(false);
     }
   }, [isExecuting, confirmDisabled, onConfirm, onClose]);
@@ -88,6 +94,11 @@ export const StartHereModal: React.FC<StartHereModalProps> = ({
             This will start a new context from this message and preserve earlier chat history.
           </DialogDescription>
         </DialogHeader>
+        {error && (
+          <div role="alert" className="bg-error-bg text-error rounded p-2 px-3 text-[13px]">
+            {error}
+          </div>
+        )}
         <DialogFooter className="justify-center">
           <Button variant="secondary" onClick={handleCancel} disabled={isExecuting}>
             Cancel

src/browser/features/Messages/StreamErrorMessage.tsx

@@ -57,6 +57,20 @@ const StreamErrorMessageBase: React.FC<StreamErrorMessageBaseProps> = (props) =>
     </Tooltip>
   );
 
+  // Perf harness (XUM_REPLAY_TAPES): the backend refused to replay this workspace's tape. No
+  // model or stream was involved, so no error pill and no LLM request debug action.
+  if (message.errorType === "session_tape_replay") {
+    return (
+      <div className={cn("bg-error-bg border border-error rounded px-5 py-4 my-3", className)}>
+        <div className="font-primary text-error mb-2 flex items-center gap-2 text-[13px] font-semibold">
+          <AlertTriangle aria-hidden="true" className="h-4 w-4" />
+          <span>Session tape replay refused</span>
+        </div>
+        <div className="text-foreground/80 text-[13px] leading-relaxed">{message.error}</div>
+      </div>
+    );
+  }
+
   // Runtime unavailable gets a distinct, friendlier presentation.
   // This is a permanent failure (container/runtime doesn't exist), not a transient stream error.
   // The backend sends "Container unavailable..." for Docker or "Runtime unavailable..." for others.

src/browser/hooks/useStartHere.ts

@@ -76,11 +76,11 @@ export function useStartHere(
         deletePlanFile: options?.deletePlanFile,
       });
 
+      // Thrown, not logged: the modal keeps itself open and shows the reason (for example a
+      // workspace replaying a session tape refuses history changes).
       if (!result.success) {
-        console.error("Failed to start here:", result.error);
+        throw new Error(String(result.error));
       }
-    } catch (err) {
-      console.error("Start here error:", err);
     } finally {
       setIsStartingHere(false);
     }

src/browser/stores/WorkspaceStore.test.ts

@@ -6,7 +6,11 @@ import { createAgentSessionHarness } from "@/node/services/agentSession.testHarn
 import { createWorkspaceServiceForTest } from "@/node/services/workspaceService.testHarness";
 // eslint-disable-next-line local/no-cross-boundary-imports -- exercise the actual IPC replay boundary in this store fixture
 import { subscribeWorkspaceChat } from "@/node/orpc/routerSubscriptions";
+import { markSessionTapeReplayEgressBlocked } from "@/common/utils/sessionTapes/sessionTapeReplay";
 import type { ORPCContext } from "@/node/orpc/context";
+import { CUSTOM_EVENTS } from "@/common/constants/events";
+import { MUX_GATEWAY_SESSION_EXPIRED_MESSAGE } from "@/common/constants/muxGatewayOAuth";
+import { getInterruptionContext } from "@/common/utils/messages/retryEligibility";
 import type { TurnCoordinator, OperationId } from "@/node/services/turnCoordinator";
 import { Ok } from "@/common/types/result";
 import { GlobalWindow } from "happy-dom";
@@ -879,6 +883,101 @@ describe("WorkspaceStore", () => {
     store.dispose();
   });
 
+  it("shows a refused session tape replay as an error and does not retry it", async () => {
+    // A mapped tape the backend refuses (here: missing) must end the skeleton with a visible
+    // reason, keep sends closed and not resubscribe: a retry can only be refused again. Served
+    // by the backend's real onChat entry point, with no services behind it.
+    const workspaceId = "tape-refused-workspace";
+    const savedEnv = {
+      XUM_REPLAY_TAPES: process.env.XUM_REPLAY_TAPES,
+      XUM_E2E: process.env.XUM_E2E,
+      XUM_REPLAY_HARNESS: process.env.XUM_REPLAY_HARNESS,
+    };
+    process.env.XUM_REPLAY_TAPES = JSON.stringify({ [workspaceId]: "/nonexistent/missing.jsonl" });
+    // The perf harness markers: outside them the backend refuses before reading the tape.
+    process.env.XUM_E2E = "1";
+    process.env.XUM_REPLAY_HARNESS = "1";
+    markSessionTapeReplayEgressBlocked();
+    const context = {} as unknown as ORPCContext;
+    mockOnChat.mockImplementation(async function* (input, options) {
+      yield* subscribeWorkspaceChat(context, { workspaceId: input!.workspaceId }, options?.signal, {
+        validateOutput: true,
+      });
+    });
+    try {
+      createAndAddWorkspace(store, workspaceId);
+      const showsRefusal = () =>
+        store
+          .getWorkspaceState(workspaceId)
+          .messages.some(
+            (message) => message.type === "stream-error" && message.error.includes("unreadable")
+          );
+      expect(await waitUntil(showsRefusal)).toBe(true);
+      // Past the first retry backoff (SUBSCRIPTION_RETRY_BASE_MS): a retry would subscribe again.
+      await tick(400);
+      expect(mockOnChat).toHaveBeenCalledTimes(1);
+      const state = store.getWorkspaceState(workspaceId);
+      expect(state.isHydratingTranscript).toBe(false);
+      expect(state.loading).toBe(false);
+      expect(state.isTranscriptCaughtUp).toBe(false);
+      // Not a model stream failure: no "Stream interrupted" barrier and no Retry/auto-retry.
+      expect(state.messages.at(-1)).toMatchObject({ errorType: "session_tape_replay" });
+      const interruption = getInterruptionContext(state.messages);
+      expect(interruption.hasInterruptedStream).toBe(false);
+      expect(interruption.isEligibleForAutoRetry).toBe(false);
+    } finally {
+      for (const [key, value] of Object.entries(savedEnv)) {
+        if (value === undefined) delete process.env[key];
+        else process.env[key] = value;
+      }
+    }
+  });
+
+  it.each([false, true])(
+    "suppresses recorded side effects when the renderer replays a session tape (%p)",
+    async (replaying) => {
+      // A replayed tape's events never ran here: no gateway dialog, no git/review refresh.
+      const workspaceId = `tape-side-effects-${String(replaying)}`;
+      const api = global.window.api as { isSessionTapeReplay?: boolean };
+      api.isSessionTapeReplay = replaying;
+      const dispatchEvent = global.window.dispatchEvent as Mock<(event: Event) => boolean>;
+      dispatchEvent.mockClear();
+      try {
+        const send = openChat(workspaceId);
+        createAndAddWorkspace(store, workspaceId);
+        const messageId = "tape-stream";
+        await send(
+          caughtUpEvent(),
+          {
+            type: "stream-start",
+            workspaceId,
+            messageId,
+            historySequence: 1,
+            model: TEST_MODEL,
+            startTime: 1,
+          },
+          toolCallEndEvent(workspaceId, "tool-1", "bash", { output: "ok" }, { messageId }),
+          {
+            type: "stream-error",
+            messageId,
+            error: MUX_GATEWAY_SESSION_EXPIRED_MESSAGE,
+            errorType: "authentication",
+          }
+        );
+        expect(
+          await waitUntil(() => store.getWorkspaceState(workspaceId).messages.length > 0)
+        ).toBe(true);
+        const gatewayDialogs = dispatchEvent.mock.calls.filter(
+          ([event]) => event.type === CUSTOM_EVENTS.MUX_GATEWAY_SESSION_EXPIRED
+        );
+        expect(gatewayDialogs.length).toBe(replaying ? 0 : 1);
+        expect(store.getFileModifyingToolMs(workspaceId) === undefined).toBe(replaying);
+      } finally {
+        delete api.isSessionTapeReplay;
+      }
+    }
+  );
+
   it.each([
     ["stream-abort", "full"],
     ["error", "full"],

src/browser/stores/WorkspaceStore.ts

@@ -21,7 +21,10 @@ import type { TodoItem } from "@/common/types/tools";
 import type { AssistedReviewHunk } from "@/common/types/review";
 import type { WorkflowRunRecord } from "@/common/types/workflow";
 import type { TimelineEvent, TimelineSubscriptionEvent } from "@/common/orpc/schemas/timeline";
-import { applyWorkspaceChatEventToAggregator } from "@/browser/utils/messages/applyWorkspaceChatEventToAggregator";
+import {
+  applyWorkspaceChatEventToAggregator,
+  isSessionTapeReplayRenderer,
+} from "@/browser/utils/messages/applyWorkspaceChatEventToAggregator";
 import {
   StreamingMessageAggregator,
   type LoadedSkill,
@@ -37,6 +40,7 @@ import {
   type ResponseCompleteHandler,
 } from "@/browser/utils/messages/responseCompletionMetadata";
 import { isAbortError } from "@/browser/utils/isAbortError";
+import { isSessionTapeReplayRefusal } from "@/common/utils/sessionTapes/sessionTapeReplay";
 import {
   SUBSCRIPTION_RETRY_BASE_MS,
   calculateSubscriptionBackoffMs,
@@ -1176,8 +1180,10 @@ export class WorkspaceStore {
       this.consumerManager.scheduleCalculation(workspaceId, aggregator);
 
       // Track file-modifying tools for ReviewPanel diff refresh.
+      // Not for a replayed session tape (perf harness): its tools never ran here.
       const shouldTriggerReviewPanelRefresh =
-        toolCallEnd.toolName.startsWith("file_edit_") || toolCallEnd.toolName === "bash";
+        (toolCallEnd.toolName.startsWith("file_edit_") || toolCallEnd.toolName === "bash") &&
+        !isSessionTapeReplayRenderer();
 
       if (shouldTriggerReviewPanelRefresh) {
         this.fileModifyingToolMs.set(workspaceId, Date.now());
@@ -4465,6 +4471,12 @@ export class WorkspaceStore {
             console.warn(
               "[WorkspaceStore] onChat subscription aborted for " + workspaceId + "; retrying..."
             );
+        } else if (isSessionTapeReplayRefusal(error)) {
+          // Perf harness (XUM_REPLAY_TAPES): this workspace is mapped to a tape the backend
+          // cannot serve. Retrying cannot help and there is no live fallback: show the refusal
+          // and stop the loop.
+          this.showSessionTapeReplayRefusal(workspaceId, error.message);
+          return true;
         } else if (isIteratorValidationFailed(error)) {
           if (!this.isWorkspaceRegistered(workspaceId)) return true;
           console.error(
@@ -4518,6 +4530,27 @@ export class WorkspaceStore {
     }
   }
 
+  /**
+   * End hydration for a workspace whose session tape replay was refused and show the reason as
+   * an error row. The onChat loop stops (no attempt-finished hook runs), so this also clears the
+   * attempt's buffers and opens the replay gate. History stays unverified, so the send barrier
+   * stays closed.
+   */
+  private showSessionTapeReplayRefusal(workspaceId: string, message: string): void {
+    if (!this.isWorkspaceRegistered(workspaceId)) return;
+    this.clearReplayBuffers(workspaceId);
+    this.chatReplayPendingWorkspaces.delete(workspaceId);
+    const transient = this.chatTransientState.get(workspaceId);
+    if (transient) transient.isHydratingTranscript = false;
+    this.assertGet(workspaceId).handleStreamError({
+      type: "stream-error",
+      messageId: "session-tape-replay-refused",
+      error: message,
+      errorType: "session_tape_replay",
+    });
+    this.states.bump(workspaceId);
+  }
+
   /**
    * Register a workspace and initialize local state.
    */

src/browser/utils/messages/applyWorkspaceChatEventToAggregator.ts

@@ -91,6 +91,15 @@ export interface WorkspaceChatEventAggregator {
   clearTokenState(messageId: string): void;
 }
 
+/**
+ * Desktop perf harness (XUM_REPLAY_TAPES, exposed by preload): chat events come from a recorded
+ * session tape, so they must not trigger app side effects (gateway dialogs, skill refreshes,
+ * child-goal toasts, git/review refreshes).
+ */
+export function isSessionTapeReplayRenderer(): boolean {
+  return typeof window !== "undefined" && window.api?.isSessionTapeReplay === true;
+}
+
 function dispatchSkillsRefreshRequested(): void {
   if (typeof window === "undefined") return;
   window.dispatchEvent(new CustomEvent(CUSTOM_EVENTS.SKILLS_REFRESH_REQUESTED));
@@ -120,7 +129,7 @@ export function applyWorkspaceChatEventToAggregator(
     "applyWorkspaceChatEventToAggregator requires event object"
   );
 
-  const allowSideEffects = options?.allowSideEffects !== false;
+  const allowSideEffects = options?.allowSideEffects !== false && !isSessionTapeReplayRenderer();
 
   if (isStreamStart(event)) {
     aggregator.handleStreamStart(event);

src/common/orpc/schemas/errors.ts

@@ -34,6 +34,8 @@ export const SendMessageErrorSchema = z.discriminatedUnion("type", [
   z.object({ type: z.literal("history-changed") }),
   /** A direct edit targeted authentic plan-review feedback; nothing was changed. */
   z.object({ type: z.literal("plan_review_feedback_edit_blocked"), message: z.string() }),
+  // Session tape replay mode (XUM_REPLAY_TAPES) refuses turns and model creation; deterministic
+  z.object({ type: z.literal("session_tape_replay"), message: z.string() }),
   z.object({ type: z.literal("unknown"), raw: z.string() }),
 ]);
 
@@ -79,6 +81,7 @@ export const StreamErrorTypeSchema = z.enum([
   "model_refusal", // Provider declined to answer (refusal/content-filter); retrying the same request will refuse again
   "agent_resolution", // Strict explicit-agent contract failure (agent missing/hidden/disabled/provenance changed); deterministic, retrying reproduces it
   "reasoning_rejected", // Provider rejected replayed reasoning (OpenAI rs_ item / encrypted_content, Anthropic thinking signature) after the in-stream repair; deterministic
+  "session_tape_replay", // Perf harness (XUM_REPLAY_TAPES) refused to replay this workspace's tape; renderer-only, no model involved
   "unknown", // Catch-all
 ]);
 

src/common/types/global.d.ts

@@ -17,6 +17,9 @@ declare global {
     enableTelemetryInDev?: boolean;
     // E2E test mode flag - used to adjust UI behavior (e.g., longer toast durations)
     isE2E?: boolean;
+    // Session tape replay mode (XUM_REPLAY_TAPES, perf harness): chat events are recorded, so
+    // the renderer suppresses their side effects.
+    isSessionTapeReplay?: boolean;
     // Enables in-app React render capture for dev profiling and automated perf tests.
     enableReactPerfProfile?: boolean;
     // Sandbox launchers default tutorials off unless explicitly re-enabled by env.