fix(web): re-ask a run-owned open request's owner when the activation runs

Every ownership check so far ran when the request was made. The workspace can
park an activation behind an unsettled manual edit for an unbounded time, and
the gate that releases it only re-checks the source tab and the activation
sequence — neither of which a run or conversation handoff changes. So a
request enqueued by run A could still focus A's file after the user started
run B or moved to another chat.

Requests now carry `isStillOwned`, re-asked at the moment the activation
executes. A predicate rather than data because only the requester knows what
owning it means: run-owned opens carry their generation and conversation, the
settle watch carries its conversation, and a user's click carries nothing —
a user's choice cannot go stale by waiting.

This closes the class rather than another instance of it: anything that
becomes false between enqueue and activation is now caught at activation.

Also polls the delayed per-write assertion instead of asserting on the tick
after the release. That race made a green guard look like a blocking one under
full-suite load, which is an expensive way to be wrong.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LQKCR9FRJiexWWUpcoFLpm

Author: maxmilian

apps/web/src/components/FileWorkspace.tsx

@@ -212,6 +212,15 @@ export interface WorkspaceOpenRequest {
   name: string;
   nonce: number;
   source: WorkspaceOpenRequestSource;
+  // Re-asked at the moment the activation actually runs, not when the request
+  // is made. An activation can be parked behind an unsettled manual edit for an
+  // unbounded time (see `afterActiveManualEditSettles`), and the requester's own
+  // checks have long since passed by then — so whatever made this request the
+  // right one to honour has to stay askable. Only the requester knows what that
+  // is, which is why this is a predicate rather than data: 'internal' requests
+  // carry their run's ownership, and a user's click carries nothing because a
+  // user's choice cannot go stale.
+  isStillOwned?: () => boolean;
 }
 
 interface Props {
@@ -1605,16 +1614,23 @@ export function FileWorkspace({
   function afterActiveManualEditSettles(
     action: () => void,
     origin: WorkspaceOpenRequestSource = 'user',
+    isStillOwned?: () => boolean,
   ) {
     // Over-reporting is the safe direction and is deliberate here: this can
     // double-count with the `activeTab` effect when the activation lands
     // promptly. The count is only ever compared for equality, so an extra
     // increment can retire a watch early — never move focus off the user's tab.
     if (origin === 'user') onUserActivateTab?.();
+    // The owner is re-checked HERE rather than at the callsite, because this is
+    // the only place that knows whether the action ran immediately or waited.
+    const run = () => {
+      if (isStillOwned && !isStillOwned()) return;
+      action();
+    };
     const sourceTab = activeTabRef.current;
     const exit = manualEditExitHandlersRef.current.get(sourceTab);
     if (!exit) {
-      action();
+      run();
       return;
     }
     const sequence = ++requestedActivationSequenceRef.current;
@@ -1624,7 +1640,7 @@ export function FileWorkspace({
         ok
         && sequence === requestedActivationSequenceRef.current
         && activeTabRef.current === sourceTab
-      ) action();
+      ) run();
     });
   }
 
@@ -1869,13 +1885,17 @@ export function FileWorkspace({
     onTabsStateChange(next);
   }
 
-  function setPersistedActive(name: string | null, origin: WorkspaceOpenRequestSource = 'user') {
+  function setPersistedActive(
+    name: string | null,
+    origin: WorkspaceOpenRequestSource = 'user',
+    isStillOwned?: () => boolean,
+  ) {
     const nextActive = name ?? defaultRootTab;
     if (nextActive === activeTab) return;
     afterActiveManualEditSettles(() => {
       setActiveTab(nextActive);
       commitTabsState(workspaceTabsState(persistedTabs, name));
-    }, origin);
+    }, origin, isStillOwned);
   }
 
   function openRequestedBrowserTab(request: BrowserOpenRequest) {
@@ -2084,6 +2104,7 @@ export function FileWorkspace({
     // classify the user's click as the parent's and leave the settle watcher
     // free to open a higher-ranked artifact over it.
     const origin = openRequest.source;
+    const isStillOwned = openRequest.isStillOwned;
     // Still marked for BOTH sources, so the reporter above never fires off the
     // landed activation for a request that came through this prop: a run's own
     // auto-open must not retire the watch that issued it, and a user-sourced one
@@ -2096,16 +2117,16 @@ export function FileWorkspace({
           ? DESIGN_FILES_TAB
           : name;
       parentRequestedActivationRef.current = nextActive;
-      setPersistedActive(nextActive, origin);
+      setPersistedActive(nextActive, origin, isStillOwned);
       return;
     }
     if (isBrowserTabId(name) && browserTabs.some((tab) => tab.id === name)) {
       parentRequestedActivationRef.current = name;
-      setPersistedActive(name, origin);
+      setPersistedActive(name, origin, isStillOwned);
       return;
     }
     parentRequestedActivationRef.current = name;
-    openFile(name, { forcePersist: true, origin });
+    openFile(name, { forcePersist: true, origin, isStillOwned });
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [openRequest]);
 
@@ -2170,7 +2191,11 @@ export function FileWorkspace({
 
   function openFile(
     name: string,
-    options?: { forcePersist?: boolean; origin?: WorkspaceOpenRequestSource },
+    options?: {
+      forcePersist?: boolean;
+      origin?: WorkspaceOpenRequestSource;
+      isStillOwned?: () => boolean;
+    },
   ) {
     if (name === activeTab) return;
     afterActiveManualEditSettles(() => {
@@ -2190,7 +2215,7 @@ export function FileWorkspace({
       if (nextBrowserTabs !== browserTabs) setBrowserTabs(nextBrowserTabs);
       commitTabsState(workspaceTabsState(nextTabs, name, nextBrowserTabs));
       setActiveTab(name);
-    }, options?.origin ?? 'user');
+    }, options?.origin ?? 'user', options?.isStillOwned);
   }
   openFileRef.current = openFile;
 

apps/web/src/components/ProjectView.tsx

@@ -3561,9 +3561,20 @@ export function ProjectView({
   // gesture or opening on the project's own initiative. Defaulting either way
   // would silently mislabel whichever kind of caller forgot it, and mislabelling
   // a user click is exactly what lets the settle watcher overwrite her choice.
-  const requestOpenFile = useCallback((name: string, source: WorkspaceOpenRequestSource) => {
+  // `isStillOwned` is re-asked by the workspace when the activation actually
+  // runs. Everything checked here is checked at REQUEST time, and the workspace
+  // can park an activation behind an unsettled manual edit for an unbounded
+  // time — long enough for a newer run or another conversation to take over. A
+  // predicate rather than data because only the caller knows what owning this
+  // request means; a user's click passes none, since a user's choice cannot go
+  // stale by waiting.
+  const requestOpenFile = useCallback((
+    name: string,
+    source: WorkspaceOpenRequestSource,
+    isStillOwned?: () => boolean,
+  ) => {
     if (!name) return;
-    setOpenRequest({ name, nonce: Date.now(), source });
+    setOpenRequest({ name, nonce: Date.now(), source, isStillOwned });
   }, []);
   // Handed to ChatPane, whose file links and produced-file chips are clicked by
   // the user; ChatPane itself stays a plain `(name) => void` consumer.
@@ -3844,7 +3855,18 @@ export function ProjectView({
       userActivations: workspaceUserActivationsRef.current,
     });
     if (!decision.keepWatching) pendingAutoOpenSettleRef.current = null;
-    if (decision.openFileName) requestOpenFile(decision.openFileName, 'internal');
+    // The watch's own conversation guard runs above, at decision time; this
+    // carries it to activation time for the same reason the run opener does.
+    // Generation is not this path's fence — the watch is retired outright when a
+    // newer send arms over it — so conversation is the whole ownership here.
+    const watchConversationId = pending.conversationId;
+    if (decision.openFileName) {
+      requestOpenFile(
+        decision.openFileName,
+        'internal',
+        () => activeConversationIdRef.current === watchConversationId,
+      );
+    }
   }, [requestOpenFile]);
 
   // Later lists: every accepted file-list generation (and every focus change,
@@ -7097,10 +7119,16 @@ export function ProjectView({
       // it. Checked here, at the moment the request actually goes out, rather
       // than at arming: the whole point is that an unbounded amount of time can
       // pass in between.
+      const runStillOwnsAutoOpen = () =>
+        autoOpenSettleGenerationRef.current === autoOpenSettleGeneration
+        && activeConversationIdRef.current === runConversationId;
       const requestRunOpenFile = (fileName: string) => {
-        if (autoOpenSettleGenerationRef.current !== autoOpenSettleGeneration) return false;
-        if (activeConversationIdRef.current !== runConversationId) return false;
-        requestOpenFile(fileName, 'internal');
+        if (!runStillOwnsAutoOpen()) return false;
+        // The same predicate travels with the request, because passing it here
+        // only proves the run owned auto-open when it asked. The workspace can
+        // hold the activation until a manual edit flushes, and the two lines
+        // above have already run by then.
+        requestOpenFile(fileName, 'internal', runStillOwnsAutoOpen);
         runAutoOpenedFileNames.add(fileName);
         return true;
       };

apps/web/tests/components/FileWorkspace.userActivationTiming.test.tsx

@@ -19,7 +19,10 @@
 import { cleanup, render, waitFor } from '@testing-library/react';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
-import { FileWorkspace } from '../../src/components/FileWorkspace';
+import {
+  FileWorkspace,
+  type WorkspaceOpenRequest,
+} from '../../src/components/FileWorkspace';
 import { I18nProvider } from '../../src/i18n';
 import type { ProjectFile } from '../../src/types';
 
@@ -37,7 +40,10 @@ vi.mock('../../src/providers/registry', async () => {
   };
 });
 
-const manualEditHeld = { open: false };
+const manualEditHeld: {
+  open: boolean;
+  release: ((settled: boolean) => void) | null;
+} = { open: false, release: null };
 
 vi.mock('../../src/components/FileViewer', () => ({
   // Stands in for a file sitting in Manual Edit mode: it registers an exit
@@ -55,7 +61,12 @@ vi.mock('../../src/components/FileViewer', () => ({
   }) => {
     onManualEditExitHandlerChange?.(file.name, () => {
       manualEditHeld.open = true;
-      return new Promise<boolean>(() => {});
+      // Resolvable, unlike a plain never-settling promise: the ownership tests
+      // below need the parked activation to be RELEASED after the handoff, to
+      // show it is dropped at that moment rather than merely still waiting.
+      return new Promise<boolean>((resolve) => {
+        manualEditHeld.release = resolve;
+      });
     });
     return <div data-testid="file-viewer">{file.name}</div>;
   },
@@ -80,7 +91,7 @@ const OTHER = textFile('other.md');
 function renderWorkspace(props: {
   onTabsStateChange: () => void;
   onUserActivateTab: () => void;
-  openRequest?: { name: string; nonce: number; source: 'user' | 'internal' } | null;
+  openRequest?: WorkspaceOpenRequest | null;
 }) {
   return render(
     <I18nProvider>
@@ -104,6 +115,7 @@ describe('FileWorkspace user-activation reporting', () => {
   afterEach(() => {
     cleanup();
     manualEditHeld.open = false;
+    manualEditHeld.release = null;
     vi.clearAllMocks();
   });
 
@@ -173,4 +185,78 @@ describe('FileWorkspace user-activation reporting', () => {
     await waitFor(() => expect(manualEditHeld.open).toBe(true));
     expect(onUserActivateTab).not.toHaveBeenCalled();
   });
+  // Shared by the two ownership tests: render, then hand the workspace an
+  // internal request whose owner predicate the test controls, and leave the
+  // activation parked on the manual edit.
+  async function parkInternalRequest(isStillOwned: () => boolean) {
+    const onTabsStateChange = vi.fn();
+    const onUserActivateTab = vi.fn();
+    const request: WorkspaceOpenRequest = {
+      name: 'other.md',
+      nonce: 1,
+      source: 'internal',
+      isStillOwned,
+    };
+
+    const { rerender } = renderWorkspace({ onTabsStateChange, onUserActivateTab });
+    rerender(
+      <I18nProvider>
+        <FileWorkspace
+          projectId="project-1"
+          projectKind="prototype"
+          files={[NOTES, OTHER]}
+          liveArtifacts={[]}
+          onRefreshFiles={vi.fn()}
+          isDeck={false}
+          tabsState={{ tabs: ['notes.md'], active: 'notes.md' }}
+          onTabsStateChange={onTabsStateChange}
+          onUserActivateTab={onUserActivateTab}
+          openRequest={request}
+        />
+      </I18nProvider>,
+    );
+
+    // The activation must really be parked, or releasing it below proves nothing.
+    await waitFor(() => expect(manualEditHeld.release).not.toBeNull());
+    expect(onTabsStateChange).not.toHaveBeenCalled();
+    return { onTabsStateChange };
+  }
+
+  async function releaseManualEdit() {
+    manualEditHeld.release?.(true);
+    await waitFor(() => expect(manualEditHeld.release).not.toBeNull());
+    await Promise.resolve();
+    await Promise.resolve();
+  }
+
+  // Positive control for the ownership test below: without it, "did not
+  // activate" would also pass if the parked activation simply never ran.
+  it('lands a parked internal activation whose run still owns it', async () => {
+    const { onTabsStateChange } = await parkInternalRequest(() => true);
+
+    await releaseManualEdit();
+
+    await waitFor(() =>
+      expect(onTabsStateChange).toHaveBeenCalledWith(
+        expect.objectContaining({ active: 'other.md' }),
+      ),
+    );
+  });
+
+  it('drops a parked internal activation whose run lost ownership while it waited', async () => {
+    // Reviewer #6842 (nettee, 2026-08-18, round 7): the requester's generation
+    // and conversation checks ran when the request was made. This window is
+    // unbounded, so a newer run or another conversation can take over inside
+    // it — and the parked callback would still activate, because the gate only
+    // re-checks the source tab and the activation sequence, neither of which a
+    // handoff changes. Re-asking the owner at release is what stops it.
+    let owned = true;
+    const { onTabsStateChange } = await parkInternalRequest(() => owned);
+
+    // The handoff: a newer send, or the user moving to another chat.
+    owned = false;
+    await releaseManualEdit();
+
+    expect(onTabsStateChange).not.toHaveBeenCalled();
+  });
 });

apps/web/tests/components/ProjectView.autoOpenSettle.test.tsx

@@ -831,7 +831,15 @@ describe('ProjectView auto-open settle watcher lifecycle', () => {
     });
 
     await turn.releasePerWriteRead();
-    expect(openRequestKeys().map((key) => key.name)).toContain('plan.md');
+    // Polled rather than asserted on the tick after the release: the release
+    // awaits a fixed number of microtasks, which is not a guarantee that the
+    // continuation behind it has reached its open. Under full-suite load that
+    // raced, and the failure looked like "the guard blocked it" rather than
+    // "the assertion ran early" — the two are indistinguishable from an empty
+    // list, which cost real debugging time.
+    await waitFor(() =>
+      expect(openRequestKeys().map((key) => key.name)).toContain('plan.md'),
+    );
 
     // The workspace follows the open request, exactly as it would in the app.
     await act(async () => {