3 files changed, 261 insertions, 15 deletions
diff --git a/src/features/workspaces/adapter/http.test.ts b/src/features/workspaces/adapter/http.test.ts
index 18d8939..d6409ca 100644
--- a/src/features/workspaces/adapter/http.test.ts
+++ b/src/features/workspaces/adapter/http.test.ts
@@ -79,15 +79,37 @@ describe("createWorkspaceHttp", () => {
     expect(result).toEqual({ ok: false, error: "invalid slug" });
   });
 
-  it("get returns null on 404", async () => {
+  it("get reports a missing lookup on 404", async () => {
     const http = createWorkspaceHttp(BASE, fakeFetch([{ status: 404 }]));
-    expect(await http.get("nope")).toBeNull();
+    expect(await http.get("nope")).toEqual({ kind: "missing" });
   });
 
   it("get returns the workspace on 200", async () => {
-    const ws = { id: "x", title: "X", defaultCwd: "/home", createdAt: 1, lastActivityAt: 2 };
+    const ws = {
+      id: "x",
+      title: "X",
+      defaultCwd: "/home",
+      defaultComputerId: null,
+      starred: false,
+      archived: false,
+      createdAt: 1,
+      lastActivityAt: 2,
+    };
     const http = createWorkspaceHttp(BASE, fakeFetch([{ body: ws }]));
-    expect(await http.get("x")).toEqual(ws);
+    expect(await http.get("x")).toEqual({ kind: "found", workspace: ws });
+  });
+
+  it("get distinguishes a failed response from 404 (not 'missing')", async () => {
+    const http = createWorkspaceHttp(
+      BASE,
+      fakeFetch([{ status: 500, body: { error: "db down" } }]),
+    );
+    expect(await http.get("x")).toEqual({ kind: "failed", error: "db down" });
+  });
+
+  it("get reports a network error as failed (not 'missing')", async () => {
+    const http = createWorkspaceHttp(BASE, fakeFetch([new Error("network")]));
+    expect(await http.get("x")).toEqual({ kind: "failed", error: "network" });
   });
 
   it("setTitle PUTs the title", async () => {
@@ -186,4 +208,67 @@ describe("createWorkspaceHttp", () => {
     const result = await http.unstar("a");
     expect(result).toEqual({ ok: false, error: "Failed to unstar workspace" });
   });
+
+  it("list passes the archived filter as a query param", async () => {
+    const fetchImpl = fakeFetch([{ body: { workspaces: [] } }]);
+    const http = createWorkspaceHttp(BASE, fetchImpl);
+    await http.list("true");
+    expect(fetchImpl).toHaveBeenCalledWith(`${BASE}/workspaces?archived=true`);
+  });
+
+  it("list omits the query param when no filter is given", async () => {
+    const fetchImpl = fakeFetch([{ body: { workspaces: [] } }]);
+    const http = createWorkspaceHttp(BASE, fetchImpl);
+    await http.list();
+    expect(fetchImpl).toHaveBeenCalledWith(`${BASE}/workspaces`);
+  });
+
+  it("archive PUTs /archive with no body and returns the updated workspace", async () => {
+    const ws = {
+      id: "a",
+      title: "A",
+      defaultCwd: null,
+      defaultComputerId: null,
+      starred: false,
+      archived: true,
+      createdAt: 1,
+      lastActivityAt: 2,
+    };
+    const fetchImpl = fakeFetch([{ body: ws }]);
+    const http = createWorkspaceHttp(BASE, fetchImpl);
+    const result = await http.archive("a");
+    expect(result).toEqual({ ok: true, value: ws });
+    const call = (fetchImpl as unknown as ReturnType<typeof vi.fn>).mock.calls[0];
+    expect(call?.[0]).toBe(`${BASE}/workspaces/a/archive`);
+    expect(call?.[1]).toEqual({ method: "PUT" });
+  });
+
+  it("unarchive DELETEs /archive with no body and returns the updated workspace", async () => {
+    const ws = {
+      id: "a",
+      title: "A",
+      defaultCwd: null,
+      defaultComputerId: null,
+      starred: false,
+      archived: false,
+      createdAt: 1,
+      lastActivityAt: 2,
+    };
+    const fetchImpl = fakeFetch([{ body: ws }]);
+    const http = createWorkspaceHttp(BASE, fetchImpl);
+    const result = await http.unarchive("a");
+    expect(result).toEqual({ ok: true, value: ws });
+    const call = (fetchImpl as unknown as ReturnType<typeof vi.fn>).mock.calls[0];
+    expect(call?.[0]).toBe(`${BASE}/workspaces/a/archive`);
+    expect(call?.[1]).toEqual({ method: "DELETE" });
+  });
+
+  it("archive surfaces the backend error on a 409 (default workspace)", async () => {
+    const http = createWorkspaceHttp(
+      BASE,
+      fakeFetch([{ status: 409, body: { error: 'The "default" workspace cannot be archived' } }]),
+    );
+    const result = await http.archive("default");
+    expect(result).toEqual({ ok: false, error: 'The "default" workspace cannot be archived' });
+  });
 });
diff --git a/src/features/workspaces/adapter/http.ts b/src/features/workspaces/adapter/http.ts
index 5673881..3f7f058 100644
--- a/src/features/workspaces/adapter/http.ts
+++ b/src/features/workspaces/adapter/http.ts
@@ -9,6 +9,7 @@ import type {
   WorkspaceListResponse,
   WorkspaceResponse,
 } from "@dispatch/transport-contract";
+import type { WorkspaceLookup } from "../logic/create";
 
 /**
  * Workspace HTTP effects — the injected edge that talks to the backend's
@@ -19,24 +20,34 @@ import type {
  * safe empty/null on failure (non-fatal — the UI falls back gracefully).
  *
  * Endpoints ([email protected]):
- * - `GET /workspaces` → list
+ * - `GET /workspaces` (optional `?archived=true|false|all`, default `false` = active only) → list
  * - `PUT /workspaces/:id` (create-on-miss, idempotent) → ensure
- * - `GET /workspaces/:id` (404 → null) → get
+ * - `GET /workspaces/:id` (found | 404-missing | failed) → get
  * - `PUT /workspaces/:id/title` → rename
  * - `PUT /workspaces/:id/default-cwd` → set/clear default cwd
  * - `PUT /workspaces/:id/default-computer` → set/clear default computer (SSH handoff #2)
  * - `PUT /workspaces/:id/star` (create-on-miss) → star (concurrency priority)
  * - `DELETE /workspaces/:id/star` (create-on-miss) → unstar
+ * - `PUT /workspaces/:id/archive` (create-on-miss; 409 for "default") → archive (hide from home grid)
+ * - `DELETE /workspaces/:id/archive` (create-on-miss; 409 for "default") → unarchive
  * - `DELETE /workspaces/:id` (409 for "default") → delete
  */
 export type WorkspaceResult<T> =
   | { readonly ok: true; readonly value: T }
   | { readonly ok: false; readonly error: string };
 
+/** Which workspaces `GET /workspaces` returns: active-only (default), archived-only, or all. */
+export type WorkspaceArchivedFilter = "true" | "false" | "all";
+
 export interface WorkspaceHttp {
-  list(): Promise<readonly WorkspaceEntry[]>;
+  list(archived?: WorkspaceArchivedFilter): Promise<readonly WorkspaceEntry[]>;
   ensure(id: string, body?: EnsureWorkspaceRequest): Promise<WorkspaceResult<Workspace>>;
-  get(id: string): Promise<Workspace | null>;
+  /**
+   * Authoritative existence probe. 404 → `missing`, a network/server failure →
+   * `failed` (distinct on purpose: the create gate must not treat a broken
+   * check as "doesn't exist"), 200 → the workspace (`found`).
+   */
+  get(id: string): Promise<WorkspaceLookup>;
   setTitle(id: string, title: string): Promise<WorkspaceResult<Workspace>>;
   setDefaultCwd(id: string, defaultCwd: string | null): Promise<WorkspaceResult<Workspace>>;
   setDefaultComputer(id: string, computerId: string | null): Promise<WorkspaceResult<Workspace>>;
@@ -44,6 +55,10 @@ export interface WorkspaceHttp {
   star(id: string): Promise<WorkspaceResult<Workspace>>;
   /** Unstar a workspace. Create-on-miss; no body. */
   unstar(id: string): Promise<WorkspaceResult<Workspace>>;
+  /** Archive a workspace (hide from the home grid; data untouched). Create-on-miss; no body. */
+  archive(id: string): Promise<WorkspaceResult<Workspace>>;
+  /** Unarchive a workspace (restore to the home grid). Create-on-miss; no body. */
+  unarchive(id: string): Promise<WorkspaceResult<Workspace>>;
   delete(id: string): Promise<WorkspaceResult<{ closedCount: number }>>;
 }
 
@@ -58,9 +73,10 @@ async function errText(res: Response): Promise<string> {
 
 export function createWorkspaceHttp(httpBase: string, fetchImpl: typeof fetch): WorkspaceHttp {
   return {
-    async list(): Promise<readonly WorkspaceEntry[]> {
+    async list(archived?: WorkspaceArchivedFilter): Promise<readonly WorkspaceEntry[]> {
       try {
-        const res = await fetchImpl(`${httpBase}/workspaces`);
+        const qs = archived !== undefined ? `?archived=${archived}` : "";
+        const res = await fetchImpl(`${httpBase}/workspaces${qs}`);
         if (!res.ok) return [];
         const data = (await res.json()) as WorkspaceListResponse;
         return data.workspaces;
@@ -86,13 +102,17 @@ export function createWorkspaceHttp(httpBase: string, fetchImpl: typeof fetch):
       }
     },
 
-    async get(id): Promise<Workspace | null> {
+    async get(id): Promise<WorkspaceLookup> {
       try {
         const res = await fetchImpl(`${httpBase}/workspaces/${encodeURIComponent(id)}`);
-        if (res.status === 404 || !res.ok) return null;
-        return (await res.json()) as WorkspaceResponse;
-      } catch {
-        return null;
+        if (res.status === 404) return { kind: "missing" };
+        if (!res.ok) return { kind: "failed", error: await errText(res) };
+        return { kind: "found", workspace: (await res.json()) as WorkspaceResponse };
+      } catch (err) {
+        return {
+          kind: "failed",
+          error: err instanceof Error ? err.message : "Workspace lookup failed",
+        };
       }
     },
 
@@ -171,6 +191,30 @@ export function createWorkspaceHttp(httpBase: string, fetchImpl: typeof fetch):
       }
     },
 
+    async archive(id): Promise<WorkspaceResult<Workspace>> {
+      try {
+        const res = await fetchImpl(`${httpBase}/workspaces/${encodeURIComponent(id)}/archive`, {
+          method: "PUT",
+        });
+        if (!res.ok) return { ok: false, error: await errText(res) };
+        return { ok: true, value: (await res.json()) as WorkspaceResponse };
+      } catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : "Archive failed" };
+      }
+    },
+
+    async unarchive(id): Promise<WorkspaceResult<Workspace>> {
+      try {
+        const res = await fetchImpl(`${httpBase}/workspaces/${encodeURIComponent(id)}/archive`, {
+          method: "DELETE",
+        });
+        if (!res.ok) return { ok: false, error: await errText(res) };
+        return { ok: true, value: (await res.json()) as WorkspaceResponse };
+      } catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : "Unarchive failed" };
+      }
+    },
+
     async delete(id): Promise<WorkspaceResult<{ closedCount: number }>> {
       try {
         const res = await fetchImpl(`${httpBase}/workspaces/${encodeURIComponent(id)}`, {
diff --git a/src/features/workspaces/adapter/tile-layout-http.ts b/src/features/workspaces/adapter/tile-layout-http.ts
new file mode 100644
index 0000000..58af9d8
--- /dev/null
+++ b/src/features/workspaces/adapter/tile-layout-http.ts
@@ -0,0 +1,117 @@
+import type { TileGeometryMode, TileLayoutData } from "@dispatch/tile-layout-contract";
+
+/**
+ * Home tile-layout HTTP effects — the injected edge that talks to the
+ * `home-tile-layout` plugin's well-known routes:
+ * - `GET /home/tile-layout/:mode` → `{ layout }` (a fresh orientation reads
+ *   as the seeded empty document)
+ * - `PUT /home/tile-layout/:mode` body `{ layout }` → 200 `{ layout }` /
+ *   400 `{ error }`
+ * - `DELETE /home/tile-layout/:mode` → the fresh empty document (reset)
+ *
+ * Mirrors the layout adapter's pattern: `httpBase` + an injected `fetchImpl`
+ * (testable without the network). A 404 is NOT a "no document" signal (the
+ * backend never 404s a fresh orientation — it seeds): any non-2xx / network
+ * failure means "the routes aren't served" (an old backend) or "backend
+ * unreachable" — both degrade the store to its local state with ephemeral
+ * edits, never an error UI.
+ */
+
+/** Outcome of a tile-layout read/write. */
+export type TileLayoutHttpResult =
+  | { readonly ok: true; readonly layout: TileLayoutData }
+  | { readonly ok: false; readonly notFound: boolean; readonly error: string };
+
+export interface TileLayoutHttp {
+  getLayout(mode: TileGeometryMode): Promise<TileLayoutHttpResult>;
+  putLayout(mode: TileGeometryMode, layout: TileLayoutData): Promise<TileLayoutHttpResult>;
+  deleteLayout(mode: TileGeometryMode): Promise<TileLayoutHttpResult>;
+}
+
+/** Read an error message from a non-2xx body (`{ error }`), tolerating junk. */
+async function errorOf(res: Response): Promise<string> {
+  try {
+    const body = (await res.json()) as { error?: unknown };
+    if (typeof body.error === "string" && body.error.length > 0) return body.error;
+  } catch {
+    // fall through
+  }
+  return `HTTP ${res.status}`;
+}
+
+/** A malformed 200 (e.g. an SPA-fallback page) degrades like a failure — never poisons the store. */
+function malformed(): TileLayoutHttpResult {
+  return { ok: false, notFound: false, error: "Malformed tile-layout response" };
+}
+
+function route(httpBase: string, mode: TileGeometryMode): string {
+  return `${httpBase}/home/tile-layout/${encodeURIComponent(mode)}`;
+}
+
+export function createTileLayoutHttp(httpBase: string, fetchImpl: typeof fetch): TileLayoutHttp {
+  return {
+    async getLayout(mode): Promise<TileLayoutHttpResult> {
+      try {
+        const res = await fetchImpl(route(httpBase, mode));
+        if (res.status === 404) {
+          return { ok: false, notFound: true, error: "Tile-layout routes are not served" };
+        }
+        if (!res.ok) return { ok: false, notFound: false, error: await errorOf(res) };
+        const body = (await res.json()) as { layout?: unknown };
+        if (body === null || typeof body !== "object" || body.layout === undefined)
+          return malformed();
+        return { ok: true, layout: body.layout as TileLayoutData };
+      } catch (err) {
+        return {
+          ok: false,
+          notFound: false,
+          error: err instanceof Error ? err.message : "Tile-layout request failed",
+        };
+      }
+    },
+
+    async putLayout(mode, layout): Promise<TileLayoutHttpResult> {
+      try {
+        const res = await fetchImpl(route(httpBase, mode), {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ layout }),
+        });
+        if (res.status === 404) {
+          return { ok: false, notFound: true, error: "Tile-layout routes are not served" };
+        }
+        if (!res.ok) return { ok: false, notFound: false, error: await errorOf(res) };
+        const body = (await res.json()) as { layout?: unknown };
+        if (body === null || typeof body !== "object" || body.layout === undefined)
+          return malformed();
+        return { ok: true, layout: body.layout as TileLayoutData };
+      } catch (err) {
+        return {
+          ok: false,
+          notFound: false,
+          error: err instanceof Error ? err.message : "Tile-layout request failed",
+        };
+      }
+    },
+
+    async deleteLayout(mode): Promise<TileLayoutHttpResult> {
+      try {
+        const res = await fetchImpl(route(httpBase, mode), { method: "DELETE" });
+        if (res.status === 404) {
+          return { ok: false, notFound: true, error: "Tile-layout routes are not served" };
+        }
+        if (!res.ok) return { ok: false, notFound: false, error: await errorOf(res) };
+        const body = (await res.json()) as { layout?: unknown };
+        if (body === null || typeof body !== "object" || body.layout === undefined)
+          return malformed();
+        return { ok: true, layout: body.layout as TileLayoutData };
+      } catch (err) {
+        return {
+          ok: false,
+          notFound: false,
+          error: err instanceof Error ? err.message : "Tile-layout request failed",
+        };
+      }
+    },
+  };
+}