From afc7ac4bd06e4607ec4b74269fe95c8dc356db5b Mon Sep 17 00:00:00 2001
From: Naiyuan Qing <145280634+NevilleQingNY@users.noreply.github.com>
Date: Wed, 8 Jul 2026 20:57:38 +0800
Subject: [PATCH] =?UTF-8?q?feat:=20space=20rollout=20=E2=80=94=20space-fir?=
 =?UTF-8?q?st=20navigation,=20per-user=20membership,=20move-to-space=20(MU?=
 =?UTF-8?q?L-4142)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Squashed history of PR #4892 (pr-4784-fix). Makes spaces the primary
navigation and working surface, on the "associations bind at creation
time only" model.

Model
- Issue <-> space is the only enforced ownership (per-space numbering).
  Parent/child and project<->space associations only seed defaults at
  creation; cross-space/child and project-association validations are
  removed.
- Moving an issue renumbers it and records the old identifier in
  issue_identifier_alias; API/CLI lookups and GitHub branch/PR
  auto-linking fall back to the alias, so old identifiers resolve forever.
- Membership drives only the sidebar and personal defaults — never
  access. Anyone can configure any space's member set wholesale
  (PUT /api/spaces/{id}/members); saving an empty set archives the
  space behind a confirm.
- Per-user space order (workspace_space_member.sort_order, fractional):
  drag-sorted sidebar, "my first space" is the personal issue-creation
  default; the workspace default space backs headless creation
  (agents/CLI/Slack) and system placement.

Surfaces
- Sidebar: joined-spaces section (drag reorder, row -> space page,
  per-group persisted collapse), Workspace group with a More menu,
  Settings demoted to a footer icon.
- /space/:key/{issues,projects,autopilots,settings} — space surfaces
  reuse shared page components; a routed /space/new create page
  (replacing the earlier create-space modal), reserved key "NEW" so it
  can never collide with a real space's /space/:key detail page.
- Issue detail moves to /issue/:id (identifier-first, Linear-style; old
  /issues/:id redirects); create dialogs lead with a required space pill.
- Agent runtime brief now carries Space context (id/key/name) through
  the daemon claim -> TaskContextForEnv -> prompt pipeline, with a
  "## Space Context" section and --space on issue create/update in both
  brief renderers, matching Project's existing treatment.
- zh-Hans: Space translated to 空间 across locales and conventions.zh.mdx.

Fixes along the way
- Cache membership judgment gains the space dimension + space_changed
  WS flag.
- Silent skip on default-space lookup during invite acceptance is now a
  hard failure (no space-less members).
- Backfilled space_id into ~28 raw-SQL Go test fixtures across
  internal/handler and cmd/server that predated migration 132's NOT
  NULL cutover.
- Fixed a resolve-loop bug in the IssueDetail identifier wrapper (mount/
  unmount cycle on resolution failure) and gave it its own loading
  skeleton instead of a blank screen while resolving.
- reserved-slugs generator's stale hardcoded doc-comment example synced
  back to /create-space.

Verification
- go build ./..., go vet ./..., go test ./... all clean.
- pnpm typecheck (core/views/web/desktop) clean.
- packages/views: 162 files / 1656 tests passing.
- pnpm generate:reserved-slugs produces no diff.

Follow-ups tracked in docs/follow-ups/space-rollout.md.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .../renderer/src/components/tab-bar.test.tsx  |   8 +
 .../src/renderer/src/components/tab-bar.tsx   |  55 +-
 .../src/pages/space-surface-pages.tsx         |  34 +
 apps/desktop/src/renderer/src/routes.tsx      |  41 +
 .../src/renderer/src/stores/tab-store.ts      |   2 +
 .../docs/developers/conventions.zh.mdx        |   9 +-
 apps/mobile/data/schemas.ts                   |   2 +
 .../(dashboard)/issue/[id]/page.tsx           |  22 +
 .../(dashboard)/issues/[id]/page.tsx          |  21 +-
 .../space/[spaceKey]/autopilots/page.tsx      |  13 +
 .../space/[spaceKey]/issues/page.tsx          |  13 +
 .../(dashboard)/space/[spaceKey]/page.tsx     |  13 +
 .../space/[spaceKey]/projects/page.tsx        |  13 +
 .../(dashboard)/space/new/page.tsx            |   7 +
 docs/follow-ups/space-rollout.md              |  79 ++
 packages/core/api/client.ts                   |  77 +-
 packages/core/api/schema.ts                   |  30 +
 packages/core/api/schemas.test.ts             | 125 +++
 packages/core/api/schemas.ts                  |  77 ++
 packages/core/issues/queries.ts               |   2 +
 packages/core/issues/stores/view-store.ts     |   5 +
 .../core/issues/surface/membership.test.ts    |  33 +-
 packages/core/issues/surface/membership.ts    |   7 +
 packages/core/issues/surface/query-plan.ts    |  25 +-
 packages/core/issues/surface/scope.test.ts    |  23 +-
 packages/core/issues/surface/scope.ts         |   6 +-
 packages/core/issues/ws-updaters.ts           |   6 +
 packages/core/layout/sidebar-store.ts         |  32 +
 packages/core/package.json                    |   6 +
 packages/core/paths/consistency.test.ts       |   1 +
 packages/core/paths/paths.test.ts             |   4 +-
 packages/core/paths/paths.ts                  |  16 +-
 packages/core/paths/reserved-slugs.ts         |   7 +-
 packages/core/permissions/index.ts            |   2 +
 packages/core/realtime/use-realtime-sync.ts   |  18 +
 packages/core/spaces/default-space.test.ts    |  76 ++
 packages/core/spaces/default-space.ts         |  47 ++
 packages/core/spaces/index.ts                 |  17 +
 packages/core/spaces/last-space-store.ts      |  32 +
 packages/core/spaces/mutations.ts             | 135 ++++
 packages/core/spaces/queries.ts               |  67 ++
 packages/core/types/api.ts                    |   7 +
 packages/core/types/autopilot.ts              |   3 +
 packages/core/types/events.ts                 |  10 +-
 packages/core/types/index.ts                  |   1 +
 packages/core/types/issue.ts                  |   3 +
 packages/core/types/project.ts                |   3 +
 packages/core/types/space.ts                  |  60 ++
 packages/core/workspace/index.ts              |   1 +
 packages/core/workspace/mutations.ts          |   7 +-
 packages/core/workspace/space-key.ts          |  25 +
 .../ui/components/common/plain-text-field.tsx |  72 ++
 packages/ui/components/ui/list-grid.tsx       |   2 +-
 .../components/autopilot-detail-page.tsx      |   1 +
 .../components/autopilot-dialog.tsx           |  62 +-
 .../autopilots/components/autopilots-page.tsx |  26 +-
 packages/views/editor/title-editor.tsx        |   6 +-
 packages/views/editor/utils/link-handler.ts   |   1 +
 packages/views/i18n/resources-types.ts        |   2 +
 .../__tests__/use-issue-actions.test.tsx      |   2 +-
 .../actions/issue-actions-menu-items.tsx      |   3 +
 .../views/issues/actions/use-issue-actions.ts |   7 +-
 .../issues/components/issue-detail.test.tsx   |   2 +-
 .../views/issues/components/issue-detail.tsx  | 200 +++--
 .../views/issues/components/issues-header.tsx | 118 ++-
 .../views/issues/components/issues-page.tsx   |   5 +-
 .../surface/use-issue-surface-controller.ts   |   9 +-
 packages/views/layout/app-sidebar.test.tsx    |  21 +-
 packages/views/layout/app-sidebar.tsx         | 443 +++++++++--
 packages/views/locales/en/autopilots.json     |  10 +-
 packages/views/locales/en/issues.json         |   6 +-
 packages/views/locales/en/layout.json         |  10 +-
 packages/views/locales/en/modals.json         |   4 +-
 packages/views/locales/en/onboarding.json     |  29 +-
 packages/views/locales/en/projects.json       |   1 +
 packages/views/locales/en/spaces.json         |  89 +++
 packages/views/locales/index.ts               |   8 +
 packages/views/locales/ja/autopilots.json     |   4 +-
 packages/views/locales/ja/issues.json         |   4 +
 packages/views/locales/ja/layout.json         |   8 +-
 packages/views/locales/ja/modals.json         |   2 +
 packages/views/locales/ja/onboarding.json     |   3 -
 packages/views/locales/ja/projects.json       |   1 +
 packages/views/locales/ja/spaces.json         |  88 +++
 packages/views/locales/ko/autopilots.json     |   4 +-
 packages/views/locales/ko/issues.json         |   4 +
 packages/views/locales/ko/layout.json         |   8 +-
 packages/views/locales/ko/modals.json         |   2 +
 packages/views/locales/ko/onboarding.json     |   3 -
 packages/views/locales/ko/projects.json       |   1 +
 packages/views/locales/ko/spaces.json         |  88 +++
 .../views/locales/zh-Hans/autopilots.json     |   4 +-
 packages/views/locales/zh-Hans/issues.json    |   4 +
 packages/views/locales/zh-Hans/layout.json    |   8 +-
 packages/views/locales/zh-Hans/modals.json    |   2 +
 .../views/locales/zh-Hans/onboarding.json     |   3 -
 packages/views/locales/zh-Hans/projects.json  |   1 +
 packages/views/locales/zh-Hans/spaces.json    |  88 +++
 packages/views/modals/create-issue.tsx        |  84 +-
 packages/views/modals/create-project.test.tsx |   1 +
 packages/views/modals/create-project.tsx      |  75 +-
 .../views/modals/quick-create-issue.test.tsx  |   1 +
 packages/views/modals/quick-create-issue.tsx  |  84 +-
 packages/views/modals/registry.tsx            |   2 +-
 .../views/onboarding/steps/step-workspace.tsx |  32 +-
 packages/views/package.json                   |   1 +
 .../projects/components/project-detail.tsx    |  11 +
 .../projects/components/projects-page.tsx     |  14 +-
 .../spaces/components/create-space-page.tsx   | 343 ++++++++
 packages/views/spaces/components/index.ts     |   5 +
 .../spaces/components/space-detail-page.tsx   | 515 ++++++++++++
 .../views/spaces/components/space-icon.tsx    |  26 +
 .../views/spaces/components/space-picker.tsx  | 187 +++++
 .../space-project-conflict-dialog.tsx         |  87 +++
 .../spaces/components/space-surface-pages.tsx |  93 +++
 packages/views/spaces/index.ts                |  10 +
 .../views/workspace/create-workspace-form.tsx |   5 +-
 .../welcome-after-onboarding.test.tsx         |   2 +-
 scripts/generate-reserved-slugs.mjs           |   2 +-
 .../cmd/migrate/space_number_cutover_test.go  | 358 +++++++++
 server/cmd/multica/cmd_autopilot.go           |  37 +-
 server/cmd/multica/cmd_issue.go               |  20 +
 server/cmd/multica/cmd_project.go             |  29 +-
 server/cmd/multica/cmd_space.go               | 289 +++++++
 server/cmd/multica/main.go                    |   2 +
 .../autopilot_dispatch_for_plan_test.go       |   3 +
 .../server/autopilot_failure_monitor_test.go  |   1 +
 server/cmd/server/autopilot_listeners_test.go |   5 +
 .../cmd/server/autopilot_schedule_job_test.go |   2 +
 server/cmd/server/integration_test.go         |  43 +-
 .../cmd/server/notification_listeners_test.go |   8 +-
 .../server/quick_create_subscriber_test.go    |  20 +-
 server/cmd/server/rerun_session_test.go       |   8 +-
 server/cmd/server/router.go                   |  18 +-
 server/cmd/server/runtime_sweeper_test.go     |  28 +-
 .../cmd/server/subscriber_listeners_test.go   |   4 +-
 .../cmd/server/workspace_scope_guard_test.go  |   4 +-
 server/internal/daemon/daemon.go              |   3 +
 server/internal/daemon/execenv/execenv.go     |   3 +
 .../internal/daemon/execenv/runtime_config.go |  15 +-
 .../daemon/execenv/runtime_config_sections.go |  22 +-
 server/internal/daemon/prompt.go              |  11 +
 server/internal/daemon/types.go               |   3 +
 server/internal/handler/agent.go              |   3 +
 server/internal/handler/agent_access_test.go  |  10 +-
 server/internal/handler/autopilot.go          |  56 ++
 .../internal/handler/autopilot_list_test.go   |   5 +-
 .../handler/autopilot_private_leader_test.go  |  10 +-
 .../handler/autopilot_webhook_handler_test.go |   5 +-
 .../handler/cancel_task_by_user_test.go       |  19 +-
 server/internal/handler/comment_list_test.go  |  24 +-
 .../internal/handler/comment_resolve_test.go  |   8 +-
 .../handler/comment_trigger_preview_test.go   |  10 +-
 server/internal/handler/daemon.go             |  33 +-
 server/internal/handler/daemon_test.go        | 120 +--
 server/internal/handler/dashboard_test.go     |  40 +-
 server/internal/handler/github.go             |  30 +-
 server/internal/handler/handler.go            |  28 +-
 server/internal/handler/handler_test.go       | 178 ++++-
 server/internal/handler/invitation.go         |  18 +
 server/internal/handler/issue.go              | 348 +++++++--
 .../handler/issue_assignee_types_test.go      |   4 +-
 server/internal/handler/issue_child_done.go   |   3 +-
 .../issue_children_for_parents_test.go        |  21 +-
 server/internal/handler/issue_grouped_test.go |  99 ++-
 .../internal/handler/issue_involves_test.go   |  14 +-
 .../handler/issue_limit_validation_test.go    |   8 +-
 .../handler/issue_reassign_no_cancel_test.go  |   4 +-
 .../internal/handler/issue_scheduled_test.go  |   4 +-
 .../handler/mention_self_trigger_test.go      |   5 +-
 server/internal/handler/onboarding_shim.go    |  35 +-
 server/internal/handler/project.go            | 239 +++++-
 .../internal/handler/project_resource_test.go |   5 +-
 .../handler/quick_create_parent_test.go       |  18 +-
 server/internal/handler/reserved_slugs.json   |   7 +-
 server/internal/handler/runtime_test.go       |  10 +-
 server/internal/handler/search_test.go        |  30 +-
 server/internal/handler/space.go              | 616 +++++++++++++++
 server/internal/handler/space_resolve.go      |  51 ++
 server/internal/handler/space_resolve_test.go |  58 ++
 server/internal/handler/squad.go              |   5 +-
 .../internal/handler/squad_briefing_test.go   |   4 +-
 .../handler/squad_comment_trigger_test.go     |  12 +-
 .../internal/handler/squad_id_enqueue_test.go |   4 +-
 .../handler/squad_private_leader_test.go      |  12 +-
 .../squad_worker_comment_wakes_leader_test.go |   4 +-
 server/internal/handler/workspace.go          | 181 ++++-
 .../integrations/channel/engine/resolvers.go  |   2 +
 .../integrations/channel/engine/router.go     |   7 +-
 .../channel/engine/router_test.go             |  34 +-
 .../integrations/slack/slash_command.go       |   3 +-
 .../integrations/slack/slash_command_test.go  |   2 +-
 server/internal/issueguard/duplicate.go       |   7 +-
 server/internal/issueidentifier/identifier.go | 141 ++++
 .../issueidentifier/identifier_test.go        | 353 +++++++++
 server/internal/issueposition/position.go     |  13 +-
 server/internal/service/autopilot.go          | 238 +++---
 .../multica-autopilots/SKILL.md               |  10 +-
 .../references/autopilots-source-map.md       |   1 +
 .../multica-projects-and-resources/SKILL.md   |  27 +-
 .../projects-and-resources-source-map.md      |   4 +
 .../multica-working-on-issues/SKILL.md        |  26 +-
 .../working-on-issues-source-map.md           |  28 +-
 server/internal/service/issue.go              | 241 +++++-
 server/internal/service/issue_resolve_test.go |  35 +
 .../service/resolve_originator_test.go        |  20 +-
 server/internal/service/task.go               |  34 +-
 .../internal/service/task_claim_race_test.go  |  13 +-
 .../service/task_dedup_head_sha_test.go       |  10 +-
 .../service/task_issue_broadcast_test.go      |  10 +-
 .../migrations/131_workspace_space.down.sql   |  18 +
 server/migrations/131_workspace_space.up.sql  | 186 +++++
 .../132_space_number_cutover.down.sql         |  27 +
 .../132_space_number_cutover.up.sql           | 161 ++++
 .../134_issue_identifier_alias.down.sql       |   1 +
 .../134_issue_identifier_alias.up.sql         |  16 +
 .../135_space_member_sort_order.down.sql      |   1 +
 .../135_space_member_sort_order.up.sql        |  23 +
 server/pkg/db/generated/autopilot.sql.go      |  61 +-
 server/pkg/db/generated/issue.sql.go          | 332 +++++---
 .../generated/issue_identifier_alias.sql.go   |  84 ++
 server/pkg/db/generated/models.go             |  41 +
 server/pkg/db/generated/project.sql.go        | 172 +++-
 server/pkg/db/generated/space.sql.go          | 736 ++++++++++++++++++
 server/pkg/db/generated/workspace.sql.go      |  13 -
 server/pkg/db/queries/autopilot.sql           |  17 +-
 server/pkg/db/queries/issue.sql               |  50 +-
 .../pkg/db/queries/issue_identifier_alias.sql |  12 +
 server/pkg/db/queries/project.sql             |  45 +-
 server/pkg/db/queries/space.sql               | 146 ++++
 server/pkg/db/queries/workspace.sql           |   5 -
 231 files changed, 10070 insertions(+), 1047 deletions(-)
 create mode 100644 apps/desktop/src/renderer/src/pages/space-surface-pages.tsx
 create mode 100644 apps/web/app/[workspaceSlug]/(dashboard)/issue/[id]/page.tsx
 create mode 100644 apps/web/app/[workspaceSlug]/(dashboard)/space/[spaceKey]/autopilots/page.tsx
 create mode 100644 apps/web/app/[workspaceSlug]/(dashboard)/space/[spaceKey]/issues/page.tsx
 create mode 100644 apps/web/app/[workspaceSlug]/(dashboard)/space/[spaceKey]/page.tsx
 create mode 100644 apps/web/app/[workspaceSlug]/(dashboard)/space/[spaceKey]/projects/page.tsx
 create mode 100644 apps/web/app/[workspaceSlug]/(dashboard)/space/new/page.tsx
 create mode 100644 docs/follow-ups/space-rollout.md
 create mode 100644 packages/core/layout/sidebar-store.ts
 create mode 100644 packages/core/spaces/default-space.test.ts
 create mode 100644 packages/core/spaces/default-space.ts
 create mode 100644 packages/core/spaces/index.ts
 create mode 100644 packages/core/spaces/last-space-store.ts
 create mode 100644 packages/core/spaces/mutations.ts
 create mode 100644 packages/core/spaces/queries.ts
 create mode 100644 packages/core/types/space.ts
 create mode 100644 packages/core/workspace/space-key.ts
 create mode 100644 packages/ui/components/common/plain-text-field.tsx
 create mode 100644 packages/views/locales/en/spaces.json
 create mode 100644 packages/views/locales/ja/spaces.json
 create mode 100644 packages/views/locales/ko/spaces.json
 create mode 100644 packages/views/locales/zh-Hans/spaces.json
 create mode 100644 packages/views/spaces/components/create-space-page.tsx
 create mode 100644 packages/views/spaces/components/index.ts
 create mode 100644 packages/views/spaces/components/space-detail-page.tsx
 create mode 100644 packages/views/spaces/components/space-icon.tsx
 create mode 100644 packages/views/spaces/components/space-picker.tsx
 create mode 100644 packages/views/spaces/components/space-project-conflict-dialog.tsx
 create mode 100644 packages/views/spaces/components/space-surface-pages.tsx
 create mode 100644 packages/views/spaces/index.ts
 create mode 100644 server/cmd/migrate/space_number_cutover_test.go
 create mode 100644 server/cmd/multica/cmd_space.go
 create mode 100644 server/internal/handler/space.go
 create mode 100644 server/internal/handler/space_resolve.go
 create mode 100644 server/internal/handler/space_resolve_test.go
 create mode 100644 server/internal/issueidentifier/identifier.go
 create mode 100644 server/internal/issueidentifier/identifier_test.go
 create mode 100644 server/internal/service/issue_resolve_test.go
 create mode 100644 server/migrations/131_workspace_space.down.sql
 create mode 100644 server/migrations/131_workspace_space.up.sql
 create mode 100644 server/migrations/132_space_number_cutover.down.sql
 create mode 100644 server/migrations/132_space_number_cutover.up.sql
 create mode 100644 server/migrations/134_issue_identifier_alias.down.sql
 create mode 100644 server/migrations/134_issue_identifier_alias.up.sql
 create mode 100644 server/migrations/135_space_member_sort_order.down.sql
 create mode 100644 server/migrations/135_space_member_sort_order.up.sql
 create mode 100644 server/pkg/db/generated/issue_identifier_alias.sql.go
 create mode 100644 server/pkg/db/generated/space.sql.go
 create mode 100644 server/pkg/db/queries/issue_identifier_alias.sql
 create mode 100644 server/pkg/db/queries/space.sql

diff --git a/apps/desktop/src/renderer/src/components/tab-bar.test.tsx b/apps/desktop/src/renderer/src/components/tab-bar.test.tsx
index f1b59d026c..08a42cf185 100644
--- a/apps/desktop/src/renderer/src/components/tab-bar.test.tsx
+++ b/apps/desktop/src/renderer/src/components/tab-bar.test.tsx
@@ -60,6 +60,14 @@ vi.mock("@multica/core/paths", () => ({
       issues: () => `/${slug}/issues`,
     }),
   },
+  useCurrentWorkspace: () => ({ id: "ws-1", slug: "acme" }),
+}));
+
+vi.mock("@tanstack/react-query", () => ({
+  useQuery: () => ({ data: [] }),
+}));
+vi.mock("@multica/core/spaces/queries", () => ({
+  spaceListOptions: () => ({ queryKey: ["spaces"], queryFn: () => [] }),
 }));
 
 import { TabBar } from "./tab-bar";
diff --git a/apps/desktop/src/renderer/src/components/tab-bar.tsx b/apps/desktop/src/renderer/src/components/tab-bar.tsx
index f002d26fcf..6893973b96 100644
--- a/apps/desktop/src/renderer/src/components/tab-bar.tsx
+++ b/apps/desktop/src/renderer/src/components/tab-bar.tsx
@@ -1,4 +1,4 @@
-import { Fragment } from "react";
+import { Fragment, useMemo } from "react";
 import {
   Inbox,
   CircleUser,
@@ -7,12 +7,15 @@ import {
   Monitor,
   BookOpenText,
   Settings,
+  Users,
+  FolderKanban,
   X,
   Plus,
   Pin,
   PinOff,
   type LucideIcon,
 } from "lucide-react";
+import { useQuery } from "@tanstack/react-query";
 import {
   DndContext,
   PointerSensor,
@@ -45,7 +48,10 @@ import {
   resolveRouteIcon,
   type Tab,
 } from "@/stores/tab-store";
-import { paths } from "@multica/core/paths";
+import { paths, useCurrentWorkspace } from "@multica/core/paths";
+import { spaceListOptions } from "@multica/core/spaces/queries";
+import type { Space } from "@multica/core/types";
+import { SpaceIcon } from "@multica/views/spaces";
 
 const TAB_ICONS: Record<string, LucideIcon> = {
   Inbox,
@@ -55,12 +61,23 @@ const TAB_ICONS: Record<string, LucideIcon> = {
   Monitor,
   BookOpenText,
   Settings,
+  Users,
+  FolderKanban,
 };
 
+/** Space key from a tab path, or null if the tab isn't a space-scoped route.
+ *  Mirrors resolveRouteIcon's segment convention: `/{slug}/space/{key}/...`. */
+function extractSpaceKey(path: string): string | null {
+  const segments = path.split("/").filter(Boolean);
+  if (segments[1] !== "space" || !segments[2]) return null;
+  return decodeURIComponent(segments[2]);
+}
+
 function SortableTabItem({
   tab,
   isActive,
   isOnly,
+  spacesByKey,
 }: {
   tab: Tab;
   isActive: boolean;
@@ -70,6 +87,9 @@ function SortableTabItem({
    * last-tab reseed kicking in. Pinned tabs always hide X (RFC §3 D3c).
    */
   isOnly: boolean;
+  /** Space-scoped tabs render the actual space's icon instead of a generic
+   *  route glyph — keyed by space key, same cache the sidebar reads. */
+  spacesByKey: Map<string, Space>;
 }) {
   const setActiveTab = useTabStore((s) => s.setActiveTab);
   const closeTab = useTabStore((s) => s.closeTab);
@@ -84,11 +104,9 @@ function SortableTabItem({
     isDragging,
   } = useSortable({ id: tab.id });
 
-  // Pinned tabs swap the route icon for a Pin glyph as the static "I am
-  // pinned" indicator (RFC §3 D1v-iv FINAL). The route information is still
-  // present in the title, and this avoids a hard left accent border that read
-  // as visually heavy in light mode.
-  const LeadingIcon = tab.pinned ? Pin : TAB_ICONS[tab.icon];
+  const spaceKey = extractSpaceKey(tab.path);
+  const space = spaceKey ? spacesByKey.get(spaceKey) : undefined;
+  const RouteIcon = TAB_ICONS[tab.icon];
 
   const style = {
     transform: CSS.Transform.toString(transform),
@@ -141,7 +159,17 @@ function SortableTabItem({
         isDragging && "opacity-60",
       )}
     >
-      {LeadingIcon && <LeadingIcon className="size-3.5 shrink-0" />}
+      {tab.pinned ? (
+        // Pinned tabs swap the route icon for a Pin glyph as the static "I am
+        // pinned" indicator (RFC §3 D1v-iv FINAL). The route information is
+        // still present in the title, and this avoids a hard left accent
+        // border that read as visually heavy in light mode.
+        <Pin className="size-3.5 shrink-0" />
+      ) : space ? (
+        <SpaceIcon space={space} className="size-3.5 shrink-0" />
+      ) : (
+        RouteIcon && <RouteIcon className="size-3.5 shrink-0" />
+      )}
       <span
         className="min-w-0 flex-1 overflow-hidden whitespace-nowrap text-left"
         style={{
@@ -236,6 +264,16 @@ export function TabBar() {
   const group = useActiveGroup();
   const moveTab = useTabStore((s) => s.moveTab);
 
+  const wsId = useCurrentWorkspace()?.id;
+  const { data: spaces = [] } = useQuery({
+    ...spaceListOptions(wsId ?? ""),
+    enabled: !!wsId,
+  });
+  const spacesByKey = useMemo(
+    () => new Map(spaces.map((space) => [space.key, space])),
+    [spaces],
+  );
+
   const sensors = useSensors(
     useSensor(PointerSensor, {
       activationConstraint: { distance: 5 },
@@ -274,6 +312,7 @@ export function TabBar() {
                 tab={tab}
                 isActive={tab.id === activeTabId}
                 isOnly={tabs.length === 1}
+                spacesByKey={spacesByKey}
               />
               {tab.pinned &&
                 index === pinnedCount - 1 &&
diff --git a/apps/desktop/src/renderer/src/pages/space-surface-pages.tsx b/apps/desktop/src/renderer/src/pages/space-surface-pages.tsx
new file mode 100644
index 0000000000..e720ae330b
--- /dev/null
+++ b/apps/desktop/src/renderer/src/pages/space-surface-pages.tsx
@@ -0,0 +1,34 @@
+import { useParams } from "react-router-dom";
+import {
+  SpaceIssuesPage,
+  SpaceProjectsPage,
+  SpaceAutopilotsPage,
+  SpaceDetailPage,
+} from "@multica/views/spaces";
+
+// Router wrappers: resolve the :spaceKey param and hand it to the shared
+// space surface pages (packages/views owns the actual rendering).
+
+export function SpaceIssuesRoute() {
+  const { spaceKey } = useParams<{ spaceKey: string }>();
+  if (!spaceKey) return null;
+  return <SpaceIssuesPage spaceKey={spaceKey} />;
+}
+
+export function SpaceProjectsRoute() {
+  const { spaceKey } = useParams<{ spaceKey: string }>();
+  if (!spaceKey) return null;
+  return <SpaceProjectsPage spaceKey={spaceKey} />;
+}
+
+export function SpaceAutopilotsRoute() {
+  const { spaceKey } = useParams<{ spaceKey: string }>();
+  if (!spaceKey) return null;
+  return <SpaceAutopilotsPage spaceKey={spaceKey} />;
+}
+
+export function SpaceDetailRoute() {
+  const { spaceKey } = useParams<{ spaceKey: string }>();
+  if (!spaceKey) return null;
+  return <SpaceDetailPage spaceKey={spaceKey} />;
+}
diff --git a/apps/desktop/src/renderer/src/routes.tsx b/apps/desktop/src/renderer/src/routes.tsx
index c39b1648bd..8d8a506459 100644
--- a/apps/desktop/src/renderer/src/routes.tsx
+++ b/apps/desktop/src/renderer/src/routes.tsx
@@ -14,6 +14,13 @@ import { AgentDetailPage } from "./pages/agent-detail-page";
 import { MemberDetailPage } from "./pages/member-detail-page";
 import { RuntimeDetailPage } from "./pages/runtime-detail-page";
 import { AttachmentPreviewRoute } from "./pages/attachment-preview-page";
+import {
+  SpaceIssuesRoute,
+  SpaceProjectsRoute,
+  SpaceAutopilotsRoute,
+  SpaceDetailRoute,
+} from "./pages/space-surface-pages";
+import { CreateSpacePage } from "@multica/views/spaces";
 import { IssuesPage } from "@multica/views/issues/components";
 import { ProjectsPage } from "@multica/views/projects/components";
 import { DashboardPage } from "@multica/views/dashboard";
@@ -123,6 +130,15 @@ export const appRoutes: RouteObject[] = [
             handle: { title: "Issues" },
           },
           {
+            // Canonical issue-detail route: identifier-first (/issue/NAI-3),
+            // also accepts a UUID.
+            path: "issue/:id",
+            element: <IssueDetailPage />,
+            handle: { title: "Issue" },
+          },
+          {
+            // Legacy alias — persisted tabs from older builds still point at
+            // /issues/:id; keep them opening instead of dropping the tab.
             path: "issues/:id",
             element: <IssueDetailPage />,
             handle: { title: "Issue" },
@@ -132,6 +148,31 @@ export const appRoutes: RouteObject[] = [
             element: <ProjectsPage />,
             handle: { title: "Projects" },
           },
+          {
+            path: "space/new",
+            element: <CreateSpacePage />,
+            handle: { title: "New space" },
+          },
+          {
+            path: "space/:spaceKey/issues",
+            element: <SpaceIssuesRoute />,
+            handle: { title: "Space issues" },
+          },
+          {
+            path: "space/:spaceKey/projects",
+            element: <SpaceProjectsRoute />,
+            handle: { title: "Space projects" },
+          },
+          {
+            path: "space/:spaceKey/autopilots",
+            element: <SpaceAutopilotsRoute />,
+            handle: { title: "Space autopilots" },
+          },
+          {
+            path: "space/:spaceKey",
+            element: <SpaceDetailRoute />,
+            handle: { title: "Space detail" },
+          },
           {
             path: "projects/:id",
             element: <ProjectDetailPage />,
diff --git a/apps/desktop/src/renderer/src/stores/tab-store.ts b/apps/desktop/src/renderer/src/stores/tab-store.ts
index 33613429eb..c435e4b35e 100644
--- a/apps/desktop/src/renderer/src/stores/tab-store.ts
+++ b/apps/desktop/src/renderer/src/stores/tab-store.ts
@@ -132,7 +132,9 @@ interface TabStore {
 const ROUTE_ICONS: Record<string, string> = {
   inbox: "Inbox",
   "my-issues": "CircleUser",
+  issue: "ListTodo",
   issues: "ListTodo",
+  space: "Users",
   projects: "FolderKanban",
   autopilots: "ListTodo",
   agents: "Bot",
diff --git a/apps/docs/content/docs/developers/conventions.zh.mdx b/apps/docs/content/docs/developers/conventions.zh.mdx
index b3a036e5b7..11a1a69acb 100644
--- a/apps/docs/content/docs/developers/conventions.zh.mdx
+++ b/apps/docs/content/docs/developers/conventions.zh.mdx
@@ -16,7 +16,7 @@ description: 代码命名规范、i18n 翻译术语表、中文风格指南的
 工作区前置路由（用户进入工作区之前能访问的路由）必须用单个单词，或者 `/{noun}/{verb}` 格式。
 
 - ✅ `/login`、`/inbox`、`/workspaces/new`
-- ❌ `/new-workspace`、`/create-team`、`/accept-invite`
+- ❌ `/new-workspace`、`/create-space`、`/accept-invite`
 
 根目录的连字符词组会跟用户自选 workspace slug 冲突，逼着团队不停审保留字列表。把名词（`workspaces`）保留下来，整个 `/workspaces/*` 子树自动受保护。
 
@@ -111,12 +111,16 @@ Multica 的产品名词分两类：
 - `task` ↔ `执行任务`（上下文清楚后可简写为「任务」）
 - `issue` 没有公认中文译法 —— 保留英文；标题可大写为 `Issue`
 - `skill` 没有公认中文译法 —— 保留英文；标题可大写为 `Skills`
+- `space` 翻成「空间」—— 它是 issue 编号命名空间的所有者，key（如 `MUL`）仍保持英文
+  不译，只构成 issue 标识符（`MUL-42`）本身；"空间"是 Notion / 语雀 / 飞书文档等同类
+  产品对"工作区下子分组"的通用译法，不会与「团队」（泛指人群）混淆，也不会与「工作区」
+  （workspace）产生歧义
 
 **为什么 `issue` / `skill` / `task` 不强制译，而 `project` / `autopilot` 必译**：
 
 - **`issue` / `task`**：dev 团队习惯说英文，"任务"在中文里和"工作"几乎同义太空泛，"工单"是 IT 工单语义，"议题"是 GitHub 风格但用户场景不匹配 —— 三个候选都不如 `issue` 准确。**但**在长篇 doc 正文里，重复 50 次 `task` 节奏不顺，所以正文允许用 `执行任务`，UI 短句、状态名仍保持小写英文。
 - **`skill`**：Multica 特有概念，没有公认中文译法。
-- **`project` 翻成「项目」**：中文里早就稳定的日常词。飞书 / Tower / Teambition / PingCode / GitHub Projects 中文版 0 例外都翻译成「项目」，没有产品保留 `project`。
+- **`project` 翻成「项目」**：中文里早就稳定的日常词。飞书 / Tower / Spacebition / PingCode / GitHub Projects 中文版 0 例外都翻译成「项目」，没有产品保留 `project`。
 - **`autopilot` 翻成「自动化」**：autopilot 在中文里联想到特斯拉的「自动驾驶」，跟产品功能（按周期跑 task）对应不上。Notion / 飞书都用「自动化」，是行业共识。
 
 ### 完整翻译 —— 概念词
@@ -124,6 +128,7 @@ Multica 的产品名词分两类：
 | 英 | 中 |
 | --- | --- |
 | Workspace | **工作区** |
+| Space | **空间**（见上） |
 | Agent | **智能体** |
 | Project | **项目** |
 | Autopilot | **自动化** |
diff --git a/apps/mobile/data/schemas.ts b/apps/mobile/data/schemas.ts
index 596ad82346..c4c2fd403b 100644
--- a/apps/mobile/data/schemas.ts
+++ b/apps/mobile/data/schemas.ts
@@ -163,6 +163,7 @@ export const ProjectSchema = z.object({
   priority: z.string(),
   lead_type: z.string().nullable(),
   lead_id: z.string().nullable(),
+  space_ids: z.array(z.string()).default([]),
   created_at: z.string(),
   updated_at: z.string(),
   issue_count: z.number().default(0),
@@ -196,6 +197,7 @@ export const EMPTY_PROJECT: Project = {
   priority: "none",
   lead_type: null,
   lead_id: null,
+  space_ids: [],
   created_at: "",
   updated_at: "",
   issue_count: 0,
diff --git a/apps/web/app/[workspaceSlug]/(dashboard)/issue/[id]/page.tsx b/apps/web/app/[workspaceSlug]/(dashboard)/issue/[id]/page.tsx
new file mode 100644
index 0000000000..46eea65115
--- /dev/null
+++ b/apps/web/app/[workspaceSlug]/(dashboard)/issue/[id]/page.tsx
@@ -0,0 +1,22 @@
+"use client";
+
+import { use } from "react";
+import { IssueDetail } from "@multica/views/issues/components";
+import { ErrorBoundary } from "@multica/ui/components/common/error-boundary";
+
+// Issue detail — identifier-first (Linear-style /issue/NAI-3), also accepts
+// a UUID. The space rides in the identifier, not in a path segment, so a
+// space move never orphans the URL (old identifiers resolve via the
+// server-side alias).
+export default function IssueDetailPage({
+  params,
+}: {
+  params: Promise<{ id: string }>;
+}) {
+  const { id } = use(params);
+  return (
+    <ErrorBoundary resetKeys={[id]}>
+      <IssueDetail issueId={id} />
+    </ErrorBoundary>
+  );
+}
diff --git a/apps/web/app/[workspaceSlug]/(dashboard)/issues/[id]/page.tsx b/apps/web/app/[workspaceSlug]/(dashboard)/issues/[id]/page.tsx
index 6f90958db8..64424278ee 100644
--- a/apps/web/app/[workspaceSlug]/(dashboard)/issues/[id]/page.tsx
+++ b/apps/web/app/[workspaceSlug]/(dashboard)/issues/[id]/page.tsx
@@ -1,18 +1,13 @@
-"use client";
+import { redirect } from "next/navigation";
 
-import { use } from "react";
-import { IssueDetail } from "@multica/views/issues/components";
-import { ErrorBoundary } from "@multica/ui/components/common/error-boundary";
-
-export default function IssueDetailPage({
+// Legacy issue-detail path. The canonical route moved to /issue/:id
+// (identifier-first, Linear-style); old bookmarks and persisted tabs land
+// here and get forwarded.
+export default async function LegacyIssueDetailRedirect({
   params,
 }: {
-  params: Promise<{ id: string }>;
+  params: Promise<{ workspaceSlug: string; id: string }>;
 }) {
-  const { id } = use(params);
-  return (
-    <ErrorBoundary resetKeys={[id]}>
-      <IssueDetail issueId={id} />
-    </ErrorBoundary>
-  );
+  const { workspaceSlug, id } = await params;
+  redirect(`/${encodeURIComponent(workspaceSlug)}/issue/${encodeURIComponent(id)}`);
 }
diff --git a/apps/web/app/[workspaceSlug]/(dashboard)/space/[spaceKey]/autopilots/page.tsx b/apps/web/app/[workspaceSlug]/(dashboard)/space/[spaceKey]/autopilots/page.tsx
new file mode 100644
index 0000000000..9bbc8c6d6e
--- /dev/null
+++ b/apps/web/app/[workspaceSlug]/(dashboard)/space/[spaceKey]/autopilots/page.tsx
@@ -0,0 +1,13 @@
+"use client";
+
+import { use } from "react";
+import { SpaceAutopilotsPage } from "@multica/views/spaces";
+
+export default function Page({
+  params,
+}: {
+  params: Promise<{ spaceKey: string }>;
+}) {
+  const { spaceKey } = use(params);
+  return <SpaceAutopilotsPage spaceKey={spaceKey} />;
+}
diff --git a/apps/web/app/[workspaceSlug]/(dashboard)/space/[spaceKey]/issues/page.tsx b/apps/web/app/[workspaceSlug]/(dashboard)/space/[spaceKey]/issues/page.tsx
new file mode 100644
index 0000000000..1ccc094f3a
--- /dev/null
+++ b/apps/web/app/[workspaceSlug]/(dashboard)/space/[spaceKey]/issues/page.tsx
@@ -0,0 +1,13 @@
+"use client";
+
+import { use } from "react";
+import { SpaceIssuesPage } from "@multica/views/spaces";
+
+export default function Page({
+  params,
+}: {
+  params: Promise<{ spaceKey: string }>;
+}) {
+  const { spaceKey } = use(params);
+  return <SpaceIssuesPage spaceKey={spaceKey} />;
+}
diff --git a/apps/web/app/[workspaceSlug]/(dashboard)/space/[spaceKey]/page.tsx b/apps/web/app/[workspaceSlug]/(dashboard)/space/[spaceKey]/page.tsx
new file mode 100644
index 0000000000..66a13b7bcb
--- /dev/null
+++ b/apps/web/app/[workspaceSlug]/(dashboard)/space/[spaceKey]/page.tsx
@@ -0,0 +1,13 @@
+"use client";
+
+import { use } from "react";
+import { SpaceDetailPage } from "@multica/views/spaces";
+
+export default function Page({
+  params,
+}: {
+  params: Promise<{ spaceKey: string }>;
+}) {
+  const { spaceKey } = use(params);
+  return <SpaceDetailPage spaceKey={spaceKey} />;
+}
diff --git a/apps/web/app/[workspaceSlug]/(dashboard)/space/[spaceKey]/projects/page.tsx b/apps/web/app/[workspaceSlug]/(dashboard)/space/[spaceKey]/projects/page.tsx
new file mode 100644
index 0000000000..9791e8680c
--- /dev/null
+++ b/apps/web/app/[workspaceSlug]/(dashboard)/space/[spaceKey]/projects/page.tsx
@@ -0,0 +1,13 @@
+"use client";
+
+import { use } from "react";
+import { SpaceProjectsPage } from "@multica/views/spaces";
+
+export default function Page({
+  params,
+}: {
+  params: Promise<{ spaceKey: string }>;
+}) {
+  const { spaceKey } = use(params);
+  return <SpaceProjectsPage spaceKey={spaceKey} />;
+}
diff --git a/apps/web/app/[workspaceSlug]/(dashboard)/space/new/page.tsx b/apps/web/app/[workspaceSlug]/(dashboard)/space/new/page.tsx
new file mode 100644
index 0000000000..fddf88f3ae
--- /dev/null
+++ b/apps/web/app/[workspaceSlug]/(dashboard)/space/new/page.tsx
@@ -0,0 +1,7 @@
+"use client";
+
+import { CreateSpacePage } from "@multica/views/spaces";
+
+export default function Page() {
+  return <CreateSpacePage />;
+}
diff --git a/docs/follow-ups/space-rollout.md b/docs/follow-ups/space-rollout.md
new file mode 100644
index 0000000000..539fa28c4c
--- /dev/null
+++ b/docs/follow-ups/space-rollout.md
@@ -0,0 +1,79 @@
+# Space rollout — 决策记录与 follow-up 清单
+
+> 开发期工作文档(非 apps/docs 官方文档)。记录 space 功能的已定模型、正在做的事、以及容易被忘掉的后续项。
+> 最后更新:2026-07-03(pr-4784-fix 分支讨论)
+
+## 已定模型(核心原则)
+
+**一切关联只在"创建时刻"起作用(做默认值),之后互不约束。**
+
+- issue ↔ space:一对一,唯一被强制的归属;space 决定 identifier 命名空间(编号 per-space 分配)。
+- 父 issue ↔ 子 issue:创建子 issue 时默认继承父的 space,之后各自独立;移动父 issue 子 issue 不跟随。(与 Linear 一致:官方文档明确 sub-issue 可属于任意 space,继承仅发生在创建时。)
+- project ↔ space:创建 issue 时用于推断默认 space;之后 issue 换 space **project 保留不动**(比 Linear 更简 —— Linear 移动时会自动移除不兼容 project,因为它有 per-space workflow/labels/cycles,我们没有)。
+- assignee 与 space 完全解耦:assignee 池 = workspace 成员 + agents,不按 space 过滤(v1 刻意如此,成员管理闭环缺失时过滤只会把人筛没)。
+- 权限:space 是组织标签,不是可见性边界;issue 可见性仍只由 workspace membership 决定。
+
+**换 space 的清理准则**(将来加 space 级属性时照此办理):
+只有"取值空间由 space 决定"的属性才需要在换 space 时清理/映射。
+当前唯一此类属性是编号/identifier(用重编号 + 别名表解决);status/priority/labels/project 均为 workspace 级,换 space 一概不动。
+
+## 正在实现(move to space,本分支)
+
+1. `issue_identifier_alias` 表:换 space 重编号后,旧 identifier(如 `MUL-3`)仍可解析到该 issue(Linear `previousIdentifiers` 的轻量版)。两个解析点加 fallback:
+   - `handler.go` `resolveIssueByIdentifier`(CLI / API 按 identifier 查)
+   - `github.go` `lookupIssueByIdentifier`(分支名/PR → issue 自动关联,不加会直接坏)
+2. `UpdateIssue` 支持 `space_id`:校验目标 space active → `IncrementSpaceIssueCounter` 重新取号 + space 内重新定位 → 写旧号别名 → 广播。
+3. 删除与新模型矛盾的校验(同一状态不允许 A 路径能到、B 路径 400):
+   - 创建/改 parent 时的父子同 space 校验(`ErrCrossSpaceChild`)
+   - 创建时显式 space × project 关联校验(`ErrProjectSpaceMismatch`)
+   - 改 issue project 时"project 与 issue 团队无关联" 400
+   - project 移除 space 时"还有 issue" 409
+4. 前端换 space 入口:右键/三点共用菜单体(`issue-actions-menu-items.tsx`)加 Space 子菜单(第一位);issue 详情右栏 Properties 首行加 Space;创建弹窗解除 `allowedSpaceIds` 限制与 sub-issue 锁定,降级为默认值种子。
+5. 换 space 不做乐观编号(新号由服务端分配),等响应/invalidate。
+
+## Follow-ups(防遗忘清单)
+
+### 缓存正确性(move to space 落地后从"优化"变"必须")
+- [ ] WS `issue:updated` 增加 `spaceChanged` flag(后端 meta 目前只有 assignee/status/project)。
+- [ ] `packages/core/issues/surface/membership.ts` 增加 space 维度(`IssueChangedDims`/`listFilterDependsOn`/`issueMatchesListFilter` 目前都不含 space);cache-coordinator 注释已预留插槽(`cache-coordinator.ts` "and future space")。
+
+### Sidebar 重构(方案已定,分两步)
+- [ ] 后端 membership 闭环:AcceptInvitation 自动入默认团队;CreateSpace 创建者自动成为 lead;`workspace_space_member.sort_order DOUBLE PRECISION`(fractional ordering,Linear 同构:SpaceMembership.sortOrder);`GET /api/spaces` 响应加 `is_member`/`sort_order`;`PATCH /api/spaces/{id}/membership` 单行改排序。
+- [ ] space scope 打通:`packages/core/issues/surface/query-plan.ts:166` 目前对 space scope 抛 `UnsupportedIssueScopeError`;加 `/space/:key/issues|projects|automations` 路由三件套(paths + web + desktop)。
+- [ ] sidebar 本体:`Workspace ▾`(Projects/Agents/Squads/Autopilots/Skills/More▾(Usage/Runtimes))+ `Spaces ▾`(只显示我加入的、按我的 sort_order、可拖拽 —— 复用 Pinned 组 dnd-kit 基建)+ Settings 底部;全局 Issues 移出导航;折叠态 Zustand persist(按 wsId)。
+- [ ] 创建 issue 默认 space 从"默认团队"切到"我的排序第一个 space"(取值函数替换即可,种子链已铺好)。
+
+### 待拍板(讨论过但未定)
+- [ ] quick-create 的 `lastSpaceId` 记忆与"排序第一 = 默认"规则冲突,推荐删记忆(排序上线时一并处理)。
+- [ ] v1 无加入团队机制:"只显示我加入的" + "没有 join API" = 别人建的团队对我不可见。推荐最小闭环:建团队对话框加成员多选 + `POST /api/spaces/{id}/members`。
+
+### 将来做 space 级属性时
+- [ ] label 下放到 space 维度时:换 space 逻辑里加"移除/映射目标 space 不存在的 label"(参照 Linear:space labels → Removed)。
+- [ ] 若引入 per-space workflow/cycle,同理加映射/清理。
+
+### 小项
+- [ ] 别名表的锦上添花:搜索输入旧 identifier 也能命中(目前只做解析 fallback)。
+- [ ] Space icon/color 自定义上传;落点在 `packages/views/spaces/components/space-icon.tsx`(当前蓝色默认块即占位,`bg-blue-500` 待 `space.color` 数据驱动替换)。
+- [ ] 批量 move to space(batch update 支持 `space_id`,前端批量工具栏加入口)。
+- [ ] 撤销:Linear 移动支持 Cmd+Z,我们无 undo 体系,记为已知差异。
+- [ ] `apps/docs/content/docs/developers/conventions.mdx:73` issue 编号章节仍是旧语义(workspace 前缀、最长 10 位、改前缀重编号),需按 space key(≤7 位、per-space 编号、编号不变)重写。
+- [ ] issue 详情页 space 字段展示(`space_key`/`space_name` 有类型无 UI 消费点)—— 本次加 Properties 行后即覆盖,验证后可勾掉。
+
+## 全产品面扫描补充(2026-07-03,对照 Linear)
+
+### P1 — 用户会很快撞上
+- [ ] 邀请成员时选团队(Linear 同款):Invitation 加 space_ids,AcceptInvitation 按其入队(现在只进默认团队)。成员管理闭环的最大剩余豁口。
+- [ ] 全局搜索(⌘K)的 space facet:按 space 过滤/分组搜索结果。
+- [ ] 移动端 space parity:identifier 显示、space 筛选、创建归属(mobile 目前只有 schema 字段)。按 apps/mobile/CLAUDE.md 流程单独排期。
+
+### P2 — 架构已留位,按需接线
+- [ ] Slack 频道 ↔ space 路由:channel 配置加 space_id,`/issue` 建到对应团队(quick-create 已支持显式 space,纯配置接线;现在一律默认团队)。
+- [ ] 订阅整个 space(入队即默认订阅该团队新 issue)—— membership 表已就位,通知系统的自然延伸。
+- [ ] space 级 dashboard/usage 统计(数据列已在,加 group-by)。
+- [ ] 团队 unarchive(现在只能归档不能恢复;一个端点 + 列表按钮)。
+- [ ] GitHub 仓库 ↔ space 关联(Linear 用于自动化路由;暂无必要)。
+
+### 有意不做(决策记录,勿误判为遗漏)
+- per-space workflow/状态、space 级 labels、cycles:Linear 换 space 清理复杂度的全部来源;我们 status/labels 为 workspace 级是刻意简化(清理判定准则见上文)。
+- 私有团队(space 作为可见性边界):v1 定为纯组织标签;若做,动整个查询层权限模型,属独立大项目。
+- squad/agent 不归属 space:workspace 资产、跨团队服务;其名下 issue 各有各的 space,无冲突。
diff --git a/packages/core/api/client.ts b/packages/core/api/client.ts
index 2566187b90..4a4dbf1a6c 100644
--- a/packages/core/api/client.ts
+++ b/packages/core/api/client.ts
@@ -74,6 +74,12 @@ import type {
   HasPendingChatTasksResponse,
   SendChatMessageResponse,
   CancelTaskResponse,
+  Space,
+  SpaceMembership,
+  ListSpaceMembersResponse,
+  CreateSpaceRequest,
+  UpdateSpaceRequest,
+  ListSpacesResponse,
   Project,
   CreateProjectRequest,
   UpdateProjectRequest,
@@ -144,7 +150,7 @@ import type {
 import { type Logger, noopLogger } from "../logger";
 import { createRequestId } from "../utils";
 import { getCurrentSlug } from "../platform/workspace-storage";
-import { parseWithFallback } from "./schema";
+import { parseWithFallback, parseOrWarn } from "./schema";
 import {
   AgentTemplateSchema,
   AgentTemplateSummaryListSchema,
@@ -170,6 +176,7 @@ import {
   EMPTY_CREATE_AGENT_FROM_TEMPLATE_RESPONSE,
   EMPTY_GROUPED_ISSUES_RESPONSE,
   EMPTY_LIST_ISSUES_RESPONSE,
+  EMPTY_LIST_SPACES_RESPONSE,
   EMPTY_SEARCH_ISSUES_RESPONSE,
   EMPTY_SEARCH_PROJECTS_RESPONSE,
   EMPTY_SQUAD,
@@ -185,6 +192,11 @@ import {
   ListAutopilotsResponseSchema,
   EMPTY_LIST_AUTOPILOTS_RESPONSE,
   ListIssuesResponseSchema,
+  ListSpacesResponseSchema,
+  ListSpaceMembersResponseSchema,
+  EMPTY_LIST_SPACE_MEMBERS_RESPONSE,
+  SpaceSchema,
+  SpaceMembershipSchema,
   ListWebhookDeliveriesResponseSchema,
   RuntimeHourlyActivityListSchema,
   RuntimeUsageByAgentListSchema,
@@ -508,6 +520,7 @@ export class ApiClient {
     if (params?.assignee_ids?.length) search.set("assignee_ids", params.assignee_ids.join(","));
     if (params?.assignee_types?.length) search.set("assignee_types", params.assignee_types.join(","));
     if (params?.creator_id) search.set("creator_id", params.creator_id);
+    if (params?.space_id) search.set("space_id", params.space_id);
     if (params?.project_id) search.set("project_id", params.project_id);
     if (params?.involves_user_id) search.set("involves_user_id", params.involves_user_id);
     if (params?.metadata && Object.keys(params.metadata).length > 0) {
@@ -538,6 +551,7 @@ export class ApiClient {
     if (params.assignee_id) search.set("assignee_id", params.assignee_id);
     if (params.assignee_ids?.length) search.set("assignee_ids", params.assignee_ids.join(","));
     if (params.creator_id) search.set("creator_id", params.creator_id);
+    if (params.space_id) search.set("space_id", params.space_id);
     if (params.project_id) search.set("project_id", params.project_id);
     if (params.involves_user_id) search.set("involves_user_id", params.involves_user_id);
     if (params.metadata && Object.keys(params.metadata).length > 0) {
@@ -609,6 +623,7 @@ export class ApiClient {
     agent_id?: string;
     squad_id?: string;
     prompt: string;
+    space_id?: string | null;
     project_id?: string | null;
     parent_issue_id?: string | null;
     attachment_ids?: string[];
@@ -1583,6 +1598,60 @@ export class ApiClient {
     });
   }
 
+  // Spaces
+  async listSpaces(): Promise<ListSpacesResponse> {
+    const raw = await this.fetch<unknown>("/api/spaces");
+    return parseWithFallback(raw, ListSpacesResponseSchema, EMPTY_LIST_SPACES_RESPONSE, {
+      endpoint: "GET /api/spaces",
+    });
+  }
+
+  async createSpace(data: CreateSpaceRequest): Promise<Space> {
+    const raw = await this.fetch<unknown>("/api/spaces", {
+      method: "POST",
+      body: JSON.stringify(data),
+    });
+    return parseOrWarn(raw, SpaceSchema, { endpoint: "POST /api/spaces" });
+  }
+
+  async updateSpace(id: string, data: UpdateSpaceRequest): Promise<Space> {
+    const raw = await this.fetch<unknown>(`/api/spaces/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data),
+    });
+    return parseOrWarn(raw, SpaceSchema, { endpoint: "PATCH /api/spaces/:id" });
+  }
+
+  async updateSpaceMembership(id: string, data: { sort_order: number }): Promise<SpaceMembership> {
+    const raw = await this.fetch<unknown>(`/api/spaces/${id}/membership`, {
+      method: "PATCH",
+      body: JSON.stringify(data),
+    });
+    return parseOrWarn(raw, SpaceMembershipSchema, { endpoint: "PATCH /api/spaces/:id/membership" });
+  }
+
+  async replaceSpaceMembers(id: string, memberIds: string[]): Promise<ListSpaceMembersResponse> {
+    const raw = await this.fetch<unknown>(`/api/spaces/${id}/members`, {
+      method: "PUT",
+      body: JSON.stringify({ member_ids: memberIds }),
+    });
+    return parseWithFallback(raw, ListSpaceMembersResponseSchema, EMPTY_LIST_SPACE_MEMBERS_RESPONSE, {
+      endpoint: "PUT /api/spaces/:id/members",
+    });
+  }
+
+  async listSpaceMembers(id: string): Promise<ListSpaceMembersResponse> {
+    const raw = await this.fetch<unknown>(`/api/spaces/${id}/members`);
+    return parseWithFallback(raw, ListSpaceMembersResponseSchema, EMPTY_LIST_SPACE_MEMBERS_RESPONSE, {
+      endpoint: "GET /api/spaces/:id/members",
+    });
+  }
+
+  async archiveSpace(id: string): Promise<Space> {
+    const raw = await this.fetch<unknown>(`/api/spaces/${id}`, { method: "DELETE" });
+    return parseOrWarn(raw, SpaceSchema, { endpoint: "DELETE /api/spaces/:id" });
+  }
+
   // Members
   async listMembers(workspaceId: string): Promise<MemberWithUser[]> {
     return this.fetch(`/api/workspaces/${workspaceId}/members`);
@@ -1911,9 +1980,10 @@ export class ApiClient {
   }
 
   // Projects
-  async listProjects(params?: { status?: string }): Promise<ListProjectsResponse> {
+  async listProjects(params?: { status?: string; space_id?: string }): Promise<ListProjectsResponse> {
     const search = new URLSearchParams();
     if (params?.status) search.set("status", params.status);
+    if (params?.space_id) search.set("space_id", params.space_id);
     return this.fetch(`/api/projects?${search}`);
   }
 
@@ -2104,9 +2174,10 @@ export class ApiClient {
   }
 
   // Autopilots
-  async listAutopilots(params?: { status?: string }): Promise<ListAutopilotsResponse> {
+  async listAutopilots(params?: { status?: string; space_id?: string }): Promise<ListAutopilotsResponse> {
     const search = new URLSearchParams();
     if (params?.status) search.set("status", params.status);
+    if (params?.space_id) search.set("space_id", params.space_id);
     const raw = await this.fetch<unknown>(`/api/autopilots?${search}`);
     return parseWithFallback(
       raw,
diff --git a/packages/core/api/schema.ts b/packages/core/api/schema.ts
index 37047f5b4b..0236b8b74e 100644
--- a/packages/core/api/schema.ts
+++ b/packages/core/api/schema.ts
@@ -53,3 +53,33 @@ export function parseWithFallback<T>(
   );
   return fallback;
 }
+
+/**
+ * Validate a mutation response against a zod schema, warning (not throwing) on
+ * drift. Unlike `parseWithFallback`, there is no synthetic fallback: a write
+ * response has no safe empty stand-in — an `id: ""` placeholder would corrupt
+ * the caches these responses feed. On drift we log via the same channel as
+ * `parseWithFallback` and return the raw value cast to `T`; the caller's
+ * optimistic cache patch plus `onSettled` invalidation remain the authoritative
+ * safety net.
+ *
+ * See CLAUDE.md "API Compatibility" for when to reach for this over
+ * `parseWithFallback`.
+ */
+export function parseOrWarn<T>(
+  data: unknown,
+  schema: ZodType,
+  opts: ParseOptions,
+): T {
+  const result = schema.safeParse(data);
+  if (result.success) return result.data as T;
+  schemaLogger.warn(
+    `API response failed schema validation: ${opts.endpoint}`,
+    {
+      endpoint: opts.endpoint,
+      issues: result.error.issues,
+      received: data,
+    },
+  );
+  return data as T;
+}
diff --git a/packages/core/api/schemas.test.ts b/packages/core/api/schemas.test.ts
index 12d275a381..3faf5efccf 100644
--- a/packages/core/api/schemas.test.ts
+++ b/packages/core/api/schemas.test.ts
@@ -12,6 +12,11 @@ import {
   InboxUnreadSummarySchema,
   IssueTriggerPreviewSchema,
   ListIssuesResponseSchema,
+  ListSpacesResponseSchema,
+  SpaceSchema,
+  EMPTY_LIST_SPACES_RESPONSE,
+  SearchProjectsResponseSchema,
+  EMPTY_SEARCH_PROJECTS_RESPONSE,
   RuntimeHourlyActivityListSchema,
   RuntimeUsageByAgentListSchema,
   RuntimeUsageByHourListSchema,
@@ -509,3 +514,123 @@ describe("InboxUnreadSummarySchema", () => {
     ).toBe(EMPTY_INBOX_UNREAD_SUMMARY);
   });
 });
+
+describe("SpaceSchema / ListSpacesResponseSchema drift", () => {
+  const ENDPOINT = { endpoint: "GET /api/spaces" };
+  const baseSpace = {
+    id: "space-1",
+    workspace_id: "ws-1",
+    name: "Frontend",
+    key: "FE",
+    description: "",
+    icon: null,
+    issue_counter: 3,
+    archived_at: null,
+    created_by: "user-1",
+    created_at: "2026-05-01T00:00:00Z",
+    updated_at: "2026-05-01T00:00:00Z",
+  };
+
+  it("parses a well-formed space and tolerates extra fields", () => {
+    const parsed = SpaceSchema.parse({ ...baseSpace, future_field: "ignored" });
+    expect(parsed.id).toBe("space-1");
+    expect(parsed.key).toBe("FE");
+  });
+
+  it("defaults scalar fields when an older backend omits them", () => {
+    const parsed = SpaceSchema.parse({ id: "space-2", workspace_id: "ws-1" });
+    expect(parsed.name).toBe("");
+    expect(parsed.key).toBe("");
+    expect(parsed.description).toBe("");
+    expect(parsed.icon).toBeNull();
+    expect(parsed.issue_counter).toBe(0);
+    expect(parsed.archived_at).toBeNull();
+  });
+
+  it("parses a list response and coerces total", () => {
+    const parsed = parseWithFallback(
+      { spaces: [baseSpace], total: 1 },
+      ListSpacesResponseSchema,
+      EMPTY_LIST_SPACES_RESPONSE,
+      ENDPOINT,
+    );
+    expect(parsed.spaces).toHaveLength(1);
+    expect(parsed.total).toBe(1);
+  });
+
+  it("defaults spaces and total when the body omits them", () => {
+    const parsed = parseWithFallback(
+      {},
+      ListSpacesResponseSchema,
+      EMPTY_LIST_SPACES_RESPONSE,
+      ENDPOINT,
+    );
+    expect(parsed.spaces).toEqual([]);
+    expect(parsed.total).toBe(0);
+  });
+
+  it("falls back to empty when a space row has a wrong-typed id", () => {
+    expect(
+      parseWithFallback(
+        { spaces: [{ ...baseSpace, id: 42 }], total: 1 },
+        ListSpacesResponseSchema,
+        EMPTY_LIST_SPACES_RESPONSE,
+        ENDPOINT,
+      ),
+    ).toBe(EMPTY_LIST_SPACES_RESPONSE);
+  });
+
+  it("falls back to empty for a non-object body", () => {
+    expect(
+      parseWithFallback(null, ListSpacesResponseSchema, EMPTY_LIST_SPACES_RESPONSE, ENDPOINT),
+    ).toBe(EMPTY_LIST_SPACES_RESPONSE);
+  });
+});
+
+describe("ProjectSchema space_ids drift", () => {
+  const ENDPOINT = { endpoint: "GET /api/projects/search" };
+  const baseProject = {
+    id: "proj-1",
+    workspace_id: "ws-1",
+    title: "Website",
+    description: null,
+    icon: null,
+    status: "active",
+    priority: "medium",
+    lead_type: null,
+    lead_id: null,
+    created_at: "2026-05-01T00:00:00Z",
+    updated_at: "2026-05-01T00:00:00Z",
+    match_source: "title",
+  };
+
+  it("preserves a populated space_ids array", () => {
+    const parsed = parseWithFallback(
+      { projects: [{ ...baseProject, space_ids: ["space-1", "space-2"] }], total: 1 },
+      SearchProjectsResponseSchema,
+      EMPTY_SEARCH_PROJECTS_RESPONSE,
+      ENDPOINT,
+    );
+    expect(parsed.projects[0]?.space_ids).toEqual(["space-1", "space-2"]);
+  });
+
+  it("defaults space_ids to an empty array when the field is missing", () => {
+    const parsed = parseWithFallback(
+      { projects: [baseProject], total: 1 },
+      SearchProjectsResponseSchema,
+      EMPTY_SEARCH_PROJECTS_RESPONSE,
+      ENDPOINT,
+    );
+    expect(parsed.projects[0]?.space_ids).toEqual([]);
+  });
+
+  it("coerces a null space_ids to an empty array", () => {
+    const parsed = parseWithFallback(
+      { projects: [{ ...baseProject, space_ids: null }], total: 1 },
+      SearchProjectsResponseSchema,
+      EMPTY_SEARCH_PROJECTS_RESPONSE,
+      ENDPOINT,
+    );
+    expect(parsed.projects[0]?.space_ids).toEqual([]);
+  });
+});
diff --git a/packages/core/api/schemas.ts b/packages/core/api/schemas.ts
index 3932adcc3d..108aeb9ec3 100644
--- a/packages/core/api/schemas.ts
+++ b/packages/core/api/schemas.ts
@@ -17,10 +17,13 @@ import type {
   GroupedIssuesResponse,
   InboxWorkspaceUnread,
   ListIssuesResponse,
+  ListSpacesResponse,
+  ListSpaceMembersResponse,
   ListWebhookDeliveriesResponse,
   SearchIssuesResponse,
   SearchProjectsResponse,
   Squad,
+  Space,
   TimelineEntry,
   User,
   WebhookDelivery,
@@ -265,6 +268,9 @@ const IssueMetadataSchema = z.record(z.string(), z.union([z.string(), z.number()
 export const IssueSchema = z.object({
   id: z.string(),
   workspace_id: z.string(),
+  space_id: z.string().nullable().default(null),
+  space_key: z.string().nullable().default(null),
+  space_name: z.string().nullable().default(null),
   number: z.number(),
   identifier: z.string(),
   title: z.string(),
@@ -317,6 +323,73 @@ export const EMPTY_SEARCH_ISSUES_RESPONSE: SearchIssuesResponse = {
   total: 0,
 };
 
+export const SpaceSchema = z.object({
+  id: z.string(),
+  workspace_id: z.string(),
+  name: z.string().default(""),
+  key: z.string().default(""),
+  description: z.string().default(""),
+  icon: z.string().nullable().default(null),
+  issue_counter: z.number().default(0),
+  archived_at: z.string().nullable().default(null),
+  created_by: z.string().nullable().default(null),
+  created_at: z.string().default(""),
+  updated_at: z.string().default(""),
+  is_member: z.boolean().default(false),
+  sort_order: z.number().default(0),
+}).loose();
+
+// PATCH /api/spaces/{id}/membership — the caller's own sort position.
+export const SpaceMembershipSchema = z.object({
+  space_id: z.string().default(""),
+  sort_order: z.number().default(0),
+}).loose();
+
+export const SpaceMemberSchema = z.object({
+  user_id: z.string(),
+  name: z.string().default(""),
+  email: z.string().default(""),
+  avatar_url: z.string().nullable().default(null),
+  role: z.string().default("member"),
+  created_at: z.string().default(""),
+}).loose();
+
+export const ListSpaceMembersResponseSchema = z.object({
+  members: z.array(SpaceMemberSchema).default([]),
+  total: z.number().default(0),
+});
+
+export const EMPTY_LIST_SPACE_MEMBERS_RESPONSE: ListSpaceMembersResponse = {
+  members: [],
+  total: 0,
+};
+
+export const ListSpacesResponseSchema = z.object({
+  spaces: z.array(SpaceSchema).default([]),
+  total: z.number().default(0),
+}).loose();
+
+export const EMPTY_SPACE: Space = {
+  id: "",
+  workspace_id: "",
+  name: "",
+  key: "",
+  description: "",
+  icon: null,
+  issue_counter: 0,
+  archived_at: null,
+  created_by: null,
+  created_at: "",
+  updated_at: "",
+  is_member: false,
+  sort_order: 0,
+};
+
+export const EMPTY_LIST_SPACES_RESPONSE: ListSpacesResponse = {
+  spaces: [],
+  total: 0,
+};
+
 const ProjectSchema = z.object({
   id: z.string(),
   workspace_id: z.string(),
@@ -332,6 +405,9 @@ const ProjectSchema = z.object({
   issue_count: z.number().default(0),
   done_count: z.number().default(0),
   resource_count: z.number().default(0),
+  // Tolerate a missing key or an explicit null (older backends) by defaulting
+  // to an empty membership list.
+  space_ids: z.array(z.string()).nullish().transform((ids) => ids ?? []),
 }).loose();
 
 const SearchProjectResultSchema = ProjectSchema.extend({
@@ -879,6 +955,7 @@ const AutopilotListItemSchema = z.object({
   title: z.string(),
   description: z.string().nullable().optional(),
   project_id: z.string().nullable().optional(),
+  space_id: z.string().nullable().optional(),
   // Older servers (pre-MUL-2429) omit assignee_type; "agent" is the
   // documented default.
   assignee_type: z.string().default("agent"),
diff --git a/packages/core/issues/queries.ts b/packages/core/issues/queries.ts
index a4123beb96..82d954bf68 100644
--- a/packages/core/issues/queries.ts
+++ b/packages/core/issues/queries.ts
@@ -16,6 +16,7 @@ export interface IssueSortParam {
   date_field?: ListIssuesParams["date_field"];
   date_start?: ListIssuesParams["date_start"];
   date_end?: ListIssuesParams["date_end"];
+  space_id?: ListIssuesParams["space_id"];
 }
 
 export const issueKeys = {
@@ -119,6 +120,7 @@ export type MyIssuesFilter = Pick<
   | "assignee_ids"
   | "assignee_types"
   | "creator_id"
+  | "space_id"
   | "project_id"
   | "involves_user_id"
 >;
diff --git a/packages/core/issues/stores/view-store.ts b/packages/core/issues/stores/view-store.ts
index b4c4f0b561..4a422c6f4c 100644
--- a/packages/core/issues/stores/view-store.ts
+++ b/packages/core/issues/stores/view-store.ts
@@ -74,6 +74,7 @@ export interface IssueViewState {
   assigneeFilters: ActorFilterValue[];
   includeNoAssignee: boolean;
   creatorFilters: ActorFilterValue[];
+  spaceFilter: string | null;
   projectFilters: string[];
   includeNoProject: boolean;
   labelFilters: string[];
@@ -112,6 +113,7 @@ export interface IssueViewState {
   toggleAssigneeFilter: (value: ActorFilterValue) => void;
   toggleNoAssignee: () => void;
   toggleCreatorFilter: (value: ActorFilterValue) => void;
+  setSpaceFilter: (spaceId: string | null) => void;
   toggleProjectFilter: (projectId: string) => void;
   toggleNoProject: () => void;
   toggleLabelFilter: (labelId: string) => void;
@@ -140,6 +142,7 @@ export const viewStoreSlice = (set: StoreApi<IssueViewState>["setState"]): Issue
   assigneeFilters: [],
   includeNoAssignee: false,
   creatorFilters: [],
+  spaceFilter: null,
   projectFilters: [],
   includeNoProject: false,
   labelFilters: [],
@@ -210,6 +213,7 @@ export const viewStoreSlice = (set: StoreApi<IssueViewState>["setState"]): Issue
           : [...state.creatorFilters, value],
       };
     }),
+  setSpaceFilter: (spaceId) => set({ spaceFilter: spaceId }),
   toggleProjectFilter: (projectId) =>
     set((state) => ({
       projectFilters: state.projectFilters.includes(projectId)
@@ -250,6 +254,7 @@ export const viewStoreSlice = (set: StoreApi<IssueViewState>["setState"]): Issue
       assigneeFilters: [],
       includeNoAssignee: false,
       creatorFilters: [],
+      spaceFilter: null,
       projectFilters: [],
       includeNoProject: false,
       labelFilters: [],
diff --git a/packages/core/issues/surface/membership.test.ts b/packages/core/issues/surface/membership.test.ts
index e707475798..d487fa52a2 100644
--- a/packages/core/issues/surface/membership.test.ts
+++ b/packages/core/issues/surface/membership.test.ts
@@ -83,6 +83,18 @@ describe("issueMatchesListFilter", () => {
     ).toBe(false);
   });
 
+  it("judges space filters — a moved issue leaves the old space's list", () => {
+    expect(
+      issueMatchesListFilter(makeIssue({ space_id: "t1" }), "space:t1", { space_id: "t1" }),
+    ).toBe(true);
+    expect(
+      issueMatchesListFilter(makeIssue({ space_id: "t2" }), "space:t1", { space_id: "t1" }),
+    ).toBe(false);
+    expect(
+      issueMatchesListFilter(makeIssue({ space_id: undefined }), "space:t1", { space_id: "t1" }),
+    ).toBe("unknown");
+  });
+
   it("never decides involves_user_id — the ownership graph is server-side", () => {
     expect(
       issueMatchesListFilter(makeIssue(), "agents", { involves_user_id: "me" }),
@@ -110,11 +122,13 @@ describe("issueChangedDims", () => {
       assignee: true,
       project: false,
       status: false,
+      space: false,
     });
     expect(issueChangedDims({ project_id: null })).toEqual({
       assignee: false,
       project: true,
       status: false,
+      space: false,
     });
   });
 
@@ -124,10 +138,13 @@ describe("issueChangedDims", () => {
       assignee: false,
       project: false,
       status: false,
+      space: false,
     });
     expect(issueChangedDims({ status: "todo" }, base).status).toBe(false);
     expect(issueChangedDims({ status: "done" }, base).status).toBe(true);
     expect(issueChangedDims({ project_id: "p2" }, base).project).toBe(true);
+    expect(issueChangedDims({ space_id: "t2" }, makeIssue({ space_id: "t1" })).space).toBe(true);
+    expect(issueChangedDims({ space_id: "t1" }, makeIssue({ space_id: "t1" })).space).toBe(false);
   });
 
   it("ignores non-membership fields", () => {
@@ -135,12 +152,13 @@ describe("issueChangedDims", () => {
       assignee: false,
       project: false,
       status: false,
+      space: false,
     });
   });
 });
 
 describe("listFilterDependsOn", () => {
-  const none = { assignee: false, project: false, status: false };
+  const none = { assignee: false, project: false, status: false, space: false };
 
   it("my:all reacts to assignee changes only", () => {
     expect(listFilterDependsOn("all", {}, { ...none, assignee: true })).toBe(true);
@@ -175,19 +193,28 @@ describe("listFilterDependsOn", () => {
     ).toBe(false);
   });
 
+  it("space filters react to space changes", () => {
+    expect(
+      listFilterDependsOn("space:t1", { space_id: "t1" }, { ...none, space: true }),
+    ).toBe(true);
+    expect(
+      listFilterDependsOn("space:t1", { space_id: "t1" }, { ...none, status: true }),
+    ).toBe(false);
+  });
+
   it("creator filters never react — creator is immutable", () => {
     expect(
       listFilterDependsOn(
         "created",
         { creator_id: "me" },
-        { assignee: true, project: true, status: true },
+        { assignee: true, project: true, status: true, space: true },
       ),
     ).toBe(false);
   });
 
   it("the unfiltered workspace list never reacts", () => {
     expect(
-      listFilterDependsOn(undefined, {}, { assignee: true, project: true, status: true }),
+      listFilterDependsOn(undefined, {}, { assignee: true, project: true, status: true, space: true }),
     ).toBe(false);
   });
 });
diff --git a/packages/core/issues/surface/membership.ts b/packages/core/issues/surface/membership.ts
index 019cc20f56..be86e7ef16 100644
--- a/packages/core/issues/surface/membership.ts
+++ b/packages/core/issues/surface/membership.ts
@@ -22,6 +22,7 @@ export interface IssueChangedDims {
   assignee: boolean;
   project: boolean;
   status: boolean;
+  space: boolean;
 }
 
 /**
@@ -44,6 +45,7 @@ export function issueChangedDims(
       (has("assignee_type") && (!base || base.assignee_type !== p.assignee_type)),
     project: has("project_id") && (!base || base.project_id !== p.project_id),
     status: has("status") && p.status !== undefined && (!base || base.status !== p.status),
+    space: has("space_id") && (!base || base.space_id !== p.space_id),
   };
 }
 
@@ -72,6 +74,7 @@ export function listFilterDependsOn(
     return true;
   }
   if (changed.project && filter.project_id !== undefined) return true;
+  if (changed.space && filter.space_id !== undefined) return true;
   // creator_id filters never react to updates — creator is immutable.
   return false;
 }
@@ -123,6 +126,10 @@ export function issueMatchesListFilter(
     if (issue.project_id === undefined) unknown = true;
     else if (issue.project_id !== filter.project_id) return false;
   }
+  if (filter.space_id !== undefined) {
+    if (issue.space_id === undefined) unknown = true;
+    else if (issue.space_id !== filter.space_id) return false;
+  }
   if (filter.involves_user_id !== undefined) {
     // Indirect-assignee predicate (owned agents / squads) — server-only.
     unknown = true;
diff --git a/packages/core/issues/surface/query-plan.ts b/packages/core/issues/surface/query-plan.ts
index 5ea411b412..1bace1b5cb 100644
--- a/packages/core/issues/surface/query-plan.ts
+++ b/packages/core/issues/surface/query-plan.ts
@@ -3,11 +3,7 @@ import type {
   AssigneeGroupedIssuesFilter,
   MyIssuesFilter,
 } from "../queries";
-import {
-  issueScopeKey,
-  UnsupportedIssueScopeError,
-  type IssueScope,
-} from "./scope";
+import { issueScopeKey, type IssueScope } from "./scope";
 
 export type IssueSurfaceQueryPlan =
   | {
@@ -163,7 +159,22 @@ export function buildIssueSurfaceQueryPlan(
             : {},
       };
     }
-    case "team":
-      throw new UnsupportedIssueScopeError(scope, "issue surface query plan");
+    case "space": {
+      // Mirrors the project plan: space_id is a real server filter on both
+      // the list and grouped endpoints, so the space surface gets its own
+      // cache entry, and issues created from it default into the space.
+      const queryFilter = { space_id: scope.spaceId };
+      return {
+        kind: "scoped",
+        scopeKey,
+        queryScope: scopeKey,
+        queryFilter,
+        groupedScopeFilter: queryFilter,
+        loadMoreScope: scopeKey,
+        loadMoreFilter: queryFilter,
+        userId: undefined,
+        createDefaults: { space_id: scope.spaceId },
+      };
+    }
   }
 }
diff --git a/packages/core/issues/surface/scope.test.ts b/packages/core/issues/surface/scope.test.ts
index 7b08477be4..2890d797f0 100644
--- a/packages/core/issues/surface/scope.test.ts
+++ b/packages/core/issues/surface/scope.test.ts
@@ -1,8 +1,5 @@
 import { describe, expect, it } from "vitest";
-import {
-  UnsupportedIssueScopeError,
-  issueScopeKey,
-} from "./scope";
+import { issueScopeKey } from "./scope";
 import { buildIssueSurfaceQueryPlan } from "./query-plan";
 
 describe("issue surface scope", () => {
@@ -25,7 +22,7 @@ describe("issue surface scope", () => {
         relation: "created",
       }),
     ).toBe("actor:agent:a1:created");
-    expect(issueScopeKey({ type: "team", teamId: "t1" })).toBe("team:t1");
+    expect(issueScopeKey({ type: "space", spaceId: "t1" })).toBe("space:t1");
   });
 
   it("builds the workspace query plan", () => {
@@ -145,10 +142,16 @@ describe("issue surface scope", () => {
     });
   });
 
-  it("throws for team until the issue API has a team filter", () => {
-    const scope = { type: "team" as const, teamId: "t1" };
-    expect(() => buildIssueSurfaceQueryPlan(scope)).toThrow(
-      UnsupportedIssueScopeError,
-    );
+  it("builds the space query plan mirroring the project shape", () => {
+    expect(
+      buildIssueSurfaceQueryPlan({ type: "space", spaceId: "t1" }),
+    ).toMatchObject({
+      kind: "scoped",
+      scopeKey: "space:t1",
+      queryScope: "space:t1",
+      queryFilter: { space_id: "t1" },
+      groupedScopeFilter: { space_id: "t1" },
+      createDefaults: { space_id: "t1" },
+    });
   });
 });
diff --git a/packages/core/issues/surface/scope.ts b/packages/core/issues/surface/scope.ts
index 21a7839795..552c1de18c 100644
--- a/packages/core/issues/surface/scope.ts
+++ b/packages/core/issues/surface/scope.ts
@@ -16,7 +16,7 @@ export type IssueScope =
       actorId: string;
       relation: "assigned" | "created";
     }
-  | { type: "team"; teamId: string };
+  | { type: "space"; spaceId: string };
 
 export class UnsupportedIssueScopeError extends Error {
   constructor(scope: IssueScope, operation: string) {
@@ -35,7 +35,7 @@ export function issueScopeKey(scope: IssueScope): string {
       return `project:${scope.projectId}`;
     case "actor":
       return `actor:${scope.actorType}:${scope.actorId}:${scope.relation}`;
-    case "team":
-      return `team:${scope.teamId}`;
+    case "space":
+      return `space:${scope.spaceId}`;
   }
 }
diff --git a/packages/core/issues/ws-updaters.ts b/packages/core/issues/ws-updaters.ts
index 004e1a613d..cda525a6b9 100644
--- a/packages/core/issues/ws-updaters.ts
+++ b/packages/core/issues/ws-updaters.ts
@@ -54,6 +54,7 @@ export function onIssueUpdated(
     assigneeChanged?: boolean;
     statusChanged?: boolean;
     projectChanged?: boolean;
+    spaceChanged?: boolean;
   } = {},
 ) {
   // Look up the OLD parent + cached entity before mutating cache state, so we
@@ -96,6 +97,11 @@ export function onIssueUpdated(
       (cachedIssue !== undefined &&
         issue.status !== undefined &&
         issue.status !== cachedIssue.status),
+    space:
+      meta.spaceChanged ??
+      (cachedIssue !== undefined &&
+        issue.space_id !== undefined &&
+        issue.space_id !== cachedIssue.space_id),
   };
 
   // The coordinator applies the same rules table the local mutations use:
diff --git a/packages/core/layout/sidebar-store.ts b/packages/core/layout/sidebar-store.ts
new file mode 100644
index 0000000000..5a90a8e72b
--- /dev/null
+++ b/packages/core/layout/sidebar-store.ts
@@ -0,0 +1,32 @@
+"use client";
+
+import { create } from "zustand";
+import { createJSONStorage, persist } from "zustand/middleware";
+import { createWorkspaceAwareStorage, registerForWorkspaceRehydration } from "../platform/workspace-storage";
+import { defaultStorage } from "../platform/storage";
+
+// Sidebar group collapse state, persisted per workspace (same
+// workspace-aware storage the quick-create prefs use). Keys are group ids:
+// "pinned", "workspace", "more", "spaces", and `space:{spaceId}` for each space
+// group. Absent key = expanded — groups default open so a fresh workspace
+// shows its whole structure.
+interface SidebarState {
+  collapsed: Record<string, boolean>;
+  setGroupCollapsed: (key: string, collapsed: boolean) => void;
+}
+
+export const useSidebarStore = create<SidebarState>()(
+  persist(
+    (set) => ({
+      collapsed: {},
+      setGroupCollapsed: (key, collapsed) =>
+        set((s) => ({ collapsed: { ...s.collapsed, [key]: collapsed } })),
+    }),
+    {
+      name: "multica_sidebar",
+      storage: createJSONStorage(() => createWorkspaceAwareStorage(defaultStorage)),
+    },
+  ),
+);
+
+registerForWorkspaceRehydration(() => useSidebarStore.persist.rehydrate());
diff --git a/packages/core/package.json b/packages/core/package.json
index 714e7aca68..2e5644a9f0 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -70,6 +70,12 @@
     "./projects/queries": "./projects/queries.ts",
     "./projects/mutations": "./projects/mutations.ts",
     "./projects/config": "./projects/config.ts",
+    "./spaces": "./spaces/index.ts",
+    "./spaces/queries": "./spaces/queries.ts",
+    "./spaces/mutations": "./spaces/mutations.ts",
+    "./spaces/default-space": "./spaces/default-space.ts",
+    "./spaces/last-space-store": "./spaces/last-space-store.ts",
+    "./layout/sidebar-store": "./layout/sidebar-store.ts",
     "./labels": "./labels/index.ts",
     "./labels/queries": "./labels/queries.ts",
     "./labels/mutations": "./labels/mutations.ts",
diff --git a/packages/core/paths/consistency.test.ts b/packages/core/paths/consistency.test.ts
index 422b47df50..d67508eada 100644
--- a/packages/core/paths/consistency.test.ts
+++ b/packages/core/paths/consistency.test.ts
@@ -19,6 +19,7 @@ describe("paths.workspace() shape", () => {
         "root",
         "usage",
         "issues",
+        "spaceNew",
         "projects",
         "autopilots",
         "agents",
diff --git a/packages/core/paths/paths.test.ts b/packages/core/paths/paths.test.ts
index 5df542a301..79fc1566d4 100644
--- a/packages/core/paths/paths.test.ts
+++ b/packages/core/paths/paths.test.ts
@@ -7,7 +7,7 @@ describe("paths.workspace(slug)", () => {
   it("builds workspace paths with slug prefix", () => {
     expect(ws.usage()).toBe("/acme/usage");
     expect(ws.issues()).toBe("/acme/issues");
-    expect(ws.issueDetail("abc-123")).toBe("/acme/issues/abc-123");
+    expect(ws.issueDetail("abc-123")).toBe("/acme/issue/abc-123");
     expect(ws.projects()).toBe("/acme/projects");
     expect(ws.projectDetail("p1")).toBe("/acme/projects/p1");
     expect(ws.autopilots()).toBe("/acme/autopilots");
@@ -26,7 +26,7 @@ describe("paths.workspace(slug)", () => {
   });
 
   it("URL-encodes special characters in ids", () => {
-    expect(ws.issueDetail("id with space")).toBe("/acme/issues/id%20with%20space");
+    expect(ws.issueDetail("id with space")).toBe("/acme/issue/id%20with%20space");
   });
 });
 
diff --git a/packages/core/paths/paths.ts b/packages/core/paths/paths.ts
index 8743c9e375..c36c5f6ab0 100644
--- a/packages/core/paths/paths.ts
+++ b/packages/core/paths/paths.ts
@@ -20,7 +20,21 @@ function workspaceScoped(slug: string) {
     root: () => `${ws}/issues`,
     usage: () => `${ws}/usage`,
     issues: () => `${ws}/issues`,
-    issueDetail: (id: string) => `${ws}/issues/${encode(id)}`,
+    // Issue detail is identifier-first (Linear-style /issue/NAI-3): the space
+    // rides in the identifier, never in a nested path segment, so moving an
+    // issue between spaces can't orphan the URL (old identifiers keep
+    // resolving via the server-side alias). The same route accepts a UUID —
+    // internal navigation passes ids, shared links pass identifiers.
+    issueDetail: (idOrIdentifier: string) => `${ws}/issue/${encode(idOrIdentifier)}`,
+    // Space-scoped surfaces, addressed by space key (readable, stable: keys
+    // freeze once a space has issues) — /space/ENG/issues, Linear-style.
+    spaceIssues: (key: string) => `${ws}/space/${encode(key)}/issues`,
+    spaceProjects: (key: string) => `${ws}/space/${encode(key)}/projects`,
+    spaceAutopilots: (key: string) => `${ws}/space/${encode(key)}/autopilots`,
+    spaceDetail: (key: string) => `${ws}/space/${encode(key)}`,
+    // Static sibling of spaceDetail — "new" is a reserved space key
+    // (RESERVED_SPACE_KEYS) precisely so it can never collide with this route.
+    spaceNew: () => `${ws}/space/new`,
     projects: () => `${ws}/projects`,
     projectDetail: (id: string) => `${ws}/projects/${encode(id)}`,
     autopilots: () => `${ws}/autopilots`,
diff --git a/packages/core/paths/reserved-slugs.ts b/packages/core/paths/reserved-slugs.ts
index efafda502b..44b64076ed 100644
--- a/packages/core/paths/reserved-slugs.ts
+++ b/packages/core/paths/reserved-slugs.ts
@@ -11,7 +11,7 @@
  *
  * Convention for new global routes (CLAUDE.md): use a single word
  * (`/login`, `/inbox`) or `/{noun}/{verb}` (`/workspaces/new`). Hyphenated
- * root-level word groups (`/new-workspace`, `/create-team`) collide with
+ * root-level word groups (`/new-workspace`, `/create-space`) collide with
  * common user workspace names — see PR for full discussion.
  */
 export const RESERVED_SLUGS: ReadonlySet<string> = new Set([
@@ -76,7 +76,7 @@ export const RESERVED_SLUGS: ReadonlySet<string> = new Set([
   // Reserving each segment name prevents `/{slug}/{view}` from being visually
   // ambiguous (e.g. a workspace named `issues` would make `/issues/abc` mean two
   // things). `workspaces` covers the global `/workspaces/new` workspace-creation
-  // page; `teams` is reserved for future team management.
+  // page; `spaces` is reserved for future space management.
   "issues",
   "projects",
   "autopilots",
@@ -89,7 +89,8 @@ export const RESERVED_SLUGS: ReadonlySet<string> = new Set([
   "skills",
   "settings",
   "workspaces",
-  "teams",
+  "spaces",
+  "space",
 
   // API / integration prefixes
   // `api` above already covers `/api/*`; these guard against future top-level
diff --git a/packages/core/permissions/index.ts b/packages/core/permissions/index.ts
index 4091d8ed1a..03745bf297 100644
--- a/packages/core/permissions/index.ts
+++ b/packages/core/permissions/index.ts
@@ -18,3 +18,5 @@ export {
   useAgentPermissions,
   useSkillPermissions,
 } from "./use-resource-permissions";
+
+export { useCurrentMember } from "./use-current-member";
diff --git a/packages/core/realtime/use-realtime-sync.ts b/packages/core/realtime/use-realtime-sync.ts
index 3f6a3733f1..25e767fc96 100644
--- a/packages/core/realtime/use-realtime-sync.ts
+++ b/packages/core/realtime/use-realtime-sync.ts
@@ -11,6 +11,7 @@ import { defaultStorage } from "../platform/storage";
 import { getCurrentWsId, getCurrentSlug } from "../platform/workspace-storage";
 import { issueKeys } from "../issues/queries";
 import { projectKeys } from "../projects/queries";
+import { spaceKeys } from "../spaces/queries";
 import { pinKeys } from "../pins/queries";
 import { autopilotKeys } from "../autopilots/queries";
 import { runtimeKeys } from "../runtimes/queries";
@@ -196,6 +197,22 @@ export function applyWorkspaceUpdatedToCache(
   qc: QueryClient,
   payload: WorkspaceUpdatedPayload,
 ): void {
+  // Space create/update/archive rides the same `workspace:updated` channel but
+  // carries a `space` instead of a `workspace`. The global query client uses
+  // staleTime: Infinity, so without an explicit invalidation other clients
+  // never refetch the space list. Archiving a space also shifts issue
+  // identifiers/filters, so mirror the space mutations' onSettled issue-key
+  // invalidation here.
+  const space = payload.space;
+  if (space?.workspace_id) {
+    qc.invalidateQueries({ queryKey: spaceKeys.list(space.workspace_id) });
+    qc.invalidateQueries({ queryKey: issueKeys.all(space.workspace_id) });
+    // Mirror useArchiveSpace.onSettled: projects carry space_ids, autopilots
+    // carry space_id, and both group under spaces in the sidebar — an archive
+    // or rename on another client must refresh them too.
+    qc.invalidateQueries({ queryKey: projectKeys.all(space.workspace_id) });
+    qc.invalidateQueries({ queryKey: autopilotKeys.all(space.workspace_id) });
+  }
   const next = payload.workspace;
   if (next?.id) {
     const cached =
@@ -637,6 +654,7 @@ export function useRealtimeSync(
           assigneeChanged: payload.assignee_changed,
           statusChanged: payload.status_changed,
           projectChanged: payload.project_changed,
+          spaceChanged: payload.space_changed,
         });
         if (issue.status) {
           onInboxIssueStatusChanged(qc, wsId, issue.id, issue.status);
diff --git a/packages/core/spaces/default-space.test.ts b/packages/core/spaces/default-space.test.ts
new file mode 100644
index 0000000000..7347de54b2
--- /dev/null
+++ b/packages/core/spaces/default-space.test.ts
@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import type { Space } from "../types";
+import { creationDefaultSpaceId, resolveCreationSpaceId } from "./default-space";
+
+function space(overrides: Partial<Space>): Space {
+  return {
+    id: "space-id",
+    workspace_id: "ws-1",
+    name: "Space",
+    key: "SPC",
+    description: "",
+    icon: null,
+    issue_counter: 0,
+    archived_at: null,
+    created_by: null,
+    created_at: "2026-01-01T00:00:00Z",
+    updated_at: "2026-01-01T00:00:00Z",
+    is_member: false,
+    sort_order: 0,
+    ...overrides,
+  };
+}
+
+describe("creationDefaultSpaceId", () => {
+  it("prefers the first space in the user's personal sort order", () => {
+    const spaces = [
+      space({ id: "a", is_member: true, sort_order: 2 }),
+      space({ id: "b", is_member: true, sort_order: 1 }),
+      space({ id: "c", is_member: false, created_at: "2020-01-01T00:00:00Z" }),
+    ];
+    expect(creationDefaultSpaceId(spaces)).toBe("b");
+  });
+
+  it("falls back to the earliest-created active space when the user has no membership rows", () => {
+    const spaces = [
+      space({ id: "newer", is_member: false, created_at: "2026-02-01T00:00:00Z" }),
+      space({ id: "older", is_member: false, created_at: "2026-01-01T00:00:00Z" }),
+    ];
+    expect(creationDefaultSpaceId(spaces)).toBe("older");
+  });
+
+  it("ignores archived spaces in both the personal and earliest-created fallbacks", () => {
+    const spaces = [
+      space({ id: "archived-mine", is_member: true, sort_order: 0, archived_at: "2026-01-01T00:00:00Z" }),
+      space({ id: "archived-oldest", created_at: "2020-01-01T00:00:00Z", archived_at: "2026-01-01T00:00:00Z" }),
+      space({ id: "active", created_at: "2026-01-02T00:00:00Z" }),
+    ];
+    expect(creationDefaultSpaceId(spaces)).toBe("active");
+  });
+
+  it("returns undefined when there are no active spaces", () => {
+    expect(creationDefaultSpaceId([])).toBeUndefined();
+  });
+});
+
+describe("resolveCreationSpaceId", () => {
+  const spaces = [space({ id: "fallback", created_at: "2026-01-01T00:00:00Z" })];
+
+  it("prioritizes structural context over the creation default", () => {
+    expect(
+      resolveCreationSpaceId(spaces, {
+        parentSpaceId: "parent",
+        projectSpaceId: "project",
+        lastSpaceId: "last",
+      }),
+    ).toBe("parent");
+    expect(resolveCreationSpaceId(spaces, { projectSpaceId: "project", lastSpaceId: "last" })).toBe(
+      "project",
+    );
+    expect(resolveCreationSpaceId(spaces, { lastSpaceId: "last" })).toBe("last");
+  });
+
+  it("falls through to the creation default when no context applies", () => {
+    expect(resolveCreationSpaceId(spaces, {})).toBe("fallback");
+  });
+});
diff --git a/packages/core/spaces/default-space.ts b/packages/core/spaces/default-space.ts
new file mode 100644
index 0000000000..9d06db0eb0
--- /dev/null
+++ b/packages/core/spaces/default-space.ts
@@ -0,0 +1,47 @@
+import type { Space } from "../types";
+
+/**
+ * The space a new issue defaults into when no other context (route, parent,
+ * single-space project) applies: the first space in the user's personal order.
+ * Falls back to the workspace's earliest-created active space for users whose
+ * membership rows predate the membership rollout — no space is flagged
+ * "default"; the earliest one is the same one the server resolves to when a
+ * create request omits space_id (see GetDefaultWorkspaceSpace).
+ */
+export function creationDefaultSpaceId(spaces: Space[]): string | undefined {
+  const active = spaces.filter((space) => !space.archived_at);
+  const mine = active
+    .filter((space) => space.is_member)
+    .sort((a, b) => a.sort_order - b.sort_order);
+  const earliest = [...active].sort(
+    (a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime(),
+  )[0];
+  return (mine[0] ?? earliest)?.id;
+}
+
+/**
+ * Single fallback chain for "which space does this new issue/project/autopilot
+ * belong to", shared by every creation surface. Callers pass whichever
+ * signals apply to them (e.g. only issue creation has a parent to inherit
+ * from) and leave the rest undefined.
+ *
+ * Priority: structural inheritance (parent issue's space) > single-space
+ * project inference > the space the user last created something in >
+ * personal static default (first space in my sort order).
+ *
+ * Explicit picks and view/route context (e.g. a space's own Issues page)
+ * are NOT part of this chain — callers seed their own local `spaceId` state
+ * from those directly and only fall through to this resolver while that
+ * state is still unset.
+ */
+export function resolveCreationSpaceId(
+  spaces: Space[],
+  ctx: { parentSpaceId?: string; projectSpaceId?: string; lastSpaceId?: string | null },
+): string | undefined {
+  return (
+    ctx.parentSpaceId ??
+    ctx.projectSpaceId ??
+    ctx.lastSpaceId ??
+    creationDefaultSpaceId(spaces)
+  );
+}
diff --git a/packages/core/spaces/index.ts b/packages/core/spaces/index.ts
new file mode 100644
index 0000000000..bccc7a1305
--- /dev/null
+++ b/packages/core/spaces/index.ts
@@ -0,0 +1,17 @@
+export {
+  spaceKeys,
+  spaceListOptions,
+  activeSpaceListOptions,
+  mySpaceListOptions,
+  spaceMembersOptions,
+  sortSpacesForDisplay,
+} from "./queries";
+export {
+  useCreateSpace,
+  useUpdateSpace,
+  useArchiveSpace,
+  useUpdateSpaceMembership,
+  useReplaceSpaceMembers,
+} from "./mutations";
+export { creationDefaultSpaceId, resolveCreationSpaceId } from "./default-space";
+export { useLastSpaceStore } from "./last-space-store";
diff --git a/packages/core/spaces/last-space-store.ts b/packages/core/spaces/last-space-store.ts
new file mode 100644
index 0000000000..09d88821ca
--- /dev/null
+++ b/packages/core/spaces/last-space-store.ts
@@ -0,0 +1,32 @@
+"use client";
+
+import { create } from "zustand";
+import { createJSONStorage, persist } from "zustand/middleware";
+import { createWorkspaceAwareStorage, registerForWorkspaceRehydration } from "../platform/workspace-storage";
+import { defaultStorage } from "../platform/storage";
+
+// Per-workspace memory of the last space the user created something in.
+// Shared by every creation surface (issue, quick-create, project, autopilot)
+// — users don't distinguish "last space for issues" from "last space for
+// projects", so one memory backs all of them. Only consulted as a fallback
+// when no stronger signal applies (view context, parent issue, single-space
+// project); see resolveCreationSpaceId in ./default-space.
+interface LastSpaceState {
+  lastSpaceId: string | null;
+  setLastSpaceId: (id: string | null) => void;
+}
+
+export const useLastSpaceStore = create<LastSpaceState>()(
+  persist(
+    (set) => ({
+      lastSpaceId: null,
+      setLastSpaceId: (id) => set({ lastSpaceId: id }),
+    }),
+    {
+      name: "multica_last_space",
+      storage: createJSONStorage(() => createWorkspaceAwareStorage(defaultStorage)),
+    },
+  ),
+);
+
+registerForWorkspaceRehydration(() => useLastSpaceStore.persist.rehydrate());
diff --git a/packages/core/spaces/mutations.ts b/packages/core/spaces/mutations.ts
new file mode 100644
index 0000000000..38c34925f8
--- /dev/null
+++ b/packages/core/spaces/mutations.ts
@@ -0,0 +1,135 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { api } from "../api";
+import { useWorkspaceId } from "../hooks";
+import { issueKeys } from "../issues/queries";
+import { projectKeys } from "../projects/queries";
+import { autopilotKeys } from "../autopilots/queries";
+import { spaceKeys } from "./queries";
+import type { CreateSpaceRequest, ListSpacesResponse, UpdateSpaceRequest } from "../types";
+
+export function useCreateSpace() {
+  const qc = useQueryClient();
+  const wsId = useWorkspaceId();
+  return useMutation({
+    mutationFn: (data: CreateSpaceRequest) => api.createSpace(data),
+    // Create stays onSuccess-append: there's no stable local id to seed an
+    // optimistic row, so we wait for the server-assigned space.
+    onSuccess: (space) => {
+      qc.setQueryData<ListSpacesResponse>(spaceKeys.list(wsId), (old) =>
+        old && !old.spaces.some((t) => t.id === space.id)
+          ? { ...old, spaces: [...old.spaces, space], total: old.total + 1 }
+          : old,
+      );
+    },
+    onSettled: () => {
+      qc.invalidateQueries({ queryKey: spaceKeys.all(wsId) });
+    },
+  });
+}
+
+export function useUpdateSpace() {
+  const qc = useQueryClient();
+  const wsId = useWorkspaceId();
+  return useMutation({
+    mutationFn: ({ id, ...data }: { id: string } & UpdateSpaceRequest) =>
+      api.updateSpace(id, data),
+    onMutate: async ({ id, ...data }) => {
+      await qc.cancelQueries({ queryKey: spaceKeys.list(wsId) });
+      const prevList = qc.getQueryData<ListSpacesResponse>(spaceKeys.list(wsId));
+      qc.setQueryData<ListSpacesResponse>(spaceKeys.list(wsId), (old) =>
+        old
+          ? { ...old, spaces: old.spaces.map((t) => (t.id === id ? { ...t, ...data } : t)) }
+          : old,
+      );
+      return { prevList };
+    },
+    onError: (_err, _vars, ctx) => {
+      if (ctx?.prevList) qc.setQueryData(spaceKeys.list(wsId), ctx.prevList);
+    },
+    onSettled: () => {
+      qc.invalidateQueries({ queryKey: spaceKeys.all(wsId) });
+      // A key change re-derives every issue identifier under the space.
+      qc.invalidateQueries({ queryKey: issueKeys.all(wsId) });
+    },
+  });
+}
+
+export function useUpdateSpaceMembership() {
+  const qc = useQueryClient();
+  const wsId = useWorkspaceId();
+  return useMutation({
+    mutationFn: ({ id, sort_order }: { id: string; sort_order: number }) =>
+      api.updateSpaceMembership(id, { sort_order }),
+    // Optimistic: sidebar ordering must not snap back while the PATCH is in
+    // flight. Fractional sort keys mean only the dragged space's row changes.
+    onMutate: async ({ id, sort_order }) => {
+      await qc.cancelQueries({ queryKey: spaceKeys.list(wsId) });
+      const prevList = qc.getQueryData<ListSpacesResponse>(spaceKeys.list(wsId));
+      qc.setQueryData<ListSpacesResponse>(spaceKeys.list(wsId), (old) =>
+        old
+          ? {
+              ...old,
+              spaces: old.spaces.map((t) => (t.id === id ? { ...t, sort_order } : t)),
+            }
+          : old,
+      );
+      return { prevList };
+    },
+    onError: (_err, _vars, ctx) => {
+      if (ctx?.prevList) qc.setQueryData(spaceKeys.list(wsId), ctx.prevList);
+    },
+    onSettled: () => {
+      qc.invalidateQueries({ queryKey: spaceKeys.all(wsId) });
+    },
+  });
+}
+
+export function useReplaceSpaceMembers() {
+  const qc = useQueryClient();
+  const wsId = useWorkspaceId();
+  return useMutation({
+    mutationFn: ({ id, member_ids }: { id: string; member_ids: string[] }) =>
+      api.replaceSpaceMembers(id, member_ids),
+    // No optimistic patch: the config panel closes on save, and the
+    // caller's own is_member may flip (they can add/remove themselves), so
+    // one settled invalidation of the list + members caches is the simplest
+    // correct reconcile.
+    onSettled: (_data, _err, { id }) => {
+      qc.invalidateQueries({ queryKey: spaceKeys.all(wsId) });
+      qc.invalidateQueries({ queryKey: spaceKeys.members(wsId, id) });
+    },
+  });
+}
+
+export function useArchiveSpace() {
+  const qc = useQueryClient();
+  const wsId = useWorkspaceId();
+  return useMutation({
+    mutationFn: (id: string) => api.archiveSpace(id),
+    onMutate: async (id) => {
+      await qc.cancelQueries({ queryKey: spaceKeys.list(wsId) });
+      const prevList = qc.getQueryData<ListSpacesResponse>(spaceKeys.list(wsId));
+      const archivedAt = new Date().toISOString();
+      qc.setQueryData<ListSpacesResponse>(spaceKeys.list(wsId), (old) =>
+        old
+          ? {
+              ...old,
+              spaces: old.spaces.map((t) =>
+                t.id === id ? { ...t, archived_at: archivedAt } : t,
+              ),
+            }
+          : old,
+      );
+      return { prevList };
+    },
+    onError: (_err, _id, ctx) => {
+      if (ctx?.prevList) qc.setQueryData(spaceKeys.list(wsId), ctx.prevList);
+    },
+    onSettled: () => {
+      qc.invalidateQueries({ queryKey: spaceKeys.all(wsId) });
+      qc.invalidateQueries({ queryKey: issueKeys.all(wsId) });
+      qc.invalidateQueries({ queryKey: projectKeys.all(wsId) });
+      qc.invalidateQueries({ queryKey: autopilotKeys.all(wsId) });
+    },
+  });
+}
diff --git a/packages/core/spaces/queries.ts b/packages/core/spaces/queries.ts
new file mode 100644
index 0000000000..46436cfd37
--- /dev/null
+++ b/packages/core/spaces/queries.ts
@@ -0,0 +1,67 @@
+import { queryOptions } from "@tanstack/react-query";
+import { api } from "../api";
+import type { Space } from "../types";
+
+// Canonical presentation order for space lists shown to a user: joined spaces
+// first in the personal drag order (mirroring the sidebar's Spaces section),
+// then non-joined spaces alphabetically. Pickers and filters share this so
+// every space list a user sees is ordered the same way.
+export function sortSpacesForDisplay(spaces: Space[]): Space[] {
+  const mine = spaces
+    .filter((space) => space.is_member)
+    .sort((a, b) => a.sort_order - b.sort_order);
+  const others = spaces
+    .filter((space) => !space.is_member)
+    .sort((a, b) => a.name.localeCompare(b.name));
+  return [...mine, ...others];
+}
+
+export const spaceKeys = {
+  all: (wsId: string) => ["spaces", wsId] as const,
+  list: (wsId: string) => [...spaceKeys.all(wsId), "list"] as const,
+  members: (wsId: string, spaceId: string) =>
+    [...spaceKeys.all(wsId), "members", spaceId] as const,
+};
+
+export function spaceListOptions(wsId: string) {
+  return queryOptions({
+    queryKey: spaceKeys.list(wsId),
+    queryFn: () => api.listSpaces(),
+    select: (data) => data.spaces,
+  });
+}
+
+export function activeSpaceListOptions(wsId: string) {
+  // Shares spaceListOptions' query key (and fetch/cache) — the active/archived
+  // distinction is a per-observer `select`, not a separate cache entry, so
+  // mutation cache patches on the base key are reflected here too. Sorted
+  // with sortSpacesForDisplay so pickers match the sidebar's personal order.
+  return queryOptions({
+    queryKey: spaceKeys.list(wsId),
+    queryFn: () => api.listSpaces(),
+    select: (data) =>
+      sortSpacesForDisplay(data.spaces.filter((space) => !space.archived_at)),
+  });
+}
+
+export function spaceMembersOptions(wsId: string, spaceId: string) {
+  return queryOptions({
+    queryKey: spaceKeys.members(wsId, spaceId),
+    queryFn: () => api.listSpaceMembers(spaceId),
+    select: (data) => data.members,
+  });
+}
+
+export function mySpaceListOptions(wsId: string) {
+  // The sidebar's Spaces section: only spaces the user joined, in their
+  // personal order. Same cache entry as spaceListOptions (per-observer
+  // select), so reorder patches on the base key reflect here instantly.
+  return queryOptions({
+    queryKey: spaceKeys.list(wsId),
+    queryFn: () => api.listSpaces(),
+    select: (data) =>
+      data.spaces
+        .filter((space) => space.is_member && !space.archived_at)
+        .sort((a, b) => a.sort_order - b.sort_order),
+  });
+}
diff --git a/packages/core/types/api.ts b/packages/core/types/api.ts
index 001c75e218..54834c573a 100644
--- a/packages/core/types/api.ts
+++ b/packages/core/types/api.ts
@@ -11,6 +11,7 @@ export interface CreateIssueRequest {
   assignee_type?: IssueAssigneeType;
   assignee_id?: string;
   parent_issue_id?: string;
+  space_id?: string;
   project_id?: string;
   /** Ordered stage (>= 1) grouping this sub-issue under its parent. */
   stage?: number;
@@ -31,6 +32,10 @@ export interface UpdateIssueRequest {
   due_date?: string | null;
   parent_issue_id?: string | null;
   project_id?: string | null;
+  /** Move the issue to another space. Numbers are per-space, so the move
+   *  renumbers the issue server-side (the old identifier keeps resolving
+   *  via an alias); never null — every issue belongs to exactly one space. */
+  space_id?: string;
   /** Ordered stage (>= 1); null clears it (unstaged). */
   stage?: number | null;
   /** Attachment IDs to bind to this issue alongside the description update.
@@ -88,6 +93,7 @@ export interface ListIssuesParams {
    */
   assignee_types?: IssueAssigneeType[];
   creator_id?: string;
+  space_id?: string;
   project_id?: string;
   /**
    * Widen the assignee filter to issues where the user is the *indirect*
@@ -131,6 +137,7 @@ export interface ListGroupedIssuesParams {
   assignee_id?: string;
   assignee_ids?: string[];
   creator_id?: string;
+  space_id?: string;
   project_id?: string;
   /** See `ListIssuesParams.involves_user_id` — same semantics. */
   involves_user_id?: string;
diff --git a/packages/core/types/autopilot.ts b/packages/core/types/autopilot.ts
index 0d52bdbb47..67a140142f 100644
--- a/packages/core/types/autopilot.ts
+++ b/packages/core/types/autopilot.ts
@@ -29,6 +29,7 @@ export interface Autopilot {
   title: string;
   description: string | null;
   project_id?: string | null;
+  space_id?: string | null;
   assignee_type: AutopilotAssigneeType;
   assignee_id: string;
   status: AutopilotStatus;
@@ -136,6 +137,7 @@ export interface CreateAutopilotRequest {
   title: string;
   description?: string;
   project_id?: string | null;
+  space_id?: string | null;
   // Optional on the wire — when omitted the server defaults to "agent" so
   // older clients keep working.
   assignee_type?: AutopilotAssigneeType;
@@ -149,6 +151,7 @@ export interface UpdateAutopilotRequest {
   title?: string;
   description?: string | null;
   project_id?: string | null;
+  space_id?: string | null;
   // Send `assignee_type` together with `assignee_id` whenever you change the
   // assignee — the server requires both for a type swap.
   assignee_type?: AutopilotAssigneeType;
diff --git a/packages/core/types/events.ts b/packages/core/types/events.ts
index 34a05e6452..458ed8dc1b 100644
--- a/packages/core/types/events.ts
+++ b/packages/core/types/events.ts
@@ -5,6 +5,7 @@ import type { Comment, Reaction } from "./comment";
 import type { TimelineEntry } from "./activity";
 import type { Workspace, MemberWithUser, Invitation } from "./workspace";
 import type { Project } from "./project";
+import type { Space } from "./space";
 import type { Label } from "./label";
 
 // WebSocket event types (matching Go server protocol/events.go)
@@ -106,6 +107,10 @@ export interface IssueUpdatedPayload {
   assignee_changed?: boolean;
   status_changed?: boolean;
   project_changed?: boolean;
+  // Moving an issue between spaces renumbers it and moves it across
+  // space-filtered lists; the flag drives the same membership reconcile as
+  // project_changed.
+  space_changed?: boolean;
 }
 
 export interface IssueDeletedPayload {
@@ -184,7 +189,10 @@ export interface CommentUnresolvedPayload {
 }
 
 export interface WorkspaceUpdatedPayload {
-  workspace: Workspace;
+  workspace?: Workspace;
+  // Space create/update/archive is broadcast on the same channel; the payload
+  // carries the affected space instead of the workspace in that case.
+  space?: Space;
 }
 
 export interface WorkspaceDeletedPayload {
diff --git a/packages/core/types/index.ts b/packages/core/types/index.ts
index ea56f8c08c..8c482b8970 100644
--- a/packages/core/types/index.ts
+++ b/packages/core/types/index.ts
@@ -64,6 +64,7 @@ export type {
 } from "./agent";
 export { RUNTIME_PROFILE_PROTOCOL_FAMILIES } from "./agent";
 export type { Workspace, WorkspaceRepo, Member, MemberRole, User, MemberWithUser, Invitation } from "./workspace";
+export type { Space, CreateSpaceRequest, UpdateSpaceRequest, ListSpacesResponse, SpaceMembership, SpaceMember, ListSpaceMembersResponse } from "./space";
 export type { InboxItem, InboxSeverity, InboxItemType, InboxWorkspaceUnread } from "./inbox";
 export type { NotificationGroupKey, NotificationGroupValue, NotificationPreferences, NotificationPreferenceResponse } from "./notification-preference";
 export type { Comment, CommentType, CommentAuthorType, CommentTriggerPreview, CommentTriggerPreviewAgent, CommentTriggerSource, Reaction } from "./comment";
diff --git a/packages/core/types/issue.ts b/packages/core/types/issue.ts
index adc857aa5f..c922c17a89 100644
--- a/packages/core/types/issue.ts
+++ b/packages/core/types/issue.ts
@@ -35,6 +35,9 @@ export type IssueMetadata = Record<string, IssueMetadataValue>;
 export interface Issue {
   id: string;
   workspace_id: string;
+  space_id?: string | null;
+  space_key?: string | null;
+  space_name?: string | null;
   number: number;
   identifier: string;
   title: string;
diff --git a/packages/core/types/project.ts b/packages/core/types/project.ts
index 333d094826..0be8f704b3 100644
--- a/packages/core/types/project.ts
+++ b/packages/core/types/project.ts
@@ -17,6 +17,7 @@ export interface Project {
   issue_count: number;
   done_count: number;
   resource_count: number;
+  space_ids?: string[];
 }
 
 export interface CreateProjectRequest {
@@ -27,6 +28,7 @@ export interface CreateProjectRequest {
   priority?: ProjectPriority;
   lead_type?: "member" | "agent";
   lead_id?: string;
+  space_ids?: string[];
   // Resources to attach in the same transaction as the project. Server returns
   // 4xx (and rolls back) if any one is invalid or duplicate.
   resources?: CreateProjectResourceRequest[];
@@ -40,6 +42,7 @@ export interface UpdateProjectRequest {
   priority?: ProjectPriority;
   lead_type?: "member" | "agent" | null;
   lead_id?: string | null;
+  space_ids?: string[];
 }
 
 export interface ListProjectsResponse {
diff --git a/packages/core/types/space.ts b/packages/core/types/space.ts
new file mode 100644
index 0000000000..a5b32b6e8c
--- /dev/null
+++ b/packages/core/types/space.ts
@@ -0,0 +1,60 @@
+export interface Space {
+  id: string;
+  workspace_id: string;
+  name: string;
+  key: string;
+  description: string;
+  icon: string | null;
+  issue_counter: number;
+  archived_at: string | null;
+  created_by: string | null;
+  created_at: string;
+  updated_at: string;
+  /** Requesting user's membership view — the sidebar shows only joined
+   *  spaces, ordered by sort_order (per-user fractional position). */
+  is_member: boolean;
+  sort_order: number;
+}
+
+export interface CreateSpaceRequest {
+  name: string;
+  key: string;
+  description?: string;
+  icon?: string | null;
+  /** Workspace members invited alongside the creator (who joins as lead). */
+  member_ids?: string[];
+}
+
+export interface UpdateSpaceRequest {
+  name?: string;
+  key?: string;
+  description?: string;
+  icon?: string | null;
+}
+
+export interface ListSpacesResponse {
+  spaces: Space[];
+  total: number;
+}
+
+/** Caller's own membership row, as returned by PATCH /api/spaces/{id}/membership. */
+export interface SpaceMembership {
+  space_id: string;
+  sort_order: number;
+}
+
+/** A space member with user display data (GET /api/spaces/{id}/members). */
+export interface SpaceMember {
+  user_id: string;
+  name: string;
+  email: string;
+  avatar_url: string | null;
+  /** "lead" | "member" — informational in v1, no privileges attached. */
+  role: string;
+  created_at: string;
+}
+
+export interface ListSpaceMembersResponse {
+  members: SpaceMember[];
+  total: number;
+}
diff --git a/packages/core/workspace/index.ts b/packages/core/workspace/index.ts
index 4e9f5df488..ecd9138ebd 100644
--- a/packages/core/workspace/index.ts
+++ b/packages/core/workspace/index.ts
@@ -1,3 +1,4 @@
 export * from "./queries";
 export * from "./mutations";
 export * from "./hooks";
+export * from "./space-key";
diff --git a/packages/core/workspace/mutations.ts b/packages/core/workspace/mutations.ts
index 84487d4572..501b8e7812 100644
--- a/packages/core/workspace/mutations.ts
+++ b/packages/core/workspace/mutations.ts
@@ -12,7 +12,12 @@ import {
 export function useCreateWorkspace() {
   const qc = useQueryClient();
   return useMutation({
-    mutationFn: (data: { name: string; slug: string; description?: string }) =>
+    mutationFn: (data: {
+      name: string;
+      slug: string;
+      description?: string;
+      context?: string;
+    }) =>
       api.createWorkspace(data),
     // Seed the workspace list cache BEFORE callers navigate to /{newWs.slug}/issues.
     // The destination [workspaceSlug]/layout queries by slug from this cache;
diff --git a/packages/core/workspace/space-key.ts b/packages/core/workspace/space-key.ts
new file mode 100644
index 0000000000..d17aad9c49
--- /dev/null
+++ b/packages/core/workspace/space-key.ts
@@ -0,0 +1,25 @@
+export const SPACE_KEY_REGEX = /^[A-Z][A-Z0-9]{0,6}$/;
+
+// Mirrors reservedSpaceKeys in server/internal/handler/workspace.go: keys
+// that would collide with a static route under /space/{key} (e.g. the
+// create-space page at /space/new).
+export const RESERVED_SPACE_KEYS = new Set(["NEW"]);
+
+// Mirrors the server-side normalizeSpaceKey (handler/workspace.go) and the
+// migration backfill: uppercase, strip characters outside [A-Z0-9], truncate
+// to 7, and prefix digit-leading keys with "T".
+export function normalizeSpaceKey(value: string): string {
+  let key = value
+    .trim()
+    .toUpperCase()
+    .replace(/[^A-Z0-9]/g, "")
+    .slice(0, 7);
+  if (/^[0-9]/.test(key)) {
+    key = `T${key}`.slice(0, 7);
+  }
+  return key;
+}
+
+export function isValidSpaceKey(key: string): boolean {
+  return SPACE_KEY_REGEX.test(key) && !RESERVED_SPACE_KEYS.has(key);
+}
diff --git a/packages/ui/components/common/plain-text-field.tsx b/packages/ui/components/common/plain-text-field.tsx
new file mode 100644
index 0000000000..5f43e381ed
--- /dev/null
+++ b/packages/ui/components/common/plain-text-field.tsx
@@ -0,0 +1,72 @@
+"use client";
+
+import * as React from "react";
+import { cn } from "../../lib/utils";
+import { Textarea } from "../ui/textarea";
+
+interface PlainTextFieldProps {
+  defaultValue: string;
+  /** Called on blur when the trimmed value changed and is within the limit. */
+  onCommit: (value: string) => void;
+  placeholder?: string;
+  /** Soft limit: typing past it is allowed but shows the hint and blocks commit. */
+  maxLength?: number;
+  /** Over-limit hint line; caller supplies the localized text. */
+  limitHint?: (count: number, max: number) => string;
+  className?: string;
+  id?: string;
+  "aria-label"?: string;
+}
+
+/**
+ * Not an editor — a borderless plain-text area that reads as page text until
+ * clicked (Linear's "Add a description…" pattern). Single line at rest,
+ * auto-grows with content. Commits on blur, restores on Escape. Re-seed by
+ * changing the React `key` when the upstream value changes.
+ */
+function PlainTextField({
+  defaultValue,
+  onCommit,
+  placeholder,
+  maxLength = 255,
+  limitHint,
+  className,
+  ...props
+}: PlainTextFieldProps) {
+  const [value, setValue] = React.useState(defaultValue);
+  const over = value.length > maxLength;
+
+  return (
+    <div className="flex flex-col gap-1">
+      <Textarea
+        {...props}
+        value={value}
+        rows={1}
+        placeholder={placeholder}
+        onChange={(event) => setValue(event.target.value)}
+        onKeyDown={(event) => {
+          if (event.key === "Escape") {
+            setValue(defaultValue);
+            event.currentTarget.blur();
+          }
+        }}
+        onBlur={() => {
+          if (over) return; // keep the text and the hint; nothing is saved
+          const next = value.trim();
+          if (next !== defaultValue) onCommit(next);
+        }}
+        className={cn(
+          "min-h-8 resize-none rounded-none border-0 bg-transparent px-0 py-1 shadow-none focus-visible:ring-0 dark:bg-transparent",
+          className,
+        )}
+      />
+      {over && (
+        <p className="text-xs text-destructive">
+          {limitHint ? limitHint(value.length, maxLength) : `${value.length}/${maxLength}`}
+        </p>
+      )}
+    </div>
+  );
+}
+
+export { PlainTextField };
diff --git a/packages/ui/components/ui/list-grid.tsx b/packages/ui/components/ui/list-grid.tsx
index 46a9acf77d..b1c69a3925 100644
--- a/packages/ui/components/ui/list-grid.tsx
+++ b/packages/ui/components/ui/list-grid.tsx
@@ -53,7 +53,7 @@ function ListGridHeader({
     <div
       role="row"
       className={cn(
-        "group/header sticky top-0 z-10 col-span-full grid h-9 grid-cols-subgrid items-center bg-background after:pointer-events-none after:absolute after:inset-x-0 after:top-full after:h-3 after:bg-gradient-to-b after:from-background after:to-transparent",
+        "group/header sticky top-0 z-10 col-span-full grid h-9 grid-cols-subgrid items-center bg-background",
         className,
       )}
       {...props}
diff --git a/packages/views/autopilots/components/autopilot-detail-page.tsx b/packages/views/autopilots/components/autopilot-detail-page.tsx
index e65c8ba99a..9cb359905b 100644
--- a/packages/views/autopilots/components/autopilot-detail-page.tsx
+++ b/packages/views/autopilots/components/autopilot-detail-page.tsx
@@ -963,6 +963,7 @@ export function AutopilotDetailPage({ autopilotId }: { autopilotId: string }) {
             title: autopilot.title,
             description: autopilot.description ?? "",
             project_id: autopilot.project_id ?? null,
+            space_id: autopilot.space_id ?? null,
             assignee_type: autopilot.assignee_type,
             assignee_id: autopilot.assignee_id,
             execution_mode: autopilot.execution_mode as AutopilotExecutionMode,
diff --git a/packages/views/autopilots/components/autopilot-dialog.tsx b/packages/views/autopilots/components/autopilot-dialog.tsx
index 0b8781b081..3fb3188570 100644
--- a/packages/views/autopilots/components/autopilot-dialog.tsx
+++ b/packages/views/autopilots/components/autopilot-dialog.tsx
@@ -4,6 +4,7 @@ import { useEffect, useMemo, useRef, useState } from "react";
 import { useQuery } from "@tanstack/react-query";
 import { toast } from "sonner";
 import {
+  AlertTriangle,
   Check,
   ChevronDown,
   ChevronRight,
@@ -46,10 +47,12 @@ import {
 } from "@multica/ui/components/ui/select";
 import { TimeInput } from "@multica/ui/components/ui/time-input";
 import { TimezonePicker } from "./pickers/timezone-picker";
-import { useCurrentWorkspace } from "@multica/core/paths";
 import { useWorkspaceId } from "@multica/core/hooks";
 import { agentListOptions, squadListOptions } from "@multica/core/workspace/queries";
 import { projectListOptions } from "@multica/core/projects/queries";
+import { activeSpaceListOptions } from "@multica/core/spaces/queries";
+import { resolveCreationSpaceId } from "@multica/core/spaces/default-space";
+import { useLastSpaceStore } from "@multica/core/spaces/last-space-store";
 import {
   useCreateAutopilot,
   useCreateAutopilotTrigger,
@@ -66,8 +69,10 @@ import type {
 } from "@multica/core/types";
 import { TitleEditor, ContentEditor } from "../../editor";
 import { ActorAvatar } from "../../common/actor-avatar";
+import { PillButton } from "../../common/pill-button";
 import { ProjectPicker } from "../../projects/components/project-picker";
 import { ProjectIcon } from "../../projects/components/project-icon";
+import { SpacePicker } from "../../spaces/components/space-picker";
 import { AgentPicker, type AssigneeSelection } from "./pickers/agent-picker";
 import { SubscriberMultiSelect } from "./subscriber-multi-select";
 import { AutopilotAccessManager } from "./autopilot-access-manager";
@@ -92,6 +97,7 @@ export interface AutopilotInitial {
   title: string;
   description: string;
   project_id: string | null;
+  space_id: string | null;
   assignee_type: AutopilotAssigneeType;
   assignee_id: string;
   execution_mode: AutopilotExecutionMode;
@@ -278,11 +284,11 @@ function useNowTicker(intervalMs = 30_000): Date {
 export function AutopilotDialog(props: AutopilotDialogProps) {
   const { t } = useT("autopilots");
   const { open, onOpenChange } = props;
-  const workspaceName = useCurrentWorkspace()?.name;
   const wsId = useWorkspaceId();
   const { data: agents = [] } = useQuery(agentListOptions(wsId));
   const { data: squads = [] } = useQuery(squadListOptions(wsId));
   const { data: projects = [] } = useQuery(projectListOptions(wsId));
+  const { data: spaces = [] } = useQuery(activeSpaceListOptions(wsId));
   const [isExpanded, setIsExpanded] = useState(false);
 
   const isCreate = props.mode === "create";
@@ -293,6 +299,7 @@ export function AutopilotDialog(props: AutopilotDialogProps) {
   const [title, setTitle] = useState(initial.title ?? "");
   const [description, setDescription] = useState(initial.description ?? "");
   const [projectId, setProjectId] = useState<string | null>(initial.project_id ?? null);
+  const [spaceId, setSpaceId] = useState<string | null>(initial.space_id ?? null);
   const [assigneeType, setAssigneeType] = useState<AutopilotAssigneeType>(
     initial.assignee_type ?? "agent",
   );
@@ -364,6 +371,16 @@ export function AutopilotDialog(props: AutopilotDialogProps) {
     () => projects.find((project) => project.id === projectId) ?? null,
     [projects, projectId],
   );
+  // Space is required and always resolves to a value — same model as the
+  // issue modal. Associations are creation-time defaults, never constraints:
+  // explicit pick → single-space project → last used → the user's first space.
+  // The picker is never restricted to the project's space set.
+  const lastSpaceId = useLastSpaceStore((s) => s.lastSpaceId);
+  const setLastSpaceId = useLastSpaceStore((s) => s.setLastSpaceId);
+  const projectSpaceId =
+    selectedProject?.space_ids?.length === 1 ? selectedProject.space_ids[0] : undefined;
+  const effectiveSpaceId =
+    spaceId ?? resolveCreationSpaceId(spaces, { projectSpaceId, lastSpaceId }) ?? null;
 
   const handleAssigneeChange = (next: AssigneeSelection) => {
     setAssigneeType(next.type);
@@ -394,6 +411,7 @@ export function AutopilotDialog(props: AutopilotDialogProps) {
           title: title.trim(),
           description: description.trim() || undefined,
           project_id: executionMode === "create_issue" ? projectId : null,
+          space_id: effectiveSpaceId,
           assignee_type: assigneeType,
           assignee_id: assigneeId,
           execution_mode: executionMode,
@@ -402,6 +420,7 @@ export function AutopilotDialog(props: AutopilotDialogProps) {
             user_id,
           })),
         });
+        setLastSpaceId(effectiveSpaceId);
         let triggerOk = true;
         let triggerErrMessage: string | null = null;
         let webhookTrigger: AutopilotTrigger | null = null;
@@ -447,6 +466,7 @@ export function AutopilotDialog(props: AutopilotDialogProps) {
           title: title.trim(),
           description: description.trim() || null,
           project_id: executionMode === "create_issue" ? projectId : null,
+          space_id: effectiveSpaceId,
           assignee_type: assigneeType,
           assignee_id: assigneeId,
           execution_mode: executionMode,
@@ -548,6 +568,16 @@ export function AutopilotDialog(props: AutopilotDialogProps) {
         {/* Header */}
         <div className="flex items-center justify-between px-5 pt-3 pb-2 shrink-0 border-b">
           <div className="flex items-center gap-2 text-xs">
+            {/* Owning space leads the breadcrumb — same grammar as the
+                issue/project modals: [space] › action. Required single-select,
+                seeded from context, switchable. */}
+            <SpacePicker
+              spaceId={effectiveSpaceId}
+              onChange={setSpaceId}
+              triggerRender={<PillButton />}
+              align="start"
+            />
+            <ChevronRight className="size-3 text-muted-foreground/40" />
             <div className="flex items-center gap-1.5">
               <span className="inline-flex size-5 items-center justify-center rounded-md bg-primary/15 text-primary">
                 <Rocket className="size-3" />
@@ -560,12 +590,6 @@ export function AutopilotDialog(props: AutopilotDialogProps) {
             </div>
             <span className="text-muted-foreground/60">·</span>
             <span className="text-muted-foreground">{t(($) => $.dialog.subtitle)}</span>
-            {workspaceName && (
-              <>
-                <ChevronRight className="size-3 text-muted-foreground/40" />
-                <span className="text-muted-foreground">{workspaceName}</span>
-              </>
-            )}
           </div>
           <div className="flex items-center gap-1">
             {!isCreate && props.canManageAccess && (
@@ -728,10 +752,24 @@ export function AutopilotDialog(props: AutopilotDialogProps) {
 
         {/* Footer */}
         <div className="flex items-center justify-between gap-3 px-5 py-3 border-t shrink-0 bg-background">
-          <div className="flex items-center gap-1.5 text-xs text-muted-foreground min-w-0">
-            <Zap className="size-3.5 text-amber-500 shrink-0" />
-            <span className="truncate">{t(($) => $.dialog.auto_run_hint)}</span>
-          </div>
+          {/* Left slot: blocking-validation warnings take precedence over the
+              ambient auto-run hint — one message at a time, in the order the
+              form asks for them (title, then assignee). */}
+          {title.trim().length === 0 || assigneeId.length === 0 ? (
+            <div className="flex items-center gap-1.5 text-xs text-destructive min-w-0">
+              <AlertTriangle className="size-3.5 shrink-0" />
+              <span className="truncate">
+                {title.trim().length === 0
+                  ? t(($) => $.dialog.title_required)
+                  : t(($) => $.dialog.assignee_required)}
+              </span>
+            </div>
+          ) : (
+            <div className="flex items-center gap-1.5 text-xs text-muted-foreground min-w-0">
+              <Zap className="size-3.5 text-amber-500 shrink-0" />
+              <span className="truncate">{t(($) => $.dialog.auto_run_hint)}</span>
+            </div>
+          )}
           <div className="flex items-center gap-2 shrink-0">
             <Button size="sm" variant="outline" onClick={() => onOpenChange(false)}>
               {t(($) => $.dialog.cancel)}
diff --git a/packages/views/autopilots/components/autopilots-page.tsx b/packages/views/autopilots/components/autopilots-page.tsx
index 3ff3f789f3..18be4cb66c 100644
--- a/packages/views/autopilots/components/autopilots-page.tsx
+++ b/packages/views/autopilots/components/autopilots-page.tsx
@@ -139,7 +139,7 @@ const TEMPLATES: AutopilotTemplate[] = [
   {
     id: "daily_news",
     prompt: `1. Search the web for news and announcements published today only (strictly today's date)
-2. Filter for topics relevant to our team and industry
+2. Filter for topics relevant to our space and industry
 3. For each item, write a short summary including: title, source, key takeaways
 4. Compile everything into a single digest post
 5. Post the digest as a comment on this issue and @mention all workspace members`,
@@ -153,7 +153,7 @@ const TEMPLATES: AutopilotTemplate[] = [
 2. Identify PRs that have been open for more than 24 hours without a review
 3. For each stale PR, note the author, age, and a one-line summary of the change
 4. Post a comment on this issue listing all stale PRs with links
-5. @mention the team to remind them to review`,
+5. @mention the space to remind them to review`,
     icon: GitPullRequest,
     frequency: "weekdays",
     time: "10:00",
@@ -597,17 +597,24 @@ function LoadingSkeleton() {
 // Page
 // ---------------------------------------------------------------------------
 
-export function AutopilotsPage() {
+// `spaceId` narrows the list to that space's autopilots — used by the space
+// surface pages (/space/:key/autopilots). Client-side filter over the shared
+// list cache.
+export function AutopilotsPage({ spaceId }: { spaceId?: string } = {}) {
   const { t } = useT("autopilots");
   const wsId = useWorkspaceId();
   const wsPaths = useWorkspacePaths();
   const rowLink = useRowLink();
   const {
-    data: autopilots = [],
+    data: allAutopilots = [],
     isLoading,
     error: listError,
     refetch: refetchList,
   } = useQuery(autopilotListOptions(wsId));
+  const autopilots = useMemo(
+    () => (spaceId ? allAutopilots.filter((a) => a.space_id === spaceId) : allAutopilots),
+    [allAutopilots, spaceId],
+  );
 
   const [createOpen, setCreateOpen] = useState(false);
   const [selectedTemplate, setSelectedTemplate] =
@@ -972,8 +979,11 @@ export function AutopilotsPage() {
           mode="create"
           open={createOpen}
           onOpenChange={setCreateOpen}
-          initial={
-            selectedTemplate
+          initial={{
+            // Opening from a space surface injects that space as the seed —
+            // the dialog itself stays the same everywhere (switchable).
+            ...(spaceId ? { space_id: spaceId } : {}),
+            ...(selectedTemplate
               ? {
                   // Template title pulls from i18n so the user-visible default
                   // matches their locale, while the prompt body stays raw EN
@@ -981,8 +991,8 @@ export function AutopilotsPage() {
                   title: t(($) => $.templates[selectedTemplate.id].title),
                   description: selectedTemplate.prompt,
                 }
-              : undefined
-          }
+              : {}),
+          }}
           initialTriggerConfig={
             selectedTemplate
               ? {
diff --git a/packages/views/editor/title-editor.tsx b/packages/views/editor/title-editor.tsx
index 2ba4a7eb07..219f885dc8 100644
--- a/packages/views/editor/title-editor.tsx
+++ b/packages/views/editor/title-editor.tsx
@@ -121,12 +121,14 @@ const TitleEditor = forwardRef<TitleEditorRef, TitleEditorProps>(
       },
     });
 
-    // Auto-focus after mount — delay to wait for Dialog open animation
+    // Auto-focus after mount — delayed past the Dialog open animation so the
+    // focus manager's initial-focus (first tabbable, e.g. a header pill)
+    // can't steal it back after we take it.
     useEffect(() => {
       if (autoFocus && editor) {
         const timer = setTimeout(() => {
           editor.commands.focus("end");
-        }, 50);
+        }, 180);
         return () => clearTimeout(timer);
       }
       return undefined;
diff --git a/packages/views/editor/utils/link-handler.ts b/packages/views/editor/utils/link-handler.ts
index 4f4e580283..6a851be391 100644
--- a/packages/views/editor/utils/link-handler.ts
+++ b/packages/views/editor/utils/link-handler.ts
@@ -28,6 +28,7 @@ const WORKSPACE_ROUTE_SEGMENTS = new Set([
   "my-issues",
   "runtimes",
   "skills",
+  "space",
   "settings",
 ]);
 
diff --git a/packages/views/i18n/resources-types.ts b/packages/views/i18n/resources-types.ts
index a7a87c2b5c..9e10c3688f 100644
--- a/packages/views/i18n/resources-types.ts
+++ b/packages/views/i18n/resources-types.ts
@@ -18,6 +18,7 @@ import type search from "../locales/en/search.json";
 import type inbox from "../locales/en/inbox.json";
 import type workspace from "../locales/en/workspace.json";
 import type projects from "../locales/en/projects.json";
+import type spaces from "../locales/en/spaces.json";
 import type autopilots from "../locales/en/autopilots.json";
 import type skills from "../locales/en/skills.json";
 import type chat from "../locales/en/chat.json";
@@ -59,6 +60,7 @@ declare global {
     inbox: typeof inbox;
     workspace: typeof workspace;
     projects: typeof projects;
+    spaces: typeof spaces;
     autopilots: typeof autopilots;
     skills: typeof skills;
     chat: typeof chat;
diff --git a/packages/views/issues/actions/__tests__/use-issue-actions.test.tsx b/packages/views/issues/actions/__tests__/use-issue-actions.test.tsx
index 536b5d719e..d08a7e7ebe 100644
--- a/packages/views/issues/actions/__tests__/use-issue-actions.test.tsx
+++ b/packages/views/issues/actions/__tests__/use-issue-actions.test.tsx
@@ -196,7 +196,7 @@ describe("useIssueActions", () => {
     });
 
     expect(navigator.clipboard.writeText).toHaveBeenCalledWith(
-      "https://app.multica.com/test/issues/issue-1",
+      "https://app.multica.com/test/issue/TES-1",
     );
   });
 
diff --git a/packages/views/issues/actions/issue-actions-menu-items.tsx b/packages/views/issues/actions/issue-actions-menu-items.tsx
index fe7a5396b6..e75e0ce326 100644
--- a/packages/views/issues/actions/issue-actions-menu-items.tsx
+++ b/packages/views/issues/actions/issue-actions-menu-items.tsx
@@ -143,6 +143,9 @@ export function IssueActionsMenuItems({
 
   return (
     <>
+      {/* Move-to-space was cut from v1's menus: the server/CLI capability
+          (renumber + identifier alias) stays, but the UI treats space as
+          creation-time-only until the product needs surfaced moves. */}
       {/* Status */}
       <P.Sub>
         <P.SubTrigger>
diff --git a/packages/views/issues/actions/use-issue-actions.ts b/packages/views/issues/actions/use-issue-actions.ts
index e443fc0ed2..60a37efeb9 100644
--- a/packages/views/issues/actions/use-issue-actions.ts
+++ b/packages/views/issues/actions/use-issue-actions.ts
@@ -120,13 +120,16 @@ export function useIssueActions(issue: Issue | null): UseIssueActionsResult {
 
   const copyLink = useCallback(async () => {
     if (!issueId) return;
-    const url = navigation.getShareableUrl(paths.issueDetail(issueId));
+    // Shared links are identifier-canonical (readable, and they survive a
+    // space move via the server-side identifier alias); internal navigation
+    // keeps passing UUIDs to the same route.
+    const url = navigation.getShareableUrl(paths.issueDetail(issue?.identifier || issueId));
     if (await copyText(url)) {
       toast.success(t(($) => $.detail.link_copied));
     } else {
       toast.error(t(($) => $.detail.link_copy_failed));
     }
-  }, [paths, issueId, navigation, t]);
+  }, [paths, issueId, issue?.identifier, navigation, t]);
 
   const openCreateSubIssue = useCallback(() => {
     if (!issueId) return;
diff --git a/packages/views/issues/components/issue-detail.test.tsx b/packages/views/issues/components/issue-detail.test.tsx
index e745941cb5..34fb03ff3c 100644
--- a/packages/views/issues/components/issue-detail.test.tsx
+++ b/packages/views/issues/components/issue-detail.test.tsx
@@ -575,7 +575,7 @@ describe("IssueDetail (shared)", () => {
     // single link to the issue's own detail route (used to open the full page
     // from the inline Inbox pane). A bare issue has no ancestor crumbs.
     const leaf = await screen.findByText("TES-1 Implement authentication");
-    expect(leaf.closest("a")).toHaveAttribute("href", "/test/issues/issue-1");
+    expect(leaf.closest("a")).toHaveAttribute("href", "/test/issue/issue-1");
   });
 
   it("omits the project breadcrumb segment when the issue has no project_id", async () => {
diff --git a/packages/views/issues/components/issue-detail.tsx b/packages/views/issues/components/issue-detail.tsx
index aa8a853f01..3d4a1fd39d 100644
--- a/packages/views/issues/components/issue-detail.tsx
+++ b/packages/views/issues/components/issue-detail.tsx
@@ -54,6 +54,7 @@ import { StatusIcon, PriorityIcon, StatusPicker, PriorityPicker, StagePicker, St
 import { maxSiblingStage } from "./pickers/stage-picker";
 import { IssueActionsDropdown, useIssueActions } from "../actions";
 import { ProjectPicker } from "../../projects/components/project-picker";
+import { SpacePicker } from "../../spaces/components/space-picker";
 import { LocalDirectoryHint } from "../../projects/components/local-directory-hint";
 import { CommentCard } from "./comment-card";
 import { CommentInput } from "./comment-input";
@@ -70,7 +71,10 @@ import { useActorName } from "@multica/core/workspace/hooks";
 import { useWorkspaceId } from "@multica/core/hooks";
 import { useRecentContextStore } from "@multica/core/chat";
 import { issueListOptions, issueDetailOptions, childIssuesOptions, issueUsageOptions, issueAttachmentsOptions } from "@multica/core/issues/queries";
-import { projectDetailOptions } from "@multica/core/projects/queries";
+import { projectDetailOptions, projectListOptions } from "@multica/core/projects/queries";
+import { activeSpaceListOptions } from "@multica/core/spaces/queries";
+import type { Space } from "@multica/core/types";
+import { SpaceProjectConflictDialog } from "../../spaces/components/space-project-conflict-dialog";
 import { ProjectIcon } from "../../projects/components/project-icon";
 import { issueLabelsOptions } from "@multica/core/labels";
 import { memberListOptions, agentListOptions } from "@multica/core/workspace/queries";
@@ -697,7 +701,98 @@ interface IssueDetailProps {
 // IssueDetail
 // ---------------------------------------------------------------------------
 
-export function IssueDetail({ issueId, onDelete, onDone, defaultSidebarOpen = true, layoutId = "multica_issue_detail_layout", highlightCommentId }: IssueDetailProps) {
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/**
+ * Shared loading placeholder: shown by the IssueDetail wrapper while
+ * resolving an identifier to a UUID, and by IssueDetailInner while fetching
+ * the resolved issue.
+ */
+function IssueDetailSkeleton() {
+  return (
+    <div className="flex flex-1 min-h-0 flex-col">
+      <div className="flex h-12 shrink-0 items-center gap-2 border-b px-4">
+        <Skeleton className="h-4 w-16" />
+        <Skeleton className="h-4 w-4" />
+        <Skeleton className="h-4 w-24" />
+      </div>
+      <div className="flex flex-1 min-h-0">
+        <div className="flex-1 overflow-y-auto">
+          <div className="mx-auto w-full max-w-4xl px-8 py-8 space-y-6">
+            <Skeleton className="h-8 w-3/4" />
+            <div className="space-y-2">
+              <Skeleton className="h-4 w-full" />
+              <Skeleton className="h-4 w-5/6" />
+              <Skeleton className="h-4 w-2/3" />
+            </div>
+            <Skeleton className="h-px w-full" />
+            <div className="space-y-3">
+              <Skeleton className="h-4 w-20" />
+              <div className="flex items-start gap-3">
+                <Skeleton className="h-8 w-8 shrink-0 rounded-full" />
+                <div className="flex-1 space-y-2">
+                  <Skeleton className="h-4 w-32" />
+                  <Skeleton className="h-16 w-full rounded-lg" />
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+        <div className="hidden md:block w-80 border-l p-4 space-y-5">
+          {Array.from({ length: 4 }).map((_, i) => (
+            <div key={i} className="flex items-center gap-2">
+              <Skeleton className="h-3 w-16 shrink-0" />
+              <Skeleton className="h-5 w-24" />
+            </div>
+          ))}
+          <Skeleton className="h-px w-full" />
+          {Array.from({ length: 3 }).map((_, i) => (
+            <div key={i} className="flex items-center gap-2">
+              <Skeleton className="h-3 w-16 shrink-0" />
+              <Skeleton className="h-4 w-28" />
+            </div>
+          ))}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+/**
+ * Route boundary: the /issue/:id route is identifier-first (NAI-3) but also
+ * accepts a UUID. Everything downstream (detail cache key, WS patches,
+ * comments, mutations) is keyed by UUID, so an identifier is resolved to its
+ * UUID once here — the server accepts identifiers on GET /api/issues/:id and
+ * falls back to the alias table for pre-move identifiers.
+ */
+export function IssueDetail({ issueId, ...rest }: IssueDetailProps) {
+  const wsId = useWorkspaceId();
+  const isUuid = UUID_RE.test(issueId);
+  const { data: resolved, isError } = useQuery({
+    ...issueDetailOptions(wsId, issueId),
+    enabled: !isUuid,
+  });
+  const canonicalId = isUuid ? issueId : resolved?.id;
+  // Once resolution fails, commit to the raw-id fallback permanently (per
+  // mount) instead of re-reading live isError on every render: IssueDetailInner
+  // fetches the same query key on mount and (refetchOnMount default) refetches
+  // it, which flips this component's own isError back to false mid-cycle —
+  // without the latch that toggle unmounts IssueDetailInner, which remounts
+  // and refetches again, forever (never a stable frame to reach "not found").
+  const fellBackToRawIdRef = useRef(false);
+  if (isError) fellBackToRawIdRef.current = true;
+  // canonicalId is only ever falsy while !isUuid (isUuid always yields
+  // canonicalId = issueId), so this is the "still resolving" state.
+  if (!canonicalId && !fellBackToRawIdRef.current) {
+    return <IssueDetailSkeleton />;
+  }
+  if (!canonicalId) {
+    return <IssueDetailInner issueId={issueId} {...rest} />;
+  }
+  return <IssueDetailInner issueId={canonicalId} {...rest} />;
+}
+
+function IssueDetailInner({ issueId, onDelete, onDone, defaultSidebarOpen = true, layoutId = "multica_issue_detail_layout", highlightCommentId }: IssueDetailProps) {
   const { t } = useT("issues");
   const timeAgo = useTimeAgo();
   const id = issueId;
@@ -1274,6 +1369,32 @@ export function IssueDetail({ issueId, onDelete, onDone, defaultSidebarOpen = tr
   const actions = useIssueActions(issue);
   const handleUpdateField = actions.updateField;
 
+  // Attaching the issue to a project whose space set misses the issue's space
+  // pauses behind the Linear-style resolution dialog (add space vs move issue).
+  const { data: allProjects = [] } = useQuery(projectListOptions(wsId));
+  const { data: allSpaces = [] } = useQuery(activeSpaceListOptions(wsId));
+  const [projectConflict, setProjectConflict] = useState<{
+    projectId: string;
+    projectTitle: string;
+    projectSpaces: Space[];
+  } | null>(null);
+  const handleProjectUpdate = (updates: Partial<UpdateIssueRequest>) => {
+    const pid = updates.project_id;
+    if (pid && issue?.space_id) {
+      const proj = allProjects.find((p) => p.id === pid);
+      const ids = proj?.space_ids ?? [];
+      if (ids.length > 0 && !ids.includes(issue.space_id)) {
+        setProjectConflict({
+          projectId: pid,
+          projectTitle: proj?.title ?? "",
+          projectSpaces: allSpaces.filter((tm) => ids.includes(tm.id)),
+        });
+        return;
+      }
+    }
+    handleUpdateField(updates);
+  };
+
   // Labels live in their own query (not on the issue body) — fetch the count
   // here so seeding can decide whether the "Labels" optional row should be
   // shown for an issue that already has labels attached.
@@ -1358,53 +1479,7 @@ export function IssueDetail({ issueId, onDelete, onDone, defaultSidebarOpen = tr
   });
 
   if (loading) {
-    return (
-      <div className="flex flex-1 min-h-0 flex-col">
-        <div className="flex h-12 shrink-0 items-center gap-2 border-b px-4">
-          <Skeleton className="h-4 w-16" />
-          <Skeleton className="h-4 w-4" />
-          <Skeleton className="h-4 w-24" />
-        </div>
-        <div className="flex flex-1 min-h-0">
-          <div className="flex-1 overflow-y-auto">
-            <div className="mx-auto w-full max-w-4xl px-8 py-8 space-y-6">
-              <Skeleton className="h-8 w-3/4" />
-              <div className="space-y-2">
-                <Skeleton className="h-4 w-full" />
-                <Skeleton className="h-4 w-5/6" />
-                <Skeleton className="h-4 w-2/3" />
-              </div>
-              <Skeleton className="h-px w-full" />
-              <div className="space-y-3">
-                <Skeleton className="h-4 w-20" />
-                <div className="flex items-start gap-3">
-                  <Skeleton className="h-8 w-8 shrink-0 rounded-full" />
-                  <div className="flex-1 space-y-2">
-                    <Skeleton className="h-4 w-32" />
-                    <Skeleton className="h-16 w-full rounded-lg" />
-                  </div>
-                </div>
-              </div>
-            </div>
-          </div>
-          <div className="hidden md:block w-80 border-l p-4 space-y-5">
-            {Array.from({ length: 4 }).map((_, i) => (
-              <div key={i} className="flex items-center gap-2">
-                <Skeleton className="h-3 w-16 shrink-0" />
-                <Skeleton className="h-5 w-24" />
-              </div>
-            ))}
-            <Skeleton className="h-px w-full" />
-            {Array.from({ length: 3 }).map((_, i) => (
-              <div key={i} className="flex items-center gap-2">
-                <Skeleton className="h-3 w-16 shrink-0" />
-                <Skeleton className="h-4 w-28" />
-              </div>
-            ))}
-          </div>
-        </div>
-      </div>
-    );
+    return <IssueDetailSkeleton />;
   }
 
   if (!issue) {
@@ -1434,7 +1509,13 @@ export function IssueDetail({ issueId, onDelete, onDone, defaultSidebarOpen = tr
           <ChevronRight className={`!size-3 shrink-0 stroke-[2.5] text-muted-foreground transition-transform ${propertiesOpen ? "rotate-90" : ""}`} />
         </button>
         {propertiesOpen && <div className="grid grid-cols-[auto_1fr] gap-x-2 gap-y-0.5 pl-2">
-          {/* Core props — always rendered. */}
+          {/* Core props — always rendered. Space leads: it owns the issue's
+              identifier namespace. Display-only in v1 — moving an issue
+              between spaces was cut from the UI (the server capability and
+              identifier aliasing remain for a later surface). */}
+          <PropRow label={t(($) => $.detail.prop_space)}>
+            <SpacePicker spaceId={issue.space_id ?? null} onChange={() => {}} align="start" disabled />
+          </PropRow>
           <PropRow label={t(($) => $.detail.prop_status)}>
             <StatusPicker status={issue.status} onUpdate={handleUpdateField} align="start" />
           </PropRow>
@@ -1444,9 +1525,26 @@ export function IssueDetail({ issueId, onDelete, onDone, defaultSidebarOpen = tr
           <PropRow label={t(($) => $.detail.prop_project)}>
             <ProjectPicker
               projectId={issue.project_id}
-              onUpdate={handleUpdateField}
+              onUpdate={handleProjectUpdate}
             />
           </PropRow>
+          {projectConflict && (
+            <SpaceProjectConflictDialog
+              open
+              spaceName={allSpaces.find((tm) => tm.id === issue.space_id)?.name ?? ""}
+              projectName={projectConflict.projectTitle}
+              projectSpaces={projectConflict.projectSpaces}
+              onAddSpace={() => {
+                handleUpdateField({ project_id: projectConflict.projectId });
+                setProjectConflict(null);
+              }}
+              onMoveToSpace={(tid) => {
+                handleUpdateField({ project_id: projectConflict.projectId, space_id: tid });
+                setProjectConflict(null);
+              }}
+              onCancel={() => setProjectConflict(null)}
+            />
+          )}
 
           {/* Optional props — rendered only when set on the issue OR added
               via "+ Add property" in this session. Row order follows the
diff --git a/packages/views/issues/components/issues-header.tsx b/packages/views/issues/components/issues-header.tsx
index 604045257e..f109abb056 100644
--- a/packages/views/issues/components/issues-header.tsx
+++ b/packages/views/issues/components/issues-header.tsx
@@ -20,6 +20,7 @@ import {
   User,
   UserMinus,
   UserPen,
+  Users,
   Waves,
 } from "lucide-react";
 import { Button } from "@multica/ui/components/ui/button";
@@ -55,6 +56,7 @@ import { useQuery } from "@tanstack/react-query";
 import { useWorkspaceId } from "@multica/core/hooks";
 import { memberListOptions, agentListOptions, squadListOptions } from "@multica/core/workspace/queries";
 import { projectListOptions } from "@multica/core/projects/queries";
+import { activeSpaceListOptions } from "@multica/core/spaces/queries";
 import { labelListOptions } from "@multica/core/labels/queries";
 import { ProjectIcon } from "../../projects/components/project-icon";
 import { ActorAvatar } from "../../common/actor-avatar";
@@ -100,6 +102,7 @@ function getActiveFilterCount(state: {
   assigneeFilters: ActorFilterValue[];
   includeNoAssignee: boolean;
   creatorFilters: ActorFilterValue[];
+  spaceFilter?: string | null;
   projectFilters: string[];
   includeNoProject: boolean;
   labelFilters: string[];
@@ -110,6 +113,7 @@ function getActiveFilterCount(state: {
   if (state.priorityFilters.length > 0) count++;
   if (state.assigneeFilters.length > 0 || state.includeNoAssignee) count++;
   if (state.creatorFilters.length > 0) count++;
+  if (state.spaceFilter) count++;
   if (state.projectFilters.length > 0 || state.includeNoProject) count++;
   if (state.labelFilters.length > 0) count++;
   if (state.dateFilter) count++;
@@ -134,8 +138,9 @@ function useIssueCounts(allIssues: Issue[]) {
     const status = new Map<string, number>();
     const priority = new Map<string, number>();
     const assignee = new Map<string, number>();
-    const creator = new Map<string, number>();
-    const project = new Map<string, number>();
+  const creator = new Map<string, number>();
+  const space = new Map<string, number>();
+  const project = new Map<string, number>();
     const label = new Map<string, number>();
     let noAssignee = 0;
     let noProject = 0;
@@ -154,6 +159,10 @@ function useIssueCounts(allIssues: Issue[]) {
       const cKey = `${issue.creator_type}:${issue.creator_id}`;
       creator.set(cKey, (creator.get(cKey) ?? 0) + 1);
 
+      if (issue.space_id) {
+        space.set(issue.space_id, (space.get(issue.space_id) ?? 0) + 1);
+      }
+
       if (!issue.project_id) {
         noProject++;
       } else {
@@ -167,7 +176,7 @@ function useIssueCounts(allIssues: Issue[]) {
       }
     }
 
-    return { status, priority, assignee, creator, noAssignee, project, noProject, label };
+    return { status, priority, assignee, creator, noAssignee, space, project, noProject, label };
   }, [allIssues]);
 }
 
@@ -349,6 +358,89 @@ function ActorSubContent({
   );
 }
 
+// ---------------------------------------------------------------------------
+// Space sub-menu content
+// ---------------------------------------------------------------------------
+
+function SpaceSubContent({
+  counts,
+  selected,
+  onSelect,
+}: {
+  counts: Map<string, number>;
+  selected: string | null;
+  onSelect: (spaceId: string | null) => void;
+}) {
+  const { t } = useT("issues");
+  const [search, setSearch] = useState("");
+  const wsId = useWorkspaceId();
+  const { data: spaces = [] } = useQuery(activeSpaceListOptions(wsId));
+  const query = search.trim().toLowerCase();
+  const filtered = spaces.filter((space) =>
+    space.name.toLowerCase().includes(query) ||
+    space.key.toLowerCase().includes(query),
+  );
+
+  return (
+    <>
+      <div className="px-2 py-1.5 border-b border-foreground/5">
+        <input
+          type="text"
+          value={search}
+          onChange={(e) => setSearch(e.target.value)}
+          placeholder={t(($) => $.filters.placeholder)}
+          className="w-full bg-transparent text-sm placeholder:text-muted-foreground outline-none"
+          autoFocus
+        />
+      </div>
+
+      <div className="max-h-64 overflow-y-auto p-1">
+        {(!query || "all spaces".includes(query)) && (
+          <DropdownMenuCheckboxItem
+            checked={!selected}
+            onCheckedChange={() => onSelect(null)}
+            className={FILTER_ITEM_CLASS}
+          >
+            <HoverCheck checked={!selected} />
+            <Users className="size-3.5 text-muted-foreground" />
+            {t(($) => $.filters.all_spaces)}
+          </DropdownMenuCheckboxItem>
+        )}
+
+        {filtered.map((space) => {
+          const checked = selected === space.id;
+          const count = counts.get(space.id) ?? 0;
+          return (
+            <DropdownMenuCheckboxItem
+              key={space.id}
+              checked={checked}
+              onCheckedChange={() => onSelect(checked ? null : space.id)}
+              className={FILTER_ITEM_CLASS}
+            >
+              <HoverCheck checked={checked} />
+              <span className="inline-flex h-5 min-w-7 items-center justify-center rounded bg-muted px-1.5 text-[10px] font-medium text-muted-foreground">
+                {space.key}
+              </span>
+              <span className="truncate">{space.name}</span>
+              {count > 0 && (
+                <span className="ml-auto text-xs text-muted-foreground">
+                  {count}
+                </span>
+              )}
+            </DropdownMenuCheckboxItem>
+          );
+        })}
+
+        {filtered.length === 0 && search && (
+          <div className="px-2 py-3 text-center text-sm text-muted-foreground">
+            {t(($) => $.filters.no_results)}
+          </div>
+        )}
+      </div>
+    </>
+  );
+}
+
 // ---------------------------------------------------------------------------
 // Project sub-menu content
 // ---------------------------------------------------------------------------
@@ -793,6 +885,7 @@ export function IssueDisplayControls({
   const assigneeFilters = useViewStore((s) => s.assigneeFilters);
   const includeNoAssignee = useViewStore((s) => s.includeNoAssignee);
   const creatorFilters = useViewStore((s) => s.creatorFilters);
+  const spaceFilter = useViewStore((s) => s.spaceFilter);
   const projectFilters = useViewStore((s) => s.projectFilters);
   const includeNoProject = useViewStore((s) => s.includeNoProject);
   const labelFilters = useViewStore((s) => s.labelFilters);
@@ -813,6 +906,7 @@ export function IssueDisplayControls({
     assigneeFilters,
     includeNoAssignee,
     creatorFilters,
+    spaceFilter,
     projectFilters,
     includeNoProject,
     labelFilters,
@@ -1047,6 +1141,24 @@ export function IssueDisplayControls({
               </DropdownMenuSubContent>
             </DropdownMenuSub>
 
+            {/* Space */}
+            <DropdownMenuSub>
+              <DropdownMenuSubTrigger>
+                <Users className="size-3.5" />
+                <span className="flex-1">{t(($) => $.filters.section_space)}</span>
+                {spaceFilter && (
+                  <span className="text-xs text-primary font-medium">1</span>
+                )}
+              </DropdownMenuSubTrigger>
+              <DropdownMenuSubContent className="w-auto min-w-52 p-0">
+                <SpaceSubContent
+                  counts={counts.space}
+                  selected={spaceFilter}
+                  onSelect={act.setSpaceFilter}
+                />
+              </DropdownMenuSubContent>
+            </DropdownMenuSub>
+
             {/* Project */}
             <DropdownMenuSub>
               <DropdownMenuSubTrigger>
diff --git a/packages/views/issues/components/issues-page.tsx b/packages/views/issues/components/issues-page.tsx
index bd188cacd3..43ff444056 100644
--- a/packages/views/issues/components/issues-page.tsx
+++ b/packages/views/issues/components/issues-page.tsx
@@ -9,7 +9,10 @@ import { useT } from "../../i18n";
 import { IssueSurface } from "../surface/issue-surface";
 import { IssuesHeader } from "./issues-header";
 
-function IssuesSurfaceHeader({
+// Exported for space surface pages, which render the same filter header over
+// a space-scoped IssueSurface. Must render inside IssueSurface's renderHeader
+// (it reads the surface's view-store context).
+export function IssuesSurfaceHeader({
   issues,
   isRefreshing,
 }: {
diff --git a/packages/views/issues/surface/use-issue-surface-controller.ts b/packages/views/issues/surface/use-issue-surface-controller.ts
index 4c66a256fe..d7d6277e13 100644
--- a/packages/views/issues/surface/use-issue-surface-controller.ts
+++ b/packages/views/issues/surface/use-issue-surface-controller.ts
@@ -122,6 +122,7 @@ export function useIssueSurfaceController({
   const assigneeFilters = useViewStore((s) => s.assigneeFilters);
   const includeNoAssignee = useViewStore((s) => s.includeNoAssignee);
   const creatorFilters = useViewStore((s) => s.creatorFilters);
+  const spaceFilter = useViewStore((s) => s.spaceFilter);
   const projectFilters = useViewStore((s) => s.projectFilters);
   const includeNoProject = useViewStore((s) => s.includeNoProject);
   const labelFilters = useViewStore((s) => s.labelFilters);
@@ -156,8 +157,14 @@ export function useIssueSurfaceController({
       sort_by: sortBy,
       sort_direction: sortBy !== "position" ? sortDirection : undefined,
       ...dateParams,
+      // space_id is a cross-scope server filter, not a sort. It rides the
+      // sort param bag (like the date filter) so it threads through every
+      // repository path — workspace list, scoped list, and assignee-grouped —
+      // and forks the query-key cache per space without the query plan (built
+      // from scope alone) needing to know about the view store.
+      ...(spaceFilter ? { space_id: spaceFilter } : {}),
     }),
-    [dateParams, sortBy, sortDirection],
+    [dateParams, sortBy, sortDirection, spaceFilter],
   );
 
   const selection = useCreateIssueSurfaceSelection(
diff --git a/packages/views/layout/app-sidebar.test.tsx b/packages/views/layout/app-sidebar.test.tsx
index 76836e2563..9daad66d78 100644
--- a/packages/views/layout/app-sidebar.test.tsx
+++ b/packages/views/layout/app-sidebar.test.tsx
@@ -30,6 +30,7 @@ vi.mock("@dnd-kit/core", () => ({
   DndContext: ({ children }: { children: React.ReactNode }) => <>{children}</>,
   PointerSensor: vi.fn(),
   closestCenter: vi.fn(),
+  MeasuringStrategy: { Always: "always" },
   useSensor: vi.fn(),
   useSensors: vi.fn(),
 }));
@@ -44,6 +45,19 @@ vi.mock("@multica/ui/components/ui/sidebar", () => ({
   SidebarContent: ({ children }: { children: React.ReactNode }) => <>{children}</>,
   SidebarFooter: ({ children }: { children: React.ReactNode }) => <>{children}</>,
   SidebarGroup: ({ children }: { children: React.ReactNode }) => <>{children}</>,
+  SidebarGroupAction: ({
+    children,
+    title,
+    onClick,
+  }: {
+    children: React.ReactNode;
+    title?: string;
+    onClick?: () => void;
+  }) => (
+    <button type="button" title={title} onClick={onClick}>
+      {children}
+    </button>
+  ),
   SidebarGroupContent: ({ children }: { children: React.ReactNode }) => <>{children}</>,
   SidebarGroupLabel: ({ children }: { children: React.ReactNode }) => <>{children}</>,
   SidebarHeader: ({ children }: { children: React.ReactNode }) => <>{children}</>,
@@ -146,6 +160,8 @@ vi.mock("@multica/core/issues/stores/draft-store", () => ({ useIssueDraftStore:
 vi.mock("@multica/core/modals", () => ({ useModalStore: { getState: () => ({ modal: null, open: vi.fn() }) } }));
 vi.mock("@multica/core/pins/mutations", () => ({ useDeletePin: () => ({ mutate: deletePin }), useReorderPins: () => ({ mutate: vi.fn() }) }));
 vi.mock("@multica/core/pins/queries", () => ({ pinListOptions: () => ({ queryKey: ["pins"] }) }));
+vi.mock("@multica/core/spaces/queries", () => ({ mySpaceListOptions: () => ({ queryKey: ["spaces"] }) }));
+vi.mock("@multica/core/spaces/mutations", () => ({ useUpdateSpaceMembership: () => ({ mutate: vi.fn() }) }));
 vi.mock("@multica/core/projects/queries", () => ({ projectDetailOptions: () => ({ queryKey: ["project"] }) }));
 vi.mock("@multica/core/runtimes/hooks", () => ({ useMyRuntimesNeedUpdate: () => false }));
 vi.mock("@multica/core/workspace/queries", () => ({
@@ -209,7 +225,10 @@ describe("PinRow", () => {
       "data-active",
       "true",
     );
-    expect(container.querySelector('button[data-href="/acme/issues"]')).not.toHaveAttribute("data-active");
+    // The workspace-wide Issues nav left with the space rollout, so the pin
+    // must be the ONLY active element — no nav entry lights up alongside it.
+    expect(container.querySelector('button[data-href="/acme/issues"]')).toBeNull();
+    expect(container.querySelectorAll('[data-active="true"]')).toHaveLength(1);
   });
 });
 
diff --git a/packages/views/layout/app-sidebar.tsx b/packages/views/layout/app-sidebar.tsx
index 6953a99d90..6479567dc1 100644
--- a/packages/views/layout/app-sidebar.tsx
+++ b/packages/views/layout/app-sidebar.tsx
@@ -12,6 +12,7 @@ import {
   useSensor,
   useSensors,
   closestCenter,
+  MeasuringStrategy,
   type DragEndEvent,
 } from "@dnd-kit/core";
 import { SortableContext, verticalListSortingStrategy, useSortable, arrayMove } from "@dnd-kit/sortable";
@@ -48,6 +49,7 @@ import {
   SidebarContent,
   SidebarFooter,
   SidebarGroup,
+  SidebarGroupAction,
   SidebarGroupContent,
   SidebarGroupLabel,
   SidebarHeader,
@@ -77,6 +79,11 @@ import { useConfigStore } from "@multica/core/config";
 import { useMyRuntimesNeedUpdate } from "@multica/core/runtimes/hooks";
 import { pinListOptions } from "@multica/core/pins/queries";
 import { useDeletePin, useReorderPins } from "@multica/core/pins/mutations";
+import { mySpaceListOptions } from "@multica/core/spaces/queries";
+import { useUpdateSpaceMembership } from "@multica/core/spaces/mutations";
+import { useSidebarStore } from "@multica/core/layout/sidebar-store";
+import { SpaceIcon } from "../spaces/components/space-icon";
+import type { Space } from "@multica/core/types";
 import { issueDetailOptions } from "@multica/core/issues/queries";
 import { projectDetailOptions } from "@multica/core/projects/queries";
 import type { PinnedItem } from "@multica/core/types";
@@ -109,7 +116,6 @@ const EMPTY_INBOX_SUMMARY: Awaited<ReturnType<typeof api.getInboxUnreadSummary>>
 type NavKey =
   | "inbox"
   | "myIssues"
-  | "issues"
   | "projects"
   | "autopilots"
   | "agents"
@@ -123,7 +129,7 @@ type NavKey =
 type NavLabelKey =
   | "inbox"
   | "my_issues"
-  | "issues"
+  | "spaces"
   | "projects"
   | "autopilots"
   | "agents"
@@ -133,32 +139,173 @@ type NavLabelKey =
   | "skills"
   | "settings";
 
+// Re-measure droppable rects during a space drag: groups collapse on drag
+// start, so the rects cached at gesture start are immediately stale.
+const spaceDragMeasuring = { droppable: { strategy: MeasuringStrategy.Always } };
+
 const personalNav: { key: NavKey; labelKey: NavLabelKey; icon: typeof Inbox }[] = [
   { key: "inbox", labelKey: "inbox", icon: Inbox },
   { key: "myIssues", labelKey: "my_issues", icon: CircleUser },
 ];
 
+// The workspace-wide issues list left the nav with the space rollout: issues
+// live under their space (Spaces section below) or under My Issues. Space
+// management lives on each space's detail page (the /spaces overview was cut
+// from v1). Autopilots are space-scoped like issues (space_id NOT NULL,
+// their output lands in their space), so they live under each space below —
+// no global entry, same rationale as the removed workspace-wide Issues.
 const workspaceNav: { key: NavKey; labelKey: NavLabelKey; icon: typeof Inbox }[] = [
-  { key: "issues", labelKey: "issues", icon: ListTodo },
   { key: "projects", labelKey: "projects", icon: FolderKanban },
-  { key: "autopilots", labelKey: "autopilots", icon: Zap },
   { key: "agents", labelKey: "agents", icon: Bot },
   { key: "squads", labelKey: "squads", icon: Users },
-  { key: "usage", labelKey: "usage", icon: BarChart3 },
 ];
 
-const configureNav: { key: NavKey; labelKey: NavLabelKey; icon: typeof Inbox }[] = [
-  { key: "runtimes", labelKey: "runtimes", icon: Monitor },
+// Rendered as plain rows alongside workspaceNav (see the Workspace group
+// below) — used to sit behind a "More" dropdown, now always visible.
+const moreNav: { key: NavKey; labelKey: NavLabelKey; icon: typeof Inbox }[] = [
   { key: "skills", labelKey: "skills", icon: BookOpenText },
-  { key: "settings", labelKey: "settings", icon: Settings },
+  { key: "usage", labelKey: "usage", icon: BarChart3 },
+  { key: "runtimes", labelKey: "runtimes", icon: Monitor },
 ];
 
+// Per-space children under the Spaces group. Hrefs are built per space key.
+const spaceChildNav = [
+  { pathKey: "spaceIssues", labelKey: "issues", icon: ListTodo },
+  { pathKey: "spaceProjects", labelKey: "projects", icon: FolderKanban },
+  { pathKey: "spaceAutopilots", labelKey: "autopilots", icon: Zap },
+] as const;
+
 function DraftDot() {
   const hasDraft = useIssueDraftStore((s) => !!(s.draft.title || s.draft.description));
   if (!hasDraft) return null;
   return <span className="absolute top-0 right-0 size-1.5 rounded-full bg-brand" />;
 }
 
+// Controlled collapse state persisted per workspace (sidebar-store). Absent
+// key = expanded, so new groups (and fresh workspaces) start open.
+function useGroupCollapse(key: string) {
+  const collapsed = useSidebarStore((s) => s.collapsed[key] === true);
+  const setGroupCollapsed = useSidebarStore((s) => s.setGroupCollapsed);
+  const onOpenChange = useCallback(
+    (open: boolean) => setGroupCollapsed(key, !open),
+    [key, setGroupCollapsed],
+  );
+  return { open: !collapsed, onOpenChange };
+}
+
+// One space's collapsible nav group inside the Spaces section: draggable via
+// the same dnd-kit setup the Pinned section uses (PointerSensor distance 5,
+// so plain clicks still toggle the collapse), children are the space's
+// surfaces addressed by space key.
+function SortableSpaceGroup({
+  space,
+  pathname,
+  buildHref,
+  detailHref,
+  forceCollapsed,
+}: {
+  space: Space;
+  pathname: string;
+  buildHref: (pathKey: (typeof spaceChildNav)[number]["pathKey"], spaceKey: string) => string;
+  detailHref: string;
+  /** True while any space drag is in flight: every group renders collapsed so
+      all sortable items are the same height — variable-height blocks make
+      dnd-kit's rect math (and thus the whole gesture) feel broken. */
+  forceCollapsed: boolean;
+}) {
+  const { t } = useT("layout");
+  const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({ id: space.id });
+  const collapse = useGroupCollapse(`space:${space.id}`);
+  // Same trap the pinned rows hit: the click that ends a drag would follow
+  // the row's link and reload the page. Mirror SortablePinItem's guard —
+  // remember the drag and swallow exactly that one click.
+  const wasDragged = useRef(false);
+  useEffect(() => {
+    if (isDragging) wasDragged.current = true;
+  }, [isDragging]);
+  // The row itself is the space's home (detail page). It stays highlighted
+  // anywhere inside the space (issues/projects/autopilots too) so the sidebar
+  // always shows which space you're in.
+  const isSpaceActive = isNavActive(pathname, detailHref);
+  return (
+    <div
+      ref={setNodeRef}
+      style={{ transform: CSS.Transform.toString(transform), transition }}
+      className={cn(isDragging && "opacity-30")}
+    >
+      <Collapsible open={collapse.open && !forceCollapsed} onOpenChange={collapse.onOpenChange}>
+        {/* The whole row navigates to the space page (and expands the group —
+            navigation is context). The chevron sits right after the name like
+            every other group label — always visible, secondary color, primary
+            only when hovered (the one independently-clickable element: it
+            toggles the collapse without navigating). Drag listeners live on
+            the row; the 5px activation distance keeps clicks working. */}
+        <div {...attributes} {...listeners}>
+          <SidebarGroupLabel
+            render={<AppLink href={detailHref} draggable={false} />}
+            onClick={(event) => {
+              if (wasDragged.current) {
+                wasDragged.current = false;
+                event.preventDefault();
+                return;
+              }
+              collapse.onOpenChange(true);
+            }}
+            className={cn(
+              "w-full cursor-pointer gap-1.5 hover:bg-sidebar-accent/70 hover:text-sidebar-accent-foreground",
+              isSpaceActive && "bg-sidebar-accent text-sidebar-accent-foreground",
+              isDragging && "pointer-events-none",
+            )}
+          >
+            <SpaceIcon space={space} className="size-3.5" />
+            <span className="truncate">{space.name}</span>
+            <button
+              type="button"
+              onClick={(e) => {
+                // Toggle only — never follow the surrounding link.
+                e.preventDefault();
+                e.stopPropagation();
+                collapse.onOpenChange(!collapse.open);
+              }}
+              className="-ml-1 flex size-4 shrink-0 cursor-pointer items-center justify-center rounded-sm text-muted-foreground hover:bg-sidebar-accent hover:text-foreground"
+            >
+              <ChevronRight
+                className={cn(
+                  "!size-3 stroke-[2.5] transition-transform duration-200",
+                  collapse.open && "rotate-90",
+                )}
+              />
+            </button>
+          </SidebarGroupLabel>
+        </div>
+        <CollapsibleContent>
+          {/* pt-0.5 breathes the children away from their space row; the
+              group container's gap-0.5 covers the space below. pl-5 lands
+              child icons exactly under the space name's text start. */}
+          <SidebarMenu className="gap-0.5 pt-0.5 pl-5">
+            {spaceChildNav.map((child) => {
+              const href = buildHref(child.pathKey, space.key);
+              const isActive = isNavActive(pathname, href);
+              return (
+                <SidebarMenuItem key={child.pathKey}>
+                  <SidebarMenuButton
+                    isActive={isActive}
+                    render={<AppLink href={href} />}
+                    className="text-muted-foreground hover:not-data-active:bg-sidebar-accent/70 data-active:bg-sidebar-accent data-active:text-sidebar-accent-foreground"
+                  >
+                    <child.icon />
+                    <span>{t(($) => $.nav[child.labelKey])}</span>
+                  </SidebarMenuButton>
+                </SidebarMenuItem>
+              );
+            })}
+          </SidebarMenu>
+        </CollapsibleContent>
+      </Collapsible>
+    </div>
+  );
+}
+
 /**
  * Presentational pin row. The `label` and `iconNode` are computed by the
  * parent `PinRow` from cached issue / project detail queries — keeping
@@ -387,6 +534,73 @@ export function AppSidebar({ topSlot, searchSlot, headerClassName, headerStyle }
   const deletePin = useDeletePin();
   const reorderPins = useReorderPins();
   const sensors = useSensors(useSensor(PointerSensor, { activationConstraint: { distance: 5 } }));
+
+  // Persisted collapse state per group; per-space groups manage their own
+  // inside SortableSpaceGroup.
+  const pinnedCollapse = useGroupCollapse("pinned");
+  const workspaceCollapse = useGroupCollapse("workspace");
+  const spacesCollapse = useGroupCollapse("spaces");
+
+  // Spaces section: only spaces the user joined, in their personal order.
+  const { data: mySpaces = [] } = useQuery({
+    ...mySpaceListOptions(wsId ?? ""),
+    enabled: !!wsId,
+  });
+  const updateSpaceMembership = useUpdateSpaceMembership();
+  // Local presentational copy for drop-animation stability — same trick as
+  // the pinned rows below: follow TQ at rest, freeze during a drag so the
+  // optimistic cache re-sort can't reorder the DOM while dnd-kit's drop
+  // animation is still interpolating (that's what made drops snap back).
+  const [localSpaces, setLocalSpaces] = useState(mySpaces);
+  const [localSpacesWsId, setLocalSpacesWsId] = useState<string | null>(wsId ?? null);
+  const isSpaceDraggingRef = useRef(false);
+  const [spaceDragActive, setSpaceDragActive] = useState(false);
+  useEffect(() => {
+    if (!isSpaceDraggingRef.current) {
+      setLocalSpaces(mySpaces);
+    }
+  }, [mySpaces]);
+  useEffect(() => {
+    setLocalSpacesWsId(wsId ?? null);
+  }, [wsId]);
+  const visibleSpaces = localSpacesWsId === (wsId ?? null) ? localSpaces : [];
+  const handleSpaceDragStart = useCallback(() => {
+    isSpaceDraggingRef.current = true;
+    setSpaceDragActive(true);
+  }, []);
+  const handleSpaceDragCancel = useCallback(() => {
+    isSpaceDraggingRef.current = false;
+    setSpaceDragActive(false);
+  }, []);
+  // Fractional reorder (Linear-style): the dragged space takes the midpoint
+  // of its new neighbors, so a drag is a single-row membership update. The
+  // local array is rearranged first so the dropped row lands exactly where
+  // the animation ends.
+  const handleSpaceDragEnd = useCallback(
+    (event: DragEndEvent) => {
+      isSpaceDraggingRef.current = false;
+      setSpaceDragActive(false);
+      const { active, over } = event;
+      if (!over || active.id === over.id) return;
+      const oldIndex = localSpaces.findIndex((t) => t.id === active.id);
+      const newIndex = localSpaces.findIndex((t) => t.id === over.id);
+      if (oldIndex === -1 || newIndex === -1) return;
+      const reordered = arrayMove(localSpaces, oldIndex, newIndex);
+      setLocalSpaces(reordered);
+      const prev = reordered[newIndex - 1];
+      const next = reordered[newIndex + 1];
+      const sortOrder =
+        prev && next
+          ? (prev.sort_order + next.sort_order) / 2
+          : prev
+            ? prev.sort_order + 1
+            : next
+              ? next.sort_order - 1
+              : 1;
+      updateSpaceMembership.mutate({ id: String(active.id), sort_order: sortOrder });
+    },
+    [localSpaces, updateSpaceMembership],
+  );
   const sidebarScrollRef = useRef<HTMLDivElement>(null);
   const sidebarFadeStyle = useScrollFade(sidebarScrollRef, 24);
   const getPinHref = useCallback(
@@ -460,6 +674,24 @@ export function AppSidebar({ topSlot, searchSlot, headerClassName, headerStyle }
     },
   });
 
+  // Route-derived seed for the create-issue flow: whichever route the user is
+  // standing on should default the modal, not just a page's own local "+"
+  // button. Shared by the global "C" shortcut and the sidebar's "New Issue"
+  // button below — neither goes through a page's `scope`-aware create
+  // handler, so without this they always fell through to the personal
+  // default space regardless of which space's pages the user was browsing.
+  const projectRouteMatch = pathname.match(/^\/[^/]+\/projects\/([^/]+)$/);
+  const spaceRouteMatch = pathname.match(/^\/[^/]+\/space\/([^/]+)/);
+  const routeSpaceKey = spaceRouteMatch?.[1];
+  const routeSpace = routeSpaceKey
+    ? mySpaces.find((s) => s.key.toLowerCase() === routeSpaceKey.toLowerCase())
+    : undefined;
+  const routeCreateDefaults = projectRouteMatch
+    ? { project_id: projectRouteMatch[1] }
+    : routeSpace
+      ? { space_id: routeSpace.id }
+      : undefined;
+
   // Global "C" shortcut: opens whichever create mode the user landed on last
   // (agent vs manual), persisted in useCreateModeStore. The mode switch lives
   // inside both modal footers so users can flip without remembering which
@@ -477,16 +709,11 @@ export function AppSidebar({ topSlot, searchSlot, headerClassName, headerStyle }
       if (isEditable) return;
       if (useModalStore.getState().modal) return;
       e.preventDefault();
-      // Auto-fill project when on a project detail page. The manual form
-      // consumes `project_id`; quick-create also honours it as a seed for
-      // its project picker, so passing it through is safe for both modes.
-      const projectMatch = pathname.match(/^\/[^/]+\/projects\/([^/]+)$/);
-      const data = projectMatch ? { project_id: projectMatch[1] } : undefined;
-      openCreateIssueWithPreference(data);
+      openCreateIssueWithPreference(routeCreateDefaults);
     };
     document.addEventListener("keydown", handleKeyDown);
     return () => document.removeEventListener("keydown", handleKeyDown);
-  }, [pathname]);
+  }, [routeCreateDefaults]);
 
   return (
       <Sidebar variant="inset">
@@ -616,6 +843,10 @@ export function AppSidebar({ topSlot, searchSlot, headerClassName, headerStyle }
                   )}
                   <DropdownMenuSeparator />
                   <DropdownMenuGroup>
+                    <DropdownMenuItem render={<AppLink href={p.settings()} />}>
+                      <Settings className="h-3.5 w-3.5" />
+                      {t(($) => $.nav.settings)}
+                    </DropdownMenuItem>
                     <DropdownMenuItem variant="destructive" onClick={logout}>
                       <LogOut className="h-3.5 w-3.5" />
                       {t(($) => $.sidebar.log_out)}
@@ -634,7 +865,7 @@ export function AppSidebar({ topSlot, searchSlot, headerClassName, headerStyle }
             <SidebarMenuItem>
               <SidebarMenuButton
                 className="text-muted-foreground"
-                onClick={() => openCreateIssueWithPreference()}
+                onClick={() => openCreateIssueWithPreference(routeCreateDefaults)}
               >
                 <span className="relative">
                   <SquarePen />
@@ -649,7 +880,7 @@ export function AppSidebar({ topSlot, searchSlot, headerClassName, headerStyle }
 
         {/* Navigation */}
         <SidebarContent ref={sidebarScrollRef} style={sidebarFadeStyle}>
-          <SidebarGroup>
+          <SidebarGroup className="py-1">
             <SidebarGroupContent>
               <SidebarMenu className="gap-0.5">
                 {personalNav.map((item) => {
@@ -678,8 +909,8 @@ export function AppSidebar({ topSlot, searchSlot, headerClassName, headerStyle }
           </SidebarGroup>
 
           {visiblePinned.length > 0 && (
-            <Collapsible defaultOpen>
-              <SidebarGroup className="group/pinned">
+            <Collapsible open={pinnedCollapse.open} onOpenChange={pinnedCollapse.onOpenChange}>
+              <SidebarGroup className="group/pinned py-1">
                 <SidebarGroupLabel
                   render={<CollapsibleTrigger />}
                   className="group/trigger cursor-pointer hover:bg-sidebar-accent/70 hover:text-sidebar-accent-foreground"
@@ -712,61 +943,137 @@ export function AppSidebar({ topSlot, searchSlot, headerClassName, headerStyle }
             </Collapsible>
           )}
 
-          <SidebarGroup>
-            <SidebarGroupLabel>{t(($) => $.sidebar.workspace_group)}</SidebarGroupLabel>
-            <SidebarGroupContent>
-              <SidebarMenu className="gap-0.5">
-                {workspaceNav.map((item) => {
-                  const href = p[item.key]();
-                  const isActive = !isActivePinnedRoute && isNavActive(pathname, href);
-                  return (
-                    <SidebarMenuItem key={item.key}>
-                      <SidebarMenuButton
-                        isActive={isActive}
-                        render={<AppLink href={href} />}
-                        className="text-muted-foreground hover:not-data-active:bg-sidebar-accent/70 data-active:bg-sidebar-accent data-active:text-sidebar-accent-foreground"
-                      >
-                        <item.icon />
-                        <span>{t(($) => $.nav[item.labelKey])}</span>
-                      </SidebarMenuButton>
-                    </SidebarMenuItem>
-                  );
-                })}
-              </SidebarMenu>
-            </SidebarGroupContent>
-          </SidebarGroup>
+          {/* Workspace — shared resources. */}
+          <Collapsible open={workspaceCollapse.open} onOpenChange={workspaceCollapse.onOpenChange}>
+            <SidebarGroup className="group/ws py-1">
+              <SidebarGroupLabel
+                render={<CollapsibleTrigger />}
+                className="group/trigger cursor-pointer hover:bg-sidebar-accent/70 hover:text-sidebar-accent-foreground"
+              >
+                <span>{t(($) => $.sidebar.workspace_group)}</span>
+                <ChevronRight className="!size-3 ml-1 stroke-[2.5] transition-transform duration-200 group-data-[panel-open]/trigger:rotate-90" />
+              </SidebarGroupLabel>
+              <CollapsibleContent>
+                <SidebarGroupContent>
+                  <SidebarMenu className="gap-0.5">
+                    {[...workspaceNav, ...moreNav].map((item) => {
+                      const href = p[item.key]();
+                      const isActive = !isActivePinnedRoute && isNavActive(pathname, href);
+                      return (
+                        <SidebarMenuItem key={item.key}>
+                          <SidebarMenuButton
+                            isActive={isActive}
+                            render={<AppLink href={href} />}
+                            className="text-muted-foreground hover:not-data-active:bg-sidebar-accent/70 data-active:bg-sidebar-accent data-active:text-sidebar-accent-foreground"
+                          >
+                            <item.icon />
+                            <span>{t(($) => $.nav[item.labelKey])}</span>
+                            {item.key === "runtimes" && hasRuntimeUpdates && (
+                              <span className="ml-auto size-1.5 rounded-full bg-destructive" />
+                            )}
+                          </SidebarMenuButton>
+                        </SidebarMenuItem>
+                      );
+                    })}
+                  </SidebarMenu>
+                </SidebarGroupContent>
+              </CollapsibleContent>
+            </SidebarGroup>
+          </Collapsible>
 
-          <SidebarGroup>
-            <SidebarGroupLabel>{t(($) => $.sidebar.configure_group)}</SidebarGroupLabel>
-            <SidebarGroupContent>
-              <SidebarMenu className="gap-0.5">
-                {configureNav.map((item) => {
-                  const href = p[item.key]();
-                  const isActive = isNavActive(pathname, href);
-                  return (
-                    <SidebarMenuItem key={item.key}>
-                      <SidebarMenuButton
-                        isActive={isActive}
-                        render={<AppLink href={href} />}
-                        className="text-muted-foreground hover:not-data-active:bg-sidebar-accent/70 data-active:bg-sidebar-accent data-active:text-sidebar-accent-foreground"
+          {/* Spaces — joined spaces only, in the user's personal order.
+              Drag a space header to reorder; the first space doubles as the
+              issue-creation default. Always rendered: a user with no joined
+              spaces gets an empty-state row (join/create) instead of losing
+              the section — and with it every create/browse entry point. */}
+          <Collapsible open={spacesCollapse.open} onOpenChange={spacesCollapse.onOpenChange}>
+              <SidebarGroup className="group/spaces relative py-1">
+                {/* Rendered before the label so the label can react to it via
+                    peer-hover (CSS peer only looks at *earlier* siblings).
+                    Absolute positioning means this render-order swap doesn't
+                    move it visually — it still paints above the label. */}
+                {/* Hover-revealed, secondary until hovered itself — mirrors
+                    the pinned-count affordance. Navigates to the create-space
+                    page directly; sized like the space-row chevron buttons. */}
+                {/* right-4 = group px-2 + label px-2, so the icon's right
+                    edge sits on the same inset line as row content; top-3
+                    centers the 16px button in the 32px label row (group
+                    py-1). */}
+                <SidebarGroupAction
+                  title={t(($) => $.sidebar.new_space)}
+                  className="peer/spaces-action top-3 right-4 h-4 w-4 rounded-sm text-muted-foreground opacity-0 transition-opacity hover:bg-sidebar-accent hover:text-foreground group-hover/spaces:opacity-100 [&>svg]:size-3"
+                  onClick={() => push(p.spaceNew())}
+                >
+                  <Plus />
+                </SidebarGroupAction>
+                {/* The action overlaps this row's top-right corner, so its own
+                    hover steals the pointer from the label underneath and the
+                    label's plain hover: would drop out. peer-hover keeps the
+                    row background lit while the pointer is over the action;
+                    the action's own hover: still makes it visibly brighter on
+                    top of that. */}
+                <SidebarGroupLabel
+                  render={<CollapsibleTrigger />}
+                  className="group/trigger cursor-pointer hover:bg-sidebar-accent/70 hover:text-sidebar-accent-foreground peer-hover/spaces-action:bg-sidebar-accent/70 peer-hover/spaces-action:text-sidebar-accent-foreground"
+                >
+                  <span>{t(($) => $.nav.spaces)}</span>
+                  <ChevronRight className="!size-3 ml-1 stroke-[2.5] transition-transform duration-200 group-data-[panel-open]/trigger:rotate-90" />
+                </SidebarGroupLabel>
+                <CollapsibleContent>
+                  {/* pt-0.5 mirrors the space rows' own children breathing
+                      (py-0.5): space rows are row-styled, not plain content,
+                      so they need the same gap above as below. */}
+                  {/* gap-0.5 keeps a constant 2px rhythm between space
+                      blocks whether they're collapsed (row→row) or expanded
+                      (children→next row) — same spacing as SidebarMenu rows
+                      everywhere else. */}
+                  <SidebarGroupContent className="flex flex-col gap-0.5 pt-0.5">
+                    {mySpaces.length === 0 && (
+                      <button
+                        type="button"
+                        onClick={() => push(p.spaceNew())}
+                        className="flex h-8 cursor-pointer items-center rounded-md px-2 text-left text-xs text-muted-foreground transition-colors hover:bg-sidebar-accent/70 hover:text-sidebar-accent-foreground"
                       >
-                        <item.icon />
-                        <span>{t(($) => $.nav[item.labelKey])}</span>
-                        {item.key === "runtimes" && hasRuntimeUpdates && (
-                          <span className="ml-auto size-1.5 rounded-full bg-destructive" />
-                        )}
-                      </SidebarMenuButton>
-                    </SidebarMenuItem>
-                  );
-                })}
-              </SidebarMenu>
-            </SidebarGroupContent>
-          </SidebarGroup>
+                        {t(($) => $.sidebar.spaces_empty)}
+                      </button>
+                    )}
+                    <DndContext sensors={sensors} collisionDetection={closestCenter} measuring={spaceDragMeasuring} onDragStart={handleSpaceDragStart} onDragEnd={handleSpaceDragEnd} onDragCancel={handleSpaceDragCancel}>
+                      <SortableContext items={visibleSpaces.map((space) => space.id)} strategy={verticalListSortingStrategy}>
+                        {visibleSpaces.map((space) => (
+                          <SortableSpaceGroup
+                            key={space.id}
+                            forceCollapsed={spaceDragActive}
+                            space={space}
+                            pathname={pathname}
+                            buildHref={(pathKey, spaceKey) => p[pathKey](spaceKey)}
+                            detailHref={p.spaceDetail(space.key)}
+                          />
+                        ))}
+                      </SortableContext>
+                    </DndContext>
+                  </SidebarGroupContent>
+                </CollapsibleContent>
+              </SidebarGroup>
+            </Collapsible>
+
         </SidebarContent>
 
         <SidebarFooter className="p-2">
           <JoinDiscordCard />
-          <div className="flex justify-end">
+          <div className="flex items-center justify-end gap-1">
+            {/* Settings lives as a footer icon next to Help — it's a
+                low-frequency destination that doesn't earn a nav row. */}
+            <AppLink
+              href={p.settings()}
+              aria-label={t(($) => $.nav.settings)}
+              title={t(($) => $.nav.settings)}
+              className={cn(
+                "inline-flex size-7 items-center justify-center rounded-full text-muted-foreground transition-colors hover:bg-accent hover:text-foreground",
+                isNavActive(pathname, p.settings()) && "bg-accent text-foreground",
+              )}
+            >
+              <Settings className="size-4" />
+            </AppLink>
             <HelpLauncher />
           </div>
         </SidebarFooter>
diff --git a/packages/views/locales/en/autopilots.json b/packages/views/locales/en/autopilots.json
index 09d83a4603..a19ef22877 100644
--- a/packages/views/locales/en/autopilots.json
+++ b/packages/views/locales/en/autopilots.json
@@ -42,7 +42,7 @@
   "templates": {
     "daily_news": {
       "title": "Daily news digest",
-      "summary": "Search and summarize today's news for the team"
+      "summary": "Search and summarize today's news for the space"
     },
     "pr_review": {
       "title": "PR review reminder",
@@ -54,7 +54,7 @@
     },
     "weekly_progress": {
       "title": "Weekly progress report",
-      "summary": "Compile a weekly summary of team progress"
+      "summary": "Compile a weekly summary of space progress"
     },
     "dependency_audit": {
       "title": "Dependency audit",
@@ -273,7 +273,7 @@
     "section_output_mode": "Output mode",
     "section_subscribers": "Subscribers",
     "subscribers_hint": "Auto-subscribed to every issue this autopilot creates",
-    "subscribers_empty": "No subscribers — add a teammate to notify them on every run",
+    "subscribers_empty": "No subscribers — add a spacemate to notify them on every run",
     "subscribers_add": "Add subscriber",
     "subscribers_search_placeholder": "Search members by name…",
     "subscribers_no_results": "No matching members",
@@ -321,7 +321,9 @@
       "thursday": "Thursday",
       "friday": "Friday",
       "saturday": "Saturday"
-    }
+    },
+    "title_required": "Title is required",
+    "assignee_required": "An assignee is required — pick an agent or squad"
   },
   "trigger_config": {
     "frequencies": {
diff --git a/packages/views/locales/en/issues.json b/packages/views/locales/en/issues.json
index d126bf3331..164a0cfe1e 100644
--- a/packages/views/locales/en/issues.json
+++ b/packages/views/locales/en/issues.json
@@ -30,7 +30,7 @@
     "all_label": "All",
     "all_description": "All issues in this workspace",
     "members_label": "Members",
-    "members_description": "Issues assigned to team members",
+    "members_description": "Issues assigned to space members",
     "agents_label": "Agents",
     "agents_description": "Issues assigned to AI agents"
   },
@@ -41,10 +41,12 @@
     "no_labels": "No labels yet",
     "no_assignee": "No assignee",
     "no_project": "No project",
+    "all_spaces": "All spaces",
     "section_status": "Status",
     "section_priority": "Priority",
     "section_assignee": "Assignee",
     "section_creator": "Creator",
+    "section_space": "Space",
     "section_project": "Project",
     "section_label": "Label",
     "section_date": "Date",
@@ -199,6 +201,7 @@
     "pull_request_card_files_count_other": "{{count}} files",
     "pull_request_card_show_more": "Show {{count}} more",
     "pull_request_card_show_less": "Show less",
+    "prop_space": "Space",
     "prop_status": "Status",
     "prop_priority": "Priority",
     "prop_stage": "Stage",
@@ -420,6 +423,7 @@
     "updated_ago": "Updated {{time}}"
   },
   "actions": {
+    "space": "Space",
     "status": "Status",
     "priority": "Priority",
     "assignee": "Assignee",
diff --git a/packages/views/locales/en/layout.json b/packages/views/locales/en/layout.json
index 52917c162e..6c5c3d5321 100644
--- a/packages/views/locales/en/layout.json
+++ b/packages/views/locales/en/layout.json
@@ -3,6 +3,7 @@
     "inbox": "Inbox",
     "my_issues": "My Issues",
     "issues": "Issues",
+    "spaces": "Spaces",
     "projects": "Projects",
     "autopilots": "Autopilot",
     "agents": "Agents",
@@ -10,7 +11,8 @@
     "usage": "Usage",
     "runtimes": "Runtimes",
     "skills": "Skills",
-    "settings": "Settings"
+    "settings": "Settings",
+    "more": "More"
   },
   "help": {
     "trigger": "Help",
@@ -40,8 +42,10 @@
     "unread_overflow": "99+",
     "discord_card": {
       "title": "Join our Discord",
-      "description": "Chat with the team and other builders.",
+      "description": "Chat with the space and other builders.",
       "dismiss": "Dismiss"
-    }
+    },
+    "new_space": "New space",
+    "spaces_empty": "Create your first space"
   }
 }
diff --git a/packages/views/locales/en/modals.json b/packages/views/locales/en/modals.json
index 7090d816f1..79b9c6ed9d 100644
--- a/packages/views/locales/en/modals.json
+++ b/packages/views/locales/en/modals.json
@@ -8,7 +8,7 @@
   },
   "create_workspace": {
     "title": "Create a new workspace",
-    "description": "Workspaces are shared environments where teams can work on projects and issues."
+    "description": "Workspaces are shared environments where members can work on projects and issues."
   },
   "delete_issue": {
     "title": "Delete issue",
@@ -119,6 +119,8 @@
     "submitting": "Creating...",
     "toast_created": "Project created",
     "toast_failed": "Failed to create project",
+    "space_required": "Select at least one space",
+    "space_min_hint": "A project belongs to at least one space",
     "repos_pill": "Repos",
     "repos_pill_count_one": "{{count}} repo",
     "repos_pill_count_other": "{{count}} repos",
diff --git a/packages/views/locales/en/onboarding.json b/packages/views/locales/en/onboarding.json
index badd0ed107..7cf7cb6c14 100644
--- a/packages/views/locales/en/onboarding.json
+++ b/packages/views/locales/en/onboarding.json
@@ -4,7 +4,7 @@
   },
   "welcome": {
     "wordmark": "Welcome to Multica",
-    "headline_line1": "Your AI teammates,",
+    "headline_line1": "Your AI spacemates,",
     "headline_line2": "in",
     "headline_emphasis": "one workspace.",
     "lede": "Assign them work like you'd assign a colleague — they pick it up, update status, and comment when done.",
@@ -14,7 +14,7 @@
     "continue_on_web": "Continue on web",
     "start_exploring": "Start exploring",
     "skip_existing": "I've done this before",
-    "illustration_caption": "Every issue, every thread, every decision — shared by your team and agents.",
+    "illustration_caption": "Every issue, every thread, every decision — shared by your space and agents.",
     "illustration": {
       "card1_actor_name": "You",
       "card1_actor_initial": "N",
@@ -112,7 +112,7 @@
     "swap_title": "Swap anytime",
     "swap_body": "Each agent's runtime is just a setting. Change it whenever you want.",
     "add_more_title": "Add more later",
-    "add_more_body": "You can connect another computer for a teammate, or a dedicated one per agent.",
+    "add_more_body": "You can connect another computer for a spacemate, or a dedicated one per agent.",
     "learn_more": "Learn about agent runtimes →"
   },
   "cli_install": {
@@ -143,7 +143,7 @@
   },
   "step_agent": {
     "eyebrow": "Your first agent",
-    "headline": "Meet your first teammate.",
+    "headline": "Meet your first spacemate.",
     "lede_prefix": "Your answers point to a ",
     "lede_suffix": ". Pick whichever of the four fits you — each template ships ready to take its first issue. You can retune its instructions from the agent settings page later.",
     "footer_hint": "One agent is enough to start. Add more from the sidebar later.",
@@ -154,7 +154,7 @@
       "coding": {
         "label": "Coding Agent",
         "blurb": "Writes, refactors, and ships code. Reads your repo.",
-        "instructions": "You are a Coding Agent on a product team. Pick up coding issues — implement features, fix bugs, write tests, and open pull requests. Read the repository before you start, follow existing code conventions, and keep diffs focused. Ask for clarification when the acceptance criteria are ambiguous."
+        "instructions": "You are a Coding Agent on a product space. Pick up coding issues — implement features, fix bugs, write tests, and open pull requests. Read the repository before you start, follow existing code conventions, and keep diffs focused. Ask for clarification when the acceptance criteria are ambiguous."
       },
       "planning": {
         "label": "Planning Agent",
@@ -169,11 +169,11 @@
       "assistant": {
         "label": "Assistant",
         "blurb": "General-purpose. Good default when the task is unclear.",
-        "instructions": "You are a general-purpose teammate. Handle varied tasks — light coding, writing, research, planning — and stay pragmatic about scope. When the task is ambiguous, ask one clarifying question before diving in. Default to short, useful outputs over exhaustive ones."
+        "instructions": "You are a general-purpose spacemate. Handle varied tasks — light coding, writing, research, planning — and stay pragmatic about scope. When the task is ambiguous, ask one clarifying question before diving in. Default to short, useful outputs over exhaustive ones."
       }
     },
     "about_eyebrow": "What's an agent",
-    "about_headline": "An AI teammate that lives in your workspace.",
+    "about_headline": "An AI spacemate that lives in your workspace.",
     "about_body": "Agents show up in every assignee picker, just like any other colleague — except they can work 24/7 on whatever runtime you give them.",
     "ways_eyebrow": "Ways to work with an agent",
     "way_assign_title": "Assign it an issue",
@@ -184,7 +184,7 @@
     "way_chat_body": "Ask quick questions without creating an issue.",
     "way_autopilot_title": "Put it on Autopilot",
     "way_autopilot_body": "Daily triage, weekly digest, monthly audit — on a schedule.",
-    "add_more_hint": "Add more agents anytime. A small team of specialized agents beats one jack-of-all-trades.",
+    "add_more_hint": "Add more agents anytime. A small space of specialized agents beats one jack-of-all-trades.",
     "docs_link": "Creating your first agent →"
   },
   "welcome_after_onboarding": {
@@ -248,15 +248,12 @@
     "eyebrow_resume": "Pick up or start fresh",
     "headline_first": "Name your workspace.",
     "headline_resume": "Continue with {{name}}, or start another.",
-    "lede_first": "A workspace is where your issues, agents, and projects live. You can invite teammates or spin up more workspaces later.",
+    "lede_first": "A workspace is where your issues, agents, and projects live. You can invite spacemates or spin up more workspaces later.",
     "lede_resume": "Resume setup with the workspace you already have, or create a new one alongside it — you can belong to any number of workspaces.",
     "name_label": "Workspace name",
     "name_placeholder": "Acme Inc, My Lab, Side Projects…",
     "url_label": "URL",
     "slug_placeholder": "acme",
-    "issue_prefix_label": "Issue prefix",
-    "issue_prefix_prefix": "Issues will look like ",
-    "issue_prefix_suffix": ". You can change this later in settings.",
     "create_new_title": "Create a new workspace",
     "create_new_subtitle": "Start fresh — a separate space for a different side of your work.",
     "hint_opening": "Opening {{name}}.",
@@ -280,9 +277,9 @@
     "side_next_eyebrow": "What's next",
     "side_preview_name": "Your workspace",
     "side_preview_slug": "workspace",
-    "perk_assign": "Assign issues to agents like you would a teammate",
+    "perk_assign": "Assign issues to agents like you would a spacemate",
     "perk_chat": "Chat with any agent without creating an issue",
-    "perk_invite": "Invite teammates — they see only this workspace",
+    "perk_invite": "Invite spacemates — they see only this workspace",
     "perk_switch": "Switch to other workspaces anytime from the top-left",
     "next_runtime": "Connect a computer so your agents have somewhere to run",
     "next_agent": "Create Multica Helper from your connected runtime",
@@ -293,7 +290,7 @@
       "issues_label": "Issues",
       "issues_meta": "shared task board",
       "agents_label": "Agents",
-      "agents_meta": "your AI teammates",
+      "agents_meta": "your AI spacemates",
       "projects_label": "Projects",
       "projects_meta": "group related issues",
       "autopilot_label": "Autopilot",
@@ -330,7 +327,7 @@
     "empty_lede_prefix": "An agent runtime is an AI coding tool we connect to — like ",
     "empty_lede_suffix": ". Install one and refresh, or pick a path below.",
     "empty_skip_title": "Skip for now",
-    "empty_skip_subtitle": "Enter your workspace in read-only mode. Your agent can't run tasks until an agent runtime is connected on this computer — but you can still browse, plan, and invite teammates.",
+    "empty_skip_subtitle": "Enter your workspace in read-only mode. Your agent can't run tasks until an agent runtime is connected on this computer — but you can still browse, plan, and invite spacemates.",
     "empty_skip_action": "Skip",
     "empty_waitlist_title": "Use a cloud computer",
     "empty_waitlist_subtitle": "We'll run a computer for you in the cloud. Not live yet.",
diff --git a/packages/views/locales/en/projects.json b/packages/views/locales/en/projects.json
index e52c4dac68..410dc68301 100644
--- a/packages/views/locales/en/projects.json
+++ b/packages/views/locales/en/projects.json
@@ -25,6 +25,7 @@
     "status": "Status",
     "progress": "Progress",
     "lead": "Lead",
+    "spaces": "Spaces",
     "created": "Created",
     "issues": "Issues"
   },
diff --git a/packages/views/locales/en/spaces.json b/packages/views/locales/en/spaces.json
new file mode 100644
index 0000000000..17d1e83226
--- /dev/null
+++ b/packages/views/locales/en/spaces.json
@@ -0,0 +1,89 @@
+{
+  "page": {
+    "title": "Spaces",
+    "new_space": "New space",
+    "loading": "Loading spaces...",
+    "empty_title": "No spaces yet",
+    "create_first": "Create your first space"
+  },
+  "table": {
+    "key": "Identifier",
+    "name": "Name",
+    "issues": "Issues",
+    "state": "State",
+    "actions": "Actions"
+  },
+  "state": {
+    "active": "Active",
+    "archived": "Archived"
+  },
+  "actions": {
+    "edit": "Edit space",
+    "archive": "Archive space",
+    "cancel": "Cancel",
+    "save": "Save",
+    "saving": "Saving..."
+  },
+  "dialog": {
+    "create_title": "Create space",
+    "edit_title": "Edit space",
+    "member_search": "Search members…",
+    "member_search_empty": "No matching members",
+    "creator_row": "Creator · Lead",
+    "name_required": "Name is required",
+    "members_entry": "Members",
+    "member_count": "{{count}} selected"
+  },
+  "form": {
+    "name": "Name",
+    "name_placeholder": "Engineering",
+    "key": "Identifier",
+    "key_hint": "Numbers this space’s issues — e.g. ENG-123. 1-7 uppercase letters or numbers, starting with a letter.",
+    "key_reserved": "NEW is a reserved identifier — pick another one.",
+    "key_locked": "The identifier is locked because issues have already been created.",
+    "icon": "Icon",
+    "description": "Description",
+    "description_placeholder": "Add a description…",
+    "members": "Members",
+    "members_placeholder": "Add spacemates…",
+    "members_selected": "{{count}} spacemates selected",
+    "icon_name": "Icon & name",
+    "description_limit": "Up to {{max}} characters ({{count}} now)"
+  },
+  "picker": {
+    "placeholder": "Space",
+    "empty": "No active spaces",
+    "selected_count_one": "{{count}} space",
+    "selected_count_other": "{{count}} spaces"
+  },
+  "toast_created": "Space created",
+  "toast_updated": "Space updated",
+  "toast_archived": "Space archived",
+  "toast_archive_failed": "Failed to archive space",
+  "toast_save_failed": "Failed to save space",
+  "surface": {
+    "not_found": "Space not found"
+  },
+  "settings": {
+    "stats_title": "At a glance",
+    "stats_issues": "Issues",
+    "stats_projects": "Projects",
+    "stats_autopilots": "Autopilots",
+    "danger_title": "Danger zone",
+    "archive_hint": "Archiving stops new work; existing issues stay readable.",
+    "members": "Members",
+    "members_empty": "No members yet",
+    "archive_confirm_title": "Archive space?",
+    "archive_confirm_body": "Removing every member archives {{name}}. Existing issues stay readable.",
+    "last_space_cannot_archive": "A workspace must keep at least one space",
+    "archive_admin_only": "Only admins can archive a space",
+    "goto": "Go to"
+  },
+  "conflict": {
+    "title": "{{space}} is not part of the project",
+    "body": "The {{space}} space is not currently part of the {{project}} project. Add the space to the project, or move the issue to one of the project's spaces.",
+    "add_space": "Add {{space}} to the project",
+    "project_spaces": "Project spaces",
+    "move_issue": "Move issue to {{space}}"
+  }
+}
diff --git a/packages/views/locales/index.ts b/packages/views/locales/index.ts
index 7089d068a0..87a38283a8 100644
--- a/packages/views/locales/index.ts
+++ b/packages/views/locales/index.ts
@@ -14,6 +14,7 @@ import enSearch from "./en/search.json";
 import enInbox from "./en/inbox.json";
 import enWorkspace from "./en/workspace.json";
 import enProjects from "./en/projects.json";
+import enSpaces from "./en/spaces.json";
 import enAutopilots from "./en/autopilots.json";
 import enSkills from "./en/skills.json";
 import enChat from "./en/chat.json";
@@ -39,6 +40,7 @@ import zhHansSearch from "./zh-Hans/search.json";
 import zhHansInbox from "./zh-Hans/inbox.json";
 import zhHansWorkspace from "./zh-Hans/workspace.json";
 import zhHansProjects from "./zh-Hans/projects.json";
+import zhHansSpaces from "./zh-Hans/spaces.json";
 import zhHansAutopilots from "./zh-Hans/autopilots.json";
 import zhHansSkills from "./zh-Hans/skills.json";
 import zhHansChat from "./zh-Hans/chat.json";
@@ -64,6 +66,7 @@ import koSearch from "./ko/search.json";
 import koInbox from "./ko/inbox.json";
 import koWorkspace from "./ko/workspace.json";
 import koProjects from "./ko/projects.json";
+import koSpaces from "./ko/spaces.json";
 import koAutopilots from "./ko/autopilots.json";
 import koSkills from "./ko/skills.json";
 import koChat from "./ko/chat.json";
@@ -89,6 +92,7 @@ import jaSearch from "./ja/search.json";
 import jaInbox from "./ja/inbox.json";
 import jaWorkspace from "./ja/workspace.json";
 import jaProjects from "./ja/projects.json";
+import jaSpaces from "./ja/spaces.json";
 import jaAutopilots from "./ja/autopilots.json";
 import jaSkills from "./ja/skills.json";
 import jaChat from "./ja/chat.json";
@@ -120,6 +124,7 @@ export const RESOURCES: Record<SupportedLocale, LocaleResources> = {
     inbox: enInbox,
     workspace: enWorkspace,
     projects: enProjects,
+    spaces: enSpaces,
     autopilots: enAutopilots,
     skills: enSkills,
     chat: enChat,
@@ -147,6 +152,7 @@ export const RESOURCES: Record<SupportedLocale, LocaleResources> = {
     inbox: zhHansInbox,
     workspace: zhHansWorkspace,
     projects: zhHansProjects,
+    spaces: zhHansSpaces,
     autopilots: zhHansAutopilots,
     skills: zhHansSkills,
     chat: zhHansChat,
@@ -174,6 +180,7 @@ export const RESOURCES: Record<SupportedLocale, LocaleResources> = {
     inbox: koInbox,
     workspace: koWorkspace,
     projects: koProjects,
+    spaces: koSpaces,
     autopilots: koAutopilots,
     skills: koSkills,
     chat: koChat,
@@ -201,6 +208,7 @@ export const RESOURCES: Record<SupportedLocale, LocaleResources> = {
     inbox: jaInbox,
     workspace: jaWorkspace,
     projects: jaProjects,
+    spaces: jaSpaces,
     autopilots: jaAutopilots,
     skills: jaSkills,
     chat: jaChat,
diff --git a/packages/views/locales/ja/autopilots.json b/packages/views/locales/ja/autopilots.json
index 6e73b8a7a9..8cdab0ca47 100644
--- a/packages/views/locales/ja/autopilots.json
+++ b/packages/views/locales/ja/autopilots.json
@@ -321,7 +321,9 @@
       "thursday": "木曜日",
       "friday": "金曜日",
       "saturday": "土曜日"
-    }
+    },
+    "title_required": "タイトルが必要です",
+    "assignee_required": "実行者が必要です — エージェントまたはスクワッドを選択"
   },
   "trigger_config": {
     "frequencies": {
diff --git a/packages/views/locales/ja/issues.json b/packages/views/locales/ja/issues.json
index 945399f26f..813d7f7e1e 100644
--- a/packages/views/locales/ja/issues.json
+++ b/packages/views/locales/ja/issues.json
@@ -41,10 +41,12 @@
     "no_labels": "まだラベルがありません",
     "no_assignee": "担当者なし",
     "no_project": "プロジェクトなし",
+    "all_spaces": "すべての Space",
     "section_status": "ステータス",
     "section_priority": "優先度",
     "section_assignee": "担当者",
     "section_creator": "作成者",
+    "section_space": "Space",
     "section_project": "プロジェクト",
     "section_label": "ラベル",
     "section_date": "日付",
@@ -196,6 +198,7 @@
     "pull_request_card_files_count_other": "{{count}} ファイル",
     "pull_request_card_show_more": "他 {{count}} 件を表示",
     "pull_request_card_show_less": "折りたたむ",
+    "prop_space": "Space",
     "prop_status": "ステータス",
     "prop_priority": "優先度",
     "prop_stage": "ステージ",
@@ -400,6 +403,7 @@
     "updated_ago": "{{time}} に更新"
   },
   "actions": {
+    "space": "Space",
     "status": "ステータス",
     "priority": "優先度",
     "assignee": "担当者",
diff --git a/packages/views/locales/ja/layout.json b/packages/views/locales/ja/layout.json
index 76e85bc0fb..4e7ebc9902 100644
--- a/packages/views/locales/ja/layout.json
+++ b/packages/views/locales/ja/layout.json
@@ -3,6 +3,7 @@
     "inbox": "インボックス",
     "my_issues": "マイイシュー",
     "issues": "イシュー",
+    "spaces": "Space",
     "projects": "プロジェクト",
     "autopilots": "オートパイロット",
     "agents": "エージェント",
@@ -10,7 +11,8 @@
     "usage": "使用量",
     "runtimes": "ランタイム",
     "skills": "スキル",
-    "settings": "設定"
+    "settings": "設定",
+    "more": "その他"
   },
   "help": {
     "trigger": "ヘルプ",
@@ -42,6 +44,8 @@
       "title": "Discord に参加",
       "description": "チームや他のユーザーと交流しましょう。",
       "dismiss": "閉じる"
-    }
+    },
+    "new_space": "新しい Space",
+    "spaces_empty": "最初の Space を作成"
   }
 }
diff --git a/packages/views/locales/ja/modals.json b/packages/views/locales/ja/modals.json
index 18660e2548..f9716baef5 100644
--- a/packages/views/locales/ja/modals.json
+++ b/packages/views/locales/ja/modals.json
@@ -118,6 +118,8 @@
     "submitting": "作成中...",
     "toast_created": "プロジェクトを作成しました",
     "toast_failed": "プロジェクトを作成できませんでした",
+    "space_required": "Space を少なくとも1つ選択してください",
+    "space_min_hint": "プロジェクトは少なくとも 1 つの Space に属します",
     "repos_pill": "リポジトリ",
     "repos_pill_count_other": "{{count}} 個のリポジトリ",
     "repos_heading": "このプロジェクトに GitHub リポジトリを接続",
diff --git a/packages/views/locales/ja/onboarding.json b/packages/views/locales/ja/onboarding.json
index 47d339e13d..adb2fbaf03 100644
--- a/packages/views/locales/ja/onboarding.json
+++ b/packages/views/locales/ja/onboarding.json
@@ -254,9 +254,6 @@
     "name_placeholder": "Acme Inc、My Lab、Side Projects…",
     "url_label": "URL",
     "slug_placeholder": "acme",
-    "issue_prefix_label": "イシュープレフィックス",
-    "issue_prefix_prefix": "イシューは ",
-    "issue_prefix_suffix": " のように表示されます。あとで設定から変更できます。",
     "create_new_title": "新しいワークスペースを作成",
     "create_new_subtitle": "新しく始めましょう — 別の業務領域のための独立した場所です。",
     "hint_opening": "{{name}} を開いています。",
diff --git a/packages/views/locales/ja/projects.json b/packages/views/locales/ja/projects.json
index f8ad32ea28..a7127ad874 100644
--- a/packages/views/locales/ja/projects.json
+++ b/packages/views/locales/ja/projects.json
@@ -24,6 +24,7 @@
     "status": "ステータス",
     "progress": "進捗",
     "lead": "リード",
+    "spaces": "Space",
     "created": "作成日",
     "issues": "Issue 数"
   },
diff --git a/packages/views/locales/ja/spaces.json b/packages/views/locales/ja/spaces.json
new file mode 100644
index 0000000000..4842bc5e2e
--- /dev/null
+++ b/packages/views/locales/ja/spaces.json
@@ -0,0 +1,88 @@
+{
+  "page": {
+    "title": "Space",
+    "new_space": "新しい Space",
+    "loading": "Space を読み込み中...",
+    "empty_title": "Space はまだありません",
+    "create_first": "最初の Space を作成"
+  },
+  "table": {
+    "key": "識別子",
+    "name": "名前",
+    "issues": "イシュー",
+    "state": "状態",
+    "actions": "操作"
+  },
+  "state": {
+    "active": "アクティブ",
+    "archived": "アーカイブ済み"
+  },
+  "actions": {
+    "edit": "Space を編集",
+    "archive": "Space をアーカイブ",
+    "cancel": "キャンセル",
+    "save": "保存",
+    "saving": "保存中..."
+  },
+  "dialog": {
+    "create_title": "Space を作成",
+    "edit_title": "Space を編集",
+    "member_search": "メンバーを検索…",
+    "member_search_empty": "一致するメンバーはいません",
+    "creator_row": "作成者 · リード",
+    "name_required": "名前が必要です",
+    "members_entry": "メンバー",
+    "member_count": "{{count}} 人選択"
+  },
+  "form": {
+    "name": "名前",
+    "name_placeholder": "Engineering",
+    "key": "識別子",
+    "key_hint": "この Space の issue 番号に使われます（例: ENG-123）。1〜7 文字の大文字英数字、先頭は英字。",
+    "key_reserved": "NEW は予約済みの識別子です。別の識別子を選んでください。",
+    "key_locked": "issue が作成された後は識別子を変更できません。",
+    "icon": "アイコン",
+    "description": "説明",
+    "description_placeholder": "説明を追加…",
+    "members": "メンバー",
+    "members_placeholder": "メンバーを追加…",
+    "members_selected": "{{count}} 人を選択済み",
+    "icon_name": "アイコンと名前",
+    "description_limit": "最大 {{max}} 文字（現在 {{count}}）"
+  },
+  "picker": {
+    "placeholder": "Space",
+    "empty": "アクティブな Space はありません",
+    "selected_count_other": "{{count}} Space"
+  },
+  "toast_created": "Space を作成しました",
+  "toast_updated": "Space を更新しました",
+  "toast_archived": "Space をアーカイブしました",
+  "toast_archive_failed": "Space をアーカイブできませんでした",
+  "toast_save_failed": "Space を保存できませんでした",
+  "surface": {
+    "not_found": "Space が見つかりません"
+  },
+  "settings": {
+    "stats_title": "概況",
+    "stats_issues": "Issue",
+    "stats_projects": "プロジェクト",
+    "stats_autopilots": "自動化",
+    "danger_title": "危険な操作",
+    "archive_hint": "アーカイブすると新しい作業を受け付けません。既存の issue は閲覧できます。",
+    "members": "メンバー",
+    "members_empty": "メンバーはまだいません",
+    "archive_confirm_title": "Space をアーカイブしますか？",
+    "archive_confirm_body": "全メンバーを外すと {{name}} はアーカイブされます。既存の issue は閲覧できます。",
+    "last_space_cannot_archive": "ワークスペースには少なくとも 1 つの Space が必要です",
+    "archive_admin_only": "Space をアーカイブできるのは管理者のみです",
+    "goto": "移動"
+  },
+  "conflict": {
+    "title": "{{space}} はプロジェクトに含まれていません",
+    "body": "{{space}} Space はプロジェクト {{project}} にまだ含まれていません。Space をプロジェクトに追加するか、Issue をプロジェクトの Space に移動できます。",
+    "add_space": "{{space}} をプロジェクトに追加",
+    "project_spaces": "プロジェクトの Space",
+    "move_issue": "Issue を {{space}} に移動"
+  }
+}
diff --git a/packages/views/locales/ko/autopilots.json b/packages/views/locales/ko/autopilots.json
index 27bf73035b..1d825e59e1 100644
--- a/packages/views/locales/ko/autopilots.json
+++ b/packages/views/locales/ko/autopilots.json
@@ -321,7 +321,9 @@
       "thursday": "목요일",
       "friday": "금요일",
       "saturday": "토요일"
-    }
+    },
+    "title_required": "제목을 입력해야 합니다",
+    "assignee_required": "실행자를 선택해야 합니다 — 에이전트 또는 스쿼드 선택"
   },
   "trigger_config": {
     "frequencies": {
diff --git a/packages/views/locales/ko/issues.json b/packages/views/locales/ko/issues.json
index b212b2c49e..dd3e91aee7 100644
--- a/packages/views/locales/ko/issues.json
+++ b/packages/views/locales/ko/issues.json
@@ -41,10 +41,12 @@
     "no_labels": "아직 라벨이 없습니다",
     "no_assignee": "담당자 없음",
     "no_project": "프로젝트 없음",
+    "all_spaces": "모든 Space",
     "section_status": "상태",
     "section_priority": "우선순위",
     "section_assignee": "담당자",
     "section_creator": "생성자",
+    "section_space": "Space",
     "section_project": "프로젝트",
     "section_label": "라벨",
     "section_date": "날짜",
@@ -196,6 +198,7 @@
     "pull_request_card_files_count_other": "파일 {{count}}개",
     "pull_request_card_show_more": "{{count}}개 더 보기",
     "pull_request_card_show_less": "간단히 보기",
+    "prop_space": "Space",
     "prop_status": "상태",
     "prop_priority": "우선순위",
     "prop_stage": "단계",
@@ -400,6 +403,7 @@
     "updated_ago": "{{time}} 수정됨"
   },
   "actions": {
+    "space": "Space",
     "status": "상태",
     "priority": "우선순위",
     "assignee": "담당자",
diff --git a/packages/views/locales/ko/layout.json b/packages/views/locales/ko/layout.json
index 83b5c66ab0..67b959fe6b 100644
--- a/packages/views/locales/ko/layout.json
+++ b/packages/views/locales/ko/layout.json
@@ -3,6 +3,7 @@
     "inbox": "인박스",
     "my_issues": "내 이슈",
     "issues": "이슈",
+    "spaces": "Space",
     "projects": "프로젝트",
     "autopilots": "오토파일럿",
     "agents": "에이전트",
@@ -10,7 +11,8 @@
     "usage": "사용량",
     "runtimes": "런타임",
     "skills": "스킬",
-    "settings": "설정"
+    "settings": "설정",
+    "more": "더 보기"
   },
   "help": {
     "trigger": "도움말",
@@ -42,6 +44,8 @@
       "title": "Discord 참여하기",
       "description": "팀과 다른 사용자들과 교류해 보세요.",
       "dismiss": "닫기"
-    }
+    },
+    "new_space": "새 Space",
+    "spaces_empty": "첫 Space 만들기"
   }
 }
diff --git a/packages/views/locales/ko/modals.json b/packages/views/locales/ko/modals.json
index cd615317e7..0a863b8343 100644
--- a/packages/views/locales/ko/modals.json
+++ b/packages/views/locales/ko/modals.json
@@ -118,6 +118,8 @@
     "submitting": "만드는 중...",
     "toast_created": "프로젝트를 만들었습니다",
     "toast_failed": "프로젝트를 만들지 못했습니다",
+    "space_required": "Space를 하나 이상 선택하세요",
+    "space_min_hint": "프로젝트는 최소 한 개의 Space에 속해야 합니다",
     "repos_pill": "저장소",
     "repos_pill_count_other": "저장소 {{count}}개",
     "repos_heading": "이 프로젝트에 GitHub 저장소 연결",
diff --git a/packages/views/locales/ko/onboarding.json b/packages/views/locales/ko/onboarding.json
index 40e38a45fd..b44e5ae7de 100644
--- a/packages/views/locales/ko/onboarding.json
+++ b/packages/views/locales/ko/onboarding.json
@@ -254,9 +254,6 @@
     "name_placeholder": "Acme Inc, 내 연구실, 사이드 프로젝트...",
     "url_label": "URL",
     "slug_placeholder": "acme",
-    "issue_prefix_label": "이슈 접두사",
-    "issue_prefix_prefix": "이슈는 ",
-    "issue_prefix_suffix": "처럼 표시됩니다. 나중에 설정에서 바꿀 수 있습니다.",
     "create_new_title": "새 워크스페이스 만들기",
     "create_new_subtitle": "새로 시작합니다. 다른 업무 영역을 위한 별도 공간입니다.",
     "hint_opening": "{{name}} 여는 중.",
diff --git a/packages/views/locales/ko/projects.json b/packages/views/locales/ko/projects.json
index 9da75dbd22..264796f3ea 100644
--- a/packages/views/locales/ko/projects.json
+++ b/packages/views/locales/ko/projects.json
@@ -24,6 +24,7 @@
     "status": "상태",
     "progress": "진행률",
     "lead": "리드",
+    "spaces": "Space",
     "created": "생성일",
     "issues": "이슈 수"
   },
diff --git a/packages/views/locales/ko/spaces.json b/packages/views/locales/ko/spaces.json
new file mode 100644
index 0000000000..6b52695b99
--- /dev/null
+++ b/packages/views/locales/ko/spaces.json
@@ -0,0 +1,88 @@
+{
+  "page": {
+    "title": "Space",
+    "new_space": "새 Space",
+    "loading": "Space를 불러오는 중...",
+    "empty_title": "아직 Space가 없습니다",
+    "create_first": "첫 Space 만들기"
+  },
+  "table": {
+    "key": "식별자",
+    "name": "이름",
+    "issues": "이슈",
+    "state": "상태",
+    "actions": "작업"
+  },
+  "state": {
+    "active": "활성",
+    "archived": "보관됨"
+  },
+  "actions": {
+    "edit": "Space 편집",
+    "archive": "Space 보관",
+    "cancel": "취소",
+    "save": "저장",
+    "saving": "저장 중..."
+  },
+  "dialog": {
+    "create_title": "Space 만들기",
+    "edit_title": "Space 편집",
+    "member_search": "멤버 검색…",
+    "member_search_empty": "일치하는 멤버가 없습니다",
+    "creator_row": "생성자 · 리드",
+    "name_required": "이름을 입력해야 합니다",
+    "members_entry": "멤버",
+    "member_count": "{{count}}명 선택"
+  },
+  "form": {
+    "name": "이름",
+    "name_placeholder": "Engineering",
+    "key": "식별자",
+    "key_hint": "이 Space의 이슈 번호에 사용됩니다(예: ENG-123). 1-7자의 대문자 또는 숫자, 문자로 시작.",
+    "key_reserved": "NEW는 예약된 식별자입니다. 다른 식별자를 선택하세요.",
+    "key_locked": "이슈가 생성된 후에는 식별자를 변경할 수 없습니다.",
+    "icon": "아이콘",
+    "description": "설명",
+    "description_placeholder": "설명 추가…",
+    "members": "멤버",
+    "members_placeholder": "멤버 추가…",
+    "members_selected": "{{count}}명 선택됨",
+    "icon_name": "아이콘 및 이름",
+    "description_limit": "최대 {{max}}자(현재 {{count}}자)"
+  },
+  "picker": {
+    "placeholder": "Space",
+    "empty": "활성 Space가 없습니다",
+    "selected_count_other": "Space {{count}}개"
+  },
+  "toast_created": "Space를 만들었습니다",
+  "toast_updated": "Space를 업데이트했습니다",
+  "toast_archived": "Space를 보관했습니다",
+  "toast_archive_failed": "Space를 보관하지 못했습니다",
+  "toast_save_failed": "Space를 저장하지 못했습니다",
+  "surface": {
+    "not_found": "Space를 찾을 수 없습니다"
+  },
+  "settings": {
+    "stats_title": "현황",
+    "stats_issues": "이슈",
+    "stats_projects": "프로젝트",
+    "stats_autopilots": "자동화",
+    "danger_title": "위험 구역",
+    "archive_hint": "보관하면 새 작업을 받지 않습니다. 기존 이슈는 계속 볼 수 있습니다.",
+    "members": "멤버",
+    "members_empty": "아직 멤버가 없습니다",
+    "archive_confirm_title": "Space를 보관할까요?",
+    "archive_confirm_body": "모든 멤버를 제거하면 {{name}}이(가) 보관됩니다. 기존 이슈는 계속 볼 수 있습니다.",
+    "last_space_cannot_archive": "워크스페이스에는 최소 하나의 Space가 있어야 합니다",
+    "archive_admin_only": "관리자만 Space를 보관할 수 있습니다",
+    "goto": "이동"
+  },
+  "conflict": {
+    "title": "{{space}}은(는) 프로젝트에 속해 있지 않습니다",
+    "body": "{{space}} Space는 아직 {{project}} 프로젝트에 속해 있지 않습니다. Space를 프로젝트에 추가하거나 이슈를 프로젝트의 Space로 이동할 수 있습니다.",
+    "add_space": "{{space}}을(를) 프로젝트에 추가",
+    "project_spaces": "프로젝트 Space",
+    "move_issue": "이슈를 {{space}}(으)로 이동"
+  }
+}
diff --git a/packages/views/locales/zh-Hans/autopilots.json b/packages/views/locales/zh-Hans/autopilots.json
index 63a5be3aa1..3bd06fcf5f 100644
--- a/packages/views/locales/zh-Hans/autopilots.json
+++ b/packages/views/locales/zh-Hans/autopilots.json
@@ -321,7 +321,9 @@
       "thursday": "周四",
       "friday": "周五",
       "saturday": "周六"
-    }
+    },
+    "title_required": "需要填写标题",
+    "assignee_required": "需要选择执行者 —— 选择智能体或小队"
   },
   "trigger_config": {
     "frequencies": {
diff --git a/packages/views/locales/zh-Hans/issues.json b/packages/views/locales/zh-Hans/issues.json
index c9b10701a7..5d20e66833 100644
--- a/packages/views/locales/zh-Hans/issues.json
+++ b/packages/views/locales/zh-Hans/issues.json
@@ -41,10 +41,12 @@
     "no_labels": "还没有标签",
     "no_assignee": "无负责人",
     "no_project": "无项目",
+    "all_spaces": "所有空间",
     "section_status": "状态",
     "section_priority": "优先级",
     "section_assignee": "负责人",
     "section_creator": "创建者",
+    "section_space": "空间",
     "section_project": "项目",
     "section_label": "标签",
     "section_date": "日期",
@@ -196,6 +198,7 @@
     "pull_request_card_files_count_other": "{{count}} 个文件",
     "pull_request_card_show_more": "展开剩余 {{count}} 个",
     "pull_request_card_show_less": "收起",
+    "prop_space": "空间",
     "prop_status": "状态",
     "prop_priority": "优先级",
     "prop_stage": "阶段",
@@ -400,6 +403,7 @@
     "updated_ago": "更新于 {{time}}"
   },
   "actions": {
+    "space": "空间",
     "status": "状态",
     "priority": "优先级",
     "assignee": "负责人",
diff --git a/packages/views/locales/zh-Hans/layout.json b/packages/views/locales/zh-Hans/layout.json
index 1f41d69c86..969275dbe7 100644
--- a/packages/views/locales/zh-Hans/layout.json
+++ b/packages/views/locales/zh-Hans/layout.json
@@ -3,6 +3,7 @@
     "inbox": "收件箱",
     "my_issues": "我的 issue",
     "issues": "Issues",
+    "spaces": "空间",
     "projects": "项目",
     "autopilots": "自动化",
     "agents": "智能体",
@@ -10,7 +11,8 @@
     "usage": "用量",
     "runtimes": "运行时",
     "skills": "Skills",
-    "settings": "设置"
+    "settings": "设置",
+    "more": "更多"
   },
   "help": {
     "trigger": "帮助",
@@ -42,6 +44,8 @@
       "title": "加入我们的 Discord",
       "description": "和团队及其他用户一起交流。",
       "dismiss": "关闭"
-    }
+    },
+    "new_space": "新建空间",
+    "spaces_empty": "新建第一个空间"
   }
 }
diff --git a/packages/views/locales/zh-Hans/modals.json b/packages/views/locales/zh-Hans/modals.json
index 3e47eddc0a..f02ad8957f 100644
--- a/packages/views/locales/zh-Hans/modals.json
+++ b/packages/views/locales/zh-Hans/modals.json
@@ -118,6 +118,8 @@
     "submitting": "创建中...",
     "toast_created": "已创建项目",
     "toast_failed": "创建项目失败",
+    "space_required": "请至少选择一个空间",
+    "space_min_hint": "项目至少属于一个空间",
     "repos_pill": "代码仓库",
     "repos_pill_count_other": "{{count}} 个仓库",
     "repos_heading": "为此项目关联 GitHub 仓库",
diff --git a/packages/views/locales/zh-Hans/onboarding.json b/packages/views/locales/zh-Hans/onboarding.json
index fdd2d760da..c368aea256 100644
--- a/packages/views/locales/zh-Hans/onboarding.json
+++ b/packages/views/locales/zh-Hans/onboarding.json
@@ -254,9 +254,6 @@
     "name_placeholder": "Acme Inc、我的实验室、副业...",
     "url_label": "URL",
     "slug_placeholder": "acme",
-    "issue_prefix_label": "issue 前缀",
-    "issue_prefix_prefix": "issue 编号会形如 ",
-    "issue_prefix_suffix": "。之后可以在设置里修改。",
     "create_new_title": "创建一个新工作区",
     "create_new_subtitle": "重新开始 —— 给工作的另一面留一个独立空间。",
     "hint_opening": "正在打开 {{name}}。",
diff --git a/packages/views/locales/zh-Hans/projects.json b/packages/views/locales/zh-Hans/projects.json
index 7fed25b6d3..7937ade3a7 100644
--- a/packages/views/locales/zh-Hans/projects.json
+++ b/packages/views/locales/zh-Hans/projects.json
@@ -24,6 +24,7 @@
     "status": "状态",
     "progress": "进度",
     "lead": "负责人",
+    "spaces": "空间",
     "created": "创建时间",
     "issues": "Issue 数"
   },
diff --git a/packages/views/locales/zh-Hans/spaces.json b/packages/views/locales/zh-Hans/spaces.json
new file mode 100644
index 0000000000..5f08a52155
--- /dev/null
+++ b/packages/views/locales/zh-Hans/spaces.json
@@ -0,0 +1,88 @@
+{
+  "page": {
+    "title": "空间",
+    "new_space": "新建空间",
+    "loading": "正在加载空间...",
+    "empty_title": "还没有空间",
+    "create_first": "创建第一个空间"
+  },
+  "table": {
+    "key": "标识符",
+    "name": "名称",
+    "issues": "Issues",
+    "state": "状态",
+    "actions": "操作"
+  },
+  "state": {
+    "active": "启用",
+    "archived": "已归档"
+  },
+  "actions": {
+    "edit": "编辑空间",
+    "archive": "归档空间",
+    "cancel": "取消",
+    "save": "保存",
+    "saving": "保存中..."
+  },
+  "dialog": {
+    "create_title": "创建空间",
+    "edit_title": "编辑空间",
+    "member_search": "搜索成员…",
+    "member_search_empty": "没有匹配的成员",
+    "creator_row": "创建人 · 负责人",
+    "name_required": "需要填写名称",
+    "members_entry": "成员",
+    "member_count": "已选 {{count}} 人"
+  },
+  "form": {
+    "name": "名称",
+    "name_placeholder": "Engineering",
+    "key": "标识符",
+    "key_hint": "用于该空间的 issue 编号，例如 ENG-123。1-7 位大写字母或数字，字母开头。",
+    "key_reserved": "NEW 是保留标识符，请换一个。",
+    "key_locked": "已有 issue 创建后，标识符会被锁定。",
+    "icon": "图标",
+    "description": "描述",
+    "description_placeholder": "添加描述…",
+    "members": "成员",
+    "members_placeholder": "添加同事…",
+    "members_selected": "已选 {{count}} 位同事",
+    "icon_name": "图标与名称",
+    "description_limit": "最多 {{max}} 个字符（当前 {{count}}）"
+  },
+  "picker": {
+    "placeholder": "空间",
+    "empty": "没有可用的空间",
+    "selected_count_other": "已选 {{count}} 个空间"
+  },
+  "toast_created": "空间已创建",
+  "toast_updated": "空间已更新",
+  "toast_archived": "空间已归档",
+  "toast_archive_failed": "归档空间失败",
+  "toast_save_failed": "保存空间失败",
+  "surface": {
+    "not_found": "未找到空间"
+  },
+  "settings": {
+    "stats_title": "概况",
+    "stats_issues": "Issues",
+    "stats_projects": "项目",
+    "stats_autopilots": "自动化",
+    "danger_title": "危险区",
+    "archive_hint": "归档后停止接收新工作;已有 issue 仍可查看。",
+    "members": "成员",
+    "members_empty": "暂无成员",
+    "archive_confirm_title": "归档空间？",
+    "archive_confirm_body": "移除全部成员将归档 {{name}}。已有 issue 仍可查看。",
+    "last_space_cannot_archive": "工作区必须至少保留一个空间",
+    "archive_admin_only": "只有管理员可以归档空间",
+    "goto": "前往"
+  },
+  "conflict": {
+    "title": "{{space}} 不在该项目中",
+    "body": "空间 {{space}} 尚未加入项目 {{project}}。可以把空间加入项目，或把 issue 改到项目已有的空间。",
+    "add_space": "把 {{space}} 加入项目",
+    "project_spaces": "项目的空间",
+    "move_issue": "把 issue 改到 {{space}}"
+  }
+}
diff --git a/packages/views/modals/create-issue.tsx b/packages/views/modals/create-issue.tsx
index 772806f891..f8055a4216 100644
--- a/packages/views/modals/create-issue.tsx
+++ b/packages/views/modals/create-issue.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { useState, useRef, useEffect } from "react";
+import { useState, useRef, useEffect, useMemo } from "react";
 import { useQuery } from "@tanstack/react-query";
 import { useNavigation } from "../navigation";
 import {
@@ -39,14 +39,20 @@ import { ContentEditor, type ContentEditorRef, TitleEditor, useFileDropZone, Fil
 import { StatusIcon, StatusPicker, PriorityPicker, StagePicker, AssigneePicker, StartDatePicker, DueDatePicker, LabelPicker } from "../issues/components";
 import { maxSiblingStage } from "../issues/components/pickers/stage-picker";
 import { ProjectPicker } from "../projects/components/project-picker";
+import { SpacePicker } from "../spaces/components/space-picker";
+import { SpaceProjectConflictDialog } from "../spaces/components/space-project-conflict-dialog";
 import { useIssueTriggerPreview } from "../issues/hooks/use-issue-trigger-preview";
 import { useActorName } from "@multica/core/workspace/hooks";
-import { useCurrentWorkspace, useWorkspacePaths } from "@multica/core/paths";
+import { useWorkspacePaths } from "@multica/core/paths";
 import { useWorkspaceId } from "@multica/core/hooks";
 import { useIssueDraftStore } from "@multica/core/issues/stores/draft-store";
 import { useCreateModeStore } from "@multica/core/issues/stores/create-mode-store";
 import { useQuickCreateStore } from "@multica/core/issues/stores/quick-create-store";
 import { issueDetailOptions, childIssuesOptions } from "@multica/core/issues/queries";
+import { projectListOptions } from "@multica/core/projects/queries";
+import { activeSpaceListOptions } from "@multica/core/spaces/queries";
+import { resolveCreationSpaceId } from "@multica/core/spaces/default-space";
+import { useLastSpaceStore } from "@multica/core/spaces/last-space-store";
 import { useCreateIssue, useUpdateIssue } from "@multica/core/issues/mutations";
 import { useAttachLabelToIssue } from "@multica/core/labels";
 import { useFileUpload } from "@multica/core/hooks/use-file-upload";
@@ -192,7 +198,6 @@ export function ManualCreatePanel({
   const { t } = useT("modals");
   const router = useNavigation();
   const p = useWorkspacePaths();
-  const workspaceName = useCurrentWorkspace()?.name;
 
   const draft = useIssueDraftStore((s) => s.draft);
   const setDraft = useIssueDraftStore((s) => s.setDraft);
@@ -229,6 +234,9 @@ export function ManualCreatePanel({
   const [projectId, setProjectId] = useState<string | undefined>(
     (data?.project_id as string) || undefined,
   );
+  const [spaceId, setSpaceId] = useState<string | undefined>(
+    (data?.space_id as string) || undefined,
+  );
   const [parentIssueId, setParentIssueId] = useState<string | undefined>(
     (data?.parent_issue_id as string) || undefined,
   );
@@ -265,6 +273,23 @@ export function ManualCreatePanel({
     enabled: !!parentIssueId,
   });
 
+  const { data: projects = [] } = useQuery(projectListOptions(wsId));
+  const selectedProject = useMemo(
+    () => projects.find((p) => p.id === projectId) ?? null,
+    [projects, projectId],
+  );
+  // Every issue belongs to exactly one space, so the picker always resolves to
+  // a value. Associations are creation-time defaults, never constraints:
+  // explicit pick → parent's space → single-space project → last used → personal default.
+  const { data: spaces = [] } = useQuery(activeSpaceListOptions(wsId));
+  const lastSpaceId = useLastSpaceStore((s) => s.lastSpaceId);
+  const setLastSpaceId = useLastSpaceStore((s) => s.setLastSpaceId);
+  const parentSpaceId = parentIssueId ? parentIssue?.space_id ?? undefined : undefined;
+  const projectSpaceId =
+    selectedProject?.space_ids?.length === 1 ? selectedProject.space_ids[0] : undefined;
+  const effectiveSpaceId =
+    spaceId ?? resolveCreationSpaceId(spaces, { parentSpaceId, projectSpaceId, lastSpaceId });
+
   const draftAttachments = draft.attachments ?? [];
 
   // Prune draft attachments whose markdown reference was deleted in an
@@ -320,6 +345,7 @@ export function ManualCreatePanel({
     setDueDate(null);
     setLabelIds([]);
     setProjectId(undefined);
+    setSpaceId(undefined);
     setParentIssueId(undefined);
     setStage(null);
     setChildIssues([]);
@@ -339,7 +365,29 @@ export function ManualCreatePanel({
     setFormResetKey((key) => key + 1);
   };
 
+  // Linear-style interception: space ∉ project's space set pauses the submit
+  // behind a resolution dialog. "Add to project" proceeds unchanged (the
+  // server adds the association), "move" retargets the issue's space first.
+  const spaceProjectConflict = useMemo(() => {
+    if (!selectedProject || !effectiveSpaceId) return null;
+    const ids = selectedProject.space_ids ?? [];
+    if (ids.length === 0 || ids.includes(effectiveSpaceId)) return null;
+    const space = spaces.find((tm) => tm.id === effectiveSpaceId);
+    if (!space) return null;
+    return { space, projectSpaces: spaces.filter((tm) => ids.includes(tm.id)) };
+  }, [selectedProject, effectiveSpaceId, spaces]);
+  const [conflictOpen, setConflictOpen] = useState(false);
+
   const handleSubmit = async () => {
+    if (!title.trim() || submitting) return;
+    if (spaceProjectConflict) {
+      setConflictOpen(true);
+      return;
+    }
+    await doSubmit(effectiveSpaceId);
+  };
+
+  const doSubmit = async (finalSpaceId: string | undefined) => {
     if (!title.trim() || submitting) return;
     setSubmitting(true);
     try {
@@ -358,10 +406,12 @@ export function ManualCreatePanel({
         due_date: dueDate || undefined,
         attachment_ids: activeAttachmentIds.length > 0 ? activeAttachmentIds : undefined,
         parent_issue_id: parentIssueId,
+        space_id: finalSpaceId,
         // Stage is only meaningful for a sub-issue (relative to its siblings).
         stage: parentIssueId && stage != null ? stage : undefined,
         project_id: projectId,
       });
+      setLastSpaceId(finalSpaceId ?? null);
 
       // Link queued children to the new parent. Deferred to after create
       // because the new issue's ID doesn't exist yet. Partial failures don't
@@ -551,6 +601,7 @@ export function ManualCreatePanel({
           ? { squad_id: assigneeId }
           : {}),
       ...(projectId ? { project_id: projectId } : {}),
+      ...(effectiveSpaceId ? { space_id: effectiveSpaceId } : {}),
       ...(parentIssueId ? { parent_issue_id: parentIssueId } : {}),
       ...(carryParentIdentifier ? { parent_issue_identifier: carryParentIdentifier } : {}),
     });
@@ -563,7 +614,14 @@ export function ManualCreatePanel({
             {/* Header */}
             <div className="flex items-center justify-between px-5 pt-3 pb-2 shrink-0">
               <div className="flex items-center gap-1.5 text-xs">
-                <span className="text-muted-foreground">{workspaceName}</span>
+                {/* The issue's space namespace — leads the breadcrumb like the
+                    workspace name used to, but as a required single-select. */}
+                <SpacePicker
+                  spaceId={effectiveSpaceId ?? null}
+                  onChange={setSpaceId}
+                  triggerRender={<PillButton />}
+                  align="start"
+                />
                 <ChevronRight className="size-3 text-muted-foreground/50" />
                 <span className="font-medium">{t(($) => $.create_issue.manual_breadcrumb)}</span>
               </div>
@@ -900,6 +958,24 @@ export function ManualCreatePanel({
                 )}
               </div>
             </div>
+      {spaceProjectConflict && (
+        <SpaceProjectConflictDialog
+          open={conflictOpen}
+          spaceName={spaceProjectConflict.space.name}
+          projectName={selectedProject?.title ?? ""}
+          projectSpaces={spaceProjectConflict.projectSpaces}
+          onAddSpace={() => {
+            setConflictOpen(false);
+            void doSubmit(effectiveSpaceId);
+          }}
+          onMoveToSpace={(tid) => {
+            setConflictOpen(false);
+            setSpaceId(tid);
+            void doSubmit(tid);
+          }}
+          onCancel={() => setConflictOpen(false)}
+        />
+      )}
     </>
   );
 }
diff --git a/packages/views/modals/create-project.test.tsx b/packages/views/modals/create-project.test.tsx
index 9f3004facb..32ed5743fe 100644
--- a/packages/views/modals/create-project.test.tsx
+++ b/packages/views/modals/create-project.test.tsx
@@ -11,6 +11,7 @@ const webRepoUrl = "https://github.com/multica-ai/web";
 
 vi.mock("@tanstack/react-query", () => ({
   useQuery: () => ({ data: [] }),
+  queryOptions: (options: unknown) => options,
 }));
 
 vi.mock("@multica/core/projects/mutations", () => ({
diff --git a/packages/views/modals/create-project.tsx b/packages/views/modals/create-project.tsx
index d443a9c096..c592f7320c 100644
--- a/packages/views/modals/create-project.tsx
+++ b/packages/views/modals/create-project.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { useState, useRef } from "react";
+import { useEffect, useMemo, useState, useRef } from "react";
 import { ChevronRight, FolderOpen, Maximize2, Minimize2, Search, X as XIcon, UserMinus } from "lucide-react";
 
 /**
@@ -30,6 +30,9 @@ import {
   PROJECT_PRIORITY_ORDER,
 } from "@multica/core/projects/config";
 import { useWorkspaceId } from "@multica/core/hooks";
+import { activeSpaceListOptions } from "@multica/core/spaces/queries";
+import { resolveCreationSpaceId } from "@multica/core/spaces/default-space";
+import { useLastSpaceStore } from "@multica/core/spaces/last-space-store";
 import { useCurrentWorkspace, useWorkspacePaths } from "@multica/core/paths";
 import { memberListOptions, agentListOptions } from "@multica/core/workspace/queries";
 import { useActorName } from "@multica/core/workspace/hooks";
@@ -50,6 +53,7 @@ import { EmojiPicker } from "@multica/ui/components/common/emoji-picker";
 import { ContentEditor, type ContentEditorRef, TitleEditor } from "../editor";
 import { PriorityIcon } from "../issues/components/priority-icon";
 import { ActorAvatar } from "../common/actor-avatar";
+import { SpaceMultiPicker } from "../spaces/components/space-picker";
 import { useNavigation } from "../navigation";
 import { useT } from "../i18n";
 import { matchesPinyin } from "../editor/extensions/pinyin-match";
@@ -110,15 +114,23 @@ function RepoUrlText({
   );
 }
 
-export function CreateProjectModal({ onClose }: { onClose: () => void }) {
+export function CreateProjectModal({
+  onClose,
+  data,
+}: {
+  onClose: () => void;
+  /** `space_id`: the space the modal was opened from (e.g. a space's Projects
+   *  page) — pre-selects that space instead of the personal default. */
+  data?: Record<string, unknown> | null;
+}) {
   const { t } = useT("modals");
   const router = useNavigation();
   const workspace = useCurrentWorkspace();
-  const workspaceName = workspace?.name;
   const wsPaths = useWorkspacePaths();
   const wsId = useWorkspaceId();
   const { data: members = [] } = useQuery(memberListOptions(wsId));
   const { data: agents = [] } = useQuery(agentListOptions(wsId));
+  const { data: spaces = [] } = useQuery(activeSpaceListOptions(wsId));
   const { getActorName } = useActorName();
   const projectStatusLabels = useProjectStatusLabels();
   const projectPriorityLabels = useProjectPriorityLabels();
@@ -133,6 +145,7 @@ export function CreateProjectModal({ onClose }: { onClose: () => void }) {
   const [priority, setPriority] = useState<ProjectPriority>(draft.priority);
   const [leadType, setLeadType] = useState<"member" | "agent" | undefined>(draft.leadType);
   const [leadId, setLeadId] = useState<string | undefined>(draft.leadId);
+  const [spaceIds, setSpaceIds] = useState<string[]>([]);
   const [icon, setIcon] = useState<string | undefined>(draft.icon);
   const [iconPickerOpen, setIconPickerOpen] = useState(false);
   const [submitting, setSubmitting] = useState(false);
@@ -222,13 +235,45 @@ export function CreateProjectModal({ onClose }: { onClose: () => void }) {
     (a) => !a.archived_at && (a.name.toLowerCase().includes(leadQuery) || matchesPinyin(a.name, leadQuery)),
   );
 
+  // Seed the default space exactly once, when spaces first load. Guarding only
+  // on `spaceIds.length` re-seeded the moment the user cleared the selection,
+  // fighting the deselection; the ref makes seeding a one-shot so clearing
+  // sticks.
+  const contextSpaceId = (data?.space_id as string) || undefined;
+  const lastSpaceId = useLastSpaceStore((s) => s.lastSpaceId);
+  const setLastSpaceId = useLastSpaceStore((s) => s.setLastSpaceId);
+  const seededDefaultSpaceRef = useRef(false);
+  useEffect(() => {
+    if (seededDefaultSpaceRef.current || spaces.length === 0) return;
+    seededDefaultSpaceRef.current = true;
+    if (spaceIds.length > 0) return;
+    // The space the modal was opened from wins (e.g. a space's Projects
+    // page); otherwise the same shared fallback as the issue/quick-create/
+    // autopilot forms: last space used, then my first space.
+    const defaultSpaceId = contextSpaceId ?? resolveCreationSpaceId(spaces, { lastSpaceId });
+    if (defaultSpaceId) setSpaceIds([defaultSpaceId]);
+  }, [spaceIds.length, spaces, contextSpaceId, lastSpaceId]);
+
   const leadLabel =
     leadType && leadId ? getActorName(leadType, leadId) : t(($) => $.create_project.lead);
 
+  // A project always keeps at least one space (server rule) — otherwise it
+  // would vanish from every space's Projects page. Single source for the
+  // inline hint, the disabled submit button, and the submit guard; moot
+  // while the workspace has no spaces loaded yet.
+  const spaceSelectionMissing = useMemo(
+    () => spaces.length > 0 && spaceIds.length === 0,
+    [spaces.length, spaceIds.length],
+  );
+
   const createProject = useCreateProject();
 
   const handleSubmit = async () => {
     if (!title.trim() || submitting) return;
+    if (spaceSelectionMissing) {
+      toast.error(t(($) => $.create_project.space_required));
+      return;
+    }
     // `sourceMode` decides which side's stash gets persisted — the other
     // side is silently dropped, so repos picked then abandoned for local
     // mode don't leak into the project.
@@ -266,9 +311,13 @@ export function CreateProjectModal({ onClose }: { onClose: () => void }) {
         priority,
         lead_type: leadType,
         lead_id: leadId,
+        space_ids: spaceIds.length > 0 ? spaceIds : undefined,
         // Server attaches these in the same transaction as the project.
         resources,
       });
+      // A project can span multiple spaces; the first selected one stands in
+      // as "primary" for the shared last-used memory.
+      if (spaceIds[0]) setLastSpaceId(spaceIds[0]);
       clearDraft();
       onClose();
       toast.success(t(($) => $.create_project.toast_created));
@@ -314,7 +363,15 @@ export function CreateProjectModal({ onClose }: { onClose: () => void }) {
 
         <div className="flex items-center justify-between px-5 pt-3 pb-2 shrink-0">
           <div className="flex items-center gap-1.5 text-xs">
-            <span className="text-muted-foreground">{workspaceName}</span>
+            {/* Owning spaces lead the breadcrumb — same slot as the issue
+                modal's space picker, multi-select since projects can span
+                spaces. */}
+            <SpaceMultiPicker
+              spaceIds={spaceIds}
+              onChange={setSpaceIds}
+              triggerRender={<PillButton />}
+              align="start"
+            />
             <ChevronRight className="size-3 text-muted-foreground/50" />
             <span className="font-medium">{t(($) => $.create_project.title_breadcrumb)}</span>
           </div>
@@ -354,6 +411,14 @@ export function CreateProjectModal({ onClose }: { onClose: () => void }) {
           </div>
         </div>
 
+        {/* At-least-one-space nudge on its own line, aligned under the space
+            picker; the submit button disables on the same condition. */}
+        {spaceSelectionMissing && (
+          <div className="px-5 -mt-1 pb-1 text-[11px] text-destructive/80 shrink-0">
+            {t(($) => $.create_project.space_min_hint)}
+          </div>
+        )}
+
         <div className="px-5 pb-2 shrink-0">
           <Popover open={iconPickerOpen} onOpenChange={setIconPickerOpen}>
             <PopoverTrigger
@@ -794,7 +859,7 @@ export function CreateProjectModal({ onClose }: { onClose: () => void }) {
           <Button
             size="sm"
             onClick={handleSubmit}
-            disabled={!title.trim() || submitting}
+            disabled={!title.trim() || submitting || spaceSelectionMissing}
             className="shrink-0"
           >
             {submitting ? t(($) => $.create_project.submitting) : t(($) => $.create_project.submit)}
diff --git a/packages/views/modals/quick-create-issue.test.tsx b/packages/views/modals/quick-create-issue.test.tsx
index c8380034b9..7046037b99 100644
--- a/packages/views/modals/quick-create-issue.test.tsx
+++ b/packages/views/modals/quick-create-issue.test.tsx
@@ -63,6 +63,7 @@ vi.mock("@tanstack/react-query", () => ({
         return { data: [] };
     }
   },
+  queryOptions: (options: unknown) => options,
 }));
 
 vi.mock("@multica/core/api", () => ({
diff --git a/packages/views/modals/quick-create-issue.tsx b/packages/views/modals/quick-create-issue.tsx
index ed0673bc48..867c0a87e8 100644
--- a/packages/views/modals/quick-create-issue.tsx
+++ b/packages/views/modals/quick-create-issue.tsx
@@ -9,9 +9,12 @@ import { Button } from "@multica/ui/components/ui/button";
 import { Switch } from "@multica/ui/components/ui/switch";
 import { api, ApiError } from "@multica/core/api";
 import { useWorkspaceId } from "@multica/core/hooks";
-import { useCurrentWorkspace } from "@multica/core/paths";
 import { agentListOptions, squadListOptions } from "@multica/core/workspace/queries";
 import { projectListOptions } from "@multica/core/projects/queries";
+import { activeSpaceListOptions } from "@multica/core/spaces/queries";
+import { resolveCreationSpaceId } from "@multica/core/spaces/default-space";
+import { useLastSpaceStore } from "@multica/core/spaces/last-space-store";
+import { issueDetailOptions } from "@multica/core/issues/queries";
 import {
   useQuickCreateStore,
   type QuickCreateActorType,
@@ -30,6 +33,8 @@ import { contentReferencesAttachment, type Agent, type Attachment, type Squad }
 import { ActorAvatar } from "../common/actor-avatar";
 import { PillButton } from "../common/pill-button";
 import { ProjectPicker } from "../projects/components/project-picker";
+import { SpacePicker } from "../spaces/components/space-picker";
+import { SpaceProjectConflictDialog } from "../spaces/components/space-project-conflict-dialog";
 import { canAssignAgent } from "../issues/components/pickers/assignee-picker";
 import {
   PropertyPicker,
@@ -82,7 +87,6 @@ export function AgentCreatePanel({
   setIsExpanded: (v: boolean) => void;
 }) {
   const { t } = useT("modals");
-  const workspaceName = useCurrentWorkspace()?.name;
   const wsId = useWorkspaceId();
   const userId = useAuthStore((s) => s.user?.id);
   const { data: members = [] } = useQuery(memberListOptions(wsId));
@@ -200,6 +204,9 @@ export function AgentCreatePanel({
     const seed = (data?.project_id as string | undefined) ?? lastProjectId;
     return seed ?? null;
   });
+  const [spaceId, setSpaceId] = useState<string | null>(
+    (data?.space_id as string | undefined) ?? null,
+  );
 
   // Parent-issue context — seeded by `openCreateSubIssue` when the modal is
   // opened from the "Add sub issue" entry on an existing issue. We carry it
@@ -211,6 +218,29 @@ export function AgentCreatePanel({
   const parentIssueIdentifier =
     (data?.parent_issue_identifier as string | undefined) ?? undefined;
 
+  // Every issue belongs to exactly one space, so the header picker always
+  // resolves to a value. Associations are creation-time defaults, never
+  // constraints: explicit pick → parent's space → single-space project →
+  // last used → personal default.
+  const { data: spaces = [] } = useQuery(activeSpaceListOptions(wsId));
+  const lastSpaceId = useLastSpaceStore((s) => s.lastSpaceId);
+  const setLastSpaceId = useLastSpaceStore((s) => s.setLastSpaceId);
+  const { data: parentIssue } = useQuery({
+    ...issueDetailOptions(wsId, parentIssueId ?? ""),
+    enabled: !!parentIssueId,
+  });
+  const parentSpaceId = parentIssueId ? parentIssue?.space_id ?? undefined : undefined;
+  const selectedProject = useMemo(
+    () => projects.find((p) => p.id === projectId) ?? null,
+    [projects, projectId],
+  );
+  const projectSpaceId =
+    selectedProject?.space_ids?.length === 1 ? selectedProject.space_ids[0] : undefined;
+  const effectiveSpaceId =
+    spaceId ??
+    resolveCreationSpaceId(spaces, { parentSpaceId, projectSpaceId, lastSpaceId }) ??
+    null;
+
   // Stale-id sweep. Once the project list query has actually resolved
   // (`isSuccess` — distinct from "data is the empty default during loading"),
   // a `projectId` that isn't in the list means the project was deleted in
@@ -284,7 +314,27 @@ export function AgentCreatePanel({
     return () => cancelAnimationFrame(id);
   }, []);
 
+  // Linear-style interception: space ∉ project's space set pauses the submit
+  // behind a resolution dialog (see SpaceProjectConflictDialog).
+  const spaceProjectConflict = useMemo(() => {
+    if (!selectedProject || !effectiveSpaceId) return null;
+    const ids = selectedProject.space_ids ?? [];
+    if (ids.length === 0 || ids.includes(effectiveSpaceId)) return null;
+    const space = spaces.find((tm) => tm.id === effectiveSpaceId);
+    if (!space) return null;
+    return { space, projectSpaces: spaces.filter((tm) => ids.includes(tm.id)) };
+  }, [selectedProject, effectiveSpaceId, spaces]);
+  const [conflictOpen, setConflictOpen] = useState(false);
+
   const submit = async () => {
+    if (spaceProjectConflict) {
+      setConflictOpen(true);
+      return;
+    }
+    await doSubmit(effectiveSpaceId);
+  };
+
+  const doSubmit = async (finalSpaceId: string | null) => {
     const md = editorRef.current?.getMarkdown()?.trim() ?? "";
     if (!md || !actor || submitting || versionBlocked || uploading) return;
     // Belt-and-suspenders against the multi-file upload race fixed in
@@ -306,12 +356,14 @@ export function AgentCreatePanel({
           ? { agent_id: actor.id }
           : { squad_id: actor.id }),
         prompt: md,
+        space_id: finalSpaceId ?? undefined,
         project_id: projectId ?? undefined,
         parent_issue_id: parentIssueId,
         ...(activeAttachmentIds.length > 0 ? { attachment_ids: activeAttachmentIds } : {}),
       });
       setLastActor(actor.type, actor.id);
       setLastProjectId(projectId);
+      setLastSpaceId(finalSpaceId);
       clearPrompt();
       setLastMode("agent");
       toast.success(t(($) => $.create_issue.agent.toast_sent), {
@@ -396,6 +448,7 @@ export function AgentCreatePanel({
     // through.
     const carry: Record<string, unknown> = {};
     if (projectId) carry.project_id = projectId;
+    if (effectiveSpaceId) carry.space_id = effectiveSpaceId;
     if (parentIssueId) carry.parent_issue_id = parentIssueId;
     if (parentIssueIdentifier) carry.parent_issue_identifier = parentIssueIdentifier;
     onSwitchMode?.(Object.keys(carry).length > 0 ? carry : null);
@@ -408,7 +461,14 @@ export function AgentCreatePanel({
         {/* Header */}
         <div className="flex items-center justify-between px-5 pt-3 pb-2 shrink-0">
           <div className="flex items-center gap-1.5 text-xs">
-            <span className="text-muted-foreground">{workspaceName}</span>
+            {/* The issue's space namespace — leads the breadcrumb like the
+                workspace name used to, but as a required single-select. */}
+            <SpacePicker
+              spaceId={effectiveSpaceId}
+              onChange={setSpaceId}
+              triggerRender={<PillButton />}
+              align="start"
+            />
             <ChevronRight className="size-3 text-muted-foreground/50" />
             <span className="font-medium">{t(($) => $.create_issue.agent_breadcrumb)}</span>
           </div>
@@ -584,6 +644,24 @@ export function AgentCreatePanel({
             </Button>
           </div>
         </div>
+      {spaceProjectConflict && (
+        <SpaceProjectConflictDialog
+          open={conflictOpen}
+          spaceName={spaceProjectConflict.space.name}
+          projectName={selectedProject?.title ?? ""}
+          projectSpaces={spaceProjectConflict.projectSpaces}
+          onAddSpace={() => {
+            setConflictOpen(false);
+            void doSubmit(effectiveSpaceId);
+          }}
+          onMoveToSpace={(tid) => {
+            setConflictOpen(false);
+            setSpaceId(tid);
+            void doSubmit(tid);
+          }}
+          onCancel={() => setConflictOpen(false)}
+        />
+      )}
     </>
   );
 }
diff --git a/packages/views/modals/registry.tsx b/packages/views/modals/registry.tsx
index b014515cf2..8f4204ffa6 100644
--- a/packages/views/modals/registry.tsx
+++ b/packages/views/modals/registry.tsx
@@ -26,7 +26,7 @@ export function ModalRegistry() {
     case "quick-create-issue":
       return <CreateIssueDialog onClose={close} initialMode="agent" data={data} />;
     case "create-project":
-      return <CreateProjectModal onClose={close} />;
+      return <CreateProjectModal onClose={close} data={data} />;
     case "create-squad":
       return <CreateSquadModal onClose={close} />;
     case "feedback":
diff --git a/packages/views/onboarding/steps/step-workspace.tsx b/packages/views/onboarding/steps/step-workspace.tsx
index 770c7780d8..09c21fafa3 100644
--- a/packages/views/onboarding/steps/step-workspace.tsx
+++ b/packages/views/onboarding/steps/step-workspace.tsx
@@ -53,24 +53,15 @@ import { isReservedSlug } from "@multica/core/paths";
  *
  * The create-fields block doubles as a pedagogical preview: the URL is
  * rendered as a `<host>/[slug]` pill (host derived from the deployment's
- * app URL so self-hosted instances show their own domain), and a live
- * `Issues will look
- * like ACME-123` line shows the user what their issue IDs will read
- * like before they've created anything.
+ * app URL so self-hosted instances show their own domain). The default
+ * space's issue key is derived server-side from the slug, so the form
+ * only asks for name and URL.
  *
  * Resume path ships two picker cards (existing + create-new) and the
  * user toggles between them. No-existing path just shows the create
  * fields directly.
  */
 
-function issuePrefix(slug: string): string {
-  // Mirrors the server's default prefix derivation — first 4 chars of
-  // the slug, uppercased. Falls back to "WS" when the slug is empty so
-  // the preview line never collapses to a single dangling "-".
-  const head = slug.trim().replace(/[^a-z0-9]/g, "").slice(0, 4);
-  return (head || "ws").toUpperCase();
-}
-
 export function StepWorkspace({
   existing,
   onCreated,
@@ -148,7 +139,10 @@ export function StepWorkspace({
   const handleCreate = () => {
     if (!canCreate || createWorkspace.isPending) return;
     createWorkspace.mutate(
-      { name: name.trim(), slug: slug.trim() },
+      {
+        name: name.trim(),
+        slug: slug.trim(),
+      },
       {
         onSuccess: onCreated,
         onError: (error) => {
@@ -263,18 +257,6 @@ export function StepWorkspace({
         </div>
         {slugError && <p className="text-xs text-destructive">{slugError}</p>}
       </div>
-      <div className="flex flex-col gap-1.5">
-        <div className="text-xs font-medium text-muted-foreground">
-          {t(($) => $.step_workspace.issue_prefix_label)}
-        </div>
-        <div className="text-sm leading-[1.55] text-muted-foreground">
-          {t(($) => $.step_workspace.issue_prefix_prefix)}
-          <span className="font-mono text-foreground">
-            {issuePrefix(slug)}-123
-          </span>
-          {t(($) => $.step_workspace.issue_prefix_suffix)}
-        </div>
-      </div>
     </div>
   );
 
diff --git a/packages/views/package.json b/packages/views/package.json
index 2e496aa33a..6b37e83564 100644
--- a/packages/views/package.json
+++ b/packages/views/package.json
@@ -39,6 +39,7 @@
     "./workspace/welcome-after-onboarding": "./workspace/welcome-after-onboarding.tsx",
     "./workspace/use-workspace-seen": "./workspace/use-workspace-seen.ts",
     "./layout": "./layout/index.ts",
+    "./spaces": "./spaces/index.ts",
     "./auth": "./auth/index.ts",
     "./search": "./search/index.ts",
     "./chat": "./chat/index.ts",
diff --git a/packages/views/projects/components/project-detail.tsx b/packages/views/projects/components/project-detail.tsx
index 06cfd298db..c468c4d4e5 100644
--- a/packages/views/projects/components/project-detail.tsx
+++ b/packages/views/projects/components/project-detail.tsx
@@ -25,6 +25,7 @@ import { useNavigation } from "../../navigation";
 import { TitleEditor, ContentEditor, type ContentEditorRef } from "../../editor";
 import { PriorityIcon } from "../../issues/components/priority-icon";
 import { ProjectResourcesSection } from "./project-resources-section";
+import { SpaceMultiPicker } from "../../spaces/components/space-picker";
 import { IssueSurface } from "../../issues/surface/issue-surface";
 import { Skeleton } from "@multica/ui/components/ui/skeleton";
 import { Button } from "@multica/ui/components/ui/button";
@@ -398,6 +399,16 @@ export function ProjectDetail({ projectId }: { projectId: string }) {
               </PopoverContent>
             </Popover>
           </PropRow>
+          {/* Display-only in v1: the project↔space set binds at creation.
+              Post-create editing was cut together with issue move-to-space. */}
+          <PropRow label={t(($) => $.table.spaces)}>
+            <SpaceMultiPicker
+              spaceIds={project.space_ids ?? []}
+              onChange={() => {}}
+              align="start"
+              disabled
+            />
+          </PropRow>
         </div>}
       </div>
 
diff --git a/packages/views/projects/components/projects-page.tsx b/packages/views/projects/components/projects-page.tsx
index 3417cadebc..224ef10e35 100644
--- a/packages/views/projects/components/projects-page.tsx
+++ b/packages/views/projects/components/projects-page.tsx
@@ -768,7 +768,10 @@ function ProjectBatchToolbar({
 // Page
 // ---------------------------------------------------------------------------
 
-export function ProjectsPage() {
+// `spaceId` narrows the list to projects associated with that space — used by
+// the space surface pages (/space/:key/projects). Association is a creation-time
+// tag, so this stays a client-side filter over the shared list cache.
+export function ProjectsPage({ spaceId }: { spaceId?: string } = {}) {
   const { t } = useT("projects");
   const wsId = useWorkspaceId();
   const wsPaths = useWorkspacePaths();
@@ -791,13 +794,18 @@ export function ProjectsPage() {
   const isCompact = viewMode === "compact";
   const isColVisible = (key: ProjectColumnKey) => !hiddenColumns.includes(key);
 
-  const { data: projects = [], isLoading } = useQuery(projectListOptions(wsId));
+  const { data: allProjects = [], isLoading } = useQuery(projectListOptions(wsId));
+  const projects = useMemo(
+    () => (spaceId ? allProjects.filter((p) => p.space_ids?.includes(spaceId)) : allProjects),
+    [allProjects, spaceId],
+  );
   const { data: members = [] } = useQuery(memberListOptions(wsId));
   const { data: pins = [] } = useQuery({
     ...pinListOptions(wsId, currentUser?.id ?? ""),
     enabled: !!wsId && !!currentUser?.id,
   });
-  const openCreateProject = () => useModalStore.getState().open("create-project");
+  const openCreateProject = () =>
+    useModalStore.getState().open("create-project", spaceId ? { space_id: spaceId } : undefined);
 
   const isWorkspaceAdmin = useMemo(() => {
     if (!currentUser) return false;
diff --git a/packages/views/spaces/components/create-space-page.tsx b/packages/views/spaces/components/create-space-page.tsx
new file mode 100644
index 0000000000..9a9119356a
--- /dev/null
+++ b/packages/views/spaces/components/create-space-page.tsx
@@ -0,0 +1,343 @@
+"use client";
+
+import { useState, type FormEvent } from "react";
+import { ArrowLeft, Search } from "lucide-react";
+import { EmojiPicker } from "@multica/ui/components/common/emoji-picker";
+import { PlainTextField } from "@multica/ui/components/common/plain-text-field";
+import { useQuery } from "@tanstack/react-query";
+import { toast } from "sonner";
+import { cn } from "@multica/ui/lib/utils";
+import { normalizeSpaceKey, isValidSpaceKey, RESERVED_SPACE_KEYS } from "@multica/core/workspace";
+import { useCreateSpace } from "@multica/core/spaces/mutations";
+import { useWorkspaceId } from "@multica/core/hooks";
+import { useWorkspacePaths } from "@multica/core/paths";
+import { memberListOptions } from "@multica/core/workspace/queries";
+import { useAuthStore } from "@multica/core/auth";
+import { Button } from "@multica/ui/components/ui/button";
+import { Checkbox } from "@multica/ui/components/ui/checkbox";
+import { Input } from "@multica/ui/components/ui/input";
+import { Label } from "@multica/ui/components/ui/label";
+import {
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+} from "@multica/ui/components/ui/popover";
+import { ActorAvatar } from "@multica/ui/components/common/actor-avatar";
+import { useNavigation } from "../../navigation";
+import { PageHeader } from "../../layout/page-header";
+import { SpaceIcon } from "./space-icon";
+import { useT } from "../../i18n";
+
+const underline =
+  "rounded-none border-0 border-b border-input bg-transparent dark:bg-transparent px-0 shadow-none focus-visible:ring-0 focus-visible:border-foreground";
+
+/**
+ * Create-space page — /space/new, a static sibling of /space/:key ("new" is
+ * a reserved space key so it can never collide with a real space's detail
+ * page). Layout mirrors SpaceDetailPage's single max-w-4xl column so create
+ * and edit read as the same surface; unlike the edit page's blur-commit
+ * fields, this one needs an explicit submit — there's no space.id to PATCH
+ * against until the create call returns.
+ */
+export function CreateSpacePage() {
+  const { t } = useT("spaces");
+  const p = useWorkspacePaths();
+  const navigation = useNavigation();
+  const createSpace = useCreateSpace();
+
+  const [name, setName] = useState("");
+  const [nameTouched, setNameTouched] = useState(false);
+  const [key, setKey] = useState("");
+  const [keyTouched, setKeyTouched] = useState(false);
+  const [icon, setIcon] = useState("");
+  const [iconPickerOpen, setIconPickerOpen] = useState(false);
+  const [description, setDescription] = useState("");
+  const [memberIds, setMemberIds] = useState<string[]>([]);
+  const [submitting, setSubmitting] = useState(false);
+
+  const normalizedKey = normalizeSpaceKey(key);
+  const nameError = nameTouched && name.trim().length === 0;
+  const keyReserved = RESERVED_SPACE_KEYS.has(normalizedKey);
+  const keyError = keyTouched && key.length > 0 && !isValidSpaceKey(normalizedKey);
+  const canSubmit = name.trim().length > 0 && isValidSpaceKey(normalizedKey) && !submitting;
+
+  const submit = async (event: FormEvent) => {
+    event.preventDefault();
+    setNameTouched(true);
+    setKeyTouched(true);
+    if (!canSubmit) return;
+    setSubmitting(true);
+    try {
+      const space = await createSpace.mutateAsync({
+        name: name.trim(),
+        key: normalizedKey,
+        description: description.trim() || undefined,
+        icon: icon.trim() || null,
+        member_ids: memberIds,
+      });
+      toast.success(t(($) => $.toast_created));
+      navigation.replace(p.spaceDetail(space.key));
+    } catch (err) {
+      toast.error(
+        err instanceof Error && err.message ? err.message : t(($) => $.toast_save_failed),
+      );
+    } finally {
+      setSubmitting(false);
+    }
+  };
+
+  return (
+    <div className="flex min-h-0 flex-1 flex-col">
+      <PageHeader className="justify-between">
+        <h1 className="text-sm font-medium">{t(($) => $.dialog.create_title)}</h1>
+        <Button
+          type="button"
+          variant="ghost"
+          size="sm"
+          className="text-muted-foreground"
+          onClick={() => navigation.back()}
+        >
+          <ArrowLeft className="h-4 w-4" />
+          {t(($) => $.actions.cancel)}
+        </Button>
+      </PageHeader>
+
+      <div className="min-h-0 flex-1 overflow-y-auto">
+        <form
+          onSubmit={submit}
+          autoComplete="off"
+          className="mx-auto flex w-full max-w-4xl flex-col gap-8 px-6 py-8"
+        >
+          <div className="flex flex-col gap-3">
+            <div className="flex items-center gap-3">
+              {/* Icon is emoji-only — picked, never typed. */}
+              <Popover open={iconPickerOpen} onOpenChange={setIconPickerOpen}>
+                <PopoverTrigger
+                  render={
+                    <button
+                      type="button"
+                      aria-label={t(($) => $.form.icon)}
+                      className="flex size-10 shrink-0 cursor-pointer items-center justify-center rounded-lg bg-muted/60 text-2xl transition-colors hover:bg-accent"
+                    />
+                  }
+                >
+                  {icon || <SpaceIcon space={{ icon: null }} className="size-5" />}
+                </PopoverTrigger>
+                <PopoverContent align="start" className="w-auto p-0">
+                  <EmojiPicker
+                    onSelect={(emoji) => {
+                      setIcon(emoji);
+                      setIconPickerOpen(false);
+                    }}
+                  />
+                </PopoverContent>
+              </Popover>
+              <div className="min-w-0 flex-1">
+                <Input
+                  autoFocus
+                  aria-label={t(($) => $.form.name)}
+                  value={name}
+                  onChange={(event) => setName(event.target.value)}
+                  onBlur={() => setNameTouched(true)}
+                  placeholder={t(($) => $.form.name_placeholder)}
+                  className="h-auto rounded-none border-0 bg-transparent px-0 py-1 !text-2xl font-bold leading-snug tracking-tight shadow-none focus-visible:ring-0 dark:bg-transparent"
+                />
+              </div>
+            </div>
+            {/* pl-[52px] = icon (size-10) + row gap-3, so this lines up under the name input, not the icon.
+                Always mounted (visibility toggled, not conditionally rendered) so the row below doesn't jump. */}
+            <p
+              className={cn(
+                "pl-[52px] text-xs text-destructive",
+                nameError ? "visible" : "invisible",
+              )}
+            >
+              {t(($) => $.dialog.name_required)}
+            </p>
+            <PlainTextField
+              defaultValue={description}
+              placeholder={t(($) => $.form.description_placeholder)}
+              aria-label={t(($) => $.form.description)}
+              className="text-sm text-muted-foreground"
+              limitHint={(count, max) => t(($) => $.form.description_limit, { count, max })}
+              onCommit={setDescription}
+            />
+          </div>
+
+          <div className="space-y-1.5">
+            <Label htmlFor="space-key" className="text-xs font-medium text-muted-foreground">
+              {t(($) => $.form.key)}
+            </Label>
+            <Input
+              id="space-key"
+              value={key}
+              onChange={(event) => setKey(normalizeSpaceKey(event.target.value))}
+              onBlur={() => setKeyTouched(true)}
+              placeholder="ENG"
+              maxLength={7}
+              className={cn(underline, "max-w-40 font-mono", keyError && "border-destructive")}
+            />
+            <p className={cn("text-xs", keyError ? "text-destructive" : "text-muted-foreground")}>
+              {keyError && keyReserved ? t(($) => $.form.key_reserved) : t(($) => $.form.key_hint)}
+            </p>
+          </div>
+
+          <MembersField memberIds={memberIds} onChange={setMemberIds} />
+
+          <div className="flex justify-end">
+            <Button type="submit" disabled={!canSubmit}>
+              {submitting ? t(($) => $.actions.saving) : t(($) => $.actions.save)}
+            </Button>
+          </div>
+        </form>
+      </div>
+    </div>
+  );
+}
+
+/**
+ * Member picker for the create page — same avatar-stack + popover-checkbox
+ * shape as SpaceDetailPage's MembersSection, but against local unsaved state
+ * (the space doesn't exist yet, so there's nothing to PATCH). The creator is
+ * always in and always lead, matching what CreateSpace does server-side.
+ */
+function MembersField({
+  memberIds,
+  onChange,
+}: {
+  memberIds: string[];
+  onChange: (ids: string[]) => void;
+}) {
+  const { t } = useT("spaces");
+  const wsId = useWorkspaceId();
+  const currentUser = useAuthStore((s) => s.user);
+  const { data: allMembers = [] } = useQuery(memberListOptions(wsId));
+
+  const [open, setOpen] = useState(false);
+  const [search, setSearch] = useState("");
+
+  const invitableMembers = allMembers
+    .filter((member) => member.user_id !== currentUser?.id)
+    .filter((member) => {
+      const q = search.trim().toLowerCase();
+      return (
+        !q ||
+        member.name.toLowerCase().includes(q) ||
+        member.email.toLowerCase().includes(q)
+      );
+    });
+
+  const toggle = (userId: string) =>
+    onChange(
+      memberIds.includes(userId)
+        ? memberIds.filter((id) => id !== userId)
+        : [...memberIds, userId],
+    );
+
+  const invitedMembers = allMembers.filter((member) => memberIds.includes(member.user_id));
+  const stack = invitedMembers.slice(0, 4);
+  const overflow = invitedMembers.length - stack.length;
+
+  return (
+    <div className="flex flex-col gap-2">
+      <h3 className="text-xs font-medium text-muted-foreground">
+        {t(($) => $.dialog.members_entry)}
+      </h3>
+      <Popover open={open} onOpenChange={setOpen}>
+        <PopoverTrigger
+          render={
+            <button
+              type="button"
+              className="-mx-1.5 flex items-center gap-2 rounded-md px-1.5 py-1 text-left transition-colors hover:bg-accent/60"
+            />
+          }
+        >
+          <span className="flex items-center -space-x-1.5">
+            {currentUser && (
+              <span className="rounded-full ring-2 ring-background">
+                <ActorAvatar
+                  name={currentUser.name}
+                  initials={(currentUser.name || "?").charAt(0).toUpperCase()}
+                  avatarUrl={currentUser.avatar_url ?? null}
+                  size={22}
+                />
+              </span>
+            )}
+            {stack.map((member) => (
+              <span key={member.user_id} className="rounded-full ring-2 ring-background">
+                <ActorAvatar
+                  name={member.name}
+                  initials={(member.name || member.email || "?").charAt(0).toUpperCase()}
+                  avatarUrl={member.avatar_url}
+                  size={22}
+                />
+              </span>
+            ))}
+            {overflow > 0 && (
+              <span className="flex size-[22px] items-center justify-center rounded-full bg-muted text-[10px] font-medium text-muted-foreground ring-2 ring-background">
+                +{overflow}
+              </span>
+            )}
+          </span>
+          <span className="text-xs text-muted-foreground">
+            {t(($) => $.dialog.member_count, { count: memberIds.length + 1 })}
+          </span>
+        </PopoverTrigger>
+        <PopoverContent align="start" className="flex w-80 flex-col gap-2 p-3">
+          <div className="relative shrink-0">
+            <Search className="absolute left-0 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground" />
+            <Input
+              autoFocus
+              value={search}
+              onChange={(event) => setSearch(event.target.value)}
+              placeholder={t(($) => $.dialog.member_search)}
+              className={cn(underline, "pl-6")}
+            />
+          </div>
+          <div className="max-h-64 min-h-0 overflow-y-auto overflow-x-hidden">
+            {/* Creator — always in, always lead. */}
+            {currentUser && (
+              <div className="flex items-center gap-2 border-b px-1 py-2 opacity-80">
+                <ActorAvatar
+                  name={currentUser.name}
+                  initials={(currentUser.name || "?").charAt(0).toUpperCase()}
+                  avatarUrl={currentUser.avatar_url ?? null}
+                  size={24}
+                />
+                <span className="min-w-0 flex-1 truncate text-sm">{currentUser.name}</span>
+                <span className="text-xs text-muted-foreground">
+                  {t(($) => $.dialog.creator_row)}
+                </span>
+              </div>
+            )}
+            {invitableMembers.map((member) => (
+              <label
+                key={member.user_id}
+                className="flex cursor-pointer items-center gap-2 border-b px-1 py-2 transition-colors last:border-b-0 hover:bg-accent/40"
+              >
+                <ActorAvatar
+                  name={member.name}
+                  initials={(member.name || member.email || "?").charAt(0).toUpperCase()}
+                  avatarUrl={member.avatar_url}
+                  size={24}
+                />
+                <span className="min-w-0 flex-1 truncate text-sm">
+                  {member.name || member.email}
+                </span>
+                <Checkbox
+                  checked={memberIds.includes(member.user_id)}
+                  onCheckedChange={() => toggle(member.user_id)}
+                />
+              </label>
+            ))}
+            {invitableMembers.length === 0 && (
+              <div className="px-1 py-4 text-center text-sm text-muted-foreground">
+                {t(($) => $.dialog.member_search_empty)}
+              </div>
+            )}
+          </div>
+        </PopoverContent>
+      </Popover>
+    </div>
+  );
+}
diff --git a/packages/views/spaces/components/index.ts b/packages/views/spaces/components/index.ts
new file mode 100644
index 0000000000..f9b6066cd2
--- /dev/null
+++ b/packages/views/spaces/components/index.ts
@@ -0,0 +1,5 @@
+export { SpacePicker, SpaceMultiPicker } from "./space-picker";
+export { SpaceIcon } from "./space-icon";
+export { SpaceIssuesPage, SpaceProjectsPage, SpaceAutopilotsPage } from "./space-surface-pages";
+export { SpaceDetailPage } from "./space-detail-page";
+export { CreateSpacePage } from "./create-space-page";
diff --git a/packages/views/spaces/components/space-detail-page.tsx b/packages/views/spaces/components/space-detail-page.tsx
new file mode 100644
index 0000000000..f97f65d475
--- /dev/null
+++ b/packages/views/spaces/components/space-detail-page.tsx
@@ -0,0 +1,515 @@
+"use client";
+
+import { useEffect, useMemo, useState } from "react";
+import { FolderKanban, ListTodo, Search, Zap } from "lucide-react";
+import { EmojiPicker } from "@multica/ui/components/common/emoji-picker";
+import { PlainTextField } from "@multica/ui/components/common/plain-text-field";
+import { useQuery } from "@tanstack/react-query";
+import { toast } from "sonner";
+import { cn } from "@multica/ui/lib/utils";
+import { spaceListOptions, spaceMembersOptions } from "@multica/core/spaces/queries";
+import {
+  useArchiveSpace,
+  useReplaceSpaceMembers,
+  useUpdateSpace,
+} from "@multica/core/spaces/mutations";
+import { useWorkspaceId } from "@multica/core/hooks";
+import { useCurrentMember } from "@multica/core/permissions";
+import { useWorkspacePaths } from "@multica/core/paths";
+import { Tooltip, TooltipTrigger, TooltipContent } from "@multica/ui/components/ui/tooltip";
+import { projectListOptions } from "@multica/core/projects/queries";
+import { autopilotListOptions } from "@multica/core/autopilots/queries";
+import { memberListOptions } from "@multica/core/workspace/queries";
+import type { Space } from "@multica/core/types";
+import { Button } from "@multica/ui/components/ui/button";
+import { Badge } from "@multica/ui/components/ui/badge";
+import { Checkbox } from "@multica/ui/components/ui/checkbox";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogTitle,
+} from "@multica/ui/components/ui/dialog";
+import { Input } from "@multica/ui/components/ui/input";
+import {
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+} from "@multica/ui/components/ui/popover";
+import { ActorAvatar } from "@multica/ui/components/common/actor-avatar";
+import { AppLink } from "../../navigation";
+import { PageHeader } from "../../layout/page-header";
+import { SpaceIcon } from "./space-icon";
+import { useT } from "../../i18n";
+
+// Underline style for the member search field inside the config popover.
+const underline =
+  "rounded-none border-0 border-b border-input bg-transparent dark:bg-transparent px-0 shadow-none focus-visible:ring-0 focus-visible:border-foreground";
+
+/**
+ * Space detail — /space/:key, the sidebar space row's landing page. A single
+ * narrow column: the identity rendered as page text (icon picker applies on
+ * pick, name and description commit on blur — no save buttons), then members
+ * (avatar stack → checkbox config; saving an empty set archives behind a
+ * confirm), go-to links, and archive.
+ */
+export function SpaceDetailPage({ spaceKey }: { spaceKey: string }) {
+  const { t } = useT("spaces");
+  const wsId = useWorkspaceId();
+  // Full list (not active-only): an archived space's settings stay viewable.
+  const { data: spaces = [], isSuccess } = useQuery(spaceListOptions(wsId));
+  const space = spaces.find((tm) => tm.key.toLowerCase() === spaceKey.toLowerCase());
+  // No space is flagged "default" — every workspace just always keeps at
+  // least one active space (archiving the last one is rejected server-side).
+  // This is that same rule surfaced client-side, computed from the sibling
+  // count rather than a stored flag.
+  const isLastActiveSpace = spaces.filter((s) => !s.archived_at).length <= 1;
+
+  if (!space) {
+    return isSuccess ? (
+      <div className="flex flex-1 min-h-0 items-center justify-center text-sm text-muted-foreground">
+        {t(($) => $.surface.not_found)}
+      </div>
+    ) : null;
+  }
+
+  return (
+    <div className="flex min-h-0 flex-1 flex-col">
+      <PageHeader className="gap-2">
+        <SpaceIcon space={space} />
+        <h1 className="text-sm font-medium">{space.name}</h1>
+        {space.archived_at && <Badge variant="outline">{t(($) => $.state.archived)}</Badge>}
+      </PageHeader>
+
+      <div className="min-h-0 flex-1 overflow-y-auto">
+        <div className="mx-auto flex w-full max-w-4xl flex-col gap-8 px-6 py-8">
+          <Identity space={space} />
+          <MembersSection space={space} isLastActiveSpace={isLastActiveSpace} />
+          <GotoSection space={space} />
+          <ArchiveSection space={space} isLastActiveSpace={isLastActiveSpace} />
+        </div>
+      </div>
+    </div>
+  );
+}
+
+/**
+ * Icon + name + description rendered as page content. The icon applies on
+ * pick; name and description commit on blur (Escape restores) — there is no
+ * save button anywhere on this page.
+ */
+function Identity({ space }: { space: Space }) {
+  const { t } = useT("spaces");
+  const updateSpace = useUpdateSpace();
+  const [name, setName] = useState(space.name);
+  const [iconPickerOpen, setIconPickerOpen] = useState(false);
+
+  // Re-seed when navigating between spaces (or after a save round-trips).
+  useEffect(() => {
+    setName(space.name);
+  }, [space.id, space.name]);
+
+  const saveField = async (patch: { name?: string; icon?: string | null; description?: string }) => {
+    try {
+      await updateSpace.mutateAsync({ id: space.id, ...patch });
+      toast.success(t(($) => $.toast_updated));
+    } catch (err) {
+      toast.error(
+        err instanceof Error && err.message ? err.message : t(($) => $.toast_save_failed),
+      );
+    }
+  };
+
+  const commitName = () => {
+    const next = name.trim();
+    if (!next) {
+      setName(space.name);
+      return;
+    }
+    if (next !== space.name) void saveField({ name: next });
+  };
+
+  return (
+    <div className="flex flex-col gap-3">
+      <div className="flex items-center gap-3">
+        {/* Icon is emoji-only and applies immediately on pick. */}
+        <Popover open={iconPickerOpen} onOpenChange={setIconPickerOpen}>
+          <PopoverTrigger
+            render={
+              <button
+                type="button"
+                aria-label={t(($) => $.form.icon)}
+                className="flex size-10 shrink-0 cursor-pointer items-center justify-center rounded-lg bg-muted/60 text-2xl transition-colors hover:bg-accent"
+              />
+            }
+          >
+            {space.icon || <SpaceIcon space={{ icon: null }} className="size-5" />}
+          </PopoverTrigger>
+          <PopoverContent align="start" className="w-auto p-0">
+            <EmojiPicker
+              onSelect={(emoji) => {
+                setIconPickerOpen(false);
+                void saveField({ icon: emoji });
+              }}
+            />
+          </PopoverContent>
+        </Popover>
+        <Input
+          aria-label={t(($) => $.form.name)}
+          value={name}
+          onChange={(event) => setName(event.target.value)}
+          onBlur={commitName}
+          onKeyDown={(event) => {
+            if (event.key === "Enter") event.currentTarget.blur();
+            if (event.key === "Escape") {
+              setName(space.name);
+              event.currentTarget.blur();
+            }
+          }}
+          className="h-auto rounded-none border-0 bg-transparent px-0 py-1 !text-2xl font-bold leading-snug tracking-tight shadow-none focus-visible:ring-0 dark:bg-transparent"
+        />
+      </div>
+      {/* Keyed by the server value so a committed save (or a WS update)
+          re-seeds the field without fighting in-progress typing. */}
+      <PlainTextField
+        key={`${space.id}:${space.description}`}
+        defaultValue={space.description}
+        placeholder={t(($) => $.form.description_placeholder)}
+        aria-label={t(($) => $.form.description)}
+        className="text-sm text-muted-foreground"
+        limitHint={(count, max) => t(($) => $.form.description_limit, { count, max })}
+        onCommit={(value) => void saveField({ description: value })}
+      />
+    </div>
+  );
+}
+
+/**
+ * Member stack + config popover. The checkbox set is the full source of
+ * truth; saving replaces the space's membership wholesale. Deselecting
+ * everyone means the space has no reason to exist — saving then archives it,
+ * behind a confirm (blocked when this is the workspace's last active space).
+ */
+function MembersSection({ space, isLastActiveSpace }: { space: Space; isLastActiveSpace: boolean }) {
+  const { t } = useT("spaces");
+  const wsId = useWorkspaceId();
+  const { role } = useCurrentMember(wsId);
+  const isAdmin = role === "owner" || role === "admin";
+  const { data: members = [] } = useQuery(spaceMembersOptions(wsId, space.id));
+  const { data: allMembers = [] } = useQuery(memberListOptions(wsId));
+  const replaceMembers = useReplaceSpaceMembers();
+  const archiveSpace = useArchiveSpace();
+
+  const [open, setOpen] = useState(false);
+  const [selected, setSelected] = useState<string[]>([]);
+  const [search, setSearch] = useState("");
+  const [confirmArchive, setConfirmArchive] = useState(false);
+  const [saving, setSaving] = useState(false);
+
+  // Seed the checkbox set from the live membership each time the panel opens.
+  useEffect(() => {
+    if (open) {
+      setSelected(members.map((member) => member.user_id));
+      setSearch("");
+    }
+  }, [open, members]);
+
+  const filteredMembers = useMemo(() => {
+    const q = search.trim().toLowerCase();
+    return allMembers.filter(
+      (member) =>
+        !q ||
+        member.name.toLowerCase().includes(q) ||
+        member.email.toLowerCase().includes(q),
+    );
+  }, [allMembers, search]);
+
+  const toggle = (userId: string) =>
+    setSelected((prev) =>
+      prev.includes(userId) ? prev.filter((id) => id !== userId) : [...prev, userId],
+    );
+
+  const doArchive = async () => {
+    setConfirmArchive(false);
+    setOpen(false);
+    try {
+      await archiveSpace.mutateAsync(space.id);
+      toast.success(t(($) => $.toast_archived));
+    } catch (err) {
+      toast.error(
+        err instanceof Error && err.message ? err.message : t(($) => $.toast_archive_failed),
+      );
+    }
+  };
+
+  const save = async () => {
+    if (selected.length === 0) {
+      if (isLastActiveSpace) {
+        toast.error(t(($) => $.settings.last_space_cannot_archive));
+        return;
+      }
+      // Empty membership funnels into archive, which is admin-only —
+      // pre-check here so members get the reason instead of a raw 403.
+      if (!isAdmin) {
+        toast.error(t(($) => $.settings.archive_admin_only));
+        return;
+      }
+      setConfirmArchive(true);
+      return;
+    }
+    setSaving(true);
+    try {
+      await replaceMembers.mutateAsync({ id: space.id, member_ids: selected });
+      toast.success(t(($) => $.toast_updated));
+      setOpen(false);
+    } catch (err) {
+      toast.error(
+        err instanceof Error && err.message ? err.message : t(($) => $.toast_save_failed),
+      );
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  const stack = members.slice(0, 5);
+  const overflow = members.length - stack.length;
+
+  return (
+    <div className="flex flex-col gap-2">
+      <h3 className="text-xs font-medium text-muted-foreground">
+        {t(($) => $.settings.members)}
+      </h3>
+      <Popover open={open} onOpenChange={setOpen}>
+        <PopoverTrigger
+          render={
+            <button
+              type="button"
+              className="-mx-1.5 flex items-center gap-2 rounded-md px-1.5 py-1 text-left transition-colors hover:bg-accent/60"
+            />
+          }
+        >
+          {members.length > 0 ? (
+            <span className="flex items-center -space-x-1.5">
+              {stack.map((member) => (
+                <span key={member.user_id} className="rounded-full ring-2 ring-background">
+                  <ActorAvatar
+                    name={member.name}
+                    initials={(member.name || member.email || "?").charAt(0).toUpperCase()}
+                    avatarUrl={member.avatar_url}
+                    size={22}
+                  />
+                </span>
+              ))}
+              {overflow > 0 && (
+                <span className="flex size-[22px] items-center justify-center rounded-full bg-muted text-[10px] font-medium text-muted-foreground ring-2 ring-background">
+                  +{overflow}
+                </span>
+              )}
+            </span>
+          ) : (
+            <span className="text-sm text-muted-foreground">
+              {t(($) => $.settings.members_empty)}
+            </span>
+          )}
+        </PopoverTrigger>
+        <PopoverContent align="start" className="flex w-80 flex-col gap-2 p-3">
+          <div className="relative shrink-0">
+            <Search className="absolute left-0 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground" />
+            <Input
+              autoFocus
+              value={search}
+              onChange={(event) => setSearch(event.target.value)}
+              placeholder={t(($) => $.dialog.member_search)}
+              className={cn(underline, "pl-6")}
+            />
+          </div>
+          <div className="max-h-64 min-h-0 overflow-y-auto overflow-x-hidden">
+            {filteredMembers.map((member) => (
+              <label
+                key={member.user_id}
+                className="flex cursor-pointer items-center gap-2 border-b px-1 py-2 transition-colors last:border-b-0 hover:bg-accent/40"
+              >
+                <ActorAvatar
+                  name={member.name}
+                  initials={(member.name || member.email || "?").charAt(0).toUpperCase()}
+                  avatarUrl={member.avatar_url}
+                  size={24}
+                />
+                <span className="min-w-0 flex-1 truncate text-sm">
+                  {member.name || member.email}
+                </span>
+                <Checkbox
+                  checked={selected.includes(member.user_id)}
+                  onCheckedChange={() => toggle(member.user_id)}
+                />
+              </label>
+            ))}
+            {filteredMembers.length === 0 && (
+              <div className="px-1 py-4 text-center text-sm text-muted-foreground">
+                {t(($) => $.dialog.member_search_empty)}
+              </div>
+            )}
+          </div>
+          <div className="flex items-center justify-between pt-1">
+            <span className="text-xs text-muted-foreground">
+              {t(($) => $.dialog.member_count, { count: selected.length })}
+            </span>
+            <Button size="sm" onClick={save} disabled={saving}>
+              {saving ? t(($) => $.actions.saving) : t(($) => $.actions.save)}
+            </Button>
+          </div>
+        </PopoverContent>
+      </Popover>
+
+      <Dialog open={confirmArchive} onOpenChange={setConfirmArchive}>
+        <DialogContent showCloseButton={false} className="sm:max-w-sm">
+          <DialogTitle>{t(($) => $.settings.archive_confirm_title)}</DialogTitle>
+          <DialogDescription>
+            {t(($) => $.settings.archive_confirm_body, { name: space.name })}
+          </DialogDescription>
+          <DialogFooter>
+            <Button variant="outline" onClick={() => setConfirmArchive(false)}>
+              {t(($) => $.actions.cancel)}
+            </Button>
+            <Button variant="destructive" onClick={doArchive}>
+              {t(($) => $.actions.archive)}
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </div>
+  );
+}
+
+function GotoSection({ space }: { space: Space }) {
+  const { t } = useT("spaces");
+  const wsId = useWorkspaceId();
+  const p = useWorkspacePaths();
+  // Counts come from the shared list caches — cheap, and clicking through
+  // lands on the matching space surface.
+  const { data: projects = [] } = useQuery(projectListOptions(wsId));
+  const { data: autopilots = [] } = useQuery(autopilotListOptions(wsId));
+  const projectCount = useMemo(
+    () => projects.filter((project) => project.space_ids?.includes(space.id)).length,
+    [projects, space.id],
+  );
+  const autopilotCount = useMemo(
+    () => autopilots.filter((autopilot) => autopilot.space_id === space.id).length,
+    [autopilots, space.id],
+  );
+
+  const links = [
+    { icon: ListTodo, label: t(($) => $.settings.stats_issues), value: space.issue_counter, href: p.spaceIssues(space.key) },
+    { icon: FolderKanban, label: t(($) => $.settings.stats_projects), value: projectCount, href: p.spaceProjects(space.key) },
+    { icon: Zap, label: t(($) => $.settings.stats_autopilots), value: autopilotCount, href: p.spaceAutopilots(space.key) },
+  ];
+
+  return (
+    <div className="flex flex-col gap-1">
+      <h3 className="mb-1 text-xs font-medium text-muted-foreground">
+        {t(($) => $.settings.goto)}
+      </h3>
+      {/* Equal-width cells, three across in the detail container; auto-fit
+          wraps them cleanly when the container narrows. */}
+      <div className="grid grid-cols-[repeat(auto-fit,minmax(10rem,1fr))] gap-2">
+        {links.map((link) => (
+          <AppLink
+            key={link.href}
+            href={link.href}
+            className="flex items-center gap-2 rounded-md border border-input/60 px-3 py-2 text-sm transition-colors hover:bg-accent/60"
+          >
+            <link.icon className="h-4 w-4 shrink-0 text-muted-foreground" />
+            <span className="min-w-0 flex-1 truncate">{link.label}</span>
+            <span className="text-xs tabular-nums text-muted-foreground">{link.value}</span>
+          </AppLink>
+        ))}
+      </div>
+    </div>
+  );
+}
+
+function ArchiveSection({
+  space,
+  isLastActiveSpace,
+}: {
+  space: Space;
+  isLastActiveSpace: boolean;
+}) {
+  const { t } = useT("spaces");
+  const wsId = useWorkspaceId();
+  const { role } = useCurrentMember(wsId);
+  const isAdmin = role === "owner" || role === "admin";
+  const archiveSpace = useArchiveSpace();
+  const [confirmOpen, setConfirmOpen] = useState(false);
+
+  // Only an already-archived space drops the section (archiving it again is
+  // meaningless). Every other blocked state renders disabled with the reason
+  // in a tooltip — nothing is hidden, so the rule is always discoverable.
+  if (space.archived_at) return null;
+  const blockedReason = isLastActiveSpace
+    ? "last"
+    : !isAdmin
+      ? "admin"
+      : null;
+
+  const doArchive = async () => {
+    setConfirmOpen(false);
+    try {
+      await archiveSpace.mutateAsync(space.id);
+      toast.success(t(($) => $.toast_archived));
+    } catch (err) {
+      toast.error(
+        err instanceof Error && err.message ? err.message : t(($) => $.toast_archive_failed),
+      );
+    }
+  };
+
+  return (
+    <div className="flex flex-col gap-1">
+      <h3 className="mb-1 text-xs font-medium text-muted-foreground">
+        {t(($) => $.settings.danger_title)}
+      </h3>
+      {/* Archiving is admin-only and never allowed on a workspace's last
+          active space (server enforces both). Blocked states stay visible
+          but disabled with the reason, so users learn the rule instead of
+          wondering where the action went. */}
+      <Tooltip>
+        <TooltipTrigger render={<span className="-mx-1.5 inline-flex w-fit" />}>
+          <button
+            type="button"
+            disabled={blockedReason !== null}
+            onClick={() => setConfirmOpen(true)}
+            className="flex items-center rounded-md px-1.5 py-1 text-left text-sm text-destructive transition-colors hover:bg-destructive/10 disabled:cursor-not-allowed disabled:opacity-50 disabled:hover:bg-transparent"
+          >
+            {t(($) => $.actions.archive)}
+          </button>
+        </TooltipTrigger>
+        {blockedReason !== null && (
+          <TooltipContent>
+            {blockedReason === "last"
+              ? t(($) => $.settings.last_space_cannot_archive)
+              : t(($) => $.settings.archive_admin_only)}
+          </TooltipContent>
+        )}
+      </Tooltip>
+
+      <Dialog open={confirmOpen} onOpenChange={setConfirmOpen}>
+        <DialogContent showCloseButton={false} className="sm:max-w-sm">
+          <DialogTitle>{t(($) => $.settings.archive_confirm_title)}</DialogTitle>
+          <DialogDescription>
+            {t(($) => $.settings.archive_confirm_body, { name: space.name })}
+          </DialogDescription>
+          <DialogFooter>
+            <Button variant="outline" onClick={() => setConfirmOpen(false)}>
+              {t(($) => $.actions.cancel)}
+            </Button>
+            <Button variant="destructive" onClick={doArchive}>
+              {t(($) => $.actions.archive)}
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </div>
+  );
+}
diff --git a/packages/views/spaces/components/space-icon.tsx b/packages/views/spaces/components/space-icon.tsx
new file mode 100644
index 0000000000..2130104a89
--- /dev/null
+++ b/packages/views/spaces/components/space-icon.tsx
@@ -0,0 +1,26 @@
+import { Users } from "lucide-react";
+import { cn } from "@multica/ui/lib/utils";
+import type { Space } from "@multica/core/types";
+
+/**
+ * Space avatar: renders the space's custom icon (emoji, set in the space
+ * dialog) when present, otherwise a default glyph on a neutral block.
+ * Custom icon upload / per-space colors are planned — this fallback block
+ * is where the future `space.color` field lands; until then it stays on
+ * semantic neutrals so it reads as "unset" rather than a chosen color.
+ */
+export function SpaceIcon({ space, className }: { space: Pick<Space, "icon">; className?: string }) {
+  return (
+    <span
+      className={cn(
+        "flex size-4 shrink-0 items-center justify-center rounded-sm",
+        space.icon
+          ? "bg-transparent text-sm leading-none"
+          : "bg-muted text-muted-foreground",
+        className,
+      )}
+    >
+      {space.icon ? space.icon : <Users className="size-3" />}
+    </span>
+  );
+}
diff --git a/packages/views/spaces/components/space-picker.tsx b/packages/views/spaces/components/space-picker.tsx
new file mode 100644
index 0000000000..39ae047ca3
--- /dev/null
+++ b/packages/views/spaces/components/space-picker.tsx
@@ -0,0 +1,187 @@
+"use client";
+
+import type { ReactElement } from "react";
+import { Check, Users } from "lucide-react";
+import { useQuery } from "@tanstack/react-query";
+import { activeSpaceListOptions } from "@multica/core/spaces/queries";
+import { useWorkspaceId } from "@multica/core/hooks";
+import {
+  DropdownMenu,
+  DropdownMenuCheckboxItem,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from "@multica/ui/components/ui/dropdown-menu";
+import type { Space } from "@multica/core/types";
+import { SpaceIcon } from "./space-icon";
+import { useT } from "../../i18n";
+
+// icon + key: how a space is identified everywhere (picker rows, triggers).
+function SpaceBadge({ space }: { space: Space }) {
+  return (
+    <span className="flex items-center gap-1.5 overflow-hidden">
+      <SpaceIcon space={space} />
+      <span className="shrink-0 text-[10px] font-medium text-muted-foreground">
+        {space.key}
+      </span>
+    </span>
+  );
+}
+
+// Single-select and non-clearable by design: every issue belongs to exactly
+// one space, so the picker never offers an empty state — `spaceId` is only
+// null while the space list is still loading.
+export function SpacePicker({
+  spaceId,
+  onChange,
+  triggerRender,
+  align = "start",
+  disabled = false,
+}: {
+  spaceId: string | null;
+  onChange: (spaceId: string) => void;
+  triggerRender?: ReactElement;
+  align?: "start" | "center" | "end";
+  // Locked display (e.g. sub-issues inherit the parent's space server-side).
+  disabled?: boolean;
+}) {
+  const { t } = useT("spaces");
+  const wsId = useWorkspaceId();
+  // Always the full active list: space is a creation-time default, never
+  // constrained by the selected project (the old allowedSpaceIds filter was
+  // a strong-association-model leftover).
+  const { data: spaces = [] } = useQuery(activeSpaceListOptions(wsId));
+  const current = spaces.find((space) => space.id === spaceId);
+
+  return (
+    <DropdownMenu>
+      <DropdownMenuTrigger
+        disabled={disabled}
+        className={
+          triggerRender
+            ? undefined
+            : "flex items-center gap-1.5 cursor-pointer rounded px-1 -mx-1 hover:bg-accent/30 transition-colors overflow-hidden disabled:cursor-default disabled:hover:bg-transparent"
+        }
+        render={triggerRender}
+      >
+        {/* Trigger shows icon + name — the key alone reads as an opaque
+            identifier out of context (e.g. an auto-normalized "T2323");
+            key + name live together in the menu items. */}
+        {current ? (
+          <>
+            <SpaceIcon space={current} />
+            <span className="truncate">{current.name}</span>
+          </>
+        ) : (
+          <>
+            <Users className="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+            <span className="truncate">{t(($) => $.picker.placeholder)}</span>
+          </>
+        )}
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align={align} className="w-56">
+        {spaces.map((space) => (
+          <DropdownMenuItem key={space.id} onClick={() => onChange(space.id)}>
+            <SpaceBadge space={space} />
+            <span className="truncate">{space.name}</span>
+            {space.id === spaceId && (
+              <Check className="ml-auto h-3.5 w-3.5 shrink-0" />
+            )}
+          </DropdownMenuItem>
+        ))}
+        {spaces.length === 0 && (
+          <div className="px-2 py-1.5 text-xs text-muted-foreground">
+            {t(($) => $.picker.empty)}
+          </div>
+        )}
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+}
+
+export function SpaceMultiPicker({
+  spaceIds,
+  onChange,
+  triggerRender,
+  align = "start",
+  disabled = false,
+}: {
+  spaceIds: string[];
+  onChange: (spaceIds: string[]) => void;
+  triggerRender?: ReactElement;
+  align?: "start" | "center" | "end";
+  // Display-only rendering of the current selection.
+  disabled?: boolean;
+}) {
+  const { t } = useT("spaces");
+  const wsId = useWorkspaceId();
+  const { data: spaces = [] } = useQuery(activeSpaceListOptions(wsId));
+  const selected = spaces.filter((space) => spaceIds.includes(space.id));
+
+  const toggle = (spaceId: string) => {
+    onChange(
+      spaceIds.includes(spaceId)
+        ? spaceIds.filter((id) => id !== spaceId)
+        : [...spaceIds, spaceId],
+    );
+  };
+
+  return (
+    <DropdownMenu>
+      <DropdownMenuTrigger
+        disabled={disabled}
+        className={
+          triggerRender
+            ? undefined
+            : "flex items-center gap-1.5 cursor-pointer rounded px-1 -mx-1 hover:bg-accent/30 transition-colors overflow-hidden disabled:cursor-default disabled:hover:bg-transparent"
+        }
+        render={triggerRender}
+      >
+        {/* Mirror the single picker's icon+name trigger when exactly one space
+            is selected; degrade to icons+count for multiple. */}
+        {selected.length === 0 ? (
+          <>
+            <Users className="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+            <span className="truncate">{t(($) => $.picker.placeholder)}</span>
+          </>
+        ) : selected.length === 1 ? (
+          <>
+            <SpaceIcon space={selected[0]!} />
+            <span className="truncate">{selected[0]!.name}</span>
+          </>
+        ) : (
+          <>
+            <span className="flex shrink-0 items-center gap-0.5">
+              {selected.slice(0, 3).map((space) => (
+                <SpaceIcon key={space.id} space={space} />
+              ))}
+            </span>
+            <span className="truncate">
+              {t(($) => $.picker.selected_count, { count: selected.length })}
+            </span>
+          </>
+        )}
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align={align} className="w-56">
+        {spaces.map((space) => {
+          const checked = spaceIds.includes(space.id);
+          return (
+            <DropdownMenuCheckboxItem
+              key={space.id}
+              checked={checked}
+              onCheckedChange={() => toggle(space.id)}
+            >
+              <SpaceBadge space={space} />
+              <span className="truncate">{space.name}</span>
+            </DropdownMenuCheckboxItem>
+          );
+        })}
+        {spaces.length === 0 && (
+          <div className="px-2 py-1.5 text-xs text-muted-foreground">
+            {t(($) => $.picker.empty)}
+          </div>
+        )}
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+}
diff --git a/packages/views/spaces/components/space-project-conflict-dialog.tsx b/packages/views/spaces/components/space-project-conflict-dialog.tsx
new file mode 100644
index 0000000000..5c8e05092b
--- /dev/null
+++ b/packages/views/spaces/components/space-project-conflict-dialog.tsx
@@ -0,0 +1,87 @@
+"use client";
+
+import { Check } from "lucide-react";
+import type { Space } from "@multica/core/types";
+import {
+  Dialog,
+  DialogContent,
+  DialogTitle,
+  DialogDescription,
+} from "@multica/ui/components/ui/dialog";
+import { SpaceIcon } from "./space-icon";
+import { useT } from "../../i18n";
+
+/**
+ * Resolution dialog for "the issue's space is not part of the selected
+ * project" (Linear-style). The first option mirrors the server-side default
+ * for headless callers — adding the space to the project — so confirming it
+ * simply proceeds; picking a project space instead retargets the issue.
+ */
+export function SpaceProjectConflictDialog({
+  open,
+  spaceName,
+  projectName,
+  projectSpaces,
+  onAddSpace,
+  onMoveToSpace,
+  onCancel,
+}: {
+  open: boolean;
+  spaceName: string;
+  projectName: string;
+  /** The project's current spaces, offered as "move the issue there" targets. */
+  projectSpaces: Space[];
+  onAddSpace: () => void;
+  onMoveToSpace: (spaceId: string) => void;
+  onCancel: () => void;
+}) {
+  const { t } = useT("spaces");
+  return (
+    <Dialog
+      open={open}
+      onOpenChange={(next) => {
+        if (!next) onCancel();
+      }}
+    >
+      <DialogContent showCloseButton={false} className="sm:max-w-md">
+        <DialogTitle>{t(($) => $.conflict.title, { space: spaceName })}</DialogTitle>
+        <DialogDescription>
+          {t(($) => $.conflict.body, { space: spaceName, project: projectName })}
+        </DialogDescription>
+        <div className="flex flex-col gap-1">
+          <button
+            type="button"
+            autoFocus
+            onClick={onAddSpace}
+            className="flex items-center gap-2 rounded-md border border-input bg-accent/40 px-3 py-2 text-left text-sm transition-colors hover:bg-accent"
+          >
+            <span className="min-w-0 flex-1 truncate">
+              {t(($) => $.conflict.add_space, { space: spaceName })}
+            </span>
+            <Check className="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+          </button>
+          {projectSpaces.length > 0 && (
+            <>
+              <div className="px-1 pt-1 text-xs text-muted-foreground">
+                {t(($) => $.conflict.project_spaces)}
+              </div>
+              {projectSpaces.map((space) => (
+                <button
+                  key={space.id}
+                  type="button"
+                  onClick={() => onMoveToSpace(space.id)}
+                  className="flex items-center gap-2 rounded-md px-3 py-2 text-left text-sm transition-colors hover:bg-accent/60"
+                >
+                  <SpaceIcon space={space} />
+                  <span className="min-w-0 flex-1 truncate">
+                    {t(($) => $.conflict.move_issue, { space: space.name })}
+                  </span>
+                </button>
+              ))}
+            </>
+          )}
+        </div>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/packages/views/spaces/components/space-surface-pages.tsx b/packages/views/spaces/components/space-surface-pages.tsx
new file mode 100644
index 0000000000..c25149d8ad
--- /dev/null
+++ b/packages/views/spaces/components/space-surface-pages.tsx
@@ -0,0 +1,93 @@
+"use client";
+
+import { ListTodo } from "lucide-react";
+import { useQuery } from "@tanstack/react-query";
+import { useWorkspaceId } from "@multica/core/hooks";
+import { activeSpaceListOptions } from "@multica/core/spaces/queries";
+import type { Space } from "@multica/core/types";
+import { useWorkspacePaths } from "@multica/core/paths";
+import { AppLink } from "../../navigation";
+import { PageHeader } from "../../layout/page-header";
+import { IssueSurface } from "../../issues/surface/issue-surface";
+import { IssuesSurfaceHeader } from "../../issues/components/issues-page";
+import { ProjectsPage } from "../../projects/components/projects-page";
+import { AutopilotsPage } from "../../autopilots/components/autopilots-page";
+import { SpaceIcon } from "./space-icon";
+import { useT } from "../../i18n";
+
+/**
+ * Space surface pages — the sidebar's per-space children (/space/:key/...).
+ * Spaces are addressed by key (readable URLs; keys freeze once a space has
+ * issues), resolved against the cached space list.
+ */
+function useSpaceByKey(spaceKey: string): { space: Space | undefined; resolved: boolean } {
+  const wsId = useWorkspaceId();
+  const { data: spaces = [], isSuccess } = useQuery(activeSpaceListOptions(wsId));
+  const space = spaces.find((t) => t.key.toLowerCase() === spaceKey.toLowerCase());
+  return { space, resolved: isSuccess };
+}
+
+function SpaceNotFound() {
+  const { t } = useT("spaces");
+  return (
+    <div className="flex flex-1 min-h-0 items-center justify-center text-sm text-muted-foreground">
+      {t(($) => $.surface.not_found)}
+    </div>
+  );
+}
+
+export function SpaceIssuesPage({ spaceKey }: { spaceKey: string }) {
+  const { t } = useT("issues");
+  const p = useWorkspacePaths();
+  const { space, resolved } = useSpaceByKey(spaceKey);
+  if (!space) return resolved ? <SpaceNotFound /> : null;
+
+  return (
+    <div className="flex flex-1 min-h-0 flex-col">
+      <PageHeader className="gap-2">
+        {/* Space name links into the space's settings page. */}
+        <AppLink
+          href={p.spaceDetail(space.key)}
+          className="flex items-center gap-2 rounded px-1 -mx-1 transition-colors hover:bg-accent/40"
+        >
+          <SpaceIcon space={space} />
+          <h1 className="text-sm font-medium">{space.name}</h1>
+        </AppLink>
+        <span className="text-xs text-muted-foreground">
+          {t(($) => $.page.breadcrumb_title)}
+        </span>
+      </PageHeader>
+
+      <IssueSurface
+        scope={{ type: "space", spaceId: space.id }}
+        modes={["board", "list", "swimlane"]}
+        batchToolbar="list"
+        renderHeader={({ controller }) => (
+          <IssuesSurfaceHeader
+            issues={controller.surfaceIssues}
+            isRefreshing={controller.isRefreshing}
+          />
+        )}
+        renderEmpty={() => (
+          <div className="flex flex-1 min-h-0 flex-col items-center justify-center gap-2 text-muted-foreground">
+            <ListTodo className="h-10 w-10 text-muted-foreground/40" />
+            <p className="text-sm">{t(($) => $.page.empty_title)}</p>
+            <p className="text-xs">{t(($) => $.page.empty_hint)}</p>
+          </div>
+        )}
+      />
+    </div>
+  );
+}
+
+export function SpaceProjectsPage({ spaceKey }: { spaceKey: string }) {
+  const { space, resolved } = useSpaceByKey(spaceKey);
+  if (!space) return resolved ? <SpaceNotFound /> : null;
+  return <ProjectsPage spaceId={space.id} />;
+}
+
+export function SpaceAutopilotsPage({ spaceKey }: { spaceKey: string }) {
+  const { space, resolved } = useSpaceByKey(spaceKey);
+  if (!space) return resolved ? <SpaceNotFound /> : null;
+  return <AutopilotsPage spaceId={space.id} />;
+}
diff --git a/packages/views/spaces/index.ts b/packages/views/spaces/index.ts
new file mode 100644
index 0000000000..0642b21443
--- /dev/null
+++ b/packages/views/spaces/index.ts
@@ -0,0 +1,10 @@
+export {
+  SpacePicker,
+  SpaceMultiPicker,
+  SpaceIcon,
+  SpaceIssuesPage,
+  SpaceProjectsPage,
+  SpaceAutopilotsPage,
+  SpaceDetailPage,
+  CreateSpacePage,
+} from "./components";
diff --git a/packages/views/workspace/create-workspace-form.tsx b/packages/views/workspace/create-workspace-form.tsx
index 944fea6f29..3da8d6bca2 100644
--- a/packages/views/workspace/create-workspace-form.tsx
+++ b/packages/views/workspace/create-workspace-form.tsx
@@ -61,7 +61,10 @@ export function CreateWorkspaceForm({ onSuccess }: CreateWorkspaceFormProps) {
   const handleCreate = () => {
     if (!canSubmit) return;
     createWorkspace.mutate(
-      { name: name.trim(), slug: slug.trim() },
+      {
+        name: name.trim(),
+        slug: slug.trim(),
+      },
       {
         onSuccess,
         onError: (error) => {
diff --git a/packages/views/workspace/welcome-after-onboarding.test.tsx b/packages/views/workspace/welcome-after-onboarding.test.tsx
index 9bacc2db4b..24b19aac04 100644
--- a/packages/views/workspace/welcome-after-onboarding.test.tsx
+++ b/packages/views/workspace/welcome-after-onboarding.test.tsx
@@ -294,7 +294,7 @@ describe("WelcomeAfterOnboarding", () => {
       // Navigates to the first issue (intro, since it's earlier in
       // STARTER_CARD_IDS).
       await waitFor(() =>
-        expect(mockPush).toHaveBeenCalledWith("/test-ws/issues/issue-intro"),
+        expect(mockPush).toHaveBeenCalledWith("/test-ws/issue/issue-intro"),
       );
     });
 
diff --git a/scripts/generate-reserved-slugs.mjs b/scripts/generate-reserved-slugs.mjs
index 220ee4ec4f..86a0ac5d4d 100644
--- a/scripts/generate-reserved-slugs.mjs
+++ b/scripts/generate-reserved-slugs.mjs
@@ -34,7 +34,7 @@ lines.push(" * The Go backend embeds that JSON; this file is regenerated from it
 lines.push(" *");
 lines.push(" * Convention for new global routes (CLAUDE.md): use a single word");
 lines.push(" * (`/login`, `/inbox`) or `/{noun}/{verb}` (`/workspaces/new`). Hyphenated");
-lines.push(" * root-level word groups (`/new-workspace`, `/create-team`) collide with");
+lines.push(" * root-level word groups (`/new-workspace`, `/create-space`) collide with");
 lines.push(" * common user workspace names — see PR for full discussion.");
 lines.push(" */");
 lines.push("export const RESERVED_SLUGS: ReadonlySet<string> = new Set([");
diff --git a/server/cmd/migrate/space_number_cutover_test.go b/server/cmd/migrate/space_number_cutover_test.go
new file mode 100644
index 0000000000..57ca9ee934
--- /dev/null
+++ b/server/cmd/migrate/space_number_cutover_test.go
@@ -0,0 +1,358 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"math/rand/v2"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+	"github.com/multica-ai/multica/server/internal/migrations"
+)
+
+// Migration B (132_space_number_cutover) end-to-end invariant test.
+//
+// The full migration chain cannot be replayed locally (084/101 need pg15+
+// UNIQUE NULLS NOT DISTINCT and the dev box only has pg14), and Docker is
+// unavailable in most sandboxes, so this test is deliberately CI-shaped: it
+// connects to whatever DATABASE_URL points at (default the local dev DSN),
+// and if Postgres is unreachable it SKIPS cleanly — the same pattern as
+// migrate_concurrent_test.go and every other live-Postgres test in the repo.
+//
+// Rather than replay all 132 migrations, it builds a *synthetic minimal
+// schema* — just the tables and the uq_issue_workspace_number constraint that
+// 131 and 132 actually reference — inside a private throwaway schema
+// (cutover_test_<ts>_<rand>) with search_path pinned to it. Then it applies the
+// real 131 + 132 SQL files through the production runMigrations loop and
+// asserts the numbering invariant:
+//
+//   - re-backfill: a NULL-space straggler written during the deploy window is
+//     assigned the default Space by 132;
+//   - counter sync: the default Space's issue_counter never regresses and rises
+//     to cover both max(number) and the legacy workspace.issue_counter;
+//   - cutover: issue.space_id / autopilot.space_id become NOT NULL, the legacy
+//     uq_issue_workspace_number is gone, uq_issue_space_number is in place;
+//   - per-space numbering: two Spaces' number-1 issues coexist in one workspace,
+//     while a duplicate (space_id, number) is rejected.
+//
+// Two negative tests prove the safe-by-construction preflight RAISEs (and rolls
+// back before any destructive DDL) when its invariants are violated.
+
+func cutoverDSN() string {
+	dsn := os.Getenv("DATABASE_URL")
+	if dsn == "" {
+		dsn = "postgres://multica:multica@localhost:5432/multica?sslmode=disable"
+	}
+	return dsn
+}
+
+// newCutoverSchema opens a pool whose connections are pinned to a fresh private
+// schema via search_path, so the migrations' unqualified table names resolve to
+// synthetic fixtures instead of the real public schema. Skips when the DB is
+// unreachable; drops the schema on cleanup.
+func newCutoverSchema(t *testing.T) (*pgxpool.Pool, string) {
+	t.Helper()
+	schema := fmt.Sprintf("cutover_test_%d_%d", time.Now().UnixNano(), rand.Uint32())
+
+	cfg, err := pgxpool.ParseConfig(cutoverDSN())
+	if err != nil {
+		t.Skipf("parse DATABASE_URL: %v", err)
+	}
+	// Pinning search_path to a not-yet-existing schema is allowed by Postgres;
+	// the schema is created below before any unqualified name is used.
+	cfg.ConnConfig.RuntimeParams["search_path"] = schema
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	pool, err := pgxpool.NewWithConfig(ctx, cfg)
+	if err != nil {
+		t.Skipf("could not open pool: %v", err)
+	}
+	if err := pool.Ping(ctx); err != nil {
+		pool.Close()
+		t.Skipf("database not reachable at %s: %v", cutoverDSN(), err)
+	}
+	if _, err := pool.Exec(ctx, fmt.Sprintf("CREATE SCHEMA %s", pgx.Identifier{schema}.Sanitize())); err != nil {
+		pool.Close()
+		t.Fatalf("create schema: %v", err)
+	}
+	t.Cleanup(func() {
+		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+		defer cancel()
+		if _, err := pool.Exec(ctx, fmt.Sprintf("DROP SCHEMA IF EXISTS %s CASCADE", pgx.Identifier{schema}.Sanitize())); err != nil {
+			t.Logf("drop schema %s: %v", schema, err)
+		}
+		pool.Close()
+	})
+	return pool, schema
+}
+
+// syntheticBaseSchema is the minimal pre-131 schema: only the columns and
+// constraints that migrations 131 and 132 read or alter. Names must match
+// exactly (uq_issue_workspace_number, member/project/user FK targets).
+const syntheticBaseSchema = `
+CREATE TABLE "user" (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid()
+);
+CREATE TABLE workspace (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    name TEXT NOT NULL DEFAULT '',
+    issue_prefix TEXT NOT NULL DEFAULT '',
+    issue_counter INT NOT NULL DEFAULT 0
+);
+CREATE TABLE member (
+    workspace_id UUID NOT NULL,
+    user_id UUID NOT NULL,
+    role TEXT NOT NULL DEFAULT 'member',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (workspace_id, user_id)
+);
+CREATE TABLE project (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    workspace_id UUID NOT NULL
+);
+CREATE TABLE issue (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    workspace_id UUID NOT NULL,
+    number INT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'todo',
+    position DOUBLE PRECISION NOT NULL DEFAULT 0,
+    project_id UUID,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    CONSTRAINT uq_issue_workspace_number UNIQUE (workspace_id, number)
+);
+CREATE TABLE autopilot (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    workspace_id UUID NOT NULL
+);
+`
+
+func execCutover(t *testing.T, pool *pgxpool.Pool, sql string, args ...any) {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	if _, err := pool.Exec(ctx, sql, args...); err != nil {
+		t.Fatalf("exec %q: %v", sql, err)
+	}
+}
+
+// applyCutoverMigration runs a single real migration file through the
+// production runMigrations loop against the pinned pool + private
+// schema_migrations table. A unique advisory-lock key per call keeps it from
+// blocking on a real migration runner sharing the same database.
+func applyCutoverMigration(pool *pgxpool.Pool, schema, path string) error {
+	ctx, cancel := context.WithTimeout(context.Background(), raceTestTimeout)
+	defer cancel()
+	return runMigrations(ctx, pool, runOptions{
+		Direction:             "up",
+		Files:                 []string{path},
+		SchemaMigrationsTable: schema + ".schema_migrations",
+		AdvisoryLockKey:       int64(rand.Uint64()&0x7fffffffffffffff) | 1,
+	})
+}
+
+func cutoverFilePaths(t *testing.T) (up131, up132 string) {
+	t.Helper()
+	dir, err := migrations.ResolveDir()
+	if err != nil {
+		t.Fatalf("resolve migrations dir: %v", err)
+	}
+	up131 = filepath.Join(dir, "131_workspace_space.up.sql")
+	up132 = filepath.Join(dir, "132_space_number_cutover.up.sql")
+	for _, p := range []string{up131, up132} {
+		if _, err := os.Stat(p); err != nil {
+			t.Fatalf("migration file missing: %s: %v", p, err)
+		}
+	}
+	return up131, up132
+}
+
+// seedPre131 creates one workspace (prefix ENG, counter 3) with an owner and
+// three legacy issues (numbers 1..3, NULL space) and returns the workspace id.
+func seedPre131(t *testing.T, pool *pgxpool.Pool) string {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	var userID, wsID string
+	if err := pool.QueryRow(ctx, `INSERT INTO "user" DEFAULT VALUES RETURNING id`).Scan(&userID); err != nil {
+		t.Fatalf("insert user: %v", err)
+	}
+	if err := pool.QueryRow(ctx,
+		`INSERT INTO workspace (name, issue_prefix, issue_counter) VALUES ('Acme', 'ENG', 3) RETURNING id`,
+	).Scan(&wsID); err != nil {
+		t.Fatalf("insert workspace: %v", err)
+	}
+	execCutover(t, pool, `INSERT INTO member (workspace_id, user_id, role) VALUES ($1, $2, 'owner')`, wsID, userID)
+	for n := 1; n <= 3; n++ {
+		execCutover(t, pool,
+			`INSERT INTO issue (workspace_id, number, status) VALUES ($1, $2, 'todo')`, wsID, n)
+	}
+	return wsID
+}
+
+func constraintExists(t *testing.T, pool *pgxpool.Pool, name string) bool {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	var exists bool
+	if err := pool.QueryRow(ctx,
+		`SELECT EXISTS(SELECT 1 FROM pg_constraint WHERE conname = $1 AND conrelid = 'issue'::regclass)`,
+		name,
+	).Scan(&exists); err != nil {
+		t.Fatalf("check constraint %s: %v", name, err)
+	}
+	return exists
+}
+
+func TestMigration132CutoverInvariant(t *testing.T) {
+	pool, schema := newCutoverSchema(t)
+	up131, up132 := cutoverFilePaths(t)
+
+	execCutover(t, pool, syntheticBaseSchema)
+	wsID := seedPre131(t, pool)
+
+	if err := applyCutoverMigration(pool, schema, up131); err != nil {
+		t.Fatalf("apply 131: %v", err)
+	}
+
+	// Simulate the deploy window: an old, space-unaware instance mints issue #4
+	// with a NULL space_id and advances the legacy workspace counter to 5.
+	execCutover(t, pool, `INSERT INTO issue (workspace_id, number, status) VALUES ($1, 4, 'todo')`, wsID)
+	execCutover(t, pool, `UPDATE workspace SET issue_counter = 5 WHERE id = $1`, wsID)
+
+	if err := applyCutoverMigration(pool, schema, up132); err != nil {
+		t.Fatalf("apply 132: %v", err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	// Re-backfill: no issue may still carry a NULL space_id.
+	var nullSpaceCount int
+	if err := pool.QueryRow(ctx, `SELECT count(*) FROM issue WHERE space_id IS NULL`).Scan(&nullSpaceCount); err != nil {
+		t.Fatalf("count null-space issues: %v", err)
+	}
+	if nullSpaceCount != 0 {
+		t.Fatalf("re-backfill left %d NULL-space issues, want 0", nullSpaceCount)
+	}
+
+	// Counter sync: default space counter = GREATEST(seeded 3, max number 4,
+	// legacy ws counter 5) = 5. It must never regress. No is_default flag — the
+	// default space is identified the same way GetDefaultWorkspaceSpace and
+	// migration 132 itself do: the workspace's earliest-created Space.
+	var defaultSpaceID string
+	var defaultCounter int
+	var defaultKey string
+	if err := pool.QueryRow(ctx,
+		`SELECT id, key, issue_counter FROM workspace_space WHERE workspace_id = $1 ORDER BY created_at ASC, id ASC LIMIT 1`, wsID,
+	).Scan(&defaultSpaceID, &defaultKey, &defaultCounter); err != nil {
+		t.Fatalf("read default space: %v", err)
+	}
+	if defaultCounter != 5 {
+		t.Fatalf("default space issue_counter = %d, want 5 (GREATEST of counter/max-number/ws-counter)", defaultCounter)
+	}
+	if defaultKey != "ENG" {
+		t.Fatalf("default space key = %q, want ENG", defaultKey)
+	}
+
+	// Cutover: legacy uniqueness gone, space-scoped uniqueness present.
+	if constraintExists(t, pool, "uq_issue_workspace_number") {
+		t.Fatal("uq_issue_workspace_number should have been dropped")
+	}
+	if !constraintExists(t, pool, "uq_issue_space_number") {
+		t.Fatal("uq_issue_space_number should exist after cutover")
+	}
+
+	// space_id is NOT NULL now: a NULL insert must fail.
+	if _, err := pool.Exec(ctx,
+		`INSERT INTO issue (workspace_id, space_id, number, status) VALUES ($1, NULL, 99, 'todo')`, wsID,
+	); err == nil {
+		t.Fatal("expected NOT NULL violation inserting issue with NULL space_id")
+	}
+
+	// Per-space numbering: a second Space's issue #1 coexists with ENG-1 in the
+	// same workspace (impossible under the dropped workspace-number unique).
+	var designSpaceID string
+	if err := pool.QueryRow(ctx,
+		`INSERT INTO workspace_space (workspace_id, name, key) VALUES ($1, 'Design', 'DES') RETURNING id`, wsID,
+	).Scan(&designSpaceID); err != nil {
+		t.Fatalf("insert design space: %v", err)
+	}
+	if _, err := pool.Exec(ctx,
+		`INSERT INTO issue (workspace_id, space_id, number, status) VALUES ($1, $2, 1, 'todo')`, wsID, designSpaceID,
+	); err != nil {
+		t.Fatalf("DES-1 should coexist with ENG-1: %v", err)
+	}
+	// But a duplicate (space_id, number) within one Space is rejected.
+	if _, err := pool.Exec(ctx,
+		`INSERT INTO issue (workspace_id, space_id, number, status) VALUES ($1, $2, 1, 'todo')`, wsID, designSpaceID,
+	); err == nil {
+		t.Fatal("expected uq_issue_space_number violation on duplicate DES-1")
+	}
+}
+
+func TestMigration132PreflightRejectsDuplicateSpaceNumber(t *testing.T) {
+	pool, schema := newCutoverSchema(t)
+	up131, up132 := cutoverFilePaths(t)
+
+	execCutover(t, pool, syntheticBaseSchema)
+	wsID := seedPre131(t, pool)
+	if err := applyCutoverMigration(pool, schema, up131); err != nil {
+		t.Fatalf("apply 131: %v", err)
+	}
+
+	// Force a duplicate (space_id, number): the legacy constraint normally makes
+	// this impossible, so drop it first, then mint a second default-space issue
+	// reusing number 1.
+	execCutover(t, pool, `ALTER TABLE issue DROP CONSTRAINT uq_issue_workspace_number`)
+	execCutover(t, pool, `
+		INSERT INTO issue (workspace_id, space_id, number, status)
+		SELECT $1, wt.id, 1, 'todo' FROM workspace_space wt WHERE wt.workspace_id = $1`, wsID)
+
+	err := applyCutoverMigration(pool, schema, up132)
+	if err == nil {
+		t.Fatal("expected 132 to fail on duplicate (space_id, number)")
+	}
+	if !strings.Contains(err.Error(), "duplicate") {
+		t.Fatalf("error %q does not mention duplicate preflight", err)
+	}
+	// Preflight RAISEs before the DDL, so the cutover constraint must not exist.
+	if constraintExists(t, pool, "uq_issue_space_number") {
+		t.Fatal("uq_issue_space_number must not be created when preflight fails")
+	}
+}
+
+func TestMigration132PreflightRejectsNullSpace(t *testing.T) {
+	pool, schema := newCutoverSchema(t)
+	up131, up132 := cutoverFilePaths(t)
+
+	execCutover(t, pool, syntheticBaseSchema)
+	wsID := seedPre131(t, pool)
+	if err := applyCutoverMigration(pool, schema, up131); err != nil {
+		t.Fatalf("apply 131: %v", err)
+	}
+
+	// Create an un-backfillable straggler: null out an issue's space and archive
+	// the workspace's only Space, so it's no longer a valid re-backfill target
+	// (132's re-backfill only considers archived_at IS NULL Spaces — there is no
+	// is_default flag to strip instead).
+	execCutover(t, pool, `UPDATE issue SET space_id = NULL WHERE workspace_id = $1 AND number = 1`, wsID)
+	execCutover(t, pool, `UPDATE workspace_space SET archived_at = now() WHERE workspace_id = $1`, wsID)
+
+	err := applyCutoverMigration(pool, schema, up132)
+	if err == nil {
+		t.Fatal("expected 132 to fail on remaining NULL space_id")
+	}
+	if !strings.Contains(err.Error(), "NULL space_id") {
+		t.Fatalf("error %q does not mention the NULL space_id preflight", err)
+	}
+	if constraintExists(t, pool, "uq_issue_space_number") {
+		t.Fatal("uq_issue_space_number must not be created when preflight fails")
+	}
+}
diff --git a/server/cmd/multica/cmd_autopilot.go b/server/cmd/multica/cmd_autopilot.go
index c10c2b93f7..3619c4023c 100644
--- a/server/cmd/multica/cmd_autopilot.go
+++ b/server/cmd/multica/cmd_autopilot.go
@@ -110,6 +110,7 @@ func init() {
 
 	// list
 	autopilotListCmd.Flags().String("status", "", "Filter by status (active, paused)")
+	autopilotListCmd.Flags().String("space", "", "Filter by Space UUID or key")
 	autopilotListCmd.Flags().String("output", "table", "Output format: table or json")
 	autopilotListCmd.Flags().Bool("full-id", false, "Show full UUIDs in table output")
 
@@ -122,6 +123,7 @@ func init() {
 	autopilotCreateCmd.Flags().String("agent", "", "Assignee agent (name or ID) — required")
 	autopilotCreateCmd.Flags().String("mode", "", "Execution mode: create_issue or run_only (required)")
 	autopilotCreateCmd.Flags().String("priority", "none", "Priority for created issues (none, low, medium, high, urgent)")
+	autopilotCreateCmd.Flags().String("space", "", "Space UUID or key")
 	autopilotCreateCmd.Flags().String("project", "", "Project ID (optional)")
 	autopilotCreateCmd.Flags().String("issue-title-template", "", "Template for issue titles (create_issue mode). Only {{date}} (UTC, YYYY-MM-DD) is interpolated; any other {{...}} token is rejected at create-time.")
 	autopilotCreateCmd.Flags().StringArray("subscriber", nil, "Member subscriber to notify for issues this autopilot creates (name or user ID; repeatable)")
@@ -131,6 +133,7 @@ func init() {
 	autopilotUpdateCmd.Flags().String("title", "", "New title")
 	autopilotUpdateCmd.Flags().String("description", "", "New description")
 	autopilotUpdateCmd.Flags().String("agent", "", "New assignee agent (name or ID)")
+	autopilotUpdateCmd.Flags().String("space", "", "New Space UUID or key")
 	autopilotUpdateCmd.Flags().String("project", "", "New project ID (use empty string to clear)")
 	autopilotUpdateCmd.Flags().String("priority", "", "New priority")
 	autopilotUpdateCmd.Flags().String("status", "", "New status (active, paused)")
@@ -186,9 +189,20 @@ func runAutopilotList(cmd *cobra.Command, _ []string) error {
 	ctx, cancel := cli.APIContext(context.Background())
 	defer cancel()
 
-	path := "/api/autopilots"
+	params := url.Values{}
 	if status, _ := cmd.Flags().GetString("status"); status != "" {
-		path += "?" + url.Values{"status": {status}}.Encode()
+		params.Set("status", status)
+	}
+	if v, _ := cmd.Flags().GetString("space"); v != "" {
+		spaceID, err := resolveSpaceRef(ctx, client, v)
+		if err != nil {
+			return fmt.Errorf("resolve space: %w", err)
+		}
+		params.Set("space_id", spaceID)
+	}
+	path := "/api/autopilots"
+	if len(params) > 0 {
+		path += "?" + params.Encode()
 	}
 
 	var resp struct {
@@ -313,6 +327,13 @@ func runAutopilotCreate(cmd *cobra.Command, _ []string) error {
 		}
 		body["project_id"] = projectRef.ID
 	}
+	if v, _ := cmd.Flags().GetString("space"); v != "" {
+		spaceID, err := resolveSpaceRef(ctx, client, v)
+		if err != nil {
+			return fmt.Errorf("resolve space: %w", err)
+		}
+		body["space_id"] = spaceID
+	}
 	if v, _ := cmd.Flags().GetString("issue-title-template"); v != "" {
 		body["issue_title_template"] = v
 	}
@@ -380,6 +401,18 @@ func runAutopilotUpdate(cmd *cobra.Command, args []string) error {
 			body["project_id"] = projectRef.ID
 		}
 	}
+	if cmd.Flags().Changed("space") {
+		v, _ := cmd.Flags().GetString("space")
+		if v == "" {
+			body["space_id"] = nil
+		} else {
+			spaceID, err := resolveSpaceRef(ctx, client, v)
+			if err != nil {
+				return fmt.Errorf("resolve space: %w", err)
+			}
+			body["space_id"] = spaceID
+		}
+	}
 	if cmd.Flags().Changed("priority") {
 		v, _ := cmd.Flags().GetString("priority")
 		body["priority"] = v
diff --git a/server/cmd/multica/cmd_issue.go b/server/cmd/multica/cmd_issue.go
index d8e626a330..39265de1a4 100644
--- a/server/cmd/multica/cmd_issue.go
+++ b/server/cmd/multica/cmd_issue.go
@@ -364,6 +364,7 @@ func init() {
 	issueListCmd.Flags().String("assignee", "", "Filter by assignee name (member, agent, or squad; fuzzy match)")
 	issueListCmd.Flags().String("assignee-id", "", "Filter by assignee UUID — member, agent, or squad (mutually exclusive with --assignee)")
 	issueListCmd.Flags().String("project", "", "Filter by project ID")
+	issueListCmd.Flags().String("space", "", "Filter by Space UUID")
 	issueListCmd.Flags().StringSlice("metadata", nil, "Filter by metadata key=value (repeatable; combined with AND). Value is JSON-parsed: 'true'/'false' → bool, numbers → number, otherwise string. Wrap as '\"42\"' to force a string when the value would otherwise sniff as a number.")
 	issueListCmd.Flags().Int("limit", 50, "Maximum number of issues to return")
 	issueListCmd.Flags().Int("offset", 0, "Number of issues to skip (for pagination)")
@@ -391,6 +392,7 @@ func init() {
 	issueCreateCmd.Flags().String("parent", "", "Parent issue ID")
 	issueCreateCmd.Flags().Int("stage", 0, "Stage ordinal (>=1) grouping this sub-issue into an ordered barrier group under its parent; omit for unstaged. The parent assignee is woken only when every sub-issue in a stage finishes.")
 	issueCreateCmd.Flags().String("project", "", "Project ID")
+	issueCreateCmd.Flags().String("space", "", "Space UUID")
 	issueCreateCmd.Flags().String("start-date", "", "Start date (calendar day, YYYY-MM-DD)")
 	issueCreateCmd.Flags().String("due-date", "", "Due date (calendar day, YYYY-MM-DD)")
 	issueCreateCmd.Flags().Bool("allow-duplicate", false, "Allow creating an issue even when an active duplicate exists")
@@ -411,6 +413,7 @@ func init() {
 	issueUpdateCmd.Flags().String("start-date", "", "New start date (calendar day, YYYY-MM-DD; pass empty string to clear)")
 	issueUpdateCmd.Flags().String("due-date", "", "New due date (calendar day, YYYY-MM-DD)")
 	issueUpdateCmd.Flags().String("parent", "", "Parent issue ID (use --parent \"\" to clear)")
+	issueUpdateCmd.Flags().String("space", "", "Move the issue to this Space (UUID or key); it is renumbered and the old identifier keeps resolving")
 	issueUpdateCmd.Flags().Int("stage", 0, "Stage ordinal (>=1) for this sub-issue; see `issue create --stage`")
 	issueUpdateCmd.Flags().Float64("position", 0, "Ordering position within the board column (lower sorts first); prefer `issue reorder` for relative moves")
 	issueUpdateCmd.Flags().String("output", "json", "Output format: table or json")
@@ -538,6 +541,9 @@ func runIssueList(cmd *cobra.Command, _ []string) error {
 		}
 		params.Set("project_id", project.ID)
 	}
+	if v, _ := cmd.Flags().GetString("space"); v != "" {
+		params.Set("space_id", v)
+	}
 	if mdFlags, _ := cmd.Flags().GetStringSlice("metadata"); len(mdFlags) > 0 {
 		filter, err := buildMetadataFilterQueryParam(mdFlags)
 		if err != nil {
@@ -973,6 +979,9 @@ func runIssueCreate(cmd *cobra.Command, _ []string) error {
 		}
 		body["project_id"] = project.ID
 	}
+	if v, _ := cmd.Flags().GetString("space"); v != "" {
+		body["space_id"] = v
+	}
 	if cmd.Flags().Changed("stage") {
 		stage, _ := cmd.Flags().GetInt("stage")
 		if stage < 1 {
@@ -1152,6 +1161,17 @@ func runIssueUpdate(cmd *cobra.Command, args []string) error {
 	if priorityChanged {
 		body["priority"] = priorityFlag
 	}
+	if cmd.Flags().Changed("space") {
+		v, _ := cmd.Flags().GetString("space")
+		if v == "" {
+			return fmt.Errorf("--space requires a Space UUID or key")
+		}
+		spaceID, err := resolveSpaceRef(ctx, client, v)
+		if err != nil {
+			return err
+		}
+		body["space_id"] = spaceID
+	}
 	if cmd.Flags().Changed("project") {
 		v, _ := cmd.Flags().GetString("project")
 		if v == "" {
diff --git a/server/cmd/multica/cmd_project.go b/server/cmd/multica/cmd_project.go
index a45d0c66ef..c1acc77b59 100644
--- a/server/cmd/multica/cmd_project.go
+++ b/server/cmd/multica/cmd_project.go
@@ -125,6 +125,7 @@ func init() {
 	projectListCmd.Flags().String("output", "table", "Output format: table or json")
 	projectListCmd.Flags().Bool("full-id", false, "Show full UUIDs in table output")
 	projectListCmd.Flags().String("status", "", "Filter by status")
+	projectListCmd.Flags().String("space", "", "Filter by Space UUID or key")
 
 	// project get
 	projectGetCmd.Flags().String("output", "json", "Output format: table or json")
@@ -135,6 +136,7 @@ func init() {
 	projectCreateCmd.Flags().String("status", "", "Project status")
 	projectCreateCmd.Flags().String("icon", "", "Project icon (emoji)")
 	projectCreateCmd.Flags().String("lead", "", "Lead name (member or agent)")
+	projectCreateCmd.Flags().StringArray("space", nil, "Space UUID or key (may be repeated)")
 	projectCreateCmd.Flags().StringArray("repo", nil, "Attach a github_repo resource by URL (may be repeated)")
 	projectCreateCmd.Flags().String("output", "json", "Output format: table or json")
 
@@ -178,6 +180,7 @@ func init() {
 	projectUpdateCmd.Flags().String("status", "", "New status")
 	projectUpdateCmd.Flags().String("icon", "", "New icon (emoji)")
 	projectUpdateCmd.Flags().String("lead", "", "New lead name (member or agent)")
+	projectUpdateCmd.Flags().StringArray("space", nil, "Replace project Spaces with these UUIDs or keys (may be repeated)")
 	projectUpdateCmd.Flags().String("output", "json", "Output format: table or json")
 
 	// project delete
@@ -207,6 +210,13 @@ func runProjectList(cmd *cobra.Command, _ []string) error {
 	if v, _ := cmd.Flags().GetString("status"); v != "" {
 		params.Set("status", v)
 	}
+	if v, _ := cmd.Flags().GetString("space"); v != "" {
+		spaceID, err := resolveSpaceRef(ctx, client, v)
+		if err != nil {
+			return fmt.Errorf("resolve space: %w", err)
+		}
+		params.Set("space_id", spaceID)
+	}
 
 	path := "/api/projects"
 	if len(params) > 0 {
@@ -332,6 +342,15 @@ func runProjectCreate(cmd *cobra.Command, _ []string) error {
 		body["lead_type"] = aType
 		body["lead_id"] = aID
 	}
+	if spaceRefs, _ := cmd.Flags().GetStringArray("space"); len(spaceRefs) > 0 {
+		spaceIDs, err := resolveSpaceRefs(ctx, client, spaceRefs)
+		if err != nil {
+			return fmt.Errorf("resolve space: %w", err)
+		}
+		if len(spaceIDs) > 0 {
+			body["space_ids"] = spaceIDs
+		}
+	}
 
 	// Bundle resources into the create payload so the server attaches them in
 	// the same transaction; this avoids leaving a half-attached project on
@@ -417,9 +436,17 @@ func runProjectUpdate(cmd *cobra.Command, args []string) error {
 		body["lead_type"] = aType
 		body["lead_id"] = aID
 	}
+	if cmd.Flags().Changed("space") {
+		spaceRefs, _ := cmd.Flags().GetStringArray("space")
+		spaceIDs, err := resolveSpaceRefs(ctx, client, spaceRefs)
+		if err != nil {
+			return fmt.Errorf("resolve space: %w", err)
+		}
+		body["space_ids"] = spaceIDs
+	}
 
 	if len(body) == 0 {
-		return fmt.Errorf("no fields to update; use flags like --title, --status, --description, --icon, --lead")
+		return fmt.Errorf("no fields to update; use flags like --title, --status, --description, --icon, --lead, --space")
 	}
 
 	var result map[string]any
diff --git a/server/cmd/multica/cmd_space.go b/server/cmd/multica/cmd_space.go
new file mode 100644
index 0000000000..2d0f4a8c91
--- /dev/null
+++ b/server/cmd/multica/cmd_space.go
@@ -0,0 +1,289 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"os"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/multica-ai/multica/server/internal/cli"
+)
+
+var spaceCmd = &cobra.Command{
+	Use:   "space",
+	Short: "Work with spaces",
+}
+
+var spaceListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List spaces in the workspace",
+	Args:  cobra.NoArgs,
+	RunE:  runSpaceList,
+}
+
+var spaceCreateCmd = &cobra.Command{
+	Use:   "create",
+	Short: "Create a new space",
+	Args:  cobra.NoArgs,
+	RunE:  runSpaceCreate,
+}
+
+var spaceUpdateCmd = &cobra.Command{
+	Use:   "update <space-id-or-key>",
+	Short: "Update a space",
+	Args:  exactArgs(1),
+	RunE:  runSpaceUpdate,
+}
+
+var spaceArchiveCmd = &cobra.Command{
+	Use:   "archive <space-id-or-key>",
+	Short: "Archive a space",
+	Args:  exactArgs(1),
+	RunE:  runSpaceArchive,
+}
+
+type spaceCLIResponse struct {
+	ID           string  `json:"id"`
+	WorkspaceID  string  `json:"workspace_id"`
+	Name         string  `json:"name"`
+	Key          string  `json:"key"`
+	Description  string  `json:"description"`
+	Icon         *string `json:"icon"`
+	IssueCounter int32   `json:"issue_counter"`
+	ArchivedAt   *string `json:"archived_at"`
+	CreatedAt    string  `json:"created_at"`
+	UpdatedAt    string  `json:"updated_at"`
+}
+
+type spaceCLIListResponse struct {
+	Spaces []spaceCLIResponse `json:"spaces"`
+	Total  int                `json:"total"`
+}
+
+func init() {
+	spaceCmd.AddCommand(spaceListCmd)
+	spaceCmd.AddCommand(spaceCreateCmd)
+	spaceCmd.AddCommand(spaceUpdateCmd)
+	spaceCmd.AddCommand(spaceArchiveCmd)
+
+	spaceListCmd.Flags().String("output", "table", "Output format: table or json")
+	spaceListCmd.Flags().Bool("full-id", false, "Show full UUIDs in table output")
+
+	spaceCreateCmd.Flags().String("name", "", "Space name (required)")
+	spaceCreateCmd.Flags().String("key", "", "Space key / issue prefix")
+	spaceCreateCmd.Flags().String("description", "", "Space description")
+	spaceCreateCmd.Flags().String("icon", "", "Space icon")
+	spaceCreateCmd.Flags().String("output", "json", "Output format: table or json")
+
+	spaceUpdateCmd.Flags().String("name", "", "New space name")
+	spaceUpdateCmd.Flags().String("key", "", "New Space key / issue prefix")
+	spaceUpdateCmd.Flags().String("description", "", "New space description")
+	spaceUpdateCmd.Flags().String("icon", "", "New space icon")
+	spaceUpdateCmd.Flags().String("output", "json", "Output format: table or json")
+
+	spaceArchiveCmd.Flags().String("output", "json", "Output format: table or json")
+}
+
+func spaceCollectionPath(client *cli.APIClient) string {
+	params := url.Values{}
+	if client.WorkspaceID != "" {
+		params.Set("workspace_id", client.WorkspaceID)
+	}
+	if len(params) == 0 {
+		return "/api/spaces"
+	}
+	return "/api/spaces?" + params.Encode()
+}
+
+func runSpaceList(cmd *cobra.Command, _ []string) error {
+	client, err := newAPIClient(cmd)
+	if err != nil {
+		return err
+	}
+	ctx, cancel := cli.APIContext(context.Background())
+	defer cancel()
+
+	var result spaceCLIListResponse
+	if err := client.GetJSON(ctx, spaceCollectionPath(client), &result); err != nil {
+		return fmt.Errorf("list spaces: %w", err)
+	}
+
+	output, _ := cmd.Flags().GetString("output")
+	if output == "json" {
+		return cli.PrintJSON(os.Stdout, result.Spaces)
+	}
+
+	fullID, _ := cmd.Flags().GetBool("full-id")
+	headers := []string{"ID", "KEY", "NAME", "ISSUES", "STATE"}
+	rows := make([][]string, 0, len(result.Spaces))
+	for _, space := range result.Spaces {
+		rows = append(rows, []string{
+			displayID(space.ID, fullID),
+			space.Key,
+			space.Name,
+			fmt.Sprintf("%d", space.IssueCounter),
+			spaceState(space),
+		})
+	}
+	cli.PrintTable(os.Stdout, headers, rows)
+	return nil
+}
+
+func runSpaceCreate(cmd *cobra.Command, _ []string) error {
+	name, _ := cmd.Flags().GetString("name")
+	if strings.TrimSpace(name) == "" {
+		return fmt.Errorf("--name is required")
+	}
+
+	body := map[string]any{"name": strings.TrimSpace(name)}
+	if key, _ := cmd.Flags().GetString("key"); strings.TrimSpace(key) != "" {
+		body["key"] = strings.TrimSpace(key)
+	}
+	if desc, _ := cmd.Flags().GetString("description"); desc != "" {
+		body["description"] = desc
+	}
+	if icon, _ := cmd.Flags().GetString("icon"); icon != "" {
+		body["icon"] = icon
+	}
+
+	client, err := newAPIClient(cmd)
+	if err != nil {
+		return err
+	}
+	ctx, cancel := cli.APIContext(context.Background())
+	defer cancel()
+
+	var result spaceCLIResponse
+	if err := client.PostJSON(ctx, "/api/spaces", body, &result); err != nil {
+		return fmt.Errorf("create space: %w", err)
+	}
+	return printSpaceResult(cmd, result)
+}
+
+func runSpaceUpdate(cmd *cobra.Command, args []string) error {
+	body := map[string]any{}
+	if cmd.Flags().Changed("name") {
+		name, _ := cmd.Flags().GetString("name")
+		body["name"] = strings.TrimSpace(name)
+	}
+	if cmd.Flags().Changed("key") {
+		key, _ := cmd.Flags().GetString("key")
+		body["key"] = strings.TrimSpace(key)
+	}
+	if cmd.Flags().Changed("description") {
+		desc, _ := cmd.Flags().GetString("description")
+		body["description"] = desc
+	}
+	if cmd.Flags().Changed("icon") {
+		icon, _ := cmd.Flags().GetString("icon")
+		body["icon"] = icon
+	}
+	if len(body) == 0 {
+		return fmt.Errorf("nothing to update; pass --name, --key, --description, or --icon")
+	}
+
+	client, err := newAPIClient(cmd)
+	if err != nil {
+		return err
+	}
+	ctx, cancel := cli.APIContext(context.Background())
+	defer cancel()
+
+	spaceID, err := resolveSpaceRef(ctx, client, args[0])
+	if err != nil {
+		return err
+	}
+
+	var result spaceCLIResponse
+	if err := client.PatchJSON(ctx, "/api/spaces/"+url.PathEscape(spaceID), body, &result); err != nil {
+		return fmt.Errorf("update space: %w", err)
+	}
+	return printSpaceResult(cmd, result)
+}
+
+func runSpaceArchive(cmd *cobra.Command, args []string) error {
+	client, err := newAPIClient(cmd)
+	if err != nil {
+		return err
+	}
+	ctx, cancel := cli.APIContext(context.Background())
+	defer cancel()
+
+	spaceID, err := resolveSpaceRef(ctx, client, args[0])
+	if err != nil {
+		return err
+	}
+
+	var result spaceCLIResponse
+	if err := client.DeleteJSONResponse(ctx, "/api/spaces/"+url.PathEscape(spaceID), &result); err != nil {
+		return fmt.Errorf("archive space: %w", err)
+	}
+	return printSpaceResult(cmd, result)
+}
+
+func resolveSpaceRef(ctx context.Context, client *cli.APIClient, ref string) (string, error) {
+	ref = strings.TrimSpace(ref)
+	if ref == "" {
+		return "", fmt.Errorf("space reference is required")
+	}
+	var result spaceCLIListResponse
+	if err := client.GetJSON(ctx, spaceCollectionPath(client), &result); err != nil {
+		return "", fmt.Errorf("list spaces: %w", err)
+	}
+	for _, space := range result.Spaces {
+		if space.ID == ref || strings.EqualFold(space.Key, ref) {
+			return space.ID, nil
+		}
+	}
+	return "", fmt.Errorf("space %q not found", ref)
+}
+
+func resolveSpaceRefs(ctx context.Context, client *cli.APIClient, refs []string) ([]string, error) {
+	ids := make([]string, 0, len(refs))
+	seen := map[string]struct{}{}
+	for _, ref := range refs {
+		ref = strings.TrimSpace(ref)
+		if ref == "" {
+			continue
+		}
+		id, err := resolveSpaceRef(ctx, client, ref)
+		if err != nil {
+			return nil, err
+		}
+		if _, ok := seen[id]; ok {
+			continue
+		}
+		seen[id] = struct{}{}
+		ids = append(ids, id)
+	}
+	return ids, nil
+}
+
+func printSpaceResult(cmd *cobra.Command, space spaceCLIResponse) error {
+	output, _ := cmd.Flags().GetString("output")
+	if output == "table" {
+		cli.PrintTable(os.Stdout, []string{"ID", "KEY", "NAME", "ISSUES", "STATE"}, [][]string{{
+			space.ID,
+			space.Key,
+			space.Name,
+			fmt.Sprintf("%d", space.IssueCounter),
+			spaceState(space),
+		}})
+		return nil
+	}
+	return cli.PrintJSON(os.Stdout, space)
+}
+
+func spaceState(space spaceCLIResponse) string {
+	var parts []string
+	if space.ArchivedAt != nil && *space.ArchivedAt != "" {
+		parts = append(parts, "archived")
+	}
+	if len(parts) == 0 {
+		return "active"
+	}
+	return strings.Join(parts, ",")
+}
diff --git a/server/cmd/multica/main.go b/server/cmd/multica/main.go
index e0415ba82c..ec10f6fc88 100644
--- a/server/cmd/multica/main.go
+++ b/server/cmd/multica/main.go
@@ -45,6 +45,7 @@ func init() {
 	// Core commands
 	issueCmd.GroupID = groupCore
 	projectCmd.GroupID = groupCore
+	spaceCmd.GroupID = groupCore
 	labelCmd.GroupID = groupCore
 	agentCmd.GroupID = groupCore
 	autopilotCmd.GroupID = groupCore
@@ -70,6 +71,7 @@ func init() {
 
 	rootCmd.AddCommand(issueCmd)
 	rootCmd.AddCommand(projectCmd)
+	rootCmd.AddCommand(spaceCmd)
 	rootCmd.AddCommand(labelCmd)
 	rootCmd.AddCommand(agentCmd)
 	rootCmd.AddCommand(autopilotCmd)
diff --git a/server/cmd/server/autopilot_dispatch_for_plan_test.go b/server/cmd/server/autopilot_dispatch_for_plan_test.go
index 131088495c..a01d56eba9 100644
--- a/server/cmd/server/autopilot_dispatch_for_plan_test.go
+++ b/server/cmd/server/autopilot_dispatch_for_plan_test.go
@@ -43,6 +43,7 @@ func TestDispatchAutopilotForPlanIsIdempotent(t *testing.T) {
 
 	ap, err := queries.CreateAutopilot(ctx, db.CreateAutopilotParams{
 		WorkspaceID:        parseUUID(testWorkspaceID),
+		SpaceID:            defaultSpaceUUID(t, ctx, testWorkspaceID),
 		Title:              "Dispatch for plan idempotency",
 		Description:        pgtype.Text{String: "Dispatch for plan test", Valid: true},
 		AssigneeType:       "agent",
@@ -167,6 +168,7 @@ func TestDispatchAutopilotSuppressesRecentDuplicateIssue(t *testing.T) {
 	title := "Autopilot recent duplicate issue " + time.Now().UTC().Format("20060102150405.000000000")
 	ap, err := queries.CreateAutopilot(ctx, db.CreateAutopilotParams{
 		WorkspaceID:        parseUUID(testWorkspaceID),
+		SpaceID:            defaultSpaceUUID(t, ctx, testWorkspaceID),
 		Title:              "Recent duplicate issue guard",
 		Description:        pgtype.Text{String: "Recent duplicate issue guard test", Valid: true},
 		AssigneeType:       "agent",
@@ -290,6 +292,7 @@ func TestDispatchAutopilotForPlanRecoversPartialRun(t *testing.T) {
 
 			ap, err := queries.CreateAutopilot(ctx, db.CreateAutopilotParams{
 				WorkspaceID:        parseUUID(testWorkspaceID),
+				SpaceID:            defaultSpaceUUID(t, ctx, testWorkspaceID),
 				Title:              "Partial recovery " + mode,
 				Description:        pgtype.Text{String: "partial run recovery test", Valid: true},
 				AssigneeType:       "agent",
diff --git a/server/cmd/server/autopilot_failure_monitor_test.go b/server/cmd/server/autopilot_failure_monitor_test.go
index 8eee7e6d72..4f13bb519b 100644
--- a/server/cmd/server/autopilot_failure_monitor_test.go
+++ b/server/cmd/server/autopilot_failure_monitor_test.go
@@ -33,6 +33,7 @@ func seedAutopilot(t *testing.T, queries *db.Queries, title, creatorType string,
 	ctx := context.Background()
 	ap, err := queries.CreateAutopilot(ctx, db.CreateAutopilotParams{
 		WorkspaceID:   parseUUID(testWorkspaceID),
+		SpaceID:       defaultSpaceUUID(t, ctx, testWorkspaceID),
 		Title:         title,
 		AssigneeType:  "agent",
 		AssigneeID:    agentID,
diff --git a/server/cmd/server/autopilot_listeners_test.go b/server/cmd/server/autopilot_listeners_test.go
index 49d5a683cb..f2b25eeaa8 100644
--- a/server/cmd/server/autopilot_listeners_test.go
+++ b/server/cmd/server/autopilot_listeners_test.go
@@ -60,6 +60,7 @@ func TestAutopilotRunOnlyTaskTerminalEventsUpdateRun(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			ap, err := queries.CreateAutopilot(ctx, db.CreateAutopilotParams{
 				WorkspaceID:        parseUUID(testWorkspaceID),
+				SpaceID:            defaultSpaceUUID(t, ctx, testWorkspaceID),
 				Title:              "Run-only listener " + tc.name,
 				Description:        pgtype.Text{String: "Run listener regression test", Valid: true},
 				AssigneeType:       "agent",
@@ -155,6 +156,7 @@ func dispatchCreateIssueAutopilot(t *testing.T, title string) linkedIssueAutopil
 
 	ap, err := queries.CreateAutopilot(ctx, db.CreateAutopilotParams{
 		WorkspaceID:        parseUUID(testWorkspaceID),
+		SpaceID:            defaultSpaceUUID(t, ctx, testWorkspaceID),
 		Title:              title,
 		Description:        pgtype.Text{String: "VEN-661 / VEN-662 regression test", Valid: true},
 		AssigneeType:       "agent",
@@ -352,6 +354,7 @@ func TestAutopilotDispatchSkipsWhenRuntimeOffline(t *testing.T) {
 
 	ap, err := queries.CreateAutopilot(ctx, db.CreateAutopilotParams{
 		WorkspaceID:        parseUUID(testWorkspaceID),
+		SpaceID:            defaultSpaceUUID(t, ctx, testWorkspaceID),
 		Title:              "Offline-runtime autopilot",
 		Description:        pgtype.Text{String: "MUL-1899 admission test", Valid: true},
 		AssigneeType:       "agent",
@@ -441,6 +444,7 @@ func TestAutopilotCreateIssueDispatchCreatesIssueWhenRuntimeOffline(t *testing.T
 
 	ap, err := queries.CreateAutopilot(ctx, db.CreateAutopilotParams{
 		WorkspaceID:        parseUUID(testWorkspaceID),
+		SpaceID:            defaultSpaceUUID(t, ctx, testWorkspaceID),
 		Title:              "Offline create-issue autopilot",
 		Description:        pgtype.Text{String: "WS-1325 regression test", Valid: true},
 		AssigneeType:       "agent",
@@ -553,6 +557,7 @@ func TestManualTriggerDoesNotErrorOnPostAdmissionSkip(t *testing.T) {
 
 	ap, err := queries.CreateAutopilot(ctx, db.CreateAutopilotParams{
 		WorkspaceID:        parseUUID(testWorkspaceID),
+		SpaceID:            defaultSpaceUUID(t, ctx, testWorkspaceID),
 		Title:              "Manual-trigger skip autopilot",
 		Description:        pgtype.Text{String: "PR #2888 review fix #2", Valid: true},
 		AssigneeType:       "agent",
diff --git a/server/cmd/server/autopilot_schedule_job_test.go b/server/cmd/server/autopilot_schedule_job_test.go
index 2f9d012e13..075c903bdd 100644
--- a/server/cmd/server/autopilot_schedule_job_test.go
+++ b/server/cmd/server/autopilot_schedule_job_test.go
@@ -38,6 +38,7 @@ func setupAutopilotScheduleJob(t *testing.T, cron string) (db.AutopilotTrigger,
 
 	ap, err := queries.CreateAutopilot(ctx, db.CreateAutopilotParams{
 		WorkspaceID:        parseUUID(testWorkspaceID),
+		SpaceID:            defaultSpaceUUID(t, ctx, testWorkspaceID),
 		Title:              "Schedule dispatch fixture",
 		Description:        pgtype.Text{String: "schedule dispatch test", Valid: true},
 		AssigneeType:       "agent",
@@ -614,6 +615,7 @@ func seedColdStartTrigger(t *testing.T, cron string) (db.AutopilotTrigger, *db.Q
 
 	ap, err := queries.CreateAutopilot(ctx, db.CreateAutopilotParams{
 		WorkspaceID:        parseUUID(testWorkspaceID),
+		SpaceID:            defaultSpaceUUID(t, ctx, testWorkspaceID),
 		Title:              "Cold-start regression",
 		Description:        pgtype.Text{String: "deterministic cold-start", Valid: true},
 		AssigneeType:       "agent",
diff --git a/server/cmd/server/integration_test.go b/server/cmd/server/integration_test.go
index ad20982558..4e03f31bc3 100644
--- a/server/cmd/server/integration_test.go
+++ b/server/cmd/server/integration_test.go
@@ -15,6 +15,7 @@ import (
 
 	"github.com/golang-jwt/jwt/v5"
 	"github.com/gorilla/websocket"
+	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/jackc/pgx/v5/pgxpool"
 
 	"github.com/multica-ai/multica/server/internal/analytics"
@@ -111,11 +112,13 @@ func setupIntegrationTestFixture(ctx context.Context, pool *pgxpool.Pool) (strin
 	}
 
 	var workspaceID string
+	var workspaceCounter int32
+	var workspacePrefix string
 	if err := pool.QueryRow(ctx, `
-		INSERT INTO workspace (name, slug, description)
-		VALUES ($1, $2, $3)
-		RETURNING id
-	`, "Integration Tests", integrationTestWorkspaceSlug, "Temporary workspace for router integration tests").Scan(&workspaceID); err != nil {
+		INSERT INTO workspace (name, slug, description, issue_prefix)
+		VALUES ($1, $2, $3, $4)
+		RETURNING id, issue_counter, issue_prefix
+	`, "Integration Tests", integrationTestWorkspaceSlug, "Temporary workspace for router integration tests", "INT").Scan(&workspaceID, &workspaceCounter, &workspacePrefix); err != nil {
 		return "", "", err
 	}
 
@@ -126,6 +129,18 @@ func setupIntegrationTestFixture(ctx context.Context, pool *pgxpool.Pool) (strin
 		return "", "", err
 	}
 
+	// Seed the default Space so space-aware issue creates resolve a Space the same
+	// way migration 131 backfills production workspaces. Without this every
+	// space-aware create fails "space not found in this workspace". The space's
+	// issue_counter mirrors the workspace counter so the two never hand out
+	// overlapping numbers.
+	if _, err := pool.Exec(ctx, `
+		INSERT INTO workspace_space (workspace_id, name, key, issue_counter, created_by)
+		VALUES ($1, 'Default', $2, $3, $4)
+	`, workspaceID, workspacePrefix, workspaceCounter, userID); err != nil {
+		return "", "", err
+	}
+
 	var runtimeID string
 	if err := pool.QueryRow(ctx, `
 		INSERT INTO agent_runtime (
@@ -160,6 +175,22 @@ func cleanupIntegrationTestFixture(ctx context.Context, pool *pgxpool.Pool) erro
 	return nil
 }
 
+// defaultSpaceUUID returns the seeded default workspace_space for the given
+// workspace. Direct issue/autopilot inserts that bypass the space-aware service
+// layer must carry this so the NOT NULL space_id (migration 132) is satisfied
+// the same way a real create would resolve it via ResolveSpace.
+func defaultSpaceUUID(t *testing.T, ctx context.Context, workspaceID string) pgtype.UUID {
+	t.Helper()
+	var id string
+	if err := testPool.QueryRow(ctx,
+		`SELECT id::text FROM workspace_space WHERE workspace_id = $1 LIMIT 1`,
+		workspaceID,
+	).Scan(&id); err != nil {
+		t.Fatalf("load default space: %v", err)
+	}
+	return parseUUID(id)
+}
+
 // Helper to make authenticated requests
 func authRequest(t *testing.T, method, path string, body any) *http.Response {
 	t.Helper()
@@ -857,8 +888,8 @@ func TestInboxUnreadSummaryDedupesByIssue(t *testing.T) {
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, creator_type, creator_id)
-		VALUES ($1, 'Dedup fixture', 'member', $2)
+		INSERT INTO issue (workspace_id, space_id, title, creator_type, creator_id)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'Dedup fixture', 'member', $2)
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
 		t.Fatalf("failed to seed issue: %v", err)
diff --git a/server/cmd/server/notification_listeners_test.go b/server/cmd/server/notification_listeners_test.go
index f292bbae27..fe5ce7da3d 100644
--- a/server/cmd/server/notification_listeners_test.go
+++ b/server/cmd/server/notification_listeners_test.go
@@ -56,8 +56,8 @@ func createTestSubIssue(t *testing.T, workspaceID, creatorID, parentIssueID stri
 	ctx := context.Background()
 	var issueID string
 	err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, position, parent_issue_id, number)
-		VALUES ($1, 'sub-issue test', 'todo', 'medium', 'member', $2, 0, $3,
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_type, creator_id, position, parent_issue_id, number)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'sub-issue test', 'todo', 'medium', 'member', $2, 0, $3,
 		        (SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1))
 		RETURNING id
 	`, workspaceID, creatorID, parentIssueID).Scan(&issueID)
@@ -538,8 +538,8 @@ func TestNotification_AssigneeChanged(t *testing.T) {
 				AssigneeType: &newAssigneeType,
 				AssigneeID:   &newAssigneeID,
 			},
-			"assignee_changed":  true,
-			"status_changed":    false,
+			"assignee_changed":   true,
+			"status_changed":     false,
 			"prev_assignee_type": &oldAssigneeType,
 			"prev_assignee_id":   &oldAssigneeID,
 		},
diff --git a/server/cmd/server/quick_create_subscriber_test.go b/server/cmd/server/quick_create_subscriber_test.go
index 14e638a1fe..3052d40fc6 100644
--- a/server/cmd/server/quick_create_subscriber_test.go
+++ b/server/cmd/server/quick_create_subscriber_test.go
@@ -38,6 +38,7 @@ func TestQuickCreateCompletion_SubscribesRequester(t *testing.T) {
 		"please file a bug",
 		pgtype.UUID{},
 		pgtype.UUID{},
+		pgtype.UUID{},
 		nil,
 	)
 	if err != nil {
@@ -57,12 +58,26 @@ func TestQuickCreateCompletion_SubscribesRequester(t *testing.T) {
 		t.Fatalf("StartAgentTask: %v", err)
 	}
 
-	number, err := queries.IncrementIssueCounter(ctx, parseUUID(testWorkspaceID))
+	var spaceID string
+	if err := testPool.QueryRow(ctx,
+		`SELECT id::text FROM workspace_space WHERE workspace_id = $1 LIMIT 1`,
+		testWorkspaceID,
+	).Scan(&spaceID); err != nil {
+		t.Fatalf("load fixture default space: %v", err)
+	}
+
+	// Mint the number from the Space counter (not the workspace counter) so this
+	// test cannot hand out a number that overlaps a space-aware create.
+	number, err := queries.IncrementSpaceIssueCounter(ctx, db.IncrementSpaceIssueCounterParams{
+		ID:          parseUUID(spaceID),
+		WorkspaceID: parseUUID(testWorkspaceID),
+	})
 	if err != nil {
-		t.Fatalf("IncrementIssueCounter: %v", err)
+		t.Fatalf("IncrementSpaceIssueCounter: %v", err)
 	}
 	issue, err := queries.CreateIssueWithOrigin(ctx, db.CreateIssueWithOriginParams{
 		WorkspaceID: parseUUID(testWorkspaceID),
+		SpaceID:     parseUUID(spaceID),
 		Title:       "agent-filed bug",
 		Status:      "todo",
 		Priority:    "none",
@@ -113,6 +128,7 @@ func TestQuickCreateFailure_DoesNotSubscribeRequester(t *testing.T) {
 		"another bug",
 		pgtype.UUID{},
 		pgtype.UUID{},
+		pgtype.UUID{},
 		nil,
 	)
 	if err != nil {
diff --git a/server/cmd/server/rerun_session_test.go b/server/cmd/server/rerun_session_test.go
index 3ef5632ba9..b6aabe2f38 100644
--- a/server/cmd/server/rerun_session_test.go
+++ b/server/cmd/server/rerun_session_test.go
@@ -36,8 +36,8 @@ func setupRerunTestFixture(t *testing.T) (string, string, string) {
 	// uq_issue_workspace_number unique constraint when multiple fixtures
 	// coexist in the same test (e.g. TestRerunIssueRejectsCrossIssueTask).
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, assignee_type, assignee_id, number)
-		SELECT $1, 'Rerun test issue', 'todo', 'none', 'member', m.user_id, 'agent', $2,
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_type, creator_id, assignee_type, assignee_id, number)
+		SELECT $1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'Rerun test issue', 'todo', 'none', 'member', m.user_id, 'agent', $2,
 		       (SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1)
 		FROM member m WHERE m.workspace_id = $1 LIMIT 1
 		RETURNING id
@@ -521,8 +521,8 @@ func TestRerunIssueRejectsCrossIssueTask(t *testing.T) {
 	// rerun assertion can.
 	var issueBID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, assignee_type, assignee_id, number)
-		SELECT $1, 'Rerun cross-issue test', 'todo', 'none', 'member', m.user_id, 'agent', $2,
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_type, creator_id, assignee_type, assignee_id, number)
+		SELECT $1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'Rerun cross-issue test', 'todo', 'none', 'member', m.user_id, 'agent', $2,
 		       (SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1)
 		FROM member m WHERE m.workspace_id = $1 LIMIT 1
 		RETURNING id
diff --git a/server/cmd/server/router.go b/server/cmd/server/router.go
index 1c6ecaa92f..1501f2d0b2 100644
--- a/server/cmd/server/router.go
+++ b/server/cmd/server/router.go
@@ -417,7 +417,7 @@ func NewRouterWithOptions(pool *pgxpool.Pool, hub *realtime.Hub, bus *events.Bus
 
 	// Slack integration. Multi-tenant B2 model (MUL-3666): Multica hosts ONE
 	// Slack app, workspaces self-install via OAuth, and inbound runs on a single
-	// deployment-level Socket Mode connection routed by team_id — replacing the
+	// deployment-level Socket Mode connection routed by space_id — replacing the
 	// stage-3 per-installation connection model (MUL-3516).
 	//
 	// Two deployment-level env vars gate the two halves:
@@ -1038,6 +1038,22 @@ func NewRouterWithOptions(pool *pgxpool.Pool, hub *realtime.Hub, bus *events.Bus
 				})
 			})
 
+			// Spaces
+			r.Route("/api/spaces", func(r chi.Router) {
+				r.Get("/", h.ListSpaces)
+				r.Post("/", h.CreateSpace)
+				r.Route("/{id}", func(r chi.Router) {
+					r.Patch("/", h.UpdateSpace)
+					r.Put("/", h.UpdateSpace)
+					r.Delete("/", h.ArchiveSpace)
+					// Caller's own membership row (per-user sidebar sort).
+					r.Patch("/membership", h.UpdateSpaceMembership)
+					// Member set is configured wholesale — anyone can edit.
+					r.Get("/members", h.ListSpaceMembers)
+					r.Put("/members", h.ReplaceSpaceMembers)
+				})
+			})
+
 			// Squads
 			r.Route("/api/squads", func(r chi.Router) {
 				r.Get("/", h.ListSquads)
diff --git a/server/cmd/server/runtime_sweeper_test.go b/server/cmd/server/runtime_sweeper_test.go
index 050bd33e96..0e51272086 100644
--- a/server/cmd/server/runtime_sweeper_test.go
+++ b/server/cmd/server/runtime_sweeper_test.go
@@ -33,8 +33,8 @@ func setupSweeperTestFixture(t *testing.T, taskStatus string) (string, string, s
 	// Create an issue assigned to the agent
 	var issueID string
 	err = testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, assignee_type, assignee_id)
-		SELECT $1, 'Sweeper test issue', 'todo', 'none', 'member', m.user_id, 'agent', $2
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_type, creator_id, assignee_type, assignee_id)
+		SELECT $1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'Sweeper test issue', 'todo', 'none', 'member', m.user_id, 'agent', $2
 		FROM member m WHERE m.workspace_id = $1 LIMIT 1
 		RETURNING id
 	`, testWorkspaceID, agentID).Scan(&issueID)
@@ -500,8 +500,8 @@ func TestSweepResetsInProgressIssueToTodo(t *testing.T) {
 	// Create an issue already in in_progress (simulates a daemon crash mid-run).
 	var issueID string
 	err = testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, assignee_type, assignee_id)
-		SELECT $1, 'Stuck in_progress issue', 'in_progress', 'none', 'member', m.user_id, 'agent', $2
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_type, creator_id, assignee_type, assignee_id)
+		SELECT $1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'Stuck in_progress issue', 'in_progress', 'none', 'member', m.user_id, 'agent', $2
 		FROM member m WHERE m.workspace_id = $1 LIMIT 1
 		RETURNING id
 	`, testWorkspaceID, agentID).Scan(&issueID)
@@ -590,8 +590,8 @@ func TestSweepDoesNotResetIssueAlreadyInReview(t *testing.T) {
 	// Issue already advanced to in_review by the agent before the task timed out.
 	var issueID string
 	err = testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, assignee_type, assignee_id)
-		SELECT $1, 'Already in_review issue', 'in_review', 'none', 'member', m.user_id, 'agent', $2
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_type, creator_id, assignee_type, assignee_id)
+		SELECT $1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'Already in_review issue', 'in_review', 'none', 'member', m.user_id, 'agent', $2
 		FROM member m WHERE m.workspace_id = $1 LIMIT 1
 		RETURNING id
 	`, testWorkspaceID, agentID).Scan(&issueID)
@@ -670,11 +670,11 @@ func TestExpireStaleQueuedTasks(t *testing.T) {
 		var issueID string
 		if err := testPool.QueryRow(ctx, `
 			WITH bumped AS (
-				UPDATE workspace SET issue_counter = issue_counter + 1
-				WHERE id = $1 RETURNING issue_counter
+				UPDATE workspace_space SET issue_counter = issue_counter + 1
+				WHERE workspace_id = $1 RETURNING id AS space_id, issue_counter
 			)
-			INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, assignee_type, assignee_id, number)
-			SELECT $1, $3, 'todo', 'none', 'member', m.user_id, 'agent', $2, (SELECT issue_counter FROM bumped)
+			INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_type, creator_id, assignee_type, assignee_id, number)
+			SELECT $1, (SELECT space_id FROM bumped), $3, 'todo', 'none', 'member', m.user_id, 'agent', $2, (SELECT issue_counter FROM bumped)
 			FROM member m WHERE m.workspace_id = $1 LIMIT 1
 			RETURNING id
 		`, testWorkspaceID, agentID, label).Scan(&issueID); err != nil {
@@ -782,11 +782,11 @@ func TestExpireStaleQueuedTasksRespectsBatchLimit(t *testing.T) {
 		var issueID string
 		if err := testPool.QueryRow(ctx, `
 			WITH bumped AS (
-				UPDATE workspace SET issue_counter = issue_counter + 1
-				WHERE id = $1 RETURNING issue_counter
+				UPDATE workspace_space SET issue_counter = issue_counter + 1
+				WHERE workspace_id = $1 RETURNING id AS space_id, issue_counter
 			)
-			INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, assignee_type, assignee_id, number)
-			SELECT $1, 'Queued TTL batch test', 'todo', 'none', 'member', m.user_id, 'agent', $2, (SELECT issue_counter FROM bumped)
+			INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_type, creator_id, assignee_type, assignee_id, number)
+			SELECT $1, (SELECT space_id FROM bumped), 'Queued TTL batch test', 'todo', 'none', 'member', m.user_id, 'agent', $2, (SELECT issue_counter FROM bumped)
 			FROM member m WHERE m.workspace_id = $1 LIMIT 1
 			RETURNING id
 		`, testWorkspaceID, agentID).Scan(&issueID); err != nil {
diff --git a/server/cmd/server/subscriber_listeners_test.go b/server/cmd/server/subscriber_listeners_test.go
index 871068004b..8b8cbcb281 100644
--- a/server/cmd/server/subscriber_listeners_test.go
+++ b/server/cmd/server/subscriber_listeners_test.go
@@ -23,8 +23,8 @@ func createTestIssue(t *testing.T, workspaceID, creatorID string) string {
 	ctx := context.Background()
 	var issueID string
 	err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, position, number)
-		VALUES ($1, 'subscriber test issue', 'todo', 'medium', 'member', $2, 0,
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_type, creator_id, position, number)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'subscriber test issue', 'todo', 'medium', 'member', $2, 0,
 		        (SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1))
 		RETURNING id
 	`, workspaceID, creatorID).Scan(&issueID)
diff --git a/server/cmd/server/workspace_scope_guard_test.go b/server/cmd/server/workspace_scope_guard_test.go
index 1560f1ee49..a3a754dc9e 100644
--- a/server/cmd/server/workspace_scope_guard_test.go
+++ b/server/cmd/server/workspace_scope_guard_test.go
@@ -137,8 +137,8 @@ func seedIssue(t *testing.T, ctx context.Context) pgtype.UUID {
 	// avoid colliding with concurrent integration tests in the same DB.
 	n := 1_000_000 + rand.IntN(1_000_000)
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, position, number)
-		VALUES ($1, 'scope-guard test issue', 'todo', 'none', 'member', $2, 0, $3)
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_type, creator_id, position, number)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'scope-guard test issue', 'todo', 'none', 'member', $2, 0, $3)
 		RETURNING id
 	`, testWorkspaceID, testUserID, n).Scan(&s); err != nil {
 		t.Fatalf("seed issue: %v", err)
diff --git a/server/internal/daemon/daemon.go b/server/internal/daemon/daemon.go
index a0aa9dd278..79c3096a44 100644
--- a/server/internal/daemon/daemon.go
+++ b/server/internal/daemon/daemon.go
@@ -3522,6 +3522,9 @@ func (d *Daemon) runTask(ctx context.Context, task Task, provider string, slot i
 		AgentInstructions:                instructions,
 		AgentSkills:                      convertSkillsForEnv(skills),
 		Repos:                            convertReposForEnv(task.Repos),
+		SpaceID:                          task.SpaceID,
+		SpaceKey:                         task.SpaceKey,
+		SpaceName:                        task.SpaceName,
 		ProjectID:                        task.ProjectID,
 		ProjectTitle:                     task.ProjectTitle,
 		ProjectDescription:               task.ProjectDescription,
diff --git a/server/internal/daemon/execenv/execenv.go b/server/internal/daemon/execenv/execenv.go
index f565bcc214..3b5657ba78 100644
--- a/server/internal/daemon/execenv/execenv.go
+++ b/server/internal/daemon/execenv/execenv.go
@@ -76,6 +76,9 @@ type TaskContextForEnv struct {
 	AgentInstructions       string // agent identity/persona instructions, injected into CLAUDE.md
 	AgentSkills             []SkillContextForEnv
 	Repos                   []RepoContextForEnv     // workspace repos available for checkout
+	SpaceID                 string                  // issue/autopilot/quick-create Space — always set for issue-bound tasks
+	SpaceKey                string                  // Space issue namespace key, e.g. MUL
+	SpaceName               string                  // human-readable Space name
 	ProjectID               string                  // issue's project, when present
 	ProjectTitle            string                  // human-readable project title
 	ProjectDescription      string                  // durable project-level context, rendered into the brief's Project Context section
diff --git a/server/internal/daemon/execenv/runtime_config.go b/server/internal/daemon/execenv/runtime_config.go
index e17bb05943..088bf47baa 100644
--- a/server/internal/daemon/execenv/runtime_config.go
+++ b/server/internal/daemon/execenv/runtime_config.go
@@ -502,8 +502,8 @@ func buildMetaSkillContent(provider string, ctx TaskContextForEnv) string {
 	b.WriteString("### Core\n")
 	b.WriteString("- `multica issue get <id> --output json` — Get full issue details.\n")
 	b.WriteString("- `multica issue comment list <issue-id> [--thread <comment-id> [--tail N] | --recent N] [--before <ts> --before-id <uuid>] [--since <RFC3339>] [--full] --output json` — List comments on an issue. Default returns the full flat timeline (server cap 2000). On busy issues prefer the thread-aware reads: `--thread <comment-id>` returns one conversation (root + every reply); `--thread <id> --tail N` caps replies to the N most recent (root is always included, even at `--tail 0`); `--recent N` returns the N most recently active threads. **Resolve-aware folding is on by default for the complete-thread reads (default list, `--recent`, `--thread` without `--tail`): a resolved thread collapses to its root + conclusion comment (reply-resolved) or its root only (root-resolved), with the dropped count reported on the root as `folded_count` and `thread_resolved: true` — so you skip settled discussion. Pass `--full` to get a folded thread's complete discussion. Folding never applies to `--since`/`--tail`/`--roots-only` reads (they return partial threads), so `--full` is a no-op there.** `--before` / `--before-id` walks older replies under `--thread --tail` (stderr label: `Next reply cursor`) or older threads under `--recent` (stderr label: `Next thread cursor`). `--since` is for incremental polling and may combine with `--thread` (with or without `--tail`) or `--recent`.\n")
-	b.WriteString("- `multica issue create --title \"...\" [--description \"...\" | --description-file <path> | --description-stdin] [--priority X] [--status X] [--assignee X | --assignee-id <uuid>] [--parent <issue-id>] [--stage N] [--project <project-id>] [--due-date <RFC3339>] [--attachment <path>]` — Create a new issue; `--attachment` may be repeated. `--stage N` (N ≥ 1) groups a sub-issue into an ordered barrier group under its parent so the parent wakes per stage, not per child. For agent-authored long descriptions, prefer `--description-file <path>` — flags after a HEREDOC terminator can be silently swallowed (#4182).\n")
-	b.WriteString("- `multica issue update <id> [--title X] [--description X | --description-file <path> | --description-stdin] [--priority X] [--status X] [--assignee X | --assignee-id <uuid>] [--parent <issue-id>] [--stage N] [--project <project-id>] [--due-date <RFC3339>]` — Update issue fields; use `--parent \"\"` to clear parent. For agent-authored long descriptions, prefer `--description-file <path>` over stdin (#4182).\n")
+	b.WriteString("- `multica issue create --title \"...\" [--description \"...\" | --description-file <path> | --description-stdin] [--priority X] [--status X] [--assignee X | --assignee-id <uuid>] [--parent <issue-id>] [--stage N] [--space <space-id-or-key>] [--project <project-id>] [--due-date <RFC3339>] [--attachment <path>]` — Create a new issue; `--attachment` may be repeated. Omitting `--space` falls back to the workspace's default Space. `--stage N` (N ≥ 1) groups a sub-issue into an ordered barrier group under its parent so the parent wakes per stage, not per child. For agent-authored long descriptions, prefer `--description-file <path>` — flags after a HEREDOC terminator can be silently swallowed (#4182).\n")
+	b.WriteString("- `multica issue update <id> [--title X] [--description X | --description-file <path> | --description-stdin] [--priority X] [--status X] [--assignee X | --assignee-id <uuid>] [--parent <issue-id>] [--stage N] [--space <space-id-or-key>] [--project <project-id>] [--due-date <RFC3339>]` — Update issue fields; `--space` moves the issue to another Space (renumbers it; the old identifier keeps resolving); use `--parent \"\"` to clear parent. For agent-authored long descriptions, prefer `--description-file <path>` over stdin (#4182).\n")
 	b.WriteString("- `multica repo checkout <url> [--ref <branch-or-sha>]` — Check out a repository into the working directory (creates a git worktree with a dedicated branch; use `--ref` for review/QA on a specific branch, tag, or commit)\n")
 	b.WriteString("- `multica issue status <id> <status>` — Shortcut for `issue update --status` when you only need to flip status (todo, in_progress, in_review, done, blocked, backlog, cancelled)\n")
 	b.WriteString("- `multica issue children <id> [--output json]` — List a parent's sub-issues grouped by stage (table or JSON), so you can see how many children there are, which stage each is in, and which stage to promote next.\n")
@@ -588,6 +588,17 @@ func buildMetaSkillContent(provider string, ctx TaskContextForEnv) string {
 		b.WriteString("\nThe checkout command creates a git worktree with a dedicated branch. You can check out one or more repos as needed, and can pass `--ref` for review/QA on a non-default branch or commit.\n\n")
 	}
 
+	// Inject Space context. Unlike Project (optional, many-to-many), every
+	// issue-bound task has exactly one Space — it owns the issue's identifier
+	// namespace (SPACE_KEY-NUMBER) — so this fires whenever ctx carries one.
+	if ctx.SpaceID != "" {
+		b.WriteString("## Space Context\n\n")
+		if ctx.SpaceName != "" && ctx.SpaceKey != "" {
+			fmt.Fprintf(&b, "This issue belongs to the **%s** Space (key `%s`) — it owns this issue's identifier namespace (`%s-N`).\n\n", ctx.SpaceName, ctx.SpaceKey, ctx.SpaceKey)
+		}
+		b.WriteString("Pass `--space <space-id-or-key>` on `multica issue create` to file a new issue under a specific Space instead of the workspace default. `multica issue update <id> --space <space-id-or-key>` moves an existing issue to another Space — it is renumbered under the target Space, and the old identifier is recorded as an alias that keeps resolving forever, so this is always safe.\n\n")
+	}
+
 	// Inject project-scoped context (resources attached to the issue's project).
 	// The full structured payload is also available at .multica/project/resources.json
 	// so skills can consume it programmatically.
diff --git a/server/internal/daemon/execenv/runtime_config_sections.go b/server/internal/daemon/execenv/runtime_config_sections.go
index da82c004f4..f65e0da0c3 100644
--- a/server/internal/daemon/execenv/runtime_config_sections.go
+++ b/server/internal/daemon/execenv/runtime_config_sections.go
@@ -200,8 +200,8 @@ func writeAvailableCommands(b *strings.Builder) {
 	b.WriteString("### Core\n")
 	b.WriteString("- `multica issue get <id> --output json` — full issue.\n")
 	b.WriteString("- `multica issue comment list <issue-id> [--thread <comment-id> [--tail N] | --recent N] [--before <ts> --before-id <uuid>] [--since <RFC3339>] [--full] --output json` — thread-aware comment reads. Resolved threads come back folded by default on complete-thread reads (default list, `--recent`, `--thread` without `--tail`); pass `--full` to expand. Page older replies / threads with `--before`/`--before-id` (stderr labels: `Next reply cursor`, `Next thread cursor`); `--help` for full semantics.\n")
-	b.WriteString("- `multica issue create --title \"...\" [--description-file <path>] [--priority X] [--status X] [--assignee X | --assignee-id <uuid>] [--parent <issue-id>] [--stage N] [--project <project-id>] [--due-date <RFC3339>] [--attachment <path>]` — create an issue. For agent-authored long descriptions prefer `--description-file <path>` (heredoc stdin can swallow trailing flags, #4182).\n")
-	b.WriteString("- `multica issue update <id> [--title X] [--description-file <path>] [--priority X] [--status X] [--assignee X] [--parent <issue-id>] [--stage N] [--project <project-id>] [--due-date <RFC3339>]` — update fields; pass `--parent \"\"` to clear parent.\n")
+	b.WriteString("- `multica issue create --title \"...\" [--description-file <path>] [--priority X] [--status X] [--assignee X | --assignee-id <uuid>] [--parent <issue-id>] [--stage N] [--space <space-id-or-key>] [--project <project-id>] [--due-date <RFC3339>] [--attachment <path>]` — create an issue. Omitting `--space` falls back to the workspace's default Space. For agent-authored long descriptions prefer `--description-file <path>` (heredoc stdin can swallow trailing flags, #4182).\n")
+	b.WriteString("- `multica issue update <id> [--title X] [--description-file <path>] [--priority X] [--status X] [--assignee X] [--parent <issue-id>] [--stage N] [--space <space-id-or-key>] [--project <project-id>] [--due-date <RFC3339>]` — update fields; `--space` moves the issue to another Space (renumbers it; the old identifier keeps resolving); pass `--parent \"\"` to clear parent.\n")
 	b.WriteString("- `multica issue status <id> <status>` — flip status (todo / in_progress / in_review / done / blocked / backlog / cancelled).\n")
 	b.WriteString("- `multica issue children <id> [--output json]` — list a parent's sub-issues grouped by stage.\n")
 	b.WriteString("- `multica issue comment add <issue-id> [--content \"...\" | --content-file <path> | --content-stdin] [--parent <comment-id>] [--attachment <path>]` — post a comment. Agent-authored bodies MUST use `--content-file`. `multica issue comment add --help` for full flags.\n")
@@ -221,7 +221,7 @@ func writeAvailableCommandsQuickCreate(b *strings.Builder) {
 	b.WriteString("## Available Commands\n\n")
 	b.WriteString("**Use `--output json` for structured data.** For anything beyond `issue create`, run `multica --help` or `multica <command> --help`.\n\n")
 	b.WriteString("### Core\n")
-	b.WriteString("- `multica issue create --title \"...\" [--description \"...\" | --description-file <path> | --description-stdin] [--priority X] [--status X] [--assignee X | --assignee-id <uuid>] [--parent <issue-id>] [--stage N] [--project <project-id>] [--due-date <RFC3339>] [--attachment <path>]` — Create a new issue; `--attachment` may be repeated. For agent-authored long descriptions, prefer `--description-file <path>` over `--description-stdin` (flags after a HEREDOC terminator can be silently swallowed, #4182).\n\n")
+	b.WriteString("- `multica issue create --title \"...\" [--description \"...\" | --description-file <path> | --description-stdin] [--priority X] [--status X] [--assignee X | --assignee-id <uuid>] [--parent <issue-id>] [--stage N] [--space <space-id-or-key>] [--project <project-id>] [--due-date <RFC3339>] [--attachment <path>]` — Create a new issue; `--attachment` may be repeated. Omitting `--space` falls back to the workspace's default Space. For agent-authored long descriptions, prefer `--description-file <path>` over `--description-stdin` (flags after a HEREDOC terminator can be silently swallowed, #4182).\n\n")
 }
 
 // writeCommentFormatting emits the cross-platform file-first guardrail.
@@ -255,6 +255,21 @@ func writeRepositories(b *strings.Builder, ctx TaskContextForEnv) {
 	b.WriteString("\n")
 }
 
+// writeSpaceContext emits the Space Context section. Unlike Project (optional,
+// many-to-many), every issue-bound task has exactly one Space — it owns the
+// issue's identifier namespace (SPACE_KEY-NUMBER), so this always fires when
+// the context carries one.
+func writeSpaceContext(b *strings.Builder, ctx TaskContextForEnv) {
+	if ctx.SpaceID == "" {
+		return
+	}
+	b.WriteString("## Space Context\n\n")
+	if ctx.SpaceName != "" && ctx.SpaceKey != "" {
+		fmt.Fprintf(b, "This issue belongs to the **%s** Space (key `%s`) — it owns this issue's identifier namespace (`%s-N`).\n\n", ctx.SpaceName, ctx.SpaceKey, ctx.SpaceKey)
+	}
+	b.WriteString("Pass `--space <space-id-or-key>` on `multica issue create` to file a new issue under a specific Space instead of the workspace default. `multica issue update <id> --space <space-id-or-key>` moves an existing issue to another Space — it is renumbered under the target Space, and the old identifier is recorded as an alias that keeps resolving forever, so this is always safe.\n\n")
+}
+
 // writeProjectContext emits the Project Context section when the issue
 // belongs to a project.
 func writeProjectContext(b *strings.Builder, ctx TaskContextForEnv) {
@@ -542,6 +557,7 @@ func buildMetaSkillContentSlim(provider string, ctx TaskContextForEnv) string {
 	}
 
 	if kind.hasIssueContext() {
+		writeSpaceContext(&b, ctx)
 		writeProjectContext(&b, ctx)
 		writeIssueMetadata(&b)
 	}
diff --git a/server/internal/daemon/prompt.go b/server/internal/daemon/prompt.go
index ddca45e9f1..558851e450 100644
--- a/server/internal/daemon/prompt.go
+++ b/server/internal/daemon/prompt.go
@@ -112,6 +112,17 @@ func buildQuickCreatePrompt(task Task) string {
 	} else {
 		b.WriteString("- **project**: omit. The platform will route the issue to the workspace default.\n")
 	}
+	if task.SpaceID != "" {
+		label := task.SpaceName
+		if label == "" {
+			label = task.SpaceKey
+		}
+		if label != "" {
+			fmt.Fprintf(&b, "- **space**: required for this run. Pass `--space %q` so the new issue lands in Space %q. Do not infer a different Space from the prompt text — the modal/context selection is authoritative.\n", task.SpaceID, label)
+		} else {
+			fmt.Fprintf(&b, "- **space**: required for this run. Pass `--space %q` so the new issue lands in the selected Space. Do not infer a different Space from the prompt text — the modal/context selection is authoritative.\n", task.SpaceID)
+		}
+	}
 	// parent — pinned by the modal when the user opened it from "Add sub
 	// issue" on an existing issue. Pass the UUID (never the identifier) so
 	// the create lands the sub-issue under the right parent even when the
diff --git a/server/internal/daemon/types.go b/server/internal/daemon/types.go
index 718eb9b7f2..61921af79d 100644
--- a/server/internal/daemon/types.go
+++ b/server/internal/daemon/types.go
@@ -63,6 +63,9 @@ type Task struct {
 	Agent                    *AgentData            `json:"agent,omitempty"`
 	ConnectedApps            []ConnectedAppData    `json:"connected_apps,omitempty"` // per-run app capabilities mounted through runtime MCP overlays
 	Repos                    []RepoData            `json:"repos,omitempty"`
+	SpaceID                  string                `json:"space_id,omitempty"`                    // issue/autopilot/quick-create Space, when known
+	SpaceKey                 string                `json:"space_key,omitempty"`                   // Space issue namespace key, e.g. MUL
+	SpaceName                string                `json:"space_name,omitempty"`                  // human-readable Space name
 	ProjectID                string                `json:"project_id,omitempty"`                  // issue's project, when present
 	ProjectTitle             string                `json:"project_title,omitempty"`               // human-readable project title for context injection
 	ProjectDescription       string                `json:"project_description,omitempty"`         // durable project-level context injected into the brief
diff --git a/server/internal/handler/agent.go b/server/internal/handler/agent.go
index 4df659e7ba..ec97e4b9a5 100644
--- a/server/internal/handler/agent.go
+++ b/server/internal/handler/agent.go
@@ -290,6 +290,9 @@ type AgentTaskResponse struct {
 	Agent              *TaskAgentData        `json:"agent,omitempty"`
 	ConnectedApps      []ConnectedAppData    `json:"connected_apps,omitempty"` // daemon-claim only: per-run app capabilities mounted through runtime MCP overlays
 	Repos              []RepoData            `json:"repos,omitempty"`
+	SpaceID            string                `json:"space_id,omitempty"`            // issue/autopilot/quick-create Space, when known
+	SpaceKey           string                `json:"space_key,omitempty"`           // Space issue namespace key, e.g. MUL
+	SpaceName          string                `json:"space_name,omitempty"`          // human-readable Space name
 	ProjectID          string                `json:"project_id,omitempty"`          // issue's project, when present
 	ProjectTitle       string                `json:"project_title,omitempty"`       // for surfacing in agent context
 	ProjectDescription string                `json:"project_description,omitempty"` // durable project-level context injected into the brief
diff --git a/server/internal/handler/agent_access_test.go b/server/internal/handler/agent_access_test.go
index 8aa631c769..c123c03bb4 100644
--- a/server/internal/handler/agent_access_test.go
+++ b/server/internal/handler/agent_access_test.go
@@ -446,9 +446,10 @@ func TestMentionAgent_RejectsCrossWorkspaceAgentUUID(t *testing.T) {
 	// agent and enqueued a task.
 	var issueID, commentID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, number)
+		INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, number, space_id)
 		VALUES ($1, 'cross-ws mention test', 'todo', 'medium', 'member', $2,
-		        COALESCE((SELECT MAX(number) FROM issue WHERE workspace_id = $1), 0) + 1)
+		        COALESCE((SELECT MAX(number) FROM issue WHERE workspace_id = $1), 0) + 1,
+		        (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
 		t.Fatalf("create test issue: %v", err)
@@ -531,10 +532,11 @@ func TestShouldEnqueueOnComment_PrivateAgentGate(t *testing.T) {
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
 		INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id,
-		                   assignee_type, assignee_id, number)
+		                   assignee_type, assignee_id, number, space_id)
 		VALUES ($1, 'on_comment private-agent gate test', 'todo', 'medium', 'member', $2,
 		        'agent', $3,
-		        COALESCE((SELECT MAX(number) FROM issue WHERE workspace_id = $1), 0) + 1)
+		        COALESCE((SELECT MAX(number) FROM issue WHERE workspace_id = $1), 0) + 1,
+		        (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, testUserID, agentID).Scan(&issueID); err != nil {
 		t.Fatalf("create issue assigned to private agent: %v", err)
diff --git a/server/internal/handler/autopilot.go b/server/internal/handler/autopilot.go
index 1080889e72..3ea0d7d7fc 100644
--- a/server/internal/handler/autopilot.go
+++ b/server/internal/handler/autopilot.go
@@ -33,6 +33,7 @@ type AutopilotResponse struct {
 	Title       string  `json:"title"`
 	Description *string `json:"description"`
 	ProjectID   *string `json:"project_id"`
+	SpaceID     *string `json:"space_id"`
 	// AssigneeType is "agent" or "squad". Path A from MUL-2429: when set
 	// to "squad", AssigneeID points at squad(id) rather than agent(id) and
 	// dispatch resolves to squad.leader_id at run time.
@@ -180,6 +181,7 @@ func autopilotToResponse(a db.Autopilot, subscribers []db.AutopilotSubscriber) A
 		Title:              a.Title,
 		Description:        textToPtr(a.Description),
 		ProjectID:          uuidToPtr(a.ProjectID),
+		SpaceID:            uuidToPtr(a.SpaceID),
 		AssigneeType:       assigneeType,
 		AssigneeID:         uuidToString(a.AssigneeID),
 		Status:             a.Status,
@@ -301,6 +303,7 @@ type CreateAutopilotRequest struct {
 	Title       string  `json:"title"`
 	Description *string `json:"description"`
 	ProjectID   *string `json:"project_id"`
+	SpaceID     *string `json:"space_id"`
 	// AssigneeType is optional and defaults to "agent" — preserves backward
 	// compatibility with desktop clients shipped before MUL-2429.
 	AssigneeType       *string           `json:"assignee_type"`
@@ -314,6 +317,7 @@ type UpdateAutopilotRequest struct {
 	Title              *string `json:"title"`
 	Description        *string `json:"description"`
 	ProjectID          *string `json:"project_id"`
+	SpaceID            *string `json:"space_id"`
 	AssigneeType       *string `json:"assignee_type"`
 	AssigneeID         *string `json:"assignee_id"`
 	Status             *string `json:"status"`
@@ -384,9 +388,18 @@ func (h *Handler) ListAutopilots(w http.ResponseWriter, r *http.Request) {
 	if s := r.URL.Query().Get("status"); s != "" {
 		statusFilter = pgtype.Text{String: s, Valid: true}
 	}
+	var spaceFilter pgtype.UUID
+	if t := r.URL.Query().Get("space_id"); t != "" {
+		id, ok := parseUUIDOrBadRequest(w, t, "space_id")
+		if !ok {
+			return
+		}
+		spaceFilter = id
+	}
 
 	autopilots, err := h.Queries.ListAutopilots(r.Context(), db.ListAutopilotsParams{
 		WorkspaceID: parseUUID(workspaceID),
+		SpaceID:     spaceFilter,
 		Status:      statusFilter,
 	})
 	if err != nil {
@@ -643,6 +656,10 @@ func (h *Handler) CreateAutopilot(w http.ResponseWriter, r *http.Request) {
 	if !ok {
 		return
 	}
+	spaceID, ok := h.resolveAutopilotSpace(w, r, wsUUID, req.SpaceID, projectID, pgtype.UUID{})
+	if !ok {
+		return
+	}
 
 	// Validate before insert so a bad payload doesn't half-create the row.
 	subscriberUUIDs, ok := h.validateAutopilotSubscribers(w, r, req.Subscribers, workspaceID)
@@ -665,6 +682,7 @@ func (h *Handler) CreateAutopilot(w http.ResponseWriter, r *http.Request) {
 		AssigneeID:         assigneeUUID,
 		Status:             "active",
 		ExecutionMode:      req.ExecutionMode,
+		SpaceID:            spaceID,
 		CreatedByType:      "member",
 		CreatedByID:        parseUUID(userID),
 		Description:        ptrToText(req.Description),
@@ -783,6 +801,7 @@ func (h *Handler) UpdateAutopilot(w http.ResponseWriter, r *http.Request) {
 		AssigneeID:         prev.AssigneeID,
 		IssueTitleTemplate: prev.IssueTitleTemplate,
 		ProjectID:          prev.ProjectID,
+		SpaceID:            prev.SpaceID,
 	}
 	if req.Title != nil {
 		params.Title = pgtype.Text{String: *req.Title, Valid: true}
@@ -812,6 +831,17 @@ func (h *Handler) UpdateAutopilot(w http.ResponseWriter, r *http.Request) {
 		}
 		params.ProjectID = projectID
 	}
+	if _, ok := rawFields["space_id"]; ok {
+		spaceID, ok := h.resolveAutopilotSpace(w, r, prev.WorkspaceID, req.SpaceID, params.ProjectID, prev.SpaceID)
+		if !ok {
+			return
+		}
+		params.SpaceID = spaceID
+	} else if _, projectTouched := rawFields["project_id"]; projectTouched {
+		if _, ok := h.resolveAutopilotSpace(w, r, prev.WorkspaceID, nil, params.ProjectID, params.SpaceID); !ok {
+			return
+		}
+	}
 	// assignee_type and assignee_id are validated as a pair: switching
 	// between agent and squad without supplying a new id would leave the
 	// row pointing at the wrong table. The client is expected to send both
@@ -941,6 +971,32 @@ func (h *Handler) parseAutopilotProjectID(
 	return projectID, true
 }
 
+func (h *Handler) resolveAutopilotSpace(
+	w http.ResponseWriter,
+	r *http.Request,
+	workspaceID pgtype.UUID,
+	rawSpaceID *string,
+	projectID pgtype.UUID,
+	fallback pgtype.UUID,
+) (pgtype.UUID, bool) {
+	requested := fallback
+	if rawSpaceID != nil && *rawSpaceID != "" {
+		parsed, ok := parseUUIDOrBadRequest(w, *rawSpaceID, "space_id")
+		if !ok {
+			return pgtype.UUID{}, false
+		}
+		requested = parsed
+	}
+	space, err := service.ResolveSpace(r.Context(), h.Queries, workspaceID, requested, projectID)
+	if err != nil {
+		if !writeSpaceResolveError(w, err) {
+			writeError(w, http.StatusBadRequest, err.Error())
+		}
+		return pgtype.UUID{}, false
+	}
+	return space.ID, true
+}
+
 func (h *Handler) DeleteAutopilot(w http.ResponseWriter, r *http.Request) {
 	id := chi.URLParam(r, "id")
 	workspaceID := h.resolveWorkspaceID(r)
diff --git a/server/internal/handler/autopilot_list_test.go b/server/internal/handler/autopilot_list_test.go
index c8bb6b9e0d..26eab148be 100644
--- a/server/internal/handler/autopilot_list_test.go
+++ b/server/internal/handler/autopilot_list_test.go
@@ -15,9 +15,10 @@ func insertListTestAutopilot(t *testing.T, agentID, title string) string {
 	if err := testPool.QueryRow(context.Background(), `
 		INSERT INTO autopilot (
 			workspace_id, title, assignee_type, assignee_id,
-			status, execution_mode, created_by_type, created_by_id
+			status, execution_mode, created_by_type, created_by_id, space_id
 		)
-		VALUES ($1, $2, 'agent', $3, 'active', 'run_only', 'member', $4)
+		VALUES ($1, $2, 'agent', $3, 'active', 'run_only', 'member', $4,
+		        (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, title, agentID, testUserID).Scan(&id); err != nil {
 		t.Fatalf("failed to insert test autopilot: %v", err)
diff --git a/server/internal/handler/autopilot_private_leader_test.go b/server/internal/handler/autopilot_private_leader_test.go
index d615dea3ac..6af3256406 100644
--- a/server/internal/handler/autopilot_private_leader_test.go
+++ b/server/internal/handler/autopilot_private_leader_test.go
@@ -238,8 +238,9 @@ func TestTriggerAutopilot_SquadPrivateLeader_PlainMemberCreator_Blocked(t *testi
 	var apID string
 	if err := testPool.QueryRow(ctx, `
 		INSERT INTO autopilot (workspace_id, title, assignee_type, assignee_id,
-		                       execution_mode, created_by_type, created_by_id, status)
-		VALUES ($1, 'legacy illegal ap', 'squad', $2, 'create_issue', 'member', $3, 'active')
+		                       execution_mode, created_by_type, created_by_id, status, space_id)
+		VALUES ($1, 'legacy illegal ap', 'squad', $2, 'create_issue', 'member', $3, 'active',
+		        (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, squadID, memberID).Scan(&apID); err != nil {
 		t.Fatalf("create autopilot: %v", err)
@@ -298,8 +299,9 @@ func TestTriggerAutopilot_RunOnly_SquadPrivateLeader_PlainMemberCreator_Blocked(
 	var apID string
 	if err := testPool.QueryRow(ctx, `
 		INSERT INTO autopilot (workspace_id, title, assignee_type, assignee_id,
-		                       execution_mode, created_by_type, created_by_id, status)
-		VALUES ($1, 'legacy run_only illegal ap', 'squad', $2, 'run_only', 'member', $3, 'active')
+		                       execution_mode, created_by_type, created_by_id, status, space_id)
+		VALUES ($1, 'legacy run_only illegal ap', 'squad', $2, 'run_only', 'member', $3, 'active',
+		        (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, squadID, memberID).Scan(&apID); err != nil {
 		t.Fatalf("create autopilot: %v", err)
diff --git a/server/internal/handler/autopilot_webhook_handler_test.go b/server/internal/handler/autopilot_webhook_handler_test.go
index 32d790f8d0..f5de8e66b8 100644
--- a/server/internal/handler/autopilot_webhook_handler_test.go
+++ b/server/internal/handler/autopilot_webhook_handler_test.go
@@ -46,8 +46,9 @@ func createWebhookTestAutopilot(t *testing.T, agentID, status, mode string) stri
 	if err := testPool.QueryRow(context.Background(), `
 		INSERT INTO autopilot (
 			workspace_id, title, assignee_id, status, execution_mode,
-			created_by_type, created_by_id
-		) VALUES ($1, $2, $3, $4, $5, 'member', $6)
+			created_by_type, created_by_id, space_id
+		) VALUES ($1, $2, $3, $4, $5, 'member', $6,
+			(SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, "Webhook test "+status, agentID, status, mode, testUserID).Scan(&apID); err != nil {
 		t.Fatalf("create autopilot: %v", err)
diff --git a/server/internal/handler/cancel_task_by_user_test.go b/server/internal/handler/cancel_task_by_user_test.go
index c9a39534e4..1f9ea62fef 100644
--- a/server/internal/handler/cancel_task_by_user_test.go
+++ b/server/internal/handler/cancel_task_by_user_test.go
@@ -45,8 +45,9 @@ func createAutopilotRunOnlyTask(t *testing.T, agentID string) string {
 
 	var autopilotID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO autopilot (workspace_id, title, assignee_id, execution_mode, created_by_type, created_by_id)
-		VALUES ($1, 'cancel-runonly-ap', $2, 'run_only', 'member', $3)
+		INSERT INTO autopilot (workspace_id, title, assignee_id, execution_mode, created_by_type, created_by_id, space_id)
+		VALUES ($1, 'cancel-runonly-ap', $2, 'run_only', 'member', $3,
+		        (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, workspaceID, agentID, testUserID).Scan(&autopilotID); err != nil {
 		t.Fatalf("create autopilot: %v", err)
@@ -90,6 +91,15 @@ func createForeignWorkspaceAgent(t *testing.T) string {
 	}
 	t.Cleanup(func() { testPool.Exec(context.Background(), `DELETE FROM workspace WHERE id = $1`, workspaceID) })
 
+	// The autopilot fixture resolves space_id from this workspace's default
+	// Space; a freshly-created workspace has none, so seed it here.
+	if _, err := testPool.Exec(ctx, `
+		INSERT INTO workspace_space (workspace_id, name, key, issue_counter, created_by)
+		VALUES ($1, 'Default', 'FCW', 0, $2)
+	`, workspaceID, testUserID); err != nil {
+		t.Fatalf("create foreign workspace_space: %v", err)
+	}
+
 	var runtimeID string
 	if err := testPool.QueryRow(ctx, `
 		INSERT INTO agent_runtime (workspace_id, daemon_id, name, runtime_mode, provider, status, device_info, metadata, last_seen_at)
@@ -256,8 +266,9 @@ func TestCancelTaskByUser_IssueTask_Succeeds(t *testing.T) {
 
 	var issueID, taskID string
 	if err := testPool.QueryRow(context.Background(), `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position)
-		VALUES ($1, 'cancel-byid-issue', 'todo', 'medium', $2, 'member', 92001, 0)
+		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position, space_id)
+		VALUES ($1, 'cancel-byid-issue', 'todo', 'medium', $2, 'member', 92001, 0,
+		        (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
diff --git a/server/internal/handler/comment_list_test.go b/server/internal/handler/comment_list_test.go
index 9cc404efd2..28dde6ff22 100644
--- a/server/internal/handler/comment_list_test.go
+++ b/server/internal/handler/comment_list_test.go
@@ -76,8 +76,8 @@ func newCommentListFixture(t *testing.T) commentListFixture {
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title)
-		VALUES ($1, 'member', $2, $3)
+		INSERT INTO issue (workspace_id, space_id, creator_type, creator_id, title)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'member', $2, $3)
 		RETURNING id
 	`, testWorkspaceID, testUserID, "comment list fixture").Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
@@ -295,8 +295,8 @@ func TestListComments_SummaryClipsContent(t *testing.T) {
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title)
-		VALUES ($1, 'member', $2, $3)
+		INSERT INTO issue (workspace_id, space_id, creator_type, creator_id, title)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'member', $2, $3)
 		RETURNING id
 	`, testWorkspaceID, testUserID, "summary fixture").Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
@@ -387,8 +387,8 @@ func TestListComments_RootsOnlySummaryComposes(t *testing.T) {
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title)
-		VALUES ($1, 'member', $2, $3)
+		INSERT INTO issue (workspace_id, space_id, creator_type, creator_id, title)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'member', $2, $3)
 		RETURNING id
 	`, testWorkspaceID, testUserID, "roots+summary fixture").Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
@@ -535,8 +535,8 @@ func TestListComments_RecentRanksStaleThreadAheadIfRecentlyReplied(t *testing.T)
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title)
-		VALUES ($1, 'member', $2, $3) RETURNING id
+		INSERT INTO issue (workspace_id, space_id, creator_type, creator_id, title)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'member', $2, $3) RETURNING id
 	`, testWorkspaceID, testUserID, "stale-but-fresh fixture").Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
 	}
@@ -662,8 +662,8 @@ func TestListComments_ThreadCursorStableUnderSameLastActivity(t *testing.T) {
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title)
-		VALUES ($1, 'member', $2, $3) RETURNING id
+		INSERT INTO issue (workspace_id, space_id, creator_type, creator_id, title)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'member', $2, $3) RETURNING id
 	`, testWorkspaceID, testUserID, "thread tie-break fixture").Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
 	}
@@ -1388,8 +1388,8 @@ func TestCreateCommentPreservesDirectParent(t *testing.T) {
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title)
-		VALUES ($1, 'member', $2, $3)
+		INSERT INTO issue (workspace_id, space_id, creator_type, creator_id, title)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'member', $2, $3)
 		RETURNING id
 	`, testWorkspaceID, testUserID, "direct parent fixture").Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
diff --git a/server/internal/handler/comment_resolve_test.go b/server/internal/handler/comment_resolve_test.go
index 3465a4038b..ce4c199d1c 100644
--- a/server/internal/handler/comment_resolve_test.go
+++ b/server/internal/handler/comment_resolve_test.go
@@ -127,8 +127,8 @@ func newResolveTestFixture(t *testing.T) resolveTestFixture {
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title)
-		VALUES ($1, 'member', $2, $3)
+		INSERT INTO issue (workspace_id, space_id, creator_type, creator_id, title)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'member', $2, $3)
 		RETURNING id
 	`, testWorkspaceID, testUserID, "resolve fixture").Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
@@ -204,8 +204,8 @@ func TestResolveComment_ScopedToThread(t *testing.T) {
 	}
 	fx := newResolveTestFixture(t)
 
-	resolveCommentHTTP(t, fx.B1)   // thread 1 resolution
-	resolveCommentHTTP(t, fx.A2)   // thread 2 resolution — must NOT touch thread 1
+	resolveCommentHTTP(t, fx.B1) // thread 1 resolution
+	resolveCommentHTTP(t, fx.A2) // thread 2 resolution — must NOT touch thread 1
 	if !commentResolved(t, fx.B1) {
 		t.Fatalf("b1 (thread 1) must stay resolved when a separate thread is resolved")
 	}
diff --git a/server/internal/handler/comment_trigger_preview_test.go b/server/internal/handler/comment_trigger_preview_test.go
index 1083fd34d9..71e1012892 100644
--- a/server/internal/handler/comment_trigger_preview_test.go
+++ b/server/internal/handler/comment_trigger_preview_test.go
@@ -18,9 +18,9 @@ func createCommentTriggerPreviewIssue(t *testing.T, title string, assigneeType,
 
 	var number int
 	if err := testPool.QueryRow(ctx, `
-		UPDATE workspace
-		SET issue_counter = GREATEST(issue_counter, (SELECT COALESCE(MAX(number), 0) FROM issue WHERE workspace_id = $1)) + 1
-		WHERE id = $1 RETURNING issue_counter
+		UPDATE workspace_space
+		SET issue_counter = GREATEST(issue_counter, (SELECT COALESCE(MAX(number), 0) FROM issue WHERE space_id = workspace_space.id)) + 1
+		WHERE workspace_id = $1 RETURNING issue_counter
 	`, testWorkspaceID).Scan(&number); err != nil {
 		t.Fatalf("next issue number: %v", err)
 	}
@@ -36,8 +36,8 @@ func createCommentTriggerPreviewIssue(t *testing.T, title string, assigneeType,
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title, assignee_type, assignee_id, number)
-		VALUES ($1, 'member', $2, $3, $4, $5, $6)
+		INSERT INTO issue (workspace_id, creator_type, creator_id, title, assignee_type, assignee_id, number, space_id)
+		VALUES ($1, 'member', $2, $3, $4, $5, $6, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, testUserID, title, assigneeTypeArg, assigneeIDArg, number).Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
diff --git a/server/internal/handler/daemon.go b/server/internal/handler/daemon.go
index 63483c15b9..453faf6365 100644
--- a/server/internal/handler/daemon.go
+++ b/server/internal/handler/daemon.go
@@ -21,6 +21,7 @@ import (
 	"github.com/multica-ai/multica/server/internal/auth"
 	"github.com/multica-ai/multica/server/internal/daemonws"
 	"github.com/multica-ai/multica/server/internal/integrations/slack"
+	"github.com/multica-ai/multica/server/internal/issueidentifier"
 	obsmetrics "github.com/multica-ai/multica/server/internal/metrics"
 	"github.com/multica-ai/multica/server/internal/middleware"
 	"github.com/multica-ai/multica/server/internal/runtimeapps"
@@ -1499,6 +1500,7 @@ func (h *Handler) ClaimTaskByRuntime(w http.ResponseWriter, r *http.Request) {
 		if issue, err := h.Queries.GetIssue(r.Context(), task.IssueID); err == nil {
 			resp.WorkspaceID = uuidToString(issue.WorkspaceID)
 			resp.ThreadName = issue.Title
+			h.attachSpaceToTaskResponse(r.Context(), &resp, issue.WorkspaceID, issue.SpaceID)
 
 			// Squad-leader briefing injection: keyed off the task being a
 			// leader-task (is_leader_task) carrying a squad_id — NOT off the
@@ -1810,6 +1812,7 @@ func (h *Handler) ClaimTaskByRuntime(w http.ResponseWriter, r *http.Request) {
 			if ap, err := h.Queries.GetAutopilot(r.Context(), run.AutopilotID); err == nil {
 				resp.AutopilotTitle = ap.Title
 				resp.ThreadName = ap.Title
+				h.attachSpaceToTaskResponse(r.Context(), &resp, ap.WorkspaceID, ap.SpaceID)
 				if ap.Description.Valid {
 					resp.AutopilotDescription = ap.Description.String
 				}
@@ -1844,6 +1847,16 @@ func (h *Handler) ClaimTaskByRuntime(w http.ResponseWriter, r *http.Request) {
 			resp.QuickCreateAttachmentIDs = append([]string(nil), qc.AttachmentIDs...)
 			resp.ThreadName = qc.Prompt
 			resp.WorkspaceID = qc.WorkspaceID
+			resp.SpaceID = qc.SpaceID
+			resp.SpaceKey = qc.SpaceKey
+			resp.SpaceName = qc.SpaceName
+			if qc.SpaceID != "" && (resp.SpaceKey == "" || resp.SpaceName == "") {
+				if spaceUUID, err := util.ParseUUID(qc.SpaceID); err == nil {
+					if wsUUID, wsErr := util.ParseUUID(qc.WorkspaceID); wsErr == nil {
+						h.attachSpaceToTaskResponse(r.Context(), &resp, wsUUID, spaceUUID)
+					}
+				}
+			}
 
 			// When the user picked a project in the modal, surface its title
 			// and resources to the daemon so the agent has the same context
@@ -1918,9 +1931,7 @@ func (h *Handler) ClaimTaskByRuntime(w http.ResponseWriter, r *http.Request) {
 							WorkspaceID: wsUUID,
 						})
 						if perr == nil && parent.ID.Valid {
-							if ws, werr := h.Queries.GetWorkspace(r.Context(), wsUUID); werr == nil {
-								resp.ParentIssueIdentifier = ws.IssuePrefix + "-" + strconv.Itoa(int(parent.Number))
-							}
+							resp.ParentIssueIdentifier = issueidentifier.PrefixForIssue(r.Context(), h.Queries, parent) + "-" + strconv.Itoa(int(parent.Number))
 						}
 					}
 				}
@@ -2070,6 +2081,22 @@ func (h *Handler) ClaimTaskByRuntime(w http.ResponseWriter, r *http.Request) {
 	payloadBytes, _ = writeMeasuredJSON(w, http.StatusOK, map[string]any{"task": resp})
 }
 
+func (h *Handler) attachSpaceToTaskResponse(ctx context.Context, resp *AgentTaskResponse, workspaceID, spaceID pgtype.UUID) {
+	if !spaceID.Valid {
+		return
+	}
+	space, err := h.Queries.GetWorkspaceSpace(ctx, db.GetWorkspaceSpaceParams{
+		ID:          spaceID,
+		WorkspaceID: workspaceID,
+	})
+	if err != nil {
+		return
+	}
+	resp.SpaceID = uuidToString(space.ID)
+	resp.SpaceKey = space.Key
+	resp.SpaceName = space.Name
+}
+
 type resolveSkillBundlesRequest struct {
 	Skills []resolveSkillBundleRef `json:"skills"`
 }
diff --git a/server/internal/handler/daemon_test.go b/server/internal/handler/daemon_test.go
index 5b8286f53f..faf6e9055e 100644
--- a/server/internal/handler/daemon_test.go
+++ b/server/internal/handler/daemon_test.go
@@ -157,9 +157,9 @@ func createClaimReclaimAgentAndIssue(t *testing.T, ctx context.Context, runtimeI
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position)
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type, number, position)
 		VALUES (
-			$1, $2, 'in_progress', 'none', $3, 'member',
+			$1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), $2, 'in_progress', 'none', $3, 'member',
 			(SELECT COALESCE(MAX(number), 82649) + 1 FROM issue WHERE workspace_id = $1),
 			0
 		)
@@ -1068,8 +1068,8 @@ func TestGetTaskStatus_WithDaemonToken_CrossWorkspace(t *testing.T) {
 	// Create a task in the test workspace.
 	var issueID, taskID string
 	err := testPool.QueryRow(context.Background(), `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type)
-		VALUES ($1, 'daemon-auth-test-issue', 'todo', 'medium', $2, 'member')
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'daemon-auth-test-issue', 'todo', 'medium', $2, 'member')
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID)
 	if err != nil {
@@ -1176,8 +1176,8 @@ func TestGetIssueGCCheck_WithDaemonToken_CrossWorkspace(t *testing.T) {
 	// only status + updated_at, so a "done" issue exercises the typical path.
 	var issueID string
 	err := testPool.QueryRow(context.Background(), `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type)
-		VALUES ($1, 'gc-check-auth-test-issue', 'done', 'medium', $2, 'member')
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'gc-check-auth-test-issue', 'done', 'medium', $2, 'member')
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID)
 	if err != nil {
@@ -1273,6 +1273,13 @@ func setupForeignWorkspaceFixture(t *testing.T) (string, string) {
 		testPool.Exec(context.Background(), `DELETE FROM workspace WHERE id = $1`, foreignWorkspaceID)
 	})
 
+	if _, err := testPool.Exec(ctx, `
+		INSERT INTO workspace_space (workspace_id, name, key)
+		VALUES ($1, 'Default', 'FOR')
+	`, foreignWorkspaceID); err != nil {
+		t.Fatalf("setup: seed foreign default space: %v", err)
+	}
+
 	var runtimeID string
 	if err := testPool.QueryRow(ctx, `
 		INSERT INTO agent_runtime (
@@ -1298,8 +1305,8 @@ func setupForeignWorkspaceFixture(t *testing.T) (string, string) {
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type)
-		VALUES ($1, 'foreign-workspace-issue', 'todo', 'medium', $2, 'agent')
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'foreign-workspace-issue', 'todo', 'medium', $2, 'agent')
 		RETURNING id
 	`, foreignWorkspaceID, agentID).Scan(&issueID); err != nil {
 		t.Fatalf("setup: create foreign issue: %v", err)
@@ -1390,8 +1397,8 @@ func TestCancelTask_TaskBelongsToDifferentIssue_Returns404(t *testing.T) {
 	// Issue X — the task's real parent.
 	var issueXID, taskID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position)
-		VALUES ($1, 'cancel-crossissue-x', 'todo', 'medium', $2, 'member', 91001, 0)
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type, number, position)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'cancel-crossissue-x', 'todo', 'medium', $2, 'member', 91001, 0)
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueXID); err != nil {
 		t.Fatalf("setup: create issue X: %v", err)
@@ -1410,8 +1417,8 @@ func TestCancelTask_TaskBelongsToDifferentIssue_Returns404(t *testing.T) {
 	// Issue Y — a sibling in the same workspace, used only as the URL cover.
 	var issueYID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position)
-		VALUES ($1, 'cancel-crossissue-y', 'todo', 'medium', $2, 'member', 91002, 0)
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type, number, position)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'cancel-crossissue-y', 'todo', 'medium', $2, 'member', 91002, 0)
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueYID); err != nil {
 		t.Fatalf("setup: create issue Y: %v", err)
@@ -1457,8 +1464,8 @@ func TestCancelTask_SameIssue_Succeeds(t *testing.T) {
 
 	var issueID, taskID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position)
-		VALUES ($1, 'cancel-happy-path', 'todo', 'medium', $2, 'member', 91003, 0)
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type, number, position)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'cancel-happy-path', 'todo', 'medium', $2, 'member', 91003, 0)
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
 		t.Fatalf("setup: create issue: %v", err)
@@ -1528,8 +1535,8 @@ func TestGetDaemonWorkspaceRepos_WithDaemonToken(t *testing.T) {
 	}
 
 	setHandlerTestWorkspaceRepos(t, []map[string]string{
-		{"url": "git@example.com:team/api.git", "description": "API"},
-		{"url": "  git@example.com:team/web.git  ", "description": " Web "},
+		{"url": "git@example.com:space/api.git", "description": "API"},
+		{"url": "  git@example.com:space/web.git  ", "description": " Web "},
 	})
 
 	w := httptest.NewRecorder()
@@ -1556,7 +1563,7 @@ func TestGetDaemonWorkspaceRepos_WithDaemonToken(t *testing.T) {
 	if len(resp.Repos) != 2 {
 		t.Fatalf("expected 2 repos, got %d", len(resp.Repos))
 	}
-	if resp.Repos[1]["url"] != "git@example.com:team/web.git" {
+	if resp.Repos[1]["url"] != "git@example.com:space/web.git" {
 		t.Fatalf("expected trimmed repo URL, got %q", resp.Repos[1]["url"])
 	}
 	if resp.ReposVersion == "" {
@@ -1585,8 +1592,8 @@ func TestGetDaemonWorkspaceRepos_VersionIgnoresOrderAndDescription(t *testing.T)
 	}
 
 	setHandlerTestWorkspaceRepos(t, []map[string]string{
-		{"url": "git@example.com:team/api.git", "description": "API"},
-		{"url": "git@example.com:team/web.git", "description": "Web"},
+		{"url": "git@example.com:space/api.git", "description": "API"},
+		{"url": "git@example.com:space/web.git", "description": "Web"},
 	})
 
 	getReposVersion := func() string {
@@ -1609,7 +1616,7 @@ func TestGetDaemonWorkspaceRepos_VersionIgnoresOrderAndDescription(t *testing.T)
 
 	version1 := getReposVersion()
 
-	if _, err := testPool.Exec(context.Background(), `UPDATE workspace SET repos = $1 WHERE id = $2`, []byte(`[{"url":"git@example.com:team/web.git","description":"frontend"},{"url":"git@example.com:team/api.git","description":"backend"}]`), testWorkspaceID); err != nil {
+	if _, err := testPool.Exec(context.Background(), `UPDATE workspace SET repos = $1 WHERE id = $2`, []byte(`[{"url":"git@example.com:space/web.git","description":"frontend"},{"url":"git@example.com:space/api.git","description":"backend"}]`), testWorkspaceID); err != nil {
 		t.Fatalf("update workspace repos: %v", err)
 	}
 	version2 := getReposVersion()
@@ -1617,7 +1624,7 @@ func TestGetDaemonWorkspaceRepos_VersionIgnoresOrderAndDescription(t *testing.T)
 		t.Fatalf("expected repos_version to ignore order/description changes, got %s vs %s", version1, version2)
 	}
 
-	if _, err := testPool.Exec(context.Background(), `UPDATE workspace SET repos = $1 WHERE id = $2`, []byte(`[{"url":"git@example.com:team/api.git","description":"backend"},{"url":"git@example.com:team/mobile.git","description":"mobile"}]`), testWorkspaceID); err != nil {
+	if _, err := testPool.Exec(context.Background(), `UPDATE workspace SET repos = $1 WHERE id = $2`, []byte(`[{"url":"git@example.com:space/api.git","description":"backend"},{"url":"git@example.com:space/mobile.git","description":"mobile"}]`), testWorkspaceID); err != nil {
 		t.Fatalf("update workspace repos: %v", err)
 	}
 	version3 := getReposVersion()
@@ -1679,8 +1686,8 @@ func TestDaemonRegister_MergesLegacyDaemonIDRuntime(t *testing.T) {
 	// drop historical tasks).
 	var legacyIssueID, legacyTaskID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position)
-		VALUES ($1, 'legacy-task-owner', 'todo', 'medium', $2, 'member', 97501, 0)
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type, number, position)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'legacy-task-owner', 'todo', 'medium', $2, 'member', 97501, 0)
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&legacyIssueID); err != nil {
 		t.Fatalf("seed legacy issue: %v", err)
@@ -2056,10 +2063,10 @@ func TestStartTask_AutopilotRunOnlyTask_ResolvesWorkspace(t *testing.T) {
 	var autopilotID string
 	if err := testPool.QueryRow(ctx, `
 		INSERT INTO autopilot (
-			workspace_id, title, assignee_id, execution_mode,
+			workspace_id, space_id, title, assignee_id, execution_mode,
 			created_by_type, created_by_id
 		)
-		VALUES ($1, 'run_only fixture', $2, 'run_only', 'member', $3)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'run_only fixture', $2, 'run_only', 'member', $3)
 		RETURNING id
 	`, testWorkspaceID, agentID, testUserID).Scan(&autopilotID); err != nil {
 		t.Fatalf("setup: create autopilot: %v", err)
@@ -2170,8 +2177,8 @@ func TestClaimTask_ProjectGithubReposOverrideWorkspaceRepos(t *testing.T) {
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
 		INSERT INTO issue (
-			workspace_id, project_id, title, status, priority, creator_id, creator_type, number, position
-		) VALUES ($1, $2, 'project repo override', 'todo', 'medium', $3, 'member', 88001, 0)
+			workspace_id, space_id, project_id, title, status, priority, creator_id, creator_type, number, position
+		) VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), $2, 'project repo override', 'todo', 'medium', $3, 'member', 88001, 0)
 		RETURNING id
 	`, testWorkspaceID, projectID, testUserID).Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
@@ -2261,8 +2268,8 @@ func TestClaimTask_ProjectDescriptionInjected(t *testing.T) {
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
 		INSERT INTO issue (
-			workspace_id, project_id, title, status, priority, creator_id, creator_type, number, position
-		) VALUES ($1, $2, 'project description', 'todo', 'medium', $3, 'member', 88002, 0)
+			workspace_id, space_id, project_id, title, status, priority, creator_id, creator_type, number, position
+		) VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), $2, 'project description', 'todo', 'medium', $3, 'member', 88002, 0)
 		RETURNING id
 	`, testWorkspaceID, projectID, testUserID).Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
@@ -2383,8 +2390,8 @@ func TestClaimTask_ProjectWithoutRepos_FallsBackToWorkspaceRepos(t *testing.T) {
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
 		INSERT INTO issue (
-			workspace_id, project_id, title, status, priority, creator_id, creator_type, number, position
-		) VALUES ($1, $2, 'no project repos', 'todo', 'medium', $3, 'member', 88002, 0)
+			workspace_id, space_id, project_id, title, status, priority, creator_id, creator_type, number, position
+		) VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), $2, 'no project repos', 'todo', 'medium', $3, 'member', 88002, 0)
 		RETURNING id
 	`, testWorkspaceID, projectID, testUserID).Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
@@ -2448,10 +2455,10 @@ func TestClaimTask_AutopilotRunOnly_PopulatesWorkspaceID(t *testing.T) {
 	var autopilotID string
 	if err := testPool.QueryRow(ctx, `
 		INSERT INTO autopilot (
-			workspace_id, title, assignee_id, execution_mode,
+			workspace_id, space_id, title, assignee_id, execution_mode,
 			created_by_type, created_by_id
 		)
-		VALUES ($1, 'claim workspace fixture', $2, 'run_only', 'member', $3)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'claim workspace fixture', $2, 'run_only', 'member', $3)
 		RETURNING id
 	`, testWorkspaceID, agentID, testUserID).Scan(&autopilotID); err != nil {
 		t.Fatalf("setup: create autopilot: %v", err)
@@ -2550,10 +2557,17 @@ func TestClaimTaskByRuntime_TaskWorkspaceMismatch_CancelsAndRejects(t *testing.T
 	}
 	t.Cleanup(func() { testPool.Exec(context.Background(), `DELETE FROM workspace WHERE id = $1`, foreignWorkspaceID) })
 
+	if _, err := testPool.Exec(ctx, `
+		INSERT INTO workspace_space (workspace_id, name, key)
+		VALUES ($1, 'Default', 'MFC')
+	`, foreignWorkspaceID); err != nil {
+		t.Fatalf("setup: seed foreign default space: %v", err)
+	}
+
 	var foreignIssueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position)
-		VALUES ($1, 'mismatch-foreign-issue', 'todo', 'medium', $2, 'member', 77001, 0)
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type, number, position)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'mismatch-foreign-issue', 'todo', 'medium', $2, 'member', 77001, 0)
 		RETURNING id
 	`, foreignWorkspaceID, testUserID).Scan(&foreignIssueID); err != nil {
 		t.Fatalf("setup: create foreign issue: %v", err)
@@ -2622,8 +2636,8 @@ func TestCompleteTask_CommentTriggered_SynthesizesCommentWhenAgentSilent(t *test
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position)
-		VALUES ($1, 'mul-3310 agent output fixture', 'in_progress', 'none', $2, 'member', 3310, 0)
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type, number, position)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'mul-3310 agent output fixture', 'in_progress', 'none', $2, 'member', 3310, 0)
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
 		t.Fatalf("setup: create issue: %v", err)
@@ -2728,8 +2742,8 @@ func TestCompleteTask_CommentTriggered_SkipsSynthesisWhenAgentAlreadyCommented(t
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position)
-		VALUES ($1, 'mul-1198 dedup fixture', 'in_progress', 'none', $2, 'member', 81199, 0)
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type, number, position)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'mul-1198 dedup fixture', 'in_progress', 'none', $2, 'member', 81199, 0)
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
 		t.Fatalf("setup: create issue: %v", err)
@@ -2807,8 +2821,8 @@ func TestCompleteTask_CommentTriggered_SuppressesTrivialDoneOutput(t *testing.T)
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position)
-		VALUES ($1, 'trivial-done-suppression fixture', 'in_progress', 'none', $2, 'member', 81200, 0)
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type, number, position)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'trivial-done-suppression fixture', 'in_progress', 'none', $2, 'member', 81200, 0)
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
 		t.Fatalf("setup: create issue: %v", err)
@@ -2878,8 +2892,8 @@ func TestCompleteTask_AssignmentTriggered_DoesNotSuppressTrivialDoneOutput(t *te
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position)
-		VALUES ($1, 'assignment-trivial-done fixture', 'in_progress', 'none', $2, 'member', 81201, 0)
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type, number, position)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'assignment-trivial-done fixture', 'in_progress', 'none', $2, 'member', 81201, 0)
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
 		t.Fatalf("setup: create issue: %v", err)
@@ -3148,8 +3162,8 @@ func TestClaimTask_IssuePriorSessionRuntimeGuard(t *testing.T) {
 
 	var skipIssueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position)
-		VALUES ($1, 'runtime-session-skip fixture', 'in_progress', 'none', $2, 'member', 81203, 0)
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type, number, position)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'runtime-session-skip fixture', 'in_progress', 'none', $2, 'member', 81203, 0)
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&skipIssueID); err != nil {
 		t.Fatalf("setup: create skip issue: %v", err)
@@ -3196,8 +3210,8 @@ func TestClaimTask_IssuePriorSessionRuntimeGuard(t *testing.T) {
 
 	var resumeIssueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position)
-		VALUES ($1, 'runtime-session-resume fixture', 'in_progress', 'none', $2, 'member', 81204, 0)
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type, number, position)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'runtime-session-resume fixture', 'in_progress', 'none', $2, 'member', 81204, 0)
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&resumeIssueID); err != nil {
 		t.Fatalf("setup: create resume issue: %v", err)
@@ -3234,8 +3248,8 @@ func TestClaimTask_IssuePriorSessionRuntimeGuard(t *testing.T) {
 
 	var commentIssueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position)
-		VALUES ($1, 'comment-triggered-session-skip fixture', 'in_progress', 'none', $2, 'member', 81205, 0)
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type, number, position)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'comment-triggered-session-skip fixture', 'in_progress', 'none', $2, 'member', 81205, 0)
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&commentIssueID); err != nil {
 		t.Fatalf("setup: create comment-triggered issue: %v", err)
@@ -3289,8 +3303,8 @@ func TestClaimTask_IssuePriorSessionRuntimeGuard(t *testing.T) {
 
 	var freshIssueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position)
-		VALUES ($1, 'force-fresh-session fixture', 'in_progress', 'none', $2, 'member', 81206, 0)
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type, number, position)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'force-fresh-session fixture', 'in_progress', 'none', $2, 'member', 81206, 0)
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&freshIssueID); err != nil {
 		t.Fatalf("setup: create force-fresh issue: %v", err)
@@ -3801,10 +3815,10 @@ func TestGetAutopilotRunGCCheck(t *testing.T) {
 	var autopilotID string
 	if err := testPool.QueryRow(ctx, `
 		INSERT INTO autopilot (
-			workspace_id, title, assignee_id, execution_mode,
+			workspace_id, space_id, title, assignee_id, execution_mode,
 			created_by_type, created_by_id
 		)
-		VALUES ($1, 'gc-check autopilot', $2, 'run_only', 'member', $3)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'gc-check autopilot', $2, 'run_only', 'member', $3)
 		RETURNING id
 	`, testWorkspaceID, agentID, testUserID).Scan(&autopilotID); err != nil {
 		t.Fatalf("setup: create autopilot: %v", err)
diff --git a/server/internal/handler/dashboard_test.go b/server/internal/handler/dashboard_test.go
index 9a3d7218db..daaf94cde0 100644
--- a/server/internal/handler/dashboard_test.go
+++ b/server/internal/handler/dashboard_test.go
@@ -59,9 +59,9 @@ func TestDashboardEndpoints(t *testing.T) {
 			pid = projectID
 		}
 		if err := testPool.QueryRow(ctx, `
-			INSERT INTO issue (workspace_id, title, creator_id, creator_type, project_id, number)
+			INSERT INTO issue (workspace_id, space_id, title, creator_id, creator_type, project_id, number)
 			VALUES (
-				$1, 'dashboard test', $2, 'member', $3,
+				$1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'dashboard test', $2, 'member', $3,
 				(SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1)
 			)
 			RETURNING id
@@ -351,8 +351,8 @@ func TestDashboardRunTimeDailyBucketsByViewerTimezone(t *testing.T) {
 	// Issue tagged so we can clean up just this test's rows.
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, creator_id, creator_type, number)
-		VALUES ($1, 'runtime-daily tz test', $2, 'member',
+		INSERT INTO issue (workspace_id, space_id, title, creator_id, creator_type, number)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'runtime-daily tz test', $2, 'member',
 		        (SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1))
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
@@ -447,8 +447,8 @@ func TestRollupTaskUsageHourlyIdempotentAndWatermark(t *testing.T) {
 
 	var issueID, taskID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, creator_id, creator_type, number)
-		VALUES ($1, 'rollup idempotency', $2, 'member',
+		INSERT INTO issue (workspace_id, space_id, title, creator_id, creator_type, number)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'rollup idempotency', $2, 'member',
 		        (SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1))
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
@@ -558,8 +558,8 @@ func TestRollupTaskUsageHourlyReassignBetweenRuntimes(t *testing.T) {
 	}
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, creator_id, creator_type, number)
-		VALUES ($1, 'reassign hourly test', $2, 'member',
+		INSERT INTO issue (workspace_id, space_id, title, creator_id, creator_type, number)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'reassign hourly test', $2, 'member',
 		        (SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1))
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
@@ -682,8 +682,8 @@ func TestRollupTaskUsageHourlyWorkspaceMismatch(t *testing.T) {
 	// foreign one — so agent.workspace_id != issue.workspace_id.
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, creator_id, creator_type, number)
-		VALUES ($1, 'mismatch hourly test', $2, 'member',
+		INSERT INTO issue (workspace_id, space_id, title, creator_id, creator_type, number)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'mismatch hourly test', $2, 'member',
 		        (SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1))
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
@@ -766,8 +766,8 @@ func TestDashboardRollupReattributesOnProjectChange(t *testing.T) {
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, creator_id, creator_type, project_id, number)
-		VALUES ($1, 'reattr issue', $2, 'member', $3,
+		INSERT INTO issue (workspace_id, space_id, title, creator_id, creator_type, project_id, number)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'reattr issue', $2, 'member', $3,
 		        (SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1))
 		RETURNING id
 	`, testWorkspaceID, testUserID, projectA).Scan(&issueID); err != nil {
@@ -871,8 +871,8 @@ func TestDashboardRollupClearsOnIssueDelete(t *testing.T) {
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, creator_id, creator_type, project_id, number)
-		VALUES ($1, 'cascade issue', $2, 'member', $3,
+		INSERT INTO issue (workspace_id, space_id, title, creator_id, creator_type, project_id, number)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'cascade issue', $2, 'member', $3,
 		        (SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1))
 		RETURNING id
 	`, testWorkspaceID, testUserID, projectID).Scan(&issueID); err != nil {
@@ -1004,8 +1004,8 @@ func TestDashboardRollupReattributesOnLinkTaskToIssue(t *testing.T) {
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, creator_id, creator_type, project_id, number)
-		VALUES ($1, 'link test issue', $2, 'member', $3,
+		INSERT INTO issue (workspace_id, space_id, title, creator_id, creator_type, project_id, number)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'link test issue', $2, 'member', $3,
 		        (SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1))
 		RETURNING id
 	`, testWorkspaceID, testUserID, projectID).Scan(&issueID); err != nil {
@@ -1228,8 +1228,8 @@ func TestDashboardUsageDailyCrossMidnightFullPipeline(t *testing.T) {
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, creator_id, creator_type, number)
-		VALUES ($1, 'cross-midnight pipeline test', $2, 'member',
+		INSERT INTO issue (workspace_id, space_id, title, creator_id, creator_type, number)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'cross-midnight pipeline test', $2, 'member',
 		        (SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1))
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
@@ -1339,8 +1339,8 @@ func TestRollupTaskUsageHourlyConvergesOnTaskUsageDelete(t *testing.T) {
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, creator_id, creator_type, number)
-		VALUES ($1, 'tu-delete trigger test', $2, 'member',
+		INSERT INTO issue (workspace_id, space_id, title, creator_id, creator_type, number)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'tu-delete trigger test', $2, 'member',
 		        (SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1))
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
diff --git a/server/internal/handler/github.go b/server/internal/handler/github.go
index 828d0b50b9..5c53a5f56d 100644
--- a/server/internal/handler/github.go
+++ b/server/internal/handler/github.go
@@ -23,6 +23,7 @@ import (
 	"github.com/golang-jwt/jwt/v5"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/multica-ai/multica/server/internal/issueidentifier"
 	"github.com/multica-ai/multica/server/internal/middleware"
 	db "github.com/multica-ai/multica/server/pkg/db/generated"
 	"github.com/multica-ai/multica/server/pkg/protocol"
@@ -581,7 +582,7 @@ func (h *Handler) ListPullRequestsForIssue(w http.ResponseWriter, r *http.Reques
 // uppercase. Word boundary on the left prevents matching inside email-style
 // strings (e.g. "abc@MUL-1") and the digit anchor on the right rules out
 // version numbers like "v1.2-3".
-var identifierRe = regexp.MustCompile(`(?i)\b([a-z][a-z0-9]{1,9})-(\d+)\b`)
+var identifierRe = regexp.MustCompile(`(?i)\b([a-z][a-z0-9]{0,6})-(\d+)\b`)
 
 // closingIdentifierRe extracts identifiers that appear immediately after a
 // GitHub-style closing keyword ("close[sd]?", "fix(e[sd])?", "resolve[sd]?"),
@@ -593,7 +594,7 @@ var identifierRe = regexp.MustCompile(`(?i)\b([a-z][a-z0-9]{1,9})-(\d+)\b`)
 // title prefixes like "MUL-1: ..." link the PR (via identifierRe) but
 // never auto-close.
 var closingIdentifierRe = regexp.MustCompile(
-	`(?i)\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)[:\s]+([a-z][a-z0-9]{1,9})-(\d+)\b`,
+	`(?i)\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)[:\s]+([a-z][a-z0-9]{0,6})-(\d+)\b`,
 )
 
 // HandleGitHubWebhook (POST /api/webhooks/github) is GitHub's destination for
@@ -911,7 +912,7 @@ func (h *Handler) handlePullRequestEvent(ctx context.Context, body []byte) {
 		// a terminal event, later edit/synchronize webhooks must not rewrite
 		// the merge-time close decision.
 		preserveCloseIntent := p.Action != "closed" && (state == "merged" || state == "closed")
-		prefix := h.getIssuePrefix(ctx, wsID)
+		prefix := issueidentifier.PrefixForWorkspace(ctx, h.Queries, wsID)
 		// reevalIssues collects each issue whose link row we just touched so
 		// we can re-run the auto-advance gate against the persisted aggregate
 		// after every link upsert in this event. Driving the gate off
@@ -1408,26 +1409,34 @@ func (h *Handler) workspaceAutoLinkPRsEnabled(ctx context.Context, workspaceID p
 	return *s.GitHubAutoLinkPRsEnabled
 }
 
-// the workspace's configured prefix and the number resolves to a real issue.
+// the Space key and number resolve to a real issue in the workspace.
 func (h *Handler) lookupIssueByIdentifier(ctx context.Context, workspaceID pgtype.UUID, prefix, identifier string) (db.Issue, bool) {
+	_ = prefix // compatibility parameter; Space key now comes from identifier itself.
 	idx := strings.LastIndex(identifier, "-")
 	if idx < 0 {
 		return db.Issue{}, false
 	}
 	gotPrefix, numStr := identifier[:idx], identifier[idx+1:]
-	if !strings.EqualFold(gotPrefix, prefix) {
-		return db.Issue{}, false
-	}
 	n, err := strconv.Atoi(numStr)
 	if err != nil {
 		return db.Issue{}, false
 	}
-	issue, err := h.Queries.GetIssueByNumber(ctx, db.GetIssueByNumberParams{
+	issue, err := h.Queries.GetIssueBySpaceKeyAndNumber(ctx, db.GetIssueBySpaceKeyAndNumberParams{
 		WorkspaceID: workspaceID,
+		Lower:       gotPrefix,
 		Number:      int32(n),
 	})
 	if err != nil {
-		return db.Issue{}, false
+		// Branch names / PR titles keep referencing the pre-move identifier
+		// after an issue moves spaces; the alias keeps auto-linking working.
+		issue, err = h.Queries.GetIssueByIdentifierAlias(ctx, db.GetIssueByIdentifierAliasParams{
+			WorkspaceID:   workspaceID,
+			SpaceKeyLower: gotPrefix,
+			Number:        int32(n),
+		})
+		if err != nil {
+			return db.Issue{}, false
+		}
 	}
 	return issue, true
 }
@@ -1451,8 +1460,7 @@ func (h *Handler) advanceIssueToDone(ctx context.Context, issue db.Issue, worksp
 	// exists, parent not terminal), so calling it unconditionally is safe.
 	h.notifyParentOfChildDone(ctx, issue, updated)
 
-	prefix := h.getIssuePrefix(ctx, issue.WorkspaceID)
-	resp := issueToResponse(updated, prefix)
+	resp := issueToResponse(updated, issueidentifier.PrefixForIssue(ctx, h.Queries, updated))
 	h.publish(protocol.EventIssueUpdated, workspaceID, "system", "", map[string]any{
 		"issue":          resp,
 		"status_changed": true,
diff --git a/server/internal/handler/handler.go b/server/internal/handler/handler.go
index 7dca3a0536..a011d63481 100644
--- a/server/internal/handler/handler.go
+++ b/server/internal/handler/handler.go
@@ -672,12 +672,22 @@ func (h *Handler) resolveIssueByIdentifier(ctx context.Context, id, workspaceID
 	if err != nil {
 		return db.Issue{}, false
 	}
-	issue, err := h.Queries.GetIssueByNumber(ctx, db.GetIssueByNumberParams{
+	issue, err := h.Queries.GetIssueBySpaceKeyAndNumber(ctx, db.GetIssueBySpaceKeyAndNumberParams{
 		WorkspaceID: wsUUID,
+		Lower:       parts.prefix,
 		Number:      parts.number,
 	})
 	if err != nil {
-		return db.Issue{}, false
+		// The identifier may be pre-move: moving an issue between spaces
+		// renumbers it but records the old identifier as an alias.
+		issue, err = h.Queries.GetIssueByIdentifierAlias(ctx, db.GetIssueByIdentifierAliasParams{
+			WorkspaceID:   wsUUID,
+			SpaceKeyLower: parts.prefix,
+			Number:        parts.number,
+		})
+		if err != nil {
+			return db.Issue{}, false
+		}
 	}
 	return issue, true
 }
@@ -712,20 +722,6 @@ func splitIdentifier(id string) *identifierParts {
 	return &identifierParts{prefix: id[:idx], number: int32(num)}
 }
 
-// getIssuePrefix fetches the issue_prefix for a workspace.
-// Falls back to generating a prefix from the workspace name if the stored
-// prefix is empty (e.g. workspaces created before the prefix was introduced).
-func (h *Handler) getIssuePrefix(ctx context.Context, workspaceID pgtype.UUID) string {
-	ws, err := h.Queries.GetWorkspace(ctx, workspaceID)
-	if err != nil {
-		return ""
-	}
-	if ws.IssuePrefix != "" {
-		return ws.IssuePrefix
-	}
-	return generateIssuePrefix(ws.Name)
-}
-
 func (h *Handler) loadAgentForUser(w http.ResponseWriter, r *http.Request, agentID string) (db.Agent, bool) {
 	if _, ok := requireUserID(w, r); !ok {
 		return db.Agent{}, false
diff --git a/server/internal/handler/handler_test.go b/server/internal/handler/handler_test.go
index 1162c26430..5cf17a4aab 100644
--- a/server/internal/handler/handler_test.go
+++ b/server/internal/handler/handler_test.go
@@ -103,11 +103,13 @@ func setupHandlerTestFixture(ctx context.Context, pool *pgxpool.Pool) (string, s
 	}
 
 	var workspaceID string
+	var workspaceCounter int32
+	var workspacePrefix string
 	if err := pool.QueryRow(ctx, `
 		INSERT INTO workspace (name, slug, description, issue_prefix)
 		VALUES ($1, $2, $3, $4)
-		RETURNING id
-	`, "Handler Tests", handlerTestWorkspaceSlug, "Temporary workspace for handler tests", "HAN").Scan(&workspaceID); err != nil {
+		RETURNING id, issue_counter, issue_prefix
+	`, "Handler Tests", handlerTestWorkspaceSlug, "Temporary workspace for handler tests", "HAN").Scan(&workspaceID, &workspaceCounter, &workspacePrefix); err != nil {
 		return "", "", err
 	}
 
@@ -118,6 +120,18 @@ func setupHandlerTestFixture(ctx context.Context, pool *pgxpool.Pool) (string, s
 		return "", "", err
 	}
 
+	// Seed the default Space so space-aware issue/autopilot creates resolve a Space
+	// the same way migration 131 backfills production workspaces, and so direct
+	// inserts can carry the NOT NULL space_id from migration 132. The space's
+	// issue_counter mirrors the workspace counter so the two never hand out
+	// overlapping numbers.
+	if _, err := pool.Exec(ctx, `
+		INSERT INTO workspace_space (workspace_id, name, key, issue_counter, created_by)
+		VALUES ($1, 'Default', $2, $3, $4)
+	`, workspaceID, workspacePrefix, workspaceCounter, userID); err != nil {
+		return "", "", err
+	}
+
 	var runtimeID string
 	if err := pool.QueryRow(ctx, `
 		INSERT INTO agent_runtime (
@@ -496,6 +510,127 @@ func TestDeleteIssueByIdentifier(t *testing.T) {
 	}
 }
 
+func TestUpdateIssueProjectAndSpaceUsesFinalProjectSpacePair(t *testing.T) {
+	ctx := context.Background()
+	suffix := time.Now().UnixNano() % 1_000_000
+	oldSpaceKey := fmt.Sprintf("OA%05d", suffix%100000)
+	targetSpaceKey := fmt.Sprintf("TB%05d", suffix%100000)
+
+	var oldSpaceID, targetSpaceID string
+	if err := testPool.QueryRow(ctx, `
+		INSERT INTO workspace_space (workspace_id, name, key, issue_counter, created_by)
+		VALUES ($1, $2, $3, 1, $4)
+		RETURNING id
+	`, testWorkspaceID, "Old Space", oldSpaceKey, testUserID).Scan(&oldSpaceID); err != nil {
+		t.Fatalf("insert old space: %v", err)
+	}
+	if err := testPool.QueryRow(ctx, `
+		INSERT INTO workspace_space (workspace_id, name, key, issue_counter, created_by)
+		VALUES ($1, $2, $3, 10, $4)
+		RETURNING id
+	`, testWorkspaceID, "Target Space", targetSpaceKey, testUserID).Scan(&targetSpaceID); err != nil {
+		t.Fatalf("insert target space: %v", err)
+	}
+
+	var oldProjectID, targetProjectID string
+	if err := testPool.QueryRow(ctx, `
+		INSERT INTO project (workspace_id, title, priority)
+		VALUES ($1, $2, 'none')
+		RETURNING id
+	`, testWorkspaceID, "Old Project").Scan(&oldProjectID); err != nil {
+		t.Fatalf("insert old project: %v", err)
+	}
+	if err := testPool.QueryRow(ctx, `
+		INSERT INTO project (workspace_id, title, priority)
+		VALUES ($1, $2, 'none')
+		RETURNING id
+	`, testWorkspaceID, "Target Project").Scan(&targetProjectID); err != nil {
+		t.Fatalf("insert target project: %v", err)
+	}
+	if _, err := testPool.Exec(ctx, `
+		INSERT INTO project_space (workspace_id, project_id, space_id)
+		VALUES ($1, $2, $3), ($1, $4, $5)
+	`, testWorkspaceID, oldProjectID, oldSpaceID, targetProjectID, targetSpaceID); err != nil {
+		t.Fatalf("insert project spaces: %v", err)
+	}
+
+	var issueID string
+	var oldNumber int32
+	if err := testPool.QueryRow(ctx, `
+		INSERT INTO issue (
+			workspace_id, space_id, project_id, title, status, priority,
+			creator_type, creator_id, number, position
+		)
+		VALUES ($1, $2, $3, 'move issue final pair test', 'todo', 'none', 'member', $4, 1, 0)
+		RETURNING id, number
+	`, testWorkspaceID, oldSpaceID, oldProjectID, testUserID).Scan(&issueID, &oldNumber); err != nil {
+		t.Fatalf("insert issue: %v", err)
+	}
+	t.Cleanup(func() {
+		testPool.Exec(context.Background(), `DELETE FROM issue_identifier_alias WHERE issue_id = $1`, issueID)
+		testPool.Exec(context.Background(), `DELETE FROM issue WHERE id = $1`, issueID)
+		testPool.Exec(context.Background(), `DELETE FROM project WHERE id IN ($1, $2)`, oldProjectID, targetProjectID)
+		testPool.Exec(context.Background(), `DELETE FROM workspace_space WHERE id IN ($1, $2)`, oldSpaceID, targetSpaceID)
+	})
+
+	w := httptest.NewRecorder()
+	req := newRequest("PATCH", "/api/issues/"+issueID, map[string]any{
+		"project_id": targetProjectID,
+		"space_id":   targetSpaceID,
+	})
+	req = withURLParam(req, "id", issueID)
+	testHandler.UpdateIssue(w, req)
+	if w.Code != http.StatusOK {
+		t.Fatalf("UpdateIssue: expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+
+	var updated IssueResponse
+	if err := json.NewDecoder(w.Body).Decode(&updated); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if updated.ProjectID == nil || *updated.ProjectID != targetProjectID {
+		t.Fatalf("project_id = %v, want %s", updated.ProjectID, targetProjectID)
+	}
+	if updated.SpaceID == nil || *updated.SpaceID != targetSpaceID {
+		t.Fatalf("space_id = %v, want %s", updated.SpaceID, targetSpaceID)
+	}
+
+	projectSpaceCount := func(projectID, spaceID string) int {
+		t.Helper()
+		var count int
+		if err := testPool.QueryRow(ctx, `
+			SELECT count(*) FROM project_space
+			WHERE workspace_id = $1 AND project_id = $2 AND space_id = $3
+		`, testWorkspaceID, projectID, spaceID).Scan(&count); err != nil {
+			t.Fatalf("count project_space %s/%s: %v", projectID, spaceID, err)
+		}
+		return count
+	}
+	if got := projectSpaceCount(targetProjectID, targetSpaceID); got != 1 {
+		t.Fatalf("target project/target space count = %d, want 1", got)
+	}
+	if got := projectSpaceCount(targetProjectID, oldSpaceID); got != 0 {
+		t.Fatalf("target project/old space count = %d, want 0", got)
+	}
+	if got := projectSpaceCount(oldProjectID, targetSpaceID); got != 0 {
+		t.Fatalf("old project/target space count = %d, want 0", got)
+	}
+	if got := projectSpaceCount(oldProjectID, oldSpaceID); got != 1 {
+		t.Fatalf("old project/old space count = %d, want 1", got)
+	}
+
+	var aliasCount int
+	if err := testPool.QueryRow(ctx, `
+		SELECT count(*) FROM issue_identifier_alias
+		WHERE workspace_id = $1 AND space_key_lower = lower($2) AND number = $3 AND issue_id = $4
+	`, testWorkspaceID, oldSpaceKey, oldNumber, issueID).Scan(&aliasCount); err != nil {
+		t.Fatalf("count identifier alias: %v", err)
+	}
+	if aliasCount != 1 {
+		t.Fatalf("identifier alias count = %d, want 1", aliasCount)
+	}
+}
+
 // TestDeleteIssueRejectsInvalidUUID verifies that a path segment that is
 // neither a valid UUID nor a valid identifier returns 404 (not 204) — the
 // handler must never silently succeed on malformed input.
@@ -584,10 +719,17 @@ func TestCreateIssueRejectsCrossWorkspaceParent(t *testing.T) {
 		testPool.Exec(ctx, `DELETE FROM workspace WHERE id = $1`, otherWorkspaceID)
 	})
 
+	if _, err := testPool.Exec(ctx, `
+		INSERT INTO workspace_space (workspace_id, name, key)
+		VALUES ($1, 'Default', 'XWP')
+	`, otherWorkspaceID); err != nil {
+		t.Fatalf("insert foreign default space: %v", err)
+	}
+
 	var foreignParentID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, number)
-		VALUES ($1, $2, 'todo', 'none', 'member', $3, 1)
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_type, creator_id, number)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), $2, 'todo', 'none', 'member', $3, 1)
 		RETURNING id
 	`, otherWorkspaceID, "Foreign parent", testUserID).Scan(&foreignParentID); err != nil {
 		t.Fatalf("insert foreign parent: %v", err)
@@ -1735,8 +1877,8 @@ func TestCommentWritePathsPreserveIssueIdentifiers(t *testing.T) {
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title, number)
-		VALUES ($1, 'member', $2, $3, 3310)
+		INSERT INTO issue (workspace_id, space_id, creator_type, creator_id, title, number)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'member', $2, $3, 3310)
 		RETURNING id
 	`, testWorkspaceID, testUserID, "preserve bare issue identifiers").Scan(&issueID); err != nil {
 		t.Fatalf("create issue fixture: %v", err)
@@ -2799,8 +2941,8 @@ func TestResolveActor(t *testing.T) {
 	// Create a task for the agent so we can test X-Task-ID validation.
 	var issueID string
 	err = testPool.QueryRow(ctx,
-		`INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, number, position)
-		 VALUES ($1, 'resolveActor test', 'todo', 'none', 'member', $2, 9999, 0)
+		`INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_type, creator_id, number, position)
+		 VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'resolveActor test', 'todo', 'none', 'member', $2, 9999, 0)
 		 RETURNING id`, testWorkspaceID, testUserID,
 	).Scan(&issueID)
 	if err != nil {
@@ -3584,17 +3726,17 @@ func TestNestedMemberReplyUsesDirectParentForMentionInheritance(t *testing.T) {
 
 	var number int
 	if err := testPool.QueryRow(ctx, `
-		UPDATE workspace
-		SET issue_counter = GREATEST(issue_counter, (SELECT COALESCE(MAX(number), 0) FROM issue WHERE workspace_id = $1)) + 1
-		WHERE id = $1 RETURNING issue_counter
+		UPDATE workspace_space
+		SET issue_counter = GREATEST(issue_counter, (SELECT COALESCE(MAX(number), 0) FROM issue WHERE space_id = workspace_space.id)) + 1
+		WHERE workspace_id = $1 RETURNING issue_counter
 	`, testWorkspaceID).Scan(&number); err != nil {
 		t.Fatalf("next issue number: %v", err)
 	}
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title, assignee_type, assignee_id, number)
-		VALUES ($1, 'member', $2, $3, 'agent', $4, $5)
+		INSERT INTO issue (workspace_id, space_id, creator_type, creator_id, title, assignee_type, assignee_id, number)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'member', $2, $3, 'agent', $4, $5)
 		RETURNING id
 	`, testWorkspaceID, testUserID, "nested mention inheritance regression", assigneeAgent, number).Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
@@ -3679,17 +3821,17 @@ func TestNestedMemberReplyUsesDirectParentForAssigneeParticipation(t *testing.T)
 
 	var number int
 	if err := testPool.QueryRow(ctx, `
-		UPDATE workspace
-		SET issue_counter = GREATEST(issue_counter, (SELECT COALESCE(MAX(number), 0) FROM issue WHERE workspace_id = $1)) + 1
-		WHERE id = $1 RETURNING issue_counter
+		UPDATE workspace_space
+		SET issue_counter = GREATEST(issue_counter, (SELECT COALESCE(MAX(number), 0) FROM issue WHERE space_id = workspace_space.id)) + 1
+		WHERE workspace_id = $1 RETURNING issue_counter
 	`, testWorkspaceID).Scan(&number); err != nil {
 		t.Fatalf("next issue number: %v", err)
 	}
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title, assignee_type, assignee_id, number)
-		VALUES ($1, 'member', $2, $3, 'agent', $4, $5)
+		INSERT INTO issue (workspace_id, space_id, creator_type, creator_id, title, assignee_type, assignee_id, number)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'member', $2, $3, 'agent', $4, $5)
 		RETURNING id
 	`, testWorkspaceID, testUserID, "nested participation regression", assigneeAgent, number).Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
diff --git a/server/internal/handler/invitation.go b/server/internal/handler/invitation.go
index aaa13518ae..0c1c86e470 100644
--- a/server/internal/handler/invitation.go
+++ b/server/internal/handler/invitation.go
@@ -427,6 +427,24 @@ func (h *Handler) AcceptInvitation(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// Every system-placed member joins the default space: the sidebar shows
+	// joined spaces only, and issue creation needs a per-user default. Hard
+	// failure (rolls the whole accept back) — a missing default space is data
+	// corruption, and silently skipping would mint a space-less member.
+	defSpace, err := qtx.GetDefaultWorkspaceSpace(r.Context(), accepted.WorkspaceID)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to resolve default space")
+		return
+	}
+	spaceRole := "member"
+	if accepted.Role == "owner" || accepted.Role == "admin" {
+		spaceRole = "lead"
+	}
+	if _, err := addSpaceMember(r.Context(), qtx, accepted.WorkspaceID, defSpace.ID, user.ID, spaceRole); err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to join default space")
+		return
+	}
+
 	// Accepting an invite marks the invitee as onboarded. The web /
 	// desktop workspace layout has a hard onboarded_at gate; without
 	// this mark, an invitee landing on their first workspace would be
diff --git a/server/internal/handler/issue.go b/server/internal/handler/issue.go
index c9c67ede2a..4c5ef11eef 100644
--- a/server/internal/handler/issue.go
+++ b/server/internal/handler/issue.go
@@ -19,6 +19,8 @@ import (
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/multica-ai/multica/server/internal/issueguard"
+	"github.com/multica-ai/multica/server/internal/issueidentifier"
+	"github.com/multica-ai/multica/server/internal/issueposition"
 	"github.com/multica-ai/multica/server/internal/logger"
 	"github.com/multica-ai/multica/server/internal/middleware"
 	"github.com/multica-ai/multica/server/internal/service"
@@ -32,6 +34,9 @@ import (
 type IssueResponse struct {
 	ID            string  `json:"id"`
 	WorkspaceID   string  `json:"workspace_id"`
+	SpaceID       *string `json:"space_id,omitempty"`
+	SpaceKey      *string `json:"space_key,omitempty"`
+	SpaceName     *string `json:"space_name,omitempty"`
 	Number        int32   `json:"number"`
 	Identifier    string  `json:"identifier"`
 	Title         string  `json:"title"`
@@ -87,9 +92,12 @@ func validateIssueEnum(w http.ResponseWriter, field, value string, allowed []str
 
 func issueToResponse(i db.Issue, issuePrefix string) IssueResponse {
 	identifier := issuePrefix + "-" + strconv.Itoa(int(i.Number))
+	spaceKey := issuePrefix
 	return IssueResponse{
 		ID:            uuidToString(i.ID),
 		WorkspaceID:   uuidToString(i.WorkspaceID),
+		SpaceID:       uuidToPtr(i.SpaceID),
+		SpaceKey:      &spaceKey,
 		Number:        i.Number,
 		Identifier:    identifier,
 		Title:         i.Title,
@@ -114,10 +122,21 @@ func issueToResponse(i db.Issue, issuePrefix string) IssueResponse {
 
 // issueListRowToResponse converts a list-query row (no description) to an IssueResponse.
 func issueListRowToResponse(i db.ListIssuesRow, issuePrefix string) IssueResponse {
+	if i.SpaceKey != "" {
+		issuePrefix = i.SpaceKey
+	}
 	identifier := issuePrefix + "-" + strconv.Itoa(int(i.Number))
+	spaceKey := issuePrefix
+	var spaceName *string
+	if i.SpaceName != "" {
+		spaceName = &i.SpaceName
+	}
 	return IssueResponse{
 		ID:            uuidToString(i.ID),
 		WorkspaceID:   uuidToString(i.WorkspaceID),
+		SpaceID:       uuidToPtr(i.SpaceID),
+		SpaceKey:      &spaceKey,
+		SpaceName:     spaceName,
 		Number:        i.Number,
 		Identifier:    identifier,
 		Title:         i.Title,
@@ -172,10 +191,21 @@ func (h *Handler) labelsByIssue(ctx context.Context, wsUUID pgtype.UUID, issueID
 }
 
 func openIssueRowToResponse(i db.ListOpenIssuesRow, issuePrefix string) IssueResponse {
+	if i.SpaceKey != "" {
+		issuePrefix = i.SpaceKey
+	}
 	identifier := issuePrefix + "-" + strconv.Itoa(int(i.Number))
+	spaceKey := issuePrefix
+	var spaceName *string
+	if i.SpaceName != "" {
+		spaceName = &i.SpaceName
+	}
 	return IssueResponse{
 		ID:            uuidToString(i.ID),
 		WorkspaceID:   uuidToString(i.WorkspaceID),
+		SpaceID:       uuidToPtr(i.SpaceID),
+		SpaceKey:      &spaceKey,
+		SpaceName:     spaceName,
 		Number:        i.Number,
 		Identifier:    identifier,
 		Title:         i.Title,
@@ -351,29 +381,33 @@ func splitSearchTerms(q string) []string {
 	return terms
 }
 
-// identifierNumberRe matches patterns like "MUL-123" or "ABC-45".
-var identifierNumberRe = regexp.MustCompile(`(?i)^[a-z]+-(\d+)$`)
+// identifierNumberRe matches Space-scoped identifiers like "MUL-123" or "ABC-45".
+var identifierNumberRe = regexp.MustCompile(`(?i)^([a-z][a-z0-9]{0,6})-(\d+)$`)
 
 // parseQueryNumber extracts an issue number from the query if it looks like
-// an identifier (e.g. "MUL-123") or a bare number (e.g. "123").
-func parseQueryNumber(q string) (int, bool) {
+// an identifier (e.g. "MUL-123") or a bare number (e.g. "123"). When an
+// identifier is supplied, the Space key must be preserved so search does not
+// collapse Space namespaces back to workspace+number.
+func parseQueryNumber(q string) (int, string, bool) {
 	q = strings.TrimSpace(q)
 	// Check for identifier pattern like "MUL-123"
 	if m := identifierNumberRe.FindStringSubmatch(q); m != nil {
-		if n, err := strconv.Atoi(m[1]); err == nil && n > 0 {
-			return n, true
+		if n, err := strconv.Atoi(m[2]); err == nil && n > 0 {
+			return n, m[1], true
 		}
 	}
 	// Check for bare number
 	if n, err := strconv.Atoi(q); err == nil && n > 0 {
-		return n, true
+		return n, "", true
 	}
-	return 0, false
+	return 0, "", false
 }
 
 // searchResult holds a raw row from the dynamic search query.
 type searchResult struct {
 	issue                 db.Issue
+	spaceKey              string
+	spaceName             string
 	totalCount            int64
 	matchSource           string
 	matchedCommentContent string
@@ -383,7 +417,7 @@ type searchResult struct {
 // It uses LOWER(column) LIKE for case-insensitive matching compatible with pg_bigm 1.2 GIN indexes.
 // Search patterns are lowercased in Go to avoid redundant LOWER() on the pattern side in SQL.
 // LIKE patterns are pre-built in Go (e.g. "%html%") so pg_bigm can extract bigrams from a single parameter value.
-func buildSearchQuery(phrase string, terms []string, queryNum int, hasNum bool, includeClosed bool) (string, []any) {
+func buildSearchQuery(phrase string, terms []string, queryNum int, querySpaceKey string, hasNum bool, includeClosed bool) (string, []any) {
 	// Lowercase in Go so SQL only needs LOWER() on the column side.
 	phrase = strings.ToLower(phrase)
 	for i, t := range terms {
@@ -457,9 +491,19 @@ func buildSearchQuery(phrase string, terms []string, queryNum int, hasNum bool,
 
 	// Number match
 	numParam := ""
+	spaceKeyParam := ""
+	// identifierKeyExpr is the Space key an identifier search ("MUL-123") matches
+	// against. issue.space_id is NOT NULL as of migration 132, so wt.key (the
+	// issue's own Space) is always present via the wt join.
+	identifierKeyExpr := "wt.key"
 	if hasNum {
 		numParam = nextArg(queryNum)
-		whereParts = append(whereParts, fmt.Sprintf("i.number = %s", numParam))
+		if querySpaceKey != "" {
+			spaceKeyParam = nextArg(querySpaceKey)
+			whereParts = append(whereParts, fmt.Sprintf("(i.number = %s AND lower(%s) = lower(%s))", numParam, identifierKeyExpr, spaceKeyParam))
+		} else {
+			whereParts = append(whereParts, fmt.Sprintf("i.number = %s", numParam))
+		}
 	}
 
 	whereClause := "(" + strings.Join(whereParts, " OR ") + ")"
@@ -474,7 +518,11 @@ func buildSearchQuery(phrase string, terms []string, queryNum int, hasNum bool,
 
 	// Tier 0: Identifier exact match
 	if hasNum {
-		rankCases = append(rankCases, fmt.Sprintf("WHEN i.number = %s THEN 0", numParam))
+		if querySpaceKey != "" {
+			rankCases = append(rankCases, fmt.Sprintf("WHEN i.number = %s AND lower(%s) = lower(%s) THEN 0", numParam, identifierKeyExpr, spaceKeyParam))
+		} else {
+			rankCases = append(rankCases, fmt.Sprintf("WHEN i.number = %s THEN 0", numParam))
+		}
 	}
 
 	// Tier 1: Exact title match
@@ -590,14 +638,17 @@ func buildSearchQuery(phrase string, terms []string, queryNum int, hasNum bool,
 	limitParam := nextArg(nil)  // placeholder
 	offsetParam := nextArg(nil) // placeholder
 
-	query := fmt.Sprintf(`SELECT i.id, i.workspace_id, i.title, i.description, i.status, i.priority,
+	query := fmt.Sprintf(`SELECT i.id, i.workspace_id, i.space_id, i.title, i.description, i.status, i.priority,
 		i.assignee_type, i.assignee_id, i.creator_type, i.creator_id,
 		i.parent_issue_id, i.acceptance_criteria, i.context_refs, i.position,
 		i.start_date, i.due_date, i.created_at, i.updated_at, i.number, i.project_id,
+		COALESCE(wt.key, '')::text AS space_key,
+		COALESCE(wt.name, '')::text AS space_name,
 		COUNT(*) OVER() AS total_count,
 		%s AS match_source,
 		%s AS matched_comment_content
 	FROM issue i
+	LEFT JOIN workspace_space wt ON wt.id = i.space_id AND wt.workspace_id = i.workspace_id
 	WHERE i.workspace_id = %s AND %s
 	ORDER BY %s, %s, i.updated_at DESC
 	LIMIT %s OFFSET %s`,
@@ -647,9 +698,9 @@ func (h *Handler) SearchIssues(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	terms := splitSearchTerms(q)
-	queryNum, hasNum := parseQueryNumber(q)
+	queryNum, querySpaceKey, hasNum := parseQueryNumber(q)
 
-	sqlQuery, args := buildSearchQuery(q, terms, queryNum, hasNum, includeClosed)
+	sqlQuery, args := buildSearchQuery(q, terms, queryNum, querySpaceKey, hasNum, includeClosed)
 	// Fill placeholder args: $4 = workspace_id, last two = limit, offset
 	args[3] = wsUUID
 	args[len(args)-2] = limit
@@ -662,6 +713,7 @@ func (h *Handler) SearchIssues(w http.ResponseWriter, r *http.Request) {
 			if err := rows.Scan(
 				&sr.issue.ID,
 				&sr.issue.WorkspaceID,
+				&sr.issue.SpaceID,
 				&sr.issue.Title,
 				&sr.issue.Description,
 				&sr.issue.Status,
@@ -680,6 +732,8 @@ func (h *Handler) SearchIssues(w http.ResponseWriter, r *http.Request) {
 				&sr.issue.UpdatedAt,
 				&sr.issue.Number,
 				&sr.issue.ProjectID,
+				&sr.spaceKey,
+				&sr.spaceName,
 				&sr.totalCount,
 				&sr.matchSource,
 				&sr.matchedCommentContent,
@@ -714,13 +768,20 @@ func (h *Handler) SearchIssues(w http.ResponseWriter, r *http.Request) {
 		total = results[0].totalCount
 	}
 
-	prefix := h.getIssuePrefix(ctx, wsUUID)
 	resp := make([]SearchIssueResponse, len(results))
+	identifiers := issueidentifier.NewResolver(h.Queries)
 	for i, sr := range results {
+		prefix := sr.spaceKey
+		if prefix == "" {
+			prefix = identifiers.PrefixForIssue(ctx, sr.issue)
+		}
 		sir := SearchIssueResponse{
 			IssueResponse: issueToResponse(sr.issue, prefix),
 			MatchSource:   sr.matchSource,
 		}
+		if sr.spaceName != "" {
+			sir.SpaceName = &sr.spaceName
+		}
 		// Always populate comment snippet when a matching comment exists
 		if sr.matchedCommentContent != "" {
 			snippet := extractSnippet(sr.matchedCommentContent, q)
@@ -799,6 +860,14 @@ func (h *Handler) ListIssues(w http.ResponseWriter, r *http.Request) {
 		}
 		projectFilter = id
 	}
+	var spaceFilter pgtype.UUID
+	if t := r.URL.Query().Get("space_id"); t != "" {
+		id, ok := parseUUIDOrBadRequest(w, t, "space_id")
+		if !ok {
+			return
+		}
+		spaceFilter = id
+	}
 	// involves_user_id widens the assignee filter to surface issues where the
 	// user is the indirect assignee (their owned agent, or a squad they belong
 	// to / lead / have an agent inside). Direct member-assignment is excluded
@@ -826,6 +895,7 @@ func (h *Handler) ListIssues(w http.ResponseWriter, r *http.Request) {
 	if r.URL.Query().Get("open_only") == "true" {
 		issues, err := h.Queries.ListOpenIssues(ctx, db.ListOpenIssuesParams{
 			WorkspaceID:    wsUUID,
+			SpaceID:        spaceFilter,
 			Priority:       priorityFilter,
 			AssigneeID:     assigneeFilter,
 			AssigneeIds:    assigneeIdsFilter,
@@ -839,7 +909,7 @@ func (h *Handler) ListIssues(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 
-		prefix := h.getIssuePrefix(ctx, wsUUID)
+		prefix := issueidentifier.PrefixForWorkspace(ctx, h.Queries, wsUUID)
 		ids := make([]pgtype.UUID, len(issues))
 		for i, issue := range issues {
 			ids[i] = issue.ID
@@ -963,6 +1033,9 @@ func (h *Handler) ListIssues(w http.ResponseWriter, r *http.Request) {
 	if projectFilter.Valid {
 		where = append(where, fmt.Sprintf("i.project_id = %s::uuid", addArg(projectFilter)))
 	}
+	if spaceFilter.Valid {
+		where = append(where, fmt.Sprintf("i.space_id = %s::uuid", addArg(spaceFilter)))
+	}
 	if scheduledFilter.Valid {
 		where = append(where, "(i.start_date IS NOT NULL OR i.due_date IS NOT NULL)")
 	}
@@ -1021,10 +1094,12 @@ func (h *Handler) ListIssues(w http.ResponseWriter, r *http.Request) {
 	offsetRef := addArg(int64(offset))
 	limitRef := addArg(int64(limit))
 
-	query := fmt.Sprintf(`SELECT i.id, i.workspace_id, i.title, i.description, i.status, i.priority,
+	query := fmt.Sprintf(`SELECT i.id, i.workspace_id, i.space_id, i.title, i.description, i.status, i.priority,
        i.assignee_type, i.assignee_id, i.creator_type, i.creator_id,
-       i.parent_issue_id, i.position, i.start_date, i.due_date, i.created_at, i.updated_at, i.number, i.project_id, i.metadata
+       i.parent_issue_id, i.position, i.start_date, i.due_date, i.created_at, i.updated_at, i.number, i.project_id, i.metadata,
+       COALESCE(wt.key, '')::text AS space_key, COALESCE(wt.name, '')::text AS space_name
 FROM issue i
+LEFT JOIN workspace_space wt ON wt.id = i.space_id AND wt.workspace_id = i.workspace_id
 WHERE %s
 ORDER BY %s
 LIMIT %s OFFSET %s`, whereSql, orderBy, limitRef, offsetRef)
@@ -1043,6 +1118,7 @@ LIMIT %s OFFSET %s`, whereSql, orderBy, limitRef, offsetRef)
 		if err := rows.Scan(
 			&row.ID,
 			&row.WorkspaceID,
+			&row.SpaceID,
 			&row.Title,
 			&row.Description,
 			&row.Status,
@@ -1060,6 +1136,8 @@ LIMIT %s OFFSET %s`, whereSql, orderBy, limitRef, offsetRef)
 			&row.Number,
 			&row.ProjectID,
 			&row.Metadata,
+			&row.SpaceKey,
+			&row.SpaceName,
 		); err != nil {
 			slog.Warn("ListIssues scan failed", "error", err)
 			writeError(w, http.StatusInternalServerError, "failed to list issues")
@@ -1082,7 +1160,7 @@ LIMIT %s OFFSET %s`, whereSql, orderBy, limitRef, offsetRef)
 		total = int64(len(issues))
 	}
 
-	prefix := h.getIssuePrefix(ctx, wsUUID)
+	prefix := issueidentifier.PrefixForWorkspace(ctx, h.Queries, wsUUID)
 	ids := make([]pgtype.UUID, len(issues))
 	for i, issue := range issues {
 		ids[i] = issue.ID
@@ -1331,6 +1409,22 @@ func (h *Handler) ListGroupedIssues(w http.ResponseWriter, r *http.Request) {
 		}
 		where = append(where, fmt.Sprintf("i.project_id = %s::uuid", addArg(id)))
 	}
+	if raw := r.URL.Query().Get("space_id"); raw != "" {
+		id, ok := parseUUIDOrBadRequest(w, raw, "space_id")
+		if !ok {
+			return
+		}
+		where = append(where, fmt.Sprintf("i.space_id = %s::uuid", addArg(id)))
+	}
+	if raw := r.URL.Query().Get("space_ids"); raw != "" {
+		ids, ok := parseUUIDParamList(w, raw, "space_ids")
+		if !ok {
+			return
+		}
+		if len(ids) > 0 {
+			where = append(where, fmt.Sprintf("i.space_id = ANY(%s::uuid[])", addArg(ids)))
+		}
+	}
 	if filter, ok := parseMetadataFilterParam(w, r.URL.Query().Get("metadata")); !ok {
 		return
 	} else if filter != nil {
@@ -1518,22 +1612,26 @@ func (h *Handler) ListGroupedIssues(w http.ResponseWriter, r *http.Request) {
 WITH ranked AS (
 	SELECT
 		i.id, i.workspace_id, i.title, i.description, i.status, i.priority,
+		i.space_id,
 		i.assignee_type, i.assignee_id, i.creator_type, i.creator_id,
 		i.parent_issue_id, i.position, i.due_date, i.created_at, i.updated_at,
 		i.number, i.project_id, i.metadata,
+		COALESCE(wt.key, '')::text AS space_key,
+		COALESCE(wt.name, '')::text AS space_name,
 		COUNT(*) OVER (PARTITION BY i.assignee_type, i.assignee_id) AS group_total,
 		ROW_NUMBER() OVER (
 			PARTITION BY i.assignee_type, i.assignee_id
 			ORDER BY %s
 		) AS rn
 	FROM issue i
+	LEFT JOIN workspace_space wt ON wt.id = i.space_id AND wt.workspace_id = i.workspace_id
 	WHERE %s
 )
 SELECT
-	id, workspace_id, title, description, status, priority,
+	id, workspace_id, space_id, title, description, status, priority,
 	assignee_type, assignee_id, creator_type, creator_id,
 	parent_issue_id, position, due_date, created_at, updated_at,
-	number, project_id, metadata, group_total
+	number, project_id, metadata, space_key, space_name, group_total
 FROM ranked
 WHERE rn > %s AND rn <= %s + %s
 ORDER BY
@@ -1561,6 +1659,7 @@ ORDER BY
 		if err := rows.Scan(
 			&row.ID,
 			&row.WorkspaceID,
+			&row.SpaceID,
 			&row.Title,
 			&row.Description,
 			&row.Status,
@@ -1577,6 +1676,8 @@ ORDER BY
 			&row.Number,
 			&row.ProjectID,
 			&row.Metadata,
+			&row.SpaceKey,
+			&row.SpaceName,
 			&row.GroupTotal,
 		); err != nil {
 			slog.Warn("ListGroupedIssues scan failed", "error", err)
@@ -1596,7 +1697,7 @@ ORDER BY
 		ids[i] = row.ID
 	}
 	labelsMap := h.labelsByIssue(ctx, wsUUID, ids)
-	prefix := h.getIssuePrefix(ctx, wsUUID)
+	prefix := issueidentifier.PrefixForWorkspace(ctx, h.Queries, wsUUID)
 
 	groups := []IssueAssigneeGroupResponse{}
 	groupIndex := map[string]int{}
@@ -1633,7 +1734,7 @@ func (h *Handler) GetIssue(w http.ResponseWriter, r *http.Request) {
 	if !ok {
 		return
 	}
-	prefix := h.getIssuePrefix(r.Context(), issue.WorkspaceID)
+	prefix := issueidentifier.PrefixForIssue(r.Context(), h.Queries, issue)
 	resp := issueToResponse(issue, prefix)
 	detailLabels := h.labelsByIssue(r.Context(), issue.WorkspaceID, []pgtype.UUID{issue.ID})[uuidToString(issue.ID)]
 	if detailLabels == nil {
@@ -1676,10 +1777,10 @@ func (h *Handler) ListChildIssues(w http.ResponseWriter, r *http.Request) {
 		writeError(w, http.StatusInternalServerError, "failed to list child issues")
 		return
 	}
-	prefix := h.getIssuePrefix(r.Context(), issue.WorkspaceID)
 	resp := make([]IssueResponse, len(children))
+	identifiers := issueidentifier.NewResolver(h.Queries)
 	for i, child := range children {
-		resp[i] = issueToResponse(child, prefix)
+		resp[i] = issueToResponse(child, identifiers.PrefixForIssue(r.Context(), child))
 	}
 	writeJSON(w, http.StatusOK, map[string]any{
 		"issues": resp,
@@ -1745,10 +1846,10 @@ func (h *Handler) ListChildrenByParents(w http.ResponseWriter, r *http.Request)
 		writeError(w, http.StatusInternalServerError, "failed to list child issues")
 		return
 	}
-	prefix := h.getIssuePrefix(r.Context(), wsUUID)
 	resp := make([]IssueResponse, len(children))
+	identifiers := issueidentifier.NewResolver(h.Queries)
 	for i, child := range children {
-		resp[i] = issueToResponse(child, prefix)
+		resp[i] = issueToResponse(child, identifiers.PrefixForIssue(r.Context(), child))
 	}
 	writeJSON(w, http.StatusOK, map[string]any{
 		"issues": resp,
@@ -1813,6 +1914,7 @@ type QuickCreateIssueRequest struct {
 	AgentID       string   `json:"agent_id,omitempty"`
 	SquadID       string   `json:"squad_id,omitempty"`
 	Prompt        string   `json:"prompt"`
+	SpaceID       string   `json:"space_id,omitempty"`
 	ProjectID     string   `json:"project_id,omitempty"`
 	ParentIssueID string   `json:"parent_issue_id,omitempty"`
 	AttachmentIDs []string `json:"attachment_ids,omitempty"`
@@ -1973,6 +2075,7 @@ func (h *Handler) QuickCreateIssue(w http.ResponseWriter, r *http.Request) {
 	// issue" entry, but the handler re-checks so a forged request can't
 	// smuggle a foreign parent UUID through.
 	var parentIssueUUID pgtype.UUID
+	var parentIssue db.Issue
 	if strings.TrimSpace(req.ParentIssueID) != "" {
 		pid, ok := parseUUIDOrBadRequest(w, req.ParentIssueID, "parent_issue_id")
 		if !ok {
@@ -1986,10 +2089,34 @@ func (h *Handler) QuickCreateIssue(w http.ResponseWriter, r *http.Request) {
 			writeError(w, http.StatusBadRequest, "parent issue not found in this workspace")
 			return
 		}
+		parentIssue = parent
 		parentIssueUUID = pid
 	}
 
-	task, err := h.TaskService.EnqueueQuickCreateTask(r.Context(), wsUUID, requesterUUID, agentUUID, squadUUID, prompt, projectUUID, parentIssueUUID, attachmentIDs)
+	var requestedSpaceUUID pgtype.UUID
+	if strings.TrimSpace(req.SpaceID) != "" {
+		tid, ok := parseUUIDOrBadRequest(w, req.SpaceID, "space_id")
+		if !ok {
+			return
+		}
+		requestedSpaceUUID = tid
+	}
+	// A sub-issue seeds its Space from the parent when the caller didn't pick
+	// one — a creation-time default, not a constraint; an explicit space_id
+	// always wins and parent/child may diverge afterwards.
+	spaceUUID := requestedSpaceUUID
+	if !spaceUUID.Valid && parentIssueUUID.Valid && parentIssue.SpaceID.Valid {
+		spaceUUID = parentIssue.SpaceID
+	}
+	space, err := service.ResolveSpace(r.Context(), h.Queries, wsUUID, spaceUUID, projectUUID)
+	if err != nil {
+		if !writeSpaceResolveError(w, err) {
+			writeError(w, http.StatusBadRequest, err.Error())
+		}
+		return
+	}
+
+	task, err := h.TaskService.EnqueueQuickCreateTask(r.Context(), wsUUID, requesterUUID, agentUUID, squadUUID, prompt, projectUUID, parentIssueUUID, space.ID, attachmentIDs)
 	if err != nil {
 		slog.Warn("quick-create enqueue failed", append(logger.RequestAttrs(r), "error", err)...)
 		writeError(w, http.StatusInternalServerError, "failed to enqueue quick-create task")
@@ -2090,6 +2217,7 @@ func readRuntimeCLIVersion(metadata []byte) string {
 type CreateIssueRequest struct {
 	Title         string   `json:"title"`
 	Description   *string  `json:"description"`
+	SpaceID       *string  `json:"space_id"`
 	Status        string   `json:"status"`
 	Priority      string   `json:"priority"`
 	AssigneeType  *string  `json:"assignee_type"`
@@ -2178,6 +2306,14 @@ func (h *Handler) CreateIssue(w http.ResponseWriter, r *http.Request) {
 
 	var parentIssueID pgtype.UUID
 	var projectID pgtype.UUID
+	var spaceID pgtype.UUID
+	if req.SpaceID != nil {
+		id, ok := parseUUIDOrBadRequest(w, *req.SpaceID, "space_id")
+		if !ok {
+			return
+		}
+		spaceID = id
+	}
 	if req.ProjectID != nil {
 		id, ok := parseUUIDOrBadRequest(w, *req.ProjectID, "project_id")
 		if !ok {
@@ -2251,10 +2387,6 @@ func (h *Handler) CreateIssue(w http.ResponseWriter, r *http.Request) {
 		originID = oid
 	}
 
-	// Prefix is workspace-level; pre-compute once so both the broadcast
-	// payload builder and the HTTP response share the same value.
-	prefix := h.getIssuePrefix(r.Context(), wsUUID)
-
 	// Analytics agent ID: assignee agent when the issue is being assigned
 	// to an agent, otherwise the creator agent for agent-authored issues.
 	// Resolved here (not in the service) because creator identity is HTTP-side.
@@ -2279,6 +2411,7 @@ func (h *Handler) CreateIssue(w http.ResponseWriter, r *http.Request) {
 
 	res, err := h.IssueService.Create(r.Context(), service.IssueCreateParams{
 		WorkspaceID:    wsUUID,
+		SpaceID:        spaceID,
 		Title:          req.Title,
 		Description:    ptrToText(req.Description),
 		Status:         status,
@@ -2300,8 +2433,8 @@ func (h *Handler) CreateIssue(w http.ResponseWriter, r *http.Request) {
 		ActorID:          actualCreatorID,
 		AnalyticsAgentID: analyticsAgentID,
 		Platform:         func() string { p, _, _ := middleware.ClientMetadataFromContext(r.Context()); return p }(),
-		BroadcastPayload: func(issue db.Issue, atts []db.Attachment) map[string]any {
-			payload := issueToResponse(issue, prefix)
+		BroadcastPayload: func(issue db.Issue, atts []db.Attachment, spaceKey string) map[string]any {
+			payload := issueToResponse(issue, spaceKey)
 			payload.Attachments = buildAttachmentResponses(atts)
 			return map[string]any{"issue": payload}
 		},
@@ -2309,7 +2442,7 @@ func (h *Handler) CreateIssue(w http.ResponseWriter, r *http.Request) {
 
 	if errors.Is(err, service.ErrActiveDuplicate) {
 		dup := *res.DuplicateIssue
-		existing := issueToResponse(dup, h.getIssuePrefix(r.Context(), dup.WorkspaceID))
+		existing := issueToResponse(dup, issueidentifier.PrefixForIssue(r.Context(), h.Queries, dup))
 		writeJSON(w, http.StatusConflict, map[string]any{
 			"code":  "active_duplicate_issue",
 			"error": duplicateIssueMessage(existing),
@@ -2325,6 +2458,9 @@ func (h *Handler) CreateIssue(w http.ResponseWriter, r *http.Request) {
 		writeError(w, http.StatusBadRequest, "project not found in this workspace")
 		return
 	}
+	if writeSpaceResolveError(w, err) {
+		return
+	}
 	if err != nil {
 		slog.Warn("create issue failed", append(logger.RequestAttrs(r), "error", err, "workspace_id", workspaceID)...)
 		writeError(w, http.StatusInternalServerError, "failed to create issue: "+err.Error())
@@ -2334,7 +2470,7 @@ func (h *Handler) CreateIssue(w http.ResponseWriter, r *http.Request) {
 	issue := res.Issue
 	slog.Info("issue created", append(logger.RequestAttrs(r), "issue_id", uuidToString(issue.ID), "title", issue.Title, "status", issue.Status, "workspace_id", workspaceID)...)
 
-	resp := issueToResponse(issue, prefix)
+	resp := issueToResponse(issue, res.SpaceKey)
 	resp.Attachments = buildAttachmentResponses(res.Attachments)
 	writeJSON(w, http.StatusCreated, resp)
 }
@@ -2351,7 +2487,10 @@ type UpdateIssueRequest struct {
 	DueDate       *string  `json:"due_date"`
 	ParentIssueID *string  `json:"parent_issue_id"`
 	ProjectID     *string  `json:"project_id"`
-	Stage         *int32   `json:"stage"`
+	// SpaceID moves the issue to another space. Numbers are per-space, so the
+	// move renumbers the issue and records the old identifier as an alias.
+	SpaceID *string `json:"space_id"`
+	Stage   *int32  `json:"stage"`
 	// AttachmentIDs lets the description editor bind newly uploaded files to
 	// this issue so they surface in `GET /api/issues/:id/attachments` and the
 	// editor's preview Eye keeps working past a refresh. Existing bindings
@@ -2486,7 +2625,8 @@ func (h *Handler) UpdateIssue(w http.ResponseWriter, r *http.Request) {
 				writeError(w, http.StatusBadRequest, "an issue cannot be its own parent")
 				return
 			}
-			// Validate parent exists in the same workspace.
+			// Validate parent exists in the same workspace. Cross-space
+			// parent/child is allowed — space only binds at creation time.
 			if _, err := h.Queries.GetIssueInWorkspace(r.Context(), db.GetIssueInWorkspaceParams{
 				ID:          newParentID,
 				WorkspaceID: prevIssue.WorkspaceID,
@@ -2512,15 +2652,27 @@ func (h *Handler) UpdateIssue(w http.ResponseWriter, r *http.Request) {
 			params.ParentIssueID = pgtype.UUID{Valid: false} // explicit null = remove parent
 		}
 	}
+	finalProjectID := prevIssue.ProjectID
+	projectTouched := false
 	if _, ok := rawFields["project_id"]; ok {
+		projectTouched = true
 		if req.ProjectID != nil {
 			projectUUID, ok := parseUUIDOrBadRequest(w, *req.ProjectID, "project_id")
 			if !ok {
 				return
 			}
+			if _, err := h.Queries.GetProjectInWorkspace(r.Context(), db.GetProjectInWorkspaceParams{
+				ID:          projectUUID,
+				WorkspaceID: prevIssue.WorkspaceID,
+			}); err != nil {
+				writeError(w, http.StatusBadRequest, "project not found in this workspace")
+				return
+			}
 			params.ProjectID = projectUUID
+			finalProjectID = projectUUID
 		} else {
 			params.ProjectID = pgtype.UUID{Valid: false}
+			finalProjectID = pgtype.UUID{Valid: false}
 		}
 	}
 	if _, ok := rawFields["stage"]; ok {
@@ -2552,18 +2704,121 @@ func (h *Handler) UpdateIssue(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	issue, err := h.Queries.UpdateIssue(r.Context(), params)
-	if err != nil {
-		slog.Warn("update issue failed", append(logger.RequestAttrs(r), "error", err, "issue_id", id, "workspace_id", workspaceID)...)
-		writeError(w, http.StatusInternalServerError, "failed to update issue: "+err.Error())
-		return
+	// space_id — moving an issue between spaces renumbers it (numbers are
+	// per-space). Runs in its own tx before the field update: allocate the
+	// next number in the destination space, take a fresh top position in the
+	// destination column, and record the old identifier as an alias so
+	// external references (CLI/API lookups, GitHub branch/PR auto-linking)
+	// keep resolving. Everything else (project, parent, labels) is left
+	// untouched — those associations only bind at creation time.
+	spaceChanged := false
+	finalSpaceID := prevIssue.SpaceID
+	if _, ok := rawFields["space_id"]; ok {
+		if req.SpaceID == nil {
+			writeError(w, http.StatusBadRequest, "space_id cannot be null")
+			return
+		}
+		newSpaceID, ok := parseUUIDOrBadRequest(w, *req.SpaceID, "space_id")
+		if !ok {
+			return
+		}
+		finalSpaceID = newSpaceID
+		if newSpaceID != prevIssue.SpaceID {
+			if _, err := service.ValidateActiveSpace(r.Context(), h.Queries, prevIssue.WorkspaceID, newSpaceID); err != nil {
+				if !writeSpaceResolveError(w, err) {
+					writeError(w, http.StatusBadRequest, err.Error())
+				}
+				return
+			}
+			spaceChanged = true
+		}
+	}
+
+	var issue db.Issue
+	if projectTouched || spaceChanged {
+		tx, err := h.TxStarter.Begin(r.Context())
+		if err != nil {
+			writeError(w, http.StatusInternalServerError, "failed to update issue")
+			return
+		}
+		defer tx.Rollback(r.Context())
+		qtx := h.Queries.WithTx(tx)
+
+		if spaceChanged {
+			newNumber, err := qtx.IncrementSpaceIssueCounter(r.Context(), db.IncrementSpaceIssueCounterParams{
+				ID:          finalSpaceID,
+				WorkspaceID: prevIssue.WorkspaceID,
+			})
+			if err != nil {
+				writeError(w, http.StatusInternalServerError, "failed to allocate issue number")
+				return
+			}
+			newPosition, err := issueposition.NextTopPositionForSpace(r.Context(), tx, prevIssue.WorkspaceID, finalSpaceID, prevIssue.Status)
+			if err != nil {
+				writeError(w, http.StatusInternalServerError, "failed to position issue")
+				return
+			}
+			if _, err := qtx.MoveIssueToSpace(r.Context(), db.MoveIssueToSpaceParams{
+				ID:       prevIssue.ID,
+				SpaceID:  finalSpaceID,
+				Number:   newNumber,
+				Position: newPosition,
+			}); err != nil {
+				writeError(w, http.StatusInternalServerError, "failed to move issue to space")
+				return
+			}
+			// Preserve the pre-move identifier so it keeps resolving.
+			if prevIssue.SpaceID.Valid {
+				oldSpace, err := qtx.GetWorkspaceSpace(r.Context(), db.GetWorkspaceSpaceParams{
+					ID:          prevIssue.SpaceID,
+					WorkspaceID: prevIssue.WorkspaceID,
+				})
+				if err == nil && oldSpace.Key != "" {
+					if err := qtx.UpsertIssueIdentifierAlias(r.Context(), db.UpsertIssueIdentifierAliasParams{
+						WorkspaceID:   prevIssue.WorkspaceID,
+						SpaceKeyLower: strings.ToLower(oldSpace.Key),
+						Number:        prevIssue.Number,
+						IssueID:       prevIssue.ID,
+					}); err != nil {
+						writeError(w, http.StatusInternalServerError, "failed to record identifier alias")
+						return
+					}
+				}
+			}
+		}
+
+		issue, err = qtx.UpdateIssue(r.Context(), params)
+		if err != nil {
+			slog.Warn("update issue failed", append(logger.RequestAttrs(r), "error", err, "issue_id", id, "workspace_id", workspaceID)...)
+			writeError(w, http.StatusInternalServerError, "failed to update issue: "+err.Error())
+			return
+		}
+		// Ensure exactly the final issue/project pair is represented. For combined
+		// project+space patches this avoids adding old-space→new-project or
+		// new-space→old-project associations.
+		if err := service.EnsureProjectHasSpace(r.Context(), qtx, prevIssue.WorkspaceID, finalProjectID, finalSpaceID); err != nil {
+			writeError(w, http.StatusInternalServerError, "failed to update project spaces")
+			return
+		}
+		if err := tx.Commit(r.Context()); err != nil {
+			writeError(w, http.StatusInternalServerError, "failed to update issue")
+			return
+		}
+	} else {
+		var err error
+		issue, err = h.Queries.UpdateIssue(r.Context(), params)
+		if err != nil {
+			slog.Warn("update issue failed", append(logger.RequestAttrs(r), "error", err, "issue_id", id, "workspace_id", workspaceID)...)
+			writeError(w, http.StatusInternalServerError, "failed to update issue: "+err.Error())
+			return
+		}
 	}
 
 	if len(attachmentIDs) > 0 {
 		h.linkAttachmentsByIssueIDs(r.Context(), issue.ID, issue.WorkspaceID, attachmentIDs)
 	}
 
-	prefix := h.getIssuePrefix(r.Context(), issue.WorkspaceID)
+	prefix := issueidentifier.PrefixForIssue(r.Context(), h.Queries, issue)
 	resp := issueToResponse(issue, prefix)
 	slog.Info("issue updated", append(logger.RequestAttrs(r), "issue_id", id, "workspace_id", workspaceID)...)
 
@@ -2594,6 +2849,8 @@ func (h *Handler) UpdateIssue(w http.ResponseWriter, r *http.Request) {
 		"status_changed":      statusChanged,
 		"priority_changed":    priorityChanged,
 		"project_changed":     projectChanged,
+		"space_changed":       spaceChanged,
+		"prev_space_id":       uuidToPtr(prevIssue.SpaceID),
 		"start_date_changed":  startDateChanged,
 		"due_date_changed":    dueDateChanged,
 		"description_changed": descriptionChanged,
@@ -2944,6 +3201,7 @@ func (h *Handler) BatchUpdateIssues(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	updated := 0
+	identifiers := issueidentifier.NewResolver(h.Queries)
 	for _, issueID := range req.IssueIDs {
 		issueUUID, err := util.ParseUUID(issueID)
 		if err != nil {
@@ -3101,7 +3359,7 @@ func (h *Handler) BatchUpdateIssues(w http.ResponseWriter, r *http.Request) {
 			continue
 		}
 
-		prefix := h.getIssuePrefix(r.Context(), issue.WorkspaceID)
+		prefix := identifiers.PrefixForIssue(r.Context(), issue)
 		resp := issueToResponse(issue, prefix)
 		actorType, actorID := h.resolveActor(r, userID, workspaceID)
 
diff --git a/server/internal/handler/issue_assignee_types_test.go b/server/internal/handler/issue_assignee_types_test.go
index 760336a485..7d3b3c4836 100644
--- a/server/internal/handler/issue_assignee_types_test.go
+++ b/server/internal/handler/issue_assignee_types_test.go
@@ -52,8 +52,8 @@ func TestListIssues_AssigneeTypesFilter(t *testing.T) {
 		}
 		var id string
 		if err := testPool.QueryRow(ctx, `
-			INSERT INTO issue (workspace_id, title, status, priority, assignee_type, assignee_id, creator_type, creator_id, position, number, project_id)
-			VALUES ($1, $2, 'todo', 'none', $3, $4, 'member', $5, 0, $6, $7) RETURNING id
+			INSERT INTO issue (workspace_id, title, status, priority, assignee_type, assignee_id, creator_type, creator_id, position, number, project_id, space_id)
+			VALUES ($1, $2, 'todo', 'none', $3, $4, 'member', $5, 0, $6, $7, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1)) RETURNING id
 		`, testWorkspaceID, title, assigneeType, assigneeID, testUserID, number, projectID).Scan(&id); err != nil {
 			t.Fatalf("create issue %q: %v", title, err)
 		}
diff --git a/server/internal/handler/issue_child_done.go b/server/internal/handler/issue_child_done.go
index d41fd5bd57..0281cad7e6 100644
--- a/server/internal/handler/issue_child_done.go
+++ b/server/internal/handler/issue_child_done.go
@@ -9,6 +9,7 @@ import (
 	"strings"
 
 	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/multica-ai/multica/server/internal/issueidentifier"
 	db "github.com/multica-ai/multica/server/pkg/db/generated"
 	"github.com/multica-ai/multica/server/pkg/protocol"
 )
@@ -126,7 +127,7 @@ func (h *Handler) notifyParentOfChildDone(ctx context.Context, prev, issue db.Is
 	}
 	staged := siblingsAreStaged(children)
 
-	prefix := h.getIssuePrefix(ctx, issue.WorkspaceID)
+	prefix := issueidentifier.PrefixForIssue(ctx, h.Queries, issue)
 	identifier := prefix + "-" + strconv.Itoa(int(issue.Number))
 	childID := uuidToString(issue.ID)
 	title := sanitizeChildTitleForSystemComment(issue.Title)
diff --git a/server/internal/handler/issue_children_for_parents_test.go b/server/internal/handler/issue_children_for_parents_test.go
index ed702110ee..2ebd8f5e58 100644
--- a/server/internal/handler/issue_children_for_parents_test.go
+++ b/server/internal/handler/issue_children_for_parents_test.go
@@ -188,17 +188,26 @@ func TestListChildrenByParents_IgnoresForeignWorkspaceParents(t *testing.T) {
 			`DELETE FROM workspace WHERE id = $1`, foreignWorkspaceID)
 	})
 
+	// The foreign workspace needs its own default Space to satisfy the NOT NULL
+	// space_id constraint on the issues seeded below.
+	if _, err := testPool.Exec(ctx, `
+		INSERT INTO workspace_space (workspace_id, name, key, created_by)
+		VALUES ($1, 'Default', 'FCW', $2)
+	`, foreignWorkspaceID, testUserID); err != nil {
+		t.Fatalf("setup: seed foreign default space: %v", err)
+	}
+
 	var foreignParentID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, number, title, status, position, creator_type, creator_id)
-		VALUES ($1, 1, 'foreign parent', 'todo', 1, 'member', $2)
+		INSERT INTO issue (workspace_id, number, title, status, position, creator_type, creator_id, space_id)
+		VALUES ($1, 1, 'foreign parent', 'todo', 1, 'member', $2, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, foreignWorkspaceID, testUserID).Scan(&foreignParentID); err != nil {
 		t.Fatalf("setup: insert foreign parent: %v", err)
 	}
 	if _, err := testPool.Exec(ctx, `
-		INSERT INTO issue (workspace_id, number, title, status, position, parent_issue_id, creator_type, creator_id)
-		VALUES ($1, 2, 'foreign child', 'todo', 2, $2, 'member', $3)
+		INSERT INTO issue (workspace_id, number, title, status, position, parent_issue_id, creator_type, creator_id, space_id)
+		VALUES ($1, 2, 'foreign child', 'todo', 2, $2, 'member', $3, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 	`, foreignWorkspaceID, foreignParentID, testUserID); err != nil {
 		t.Fatalf("setup: insert foreign child: %v", err)
 	}
@@ -246,8 +255,8 @@ func createChildIssue(t *testing.T, title, status, parentID string) IssueRespons
 // newScrambledChildren creates a parent plus four children whose issue numbers
 // ascend in creation order while their position values are set in the opposite
 // order and their statuses are mixed. This reproduces the real-world layout:
-// NextTopPosition assigns MIN(position)-1 per (workspace, status), so newer
-// children get ever-smaller positions and different statuses draw from
+// NextTopPositionForSpace assigns MIN(position)-1 per (workspace, space, status),
+// so newer children get ever-smaller positions and different statuses draw from
 // different pools. A position-ordered query would interleave them; only a
 // number-ordered query returns them in creation order. Returns the parent and
 // the children in creation order (ascending number).
diff --git a/server/internal/handler/issue_grouped_test.go b/server/internal/handler/issue_grouped_test.go
index 73d8246596..2c43e5a9d2 100644
--- a/server/internal/handler/issue_grouped_test.go
+++ b/server/internal/handler/issue_grouped_test.go
@@ -68,9 +68,10 @@ func TestListGroupedIssuesAssigneePaginatesPerGroup(t *testing.T) {
 			INSERT INTO issue (
 				workspace_id, title, description, status, priority,
 				assignee_type, assignee_id, creator_type, creator_id,
-				position, number
+				position, number, space_id
 			)
-			VALUES ($1, $2, NULL, 'todo', 'none', $3, $4, 'member', $5, $6, $7)
+			VALUES ($1, $2, NULL, 'todo', 'none', $3, $4, 'member', $5, $6, $7,
+				(SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 			RETURNING id
 		`, testWorkspaceID, title, assigneeType, assigneeID, testUserID, position, number).Scan(&id); err != nil {
 			t.Fatalf("create issue %q: %v", title, err)
@@ -154,3 +155,97 @@ func TestListGroupedIssuesAssigneePaginatesPerGroup(t *testing.T) {
 		t.Fatalf("unexpected next-page issue: %#v", nextResp.Groups[0].Issues[0])
 	}
 }
+
+func TestListGroupedIssuesFiltersBySpace(t *testing.T) {
+	ctx := context.Background()
+	suffix := time.Now().UnixNano() % 1_000_000
+	keyA := fmt.Sprintf("A%06d", suffix)
+	keyB := fmt.Sprintf("B%06d", suffix)
+
+	var workspaceID string
+	if err := testPool.QueryRow(ctx, `
+		INSERT INTO workspace (name, slug, description, issue_prefix)
+		VALUES ($1, $2, '', $3)
+		RETURNING id
+	`, "Grouped Space Filter", fmt.Sprintf("grouped-space-filter-%d", suffix), keyA).Scan(&workspaceID); err != nil {
+		t.Fatalf("create workspace: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = testPool.Exec(context.Background(), `DELETE FROM workspace WHERE id = $1`, workspaceID)
+	})
+
+	var spaceA, spaceB string
+	if err := testPool.QueryRow(ctx, `
+		INSERT INTO workspace_space (workspace_id, name, key)
+		VALUES ($1, 'Space A', $2)
+		RETURNING id
+	`, workspaceID, keyA).Scan(&spaceA); err != nil {
+		t.Fatalf("create space A: %v", err)
+	}
+	if err := testPool.QueryRow(ctx, `
+		INSERT INTO workspace_space (workspace_id, name, key)
+		VALUES ($1, 'Space B', $2)
+		RETURNING id
+	`, workspaceID, keyB).Scan(&spaceB); err != nil {
+		t.Fatalf("create space B: %v", err)
+	}
+
+	createIssue := func(title, spaceID string, position float64) {
+		t.Helper()
+		var number int32
+		if err := testPool.QueryRow(ctx, `
+			UPDATE workspace
+			SET issue_counter = issue_counter + 1
+			WHERE id = $1
+			RETURNING issue_counter
+		`, workspaceID).Scan(&number); err != nil {
+			t.Fatalf("next issue number: %v", err)
+		}
+		if _, err := testPool.Exec(ctx, `
+			INSERT INTO issue (
+				workspace_id, space_id, title, description, status, priority,
+				assignee_type, assignee_id, creator_type, creator_id,
+				position, number
+			)
+			VALUES ($1, $2, $3, NULL, 'todo', 'none', 'member', $4, 'member', $4, $5, $6)
+		`, workspaceID, spaceID, title, testUserID, position, number); err != nil {
+			t.Fatalf("create issue %q: %v", title, err)
+		}
+	}
+
+	createIssue("Space A first", spaceA, 1)
+	createIssue("Space A second", spaceA, 2)
+	createIssue("Space B hidden", spaceB, 3)
+
+	path := fmt.Sprintf(
+		"/api/issues/grouped?workspace_id=%s&group_by=assignee&statuses=todo&space_id=%s&limit=10",
+		workspaceID,
+		spaceA,
+	)
+	w := httptest.NewRecorder()
+	req := newRequest("GET", path, nil)
+	req.Header.Set("X-Workspace-ID", workspaceID)
+	testHandler.ListGroupedIssues(w, req)
+	if w.Code != http.StatusOK {
+		t.Fatalf("ListGroupedIssues: expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+
+	var resp GroupedIssuesResponse
+	if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
+		t.Fatalf("decode grouped response: %v", err)
+	}
+	if len(resp.Groups) != 1 {
+		t.Fatalf("expected one assignee group, got %#v", resp.Groups)
+	}
+	if resp.Groups[0].Total != 2 || len(resp.Groups[0].Issues) != 2 {
+		t.Fatalf("expected only Space A issues, total=%d len=%d", resp.Groups[0].Total, len(resp.Groups[0].Issues))
+	}
+	for _, issue := range resp.Groups[0].Issues {
+		if issue.SpaceID == nil || *issue.SpaceID != spaceA {
+			t.Fatalf("grouped space filter leaked wrong space issue: %#v", issue)
+		}
+		if issue.Title == "Space B hidden" {
+			t.Fatalf("grouped space filter leaked Space B issue: %#v", issue)
+		}
+	}
+}
diff --git a/server/internal/handler/issue_involves_test.go b/server/internal/handler/issue_involves_test.go
index 9ee56cdcdc..5abd77d27b 100644
--- a/server/internal/handler/issue_involves_test.go
+++ b/server/internal/handler/issue_involves_test.go
@@ -109,6 +109,15 @@ func setupInvolvesFixture(t *testing.T) *involvesFixture {
 	t.Cleanup(func() { testPool.Exec(context.Background(), `DELETE FROM workspace WHERE id = $1`, otherWsID) })
 	fx.otherWsID = otherWsID
 
+	// The other workspace needs its own default Space to satisfy the NOT NULL
+	// space_id constraint, mirroring how production backfills one per workspace.
+	if _, err := testPool.Exec(ctx, `
+		INSERT INTO workspace_space (workspace_id, name, key, created_by)
+		VALUES ($1, 'Default', 'OTH', $2)
+	`, otherWsID, fx.userID); err != nil {
+		t.Fatalf("create other-ws default space: %v", err)
+	}
+
 	// Membership in other workspace (so the user could legitimately be assigned
 	// there too — exercises whether subquery workspace_id clause filters it out).
 	if _, err := testPool.Exec(ctx, `
@@ -212,9 +221,10 @@ func insertIssueTo(t *testing.T, ctx context.Context, workspaceID, title, assign
 		INSERT INTO issue (
 			workspace_id, title, description, status, priority,
 			assignee_type, assignee_id, creator_type, creator_id,
-			position, number
+			position, number, space_id
 		)
-		VALUES ($1, $2, NULL, 'todo', 'none', $3, $4, 'member', $5, 0, $6)
+		VALUES ($1, $2, NULL, 'todo', 'none', $3, $4, 'member', $5, 0, $6,
+			(SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, workspaceID, title, assigneeType, assigneeID, testUserID, number).Scan(&id); err != nil {
 		t.Fatalf("create issue %q: %v", title, err)
diff --git a/server/internal/handler/issue_limit_validation_test.go b/server/internal/handler/issue_limit_validation_test.go
index 7f72089b4a..69a68d5017 100644
--- a/server/internal/handler/issue_limit_validation_test.go
+++ b/server/internal/handler/issue_limit_validation_test.go
@@ -51,8 +51,8 @@ func TestListIssues_LimitValidation(t *testing.T) {
 		}
 		var id string
 		if err := testPool.QueryRow(ctx, `
-			INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, position, number, project_id)
-			VALUES ($1, $2, 'todo', 'none', 'member', $3, 0, $4, $5) RETURNING id
+			INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, position, number, project_id, space_id)
+			VALUES ($1, $2, 'todo', 'none', 'member', $3, 0, $4, $5, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1)) RETURNING id
 		`, testWorkspaceID, title, testUserID, number, projectID).Scan(&id); err != nil {
 			t.Fatalf("create issue %q: %v", title, err)
 		}
@@ -176,8 +176,8 @@ func TestListIssues_LimitClamp(t *testing.T) {
 			t.Fatalf("next issue number: %v", err)
 		}
 		if _, err := testPool.Exec(ctx, `
-			INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, position, number, project_id)
-			VALUES ($1, $2, 'todo', 'none', 'member', $3, 0, $4, $5)
+			INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, position, number, project_id, space_id)
+			VALUES ($1, $2, 'todo', 'none', 'member', $3, 0, $4, $5, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		`, testWorkspaceID, title, testUserID, number, projectID); err != nil {
 			t.Fatalf("create issue #%d: %v", idx, err)
 		}
diff --git a/server/internal/handler/issue_reassign_no_cancel_test.go b/server/internal/handler/issue_reassign_no_cancel_test.go
index f22964cbe6..935388348c 100644
--- a/server/internal/handler/issue_reassign_no_cancel_test.go
+++ b/server/internal/handler/issue_reassign_no_cancel_test.go
@@ -29,8 +29,8 @@ func insertAgentAssignedIssue(t *testing.T, agentID string, number int, title st
 	t.Helper()
 	var issueID string
 	if err := testPool.QueryRow(context.Background(), `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position, assignee_type, assignee_id)
-		VALUES ($1, $2, 'todo', 'medium', $3, 'member', $4, 0, 'agent', $5)
+		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position, assignee_type, assignee_id, space_id)
+		VALUES ($1, $2, 'todo', 'medium', $3, 'member', $4, 0, 'agent', $5, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, title, testUserID, number, agentID).Scan(&issueID); err != nil {
 		t.Fatalf("insert issue: %v", err)
diff --git a/server/internal/handler/issue_scheduled_test.go b/server/internal/handler/issue_scheduled_test.go
index c58ffec37e..cf4c186435 100644
--- a/server/internal/handler/issue_scheduled_test.go
+++ b/server/internal/handler/issue_scheduled_test.go
@@ -39,8 +39,8 @@ func TestListIssues_ScheduledFilter(t *testing.T) {
 		}
 		var id string
 		if err := testPool.QueryRow(ctx, `
-			INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, position, number, project_id, start_date, due_date)
-			VALUES ($1, $2, 'todo', 'none', 'member', $3, 0, $4, $5, $6, $7) RETURNING id
+			INSERT INTO issue (workspace_id, title, status, priority, creator_type, creator_id, position, number, project_id, start_date, due_date, space_id)
+			VALUES ($1, $2, 'todo', 'none', 'member', $3, 0, $4, $5, $6, $7, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1)) RETURNING id
 		`, testWorkspaceID, title, testUserID, number, projectID, startDate, dueDate).Scan(&id); err != nil {
 			t.Fatalf("create issue %q: %v", title, err)
 		}
diff --git a/server/internal/handler/mention_self_trigger_test.go b/server/internal/handler/mention_self_trigger_test.go
index d31fd63a11..1ee667b195 100644
--- a/server/internal/handler/mention_self_trigger_test.go
+++ b/server/internal/handler/mention_self_trigger_test.go
@@ -72,8 +72,9 @@ func newSelfMentionFixture(t *testing.T) selfMentionFixture {
 		}
 		var id string
 		if err := testPool.QueryRow(ctx, `
-			INSERT INTO issue (workspace_id, creator_type, creator_id, title, assignee_type, assignee_id, number)
-			VALUES ($1, 'member', $2, $3, 'agent', $4, $5)
+			INSERT INTO issue (workspace_id, creator_type, creator_id, title, assignee_type, assignee_id, number, space_id)
+			VALUES ($1, 'member', $2, $3, 'agent', $4, $5,
+			        (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 			RETURNING id
 		`, testWorkspaceID, testUserID, title, jID, number).Scan(&id); err != nil {
 			t.Fatalf("create issue %q: %v", title, err)
diff --git a/server/internal/handler/onboarding_shim.go b/server/internal/handler/onboarding_shim.go
index f460cc6b57..0e92d8d72b 100644
--- a/server/internal/handler/onboarding_shim.go
+++ b/server/internal/handler/onboarding_shim.go
@@ -32,6 +32,7 @@ import (
 
 	"github.com/multica-ai/multica/server/internal/analytics"
 	"github.com/multica-ai/multica/server/internal/issueguard"
+	"github.com/multica-ai/multica/server/internal/issueidentifier"
 	"github.com/multica-ai/multica/server/internal/logger"
 	obsmetrics "github.com/multica-ai/multica/server/internal/metrics"
 	"github.com/multica-ai/multica/server/internal/middleware"
@@ -75,7 +76,7 @@ const onboardingAssistantInstructions = `You are Multica Helper, the built-in AI
 
 ## What Multica is
 
-Multica is an open-source, AI-native team workspace (source: https://github.com/multica-ai/multica). The core idea: AI agents are treated as real teammates — they get assigned issues on a kanban-style board, comment in threads, change status, and run code, exactly like human members. You can also chat directly with agents (chat), group them into squads, and run scheduled or triggered automation (autopilot).
+Multica is an open-source, AI-native space workspace (source: https://github.com/multica-ai/multica). The core idea: AI agents are treated as real spacemates — they get assigned issues on a kanban-style board, comment in threads, change status, and run code, exactly like human members. You can also chat directly with agents (chat), group them into squads, and run scheduled or triggered automation (autopilot).
 
 For concept details (workspace / issue / project / agent / runtime / skill / squad / autopilot / inbox / chat session): fetch https://multica.ai/docs via WebFetch — that's authoritative. For the "why" or implementation, fetch the GitHub repo above. Never paraphrase concepts from memory.
 
@@ -103,7 +104,7 @@ This is your guided first run. Multica Helper is assigned to this issue and will
 1. Read Multica Helper's first comment.
 2. Reply with something you want to build, fix, write, or plan.
 3. @mention Multica Helper when you want it to continue.
-4. Open Agents and Runtimes later when you want to customize the teammate or the computer it runs on.
+4. Open Agents and Runtimes later when you want to customize the spacemate or the computer it runs on.
 
 You can close this issue when the workflow makes sense.`
 
@@ -239,8 +240,13 @@ func (h *Handler) BootstrapOnboardingRuntime(w http.ResponseWriter, r *http.Requ
 	}
 
 	var emptyUUID pgtype.UUID
+	defaultSpace, err := qtx.GetDefaultWorkspaceSpace(r.Context(), wsUUID)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to resolve default space")
+		return
+	}
 	issue, foundIssue, err := issueguard.LockAndFindActiveDuplicate(
-		r.Context(), qtx, wsUUID, emptyUUID, emptyUUID, onboardingIssueTitle, false,
+		r.Context(), qtx, wsUUID, defaultSpace.ID, emptyUUID, emptyUUID, onboardingIssueTitle, false,
 	)
 	if err != nil {
 		slog.Warn("bootstrap onboarding (shim): duplicate issue check failed", append(logger.RequestAttrs(r), "error", err, "workspace_id", req.WorkspaceID)...)
@@ -249,7 +255,10 @@ func (h *Handler) BootstrapOnboardingRuntime(w http.ResponseWriter, r *http.Requ
 	}
 	issueCreated := false
 	if !foundIssue {
-		issueNumber, err := qtx.IncrementIssueCounter(r.Context(), wsUUID)
+		issueNumber, err := qtx.IncrementSpaceIssueCounter(r.Context(), db.IncrementSpaceIssueCounterParams{
+			ID:          defaultSpace.ID,
+			WorkspaceID: wsUUID,
+		})
 		if err != nil {
 			writeError(w, http.StatusInternalServerError, "failed to allocate issue number")
 			return
@@ -260,6 +269,7 @@ func (h *Handler) BootstrapOnboardingRuntime(w http.ResponseWriter, r *http.Requ
 		}
 		issue, err = qtx.CreateIssue(r.Context(), db.CreateIssueParams{
 			WorkspaceID:   wsUUID,
+			SpaceID:       defaultSpace.ID,
 			Title:         onboardingIssueTitle,
 			Description:   strOrNullText(description),
 			Status:        "todo",
@@ -316,7 +326,7 @@ func (h *Handler) BootstrapOnboardingRuntime(w http.ResponseWriter, r *http.Requ
 		))
 	}
 	if issueCreated {
-		prefix := h.getIssuePrefix(r.Context(), issue.WorkspaceID)
+		prefix := issueidentifier.PrefixForIssue(r.Context(), h.Queries, issue)
 		resp := issueToResponse(issue, prefix)
 		h.publish(protocol.EventIssueCreated, req.WorkspaceID, "member", userID, map[string]any{"issue": resp})
 		platform, _, _ := middleware.ClientMetadataFromContext(r.Context())
@@ -397,8 +407,13 @@ func (h *Handler) BootstrapOnboardingNoRuntime(w http.ResponseWriter, r *http.Re
 	}
 
 	var emptyUUID pgtype.UUID
+	defaultSpace, err := qtx.GetDefaultWorkspaceSpace(r.Context(), wsUUID)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to resolve default space")
+		return
+	}
 	existing, foundIssue, err := issueguard.LockAndFindActiveDuplicate(
-		r.Context(), qtx, wsUUID, emptyUUID, emptyUUID, noRuntimeIssueTitle, false,
+		r.Context(), qtx, wsUUID, defaultSpace.ID, emptyUUID, emptyUUID, noRuntimeIssueTitle, false,
 	)
 	if err != nil {
 		slog.Warn("bootstrap no-runtime onboarding (shim): duplicate issue check failed", append(logger.RequestAttrs(r), "error", err, "workspace_id", req.WorkspaceID)...)
@@ -411,13 +426,17 @@ func (h *Handler) BootstrapOnboardingNoRuntime(w http.ResponseWriter, r *http.Re
 	if foundIssue {
 		issue = existing
 	} else {
-		issueNumber, err := qtx.IncrementIssueCounter(r.Context(), wsUUID)
+		issueNumber, err := qtx.IncrementSpaceIssueCounter(r.Context(), db.IncrementSpaceIssueCounterParams{
+			ID:          defaultSpace.ID,
+			WorkspaceID: wsUUID,
+		})
 		if err != nil {
 			writeError(w, http.StatusInternalServerError, "failed to allocate issue number")
 			return
 		}
 		issue, err = qtx.CreateIssue(r.Context(), db.CreateIssueParams{
 			WorkspaceID:   wsUUID,
+			SpaceID:       defaultSpace.ID,
 			Title:         noRuntimeIssueTitle,
 			Description:   strOrNullText(noRuntimeIssueDescription(userBefore.Language)),
 			Status:        "todo",
@@ -456,7 +475,7 @@ func (h *Handler) BootstrapOnboardingNoRuntime(w http.ResponseWriter, r *http.Re
 	}
 
 	if issueCreated {
-		prefix := h.getIssuePrefix(r.Context(), issue.WorkspaceID)
+		prefix := issueidentifier.PrefixForIssue(r.Context(), h.Queries, issue)
 		resp := issueToResponse(issue, prefix)
 		h.publish(protocol.EventIssueCreated, req.WorkspaceID, "member", userID, map[string]any{"issue": resp})
 		platform2, _, _ := middleware.ClientMetadataFromContext(r.Context())
diff --git a/server/internal/handler/project.go b/server/internal/handler/project.go
index 11b93915fb..9f2512e38b 100644
--- a/server/internal/handler/project.go
+++ b/server/internal/handler/project.go
@@ -14,24 +14,26 @@ import (
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/multica-ai/multica/server/internal/logger"
+	"github.com/multica-ai/multica/server/internal/service"
 	db "github.com/multica-ai/multica/server/pkg/db/generated"
 	"github.com/multica-ai/multica/server/pkg/protocol"
 )
 
 type ProjectResponse struct {
-	ID          string  `json:"id"`
-	WorkspaceID string  `json:"workspace_id"`
-	Title       string  `json:"title"`
-	Description *string `json:"description"`
-	Icon        *string `json:"icon"`
-	Status      string  `json:"status"`
-	Priority    string  `json:"priority"`
-	LeadType    *string `json:"lead_type"`
-	LeadID      *string `json:"lead_id"`
-	CreatedAt   string  `json:"created_at"`
-	UpdatedAt   string  `json:"updated_at"`
-	IssueCount  int64   `json:"issue_count"`
-	DoneCount   int64   `json:"done_count"`
+	ID          string   `json:"id"`
+	WorkspaceID string   `json:"workspace_id"`
+	Title       string   `json:"title"`
+	Description *string  `json:"description"`
+	Icon        *string  `json:"icon"`
+	Status      string   `json:"status"`
+	Priority    string   `json:"priority"`
+	LeadType    *string  `json:"lead_type"`
+	LeadID      *string  `json:"lead_id"`
+	SpaceIDs    []string `json:"space_ids"`
+	CreatedAt   string   `json:"created_at"`
+	UpdatedAt   string   `json:"updated_at"`
+	IssueCount  int64    `json:"issue_count"`
+	DoneCount   int64    `json:"done_count"`
 	// ResourceCount is a breadcrumb pointing at the sub-collection at
 	// /api/projects/{id}/resources. Resources themselves stay out of this
 	// payload to keep parent metadata and child collections separate; clients
@@ -50,8 +52,11 @@ func projectToResponse(p db.Project) ProjectResponse {
 		Priority:    p.Priority,
 		LeadType:    textToPtr(p.LeadType),
 		LeadID:      uuidToPtr(p.LeadID),
-		CreatedAt:   timestampToString(p.CreatedAt),
-		UpdatedAt:   timestampToString(p.UpdatedAt),
+		// Always a non-nil slice so no endpoint can serialize space_ids as null;
+		// the frontend zod schema rejects null and would blank the surface.
+		SpaceIDs:  []string{},
+		CreatedAt: timestampToString(p.CreatedAt),
+		UpdatedAt: timestampToString(p.UpdatedAt),
 	}
 }
 
@@ -71,6 +76,60 @@ func (h *Handler) loadProjectResourceCount(ctx context.Context, projectID pgtype
 	return rows[0].ResourceCount
 }
 
+// attachProjectSpaces loads the space links for a single project. Callers pass the
+// pgtype.UUIDs they already hold (from the sqlc row) instead of re-parsing the
+// string form on the response. The error is returned rather than swallowed so
+// callers can log it — a silent failure here serializes space_ids as [] and
+// blanks the project's space affiliation in the UI.
+func (h *Handler) attachProjectSpaces(ctx context.Context, resp *ProjectResponse, workspaceID, projectID pgtype.UUID) error {
+	spaces, err := h.Queries.ListProjectSpaces(ctx, db.ListProjectSpacesParams{
+		WorkspaceID: workspaceID,
+		ProjectID:   projectID,
+	})
+	if err != nil {
+		return err
+	}
+	resp.SpaceIDs = make([]string, len(spaces))
+	for i, space := range spaces {
+		resp.SpaceIDs[i] = uuidToString(space.ID)
+	}
+	return nil
+}
+
+func (h *Handler) resolveProjectSpaceIDs(ctx context.Context, workspaceID pgtype.UUID, raw []string) ([]pgtype.UUID, bool, string) {
+	if len(raw) == 0 {
+		space, err := h.Queries.GetDefaultWorkspaceSpace(ctx, workspaceID)
+		if err != nil || !space.ID.Valid {
+			return nil, false, spaceNotFoundMessage
+		}
+		if space.ArchivedAt.Valid {
+			return nil, false, spaceArchivedMessage
+		}
+		return []pgtype.UUID{space.ID}, true, ""
+	}
+	ids := make([]pgtype.UUID, 0, len(raw))
+	seen := map[string]struct{}{}
+	for _, value := range raw {
+		id, err := parseStrictUUID(strings.TrimSpace(value))
+		if err != nil {
+			return nil, false, "invalid space_id"
+		}
+		key := uuidToString(id)
+		if _, ok := seen[key]; ok {
+			continue
+		}
+		seen[key] = struct{}{}
+		if _, err := service.ValidateActiveSpace(ctx, h.Queries, workspaceID, id); err != nil {
+			return nil, false, spaceResolveMessage(err)
+		}
+		ids = append(ids, id)
+	}
+	if len(ids) == 0 {
+		return nil, false, "space_ids must not be empty"
+	}
+	return ids, true, ""
+}
+
 type CreateProjectRequest struct {
 	Title       string                                `json:"title"`
 	Description *string                               `json:"description"`
@@ -80,6 +139,7 @@ type CreateProjectRequest struct {
 	LeadType    *string                               `json:"lead_type"`
 	LeadID      *string                               `json:"lead_id"`
 	Resources   []CreateProjectResourceRequestPayload `json:"resources,omitempty"`
+	SpaceIDs    []string                              `json:"space_ids,omitempty"`
 }
 
 // CreateProjectResourceRequestPayload mirrors CreateProjectResourceRequest but
@@ -93,13 +153,14 @@ type CreateProjectResourceRequestPayload struct {
 }
 
 type UpdateProjectRequest struct {
-	Title       *string `json:"title"`
-	Description *string `json:"description"`
-	Icon        *string `json:"icon"`
-	Status      *string `json:"status"`
-	Priority    *string `json:"priority"`
-	LeadType    *string `json:"lead_type"`
-	LeadID      *string `json:"lead_id"`
+	Title       *string  `json:"title"`
+	Description *string  `json:"description"`
+	Icon        *string  `json:"icon"`
+	Status      *string  `json:"status"`
+	Priority    *string  `json:"priority"`
+	LeadType    *string  `json:"lead_type"`
+	LeadID      *string  `json:"lead_id"`
+	SpaceIDs    []string `json:"space_ids"`
 }
 
 func (h *Handler) ListProjects(w http.ResponseWriter, r *http.Request) {
@@ -116,8 +177,17 @@ func (h *Handler) ListProjects(w http.ResponseWriter, r *http.Request) {
 	if p := r.URL.Query().Get("priority"); p != "" {
 		priorityFilter = pgtype.Text{String: p, Valid: true}
 	}
+	var spaceFilter pgtype.UUID
+	if t := r.URL.Query().Get("space_id"); t != "" {
+		id, ok := parseUUIDOrBadRequest(w, t, "space_id")
+		if !ok {
+			return
+		}
+		spaceFilter = id
+	}
 	projects, err := h.Queries.ListProjects(r.Context(), db.ListProjectsParams{
 		WorkspaceID: wsUUID,
+		SpaceID:     spaceFilter,
 		Status:      statusFilter,
 		Priority:    priorityFilter,
 	})
@@ -126,9 +196,12 @@ func (h *Handler) ListProjects(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// Batch-fetch issue stats and resource counts for all projects
+	// Batch-fetch issue stats, resource counts, and space links for all projects
+	// in one query each — same shape as loadProjectIssueStats batching — so the
+	// list endpoint never N+1s per project row.
 	statsMap := make(map[string]db.GetProjectIssueStatsRow)
 	resourceCountMap := make(map[string]int64)
+	spaceIDsMap := make(map[string][]string)
 	if len(projects) > 0 {
 		projectIDs := make([]pgtype.UUID, len(projects))
 		for i, p := range projects {
@@ -146,6 +219,18 @@ func (h *Handler) ListProjects(w http.ResponseWriter, r *http.Request) {
 				resourceCountMap[uuidToString(c.ProjectID)] = c.ResourceCount
 			}
 		}
+		spaceRows, err := h.Queries.ListProjectSpacesByProjects(r.Context(), db.ListProjectSpacesByProjectsParams{
+			WorkspaceID: wsUUID,
+			ProjectIds:  projectIDs,
+		})
+		if err != nil {
+			slog.Error("failed to batch-load project spaces", append(logger.RequestAttrs(r), "error", err)...)
+		} else {
+			for _, tr := range spaceRows {
+				pid := uuidToString(tr.ProjectID)
+				spaceIDsMap[pid] = append(spaceIDsMap[pid], uuidToString(tr.ID))
+			}
+		}
 	}
 
 	resp := make([]ProjectResponse, len(projects))
@@ -156,6 +241,9 @@ func (h *Handler) ListProjects(w http.ResponseWriter, r *http.Request) {
 			resp[i].DoneCount = s.DoneCount
 		}
 		resp[i].ResourceCount = resourceCountMap[resp[i].ID]
+		if spaces, ok := spaceIDsMap[resp[i].ID]; ok {
+			resp[i].SpaceIDs = spaces
+		}
 	}
 	writeJSON(w, http.StatusOK, map[string]any{"projects": resp, "total": len(resp)})
 }
@@ -181,6 +269,9 @@ func (h *Handler) GetProject(w http.ResponseWriter, r *http.Request) {
 	resp := projectToResponse(project)
 	resp.IssueCount, resp.DoneCount = h.loadProjectIssueStats(r.Context(), project.ID)
 	resp.ResourceCount = h.loadProjectResourceCount(r.Context(), project.ID)
+	if err := h.attachProjectSpaces(r.Context(), &resp, project.WorkspaceID, project.ID); err != nil {
+		slog.Error("failed to attach project spaces", append(logger.RequestAttrs(r), "error", err, "project_id", uuidToString(project.ID))...)
+	}
 	writeJSON(w, http.StatusOK, resp)
 }
 
@@ -312,20 +403,13 @@ func (h *Handler) CreateProject(w http.ResponseWriter, r *http.Request) {
 		Priority:    priority,
 	}
 
-	// Without resources, keep the simple non-tx path.
-	if len(req.Resources) == 0 {
-		project, err := h.Queries.CreateProject(r.Context(), createParams)
-		if err != nil {
-			h.writeProjectWriteError(w, r, err, "create")
-			return
-		}
-		resp := projectToResponse(project)
-		h.publish(protocol.EventProjectCreated, workspaceID, "member", userID, map[string]any{"project": resp})
-		writeJSON(w, http.StatusCreated, resp)
+	spaceIDs, ok, msg := h.resolveProjectSpaceIDs(r.Context(), wsUUID, req.SpaceIDs)
+	if !ok {
+		writeError(w, http.StatusBadRequest, msg)
 		return
 	}
 
-	// Transactional path: project + all resources are atomic.
+	// Transactional path: project + space links + all resources are atomic.
 	tx, err := h.TxStarter.Begin(r.Context())
 	if err != nil {
 		writeError(w, http.StatusInternalServerError, "failed to start transaction")
@@ -339,6 +423,16 @@ func (h *Handler) CreateProject(w http.ResponseWriter, r *http.Request) {
 		h.writeProjectWriteError(w, r, err, "create")
 		return
 	}
+	for _, spaceID := range spaceIDs {
+		if err := qtx.AddProjectSpace(r.Context(), db.AddProjectSpaceParams{
+			WorkspaceID: wsUUID,
+			ProjectID:   project.ID,
+			SpaceID:     spaceID,
+		}); err != nil {
+			writeError(w, http.StatusInternalServerError, "failed to attach project space")
+			return
+		}
+	}
 
 	creator, _ := h.parseUserUUIDOrZero(userID)
 	resourceRows := make([]db.ProjectResource, 0, len(req.Resources))
@@ -380,6 +474,9 @@ func (h *Handler) CreateProject(w http.ResponseWriter, r *http.Request) {
 		resourceResp[i] = projectResourceToResponse(row)
 	}
 	resp := projectToResponse(project)
+	if err := h.attachProjectSpaces(r.Context(), &resp, project.WorkspaceID, project.ID); err != nil {
+		slog.Error("failed to attach project spaces", append(logger.RequestAttrs(r), "error", err, "project_id", uuidToString(project.ID))...)
+	}
 	resp.ResourceCount = int64(len(resourceResp))
 	h.publish(protocol.EventProjectCreated, workspaceID, "member", userID, map[string]any{"project": resp})
 	for _, rr := range resourceResp {
@@ -489,14 +586,65 @@ func (h *Handler) UpdateProject(w http.ResponseWriter, r *http.Request) {
 			params.LeadID = pgtype.UUID{Valid: false}
 		}
 	}
-	project, err := h.Queries.UpdateProject(r.Context(), params)
+	var (
+		replaceSpaces bool
+		nextSpaceIDs  []pgtype.UUID
+	)
+	if _, ok := rawFields["space_ids"]; ok {
+		replaceSpaces = true
+		// A project always keeps at least one space. The association is still
+		// only a creation-time default for issues, but an unanchored project
+		// would vanish from every space's Projects page — the invariant is
+		// about navigability, not ownership.
+		if len(req.SpaceIDs) == 0 {
+			writeError(w, http.StatusBadRequest, "space_ids must not be empty")
+			return
+		}
+		var msg string
+		var valid bool
+		nextSpaceIDs, valid, msg = h.resolveProjectSpaceIDs(r.Context(), wsUUID, req.SpaceIDs)
+		if !valid {
+			writeError(w, http.StatusBadRequest, msg)
+			return
+		}
+	}
+
+	tx, err := h.TxStarter.Begin(r.Context())
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to start transaction")
+		return
+	}
+	defer tx.Rollback(r.Context())
+	qtx := h.Queries.WithTx(tx)
+
+	// Removing a space association is unguarded by design: the project↔space
+	// link is a creation-time default, not an invariant. Issues keep their
+	// project, and autopilots carry their own space_id independently.
+	project, err := qtx.UpdateProject(r.Context(), params)
 	if err != nil {
 		h.writeProjectWriteError(w, r, err, "update")
 		return
 	}
+	if replaceSpaces {
+		if err := qtx.ReplaceProjectSpaces(r.Context(), db.ReplaceProjectSpacesParams{
+			WorkspaceID: wsUUID,
+			ProjectID:   project.ID,
+			SpaceIds:    nextSpaceIDs,
+		}); err != nil {
+			writeError(w, http.StatusInternalServerError, "failed to update project spaces")
+			return
+		}
+	}
+	if err := tx.Commit(r.Context()); err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to commit project update")
+		return
+	}
 	resp := projectToResponse(project)
 	resp.IssueCount, resp.DoneCount = h.loadProjectIssueStats(r.Context(), project.ID)
 	resp.ResourceCount = h.loadProjectResourceCount(r.Context(), project.ID)
+	if err := h.attachProjectSpaces(r.Context(), &resp, project.WorkspaceID, project.ID); err != nil {
+		slog.Error("failed to attach project spaces", append(logger.RequestAttrs(r), "error", err, "project_id", uuidToString(project.ID))...)
+	}
 	h.publish(protocol.EventProjectUpdated, workspaceID, "member", userID, map[string]any{"project": resp})
 	writeJSON(w, http.StatusOK, resp)
 }
@@ -762,9 +910,13 @@ func (h *Handler) SearchProjects(w http.ResponseWriter, r *http.Request) {
 		total = results[0].totalCount
 	}
 
-	// Batch-fetch issue stats and resource counts
+	// Batch-fetch issue stats, resource counts, and space links. Search is the
+	// only project endpoint that previously never attached spaces, so it
+	// serialized space_ids as [] for every hit; without the space links the
+	// frontend cannot render project space affiliation for search results.
 	statsMap := make(map[string]db.GetProjectIssueStatsRow)
 	resourceCountMap := make(map[string]int64)
+	spaceIDsMap := make(map[string][]string)
 	if len(results) > 0 {
 		projectIDs := make([]pgtype.UUID, len(results))
 		for i, r := range results {
@@ -782,6 +934,18 @@ func (h *Handler) SearchProjects(w http.ResponseWriter, r *http.Request) {
 				resourceCountMap[uuidToString(c.ProjectID)] = c.ResourceCount
 			}
 		}
+		spaceRows, err := h.Queries.ListProjectSpacesByProjects(ctx, db.ListProjectSpacesByProjectsParams{
+			WorkspaceID: wsUUID,
+			ProjectIds:  projectIDs,
+		})
+		if err != nil {
+			slog.Error("failed to batch-load project spaces", append(logger.RequestAttrs(r), "error", err)...)
+		} else {
+			for _, tr := range spaceRows {
+				pid := uuidToString(tr.ProjectID)
+				spaceIDsMap[pid] = append(spaceIDsMap[pid], uuidToString(tr.ID))
+			}
+		}
 	}
 
 	resp := make([]SearchProjectResponse, len(results))
@@ -792,6 +956,9 @@ func (h *Handler) SearchProjects(w http.ResponseWriter, r *http.Request) {
 			pr.DoneCount = s.DoneCount
 		}
 		pr.ResourceCount = resourceCountMap[pr.ID]
+		if spaces, ok := spaceIDsMap[pr.ID]; ok {
+			pr.SpaceIDs = spaces
+		}
 		spr := SearchProjectResponse{
 			ProjectResponse: pr,
 			MatchSource:     row.matchSource,
diff --git a/server/internal/handler/project_resource_test.go b/server/internal/handler/project_resource_test.go
index 1c7530a78b..7501501cd3 100644
--- a/server/internal/handler/project_resource_test.go
+++ b/server/internal/handler/project_resource_test.go
@@ -589,9 +589,10 @@ func TestProjectResourceCountBreadcrumb(t *testing.T) {
 	if err := testPool.QueryRow(context.Background(), `
 		INSERT INTO issue (
 			workspace_id, creator_type, creator_id, title, status, priority,
-			project_id, number, position
+			project_id, number, position, space_id
 		)
-		VALUES ($1, 'member', $2, 'Project update stats breadcrumb', 'done', 'none', $3, $4, 0)
+		VALUES ($1, 'member', $2, 'Project update stats breadcrumb', 'done', 'none', $3, $4, 0,
+		        (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, testUserID, project.ID, number).Scan(&issueID); err != nil {
 		t.Fatalf("create project issue: %v", err)
diff --git a/server/internal/handler/quick_create_parent_test.go b/server/internal/handler/quick_create_parent_test.go
index 07a3fe6af8..e9819d5709 100644
--- a/server/internal/handler/quick_create_parent_test.go
+++ b/server/internal/handler/quick_create_parent_test.go
@@ -64,9 +64,10 @@ func TestQuickCreateIssueParentTrustBoundary(t *testing.T) {
 	// Same-workspace parent — must be accepted and threaded through.
 	var localParentID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, creator_id, creator_type, number)
+		INSERT INTO issue (workspace_id, title, creator_id, creator_type, number, space_id)
 		VALUES ($1, 'quick-create parent (local)', $2, 'member',
-		        (SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1))
+		        (SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1),
+		        (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&localParentID); err != nil {
 		t.Fatalf("create local parent issue: %v", err)
@@ -94,10 +95,19 @@ func TestQuickCreateIssueParentTrustBoundary(t *testing.T) {
 	t.Cleanup(func() {
 		testPool.Exec(context.Background(), `DELETE FROM workspace WHERE id = $1`, foreignWorkspaceID)
 	})
+	// The foreign parent issue below resolves space_id from this workspace's
+	// default Space; a freshly-created workspace has none, so seed it here.
+	if _, err := testPool.Exec(ctx, `
+		INSERT INTO workspace_space (workspace_id, name, key, issue_counter, created_by)
+		VALUES ($1, 'Default', 'QCF', 0, $2)
+	`, foreignWorkspaceID, foreignUserID); err != nil {
+		t.Fatalf("create foreign workspace_space: %v", err)
+	}
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, creator_id, creator_type, number)
+		INSERT INTO issue (workspace_id, title, creator_id, creator_type, number, space_id)
 		VALUES ($1, 'quick-create parent (foreign)', $2, 'member',
-		        (SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1))
+		        (SELECT COALESCE(MAX(number), 0) + 1 FROM issue WHERE workspace_id = $1),
+		        (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, foreignWorkspaceID, foreignUserID).Scan(&foreignParentID); err != nil {
 		t.Fatalf("create foreign parent issue: %v", err)
diff --git a/server/internal/handler/reserved_slugs.json b/server/internal/handler/reserved_slugs.json
index f2f6d01511..55661b066c 100644
--- a/server/internal/handler/reserved_slugs.json
+++ b/server/internal/handler/reserved_slugs.json
@@ -1,5 +1,5 @@
 {
-  "$comment": "Source of truth for reserved workspace slugs. Edit this file only. The Go side embeds this JSON directly; the TS side (packages/core/paths/reserved-slugs.ts) is regenerated from this file by `pnpm generate:reserved-slugs`. CI re-runs the generator and fails on any diff, so the two sides cannot drift. Convention for new global routes: single word (`/login`, `/inbox`) or `/{noun}/{verb}` (`/workspaces/new`). Never add hyphenated root-level word groups (`/new-workspace`, `/create-team`) — they collide with common user workspace names.",
+  "$comment": "Source of truth for reserved workspace slugs. Edit this file only. The Go side embeds this JSON directly; the TS side (packages/core/paths/reserved-slugs.ts) is regenerated from this file by `pnpm generate:reserved-slugs`. CI re-runs the generator and fails on any diff, so the two sides cannot drift. Convention for new global routes: single word (`/login`, `/inbox`) or `/{noun}/{verb}` (`/workspaces/new`). Never add hyphenated root-level word groups (`/new-workspace`, `/create-space`) — they collide with common user workspace names.",
   "groups": [
     {
       "label": "Auth flow",
@@ -66,7 +66,7 @@
     },
     {
       "label": "Workspace route segments",
-      "description": "Reserving each segment name prevents `/{slug}/{view}` from being visually ambiguous (e.g. a workspace named `issues` would make `/issues/abc` mean two things). `workspaces` covers the global `/workspaces/new` workspace-creation page; `teams` is reserved for future team management.",
+      "description": "Reserving each segment name prevents `/{slug}/{view}` from being visually ambiguous (e.g. a workspace named `issues` would make `/issues/abc` mean two things). `workspaces` covers the global `/workspaces/new` workspace-creation page; `spaces` is reserved for future space management.",
       "slugs": [
         "issues",
         "projects",
@@ -80,7 +80,8 @@
         "skills",
         "settings",
         "workspaces",
-        "teams"
+        "spaces",
+        "space"
       ]
     },
     {
diff --git a/server/internal/handler/runtime_test.go b/server/internal/handler/runtime_test.go
index 3cc063f321..25b7b42d66 100644
--- a/server/internal/handler/runtime_test.go
+++ b/server/internal/handler/runtime_test.go
@@ -105,8 +105,9 @@ func TestGetRuntimeUsage_BucketsByUsageTime(t *testing.T) {
 	// Create an issue for the tasks to reference.
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, creator_id, creator_type)
-		VALUES ($1, 'runtime usage test', $2, 'member')
+		INSERT INTO issue (workspace_id, title, creator_id, creator_type, space_id)
+		VALUES ($1, 'runtime usage test', $2, 'member',
+		        (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
@@ -227,8 +228,9 @@ func TestListRuntimeUsageByAgent_MergesMixedCaseProvider(t *testing.T) {
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, creator_id, creator_type)
-		VALUES ($1, 'mixed-case provider test', $2, 'member')
+		INSERT INTO issue (workspace_id, title, creator_id, creator_type, space_id)
+		VALUES ($1, 'mixed-case provider test', $2, 'member',
+		        (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
diff --git a/server/internal/handler/search_test.go b/server/internal/handler/search_test.go
index f8309a7d5f..8d74a4e198 100644
--- a/server/internal/handler/search_test.go
+++ b/server/internal/handler/search_test.go
@@ -6,7 +6,7 @@ import (
 )
 
 func TestBuildSearchQuery_SingleTerm(t *testing.T) {
-	query, args := buildSearchQuery("Hello", []string{"Hello"}, 0, false, false)
+	query, args := buildSearchQuery("Hello", []string{"Hello"}, 0, "", false, false)
 
 	// Pattern should be lowercased in Go.
 	if args[0] != "hello" {
@@ -42,7 +42,7 @@ func TestBuildSearchQuery_SingleTerm(t *testing.T) {
 }
 
 func TestBuildSearchQuery_MultiTerm(t *testing.T) {
-	query, args := buildSearchQuery("Foo Bar", []string{"Foo", "Bar"}, 0, false, false)
+	query, args := buildSearchQuery("Foo Bar", []string{"Foo", "Bar"}, 0, "", false, false)
 
 	// Both phrase and terms should be lowercased.
 	if args[0] != "foo bar" {
@@ -63,13 +63,21 @@ func TestBuildSearchQuery_MultiTerm(t *testing.T) {
 }
 
 func TestBuildSearchQuery_WithNumber(t *testing.T) {
-	query, args := buildSearchQuery("MUL-42", []string{"MUL-42"}, 42, true, false)
+	query, args := buildSearchQuery("MUL-42", []string{"MUL-42"}, 42, "MUL", true, false)
 
-	_ = args
 	// Number match should be in WHERE.
 	if !strings.Contains(query, "i.number = ") {
 		t.Error("query should contain number match in WHERE clause")
 	}
+	// Identifier search constrains by the issue's own Space key (wt, from the
+	// query's base join) — issue.space_id is NOT NULL as of migration 132, so
+	// no fallback join is needed.
+	if !strings.Contains(query, "lower(wt.key) = lower(") {
+		t.Error("identifier search should constrain by lower(wt.key)")
+	}
+	if args[4] != int(42) || args[5] != "MUL" {
+		t.Errorf("expected number/space key args at positions 4/5, got %#v", args)
+	}
 	// Tier 0 rank for identifier match.
 	if !strings.Contains(query, "THEN 0") {
 		t.Error("query should contain tier 0 rank for identifier match")
@@ -77,7 +85,7 @@ func TestBuildSearchQuery_WithNumber(t *testing.T) {
 }
 
 func TestBuildSearchQuery_IncludeClosed(t *testing.T) {
-	query, _ := buildSearchQuery("test", []string{"test"}, 0, false, true)
+	query, _ := buildSearchQuery("test", []string{"test"}, 0, "", false, true)
 
 	if strings.Contains(query, "NOT IN ('done', 'cancelled')") {
 		t.Error("query should not exclude done/cancelled when includeClosed=true")
@@ -85,7 +93,7 @@ func TestBuildSearchQuery_IncludeClosed(t *testing.T) {
 }
 
 func TestBuildSearchQuery_SpecialChars(t *testing.T) {
-	query, args := buildSearchQuery("100%", []string{"100%"}, 0, false, false)
+	query, args := buildSearchQuery("100%", []string{"100%"}, 0, "", false, false)
 
 	_ = query
 	// % should be escaped in the phrase arg.
@@ -204,7 +212,7 @@ func TestExtractSnippet_CJKContent(t *testing.T) {
 // --- Ranking regression tests ---
 
 func TestBuildSearchQuery_CommentRankTiers(t *testing.T) {
-	query, _ := buildSearchQuery("test phrase", []string{"test", "phrase"}, 0, false, false)
+	query, _ := buildSearchQuery("test phrase", []string{"test", "phrase"}, 0, "", false, false)
 
 	// Comment phrase match should be tier 7
 	if !strings.Contains(query, "THEN 7") {
@@ -221,7 +229,7 @@ func TestBuildSearchQuery_CommentRankTiers(t *testing.T) {
 }
 
 func TestBuildSearchQuery_DescriptionRankTiers(t *testing.T) {
-	query, _ := buildSearchQuery("foo bar", []string{"foo", "bar"}, 0, false, false)
+	query, _ := buildSearchQuery("foo bar", []string{"foo", "bar"}, 0, "", false, false)
 
 	// Description phrase match should be tier 5
 	if !strings.Contains(query, "THEN 5") {
@@ -234,7 +242,7 @@ func TestBuildSearchQuery_DescriptionRankTiers(t *testing.T) {
 }
 
 func TestBuildSearchQuery_SingleTermNoAllTermTiers(t *testing.T) {
-	query, _ := buildSearchQuery("html", []string{"html"}, 0, false, false)
+	query, _ := buildSearchQuery("html", []string{"html"}, 0, "", false, false)
 
 	// Extract the rank CASE expression (ends with "ELSE 9 END") to avoid
 	// false matches against statusRank which also contains THEN 4/6.
@@ -268,7 +276,7 @@ func TestBuildSearchQuery_SingleTermNoAllTermTiers(t *testing.T) {
 // $4 is buildSearchQuery's canonical workspace_id placeholder (the
 // caller writes wsUUID into args[3] before executing).
 func TestBuildSearchQuery_CommentSubqueryWorkspaceScope(t *testing.T) {
-	singleQuery, _ := buildSearchQuery("html", []string{"html"}, 0, false, false)
+	singleQuery, _ := buildSearchQuery("html", []string{"html"}, 0, "", false, false)
 
 	// Every occurrence of `FROM comment c` must be followed by the
 	// c.workspace_id = $4 constraint. Counting is safer than a single
@@ -286,7 +294,7 @@ func TestBuildSearchQuery_CommentSubqueryWorkspaceScope(t *testing.T) {
 
 	// Multi-term uses one extra comment subquery in the WHERE and one in
 	// the rank CASE for the all-terms match — same invariant applies.
-	multiQuery, _ := buildSearchQuery("foo bar", []string{"foo", "bar"}, 0, false, false)
+	multiQuery, _ := buildSearchQuery("foo bar", []string{"foo", "bar"}, 0, "", false, false)
 	fromCountMulti := strings.Count(multiQuery, "FROM comment c")
 	scopedCountMulti := strings.Count(multiQuery, "c.workspace_id = $4")
 	if scopedCountMulti < fromCountMulti {
diff --git a/server/internal/handler/space.go b/server/internal/handler/space.go
new file mode 100644
index 0000000000..2c59f54ee5
--- /dev/null
+++ b/server/internal/handler/space.go
@@ -0,0 +1,616 @@
+package handler
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"strings"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/multica-ai/multica/server/internal/service"
+	db "github.com/multica-ai/multica/server/pkg/db/generated"
+	"github.com/multica-ai/multica/server/pkg/protocol"
+)
+
+var errSpaceKeyFrozen = errors.New("space identifier cannot be changed after issues have been created")
+
+type SpaceResponse struct {
+	ID           string  `json:"id"`
+	WorkspaceID  string  `json:"workspace_id"`
+	Name         string  `json:"name"`
+	Key          string  `json:"key"`
+	Description  string  `json:"description"`
+	Icon         *string `json:"icon"`
+	IssueCounter int32   `json:"issue_counter"`
+	ArchivedAt   *string `json:"archived_at"`
+	CreatedBy    *string `json:"created_by"`
+	CreatedAt    string  `json:"created_at"`
+	UpdatedAt    string  `json:"updated_at"`
+	// Requesting user's membership view: the sidebar shows only joined
+	// spaces, ordered by SortOrder (per-user fractional position; the first
+	// space doubles as the issue-creation default when no context applies).
+	IsMember  bool    `json:"is_member"`
+	SortOrder float64 `json:"sort_order"`
+}
+
+func spaceToResponse(t db.WorkspaceSpace) SpaceResponse {
+	return SpaceResponse{
+		ID:           uuidToString(t.ID),
+		WorkspaceID:  uuidToString(t.WorkspaceID),
+		Name:         t.Name,
+		Key:          t.Key,
+		Description:  t.Description,
+		Icon:         textToPtr(t.Icon),
+		IssueCounter: t.IssueCounter,
+		ArchivedAt:   timestampToPtr(t.ArchivedAt),
+		CreatedBy:    uuidToPtr(t.CreatedBy),
+		CreatedAt:    timestampToString(t.CreatedAt),
+		UpdatedAt:    timestampToString(t.UpdatedAt),
+	}
+}
+
+type CreateSpaceRequest struct {
+	Name        string  `json:"name"`
+	Key         string  `json:"key"`
+	Description *string `json:"description"`
+	Icon        *string `json:"icon"`
+	// MemberIDs invites workspace members into the new space alongside the
+	// creator (who always joins as lead). Minimal v1 membership loop —
+	// there is no separate join/leave API yet, so a space is only visible in
+	// its members' sidebars.
+	MemberIDs []string `json:"member_ids"`
+}
+
+type UpdateSpaceRequest struct {
+	Name        *string `json:"name"`
+	Key         *string `json:"key"`
+	Description *string `json:"description"`
+	Icon        *string `json:"icon"`
+}
+
+func (h *Handler) ListSpaces(w http.ResponseWriter, r *http.Request) {
+	workspaceID := h.resolveWorkspaceID(r)
+	wsUUID, ok := parseUUIDOrBadRequest(w, workspaceID, "workspace_id")
+	if !ok {
+		return
+	}
+	userID, ok := requireUserID(w, r)
+	if !ok {
+		return
+	}
+	rows, err := h.Queries.ListWorkspaceSpacesForUser(r.Context(), db.ListWorkspaceSpacesForUserParams{
+		WorkspaceID: wsUUID,
+		UserID:      parseUUID(userID),
+	})
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to list spaces")
+		return
+	}
+	resp := make([]SpaceResponse, len(rows))
+	for i, row := range rows {
+		resp[i] = spaceToResponse(row.WorkspaceSpace)
+		resp[i].IsMember = row.IsMember
+		resp[i].SortOrder = row.MemberSortOrder
+	}
+	writeJSON(w, http.StatusOK, map[string]any{"spaces": resp, "total": len(resp)})
+}
+
+func (h *Handler) CreateSpace(w http.ResponseWriter, r *http.Request) {
+	var req CreateSpaceRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid request body")
+		return
+	}
+	req.Name = strings.TrimSpace(req.Name)
+	if req.Name == "" {
+		writeError(w, http.StatusBadRequest, "name is required")
+		return
+	}
+	key := normalizeSpaceKey(req.Key)
+	if key == "" {
+		key = defaultSpaceKeyFromSlug(req.Name)
+	}
+	if !validSpaceKey(key) {
+		writeError(w, http.StatusBadRequest, "identifier must match ^[A-Z][A-Z0-9]{0,6}$ and must not be a reserved word (e.g. NEW)")
+		return
+	}
+	workspaceID := h.resolveWorkspaceID(r)
+	wsUUID, ok := parseUUIDOrBadRequest(w, workspaceID, "workspace_id")
+	if !ok {
+		return
+	}
+	userID, ok := requireUserID(w, r)
+	if !ok {
+		return
+	}
+	memberIDs := make([]pgtype.UUID, 0, len(req.MemberIDs))
+	creatorUUID := parseUUID(userID)
+	for _, raw := range req.MemberIDs {
+		uid, ok := parseUUIDOrBadRequest(w, raw, "member_ids")
+		if !ok {
+			return
+		}
+		if uid == creatorUUID {
+			continue // creator joins as lead below
+		}
+		memberIDs = append(memberIDs, uid)
+	}
+
+	tx, err := h.TxStarter.Begin(r.Context())
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to create space")
+		return
+	}
+	defer tx.Rollback(r.Context())
+	qtx := h.Queries.WithTx(tx)
+
+	space, err := qtx.CreateWorkspaceSpace(r.Context(), db.CreateWorkspaceSpaceParams{
+		WorkspaceID: wsUUID,
+		Name:        req.Name,
+		Key:         key,
+		Description: ptrToText(req.Description),
+		Icon:        ptrToText(req.Icon),
+		CreatedBy:   creatorUUID,
+	})
+	if err != nil {
+		if isUniqueViolation(err) || isCheckViolation(err) {
+			writeError(w, http.StatusBadRequest, "space identifier is invalid or already used")
+			return
+		}
+		writeError(w, http.StatusInternalServerError, "failed to create space")
+		return
+	}
+	// The creator always joins as lead — a space invisible in its creator's
+	// own sidebar would be unreachable (sidebar shows joined spaces only).
+	creatorSort, err := addSpaceMember(r.Context(), qtx, wsUUID, space.ID, creatorUUID, "lead")
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to add space members")
+		return
+	}
+	for _, uid := range memberIDs {
+		if _, err := qtx.GetMemberByUserAndWorkspace(r.Context(), db.GetMemberByUserAndWorkspaceParams{
+			UserID:      uid,
+			WorkspaceID: wsUUID,
+		}); err != nil {
+			writeError(w, http.StatusBadRequest, "member_ids must be members of this workspace")
+			return
+		}
+		if _, err := addSpaceMember(r.Context(), qtx, wsUUID, space.ID, uid, "member"); err != nil {
+			writeError(w, http.StatusInternalServerError, "failed to add space members")
+			return
+		}
+	}
+	if err := tx.Commit(r.Context()); err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to create space")
+		return
+	}
+
+	resp := spaceToResponse(space)
+	resp.IsMember = true
+	resp.SortOrder = creatorSort
+	h.publish(protocol.EventWorkspaceUpdated, workspaceID, "member", userID, map[string]any{"space": resp})
+	writeJSON(w, http.StatusCreated, resp)
+}
+
+// addSpaceMember appends the user to the space at the end of their personal
+// space order and returns the assigned sort position.
+func addSpaceMember(ctx context.Context, q *db.Queries, wsUUID, spaceID, userID pgtype.UUID, role string) (float64, error) {
+	sort, err := q.NextSpaceMemberSortOrder(ctx, db.NextSpaceMemberSortOrderParams{
+		WorkspaceID: wsUUID,
+		UserID:      userID,
+	})
+	if err != nil {
+		return 0, err
+	}
+	if err := q.AddWorkspaceSpaceMember(ctx, db.AddWorkspaceSpaceMemberParams{
+		WorkspaceID: wsUUID,
+		SpaceID:     spaceID,
+		UserID:      userID,
+		Role:        role,
+		SortOrder:   sort,
+	}); err != nil {
+		return 0, err
+	}
+	return sort, nil
+}
+
+type UpdateSpaceMembershipRequest struct {
+	SortOrder *float64 `json:"sort_order"`
+}
+
+type ReplaceSpaceMembersRequest struct {
+	MemberIDs []string `json:"member_ids"`
+}
+
+// ReplaceSpaceMembers sets a space's member list wholesale. Anyone in the
+// workspace may configure any space's members — membership only drives the
+// sidebar and personal defaults, never access, so there is no extra
+// permission layer. Kept rows are untouched (their sort_order and role
+// survive); added members land at the end of their own personal order. An
+// empty list is rejected: zero members means "archive the space", which the
+// client performs explicitly via DELETE /api/spaces/{id} after a confirm.
+func (h *Handler) ReplaceSpaceMembers(w http.ResponseWriter, r *http.Request) {
+	workspaceID := h.resolveWorkspaceID(r)
+	wsUUID, ok := parseUUIDOrBadRequest(w, workspaceID, "workspace_id")
+	if !ok {
+		return
+	}
+	spaceID, ok := parseUUIDOrBadRequest(w, chi.URLParam(r, "id"), "space id")
+	if !ok {
+		return
+	}
+	var req ReplaceSpaceMembersRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid request body")
+		return
+	}
+	if len(req.MemberIDs) == 0 {
+		writeError(w, http.StatusBadRequest, "empty membership archives the space — archive it instead")
+		return
+	}
+	if _, err := service.ValidateActiveSpace(r.Context(), h.Queries, wsUUID, spaceID); err != nil {
+		if !writeSpaceResolveError(w, err) {
+			writeError(w, http.StatusBadRequest, err.Error())
+		}
+		return
+	}
+	next := make(map[pgtype.UUID]struct{}, len(req.MemberIDs))
+	for _, raw := range req.MemberIDs {
+		uid, ok := parseUUIDOrBadRequest(w, raw, "member_ids")
+		if !ok {
+			return
+		}
+		next[uid] = struct{}{}
+	}
+
+	tx, err := h.TxStarter.Begin(r.Context())
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to update space members")
+		return
+	}
+	defer tx.Rollback(r.Context())
+	qtx := h.Queries.WithTx(tx)
+
+	current, err := qtx.ListWorkspaceSpaceMembers(r.Context(), db.ListWorkspaceSpaceMembersParams{
+		WorkspaceID: wsUUID,
+		SpaceID:     spaceID,
+	})
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to load space members")
+		return
+	}
+	currentSet := make(map[pgtype.UUID]struct{}, len(current))
+	for _, m := range current {
+		currentSet[m.UserID] = struct{}{}
+	}
+	for uid := range next {
+		if _, kept := currentSet[uid]; kept {
+			continue
+		}
+		if _, err := qtx.GetMemberByUserAndWorkspace(r.Context(), db.GetMemberByUserAndWorkspaceParams{
+			UserID:      uid,
+			WorkspaceID: wsUUID,
+		}); err != nil {
+			writeError(w, http.StatusBadRequest, "member_ids must be members of this workspace")
+			return
+		}
+		if _, err := addSpaceMember(r.Context(), qtx, wsUUID, spaceID, uid, "member"); err != nil {
+			writeError(w, http.StatusInternalServerError, "failed to update space members")
+			return
+		}
+	}
+	for _, m := range current {
+		if _, keep := next[m.UserID]; keep {
+			continue
+		}
+		if _, err := qtx.RemoveWorkspaceSpaceMember(r.Context(), db.RemoveWorkspaceSpaceMemberParams{
+			WorkspaceID: wsUUID,
+			SpaceID:     spaceID,
+			UserID:      m.UserID,
+		}); err != nil {
+			writeError(w, http.StatusInternalServerError, "failed to update space members")
+			return
+		}
+	}
+	if err := tx.Commit(r.Context()); err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to update space members")
+		return
+	}
+	h.listSpaceMembersResponse(w, r, wsUUID, spaceID)
+}
+
+type SpaceMemberResponse struct {
+	UserID    string  `json:"user_id"`
+	Name      string  `json:"name"`
+	Email     string  `json:"email"`
+	AvatarURL *string `json:"avatar_url"`
+	Role      string  `json:"role"`
+	CreatedAt string  `json:"created_at"`
+}
+
+// ListSpaceMembers lists a space's members with user display data. Membership
+// is configured wholesale via ReplaceSpaceMembers.
+func (h *Handler) ListSpaceMembers(w http.ResponseWriter, r *http.Request) {
+	workspaceID := h.resolveWorkspaceID(r)
+	wsUUID, ok := parseUUIDOrBadRequest(w, workspaceID, "workspace_id")
+	if !ok {
+		return
+	}
+	spaceID, ok := parseUUIDOrBadRequest(w, chi.URLParam(r, "id"), "space id")
+	if !ok {
+		return
+	}
+	h.listSpaceMembersResponse(w, r, wsUUID, spaceID)
+}
+
+// listSpaceMembersResponse writes the members payload shared by the GET and
+// the PUT (replace) endpoints.
+func (h *Handler) listSpaceMembersResponse(w http.ResponseWriter, r *http.Request, wsUUID, spaceID pgtype.UUID) {
+	rows, err := h.Queries.ListWorkspaceSpaceMembersWithUser(r.Context(), db.ListWorkspaceSpaceMembersWithUserParams{
+		WorkspaceID: wsUUID,
+		SpaceID:     spaceID,
+	})
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to list space members")
+		return
+	}
+	resp := make([]SpaceMemberResponse, len(rows))
+	for i, row := range rows {
+		resp[i] = SpaceMemberResponse{
+			UserID:    uuidToString(row.UserID),
+			Name:      row.UserName,
+			Email:     row.UserEmail,
+			AvatarURL: textToPtr(row.UserAvatarUrl),
+			Role:      row.Role,
+			CreatedAt: timestampToString(row.CreatedAt),
+		}
+	}
+	writeJSON(w, http.StatusOK, map[string]any{"members": resp, "total": len(resp)})
+}
+
+// UpdateSpaceMembership updates the caller's own membership row — currently
+// just sort_order, the per-user sidebar position. Fractional: a drag sends
+// the midpoint of the drop slot's neighbors, so single-row updates suffice.
+func (h *Handler) UpdateSpaceMembership(w http.ResponseWriter, r *http.Request) {
+	workspaceID := h.resolveWorkspaceID(r)
+	wsUUID, ok := parseUUIDOrBadRequest(w, workspaceID, "workspace_id")
+	if !ok {
+		return
+	}
+	spaceID, ok := parseUUIDOrBadRequest(w, chi.URLParam(r, "id"), "space id")
+	if !ok {
+		return
+	}
+	userID, ok := requireUserID(w, r)
+	if !ok {
+		return
+	}
+	var req UpdateSpaceMembershipRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.SortOrder == nil {
+		writeError(w, http.StatusBadRequest, "sort_order is required")
+		return
+	}
+	m, err := h.Queries.UpdateSpaceMemberSortOrder(r.Context(), db.UpdateSpaceMemberSortOrderParams{
+		WorkspaceID: wsUUID,
+		SpaceID:     spaceID,
+		UserID:      parseUUID(userID),
+		SortOrder:   *req.SortOrder,
+	})
+	if err != nil {
+		writeError(w, http.StatusNotFound, "you are not a member of this space")
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]any{
+		"space_id":   uuidToString(m.SpaceID),
+		"sort_order": m.SortOrder,
+	})
+}
+
+func (h *Handler) UpdateSpace(w http.ResponseWriter, r *http.Request) {
+	workspaceID := h.resolveWorkspaceID(r)
+	wsUUID, ok := parseUUIDOrBadRequest(w, workspaceID, "workspace_id")
+	if !ok {
+		return
+	}
+	spaceID, ok := parseUUIDOrBadRequest(w, chi.URLParam(r, "id"), "space id")
+	if !ok {
+		return
+	}
+	var req UpdateSpaceRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid request body")
+		return
+	}
+	params := db.UpdateWorkspaceSpaceParams{
+		ID:          spaceID,
+		WorkspaceID: wsUUID,
+	}
+	if req.Name != nil {
+		name := strings.TrimSpace(*req.Name)
+		if name == "" {
+			writeError(w, http.StatusBadRequest, "name is required")
+			return
+		}
+		params.Name = pgtype.Text{String: name, Valid: true}
+	}
+	if req.Key != nil {
+		key := normalizeSpaceKey(*req.Key)
+		if !validSpaceKey(key) {
+			writeError(w, http.StatusBadRequest, "identifier must match ^[A-Z][A-Z0-9]{0,6}$ and must not be a reserved word (e.g. NEW)")
+			return
+		}
+		// Key changes are admin-only: the key is the workspace-wide issue
+		// identifier namespace, and the legacy workspace issue_prefix path
+		// (admin-gated at the router) funnels into the same row — both
+		// doors must carry the same gate.
+		current, err := h.Queries.GetWorkspaceSpace(r.Context(), db.GetWorkspaceSpaceParams{
+			ID:          spaceID,
+			WorkspaceID: wsUUID,
+		})
+		if err != nil {
+			writeError(w, http.StatusNotFound, "space not found")
+			return
+		}
+		if current.Key != key {
+			member, ok := ctxMember(r.Context())
+			if !ok || !roleAllowed(member.Role, "owner", "admin") {
+				writeError(w, http.StatusForbidden, "only workspace admins can change the space key")
+				return
+			}
+		}
+		params.Key = pgtype.Text{String: key, Valid: true}
+	}
+	if req.Description != nil {
+		params.Description = pgtype.Text{String: *req.Description, Valid: true}
+	}
+	if req.Icon != nil {
+		params.Icon = pgtype.Text{String: *req.Icon, Valid: true}
+	}
+
+	tx, err := h.TxStarter.Begin(r.Context())
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to start transaction")
+		return
+	}
+	defer tx.Rollback(r.Context())
+	qtx := h.Queries.WithTx(tx)
+
+	space, err := updateWorkspaceSpaceLocked(r.Context(), qtx, params)
+	if err != nil {
+		if errors.Is(err, errSpaceKeyFrozen) {
+			writeError(w, http.StatusConflict, "space identifier cannot be changed after issues have been created")
+			return
+		}
+		if isUniqueViolation(err) || isCheckViolation(err) {
+			writeError(w, http.StatusBadRequest, "space identifier is invalid or already used")
+			return
+		}
+		if errors.Is(err, pgx.ErrNoRows) {
+			writeError(w, http.StatusNotFound, "space not found")
+			return
+		}
+		writeError(w, http.StatusInternalServerError, "failed to update space")
+		return
+	}
+	if err := tx.Commit(r.Context()); err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to commit space update")
+		return
+	}
+	resp := spaceToResponse(space)
+	userID := requestUserID(r)
+	resp = h.withCallerMembership(r.Context(), resp, space.ID, userID)
+	h.publish(protocol.EventWorkspaceUpdated, workspaceID, "member", userID, map[string]any{"space": resp})
+	writeJSON(w, http.StatusOK, resp)
+}
+
+// withCallerMembership stamps the caller's membership view onto a single-space
+// response so mutations don't clobber is_member/sort_order in the client's
+// list cache (the list endpoint always carries them).
+func (h *Handler) withCallerMembership(ctx context.Context, resp SpaceResponse, spaceID pgtype.UUID, userID string) SpaceResponse {
+	m, err := h.Queries.GetWorkspaceSpaceMember(ctx, db.GetWorkspaceSpaceMemberParams{
+		SpaceID: spaceID,
+		UserID:  parseUUID(userID),
+	})
+	if err == nil {
+		resp.IsMember = true
+		resp.SortOrder = m.SortOrder
+	}
+	return resp
+}
+
+func updateWorkspaceSpaceLocked(ctx context.Context, qtx *db.Queries, params db.UpdateWorkspaceSpaceParams) (db.WorkspaceSpace, error) {
+	locked, err := qtx.LockWorkspaceSpaceForKeyUpdate(ctx, db.LockWorkspaceSpaceForKeyUpdateParams{
+		ID:          params.ID,
+		WorkspaceID: params.WorkspaceID,
+	})
+	if err != nil {
+		return db.WorkspaceSpace{}, err
+	}
+	if params.Key.Valid && params.Key.String != locked.Key && locked.IssueCounter > 0 {
+		return db.WorkspaceSpace{}, errSpaceKeyFrozen
+	}
+	return qtx.UpdateWorkspaceSpace(ctx, params)
+}
+
+func (h *Handler) ArchiveSpace(w http.ResponseWriter, r *http.Request) {
+	workspaceID := h.resolveWorkspaceID(r)
+	wsUUID, ok := parseUUIDOrBadRequest(w, workspaceID, "workspace_id")
+	if !ok {
+		return
+	}
+	spaceID, ok := parseUUIDOrBadRequest(w, chi.URLParam(r, "id"), "space id")
+	if !ok {
+		return
+	}
+	userID, ok := requireUserID(w, r)
+	if !ok {
+		return
+	}
+	// Archiving is admin-only, matching the destructive-op convention
+	// (project delete, squad delete). Everything else on a space stays
+	// member-open — membership is not a permission layer.
+	if member, ok := ctxMember(r.Context()); !ok || !roleAllowed(member.Role, "owner", "admin") {
+		writeError(w, http.StatusForbidden, "only workspace admins can archive a space")
+		return
+	}
+	// Block archiving a Space that still drives live autopilots — without this
+	// an archived Space would leave active autopilots pointing at a Space that
+	// can no longer receive work. Existing issues are intentionally NOT a
+	// blocker: archived-space issues stay readable.
+	activeAutopilots, err := h.Queries.CountActiveAutopilotsBySpace(r.Context(), db.CountActiveAutopilotsBySpaceParams{
+		WorkspaceID: wsUUID,
+		SpaceID:     spaceID,
+	})
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to validate space usage")
+		return
+	}
+	if activeAutopilots > 0 {
+		writeError(w, http.StatusConflict, "cannot archive a space used by active autopilots")
+		return
+	}
+
+	tx, err := h.TxStarter.Begin(r.Context())
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to archive space")
+		return
+	}
+	defer tx.Rollback(r.Context())
+	qtx := h.Queries.WithTx(tx)
+
+	// No space is permanently protected — instead every workspace must always
+	// keep at least one active Space. FOR UPDATE locks every active Space row
+	// for this workspace so a concurrent archive on a different Space in the
+	// same workspace serializes behind this one; without the lock, two
+	// concurrent archives of the last two Spaces could both read "2 active"
+	// and both proceed, leaving zero.
+	active, err := qtx.ListActiveWorkspaceSpacesForUpdate(r.Context(), wsUUID)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to validate space usage")
+		return
+	}
+	if len(active) <= 1 {
+		writeError(w, http.StatusConflict, "cannot archive the last active space in a workspace")
+		return
+	}
+
+	space, err := qtx.ArchiveWorkspaceSpace(r.Context(), db.ArchiveWorkspaceSpaceParams{
+		ID:          spaceID,
+		WorkspaceID: wsUUID,
+		ArchivedBy:  parseUUID(userID),
+	})
+	if err != nil {
+		writeError(w, http.StatusBadRequest, "space cannot be archived")
+		return
+	}
+	if err := tx.Commit(r.Context()); err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to archive space")
+		return
+	}
+	resp := h.withCallerMembership(r.Context(), spaceToResponse(space), space.ID, userID)
+	h.publish(protocol.EventWorkspaceUpdated, workspaceID, "member", userID, map[string]any{"space": resp})
+	writeJSON(w, http.StatusOK, resp)
+}
diff --git a/server/internal/handler/space_resolve.go b/server/internal/handler/space_resolve.go
new file mode 100644
index 0000000000..27e1e40f60
--- /dev/null
+++ b/server/internal/handler/space_resolve.go
@@ -0,0 +1,51 @@
+package handler
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/multica-ai/multica/server/internal/service"
+)
+
+// Unified, transport-facing messages for the service-layer space-resolution
+// errors. Every issue-producing handler (create, quick-create, autopilot,
+// project space lists) maps the same typed error to the same string so callers
+// see one wording per condition.
+const (
+	spaceNotFoundMessage         = "space not found in this workspace"
+	spaceArchivedMessage         = "space is archived"
+	projectSpaceAmbiguousMessage = "project has multiple spaces; specify space_id"
+)
+
+// spaceResolveMessage maps a service space-resolution error to its unified
+// message. The ambiguous case includes the candidate Space keys. Returns "" for
+// errors that are not space-resolution errors.
+func spaceResolveMessage(err error) string {
+	switch {
+	case errors.Is(err, service.ErrProjectSpaceAmbiguous):
+		var amb *service.ProjectSpaceAmbiguousError
+		if errors.As(err, &amb) {
+			return amb.Error()
+		}
+		return projectSpaceAmbiguousMessage
+	case errors.Is(err, service.ErrSpaceNotFound):
+		return spaceNotFoundMessage
+	case errors.Is(err, service.ErrSpaceArchived):
+		return spaceArchivedMessage
+	default:
+		return ""
+	}
+}
+
+// writeSpaceResolveError writes a 400 with the unified message for a
+// space-resolution error and returns true. It returns false (writing nothing)
+// for errors it does not recognize so callers can fall through to their own
+// handling.
+func writeSpaceResolveError(w http.ResponseWriter, err error) bool {
+	msg := spaceResolveMessage(err)
+	if msg == "" {
+		return false
+	}
+	writeError(w, http.StatusBadRequest, msg)
+	return true
+}
diff --git a/server/internal/handler/space_resolve_test.go b/server/internal/handler/space_resolve_test.go
new file mode 100644
index 0000000000..6119407851
--- /dev/null
+++ b/server/internal/handler/space_resolve_test.go
@@ -0,0 +1,58 @@
+package handler
+
+import (
+	"errors"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/multica-ai/multica/server/internal/service"
+)
+
+// TestSpaceResolveMessage locks the single unified wording each service
+// space-resolution error maps to, including the guided ambiguous message that
+// names the candidate Space keys. Unrecognized errors return "".
+func TestSpaceResolveMessage(t *testing.T) {
+	cases := []struct {
+		name string
+		err  error
+		want string
+	}{
+		{"not found", service.ErrSpaceNotFound, "space not found in this workspace"},
+		{"archived", service.ErrSpaceArchived, "space is archived"},
+		{
+			"ambiguous names keys",
+			&service.ProjectSpaceAmbiguousError{SpaceKeys: []string{"ENG", "GROWTH"}},
+			"project has multiple spaces (ENG, GROWTH); specify space_id",
+		},
+		{"unrelated", errors.New("boom"), ""},
+		{"nil", nil, ""},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := spaceResolveMessage(tc.err); got != tc.want {
+				t.Fatalf("spaceResolveMessage(%v) = %q, want %q", tc.err, got, tc.want)
+			}
+		})
+	}
+}
+
+// TestWriteSpaceResolveError verifies the writer emits a 400 for space-resolution
+// errors and reports false (writing nothing) for anything else so callers can
+// fall through to their own handling.
+func TestWriteSpaceResolveError(t *testing.T) {
+	rec := httptest.NewRecorder()
+	if !writeSpaceResolveError(rec, service.ErrSpaceNotFound) {
+		t.Fatal("expected writeSpaceResolveError to handle ErrSpaceNotFound")
+	}
+	if rec.Code != 400 {
+		t.Fatalf("expected 400, got %d", rec.Code)
+	}
+
+	rec = httptest.NewRecorder()
+	if writeSpaceResolveError(rec, errors.New("boom")) {
+		t.Fatal("expected writeSpaceResolveError to ignore a non-space-resolution error")
+	}
+	if rec.Code != 200 {
+		t.Fatalf("expected nothing written (default 200), got %d", rec.Code)
+	}
+}
diff --git a/server/internal/handler/squad.go b/server/internal/handler/squad.go
index 94c8ffd155..dac2d47c48 100644
--- a/server/internal/handler/squad.go
+++ b/server/internal/handler/squad.go
@@ -11,6 +11,7 @@ import (
 	"github.com/go-chi/chi/v5"
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/multica-ai/multica/server/internal/analytics"
+	"github.com/multica-ai/multica/server/internal/issueidentifier"
 	obsmetrics "github.com/multica-ai/multica/server/internal/metrics"
 	"github.com/multica-ai/multica/server/internal/util"
 	db "github.com/multica-ai/multica/server/pkg/db/generated"
@@ -588,7 +589,7 @@ func (h *Handler) ListSquadMemberStatus(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
-	prefix := h.getIssuePrefix(r.Context(), squad.WorkspaceID)
+	prefix := issueidentifier.PrefixForWorkspace(r.Context(), h.Queries, squad.WorkspaceID)
 	now := time.Now()
 
 	// Group rows by member_id while preserving the SQL ORDER BY (squad_member
@@ -1041,7 +1042,7 @@ func (h *Handler) enqueueSquadLeaderTask(ctx context.Context, issue db.Issue, tr
 
 	// Member authors are their own originator; agent-authored triggers have no
 	// request context here, so the originator is left empty (canInvokeAgent
-	// then fails closed for member/team targets — a workspace target still
+	// then fails closed for member/space targets — a workspace target still
 	// admits the agent as a workspace principal).
 	leaderOriginator := ""
 	if authorType == "member" {
diff --git a/server/internal/handler/squad_briefing_test.go b/server/internal/handler/squad_briefing_test.go
index 903d11fbf0..9e536e04b5 100644
--- a/server/internal/handler/squad_briefing_test.go
+++ b/server/internal/handler/squad_briefing_test.go
@@ -320,9 +320,9 @@ func queueSquadIssueTaskFor(t *testing.T, squadID, agentID, runtimeID string, is
 	if err := testPool.QueryRow(ctx, `
 INSERT INTO issue (
 workspace_id, title, status, priority, creator_id, creator_type,
-assignee_type, assignee_id, number, position
+assignee_type, assignee_id, number, position, space_id
 ) VALUES ($1, 'Squad briefing claim test', 'todo', 'medium', $2, 'member',
-'squad', $3, $4, 0)
+'squad', $3, $4, 0, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 RETURNING id
 `, testWorkspaceID, testUserID, squadID, issueNumber).Scan(&issueID); err != nil {
 		t.Fatalf("create squad-assigned issue: %v", err)
diff --git a/server/internal/handler/squad_comment_trigger_test.go b/server/internal/handler/squad_comment_trigger_test.go
index ae18a4037d..6a0ae2ca45 100644
--- a/server/internal/handler/squad_comment_trigger_test.go
+++ b/server/internal/handler/squad_comment_trigger_test.go
@@ -101,8 +101,8 @@ func newSquadCommentTriggerFixture(t *testing.T) squadCommentTriggerFixture {
 
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title, assignee_type, assignee_id)
-		VALUES ($1, 'member', $2, $3, 'squad', $4)
+		INSERT INTO issue (workspace_id, creator_type, creator_id, title, assignee_type, assignee_id, space_id)
+		VALUES ($1, 'member', $2, $3, 'squad', $4, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, testUserID, "squad comment trigger", squadID).Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
@@ -740,8 +740,8 @@ func TestCreateComment_SquadMentionPrivateLeaderBlocksPlainMember(t *testing.T)
 	// Create an issue.
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title)
-		VALUES ($1, 'member', $2, 'private leader squad mention test')
+		INSERT INTO issue (workspace_id, creator_type, creator_id, title, space_id)
+		VALUES ($1, 'member', $2, 'private leader squad mention test', (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, memberID).Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
@@ -808,8 +808,8 @@ func TestCreateComment_SquadMentionTriggersLeader(t *testing.T) {
 	// Create an issue NOT assigned to the squad (assigned to nobody).
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title)
-		VALUES ($1, 'member', $2, 'squad mention trigger test')
+		INSERT INTO issue (workspace_id, creator_type, creator_id, title, space_id)
+		VALUES ($1, 'member', $2, 'squad mention trigger test', (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
diff --git a/server/internal/handler/squad_id_enqueue_test.go b/server/internal/handler/squad_id_enqueue_test.go
index 256a67cb4f..902c5a20d2 100644
--- a/server/internal/handler/squad_id_enqueue_test.go
+++ b/server/internal/handler/squad_id_enqueue_test.go
@@ -43,8 +43,8 @@ func TestCreateComment_SquadMentionStampsSquadIDOnLeaderTask(t *testing.T) {
 	// produced purely by the @squad comment mention.
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title)
-		VALUES ($1, 'member', $2, 'squad_id stamp test')
+		INSERT INTO issue (workspace_id, creator_type, creator_id, title, space_id)
+		VALUES ($1, 'member', $2, 'squad_id stamp test', (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
diff --git a/server/internal/handler/squad_private_leader_test.go b/server/internal/handler/squad_private_leader_test.go
index efbd79d1f5..e429299a23 100644
--- a/server/internal/handler/squad_private_leader_test.go
+++ b/server/internal/handler/squad_private_leader_test.go
@@ -68,8 +68,8 @@ func TestUpdateIssue_SquadPrivateLeader_PlainMemberBlocked(t *testing.T) {
 	// Create an unassigned issue as workspace owner.
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title)
-		VALUES ($1, 'member', $2, 'update target')
+		INSERT INTO issue (workspace_id, creator_type, creator_id, title, space_id)
+		VALUES ($1, 'member', $2, 'update target', (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, testUserID).Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
@@ -161,8 +161,8 @@ func TestComment_SquadPrivateLeader_PlainMemberNoEnqueue(t *testing.T) {
 	// Create issue assigned to the squad as workspace owner.
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title, assignee_type, assignee_id)
-		VALUES ($1, 'member', $2, 'private leader comment test', 'squad', $3)
+		INSERT INTO issue (workspace_id, creator_type, creator_id, title, assignee_type, assignee_id, space_id)
+		VALUES ($1, 'member', $2, 'private leader comment test', 'squad', $3, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, testUserID, squadID).Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
@@ -440,8 +440,8 @@ func TestComment_SquadPrivateLeader_AgentActorAllowed(t *testing.T) {
 	// Create issue assigned to the squad.
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title, assignee_type, assignee_id)
-		VALUES ($1, 'member', $2, 'private leader agent actor test', 'squad', $3)
+		INSERT INTO issue (workspace_id, creator_type, creator_id, title, assignee_type, assignee_id, space_id)
+		VALUES ($1, 'member', $2, 'private leader agent actor test', 'squad', $3, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, testUserID, squadID).Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
diff --git a/server/internal/handler/squad_worker_comment_wakes_leader_test.go b/server/internal/handler/squad_worker_comment_wakes_leader_test.go
index 5b2d7347c4..db658ae3db 100644
--- a/server/internal/handler/squad_worker_comment_wakes_leader_test.go
+++ b/server/internal/handler/squad_worker_comment_wakes_leader_test.go
@@ -246,8 +246,8 @@ func TestCreateComment_WorkerAgentCommentWakesPrivateSquadLeader_MUL4015(t *test
 	// keeps the assign-time originator resolution to M.
 	var issueID string
 	if err := testPool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, creator_type, creator_id, title, assignee_type, assignee_id)
-		VALUES ($1, 'member', $2, 'private squad worker-comment MUL-4015', 'squad', $3)
+		INSERT INTO issue (workspace_id, creator_type, creator_id, title, assignee_type, assignee_id, space_id)
+		VALUES ($1, 'member', $2, 'private squad worker-comment MUL-4015', 'squad', $3, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1))
 		RETURNING id
 	`, testWorkspaceID, testUserID, squadID).Scan(&issueID); err != nil {
 		t.Fatalf("create private squad issue: %v", err)
diff --git a/server/internal/handler/workspace.go b/server/internal/handler/workspace.go
index ccc85b17a2..cec2a2cc6c 100644
--- a/server/internal/handler/workspace.go
+++ b/server/internal/handler/workspace.go
@@ -17,21 +17,50 @@ import (
 	"github.com/multica-ai/multica/server/pkg/protocol"
 )
 
-var nonAlpha = regexp.MustCompile(`[^a-zA-Z]`)
 var workspaceSlugPattern = regexp.MustCompile(`^[a-z0-9]+(?:-[a-z0-9]+)*$`)
+var spaceKeyPattern = regexp.MustCompile(`^[A-Z][A-Z0-9]{0,6}$`)
+var nonSpaceKeyChars = regexp.MustCompile(`[^A-Z0-9]`)
 
-// generateIssuePrefix produces a 2-5 char uppercase prefix from a workspace name.
-// Examples: "Jiayuan's Workspace" → "JIA", "My Team" → "MYT", "AB" → "AB".
-func generateIssuePrefix(name string) string {
-	letters := nonAlpha.ReplaceAllString(name, "")
-	if len(letters) == 0 {
-		return "WS"
+// reservedSpaceKeys blocks keys that would collide with static routes under
+// /space/{key} (e.g. the create-space page at /space/new). Mirrors why
+// "workspaces" is a reserved workspace slug for /workspaces/new.
+var reservedSpaceKeys = map[string]struct{}{
+	"NEW": {},
+}
+
+// defaultSpaceKeyFromSlug derives the default space key by normalizing the
+// slug: the first 7 usable characters, so workspace "naiyuan" gets NAIYUAN.
+func defaultSpaceKeyFromSlug(slug string) string {
+	key := normalizeSpaceKey(slug)
+	if key == "" {
+		return "T"
 	}
-	letters = strings.ToUpper(letters)
-	if len(letters) > 3 {
-		letters = letters[:3]
+	return key
+}
+
+// normalizeSpaceKey mirrors pg_temp.normalize_space_key in migration 131 (minus
+// the 'SPACE' fallback, which callers decide): uppercase, strip characters
+// outside [A-Z0-9], truncate to 7, and prefix digit-leading keys with 'T'.
+func normalizeSpaceKey(raw string) string {
+	key := nonSpaceKeyChars.ReplaceAllString(strings.ToUpper(strings.TrimSpace(raw)), "")
+	if len(key) > 7 {
+		key = key[:7]
 	}
-	return letters
+	if key != "" && key[0] >= '0' && key[0] <= '9' {
+		key = "T" + key
+		if len(key) > 7 {
+			key = key[:7]
+		}
+	}
+	return key
+}
+
+func validSpaceKey(key string) bool {
+	if !spaceKeyPattern.MatchString(key) {
+		return false
+	}
+	_, reserved := reservedSpaceKeys[key]
+	return !reserved
 }
 
 type WorkspaceResponse struct {
@@ -132,11 +161,12 @@ func (h *Handler) GetWorkspace(w http.ResponseWriter, r *http.Request) {
 }
 
 type CreateWorkspaceRequest struct {
-	Name        string  `json:"name"`
-	Slug        string  `json:"slug"`
-	Description *string `json:"description"`
-	Context     *string `json:"context"`
-	IssuePrefix *string `json:"issue_prefix"`
+	Name            string  `json:"name"`
+	Slug            string  `json:"slug"`
+	Description     *string `json:"description"`
+	Context         *string `json:"context"`
+	DefaultSpaceKey *string `json:"default_space_key"`
+	IssuePrefix     *string `json:"issue_prefix"`
 }
 
 func (h *Handler) CreateWorkspace(w http.ResponseWriter, r *http.Request) {
@@ -183,9 +213,16 @@ func (h *Handler) CreateWorkspace(w http.ResponseWriter, r *http.Request) {
 	}
 	defer tx.Rollback(r.Context())
 
-	issuePrefix := generateIssuePrefix(req.Name)
+	defaultSpaceKey := defaultSpaceKeyFromSlug(req.Slug)
 	if req.IssuePrefix != nil && strings.TrimSpace(*req.IssuePrefix) != "" {
-		issuePrefix = strings.ToUpper(strings.TrimSpace(*req.IssuePrefix))
+		defaultSpaceKey = normalizeSpaceKey(*req.IssuePrefix)
+	}
+	if req.DefaultSpaceKey != nil && strings.TrimSpace(*req.DefaultSpaceKey) != "" {
+		defaultSpaceKey = normalizeSpaceKey(*req.DefaultSpaceKey)
+	}
+	if !validSpaceKey(defaultSpaceKey) {
+		writeError(w, http.StatusBadRequest, "default_space_key must match ^[A-Z][A-Z0-9]{0,6}$")
+		return
 	}
 
 	qtx := h.Queries.WithTx(tx)
@@ -194,7 +231,7 @@ func (h *Handler) CreateWorkspace(w http.ResponseWriter, r *http.Request) {
 		Slug:        req.Slug,
 		Description: ptrToText(req.Description),
 		Context:     ptrToText(req.Context),
-		IssuePrefix: issuePrefix,
+		IssuePrefix: defaultSpaceKey,
 	})
 	if err != nil {
 		if isUniqueViolation(err) {
@@ -215,6 +252,32 @@ func (h *Handler) CreateWorkspace(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	space, err := qtx.CreateWorkspaceSpace(r.Context(), db.CreateWorkspaceSpaceParams{
+		WorkspaceID: ws.ID,
+		Name:        ws.Name,
+		Key:         defaultSpaceKey,
+		Description: pgtype.Text{},
+		// No icon on purpose: the default space renders SpaceIcon's colored
+		// fallback block, which is the designated landing spot for the
+		// planned per-space colors (see SpaceIcon).
+		Icon:      pgtype.Text{},
+		CreatedBy: parseUUID(userID),
+	})
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to create default space: "+err.Error())
+		return
+	}
+	if err := qtx.AddWorkspaceSpaceMember(r.Context(), db.AddWorkspaceSpaceMemberParams{
+		WorkspaceID: ws.ID,
+		SpaceID:     space.ID,
+		UserID:      parseUUID(userID),
+		Role:        "lead",
+		SortOrder:   1,
+	}); err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to add default space member: "+err.Error())
+		return
+	}
+
 	// NOTE: CreateWorkspace deliberately does NOT mark the user as
 	// onboarded. The `onboarded_at` flag is owned by CompleteOnboarding
 	// (Step 3 of the flow) and by AcceptInvitation (invitee joining an
@@ -333,17 +396,61 @@ func (h *Handler) UpdateWorkspace(w http.ResponseWriter, r *http.Request) {
 		}
 		params.Repos = reposJSON
 	}
+	var updateDefaultSpaceKey bool
 	if req.IssuePrefix != nil {
-		prefix := strings.ToUpper(strings.TrimSpace(*req.IssuePrefix))
+		prefix := normalizeSpaceKey(*req.IssuePrefix)
 		if prefix != "" {
+			if !validSpaceKey(prefix) {
+				writeError(w, http.StatusBadRequest, "issue_prefix must match ^[A-Z][A-Z0-9]{0,6}$")
+				return
+			}
 			params.IssuePrefix = pgtype.Text{String: prefix, Valid: true}
+			updateDefaultSpaceKey = true
 		}
 	}
 	if req.AvatarURL != nil {
 		params.AvatarUrl = pgtype.Text{String: *req.AvatarURL, Valid: true}
 	}
 
-	ws, err := h.Queries.UpdateWorkspace(r.Context(), params)
+	var ws db.Workspace
+	var err error
+	if updateDefaultSpaceKey {
+		tx, txErr := h.TxStarter.Begin(r.Context())
+		if txErr != nil {
+			writeError(w, http.StatusInternalServerError, "failed to start transaction")
+			return
+		}
+		defer tx.Rollback(r.Context())
+		qtx := h.Queries.WithTx(tx)
+
+		defaultSpace, spaceErr := qtx.GetDefaultWorkspaceSpace(r.Context(), idUUID)
+		if spaceErr != nil {
+			writeError(w, http.StatusBadRequest, "default space not found")
+			return
+		}
+		if _, spaceErr := updateWorkspaceSpaceLocked(r.Context(), qtx, db.UpdateWorkspaceSpaceParams{
+			ID:          defaultSpace.ID,
+			WorkspaceID: idUUID,
+			Key:         params.IssuePrefix,
+		}); spaceErr != nil {
+			if spaceErr == errSpaceKeyFrozen {
+				writeError(w, http.StatusConflict, "space identifier cannot be changed after issues have been created")
+				return
+			}
+			if isUniqueViolation(spaceErr) || isCheckViolation(spaceErr) {
+				writeError(w, http.StatusBadRequest, "issue_prefix is invalid or already used")
+				return
+			}
+			writeError(w, http.StatusInternalServerError, "failed to update default space key")
+			return
+		}
+		ws, err = qtx.UpdateWorkspace(r.Context(), params)
+		if err == nil {
+			err = tx.Commit(r.Context())
+		}
+	} else {
+		ws, err = h.Queries.UpdateWorkspace(r.Context(), params)
+	}
 	if err != nil {
 		slog.Warn("update workspace failed", append(logger.RequestAttrs(r), "error", err, "workspace_id", id)...)
 		writeError(w, http.StatusInternalServerError, "failed to update workspace: "+err.Error())
@@ -498,7 +605,18 @@ func (h *Handler) CreateMember(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	member, err := h.Queries.CreateMember(r.Context(), db.CreateMemberParams{
+	// Member creation + default-space join are atomic: the sidebar shows
+	// joined spaces only, so a member outside every space would see an empty
+	// Spaces section and issue creation would lose its per-user default.
+	tx, err := h.TxStarter.Begin(r.Context())
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to create member")
+		return
+	}
+	defer tx.Rollback(r.Context())
+	qtx := h.Queries.WithTx(tx)
+
+	member, err := qtx.CreateMember(r.Context(), db.CreateMemberParams{
 		WorkspaceID: requester.WorkspaceID,
 		UserID:      user.ID,
 		Role:        role,
@@ -512,6 +630,25 @@ func (h *Handler) CreateMember(w http.ResponseWriter, r *http.Request) {
 		writeError(w, http.StatusInternalServerError, "failed to create member")
 		return
 	}
+	// Hard failure (rolls the member insert back) — a missing default space is
+	// data corruption, and silently skipping would mint a space-less member.
+	defSpace, err := qtx.GetDefaultWorkspaceSpace(r.Context(), requester.WorkspaceID)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to resolve default space")
+		return
+	}
+	spaceRole := "member"
+	if role == "owner" || role == "admin" {
+		spaceRole = "lead"
+	}
+	if _, err := addSpaceMember(r.Context(), qtx, requester.WorkspaceID, defSpace.ID, user.ID, spaceRole); err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to join default space")
+		return
+	}
+	if err := tx.Commit(r.Context()); err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to create member")
+		return
+	}
 
 	slog.Info("member added", append(logger.RequestAttrs(r), "member_id", uuidToString(member.ID), "workspace_id", workspaceID, "email", email, "role", role)...)
 	userID := requestUserID(r)
diff --git a/server/internal/integrations/channel/engine/resolvers.go b/server/internal/integrations/channel/engine/resolvers.go
index 80b1d76a6c..f62e255f6b 100644
--- a/server/internal/integrations/channel/engine/resolvers.go
+++ b/server/internal/integrations/channel/engine/resolvers.go
@@ -223,4 +223,6 @@ type TaskEnqueuer interface {
 type SessionReader interface {
 	GetChatSession(ctx context.Context, id pgtype.UUID) (db.ChatSession, error)
 	GetWorkspace(ctx context.Context, id pgtype.UUID) (db.Workspace, error)
+	GetWorkspaceSpace(ctx context.Context, arg db.GetWorkspaceSpaceParams) (db.WorkspaceSpace, error)
+	GetDefaultWorkspaceSpace(ctx context.Context, workspaceID pgtype.UUID) (db.WorkspaceSpace, error)
 }
diff --git a/server/internal/integrations/channel/engine/router.go b/server/internal/integrations/channel/engine/router.go
index 1335ea5487..76e8870483 100644
--- a/server/internal/integrations/channel/engine/router.go
+++ b/server/internal/integrations/channel/engine/router.go
@@ -11,6 +11,7 @@ import (
 	"github.com/jackc/pgx/v5/pgtype"
 
 	"github.com/multica-ai/multica/server/internal/integrations/channel"
+	"github.com/multica-ai/multica/server/internal/issueidentifier"
 	"github.com/multica-ai/multica/server/internal/service"
 )
 
@@ -299,11 +300,7 @@ func (r *Router) processClaimed(ctx context.Context, set ResolverSet, msg channe
 		res.IssueID = issueRes.Issue.ID
 		res.IssueNumber = issueRes.Issue.Number
 		res.IssueTitle = issueRes.Issue.Title
-		if ws, werr := r.reader.GetWorkspace(ctx, inst.WorkspaceID); werr == nil && ws.IssuePrefix != "" {
-			res.IssueIdentifier = fmt.Sprintf("%s-%d", ws.IssuePrefix, issueRes.Issue.Number)
-		} else {
-			res.IssueIdentifier = fmt.Sprintf("#%d", issueRes.Issue.Number)
-		}
+		res.IssueIdentifier = issueidentifier.ForIssue(ctx, r.reader, issueRes.Issue)
 	}
 
 	// 8. Debounce the run trigger. The synchronous outcome is OutcomeIngested
diff --git a/server/internal/integrations/channel/engine/router_test.go b/server/internal/integrations/channel/engine/router_test.go
index 5afe8b8a7d..91b809b961 100644
--- a/server/internal/integrations/channel/engine/router_test.go
+++ b/server/internal/integrations/channel/engine/router_test.go
@@ -173,9 +173,11 @@ func (f *fakeTasks) wasCalled() bool { f.mu.Lock(); defer f.mu.Unlock(); return
 func (f *fakeTasks) freshArg() bool  { f.mu.Lock(); defer f.mu.Unlock(); return f.forceFresh }
 
 type fakeReader struct {
-	session db.ChatSession
-	ws      db.Workspace
-	sessErr error
+	session  db.ChatSession
+	ws       db.Workspace
+	space    db.WorkspaceSpace
+	spaceErr error
+	sessErr  error
 }
 
 func (f *fakeReader) GetChatSession(_ context.Context, _ pgtype.UUID) (db.ChatSession, error) {
@@ -184,6 +186,18 @@ func (f *fakeReader) GetChatSession(_ context.Context, _ pgtype.UUID) (db.ChatSe
 func (f *fakeReader) GetWorkspace(_ context.Context, _ pgtype.UUID) (db.Workspace, error) {
 	return f.ws, nil
 }
+func (f *fakeReader) GetWorkspaceSpace(_ context.Context, _ db.GetWorkspaceSpaceParams) (db.WorkspaceSpace, error) {
+	if f.spaceErr != nil {
+		return db.WorkspaceSpace{}, f.spaceErr
+	}
+	return f.space, nil
+}
+func (f *fakeReader) GetDefaultWorkspaceSpace(_ context.Context, _ pgtype.UUID) (db.WorkspaceSpace, error) {
+	if f.spaceErr != nil {
+		return db.WorkspaceSpace{}, f.spaceErr
+	}
+	return f.space, nil
+}
 
 // ---- harness ----
 
@@ -400,7 +414,15 @@ func TestRouter_ClaimLost_Drops(t *testing.T) {
 func TestRouter_IssueCommand_Creates(t *testing.T) {
 	h := newHarness(t)
 	h.binder.appendResult = AppendResult{DedupMarked: true, IssueCommand: &IssueCommand{Title: "Fix login", Description: "details"}}
-	h.issues.result = service.IssueCreateResult{Issue: db.Issue{ID: uuidFromString(t, "77777777-7777-7777-7777-777777777777"), Number: 42, Title: "Fix login"}}
+	spaceID := uuidFromString(t, "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
+	h.reader.space = db.WorkspaceSpace{ID: spaceID, WorkspaceID: h.inst.inst.WorkspaceID, Key: "ENG"}
+	h.issues.result = service.IssueCreateResult{Issue: db.Issue{
+		ID:          uuidFromString(t, "77777777-7777-7777-7777-777777777777"),
+		WorkspaceID: h.inst.inst.WorkspaceID,
+		SpaceID:     spaceID,
+		Number:      42,
+		Title:       "Fix login",
+	}}
 	if err := h.router.Handle(context.Background(), p2pMessage(t)); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -412,13 +434,13 @@ func TestRouter_IssueCommand_Creates(t *testing.T) {
 	}
 	if !waitFor(time.Second, func() bool {
 		for _, r := range h.replier.calls() {
-			if r.IssueIdentifier == "MUL-42" && r.IssueTitle == "Fix login" {
+			if r.IssueIdentifier == "ENG-42" && r.IssueTitle == "Fix login" {
 				return true
 			}
 		}
 		return false
 	}) {
-		t.Fatalf("expected an issue-created reply with the workspace-qualified identifier")
+		t.Fatalf("expected an issue-created reply with the space-qualified identifier")
 	}
 }
 
diff --git a/server/internal/integrations/slack/slash_command.go b/server/internal/integrations/slack/slash_command.go
index ac9c76695c..5b15002db8 100644
--- a/server/internal/integrations/slack/slash_command.go
+++ b/server/internal/integrations/slack/slash_command.go
@@ -66,7 +66,7 @@ type slashQueries interface {
 // command needs to hand the invoker's prompt to the agent. *service.TaskService
 // satisfies it; tests supply a fake.
 type quickCreateEnqueuer interface {
-	EnqueueQuickCreateTask(ctx context.Context, workspaceID, requesterID, agentID, squadID pgtype.UUID, prompt string, projectID, parentIssueID pgtype.UUID, attachmentIDs []pgtype.UUID) (db.AgentTaskQueue, error)
+	EnqueueQuickCreateTask(ctx context.Context, workspaceID, requesterID, agentID, squadID pgtype.UUID, prompt string, projectID, parentIssueID, teamID pgtype.UUID, attachmentIDs []pgtype.UUID) (db.AgentTaskQueue, error)
 }
 
 // SlashCommandProcessor handles the Slack `/issue` slash command end to end.
@@ -193,6 +193,7 @@ func (p *SlashCommandProcessor) process(ctx context.Context, cmd slack.SlashComm
 		prompt,
 		pgtype.UUID{}, // no project
 		pgtype.UUID{}, // no parent issue
+		pgtype.UUID{}, // no space
 		nil,           // no attachments
 	); err != nil {
 		p.logger.WarnContext(ctx, "slack slash command: enqueue quick-create failed",
diff --git a/server/internal/integrations/slack/slash_command_test.go b/server/internal/integrations/slack/slash_command_test.go
index 9e6e19ebee..ba34a67da3 100644
--- a/server/internal/integrations/slack/slash_command_test.go
+++ b/server/internal/integrations/slack/slash_command_test.go
@@ -52,7 +52,7 @@ type fakeQuickCreate struct {
 	prompt      string
 }
 
-func (f *fakeQuickCreate) EnqueueQuickCreateTask(_ context.Context, workspaceID, requesterID, agentID, squadID pgtype.UUID, prompt string, _, _ pgtype.UUID, _ []pgtype.UUID) (db.AgentTaskQueue, error) {
+func (f *fakeQuickCreate) EnqueueQuickCreateTask(_ context.Context, workspaceID, requesterID, agentID, squadID pgtype.UUID, prompt string, _, _, _ pgtype.UUID, _ []pgtype.UUID) (db.AgentTaskQueue, error) {
 	f.calls++
 	f.workspaceID = workspaceID
 	f.requesterID = requesterID
diff --git a/server/internal/issueguard/duplicate.go b/server/internal/issueguard/duplicate.go
index 23085c129e..07907d9982 100644
--- a/server/internal/issueguard/duplicate.go
+++ b/server/internal/issueguard/duplicate.go
@@ -45,6 +45,7 @@ func LockAndFindActiveDuplicate(
 	ctx context.Context,
 	q *db.Queries,
 	workspaceID pgtype.UUID,
+	spaceID pgtype.UUID,
 	projectID pgtype.UUID,
 	parentIssueID pgtype.UUID,
 	title string,
@@ -54,7 +55,7 @@ func LockAndFindActiveDuplicate(
 	if normalizedTitle == "" {
 		return db.Issue{}, false, nil
 	}
-	if err := q.LockIssueDuplicateKey(ctx, lockKey(workspaceID, projectID, parentIssueID, normalizedTitle)); err != nil {
+	if err := q.LockIssueDuplicateKey(ctx, lockKey(workspaceID, spaceID, projectID, parentIssueID, normalizedTitle)); err != nil {
 		return db.Issue{}, false, err
 	}
 	if allowDuplicate {
@@ -63,6 +64,7 @@ func LockAndFindActiveDuplicate(
 
 	duplicate, err := q.FindActiveDuplicateIssue(ctx, db.FindActiveDuplicateIssueParams{
 		WorkspaceID:     workspaceID,
+		SpaceID:         spaceID,
 		ProjectID:       projectID,
 		ParentIssueID:   parentIssueID,
 		NormalizedTitle: normalizedTitle,
@@ -109,10 +111,11 @@ func LockAndFindRecentAutopilotDuplicate(
 	return duplicate, true, nil
 }
 
-func lockKey(workspaceID, projectID, parentIssueID pgtype.UUID, normalizedTitle string) string {
+func lockKey(workspaceID, spaceID, projectID, parentIssueID pgtype.UUID, normalizedTitle string) string {
 	return strings.Join([]string{
 		"issue-active-duplicate",
 		util.UUIDToString(workspaceID),
+		util.UUIDToString(spaceID),
 		util.UUIDToString(projectID),
 		util.UUIDToString(parentIssueID),
 		normalizedTitle,
diff --git a/server/internal/issueidentifier/identifier.go b/server/internal/issueidentifier/identifier.go
new file mode 100644
index 0000000000..4fc7db47eb
--- /dev/null
+++ b/server/internal/issueidentifier/identifier.go
@@ -0,0 +1,141 @@
+// Package issueidentifier is the single authority for turning an issue into its
+// human-readable "PREFIX-NUMBER" identifier and for resolving the bare prefix
+// (Space key) of an issue or workspace.
+//
+// It replaces four drifted copies of the same fallback chain that previously
+// lived in the handler, task service, autopilot service, and channel router.
+// The chain is, in order:
+//
+//  1. the issue's own Space key (when the issue has a Space);
+//  2. the workspace's default Space key;
+//  3. the legacy workspace issue_prefix (compatibility window);
+//  4. a prefix generated from the workspace name.
+//
+// Step 4 is the defensive fallback-of-last-resort: callers never emit "-42" or
+// "#42" for an issue whose Space/workspace lookups all failed.
+package issueidentifier
+
+import (
+	"context"
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/jackc/pgx/v5/pgtype"
+	db "github.com/multica-ai/multica/server/pkg/db/generated"
+)
+
+// Queries is the read surface the resolver needs. Both *db.Queries and the
+// channel engine's SessionReader satisfy it.
+type Queries interface {
+	GetWorkspaceSpace(ctx context.Context, arg db.GetWorkspaceSpaceParams) (db.WorkspaceSpace, error)
+	GetDefaultWorkspaceSpace(ctx context.Context, workspaceID pgtype.UUID) (db.WorkspaceSpace, error)
+	GetWorkspace(ctx context.Context, id pgtype.UUID) (db.Workspace, error)
+}
+
+var nonAlpha = regexp.MustCompile(`[^a-zA-Z]`)
+
+// GeneratePrefix produces a 2-3 char uppercase prefix from a workspace name.
+// Examples: "Jiayuan's Workspace" -> "JIA", "My Space" -> "MYT", "AB" -> "AB".
+func GeneratePrefix(name string) string {
+	letters := nonAlpha.ReplaceAllString(name, "")
+	if len(letters) == 0 {
+		return "WS"
+	}
+	letters = strings.ToUpper(letters)
+	if len(letters) > 3 {
+		letters = letters[:3]
+	}
+	return letters
+}
+
+// PrefixForIssue returns the identifier prefix (Space key) for a single issue,
+// following the full fallback chain.
+func PrefixForIssue(ctx context.Context, q Queries, issue db.Issue) string {
+	if issue.SpaceID.Valid {
+		space, err := q.GetWorkspaceSpace(ctx, db.GetWorkspaceSpaceParams{
+			ID:          issue.SpaceID,
+			WorkspaceID: issue.WorkspaceID,
+		})
+		if err == nil && space.Key != "" {
+			return space.Key
+		}
+	}
+	return PrefixForWorkspace(ctx, q, issue.WorkspaceID)
+}
+
+// PrefixForWorkspace returns the workspace-level identifier prefix: the default
+// Space key, then the legacy issue_prefix, then a generated prefix.
+func PrefixForWorkspace(ctx context.Context, q Queries, workspaceID pgtype.UUID) string {
+	space, err := q.GetDefaultWorkspaceSpace(ctx, workspaceID)
+	if err == nil && space.Key != "" {
+		return space.Key
+	}
+	ws, err := q.GetWorkspace(ctx, workspaceID)
+	if err != nil {
+		return ""
+	}
+	if ws.IssuePrefix != "" {
+		return ws.IssuePrefix
+	}
+	return GeneratePrefix(ws.Name)
+}
+
+// ForIssue returns the full "PREFIX-NUMBER" identifier for an issue.
+func ForIssue(ctx context.Context, q Queries, issue db.Issue) string {
+	return fmt.Sprintf("%s-%d", PrefixForIssue(ctx, q, issue), issue.Number)
+}
+
+// Resolver memoizes Space-key lookups so list/batch paths that resolve
+// identifiers for many issues avoid a per-row GetWorkspaceSpace query. It is not
+// safe for concurrent use; construct one per request/loop.
+type Resolver struct {
+	q         Queries
+	spaceKeys map[pgtype.UUID]string // resolved Space ID -> Space key ("" = lookup failed/empty)
+	wsPrefix  map[pgtype.UUID]string // workspace ID -> fallback prefix
+}
+
+// NewResolver returns a memoizing Resolver over the given queries.
+func NewResolver(q Queries) *Resolver {
+	return &Resolver{
+		q:         q,
+		spaceKeys: make(map[pgtype.UUID]string),
+		wsPrefix:  make(map[pgtype.UUID]string),
+	}
+}
+
+// PrefixForIssue mirrors the package-level function but caches Space and
+// workspace lookups across calls on the same Resolver.
+func (r *Resolver) PrefixForIssue(ctx context.Context, issue db.Issue) string {
+	if issue.SpaceID.Valid {
+		if key := r.spaceKey(ctx, issue.SpaceID, issue.WorkspaceID); key != "" {
+			return key
+		}
+	}
+	return r.prefixForWorkspace(ctx, issue.WorkspaceID)
+}
+
+func (r *Resolver) spaceKey(ctx context.Context, spaceID, workspaceID pgtype.UUID) string {
+	if key, ok := r.spaceKeys[spaceID]; ok {
+		return key
+	}
+	key := ""
+	space, err := r.q.GetWorkspaceSpace(ctx, db.GetWorkspaceSpaceParams{
+		ID:          spaceID,
+		WorkspaceID: workspaceID,
+	})
+	if err == nil {
+		key = space.Key
+	}
+	r.spaceKeys[spaceID] = key
+	return key
+}
+
+func (r *Resolver) prefixForWorkspace(ctx context.Context, workspaceID pgtype.UUID) string {
+	if prefix, ok := r.wsPrefix[workspaceID]; ok {
+		return prefix
+	}
+	prefix := PrefixForWorkspace(ctx, r.q, workspaceID)
+	r.wsPrefix[workspaceID] = prefix
+	return prefix
+}
diff --git a/server/internal/issueidentifier/identifier_test.go b/server/internal/issueidentifier/identifier_test.go
new file mode 100644
index 0000000000..4b9c5c3a8e
--- /dev/null
+++ b/server/internal/issueidentifier/identifier_test.go
@@ -0,0 +1,353 @@
+package issueidentifier
+
+import (
+	"context"
+	"errors"
+	"regexp"
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5/pgtype"
+	db "github.com/multica-ai/multica/server/pkg/db/generated"
+)
+
+// fakeQueries implements Queries entirely in memory, with call counters so
+// Resolver memoization tests can assert a lookup happened at most once.
+type fakeQueries struct {
+	// spaces is keyed by space ID. GetWorkspaceSpace additionally checks that
+	// the stored space's WorkspaceID matches the requested WorkspaceID, the
+	// same way the real "WHERE id = $1 AND workspace_id = $2" query would.
+	spaces         map[[16]byte]db.WorkspaceSpace
+	spaceCalls     int
+	defaultSpaces  map[[16]byte]db.WorkspaceSpace // keyed by workspace ID
+	defaultCalls   int
+	workspaces     map[[16]byte]db.Workspace
+	workspaceCalls int
+}
+
+func newFakeQueries() *fakeQueries {
+	return &fakeQueries{
+		spaces:        make(map[[16]byte]db.WorkspaceSpace),
+		defaultSpaces: make(map[[16]byte]db.WorkspaceSpace),
+		workspaces:    make(map[[16]byte]db.Workspace),
+	}
+}
+
+var errNotFound = errors.New("not found")
+
+func (f *fakeQueries) GetWorkspaceSpace(_ context.Context, arg db.GetWorkspaceSpaceParams) (db.WorkspaceSpace, error) {
+	f.spaceCalls++
+	space, ok := f.spaces[arg.ID.Bytes]
+	if !ok || space.WorkspaceID.Bytes != arg.WorkspaceID.Bytes {
+		return db.WorkspaceSpace{}, errNotFound
+	}
+	return space, nil
+}
+
+func (f *fakeQueries) GetDefaultWorkspaceSpace(_ context.Context, workspaceID pgtype.UUID) (db.WorkspaceSpace, error) {
+	f.defaultCalls++
+	space, ok := f.defaultSpaces[workspaceID.Bytes]
+	if !ok {
+		return db.WorkspaceSpace{}, errNotFound
+	}
+	return space, nil
+}
+
+func (f *fakeQueries) GetWorkspace(_ context.Context, id pgtype.UUID) (db.Workspace, error) {
+	f.workspaceCalls++
+	ws, ok := f.workspaces[id.Bytes]
+	if !ok {
+		return db.Workspace{}, errNotFound
+	}
+	return ws, nil
+}
+
+func newUUID(t *testing.T) pgtype.UUID {
+	t.Helper()
+	u, err := uuid.NewRandom()
+	if err != nil {
+		t.Fatalf("uuid.NewRandom: %v", err)
+	}
+	return pgtype.UUID{Bytes: u, Valid: true}
+}
+
+// TestGeneratePrefix covers the pure name -> prefix derivation: strip
+// non-ASCII-letters, uppercase, truncate to 3, fall back to "WS" when nothing
+// usable remains. This function is unrelated to the workspace_space CHECK
+// constraint's normalize_space_key (migration 131) — it keeps digits out
+// entirely and falls back to "WS", not "SPACE" — so cases below assert only
+// what identifier.go itself does, not the migration's SQL semantics.
+func TestGeneratePrefix(t *testing.T) {
+	tests := []struct {
+		name string
+		in   string
+		want string
+	}{
+		{"two words with apostrophe and space", "Jiayuan's Workspace", "JIA"},
+		{"two words", "My Space", "MYS"},
+		{"already short stays as-is", "AB", "AB"},
+		{"single letter stays as-is", "X", "X"},
+		{"empty string falls back to WS", "", "WS"},
+		{"digits and symbols only fall back to WS", "123!@#", "WS"},
+		{"whitespace only falls back to WS", "   ", "WS"},
+		{"non-ASCII letters are stripped, falls back to WS", "日本語", "WS"},
+		{"mixed non-ASCII and ASCII keeps only ASCII letters", "日本Space", "SPA"},
+		{"long single word truncates to first three letters", "Supercalifragilisticexpialidocious", "SUP"},
+		{"hyphen and underscore are stripped", "Multi-Ca_Workspace", "MUL"},
+		{"leading digits are stripped, not just non-leading", "42Widgets", "WID"},
+		{"already uppercase truncates to three", "ACME", "ACM"},
+		{"lowercase word is uppercased and truncated", "widgets", "WID"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := GeneratePrefix(tt.in)
+			if got != tt.want {
+				t.Errorf("GeneratePrefix(%q) = %q, want %q", tt.in, got, tt.want)
+			}
+		})
+	}
+}
+
+// TestPrefixForIssue_UsesSpaceKeyWhenSpaceValidAndFound is step 1 of the
+// fallback chain: an issue with a valid, resolvable Space uses that Space's key
+// and never touches the workspace-level fallbacks.
+func TestPrefixForIssue_UsesSpaceKeyWhenSpaceValidAndFound(t *testing.T) {
+	wsID := newUUID(t)
+	spaceID := newUUID(t)
+	f := newFakeQueries()
+	f.spaces[spaceID.Bytes] = db.WorkspaceSpace{ID: spaceID, WorkspaceID: wsID, Key: "ACME"}
+	// If the chain fell through to workspace level it would find this and
+	// the test would still (wrongly) pass, so also make it wrong to catch
+	// a chain that skips the Space step.
+	f.defaultSpaces[wsID.Bytes] = db.WorkspaceSpace{Key: "WRONG"}
+
+	issue := db.Issue{SpaceID: spaceID, WorkspaceID: wsID}
+	got := PrefixForIssue(context.Background(), f, issue)
+	if got != "ACME" {
+		t.Errorf("PrefixForIssue() = %q, want %q (space key)", got, "ACME")
+	}
+}
+
+// TestPrefixForIssue_FallsBackToWorkspaceWhenSpaceIDInvalid is step 2: an
+// issue with no Space (SpaceID.Valid == false) skips the Space lookup entirely
+// and resolves via PrefixForWorkspace.
+func TestPrefixForIssue_FallsBackToWorkspaceWhenSpaceIDInvalid(t *testing.T) {
+	wsID := newUUID(t)
+	f := newFakeQueries()
+	f.defaultSpaces[wsID.Bytes] = db.WorkspaceSpace{Key: "DEFT"}
+
+	issue := db.Issue{WorkspaceID: wsID} // SpaceID left zero-value: Valid == false
+	got := PrefixForIssue(context.Background(), f, issue)
+	if got != "DEFT" {
+		t.Errorf("PrefixForIssue() = %q, want %q (default space key)", got, "DEFT")
+	}
+	if f.spaceCalls != 0 {
+		t.Errorf("GetWorkspaceSpace called %d times, want 0 for an issue with no Space", f.spaceCalls)
+	}
+}
+
+// TestPrefixForIssue_FallsBackToWorkspaceWhenSpaceLookupFails covers a Space
+// that is set on the issue but no longer resolvable (deleted/cross-workspace
+// row) — the chain must still fall back to workspace level rather than
+// propagate the error or return an empty prefix.
+func TestPrefixForIssue_FallsBackToWorkspaceWhenSpaceLookupFails(t *testing.T) {
+	wsID := newUUID(t)
+	danglingSpaceID := newUUID(t)
+	f := newFakeQueries()
+	f.defaultSpaces[wsID.Bytes] = db.WorkspaceSpace{Key: "DEFT"}
+	// danglingSpaceID is intentionally absent from f.spaces.
+
+	issue := db.Issue{SpaceID: danglingSpaceID, WorkspaceID: wsID}
+	got := PrefixForIssue(context.Background(), f, issue)
+	if got != "DEFT" {
+		t.Errorf("PrefixForIssue() = %q, want %q (default space key) when Space lookup fails", got, "DEFT")
+	}
+}
+
+// TestPrefixForIssue_FallsBackToWorkspaceWhenSpaceKeyEmpty covers a Space row
+// that resolves successfully but has an empty key (defensive against bad
+// data), which must be treated the same as "not found".
+func TestPrefixForIssue_FallsBackToWorkspaceWhenSpaceKeyEmpty(t *testing.T) {
+	wsID := newUUID(t)
+	spaceID := newUUID(t)
+	f := newFakeQueries()
+	f.spaces[spaceID.Bytes] = db.WorkspaceSpace{ID: spaceID, WorkspaceID: wsID, Key: ""}
+	f.defaultSpaces[wsID.Bytes] = db.WorkspaceSpace{Key: "DEFT"}
+
+	issue := db.Issue{SpaceID: spaceID, WorkspaceID: wsID}
+	got := PrefixForIssue(context.Background(), f, issue)
+	if got != "DEFT" {
+		t.Errorf("PrefixForIssue() = %q, want %q (default space key) when Space key is empty", got, "DEFT")
+	}
+}
+
+// TestPrefixForWorkspace_UsesDefaultSpaceKeyWhenFound is step 2 in isolation.
+func TestPrefixForWorkspace_UsesDefaultSpaceKeyWhenFound(t *testing.T) {
+	wsID := newUUID(t)
+	f := newFakeQueries()
+	f.defaultSpaces[wsID.Bytes] = db.WorkspaceSpace{Key: "DEFT"}
+	f.workspaces[wsID.Bytes] = db.Workspace{ID: wsID, Name: "Ignored Workspace", IssuePrefix: "IGN"}
+
+	got := PrefixForWorkspace(context.Background(), f, wsID)
+	if got != "DEFT" {
+		t.Errorf("PrefixForWorkspace() = %q, want %q (default space key)", got, "DEFT")
+	}
+}
+
+// TestPrefixForWorkspace_FallsBackToLegacyIssuePrefixWhenNoDefaultSpace is
+// step 3: no default Space exists (e.g. pre-migration workspace), so the
+// legacy workspace.issue_prefix compatibility column is used.
+func TestPrefixForWorkspace_FallsBackToLegacyIssuePrefixWhenNoDefaultSpace(t *testing.T) {
+	wsID := newUUID(t)
+	f := newFakeQueries()
+	f.workspaces[wsID.Bytes] = db.Workspace{ID: wsID, Name: "Ignored Name", IssuePrefix: "LEGACY"}
+
+	got := PrefixForWorkspace(context.Background(), f, wsID)
+	if got != "LEGACY" {
+		t.Errorf("PrefixForWorkspace() = %q, want %q (legacy issue_prefix)", got, "LEGACY")
+	}
+}
+
+// TestPrefixForWorkspace_FallsBackToGeneratePrefixWhenNoIssuePrefix is step 4,
+// the fallback-of-last-resort: no default Space and no legacy issue_prefix.
+func TestPrefixForWorkspace_FallsBackToGeneratePrefixWhenNoIssuePrefix(t *testing.T) {
+	wsID := newUUID(t)
+	f := newFakeQueries()
+	f.workspaces[wsID.Bytes] = db.Workspace{ID: wsID, Name: "Jiayuan's Workspace", IssuePrefix: ""}
+
+	got := PrefixForWorkspace(context.Background(), f, wsID)
+	want := GeneratePrefix("Jiayuan's Workspace")
+	if got != want {
+		t.Errorf("PrefixForWorkspace() = %q, want %q (GeneratePrefix fallback)", got, want)
+	}
+}
+
+// TestPrefixForWorkspace_ReturnsEmptyWhenWorkspaceLookupFails documents the
+// one case where the chain gives up: no default Space AND the workspace row
+// itself cannot be read (e.g. deleted workspace). Callers must be defensive
+// about an empty prefix rather than the chain fabricating one.
+func TestPrefixForWorkspace_ReturnsEmptyWhenWorkspaceLookupFails(t *testing.T) {
+	wsID := newUUID(t) // absent from both f.defaultSpaces and f.workspaces
+	f := newFakeQueries()
+
+	got := PrefixForWorkspace(context.Background(), f, wsID)
+	if got != "" {
+		t.Errorf("PrefixForWorkspace() = %q, want empty string when workspace lookup also fails", got)
+	}
+}
+
+// TestForIssue_FormatsAsPrefixDashNumber pins the "PREFIX-NUMBER" identifier
+// shape across both a Space-key resolution and a fully-fallen-back
+// GeneratePrefix resolution, so an issue whose Space/workspace lookups all
+// fail still never renders as a bare "-42" or "#42".
+func TestForIssue_FormatsAsPrefixDashNumber(t *testing.T) {
+	identifierShape := regexp.MustCompile(`^[A-Z0-9]+-[0-9]+$`)
+
+	t.Run("space key resolves", func(t *testing.T) {
+		wsID := newUUID(t)
+		spaceID := newUUID(t)
+		f := newFakeQueries()
+		f.spaces[spaceID.Bytes] = db.WorkspaceSpace{ID: spaceID, WorkspaceID: wsID, Key: "ACME"}
+		issue := db.Issue{SpaceID: spaceID, WorkspaceID: wsID, Number: 42}
+
+		got := ForIssue(context.Background(), f, issue)
+		if got != "ACME-42" {
+			t.Errorf("ForIssue() = %q, want %q", got, "ACME-42")
+		}
+		if !identifierShape.MatchString(got) {
+			t.Errorf("ForIssue() = %q does not match PREFIX-NUMBER shape", got)
+		}
+	})
+
+	t.Run("every lookup fails, still no bare -42 or #42", func(t *testing.T) {
+		wsID := newUUID(t)
+		danglingSpaceID := newUUID(t)
+		f := newFakeQueries()
+		f.workspaces[wsID.Bytes] = db.Workspace{ID: wsID, Name: "Jiayuan's Workspace"}
+		issue := db.Issue{SpaceID: danglingSpaceID, WorkspaceID: wsID, Number: 42}
+
+		got := ForIssue(context.Background(), f, issue)
+		want := GeneratePrefix("Jiayuan's Workspace") + "-42"
+		if got != want {
+			t.Errorf("ForIssue() = %q, want %q", got, want)
+		}
+		if got == "-42" || got == "#42" {
+			t.Errorf("ForIssue() = %q, must never be a bare number identifier", got)
+		}
+		if !identifierShape.MatchString(got) {
+			t.Errorf("ForIssue() = %q does not match PREFIX-NUMBER shape", got)
+		}
+	})
+}
+
+// TestResolver_PrefixForIssue_CachesSpaceKeyLookupAcrossCalls asserts the
+// memoization contract stated in the Resolver doc comment: resolving two
+// issues that share a Space must only call GetWorkspaceSpace once.
+func TestResolver_PrefixForIssue_CachesSpaceKeyLookupAcrossCalls(t *testing.T) {
+	wsID := newUUID(t)
+	spaceID := newUUID(t)
+	f := newFakeQueries()
+	f.spaces[spaceID.Bytes] = db.WorkspaceSpace{ID: spaceID, WorkspaceID: wsID, Key: "ACME"}
+	r := NewResolver(f)
+
+	issue1 := db.Issue{SpaceID: spaceID, WorkspaceID: wsID, Number: 1}
+	issue2 := db.Issue{SpaceID: spaceID, WorkspaceID: wsID, Number: 2}
+
+	if got := r.PrefixForIssue(context.Background(), issue1); got != "ACME" {
+		t.Fatalf("first PrefixForIssue() = %q, want %q", got, "ACME")
+	}
+	if got := r.PrefixForIssue(context.Background(), issue2); got != "ACME" {
+		t.Fatalf("second PrefixForIssue() = %q, want %q", got, "ACME")
+	}
+	if f.spaceCalls != 1 {
+		t.Errorf("GetWorkspaceSpace called %d times for two issues sharing a Space, want 1 (memoized)", f.spaceCalls)
+	}
+}
+
+// TestResolver_PrefixForIssue_CachesWorkspaceFallbackAcrossCalls covers
+// memoization of the workspace-level fallback path (no Space on either
+// issue): GetDefaultWorkspaceSpace must only be called once per workspace.
+func TestResolver_PrefixForIssue_CachesWorkspaceFallbackAcrossCalls(t *testing.T) {
+	wsID := newUUID(t)
+	f := newFakeQueries()
+	f.defaultSpaces[wsID.Bytes] = db.WorkspaceSpace{Key: "DEFT"}
+	r := NewResolver(f)
+
+	issue1 := db.Issue{WorkspaceID: wsID, Number: 1}
+	issue2 := db.Issue{WorkspaceID: wsID, Number: 2}
+
+	if got := r.PrefixForIssue(context.Background(), issue1); got != "DEFT" {
+		t.Fatalf("first PrefixForIssue() = %q, want %q", got, "DEFT")
+	}
+	if got := r.PrefixForIssue(context.Background(), issue2); got != "DEFT" {
+		t.Fatalf("second PrefixForIssue() = %q, want %q", got, "DEFT")
+	}
+	if f.defaultCalls != 1 {
+		t.Errorf("GetDefaultWorkspaceSpace called %d times for two issues sharing a workspace, want 1 (memoized)", f.defaultCalls)
+	}
+}
+
+// TestResolver_CachesFailedSpaceLookupToAvoidRepeatedQueries covers negative
+// caching: a Space ID that fails to resolve is cached as "" so a batch of
+// issues all pointing at the same dangling Space does not re-issue the failed
+// query per issue.
+func TestResolver_CachesFailedSpaceLookupToAvoidRepeatedQueries(t *testing.T) {
+	wsID := newUUID(t)
+	danglingSpaceID := newUUID(t)
+	f := newFakeQueries()
+	f.defaultSpaces[wsID.Bytes] = db.WorkspaceSpace{Key: "DEFT"}
+	r := NewResolver(f)
+
+	issue1 := db.Issue{SpaceID: danglingSpaceID, WorkspaceID: wsID, Number: 1}
+	issue2 := db.Issue{SpaceID: danglingSpaceID, WorkspaceID: wsID, Number: 2}
+
+	if got := r.PrefixForIssue(context.Background(), issue1); got != "DEFT" {
+		t.Fatalf("first PrefixForIssue() = %q, want %q", got, "DEFT")
+	}
+	if got := r.PrefixForIssue(context.Background(), issue2); got != "DEFT" {
+		t.Fatalf("second PrefixForIssue() = %q, want %q", got, "DEFT")
+	}
+	if f.spaceCalls != 1 {
+		t.Errorf("GetWorkspaceSpace called %d times for two issues sharing a dangling Space, want 1 (negative-cached)", f.spaceCalls)
+	}
+}
diff --git a/server/internal/issueposition/position.go b/server/internal/issueposition/position.go
index 2ec255ce72..dd748f330e 100644
--- a/server/internal/issueposition/position.go
+++ b/server/internal/issueposition/position.go
@@ -12,15 +12,16 @@ type queryRower interface {
 	QueryRow(ctx context.Context, sql string, args ...any) pgx.Row
 }
 
-// NextTopPosition returns a position that sorts before every existing issue in
-// the workspace/status column when manual sorting orders by position ASC.
-func NextTopPosition(ctx context.Context, q queryRower, workspaceID pgtype.UUID, status string) (float64, error) {
+// NextTopPositionForSpace returns a position that sorts before every existing
+// issue in the (workspace, space, status) column when manual sorting orders by
+// position ASC.
+func NextTopPositionForSpace(ctx context.Context, q queryRower, workspaceID, spaceID pgtype.UUID, status string) (float64, error) {
 	var minPos float64
 	if err := q.QueryRow(ctx,
-		`SELECT COALESCE(MIN(position), 0) FROM issue WHERE workspace_id = $1 AND status = $2`,
-		workspaceID, status,
+		`SELECT COALESCE(MIN(position), 0) FROM issue WHERE workspace_id = $1 AND space_id = $2 AND status = $3`,
+		workspaceID, spaceID, status,
 	).Scan(&minPos); err != nil {
-		return 0, fmt.Errorf("query min issue position: %w", err)
+		return 0, fmt.Errorf("query min space issue position: %w", err)
 	}
 	return minPos - 1, nil
 }
diff --git a/server/internal/service/autopilot.go b/server/internal/service/autopilot.go
index 49dac019ad..45a978db41 100644
--- a/server/internal/service/autopilot.go
+++ b/server/internal/service/autopilot.go
@@ -15,7 +15,6 @@ import (
 	"github.com/multica-ai/multica/server/internal/analytics"
 	"github.com/multica-ai/multica/server/internal/events"
 	"github.com/multica-ai/multica/server/internal/issueguard"
-	"github.com/multica-ai/multica/server/internal/issueposition"
 	obsmetrics "github.com/multica-ai/multica/server/internal/metrics"
 	"github.com/multica-ai/multica/server/internal/util"
 	db "github.com/multica-ai/multica/server/pkg/db/generated"
@@ -32,6 +31,7 @@ type AutopilotService struct {
 	TxStarter TxStarter
 	Bus       *events.Bus
 	TaskSvc   *TaskService
+	issueSvc  *IssueService
 }
 
 // DefaultAutopilotTriggerTimezone is the timezone used to render Autopilot
@@ -43,7 +43,17 @@ const DefaultAutopilotTriggerTimezone = "UTC"
 const autopilotRecentDuplicateWindow = 60 * time.Second
 
 func NewAutopilotService(q *db.Queries, tx TxStarter, bus *events.Bus, taskSvc *TaskService) *AutopilotService {
-	return &AutopilotService{Queries: q, TxStarter: tx, Bus: bus, TaskSvc: taskSvc}
+	return &AutopilotService{
+		Queries:   q,
+		TxStarter: tx,
+		Bus:       bus,
+		TaskSvc:   taskSvc,
+		// nil analytics is deliberate: the autopilot dispatch path captures the
+		// IssueCreated event itself via captureIssueCreatedFromAutopilot (using
+		// TaskSvc.Analytics). Passing nil here keeps IssueService.Create from
+		// also capturing it, avoiding a double count.
+		issueSvc: NewIssueService(q, tx, bus, nil, taskSvc),
+	}
 }
 
 // DispatchAutopilot is the core execution entry point.
@@ -169,8 +179,10 @@ func (s *AutopilotService) DispatchAutopilotForPlan(
 //   - It is in-flight in a state whose downstream side effect is
 //     observable:
 //
-//   - issue_created with a valid issue_id — the issue exists and
-//     the issue-event listener owns task creation from here.
+//   - issue_created with a valid issue_id — the issue exists and its
+//     agent task was enqueued inline by IssueService.Create during
+//     dispatchCreateIssue (an enqueue failure would have flipped the run
+//     to failed before it reached this state).
 //
 //   - running with a valid task_id — the task is queued, the
 //     listener will close the run when the task terminates.
@@ -290,114 +302,95 @@ func (s *AutopilotService) dispatchCreateIssue(ctx context.Context, ap db.Autopi
 	if err != nil {
 		return fmt.Errorf("resolve leader: %w", err)
 	}
-
-	tx, err := s.TxStarter.Begin(ctx)
-	if err != nil {
-		return fmt.Errorf("begin tx: %w", err)
+	// Fail-closed invocation gate: verify the autopilot creator may still
+	// invoke the leader under the permission model. Catches configs that
+	// predate the save-time gate, and admin-created configs that no longer
+	// pass (MUL-3963).
+	if ap.AssigneeType == "squad" && !s.canCreatorInvokeAgent(ctx, ap, leader) {
+		return fmt.Errorf("autopilot creator cannot access private squad leader")
 	}
-	defer tx.Rollback(ctx)
-
-	qtx := s.Queries.WithTx(tx)
 
 	title := s.interpolateTemplate(ap, *run, triggerTimezone)
 	description := s.buildIssueDescription(ap, *run, triggerTimezone)
 
-	if duplicate, found, err := issueguard.LockAndFindRecentAutopilotDuplicate(
-		ctx, qtx, ap.WorkspaceID, ap.ID, ap.ProjectID, title, autopilotRecentDuplicateWindow,
-	); err != nil {
-		return fmt.Errorf("recent duplicate guard: %w", err)
-	} else if found {
-		return &errDispatchSkipped{reason: "recent duplicate autopilot issue: " + util.UUIDToString(duplicate.ID)}
-	}
-
-	issueNumber, err := qtx.IncrementIssueCounter(ctx, ap.WorkspaceID)
-	if err != nil {
-		return fmt.Errorf("increment issue counter: %w", err)
-	}
-
-	newPosition, err := issueposition.NextTopPosition(ctx, tx, ap.WorkspaceID, "todo")
-	if err != nil {
-		return fmt.Errorf("get next issue position: %w", err)
-	}
-
-	issue, err := qtx.CreateIssueWithOrigin(ctx, db.CreateIssueWithOriginParams{
-		WorkspaceID:  ap.WorkspaceID,
-		Title:        title,
-		Description:  description,
-		Status:       "todo",
-		Priority:     "none",
-		AssigneeType: pgtype.Text{String: ap.AssigneeType, Valid: true},
-		AssigneeID:   ap.AssigneeID,
-		// The agent that the autopilot dispatches to is the issue's creator,
-		// not the human who originally configured the autopilot. The latter
-		// is captured separately via origin_type=autopilot + origin_id. For
-		// squad-assigned autopilots, the creator is the resolved leader —
-		// the same agent the issue listener will end up enqueueing.
-		CreatorType:   "agent",
-		CreatorID:     leader.ID,
-		ParentIssueID: pgtype.UUID{},
-		Position:      newPosition,
-		StartDate:     pgtype.Date{},
-		DueDate:       pgtype.Date{},
-		Number:        issueNumber,
-		ProjectID:     ap.ProjectID,
-		OriginType:    pgtype.Text{String: "autopilot", Valid: true},
-		OriginID:      ap.ID,
+	var templateSubs []db.AutopilotSubscriber
+	var linkedRun db.AutopilotRun
+	result, err := s.issueSvc.Create(ctx, IssueCreateParams{
+		WorkspaceID:    ap.WorkspaceID,
+		SpaceID:        ap.SpaceID,
+		Title:          title,
+		Description:    description,
+		Status:         "todo",
+		Priority:       "none",
+		AssigneeType:   pgtype.Text{String: ap.AssigneeType, Valid: true},
+		AssigneeID:     ap.AssigneeID,
+		CreatorType:    "agent",
+		CreatorID:      leader.ID,
+		ParentIssueID:  pgtype.UUID{},
+		ProjectID:      ap.ProjectID,
+		StartDate:      pgtype.Date{},
+		DueDate:        pgtype.Date{},
+		OriginType:     pgtype.Text{String: "autopilot", Valid: true},
+		OriginID:       ap.ID,
+		AllowDuplicate: true,
+	}, IssueCreateOpts{
+		ActorID:          util.UUIDToString(leader.ID),
+		AnalyticsAgentID: util.UUIDToString(leader.ID),
+		Platform:         "autopilot",
+		BroadcastPayload: func(issue db.Issue, _ []db.Attachment, spaceKey string) map[string]any {
+			return map[string]any{"issue": issueToMap(issue, spaceKey)}
+		},
+		// Recent-duplicate guard (WS-1465). Runs inside the create tx so its
+		// advisory lock is held until commit: concurrent dispatches of the
+		// same autopilot+title serialize, and the loser sees the winner's
+		// committed issue with its run link already in place.
+		PreCreate: func(ctx context.Context, qtx *db.Queries) error {
+			if duplicate, found, err := issueguard.LockAndFindRecentAutopilotDuplicate(
+				ctx, qtx, ap.WorkspaceID, ap.ID, ap.ProjectID, title, autopilotRecentDuplicateWindow,
+			); err != nil {
+				return fmt.Errorf("recent duplicate guard: %w", err)
+			} else if found {
+				return &errDispatchSkipped{reason: "recent duplicate autopilot issue: " + util.UUIDToString(duplicate.ID)}
+			}
+			return nil
+		},
+		BeforeCommit: func(ctx context.Context, qtx *db.Queries, issue db.Issue) error {
+			subs, err := qtx.ListAutopilotSubscribers(ctx, ap.ID)
+			if err != nil {
+				return fmt.Errorf("list autopilot subscribers: %w", err)
+			}
+			templateSubs = subs
+			for _, sub := range subs {
+				if err := qtx.AddIssueSubscriber(ctx, db.AddIssueSubscriberParams{
+					IssueID:  issue.ID,
+					UserType: sub.UserType,
+					UserID:   sub.UserID,
+					Reason:   "autopilot",
+				}); err != nil {
+					return fmt.Errorf("add autopilot subscriber to issue: %w", err)
+				}
+			}
+			// Link the run inside the same tx as the issue insert (WS-1465):
+			// the recent-duplicate guard only counts issues with a linked
+			// run, and same-tx linking avoids a crash window where recovery
+			// would see an orphan issue but no linked run.
+			updatedRun, err := qtx.UpdateAutopilotRunIssueCreated(ctx, db.UpdateAutopilotRunIssueCreatedParams{
+				ID:      run.ID,
+				IssueID: issue.ID,
+			})
+			if err != nil {
+				return fmt.Errorf("link run to issue: %w", err)
+			}
+			linkedRun = updatedRun
+			return nil
+		},
 	})
 	if err != nil {
 		return fmt.Errorf("create issue: %w", err)
 	}
+	issue := result.Issue
+	*run = linkedRun
 
-	// Fan out the default subscriber template inside the same tx as the
-	// issue insert, before EventIssueCreated fires — so notification
-	// listeners see the full subscriber set on the first event instead of
-	// racing the listener that would otherwise hydrate the template.
-	templateSubs, err := qtx.ListAutopilotSubscribers(ctx, ap.ID)
-	if err != nil {
-		return fmt.Errorf("list autopilot subscribers: %w", err)
-	}
-	for _, sub := range templateSubs {
-		if err := qtx.AddIssueSubscriber(ctx, db.AddIssueSubscriberParams{
-			IssueID:  issue.ID,
-			UserType: sub.UserType,
-			UserID:   sub.UserID,
-			Reason:   "autopilot",
-		}); err != nil {
-			return fmt.Errorf("add autopilot subscriber to issue: %w", err)
-		}
-	}
-
-	// Link the run inside the same tx as the issue insert. This makes the
-	// recent-duplicate guard count only fully observable autopilot issues and
-	// avoids a crash window where recovery would see an orphan issue but no
-	// linked run.
-	updatedRun, err := qtx.UpdateAutopilotRunIssueCreated(ctx, db.UpdateAutopilotRunIssueCreatedParams{
-		ID:      run.ID,
-		IssueID: issue.ID,
-	})
-	if err != nil {
-		return fmt.Errorf("link run to issue: %w", err)
-	}
-	*run = updatedRun
-
-	if err := tx.Commit(ctx); err != nil {
-		return fmt.Errorf("commit tx: %w", err)
-	}
-
-	// Publish issue:created so the existing event chain fires
-	// (subscriber listeners, activity listeners, notification listeners). For
-	// squad autopilots, this is what triggers shouldEnqueueSquadLeaderOnAssign
-	// → enqueueSquadLeaderTask — no separate squad-routing code needed here.
-	prefix := s.getIssuePrefix(ap.WorkspaceID)
-	s.Bus.Publish(events.Event{
-		Type:        protocol.EventIssueCreated,
-		WorkspaceID: util.UUIDToString(ap.WorkspaceID),
-		ActorType:   "agent",
-		ActorID:     util.UUIDToString(leader.ID),
-		Payload: map[string]any{
-			"issue": issueToMap(issue, prefix),
-		},
-	})
 	s.captureIssueCreatedFromAutopilot(ap, run, issue, leader.ID)
 
 	// The issue:created notification listener only handles handler.IssueResponse
@@ -411,27 +404,6 @@ func (s *AutopilotService) dispatchCreateIssue(ctx context.Context, ap db.Autopi
 	// roll back the issue itself.
 	s.notifyAutopilotSubscribersOnCreate(ctx, ap, issue, leader.ID, templateSubs)
 
-	// Enqueue agent task via the existing flow. Squad-assigned autopilots
-	// route to the resolved leader as the executing agent (Path A from
-	// MUL-2429); agent-assigned autopilots go through the standard issue
-	// path. Both code paths land in agent_task_queue with agent_id = leader.
-	if ap.AssigneeType == "squad" {
-		// Fail-closed invocation gate: verify the autopilot creator may still
-		// invoke the leader under the permission model. Catches configs that
-		// predate the save-time gate, and admin-created configs that no longer
-		// pass (MUL-3963).
-		if !s.canCreatorInvokeAgent(ctx, ap, leader) {
-			return fmt.Errorf("autopilot creator cannot access private squad leader")
-		}
-		if _, err := s.TaskSvc.EnqueueTaskForSquadLeader(ctx, issue, leader.ID, ap.AssigneeID, pgtype.UUID{}); err != nil {
-			return fmt.Errorf("enqueue squad leader task: %w", err)
-		}
-	} else {
-		if _, err := s.TaskSvc.EnqueueTaskForIssue(ctx, issue); err != nil {
-			return fmt.Errorf("enqueue task for issue: %w", err)
-		}
-	}
-
 	slog.Info("autopilot dispatched (create_issue)",
 		"autopilot_id", util.UUIDToString(ap.ID),
 		"assignee_type", ap.AssigneeType,
@@ -439,6 +411,16 @@ func (s *AutopilotService) dispatchCreateIssue(ctx context.Context, ap db.Autopi
 		"leader_id", util.UUIDToString(leader.ID),
 		"run_id", util.UUIDToString(run.ID),
 	)
+
+	// The issue exists and the run is linked to it, but the agent task the run
+	// was supposed to drive was never enqueued. Surface this as a run failure so
+	// it is retried / visible instead of being recorded as a success with no
+	// downstream work. The issue_id stays linked (failRun only flips status), so
+	// the created issue remains discoverable; the message makes the ordering
+	// explicit so operators are not misled into thinking no issue was created.
+	if result.EnqueueErr != nil {
+		return fmt.Errorf("issue created but task enqueue failed: %w", result.EnqueueErr)
+	}
 	return nil
 }
 
@@ -1379,14 +1361,6 @@ func isSupportedIssueTitleVariable(name string) bool {
 	return false
 }
 
-func (s *AutopilotService) getIssuePrefix(workspaceID pgtype.UUID) string {
-	ws, err := s.Queries.GetWorkspace(context.Background(), workspaceID)
-	if err != nil {
-		return ""
-	}
-	return ws.IssuePrefix
-}
-
 // canCreatorInvokeAgent checks whether the autopilot's creator may invoke the
 // target agent under the invocation-permission model (MUL-3963). It mirrors
 // handler.canInvokeAgent with the autopilot creator as the effective user:
@@ -1394,7 +1368,7 @@ func (s *AutopilotService) getIssuePrefix(workspaceID pgtype.UUID) string {
 //   - private agent -> only the owner (NO admin bypass, NO agent-created bypass)
 //   - public_to agent -> workspace target admits any workspace-member creator
 //     (and agent-created autopilots as workspace principals); member target
-//     admits the matching creator; team targets are inert.
+//     admits the matching creator; space targets are inert.
 //
 // Fail-closed on any lookup error.
 func (s *AutopilotService) canCreatorInvokeAgent(ctx context.Context, ap db.Autopilot, agent db.Agent) bool {
diff --git a/server/internal/service/builtin_skills/multica-autopilots/SKILL.md b/server/internal/service/builtin_skills/multica-autopilots/SKILL.md
index 110788bb2e..24cb0a2540 100644
--- a/server/internal/service/builtin_skills/multica-autopilots/SKILL.md
+++ b/server/internal/service/builtin_skills/multica-autopilots/SKILL.md
@@ -38,8 +38,9 @@ Execution modes:
 ```bash
 multica autopilot list --output json
 multica autopilot get <autopilot-id> --output json
-multica autopilot create --title "<title>" --description "<task prompt>" --agent <agent-name-or-id> --mode create_issue|run_only --output json
+multica autopilot create --title "<title>" --description "<task prompt>" --agent <agent-name-or-id> --mode create_issue|run_only --space <space-id-or-key> --output json
 multica autopilot update <autopilot-id> --status active|paused --output json
+multica autopilot update <autopilot-id> --space <space-id-or-key> --output json
 multica autopilot runs <autopilot-id> --output json
 multica autopilot trigger-add <autopilot-id> --kind schedule --cron "0 9 * * *" --timezone Asia/Shanghai --output json
 multica autopilot trigger-add <autopilot-id> --kind webhook --label "ci" --output json
@@ -47,6 +48,13 @@ multica autopilot trigger <autopilot-id> --output json
 multica autopilot trigger-rotate-url <autopilot-id> <trigger-id> --yes --output json
 ```
 
+`--space <space-id-or-key>` (UUID or key) sets the autopilot's space on `create` and
+reassigns it on `update`. Omitting `--space` on create uses the workspace's default
+space, whose key is the legacy workspace prefix; omitting it on update keeps the
+current space. Every autopilot always belongs to a space — there is no clear
+operation, and `--space ""` is ignored (the server keeps the existing space).
+`multica autopilot list --space <space-id-or-key>` filters by space.
+
 Use `trigger` only when the user explicitly asks for a manual run. Use `trigger-rotate-url` only when rotating a webhook URL; the old URL stops being valid.
 
 Webhook trigger output can include a URL/token. Do not paste webhook tokens or signing material into comments, logs, docs, or PRs. Redact secrets.
diff --git a/server/internal/service/builtin_skills/multica-autopilots/references/autopilots-source-map.md b/server/internal/service/builtin_skills/multica-autopilots/references/autopilots-source-map.md
index d394eb0601..54368049d4 100644
--- a/server/internal/service/builtin_skills/multica-autopilots/references/autopilots-source-map.md
+++ b/server/internal/service/builtin_skills/multica-autopilots/references/autopilots-source-map.md
@@ -1,6 +1,7 @@
 # Autopilots source map
 
 - `server/cmd/multica/cmd_autopilot.go` registers `list`, `get`, `create`, `update`, `delete`, `trigger`, `runs`, `trigger-add`, `trigger-update`, `trigger-delete`, and `trigger-rotate-url`.
+- `autopilot create`/`update` take `--space` (single UUID or key, resolved via `resolveSpaceRef` into `space_id`). On `update` a supplied value reassigns the space; `resolveAutopilotSpace` (`server/internal/handler/autopilot.go:974`) falls back to the previous space when the value is nil/empty, and `UpdateAutopilot` SQL uses `space_id = COALESCE(sqlc.narg('space_id')::uuid, space_id)` (`server/pkg/db/queries/autopilot.sql:75`), so `--space ""` is a no-op — there is no clear operation and every autopilot always belongs to a space. `autopilot list --space` sets the `space_id` filter. Omitting `--space` on create files the autopilot under the workspace's default space, whose key is the legacy workspace prefix.
 - The CLI maps reads/writes to `/api/autopilots`, `/api/autopilots/{id}`, `/api/autopilots/{id}/trigger`, `/api/autopilots/{id}/runs`, and trigger subroutes.
 - `server/internal/service/autopilot.go` has `DispatchAutopilot`, creates `autopilot_run`, and switches on `execution_mode`.
 - `create_issue` calls `dispatchCreateIssue`; `run_only` calls `dispatchRunOnly`.
diff --git a/server/internal/service/builtin_skills/multica-projects-and-resources/SKILL.md b/server/internal/service/builtin_skills/multica-projects-and-resources/SKILL.md
index 850f38b044..ab8a375703 100644
--- a/server/internal/service/builtin_skills/multica-projects-and-resources/SKILL.md
+++ b/server/internal/service/builtin_skills/multica-projects-and-resources/SKILL.md
@@ -31,13 +31,38 @@ Common resource types:
 - `github_repo` — durable GitHub repo context, with `resource_ref.url`, optional checkout `ref`, and optional prompt-only `default_branch_hint`;
 - `local_directory` — daemon-local path context, with `resource_ref.local_path`, `daemon_id`, and optional label.
 
+## Spaces
+
+A workspace is organized into spaces. A space owns an issue-key prefix and its own
+issue-number counter, so issue identifiers read `SPACE_KEY-NUMBER` (e.g. `MUL-42`).
+Every workspace has a default space whose key is the legacy workspace prefix;
+commands that omit `--space` fall back to it.
+
+Projects belong to one or more spaces. `project create` and `project update` take a
+repeatable `--space <space-id-or-key>` (UUID or key); on `update` the flag
+**replaces** the project's space set. `project list --space <space-id-or-key>` filters
+a listing to one space.
+
+```bash
+multica space list --output json
+multica space create --name "<name>" --key <PREFIX> --output json
+multica space update <space-id-or-key> --name "<name>" --key <PREFIX> --output json
+multica space archive <space-id-or-key> --output json
+```
+
+`space create` requires `--name`; `--key` sets the issue prefix and is optional.
+`--description` and `--icon` are optional on both `create` and `update`. `archive`
+resolves a space by id or key.
+
 ## CLI
 
 ```bash
 multica project list --output json
+multica project list --space <space-id-or-key> --output json
 multica project get <project-id> --output json
-multica project create --title "<title>" --repo <github-url> --output json
+multica project create --title "<title>" --space <space-id-or-key> --repo <github-url> --output json
 multica project update <project-id> --title "<title>" --output json
+multica project update <project-id> --space <space-id-or-key> --output json
 multica project status <project-id> in_progress --output json
 multica project resource list <project-id> --output json
 multica project resource add <project-id> --type github_repo --url <github-url> --output json
diff --git a/server/internal/service/builtin_skills/multica-projects-and-resources/references/projects-and-resources-source-map.md b/server/internal/service/builtin_skills/multica-projects-and-resources/references/projects-and-resources-source-map.md
index 0a90af2836..1487933248 100644
--- a/server/internal/service/builtin_skills/multica-projects-and-resources/references/projects-and-resources-source-map.md
+++ b/server/internal/service/builtin_skills/multica-projects-and-resources/references/projects-and-resources-source-map.md
@@ -1,6 +1,10 @@
 # Projects and resources source map
 
 - `server/cmd/multica/cmd_project.go` registers project `list`, `get`, `create`, `update`, `delete`, and `status`.
+- `project list --space` (single UUID or key) sets `space_id`; `project create`/`project update` take a repeatable `--space` (`StringArray`, UUID or key) resolved via `resolveSpaceRefs` into `space_ids`. On `update` the resolved list **replaces** the project's space set.
+- `server/cmd/multica/cmd_space.go` registers space `list`, `create`, `update`, and `archive`. `create` requires `--name`; `--key` (issue prefix), `--description`, `--icon` are optional; `update` accepts the same optional flags. The CLI maps to `/api/spaces` (GET/POST) and `/api/spaces/{id}` (PATCH/PUT update, DELETE archive), routes registered at `server/cmd/server/router.go:951`.
+- `resolveSpaceRef`/`resolveSpaceRefs` (`cmd_space.go`) resolve a `--space` value by exact UUID or case-insensitive key against `GET /api/spaces`. `spaceCLIResponse` carries `key`, `issue_counter`, and `is_default`.
+- A space owns the issue-key prefix and its own issue-number counter, so identifiers read `SPACE_KEY-NUMBER`. Each workspace has a default space whose key is the legacy workspace prefix; omitting `--space` uses that default space.
 - The same file registers `project resource list/add/update/remove`.
 - `project create --repo` attaches `github_repo` resources during project creation.
 - `project resource add` supports shortcuts for `github_repo` (`--url`, non-JSON `--ref` for checkout ref, `--default-branch-hint`) and `local_directory` (`--local-path`, `--daemon-id`, `--ref-label`), or generic JSON `--ref '<json>'`.
diff --git a/server/internal/service/builtin_skills/multica-working-on-issues/SKILL.md b/server/internal/service/builtin_skills/multica-working-on-issues/SKILL.md
index f19be4db2d..32c651ed6f 100644
--- a/server/internal/service/builtin_skills/multica-working-on-issues/SKILL.md
+++ b/server/internal/service/builtin_skills/multica-working-on-issues/SKILL.md
@@ -22,10 +22,12 @@ The GitHub webhook runs two separate scans over an incoming PR. They are not the
 same gate and they read different fields.
 
 **Linking** scans the PR **title, body, OR branch** for a routable issue key
-(`PREFIX-NUMBER`, e.g. `MUL-2759`). Each match writes an issue ↔ PR link row.
-This is the link that `multica issue pull-requests` reads back — but see the
-reference-only rule below: a key that appears **only** as a bare mention in the
-body is linked yet hidden from that list.
+(`SPACE_KEY-NUMBER`, e.g. `MUL-2759`). The prefix is the issue's Space key — a space
+owns its issue-number namespace, and each workspace has a default space whose key is
+the legacy workspace prefix, so a bare `MUL-2759` still routes. Each match writes an
+issue ↔ PR link row. This is the link that `multica issue pull-requests` reads back —
+but see the reference-only rule below: a key that appears **only** as a bare mention
+in the body is linked yet hidden from that list.
 
 ```text
 MUL-2759: add built-in issue working skill        # title prefix → links, shown
@@ -167,6 +169,22 @@ On an agent-assigned issue, create status decides whether the assignee fires
 immediately. A non-backlog status (e.g. `todo`) enqueues the agent at create
 time; `backlog` sets the assignee without triggering.
 
+`multica issue create` files the issue under a space: pass `--space <UUID>` to pick
+one explicitly (the space owns the `SPACE_KEY-NUMBER` identifier namespace), or omit
+it to fall back to the workspace's default space, whose key is the legacy workspace
+prefix. `multica issue list --space <UUID>` filters a listing to one space.
+
+Space binds at creation time only, and it can change later:
+
+- `multica issue update <id> --space <UUID-or-key>` moves the issue to another
+  space. It is renumbered under the target space's key; the old identifier is
+  recorded as an alias and keeps resolving (CLI lookups, API, GitHub branch/PR
+  linking), so existing references never break.
+- Parent and child issues may live in different spaces. A child only inherits
+  its parent's space as a creation-time default when you don't pass `--space`.
+- A project's space set is likewise a creation-time default, not a constraint —
+  an issue in a project may belong to any space.
+
 Parallel children — all start now:
 
 ```bash
diff --git a/server/internal/service/builtin_skills/multica-working-on-issues/references/working-on-issues-source-map.md b/server/internal/service/builtin_skills/multica-working-on-issues/references/working-on-issues-source-map.md
index e81dab4a26..931520f9a5 100644
--- a/server/internal/service/builtin_skills/multica-working-on-issues/references/working-on-issues-source-map.md
+++ b/server/internal/service/builtin_skills/multica-working-on-issues/references/working-on-issues-source-map.md
@@ -63,14 +63,28 @@ auto-link flag (`workspaceAutoLinkPRsEnabled`, `github.go:1074`).
 ### Path 1 — link (title OR body OR branch)
 
 - `extractIdentifiers` regex helper: `server/internal/handler/github.go:1028`
-- driving regex `identifierRe` (`\b([a-z][a-z0-9]{1,9})-(\d+)\b`, case-insensitive):
-  `server/internal/handler/github.go:490`
+- driving regex `identifierRe` (`\b([a-z][a-z0-9]{0,6})-(\d+)\b`, case-insensitive):
+  `server/internal/handler/github.go:584`
 - call site: `server/internal/handler/github.go:727` —
   `extractIdentifiers(p.PullRequest.Title, p.PullRequest.Body, p.PullRequest.Head.Ref)`
 
-Every `PREFIX-NUMBER` mention in **title, body, or branch** resolves to an issue
+Every `SPACE_KEY-NUMBER` mention in **title, body, or branch** resolves to an issue
 in the workspace and writes a link row (`LinkIssueToPullRequest`, ~`github.go:762`).
-This is what `multica issue pull-requests` later reads back.
+This is what `multica issue pull-requests` later reads back. The prefix is a Space
+key — letter-first, 1-7 chars total (`[a-z][a-z0-9]{0,6}`, narrowed from the old
+`{1,9}`/1-10 char bound) — because a Space now owns the issue-number namespace. Each
+workspace has a default space whose key is the legacy workspace prefix, so a bare
+`MUL-2759` routes through that default space.
+
+**Move-to-space (issue update `--space`).** `UpdateIssue`'s `space_id` branch
+(`handler/issue.go`, move block) renumbers the issue under the target space's
+counter and records the old `key-number` in `issue_identifier_alias`
+(`UpsertIssueIdentifierAlias`). Identifier resolution falls back to that alias
+in `resolveIssueByIdentifier` (`handler.go`) and in GitHub branch/PR linking
+(`github.go`), so pre-move references keep resolving. The CLI exposes this as
+`multica issue update <id> --space <UUID-or-key>` (`cmd_issue.go`,
+`resolveSpaceRef` accepts a key or UUID). Space is a creation-time default
+elsewhere: parent/child and project↔space carry no cross-space validation.
 
 **Reference-only flag (MUL-3739).** The link row carries a `reference_only`
 boolean (`migrations/127_issue_pull_request_reference_only.up.sql`). The handler
@@ -92,12 +106,12 @@ call-site location for the link logic.
 
 - `extractClosingIdentifiers` regex helper: `server/internal/handler/github.go:1051`
 - driving regex `closingIdentifierRe`
-  (`\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)[:\s]+([a-z][a-z0-9]{1,9})-(\d+)\b`):
-  `server/internal/handler/github.go:501`
+  (`\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)[:\s]+([a-z][a-z0-9]{0,6})-(\d+)\b`):
+  `server/internal/handler/github.go:596`
 - call site: `server/internal/handler/github.go:736` —
   `extractClosingIdentifiers(p.PullRequest.Title, p.PullRequest.Body)` (no branch arg)
 
-Only a `PREFIX-NUMBER` immediately after a closing keyword
+Only a `SPACE_KEY-NUMBER` immediately after a closing keyword
 (`Closes`/`Fixes`/`Resolves`, optional `:` then whitespace) sets the link row's
 `close_intent` flag — the gate that auto-advances the issue to `done` on merge.
 `Fix MUL-1` closes; `Fix login MUL-1` does not (adjacency). Branch names are
diff --git a/server/internal/service/issue.go b/server/internal/service/issue.go
index d4a72b14d2..a77e14a355 100644
--- a/server/internal/service/issue.go
+++ b/server/internal/service/issue.go
@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"log/slog"
+	"strings"
 
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/multica-ai/multica/server/internal/analytics"
@@ -51,6 +52,7 @@ func NewIssueService(q *db.Queries, tx TxStarter, bus *events.Bus, ac analytics.
 // request payload into this struct; the service stays transport-agnostic.
 type IssueCreateParams struct {
 	WorkspaceID    pgtype.UUID
+	SpaceID        pgtype.UUID
 	Title          string
 	Description    pgtype.Text
 	Status         string
@@ -82,8 +84,9 @@ type IssueCreateOpts struct {
 	// package to depend on handler-layer types. If nil, the service
 	// emits a minimal `{"issue_id": <uuid>}` payload — enough for cache
 	// invalidation, but front-ends that expect the full response shape
-	// must provide BroadcastPayload.
-	BroadcastPayload func(issue db.Issue, attachments []db.Attachment) map[string]any
+	// must provide BroadcastPayload. spaceKey is the resolved Space key so
+	// the callback can build the identifier without re-querying the Space.
+	BroadcastPayload func(issue db.Issue, attachments []db.Attachment, spaceKey string) map[string]any
 
 	// ActorID overrides the actor ID used for broadcast + analytics
 	// when it differs from the creator on the row. Agent-created issues
@@ -102,6 +105,18 @@ type IssueCreateOpts struct {
 	// daemon / lark / autopilot). Derived from middleware's client
 	// metadata at the handler layer.
 	Platform string
+
+	// BeforeCommit runs after the issue row has been inserted and before the
+	// create transaction commits. It is for same-transaction side effects that
+	// must be visible when EventIssueCreated fires.
+	BeforeCommit func(ctx context.Context, qtx *db.Queries, issue db.Issue) error
+
+	// PreCreate runs inside the create transaction before validation,
+	// numbering, and insert. It is for caller-specific guards whose locks
+	// must be held until the transaction commits (e.g. the autopilot
+	// recent-duplicate guard). Its error aborts the create and is
+	// propagated to the caller unwrapped.
+	PreCreate func(ctx context.Context, qtx *db.Queries) error
 }
 
 // ErrActiveDuplicate signals that the duplicate guard found an active
@@ -124,6 +139,36 @@ var ErrParentIssueNotFound = errors.New("parent issue not found in this workspac
 // having to remember it. Callers translate this into 400.
 var ErrProjectNotFound = errors.New("project not found in this workspace")
 
+// ErrSpaceNotFound signals that the requested or fallback Space does not exist
+// in the workspace. Callers translate this into 400.
+var ErrSpaceNotFound = errors.New("space not found in this workspace")
+
+// ErrSpaceArchived signals that the resolved Space exists but is archived and
+// cannot receive new work. Kept distinct from ErrSpaceNotFound so callers can
+// return a clear "space is archived" message instead of a misleading "not found".
+var ErrSpaceArchived = errors.New("space is archived")
+
+// ErrProjectSpaceAmbiguous signals that a Space was not specified for an issue
+// whose Project belongs to more than one Space, so no single Space can be
+// inferred. Callers translate this into a 400 that names the candidate Space
+// keys; matched via errors.Is against a *ProjectSpaceAmbiguousError.
+var ErrProjectSpaceAmbiguous = errors.New("project has multiple spaces; specify space_id")
+
+// ProjectSpaceAmbiguousError carries the candidate Space keys so the transport
+// layer can produce a guided message. It matches ErrProjectSpaceAmbiguous under
+// errors.Is.
+type ProjectSpaceAmbiguousError struct {
+	SpaceKeys []string
+}
+
+func (e *ProjectSpaceAmbiguousError) Error() string {
+	return fmt.Sprintf("project has multiple spaces (%s); specify space_id", strings.Join(e.SpaceKeys, ", "))
+}
+
+func (e *ProjectSpaceAmbiguousError) Is(target error) bool {
+	return target == ErrProjectSpaceAmbiguous
+}
+
 // IssueCreateResult is the typed return from IssueService.Create.
 //
 //   - On the happy path: Issue is the new row, Attachments lists the
@@ -131,9 +176,19 @@ var ErrProjectNotFound = errors.New("project not found in this workspace")
 //   - On ErrActiveDuplicate: DuplicateIssue is the row that blocked the
 //     create; Issue and Attachments are zero.
 type IssueCreateResult struct {
-	Issue          db.Issue
-	Attachments    []db.Attachment
+	Issue       db.Issue
+	Attachments []db.Attachment
+	// SpaceKey is the identifier prefix of the resolved Space, captured during
+	// creation so callers building the broadcast payload and HTTP response do
+	// not each re-query the Space that Create already resolved.
+	SpaceKey       string
 	DuplicateIssue *db.Issue
+	// EnqueueErr carries a non-fatal agent/squad task enqueue failure that
+	// happened AFTER the issue was committed. The issue itself is valid; the
+	// manual HTTP path ignores this (warn-only, historical behavior), but the
+	// autopilot path uses it to fail the run instead of recording a success
+	// for work whose agent task was never created.
+	EnqueueErr error
 }
 
 // Create runs the full issue-creation pipeline atomically end-to-end:
@@ -164,12 +219,19 @@ func (s *IssueService) Create(ctx context.Context, p IssueCreateParams, opts Iss
 	defer tx.Rollback(ctx)
 	qtx := s.Queries.WithTx(tx)
 
+	if opts.PreCreate != nil {
+		if err := opts.PreCreate(ctx, qtx); err != nil {
+			return IssueCreateResult{}, err
+		}
+	}
+
 	// Resolve and validate parent / project before reading from the
 	// duplicate guard so a forged parent or project ID is rejected
 	// before we touch the issue counter. Both checks scope by
 	// WorkspaceID — there is no path from this service to a row in a
 	// foreign workspace.
 	projectID := p.ProjectID
+	spaceID := p.SpaceID
 	if p.ParentIssueID.Valid {
 		parent, err := qtx.GetIssueInWorkspace(ctx, db.GetIssueInWorkspaceParams{
 			ID:          p.ParentIssueID,
@@ -184,6 +246,12 @@ func (s *IssueService) Create(ctx context.Context, p IssueCreateParams, opts Iss
 		if !projectID.Valid {
 			projectID = parent.ProjectID
 		}
+		// Space is a creation-time default, not a constraint: a sub-issue
+		// seeds its space from the parent only when the caller didn't pick
+		// one. Parent and child may diverge afterwards.
+		if !spaceID.Valid && parent.SpaceID.Valid {
+			spaceID = parent.SpaceID
+		}
 	}
 	if projectID.Valid {
 		if _, err := qtx.GetProjectInWorkspace(ctx, db.GetProjectInWorkspaceParams{
@@ -193,8 +261,23 @@ func (s *IssueService) Create(ctx context.Context, p IssueCreateParams, opts Iss
 			return IssueCreateResult{}, ErrProjectNotFound
 		}
 	}
+	space, err := ResolveSpace(ctx, qtx, p.WorkspaceID, spaceID, projectID)
+	if err != nil {
+		return IssueCreateResult{}, err
+	}
+	spaceID = space.ID
 
-	duplicate, found, err := issueguard.LockAndFindActiveDuplicate(ctx, qtx, p.WorkspaceID, projectID, p.ParentIssueID, p.Title, p.AllowDuplicate)
+	// Invariant: an issue's space is always part of its project's space set.
+	// The UI resolves a mismatch with an explicit dialog whose default is
+	// "add the space to the project"; headless callers (agents, CLI, API)
+	// get that same default applied here, so the invariant holds on every
+	// path and a space's Projects page never misses a project that holds
+	// its issues.
+	if err := EnsureProjectHasSpace(ctx, qtx, p.WorkspaceID, projectID, spaceID); err != nil {
+		return IssueCreateResult{}, err
+	}
+
+	duplicate, found, err := issueguard.LockAndFindActiveDuplicate(ctx, qtx, p.WorkspaceID, spaceID, projectID, p.ParentIssueID, p.Title, p.AllowDuplicate)
 	if err != nil {
 		return IssueCreateResult{}, fmt.Errorf("duplicate guard: %w", err)
 	}
@@ -203,21 +286,24 @@ func (s *IssueService) Create(ctx context.Context, p IssueCreateParams, opts Iss
 		return IssueCreateResult{DuplicateIssue: &dup}, ErrActiveDuplicate
 	}
 
-	issueNumber, err := qtx.IncrementIssueCounter(ctx, p.WorkspaceID)
+	issueNumber, err := qtx.IncrementSpaceIssueCounter(ctx, db.IncrementSpaceIssueCounterParams{
+		ID:          spaceID,
+		WorkspaceID: p.WorkspaceID,
+	})
 	if err != nil {
 		return IssueCreateResult{}, fmt.Errorf("increment counter: %w", err)
 	}
 
-	// New issues sort to the top of their (workspace, status) column for
-	// manual ordering. Computed inside the tx, after IncrementIssueCounter
-	// has already taken the workspace row lock, so two concurrent creates
-	// in the same workspace see each other's positions and don't both
+	// New issues sort to the top of their (workspace, space, status) column for
+	// manual ordering. Computed inside the tx, after IncrementSpaceIssueCounter
+	// has already taken the space row lock, so two concurrent creates
+	// in the same space see each other's positions and don't both
 	// land on the same min-1 slot. Concurrent manual reorder via
 	// UpdateIssue(position) does NOT take this lock, so a create racing
 	// a reorder is still allowed to collide on position — manual ordering
 	// is best-effort and the UI tolerates equal positions by falling back
 	// to the secondary ORDER BY key.
-	newPosition, err := issueposition.NextTopPosition(ctx, tx, p.WorkspaceID, p.Status)
+	newPosition, err := issueposition.NextTopPositionForSpace(ctx, tx, p.WorkspaceID, spaceID, p.Status)
 	if err != nil {
 		return IssueCreateResult{}, fmt.Errorf("next top position: %w", err)
 	}
@@ -226,6 +312,7 @@ func (s *IssueService) Create(ctx context.Context, p IssueCreateParams, opts Iss
 	if p.OriginType.Valid {
 		issue, err = qtx.CreateIssueWithOrigin(ctx, db.CreateIssueWithOriginParams{
 			WorkspaceID:   p.WorkspaceID,
+			SpaceID:       spaceID,
 			Title:         p.Title,
 			Description:   p.Description,
 			Status:        p.Status,
@@ -247,6 +334,7 @@ func (s *IssueService) Create(ctx context.Context, p IssueCreateParams, opts Iss
 	} else {
 		issue, err = qtx.CreateIssue(ctx, db.CreateIssueParams{
 			WorkspaceID:   p.WorkspaceID,
+			SpaceID:       spaceID,
 			Title:         p.Title,
 			Description:   p.Description,
 			Status:        p.Status,
@@ -268,6 +356,12 @@ func (s *IssueService) Create(ctx context.Context, p IssueCreateParams, opts Iss
 		return IssueCreateResult{}, fmt.Errorf("create issue: %w", err)
 	}
 
+	if opts.BeforeCommit != nil {
+		if err := opts.BeforeCommit(ctx, qtx, issue); err != nil {
+			return IssueCreateResult{}, err
+		}
+	}
+
 	if err := tx.Commit(ctx); err != nil {
 		return IssueCreateResult{}, fmt.Errorf("commit: %w", err)
 	}
@@ -279,11 +373,103 @@ func (s *IssueService) Create(ctx context.Context, p IssueCreateParams, opts Iss
 		actorID = util.UUIDToString(issue.CreatorID)
 	}
 
-	s.publishIssueCreated(issue, attachments, p.CreatorType, actorID, opts)
+	s.publishIssueCreated(issue, attachments, space.Key, p.CreatorType, actorID, opts)
 	s.captureCreatedAnalytics(issue, p.CreatorType, actorID, opts)
-	s.maybeEnqueueOnAssign(ctx, issue, p.CreatorType, actorID)
+	enqueueErr := s.maybeEnqueueOnAssign(ctx, issue, p.CreatorType, actorID)
 
-	return IssueCreateResult{Issue: issue, Attachments: attachments}, nil
+	return IssueCreateResult{Issue: issue, Attachments: attachments, SpaceKey: space.Key, EnqueueErr: enqueueErr}, nil
+}
+
+// ResolveSpace is the single authority for choosing an issue's Space. It is used
+// by IssueService.Create and by the HTTP quick-create / autopilot handlers so
+// every issue-producing path shares one inference and validation policy:
+//
+//   - an explicit requestedSpaceID is validated and used;
+//   - otherwise, when a Project is given: a single-space Project infers that
+//     Space, a multi-space Project is ambiguous (ErrProjectSpaceAmbiguous), and a
+//     Project with no Space links falls through;
+//   - otherwise the workspace default Space is used.
+//
+// The chosen Space must be active (ErrSpaceNotFound / ErrSpaceArchived). The
+// project association is a creation-time default only — an explicit space is
+// never validated against the project's space set.
+func ResolveSpace(ctx context.Context, q *db.Queries, workspaceID, requestedSpaceID, projectID pgtype.UUID) (db.WorkspaceSpace, error) {
+	spaceID := requestedSpaceID
+	if !spaceID.Valid && projectID.Valid {
+		spaces, err := q.ListProjectSpaces(ctx, db.ListProjectSpacesParams{
+			WorkspaceID: workspaceID,
+			ProjectID:   projectID,
+		})
+		if err != nil {
+			return db.WorkspaceSpace{}, fmt.Errorf("list project spaces: %w", err)
+		}
+		switch {
+		case len(spaces) == 1:
+			spaceID = spaces[0].ID
+		case len(spaces) > 1:
+			keys := make([]string, len(spaces))
+			for i, t := range spaces {
+				keys[i] = t.Key
+			}
+			return db.WorkspaceSpace{}, &ProjectSpaceAmbiguousError{SpaceKeys: keys}
+		}
+	}
+	if !spaceID.Valid {
+		space, err := q.GetDefaultWorkspaceSpace(ctx, workspaceID)
+		if err != nil {
+			return db.WorkspaceSpace{}, ErrSpaceNotFound
+		}
+		spaceID = space.ID
+	}
+	return ValidateActiveSpace(ctx, q, workspaceID, spaceID)
+}
+
+// EnsureProjectHasSpace upholds the invariant that an issue's space is part of
+// its project's space set, by adding the association when it is missing (the
+// same default the UI's conflict dialog offers). No-op without a project.
+// Exported via the issue create/update paths only — project↔space stays a
+// creation-time default for everything else.
+func EnsureProjectHasSpace(ctx context.Context, q *db.Queries, workspaceID, projectID, spaceID pgtype.UUID) error {
+	if !projectID.Valid || !spaceID.Valid {
+		return nil
+	}
+	spaces, err := q.ListProjectSpaces(ctx, db.ListProjectSpacesParams{
+		WorkspaceID: workspaceID,
+		ProjectID:   projectID,
+	})
+	if err != nil {
+		return fmt.Errorf("list project spaces: %w", err)
+	}
+	for _, t := range spaces {
+		if t.ID == spaceID {
+			return nil
+		}
+	}
+	if err := q.AddProjectSpace(ctx, db.AddProjectSpaceParams{
+		WorkspaceID: workspaceID,
+		ProjectID:   projectID,
+		SpaceID:     spaceID,
+	}); err != nil {
+		return fmt.Errorf("add project space: %w", err)
+	}
+	return nil
+}
+
+// ValidateActiveSpace loads a Space by ID and returns it only if it exists in the
+// workspace and is not archived. Shared active-space validation for ResolveSpace
+// and for handlers validating a Space-id list.
+func ValidateActiveSpace(ctx context.Context, q *db.Queries, workspaceID, spaceID pgtype.UUID) (db.WorkspaceSpace, error) {
+	space, err := q.GetWorkspaceSpace(ctx, db.GetWorkspaceSpaceParams{
+		ID:          spaceID,
+		WorkspaceID: workspaceID,
+	})
+	if err != nil || !space.ID.Valid {
+		return db.WorkspaceSpace{}, ErrSpaceNotFound
+	}
+	if space.ArchivedAt.Valid {
+		return db.WorkspaceSpace{}, ErrSpaceArchived
+	}
+	return space, nil
 }
 
 // linkAttachments links the given attachment IDs to the newly created
@@ -318,13 +504,13 @@ func (s *IssueService) linkAttachments(ctx context.Context, issue db.Issue, ids
 	return list
 }
 
-func (s *IssueService) publishIssueCreated(issue db.Issue, attachments []db.Attachment, creatorType, actorID string, opts IssueCreateOpts) {
+func (s *IssueService) publishIssueCreated(issue db.Issue, attachments []db.Attachment, spaceKey, creatorType, actorID string, opts IssueCreateOpts) {
 	if s.Bus == nil {
 		return
 	}
 	var payload map[string]any
 	if opts.BroadcastPayload != nil {
-		payload = opts.BroadcastPayload(issue, attachments)
+		payload = opts.BroadcastPayload(issue, attachments, spaceKey)
 	} else {
 		// Minimal fallback so cache invalidations still fire even if the
 		// caller forgot to supply a builder. Front-ends that expect the
@@ -385,20 +571,29 @@ func classifyOrigin(issue db.Issue, opts IssueCreateOpts) (source, taskID, autop
 	}
 }
 
-func (s *IssueService) maybeEnqueueOnAssign(ctx context.Context, issue db.Issue, creatorType, actorID string) {
+// maybeEnqueueOnAssign enqueues the assignee agent (or squad leader) task for a
+// freshly created, non-backlog, assigned issue. It still logs a warning on
+// failure so the manual create path is unchanged, but it also RETURNS the
+// failure so callers that need a durable outcome (autopilot) can act on it
+// instead of silently recording a success.
+func (s *IssueService) maybeEnqueueOnAssign(ctx context.Context, issue db.Issue, creatorType, actorID string) error {
 	if !issue.AssigneeType.Valid || !issue.AssigneeID.Valid {
-		return
+		return nil
 	}
 	if s.shouldEnqueueAgentTask(ctx, issue) {
 		if _, err := s.TaskService.EnqueueTaskForIssue(ctx, issue); err != nil {
 			slog.Warn("enqueue agent task on create failed",
 				"issue_id", util.UUIDToString(issue.ID),
 				"error", err)
+			return fmt.Errorf("enqueue agent task: %w", err)
 		}
 	}
 	if s.shouldEnqueueSquadLeaderOnAssign(ctx, issue) {
-		s.enqueueSquadLeaderTask(ctx, issue, pgtype.UUID{}, creatorType, actorID)
+		if err := s.enqueueSquadLeaderTask(ctx, issue, pgtype.UUID{}, creatorType, actorID); err != nil {
+			return fmt.Errorf("enqueue squad leader task: %w", err)
+		}
 	}
+	return nil
 }
 
 // shouldEnqueueAgentTask returns true when an issue create or assignment
@@ -453,13 +648,13 @@ func (s *IssueService) isSquadLeaderReady(ctx context.Context, issue db.Issue) b
 	return ready
 }
 
-func (s *IssueService) enqueueSquadLeaderTask(ctx context.Context, issue db.Issue, triggerCommentID pgtype.UUID, authorType, authorID string) {
+func (s *IssueService) enqueueSquadLeaderTask(ctx context.Context, issue db.Issue, triggerCommentID pgtype.UUID, authorType, authorID string) error {
 	squad, err := s.Queries.GetSquadInWorkspace(ctx, db.GetSquadInWorkspaceParams{
 		ID:          issue.AssigneeID,
 		WorkspaceID: issue.WorkspaceID,
 	})
 	if err != nil {
-		return
+		return nil
 	}
 	hasPending, err := s.Queries.HasPendingTaskForIssueAndAgent(ctx, db.HasPendingTaskForIssueAndAgentParams{
 		IssueID: issue.ID,
@@ -468,7 +663,7 @@ func (s *IssueService) enqueueSquadLeaderTask(ctx context.Context, issue db.Issu
 		HeadSha: headShaText(s.TaskService.ResolveIssueReviewSHA(ctx, issue.ID)),
 	})
 	if err != nil || hasPending {
-		return
+		return nil
 	}
 	if _, err := s.TaskService.EnqueueTaskForSquadLeader(ctx, issue, squad.LeaderID, squad.ID, triggerCommentID); err != nil {
 		slog.Warn("enqueue squad leader task on create failed",
@@ -476,5 +671,7 @@ func (s *IssueService) enqueueSquadLeaderTask(ctx context.Context, issue db.Issu
 			"squad_id", util.UUIDToString(squad.ID),
 			"leader_id", util.UUIDToString(squad.LeaderID),
 			"error", err)
+		return err
 	}
+	return nil
 }
diff --git a/server/internal/service/issue_resolve_test.go b/server/internal/service/issue_resolve_test.go
new file mode 100644
index 0000000000..9b48b38249
--- /dev/null
+++ b/server/internal/service/issue_resolve_test.go
@@ -0,0 +1,35 @@
+package service
+
+import (
+	"errors"
+	"testing"
+)
+
+// TestProjectSpaceAmbiguousError pins the contract handlers depend on when a
+// Space is omitted for a multi-space Project: the error matches the sentinel via
+// errors.Is and its message names the candidate Space keys in order.
+func TestProjectSpaceAmbiguousError(t *testing.T) {
+	err := error(&ProjectSpaceAmbiguousError{SpaceKeys: []string{"ENG", "GROWTH"}})
+
+	if !errors.Is(err, ErrProjectSpaceAmbiguous) {
+		t.Fatalf("expected errors.Is(err, ErrProjectSpaceAmbiguous) to be true")
+	}
+	// The other typed space errors must not match, so handlers can branch on them
+	// independently.
+	if errors.Is(err, ErrSpaceNotFound) || errors.Is(err, ErrSpaceArchived) {
+		t.Fatalf("ambiguous error must not match unrelated space sentinels")
+	}
+
+	const want = "project has multiple spaces (ENG, GROWTH); specify space_id"
+	if got := err.Error(); got != want {
+		t.Fatalf("message mismatch:\n got %q\nwant %q", got, want)
+	}
+
+	var amb *ProjectSpaceAmbiguousError
+	if !errors.As(err, &amb) {
+		t.Fatalf("expected errors.As to recover *ProjectSpaceAmbiguousError")
+	}
+	if len(amb.SpaceKeys) != 2 || amb.SpaceKeys[0] != "ENG" || amb.SpaceKeys[1] != "GROWTH" {
+		t.Fatalf("recovered space keys mismatch: %v", amb.SpaceKeys)
+	}
+}
diff --git a/server/internal/service/resolve_originator_test.go b/server/internal/service/resolve_originator_test.go
index 4b2e052ce2..883779ab03 100644
--- a/server/internal/service/resolve_originator_test.go
+++ b/server/internal/service/resolve_originator_test.go
@@ -148,6 +148,12 @@ func seedOriginatorFanout(t *testing.T, pool *pgxpool.Pool) (memberCommentID, ag
 	`, workspaceID, userIDStr); err != nil {
 		t.Fatalf("seed member: %v", err)
 	}
+	if _, err := pool.Exec(ctx, `
+		INSERT INTO workspace_space (workspace_id, name, key, created_by)
+		VALUES ($1, 'Default', 'DEF', $2)
+	`, workspaceID, userIDStr); err != nil {
+		t.Fatalf("seed default space: %v", err)
+	}
 
 	if err := pool.QueryRow(ctx, `
 		INSERT INTO agent_runtime (
@@ -185,8 +191,8 @@ func seedOriginatorFanout(t *testing.T, pool *pgxpool.Pool) (memberCommentID, ag
 	}
 
 	if err := pool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, creator_type, creator_id)
-		VALUES ($1, 'fanout-issue', 'member', $2)
+		INSERT INTO issue (workspace_id, space_id, title, creator_type, creator_id)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'fanout-issue', 'member', $2)
 		RETURNING id
 	`, workspaceID, userIDStr).Scan(&issueID); err != nil {
 		t.Fatalf("seed issue: %v", err)
@@ -348,6 +354,12 @@ func TestEnqueueTaskForIssueStoresRuntimeMCPOverlayInQueuedRow(t *testing.T) {
 	`, workspaceIDStr, userIDStr); err != nil {
 		t.Fatalf("seed member: %v", err)
 	}
+	if _, err := pool.Exec(ctx, `
+		INSERT INTO workspace_space (workspace_id, name, key, created_by)
+		VALUES ($1, 'Default', 'DEF', $2)
+	`, workspaceIDStr, userIDStr); err != nil {
+		t.Fatalf("seed default space: %v", err)
+	}
 	if err := pool.QueryRow(ctx, `
 		INSERT INTO agent_runtime (
 			workspace_id, name, runtime_mode, provider, status, device_info, metadata, owner_id
@@ -370,9 +382,9 @@ func TestEnqueueTaskForIssueStoresRuntimeMCPOverlayInQueuedRow(t *testing.T) {
 	}
 	if err := pool.QueryRow(ctx, `
 		INSERT INTO issue (
-			workspace_id, title, creator_type, creator_id, assignee_type, assignee_id, priority
+			workspace_id, space_id, title, creator_type, creator_id, assignee_type, assignee_id, priority
 		)
-		VALUES ($1, 'runtime overlay issue', 'member', $2, 'agent', $3, 'medium')
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), 'runtime overlay issue', 'member', $2, 'agent', $3, 'medium')
 		RETURNING id
 	`, workspaceIDStr, userIDStr, agentIDStr).Scan(&issueIDStr); err != nil {
 		t.Fatalf("seed issue: %v", err)
diff --git a/server/internal/service/task.go b/server/internal/service/task.go
index a7b7c440b9..cf8c71a105 100644
--- a/server/internal/service/task.go
+++ b/server/internal/service/task.go
@@ -16,6 +16,7 @@ import (
 	"github.com/multica-ai/multica/server/internal/analytics"
 	"github.com/multica-ai/multica/server/internal/events"
 	"github.com/multica-ai/multica/server/internal/featureflags"
+	"github.com/multica-ai/multica/server/internal/issueidentifier"
 	obsmetrics "github.com/multica-ai/multica/server/internal/metrics"
 	"github.com/multica-ai/multica/server/internal/realtime"
 	"github.com/multica-ai/multica/server/internal/runtimeapps"
@@ -860,6 +861,9 @@ type QuickCreateContext struct {
 	RequesterID   string   `json:"requester_id"`
 	WorkspaceID   string   `json:"workspace_id"`
 	ProjectID     string   `json:"project_id,omitempty"`
+	SpaceID       string   `json:"space_id,omitempty"`
+	SpaceKey      string   `json:"space_key,omitempty"`
+	SpaceName     string   `json:"space_name,omitempty"`
 	SquadID       string   `json:"squad_id,omitempty"`
 	AttachmentIDs []string `json:"attachment_ids,omitempty"`
 	// ParentIssueID is the optional UUID of the parent issue the new issue
@@ -893,7 +897,7 @@ const QuickCreateContextType = "quick_create"
 // parentIssueID is optional (zero-valued pgtype.UUID when the user didn't
 // open the modal from "Add sub issue"). The handler is responsible for
 // validating it belongs to the same workspace before passing it in.
-func (s *TaskService) EnqueueQuickCreateTask(ctx context.Context, workspaceID, requesterID pgtype.UUID, agentID, squadID pgtype.UUID, prompt string, projectID, parentIssueID pgtype.UUID, attachmentIDs []pgtype.UUID) (db.AgentTaskQueue, error) {
+func (s *TaskService) EnqueueQuickCreateTask(ctx context.Context, workspaceID, requesterID pgtype.UUID, agentID, squadID pgtype.UUID, prompt string, projectID, parentIssueID, spaceID pgtype.UUID, attachmentIDs []pgtype.UUID) (db.AgentTaskQueue, error) {
 	agent, err := s.Queries.GetAgent(ctx, agentID)
 	if err != nil {
 		return db.AgentTaskQueue{}, fmt.Errorf("load agent: %w", err)
@@ -914,6 +918,16 @@ func (s *TaskService) EnqueueQuickCreateTask(ctx context.Context, workspaceID, r
 	if projectID.Valid {
 		payload.ProjectID = util.UUIDToString(projectID)
 	}
+	if spaceID.Valid {
+		payload.SpaceID = util.UUIDToString(spaceID)
+		if space, err := s.Queries.GetWorkspaceSpace(ctx, db.GetWorkspaceSpaceParams{
+			ID:          spaceID,
+			WorkspaceID: workspaceID,
+		}); err == nil {
+			payload.SpaceKey = space.Key
+			payload.SpaceName = space.Name
+		}
+	}
 	if squadID.Valid {
 		payload.SquadID = util.UUIDToString(squadID)
 	}
@@ -2201,7 +2215,7 @@ func (s *TaskService) HandleFailedTasks(ctx context.Context, tasks []db.AgentTas
 							// it here too. Without it the board / status-filter
 							// caches keep showing the issue as in_progress until
 							// the next write touches it (#4648 / MUL-3782).
-							s.broadcastIssueUpdated(updatedIssue, issue.Status)
+							s.broadcastIssueUpdated(ctx, updatedIssue, issue.Status)
 						}
 					}
 				}
@@ -2635,8 +2649,8 @@ func (s *TaskService) broadcastChatDone(ctx context.Context, task db.AgentTaskQu
 // emit status-change activity / notifications. That is intentional for the
 // realtime-staleness fix (#4648 / MUL-3782); folding those side effects in
 // would mean unifying the payload type and is left as a follow-up.
-func (s *TaskService) broadcastIssueUpdated(issue db.Issue, prevStatus string) {
-	prefix := s.getIssuePrefix(issue.WorkspaceID)
+func (s *TaskService) broadcastIssueUpdated(ctx context.Context, issue db.Issue, prevStatus string) {
+	prefix := issueidentifier.PrefixForIssue(ctx, s.Queries, issue)
 	s.Bus.Publish(events.Event{
 		Type:        protocol.EventIssueUpdated,
 		WorkspaceID: util.UUIDToString(issue.WorkspaceID),
@@ -2650,14 +2664,6 @@ func (s *TaskService) broadcastIssueUpdated(issue db.Issue, prevStatus string) {
 	})
 }
 
-func (s *TaskService) getIssuePrefix(workspaceID pgtype.UUID) string {
-	ws, err := s.Queries.GetWorkspace(context.Background(), workspaceID)
-	if err != nil {
-		return ""
-	}
-	return ws.IssuePrefix
-}
-
 func (s *TaskService) createAgentComment(ctx context.Context, issueID, agentID pgtype.UUID, content, commentType string, parentID, sourceTaskID pgtype.UUID) {
 	if content == "" {
 		return
@@ -2760,6 +2766,8 @@ func issueToMap(issue db.Issue, issuePrefix string) map[string]any {
 	return map[string]any{
 		"id":              util.UUIDToString(issue.ID),
 		"workspace_id":    util.UUIDToString(issue.WorkspaceID),
+		"space_id":        util.UUIDToPtr(issue.SpaceID),
+		"space_key":       issuePrefix,
 		"number":          issue.Number,
 		"identifier":      issuePrefix + "-" + strconv.Itoa(int(issue.Number)),
 		"title":           issue.Title,
@@ -2884,7 +2892,7 @@ func (s *TaskService) notifyQuickCreateCompleted(ctx context.Context, task db.Ag
 			},
 		})
 	}
-	prefix := s.getIssuePrefix(workspaceID)
+	prefix := issueidentifier.PrefixForIssue(ctx, s.Queries, issue)
 	identifier := fmt.Sprintf("%s-%d", prefix, issue.Number)
 	details, _ := json.Marshal(map[string]any{
 		"task_id":         util.UUIDToString(task.ID),
diff --git a/server/internal/service/task_claim_race_test.go b/server/internal/service/task_claim_race_test.go
index e0a0237b0f..663052411b 100644
--- a/server/internal/service/task_claim_race_test.go
+++ b/server/internal/service/task_claim_race_test.go
@@ -168,6 +168,15 @@ func createClaimCapacityFixture(t *testing.T, ctx context.Context, pool *pgxpool
 		t.Fatalf("create member: %v", err)
 	}
 
+	// Seed the default Space so direct issue inserts can carry the NOT NULL
+	// space_id (migration 132), matching how migration 131 backfills production.
+	if _, err := pool.Exec(ctx, `
+		INSERT INTO workspace_space (workspace_id, name, key, created_by)
+		VALUES ($1, 'Default', 'CCR', $2)
+	`, workspaceID, userID); err != nil {
+		t.Fatalf("create default space: %v", err)
+	}
+
 	var runtimeID string
 	if err := pool.QueryRow(ctx, `
 		INSERT INTO agent_runtime (
@@ -205,8 +214,8 @@ func createClaimCapacityFixture(t *testing.T, ctx context.Context, pool *pgxpool
 	for i := 0; i < 2; i++ {
 		var issueID string
 		if err := pool.QueryRow(ctx, `
-			INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position)
-			VALUES ($1, $2, 'in_progress', 'none', $3, 'member', $4, $5)
+			INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type, number, position)
+			VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), $2, 'in_progress', 'none', $3, 'member', $4, $5)
 			RETURNING id
 		`, workspaceID, fmt.Sprintf("claim capacity issue %d", i+1), userID, 900000+i, i).Scan(&issueID); err != nil {
 			t.Fatalf("create issue %d: %v", i+1, err)
diff --git a/server/internal/service/task_dedup_head_sha_test.go b/server/internal/service/task_dedup_head_sha_test.go
index d337d4b0c3..d7fc0c6991 100644
--- a/server/internal/service/task_dedup_head_sha_test.go
+++ b/server/internal/service/task_dedup_head_sha_test.go
@@ -81,6 +81,12 @@ func createHeadShaDedupFixture(t *testing.T, ctx context.Context, pool *pgxpool.
 	`, workspaceID, userID); err != nil {
 		t.Fatalf("create member: %v", err)
 	}
+	if _, err := pool.Exec(ctx, `
+		INSERT INTO workspace_space (workspace_id, name, key, created_by)
+		VALUES ($1, 'Default', 'HSD', $2)
+	`, workspaceID, userID); err != nil {
+		t.Fatalf("create default space: %v", err)
+	}
 
 	var runtimeID string
 	if err := pool.QueryRow(ctx, `
@@ -108,8 +114,8 @@ func createHeadShaDedupFixture(t *testing.T, ctx context.Context, pool *pgxpool.
 
 	var issueID string
 	if err := pool.QueryRow(ctx, `
-		INSERT INTO issue (workspace_id, title, status, priority, creator_id, creator_type, number, position)
-		VALUES ($1, $2, 'in_review', 'none', $3, 'member', $4, 0)
+		INSERT INTO issue (workspace_id, space_id, title, status, priority, creator_id, creator_type, number, position)
+		VALUES ($1, (SELECT id FROM workspace_space WHERE workspace_id = $1 LIMIT 1), $2, 'in_review', 'none', $3, 'member', $4, 0)
 		RETURNING id
 	`, workspaceID, "head sha dedup issue", userID, 970000+int(suffix%1000)).Scan(&issueID); err != nil {
 		t.Fatalf("create issue: %v", err)
diff --git a/server/internal/service/task_issue_broadcast_test.go b/server/internal/service/task_issue_broadcast_test.go
index e74a834c21..1c192d4456 100644
--- a/server/internal/service/task_issue_broadcast_test.go
+++ b/server/internal/service/task_issue_broadcast_test.go
@@ -12,9 +12,9 @@ import (
 	"github.com/multica-ai/multica/server/pkg/protocol"
 )
 
-// noRowsDBTX makes every read return pgx.ErrNoRows so getIssuePrefix's
-// GetWorkspace lookup falls back to an empty prefix without needing a DB. The
-// helper under test still publishes regardless of the prefix result.
+// noRowsDBTX makes every read return pgx.ErrNoRows so the identifier prefix
+// lookup falls back to an empty prefix without needing a DB. The helper under
+// test still publishes regardless of the prefix result.
 type noRowsDBTX struct{}
 
 func (noRowsDBTX) Exec(context.Context, string, ...any) (pgconn.CommandTag, error) {
@@ -51,7 +51,7 @@ func TestBroadcastIssueUpdated_EmitsStatusChange(t *testing.T) {
 		Number:      7,
 		Status:      "todo",
 	}
-	svc.broadcastIssueUpdated(issue, "in_progress")
+	svc.broadcastIssueUpdated(context.Background(), issue, "in_progress")
 
 	if len(got) != 1 {
 		t.Fatalf("expected exactly 1 published event, got %d", len(got))
@@ -104,7 +104,7 @@ func TestBroadcastIssueUpdated_NoStatusChange(t *testing.T) {
 		WorkspaceID: testUUID(2),
 		Status:      "todo",
 	}
-	svc.broadcastIssueUpdated(issue, "todo")
+	svc.broadcastIssueUpdated(context.Background(), issue, "todo")
 
 	if len(got) != 1 {
 		t.Fatalf("expected exactly 1 published event, got %d", len(got))
diff --git a/server/migrations/131_workspace_space.down.sql b/server/migrations/131_workspace_space.down.sql
new file mode 100644
index 0000000000..54f47fcced
--- /dev/null
+++ b/server/migrations/131_workspace_space.down.sql
@@ -0,0 +1,18 @@
+DROP INDEX IF EXISTS idx_autopilot_workspace_space;
+ALTER TABLE autopilot DROP CONSTRAINT IF EXISTS fk_autopilot_workspace_space;
+ALTER TABLE autopilot DROP COLUMN IF EXISTS space_id;
+
+DROP INDEX IF EXISTS idx_issue_project_space;
+DROP INDEX IF EXISTS idx_issue_workspace_space_created_at;
+DROP INDEX IF EXISTS idx_issue_workspace_space_status_position;
+ALTER TABLE issue DROP CONSTRAINT IF EXISTS fk_issue_workspace_space;
+ALTER TABLE issue DROP COLUMN IF EXISTS space_id;
+
+DROP TABLE IF EXISTS project_space;
+ALTER TABLE project DROP CONSTRAINT IF EXISTS uq_project_workspace_id;
+
+DROP TABLE IF EXISTS workspace_space_member;
+
+DROP INDEX IF EXISTS idx_workspace_space_active;
+DROP INDEX IF EXISTS uq_workspace_space_workspace_key_lower;
+DROP TABLE IF EXISTS workspace_space;
diff --git a/server/migrations/131_workspace_space.up.sql b/server/migrations/131_workspace_space.up.sql
new file mode 100644
index 0000000000..6cc7bf4b1f
--- /dev/null
+++ b/server/migrations/131_workspace_space.up.sql
@@ -0,0 +1,186 @@
+-- Space ownership additive rollout.
+--
+-- This migration deliberately stops before the numbering cutover:
+-- issue.space_id and autopilot.space_id are nullable here, and
+-- uq_issue_workspace_number remains in place. Migration B can only run after
+-- all write and resolver paths are Space-aware.
+
+-- Deterministically normalize each workspace's legacy issue_prefix into a Space
+-- key that satisfies the workspace_space CHECK (^[A-Z][A-Z0-9]{0,6}$). Legacy
+-- data legitimately contains 8-10 char prefixes (the old UI allowed
+-- slice(0, 10)) and digit-first prefixes, so aborting the deploy on those would
+-- brick upgrades. Instead we normalize: uppercase, strip non-[A-Z0-9],
+-- truncate to 7; if the result is digit-first, prefix 'T' and re-truncate to 7;
+-- if nothing usable remains, fall back to 'SPACE'. The default-space backfill and
+-- every other prefix consumer in this migration use the same function so the
+-- seeded key can never diverge from what is emitted below.
+CREATE FUNCTION pg_temp.normalize_space_key(prefix text) RETURNS text AS $$
+DECLARE
+    cleaned text;
+BEGIN
+    cleaned := left(regexp_replace(upper(coalesce(prefix, '')), '[^A-Z0-9]', '', 'g'), 7);
+    IF cleaned ~ '^[0-9]' THEN
+        cleaned := left('T' || cleaned, 7);
+    END IF;
+    IF cleaned = '' THEN
+        cleaned := 'SPACE';
+    END IF;
+    RETURN cleaned;
+END;
+$$ LANGUAGE plpgsql IMMUTABLE;
+
+DO $$
+DECLARE
+    rec record;
+    counter_regression_count integer;
+BEGIN
+    -- Surface every prefix that had to be rewritten so operators can reconcile
+    -- external references to the old key. Informational only, never fatal.
+    FOR rec IN
+        SELECT w.id AS workspace_id,
+               upper(btrim(w.issue_prefix)) AS old_key,
+               pg_temp.normalize_space_key(w.issue_prefix) AS new_key
+        FROM workspace w
+        WHERE pg_temp.normalize_space_key(w.issue_prefix) <> upper(btrim(w.issue_prefix))
+        ORDER BY w.id
+    LOOP
+        RAISE NOTICE 'workspace_space: normalized issue_prefix for workspace % (% -> %)',
+            rec.workspace_id, rec.old_key, rec.new_key;
+    END LOOP;
+
+    SELECT count(*) INTO counter_regression_count
+    FROM workspace w
+    WHERE w.issue_counter < (
+        SELECT COALESCE(max(i.number), 0)
+        FROM issue i
+        WHERE i.workspace_id = w.id
+    );
+
+    IF counter_regression_count > 0 THEN
+        RAISE EXCEPTION 'workspace_space preflight failed: % workspace.issue_counter values are below max(issue.number)', counter_regression_count;
+    END IF;
+END $$;
+
+CREATE TABLE workspace_space (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    workspace_id UUID NOT NULL REFERENCES workspace(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    key TEXT NOT NULL CHECK (key ~ '^[A-Z][A-Z0-9]{0,6}$'),
+    description TEXT NOT NULL DEFAULT '',
+    icon TEXT,
+    issue_counter INT NOT NULL DEFAULT 0 CHECK (issue_counter >= 0),
+    archived_at TIMESTAMPTZ,
+    archived_by UUID REFERENCES "user"(id) ON DELETE SET NULL,
+    created_by UUID REFERENCES "user"(id) ON DELETE SET NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    UNIQUE(workspace_id, id)
+);
+
+-- No is_default flag: every workspace is guaranteed >=1 active Space by the
+-- ArchiveSpace handler refusing to archive the last one (see space.sql /
+-- ArchiveWorkspaceSpace). The Space callers fall back to when none is
+-- specified (GetDefaultWorkspaceSpace) is simply the workspace's
+-- earliest-created active Space — deterministic from created_at, nothing to
+-- store. The row backfilled below is that earliest Space by construction,
+-- since no Space could exist for a workspace before this migration ran.
+CREATE UNIQUE INDEX uq_workspace_space_workspace_key_lower
+    ON workspace_space(workspace_id, lower(key));
+CREATE INDEX idx_workspace_space_active
+    ON workspace_space(workspace_id)
+    WHERE archived_at IS NULL;
+
+CREATE TABLE workspace_space_member (
+    workspace_id UUID NOT NULL,
+    space_id UUID NOT NULL,
+    user_id UUID NOT NULL,
+    role TEXT NOT NULL DEFAULT 'member' CHECK (role IN ('lead', 'member')),
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (space_id, user_id),
+    FOREIGN KEY (workspace_id, space_id) REFERENCES workspace_space(workspace_id, id) ON DELETE CASCADE,
+    FOREIGN KEY (workspace_id, user_id) REFERENCES member(workspace_id, user_id) ON DELETE CASCADE
+);
+
+ALTER TABLE project
+    ADD CONSTRAINT uq_project_workspace_id UNIQUE (workspace_id, id);
+
+CREATE TABLE project_space (
+    workspace_id UUID NOT NULL,
+    project_id UUID NOT NULL,
+    space_id UUID NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (project_id, space_id),
+    FOREIGN KEY (workspace_id, project_id) REFERENCES project(workspace_id, id) ON DELETE CASCADE,
+    FOREIGN KEY (workspace_id, space_id) REFERENCES workspace_space(workspace_id, id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_project_space_workspace_space
+    ON project_space(workspace_id, space_id);
+
+ALTER TABLE issue
+    ADD COLUMN space_id UUID;
+
+ALTER TABLE issue
+    ADD CONSTRAINT fk_issue_workspace_space
+    FOREIGN KEY (workspace_id, space_id) REFERENCES workspace_space(workspace_id, id);
+
+CREATE INDEX idx_issue_workspace_space_status_position
+    ON issue(workspace_id, space_id, status, position);
+CREATE INDEX idx_issue_workspace_space_created_at
+    ON issue(workspace_id, space_id, created_at DESC);
+CREATE INDEX idx_issue_project_space
+    ON issue(workspace_id, project_id, space_id)
+    WHERE project_id IS NOT NULL;
+
+ALTER TABLE autopilot
+    ADD COLUMN space_id UUID;
+
+ALTER TABLE autopilot
+    ADD CONSTRAINT fk_autopilot_workspace_space
+    FOREIGN KEY (workspace_id, space_id) REFERENCES workspace_space(workspace_id, id);
+
+CREATE INDEX idx_autopilot_workspace_space
+    ON autopilot(workspace_id, space_id);
+
+-- This is the only Space any workspace has at this point in the migration, so
+-- every join below against workspace_space by workspace_id alone already
+-- resolves to exactly this row — no is_default marker needed to disambiguate.
+INSERT INTO workspace_space (workspace_id, name, key, issue_counter, created_by)
+SELECT
+    w.id,
+    w.name,
+    pg_temp.normalize_space_key(w.issue_prefix),
+    w.issue_counter,
+    (
+        SELECT m.user_id
+        FROM member m
+        WHERE m.workspace_id = w.id
+        ORDER BY (m.role = 'owner') DESC, m.created_at ASC
+        LIMIT 1
+    )
+FROM workspace w;
+
+INSERT INTO workspace_space_member (workspace_id, space_id, user_id, role)
+SELECT wt.workspace_id, wt.id, m.user_id,
+       CASE WHEN m.role IN ('owner', 'admin') THEN 'lead' ELSE 'member' END
+FROM workspace_space wt
+JOIN member m ON m.workspace_id = wt.workspace_id;
+
+UPDATE issue i
+SET space_id = wt.id
+FROM workspace_space wt
+WHERE wt.workspace_id = i.workspace_id
+  AND i.space_id IS NULL;
+
+UPDATE autopilot a
+SET space_id = wt.id
+FROM workspace_space wt
+WHERE wt.workspace_id = a.workspace_id
+  AND a.space_id IS NULL;
+
+INSERT INTO project_space (workspace_id, project_id, space_id)
+SELECT p.workspace_id, p.id, wt.id
+FROM project p
+JOIN workspace_space wt ON wt.workspace_id = p.workspace_id;
+
+DROP FUNCTION pg_temp.normalize_space_key(text);
diff --git a/server/migrations/132_space_number_cutover.down.sql b/server/migrations/132_space_number_cutover.down.sql
new file mode 100644
index 0000000000..dbddd47fd5
--- /dev/null
+++ b/server/migrations/132_space_number_cutover.down.sql
@@ -0,0 +1,27 @@
+-- Reverse of the space-numbering cutover (Migration B).
+--
+-- Restores the additive 131 state: space_id nullable again, space-scoped
+-- uniqueness dropped, legacy workspace-scoped uniqueness restored.
+--
+-- WARNING: re-adding uq_issue_workspace_number WILL FAIL if per-space numbering
+-- has already minted overlapping numbers across spaces in the same workspace
+-- (e.g. ENG-1 and DES-1 both exist as issue.number = 1 under one workspace).
+-- That failure is inherent: once spaces number independently from 1, the
+-- workspace-number space is no longer unique. This down migration deliberately
+-- attempts the constraint and lets Postgres error out rather than silently
+-- dropping the constraint or renumbering data. Recovery requires renumbering
+-- issues into a single monotonic per-workspace sequence before this migration
+-- can complete — or accepting that the cutover is effectively one-way once
+-- multi-space numbers have been minted.
+--
+-- The re-backfill of NULL space_id done by the up migration is not reversed:
+-- which rows were originally NULL is not recoverable, and 131's own down
+-- migration drops the space_id column entirely anyway.
+
+ALTER TABLE issue DROP CONSTRAINT IF EXISTS uq_issue_space_number;
+
+ALTER TABLE autopilot ALTER COLUMN space_id DROP NOT NULL;
+ALTER TABLE issue ALTER COLUMN space_id DROP NOT NULL;
+
+-- May fail by design; see the WARNING above.
+ALTER TABLE issue ADD CONSTRAINT uq_issue_workspace_number UNIQUE (workspace_id, number);
diff --git a/server/migrations/132_space_number_cutover.up.sql b/server/migrations/132_space_number_cutover.up.sql
new file mode 100644
index 0000000000..0be9a508e7
--- /dev/null
+++ b/server/migrations/132_space_number_cutover.up.sql
@@ -0,0 +1,161 @@
+-- Space numbering cutover ("Migration B").
+--
+-- Phase 2 of the two-phase space-numbering rollout. Migration 131 added the
+-- Space schema additively: issue.space_id / autopilot.space_id are nullable and
+-- the legacy uq_issue_workspace_number (UNIQUE(workspace_id, number)) still
+-- holds. This migration runs ONLY after every old, space-unaware server
+-- instance has drained, so no writer can still emit a NULL space_id.
+--
+-- It is SAFE-BY-CONSTRUCTION: it re-backfills stragglers, syncs counters
+-- upward (never regressing), then VALIDATES the preconditions and RAISEs with
+-- actionable detail if anything is off. It never silently "fixes" corrupt
+-- data. Only after validation passes does it flip the columns to NOT NULL and
+-- swap workspace-scoped uniqueness for space-scoped uniqueness, so that spaces
+-- number independently from 1 (Linear-style ENG-1, DES-1, ...).
+--
+-- Steps, in order:
+--   1. Re-backfill any issue/autopilot rows an old instance wrote with a NULL
+--      space_id during the deploy window to the workspace's default Space, using
+--      the same join shape as 131.
+--   2. Sync each Space's issue_counter upward to cover the highest number
+--      actually minted into it, and — for default Spaces — the legacy
+--      workspace.issue_counter that old writers advanced during the window.
+--      Counters never regress.
+--   3. Validate (DO block, RAISE EXCEPTION on failure): zero remaining NULL
+--      space_id in issue and autopilot; zero duplicate (space_id, number) pairs
+--      in issue. Duplicates are theoretically impossible while
+--      uq_issue_workspace_number holds and every issue maps to exactly one
+--      Space within its workspace, but we validate anyway and fail loudly
+--      rather than mint a broken unique index.
+--   4. Cut over: space_id NOT NULL on issue + autopilot; drop
+--      uq_issue_workspace_number; add uq_issue_space_number UNIQUE(space_id,
+--      number).
+--
+-- Transaction / locking notes:
+--   cmd/migrate executes each .sql file as one implicit transaction (a single
+--   conn.Exec). Every statement below is transaction-safe (no CREATE INDEX
+--   CONCURRENTLY), so the whole cutover is atomic: any RAISE in step 3 rolls
+--   the file back and leaves schema_migrations unchanged for a clean retry.
+--   The ALTER TABLE / constraint swap on `issue` briefly takes an ACCESS
+--   EXCLUSIVE lock; acceptable at this product's scale and kept short by doing
+--   all validation before the locking DDL.
+--
+-- workspace.issue_prefix / issue_counter are intentionally retained here; a
+-- later cleanup migration drops them once nothing reads them (per plan).
+
+-- 1. Re-backfill stragglers written by old instances during the deploy window,
+--    to the same workspace's earliest active Space — the same fallback
+--    GetDefaultWorkspaceSpace resolves to at runtime (no is_default flag; see
+--    131's comment on workspace_space).
+UPDATE issue i
+SET space_id = wt.id
+FROM workspace_space wt
+WHERE wt.workspace_id = i.workspace_id
+  AND wt.archived_at IS NULL
+  AND wt.id = (
+      SELECT w2.id FROM workspace_space w2
+      WHERE w2.workspace_id = i.workspace_id AND w2.archived_at IS NULL
+      ORDER BY w2.created_at ASC, w2.id ASC
+      LIMIT 1
+  )
+  AND i.space_id IS NULL;
+
+UPDATE autopilot a
+SET space_id = wt.id
+FROM workspace_space wt
+WHERE wt.workspace_id = a.workspace_id
+  AND wt.archived_at IS NULL
+  AND wt.id = (
+      SELECT w2.id FROM workspace_space w2
+      WHERE w2.workspace_id = a.workspace_id AND w2.archived_at IS NULL
+      ORDER BY w2.created_at ASC, w2.id ASC
+      LIMIT 1
+  )
+  AND a.space_id IS NULL;
+
+-- 2. Sync counters upward. GREATEST of the current counter, the max number
+--    actually minted into the Space, and (for the workspace's earliest Space
+--    only — there is no is_default flag, but that Space is always the one
+--    migration 131 backfilled from the legacy workspace counter, since no
+--    other Space could have existed before that migration ran) the legacy
+--    workspace counter old writers incremented. Deliberately not filtered to
+--    archived_at IS NULL: this identifies which Space historically inherited
+--    the legacy counter, which doesn't change if that Space was later
+--    archived. The WHERE guard keeps this to only the rows that would
+--    actually rise, so counters never regress.
+UPDATE workspace_space wt
+SET issue_counter = GREATEST(
+        wt.issue_counter,
+        COALESCE((SELECT max(i.number) FROM issue i WHERE i.space_id = wt.id), 0),
+        CASE WHEN wt.id = (
+                 SELECT w2.id FROM workspace_space w2
+                 WHERE w2.workspace_id = wt.workspace_id
+                 ORDER BY w2.created_at ASC, w2.id ASC
+                 LIMIT 1
+             )
+             THEN COALESCE((SELECT w.issue_counter FROM workspace w WHERE w.id = wt.workspace_id), 0)
+             ELSE 0 END
+    ),
+    updated_at = now()
+WHERE wt.issue_counter < GREATEST(
+        COALESCE((SELECT max(i.number) FROM issue i WHERE i.space_id = wt.id), 0),
+        CASE WHEN wt.id = (
+                 SELECT w2.id FROM workspace_space w2
+                 WHERE w2.workspace_id = wt.workspace_id
+                 ORDER BY w2.created_at ASC, w2.id ASC
+                 LIMIT 1
+             )
+             THEN COALESCE((SELECT w.issue_counter FROM workspace w WHERE w.id = wt.workspace_id), 0)
+             ELSE 0 END
+    );
+
+-- 3. Validation preflight. Fail loudly with actionable counts/ids; never fix.
+DO $$
+DECLARE
+    null_issue_count integer;
+    null_autopilot_count integer;
+    dup_count integer;
+    offenders text;
+BEGIN
+    SELECT count(*) INTO null_issue_count FROM issue WHERE space_id IS NULL;
+    SELECT count(*) INTO null_autopilot_count FROM autopilot WHERE space_id IS NULL;
+    IF null_issue_count > 0 OR null_autopilot_count > 0 THEN
+        RAISE EXCEPTION 'space_number_cutover preflight failed: % issue and % autopilot rows still have NULL space_id. An old, space-unaware instance is likely still writing; drain every old instance before running Migration B.',
+            null_issue_count, null_autopilot_count;
+    END IF;
+
+    SELECT count(*) INTO dup_count
+    FROM (
+        SELECT space_id, number
+        FROM issue
+        GROUP BY space_id, number
+        HAVING count(*) > 1
+    ) d;
+    IF dup_count > 0 THEN
+        SELECT string_agg(format('(space_id=%s, number=%s, count=%s)', space_id, number, cnt), ', ')
+        INTO offenders
+        FROM (
+            SELECT space_id, number, count(*) AS cnt
+            FROM issue
+            GROUP BY space_id, number
+            HAVING count(*) > 1
+            ORDER BY count(*) DESC
+            LIMIT 20
+        ) s;
+        RAISE EXCEPTION 'space_number_cutover preflight failed: % duplicate (space_id, number) pairs exist; refusing to create uq_issue_space_number. Offenders (up to 20): %',
+            dup_count, offenders;
+    END IF;
+END $$;
+
+-- 4. Cutover. Validation above guarantees these succeed.
+ALTER TABLE issue ALTER COLUMN space_id SET NOT NULL;
+ALTER TABLE autopilot ALTER COLUMN space_id SET NOT NULL;
+
+-- Swap workspace-scoped uniqueness for space-scoped uniqueness. Dropping the
+-- constraint drops its backing unique index; the new uq_issue_space_number
+-- (space_id, number) serves the only remaining identifier lookup
+-- (GetIssueBySpaceKeyAndNumber, which joins on space_id then filters number).
+-- No production path resolves an issue by (workspace_id, number) after the
+-- resolver audit, so no replacement (workspace_id, number) index is added.
+ALTER TABLE issue DROP CONSTRAINT uq_issue_workspace_number;
+ALTER TABLE issue ADD CONSTRAINT uq_issue_space_number UNIQUE (space_id, number);
diff --git a/server/migrations/134_issue_identifier_alias.down.sql b/server/migrations/134_issue_identifier_alias.down.sql
new file mode 100644
index 0000000000..cb4fadf80b
--- /dev/null
+++ b/server/migrations/134_issue_identifier_alias.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS issue_identifier_alias;
diff --git a/server/migrations/134_issue_identifier_alias.up.sql b/server/migrations/134_issue_identifier_alias.up.sql
new file mode 100644
index 0000000000..107624f3d6
--- /dev/null
+++ b/server/migrations/134_issue_identifier_alias.up.sql
@@ -0,0 +1,16 @@
+-- Issue identifier aliases: when an issue moves to another space it is
+-- renumbered (numbers are per-space), so its old identifier (e.g. MUL-3)
+-- would stop resolving. Every move records the pre-move identifier here so
+-- identifier lookups (API/CLI, GitHub branch/PR auto-linking) can fall back
+-- to the alias and land on the moved issue. Numbers are never reused
+-- (issue_counter is monotonic), so an alias can never shadow a live issue.
+CREATE TABLE issue_identifier_alias (
+    workspace_id UUID NOT NULL REFERENCES workspace(id) ON DELETE CASCADE,
+    space_key_lower TEXT NOT NULL,
+    number INTEGER NOT NULL,
+    issue_id UUID NOT NULL REFERENCES issue(id) ON DELETE CASCADE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (workspace_id, space_key_lower, number)
+);
+
+CREATE INDEX idx_issue_identifier_alias_issue ON issue_identifier_alias(issue_id);
diff --git a/server/migrations/135_space_member_sort_order.down.sql b/server/migrations/135_space_member_sort_order.down.sql
new file mode 100644
index 0000000000..ec25cd7af2
--- /dev/null
+++ b/server/migrations/135_space_member_sort_order.down.sql
@@ -0,0 +1 @@
+ALTER TABLE workspace_space_member DROP COLUMN IF EXISTS sort_order;
diff --git a/server/migrations/135_space_member_sort_order.up.sql b/server/migrations/135_space_member_sort_order.up.sql
new file mode 100644
index 0000000000..86ef60f147
--- /dev/null
+++ b/server/migrations/135_space_member_sort_order.up.sql
@@ -0,0 +1,23 @@
+-- Per-user space ordering for the sidebar Spaces section (mirrors Linear's
+-- SpaceMembership.sortOrder). Fractional (double precision) so a drag can
+-- take the midpoint of its neighbors without rewriting sibling rows.
+-- The first space in a user's order is also the default space for issue
+-- creation when no other context applies.
+ALTER TABLE workspace_space_member
+    ADD COLUMN sort_order DOUBLE PRECISION NOT NULL DEFAULT 0;
+
+-- Backfill: stable per-user sequence by join time (default space first since
+-- it was backfilled earliest in migration 131).
+WITH ranked AS (
+    SELECT space_id, user_id,
+           row_number() OVER (
+               PARTITION BY workspace_id, user_id
+               ORDER BY created_at ASC, space_id ASC
+           )::double precision AS rn
+    FROM workspace_space_member
+)
+UPDATE workspace_space_member m
+SET sort_order = ranked.rn
+FROM ranked
+WHERE m.space_id = ranked.space_id
+  AND m.user_id = ranked.user_id;
diff --git a/server/pkg/db/generated/autopilot.sql.go b/server/pkg/db/generated/autopilot.sql.go
index 073a007c95..dc1656ad1e 100644
--- a/server/pkg/db/generated/autopilot.sql.go
+++ b/server/pkg/db/generated/autopilot.sql.go
@@ -92,16 +92,38 @@ func (q *Queries) ArchiveAutopilot(ctx context.Context, id pgtype.UUID) error {
 	return err
 }
 
+const countActiveAutopilotsBySpace = `-- name: CountActiveAutopilotsBySpace :one
+SELECT count(*) FROM autopilot
+WHERE workspace_id = $1
+  AND space_id = $2
+  AND status <> 'archived'
+`
+
+type CountActiveAutopilotsBySpaceParams struct {
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+	SpaceID     pgtype.UUID `json:"space_id"`
+}
+
+// Counts non-archived autopilots pinned to a Space. Used to block archiving a
+// Space that still drives live autopilots (mirrors CountActiveProjectAutopilotsBySpace,
+// which scopes the same liveness column to a single project).
+func (q *Queries) CountActiveAutopilotsBySpace(ctx context.Context, arg CountActiveAutopilotsBySpaceParams) (int64, error) {
+	row := q.db.QueryRow(ctx, countActiveAutopilotsBySpace, arg.WorkspaceID, arg.SpaceID)
+	var count int64
+	err := row.Scan(&count)
+	return count, err
+}
+
 const createAutopilot = `-- name: CreateAutopilot :one
 INSERT INTO autopilot (
     workspace_id, title, description, assignee_type, assignee_id,
-    status, execution_mode, issue_title_template, project_id,
+    status, execution_mode, issue_title_template, project_id, space_id,
     created_by_type, created_by_id
 ) VALUES (
-    $1, $2, $9, $3, $4,
-    $5, $6, $10, $11,
-    $7, $8
-) RETURNING id, workspace_id, title, description, assignee_id, status, execution_mode, issue_title_template, created_by_type, created_by_id, last_run_at, created_at, updated_at, assignee_type, project_id
+    $1, $2, $10, $3, $4,
+    $5, $6, $11, $12, $7,
+    $8, $9
+) RETURNING id, workspace_id, title, description, assignee_id, status, execution_mode, issue_title_template, created_by_type, created_by_id, last_run_at, created_at, updated_at, assignee_type, project_id, space_id
 `
 
 type CreateAutopilotParams struct {
@@ -111,6 +133,7 @@ type CreateAutopilotParams struct {
 	AssigneeID         pgtype.UUID `json:"assignee_id"`
 	Status             string      `json:"status"`
 	ExecutionMode      string      `json:"execution_mode"`
+	SpaceID            pgtype.UUID `json:"space_id"`
 	CreatedByType      string      `json:"created_by_type"`
 	CreatedByID        pgtype.UUID `json:"created_by_id"`
 	Description        pgtype.Text `json:"description"`
@@ -126,6 +149,7 @@ func (q *Queries) CreateAutopilot(ctx context.Context, arg CreateAutopilotParams
 		arg.AssigneeID,
 		arg.Status,
 		arg.ExecutionMode,
+		arg.SpaceID,
 		arg.CreatedByType,
 		arg.CreatedByID,
 		arg.Description,
@@ -149,6 +173,7 @@ func (q *Queries) CreateAutopilot(ctx context.Context, arg CreateAutopilotParams
 		&i.UpdatedAt,
 		&i.AssigneeType,
 		&i.ProjectID,
+		&i.SpaceID,
 	)
 	return i, err
 }
@@ -406,7 +431,7 @@ func (q *Queries) FailAutopilotRunsByIssue(ctx context.Context, issueID pgtype.U
 }
 
 const getAutopilot = `-- name: GetAutopilot :one
-SELECT id, workspace_id, title, description, assignee_id, status, execution_mode, issue_title_template, created_by_type, created_by_id, last_run_at, created_at, updated_at, assignee_type, project_id FROM autopilot
+SELECT id, workspace_id, title, description, assignee_id, status, execution_mode, issue_title_template, created_by_type, created_by_id, last_run_at, created_at, updated_at, assignee_type, project_id, space_id FROM autopilot
 WHERE id = $1
 `
 
@@ -429,12 +454,13 @@ func (q *Queries) GetAutopilot(ctx context.Context, id pgtype.UUID) (Autopilot,
 		&i.UpdatedAt,
 		&i.AssigneeType,
 		&i.ProjectID,
+		&i.SpaceID,
 	)
 	return i, err
 }
 
 const getAutopilotInWorkspace = `-- name: GetAutopilotInWorkspace :one
-SELECT id, workspace_id, title, description, assignee_id, status, execution_mode, issue_title_template, created_by_type, created_by_id, last_run_at, created_at, updated_at, assignee_type, project_id FROM autopilot
+SELECT id, workspace_id, title, description, assignee_id, status, execution_mode, issue_title_template, created_by_type, created_by_id, last_run_at, created_at, updated_at, assignee_type, project_id, space_id FROM autopilot
 WHERE id = $1 AND workspace_id = $2
 `
 
@@ -462,6 +488,7 @@ func (q *Queries) GetAutopilotInWorkspace(ctx context.Context, arg GetAutopilotI
 		&i.UpdatedAt,
 		&i.AssigneeType,
 		&i.ProjectID,
+		&i.SpaceID,
 	)
 	return i, err
 }
@@ -870,7 +897,7 @@ func (q *Queries) ListAutopilotTriggers(ctx context.Context, autopilotID pgtype.
 const listAutopilots = `-- name: ListAutopilots :many
 
 SELECT
-  a.id, a.workspace_id, a.title, a.description, a.assignee_id, a.status, a.execution_mode, a.issue_title_template, a.created_by_type, a.created_by_id, a.last_run_at, a.created_at, a.updated_at, a.assignee_type, a.project_id,
+  a.id, a.workspace_id, a.title, a.description, a.assignee_id, a.status, a.execution_mode, a.issue_title_template, a.created_by_type, a.created_by_id, a.last_run_at, a.created_at, a.updated_at, a.assignee_type, a.project_id, a.space_id,
   (
     SELECT array_agg(DISTINCT t.kind ORDER BY t.kind)
     FROM autopilot_trigger t
@@ -890,15 +917,17 @@ SELECT
   ), '')::text AS last_run_status
 FROM autopilot a
 WHERE a.workspace_id = $1
+  AND ($2::uuid IS NULL OR a.space_id = $2)
   AND (
-    ($2::text IS NULL AND a.status <> 'archived')
-    OR a.status = $2
+    ($3::text IS NULL AND a.status <> 'archived')
+    OR a.status = $3
   )
 ORDER BY a.created_at DESC
 `
 
 type ListAutopilotsParams struct {
 	WorkspaceID pgtype.UUID `json:"workspace_id"`
+	SpaceID     pgtype.UUID `json:"space_id"`
 	Status      pgtype.Text `json:"status"`
 }
 
@@ -919,7 +948,7 @@ type ListAutopilotsRow struct {
 // last_run_status is COALESCEd to ” (never ran) because sqlc cannot infer
 // nullability through a scalar subquery; the handler maps ” back to omitted.
 func (q *Queries) ListAutopilots(ctx context.Context, arg ListAutopilotsParams) ([]ListAutopilotsRow, error) {
-	rows, err := q.db.Query(ctx, listAutopilots, arg.WorkspaceID, arg.Status)
+	rows, err := q.db.Query(ctx, listAutopilots, arg.WorkspaceID, arg.SpaceID, arg.Status)
 	if err != nil {
 		return nil, err
 	}
@@ -943,6 +972,7 @@ func (q *Queries) ListAutopilots(ctx context.Context, arg ListAutopilotsParams)
 			&i.Autopilot.UpdatedAt,
 			&i.Autopilot.AssigneeType,
 			&i.Autopilot.ProjectID,
+			&i.Autopilot.SpaceID,
 			&i.TriggerKinds,
 			&i.NextRunAt,
 			&i.LastRunStatus,
@@ -1262,7 +1292,7 @@ const systemPauseAutopilot = `-- name: SystemPauseAutopilot :one
 UPDATE autopilot
 SET status = 'paused', updated_at = now()
 WHERE id = $1 AND status = 'active'
-RETURNING id, workspace_id, title, description, assignee_id, status, execution_mode, issue_title_template, created_by_type, created_by_id, last_run_at, created_at, updated_at, assignee_type, project_id
+RETURNING id, workspace_id, title, description, assignee_id, status, execution_mode, issue_title_template, created_by_type, created_by_id, last_run_at, created_at, updated_at, assignee_type, project_id, space_id
 `
 
 // Atomically pauses an autopilot only if it is currently active. Returns no
@@ -1288,6 +1318,7 @@ func (q *Queries) SystemPauseAutopilot(ctx context.Context, id pgtype.UUID) (Aut
 		&i.UpdatedAt,
 		&i.AssigneeType,
 		&i.ProjectID,
+		&i.SpaceID,
 	)
 	return i, err
 }
@@ -1318,9 +1349,10 @@ UPDATE autopilot SET
     execution_mode = COALESCE($7, execution_mode),
     issue_title_template = $8,
     project_id = $9,
+    space_id = COALESCE($10::uuid, space_id),
     updated_at = now()
 WHERE id = $1
-RETURNING id, workspace_id, title, description, assignee_id, status, execution_mode, issue_title_template, created_by_type, created_by_id, last_run_at, created_at, updated_at, assignee_type, project_id
+RETURNING id, workspace_id, title, description, assignee_id, status, execution_mode, issue_title_template, created_by_type, created_by_id, last_run_at, created_at, updated_at, assignee_type, project_id, space_id
 `
 
 type UpdateAutopilotParams struct {
@@ -1333,6 +1365,7 @@ type UpdateAutopilotParams struct {
 	ExecutionMode      pgtype.Text `json:"execution_mode"`
 	IssueTitleTemplate pgtype.Text `json:"issue_title_template"`
 	ProjectID          pgtype.UUID `json:"project_id"`
+	SpaceID            pgtype.UUID `json:"space_id"`
 }
 
 func (q *Queries) UpdateAutopilot(ctx context.Context, arg UpdateAutopilotParams) (Autopilot, error) {
@@ -1346,6 +1379,7 @@ func (q *Queries) UpdateAutopilot(ctx context.Context, arg UpdateAutopilotParams
 		arg.ExecutionMode,
 		arg.IssueTitleTemplate,
 		arg.ProjectID,
+		arg.SpaceID,
 	)
 	var i Autopilot
 	err := row.Scan(
@@ -1364,6 +1398,7 @@ func (q *Queries) UpdateAutopilot(ctx context.Context, arg UpdateAutopilotParams
 		&i.UpdatedAt,
 		&i.AssigneeType,
 		&i.ProjectID,
+		&i.SpaceID,
 	)
 	return i, err
 }
diff --git a/server/pkg/db/generated/issue.sql.go b/server/pkg/db/generated/issue.sql.go
index 71ae4b8460..93a300a1dd 100644
--- a/server/pkg/db/generated/issue.sql.go
+++ b/server/pkg/db/generated/issue.sql.go
@@ -96,20 +96,22 @@ func (q *Queries) CountCreatedIssueAssignees(ctx context.Context, arg CountCreat
 const countIssues = `-- name: CountIssues :one
 SELECT count(*) FROM issue i
 WHERE i.workspace_id = $1
-  AND ($2::text IS NULL OR i.status = $2)
-  AND ($3::text IS NULL OR i.priority = $3)
-  AND ($4::uuid IS NULL OR i.assignee_id = $4)
-  AND ($5::uuid[] IS NULL OR i.assignee_id = ANY($5::uuid[]))
-  AND ($6::uuid IS NULL OR i.creator_id = $6)
-  AND ($7::uuid IS NULL OR i.project_id = $7)
-  AND ($8::bool IS NULL OR (i.start_date IS NOT NULL OR i.due_date IS NOT NULL))
-  AND ($9::jsonb IS NULL OR i.metadata @> $9::jsonb)
+  AND ($2::uuid IS NULL OR i.space_id = $2)
+  AND ($3::uuid[] IS NULL OR i.space_id = ANY($3::uuid[]))
+  AND ($4::text IS NULL OR i.status = $4)
+  AND ($5::text IS NULL OR i.priority = $5)
+  AND ($6::uuid IS NULL OR i.assignee_id = $6)
+  AND ($7::uuid[] IS NULL OR i.assignee_id = ANY($7::uuid[]))
+  AND ($8::uuid IS NULL OR i.creator_id = $8)
+  AND ($9::uuid IS NULL OR i.project_id = $9)
+  AND ($10::bool IS NULL OR (i.start_date IS NOT NULL OR i.due_date IS NOT NULL))
+  AND ($11::jsonb IS NULL OR i.metadata @> $11::jsonb)
   AND (
-    $10::uuid IS NULL
+    $12::uuid IS NULL
     OR (i.assignee_type = 'agent' AND i.assignee_id IN (
           SELECT a.id FROM agent a
            WHERE a.workspace_id = $1
-             AND a.owner_id     = $10::uuid
+             AND a.owner_id     = $12::uuid
     ))
     OR (i.assignee_type = 'squad' AND i.assignee_id IN (
           SELECT sm.squad_id
@@ -117,14 +119,14 @@ WHERE i.workspace_id = $1
             JOIN squad s ON s.id = sm.squad_id
            WHERE s.workspace_id = $1
              AND sm.member_type = 'member'
-             AND sm.member_id   = $10::uuid
+             AND sm.member_id   = $12::uuid
           UNION
           SELECT s.id
             FROM squad s
             JOIN agent a ON a.id = s.leader_id
            WHERE s.workspace_id = $1
              AND a.workspace_id = $1
-             AND a.owner_id     = $10::uuid
+             AND a.owner_id     = $12::uuid
           UNION
           SELECT sm.squad_id
             FROM squad_member sm
@@ -133,13 +135,15 @@ WHERE i.workspace_id = $1
            WHERE s.workspace_id = $1
              AND sm.member_type = 'agent'
              AND a.workspace_id = $1
-             AND a.owner_id     = $10::uuid
+             AND a.owner_id     = $12::uuid
     ))
   )
 `
 
 type CountIssuesParams struct {
 	WorkspaceID    pgtype.UUID   `json:"workspace_id"`
+	SpaceID        pgtype.UUID   `json:"space_id"`
+	SpaceIds       []pgtype.UUID `json:"space_ids"`
 	Status         pgtype.Text   `json:"status"`
 	Priority       pgtype.Text   `json:"priority"`
 	AssigneeID     pgtype.UUID   `json:"assignee_id"`
@@ -155,6 +159,8 @@ type CountIssuesParams struct {
 func (q *Queries) CountIssues(ctx context.Context, arg CountIssuesParams) (int64, error) {
 	row := q.db.QueryRow(ctx, countIssues,
 		arg.WorkspaceID,
+		arg.SpaceID,
+		arg.SpaceIds,
 		arg.Status,
 		arg.Priority,
 		arg.AssigneeID,
@@ -172,18 +178,19 @@ func (q *Queries) CountIssues(ctx context.Context, arg CountIssuesParams) (int64
 
 const createIssue = `-- name: CreateIssue :one
 INSERT INTO issue (
-    workspace_id, title, description, status, priority,
+    workspace_id, space_id, title, description, status, priority,
     assignee_type, assignee_id, creator_type, creator_id,
     parent_issue_id, position, start_date, due_date, number, project_id,
     stage
 ) VALUES (
-    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15,
-    $16
-) RETURNING id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage
+    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16,
+    $17
+) RETURNING id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage, space_id
 `
 
 type CreateIssueParams struct {
 	WorkspaceID   pgtype.UUID `json:"workspace_id"`
+	SpaceID       pgtype.UUID `json:"space_id"`
 	Title         string      `json:"title"`
 	Description   pgtype.Text `json:"description"`
 	Status        string      `json:"status"`
@@ -204,6 +211,7 @@ type CreateIssueParams struct {
 func (q *Queries) CreateIssue(ctx context.Context, arg CreateIssueParams) (Issue, error) {
 	row := q.db.QueryRow(ctx, createIssue,
 		arg.WorkspaceID,
+		arg.SpaceID,
 		arg.Title,
 		arg.Description,
 		arg.Status,
@@ -247,24 +255,26 @@ func (q *Queries) CreateIssue(ctx context.Context, arg CreateIssueParams) (Issue
 		&i.StartDate,
 		&i.Metadata,
 		&i.Stage,
+		&i.SpaceID,
 	)
 	return i, err
 }
 
 const createIssueWithOrigin = `-- name: CreateIssueWithOrigin :one
 INSERT INTO issue (
-    workspace_id, title, description, status, priority,
+    workspace_id, space_id, title, description, status, priority,
     assignee_type, assignee_id, creator_type, creator_id,
     parent_issue_id, position, start_date, due_date, number, project_id,
     origin_type, origin_id, stage
 ) VALUES (
-    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15,
-    $16, $17, $18
-) RETURNING id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage
+    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16,
+    $17, $18, $19
+) RETURNING id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage, space_id
 `
 
 type CreateIssueWithOriginParams struct {
 	WorkspaceID   pgtype.UUID `json:"workspace_id"`
+	SpaceID       pgtype.UUID `json:"space_id"`
 	Title         string      `json:"title"`
 	Description   pgtype.Text `json:"description"`
 	Status        string      `json:"status"`
@@ -287,6 +297,7 @@ type CreateIssueWithOriginParams struct {
 func (q *Queries) CreateIssueWithOrigin(ctx context.Context, arg CreateIssueWithOriginParams) (Issue, error) {
 	row := q.db.QueryRow(ctx, createIssueWithOrigin,
 		arg.WorkspaceID,
+		arg.SpaceID,
 		arg.Title,
 		arg.Description,
 		arg.Status,
@@ -332,6 +343,7 @@ func (q *Queries) CreateIssueWithOrigin(ctx context.Context, arg CreateIssueWith
 		&i.StartDate,
 		&i.Metadata,
 		&i.Stage,
+		&i.SpaceID,
 	)
 	return i, err
 }
@@ -360,7 +372,7 @@ UPDATE issue SET
     metadata = metadata - $1::text,
     updated_at = now()
 WHERE id = $2 AND workspace_id = $3
-RETURNING id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage
+RETURNING id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage, space_id
 `
 
 type DeleteIssueMetadataKeyParams struct {
@@ -400,23 +412,26 @@ func (q *Queries) DeleteIssueMetadataKey(ctx context.Context, arg DeleteIssueMet
 		&i.StartDate,
 		&i.Metadata,
 		&i.Stage,
+		&i.SpaceID,
 	)
 	return i, err
 }
 
 const findActiveDuplicateIssue = `-- name: FindActiveDuplicateIssue :one
-SELECT id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage FROM issue
+SELECT id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage, space_id FROM issue
 WHERE workspace_id = $1
   AND status NOT IN ('done', 'cancelled')
-  AND project_id IS NOT DISTINCT FROM $2::uuid
-  AND parent_issue_id IS NOT DISTINCT FROM $3::uuid
-  AND lower(btrim(regexp_replace(title, '[[:space:]]+', ' ', 'g'))) = $4
+  AND space_id = $2::uuid
+  AND project_id IS NOT DISTINCT FROM $3::uuid
+  AND parent_issue_id IS NOT DISTINCT FROM $4::uuid
+  AND lower(btrim(regexp_replace(title, '[[:space:]]+', ' ', 'g'))) = $5
 ORDER BY created_at ASC
 LIMIT 1
 `
 
 type FindActiveDuplicateIssueParams struct {
 	WorkspaceID     pgtype.UUID `json:"workspace_id"`
+	SpaceID         pgtype.UUID `json:"space_id"`
 	ProjectID       pgtype.UUID `json:"project_id"`
 	ParentIssueID   pgtype.UUID `json:"parent_issue_id"`
 	NormalizedTitle string      `json:"normalized_title"`
@@ -425,6 +440,7 @@ type FindActiveDuplicateIssueParams struct {
 func (q *Queries) FindActiveDuplicateIssue(ctx context.Context, arg FindActiveDuplicateIssueParams) (Issue, error) {
 	row := q.db.QueryRow(ctx, findActiveDuplicateIssue,
 		arg.WorkspaceID,
+		arg.SpaceID,
 		arg.ProjectID,
 		arg.ParentIssueID,
 		arg.NormalizedTitle,
@@ -456,12 +472,13 @@ func (q *Queries) FindActiveDuplicateIssue(ctx context.Context, arg FindActiveDu
 		&i.StartDate,
 		&i.Metadata,
 		&i.Stage,
+		&i.SpaceID,
 	)
 	return i, err
 }
 
 const findRecentAutopilotDuplicateIssue = `-- name: FindRecentAutopilotDuplicateIssue :one
-SELECT i.id, i.workspace_id, i.title, i.description, i.status, i.priority, i.assignee_type, i.assignee_id, i.creator_type, i.creator_id, i.parent_issue_id, i.acceptance_criteria, i.context_refs, i.position, i.due_date, i.created_at, i.updated_at, i.number, i.project_id, i.origin_type, i.origin_id, i.first_executed_at, i.start_date, i.metadata, i.stage FROM issue i
+SELECT i.id, i.workspace_id, i.title, i.description, i.status, i.priority, i.assignee_type, i.assignee_id, i.creator_type, i.creator_id, i.parent_issue_id, i.acceptance_criteria, i.context_refs, i.position, i.due_date, i.created_at, i.updated_at, i.number, i.project_id, i.origin_type, i.origin_id, i.first_executed_at, i.start_date, i.metadata, i.stage, i.space_id FROM issue i
 WHERE i.workspace_id = $1
   AND i.status NOT IN ('done', 'cancelled')
   AND i.origin_type = 'autopilot'
@@ -523,12 +540,13 @@ func (q *Queries) FindRecentAutopilotDuplicateIssue(ctx context.Context, arg Fin
 		&i.StartDate,
 		&i.Metadata,
 		&i.Stage,
+		&i.SpaceID,
 	)
 	return i, err
 }
 
 const getIssue = `-- name: GetIssue :one
-SELECT id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage FROM issue
+SELECT id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage, space_id FROM issue
 WHERE id = $1
 `
 
@@ -561,55 +579,13 @@ func (q *Queries) GetIssue(ctx context.Context, id pgtype.UUID) (Issue, error) {
 		&i.StartDate,
 		&i.Metadata,
 		&i.Stage,
-	)
-	return i, err
-}
-
-const getIssueByNumber = `-- name: GetIssueByNumber :one
-SELECT id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage FROM issue
-WHERE workspace_id = $1 AND number = $2
-`
-
-type GetIssueByNumberParams struct {
-	WorkspaceID pgtype.UUID `json:"workspace_id"`
-	Number      int32       `json:"number"`
-}
-
-func (q *Queries) GetIssueByNumber(ctx context.Context, arg GetIssueByNumberParams) (Issue, error) {
-	row := q.db.QueryRow(ctx, getIssueByNumber, arg.WorkspaceID, arg.Number)
-	var i Issue
-	err := row.Scan(
-		&i.ID,
-		&i.WorkspaceID,
-		&i.Title,
-		&i.Description,
-		&i.Status,
-		&i.Priority,
-		&i.AssigneeType,
-		&i.AssigneeID,
-		&i.CreatorType,
-		&i.CreatorID,
-		&i.ParentIssueID,
-		&i.AcceptanceCriteria,
-		&i.ContextRefs,
-		&i.Position,
-		&i.DueDate,
-		&i.CreatedAt,
-		&i.UpdatedAt,
-		&i.Number,
-		&i.ProjectID,
-		&i.OriginType,
-		&i.OriginID,
-		&i.FirstExecutedAt,
-		&i.StartDate,
-		&i.Metadata,
-		&i.Stage,
+		&i.SpaceID,
 	)
 	return i, err
 }
 
 const getIssueByOrigin = `-- name: GetIssueByOrigin :one
-SELECT id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage FROM issue
+SELECT id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage, space_id FROM issue
 WHERE workspace_id = $1
   AND origin_type = $2
   AND origin_id = $3
@@ -656,12 +632,63 @@ func (q *Queries) GetIssueByOrigin(ctx context.Context, arg GetIssueByOriginPara
 		&i.StartDate,
 		&i.Metadata,
 		&i.Stage,
+		&i.SpaceID,
+	)
+	return i, err
+}
+
+const getIssueBySpaceKeyAndNumber = `-- name: GetIssueBySpaceKeyAndNumber :one
+SELECT i.id, i.workspace_id, i.title, i.description, i.status, i.priority, i.assignee_type, i.assignee_id, i.creator_type, i.creator_id, i.parent_issue_id, i.acceptance_criteria, i.context_refs, i.position, i.due_date, i.created_at, i.updated_at, i.number, i.project_id, i.origin_type, i.origin_id, i.first_executed_at, i.start_date, i.metadata, i.stage, i.space_id FROM issue i
+JOIN workspace_space issue_space ON issue_space.id = i.space_id AND issue_space.workspace_id = i.workspace_id
+WHERE i.workspace_id = $1
+  AND lower(issue_space.key) = lower($2)
+  AND i.number = $3
+`
+
+type GetIssueBySpaceKeyAndNumberParams struct {
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+	Lower       string      `json:"lower"`
+	Number      int32       `json:"number"`
+}
+
+// issue.space_id is NOT NULL as of migration 132, which ships in the same
+// release as this query, so no null-space fallback is needed.
+func (q *Queries) GetIssueBySpaceKeyAndNumber(ctx context.Context, arg GetIssueBySpaceKeyAndNumberParams) (Issue, error) {
+	row := q.db.QueryRow(ctx, getIssueBySpaceKeyAndNumber, arg.WorkspaceID, arg.Lower, arg.Number)
+	var i Issue
+	err := row.Scan(
+		&i.ID,
+		&i.WorkspaceID,
+		&i.Title,
+		&i.Description,
+		&i.Status,
+		&i.Priority,
+		&i.AssigneeType,
+		&i.AssigneeID,
+		&i.CreatorType,
+		&i.CreatorID,
+		&i.ParentIssueID,
+		&i.AcceptanceCriteria,
+		&i.ContextRefs,
+		&i.Position,
+		&i.DueDate,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.Number,
+		&i.ProjectID,
+		&i.OriginType,
+		&i.OriginID,
+		&i.FirstExecutedAt,
+		&i.StartDate,
+		&i.Metadata,
+		&i.Stage,
+		&i.SpaceID,
 	)
 	return i, err
 }
 
 const getIssueInWorkspace = `-- name: GetIssueInWorkspace :one
-SELECT id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage FROM issue
+SELECT id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage, space_id FROM issue
 WHERE id = $1 AND workspace_id = $2
 `
 
@@ -699,12 +726,13 @@ func (q *Queries) GetIssueInWorkspace(ctx context.Context, arg GetIssueInWorkspa
 		&i.StartDate,
 		&i.Metadata,
 		&i.Stage,
+		&i.SpaceID,
 	)
 	return i, err
 }
 
 const listChildIssues = `-- name: ListChildIssues :many
-SELECT id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage FROM issue
+SELECT id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage, space_id FROM issue
 WHERE parent_issue_id = $1
 ORDER BY number ASC
 `
@@ -750,6 +778,7 @@ func (q *Queries) ListChildIssues(ctx context.Context, parentIssueID pgtype.UUID
 			&i.StartDate,
 			&i.Metadata,
 			&i.Stage,
+			&i.SpaceID,
 		); err != nil {
 			return nil, err
 		}
@@ -762,7 +791,7 @@ func (q *Queries) ListChildIssues(ctx context.Context, parentIssueID pgtype.UUID
 }
 
 const listChildrenByParents = `-- name: ListChildrenByParents :many
-SELECT id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage FROM issue
+SELECT id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage, space_id FROM issue
 WHERE workspace_id = $1
   AND parent_issue_id = ANY($2::uuid[])
 ORDER BY parent_issue_id, number ASC
@@ -815,6 +844,7 @@ func (q *Queries) ListChildrenByParents(ctx context.Context, arg ListChildrenByP
 			&i.StartDate,
 			&i.Metadata,
 			&i.Stage,
+			&i.SpaceID,
 		); err != nil {
 			return nil, err
 		}
@@ -827,26 +857,30 @@ func (q *Queries) ListChildrenByParents(ctx context.Context, arg ListChildrenByP
 }
 
 const listIssues = `-- name: ListIssues :many
-SELECT i.id, i.workspace_id, i.title, i.description, i.status, i.priority,
+SELECT i.id, i.workspace_id, i.space_id, i.title, i.description, i.status, i.priority,
        i.assignee_type, i.assignee_id, i.creator_type, i.creator_id,
-       i.parent_issue_id, i.position, i.start_date, i.due_date, i.created_at, i.updated_at, i.number, i.project_id, i.metadata, i.stage
+       i.parent_issue_id, i.position, i.start_date, i.due_date, i.created_at, i.updated_at, i.number, i.project_id, i.metadata, i.stage,
+       COALESCE(wt.key, '')::text AS space_key, COALESCE(wt.name, '')::text AS space_name
 FROM issue i
+LEFT JOIN workspace_space wt ON wt.id = i.space_id AND wt.workspace_id = i.workspace_id
 WHERE i.workspace_id = $1
-  AND ($4::text IS NULL OR i.status = $4)
-  AND ($5::text IS NULL OR i.priority = $5)
-  AND ($6::uuid IS NULL OR i.assignee_id = $6)
-  AND ($7::uuid[] IS NULL OR i.assignee_id = ANY($7::uuid[]))
-  AND ($8::uuid IS NULL OR i.creator_id = $8)
-  AND ($9::uuid IS NULL OR i.project_id = $9)
-  AND ($10::bool IS NULL OR (i.start_date IS NOT NULL OR i.due_date IS NOT NULL))
-  AND ($11::jsonb IS NULL OR i.metadata @> $11::jsonb)
+  AND ($4::uuid IS NULL OR i.space_id = $4)
+  AND ($5::uuid[] IS NULL OR i.space_id = ANY($5::uuid[]))
+  AND ($6::text IS NULL OR i.status = $6)
+  AND ($7::text IS NULL OR i.priority = $7)
+  AND ($8::uuid IS NULL OR i.assignee_id = $8)
+  AND ($9::uuid[] IS NULL OR i.assignee_id = ANY($9::uuid[]))
+  AND ($10::uuid IS NULL OR i.creator_id = $10)
+  AND ($11::uuid IS NULL OR i.project_id = $11)
+  AND ($12::bool IS NULL OR (i.start_date IS NOT NULL OR i.due_date IS NOT NULL))
+  AND ($13::jsonb IS NULL OR i.metadata @> $13::jsonb)
   AND (
-    $12::uuid IS NULL
+    $14::uuid IS NULL
     -- (1) assignee is an agent owned by the user
     OR (i.assignee_type = 'agent' AND i.assignee_id IN (
           SELECT a.id FROM agent a
            WHERE a.workspace_id = $1
-             AND a.owner_id     = $12::uuid
+             AND a.owner_id     = $14::uuid
     ))
     -- (2)(3)(4) assignee is a squad related to the user — three relations
     OR (i.assignee_type = 'squad' AND i.assignee_id IN (
@@ -856,7 +890,7 @@ WHERE i.workspace_id = $1
             JOIN squad s ON s.id = sm.squad_id
            WHERE s.workspace_id = $1
              AND sm.member_type = 'member'
-             AND sm.member_id   = $12::uuid
+             AND sm.member_id   = $14::uuid
           UNION
           -- (3) the squad's canonical leader is an agent owned by the user.
           -- We read squad.leader_id directly rather than relying on a
@@ -867,7 +901,7 @@ WHERE i.workspace_id = $1
             JOIN agent a ON a.id = s.leader_id
            WHERE s.workspace_id = $1
              AND a.workspace_id = $1
-             AND a.owner_id     = $12::uuid
+             AND a.owner_id     = $14::uuid
           UNION
           -- (4) the squad has an agent member owned by the user
           SELECT sm.squad_id
@@ -877,7 +911,7 @@ WHERE i.workspace_id = $1
            WHERE s.workspace_id = $1
              AND sm.member_type = 'agent'
              AND a.workspace_id = $1
-             AND a.owner_id     = $12::uuid
+             AND a.owner_id     = $14::uuid
     ))
   )
 ORDER BY i.position ASC, i.created_at DESC
@@ -888,6 +922,8 @@ type ListIssuesParams struct {
 	WorkspaceID    pgtype.UUID   `json:"workspace_id"`
 	Limit          int32         `json:"limit"`
 	Offset         int32         `json:"offset"`
+	SpaceID        pgtype.UUID   `json:"space_id"`
+	SpaceIds       []pgtype.UUID `json:"space_ids"`
 	Status         pgtype.Text   `json:"status"`
 	Priority       pgtype.Text   `json:"priority"`
 	AssigneeID     pgtype.UUID   `json:"assignee_id"`
@@ -902,6 +938,7 @@ type ListIssuesParams struct {
 type ListIssuesRow struct {
 	ID            pgtype.UUID        `json:"id"`
 	WorkspaceID   pgtype.UUID        `json:"workspace_id"`
+	SpaceID       pgtype.UUID        `json:"space_id"`
 	Title         string             `json:"title"`
 	Description   pgtype.Text        `json:"description"`
 	Status        string             `json:"status"`
@@ -920,6 +957,8 @@ type ListIssuesRow struct {
 	ProjectID     pgtype.UUID        `json:"project_id"`
 	Metadata      []byte             `json:"metadata"`
 	Stage         pgtype.Int4        `json:"stage"`
+	SpaceKey      string             `json:"space_key"`
+	SpaceName     string             `json:"space_name"`
 }
 
 // involves_user_id widens the assignee filter to surface issues where the user
@@ -933,6 +972,8 @@ func (q *Queries) ListIssues(ctx context.Context, arg ListIssuesParams) ([]ListI
 		arg.WorkspaceID,
 		arg.Limit,
 		arg.Offset,
+		arg.SpaceID,
+		arg.SpaceIds,
 		arg.Status,
 		arg.Priority,
 		arg.AssigneeID,
@@ -953,6 +994,7 @@ func (q *Queries) ListIssues(ctx context.Context, arg ListIssuesParams) ([]ListI
 		if err := rows.Scan(
 			&i.ID,
 			&i.WorkspaceID,
+			&i.SpaceID,
 			&i.Title,
 			&i.Description,
 			&i.Status,
@@ -971,6 +1013,8 @@ func (q *Queries) ListIssues(ctx context.Context, arg ListIssuesParams) ([]ListI
 			&i.ProjectID,
 			&i.Metadata,
 			&i.Stage,
+			&i.SpaceKey,
+			&i.SpaceName,
 		); err != nil {
 			return nil, err
 		}
@@ -983,24 +1027,28 @@ func (q *Queries) ListIssues(ctx context.Context, arg ListIssuesParams) ([]ListI
 }
 
 const listOpenIssues = `-- name: ListOpenIssues :many
-SELECT i.id, i.workspace_id, i.title, i.description, i.status, i.priority,
+SELECT i.id, i.workspace_id, i.space_id, i.title, i.description, i.status, i.priority,
        i.assignee_type, i.assignee_id, i.creator_type, i.creator_id,
-       i.parent_issue_id, i.position, i.start_date, i.due_date, i.created_at, i.updated_at, i.number, i.project_id, i.metadata, i.stage
+       i.parent_issue_id, i.position, i.start_date, i.due_date, i.created_at, i.updated_at, i.number, i.project_id, i.metadata, i.stage,
+       COALESCE(wt.key, '')::text AS space_key, COALESCE(wt.name, '')::text AS space_name
 FROM issue i
+LEFT JOIN workspace_space wt ON wt.id = i.space_id AND wt.workspace_id = i.workspace_id
 WHERE i.workspace_id = $1
+  AND ($2::uuid IS NULL OR i.space_id = $2)
+  AND ($3::uuid[] IS NULL OR i.space_id = ANY($3::uuid[]))
   AND i.status NOT IN ('done', 'cancelled')
-  AND ($2::text IS NULL OR i.priority = $2)
-  AND ($3::uuid IS NULL OR i.assignee_id = $3)
-  AND ($4::uuid[] IS NULL OR i.assignee_id = ANY($4::uuid[]))
-  AND ($5::uuid IS NULL OR i.creator_id = $5)
-  AND ($6::uuid IS NULL OR i.project_id = $6)
-  AND ($7::jsonb IS NULL OR i.metadata @> $7::jsonb)
+  AND ($4::text IS NULL OR i.priority = $4)
+  AND ($5::uuid IS NULL OR i.assignee_id = $5)
+  AND ($6::uuid[] IS NULL OR i.assignee_id = ANY($6::uuid[]))
+  AND ($7::uuid IS NULL OR i.creator_id = $7)
+  AND ($8::uuid IS NULL OR i.project_id = $8)
+  AND ($9::jsonb IS NULL OR i.metadata @> $9::jsonb)
   AND (
-    $8::uuid IS NULL
+    $10::uuid IS NULL
     OR (i.assignee_type = 'agent' AND i.assignee_id IN (
           SELECT a.id FROM agent a
            WHERE a.workspace_id = $1
-             AND a.owner_id     = $8::uuid
+             AND a.owner_id     = $10::uuid
     ))
     OR (i.assignee_type = 'squad' AND i.assignee_id IN (
           SELECT sm.squad_id
@@ -1008,14 +1056,14 @@ WHERE i.workspace_id = $1
             JOIN squad s ON s.id = sm.squad_id
            WHERE s.workspace_id = $1
              AND sm.member_type = 'member'
-             AND sm.member_id   = $8::uuid
+             AND sm.member_id   = $10::uuid
           UNION
           SELECT s.id
             FROM squad s
             JOIN agent a ON a.id = s.leader_id
            WHERE s.workspace_id = $1
              AND a.workspace_id = $1
-             AND a.owner_id     = $8::uuid
+             AND a.owner_id     = $10::uuid
           UNION
           SELECT sm.squad_id
             FROM squad_member sm
@@ -1024,7 +1072,7 @@ WHERE i.workspace_id = $1
            WHERE s.workspace_id = $1
              AND sm.member_type = 'agent'
              AND a.workspace_id = $1
-             AND a.owner_id     = $8::uuid
+             AND a.owner_id     = $10::uuid
     ))
   )
 ORDER BY i.position ASC, i.created_at DESC
@@ -1032,6 +1080,8 @@ ORDER BY i.position ASC, i.created_at DESC
 
 type ListOpenIssuesParams struct {
 	WorkspaceID    pgtype.UUID   `json:"workspace_id"`
+	SpaceID        pgtype.UUID   `json:"space_id"`
+	SpaceIds       []pgtype.UUID `json:"space_ids"`
 	Priority       pgtype.Text   `json:"priority"`
 	AssigneeID     pgtype.UUID   `json:"assignee_id"`
 	AssigneeIds    []pgtype.UUID `json:"assignee_ids"`
@@ -1044,6 +1094,7 @@ type ListOpenIssuesParams struct {
 type ListOpenIssuesRow struct {
 	ID            pgtype.UUID        `json:"id"`
 	WorkspaceID   pgtype.UUID        `json:"workspace_id"`
+	SpaceID       pgtype.UUID        `json:"space_id"`
 	Title         string             `json:"title"`
 	Description   pgtype.Text        `json:"description"`
 	Status        string             `json:"status"`
@@ -1062,6 +1113,8 @@ type ListOpenIssuesRow struct {
 	ProjectID     pgtype.UUID        `json:"project_id"`
 	Metadata      []byte             `json:"metadata"`
 	Stage         pgtype.Int4        `json:"stage"`
+	SpaceKey      string             `json:"space_key"`
+	SpaceName     string             `json:"space_name"`
 }
 
 // See ListIssues for the semantics of involves_user_id (mirrors the 4-branch
@@ -1069,6 +1122,8 @@ type ListOpenIssuesRow struct {
 func (q *Queries) ListOpenIssues(ctx context.Context, arg ListOpenIssuesParams) ([]ListOpenIssuesRow, error) {
 	rows, err := q.db.Query(ctx, listOpenIssues,
 		arg.WorkspaceID,
+		arg.SpaceID,
+		arg.SpaceIds,
 		arg.Priority,
 		arg.AssigneeID,
 		arg.AssigneeIds,
@@ -1087,6 +1142,7 @@ func (q *Queries) ListOpenIssues(ctx context.Context, arg ListOpenIssuesParams)
 		if err := rows.Scan(
 			&i.ID,
 			&i.WorkspaceID,
+			&i.SpaceID,
 			&i.Title,
 			&i.Description,
 			&i.Status,
@@ -1105,6 +1161,8 @@ func (q *Queries) ListOpenIssues(ctx context.Context, arg ListOpenIssuesParams)
 			&i.ProjectID,
 			&i.Metadata,
 			&i.Stage,
+			&i.SpaceKey,
+			&i.SpaceName,
 		); err != nil {
 			return nil, err
 		}
@@ -1157,13 +1215,72 @@ func (q *Queries) MarkIssueFirstExecuted(ctx context.Context, id pgtype.UUID) (M
 	return i, err
 }
 
+const moveIssueToSpace = `-- name: MoveIssueToSpace :one
+UPDATE issue
+SET space_id = $2,
+    number = $3,
+    position = $4,
+    updated_at = now()
+WHERE id = $1
+RETURNING id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage, space_id
+`
+
+type MoveIssueToSpaceParams struct {
+	ID       pgtype.UUID `json:"id"`
+	SpaceID  pgtype.UUID `json:"space_id"`
+	Number   int32       `json:"number"`
+	Position float64     `json:"position"`
+}
+
+// Moving an issue between spaces renumbers it: numbers are allocated
+// per-space (uq_issue_space_number), so the caller passes a fresh number from
+// IncrementSpaceIssueCounter and a fresh position in the destination column.
+func (q *Queries) MoveIssueToSpace(ctx context.Context, arg MoveIssueToSpaceParams) (Issue, error) {
+	row := q.db.QueryRow(ctx, moveIssueToSpace,
+		arg.ID,
+		arg.SpaceID,
+		arg.Number,
+		arg.Position,
+	)
+	var i Issue
+	err := row.Scan(
+		&i.ID,
+		&i.WorkspaceID,
+		&i.Title,
+		&i.Description,
+		&i.Status,
+		&i.Priority,
+		&i.AssigneeType,
+		&i.AssigneeID,
+		&i.CreatorType,
+		&i.CreatorID,
+		&i.ParentIssueID,
+		&i.AcceptanceCriteria,
+		&i.ContextRefs,
+		&i.Position,
+		&i.DueDate,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.Number,
+		&i.ProjectID,
+		&i.OriginType,
+		&i.OriginID,
+		&i.FirstExecutedAt,
+		&i.StartDate,
+		&i.Metadata,
+		&i.Stage,
+		&i.SpaceID,
+	)
+	return i, err
+}
+
 const setIssueMetadataKey = `-- name: SetIssueMetadataKey :one
 
 UPDATE issue SET
     metadata = jsonb_set(metadata, ARRAY[$1::text], $2::jsonb),
     updated_at = now()
 WHERE id = $3 AND workspace_id = $4
-RETURNING id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage
+RETURNING id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage, space_id
 `
 
 type SetIssueMetadataKeyParams struct {
@@ -1211,6 +1328,7 @@ func (q *Queries) SetIssueMetadataKey(ctx context.Context, arg SetIssueMetadataK
 		&i.StartDate,
 		&i.Metadata,
 		&i.Stage,
+		&i.SpaceID,
 	)
 	return i, err
 }
@@ -1231,7 +1349,7 @@ UPDATE issue SET
     stage = $13,
     updated_at = now()
 WHERE id = $1
-RETURNING id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage
+RETURNING id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage, space_id
 `
 
 type UpdateIssueParams struct {
@@ -1293,6 +1411,7 @@ func (q *Queries) UpdateIssue(ctx context.Context, arg UpdateIssueParams) (Issue
 		&i.StartDate,
 		&i.Metadata,
 		&i.Stage,
+		&i.SpaceID,
 	)
 	return i, err
 }
@@ -1302,7 +1421,7 @@ UPDATE issue SET
     status = $2,
     updated_at = now()
 WHERE id = $1 AND workspace_id = $3
-RETURNING id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage
+RETURNING id, workspace_id, title, description, status, priority, assignee_type, assignee_id, creator_type, creator_id, parent_issue_id, acceptance_criteria, context_refs, position, due_date, created_at, updated_at, number, project_id, origin_type, origin_id, first_executed_at, start_date, metadata, stage, space_id
 `
 
 type UpdateIssueStatusParams struct {
@@ -1341,6 +1460,7 @@ func (q *Queries) UpdateIssueStatus(ctx context.Context, arg UpdateIssueStatusPa
 		&i.StartDate,
 		&i.Metadata,
 		&i.Stage,
+		&i.SpaceID,
 	)
 	return i, err
 }
diff --git a/server/pkg/db/generated/issue_identifier_alias.sql.go b/server/pkg/db/generated/issue_identifier_alias.sql.go
new file mode 100644
index 0000000000..57449b6f90
--- /dev/null
+++ b/server/pkg/db/generated/issue_identifier_alias.sql.go
@@ -0,0 +1,84 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.31.1
+// source: issue_identifier_alias.sql
+
+package db
+
+import (
+	"context"
+
+	"github.com/jackc/pgx/v5/pgtype"
+)
+
+const getIssueByIdentifierAlias = `-- name: GetIssueByIdentifierAlias :one
+SELECT i.id, i.workspace_id, i.title, i.description, i.status, i.priority, i.assignee_type, i.assignee_id, i.creator_type, i.creator_id, i.parent_issue_id, i.acceptance_criteria, i.context_refs, i.position, i.due_date, i.created_at, i.updated_at, i.number, i.project_id, i.origin_type, i.origin_id, i.first_executed_at, i.start_date, i.metadata, i.stage, i.space_id FROM issue_identifier_alias a
+JOIN issue i ON i.id = a.issue_id
+WHERE a.workspace_id = $1
+  AND a.space_key_lower = $2
+  AND a.number = $3
+`
+
+type GetIssueByIdentifierAliasParams struct {
+	WorkspaceID   pgtype.UUID `json:"workspace_id"`
+	SpaceKeyLower string      `json:"space_key_lower"`
+	Number        int32       `json:"number"`
+}
+
+func (q *Queries) GetIssueByIdentifierAlias(ctx context.Context, arg GetIssueByIdentifierAliasParams) (Issue, error) {
+	row := q.db.QueryRow(ctx, getIssueByIdentifierAlias, arg.WorkspaceID, arg.SpaceKeyLower, arg.Number)
+	var i Issue
+	err := row.Scan(
+		&i.ID,
+		&i.WorkspaceID,
+		&i.Title,
+		&i.Description,
+		&i.Status,
+		&i.Priority,
+		&i.AssigneeType,
+		&i.AssigneeID,
+		&i.CreatorType,
+		&i.CreatorID,
+		&i.ParentIssueID,
+		&i.AcceptanceCriteria,
+		&i.ContextRefs,
+		&i.Position,
+		&i.DueDate,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.Number,
+		&i.ProjectID,
+		&i.OriginType,
+		&i.OriginID,
+		&i.FirstExecutedAt,
+		&i.StartDate,
+		&i.Metadata,
+		&i.Stage,
+		&i.SpaceID,
+	)
+	return i, err
+}
+
+const upsertIssueIdentifierAlias = `-- name: UpsertIssueIdentifierAlias :exec
+INSERT INTO issue_identifier_alias (workspace_id, space_key_lower, number, issue_id)
+VALUES ($1, $2, $3, $4)
+ON CONFLICT (workspace_id, space_key_lower, number)
+DO UPDATE SET issue_id = EXCLUDED.issue_id
+`
+
+type UpsertIssueIdentifierAliasParams struct {
+	WorkspaceID   pgtype.UUID `json:"workspace_id"`
+	SpaceKeyLower string      `json:"space_key_lower"`
+	Number        int32       `json:"number"`
+	IssueID       pgtype.UUID `json:"issue_id"`
+}
+
+func (q *Queries) UpsertIssueIdentifierAlias(ctx context.Context, arg UpsertIssueIdentifierAliasParams) error {
+	_, err := q.db.Exec(ctx, upsertIssueIdentifierAlias,
+		arg.WorkspaceID,
+		arg.SpaceKeyLower,
+		arg.Number,
+		arg.IssueID,
+	)
+	return err
+}
diff --git a/server/pkg/db/generated/models.go b/server/pkg/db/generated/models.go
index 5ff5a463ea..8e156c5ee2 100644
--- a/server/pkg/db/generated/models.go
+++ b/server/pkg/db/generated/models.go
@@ -159,6 +159,7 @@ type Autopilot struct {
 	UpdatedAt          pgtype.Timestamptz `json:"updated_at"`
 	AssigneeType       string             `json:"assignee_type"`
 	ProjectID          pgtype.UUID        `json:"project_id"`
+	SpaceID            pgtype.UUID        `json:"space_id"`
 }
 
 type AutopilotCollaborator struct {
@@ -509,6 +510,7 @@ type Issue struct {
 	StartDate          pgtype.Date        `json:"start_date"`
 	Metadata           []byte             `json:"metadata"`
 	Stage              pgtype.Int4        `json:"stage"`
+	SpaceID            pgtype.UUID        `json:"space_id"`
 }
 
 type IssueDependency struct {
@@ -518,6 +520,14 @@ type IssueDependency struct {
 	Type             string      `json:"type"`
 }
 
+type IssueIdentifierAlias struct {
+	WorkspaceID   pgtype.UUID        `json:"workspace_id"`
+	SpaceKeyLower string             `json:"space_key_lower"`
+	Number        int32              `json:"number"`
+	IssueID       pgtype.UUID        `json:"issue_id"`
+	CreatedAt     pgtype.Timestamptz `json:"created_at"`
+}
+
 type IssueLabel struct {
 	ID          pgtype.UUID        `json:"id"`
 	WorkspaceID pgtype.UUID        `json:"workspace_id"`
@@ -704,6 +714,13 @@ type ProjectResource struct {
 	CreatedBy    pgtype.UUID        `json:"created_by"`
 }
 
+type ProjectSpace struct {
+	WorkspaceID pgtype.UUID        `json:"workspace_id"`
+	ProjectID   pgtype.UUID        `json:"project_id"`
+	SpaceID     pgtype.UUID        `json:"space_id"`
+	CreatedAt   pgtype.Timestamptz `json:"created_at"`
+}
+
 type RuntimeProfile struct {
 	ID             pgtype.UUID        `json:"id"`
 	WorkspaceID    pgtype.UUID        `json:"workspace_id"`
@@ -956,3 +973,27 @@ type WorkspaceInvitation struct {
 	UpdatedAt     pgtype.Timestamptz `json:"updated_at"`
 	ExpiresAt     pgtype.Timestamptz `json:"expires_at"`
 }
+
+type WorkspaceSpace struct {
+	ID           pgtype.UUID        `json:"id"`
+	WorkspaceID  pgtype.UUID        `json:"workspace_id"`
+	Name         string             `json:"name"`
+	Key          string             `json:"key"`
+	Description  string             `json:"description"`
+	Icon         pgtype.Text        `json:"icon"`
+	IssueCounter int32              `json:"issue_counter"`
+	ArchivedAt   pgtype.Timestamptz `json:"archived_at"`
+	ArchivedBy   pgtype.UUID        `json:"archived_by"`
+	CreatedBy    pgtype.UUID        `json:"created_by"`
+	CreatedAt    pgtype.Timestamptz `json:"created_at"`
+	UpdatedAt    pgtype.Timestamptz `json:"updated_at"`
+}
+
+type WorkspaceSpaceMember struct {
+	WorkspaceID pgtype.UUID        `json:"workspace_id"`
+	SpaceID     pgtype.UUID        `json:"space_id"`
+	UserID      pgtype.UUID        `json:"user_id"`
+	Role        string             `json:"role"`
+	CreatedAt   pgtype.Timestamptz `json:"created_at"`
+	SortOrder   float64            `json:"sort_order"`
+}
diff --git a/server/pkg/db/generated/project.sql.go b/server/pkg/db/generated/project.sql.go
index 1a7cdfcece..1357c84f9f 100644
--- a/server/pkg/db/generated/project.sql.go
+++ b/server/pkg/db/generated/project.sql.go
@@ -11,6 +11,23 @@ import (
 	"github.com/jackc/pgx/v5/pgtype"
 )
 
+const addProjectSpace = `-- name: AddProjectSpace :exec
+INSERT INTO project_space (workspace_id, project_id, space_id)
+VALUES ($1, $2, $3)
+ON CONFLICT (project_id, space_id) DO NOTHING
+`
+
+type AddProjectSpaceParams struct {
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+	ProjectID   pgtype.UUID `json:"project_id"`
+	SpaceID     pgtype.UUID `json:"space_id"`
+}
+
+func (q *Queries) AddProjectSpace(ctx context.Context, arg AddProjectSpaceParams) error {
+	_, err := q.db.Exec(ctx, addProjectSpace, arg.WorkspaceID, arg.ProjectID, arg.SpaceID)
+	return err
+}
+
 const countIssuesByProject = `-- name: CountIssuesByProject :one
 SELECT count(*) FROM issue
 WHERE project_id = $1
@@ -174,22 +191,146 @@ func (q *Queries) GetProjectIssueStats(ctx context.Context, projectIds []pgtype.
 	return items, nil
 }
 
+const listProjectSpaces = `-- name: ListProjectSpaces :many
+SELECT wt.id, wt.workspace_id, wt.name, wt.key, wt.description, wt.icon, wt.issue_counter, wt.archived_at, wt.archived_by, wt.created_by, wt.created_at, wt.updated_at FROM workspace_space wt
+JOIN project_space pt ON pt.space_id = wt.id AND pt.workspace_id = wt.workspace_id
+WHERE pt.workspace_id = $1
+  AND pt.project_id = $2
+ORDER BY wt.name ASC, wt.created_at ASC
+`
+
+type ListProjectSpacesParams struct {
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+	ProjectID   pgtype.UUID `json:"project_id"`
+}
+
+func (q *Queries) ListProjectSpaces(ctx context.Context, arg ListProjectSpacesParams) ([]WorkspaceSpace, error) {
+	rows, err := q.db.Query(ctx, listProjectSpaces, arg.WorkspaceID, arg.ProjectID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []WorkspaceSpace{}
+	for rows.Next() {
+		var i WorkspaceSpace
+		if err := rows.Scan(
+			&i.ID,
+			&i.WorkspaceID,
+			&i.Name,
+			&i.Key,
+			&i.Description,
+			&i.Icon,
+			&i.IssueCounter,
+			&i.ArchivedAt,
+			&i.ArchivedBy,
+			&i.CreatedBy,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listProjectSpacesByProjects = `-- name: ListProjectSpacesByProjects :many
+SELECT pt.project_id, wt.id, wt.workspace_id, wt.name, wt.key, wt.description,
+       wt.icon, wt.issue_counter, wt.archived_at, wt.archived_by,
+       wt.created_by, wt.created_at, wt.updated_at
+FROM project_space pt
+JOIN workspace_space wt ON wt.id = pt.space_id AND wt.workspace_id = pt.workspace_id
+WHERE pt.workspace_id = $1
+  AND pt.project_id = ANY($2::uuid[])
+ORDER BY pt.project_id, wt.name ASC, wt.created_at ASC
+`
+
+type ListProjectSpacesByProjectsParams struct {
+	WorkspaceID pgtype.UUID   `json:"workspace_id"`
+	ProjectIds  []pgtype.UUID `json:"project_ids"`
+}
+
+type ListProjectSpacesByProjectsRow struct {
+	ProjectID    pgtype.UUID        `json:"project_id"`
+	ID           pgtype.UUID        `json:"id"`
+	WorkspaceID  pgtype.UUID        `json:"workspace_id"`
+	Name         string             `json:"name"`
+	Key          string             `json:"key"`
+	Description  string             `json:"description"`
+	Icon         pgtype.Text        `json:"icon"`
+	IssueCounter int32              `json:"issue_counter"`
+	ArchivedAt   pgtype.Timestamptz `json:"archived_at"`
+	ArchivedBy   pgtype.UUID        `json:"archived_by"`
+	CreatedBy    pgtype.UUID        `json:"created_by"`
+	CreatedAt    pgtype.Timestamptz `json:"created_at"`
+	UpdatedAt    pgtype.Timestamptz `json:"updated_at"`
+}
+
+func (q *Queries) ListProjectSpacesByProjects(ctx context.Context, arg ListProjectSpacesByProjectsParams) ([]ListProjectSpacesByProjectsRow, error) {
+	rows, err := q.db.Query(ctx, listProjectSpacesByProjects, arg.WorkspaceID, arg.ProjectIds)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListProjectSpacesByProjectsRow{}
+	for rows.Next() {
+		var i ListProjectSpacesByProjectsRow
+		if err := rows.Scan(
+			&i.ProjectID,
+			&i.ID,
+			&i.WorkspaceID,
+			&i.Name,
+			&i.Key,
+			&i.Description,
+			&i.Icon,
+			&i.IssueCounter,
+			&i.ArchivedAt,
+			&i.ArchivedBy,
+			&i.CreatedBy,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
 const listProjects = `-- name: ListProjects :many
 SELECT id, workspace_id, title, description, icon, status, lead_type, lead_id, created_at, updated_at, priority FROM project
-WHERE workspace_id = $1
-  AND ($2::text IS NULL OR status = $2)
-  AND ($3::text IS NULL OR priority = $3)
+WHERE project.workspace_id = $1
+  AND ($2::uuid IS NULL OR EXISTS (
+    SELECT 1 FROM project_space pt
+    WHERE pt.project_id = project.id
+      AND pt.workspace_id = project.workspace_id
+      AND pt.space_id = $2::uuid
+  ))
+  AND ($3::text IS NULL OR project.status = $3)
+  AND ($4::text IS NULL OR project.priority = $4)
 ORDER BY created_at DESC
 `
 
 type ListProjectsParams struct {
 	WorkspaceID pgtype.UUID `json:"workspace_id"`
+	SpaceID     pgtype.UUID `json:"space_id"`
 	Status      pgtype.Text `json:"status"`
 	Priority    pgtype.Text `json:"priority"`
 }
 
 func (q *Queries) ListProjects(ctx context.Context, arg ListProjectsParams) ([]Project, error) {
-	rows, err := q.db.Query(ctx, listProjects, arg.WorkspaceID, arg.Status, arg.Priority)
+	rows, err := q.db.Query(ctx, listProjects,
+		arg.WorkspaceID,
+		arg.SpaceID,
+		arg.Status,
+		arg.Priority,
+	)
 	if err != nil {
 		return nil, err
 	}
@@ -220,6 +361,29 @@ func (q *Queries) ListProjects(ctx context.Context, arg ListProjectsParams) ([]P
 	return items, nil
 }
 
+const replaceProjectSpaces = `-- name: ReplaceProjectSpaces :exec
+WITH deleted AS (
+  DELETE FROM project_space
+  WHERE workspace_id = $1
+    AND project_id = $2
+    AND NOT (space_id = ANY($3::uuid[]))
+)
+INSERT INTO project_space (workspace_id, project_id, space_id)
+SELECT $1, $2, unnest($3::uuid[])
+ON CONFLICT (project_id, space_id) DO NOTHING
+`
+
+type ReplaceProjectSpacesParams struct {
+	WorkspaceID pgtype.UUID   `json:"workspace_id"`
+	ProjectID   pgtype.UUID   `json:"project_id"`
+	SpaceIds    []pgtype.UUID `json:"space_ids"`
+}
+
+func (q *Queries) ReplaceProjectSpaces(ctx context.Context, arg ReplaceProjectSpacesParams) error {
+	_, err := q.db.Exec(ctx, replaceProjectSpaces, arg.WorkspaceID, arg.ProjectID, arg.SpaceIds)
+	return err
+}
+
 const updateProject = `-- name: UpdateProject :one
 UPDATE project SET
     title = COALESCE($2, title),
diff --git a/server/pkg/db/generated/space.sql.go b/server/pkg/db/generated/space.sql.go
new file mode 100644
index 0000000000..f5e105baca
--- /dev/null
+++ b/server/pkg/db/generated/space.sql.go
@@ -0,0 +1,736 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.31.1
+// source: space.sql
+
+package db
+
+import (
+	"context"
+
+	"github.com/jackc/pgx/v5/pgtype"
+)
+
+const addWorkspaceSpaceMember = `-- name: AddWorkspaceSpaceMember :exec
+INSERT INTO workspace_space_member (workspace_id, space_id, user_id, role, sort_order)
+VALUES ($1, $2, $3, $4, $5)
+ON CONFLICT (space_id, user_id) DO UPDATE SET role = EXCLUDED.role
+`
+
+type AddWorkspaceSpaceMemberParams struct {
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+	SpaceID     pgtype.UUID `json:"space_id"`
+	UserID      pgtype.UUID `json:"user_id"`
+	Role        string      `json:"role"`
+	SortOrder   float64     `json:"sort_order"`
+}
+
+func (q *Queries) AddWorkspaceSpaceMember(ctx context.Context, arg AddWorkspaceSpaceMemberParams) error {
+	_, err := q.db.Exec(ctx, addWorkspaceSpaceMember,
+		arg.WorkspaceID,
+		arg.SpaceID,
+		arg.UserID,
+		arg.Role,
+		arg.SortOrder,
+	)
+	return err
+}
+
+const archiveWorkspaceSpace = `-- name: ArchiveWorkspaceSpace :one
+UPDATE workspace_space SET
+    archived_at = now(),
+    archived_by = $3,
+    updated_at = now()
+WHERE id = $1
+  AND workspace_id = $2
+  AND archived_at IS NULL
+RETURNING id, workspace_id, name, key, description, icon, issue_counter, archived_at, archived_by, created_by, created_at, updated_at
+`
+
+type ArchiveWorkspaceSpaceParams struct {
+	ID          pgtype.UUID `json:"id"`
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+	ArchivedBy  pgtype.UUID `json:"archived_by"`
+}
+
+// Callers must first lock the workspace's active Spaces (see
+// ListActiveWorkspaceSpacesForUpdate) and confirm more than one remains —
+// this query no longer guards that itself.
+func (q *Queries) ArchiveWorkspaceSpace(ctx context.Context, arg ArchiveWorkspaceSpaceParams) (WorkspaceSpace, error) {
+	row := q.db.QueryRow(ctx, archiveWorkspaceSpace, arg.ID, arg.WorkspaceID, arg.ArchivedBy)
+	var i WorkspaceSpace
+	err := row.Scan(
+		&i.ID,
+		&i.WorkspaceID,
+		&i.Name,
+		&i.Key,
+		&i.Description,
+		&i.Icon,
+		&i.IssueCounter,
+		&i.ArchivedAt,
+		&i.ArchivedBy,
+		&i.CreatedBy,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+	)
+	return i, err
+}
+
+const createWorkspaceSpace = `-- name: CreateWorkspaceSpace :one
+INSERT INTO workspace_space (
+    workspace_id, name, key, description, icon, created_by
+) VALUES (
+    $1, $2, $3, COALESCE($4::text, ''), $5::text, $6
+) RETURNING id, workspace_id, name, key, description, icon, issue_counter, archived_at, archived_by, created_by, created_at, updated_at
+`
+
+type CreateWorkspaceSpaceParams struct {
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+	Name        string      `json:"name"`
+	Key         string      `json:"key"`
+	Description pgtype.Text `json:"description"`
+	Icon        pgtype.Text `json:"icon"`
+	CreatedBy   pgtype.UUID `json:"created_by"`
+}
+
+func (q *Queries) CreateWorkspaceSpace(ctx context.Context, arg CreateWorkspaceSpaceParams) (WorkspaceSpace, error) {
+	row := q.db.QueryRow(ctx, createWorkspaceSpace,
+		arg.WorkspaceID,
+		arg.Name,
+		arg.Key,
+		arg.Description,
+		arg.Icon,
+		arg.CreatedBy,
+	)
+	var i WorkspaceSpace
+	err := row.Scan(
+		&i.ID,
+		&i.WorkspaceID,
+		&i.Name,
+		&i.Key,
+		&i.Description,
+		&i.Icon,
+		&i.IssueCounter,
+		&i.ArchivedAt,
+		&i.ArchivedBy,
+		&i.CreatedBy,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+	)
+	return i, err
+}
+
+const getDefaultWorkspaceSpace = `-- name: GetDefaultWorkspaceSpace :one
+SELECT id, workspace_id, name, key, description, icon, issue_counter, archived_at, archived_by, created_by, created_at, updated_at FROM workspace_space
+WHERE workspace_id = $1 AND archived_at IS NULL
+ORDER BY created_at ASC, id ASC
+LIMIT 1
+`
+
+// Fallback Space when none is specified: the workspace's earliest-created
+// active Space. No is_default flag — deterministic from created_at, and
+// always resolvable because ArchiveSpace refuses to archive a workspace's
+// last active Space.
+func (q *Queries) GetDefaultWorkspaceSpace(ctx context.Context, workspaceID pgtype.UUID) (WorkspaceSpace, error) {
+	row := q.db.QueryRow(ctx, getDefaultWorkspaceSpace, workspaceID)
+	var i WorkspaceSpace
+	err := row.Scan(
+		&i.ID,
+		&i.WorkspaceID,
+		&i.Name,
+		&i.Key,
+		&i.Description,
+		&i.Icon,
+		&i.IssueCounter,
+		&i.ArchivedAt,
+		&i.ArchivedBy,
+		&i.CreatedBy,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+	)
+	return i, err
+}
+
+const getWorkspaceSpace = `-- name: GetWorkspaceSpace :one
+SELECT id, workspace_id, name, key, description, icon, issue_counter, archived_at, archived_by, created_by, created_at, updated_at FROM workspace_space
+WHERE id = $1 AND workspace_id = $2
+`
+
+type GetWorkspaceSpaceParams struct {
+	ID          pgtype.UUID `json:"id"`
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+}
+
+func (q *Queries) GetWorkspaceSpace(ctx context.Context, arg GetWorkspaceSpaceParams) (WorkspaceSpace, error) {
+	row := q.db.QueryRow(ctx, getWorkspaceSpace, arg.ID, arg.WorkspaceID)
+	var i WorkspaceSpace
+	err := row.Scan(
+		&i.ID,
+		&i.WorkspaceID,
+		&i.Name,
+		&i.Key,
+		&i.Description,
+		&i.Icon,
+		&i.IssueCounter,
+		&i.ArchivedAt,
+		&i.ArchivedBy,
+		&i.CreatedBy,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+	)
+	return i, err
+}
+
+const getWorkspaceSpaceByKey = `-- name: GetWorkspaceSpaceByKey :one
+SELECT id, workspace_id, name, key, description, icon, issue_counter, archived_at, archived_by, created_by, created_at, updated_at FROM workspace_space
+WHERE workspace_id = $1
+  AND lower(key) = lower($2)
+LIMIT 1
+`
+
+type GetWorkspaceSpaceByKeyParams struct {
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+	Lower       string      `json:"lower"`
+}
+
+func (q *Queries) GetWorkspaceSpaceByKey(ctx context.Context, arg GetWorkspaceSpaceByKeyParams) (WorkspaceSpace, error) {
+	row := q.db.QueryRow(ctx, getWorkspaceSpaceByKey, arg.WorkspaceID, arg.Lower)
+	var i WorkspaceSpace
+	err := row.Scan(
+		&i.ID,
+		&i.WorkspaceID,
+		&i.Name,
+		&i.Key,
+		&i.Description,
+		&i.Icon,
+		&i.IssueCounter,
+		&i.ArchivedAt,
+		&i.ArchivedBy,
+		&i.CreatedBy,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+	)
+	return i, err
+}
+
+const getWorkspaceSpaceMember = `-- name: GetWorkspaceSpaceMember :one
+SELECT workspace_id, space_id, user_id, role, created_at, sort_order FROM workspace_space_member
+WHERE space_id = $1
+  AND user_id = $2
+`
+
+type GetWorkspaceSpaceMemberParams struct {
+	SpaceID pgtype.UUID `json:"space_id"`
+	UserID  pgtype.UUID `json:"user_id"`
+}
+
+func (q *Queries) GetWorkspaceSpaceMember(ctx context.Context, arg GetWorkspaceSpaceMemberParams) (WorkspaceSpaceMember, error) {
+	row := q.db.QueryRow(ctx, getWorkspaceSpaceMember, arg.SpaceID, arg.UserID)
+	var i WorkspaceSpaceMember
+	err := row.Scan(
+		&i.WorkspaceID,
+		&i.SpaceID,
+		&i.UserID,
+		&i.Role,
+		&i.CreatedAt,
+		&i.SortOrder,
+	)
+	return i, err
+}
+
+const incrementSpaceIssueCounter = `-- name: IncrementSpaceIssueCounter :one
+UPDATE workspace_space
+SET issue_counter = issue_counter + 1,
+    updated_at = now()
+WHERE id = $1
+  AND workspace_id = $2
+  AND archived_at IS NULL
+RETURNING issue_counter
+`
+
+type IncrementSpaceIssueCounterParams struct {
+	ID          pgtype.UUID `json:"id"`
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+}
+
+func (q *Queries) IncrementSpaceIssueCounter(ctx context.Context, arg IncrementSpaceIssueCounterParams) (int32, error) {
+	row := q.db.QueryRow(ctx, incrementSpaceIssueCounter, arg.ID, arg.WorkspaceID)
+	var issue_counter int32
+	err := row.Scan(&issue_counter)
+	return issue_counter, err
+}
+
+const listActiveWorkspaceSpaces = `-- name: ListActiveWorkspaceSpaces :many
+SELECT id, workspace_id, name, key, description, icon, issue_counter, archived_at, archived_by, created_by, created_at, updated_at FROM workspace_space
+WHERE workspace_id = $1
+  AND archived_at IS NULL
+ORDER BY name ASC, created_at ASC
+`
+
+func (q *Queries) ListActiveWorkspaceSpaces(ctx context.Context, workspaceID pgtype.UUID) ([]WorkspaceSpace, error) {
+	rows, err := q.db.Query(ctx, listActiveWorkspaceSpaces, workspaceID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []WorkspaceSpace{}
+	for rows.Next() {
+		var i WorkspaceSpace
+		if err := rows.Scan(
+			&i.ID,
+			&i.WorkspaceID,
+			&i.Name,
+			&i.Key,
+			&i.Description,
+			&i.Icon,
+			&i.IssueCounter,
+			&i.ArchivedAt,
+			&i.ArchivedBy,
+			&i.CreatedBy,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listActiveWorkspaceSpacesForUpdate = `-- name: ListActiveWorkspaceSpacesForUpdate :many
+SELECT id, workspace_id, name, key, description, icon, issue_counter, archived_at, archived_by, created_by, created_at, updated_at FROM workspace_space
+WHERE workspace_id = $1
+  AND archived_at IS NULL
+FOR UPDATE
+`
+
+// Locks every active Space row for this workspace so a concurrent archive on
+// another Space in the same workspace serializes behind this one. Used by
+// ArchiveSpace to count active Spaces before archiving without racing another
+// archive down to zero.
+func (q *Queries) ListActiveWorkspaceSpacesForUpdate(ctx context.Context, workspaceID pgtype.UUID) ([]WorkspaceSpace, error) {
+	rows, err := q.db.Query(ctx, listActiveWorkspaceSpacesForUpdate, workspaceID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []WorkspaceSpace{}
+	for rows.Next() {
+		var i WorkspaceSpace
+		if err := rows.Scan(
+			&i.ID,
+			&i.WorkspaceID,
+			&i.Name,
+			&i.Key,
+			&i.Description,
+			&i.Icon,
+			&i.IssueCounter,
+			&i.ArchivedAt,
+			&i.ArchivedBy,
+			&i.CreatedBy,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listWorkspaceSpaceMembers = `-- name: ListWorkspaceSpaceMembers :many
+SELECT workspace_id, space_id, user_id, role, created_at, sort_order FROM workspace_space_member
+WHERE workspace_id = $1
+  AND space_id = $2
+ORDER BY role ASC, created_at ASC
+`
+
+type ListWorkspaceSpaceMembersParams struct {
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+	SpaceID     pgtype.UUID `json:"space_id"`
+}
+
+func (q *Queries) ListWorkspaceSpaceMembers(ctx context.Context, arg ListWorkspaceSpaceMembersParams) ([]WorkspaceSpaceMember, error) {
+	rows, err := q.db.Query(ctx, listWorkspaceSpaceMembers, arg.WorkspaceID, arg.SpaceID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []WorkspaceSpaceMember{}
+	for rows.Next() {
+		var i WorkspaceSpaceMember
+		if err := rows.Scan(
+			&i.WorkspaceID,
+			&i.SpaceID,
+			&i.UserID,
+			&i.Role,
+			&i.CreatedAt,
+			&i.SortOrder,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listWorkspaceSpaceMembersWithUser = `-- name: ListWorkspaceSpaceMembersWithUser :many
+SELECT m.workspace_id, m.space_id, m.user_id, m.role, m.sort_order, m.created_at,
+       u.name AS user_name, u.email AS user_email, u.avatar_url AS user_avatar_url
+FROM workspace_space_member m
+JOIN "user" u ON u.id = m.user_id
+WHERE m.workspace_id = $1
+  AND m.space_id = $2
+ORDER BY m.role ASC, m.created_at ASC
+`
+
+type ListWorkspaceSpaceMembersWithUserParams struct {
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+	SpaceID     pgtype.UUID `json:"space_id"`
+}
+
+type ListWorkspaceSpaceMembersWithUserRow struct {
+	WorkspaceID   pgtype.UUID        `json:"workspace_id"`
+	SpaceID       pgtype.UUID        `json:"space_id"`
+	UserID        pgtype.UUID        `json:"user_id"`
+	Role          string             `json:"role"`
+	SortOrder     float64            `json:"sort_order"`
+	CreatedAt     pgtype.Timestamptz `json:"created_at"`
+	UserName      string             `json:"user_name"`
+	UserEmail     string             `json:"user_email"`
+	UserAvatarUrl pgtype.Text        `json:"user_avatar_url"`
+}
+
+func (q *Queries) ListWorkspaceSpaceMembersWithUser(ctx context.Context, arg ListWorkspaceSpaceMembersWithUserParams) ([]ListWorkspaceSpaceMembersWithUserRow, error) {
+	rows, err := q.db.Query(ctx, listWorkspaceSpaceMembersWithUser, arg.WorkspaceID, arg.SpaceID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListWorkspaceSpaceMembersWithUserRow{}
+	for rows.Next() {
+		var i ListWorkspaceSpaceMembersWithUserRow
+		if err := rows.Scan(
+			&i.WorkspaceID,
+			&i.SpaceID,
+			&i.UserID,
+			&i.Role,
+			&i.SortOrder,
+			&i.CreatedAt,
+			&i.UserName,
+			&i.UserEmail,
+			&i.UserAvatarUrl,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listWorkspaceSpaces = `-- name: ListWorkspaceSpaces :many
+SELECT id, workspace_id, name, key, description, icon, issue_counter, archived_at, archived_by, created_by, created_at, updated_at FROM workspace_space
+WHERE workspace_id = $1
+ORDER BY archived_at NULLS FIRST, name ASC, created_at ASC
+`
+
+func (q *Queries) ListWorkspaceSpaces(ctx context.Context, workspaceID pgtype.UUID) ([]WorkspaceSpace, error) {
+	rows, err := q.db.Query(ctx, listWorkspaceSpaces, workspaceID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []WorkspaceSpace{}
+	for rows.Next() {
+		var i WorkspaceSpace
+		if err := rows.Scan(
+			&i.ID,
+			&i.WorkspaceID,
+			&i.Name,
+			&i.Key,
+			&i.Description,
+			&i.Icon,
+			&i.IssueCounter,
+			&i.ArchivedAt,
+			&i.ArchivedBy,
+			&i.CreatedBy,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listWorkspaceSpacesByIDs = `-- name: ListWorkspaceSpacesByIDs :many
+SELECT id, workspace_id, name, key, description, icon, issue_counter, archived_at, archived_by, created_by, created_at, updated_at FROM workspace_space
+WHERE workspace_id = $1
+  AND id = ANY($2::uuid[])
+`
+
+type ListWorkspaceSpacesByIDsParams struct {
+	WorkspaceID pgtype.UUID   `json:"workspace_id"`
+	SpaceIds    []pgtype.UUID `json:"space_ids"`
+}
+
+func (q *Queries) ListWorkspaceSpacesByIDs(ctx context.Context, arg ListWorkspaceSpacesByIDsParams) ([]WorkspaceSpace, error) {
+	rows, err := q.db.Query(ctx, listWorkspaceSpacesByIDs, arg.WorkspaceID, arg.SpaceIds)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []WorkspaceSpace{}
+	for rows.Next() {
+		var i WorkspaceSpace
+		if err := rows.Scan(
+			&i.ID,
+			&i.WorkspaceID,
+			&i.Name,
+			&i.Key,
+			&i.Description,
+			&i.Icon,
+			&i.IssueCounter,
+			&i.ArchivedAt,
+			&i.ArchivedBy,
+			&i.CreatedBy,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listWorkspaceSpacesForUser = `-- name: ListWorkspaceSpacesForUser :many
+SELECT wt.id, wt.workspace_id, wt.name, wt.key, wt.description, wt.icon, wt.issue_counter, wt.archived_at, wt.archived_by, wt.created_by, wt.created_at, wt.updated_at,
+       (m.user_id IS NOT NULL)::boolean AS is_member,
+       COALESCE(m.sort_order, 0)::double precision AS member_sort_order
+FROM workspace_space wt
+LEFT JOIN workspace_space_member m
+    ON m.space_id = wt.id AND m.user_id = $2
+WHERE wt.workspace_id = $1
+ORDER BY wt.archived_at NULLS FIRST, wt.name ASC, wt.created_at ASC
+`
+
+type ListWorkspaceSpacesForUserParams struct {
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+	UserID      pgtype.UUID `json:"user_id"`
+}
+
+type ListWorkspaceSpacesForUserRow struct {
+	WorkspaceSpace  WorkspaceSpace `json:"workspace_space"`
+	IsMember        bool           `json:"is_member"`
+	MemberSortOrder float64        `json:"member_sort_order"`
+}
+
+// Space list enriched with the requesting user's membership (drives the
+// sidebar Spaces section: only joined spaces, ordered by member sort_order).
+func (q *Queries) ListWorkspaceSpacesForUser(ctx context.Context, arg ListWorkspaceSpacesForUserParams) ([]ListWorkspaceSpacesForUserRow, error) {
+	rows, err := q.db.Query(ctx, listWorkspaceSpacesForUser, arg.WorkspaceID, arg.UserID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListWorkspaceSpacesForUserRow{}
+	for rows.Next() {
+		var i ListWorkspaceSpacesForUserRow
+		if err := rows.Scan(
+			&i.WorkspaceSpace.ID,
+			&i.WorkspaceSpace.WorkspaceID,
+			&i.WorkspaceSpace.Name,
+			&i.WorkspaceSpace.Key,
+			&i.WorkspaceSpace.Description,
+			&i.WorkspaceSpace.Icon,
+			&i.WorkspaceSpace.IssueCounter,
+			&i.WorkspaceSpace.ArchivedAt,
+			&i.WorkspaceSpace.ArchivedBy,
+			&i.WorkspaceSpace.CreatedBy,
+			&i.WorkspaceSpace.CreatedAt,
+			&i.WorkspaceSpace.UpdatedAt,
+			&i.IsMember,
+			&i.MemberSortOrder,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const lockWorkspaceSpaceForKeyUpdate = `-- name: LockWorkspaceSpaceForKeyUpdate :one
+SELECT id, workspace_id, name, key, description, icon, issue_counter, archived_at, archived_by, created_by, created_at, updated_at FROM workspace_space
+WHERE id = $1 AND workspace_id = $2
+FOR UPDATE
+`
+
+type LockWorkspaceSpaceForKeyUpdateParams struct {
+	ID          pgtype.UUID `json:"id"`
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+}
+
+func (q *Queries) LockWorkspaceSpaceForKeyUpdate(ctx context.Context, arg LockWorkspaceSpaceForKeyUpdateParams) (WorkspaceSpace, error) {
+	row := q.db.QueryRow(ctx, lockWorkspaceSpaceForKeyUpdate, arg.ID, arg.WorkspaceID)
+	var i WorkspaceSpace
+	err := row.Scan(
+		&i.ID,
+		&i.WorkspaceID,
+		&i.Name,
+		&i.Key,
+		&i.Description,
+		&i.Icon,
+		&i.IssueCounter,
+		&i.ArchivedAt,
+		&i.ArchivedBy,
+		&i.CreatedBy,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+	)
+	return i, err
+}
+
+const nextSpaceMemberSortOrder = `-- name: NextSpaceMemberSortOrder :one
+SELECT (COALESCE(MAX(sort_order), 0) + 1)::double precision FROM workspace_space_member
+WHERE workspace_id = $1
+  AND user_id = $2
+`
+
+type NextSpaceMemberSortOrderParams struct {
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+	UserID      pgtype.UUID `json:"user_id"`
+}
+
+// Next slot at the end of this user's space list (per-user ordering).
+func (q *Queries) NextSpaceMemberSortOrder(ctx context.Context, arg NextSpaceMemberSortOrderParams) (float64, error) {
+	row := q.db.QueryRow(ctx, nextSpaceMemberSortOrder, arg.WorkspaceID, arg.UserID)
+	var column_1 float64
+	err := row.Scan(&column_1)
+	return column_1, err
+}
+
+const removeWorkspaceSpaceMember = `-- name: RemoveWorkspaceSpaceMember :execrows
+DELETE FROM workspace_space_member
+WHERE workspace_id = $1
+  AND space_id = $2
+  AND user_id = $3
+`
+
+type RemoveWorkspaceSpaceMemberParams struct {
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+	SpaceID     pgtype.UUID `json:"space_id"`
+	UserID      pgtype.UUID `json:"user_id"`
+}
+
+func (q *Queries) RemoveWorkspaceSpaceMember(ctx context.Context, arg RemoveWorkspaceSpaceMemberParams) (int64, error) {
+	result, err := q.db.Exec(ctx, removeWorkspaceSpaceMember, arg.WorkspaceID, arg.SpaceID, arg.UserID)
+	if err != nil {
+		return 0, err
+	}
+	return result.RowsAffected(), nil
+}
+
+const updateSpaceMemberSortOrder = `-- name: UpdateSpaceMemberSortOrder :one
+UPDATE workspace_space_member
+SET sort_order = $4
+WHERE workspace_id = $1
+  AND space_id = $2
+  AND user_id = $3
+RETURNING workspace_id, space_id, user_id, role, created_at, sort_order
+`
+
+type UpdateSpaceMemberSortOrderParams struct {
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+	SpaceID     pgtype.UUID `json:"space_id"`
+	UserID      pgtype.UUID `json:"user_id"`
+	SortOrder   float64     `json:"sort_order"`
+}
+
+func (q *Queries) UpdateSpaceMemberSortOrder(ctx context.Context, arg UpdateSpaceMemberSortOrderParams) (WorkspaceSpaceMember, error) {
+	row := q.db.QueryRow(ctx, updateSpaceMemberSortOrder,
+		arg.WorkspaceID,
+		arg.SpaceID,
+		arg.UserID,
+		arg.SortOrder,
+	)
+	var i WorkspaceSpaceMember
+	err := row.Scan(
+		&i.WorkspaceID,
+		&i.SpaceID,
+		&i.UserID,
+		&i.Role,
+		&i.CreatedAt,
+		&i.SortOrder,
+	)
+	return i, err
+}
+
+const updateWorkspaceSpace = `-- name: UpdateWorkspaceSpace :one
+UPDATE workspace_space SET
+    name = COALESCE($3, name),
+    key = COALESCE($4, key),
+    description = COALESCE($5, description),
+    icon = COALESCE($6, icon),
+    updated_at = now()
+WHERE id = $1 AND workspace_id = $2
+RETURNING id, workspace_id, name, key, description, icon, issue_counter, archived_at, archived_by, created_by, created_at, updated_at
+`
+
+type UpdateWorkspaceSpaceParams struct {
+	ID          pgtype.UUID `json:"id"`
+	WorkspaceID pgtype.UUID `json:"workspace_id"`
+	Name        pgtype.Text `json:"name"`
+	Key         pgtype.Text `json:"key"`
+	Description pgtype.Text `json:"description"`
+	Icon        pgtype.Text `json:"icon"`
+}
+
+func (q *Queries) UpdateWorkspaceSpace(ctx context.Context, arg UpdateWorkspaceSpaceParams) (WorkspaceSpace, error) {
+	row := q.db.QueryRow(ctx, updateWorkspaceSpace,
+		arg.ID,
+		arg.WorkspaceID,
+		arg.Name,
+		arg.Key,
+		arg.Description,
+		arg.Icon,
+	)
+	var i WorkspaceSpace
+	err := row.Scan(
+		&i.ID,
+		&i.WorkspaceID,
+		&i.Name,
+		&i.Key,
+		&i.Description,
+		&i.Icon,
+		&i.IssueCounter,
+		&i.ArchivedAt,
+		&i.ArchivedBy,
+		&i.CreatedBy,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+	)
+	return i, err
+}
diff --git a/server/pkg/db/generated/workspace.sql.go b/server/pkg/db/generated/workspace.sql.go
index a89661bdba..8def520f0d 100644
--- a/server/pkg/db/generated/workspace.sql.go
+++ b/server/pkg/db/generated/workspace.sql.go
@@ -113,19 +113,6 @@ func (q *Queries) GetWorkspaceBySlug(ctx context.Context, slug string) (Workspac
 	return i, err
 }
 
-const incrementIssueCounter = `-- name: IncrementIssueCounter :one
-UPDATE workspace SET issue_counter = issue_counter + 1
-WHERE id = $1
-RETURNING issue_counter
-`
-
-func (q *Queries) IncrementIssueCounter(ctx context.Context, id pgtype.UUID) (int32, error) {
-	row := q.db.QueryRow(ctx, incrementIssueCounter, id)
-	var issue_counter int32
-	err := row.Scan(&issue_counter)
-	return issue_counter, err
-}
-
 const listWorkspaces = `-- name: ListWorkspaces :many
 SELECT w.id, w.name, w.slug, w.description, w.settings,
        w.created_at, w.updated_at, w.context, w.repos,
diff --git a/server/pkg/db/queries/autopilot.sql b/server/pkg/db/queries/autopilot.sql
index fa7a98cdfd..044e2ad1a2 100644
--- a/server/pkg/db/queries/autopilot.sql
+++ b/server/pkg/db/queries/autopilot.sql
@@ -30,12 +30,22 @@ SELECT
   ), '')::text AS last_run_status
 FROM autopilot a
 WHERE a.workspace_id = $1
+  AND (sqlc.narg('space_id')::uuid IS NULL OR a.space_id = sqlc.narg('space_id'))
   AND (
     (sqlc.narg('status')::text IS NULL AND a.status <> 'archived')
     OR a.status = sqlc.narg('status')
   )
 ORDER BY a.created_at DESC;
 
+-- name: CountActiveAutopilotsBySpace :one
+-- Counts non-archived autopilots pinned to a Space. Used to block archiving a
+-- Space that still drives live autopilots (mirrors CountActiveProjectAutopilotsBySpace,
+-- which scopes the same liveness column to a single project).
+SELECT count(*) FROM autopilot
+WHERE workspace_id = $1
+  AND space_id = $2
+  AND status <> 'archived';
+
 -- name: GetAutopilot :one
 SELECT * FROM autopilot
 WHERE id = $1;
@@ -47,12 +57,12 @@ WHERE id = $1 AND workspace_id = $2;
 -- name: CreateAutopilot :one
 INSERT INTO autopilot (
     workspace_id, title, description, assignee_type, assignee_id,
-    status, execution_mode, issue_title_template, project_id,
+    status, execution_mode, issue_title_template, project_id, space_id,
     created_by_type, created_by_id
 ) VALUES (
     $1, $2, sqlc.narg('description'), $3, $4,
-    $5, $6, sqlc.narg('issue_title_template'), sqlc.narg('project_id'),
-    $7, $8
+    $5, $6, sqlc.narg('issue_title_template'), sqlc.narg('project_id'), $7,
+    $8, $9
 ) RETURNING *;
 
 -- name: UpdateAutopilot :one
@@ -65,6 +75,7 @@ UPDATE autopilot SET
     execution_mode = COALESCE(sqlc.narg('execution_mode'), execution_mode),
     issue_title_template = sqlc.narg('issue_title_template'),
     project_id = sqlc.narg('project_id'),
+    space_id = COALESCE(sqlc.narg('space_id')::uuid, space_id),
     updated_at = now()
 WHERE id = $1
 RETURNING *;
diff --git a/server/pkg/db/queries/issue.sql b/server/pkg/db/queries/issue.sql
index 1ae6c1c4be..030b7f0657 100644
--- a/server/pkg/db/queries/issue.sql
+++ b/server/pkg/db/queries/issue.sql
@@ -5,11 +5,15 @@
 -- member assignment (`assignee_type='member' AND assignee_id=involves_user_id`)
 -- because that is already the meaning of the `assignee_id` filter (tab 1
 -- "Assigned to me"), and the two filters must produce disjoint result sets.
-SELECT i.id, i.workspace_id, i.title, i.description, i.status, i.priority,
+SELECT i.id, i.workspace_id, i.space_id, i.title, i.description, i.status, i.priority,
        i.assignee_type, i.assignee_id, i.creator_type, i.creator_id,
-       i.parent_issue_id, i.position, i.start_date, i.due_date, i.created_at, i.updated_at, i.number, i.project_id, i.metadata, i.stage
+       i.parent_issue_id, i.position, i.start_date, i.due_date, i.created_at, i.updated_at, i.number, i.project_id, i.metadata, i.stage,
+       COALESCE(wt.key, '')::text AS space_key, COALESCE(wt.name, '')::text AS space_name
 FROM issue i
+LEFT JOIN workspace_space wt ON wt.id = i.space_id AND wt.workspace_id = i.workspace_id
 WHERE i.workspace_id = $1
+  AND (sqlc.narg('space_id')::uuid IS NULL OR i.space_id = sqlc.narg('space_id'))
+  AND (sqlc.narg('space_ids')::uuid[] IS NULL OR i.space_id = ANY(sqlc.narg('space_ids')::uuid[]))
   AND (sqlc.narg('status')::text IS NULL OR i.status = sqlc.narg('status'))
   AND (sqlc.narg('priority')::text IS NULL OR i.priority = sqlc.narg('priority'))
   AND (sqlc.narg('assignee_id')::uuid IS NULL OR i.assignee_id = sqlc.narg('assignee_id'))
@@ -71,18 +75,23 @@ WHERE id = $1 AND workspace_id = $2;
 
 -- name: CreateIssue :one
 INSERT INTO issue (
-    workspace_id, title, description, status, priority,
+    workspace_id, space_id, title, description, status, priority,
     assignee_type, assignee_id, creator_type, creator_id,
     parent_issue_id, position, start_date, due_date, number, project_id,
     stage
 ) VALUES (
-    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15,
+    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16,
     sqlc.narg('stage')
 ) RETURNING *;
 
--- name: GetIssueByNumber :one
-SELECT * FROM issue
-WHERE workspace_id = $1 AND number = $2;
+-- name: GetIssueBySpaceKeyAndNumber :one
+-- issue.space_id is NOT NULL as of migration 132, which ships in the same
+-- release as this query, so no null-space fallback is needed.
+SELECT i.* FROM issue i
+JOIN workspace_space issue_space ON issue_space.id = i.space_id AND issue_space.workspace_id = i.workspace_id
+WHERE i.workspace_id = $1
+  AND lower(issue_space.key) = lower($2)
+  AND i.number = $3;
 
 -- name: UpdateIssue :one
 UPDATE issue SET
@@ -112,12 +121,12 @@ RETURNING *;
 
 -- name: CreateIssueWithOrigin :one
 INSERT INTO issue (
-    workspace_id, title, description, status, priority,
+    workspace_id, space_id, title, description, status, priority,
     assignee_type, assignee_id, creator_type, creator_id,
     parent_issue_id, position, start_date, due_date, number, project_id,
     origin_type, origin_id, stage
 ) VALUES (
-    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15,
+    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16,
     sqlc.narg('origin_type'), sqlc.narg('origin_id'), sqlc.narg('stage')
 ) RETURNING *;
 
@@ -128,6 +137,7 @@ SELECT pg_advisory_xact_lock(hashtextextended($1::text, 0));
 SELECT * FROM issue
 WHERE workspace_id = $1
   AND status NOT IN ('done', 'cancelled')
+  AND space_id = sqlc.arg('space_id')::uuid
   AND project_id IS NOT DISTINCT FROM sqlc.arg('project_id')::uuid
   AND parent_issue_id IS NOT DISTINCT FROM sqlc.arg('parent_issue_id')::uuid
   AND lower(btrim(regexp_replace(title, '[[:space:]]+', ' ', 'g'))) = sqlc.arg('normalized_title')
@@ -164,11 +174,15 @@ DELETE FROM issue WHERE id = $1 AND workspace_id = $2;
 -- name: ListOpenIssues :many
 -- See ListIssues for the semantics of involves_user_id (mirrors the 4-branch
 -- filter; member-direct assignment is intentionally excluded).
-SELECT i.id, i.workspace_id, i.title, i.description, i.status, i.priority,
+SELECT i.id, i.workspace_id, i.space_id, i.title, i.description, i.status, i.priority,
        i.assignee_type, i.assignee_id, i.creator_type, i.creator_id,
-       i.parent_issue_id, i.position, i.start_date, i.due_date, i.created_at, i.updated_at, i.number, i.project_id, i.metadata, i.stage
+       i.parent_issue_id, i.position, i.start_date, i.due_date, i.created_at, i.updated_at, i.number, i.project_id, i.metadata, i.stage,
+       COALESCE(wt.key, '')::text AS space_key, COALESCE(wt.name, '')::text AS space_name
 FROM issue i
+LEFT JOIN workspace_space wt ON wt.id = i.space_id AND wt.workspace_id = i.workspace_id
 WHERE i.workspace_id = $1
+  AND (sqlc.narg('space_id')::uuid IS NULL OR i.space_id = sqlc.narg('space_id'))
+  AND (sqlc.narg('space_ids')::uuid[] IS NULL OR i.space_id = ANY(sqlc.narg('space_ids')::uuid[]))
   AND i.status NOT IN ('done', 'cancelled')
   AND (sqlc.narg('priority')::text IS NULL OR i.priority = sqlc.narg('priority'))
   AND (sqlc.narg('assignee_id')::uuid IS NULL OR i.assignee_id = sqlc.narg('assignee_id'))
@@ -214,6 +228,8 @@ ORDER BY i.position ASC, i.created_at DESC;
 -- See ListIssues for the semantics of involves_user_id.
 SELECT count(*) FROM issue i
 WHERE i.workspace_id = $1
+  AND (sqlc.narg('space_id')::uuid IS NULL OR i.space_id = sqlc.narg('space_id'))
+  AND (sqlc.narg('space_ids')::uuid[] IS NULL OR i.space_id = ANY(sqlc.narg('space_ids')::uuid[]))
   AND (sqlc.narg('status')::text IS NULL OR i.status = sqlc.narg('status'))
   AND (sqlc.narg('priority')::text IS NULL OR i.priority = sqlc.narg('priority'))
   AND (sqlc.narg('assignee_id')::uuid IS NULL OR i.assignee_id = sqlc.narg('assignee_id'))
@@ -344,3 +360,15 @@ UPDATE issue
 SET first_executed_at = now()
 WHERE id = $1 AND first_executed_at IS NULL
 RETURNING id, workspace_id, creator_type, creator_id, first_executed_at;
+
+-- name: MoveIssueToSpace :one
+-- Moving an issue between spaces renumbers it: numbers are allocated
+-- per-space (uq_issue_space_number), so the caller passes a fresh number from
+-- IncrementSpaceIssueCounter and a fresh position in the destination column.
+UPDATE issue
+SET space_id = $2,
+    number = $3,
+    position = $4,
+    updated_at = now()
+WHERE id = $1
+RETURNING *;
diff --git a/server/pkg/db/queries/issue_identifier_alias.sql b/server/pkg/db/queries/issue_identifier_alias.sql
new file mode 100644
index 0000000000..fc1a78ec06
--- /dev/null
+++ b/server/pkg/db/queries/issue_identifier_alias.sql
@@ -0,0 +1,12 @@
+-- name: UpsertIssueIdentifierAlias :exec
+INSERT INTO issue_identifier_alias (workspace_id, space_key_lower, number, issue_id)
+VALUES ($1, $2, $3, $4)
+ON CONFLICT (workspace_id, space_key_lower, number)
+DO UPDATE SET issue_id = EXCLUDED.issue_id;
+
+-- name: GetIssueByIdentifierAlias :one
+SELECT i.* FROM issue_identifier_alias a
+JOIN issue i ON i.id = a.issue_id
+WHERE a.workspace_id = $1
+  AND a.space_key_lower = $2
+  AND a.number = $3;
diff --git a/server/pkg/db/queries/project.sql b/server/pkg/db/queries/project.sql
index 7115947064..5e01b8bc22 100644
--- a/server/pkg/db/queries/project.sql
+++ b/server/pkg/db/queries/project.sql
@@ -1,8 +1,14 @@
 -- name: ListProjects :many
 SELECT * FROM project
-WHERE workspace_id = $1
-  AND (sqlc.narg('status')::text IS NULL OR status = sqlc.narg('status'))
-  AND (sqlc.narg('priority')::text IS NULL OR priority = sqlc.narg('priority'))
+WHERE project.workspace_id = $1
+  AND (sqlc.narg('space_id')::uuid IS NULL OR EXISTS (
+    SELECT 1 FROM project_space pt
+    WHERE pt.project_id = project.id
+      AND pt.workspace_id = project.workspace_id
+      AND pt.space_id = sqlc.narg('space_id')::uuid
+  ))
+  AND (sqlc.narg('status')::text IS NULL OR project.status = sqlc.narg('status'))
+  AND (sqlc.narg('priority')::text IS NULL OR project.priority = sqlc.narg('priority'))
 ORDER BY created_at DESC;
 
 -- name: GetProject :one
@@ -49,3 +55,36 @@ SELECT project_id,
 FROM issue
 WHERE project_id = ANY(sqlc.arg('project_ids')::uuid[])
 GROUP BY project_id;
+
+-- name: ListProjectSpaces :many
+SELECT wt.* FROM workspace_space wt
+JOIN project_space pt ON pt.space_id = wt.id AND pt.workspace_id = wt.workspace_id
+WHERE pt.workspace_id = $1
+  AND pt.project_id = $2
+ORDER BY wt.name ASC, wt.created_at ASC;
+
+-- name: ListProjectSpacesByProjects :many
+SELECT pt.project_id, wt.id, wt.workspace_id, wt.name, wt.key, wt.description,
+       wt.icon, wt.issue_counter, wt.archived_at, wt.archived_by,
+       wt.created_by, wt.created_at, wt.updated_at
+FROM project_space pt
+JOIN workspace_space wt ON wt.id = pt.space_id AND wt.workspace_id = pt.workspace_id
+WHERE pt.workspace_id = $1
+  AND pt.project_id = ANY(sqlc.arg('project_ids')::uuid[])
+ORDER BY pt.project_id, wt.name ASC, wt.created_at ASC;
+
+-- name: AddProjectSpace :exec
+INSERT INTO project_space (workspace_id, project_id, space_id)
+VALUES ($1, $2, $3)
+ON CONFLICT (project_id, space_id) DO NOTHING;
+
+-- name: ReplaceProjectSpaces :exec
+WITH deleted AS (
+  DELETE FROM project_space
+  WHERE workspace_id = sqlc.arg('workspace_id')
+    AND project_id = sqlc.arg('project_id')
+    AND NOT (space_id = ANY(sqlc.arg('space_ids')::uuid[]))
+)
+INSERT INTO project_space (workspace_id, project_id, space_id)
+SELECT sqlc.arg('workspace_id'), sqlc.arg('project_id'), unnest(sqlc.arg('space_ids')::uuid[])
+ON CONFLICT (project_id, space_id) DO NOTHING;
\ No newline at end of file
diff --git a/server/pkg/db/queries/space.sql b/server/pkg/db/queries/space.sql
new file mode 100644
index 0000000000..9f82b8e5ca
--- /dev/null
+++ b/server/pkg/db/queries/space.sql
@@ -0,0 +1,146 @@
+-- name: ListWorkspaceSpaces :many
+SELECT * FROM workspace_space
+WHERE workspace_id = $1
+ORDER BY archived_at NULLS FIRST, name ASC, created_at ASC;
+
+-- name: ListActiveWorkspaceSpaces :many
+SELECT * FROM workspace_space
+WHERE workspace_id = $1
+  AND archived_at IS NULL
+ORDER BY name ASC, created_at ASC;
+
+-- name: ListActiveWorkspaceSpacesForUpdate :many
+-- Locks every active Space row for this workspace so a concurrent archive on
+-- another Space in the same workspace serializes behind this one. Used by
+-- ArchiveSpace to count active Spaces before archiving without racing another
+-- archive down to zero.
+SELECT * FROM workspace_space
+WHERE workspace_id = $1
+  AND archived_at IS NULL
+FOR UPDATE;
+
+-- name: ListWorkspaceSpacesByIDs :many
+SELECT * FROM workspace_space
+WHERE workspace_id = $1
+  AND id = ANY(sqlc.arg('space_ids')::uuid[]);
+
+-- name: GetWorkspaceSpace :one
+SELECT * FROM workspace_space
+WHERE id = $1 AND workspace_id = $2;
+
+-- name: GetDefaultWorkspaceSpace :one
+-- Fallback Space when none is specified: the workspace's earliest-created
+-- active Space. No is_default flag — deterministic from created_at, and
+-- always resolvable because ArchiveSpace refuses to archive a workspace's
+-- last active Space.
+SELECT * FROM workspace_space
+WHERE workspace_id = $1 AND archived_at IS NULL
+ORDER BY created_at ASC, id ASC
+LIMIT 1;
+
+-- name: GetWorkspaceSpaceByKey :one
+SELECT * FROM workspace_space
+WHERE workspace_id = $1
+  AND lower(key) = lower($2)
+LIMIT 1;
+
+-- name: CreateWorkspaceSpace :one
+INSERT INTO workspace_space (
+    workspace_id, name, key, description, icon, created_by
+) VALUES (
+    $1, $2, $3, COALESCE(sqlc.narg('description')::text, ''), sqlc.narg('icon')::text, sqlc.narg('created_by')
+) RETURNING *;
+
+-- name: UpdateWorkspaceSpace :one
+UPDATE workspace_space SET
+    name = COALESCE(sqlc.narg('name'), name),
+    key = COALESCE(sqlc.narg('key'), key),
+    description = COALESCE(sqlc.narg('description'), description),
+    icon = COALESCE(sqlc.narg('icon'), icon),
+    updated_at = now()
+WHERE id = $1 AND workspace_id = $2
+RETURNING *;
+
+-- name: ArchiveWorkspaceSpace :one
+-- Callers must first lock the workspace's active Spaces (see
+-- ListActiveWorkspaceSpacesForUpdate) and confirm more than one remains —
+-- this query no longer guards that itself.
+UPDATE workspace_space SET
+    archived_at = now(),
+    archived_by = $3,
+    updated_at = now()
+WHERE id = $1
+  AND workspace_id = $2
+  AND archived_at IS NULL
+RETURNING *;
+
+-- name: IncrementSpaceIssueCounter :one
+UPDATE workspace_space
+SET issue_counter = issue_counter + 1,
+    updated_at = now()
+WHERE id = $1
+  AND workspace_id = $2
+  AND archived_at IS NULL
+RETURNING issue_counter;
+
+-- name: LockWorkspaceSpaceForKeyUpdate :one
+SELECT * FROM workspace_space
+WHERE id = $1 AND workspace_id = $2
+FOR UPDATE;
+
+-- name: AddWorkspaceSpaceMember :exec
+INSERT INTO workspace_space_member (workspace_id, space_id, user_id, role, sort_order)
+VALUES ($1, $2, $3, $4, $5)
+ON CONFLICT (space_id, user_id) DO UPDATE SET role = EXCLUDED.role;
+
+-- name: NextSpaceMemberSortOrder :one
+-- Next slot at the end of this user's space list (per-user ordering).
+SELECT (COALESCE(MAX(sort_order), 0) + 1)::double precision FROM workspace_space_member
+WHERE workspace_id = $1
+  AND user_id = $2;
+
+-- name: GetWorkspaceSpaceMember :one
+SELECT * FROM workspace_space_member
+WHERE space_id = $1
+  AND user_id = $2;
+
+-- name: UpdateSpaceMemberSortOrder :one
+UPDATE workspace_space_member
+SET sort_order = $4
+WHERE workspace_id = $1
+  AND space_id = $2
+  AND user_id = $3
+RETURNING *;
+
+-- name: ListWorkspaceSpacesForUser :many
+-- Space list enriched with the requesting user's membership (drives the
+-- sidebar Spaces section: only joined spaces, ordered by member sort_order).
+SELECT sqlc.embed(wt),
+       (m.user_id IS NOT NULL)::boolean AS is_member,
+       COALESCE(m.sort_order, 0)::double precision AS member_sort_order
+FROM workspace_space wt
+LEFT JOIN workspace_space_member m
+    ON m.space_id = wt.id AND m.user_id = $2
+WHERE wt.workspace_id = $1
+ORDER BY wt.archived_at NULLS FIRST, wt.name ASC, wt.created_at ASC;
+
+-- name: RemoveWorkspaceSpaceMember :execrows
+DELETE FROM workspace_space_member
+WHERE workspace_id = $1
+  AND space_id = $2
+  AND user_id = $3;
+
+-- name: ListWorkspaceSpaceMembersWithUser :many
+SELECT m.workspace_id, m.space_id, m.user_id, m.role, m.sort_order, m.created_at,
+       u.name AS user_name, u.email AS user_email, u.avatar_url AS user_avatar_url
+FROM workspace_space_member m
+JOIN "user" u ON u.id = m.user_id
+WHERE m.workspace_id = $1
+  AND m.space_id = $2
+ORDER BY m.role ASC, m.created_at ASC;
+
+-- name: ListWorkspaceSpaceMembers :many
+SELECT * FROM workspace_space_member
+WHERE workspace_id = $1
+  AND space_id = $2
+ORDER BY role ASC, created_at ASC;
diff --git a/server/pkg/db/queries/workspace.sql b/server/pkg/db/queries/workspace.sql
index 3f9daa0dd5..12de073074 100644
--- a/server/pkg/db/queries/workspace.sql
+++ b/server/pkg/db/queries/workspace.sql
@@ -40,11 +40,6 @@ SELECT id, repos FROM workspace
 WHERE repos IS NOT NULL AND repos <> '[]'::jsonb
 ORDER BY id;
 
--- name: IncrementIssueCounter :one
-UPDATE workspace SET issue_counter = issue_counter + 1
-WHERE id = $1
-RETURNING issue_counter;
-
 -- name: DeleteWorkspace :exec
 WITH deleted_pending_check_suites AS (
     DELETE FROM github_pending_check_suite WHERE workspace_id = $1