diff --git a/CHANGELOG.md b/CHANGELOG.md
index 84e81e7e..cf300220 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,8 @@
 
 ### Added
 
+- #560：新增文档与结构双视图的协作区预览；结构写回保留空行与文件末尾换行，缺少结构章节时插入新章节。持久化验收仍待接入，不作为正式验收入口发布。
+
 - #559：新增协作区人工验收契约，验收通过必须完整覆盖计划中的全部验收项；限制标识符、时间戳和产物路径，拒绝遗漏或越界的裁决。
 
 - #469：可选 Laya 接力停止建议。仅在 `ROLEWEAVE_LAYA_ENABLED` 开启、已完成步骤得到正向建议且仍有未执行步骤时暂停；桌面端由 owner 显式选择“停止剩余步骤”或“继续接力”。30 秒超时、SSE 断连、无效或失败建议均继续原 mention order；Laya 只接收 `status`、`errorCode`、`hasOutput`，不接收输入、输出或 handoff 文本。已接受的消息与 spawn 清单保持不可变。Refs #422。
diff --git a/apps/desktop/packaging/runtime-layout.cjs b/apps/desktop/packaging/runtime-layout.cjs
index 2c4f9e82..a9fa04a2 100644
--- a/apps/desktop/packaging/runtime-layout.cjs
+++ b/apps/desktop/packaging/runtime-layout.cjs
@@ -191,6 +191,7 @@ const SHARED_RUNTIME_FILES = [
   "dist/semantic-runtime.js",
   "dist/services.js",
   "dist/sessions.js",
+  "dist/space-doc.js",
   "dist/task-board.js",
   "dist/turn-progress.js",
   "dist/turns.js",
diff --git a/apps/desktop/renderer/src/App.tsx b/apps/desktop/renderer/src/App.tsx
index 230dadca..74eee761 100644
--- a/apps/desktop/renderer/src/App.tsx
+++ b/apps/desktop/renderer/src/App.tsx
@@ -34,7 +34,7 @@ import type {
   WorkspaceCreateResponse,
   WorkspaceInfoResponse,
 } from "@roleweave/shared";
-import { ChevronsRight, FolderKanban, FolderOpen, Inbox, MessagesSquare, MoreHorizontal, Network, PanelLeft, PencilLine, Plus, Settings, Undo2, X } from "lucide-react";
+import { Boxes, ChevronsRight, FolderKanban, FolderOpen, Inbox, MessagesSquare, MoreHorizontal, Network, PanelLeft, PencilLine, Plus, Settings, Undo2, X } from "lucide-react";
 import { useThemeMode, useThemeProfile } from "./theme-toggle";
 import { useTheme, ThemeProvider } from "./theme-context";
 import { themeToAntdSeed } from "./theme-resolution";
@@ -84,6 +84,7 @@ import { decodeEscapedUnicode } from "./display-text";
 import { SettingsModule, type ConfigurationCategory } from "./settings/SettingsModule";
 import { GoalsModule } from "./goals/GoalsModule";
 import { ProjectManagementModule } from "./projects/ProjectManagementModule";
+import { SpaceHost } from "./space/SpaceHost.js";
 import { ProjectSwitcher } from "./project/ProjectSwitcher";
 import { ProjectWorkspaceDialog } from "./project/ProjectWorkspaceDialog";
 import { assignDefaultAvatars, avatarSrcFor, readAvatarPreferences, type AvatarValue } from "./PositionAvatar";
@@ -135,7 +136,7 @@ function AppInner({
 }) {
   const themeContext = useTheme();
   const [activeModule, setActiveModuleRaw] = useState<
-    "conversation" | "profile" | "org" | "groups" | "reports" | "approvals" | "docs" | "goals" | "projects" | "settings" | "progress"
+    "conversation" | "profile" | "org" | "groups" | "reports" | "approvals" | "docs" | "goals" | "projects" | "settings" | "progress" | "space"
   >("conversation");
   const [settingsInitialCategory, setSettingsInitialCategory] = useState<ConfigurationCategory | undefined>();
   const [contactsOpen, setContactsOpen] = useState(false);
@@ -1971,6 +1972,7 @@ function AppInner({
             { id: "collaboration", label: t("rail.collaboration"), icon: <MessagesSquare aria-hidden="true" size={16} />, active: collaborationActive, onSelect: () => setActiveModule("conversation") },
             { id: "org", label: t("rail.org"), icon: <Network aria-hidden="true" size={16} />, active: activeModule === "org", onSelect: () => setActiveModule("org") },
             { id: "projects", label: t("rail.projects"), icon: <FolderKanban aria-hidden="true" size={16} />, active: projectsActive, onSelect: () => setActiveModule("projects") },
+            { id: "space", label: t("rail.space"), icon: <Boxes aria-hidden="true" size={16} />, active: activeModule === "space", onSelect: () => setActiveModule("space") },
             { id: "inbox", label: t("rail.inbox"), icon: <Badge count={pendingApprovals} size="small" showZero={false} offset={[6, -2]} color="var(--ui-primary)"><Inbox aria-hidden="true" size={16} /></Badge>, active: inboxActive, onSelect: () => { setActiveModule("approvals"); void approvalState.refresh(); } },
           ]}
           footer={<>
@@ -2209,6 +2211,17 @@ function AppInner({
               setActiveModule("conversation");
             }}
           />
+        ) : activeModule === "space" ? (
+          <SpaceHost
+            workspaceOpen={workspaceInfo?.open === true}
+            spacePositionId={selectedId}
+            positionNames={positionNames}
+            ownerPositionId={snapshot?.owner}
+            onOpenBoundSession={(positionId) => {
+              selectPosition(positionId);
+              setActiveModule("conversation");
+            }}
+          />
         ) : activeModule === "goals" ? (
           <GoalsModule
             workspaceOpen={workspaceInfo?.open === true}
diff --git a/apps/desktop/renderer/src/space/AcceptanceGate.tsx b/apps/desktop/renderer/src/space/AcceptanceGate.tsx
new file mode 100644
index 00000000..770a3b30
--- /dev/null
+++ b/apps/desktop/renderer/src/space/AcceptanceGate.tsx
@@ -0,0 +1,134 @@
+import { useMemo, useState } from "react";
+import { Button as AntButton, Checkbox, Input } from "antd";
+import { CheckCircle2, XCircle } from "lucide-react";
+import { useT } from "@roleweave/ui";
+import type { AcceptanceDecision, SpaceDocCriterion } from "@roleweave/shared";
+import {
+  buildAcceptanceRecord,
+  canAccept,
+  canReject,
+  untickedCriteria,
+  type GateDraft,
+  type GateEvidence,
+  type GateTicks,
+} from "./acceptance-gate-model.js";
+import "./space-gate.css";
+
+export interface AcceptanceGateProps {
+  draft: GateDraft;
+  criteria: SpaceDocCriterion[];
+  /** Called with a record that has already passed the model's invariants. */
+  onDecide: (decision: AcceptanceDecision, record: ReturnType<typeof buildAcceptanceRecord>) => void | Promise<void>;
+  busy?: boolean;
+}
+
+/**
+ * The single place the human signs off. Accept stays disabled until every
+ * criterion is ticked, and reject demands a reason — the same invariants
+ * `acceptance.v1` enforces, surfaced before anything is submitted.
+ */
+export function AcceptanceGate({ draft, criteria, onDecide, busy = false }: AcceptanceGateProps) {
+  const t = useT();
+  const [ticks, setTicks] = useState<GateTicks>({});
+  const [evidence, setEvidence] = useState<GateEvidence>({});
+  const [note, setNote] = useState("");
+  const [pendingDecision, setPendingDecision] = useState<AcceptanceDecision | null>(null);
+
+  const remaining = useMemo(() => untickedCriteria(criteria, ticks), [criteria, ticks]);
+  const acceptReady = canAccept(criteria, ticks);
+  const rejectReady = canReject(note);
+
+  const submit = (decision: AcceptanceDecision) => {
+    const record = buildAcceptanceRecord(draft, criteria, ticks, decision, note, evidence);
+    setPendingDecision(null);
+    void onDecide(decision, record);
+  };
+
+  if (criteria.length === 0) {
+    return (
+      <div className="owb-space-gate owb-space-gate--empty">
+        <p className="owb-space-gate__empty">{t("space.gate.empty")}</p>
+      </div>
+    );
+  }
+
+  return (
+    <div className="owb-space-gate" data-ticked={criteria.length - remaining.length} data-total={criteria.length}>
+      <div className="owb-space-gate__head">
+        <h3 className="owb-space-gate__title">{t("space.gate.title")}</h3>
+        <span className="owb-space-gate__progress">
+          {t("space.gate.progress", { done: criteria.length - remaining.length, total: criteria.length })}
+        </span>
+      </div>
+
+      <ul className="owb-space-gate__list">
+        {criteria.map((criterion) => (
+          <li key={criterion.criteriaIndex} className="owb-space-gate__item">
+            <Checkbox
+              checked={ticks[criterion.criteriaIndex] === true}
+              onChange={(event) =>
+                setTicks((prev) => ({ ...prev, [criterion.criteriaIndex]: event.target.checked }))
+              }
+            >
+              {criterion.text}
+            </Checkbox>
+            <Input
+              className="owb-space-gate__evidence"
+              size="small"
+              value={evidence[criterion.criteriaIndex] ?? ""}
+              placeholder={t("space.gate.evidencePlaceholder")}
+              onChange={(event) =>
+                setEvidence((prev) => ({ ...prev, [criterion.criteriaIndex]: event.target.value }))
+              }
+            />
+          </li>
+        ))}
+      </ul>
+
+      {remaining.length > 0 ? (
+        <p className="owb-space-gate__hint">{t("space.gate.remaining", { count: remaining.length })}</p>
+      ) : null}
+
+      <Input.TextArea
+        className="owb-space-gate__note"
+        rows={2}
+        value={note}
+        placeholder={t("space.gate.notePlaceholder")}
+        onChange={(event) => setNote(event.target.value)}
+      />
+
+      <div className="owb-space-gate__actions">
+        {pendingDecision === null ? (
+          <>
+            <AntButton
+              type="primary"
+              icon={<CheckCircle2 size={14} aria-hidden="true" />}
+              disabled={!acceptReady || busy}
+              onClick={() => setPendingDecision("accepted")}
+            >
+              {t("space.gate.accept")}
+            </AntButton>
+            <AntButton
+              danger
+              icon={<XCircle size={14} aria-hidden="true" />}
+              disabled={!rejectReady || busy}
+              onClick={() => setPendingDecision("rejected")}
+            >
+              {t("space.gate.reject")}
+            </AntButton>
+          </>
+        ) : (
+          <>
+            <span className="owb-space-gate__confirm">
+              {pendingDecision === "accepted" ? t("space.gate.confirmAccept") : t("space.gate.confirmReject")}
+            </span>
+            <AntButton type="primary" loading={busy} onClick={() => submit(pendingDecision)}>
+              {t("space.gate.confirm")}
+            </AntButton>
+            <AntButton onClick={() => setPendingDecision(null)}>{t("space.gate.cancel")}</AntButton>
+          </>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/apps/desktop/renderer/src/space/SpaceHost.tsx b/apps/desktop/renderer/src/space/SpaceHost.tsx
new file mode 100644
index 00000000..27a4fcfe
--- /dev/null
+++ b/apps/desktop/renderer/src/space/SpaceHost.tsx
@@ -0,0 +1,60 @@
+import { useMemo } from "react";
+import { useT } from "@roleweave/ui";
+import type { AcceptanceRecord } from "@roleweave/shared";
+import { SpaceModule, type SpaceAgent } from "./SpaceModule.js";
+import { useSpaceFiles } from "./useSpaceFiles.js";
+
+export interface SpaceHostProps {
+  workspaceOpen: boolean;
+  /** The position whose package directory backs the current space, if any. */
+  spacePositionId: string | null;
+  positionNames: Record<string, string>;
+  ownerPositionId?: string;
+  onOpenBoundSession?: (positionId: string) => void;
+  onAccept?: (record: AcceptanceRecord) => void | Promise<void>;
+}
+
+/**
+ * Bridges the space module to the shell: resolves the current space's files
+ * through the existing position-docs bridge and derives the participant list
+ * from the org, so the module itself stays a pure view.
+ */
+export function SpaceHost({
+  workspaceOpen,
+  spacePositionId,
+  positionNames,
+  ownerPositionId,
+  onOpenBoundSession,
+  onAccept,
+}: SpaceHostProps) {
+  const t = useT();
+  const state = useSpaceFiles(spacePositionId, workspaceOpen);
+
+  const participants = useMemo<SpaceAgent[]>(() => {
+    const ids = Object.keys(positionNames);
+    // The owner always comes first and is marked; it is an org-level fact.
+    const ordered = ownerPositionId && ids.includes(ownerPositionId)
+      ? [ownerPositionId, ...ids.filter((id) => id !== ownerPositionId)]
+      : ids;
+    return ordered.map((positionId) => ({
+      positionId,
+      name: positionNames[positionId] ?? positionId,
+      owner: positionId === ownerPositionId,
+    }));
+  }, [positionNames, ownerPositionId]);
+
+  return (
+    <SpaceModule
+      key={spacePositionId ?? "none"}
+      workspaceOpen={workspaceOpen}
+      spaceId={spacePositionId ?? undefined}
+      spaceName={spacePositionId ? (positionNames[spacePositionId] ?? spacePositionId) : t("space.untitled")}
+      files={state.files}
+      readFile={state.readFile}
+      writeFile={state.writeFile}
+      participants={participants}
+      onOpenBoundSession={onOpenBoundSession}
+      onAccept={onAccept}
+    />
+  );
+}
diff --git a/apps/desktop/renderer/src/space/SpaceModule.tsx b/apps/desktop/renderer/src/space/SpaceModule.tsx
new file mode 100644
index 00000000..ea7ad14d
--- /dev/null
+++ b/apps/desktop/renderer/src/space/SpaceModule.tsx
@@ -0,0 +1,347 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Empty, Spin, Tag } from "antd";
+import { FileText, Folder, GitBranch, LayoutList, Users } from "lucide-react";
+import { useT } from "@roleweave/ui";
+// Value imports go through the subpath, not the barrel: the barrel reaches
+// node-only modules such as position-id.js (createRequire), which the renderer
+// bundle cannot resolve.
+import { parseSpaceDoc, renderSpaceDoc } from "@roleweave/shared/space-doc";
+import type {
+  AcceptanceDecision,
+  AcceptanceRecord,
+  DocsFileEntry,
+  SpaceDoc,
+  SpaceDocCriterion,
+  SpaceDocTask,
+} from "@roleweave/shared";
+import { Markdown } from "../markdown/Markdown.js";
+import { AcceptanceGate } from "./AcceptanceGate.js";
+import { buildAcceptanceRecord, type GateDraft } from "./acceptance-gate-model.js";
+import "./space.css";
+
+/** The spine file of a space. Every other file in the folder is supporting. */
+export const SPACE_SPINE_FILE_KEY = "space.spineFile";
+
+export interface SpaceAgent {
+  positionId: string;
+  name: string;
+  /** Exactly one participant is the owner; it comes from the org, not a space field. */
+  owner: boolean;
+}
+
+export interface SpaceModuleProps {
+  workspaceOpen: boolean;
+  /** Name of the space (the folder). */
+  spaceName?: string;
+  /** Stable identity, independent of the display name. */
+  spaceId?: string;
+  files: DocsFileEntry[];
+  /** Injected loader, mirroring DocsPanel's contract so this stays testable. */
+  readFile: (path: string) => Promise<{ content: string; version: string }>;
+  writeFile?: (path: string, content: string, expectedVersion: string) => Promise<{ version: string }>;
+  participants?: SpaceAgent[];
+  onOpenBoundSession?: (positionId: string) => void;
+  onAccept?: (record: AcceptanceRecord) => void | Promise<void>;
+  /** Which file the space is currently focused on; defaults to the spine. */
+  requestedPath?: string | null;
+}
+
+type SpaceView = "document" | "structure";
+
+function statusTone(status: SpaceDocTask["status"]): string {
+  switch (status) {
+    case "done":
+      return "success";
+    case "in_progress":
+      return "processing";
+    case "blocked":
+      return "error";
+    case "review":
+      return "warning";
+    default:
+      return "default";
+  }
+}
+
+export function SpaceModule(props: SpaceModuleProps) {
+  const t = useT();
+  const spineFile = t(SPACE_SPINE_FILE_KEY);
+  const [view, setView] = useState<SpaceView>("document");
+  const [activePath, setActivePath] = useState<string>(props.requestedPath ?? spineFile);
+  const [source, setSource] = useState("");
+  const [version, setVersion] = useState("");
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [decided, setDecided] = useState<AcceptanceRecord | null>(null);
+
+  const load = useCallback(
+    async (path: string) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const file = await props.readFile(path);
+        setSource(file.content);
+        setVersion(file.version);
+      } catch {
+        setError(t("space.error.read", { path }));
+        setSource("");
+      } finally {
+        setLoading(false);
+      }
+    },
+    [props, t],
+  );
+
+  useEffect(() => {
+    if (!props.workspaceOpen) return;
+    void load(activePath);
+  }, [props.workspaceOpen, activePath, load]);
+
+  const parsed = useMemo(() => parseSpaceDoc(source), [source]);
+  const doc = parsed.doc;
+  const isSpine = activePath === spineFile;
+
+  const owner = props.participants?.find((agent) => agent.owner);
+  const others = props.participants?.filter((agent) => !agent.owner) ?? [];
+
+  const gateDraft: GateDraft = useMemo(
+    () => ({
+      spaceId: props.spaceId ?? "space",
+      positionId: owner?.positionId ?? "operator",
+      artifactPath: activePath,
+      decidedBy: "operator",
+    }),
+    [props.spaceId, owner?.positionId, activePath],
+  );
+
+  const handleDecide = useCallback(
+    async (decision: AcceptanceDecision, record: AcceptanceRecord) => {
+      setError(null);
+      if (decision === "accepted" && props.writeFile && isSpine) {
+        // Acceptance is the only thing allowed to mark criteria done.
+        const next: SpaceDoc = {
+          ...doc,
+          criteria: doc.criteria.map((criterion) => ({ ...criterion, done: true })),
+        };
+        const content = renderSpaceDoc(next, source);
+        try {
+          const result = await props.writeFile(activePath, content, version);
+          setSource(content);
+          setVersion(result.version);
+        } catch {
+          setError(t("space.error.write", { path: activePath }));
+          return;
+        }
+      }
+      try {
+        await props.onAccept?.(record);
+        setDecided(record);
+      } catch {
+        setError(t("space.error.write", { path: activePath }));
+      }
+    },
+    [props, doc, source, version, activePath, isSpine, t],
+  );
+
+  if (!props.workspaceOpen) {
+    return (
+      <div className="owb-space-module">
+        <Empty description={t("space.emptyWorkspace")} />
+      </div>
+    );
+  }
+
+  return (
+    <div className="owb-space-module" data-view={view}>
+      <header className="owb-space-header">
+        <div className="owb-space-header__title">
+          <Folder size={16} aria-hidden="true" />
+          <h2>{props.spaceName ?? t("space.untitled")}</h2>
+          <Tag className="owb-space-header__root" variant="filled">
+            {t("space.rootHint")}
+          </Tag>
+        </div>
+        <div className="owb-space-header__view">
+          <button
+            type="button"
+            className={view === "document" ? "is-active" : ""}
+            onClick={() => setView("document")}
+          >
+            <FileText size={14} aria-hidden="true" />
+            {t("space.view.document")}
+          </button>
+          <button
+            type="button"
+            className={view === "structure" ? "is-active" : ""}
+            onClick={() => setView("structure")}
+          >
+            <LayoutList size={14} aria-hidden="true" />
+            {t("space.view.structure")}
+          </button>
+        </div>
+      </header>
+
+      <div className="owb-space-body">
+        <aside className="owb-space-files">
+          <div className="owb-space-files__head">{t("space.filesTitle")}</div>
+          <ul className="owb-space-files__list">
+            {props.files.map((file) => (
+              <li key={file.path}>
+                <button
+                  type="button"
+                  className={file.path === activePath ? "is-active" : ""}
+                  onClick={() => setActivePath(file.path)}
+                >
+                  <FileText size={13} aria-hidden="true" />
+                  <span className="owb-space-files__name">{file.path}</span>
+                  {file.path === spineFile ? (
+                    <Tag variant="filled" className="owb-space-files__spine">
+                      {t("space.spineTag")}
+                    </Tag>
+                  ) : null}
+                </button>
+              </li>
+            ))}
+          </ul>
+
+          <div className="owb-space-files__head">{t("space.participantsTitle")}</div>
+          <ul className="owb-space-agents">
+            {owner ? (
+              <li className="owb-space-agents__item owb-space-agents__item--owner">
+                <Users size={13} aria-hidden="true" />
+                <span>{owner.name}</span>
+                <Tag color="blue" variant="filled">
+                  {t("space.ownerTag")}
+                </Tag>
+              </li>
+            ) : null}
+            {others.map((agent) => (
+              <li key={agent.positionId} className="owb-space-agents__item">
+                <button
+                  type="button"
+                  onClick={() => props.onOpenBoundSession?.(agent.positionId)}
+                  disabled={!props.onOpenBoundSession}
+                >
+                  {agent.name}
+                </button>
+              </li>
+            ))}
+          </ul>
+        </aside>
+
+        <main className="owb-space-content">
+          {loading ? (
+            <div className="owb-space-content__loading">
+              <Spin />
+            </div>
+          ) : error ? (
+            <div className="owb-space-content__error">{error}</div>
+          ) : view === "document" ? (
+            <article className="owb-space-doc" data-path={activePath}>
+              <Markdown content={source} />
+            </article>
+          ) : (
+            <SpaceStructure doc={doc} decided={decided} />
+          )}
+        </main>
+      </div>
+
+      {isSpine && !loading ? (
+        <footer className="owb-space-gate-host">
+          <AcceptanceGate draft={gateDraft} criteria={doc.criteria} onDecide={handleDecide} />
+        </footer>
+      ) : null}
+    </div>
+  );
+}
+
+interface SpaceStructureProps {
+  doc: SpaceDoc;
+  decided: AcceptanceRecord | null;
+}
+
+/** The structural rendering of the same file — never a second copy of it. */
+function SpaceStructure({ doc, decided }: SpaceStructureProps) {
+  const t = useT();
+  const columns: Array<{ id: SpaceDocTask["status"]; label: string }> = [
+    { id: "todo", label: t("space.status.todo") },
+    { id: "in_progress", label: t("space.status.in_progress") },
+    { id: "blocked", label: t("space.status.blocked") },
+    { id: "review", label: t("space.status.review") },
+    { id: "done", label: t("space.status.done") },
+  ];
+
+  return (
+    <div className="owb-space-structure">
+      <section className="owb-space-structure__section">
+        <h3>{t("space.structure.criteria")}</h3>
+        {doc.criteria.length === 0 ? (
+          <p className="owb-space-structure__hint">{t("space.structure.noCriteria")}</p>
+        ) : (
+          <ul className="owb-space-criteria-list">
+            {doc.criteria.map((criterion: SpaceDocCriterion) => (
+              <li key={criterion.criteriaIndex} data-done={criterion.done}>
+                <span className="owb-space-criteria-list__box" aria-hidden="true">
+                  {criterion.done ? "✓" : ""}
+                </span>
+                <span>{criterion.text}</span>
+              </li>
+            ))}
+          </ul>
+        )}
+      </section>
+
+      <section className="owb-space-structure__section">
+        <h3>{t("space.structure.board")}</h3>
+        {doc.tasksUnparseable ? (
+          <p className="owb-space-structure__warn">{t("space.structure.unparseable")}</p>
+        ) : null}
+        <div className="owb-space-board">
+          {columns.map((column) => {
+            const tasks = doc.tasks.filter((task) => task.status === column.id);
+            return (
+              <div key={column.id} className="owb-space-board__column">
+                <div className="owb-space-board__column-head">
+                  <span>{column.label}</span>
+                  <Tag variant="filled">{tasks.length}</Tag>
+                </div>
+                <ul>
+                  {tasks.map((task, index) => (
+                    <li key={`${task.title}-${index}`} className="owb-space-board__card">
+                      <div className="owb-space-board__card-title">{task.title}</div>
+                      {task.assigneePositionId ? (
+                        <div className="owb-space-board__card-meta">{task.assigneePositionId}</div>
+                      ) : null}
+                      {task.dueDate ? (
+                        <Tag variant="filled" color={statusTone(task.status)}>
+                          {task.dueDate}
+                        </Tag>
+                      ) : null}
+                    </li>
+                  ))}
+                </ul>
+              </div>
+            );
+          })}
+        </div>
+      </section>
+
+      {decided ? (
+        <section className="owb-space-structure__section owb-space-structure__decision">
+          <h3>
+            <GitBranch size={14} aria-hidden="true" />
+            {t("space.structure.lastDecision")}
+          </h3>
+          <p>
+            {decided.decision === "accepted" ? t("space.decision.accepted") : t("space.decision.rejected")}
+            {" · "}
+            {decided.decidedAt}
+          </p>
+          {decided.note ? <p className="owb-space-structure__hint">{decided.note}</p> : null}
+        </section>
+      ) : null}
+    </div>
+  );
+}
+
+export { buildAcceptanceRecord };
diff --git a/apps/desktop/renderer/src/space/acceptance-gate-model.ts b/apps/desktop/renderer/src/space/acceptance-gate-model.ts
new file mode 100644
index 00000000..03ccb7bd
--- /dev/null
+++ b/apps/desktop/renderer/src/space/acceptance-gate-model.ts
@@ -0,0 +1,96 @@
+// Value import via the subpath; see SpaceModule for why the barrel is avoided.
+import { ACCEPTANCE_SCHEMA_VERSION, validateAcceptanceRecord } from "@roleweave/shared/acceptance";
+import type {
+  AcceptanceDecision,
+  AcceptanceRecord,
+  AcceptanceVerdict,
+  SpaceDocCriterion,
+} from "@roleweave/shared";
+
+/**
+ * Build the acceptance payload for a space gate.
+ *
+ * The gate is the one place where the UI must not be able to produce an
+ * invalid record: an `accepted` decision is only legal when every criterion
+ * is ticked. Rather than let the component decide that, it funnels through
+ * here so the rule is testable on its own.
+ */
+export interface GateDraft {
+  spaceId: string;
+  positionId: string;
+  turnId?: string;
+  artifactPath?: string;
+  decidedBy: string;
+}
+
+export interface GateTicks {
+  /** criteriaIndex → ticked. Absent means unticked. */
+  [criteriaIndex: number]: boolean;
+}
+
+export interface GateEvidence {
+  /** criteriaIndex → artifact path shown as evidence. */
+  [criteriaIndex: number]: string | undefined;
+}
+
+export function untickedCriteria(criteria: SpaceDocCriterion[], ticks: GateTicks): number[] {
+  return criteria.filter((criterion) => ticks[criterion.criteriaIndex] !== true).map((criterion) => criterion.criteriaIndex);
+}
+
+/** The accept button is enabled only when this is true. */
+export function canAccept(criteria: SpaceDocCriterion[], ticks: GateTicks): boolean {
+  return criteria.length > 0 && untickedCriteria(criteria, ticks).length === 0;
+}
+
+/** A rejection is only meaningful with a reason; the field is not optional here. */
+export function canReject(note: string): boolean {
+  return note.trim().length > 0;
+}
+
+export function buildVerdicts(criteria: SpaceDocCriterion[], ticks: GateTicks, evidence: GateEvidence = {}): AcceptanceVerdict[] {
+  return criteria.map((criterion) => {
+    const verdict: AcceptanceVerdict = {
+      criteriaIndex: criterion.criteriaIndex,
+      passed: ticks[criterion.criteriaIndex] === true,
+    };
+    const path = evidence[criterion.criteriaIndex];
+    if (path !== undefined && path.trim().length > 0) verdict.evidencePath = path;
+    return verdict;
+  });
+}
+
+export function buildAcceptanceRecord(
+  draft: GateDraft,
+  criteria: SpaceDocCriterion[],
+  ticks: GateTicks,
+  decision: AcceptanceDecision,
+  note: string,
+  evidence: GateEvidence = {},
+  now: () => Date = () => new Date(),
+): AcceptanceRecord {
+  if (decision === "accepted" && !canAccept(criteria, ticks)) {
+    throw new Error("cannot accept while criteria remain unticked");
+  }
+  if (decision === "rejected" && !canReject(note)) {
+    throw new Error("cannot reject without a note");
+  }
+
+  const record: AcceptanceRecord = {
+    schemaVersion: ACCEPTANCE_SCHEMA_VERSION,
+    acceptanceId: `acceptance:${crypto.randomUUID()}`,
+    spaceId: draft.spaceId,
+    source: { positionId: draft.positionId },
+    criteriaCount: criteria.length,
+    verdicts: buildVerdicts(criteria, ticks, evidence),
+    decision,
+    decidedBy: draft.decidedBy,
+    decidedAt: now().toISOString(),
+  };
+  if (draft.turnId !== undefined) record.source.turnId = draft.turnId;
+  if (draft.artifactPath !== undefined) record.source.artifactPath = draft.artifactPath;
+  if (decision === "rejected") record.note = note.trim();
+
+  const result = validateAcceptanceRecord(record);
+  if (!result.ok) throw new Error(result.message);
+  return result.value;
+}
diff --git a/apps/desktop/renderer/src/space/index.ts b/apps/desktop/renderer/src/space/index.ts
new file mode 100644
index 00000000..d2c4b34b
--- /dev/null
+++ b/apps/desktop/renderer/src/space/index.ts
@@ -0,0 +1,16 @@
+export { SpaceModule, SPACE_SPINE_FILE_KEY } from "./SpaceModule.js";
+export type { SpaceModuleProps, SpaceAgent } from "./SpaceModule.js";
+export { SpaceHost } from "./SpaceHost.js";
+export type { SpaceHostProps } from "./SpaceHost.js";
+export { useSpaceFiles } from "./useSpaceFiles.js";
+export type { SpaceFilesState } from "./useSpaceFiles.js";
+export { AcceptanceGate } from "./AcceptanceGate.js";
+export type { AcceptanceGateProps } from "./AcceptanceGate.js";
+export {
+  buildAcceptanceRecord,
+  buildVerdicts,
+  canAccept,
+  canReject,
+  untickedCriteria,
+} from "./acceptance-gate-model.js";
+export type { GateDraft, GateEvidence, GateTicks } from "./acceptance-gate-model.js";
diff --git a/apps/desktop/renderer/src/space/space-gate.css b/apps/desktop/renderer/src/space/space-gate.css
new file mode 100644
index 00000000..942cd38d
--- /dev/null
+++ b/apps/desktop/renderer/src/space/space-gate.css
@@ -0,0 +1,63 @@
+.owb-app .owb-space-gate {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  max-width: 780px;
+}
+
+.owb-app .owb-space-gate__empty {
+  margin: 0;
+  color: var(--ui-foreground-muted);
+  font-size: 12px;
+}
+
+.owb-app .owb-space-gate__head {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 12px;
+}
+
+.owb-app .owb-space-gate__title {
+  margin: 0;
+  font-size: 13px;
+  font-weight: 600;
+}
+
+.owb-app .owb-space-gate__progress,
+.owb-app .owb-space-gate__hint,
+.owb-app .owb-space-gate__confirm {
+  color: var(--ui-foreground-muted);
+  font-size: 12px;
+}
+
+.owb-app .owb-space-gate__list {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.owb-app .owb-space-gate__item {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.owb-app .owb-space-gate__evidence {
+  flex: 1;
+  min-width: 0;
+  max-width: 260px;
+}
+
+.owb-app .owb-space-gate__note {
+  max-width: 520px;
+}
+
+.owb-app .owb-space-gate__actions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
diff --git a/apps/desktop/renderer/src/space/space.css b/apps/desktop/renderer/src/space/space.css
new file mode 100644
index 00000000..4e9de588
--- /dev/null
+++ b/apps/desktop/renderer/src/space/space.css
@@ -0,0 +1,293 @@
+.owb-app .owb-space-module {
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+  height: 100%;
+  background: var(--ui-surface);
+  color: var(--ui-foreground);
+}
+
+.owb-app .owb-space-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  padding: 12px 20px;
+  border-bottom: 1px solid var(--ui-border);
+}
+
+.owb-app .owb-space-header__title {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
+}
+
+.owb-app .owb-space-header__title h2 {
+  margin: 0;
+  font-size: 15px;
+  font-weight: 600;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.owb-app .owb-space-header__view {
+  display: flex;
+  gap: 4px;
+  padding: 2px;
+  border-radius: 8px;
+  background: var(--ui-surface-sunken, rgba(127, 127, 127, 0.12));
+}
+
+.owb-app .owb-space-header__view button {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 4px 10px;
+  border: 0;
+  border-radius: 6px;
+  background: transparent;
+  color: var(--ui-foreground-muted);
+  font-size: 12px;
+  cursor: pointer;
+}
+
+.owb-app .owb-space-header__view button.is-active {
+  background: var(--ui-surface);
+  color: var(--ui-foreground);
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.12);
+}
+
+.owb-app .owb-space-body {
+  display: grid;
+  grid-template-columns: 232px minmax(0, 1fr);
+  flex: 1;
+  min-height: 0;
+}
+
+.owb-app .owb-space-files {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  padding: 12px 8px;
+  border-inline-end: 1px solid var(--ui-border);
+  overflow-y: auto;
+}
+
+.owb-app .owb-space-files__head {
+  padding: 8px 8px 4px;
+  color: var(--ui-foreground-muted);
+  font-size: 11px;
+  font-weight: 600;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+}
+
+.owb-app .owb-space-files__list,
+.owb-app .owb-space-agents {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.owb-app .owb-space-files__list button,
+.owb-app .owb-space-agents__item button {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  width: 100%;
+  padding: 5px 8px;
+  border: 0;
+  border-radius: 6px;
+  background: transparent;
+  color: var(--ui-foreground);
+  font-size: 12px;
+  text-align: start;
+  cursor: pointer;
+}
+
+.owb-app .owb-space-files__list button:hover,
+.owb-app .owb-space-agents__item button:hover {
+  background: var(--ui-surface-hover, rgba(127, 127, 127, 0.12));
+}
+
+.owb-app .owb-space-files__list button.is-active {
+  background: var(--ui-primary-soft, rgba(134, 160, 255, 0.16));
+  color: var(--ui-primary);
+}
+
+.owb-app .owb-space-files__name {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.owb-app .owb-space-agents__item {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 4px 8px;
+  font-size: 12px;
+}
+
+.owb-app .owb-space-agents__item--owner {
+  color: var(--ui-foreground);
+}
+
+.owb-app .owb-space-content {
+  min-width: 0;
+  overflow-y: auto;
+  padding: 20px 28px;
+}
+
+.owb-app .owb-space-content__loading,
+.owb-app .owb-space-content__error {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 160px;
+  color: var(--ui-foreground-muted);
+  font-size: 13px;
+}
+
+.owb-app .owb-space-content__error {
+  color: var(--ui-danger, #e5484d);
+}
+
+.owb-app .owb-space-doc {
+  max-width: 780px;
+}
+
+.owb-app .owb-space-structure {
+  display: flex;
+  flex-direction: column;
+  gap: 24px;
+}
+
+.owb-app .owb-space-structure__section h3 {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  margin: 0 0 10px;
+  font-size: 13px;
+  font-weight: 600;
+}
+
+.owb-app .owb-space-structure__hint,
+.owb-app .owb-space-structure__warn {
+  margin: 0;
+  color: var(--ui-foreground-muted);
+  font-size: 12px;
+}
+
+.owb-app .owb-space-structure__warn {
+  color: var(--ui-warning, #f5a524);
+}
+
+.owb-app .owb-space-criteria-list {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.owb-app .owb-space-criteria-list li {
+  display: flex;
+  align-items: flex-start;
+  gap: 8px;
+  font-size: 13px;
+}
+
+.owb-app .owb-space-criteria-list__box {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 16px;
+  height: 16px;
+  margin-top: 1px;
+  border: 1px solid var(--ui-border);
+  border-radius: 4px;
+  color: var(--ui-primary);
+  font-size: 11px;
+}
+
+.owb-app .owb-space-criteria-list li[data-done="true"] {
+  color: var(--ui-foreground-muted);
+  text-decoration: line-through;
+}
+
+.owb-app .owb-space-board {
+  display: grid;
+  grid-template-columns: repeat(5, minmax(0, 1fr));
+  gap: 10px;
+}
+
+.owb-app .owb-space-board__column {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding: 10px;
+  border: 1px solid var(--ui-border);
+  border-radius: 10px;
+  background: var(--ui-surface-sunken, rgba(127, 127, 127, 0.06));
+}
+
+.owb-app .owb-space-board__column-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  color: var(--ui-foreground-muted);
+  font-size: 12px;
+  font-weight: 600;
+}
+
+.owb-app .owb-space-board__column ul {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.owb-app .owb-space-board__card {
+  padding: 8px;
+  border: 1px solid var(--ui-border);
+  border-radius: 8px;
+  background: var(--ui-surface);
+}
+
+.owb-app .owb-space-board__card-title {
+  font-size: 12px;
+  line-height: 1.4;
+}
+
+.owb-app .owb-space-board__card-meta {
+  margin-top: 4px;
+  color: var(--ui-foreground-muted);
+  font-size: 11px;
+}
+
+.owb-app .owb-space-gate-host {
+  border-top: 1px solid var(--ui-border);
+  padding: 12px 20px 16px;
+  background: var(--ui-surface-sunken, rgba(127, 127, 127, 0.05));
+}
+
+@media (max-width: 1100px) {
+  .owb-app .owb-space-body {
+    grid-template-columns: minmax(0, 1fr);
+  }
+  .owb-app .owb-space-files {
+    border-inline-end: 0;
+    border-bottom: 1px solid var(--ui-border);
+  }
+  .owb-app .owb-space-board {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+}
diff --git a/apps/desktop/renderer/src/space/useSpaceFiles.ts b/apps/desktop/renderer/src/space/useSpaceFiles.ts
new file mode 100644
index 00000000..69ba0150
--- /dev/null
+++ b/apps/desktop/renderer/src/space/useSpaceFiles.ts
@@ -0,0 +1,89 @@
+import { useCallback, useEffect, useState } from "react";
+import { useT } from "@roleweave/ui";
+import type { DocsFileEntry } from "@roleweave/shared";
+
+export interface SpaceFilesState {
+  files: DocsFileEntry[];
+  loading: boolean;
+  error: string | null;
+  reload: () => void;
+  readFile: (path: string) => Promise<{ content: string; version: string }>;
+  writeFile: ((path: string, content: string, expectedVersion: string) => Promise<{ version: string }>) | undefined;
+}
+
+/**
+ * Loads the files of one space folder.
+ *
+ * A space is identified by the position whose package directory holds it, so
+ * the existing position-docs IPC is reused unchanged. Writes are optional so
+ * the module degrades to read-only when the bridge lacks them.
+ */
+export function useSpaceFiles(positionId: string | null, workspaceOpen: boolean): SpaceFilesState {
+  const t = useT();
+  const [files, setFiles] = useState<DocsFileEntry[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [reloadToken, setReloadToken] = useState(0);
+
+  useEffect(() => {
+    if (!workspaceOpen || !positionId) {
+      setFiles([]);
+      return;
+    }
+    let alive = true;
+    setLoading(true);
+    setError(null);
+    void window.owb
+      .positionDocs(positionId)
+      .then((res) => {
+        if (!alive) return;
+        if (res.status >= 400 || !res.body) {
+          setError(t("space.error.read", { path: positionId }));
+          setFiles([]);
+          return;
+        }
+        setFiles(res.body.files);
+      })
+      .catch(() => {
+        if (alive) setError(t("space.error.read", { path: positionId }));
+      })
+      .finally(() => {
+        if (alive) setLoading(false);
+      });
+    return () => {
+      alive = false;
+    };
+  }, [positionId, workspaceOpen, reloadToken, t]);
+
+  const readFile = useCallback(
+    async (path: string): Promise<{ content: string; version: string }> => {
+      if (!positionId) throw new Error(t("space.error.read", { path }));
+      const res = await window.owb.positionDocFile(positionId, path);
+      if (res.status >= 400 || !res.body) throw new Error(t("space.error.read", { path }));
+      return { content: res.body.content, version: res.body.version };
+    },
+    [positionId, t],
+  );
+
+  const writeFile = useCallback(
+    async (path: string, content: string, expectedVersion: string): Promise<{ version: string }> => {
+      const write = window.owb.writePositionDoc;
+      if (!positionId || !write) throw new Error(t("space.error.write", { path }));
+      const res = await write({ positionId, path, content, expectedVersion });
+      if (res.status >= 400 || !res.body) throw new Error(t("space.error.write", { path }));
+      return { version: res.body.version };
+    },
+    [positionId, t],
+  );
+
+  const reload = useCallback(() => setReloadToken((token) => token + 1), []);
+
+  return {
+    files,
+    loading,
+    error,
+    reload,
+    readFile,
+    writeFile: window.owb.writePositionDoc ? writeFile : undefined,
+  };
+}
diff --git a/apps/desktop/renderer/test/App.test.tsx b/apps/desktop/renderer/test/App.test.tsx
index 61b1cb59..98a25b63 100644
--- a/apps/desktop/renderer/test/App.test.tsx
+++ b/apps/desktop/renderer/test/App.test.tsx
@@ -323,7 +323,7 @@ describe("App context navigation", () => {
     render(<App />);
     await screen.findByRole("tree");
     const rail = within(screen.getByRole("navigation", { name: "模块" }));
-    expect(rail.getAllByRole("button").filter(button => !button.hasAttribute("aria-expanded")).map(button => button.getAttribute("aria-label") ?? button.textContent)).toEqual(["协作", "组织", "项目", "收件箱", "设置"]);
+    expect(rail.getAllByRole("button").filter(button => !button.hasAttribute("aria-expanded")).map(button => button.getAttribute("aria-label") ?? button.textContent)).toEqual(["协作", "组织", "项目", "协作区", "收件箱", "设置"]);
     expect(rail.getByRole("button", { name: "协作" })).toHaveAttribute("aria-current", "page");
   });
 
diff --git a/apps/desktop/renderer/test/space-acceptance-gate.test.ts b/apps/desktop/renderer/test/space-acceptance-gate.test.ts
new file mode 100644
index 00000000..9973b6ac
--- /dev/null
+++ b/apps/desktop/renderer/test/space-acceptance-gate.test.ts
@@ -0,0 +1,116 @@
+import { describe, expect, it } from "vitest";
+import type { SpaceDocCriterion } from "@roleweave/shared";
+import {
+  buildAcceptanceRecord,
+  buildVerdicts,
+  canAccept,
+  canReject,
+  untickedCriteria,
+  type GateDraft,
+} from "../src/space/acceptance-gate-model.js";
+
+const criteria: SpaceDocCriterion[] = [
+  { criteriaIndex: 0, text: "差异可归因", done: false, marker: " " },
+  { criteriaIndex: 1, text: "口径已评审", done: false, marker: " " },
+  { criteriaIndex: 2, text: "回滚有演练", done: false, marker: " " },
+];
+
+const draft: GateDraft = {
+  spaceId: "space-billing",
+  positionId: "analyst",
+  decidedBy: "operator",
+};
+
+const fixedNow = () => new Date("2026-10-01T12:00:00.000Z");
+
+describe("gate readiness", () => {
+  it("blocks accept until every criterion is ticked", () => {
+    expect(canAccept(criteria, {})).toBe(false);
+    expect(canAccept(criteria, { 0: true, 1: true })).toBe(false);
+    expect(canAccept(criteria, { 0: true, 1: true, 2: true })).toBe(true);
+  });
+
+  it("never accepts an empty criteria list", () => {
+    expect(canAccept([], {})).toBe(false);
+  });
+
+  it("lists exactly the unticked indices", () => {
+    expect(untickedCriteria(criteria, { 1: true })).toEqual([0, 2]);
+    expect(untickedCriteria(criteria, { 0: true, 1: true, 2: true })).toEqual([]);
+  });
+
+  it("requires a non-blank reason to reject", () => {
+    expect(canReject("")).toBe(false);
+    expect(canReject("   ")).toBe(false);
+    expect(canReject("no evidence")).toBe(true);
+  });
+});
+
+describe("verdict construction", () => {
+  it("emits one verdict per criterion, in order", () => {
+    const verdicts = buildVerdicts(criteria, { 0: true, 2: true });
+    expect(verdicts).toEqual([
+      { criteriaIndex: 0, passed: true },
+      { criteriaIndex: 1, passed: false },
+      { criteriaIndex: 2, passed: true },
+    ]);
+  });
+
+  it("attaches evidence only when a path is non-blank", () => {
+    const verdicts = buildVerdicts(criteria, { 0: true }, { 0: "产出/a.md", 1: "   " });
+    expect(verdicts[0].evidencePath).toBe("产出/a.md");
+    expect(verdicts[1].evidencePath).toBeUndefined();
+  });
+});
+
+describe("record construction", () => {
+  it("builds an accepted record that satisfies acceptance.v1", () => {
+    const record = buildAcceptanceRecord(
+      draft,
+      criteria,
+      { 0: true, 1: true, 2: true },
+      "accepted",
+      "",
+      {},
+      fixedNow,
+    );
+    expect(record.schemaVersion).toBe("acceptance.v1");
+    expect(record.decision).toBe("accepted");
+    expect(record.verdicts).toHaveLength(3);
+    expect(record.verdicts.every((verdict) => verdict.passed)).toBe(true);
+    expect(record.note).toBeUndefined();
+    expect(record.decidedAt).toBe("2026-10-01T12:00:00.000Z");
+  });
+
+  it("refuses to build an accepted record with a gap", () => {
+    expect(() =>
+      buildAcceptanceRecord(draft, criteria, { 0: true }, "accepted", "", {}, fixedNow),
+    ).toThrow(/unticked/);
+  });
+
+  it("refuses to build a rejected record with no reason", () => {
+    expect(() =>
+      buildAcceptanceRecord(draft, criteria, {}, "rejected", "  ", {}, fixedNow),
+    ).toThrow(/note/);
+  });
+
+  it("keeps the rejection reason, trimmed", () => {
+    const record = buildAcceptanceRecord(draft, criteria, {}, "rejected", "  needs evidence  ", {}, fixedNow);
+    expect(record.decision).toBe("rejected");
+    expect(record.note).toBe("needs evidence");
+  });
+
+  it("carries turn and artifact provenance when provided", () => {
+    const record = buildAcceptanceRecord(
+      { ...draft, turnId: "turn-9", artifactPath: "目标.md" },
+      criteria,
+      { 0: true, 1: true, 2: true },
+      "accepted",
+      "",
+      {},
+      fixedNow,
+    );
+    expect(record.source.turnId).toBe("turn-9");
+    expect(record.source.artifactPath).toBe("目标.md");
+  });
+});
diff --git a/apps/desktop/renderer/test/space-module.test.tsx b/apps/desktop/renderer/test/space-module.test.tsx
new file mode 100644
index 00000000..bcdf07fc
--- /dev/null
+++ b/apps/desktop/renderer/test/space-module.test.tsx
@@ -0,0 +1,149 @@
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { zhCatalog } from "@roleweave/ui";
+import { SpaceModule, SPACE_SPINE_FILE_KEY } from "../src/space/SpaceModule.js";
+import type { DocsFileEntry } from "@roleweave/shared";
+
+/**
+ * The spine filename is UI copy, so it lives in the catalog rather than as a
+ * literal in the component (the CJK gate forbids string literals under src/).
+ * Read it back from the same catalog so the fixtures cannot drift.
+ */
+const SPACE_SPINE_FILE = zhCatalog[SPACE_SPINE_FILE_KEY] as string;
+
+const SPINE = `# 目标：对账自动化
+
+先说结论。
+
+## 验收标准
+- [ ] 差异可归因
+- [ ] 口径已评审
+
+## 任务
+| 任务 | 状态 | 负责岗位 | 截止 |
+| --- | --- | --- | --- |
+| 写脚本 | in_progress | engineer | 2026-10-05 |
+| 梳理分类 | done | analyst | 2026-09-20 |
+`;
+
+const files: DocsFileEntry[] = [
+  { path: SPACE_SPINE_FILE, kind: "file", size: SPINE.length, modifiedAt: "2026-10-01T00:00:00.000Z" },
+  { path: "笔记.md", kind: "file", size: 10, modifiedAt: "2026-10-01T00:00:00.000Z" },
+];
+
+function setup(overrides: Partial<Parameters<typeof SpaceModule>[0]> = {}) {
+  const readFile = vi.fn(async (path: string) => ({ content: path === SPACE_SPINE_FILE ? SPINE : "笔记", version: "v1" }));
+  const writeFile = vi.fn(async () => ({ version: "v2" }));
+  const onAccept = vi.fn();
+  const utils = render(
+    <SpaceModule
+      workspaceOpen
+      spaceName="对账专项"
+      files={files}
+      readFile={readFile}
+      writeFile={writeFile}
+      participants={[
+        { positionId: "operator", name: "修雨", owner: true },
+        { positionId: "engineer", name: "工程师", owner: false },
+      ]}
+      onAccept={onAccept}
+      {...overrides}
+    />,
+  );
+  return { ...utils, readFile, writeFile, onAccept };
+}
+
+describe("SpaceModule", () => {
+  it("loads the spine file by default", async () => {
+    const { readFile } = setup();
+    await waitFor(() => expect(readFile).toHaveBeenCalledWith(SPACE_SPINE_FILE));
+    await screen.findByText(/先说结论/);
+  });
+
+  it("marks exactly one participant as owner", async () => {
+    setup();
+    await screen.findByText("修雨");
+    const ownerRow = document.querySelector(".owb-space-agents__item--owner");
+    expect(ownerRow?.textContent).toContain("修雨");
+    expect(document.querySelectorAll(".owb-space-agents__item--owner")).toHaveLength(1);
+  });
+
+  it("switches to the structure view and renders the board columns", async () => {
+    setup();
+    await screen.findByText(/先说结论/);
+    fireEvent.click(screen.getByRole("button", { name: /结构/ }));
+    await waitFor(() => expect(document.querySelector(".owb-space-structure")).toBeTruthy());
+    expect(screen.getByText("写脚本")).toBeTruthy();
+    expect(screen.getByText("梳理分类")).toBeTruthy();
+  });
+
+  it("disables accept until every criterion is ticked", async () => {
+    const { onAccept } = setup();
+    await waitFor(() => expect(document.querySelector(".owb-space-gate")).toBeTruthy());
+    const gate = document.querySelector(".owb-space-gate") as HTMLElement;
+
+    const acceptNow = () =>
+      Array.from(gate.querySelectorAll("button")).find((b) => b.textContent?.includes("验收通过")) as HTMLButtonElement;
+    // antd inserts a space between two CJK characters, so match on the raw text
+    // with whitespace stripped rather than an exact string.
+    const confirmNow = () =>
+      Array.from(gate.querySelectorAll("button")).find(
+        (b) => b.textContent?.replace(/\s/g, "") === "确认",
+      ) as HTMLButtonElement | undefined;
+
+    expect(acceptNow().disabled).toBe(true);
+
+    const boxes = Array.from(gate.querySelectorAll('input[type="checkbox"]')) as HTMLInputElement[];
+    expect(boxes).toHaveLength(2);
+    for (const box of boxes) fireEvent.click(box);
+
+    await waitFor(() => expect(acceptNow().disabled).toBe(false));
+
+    fireEvent.click(acceptNow());
+    await waitFor(() => expect(confirmNow()).toBeTruthy());
+    fireEvent.click(confirmNow() as HTMLButtonElement);
+    await waitFor(() => expect(onAccept).toHaveBeenCalledTimes(1));
+  });
+
+  it("writes criteria back as done on acceptance", async () => {
+    const { writeFile } = setup();
+    await waitFor(() => expect(document.querySelector(".owb-space-gate")).toBeTruthy());
+    const gate = document.querySelector(".owb-space-gate") as HTMLElement;
+    const boxes = Array.from(gate.querySelectorAll('input[type="checkbox"]')) as HTMLInputElement[];
+    for (const box of boxes) fireEvent.click(box);
+    fireEvent.click(
+      Array.from(gate.querySelectorAll("button")).find((b) => b.textContent?.includes("验收通过")) as HTMLButtonElement,
+    );
+    await waitFor(() =>
+      expect(
+        Array.from(gate.querySelectorAll("button")).some((b) => b.textContent?.replace(/\s/g, "") === "确认"),
+      ).toBe(true),
+    );
+    fireEvent.click(
+      Array.from(gate.querySelectorAll("button")).find(
+        (b) => b.textContent?.replace(/\s/g, "") === "确认",
+      ) as HTMLButtonElement,
+    );
+    await waitFor(() => expect(writeFile).toHaveBeenCalled());
+    const [, content] = writeFile.mock.calls[0] as unknown as [string, string, string];
+    expect(content).toContain("- [x] 差异可归因");
+    expect(content).toContain("- [x] 口径已评审");
+  });
+});
+
+
+describe("acceptance write failure", () => {
+  it("does not report acceptance when optimistic document persistence fails", async () => {
+    const writeFile = vi.fn(async () => { throw new Error("version conflict"); });
+    const {onAccept} = setup({writeFile});
+    await screen.findByText(/先说结论/);
+    const gate = document.querySelector(".owb-space-gate") as HTMLElement;
+    for (const box of gate.querySelectorAll('input[type="checkbox"]')) fireEvent.click(box);
+    fireEvent.click(Array.from(gate.querySelectorAll("button")).find((b) => b.textContent?.includes("验收通过")) as HTMLButtonElement);
+    fireEvent.click(Array.from(gate.querySelectorAll("button")).find((b) => b.textContent?.replace(/\s/g, "") === "确认") as HTMLButtonElement);
+    await waitFor(() => expect(writeFile).toHaveBeenCalledTimes(1));
+    await screen.findByText(/写入|保存|无法/);
+    expect(onAccept).not.toHaveBeenCalled();
+    expect(document.querySelector(".owb-space-structure__decision")).toBeNull();
+  });
+});
diff --git a/apps/server/test/space-doc.test.ts b/apps/server/test/space-doc.test.ts
new file mode 100644
index 00000000..c7f22d90
--- /dev/null
+++ b/apps/server/test/space-doc.test.ts
@@ -0,0 +1,231 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  SPACE_DOC_SCHEMA_VERSION,
+  parseSpaceDoc,
+  renderSpaceDoc,
+} from "@roleweave/shared";
+
+/**
+ * Indexed access under `noUncheckedIndexedAccess` is `T | undefined`, which turns
+ * every `list[0]` in an assertion into a type error. These tests assert on known
+ * fixtures, so narrow once here instead of scattering `!` through the file.
+ */
+function at<T>(list: readonly T[], index: number): T {
+  assert.ok(index >= 0 && index < list.length, `index ${index} out of range`);
+  const value = list[index];
+  assert.ok(value !== undefined, `index ${index} is undefined`);
+  return value;
+}
+
+const DOC = `# 目标：把结算对账自动化
+
+先把口径对齐，再看边界。
+
+## 背景
+
+这块现在靠人工，每月两个人力日。
+
+## 验收标准
+- [ ] 对账差异能被自动归因
+- [x] 口径文档已评审
+- [ ] 回滚路径有演练记录
+
+## 任务
+| 任务 | 状态 | 负责岗位 | 截止 |
+| --- | --- | --- | --- |
+| 梳理差异分类 | done | analyst | 2026-09-20 |
+| 写对账脚本 | in_progress | engineer | 2026-10-05 |
+| 补回滚演练 | todo |  |  |
+
+## 风险
+
+数据源有延迟。
+`;
+
+test("parses the title", () => {
+  const { doc } = parseSpaceDoc(DOC);
+  assert.equal(doc.title, "把结算对账自动化");
+  assert.equal(doc.schemaVersion, SPACE_DOC_SCHEMA_VERSION);
+});
+
+test("parses criteria with their checkbox state and stable index", () => {
+  const { doc } = parseSpaceDoc(DOC);
+  assert.equal(doc.criteria.length, 3);
+  assert.deepEqual(doc.criteria.map((c) => c.criteriaIndex), [0, 1, 2]);
+  assert.equal(at(doc.criteria, 0).text, "对账差异能被自动归因");
+  assert.equal(at(doc.criteria, 0).done, false);
+  assert.equal(at(doc.criteria, 1).done, true);
+  assert.equal(at(doc.criteria, 1).marker, "x");
+});
+
+test("parses the task table into typed rows", () => {
+  const { doc } = parseSpaceDoc(DOC);
+  assert.equal(doc.tasks.length, 3);
+  assert.deepEqual(at(doc.tasks, 0), {
+    title: "梳理差异分类",
+    status: "done",
+    assigneePositionId: "analyst",
+    dueDate: "2026-09-20",
+    raw: ["梳理差异分类", "done", "analyst", "2026-09-20"],
+  });
+  assert.equal(at(doc.tasks, 1).status, "in_progress");
+  assert.equal(at(doc.tasks, 2).assigneePositionId, undefined);
+  assert.equal(at(doc.tasks, 2).dueDate, undefined);
+});
+
+test("keeps sections the parser does not own, in document order", () => {
+  const { doc } = parseSpaceDoc(DOC);
+  assert.deepEqual(doc.otherSections.map((s) => s.heading), ["背景", "风险"]);
+  assert.equal(at(doc.otherSections, 0).body.join("\n").trim(), "这块现在靠人工，每月两个人力日。");
+});
+
+test("keeps the intro prose before the first H2", () => {
+  const { doc } = parseSpaceDoc(DOC);
+  assert.equal(doc.intro, "先把口径对齐，再看边界。");
+});
+
+test("a document without the structured sections is still total", () => {
+  const { doc, issues } = parseSpaceDoc("# 只有标题\n\n随便写点东西。\n");
+  assert.equal(doc.title, "只有标题");
+  assert.deepEqual(doc.criteria, []);
+  assert.deepEqual(doc.tasks, []);
+  assert.equal(doc.tasksUnparseable, false);
+  assert.deepEqual(issues, []);
+  assert.equal(doc.intro, "随便写点东西。");
+});
+
+test("an empty string parses without throwing", () => {
+  const { doc } = parseSpaceDoc("");
+  assert.equal(doc.title, "");
+  assert.deepEqual(doc.criteria, []);
+  assert.deepEqual(doc.tasks, []);
+});
+
+test("flags a task table that yields no rows", () => {
+  const { doc } = parseSpaceDoc("# 目标：x\n\n## 任务\n| 任务 | 状态 |\n| --- | --- |\n");
+  assert.equal(doc.tasks.length, 0);
+  assert.equal(doc.tasksUnparseable, true);
+});
+
+test("reports an unknown status instead of guessing", () => {
+  const source = "# 目标：x\n\n## 任务\n| 任务 | 状态 |\n| --- | --- |\n| a | 做完了 |\n";
+  const { doc, issues } = parseSpaceDoc(source);
+  assert.equal(at(doc.tasks, 0).status, "todo");
+  assert.equal(issues.length, 1);
+  assert.match(at(issues, 0).message, /unknown task status/);
+});
+
+test("ignores a non-position assignee and a non-date due, with an issue", () => {
+  const source =
+    "# 目标：x\n\n## 任务\n| 任务 | 状态 | 负责岗位 | 截止 |\n| --- | --- | --- | --- |\n| a | todo | Alice Smith | 明天 |\n";
+  const { doc, issues } = parseSpaceDoc(source);
+  assert.equal(at(doc.tasks, 0).assigneePositionId, undefined);
+  assert.equal(at(doc.tasks, 0).dueDate, undefined);
+  assert.equal(issues.length, 2);
+});
+
+test("accepts header aliases", () => {
+  const source = "# 目标：x\n\n## 任务\n| Title | Status | Assignee | Due Date |\n| --- | --- | --- | --- |\n| a | blocked | engineer | 2026-11-01 |\n";
+  const { doc } = parseSpaceDoc(source);
+  assert.equal(at(doc.tasks, 0).status, "blocked");
+  assert.equal(at(doc.tasks, 0).assigneePositionId, "engineer");
+  assert.equal(at(doc.tasks, 0).dueDate, "2026-11-01");
+});
+
+test("round-trip preserves prose and other sections byte for byte", () => {
+  const { doc } = parseSpaceDoc(DOC);
+  const rendered = renderSpaceDoc(doc, DOC);
+  const reparsed = parseSpaceDoc(rendered).doc;
+
+  assert.equal(reparsed.intro, doc.intro);
+  // startLine is source provenance, so it legitimately shifts after a rewrite;
+  // the content of sections the parser does not own must not change.
+  assert.deepEqual(
+    reparsed.otherSections.map((s) => ({ heading: s.heading, body: s.body })),
+    doc.otherSections.map((s) => ({ heading: s.heading, body: s.body })),
+  );
+  assert.deepEqual(reparsed.criteria, doc.criteria);
+  assert.deepEqual(reparsed.tasks, doc.tasks);
+  assert.ok(rendered.includes("这块现在靠人工，每月两个人力日。"));
+  assert.ok(rendered.includes("数据源有延迟。"));
+});
+
+test("round-trip on an already-canonical document is a fixed point", () => {
+  const { doc } = parseSpaceDoc(DOC);
+  const once = renderSpaceDoc(doc, DOC);
+  const twice = renderSpaceDoc(parseSpaceDoc(once).doc, once);
+  assert.equal(once, twice);
+});
+
+test("toggling a criterion rewrites only its line", () => {
+  const { doc } = parseSpaceDoc(DOC);
+  doc.criteria[0] = { ...at(doc.criteria, 0), done: true };
+  const rendered = renderSpaceDoc(doc, DOC);
+  assert.ok(rendered.includes("- [x] 对账差异能被自动归因"));
+  assert.ok(rendered.includes("- [x] 口径文档已评审"));
+  assert.ok(rendered.includes("- [ ] 回滚路径有演练记录"));
+});
+
+test("renders a task row without assignee or due as empty cells", () => {
+  const { doc } = parseSpaceDoc(DOC);
+  const rendered = renderSpaceDoc(doc, DOC);
+  assert.ok(rendered.includes("| 补回滚演练 | todo |  |  |"));
+});
+
+test("preserves CRLF line endings", () => {
+  const crlf = DOC.replace(/\n/g, "\r\n");
+  const { doc } = parseSpaceDoc(crlf);
+  const rendered = renderSpaceDoc(doc, crlf);
+  assert.ok(rendered.includes("\r\n"));
+  assert.ok(!rendered.replace(/\r\n/g, "").includes("\n"));
+});
+
+test("criteria before a later section do not leak into it", () => {
+  const source = "# 目标：x\n\n## 验收标准\n- [ ] a\n\n## 备注\n- [ ] 这不是验收项\n";
+  const { doc } = parseSpaceDoc(source);
+  assert.equal(doc.criteria.length, 1);
+  assert.equal(at(doc.criteria, 0).text, "a");
+  assert.equal(doc.otherSections.length, 1);
+  assert.equal(at(doc.otherSections, 0).heading, "备注");
+});
+
+
+test("canonical round trips preserve every byte including separators and EOF", () => {
+  assert.equal(renderSpaceDoc(parseSpaceDoc(DOC).doc, DOC), DOC);
+  for (const eol of ["\n", "\r\n"]) {
+    for (const ending of ["", eol, eol + eol]) {
+      const source = ["# x", "", "## 验收标准", "", "- [ ] a"].join(eol) + ending;
+      assert.equal(renderSpaceDoc(parseSpaceDoc(source).doc, source), source);
+    }
+  }
+});
+
+test("missing sections are inserted rather than silently dropping new data", () => {
+  const source = "# x\n\nKeep this prose.\n";
+  const {doc} = parseSpaceDoc(source);
+  doc.criteria = [{criteriaIndex: 0, text: "new criterion", done: false, marker: " "}];
+  doc.tasks = [{title: "new task", status: "todo", raw: []}];
+  const rendered = renderSpaceDoc(doc, source);
+  assert.ok(rendered.startsWith(source));
+  assert.equal(parseSpaceDoc(rendered).doc.criteria[0]?.text, "new criterion");
+  assert.equal(parseSpaceDoc(rendered).doc.tasks[0]?.title, "new task");
+  assert.equal(renderSpaceDoc(parseSpaceDoc(rendered).doc, rendered), rendered);
+});
+
+test("a missing task section is added without disturbing the existing criteria section", () => {
+  const source = "# x\n\n## 验收标准\n- [ ] a\n";
+  const {doc} = parseSpaceDoc(source);
+  doc.tasks = [{title: "new task", status: "review", raw: []}];
+  const rendered = renderSpaceDoc(doc, source);
+  assert.ok(rendered.startsWith(source));
+  assert.equal(parseSpaceDoc(rendered).doc.tasks[0]?.title, "new task");
+});
+
+test("empty structured sections can be cleared while preserving surrounding prose", () => {
+  const source = "# x\n\n## 验收标准\n- [ ] remove\n\n## Notes\nKeep this.\n";
+  const {doc} = parseSpaceDoc(source); doc.criteria = [];
+  const rendered = renderSpaceDoc(doc, source);
+  assert.ok(!rendered.includes("remove"));
+  assert.ok(rendered.endsWith("\n## Notes\nKeep this.\n"));
+});
diff --git a/packages/shared/package.json b/packages/shared/package.json
index ec21dec8..60942dbd 100644
--- a/packages/shared/package.json
+++ b/packages/shared/package.json
@@ -49,6 +49,10 @@
       "types": "./dist/acceptance.d.ts",
       "import": "./dist/acceptance.js"
     },
+    "./space-doc": {
+      "types": "./dist/space-doc.d.ts",
+      "import": "./dist/space-doc.js"
+    },
     "./task-board": {
       "types": "./dist/task-board.d.ts",
       "import": "./dist/task-board.js"
diff --git a/packages/shared/src/index.ts b/packages/shared/src/index.ts
index 64134633..2bb3b8eb 100644
--- a/packages/shared/src/index.ts
+++ b/packages/shared/src/index.ts
@@ -27,6 +27,7 @@ export * from "./context-sources.js";
 export * from "./updates.js";
 export * from "./goals.js";
 export * from "./acceptance.js";
+export * from "./space-doc.js";
 export * from "./task-board.js";
 export * from "./relationship-graph.js";
 export * from "./avatar.js";
diff --git a/packages/shared/src/space-doc.ts b/packages/shared/src/space-doc.ts
new file mode 100644
index 00000000..5f189f68
--- /dev/null
+++ b/packages/shared/src/space-doc.ts
@@ -0,0 +1,368 @@
+/**
+ * Space document contract (v1).
+ *
+ * A space (专项作战人机协作区) is a folder inside a workspace. Its spine is one
+ * Markdown file that the human and the agents both edit. The file is the
+ * source of truth; the structure below is derived from it, never stored
+ * alongside it.
+ *
+ * Structure is carried by fixed H2 headings rather than a custom DSL or
+ * front-matter schema, so the same file stays readable as a plain document:
+ *
+ *   # 目标：<title>
+ *
+ *   <free prose the human writes>
+ *
+ *   ## 验收标准
+ *   - [ ] <criterion>
+ *
+ *   ## 任务
+ *   | 任务 | 状态 | 负责岗位 | 截止 |
+ *   | --- | --- | --- | --- |
+ *   | <title> | todo | <positionId> | 2026-10-01 |
+ *
+ * Parsing is pure and total: any string produces a result, and a document
+ * that lacks a section simply yields an empty one. Round-tripping the parsed
+ * value never rewrites prose the parser did not understand.
+ */
+
+import { goalWorkItemStatuses, type GoalWorkItemStatus } from "./goals.js";
+
+export const SPACE_DOC_SCHEMA_VERSION = "space-doc.v1" as const;
+
+export const SPACE_DOC_MAX_CRITERIA = 64;
+export const SPACE_DOC_MAX_TASKS = 128;
+export const SPACE_DOC_MAX_TITLE_LENGTH = 256;
+
+/** Section headings are fixed identifiers, not localised at parse time. */
+export const SPACE_DOC_CRITERIA_HEADING = "验收标准" as const;
+export const SPACE_DOC_TASKS_HEADING = "任务" as const;
+
+export interface SpaceDocCriterion {
+  /** Stable index within the document; matches `acceptance.v1` criteriaIndex. */
+  criteriaIndex: number;
+  text: string;
+  done: boolean;
+  /** Raw checkbox token as written, so an unrelated state is not silently lost. */
+  marker: " " | "x" | "X";
+}
+
+export interface SpaceDocTask {
+  title: string;
+  status: GoalWorkItemStatus;
+  /** A position id when the cell looks like one; otherwise undefined. */
+  assigneePositionId?: string;
+  dueDate?: string;
+  /** Cells the parser could not classify, preserved for the structure view. */
+  raw: string[];
+}
+
+export interface SpaceDocSection {
+  heading: string;
+  /** Line index of the heading in the source, or -1 for a synthesised section. */
+  startLine: number;
+  body: string[];
+}
+
+export interface SpaceDoc {
+  schemaVersion: typeof SPACE_DOC_SCHEMA_VERSION;
+  title: string;
+  /** Everything before the first H2, minus the H1 line. */
+  intro: string;
+  criteria: SpaceDocCriterion[];
+  tasks: SpaceDocTask[];
+  /** Sections that are neither 验收标准 nor 任务, kept in document order. */
+  otherSections: SpaceDocSection[];
+  /** True when a `## 任务` table was found but no row parsed cleanly. */
+  tasksUnparseable: boolean;
+}
+
+export interface SpaceDocParseIssue {
+  line: number;
+  message: string;
+}
+
+export interface SpaceDocParseResult {
+  doc: SpaceDoc;
+  issues: SpaceDocParseIssue[];
+}
+
+function isH1(line: string): boolean {
+  return /^#\s+/.test(line);
+}
+
+function isH2(line: string): boolean {
+  return /^##\s+/.test(line);
+}
+
+function h2Heading(line: string): string {
+  return line.replace(/^##\s+/, "").trim();
+}
+
+/** `# 目标：X` / `# 目标: X` / `# X` all resolve to the title text. */
+export function parseSpaceDocTitle(line: string): string {
+  const text = line.replace(/^#\s+/, "").trim();
+  const stripped = text.replace(/^目标\s*[：:]\s*/, "").trim();
+  return stripped.length > 0 ? stripped : text;
+}
+
+function splitTableRow(line: string): string[] {
+  const trimmed = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+  return trimmed.split("|").map((cell) => cell.trim());
+}
+
+function isTableSeparator(cells: string[]): boolean {
+  return cells.length > 0 && cells.every((cell) => /^:?-{2,}:?$/.test(cell.replace(/\s/g, "")));
+}
+
+function isTableRow(line: string): boolean {
+  const trimmed = line.trim();
+  return trimmed.startsWith("|") && trimmed.endsWith("|") && trimmed.length > 2;
+}
+
+function parseCriterion(line: string, criteriaIndex: number): SpaceDocCriterion | null {
+  const match = /^\s*[-*+]\s+\[([ xX])\]\s*(.*)$/.exec(line);
+  if (!match) return null;
+  const marker = match[1];
+  if (marker === undefined) return null;
+  const text = (match[2] ?? "").trim();
+  if (text.length === 0) return null;
+  return { criteriaIndex, text, done: marker !== " ", marker: marker as " " | "x" | "X" };
+}
+
+const TASK_COLUMN_ALIASES: Record<string, "title" | "status" | "assignee" | "due"> = {
+  "任务": "title",
+  "标题": "title",
+  "task": "title",
+  "title": "title",
+  "状态": "status",
+  "status": "status",
+  "负责岗位": "assignee",
+  "负责": "assignee",
+  "assignee": "assignee",
+  "owner": "assignee",
+  "截止": "due",
+  "截止时间": "due",
+  "due": "due",
+  "due date": "due",
+};
+
+const POSITION_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const CALENDAR_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+
+function isPositionId(value: string): boolean {
+  return value.length > 0 && value.length <= 64 && POSITION_ID_PATTERN.test(value);
+}
+
+function isCalendarDate(value: string): boolean {
+  if (!CALENDAR_DATE_PATTERN.test(value) || value.startsWith("0000-")) return false;
+  const date = new Date(`${value}T00:00:00.000Z`);
+  return !Number.isNaN(date.getTime()) && date.toISOString().slice(0, 10) === value;
+}
+
+function isWorkItemStatus(value: string): value is GoalWorkItemStatus {
+  return (goalWorkItemStatuses as readonly string[]).includes(value);
+}
+
+/** Column index → semantic role, resolved from a header row (or its alias). */
+function resolveColumns(header: string[]): Array<"title" | "status" | "assignee" | "due" | null> {
+  return header.map((cell) => TASK_COLUMN_ALIASES[cell.toLowerCase()] ?? TASK_COLUMN_ALIASES[cell] ?? null);
+}
+
+function parseTaskRow(cells: string[], columns: Array<string | null>, line: number, issues: SpaceDocParseIssue[]): SpaceDocTask | null {
+  const title = cells[0]?.trim() ?? "";
+  if (title.length === 0) {
+    issues.push({ line, message: "task row has an empty title" });
+    return null;
+  }
+
+  const task: SpaceDocTask = {
+    title: title.slice(0, SPACE_DOC_MAX_TITLE_LENGTH),
+    status: "todo",
+    raw: cells,
+  };
+
+  for (let index = 1; index < cells.length; index += 1) {
+    const role = columns[index] ?? null;
+    const value = cells[index]?.trim() ?? "";
+    if (value.length === 0) continue;
+
+    if (role === "status") {
+      if (isWorkItemStatus(value)) task.status = value;
+      else issues.push({ line, message: `unknown task status "${value}"; kept as todo` });
+    } else if (role === "assignee") {
+      if (isPositionId(value)) task.assigneePositionId = value;
+      else issues.push({ line, message: `"${value}" is not a position id; left unassigned` });
+    } else if (role === "due") {
+      if (isCalendarDate(value)) task.dueDate = value;
+      else issues.push({ line, message: `"${value}" is not a YYYY-MM-DD date; ignored` });
+    }
+  }
+  return task;
+}
+
+function parseTasks(section: SpaceDocSection, issues: SpaceDocParseIssue[]): { tasks: SpaceDocTask[]; unparseable: boolean } {
+  const tasks: SpaceDocTask[] = [];
+  let columns: Array<string | null> | null = null;
+  let sawTable = false;
+
+  for (let offset = 0; offset < section.body.length; offset += 1) {
+    const line = section.body[offset] ?? "";
+    const lineNumber = section.startLine + offset + 1;
+
+    if (!isTableRow(line)) continue;
+    const cells = splitTableRow(line);
+
+    if (!sawTable) {
+      // First row is the header, the second (separator) is skipped.
+      if (isTableSeparator(cells)) continue;
+      columns = resolveColumns(cells);
+      sawTable = true;
+      continue;
+    }
+    if (isTableSeparator(cells)) continue;
+
+    const task = parseTaskRow(cells, columns ?? [], lineNumber, issues);
+    if (task) tasks.push(task);
+    if (tasks.length >= SPACE_DOC_MAX_TASKS) break;
+  }
+
+  return { tasks, unparseable: sawTable && tasks.length === 0 };
+}
+
+export function parseSpaceDoc(source: string): SpaceDocParseResult {
+  const issues: SpaceDocParseIssue[] = [];
+  const lines = source.replace(/\r\n?/g, "\n").split("\n");
+
+  let title = "";
+  let introLines: string[] = [];
+  const sections: SpaceDocSection[] = [];
+  let current: SpaceDocSection | null = null;
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+
+    if (isH2(line)) {
+      current = { heading: h2Heading(line), startLine: index, body: [] };
+      sections.push(current);
+      continue;
+    }
+    if (isH1(line)) {
+      if (title.length === 0) title = parseSpaceDocTitle(line);
+      continue;
+    }
+    if (current) current.body.push(line);
+    else introLines.push(line);
+  }
+
+  let criteria: SpaceDocCriterion[] = [];
+  let tasks: SpaceDocTask[] = [];
+  let tasksUnparseable = false;
+  const otherSections: SpaceDocSection[] = [];
+
+  for (const section of sections) {
+    if (section.heading === SPACE_DOC_CRITERIA_HEADING) {
+      for (let offset = 0; offset < section.body.length; offset += 1) {
+        if (criteria.length >= SPACE_DOC_MAX_CRITERIA) break;
+        const criterion = parseCriterion(section.body[offset] ?? "", criteria.length);
+        if (criterion) criteria.push(criterion);
+      }
+    } else if (section.heading === SPACE_DOC_TASKS_HEADING) {
+      const parsed = parseTasks(section, issues);
+      tasks = parsed.tasks;
+      tasksUnparseable = parsed.unparseable;
+    } else {
+      otherSections.push(section);
+    }
+  }
+
+  return {
+    doc: {
+      schemaVersion: SPACE_DOC_SCHEMA_VERSION,
+      title,
+      intro: introLines.join("\n").trim(),
+      criteria,
+      tasks,
+      otherSections,
+      tasksUnparseable,
+    },
+    issues,
+  };
+}
+
+/**
+ * Rewrite only the two structured sections, leaving every other byte of the
+ * document untouched. This is what makes the structure view safe to edit:
+ * prose the parser did not understand is never regenerated from a lossy model.
+ */
+export function renderSpaceDoc(doc: SpaceDoc, source: string): string {
+  const eol = source.includes("\r\n") ? "\r\n" : "\n";
+  const criterionLines = doc.criteria.map(
+    (criterion) => `- [${criterion.done ? "x" : " "}] ${criterion.text}`,
+  );
+  const taskLines = [
+    "| 任务 | 状态 | 负责岗位 | 截止 |",
+    "| --- | --- | --- | --- |",
+    ...doc.tasks.map((task) =>
+      [
+        task.title,
+        task.status,
+        task.assigneePositionId ?? "",
+        task.dueDate ?? "",
+      ].join(" | ").replace(/^/, "| ").replace(/$/, " |"),
+    ),
+  ];
+
+  const replacements = new Map<string, string[]>([
+    [SPACE_DOC_CRITERIA_HEADING, criterionLines],
+    [SPACE_DOC_TASKS_HEADING, taskLines],
+  ]);
+  // Keep complete source lines, including their individual line endings.
+  // Only a structured section's nonblank body is regenerated.
+  const chunks = source.match(/[^\r\n]*(?:\r\n|\r|\n|$)/g)?.filter((line) => line.length > 0) ?? [];
+  const textOf = (line: string) => line.replace(/(?:\r\n|\r|\n)$/, "");
+  const seen = new Set<string>();
+  let out = "";
+  let index = 0;
+  while (index < chunks.length) {
+    const chunk = chunks[index] ?? "";
+    const line = textOf(chunk);
+    const heading = isH2(line) ? h2Heading(line) : "";
+    const replacement = replacements.get(heading);
+    if (!replacement) {
+      out += chunk;
+      index += 1;
+      continue;
+    }
+    seen.add(heading);
+    out += chunk;
+    index += 1;
+    const start = index;
+    while (index < chunks.length && !isH2(textOf(chunks[index] ?? ""))) index += 1;
+    let bodyStart = start;
+    let bodyEnd = index;
+    while (bodyStart < bodyEnd && textOf(chunks[bodyStart] ?? "").trim() === "") bodyStart += 1;
+    while (bodyEnd > bodyStart && textOf(chunks[bodyEnd - 1] ?? "").trim() === "") bodyEnd -= 1;
+    if (replacement.length > 0 && !/[\r\n]$/.test(chunk)) out += eol;
+    out += chunks.slice(start, bodyStart).join("");
+    out += replacement.join(eol);
+    // Preserve the last content line's terminator and every separator byte.
+    const terminator = (chunks[bodyEnd - 1] ?? "").match(/(?:\r\n|\r|\n)$/)?.[0] ?? "";
+    if (replacement.length > 0) out += bodyEnd > bodyStart ? terminator : (index < chunks.length ? eol : "");
+    out += chunks.slice(bodyEnd, index).join("");
+  }
+  for (const [heading, replacement] of replacements) {
+    if (seen.has(heading) || (heading === SPACE_DOC_CRITERIA_HEADING ? doc.criteria.length === 0 : doc.tasks.length === 0)) continue;
+    if (out.length > 0) {
+      if (!/[\r\n]$/.test(out)) out += eol;
+      if (!out.endsWith(eol + eol)) out += eol;
+    }
+    out += `## ${heading}${eol}${replacement.join(eol)}${eol}`;
+  }
+  return out;
+}
+
+/** Derive the `acceptance.v1` criteria count a space exposes to the gate. */
+export function spaceDocCriteriaCount(doc: SpaceDoc): number {
+  return doc.criteria.length;
+}
diff --git a/packages/ui/src/locales/en.ts b/packages/ui/src/locales/en.ts
index f0f8b282..f90e73e2 100644
--- a/packages/ui/src/locales/en.ts
+++ b/packages/ui/src/locales/en.ts
@@ -329,6 +329,7 @@ export const enCatalog: Record<string, string> = {
   "rail.collaboration": "Collaborate",
   "rail.projects": "Projects",
   "rail.inbox": "Inbox",
+  "rail.space": "Spaces",
   "nav.collaboration": "Collaboration mode",
   "nav.employee": "Employee views",
   "nav.organization": "Organization views",
@@ -1762,6 +1763,44 @@ export const enCatalog: Record<string, string> = {
   "credentials.failed": "The credential change could not be saved. Unlock your system keychain and retry.",
   "credentials.saved": "Saved securely. Applies on the next control-plane start.",
   "credentials.cleared": "Saved value cleared. Applies on the next control-plane start.",
+
+  // Space (专项作战人机协作区)
+  "space.untitled": "Untitled space",
+  "space.rootHint": "A space is a folder inside a workspace",
+  "space.emptyWorkspace": "Open a workspace before entering a space.",
+  "space.filesTitle": "Files",
+  "space.spineFile": "goal.md",
+  "space.spineTag": "Spine",
+  "space.participantsTitle": "Participants",
+  "space.ownerTag": "Owner",
+  "space.view.document": "Document",
+  "space.view.structure": "Structure",
+  "space.error.read": "Could not read {path}.",
+  "space.error.write": "Could not write {path}.",
+  "space.structure.criteria": "Acceptance criteria",
+  "space.structure.noCriteria": "This document has no acceptance criteria section yet.",
+  "space.structure.board": "Task board",
+  "space.structure.unparseable": "A task table was found but no row parsed. Check the header row.",
+  "space.structure.lastDecision": "Last acceptance",
+  "space.decision.accepted": "Accepted",
+  "space.decision.rejected": "Rejected",
+  "space.status.todo": "To do",
+  "space.status.in_progress": "In progress",
+  "space.status.blocked": "Blocked",
+  "space.status.review": "In review",
+  "space.status.done": "Done",
+  "space.gate.title": "Acceptance",
+  "space.gate.empty": "This document has no criteria to accept.",
+  "space.gate.progress": "{done}/{total} confirmed",
+  "space.gate.remaining": "{count} left unconfirmed; confirm them before accepting.",
+  "space.gate.evidencePlaceholder": "Evidence path (optional)",
+  "space.gate.notePlaceholder": "Reason for rejection / note",
+  "space.gate.accept": "Accept",
+  "space.gate.reject": "Reject",
+  "space.gate.confirmAccept": "Accept this deliverable? Accepting counts it as done.",
+  "space.gate.confirmReject": "Reject it? Make sure a reason is written.",
+  "space.gate.confirm": "Confirm",
+  "space.gate.cancel": "Cancel",
   "goals.lede": "Track objectives, acceptance criteria, execution branches and responsible roles.",
   "goals.currentGoals": "Current project goals",
   "goals.branchCount": "{count} execution branches",
diff --git a/packages/ui/src/locales/zh.ts b/packages/ui/src/locales/zh.ts
index f6c5d24b..1477e833 100644
--- a/packages/ui/src/locales/zh.ts
+++ b/packages/ui/src/locales/zh.ts
@@ -332,6 +332,7 @@ export const zhCatalog: Record<string, string> = {
   "rail.collaboration": "协作",
   "rail.projects": "项目",
   "rail.inbox": "收件箱",
+  "rail.space": "协作区",
   "nav.collaboration": "协作方式",
   "nav.employee": "员工视图",
   "nav.organization": "组织视图",
@@ -1765,6 +1766,44 @@ export const zhCatalog: Record<string, string> = {
   "credentials.failed": "无法保存凭据更改。请解锁系统密钥环后重试。",
   "credentials.saved": "已安全保存。将在控制面下次启动时生效。",
   "credentials.cleared": "已清除保存的值。将在控制面下次启动时生效。",
+
+  // 协作区（专项作战人机协作区）
+  "space.untitled": "未命名协作区",
+  "space.rootHint": "协作区 = 工作区里的一个文件夹",
+  "space.emptyWorkspace": "先打开一个工作区，再进入协作区。",
+  "space.filesTitle": "文件",
+  "space.spineFile": "目标.md",
+  "space.spineTag": "主线",
+  "space.participantsTitle": "参与者",
+  "space.ownerTag": "负责人",
+  "space.view.document": "文档",
+  "space.view.structure": "结构",
+  "space.error.read": "无法读取 {path}。",
+  "space.error.write": "无法写入 {path}。",
+  "space.structure.criteria": "验收标准",
+  "space.structure.noCriteria": "这份文档还没有「## 验收标准」小节。",
+  "space.structure.board": "任务看板",
+  "space.structure.unparseable": "检测到「## 任务」表格，但没有一行能解析。请检查表头。",
+  "space.structure.lastDecision": "最近一次验收",
+  "space.decision.accepted": "已验收通过",
+  "space.decision.rejected": "已打回",
+  "space.status.todo": "待办",
+  "space.status.in_progress": "进行中",
+  "space.status.blocked": "受阻",
+  "space.status.review": "待验收",
+  "space.status.done": "已完成",
+  "space.gate.title": "验收",
+  "space.gate.empty": "这份文档没有可验收的标准。",
+  "space.gate.progress": "{done}/{total} 项已确认",
+  "space.gate.remaining": "还有 {count} 项未确认，勾选后才能验收通过。",
+  "space.gate.evidencePlaceholder": "证据路径（可选）",
+  "space.gate.notePlaceholder": "打回原因 / 备注",
+  "space.gate.accept": "验收通过",
+  "space.gate.reject": "打回",
+  "space.gate.confirmAccept": "确认通过这份产出？通过后任务计入完成度。",
+  "space.gate.confirmReject": "确认打回？请确保已填写原因。",
+  "space.gate.confirm": "确认",
+  "space.gate.cancel": "取消",
   "goals.lede": "追踪目标、验收标准、执行分支与责任岗位。",
   "goals.currentGoals": "当前项目目标",
   "goals.branchCount": "{count} 个执行分支",