Merge local dev into feature/close-tab-cascade-subagents

2 files changed, 114 insertions, 0 deletions

diff --git a/src/features/workspaces/logic/create.test.ts b/src/features/workspaces/logic/create.test.ts
new file mode 100644
index 0000000..278bcd6
--- /dev/null
+++ b/src/features/workspaces/logic/create.test.ts
@@ -0,0 +1,50 @@
+import type { Workspace } from "@dispatch/wire";
+import { describe, expect, it } from "vitest";
+import {
+  archivedCreateMessage,
+  checkFailedCreateMessage,
+  gateCreate,
+  type WorkspaceLookup,
+} from "./create";
+
+function workspace(overrides: Partial<Workspace> = {}): Workspace {
+  return {
+    id: "old",
+    title: "Old",
+    defaultCwd: null,
+    defaultComputerId: null,
+    starred: false,
+    archived: false,
+    createdAt: 1,
+    lastActivityAt: 2,
+    ...overrides,
+  };
+}
+
+describe("gateCreate", () => {
+  it("blocks a slug whose workspace is archived, with the can't-create message", () => {
+    const lookup: WorkspaceLookup = { kind: "found", workspace: workspace({ archived: true }) };
+    const gate = gateCreate("old", lookup);
+    expect(gate).toEqual({ ok: false, error: archivedCreateMessage("old") });
+    expect(gate.ok === false && gate.error).toContain(
+      'A workspace named "old" already exists and is archived — you can\'t create it.',
+    );
+  });
+
+  it("proceeds for an existing ACTIVE workspace (ensure is idempotent)", () => {
+    const lookup: WorkspaceLookup = { kind: "found", workspace: workspace({ archived: false }) };
+    expect(gateCreate("old", lookup)).toEqual({ ok: true });
+  });
+
+  it("proceeds for a missing slug", () => {
+    expect(gateCreate("fresh", { kind: "missing" })).toEqual({ ok: true });
+  });
+
+  it("blocks when the existence probe failed (never guesses)", () => {
+    const gate = gateCreate("maybe", { kind: "failed", error: "db down" });
+    expect(gate).toEqual({ ok: false, error: checkFailedCreateMessage("maybe", "db down") });
+    expect(gate.ok === false && gate.error).toContain(
+      'Couldn\'t check whether a workspace named "maybe"',
+    );
+  });
+});
diff --git a/src/features/workspaces/logic/create.ts b/src/features/workspaces/logic/create.ts
new file mode 100644
index 0000000..c9385e1
--- /dev/null
+++ b/src/features/workspaces/logic/create.ts
@@ -0,0 +1,64 @@
+/**
+ * Pure create-gate logic for the New-workspace form — zero DOM, zero effects.
+ *
+ * `PUT /workspaces/:id` (ensure) is idempotent, so creating a slug that belongs
+ * to an ARCHIVED workspace would silently "succeed": the backend returns the
+ * archived workspace, the active list (which excludes archived) never shows it,
+ * and the home grid would still place a tile for something invisible. The
+ * frontend therefore probes `GET /workspaces/:id` first and refuses the create
+ * when the slug exists and is archived.
+ */
+
+import type { Workspace } from "@dispatch/wire";
+
+/**
+ * The authoritative existence probe's outcome (`GET /workspaces/:id`). The
+ * adapter maps HTTP status to these kinds; `failed` is deliberately distinct
+ * from `missing` (404) so a broken check is never mistaken for "no such
+ * workspace".
+ */
+export type WorkspaceLookup =
+  | { readonly kind: "found"; readonly workspace: Workspace }
+  | { readonly kind: "missing" }
+  | { readonly kind: "failed"; readonly error: string };
+
+/** Whether a create may proceed: `ok` or a user-facing error message. */
+export type CreateGate = { readonly ok: true } | { readonly ok: false; readonly error: string };
+
+/**
+ * The user-facing message when a slug belongs to an archived workspace. It
+ * states plainly that the create can't happen and points at the existing
+ * recovery affordance (the Archived workspaces list) without adding UI.
+ */
+export function archivedCreateMessage(id: string): string {
+  return `A workspace named "${id}" already exists and is archived — you can't create it. Unarchive it from Archived workspaces instead.`;
+}
+
+/**
+ * The user-facing message when the existence probe itself failed. Proceeding
+ * blindly could recreate the silent archived-tile bug, so the create is
+ * refused with a retryable message instead.
+ */
+export function checkFailedCreateMessage(id: string, error: string): string {
+  return `Couldn't check whether a workspace named "${id}" already exists (${error}). Try again.`;
+}
+
+/**
+ * Decide whether a create may proceed, given the probe outcome. Pure:
+ * `(id, lookup) → gate`.
+ *
+ * - archived slug → blocked with the "can't create" message;
+ * - missing slug or an ACTIVE existing slug → proceed (`ensure` is idempotent,
+ *   so an active slug keeps today's behavior);
+ * - a failed probe → blocked too (plan §3.4): never guess, because proceeding
+ *   could ensure an archived workspace's tile.
+ */
+export function gateCreate(id: string, lookup: WorkspaceLookup): CreateGate {
+  if (lookup.kind === "failed") {
+    return { ok: false, error: checkFailedCreateMessage(id, lookup.error) };
+  }
+  if (lookup.kind === "found" && lookup.workspace.archived) {
+    return { ok: false, error: archivedCreateMessage(id) };
+  }
+  return { ok: true };
+}