Restore project grouping across hosts (#2565)

* fix(projects): restore cross-host grouping

Random host-local project IDs replaced the remote-derived value that had also served as grouping identity. Persist a separate opaque group key and let normal boot reconciliation backfill older records without a migration.

* fix(projects): keep ambiguous clones separate

A shared remote can identify a project across hosts, but it cannot distinguish two independent clones on one host. Treat those keys as ambiguous so host-local project IDs remain separate.

* fix(projects): preserve host-local project identity

* fix(projects): strengthen grouping identity

* test(app): update project host shape contract

* fix(projects): preserve selected host identity

* fix(projects): close grouped routing gaps

* fix(projects): stabilize legacy subproject grouping

* fix(projects): preserve selected project identity

* fix(projects): isolate legacy host identity

* fix(projects): preserve symlinked bootstrap roots

* fix(projects): reconcile grouped custom names

* fix(projects): stabilize settings and path identity

* fix(projects): normalize default remote ports

* fix(projects): harden host and remote identity

* fix(projects): preserve host-scoped actions

* fix(projects): preserve remote path semantics

* fix(projects): model SCP remote semantics

* fix(projects): keep settings on routed host

* fix(projects): preserve SSH URL path semantics

* fix(projects): separate identity from presentation

* test(projects): use grouped identity in UI specs

* fix(projects): harden grouped project routing

* test(projects): expect framed settings route

* fix(projects): preserve exact placement identity

* fix(projects): harden grouping identity and routing

* fix(projects): restore project key as grouping identity

Random host-local project IDs had replaced the persisted cross-host value carried by projectKey. Keep projectId for routing while reconciliation owns and persists projectKey for grouping.

* fix(projects): prevent project key collisions

Preserve platform path semantics and generic remote transports in cross-host keys, and compare legacy checkout roots using filesystem equivalence before materializing ownership.

* test(projects): assert host-scoped project keys

* fix(projects): preserve project key compatibility

Resolve legacy workspace project references at the daemon boundary while keeping projectKey as the cross-host identity. Complete generic SSH normalization without collapsing distinct repositories.

* fix(projects): harden project reference identity

* fix(projects): retain archived reference errors

* fix(projects): scope legacy paths to hosts

* test(app): model persisted project keys

* fix(projects): retain absolute scp users

* fix(projects): resolve legacy mutation aliases

* fix(projects): preserve conservative identity boundaries

* fix(projects): preserve legacy placement identity

* test(projects): assert legacy placement identity

* test(projects): expect canonical Windows keys

* fix(projects): separate bootstrap identity fields

* fix(projects): scope legacy paths by host

* fix(projects): stabilize opaque project identity

* fix(projects): preserve remaining opaque identities

* fix(projects): classify forward-slash UNC roots

* fix(projects): preserve opaque selection keys

* fix(projects): frame host-local project keys

* fix(projects): canonicalize framed identities

* test(projects): isolate repeated remote fixtures

* fix(projects): keep project key as UI identity

* fix(projects): reconcile hydrated project references

* fix(projects): preserve archived project identity

* refactor(projects): group projects from project records, not workspaces

Cross-host grouping had been built by hanging a projectKey off every
workspace descriptor. That scoped the key to the wrong entity: the app
then had to reconstruct project identity per workspace in six modules,
which forced projectKey fallbacks into RPC arguments and a server-side
resolver that turned grouping keys back into project ids.

A workspace has a projectId. The key belongs to the project, and
grouping is a display concern, so the daemon now publishes projects
over project.list plus the existing project.update channel and the app
groups them in one place. Projects are addressed by host-local
projectId everywhere, including the settings route.

Projects persisted without a key are backfilled by ordinary boot
reconciliation, with no migration. Old daemons advertise no projectList
capability and simply do not group.

* test(projects): seed projects alongside workspaces in fixtures

Sidebar fixtures seeded workspaces without their projects, which the
daemon cannot produce now that projects arrive on their own channel, so
nothing rendered. Adds a seeding helper that supplies both.

Also drops the provisioning test for accepting a project key where a
project id belongs; that resolver was removed deliberately.

* fix(projects): keep derived project identity stable

Four gaps left by shrinking the key derivation:

Local keys used a bare path resolve, so one directory reached by a
different spelling produced a different key and reset grouped identity.
Windows CI caught this with the 8.3 and long-name forms of one temp
path. Canonicalize through the shared realpath-aware normalization.

Subproject display names lost their selected-path input, so every
subproject of a monorepo rendered under the same remote-derived name.

Reconciliation only ever backfilled a missing key, so a project whose
remote changed stayed grouped with hosts on the old remote.

Project settings kept a disconnected host selected and rendered a dead
end with no way back to an editable host.

* fix(projects): read scheme remotes as URLs, not scp form

An `ssh://user@host:22/org/repo` remote matched the scp-form pattern
first, because `[^@]+` happily eats `ssh://git`, so the port landed in
the path and the project keyed as `remote:host/22/org/repo`. Two
spellings of one remote therefore never grouped.

Try scp form only when there is no scheme, and drop protocol-default
ports so an explicitly written `:22` matches the same remote without it.

packages/app/src/hooks/use-projects.test.ts

@@ -1,242 +1,90 @@
 import { describe, expect, it } from "vitest";
-import type { EmptyProjectDescriptor, WorkspaceDescriptor } from "@/stores/session-store";
+import type { ProjectDescriptor } from "@/stores/session-store";
 import {
   deriveProjectsFromReplica,
   type ProjectHostReplica,
   type ProjectHostRuntimeState,
 } from "@/hooks/use-projects";
 
-function runtimeState(input: {
-  serverId: string;
-  isOnline: boolean;
-  isLoading?: boolean;
-  isFetching?: boolean;
-  error?: string | null;
-}): ProjectHostRuntimeState {
+function project(id: string, name: string, root: string): ProjectDescriptor {
+  return {
+    projectId: id,
+    projectKey: `remote:github.com/${name}`,
+    projectDisplayName: name,
+    projectCustomName: null,
+    projectRootPath: root,
+    projectKind: "git",
+  };
+}
+
+function runtimeState(input: Partial<ProjectHostRuntimeState> & { serverId: string }) {
   return {
     serverId: input.serverId,
-    isOnline: input.isOnline,
+    isOnline: input.isOnline ?? true,
     isLoading: input.isLoading ?? false,
     isFetching: input.isFetching ?? false,
     error: input.error ?? null,
   };
 }
 
-function workspace(input: {
-  id: string;
-  projectKey: string;
-  projectName: string;
-  cwd: string;
-  remoteUrl: string | null;
-}): WorkspaceDescriptor {
-  return {
-    id: input.id,
-    projectId: input.projectKey,
-    projectDisplayName: input.projectName,
-    projectCustomName: null,
-    projectRootPath: input.cwd,
-    workspaceDirectory: input.cwd,
-    projectKind: "git",
-    workspaceKind: "local_checkout",
-    name: input.id,
-    title: null,
-    archivingAt: null,
-    status: "done",
-    statusEnteredAt: null,
-    diffStat: null,
-    scripts: [],
-    gitRuntime: {
-      currentBranch: "main",
-      remoteUrl: input.remoteUrl,
-      isPaseoOwnedWorktree: false,
-      isDirty: false,
-      aheadBehind: null,
-      aheadOfOrigin: null,
-      behindOfOrigin: null,
-    },
-    githubRuntime: null,
-    project: {
-      projectKey: input.projectKey,
-      projectName: input.projectName,
-      checkout: {
-        cwd: input.cwd,
-        isGit: true,
-        currentBranch: "main",
-        remoteUrl: input.remoteUrl,
-        worktreeRoot: input.cwd,
-        isPaseoOwnedWorktree: false,
-        mainRepoRoot: null,
-      },
-    },
-  };
-}
-
-function emptyProject(input: {
-  projectKey: string;
-  projectName: string;
-  cwd: string;
-}): EmptyProjectDescriptor {
-  return {
-    projectId: input.projectKey,
-    projectDisplayName: input.projectName,
-    projectCustomName: null,
-    projectRootPath: input.cwd,
-    projectKind: "git",
-  };
-}
-
 describe("deriveProjectsFromReplica", () => {
-  it("aggregates store workspaces and empty projects sorted by display name", () => {
+  it("derives projects from the project descriptor replica", () => {
     const replicas: ProjectHostReplica[] = [
       {
         serverId: "local",
         serverName: "Local",
-        workspaces: [
-          workspace({
-            id: "z-main",
-            projectKey: "remote:github.com/acme/zeta",
-            projectName: "acme/zeta",
-            cwd: "/repo/zeta",
-            remoteUrl: "https://github.com/acme/zeta.git",
-          }),
-        ],
-        emptyProjects: [],
+        workspaces: [],
+        projects: [project("prj_zeta", "acme/zeta", "/repo/zeta")],
       },
       {
         serverId: "laptop",
         serverName: "Laptop",
         workspaces: [],
-        emptyProjects: [
-          emptyProject({
-            projectKey: "remote:github.com/acme/alpha",
-            projectName: "acme/alpha",
-            cwd: "/repo/alpha",
-          }),
-        ],
+        projects: [project("prj_alpha", "acme/alpha", "/repo/alpha")],
       },
     ];
 
     const result = deriveProjectsFromReplica({
       replicas,
       runtimeStates: [
-        runtimeState({ serverId: "local", isOnline: true }),
+        runtimeState({ serverId: "local" }),
         runtimeState({ serverId: "laptop", isOnline: false }),
       ],
     });
 
-    expect(result.projects.map((project) => project.projectName)).toEqual([
-      "acme/alpha",
-      "acme/zeta",
-    ]);
-    expect(result.projects[0]?.hosts).toEqual([
-      expect.objectContaining({
-        serverId: "laptop",
-        isOnline: false,
-        repoRoot: "/repo/alpha",
-        workspaceCount: 0,
-      }),
-    ]);
-    expect(result.hostErrors).toEqual([]);
-  });
-
-  it("maps runtime directory status into loading and host errors", () => {
-    const replicas: ProjectHostReplica[] = [
-      {
-        serverId: "local",
-        serverName: "Local",
-        workspaces: [
-          workspace({
-            id: "main",
-            projectKey: "remote:github.com/acme/app",
-            projectName: "acme/app",
-            cwd: "/repo/app",
-            remoteUrl: "https://github.com/acme/app.git",
-          }),
-        ],
-        emptyProjects: [],
-      },
-      {
-        serverId: "laptop",
-        serverName: "Laptop",
-        workspaces: [],
-        emptyProjects: [],
-      },
-    ];
-
-    const result = deriveProjectsFromReplica({
-      replicas,
-      runtimeStates: [
-        runtimeState({ serverId: "local", isOnline: true, isFetching: true }),
-        runtimeState({
-          serverId: "laptop",
-          isOnline: true,
-          isLoading: true,
-          error: "laptop unavailable",
-        }),
-      ],
+    expect(result.projects.map((item) => item.projectName)).toEqual(["acme/alpha", "acme/zeta"]);
+    expect(result.projects[0]?.hosts[0]).toMatchObject({
+      serverId: "laptop",
+      projectId: "prj_alpha",
+      repoRoot: "/repo/alpha",
+      workspaceCount: 0,
     });
-
-    expect(result.projects).toEqual([
-      expect.objectContaining({ projectKey: "remote:github.com/acme/app" }),
-    ]);
-    expect(result.hostErrors).toEqual([
-      {
-        serverId: "laptop",
-        serverName: "Laptop",
-        message: "laptop unavailable",
-      },
-    ]);
-    expect(result.isLoading).toBe(true);
-    expect(result.isFetching).toBe(true);
   });
 
-  it("returns only the stable public project and host entry shapes", () => {
+  it("preserves runtime loading and error state", () => {
     const result = deriveProjectsFromReplica({
       replicas: [
         {
           serverId: "local",
           serverName: "Local",
-          workspaces: [
-            workspace({
-              id: "main",
-              projectKey: "remote:github.com/acme/app",
-              projectName: "acme/app",
-              cwd: "/repo/app",
-              remoteUrl: "https://github.com/acme/app.git",
-            }),
-          ],
-          emptyProjects: [],
+          workspaces: [],
+          projects: [project("prj_app", "acme/app", "/repo/app")],
         },
       ],
-      runtimeStates: [runtimeState({ serverId: "local", isOnline: true })],
+      runtimeStates: [
+        runtimeState({
+          serverId: "local",
+          isLoading: true,
+          isFetching: true,
+          error: "unavailable",
+        }),
+      ],
     });
 
-    expect(Object.keys(result.projects[0] ?? {}).sort()).toEqual([
-      "githubUrl",
-      "hostCount",
-      "hosts",
-      "onlineHostCount",
-      "projectCustomName",
-      "projectKey",
-      "projectName",
-      "totalWorkspaceCount",
-    ]);
-    expect(Object.keys(result.projects[0]?.hosts[0] ?? {}).sort()).toEqual([
-      "gitRuntime",
-      "githubRuntime",
-      "isOnline",
-      "repoRoot",
-      "serverId",
-      "serverName",
-      "workspaceCount",
-      "workspaces",
-    ]);
-    expect(Object.keys(result.projects[0]?.hosts[0]?.workspaces[0] ?? {}).sort()).toEqual([
-      "currentBranch",
-      "id",
-      "name",
-      "status",
-      "workspaceKind",
+    expect(result.isLoading).toBe(true);
+    expect(result.isFetching).toBe(true);
+    expect(result.hostErrors).toEqual([
+      { serverId: "local", serverName: "Local", message: "unavailable" },
     ]);
   });
 });