feat(web): group sidebar v2 by worktree and scope panes to the checkout

apps/server/src/server.test.ts

@@ -6739,6 +6739,75 @@ it.layer(NodeServices.layer)("server router seam", (it) => {
     }).pipe(Effect.provide(NodeHttpServer.layerTest)),
   );
 
+  it.effect("skips closing terminals on archive while a sibling thread shares the worktree", () =>
+    Effect.gen(function* () {
+      const threadId = ThreadId.make("thread-archive-shared-worktree");
+      const siblingThreadId = ThreadId.make("thread-archive-shared-sibling");
+      const worktreePath = "/tmp/worktrees/shared";
+      const effects: string[] = [];
+      const now = "2026-01-01T00:00:00.000Z";
+
+      yield* buildAppUnderTest({
+        layers: {
+          terminalManager: {
+            close: (input) =>
+              Effect.sync(() => {
+                effects.push(`terminal.close:${input.threadId}`);
+              }),
+          },
+          orchestrationEngine: {
+            dispatch: (command) =>
+              Effect.sync(() => {
+                effects.push(`dispatch:${command.type}`);
+                return { sequence: 1 };
+              }),
+          },
+          projectionSnapshotQuery: {
+            getThreadShellById: () =>
+              Effect.succeed(
+                Option.some(
+                  makeDefaultOrchestrationThreadShell({
+                    id: threadId,
+                    updatedAt: now,
+                    worktreePath,
+                  }),
+                ),
+              ),
+            getShellSnapshot: () =>
+              Effect.succeed({
+                snapshotSequence: 1,
+                projects: [],
+                threads: [
+                  makeDefaultOrchestrationThreadShell({
+                    id: siblingThreadId,
+                    updatedAt: now,
+                    worktreePath,
+                  }),
+                ],
+                updatedAt: now,
+              }),
+          },
+        },
+      });
+
+      const wsUrl = yield* getWsServerUrl("/ws");
+      yield* Effect.scoped(
+        withWsRpcClient(wsUrl, (client) =>
+          client[ORCHESTRATION_WS_METHODS.dispatchCommand]({
+            type: "thread.archive",
+            commandId: CommandId.make("cmd-thread-archive-shared-worktree"),
+            threadId,
+          }),
+        ),
+      );
+
+      // Terminals are worktree-scoped on the client: the sibling still uses
+      // the checkout, so its terminals (e.g. a running dev server) must
+      // survive the archive.
+      assert.deepEqual(effects, ["dispatch:thread.archive"]);
+    }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+  );
+
   it.effect(
     "bootstraps first-send worktree turns on the server before dispatching turn start",
     () =>

apps/server/src/ws.ts

@@ -30,6 +30,7 @@ import {
   OrchestrationDispatchCommandError,
   type OrchestrationEvent,
   type OrchestrationShellStreamEvent,
+  type OrchestrationThreadShell,
   type OrchestrationShellStreamItem,
   type OrchestrationThreadStreamItem,
   OrchestrationGetFullThreadDiffError,
@@ -1100,6 +1101,13 @@ const makeWsRpcLayer = (
         };
       });
 
+      // Mirrors the client's worktree identity rule (worktreeCleanup.ts):
+      // blank and null both mean "the project's local checkout".
+      const normalizeWorktreePathForArchive = (worktreePath: string | null): string | null => {
+        const trimmed = worktreePath?.trim();
+        return trimmed !== undefined && trimmed.length > 0 ? trimmed : null;
+      };
+
       const refreshGitStatus = (cwd: string) =>
         vcsStatusBroadcaster
           .refreshStatus(cwd)
@@ -1111,21 +1119,17 @@ const makeWsRpcLayer = (
             ORCHESTRATION_WS_METHODS.dispatchCommand,
             Effect.gen(function* () {
               const normalizedCommand = yield* normalizeDispatchCommand(command);
-              const shouldStopSessionAfterArchive =
+              const threadShellBeforeArchive =
                 normalizedCommand.type === "thread.archive"
                   ? yield* projectionSnapshotQuery
                       .getThreadShellById(normalizedCommand.threadId)
-                      .pipe(
-                        Effect.map(
-                          Option.match({
-                            onNone: () => false,
-                            onSome: (thread) =>
-                              thread.session !== null && thread.session.status !== "stopped",
-                          }),
-                        ),
-                        Effect.orElseSucceed(() => false),
-                      )
-                  : false;
+                      .pipe(Effect.orElseSucceed(() => Option.none<OrchestrationThreadShell>()))
+                  : Option.none<OrchestrationThreadShell>();
+              const shouldStopSessionAfterArchive = Option.match(threadShellBeforeArchive, {
+                onNone: () => false,
+                onSome: (thread) =>
+                  thread.session !== null && thread.session.status !== "stopped",
+              });
               const result = yield* dispatchNormalizedCommand(normalizedCommand);
               if (normalizedCommand.type === "thread.archive") {
                 if (shouldStopSessionAfterArchive) {
@@ -1150,14 +1154,36 @@ const makeWsRpcLayer = (
                   );
                 }
 
-                yield* terminalManager.close({ threadId: normalizedCommand.threadId }).pipe(
-                  Effect.catch((error) =>
-                    Effect.logWarning("failed to close thread terminals after archive", {
-                      threadId: normalizedCommand.threadId,
-                      error: error.message,
-                    }),
-                  ),
-                );
+                // Terminals are worktree-scoped on the client (every thread in
+                // a checkout shares one set of ptys via a canonical thread id),
+                // so archiving one thread must not kill sessions that sibling
+                // threads still use — e.g. a running dev server.
+                const worktreeStillInUse = yield* Option.match(threadShellBeforeArchive, {
+                  onNone: () => Effect.succeed(false),
+                  onSome: (archivedThread) =>
+                    projectionSnapshotQuery.getShellSnapshot().pipe(
+                      Effect.map((snapshot) =>
+                        snapshot.threads.some(
+                          (thread) =>
+                            thread.id !== archivedThread.id &&
+                            thread.projectId === archivedThread.projectId &&
+                            normalizeWorktreePathForArchive(thread.worktreePath) ===
+                              normalizeWorktreePathForArchive(archivedThread.worktreePath),
+                        ),
+                      ),
+                      Effect.orElseSucceed(() => false),
+                    ),
+                });
+                if (!worktreeStillInUse) {
+                  yield* terminalManager.close({ threadId: normalizedCommand.threadId }).pipe(
+                    Effect.catch((error) =>
+                      Effect.logWarning("failed to close thread terminals after archive", {
+                        threadId: normalizedCommand.threadId,
+                        error: error.message,
+                      }),
+                    ),
+                  );
+                }
               }
               return result;
             }).pipe(

apps/web/src/browser/openFileInPreview.ts

@@ -21,6 +21,7 @@ import {
   rememberPreviewUrl,
 } from "~/previewStateStore";
 import { useRightPanelStore } from "~/rightPanelStore";
+import { resolveWorktreeCanonicalThreadRef } from "~/worktreeScope";
 
 export const isBrowserPreviewFile = (path: string): boolean =>
   /\.(?:html?|pdf)$/i.test(path.split(/[?#]/, 1)[0] ?? "");
@@ -41,9 +42,12 @@ export async function openUrlInPreview<E>(input: {
   readonly url: string;
   readonly openPreview: OpenPreviewMutation<E>;
 }): Promise<AtomCommandResult<void, E>> {
+  // Preview sessions are worktree-scoped: open through the worktree's
+  // canonical thread id so sibling threads share one set of tabs.
+  const canonicalRef = resolveWorktreeCanonicalThreadRef(input.threadRef);
   const result = await input.openPreview({
-    environmentId: input.threadRef.environmentId,
-    input: { threadId: input.threadRef.threadId, url: input.url },
+    environmentId: canonicalRef.environmentId,
+    input: { threadId: canonicalRef.threadId, url: input.url },
   });
   return mapAtomCommandResult(result, (snapshot) => {
     applyPreviewServerSnapshot(input.threadRef, snapshot);