diff --git a/docs/pipe-master-slave-complete.md b/docs/pipe-master-slave-complete.md
new file mode 100644
index 0000000..0d0cd80
--- /dev/null
+++ b/docs/pipe-master-slave-complete.md
@@ -0,0 +1,575 @@
+# Master-Slave CLI 通信系统 — 完整文档
+
+> 版本：1.0  
+> 日期：2026-04-05  
+> 分支：`claude/agent-teams-communication-YT18t`
+
+---
+
+## 目录
+
+1. [需求文档](#1-需求文档)
+2. [设计文档](#2-设计文档)
+3. [实现详情](#3-实现详情)
+4. [文件清单与修改说明](#4-文件清单与修改说明)
+5. [测试验证](#5-测试验证)
+
+---
+
+## 1. 需求文档
+
+### 1.1 背景
+
+Claude Code CLI 目前每个终端实例是完全独立的。用户希望在多个终端之间建立通信机制，使得一个"主 CLI"可以控制和监控多个"从 CLI"，形成类似调度中心的工作模式。
+
+### 1.2 核心需求
+
+| 编号 | 需求 | 优先级 |
+|------|------|--------|
+| R1 | 每个 CLI 默认是**完全独立**的，没有任何特殊行为 | 必须 |
+| R2 | 主 CLI 通过 `/attach` 命令连接到从 CLI，成为**控制中心/监视器** | 必须 |
+| R3 | 主 CLI 的自身会话/命令**保持完全正常**，不被劫持 | 必须 |
+| R4 | 主 CLI 可以同时连接**多个**从 CLI | 必须 |
+| R5 | 从 CLI 是**自主工作者**，独立处理 AI 查询和工具调用 | 必须 |
+| R6 | 从 CLI 的命令和对话**只对自己生效** | 必须 |
+| R7 | 从 CLI 被 attach 后**自动上报所有会话数据**给主 CLI | 必须 |
+| R8 | 上报数据包括：用户输入 + AI 回复 + 工具调用结果 | 必须 |
+| R9 | 主 CLI 可以审查从 CLI 的完整会话历史 | 必须 |
+| R10 | 主 CLI 可以向从 CLI **发送任务**（注入 prompt） | 必须 |
+| R11 | 断开连接后，双方都**恢复为独立模式** | 必须 |
+| R12 | 必须是**真正独立的 CLI 进程**，不是模拟 | 必须 |
+
+### 1.3 命令列表
+
+| 命令 | 说明 | 角色 |
+|------|------|------|
+| `/attach <name>` | 连接到从 CLI，开始接收会话报告 | 主 |
+| `/detach [name]` | 断开一个从 CLI（无参数则断开全部） | 主 |
+| `/pipes` | 发现所有可用的 CLI 管道 | 任意 |
+| `/send <name> <msg>` | 向从 CLI 注入一条 prompt | 主 |
+| `/history <name>` | 查看从 CLI 的完整会话记录 | 主 |
+| `/pipe-status` | 查看所有已连接从 CLI 的状态概览 | 任意 |
+
+### 1.4 角色状态机
+
+```
+          /attach          被 attach
+standalone ──────► master    standalone ──────► slave
+    ▲                |           ▲                |
+    │   /detach      │           │   detach       │
+    │   (最后一个)     │           │                │
+    └────────────────┘           └────────────────┘
+```
+
+- **standalone**（默认）：完全独立，无特殊行为
+- **master**：已连接一个或多个 slave，接收会话数据
+- **slave**：被一个 master 控制，自动上报会话数据
+
+---
+
+## 2. 设计文档
+
+### 2.1 整体架构
+
+```
+┌─────────────────────┐         Unix Domain Socket          ┌─────────────────────┐
+│     Master CLI      │◄══════════════════════════════════►  │      Slave CLI      │
+│                     │    ~/.claude/pipes/{name}.sock       │                     │
+│  ┌───────────────┐  │                                     │  ┌───────────────┐  │
+│  │ useMasterMon  │  │  ◄── stream/tool/done/error ────── │  │  usePipeIpc   │  │
+│  │  (接收存储)    │  │                                     │  │  (自动上报)    │  │
+│  └───────────────┘  │  ── prompt ──────────────────────►  │  └───────────────┘  │
+│                     │                                     │                     │
+│  AppState.pipeIpc   │                                     │  AppState.pipeIpc   │
+│  role: 'master'     │                                     │  role: 'slave'      │
+│  slaves: { A, B }   │                                     │  attachedBy: 'M'    │
+└─────────────────────┘                                     └─────────────────────┘
+```
+
+### 2.2 传输层
+
+**协议**：NDJSON（换行分隔的 JSON），每条消息一行。
+
+**Socket 路径**：
+- Unix: `~/.claude/pipes/{name}.sock`
+- Windows: `\\.\pipe\claude-code-{name}`
+
+**消息类型**：
+
+| 类型 | 方向 | 说明 |
+|------|------|------|
+| `ping` / `pong` | 双向 | 健康检查 |
+| `attach_request` | M → S | 主请求附加 |
+| `attach_accept` | S → M | 从接受附加 |
+| `attach_reject` | S → M | 从拒绝（已被其他主控制） |
+| `detach` | M → S | 主断开连接 |
+| `prompt` | M → S | 主发送任务/提示 |
+| `stream` | S → M | AI 输出流片段 |
+| `tool_start` | S → M | 工具开始执行 |
+| `tool_result` | S → M | 工具执行结果 |
+| `done` | S → M | 一轮会话完成 |
+| `error` | 双向 | 错误报告 |
+
+**消息格式**：
+```typescript
+type PipeMessage = {
+  type: PipeMessageType    // 消息类型
+  data?: string            // 负载内容
+  from?: string            // 发送方管道名
+  ts?: string              // ISO 时间戳
+  meta?: Record<string, unknown>  // 额外元数据
+}
+```
+
+### 2.3 状态模型
+
+```typescript
+// 添加到 AppState
+type PipeIpcState = {
+  role: 'standalone' | 'master' | 'slave'
+  serverName: string | null          // 本 CLI 的管道服务名
+  slaves: Record<string, SlaveInfo>  // 主模式：已连接的从 CLI
+  attachedBy: string | null          // 从模式：控制我的主 CLI
+}
+
+type SlaveInfo = {
+  name: string
+  connectedAt: string       // ISO 时间戳
+  status: 'connected' | 'busy' | 'idle'
+  history: SessionEntry[]   // 完整会话记录
+}
+
+type SessionEntry = {
+  type: 'prompt' | 'stream' | 'tool_start' | 'tool_result' | 'done' | 'error'
+  content: string
+  from: string
+  timestamp: string
+  meta?: Record<string, unknown>
+}
+```
+
+### 2.4 Attach 流程
+
+```
+Master CLI                              Slave CLI
+    │                                       │
+    │── /attach cli-abc12345 ────────────►  │
+    │   (PipeClient.connect)                │
+    │                                       │
+    │── { type: "attach_request" } ──────►  │
+    │                                       │── 检查 role === 'standalone'
+    │◄── { type: "attach_accept" } ────────│── 设置 role = 'slave'
+    │── 设置 role = 'master'                │
+    │── 添加到 slaves map                    │
+    │                                       │
+    │◄═══════ 自动上报会话数据 ═══════════════│  (slave 发送所有 session 事件)
+```
+
+### 2.5 Send 流程
+
+```
+Master CLI                              Slave CLI
+    │                                       │
+    │── /send cli-abc12345 "任务" ────────►  │
+    │── { type: "prompt", data: "任务" } ──►│
+    │                                       │── handleIncomingPrompt()
+    │                                       │── AI 处理任务
+    │◄── { type: "stream", data: "..." } ──│
+    │◄── { type: "tool_start", ... } ──────│
+    │◄── { type: "tool_result", ... } ─────│
+    │◄── { type: "done" } ─────────────────│
+    │── 存入 slaves[name].history            │
+```
+
+### 2.6 Detach 流程
+
+```
+Master CLI                              Slave CLI
+    │                                       │
+    │── /detach cli-abc12345 ────────────►  │
+    │── { type: "detach" } ──────────────►  │
+    │                                       │── 设置 role = 'standalone'
+    │── 从 slaves map 删除                   │── 停止自动上报
+    │── (如无更多 slave → standalone)         │
+```
+
+---
+
+## 3. 实现详情
+
+### 3.1 传输层 — `src/utils/pipeTransport.ts`
+
+**状态**：已有，复用。
+
+**类与函数**：
+
+| 组件 | 说明 |
+|------|------|
+| `PipeServer` | Unix socket 服务端，管理多个客户端连接。支持 `onMessage(handler)` 注册消息处理、`broadcast(msg)` 广播、`sendTo(socket, msg)` 定向发送 |
+| `PipeClient` | 客户端，连接到远程 PipeServer。支持 `connect(timeout)` 自动重试（ENOENT 轮询）、`send(msg)`、`onMessage(handler)` |
+| `createPipeServer(name)` | 工厂函数，创建并启动 PipeServer |
+| `connectToPipe(target, sender, timeout)` | 工厂函数，创建 PipeClient 并连接 |
+| `listPipes()` | 扫描 `~/.claude/pipes/` 目录，返回所有 `.sock` 文件名 |
+| `isPipeAlive(name, timeout)` | 通过 ping/pong 检测管道是否存活 |
+
+**关键实现细节**：
+- 使用 Node.js `net` 模块的 `createServer` / `createConnection`
+- NDJSON 协议：每条消息是一行 JSON，用 `\n` 分隔
+- 缓冲区处理：`buffer += chunk; lines = buffer.split('\n'); buffer = lines.pop()`
+- ENOENT 处理：连接前用 `fs.access()` 轮询等待 socket 文件存在
+- 清理机制：服务关闭时自动 `unlink` socket 文件
+
+### 3.2 Slave 侧 Hook — `src/hooks/usePipeIpc.ts`
+
+**状态**：完全重写。
+
+**核心逻辑**：
+
+```
+挂载时:
+  1. 生成管道名: cli-{sessionId前8位}
+  2. 创建 PipeServer 并监听
+  3. 设置 globalThis.__pipeSendToMaster 全局函数
+  4. 注册消息处理器:
+     - ping → pong
+     - attach_request → 检查角色 → accept/reject
+     - detach → 恢复 standalone
+     - prompt → handleIncomingPrompt 注入
+```
+
+**`relayToMaster(msg)` 导出函数**：
+- 由 REPL.tsx 的 `onQueryEvent` 调用
+- 通过 `globalThis.__pipeSendToMaster` 桥接，避免循环依赖
+- 仅在 `role === 'slave'` 时生效
+
+**Master 断线处理**：
+- 监听 master socket 的 `close` 事件
+- 自动恢复为 standalone
+
+### 3.3 Master 侧 Hook — `src/hooks/useMasterMonitor.ts`
+
+**状态**：新建。
+
+**核心逻辑**：
+
+```
+当 role === 'master' 时:
+  1. 遍历 _slaveClients Map 中所有 PipeClient
+  2. 为每个 client 注册消息监听
+  3. 收到 stream/tool_start/tool_result/done/error → 存入 AppState.pipeIpc.slaves[name].history
+  4. 更新 slave 状态: prompt → busy, done/error → idle
+  5. 监听 slave disconnect → 自动从 slaves 删除
+```
+
+**模块级 PipeClient 注册表**：
+
+| 函数 | 说明 |
+|------|------|
+| `addSlaveClient(name, client)` | 注册从 CLI 连接（由 /attach 调用） |
+| `removeSlaveClient(name)` | 删除从 CLI 连接（由 /detach 调用） |
+| `getSlaveClient(name)` | 获取指定从 CLI 连接（由 /send 调用） |
+| `getAllSlaveClients()` | 获取所有连接（由 /pipe-status 调用） |
+
+### 3.4 命令实现
+
+#### `/attach <name>` — `src/commands/attach/attach.ts`
+
+```
+1. 解析目标管道名
+2. 检查: 是否已连接该 slave？是否处于 slave 模式？
+3. connectToPipe(target, myName) 建立连接
+4. 发送 attach_request，等待响应（5s 超时）
+5. 收到 attach_accept:
+   - addSlaveClient(name, client) 注册到 Monitor
+   - 更新 AppState: role → master, 添加 slave 记录
+6. 收到 attach_reject: 断开，报告原因
+```
+
+#### `/detach [name]` — `src/commands/detach/detach.ts`
+
+```
+有目标名:
+  1. removeSlaveClient(name)
+  2. 发送 detach 消息
+  3. client.disconnect()
+  4. 从 AppState.slaves 删除
+  5. 如无更多 slave → role 恢复 standalone
+
+无目标名（全部断开）:
+  1. 遍历所有 slaveClients
+  2. 对每个执行上述流程
+  3. role → standalone
+```
+
+#### `/pipes` — `src/commands/pipes/pipes.ts`
+
+```
+1. 显示本 CLI 的管道名和角色
+2. 如 master: 显示已连接 slave 列表
+3. 如 slave: 显示控制方
+4. listPipes() 列出所有管道文件
+5. isPipeAlive() 逐个检测存活状态
+6. 标记已 attach 的管道
+```
+
+#### `/send <name> <msg>` — `src/commands/send/send.ts`
+
+```
+1. 检查 role === master
+2. 解析: 第一个空格前是管道名，后面是消息
+3. getSlaveClient(name) 获取连接
+4. client.send({ type: 'prompt', data: message })
+5. 记录到 slaves[name].history (type: 'prompt')
+6. 更新 slave 状态为 busy
+```
+
+#### `/history <name>` — `src/commands/history/history.ts`
+
+```
+1. 检查 role === master
+2. 从 AppState.pipeIpc.slaves[name].history 读取记录
+3. 支持 --last N 参数限制显示条数
+4. 格式化输出: [时间] [类型] 内容
+   类型标记: [PROMPT] [AI] [TOOL>] [TOOL<] [DONE] [ERROR]
+```
+
+#### `/pipe-status` — `src/commands/pipe-status/pipe-status.ts`
+
+```
+1. standalone: 提示未连接
+2. slave: 显示控制方信息
+3. master: 逐个显示 slave 信息
+   - 名称、状态(idle/busy)、连接状态、连接时间、历史条数
+```
+
+### 3.5 REPL 集成 — `src/screens/REPL.tsx`
+
+**修改点一：导入**（第 144-145 行）
+```typescript
+import { usePipeIpc, relayToMaster } from '../hooks/usePipeIpc.js';
+import { useMasterMonitor } from '../hooks/useMasterMonitor.js';
+```
+
+**修改点二：Hook 挂载**（第 4114-4120 行，位于 `useMailboxBridge` 之后）
+```typescript
+usePipeIpc({
+  enabled: true,
+  isLoading,
+  onSubmitMessage: handleIncomingPrompt,
+});
+useMasterMonitor();
+```
+
+**修改点三：`resetLoadingState` 中发送 done 信号**（第 1607 行）
+```typescript
+relayToMaster({ type: 'done' });
+```
+每轮 AI 对话结束时通知 master。
+
+**修改点四：`onQueryEvent` 中继 AI 输出**
+
+流式文本回调（第 2697 行）：
+```typescript
+relayToMaster({ type: 'stream', data: newContent });
+```
+
+消息处理回调中（第 2671-2678 行）：
+```typescript
+// Tool 事件
+if (newMessage.type === 'progress') {
+  relayToMaster({ type: 'tool_start', data: tool, meta: { toolUseId } });
+  relayToMaster({ type: 'tool_result', data: result, meta: { toolUseId } });
+}
+// Assistant 文本消息
+if (newMessage.type === 'assistant') {
+  relayToMaster({ type: 'stream', data: text });
+}
+```
+
+**删除点：旧的 master 输入劫持**
+
+旧代码会在 master 模式下拦截用户输入转发给 slave，这**违反需求 R3**（主 CLI 保持完全正常）。已完全删除此逻辑。任务发送现在只通过 `/send` 命令。
+
+### 3.6 状态定义 — `src/state/AppStateStore.ts`
+
+**新增类型**（第 93-116 行）：
+```typescript
+export type SessionEntry = {
+  type: 'prompt' | 'stream' | 'tool_start' | 'tool_result' | 'done' | 'error'
+  content: string
+  from: string
+  timestamp: string
+  meta?: Record<string, unknown>
+}
+
+export type SlaveInfo = {
+  name: string
+  connectedAt: string
+  status: 'connected' | 'busy' | 'idle'
+  history: SessionEntry[]
+}
+
+export type PipeIpcState = {
+  role: 'standalone' | 'master' | 'slave'
+  serverName: string | null
+  slaves: Record<string, SlaveInfo>
+  attachedBy: string | null
+}
+```
+
+**AppState 新增字段**（第 481 行）：
+```typescript
+pipeIpc: PipeIpcState
+```
+
+**默认值**（第 598 行）：
+```typescript
+pipeIpc: {
+  role: 'standalone',
+  serverName: null,
+  slaves: {},
+  attachedBy: null,
+}
+```
+
+### 3.7 命令注册 — `src/commands.ts`
+
+**新增导入**（第 59-64 行）：
+```typescript
+import attach from './commands/attach/index.js'
+import detach from './commands/detach/index.js'
+import pipes from './commands/pipes/index.js'
+import send from './commands/send/index.js'
+import pipeHistory from './commands/history/index.js'
+import pipeStatus from './commands/pipe-status/index.js'
+```
+
+**注册到 COMMANDS 数组**（第 335-340 行）：
+```typescript
+attach,
+detach,
+pipes,
+send,
+pipeHistory,
+pipeStatus,
+```
+
+---
+
+## 4. 文件清单与修改说明
+
+### 4.1 新建文件
+
+| 文件 | 说明 |
+|------|------|
+| `docs/pipe-master-slave-design.md` | 设计文档 |
+| `src/utils/pipeTransport.ts` | 传输层：PipeServer、PipeClient、NDJSON 协议 |
+| `src/hooks/usePipeIpc.ts` | Slave 侧 Hook：自动建立 PipeServer、处理 attach/detach/prompt、relay |
+| `src/hooks/useMasterMonitor.ts` | Master 侧 Hook：监听 slave 会话数据、存储历史记录 |
+| `src/commands/attach/index.ts` | /attach 命令注册 |
+| `src/commands/attach/attach.ts` | /attach 命令实现 |
+| `src/commands/detach/index.ts` | /detach 命令注册 |
+| `src/commands/detach/detach.ts` | /detach 命令实现 |
+| `src/commands/pipes/index.ts` | /pipes 命令注册 |
+| `src/commands/pipes/pipes.ts` | /pipes 命令实现 |
+| `src/commands/send/index.ts` | /send 命令注册 |
+| `src/commands/send/send.ts` | /send 命令实现 |
+| `src/commands/history/index.ts` | /history 命令注册 |
+| `src/commands/history/history.ts` | /history 命令实现 |
+| `src/commands/pipe-status/index.ts` | /pipe-status 命令注册 |
+| `src/commands/pipe-status/pipe-status.ts` | /pipe-status 命令实现 |
+| `test-pipe-ipc.ts` | 双进程端到端测试脚本 |
+
+### 4.2 修改的已有文件
+
+| 文件 | 修改内容 |
+|------|----------|
+| `src/state/AppStateStore.ts` | 新增 `SessionEntry`、`SlaveInfo`、`PipeIpcState` 类型；AppState 添加 `pipeIpc` 字段；`getDefaultAppState()` 添加默认值 |
+| `src/commands.ts` | 导入 6 个新命令模块；注册到 `COMMANDS` 数组 |
+| `src/screens/REPL.tsx` | 导入 `usePipeIpc`/`relayToMaster`/`useMasterMonitor`；挂载两个 Hook；`resetLoadingState` 中添加 done 信号；`onQueryEvent` 中添加 stream/tool/assistant 中继；**删除**旧的 master 输入劫持逻辑和旧的 `__pipeSendToMaster` 内联调用 |
+
+### 4.3 删除的文件
+
+| 文件 | 原因 |
+|------|------|
+| `src/hooks/useMasterRelay.ts` | 旧的单 slave 架构，被 `useMasterMonitor.ts` 替代 |
+
+---
+
+## 5. 测试验证
+
+### 5.1 集成测试（同进程双端通信）
+
+通过 `test-pipe-ipc.ts` 在同一进程中创建独立的 PipeServer 和 PipeClient，通过真实 Unix domain socket 通信。
+
+**测试用例**：
+
+| # | 测试项 | 结果 |
+|---|--------|------|
+| 1 | Slave PipeServer 启动成功 | ✓ PASS |
+| 2 | `listPipes()` 发现管道 | ✓ PASS |
+| 3 | `isPipeAlive()` ping/pong 健康检查 | ✓ PASS |
+| 4 | Master 连接到 Slave | ✓ PASS |
+| 5 | Attach 请求被接受 | ✓ PASS |
+| 6 | 重复 attach 被正确拒绝 | ✓ PASS |
+| 7 | 发送 prompt → 收到完整 session 数据 (stream×2 → tool_start → tool_result → done) | ✓ PASS |
+| 8 | Stream 内容完整 | ✓ PASS |
+| 9 | Tool 事件携带正确 metadata | ✓ PASS |
+| 10 | Detach 命令 | ✓ PASS |
+| 11 | Detach 后重新 attach 成功 | ✓ PASS |
+
+### 5.2 双独立进程测试
+
+启动两个真正独立的操作系统进程：
+
+```
+进程 A (Slave, PID 12572):
+  bun run test-pipe-ipc.ts slave
+
+进程 B (Master, PID 12588):
+  bun run test-pipe-ipc.ts master
+```
+
+**验证结果**：
+
+```
+[SLAVE]  Server started: test-slave-001
+[SLAVE]  等待 master 连接...
+
+[MASTER] Connecting to slave "test-slave-001"...
+[MASTER] Connected!
+[MASTER] 已发送 attach_request
+[SLAVE]  Accepted attach from test-master-001
+[MASTER] 收到: attach_accept test-slave-001
+
+[MASTER] 已发送 prompt
+[SLAVE]  Received prompt: "请帮我分析这段代码的问题"
+[SLAVE]  Sent stream fragment 1
+[MASTER] 收到: stream Processing your request
+[SLAVE]  Sent stream fragment 2
+[MASTER] 收到: stream ... analyzing code...
+[SLAVE]  Sent tool_start
+[MASTER] 收到: tool_start ReadFile
+[SLAVE]  Sent tool_result
+[MASTER] 收到: tool_result file contents here...
+[SLAVE]  Sent done
+[MASTER] 收到: done
+
+[SLAVE]  Detached by test-master-001
+[MASTER] 已断开连接
+```
+
+**结论**：两个独立进程通过 Unix domain socket 完成了完整的 attach → prompt → session 数据回传 → detach 流程。
+
+### 5.3 测试命令
+
+```bash
+# 集成测试（11 项全部通过）
+bun run test-pipe-ipc.ts
+
+# 双进程测试（终端 1）
+bun run test-pipe-ipc.ts slave
+
+# 双进程测试（终端 2）
+bun run test-pipe-ipc.ts master
+```
diff --git a/docs/pipe-master-slave-design.md b/docs/pipe-master-slave-design.md
new file mode 100644
index 0000000..d7bbff3
--- /dev/null
+++ b/docs/pipe-master-slave-design.md
@@ -0,0 +1,149 @@
+# Master-Slave CLI Communication Architecture Design Document
+
+## 1. Overview
+
+This document describes a **master-slave architecture** for inter-CLI communication using Unix domain sockets (named pipes). The system allows independent CLI instances to form a coordination network where:
+
+- **Master CLI**: A control center that connects to multiple slave CLIs, sends them tasks, and receives their full session data (user input + AI output + tool results) for review.
+- **Slave CLI**: An autonomous worker that processes tasks independently. When attached by a master, it automatically reports all session activity back to the master.
+- **Standalone CLI**: The default mode — a completely normal, independent CLI with no special behavior.
+
+## 2. Core Principles
+
+1. **Independence by default**: Every CLI starts as standalone. No master/slave behavior until explicitly activated via `/attach`.
+2. **Master is a monitor, not a terminal proxy**: The master CLI's own conversation/commands remain fully functional. Master monitors slaves, it doesn't become them.
+3. **Slave is autonomous**: Slave executes its own AI queries and tool calls. It just reports what happens to the master.
+4. **Multiple slaves**: A master can attach to multiple slaves simultaneously.
+5. **Bidirectional control**: Master can send prompts to slaves via `/send`, and receives session reports automatically.
+6. **Clean detach**: Either side can disconnect, returning to standalone mode.
+
+## 3. Architecture
+
+### 3.1 Transport Layer (existing — `src/utils/pipeTransport.ts`)
+
+- **PipeServer**: Each CLI creates a Unix domain socket server at `~/.claude/pipes/{session-id}.sock`
+- **PipeClient**: Connects to a remote PipeServer for communication
+- **Protocol**: NDJSON (newline-delimited JSON) over Unix domain sockets
+- **Message types**: `ping/pong`, `attach_request/accept/reject`, `detach`, `prompt`, `stream`, `tool_start`, `tool_result`, `done`, `error`
+
+### 3.2 State Model (`AppState.pipeIpc`)
+
+```typescript
+pipeIpc: {
+  role: 'standalone' | 'master' | 'slave'
+  serverName: string | null          // This CLI's pipe server name
+  // Master-specific
+  slaves: Map<string, SlaveInfo>     // Connected slaves (name → info)
+  // Slave-specific
+  attachedBy: string | null          // Master pipe name (when slave)
+}
+
+type SlaveInfo = {
+  name: string
+  connectedAt: string                // ISO timestamp
+  status: 'connected' | 'busy' | 'idle'
+  history: SessionEntry[]            // Full session transcript
+}
+
+type SessionEntry = {
+  type: 'prompt' | 'stream' | 'tool_start' | 'tool_result' | 'done' | 'error'
+  content: string
+  from: string
+  timestamp: string
+  meta?: Record<string, unknown>
+}
+```
+
+### 3.3 Hooks
+
+#### `usePipeIpc` (every CLI)
+- On mount: create PipeServer for this session
+- Handle `attach_request` → accept, switch to slave role, begin auto-reporting
+- Handle `prompt` → inject via `handleIncomingPrompt`
+- Handle `detach` → revert to standalone
+- **Auto-report**: When in slave role, relay all session events (user input, AI output, tool calls) to master via `globalThis.__pipeSendToMaster`
+
+#### `useMasterMonitor` (master only)
+- Active when `role === 'master'`
+- For each connected slave PipeClient: listen for `stream`, `tool_start`, `tool_result`, `done`, `error`
+- Store received messages into `slaves[name].history`
+- Update slave status (`busy`/`idle`) based on `prompt`/`done` events
+
+### 3.4 Session Relay (Slave → Master)
+
+When a CLI is in slave role, the REPL's `onQueryEvent` handler additionally calls `globalThis.__pipeSendToMaster()` to forward:
+- **AI stream fragments** → `{ type: 'stream', data: text }`
+- **Tool start** → `{ type: 'tool_start', data: toolName, meta: { toolUseId } }`
+- **Tool results** → `{ type: 'tool_result', data: resultText, meta: { toolUseId } }`
+- **Turn complete** → `{ type: 'done' }`
+- **Errors** → `{ type: 'error', data: errorMessage }`
+
+### 3.5 Commands
+
+| Command | Description |
+|---------|-------------|
+| `/pipes` | List all discoverable pipe servers with liveness status |
+| `/attach <name>` | Connect to a slave CLI, begin receiving session reports |
+| `/detach [name]` | Disconnect from one slave (or all if no arg) |
+| `/send <name> <msg>` | Inject a prompt into a slave CLI |
+| `/history <name>` | View a slave's full session transcript |
+| `/status` | Overview of all connected slaves and their status |
+
+## 4. Flow Diagrams
+
+### 4.1 Attach Flow
+```
+Master CLI                          Slave CLI
+    |                                   |
+    |-- /attach cli-abc12345 -------->  |
+    |   (PipeClient connects)           |
+    |                                   |
+    |-- attach_request --------------->  |
+    |                                   |-- (checks role == standalone)
+    |<------------- attach_accept ------|-- (sets role = slave)
+    |-- (sets role = master)            |
+    |-- (adds to slaves map)            |
+    |                                   |
+    |<============ auto-report =========|  (slave sends all session data)
+```
+
+### 4.2 Send Flow
+```
+Master CLI                          Slave CLI
+    |                                   |
+    |-- /send cli-abc12345 "task" -->   |
+    |-- prompt {data: "task"} -------->  |
+    |                                   |-- (handleIncomingPrompt)
+    |                                   |-- (AI processes task)
+    |<-------- stream {data: "..."} ----|
+    |<-------- tool_start -------------|
+    |<-------- tool_result ------------|
+    |<-------- done -------------------|
+    |-- (stores in history)             |
+```
+
+### 4.3 Detach Flow
+```
+Master CLI                          Slave CLI
+    |                                   |
+    |-- /detach cli-abc12345 -------->  |
+    |-- detach ---------------------->  |
+    |                                   |-- (sets role = standalone)
+    |-- (removes from slaves map)       |-- (stops auto-report)
+    |-- (role stays master or           |
+    |    becomes standalone if          |
+    |    no more slaves)                |
+```
+
+## 5. Implementation Plan
+
+1. Update `AppState.pipeIpc` to support multi-slave master model
+2. Rewrite `usePipeIpc` hook for correct slave behavior
+3. Create `useMasterMonitor` hook for master-side monitoring
+4. Rewrite `/attach` command for multi-slave support
+5. Rewrite `/detach` command with optional target
+6. Update `/pipes` command
+7. Create `/send`, `/history`, `/status` commands
+8. Mount hooks in REPL.tsx
+9. Register all commands in commands.ts
+10. Integrate session relay into REPL's `onQueryEvent`
diff --git a/src/assistant/gate.ts b/src/assistant/gate.ts
new file mode 100644
index 0000000..1602a3b
--- /dev/null
+++ b/src/assistant/gate.ts
@@ -0,0 +1,25 @@
+import { feature } from 'bun:bundle'
+import { getKairosActive } from '../bootstrap/state.js'
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js'
+
+/**
+ * Runtime gate for KAIROS features.
+ *
+ * Build-time: feature('KAIROS') must be on (checked by caller before
+ * this module is required).
+ *
+ * Runtime: tengu_kairos_assistant GrowthBook flag acts as a remote kill
+ * switch, and kairosActive state must be true (set during bootstrap when
+ * the session qualifies for KAIROS features).
+ */
+export async function isKairosEnabled(): Promise<boolean> {
+  if (!feature('KAIROS')) {
+    return false
+  }
+  if (
+    !getFeatureValue_CACHED_MAY_BE_STALE('tengu_kairos_assistant', false)
+  ) {
+    return false
+  }
+  return getKairosActive()
+}
diff --git a/src/commands.ts b/src/commands.ts
index 10f03b2..3a24957 100644
--- a/src/commands.ts
+++ b/src/commands.ts
@@ -56,6 +56,12 @@ import terminalSetup from './commands/terminalSetup/index.js'
 import usage from './commands/usage/index.js'
 import theme from './commands/theme/index.js'
 import vim from './commands/vim/index.js'
+import attach from './commands/attach/index.js'
+import detach from './commands/detach/index.js'
+import pipes from './commands/pipes/index.js'
+import send from './commands/send/index.js'
+import pipeHistory from './commands/history/index.js'
+import pipeStatus from './commands/pipe-status/index.js'
 import { feature } from 'bun:bundle'
 // Dead code elimination: conditional imports
 /* eslint-disable @typescript-eslint/no-require-imports */
@@ -326,6 +332,12 @@ const COMMANDS = memoize((): Command[] => [
   ...(bridge ? [bridge] : []),
   ...(remoteControlServerCommand ? [remoteControlServerCommand] : []),
   ...(voiceCommand ? [voiceCommand] : []),
+  attach,
+  detach,
+  pipes,
+  send,
+  pipeHistory,
+  pipeStatus,
   thinkback,
   thinkbackPlay,
   permissions,
diff --git a/src/commands/assistant/assistant.tsx b/src/commands/assistant/assistant.tsx
new file mode 100644
index 0000000..df0e62e
--- /dev/null
+++ b/src/commands/assistant/assistant.tsx
@@ -0,0 +1,36 @@
+import type { LocalJSXCommandContext } from '../../commands.js'
+import type { LocalJSXCommandOnDone } from '../../types/command.js'
+
+/**
+ * /assistant command implementation.
+ *
+ * Opens the Kairos assistant panel. In the current build the panel is
+ * rendered by the REPL layer when kairosActive is true; the slash command
+ * simply toggles visibility and prints a confirmation line.
+ */
+export async function call(
+  onDone: LocalJSXCommandOnDone,
+  context: LocalJSXCommandContext,
+  _args: string,
+): Promise<React.ReactNode> {
+  const { setAppState, getAppState } = context
+
+  const current = getAppState()
+  const isVisible = (current as Record<string, unknown>).assistantPanelVisible
+
+  if (isVisible) {
+    setAppState((prev: Record<string, unknown>) => ({
+      ...prev,
+      assistantPanelVisible: false,
+    }))
+    onDone('Assistant panel hidden.', { display: 'system' })
+  } else {
+    setAppState((prev: Record<string, unknown>) => ({
+      ...prev,
+      assistantPanelVisible: true,
+    }))
+    onDone('Assistant panel opened.', { display: 'system' })
+  }
+
+  return null
+}
diff --git a/src/commands/assistant/gate.ts b/src/commands/assistant/gate.ts
new file mode 100644
index 0000000..0bf42b1
--- /dev/null
+++ b/src/commands/assistant/gate.ts
@@ -0,0 +1,25 @@
+import { feature } from 'bun:bundle'
+import { getKairosActive } from '../../bootstrap/state.js'
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js'
+
+/**
+ * Runtime gate for the /assistant command.
+ *
+ * Build-time: feature('KAIROS') must be on (checked in commands.ts before
+ * the module is even required).
+ *
+ * Runtime: tengu_kairos_assistant GrowthBook flag acts as a remote kill
+ * switch, and kairosActive state must be true (set during bootstrap when
+ * the session qualifies for KAIROS features).
+ */
+export function isAssistantEnabled(): boolean {
+  if (!feature('KAIROS')) {
+    return false
+  }
+  if (
+    !getFeatureValue_CACHED_MAY_BE_STALE('tengu_kairos_assistant', false)
+  ) {
+    return false
+  }
+  return getKairosActive()
+}
diff --git a/src/commands/assistant/index.ts b/src/commands/assistant/index.ts
new file mode 100644
index 0000000..18263be
--- /dev/null
+++ b/src/commands/assistant/index.ts
@@ -0,0 +1,16 @@
+import type { Command } from '../../commands.js'
+import { isAssistantEnabled } from './gate.js'
+
+const assistant = {
+  type: 'local-jsx',
+  name: 'assistant',
+  description: 'Open the Kairos assistant panel',
+  isEnabled: isAssistantEnabled,
+  get isHidden() {
+    return !isAssistantEnabled()
+  },
+  immediate: true,
+  load: () => import('./assistant.js'),
+} satisfies Command
+
+export default assistant
diff --git a/src/commands/attach/attach.ts b/src/commands/attach/attach.ts
new file mode 100644
index 0000000..f300ff8
--- /dev/null
+++ b/src/commands/attach/attach.ts
@@ -0,0 +1,97 @@
+import type { LocalCommandCall } from '../../types/command.js'
+import { connectToPipe, getPipeIpc, type PipeClient, type PipeMessage } from '../../utils/pipeTransport.js'
+import { addSlaveClient } from '../../hooks/useMasterMonitor.js'
+
+export const call: LocalCommandCall = async (args, context) => {
+  const targetName = args.trim()
+  if (!targetName) {
+    return {
+      type: 'text',
+      value: 'Usage: /attach <pipe-name>\nUse /pipes to list available pipes.',
+    }
+  }
+
+  const currentState = context.getAppState()
+
+  // Check if already attached to this slave
+  if (getPipeIpc(currentState).slaves[targetName]) {
+    return {
+      type: 'text',
+      value: `Already attached to "${targetName}".`,
+    }
+  }
+
+  // Cannot attach when in slave mode
+  if (getPipeIpc(currentState).role === 'slave') {
+    return {
+      type: 'text',
+      value: 'Cannot attach: this CLI is in slave mode. Use /detach from the master first.',
+    }
+  }
+
+  // Connect to the target pipe server
+  let client: PipeClient
+  try {
+    const myName = getPipeIpc(currentState).serverName ?? `master-${process.pid}`
+    client = await connectToPipe(targetName, myName)
+  } catch (err) {
+    return {
+      type: 'text',
+      value: `Failed to connect to "${targetName}": ${err instanceof Error ? err.message : String(err)}`,
+    }
+  }
+
+  // Send attach request and wait for response
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      client.disconnect()
+      resolve({
+        type: 'text',
+        value: `Attach to "${targetName}" timed out (no response within 5s).`,
+      })
+    }, 5000)
+
+    client.onMessage((msg: PipeMessage) => {
+      if (msg.type === 'attach_accept') {
+        clearTimeout(timeout)
+
+        // Register the slave client in the module-level registry
+        addSlaveClient(targetName, client)
+
+        // Update AppState: add slave and switch to master role
+        context.setAppState((prev) => ({
+          ...prev,
+          pipeIpc: {
+            ...getPipeIpc(prev),
+            role: 'master',
+            slaves: {
+              ...getPipeIpc(prev).slaves,
+              [targetName]: {
+                name: targetName,
+                connectedAt: new Date().toISOString(),
+                status: 'idle' as const,
+                history: [],
+              },
+            },
+          },
+        }))
+
+        const slaveCount = Object.keys(getPipeIpc(currentState).slaves).length + 1
+        resolve({
+          type: 'text',
+          value: `Attached to "${targetName}" as master. Now monitoring ${slaveCount} slave(s).\nUse /send ${targetName} <message> to send tasks.\nUse /status to see all slaves.\nUse /detach ${targetName} to disconnect.`,
+        })
+      } else if (msg.type === 'attach_reject') {
+        clearTimeout(timeout)
+        client.disconnect()
+
+        resolve({
+          type: 'text',
+          value: `Attach rejected by "${targetName}": ${msg.data ?? 'unknown reason'}`,
+        })
+      }
+    })
+
+    client.send({ type: 'attach_request' })
+  })
+}
diff --git a/src/commands/attach/index.ts b/src/commands/attach/index.ts
new file mode 100644
index 0000000..ab68930
--- /dev/null
+++ b/src/commands/attach/index.ts
@@ -0,0 +1,12 @@
+import type { Command } from '../../commands.js'
+
+const attach = {
+  type: 'local',
+  name: 'attach',
+  description: 'Attach to a slave CLI to monitor and control it',
+  argumentHint: '<pipe-name>',
+  supportsNonInteractive: false,
+  load: () => import('./attach.js'),
+} satisfies Command
+
+export default attach
diff --git a/src/commands/buddy/buddy.tsx b/src/commands/buddy/buddy.tsx
new file mode 100644
index 0000000..b4c8e87
--- /dev/null
+++ b/src/commands/buddy/buddy.tsx
@@ -0,0 +1,244 @@
+import React from 'react'
+import { Box, Text } from '../../ink.js'
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js'
+import {
+  companionUserId,
+  getCompanion,
+  roll,
+} from '../../buddy/companion.js'
+import { isBuddyLive } from '../../buddy/useBuddyNotification.js'
+import {
+  RARITY_COLORS,
+  RARITY_STARS,
+  STAT_NAMES,
+  type CompanionBones,
+  type CompanionSoul,
+  type StoredCompanion,
+} from '../../buddy/types.js'
+import { renderSprite } from '../../buddy/sprites.js'
+import type { LocalJSXCommandCall } from '../../types/command.js'
+import { useTheme } from '../../ink.js'
+
+// Fallback names when soul generation API is unavailable
+const FALLBACK_NAMES = [
+  'Crumpet',
+  'Soup',
+  'Pickle',
+  'Biscuit',
+  'Moth',
+  'Gravy',
+] as const
+
+// Inspiration words for soul generation
+const INSPIRATION = [
+  'thunder', 'biscuit', 'void', 'accordion', 'moss', 'velvet', 'static',
+  'marble', 'squall', 'prism', 'glyph', 'lichen', 'torque', 'ember', 'drift',
+  'mercury', 'fable', 'plume', 'cipher', 'soot', 'quartz', 'anthem', 'gauge',
+  'thistle', 'rumble', 'opal', 'forge', 'vex', 'wane', 'yew', 'zest',
+] as const
+
+function fallbackSoul(bones: CompanionBones): CompanionSoul {
+  const idx = bones.species.charCodeAt(0) + bones.eye.charCodeAt(0)
+  return {
+    name: FALLBACK_NAMES[idx % FALLBACK_NAMES.length]!,
+    personality: `A ${bones.rarity} ${bones.species} of few words.`,
+  }
+}
+
+function hatchCompanion(
+  setCompanionReaction: (reaction: string | undefined) => void,
+): StoredCompanion {
+  const userId = companionUserId()
+  const { bones } = roll(userId)
+
+  // Use fallback soul generation (API-based soul generation requires
+  // firstParty org access to /api/organizations/{org}/claude_code/buddy_react)
+  const soul = fallbackSoul(bones)
+  const hatchedAt = Date.now()
+
+  // Persist soul in global config
+  saveGlobalConfig(config => ({
+    ...config,
+    companion: { ...soul, hatchedAt },
+  }))
+
+  return { ...soul, hatchedAt }
+}
+
+function StatBar({
+  name,
+  value,
+}: {
+  name: string
+  value: number
+}): React.ReactNode {
+  const filled = Math.round(value / 10)
+  const empty = 10 - filled
+  return (
+    <Text>
+      <Text>{name.padEnd(10)}</Text>
+      <Text color="green">{'█'.repeat(filled)}</Text>
+      <Text dimColor>{'░'.repeat(empty)}</Text>
+      <Text dimColor> {String(value).padStart(3)}</Text>
+    </Text>
+  )
+}
+
+function CompanionCard({
+  bones,
+  soul,
+  lastReaction,
+}: {
+  bones: CompanionBones
+  soul: CompanionSoul & { hatchedAt: number }
+  lastReaction?: string
+}): React.ReactNode {
+  const [theme] = useTheme()
+  const rarityColor =
+    theme[RARITY_COLORS[bones.rarity]] ?? undefined
+
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="round"
+      borderColor={rarityColor}
+      width={40}
+      paddingX={1}
+    >
+      <Box justifyContent="center">
+        <Text color={rarityColor}>
+          {RARITY_STARS[bones.rarity]} {bones.rarity.toUpperCase()}
+        </Text>
+      </Box>
+      <Box justifyContent="center">
+        <Text bold>{bones.species.toUpperCase()}</Text>
+      </Box>
+      {bones.shiny && (
+        <Box justifyContent="center">
+          <Text>✨ SHINY ✨</Text>
+        </Box>
+      )}
+      <Box justifyContent="center" marginY={1}>
+        <Text color={rarityColor}>
+          {renderSprite(bones, 0).join('\n')}
+        </Text>
+      </Box>
+      <Box justifyContent="center">
+        <Text bold>{soul.name}</Text>
+      </Box>
+      <Box justifyContent="center">
+        <Text dimColor italic>
+          {soul.personality}
+        </Text>
+      </Box>
+      <Box flexDirection="column" marginTop={1}>
+        {STAT_NAMES.map(stat => (
+          <StatBar key={stat} name={stat} value={bones.stats[stat]} />
+        ))}
+      </Box>
+      {lastReaction && (
+        <Box marginTop={1} justifyContent="center">
+          <Text dimColor>&ldquo;{lastReaction}&rdquo;</Text>
+        </Box>
+      )}
+    </Box>
+  )
+}
+
+function HatchingView({
+  bones,
+  soul,
+  onDone,
+}: {
+  bones: CompanionBones
+  soul: CompanionSoul & { hatchedAt: number }
+  onDone: (msg: string, opts?: { display?: string }) => void
+}): React.ReactNode {
+  return (
+    <Box flexDirection="column" gap={1}>
+      <CompanionCard bones={bones} soul={soul} />
+      <Box flexDirection="column">
+        <Text dimColor>
+          {soul.name} is here · it&apos;ll chime in as you code
+        </Text>
+        <Text dimColor>
+          your buddy won&apos;t count toward your usage
+        </Text>
+        <Text dimColor>
+          say its name to get its take · /buddy pet · /buddy off
+        </Text>
+      </Box>
+    </Box>
+  )
+}
+
+export const call: LocalJSXCommandCall = async (onDone, context, args) => {
+  const config = getGlobalConfig()
+  const arg = args?.trim()
+
+  if (arg === 'off') {
+    if (config.companionMuted !== true) {
+      saveGlobalConfig(c => ({ ...c, companionMuted: true }))
+    }
+    onDone('companion muted', { display: 'system' })
+    return null
+  }
+
+  if (arg === 'on') {
+    if (config.companionMuted === true) {
+      saveGlobalConfig(c => ({ ...c, companionMuted: false }))
+    }
+    onDone('companion unmuted', { display: 'system' })
+    return null
+  }
+
+  if (!isBuddyLive()) {
+    onDone('buddy is unavailable on this configuration', {
+      display: 'system',
+    })
+    return null
+  }
+
+  if (arg === 'pet') {
+    const companion = getCompanion()
+    if (!companion) {
+      onDone('no companion yet · run /buddy first', { display: 'system' })
+      return null
+    }
+    if (config.companionMuted === true) {
+      saveGlobalConfig(c => ({ ...c, companionMuted: false }))
+    }
+    context.setAppState((s: any) => ({ ...s, companionPetAt: Date.now() }))
+    onDone(`petted ${companion.name}`, { display: 'system' })
+    return null
+  }
+
+  // Unmute if muted
+  if (config.companionMuted === true) {
+    saveGlobalConfig(c => ({ ...c, companionMuted: false }))
+  }
+
+  // Show existing companion
+  const existing = getCompanion()
+  if (existing) {
+    return (
+      <CompanionCard
+        bones={existing}
+        soul={{
+          name: existing.name,
+          personality: existing.personality,
+          hatchedAt: existing.hatchedAt,
+        }}
+      />
+    )
+  }
+
+  // Hatch new companion
+  const setReaction = (reaction: string | undefined) => {
+    context.setAppState((s: any) => ({ ...s, companionReaction: reaction }))
+  }
+  const soul = hatchCompanion(setReaction)
+  const { bones } = roll(companionUserId())
+
+  return <HatchingView bones={bones} soul={soul} onDone={onDone} />
+}
diff --git a/src/commands/buddy/index.ts b/src/commands/buddy/index.ts
new file mode 100644
index 0000000..725f2a2
--- /dev/null
+++ b/src/commands/buddy/index.ts
@@ -0,0 +1,16 @@
+import type { Command } from '../../types/command.js'
+import { isBuddyLive } from '../../buddy/useBuddyNotification.js'
+
+const buddy = {
+  type: 'local-jsx',
+  name: 'buddy',
+  description: 'Hatch a coding companion \u00b7 pet, off',
+  argumentHint: '[pet|off]',
+  get isHidden() {
+    return !isBuddyLive()
+  },
+  immediate: true,
+  load: () => import('./buddy.js'),
+} satisfies Command
+
+export default buddy
diff --git a/src/commands/detach/detach.ts b/src/commands/detach/detach.ts
new file mode 100644
index 0000000..4c03d65
--- /dev/null
+++ b/src/commands/detach/detach.ts
@@ -0,0 +1,88 @@
+import type { LocalCommandCall } from '../../types/command.js'
+import { removeSlaveClient, getAllSlaveClients } from '../../hooks/useMasterMonitor.js'
+import { getPipeIpc } from '../../utils/pipeTransport.js'
+
+export const call: LocalCommandCall = async (args, context) => {
+  const currentState = context.getAppState()
+
+  if (getPipeIpc(currentState).role === 'standalone') {
+    return { type: 'text', value: 'Not attached to any CLI.' }
+  }
+
+  if (getPipeIpc(currentState).role === 'slave') {
+    return {
+      type: 'text',
+      value: 'This CLI is in slave mode. The master must detach.',
+    }
+  }
+
+  // Master mode
+  const targetName = args.trim()
+
+  if (targetName) {
+    // Detach from a specific slave
+    const client = removeSlaveClient(targetName)
+    if (!client) {
+      return {
+        type: 'text',
+        value: `Not attached to "${targetName}". Use /status to see connected slaves.`,
+      }
+    }
+
+    try {
+      client.send({ type: 'detach' })
+    } catch {
+      // Socket may already be closed
+    }
+    client.disconnect()
+
+    // Remove slave from state
+    context.setAppState((prev) => {
+      const { [targetName]: _removed, ...remainingSlaves } = getPipeIpc(prev).slaves
+      const hasSlaves = Object.keys(remainingSlaves).length > 0
+      return {
+        ...prev,
+        pipeIpc: {
+          ...getPipeIpc(prev),
+          role: hasSlaves ? 'master' : 'standalone',
+          slaves: remainingSlaves,
+        },
+      }
+    })
+
+    return {
+      type: 'text',
+      value: `Detached from "${targetName}".`,
+    }
+  }
+
+  // No target specified — detach from ALL slaves
+  const allClients = getAllSlaveClients()
+  const slaveNames = Array.from(allClients.keys())
+
+  for (const name of slaveNames) {
+    const client = removeSlaveClient(name)
+    if (client) {
+      try {
+        client.send({ type: 'detach' })
+      } catch {
+        // Ignore
+      }
+      client.disconnect()
+    }
+  }
+
+  context.setAppState((prev) => ({
+    ...prev,
+    pipeIpc: {
+      ...getPipeIpc(prev),
+      role: 'standalone',
+      slaves: {},
+    },
+  }))
+
+  return {
+    type: 'text',
+    value: `Detached from ${slaveNames.length} slave(s): ${slaveNames.join(', ')}. Back to standalone mode.`,
+  }
+}
diff --git a/src/commands/detach/index.ts b/src/commands/detach/index.ts
new file mode 100644
index 0000000..adac6a0
--- /dev/null
+++ b/src/commands/detach/index.ts
@@ -0,0 +1,12 @@
+import type { Command } from '../../commands.js'
+
+const detach = {
+  type: 'local',
+  name: 'detach',
+  description: 'Detach from a slave CLI (or all slaves if no name given)',
+  argumentHint: '[pipe-name]',
+  supportsNonInteractive: false,
+  load: () => import('./detach.js'),
+} satisfies Command
+
+export default detach
diff --git a/src/commands/force-snip.ts b/src/commands/force-snip.ts
new file mode 100644
index 0000000..6d1a355
--- /dev/null
+++ b/src/commands/force-snip.ts
@@ -0,0 +1,59 @@
+import { randomUUID } from 'crypto'
+import type { Command, LocalCommandCall } from '../types/command.js'
+import type { Message } from '../types/message.js'
+
+/**
+ * Insert a snip boundary into the message array.
+ *
+ * A snip boundary is a system message that marks everything before it as
+ * "snipped". During the next query cycle, `snipCompactIfNeeded` (in
+ * services/compact/snipCompact.ts) detects this boundary and removes — or
+ * collapses — the older messages so they no longer consume context-window
+ * tokens. The REPL keeps the full history for UI scrollback; the boundary
+ * only affects model-facing projections.
+ *
+ * The `snipMetadata.removedUuids` field tells downstream consumers
+ * (sessionStorage persistence, snipProjection) which messages were removed.
+ */
+const call: LocalCommandCall = async (_args, context) => {
+  const { messages, setMessages } = context
+
+  if (messages.length === 0) {
+    return { type: 'text', value: 'No messages to snip.' }
+  }
+
+  // Collect UUIDs of every message that will be snipped (everything currently
+  // in the conversation). The next call to `snipCompactIfNeeded` will honour
+  // the boundary and strip these from the model-facing view.
+  const removedUuids = messages.map((m) => m.uuid)
+
+  const boundaryMessage: Message = {
+    type: 'system',
+    subtype: 'snip_boundary',
+    content: '[snip] Conversation history before this point has been snipped.',
+    isMeta: true,
+    timestamp: new Date().toISOString(),
+    uuid: randomUUID(),
+    snipMetadata: {
+      removedUuids,
+    },
+  } as Message // subtype is feature-gated; cast through Message
+
+  setMessages((prev) => [...prev, boundaryMessage])
+
+  return {
+    type: 'text',
+    value: `Snipped ${removedUuids.length} message(s). Older history will be excluded from the next model query.`,
+  }
+}
+
+const forceSnip = {
+  type: 'local',
+  name: 'force-snip',
+  description: 'Force snip conversation history at current point',
+  supportsNonInteractive: true,
+  isHidden: true,
+  load: () => Promise.resolve({ call }),
+} satisfies Command
+
+export default forceSnip
diff --git a/src/commands/fork/fork.tsx b/src/commands/fork/fork.tsx
new file mode 100644
index 0000000..1cc5d42
--- /dev/null
+++ b/src/commands/fork/fork.tsx
@@ -0,0 +1,287 @@
+import { randomUUID, type UUID } from 'crypto'
+import { mkdir, readFile, writeFile } from 'fs/promises'
+import { getOriginalCwd, getSessionId } from '../../bootstrap/state.js'
+import type { LocalJSXCommandContext } from '../../commands.js'
+import { logEvent } from '../../services/analytics/index.js'
+import type { LocalJSXCommandOnDone } from '../../types/command.js'
+import type {
+  ContentReplacementEntry,
+  Entry,
+  LogOption,
+  SerializedMessage,
+  TranscriptMessage,
+} from '../../types/logs.js'
+import { parseJSONL } from '../../utils/json.js'
+import {
+  getProjectDir,
+  getTranscriptPath,
+  getTranscriptPathForSession,
+  isTranscriptMessage,
+  saveCustomTitle,
+  searchSessionsByCustomTitle,
+} from '../../utils/sessionStorage.js'
+import { jsonStringify } from '../../utils/slowOperations.js'
+import { escapeRegExp } from '../../utils/stringUtils.js'
+
+type TranscriptEntry = TranscriptMessage & {
+  forkedFrom?: {
+    sessionId: string
+    messageUuid: UUID
+  }
+}
+
+/**
+ * Derive a single-line title base from the first user message.
+ * Collapses whitespace so multiline first messages don't break the saved title.
+ */
+function deriveFirstPrompt(
+  firstUserMessage: Extract<SerializedMessage, { type: 'user' }> | undefined,
+): string {
+  const content = firstUserMessage?.message?.content
+  if (!content) return 'Forked conversation'
+  const raw =
+    typeof content === 'string'
+      ? content
+      : content.find(
+          (block): block is { type: 'text'; text: string } =>
+            block.type === 'text',
+        )?.text
+  if (!raw) return 'Forked conversation'
+  return (
+    raw.replace(/\s+/g, ' ').trim().slice(0, 100) || 'Forked conversation'
+  )
+}
+
+/**
+ * Creates a fork of the current conversation by copying from the transcript file.
+ * Preserves all original metadata (timestamps, gitBranch, etc.) while updating
+ * sessionId and adding forkedFrom traceability.
+ */
+async function createFork(customTitle?: string): Promise<{
+  sessionId: UUID
+  title: string | undefined
+  forkPath: string
+  serializedMessages: SerializedMessage[]
+  contentReplacementRecords: ContentReplacementEntry['replacements']
+}> {
+  const forkSessionId = randomUUID() as UUID
+  const originalSessionId = getSessionId()
+  const projectDir = getProjectDir(getOriginalCwd())
+  const forkSessionPath = getTranscriptPathForSession(forkSessionId)
+  const currentTranscriptPath = getTranscriptPath()
+
+  // Ensure project directory exists
+  await mkdir(projectDir, { recursive: true, mode: 0o700 })
+
+  // Read current transcript file
+  let transcriptContent: Buffer
+  try {
+    transcriptContent = await readFile(currentTranscriptPath)
+  } catch {
+    throw new Error('No conversation to fork')
+  }
+
+  if (transcriptContent.length === 0) {
+    throw new Error('No conversation to fork')
+  }
+
+  // Parse all transcript entries (messages + metadata entries like content-replacement)
+  const entries = parseJSONL<Entry>(transcriptContent)
+
+  // Filter to only main conversation messages (exclude sidechains and non-message entries)
+  const mainConversationEntries = entries.filter(
+    (entry): entry is TranscriptMessage =>
+      isTranscriptMessage(entry) && !entry.isSidechain,
+  )
+
+  // Content-replacement entries for the original session. These record which
+  // tool_result blocks were replaced with previews by the per-message budget.
+  // Without them in the fork JSONL, resuming the fork reconstructs state with
+  // an empty replacements Map, causing prompt cache misses.
+  const contentReplacementRecords = entries
+    .filter(
+      (entry): entry is ContentReplacementEntry =>
+        entry.type === 'content-replacement' &&
+        entry.sessionId === originalSessionId,
+    )
+    .flatMap(entry => entry.replacements)
+
+  if (mainConversationEntries.length === 0) {
+    throw new Error('No messages to fork')
+  }
+
+  // Build forked entries with new sessionId and preserved metadata
+  let parentUuid: UUID | null = null
+  const lines: string[] = []
+  const serializedMessages: SerializedMessage[] = []
+
+  for (const entry of mainConversationEntries) {
+    // Create forked transcript entry preserving all original metadata
+    const forkedEntry: TranscriptEntry = {
+      ...entry,
+      sessionId: forkSessionId,
+      parentUuid,
+      isSidechain: false,
+      forkedFrom: {
+        sessionId: originalSessionId,
+        messageUuid: entry.uuid,
+      },
+    }
+
+    // Build serialized message for LogOption
+    const serialized: SerializedMessage = {
+      ...entry,
+      sessionId: forkSessionId,
+    }
+
+    serializedMessages.push(serialized)
+    lines.push(jsonStringify(forkedEntry))
+    if (entry.type !== 'progress') {
+      parentUuid = entry.uuid
+    }
+  }
+
+  // Append content-replacement entry (if any) with the fork's sessionId.
+  if (contentReplacementRecords.length > 0) {
+    const forkedReplacementEntry: ContentReplacementEntry = {
+      type: 'content-replacement',
+      sessionId: forkSessionId,
+      replacements: contentReplacementRecords,
+    }
+    lines.push(jsonStringify(forkedReplacementEntry))
+  }
+
+  // Write the fork session file
+  await writeFile(forkSessionPath, lines.join('\n') + '\n', {
+    encoding: 'utf8',
+    mode: 0o600,
+  })
+
+  return {
+    sessionId: forkSessionId,
+    title: customTitle,
+    forkPath: forkSessionPath,
+    serializedMessages,
+    contentReplacementRecords,
+  }
+}
+
+/**
+ * Generates a unique fork name by checking for collisions with existing session names.
+ * If "baseName (Fork)" already exists, tries "baseName (Fork 2)", "baseName (Fork 3)", etc.
+ */
+async function getUniqueForkName(baseName: string): Promise<string> {
+  const candidateName = `${baseName} (Fork)`
+
+  // Check if this exact name already exists
+  const existingWithExactName = await searchSessionsByCustomTitle(
+    candidateName,
+    { exact: true },
+  )
+
+  if (existingWithExactName.length === 0) {
+    return candidateName
+  }
+
+  // Name collision - find a unique numbered suffix
+  const existingForks = await searchSessionsByCustomTitle(`${baseName} (Fork`)
+
+  // Extract existing fork numbers to find the next available
+  const usedNumbers = new Set<number>([1]) // Consider " (Fork)" as number 1
+  const forkNumberPattern = new RegExp(
+    `^${escapeRegExp(baseName)} \\(Fork(?: (\\d+))?\\)$`,
+  )
+
+  for (const session of existingForks) {
+    const match = session.customTitle?.match(forkNumberPattern)
+    if (match) {
+      if (match[1]) {
+        usedNumbers.add(parseInt(match[1], 10))
+      } else {
+        usedNumbers.add(1) // " (Fork)" without number is treated as 1
+      }
+    }
+  }
+
+  // Find the next available number
+  let nextNumber = 2
+  while (usedNumbers.has(nextNumber)) {
+    nextNumber++
+  }
+
+  return `${baseName} (Fork ${nextNumber})`
+}
+
+export async function call(
+  onDone: LocalJSXCommandOnDone,
+  context: LocalJSXCommandContext,
+  args: string,
+): Promise<React.ReactNode> {
+  const customTitle = args?.trim() || undefined
+
+  const originalSessionId = getSessionId()
+
+  try {
+    const {
+      sessionId,
+      title,
+      forkPath,
+      serializedMessages,
+      contentReplacementRecords,
+    } = await createFork(customTitle)
+
+    // Build LogOption for resume
+    const now = new Date()
+    const firstPrompt = deriveFirstPrompt(
+      serializedMessages.find(m => m.type === 'user'),
+    )
+
+    // Save custom title with " (Fork)" suffix
+    // Handle collisions by adding a number suffix (e.g., " (Fork 2)", " (Fork 3)")
+    const baseName = title ?? firstPrompt
+    const effectiveTitle = await getUniqueForkName(baseName)
+    await saveCustomTitle(sessionId, effectiveTitle, forkPath)
+
+    logEvent('tengu_conversation_forked', {
+      message_count: serializedMessages.length,
+      has_custom_title: !!title,
+    })
+
+    const forkLog: LogOption = {
+      date: now.toISOString().split('T')[0]!,
+      messages: serializedMessages,
+      fullPath: forkPath,
+      value: now.getTime(),
+      created: now,
+      modified: now,
+      firstPrompt,
+      messageCount: serializedMessages.length,
+      isSidechain: false,
+      sessionId,
+      customTitle: effectiveTitle,
+      contentReplacements: contentReplacementRecords,
+    }
+
+    // Resume into the fork
+    const titleInfo = title ? ` "${title}"` : ''
+    const resumeHint = `\nTo resume the original: claude -r ${originalSessionId}`
+    const successMessage = `Forked conversation${titleInfo}. You are now in the fork.${resumeHint}`
+
+    if (context.resume) {
+      await context.resume(sessionId, forkLog, 'fork')
+      onDone(successMessage, { display: 'system' })
+    } else {
+      // Fallback if resume not available
+      onDone(
+        `Forked conversation${titleInfo}. Resume with: /resume ${sessionId}`,
+      )
+    }
+
+    return null
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : 'Unknown error occurred'
+    onDone(`Failed to fork conversation: ${message}`)
+    return null
+  }
+}
diff --git a/src/commands/fork/index.ts b/src/commands/fork/index.ts
new file mode 100644
index 0000000..183a3a2
--- /dev/null
+++ b/src/commands/fork/index.ts
@@ -0,0 +1,13 @@
+import type { Command } from '../../commands.js'
+
+const fork = {
+  type: 'local-jsx',
+  name: 'fork',
+  description: 'Create a fork of the current conversation at this point',
+  argumentHint: '[name]',
+  isEnabled: () => true,
+  isHidden: false,
+  load: () => import('./fork.js'),
+} satisfies Command
+
+export default fork
diff --git a/src/commands/history/history.ts b/src/commands/history/history.ts
new file mode 100644
index 0000000..41d4e45
--- /dev/null
+++ b/src/commands/history/history.ts
@@ -0,0 +1,83 @@
+import type { LocalCommandCall } from '../../types/command.js'
+import { getPipeIpc } from '../../utils/pipeTransport.js'
+
+export const call: LocalCommandCall = async (args, context) => {
+  const currentState = context.getAppState()
+
+  if (getPipeIpc(currentState).role !== 'master') {
+    return {
+      type: 'text',
+      value: 'Not in master mode. Use /attach <pipe-name> first.',
+    }
+  }
+
+  const parts = args.trim().split(/\s+/)
+  const targetName = parts[0]
+
+  if (!targetName) {
+    // Show list of slaves
+    const slaveNames = Object.keys(getPipeIpc(currentState).slaves)
+    if (slaveNames.length === 0) {
+      return { type: 'text', value: 'No slaves connected.' }
+    }
+    return {
+      type: 'text',
+      value: `Usage: /history <pipe-name>\nConnected slaves: ${slaveNames.join(', ')}`,
+    }
+  }
+
+  const slave = getPipeIpc(currentState).slaves[targetName]
+  if (!slave) {
+    return {
+      type: 'text',
+      value: `Not attached to "${targetName}". Use /status to see connected slaves.`,
+    }
+  }
+
+  // Parse --last N
+  let limit = slave.history.length
+  const lastIdx = parts.indexOf('--last')
+  if (lastIdx !== -1 && parts[lastIdx + 1]) {
+    const n = parseInt(parts[lastIdx + 1], 10)
+    if (!isNaN(n) && n > 0) {
+      limit = n
+    }
+  }
+
+  const entries = slave.history.slice(-limit)
+
+  if (entries.length === 0) {
+    return {
+      type: 'text',
+      value: `No session history for "${targetName}" yet.`,
+    }
+  }
+
+  const lines: string[] = [
+    `Session history for "${targetName}" (${entries.length}/${slave.history.length} entries):`,
+    '',
+  ]
+
+  for (const entry of entries) {
+    const time = entry.timestamp.slice(11, 19) // HH:MM:SS
+    const prefix = formatEntryType(entry.type)
+    const content = entry.content.length > 200
+      ? entry.content.slice(0, 200) + '...'
+      : entry.content
+    lines.push(`[${time}] ${prefix} ${content}`)
+  }
+
+  return { type: 'text', value: lines.join('\n') }
+}
+
+function formatEntryType(type: string): string {
+  switch (type) {
+    case 'prompt': return '[PROMPT]'
+    case 'stream': return '[AI]    '
+    case 'tool_start': return '[TOOL>] '
+    case 'tool_result': return '[TOOL<] '
+    case 'done': return '[DONE]  '
+    case 'error': return '[ERROR] '
+    default: return `[${type}]`
+  }
+}
diff --git a/src/commands/history/index.ts b/src/commands/history/index.ts
new file mode 100644
index 0000000..3fa8a32
--- /dev/null
+++ b/src/commands/history/index.ts
@@ -0,0 +1,12 @@
+import type { Command } from '../../commands.js'
+
+const history = {
+  type: 'local',
+  name: 'history',
+  description: 'View session transcript of a connected slave CLI',
+  argumentHint: '<pipe-name> [--last N]',
+  supportsNonInteractive: false,
+  load: () => import('./history.js'),
+} satisfies Command
+
+export default history
diff --git a/src/commands/peers/index.ts b/src/commands/peers/index.ts
new file mode 100644
index 0000000..c573114
--- /dev/null
+++ b/src/commands/peers/index.ts
@@ -0,0 +1,12 @@
+import type { Command } from '../../commands.js'
+
+const peers = {
+  type: 'local',
+  name: 'peers',
+  aliases: ['who'],
+  description: 'List connected Claude Code peers',
+  supportsNonInteractive: true,
+  load: () => import('./peers.js'),
+} satisfies Command
+
+export default peers
diff --git a/src/commands/peers/peers.ts b/src/commands/peers/peers.ts
new file mode 100644
index 0000000..aed37d3
--- /dev/null
+++ b/src/commands/peers/peers.ts
@@ -0,0 +1,61 @@
+import type { LocalCommandCall } from '../../types/command.js'
+import { listPeers, isPeerAlive } from '../../utils/udsClient.js'
+import { getUdsMessagingSocketPath } from '../../utils/udsMessaging.js'
+
+export const call: LocalCommandCall = async (_args, _context) => {
+  const mySocket = getUdsMessagingSocketPath()
+  const peers = await listPeers()
+
+  const lines: string[] = []
+
+  // Show own socket
+  lines.push(`Your socket: ${mySocket ?? '(not started)'}`)
+  lines.push('')
+
+  if (peers.length === 0) {
+    lines.push('No other Claude Code peers found.')
+  } else {
+    lines.push(`Peers (${peers.length}):`)
+    lines.push('')
+
+    for (const peer of peers) {
+      const alive = peer.messagingSocketPath
+        ? await isPeerAlive(peer.messagingSocketPath)
+        : false
+      const status = alive ? 'reachable' : 'unreachable'
+      const label = peer.name ?? peer.kind ?? 'interactive'
+      const cwd = peer.cwd ? `  cwd: ${peer.cwd}` : ''
+      const age = peer.startedAt
+        ? `  started: ${formatAge(peer.startedAt)}`
+        : ''
+
+      lines.push(
+        `  [${status}] PID ${peer.pid} (${label})${cwd}${age}`,
+      )
+      if (peer.messagingSocketPath) {
+        lines.push(`           socket: ${peer.messagingSocketPath}`)
+      }
+      if (peer.sessionId) {
+        lines.push(`           session: ${peer.sessionId}`)
+      }
+    }
+  }
+
+  lines.push('')
+  lines.push(
+    'To message a peer: use SendMessage with to="uds:<socket-path>"',
+  )
+
+  return { type: 'text', value: lines.join('\n') }
+}
+
+function formatAge(startedAt: number): string {
+  const elapsed = Date.now() - startedAt
+  const seconds = Math.floor(elapsed / 1000)
+  if (seconds < 60) return `${seconds}s ago`
+  const minutes = Math.floor(seconds / 60)
+  if (minutes < 60) return `${minutes}m ago`
+  const hours = Math.floor(minutes / 60)
+  const remainingMinutes = minutes % 60
+  return `${hours}h ${remainingMinutes}m ago`
+}
diff --git a/src/commands/pipe-status/index.ts b/src/commands/pipe-status/index.ts
new file mode 100644
index 0000000..dc9e9f4
--- /dev/null
+++ b/src/commands/pipe-status/index.ts
@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js'
+
+const pipeStatus = {
+  type: 'local',
+  name: 'pipe-status',
+  description: 'Show status of all connected slave CLIs',
+  supportsNonInteractive: false,
+  load: () => import('./pipe-status.js'),
+} satisfies Command
+
+export default pipeStatus
diff --git a/src/commands/pipe-status/pipe-status.ts b/src/commands/pipe-status/pipe-status.ts
new file mode 100644
index 0000000..073c366
--- /dev/null
+++ b/src/commands/pipe-status/pipe-status.ts
@@ -0,0 +1,59 @@
+import type { LocalCommandCall } from '../../types/command.js'
+import { getAllSlaveClients } from '../../hooks/useMasterMonitor.js'
+import { getPipeIpc } from '../../utils/pipeTransport.js'
+
+export const call: LocalCommandCall = async (_args, context) => {
+  const currentState = context.getAppState()
+
+  if (getPipeIpc(currentState).role === 'standalone') {
+    return {
+      type: 'text',
+      value: 'Standalone mode — not connected to any CLIs.\nUse /attach <pipe-name> to connect to a slave.',
+    }
+  }
+
+  if (getPipeIpc(currentState).role === 'slave') {
+    return {
+      type: 'text',
+      value: `Slave mode — controlled by "${getPipeIpc(currentState).attachedBy}".\nAll session data is being reported to the master.`,
+    }
+  }
+
+  // Master mode
+  const slaves = getPipeIpc(currentState).slaves
+  const slaveNames = Object.keys(slaves)
+  const clients = getAllSlaveClients()
+
+  if (slaveNames.length === 0) {
+    return {
+      type: 'text',
+      value: 'Master mode but no slaves connected.\nUse /attach <pipe-name> to connect.',
+    }
+  }
+
+  const lines: string[] = [
+    `Master mode — ${slaveNames.length} slave(s) connected:`,
+    '',
+  ]
+
+  for (const name of slaveNames) {
+    const slave = slaves[name]!
+    const client = clients.get(name)
+    const connected = client?.connected ? 'connected' : 'disconnected'
+    const historyCount = slave.history.length
+    const connectedAt = slave.connectedAt.slice(11, 19)
+
+    lines.push(`  ${name}`)
+    lines.push(`    Status:    ${slave.status} (${connected})`)
+    lines.push(`    Connected: ${connectedAt}`)
+    lines.push(`    History:   ${historyCount} entries`)
+    lines.push('')
+  }
+
+  lines.push('Commands:')
+  lines.push('  /send <name> <msg>  — Send a task to a slave')
+  lines.push('  /history <name>     — View slave session transcript')
+  lines.push('  /detach [name]      — Disconnect from a slave (or all)')
+
+  return { type: 'text', value: lines.join('\n') }
+}
diff --git a/src/commands/pipes/index.ts b/src/commands/pipes/index.ts
new file mode 100644
index 0000000..e1ee798
--- /dev/null
+++ b/src/commands/pipes/index.ts
@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js'
+
+const pipes = {
+  type: 'local',
+  name: 'pipes',
+  description: 'List available named pipes for terminal-to-terminal communication',
+  supportsNonInteractive: false,
+  load: () => import('./pipes.js'),
+} satisfies Command
+
+export default pipes
diff --git a/src/commands/pipes/pipes.ts b/src/commands/pipes/pipes.ts
new file mode 100644
index 0000000..4974016
--- /dev/null
+++ b/src/commands/pipes/pipes.ts
@@ -0,0 +1,45 @@
+import type { LocalCommandCall } from '../../types/command.js'
+import { listPipes, isPipeAlive, getPipeIpc } from '../../utils/pipeTransport.js'
+
+export const call: LocalCommandCall = async (_args, context) => {
+  const currentState = context.getAppState()
+  const myName = getPipeIpc(currentState).serverName
+  const role = getPipeIpc(currentState).role
+
+  const allPipes = await listPipes()
+
+  const lines: string[] = []
+
+  // Show own pipe name and status
+  lines.push(`Your pipe:  ${myName ?? '(not started)'}`)
+  lines.push(`Role:       ${role}`)
+
+  if (role === 'master') {
+    const slaveNames = Object.keys(getPipeIpc(currentState).slaves)
+    lines.push(`Slaves (${slaveNames.length}): ${slaveNames.join(', ') || 'none'}`)
+  } else if (role === 'slave') {
+    lines.push(`Controlled by: ${getPipeIpc(currentState).attachedBy}`)
+  }
+
+  lines.push('')
+
+  // List other pipes with liveness check
+  const otherPipes = allPipes.filter((p) => p !== myName)
+  if (otherPipes.length === 0) {
+    lines.push('No other pipes found.')
+  } else {
+    lines.push(`Other pipes (${otherPipes.length}):`)
+    for (const name of otherPipes) {
+      const alive = await isPipeAlive(name)
+      const status = alive ? 'alive' : 'stale'
+      const isAttached = getPipeIpc(currentState).slaves[name] ? ' [attached]' : ''
+      lines.push(`  ${name}  [${status}]${isAttached}`)
+    }
+  }
+
+  lines.push('')
+  lines.push('To attach: /attach <pipe-name>')
+  lines.push('To send:   /send <pipe-name> <message>')
+
+  return { type: 'text', value: lines.join('\n') }
+}
diff --git a/src/commands/proactive.ts b/src/commands/proactive.ts
new file mode 100644
index 0000000..7b85954
--- /dev/null
+++ b/src/commands/proactive.ts
@@ -0,0 +1 @@
+export default null
diff --git a/src/commands/remoteControlServer/index.ts b/src/commands/remoteControlServer/index.ts
new file mode 100644
index 0000000..7b85954
--- /dev/null
+++ b/src/commands/remoteControlServer/index.ts
@@ -0,0 +1 @@
+export default null
diff --git a/src/commands/send/index.ts b/src/commands/send/index.ts
new file mode 100644
index 0000000..85c908c
--- /dev/null
+++ b/src/commands/send/index.ts
@@ -0,0 +1,12 @@
+import type { Command } from '../../commands.js'
+
+const send = {
+  type: 'local',
+  name: 'send',
+  description: 'Send a prompt/task to a connected slave CLI',
+  argumentHint: '<pipe-name> <message>',
+  supportsNonInteractive: false,
+  load: () => import('./send.js'),
+} satisfies Command
+
+export default send
diff --git a/src/commands/send/send.ts b/src/commands/send/send.ts
new file mode 100644
index 0000000..158e5c5
--- /dev/null
+++ b/src/commands/send/send.ts
@@ -0,0 +1,94 @@
+import type { LocalCommandCall } from '../../types/command.js'
+import { getSlaveClient } from '../../hooks/useMasterMonitor.js'
+import { getPipeIpc } from '../../utils/pipeTransport.js'
+
+export const call: LocalCommandCall = async (args, context) => {
+  const currentState = context.getAppState()
+
+  if (getPipeIpc(currentState).role !== 'master') {
+    return {
+      type: 'text',
+      value: 'Not in master mode. Use /attach <pipe-name> first.',
+    }
+  }
+
+  // Parse: first word is pipe name, rest is the message
+  const trimmed = args.trim()
+  const spaceIdx = trimmed.indexOf(' ')
+  if (spaceIdx === -1) {
+    return {
+      type: 'text',
+      value: 'Usage: /send <pipe-name> <message>',
+    }
+  }
+
+  const targetName = trimmed.slice(0, spaceIdx)
+  const message = trimmed.slice(spaceIdx + 1).trim()
+
+  if (!message) {
+    return {
+      type: 'text',
+      value: 'Usage: /send <pipe-name> <message>',
+    }
+  }
+
+  const client = getSlaveClient(targetName)
+  if (!client) {
+    return {
+      type: 'text',
+      value: `Not attached to "${targetName}". Use /status to see connected slaves.`,
+    }
+  }
+
+  if (!client.connected) {
+    return {
+      type: 'text',
+      value: `Connection to "${targetName}" is closed. Use /detach ${targetName} and re-attach.`,
+    }
+  }
+
+  try {
+    client.send({
+      type: 'prompt',
+      data: message,
+    })
+
+    // Record the sent prompt in history
+    context.setAppState((prev) => {
+      const slave = getPipeIpc(prev).slaves[targetName]
+      if (!slave) return prev
+      return {
+        ...prev,
+        pipeIpc: {
+          ...getPipeIpc(prev),
+          slaves: {
+            ...getPipeIpc(prev).slaves,
+            [targetName]: {
+              ...slave,
+              status: 'busy' as const,
+              history: [
+                ...slave.history,
+                {
+                  type: 'prompt' as const,
+                  content: message,
+                  from: getPipeIpc(currentState).serverName ?? 'master',
+                  timestamp: new Date().toISOString(),
+                },
+              ],
+            },
+          },
+        },
+      }
+    })
+
+    return {
+      type: 'text',
+      value: `Sent to "${targetName}": ${message.slice(0, 100)}${message.length > 100 ? '...' : ''}`,
+    }
+  } catch (err) {
+    return {
+      type: 'text',
+      value: `Failed to send to "${targetName}": ${err instanceof Error ? err.message : String(err)}`,
+    }
+  }
+}
diff --git a/src/commands/subscribe-pr.ts b/src/commands/subscribe-pr.ts
new file mode 100644
index 0000000..a38c4b3
--- /dev/null
+++ b/src/commands/subscribe-pr.ts
@@ -0,0 +1,174 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import type { Command, LocalCommandCall } from '../types/command.js'
+import { detectCurrentRepositoryWithHost } from '../utils/detectRepository.js'
+import { getClaudeConfigHomeDir } from '../utils/envUtils.js'
+
+/**
+ * File-backed store for PR webhook subscriptions.
+ * Each subscription tracks the repo + PR number so the bridge layer
+ * (useReplBridge / webhookSanitizer) can filter inbound events.
+ */
+interface PRSubscription {
+  repo: string // "owner/repo"
+  prNumber: number
+  subscribedAt: string // ISO 8601
+}
+
+function getSubscriptionsFilePath(): string {
+  return path.join(getClaudeConfigHomeDir(), 'pr-subscriptions.json')
+}
+
+function readSubscriptions(): PRSubscription[] {
+  const filePath = getSubscriptionsFilePath()
+  try {
+    const raw = fs.readFileSync(filePath, 'utf-8')
+    return JSON.parse(raw) as PRSubscription[]
+  } catch {
+    return []
+  }
+}
+
+function writeSubscriptions(subs: PRSubscription[]): void {
+  const filePath = getSubscriptionsFilePath()
+  const dir = path.dirname(filePath)
+  fs.mkdirSync(dir, { recursive: true })
+  fs.writeFileSync(filePath, JSON.stringify(subs, null, 2), 'utf-8')
+}
+
+/**
+ * Parse a PR URL or number into { repo, prNumber }.
+ *
+ * Accepts:
+ *   - Full URL:  https://github.com/owner/repo/pull/123
+ *   - Short ref: owner/repo#123
+ *   - Bare number: 123  (uses the current git repository)
+ */
+async function parsePRArg(
+  arg: string,
+): Promise<{ repo: string; prNumber: number } | { error: string }> {
+  const trimmed = arg.trim()
+
+  // Full GitHub PR URL
+  const urlMatch = trimmed.match(
+    /^https?:\/\/[^/]+\/([^/]+\/[^/]+)\/pull\/(\d+)/,
+  )
+  if (urlMatch) {
+    return { repo: urlMatch[1]!, prNumber: parseInt(urlMatch[2]!, 10) }
+  }
+
+  // Short ref: owner/repo#123
+  const shortMatch = trimmed.match(/^([^/]+\/[^/]+)#(\d+)$/)
+  if (shortMatch) {
+    return { repo: shortMatch[1]!, prNumber: parseInt(shortMatch[2]!, 10) }
+  }
+
+  // Bare number — resolve repo from current git checkout
+  const numMatch = trimmed.match(/^#?(\d+)$/)
+  if (numMatch) {
+    const prNumber = parseInt(numMatch[1]!, 10)
+    const detected = await detectCurrentRepositoryWithHost()
+    if (!detected) {
+      return {
+        error:
+          'Could not detect the GitHub repository for the current directory. Provide a full PR URL instead.',
+      }
+    }
+    const repo = `${detected.owner}/${detected.repo}`
+    return { repo, prNumber }
+  }
+
+  return {
+    error: `Unrecognised PR reference: "${trimmed}". Expected a PR URL, owner/repo#123, or a PR number.`,
+  }
+}
+
+const call: LocalCommandCall = async (args, _context) => {
+  const trimmed = args.trim()
+
+  // List current subscriptions
+  if (!trimmed || trimmed === '--list' || trimmed === 'list') {
+    const subs = readSubscriptions()
+    if (subs.length === 0) {
+      return {
+        type: 'text',
+        value:
+          'No active PR subscriptions. Usage: /subscribe-pr <pr-url-or-number>',
+      }
+    }
+    const lines = subs.map(
+      (s) => `  ${s.repo}#${s.prNumber}  (since ${s.subscribedAt})`,
+    )
+    return {
+      type: 'text',
+      value: `Active PR subscriptions:\n${lines.join('\n')}`,
+    }
+  }
+
+  // Unsubscribe
+  if (trimmed.startsWith('--remove ') || trimmed.startsWith('remove ')) {
+    const rest = trimmed.replace(/^(--remove|remove)\s+/, '')
+    const parsed = await parsePRArg(rest)
+    if ('error' in parsed) {
+      return { type: 'text', value: parsed.error }
+    }
+    const subs = readSubscriptions()
+    const before = subs.length
+    const after = subs.filter(
+      (s) => !(s.repo === parsed.repo && s.prNumber === parsed.prNumber),
+    )
+    if (after.length === before) {
+      return {
+        type: 'text',
+        value: `No subscription found for ${parsed.repo}#${parsed.prNumber}.`,
+      }
+    }
+    writeSubscriptions(after)
+    return {
+      type: 'text',
+      value: `Unsubscribed from ${parsed.repo}#${parsed.prNumber}.`,
+    }
+  }
+
+  // Subscribe
+  const parsed = await parsePRArg(trimmed)
+  if ('error' in parsed) {
+    return { type: 'text', value: parsed.error }
+  }
+
+  const subs = readSubscriptions()
+  const existing = subs.find(
+    (s) => s.repo === parsed.repo && s.prNumber === parsed.prNumber,
+  )
+  if (existing) {
+    return {
+      type: 'text',
+      value: `Already subscribed to ${parsed.repo}#${parsed.prNumber} (since ${existing.subscribedAt}).`,
+    }
+  }
+
+  subs.push({
+    repo: parsed.repo,
+    prNumber: parsed.prNumber,
+    subscribedAt: new Date().toISOString(),
+  })
+  writeSubscriptions(subs)
+
+  return {
+    type: 'text',
+    value: `Subscribed to ${parsed.repo}#${parsed.prNumber}. You will receive notifications for comments, CI status, and reviews.`,
+  }
+}
+
+const subscribePr = {
+  type: 'local',
+  name: 'subscribe-pr',
+  aliases: ['watch-pr'],
+  description: 'Subscribe to GitHub PR activity (comments, CI, reviews)',
+  argumentHint: '<pr-url-or-number>',
+  supportsNonInteractive: false,
+  isHidden: true,
+  load: () => Promise.resolve({ call }),
+} satisfies Command
+
+export default subscribePr
diff --git a/src/commands/torch.ts b/src/commands/torch.ts
new file mode 100644
index 0000000..7b85954
--- /dev/null
+++ b/src/commands/torch.ts
@@ -0,0 +1 @@
+export default null
diff --git a/src/commands/workflows/index.ts b/src/commands/workflows/index.ts
new file mode 100644
index 0000000..d7d6447
--- /dev/null
+++ b/src/commands/workflows/index.ts
@@ -0,0 +1,25 @@
+import type { Command, LocalCommandCall } from '../../types/command.js'
+import { getWorkflowCommands } from '../../tools/WorkflowTool/createWorkflowCommand.js'
+import { getCwd } from '../../utils/cwd.js'
+
+const call: LocalCommandCall = async (_args, _context) => {
+  const commands = await getWorkflowCommands(getCwd())
+  if (commands.length === 0) {
+    return {
+      type: 'text',
+      value: 'No workflows found. Add workflow files to .claude/workflows/ (YAML or Markdown).',
+    }
+  }
+  const list = commands.map((cmd) => `  /${cmd.name} - ${cmd.description}`).join('\n')
+  return { type: 'text', value: `Available workflows:\n${list}` }
+}
+
+const workflows = {
+  type: 'local',
+  name: 'workflows',
+  description: 'List available workflow scripts',
+  supportsNonInteractive: true,
+  load: () => Promise.resolve({ call }),
+} satisfies Command
+
+export default workflows
diff --git a/src/components/permissions/MonitorPermissionRequest/MonitorPermissionRequest.tsx b/src/components/permissions/MonitorPermissionRequest/MonitorPermissionRequest.tsx
index 0505f19..c54dcde 100644
--- a/src/components/permissions/MonitorPermissionRequest/MonitorPermissionRequest.tsx
+++ b/src/components/permissions/MonitorPermissionRequest/MonitorPermissionRequest.tsx
@@ -1,3 +1,163 @@
-export function MonitorPermissionRequest() {
-  return null
+import React, { useCallback, useMemo } from 'react'
+import { Box, Text, useTheme } from '../../../ink.js'
+import { env } from '../../../utils/env.js'
+import { shouldShowAlwaysAllowOptions } from '../../../utils/permissions/permissionsLoader.js'
+import { truncateToLines } from '../../../utils/stringUtils.js'
+import { logUnaryEvent } from '../../../utils/unaryLogging.js'
+import { PermissionDialog } from '../PermissionDialog.js'
+import {
+  PermissionPrompt,
+  type PermissionPromptOption,
+} from '../PermissionPrompt.js'
+import type { PermissionRequestProps } from '../PermissionRequest.js'
+import { PermissionRuleExplanation } from '../PermissionRuleExplanation.js'
+
+type OptionValue = 'yes' | 'yes-dont-ask-again' | 'no'
+
+/**
+ * Permission request UI for the MonitorTool. Asks the user to confirm
+ * starting a long-running background monitor process.
+ * Follows the FallbackPermissionRequest pattern.
+ */
+export function MonitorPermissionRequest({
+  toolUseConfirm,
+  onDone,
+  onReject,
+  workerBadge,
+}: PermissionRequestProps): React.ReactNode {
+  const [theme] = useTheme()
+
+  const input = toolUseConfirm.input as {
+    command: string
+    description: string
+  }
+
+  const showAlwaysAllowOptions = useMemo(
+    () => shouldShowAlwaysAllowOptions(),
+    [],
+  )
+
+  const options: PermissionPromptOption<OptionValue>[] = useMemo(() => {
+    const opts: PermissionPromptOption<OptionValue>[] = [
+      {
+        label: 'Yes',
+        value: 'yes',
+        feedbackConfig: { type: 'accept' as const },
+      },
+    ]
+    if (showAlwaysAllowOptions) {
+      opts.push({
+        label: (
+          <Text>
+            Yes, and don{'\u2019'}t ask again for{' '}
+            <Text bold>{toolUseConfirm.tool.name}</Text> commands
+          </Text>
+        ),
+        value: 'yes-dont-ask-again',
+      })
+    }
+    opts.push({
+      label: 'No',
+      value: 'no',
+      feedbackConfig: { type: 'reject' as const },
+    })
+    return opts
+  }, [showAlwaysAllowOptions, toolUseConfirm.tool.name])
+
+  const handleSelect = useCallback(
+    (value: OptionValue, feedback?: string) => {
+      switch (value) {
+        case 'yes':
+          logUnaryEvent({
+            completion_type: 'tool_use_single',
+            event: 'accept',
+            metadata: {
+              language_name: 'none',
+              message_id: toolUseConfirm.assistantMessage.message.id,
+              platform: env.platform,
+            },
+          })
+          toolUseConfirm.onAllow(toolUseConfirm.input, [], feedback)
+          onDone()
+          break
+        case 'yes-dont-ask-again':
+          logUnaryEvent({
+            completion_type: 'tool_use_single',
+            event: 'accept',
+            metadata: {
+              language_name: 'none',
+              message_id: toolUseConfirm.assistantMessage.message.id,
+              platform: env.platform,
+            },
+          })
+          toolUseConfirm.onAllow(toolUseConfirm.input, [
+            {
+              type: 'addRules',
+              rules: [{ toolName: toolUseConfirm.tool.name }],
+              behavior: 'allow',
+              destination: 'localSettings',
+            },
+          ])
+          onDone()
+          break
+        case 'no':
+          logUnaryEvent({
+            completion_type: 'tool_use_single',
+            event: 'reject',
+            metadata: {
+              language_name: 'none',
+              message_id: toolUseConfirm.assistantMessage.message.id,
+              platform: env.platform,
+            },
+          })
+          toolUseConfirm.onReject(feedback)
+          onReject()
+          onDone()
+          break
+      }
+    },
+    [toolUseConfirm, onDone, onReject],
+  )
+
+  const handleCancel = useCallback(() => {
+    logUnaryEvent({
+      completion_type: 'tool_use_single',
+      event: 'reject',
+      metadata: {
+        language_name: 'none',
+        message_id: toolUseConfirm.assistantMessage.message.id,
+        platform: env.platform,
+      },
+    })
+    toolUseConfirm.onReject()
+    onReject()
+    onDone()
+  }, [toolUseConfirm, onDone, onReject])
+
+  return (
+    <PermissionDialog
+      title="Monitor"
+      workerBadge={workerBadge}
+    >
+      <Box flexDirection="column" gap={1}>
+        <Box flexDirection="column">
+          <Text bold color={theme.permission}>
+            {input.description}
+          </Text>
+          <Text dimColor>
+            {truncateToLines(input.command, 5)}
+          </Text>
+        </Box>
+        <PermissionRuleExplanation
+          permissionResult={toolUseConfirm.permissionResult}
+          toolType="command"
+        />
+        <PermissionPrompt<OptionValue>
+          options={options}
+          onSelect={handleSelect}
+          onCancel={handleCancel}
+        />
+      </Box>
+    </PermissionDialog>
+  )
 }
diff --git a/src/components/permissions/ReviewArtifactPermissionRequest/ReviewArtifactPermissionRequest.tsx b/src/components/permissions/ReviewArtifactPermissionRequest/ReviewArtifactPermissionRequest.tsx
index 131732c..c4a2650 100644
--- a/src/components/permissions/ReviewArtifactPermissionRequest/ReviewArtifactPermissionRequest.tsx
+++ b/src/components/permissions/ReviewArtifactPermissionRequest/ReviewArtifactPermissionRequest.tsx
@@ -1,3 +1,74 @@
-export function ReviewArtifactPermissionRequest() {
-  return null
+import React from 'react'
+import { Box, Text } from '../../../ink.js'
+import { Select } from '../../CustomSelect/select.js'
+import { usePermissionRequestLogging } from '../hooks.js'
+import { PermissionDialog } from '../PermissionDialog.js'
+import type { PermissionRequestProps } from '../PermissionRequest.js'
+import { logUnaryPermissionEvent } from '../utils.js'
+
+export function ReviewArtifactPermissionRequest({
+  toolUseConfirm,
+  onDone,
+  onReject,
+  workerBadge,
+}: PermissionRequestProps): React.ReactNode {
+  const { title, annotations, summary } = toolUseConfirm.input as {
+    title?: string
+    annotations?: Array<{ line?: number; message: string; severity?: string }>
+    summary?: string
+  }
+
+  const unaryEvent = {
+    completion_type: 'tool_use_single' as const,
+    language_name: 'none',
+  }
+  usePermissionRequestLogging(toolUseConfirm, unaryEvent)
+
+  const annotationCount = annotations?.length ?? 0
+
+  function handleResponse(value: 'yes' | 'no'): void {
+    if (value === 'yes') {
+      logUnaryPermissionEvent('tool_use_single', toolUseConfirm, 'accept')
+      toolUseConfirm.onAllow(toolUseConfirm.input, [])
+      onDone()
+    } else {
+      logUnaryPermissionEvent('tool_use_single', toolUseConfirm, 'reject')
+      toolUseConfirm.onReject()
+      onReject()
+      onDone()
+    }
+  }
+
+  return (
+    <PermissionDialog
+      color="permission"
+      title="Review artifact?"
+      workerBadge={workerBadge}
+    >
+      <Box flexDirection="column" marginTop={1} paddingX={1}>
+        <Text>
+          Claude wants to review{title ? `: ${title}` : ' an artifact'}.
+        </Text>
+
+        <Box marginTop={1} flexDirection="column">
+          <Text dimColor>
+            {annotationCount} annotation{annotationCount !== 1 ? 's' : ''} will
+            be presented.
+          </Text>
+          {summary ? <Text dimColor>Summary: {summary}</Text> : null}
+        </Box>
+
+        <Box marginTop={1}>
+          <Select
+            options={[
+              { label: 'Yes, show review', value: 'yes' as const },
+              { label: 'No, skip', value: 'no' as const },
+            ]}
+            onChange={handleResponse}
+            onCancel={() => handleResponse('no')}
+          />
+        </Box>
+      </Box>
+    </PermissionDialog>
+  )
 }
diff --git a/src/components/tasks/MonitorMcpDetailDialog.tsx b/src/components/tasks/MonitorMcpDetailDialog.tsx
index 1540dc3..59a1b5b 100644
--- a/src/components/tasks/MonitorMcpDetailDialog.tsx
+++ b/src/components/tasks/MonitorMcpDetailDialog.tsx
@@ -1,3 +1,101 @@
-export function MonitorMcpDetailDialog() {
-  return null
+import React from 'react'
+import type { DeepImmutable } from 'src/types/utils.js'
+import { useElapsedTime } from '../../hooks/useElapsedTime.js'
+import type { KeyboardEvent } from '../../ink/events/keyboard-event.js'
+import { Box, Text } from '../../ink.js'
+import { useKeybindings } from '../../keybindings/useKeybinding.js'
+import type { MonitorMcpTaskState } from '../../tasks/MonitorMcpTask/MonitorMcpTask.js'
+import { Byline } from '../design-system/Byline.js'
+import { Dialog } from '../design-system/Dialog.js'
+import { KeyboardShortcutHint } from '../design-system/KeyboardShortcutHint.js'
+
+type Props = {
+  task: DeepImmutable<MonitorMcpTaskState>
+  onBack?: () => void
+  onKill?: () => void
+}
+
+/**
+ * Detail dialog for MCP monitor tasks shown in the Shift+Down background
+ * tasks overlay. Displays the server name, resource URI, and current status.
+ * Follows the DreamDetailDialog/ShellDetailDialog pattern.
+ */
+export function MonitorMcpDetailDialog({
+  task,
+  onBack,
+  onKill,
+}: Props): React.ReactNode {
+  const elapsedTime = useElapsedTime(
+    task.startTime,
+    task.status === 'running',
+    1000,
+    0,
+  )
+
+  useKeybindings(
+    {},
+    { context: 'MonitorMcpDetail' },
+  )
+
+  const handleKeyDown = (e: KeyboardEvent): void => {
+    if (e.key === 'left' && onBack) {
+      e.preventDefault()
+      onBack()
+    } else if (e.key === 'x' && task.status === 'running' && onKill) {
+      e.preventDefault()
+      onKill()
+    }
+  }
+
+  return (
+    <Box flexDirection="column" tabIndex={0} borderStyle="round" onKeyDown={handleKeyDown}>
+      <Dialog
+        title="MCP Monitor"
+        subtitle={
+          <Text dimColor>
+            {elapsedTime} · {task.serverName}:{task.resourceUri}
+          </Text>
+        }
+        onCancel={onBack ?? (() => {})}
+        inputGuide={() => (
+          <Byline>
+            {onBack && (
+              <KeyboardShortcutHint shortcut="←" action="go back" />
+            )}
+            <KeyboardShortcutHint shortcut="Esc" action="close" />
+            {task.status === 'running' && onKill && (
+              <KeyboardShortcutHint shortcut="x" action="stop" />
+            )}
+          </Byline>
+        )}
+      >
+        <Box flexDirection="column" gap={1}>
+          <Text>
+            <Text bold>Status:</Text>{' '}
+            {task.status === 'running' ? (
+              <Text color="green">running</Text>
+            ) : task.status === 'completed' ? (
+              <Text color="green">{task.status}</Text>
+            ) : (
+              <Text color="red">{task.status}</Text>
+            )}
+          </Text>
+          <Text>
+            <Text bold>Description:</Text> {task.description}
+          </Text>
+          <Text>
+            <Text bold>Server:</Text> {task.serverName}
+          </Text>
+          <Text>
+            <Text bold>Resource:</Text> {task.resourceUri}
+          </Text>
+          {task.command && (
+            <Text>
+              <Text bold>Command:</Text> {task.command}
+            </Text>
+          )}
+        </Box>
+      </Dialog>
+    </Box>
+  )
 }
diff --git a/src/components/tasks/WorkflowDetailDialog.tsx b/src/components/tasks/WorkflowDetailDialog.tsx
index df719fc..bef51aa 100644
--- a/src/components/tasks/WorkflowDetailDialog.tsx
+++ b/src/components/tasks/WorkflowDetailDialog.tsx
@@ -1,3 +1,116 @@
-export function WorkflowDetailDialog() {
-  return null
+import React, { useCallback } from 'react'
+import type { DeepImmutable } from 'src/types/utils.js'
+import { useElapsedTime } from '../../hooks/useElapsedTime.js'
+import type { KeyboardEvent } from '../../ink/events/keyboard-event.js'
+import { Box, Text } from '../../ink.js'
+import { useKeybindings } from '../../keybindings/useKeybinding.js'
+import type { LocalWorkflowTaskState } from '../../tasks/LocalWorkflowTask/LocalWorkflowTask.js'
+import { Byline } from '../design-system/Byline.js'
+import { Dialog } from '../design-system/Dialog.js'
+import { KeyboardShortcutHint } from '../design-system/KeyboardShortcutHint.js'
+
+type Props = {
+  workflow: DeepImmutable<LocalWorkflowTaskState>
+  onDone: (message?: string, options?: { display?: string }) => void
+  onKill?: () => void
+  onSkipAgent?: (agentId: string) => void
+  onRetryAgent?: (agentId: string) => void
+  onBack?: () => void
+}
+
+/**
+ * Detail dialog for local workflow tasks shown in the Shift+Down background
+ * tasks overlay. Displays the workflow name, file, status, and output.
+ * Follows the DreamDetailDialog/ShellDetailDialog pattern.
+ */
+export function WorkflowDetailDialog({
+  workflow,
+  onDone,
+  onKill,
+  onSkipAgent: _onSkipAgent,
+  onRetryAgent: _onRetryAgent,
+  onBack,
+}: Props): React.ReactNode {
+  const elapsedTime = useElapsedTime(
+    workflow.startTime,
+    workflow.status === 'running',
+    1000,
+    0,
+  )
+
+  useKeybindings(
+    {},
+    { context: 'WorkflowDetail' },
+  )
+
+  const handleKeyDown = useCallback(
+    (e: KeyboardEvent): void => {
+      if (e.key === 'left' && onBack) {
+        e.preventDefault()
+        onBack()
+      } else if (e.key === 'x' && workflow.status === 'running' && onKill) {
+        e.preventDefault()
+        onKill()
+      }
+    },
+    [onBack, onKill, workflow.status],
+  )
+
+  return (
+    <Box flexDirection="column" tabIndex={0} borderStyle="round" onKeyDown={handleKeyDown}>
+      <Dialog
+        title="Workflow"
+        subtitle={
+          <Text dimColor>
+            {elapsedTime} · {workflow.workflowName}
+          </Text>
+        }
+        onCancel={onBack ?? (() => {})}
+        inputGuide={() => (
+          <Byline>
+            {onBack && (
+              <KeyboardShortcutHint shortcut={'\u2190'} action="go back" />
+            )}
+            <KeyboardShortcutHint shortcut="Esc" action="close" />
+            {workflow.status === 'running' && onKill && (
+              <KeyboardShortcutHint shortcut="x" action="stop" />
+            )}
+          </Byline>
+        )}
+      >
+        <Box flexDirection="column" gap={1}>
+          <Text>
+            <Text bold>Status:</Text>{' '}
+            {workflow.status === 'running' ? (
+              <Text color="green">running</Text>
+            ) : workflow.status === 'completed' ? (
+              <Text color="green">{workflow.status}</Text>
+            ) : (
+              <Text color="red">{workflow.status}</Text>
+            )}
+          </Text>
+          <Text>
+            <Text bold>Description:</Text> {workflow.description}
+          </Text>
+          <Text>
+            <Text bold>Workflow:</Text> {workflow.workflowName}
+          </Text>
+          <Text>
+            <Text bold>File:</Text> {workflow.workflowFile}
+          </Text>
+          {workflow.summary && (
+            <Text>
+              <Text bold>Summary:</Text> {workflow.summary}
+            </Text>
+          )}
+          {workflow.output && (
+            <Box flexDirection="column">
+              <Text bold>Output:</Text>
+              <Text dimColor>{workflow.output}</Text>
+            </Box>
+          )}
+        </Box>
+      </Dialog>
+    </Box>
+  )
 }
diff --git a/src/hooks/useMasterMonitor.ts b/src/hooks/useMasterMonitor.ts
new file mode 100644
index 0000000..43c8038
--- /dev/null
+++ b/src/hooks/useMasterMonitor.ts
@@ -0,0 +1,136 @@
+/**
+ * useMasterMonitor — Master-side monitoring hook
+ *
+ * When role === 'master', this hook listens to all connected slave PipeClients
+ * and stores their session data (stream, tool events, done, error) into
+ * AppState.pipeIpc.slaves[name].history.
+ *
+ * The master CLI itself remains fully functional — this hook only collects
+ * data from slaves for review via /history and /status commands.
+ */
+
+import { useEffect } from 'react'
+import { useAppState, useSetAppState } from '../state/AppState.js'
+import { getPipeIpc, type PipeClient, type PipeMessage } from '../utils/pipeTransport.js'
+import { logForDebugging } from '../utils/debug.js'
+
+/** Session history entry for pipe IPC monitoring. */
+export type SessionEntry = {
+  type: string
+  content: string
+  from: string
+  timestamp: string
+  meta?: Record<string, unknown>
+}
+
+/**
+ * Module-level registry of connected slave PipeClients.
+ * Keyed by slave pipe name. Managed by /attach and /detach commands.
+ */
+const _slaveClients = new Map<string, PipeClient>()
+
+export function addSlaveClient(name: string, client: PipeClient): void {
+  _slaveClients.set(name, client)
+}
+
+export function removeSlaveClient(name: string): PipeClient | undefined {
+  const client = _slaveClients.get(name)
+  _slaveClients.delete(name)
+  return client
+}
+
+export function getSlaveClient(name: string): PipeClient | undefined {
+  return _slaveClients.get(name)
+}
+
+export function getAllSlaveClients(): Map<string, PipeClient> {
+  return _slaveClients
+}
+
+export function useMasterMonitor(): void {
+  const role = useAppState((s) => getPipeIpc(s).role)
+  const setAppState = useSetAppState()
+
+  useEffect(() => {
+    if (role !== 'master') return
+
+    // Set up listeners for each connected slave client
+    const cleanups: (() => void)[] = []
+
+    for (const [slaveName, client] of _slaveClients.entries()) {
+      const handler = (msg: PipeMessage) => {
+        const entry: SessionEntry = {
+          type: msg.type as SessionEntry['type'],
+          content: msg.data ?? '',
+          from: msg.from ?? slaveName,
+          timestamp: msg.ts ?? new Date().toISOString(),
+          meta: msg.meta,
+        }
+
+        // Only record relevant message types
+        if (!['stream', 'tool_start', 'tool_result', 'done', 'error', 'prompt'].includes(msg.type)) {
+          return
+        }
+
+        setAppState((prev) => {
+          const slave = getPipeIpc(prev).slaves[slaveName]
+          if (!slave) return prev
+
+          const newStatus =
+            msg.type === 'done' || msg.type === 'error' ? 'idle' :
+            msg.type === 'prompt' ? 'busy' : slave.status
+
+          return {
+            ...prev,
+            pipeIpc: {
+              ...getPipeIpc(prev),
+              slaves: {
+                ...getPipeIpc(prev).slaves,
+                [slaveName]: {
+                  ...slave,
+                  status: newStatus,
+                  history: [...slave.history, entry],
+                },
+              },
+            },
+          }
+        })
+
+        if (msg.type === 'done') {
+          logForDebugging(`[MasterMonitor] Slave "${slaveName}" turn complete`)
+        }
+      }
+
+      client.onMessage(handler)
+
+      // Handle slave disconnect
+      const onDisconnect = () => {
+        logForDebugging(`[MasterMonitor] Slave "${slaveName}" disconnected`)
+        _slaveClients.delete(slaveName)
+        setAppState((prev) => {
+          const { [slaveName]: _removed, ...remainingSlaves } = getPipeIpc(prev).slaves
+          const hasSlaves = Object.keys(remainingSlaves).length > 0
+          return {
+            ...prev,
+            pipeIpc: {
+              ...getPipeIpc(prev),
+              role: hasSlaves ? 'master' : 'standalone',
+              slaves: remainingSlaves,
+            },
+          }
+        })
+      }
+
+      client.on('disconnect', onDisconnect)
+      cleanups.push(() => {
+        client.removeListener('disconnect', onDisconnect)
+      })
+    }
+
+    return () => {
+      for (const cleanup of cleanups) {
+        cleanup()
+      }
+    }
+  }, [role, setAppState])
+}
diff --git a/src/hooks/useMasterRelay.ts b/src/hooks/useMasterRelay.ts
new file mode 100644
index 0000000..18ec1c4
--- /dev/null
+++ b/src/hooks/useMasterRelay.ts
@@ -0,0 +1,130 @@
+/**
+ * useMasterRelay — Master-side named pipe relay hook
+ *
+ * When role === 'master', this hook:
+ * 1. Listens to messages from the slave PipeClient
+ * 2. Injects slave AI output (`stream`, `done`, `error`) into the master's display
+ *    via onSubmitMessage (same path as teammate messages)
+ * 3. Does nothing when role !== 'master'
+ *
+ * The actual user-input interception (sending prompts to slave instead of local AI)
+ * is handled by the /attach command modifying the submit flow, not by this hook.
+ */
+
+import { useEffect, useRef } from 'react'
+import { useAppState } from '../state/AppState.js'
+import { getPipeIpc, type PipeClient, type PipeMessage } from '../utils/pipeTransport.js'
+import { logForDebugging } from '../utils/debug.js'
+
+const PIPE_RELAY_TAG = 'pipe_relay'
+
+type Props = {
+  /** Should be true only when role === 'master' */
+  enabled: boolean
+  /** The connected PipeClient to the slave, or null */
+  masterClient: PipeClient | null
+  /** Inject content as a new turn (same as handleIncomingPrompt) */
+  onSubmitMessage: (formatted: string) => boolean
+}
+
+/**
+ * Module-level reference to the master's PipeClient.
+ * Set by /attach command, read by useMasterRelay and REPL submit override.
+ */
+let _masterPipeClient: PipeClient | null = null
+
+export function setMasterPipeClient(client: PipeClient | null): void {
+  _masterPipeClient = client
+}
+
+export function getMasterPipeClient(): PipeClient | null {
+  return _masterPipeClient
+}
+
+export function useMasterRelay({
+  enabled,
+  masterClient,
+  onSubmitMessage,
+}: Props): void {
+  const role = useAppState((s) => getPipeIpc(s).role)
+
+  // Use refs to avoid re-binding the handler when callback identity changes
+  const onSubmitRef = useRef(onSubmitMessage)
+  onSubmitRef.current = onSubmitMessage
+
+  // Track the client we've bound to so we only bind once per client instance
+  const boundClientRef = useRef<PipeClient | null>(null)
+
+  useEffect(() => {
+    if (!enabled || role !== 'master' || !masterClient) {
+      boundClientRef.current = null
+      return
+    }
+
+    // Skip if we've already bound a handler to this exact client instance
+    if (boundClientRef.current === masterClient) return
+
+    logForDebugging(`[MasterRelay] Listening to slave output`)
+    boundClientRef.current = masterClient
+
+    // Accumulate stream fragments for the current turn
+    let streamBuffer = ''
+
+    const handler = (msg: PipeMessage) => {
+      switch (msg.type) {
+        case 'stream': {
+          // Accumulate streamed output
+          streamBuffer += msg.data ?? ''
+          break
+        }
+
+        case 'done': {
+          // Turn complete — inject accumulated output into the master's conversation
+          const output = streamBuffer || msg.data || '(slave completed with no output)'
+          streamBuffer = ''
+
+          const formatted = `<${PIPE_RELAY_TAG} from="${msg.from ?? 'slave'}" type="response">\n${output}\n</${PIPE_RELAY_TAG}>`
+          const submitted = onSubmitRef.current(formatted)
+          if (!submitted) {
+            logForDebugging(`[MasterRelay] Failed to inject slave output (master busy)`)
+          }
+          break
+        }
+
+        case 'tool_start': {
+          logForDebugging(`[MasterRelay] Slave tool: ${msg.data}`)
+          break
+        }
+
+        case 'tool_result': {
+          logForDebugging(`[MasterRelay] Slave tool result: ${(msg.data ?? '').slice(0, 100)}`)
+          break
+        }
+
+        case 'error': {
+          const formatted = `<${PIPE_RELAY_TAG} from="${msg.from ?? 'slave'}" type="error">\n${msg.data ?? 'Unknown error'}\n</${PIPE_RELAY_TAG}>`
+          const submitted = onSubmitRef.current(formatted)
+          if (!submitted) {
+            logForDebugging(`[MasterRelay] Failed to inject slave error (master busy)`)
+          }
+          break
+        }
+
+        case 'attach_reject': {
+          logForDebugging(`[MasterRelay] Attach rejected: ${msg.data}`)
+          break
+        }
+
+        default:
+          break
+      }
+    }
+
+    masterClient.onMessage(handler)
+
+    return () => {
+      streamBuffer = ''
+      boundClientRef.current = null
+    }
+  }, [enabled, role, masterClient])
+}
diff --git a/src/hooks/usePipeIpc.ts b/src/hooks/usePipeIpc.ts
new file mode 100644
index 0000000..1b789ff
--- /dev/null
+++ b/src/hooks/usePipeIpc.ts
@@ -0,0 +1,247 @@
+/**
+ * usePipeIpc — Per-CLI named pipe IPC hook
+ *
+ * Every CLI instance auto-starts a PipeServer on mount.
+ * Default role is 'standalone' — completely independent.
+ *
+ * When a master sends attach_request:
+ *   - Accept → switch to 'slave' role
+ *   - Begin auto-reporting all session events to master
+ *
+ * When a master sends prompt:
+ *   - Inject via onSubmitMessage (same path as useInboxPoller)
+ *
+ * When a master sends detach:
+ *   - Revert to standalone
+ *
+ * The globalThis.__pipeSendToMaster function is set when in slave mode
+ * so that REPL's onQueryEvent can relay AI output without importing hooks.
+ */
+
+import { useCallback, useEffect, useRef } from 'react'
+import type { Socket } from 'net'
+import {
+  useAppState,
+  useAppStateStore,
+  useSetAppState,
+} from '../state/AppState.js'
+import { getSessionId } from '../bootstrap/state.js'
+import {
+  createPipeServer,
+  getPipeIpc,
+  type PipeMessage,
+  type PipeServer,
+} from '../utils/pipeTransport.js'
+import { logForDebugging } from '../utils/debug.js'
+
+const PIPE_IPC_TAG = 'pipe_message'
+
+/**
+ * Generate a short pipe name from the session ID.
+ */
+function getSessionPipeName(): string {
+  const sessionId = getSessionId()
+  return `cli-${sessionId.slice(0, 8)}`
+}
+
+type Props = {
+  enabled: boolean
+  isLoading: boolean
+  /** Same callback as useInboxPoller — injects content as a new turn */
+  onSubmitMessage: (formatted: string) => boolean
+}
+
+export function usePipeIpc({ enabled, isLoading, onSubmitMessage }: Props): void {
+  const setAppState = useSetAppState()
+  const store = useAppStateStore()
+  const pipeRole = useAppState((s) => getPipeIpc(s).role)
+
+  const serverRef = useRef<PipeServer | null>(null)
+  // Track all connected master sockets (in slave mode, only one master at a time)
+  const masterSocketRef = useRef<Socket | null>(null)
+
+  // Send helper (slave → master)
+  const sendToMaster = useCallback((msg: PipeMessage) => {
+    const server = serverRef.current
+    const masterSocket = masterSocketRef.current
+    if (server && masterSocket && !masterSocket.destroyed) {
+      server.sendTo(masterSocket, msg)
+    }
+  }, [])
+
+  const sendToMasterRef = useRef(sendToMaster)
+  sendToMasterRef.current = sendToMaster
+
+  // Start server on mount
+  useEffect(() => {
+    if (!enabled) return
+
+    const pipeName = getSessionPipeName()
+    let server: PipeServer | null = null
+    let disposed = false
+
+    const init = async () => {
+      try {
+        server = await createPipeServer(pipeName)
+        if (disposed) {
+          await server.close()
+          return
+        }
+        serverRef.current = server
+
+        setAppState((prev) => ({
+          ...prev,
+          pipeIpc: { ...getPipeIpc(prev), serverName: pipeName },
+        }))
+
+        // Expose sendToMaster globally so REPL onQueryEvent can relay output
+        ;(globalThis as any).__pipeSendToMaster = (msg: PipeMessage) => {
+          const currentState = store.getState()
+          if (getPipeIpc(currentState).role !== 'slave') return
+          const masterSocket = masterSocketRef.current
+          if (server && masterSocket && !masterSocket.destroyed) {
+            server.sendTo(masterSocket, msg)
+          }
+        }
+
+        logForDebugging(`[PipeIpc] Server started: ${pipeName}`)
+
+        // --- Auto-reply to pings (health check) ---
+        server.onMessage((msg, reply) => {
+          if (msg.type === 'ping') {
+            reply({ type: 'pong' })
+          }
+        })
+
+        // --- Handle attach_request ---
+        server.onMessage((msg, reply) => {
+          if (msg.type === 'attach_request') {
+            const currentState = store.getState()
+
+            if (getPipeIpc(currentState).role === 'slave') {
+              reply({
+                type: 'attach_reject',
+                data: `Already controlled by ${getPipeIpc(currentState).attachedBy}`,
+              })
+              logForDebugging(`[PipeIpc] Rejected attach from ${msg.from}: already slave`)
+              return
+            }
+
+            // Accept the attach — find the latest client socket
+            const clients = Array.from((server as any).clients as Set<Socket>)
+            const latestClient = clients[clients.length - 1]
+            if (latestClient) {
+              masterSocketRef.current = latestClient
+
+              // When master disconnects unexpectedly, revert to standalone
+              latestClient.on('close', () => {
+                if (masterSocketRef.current === latestClient) {
+                  masterSocketRef.current = null
+                  setAppState((prev) => ({
+                    ...prev,
+                    pipeIpc: {
+                      ...getPipeIpc(prev),
+                      role: 'standalone',
+                      attachedBy: null,
+                    },
+                  }))
+                  logForDebugging(`[PipeIpc] Master disconnected, reverted to standalone`)
+                }
+              })
+            }
+
+            setAppState((prev) => ({
+              ...prev,
+              pipeIpc: {
+                ...getPipeIpc(prev),
+                role: 'slave',
+                attachedBy: msg.from ?? 'unknown',
+              },
+            }))
+
+            reply({
+              type: 'attach_accept',
+              data: pipeName,
+            })
+            logForDebugging(`[PipeIpc] Accepted attach from ${msg.from}`)
+          }
+        })
+
+        // --- Handle detach ---
+        server.onMessage((msg, _reply) => {
+          if (msg.type === 'detach') {
+            masterSocketRef.current = null
+            setAppState((prev) => ({
+              ...prev,
+              pipeIpc: {
+                ...getPipeIpc(prev),
+                role: 'standalone',
+                attachedBy: null,
+              },
+            }))
+            logForDebugging(`[PipeIpc] Detached by ${msg.from}`)
+          }
+        })
+
+        // --- Handle prompt (master → slave) ---
+        server.onMessage((msg, _reply) => {
+          if (msg.type === 'prompt') {
+            const currentState = store.getState()
+            if (getPipeIpc(currentState).role !== 'slave') return
+
+            const promptText = msg.data ?? ''
+            if (!promptText) return
+
+            logForDebugging(`[PipeIpc] Received prompt from master: ${promptText.slice(0, 50)}...`)
+
+            const formatted = `<${PIPE_IPC_TAG} from="${msg.from ?? 'master'}">\n${promptText}\n</${PIPE_IPC_TAG}>`
+
+            const submitted = onSubmitMessage(formatted)
+            if (!submitted) {
+              sendToMasterRef.current({
+                type: 'error',
+                data: 'Slave CLI is busy processing another request. Please wait.',
+              })
+            }
+          }
+        })
+      } catch (err) {
+        logForDebugging(`[PipeIpc] Failed to start server: ${err}`)
+      }
+    }
+
+    void init()
+
+    return () => {
+      disposed = true
+      ;(globalThis as any).__pipeSendToMaster = undefined
+      if (serverRef.current) {
+        void serverRef.current.close()
+        serverRef.current = null
+      }
+      masterSocketRef.current = null
+      setAppState((prev) => ({
+        ...prev,
+        pipeIpc: {
+          role: 'standalone',
+          serverName: null,
+          slaves: {},
+          attachedBy: null,
+        },
+      }))
+    }
+  }, [enabled, setAppState, store, onSubmitMessage])
+}
+
+/**
+ * Relay a session event to the master CLI (if in slave mode).
+ * Called from REPL's onQueryEvent handler.
+ */
+export function relayToMaster(msg: PipeMessage): void {
+  const fn = (globalThis as any).__pipeSendToMaster as
+    | ((msg: PipeMessage) => void)
+    | undefined
+  if (fn) {
+    fn(msg)
+  }
+}
diff --git a/src/hooks/useSlaveNotifications.ts b/src/hooks/useSlaveNotifications.ts
new file mode 100644
index 0000000..8dd28d2
--- /dev/null
+++ b/src/hooks/useSlaveNotifications.ts
@@ -0,0 +1,126 @@
+/**
+ * useSlaveNotifications — Real-time toast notifications for slave CLI events
+ *
+ * When role === 'master', watches slave session history for key events
+ * and shows toast notifications in the master CLI's footer:
+ *
+ * - Slave turn complete (done) → "[slave-name] 完成: <last stream content>"
+ * - Slave error → "[slave-name] 错误: <error message>"
+ * - Slave tool execution → "[slave-name] 工具: <tool name>"
+ * - Slave busy (prompt received) → "[slave-name] 开始处理任务"
+ */
+
+import { useEffect, useRef } from 'react'
+import { useAppState } from '../state/AppState.js'
+import { useNotifications } from '../context/notifications.js'
+import type { Notification } from '../context/notifications.js'
+import type { SessionEntry } from './useMasterMonitor.js'
+import { getPipeIpc } from '../utils/pipeTransport.js'
+
+/**
+ * Fold function: merge consecutive notifications from the same slave
+ * into a single count-based notification.
+ */
+function foldSlaveNotif(
+  acc: Notification,
+  _incoming: Notification,
+): Notification {
+  if (!('text' in acc)) return acc
+  const match = acc.text.match(/\((\d+)\)$/)
+  const count = match ? parseInt(match[1], 10) + 1 : 2
+  // Replace trailing count or append it
+  const base = acc.text.replace(/\s*\(\d+\)$/, '')
+  return {
+    ...acc,
+    text: `${base} (${count})`,
+    fold: foldSlaveNotif,
+  }
+}
+
+function truncate(s: string, max: number): string {
+  if (s.length <= max) return s
+  return s.slice(0, max) + '…'
+}
+
+export function useSlaveNotifications(): void {
+  const role = useAppState((s) => getPipeIpc(s).role)
+  const slaves = useAppState((s) => getPipeIpc(s).slaves)
+  const { addNotification } = useNotifications()
+
+  // Track last seen history length per slave to detect new entries
+  const lastSeenRef = useRef<Record<string, number>>({})
+
+  useEffect(() => {
+    if (role !== 'master') return
+
+    for (const [name, slave] of Object.entries(slaves)) {
+      const lastSeen = lastSeenRef.current[name] ?? 0
+      const newEntries = slave.history.slice(lastSeen)
+      lastSeenRef.current[name] = slave.history.length
+
+      for (const entry of newEntries) {
+        const notif = makeNotification(name, entry)
+        if (notif) {
+          addNotification(notif)
+        }
+      }
+    }
+
+    // Clean up removed slaves
+    for (const name of Object.keys(lastSeenRef.current)) {
+      if (!(name in slaves)) {
+        delete lastSeenRef.current[name]
+      }
+    }
+  }, [role, slaves, addNotification])
+}
+
+function makeNotification(
+  slaveName: string,
+  entry: SessionEntry,
+): Notification | null {
+  const short = slaveName.length > 16 ? slaveName.slice(0, 16) + '…' : slaveName
+
+  switch (entry.type) {
+    case 'done':
+      return {
+        key: `slave-done-${slaveName}`,
+        text: `[${short}] ✓ 任务完成`,
+        priority: 'medium',
+        timeoutMs: 5000,
+        fold: foldSlaveNotif,
+      }
+
+    case 'error':
+      return {
+        key: `slave-error-${slaveName}`,
+        text: `[${short}] ✗ 错误: ${truncate(entry.content, 60)}`,
+        color: 'error',
+        priority: 'high',
+        timeoutMs: 8000,
+      }
+
+    case 'tool_start':
+      return {
+        key: `slave-tool-${slaveName}`,
+        text: `[${short}] 工具: ${truncate(entry.content, 40)}`,
+        priority: 'low',
+        timeoutMs: 3000,
+        fold: foldSlaveNotif,
+      }
+
+    case 'prompt':
+      return {
+        key: `slave-prompt-${slaveName}`,
+        text: `[${short}] ▶ 开始处理: ${truncate(entry.content, 50)}`,
+        priority: 'medium',
+        timeoutMs: 4000,
+      }
+
+    // stream and tool_result are too frequent — skip to avoid noise
+    case 'stream':
+    case 'tool_result':
+    default:
+      return null
+  }
+}
diff --git a/src/pipe-demo.ts b/src/pipe-demo.ts
new file mode 100644
index 0000000..4a4a925
--- /dev/null
+++ b/src/pipe-demo.ts
@@ -0,0 +1,45 @@
+#!/usr/bin/env bun
+/**
+ * Pipe Demo - Quick launcher for terminal-to-terminal communication
+ *
+ * Usage:
+ *   # Terminal A (server):
+ *   bun run src/pipe-demo.ts server myroom
+ *
+ *   # Terminal B (client):
+ *   bun run src/pipe-demo.ts client myroom
+ *
+ * Commands inside REPL:
+ *   (text)       → send chat message
+ *   /cmd <cmd>   → execute command on remote side
+ *   /ping        → latency check
+ *   /list        → list active pipes
+ *   /exit        → disconnect
+ */
+
+import { startPipeRepl } from './utils/pipeRepl.js'
+
+const [, , role, name] = process.argv
+
+if (role === 'server') {
+  const pipeName = name || 'default'
+  await startPipeRepl({ role: 'server', name: pipeName })
+} else if (role === 'client') {
+  const target = name || 'default'
+  await startPipeRepl({ role: 'client', target })
+} else {
+  console.log(`Usage:
+  bun run src/pipe-demo.ts server [name]   # Start pipe server (default name: "default")
+  bun run src/pipe-demo.ts client [name]   # Connect to pipe server
+
+Example:
+  Terminal A:  bun run src/pipe-demo.ts server myroom
+  Terminal B:  bun run src/pipe-demo.ts client myroom
+
+Then type messages in either terminal to chat.
+  /cmd ls       Send a command to execute on remote side
+  /ping         Check latency
+  /list         List active pipes
+  /exit         Disconnect`)
+  process.exit(1)
+}
diff --git a/src/screens/REPL.tsx b/src/screens/REPL.tsx
index 0388c54..10610ee 100644
--- a/src/screens/REPL.tsx
+++ b/src/screens/REPL.tsx
@@ -141,6 +141,8 @@ import { gracefulShutdownSync } from '../utils/gracefulShutdown.js';
 import { handlePromptSubmit, type PromptInputHelpers } from '../utils/handlePromptSubmit.js';
 import { useQueueProcessor } from '../hooks/useQueueProcessor.js';
 import { useMailboxBridge } from '../hooks/useMailboxBridge.js';
+import { usePipeIpc, relayToMaster } from '../hooks/usePipeIpc.js';
+import { useMasterMonitor } from '../hooks/useMasterMonitor.js';
 import { queryCheckpoint, logQueryProfileReport } from '../utils/queryProfiler.js';
 import type { Message as MessageType, UserMessage, ProgressMessage, HookResultMessage, PartialCompactDirection } from '../types/message.js';
 import { query } from '../query.js';
@@ -1601,6 +1603,8 @@ export function REPL({
     // queryGuard.end() (onQuery finally) or cancelReservation() (executeUserInput
     // finally) have already transitioned the guard to idle by the time this runs.
     // External loading (remote/backgrounding) is reset separately by those hooks.
+    // Relay turn-complete to master (if in slave mode)
+    relayToMaster({ type: 'done' });
     setIsExternalLoading(false);
     setUserInputOnProcessing(undefined);
     responseLengthRef.current = 0;
@@ -2660,6 +2664,20 @@ export function REPL({
       } else {
         setMessages(oldMessages => [...oldMessages, newMessage]);
       }
+      // Relay tool and assistant events to master (if in slave mode)
+      if (newMessage.type === 'progress' && 'data' in newMessage) {
+        const progressType = (newMessage.data as any)?.type as string | undefined;
+        if (progressType === 'tool_start') {
+          relayToMaster({ type: 'tool_start', data: (newMessage.data as any)?.tool ?? '', meta: { toolUseId: (newMessage as any).parentToolUseID } });
+        } else if (progressType === 'tool_result') {
+          relayToMaster({ type: 'tool_result', data: String((newMessage.data as any)?.result ?? '').slice(0, 500), meta: { toolUseId: (newMessage as any).parentToolUseID } });
+        }
+      } else if (newMessage.type === 'assistant') {
+        const text = typeof (newMessage as any).content === 'string' ? (newMessage as any).content : '';
+        if (text) {
+          relayToMaster({ type: 'stream', data: text });
+        }
+      }
       // Block ticks on API errors to prevent tick → error → tick
       // runaway loops (e.g., auth failure, rate limit, blocking limit).
       // Cleared on compact boundary (above) or successful response (below).
@@ -2675,6 +2693,8 @@ export function REPL({
       // spinner animation) and apiMetricsRef (endResponseLength/lastTokenTime
       // for OTPS). No separate metrics update needed here.
       setResponseLength(length => length + newContent.length);
+      // Relay streaming text to master (if in slave mode)
+      relayToMaster({ type: 'stream', data: newContent });
     }, setStreamMode, setStreamingToolUses, tombstonedMessage => {
       setMessages(oldMessages => oldMessages.filter(m => m !== tombstonedMessage));
       void removeTranscriptMessage(tombstonedMessage.uuid);
@@ -4090,6 +4110,15 @@ export function REPL({
     onSubmitMessage: handleIncomingPrompt
   });
 
+  // Pipe IPC: every CLI auto-starts a PipeServer for inter-terminal communication
+  usePipeIpc({
+    enabled: true,
+    isLoading,
+    onSubmitMessage: handleIncomingPrompt,
+  });
+  // Master monitor: receives session data from connected slaves
+  useMasterMonitor();
+
   // Scheduled tasks from .claude/scheduled_tasks.json (CronCreate/Delete/List)
   if (feature('AGENT_TRIGGERS')) {
     // Assistant mode bypasses the isLoading gate (the proactive tick →
diff --git a/src/skills/mcpSkills.ts b/src/skills/mcpSkills.ts
index 6f074a1..27fc71a 100644
--- a/src/skills/mcpSkills.ts
+++ b/src/skills/mcpSkills.ts
@@ -1,3 +1,142 @@
-export async function fetchMcpSkillsForClient() {
-  return []
-}
+import {
+  type ListResourcesResult,
+  ListResourcesResultSchema,
+  type ReadResourceResult,
+  ReadResourceResultSchema,
+} from '@modelcontextprotocol/sdk/types.js'
+import type { Command } from '../commands.js'
+import type { MCPServerConnection } from '../services/mcp/types.js'
+import { normalizeNameForMCP } from '../services/mcp/normalization.js'
+import { memoizeWithLRU } from '../utils/memoize.js'
+import { errorMessage } from '../utils/errors.js'
+import { logMCPDebug, logMCPError } from '../utils/log.js'
+import { recursivelySanitizeUnicode } from '../utils/sanitization.js'
+import { parseFrontmatter } from '../utils/frontmatterParser.js'
+import { getMCPSkillBuilders } from './mcpSkillBuilders.js'
+
+const SKILL_URI_PREFIX = 'skill://'
+const MCP_FETCH_CACHE_SIZE = 20
+
+/**
+ * Discovers skills exposed as `skill://` resources by an MCP server.
+ *
+ * Each matching resource is read, its markdown content is parsed for
+ * frontmatter, and the result is converted into a Command that the skill
+ * system can index and invoke just like a local `.md` skill file.
+ *
+ * Memoized by server name so repeated calls within a connection lifecycle
+ * return the cached result. Callers invalidate via `.cache.delete(name)`.
+ */
+export const fetchMcpSkillsForClient = memoizeWithLRU(
+  async (client: MCPServerConnection): Promise<Command[]> => {
+    if (client.type !== 'connected') return []
+
+    try {
+      if (!client.capabilities?.resources) {
+        return []
+      }
+
+      // List all resources and filter to skill:// URIs
+      const result = (await client.client.request(
+        { method: 'resources/list' },
+        ListResourcesResultSchema,
+      )) as ListResourcesResult
+
+      if (!result.resources) return []
+
+      const skillResources = result.resources.filter(r =>
+        r.uri.startsWith(SKILL_URI_PREFIX),
+      )
+
+      if (skillResources.length === 0) return []
+
+      logMCPDebug(
+        client.name,
+        `Found ${skillResources.length} skill resource(s)`,
+      )
+
+      const { createSkillCommand, parseSkillFrontmatterFields } =
+        getMCPSkillBuilders()
+
+      const commands: Command[] = []
+
+      for (const resource of skillResources) {
+        try {
+          // Read the skill resource content
+          const readResult = (await client.client.request(
+            {
+              method: 'resources/read',
+              params: { uri: resource.uri },
+            },
+            ReadResourceResultSchema,
+          )) as ReadResourceResult
+
+          // Extract text content from the resource
+          const textContent = readResult.contents
+            ?.map(c => ('text' in c ? c.text : undefined))
+            .filter(Boolean)
+            .join('\n')
+
+          if (!textContent) {
+            logMCPDebug(
+              client.name,
+              `Skill resource ${resource.uri} returned no text content, skipping`,
+            )
+            continue
+          }
+
+          const sanitizedContent = recursivelySanitizeUnicode(textContent)
+
+          // Parse the markdown frontmatter
+          const { frontmatter, content: markdownContent } =
+            parseFrontmatter(sanitizedContent)
+
+          // Derive a skill name from the resource URI. Strip the skill://
+          // prefix and use the remainder, prefixed with the MCP server name
+          // so it is unique across servers.
+          const rawName = resource.uri.slice(SKILL_URI_PREFIX.length)
+          const skillName =
+            'mcp__' + normalizeNameForMCP(client.name) + '__' + rawName
+
+          const parsed = parseSkillFrontmatterFields(
+            frontmatter,
+            markdownContent,
+            skillName,
+          )
+
+          commands.push(
+            createSkillCommand({
+              ...parsed,
+              skillName,
+              markdownContent,
+              source: 'mcp',
+              loadedFrom: 'mcp',
+              baseDir: undefined,
+              paths: undefined,
+            }),
+          )
+        } catch (error) {
+          logMCPError(
+            client.name,
+            `Failed to load skill resource ${resource.uri}: ${errorMessage(error)}`,
+          )
+        }
+      }
+
+      logMCPDebug(
+        client.name,
+        `Loaded ${commands.length} skill(s) from resources`,
+      )
+
+      return commands
+    } catch (error) {
+      logMCPError(
+        client.name,
+        `Failed to fetch skill resources: ${errorMessage(error)}`,
+      )
+      return []
+    }
+  },
+  (client: MCPServerConnection) => client.name,
+  MCP_FETCH_CACHE_SIZE,
+)
diff --git a/src/state/AppStateStore.ts b/src/state/AppStateStore.ts
index fd6526e..3215a13 100644
--- a/src/state/AppStateStore.ts
+++ b/src/state/AppStateStore.ts
@@ -86,6 +86,34 @@ export type FooterItem =
   | 'bridge'
   | 'companion'
 
+// ---------------------------------------------------------------------------
+// Pipe IPC types (master-slave CLI communication)
+// ---------------------------------------------------------------------------
+
+export type SessionEntry = {
+  type: 'prompt' | 'stream' | 'tool_start' | 'tool_result' | 'done' | 'error'
+  content: string
+  from: string
+  timestamp: string
+  meta?: Record<string, unknown>
+}
+
+export type SlaveInfo = {
+  name: string
+  connectedAt: string
+  status: 'connected' | 'busy' | 'idle'
+  history: SessionEntry[]
+}
+
+export type PipeIpcState = {
+  role: 'standalone' | 'master' | 'slave'
+  serverName: string | null
+  // Master-specific: connected slaves
+  slaves: Record<string, SlaveInfo>
+  // Slave-specific: which master controls us
+  attachedBy: string | null
+}
+
 export type AppState = DeepImmutable<{
   settings: SettingsJson
   verbose: boolean
@@ -449,6 +477,8 @@ export type AppState = DeepImmutable<{
   // Races against local UI + bridge + hooks + classifier via claim() in
   // interactiveHandler.ts. Constructed once in useManageMCPConnections.
   channelPermissionCallbacks?: ChannelPermissionCallbacks
+  // Pipe IPC: master-slave CLI communication
+  pipeIpc: PipeIpcState
 }
 
 export type AppStateStore = Store<AppState>
@@ -565,5 +595,11 @@ export function getDefaultAppState(): AppState {
     effortValue: undefined,
     activeOverlays: new Set<string>(),
     fastMode: false,
+    pipeIpc: {
+      role: 'standalone',
+      serverName: null,
+      slaves: {},
+      attachedBy: null,
+    },
   }
 }
diff --git a/src/tasks/LocalWorkflowTask/LocalWorkflowTask.ts b/src/tasks/LocalWorkflowTask/LocalWorkflowTask.ts
index 19bd859..3d7fb78 100644
--- a/src/tasks/LocalWorkflowTask/LocalWorkflowTask.ts
+++ b/src/tasks/LocalWorkflowTask/LocalWorkflowTask.ts
@@ -1,5 +1,207 @@
-export type LocalWorkflowTaskState = Record<string, unknown>
+// Background task entry for local workflow execution.
+// Makes workflow scripts visible in the footer pill and Shift+Down
+// dialog. Follows the DreamTask pattern: lifecycle + UI surfacing via
+// the existing task registry.
 
-export function isLocalWorkflowTask(_value: unknown): boolean {
-  return false
+import type { AppState } from '../../state/AppState.js'
+import type { SetAppState, Task, TaskStateBase } from '../../Task.js'
+import { createTaskStateBase, generateTaskId } from '../../Task.js'
+import type { AgentId } from '../../types/ids.js'
+import { logForDebugging } from '../../utils/debug.js'
+import { registerTask, updateTaskState } from '../../utils/task/framework.js'
+
+export type LocalWorkflowTaskState = TaskStateBase & {
+  type: 'local_workflow'
+  /** meta.name from the workflow script (e.g. 'spec'). */
+  workflowName: string
+  /** Absolute path to the workflow file on disk. */
+  workflowFile: string
+  /** Human-readable one-line summary for the task list. */
+  summary?: string
+  /** Number of sub-agents spawned by this workflow. */
+  agentCount?: number
+  /** Captured output from workflow execution. */
+  output?: string
+  /** Agent that spawned this task. Used for orphan cleanup. */
+  agentId?: AgentId
+  /** Abort controller for cancellation. */
+  abortController?: AbortController
+  /**
+   * Pending action for a sub-agent within this workflow.
+   * The workflow execution loop polls this field and acts on it.
+   */
+  pendingAgentAction?: {
+    kind: 'skip' | 'retry'
+    agentId: AgentId
+    requestedAt: number
+  }
+}
+
+export function isLocalWorkflowTask(
+  value: unknown,
+): value is LocalWorkflowTaskState {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'type' in value &&
+    (value as { type: string }).type === 'local_workflow'
+  )
+}
+
+export function registerLocalWorkflowTask(
+  setAppState: SetAppState,
+  opts: {
+    description: string
+    workflowName: string
+    workflowFile: string
+    summary?: string
+    toolUseId?: string
+    agentId?: AgentId
+    abortController?: AbortController
+  },
+): string {
+  const id = generateTaskId('local_workflow')
+  const task: LocalWorkflowTaskState = {
+    ...createTaskStateBase(id, 'local_workflow', opts.description, opts.toolUseId),
+    type: 'local_workflow',
+    status: 'running',
+    workflowName: opts.workflowName,
+    workflowFile: opts.workflowFile,
+    summary: opts.summary,
+    agentId: opts.agentId,
+    abortController: opts.abortController,
+  }
+  registerTask(task, setAppState)
+  return id
+}
+
+export function completeWorkflowTask(
+  taskId: string,
+  setAppState: SetAppState,
+): void {
+  updateTaskState<LocalWorkflowTaskState>(taskId, setAppState, task => ({
+    ...task,
+    status: 'completed',
+    endTime: Date.now(),
+    notified: true,
+    abortController: undefined,
+  }))
+}
+
+export function failWorkflowTask(
+  taskId: string,
+  setAppState: SetAppState,
+): void {
+  updateTaskState<LocalWorkflowTaskState>(taskId, setAppState, task => ({
+    ...task,
+    status: 'failed',
+    endTime: Date.now(),
+    notified: true,
+    abortController: undefined,
+  }))
+}
+
+/**
+ * Kill a running workflow task. Called from BackgroundTasksDialog
+ * via the feature-gated `killWorkflowTask` binding.
+ */
+export function killWorkflowTask(
+  taskId: string,
+  setAppState: SetAppState,
+): void {
+  updateTaskState<LocalWorkflowTaskState>(taskId, setAppState, task => {
+    if (task.status !== 'running') return task
+    task.abortController?.abort()
+    return {
+      ...task,
+      status: 'killed',
+      endTime: Date.now(),
+      notified: true,
+      abortController: undefined,
+    }
+  })
+}
+
+/**
+ * Skip the current agent step within a running workflow.
+ * Called from BackgroundTasksDialog via the feature-gated
+ * `skipWorkflowAgent` binding: skipWorkflowAgent(taskId, agentId, setAppState).
+ */
+export function skipWorkflowAgent(
+  taskId: string,
+  agentId: AgentId,
+  setAppState: SetAppState,
+): void {
+  logForDebugging(
+    `skipWorkflowAgent: skipping agent ${agentId} in workflow task ${taskId}`,
+  )
+  updateTaskState<LocalWorkflowTaskState>(taskId, setAppState, task => {
+    if (task.status !== 'running') return task
+    return {
+      ...task,
+      pendingAgentAction: {
+        kind: 'skip',
+        agentId,
+        requestedAt: Date.now(),
+      },
+    }
+  })
+}
+
+/**
+ * Retry the current agent step within a running workflow.
+ * Called from BackgroundTasksDialog via the feature-gated
+ * `retryWorkflowAgent` binding: retryWorkflowAgent(taskId, agentId, setAppState).
+ */
+export function retryWorkflowAgent(
+  taskId: string,
+  agentId: AgentId,
+  setAppState: SetAppState,
+): void {
+  logForDebugging(
+    `retryWorkflowAgent: retrying agent ${agentId} in workflow task ${taskId}`,
+  )
+  updateTaskState<LocalWorkflowTaskState>(taskId, setAppState, task => {
+    if (task.status !== 'running') return task
+    return {
+      ...task,
+      pendingAgentAction: {
+        kind: 'retry',
+        agentId,
+        requestedAt: Date.now(),
+      },
+    }
+  })
+}
+
+/**
+ * Kill all running workflow tasks spawned by a given agent.
+ * Called from runAgent.ts finally block.
+ */
+export function killWorkflowTasksForAgent(
+  agentId: AgentId,
+  getAppState: () => AppState,
+  setAppState: SetAppState,
+): void {
+  const tasks = getAppState().tasks ?? {}
+  for (const [taskId, task] of Object.entries(tasks)) {
+    if (
+      isLocalWorkflowTask(task) &&
+      task.agentId === agentId &&
+      task.status === 'running'
+    ) {
+      logForDebugging(
+        `killWorkflowTasksForAgent: killing orphaned workflow task ${taskId} (agent ${agentId} exiting)`,
+      )
+      killWorkflowTask(taskId, setAppState)
+    }
+  }
+}
+
+export const LocalWorkflowTask: Task = {
+  name: 'LocalWorkflowTask',
+  type: 'local_workflow',
+  async kill(taskId: string, setAppState: SetAppState) {
+    killWorkflowTask(taskId, setAppState)
+  },
 }
diff --git a/src/tasks/MonitorMcpTask/MonitorMcpTask.ts b/src/tasks/MonitorMcpTask/MonitorMcpTask.ts
index e5829f1..56cea68 100644
--- a/src/tasks/MonitorMcpTask/MonitorMcpTask.ts
+++ b/src/tasks/MonitorMcpTask/MonitorMcpTask.ts
@@ -1,5 +1,139 @@
-export type MonitorMcpTaskState = Record<string, unknown>
+// Background task entry for MCP resource monitoring.
+// Tracks a long-running subscription to an MCP server resource so the
+// otherwise-invisible stream is visible in the footer pill and Shift+Down
+// dialog. Follows the DreamTask pattern: pure UI surfacing via the existing
+// task registry.
 
-export function isMonitorMcpTask(_value: unknown): boolean {
-  return false
+import type { AppState } from '../../state/AppState.js'
+import type { SetAppState, Task, TaskStateBase } from '../../Task.js'
+import { createTaskStateBase, generateTaskId } from '../../Task.js'
+import type { AgentId } from '../../types/ids.js'
+import { logForDebugging } from '../../utils/debug.js'
+import { registerTask, updateTaskState } from '../../utils/task/framework.js'
+
+export type MonitorMcpTaskState = TaskStateBase & {
+  type: 'monitor_mcp'
+  /** The MCP server name being monitored. */
+  serverName: string
+  /** The resource URI being subscribed to. */
+  resourceUri: string
+  /** The shell command used to drive monitoring (if any). */
+  command?: string
+  /** Agent that spawned this task. Used to kill orphaned tasks on agent exit. */
+  agentId?: AgentId
+  /** Abort controller to cancel the subscription. */
+  abortController?: AbortController
+}
+
+export function isMonitorMcpTask(task: unknown): task is MonitorMcpTaskState {
+  return (
+    typeof task === 'object' &&
+    task !== null &&
+    'type' in task &&
+    task.type === 'monitor_mcp'
+  )
+}
+
+export function registerMonitorMcpTask(
+  setAppState: SetAppState,
+  opts: {
+    description: string
+    serverName: string
+    resourceUri: string
+    command?: string
+    toolUseId?: string
+    agentId?: AgentId
+    abortController?: AbortController
+  },
+): string {
+  const id = generateTaskId('monitor_mcp')
+  const task: MonitorMcpTaskState = {
+    ...createTaskStateBase(id, 'monitor_mcp', opts.description, opts.toolUseId),
+    type: 'monitor_mcp',
+    status: 'running',
+    serverName: opts.serverName,
+    resourceUri: opts.resourceUri,
+    command: opts.command,
+    agentId: opts.agentId,
+    abortController: opts.abortController,
+  }
+  registerTask(task, setAppState)
+  return id
+}
+
+export function completeMonitorMcpTask(
+  taskId: string,
+  setAppState: SetAppState,
+): void {
+  updateTaskState<MonitorMcpTaskState>(taskId, setAppState, task => ({
+    ...task,
+    status: 'completed',
+    endTime: Date.now(),
+    notified: true,
+    abortController: undefined,
+  }))
+}
+
+export function failMonitorMcpTask(
+  taskId: string,
+  setAppState: SetAppState,
+): void {
+  updateTaskState<MonitorMcpTaskState>(taskId, setAppState, task => ({
+    ...task,
+    status: 'failed',
+    endTime: Date.now(),
+    notified: true,
+    abortController: undefined,
+  }))
+}
+
+export function killMonitorMcp(
+  taskId: string,
+  setAppState: SetAppState,
+): void {
+  updateTaskState<MonitorMcpTaskState>(taskId, setAppState, task => {
+    if (task.status !== 'running') return task
+    task.abortController?.abort()
+    return {
+      ...task,
+      status: 'killed',
+      endTime: Date.now(),
+      notified: true,
+      abortController: undefined,
+    }
+  })
+}
+
+/**
+ * Kill all running monitor_mcp tasks spawned by a given agent.
+ * Called from runAgent.ts finally block so subscriptions don't outlive
+ * the agent that started them.
+ */
+export function killMonitorMcpTasksForAgent(
+  agentId: AgentId,
+  getAppState: () => AppState,
+  setAppState: SetAppState,
+): void {
+  const tasks = getAppState().tasks ?? {}
+  for (const [taskId, task] of Object.entries(tasks)) {
+    if (
+      isMonitorMcpTask(task) &&
+      task.agentId === agentId &&
+      task.status === 'running'
+    ) {
+      logForDebugging(
+        `killMonitorMcpTasksForAgent: killing orphaned monitor task ${taskId} (agent ${agentId} exiting)`,
+      )
+      killMonitorMcp(taskId, setAppState)
+    }
+  }
+}
+
+export const MonitorMcpTask: Task = {
+  name: 'MonitorMcpTask',
+  type: 'monitor_mcp',
+
+  async kill(taskId, setAppState) {
+    killMonitorMcp(taskId, setAppState)
+  },
 }
diff --git a/src/tools/CtxInspectTool/CtxInspectTool.ts b/src/tools/CtxInspectTool/CtxInspectTool.ts
new file mode 100644
index 0000000..32218ef
--- /dev/null
+++ b/src/tools/CtxInspectTool/CtxInspectTool.ts
@@ -0,0 +1,80 @@
+import { z } from 'zod/v4'
+import type { ToolResultBlockParam } from '../../Tool.js'
+import { buildTool } from '../../Tool.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+
+const CTX_INSPECT_TOOL_NAME = 'CtxInspect'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    query: z
+      .string()
+      .optional()
+      .describe('Optional query to filter context entries. If omitted, returns a summary of all context.'),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+type CtxInput = z.infer<InputSchema>
+
+type CtxOutput = {
+  total_tokens: number
+  message_count: number
+  summary: string
+}
+
+export const CtxInspectTool = buildTool({
+  name: CTX_INSPECT_TOOL_NAME,
+  searchHint: 'context inspect tokens usage messages window collapse',
+  maxResultSizeChars: 50_000,
+  strict: true,
+
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+
+  async description() {
+    return 'Inspect the current context window contents and token usage'
+  },
+  async prompt() {
+    return `Inspect the current conversation context. Shows token usage, message count, and a breakdown of what's consuming context space.
+
+Use this to understand your context budget before deciding whether to snip old messages or adjust your approach.`
+  },
+
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+
+  userFacingName() {
+    return 'CtxInspect'
+  },
+
+  renderToolUseMessage() {
+    return 'Context Inspect'
+  },
+
+  mapToolResultToToolResultBlockParam(
+    content: CtxOutput,
+    toolUseID: string,
+  ): ToolResultBlockParam {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: `Context: ${content.total_tokens} tokens, ${content.message_count} messages\n${content.summary}`,
+    }
+  },
+
+  async call() {
+    // Context inspection is wired into the context collapse system.
+    return {
+      data: {
+        total_tokens: 0,
+        message_count: 0,
+        summary: 'Context inspection requires the CONTEXT_COLLAPSE runtime.',
+      },
+    }
+  },
+})
diff --git a/src/tools/ListPeersTool/ListPeersTool.ts b/src/tools/ListPeersTool/ListPeersTool.ts
new file mode 100644
index 0000000..7ff3a88
--- /dev/null
+++ b/src/tools/ListPeersTool/ListPeersTool.ts
@@ -0,0 +1,107 @@
+import { z } from 'zod/v4'
+import type { ToolResultBlockParam } from '../../Tool.js'
+import { buildTool } from '../../Tool.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+
+const LIST_PEERS_TOOL_NAME = 'ListPeers'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    include_self: z
+      .boolean()
+      .optional()
+      .describe('Whether to include the current session in the list. Defaults to false.'),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+type ListPeersInput = z.infer<InputSchema>
+
+type PeerInfo = {
+  address: string
+  name?: string
+  cwd?: string
+  pid?: number
+}
+type ListPeersOutput = { peers: PeerInfo[] }
+
+export const ListPeersTool = buildTool({
+  name: LIST_PEERS_TOOL_NAME,
+  searchHint: 'list peers sessions discover uds socket messaging',
+  maxResultSizeChars: 50_000,
+  strict: true,
+
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+
+  async description() {
+    return 'Discover other Claude Code sessions for cross-session messaging'
+  },
+  async prompt() {
+    return `List active Claude Code sessions that can receive messages via SendMessage.
+
+Returns an array of peers with their addresses. Use these addresses as the \`to\` field in SendMessage:
+- \`"uds:/path/to.sock"\` — local sessions on the same machine (Unix Domain Socket)
+- \`"bridge:session_..."\` — remote sessions via Remote Control
+
+Use this tool to discover messaging targets before sending cross-session messages. Only running sessions with active messaging sockets are returned.`
+  },
+
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+
+  userFacingName() {
+    return LIST_PEERS_TOOL_NAME
+  },
+
+  renderToolUseMessage() {
+    return 'ListPeers'
+  },
+
+  mapToolResultToToolResultBlockParam(
+    content: ListPeersOutput,
+    toolUseID: string,
+  ): ToolResultBlockParam {
+    const lines = content.peers.map(
+      p => `${p.address}${p.name ? ` (${p.name})` : ''}${p.cwd ? ` @ ${p.cwd}` : ''}`,
+    )
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content:
+        lines.length > 0
+          ? `Found ${lines.length} peer(s):\n${lines.join('\n')}`
+          : 'No peers found.',
+    }
+  },
+
+  async call(_input: ListPeersInput, context) {
+    // Peer discovery uses the concurrent sessions PID registry and
+    // UDS socket directory. The implementation scans for live sockets
+    // and optionally includes Remote Control bridge peers.
+    const peers: PeerInfo[] = []
+
+    // Discovery is handled by the UDS messaging subsystem initialized in setup.ts.
+    // Return discovered peers from the app state.
+    const appState = context.getAppState()
+    const messagingSocketPath = (appState as Record<string, unknown>).messagingSocketPath as string | undefined
+    if (messagingSocketPath) {
+      // Self entry for reference
+      if (_input.include_self) {
+        peers.push({
+          address: `uds:${messagingSocketPath}`,
+          name: 'self',
+          pid: process.pid,
+        })
+      }
+    }
+
+    return {
+      data: { peers },
+    }
+  },
+})
diff --git a/src/tools/MonitorTool/MonitorTool.ts b/src/tools/MonitorTool/MonitorTool.ts
index 155567b..ae181ee 100644
--- a/src/tools/MonitorTool/MonitorTool.ts
+++ b/src/tools/MonitorTool/MonitorTool.ts
@@ -1 +1,188 @@
-export const MonitorTool = null
+import { z } from 'zod/v4'
+import { TOOL_SUMMARY_MAX_LENGTH } from '../../constants/toolLimits.js'
+import type { ToolResultBlockParam, ToolUseContext, ValidationResult } from '../../Tool.js'
+import { buildTool } from '../../Tool.js'
+import { spawnShellTask } from '../../tasks/LocalShellTask/LocalShellTask.js'
+import { bashToolHasPermission } from '../BashTool/bashPermissions.js'
+import type { PermissionResult } from '../../utils/permissions/PermissionResult.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { truncate } from '../../utils/format.js'
+import { exec } from '../../utils/Shell.js'
+import { getTaskOutputPath } from '../../utils/task/diskOutput.js'
+import { logEvent } from '../../services/analytics/index.js'
+
+const MONITOR_TOOL_NAME = 'Monitor'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    command: z
+      .string()
+      .describe(
+        'The shell command to run as a long-running monitor. Should produce streaming output (e.g., tail -f, watch, polling loops).',
+      ),
+    description: z
+      .string()
+      .describe(
+        'Clear, concise description of what this monitor watches. Used as the label in the background tasks UI.',
+      ),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+export type MonitorInput = z.infer<InputSchema>
+
+const outputSchema = lazySchema(() =>
+  z.object({
+    taskId: z.string(),
+    outputFile: z.string(),
+  }),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+export type MonitorOutput = z.infer<OutputSchema>
+
+export const MonitorTool = buildTool({
+  name: MONITOR_TOOL_NAME,
+  searchHint: 'start long-running background monitor for streaming events',
+  maxResultSizeChars: 10_000,
+  strict: true,
+
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+
+  async description() {
+    return 'Start a long-running background monitor'
+  },
+  async prompt() {
+    return `Use Monitor to start a long-running background process that streams output (watching logs, polling APIs, tailing files, etc.). The command runs in the background and you receive a notification when it exits. Use the Read tool with the output file path to check its output at any time.
+
+Guidelines:
+- Use Monitor for commands that produce ongoing streaming output: \`tail -f\`, log watchers, file watchers, API polling loops, \`watch\` commands
+- Do NOT use Monitor for one-shot commands that finish quickly — use Bash for those
+- Do NOT use Monitor for commands that need interactive input — they will hang
+- The description should clearly explain what is being monitored
+- You'll get a task notification when the monitor process exits (stream ends, script fails, or killed)
+- To check output at any time, use Read on the output file path returned by this tool
+
+Examples:
+- Watching a log file: command="tail -f /var/log/app.log", description="Watch app log for errors"
+- Polling an API: command="while true; do curl -s http://localhost:3000/health; sleep 5; done", description="Poll health endpoint every 5s"
+- Watching for file changes: command="inotifywait -m -r ./src", description="Watch src directory for file changes"`
+  },
+
+  isConcurrencySafe() {
+    return true
+  },
+
+  isReadOnly() {
+    // Monitor executes shell commands which may have side effects
+    return false
+  },
+
+  toAutoClassifierInput(input: MonitorInput) {
+    return `Monitor: ${input.command}`
+  },
+
+  async checkPermissions(
+    input: MonitorInput,
+    context: ToolUseContext,
+  ): Promise<PermissionResult> {
+    // Reuse bash permission checking for the underlying command
+    return bashToolHasPermission(
+      { command: input.command },
+      context,
+    )
+  },
+
+  userFacingName() {
+    return MONITOR_TOOL_NAME
+  },
+
+  getActivityDescription(input: MonitorInput) {
+    if (!input?.description) {
+      return 'Starting monitor'
+    }
+    return `Monitoring: ${truncate(input.description, TOOL_SUMMARY_MAX_LENGTH)}`
+  },
+
+  async validateInput(input: MonitorInput): Promise<ValidationResult> {
+    if (!input.command || input.command.trim() === '') {
+      return {
+        result: false,
+        message: 'Monitor command cannot be empty.',
+        errorCode: 1,
+      }
+    }
+    if (!input.description || input.description.trim() === '') {
+      return {
+        result: false,
+        message: 'Monitor description cannot be empty.',
+        errorCode: 2,
+      }
+    }
+    return { result: true }
+  },
+
+  async call(input: MonitorInput, context: ToolUseContext) {
+    const { command, description } = input
+    const {
+      abortController,
+      setAppState,
+      toolUseID,
+      agentId,
+    } = context
+
+    logEvent('tengu_monitor_tool_used', {})
+
+    // Create the shell command via exec
+    const shellCommand = await exec(command, abortController.signal, 'bash')
+
+    // Spawn as a background task with kind: 'monitor'
+    const handle = await spawnShellTask(
+      {
+        command,
+        description,
+        shellCommand,
+        toolUseId: toolUseID,
+        agentId,
+        kind: 'monitor',
+      },
+      {
+        abortController,
+        getAppState: context.getAppState,
+        setAppState,
+      },
+    )
+
+    const outputFile = getTaskOutputPath(handle.taskId)
+
+    return {
+      data: {
+        taskId: handle.taskId,
+        outputFile,
+      },
+    }
+  },
+
+  renderToolUseMessage(input: MonitorInput, { verbose }) {
+    const desc = truncate(input.description || input.command, 80)
+    return `Monitor: ${desc}`
+  },
+
+  mapToolResultToToolResultBlockParam(
+    content: MonitorOutput,
+    toolUseID: string,
+  ): ToolResultBlockParam {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: `Monitor started (task ${content.taskId}). Output file: ${content.outputFile}`,
+    }
+  },
+
+  renderToolResultMessage(output: MonitorOutput) {
+    return `Monitor started (task ${output.taskId}). Output: ${output.outputFile}`
+  },
+})
diff --git a/src/tools/PushNotificationTool/PushNotificationTool.ts b/src/tools/PushNotificationTool/PushNotificationTool.ts
new file mode 100644
index 0000000..bc73059
--- /dev/null
+++ b/src/tools/PushNotificationTool/PushNotificationTool.ts
@@ -0,0 +1,87 @@
+import { z } from 'zod/v4'
+import type { ToolResultBlockParam } from '../../Tool.js'
+import { buildTool } from '../../Tool.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+
+const PUSH_NOTIFICATION_TOOL_NAME = 'PushNotification'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    title: z
+      .string()
+      .describe('Title of the push notification.'),
+    body: z
+      .string()
+      .describe('Body text of the push notification.'),
+    priority: z
+      .enum(['normal', 'high'])
+      .optional()
+      .describe('Notification priority. Use "high" for blockers or permission prompts.'),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+type PushInput = z.infer<InputSchema>
+
+type PushOutput = { sent: boolean }
+
+export const PushNotificationTool = buildTool({
+  name: PUSH_NOTIFICATION_TOOL_NAME,
+  searchHint: 'push notification mobile alert notify user',
+  maxResultSizeChars: 1_000,
+  strict: true,
+
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+
+  async description() {
+    return 'Send a push notification to the user\'s mobile device'
+  },
+  async prompt() {
+    return `Send a push notification to the user's mobile device via Remote Control.
+
+Use this when:
+- A long-running task completes and the user may not be watching
+- A permission prompt is waiting and you need user input
+- Something urgent requires the user's attention
+
+Requires Remote Control to be configured. Respects user notification settings (taskCompleteNotifEnabled, inputNeededNotifEnabled, agentPushNotifEnabled).`
+  },
+
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+
+  userFacingName() {
+    return 'Notify'
+  },
+
+  renderToolUseMessage(input: Partial<PushInput>) {
+    return `Push: ${input.title ?? '...'}`
+  },
+
+  mapToolResultToToolResultBlockParam(
+    content: PushOutput,
+    toolUseID: string,
+  ): ToolResultBlockParam {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: content.sent ? 'Notification sent.' : 'Failed to send notification.',
+    }
+  },
+
+  async call(_input: PushInput) {
+    // Push delivery is handled by the Remote Control / KAIROS transport layer.
+    // Without the KAIROS runtime, this tool is not available.
+    return {
+      data: {
+        sent: false,
+        error: 'PushNotification requires the KAIROS transport layer.',
+      },
+    }
+  },
+})
diff --git a/src/tools/REPLTool/REPLTool.ts b/src/tools/REPLTool/REPLTool.ts
new file mode 100644
index 0000000..cc9bb80
--- /dev/null
+++ b/src/tools/REPLTool/REPLTool.ts
@@ -0,0 +1,89 @@
+import { z } from 'zod/v4'
+import type { ToolResultBlockParam } from '../../Tool.js'
+import { buildTool } from '../../Tool.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { REPL_TOOL_NAME } from './constants.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    code: z
+      .string()
+      .describe(
+        'The code to execute in the REPL. Can call any primitive tool (Read, Write, Edit, Glob, Grep, Bash, NotebookEdit, Agent) via their APIs.',
+      ),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+type REPLInput = z.infer<InputSchema>
+
+type REPLOutput = { result: string; tool_calls: number }
+
+export const REPLTool = buildTool({
+  name: REPL_TOOL_NAME,
+  searchHint: 'repl execute batch code read write edit glob grep bash',
+  maxResultSizeChars: 100_000,
+  strict: true,
+
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+
+  async description() {
+    return 'Execute code in the REPL environment with access to all primitive tools'
+  },
+  async prompt() {
+    return `Execute code in the REPL — a sandboxed environment with direct access to primitive tools (Read, Write, Edit, Glob, Grep, Bash, NotebookEdit, Agent).
+
+When REPL mode is active, primitive tools are only accessible through this tool. Use REPL for:
+- Batch operations across many files
+- Complex multi-step file transformations
+- Operations that benefit from programmatic control flow
+- Combining search results with edits in a single turn
+
+The REPL runs in a VM context with tool APIs available as functions. Results from each tool call are collected and returned together.`
+  },
+
+  isConcurrencySafe() {
+    return false
+  },
+  isReadOnly() {
+    return false
+  },
+  isTransparentWrapper() {
+    return true
+  },
+
+  userFacingName() {
+    return REPL_TOOL_NAME
+  },
+
+  renderToolUseMessage(input: Partial<REPLInput>) {
+    const code = input.code ?? ''
+    const preview = code.length > 80 ? code.slice(0, 77) + '...' : code
+    return `REPL: ${preview}`
+  },
+
+  mapToolResultToToolResultBlockParam(
+    content: REPLOutput,
+    toolUseID: string,
+  ): ToolResultBlockParam {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: content.result,
+    }
+  },
+
+  async call(_input: REPLInput) {
+    // REPL execution engine is provided by the ant-native runtime.
+    // This stub satisfies the tool interface; the actual VM dispatch
+    // is wired in the ant build. Without the ant runtime, REPL is
+    // not available and callers should be informed.
+    return {
+      data: {
+        result: 'Error: REPL tool is not available in this build. The REPL execution engine requires the ant-native runtime.',
+        tool_calls: 0,
+      },
+    }
+  },
+})
diff --git a/src/tools/ReviewArtifactTool/ReviewArtifactTool.ts b/src/tools/ReviewArtifactTool/ReviewArtifactTool.ts
index 1e84e93..c641257 100644
--- a/src/tools/ReviewArtifactTool/ReviewArtifactTool.ts
+++ b/src/tools/ReviewArtifactTool/ReviewArtifactTool.ts
@@ -1 +1,142 @@
-export const ReviewArtifactTool = null
+import { z } from 'zod/v4'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import React from 'react'
+import { Box, Text } from '../../ink.js'
+
+const REVIEW_ARTIFACT_TOOL_NAME = 'ReviewArtifact'
+
+const DESCRIPTION =
+  'Review an artifact (code snippet, document, or other content) with inline annotations and feedback.'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    artifact: z
+      .string()
+      .describe(
+        'The content of the artifact to review (code snippet, document text, etc.).',
+      ),
+    title: z
+      .string()
+      .optional()
+      .describe(
+        'Optional title or file path for the artifact being reviewed.',
+      ),
+    annotations: z
+      .array(
+        z.object({
+          line: z.number().optional().describe('Line number for the annotation (1-based).'),
+          message: z.string().describe('The annotation or feedback message.'),
+          severity: z
+            .enum(['info', 'warning', 'error', 'suggestion'])
+            .optional()
+            .describe('Severity level of the annotation.'),
+        }),
+      )
+      .describe('List of annotations/comments on the artifact.'),
+    summary: z
+      .string()
+      .optional()
+      .describe('An overall summary of the review.'),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+
+const outputSchema = lazySchema(() =>
+  z.object({
+    artifact: z.string().describe('The reviewed artifact content.'),
+    title: z.string().optional().describe('Title of the reviewed artifact.'),
+    annotationCount: z
+      .number()
+      .describe('Number of annotations applied.'),
+    summary: z.string().optional().describe('Summary of the review.'),
+  }),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+
+export type Output = z.infer<OutputSchema>
+
+export const ReviewArtifactTool = buildTool({
+  name: REVIEW_ARTIFACT_TOOL_NAME,
+  searchHint: 'review code or documents with inline annotations',
+  maxResultSizeChars: 100_000,
+  async description(input) {
+    const { title } = input as { title?: string }
+    return title
+      ? `Claude wants to review: ${title}`
+      : 'Claude wants to review an artifact'
+  },
+  userFacingName() {
+    return 'ReviewArtifact'
+  },
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+  toAutoClassifierInput(input) {
+    return input.title ?? input.artifact.slice(0, 200)
+  },
+  async prompt() {
+    return `Use this tool to present a review of a code snippet, document, or other artifact with inline annotations and feedback. Each annotation can target a specific line and include a severity level. ${DESCRIPTION}`
+  },
+  mapToolResultToToolResultBlockParam(output, toolUseID) {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: `Review delivered with ${output.annotationCount} annotation(s).${output.summary ? ` Summary: ${output.summary}` : ''}`,
+    }
+  },
+  renderToolUseMessage(
+    input: Partial<z.infer<InputSchema>>,
+    { verbose }: { theme?: string; verbose: boolean },
+  ): React.ReactNode {
+    const title = input.title ?? 'Untitled artifact'
+    const count = input.annotations?.length ?? 0
+    if (verbose) {
+      return `Review: "${title}" (${count} annotation(s))`
+    }
+    return title
+  },
+  renderToolResultMessage(
+    output: Output,
+    _progressMessages: unknown[],
+    { verbose }: { verbose: boolean },
+  ): React.ReactNode {
+    if (verbose) {
+      return React.createElement(
+        Box,
+        { flexDirection: 'column' },
+        React.createElement(
+          Text,
+          null,
+          `Reviewed artifact: ${output.title ?? 'Untitled'} (${output.annotationCount} annotations)`,
+        ),
+        output.summary
+          ? React.createElement(Text, { dimColor: true }, output.summary)
+          : null,
+      )
+    }
+    return React.createElement(
+      Text,
+      null,
+      `Review complete: ${output.annotationCount} annotation(s)`,
+    )
+  },
+  async call({ artifact, title, annotations, summary }, _context) {
+    const output: Output = {
+      artifact,
+      title,
+      annotationCount: annotations.length,
+      summary,
+    }
+    return { data: output }
+  },
+} satisfies ToolDef<InputSchema, Output>)
diff --git a/src/tools/SendUserFileTool/SendUserFileTool.ts b/src/tools/SendUserFileTool/SendUserFileTool.ts
new file mode 100644
index 0000000..584872c
--- /dev/null
+++ b/src/tools/SendUserFileTool/SendUserFileTool.ts
@@ -0,0 +1,84 @@
+import { z } from 'zod/v4'
+import type { ToolResultBlockParam } from '../../Tool.js'
+import { buildTool } from '../../Tool.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { SEND_USER_FILE_TOOL_NAME } from './prompt.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    file_path: z
+      .string()
+      .describe('Absolute path to the file to send to the user.'),
+    description: z
+      .string()
+      .optional()
+      .describe('Optional description of the file being sent.'),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+type SendUserFileInput = z.infer<InputSchema>
+
+type SendUserFileOutput = { sent: boolean; file_path: string }
+
+export const SendUserFileTool = buildTool({
+  name: SEND_USER_FILE_TOOL_NAME,
+  searchHint: 'send file to user mobile device upload share',
+  maxResultSizeChars: 5_000,
+  strict: true,
+
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+
+  async description() {
+    return 'Send a file to the user (KAIROS assistant mode)'
+  },
+  async prompt() {
+    return `Send a file to the user's device. Use this in assistant mode when the user requests a file or when a file is relevant to the conversation.
+
+Guidelines:
+- Use absolute paths
+- The file must exist and be readable
+- Large files may take time to transfer`
+  },
+
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+
+  userFacingName() {
+    return 'SendFile'
+  },
+
+  renderToolUseMessage(input: Partial<SendUserFileInput>) {
+    return `Send file: ${input.file_path ?? '...'}`
+  },
+
+  mapToolResultToToolResultBlockParam(
+    content: SendUserFileOutput,
+    toolUseID: string,
+  ): ToolResultBlockParam {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: content.sent
+        ? `File sent: ${content.file_path}`
+        : `Failed to send file: ${content.file_path}`,
+    }
+  },
+
+  async call(_input: SendUserFileInput) {
+    // File transfer is handled by the KAIROS assistant transport layer.
+    // Without the KAIROS runtime, this tool is not available.
+    return {
+      data: {
+        sent: false,
+        file_path: _input.file_path,
+        error: 'SendUserFile requires the KAIROS assistant transport layer.',
+      },
+    }
+  },
+})
diff --git a/src/tools/SleepTool/SleepTool.ts b/src/tools/SleepTool/SleepTool.ts
new file mode 100644
index 0000000..7de55d4
--- /dev/null
+++ b/src/tools/SleepTool/SleepTool.ts
@@ -0,0 +1,100 @@
+import { z } from 'zod/v4'
+import type { ToolResultBlockParam } from '../../Tool.js'
+import { buildTool } from '../../Tool.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { SLEEP_TOOL_NAME, DESCRIPTION, SLEEP_TOOL_PROMPT } from './prompt.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    duration_seconds: z
+      .number()
+      .describe(
+        'How long to sleep in seconds. Can be interrupted by the user at any time.',
+      ),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+type SleepInput = z.infer<InputSchema>
+
+type SleepOutput = { slept_seconds: number; interrupted: boolean }
+
+export const SleepTool = buildTool({
+  name: SLEEP_TOOL_NAME,
+  searchHint: 'wait pause sleep rest idle duration timer',
+  maxResultSizeChars: 1_000,
+  strict: true,
+
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+
+  async description() {
+    return DESCRIPTION
+  },
+  async prompt() {
+    return SLEEP_TOOL_PROMPT
+  },
+
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+
+  userFacingName() {
+    return SLEEP_TOOL_NAME
+  },
+
+  renderToolUseMessage(input: Partial<SleepInput>) {
+    const secs = input.duration_seconds ?? '?'
+    return `Sleep: ${secs}s`
+  },
+
+  mapToolResultToToolResultBlockParam(
+    content: SleepOutput,
+    toolUseID: string,
+  ): ToolResultBlockParam {
+    const msg = content.interrupted
+      ? `Sleep interrupted after ${content.slept_seconds}s`
+      : `Slept for ${content.slept_seconds}s`
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: msg,
+    }
+  },
+
+  async call(input: SleepInput, context) {
+    const { duration_seconds } = input
+    const startTime = Date.now()
+
+    try {
+      await new Promise<void>((resolve, reject) => {
+        const timer = setTimeout(resolve, duration_seconds * 1000)
+        context.abortController.signal.addEventListener(
+          'abort',
+          () => {
+            clearTimeout(timer)
+            reject(new Error('interrupted'))
+          },
+          { once: true },
+        )
+      })
+      return {
+        data: {
+          slept_seconds: duration_seconds,
+          interrupted: false,
+        },
+      }
+    } catch {
+      const elapsed = Math.round((Date.now() - startTime) / 1000)
+      return {
+        data: {
+          slept_seconds: elapsed,
+          interrupted: true,
+        },
+      }
+    }
+  },
+})
diff --git a/src/tools/SnipTool/SnipTool.ts b/src/tools/SnipTool/SnipTool.ts
new file mode 100644
index 0000000..773d403
--- /dev/null
+++ b/src/tools/SnipTool/SnipTool.ts
@@ -0,0 +1,92 @@
+import { z } from 'zod/v4'
+import type { ToolResultBlockParam } from '../../Tool.js'
+import { buildTool } from '../../Tool.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { SNIP_TOOL_NAME } from './prompt.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    message_ids: z
+      .array(z.string())
+      .describe(
+        'IDs of the messages to snip from history. Snipped messages are replaced with a short summary.',
+      ),
+    reason: z
+      .string()
+      .optional()
+      .describe(
+        'Why these messages are being snipped. Used in the summary replacement.',
+      ),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+type SnipInput = z.infer<InputSchema>
+
+type SnipOutput = { snipped_count: number; summary: string }
+
+export const SnipTool = buildTool({
+  name: SNIP_TOOL_NAME,
+  searchHint: 'snip trim history remove old messages compact context',
+  maxResultSizeChars: 5_000,
+  strict: true,
+
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+
+  async description() {
+    return 'Snip messages from conversation history to free up context'
+  },
+  async prompt() {
+    return `Snip messages from your conversation history to free up context window space. Snipped messages are replaced with a compact summary so you retain awareness of what happened without the full content.
+
+Use this when:
+- Your context is getting full and you need to make room
+- Earlier messages contain large tool outputs you no longer need in full
+- You want to compact a long exploration sequence into a summary
+
+Guidelines:
+- Only snip messages you're confident you won't need verbatim again
+- The summary replacement preserves key facts (file paths, decisions, errors found)
+- You cannot un-snip — the original content is gone from context`
+  },
+
+  isConcurrencySafe() {
+    return false
+  },
+  isReadOnly() {
+    return false
+  },
+
+  userFacingName() {
+    return 'Snip'
+  },
+
+  renderToolUseMessage(input: Partial<SnipInput>) {
+    const count = input.message_ids?.length ?? 0
+    return `Snip: ${count} message${count !== 1 ? 's' : ''}`
+  },
+
+  mapToolResultToToolResultBlockParam(
+    content: SnipOutput,
+    toolUseID: string,
+  ): ToolResultBlockParam {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: `Snipped ${content.snipped_count} messages. Summary: ${content.summary}`,
+    }
+  },
+
+  async call(input: SnipInput) {
+    // Snip implementation is handled by the query engine's projection system.
+    // The tool call itself records the intent; the query engine intercepts
+    // snip tool results and adjusts its message projection accordingly.
+    return {
+      data: {
+        snipped_count: input.message_ids.length,
+        summary: input.reason ?? `Snipped ${input.message_ids.length} messages`,
+      },
+    }
+  },
+})
diff --git a/src/tools/SubscribePRTool/SubscribePRTool.ts b/src/tools/SubscribePRTool/SubscribePRTool.ts
new file mode 100644
index 0000000..adb4d71
--- /dev/null
+++ b/src/tools/SubscribePRTool/SubscribePRTool.ts
@@ -0,0 +1,88 @@
+import { z } from 'zod/v4'
+import type { ToolResultBlockParam } from '../../Tool.js'
+import { buildTool } from '../../Tool.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+
+const SUBSCRIBE_PR_TOOL_NAME = 'SubscribePR'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    repo: z
+      .string()
+      .describe('Repository in owner/repo format.'),
+    pr_number: z
+      .number()
+      .describe('Pull request number to subscribe to.'),
+    events: z
+      .array(z.enum(['comment', 'review', 'ci', 'merge', 'close']))
+      .optional()
+      .describe('Event types to subscribe to. Defaults to all events.'),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+type SubscribeInput = z.infer<InputSchema>
+
+type SubscribeOutput = { subscribed: boolean; subscription_id: string }
+
+export const SubscribePRTool = buildTool({
+  name: SUBSCRIBE_PR_TOOL_NAME,
+  searchHint: 'subscribe pull request github webhook events watch',
+  maxResultSizeChars: 5_000,
+  strict: true,
+
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+
+  async description() {
+    return 'Subscribe to pull request events via GitHub webhooks'
+  },
+  async prompt() {
+    return `Subscribe to events on a GitHub pull request. You'll receive notifications when selected events occur (comments, reviews, CI status changes, merge, close).
+
+Use this to monitor PRs you've created or are reviewing. Events are delivered as messages you can act on.`
+  },
+
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+
+  userFacingName() {
+    return 'SubscribePR'
+  },
+
+  renderToolUseMessage(input: Partial<SubscribeInput>) {
+    const pr = input.repo && input.pr_number
+      ? `${input.repo}#${input.pr_number}`
+      : '...'
+    return `Subscribe PR: ${pr}`
+  },
+
+  mapToolResultToToolResultBlockParam(
+    content: SubscribeOutput,
+    toolUseID: string,
+  ): ToolResultBlockParam {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: content.subscribed
+        ? `Subscribed to PR events (id: ${content.subscription_id})`
+        : 'Failed to subscribe to PR events.',
+    }
+  },
+
+  async call(_input: SubscribeInput) {
+    // Webhook subscription is managed by the KAIROS GitHub webhook subsystem.
+    // Without the KAIROS runtime, this tool is not available.
+    return {
+      data: {
+        subscribed: false,
+        subscription_id: '',
+        error: 'SubscribePR requires the KAIROS GitHub webhook subsystem.',
+      },
+    }
+  },
+})
diff --git a/src/tools/SuggestBackgroundPRTool/SuggestBackgroundPRTool.ts b/src/tools/SuggestBackgroundPRTool/SuggestBackgroundPRTool.ts
new file mode 100644
index 0000000..d97ba09
--- /dev/null
+++ b/src/tools/SuggestBackgroundPRTool/SuggestBackgroundPRTool.ts
@@ -0,0 +1,84 @@
+import { z } from 'zod/v4'
+import type { ToolResultBlockParam } from '../../Tool.js'
+import { buildTool } from '../../Tool.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+
+const SUGGEST_BACKGROUND_PR_TOOL_NAME = 'SuggestBackgroundPR'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    title: z
+      .string()
+      .describe('Suggested title for the background PR.'),
+    description: z
+      .string()
+      .describe('Description of the changes to make in the background PR.'),
+    branch: z
+      .string()
+      .optional()
+      .describe('Branch name for the PR. Auto-generated if omitted.'),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+type SuggestInput = z.infer<InputSchema>
+
+type SuggestOutput = { suggested: boolean; suggestion_id: string }
+
+export const SuggestBackgroundPRTool = buildTool({
+  name: SUGGEST_BACKGROUND_PR_TOOL_NAME,
+  searchHint: 'suggest background pr pull request create',
+  maxResultSizeChars: 5_000,
+  strict: true,
+
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+
+  async description() {
+    return 'Suggest creating a background PR for follow-up changes'
+  },
+  async prompt() {
+    return `Suggest creating a pull request in the background for follow-up work. Use this when you identify improvements or cleanup that should be done but aren't part of the current task.
+
+The suggestion is presented to the user who can approve or dismiss it. If approved, a background agent creates the PR.`
+  },
+
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+
+  userFacingName() {
+    return 'SuggestPR'
+  },
+
+  renderToolUseMessage(input: Partial<SuggestInput>) {
+    return `Suggest PR: ${input.title ?? '...'}`
+  },
+
+  mapToolResultToToolResultBlockParam(
+    content: SuggestOutput,
+    toolUseID: string,
+  ): ToolResultBlockParam {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: content.suggested
+        ? `PR suggestion recorded (id: ${content.suggestion_id})`
+        : 'Failed to record PR suggestion.',
+    }
+  },
+
+  async call(_input: SuggestInput) {
+    // Background PR suggestion requires the KAIROS runtime.
+    return {
+      data: {
+        suggested: false,
+        suggestion_id: '',
+        error: 'SuggestBackgroundPR requires the KAIROS runtime.',
+      },
+    }
+  },
+})
diff --git a/src/tools/TerminalCaptureTool/TerminalCaptureTool.ts b/src/tools/TerminalCaptureTool/TerminalCaptureTool.ts
new file mode 100644
index 0000000..9f953a1
--- /dev/null
+++ b/src/tools/TerminalCaptureTool/TerminalCaptureTool.ts
@@ -0,0 +1,82 @@
+import { z } from 'zod/v4'
+import type { ToolResultBlockParam } from '../../Tool.js'
+import { buildTool } from '../../Tool.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { TERMINAL_CAPTURE_TOOL_NAME } from './prompt.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    lines: z
+      .number()
+      .optional()
+      .describe('Number of lines to capture from the terminal. Defaults to 50.'),
+    panel_id: z
+      .string()
+      .optional()
+      .describe('ID of the terminal panel to capture from. Defaults to the active panel.'),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+type CaptureInput = z.infer<InputSchema>
+
+type CaptureOutput = { content: string; line_count: number }
+
+export const TerminalCaptureTool = buildTool({
+  name: TERMINAL_CAPTURE_TOOL_NAME,
+  searchHint: 'terminal capture screen output panel read',
+  maxResultSizeChars: 100_000,
+  strict: true,
+
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+
+  async description() {
+    return 'Capture output from a terminal panel'
+  },
+  async prompt() {
+    return `Capture the current content of a terminal panel. Use this to read output from terminal sessions running in the terminal panel UI.
+
+Guidelines:
+- Specify the number of lines to capture (default 50)
+- Optionally target a specific panel by ID
+- Content is returned as plain text`
+  },
+
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+
+  userFacingName() {
+    return 'TerminalCapture'
+  },
+
+  renderToolUseMessage(input: Partial<CaptureInput>) {
+    const lines = input.lines ?? 50
+    return `Terminal Capture: ${lines} lines`
+  },
+
+  mapToolResultToToolResultBlockParam(
+    content: CaptureOutput,
+    toolUseID: string,
+  ): ToolResultBlockParam {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: content.content || '(empty terminal)',
+    }
+  },
+
+  async call(input: CaptureInput) {
+    // Terminal panel capture is provided by the TERMINAL_PANEL runtime.
+    return {
+      data: {
+        content: '',
+        line_count: 0,
+      },
+    }
+  },
+})
diff --git a/src/tools/VerifyPlanExecutionTool/VerifyPlanExecutionTool.ts b/src/tools/VerifyPlanExecutionTool/VerifyPlanExecutionTool.ts
new file mode 100644
index 0000000..65131d6
--- /dev/null
+++ b/src/tools/VerifyPlanExecutionTool/VerifyPlanExecutionTool.ts
@@ -0,0 +1,93 @@
+import { z } from 'zod/v4'
+import type { ToolResultBlockParam } from '../../Tool.js'
+import { buildTool } from '../../Tool.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { VERIFY_PLAN_EXECUTION_TOOL_NAME } from './constants.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    plan_summary: z
+      .string()
+      .describe('A summary of the plan that was executed.'),
+    verification_notes: z
+      .string()
+      .optional()
+      .describe(
+        'Notes on what was verified and any issues found during verification.',
+      ),
+    all_steps_completed: z
+      .boolean()
+      .describe('Whether all planned steps were completed successfully.'),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+type VerifyInput = z.infer<InputSchema>
+
+type VerifyOutput = { verified: boolean; summary: string }
+
+export const VerifyPlanExecutionTool = buildTool({
+  name: VERIFY_PLAN_EXECUTION_TOOL_NAME,
+  searchHint: 'verify plan execution check completion',
+  maxResultSizeChars: 10_000,
+  strict: true,
+
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+
+  async description() {
+    return 'Verify that a plan was executed correctly before exiting plan mode'
+  },
+  async prompt() {
+    return `Verify that a plan has been executed correctly. Call this tool before exiting plan mode to confirm all steps were completed.
+
+Guidelines:
+- Summarize the plan that was executed
+- Note whether all steps completed successfully
+- Include any verification notes (tests passed, files created, etc.)
+- If steps were skipped or failed, explain why in verification_notes`
+  },
+
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+
+  userFacingName() {
+    return 'VerifyPlan'
+  },
+
+  renderToolUseMessage(input: Partial<VerifyInput>) {
+    if (input.all_steps_completed === true) {
+      return 'Verify Plan: all steps completed'
+    }
+    if (input.all_steps_completed === false) {
+      return 'Verify Plan: incomplete'
+    }
+    return 'Verify Plan'
+  },
+
+  mapToolResultToToolResultBlockParam(
+    content: VerifyOutput,
+    toolUseID: string,
+  ): ToolResultBlockParam {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: content.verified
+        ? `Plan verified: ${content.summary}`
+        : `Plan verification failed: ${content.summary}`,
+    }
+  },
+
+  async call(input: VerifyInput) {
+    return {
+      data: {
+        verified: input.all_steps_completed,
+        summary: input.plan_summary,
+      },
+    }
+  },
+})
diff --git a/src/tools/WebBrowserTool/WebBrowserTool.ts b/src/tools/WebBrowserTool/WebBrowserTool.ts
new file mode 100644
index 0000000..99110ca
--- /dev/null
+++ b/src/tools/WebBrowserTool/WebBrowserTool.ts
@@ -0,0 +1,97 @@
+import { z } from 'zod/v4'
+import type { ToolResultBlockParam } from '../../Tool.js'
+import { buildTool } from '../../Tool.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+
+const WEB_BROWSER_TOOL_NAME = 'WebBrowser'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    url: z
+      .string()
+      .describe('URL to navigate to in the browser.'),
+    action: z
+      .enum(['navigate', 'screenshot', 'click', 'type', 'scroll'])
+      .optional()
+      .describe('Browser action to perform. Defaults to "navigate".'),
+    selector: z
+      .string()
+      .optional()
+      .describe('CSS selector for click/type actions.'),
+    text: z
+      .string()
+      .optional()
+      .describe('Text to type when action is "type".'),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+type BrowserInput = z.infer<InputSchema>
+
+type BrowserOutput = {
+  title: string
+  url: string
+  content?: string
+  screenshot?: string
+}
+
+export const WebBrowserTool = buildTool({
+  name: WEB_BROWSER_TOOL_NAME,
+  searchHint: 'web browser navigate url page screenshot click',
+  maxResultSizeChars: 100_000,
+  strict: true,
+
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+
+  async description() {
+    return 'Browse the web using an embedded browser'
+  },
+  async prompt() {
+    return `Open and interact with web pages in an embedded browser. Supports navigation, screenshots, clicking, typing, and scrolling.
+
+Use this for:
+- Viewing web pages and their content
+- Taking screenshots of UI
+- Interacting with web applications
+- Testing web endpoints with full browser rendering`
+  },
+
+  isConcurrencySafe() {
+    return false
+  },
+  isReadOnly() {
+    return true
+  },
+
+  userFacingName() {
+    return 'Browser'
+  },
+
+  renderToolUseMessage(input: Partial<BrowserInput>) {
+    const action = input.action ?? 'navigate'
+    return `Browser ${action}: ${input.url ?? '...'}`
+  },
+
+  mapToolResultToToolResultBlockParam(
+    content: BrowserOutput,
+    toolUseID: string,
+  ): ToolResultBlockParam {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: `${content.title} (${content.url})\n${content.content ?? ''}`,
+    }
+  },
+
+  async call(input: BrowserInput) {
+    // Browser integration requires the WEB_BROWSER_TOOL runtime (Bun WebView).
+    return {
+      data: {
+        title: '',
+        url: input.url,
+        content: 'Web browser requires the WEB_BROWSER_TOOL runtime.',
+      },
+    }
+  },
+})
diff --git a/src/tools/WorkflowTool/WorkflowPermissionRequest.tsx b/src/tools/WorkflowTool/WorkflowPermissionRequest.tsx
index f1b153a..953bcf1 100644
--- a/src/tools/WorkflowTool/WorkflowPermissionRequest.tsx
+++ b/src/tools/WorkflowTool/WorkflowPermissionRequest.tsx
@@ -1,3 +1,164 @@
-export function WorkflowPermissionRequest() {
-  return null
+import React, { useCallback, useMemo } from 'react'
+import { Box, Text, useTheme } from '../../ink.js'
+import { env } from '../../utils/env.js'
+import { shouldShowAlwaysAllowOptions } from '../../utils/permissions/permissionsLoader.js'
+import { logUnaryEvent } from '../../utils/unaryLogging.js'
+import { PermissionDialog } from '../../components/permissions/PermissionDialog.js'
+import {
+  PermissionPrompt,
+  type PermissionPromptOption,
+} from '../../components/permissions/PermissionPrompt.js'
+import type { PermissionRequestProps } from '../../components/permissions/PermissionRequest.js'
+import { PermissionRuleExplanation } from '../../components/permissions/PermissionRuleExplanation.js'
+
+type OptionValue = 'yes' | 'yes-dont-ask-again' | 'no'
+
+/**
+ * Permission request UI for the WorkflowTool. Asks the user to confirm
+ * executing a workflow script.
+ * Follows the MonitorPermissionRequest / FallbackPermissionRequest pattern.
+ */
+export function WorkflowPermissionRequest({
+  toolUseConfirm,
+  onDone,
+  onReject,
+  workerBadge,
+}: PermissionRequestProps): React.ReactNode {
+  const [theme] = useTheme()
+
+  const input = toolUseConfirm.input as {
+    workflow: string
+    args?: string
+  }
+
+  const showAlwaysAllowOptions = useMemo(
+    () => shouldShowAlwaysAllowOptions(),
+    [],
+  )
+
+  const options: PermissionPromptOption<OptionValue>[] = useMemo(() => {
+    const opts: PermissionPromptOption<OptionValue>[] = [
+      {
+        label: 'Yes',
+        value: 'yes',
+        feedbackConfig: { type: 'accept' as const },
+      },
+    ]
+    if (showAlwaysAllowOptions) {
+      opts.push({
+        label: (
+          <Text>
+            Yes, and don{'\u2019'}t ask again for{' '}
+            <Text bold>{toolUseConfirm.tool.name}</Text> commands
+          </Text>
+        ),
+        value: 'yes-dont-ask-again',
+      })
+    }
+    opts.push({
+      label: 'No',
+      value: 'no',
+      feedbackConfig: { type: 'reject' as const },
+    })
+    return opts
+  }, [showAlwaysAllowOptions, toolUseConfirm.tool.name])
+
+  const handleSelect = useCallback(
+    (value: OptionValue, feedback?: string) => {
+      switch (value) {
+        case 'yes':
+          logUnaryEvent({
+            completion_type: 'tool_use_single',
+            event: 'accept',
+            metadata: {
+              language_name: 'none',
+              message_id: toolUseConfirm.assistantMessage.message.id,
+              platform: env.platform,
+            },
+          })
+          toolUseConfirm.onAllow(toolUseConfirm.input, [], feedback)
+          onDone()
+          break
+        case 'yes-dont-ask-again':
+          logUnaryEvent({
+            completion_type: 'tool_use_single',
+            event: 'accept',
+            metadata: {
+              language_name: 'none',
+              message_id: toolUseConfirm.assistantMessage.message.id,
+              platform: env.platform,
+            },
+          })
+          toolUseConfirm.onAllow(toolUseConfirm.input, [
+            {
+              type: 'addRules',
+              rules: [{ toolName: toolUseConfirm.tool.name }],
+              behavior: 'allow',
+              destination: 'localSettings',
+            },
+          ])
+          onDone()
+          break
+        case 'no':
+          logUnaryEvent({
+            completion_type: 'tool_use_single',
+            event: 'reject',
+            metadata: {
+              language_name: 'none',
+              message_id: toolUseConfirm.assistantMessage.message.id,
+              platform: env.platform,
+            },
+          })
+          toolUseConfirm.onReject(feedback)
+          onReject()
+          onDone()
+          break
+      }
+    },
+    [toolUseConfirm, onDone, onReject],
+  )
+
+  const handleCancel = useCallback(() => {
+    logUnaryEvent({
+      completion_type: 'tool_use_single',
+      event: 'reject',
+      metadata: {
+        language_name: 'none',
+        message_id: toolUseConfirm.assistantMessage.message.id,
+        platform: env.platform,
+      },
+    })
+    toolUseConfirm.onReject()
+    onReject()
+    onDone()
+  }, [toolUseConfirm, onDone, onReject])
+
+  return (
+    <PermissionDialog
+      title="Workflow"
+      workerBadge={workerBadge}
+    >
+      <Box flexDirection="column" gap={1}>
+        <Box flexDirection="column">
+          <Text bold color={theme.permission}>
+            Execute workflow: {input.workflow}
+          </Text>
+          {input.args && (
+            <Text dimColor>
+              Arguments: {input.args}
+            </Text>
+          )}
+        </Box>
+        <PermissionRuleExplanation
+          permissionResult={toolUseConfirm.permissionResult}
+          toolType="command"
+        />
+        <PermissionPrompt<OptionValue>
+          options={options}
+          onSelect={handleSelect}
+          onCancel={handleCancel}
+        />
+      </Box>
+    </PermissionDialog>
+  )
 }
diff --git a/src/tools/WorkflowTool/WorkflowTool.ts b/src/tools/WorkflowTool/WorkflowTool.ts
index 76e8f74..0d2f7a6 100644
--- a/src/tools/WorkflowTool/WorkflowTool.ts
+++ b/src/tools/WorkflowTool/WorkflowTool.ts
@@ -1 +1,75 @@
-export const WorkflowTool = null
+import React from 'react'
+import { z } from 'zod/v4'
+import { Text } from '../../ink.js'
+import type { ToolResultBlockParam } from '../../Tool.js'
+import { buildTool } from '../../Tool.js'
+import { truncate } from '../../utils/format.js'
+import { WORKFLOW_TOOL_NAME } from './constants.js'
+
+const inputSchema = z.object({
+  workflow: z.string().describe('Name of the workflow to execute'),
+  args: z.string().optional().describe('Arguments to pass to the workflow'),
+})
+type Input = typeof inputSchema
+type WorkflowInput = z.infer<Input>
+
+type WorkflowOutput = { output: string }
+
+export const WorkflowTool = buildTool({
+  name: WORKFLOW_TOOL_NAME,
+  searchHint: 'execute user-defined workflow scripts',
+  maxResultSizeChars: 50_000,
+  strict: true,
+
+  inputSchema,
+
+  async description() {
+    return 'Execute a user-defined workflow script from .claude/workflows/'
+  },
+  async prompt() {
+    return `Use the Workflow tool to execute user-defined workflow scripts located in .claude/workflows/. Workflows are YAML or Markdown files that define a sequence of steps for common development tasks.
+
+Guidelines:
+- Specify the workflow name to execute (must match a file in .claude/workflows/)
+- Optionally pass arguments that the workflow can use
+- Workflows run in the context of the current project`
+  },
+  userFacingName() {
+    return 'Workflow'
+  },
+  isReadOnly() {
+    return false
+  },
+  isEnabled() {
+    return true
+  },
+
+  renderToolUseMessage(input: Partial<WorkflowInput>, { verbose }) {
+    const name = input.workflow ?? 'unknown'
+    if (verbose && input.args) {
+      return <Text>Workflow: {name} {input.args}</Text>
+    }
+    return <Text>Workflow: {name}</Text>
+  },
+
+  mapToolResultToToolResultBlockParam(
+    content: WorkflowOutput,
+    toolUseID: string,
+  ): ToolResultBlockParam {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: truncate(content.output, 50_000),
+    }
+  },
+
+  async call(_input: WorkflowInput, _context, _progress) {
+    // Workflow execution is wired by the WORKFLOW_SCRIPTS feature bootstrap.
+    // Without it, this tool is not functional.
+    return {
+      data: {
+        output: 'Error: Workflow execution requires the WORKFLOW_SCRIPTS runtime.',
+      },
+    }
+  },
+})
diff --git a/src/tools/WorkflowTool/bundled/index.ts b/src/tools/WorkflowTool/bundled/index.ts
new file mode 100644
index 0000000..eb6620c
--- /dev/null
+++ b/src/tools/WorkflowTool/bundled/index.ts
@@ -0,0 +1,15 @@
+// Bundled workflow initialization.
+// Called by tools.ts when WORKFLOW_SCRIPTS feature flag is enabled.
+// Sets up any pre-bundled workflow scripts that ship with the CLI.
+
+/**
+ * Initialize bundled workflows. Called once at startup when the
+ * WORKFLOW_SCRIPTS feature flag is active. This is the hook point
+ * for registering any workflow scripts that are compiled into the
+ * binary (as opposed to user-authored ones in .claude/workflows/).
+ */
+export function initBundledWorkflows(): void {
+  // Bundled workflows are registered here at startup.
+  // Currently a no-op — all workflows are user-authored in .claude/workflows/.
+  // This function exists as the extension point for future built-in workflows.
+}
diff --git a/src/tools/WorkflowTool/constants.ts b/src/tools/WorkflowTool/constants.ts
index 444a03a..49249ca 100644
--- a/src/tools/WorkflowTool/constants.ts
+++ b/src/tools/WorkflowTool/constants.ts
@@ -1 +1,3 @@
 export const WORKFLOW_TOOL_NAME = 'workflow'
+export const WORKFLOW_DIR_NAME = '.claude/workflows'
+export const WORKFLOW_FILE_EXTENSIONS = ['.yml', '.yaml', '.md']
diff --git a/src/tools/WorkflowTool/createWorkflowCommand.ts b/src/tools/WorkflowTool/createWorkflowCommand.ts
index 0c940f7..a6369f5 100644
--- a/src/tools/WorkflowTool/createWorkflowCommand.ts
+++ b/src/tools/WorkflowTool/createWorkflowCommand.ts
@@ -1,3 +1,41 @@
-export function createWorkflowCommand() {
-  return null
+import { readdir } from 'fs/promises'
+import { join, parse } from 'path'
+import type { Command } from '../../types/command.js'
+import { WORKFLOW_DIR_NAME, WORKFLOW_FILE_EXTENSIONS } from './constants.js'
+
+/**
+ * Scans .claude/workflows/ directory and creates Command objects for each workflow file.
+ * Each workflow file becomes a slash command (e.g. /workflow-name).
+ */
+export async function getWorkflowCommands(cwd: string): Promise<Command[]> {
+  const workflowDir = join(cwd, WORKFLOW_DIR_NAME)
+  let files: string[]
+  try {
+    files = await readdir(workflowDir)
+  } catch {
+    return []
+  }
+
+  const workflowFiles = files.filter((f) => {
+    const ext = parse(f).ext.toLowerCase()
+    return WORKFLOW_FILE_EXTENSIONS.includes(ext)
+  })
+
+  return workflowFiles.map((file) => {
+    const name = parse(file).name
+    return {
+      type: 'prompt' as const,
+      name,
+      description: `Run workflow: ${name}`,
+      kind: 'workflow' as const,
+      source: 'builtin' as const,
+      progressMessage: `Running workflow ${name}...`,
+      contentLength: 0,
+      async getPromptForCommand(args, _context) {
+        const { readFile } = await import('fs/promises')
+        const content = await readFile(join(workflowDir, file), 'utf-8')
+        return [{ type: 'text' as const, text: `Execute this workflow:\n\n${content}${args ? `\n\nArguments: ${args}` : ''}` }]
+      },
+    } satisfies Command
+  })
 }
diff --git a/src/utils/pipeRepl.ts b/src/utils/pipeRepl.ts
new file mode 100644
index 0000000..940eb00
--- /dev/null
+++ b/src/utils/pipeRepl.ts
@@ -0,0 +1,187 @@
+/**
+ * Pipe REPL - Interactive terminal-to-terminal communication demo
+ *
+ * This module wires up PipeServer / PipeClient to provide a bidirectional
+ * chat + remote-command channel between two independent Claude Code terminals.
+ *
+ * Usage (two separate terminals):
+ *
+ *   Terminal A (server):
+ *     import { startPipeRepl } from './pipeRepl.js'
+ *     await startPipeRepl({ role: 'server', name: 'repl' })
+ *
+ *   Terminal B (client):
+ *     import { startPipeRepl } from './pipeRepl.js'
+ *     await startPipeRepl({ role: 'client', target: 'repl', name: 'client-b' })
+ *
+ * Messages:
+ *   - Plain text  → chat message forwarded to the other side
+ *   - /cmd <expr> → remote command execution request
+ *   - /exit       → graceful disconnect
+ *   - /list       → show all active pipes
+ *   - /ping       → latency check
+ */
+
+import { createInterface } from 'readline'
+import {
+  createPipeServer,
+  connectToPipe,
+  listPipes,
+  type PipeMessage,
+  type PipeServer,
+  type PipeClient,
+} from './pipeTransport.js'
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type PipeReplOptions =
+  | { role: 'server'; name: string }
+  | { role: 'client'; target: string; name?: string }
+
+// ---------------------------------------------------------------------------
+// REPL
+// ---------------------------------------------------------------------------
+
+export async function startPipeRepl(options: PipeReplOptions): Promise<void> {
+  let server: PipeServer | undefined
+  let client: PipeClient | undefined
+
+  // A unified send function set after connection
+  let sendFn: (msg: PipeMessage) => void = () => {}
+
+  const log = (prefix: string, text: string) => {
+    process.stdout.write(`\n${prefix} ${text}\n> `)
+  }
+
+  // Handler for incoming messages (shared by server & client)
+  const handleMessage = (msg: PipeMessage, reply: (m: PipeMessage) => void) => {
+    switch (msg.type) {
+      case 'chat':
+        log(`[${msg.from}]`, msg.data ?? '')
+        break
+
+      case 'cmd':
+        log(`[${msg.from}] CMD:`, msg.data ?? '')
+        // Execute and reply with result
+        try {
+          const { execSync } = require('child_process') as typeof import('child_process')
+          const output = execSync(msg.data ?? '', {
+            encoding: 'utf-8',
+            timeout: 10_000,
+          }).trim()
+          reply({ type: 'result', data: output })
+        } catch (err: unknown) {
+          const errMsg = err instanceof Error ? err.message : String(err)
+          reply({ type: 'result', data: `ERROR: ${errMsg}` })
+        }
+        break
+
+      case 'result':
+        log('[RESULT]', msg.data ?? '(empty)')
+        break
+
+      case 'ping':
+        reply({ type: 'pong', data: new Date().toISOString() })
+        break
+
+      case 'pong':
+        log('[PONG]', `from ${msg.from} at ${msg.data}`)
+        break
+
+      case 'exit':
+        log('[SYSTEM]', `${msg.from} disconnected.`)
+        break
+    }
+  }
+
+  // ---- Setup ----
+
+  if (options.role === 'server') {
+    server = await createPipeServer(options.name)
+
+    // Auto-respond to pings (for health checks)
+    server.onMessage((msg, reply) => {
+      if (msg.type === 'ping') {
+        reply({ type: 'pong', data: new Date().toISOString() })
+      }
+    })
+
+    server.onMessage(handleMessage)
+    sendFn = (msg) => server!.broadcast(msg)
+
+    console.log(`[PIPE SERVER] Listening as "${options.name}"`)
+    console.log(`[PIPE SERVER] Socket: ${server.socketPath}`)
+    console.log(`[PIPE SERVER] Waiting for connections...`)
+
+    server.on('connection', () => {
+      log('[SYSTEM]', `Client connected (${server!.connectionCount} total)`)
+    })
+    server.on('disconnect', () => {
+      log('[SYSTEM]', `Client disconnected (${server!.connectionCount} remaining)`)
+    })
+  } else {
+    const senderName = options.name ?? `client-${process.pid}`
+    client = await connectToPipe(options.target, senderName)
+    client.onMessage(handleMessage)
+    sendFn = (msg) => client!.send(msg)
+
+    console.log(`[PIPE CLIENT] Connected to "${options.target}" as "${senderName}"`)
+  }
+
+  // ---- Interactive loop ----
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: '> ',
+  })
+
+  rl.prompt()
+
+  rl.on('line', async (line) => {
+    const input = line.trim()
+    if (!input) {
+      rl.prompt()
+      return
+    }
+
+    if (input === '/exit') {
+      sendFn({ type: 'exit' })
+      console.log('[SYSTEM] Bye!')
+      if (server) await server.close()
+      if (client) client.disconnect()
+      rl.close()
+      process.exit(0)
+    }
+
+    if (input === '/list') {
+      const pipes = await listPipes()
+      console.log(`[PIPES] Active: ${pipes.length > 0 ? pipes.join(', ') : '(none)'}`)
+      rl.prompt()
+      return
+    }
+
+    if (input === '/ping') {
+      sendFn({ type: 'ping' })
+      rl.prompt()
+      return
+    }
+
+    if (input.startsWith('/cmd ')) {
+      sendFn({ type: 'cmd', data: input.slice(5) })
+      rl.prompt()
+      return
+    }
+
+    // Default: chat message
+    sendFn({ type: 'chat', data: input })
+    rl.prompt()
+  })
+
+  rl.on('close', async () => {
+    if (server) await server.close()
+    if (client) client.disconnect()
+  })
+}
diff --git a/src/utils/pipeTransport.ts b/src/utils/pipeTransport.ts
new file mode 100644
index 0000000..da45559
--- /dev/null
+++ b/src/utils/pipeTransport.ts
@@ -0,0 +1,456 @@
+/**
+ * Named Pipe Transport - Unix domain socket IPC for CLI terminals
+ *
+ * Supports two modes:
+ * 1. Standalone: Two independent terminals chat via pipes
+ * 2. Master-Slave bridge: Master CLI attaches to Slave CLI, forwarding
+ *    prompts and receiving streamed AI output back.
+ *
+ * Each CLI auto-creates a PipeServer at:
+ *   ~/.claude/pipes/{session-short-id}.sock
+ *
+ * Protocol: newline-delimited JSON (NDJSON), one message per line.
+ */
+
+import { createServer, createConnection, type Server, type Socket } from 'net'
+import { mkdir, unlink, readdir } from 'fs/promises'
+import { join } from 'path'
+import { EventEmitter } from 'events'
+import { getClaudeConfigHomeDir } from './envUtils.js'
+import { logError } from './log.js'
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/**
+ * Message types exchanged over the pipe.
+ *
+ * Basic:        ping, pong
+ * Control:      attach_request, attach_accept, attach_reject, detach
+ * Data (M→S):   prompt           — master sends user input to slave
+ * Data (S→M):   stream           — slave streams AI output fragments
+ *               tool_start       — slave notifies tool execution start
+ *               tool_result      — slave notifies tool result
+ *               done             — slave signals turn complete
+ *               error            — either side reports an error
+ * Legacy:       chat, cmd, result, exit  — kept for backward compat
+ */
+export type PipeMessageType =
+  // Basic
+  | 'ping'
+  | 'pong'
+  // Control flow (master-slave bridge)
+  | 'attach_request'
+  | 'attach_accept'
+  | 'attach_reject'
+  | 'detach'
+  // Data flow (master → slave)
+  | 'prompt'
+  // Data flow (slave → master)
+  | 'stream'
+  | 'tool_start'
+  | 'tool_result'
+  | 'done'
+  | 'error'
+  // Legacy (standalone chat demo)
+  | 'chat'
+  | 'cmd'
+  | 'result'
+  | 'exit'
+
+export type PipeMessage = {
+  /** Discriminator */
+  type: PipeMessageType
+  /** Payload (text, command output, prompt, stream fragment, etc.) */
+  data?: string
+  /** Sender pipe name */
+  from?: string
+  /** ISO timestamp */
+  ts?: string
+  /** Additional metadata (tool name, error details, etc.) */
+  meta?: Record<string, unknown>
+}
+
+export type PipeMessageHandler = (msg: PipeMessage, reply: (msg: PipeMessage) => void) => void
+
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+
+function getPipesDir(): string {
+  return join(getClaudeConfigHomeDir(), 'pipes')
+}
+
+export function getPipePath(name: string): string {
+  const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '_')
+  if (process.platform === 'win32') {
+    return `\\\\.\\pipe\\claude-code-${safeName}`
+  }
+  return join(getPipesDir(), `${safeName}.sock`)
+}
+
+async function ensurePipesDir(): Promise<void> {
+  await mkdir(getPipesDir(), { recursive: true })
+}
+
+// ---------------------------------------------------------------------------
+// Server (listener side)
+// ---------------------------------------------------------------------------
+
+export class PipeServer extends EventEmitter {
+  private server: Server | null = null
+  private clients: Set<Socket> = new Set()
+  private handlers: PipeMessageHandler[] = []
+  readonly name: string
+  readonly socketPath: string
+
+  constructor(name: string) {
+    super()
+    this.name = name
+    this.socketPath = getPipePath(name)
+  }
+
+  /**
+   * Start listening for incoming connections.
+   */
+  async start(): Promise<void> {
+    await ensurePipesDir()
+
+    // Clean up stale socket file (Unix only)
+    if (process.platform !== 'win32') {
+      try {
+        await unlink(this.socketPath)
+      } catch {
+        // File doesn't exist — fine
+      }
+    }
+
+    return new Promise((resolve, reject) => {
+      this.server = createServer((socket) => {
+        this.clients.add(socket)
+        this.emit('connection', socket)
+
+        let buffer = ''
+
+        socket.on('data', (chunk) => {
+          buffer += chunk.toString()
+          const lines = buffer.split('\n')
+          buffer = lines.pop() ?? ''
+
+          for (const line of lines) {
+            if (!line.trim()) continue
+            try {
+              const msg = JSON.parse(line) as PipeMessage
+              this.emit('message', msg)
+              const reply = (replyMsg: PipeMessage) => {
+                replyMsg.from = replyMsg.from ?? this.name
+                replyMsg.ts = replyMsg.ts ?? new Date().toISOString()
+                if (!socket.destroyed) {
+                  socket.write(JSON.stringify(replyMsg) + '\n')
+                }
+              }
+              for (const handler of this.handlers) {
+                handler(msg, reply)
+              }
+            } catch {
+              // Malformed JSON — skip
+            }
+          }
+        })
+
+        socket.on('close', () => {
+          this.clients.delete(socket)
+          this.emit('disconnect', socket)
+        })
+
+        socket.on('error', (err) => {
+          this.clients.delete(socket)
+          logError(err)
+        })
+      })
+
+      this.server.on('error', reject)
+
+      this.server.listen(this.socketPath, () => {
+        resolve()
+      })
+    })
+  }
+
+  /**
+   * Register a handler for incoming messages.
+   */
+  onMessage(handler: PipeMessageHandler): void {
+    this.handlers.push(handler)
+  }
+
+  /**
+   * Broadcast a message to all connected clients.
+   */
+  broadcast(msg: PipeMessage): void {
+    msg.from = msg.from ?? this.name
+    msg.ts = msg.ts ?? new Date().toISOString()
+    const line = JSON.stringify(msg) + '\n'
+    for (const client of this.clients) {
+      if (!client.destroyed) {
+        client.write(line)
+      }
+    }
+  }
+
+  /**
+   * Send to a specific socket (used for directed replies in attach flow).
+   */
+  sendTo(socket: Socket, msg: PipeMessage): void {
+    msg.from = msg.from ?? this.name
+    msg.ts = msg.ts ?? new Date().toISOString()
+    if (!socket.destroyed) {
+      socket.write(JSON.stringify(msg) + '\n')
+    }
+  }
+
+  get connectionCount(): number {
+    return this.clients.size
+  }
+
+  async close(): Promise<void> {
+    for (const client of this.clients) {
+      client.destroy()
+    }
+    this.clients.clear()
+
+    return new Promise((resolve) => {
+      if (!this.server) {
+        resolve()
+        return
+      }
+      this.server.close(() => {
+        this.server = null
+        if (process.platform !== 'win32') {
+          void unlink(this.socketPath).catch(() => {})
+        }
+        resolve()
+      })
+    })
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Client (connector side)
+// ---------------------------------------------------------------------------
+
+export class PipeClient extends EventEmitter {
+  private socket: Socket | null = null
+  private handlers: PipeMessageHandler[] = []
+  readonly targetName: string
+  readonly senderName: string
+  readonly socketPath: string
+
+  constructor(targetName: string, senderName?: string) {
+    super()
+    this.targetName = targetName
+    this.senderName = senderName ?? `client-${process.pid}`
+    this.socketPath = getPipePath(targetName)
+  }
+
+  /**
+   * Connect to a remote pipe server.
+   * Retries automatically if the socket file doesn't exist yet (ENOENT).
+   */
+  async connect(timeoutMs: number = 5000): Promise<void> {
+    const { access } = await import('fs/promises')
+    const deadline = Date.now() + timeoutMs
+    const retryDelayMs = 300
+
+    // Wait for socket file to exist (Unix only)
+    if (process.platform !== 'win32') {
+      while (Date.now() < deadline) {
+        try {
+          await access(this.socketPath)
+          break
+        } catch {
+          if (Date.now() + retryDelayMs >= deadline) {
+            throw new Error(
+              `Pipe "${this.targetName}" not found at ${this.socketPath}. Is the server running?`,
+            )
+          }
+          await new Promise((r) => setTimeout(r, retryDelayMs))
+        }
+      }
+    }
+
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`Connection to pipe "${this.targetName}" timed out after ${timeoutMs}ms`))
+      }, Math.max(deadline - Date.now(), 1000))
+
+      const socket = createConnection({ path: this.socketPath }, () => {
+        clearTimeout(timer)
+        this.socket = socket
+        this.setupSocketListeners(socket)
+        this.emit('connected')
+        resolve()
+      })
+
+      socket.on('error', (err) => {
+        clearTimeout(timer)
+        socket.destroy()
+        reject(err)
+      })
+    })
+  }
+
+  private setupSocketListeners(socket: Socket): void {
+    let buffer = ''
+
+    socket.on('data', (chunk) => {
+      buffer += chunk.toString()
+      const lines = buffer.split('\n')
+      buffer = lines.pop() ?? ''
+
+      for (const line of lines) {
+        if (!line.trim()) continue
+        try {
+          const msg = JSON.parse(line) as PipeMessage
+          this.emit('message', msg)
+          const reply = (replyMsg: PipeMessage) => this.send(replyMsg)
+          for (const handler of this.handlers) {
+            handler(msg, reply)
+          }
+        } catch {
+          // Malformed JSON — skip
+        }
+      }
+    })
+
+    socket.on('close', () => {
+      this.emit('disconnect')
+    })
+
+    socket.on('error', (err) => {
+      logError(err)
+    })
+  }
+
+  onMessage(handler: PipeMessageHandler): void {
+    this.handlers.push(handler)
+  }
+
+  send(msg: PipeMessage): void {
+    if (!this.socket || this.socket.destroyed) {
+      throw new Error(`Not connected to pipe "${this.targetName}"`)
+    }
+    msg.from = msg.from ?? this.senderName
+    msg.ts = msg.ts ?? new Date().toISOString()
+    this.socket.write(JSON.stringify(msg) + '\n')
+  }
+
+  disconnect(): void {
+    if (this.socket) {
+      this.socket.destroy()
+      this.socket = null
+    }
+  }
+
+  get connected(): boolean {
+    return this.socket !== null && !this.socket.destroyed
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Convenience factory functions
+// ---------------------------------------------------------------------------
+
+export async function createPipeServer(name: string): Promise<PipeServer> {
+  const server = new PipeServer(name)
+  await server.start()
+  return server
+}
+
+export async function connectToPipe(
+  targetName: string,
+  senderName?: string,
+  timeoutMs?: number,
+): Promise<PipeClient> {
+  const client = new PipeClient(targetName, senderName)
+  await client.connect(timeoutMs)
+  return client
+}
+
+/**
+ * List all active pipe names (by scanning the pipes directory).
+ */
+export async function listPipes(): Promise<string[]> {
+  try {
+    await ensurePipesDir()
+    const files = await readdir(getPipesDir())
+    return files
+      .filter((f) => f.endsWith('.sock'))
+      .map((f) => f.replace(/\.sock$/, ''))
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Probe whether a pipe server is alive by sending a ping.
+ */
+export async function isPipeAlive(name: string, timeoutMs: number = 2000): Promise<boolean> {
+  try {
+    const client = new PipeClient(name, '_probe')
+    await client.connect(timeoutMs)
+
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        client.disconnect()
+        resolve(false)
+      }, timeoutMs)
+
+      client.onMessage((msg) => {
+        if (msg.type === 'pong') {
+          clearTimeout(timer)
+          client.disconnect()
+          resolve(true)
+        }
+      })
+
+      client.send({ type: 'ping' })
+    })
+  } catch {
+    return false
+  }
+}
+
+// ─── PipeIpc AppState extension ──────────────────────────────────────
+// AppState.pipeIpc is added at runtime when feature('PIPE_IPC') is on.
+// These types and the default accessor ensure safe access from hooks
+// and commands without modifying the original AppStateStore.
+
+export type PipeIpcSlaveState = {
+  client: PipeClient | null
+  history: Array<{ type: string; content: string; from: string; timestamp: string; meta?: Record<string, unknown> }>
+}
+
+export type PipeIpcState = {
+  role: 'standalone' | 'master' | 'slave'
+  serverName: string | null
+  attachedBy: string | null
+  slaves: Record<string, PipeIpcSlaveState>
+}
+
+const DEFAULT_PIPE_IPC: PipeIpcState = {
+  role: 'standalone',
+  serverName: null,
+  attachedBy: null,
+  slaves: {},
+}
+
+/**
+ * Safely read pipeIpc from AppState, returning the default if not yet initialized.
+ * This avoids crashes when the state hasn't been extended by the PIPE_IPC bootstrap.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getPipeIpc(state: any): PipeIpcState {
+  return state?.pipeIpc ?? DEFAULT_PIPE_IPC
+}
diff --git a/src/utils/udsClient.ts b/src/utils/udsClient.ts
index 934cdeb..781f3dd 100644
--- a/src/utils/udsClient.ts
+++ b/src/utils/udsClient.ts
@@ -1,3 +1,219 @@
-export async function createUdsClient() {
-  return null
+/**
+ * UDS Client — connect to peer Claude Code sessions via Unix Domain Sockets.
+ *
+ * Peers are discovered by reading the PID-file registry in ~/.claude/sessions/
+ * (written by concurrentSessions.ts) and checking each entry's
+ * `messagingSocketPath` field. A peer is "alive" if its PID is running and
+ * its socket accepts a ping/pong round-trip.
+ */
+
+import { createConnection, type Socket } from 'net'
+import { readdir, readFile } from 'fs/promises'
+import { join } from 'path'
+import { getClaudeConfigHomeDir } from './envUtils.js'
+import { logForDebugging } from './debug.js'
+import { errorMessage, isFsInaccessible } from './errors.js'
+import { isProcessRunning } from './genericProcessUtils.js'
+import { jsonParse, jsonStringify } from './slowOperations.js'
+import type { SessionKind } from './concurrentSessions.js'
+import type { UdsMessage } from './udsMessaging.js'
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type PeerSession = {
+  pid: number
+  sessionId?: string
+  cwd?: string
+  startedAt?: number
+  kind?: SessionKind
+  name?: string
+  messagingSocketPath?: string
+  entrypoint?: string
+  bridgeSessionId?: string | null
+  alive: boolean
+}
+
+// ---------------------------------------------------------------------------
+// Session directory
+// ---------------------------------------------------------------------------
+
+function getSessionsDir(): string {
+  return join(getClaudeConfigHomeDir(), 'sessions')
+}
+
+// ---------------------------------------------------------------------------
+// Discovery
+// ---------------------------------------------------------------------------
+
+/**
+ * List all live sessions from the PID registry, optionally probing their
+ * UDS sockets for liveness. Sessions whose PID is no longer running are
+ * excluded (and their stale files cleaned up).
+ */
+export async function listAllLiveSessions(): Promise<PeerSession[]> {
+  const dir = getSessionsDir()
+  let files: string[]
+  try {
+    files = await readdir(dir)
+  } catch (e) {
+    if (!isFsInaccessible(e)) {
+      logForDebugging(`[udsClient] readdir failed: ${errorMessage(e)}`)
+    }
+    return []
+  }
+
+  const results: PeerSession[] = []
+
+  for (const file of files) {
+    if (!/^\d+\.json$/.test(file)) continue
+    const pid = parseInt(file.slice(0, -5), 10)
+
+    if (!isProcessRunning(pid)) {
+      // Stale — skip (concurrentSessions handles cleanup)
+      continue
+    }
+
+    try {
+      const raw = await readFile(join(dir, file), 'utf8')
+      const data = jsonParse(raw) as Record<string, unknown>
+      results.push({
+        pid,
+        sessionId: data.sessionId as string | undefined,
+        cwd: data.cwd as string | undefined,
+        startedAt: data.startedAt as number | undefined,
+        kind: data.kind as SessionKind | undefined,
+        name: data.name as string | undefined,
+        messagingSocketPath: data.messagingSocketPath as string | undefined,
+        entrypoint: data.entrypoint as string | undefined,
+        bridgeSessionId: data.bridgeSessionId as string | null | undefined,
+        alive: true,
+      })
+    } catch {
+      // Corrupted file — skip
+    }
+  }
+
+  return results
+}
+
+/**
+ * List peer sessions that have a UDS messaging socket (i.e. can receive
+ * messages). Excludes the current process.
+ */
+export async function listPeers(): Promise<PeerSession[]> {
+  const all = await listAllLiveSessions()
+  return all.filter(
+    s => s.pid !== process.pid && s.messagingSocketPath != null,
+  )
+}
+
+// ---------------------------------------------------------------------------
+// Connection helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Probe a UDS socket to check if a server is listening (ping/pong).
+ * Returns true if the peer responds within the timeout.
+ */
+export async function isPeerAlive(socketPath: string, timeoutMs = 3000): Promise<boolean> {
+  return new Promise<boolean>((resolve) => {
+    const conn = createConnection(socketPath, () => {
+      const ping: UdsMessage = { type: 'ping', ts: new Date().toISOString() }
+      conn.write(jsonStringify(ping) + '\n')
+    })
+
+    let resolved = false
+
+    const timer = setTimeout(() => {
+      if (!resolved) {
+        resolved = true
+        conn.destroy()
+        resolve(false)
+      }
+    }, timeoutMs)
+
+    let buffer = ''
+    conn.on('data', (chunk) => {
+      buffer += chunk.toString()
+      if (buffer.includes('"pong"')) {
+        if (!resolved) {
+          resolved = true
+          clearTimeout(timer)
+          conn.end()
+          resolve(true)
+        }
+      }
+    })
+
+    conn.on('error', () => {
+      if (!resolved) {
+        resolved = true
+        clearTimeout(timer)
+        resolve(false)
+      }
+    })
+  })
+}
+
+/**
+ * Send a text message to a peer's UDS socket. This is the high-level helper
+ * used by SendMessageTool for `uds:<path>` addresses.
+ */
+export async function sendToUdsSocket(
+  targetSocketPath: string,
+  message: string | Record<string, unknown>,
+): Promise<void> {
+  const data = typeof message === 'string' ? message : jsonStringify(message)
+  const udsMsg: UdsMessage = {
+    type: 'text',
+    data,
+    ts: new Date().toISOString(),
+  }
+
+  // Lazily import to avoid circular dep at module-load time
+  const { getUdsMessagingSocketPath } = await import('./udsMessaging.js')
+  udsMsg.from = getUdsMessagingSocketPath()
+
+  return new Promise<void>((resolve, reject) => {
+    const conn = createConnection(targetSocketPath, () => {
+      conn.write(jsonStringify(udsMsg) + '\n', (err) => {
+        conn.end()
+        if (err) reject(err)
+        else resolve()
+      })
+    })
+    conn.on('error', (err) => {
+      reject(new Error(`Failed to connect to peer at ${targetSocketPath}: ${errorMessage(err)}`))
+    })
+    conn.setTimeout(5000, () => {
+      conn.destroy(new Error('Connection timed out'))
+    })
+  })
+}
+
+/**
+ * Connect to a peer and return the raw socket for bidirectional communication.
+ * The caller is responsible for managing the connection lifecycle.
+ */
+export function connectToPeer(socketPath: string): Promise<Socket> {
+  return new Promise<Socket>((resolve, reject) => {
+    const conn = createConnection(socketPath, () => {
+      resolve(conn)
+    })
+    conn.on('error', reject)
+    conn.setTimeout(5000, () => {
+      conn.destroy(new Error('Connection timed out'))
+    })
+  })
+}
+
+/**
+ * Disconnect a previously connected peer socket.
+ */
+export function disconnectPeer(socket: Socket): void {
+  if (!socket.destroyed) {
+    socket.end()
+  }
 }
diff --git a/src/utils/udsMessaging.ts b/src/utils/udsMessaging.ts
index 22e2a81..8bcd507 100644
--- a/src/utils/udsMessaging.ts
+++ b/src/utils/udsMessaging.ts
@@ -1 +1,270 @@
-export async function sendUdsMessage(): Promise<void> {}
+/**
+ * UDS Messaging Layer — Unix Domain Socket IPC for Claude Code instances.
+ *
+ * Each session auto-creates a UDS server so peer sessions can send messages.
+ * Protocol: newline-delimited JSON (NDJSON), one message per line.
+ *
+ * Socket path defaults to a tmpdir-based path derived from the session PID,
+ * but can be overridden via --messaging-socket-path.
+ */
+
+import { createServer, type Server, type Socket } from 'net'
+import { mkdir, unlink } from 'fs/promises'
+import { dirname, join } from 'path'
+import { tmpdir } from 'os'
+import { registerCleanup } from './cleanupRegistry.js'
+import { logForDebugging } from './debug.js'
+import { errorMessage } from './errors.js'
+import { jsonParse, jsonStringify } from './slowOperations.js'
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type UdsMessageType =
+  | 'text'
+  | 'notification'
+  | 'query'
+  | 'response'
+  | 'ping'
+  | 'pong'
+
+export type UdsMessage = {
+  /** Discriminator */
+  type: UdsMessageType
+  /** Payload text / JSON content */
+  data?: string
+  /** Sender socket path (so the receiver can reply) */
+  from?: string
+  /** ISO timestamp */
+  ts?: string
+  /** Optional metadata */
+  meta?: Record<string, unknown>
+}
+
+export type UdsInboxEntry = {
+  id: string
+  message: UdsMessage
+  receivedAt: number
+  status: 'pending' | 'processed'
+}
+
+// ---------------------------------------------------------------------------
+// Module state
+// ---------------------------------------------------------------------------
+
+let server: Server | null = null
+let socketPath: string | null = null
+let onEnqueueCb: (() => void) | null = null
+const clients = new Set<Socket>()
+const inbox: UdsInboxEntry[] = []
+let nextId = 1
+
+// ---------------------------------------------------------------------------
+// Public API — socket path helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Default socket path based on PID, placed in a tmpdir subdirectory so it
+ * survives across config-home changes and avoids polluting ~/.claude.
+ */
+export function getDefaultUdsSocketPath(): string {
+  return join(tmpdir(), 'claude-code-socks', `${process.pid}.sock`)
+}
+
+/**
+ * Returns the socket path of the currently running server, or undefined
+ * if the server has not been started.
+ */
+export function getUdsMessagingSocketPath(): string | undefined {
+  return socketPath ?? undefined
+}
+
+// ---------------------------------------------------------------------------
+// Inbox
+// ---------------------------------------------------------------------------
+
+/**
+ * Register a callback invoked whenever a message is enqueued into the inbox.
+ * Used by the print/SDK query loop to kick off processing.
+ */
+export function setOnEnqueue(cb: (() => void) | null): void {
+  onEnqueueCb = cb
+}
+
+/**
+ * Drain all pending inbox messages, marking them processed.
+ */
+export function drainInbox(): UdsInboxEntry[] {
+  const pending = inbox.filter(e => e.status === 'pending')
+  for (const entry of pending) {
+    entry.status = 'processed'
+  }
+  return pending
+}
+
+// ---------------------------------------------------------------------------
+// Server
+// ---------------------------------------------------------------------------
+
+/**
+ * Start the UDS messaging server on the given socket path.
+ *
+ * Exports `CLAUDE_CODE_MESSAGING_SOCKET` into `process.env` so child
+ * processes (hooks, spawned agents) can discover and connect back.
+ */
+export async function startUdsMessaging(
+  path: string,
+  opts?: { isExplicit?: boolean },
+): Promise<void> {
+  if (server) {
+    logForDebugging('[udsMessaging] server already running, skipping start')
+    return
+  }
+
+  // Ensure parent directory exists
+  await mkdir(dirname(path), { recursive: true })
+
+  // Clean up stale socket file
+  try {
+    await unlink(path)
+  } catch {
+    // ENOENT is fine
+  }
+
+  socketPath = path
+
+  await new Promise<void>((resolve, reject) => {
+    const srv = createServer((socket) => {
+      clients.add(socket)
+      logForDebugging(`[udsMessaging] client connected (total: ${clients.size})`)
+
+      let buffer = ''
+
+      socket.on('data', (chunk) => {
+        buffer += chunk.toString()
+        const lines = buffer.split('\n')
+        buffer = lines.pop() ?? ''
+
+        for (const line of lines) {
+          if (!line.trim()) continue
+          try {
+            const msg = jsonParse(line) as UdsMessage
+
+            // Handle ping with automatic pong
+            if (msg.type === 'ping') {
+              const pong: UdsMessage = {
+                type: 'pong',
+                from: socketPath ?? undefined,
+                ts: new Date().toISOString(),
+              }
+              if (!socket.destroyed) {
+                socket.write(jsonStringify(pong) + '\n')
+              }
+              continue
+            }
+
+            // Enqueue into inbox
+            const entry: UdsInboxEntry = {
+              id: `uds-${nextId++}`,
+              message: msg,
+              receivedAt: Date.now(),
+              status: 'pending',
+            }
+            inbox.push(entry)
+            logForDebugging(
+              `[udsMessaging] enqueued message type=${msg.type} from=${msg.from ?? 'unknown'}`,
+            )
+            onEnqueueCb?.()
+          } catch {
+            // Malformed JSON — skip
+          }
+        }
+      })
+
+      socket.on('close', () => {
+        clients.delete(socket)
+      })
+
+      socket.on('error', (err) => {
+        clients.delete(socket)
+        logForDebugging(`[udsMessaging] client error: ${errorMessage(err)}`)
+      })
+    })
+
+    srv.on('error', reject)
+
+    srv.listen(path, () => {
+      server = srv
+      // Export so child processes can discover the socket
+      process.env.CLAUDE_CODE_MESSAGING_SOCKET = path
+      logForDebugging(
+        `[udsMessaging] server listening on ${path}${opts?.isExplicit ? ' (explicit)' : ''}`,
+      )
+      resolve()
+    })
+  })
+
+  // Register cleanup so the socket file is removed on exit
+  registerCleanup(async () => {
+    await stopUdsMessaging()
+  })
+}
+
+/**
+ * Stop the UDS messaging server and clean up the socket file.
+ */
+export async function stopUdsMessaging(): Promise<void> {
+  if (!server) return
+
+  // Close all connected clients
+  for (const socket of clients) {
+    socket.destroy()
+  }
+  clients.clear()
+
+  await new Promise<void>((resolve) => {
+    server!.close(() => resolve())
+  })
+  server = null
+
+  // Remove socket file
+  if (socketPath) {
+    try {
+      await unlink(socketPath)
+    } catch {
+      // Already gone
+    }
+    delete process.env.CLAUDE_CODE_MESSAGING_SOCKET
+    logForDebugging(`[udsMessaging] server stopped, socket removed: ${socketPath}`)
+    socketPath = null
+  }
+}
+
+/**
+ * Send a UDS message to a specific socket path (outbound — used when this
+ * session wants to push a message to a peer's server).
+ */
+export async function sendUdsMessage(
+  targetSocketPath: string,
+  message: UdsMessage,
+): Promise<void> {
+  const { createConnection } = await import('net')
+  message.from = message.from ?? socketPath ?? undefined
+  message.ts = message.ts ?? new Date().toISOString()
+
+  return new Promise<void>((resolve, reject) => {
+    const conn = createConnection(targetSocketPath, () => {
+      conn.write(jsonStringify(message) + '\n', (err) => {
+        conn.end()
+        if (err) reject(err)
+        else resolve()
+      })
+    })
+    conn.on('error', reject)
+    // Timeout so we don't hang on unreachable sockets
+    conn.setTimeout(5000, () => {
+      conn.destroy(new Error('Connection timed out'))
+    })
+  })
+}
diff --git a/test-pipe-ipc.ts b/test-pipe-ipc.ts
new file mode 100644
index 0000000..182d1ea
--- /dev/null
+++ b/test-pipe-ipc.ts
@@ -0,0 +1,450 @@
+#!/usr/bin/env bun
+/**
+ * 双进程 Pipe IPC 端到端测试
+ *
+ * 模拟两个独立 CLI 的完整通信流程：
+ * 1. 进程 A（slave）：启动 PipeServer，等待 attach
+ * 2. 进程 B（master）：连接到 A，发送 attach_request，发送 prompt，接收 stream/done
+ *
+ * 用法：
+ *   bun run test-pipe-ipc.ts
+ *
+ * 或分别测试两个独立进程：
+ *   bun run test-pipe-ipc.ts slave
+ *   bun run test-pipe-ipc.ts master
+ */
+
+import {
+  createPipeServer,
+  connectToPipe,
+  listPipes,
+  isPipeAlive,
+  type PipeMessage,
+  type PipeServer,
+  type PipeClient,
+} from './src/utils/pipeTransport.js'
+
+const SLAVE_PIPE = 'test-slave-001'
+const MASTER_NAME = 'test-master-001'
+
+// ─── Colors for output ───
+const RED = '\x1b[31m'
+const GREEN = '\x1b[32m'
+const YELLOW = '\x1b[33m'
+const CYAN = '\x1b[36m'
+const RESET = '\x1b[0m'
+
+function log(role: string, msg: string) {
+  const color = role === 'SLAVE' ? CYAN : YELLOW
+  const ts = new Date().toISOString().slice(11, 23)
+  console.log(`${color}[${ts}] [${role}]${RESET} ${msg}`)
+}
+
+function pass(test: string) {
+  console.log(`  ${GREEN}✓ PASS${RESET}: ${test}`)
+}
+
+function fail(test: string, reason: string) {
+  console.log(`  ${RED}✗ FAIL${RESET}: ${test} — ${reason}`)
+  process.exitCode = 1
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Slave Process: starts PipeServer, handles attach/prompt/detach
+// ═══════════════════════════════════════════════════════════════
+async function runSlave(): Promise<PipeServer> {
+  log('SLAVE', `Starting PipeServer "${SLAVE_PIPE}"...`)
+  const server = await createPipeServer(SLAVE_PIPE)
+  log('SLAVE', `Server started at ${server.socketPath}`)
+
+  let role: 'standalone' | 'slave' = 'standalone'
+  let masterSocket: import('net').Socket | null = null
+
+  // Ping handler
+  server.onMessage((msg, reply) => {
+    if (msg.type === 'ping') {
+      reply({ type: 'pong' })
+    }
+  })
+
+  // Attach handler
+  server.onMessage((msg, reply) => {
+    if (msg.type === 'attach_request') {
+      if (role === 'slave') {
+        reply({ type: 'attach_reject', data: 'Already attached' })
+        log('SLAVE', `Rejected attach from ${msg.from}`)
+        return
+      }
+
+      role = 'slave'
+      // Get latest client socket
+      const clients = Array.from((server as any).clients as Set<import('net').Socket>)
+      masterSocket = clients[clients.length - 1] ?? null
+
+      reply({ type: 'attach_accept', data: SLAVE_PIPE })
+      log('SLAVE', `Accepted attach from ${msg.from}`)
+    }
+  })
+
+  // Detach handler
+  server.onMessage((msg, _reply) => {
+    if (msg.type === 'detach') {
+      role = 'standalone'
+      masterSocket = null
+      log('SLAVE', `Detached by ${msg.from}`)
+    }
+  })
+
+  // Prompt handler — simulate AI processing
+  server.onMessage((msg, _reply) => {
+    if (msg.type === 'prompt') {
+      if (role !== 'slave') return
+      log('SLAVE', `Received prompt: "${msg.data}"`)
+
+      // Simulate AI response: stream fragments → tool_start → tool_result → done
+      if (masterSocket && !masterSocket.destroyed) {
+        const send = (m: PipeMessage) => {
+          m.from = m.from ?? SLAVE_PIPE
+          m.ts = m.ts ?? new Date().toISOString()
+          masterSocket!.write(JSON.stringify(m) + '\n')
+        }
+
+        setTimeout(() => {
+          send({ type: 'stream', data: 'Processing your request' })
+          log('SLAVE', 'Sent stream fragment 1')
+        }, 100)
+
+        setTimeout(() => {
+          send({ type: 'stream', data: '... analyzing code...' })
+          log('SLAVE', 'Sent stream fragment 2')
+        }, 200)
+
+        setTimeout(() => {
+          send({ type: 'tool_start', data: 'ReadFile', meta: { toolUseId: 'tool-123' } })
+          log('SLAVE', 'Sent tool_start')
+        }, 300)
+
+        setTimeout(() => {
+          send({ type: 'tool_result', data: 'file contents here...', meta: { toolUseId: 'tool-123' } })
+          log('SLAVE', 'Sent tool_result')
+        }, 400)
+
+        setTimeout(() => {
+          send({ type: 'done' })
+          log('SLAVE', 'Sent done')
+        }, 500)
+      }
+    }
+  })
+
+  return server
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Master Process: connects to slave, attaches, sends prompt
+// ═══════════════════════════════════════════════════════════════
+async function runMaster(): Promise<PipeClient> {
+  log('MASTER', `Connecting to slave "${SLAVE_PIPE}"...`)
+  const client = await connectToPipe(SLAVE_PIPE, MASTER_NAME)
+  log('MASTER', 'Connected!')
+  return client
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Full integration test (both in same process for simplicity,
+// but they communicate via real Unix domain sockets)
+// ═══════════════════════════════════════════════════════════════
+async function runFullTest() {
+  console.log('\n═══════════════════════════════════════════════')
+  console.log('  Pipe IPC 双进程通信端到端测试')
+  console.log('═══════════════════════════════════════════════\n')
+
+  let testsPassed = 0
+  let testsFailed = 0
+
+  // ── Test 1: Server startup ──
+  let server: PipeServer
+  try {
+    server = await runSlave()
+    pass('Slave PipeServer 启动成功')
+    testsPassed++
+  } catch (err) {
+    fail('Slave PipeServer 启动', String(err))
+    process.exit(1)
+    return // unreachable
+  }
+
+  // ── Test 2: List pipes ──
+  try {
+    const pipes = await listPipes()
+    if (pipes.includes(SLAVE_PIPE)) {
+      pass(`listPipes() 发现了 "${SLAVE_PIPE}"`)
+      testsPassed++
+    } else {
+      fail('listPipes()', `未找到 "${SLAVE_PIPE}"，只有: ${pipes.join(', ')}`)
+      testsFailed++
+    }
+  } catch (err) {
+    fail('listPipes()', String(err))
+    testsFailed++
+  }
+
+  // ── Test 3: Ping/Pong (liveness check) ──
+  try {
+    const alive = await isPipeAlive(SLAVE_PIPE)
+    if (alive) {
+      pass('isPipeAlive() ping/pong 健康检查通过')
+      testsPassed++
+    } else {
+      fail('isPipeAlive()', '返回 false')
+      testsFailed++
+    }
+  } catch (err) {
+    fail('isPipeAlive()', String(err))
+    testsFailed++
+  }
+
+  // ── Test 4: Master connects ──
+  let client: PipeClient
+  try {
+    client = await runMaster()
+    pass('Master 连接到 Slave 成功')
+    testsPassed++
+  } catch (err) {
+    fail('Master 连接', String(err))
+    await server.close()
+    process.exit(1)
+    return
+  }
+
+  // ── Test 5: Attach request/accept ──
+  try {
+    const attachResult = await new Promise<string>((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error('attach 超时')), 3000)
+
+      client.onMessage((msg) => {
+        if (msg.type === 'attach_accept') {
+          clearTimeout(timeout)
+          resolve('accepted')
+        } else if (msg.type === 'attach_reject') {
+          clearTimeout(timeout)
+          resolve(`rejected: ${msg.data}`)
+        }
+      })
+
+      client.send({ type: 'attach_request' })
+      log('MASTER', 'Sent attach_request')
+    })
+
+    if (attachResult === 'accepted') {
+      pass('Attach 请求被接受')
+      testsPassed++
+    } else {
+      fail('Attach 请求', attachResult)
+      testsFailed++
+    }
+  } catch (err) {
+    fail('Attach 请求', String(err))
+    testsFailed++
+  }
+
+  // ── Test 6: Duplicate attach rejection ──
+  try {
+    const client2 = await connectToPipe(SLAVE_PIPE, 'intruder')
+    const rejectResult = await new Promise<string>((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error('超时')), 3000)
+      client2.onMessage((msg) => {
+        if (msg.type === 'attach_reject') {
+          clearTimeout(timeout)
+          resolve('rejected')
+        } else if (msg.type === 'attach_accept') {
+          clearTimeout(timeout)
+          resolve('accepted (wrong!)')
+        }
+      })
+      client2.send({ type: 'attach_request' })
+    })
+
+    client2.disconnect()
+
+    if (rejectResult === 'rejected') {
+      pass('重复 attach 被正确拒绝')
+      testsPassed++
+    } else {
+      fail('重复 attach', `期望被拒绝，但结果是: ${rejectResult}`)
+      testsFailed++
+    }
+  } catch (err) {
+    fail('重复 attach', String(err))
+    testsFailed++
+  }
+
+  // ── Test 7: Send prompt and receive full session data ──
+  try {
+    const receivedMessages: PipeMessage[] = []
+
+    const sessionResult = await new Promise<PipeMessage[]>((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error('session 数据超时')), 5000)
+
+      client.onMessage((msg) => {
+        if (['stream', 'tool_start', 'tool_result', 'done'].includes(msg.type)) {
+          receivedMessages.push(msg)
+          log('MASTER', `收到 ${msg.type}: ${(msg.data ?? '').slice(0, 50)}`)
+
+          if (msg.type === 'done') {
+            clearTimeout(timeout)
+            resolve(receivedMessages)
+          }
+        }
+      })
+
+      client.send({ type: 'prompt', data: '请帮我分析代码' })
+      log('MASTER', '发送 prompt: "请帮我分析代码"')
+    })
+
+    // Verify received message types
+    const types = sessionResult.map((m) => m.type)
+    const expectedTypes = ['stream', 'stream', 'tool_start', 'tool_result', 'done']
+
+    if (JSON.stringify(types) === JSON.stringify(expectedTypes)) {
+      pass(`收到完整 session 数据: ${types.join(' → ')}`)
+      testsPassed++
+    } else {
+      fail('Session 数据', `期望 [${expectedTypes.join(', ')}]，实际 [${types.join(', ')}]`)
+      testsFailed++
+    }
+
+    // Verify stream content
+    const streamContent = sessionResult
+      .filter((m) => m.type === 'stream')
+      .map((m) => m.data)
+      .join('')
+    if (streamContent.includes('Processing') && streamContent.includes('analyzing')) {
+      pass('Stream 内容完整')
+      testsPassed++
+    } else {
+      fail('Stream 内容', `内容不完整: "${streamContent}"`)
+      testsFailed++
+    }
+
+    // Verify tool events
+    const toolStart = sessionResult.find((m) => m.type === 'tool_start')
+    if (toolStart?.data === 'ReadFile' && toolStart?.meta?.toolUseId === 'tool-123') {
+      pass('Tool 事件携带正确 metadata')
+      testsPassed++
+    } else {
+      fail('Tool 事件', `数据不正确: ${JSON.stringify(toolStart)}`)
+      testsFailed++
+    }
+  } catch (err) {
+    fail('Session 数据传输', String(err))
+    testsFailed++
+  }
+
+  // ── Test 8: Detach ──
+  try {
+    client.send({ type: 'detach' })
+    log('MASTER', '发送 detach')
+    // Give slave time to process
+    await new Promise((r) => setTimeout(r, 200))
+    pass('Detach 命令发送成功')
+    testsPassed++
+  } catch (err) {
+    fail('Detach', String(err))
+    testsFailed++
+  }
+
+  // ── Test 9: Re-attach after detach ──
+  try {
+    const reattachResult = await new Promise<string>((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error('re-attach 超时')), 3000)
+      client.onMessage((msg) => {
+        if (msg.type === 'attach_accept') {
+          clearTimeout(timeout)
+          resolve('accepted')
+        } else if (msg.type === 'attach_reject') {
+          clearTimeout(timeout)
+          resolve(`rejected: ${msg.data}`)
+        }
+      })
+      client.send({ type: 'attach_request' })
+    })
+
+    if (reattachResult === 'accepted') {
+      pass('Detach 后重新 attach 成功')
+      testsPassed++
+    } else {
+      fail('重新 attach', reattachResult)
+      testsFailed++
+    }
+  } catch (err) {
+    fail('重新 attach', String(err))
+    testsFailed++
+  }
+
+  // ── Cleanup ──
+  client.disconnect()
+  await server.close()
+  log('SLAVE', 'Server 已关闭')
+
+  // ── Summary ──
+  console.log('\n═══════════════════════════════════════════════')
+  console.log(`  测试结果: ${GREEN}${testsPassed} 通过${RESET}, ${testsFailed > 0 ? RED : GREEN}${testsFailed} 失败${RESET}`)
+  console.log('═══════════════════════════════════════════════\n')
+
+  if (testsFailed > 0) {
+    process.exit(1)
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Standalone modes (for testing with truly separate processes)
+// ═══════════════════════════════════════════════════════════════
+const mode = process.argv[2]
+
+if (mode === 'slave') {
+  // Run as standalone slave — waits for connections
+  console.log('启动 Slave 模式（按 Ctrl+C 退出）...\n')
+  const server = await runSlave()
+  log('SLAVE', `等待 master 连接... pipe: ${SLAVE_PIPE}`)
+
+  process.on('SIGINT', async () => {
+    log('SLAVE', '关闭中...')
+    await server.close()
+    process.exit(0)
+  })
+} else if (mode === 'master') {
+  // Run as standalone master — connects to existing slave
+  console.log('启动 Master 模式...\n')
+  try {
+    const client = await runMaster()
+
+    // Attach
+    client.onMessage((msg) => {
+      log('MASTER', `收到: ${msg.type} ${msg.data ?? ''}`)
+    })
+
+    client.send({ type: 'attach_request' })
+    log('MASTER', '已发送 attach_request，等待响应...')
+
+    // Wait a bit then send prompt
+    setTimeout(() => {
+      client.send({ type: 'prompt', data: '请帮我分析这段代码的问题' })
+      log('MASTER', '已发送 prompt')
+    }, 1000)
+
+    // Disconnect after 5s
+    setTimeout(() => {
+      client.send({ type: 'detach' })
+      client.disconnect()
+      log('MASTER', '已断开连接')
+      process.exit(0)
+    }, 5000)
+  } catch (err) {
+    console.error('Master 连接失败:', err)
+    process.exit(1)
+  }
+} else {
+  // Default: run full integrated test
+  await runFullTest()
+}