feat: persist last viewed workspace target

Author: pallyoung

e2e/fixtures/seed-hydrate-refresh-db.ts

@@ -134,6 +134,15 @@ try {
     "Unavailable"
   );
 
+  db.prepare("INSERT INTO user_settings (key, value) VALUES (?, ?)").run(
+    "workspace.lastViewedTarget",
+    JSON.stringify({
+      workspaceId: WORKSPACE_ID,
+      sessionId: INTERRUPTED_SESSION_ID,
+      updatedAt: now,
+    })
+  );
+
   console.log(
     JSON.stringify({
       dbPath,

e2e/specs/sessions/hydrate-refresh.spec.ts

@@ -276,8 +276,8 @@ test.describe("session hydrate refresh acceptance", () => {
 
       const visibleCard = page.locator(".mobile-shell .session-card.agent-pane").first();
       await expect(visibleCard).toBeVisible();
-      await expect(visibleCard).toHaveAttribute("data-session-id", UNAVAILABLE_SESSION_ID);
-      await expect(visibleCard.locator(".session-title")).toHaveText("Unavailable");
+      await expect(visibleCard).toHaveAttribute("data-session-id", INTERRUPTED_SESSION_ID);
+      await expect(visibleCard.locator(".session-title")).toHaveText("Resume me");
       await expect(visibleCard.locator(".session-state-badge")).toHaveText(ENDED_STATE_LABEL);
       await expect(visibleCard.getByRole("button", { name: "Expand terminal keys" })).toHaveCount(
         0
@@ -290,8 +290,8 @@ test.describe("session hydrate refresh acceptance", () => {
       });
       await expect(page.getByTestId("mobile-shell")).toBeVisible({ timeout: 20000 });
       await expect(visibleCard).toBeVisible();
-      await expect(visibleCard).toHaveAttribute("data-session-id", UNAVAILABLE_SESSION_ID);
-      await expect(visibleCard.locator(".session-title")).toHaveText("Unavailable");
+      await expect(visibleCard).toHaveAttribute("data-session-id", INTERRUPTED_SESSION_ID);
+      await expect(visibleCard.locator(".session-title")).toHaveText("Resume me");
       await expect(visibleCard.locator(".session-state-badge")).toHaveText(ENDED_STATE_LABEL);
       await expect(visibleCard.getByRole("button", { name: "Expand terminal keys" })).toHaveCount(
         0
@@ -301,10 +301,35 @@ test.describe("session hydrate refresh acceptance", () => {
       const agentSheet = page.getByRole("region", { name: "Agent Sessions sheet" });
       await expect(agentSheet).toBeVisible();
       await expect(agentSheet.getByRole("button", { name: "Resume me" })).toBeVisible();
-      await expect(agentSheet.getByRole("button", { name: "Unavailable" })).toHaveAttribute(
+      await expect(agentSheet.getByRole("button", { name: "Resume me" })).toHaveAttribute(
         "aria-pressed",
         "true"
       );
+
+      const secondContext = await browser.newContext({
+        viewport: { width: 430, height: 932 },
+      });
+
+      try {
+        const secondPage = await secondContext.newPage();
+        await secondPage.addInitScript(() => {
+          window.localStorage.setItem("ui.locale", JSON.stringify("en"));
+        });
+
+        await secondPage.goto(`${BASE_URL}/workspace`);
+        await expect(secondPage.getByTestId("workspace-resolving-shell")).toHaveCount(0, {
+          timeout: 20000,
+        });
+        await expect(secondPage.getByTestId("mobile-shell")).toBeVisible({ timeout: 20000 });
+
+        const secondVisibleCard = secondPage
+          .locator(".mobile-shell .session-card.agent-pane")
+          .first();
+        await expect(secondVisibleCard).toHaveAttribute("data-session-id", INTERRUPTED_SESSION_ID);
+        await expect(secondVisibleCard.locator(".session-title")).toHaveText("Resume me");
+      } finally {
+        await secondContext.close();
+      }
     } finally {
       await context.close();
     }

e2e/specs/workspace/route-history.spec.ts

@@ -145,8 +145,9 @@ test.describe("workspace route history acceptance", () => {
     baseURL: BASE_URL,
   });
 
-  test("switching workspaces keeps the URL stable and does not create history entries", async ({
+  test("switching workspaces keeps the URL stable and restores across refresh and a new browser context", async ({
     page,
+    browser,
   }) => {
     await page.goto("/");
     await expect(page.locator(".topbar-tab")).toHaveCount(2, { timeout: 20000 });
@@ -163,10 +164,32 @@ test.describe("workspace route history acceptance", () => {
 
     await expect(page.locator(".topbar-tab.active")).toContainText("older-workspace");
     await expect(page).toHaveURL(`${BASE_URL}/workspace`);
+    await page.waitForTimeout(300);
 
     const historyLengthAfterSwitch = await page.evaluate(() => window.history.length);
     expect(historyLengthAfterSwitch).toBe(historyLengthBeforeSwitch);
 
+    await page.reload();
+
+    await expect(page.getByTestId("workspace-resolving-shell")).toHaveCount(0, { timeout: 20000 });
+    await expect(page.locator(".topbar-tab")).toHaveCount(2, { timeout: 20000 });
+    await expect(page.locator(".topbar-tab.active")).toContainText("older-workspace");
+    await expect(page).toHaveURL(`${BASE_URL}/workspace`);
+
+    const secondContext = await browser.newContext();
+    try {
+      const secondPage = await secondContext.newPage();
+      await secondPage.goto(`${BASE_URL}/workspace`);
+      await expect(secondPage.getByTestId("workspace-resolving-shell")).toHaveCount(0, {
+        timeout: 20000,
+      });
+      await expect(secondPage.locator(".topbar-tab")).toHaveCount(2, { timeout: 20000 });
+      await expect(secondPage.locator(".topbar-tab.active")).toContainText("older-workspace");
+      await expect(secondPage).toHaveURL(`${BASE_URL}/workspace`);
+    } finally {
+      await secondContext.close();
+    }
+
     await page.goBack();
 
     await expect(page).toHaveURL("about:blank");

packages/core/src/domain/types.ts

@@ -38,6 +38,12 @@ export interface UiState {
   paneLayout?: WorkspacePaneNode;
 }
 
+export interface WorkspaceLastViewedTarget {
+  workspaceId: string;
+  sessionId?: string;
+  updatedAt: number;
+}
+
 export interface Terminal {
   id: string;
   workspaceId: string;

packages/server/src/__tests__/workspace-commands.test.ts

@@ -10,6 +10,7 @@ import { dispatch } from "../ws/dispatch.js";
 
 // Import command handlers to register them
 import "../commands/workspace.js";
+import "../commands/workspace-activity.js";
 
 describe("Workspace Commands", () => {
   let db: ReturnType<typeof openDatabase>;
@@ -46,7 +47,9 @@ describe("Workspace Commands", () => {
     ctx = {
       db,
       workspaceMgr,
-      sessionMgr: {},
+      sessionMgr: {
+        get: vi.fn(() => undefined),
+      },
       terminalMgr: {},
       eventBus,
       broadcaster: { broadcast: () => {} },
@@ -202,4 +205,115 @@ describe("Workspace Commands", () => {
       });
     });
   });
+
+  describe("workspace.lastViewedTarget", () => {
+    it("persists and returns the global workspace last-viewed target", async () => {
+      const dir = join(tmpdir(), `workspace-target-test-${Date.now()}`);
+      await mkdir(dir);
+
+      const openResult = await dispatch(
+        {
+          kind: "command",
+          id: "open-workspace-target",
+          op: "workspace.open",
+          args: { path: dir },
+        },
+        ctx
+      );
+
+      expect(openResult.ok).toBe(true);
+      const workspaceId = (openResult.data as { id: string }).id;
+
+      const writeResult = await dispatch(
+        {
+          kind: "command",
+          id: "set-last-viewed-target",
+          op: "workspace.lastViewedTarget.set",
+          args: {
+            workspaceId,
+            sessionId: "sess-123",
+          },
+        },
+        ctx
+      );
+
+      expect(writeResult.ok).toBe(true);
+      expect(writeResult.data).toMatchObject({
+        workspaceId,
+        sessionId: undefined,
+      });
+      expect((writeResult.data as { updatedAt: number }).updatedAt).toEqual(expect.any(Number));
+
+      const readResult = await dispatch(
+        {
+          kind: "command",
+          id: "get-last-viewed-target",
+          op: "workspace.lastViewedTarget.get",
+          args: {},
+        },
+        ctx
+      );
+
+      expect(readResult.ok).toBe(true);
+      expect(readResult.data).toMatchObject({
+        workspaceId,
+        sessionId: undefined,
+      });
+      expect((readResult.data as { updatedAt: number }).updatedAt).toEqual(expect.any(Number));
+    });
+
+    it("drops an out-of-workspace session id while preserving the workspace target", async () => {
+      const dir = join(tmpdir(), `workspace-target-mismatch-${Date.now()}`);
+      await mkdir(dir);
+
+      const openResult = await dispatch(
+        {
+          kind: "command",
+          id: "open-workspace-target-mismatch",
+          op: "workspace.open",
+          args: { path: dir },
+        },
+        ctx
+      );
+
+      expect(openResult.ok).toBe(true);
+      const workspaceId = (openResult.data as { id: string }).id;
+
+      const result = await dispatch(
+        {
+          kind: "command",
+          id: "set-last-viewed-target-mismatch",
+          op: "workspace.lastViewedTarget.set",
+          args: {
+            workspaceId,
+            sessionId: "sess-missing",
+          },
+        },
+        ctx
+      );
+
+      expect(result.ok).toBe(true);
+      expect(result.data).toMatchObject({
+        workspaceId,
+        sessionId: undefined,
+      });
+    });
+
+    it("returns workspace_not_found when writing a target for a missing workspace", async () => {
+      const result = await dispatch(
+        {
+          kind: "command",
+          id: "set-last-viewed-target-missing-workspace",
+          op: "workspace.lastViewedTarget.set",
+          args: {
+            workspaceId: "ws-missing",
+          },
+        },
+        ctx
+      );
+
+      expect(result.ok).toBe(false);
+      expect(result.error?.code).toBe("workspace_not_found");
+    });
+  });
 });

packages/server/src/commands/workspace-activity.ts

@@ -1,6 +1,9 @@
+import type { WorkspaceLastViewedTarget } from "@coder-studio/core";
 import { z } from "zod";
 import { registerCommand } from "../ws/dispatch.js";
 
+const WORKSPACE_LAST_VIEWED_TARGET_KEY = "workspace.lastViewedTarget";
+
 registerCommand(
   "workspace.activate",
   z.object({
@@ -24,3 +27,57 @@ registerCommand("workspace.deactivate", z.object({}), async (_args, ctx, clientI
   ctx.autoFetch.unregisterViewer(clientId);
   return {};
 });
+
+registerCommand("workspace.lastViewedTarget.get", z.object({}), async (_args, ctx) => {
+  const row = ctx.db
+    .prepare("SELECT value FROM user_settings WHERE key = ?")
+    .get(WORKSPACE_LAST_VIEWED_TARGET_KEY) as { value: string } | undefined;
+
+  if (!row) {
+    return null;
+  }
+
+  const target = JSON.parse(row.value) as WorkspaceLastViewedTarget;
+  return {
+    workspaceId: target.workspaceId,
+    sessionId: target.sessionId,
+    updatedAt: target.updatedAt,
+  } satisfies WorkspaceLastViewedTarget;
+});
+
+registerCommand(
+  "workspace.lastViewedTarget.set",
+  z.object({
+    workspaceId: z.string(),
+    sessionId: z.string().optional(),
+  }),
+  async (args, ctx) => {
+    const workspace = ctx.workspaceMgr.get(args.workspaceId);
+    if (!workspace) {
+      throw {
+        code: "workspace_not_found",
+        message: `Workspace not found: ${args.workspaceId}`,
+      };
+    }
+
+    const session = args.sessionId ? ctx.sessionMgr.get(args.sessionId) : undefined;
+
+    const nextTarget: WorkspaceLastViewedTarget = {
+      workspaceId: args.workspaceId,
+      sessionId: session && session.workspaceId === args.workspaceId ? session.id : undefined,
+      updatedAt: Date.now(),
+    };
+
+    ctx.db
+      .prepare(
+        `
+          INSERT INTO user_settings (key, value)
+          VALUES (?, ?)
+          ON CONFLICT(key) DO UPDATE SET value = excluded.value
+        `
+      )
+      .run(WORKSPACE_LAST_VIEWED_TARGET_KEY, JSON.stringify(nextTarget));
+
+    return nextTarget;
+  }
+);

packages/web/src/atoms/app-ui.ts

@@ -4,6 +4,7 @@
  * Shared app-level UI state that is not owned by a single feature.
  */
 
+import type { WorkspaceLastViewedTarget } from "@coder-studio/core";
 import { atom } from "jotai";
 import { atomWithStorage, createJSONStorage } from "jotai/utils";
 import { resolveStoredThemeId } from "../theme";
@@ -79,6 +80,15 @@ export const commandPaletteOpenAtom = atom<boolean>(false);
  */
 export const pendingFocusSessionAtom = atom<string | null>(null);
 
+/**
+ * Server-hydrated global last-viewed workspace/session target.
+ *
+ * This mirrors the server-backed cross-device target and is not persisted
+ * locally. Desktop restores only `workspaceId`; mobile can additionally use
+ * `sessionId` during session selection.
+ */
+export const lastViewedTargetAtom = atom<WorkspaceLastViewedTarget | null>(null);
+
 /**
  * Currently visible session in the mobile workspace shell.
  *