diff --git a/docs/next/api/herdr-api.schema.json b/docs/next/api/herdr-api.schema.json
index 35c9299dcb..4265282c92 100644
--- a/docs/next/api/herdr-api.schema.json
+++ b/docs/next/api/herdr-api.schema.json
@@ -4641,6 +4641,25 @@
           },
           "type": "object"
         },
+        "WorkspaceMergeParams": {
+          "description": "Relocates every tab of `source_workspace_id` into `target_workspace_id` and\nthen closes the emptied source.\n\n`merge_group` is the same explicit-intent gate `workspace.close` carries: a\nsource that owns linked worktree workspaces refuses without it, so merge\ncannot become a way around that control. With the flag the whole worktree\ngroup merges — every member's tabs move to the target, and every member\ncloses. Merge never destroys a tab.",
+          "properties": {
+            "merge_group": {
+              "type": "boolean"
+            },
+            "source_workspace_id": {
+              "type": "string"
+            },
+            "target_workspace_id": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "source_workspace_id",
+            "target_workspace_id"
+          ],
+          "type": "object"
+        },
         "WorkspaceMoveBlockParams": {
           "properties": {
             "before_workspace_id": {
@@ -5244,6 +5263,22 @@
           ],
           "type": "object"
         },
+        {
+          "properties": {
+            "method": {
+              "const": "workspace.merge",
+              "type": "string"
+            },
+            "params": {
+              "$ref": "#/schemas/request/$defs/WorkspaceMergeParams"
+            }
+          },
+          "required": [
+            "method",
+            "params"
+          ],
+          "type": "object"
+        },
         {
           "properties": {
             "method": {
diff --git a/docs/next/website/src/content/docs/cli-reference.mdx b/docs/next/website/src/content/docs/cli-reference.mdx
index 71b1dba168..0caae1fe3b 100644
--- a/docs/next/website/src/content/docs/cli-reference.mdx
+++ b/docs/next/website/src/content/docs/cli-reference.mdx
@@ -121,6 +121,7 @@ herdr workspace focus <workspace_id>
 herdr workspace rename <workspace_id> <label>
 herdr workspace move <workspace_id> --index N
 herdr workspace report-metadata <workspace_id> --source ID [--token NAME=VALUE] [--clear-token NAME] [--seq N] [--ttl-ms N]
+herdr workspace merge <source_workspace_id> <target_workspace_id> [--group]
 herdr workspace close <workspace_id> [--group]
 ```
 
@@ -143,6 +144,8 @@ herdr worktree remove --workspace ID [--force] [--trust-repository]
 
 Worktrees are normal Herdr workspaces with Git checkout provenance. `worktree create` creates a Git worktree checkout, opens it as a workspace, and groups it with the parent repo workspace. If `--branch` names an existing local branch, Herdr checks it out; otherwise it creates the branch from `--base` or `HEAD`. Without `--path`, Herdr creates the checkout under `<worktrees.directory>/<repo>/<branch-slug>`.
 
+`workspace merge` moves every tab of the source workspace into the target and closes the emptied source; no tab is destroyed. When the source owns linked-worktree workspaces, it requires `--group` — the same explicit intent `workspace close` requires — and without it returns `workspace_group_merge_required`. With `--group`, every group member's tabs move to the target and every member closes.
+
 `workspace close` closes only Herdr state. Closing a primary workspace while linked-worktree workspaces are open requires `--group`; without it, the command leaves the group open and returns `workspace_group_close_required`. To delete the checkout, run `worktree remove`. It runs `git worktree remove`, never deletes the branch, and requires `--force` when Git refuses a dirty checkout.
 
 Git rejects repositories owned by another user by default. If you have independently verified the repository, pass `--trust-repository` to trust its resolved path for that command only. Herdr does not change your Git configuration.
diff --git a/docs/next/website/src/content/docs/ja/cli-reference.mdx b/docs/next/website/src/content/docs/ja/cli-reference.mdx
index 39c44584b7..36da5a8ab6 100644
--- a/docs/next/website/src/content/docs/ja/cli-reference.mdx
+++ b/docs/next/website/src/content/docs/ja/cli-reference.mdx
@@ -117,6 +117,7 @@ herdr workspace focus <workspace_id>
 herdr workspace rename <workspace_id> <label>
 herdr workspace move <workspace_id> --index N
 herdr workspace report-metadata <workspace_id> --source ID [--token NAME=VALUE] [--clear-token NAME] [--seq N] [--ttl-ms N]
+herdr workspace merge <source_workspace_id> <target_workspace_id> [--group]
 herdr workspace close <workspace_id> [--group]
 ```
 
@@ -139,6 +140,8 @@ herdr worktree remove --workspace ID [--force] [--trust-repository]
 
 worktree は、Git チェックアウトの出自情報を持つ通常の Herdr ワークスペースです。`worktree create` は Git worktree のチェックアウトを作成し、ワークスペースとして開き、親リポジトリのワークスペースとグループ化します。`--branch` が既存のローカルブランチを指す場合はそれをチェックアウトし、そうでなければ `--base` または `HEAD` からブランチを作成します。`--path` がない場合、チェックアウトは `<worktrees.directory>/<repo>/<branch-slug>` の下に作成されます。
 
+`workspace merge` は移動元ワークスペースのすべてのタブを移動先へ移し、空になった移動元を閉じます。タブが失われることはありません。移動元がリンクされた worktree ワークスペースを持つ場合は `--group` が必要で（`workspace close` と同じ明示的な意思表示です）、指定しない場合は `workspace_group_merge_required` を返します。`--group` を指定すると、グループ全メンバーのタブが移動先へ移り、全メンバーが閉じられます。
+
 `workspace close` は Herdr の状態だけを閉じます。リンクされた worktree ワークスペースが開いている間に親ワークスペースを閉じるには `--group` が必要です。指定しない場合、グループは開いたままになり `workspace_group_close_required` が返されます。`worktree remove` が明示的なチェックアウト削除の経路です。`git worktree remove` を実行し、ブランチは決して削除せず、Git がダーティなチェックアウトを拒否する場合は `--force` が必要です。
 
 Git はデフォルトで、別のユーザーが所有するリポジトリを拒否します。リポジトリを別途確認済みの場合は `--trust-repository` を渡すと、解決されたパスをそのコマンドでのみ信頼します。Herdr は Git 設定を変更しません。
diff --git a/docs/next/website/src/content/docs/ja/socket-api.mdx b/docs/next/website/src/content/docs/ja/socket-api.mdx
index 4baaa85c14..99244737bc 100644
--- a/docs/next/website/src/content/docs/ja/socket-api.mdx
+++ b/docs/next/website/src/content/docs/ja/socket-api.mdx
@@ -96,7 +96,7 @@ herdr pane read w1:p2 --source recent --lines 50
 | 通知 | `notification.show` |
 | クライアント | `client.window_title.set`、`client.window_title.clear` |
 | セッション | `session.snapshot` |
-| ワークスペース | `workspace.create`、`workspace.list`、`workspace.get`、`workspace.focus`、`workspace.rename`、`workspace.move`、`workspace.move_block`、`workspace.report_metadata`、`workspace.close` |
+| ワークスペース | `workspace.create`、`workspace.list`、`workspace.get`、`workspace.focus`、`workspace.rename`、`workspace.move`、`workspace.move_block`、`workspace.merge`、`workspace.report_metadata`、`workspace.close` |
 | Worktree | `worktree.list`、`worktree.create`、`worktree.open`、`worktree.remove` |
 | タブ | `tab.create`、`tab.list`、`tab.get`、`tab.focus`、`tab.rename`、`tab.move`、`tab.close` |
 | ペイン | `pane.split`、`pane.swap`、`pane.move`、`pane.zoom`、`pane.layout`、`pane.process_info`、`pane.neighbor`、`pane.edges`、`pane.focus_direction`、`pane.resize`、`pane.list`、`pane.current`、`pane.get`、`pane.rename`、`pane.send_text`、`pane.send_keys`、`pane.send_input`、`pane.read`、`pane.graphics.info`、`pane.graphics.set`、`pane.graphics.clear`、`pane.graphics.stream`、`pane.report_agent`、`pane.report_agent_session`、`pane.report_metadata`、`pane.clear_agent_authority`、`pane.release_agent`、`pane.close`、`pane.wait_for_output` |
@@ -109,6 +109,8 @@ herdr pane read w1:p2 --source recent --lines 50
 
 `agent.wait` はサーバー所有でイベント駆動です。解決したペイン占有者に固定されるため、置換されたエージェントが待機を満たすことはありません。`agent.prompt` は `until` と `timeout_ms` を持つ省略可能な `wait` オブジェクトを受け付けます。これにより、プロンプト送信と待機開始を 1 つのリクエストで行い、別々の呼び出し間の競合を避けられます。解決したエージェントがすでに `blocked` の場合、`agent.prompt` は入力を送信せず、待機も開始せずに `agent_blocked` を返します。
 
+`workspace.merge` は `source_workspace_id` のすべてのタブを `target_workspace_id` へ移動し、空になった移動元をクローズします。タブが失われることはありません。リンクされたワークツリーワークスペースを持つ移動元は、`merge_group` が `true` でない限り `workspace_group_merge_required` で拒否されます。これは `workspace.close` がグループに対して要求する明示的な意思表示と同じもので、指定するとグループ全メンバーのタブが移動先へ移り、全メンバーがクローズされます。ワークスペース自身への統合、および自身のワークツリーグループのメンバーへの統合は拒否されます。レスポンスには移動先ワークスペースが含まれます。
+
 `workspace.move_block` は、順序付きの `workspace_ids` を `before_workspace_id` の前へアトミックに移動します。アンカーを省略するとブロックを末尾へ移動します。id は一意である必要があり、アンカーをブロックに含めることはできません。レスポンスにはサーバーが確定した順序付きワークスペース一覧が含まれます。
 
 `session.snapshot` は、独自のローカルランタイムキャッシュを持つクライアント向けに、一度限りのブートストラップスナップショットを返します。レスポンスには、バージョン/プロトコルメタデータ、フォーカス中のワークスペース/タブ/ペイン id、ワークスペース、タブ、ペイン、タブレイアウト、エージェントの各レコードが含まれます。これは購読ではありません。ブートストラップ中のイベントを取りこぼさないよう、まず別の接続で `events.subscribe` を開いて確認応答を待ち、そのストリームをバッファしながら `session.snapshot` を呼び出します。スナップショットを適用してから、バッファしたイベントを順番に適用し、そのままストリーミングを続けます。再接続後やキャッシュが古い可能性がある場合は、`session.snapshot` を再度呼び出します。ワークスペースレコードには、関連付けられた worktree の出自情報も含まれます。リポジトリ全体の worktree 検出には引き続き `worktree.list` を使います。
diff --git a/docs/next/website/src/content/docs/socket-api.mdx b/docs/next/website/src/content/docs/socket-api.mdx
index 7277da75aa..1a21cf0f8f 100644
--- a/docs/next/website/src/content/docs/socket-api.mdx
+++ b/docs/next/website/src/content/docs/socket-api.mdx
@@ -100,7 +100,7 @@ Raw socket method names use dot notation:
 | Notification | `notification.show` |
 | Client | `client.window_title.set`, `client.window_title.clear` |
 | Session | `session.snapshot` |
-| Workspace | `workspace.create`, `workspace.list`, `workspace.get`, `workspace.focus`, `workspace.rename`, `workspace.move`, `workspace.move_block`, `workspace.report_metadata`, `workspace.close` |
+| Workspace | `workspace.create`, `workspace.list`, `workspace.get`, `workspace.focus`, `workspace.rename`, `workspace.move`, `workspace.move_block`, `workspace.merge`, `workspace.report_metadata`, `workspace.close` |
 | Worktree | `worktree.list`, `worktree.create`, `worktree.open`, `worktree.remove` |
 | Tab | `tab.create`, `tab.list`, `tab.get`, `tab.focus`, `tab.rename`, `tab.move`, `tab.close` |
 | Pane | `pane.split`, `pane.swap`, `pane.move`, `pane.zoom`, `pane.layout`, `pane.process_info`, `pane.neighbor`, `pane.edges`, `pane.focus_direction`, `pane.resize`, `pane.list`, `pane.current`, `pane.get`, `pane.rename`, `pane.send_text`, `pane.send_keys`, `pane.send_input`, `pane.read`, `pane.graphics.info`, `pane.graphics.set`, `pane.graphics.clear`, `pane.graphics.stream`, `pane.report_agent`, `pane.report_agent_session`, `pane.report_metadata`, `pane.clear_agent_authority`, `pane.release_agent`, `pane.close`, `pane.wait_for_output` |
@@ -113,6 +113,8 @@ Raw socket method names use dot notation:
 
 `agent.wait` is server-owned and event-driven. It pins the resolved pane occupant so a replacement cannot satisfy the wait. `agent.prompt` accepts an optional `wait` object with `until` and `timeout_ms`; this submits the prompt and starts the wait in one request, avoiding a race between separate calls. If the resolved agent is already `blocked`, `agent.prompt` returns `agent_blocked` without sending input or starting the wait. `agent.type_submit` sends literal text plus Enter through the interactive agent UI path and is useful for harness commands that are not model prompts.
 
+`workspace.merge` moves every tab of `source_workspace_id` into `target_workspace_id` and then closes the emptied source; no tab is destroyed. A source workspace that owns linked worktree workspaces is refused with `workspace_group_merge_required` unless `merge_group` is `true`, the same explicit intent `workspace.close` requires for a group — with it, every group member's tabs move to the target and every member closes. Merging a workspace into itself, or into a member of its own worktree group, is refused. The response contains the target workspace.
+
 `workspace.move_block` atomically moves the ordered `workspace_ids` before `before_workspace_id`; omit the anchor to move the block to the end. The ids must be unique and the anchor cannot be part of the block. The response contains the authoritative ordered workspace list.
 
 `session.snapshot` returns a one-time bootstrap snapshot for clients that keep
diff --git a/docs/next/website/src/content/docs/zh-cn/cli-reference.mdx b/docs/next/website/src/content/docs/zh-cn/cli-reference.mdx
index 4bc3e290f9..981da6e129 100644
--- a/docs/next/website/src/content/docs/zh-cn/cli-reference.mdx
+++ b/docs/next/website/src/content/docs/zh-cn/cli-reference.mdx
@@ -117,6 +117,7 @@ herdr workspace focus <workspace_id>
 herdr workspace rename <workspace_id> <label>
 herdr workspace move <workspace_id> --index N
 herdr workspace report-metadata <workspace_id> --source ID [--token NAME=VALUE] [--clear-token NAME] [--seq N] [--ttl-ms N]
+herdr workspace merge <source_workspace_id> <target_workspace_id> [--group]
 herdr workspace close <workspace_id> [--group]
 ```
 
@@ -139,6 +140,8 @@ herdr worktree remove --workspace ID [--force] [--trust-repository]
 
 worktree 是带有 Git 检出来源信息的普通 Herdr 工作区。`worktree create` 创建一个 Git worktree 检出,作为工作区打开,并与父仓库工作区分到一组。如果 `--branch` 指向已有的本地分支,Herdr 检出它;否则从 `--base` 或 `HEAD` 创建分支。没有 `--path` 时,Herdr 在 `<worktrees.directory>/<repo>/<branch-slug>` 下创建检出。
 
+`workspace merge` 会将来源工作区的所有标签页移动到目标工作区，并关闭已清空的来源工作区；不会销毁任何标签页。当来源工作区拥有关联的 worktree 工作区时，它需要 `--group`（与 `workspace close` 要求的显式意图相同）；否则返回 `workspace_group_merge_required`。指定 `--group` 后，组内每个成员的标签页都会移动到目标工作区，并关闭每个成员。
+
 `workspace close` 只关闭 Herdr 状态。当关联的 worktree 工作区仍然打开时，关闭父工作区需要 `--group`；否则命令会保留整个组并返回 `workspace_group_close_required`。`worktree remove` 是显式的检出删除路径;它运行 `git worktree remove`,从不删除分支,并在 Git 拒绝脏检出时要求 `--force`。
 
 Git 默认拒绝由其他用户拥有的仓库。如果你已独立验证该仓库,可传入 `--trust-repository`,仅在本次命令中信任解析后的仓库路径。Herdr 不会修改你的 Git 配置。
diff --git a/docs/next/website/src/content/docs/zh-cn/socket-api.mdx b/docs/next/website/src/content/docs/zh-cn/socket-api.mdx
index d7d8e2bae9..daaa03303f 100644
--- a/docs/next/website/src/content/docs/zh-cn/socket-api.mdx
+++ b/docs/next/website/src/content/docs/zh-cn/socket-api.mdx
@@ -96,7 +96,7 @@ herdr pane read w1:p2 --source recent --lines 50
 | 通知 | `notification.show` |
 | 客户端 | `client.window_title.set`、`client.window_title.clear` |
 | 会话 | `session.snapshot` |
-| 工作区 | `workspace.create`、`workspace.list`、`workspace.get`、`workspace.focus`、`workspace.rename`、`workspace.move`、`workspace.move_block`、`workspace.report_metadata`、`workspace.close` |
+| 工作区 | `workspace.create`、`workspace.list`、`workspace.get`、`workspace.focus`、`workspace.rename`、`workspace.move`、`workspace.move_block`、`workspace.merge`、`workspace.report_metadata`、`workspace.close` |
 | Worktree | `worktree.list`、`worktree.create`、`worktree.open`、`worktree.remove` |
 | 标签页 | `tab.create`、`tab.list`、`tab.get`、`tab.focus`、`tab.rename`、`tab.move`、`tab.close` |
 | 窗格 | `pane.split`、`pane.swap`、`pane.move`、`pane.zoom`、`pane.layout`、`pane.process_info`、`pane.neighbor`、`pane.edges`、`pane.focus_direction`、`pane.resize`、`pane.list`、`pane.current`、`pane.get`、`pane.rename`、`pane.send_text`、`pane.send_keys`、`pane.send_input`、`pane.read`、`pane.graphics.info`、`pane.graphics.set`、`pane.graphics.clear`、`pane.graphics.stream`、`pane.report_agent`、`pane.report_agent_session`、`pane.report_metadata`、`pane.clear_agent_authority`、`pane.release_agent`、`pane.close`、`pane.wait_for_output` |
@@ -109,6 +109,8 @@ herdr pane read w1:p2 --source recent --lines 50
 
 `agent.wait` 由服务器拥有并由事件驱动。它会固定到已解析的窗格占用者,因此替换后的智能体不能满足该等待。`agent.prompt` 接受可选的 `wait` 对象,其中包含 `until` 和 `timeout_ms`;这样可在一个请求中提交提示并开始等待,避免两个独立调用之间的竞态。如果解析出的智能体已经是 `blocked`,`agent.prompt` 不会发送输入或开始等待,而是返回 `agent_blocked`。
 
+`workspace.merge` 会将 `source_workspace_id` 的所有标签页移动到 `target_workspace_id`，然后关闭已清空的来源工作区；不会销毁任何标签页。若来源工作区拥有链接的工作树工作区，则除非 `merge_group` 为 `true`，否则以 `workspace_group_merge_required` 拒绝——这与 `workspace.close` 对工作树组要求的显式意图相同；指定后，组内每个成员的标签页都会移动到目标工作区，并关闭每个成员。将工作区并入自身，或并入其自身工作树组的成员，都会被拒绝。响应包含目标工作区。
+
 `workspace.move_block` 会将有序的 `workspace_ids` 原子地移动到 `before_workspace_id` 之前;省略锚点则将该块移动到末尾。id 必须唯一,且锚点不能属于被移动的块。响应包含服务器确认的有序工作区列表。
 
 `session.snapshot` 为维护本地运行时缓存的客户端返回一次性引导快照。响应包含版本/协议元数据、当前聚焦的工作区/标签页/窗格 id、工作区记录、标签页记录、窗格记录、标签页布局快照和智能体记录。它不是订阅。为避免引导期间漏掉事件,应先在另一个连接上打开 `events.subscribe` 并等待确认,在调用 `session.snapshot` 时缓冲该事件流,然后安装快照、按顺序应用缓冲的事件并继续接收事件。重新连接后或本地缓存可能已过期时,再次调用 `session.snapshot`。工作区记录也包含关联 worktree 的来源信息。完整的仓库 worktree 发现仍使用 `worktree.list`。
diff --git a/docs/next/website/src/data/config-reference.json b/docs/next/website/src/data/config-reference.json
index 14fe530729..dcafbe60ef 100644
--- a/docs/next/website/src/data/config-reference.json
+++ b/docs/next/website/src/data/config-reference.json
@@ -649,6 +649,12 @@
           "default": "unset",
           "description": "Move the active tab to a new workspace. Unset by default."
         },
+        {
+          "key": "keys.merge_workspace",
+          "type": "keybinding",
+          "default": "unset",
+          "description": "Merge another workspace's tabs into a chosen workspace. Unset by default."
+        },
         {
           "key": "keys.previous_agent",
           "type": "keybinding",
diff --git a/src/api/schema.rs b/src/api/schema.rs
index d4ee46e275..6b7e917208 100644
--- a/src/api/schema.rs
+++ b/src/api/schema.rs
@@ -87,6 +87,8 @@ pub enum Method {
     WorkspaceMoveBlock(WorkspaceMoveBlockParams),
     #[serde(rename = "workspace.report_metadata")]
     WorkspaceReportMetadata(WorkspaceReportMetadataParams),
+    #[serde(rename = "workspace.merge")]
+    WorkspaceMerge(WorkspaceMergeParams),
     #[serde(rename = "workspace.close")]
     WorkspaceClose(WorkspaceCloseParams),
     #[serde(rename = "worktree.list")]
diff --git a/src/api/schema/tests.rs b/src/api/schema/tests.rs
index 79c15ecb9c..29ae8d8a68 100644
--- a/src/api/schema/tests.rs
+++ b/src/api/schema/tests.rs
@@ -1187,6 +1187,31 @@ fn authority_mutation_requests_round_trip() {
     let restored: Request = serde_json::from_value(json).unwrap();
     assert_eq!(restored, workspace_move_block);
 
+    let workspace_merge = Request {
+        id: "merge_ws".into(),
+        method: Method::WorkspaceMerge(crate::api::schema::WorkspaceMergeParams {
+            source_workspace_id: "w1".into(),
+            target_workspace_id: "w2".into(),
+            merge_group: true,
+        }),
+    };
+    let json = serde_json::to_value(&workspace_merge).unwrap();
+    assert_eq!(json["method"], "workspace.merge");
+    let restored: Request = serde_json::from_value(json).unwrap();
+    assert_eq!(restored, workspace_merge);
+    // The default omits the flag on the wire, so an explicit merge of a
+    // worktree group is never something a caller sends by accident.
+    let default_flag = serde_json::to_value(&Request {
+        id: "merge_ws_default".into(),
+        method: Method::WorkspaceMerge(crate::api::schema::WorkspaceMergeParams {
+            source_workspace_id: "w1".into(),
+            target_workspace_id: "w2".into(),
+            merge_group: false,
+        }),
+    })
+    .unwrap();
+    assert!(default_flag["params"].get("merge_group").is_none());
+
     let tab_move = Request {
         id: "move_tab".into(),
         method: Method::TabMove(TabMoveParams {
diff --git a/src/api/schema/workspaces.rs b/src/api/schema/workspaces.rs
index 1b7132c43b..0e014f36eb 100644
--- a/src/api/schema/workspaces.rs
+++ b/src/api/schema/workspaces.rs
@@ -26,6 +26,22 @@ pub struct WorkspaceCloseParams {
     pub close_group: bool,
 }
 
+/// Relocates every tab of `source_workspace_id` into `target_workspace_id` and
+/// then closes the emptied source.
+///
+/// `merge_group` is the same explicit-intent gate `workspace.close` carries: a
+/// source that owns linked worktree workspaces refuses without it, so merge
+/// cannot become a way around that control. With the flag the whole worktree
+/// group merges — every member's tabs move to the target, and every member
+/// closes. Merge never destroys a tab.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
+pub struct WorkspaceMergeParams {
+    pub source_workspace_id: String,
+    pub target_workspace_id: String,
+    #[serde(default, skip_serializing_if = "super::is_false")]
+    pub merge_group: bool,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
 pub struct WorkspaceRenameParams {
     pub workspace_id: String,
diff --git a/src/api/server.rs b/src/api/server.rs
index 0edaad9c8a..9536486a9e 100644
--- a/src/api/server.rs
+++ b/src/api/server.rs
@@ -395,6 +395,7 @@ pub(crate) fn api_method_name(method: &Method) -> &'static str {
         Method::WorkspaceMove(_) => "workspace.move",
         Method::WorkspaceMoveBlock(_) => "workspace.move_block",
         Method::WorkspaceReportMetadata(_) => "workspace.report_metadata",
+        Method::WorkspaceMerge(_) => "workspace.merge",
         Method::WorkspaceClose(_) => "workspace.close",
         Method::WorktreeList(_) => "worktree.list",
         Method::WorktreeCreate(_) => "worktree.create",
diff --git a/src/app/api.rs b/src/app/api.rs
index 5485de6d43..79a7f57b22 100644
--- a/src/app/api.rs
+++ b/src/app/api.rs
@@ -1008,6 +1008,9 @@ impl App {
             Method::WorkspaceReportMetadata(params) => {
                 return self.handle_workspace_report_metadata(request.id, params);
             }
+            Method::WorkspaceMerge(params) => {
+                return self.handle_workspace_merge(request.id, params);
+            }
             Method::WorkspaceClose(target) => {
                 return self.handle_workspace_close(request.id, target)
             }
diff --git a/src/app/api/tabs.rs b/src/app/api/tabs.rs
index 086c235613..aeab24df0b 100644
--- a/src/app/api/tabs.rs
+++ b/src/app/api/tabs.rs
@@ -428,7 +428,7 @@ impl App {
 
     /// Snapshots the public ids of every pane in a tab, before a move
     /// unregisters them from the source workspace's id space.
-    fn public_pane_ids_in_tab(
+    pub(super) fn public_pane_ids_in_tab(
         &self,
         ws_idx: usize,
         tab_idx: usize,
@@ -453,7 +453,7 @@ impl App {
 
     /// Keeps the moved panes' old public ids resolving after the workspace
     /// change, matching what `pane.move` does for a single pane.
-    fn alias_moved_pane_ids(&mut self, previous: Vec<(String, crate::layout::PaneId)>) {
+    pub(super) fn alias_moved_pane_ids(&mut self, previous: Vec<(String, crate::layout::PaneId)>) {
         for (previous_public_id, pane_id) in previous {
             self.state
                 .record_moved_pane_alias(previous_public_id, pane_id);
@@ -608,7 +608,7 @@ impl App {
         encode_success(id, ResponseResult::Ok {})
     }
 
-    fn tab_list_info(&self, ws_idx: usize) -> Vec<crate::api::schema::TabInfo> {
+    pub(super) fn tab_list_info(&self, ws_idx: usize) -> Vec<crate::api::schema::TabInfo> {
         self.state
             .workspaces
             .get(ws_idx)
diff --git a/src/app/api/workspaces.rs b/src/app/api/workspaces.rs
index 677b2f5158..7026b384c6 100644
--- a/src/app/api/workspaces.rs
+++ b/src/app/api/workspaces.rs
@@ -2,8 +2,8 @@ use std::path::PathBuf;
 
 use crate::api::schema::{
     EventData, EventEnvelope, EventKind, ResponseResult, WorkspaceCloseParams,
-    WorkspaceCreateParams, WorkspaceMoveBlockParams, WorkspaceMoveParams, WorkspaceRenameParams,
-    WorkspaceReportMetadataParams, WorkspaceTarget,
+    WorkspaceCreateParams, WorkspaceMergeParams, WorkspaceMoveBlockParams, WorkspaceMoveParams,
+    WorkspaceRenameParams, WorkspaceReportMetadataParams, WorkspaceTarget,
 };
 use crate::app::App;
 
@@ -311,6 +311,221 @@ impl App {
         encode_success(id, ResponseResult::Ok {})
     }
 
+    /// Relocates every tab of the source workspace into the target, then closes
+    /// the emptied source.
+    ///
+    /// The gate is `workspace.close`'s, unchanged: a source that owns linked
+    /// worktree workspaces refuses without explicit group intent. The socket is
+    /// reachable by every process running inside a pane — `HERDR_SOCKET_PATH` is
+    /// in their environment — so a merge without this gate would be a one-call
+    /// way around a control `workspace.close` enforces. A TUI confirmation is a
+    /// second layer over this one, never a substitute for it.
+    ///
+    /// With group intent the whole worktree group merges: every member's tabs
+    /// land in the target and every member closes, so merge never destroys a
+    /// tab the way a group close does.
+    pub(super) fn handle_workspace_merge(
+        &mut self,
+        id: String,
+        params: WorkspaceMergeParams,
+    ) -> String {
+        // `parse_workspace_id` falls back to positional parsing without bounds
+        // checking, so a bare numeric id yields an index past the end.
+        let Some(source_index) = self
+            .parse_workspace_id(&params.source_workspace_id)
+            .filter(|index| *index < self.state.workspaces.len())
+        else {
+            return workspace_not_found(id, &params.source_workspace_id);
+        };
+        let Some(target_index) = self
+            .parse_workspace_id(&params.target_workspace_id)
+            .filter(|index| *index < self.state.workspaces.len())
+        else {
+            return workspace_not_found(id, &params.target_workspace_id);
+        };
+        if source_index == target_index {
+            return encode_error(
+                id,
+                "workspace_merge_failed",
+                "source and target must be different workspaces",
+            );
+        }
+
+        let merge_indices = self.state.workspace_close_indices(source_index);
+        if merge_indices.len() >= 2 && !params.merge_group {
+            return encode_error(
+                id,
+                "workspace_group_merge_required",
+                "workspace has linked worktree workspaces; use --group (merge_group=true in the API) to merge the group",
+            );
+        }
+        if merge_indices.contains(&target_index) {
+            return encode_error(
+                id,
+                "workspace_merge_failed",
+                "target workspace belongs to the source's worktree group",
+            );
+        }
+
+        // Snapshot every closing workspace before its tabs leave: a drained
+        // workspace derefs through an active tab it no longer has.
+        let closed_workspaces = merge_indices
+            .iter()
+            .map(|index| {
+                (
+                    self.public_workspace_id(*index),
+                    self.workspace_info(*index),
+                )
+            })
+            .collect::<Vec<_>>();
+        // Follow the operator's own view by id, not by index. `workspace.close`
+        // sets `selected` to the closing workspace, which would yank the view
+        // to the target on every merge; restoring it keeps a merge of two
+        // background workspaces invisible to the operator.
+        let selected_workspace_id = self
+            .state
+            .workspaces
+            .get(self.state.selected)
+            .map(|workspace| workspace.id.clone());
+        let active_workspace_id = self
+            .state
+            .active
+            .and_then(|index| self.state.workspaces.get(index))
+            .map(|workspace| workspace.id.clone());
+        let target_workspace_key = self.state.workspaces[target_index].id.clone();
+
+        let mut moved_tabs = Vec::new();
+        for source_index in merge_indices.iter().copied() {
+            let source_workspace_id = self.public_workspace_id(source_index);
+            let tab_count = self.state.workspaces[source_index].tabs.len();
+            let previous_tab_ids = (0..tab_count)
+                .map(|tab_idx| {
+                    self.public_tab_id(source_index, tab_idx)
+                        .unwrap_or_else(|| {
+                            crate::workspace::public_tab_id_for_number(
+                                &self.state.workspaces[source_index].id,
+                                tab_idx + 1,
+                            )
+                        })
+                })
+                .collect::<Vec<_>>();
+            // Snapshot before the take: it unregisters these panes from the
+            // source's per-workspace public id space.
+            let previous_pane_ids = (0..tab_count)
+                .flat_map(|tab_idx| self.public_pane_ids_in_tab(source_index, tab_idx))
+                .collect::<Vec<_>>();
+
+            let taken = self.state.workspaces[source_index].take_all_tabs_for_move();
+            self.alias_moved_pane_ids(previous_pane_ids);
+            for (tab, previous_tab_id) in taken.into_iter().zip(previous_tab_ids) {
+                let insert_index = self.state.workspaces[target_index].tabs.len();
+                let target_tab_idx =
+                    self.state.workspaces[target_index].insert_moved_tab(tab, insert_index);
+                moved_tabs.push((previous_tab_id, source_workspace_id.clone(), target_tab_idx));
+            }
+        }
+
+        // Three records pair a pane with the workspace id it sat in:
+        // `previous_pane_focus`, a pane-targeted toast, and every pending agent
+        // notification. Their panes are alive in the target now, so leaving the
+        // source id in place would dangle each one at a workspace about to stop
+        // existing — `assert_invariants_for_test` catches exactly that.
+        let merged_workspace_keys = merge_indices
+            .iter()
+            .filter_map(|index| self.state.workspaces.get(*index))
+            .map(|workspace| workspace.id.clone())
+            .collect::<std::collections::HashSet<_>>();
+        if let Some(focus) = self.state.previous_pane_focus.as_mut() {
+            if merged_workspace_keys.contains(&focus.workspace_id) {
+                focus.workspace_id = target_workspace_key.clone();
+            }
+        }
+        if let Some(target) = self
+            .state
+            .toast
+            .as_mut()
+            .and_then(|toast| toast.target.as_mut())
+        {
+            if merged_workspace_keys.contains(&target.workspace_id) {
+                target.workspace_id = target_workspace_key.clone();
+            }
+        }
+        for notification in self.state.pending_agent_notifications.values_mut() {
+            if merged_workspace_keys.contains(&notification.workspace_id) {
+                notification.workspace_id = target_workspace_key.clone();
+            }
+        }
+
+        self.state.mark_session_dirty();
+        for index in merge_indices.iter().rev() {
+            if let Some(workspace) = self.state.workspaces.get(*index) {
+                crate::logging::workspace_closed(&workspace.id);
+            }
+            self.state.workspaces.remove(*index);
+        }
+        let target_index = self
+            .state
+            .workspaces
+            .iter()
+            .position(|workspace| workspace.id == target_workspace_key)
+            .unwrap_or(0);
+        self.state.selected = selected_workspace_id
+            .and_then(|id| {
+                self.state
+                    .workspaces
+                    .iter()
+                    .position(|workspace| workspace.id == id)
+            })
+            .unwrap_or(target_index);
+        if let Some(id) = active_workspace_id {
+            self.state.active = Some(
+                self.state
+                    .workspaces
+                    .iter()
+                    .position(|workspace| workspace.id == id)
+                    .unwrap_or(target_index),
+            );
+        }
+        self.schedule_session_save();
+
+        let target_workspace_id = self.public_workspace_id(target_index);
+        let tabs = self.tab_list_info(target_index);
+        for (previous_tab_id, source_workspace_id, target_tab_idx) in moved_tabs {
+            let Some(tab_id) = self.public_tab_id(target_index, target_tab_idx) else {
+                continue;
+            };
+            self.emit_event(EventEnvelope {
+                event: EventKind::TabMovedAcrossWorkspaces,
+                data: EventData::TabMovedAcrossWorkspaces {
+                    tab_id,
+                    previous_tab_id,
+                    workspace_id: target_workspace_id.clone(),
+                    source_workspace_id,
+                    insert_index: target_tab_idx,
+                    tabs: tabs.clone(),
+                    // The source is gone, so it has no remaining tabs to report.
+                    source_tabs: Vec::new(),
+                },
+            });
+        }
+        for (workspace_id, workspace) in closed_workspaces {
+            self.emit_event(EventEnvelope {
+                event: EventKind::WorkspaceClosed,
+                data: EventData::WorkspaceClosed {
+                    workspace_id,
+                    workspace: Some(workspace),
+                },
+            });
+        }
+
+        encode_success(
+            id,
+            ResponseResult::WorkspaceInfo {
+                workspace: self.workspace_info(target_index),
+            },
+        )
+    }
+
     pub(super) fn handle_workspace_close(
         &mut self,
         id: String,
@@ -757,6 +972,248 @@ mod tests {
         }));
     }
 
+    fn merge_test_app(labels: &[&str]) -> App {
+        let (_api_tx, api_rx) = tokio::sync::mpsc::unbounded_channel();
+        let mut app = App::new(
+            &Config::default(),
+            crate::app::AppPolicy::TEST,
+            None,
+            api_rx,
+            crate::api::EventHub::default(),
+        );
+        app.state.workspaces = labels
+            .iter()
+            .map(|label| Workspace::test_new(label))
+            .collect();
+        app.state.active = Some(0);
+        app.state.selected = 0;
+        app.state.ensure_test_terminals();
+        app
+    }
+
+    fn merge_request(app: &mut App, source: usize, target: usize, merge_group: bool) -> String {
+        let source_workspace_id = app.public_workspace_id(source);
+        let target_workspace_id = app.public_workspace_id(target);
+        app.handle_workspace_merge(
+            "req".into(),
+            WorkspaceMergeParams {
+                source_workspace_id,
+                target_workspace_id,
+                merge_group,
+            },
+        )
+    }
+
+    /// The socket is reachable from inside every pane, so this gate — not the
+    /// TUI confirmation — is what keeps merge from being a one-call way around
+    /// the explicit intent `workspace.close` requires for a worktree group.
+    #[test]
+    fn api_workspace_merge_group_source_requires_explicit_group_intent() {
+        let mut app = app_with_worktree_group();
+        app.state.workspaces.push(Workspace::test_new("target"));
+        app.state.ensure_test_terminals();
+        let workspace_ids = app
+            .state
+            .workspaces
+            .iter()
+            .map(|workspace| workspace.id.clone())
+            .collect::<Vec<_>>();
+
+        let response = merge_request(&mut app, 0, 2, false);
+
+        let error: ErrorResponse = serde_json::from_str(&response).unwrap();
+        assert_eq!(error.error.code, "workspace_group_merge_required");
+        assert_eq!(
+            app.state
+                .workspaces
+                .iter()
+                .map(|workspace| workspace.id.clone())
+                .collect::<Vec<_>>(),
+            workspace_ids
+        );
+        assert!(app.event_hub.events_after(0).is_empty());
+    }
+
+    #[test]
+    fn api_workspace_merge_group_proceeds_with_explicit_group_intent() {
+        let mut app = app_with_worktree_group();
+        app.state.workspaces.push(Workspace::test_new("target"));
+        app.state.ensure_test_terminals();
+        let target_id = app.state.workspaces[2].id.clone();
+
+        let response = merge_request(&mut app, 0, 2, true);
+
+        let _: SuccessResponse = serde_json::from_str(&response).unwrap();
+        assert_eq!(app.state.workspaces.len(), 1);
+        assert_eq!(app.state.workspaces[0].id, target_id);
+        // Merge relocates tabs rather than destroying them: the target keeps
+        // its own tab plus one from each merged group member.
+        assert_eq!(app.state.workspaces[0].tabs.len(), 3);
+        app.state.assert_invariants_for_test();
+    }
+
+    #[test]
+    fn api_workspace_merge_moves_every_tab_in_order_and_closes_the_source() {
+        let mut app = merge_test_app(&["source", "target"]);
+        app.state.workspaces[0].test_add_tab(Some("two"));
+        app.state.workspaces[0].test_add_tab(Some("three"));
+        app.state.ensure_test_terminals();
+        let source_id = app.state.workspaces[0].id.clone();
+        let source_root_panes = app.state.workspaces[0]
+            .tabs
+            .iter()
+            .map(|tab| tab.root_pane)
+            .collect::<Vec<_>>();
+        assert_eq!(source_root_panes.len(), 3);
+        let target_root_pane = app.state.workspaces[1].tabs[0].root_pane;
+
+        let response = merge_request(&mut app, 0, 1, false);
+
+        let success: SuccessResponse = serde_json::from_str(&response).unwrap();
+        let ResponseResult::WorkspaceInfo { workspace } = success.result else {
+            panic!("expected the merged target workspace");
+        };
+        assert_eq!(app.state.workspaces.len(), 1);
+        assert!(
+            !app.state
+                .workspaces
+                .iter()
+                .any(|candidate| candidate.id == source_id),
+            "merged source workspace should be gone"
+        );
+        assert_eq!(workspace.workspace_id, app.public_workspace_id(0));
+        let merged_root_panes = app.state.workspaces[0]
+            .tabs
+            .iter()
+            .map(|tab| tab.root_pane)
+            .collect::<Vec<_>>();
+        let mut expected = vec![target_root_pane];
+        expected.extend(source_root_panes);
+        assert_eq!(merged_root_panes, expected);
+        app.state.assert_invariants_for_test();
+    }
+
+    #[test]
+    fn api_workspace_merge_keeps_the_operators_selected_workspace() {
+        let mut app = merge_test_app(&["source", "target", "watching"]);
+        app.state.selected = 2;
+        app.state.active = Some(2);
+        let watched_id = app.state.workspaces[2].id.clone();
+
+        let response = merge_request(&mut app, 0, 1, false);
+
+        let _: SuccessResponse = serde_json::from_str(&response).unwrap();
+        assert_eq!(app.state.workspaces[app.state.selected].id, watched_id);
+        assert_eq!(
+            app.state
+                .active
+                .map(|index| app.state.workspaces[index].id.clone()),
+            Some(watched_id)
+        );
+        app.state.assert_invariants_for_test();
+    }
+
+    /// Three records name a pane's workspace by id. The panes survive a merge,
+    /// so a record left pointing at the closed source is dangling — and nothing
+    /// in the response says so.
+    #[test]
+    fn api_workspace_merge_repoints_pane_records_off_the_closed_source() {
+        let mut app = merge_test_app(&["source", "target"]);
+        let source_key = app.state.workspaces[0].id.clone();
+        let target_key = app.state.workspaces[1].id.clone();
+        let source_pane = app.state.workspaces[0].tabs[0].root_pane;
+        app.state.previous_pane_focus = Some(crate::app::state::PaneFocusTarget {
+            workspace_id: source_key.clone(),
+            pane_id: source_pane,
+        });
+        app.state.toast = Some(crate::app::state::ToastNotification {
+            kind: crate::app::state::ToastKind::NeedsAttention,
+            title: "waiting".into(),
+            context: String::new(),
+            position: None,
+            target: Some(crate::app::state::ToastTarget {
+                workspace_id: source_key.clone(),
+                pane_id: source_pane,
+            }),
+        });
+        app.state.pending_agent_notifications.insert(
+            source_pane,
+            crate::app::state::PendingAgentNotification {
+                pane_id: source_pane,
+                workspace_id: source_key.clone(),
+                agent_label: "agent".into(),
+                known_agent: None,
+                kind: crate::app::state::ToastKind::NeedsAttention,
+                state: crate::detect::AgentState::Blocked,
+                deadline: std::time::Instant::now(),
+            },
+        );
+
+        let response = merge_request(&mut app, 0, 1, false);
+
+        let _: SuccessResponse = serde_json::from_str(&response).unwrap();
+        assert_eq!(
+            app.state
+                .previous_pane_focus
+                .as_ref()
+                .map(|focus| focus.workspace_id.clone()),
+            Some(target_key.clone())
+        );
+        assert_eq!(
+            app.state
+                .toast
+                .as_ref()
+                .and_then(|toast| toast.target.as_ref())
+                .map(|target| target.workspace_id.clone()),
+            Some(target_key.clone())
+        );
+        assert_eq!(
+            app.state.pending_agent_notifications[&source_pane].workspace_id,
+            target_key
+        );
+        app.state.assert_invariants_for_test();
+    }
+
+    #[test]
+    fn api_workspace_merge_refuses_a_workspace_into_itself() {
+        let mut app = merge_test_app(&["only", "other"]);
+        let workspace_id = app.public_workspace_id(0);
+
+        let response = app.handle_workspace_merge(
+            "req".into(),
+            WorkspaceMergeParams {
+                source_workspace_id: workspace_id.clone(),
+                target_workspace_id: workspace_id,
+                merge_group: false,
+            },
+        );
+
+        let error: ErrorResponse = serde_json::from_str(&response).unwrap();
+        assert_eq!(error.error.code, "workspace_merge_failed");
+        // Assert the reason, not just the refusal: every other guard here
+        // returns the same code, so a code-only assertion passes even when the
+        // self-merge check is gone.
+        assert!(
+            error.error.message.contains("different workspaces"),
+            "unexpected refusal reason: {}",
+            error.error.message
+        );
+        assert_eq!(app.state.workspaces.len(), 2);
+        assert!(app.event_hub.events_after(0).is_empty());
+    }
+
+    #[test]
+    fn api_workspace_merge_refuses_a_target_inside_the_source_group() {
+        let mut app = app_with_worktree_group();
+        app.state.ensure_test_terminals();
+
+        let response = merge_request(&mut app, 0, 1, true);
+
+        let error: ErrorResponse = serde_json::from_str(&response).unwrap();
+        assert_eq!(error.error.code, "workspace_merge_failed");
+        assert_eq!(app.state.workspaces.len(), 2);
+    }
+
     #[test]
     fn workspace_metadata_tokens_patch_clear_and_emit_snapshot() {
         let event_hub = crate::api::EventHub::default();
diff --git a/src/cli/runtime.rs b/src/cli/runtime.rs
index fd3fc3a52e..420468277a 100644
--- a/src/cli/runtime.rs
+++ b/src/cli/runtime.rs
@@ -47,6 +47,12 @@ pub(super) fn workspace_move(params: WorkspaceMoveParams) -> std::io::Result<i32
     print_method_response("cli:workspace:move", Method::WorkspaceMove(params))
 }
 
+pub(super) fn workspace_merge(
+    params: crate::api::schema::WorkspaceMergeParams,
+) -> std::io::Result<i32> {
+    print_method_response("cli:workspace:merge", Method::WorkspaceMerge(params))
+}
+
 pub(super) fn workspace_close(params: WorkspaceCloseParams) -> std::io::Result<i32> {
     print_method_response("cli:workspace:close", Method::WorkspaceClose(params))
 }
diff --git a/src/cli/spec.rs b/src/cli/spec.rs
index 2cc73efeed..9d9050d790 100644
--- a/src/cli/spec.rs
+++ b/src/cli/spec.rs
@@ -263,6 +263,13 @@ fn workspace_command() -> Command {
                 .arg(option("seq", "N"))
                 .arg(option("ttl-ms", "N")),
         )
+        .subcommand(
+            Command::new("merge")
+                .about("Move every tab of one workspace into another and close the source")
+                .arg(required("source_workspace_id", "SOURCE_WORKSPACE_ID"))
+                .arg(required("target_workspace_id", "TARGET_WORKSPACE_ID"))
+                .arg(flag("group")),
+        )
         .subcommand(id_command("close", "workspace_id", "Close a workspace"))
 }
 
diff --git a/src/cli/workspace.rs b/src/cli/workspace.rs
index d7ef6723c0..4a83f65154 100644
--- a/src/cli/workspace.rs
+++ b/src/cli/workspace.rs
@@ -19,6 +19,7 @@ pub(super) fn run_workspace_command(args: &[String]) -> std::io::Result<i32> {
         "rename" => workspace_rename(&args[1..]),
         "move" => workspace_move(&args[1..]),
         "report-metadata" => workspace_report_metadata(&args[1..]),
+        "merge" => workspace_merge(&args[1..]),
         "close" => workspace_close(&args[1..]),
         "help" | "--help" | "-h" => {
             print_workspace_help();
@@ -273,6 +274,30 @@ fn workspace_report_metadata(args: &[String]) -> std::io::Result<i32> {
     ))
 }
 
+/// `--group` is the same explicit intent `workspace close --group` requires. A
+/// source workspace with linked worktree workspaces refuses without it, so a
+/// merge cannot quietly do what a close would have asked about.
+fn workspace_merge(args: &[String]) -> std::io::Result<i32> {
+    let (raw_source_id, raw_target_id, merge_group) = match args {
+        [source, target] => (source, target, false),
+        [source, target, flag] if flag == "--group" => (source, target, true),
+        _ => {
+            eprintln!("{}", workspace_merge_usage());
+            return Ok(2);
+        }
+    };
+
+    super::runtime::workspace_merge(crate::api::schema::WorkspaceMergeParams {
+        source_workspace_id: super::normalize_workspace_id(raw_source_id),
+        target_workspace_id: super::normalize_workspace_id(raw_target_id),
+        merge_group,
+    })
+}
+
+fn workspace_merge_usage() -> String {
+    "usage: herdr workspace merge <source_workspace_id> <target_workspace_id> [--group]".into()
+}
+
 fn workspace_close(args: &[String]) -> std::io::Result<i32> {
     let (raw_workspace_id, close_group) = match args {
         [workspace_id] => (workspace_id, false),
@@ -298,5 +323,6 @@ fn print_workspace_help() {
     eprintln!("  herdr workspace rename <workspace_id> <label>");
     eprintln!("  herdr workspace move <workspace_id> --index N");
     eprintln!("  herdr workspace report-metadata <workspace_id> --source ID [--token NAME=VALUE] [--clear-token NAME] [--seq N] [--ttl-ms N]");
+    eprintln!("  herdr workspace merge <source_workspace_id> <target_workspace_id> [--group]");
     eprintln!("  herdr workspace close <workspace_id> [--group]");
 }
diff --git a/src/client/shell/actions.rs b/src/client/shell/actions.rs
index 37ad219ace..4aa45c1ba8 100644
--- a/src/client/shell/actions.rs
+++ b/src/client/shell/actions.rs
@@ -81,6 +81,13 @@ impl ClientShellState {
                     }
                     return;
                 }
+                if action == crate::input::KeybindAction::MergeWorkspace {
+                    if let Some(workspace_id) = self.workspace_action_id() {
+                        self.open_navigator_overlay_for_merge(workspace_id);
+                        outcome.repaint = true;
+                    }
+                    return;
+                }
                 if action == crate::input::KeybindAction::Help {
                     self.overlay = Some(ClientShellOverlay::Help(ClientHelpOverlay {
                         query: String::new(),
diff --git a/src/client/shell/mouse.rs b/src/client/shell/mouse.rs
index 5c2c9b2665..80284e0ed8 100644
--- a/src/client/shell/mouse.rs
+++ b/src/client/shell/mouse.rs
@@ -1863,6 +1863,9 @@ impl ClientShellState {
             if super::contains(self.hits.overlay_primary, point) {
                 match self.overlay.as_ref() {
                     Some(ClientShellOverlay::Rename(_)) => self.save_rename_overlay(outcome),
+                    Some(ClientShellOverlay::ConfirmMerge(_)) => {
+                        self.confirm_pending_merge(outcome);
+                    }
                     Some(ClientShellOverlay::ConfirmClose(_)) => {
                         let Some(ClientShellOverlay::ConfirmClose(confirm)) = self.overlay.take()
                         else {
diff --git a/src/client/shell/overlay_input.rs b/src/client/shell/overlay_input.rs
index 0284032d47..321275d97e 100644
--- a/src/client/shell/overlay_input.rs
+++ b/src/client/shell/overlay_input.rs
@@ -201,6 +201,22 @@ impl ClientShellState {
         &mut self,
         pending_pane_move: Option<String>,
         pending_tab_move: Option<String>,
+    ) {
+        self.open_navigator_overlay_armed(pending_pane_move, pending_tab_move, None);
+    }
+
+    /// Opens the navigator to pick the workspace that absorbs `source`'s tabs.
+    /// Accepting a workspace row raises the confirmation dialog rather than
+    /// merging straight away.
+    pub(super) fn open_navigator_overlay_for_merge(&mut self, source_workspace_id: String) {
+        self.open_navigator_overlay_armed(None, None, Some(source_workspace_id));
+    }
+
+    fn open_navigator_overlay_armed(
+        &mut self,
+        pending_pane_move: Option<String>,
+        pending_tab_move: Option<String>,
+        pending_workspace_merge: Option<String>,
     ) {
         let Some(snapshot) = self.snapshot.as_deref() else {
             return;
@@ -219,6 +235,7 @@ impl ClientShellState {
             expanded_workspaces,
             pending_pane_move,
             pending_tab_move,
+            pending_workspace_merge,
         };
         let rows = render::client_navigator_rows(snapshot, &navigator);
         navigator.selected = rows.iter().position(|row| row.current).unwrap_or(0);
@@ -703,19 +720,30 @@ impl ClientShellState {
             Some(ClientShellOverlay::Navigator(navigator)) => (
                 navigator.pending_pane_move.clone(),
                 navigator.pending_tab_move.clone(),
+                navigator.pending_workspace_merge.clone(),
             ),
-            _ => (None, None),
+            _ => (None, None, None),
         };
         match pending {
-            (_, Some(tab_id)) => {
+            (_, _, Some(source_workspace_id)) => {
+                // A row that resolves to no workspace leaves the merge armed,
+                // the way a mis-aimed enter does for the move pickers.
+                if let Some(target_workspace_id) = self.navigator_row_workspace(&target) {
+                    if self.open_confirm_merge_overlay(source_workspace_id, target_workspace_id) {
+                        outcome.repaint = true;
+                    }
+                }
+                return;
+            }
+            (_, Some(tab_id), None) => {
                 self.complete_pending_tab_move(tab_id, target, outcome);
                 return;
             }
-            (Some(pane_id), None) => {
+            (Some(pane_id), None, None) => {
                 self.complete_pending_pane_move(pane_id, target, outcome);
                 return;
             }
-            (None, None) => {}
+            (None, None, None) => {}
         }
         self.overlay = None;
         let method = match target {
@@ -1368,6 +1396,16 @@ impl ClientShellState {
             return;
         }
 
+        if matches!(self.overlay, Some(ClientShellOverlay::ConfirmMerge(_))) {
+            if key.code == KeyCode::Enter {
+                self.confirm_pending_merge(outcome);
+            } else if key.code == KeyCode::Esc {
+                self.overlay = None;
+                outcome.repaint = true;
+            }
+            return;
+        }
+
         if matches!(self.overlay, Some(ClientShellOverlay::ConfirmClose(_))) {
             if key.code == KeyCode::Enter {
                 let Some(ClientShellOverlay::ConfirmClose(confirm)) = self.overlay.take() else {
@@ -1521,6 +1559,113 @@ impl ClientShellState {
         outcome.repaint = true;
     }
 
+    /// Raises the merge confirmation for a picked target.
+    ///
+    /// `merge_group` mirrors what the server will be told, and it is derived
+    /// from the same fact the server checks — the source owning linked worktree
+    /// workspaces — so the dialog names the real scope. The server refuses the
+    /// group merge on its own if this client ever gets that wrong.
+    fn open_confirm_merge_overlay(
+        &mut self,
+        source_workspace_id: String,
+        target_workspace_id: String,
+    ) -> bool {
+        let Some(snapshot) = self.snapshot.as_deref() else {
+            return false;
+        };
+        let Some(source) = snapshot
+            .workspaces
+            .iter()
+            .find(|workspace| workspace.workspace_id == source_workspace_id)
+        else {
+            return false;
+        };
+        let Some(target) = snapshot
+            .workspaces
+            .iter()
+            .find(|workspace| workspace.workspace_id == target_workspace_id)
+        else {
+            return false;
+        };
+        // The source's own row is a legal thing to land on and a nonsense
+        // destination; the server refuses it either way, so leave the picker
+        // armed rather than confirming a merge that cannot happen.
+        if source_workspace_id == target_workspace_id {
+            return false;
+        }
+        let group_key = source
+            .worktree
+            .as_ref()
+            .filter(|worktree| !worktree.is_linked_worktree)
+            .map(|worktree| worktree.key.as_str());
+        let group = group_key
+            .map(|key| {
+                snapshot
+                    .workspaces
+                    .iter()
+                    .filter(|member| {
+                        member
+                            .worktree
+                            .as_ref()
+                            .is_some_and(|worktree| worktree.key == key)
+                    })
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_else(|| vec![source]);
+        let merge_group = group.len() > 1;
+        let tab_count = group
+            .iter()
+            .map(|member| {
+                snapshot
+                    .tabs
+                    .iter()
+                    .filter(|tab| tab.workspace_id == member.workspace_id)
+                    .count()
+            })
+            .sum::<usize>();
+        let tabs = if tab_count == 1 {
+            "1 tab".to_owned()
+        } else {
+            format!("{tab_count} tabs")
+        };
+        let scope = if merge_group {
+            format!("{} workspaces, {tabs}", group.len())
+        } else {
+            tabs
+        };
+        self.overlay = Some(ClientShellOverlay::ConfirmMerge(
+            ClientConfirmMergeOverlay {
+                source_workspace_id,
+                target_workspace_id,
+                merge_group,
+                title: if merge_group {
+                    "Merge worktree group into workspace?".to_owned()
+                } else {
+                    "Merge workspace?".to_owned()
+                },
+                detail: format!("{} — {scope} → {}", source.label, target.label),
+            },
+        ));
+        true
+    }
+
+    /// Sends the confirmed merge. Shared by the key and mouse paths so the
+    /// button and the Enter key cannot drift apart.
+    pub(super) fn confirm_pending_merge(&mut self, outcome: &mut ClientShellInput) {
+        let Some(ClientShellOverlay::ConfirmMerge(confirm)) = self.overlay.take() else {
+            return;
+        };
+        self.push_endpoint_method(
+            crate::api::schema::Method::WorkspaceMerge(crate::api::schema::WorkspaceMergeParams {
+                source_workspace_id: confirm.source_workspace_id,
+                target_workspace_id: confirm.target_workspace_id,
+                merge_group: confirm.merge_group,
+            }),
+            outcome,
+        );
+        outcome.repaint = true;
+    }
+
     pub(super) fn open_confirm_close_overlay(&mut self, workspace_id: String) {
         let Some(snapshot) = self.snapshot.as_deref() else {
             return;
diff --git a/src/client/shell/overlays.rs b/src/client/shell/overlays.rs
index d49c6b35f6..25a336747f 100644
--- a/src/client/shell/overlays.rs
+++ b/src/client/shell/overlays.rs
@@ -63,6 +63,7 @@ pub(crate) fn render_client_overlay(
         }
         ClientShellOverlay::Rename(v) => render_rename_overlay(b, v, p),
         ClientShellOverlay::ConfirmClose(v) => render_confirm_close_overlay(b, v, p),
+        ClientShellOverlay::ConfirmMerge(v) => render_confirm_merge_overlay(b, v, p),
         ClientShellOverlay::Help(v) => render_help_overlay(b, v, k, p),
         ClientShellOverlay::Navigator(v) => render_navigator_overlay(b, v, s, p),
         ClientShellOverlay::Palette(v) => render_palette_overlay(b, v, s, k, p),
@@ -892,7 +893,12 @@ fn render_navigator_overlay(
         // While armed, the row's own identity matters less than what accepting
         // it does, and nothing else on screen says which destination a depth
         // implies.
-        let detail = if n.pending_tab_move.is_some() {
+        let detail = if n.pending_workspace_merge.is_some() {
+            match r.target {
+                ClientNavigatorTarget::NewWorkspace => " pick an existing space".to_owned(),
+                _ => " merges this space into here".to_owned(),
+            }
+        } else if n.pending_tab_move.is_some() {
             match r.target {
                 ClientNavigatorTarget::NewWorkspace => " moves this tab to a new space".to_owned(),
                 _ => " moves this tab here".to_owned(),
@@ -1369,10 +1375,32 @@ fn render_help_overlay(
         ..OverlayRender::default()
     })
 }
+/// The merge confirmation, shaped like the close confirmation because it has
+/// the same consequence — a workspace stops existing. Both call
+/// `render_confirm_overlay`, whose returned `primary`/`cancel` rects are the
+/// ones the hit map stores, so the button the operator sees and the button a
+/// click resolves to cannot disagree.
+fn render_confirm_merge_overlay(
+    b: &mut Buffer,
+    c: &ClientConfirmMergeOverlay,
+    p: &Palette,
+) -> Option<OverlayRender> {
+    render_confirm_overlay(b, &c.title, &c.detail, p)
+}
+
 fn render_confirm_close_overlay(
     b: &mut Buffer,
     c: &ClientConfirmCloseOverlay,
     p: &Palette,
+) -> Option<OverlayRender> {
+    render_confirm_overlay(b, &c.title, &c.detail, p)
+}
+
+fn render_confirm_overlay(
+    b: &mut Buffer,
+    title: &str,
+    detail: &str,
+    p: &Palette,
 ) -> Option<OverlayRender> {
     let q = popup(b.area, 64, 6)?;
     let i = panel(b, q, p.red, p.panel_bg)?;
@@ -1381,7 +1409,7 @@ fn render_confirm_close_overlay(
         i.x,
         i.y,
         i.width,
-        &format!(" {}", c.title),
+        &format!(" {title}"),
         Style::default()
             .fg(p.red)
             .bg(p.panel_bg)
@@ -1392,7 +1420,7 @@ fn render_confirm_close_overlay(
         i.x,
         i.y + 1,
         i.width,
-        &format!(" {}", c.detail),
+        &format!(" {detail}"),
         Style::default().fg(p.text).bg(p.panel_bg),
     );
     let rs = row(i, &[13, 12], 2, 3);
diff --git a/src/client/shell/palette.rs b/src/client/shell/palette.rs
index d4018eebf3..bd1f0b87c5 100644
--- a/src/client/shell/palette.rs
+++ b/src/client/shell/palette.rs
@@ -570,6 +570,25 @@ mod tests {
         );
     }
 
+    #[test]
+    fn merge_workspace_command_reaches_the_palette() {
+        let snapshot = super::super::tests::snapshot();
+        let commands = palette_commands(&keybinds(), &no_plugins(), &snapshot);
+
+        let merge = commands
+            .iter()
+            .find(|command| command.action == PaletteAction::Keybind(KeybindAction::MergeWorkspace))
+            .expect("merge workspace is missing from the palette");
+        // Unbound by default, so the palette is the only way to reach it.
+        assert!(
+            merge
+                .keywords
+                .iter()
+                .any(|keyword| keyword.contains("combine")),
+            "merge workspace should be findable by combine vocabulary"
+        );
+    }
+
     // The context menu and the sidebar say "move pane"; the API says "swap".
     // Without the keyword bridge the palette answers nothing to the wording a
     // user arrives with.
diff --git a/src/client/shell/state.rs b/src/client/shell/state.rs
index b1ab1ed5c6..071bd67419 100644
--- a/src/client/shell/state.rs
+++ b/src/client/shell/state.rs
@@ -347,6 +347,7 @@ pub(super) enum ClientShellOverlayKind {
     ReleaseNotes,
     Rename,
     ConfirmClose,
+    ConfirmMerge,
     Help,
     Navigator,
     WorktreeCreate,
@@ -432,6 +433,11 @@ pub(super) struct ClientNavigatorOverlay {
     /// While set, accepting a navigator row moves that whole tab instead of
     /// focusing it. Mutually exclusive with `pending_pane_move`.
     pub(super) pending_tab_move: Option<String>,
+    /// While set, accepting a navigator workspace row merges this workspace
+    /// into the picked one. Mutually exclusive with both move fields, and it
+    /// does not arm the destination-only "new space" row: merging into a
+    /// workspace that has just been created is a rename, not a merge.
+    pub(super) pending_workspace_merge: Option<String>,
 }
 
 impl ClientNavigatorOverlay {
@@ -668,6 +674,18 @@ pub(super) struct ClientContextMenuItem {
     pub(super) action: ClientContextMenuAction,
 }
 
+/// The second layer over `workspace.merge`'s own explicit-intent gate. The
+/// server refuses a worktree-group merge without `merge_group` whatever the
+/// client does, so this dialog buys deliberation, never authority.
+#[derive(Debug)]
+pub(super) struct ClientConfirmMergeOverlay {
+    pub(super) source_workspace_id: String,
+    pub(super) target_workspace_id: String,
+    pub(super) merge_group: bool,
+    pub(super) title: String,
+    pub(super) detail: String,
+}
+
 #[derive(Debug)]
 pub(super) struct ClientConfirmCloseOverlay {
     pub(super) workspace_id: String,
@@ -682,6 +700,7 @@ pub(super) enum ClientShellOverlay {
     ReleaseNotes(crate::app::state::ReleaseNotesState),
     Rename(ClientRenameOverlay),
     ConfirmClose(ClientConfirmCloseOverlay),
+    ConfirmMerge(ClientConfirmMergeOverlay),
     Help(ClientHelpOverlay),
     Navigator(ClientNavigatorOverlay),
     WorktreeCreate(ClientWorktreeCreateOverlay),
@@ -702,6 +721,7 @@ impl ClientShellOverlay {
             Self::ReleaseNotes(_) => ClientShellOverlayKind::ReleaseNotes,
             Self::Rename(_) => ClientShellOverlayKind::Rename,
             Self::ConfirmClose(_) => ClientShellOverlayKind::ConfirmClose,
+            Self::ConfirmMerge(_) => ClientShellOverlayKind::ConfirmMerge,
             Self::Help(_) => ClientShellOverlayKind::Help,
             Self::Navigator(_) => ClientShellOverlayKind::Navigator,
             Self::WorktreeCreate(_) => ClientShellOverlayKind::WorktreeCreate,
@@ -1823,6 +1843,7 @@ impl ClientShellState {
             return matches!(
                 overlay,
                 ClientShellOverlay::ConfirmClose(_)
+                    | ClientShellOverlay::ConfirmMerge(_)
                     | ClientShellOverlay::Help(_)
                     | ClientShellOverlay::Navigator(_)
                     | ClientShellOverlay::WorktreeRemove(_)
diff --git a/src/client/shell/tests/palette.rs b/src/client/shell/tests/palette.rs
index 6cfd88ddbc..5053094c81 100644
--- a/src/client/shell/tests/palette.rs
+++ b/src/client/shell/tests/palette.rs
@@ -386,3 +386,186 @@ fn the_split_buttons_are_hit_where_the_renderer_drew_them() {
         "clicking vertical splits right"
     );
 }
+
+/// Two workspaces, so a merge has somewhere to land.
+fn shell_with_second_workspace() -> ClientShellState {
+    let mut snapshot = snapshot();
+    let mut second = snapshot.workspaces[0].clone();
+    second.workspace_id = "ws_2".into();
+    second.number = 2;
+    second.label = "second".into();
+    second.focused = false;
+    second.active_tab_id = "tab_2".into();
+    snapshot.workspaces.push(second);
+    let mut tab = snapshot.tabs[0].clone();
+    tab.tab_id = "tab_2".into();
+    tab.workspace_id = "ws_2".into();
+    tab.number = 1;
+    tab.focused = false;
+    snapshot.tabs.push(tab);
+    let mut state = ClientShellState::new(ClientShellConfig::from_config(&Config::default()));
+    state.set_snapshot(Box::new(snapshot));
+    state.set_pane_surface(surface());
+    state.compose(106, 24).expect("composed frame");
+    state
+}
+
+fn arm_merge_on_the_second_workspace(state: &mut ClientShellState) {
+    state.open_navigator_overlay_for_merge("ws_1".into());
+    state.compose(106, 24).expect("composed frame");
+    let rows = render::client_navigator_rows(
+        state.snapshot.as_deref().expect("snapshot"),
+        match state.overlay.as_ref() {
+            Some(ClientShellOverlay::Navigator(navigator)) => navigator,
+            _ => panic!("navigator should be open"),
+        },
+    );
+    let target_row = rows
+        .iter()
+        .position(|row| matches!(&row.target, ClientNavigatorTarget::Workspace(id) if id == "ws_2"))
+        .expect("a row for the other workspace");
+    if let Some(ClientShellOverlay::Navigator(navigator)) = state.overlay.as_mut() {
+        navigator.selected = target_row;
+    }
+}
+
+#[test]
+fn the_merge_action_arms_the_navigator_and_a_workspace_row_asks_first() {
+    let mut state = shell_with_second_workspace();
+    let mut outcome = ClientShellInput::default();
+    state.record_binding(
+        crate::input::KeybindMatch::Action(crate::input::KeybindAction::MergeWorkspace),
+        &mut outcome,
+    );
+    let Some(ClientShellOverlay::Navigator(navigator)) = state.overlay.as_ref() else {
+        panic!("merge should open the navigator as a destination picker");
+    };
+    assert_eq!(navigator.pending_workspace_merge.as_deref(), Some("ws_1"));
+    // Merging into a workspace created for the merge is a rename, not a merge,
+    // so the destination-only new-space row stays off.
+    assert!(!navigator.move_armed());
+
+    arm_merge_on_the_second_workspace(&mut state);
+    let mut accept = ClientShellInput::default();
+    state.accept_navigator_selection(&mut accept);
+    assert!(
+        matches!(state.overlay, Some(ClientShellOverlay::ConfirmMerge(_))),
+        "a merge destination is confirmed before anything moves"
+    );
+    assert!(
+        endpoint_methods(&accept).is_empty(),
+        "picking the destination must not merge on its own"
+    );
+}
+
+#[test]
+fn picking_the_source_row_leaves_the_merge_armed() {
+    let mut state = shell_with_second_workspace();
+    state.open_navigator_overlay_for_merge("ws_1".into());
+    state.compose(106, 24).expect("composed frame");
+    let rows = render::client_navigator_rows(
+        state.snapshot.as_deref().expect("snapshot"),
+        match state.overlay.as_ref() {
+            Some(ClientShellOverlay::Navigator(navigator)) => navigator,
+            _ => panic!("navigator should be open"),
+        },
+    );
+    let own_row = rows
+        .iter()
+        .position(|row| matches!(&row.target, ClientNavigatorTarget::Workspace(id) if id == "ws_1"))
+        .expect("a row for the armed workspace");
+    if let Some(ClientShellOverlay::Navigator(navigator)) = state.overlay.as_mut() {
+        navigator.selected = own_row;
+    }
+
+    let mut outcome = ClientShellInput::default();
+    state.accept_navigator_selection(&mut outcome);
+    assert!(
+        matches!(state.overlay, Some(ClientShellOverlay::Navigator(_))),
+        "a workspace cannot merge into itself, so the picker stays armed"
+    );
+    assert!(endpoint_methods(&outcome).is_empty());
+}
+
+#[test]
+fn confirming_the_merge_sends_workspace_merge_for_the_picked_target() {
+    let mut state = shell_with_second_workspace();
+    arm_merge_on_the_second_workspace(&mut state);
+    let mut accept = ClientShellInput::default();
+    state.accept_navigator_selection(&mut accept);
+
+    let confirmed = press(&mut state, KeyCode::Enter);
+    assert!(state.overlay.is_none());
+    assert!(
+        endpoint_methods(&confirmed).iter().any(|method| matches!(
+            method,
+            crate::api::schema::Method::WorkspaceMerge(params)
+                if params.source_workspace_id == "ws_1"
+                    && params.target_workspace_id == "ws_2"
+                    // No worktree group here, so the client asks for no group
+                    // intent. The server refuses on its own if it disagrees.
+                    && !params.merge_group
+        )),
+        "confirming merges the armed source into the picked target"
+    );
+}
+
+#[test]
+fn the_merge_confirmation_captures_every_mouse_event_aimed_past_it() {
+    let mut state = shell_with_second_workspace();
+    arm_merge_on_the_second_workspace(&mut state);
+    let mut accept = ClientShellInput::default();
+    state.accept_navigator_selection(&mut accept);
+    state.compose(106, 24).expect("composed frame");
+    let scroll_before = state.workspace_scroll;
+
+    state.handle_raw_events(vec![
+        RawInputEvent::Mouse(MouseEvent {
+            kind: MouseEventKind::Down(MouseButton::Right),
+            column: 5,
+            row: 5,
+            modifiers: KeyModifiers::empty(),
+        }),
+        RawInputEvent::Mouse(MouseEvent {
+            kind: MouseEventKind::ScrollDown,
+            column: 1,
+            row: 1,
+            modifiers: KeyModifiers::empty(),
+        }),
+    ]);
+    assert!(
+        matches!(state.overlay, Some(ClientShellOverlay::ConfirmMerge(_))),
+        "the confirmation stays open"
+    );
+    assert_eq!(state.workspace_scroll, scroll_before);
+
+    let cancelled = click(&mut state, 0, 0);
+    assert!(state.overlay.is_none());
+    assert!(
+        endpoint_methods(&cancelled).is_empty(),
+        "cancelling merges nothing"
+    );
+}
+
+#[test]
+fn the_merge_confirm_button_is_hit_where_the_renderer_drew_it() {
+    let mut state = shell_with_second_workspace();
+    arm_merge_on_the_second_workspace(&mut state);
+    let mut accept = ClientShellInput::default();
+    state.accept_navigator_selection(&mut accept);
+    state.compose(106, 24).expect("composed frame");
+    let confirm = state.hits.overlay_primary;
+    assert!(!confirm.is_empty(), "the renderer publishes a button rect");
+
+    let merged = click(&mut state, confirm.x + 1, confirm.y);
+    assert!(state.overlay.is_none());
+    assert!(
+        endpoint_methods(&merged).iter().any(|method| matches!(
+            method,
+            crate::api::schema::Method::WorkspaceMerge(params)
+                if params.source_workspace_id == "ws_1"
+                    && params.target_workspace_id == "ws_2"
+        )),
+        "the mouse path merges exactly what the key path does"
+    );
+}
diff --git a/src/client/shell/tests/popup_focus_projection.rs b/src/client/shell/tests/popup_focus_projection.rs
index 980f8813ba..edf7f816a4 100644
--- a/src/client/shell/tests/popup_focus_projection.rs
+++ b/src/client/shell/tests/popup_focus_projection.rs
@@ -88,6 +88,7 @@ fn modal_paste_target_requires_a_focused_editable_client_field() {
         expanded_workspaces: HashSet::new(),
         pending_pane_move: None,
         pending_tab_move: None,
+        pending_workspace_merge: None,
     }));
     assert!(!state.modal_paste_target_active());
     if let Some(ClientShellOverlay::Navigator(navigator)) = state.overlay.as_mut() {
diff --git a/src/config/keybinds.rs b/src/config/keybinds.rs
index 927657ec00..f0acda3928 100644
--- a/src/config/keybinds.rs
+++ b/src/config/keybinds.rs
@@ -341,6 +341,7 @@ pub struct Keybinds {
     pub move_pane_to_new_tab: ActionKeybinds,
     pub move_tab_to_space: ActionKeybinds,
     pub move_tab_to_new_space: ActionKeybinds,
+    pub merge_workspace: ActionKeybinds,
     pub previous_agent: ActionKeybinds,
     pub next_agent: ActionKeybinds,
     pub focus_agent: Vec<IndexedKeybind>,
@@ -517,6 +518,7 @@ impl Config {
             move_pane_to_new_tab: empty_action!(),
             move_tab_to_space: empty_action!(),
             move_tab_to_new_space: empty_action!(),
+            merge_workspace: empty_action!(),
             previous_agent: empty_action!(),
             next_agent: empty_action!(),
             focus_agent: Vec::new(),
@@ -669,6 +671,7 @@ impl Config {
                 move_tab_to_new_space,
                 source
             );
+            apply_action!(keybinds.merge_workspace, merge_workspace, source);
             apply_action!(keybinds.previous_agent, previous_agent, source);
             apply_action!(keybinds.next_agent, next_agent, source);
             apply_indexed!(
diff --git a/src/config/model.rs b/src/config/model.rs
index 5bdbb2ff2d..593e904b5e 100644
--- a/src/config/model.rs
+++ b/src/config/model.rs
@@ -390,6 +390,8 @@ pub struct KeysConfig {
     pub move_tab_to_space: BindingConfig,
     /// Move the active tab to a new workspace. Unset by default.
     pub move_tab_to_new_space: BindingConfig,
+    /// Merge another workspace's tabs into a chosen workspace. Unset by default.
+    pub merge_workspace: BindingConfig,
     /// Focus the previous agent shown in the agent panel. Unset by default.
     pub previous_agent: BindingConfig,
     /// Focus the next agent shown in the agent panel. Unset by default.
@@ -538,6 +540,8 @@ pub(crate) struct KeysConfigOverlay {
     #[serde(skip_serializing_if = "Option::is_none")]
     move_tab_to_new_space: Option<BindingConfig>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    merge_workspace: Option<BindingConfig>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     previous_agent: Option<BindingConfig>,
     #[serde(skip_serializing_if = "Option::is_none")]
     next_agent: Option<BindingConfig>,
@@ -670,6 +674,7 @@ impl<'de> Deserialize<'de> for KeysConfig {
         apply_field!(move_pane_to_new_tab);
         apply_field!(move_tab_to_space);
         apply_field!(move_tab_to_new_space);
+        apply_field!(merge_workspace);
         apply_field!(previous_agent);
         apply_field!(next_agent);
         apply_field!(focus_agent);
@@ -782,6 +787,7 @@ impl KeysConfig {
         copy_effective_action_field!(move_pane_to_new_tab, keybinds.move_pane_to_new_tab);
         copy_effective_action_field!(move_tab_to_space, keybinds.move_tab_to_space);
         copy_effective_action_field!(move_tab_to_new_space, keybinds.move_tab_to_new_space);
+        copy_effective_action_field!(merge_workspace, keybinds.merge_workspace);
         copy_effective_action_field!(previous_agent, keybinds.previous_agent);
         copy_effective_action_field!(next_agent, keybinds.next_agent);
         copy_effective_indexed_field!(focus_agent, keybinds.focus_agent);
@@ -1100,6 +1106,7 @@ impl Default for KeysConfig {
             move_pane_to_new_tab: BindingConfig::empty(),
             move_tab_to_space: BindingConfig::empty(),
             move_tab_to_new_space: BindingConfig::empty(),
+            merge_workspace: BindingConfig::empty(),
             previous_agent: BindingConfig::empty(),
             next_agent: BindingConfig::empty(),
             focus_agent: BindingConfig::empty(),
diff --git a/src/input/keybind_help.rs b/src/input/keybind_help.rs
index 7b0f32d320..a84857b6b2 100644
--- a/src/input/keybind_help.rs
+++ b/src/input/keybind_help.rs
@@ -214,6 +214,16 @@ pub(crate) fn keybind_help_groups(
                     "close workspace",
                     KeybindAction::CloseWorkspace,
                 ),
+                action_entry_kw(
+                    binding_label(&keybinds.merge_workspace),
+                    "merge workspace into...",
+                    KeybindAction::MergeWorkspace,
+                    &[
+                        "combine workspaces",
+                        "merge space",
+                        "move all tabs to another space",
+                    ],
+                ),
                 action_entry(
                     binding_label(&keybinds.previous_workspace),
                     "previous workspace",
diff --git a/src/input/keybindings.rs b/src/input/keybindings.rs
index e4d4884441..a54ba9bfa7 100644
--- a/src/input/keybindings.rs
+++ b/src/input/keybindings.rs
@@ -34,6 +34,7 @@ pub(crate) enum KeybindAction {
     MovePaneToNewTab,
     MoveTabToSpace,
     MoveTabToNewSpace,
+    MergeWorkspace,
     PreviousWorkspace,
     NextWorkspace,
     MoveWorkspacePrevious,
@@ -99,6 +100,7 @@ impl KeybindAction {
             Self::MovePaneToNewTab => Some("core:move-pane-to-new-tab"),
             Self::MoveTabToSpace => Some("core:move-tab-to-space"),
             Self::MoveTabToNewSpace => Some("core:move-tab-to-new-space"),
+            Self::MergeWorkspace => Some("core:merge-workspace"),
             Self::PreviousWorkspace => Some("core:previous-workspace"),
             Self::NextWorkspace => Some("core:next-workspace"),
             Self::MoveWorkspacePrevious => Some("core:move-workspace-previous"),
@@ -211,6 +213,7 @@ pub(crate) fn resolve_non_indexed_action(
             &keybinds.move_tab_to_new_space,
             KeybindAction::MoveTabToNewSpace,
         ),
+        (&keybinds.merge_workspace, KeybindAction::MergeWorkspace),
         (&keybinds.previous_agent, KeybindAction::PreviousAgent),
         (&keybinds.next_agent, KeybindAction::NextAgent),
         (&keybinds.new_tab, KeybindAction::NewTab),
diff --git a/src/main.rs b/src/main.rs
index 09d2684a78..0dd3fb6245 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -163,6 +163,7 @@ const DEFAULT_CONFIG: &str = r##"# herdr configuration
 # move_pane_to_new_tab = ""    # optional, unset by default
 # move_tab_to_space = ""       # optional, unset by default; opens the destination picker
 # move_tab_to_new_space = ""   # optional, unset by default
+# merge_workspace = ""         # optional, unset by default; picks the workspace to merge into
 # previous_agent = ""     # optional, unset by default
 # next_agent = ""         # optional, unset by default
 # focus_agent = ""        # optional indexed binding, e.g. "prefix+alt+1..9"
diff --git a/src/server/client_commands.rs b/src/server/client_commands.rs
index 643d970d72..aa8a6c73d2 100644
--- a/src/server/client_commands.rs
+++ b/src/server/client_commands.rs
@@ -43,6 +43,7 @@ const CLIENT_SHELL_METHODS: &[&str] = &[
     "workspace.close",
     "workspace.create",
     "workspace.focus",
+    "workspace.merge",
     "workspace.move",
     "workspace.move_block",
     "workspace.rename",
@@ -255,14 +256,19 @@ mod tests {
 
     /// The fixture is the fork's contract, not upstream's.
     ///
-    /// It differs from upstream on exactly one method: `tab.move`, which this
-    /// fork extended with an optional `destination` so a tab can move to another
-    /// space, and whose `insert_index` became optional in the same change. Both
-    /// fields carry `#[serde(default, skip_serializing_if = "Option::is_none")]`,
-    /// which is this guard's own "explicitly gate new fields" escape — an older
-    /// caller omitting them still parses, and a request that omits them still
+    /// It differs from upstream on exactly one *existing* method: `tab.move`,
+    /// which this fork extended with an optional `destination` so a tab can move
+    /// to another space, and whose `insert_index` became optional in the same
+    /// change. Both fields carry
+    /// `#[serde(default, skip_serializing_if = "Option::is_none")]`, which is
+    /// this guard's own "explicitly gate new fields" escape — an older caller
+    /// omitting them still parses, and a request that omits them still
     /// serializes to the previous shape.
     ///
+    /// It also carries one fork-added method, `workspace.merge`. A new method is
+    /// additive: it adds a key here and changes no existing digest, which is why
+    /// it needed no wire-protocol bump.
+    ///
     /// If a sync makes this fail again, check *which* method moved before
     /// regenerating: a digest change on any other method is upstream's contract
     /// shifting under the fork, not the fork's own divergence.
diff --git a/src/workspace.rs b/src/workspace.rs
index 0e2c5be695..6a07f1e3f4 100644
--- a/src/workspace.rs
+++ b/src/workspace.rs
@@ -981,6 +981,27 @@ impl Workspace {
         Some(TakenTab { tab, pane_ids })
     }
 
+    /// Detaches every tab, in order, so another workspace can adopt them whole.
+    ///
+    /// This is the one path that empties a workspace, which `take_tab_for_move`
+    /// refuses to do: `Workspace` derefs through its active tab, so an empty one
+    /// panics on next access. The caller MUST remove this workspace from
+    /// `AppState::workspaces` before anything else reads it — `workspace.merge`
+    /// is the only caller, and it removes the drained source in the same
+    /// request.
+    pub(crate) fn take_all_tabs_for_move(&mut self) -> Vec<TakenTab> {
+        let mut taken = Vec::with_capacity(self.tabs.len());
+        for tab in std::mem::take(&mut self.tabs) {
+            let pane_ids = tab.layout.pane_ids();
+            for pane_id in &pane_ids {
+                self.unregister_pane(*pane_id);
+            }
+            taken.push(TakenTab { tab, pane_ids });
+        }
+        self.active_tab = 0;
+        taken
+    }
+
     /// Adopts a tab detached by `take_tab_for_move`, reissuing its public tab
     /// number and every contained pane number from this workspace's id space.
     pub(crate) fn insert_moved_tab(&mut self, taken: TakenTab, insert_idx: usize) -> usize {
diff --git a/tests/fixtures/endpoint-method-shapes-v1.json b/tests/fixtures/endpoint-method-shapes-v1.json
index 31f38f1939..1490da554d 100644
--- a/tests/fixtures/endpoint-method-shapes-v1.json
+++ b/tests/fixtures/endpoint-method-shapes-v1.json
@@ -29,6 +29,7 @@
   "workspace.close": "e4e762f28e3e2fb96be974f3cd9be7420ec7c57cf1b6f55c19d7c67853197618",
   "workspace.create": "b9dc2df43776d7d73bea576ef31b25276604c42a1c91e66e5bde8715119936ac",
   "workspace.focus": "39675f05cfe6110ece18aa2789c26f0905303b2114af801712857d0c021df150",
+  "workspace.merge": "0c56ff079eaaa68ae69cc728fe5a10eca9269f4ea8ae47bfd8338af6fcdb9942",
   "workspace.move": "1d8d308b3a6f878ef36232c7776a6d78e9ffb05f0ff3bdb52476d3a71a98208a",
   "workspace.move_block": "1c1fdf3cd9387152e09d676830998f961cf80143704940da4dc88b5c7cb639a9",
   "workspace.rename": "0e00bc779c367ef3e7a154c63b9bbbf9b9bcaa9b198450f5c479f9b9956fa7cb",