From b4e7cca6d078362d239bb4bbe3bfd7453bb83f06 Mon Sep 17 00:00:00 2001
From: axb <qindi@staff.weibo.com>
Date: Tue, 4 Aug 2026 17:31:47 +0800
Subject: [PATCH 1/7] feat(project-space): link local tasks to project spaces

---
 backend/app/api/endpoints/cloud_projects.py   |  33 ++
 backend/app/api/endpoints/deliveries.py       | 106 +++++
 backend/app/schemas/cloud_project.py          |   4 +
 backend/app/schemas/delivery.py               |  33 ++
 .../app/services/cloud_projects/service.py    |  63 ++-
 backend/app/services/loop_items/service.py    |  18 +
 backend/tests/api/test_cloud_projects_api.py  |  84 ++++
 docs/en/wework/projects.md                    |   8 +
 docs/en/wework/tasks.md                       |   6 +
 docs/zh/wework/projects.md                    |   8 +
 docs/zh/wework/tasks.md                       |   6 +
 wework/e2e/desktop/task-flow.e2e.mjs          |  89 ++++
 wework/src/api/deliveries.ts                  |  68 ++-
 wework/src/api/local/localDelivery.test.ts    | 162 +++++++
 wework/src/api/local/localDelivery.ts         | 175 +++++++-
 wework/src/components/chat/ChatInput.tsx      |   3 +
 .../chat/composer/AddContextMenu.test.tsx     |  59 +++
 .../chat/composer/AddContextMenu.tsx          | 225 +++++++---
 .../chat/composer/ComposerToolbar.tsx         |  11 +
 .../chat/composer/ProjectChatComposer.tsx     |   5 +
 .../components/layout/DesktopSidebar.test.tsx |  52 +++
 .../src/components/layout/DesktopSidebar.tsx  |   4 +
 .../layout/DesktopWorkbenchLayout.tsx         |   6 +
 .../layout/DesktopWorkbenchMain.tsx           | 411 +++++++++++++++---
 .../projects/LocalProjectEditDialog.test.tsx  |  64 ++-
 .../projects/LocalProjectEditDialog.tsx       |  97 ++++-
 .../features/todo/CloudProjectManageView.tsx  | 161 ++++++-
 .../src/features/todo/CloudTodoWorkspace.tsx  |   1 +
 .../features/todo/TodoBindingPicker.test.tsx  | 101 ++++-
 .../src/features/todo/TodoBindingPicker.tsx   | 144 ++++--
 .../todo/projectSpaceLocalBindings.test.ts    | 113 +++++
 .../todo/projectSpaceLocalBindings.ts         | 166 +++++++
 .../features/workbench/WorkbenchProvider.tsx  |  36 ++
 wework/src/i18n/locales/en/common.json        |  19 +
 wework/src/i18n/locales/zh-CN/common.json     |  19 +
 35 files changed, 2346 insertions(+), 214 deletions(-)
 create mode 100644 wework/src/features/todo/projectSpaceLocalBindings.test.ts
 create mode 100644 wework/src/features/todo/projectSpaceLocalBindings.ts

diff --git a/backend/app/api/endpoints/cloud_projects.py b/backend/app/api/endpoints/cloud_projects.py
index 3d71c8d1b3..e6c28418d7 100644
--- a/backend/app/api/endpoints/cloud_projects.py
+++ b/backend/app/api/endpoints/cloud_projects.py
@@ -29,6 +29,7 @@
     CloudProjectUpdate,
     LocalBindingCreate,
     LocalBindingResponse,
+    LocalBindingUpdate,
 )
 from app.services.cloud_files import cloud_file_service
 from app.services.cloud_projects import cloud_project_service
@@ -133,6 +134,38 @@ def list_local_bindings(
     return [LocalBindingResponse.model_validate(binding) for binding in bindings]
 
 
+@router.patch(
+    "/{project_id}/local-bindings/{binding_id}",
+    response_model=LocalBindingResponse,
+)
+def update_local_binding(
+    project_id: int,
+    binding_id: int,
+    values: LocalBindingUpdate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> LocalBindingResponse:
+    binding = cloud_project_service.update_local_binding(
+        db, project_id, binding_id, current_user.id, values
+    )
+    return LocalBindingResponse.model_validate(binding)
+
+
+@router.delete(
+    "/{project_id}/local-bindings/{binding_id}",
+    status_code=status.HTTP_204_NO_CONTENT,
+)
+def delete_local_binding(
+    project_id: int,
+    binding_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> None:
+    cloud_project_service.delete_local_binding(
+        db, project_id, binding_id, current_user.id
+    )
+
+
 @router.get("/{project_id}/members", response_model=list[CloudProjectMemberResponse])
 def list_cloud_project_members(
     project_id: int,
diff --git a/backend/app/api/endpoints/deliveries.py b/backend/app/api/endpoints/deliveries.py
index a2965aaa65..0fdd54ff4b 100644
--- a/backend/app/api/endpoints/deliveries.py
+++ b/backend/app/api/endpoints/deliveries.py
@@ -45,6 +45,9 @@
     LoopItemUpdate,
     MyWorkItemResponse,
     MyWorkListResponse,
+    RuntimeTaskTrack,
+    RuntimeTaskTrackingStatusUpdate,
+    RuntimeTaskTrackResponse,
 )
 from app.services.cloud_projects import cloud_project_service
 from app.services.delivery import delivery_service
@@ -194,6 +197,109 @@ def bind_cloud_project_task(
     return LoopItemTaskBindingResponse.model_validate(binding)
 
 
+def _tracked_item_response(
+    db: Session,
+    item_id: str,
+    current_user: User,
+) -> LoopItemResponse:
+    if external_loop_item_provider.is_external_item(db, item_id):
+        return LoopItemResponse.model_validate(
+            external_loop_item_provider.get(db, item_id, current_user.id)
+        )
+    item = loop_item_service.get(db, item_id, current_user.id)
+    return _loop_item_response(db, item, current_user)
+
+
+@router.post(
+    "/cloud-projects/{project_id}/tasks/track",
+    response_model=RuntimeTaskTrackResponse,
+    status_code=status.HTTP_201_CREATED,
+)
+def track_cloud_project_task(
+    project_id: int,
+    values: RuntimeTaskTrack,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> RuntimeTaskTrackResponse:
+    existing = loop_item_service.find_active_task_binding(
+        db, current_user.id, values.device_id, values.task_id
+    )
+    if existing is not None and existing.loop_item_id:
+        if str(existing.cloud_project_id) != str(project_id):
+            raise HTTPException(
+                status.HTTP_409_CONFLICT,
+                "Runtime task is already tracked by another project",
+            )
+        return RuntimeTaskTrackResponse(
+            item=_tracked_item_response(db, existing.loop_item_id, current_user),
+            binding=LoopItemTaskBindingResponse.model_validate(existing),
+        )
+
+    project = cloud_project_service.get(db, project_id, current_user.id)
+    created = loop_item_provider_router.create(
+        db,
+        project,
+        current_user,
+        LoopItemCreate(
+            title=values.task_title,
+            description=values.description,
+            status="in_progress",
+        ),
+    )
+    item_id = str(created.values["id"])
+    external_loop_item_provider.ensure_shadow(db, item_id, current_user.id)
+    binding = loop_item_service.bind_task(
+        db, item_id, values.binding(), current_user.id
+    )
+    return RuntimeTaskTrackResponse(
+        item=LoopItemResponse.model_validate(created.values),
+        binding=LoopItemTaskBindingResponse.model_validate(binding),
+    )
+
+
+@router.patch(
+    "/runtime-tasks/cloud-context/tracking-status",
+    response_model=LoopItemResponse | None,
+)
+def update_runtime_task_tracking_status(
+    values: RuntimeTaskTrackingStatusUpdate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> LoopItemResponse | None:
+    binding = loop_item_service.find_active_task_binding(
+        db, current_user.id, values.device_id, values.task_id
+    )
+    if binding is None or not binding.loop_item_id:
+        return None
+    item = _tracked_item_response(db, binding.loop_item_id, current_user)
+    next_status: str | None = None
+    if values.execution_status == "running" and item.status in {
+        "inbox",
+        "pending",
+        "in_review",
+    }:
+        next_status = "in_progress"
+    elif values.execution_status == "succeeded" and item.status == "in_progress":
+        next_status = "in_review"
+    if next_status is None:
+        return item
+    if external_loop_item_provider.is_external_item(db, item.id):
+        updated = external_loop_item_provider.update(
+            db,
+            item.id,
+            current_user.id,
+            LoopItemUpdate(version=item.version, status=next_status),
+        )
+        return LoopItemResponse.model_validate(updated)
+    stored = loop_item_service.update(
+        db,
+        item.id,
+        current_user.id,
+        LoopItemUpdate(version=item.version, status=next_status),
+    )
+    return _loop_item_response(db, stored, current_user)
+
+
 @router.delete("/runtime-tasks/cloud-context", status_code=status.HTTP_204_NO_CONTENT)
 def unbind_runtime_task_cloud_context(
     values: LoopItemTaskBind,
diff --git a/backend/app/schemas/cloud_project.py b/backend/app/schemas/cloud_project.py
index 56711fbb7d..001b45ab00 100644
--- a/backend/app/schemas/cloud_project.py
+++ b/backend/app/schemas/cloud_project.py
@@ -228,6 +228,10 @@ class LocalBindingCreate(BaseModel):
     is_default: bool = False
 
 
+class LocalBindingUpdate(BaseModel):
+    is_default: bool | None = None
+
+
 class LocalBindingResponse(BaseModel):
     model_config = ConfigDict(from_attributes=True)
 
diff --git a/backend/app/schemas/delivery.py b/backend/app/schemas/delivery.py
index dd166eeb1b..2888ff82e7 100644
--- a/backend/app/schemas/delivery.py
+++ b/backend/app/schemas/delivery.py
@@ -234,6 +234,39 @@ def normalize_unlinked_at(cls, value: object) -> object:
         return LoopItemResponse.normalize_unset_datetime(value)
 
 
+class RuntimeTaskTrack(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    device_id: str = Field(alias="deviceId", min_length=1, max_length=100)
+    task_id: str = Field(alias="taskId", min_length=1, max_length=255)
+    task_title: str = Field(alias="taskTitle", min_length=1, max_length=255)
+    description: str = ""
+    backend_task_id: int | None = Field(default=None, alias="backendTaskId")
+
+    def binding(self) -> LoopItemTaskBind:
+        return LoopItemTaskBind(
+            deviceId=self.device_id,
+            taskId=self.task_id,
+            taskTitle=self.task_title,
+            backendTaskId=self.backend_task_id,
+        )
+
+
+class RuntimeTaskTrackingStatusUpdate(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    device_id: str = Field(alias="deviceId", min_length=1, max_length=100)
+    task_id: str = Field(alias="taskId", min_length=1, max_length=255)
+    execution_status: Literal["running", "succeeded", "failed", "cancelled"] = Field(
+        alias="executionStatus"
+    )
+
+
+class RuntimeTaskTrackResponse(BaseModel):
+    item: LoopItemResponse
+    binding: LoopItemTaskBindingResponse
+
+
 class CloudTaskContextResponse(LoopItemTaskBindingResponse):
     project: CloudProjectResponse
     loop_item: LoopItemResponse | None = None
diff --git a/backend/app/services/cloud_projects/service.py b/backend/app/services/cloud_projects/service.py
index de82068703..f304200cd1 100644
--- a/backend/app/services/cloud_projects/service.py
+++ b/backend/app/services/cloud_projects/service.py
@@ -27,6 +27,7 @@
     CloudProjectMemberUpdate,
     CloudProjectUpdate,
     LocalBindingCreate,
+    LocalBindingUpdate,
     default_board_statuses,
     normalize_provider_config,
 )
@@ -291,14 +292,16 @@ def add_local_binding(
             raise HTTPException(status.HTTP_404_NOT_FOUND, "Local project not found")
         if values.is_default:
             db.query(CloudProjectLocalBinding).filter(
-                CloudProjectLocalBinding.cloud_project_id == cloud_project_id,
                 CloudProjectLocalBinding.user_id == user_id,
+                CloudProjectLocalBinding.local_project_id == values.local_project_id,
                 CloudProjectLocalBinding.device_id == values.device_id,
             ).update({"is_default": False})
         binding = CloudProjectLocalBinding(
             cloud_project_id=cloud_project_id,
             user_id=user_id,
-            **values.model_dump(),
+            local_project_id=values.local_project_id,
+            device_id=values.device_id,
+            is_default=values.is_default,
         )
         db.add(binding)
         try:
@@ -311,6 +314,62 @@ def add_local_binding(
         db.refresh(binding)
         return binding
 
+    def update_local_binding(
+        self,
+        db: Session,
+        cloud_project_id: int,
+        binding_id: int,
+        user_id: int,
+        values: LocalBindingUpdate,
+    ) -> CloudProjectLocalBinding:
+        require_cloud_project_role(db, cloud_project_id, user_id, BaseRole.Developer)
+        binding = (
+            db.query(CloudProjectLocalBinding)
+            .filter(
+                CloudProjectLocalBinding.id == binding_id,
+                CloudProjectLocalBinding.cloud_project_id == cloud_project_id,
+                CloudProjectLocalBinding.user_id == user_id,
+            )
+            .with_for_update()
+            .first()
+        )
+        if binding is None:
+            raise HTTPException(status.HTTP_404_NOT_FOUND, "Local binding not found")
+        if values.is_default is True:
+            db.query(CloudProjectLocalBinding).filter(
+                CloudProjectLocalBinding.user_id == user_id,
+                CloudProjectLocalBinding.local_project_id == binding.local_project_id,
+                CloudProjectLocalBinding.device_id == binding.device_id,
+                CloudProjectLocalBinding.id != binding.id,
+            ).update({"is_default": False})
+        if values.is_default is not None:
+            binding.is_default = values.is_default
+        db.commit()
+        db.refresh(binding)
+        return binding
+
+    def delete_local_binding(
+        self,
+        db: Session,
+        cloud_project_id: int,
+        binding_id: int,
+        user_id: int,
+    ) -> None:
+        require_cloud_project_role(db, cloud_project_id, user_id, BaseRole.Developer)
+        binding = (
+            db.query(CloudProjectLocalBinding)
+            .filter(
+                CloudProjectLocalBinding.id == binding_id,
+                CloudProjectLocalBinding.cloud_project_id == cloud_project_id,
+                CloudProjectLocalBinding.user_id == user_id,
+            )
+            .first()
+        )
+        if binding is None:
+            raise HTTPException(status.HTTP_404_NOT_FOUND, "Local binding not found")
+        db.delete(binding)
+        db.commit()
+
     def list_local_bindings(
         self, db: Session, cloud_project_id: int, user_id: int
     ) -> list[CloudProjectLocalBinding]:
diff --git a/backend/app/services/loop_items/service.py b/backend/app/services/loop_items/service.py
index 31eff9a567..c91c1b3429 100644
--- a/backend/app/services/loop_items/service.py
+++ b/backend/app/services/loop_items/service.py
@@ -785,6 +785,24 @@ def find_cloud_context(
         item = db.get(LoopItem, binding.loop_item_id) if binding.loop_item_id else None
         return binding, project, item
 
+    def find_active_task_binding(
+        self,
+        db: Session,
+        user_id: int,
+        device_id: str,
+        task_id: str,
+    ) -> LoopItemTaskBinding | None:
+        return (
+            db.query(LoopItemTaskBinding)
+            .filter(
+                LoopItemTaskBinding.task_user_id == user_id,
+                LoopItemTaskBinding.device_id == device_id,
+                LoopItemTaskBinding.task_id == task_id,
+                loop_datetime_is_unset(LoopItemTaskBinding.unlinked_at),
+            )
+            .first()
+        )
+
     def unbind_cloud_context(
         self, db: Session, values: LoopItemTaskBind, user_id: int
     ) -> None:
diff --git a/backend/tests/api/test_cloud_projects_api.py b/backend/tests/api/test_cloud_projects_api.py
index 7fadd6006d..e66beca7a8 100644
--- a/backend/tests/api/test_cloud_projects_api.py
+++ b/backend/tests/api/test_cloud_projects_api.py
@@ -833,6 +833,90 @@ def test_cloud_project_can_link_local_workspace(
     assert bindings.status_code == 200
     assert bindings.json()[0]["device_id"] == "desktop-1"
 
+    second_project = test_client.post(
+        "/api/v1/cloud-projects",
+        headers=_auth(test_token),
+        json={"project_key": "second", "name": "Second collaboration"},
+    ).json()
+    second_binding = test_client.post(
+        f"/api/v1/cloud-projects/{second_project['id']}/local-bindings",
+        headers=_auth(test_token),
+        json={
+            "local_project_id": local_project.id,
+            "device_id": "desktop-1",
+            "is_default": True,
+        },
+    )
+    assert second_binding.status_code == 201
+    first_bindings = test_client.get(
+        f"/api/v1/cloud-projects/{cloud_project['id']}/local-bindings",
+        headers=_auth(test_token),
+    )
+    assert first_bindings.json()[0]["is_default"] is False
+    assert second_binding.json()["is_default"] is True
+    removed = test_client.delete(
+        (
+            f"/api/v1/cloud-projects/{second_project['id']}/local-bindings/"
+            f"{second_binding.json()['id']}"
+        ),
+        headers=_auth(test_token),
+    )
+    assert removed.status_code == 204
+    assert (
+        test_client.get(
+            f"/api/v1/cloud-projects/{second_project['id']}/local-bindings",
+            headers=_auth(test_token),
+        ).json()
+        == []
+    )
+
+
+def test_explicit_project_selection_tracks_runtime_task_idempotently(
+    test_client: TestClient,
+    test_db: Session,
+    test_user: User,
+    test_token: str,
+) -> None:
+    project = test_client.post(
+        "/api/v1/cloud-projects",
+        headers=_auth(test_token),
+        json={"project_key": "track", "name": "Tracked project"},
+    ).json()
+    payload = {
+        "deviceId": "desktop-1",
+        "taskId": "runtime-task-1",
+        "taskTitle": "Implement explicit task tracking",
+        "description": "Created from the Wework task composer.",
+    }
+    tracked = test_client.post(
+        f"/api/v1/cloud-projects/{project['id']}/tasks/track",
+        headers=_auth(test_token),
+        json=payload,
+    )
+    assert tracked.status_code == 201
+    assert tracked.json()["item"]["status"] == "in_progress"
+    item_id = tracked.json()["item"]["id"]
+
+    retried = test_client.post(
+        f"/api/v1/cloud-projects/{project['id']}/tasks/track",
+        headers=_auth(test_token),
+        json=payload,
+    )
+    assert retried.status_code == 201
+    assert retried.json()["item"]["id"] == item_id
+
+    reviewed = test_client.patch(
+        "/api/v1/runtime-tasks/cloud-context/tracking-status",
+        headers=_auth(test_token),
+        json={
+            "deviceId": "desktop-1",
+            "taskId": "runtime-task-1",
+            "executionStatus": "succeeded",
+        },
+    )
+    assert reviewed.status_code == 200
+    assert reviewed.json()["status"] == "in_review"
+
 
 def test_todo_lifecycle_and_multiple_local_tasks(
     test_client: TestClient,
diff --git a/docs/en/wework/projects.md b/docs/en/wework/projects.md
index 6557c40b7f..ea84327776 100644
--- a/docs/en/wework/projects.md
+++ b/docs/en/wework/projects.md
@@ -16,6 +16,14 @@ If a connected cloud device and the current local Wework executor refer to the s
 
 To create a Git project, select a device, repository, default branch, and destination. If repositories are unavailable, check the Git connection and token permissions in Settings.
 
+## Link a project space
+
+After enabling **Settings → General → Experimental features**, open **Edit project** for a local project and configure **Automatically join project space**. A local project is the code and execution workspace, while a project space is the task-tracking and collaboration board. Linking them does not move or copy project files, and neither resource replaces the other.
+
+New conversations started in that local project inherit the selected project space. Before the first message is sent, the composer shows **Add to board · Project space name**. Sending creates a task in the selected local or cloud project space and links the conversation. Repeated synchronization of the same conversation does not create duplicate board tasks.
+
+Linking local projects from the project-space management page only controls where that space is available. Automatic joining remains a per-local-project setting. Use the composer's **+** menu to select, replace, or remove the project space for an individual conversation before sending.
+
 ## Create a project from the composer
 
 Open the project selector above a new-conversation composer to create a blank project or add an existing folder. After creation, the project appears in both the sidebar and the composer and immediately becomes the workspace for the current new conversation.
diff --git a/docs/en/wework/tasks.md b/docs/en/wework/tasks.md
index 060071e615..8339e3ff6f 100644
--- a/docs/en/wework/tasks.md
+++ b/docs/en/wework/tasks.md
@@ -12,6 +12,12 @@ Add files, images, code locations, or an Appshot to the composer when they clari
 
 After you send a local image, Wework keeps its preview in the message. The image remains available when you reopen Wework or return to the conversation after switching away. If the original local file is deleted, the preview cannot be restored.
 
+## Add a conversation to a project-space board
+
+After enabling Experimental features, open the composer's **+** menu and select **Project space**. The selected destination appears as **Add to board · Project space name** below the composer so you can confirm it before sending. Sending the first message creates the corresponding board task and links the conversation. A project space inherited from the local-project automatic-join setting appears through the same control.
+
+For an existing task, open the right-side **Environment** panel and select **Link project space**. You can link the current project or task to a local or cloud project space, or quickly create a task in that space. Local-space operations remain on the current device; cloud-space operations use shared cloud data.
+
 ## Models and devices
 
 The model provides the AI capability; the device determines where files and commands run. Local models run on the local device. Cloud models and devices require a Wegent connection.
diff --git a/docs/zh/wework/projects.md b/docs/zh/wework/projects.md
index 5d475f1c29..a34b7026ab 100644
--- a/docs/zh/wework/projects.md
+++ b/docs/zh/wework/projects.md
@@ -16,6 +16,14 @@ sidebar_position: 3
 
 从项目列表移除本机项目不会删除磁盘目录。
 
+## 关联项目空间
+
+开启 **设置 → 通用 → 实验性功能** 后，可以在本地项目的 **编辑项目** 对话框中设置 **自动加入项目空间**。本地项目是代码与执行工作区，项目空间是任务跟进与协作看板；两者是关联关系，不会互相替代，也不会移动或复制项目文件。
+
+为本地项目选择项目空间后，从该项目开启的新对话会继承这个默认值。发送第一条消息前，输入框底部会显示 **加入看板 · 项目空间名称**；发送后，Wework 会在对应的本地或云端项目空间中创建任务并关联当前对话。重复同步同一对话不会创建重复看板任务。
+
+项目空间管理页中的本地项目关联只决定该空间可以在哪些本地项目中使用。是否自动加入仍由每个本地项目的设置决定；也可以在发送前通过输入框的 **+** 菜单为当前对话临时选择、切换或取消项目空间。
+
 ## 从输入区创建项目
 
 在新对话输入框上方打开项目选择器，可以新建空白项目或添加现有目录。创建完成后，新项目会同时出现在左侧项目列表和输入框上方，并立即成为当前新对话的项目工作区。
diff --git a/docs/zh/wework/tasks.md b/docs/zh/wework/tasks.md
index c040f9b612..03f9e5c88b 100644
--- a/docs/zh/wework/tasks.md
+++ b/docs/zh/wework/tasks.md
@@ -26,6 +26,12 @@ sidebar_position: 4
 
 输入 `/` 可以选择可用 Skill。插件安装后，其 Skills、命令或工具会出现在对应任务能力中。
 
+## 将对话加入项目空间看板
+
+开启实验性功能后，可以通过输入框的 **+** 菜单选择 **项目空间**。选中的空间会以 **加入看板 · 项目空间名称** 显示在输入框底部，让你在发送前确认本次对话将进入哪个看板。发送第一条消息后，Wework 会创建对应看板任务并关联当前对话；本地项目设置的自动加入空间也会通过同一控件明确显示。
+
+对于已经启动的任务，可以在右侧 **环境** 面板中选择 **关联项目空间**，将当前项目或当前任务关联到本地、云端项目空间，或者在空间中快速新建任务。选择本地空间时操作保存在当前设备；选择云端空间时使用云端协作数据。
+
 ## 选择模型和设备
 
 模型决定任务使用的 AI 能力，设备决定代码和命令在哪里执行。本地模型只能用于本机设备；云端模型和设备需要先连接 Wegent。
diff --git a/wework/e2e/desktop/task-flow.e2e.mjs b/wework/e2e/desktop/task-flow.e2e.mjs
index ca6f8332d6..9b9b5e02e1 100644
--- a/wework/e2e/desktop/task-flow.e2e.mjs
+++ b/wework/e2e/desktop/task-flow.e2e.mjs
@@ -3461,6 +3461,85 @@ async function verifyWorkspaceDocumentTabs(control) {
   await captureVerificationScreenshot(control, 'workspace-tabs-02-task-restored.png')
 }
 
+async function configureDefaultProjectSpaceAssociation(control, localProjectId) {
+  const taskTabTestId = await control.command(
+    'getAttribute',
+    '[data-tab-kind="task"][aria-selected="true"]',
+    { value: 'data-testid' }
+  )
+  assert.ok(taskTabTestId, 'The active task tab identity was unavailable before association setup')
+
+  await control.command('click', '[data-testid^="workspace-tab-select-board-"]')
+  await control.command('waitFor', '[data-testid="cloud-todo-workspace"]', {
+    timeoutMs: WORKBENCH_READY_TIMEOUT_MS,
+  })
+  const boardSnapshot = JSON.parse(await control.command('snapshot', 'body'))
+  const createSelector = boardSnapshot.testIds.includes('cloud-projects-home-create')
+    ? '[data-testid="cloud-projects-home-create"]'
+    : '[data-testid="cloud-project-add"]'
+  await control.command('click', createSelector)
+  await control.command('waitFor', '[data-testid="cloud-project-name"]', {
+    timeoutMs: DEFAULT_STEP_TIMEOUT_MS,
+  })
+  await control.command('fill', '[data-testid="cloud-project-name"]', {
+    value: 'Task Follow-up Board',
+  })
+  await control.command('click', '[data-testid="cloud-project-location-local"]')
+  await control.command('click', '[data-testid="cloud-project-task-provider-local"]')
+  await control.command('clickWhenEnabled', '[data-testid="cloud-project-create-confirm"]')
+  await control.command('waitFor', '[data-testid="cloud-project-manage-view"]', {
+    timeoutMs: DEFAULT_STEP_TIMEOUT_MS,
+  })
+  await captureVerificationScreenshot(control, 'project-space-created-for-local-project.png')
+  await control.command('click', `[data-testid="${taskTabTestId}"]`)
+  await control.command('waitFor', ACTIVE_COMPOSER_SELECTOR, {
+    timeoutMs: WORKBENCH_READY_TIMEOUT_MS,
+  })
+  await control.command('click', `[data-testid="project-menu-${localProjectId}"]`)
+  await control.command('click', `[data-testid="edit-project-${localProjectId}"]`)
+  await control.command('waitFor', '[data-testid="local-project-edit-dialog"]', {
+    timeoutMs: DEFAULT_STEP_TIMEOUT_MS,
+  })
+  await control.command('select', '[data-testid="local-project-auto-join-space-select"]', {
+    by: 'label',
+    value: 'Task Follow-up Board',
+  })
+  await control.command('clickWhenEnabled', '[data-testid="save-local-project-button"]')
+  await control.command('waitFor', '[data-testid="project-space-context-pill"]', {
+    text: '加入看板 · Task Follow-up Board',
+    timeoutMs: DEFAULT_STEP_TIMEOUT_MS,
+  })
+  await control.command('click', '[data-testid="add-context-button"]')
+  await control.command('waitFor', '[data-testid="add-project-space-context-button"]', {
+    text: 'Task Follow-up Board',
+    timeoutMs: DEFAULT_STEP_TIMEOUT_MS,
+  })
+  await control.command('click', '[data-testid="add-project-space-context-button"]')
+  await control.command('waitFor', '[data-testid^="add-context-cloud-project-space-"]', {
+    text: 'Task Follow-up Board',
+    timeoutMs: DEFAULT_STEP_TIMEOUT_MS,
+  })
+  await control.command('press', 'body', { key: 'Escape' })
+  return taskTabTestId
+}
+
+async function verifyExplicitlyTrackedTask(control, taskTabTestId) {
+  await control.command('click', '[data-testid^="workspace-tab-select-board-"]')
+  await control.command('waitFor', '[data-testid="cloud-project-board-view"]', {
+    timeoutMs: WORKBENCH_READY_TIMEOUT_MS,
+  })
+  await control.command('click', '[data-testid="cloud-project-board-view"]')
+  await control.command('waitFor', '[data-testid="cloud-todo-column-in_review"]', {
+    text: 'WEWORK_DESKTOP_E2E_TASK',
+    timeoutMs: DEFAULT_STEP_TIMEOUT_MS,
+  })
+  await captureVerificationScreenshot(control, 'project-space-selected-task-in-review.png')
+  await control.command('click', `[data-testid="${taskTabTestId}"]`)
+  await control.command('waitFor', ACTIVE_COMPOSER_SELECTOR, {
+    timeoutMs: WORKBENCH_READY_TIMEOUT_MS,
+  })
+}
+
 function workspaceTabIds(snapshot, kind) {
   return snapshot.testIds.filter(testId => testId.startsWith(`workspace-tab-${kind}-`))
 }
@@ -12419,6 +12498,12 @@ last_updated = "2026-07-30T00:00:00Z"`
       timeoutMs: DEFAULT_STEP_TIMEOUT_MS,
     })
 
+    let associatedTaskTabTestId = null
+    if (shouldRunDesktopCheckpoint('core-task-flow')) {
+      phase = 'project-space-default-association-setup'
+      associatedTaskTabTestId = await configureDefaultProjectSpaceAssociation(control, projectId)
+    }
+
     if (GUIDANCE_SCROLL_ONLY) {
       phase = 'guidance-scroll'
       await verifyForegroundGuidanceScroll({ composerSelector, control })
@@ -12624,6 +12709,10 @@ last_updated = "2026-07-30T00:00:00Z"`
         taskRowTestId,
         userText: TASK_PROMPT,
       })
+      if (associatedTaskTabTestId) {
+        phase = 'project-space-selected-task-tracked'
+        await verifyExplicitlyTrackedTask(control, associatedTaskTabTestId)
+      }
       if (MESSAGE_RESTORATION_ONLY) {
         await verifyFollowUpMessageRestoration({
           composerSelector,
diff --git a/wework/src/api/deliveries.ts b/wework/src/api/deliveries.ts
index 1d6eec5475..447511d8c3 100644
--- a/wework/src/api/deliveries.ts
+++ b/wework/src/api/deliveries.ts
@@ -1,6 +1,9 @@
 import { invoke } from '@tauri-apps/api/core'
 import type { HttpClient } from './http'
 import type { RuntimeTaskAddress } from '@/types/api'
+
+export const PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT =
+  'wework:project-space-local-bindings-changed'
 import { openLocalFile } from '@/lib/local-terminal'
 import { isTauriRuntime } from '@/lib/runtime-environment'
 
@@ -216,7 +219,31 @@ export interface CloudMyWorkItem extends CloudLoopItem {
   has_active_task: boolean
 }
 
+export function createProjectTaskTrackingSingleFlight() {
+  const requests = new Map<string, Promise<{ item: CloudLoopItem }>>()
+
+  return (
+    projectId: CloudProjectIdInput,
+    task: RuntimeTaskAddress,
+    create: () => Promise<{ item: CloudLoopItem }>
+  ): Promise<{ item: CloudLoopItem }> => {
+    const key = `${projectId}:${task.deviceId}:${task.taskId}`
+    const existing = requests.get(key)
+    if (existing) return existing
+
+    const request = create()
+    requests.set(key, request)
+    const clear = () => {
+      if (requests.get(key) === request) requests.delete(key)
+    }
+    void request.then(clear, clear)
+    return request
+  }
+}
+
 export function createDeliveryApi(client: HttpClient) {
+  const trackProjectTaskOnce = createProjectTaskTrackingSingleFlight()
+
   return {
     listCloudProjects(): Promise<{ items: CloudProject[] }> {
       return client.get('/v1/cloud-projects')
@@ -419,6 +446,29 @@ export function createDeliveryApi(client: HttpClient) {
         ...(taskTitle ? { taskTitle } : {}),
       })
     },
+    trackProjectTask(
+      projectId: CloudProjectIdInput,
+      task: RuntimeTaskAddress,
+      taskTitle: string,
+      description: string
+    ): Promise<{ item: CloudLoopItem }> {
+      return trackProjectTaskOnce(projectId, task, () =>
+        client.post(`/v1/cloud-projects/${projectId}/tasks/track`, {
+          ...task,
+          taskTitle,
+          description,
+        })
+      )
+    },
+    updateTaskTrackingStatus(
+      task: RuntimeTaskAddress,
+      executionStatus: 'running' | 'succeeded' | 'failed' | 'cancelled'
+    ): Promise<CloudLoopItem | null> {
+      return client.patch('/v1/runtime-tasks/cloud-context/tracking-status', {
+        ...task,
+        executionStatus,
+      })
+    },
     unbindCloudContext(task: RuntimeTaskAddress): Promise<void> {
       return client.delete('/v1/runtime-tasks/cloud-context', task)
     },
@@ -458,10 +508,26 @@ export function createDeliveryApi(client: HttpClient) {
     },
     addLocalBinding(
       projectId: CloudProjectIdInput,
-      data: { local_project_id: number; device_id?: string; is_default?: boolean }
+      data: {
+        local_project_id: number
+        device_id?: string
+        is_default?: boolean
+      }
     ): Promise<CloudProjectLocalBinding> {
       return client.post(`/v1/cloud-projects/${projectId}/local-bindings`, data)
     },
+    updateLocalBinding(
+      projectId: CloudProjectIdInput,
+      bindingId: string,
+      data: {
+        is_default?: boolean
+      }
+    ): Promise<CloudProjectLocalBinding> {
+      return client.patch(`/v1/cloud-projects/${projectId}/local-bindings/${bindingId}`, data)
+    },
+    deleteLocalBinding(projectId: CloudProjectIdInput, bindingId: string): Promise<void> {
+      return client.delete(`/v1/cloud-projects/${projectId}/local-bindings/${bindingId}`)
+    },
     listCloudFiles(projectId: CloudProjectIdInput): Promise<{ items: CloudProjectFile[] }> {
       return client.get(`/v1/cloud-projects/${projectId}/files`)
     },
diff --git a/wework/src/api/local/localDelivery.test.ts b/wework/src/api/local/localDelivery.test.ts
index a259a3f396..78f3f321bf 100644
--- a/wework/src/api/local/localDelivery.test.ts
+++ b/wework/src/api/local/localDelivery.test.ts
@@ -324,6 +324,168 @@ describe('local delivery API', () => {
     })
   })
 
+  test('stores project-space associations with one default per local project', async () => {
+    window.localStorage.clear()
+    const request = vi.fn()
+    const api = createLocalDeliveryApi(request)
+
+    const first = await api.addLocalBinding('project-1', {
+      local_project_id: 91,
+      is_default: true,
+    })
+    const second = await api.addLocalBinding('project-2', {
+      local_project_id: 91,
+      is_default: true,
+    })
+
+    await expect(api.listLocalBindings('project-1')).resolves.toEqual([
+      expect.objectContaining({ id: first.id, is_default: false }),
+    ])
+    await expect(api.listLocalBindings('project-2')).resolves.toEqual([
+      expect.objectContaining({ id: second.id, is_default: true }),
+    ])
+
+    const updated = await api.updateLocalBinding('project-1', first.id, {
+      is_default: true,
+    })
+    expect(updated.is_default).toBe(true)
+    await expect(api.listLocalBindings('project-2')).resolves.toEqual([
+      expect.objectContaining({ id: second.id, is_default: false }),
+    ])
+    await api.deleteLocalBinding('project-2', second.id)
+    await expect(api.listLocalBindings('project-2')).resolves.toEqual([])
+  })
+
+  test('tracks concurrent calls for the same runtime task only once', async () => {
+    const trackedTask = { ...taskRecord, status: 'in_progress' }
+    const request = vi.fn(async (method: string) => {
+      if (method === 'runtime_tasks.context') throw new Error('Task context not found')
+      if (method === 'todos.create') return trackedTask
+      if (method === 'todos.bind') return { id: 'binding-1' }
+      throw new Error(`Unexpected method: ${method}`)
+    })
+    const api = createLocalDeliveryApi(request)
+    const trackProjectTask = api.trackProjectTask
+
+    const first = trackProjectTask(
+      'project-1',
+      { deviceId: 'local-device', taskId: 'runtime-1' },
+      'Runtime task',
+      'Track only this explicitly selected task'
+    )
+    const second = trackProjectTask(
+      'project-1',
+      { deviceId: 'local-device', taskId: 'runtime-1' },
+      'Runtime task changed during rendering',
+      'Updated description'
+    )
+
+    await expect(Promise.all([first, second])).resolves.toEqual([
+      expect.objectContaining({
+        item: expect.objectContaining({ id: 'LOCAL-1', status: 'in_progress' }),
+      }),
+      expect.objectContaining({
+        item: expect.objectContaining({ id: 'LOCAL-1', status: 'in_progress' }),
+      }),
+    ])
+
+    expect(request).toHaveBeenCalledTimes(3)
+    expect(request).toHaveBeenCalledWith('runtime_tasks.context', {
+      device_id: 'local-device',
+      task_id: 'runtime-1',
+    })
+    expect(request).toHaveBeenCalledWith('todos.create', {
+      project_id: 'project-1',
+      todo: {
+        title: 'Runtime task',
+        description: 'Track only this explicitly selected task',
+        status: 'in_progress',
+        priority: 'none',
+        parent_id: null,
+        tags: [],
+      },
+    })
+    expect(request).toHaveBeenCalledWith('todos.bind', {
+      project_id: 'project-1',
+      item_id: 'LOCAL-1',
+      task: {
+        deviceId: 'local-device',
+        taskId: 'runtime-1',
+        taskTitle: 'Runtime task',
+      },
+    })
+  })
+
+  test('allows retrying project tracking after a failed request', async () => {
+    const trackedTask = { ...taskRecord, status: 'in_progress' }
+    let createAttempts = 0
+    const request = vi.fn(async (method: string) => {
+      if (method === 'runtime_tasks.context') throw new Error('Task context not found')
+      if (method === 'todos.create') {
+        createAttempts += 1
+        if (createAttempts === 1) throw new Error('Temporary create failure')
+        return trackedTask
+      }
+      if (method === 'todos.bind') return { id: 'binding-1' }
+      throw new Error(`Unexpected method: ${method}`)
+    })
+    const api = createLocalDeliveryApi(request)
+
+    await expect(
+      api.trackProjectTask(
+        'project-1',
+        { deviceId: 'local-device', taskId: 'runtime-1' },
+        'Runtime task',
+        'Retry tracking'
+      )
+    ).rejects.toThrow('Temporary create failure')
+
+    await expect(
+      api.trackProjectTask(
+        'project-1',
+        { deviceId: 'local-device', taskId: 'runtime-1' },
+        'Runtime task',
+        'Retry tracking'
+      )
+    ).resolves.toMatchObject({ item: { id: 'LOCAL-1' } })
+  })
+
+  test('updates tracking status when the API method is called without object context', async () => {
+    const trackedTask = { ...taskRecord, status: 'in_progress' }
+    const reviewedTask = { ...trackedTask, status: 'in_review', version: 2 }
+    const request = vi.fn(async (method: string) => {
+      if (method === 'runtime_tasks.context') {
+        return {
+          id: 'binding-1',
+          cloud_project_id: 'project-1',
+          loop_item_id: 'LOCAL-1',
+          task_user_id: 0,
+          device_id: 'local-device',
+          task_id: 'runtime-1',
+          task_title: 'Runtime task',
+          backend_task_id: null,
+          linked_at: '2026-07-27T00:00:00Z',
+        }
+      }
+      if (method === 'projects.list') return [projectRecord]
+      if (method === 'todos.get') return trackedTask
+      if (method === 'todos.update') return reviewedTask
+      throw new Error(`Unexpected method: ${method}`)
+    })
+    const api = createLocalDeliveryApi(request)
+    const updateTaskTrackingStatus = api.updateTaskTrackingStatus
+
+    await expect(
+      updateTaskTrackingStatus({ deviceId: 'local-device', taskId: 'runtime-1' }, 'succeeded')
+    ).resolves.toMatchObject({ id: 'LOCAL-1', status: 'in_review' })
+
+    expect(request).toHaveBeenCalledWith('todos.update', {
+      project_id: 'project-1',
+      task_id: 'LOCAL-1',
+      todo: { version: 1, status: 'in_review' },
+    })
+  })
+
   test('routes local files, attachments, and deliveries through executor IPC', async () => {
     const delivery = {
       id: 'delivery-1',
diff --git a/wework/src/api/local/localDelivery.ts b/wework/src/api/local/localDelivery.ts
index 18a56e46c8..11c2f5c6a2 100644
--- a/wework/src/api/local/localDelivery.ts
+++ b/wework/src/api/local/localDelivery.ts
@@ -1,16 +1,18 @@
 import { convertFileSrc } from '@tauri-apps/api/core'
 
-import type {
-  CloudLoopItemAttachment,
-  CloudLoopItem,
-  CloudProject,
-  CloudProjectFile,
-  CloudProjectId,
-  CloudProjectMember,
-  Delivery,
-  DeliveryAsset,
-  DeliveryCreateInput,
-  DeliveryDetail,
+import {
+  createProjectTaskTrackingSingleFlight,
+  type CloudLoopItemAttachment,
+  type CloudLoopItem,
+  type CloudProject,
+  type CloudProjectFile,
+  type CloudProjectId,
+  type CloudProjectLocalBinding,
+  type CloudProjectMember,
+  type Delivery,
+  type DeliveryAsset,
+  type DeliveryCreateInput,
+  type DeliveryDetail,
 } from '@/api/deliveries'
 import type { WorkbenchServices } from '@/features/workbench/workbenchServices'
 import { openLocalFile } from '@/lib/local-terminal'
@@ -304,6 +306,21 @@ export function createLocalDeliveryApi(
   request: LocalRequest
 ): NonNullable<WorkbenchServices['deliveryApi']> {
   const taskProjects = new Map<string, CloudProjectId>()
+  const trackProjectTaskOnce = createProjectTaskTrackingSingleFlight()
+  const bindingStorageKey = 'wework.local-project-space-bindings'
+
+  const readLocalBindings = (): CloudProjectLocalBinding[] => {
+    try {
+      const parsed = JSON.parse(window.localStorage.getItem(bindingStorageKey) ?? '[]')
+      return Array.isArray(parsed) ? parsed : []
+    } catch {
+      return []
+    }
+  }
+
+  const writeLocalBindings = (bindings: CloudProjectLocalBinding[]) => {
+    window.localStorage.setItem(bindingStorageKey, JSON.stringify(bindings))
+  }
 
   function rememberTasks(projectId: CloudProjectId, records: LocalLoopItemRecord[]) {
     for (const record of records) taskProjects.set(record.id, projectId)
@@ -525,6 +542,59 @@ export function createLocalDeliveryApi(
         task: { ...task, ...(taskTitle ? { taskTitle } : {}) },
       })
     },
+    async trackProjectTask(
+      projectId: CloudProjectId,
+      task: RuntimeTaskAddress,
+      taskTitle: string,
+      description: string
+    ) {
+      return trackProjectTaskOnce(projectId, task, async () => {
+        try {
+          const existing = await request<LocalTaskBindingRecord>('runtime_tasks.context', {
+            device_id: task.deviceId,
+            task_id: task.taskId,
+          })
+          if (existing.loop_item_id) {
+            return { item: await api.getLoopItem(existing.loop_item_id) }
+          }
+        } catch {
+          // Missing context is the expected first-run path.
+        }
+        const item = await api.createLoopItem(projectId, {
+          title: taskTitle,
+          description,
+          status: 'in_progress',
+        })
+        await api.bindTask(item.id, task, taskTitle)
+        return { item }
+      })
+    },
+    async updateTaskTrackingStatus(
+      task: RuntimeTaskAddress,
+      executionStatus: 'running' | 'succeeded' | 'failed' | 'cancelled'
+    ) {
+      let binding: LocalTaskBindingRecord
+      try {
+        binding = await request<LocalTaskBindingRecord>('runtime_tasks.context', {
+          device_id: task.deviceId,
+          task_id: task.taskId,
+        })
+      } catch {
+        return null
+      }
+      if (!binding.loop_item_id) return null
+      const item = await api.getLoopItem(binding.loop_item_id)
+      const nextStatus =
+        executionStatus === 'running' &&
+        (item.status === 'inbox' || item.status === 'pending' || item.status === 'in_review')
+          ? 'in_progress'
+          : executionStatus === 'succeeded' && item.status === 'in_progress'
+            ? 'in_review'
+            : null
+      return nextStatus
+        ? api.updateLoopItem(item.id, { version: item.version, status: nextStatus })
+        : item
+    },
     async unbindCloudContext(task: RuntimeTaskAddress) {
       await request('runtime_tasks.unbind', {
         device_id: task.deviceId,
@@ -537,6 +607,40 @@ export function createLocalDeliveryApi(
         task_id: task.taskId,
       })
     },
+    async updateLocalBinding(
+      projectId: CloudProjectId,
+      bindingId: string,
+      data: { is_default?: boolean }
+    ) {
+      const bindings = readLocalBindings()
+      const binding = bindings.find(
+        candidate => candidate.id === bindingId && candidate.cloud_project_id === projectId
+      )
+      if (!binding) throw new Error('Local binding not found')
+      if (data.is_default) {
+        for (const candidate of bindings) {
+          if (
+            candidate.id !== binding.id &&
+            candidate.local_project_id === binding.local_project_id &&
+            candidate.device_id === binding.device_id
+          ) {
+            candidate.is_default = false
+          }
+        }
+      }
+      if (data.is_default !== undefined) binding.is_default = data.is_default
+      binding.updated_at = new Date().toISOString()
+      writeLocalBindings(bindings)
+      return binding
+    },
+    async deleteLocalBinding(projectId: CloudProjectId, bindingId: string) {
+      const bindings = readLocalBindings()
+      const nextBindings = bindings.filter(
+        candidate => candidate.id !== bindingId || candidate.cloud_project_id !== projectId
+      )
+      if (nextBindings.length === bindings.length) throw new Error('Local binding not found')
+      writeLocalBindings(nextBindings)
+    },
     async findLoopItemForTask(task: RuntimeTaskAddress) {
       const binding = await request<LocalTaskBindingRecord>('runtime_tasks.context', {
         device_id: task.deviceId,
@@ -562,13 +666,58 @@ export function createLocalDeliveryApi(
         loop_item: loopItem,
       }
     },
-    listLocalBindings: async () => [],
+    async listLocalBindings(projectId: CloudProjectId) {
+      return readLocalBindings().filter(binding => binding.cloud_project_id === projectId)
+    },
     listCloudProjectMembers: async (): Promise<CloudProjectMember[]> => [],
     addCloudProjectMember: async () => unsupported('Project members'),
     updateCloudProjectMember: async () => unsupported('Project members'),
     removeCloudProjectMember: async () => unsupported('Project members'),
     searchCloudProjectUsers: async () => ({ users: [], total: 0 }),
-    addLocalBinding: async () => unsupported('Local bindings'),
+    async addLocalBinding(
+      projectId: CloudProjectId,
+      data: {
+        local_project_id: number
+        device_id?: string
+        is_default?: boolean
+      }
+    ) {
+      const bindings = readLocalBindings()
+      if (
+        bindings.some(
+          binding =>
+            binding.cloud_project_id === projectId &&
+            binding.local_project_id === data.local_project_id &&
+            binding.device_id === (data.device_id ?? null)
+        )
+      ) {
+        throw new Error('Local project is already linked')
+      }
+      if (data.is_default) {
+        for (const candidate of bindings) {
+          if (
+            candidate.local_project_id === data.local_project_id &&
+            candidate.device_id === (data.device_id ?? null)
+          ) {
+            candidate.is_default = false
+          }
+        }
+      }
+      const now = new Date().toISOString()
+      const binding: CloudProjectLocalBinding = {
+        id: crypto.randomUUID(),
+        cloud_project_id: projectId,
+        local_project_id: data.local_project_id,
+        user_id: 0,
+        device_id: data.device_id ?? null,
+        is_default: data.is_default ?? false,
+        created_at: now,
+        updated_at: now,
+      }
+      bindings.push(binding)
+      writeLocalBindings(bindings)
+      return binding
+    },
     async listCloudFiles(projectId: CloudProjectId) {
       const records = await request<LocalProjectFileRecord[]>('files.list', {
         project_id: projectId,
diff --git a/wework/src/components/chat/ChatInput.tsx b/wework/src/components/chat/ChatInput.tsx
index 6f7f4893ad..e3eb17936b 100644
--- a/wework/src/components/chat/ChatInput.tsx
+++ b/wework/src/components/chat/ChatInput.tsx
@@ -135,6 +135,7 @@ export interface ChatInputProps {
   cloudProjectCandidates?: ComposerCloudMentionCandidate[]
   cloudSpaceEnabled?: boolean
   onSelectCloudProject?: (project: CloudProject) => void
+  selectedCloudProjectId?: CloudProject['id']
   isStreaming?: boolean
   onPause?: () => void
   showWorkspaceMenu?: boolean
@@ -257,6 +258,7 @@ export function ChatInput({
   cloudProjectCandidates,
   cloudSpaceEnabled,
   onSelectCloudProject,
+  selectedCloudProjectId,
   isStreaming = false,
   onPause,
   showWorkspaceMenu,
@@ -410,6 +412,7 @@ export function ChatInput({
     cloudProjectCandidates,
     cloudSpaceEnabled,
     onSelectCloudProject,
+    selectedCloudProjectId,
   }
   const errorBanner = error ? (
     <div
diff --git a/wework/src/components/chat/composer/AddContextMenu.test.tsx b/wework/src/components/chat/composer/AddContextMenu.test.tsx
index a762a370e3..367e46969c 100644
--- a/wework/src/components/chat/composer/AddContextMenu.test.tsx
+++ b/wework/src/components/chat/composer/AddContextMenu.test.tsx
@@ -1,7 +1,40 @@
 import { fireEvent, render, screen, waitFor } from '@testing-library/react'
 import { describe, expect, test, vi } from 'vitest'
+import type { CloudProject } from '@/api/deliveries'
+import type { ComposerCloudMentionCandidate } from './composerMentionCandidates'
 import { AddContextMenu } from './AddContextMenu'
 
+const project: CloudProject = {
+  id: 'space-1',
+  public_id: 'space-public-1',
+  project_key: 'FOLLOWUP',
+  name: 'Task Follow-up Board',
+  description: 'Track selected local tasks',
+  project_store: 'local',
+  task_provider: 'local',
+  provider_config: {},
+  created_by_user_id: 1,
+  status: 'active',
+  tags: [],
+  version: 1,
+  created_at: '2026-08-04T00:00:00Z',
+  updated_at: '2026-08-04T00:00:00Z',
+}
+
+const projectCandidate: ComposerCloudMentionCandidate = {
+  kind: 'cloud',
+  key: 'cloud-project-space:space-1',
+  title: project.name,
+  description: project.description,
+  metaLabel: '云空间',
+  statusLabel: '自动加入',
+  testId: 'cloud-project-space-space-1',
+  enabled: true,
+  reference: '[$项目空间:Task Follow-up Board](cloud://projects/space-1)',
+  searchAliases: [project.name],
+  project,
+}
+
 describe('AddContextMenu', () => {
   test('renders its menu in a body portal so composer containers cannot clip it', () => {
     render(<AddContextMenu disabled={false} onFileSelect={vi.fn()} />)
@@ -86,4 +119,30 @@ describe('AddContextMenu', () => {
     expect(screen.queryByTestId('add-context-menu')).not.toBeInTheDocument()
     expect(trigger).toHaveFocus()
   })
+
+  test('selects a linked project space from the add-context menu', () => {
+    const onSelectCloudProject = vi.fn()
+    render(
+      <AddContextMenu
+        disabled={false}
+        onFileSelect={vi.fn()}
+        cloudProjectCandidates={[projectCandidate]}
+        selectedCloudProjectId={project.id}
+        onSelectCloudProject={onSelectCloudProject}
+      />
+    )
+
+    fireEvent.click(screen.getByTestId('add-context-button'))
+    expect(screen.getByTestId('add-project-space-context-button')).toHaveTextContent(project.name)
+    fireEvent.click(screen.getByTestId('add-project-space-context-button'))
+
+    const option = screen.getByTestId('add-context-cloud-project-space-space-1')
+    expect(option).toHaveAttribute('aria-checked', 'true')
+    expect(option).toHaveTextContent('自动加入')
+    fireEvent.click(option)
+
+    expect(onSelectCloudProject).toHaveBeenCalledOnce()
+    expect(onSelectCloudProject).toHaveBeenCalledWith(project)
+    expect(screen.queryByTestId('add-context-menu')).not.toBeInTheDocument()
+  })
 })
diff --git a/wework/src/components/chat/composer/AddContextMenu.tsx b/wework/src/components/chat/composer/AddContextMenu.tsx
index e13c1c2ac3..3703b3df7f 100644
--- a/wework/src/components/chat/composer/AddContextMenu.tsx
+++ b/wework/src/components/chat/composer/AddContextMenu.tsx
@@ -1,8 +1,19 @@
-import { ClipboardList, Eye, Paperclip, Plus, Target } from 'lucide-react'
+import {
+  ArrowLeft,
+  Check,
+  ClipboardList,
+  Eye,
+  LayoutDashboard,
+  Paperclip,
+  Plus,
+  Target,
+} from 'lucide-react'
 import type { ChangeEvent } from 'react'
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { createPortal } from 'react-dom'
+import type { CloudProject } from '@/api/deliveries'
 import { useTranslation } from '@/hooks/useTranslation'
+import type { ComposerCloudMentionCandidate } from './composerMentionCandidates'
 import { useAnchoredPortalMenu } from './useAnchoredPortalMenu'
 import { useOutsideClick } from './useOutsideClick'
 
@@ -14,6 +25,9 @@ interface AddContextMenuProps {
   onConfigureSupervisor?: () => void
   supervisorEnabled?: boolean
   supervisorPending?: boolean
+  cloudProjectCandidates?: ComposerCloudMentionCandidate[]
+  selectedCloudProjectId?: CloudProject['id']
+  onSelectCloudProject?: (project: CloudProject) => void
 }
 
 export function AddContextMenu({
@@ -24,6 +38,9 @@ export function AddContextMenu({
   onConfigureSupervisor,
   supervisorEnabled = false,
   supervisorPending = false,
+  cloudProjectCandidates = [],
+  selectedCloudProjectId,
+  onSelectCloudProject,
 }: AddContextMenuProps) {
   const { t } = useTranslation('common')
   const containerRef = useRef<HTMLDivElement>(null)
@@ -31,7 +48,11 @@ export function AddContextMenu({
   const menuRef = useRef<HTMLDivElement>(null)
   const triggerRef = useRef<HTMLButtonElement>(null)
   const [open, setOpen] = useState(false)
-  const closeMenu = useCallback(() => setOpen(false), [])
+  const [view, setView] = useState<'root' | 'project-spaces'>('root')
+  const closeMenu = useCallback(() => {
+    setOpen(false)
+    setView('root')
+  }, [])
   const outsideRefs = useMemo(() => [menuRef], [])
   const menuLayout = useAnchoredPortalMenu(open, triggerRef, menuRef)
 
@@ -86,6 +107,11 @@ export function AddContextMenu({
     onConfigureSupervisor?.()
   }, [onConfigureSupervisor])
 
+  const selectableProjectSpaces = cloudProjectCandidates.filter(
+    (candidate): candidate is ComposerCloudMentionCandidate & { project: CloudProject } =>
+      candidate.enabled && Boolean(candidate.project)
+  )
+
   return (
     <div ref={containerRef} className="relative">
       <input
@@ -111,70 +137,137 @@ export function AddContextMenu({
             }}
             className="fixed z-system-popover w-[22rem] max-w-[calc(100vw-2rem)] overflow-y-auto rounded-xl border border-border bg-background p-1.5 shadow-[0_12px_32px_rgba(0,0,0,0.12)]"
           >
-            <button
-              type="button"
-              role="menuitem"
-              data-testid="attach-files-button"
-              onClick={() => fileInputRef.current?.click()}
-              className="flex h-9 w-full items-center gap-2.5 rounded-lg px-3 text-left text-base font-normal leading-[18px] text-text-primary hover:bg-muted"
-            >
-              <Paperclip className="h-[18px] w-[18px] shrink-0 text-text-secondary" />
-              <span>{t('workbench.add_photos_files', '添加照片和文件')}</span>
-            </button>
-            {onSetPlanMode && (
-              <button
-                type="button"
-                role="menuitem"
-                data-testid="set-plan-mode-button"
-                onClick={handleSetPlanMode}
-                className="flex h-9 w-full items-center gap-2.5 rounded-lg px-3 text-left text-base font-normal leading-[18px] text-text-primary hover:bg-muted"
-              >
-                <ClipboardList className="h-[18px] w-[18px] shrink-0 text-text-secondary" />
-                <span className="min-w-0 truncate">
-                  <span>{t('workbench.plan_mode', '计划模式')}</span>
-                  <span className="ml-2 text-text-muted">
-                    {t('workbench.enable_plan_mode', '开启计划模式')}
-                  </span>
-                </span>
-              </button>
-            )}
-            {onSetGoal && (
-              <button
-                type="button"
-                role="menuitem"
-                data-testid="set-goal-button"
-                onClick={handleSetGoal}
-                className="flex h-9 w-full items-center gap-2.5 rounded-lg px-3 text-left text-base font-normal leading-[18px] text-text-primary hover:bg-muted"
-              >
-                <Target className="h-[18px] w-[18px] shrink-0 text-text-secondary" />
-                <span className="min-w-0 truncate">
-                  <span>{t('workbench.goal_chip', '目标')}</span>
-                  <span className="ml-2 text-text-muted">
-                    {t('workbench.pursue_goal_description', '设置 WeWork 将持续努力实现的目标')}
-                  </span>
-                </span>
-              </button>
-            )}
-            {onConfigureSupervisor && (
-              <button
-                type="button"
-                role="menuitem"
-                data-testid="task-supervisor-toggle-button"
-                onClick={handleConfigureSupervisor}
-                className="flex h-9 w-full items-center gap-2.5 rounded-lg px-3 text-left text-base font-normal leading-[18px] text-text-primary hover:bg-muted"
-              >
-                <Eye className="h-[18px] w-[18px] shrink-0 text-text-secondary" />
-                <span className="min-w-0 truncate">
-                  <span>{t('workbench.supervisor_title')}</span>
-                  <span className="ml-2 text-text-muted">
-                    {supervisorPending
-                      ? t('workbench.supervisor_pending_menu')
-                      : supervisorEnabled
-                        ? t('workbench.supervisor_configure')
-                        : t('workbench.supervisor_enable')}
-                  </span>
-                </span>
-              </button>
+            {view === 'project-spaces' ? (
+              <>
+                <button
+                  type="button"
+                  role="menuitem"
+                  data-testid="project-space-menu-back"
+                  onClick={() => setView('root')}
+                  className="flex h-9 w-full items-center gap-2.5 rounded-lg px-3 text-left text-base font-medium text-text-primary hover:bg-muted"
+                >
+                  <ArrowLeft className="h-[18px] w-[18px] shrink-0 text-text-secondary" />
+                  <span>{t('workbench.add_context_project_space', '项目空间')}</span>
+                </button>
+                <div className="my-1 h-px bg-border" />
+                {selectableProjectSpaces.map(candidate => {
+                  const selected = candidate.project.id === selectedCloudProjectId
+                  return (
+                    <button
+                      key={candidate.key}
+                      type="button"
+                      role="menuitemradio"
+                      aria-checked={selected}
+                      data-testid={`add-context-${candidate.testId}`}
+                      onClick={() => {
+                        onSelectCloudProject?.(candidate.project)
+                        closeMenu()
+                      }}
+                      className="flex min-h-11 w-full items-center gap-2.5 rounded-lg px-3 py-2 text-left text-sm text-text-primary hover:bg-muted"
+                    >
+                      <LayoutDashboard className="h-[18px] w-[18px] shrink-0 text-text-secondary" />
+                      <span className="min-w-0 flex-1">
+                        <span className="block truncate font-medium">{candidate.title}</span>
+                        {(candidate.description || candidate.statusLabel) && (
+                          <span className="block truncate text-xs text-text-muted">
+                            {[candidate.statusLabel, candidate.description]
+                              .filter(Boolean)
+                              .join(' · ')}
+                          </span>
+                        )}
+                      </span>
+                      {selected && <Check className="h-4 w-4 shrink-0" />}
+                    </button>
+                  )
+                })}
+              </>
+            ) : (
+              <>
+                <button
+                  type="button"
+                  role="menuitem"
+                  data-testid="attach-files-button"
+                  onClick={() => fileInputRef.current?.click()}
+                  className="flex h-9 w-full items-center gap-2.5 rounded-lg px-3 text-left text-base font-normal leading-[18px] text-text-primary hover:bg-muted"
+                >
+                  <Paperclip className="h-[18px] w-[18px] shrink-0 text-text-secondary" />
+                  <span>{t('workbench.add_photos_files', '添加照片和文件')}</span>
+                </button>
+                {selectableProjectSpaces.length > 0 && onSelectCloudProject && (
+                  <button
+                    type="button"
+                    role="menuitem"
+                    data-testid="add-project-space-context-button"
+                    onClick={() => setView('project-spaces')}
+                    className="flex h-9 w-full items-center gap-2.5 rounded-lg px-3 text-left text-base font-normal leading-[18px] text-text-primary hover:bg-muted"
+                  >
+                    <LayoutDashboard className="h-[18px] w-[18px] shrink-0 text-text-secondary" />
+                    <span className="min-w-0 flex-1 truncate">
+                      {t('workbench.add_context_project_space', '项目空间')}
+                    </span>
+                    <span className="max-w-40 truncate text-sm text-text-muted">
+                      {selectableProjectSpaces.find(
+                        candidate => candidate.project.id === selectedCloudProjectId
+                      )?.title ?? t('workbench.add_context_project_space_select', '选择看板')}
+                    </span>
+                  </button>
+                )}
+                {onSetPlanMode && (
+                  <button
+                    type="button"
+                    role="menuitem"
+                    data-testid="set-plan-mode-button"
+                    onClick={handleSetPlanMode}
+                    className="flex h-9 w-full items-center gap-2.5 rounded-lg px-3 text-left text-base font-normal leading-[18px] text-text-primary hover:bg-muted"
+                  >
+                    <ClipboardList className="h-[18px] w-[18px] shrink-0 text-text-secondary" />
+                    <span className="min-w-0 truncate">
+                      <span>{t('workbench.plan_mode', '计划模式')}</span>
+                      <span className="ml-2 text-text-muted">
+                        {t('workbench.enable_plan_mode', '开启计划模式')}
+                      </span>
+                    </span>
+                  </button>
+                )}
+                {onSetGoal && (
+                  <button
+                    type="button"
+                    role="menuitem"
+                    data-testid="set-goal-button"
+                    onClick={handleSetGoal}
+                    className="flex h-9 w-full items-center gap-2.5 rounded-lg px-3 text-left text-base font-normal leading-[18px] text-text-primary hover:bg-muted"
+                  >
+                    <Target className="h-[18px] w-[18px] shrink-0 text-text-secondary" />
+                    <span className="min-w-0 truncate">
+                      <span>{t('workbench.goal_chip', '目标')}</span>
+                      <span className="ml-2 text-text-muted">
+                        {t('workbench.pursue_goal_description', '设置 WeWork 将持续努力实现的目标')}
+                      </span>
+                    </span>
+                  </button>
+                )}
+                {onConfigureSupervisor && (
+                  <button
+                    type="button"
+                    role="menuitem"
+                    data-testid="task-supervisor-toggle-button"
+                    onClick={handleConfigureSupervisor}
+                    className="flex h-9 w-full items-center gap-2.5 rounded-lg px-3 text-left text-base font-normal leading-[18px] text-text-primary hover:bg-muted"
+                  >
+                    <Eye className="h-[18px] w-[18px] shrink-0 text-text-secondary" />
+                    <span className="min-w-0 truncate">
+                      <span>{t('workbench.supervisor_title')}</span>
+                      <span className="ml-2 text-text-muted">
+                        {supervisorPending
+                          ? t('workbench.supervisor_pending_menu')
+                          : supervisorEnabled
+                            ? t('workbench.supervisor_configure')
+                            : t('workbench.supervisor_enable')}
+                      </span>
+                    </span>
+                  </button>
+                )}
+              </>
             )}
           </div>,
           document.body
diff --git a/wework/src/components/chat/composer/ComposerToolbar.tsx b/wework/src/components/chat/composer/ComposerToolbar.tsx
index 1039edd6aa..ef41f360d9 100644
--- a/wework/src/components/chat/composer/ComposerToolbar.tsx
+++ b/wework/src/components/chat/composer/ComposerToolbar.tsx
@@ -1,10 +1,12 @@
 import { ArrowUp, ChevronDown, ClipboardList, Clock3, CornerDownRight, Zap } from 'lucide-react'
 import { useLayoutEffect, useRef, useState, type ComponentProps, type ReactNode } from 'react'
+import type { CloudProject } from '@/api/deliveries'
 import { ActionMenu } from '@/components/common/ActionMenu'
 import type { ComposerSubmitOptions } from './ComposerTextarea'
 import { useTranslation } from '@/hooks/useTranslation'
 import type { ModelOptions, RuntimeContextUsage, UnifiedModel } from '@/types/api'
 import { AddContextMenu } from './AddContextMenu'
+import type { ComposerCloudMentionCandidate } from './composerMentionCandidates'
 import { ComposerModePill, GoalDraftPill } from './GoalDraftPill'
 import { ContextUsageIndicator } from './ContextUsageIndicator'
 import { ModelSelector } from './ModelSelector'
@@ -45,6 +47,9 @@ interface ComposerToolbarProps {
   onQuickPhraseSelect: (phrase: QuickPhrase) => void
   onSubmit: (options?: ComposerSubmitOptions) => void
   leadingContext?: ReactNode
+  cloudProjectCandidates?: ComposerCloudMentionCandidate[]
+  selectedCloudProjectId?: CloudProject['id']
+  onSelectCloudProject?: (project: CloudProject) => void
 }
 
 const COMPACT_TOOLBAR_WIDTH = 475
@@ -83,6 +88,9 @@ export function ComposerToolbar({
   onQuickPhraseSelect,
   onSubmit,
   leadingContext,
+  cloudProjectCandidates,
+  selectedCloudProjectId,
+  onSelectCloudProject,
 }: ComposerToolbarProps) {
   const { t } = useTranslation('common')
   const toolbarRef = useRef<HTMLDivElement>(null)
@@ -126,6 +134,9 @@ export function ComposerToolbar({
           onConfigureSupervisor={onConfigureSupervisor}
           supervisorEnabled={supervisorEnabled}
           supervisorPending={supervisorPending}
+          cloudProjectCandidates={cloudProjectCandidates}
+          selectedCloudProjectId={selectedCloudProjectId}
+          onSelectCloudProject={onSelectCloudProject}
         />
         <QuickPhraseMenu disabled={disabled} iconOnly={compact} onSelect={onQuickPhraseSelect} />
         {leadingContext}
diff --git a/wework/src/components/chat/composer/ProjectChatComposer.tsx b/wework/src/components/chat/composer/ProjectChatComposer.tsx
index 04dfd292e3..55d3311bbb 100644
--- a/wework/src/components/chat/composer/ProjectChatComposer.tsx
+++ b/wework/src/components/chat/composer/ProjectChatComposer.tsx
@@ -64,6 +64,7 @@ interface ProjectChatComposerProps {
   cloudProjectCandidates?: ComposerCloudMentionCandidate[]
   cloudSpaceEnabled?: boolean
   onSelectCloudProject?: (project: CloudProject) => void
+  selectedCloudProjectId?: CloudProject['id']
   planModeActive?: boolean
   onSetPlanMode?: () => void
   onClearPlanMode?: () => void
@@ -123,6 +124,7 @@ export function ProjectChatComposer({
   cloudProjectCandidates,
   cloudSpaceEnabled,
   onSelectCloudProject,
+  selectedCloudProjectId,
   planModeActive = false,
   onSetPlanMode,
   onClearPlanMode,
@@ -376,6 +378,9 @@ export function ProjectChatComposer({
           onQuickPhraseSelect={handleQuickPhraseSelect}
           onSubmit={options => onSubmit(value, options)}
           leadingContext={toolbarLeadingContext}
+          cloudProjectCandidates={cloudProjectCandidates}
+          selectedCloudProjectId={selectedCloudProjectId}
+          onSelectCloudProject={onSelectCloudProject}
         />
       </form>
     </div>
diff --git a/wework/src/components/layout/DesktopSidebar.test.tsx b/wework/src/components/layout/DesktopSidebar.test.tsx
index 9a4263217c..26afd696fe 100644
--- a/wework/src/components/layout/DesktopSidebar.test.tsx
+++ b/wework/src/components/layout/DesktopSidebar.test.tsx
@@ -20,6 +20,7 @@ import {
   RuntimeTaskLifecycleProvider,
   RuntimeTaskLifecycleStore,
 } from '@/features/workbench/runtimeTaskLifecycle'
+import type { ProjectSpaceBindingApi } from '@/features/todo/projectSpaceLocalBindings'
 
 const experimentalFeatures = vi.hoisted(() => ({ enabled: true }))
 
@@ -3344,6 +3345,57 @@ describe('DesktopSidebar', () => {
     })
   })
 
+  test('hides automatic project-space joining when experimental features are disabled', async () => {
+    experimentalFeatures.enabled = false
+    const user = userEvent.setup()
+    const projectSpaceApi = {
+      listCloudProjects: vi.fn().mockResolvedValue({ items: [] }),
+      listLocalBindings: vi.fn().mockResolvedValue([]),
+    } as unknown as ProjectSpaceBindingApi
+
+    renderSidebar({
+      projects: [],
+      runtimeWork: {
+        projects: [
+          {
+            project: {
+              id: 7,
+              key: 'project:7',
+              name: 'Wegent',
+              source: 'local_project',
+              stateDeviceId: 'local-device',
+              roots: [{ kind: 'local', path: '/Users/alice/dev/Wegent' }],
+            },
+            totalTasks: 0,
+            deviceWorkspaces: [
+              {
+                id: 91,
+                deviceId: 'local-device',
+                deviceName: 'Local Mac',
+                deviceStatus: 'online',
+                available: true,
+                workspacePath: '/Users/alice/dev/Wegent',
+                workspaceKind: 'workspace',
+                workspaceSource: 'local',
+                tasks: [],
+              },
+            ],
+          },
+        ],
+        chats: [],
+        totalTasks: 0,
+      },
+      projectSpaceBindingApis: [projectSpaceApi],
+      onUpdateLocalRuntimeProject: vi.fn().mockResolvedValue(undefined),
+    })
+
+    await user.click(screen.getByTestId('project-menu-7'))
+    await user.click(screen.getByTestId('edit-project-7'))
+
+    expect(screen.queryByTestId('local-project-auto-join-space-select')).not.toBeInTheDocument()
+    expect(projectSpaceApi.listCloudProjects).not.toHaveBeenCalled()
+  })
+
   test('creates a permanent worktree from a runtime project', async () => {
     const user = userEvent.setup()
     const onCreatePermanentWorktree = vi.fn().mockResolvedValue(undefined)
diff --git a/wework/src/components/layout/DesktopSidebar.tsx b/wework/src/components/layout/DesktopSidebar.tsx
index 467f1b820a..f708f0a427 100644
--- a/wework/src/components/layout/DesktopSidebar.tsx
+++ b/wework/src/components/layout/DesktopSidebar.tsx
@@ -158,6 +158,7 @@ import {
 } from '@/features/workbench/runtimeSidebarDiagnostics'
 import { formatRelativeSidebarTime, useSidebarRelativeTimeRefresh } from './runtimeSidebarTime'
 import { useResizableSidebar } from './useResizableSidebar'
+import type { ProjectSpaceBindingApi } from '@/features/todo/projectSpaceLocalBindings'
 
 interface DesktopSidebarProps {
   user: UserProfile | null
@@ -250,6 +251,7 @@ interface DesktopSidebarProps {
   onGetDeviceHomeDirectory: (deviceId: string) => Promise<string>
   onListDeviceDirectories: (deviceId: string, path: string) => Promise<string[]>
   onCreateDeviceDirectory: (deviceId: string, path: string) => Promise<void>
+  projectSpaceBindingApis?: ProjectSpaceBindingApi[]
   onOpenSettings: (options?: OpenSettingsOptions) => void
   onLogout: () => void
 }
@@ -2583,6 +2585,7 @@ export function DesktopSidebar({
   onGetDeviceHomeDirectory,
   onListDeviceDirectories,
   onCreateDeviceDirectory,
+  projectSpaceBindingApis,
   onOpenSettings,
   onLogout,
   collapsed = false,
@@ -4132,6 +4135,7 @@ export function DesktopSidebar({
             onGetDeviceHomeDirectory={onGetDeviceHomeDirectory}
             onListDeviceDirectories={onListDeviceDirectories}
             onCreateDeviceDirectory={onCreateDeviceDirectory}
+            projectSpaceApis={experimentalFeaturesEnabled ? projectSpaceBindingApis : undefined}
             onClose={() => setEditingLocalProject(null)}
             onSave={data =>
               onUpdateLocalRuntimeProject
diff --git a/wework/src/components/layout/DesktopWorkbenchLayout.tsx b/wework/src/components/layout/DesktopWorkbenchLayout.tsx
index ef4f1d0ad5..a0b62ea705 100644
--- a/wework/src/components/layout/DesktopWorkbenchLayout.tsx
+++ b/wework/src/components/layout/DesktopWorkbenchLayout.tsx
@@ -35,6 +35,7 @@ import { useWorkbenchShellEventHandlers } from './workbenchShellEvents'
 import { EMPTY_RUNTIME_TASK_REMINDERS } from '@/features/workbench/runtimeTaskReminders'
 import { CloudTodoWorkspace } from '@/features/todo/CloudTodoWorkspace'
 import { resolveLocalTodoProjects } from '@/features/todo/localTodoProjects'
+import { projectSpaceBindingApis } from '@/features/todo/projectSpaceLocalBindings'
 import { WorkbenchBackground } from '@/features/appearance'
 import { isTauriRuntime } from '@/lib/runtime-environment'
 import { useResizableSidebar } from './useResizableSidebar'
@@ -118,6 +119,10 @@ export function DesktopWorkbenchLayout({ routeActive = true }: DesktopWorkbenchL
     () => resolveLocalTodoProjects(state.projects, state.runtimeWork),
     [state.projects, state.runtimeWork]
   )
+  const availableProjectSpaceBindingApis = useMemo(
+    () => projectSpaceBindingApis(services),
+    [services]
+  )
   const workspaceTabs = useOptionalWorkspaceTabs()
   const initialPath = stripAppBasePath(window.location.pathname)
   const [currentPath, setCurrentPath] = useState(initialPath)
@@ -608,6 +613,7 @@ export function DesktopWorkbenchLayout({ routeActive = true }: DesktopWorkbenchL
       onGetDeviceHomeDirectory={onGetDeviceHomeDirectory}
       onListDeviceDirectories={onListDeviceDirectories}
       onCreateDeviceDirectory={onCreateDeviceDirectory}
+      projectSpaceBindingApis={availableProjectSpaceBindingApis}
       onOpenSettings={options => {
         setAutoOpenAddCloudDeviceDialog(Boolean(options?.autoOpenAddCloudDeviceDialog))
         setSettingsOpen(true)
diff --git a/wework/src/components/layout/DesktopWorkbenchMain.tsx b/wework/src/components/layout/DesktopWorkbenchMain.tsx
index 39d64109e7..228a887dec 100644
--- a/wework/src/components/layout/DesktopWorkbenchMain.tsx
+++ b/wework/src/components/layout/DesktopWorkbenchMain.tsx
@@ -1,6 +1,13 @@
 import { memo, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
-import { ArrowLeftRight, ChevronRight, MessageCircle, MessageSquareWarning } from 'lucide-react'
+import {
+  ArrowLeftRight,
+  ChevronRight,
+  LayoutDashboard,
+  MessageCircle,
+  MessageSquareWarning,
+} from 'lucide-react'
 import type { ProjectChatControls } from '@/components/chat/ChatInput'
+import { ComposerModePill } from '@/components/chat/composer/GoalDraftPill'
 import type { ComposerCloudMentionCandidate } from '@/components/chat/composer/composerMentionCandidates'
 import type { AssistantPlanOpenRequest } from '@/components/chat/AssistantPlanCard'
 import { RequestUserInputCard } from '@/components/chat/RequestUserInputCard'
@@ -10,15 +17,26 @@ import { useAppPreferencesState } from '@/features/app-preferences/useAppPrefere
 import { useWorkbench, useWorkbenchPaneContext } from '@/features/workbench/useWorkbench'
 import { getPopoutComposerPlaceholder } from '@/features/workbench/popoutWorkspaceContext'
 import { DeliveryDialog } from '@/features/delivery/DeliveryDialog'
-import type { CloudLoopItem, CloudProject } from '@/api/deliveries'
+import {
+  PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT,
+  type CloudLoopItem,
+  type CloudProject,
+  type CloudProjectLocalBinding,
+} from '@/api/deliveries'
 import { TodoBindingPicker } from '@/features/todo/TodoBindingPicker'
+import {
+  cacheAutoJoinProjectSpace,
+  findProjectSpaceContextForTask,
+  projectSpaceBindingApis,
+  readCachedAutoJoinProjectSpace,
+} from '@/features/todo/projectSpaceLocalBindings'
 import {
   hydrateLocalWorkItems,
   loadLocalWorkItems,
   saveLocalWorkItems,
   type LocalWorkItem,
 } from '@/features/todo/todoModel'
-import type { WorkspaceSessionApi } from '@/features/workbench/workbenchServices'
+import type { WorkbenchServices, WorkspaceSessionApi } from '@/features/workbench/workbenchServices'
 import { useTranslation } from '@/hooks/useTranslation'
 import {
   findWorkbenchDevice,
@@ -202,10 +220,47 @@ function cloudItemAsLocalWorkItem(
   }
 }
 
+function cloudProjectAdditionalContext(
+  project: CloudProject | null,
+  item: CloudLoopItem | null
+): RuntimeAdditionalContext | undefined {
+  if (!project) return undefined
+  const projectReference = `cloud://projects/${project.id}`
+  const todoReference = item ? `${projectReference}/todos/${item.id}` : null
+  const scope = item
+    ? [
+        `Current cloud project: ${project.name} (id=${project.id}).`,
+        `Current task: ${item.id} — ${item.title}.`,
+        item.description ? `Task description: ${item.description}` : null,
+        `Current task reference: ${todoReference}.`,
+      ]
+    : [
+        `Current cloud project: ${project.name} (id=${project.id}).`,
+        'No specific task is selected.',
+        `Current project reference: ${projectReference}.`,
+      ]
+  return {
+    cloudCollaboration: {
+      kind: 'application',
+      value: [
+        ...scope.filter((line): line is string => Boolean(line)),
+        'When the user refers to “this project” or “this task”, use this current cloud context.',
+        'Use the wegent_delivery MCP tools to inspect task details, shared files, and deliveries when needed. Do not ask for an id that is already provided here.',
+      ].join('\n'),
+    },
+  }
+}
+
 interface PendingTodoBinding {
   project: CloudProject
   item: CloudLoopItem | null
   target: RuntimeTaskAddress | null
+  description: string
+}
+
+interface PendingAutoJoinResolution {
+  target: RuntimeTaskAddress | null
+  description: string
 }
 
 let pendingTodoBinding: PendingTodoBinding | null = null
@@ -532,6 +587,9 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
   const { t: tChat } = useTranslation('chat')
   const currentRuntimeTask = pane.currentRuntimeTask
   const currentProject = pane.currentProject
+  const localProjectId = currentProject?.id
+  const localProjectDeviceId =
+    currentProject?.config?.execution?.deviceId ?? currentProject?.config?.device_id
   const paneKey = getWorkbenchPaneKey(pane)
   const [turnNavigationPortalTarget, setTurnNavigationPortalTarget] =
     useState<HTMLDivElement | null>(null)
@@ -545,6 +603,8 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
   }, [])
   const paneSession = useWorkbenchPaneSession({ currentRuntimeTask })
   const sendPaneInput = paneSession.send
+  const todoBindingApis = useMemo(() => projectSpaceBindingApis(services), [services])
+  const pendingAutoJoinResolutionRef = useRef<PendingAutoJoinResolution | null>(null)
   const [deliveryItem, setDeliveryItem] = useState<Omit<LocalWorkItem, 'projectId'> | null>(null)
   const [boundCloudProject, setBoundCloudProject] = useState<CloudProject | null>(null)
   const [boundCloudItem, setBoundCloudItem] = useState<CloudLoopItem | null>(null)
@@ -562,11 +622,22 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
   const [pendingTodoItem, setPendingTodoItemState] = useState<CloudLoopItem | null>(() =>
     pendingTodoForTask(currentRuntimeTask)
   )
-  const [pendingCloudProject, setPendingCloudProject] = useState<CloudProject | null>(() =>
-    pendingProjectForTask(currentRuntimeTask)
+  const [pendingCloudProject, setPendingCloudProject] = useState<CloudProject | null>(
+    () =>
+      pendingProjectForTask(currentRuntimeTask) ??
+      (!currentRuntimeTask && localProjectId
+        ? readCachedAutoJoinProjectSpace(localProjectId, localProjectDeviceId)
+        : null)
   )
   const [todoBindingError, setTodoBindingError] = useState<string | null>(null)
   const [cloudProjects, setCloudProjects] = useState<CloudProject[]>([])
+  const [defaultCloudProjectId, setDefaultCloudProjectId] = useState<CloudProject['id'] | null>(
+    null
+  )
+  const [dismissedDefaultCloudProjectKey, setDismissedDefaultCloudProjectKey] = useState<
+    string | null
+  >(null)
+  const [localBindingRevision, setLocalBindingRevision] = useState(0)
   const [cloudActionNotice, setCloudActionNotice] = useState<string | null>(null)
   const [cloudMentionState, setCloudMentionState] = useState<{
     todoId: string
@@ -588,38 +659,14 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
   )
   const composerCloudProject = currentRuntimeTask ? boundCloudProject : pendingCloudProject
   const composerTodoItem = currentRuntimeTask ? boundCloudItem : pendingTodoItem
-  const cloudAdditionalContext = useMemo<RuntimeAdditionalContext | undefined>(() => {
-    if (!composerCloudProject) return undefined
-    const projectReference = `cloud://projects/${composerCloudProject.id}`
-    const todoReference = composerTodoItem
-      ? `${projectReference}/todos/${composerTodoItem.id}`
-      : null
-    const scope = composerTodoItem
-      ? [
-          `Current cloud project: ${composerCloudProject.name} (id=${composerCloudProject.id}).`,
-          `Current task: ${composerTodoItem.id} — ${composerTodoItem.title}.`,
-          composerTodoItem.description ? `Task description: ${composerTodoItem.description}` : null,
-          `Current task reference: ${todoReference}.`,
-        ]
-      : [
-          `Current cloud project: ${composerCloudProject.name} (id=${composerCloudProject.id}).`,
-          'No specific task is selected.',
-          `Current project reference: ${projectReference}.`,
-        ]
-    return {
-      cloudCollaboration: {
-        kind: 'application',
-        value: [
-          ...scope.filter((line): line is string => Boolean(line)),
-          'When the user refers to “this project” or “this task”, use this current cloud context.',
-          'Use the wegent_delivery MCP tools to inspect task details, shared files, and deliveries when needed. Do not ask for an id that is already provided here.',
-        ].join('\n'),
-      },
-    }
-  }, [composerCloudProject, composerTodoItem])
+  const defaultCloudProjectSelectionKey = `${paneKey}:${currentProject?.id ?? 'none'}`
+  const cloudAdditionalContext = useMemo(
+    () => cloudProjectAdditionalContext(composerCloudProject, composerTodoItem),
+    [composerCloudProject, composerTodoItem]
+  )
   const setPendingCloudContext = useCallback(
     (project: CloudProject | null, item: CloudLoopItem | null) => {
-      pendingTodoBinding = project ? { project, item, target: null } : null
+      pendingTodoBinding = project ? { project, item, target: null, description: '' } : null
       setPendingCloudProject(project)
       setPendingTodoItemState(item)
     },
@@ -648,14 +695,46 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
   const submitPaneInput = useCallback(
     (value?: string, options?: { guideWhenBusy?: boolean; interruptWhenBusy?: boolean }) => {
       const supervisorConfig = currentRuntimeTask ? null : pendingSupervisorConfig
+      const description = value ?? paneSession.input
+      const cachedProject =
+        !currentRuntimeTask &&
+        localProjectId &&
+        dismissedDefaultCloudProjectKey !== defaultCloudProjectSelectionKey
+          ? readCachedAutoJoinProjectSpace(localProjectId, localProjectDeviceId)
+          : null
+      const submissionProject = currentRuntimeTask ? null : (pendingCloudProject ?? cachedProject)
+      const submissionItem =
+        submissionProject?.id === pendingCloudProject?.id ? pendingTodoItem : null
+      if (!currentRuntimeTask) {
+        setPendingCloudContext(submissionProject, submissionItem)
+        pendingAutoJoinResolutionRef.current =
+          !submissionProject &&
+          Boolean(localProjectId) &&
+          dismissedDefaultCloudProjectKey !== defaultCloudProjectSelectionKey &&
+          projectSpaceBindingApis(services).length > 0
+            ? { target: null, description }
+            : null
+      }
+      if (pendingTodoBinding) {
+        pendingTodoBinding = { ...pendingTodoBinding, description }
+      }
       return sendPaneInput(value, {
         ...options,
-        additionalContext: cloudAdditionalContext,
+        additionalContext:
+          cloudProjectAdditionalContext(submissionProject, submissionItem) ??
+          cloudAdditionalContext,
+        cloudProjectId: submissionProject?.id,
         initialSupervisor: supervisorConfig,
         onRuntimeTaskCreated: address => {
           if (pendingTodoBinding) {
             pendingTodoBinding = { ...pendingTodoBinding, target: address }
           }
+          if (pendingAutoJoinResolutionRef.current) {
+            pendingAutoJoinResolutionRef.current = {
+              ...pendingAutoJoinResolutionRef.current,
+              target: address,
+            }
+          }
         },
         onRuntimeTaskReady: () => {
           if (supervisorConfig) {
@@ -664,7 +743,21 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
         },
       })
     },
-    [cloudAdditionalContext, currentRuntimeTask, pendingSupervisorConfig, sendPaneInput]
+    [
+      cloudAdditionalContext,
+      currentRuntimeTask,
+      defaultCloudProjectSelectionKey,
+      dismissedDefaultCloudProjectKey,
+      localProjectDeviceId,
+      localProjectId,
+      paneSession.input,
+      pendingCloudProject,
+      pendingTodoItem,
+      pendingSupervisorConfig,
+      sendPaneInput,
+      services,
+      setPendingCloudContext,
+    ]
   )
 
   const setTaskSupervisor = useCallback(
@@ -721,6 +814,14 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
     [currentRuntimeTask, runtimeWorkApi, submitPaneInput, t]
   )
 
+  const projectSpaceApiFor = useCallback(
+    (project: CloudProject): NonNullable<WorkbenchServices['deliveryApi']> | undefined =>
+      project.project_store === 'local' || project.task_provider === 'dingtalk_aitable'
+        ? (services?.projectSpaceApis?.local ?? services?.deliveryApi)
+        : (services?.projectSpaceApis?.cloud ?? services?.deliveryApi),
+    [services?.deliveryApi, services?.projectSpaceApis?.cloud, services?.projectSpaceApis?.local]
+  )
+
   useEffect(() => {
     let active = true
     if (!currentRuntimeTask) {
@@ -734,9 +835,9 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
         active = false
       }
     }
-    if (services?.deliveryApi) {
-      void services.deliveryApi
-        .findCloudContextForTask(currentRuntimeTask)
+    const contextApis = projectSpaceBindingApis(services)
+    if (contextApis.length > 0) {
+      void findProjectSpaceContextForTask(contextApis, currentRuntimeTask)
         .then(context => {
           if (!active) return
           setBoundCloudProject(context.project)
@@ -774,26 +875,42 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
     return () => {
       active = false
     }
-  }, [currentRuntimeTask, services?.deliveryApi, state.user?.id])
+  }, [currentRuntimeTask, services, state.user?.id])
 
   useEffect(() => {
-    if (!currentRuntimeTask || !pendingCloudProject || !services?.deliveryApi) return
+    const projectToBind = pendingCloudProject ?? pendingTodoBinding?.project ?? null
+    const itemToBind = pendingTodoItem ?? pendingTodoBinding?.item ?? null
+    if (!currentRuntimeTask || !projectToBind) return
+    const pendingBinding = pendingTodoBinding
+    if (
+      pendingBinding?.target &&
+      (pendingBinding.target.deviceId !== currentRuntimeTask.deviceId ||
+        pendingBinding.target.taskId !== currentRuntimeTask.taskId)
+    ) {
+      return
+    }
+    const api = projectSpaceApiFor(projectToBind)
+    if (!api) return
+    const bindingTaskTitle =
+      truncateRuntimeTaskTitle(pendingBinding?.description) ||
+      t('workbench.untitled_task', '未命名任务')
     let active = true
-    const bindingRequest = pendingTodoItem
-      ? services.deliveryApi.bindTask(pendingTodoItem.id, currentRuntimeTask, runtimeTaskTitle)
-      : services.deliveryApi.bindProjectTask(
-          pendingCloudProject.id,
+    const bindingRequest = itemToBind
+      ? api
+          .bindTask(itemToBind.id, currentRuntimeTask, bindingTaskTitle)
+          .then(() => ({ item: itemToBind }))
+      : api.trackProjectTask(
+          projectToBind.id,
           currentRuntimeTask,
-          runtimeTaskTitle
+          bindingTaskTitle,
+          pendingBinding?.description ?? ''
         )
     void bindingRequest
-      .then(() => {
+      .then(({ item }) => {
         if (!active) return
-        setBoundCloudProject(pendingCloudProject)
-        setBoundCloudItem(pendingTodoItem)
-        setDeliveryItem(
-          pendingTodoItem ? cloudItemAsLocalWorkItem(pendingTodoItem, currentRuntimeTask) : null
-        )
+        setBoundCloudProject(projectToBind)
+        setBoundCloudItem(item)
+        setDeliveryItem(cloudItemAsLocalWorkItem(item, currentRuntimeTask))
         pendingTodoBinding = null
         setPendingCloudContext(null, null)
       })
@@ -812,8 +929,7 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
     currentRuntimeTask,
     pendingCloudProject,
     pendingTodoItem,
-    runtimeTaskTitle,
-    services?.deliveryApi,
+    projectSpaceApiFor,
     setPendingCloudContext,
     t,
   ])
@@ -907,31 +1023,155 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
       ? cloudMentionState.candidates
       : []
 
-  // Accessible cloud projects power the @ 项目空间 entry even when the current
-  // session is not bound to a cloud project yet.
+  useEffect(() => {
+    const refresh = () => {
+      setLocalBindingRevision(revision => revision + 1)
+      if (
+        currentRuntimeTask ||
+        !localProjectId ||
+        dismissedDefaultCloudProjectKey === defaultCloudProjectSelectionKey
+      ) {
+        return
+      }
+      const cachedProject = readCachedAutoJoinProjectSpace(localProjectId, localProjectDeviceId)
+      if (cachedProject) {
+        setPendingCloudContext(cachedProject, null)
+      } else if (pendingCloudProject?.id === defaultCloudProjectId) {
+        setPendingCloudContext(null, null)
+      }
+    }
+    window.addEventListener(PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT, refresh)
+    return () => window.removeEventListener(PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT, refresh)
+  }, [
+    currentRuntimeTask,
+    defaultCloudProjectId,
+    defaultCloudProjectSelectionKey,
+    dismissedDefaultCloudProjectKey,
+    localProjectDeviceId,
+    localProjectId,
+    pendingCloudProject?.id,
+    setPendingCloudContext,
+  ])
+
+  // A local project association limits the project spaces offered to new tasks.
+  // The default association is a preselection only; the selected task is still
+  // the sole unit that enters the project board.
   useEffect(() => {
     let active = true
-    const api = services?.deliveryApi
-    if (!api) {
+    const apis = [
+      services?.projectSpaceApis?.local,
+      services?.projectSpaceApis?.cloud,
+      services?.deliveryApi,
+    ].filter(
+      (api, index, candidates): api is NonNullable<typeof api> =>
+        Boolean(api) && candidates.indexOf(api) === index
+    )
+    if (!apis.length) {
       queueMicrotask(() => {
-        if (active) setCloudProjects([])
+        if (active) {
+          setCloudProjects([])
+          setDefaultCloudProjectId(null)
+        }
       })
       return () => {
         active = false
       }
     }
-    void api
-      .listCloudProjects()
-      .then(result => {
-        if (active) setCloudProjects(result.items)
+    const deviceId = localProjectDeviceId
+    type AssociatedProject = {
+      project: CloudProject
+      binding: CloudProjectLocalBinding | null
+    }
+    void Promise.allSettled(
+      apis.map(async (api): Promise<AssociatedProject[]> => {
+        const result = await api.listCloudProjects()
+        if (!localProjectId) {
+          return result.items.map(project => ({ project, binding: null }))
+        }
+        const candidates = await Promise.all(
+          result.items.map(async project => {
+            const bindings = await api.listLocalBindings(project.id)
+            const binding =
+              bindings.find(
+                candidate =>
+                  candidate.local_project_id === localProjectId && candidate.device_id === deviceId
+              ) ??
+              bindings.find(
+                candidate => candidate.local_project_id === localProjectId && !candidate.device_id
+              ) ??
+              null
+            return { project, binding }
+          })
+        )
+        return candidates.filter(candidate => Boolean(candidate.binding))
+      })
+    )
+      .then(results => {
+        if (!active) return
+        const candidates = results.flatMap(result =>
+          result.status === 'fulfilled' ? result.value : []
+        )
+        const uniqueProjects = candidates.filter(
+          (candidate, index) =>
+            candidates.findIndex(
+              other =>
+                other.project.id === candidate.project.id &&
+                other.project.project_store === candidate.project.project_store
+            ) === index
+        )
+        const defaultProject = uniqueProjects.find(candidate => candidate.binding?.is_default)
+        setCloudProjects(uniqueProjects.map(candidate => candidate.project))
+        setDefaultCloudProjectId(defaultProject?.project.id ?? null)
+        if (defaultProject && localProjectId) {
+          cacheAutoJoinProjectSpace(localProjectId, deviceId, defaultProject.project)
+        }
+        const pendingAutoJoin = pendingAutoJoinResolutionRef.current
+        const pendingTargetMatchesCurrentTask =
+          pendingAutoJoin?.target &&
+          currentRuntimeTask &&
+          pendingAutoJoin.target.deviceId === currentRuntimeTask.deviceId &&
+          pendingAutoJoin.target.taskId === currentRuntimeTask.taskId
+        if (
+          defaultProject &&
+          !pendingCloudProject &&
+          dismissedDefaultCloudProjectKey !== defaultCloudProjectSelectionKey &&
+          (!currentRuntimeTask || pendingTargetMatchesCurrentTask)
+        ) {
+          pendingTodoBinding = {
+            project: defaultProject.project,
+            item: null,
+            target: pendingAutoJoin?.target ?? null,
+            description: pendingAutoJoin?.description ?? '',
+          }
+          pendingAutoJoinResolutionRef.current = null
+          setPendingCloudProject(defaultProject.project)
+          setPendingTodoItemState(null)
+        } else if (!defaultProject && pendingAutoJoin) {
+          pendingAutoJoinResolutionRef.current = null
+        }
       })
       .catch(() => {
-        if (active) setCloudProjects([])
+        if (active) {
+          setCloudProjects([])
+          setDefaultCloudProjectId(null)
+        }
       })
     return () => {
       active = false
     }
-  }, [services?.deliveryApi])
+  }, [
+    currentRuntimeTask,
+    defaultCloudProjectSelectionKey,
+    dismissedDefaultCloudProjectKey,
+    localBindingRevision,
+    localProjectDeviceId,
+    localProjectId,
+    pendingCloudProject,
+    services?.deliveryApi,
+    services?.projectSpaceApis?.cloud,
+    services?.projectSpaceApis?.local,
+    setPendingCloudContext,
+  ])
   const cloudProjectMentionCandidates = useMemo<ComposerCloudMentionCandidate[]>(
     () =>
       cloudProjects.map(project => {
@@ -941,6 +1181,10 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
           key: `cloud-project-space:${project.id}`,
           title: project.name,
           description: project.description || project.project_key || undefined,
+          statusLabel:
+            project.id === defaultCloudProjectId
+              ? t('workbench.project_space_auto_join', '自动加入')
+              : undefined,
           metaLabel: t('workbench.mention_cloud_space', '云空间'),
           testId: `cloud-project-space-${String(project.id).replace(/[^a-zA-Z0-9_-]/g, '-')}`,
           enabled: true,
@@ -957,7 +1201,7 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
           project,
         }
       }),
-    [cloudProjects, t]
+    [cloudProjects, defaultCloudProjectId, t]
   )
   const bindComposerCloudProject = useCallback(
     (project: CloudProject, notice: string) => {
@@ -966,7 +1210,7 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
         setPendingCloudContext(project, null)
         return
       }
-      const api = services?.deliveryApi
+      const api = projectSpaceApiFor(project)
       if (!api) return
       void api
         .bindProjectTask(project.id, currentRuntimeTask, runtimeTaskTitle)
@@ -983,10 +1227,11 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
           )
         })
     },
-    [currentRuntimeTask, runtimeTaskTitle, services?.deliveryApi, setPendingCloudContext, t]
+    [currentRuntimeTask, projectSpaceApiFor, runtimeTaskTitle, setPendingCloudContext, t]
   )
   const handleSelectCloudProject = useCallback(
     (project: CloudProject) => {
+      setDismissedDefaultCloudProjectKey(null)
       bindComposerCloudProject(
         project,
         t('workbench.cloud_project_bound_notice', { name: project.name })
@@ -994,6 +1239,26 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
     },
     [bindComposerCloudProject, t]
   )
+  const pendingProjectSpaceContext =
+    !currentRuntimeTask && pendingCloudProject ? (
+      <ComposerModePill
+        label={t('workbench.project_space_context_pending', '加入看板 · {{name}}', {
+          name: pendingCloudProject.name,
+        })}
+        icon={LayoutDashboard}
+        testId="project-space-context-pill"
+        cancelTestId="clear-project-space-context-button"
+        cancelLabel={t('workbench.clear_project_space_context', '不加入项目看板')}
+        onCancel={() => {
+          setDismissedDefaultCloudProjectKey(defaultCloudProjectSelectionKey)
+          setPendingCloudContext(null, null)
+        }}
+        title={t(
+          'workbench.project_space_context_pending_title',
+          '发送后会在该项目空间的看板中创建任务'
+        )}
+      />
+    ) : null
 
   const activeDeliveryItem =
     currentRuntimeTask &&
@@ -2589,6 +2854,8 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
                                       experimentalFeaturesEnabled && Boolean(services?.deliveryApi)
                                     }
                                     onSelectCloudProject={handleSelectCloudProject}
+                                    selectedCloudProjectId={composerCloudProject?.id}
+                                    toolbarLeadingContext={pendingProjectSpaceContext}
                                     isStreaming={paneIsBusy}
                                     onPause={pauseCurrentResponse}
                                     onCompactContext={compactCurrentContext}
@@ -2750,6 +3017,8 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
                         experimentalFeaturesEnabled && Boolean(services?.deliveryApi)
                       }
                       onSelectCloudProject={handleSelectCloudProject}
+                      selectedCloudProjectId={composerCloudProject?.id}
+                      toolbarLeadingContext={pendingProjectSpaceContext}
                       isStreaming={paneIsBusy}
                       onPause={pauseCurrentResponse}
                       onCompactContext={compactCurrentContext}
@@ -3009,9 +3278,9 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
               onDelivered={() => void finishLocalDelivery()}
             />
           )}
-        {todoBindingPickerOpen && services?.deliveryApi && (
+        {todoBindingPickerOpen && todoBindingApis.length > 0 && (
           <TodoBindingPicker
-            api={services.deliveryApi}
+            apis={todoBindingApis}
             runtimeTask={currentRuntimeTask ?? undefined}
             runtimeTaskTitle={runtimeTaskTitle}
             currentProject={currentRuntimeTask ? boundCloudProject : pendingCloudProject}
diff --git a/wework/src/components/projects/LocalProjectEditDialog.test.tsx b/wework/src/components/projects/LocalProjectEditDialog.test.tsx
index f1860c8042..bbf4df208a 100644
--- a/wework/src/components/projects/LocalProjectEditDialog.test.tsx
+++ b/wework/src/components/projects/LocalProjectEditDialog.test.tsx
@@ -1,7 +1,9 @@
-import { render, screen } from '@testing-library/react'
+import { render, screen, waitFor } from '@testing-library/react'
 import userEvent from '@testing-library/user-event'
 import { describe, expect, test, vi } from 'vitest'
 import '@/i18n'
+import type { ProjectSpaceBindingApi } from '@/features/todo/projectSpaceLocalBindings'
+import { runtimeProjectUiId } from '@/lib/runtime-project'
 import { LocalProjectEditDialog } from './LocalProjectEditDialog'
 
 const pickerMocks = vi.hoisted(() => ({
@@ -88,4 +90,64 @@ describe('LocalProjectEditDialog', () => {
     await userEvent.click(screen.getByTestId('delete-local-project-button'))
     expect(onDelete).toHaveBeenCalledTimes(1)
   })
+
+  test('configures whether new conversations automatically join a project space', async () => {
+    const localProjectId = runtimeProjectUiId(projectWork.project)
+    const binding = {
+      id: 'binding-1',
+      cloud_project_id: 'space-1',
+      local_project_id: localProjectId,
+      device_id: 'local-device',
+      is_default: true,
+      created_at: '2026-08-04T00:00:00Z',
+      updated_at: '2026-08-04T00:00:00Z',
+    }
+    const updateLocalBinding = vi.fn().mockResolvedValue({ ...binding, is_default: false })
+    const projectSpaceApi = {
+      listCloudProjects: vi.fn().mockResolvedValue({
+        items: [
+          {
+            id: 'space-1',
+            public_id: 'space-public-1',
+            project_key: 'FOLLOWUP',
+            name: 'Task Follow-up Board',
+            description: '',
+            project_store: 'local',
+            task_provider: 'local',
+            provider_config: {},
+            created_by_user_id: 1,
+            status: 'active',
+            tags: [],
+            version: 1,
+            created_at: '2026-08-04T00:00:00Z',
+            updated_at: '2026-08-04T00:00:00Z',
+          },
+        ],
+      }),
+      listLocalBindings: vi.fn().mockResolvedValue([binding]),
+      updateLocalBinding,
+      addLocalBinding: vi.fn(),
+    } as unknown as ProjectSpaceBindingApi
+
+    render(
+      <LocalProjectEditDialog
+        {...folderPickerProps}
+        open
+        projectWork={projectWork}
+        projectSpaceApis={[projectSpaceApi]}
+        onClose={vi.fn()}
+        onSave={vi.fn().mockResolvedValue(undefined)}
+        onDelete={vi.fn()}
+      />
+    )
+
+    const select = await screen.findByTestId('local-project-auto-join-space-select')
+    await waitFor(() => expect(select).toHaveValue('local:space-1'))
+    await userEvent.selectOptions(select, '')
+    await userEvent.click(screen.getByTestId('save-local-project-button'))
+
+    expect(updateLocalBinding).toHaveBeenCalledWith('space-1', 'binding-1', {
+      is_default: false,
+    })
+  })
 })
diff --git a/wework/src/components/projects/LocalProjectEditDialog.tsx b/wework/src/components/projects/LocalProjectEditDialog.tsx
index 7d49cb397f..bed709d6d3 100644
--- a/wework/src/components/projects/LocalProjectEditDialog.tsx
+++ b/wework/src/components/projects/LocalProjectEditDialog.tsx
@@ -1,10 +1,18 @@
-import { Folder, FolderPlus, Loader2, X } from 'lucide-react'
-import { useMemo, useState } from 'react'
+import { Folder, FolderPlus, LayoutDashboard, Loader2, X } from 'lucide-react'
+import { useEffect, useMemo, useState } from 'react'
 import { createPortal } from 'react-dom'
 import { shouldUseNativeProjectDirectoryPicker } from '@/e2e/automation'
+import {
+  cacheAutoJoinProjectSpace,
+  loadProjectSpaceBindingOptions,
+  saveAutoJoinProjectSpace,
+  type ProjectSpaceBindingApi,
+  type ProjectSpaceBindingOption,
+} from '@/features/todo/projectSpaceLocalBindings'
 import { useEscapeKey } from '@/hooks/useEscapeKey'
 import { useTranslation } from '@/hooks/useTranslation'
 import { openNativeProjectDirectoryPickers } from '@/lib/native-directory-picker'
+import { runtimeProjectUiId } from '@/lib/runtime-project'
 import type { DeviceInfo, RuntimeProjectWork } from '@/types/api'
 import { DeviceFolderPicker } from './DeviceFolderPicker'
 
@@ -15,6 +23,7 @@ interface LocalProjectEditDialogProps {
   onGetDeviceHomeDirectory: (deviceId: string) => Promise<string>
   onListDeviceDirectories: (deviceId: string, path: string) => Promise<string[]>
   onCreateDeviceDirectory: (deviceId: string, path: string) => Promise<void>
+  projectSpaceApis?: ProjectSpaceBindingApi[]
   onClose: () => void
   onSave: (data: {
     deviceId: string
@@ -41,6 +50,7 @@ export function LocalProjectEditDialog({
   onGetDeviceHomeDirectory,
   onListDeviceDirectories,
   onCreateDeviceDirectory,
+  projectSpaceApis,
   onClose,
   onSave,
   onDelete,
@@ -54,6 +64,7 @@ export function LocalProjectEditDialog({
       onGetDeviceHomeDirectory={onGetDeviceHomeDirectory}
       onListDeviceDirectories={onListDeviceDirectories}
       onCreateDeviceDirectory={onCreateDeviceDirectory}
+      projectSpaceApis={projectSpaceApis}
       onClose={onClose}
       onSave={onSave}
       onDelete={onDelete}
@@ -67,6 +78,7 @@ function LocalProjectEditDialogContent({
   onGetDeviceHomeDirectory,
   onListDeviceDirectories,
   onCreateDeviceDirectory,
+  projectSpaceApis = [],
   onClose,
   onSave,
   onDelete,
@@ -87,13 +99,45 @@ function LocalProjectEditDialogContent({
   const [submitting, setSubmitting] = useState(false)
   const [showFolderPicker, setShowFolderPicker] = useState(false)
   const [error, setError] = useState<string | null>(null)
+  const [projectSpaceOptions, setProjectSpaceOptions] = useState<ProjectSpaceBindingOption[]>([])
+  const [autoJoinProjectSpaceKey, setAutoJoinProjectSpaceKey] = useState<string | null>(null)
+  const [initialAutoJoinProjectSpaceKey, setInitialAutoJoinProjectSpaceKey] = useState<
+    string | null
+  >(null)
+  const [projectSpacesLoading, setProjectSpacesLoading] = useState(projectSpaceApis.length > 0)
   const deviceId =
     projectWork.project.stateDeviceId?.trim() ||
     projectWork.deviceWorkspaces[0]?.deviceId.trim() ||
     ''
+  const localProjectId = runtimeProjectUiId(projectWork.project)
 
   useEscapeKey(onClose, !submitting)
 
+  useEffect(() => {
+    if (projectSpaceApis.length === 0) return
+    let active = true
+    void loadProjectSpaceBindingOptions(projectSpaceApis, localProjectId, deviceId || undefined)
+      .then(options => {
+        if (!active) return
+        const selectedKey = options.find(option => option.binding?.is_default)?.key ?? null
+        const selectedProject = options.find(option => option.key === selectedKey)?.project ?? null
+        cacheAutoJoinProjectSpace(localProjectId, deviceId || undefined, selectedProject)
+        setProjectSpaceOptions(options)
+        setAutoJoinProjectSpaceKey(selectedKey)
+        setInitialAutoJoinProjectSpaceKey(selectedKey)
+      })
+      .catch(loadError => {
+        if (!active) return
+        setError(loadError instanceof Error ? loadError.message : String(loadError))
+      })
+      .finally(() => {
+        if (active) setProjectSpacesLoading(false)
+      })
+    return () => {
+      active = false
+    }
+  }, [deviceId, localProjectId, projectSpaceApis])
+
   const addFolders = async () => {
     if (!shouldUseNativeProjectDirectoryPicker()) {
       setShowFolderPicker(true)
@@ -119,6 +163,14 @@ function LocalProjectEditDialogContent({
         name: trimmedName,
         roots,
       })
+      if (autoJoinProjectSpaceKey !== initialAutoJoinProjectSpaceKey) {
+        await saveAutoJoinProjectSpace(
+          projectSpaceOptions,
+          autoJoinProjectSpaceKey,
+          localProjectId,
+          deviceId || undefined
+        )
+      }
       onClose()
     } catch (saveError) {
       setError(saveError instanceof Error ? saveError.message : String(saveError))
@@ -237,6 +289,43 @@ function LocalProjectEditDialogContent({
           )}
         </div>
 
+        {projectSpaceApis.length > 0 && (
+          <>
+            <h3 className="mt-5 text-base font-medium">
+              {t('workbench.project_auto_join_space', '自动加入项目空间')}
+            </h3>
+            <p className="mt-1 text-sm text-text-secondary">
+              {t(
+                'workbench.project_auto_join_space_description',
+                '在这个项目里开启的新对话会默认加入所选项目空间，并在发送前明确显示。'
+              )}
+            </p>
+            <label className="mt-2 flex h-11 items-center rounded-xl border border-border bg-background focus-within:border-primary focus-within:ring-2 focus-within:ring-primary/10">
+              <LayoutDashboard className="mx-3 h-4 w-4 shrink-0 text-text-secondary" />
+              <span className="h-full w-px bg-border" />
+              <select
+                data-testid="local-project-auto-join-space-select"
+                aria-label={t('workbench.project_auto_join_space', '自动加入项目空间')}
+                value={autoJoinProjectSpaceKey ?? ''}
+                disabled={submitting || projectSpacesLoading}
+                onChange={event => setAutoJoinProjectSpaceKey(event.target.value || null)}
+                className="min-w-0 flex-1 bg-transparent px-3 text-base outline-none"
+              >
+                <option value="">
+                  {projectSpacesLoading
+                    ? t('workbench.loading', '加载中...')
+                    : t('workbench.project_auto_join_space_none', '不自动加入')}
+                </option>
+                {projectSpaceOptions.map(option => (
+                  <option key={option.key} value={option.key}>
+                    {option.project.name}
+                  </option>
+                ))}
+              </select>
+            </label>
+          </>
+        )}
+
         {error && <p className="mt-3 text-sm text-red-500">{error}</p>}
         <div className="mt-5 flex items-center gap-3">
           <button
@@ -261,7 +350,9 @@ function LocalProjectEditDialogContent({
           <button
             type="button"
             data-testid="save-local-project-button"
-            disabled={submitting || !name.trim() || roots.length === 0 || !deviceId}
+            disabled={
+              submitting || projectSpacesLoading || !name.trim() || roots.length === 0 || !deviceId
+            }
             onClick={() => void save()}
             className="inline-flex h-9 items-center gap-2 rounded-lg bg-text-primary px-4 text-sm font-medium text-background hover:bg-text-primary/90 disabled:opacity-50"
           >
diff --git a/wework/src/features/todo/CloudProjectManageView.tsx b/wework/src/features/todo/CloudProjectManageView.tsx
index faf56e7c83..af24160766 100644
--- a/wework/src/features/todo/CloudProjectManageView.tsx
+++ b/wework/src/features/todo/CloudProjectManageView.tsx
@@ -5,12 +5,17 @@ import type { DwsApi, DwsAuthStatus } from '@/api/dws'
 import type {
   CloudLoopItem,
   CloudProject,
+  CloudProjectLocalBinding,
   CloudProjectMember,
   CloudUserSearchItem,
 } from '@/api/deliveries'
+import { PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT } from '@/api/deliveries'
+import { cacheAutoJoinProjectSpace } from './projectSpaceLocalBindings'
 import { ActionMenu } from '@/components/common/ActionMenu'
 import type { WorkbenchServices } from '@/features/workbench/workbenchServices'
+import { useTranslation } from '@/hooks/useTranslation'
 import { cn } from '@/lib/utils'
+import type { ProjectWithTasks } from '@/types/api'
 import { BoardLayoutEditor } from './BoardLayoutEditor'
 import type { BoardCardDisplaySettings } from './CloudTodoBoardCard'
 import {
@@ -58,6 +63,7 @@ export function CloudProjectManageView({
   aitableApi,
   dwsApi,
   project,
+  localProjects,
   boardCardDisplay,
   onProjectUpdated,
 }: {
@@ -65,9 +71,11 @@ export function CloudProjectManageView({
   aitableApi?: AITableApi
   dwsApi?: DwsApi
   project: CloudProject
+  localProjects: ProjectWithTasks[]
   boardCardDisplay?: BoardCardDisplaySettings
   onProjectUpdated?: (project: CloudProject) => void
 }) {
+  const { t } = useTranslation('common')
   const [version, setVersion] = useState(project.version)
   const [error, setError] = useState<string | null>(null)
   const [members, setMembers] = useState<CloudProjectMember[]>([])
@@ -76,6 +84,11 @@ export function CloudProjectManageView({
   const [display, setDisplay] = useState(() => initialDisplay(project, boardCardDisplay))
   const [statuses, setStatuses] = useState<BoardStatuses>(project.board_config?.statuses ?? [])
   const [visibility, setVisibility] = useState(project.visibility ?? 'private')
+  const [localBindings, setLocalBindings] = useState<CloudProjectLocalBinding[]>([])
+  const [selectedLocalProjectId, setSelectedLocalProjectId] = useState<number | null>(
+    localProjects[0]?.id ?? null
+  )
+  const [bindingBusyId, setBindingBusyId] = useState<number | null>(null)
 
   const [membersOpen, setMembersOpen] = useState(false)
   const [memberQuery, setMemberQuery] = useState('')
@@ -110,11 +123,18 @@ export function CloudProjectManageView({
 
   useEffect(() => {
     let active = true
-    void Promise.all([api.listCloudProjectMembers(project.id), api.listLoopItems(project.id)])
-      .then(([nextMembers, response]) => {
+    void Promise.all([
+      api.listCloudProjectMembers(project.id),
+      api.listLoopItems(project.id),
+      typeof api.listLocalBindings === 'function'
+        ? api.listLocalBindings(project.id)
+        : Promise.resolve([]),
+    ])
+      .then(([nextMembers, response, bindings]) => {
         if (!active) return
         setMembers(nextMembers)
         setItems(response.items)
+        setLocalBindings(bindings)
       })
       .catch(cause => active && setError(cause instanceof Error ? cause.message : '加载项目失败'))
     return () => {
@@ -122,6 +142,48 @@ export function CloudProjectManageView({
     }
   }, [api, project.id])
 
+  async function addLocalProjectBinding() {
+    if (!selectedLocalProjectId || bindingBusyId !== null) return
+    setBindingBusyId(selectedLocalProjectId)
+    try {
+      const created = await api.addLocalBinding(project.id, {
+        local_project_id: selectedLocalProjectId,
+        is_default: false,
+      })
+      setLocalBindings(current => [...current, created])
+      window.dispatchEvent(new Event(PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT))
+    } catch (cause) {
+      setError(
+        cause instanceof Error
+          ? cause.message
+          : t('todo.local_binding_link_failed', '关联本地项目失败')
+      )
+    } finally {
+      setBindingBusyId(null)
+    }
+  }
+
+  async function removeLocalProjectBinding(binding: CloudProjectLocalBinding) {
+    if (bindingBusyId !== null) return
+    setBindingBusyId(binding.local_project_id)
+    try {
+      await api.deleteLocalBinding(project.id, binding.id)
+      if (binding.is_default) {
+        cacheAutoJoinProjectSpace(binding.local_project_id, binding.device_id, null)
+      }
+      setLocalBindings(current => current.filter(candidate => candidate.id !== binding.id))
+      window.dispatchEvent(new Event(PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT))
+    } catch (cause) {
+      setError(
+        cause instanceof Error
+          ? cause.message
+          : t('todo.local_binding_unlink_failed', '解除本地项目关联失败')
+      )
+    } finally {
+      setBindingBusyId(null)
+    }
+  }
+
   useEffect(() => {
     if (!isAITable || !aitableApi) return
     void aitableApi
@@ -392,6 +454,101 @@ export function CloudProjectManageView({
           <p className="mt-1 text-sm text-text-muted">管理项目成员、标签和看板布局。</p>
         </header>
 
+        <section className="border-t border-border py-6">
+          <div>
+            <h2 className="text-heading-md font-semibold">
+              {t('todo.local_binding_title', '关联本地项目')}
+            </h2>
+            <p className="mt-1 text-sm text-text-muted">
+              {t(
+                'todo.local_binding_description',
+                '关联后可从任务输入框的“+”菜单选择当前项目空间；自动加入请在本地项目设置中配置。'
+              )}
+            </p>
+          </div>
+          <div className="mt-4 space-y-2">
+            {localBindings.map(binding => {
+              const localProject = localProjects.find(
+                candidate => candidate.id === binding.local_project_id
+              )
+              return (
+                <div
+                  key={binding.id}
+                  data-testid={`cloud-project-local-binding-${binding.local_project_id}`}
+                  className="flex items-center gap-3 rounded-xl border border-border px-3 py-2.5"
+                >
+                  <span className="min-w-0 flex-1">
+                    <span className="block truncate text-sm font-medium">
+                      {localProject?.name ??
+                        t('todo.local_binding_project_fallback', '本地项目 #{{id}}', {
+                          id: binding.local_project_id,
+                        })}
+                    </span>
+                    <span className="block text-xs text-text-muted">
+                      {binding.device_id
+                        ? t('todo.local_binding_device', '设备 {{device}}', {
+                            device: binding.device_id,
+                          })
+                        : t('todo.local_binding_all_devices', '所有设备')}
+                    </span>
+                  </span>
+                  {binding.is_default && (
+                    <span
+                      data-testid={`cloud-project-local-binding-default-${binding.local_project_id}`}
+                      className="rounded-lg border border-text-primary bg-text-primary px-3 py-1.5 text-xs text-background"
+                    >
+                      {t('todo.local_binding_default', '自动加入')}
+                    </span>
+                  )}
+                  <button
+                    type="button"
+                    data-testid={`cloud-project-local-binding-remove-${binding.local_project_id}`}
+                    aria-label={t('todo.local_binding_unlink', '解除关联')}
+                    disabled={bindingBusyId !== null}
+                    onClick={() => void removeLocalProjectBinding(binding)}
+                    className="grid size-8 place-items-center rounded-lg text-text-muted hover:bg-muted hover:text-danger disabled:opacity-50"
+                  >
+                    <Trash2 className="size-4" />
+                  </button>
+                </div>
+              )
+            })}
+            {localProjects.some(
+              localProject =>
+                !localBindings.some(binding => binding.local_project_id === localProject.id)
+            ) ? (
+              <div className="flex gap-2 rounded-xl bg-muted p-2">
+                <select
+                  data-testid="cloud-project-local-binding-project"
+                  value={selectedLocalProjectId ?? ''}
+                  onChange={event => setSelectedLocalProjectId(Number(event.target.value) || null)}
+                  className="h-9 min-w-0 flex-1 rounded-lg border border-border bg-background px-2 text-sm outline-none"
+                >
+                  {localProjects
+                    .filter(
+                      localProject =>
+                        !localBindings.some(binding => binding.local_project_id === localProject.id)
+                    )
+                    .map(localProject => (
+                      <option key={localProject.id} value={localProject.id}>
+                        {localProject.name}
+                      </option>
+                    ))}
+                </select>
+                <button
+                  type="button"
+                  data-testid="cloud-project-local-binding-add"
+                  disabled={!selectedLocalProjectId || bindingBusyId !== null}
+                  onClick={() => void addLocalProjectBinding()}
+                  className="h-9 rounded-lg px-3 text-xs text-text-secondary hover:bg-background disabled:opacity-50"
+                >
+                  {t('todo.local_binding_link', '关联')}
+                </button>
+              </div>
+            ) : null}
+          </div>
+        </section>
+
         <section className="border-t border-border py-6">
           <div className="flex items-start justify-between gap-4">
             <div>
diff --git a/wework/src/features/todo/CloudTodoWorkspace.tsx b/wework/src/features/todo/CloudTodoWorkspace.tsx
index fe75f1836a..e7223e97bc 100644
--- a/wework/src/features/todo/CloudTodoWorkspace.tsx
+++ b/wework/src/features/todo/CloudTodoWorkspace.tsx
@@ -1909,6 +1909,7 @@ export function CloudTodoWorkspace({
                   aitableApi={aitableApi}
                   dwsApi={services.dwsApi}
                   project={selectedProject}
+                  localProjects={localProjects}
                   boardCardDisplay={boardCardDisplay}
                   onProjectUpdated={updated =>
                     setProjects(current =>
diff --git a/wework/src/features/todo/TodoBindingPicker.test.tsx b/wework/src/features/todo/TodoBindingPicker.test.tsx
index 41aff38dcb..ecf1cbb1e1 100644
--- a/wework/src/features/todo/TodoBindingPicker.test.tsx
+++ b/wework/src/features/todo/TodoBindingPicker.test.tsx
@@ -5,13 +5,17 @@ import type { WorkbenchServices } from '@/features/workbench/workbenchServices'
 import { TodoBindingPicker } from './TodoBindingPicker'
 
 const project = {
-  id: 1,
+  id: '1',
   public_id: 'project-1',
   project_key: 'WEG',
   name: 'Wegent',
   description: '',
+  project_store: 'backend' as const,
+  task_provider: 'local',
+  provider_config: {},
   created_by_user_id: 1,
   status: 'active',
+  tags: [],
   version: 1,
   created_at: '2026-07-22T00:00:00Z',
   updated_at: '2026-07-22T00:00:00Z',
@@ -19,8 +23,9 @@ const project = {
 
 const item = {
   id: 'WEG-1',
-  cloud_project_id: 1,
+  cloud_project_id: '1',
   sequence_number: 1,
+  parent_id: null,
   created_by_user_id: 1,
   assignee_user_id: null,
   title: 'Cloud TODO',
@@ -28,6 +33,7 @@ const item = {
   status: 'inbox' as const,
   priority: 'none' as const,
   due_at: null,
+  tags: [],
   sort_order: 0,
   current_delivery_id: null,
   version: 1,
@@ -54,7 +60,7 @@ describe('TodoBindingPicker', () => {
     const onBound = vi.fn()
     render(
       <TodoBindingPicker
-        api={deliveryApi}
+        apis={[deliveryApi]}
         runtimeTask={{ deviceId: 'local-device', taskId: 'task-1' }}
         currentProject={null}
         currentItem={null}
@@ -79,7 +85,7 @@ describe('TodoBindingPicker', () => {
     const onBound = vi.fn()
     render(
       <TodoBindingPicker
-        api={deliveryApi}
+        apis={[deliveryApi]}
         runtimeTask={{ deviceId: 'local-device', taskId: 'task-1' }}
         currentProject={project}
         currentItem={item}
@@ -102,7 +108,7 @@ describe('TodoBindingPicker', () => {
     const onBound = vi.fn()
     const view = render(
       <TodoBindingPicker
-        api={deliveryApi}
+        apis={[deliveryApi]}
         currentProject={null}
         currentItem={null}
         onClose={vi.fn()}
@@ -117,7 +123,7 @@ describe('TodoBindingPicker', () => {
 
     view.rerender(
       <TodoBindingPicker
-        api={deliveryApi}
+        apis={[deliveryApi]}
         currentProject={project}
         currentItem={item}
         onClose={vi.fn()}
@@ -135,7 +141,7 @@ describe('TodoBindingPicker', () => {
     const onBound = vi.fn()
     render(
       <TodoBindingPicker
-        api={deliveryApi}
+        apis={[deliveryApi]}
         runtimeTask={{ deviceId: 'local-device', taskId: 'task-1' }}
         currentProject={null}
         currentItem={null}
@@ -153,4 +159,85 @@ describe('TodoBindingPicker', () => {
     )
     expect(onBound).toHaveBeenCalledWith(project, null)
   })
+
+  it('lists local and cloud project spaces and binds through the selected local API', async () => {
+    const cloudApi = api()
+    const localProject = {
+      ...project,
+      id: 'local-project',
+      public_id: 'local-project-public',
+      project_key: 'LOCAL',
+      name: 'Local Project Space',
+      project_store: 'local' as const,
+    }
+    const localItem = {
+      ...item,
+      id: 'LOCAL-1',
+      cloud_project_id: localProject.id,
+      title: 'Local TODO',
+    }
+    const localApi = {
+      ...api(),
+      listCloudProjects: vi.fn(async () => ({ items: [localProject] })),
+      listLoopItems: vi.fn(async () => ({ items: [localItem] })),
+    }
+    const onBound = vi.fn()
+
+    render(
+      <TodoBindingPicker
+        apis={[localApi, cloudApi]}
+        runtimeTask={{ deviceId: 'local-device', taskId: 'task-1' }}
+        currentProject={null}
+        currentItem={null}
+        onClose={vi.fn()}
+        onBound={onBound}
+      />
+    )
+
+    const select = await screen.findByTestId('todo-binding-project')
+    expect(select).toHaveTextContent('Local Project Space')
+    expect(select).toHaveTextContent('Wegent')
+    await userEvent.selectOptions(select, 'local:local-project')
+    await userEvent.click(screen.getByTestId('todo-binding-project-only'))
+
+    expect(localApi.bindProjectTask).toHaveBeenCalledWith(
+      localProject.id,
+      { deviceId: 'local-device', taskId: 'task-1' },
+      undefined
+    )
+    expect(cloudApi.bindProjectTask).not.toHaveBeenCalled()
+    expect(onBound).toHaveBeenCalledWith(localProject, null)
+  })
+
+  it('keeps local project spaces visible when loading their tasks fails', async () => {
+    const localProject = {
+      ...project,
+      id: 'local-project',
+      public_id: 'local-project-public',
+      project_key: 'LOCAL',
+      name: 'Local Project Space',
+      project_store: 'local' as const,
+    }
+    const localApi = {
+      ...api(),
+      listCloudProjects: vi.fn(async () => ({ items: [localProject] })),
+      listLoopItems: vi.fn(async () => {
+        throw new Error('Local task list unavailable')
+      }),
+    }
+
+    render(
+      <TodoBindingPicker
+        apis={[localApi]}
+        currentProject={null}
+        currentItem={null}
+        onClose={vi.fn()}
+        onBound={vi.fn()}
+      />
+    )
+
+    expect(await screen.findByTestId('todo-binding-project')).toHaveTextContent(
+      'Local Project Space'
+    )
+  })
 })
diff --git a/wework/src/features/todo/TodoBindingPicker.tsx b/wework/src/features/todo/TodoBindingPicker.tsx
index 9934a83784..2462a67fc0 100644
--- a/wework/src/features/todo/TodoBindingPicker.tsx
+++ b/wework/src/features/todo/TodoBindingPicker.tsx
@@ -6,8 +6,15 @@ import type { RuntimeTaskAddress } from '@/types/api'
 
 type DeliveryApi = NonNullable<WorkbenchServices['deliveryApi']>
 
-interface TodoBindingPickerProps {
+interface ProjectSpaceOption {
+  key: string
+  project: CloudProject
+  items: CloudLoopItem[]
   api: DeliveryApi
+}
+
+interface TodoBindingPickerProps {
+  apis: DeliveryApi[]
   runtimeTask?: RuntimeTaskAddress
   runtimeTaskTitle?: string | null
   currentProject: CloudProject | null
@@ -17,7 +24,7 @@ interface TodoBindingPickerProps {
 }
 
 export function TodoBindingPicker({
-  api,
+  apis,
   runtimeTask,
   runtimeTaskTitle,
   currentProject,
@@ -25,57 +32,89 @@ export function TodoBindingPicker({
   onClose,
   onBound,
 }: TodoBindingPickerProps) {
-  const [projects, setProjects] = useState<CloudProject[]>([])
-  const [items, setItems] = useState<CloudLoopItem[]>([])
+  const [projectOptions, setProjectOptions] = useState<ProjectSpaceOption[]>([])
   const [query, setQuery] = useState('')
   const [creating, setCreating] = useState(false)
-  const [projectId, setProjectId] = useState<string | null>(null)
+  const [projectKey, setProjectKey] = useState<string | null>(null)
   const [title, setTitle] = useState('')
   const [saving, setSaving] = useState(false)
   const [error, setError] = useState<string | null>(null)
 
   useEffect(() => {
     let active = true
-    void api
-      .listCloudProjects()
-      .then(async response => {
-        const groups = await Promise.all(
-          response.items.map(project => api.listLoopItems(project.id).then(result => result.items))
+    void Promise.allSettled(
+      apis.map(async api => {
+        const response = await api.listCloudProjects()
+        return Promise.all(
+          response.items.map(async project => {
+            const items = await api
+              .listLoopItems(project.id)
+              .then(result => result.items)
+              .catch(() => [])
+            return {
+              key: `${project.project_store}:${project.id}`,
+              project,
+              api,
+              items,
+            }
+          })
         )
-        if (!active) return
-        setProjects(response.items)
-        setProjectId(currentProject?.id ?? response.items[0]?.id ?? null)
-        setItems(groups.flat())
-      })
-      .catch(cause => {
-        if (active) setError(cause instanceof Error ? cause.message : '加载任务失败')
       })
+    ).then(results => {
+      if (!active) return
+      const options = results.flatMap(result => (result.status === 'fulfilled' ? result.value : []))
+      const uniqueOptions = options.filter(
+        (option, index) => options.findIndex(candidate => candidate.key === option.key) === index
+      )
+      const currentProjectKey = currentProject
+        ? `${currentProject.project_store}:${currentProject.id}`
+        : null
+      setProjectOptions(uniqueOptions)
+      setProjectKey(
+        uniqueOptions.some(option => option.key === currentProjectKey)
+          ? currentProjectKey
+          : (uniqueOptions[0]?.key ?? null)
+      )
+      if (uniqueOptions.length === 0 && results.some(result => result.status === 'rejected')) {
+        const rejection = results.find(result => result.status === 'rejected')
+        setError(
+          rejection?.status === 'rejected' && rejection.reason instanceof Error
+            ? rejection.reason.message
+            : '加载任务失败'
+        )
+      }
+    })
     return () => {
       active = false
     }
-  }, [api, currentProject?.id])
+  }, [apis, currentProject])
 
+  const selectedOption =
+    projectOptions.find(option => option.key === projectKey) ?? projectOptions[0] ?? null
   const visibleItems = useMemo(() => {
     const normalized = query.trim().toLowerCase()
-    return items.filter(
+    return (selectedOption?.items ?? []).filter(
       item =>
-        item.cloud_project_id === projectId &&
-        (!normalized ||
-          `${item.id} ${item.title} ${item.description}`.toLowerCase().includes(normalized))
+        !normalized ||
+        `${item.id} ${item.title} ${item.description}`.toLowerCase().includes(normalized)
     )
-  }, [items, projectId, query])
+  }, [query, selectedOption])
 
-  const selectedProject = projects.find(project => project.id === projectId) ?? null
+  const selectedProject = selectedOption?.project ?? null
 
   async function bindProject() {
-    if (!selectedProject || saving) return
+    if (!selectedOption || saving) return
     setSaving(true)
     setError(null)
     try {
       if (runtimeTask) {
-        await api.bindProjectTask(selectedProject.id, runtimeTask, runtimeTaskTitle)
+        await selectedOption.api.bindProjectTask(
+          selectedOption.project.id,
+          runtimeTask,
+          runtimeTaskTitle
+        )
       }
-      onBound(selectedProject, null)
+      onBound(selectedOption.project, null)
     } catch (cause) {
       setError(cause instanceof Error ? cause.message : '关联云项目失败')
     } finally {
@@ -84,16 +123,16 @@ export function TodoBindingPicker({
   }
 
   async function bind(item: CloudLoopItem) {
-    if (saving || currentItem?.id === item.id) return
+    if (!selectedOption || saving || currentItem?.id === item.id) return
     setSaving(true)
     setError(null)
     try {
       if (runtimeTask) {
         await (runtimeTaskTitle
-          ? api.bindTask(item.id, runtimeTask, runtimeTaskTitle)
-          : api.bindTask(item.id, runtimeTask))
+          ? selectedOption.api.bindTask(item.id, runtimeTask, runtimeTaskTitle)
+          : selectedOption.api.bindTask(item.id, runtimeTask))
       }
-      onBound(projects.find(project => project.id === item.cloud_project_id) ?? null, item)
+      onBound(selectedOption.project, item)
     } catch (cause) {
       setError(cause instanceof Error ? cause.message : '关联任务失败')
     } finally {
@@ -110,7 +149,13 @@ export function TodoBindingPicker({
     setSaving(true)
     setError(null)
     try {
-      await api.unbindCloudContext(runtimeTask)
+      const currentProjectKey = currentProject
+        ? `${currentProject.project_store}:${currentProject.id}`
+        : null
+      const currentOption =
+        projectOptions.find(option => option.key === currentProjectKey) ?? selectedOption
+      if (!currentOption) throw new Error('关联的项目空间不可用')
+      await currentOption.api.unbindCloudContext(runtimeTask)
       onBound(null, null)
     } catch (cause) {
       setError(cause instanceof Error ? cause.message : '解除关联失败')
@@ -120,17 +165,20 @@ export function TodoBindingPicker({
   }
 
   async function createAndBind() {
-    if (!projectId || !title.trim() || saving) return
+    if (!selectedOption || !title.trim() || saving) return
     setSaving(true)
     setError(null)
     try {
-      const item = await api.createLoopItem(projectId, { title: title.trim(), status: 'inbox' })
+      const item = await selectedOption.api.createLoopItem(selectedOption.project.id, {
+        title: title.trim(),
+        status: 'inbox',
+      })
       if (runtimeTask) {
         await (runtimeTaskTitle
-          ? api.bindTask(item.id, runtimeTask, runtimeTaskTitle)
-          : api.bindTask(item.id, runtimeTask))
+          ? selectedOption.api.bindTask(item.id, runtimeTask, runtimeTaskTitle)
+          : selectedOption.api.bindTask(item.id, runtimeTask))
       }
-      onBound(projects.find(project => project.id === item.cloud_project_id) ?? null, item)
+      onBound(selectedOption.project, item)
     } catch (cause) {
       setError(cause instanceof Error ? cause.message : '创建并关联任务失败')
     } finally {
@@ -157,13 +205,13 @@ export function TodoBindingPicker({
           <div className="space-y-3 p-4">
             <select
               data-testid="todo-binding-project"
-              value={projectId ?? ''}
-              onChange={event => setProjectId(event.target.value)}
+              value={projectKey ?? ''}
+              onChange={event => setProjectKey(event.target.value)}
               className="h-9 w-full rounded-lg border border-border bg-background px-3 text-sm outline-none focus:border-text-muted"
             >
-              {projects.map(project => (
-                <option key={project.id} value={project.id}>
-                  {project.name}
+              {projectOptions.map(option => (
+                <option key={option.key} value={option.key}>
+                  {option.project.name}
                 </option>
               ))}
             </select>
@@ -182,13 +230,13 @@ export function TodoBindingPicker({
               <LibraryBig className="h-4 w-4 shrink-0 text-text-muted" />
               <select
                 data-testid="todo-binding-project"
-                value={projectId ?? ''}
-                onChange={event => setProjectId(event.target.value)}
+                value={projectKey ?? ''}
+                onChange={event => setProjectKey(event.target.value)}
                 className="h-9 min-w-0 flex-1 rounded-lg border border-border bg-background px-2 text-sm outline-none focus:border-text-muted"
               >
-                {projects.map(project => (
-                  <option key={project.id} value={project.id}>
-                    {project.name}
+                {projectOptions.map(option => (
+                  <option key={option.key} value={option.key}>
+                    {option.project.name}
                   </option>
                 ))}
               </select>
@@ -256,7 +304,7 @@ export function TodoBindingPicker({
               <button
                 type="button"
                 data-testid="todo-binding-create-confirm"
-                disabled={!projectId || !title.trim() || saving}
+                disabled={!selectedOption || !title.trim() || saving}
                 onClick={() => void createAndBind()}
                 className="h-8 rounded-lg bg-text-primary px-3 text-xs font-medium text-background disabled:opacity-50"
               >
diff --git a/wework/src/features/todo/projectSpaceLocalBindings.test.ts b/wework/src/features/todo/projectSpaceLocalBindings.test.ts
new file mode 100644
index 0000000000..b516fa72d3
--- /dev/null
+++ b/wework/src/features/todo/projectSpaceLocalBindings.test.ts
@@ -0,0 +1,113 @@
+import { describe, expect, test, vi } from 'vitest'
+import type { CloudProject, CloudProjectLocalBinding } from '@/api/deliveries'
+import {
+  findProjectSpaceContextForTask,
+  loadProjectSpaceBindingOptions,
+  readCachedAutoJoinProjectSpace,
+  saveAutoJoinProjectSpace,
+  type ProjectSpaceBindingApi,
+} from './projectSpaceLocalBindings'
+
+function project(id: string, name: string, projectStore: 'local' | 'backend'): CloudProject {
+  return {
+    id,
+    public_id: `public-${id}`,
+    project_key: id.toUpperCase(),
+    name,
+    description: '',
+    project_store: projectStore,
+    task_provider: projectStore === 'local' ? 'local' : 'native',
+    provider_config: {},
+    created_by_user_id: 1,
+    status: 'active',
+    tags: [],
+    version: 1,
+    created_at: '2026-08-04T00:00:00Z',
+    updated_at: '2026-08-04T00:00:00Z',
+  }
+}
+
+function binding(
+  id: string,
+  projectId: string,
+  localProjectId: number,
+  isDefault: boolean
+): CloudProjectLocalBinding {
+  return {
+    id,
+    cloud_project_id: projectId,
+    local_project_id: localProjectId,
+    device_id: 'device-1',
+    is_default: isDefault,
+    created_at: '2026-08-04T00:00:00Z',
+    updated_at: '2026-08-04T00:00:00Z',
+  }
+}
+
+function api(
+  cloudProject: CloudProject,
+  localBindings: CloudProjectLocalBinding[]
+): ProjectSpaceBindingApi {
+  return {
+    listCloudProjects: vi.fn().mockResolvedValue({ items: [cloudProject] }),
+    listLocalBindings: vi.fn().mockResolvedValue(localBindings),
+    updateLocalBinding: vi.fn().mockImplementation(async (_projectId, bindingId, data) => ({
+      ...localBindings.find(candidate => candidate.id === bindingId)!,
+      ...data,
+    })),
+    addLocalBinding: vi.fn(),
+  } as unknown as ProjectSpaceBindingApi
+}
+
+describe('projectSpaceLocalBindings', () => {
+  test('moves automatic joining between local and cloud project-space stores', async () => {
+    window.localStorage.clear()
+    const localProjectId = 7
+    const firstProject = project('space-local', 'Local board', 'local')
+    const secondProject = project('space-cloud', 'Cloud board', 'backend')
+    const firstBinding = binding('binding-local', firstProject.id, localProjectId, true)
+    const secondBinding = binding('binding-cloud', secondProject.id, localProjectId, false)
+    const localApi = api(firstProject, [firstBinding])
+    const cloudApi = api(secondProject, [secondBinding])
+
+    const options = await loadProjectSpaceBindingOptions(
+      [localApi, cloudApi],
+      localProjectId,
+      'device-1'
+    )
+    await saveAutoJoinProjectSpace(options, 'backend:space-cloud', localProjectId, 'device-1')
+
+    expect(cloudApi.updateLocalBinding).toHaveBeenCalledWith(secondProject.id, secondBinding.id, {
+      is_default: true,
+    })
+    expect(localApi.updateLocalBinding).toHaveBeenCalledWith(firstProject.id, firstBinding.id, {
+      is_default: false,
+    })
+    expect(readCachedAutoJoinProjectSpace(localProjectId, 'device-1')).toEqual(secondProject)
+  })
+
+  test('finds a local project-space context when the cloud store has no binding', async () => {
+    const context = {
+      id: 'context-1',
+      device_id: 'device-1',
+      task_id: 'task-1',
+      cloud_project_id: 'space-local',
+      loop_item_id: 'todo-1',
+      project: project('space-local', 'Local board', 'local'),
+      loop_item: null,
+    }
+    const cloudApi = {
+      findCloudContextForTask: vi.fn().mockRejectedValue(new Error('Not found')),
+    } as unknown as ProjectSpaceBindingApi
+    const localApi = {
+      findCloudContextForTask: vi.fn().mockResolvedValue(context),
+    } as unknown as ProjectSpaceBindingApi
+
+    await expect(
+      findProjectSpaceContextForTask([cloudApi, localApi], {
+        deviceId: 'device-1',
+        taskId: 'task-1',
+      })
+    ).resolves.toEqual(context)
+  })
+})
diff --git a/wework/src/features/todo/projectSpaceLocalBindings.ts b/wework/src/features/todo/projectSpaceLocalBindings.ts
new file mode 100644
index 0000000000..799ef085e0
--- /dev/null
+++ b/wework/src/features/todo/projectSpaceLocalBindings.ts
@@ -0,0 +1,166 @@
+import {
+  PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT,
+  type CloudProject,
+  type CloudProjectLocalBinding,
+} from '@/api/deliveries'
+import type { WorkbenchServices } from '@/features/workbench/workbenchServices'
+import type { RuntimeTaskAddress } from '@/types/api'
+
+export type ProjectSpaceBindingApi = NonNullable<WorkbenchServices['deliveryApi']>
+
+export interface ProjectSpaceBindingOption {
+  key: string
+  project: CloudProject
+  api: ProjectSpaceBindingApi
+  binding: CloudProjectLocalBinding | null
+}
+
+const AUTO_JOIN_PROJECT_SPACE_STORAGE_PREFIX = 'wework.project-space-auto-join.v1'
+
+function autoJoinStorageKey(localProjectId: number, deviceId?: string | null): string {
+  return `${AUTO_JOIN_PROJECT_SPACE_STORAGE_PREFIX}:${deviceId || 'all'}:${localProjectId}`
+}
+
+export function readCachedAutoJoinProjectSpace(
+  localProjectId: number,
+  deviceId?: string | null
+): CloudProject | null {
+  try {
+    const stored = window.localStorage.getItem(autoJoinStorageKey(localProjectId, deviceId))
+    return stored ? (JSON.parse(stored) as CloudProject) : null
+  } catch {
+    return null
+  }
+}
+
+export function cacheAutoJoinProjectSpace(
+  localProjectId: number,
+  deviceId: string | null | undefined,
+  project: CloudProject | null
+): void {
+  try {
+    const key = autoJoinStorageKey(localProjectId, deviceId)
+    if (project) {
+      window.localStorage.setItem(key, JSON.stringify(project))
+    } else {
+      window.localStorage.removeItem(key)
+    }
+  } catch {
+    // Persistence is an optimization; the server binding remains authoritative.
+  }
+}
+
+export function projectSpaceBindingApis(
+  services: WorkbenchServices | null | undefined
+): ProjectSpaceBindingApi[] {
+  if (!services) return []
+  const candidates = [
+    services.projectSpaceApis?.local,
+    services.projectSpaceApis?.cloud,
+    services.deliveryApi,
+  ]
+  return candidates.filter(
+    (api, index): api is ProjectSpaceBindingApi => Boolean(api) && candidates.indexOf(api) === index
+  )
+}
+
+export function findProjectSpaceContextForTask(
+  apis: ProjectSpaceBindingApi[],
+  task: RuntimeTaskAddress
+): ReturnType<ProjectSpaceBindingApi['findCloudContextForTask']> {
+  return Promise.any(apis.map(api => api.findCloudContextForTask(task)))
+}
+
+function matchingBinding(
+  bindings: CloudProjectLocalBinding[],
+  localProjectId: number,
+  deviceId?: string
+): CloudProjectLocalBinding | null {
+  return (
+    bindings.find(
+      binding =>
+        binding.local_project_id === localProjectId && binding.device_id === (deviceId ?? null)
+    ) ??
+    bindings.find(
+      binding => binding.local_project_id === localProjectId && binding.device_id === null
+    ) ??
+    null
+  )
+}
+
+function optionKey(project: CloudProject): string {
+  return `${project.project_store}:${project.id}`
+}
+
+export async function loadProjectSpaceBindingOptions(
+  apis: ProjectSpaceBindingApi[],
+  localProjectId: number,
+  deviceId?: string
+): Promise<ProjectSpaceBindingOption[]> {
+  const results = await Promise.allSettled(
+    apis.map(async api => {
+      const projects = await api.listCloudProjects()
+      return Promise.all(
+        projects.items.map(async project => ({
+          key: optionKey(project),
+          project,
+          api,
+          binding: matchingBinding(
+            await api.listLocalBindings(project.id),
+            localProjectId,
+            deviceId
+          ),
+        }))
+      )
+    })
+  )
+  const candidates = results.flatMap(result => (result.status === 'fulfilled' ? result.value : []))
+  const options = new Map<string, ProjectSpaceBindingOption>()
+  for (const candidate of candidates) {
+    const existing = options.get(candidate.key)
+    if (!existing || (!existing.binding?.is_default && candidate.binding?.is_default)) {
+      options.set(candidate.key, candidate)
+    }
+  }
+  return Array.from(options.values()).sort((left, right) =>
+    left.project.name.localeCompare(right.project.name)
+  )
+}
+
+export async function saveAutoJoinProjectSpace(
+  options: ProjectSpaceBindingOption[],
+  selectedKey: string | null,
+  localProjectId: number,
+  deviceId?: string
+): Promise<void> {
+  const selected = selectedKey ? options.find(option => option.key === selectedKey) : null
+  if (selectedKey && !selected) throw new Error('Selected project space is unavailable')
+
+  if (selected) {
+    if (selected.binding) {
+      if (!selected.binding.is_default) {
+        await selected.api.updateLocalBinding(selected.project.id, selected.binding.id, {
+          is_default: true,
+        })
+      }
+    } else {
+      await selected.api.addLocalBinding(selected.project.id, {
+        local_project_id: localProjectId,
+        device_id: deviceId,
+        is_default: true,
+      })
+    }
+  }
+
+  await Promise.all(
+    options
+      .filter(option => option.key !== selectedKey && option.binding?.is_default)
+      .map(option =>
+        option.api.updateLocalBinding(option.project.id, option.binding!.id, {
+          is_default: false,
+        })
+      )
+  )
+  cacheAutoJoinProjectSpace(localProjectId, deviceId, selected?.project ?? null)
+  window.dispatchEvent(new Event(PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT))
+}
diff --git a/wework/src/features/workbench/WorkbenchProvider.tsx b/wework/src/features/workbench/WorkbenchProvider.tsx
index 69852f8b44..ef92548ca9 100644
--- a/wework/src/features/workbench/WorkbenchProvider.tsx
+++ b/wework/src/features/workbench/WorkbenchProvider.tsx
@@ -219,6 +219,7 @@ export function WorkbenchProvider({
   }, [resolvedServices])
   const lifecycleStore = useMemo(() => new RuntimeTaskLifecycleStore(user.id), [user.id])
   const lifecycleSnapshot = useRuntimeTaskLifecycleStoreSnapshot(lifecycleStore)
+  const trackingStatusSignaturesRef = useRef(new Map<string, string>())
   const [state, dispatch] = useReducer(workbenchReducer, initialWorkbenchState)
   const remoteProjectSyncSignatureRef = useRef('')
   const projectActivationSignatureRef = useRef('')
@@ -242,6 +243,41 @@ export function WorkbenchProvider({
   useLayoutEffect(() => {
     lifecycleStore.setCurrentTask(state.currentRuntimeTask)
   }, [lifecycleStore, state.currentRuntimeTask])
+  useEffect(() => {
+    const trackingApis = [
+      resolvedServices.projectSpaceApis?.local,
+      resolvedServices.projectSpaceApis?.cloud ?? resolvedServices.deliveryApi,
+    ].filter((api, index, values) => Boolean(api) && values.indexOf(api) === index)
+    if (!trackingApis.length) return
+    for (const [key, lifecycle] of lifecycleSnapshot.tasks) {
+      const taskStatus = lifecycle.task?.status?.toLowerCase() ?? ''
+      const executionStatus = lifecycle.derived.isRunning
+        ? 'running'
+        : taskStatus === 'failed'
+          ? 'failed'
+          : taskStatus === 'cancelled' || taskStatus === 'canceled'
+            ? 'cancelled'
+            : lifecycle.execution.known && taskStatus === 'done'
+              ? 'succeeded'
+              : null
+      if (!executionStatus) continue
+      const signature = `${executionStatus}:${taskStatus}`
+      if (trackingStatusSignaturesRef.current.get(key) === signature) continue
+      trackingStatusSignaturesRef.current.set(key, signature)
+      void Promise.allSettled(
+        trackingApis.map(api => api!.updateTaskTrackingStatus(lifecycle.address, executionStatus))
+      ).then(results => {
+        if (results.every(result => result.status === 'rejected')) {
+          trackingStatusSignaturesRef.current.delete(key)
+          console.warn('[Wework] Failed to synchronize project board task status', {
+            address: lifecycle.address,
+            executionStatus,
+            errors: results.map(result => (result.status === 'rejected' ? result.reason : null)),
+          })
+        }
+      })
+    }
+  }, [lifecycleSnapshot, resolvedServices.deliveryApi, resolvedServices.projectSpaceApis])
   const runtimeTaskReminders = useRuntimeTaskReminders({
     runtimeWork: state.runtimeWork,
     lifecycleStore,
diff --git a/wework/src/i18n/locales/en/common.json b/wework/src/i18n/locales/en/common.json
index 38d8aad032..cd44f1e747 100644
--- a/wework/src/i18n/locales/en/common.json
+++ b/wework/src/i18n/locales/en/common.json
@@ -430,6 +430,9 @@
     "choose_folder": "Choose folders",
     "edit_project": "Edit project",
     "source_folders": "Source folders",
+    "project_auto_join_space": "Automatically join project space",
+    "project_auto_join_space_description": "New conversations in this project default to the selected project space and show that choice before sending.",
+    "project_auto_join_space_none": "Do not join automatically",
     "primary_folder": "Primary",
     "make_primary_folder": "Make primary",
     "remove_source_folder": "Remove folder {{name}}",
@@ -1636,6 +1639,12 @@
     "mention_cloud_space": "Cloud space",
     "mention_cloud_back": "Back",
     "mention_cloud_project_space": "Project space",
+    "add_context_project_space": "Project space",
+    "add_context_project_space_select": "Select board",
+    "project_space_auto_join": "Automatic",
+    "project_space_context_pending": "Add to board · {{name}}",
+    "project_space_context_pending_title": "Sending creates a task on this project-space board",
+    "clear_project_space_context": "Do not add to the project board",
     "mention_cloud_project_space_description": "@ the cloud space capability and drive any permitted action in natural language",
     "mention_cloud_project_space_list": "Project space list",
     "mention_cloud_project_space_list_description": "List every accessible cloud project space",
@@ -1961,6 +1970,16 @@
     "home_manage_search": "Search project spaces",
     "home_manage_empty": "No matching project spaces",
     "home_open": "Open",
+    "local_binding_title": "Link local projects",
+    "local_binding_description": "Linked project spaces appear in the task composer's “+” menu. Configure automatic joining in the local project settings.",
+    "local_binding_project_fallback": "Local project #{{id}}",
+    "local_binding_device": "Device {{device}}",
+    "local_binding_all_devices": "All devices",
+    "local_binding_default": "Automatic",
+    "local_binding_link": "Link",
+    "local_binding_link_failed": "Failed to link the local project",
+    "local_binding_unlink": "Unlink",
+    "local_binding_unlink_failed": "Failed to unlink the local project",
     "my_work_calendar_note": "The calendar only shows tasks with a due date.",
     "my_work_col_due": "Due",
     "my_work_col_project": "Project",
diff --git a/wework/src/i18n/locales/zh-CN/common.json b/wework/src/i18n/locales/zh-CN/common.json
index 89340aa68c..5068de0966 100644
--- a/wework/src/i18n/locales/zh-CN/common.json
+++ b/wework/src/i18n/locales/zh-CN/common.json
@@ -428,6 +428,9 @@
     "choose_folder": "选择文件夹",
     "edit_project": "编辑项目",
     "source_folders": "源文件夹",
+    "project_auto_join_space": "自动加入项目空间",
+    "project_auto_join_space_description": "在这个项目里开启的新对话会默认加入所选项目空间，并在发送前明确显示。",
+    "project_auto_join_space_none": "不自动加入",
     "primary_folder": "主目录",
     "make_primary_folder": "设为主目录",
     "remove_source_folder": "移除文件夹 {{name}}",
@@ -1633,6 +1636,12 @@
     "mention_cloud_space": "云空间",
     "mention_cloud_back": "返回",
     "mention_cloud_project_space": "项目空间",
+    "add_context_project_space": "项目空间",
+    "add_context_project_space_select": "选择看板",
+    "project_space_auto_join": "自动加入",
+    "project_space_context_pending": "加入看板 · {{name}}",
+    "project_space_context_pending_title": "发送后会在该项目空间的看板中创建任务",
+    "clear_project_space_context": "不加入项目看板",
     "mention_cloud_project_space_description": "@ 我的云空间能力,用自然语言做任何有权限的操作",
     "mention_cloud_project_space_list": "项目空间列表",
     "mention_cloud_project_space_list_description": "列出所有可访问的云项目空间",
@@ -1958,6 +1967,16 @@
     "home_manage_search": "搜索项目空间",
     "home_manage_empty": "没有匹配的项目空间",
     "home_open": "打开",
+    "local_binding_title": "关联本地项目",
+    "local_binding_description": "关联后可从任务输入框的“+”菜单选择当前项目空间；自动加入请在本地项目设置中配置。",
+    "local_binding_project_fallback": "本地项目 #{{id}}",
+    "local_binding_device": "设备 {{device}}",
+    "local_binding_all_devices": "所有设备",
+    "local_binding_default": "自动加入",
+    "local_binding_link": "关联",
+    "local_binding_link_failed": "关联本地项目失败",
+    "local_binding_unlink": "解除关联",
+    "local_binding_unlink_failed": "解除本地项目关联失败",
     "my_work_calendar_note": "日历仅展示设置了截止日期的任务。",
     "my_work_col_due": "截止日期",
     "my_work_col_project": "项目",

From c05d806b8b895cfc2a7c1c55760f2d7bc89eac12 Mon Sep 17 00:00:00 2001
From: axb <qindi@staff.weibo.com>
Date: Tue, 4 Aug 2026 18:57:11 +0800
Subject: [PATCH 2/7] fix(wework): support select controls in desktop e2e

---
 wework/src/e2e/automation.ts                  |  8 ++++
 wework/src/e2e/desktop-control-select.test.ts | 46 +++++++++++++++++++
 wework/src/e2e/desktop-control-select.ts      | 20 ++++++++
 .../extensions/desktop-control-contract.ts    |  1 +
 4 files changed, 75 insertions(+)
 create mode 100644 wework/src/e2e/desktop-control-select.test.ts
 create mode 100644 wework/src/e2e/desktop-control-select.ts

diff --git a/wework/src/e2e/automation.ts b/wework/src/e2e/automation.ts
index 931cc20fb8..c91bf2514a 100644
--- a/wework/src/e2e/automation.ts
+++ b/wework/src/e2e/automation.ts
@@ -27,6 +27,7 @@ import { getRuntimeConversationCacheStats } from '@/features/workbench/runtimeCo
 import { LOCAL_EXECUTOR_COMMANDS } from '@/tauri/localExecutor'
 import { executeVerificationControlCommand } from './verification-control'
 import { evalEmbeddedBrowserJson } from '@/lib/embedded-browser'
+import { selectDesktopControlOption } from './desktop-control-select'
 
 const DEFAULT_WAIT_TIMEOUT_MS = 5000
 const LOCAL_MODEL_SEND_CIRCUIT_BREAKER_ERROR = 'WEWORK_E2E_LOCAL_MODEL_SEND_CIRCUIT_OPEN'
@@ -1138,6 +1139,13 @@ async function executeDesktopControlCommand(command: DesktopControlCommand): Pro
       }
       return element.textContent?.trim() ?? ''
     }
+    case 'select': {
+      const element = findDesktopControlElements(command.selector)[0]
+      if (!(element instanceof HTMLSelectElement)) {
+        throw new Error(`Selector "${command.selector}" is not a select element`)
+      }
+      return selectDesktopControlOption(element, command.value ?? '', command.by)
+    }
     case 'submit': {
       const element = findDesktopControlElements(command.selector)[0]
       if (!element) throw new Error(`Unable to find selector "${command.selector}"`)
diff --git a/wework/src/e2e/desktop-control-select.test.ts b/wework/src/e2e/desktop-control-select.test.ts
new file mode 100644
index 0000000000..ce3399020d
--- /dev/null
+++ b/wework/src/e2e/desktop-control-select.test.ts
@@ -0,0 +1,46 @@
+import { describe, expect, test, vi } from 'vitest'
+import { selectDesktopControlOption } from './desktop-control-select'
+
+function createSelect() {
+  const select = document.createElement('select')
+  select.innerHTML = `
+    <option value="">None</option>
+    <option value="local:project-space-id">Task Follow-up Board</option>
+  `
+  document.body.append(select)
+  return select
+}
+
+describe('selectDesktopControlOption', () => {
+  test('selects an option by visible label and dispatches React-compatible events', () => {
+    const select = createSelect()
+    const inputListener = vi.fn()
+    const changeListener = vi.fn()
+    select.addEventListener('input', inputListener)
+    select.addEventListener('change', changeListener)
+
+    expect(selectDesktopControlOption(select, 'Task Follow-up Board', 'label')).toBe(
+      'Task Follow-up Board'
+    )
+    expect(select.value).toBe('local:project-space-id')
+    expect(inputListener).toHaveBeenCalledOnce()
+    expect(changeListener).toHaveBeenCalledOnce()
+  })
+
+  test('selects an option by value by default', () => {
+    const select = createSelect()
+
+    expect(selectDesktopControlOption(select, 'local:project-space-id')).toBe(
+      'Task Follow-up Board'
+    )
+    expect(select.value).toBe('local:project-space-id')
+  })
+
+  test('rejects an unavailable option', () => {
+    const select = createSelect()
+
+    expect(() => selectDesktopControlOption(select, 'Missing board', 'label')).toThrow(
+      'Unable to find select option by label "Missing board"'
+    )
+  })
+})
diff --git a/wework/src/e2e/desktop-control-select.ts b/wework/src/e2e/desktop-control-select.ts
new file mode 100644
index 0000000000..e905baf927
--- /dev/null
+++ b/wework/src/e2e/desktop-control-select.ts
@@ -0,0 +1,20 @@
+export type DesktopControlSelectMode = 'label' | 'value'
+
+export function selectDesktopControlOption(
+  element: HTMLSelectElement,
+  selection: string,
+  mode: DesktopControlSelectMode = 'value'
+): string {
+  const option = Array.from(element.options).find(candidate =>
+    mode === 'label' ? candidate.label.trim() === selection.trim() : candidate.value === selection
+  )
+  if (!option) {
+    throw new Error(`Unable to find select option by ${mode} "${selection}"`)
+  }
+
+  const setter = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, 'value')?.set
+  setter?.call(element, option.value)
+  element.dispatchEvent(new Event('input', { bubbles: true, composed: true }))
+  element.dispatchEvent(new Event('change', { bubbles: true }))
+  return option.label.trim()
+}
diff --git a/wework/src/extensions/desktop-control-contract.ts b/wework/src/extensions/desktop-control-contract.ts
index 2a0b3f5eb9..1dc1bcaefd 100644
--- a/wework/src/extensions/desktop-control-contract.ts
+++ b/wework/src/extensions/desktop-control-contract.ts
@@ -10,6 +10,7 @@ export interface DesktopControlCommand {
   visible?: boolean
   stableMs?: number
   key?: string
+  by?: 'label' | 'value'
   filename?: string
   mimeType?: string
 }

From 1fb1477f2de5ffb6ab2ef3eddc34f2ef00f599cc Mon Sep 17 00:00:00 2001
From: axb <qindi@staff.weibo.com>
Date: Tue, 4 Aug 2026 19:58:51 +0800
Subject: [PATCH 3/7] test(wework): hold supervisor response before completion

---
 wework/e2e/desktop/task-flow.e2e.mjs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/wework/e2e/desktop/task-flow.e2e.mjs b/wework/e2e/desktop/task-flow.e2e.mjs
index 9b9b5e02e1..02c34737db 100644
--- a/wework/e2e/desktop/task-flow.e2e.mjs
+++ b/wework/e2e/desktop/task-flow.e2e.mjs
@@ -9324,15 +9324,15 @@ class DesktopE2EServer {
           Connection: 'keep-alive',
           'Content-Type': 'text/event-stream; charset=utf-8',
         })
-        response.write(
+        response.write(createSse([responseCreated(responseId)]))
+        this.resolveSupervisorCorrectionStarted()
+        await this.supervisorCorrectionRelease
+        response.end(
           createSse([
-            responseCreated(responseId),
             assistantMessage(SUPERVISOR_CORRECTION_COMPLETION_TEXT),
+            responseCompleted(responseId),
           ])
         )
-        this.resolveSupervisorCorrectionStarted()
-        await this.supervisorCorrectionRelease
-        response.end(createSse([responseCompleted(responseId)]))
         return
       }
       assert.ok(requestText.includes(SUPERVISOR_PROMPT), 'The supervisor task prompt was lost')

From f07d1423dbb74977bf8862c101c48fc6251c5704 Mon Sep 17 00:00:00 2001
From: axb <qindi@staff.weibo.com>
Date: Tue, 4 Aug 2026 22:00:40 +0800
Subject: [PATCH 4/7] fix(executor): make runtime execution state process-local

---
 executor/src/runtime_work/handler.rs          |  14 +-
 .../src/runtime_work/handler/collection.rs    | 133 +++++++++++-------
 .../runtime_work/handler/helpers/routing.rs   |  15 +-
 executor/src/runtime_work/handler/queries.rs  |  47 +------
 executor/src/runtime_work/handler/tasks.rs    |  20 +--
 executor/src/runtime_work/handler/tests.rs    | 105 +++++++++-----
 executor/src/runtime_work/handler/turns.rs    |  61 ++++----
 executor/src/runtime_work/response.rs         |  83 ++---------
 executor/src/runtime_work/store.rs            | 103 ++------------
 9 files changed, 236 insertions(+), 345 deletions(-)

diff --git a/executor/src/runtime_work/handler.rs b/executor/src/runtime_work/handler.rs
index 0a53a5a18d..d412b62942 100644
--- a/executor/src/runtime_work/handler.rs
+++ b/executor/src/runtime_work/handler.rs
@@ -288,10 +288,10 @@ pub struct RuntimeWorkRpcHandler {
     codex_app_server: CodexAppServerClient,
     codex_runtime_proxy_config: Arc<AsyncMutex<CodexRuntimeProxyConfig>>,
     event_tx: Option<broadcast::Sender<Value>>,
-    active_local_tasks: Arc<Mutex<HashSet<String>>>,
+    next_execution_id: Arc<AtomicU64>,
     active_turn_cancellations: Arc<Mutex<HashMap<String, ActiveTurnCancellation>>>,
     active_codex_turns: Arc<Mutex<HashMap<String, ActiveCodexTurn>>>,
-    active_request_user_inputs: Arc<Mutex<HashMap<String, mpsc::Sender<Value>>>>,
+    active_request_user_inputs: Arc<Mutex<HashMap<String, ActiveRequestUserInput>>>,
     supervisor_evaluating: Arc<Mutex<HashSet<String>>>,
     thread_event_routes: Arc<Mutex<HashMap<String, RuntimeThreadEventRoute>>>,
     notification_router: Arc<Mutex<Option<tokio::task::JoinHandle<()>>>>,
@@ -312,12 +312,20 @@ struct CodexRuntimeProxyConfig {
 }
 
 struct ActiveTurnCancellation {
+    execution_id: u64,
     cancel: oneshot::Sender<()>,
     stopped: oneshot::Receiver<()>,
 }
 
+#[derive(Clone)]
+struct ActiveRequestUserInput {
+    execution_id: u64,
+    sender: mpsc::Sender<Value>,
+}
+
 #[derive(Clone)]
 struct ActiveCodexTurn {
+    execution_id: u64,
     thread_id: String,
     turn_id: String,
 }
@@ -358,7 +366,7 @@ impl RuntimeWorkRpcHandler {
                 CodexRuntimeProxyConfig::default(),
             )),
             event_tx: None,
-            active_local_tasks: Arc::new(Mutex::new(HashSet::new())),
+            next_execution_id: Arc::new(AtomicU64::new(1)),
             active_turn_cancellations: Arc::new(Mutex::new(HashMap::new())),
             active_codex_turns: Arc::new(Mutex::new(HashMap::new())),
             active_request_user_inputs: Arc::new(Mutex::new(HashMap::new())),
diff --git a/executor/src/runtime_work/handler/collection.rs b/executor/src/runtime_work/handler/collection.rs
index a732b6ef7b..b1ca748628 100644
--- a/executor/src/runtime_work/handler/collection.rs
+++ b/executor/src/runtime_work/handler/collection.rs
@@ -101,9 +101,7 @@ impl RuntimeWorkRpcHandler {
                 continue;
             }
             let running = self.is_active_local_task(&link.local_task_id);
-            if apply_local_execution_state(&mut link, running) {
-                self.store.update_task_execution_state(&link);
-            }
+            apply_local_execution_state(&mut link, running);
             link.list_order = Some(links.len());
             links.push(link);
         }
@@ -543,15 +541,10 @@ impl RuntimeWorkRpcHandler {
 
     pub(super) fn link_from_thread(&self, thread: &Value) -> Option<RuntimeTaskLink> {
         let thread_id = string_field(thread, "id")?;
-        let mut local_link = self.local_task_by_thread_id(&thread_id);
+        let local_link = self.local_task_by_thread_id(&thread_id);
         let local_active = local_link
             .as_ref()
             .is_some_and(|link| self.is_active_local_task(&link.local_task_id));
-        if let Some(link) = &mut local_link {
-            if !local_active && normalize_inactive_running_codex_task(link) {
-                self.store.update_task_execution_state(link);
-            }
-        }
         let workspace_path = string_field(thread, "cwd")
             .or_else(|| local_link.as_ref().map(|link| link.workspace_path.clone()))
             .unwrap_or_else(|| "~/.codex".to_owned());
@@ -628,25 +621,18 @@ impl RuntimeWorkRpcHandler {
         self.store.upsert_task(link);
     }
 
-    pub(super) fn mark_active_local_task(&self, local_task_id: &str) {
-        self.active_local_tasks
-            .lock()
-            .expect("active local task set lock should not be poisoned")
-            .insert(local_task_id.to_owned());
-    }
-
-    pub(super) fn unmark_active_local_task(&self, local_task_id: &str) {
-        self.active_local_tasks
-            .lock()
-            .expect("active local task set lock should not be poisoned")
-            .remove(local_task_id);
-    }
-
-    pub(super) fn set_active_turn_cancellation(
+    pub(super) fn start_local_task_execution(
         &self,
         local_task_id: String,
-        control: ActiveTurnCancellation,
-    ) {
+        cancel: oneshot::Sender<()>,
+        stopped: oneshot::Receiver<()>,
+    ) -> u64 {
+        let execution_id = self.next_execution_id.fetch_add(1, Ordering::Relaxed);
+        let control = ActiveTurnCancellation {
+            execution_id,
+            cancel,
+            stopped,
+        };
         if let Some(previous) = self
             .active_turn_cancellations
             .lock()
@@ -655,27 +641,49 @@ impl RuntimeWorkRpcHandler {
         {
             let _ = previous.cancel.send(());
         }
+        execution_id
     }
 
-    pub(super) fn clear_active_turn_cancellation(&self, local_task_id: &str) {
-        self.active_turn_cancellations
+    pub(super) fn finish_local_task_execution(
+        &self,
+        local_task_id: &str,
+        execution_id: u64,
+    ) -> bool {
+        let mut active = self
+            .active_turn_cancellations
             .lock()
-            .expect("active turn cancellation map lock should not be poisoned")
-            .remove(local_task_id);
+            .expect("active turn cancellation map lock should not be poisoned");
+        if active
+            .get(local_task_id)
+            .is_some_and(|control| control.execution_id == execution_id)
+        {
+            active.remove(local_task_id);
+            true
+        } else {
+            false
+        }
     }
 
     pub(super) fn record_active_codex_turn(
         &self,
         local_task_id: &str,
+        execution_id: u64,
         thread_id: String,
         turn_id: String,
     ) {
+        if !self.is_local_task_execution_active(local_task_id, execution_id) {
+            return;
+        }
         self.active_codex_turns
             .lock()
             .expect("active codex turn map lock should not be poisoned")
             .insert(
                 local_task_id.to_owned(),
-                ActiveCodexTurn { thread_id, turn_id },
+                ActiveCodexTurn {
+                    execution_id,
+                    thread_id,
+                    turn_id,
+                },
             );
     }
 
@@ -705,11 +713,17 @@ impl RuntimeWorkRpcHandler {
         None
     }
 
-    pub(super) fn clear_active_codex_turn(&self, local_task_id: &str) {
-        self.active_codex_turns
+    pub(super) fn clear_active_codex_turn(&self, local_task_id: &str, execution_id: u64) {
+        let mut active = self
+            .active_codex_turns
             .lock()
-            .expect("active codex turn map lock should not be poisoned")
-            .remove(local_task_id);
+            .expect("active codex turn map lock should not be poisoned");
+        if active
+            .get(local_task_id)
+            .is_some_and(|turn| turn.execution_id == execution_id)
+        {
+            active.remove(local_task_id);
+        }
     }
 
     pub(super) async fn abort_active_turn(&self, local_task_id: &str) -> bool {
@@ -727,39 +741,55 @@ impl RuntimeWorkRpcHandler {
                 return false;
             }
         }
-        self.clear_active_codex_turn(local_task_id);
-        self.unmark_active_local_task(local_task_id);
+        self.active_codex_turns
+            .lock()
+            .expect("active codex turn map lock should not be poisoned")
+            .remove(local_task_id);
         true
     }
 
     pub(super) fn is_active_local_task(&self, local_task_id: &str) -> bool {
-        self.active_local_tasks
+        self.active_turn_cancellations
             .lock()
-            .expect("active local task set lock should not be poisoned")
-            .contains(local_task_id)
+            .expect("active turn cancellation map lock should not be poisoned")
+            .contains_key(local_task_id)
+    }
+
+    fn is_local_task_execution_active(&self, local_task_id: &str, execution_id: u64) -> bool {
+        self.active_turn_cancellations
+            .lock()
+            .expect("active turn cancellation map lock should not be poisoned")
+            .get(local_task_id)
+            .is_some_and(|control| control.execution_id == execution_id)
+    }
+
+    pub(super) fn clear_active_request_user_input(&self, local_task_id: &str, execution_id: u64) {
+        let mut active = self
+            .active_request_user_inputs
+            .lock()
+            .expect("request user input map lock should not be poisoned");
+        if active
+            .get(local_task_id)
+            .is_some_and(|request| request.execution_id == execution_id)
+        {
+            active.remove(local_task_id);
+        }
     }
 
     pub(super) fn finish_local_task(
         &self,
         local_task_id: &str,
+        execution_id: u64,
         thread_id: Option<String>,
         status: &str,
     ) {
-        self.clear_active_turn_cancellation(local_task_id);
+        if !self.finish_local_task_execution(local_task_id, execution_id) {
+            return;
+        }
         self.store.update_task(local_task_id, |link| {
             if thread_id.is_some() {
                 link.thread_id = thread_id;
             }
-            link.status = status.to_owned();
-            link.running = status == "running";
-            link.thread_status = if link.running { "active" } else { "idle" }.to_owned();
-            link.turn_status = match status {
-                "running" => Some("inProgress".to_owned()),
-                "done" => Some("completed".to_owned()),
-                "cancelled" => Some("interrupted".to_owned()),
-                "failed" => Some("failed".to_owned()),
-                _ => link.turn_status.clone(),
-            };
             link.updated_at = now_ms();
             if status != "running" {
                 link.completed_at = Some(link.updated_at);
@@ -769,7 +799,6 @@ impl RuntimeWorkRpcHandler {
             }
         });
         if status != "running" {
-            self.unmark_active_local_task(local_task_id);
             self.schedule_worktree_prune();
         }
     }
diff --git a/executor/src/runtime_work/handler/helpers/routing.rs b/executor/src/runtime_work/handler/helpers/routing.rs
index 23b6efb51e..8751388646 100644
--- a/executor/src/runtime_work/handler/helpers/routing.rs
+++ b/executor/src/runtime_work/handler/helpers/routing.rs
@@ -1,6 +1,6 @@
-fn normalize_inactive_running_codex_task(link: &mut RuntimeTaskLink) -> bool {
+fn normalize_inactive_running_codex_task(link: &mut RuntimeTaskLink) {
     if !is_inactive_running_codex_task(link) {
-        return false;
+        return;
     }
     link.status = "active".to_owned();
     link.running = false;
@@ -13,23 +13,18 @@ fn normalize_inactive_running_codex_task(link: &mut RuntimeTaskLink) -> bool {
         link.turn_status = Some("completed".to_owned());
     }
     link.updated_at = now_ms();
-    true
 }
 
-fn apply_local_execution_state(link: &mut RuntimeTaskLink, running: bool) -> bool {
+fn apply_local_execution_state(link: &mut RuntimeTaskLink, running: bool) {
     if !running {
-        return normalize_inactive_running_codex_task(link);
+        normalize_inactive_running_codex_task(link);
+        return;
     }
 
-    let changed = !link.running
-        || link.status != "running"
-        || link.thread_status != "active"
-        || link.turn_status.as_deref() != Some("inProgress");
     link.running = true;
     link.status = "running".to_owned();
     link.thread_status = "active".to_owned();
     link.turn_status = Some("inProgress".to_owned());
-    changed
 }
 
 fn is_inactive_running_codex_task(link: &RuntimeTaskLink) -> bool {
diff --git a/executor/src/runtime_work/handler/queries.rs b/executor/src/runtime_work/handler/queries.rs
index bd16af8b8d..1f4e92d239 100644
--- a/executor/src/runtime_work/handler/queries.rs
+++ b/executor/src/runtime_work/handler/queries.rs
@@ -270,13 +270,10 @@ impl RuntimeWorkRpcHandler {
             }
         }
 
-        let mut thread = self
+        let thread = self
             .read_codex_thread_with_turns(&thread_id)
             .await
             .map_err(|error| AppIpcError::new("codex_error", error))?;
-        if let Some(link) = local_link.as_ref() {
-            reconcile_persisted_codex_turn_status(&mut thread, link);
-        }
         self.repair_legacy_task_activity_time(&local_task_id, &thread);
         let workspace_path = string_field(&thread, "cwd")
             .or_else(|| string_field(&payload, "workspacePath"))
@@ -332,45 +329,3 @@ impl RuntimeWorkRpcHandler {
         }))
     }
 }
-
-pub(super) fn reconcile_persisted_codex_turn_status(thread: &mut Value, link: &RuntimeTaskLink) {
-    let Some(turn_id) = string_field(&link.runtime_handle, "lastTurnId") else {
-        return;
-    };
-    let Some(status) = link
-        .turn_status
-        .as_deref()
-        .filter(|status| !runtime_status_is_running(status))
-    else {
-        return;
-    };
-    let Some(turn) = thread
-        .get_mut("turns")
-        .and_then(Value::as_array_mut)
-        .into_iter()
-        .flatten()
-        .find(|turn| string_field(turn, "id").as_deref() == Some(turn_id.as_str()))
-    else {
-        return;
-    };
-    let previous_status = string_field(turn, "status").unwrap_or_default();
-    let Some(turn) = turn.as_object_mut() else {
-        return;
-    };
-    turn.insert("status".to_owned(), Value::String(status.to_owned()));
-    if let Some(completed_at) = link.completed_at {
-        turn.insert("completedAt".to_owned(), json!(completed_at));
-    }
-    if previous_status != status {
-        log_executor_event(
-            "runtime work transcript turn status reconciled",
-            &[
-                ("local_task_id", link.local_task_id.clone()),
-                ("thread_id", link.thread_id.clone().unwrap_or_default()),
-                ("turn_id", turn_id),
-                ("provider_status", previous_status),
-                ("persisted_status", status.to_owned()),
-            ],
-        );
-    }
-}
diff --git a/executor/src/runtime_work/handler/tasks.rs b/executor/src/runtime_work/handler/tasks.rs
index ff8493b64e..9d44df2021 100644
--- a/executor/src/runtime_work/handler/tasks.rs
+++ b/executor/src/runtime_work/handler/tasks.rs
@@ -91,10 +91,6 @@ impl RuntimeWorkRpcHandler {
             title,
         );
         link.thread_id = Some(thread_id);
-        link.running = false;
-        link.status = "active".to_owned();
-        link.thread_status = "idle".to_owned();
-        link.turn_status = Some("completed".to_owned());
         link.parent = Some(
             json!({"taskId": source.local_task_id, "threadId": source_thread_id, "lastTurnId": last_turn_id}),
         );
@@ -551,6 +547,7 @@ impl RuntimeWorkRpcHandler {
                 );
                 self.record_active_codex_turn(
                     &local_task_id,
+                    active_turn.execution_id,
                     active_turn.thread_id.clone(),
                     actual_turn_id.clone(),
                 );
@@ -571,6 +568,7 @@ impl RuntimeWorkRpcHandler {
             Ok(turn_id) => {
                 self.record_active_codex_turn(
                     &local_task_id,
+                    active_turn.execution_id,
                     active_turn.thread_id.clone(),
                     turn_id.clone(),
                 );
@@ -674,7 +672,8 @@ impl RuntimeWorkRpcHandler {
             .active_request_user_inputs
             .lock()
             .ok()
-            .and_then(|requests| requests.get(local_task_id).cloned());
+            .and_then(|requests| requests.get(local_task_id).cloned())
+            .map(|request| request.sender);
         let Some(sender) = sender else {
             return Ok(json!({
                 "success": false,
@@ -708,10 +707,6 @@ impl RuntimeWorkRpcHandler {
         let link = self
             .store
             .update_task(&local_task_id, |link| {
-                link.status = "cancelled".to_owned();
-                link.running = false;
-                link.thread_status = "idle".to_owned();
-                link.turn_status = Some("interrupted".to_owned());
                 link.updated_at = now_ms();
                 link.completed_at = Some(link.updated_at);
             })
@@ -744,7 +739,8 @@ impl RuntimeWorkRpcHandler {
             .active_request_user_inputs
             .lock()
             .ok()
-            .and_then(|requests| requests.get(local_task_id).cloned());
+            .and_then(|requests| requests.get(local_task_id).cloned())
+            .map(|request| request.sender);
         if let Some(sender) = sender {
             let _ = sender.try_send(empty_request_user_input_response());
         }
@@ -769,10 +765,6 @@ impl RuntimeWorkRpcHandler {
                 );
             }
             link.workspace_path = workspace_path.to_owned();
-            link.status = "running".to_owned();
-            link.running = true;
-            link.thread_status = "active".to_owned();
-            link.turn_status = Some("inProgress".to_owned());
             link.ephemeral = link.ephemeral || request.ephemeral;
             if request.runtime_project_key.is_some() {
                 link.runtime_project_key = request.runtime_project_key.clone();
diff --git a/executor/src/runtime_work/handler/tests.rs b/executor/src/runtime_work/handler/tests.rs
index 1529052d89..d3c82c53fe 100644
--- a/executor/src/runtime_work/handler/tests.rs
+++ b/executor/src/runtime_work/handler/tests.rs
@@ -2,9 +2,14 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use super::queries::reconcile_persisted_codex_turn_status;
 use super::*;
 
+fn start_test_execution(handler: &RuntimeWorkRpcHandler, local_task_id: &str) -> u64 {
+    let (cancel, _cancelled) = oneshot::channel();
+    let (_stopped, stopped) = oneshot::channel();
+    handler.start_local_task_execution(local_task_id.to_owned(), cancel, stopped)
+}
+
 #[tokio::test]
 async fn fork_resolves_the_requested_turn_even_when_the_source_is_running() {
     for (case, persisted_running, active_in_memory) in
@@ -22,7 +27,7 @@ async fn fork_resolves_the_requested_turn_even_when_the_source_is_running() {
         link.running = persisted_running;
         handler.upsert_local_task(link);
         if active_in_memory {
-            handler.mark_active_local_task("task-1");
+            start_test_execution(&handler, "task-1");
         }
 
         let response = handler
@@ -42,7 +47,7 @@ async fn fork_resolves_the_requested_turn_even_when_the_source_is_running() {
 }
 
 #[test]
-fn finishing_an_active_goal_keeps_the_task_idle() {
+fn finishing_an_active_goal_updates_metadata_without_persisting_execution_state() {
     let index_path = temp_runtime_work_index_path("finish-active-goal");
     let mut handler = RuntimeWorkRpcHandler::new("device-1", "/bin/false");
     handler.store = RuntimeWorkStore::new(index_path.clone());
@@ -54,14 +59,17 @@ fn finishing_an_active_goal_keeps_the_task_idle() {
     link.goal_status = Some("active".to_owned());
     handler.upsert_local_task(link);
 
-    handler.finish_local_task("task-1", Some("thread-1".to_owned()), "done");
+    let execution_id = start_test_execution(&handler, "task-1");
+    handler.finish_local_task("task-1", execution_id, Some("thread-1".to_owned()), "done");
 
     let task = handler
         .local_task_link("task-1")
         .expect("task should remain stored");
-    assert_eq!(task.status, "done");
+    assert_eq!(task.status, "active");
     assert!(!task.running);
     assert_eq!(task.goal_status.as_deref(), Some("active"));
+    assert_eq!(task.thread_id.as_deref(), Some("thread-1"));
+    assert!(task.completed_at.is_some());
 
     let _ = fs::remove_file(index_path);
 }
@@ -78,12 +86,14 @@ fn turn_result_persists_observed_goal_status_before_settling_task() {
     );
     link.goal_status = Some("active".to_owned());
     handler.upsert_local_task(link);
-    handler.mark_active_local_task("task-1");
+    let execution_id = start_test_execution(&handler, "task-1");
 
     handler.handle_turn_result(
         "task-1",
+        execution_id,
         &ExecutionRequest::default(),
         Some(&ActiveCodexTurn {
+            execution_id,
             thread_id: "thread-1".to_owned(),
             turn_id: "turn-1".to_owned(),
         }),
@@ -100,7 +110,7 @@ fn turn_result_persists_observed_goal_status_before_settling_task() {
     let task = handler
         .local_task_link("task-1")
         .expect("task should remain stored");
-    assert_eq!(task.status, "done");
+    assert_eq!(task.status, "active");
     assert!(!task.running);
     assert_eq!(task.goal_status.as_deref(), Some("complete"));
     assert!(!handler.is_active_local_task("task-1"));
@@ -108,6 +118,51 @@ fn turn_result_persists_observed_goal_status_before_settling_task() {
     let _ = fs::remove_file(index_path);
 }
 
+#[test]
+fn stale_execution_cannot_finish_its_replacement() {
+    let index_path = temp_runtime_work_index_path("stale-execution-finish");
+    let mut handler = RuntimeWorkRpcHandler::new("device-1", "/bin/false");
+    handler.store = RuntimeWorkStore::new(index_path.clone());
+    handler.upsert_local_task(RuntimeTaskLink::new_pending(
+        "task-1".to_owned(),
+        "/tmp/project".to_owned(),
+        "Task".to_owned(),
+    ));
+
+    let stale_execution_id = start_test_execution(&handler, "task-1");
+    let current_execution_id = start_test_execution(&handler, "task-1");
+
+    handler.finish_local_task(
+        "task-1",
+        stale_execution_id,
+        Some("stale-thread".to_owned()),
+        "done",
+    );
+
+    let task = handler
+        .local_task_link("task-1")
+        .expect("task should remain stored");
+    assert!(handler.is_active_local_task("task-1"));
+    assert_eq!(task.thread_id, None);
+    assert_eq!(task.completed_at, None);
+
+    handler.finish_local_task(
+        "task-1",
+        current_execution_id,
+        Some("current-thread".to_owned()),
+        "done",
+    );
+
+    let task = handler
+        .local_task_link("task-1")
+        .expect("task should remain stored");
+    assert!(!handler.is_active_local_task("task-1"));
+    assert_eq!(task.thread_id.as_deref(), Some("current-thread"));
+    assert!(task.completed_at.is_some());
+
+    let _ = fs::remove_file(index_path);
+}
+
 #[test]
 fn unlinked_failed_codex_turn_persists_assistant_error_in_runtime_handle() {
     let index_path = temp_runtime_work_index_path("persist-failed-assistant");
@@ -459,10 +514,13 @@ fn completed_responses_use_the_active_codex_turn_id() {
             "/tmp/project".to_owned(),
             "Task".to_owned(),
         ));
+        let execution_id = start_test_execution(&handler, &local_task_id);
         handler.handle_turn_result(
             &local_task_id,
+            execution_id,
             &request,
             Some(&ActiveCodexTurn {
+                execution_id,
                 thread_id: format!("thread-{case}"),
                 turn_id: "turn-1".to_owned(),
             }),
@@ -989,6 +1047,7 @@ async fn codex_app_server_restart_requires_confirmation_for_active_turns() {
         .insert(
             "thread-1".to_owned(),
             ActiveCodexTurn {
+                execution_id: 1,
                 thread_id: "thread-1".to_owned(),
                 turn_id: "turn-1".to_owned(),
             },
@@ -1263,7 +1322,7 @@ fn task_list_running_state_comes_from_executor_memory() {
     assert_eq!(idle_link.thread_status, "idle");
     assert_eq!(idle_link.turn_status.as_deref(), Some("completed"));
 
-    handler.mark_active_local_task("task-1");
+    start_test_execution(&handler, "task-1");
 
     let running_link = handler
         .link_from_thread(&thread)
@@ -1297,10 +1356,11 @@ fn active_local_task_routes_only_notifications_from_other_turns_globally() {
     link.thread_id = Some("thread-1".to_owned());
     link.updated_at = 1_780_000_000_000;
     handler.upsert_local_task(link);
-    handler.mark_active_local_task(local_task_id);
+    let execution_id = start_test_execution(&handler, local_task_id);
     handler.register_thread_event_route("thread-1", local_task_id.to_owned(), request, true);
     handler.record_active_codex_turn(
         local_task_id,
+        execution_id,
         "thread-1".to_owned(),
         "turn-current".to_owned(),
     );
@@ -1475,33 +1535,6 @@ fn codex_guidance_turn_mismatch_exposes_the_actual_turn_id() {
     );
 }
 
-#[test]
-fn persisted_terminal_status_reconciles_only_the_exact_last_turn_id() {
-    let mut link = RuntimeTaskLink::new_pending(
-        "task-1".to_owned(),
-        "/tmp/project".to_owned(),
-        "Task".to_owned(),
-    );
-    link.thread_id = Some("thread-1".to_owned());
-    link.status = "done".to_owned();
-    link.turn_status = Some("completed".to_owned());
-    link.completed_at = Some(123);
-    link.runtime_handle["lastTurnId"] = json!("turn-2");
-    let mut thread = json!({
-        "id": "thread-1",
-        "turns": [
-            {"id": "turn-1", "status": "interrupted", "items": []},
-            {"id": "turn-2", "status": "interrupted", "items": []}
-        ]
-    });
-
-    reconcile_persisted_codex_turn_status(&mut thread, &link);
-
-    assert_eq!(thread["turns"][0]["status"], "interrupted");
-    assert_eq!(thread["turns"][1]["status"], "completed");
-    assert_eq!(thread["turns"][1]["completedAt"], 123);
-}
-
 #[test]
 fn archived_cleanup_targets_do_not_delete_regular_project_root() {
     let link = RuntimeTaskLink::new_pending(
diff --git a/executor/src/runtime_work/handler/turns.rs b/executor/src/runtime_work/handler/turns.rs
index 02530c9f3e..706bce5d5a 100644
--- a/executor/src/runtime_work/handler/turns.rs
+++ b/executor/src/runtime_work/handler/turns.rs
@@ -77,23 +77,23 @@ impl RuntimeWorkRpcHandler {
         }
         log_executor_event("runtime work turn spawning", &fields);
 
-        self.mark_active_local_task(&local_task_id);
         let (request_user_input_tx, request_user_input_rx): (
             mpsc::Sender<Value>,
             CodexRequestUserInputReceiver,
         ) = mpsc::channel(1);
-        if let Ok(mut requests) = self.active_request_user_inputs.lock() {
-            requests.insert(local_task_id.clone(), request_user_input_tx);
-        }
         let (cancel_tx, cancel_rx) = oneshot::channel();
         let (stopped_tx, stopped_rx) = oneshot::channel();
-        self.set_active_turn_cancellation(
-            local_task_id.clone(),
-            ActiveTurnCancellation {
-                cancel: cancel_tx,
-                stopped: stopped_rx,
-            },
-        );
+        let execution_id =
+            self.start_local_task_execution(local_task_id.clone(), cancel_tx, stopped_rx);
+        if let Ok(mut requests) = self.active_request_user_inputs.lock() {
+            requests.insert(
+                local_task_id.clone(),
+                ActiveRequestUserInput {
+                    execution_id,
+                    sender: request_user_input_tx,
+                },
+            );
+        }
         let handler = self.clone();
         let turn_local_task_id = local_task_id.clone();
         let turn_handle = tokio::spawn(async move {
@@ -169,6 +169,7 @@ impl RuntimeWorkRpcHandler {
             });
             let active_turn_handler = handler.clone();
             let active_turn_local_task_id = turn_local_task_id.clone();
+            let active_turn_execution_id = execution_id;
             let active_turn_subtask_id = request.subtask_id.to_string();
             let active_turn_request = request.clone();
             let callback_hook_turn = Arc::clone(&hook_turn);
@@ -178,11 +179,13 @@ impl RuntimeWorkRpcHandler {
                         .lock()
                         .expect("hook turn context lock should not be poisoned") =
                         Some(ActiveCodexTurn {
+                            execution_id: active_turn_execution_id,
                             thread_id: thread_id.clone(),
                             turn_id: turn_id.clone(),
                         });
                     active_turn_handler.record_active_codex_turn(
                         &active_turn_local_task_id,
+                        active_turn_execution_id,
                         thread_id,
                         turn_id.clone(),
                     );
@@ -210,7 +213,8 @@ impl RuntimeWorkRpcHandler {
             let finished_turn_handler = handler.clone();
             let finished_turn_local_task_id = turn_local_task_id.clone();
             let active_turn_finished: CodexActiveTurnFinishedCallback = Box::new(move || {
-                finished_turn_handler.clear_active_codex_turn(&finished_turn_local_task_id);
+                finished_turn_handler
+                    .clear_active_codex_turn(&finished_turn_local_task_id, execution_id);
             });
             let result = handler
                 .codex_app_server
@@ -254,13 +258,10 @@ impl RuntimeWorkRpcHandler {
                     }),
                 );
                 let _ = mapper_handle.await;
-                handler.clear_active_turn_cancellation(&turn_local_task_id);
-                handler.clear_active_codex_turn(&turn_local_task_id);
-                handler.unmark_active_local_task(&turn_local_task_id);
+                handler.finish_local_task(&turn_local_task_id, execution_id, None, "cancelled");
+                handler.clear_active_codex_turn(&turn_local_task_id, execution_id);
                 handler.mark_thread_event_routes_idle_for_local_task(&turn_local_task_id);
-                if let Ok(mut requests) = handler.active_request_user_inputs.lock() {
-                    requests.remove(&turn_local_task_id);
-                }
+                handler.clear_active_request_user_input(&turn_local_task_id, execution_id);
                 let _ = stopped_tx.send(());
                 return;
             }
@@ -270,11 +271,15 @@ impl RuntimeWorkRpcHandler {
                 .lock()
                 .expect("hook turn context lock should not be poisoned")
                 .clone();
-            handler.handle_turn_result(&turn_local_task_id, &request, active_turn.as_ref(), result);
-            handler.clear_active_codex_turn(&turn_local_task_id);
-            if let Ok(mut requests) = handler.active_request_user_inputs.lock() {
-                requests.remove(&turn_local_task_id);
-            }
+            handler.handle_turn_result(
+                &turn_local_task_id,
+                execution_id,
+                &request,
+                active_turn.as_ref(),
+                result,
+            );
+            handler.clear_active_codex_turn(&turn_local_task_id, execution_id);
+            handler.clear_active_request_user_input(&turn_local_task_id, execution_id);
             let _ = stopped_tx.send(());
         });
         drop(turn_handle);
@@ -283,6 +288,7 @@ impl RuntimeWorkRpcHandler {
     pub(super) fn handle_turn_result(
         &self,
         local_task_id: &str,
+        execution_id: u64,
         request: &ExecutionRequest,
         active_turn: Option<&ActiveCodexTurn>,
         result: Result<crate::agents::CodexAppServerTurn, String>,
@@ -327,7 +333,12 @@ impl RuntimeWorkRpcHandler {
                     event_request.clone(),
                     false,
                 );
-                self.finish_local_task(local_task_id, Some(thread_id.clone()), status);
+                self.finish_local_task(
+                    local_task_id,
+                    execution_id,
+                    Some(thread_id.clone()),
+                    status,
+                );
                 self.mark_thread_event_route_idle(&thread_id);
                 self.register_codex_thread_workspace_root(&thread_id, &event_request);
                 match turn.outcome {
@@ -390,7 +401,7 @@ impl RuntimeWorkRpcHandler {
             }
             Err(error) => {
                 self.mark_thread_event_routes_idle_for_local_task(local_task_id);
-                self.finish_local_task(local_task_id, None, "failed");
+                self.finish_local_task(local_task_id, execution_id, None, "failed");
                 self.persist_failed_assistant_message(local_task_id, &event_request, &error);
                 let mut fields = task_fields(&event_request.task_id, &event_request.subtask_id);
                 fields.push(("local_task_id", local_task_id.to_owned()));
diff --git a/executor/src/runtime_work/response.rs b/executor/src/runtime_work/response.rs
index 89d9e6632f..348d2970d8 100644
--- a/executor/src/runtime_work/response.rs
+++ b/executor/src/runtime_work/response.rs
@@ -88,28 +88,6 @@ pub(crate) struct RuntimeTaskLink {
 }
 
 impl RuntimeTaskLink {
-    pub(crate) fn copy_execution_state_from(&mut self, current: &Self) {
-        self.status = current.status.clone();
-        self.running = current.running;
-        self.thread_status = current.thread_status.clone();
-        self.turn_status = current.turn_status.clone();
-        self.updated_at = current.updated_at;
-    }
-
-    pub(crate) fn preserve_runtime_state_from(&mut self, current: &Self) {
-        self.git_info = current.git_info.clone();
-        self.list_order = current.list_order;
-        self.group_workspace_path = current.group_workspace_path.clone();
-        self.group_project_key = current.group_project_key.clone();
-        self.pinned = current.pinned;
-        self.pinned_order = current.pinned_order;
-        let archived = self.status == "archived";
-        let current_archived = current.status == "archived";
-        if archived == current_archived {
-            self.copy_execution_state_from(current);
-        }
-    }
-
     pub fn new_pending(local_task_id: String, workspace_path: String, title: String) -> Self {
         Self {
             local_task_id,
@@ -117,11 +95,11 @@ impl RuntimeTaskLink {
             workspace_path,
             title,
             runtime: "codex".to_owned(),
-            status: "running".to_owned(),
-            running: true,
+            status: "active".to_owned(),
+            running: false,
             continuable: true,
-            thread_status: "active".to_owned(),
-            turn_status: Some("inProgress".to_owned()),
+            thread_status: "notLoaded".to_owned(),
+            turn_status: None,
             goal_status: None,
             supervisor: None,
             git_info: None,
@@ -206,10 +184,10 @@ impl RuntimeTaskLink {
             git_info.insert("currentBranch".to_owned(), Value::String(current_branch));
         }
         let running = !local_archived && execution_running;
-        let mut status = merged_task_status(thread, local_link.as_ref(), running, local_archived);
+        let mut status = merged_task_status(thread, running, local_archived);
         let mut thread_status =
             codex_thread_status_type(thread).unwrap_or_else(|| "notLoaded".to_owned());
-        let mut turn_status = task_turn_status(thread, local_link.as_ref(), running);
+        let mut turn_status = task_turn_status(thread, running);
         if !running {
             if runtime_status_is_running(&status) {
                 status = "active".to_owned();
@@ -833,32 +811,17 @@ fn thread_status(thread: &Value) -> String {
     .to_owned()
 }
 
-fn merged_task_status(
-    thread: &Value,
-    local_link: Option<&RuntimeTaskLink>,
-    running: bool,
-    archived: bool,
-) -> String {
+fn merged_task_status(thread: &Value, running: bool, archived: bool) -> String {
     if archived {
         return "archived".to_owned();
     }
     if running {
         return "running".to_owned();
     }
-    if let Some(status) = local_link
-        .map(|link| link.status.trim().to_ascii_lowercase())
-        .filter(|status| matches!(status.as_str(), "done" | "cancelled" | "failed"))
-    {
-        return status;
-    }
     thread_status(thread)
 }
 
-fn task_turn_status(
-    thread: &Value,
-    local_link: Option<&RuntimeTaskLink>,
-    running: bool,
-) -> Option<String> {
+fn task_turn_status(thread: &Value, running: bool) -> Option<String> {
     if running {
         return Some("inProgress".to_owned());
     }
@@ -868,17 +831,6 @@ fn task_turn_status(
         .and_then(|turns| turns.last())
         .and_then(|turn| string_field(turn, "status"))
         .map(normalize_codex_turn_status)
-        .or_else(|| local_link.and_then(|link| link.turn_status.clone()))
-        .or_else(|| {
-            local_link.and_then(
-                |link| match link.status.trim().to_ascii_lowercase().as_str() {
-                    "done" => Some("completed".to_owned()),
-                    "cancelled" | "canceled" => Some("interrupted".to_owned()),
-                    "failed" => Some("failed".to_owned()),
-                    _ => None,
-                },
-            )
-        })
 }
 
 fn normalize_codex_turn_status(status: String) -> String {
@@ -1113,30 +1065,25 @@ mod tests {
     }
 
     #[test]
-    fn idle_thread_preserves_local_terminal_task_statuses() {
-        for (task_status, turn_status) in [
-            ("done", "completed"),
-            ("cancelled", "interrupted"),
+    fn idle_thread_uses_provider_turn_status() {
+        for (provider_status, turn_status) in [
+            ("completed", "completed"),
+            ("interrupted", "interrupted"),
             ("failed", "failed"),
         ] {
-            let local_link = RuntimeTaskLink {
-                status: task_status.to_owned(),
-                running: false,
-                turn_status: Some(turn_status.to_owned()),
-                ..RuntimeTaskLink::default()
-            };
             let link = RuntimeTaskLink::from_thread_metadata(
                 &json!({
                     "id": "thread-1",
                     "status": "idle",
                     "cwd": "/workspace/project",
+                    "turns": [{"status": provider_status}],
                 }),
-                Some(local_link),
+                None,
                 "/workspace/project".to_owned(),
                 false,
             );
 
-            assert_eq!(link.status, task_status);
+            assert_eq!(link.status, "active");
             assert!(!link.running);
             assert!(link.continuable);
             assert_eq!(link.thread_status, "idle");
diff --git a/executor/src/runtime_work/store.rs b/executor/src/runtime_work/store.rs
index 2da2d8fc94..8f869ae695 100644
--- a/executor/src/runtime_work/store.rs
+++ b/executor/src/runtime_work/store.rs
@@ -135,14 +135,6 @@ impl RuntimeWorkStore {
         self.update_task_with_persistence(local_task_id, updater, true)
     }
 
-    pub fn update_task_execution_state(&self, runtime_state: &RuntimeTaskLink) {
-        self.update_task_with_persistence(
-            &runtime_state.local_task_id,
-            |task| task.copy_execution_state_from(runtime_state),
-            false,
-        );
-    }
-
     fn update_task_with_persistence(
         &self,
         local_task_id: &str,
@@ -204,13 +196,8 @@ impl RuntimeWorkStore {
             return;
         }
 
-        let mut disk_index = read_index_from_path(&self.index_path);
+        let disk_index = read_index_from_path(&self.index_path);
         if let Ok(mut index) = self.index.lock() {
-            for (task_id, disk_task) in &mut disk_index.tasks {
-                if let Some(current_task) = index.tasks.get(task_id) {
-                    disk_task.preserve_runtime_state_from(current_task);
-                }
-            }
             *index = disk_index;
         }
         if let Ok(mut signature) = self.index_signature.lock() {
@@ -266,13 +253,7 @@ fn strip_transient_task_state(index: &mut Value) {
         task.remove("status");
         task.remove("running");
         task.remove("thread_status");
-        if !task
-            .get("turn_status")
-            .and_then(Value::as_str)
-            .is_some_and(is_terminal_turn_status)
-        {
-            task.remove("turn_status");
-        }
+        task.remove("turn_status");
         task.insert("archived".to_owned(), Value::Bool(archived));
     }
 }
@@ -298,41 +279,20 @@ fn restore_persisted_task_metadata(index: &mut Value) {
                     .as_deref()
                     .is_some_and(|status| status.eq_ignore_ascii_case("archived"))
             });
-        let restored_status = legacy_status
-            .filter(|status| {
-                matches!(
-                    status.trim().to_ascii_lowercase().as_str(),
-                    "done" | "cancelled" | "canceled" | "failed"
-                )
-            })
-            .unwrap_or_else(|| "active".to_owned());
         task.insert(
             "status".to_owned(),
             Value::String(if archived {
                 "archived".to_owned()
             } else {
-                restored_status
+                "active".to_owned()
             }),
         );
         task.remove("running");
         task.remove("thread_status");
-        if !task
-            .get("turn_status")
-            .and_then(Value::as_str)
-            .is_some_and(is_terminal_turn_status)
-        {
-            task.remove("turn_status");
-        }
+        task.remove("turn_status");
     }
 }
 
-fn is_terminal_turn_status(status: &str) -> bool {
-    matches!(
-        status.replace(['_', '-'], "").to_ascii_lowercase().as_str(),
-        "completed" | "done" | "failed" | "error" | "interrupted" | "cancelled" | "canceled"
-    )
-}
-
 fn index_file_signature(index_path: &Path) -> Option<IndexFileSignature> {
     let metadata = fs::metadata(index_path).ok()?;
     let modified_ms = metadata
@@ -453,7 +413,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn shared_index_reload_preserves_process_local_running_state() {
+    fn shared_index_never_persists_execution_state() {
         let directory = tempfile::tempdir().expect("temporary directory should be created");
         let index_path = directory.path().join("index.json");
         let owner_store = RuntimeWorkStore::new(index_path.clone());
@@ -476,10 +436,10 @@ mod tests {
         let owner_task = owner_store
             .get_task("owner-task")
             .expect("owner task should survive peer writes");
-        assert!(owner_task.running);
-        assert_eq!(owner_task.status, "running");
-        assert_eq!(owner_task.thread_status, "active");
-        assert_eq!(owner_task.turn_status.as_deref(), Some("inProgress"));
+        assert!(!owner_task.running);
+        assert_eq!(owner_task.status, "active");
+        assert_eq!(owner_task.thread_status, "notLoaded");
+        assert_eq!(owner_task.turn_status, None);
 
         let persisted: Value = serde_json::from_slice(
             &fs::read(&index_path).expect("shared index should be readable"),
@@ -495,42 +455,6 @@ mod tests {
         assert_eq!(persisted_owner.get("archived"), Some(&Value::Bool(false)));
     }
 
-    #[test]
-    fn shared_index_reload_preserves_process_local_inactive_execution_state() {
-        let directory = tempfile::tempdir().expect("temporary directory should be created");
-        let index_path = directory.path().join("index.json");
-        let owner_store = RuntimeWorkStore::new(index_path.clone());
-        let peer_store = RuntimeWorkStore::new(index_path);
-        let mut owner_task = RuntimeTaskLink::new_pending(
-            "owner-task".to_owned(),
-            "/tmp/owner".to_owned(),
-            "Owner task".to_owned(),
-        );
-
-        owner_store.upsert_task(owner_task.clone());
-        owner_task.status = "done".to_owned();
-        owner_task.running = false;
-        owner_task.thread_status = "idle".to_owned();
-        owner_task.turn_status = Some("completed".to_owned());
-        owner_store.update_task_execution_state(&owner_task);
-        peer_store.upsert_task(RuntimeTaskLink::new_imported(
-            "peer-task".to_owned(),
-            "/tmp/peer".to_owned(),
-            "Peer task".to_owned(),
-            "codex".to_owned(),
-            serde_json::json!({}),
-            serde_json::json!({}),
-        ));
-
-        let reloaded = owner_store
-            .get_task("owner-task")
-            .expect("owner task should survive peer writes");
-        assert_eq!(reloaded.status, "done");
-        assert!(!reloaded.running);
-        assert_eq!(reloaded.thread_status, "idle");
-        assert_eq!(reloaded.turn_status.as_deref(), Some("completed"));
-    }
-
     #[test]
     fn persisted_archive_metadata_restores_without_task_status_fields() {
         let directory = tempfile::tempdir().expect("temporary directory should be created");
@@ -558,7 +482,7 @@ mod tests {
     }
 
     #[test]
-    fn terminal_turn_status_persists_without_live_execution_state() {
+    fn terminal_turn_status_is_not_persisted() {
         let directory = tempfile::tempdir().expect("temporary directory should be created");
         let index_path = directory.path().join("index.json");
         let store = RuntimeWorkStore::new(index_path.clone());
@@ -584,10 +508,7 @@ mod tests {
         assert!(!task.contains_key("status"));
         assert!(!task.contains_key("running"));
         assert!(!task.contains_key("thread_status"));
-        assert_eq!(
-            task.get("turn_status"),
-            Some(&Value::String("completed".to_owned()))
-        );
+        assert!(!task.contains_key("turn_status"));
 
         let restored = RuntimeWorkStore::new(index_path)
             .get_task("completed-task")
@@ -595,7 +516,7 @@ mod tests {
         assert!(!restored.running);
         assert_eq!(restored.status, "active");
         assert_eq!(restored.thread_status, "notLoaded");
-        assert_eq!(restored.turn_status.as_deref(), Some("completed"));
+        assert_eq!(restored.turn_status, None);
     }
 
     #[test]

From 22a6ae1e757e7546275c3add451818a89badc798 Mon Sep 17 00:00:00 2001
From: axb <qindi@staff.weibo.com>
Date: Tue, 4 Aug 2026 22:06:56 +0800
Subject: [PATCH 5/7] test(executor): reject persisted runtime task status

---
 executor/tests/app_runtime_work_native_update_contract.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/executor/tests/app_runtime_work_native_update_contract.rs b/executor/tests/app_runtime_work_native_update_contract.rs
index 4e924b0474..c13102f6dc 100644
--- a/executor/tests/app_runtime_work_native_update_contract.rs
+++ b/executor/tests/app_runtime_work_native_update_contract.rs
@@ -268,7 +268,7 @@ async fn runtime_task_list_ignores_persisted_running_state_when_thread_is_missin
 }
 
 #[tokio::test]
-async fn runtime_task_list_preserves_local_failed_state_when_codex_thread_is_idle() {
+async fn runtime_task_list_ignores_persisted_failed_state_when_codex_thread_is_idle() {
     let _lock = env_lock().await;
     let executor_home = temp_path("runtime-local-failed-home", "dir");
     let _home = EnvGuard::set("WEGENT_EXECUTOR_HOME", &executor_home.display().to_string());
@@ -321,11 +321,11 @@ async fn runtime_task_list_preserves_local_failed_state_when_codex_thread_is_idl
         .find(|task| task["taskId"] == "local-failed-running-rollout")
         .unwrap();
 
-    assert_eq!(locally_failed["status"], "failed");
+    assert_eq!(locally_failed["status"], "active");
     assert_eq!(locally_failed["running"], false);
     assert_eq!(locally_failed["continuable"], true);
     assert_eq!(locally_failed["threadStatus"], "idle");
-    assert_eq!(locally_failed["turnStatus"], "failed");
+    assert!(locally_failed["turnStatus"].is_null());
 }
 
 fn write_fake_codex(log_path: &Path) -> PathBuf {

From 7affe2e2749c6603602ed5494f259f965bde99c9 Mon Sep 17 00:00:00 2001
From: axb <qindi@staff.weibo.com>
Date: Tue, 4 Aug 2026 22:42:54 +0800
Subject: [PATCH 6/7] fix(wework): sync board status from runtime events

---
 wework/e2e/desktop/task-flow.e2e.mjs          |  8 +-
 .../workbench/WorkbenchProvider.test.tsx      | 83 +++++++++++++++++++
 .../features/workbench/WorkbenchProvider.tsx  | 17 +---
 .../features/workbench/runtimePaneMessages.ts | 20 +++--
 .../RuntimeTaskLifecycleStore.test.ts         | 17 +++-
 .../RuntimeTaskLifecycleStore.ts              | 14 +++-
 .../RuntimeTaskMachine.ts                     | 13 ++-
 .../workbench/runtimeTaskLifecycle/reducer.ts |  6 ++
 .../workbench/runtimeTaskLifecycle/types.ts   | 10 ++-
 9 files changed, 159 insertions(+), 29 deletions(-)

diff --git a/wework/e2e/desktop/task-flow.e2e.mjs b/wework/e2e/desktop/task-flow.e2e.mjs
index e87fa2bd4c..081eea45fc 100644
--- a/wework/e2e/desktop/task-flow.e2e.mjs
+++ b/wework/e2e/desktop/task-flow.e2e.mjs
@@ -2774,14 +2774,14 @@ async function verifyRunningFollowUpFork({
     text: RUNNING_FORK_COMPLETION_TEXT,
     timeoutMs: DEFAULT_STEP_TIMEOUT_MS,
   })
-  const completedRuntimeIndex = JSON.parse(
+  const settledRuntimeIndex = JSON.parse(
     await readFile(join(executorHome, 'runtime-work', 'index.json'), 'utf8')
   )
   const sourceTaskId = sourceTaskRowTestId.replace('runtime-local-task-row-', '')
   assert.equal(
-    completedRuntimeIndex.tasks[sourceTaskId]?.turn_status,
-    'completed',
-    'The source follow-up was interrupted instead of completing after the fork'
+    Object.hasOwn(settledRuntimeIndex.tasks[sourceTaskId] ?? {}, 'turn_status'),
+    false,
+    'The completed source follow-up leaked process-local turn status into the runtime index'
   )
 }
 
diff --git a/wework/src/features/workbench/WorkbenchProvider.test.tsx b/wework/src/features/workbench/WorkbenchProvider.test.tsx
index deafc1b8ac..5a99c92d53 100644
--- a/wework/src/features/workbench/WorkbenchProvider.test.tsx
+++ b/wework/src/features/workbench/WorkbenchProvider.test.tsx
@@ -9097,6 +9097,89 @@ describe('WorkbenchProvider runtime tasks', () => {
     )
   })
 
+  test('syncs board completion from the in-memory terminal event while task status stays active', async () => {
+    let streamHandlers: ChatStreamHandlers = {}
+    const subscribe = vi.fn((handlers: ChatStreamHandlers) => {
+      if (handlers.onChatStart) streamHandlers = handlers
+      return vi.fn()
+    })
+    const updateTaskTrackingStatus = vi.fn().mockResolvedValue(null)
+    const runtimeWorkApi = createRuntimeWorkApiMock({
+      listRuntimeWork: vi.fn().mockResolvedValue(
+        createRuntimeWork({
+          projects: [
+            {
+              project: { id: 7, name: 'Wegent' },
+              deviceWorkspaces: [
+                {
+                  deviceId: 'device-1',
+                  deviceName: 'Project Device',
+                  deviceStatus: 'online',
+                  workspacePath: '/workspace/project-alpha',
+                  mapped: true,
+                  available: true,
+                  tasks: [
+                    {
+                      taskId: 'runtime-a',
+                      workspacePath: '/workspace/project-alpha',
+                      title: 'Runtime A',
+                      runtime: 'codex',
+                      running: false,
+                      status: 'active',
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+          totalTasks: 1,
+        })
+      ),
+    })
+    const services = createWorkbenchServices({
+      runtimeWorkApi: runtimeWorkApi as WorkbenchServices['runtimeWorkApi'],
+      chatStream: {
+        subscribe,
+      } as unknown as WorkbenchServices['chatStream'],
+      projectSpaceApis: {
+        local: { updateTaskTrackingStatus },
+      } as unknown as WorkbenchServices['projectSpaceApis'],
+    })
+
+    renderWorkbench(<RuntimeTopLevelStreamLifecycleProbe />, services)
+    await waitFor(() => expect(streamHandlers.onChatStart).toBeDefined())
+
+    act(() => {
+      streamHandlers.onChatStart?.({
+        taskId: 'runtime-a',
+        subtaskId: '101',
+        shellType: 'Codex',
+        deviceId: 'device-1',
+      })
+    })
+    await waitFor(() =>
+      expect(updateTaskTrackingStatus).toHaveBeenCalledWith(
+        expect.objectContaining({ deviceId: 'device-1', taskId: 'runtime-a' }),
+        'running'
+      )
+    )
+
+    act(() => {
+      streamHandlers.onChatDone?.({
+        taskId: 'runtime-a',
+        subtaskId: '101',
+        deviceId: 'device-1',
+        result: { value: 'done' },
+      })
+    })
+    await waitFor(() =>
+      expect(updateTaskTrackingStatus).toHaveBeenCalledWith(
+        expect.objectContaining({ deviceId: 'device-1', taskId: 'runtime-a' }),
+        'succeeded'
+      )
+    )
+  })
+
   test('sends queued runtime messages when the task becomes idle', async () => {
     let streamHandlers: ChatStreamHandlers = {}
     const subscribe = vi.fn((handlers: ChatStreamHandlers) => {
diff --git a/wework/src/features/workbench/WorkbenchProvider.tsx b/wework/src/features/workbench/WorkbenchProvider.tsx
index ef92548ca9..6ca20b62eb 100644
--- a/wework/src/features/workbench/WorkbenchProvider.tsx
+++ b/wework/src/features/workbench/WorkbenchProvider.tsx
@@ -250,18 +250,9 @@ export function WorkbenchProvider({
     ].filter((api, index, values) => Boolean(api) && values.indexOf(api) === index)
     if (!trackingApis.length) return
     for (const [key, lifecycle] of lifecycleSnapshot.tasks) {
-      const taskStatus = lifecycle.task?.status?.toLowerCase() ?? ''
-      const executionStatus = lifecycle.derived.isRunning
-        ? 'running'
-        : taskStatus === 'failed'
-          ? 'failed'
-          : taskStatus === 'cancelled' || taskStatus === 'canceled'
-            ? 'cancelled'
-            : lifecycle.execution.known && taskStatus === 'done'
-              ? 'succeeded'
-              : null
+      const executionStatus = lifecycle.derived.isRunning ? 'running' : lifecycle.turn.outcome
       if (!executionStatus) continue
-      const signature = `${executionStatus}:${taskStatus}`
+      const signature = executionStatus
       if (trackingStatusSignaturesRef.current.get(key) === signature) continue
       trackingStatusSignaturesRef.current.set(key, signature)
       void Promise.allSettled(
@@ -1284,9 +1275,9 @@ export function WorkbenchProvider({
             markRuntimeConversationAssistantStarted(address)
             lifecycleStore.turnStarted(address, turnId)
           },
-          onAssistantSettled: (address, turnId) => {
+          onAssistantSettled: (address, turnId, outcome) => {
             settleRuntimeConversationSubagents(address)
-            lifecycleStore.turnSettled(address, turnId)
+            lifecycleStore.turnSettled(address, turnId, outcome)
           },
           onContextUsageUpdated: updateCanonicalRuntimeContextUsage,
           onSubagentActivity: applyRuntimeConversationSubagentActivity,
diff --git a/wework/src/features/workbench/runtimePaneMessages.ts b/wework/src/features/workbench/runtimePaneMessages.ts
index 7e620395be..221a668b6d 100644
--- a/wework/src/features/workbench/runtimePaneMessages.ts
+++ b/wework/src/features/workbench/runtimePaneMessages.ts
@@ -39,7 +39,7 @@ export type RuntimePaneMessageAction = WorkbenchMessageAction<Attachment, TurnFi
 export interface RuntimeTaskStreamHandlers {
   onMessageAction: (action: RuntimePaneMessageAction) => void
   onAssistantStart?: (turnId: string) => void
-  onAssistantSettled?: (turnId: string) => void
+  onAssistantSettled?: (turnId: string, outcome: 'succeeded' | 'failed' | 'cancelled') => void
   onRefreshWorkLists?: () => void
   onContextUsageUpdated?: (usage: RuntimeContextUsage) => void
   onSubagentActivity?: (payload: RuntimeSubagentActivityPayload) => void
@@ -55,7 +55,11 @@ export interface RuntimeTaskStreamHandlers {
 export interface RuntimeConversationStreamHandlers {
   onMessageAction: (address: RuntimeTaskAddress, action: RuntimePaneMessageAction) => void
   onAssistantStart?: (address: RuntimeTaskAddress, turnId: string) => void
-  onAssistantSettled?: (address: RuntimeTaskAddress, turnId: string) => void
+  onAssistantSettled?: (
+    address: RuntimeTaskAddress,
+    turnId: string,
+    outcome: 'succeeded' | 'failed' | 'cancelled'
+  ) => void
   onRefreshWorkLists?: (address: RuntimeTaskAddress) => void
   onContextUsageUpdated?: (address: RuntimeTaskAddress, usage: RuntimeContextUsage) => void
   onSubagentActivity?: (
@@ -101,7 +105,8 @@ export function createRuntimeConversationStreamHandlers(
     const created = createRuntimeTaskStreamHandlers(address, {
       onMessageAction: action => handlers.onMessageAction(address, action),
       onAssistantStart: turnId => handlers.onAssistantStart?.(address, turnId),
-      onAssistantSettled: turnId => handlers.onAssistantSettled?.(address, turnId),
+      onAssistantSettled: (turnId, outcome) =>
+        handlers.onAssistantSettled?.(address, turnId, outcome),
       onRefreshWorkLists: () => handlers.onRefreshWorkLists?.(address),
       onContextUsageUpdated: usage => handlers.onContextUsageUpdated?.(address, usage),
       onSubagentActivity: payload => handlers.onSubagentActivity?.(address, payload),
@@ -266,7 +271,7 @@ export function createRuntimeTaskStreamHandlers(
         blocks,
         fileChanges,
       })
-      handlers.onAssistantSettled?.(identity.subtaskId)
+      handlers.onAssistantSettled?.(identity.subtaskId, 'succeeded')
       handlers.onRefreshWorkLists?.()
     },
     onChatError: payload => {
@@ -288,7 +293,8 @@ export function createRuntimeTaskStreamHandlers(
       logAcceptedRuntimeTerminalEvent('chat:error', address, payload, {
         errorType: payload.type ?? null,
       })
-      if (isCancelledRuntimeError(payload)) {
+      const cancelled = isCancelledRuntimeError(payload)
+      if (cancelled) {
         handlers.onMessageAction({
           type: 'assistant_cancelled',
           subtaskId: identity.subtaskId,
@@ -308,7 +314,7 @@ export function createRuntimeTaskStreamHandlers(
           errorType: payload.type,
         })
       }
-      handlers.onAssistantSettled?.(identity.subtaskId)
+      handlers.onAssistantSettled?.(identity.subtaskId, cancelled ? 'cancelled' : 'failed')
       streamedFileChanges.delete(identity.subtaskId)
       handlers.onRefreshWorkLists?.()
     },
@@ -345,7 +351,7 @@ export function createRuntimeTaskStreamHandlers(
           type: 'assistant_done',
           subtaskId: identity.subtaskId,
         })
-        handlers.onAssistantSettled?.(identity.subtaskId)
+        handlers.onAssistantSettled?.(identity.subtaskId, 'succeeded')
         handlers.onRefreshWorkLists?.()
       }
     },
diff --git a/wework/src/features/workbench/runtimeTaskLifecycle/RuntimeTaskLifecycleStore.test.ts b/wework/src/features/workbench/runtimeTaskLifecycle/RuntimeTaskLifecycleStore.test.ts
index e2cdd9838d..f9aa6cc068 100644
--- a/wework/src/features/workbench/runtimeTaskLifecycle/RuntimeTaskLifecycleStore.test.ts
+++ b/wework/src/features/workbench/runtimeTaskLifecycle/RuntimeTaskLifecycleStore.test.ts
@@ -82,11 +82,26 @@ describe('RuntimeTaskLifecycleStore', () => {
     store.turnStarted(address)
     expect(store.getTask(address)?.turn.phase).toBe('streaming')
 
-    store.turnSettled(address)
+    store.turnSettled(address, null, 'succeeded')
     expect(store.getTask(address)?.turn.phase).toBe('idle')
+    expect(store.getTask(address)?.turn.outcome).toBe('succeeded')
     expect(store.getTask(address)?.derived.isRunning).toBe(false)
   })
 
+  test('tracks terminal turn outcome without relying on persisted task status', () => {
+    const store = new RuntimeTaskLifecycleStore('test')
+    store.syncRuntimeWork(runtimeWork(task({ status: 'active' })))
+
+    store.turnStarted(address, 'turn-1')
+    store.turnSettled(address, 'turn-1', 'succeeded')
+
+    expect(store.getTask(address)?.task?.status).toBe('active')
+    expect(store.getTask(address)?.turn.outcome).toBe('succeeded')
+
+    store.turnStarted(address, 'turn-2')
+    expect(store.getTask(address)?.turn.outcome).toBeNull()
+  })
+
   test('does not regress a stream that starts before the create acknowledgement', () => {
     const store = new RuntimeTaskLifecycleStore('test')
 
diff --git a/wework/src/features/workbench/runtimeTaskLifecycle/RuntimeTaskLifecycleStore.ts b/wework/src/features/workbench/runtimeTaskLifecycle/RuntimeTaskLifecycleStore.ts
index 4c79e75b24..b3818607d6 100644
--- a/wework/src/features/workbench/runtimeTaskLifecycle/RuntimeTaskLifecycleStore.ts
+++ b/wework/src/features/workbench/runtimeTaskLifecycle/RuntimeTaskLifecycleStore.ts
@@ -110,8 +110,12 @@ export class RuntimeTaskLifecycleStore {
     this.dispatch(address, { type: 'turn_started', turnId })
   }
 
-  turnSettled(address: RuntimeTaskAddress, turnId?: string | null): void {
-    this.dispatch(address, { type: 'turn_settled', turnId })
+  turnSettled(
+    address: RuntimeTaskAddress,
+    turnId?: string | null,
+    outcome?: 'succeeded' | 'failed' | 'cancelled'
+  ): void {
+    this.dispatch(address, { type: 'turn_settled', turnId, outcome })
   }
 
   syncTranscript(
@@ -190,6 +194,12 @@ export class RuntimeTaskLifecycleStore {
     } else if (previousState.turnPhase === 'awaiting') {
       nextMachine.dispatch({ type: 'send_accepted' })
     }
+    if (previousState.turnOutcome) {
+      nextMachine.dispatch({
+        type: 'turn_settled',
+        outcome: previousState.turnOutcome,
+      })
+    }
     if (previousState.unread) nextMachine.dispatch({ type: 'marked_unread' })
     this.machines.delete(previousKey)
     if (this.currentTaskKey === previousKey) this.currentTaskKey = nextKey
diff --git a/wework/src/features/workbench/runtimeTaskLifecycle/RuntimeTaskMachine.ts b/wework/src/features/workbench/runtimeTaskLifecycle/RuntimeTaskMachine.ts
index 1aaa2864ee..316f803659 100644
--- a/wework/src/features/workbench/runtimeTaskLifecycle/RuntimeTaskMachine.ts
+++ b/wework/src/features/workbench/runtimeTaskLifecycle/RuntimeTaskMachine.ts
@@ -15,6 +15,7 @@ export class RuntimeTaskMachine {
       task: null,
       executionPhase: 'unknown',
       turnPhase: 'idle',
+      turnOutcome: null,
       activeTurnId: null,
       goalStatus: null,
       continuable: false,
@@ -34,7 +35,16 @@ export class RuntimeTaskMachine {
   }
 
   getSnapshot(): RuntimeTaskLifecycleSnapshot {
-    const { address, task, executionPhase, turnPhase, goalStatus, continuable, unread } = this.state
+    const {
+      address,
+      task,
+      executionPhase,
+      turnPhase,
+      turnOutcome,
+      goalStatus,
+      continuable,
+      unread,
+    } = this.state
     const executionKnown = executionPhase !== 'unknown'
     const isRunning =
       executionPhase === 'starting' || executionPhase === 'running' || executionPhase === 'stopping'
@@ -54,6 +64,7 @@ export class RuntimeTaskMachine {
       turn: {
         phase: turnPhase,
         active: isTurnActive,
+        outcome: turnOutcome,
       },
       goalStatus,
       continuable,
diff --git a/wework/src/features/workbench/runtimeTaskLifecycle/reducer.ts b/wework/src/features/workbench/runtimeTaskLifecycle/reducer.ts
index 4a0d5e23eb..75bfb089d9 100644
--- a/wework/src/features/workbench/runtimeTaskLifecycle/reducer.ts
+++ b/wework/src/features/workbench/runtimeTaskLifecycle/reducer.ts
@@ -49,6 +49,7 @@ export function reduceRuntimeTaskLifecycle(
         ...state,
         executionPhase: 'starting',
         turnPhase: 'submitting',
+        turnOutcome: null,
         expectedExecutorRunning: true,
         unread: false,
       }
@@ -58,6 +59,7 @@ export function reduceRuntimeTaskLifecycle(
         ...state,
         executionPhase: 'running',
         turnPhase: state.turnPhase === 'streaming' ? 'streaming' : 'awaiting',
+        turnOutcome: null,
         expectedExecutorRunning: true,
       }
 
@@ -90,6 +92,7 @@ export function reduceRuntimeTaskLifecycle(
       return {
         ...state,
         executionPhase: 'running',
+        turnOutcome: null,
         expectedExecutorRunning: true,
         unread: false,
       }
@@ -108,6 +111,7 @@ export function reduceRuntimeTaskLifecycle(
         ...state,
         executionPhase: 'running',
         turnPhase: 'streaming',
+        turnOutcome: null,
         activeTurnId: event.turnId ?? null,
         expectedExecutorRunning: true,
         unread: false,
@@ -121,6 +125,7 @@ export function reduceRuntimeTaskLifecycle(
         ...state,
         executionPhase: state.goalStatus === 'active' ? state.executionPhase : 'idle',
         turnPhase: 'idle',
+        turnOutcome: event.outcome ?? state.turnOutcome,
         activeTurnId: null,
         expectedExecutorRunning:
           state.goalStatus === 'active' ? state.expectedExecutorRunning : false,
@@ -133,6 +138,7 @@ export function reduceRuntimeTaskLifecycle(
             ...state,
             executionPhase: 'running',
             turnPhase: 'streaming',
+            turnOutcome: null,
             activeTurnId: event.turnId ?? null,
             expectedExecutorRunning: true,
           }
diff --git a/wework/src/features/workbench/runtimeTaskLifecycle/types.ts b/wework/src/features/workbench/runtimeTaskLifecycle/types.ts
index 7f1be1910c..f0372020fb 100644
--- a/wework/src/features/workbench/runtimeTaskLifecycle/types.ts
+++ b/wework/src/features/workbench/runtimeTaskLifecycle/types.ts
@@ -4,11 +4,14 @@ export type RuntimeTaskExecutionPhase = 'unknown' | 'idle' | 'starting' | 'runni
 
 export type RuntimeTaskTurnPhase = 'idle' | 'submitting' | 'awaiting' | 'streaming'
 
+export type RuntimeTaskTurnOutcome = 'succeeded' | 'failed' | 'cancelled' | null
+
 export interface RuntimeTaskLifecycleState {
   address: RuntimeTaskAddress
   task: RuntimeTaskSummary | null
   executionPhase: RuntimeTaskExecutionPhase
   turnPhase: RuntimeTaskTurnPhase
+  turnOutcome: RuntimeTaskTurnOutcome
   activeTurnId: string | null
   goalStatus: RuntimeGoalStatus | null
   continuable: boolean
@@ -40,6 +43,7 @@ export interface RuntimeTaskLifecycleSnapshot {
   turn: {
     phase: RuntimeTaskTurnPhase
     active: boolean
+    outcome: RuntimeTaskTurnOutcome
   }
   goalStatus: RuntimeGoalStatus | null
   continuable: boolean
@@ -61,7 +65,11 @@ export type RuntimeTaskLifecycleEvent =
   | { type: 'executor_started' }
   | { type: 'executor_settled' }
   | { type: 'turn_started'; turnId?: string | null }
-  | { type: 'turn_settled'; turnId?: string | null }
+  | {
+      type: 'turn_settled'
+      turnId?: string | null
+      outcome?: Exclude<RuntimeTaskTurnOutcome, null>
+    }
   | { type: 'turn_recovered'; streaming: boolean; turnId?: string | null }
   | { type: 'goal_status_received'; goalStatus: RuntimeGoalStatus | null }
   | { type: 'marked_read' }

From 09db22f1f0ed1a2969c0d6204ab73633c794a013 Mon Sep 17 00:00:00 2001
From: axb <qindi@staff.weibo.com>
Date: Tue, 4 Aug 2026 23:34:11 +0800
Subject: [PATCH 7/7] refactor(wework): store project space selection locally

---
 backend/app/api/endpoints/cloud_projects.py   |  64 -------
 backend/app/models/__init__.py                |   2 -
 backend/app/models/cloud_project.py           |   2 -
 backend/app/models/delivery.py                |   8 -
 backend/app/schemas/cloud_project.py          |  28 ---
 .../app/services/cloud_projects/service.py    | 121 +------------
 backend/tests/api/test_cloud_projects_api.py  |  86 ---------
 .../cloud-project-collaboration.md            |  15 +-
 docs/en/wework/projects.md                    |   2 +-
 .../cloud-project-collaboration.md            |  15 +-
 docs/zh/wework/projects.md                    |   2 +-
 .../src/runtime_work/codex_global_state.rs    |  85 +++++++--
 .../runtime_work/handler/helpers/routing.rs   |   1 +
 executor/src/runtime_work/handler/tasks.rs    |   1 +
 .../src/runtime_work/handler/workspaces.rs    |  10 +-
 executor/src/runtime_work/response.rs         |   5 +
 .../app_runtime_work_workspace_contract.rs    |  32 +++-
 wework/src/api/deliveries.ts                  |  38 ----
 wework/src/api/local/localDelivery.test.ts    |  32 ----
 wework/src/api/local/localDelivery.ts         |  97 ----------
 wework/src/api/local/localServices.ts         |  11 ++
 .../components/layout/DesktopSidebar.test.tsx |   7 +-
 .../src/components/layout/DesktopSidebar.tsx  |  10 +-
 .../layout/DesktopWorkbenchLayout.tsx         |   9 +-
 .../layout/DesktopWorkbenchMain.tsx           | 164 +++++------------
 .../projects/LocalProjectEditDialog.test.tsx  |  39 ++--
 .../projects/LocalProjectEditDialog.tsx       |  59 +++----
 .../features/todo/CloudProjectManageView.tsx  | 161 +----------------
 .../src/features/todo/CloudTodoWorkspace.tsx  |   1 -
 .../todo/projectSpaceLocalBindings.test.ts    | 113 ------------
 .../todo/projectSpaceLocalBindings.ts         | 166 ------------------
 .../todo/projectSpaceSelection.test.ts        |  82 +++++++++
 .../features/todo/projectSpaceSelection.ts    |  68 +++++++
 .../workbench/remoteRuntimeWorkCache.test.ts  |   8 +
 .../workbench/remoteRuntimeWorkCache.ts       |   9 +
 .../workbench/useWorkbenchProjectActions.ts   |   9 +-
 .../workbench/workbenchContextTypes.ts        |   2 +
 wework/src/i18n/locales/en/common.json        |  10 --
 wework/src/i18n/locales/zh-CN/common.json     |  10 --
 wework/src/types/api.ts                       |   8 +
 40 files changed, 424 insertions(+), 1168 deletions(-)
 delete mode 100644 wework/src/features/todo/projectSpaceLocalBindings.test.ts
 delete mode 100644 wework/src/features/todo/projectSpaceLocalBindings.ts
 create mode 100644 wework/src/features/todo/projectSpaceSelection.test.ts
 create mode 100644 wework/src/features/todo/projectSpaceSelection.ts

diff --git a/backend/app/api/endpoints/cloud_projects.py b/backend/app/api/endpoints/cloud_projects.py
index e6c28418d7..7cdd6968ff 100644
--- a/backend/app/api/endpoints/cloud_projects.py
+++ b/backend/app/api/endpoints/cloud_projects.py
@@ -27,9 +27,6 @@
     CloudProjectMemberUpdate,
     CloudProjectResponse,
     CloudProjectUpdate,
-    LocalBindingCreate,
-    LocalBindingResponse,
-    LocalBindingUpdate,
 )
 from app.services.cloud_files import cloud_file_service
 from app.services.cloud_projects import cloud_project_service
@@ -105,67 +102,6 @@ def archive_cloud_project(
     cloud_project_service.archive(db, project_id, current_user.id, version)
 
 
-@router.post(
-    "/{project_id}/local-bindings",
-    response_model=LocalBindingResponse,
-    status_code=status.HTTP_201_CREATED,
-)
-def add_local_binding(
-    project_id: int,
-    values: LocalBindingCreate,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-) -> LocalBindingResponse:
-    binding = cloud_project_service.add_local_binding(
-        db, project_id, current_user.id, values
-    )
-    return LocalBindingResponse.model_validate(binding)
-
-
-@router.get("/{project_id}/local-bindings", response_model=list[LocalBindingResponse])
-def list_local_bindings(
-    project_id: int,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-) -> list[LocalBindingResponse]:
-    bindings = cloud_project_service.list_local_bindings(
-        db, project_id, current_user.id
-    )
-    return [LocalBindingResponse.model_validate(binding) for binding in bindings]
-
-
-@router.patch(
-    "/{project_id}/local-bindings/{binding_id}",
-    response_model=LocalBindingResponse,
-)
-def update_local_binding(
-    project_id: int,
-    binding_id: int,
-    values: LocalBindingUpdate,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-) -> LocalBindingResponse:
-    binding = cloud_project_service.update_local_binding(
-        db, project_id, binding_id, current_user.id, values
-    )
-    return LocalBindingResponse.model_validate(binding)
-
-
-@router.delete(
-    "/{project_id}/local-bindings/{binding_id}",
-    status_code=status.HTTP_204_NO_CONTENT,
-)
-def delete_local_binding(
-    project_id: int,
-    binding_id: int,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-) -> None:
-    cloud_project_service.delete_local_binding(
-        db, project_id, binding_id, current_user.id
-    )
-
-
 @router.get("/{project_id}/members", response_model=list[CloudProjectMemberResponse])
 def list_cloud_project_members(
     project_id: int,
diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py
index 32297bf72e..38a973754b 100644
--- a/backend/app/models/__init__.py
+++ b/backend/app/models/__init__.py
@@ -15,7 +15,6 @@
 from app.models.cloud_project import (
     CloudProject,
     CloudProjectFile,
-    CloudProjectLocalBinding,
     LoopItemTaskBinding,
 )
 from app.models.delivery import (
@@ -67,7 +66,6 @@
     "DingtalkSyncedNode",
     "CloudProject",
     "CloudProjectFile",
-    "CloudProjectLocalBinding",
     "LoopItemTaskBinding",
     "LoopItem",
     "LoopItemAttachment",
diff --git a/backend/app/models/cloud_project.py b/backend/app/models/cloud_project.py
index a679a28f57..e2c0f1e871 100644
--- a/backend/app/models/cloud_project.py
+++ b/backend/app/models/cloud_project.py
@@ -6,13 +6,11 @@
 from app.models.delivery import (
     CloudProject,
     CloudProjectFile,
-    CloudProjectLocalBinding,
     LoopItemTaskBinding,
 )
 
 __all__ = [
     "CloudProject",
     "CloudProjectFile",
-    "CloudProjectLocalBinding",
     "LoopItemTaskBinding",
 ]
diff --git a/backend/app/models/delivery.py b/backend/app/models/delivery.py
index 0ef29e00a7..98e8d1d6eb 100644
--- a/backend/app/models/delivery.py
+++ b/backend/app/models/delivery.py
@@ -198,14 +198,6 @@ def tags(self) -> list[str]:
         return [str(tag) for tag in tags]
 
 
-class CloudProjectLocalBinding(LoopNode):
-    __mapper_args__ = {"polymorphic_identity": "local_binding"}
-
-    def __init__(self, **kwargs: object) -> None:
-        kwargs.setdefault("is_default", False)
-        super().__init__(**kwargs)
-
-
 class LoopItemTaskBinding(LoopNode):
     __mapper_args__ = {"polymorphic_identity": "execution"}
 
diff --git a/backend/app/schemas/cloud_project.py b/backend/app/schemas/cloud_project.py
index 001b45ab00..d10d41fec7 100644
--- a/backend/app/schemas/cloud_project.py
+++ b/backend/app/schemas/cloud_project.py
@@ -222,34 +222,6 @@ class CloudProjectListResponse(BaseModel):
     items: list[CloudProjectResponse]
 
 
-class LocalBindingCreate(BaseModel):
-    local_project_id: int
-    device_id: str | None = Field(default=None, max_length=100)
-    is_default: bool = False
-
-
-class LocalBindingUpdate(BaseModel):
-    is_default: bool | None = None
-
-
-class LocalBindingResponse(BaseModel):
-    model_config = ConfigDict(from_attributes=True)
-
-    id: SnowflakeId
-    cloud_project_id: SnowflakeId
-    local_project_id: int
-    user_id: int
-    device_id: str | None
-    is_default: bool
-    created_at: datetime
-    updated_at: datetime
-
-    @field_validator("device_id", mode="before")
-    @classmethod
-    def normalize_empty_device_id(cls, value: object) -> object:
-        return None if value == "" else value
-
-
 class CloudProjectMemberCreate(BaseModel):
     user_id: int = Field(ge=1)
     role: BaseRole = BaseRole.Developer
diff --git a/backend/app/services/cloud_projects/service.py b/backend/app/services/cloud_projects/service.py
index f304200cd1..a4cf9e4abb 100644
--- a/backend/app/services/cloud_projects/service.py
+++ b/backend/app/services/cloud_projects/service.py
@@ -14,9 +14,8 @@
 from sqlalchemy.orm import Session
 
 from app.core.provider_credentials import store_provider_config
-from app.models.cloud_project import CloudProject, CloudProjectLocalBinding
+from app.models.cloud_project import CloudProject
 from app.models.delivery import LoopItem, loop_datetime_is_unset
-from app.models.project import Project
 from app.models.resource_member import MemberStatus, ResourceMember
 from app.models.share_link import ResourceType
 from app.models.user import User
@@ -26,8 +25,6 @@
     CloudProjectMemberCreate,
     CloudProjectMemberUpdate,
     CloudProjectUpdate,
-    LocalBindingCreate,
-    LocalBindingUpdate,
     default_board_statuses,
     normalize_provider_config,
 )
@@ -271,122 +268,6 @@ def archive(self, db: Session, project_id: int, user_id: int, version: int) -> N
             raise HTTPException(status.HTTP_409_CONFLICT, "Cloud project changed")
         db.commit()
 
-    def add_local_binding(
-        self,
-        db: Session,
-        cloud_project_id: int,
-        user_id: int,
-        values: LocalBindingCreate,
-    ) -> CloudProjectLocalBinding:
-        require_cloud_project_role(db, cloud_project_id, user_id, BaseRole.Developer)
-        local_project = (
-            db.query(Project)
-            .filter(
-                Project.id == values.local_project_id,
-                Project.user_id == user_id,
-                Project.is_active.is_(True),
-            )
-            .first()
-        )
-        if local_project is None:
-            raise HTTPException(status.HTTP_404_NOT_FOUND, "Local project not found")
-        if values.is_default:
-            db.query(CloudProjectLocalBinding).filter(
-                CloudProjectLocalBinding.user_id == user_id,
-                CloudProjectLocalBinding.local_project_id == values.local_project_id,
-                CloudProjectLocalBinding.device_id == values.device_id,
-            ).update({"is_default": False})
-        binding = CloudProjectLocalBinding(
-            cloud_project_id=cloud_project_id,
-            user_id=user_id,
-            local_project_id=values.local_project_id,
-            device_id=values.device_id,
-            is_default=values.is_default,
-        )
-        db.add(binding)
-        try:
-            db.commit()
-        except IntegrityError as exc:
-            db.rollback()
-            raise HTTPException(
-                status.HTTP_409_CONFLICT, "Local project is already linked"
-            ) from exc
-        db.refresh(binding)
-        return binding
-
-    def update_local_binding(
-        self,
-        db: Session,
-        cloud_project_id: int,
-        binding_id: int,
-        user_id: int,
-        values: LocalBindingUpdate,
-    ) -> CloudProjectLocalBinding:
-        require_cloud_project_role(db, cloud_project_id, user_id, BaseRole.Developer)
-        binding = (
-            db.query(CloudProjectLocalBinding)
-            .filter(
-                CloudProjectLocalBinding.id == binding_id,
-                CloudProjectLocalBinding.cloud_project_id == cloud_project_id,
-                CloudProjectLocalBinding.user_id == user_id,
-            )
-            .with_for_update()
-            .first()
-        )
-        if binding is None:
-            raise HTTPException(status.HTTP_404_NOT_FOUND, "Local binding not found")
-        if values.is_default is True:
-            db.query(CloudProjectLocalBinding).filter(
-                CloudProjectLocalBinding.user_id == user_id,
-                CloudProjectLocalBinding.local_project_id == binding.local_project_id,
-                CloudProjectLocalBinding.device_id == binding.device_id,
-                CloudProjectLocalBinding.id != binding.id,
-            ).update({"is_default": False})
-        if values.is_default is not None:
-            binding.is_default = values.is_default
-        db.commit()
-        db.refresh(binding)
-        return binding
-
-    def delete_local_binding(
-        self,
-        db: Session,
-        cloud_project_id: int,
-        binding_id: int,
-        user_id: int,
-    ) -> None:
-        require_cloud_project_role(db, cloud_project_id, user_id, BaseRole.Developer)
-        binding = (
-            db.query(CloudProjectLocalBinding)
-            .filter(
-                CloudProjectLocalBinding.id == binding_id,
-                CloudProjectLocalBinding.cloud_project_id == cloud_project_id,
-                CloudProjectLocalBinding.user_id == user_id,
-            )
-            .first()
-        )
-        if binding is None:
-            raise HTTPException(status.HTTP_404_NOT_FOUND, "Local binding not found")
-        db.delete(binding)
-        db.commit()
-
-    def list_local_bindings(
-        self, db: Session, cloud_project_id: int, user_id: int
-    ) -> list[CloudProjectLocalBinding]:
-        require_cloud_project_role(db, cloud_project_id, user_id)
-        return (
-            db.query(CloudProjectLocalBinding)
-            .filter(
-                CloudProjectLocalBinding.cloud_project_id == cloud_project_id,
-                CloudProjectLocalBinding.user_id == user_id,
-            )
-            .order_by(
-                CloudProjectLocalBinding.is_default.desc(),
-                CloudProjectLocalBinding.updated_at.desc(),
-            )
-            .all()
-        )
-
     def list_members(
         self, db: Session, cloud_project_id: int, user_id: int
     ) -> list[dict[str, object]]:
diff --git a/backend/tests/api/test_cloud_projects_api.py b/backend/tests/api/test_cloud_projects_api.py
index e66beca7a8..05eec7f0be 100644
--- a/backend/tests/api/test_cloud_projects_api.py
+++ b/backend/tests/api/test_cloud_projects_api.py
@@ -15,7 +15,6 @@
 
 from app.core.security import create_access_token
 from app.models.delivery import CloudProject, Delivery, DeliveryAsset, LoopItem
-from app.models.project import Project
 from app.models.user import User
 from app.services.cloud_files import cloud_file_service
 from app.services.delivery import delivery_service
@@ -786,91 +785,6 @@ def provider_request(
     assert all("server-only-secret" not in str(payload) for _, _, payload in requests)
 
 
-def test_cloud_project_can_link_local_workspace(
-    test_client: TestClient,
-    test_db: Session,
-    test_user: User,
-    test_token: str,
-) -> None:
-    local_project = Project(
-        user_id=test_user.id,
-        name="Local checkout",
-        client_origin="wework",
-    )
-    test_db.add(local_project)
-    test_db.commit()
-    test_db.refresh(local_project)
-
-    created = test_client.post(
-        "/api/v1/cloud-projects",
-        headers=_auth(test_token),
-        json={
-            "project_key": "collab",
-            "name": "Shared collaboration",
-            "description": "A cloud-first project",
-        },
-    )
-    assert created.status_code == 201
-    cloud_project = created.json()
-    assert cloud_project["project_key"] == "COLLAB"
-
-    linked = test_client.post(
-        f"/api/v1/cloud-projects/{cloud_project['id']}/local-bindings",
-        headers=_auth(test_token),
-        json={
-            "local_project_id": local_project.id,
-            "device_id": "desktop-1",
-            "is_default": True,
-        },
-    )
-    assert linked.status_code == 201
-    assert linked.json()["local_project_id"] == local_project.id
-
-    bindings = test_client.get(
-        f"/api/v1/cloud-projects/{cloud_project['id']}/local-bindings",
-        headers=_auth(test_token),
-    )
-    assert bindings.status_code == 200
-    assert bindings.json()[0]["device_id"] == "desktop-1"
-
-    second_project = test_client.post(
-        "/api/v1/cloud-projects",
-        headers=_auth(test_token),
-        json={"project_key": "second", "name": "Second collaboration"},
-    ).json()
-    second_binding = test_client.post(
-        f"/api/v1/cloud-projects/{second_project['id']}/local-bindings",
-        headers=_auth(test_token),
-        json={
-            "local_project_id": local_project.id,
-            "device_id": "desktop-1",
-            "is_default": True,
-        },
-    )
-    assert second_binding.status_code == 201
-    first_bindings = test_client.get(
-        f"/api/v1/cloud-projects/{cloud_project['id']}/local-bindings",
-        headers=_auth(test_token),
-    )
-    assert first_bindings.json()[0]["is_default"] is False
-    assert second_binding.json()["is_default"] is True
-    removed = test_client.delete(
-        (
-            f"/api/v1/cloud-projects/{second_project['id']}/local-bindings/"
-            f"{second_binding.json()['id']}"
-        ),
-        headers=_auth(test_token),
-    )
-    assert removed.status_code == 204
-    assert (
-        test_client.get(
-            f"/api/v1/cloud-projects/{second_project['id']}/local-bindings",
-            headers=_auth(test_token),
-        ).json()
-        == []
-    )
-
-
 def test_explicit_project_selection_tracks_runtime_task_idempotently(
     test_client: TestClient,
     test_db: Session,
diff --git a/docs/en/wegent/developer-guide/cloud-project-collaboration.md b/docs/en/wegent/developer-guide/cloud-project-collaboration.md
index 35c22ba79c..cc208dcaef 100644
--- a/docs/en/wegent/developer-guide/cloud-project-collaboration.md
+++ b/docs/en/wegent/developer-guide/cloud-project-collaboration.md
@@ -8,13 +8,13 @@ sidebar_position: 32
 
 ## Goal
 
-A cloud project is the shared collaboration and storage boundary for a team. Members may link the same cloud project to different local projects, execute work in Wework, and submit selected conversations, files, and Markdown as immutable delivery snapshots.
+A cloud project is the shared collaboration and storage boundary for a team. Members may select the same cloud project as the default destination of their own local projects, execute work in Wework, and submit selected conversations, files, and Markdown as immutable delivery snapshots.
 
 A cloud project is not the existing `Project` model:
 
 - `Project` is a user-owned local execution workspace containing device, path, Git, and runtime configuration.
 - `CloudProject` is a shared aggregate containing membership, TODOs, shared files, and a MinIO namespace.
-- One cloud project may link to many local projects owned by different members.
+- Local projects owned by different members may independently select the same cloud project; the cloud project stores no reverse link.
 - One TODO may link to many Wework Tasks, while one Task may process at most one active TODO at a time.
 
 ## Domain relationships
@@ -23,8 +23,6 @@ A cloud project is not the existing `Project` model:
 CloudProject
 ├── ResourceMember(resource_type=CloudProject)
 ├── ShareLink(resource_type=CloudProject)
-├── CloudProjectLocalBinding
-│   └── Project (local execution workspace)
 └── LoopItem
     ├── LoopItemTaskBinding
     │   └── TaskResource
@@ -38,7 +36,7 @@ CloudProject
 | Data | Source of truth |
 | --- | --- |
 | Cloud projects, members, TODOs, task links, delivery metadata | Backend MySQL |
-| Local paths, devices, Git, and execution configuration | Existing `projects` and `tasks` |
+| Local paths, devices, Git, execution configuration, and default project-space reference | Device-local Codex project state |
 | Shared files, Markdown, conversations, and delivery snapshots | MinIO/S3 |
 | AI access to cloud data | MCP authorized by the Backend |
 
@@ -69,9 +67,9 @@ created_by_user_id, storage_prefix, next_item_number
 status, version, created_at, updated_at
 ```
 
-### CloudProjectLocalBinding
+### Local-project default space
 
-`cloud_project_local_bindings` records which local project a member uses on a device. Absolute paths remain in local project configuration and must not be returned to other cloud project members.
+A local Codex project may store one `{ projectStore, projectId }` default project-space reference. The reference belongs to device-local project state, never enters the Backend, and creates no reverse index on the project space. A new conversation may override or clear the default before its first message is sent.
 
 ### LoopItem
 
@@ -109,7 +107,7 @@ Every TODO, delivery, file, and MCP request resolves the caller's cloud-project
 ## Service boundaries
 
 ```text
-cloud_projects/  projects, members, and local bindings
+cloud_projects/  projects and members
 loop_items/      TODOs, state transitions, and Task bindings
 delivery/        immutable delivery snapshots
 cloud_files/     mutable shared files
@@ -133,7 +131,6 @@ Delivery services do not own TODO CRUD. LoopItem services do not access MinIO di
 /v1/cloud-projects
 /v1/cloud-projects/{id}/members
 /v1/cloud-projects/{id}/members/{user_id}
-/v1/cloud-projects/{id}/local-bindings
 /v1/cloud-projects/{id}/files
 /v1/cloud-projects/{id}/folders
 /v1/cloud-projects/files/{file_id}
diff --git a/docs/en/wework/projects.md b/docs/en/wework/projects.md
index ea84327776..61dca5dcc2 100644
--- a/docs/en/wework/projects.md
+++ b/docs/en/wework/projects.md
@@ -22,7 +22,7 @@ After enabling **Settings → General → Experimental features**, open **Edit p
 
 New conversations started in that local project inherit the selected project space. Before the first message is sent, the composer shows **Add to board · Project space name**. Sending creates a task in the selected local or cloud project space and links the conversation. Repeated synchronization of the same conversation does not create duplicate board tasks.
 
-Linking local projects from the project-space management page only controls where that space is available. Automatic joining remains a per-local-project setting. Use the composer's **+** menu to select, replace, or remove the project space for an individual conversation before sending.
+The default project space belongs to the local project's settings and is stored with that project's device-local state; the project space does not keep a reverse link. Use the composer's **+** menu to select, replace, or remove the project space for an individual conversation before sending.
 
 ## Create a project from the composer
 
diff --git a/docs/zh/wegent/developer-guide/cloud-project-collaboration.md b/docs/zh/wegent/developer-guide/cloud-project-collaboration.md
index 8cbf3b2a74..ed7676406f 100644
--- a/docs/zh/wegent/developer-guide/cloud-project-collaboration.md
+++ b/docs/zh/wegent/developer-guide/cloud-project-collaboration.md
@@ -8,13 +8,13 @@ sidebar_position: 32
 
 ## 目标
 
-云项目是多人共享的协作与存储边界。成员可以把同一个云项目关联到各自不同的本地项目，在 Wework 中执行任务，并把选定的聊天记录、文件和 Markdown 说明作为不可变交付快照提交到云端。
+云项目是多人共享的协作与存储边界。成员可以在自己的本地项目中选择默认云项目，在 Wework 中执行任务，并把选定的聊天记录、文件和 Markdown 说明作为不可变交付快照提交到云端。
 
 云项目不等同于现有 `Project`：
 
 - `Project` 是单个用户拥有的本地执行工作区，保存设备、路径、Git 和执行配置。
 - `CloudProject` 是多人共享的协作聚合根，拥有成员权限、TODO、共享文件和 MinIO 空间。
-- 一个云项目可以被多个成员关联到多个本地项目。
+- 多个成员的本地项目可以分别把同一个云项目保存为默认目标；云项目不保存反向关联。
 - 一个 TODO 可以关联多个 Wework Task，但一个 Task 同时最多处理一个活跃 TODO。
 
 ## 领域关系
@@ -23,8 +23,6 @@ sidebar_position: 32
 CloudProject
 ├── ResourceMember(resource_type=CloudProject)
 ├── ShareLink(resource_type=CloudProject)
-├── CloudProjectLocalBinding
-│   └── Project (local execution workspace)
 └── LoopItem
     ├── LoopItemTaskBinding
     │   └── TaskResource
@@ -38,7 +36,7 @@ CloudProject
 | 数据 | 事实来源 |
 | --- | --- |
 | 云项目、成员、TODO、任务关联、交付元数据 | Backend MySQL |
-| 本地路径、设备、Git 和执行配置 | 现有 `projects` 与 `tasks` |
+| 本地路径、设备、Git、执行配置和默认项目空间引用 | 本地 Codex 项目状态 |
 | 共享文件、Markdown、聊天记录、交付快照 | MinIO/S3 |
 | AI 对云空间的访问 | Backend 鉴权后的 MCP |
 
@@ -69,9 +67,9 @@ created_by_user_id, storage_prefix, next_item_number
 status, version, created_at, updated_at
 ```
 
-### CloudProjectLocalBinding
+### 本地项目默认空间
 
-`cloud_project_local_bindings` 保存某个成员在某台设备上使用的本地项目。绝对路径仍保存在本地项目配置中，并且不能向其他云项目成员返回。
+本地 Codex 项目可以保存一个 `{ projectStore, projectId }` 默认项目空间引用。该引用属于设备上的本地项目状态，不进入 Backend，也不向项目空间建立反向索引。新对话发送前可以覆盖或清除这个默认值。
 
 ### LoopItem
 
@@ -109,7 +107,7 @@ inbox → pending → in_progress → in_review → completed
 ## 服务边界
 
 ```text
-cloud_projects/  项目、成员和本地关联
+cloud_projects/  项目和成员
 loop_items/      TODO、状态机和 Task 关联
 delivery/        不可变交付快照
 cloud_files/     可变共享文件
@@ -133,7 +131,6 @@ Delivery 服务不负责 TODO CRUD；LoopItem 服务不直接访问 MinIO；MCP
 /v1/cloud-projects
 /v1/cloud-projects/{id}/members
 /v1/cloud-projects/{id}/members/{user_id}
-/v1/cloud-projects/{id}/local-bindings
 /v1/cloud-projects/{id}/files
 /v1/cloud-projects/{id}/folders
 /v1/cloud-projects/files/{file_id}
diff --git a/docs/zh/wework/projects.md b/docs/zh/wework/projects.md
index a34b7026ab..e37a463cb7 100644
--- a/docs/zh/wework/projects.md
+++ b/docs/zh/wework/projects.md
@@ -22,7 +22,7 @@ sidebar_position: 3
 
 为本地项目选择项目空间后，从该项目开启的新对话会继承这个默认值。发送第一条消息前，输入框底部会显示 **加入看板 · 项目空间名称**；发送后，Wework 会在对应的本地或云端项目空间中创建任务并关联当前对话。重复同步同一对话不会创建重复看板任务。
 
-项目空间管理页中的本地项目关联只决定该空间可以在哪些本地项目中使用。是否自动加入仍由每个本地项目的设置决定；也可以在发送前通过输入框的 **+** 菜单为当前对话临时选择、切换或取消项目空间。
+默认项目空间是本地项目自身的设置，保存在对应设备的本地项目状态中，不需要项目空间保存反向关联。也可以在发送前通过输入框的 **+** 菜单为当前对话临时选择、切换或取消项目空间。
 
 ## 从输入区创建项目
 
diff --git a/executor/src/runtime_work/codex_global_state.rs b/executor/src/runtime_work/codex_global_state.rs
index 115fc6de15..97da1241de 100644
--- a/executor/src/runtime_work/codex_global_state.rs
+++ b/executor/src/runtime_work/codex_global_state.rs
@@ -60,6 +60,10 @@ const OPLOG_FLUSH_POLL_INTERVAL: Duration = Duration::from_secs(3);
 
 static CODEX_GLOBAL_STATE_OPLOG_FLUSH_WATCHER_RUNNING: AtomicBool = AtomicBool::new(false);
 
+fn is_false(value: &bool) -> bool {
+    !*value
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct CodexGlobalProject {
     pub key: String,
@@ -73,6 +77,7 @@ pub(crate) struct CodexGlobalProject {
     pub pinned_order: Option<usize>,
     pub active: bool,
     pub appearance: Option<Value>,
+    pub default_project_space: Option<Value>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -132,6 +137,13 @@ struct CodexGlobalStateOplogRecord {
     pinned: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
     appearance: Option<Value>,
+    #[serde(
+        rename = "defaultProjectSpace",
+        skip_serializing_if = "Option::is_none"
+    )]
+    default_project_space: Option<Value>,
+    #[serde(rename = "clearDefaultProjectSpace", skip_serializing_if = "is_false")]
+    clear_default_project_space: bool,
     #[serde(skip_serializing_if = "Option::is_none")]
     label: Option<String>,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
@@ -153,6 +165,8 @@ impl Default for CodexGlobalStateOplogRecord {
             insert_at_end: None,
             pinned: None,
             appearance: None,
+            default_project_space: None,
+            clear_default_project_space: false,
             label: None,
             roots: Vec::new(),
             updated_at: 0,
@@ -410,6 +424,7 @@ pub(crate) fn upsert_codex_global_local_project(
     project_key: &str,
     name: &str,
     roots: &[String],
+    default_project_space: Option<Value>,
 ) -> Result<CodexGlobalProject, String> {
     let project_key = clean_text(project_key).ok_or_else(|| "projectKey is required".to_owned())?;
     let name = clean_text(name).ok_or_else(|| "name is required".to_owned())?;
@@ -423,30 +438,24 @@ pub(crate) fn upsert_codex_global_local_project(
     if roots.is_empty() {
         return Err("roots must contain at least one workspace path".to_owned());
     }
+    let clear_default_project_space = default_project_space.as_ref().is_some_and(Value::is_null);
     append_codex_global_state_op_record(&CodexGlobalStateOplogRecord {
         kind: OPLOG_KIND_UPSERT_LOCAL_PROJECT.to_owned(),
         workspace_path: roots[0].clone(),
         project_key: Some(project_key.clone()),
         label: Some(name.clone()),
         roots: roots.clone(),
+        default_project_space: default_project_space.filter(|value| !value.is_null()),
+        clear_default_project_space,
         updated_at: now_ms(),
         ..Default::default()
     })?;
     flush_or_watch_codex_global_state_oplog();
     refresh_codex_global_project_cache();
-    Ok(CodexGlobalProject {
-        key: project_key,
-        workspace_path: roots[0].clone(),
-        roots,
-        name,
-        source: "local_project".to_owned(),
-        kind: "local".to_owned(),
-        remote_host_id: None,
-        pinned: false,
-        pinned_order: None,
-        active: false,
-        appearance: None,
-    })
+    CodexGlobalProjectIndex::load()
+        .project_for_key(&project_key)
+        .cloned()
+        .ok_or_else(|| "local project was not persisted".to_owned())
 }
 
 pub(crate) fn register_codex_global_thread_workspace_root(
@@ -773,6 +782,15 @@ fn apply_codex_global_state_ops(
                     (op.project_key.as_deref(), op.label.as_deref())
                 {
                     upsert_local_project_payload(payload, project_key, name, &op.roots);
+                    if op.clear_default_project_space {
+                        set_local_project_default_space_payload(payload, project_key, Value::Null);
+                    } else if let Some(default_project_space) = op.default_project_space.clone() {
+                        set_local_project_default_space_payload(
+                            payload,
+                            project_key,
+                            default_project_space,
+                        );
+                    }
                 }
             }
             OPLOG_KIND_UPSERT_REMOTE_PROJECT => {
@@ -1156,6 +1174,7 @@ fn local_projects_from_payload(payload: &Map<String, Value>) -> Vec<CodexGlobalP
                 .get("name")
                 .and_then(clean_string)
                 .unwrap_or_else(|| key.clone());
+            let default_project_space = project.get("defaultProjectSpace").cloned();
             let roots = writable_roots
                 .and_then(|items| items.get(&key).or_else(|| items.get(project_key)))
                 .and_then(Value::as_array)
@@ -1177,6 +1196,7 @@ fn local_projects_from_payload(payload: &Map<String, Value>) -> Vec<CodexGlobalP
                 pinned_order: None,
                 active: false,
                 appearance: None,
+                default_project_space,
             }
         })
         .collect()
@@ -1204,6 +1224,7 @@ fn remote_projects_from_payload(payload: &Map<String, Value>) -> Vec<CodexGlobal
                 pinned_order: None,
                 active: false,
                 appearance: None,
+                default_project_space: None,
             }
         })
         .collect()
@@ -1346,6 +1367,7 @@ fn local_project_from_label(workspace_path: &str, label: Option<&str>) -> CodexG
         pinned_order: None,
         active: false,
         appearance: None,
+        default_project_space: None,
     }
 }
 
@@ -1371,13 +1393,18 @@ fn upsert_local_project_payload(
     if !projects.is_object() {
         *projects = Value::Object(Map::new());
     }
-    projects
+    let projects = projects
         .as_object_mut()
-        .expect("local projects is an object")
-        .insert(
-            project_key.to_owned(),
-            json!({"id": project_key, "name": name}),
-        );
+        .expect("local projects is an object");
+    let project = projects
+        .entry(project_key.to_owned())
+        .or_insert_with(|| Value::Object(Map::new()));
+    if !project.is_object() {
+        *project = Value::Object(Map::new());
+    }
+    let project = project.as_object_mut().expect("local project is an object");
+    project.insert("id".to_owned(), Value::String(project_key.to_owned()));
+    project.insert("name".to_owned(), Value::String(name.to_owned()));
 
     let writable_roots = payload
         .entry(PROJECT_WRITABLE_ROOTS_KEY.to_owned())
@@ -1400,6 +1427,26 @@ fn upsert_local_project_payload(
     upsert_project_order(payload, project_key);
 }
 
+fn set_local_project_default_space_payload(
+    payload: &mut Map<String, Value>,
+    project_key: &str,
+    default_project_space: Value,
+) {
+    let Some(project) = payload
+        .get_mut(LOCAL_PROJECTS_KEY)
+        .and_then(Value::as_object_mut)
+        .and_then(|projects| projects.get_mut(project_key))
+        .and_then(Value::as_object_mut)
+    else {
+        return;
+    };
+    if default_project_space.is_null() {
+        project.remove("defaultProjectSpace");
+    } else {
+        project.insert("defaultProjectSpace".to_owned(), default_project_space);
+    }
+}
+
 fn rename_codex_global_project_payload(
     payload: &mut Map<String, Value>,
     project_ref: &str,
diff --git a/executor/src/runtime_work/handler/helpers/routing.rs b/executor/src/runtime_work/handler/helpers/routing.rs
index 8751388646..68d0a0e2ef 100644
--- a/executor/src/runtime_work/handler/helpers/routing.rs
+++ b/executor/src/runtime_work/handler/helpers/routing.rs
@@ -193,6 +193,7 @@ fn codex_project_workspaces(project_index: &CodexGlobalProjectIndex) -> Vec<Runt
             project_pinned_order: project.pinned_order,
             project_active: project.active,
             project_appearance: project.appearance.clone(),
+            default_project_space: project.default_project_space.clone(),
         })
         .collect()
 }
diff --git a/executor/src/runtime_work/handler/tasks.rs b/executor/src/runtime_work/handler/tasks.rs
index 9d44df2021..6df112e8a8 100644
--- a/executor/src/runtime_work/handler/tasks.rs
+++ b/executor/src/runtime_work/handler/tasks.rs
@@ -131,6 +131,7 @@ impl RuntimeWorkRpcHandler {
                     project_key,
                     project_name,
                     &request.runtime_workspace_roots,
+                    None,
                 )
                 .map_err(|error| AppIpcError::new("codex_global_state_error", error))?;
             }
diff --git a/executor/src/runtime_work/handler/workspaces.rs b/executor/src/runtime_work/handler/workspaces.rs
index 5b5727de5f..a83964dc93 100644
--- a/executor/src/runtime_work/handler/workspaces.rs
+++ b/executor/src/runtime_work/handler/workspaces.rs
@@ -52,8 +52,13 @@ impl RuntimeWorkRpcHandler {
                 opened_roots.insert(canonical);
             }
         }
-        let project = upsert_codex_global_local_project(&project_key, &name, &roots)
-            .map_err(|error| AppIpcError::new("codex_global_state_error", error))?;
+        let default_project_space = payload
+            .get("defaultProjectSpace")
+            .or_else(|| payload.get("default_project_space"))
+            .cloned();
+        let project =
+            upsert_codex_global_local_project(&project_key, &name, &roots, default_project_space)
+                .map_err(|error| AppIpcError::new("codex_global_state_error", error))?;
         Ok(json!({
             "success": true,
             "accepted": true,
@@ -61,6 +66,7 @@ impl RuntimeWorkRpcHandler {
             "projectKey": project.key,
             "name": project.name,
             "roots": project.roots,
+            "defaultProjectSpace": project.default_project_space,
             "runtime": "codex",
         }))
     }
diff --git a/executor/src/runtime_work/response.rs b/executor/src/runtime_work/response.rs
index 348d2970d8..177c5a2d48 100644
--- a/executor/src/runtime_work/response.rs
+++ b/executor/src/runtime_work/response.rs
@@ -357,6 +357,7 @@ pub(crate) struct RuntimeWorkspaceLink {
     pub project_pinned_order: Option<usize>,
     pub project_active: bool,
     pub project_appearance: Option<Value>,
+    pub default_project_space: Option<Value>,
 }
 
 impl Default for RuntimeWorkspaceLink {
@@ -377,6 +378,7 @@ impl Default for RuntimeWorkspaceLink {
             project_pinned_order: None,
             project_active: false,
             project_appearance: None,
+            default_project_space: None,
         }
     }
 }
@@ -481,6 +483,9 @@ pub(crate) fn workspace_response(
                 if let Some(appearance) = workspace.project_appearance.clone() {
                     workspace_json["projectAppearance"] = appearance;
                 }
+                if let Some(default_project_space) = workspace.default_project_space.clone() {
+                    workspace_json["defaultProjectSpace"] = default_project_space;
+                }
             }
             if let Some(remote_host_id) = remote_host_id {
                 workspace_json["remoteHostId"] = Value::String(remote_host_id);
diff --git a/executor/tests/app_runtime_work_workspace_contract.rs b/executor/tests/app_runtime_work_workspace_contract.rs
index 3b5af5c52e..4010bb0402 100644
--- a/executor/tests/app_runtime_work_workspace_contract.rs
+++ b/executor/tests/app_runtime_work_workspace_contract.rs
@@ -290,7 +290,11 @@ async fn runtime_local_project_rpc_persists_multiple_roots() {
                 "runtime": "codex",
                 "projectKey": "product",
                 "name": "Product",
-                "roots": [first_root, second_root]
+                "roots": [first_root, second_root],
+                "defaultProjectSpace": {
+                    "projectStore": "backend",
+                    "projectId": "space-1"
+                }
             }
         }))
         .await
@@ -299,8 +303,16 @@ async fn runtime_local_project_rpc_persists_multiple_roots() {
     assert_eq!(response["accepted"], true);
     assert_eq!(response["deviceId"], "device-1");
     assert_eq!(response["projectKey"], "product");
+    assert_eq!(
+        response["defaultProjectSpace"],
+        json!({"projectStore": "backend", "projectId": "space-1"})
+    );
     let state = read_json_file(&codex_home.join(".codex-global-state.json"));
     assert_eq!(state["local-projects"]["product"]["name"], "Product");
+    assert_eq!(
+        state["local-projects"]["product"]["defaultProjectSpace"],
+        json!({"projectStore": "backend", "projectId": "space-1"})
+    );
     assert_eq!(
         state["project-writable-roots"]["product"]
             .as_array()
@@ -309,6 +321,24 @@ async fn runtime_local_project_rpc_persists_multiple_roots() {
         2
     );
     assert_eq!(state["unknown"], true);
+
+    handler
+        .handle_runtime_rpc(json!({
+            "method": "runtime.projects.upsert_local",
+            "payload": {
+                "runtime": "codex",
+                "projectKey": "product",
+                "name": "Product",
+                "roots": [first_root, second_root],
+                "defaultProjectSpace": null
+            }
+        }))
+        .await
+        .expect("clearing the default project space should succeed");
+    let state = read_json_file(&codex_home.join(".codex-global-state.json"));
+    assert!(state["local-projects"]["product"]
+        .get("defaultProjectSpace")
+        .is_none());
 }
 
 #[tokio::test]
diff --git a/wework/src/api/deliveries.ts b/wework/src/api/deliveries.ts
index 447511d8c3..28ca4c1f85 100644
--- a/wework/src/api/deliveries.ts
+++ b/wework/src/api/deliveries.ts
@@ -2,8 +2,6 @@ import { invoke } from '@tauri-apps/api/core'
 import type { HttpClient } from './http'
 import type { RuntimeTaskAddress } from '@/types/api'
 
-export const PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT =
-  'wework:project-space-local-bindings-changed'
 import { openLocalFile } from '@/lib/local-terminal'
 import { isTauriRuntime } from '@/lib/runtime-environment'
 
@@ -177,17 +175,6 @@ export interface ProjectDeliveryFile {
   delivered_at: string
 }
 
-export interface CloudProjectLocalBinding {
-  id: string
-  cloud_project_id: CloudProjectId
-  local_project_id: number
-  user_id: number
-  device_id: string | null
-  is_default: boolean
-  created_at: string
-  updated_at: string
-}
-
 export interface CloudProjectMember {
   id: number
   user_id: number
@@ -475,9 +462,6 @@ export function createDeliveryApi(client: HttpClient) {
     unbindTask(itemId: string, task: RuntimeTaskAddress): Promise<void> {
       return client.delete(`/v1/loop-items/${encodeURIComponent(itemId)}/tasks`, task)
     },
-    listLocalBindings(projectId: CloudProjectIdInput): Promise<CloudProjectLocalBinding[]> {
-      return client.get(`/v1/cloud-projects/${projectId}/local-bindings`)
-    },
     listCloudProjectMembers(projectId: CloudProjectIdInput): Promise<CloudProjectMember[]> {
       return client.get(`/v1/cloud-projects/${projectId}/members`)
     },
@@ -506,28 +490,6 @@ export function createDeliveryApi(client: HttpClient) {
     ): Promise<{ users: CloudUserSearchItem[]; total: number }> {
       return client.get(`/users/search?q=${encodeURIComponent(query)}&limit=20`)
     },
-    addLocalBinding(
-      projectId: CloudProjectIdInput,
-      data: {
-        local_project_id: number
-        device_id?: string
-        is_default?: boolean
-      }
-    ): Promise<CloudProjectLocalBinding> {
-      return client.post(`/v1/cloud-projects/${projectId}/local-bindings`, data)
-    },
-    updateLocalBinding(
-      projectId: CloudProjectIdInput,
-      bindingId: string,
-      data: {
-        is_default?: boolean
-      }
-    ): Promise<CloudProjectLocalBinding> {
-      return client.patch(`/v1/cloud-projects/${projectId}/local-bindings/${bindingId}`, data)
-    },
-    deleteLocalBinding(projectId: CloudProjectIdInput, bindingId: string): Promise<void> {
-      return client.delete(`/v1/cloud-projects/${projectId}/local-bindings/${bindingId}`)
-    },
     listCloudFiles(projectId: CloudProjectIdInput): Promise<{ items: CloudProjectFile[] }> {
       return client.get(`/v1/cloud-projects/${projectId}/files`)
     },
diff --git a/wework/src/api/local/localDelivery.test.ts b/wework/src/api/local/localDelivery.test.ts
index 78f3f321bf..bba7ac60aa 100644
--- a/wework/src/api/local/localDelivery.test.ts
+++ b/wework/src/api/local/localDelivery.test.ts
@@ -324,38 +324,6 @@ describe('local delivery API', () => {
     })
   })
 
-  test('stores project-space associations with one default per local project', async () => {
-    window.localStorage.clear()
-    const request = vi.fn()
-    const api = createLocalDeliveryApi(request)
-
-    const first = await api.addLocalBinding('project-1', {
-      local_project_id: 91,
-      is_default: true,
-    })
-    const second = await api.addLocalBinding('project-2', {
-      local_project_id: 91,
-      is_default: true,
-    })
-
-    await expect(api.listLocalBindings('project-1')).resolves.toEqual([
-      expect.objectContaining({ id: first.id, is_default: false }),
-    ])
-    await expect(api.listLocalBindings('project-2')).resolves.toEqual([
-      expect.objectContaining({ id: second.id, is_default: true }),
-    ])
-
-    const updated = await api.updateLocalBinding('project-1', first.id, {
-      is_default: true,
-    })
-    expect(updated.is_default).toBe(true)
-    await expect(api.listLocalBindings('project-2')).resolves.toEqual([
-      expect.objectContaining({ id: second.id, is_default: false }),
-    ])
-    await api.deleteLocalBinding('project-2', second.id)
-    await expect(api.listLocalBindings('project-2')).resolves.toEqual([])
-  })
-
   test('tracks concurrent calls for the same runtime task only once', async () => {
     const trackedTask = { ...taskRecord, status: 'in_progress' }
     const request = vi.fn(async (method: string) => {
diff --git a/wework/src/api/local/localDelivery.ts b/wework/src/api/local/localDelivery.ts
index 11c2f5c6a2..7d1d1cd2df 100644
--- a/wework/src/api/local/localDelivery.ts
+++ b/wework/src/api/local/localDelivery.ts
@@ -7,7 +7,6 @@ import {
   type CloudProject,
   type CloudProjectFile,
   type CloudProjectId,
-  type CloudProjectLocalBinding,
   type CloudProjectMember,
   type Delivery,
   type DeliveryAsset,
@@ -307,21 +306,6 @@ export function createLocalDeliveryApi(
 ): NonNullable<WorkbenchServices['deliveryApi']> {
   const taskProjects = new Map<string, CloudProjectId>()
   const trackProjectTaskOnce = createProjectTaskTrackingSingleFlight()
-  const bindingStorageKey = 'wework.local-project-space-bindings'
-
-  const readLocalBindings = (): CloudProjectLocalBinding[] => {
-    try {
-      const parsed = JSON.parse(window.localStorage.getItem(bindingStorageKey) ?? '[]')
-      return Array.isArray(parsed) ? parsed : []
-    } catch {
-      return []
-    }
-  }
-
-  const writeLocalBindings = (bindings: CloudProjectLocalBinding[]) => {
-    window.localStorage.setItem(bindingStorageKey, JSON.stringify(bindings))
-  }
-
   function rememberTasks(projectId: CloudProjectId, records: LocalLoopItemRecord[]) {
     for (const record of records) taskProjects.set(record.id, projectId)
   }
@@ -607,40 +591,6 @@ export function createLocalDeliveryApi(
         task_id: task.taskId,
       })
     },
-    async updateLocalBinding(
-      projectId: CloudProjectId,
-      bindingId: string,
-      data: { is_default?: boolean }
-    ) {
-      const bindings = readLocalBindings()
-      const binding = bindings.find(
-        candidate => candidate.id === bindingId && candidate.cloud_project_id === projectId
-      )
-      if (!binding) throw new Error('Local binding not found')
-      if (data.is_default) {
-        for (const candidate of bindings) {
-          if (
-            candidate.id !== binding.id &&
-            candidate.local_project_id === binding.local_project_id &&
-            candidate.device_id === binding.device_id
-          ) {
-            candidate.is_default = false
-          }
-        }
-      }
-      if (data.is_default !== undefined) binding.is_default = data.is_default
-      binding.updated_at = new Date().toISOString()
-      writeLocalBindings(bindings)
-      return binding
-    },
-    async deleteLocalBinding(projectId: CloudProjectId, bindingId: string) {
-      const bindings = readLocalBindings()
-      const nextBindings = bindings.filter(
-        candidate => candidate.id !== bindingId || candidate.cloud_project_id !== projectId
-      )
-      if (nextBindings.length === bindings.length) throw new Error('Local binding not found')
-      writeLocalBindings(nextBindings)
-    },
     async findLoopItemForTask(task: RuntimeTaskAddress) {
       const binding = await request<LocalTaskBindingRecord>('runtime_tasks.context', {
         device_id: task.deviceId,
@@ -666,58 +616,11 @@ export function createLocalDeliveryApi(
         loop_item: loopItem,
       }
     },
-    async listLocalBindings(projectId: CloudProjectId) {
-      return readLocalBindings().filter(binding => binding.cloud_project_id === projectId)
-    },
     listCloudProjectMembers: async (): Promise<CloudProjectMember[]> => [],
     addCloudProjectMember: async () => unsupported('Project members'),
     updateCloudProjectMember: async () => unsupported('Project members'),
     removeCloudProjectMember: async () => unsupported('Project members'),
     searchCloudProjectUsers: async () => ({ users: [], total: 0 }),
-    async addLocalBinding(
-      projectId: CloudProjectId,
-      data: {
-        local_project_id: number
-        device_id?: string
-        is_default?: boolean
-      }
-    ) {
-      const bindings = readLocalBindings()
-      if (
-        bindings.some(
-          binding =>
-            binding.cloud_project_id === projectId &&
-            binding.local_project_id === data.local_project_id &&
-            binding.device_id === (data.device_id ?? null)
-        )
-      ) {
-        throw new Error('Local project is already linked')
-      }
-      if (data.is_default) {
-        for (const candidate of bindings) {
-          if (
-            candidate.local_project_id === data.local_project_id &&
-            candidate.device_id === (data.device_id ?? null)
-          ) {
-            candidate.is_default = false
-          }
-        }
-      }
-      const now = new Date().toISOString()
-      const binding: CloudProjectLocalBinding = {
-        id: crypto.randomUUID(),
-        cloud_project_id: projectId,
-        local_project_id: data.local_project_id,
-        user_id: 0,
-        device_id: data.device_id ?? null,
-        is_default: data.is_default ?? false,
-        created_at: now,
-        updated_at: now,
-      }
-      bindings.push(binding)
-      writeLocalBindings(bindings)
-      return binding
-    },
     async listCloudFiles(projectId: CloudProjectId) {
       const records = await request<LocalProjectFileRecord[]>('files.list', {
         project_id: projectId,
diff --git a/wework/src/api/local/localServices.ts b/wework/src/api/local/localServices.ts
index 867a136c4f..958bf40de7 100644
--- a/wework/src/api/local/localServices.ts
+++ b/wework/src/api/local/localServices.ts
@@ -25,6 +25,7 @@ import type {
   RuntimeModelPrepareRequest,
   RuntimeLocalProjectUpsertRequest,
   RuntimeLocalProjectUpsertResponse,
+  RuntimeProjectSpaceRef,
   RuntimeGoalClearRequest,
   RuntimeGoalClearResponse,
   RuntimeGoalGetRequest,
@@ -1838,6 +1839,15 @@ function adaptRuntimeWorkListResponse(
     const projectSource =
       stringValue(workspace.projectSource) ?? stringValue(workspace.project_source) ?? 'legacy_root'
     const projectPinnedOrder = workspace.projectPinnedOrder ?? workspace.project_pinned_order
+    const rawDefaultProjectSpace = recordValue(
+      workspace.defaultProjectSpace ?? workspace.default_project_space
+    )
+    const defaultProjectStore = stringValue(rawDefaultProjectSpace.projectStore)
+    const defaultProjectId = stringValue(rawDefaultProjectSpace.projectId)
+    const defaultProjectSpace: RuntimeProjectSpaceRef | null =
+      (defaultProjectStore === 'local' || defaultProjectStore === 'backend') && defaultProjectId
+        ? { projectStore: defaultProjectStore, projectId: defaultProjectId }
+        : null
     const projectWork: RuntimeWorkListResponse['projects'][number] = {
       project: {
         key: projectKey,
@@ -1860,6 +1870,7 @@ function adaptRuntimeWorkListResponse(
         appearance: (workspace.projectAppearance ?? workspace.project_appearance ?? null) as
           | RuntimeWorkListResponse['projects'][number]['project']['appearance']
           | null,
+        ...(defaultProjectSpace ? { defaultProjectSpace } : {}),
       },
       deviceWorkspaces: [deviceWorkspace],
       totalTasks: tasks.length,
diff --git a/wework/src/components/layout/DesktopSidebar.test.tsx b/wework/src/components/layout/DesktopSidebar.test.tsx
index 7688be0afb..bfe276e7ab 100644
--- a/wework/src/components/layout/DesktopSidebar.test.tsx
+++ b/wework/src/components/layout/DesktopSidebar.test.tsx
@@ -20,7 +20,7 @@ import {
   RuntimeTaskLifecycleProvider,
   RuntimeTaskLifecycleStore,
 } from '@/features/workbench/runtimeTaskLifecycle'
-import type { ProjectSpaceBindingApi } from '@/features/todo/projectSpaceLocalBindings'
+import type { ProjectSpaceApi } from '@/features/todo/projectSpaceSelection'
 
 const experimentalFeatures = vi.hoisted(() => ({ enabled: true }))
 
@@ -3351,8 +3351,7 @@ describe('DesktopSidebar', () => {
     const user = userEvent.setup()
     const projectSpaceApi = {
       listCloudProjects: vi.fn().mockResolvedValue({ items: [] }),
-      listLocalBindings: vi.fn().mockResolvedValue([]),
-    } as unknown as ProjectSpaceBindingApi
+    } as unknown as ProjectSpaceApi
 
     renderSidebar({
       projects: [],
@@ -3386,7 +3385,7 @@ describe('DesktopSidebar', () => {
         chats: [],
         totalTasks: 0,
       },
-      projectSpaceBindingApis: [projectSpaceApi],
+      projectSpaceApis: [projectSpaceApi],
       onUpdateLocalRuntimeProject: vi.fn().mockResolvedValue(undefined),
     })
 
diff --git a/wework/src/components/layout/DesktopSidebar.tsx b/wework/src/components/layout/DesktopSidebar.tsx
index 1f6551ad1d..420c756ea9 100644
--- a/wework/src/components/layout/DesktopSidebar.tsx
+++ b/wework/src/components/layout/DesktopSidebar.tsx
@@ -100,6 +100,7 @@ import type {
   RuntimeIMNotificationSettingsResponse,
   RuntimeProjectWork,
   RuntimeProjectAppearanceRequest,
+  RuntimeProjectSpaceRef,
   RuntimeProjectPinRequest,
   RuntimeProjectReorderRequest,
   RuntimeProjectTaskReorderRequest,
@@ -158,7 +159,7 @@ import {
 } from '@/features/workbench/runtimeSidebarDiagnostics'
 import { formatRelativeSidebarTime, useSidebarRelativeTimeRefresh } from './runtimeSidebarTime'
 import { useResizableSidebar } from './useResizableSidebar'
-import type { ProjectSpaceBindingApi } from '@/features/todo/projectSpaceLocalBindings'
+import type { ProjectSpaceApi } from '@/features/todo/projectSpaceSelection'
 
 interface DesktopSidebarProps {
   user: UserProfile | null
@@ -241,6 +242,7 @@ interface DesktopSidebarProps {
     projectKey: string
     name: string
     roots: string[]
+    defaultProjectSpace: RuntimeProjectSpaceRef | null
   }) => Promise<void>
   onRemoveProject: (projectId: number) => Promise<void>
   onReorderRuntimeProjects?: (data: RuntimeProjectReorderRequest) => Promise<void>
@@ -251,7 +253,7 @@ interface DesktopSidebarProps {
   onGetDeviceHomeDirectory: (deviceId: string) => Promise<string>
   onListDeviceDirectories: (deviceId: string, path: string) => Promise<string[]>
   onCreateDeviceDirectory: (deviceId: string, path: string) => Promise<void>
-  projectSpaceBindingApis?: ProjectSpaceBindingApi[]
+  projectSpaceApis?: ProjectSpaceApi[]
   onOpenSettings: (options?: OpenSettingsOptions) => void
   onLogout: () => void
 }
@@ -2585,7 +2587,7 @@ export function DesktopSidebar({
   onGetDeviceHomeDirectory,
   onListDeviceDirectories,
   onCreateDeviceDirectory,
-  projectSpaceBindingApis,
+  projectSpaceApis,
   onOpenSettings,
   onLogout,
   collapsed = false,
@@ -4135,7 +4137,7 @@ export function DesktopSidebar({
             onGetDeviceHomeDirectory={onGetDeviceHomeDirectory}
             onListDeviceDirectories={onListDeviceDirectories}
             onCreateDeviceDirectory={onCreateDeviceDirectory}
-            projectSpaceApis={experimentalFeaturesEnabled ? projectSpaceBindingApis : undefined}
+            projectSpaceApis={experimentalFeaturesEnabled ? projectSpaceApis : undefined}
             onClose={() => setEditingLocalProject(null)}
             onSave={data =>
               onUpdateLocalRuntimeProject
diff --git a/wework/src/components/layout/DesktopWorkbenchLayout.tsx b/wework/src/components/layout/DesktopWorkbenchLayout.tsx
index b04fd62efd..aa66ec1f9b 100644
--- a/wework/src/components/layout/DesktopWorkbenchLayout.tsx
+++ b/wework/src/components/layout/DesktopWorkbenchLayout.tsx
@@ -35,7 +35,7 @@ import { useWorkbenchShellEventHandlers } from './workbenchShellEvents'
 import { EMPTY_RUNTIME_TASK_REMINDERS } from '@/features/workbench/runtimeTaskReminders'
 import { CloudTodoWorkspace } from '@/features/todo/CloudTodoWorkspace'
 import { resolveLocalTodoProjects } from '@/features/todo/localTodoProjects'
-import { projectSpaceBindingApis } from '@/features/todo/projectSpaceLocalBindings'
+import { projectSpaceApis } from '@/features/todo/projectSpaceSelection'
 import { WorkbenchBackground } from '@/features/appearance'
 import { isTauriRuntime } from '@/lib/runtime-environment'
 import { useResizableSidebar } from './useResizableSidebar'
@@ -119,10 +119,7 @@ export function DesktopWorkbenchLayout({ routeActive = true }: DesktopWorkbenchL
     () => resolveLocalTodoProjects(state.projects, state.runtimeWork),
     [state.projects, state.runtimeWork]
   )
-  const availableProjectSpaceBindingApis = useMemo(
-    () => projectSpaceBindingApis(services),
-    [services]
-  )
+  const availableProjectSpaceApis = useMemo(() => projectSpaceApis(services), [services])
   const workspaceTabs = useOptionalWorkspaceTabs()
   const initialPath = stripAppBasePath(window.location.pathname)
   const [currentPath, setCurrentPath] = useState(initialPath)
@@ -627,7 +624,7 @@ export function DesktopWorkbenchLayout({ routeActive = true }: DesktopWorkbenchL
       onGetDeviceHomeDirectory={onGetDeviceHomeDirectory}
       onListDeviceDirectories={onListDeviceDirectories}
       onCreateDeviceDirectory={onCreateDeviceDirectory}
-      projectSpaceBindingApis={availableProjectSpaceBindingApis}
+      projectSpaceApis={availableProjectSpaceApis}
       onOpenSettings={options => {
         setAutoOpenAddCloudDeviceDialog(Boolean(options?.autoOpenAddCloudDeviceDialog))
         setSettingsOpen(true)
diff --git a/wework/src/components/layout/DesktopWorkbenchMain.tsx b/wework/src/components/layout/DesktopWorkbenchMain.tsx
index 0169fd0142..8671391d12 100644
--- a/wework/src/components/layout/DesktopWorkbenchMain.tsx
+++ b/wework/src/components/layout/DesktopWorkbenchMain.tsx
@@ -17,19 +17,14 @@ import { useAppPreferencesState } from '@/features/app-preferences/useAppPrefere
 import { useWorkbench, useWorkbenchPaneContext } from '@/features/workbench/useWorkbench'
 import { getPopoutComposerPlaceholder } from '@/features/workbench/popoutWorkspaceContext'
 import { DeliveryDialog } from '@/features/delivery/DeliveryDialog'
-import {
-  PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT,
-  type CloudLoopItem,
-  type CloudProject,
-  type CloudProjectLocalBinding,
-} from '@/api/deliveries'
+import type { CloudLoopItem, CloudProject } from '@/api/deliveries'
 import { TodoBindingPicker } from '@/features/todo/TodoBindingPicker'
 import {
-  cacheAutoJoinProjectSpace,
   findProjectSpaceContextForTask,
-  projectSpaceBindingApis,
-  readCachedAutoJoinProjectSpace,
-} from '@/features/todo/projectSpaceLocalBindings'
+  projectSpaceApis,
+  projectSpaceKey,
+  projectSpaceRef,
+} from '@/features/todo/projectSpaceSelection'
 import {
   hydrateLocalWorkItems,
   loadLocalWorkItems,
@@ -64,6 +59,7 @@ import type {
   WorkspaceTarget,
 } from '@/types/workspace-files'
 import { cn } from '@/lib/utils'
+import { runtimeProjectUiId } from '@/lib/runtime-project'
 import {
   defaultAppearance,
   getWorkbenchBackground,
@@ -589,9 +585,10 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
   const { t: tChat } = useTranslation('chat')
   const currentRuntimeTask = pane.currentRuntimeTask
   const currentProject = pane.currentProject
-  const localProjectId = currentProject?.id
-  const localProjectDeviceId =
-    currentProject?.config?.execution?.deviceId ?? currentProject?.config?.device_id
+  const currentRuntimeProject = state.runtimeWork?.projects.find(
+    projectWork => currentProject && runtimeProjectUiId(projectWork.project) === currentProject.id
+  )?.project
+  const defaultProjectSpace = currentRuntimeProject?.defaultProjectSpace ?? null
   const paneKey = getWorkbenchPaneKey(pane)
   const [turnNavigationPortalTarget, setTurnNavigationPortalTarget] =
     useState<HTMLDivElement | null>(null)
@@ -605,7 +602,7 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
   }, [])
   const paneSession = useWorkbenchPaneSession({ currentRuntimeTask })
   const sendPaneInput = paneSession.send
-  const todoBindingApis = useMemo(() => projectSpaceBindingApis(services), [services])
+  const todoBindingApis = useMemo(() => projectSpaceApis(services), [services])
   const pendingAutoJoinResolutionRef = useRef<PendingAutoJoinResolution | null>(null)
   const [deliveryItem, setDeliveryItem] = useState<Omit<LocalWorkItem, 'projectId'> | null>(null)
   const [boundCloudProject, setBoundCloudProject] = useState<CloudProject | null>(null)
@@ -624,22 +621,15 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
   const [pendingTodoItem, setPendingTodoItemState] = useState<CloudLoopItem | null>(() =>
     pendingTodoForTask(currentRuntimeTask)
   )
-  const [pendingCloudProject, setPendingCloudProject] = useState<CloudProject | null>(
-    () =>
-      pendingProjectForTask(currentRuntimeTask) ??
-      (!currentRuntimeTask && localProjectId
-        ? readCachedAutoJoinProjectSpace(localProjectId, localProjectDeviceId)
-        : null)
+  const [pendingCloudProject, setPendingCloudProject] = useState<CloudProject | null>(() =>
+    pendingProjectForTask(currentRuntimeTask)
   )
   const [todoBindingError, setTodoBindingError] = useState<string | null>(null)
   const [cloudProjects, setCloudProjects] = useState<CloudProject[]>([])
-  const [defaultCloudProjectId, setDefaultCloudProjectId] = useState<CloudProject['id'] | null>(
-    null
-  )
+  const [defaultProjectOptionKey, setDefaultProjectOptionKey] = useState<string | null>(null)
   const [dismissedDefaultCloudProjectKey, setDismissedDefaultCloudProjectKey] = useState<
     string | null
   >(null)
-  const [localBindingRevision, setLocalBindingRevision] = useState(0)
   const [cloudActionNotice, setCloudActionNotice] = useState<string | null>(null)
   const [cloudMentionState, setCloudMentionState] = useState<{
     todoId: string
@@ -698,22 +688,16 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
     (value?: string, options?: { guideWhenBusy?: boolean; interruptWhenBusy?: boolean }) => {
       const supervisorConfig = currentRuntimeTask ? null : pendingSupervisorConfig
       const description = value ?? paneSession.input
-      const cachedProject =
-        !currentRuntimeTask &&
-        localProjectId &&
-        dismissedDefaultCloudProjectKey !== defaultCloudProjectSelectionKey
-          ? readCachedAutoJoinProjectSpace(localProjectId, localProjectDeviceId)
-          : null
-      const submissionProject = currentRuntimeTask ? null : (pendingCloudProject ?? cachedProject)
+      const submissionProject = currentRuntimeTask ? null : pendingCloudProject
       const submissionItem =
         submissionProject?.id === pendingCloudProject?.id ? pendingTodoItem : null
       if (!currentRuntimeTask) {
         setPendingCloudContext(submissionProject, submissionItem)
         pendingAutoJoinResolutionRef.current =
           !submissionProject &&
-          Boolean(localProjectId) &&
+          Boolean(defaultProjectSpace) &&
           dismissedDefaultCloudProjectKey !== defaultCloudProjectSelectionKey &&
-          projectSpaceBindingApis(services).length > 0
+          projectSpaceApis(services).length > 0
             ? { target: null, description }
             : null
       }
@@ -748,10 +732,9 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
     [
       cloudAdditionalContext,
       currentRuntimeTask,
+      defaultProjectSpace,
       defaultCloudProjectSelectionKey,
       dismissedDefaultCloudProjectKey,
-      localProjectDeviceId,
-      localProjectId,
       paneSession.input,
       pendingCloudProject,
       pendingTodoItem,
@@ -837,7 +820,7 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
         active = false
       }
     }
-    const contextApis = projectSpaceBindingApis(services)
+    const contextApis = projectSpaceApis(services)
     if (contextApis.length > 0) {
       void findProjectSpaceContextForTask(contextApis, currentRuntimeTask)
         .then(context => {
@@ -1025,87 +1008,24 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
       ? cloudMentionState.candidates
       : []
 
-  useEffect(() => {
-    const refresh = () => {
-      setLocalBindingRevision(revision => revision + 1)
-      if (
-        currentRuntimeTask ||
-        !localProjectId ||
-        dismissedDefaultCloudProjectKey === defaultCloudProjectSelectionKey
-      ) {
-        return
-      }
-      const cachedProject = readCachedAutoJoinProjectSpace(localProjectId, localProjectDeviceId)
-      if (cachedProject) {
-        setPendingCloudContext(cachedProject, null)
-      } else if (pendingCloudProject?.id === defaultCloudProjectId) {
-        setPendingCloudContext(null, null)
-      }
-    }
-    window.addEventListener(PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT, refresh)
-    return () => window.removeEventListener(PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT, refresh)
-  }, [
-    currentRuntimeTask,
-    defaultCloudProjectId,
-    defaultCloudProjectSelectionKey,
-    dismissedDefaultCloudProjectKey,
-    localProjectDeviceId,
-    localProjectId,
-    pendingCloudProject?.id,
-    setPendingCloudContext,
-  ])
-
-  // A local project association limits the project spaces offered to new tasks.
-  // The default association is a preselection only; the selected task is still
-  // the sole unit that enters the project board.
   useEffect(() => {
     let active = true
-    const apis = [
-      services?.projectSpaceApis?.local,
-      services?.projectSpaceApis?.cloud,
-      services?.deliveryApi,
-    ].filter(
-      (api, index, candidates): api is NonNullable<typeof api> =>
-        Boolean(api) && candidates.indexOf(api) === index
-    )
+    const apis = projectSpaceApis(services)
     if (!apis.length) {
       queueMicrotask(() => {
         if (active) {
           setCloudProjects([])
-          setDefaultCloudProjectId(null)
+          setDefaultProjectOptionKey(null)
         }
       })
       return () => {
         active = false
       }
     }
-    const deviceId = localProjectDeviceId
-    type AssociatedProject = {
-      project: CloudProject
-      binding: CloudProjectLocalBinding | null
-    }
     void Promise.allSettled(
-      apis.map(async (api): Promise<AssociatedProject[]> => {
+      apis.map(async api => {
         const result = await api.listCloudProjects()
-        if (!localProjectId) {
-          return result.items.map(project => ({ project, binding: null }))
-        }
-        const candidates = await Promise.all(
-          result.items.map(async project => {
-            const bindings = await api.listLocalBindings(project.id)
-            const binding =
-              bindings.find(
-                candidate =>
-                  candidate.local_project_id === localProjectId && candidate.device_id === deviceId
-              ) ??
-              bindings.find(
-                candidate => candidate.local_project_id === localProjectId && !candidate.device_id
-              ) ??
-              null
-            return { project, binding }
-          })
-        )
-        return candidates.filter(candidate => Boolean(candidate.binding))
+        return result.items
       })
     )
       .then(results => {
@@ -1116,17 +1036,19 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
         const uniqueProjects = candidates.filter(
           (candidate, index) =>
             candidates.findIndex(
-              other =>
-                other.project.id === candidate.project.id &&
-                other.project.project_store === candidate.project.project_store
+              other => other.id === candidate.id && other.project_store === candidate.project_store
             ) === index
         )
-        const defaultProject = uniqueProjects.find(candidate => candidate.binding?.is_default)
-        setCloudProjects(uniqueProjects.map(candidate => candidate.project))
-        setDefaultCloudProjectId(defaultProject?.project.id ?? null)
-        if (defaultProject && localProjectId) {
-          cacheAutoJoinProjectSpace(localProjectId, deviceId, defaultProject.project)
-        }
+        const defaultProject = defaultProjectSpace
+          ? uniqueProjects.find(
+              project =>
+                projectSpaceKey(projectSpaceRef(project)) === projectSpaceKey(defaultProjectSpace)
+            )
+          : null
+        setCloudProjects(uniqueProjects)
+        setDefaultProjectOptionKey(
+          defaultProject ? projectSpaceKey(projectSpaceRef(defaultProject)) : null
+        )
         const pendingAutoJoin = pendingAutoJoinResolutionRef.current
         const pendingTargetMatchesCurrentTask =
           pendingAutoJoin?.target &&
@@ -1140,13 +1062,13 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
           (!currentRuntimeTask || pendingTargetMatchesCurrentTask)
         ) {
           pendingTodoBinding = {
-            project: defaultProject.project,
+            project: defaultProject,
             item: null,
             target: pendingAutoJoin?.target ?? null,
             description: pendingAutoJoin?.description ?? '',
           }
           pendingAutoJoinResolutionRef.current = null
-          setPendingCloudProject(defaultProject.project)
+          setPendingCloudProject(defaultProject)
           setPendingTodoItemState(null)
         } else if (!defaultProject && pendingAutoJoin) {
           pendingAutoJoinResolutionRef.current = null
@@ -1155,7 +1077,7 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
       .catch(() => {
         if (active) {
           setCloudProjects([])
-          setDefaultCloudProjectId(null)
+          setDefaultProjectOptionKey(null)
         }
       })
     return () => {
@@ -1163,15 +1085,11 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
     }
   }, [
     currentRuntimeTask,
+    defaultProjectSpace,
     defaultCloudProjectSelectionKey,
     dismissedDefaultCloudProjectKey,
-    localBindingRevision,
-    localProjectDeviceId,
-    localProjectId,
     pendingCloudProject,
-    services?.deliveryApi,
-    services?.projectSpaceApis?.cloud,
-    services?.projectSpaceApis?.local,
+    services,
     setPendingCloudContext,
   ])
   const cloudProjectMentionCandidates = useMemo<ComposerCloudMentionCandidate[]>(
@@ -1184,7 +1102,7 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
           title: project.name,
           description: project.description || project.project_key || undefined,
           statusLabel:
-            project.id === defaultCloudProjectId
+            projectSpaceKey(projectSpaceRef(project)) === defaultProjectOptionKey
               ? t('workbench.project_space_auto_join', '自动加入')
               : undefined,
           metaLabel: t('workbench.mention_cloud_space', '云空间'),
@@ -1203,7 +1121,7 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
           project,
         }
       }),
-    [cloudProjects, defaultCloudProjectId, t]
+    [cloudProjects, defaultProjectOptionKey, t]
   )
   const bindComposerCloudProject = useCallback(
     (project: CloudProject, notice: string) => {
diff --git a/wework/src/components/projects/LocalProjectEditDialog.test.tsx b/wework/src/components/projects/LocalProjectEditDialog.test.tsx
index bbf4df208a..b07d0550f0 100644
--- a/wework/src/components/projects/LocalProjectEditDialog.test.tsx
+++ b/wework/src/components/projects/LocalProjectEditDialog.test.tsx
@@ -2,8 +2,7 @@ import { render, screen, waitFor } from '@testing-library/react'
 import userEvent from '@testing-library/user-event'
 import { describe, expect, test, vi } from 'vitest'
 import '@/i18n'
-import type { ProjectSpaceBindingApi } from '@/features/todo/projectSpaceLocalBindings'
-import { runtimeProjectUiId } from '@/lib/runtime-project'
+import type { ProjectSpaceApi } from '@/features/todo/projectSpaceSelection'
 import { LocalProjectEditDialog } from './LocalProjectEditDialog'
 
 const pickerMocks = vi.hoisted(() => ({
@@ -67,6 +66,7 @@ describe('LocalProjectEditDialog', () => {
       projectKey: 'multi-root',
       name: 'Platform',
       roots: ['/repo/api', '/repo/docs'],
+      defaultProjectSpace: null,
     })
   })
 
@@ -92,17 +92,7 @@ describe('LocalProjectEditDialog', () => {
   })
 
   test('configures whether new conversations automatically join a project space', async () => {
-    const localProjectId = runtimeProjectUiId(projectWork.project)
-    const binding = {
-      id: 'binding-1',
-      cloud_project_id: 'space-1',
-      local_project_id: localProjectId,
-      device_id: 'local-device',
-      is_default: true,
-      created_at: '2026-08-04T00:00:00Z',
-      updated_at: '2026-08-04T00:00:00Z',
-    }
-    const updateLocalBinding = vi.fn().mockResolvedValue({ ...binding, is_default: false })
+    const onSave = vi.fn().mockResolvedValue(undefined)
     const projectSpaceApi = {
       listCloudProjects: vi.fn().mockResolvedValue({
         items: [
@@ -124,19 +114,22 @@ describe('LocalProjectEditDialog', () => {
           },
         ],
       }),
-      listLocalBindings: vi.fn().mockResolvedValue([binding]),
-      updateLocalBinding,
-      addLocalBinding: vi.fn(),
-    } as unknown as ProjectSpaceBindingApi
+    } as unknown as ProjectSpaceApi
 
     render(
       <LocalProjectEditDialog
         {...folderPickerProps}
         open
-        projectWork={projectWork}
+        projectWork={{
+          ...projectWork,
+          project: {
+            ...projectWork.project,
+            defaultProjectSpace: { projectStore: 'local', projectId: 'space-1' },
+          },
+        }}
         projectSpaceApis={[projectSpaceApi]}
         onClose={vi.fn()}
-        onSave={vi.fn().mockResolvedValue(undefined)}
+        onSave={onSave}
         onDelete={vi.fn()}
       />
     )
@@ -146,8 +139,12 @@ describe('LocalProjectEditDialog', () => {
     await userEvent.selectOptions(select, '')
     await userEvent.click(screen.getByTestId('save-local-project-button'))
 
-    expect(updateLocalBinding).toHaveBeenCalledWith('space-1', 'binding-1', {
-      is_default: false,
+    expect(onSave).toHaveBeenCalledWith({
+      deviceId: 'local-device',
+      projectKey: 'multi-root',
+      name: 'Product',
+      roots: ['/repo/web', '/repo/api'],
+      defaultProjectSpace: null,
     })
   })
 })
diff --git a/wework/src/components/projects/LocalProjectEditDialog.tsx b/wework/src/components/projects/LocalProjectEditDialog.tsx
index bed709d6d3..60611a072e 100644
--- a/wework/src/components/projects/LocalProjectEditDialog.tsx
+++ b/wework/src/components/projects/LocalProjectEditDialog.tsx
@@ -3,17 +3,16 @@ import { useEffect, useMemo, useState } from 'react'
 import { createPortal } from 'react-dom'
 import { shouldUseNativeProjectDirectoryPicker } from '@/e2e/automation'
 import {
-  cacheAutoJoinProjectSpace,
-  loadProjectSpaceBindingOptions,
-  saveAutoJoinProjectSpace,
-  type ProjectSpaceBindingApi,
-  type ProjectSpaceBindingOption,
-} from '@/features/todo/projectSpaceLocalBindings'
+  loadProjectSpaceOptions,
+  projectSpaceKey,
+  projectSpaceRef,
+  type ProjectSpaceApi,
+  type ProjectSpaceOption,
+} from '@/features/todo/projectSpaceSelection'
 import { useEscapeKey } from '@/hooks/useEscapeKey'
 import { useTranslation } from '@/hooks/useTranslation'
 import { openNativeProjectDirectoryPickers } from '@/lib/native-directory-picker'
-import { runtimeProjectUiId } from '@/lib/runtime-project'
-import type { DeviceInfo, RuntimeProjectWork } from '@/types/api'
+import type { DeviceInfo, RuntimeProjectSpaceRef, RuntimeProjectWork } from '@/types/api'
 import { DeviceFolderPicker } from './DeviceFolderPicker'
 
 interface LocalProjectEditDialogProps {
@@ -23,13 +22,14 @@ interface LocalProjectEditDialogProps {
   onGetDeviceHomeDirectory: (deviceId: string) => Promise<string>
   onListDeviceDirectories: (deviceId: string, path: string) => Promise<string[]>
   onCreateDeviceDirectory: (deviceId: string, path: string) => Promise<void>
-  projectSpaceApis?: ProjectSpaceBindingApi[]
+  projectSpaceApis?: ProjectSpaceApi[]
   onClose: () => void
   onSave: (data: {
     deviceId: string
     projectKey: string
     name: string
     roots: string[]
+    defaultProjectSpace: RuntimeProjectSpaceRef | null
   }) => Promise<void>
   onDelete: () => void
 }
@@ -99,32 +99,25 @@ function LocalProjectEditDialogContent({
   const [submitting, setSubmitting] = useState(false)
   const [showFolderPicker, setShowFolderPicker] = useState(false)
   const [error, setError] = useState<string | null>(null)
-  const [projectSpaceOptions, setProjectSpaceOptions] = useState<ProjectSpaceBindingOption[]>([])
-  const [autoJoinProjectSpaceKey, setAutoJoinProjectSpaceKey] = useState<string | null>(null)
-  const [initialAutoJoinProjectSpaceKey, setInitialAutoJoinProjectSpaceKey] = useState<
-    string | null
-  >(null)
+  const [projectSpaceOptions, setProjectSpaceOptions] = useState<ProjectSpaceOption[]>([])
+  const [autoJoinProjectSpaceKey, setAutoJoinProjectSpaceKey] = useState<string | null>(() => {
+    const ref = projectWork.project.defaultProjectSpace
+    return ref ? projectSpaceKey(ref) : null
+  })
   const [projectSpacesLoading, setProjectSpacesLoading] = useState(projectSpaceApis.length > 0)
   const deviceId =
     projectWork.project.stateDeviceId?.trim() ||
     projectWork.deviceWorkspaces[0]?.deviceId.trim() ||
     ''
-  const localProjectId = runtimeProjectUiId(projectWork.project)
-
   useEscapeKey(onClose, !submitting)
 
   useEffect(() => {
     if (projectSpaceApis.length === 0) return
     let active = true
-    void loadProjectSpaceBindingOptions(projectSpaceApis, localProjectId, deviceId || undefined)
+    void loadProjectSpaceOptions(projectSpaceApis)
       .then(options => {
         if (!active) return
-        const selectedKey = options.find(option => option.binding?.is_default)?.key ?? null
-        const selectedProject = options.find(option => option.key === selectedKey)?.project ?? null
-        cacheAutoJoinProjectSpace(localProjectId, deviceId || undefined, selectedProject)
         setProjectSpaceOptions(options)
-        setAutoJoinProjectSpaceKey(selectedKey)
-        setInitialAutoJoinProjectSpaceKey(selectedKey)
       })
       .catch(loadError => {
         if (!active) return
@@ -136,7 +129,7 @@ function LocalProjectEditDialogContent({
     return () => {
       active = false
     }
-  }, [deviceId, localProjectId, projectSpaceApis])
+  }, [projectSpaceApis])
 
   const addFolders = async () => {
     if (!shouldUseNativeProjectDirectoryPicker()) {
@@ -157,20 +150,24 @@ function LocalProjectEditDialogContent({
     setSubmitting(true)
     setError(null)
     try {
+      const selectedProjectSpace = projectSpaceOptions.find(
+        option => option.key === autoJoinProjectSpaceKey
+      )
+      const existingDefaultProjectSpace = projectWork.project.defaultProjectSpace ?? null
+      const existingDefaultKey = existingDefaultProjectSpace
+        ? projectSpaceKey(existingDefaultProjectSpace)
+        : null
       await onSave({
         deviceId,
         projectKey: projectWork.project.key,
         name: trimmedName,
         roots,
+        defaultProjectSpace: selectedProjectSpace
+          ? projectSpaceRef(selectedProjectSpace.project)
+          : autoJoinProjectSpaceKey === existingDefaultKey
+            ? existingDefaultProjectSpace
+            : null,
       })
-      if (autoJoinProjectSpaceKey !== initialAutoJoinProjectSpaceKey) {
-        await saveAutoJoinProjectSpace(
-          projectSpaceOptions,
-          autoJoinProjectSpaceKey,
-          localProjectId,
-          deviceId || undefined
-        )
-      }
       onClose()
     } catch (saveError) {
       setError(saveError instanceof Error ? saveError.message : String(saveError))
diff --git a/wework/src/features/todo/CloudProjectManageView.tsx b/wework/src/features/todo/CloudProjectManageView.tsx
index af24160766..faf56e7c83 100644
--- a/wework/src/features/todo/CloudProjectManageView.tsx
+++ b/wework/src/features/todo/CloudProjectManageView.tsx
@@ -5,17 +5,12 @@ import type { DwsApi, DwsAuthStatus } from '@/api/dws'
 import type {
   CloudLoopItem,
   CloudProject,
-  CloudProjectLocalBinding,
   CloudProjectMember,
   CloudUserSearchItem,
 } from '@/api/deliveries'
-import { PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT } from '@/api/deliveries'
-import { cacheAutoJoinProjectSpace } from './projectSpaceLocalBindings'
 import { ActionMenu } from '@/components/common/ActionMenu'
 import type { WorkbenchServices } from '@/features/workbench/workbenchServices'
-import { useTranslation } from '@/hooks/useTranslation'
 import { cn } from '@/lib/utils'
-import type { ProjectWithTasks } from '@/types/api'
 import { BoardLayoutEditor } from './BoardLayoutEditor'
 import type { BoardCardDisplaySettings } from './CloudTodoBoardCard'
 import {
@@ -63,7 +58,6 @@ export function CloudProjectManageView({
   aitableApi,
   dwsApi,
   project,
-  localProjects,
   boardCardDisplay,
   onProjectUpdated,
 }: {
@@ -71,11 +65,9 @@ export function CloudProjectManageView({
   aitableApi?: AITableApi
   dwsApi?: DwsApi
   project: CloudProject
-  localProjects: ProjectWithTasks[]
   boardCardDisplay?: BoardCardDisplaySettings
   onProjectUpdated?: (project: CloudProject) => void
 }) {
-  const { t } = useTranslation('common')
   const [version, setVersion] = useState(project.version)
   const [error, setError] = useState<string | null>(null)
   const [members, setMembers] = useState<CloudProjectMember[]>([])
@@ -84,11 +76,6 @@ export function CloudProjectManageView({
   const [display, setDisplay] = useState(() => initialDisplay(project, boardCardDisplay))
   const [statuses, setStatuses] = useState<BoardStatuses>(project.board_config?.statuses ?? [])
   const [visibility, setVisibility] = useState(project.visibility ?? 'private')
-  const [localBindings, setLocalBindings] = useState<CloudProjectLocalBinding[]>([])
-  const [selectedLocalProjectId, setSelectedLocalProjectId] = useState<number | null>(
-    localProjects[0]?.id ?? null
-  )
-  const [bindingBusyId, setBindingBusyId] = useState<number | null>(null)
 
   const [membersOpen, setMembersOpen] = useState(false)
   const [memberQuery, setMemberQuery] = useState('')
@@ -123,18 +110,11 @@ export function CloudProjectManageView({
 
   useEffect(() => {
     let active = true
-    void Promise.all([
-      api.listCloudProjectMembers(project.id),
-      api.listLoopItems(project.id),
-      typeof api.listLocalBindings === 'function'
-        ? api.listLocalBindings(project.id)
-        : Promise.resolve([]),
-    ])
-      .then(([nextMembers, response, bindings]) => {
+    void Promise.all([api.listCloudProjectMembers(project.id), api.listLoopItems(project.id)])
+      .then(([nextMembers, response]) => {
         if (!active) return
         setMembers(nextMembers)
         setItems(response.items)
-        setLocalBindings(bindings)
       })
       .catch(cause => active && setError(cause instanceof Error ? cause.message : '加载项目失败'))
     return () => {
@@ -142,48 +122,6 @@ export function CloudProjectManageView({
     }
   }, [api, project.id])
 
-  async function addLocalProjectBinding() {
-    if (!selectedLocalProjectId || bindingBusyId !== null) return
-    setBindingBusyId(selectedLocalProjectId)
-    try {
-      const created = await api.addLocalBinding(project.id, {
-        local_project_id: selectedLocalProjectId,
-        is_default: false,
-      })
-      setLocalBindings(current => [...current, created])
-      window.dispatchEvent(new Event(PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT))
-    } catch (cause) {
-      setError(
-        cause instanceof Error
-          ? cause.message
-          : t('todo.local_binding_link_failed', '关联本地项目失败')
-      )
-    } finally {
-      setBindingBusyId(null)
-    }
-  }
-
-  async function removeLocalProjectBinding(binding: CloudProjectLocalBinding) {
-    if (bindingBusyId !== null) return
-    setBindingBusyId(binding.local_project_id)
-    try {
-      await api.deleteLocalBinding(project.id, binding.id)
-      if (binding.is_default) {
-        cacheAutoJoinProjectSpace(binding.local_project_id, binding.device_id, null)
-      }
-      setLocalBindings(current => current.filter(candidate => candidate.id !== binding.id))
-      window.dispatchEvent(new Event(PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT))
-    } catch (cause) {
-      setError(
-        cause instanceof Error
-          ? cause.message
-          : t('todo.local_binding_unlink_failed', '解除本地项目关联失败')
-      )
-    } finally {
-      setBindingBusyId(null)
-    }
-  }
-
   useEffect(() => {
     if (!isAITable || !aitableApi) return
     void aitableApi
@@ -454,101 +392,6 @@ export function CloudProjectManageView({
           <p className="mt-1 text-sm text-text-muted">管理项目成员、标签和看板布局。</p>
         </header>
 
-        <section className="border-t border-border py-6">
-          <div>
-            <h2 className="text-heading-md font-semibold">
-              {t('todo.local_binding_title', '关联本地项目')}
-            </h2>
-            <p className="mt-1 text-sm text-text-muted">
-              {t(
-                'todo.local_binding_description',
-                '关联后可从任务输入框的“+”菜单选择当前项目空间；自动加入请在本地项目设置中配置。'
-              )}
-            </p>
-          </div>
-          <div className="mt-4 space-y-2">
-            {localBindings.map(binding => {
-              const localProject = localProjects.find(
-                candidate => candidate.id === binding.local_project_id
-              )
-              return (
-                <div
-                  key={binding.id}
-                  data-testid={`cloud-project-local-binding-${binding.local_project_id}`}
-                  className="flex items-center gap-3 rounded-xl border border-border px-3 py-2.5"
-                >
-                  <span className="min-w-0 flex-1">
-                    <span className="block truncate text-sm font-medium">
-                      {localProject?.name ??
-                        t('todo.local_binding_project_fallback', '本地项目 #{{id}}', {
-                          id: binding.local_project_id,
-                        })}
-                    </span>
-                    <span className="block text-xs text-text-muted">
-                      {binding.device_id
-                        ? t('todo.local_binding_device', '设备 {{device}}', {
-                            device: binding.device_id,
-                          })
-                        : t('todo.local_binding_all_devices', '所有设备')}
-                    </span>
-                  </span>
-                  {binding.is_default && (
-                    <span
-                      data-testid={`cloud-project-local-binding-default-${binding.local_project_id}`}
-                      className="rounded-lg border border-text-primary bg-text-primary px-3 py-1.5 text-xs text-background"
-                    >
-                      {t('todo.local_binding_default', '自动加入')}
-                    </span>
-                  )}
-                  <button
-                    type="button"
-                    data-testid={`cloud-project-local-binding-remove-${binding.local_project_id}`}
-                    aria-label={t('todo.local_binding_unlink', '解除关联')}
-                    disabled={bindingBusyId !== null}
-                    onClick={() => void removeLocalProjectBinding(binding)}
-                    className="grid size-8 place-items-center rounded-lg text-text-muted hover:bg-muted hover:text-danger disabled:opacity-50"
-                  >
-                    <Trash2 className="size-4" />
-                  </button>
-                </div>
-              )
-            })}
-            {localProjects.some(
-              localProject =>
-                !localBindings.some(binding => binding.local_project_id === localProject.id)
-            ) ? (
-              <div className="flex gap-2 rounded-xl bg-muted p-2">
-                <select
-                  data-testid="cloud-project-local-binding-project"
-                  value={selectedLocalProjectId ?? ''}
-                  onChange={event => setSelectedLocalProjectId(Number(event.target.value) || null)}
-                  className="h-9 min-w-0 flex-1 rounded-lg border border-border bg-background px-2 text-sm outline-none"
-                >
-                  {localProjects
-                    .filter(
-                      localProject =>
-                        !localBindings.some(binding => binding.local_project_id === localProject.id)
-                    )
-                    .map(localProject => (
-                      <option key={localProject.id} value={localProject.id}>
-                        {localProject.name}
-                      </option>
-                    ))}
-                </select>
-                <button
-                  type="button"
-                  data-testid="cloud-project-local-binding-add"
-                  disabled={!selectedLocalProjectId || bindingBusyId !== null}
-                  onClick={() => void addLocalProjectBinding()}
-                  className="h-9 rounded-lg px-3 text-xs text-text-secondary hover:bg-background disabled:opacity-50"
-                >
-                  {t('todo.local_binding_link', '关联')}
-                </button>
-              </div>
-            ) : null}
-          </div>
-        </section>
-
         <section className="border-t border-border py-6">
           <div className="flex items-start justify-between gap-4">
             <div>
diff --git a/wework/src/features/todo/CloudTodoWorkspace.tsx b/wework/src/features/todo/CloudTodoWorkspace.tsx
index 7c85803060..3575f4ba55 100644
--- a/wework/src/features/todo/CloudTodoWorkspace.tsx
+++ b/wework/src/features/todo/CloudTodoWorkspace.tsx
@@ -1940,7 +1940,6 @@ export function CloudTodoWorkspace({
                   aitableApi={aitableApi}
                   dwsApi={services.dwsApi}
                   project={selectedProject}
-                  localProjects={localProjects}
                   boardCardDisplay={boardCardDisplay}
                   onProjectUpdated={updated =>
                     setProjects(current =>
diff --git a/wework/src/features/todo/projectSpaceLocalBindings.test.ts b/wework/src/features/todo/projectSpaceLocalBindings.test.ts
deleted file mode 100644
index b516fa72d3..0000000000
--- a/wework/src/features/todo/projectSpaceLocalBindings.test.ts
+++ /dev/null
@@ -1,113 +0,0 @@
-import { describe, expect, test, vi } from 'vitest'
-import type { CloudProject, CloudProjectLocalBinding } from '@/api/deliveries'
-import {
-  findProjectSpaceContextForTask,
-  loadProjectSpaceBindingOptions,
-  readCachedAutoJoinProjectSpace,
-  saveAutoJoinProjectSpace,
-  type ProjectSpaceBindingApi,
-} from './projectSpaceLocalBindings'
-
-function project(id: string, name: string, projectStore: 'local' | 'backend'): CloudProject {
-  return {
-    id,
-    public_id: `public-${id}`,
-    project_key: id.toUpperCase(),
-    name,
-    description: '',
-    project_store: projectStore,
-    task_provider: projectStore === 'local' ? 'local' : 'native',
-    provider_config: {},
-    created_by_user_id: 1,
-    status: 'active',
-    tags: [],
-    version: 1,
-    created_at: '2026-08-04T00:00:00Z',
-    updated_at: '2026-08-04T00:00:00Z',
-  }
-}
-
-function binding(
-  id: string,
-  projectId: string,
-  localProjectId: number,
-  isDefault: boolean
-): CloudProjectLocalBinding {
-  return {
-    id,
-    cloud_project_id: projectId,
-    local_project_id: localProjectId,
-    device_id: 'device-1',
-    is_default: isDefault,
-    created_at: '2026-08-04T00:00:00Z',
-    updated_at: '2026-08-04T00:00:00Z',
-  }
-}
-
-function api(
-  cloudProject: CloudProject,
-  localBindings: CloudProjectLocalBinding[]
-): ProjectSpaceBindingApi {
-  return {
-    listCloudProjects: vi.fn().mockResolvedValue({ items: [cloudProject] }),
-    listLocalBindings: vi.fn().mockResolvedValue(localBindings),
-    updateLocalBinding: vi.fn().mockImplementation(async (_projectId, bindingId, data) => ({
-      ...localBindings.find(candidate => candidate.id === bindingId)!,
-      ...data,
-    })),
-    addLocalBinding: vi.fn(),
-  } as unknown as ProjectSpaceBindingApi
-}
-
-describe('projectSpaceLocalBindings', () => {
-  test('moves automatic joining between local and cloud project-space stores', async () => {
-    window.localStorage.clear()
-    const localProjectId = 7
-    const firstProject = project('space-local', 'Local board', 'local')
-    const secondProject = project('space-cloud', 'Cloud board', 'backend')
-    const firstBinding = binding('binding-local', firstProject.id, localProjectId, true)
-    const secondBinding = binding('binding-cloud', secondProject.id, localProjectId, false)
-    const localApi = api(firstProject, [firstBinding])
-    const cloudApi = api(secondProject, [secondBinding])
-
-    const options = await loadProjectSpaceBindingOptions(
-      [localApi, cloudApi],
-      localProjectId,
-      'device-1'
-    )
-    await saveAutoJoinProjectSpace(options, 'backend:space-cloud', localProjectId, 'device-1')
-
-    expect(cloudApi.updateLocalBinding).toHaveBeenCalledWith(secondProject.id, secondBinding.id, {
-      is_default: true,
-    })
-    expect(localApi.updateLocalBinding).toHaveBeenCalledWith(firstProject.id, firstBinding.id, {
-      is_default: false,
-    })
-    expect(readCachedAutoJoinProjectSpace(localProjectId, 'device-1')).toEqual(secondProject)
-  })
-
-  test('finds a local project-space context when the cloud store has no binding', async () => {
-    const context = {
-      id: 'context-1',
-      device_id: 'device-1',
-      task_id: 'task-1',
-      cloud_project_id: 'space-local',
-      loop_item_id: 'todo-1',
-      project: project('space-local', 'Local board', 'local'),
-      loop_item: null,
-    }
-    const cloudApi = {
-      findCloudContextForTask: vi.fn().mockRejectedValue(new Error('Not found')),
-    } as unknown as ProjectSpaceBindingApi
-    const localApi = {
-      findCloudContextForTask: vi.fn().mockResolvedValue(context),
-    } as unknown as ProjectSpaceBindingApi
-
-    await expect(
-      findProjectSpaceContextForTask([cloudApi, localApi], {
-        deviceId: 'device-1',
-        taskId: 'task-1',
-      })
-    ).resolves.toEqual(context)
-  })
-})
diff --git a/wework/src/features/todo/projectSpaceLocalBindings.ts b/wework/src/features/todo/projectSpaceLocalBindings.ts
deleted file mode 100644
index 799ef085e0..0000000000
--- a/wework/src/features/todo/projectSpaceLocalBindings.ts
+++ /dev/null
@@ -1,166 +0,0 @@
-import {
-  PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT,
-  type CloudProject,
-  type CloudProjectLocalBinding,
-} from '@/api/deliveries'
-import type { WorkbenchServices } from '@/features/workbench/workbenchServices'
-import type { RuntimeTaskAddress } from '@/types/api'
-
-export type ProjectSpaceBindingApi = NonNullable<WorkbenchServices['deliveryApi']>
-
-export interface ProjectSpaceBindingOption {
-  key: string
-  project: CloudProject
-  api: ProjectSpaceBindingApi
-  binding: CloudProjectLocalBinding | null
-}
-
-const AUTO_JOIN_PROJECT_SPACE_STORAGE_PREFIX = 'wework.project-space-auto-join.v1'
-
-function autoJoinStorageKey(localProjectId: number, deviceId?: string | null): string {
-  return `${AUTO_JOIN_PROJECT_SPACE_STORAGE_PREFIX}:${deviceId || 'all'}:${localProjectId}`
-}
-
-export function readCachedAutoJoinProjectSpace(
-  localProjectId: number,
-  deviceId?: string | null
-): CloudProject | null {
-  try {
-    const stored = window.localStorage.getItem(autoJoinStorageKey(localProjectId, deviceId))
-    return stored ? (JSON.parse(stored) as CloudProject) : null
-  } catch {
-    return null
-  }
-}
-
-export function cacheAutoJoinProjectSpace(
-  localProjectId: number,
-  deviceId: string | null | undefined,
-  project: CloudProject | null
-): void {
-  try {
-    const key = autoJoinStorageKey(localProjectId, deviceId)
-    if (project) {
-      window.localStorage.setItem(key, JSON.stringify(project))
-    } else {
-      window.localStorage.removeItem(key)
-    }
-  } catch {
-    // Persistence is an optimization; the server binding remains authoritative.
-  }
-}
-
-export function projectSpaceBindingApis(
-  services: WorkbenchServices | null | undefined
-): ProjectSpaceBindingApi[] {
-  if (!services) return []
-  const candidates = [
-    services.projectSpaceApis?.local,
-    services.projectSpaceApis?.cloud,
-    services.deliveryApi,
-  ]
-  return candidates.filter(
-    (api, index): api is ProjectSpaceBindingApi => Boolean(api) && candidates.indexOf(api) === index
-  )
-}
-
-export function findProjectSpaceContextForTask(
-  apis: ProjectSpaceBindingApi[],
-  task: RuntimeTaskAddress
-): ReturnType<ProjectSpaceBindingApi['findCloudContextForTask']> {
-  return Promise.any(apis.map(api => api.findCloudContextForTask(task)))
-}
-
-function matchingBinding(
-  bindings: CloudProjectLocalBinding[],
-  localProjectId: number,
-  deviceId?: string
-): CloudProjectLocalBinding | null {
-  return (
-    bindings.find(
-      binding =>
-        binding.local_project_id === localProjectId && binding.device_id === (deviceId ?? null)
-    ) ??
-    bindings.find(
-      binding => binding.local_project_id === localProjectId && binding.device_id === null
-    ) ??
-    null
-  )
-}
-
-function optionKey(project: CloudProject): string {
-  return `${project.project_store}:${project.id}`
-}
-
-export async function loadProjectSpaceBindingOptions(
-  apis: ProjectSpaceBindingApi[],
-  localProjectId: number,
-  deviceId?: string
-): Promise<ProjectSpaceBindingOption[]> {
-  const results = await Promise.allSettled(
-    apis.map(async api => {
-      const projects = await api.listCloudProjects()
-      return Promise.all(
-        projects.items.map(async project => ({
-          key: optionKey(project),
-          project,
-          api,
-          binding: matchingBinding(
-            await api.listLocalBindings(project.id),
-            localProjectId,
-            deviceId
-          ),
-        }))
-      )
-    })
-  )
-  const candidates = results.flatMap(result => (result.status === 'fulfilled' ? result.value : []))
-  const options = new Map<string, ProjectSpaceBindingOption>()
-  for (const candidate of candidates) {
-    const existing = options.get(candidate.key)
-    if (!existing || (!existing.binding?.is_default && candidate.binding?.is_default)) {
-      options.set(candidate.key, candidate)
-    }
-  }
-  return Array.from(options.values()).sort((left, right) =>
-    left.project.name.localeCompare(right.project.name)
-  )
-}
-
-export async function saveAutoJoinProjectSpace(
-  options: ProjectSpaceBindingOption[],
-  selectedKey: string | null,
-  localProjectId: number,
-  deviceId?: string
-): Promise<void> {
-  const selected = selectedKey ? options.find(option => option.key === selectedKey) : null
-  if (selectedKey && !selected) throw new Error('Selected project space is unavailable')
-
-  if (selected) {
-    if (selected.binding) {
-      if (!selected.binding.is_default) {
-        await selected.api.updateLocalBinding(selected.project.id, selected.binding.id, {
-          is_default: true,
-        })
-      }
-    } else {
-      await selected.api.addLocalBinding(selected.project.id, {
-        local_project_id: localProjectId,
-        device_id: deviceId,
-        is_default: true,
-      })
-    }
-  }
-
-  await Promise.all(
-    options
-      .filter(option => option.key !== selectedKey && option.binding?.is_default)
-      .map(option =>
-        option.api.updateLocalBinding(option.project.id, option.binding!.id, {
-          is_default: false,
-        })
-      )
-  )
-  cacheAutoJoinProjectSpace(localProjectId, deviceId, selected?.project ?? null)
-  window.dispatchEvent(new Event(PROJECT_SPACE_LOCAL_BINDINGS_CHANGED_EVENT))
-}
diff --git a/wework/src/features/todo/projectSpaceSelection.test.ts b/wework/src/features/todo/projectSpaceSelection.test.ts
new file mode 100644
index 0000000000..b8e9d99d33
--- /dev/null
+++ b/wework/src/features/todo/projectSpaceSelection.test.ts
@@ -0,0 +1,82 @@
+import { describe, expect, test, vi } from 'vitest'
+import type { CloudProject } from '@/api/deliveries'
+import {
+  findProjectSpaceContextForTask,
+  loadProjectSpaceOptions,
+  projectSpaceRef,
+  type ProjectSpaceApi,
+} from './projectSpaceSelection'
+
+function project(id: string, name: string, projectStore: 'local' | 'backend'): CloudProject {
+  return {
+    id,
+    public_id: `public-${id}`,
+    project_key: id.toUpperCase(),
+    name,
+    description: '',
+    project_store: projectStore,
+    task_provider: projectStore === 'local' ? 'local' : 'native',
+    provider_config: {},
+    created_by_user_id: 1,
+    status: 'active',
+    tags: [],
+    version: 1,
+    created_at: '2026-08-04T00:00:00Z',
+    updated_at: '2026-08-04T00:00:00Z',
+  }
+}
+
+describe('projectSpaceSelection', () => {
+  test('lists local and cloud project spaces without querying per-project bindings', async () => {
+    const localProject = project('space-local', 'Local board', 'local')
+    const cloudProject = project('space-cloud', 'Cloud board', 'backend')
+    const localApi = {
+      listCloudProjects: vi.fn().mockResolvedValue({ items: [localProject] }),
+    } as unknown as ProjectSpaceApi
+    const cloudApi = {
+      listCloudProjects: vi.fn().mockResolvedValue({ items: [cloudProject] }),
+    } as unknown as ProjectSpaceApi
+
+    await expect(loadProjectSpaceOptions([localApi, cloudApi])).resolves.toEqual([
+      {
+        key: 'backend:space-cloud',
+        project: cloudProject,
+        api: cloudApi,
+      },
+      {
+        key: 'local:space-local',
+        project: localProject,
+        api: localApi,
+      },
+    ])
+    expect(projectSpaceRef(cloudProject)).toEqual({
+      projectStore: 'backend',
+      projectId: 'space-cloud',
+    })
+  })
+
+  test('finds a local project-space context when the cloud store has no context', async () => {
+    const context = {
+      id: 'context-1',
+      device_id: 'device-1',
+      task_id: 'task-1',
+      cloud_project_id: 'space-local',
+      loop_item_id: 'todo-1',
+      project: project('space-local', 'Local board', 'local'),
+      loop_item: null,
+    }
+    const cloudApi = {
+      findCloudContextForTask: vi.fn().mockRejectedValue(new Error('Not found')),
+    } as unknown as ProjectSpaceApi
+    const localApi = {
+      findCloudContextForTask: vi.fn().mockResolvedValue(context),
+    } as unknown as ProjectSpaceApi
+
+    await expect(
+      findProjectSpaceContextForTask([cloudApi, localApi], {
+        deviceId: 'device-1',
+        taskId: 'task-1',
+      })
+    ).resolves.toEqual(context)
+  })
+})
diff --git a/wework/src/features/todo/projectSpaceSelection.ts b/wework/src/features/todo/projectSpaceSelection.ts
new file mode 100644
index 0000000000..6273ebe1eb
--- /dev/null
+++ b/wework/src/features/todo/projectSpaceSelection.ts
@@ -0,0 +1,68 @@
+import type { CloudProject } from '@/api/deliveries'
+import type { WorkbenchServices } from '@/features/workbench/workbenchServices'
+import type { RuntimeProjectSpaceRef, RuntimeTaskAddress } from '@/types/api'
+
+export type ProjectSpaceApi = NonNullable<WorkbenchServices['deliveryApi']>
+
+export interface ProjectSpaceOption {
+  key: string
+  project: CloudProject
+  api: ProjectSpaceApi
+}
+
+export function projectSpaceRef(project: CloudProject): RuntimeProjectSpaceRef {
+  return {
+    projectStore: project.project_store,
+    projectId: project.id,
+  }
+}
+
+export function projectSpaceKey(ref: RuntimeProjectSpaceRef): string {
+  return `${ref.projectStore}:${ref.projectId}`
+}
+
+export function projectSpaceApis(
+  services: WorkbenchServices | null | undefined
+): ProjectSpaceApi[] {
+  if (!services) return []
+  const candidates = [
+    services.projectSpaceApis?.local,
+    services.projectSpaceApis?.cloud,
+    services.deliveryApi,
+  ]
+  return candidates.filter(
+    (api, index): api is ProjectSpaceApi => Boolean(api) && candidates.indexOf(api) === index
+  )
+}
+
+export function findProjectSpaceContextForTask(
+  apis: ProjectSpaceApi[],
+  task: RuntimeTaskAddress
+): ReturnType<ProjectSpaceApi['findCloudContextForTask']> {
+  return Promise.any(apis.map(api => api.findCloudContextForTask(task)))
+}
+
+export async function loadProjectSpaceOptions(
+  apis: ProjectSpaceApi[]
+): Promise<ProjectSpaceOption[]> {
+  const results = await Promise.allSettled(
+    apis.map(async api => {
+      const projects = await api.listCloudProjects()
+      return projects.items.map(project => ({
+        key: projectSpaceKey(projectSpaceRef(project)),
+        project,
+        api,
+      }))
+    })
+  )
+  const options = new Map<string, ProjectSpaceOption>()
+  for (const result of results) {
+    if (result.status !== 'fulfilled') continue
+    for (const option of result.value) {
+      if (!options.has(option.key)) options.set(option.key, option)
+    }
+  }
+  return Array.from(options.values()).sort((left, right) =>
+    left.project.name.localeCompare(right.project.name)
+  )
+}
diff --git a/wework/src/features/workbench/remoteRuntimeWorkCache.test.ts b/wework/src/features/workbench/remoteRuntimeWorkCache.test.ts
index d47d300454..de6058a378 100644
--- a/wework/src/features/workbench/remoteRuntimeWorkCache.test.ts
+++ b/wework/src/features/workbench/remoteRuntimeWorkCache.test.ts
@@ -101,6 +101,10 @@ describe('remote runtime work cache', () => {
         ],
       })
     )
+    input.projects[0].project.defaultProjectSpace = {
+      projectStore: 'backend',
+      projectId: 'space-1',
+    }
 
     writeCachedRemoteRuntimeWork(7, input, [
       device('remote-a', 'online', { client_ip: '10.201.3.200' }),
@@ -118,6 +122,10 @@ describe('remote runtime work cache', () => {
       remoteHostId: 'remote-a',
       repoUrl: 'git@example.com:team/repo.git',
     })
+    expect(restored.projects[0].project.defaultProjectSpace).toEqual({
+      projectStore: 'backend',
+      projectId: 'space-1',
+    })
     expect(restoredTask).toMatchObject({
       taskId: 'task-a',
       threadId: 'thread-a',
diff --git a/wework/src/features/workbench/remoteRuntimeWorkCache.ts b/wework/src/features/workbench/remoteRuntimeWorkCache.ts
index aa04f411bb..8674e4c34a 100644
--- a/wework/src/features/workbench/remoteRuntimeWorkCache.ts
+++ b/wework/src/features/workbench/remoteRuntimeWorkCache.ts
@@ -4,6 +4,7 @@ import type {
   RuntimeDeviceWorkspace,
   RuntimeProjectRef,
   RuntimeProjectRoot,
+  RuntimeProjectSpaceRef,
   RuntimeProjectWork,
   RuntimeTaskSummary,
   RuntimeWorkListResponse,
@@ -74,6 +75,13 @@ function sanitizeProjectRef(value: unknown): RuntimeProjectRef | null {
         .map(sanitizeProjectRoot)
         .filter((root): root is RuntimeProjectRoot => root !== null)
     : undefined
+  const rawDefaultProjectSpace = recordValue(project.defaultProjectSpace)
+  const defaultProjectStore = stringValue(rawDefaultProjectSpace.projectStore)
+  const defaultProjectId = stringValue(rawDefaultProjectSpace.projectId)
+  const defaultProjectSpace: RuntimeProjectSpaceRef | undefined =
+    (defaultProjectStore === 'local' || defaultProjectStore === 'backend') && defaultProjectId
+      ? { projectStore: defaultProjectStore, projectId: defaultProjectId }
+      : undefined
 
   return {
     key,
@@ -99,6 +107,7 @@ function sanitizeProjectRef(value: unknown): RuntimeProjectRef | null {
       ? { pinnedOrder: nullableNumberValue(project.pinnedOrder) }
       : {}),
     ...(booleanValue(project.active) !== undefined ? { active: booleanValue(project.active) } : {}),
+    ...(defaultProjectSpace ? { defaultProjectSpace } : {}),
   }
 }
 
diff --git a/wework/src/features/workbench/useWorkbenchProjectActions.ts b/wework/src/features/workbench/useWorkbenchProjectActions.ts
index 3fe96616c7..cc1330f770 100644
--- a/wework/src/features/workbench/useWorkbenchProjectActions.ts
+++ b/wework/src/features/workbench/useWorkbenchProjectActions.ts
@@ -21,6 +21,7 @@ import type {
   GitRepoInfo,
   ProjectWithTasks,
   RuntimeProjectAppearanceRequest,
+  RuntimeProjectSpaceRef,
   RuntimeProjectPinRequest,
   RuntimeProjectReorderRequest,
   RuntimeProjectTaskReorderRequest,
@@ -181,7 +182,13 @@ export function useWorkbenchProjectActions({
   )
 
   const updateLocalRuntimeProject = useCallback(
-    async (data: { deviceId: string; projectKey: string; name: string; roots: string[] }) => {
+    async (data: {
+      deviceId: string
+      projectKey: string
+      name: string
+      roots: string[]
+      defaultProjectSpace: RuntimeProjectSpaceRef | null
+    }) => {
       const response = await executorClient.runtime.upsertLocalRuntimeProject({
         ...data,
         runtime: 'codex',
diff --git a/wework/src/features/workbench/workbenchContextTypes.ts b/wework/src/features/workbench/workbenchContextTypes.ts
index 09ffea27c8..4c49aedbb5 100644
--- a/wework/src/features/workbench/workbenchContextTypes.ts
+++ b/wework/src/features/workbench/workbenchContextTypes.ts
@@ -32,6 +32,7 @@ import type {
   RuntimeTaskAddress,
   RuntimeTaskForkTarget,
   RuntimeProjectAppearanceRequest,
+  RuntimeProjectSpaceRef,
   RuntimeProjectPinRequest,
   RuntimeProjectReorderRequest,
   RuntimeProjectTaskReorderRequest,
@@ -251,6 +252,7 @@ export interface WorkbenchContextValue {
     projectKey: string
     name: string
     roots: string[]
+    defaultProjectSpace: RuntimeProjectSpaceRef | null
   }) => Promise<void>
   removeProject: (projectId: number) => Promise<void>
   reorderRuntimeProjects: (data: RuntimeProjectReorderRequest) => Promise<void>
diff --git a/wework/src/i18n/locales/en/common.json b/wework/src/i18n/locales/en/common.json
index ca932689be..1b1b487111 100644
--- a/wework/src/i18n/locales/en/common.json
+++ b/wework/src/i18n/locales/en/common.json
@@ -1970,16 +1970,6 @@
     "home_manage_search": "Search project spaces",
     "home_manage_empty": "No matching project spaces",
     "home_open": "Open",
-    "local_binding_title": "Link local projects",
-    "local_binding_description": "Linked project spaces appear in the task composer's “+” menu. Configure automatic joining in the local project settings.",
-    "local_binding_project_fallback": "Local project #{{id}}",
-    "local_binding_device": "Device {{device}}",
-    "local_binding_all_devices": "All devices",
-    "local_binding_default": "Automatic",
-    "local_binding_link": "Link",
-    "local_binding_link_failed": "Failed to link the local project",
-    "local_binding_unlink": "Unlink",
-    "local_binding_unlink_failed": "Failed to unlink the local project",
     "my_work_calendar_note": "The calendar only shows tasks with a due date.",
     "my_work_col_due": "Due",
     "my_work_col_project": "Project",
diff --git a/wework/src/i18n/locales/zh-CN/common.json b/wework/src/i18n/locales/zh-CN/common.json
index 76be3f428e..8dddd9a329 100644
--- a/wework/src/i18n/locales/zh-CN/common.json
+++ b/wework/src/i18n/locales/zh-CN/common.json
@@ -1967,16 +1967,6 @@
     "home_manage_search": "搜索项目空间",
     "home_manage_empty": "没有匹配的项目空间",
     "home_open": "打开",
-    "local_binding_title": "关联本地项目",
-    "local_binding_description": "关联后可从任务输入框的“+”菜单选择当前项目空间；自动加入请在本地项目设置中配置。",
-    "local_binding_project_fallback": "本地项目 #{{id}}",
-    "local_binding_device": "设备 {{device}}",
-    "local_binding_all_devices": "所有设备",
-    "local_binding_default": "自动加入",
-    "local_binding_link": "关联",
-    "local_binding_link_failed": "关联本地项目失败",
-    "local_binding_unlink": "解除关联",
-    "local_binding_unlink_failed": "解除本地项目关联失败",
     "my_work_calendar_note": "日历仅展示设置了截止日期的任务。",
     "my_work_col_due": "截止日期",
     "my_work_col_project": "项目",
diff --git a/wework/src/types/api.ts b/wework/src/types/api.ts
index 5557763c08..a9149f9fed 100644
--- a/wework/src/types/api.ts
+++ b/wework/src/types/api.ts
@@ -470,6 +470,12 @@ export interface RuntimeProjectRef {
   pinnedOrder?: number | null
   active?: boolean
   appearance?: RuntimeProjectAppearance | null
+  defaultProjectSpace?: RuntimeProjectSpaceRef | null
+}
+
+export interface RuntimeProjectSpaceRef {
+  projectStore: 'local' | 'backend'
+  projectId: string
 }
 
 export interface RuntimeProjectRoot {
@@ -813,6 +819,7 @@ export interface RuntimeLocalProjectUpsertRequest {
   projectKey: string
   name: string
   roots: string[]
+  defaultProjectSpace?: RuntimeProjectSpaceRef | null
   runtime: 'codex'
 }
 
@@ -822,6 +829,7 @@ export interface RuntimeLocalProjectUpsertResponse {
   projectKey: string
   name: string
   roots: string[]
+  defaultProjectSpace?: RuntimeProjectSpaceRef | null
   runtime: 'codex'
   error?: string | null
 }