diff --git a/.gitignore b/.gitignore
index 040e493f1..3885d0aba 100644
--- a/.gitignore
+++ b/.gitignore
@@ -55,3 +55,9 @@ src-tauri/binaries/
 
 # pnpm local store (pnpm 11+)
 .pnpm-store/
+
+# ZCode session artifacts
+.zcode/
+
+# PK Arena temporary worktrees
+.codeg-pk/
diff --git a/docs/PK-ISSUES.md b/docs/PK-ISSUES.md
new file mode 100644
index 000000000..a9a4b5e0c
--- /dev/null
+++ b/docs/PK-ISSUES.md
@@ -0,0 +1,501 @@
+# PK Arena 实现问题审计
+
+> 本文记录 `feat/agent-pk-arena` 的实现审计过程。各问题正文保留发现时的
+> 原始症状与根因，不代表当前实现仍有该问题；当前状态以文末状态表为准。
+> 初次整理于 2026-08-19，问题 0 来自 server 模式 5 选手实跑。
+
+---
+
+## 问题 0：server 模式下选手完成后状态卡在就绪，裁判不触发（P0 根因）
+
+**严重程度**：极高（阻断核心流程）
+
+**实跑证据**（round 7，2026-08-19，server 模式 / 浏览器）：
+- 5 个选手（claude_code, codex, open_code, deepseek, qoder）全部完成 git commit
+- 后端日志全部有 `turn_complete stop_reason=end_turn`
+- 但 DB pk_round status 仍然是 `running`，不是 `finished`
+- 日志中 `judge` 出现 0 次，没有裁判 conversation 被创建
+- 选手状态全部停在 `ready`，UI 显示 0/5
+
+**根因分析**：
+
+选手状态流转链：`connecting → ready → (status_changed "prompting") → running → (turn_complete) → done`
+
+- `use-pk-round.ts:922-924`：turn_complete 到达时检查 `contestant.status === "running"`
+- `use-pk-round.ts:947-950`：选手从 ready → running 依赖收到 `status_changed` 事件的 `status === "prompting"`
+- 如果 `status_changed(prompting)` 事件未到达前端，选手永远停在 `ready`
+- 后续 `turn_complete` 到达时 `contestant.status === "running"` 为 false，直接忽略（return）
+- round 永远停在 running，settleContestant 不被调用，裁判不触发
+
+**事件投递链路**（server 模式）：
+- `acp-connections-context.tsx:4388-4398`：web/server 模式跳过全局 `acp://event` 监听
+- 事件只通过 per-connection attach stream 投递（`setupAttachSubscription`）
+- PK 在 `use-pk-round.ts:1041` 调 `attachDelegationChild` → `:5912` 调 `setupAttachSubscription`
+- attach stream onEvent → `applyMappedEnvelope`（:4177）→ reducer dispatch → fan out 到 useAcpEvent subscribers（:4184-4186）
+- 链路代码看起来完整，但实际运行时 status_changed(prompting) 事件未到达 PK handler
+
+**待查**：是否 attach subscription 建立时机与 status_changed(prompting) 发出时机存在竞态，导致事件在 attach 完成前发出且未被 snapshot/replay 捕获。
+
+**修复方向**：
+1. 短期：startPrompt 发 prompt 后主动把选手设为 running（不依赖 status_changed 事件）
+2. 长期：排查 server 模式 attach stream 是否丢失早期事件
+
+---
+
+## 问题 1：取消回合不触发裁判
+
+**严重程度**：中（影响核心使用场景）
+
+**场景**：用户启动 PK，某个 agent 耗时过长，用户想提前结束并导出报告时触发裁判打分。
+
+**现状**：做不到。
+
+- `cancelRound`（`use-pk-round.ts:1102-1131`）只做：markRound("canceled") + 断开未完成选手连接 + 标选手为 canceled
+- 裁判的唯一触发点在 `settleContestant`（`:795-814`），条件是所有选手 settled（done/error/canceled）后 markRound("finished") + 检查 judgeAgent
+- cancelRound 直接 markRound("canceled")，不走 settleContestant 分支，裁判永远不会被触发
+
+**修复方向**：cancelRound 末尾加：如果配了 judgeAgent 且 judgeStatus === "idle"，调用 runJudge（复用 settleContestant 里的逻辑）。
+
+---
+
+## 问题 2：裁判评分不在导出报告里
+
+**严重程度**：中
+
+**现状**：`buildPkReportHtml`（`pk-report.ts:83-196`）完全没有引用 `round.judgeResult`。报告只包含：任务文本、元信息、计分板表格（选手/状态/用时/token/轮次/diff增删/文件数）、各选手 diff 详情。没有裁判评分板块。
+
+**修复方向**：buildPkReportHtml 加上裁判评分渲染——渲染 `round.judgeResult.scores` 的排名、分数、点评、summary。
+
+---
+
+## 问题 3：裁判评分不在分享截图里
+
+**严重程度**：低
+
+**现状**：`handleShare`（`pk-arena-dialog.tsx:162-180`）只截 `scoreboardRef.current`，即 PkScoreboard 组件。PkJudgePanel 在 scoreboard 的外面（`:330-339`），截图不包含裁判面板。
+
+**修复方向**：把截图范围扩大到包含 PkJudgePanel，或给裁判面板单独加 ref。
+
+---
+
+## 问题 4：裁判评分不持久化
+
+**严重程度**：高
+
+**现状**：`judgeResult` 只存在前端 store（`pk-arena-store.ts`）的内存里。`pk_round` 表没有 judge_result 字段（见 migration `m20260819_000001_pk_round.rs`）。刷新页面或重启 server 后，裁判结果丢失。只有裁判的 conversation transcript 还在 DB 里（kind=Pk 的 conversation）。
+
+**影响**：用户跑完 PK、关掉 arena、再打开，裁判评分就没了。只能从裁判的 conversation 记录里人肉找 JSON。
+
+**修复方向**：pk_round 表加 judge_result JSON 列，store hydrate 时读回。
+
+---
+
+## 问题 5：导出报告不含裁判评分，且取消时无法触发裁判
+
+**严重程度**：高（两个问题叠加）
+
+这是问题 1 和问题 2 的叠加效应。用户想"提前结束 + 导出报告 + 看裁判打分"这个完整流程，当前完全做不到：
+- cancel 不触发裁判（问题 1）
+- 即使裁判跑过，报告也不含评分（问题 2）
+- 截图也不含评分（问题 3）
+
+---
+
+## 问题 6：控制变量 PK 的 UI 未完成
+
+**严重程度**：中
+
+**现状**：数据层已完成——`PkRoundConfig.agents` 支持 `Array<{agent, label}>` 新格式，兼容旧 `string[]` 格式（store hydrate 时归一化）。但 launcher UI（`pk-launcher-dialog.tsx`）不支持在选手选择区重复添加同一 agent。每个 agent 只显示一个按钮，选中/取消是 toggle，无法添加第二次。
+
+**影响**：用户无法在 UI 上做"Claude Code Sonnet vs Claude Code Opus"这种控制变量实验。只能通过 API 直接创建。
+
+**修复方向**：launcher 选手选择改为"添加槽位"模式，每个槽位独立选 agent + label。
+
+---
+
+## 问题 7：真实工程 PK 的任务来源仅做了 commit 拉取
+
+**严重程度**：低
+
+**现状**：launcher 有 "From commit" 按钮拉取最近 commit 作为任务。另有 "From diff" 按钮从工作区未提交改动拉取（调 gitStatus 列出改动文件,选择后调 gitDiff 填入 task）。以下任务来源未做（架构限制/收益低）：
+- 从 TODO 注释拉取 ❌（需新增后端扫描命令,收益低）
+- 从 GitHub issue 拉取 ❌（依赖 gh 认证+网络,复杂度高）
+- 在文件树里点选问题来 PK ❌（交互复杂,偏离 launcher 定位）
+
+---
+
+## 问题 8：裁判无法手动重跑
+
+**严重程度**：低
+
+**现状**：裁判是 one-shot 自动触发，judgeStatus 从 idle→running→done/error，没有重跑按钮。如果裁判 JSON 解析失败（judgeStatus="error"），用户无法手动重新触发裁判。
+
+**修复方向**：arena 里加"重新评分"按钮，重置 judgeStatus 为 idle 后调用 runJudge。
+
+---
+
+## 问题 9：进行中的回合可以无限制新开回合
+
+**严重程度**：低（可能是预期行为）
+
+**现状**：arena 的 "New round" 按钮（`pk-arena-dialog.tsx:258-264`）始终可点击，不检查当前回合是否在运行。点击后打开 launcher，可以创建新回合，旧回合继续在后台跑。
+
+**影响**：用户可以同时跑多个回合，没有互斥。可能导致资源占用过高（每个回合的选手都开独立 worktree + agent 连接）。
+
+**评估**：这可能是有意设计（多回合并行），不是 bug。但如果需要限制，应在 launcher 的 start 校验里加检查。
+
+---
+
+## 问题 10：裁判评分维度固定，不可配置
+
+**严重程度**：低
+
+**现状**：裁判 prompt（`use-pk-round.ts:69-90`）硬编码 4 个评分维度：
+1. Correctness — 是否完成任务
+2. Code quality — 可读性、结构、边界处理
+3. Completeness — 完成了多少
+4. Efficiency — 代码层面效率（明确排除 token 数和耗时）
+
+用户无法自定义评分维度或权重。
+
+**修复方向**：launcher 加评分维度配置，传入 buildJudgePrompt。
+
+---
+
+## 问题 11：裁判只看 diff，不看运行结果
+
+**严重程度**：低（设计限制）
+
+**现状**：裁判 prompt 只传 `contestantsWithDiffs`（`use-pk-round.ts:673-693`），即每个选手的 git diff 文本。裁判不跑代码、不看截图、不看运行日志。纯静态 diff 审查。
+
+**影响**：对于"代码能跑但 diff 看起来差"或"代码差但能跑"的情况，裁判评分可能不准。
+
+**评估**：这是当前架构限制，要支持运行结果需要重大改造（沙箱执行 + 截图捕获）。暂时记录，不做。
+
+---
+
+## 问题 12：server 模式下点击文件无法打开/定位到文件夹
+
+**严重程度**：中
+
+**场景**：server 模式（浏览器访问），用户在消息/文件引用里点击文件想打开所在文件夹——桌面模式可以（调系统 Finder），server 模式无反应。
+
+**现状**：
+
+- `revealItemInDir`（`platform.ts:99-104`）和 `openPath`（`platform.ts:87-93`）在 web/server 模式下是 **no-op**——条件 `isDesktop() && getActiveRemoteConnectionId() === null` 为 false 时直接 return
+- `file-reference-actions.tsx:128-130`：右键菜单的"在系统文件管理器中打开"选项在 server 模式下通过 `isLocalDesktop()` 守卫隐藏，用户看不到入口
+- `reply-artifacts.tsx:111`：AI 生成文件的"打开"按钮调 `revealItemInDir`，server 模式下静默失败
+- 后端有 `open_worktree_folder` HTTP 端点（`handlers/folders.rs:69`），但它的作用是把 worktree 注册到侧边栏文件夹列表，不是打开系统文件管理器
+- server 模式下浏览器没有权限直接操作本地文件系统，需要后端代理
+
+**修复方向**：
+
+1. 后端加 `reveal_item` / `open_path` HTTP 端点，server 模式下调 `opener` crate 在服务器主机上打开 Finder/Explorer
+2. 前端 `revealItemInDir` / `openPath` 在 server 模式下调 HTTP 端点而非 Tauri 插件
+3. `file-reference-actions.tsx` 的 `isLocalDesktop()` 守卫改为"桌面本地 OR server 模式"都显示入口
+4. 注意：server 部署在远程时，打开的是**服务器主机**的文件管理器，不是客户端的——这个限制需要在 UI 上提示用户
+
+---
+
+## 问题 13：任务完成后 arena 对话框只能最小化无法关闭
+
+**严重程度**：中
+
+**场景**：用户跑完 PK 后想关掉 arena 对话框，但只能最小化，没有关闭按钮。
+
+**现状**：
+
+三层问题叠加：
+
+1. **正常进行中的回合**（`pk-arena-dialog.tsx:64-68`）：
+   - `liveRef = round.status === "ready" || round.status === "running"`
+   - ESC 被阻止（`:199-201` onEscapeKeyDown preventDefault）
+   - 点遮罩被阻止（`:202-204` onPointerDownOutside preventDefault）
+   - 没有关闭按钮（`:197` showCloseButton={false}）
+   - 只有"最小化"按钮（`:265-275` setArenaOpen(false)，不真正关闭/清理）
+   - 注释（`:64-65`）说"只有 X 按钮能显式关闭"，但 X 按钮被 showCloseButton={false} 去掉了——设计意图与实现矛盾
+
+2. **因问题 #0 导致的卡住**（最常见场景）：
+   - 选手完成后 round.status 仍是 running（问题 #0），liveRef 永远 true
+   - 所有关闭路径被永久阻止
+   - 只能最小化
+
+3. **即使正常完成的回合**（status=finished/canceled）：
+   - liveRef 为 false，ESC 和点遮罩能关
+   - 但仍然没有 X 按钮（showCloseButton={false}），用户不知道怎么关
+   - handleOpenChange（`:184-191`）能处理关闭，但入口不明显
+
+**修复方向**：
+1. 始终显示关闭按钮（showCloseButton=true），让用户有明确关闭入口
+2. 进行中的回合点关闭时弹确认（"回合进行中，确定关闭？"），而非永久阻止
+3. 或保持 ESC/遮罩阻止，但给一个明确的关闭按钮 + 确认对话框
+
+---
+
+## 问题 14：PK 会话管理 UI 粗糙——下拉框切换 + 标题无信息 + 侧边栏不可见
+
+**严重程度**：中（体验差，但不阻断功能）
+
+**三个子问题：**
+
+### 14a：回合切换只有一个下拉框
+
+**现状**（`pk-arena-dialog.tsx:225-239`）：
+
+```tsx
+<select value={round.id} onChange={...} className="max-w-40 ...">
+  {rounds.map((r) => (
+    <option key={r.id} value={r.id}>
+      {new Date(r.createdAt).toLocaleTimeString()} · {r.contestants.length} 选手
+    </option>
+  ))}
+</select>
+```
+
+- 只显示"时间 + 选手数"，没有任务文本、状态、分数
+- max-w-40 导致长内容被截断
+- 多回合时无法快速区分"哪轮做了什么"
+- 没有搜索/过滤
+- 没有删除单轮的入口（只有删除当前轮）
+
+### 14b：conversation 标题被 agent 自动覆盖，丢失 PK 上下文
+
+**现状**：
+
+- `create_pk`（`conversation_service.rs:99-100`）创建时 `title = "PK · <taskPreview>"`，`title_locked = false`
+- agent 跑完后，`refresh_auto_title`（`:240-262`）因为 `title_locked = false`，用 agent 自己取的标题覆盖了 PK 标题
+- 实跑证据（round 7）：DB 里 5 个选手的 title 分别是 "Interactive jelly blob browser toy"、"Build a tiny browser toy..." 等各不相同的标题，没有一个带 "PK ·" 前缀
+- 裁判会话的标题 `PK Judge · <task>` 也同样会被覆盖
+
+**根因**：PK conversation 应该 `title_locked = true`，防止 agent auto-title 覆盖。
+
+### 14c：PK 会话在侧边栏完全不可见
+
+**现状**：
+
+- `sidebar-conversation-list.tsx:1059`：`c.kind !== "pk"` 过滤掉所有 PK 会话
+- `sidebar-conversation-grouping.ts:300`：`if (conv.kind === "pk") continue` 分组时也跳过
+- types.ts:421 注释说 `kind === "pk"` "drives the sidebar's per-round grouping"，但实际分组逻辑根本没有实现——只有排除，没有 PK 专用分组渲染
+- 用户无法在侧边栏看到/打开 PK 选手的会话记录，只能通过 arena 对话框的 battle tab 看实时流
+
+**修复方向**：
+
+1. **14b（最简单）**：`create_pk` 里设 `title_locked = true`
+2. **14a**：回合切换改为列表/卡片视图，每轮显示：任务摘要、状态徽章、选手头像+分数、创建时间；支持搜索和删除
+3. **14c**：侧边栏加 PK 分组——按 round 分组，每组显示任务摘要 + 选手会话列表，点击打开选手 transcript
+
+---
+
+## 问题 15：battle/diff 列固定 w-80，不按 agent 数量自适应分配空间
+
+**严重程度**：中
+
+**场景**：3 个选手时右侧大片留白，5 个选手时需要横向滚动。
+
+**现状**：
+
+- `PkBattlePane`（`pk-arena-dialog.tsx:425`）：`w-80 shrink-0` — 固定 320px，不可收缩
+- `PkReadyPane`（`:464`）：同 `w-80 shrink-0`
+- `PkDiffView`（`pk-diff-view.tsx:79`）：`flex h-full min-h-0 flex-col` — 没有 shrink-0，但父容器 `flex h-full gap-2 overflow-x-auto`（`:360`）不限制子元素宽度，diff 列实际也不自适应
+- 容器（`:360`）：`flex h-full gap-2 overflow-x-auto p-2` — 水平滚动布局，子元素不会被压缩到容器宽度内
+- 没有根据 `round.contestants.length` 计算 `flex-basis` 或 grid 列数的逻辑
+
+**影响**：
+
+- 3 个 agent：3 × 320px = 960px，对话框通常 1400px+，右侧约 440px 留白
+- 5 个 agent：5 × 320px = 1600px，需要横向滚动
+- 8 个 agent（最大支持）：8 × 320px = 2560px，大量滚动
+
+**修复方向**：
+
+- 容器改 `grid` 布局，列数 = `min(contestants.length, 上限如6)`，`grid-template-columns: repeat(N, minmax(0, 1fr))`
+- 或改 `flex-1 min-w-0`，让每列等分剩余空间
+- 列数超过上限时再回退到固定宽度 + 横向滚动
+- 需要同时改 PkBattlePane / PkReadyPane / PkDiffView 三个组件的根 div
+
+---
+
+## 问题 16：导出报告里输出 token 和轮次全是 "—"
+
+**严重程度**：中
+
+**现状**：`pk-report.ts:105-106` 里 `c.usage ? c.usage.outputTokens : "—"`——usage 为 null 时显示 "—"。实际跑完的 PK 报告里这两列全是 "—"。
+
+**根因有三层：**
+
+1. **问题 #0 场景**（最常见）：选手卡在 ready，settleContestant（`use-pk-round.ts:779-790`）从不执行，fetchUsage 从不被调用，usage 永远 null。
+
+2. **重启/hydrate 场景**：即使选手曾经正常 done 且 fetchUsage 调过，重启后 hydrate 把 usage 重置为 null：
+   - `dbRoundToStoreRound`（`pk-arena-store.ts:246`）：硬编码 `usage: null`
+   - `createRound`（`:315`）：同 `usage: null`
+   - `pk-arena-host.tsx:40-48`：hydrate 从 DB 加载 rounds 后直接 `hydrateFromDb(storeRounds)`，**没有调 fetchUsage 重新拉取**
+   - store 注释（`:15`）说 "Live-only fields (connectionId, diff, usage) stay in the Zustand store — they are meaningless across restarts"——这个设计假设导致 usage 在重启后永远丢失
+
+3. **即使 fetchUsage 被调用**（`use-pk-round.ts:471-489`）：
+   - 调 `getFolderConversation` 拿 turns，遍历 assistant turns 累加 `turn.usage?.output_tokens`
+   - 如果 parser 没从 agent session 文件提取到 usage（某些 agent 格式不包含 token 信息），turn.usage 为 None
+   - 此时返回 `{ inputTokens: 0, outputTokens: 0, turnCount: N }`——不是 "—" 而是 0
+   - DB 里 `token_usage_turn` 表 0 行，说明 token usage 同步机制也有问题
+
+**实跑证据**（round 7）：
+- `token_usage_turn` 表 0 行
+- 5 个选手 status 全是 ready（问题 #0），settleContestant 从不执行
+- 报告里 token 和轮次全 "—"
+
+**修复方向**：
+1. hydrate 时对已完成的选手调 fetchUsage 回填（usage 不应该被当作 live-only）
+2. 或把 usage 持久化到 DB（pk_round 或 conversation 表）
+3. 修复问题 #0 让选手正常走到 settleContestant
+
+---
+
+## 问题 17：模板任务提示词应为中文，且缺少黑洞效果模板
+
+**严重程度**：低（增强需求）
+
+**现状**（`pk-templates.ts:23-60`）：
+
+6 个内置模板的 task 文本全是英文：
+- "Generate an SVG of a pelican riding a bicycle."
+- "Create an HTML animation: a ball starts in the center of a triangle..."
+- "Build a tiny browser toy: a jelly blob..."
+- "Write a Snake game in a single HTML file..."
+- "Write a Flappy Bird clone..."
+- "Create a voice-enabled chatbot web app..."
+
+i18n 只翻译了模板**标签**（zh-CN.json:5013-5018 "鹈鹕骑车"/"弹球"等），但 `setTask(tpl.task)` 填进 textarea 的是英文原文，用户提交前看到的是英文 prompt，agent 收到的也是英文。
+
+**需求**：
+
+1. task 文本改为中文（面向中文用户为主）
+2. 新增黑洞效果模板——视觉效果好的引力透镜/吸积盘动画，适合 PK 股评对比
+
+**修复方向**：
+
+- `pk-templates.ts` 的 task 字段改为中文
+- 新增 `{ id: "blackHole", emoji: "🕳️", task: "..." }` 黑洞模板
+- i18n 所有语言的 `templates.blackHole` 标签
+
+---
+
+## 问题 18："从提交拉取"混在模板按钮里，交互不清晰
+
+**严重程度**：中（体验差）
+
+**现状**（`pk-launcher-dialog.tsx:290-367`）：
+
+"从提交拉取"按钮和 6 个模板按钮并排排列（:304-333），视觉上像一个普通模板，但行为完全不同：
+
+- 模板按钮：一键填充 textarea，即时生效
+- 从提交拉取：点击后异步加载 git log，展开一个 commit 列表，再点一条 commit 才填充
+- 生成的 prompt 是硬编码英文模板（:352）：`Reproduce the change from commit ${hash}: ${message}`
+
+**问题**：
+
+1. **分类混淆**：模板（预设创意任务）和 from-commit（真实工程复现任务）是两种完全不同的 PK 模式，混在一个按钮行里，用户不知道点了会发生什么
+2. **prompt 硬编码英文**：和问题 17 一样，生成的 commit 复现 prompt 也是英文
+3. **交互不可发现**：按钮点了会展开列表，但没有视觉提示这是个"可展开"操作，第一次用的用户会困惑
+4. **commit 只显示 hash + message**：没有日期、作者、改动文件数，用户无法判断该选哪条
+5. **只拉 5 条**：`gitLog(workingDir, 5)` 硬编码 5 条，不够时没法翻页
+
+**修复方向**：
+
+把 launcher 的任务来源分成两个清晰的模式区：
+
+```
+┌─ 创意 PK（模板）──────────────────────────┐
+│ 🦤 🦤 ⚽ 弹球  🫧 果冻  🐍 贪吃蛇 ...      │
+│ [一键填充任务文本]                          │
+└────────────────────────────────────────────┘
+
+┌─ 真实工程 PK（从提交）──────────────────────┐
+│ [📋 从提交拉取]  → 展开为 commit 选择面板     │
+│  • 展开后显示: hash · 日期 · 作者 · 改动文件数 │
+│  • prompt 改为中文: "复现提交 {hash} 的改动:   │
+│    {message}"                                │
+│  • 支持加载更多 / 翻页                        │
+└──────────────────────────────────────────────┘
+```
+
+具体改动：
+1. 模板按钮和 from-commit 在视觉上分区（不同容器/分隔线/标题）
+2. from-commit 展开后的列表增加日期、作者、改动文件数（gitLog 支持 `withFiles`）
+3. 复现 prompt 改为中文
+4. 支持加载更多 commit（limit 改为可配置，或加"加载更多"按钮）
+
+---
+
+## 问题 19：战报中的嵌入式 HTML 可能无法完整运行
+
+**严重程度**：高（影响战报预览与快速分享）
+
+**最新一轮实跑证据（round 5）**：
+
+- 6 份嵌入产物与各自 worktree 原文件逐字节一致，不是导出时截断或编码损坏
+- 其中 4 份页面使用了 `localStorage`
+- 战报 iframe 当前使用 `sandbox="allow-scripts allow-pointer-lock"`，页面处于不透明来源
+- 页面访问 Web Storage 时会触发安全异常，导致后续初始化脚本中断；Qoder 页面表现为画布空白、开始层未显示
+- 仅作诊断时加入 `allow-same-origin` 后页面可以启动，证明根因是沙箱来源限制
+
+**安全约束**：不能直接把 `allow-same-origin` 与 `allow-scripts` 长期组合使用，否则会明显削弱用户生成代码的隔离边界。
+
+**修复方向**：
+
+1. 保留 iframe 沙箱隔离
+2. 导出时注入按选手隔离的内存版 `localStorage` / `sessionStorage` 兼容层
+3. 导出前扫描常见运行依赖并给出兼容性提示
+4. 增加真实浏览器回归测试，至少覆盖 Web Storage、键盘输入、Canvas 和重新开始流程
+5. 对外链依赖和多文件项目另行做资源打包，不能只靠单文件 `srcdoc`
+
+---
+
+## 问题 20：顶部固定区域的 PK 按钮层级过高且入口重复
+
+**严重程度**：中（信息架构与视觉层级问题）
+
+**现状**：`LeftEdgeChrome` 将 PK 双剑按钮与侧栏开关、远程工作区等壳层操作并列。它既可能新建竞技场，也可能打开已有竞技场，语义不稳定，视觉上还容易被理解为全局或窗口级操作。
+
+**已有入口**：
+
+- 输入框附加菜单：新建 / 打开竞技场
+- 左侧 PK 竞技场列表：打开具体历史回合
+- 缩小胶囊：恢复当前进行中的竞技场
+
+**与 `main` 分支风格的冲突**：`main` 的顶部固定区域只保留结构性、窗口级控制；代码中还明确移除了可从其他位置触达的重复入口。PK 属于业务功能，不应占据这一层级。
+
+**决策方向**：
+
+1. 删除 `LeftEdgeChrome` 中的 PK 双剑按钮
+2. 保留输入框入口负责创建，侧栏负责历史，缩小胶囊负责恢复
+3. 如果新建入口仍不够明显，可在“PK 竞技场”分组标题悬停时显示轻量 `+`，不要重新放回全局顶栏
+
+---
+
+## 优先级排序
+
+> ✅ 已修复: #0 #1 #2 #3 #4 #6 #7 #8 #10 #12 #13 #14a #14b #15 #16 #17 #18 #19 #20
+
+| 优先级 | 问题 | 状态 | 说明 |
+|--------|------|------|------|
+| P0 | #0 server 模式选手状态卡 ready，裁判不触发 | ✅ | startPrompt 主动设 running |
+| P0 | #4 裁判评分不持久化 | ✅ | pk_round 加 judge_result 列 |
+| P0 | #1 取消不触发裁判 | ✅ | cancelRound 末尾调 runJudge |
+| P1 | #2 报告不含裁判评分 | ✅ | 报告加颁奖台板块 |
+| P1 | #3 截图不含裁判评分 | ✅ | 截图范围含 PkJudgePanel |
+| P1 | #12 server 模式无法打开文件夹 | ✅ | 设计正确,加守卫隐藏 |
+| P1 | #13 arena 对话框无法关闭 | ✅ | showCloseButton=true |
+| P1 | #14b PK 标题被 agent 覆盖 | ✅ | title_locked=true |
+| P1 | #15 battle/diff 列不自适应宽度 | ✅ | flex-1 min-w-80 |
+| P1 | #16 报告里 token/轮次全 "—" | ✅ | hydrate 回填 usage |
+| P1 | #19 战报嵌入式 HTML 无法完整运行 | ✅ | 保持沙箱隔离，注入内存 Web Storage 兼容层并补回归测试 |
+| P2 | #14a 回合切换下拉框信息不足 | ✅ | option 加状态+task+冠军 |
+| P2 | #14c PK 会话侧边栏不可见 | | 待修 |
+| P2 | #6 控制变量 UI 未完成 | ✅ | 选手选择改槽位模式 |
+| P2 | #8 裁判无法重跑 | ✅ | 重评按钮 |
+| P2 | #20 顶部 PK 按钮层级过高且重复 | ✅ | 删除顶栏入口，保留创建、历史、恢复三条职责清晰的路径 |
+| P3 | #10 评分维度不可配 | ✅ | launcher 加维度配置 |
+| P3 | #7 任务来源不足 | ✅ | commit + 工作区改动拉取 |
+| P3 | #17 模板提示词改中文 + 黑洞模板 | ✅ | 中文 + 🕳️ |
+| P3 | #18 从提交拉取和模板分区 | ✅ | 分区 + commit 增强 |
+| P4 | #9 无限新开回合 | | 可能预期行为 |
+| P4 | #11 裁判只看 diff | | 架构限制 |
diff --git a/docs/PK-ROADMAP.md b/docs/PK-ROADMAP.md
new file mode 100644
index 000000000..900834cae
--- /dev/null
+++ b/docs/PK-ROADMAP.md
@@ -0,0 +1,124 @@
+# PK Arena 演进路线图
+
+> 整理于 2026-08-19。基于当前 `feat/agent-pk-arena` 分支已实现的基础设施，
+> 规划下一阶段四个增强功能，目标是把 PK 做成真正的引流点。
+
+---
+
+## 现状（已实现）
+
+| 能力 | 状态 | 关键文件 |
+|------|------|----------|
+| 多 agent 同任务 PK（2-8 选手） | ✅ | `pk-launcher-dialog.tsx` |
+| 每选手独立 git worktree 隔离 | ✅ | `use-pk-round.ts` → `gitWorktreeAdd` |
+| 权限模式（default/acceptEdits/bypass） | ✅ | launcher + `applyPermissionMode` |
+| 思考强度（effort）统一设定 | ✅ | launcher + `applyPreparedOptions` |
+| 裸机模式（禁用 skills） | ✅ | `BARE_MODE_RULES` |
+| 选手级 model/effort 选择器 | ✅ | `applyContestantSelection` |
+| 实时 transcript 分屏 | ✅ | `pk-arena-dialog.tsx` |
+| diff 对比 + 计分板 + 截图分享 | ✅ | `pk-diff-view.tsx` / `pk-scoreboard.tsx` |
+| 回合持久化到 DB | ✅ | `pk_round` 表 + store hydrate |
+| 中断恢复（interrupted） | ✅ | `dbRoundToStoreRound` |
+
+---
+
+## 四个新功能
+
+### 功能 1：快捷开赛模板
+
+**问题**：每次 PK 都要手动选 agent、写任务、调参数，门槛高。
+
+**方案**：预设一组常见任务模板，一键填入 launcher。
+
+- 内置模板（基于 AI 圈知名的一句话 benchmark，结果可视化、自带话题性）：
+
+  | 模板 | 任务文本 | 测试维度 | 来源 |
+  |------|----------|----------|------|
+  | 鹈鹕骑车 | `Generate an SVG of a pelican riding a bicycle` | 空间推理 + SVG 编码 + 指令遵循 | Simon Willison 2024-10，AI 圈最著名的非正式 benchmark |
+  | 球在三角形里弹跳 | `Create an HTML animation: a ball starts in the center of a triangle. Every time it hits a side it speeds up, and the shape gains an extra side (Triangle→Square→Pentagon→Hexagon…)` | 动画逻辑 + 物理 + 动态形状 | Instagram 病毒对比帖，Qwen Coder 胜出 |
+  | 果冻 blob | `Build a tiny browser toy: a jelly blob. You poke, grab, stretch it. No scoring, no level, just a satisfying blob.` | 交互物理 + harness 能力 | DeepSeek-Reasonix 的 harness benchmark |
+  | 贪吃蛇 | `Write a Snake game in a single HTML file with keyboard controls.` | 基础工程 + 游戏逻辑 | 经典编程测试 |
+  | Flappy Bird | `Write a Flappy Bird clone in a single HTML file.` | 游戏逻辑 + Canvas | 常见 LLM 对比题 |
+  | 语音聊天 | `Create a voice-enabled chatbot web app using the Web Speech API.` | 多功能集成 + API 调用 | YouTube LLM 对比赛 |
+
+- 用户可自定义模板（存 localStorage 或 DB）
+- 模板内容：`{ name, task, suggestedAgents?, bareMode?, effort? }`
+- 入口：launcher 对话框顶部加一排模板按钮，点击即填
+- 引流角度：鹈鹕骑车已是 AI 圈共识 benchmark，"用 Codeg PK 场跑鹈鹕骑车"自带搜索流量和话题认同
+
+**工作量**：小。纯前端，不改后端。
+
+### 功能 2：真实工程 PK
+
+**问题**：一句话任务太玩具，不反映 agent 在真实项目里的能力。
+
+**方案**：PK 直接在当前打开的项目里跑，选手各自在 worktree 里实现特性 / 修 bug。
+
+- 现有基础设施**已支持**：launcher 已从 activeTab 读 `workingDir`，`gitWorktreeAdd` 已在项目下建 `.codeg-pk/<round>/<agent>/` worktree
+- 差的是**任务来源体验**：
+  - 目前只能手输任务文本
+  - 增强：支持从 git diff / commit message / TODO 注释 / GitHub issue 拉取任务描述
+  - 可选：在项目文件树里点选"就拿这个文件的问题来 PK"
+- 选手的 diff 已经对基准分支做（`gitDiffWithBranch`），真实工程的改动能正确捕获
+
+**工作量**：中。主要是前端任务输入增强 + 可选的 issue 拉取（需 GitHub API）。
+
+### 功能 3：主裁判自动打分
+
+**问题**：PK 结果靠人肉看 diff，没有量化评分，不够系统，也不便传播。
+
+**方案**：指定一个 agent 当裁判，读所有选手 diff 后打分排座次。
+
+- 回合结束后（所有选手 `done`），自动启动裁判 agent
+- 裁判 prompt 包含：任务描述 + 每个选手的 diff + 评分维度（正确性 / 代码质量 / 效率 / 完成度）
+- 裁判输出结构化评分（JSON：每选手每维度分数 + 总分 + 排名 + 点评）
+- 评分结果展示在计分板下方，可随截图一起分享
+- 裁判可以是任意已安装的 agent（甚至可以加入一个"不参赛只裁判"的 agent）
+- 可选：多裁判投票制（2-3 个裁判各自打分取平均）
+
+**工作量**：中。需要：
+- 后端：`pk_round` 表加 `judge_agent` + `judge_result` 字段
+- 前端：launcher 加裁判选择器，arena 加评分展示区
+- 编排：`use-pk-round.ts` 在回合结束后触发裁判连接
+
+### 功能 4：控制变量 PK（同 agent 不同配置）
+
+**问题**：想做"同一 agent 跑不同 model / effort"的对比，但当前一个 agent 只能选一个槽位。
+
+**方案**：选手身份从 `agentType` 升级为 `(agentType, slotLabel)`，允许同一 agent 出现多次。
+
+- 核心改动：contestant 的唯一键从 `agentType` 改为 `contestantId`（`agentType + slot 索引`）
+- 影响面：
+  - `contestantBranchName` / `contestantContextKey` 加 slot 后缀
+  - `PkRoundConfig.agents` 从 `string[]` 改为 `Array<{ agent: string; label?: string }>`
+  - DB `pk_round.config` JSON 结构升级（需兼容旧数据）
+  - 前端 launcher 支持重复添加同一 agent，每个槽位单独设 model/effort
+- 典型场景：
+  - Claude Code × Sonnet vs Claude Code × Opus（同 agent 不同 model）
+  - Codex × medium vs Codex × high（同 agent 不同 effort）
+  - Codex 裸机 vs Codex 带 skills（同 agent 不同 bareMode）
+  - 同 agent 不同 system prompt / MCP 配置（更远期）
+
+**工作量**：中偏大。改动横跨前后端 + DB schema + 编排逻辑，是四个功能里最重的。
+
+---
+
+## 实施优先级
+
+| 顺序 | 功能 | 理由 | 预估工作量 |
+|------|------|------|-----------|
+| 1 | 快捷开赛模板 | 改动最小、体验提升最直接、立刻可用 | 半天 |
+| 2 | 主裁判自动打分 | PK 结果可量化 = 引流核心素材，差异化最强 | 1-2 天 |
+| 3 | 控制变量 PK | 直击用户真实疑问（Opus 值不值 / high 强多少），天然话题 | 2-3 天 |
+| 4 | 真实工程 PK | 基础设施已就绪，增强任务来源即可，但不急于做 issue 拉取 | 1 天（基础）/ 2-3 天（含 issue） |
+
+**建议**：1 → 2 → 3 → 4 顺序做。1 和 2 做完就能产生第一批传播素材；3 做完 PK 的"控制变量"叙事就完整了；4 是锦上添花。
+
+---
+
+## 技术约束与风险
+
+- **功能 3（裁判）**：裁判也是 one-shot 委托，裁判 agent 的 diff 不参与排名，只输出评分。注意裁判 token 也算成本。
+- **功能 4（控制变量）**：DB schema 变更需写迁移，旧 `config.agents: string[]` 要兼容读。建议用 discriminated union：`agents` 既接受旧 `string[]` 也接受新 `Array<{agent, label}>`，读取时统一归一化。
+- **所有功能**：保持双模式（Tauri + Axum）兼容，`_core` 函数共用，前端 transport 自动检测。
+- **测试**：每个功能完成后跑 `pnpm test` + `cargo test --features test-utils`，功能 4 需新增 DB 迁移测试。
diff --git a/docs/PK-TEST-CASES.md b/docs/PK-TEST-CASES.md
new file mode 100644
index 000000000..25b2564af
--- /dev/null
+++ b/docs/PK-TEST-CASES.md
@@ -0,0 +1,775 @@
+# PK Arena 测试用例
+
+> 给测试 agent 用。基于 server 模式 + Playwright 浏览器自动化。
+> 测试前先读「环境准备」一节。
+
+---
+
+## 环境准备
+
+### 1. 构建 server 二进制
+
+```bash
+cd src-tauri
+cargo build --no-default-features --bin codeg-server
+```
+
+### 2. 构建前端静态文件
+
+```bash
+pnpm build   # 产出 out/ 目录
+```
+
+### 3. 启动 server
+
+```bash
+CODEG_PORT=3080 \
+CODEG_HOST=127.0.0.1 \
+CODEG_TOKEN=test-token-123 \
+CODEG_DATA_DIR=/tmp/codeg-pk-test \
+CODEG_STATIC_DIR=$(pwd)/out \
+./src-tauri/target/debug/codeg-server
+```
+
+### 4. 浏览器访问
+
+```
+http://127.0.0.1:3080
+```
+
+登录页输入 token：`test-token-123`
+
+### 5. 准备测试用 git 仓库
+
+PK 需要一个有 git 仓库的 folder。测试前创建：
+
+```bash
+mkdir -p /tmp/codeg-pk-test-repo
+cd /tmp/codeg-pk-test-repo
+git init
+echo "# Test Repo" > README.md
+git add . && git commit -m "initial commit"
+echo "print('hello')" > hello.py
+git add . && git commit -m "add hello.py"
+```
+
+然后在 Codeg 里「添加文件夹」指向 `/tmp/codeg-pk-test-repo`。
+
+### 6. 安装 agent
+
+PK 只列出已安装的 agent。至少需要 2 个已安装的 agent（如 Claude Code、Codex）。
+如果测试环境没有真实 agent，可以用 mock——但 UI 自动化测试主要验证前端交互逻辑，
+agent 未安装时 launcher 不显示选手按钮，这是预期行为，应作为边界用例。
+
+---
+
+## 选择器约定
+
+PK 组件没有 data-testid（除 scoreboard 和 minimized-pill）。
+用以下策略定位元素：
+
+| 元素 | 选择器 |
+|------|--------|
+| Launcher 对话框 | `role="dialog"` 内含文本 "Agent PK" |
+| 选手按钮 | 选手区域的 `button[aria-pressed]`，文本匹配 agent 名称 |
+| 模板按钮 | `button[title]`，title 属性包含模板任务文本 |
+| 任务文本框 | `#pk-task` |
+| 权限单选 | `input[name="pk-permission"]` |
+| effort 按钮 | effort 区域的 `button[aria-pressed]` |
+| 裸机模式复选框 | bareMode label 内的 `input[type="checkbox"]` |
+| 裁判按钮 | 裁判区域的 `button[aria-pressed]`，"No judge" 或 agent 名 |
+| 开始按钮 | 对话框底部含 "Start match" 文本的 button |
+| 取消按钮 | 对话框底部含 "Cancel" 文本的 button |
+| 计分板 | `[data-testid="pk-scoreboard"]` |
+| 最小化浮标 | `[data-testid="pk-minimized-pill"]` |
+| Arena 对话框 | `role="dialog"` 内含 "Agent PK arena" |
+| Tab 按钮 | 含 "Battle" 或 "Diff" 文本的 button |
+| 选手状态 | 计分板内 `span` 文本 |
+
+---
+
+## 测试用例
+
+### TC-01：Launcher 打开与初始状态
+
+**前置**：已登录，已打开一个 git 仓库 folder，该 tab 处于活跃状态。
+
+**步骤**：
+1. 找到入口触发 PK launcher（左侧栏的 ⚔ 图标，或 composer 菜单里的 PK 选项）
+2. 等待对话框出现
+
+**验证**：
+- [ ] 对话框可见，标题为 "Agent PK"
+- [ ] 选手区域可见，显示 "Contestants (2-4)" 标签
+- [ ] 已安装的 agent 以圆形按钮列出，每个带图标和名称
+- [ ] 每个选手按钮 `aria-pressed="false"`（未选中状态）
+- [ ] 任务文本框 `#pk-task` 存在且为空
+- [ ] 任务文本框上方有模板按钮行（鹈鹕骑车、弹球、果冻 Blob、贪吃蛇、Flappy Bird、语音聊天）
+- [ ] 权限区域默认选中 "default"（第一个 radio）
+- [ ] effort 区域默认选中 "Default"
+- [ ] 裸机模式复选框未选中
+- [ ] 裁判区域可见，"No judge" 按钮处于选中状态（`aria-pressed="true"`）
+- [ ] 底部 "Start match" 按钮处于 disabled 状态
+- [ ] 底部计数显示 "0/8 picked (min 2)"
+
+### TC-02：选手选择与取消
+
+**前置**：TC-01 通过。
+
+**步骤**：
+1. 点击第一个 agent 按钮
+2. 验证该按钮 `aria-pressed="true"`
+3. 点击第二个 agent 按钮
+4. 验证两个按钮都 `aria-pressed="true"`
+5. 点击第一个 agent 按钮取消
+
+**验证**：
+- [ ] 选中后按钮样式变化（border-primary + bg-primary/10）
+- [ ] 底部计数更新为 "1/8 picked (min 2)"（选一个再取消一个后）
+- [ ] 只选 1 个时显示 "Pick at least 2 agents to run a match." 提示
+- [ ] 选 2 个后提示消失
+- [ ] "Start match" 按钮在选满 2 个 + 有任务文本后变为 enabled
+
+### TC-03：快捷模板填充
+
+**前置**：TC-01 通过。
+
+**步骤**：
+1. 点击 "🦤 Pelican" 模板按钮
+
+**验证**：
+- [ ] `#pk-task` 文本框内容变为 "Generate an SVG of a pelican riding a bicycle."
+- [ ] 模板按钮的 `title` 属性包含完整任务文本
+
+**步骤**：
+2. 清空文本框（手动或点另一个模板覆盖）
+3. 依次点击每个模板按钮，验证文本框内容
+
+**验证**：
+- [ ] "⚽ Bouncing Ball" → "Create an HTML animation: a ball starts in the center of a triangle..."
+- [ ] "🫧 Jelly Blob" → "Build a tiny browser toy: a jelly blob..."
+- [ ] "🐍 Snake" → "Write a Snake game in a single HTML file with keyboard controls."
+- [ ] "🐤 Flappy Bird" → "Write a Flappy Bird clone in a single HTML file with Canvas rendering."
+- [ ] "🎙️ Voice Chat" → "Create a voice-enabled chatbot web app using the Web Speech API."
+
+### TC-04：从 Git 提交拉取任务
+
+**前置**：TC-01 通过，当前 folder 是 git 仓库且有至少 2 个 commit。
+
+**步骤**：
+1. 找到 "📋 From commit" 按钮（在模板按钮行末尾）
+2. 点击它
+
+**验证**：
+- [ ] 出现一个下拉列表，显示最近的 commit
+- [ ] 每个 commit 显示 hash 前 7 位 + commit message 第一行
+- [ ] 如果还在加载，显示 "Loading commits…"
+
+**步骤**：
+3. 点击第一个 commit
+
+**验证**：
+- [ ] 下拉列表关闭
+- [ ] `#pk-task` 文本框内容变为 "Reproduce the change from commit <hash>: <message>"
+- [ ] 文本中的 hash 是完整 hash 还是短 hash 取决于 API 返回，验证前 7 位匹配
+
+### TC-05：权限模式切换
+
+**前置**：TC-01 通过。
+
+**步骤**：
+1. 默认状态验证 "default" radio 被选中
+2. 点击 "acceptEdits" radio
+3. 点击 "bypassPermissions" radio
+4. 点回 "default"
+
+**验证**：
+- [ ] 每次切换后，对应 radio 的 `checked` 属性为 true
+- [ ] 每个选项旁边有提示文本（如 "file edits run without asking"）
+- [ ] 权限区域下方有说明文本
+
+### TC-06：Effort 等级切换
+
+**前置**：TC-01 通过。
+
+**步骤**：
+1. 默认状态验证 "Default" 按钮处于选中状态
+2. 依次点击 Low → Medium → High → Max → Default
+
+**验证**：
+- [ ] 每次点击后，对应按钮 `aria-pressed="true"`
+- [ ] 其他按钮 `aria-pressed="false"`
+- [ ] 选中按钮有高亮样式
+
+### TC-07：裸机模式切换
+
+**前置**：TC-01 通过。
+
+**步骤**：
+1. 验证复选框初始未选中
+2. 点击复选框
+
+**验证**：
+- [ ] 复选框变为选中状态
+- [ ] 复选框旁有 "Bare mode (no skills)" 标签
+- [ ] 下方有说明文本
+
+### TC-08：裁判选择
+
+**前置**：TC-01 通过。
+
+**步骤**：
+1. 验证裁判区域可见
+2. 验证 "No judge" 按钮处于选中状态（`aria-pressed="true"`）
+3. 点击一个 agent 作为裁判
+
+**验证**：
+- [ ] "No judge" 按钮变为未选中
+- [ ] 选中的 agent 按钮 `aria-pressed="true"`
+- [ ] 如果该 agent 已被选为选手，其裁判按钮显示 `opacity-40`（半透明，表示不建议自裁判）
+
+**步骤**：
+4. 点击 "No judge" 取消裁判
+
+**验证**：
+- [ ] "No judge" 按钮回到选中状态
+- [ ] 之前选中的 agent 裁判按钮变为未选中
+
+### TC-09：启动验证 — 缺选手
+
+**前置**：TC-01 通过。
+
+**步骤**：
+1. 只选 1 个 agent
+2. 在任务文本框输入 "test task"
+3. 检查 "Start match" 按钮状态
+
+**验证**：
+- [ ] "Start match" 按钮处于 disabled 状态
+- [ ] 显示 "Pick at least 2 agents to run a match." 提示
+
+### TC-10：启动验证 — 缺任务
+
+**前置**：TC-01 通过。
+
+**步骤**：
+1. 选 2 个 agent
+2. 任务文本框留空
+3. 检查 "Start match" 按钮状态
+
+**验证**：
+- [ ] "Start match" 按钮处于 disabled 状态
+
+### TC-11：启动验证 — 非 Git 仓库
+
+**前置**：打开一个非 git 仓库的 folder。
+
+**步骤**：
+1. 打开 PK launcher
+
+**验证**：
+- [ ] 选手区域不显示 agent 按钮（或显示"需要 git 仓库"提示）
+- [ ] 显示 "This folder is not a git repository" 文本
+- [ ] 有 "git init" 按钮
+- [ ] "Start match" 按钮处于 disabled 状态
+
+### TC-12：完整 PK 流程 — 启动到就绪
+
+**前置**：已安装至少 2 个 agent，已打开一个 git 仓库 folder。
+
+**步骤**：
+1. 打开 PK launcher
+2. 选 2 个 agent
+3. 点击 "🦤 Pelican" 模板
+4. 权限设为 "acceptEdits"
+5. effort 设为 "Medium"
+6. 勾选裸机模式
+7. 选一个不参赛的 agent 作为裁判（如果有第 3 个 agent）
+8. 点击 "Start match"
+
+**验证**：
+- [ ] Launcher 对话框关闭
+- [ ] Arena 对话框打开
+- [ ] Arena 顶部显示任务文本
+- [ ] 状态显示 "Ready"（不是 "Live"）
+- [ ] 计分板 `[data-testid="pk-scoreboard"]` 可见
+- [ ] 计分板显示 2 个选手卡片
+- [ ] 每个选手卡片显示 agent 图标、名称、状态点（amber/ready）
+- [ ] 有 "Start match" 按钮在 arena 内（准备态的启动按钮）
+- [ ] 如果选了裁判，裁判面板可见
+- [ ] Battle tab 默认选中
+- [ ] 每个选手面板显示 "Ready" 标签 + 模型/effort 选择器（如果 agent 通告了选项）
+
+### TC-13：Arena — 模型/effort 选择器（准备态）
+
+**前置**：TC-12 通过，选手处于 ready 状态且 agent 通告了 configOptions。
+
+**步骤**：
+1. 在第一个选手面板里，如果模型选择器存在，选择一个不同的模型
+2. 如果 effort 选择器存在，选择一个不同的 effort
+
+**验证**：
+- [ ] 选择器是 `<select>` 元素或按钮组
+- [ ] 选择后 UI 更新（选择器的值改变）
+- [ ] 如果 agent 没有通告 configOptions，面板显示诊断信息（"no selectors"）
+
+### TC-14：Arena — 启动比赛
+
+**前置**：TC-12 通过，选手处于 ready 状态。
+
+**步骤**：
+1. 点击 arena 内的 "Start match" 按钮
+
+**验证**：
+- [ ] 状态从 "Ready" 变为 "Live"
+- [ ] 每个选手的状态点从 amber 变为 emerald + animate-pulse
+- [ ] 计分板开始显示计时（如果 startedAt 已设置）
+- [ ] Battle tab 的选手面板从 ready 面板切换为 transcript 视图
+- [ ] 如果 agent 在运行，transcript 内容逐步出现
+- [ ] 取消按钮（"Cancel"）可见
+
+### TC-15：Arena — 计分板实时更新
+
+**前置**：TC-14 通过，比赛正在运行。
+
+**步骤**：
+1. 观察计分板 30 秒
+
+**验证**：
+- [ ] 选手状态从 "running" 可能变为 "done"（绿色实心圆点）
+- [ ] 完成后显示耗时（如 "12s"）
+- [ ] 完成后显示 token 数（如 "1.5k tok"）
+- [ ] 完成后显示轮次数（如 "3 turns"）
+- [ ] 计时在运行中每秒更新
+
+### TC-16：Arena — 选手完成后结算
+
+**前置**：TC-14 通过，至少一个选手完成。
+
+**步骤**：
+1. 等待所有选手完成
+
+**验证**：
+- [ ] 所有选手状态变为 "done" 或 "error"
+- [ ] 回合状态从 "Live" 变为 "Finished"
+- [ ] 每个选手的连接断开（侧边栏不再转圈）
+- [ ] 如果配置了裁判，裁判自动启动（judgeStatus 从 idle 变为 running）
+
+### TC-17：Arena — 裁判自动评分
+
+**前置**：TC-16 通过，且在 TC-12 中选了裁判 agent。
+
+**步骤**：
+1. 所有选手完成后，等待裁判完成
+
+**验证**：
+- [ ] 裁判面板（PkJudgePanel）可见，位于计分板下方
+- [ ] 裁判运行时显示 "Evaluating…" + 脉冲点
+- [ ] 裁判完成后显示评分卡片：每个选手显示排名徽章（🥇🥈🥉）、分数（0-100）、点评
+- [ ] 分数有颜色编码：≥80 绿色、≥60 黄色、≥40 橙色、<40 红色
+- [ ] 评分按排名排序（rank 1 在前）
+- [ ] 裁判面板下方有总体总结文本
+
+### TC-18：Arena — 裁判无 JSON 输出时的容错
+
+**前置**：裁判 agent 返回了非 JSON 文本（可通过断开裁判连接或 mock 模拟）。
+
+**验证**：
+- [ ] 裁判状态变为 "error" 或显示 "Judge response could not be parsed."
+- [ ] 原始文本保留在 rawText 字段（可在报告导出中验证）
+- [ ] 不崩溃，其他功能正常
+
+### TC-19：Arena — Diff Tab
+
+**前置**：TC-16 通过，至少一个选手完成。
+
+**步骤**：
+1. 点击 "Diff" tab
+
+**验证**：
+- [ ] Diff tab 被选中（有底部边框高亮）
+- [ ] 如果 diff 还没加载，显示 "Loading diff…"
+- [ ] 加载完成后，每个选手显示一个 diff 面板
+- [ ] diff 面板包含 git diff 文本
+- [ ] 如果选手没有改动，显示 "No changes in this worktree" 或中文等价文本
+- [ ] 选手面板标题显示 agent 名称
+
+### TC-20：Arena — 取消进行中的比赛
+
+**前置**：TC-14 通过，比赛正在运行。
+
+**步骤**：
+1. 点击 "Cancel" 按钮
+
+**验证**：
+- [ ] 回合状态变为 "Canceled"
+- [ ] 所有未完成的选手状态变为 "canceled"
+- [ ] 选手连接断开
+- [ ] 计分板停止计时
+- [ ] ESC 键不能关闭 arena（运行中禁止误触关闭）
+
+### TC-21：Arena — 最小化与恢复
+
+**前置**：TC-14 通过，比赛正在运行。
+
+**步骤**：
+1. 点击 "Minimize" 按钮
+
+**验证**：
+- [ ] Arena 对话框关闭
+- [ ] 屏幕右下角出现 `[data-testid="pk-minimized-pill"]` 浮标
+- [ ] 浮标显示 "PK in progress" 文本
+
+**步骤**：
+2. 点击浮标
+
+**验证**：
+- [ ] Arena 对话框重新打开
+- [ ] 比赛状态保持不变（仍在运行）
+
+### TC-22：Arena — ESC 键防护
+
+**前置**：TC-14 通过，比赛正在运行。
+
+**步骤**：
+1. 按 ESC 键
+
+**验证**：
+- [ ] Arena 对话框不关闭（被阻止）
+- [ ] 比赛继续运行
+
+**步骤**：
+2. 比赛结束后（Finished 状态），按 ESC 键
+
+**验证**：
+- [ ] Arena 对话框正常关闭
+
+### TC-23：Arena — 点遮罩防护
+
+**前置**：TC-14 通过，比赛正在运行。
+
+**步骤**：
+1. 点击对话框外的遮罩区域
+
+**验证**：
+- [ ] Arena 对话框不关闭（被阻止）
+
+### TC-24：Arena — 回合切换
+
+**前置**：有 2 个以上的 PK 回合（已完成或进行中）。
+
+**步骤**：
+1. 打开 arena
+2. 如果有多个回合，验证回合选择器（`<select>`）可见
+3. 切换到另一个回合
+
+**验证**：
+- [ ] 回合选择器的每个 option 显示时间 + 选手数
+- [ ] 切换后，arena 显示选中回合的任务、选手、状态
+- [ ] 已完成回合的 live transcript 不可见（连接已断开），但持久化的会话内容仍可渲染
+
+### TC-25：Arena — 清理 Worktree
+
+**前置**：TC-16 通过，回合已完成。
+
+**步骤**：
+1. 找到 "Clean worktrees" 按钮
+2. 点击它
+
+**验证**：
+- [ ] 选手的 worktree 被移除
+- [ ] 分支保留（keepBranches=true）
+- [ ] 按钮消失或变为不可用
+
+### TC-26：Arena — 删除回合
+
+**前置**：TC-16 通过。
+
+**步骤**：
+1. 找到 "Delete" 按钮
+2. 点击它
+3. 在确认对话框点确认
+
+**验证**：
+- [ ] 回合从列表中移除
+- [ ] 如果还有其他回合，自动切换到第一个
+- [ ] 如果没有回合了，arena 显示 "No round selected"
+
+### TC-27：Arena — 分享截图
+
+**前置**：TC-16 通过，计分板有数据。
+
+**步骤**：
+1. 点击 "Share" 按钮
+
+**验证**：
+- [ ] 按钮文本变为 "Exporting…"
+- [ ] 导出完成后（按钮恢复 "Share"），浏览器触发文件下载
+- [ ] 下载的文件名匹配 `codeg-pk-<round-id>.png`
+
+### TC-28：Arena — 导出报告
+
+**前置**：TC-16 通过。
+
+**步骤**：
+1. 点击 "Export report" 按钮
+
+**验证**：
+- [ ] 按钮文本变为 "Building…"
+- [ ] 导出完成后浏览器触发文件下载
+- [ ] 下载的文件名匹配 `codeg-pk-<round-id>.html`
+- [ ] 打开 HTML 文件，验证包含任务文本、选手信息、diff 内容
+- [ ] 如果有裁判结果，报告包含裁判评分
+
+### TC-29：控制变量 PK — 同 agent 多 slot（数据层）
+
+**前置**：已安装至少 1 个 agent。
+
+**说明**：当前 UI 不支持直接在 launcher 里添加同一 agent 两次。
+此用例通过 API 直接验证数据层。
+
+**步骤**：
+1. 通过 HTTP API 创建一个带重复 agent 的 round：
+
+```bash
+curl -X POST http://127.0.0.1:3080/pk_round_create \
+  -H "Authorization: Bearer test-token-123" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "folder_id": 1,
+    "task": "test control variable",
+    "config": {
+      "agents": [
+        {"agent": "claude_code", "label": "Sonnet"},
+        {"agent": "claude_code", "label": "Opus"}
+      ],
+      "permission_mode": "default",
+      "bare_mode": false,
+      "effort": "default"
+    }
+  }'
+```
+
+**验证**：
+- [ ] API 返回 200，round 创建成功
+- [ ] 返回的 config.agents 有 2 个条目，都是 claude_code，label 分别为 "Sonnet" 和 "Opus"
+
+**步骤**：
+2. 通过 API 列出 rounds：
+
+```bash
+curl -X POST http://127.0.0.1:3080/pk_round_list \
+  -H "Authorization: Bearer test-token-123" \
+  -H "Content-Type: application/json" \
+  -d '{"folder_id": null}'
+```
+
+**验证**：
+- [ ] 返回列表包含刚创建的 round
+- [ ] config.agents 正确反序列化为 2 个 labeled 条目
+
+**步骤**：
+3. 打开 arena（如果有 UI 入口查看此 round）
+
+**验证**：
+- [ ] 计分板显示 2 个选手卡片
+- [ ] 两个选手都是同一个 agent（相同图标和名称）
+- [ ] 选手卡片用 slot 区分（不同的 key）
+
+### TC-30：控制变量 PK — 旧格式兼容
+
+**说明**：验证旧格式（agents 为纯字符串数组）仍能正确反序列化。
+
+**步骤**：
+1. 通过 API 创建一个旧格式的 round：
+
+```bash
+curl -X POST http://127.0.0.1:3080/pk_round_create \
+  -H "Authorization: Bearer test-token-123" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "folder_id": 1,
+    "task": "test old format",
+    "config": {
+      "agents": ["claude_code", "codex"],
+      "permission_mode": "default",
+      "bare_mode": false,
+      "effort": "default"
+    }
+  }'
+```
+
+**验证**：
+- [ ] API 返回 200
+- [ ] 返回的 config.agents 是 `["claude_code", "codex"]`（旧格式保持不变）
+- [ ] 列表 API 也能正确返回
+
+### TC-31：裁判 API — 无裁判的 round
+
+**步骤**：
+1. 创建一个不带 judge_agent 的 round（默认）
+
+**验证**：
+- [ ] config 里没有 `judge_agent` 字段（`skip_serializing_if = "Option::is_none"`）
+- [ ] Arena 不显示裁判面板
+
+### TC-32：裁判 API — 带裁判的 round
+
+**步骤**：
+1. 创建一个带 judge_agent 的 round：
+
+```bash
+curl -X POST http://127.0.0.1:3080/pk_round_create \
+  -H "Authorization: Bearer test-token-123" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "folder_id": 1,
+    "task": "test judge",
+    "config": {
+      "agents": ["claude_code", "codex"],
+      "permission_mode": "default",
+      "bare_mode": false,
+      "effort": "default",
+      "judge_agent": "gemini"
+    }
+  }'
+```
+
+**验证**：
+- [ ] 返回的 config 包含 `judge_agent: "gemini"`
+- [ ] Arena 显示裁判面板（即使状态为 idle，面板也应渲染）
+
+### TC-33：中断恢复
+
+**前置**：有一个运行中的 PK 回合。
+
+**步骤**：
+1. 强制重启 server（kill 进程后重新启动）
+
+**验证**：
+- [ ] 重启后 arena 中该回合状态变为 "Interrupted by restart"
+- [ ] 选手状态变为 "canceled"
+- [ ] 不会自动重新启动比赛（drivenRef 机制防止重放）
+- [ ] 已完成的回合不受影响
+
+### TC-34：多人多语言 — 中文界面
+
+**前置**：浏览器语言设为 zh-CN。
+
+**步骤**：
+1. 打开 PK launcher
+
+**验证**：
+- [ ] 对话框标题为 "Agent PK"（英文保持不变，或对应中文翻译）
+- [ ] 模板按钮显示中文名称："鹈鹕骑车"、"弹球"、"果冻 Blob"、"贪吃蛇"
+- [ ] 裁判标签显示 "裁判(可选)"
+- [ ] "No judge" 按钮显示 "无裁判"
+
+### TC-35：多人多语言 — 日文界面
+
+**前置**：浏览器语言设为 ja。
+
+**步骤**：
+1. 打开 PK launcher
+
+**验证**：
+- [ ] 模板按钮显示日文名称："ペリカン"、"ボール"、"ゼリー"、"スネーク"
+- [ ] 裁判标签显示 "審査員(任意)"
+- [ ] "No judge" 按钮显示 "審査員なし"
+
+### TC-36：边界 — 最大选手数
+
+**步骤**：
+1. 选 8 个 agent（如果安装了 8 个）
+
+**验证**：
+- [ ] 第 9 个无法选中（toggle 函数在达到 MAX_CONTESTANTS 时忽略新选择）
+- [ ] 底部计数显示 "8/8 picked (min 2)"
+
+### TC-37：边界 — 空文件夹
+
+**前置**：打开一个空的 git 仓库（只有 initial commit，无其他文件）。
+
+**步骤**：
+1. 打开 PK launcher
+2. 点击 "From commit" 按钮
+
+**验证**：
+- [ ] 只显示 initial commit
+- [ ] 选择后任务文本框填充正常
+
+### TC-38：完整流程回归 — 从模板到评分
+
+**前置**：已安装至少 3 个 agent（2 个选手 + 1 个裁判）。
+
+**步骤**：
+1. 打开 PK launcher
+2. 选 2 个 agent 作为选手
+3. 点击 "🐍 Snake" 模板
+4. 权限设为 "bypassPermissions"
+5. effort 设为 "High"
+6. 选第 3 个 agent 作为裁判
+7. 点击 "Start match"
+8. 在 arena 的 ready 态点击 "Start match" 启动比赛
+9. 等待所有选手完成
+10. 等待裁判完成评分
+11. 切换到 Diff tab 查看 diff
+12. 点击 "Share" 导出截图
+13. 点击 "Export report" 导出报告
+
+**验证**：
+- [ ] 每一步都按预期执行
+- [ ] 选手完成后裁判自动启动
+- [ ] 裁判评分显示在计分板下方
+- [ ] Diff tab 显示每个选手的代码变更
+- [ ] 截图下载成功
+- [ ] HTML 报告下载成功且内容完整
+
+### TC-39：状态文案一致性
+
+**步骤**：
+1. 在 launcher 和 arena 中检查所有可见文本
+
+**验证**：
+- [ ] Launcher 的按钮文案与 i18n 消息文件一致
+- [ ] Arena 的状态文案（Ready/Live/Finished/Canceled/Interrupted）与 i18n 一致
+- [ ] 计分板的状态文案（preparing/connecting/running/done/error/canceled）与 i18n 一致
+- [ ] 裁判面板的文案（Judge Verdict/Evaluating/Judge failed）与 i18n 一致
+
+### TC-40：Launcher 复赛预填
+
+**前置**：之前成功启动过一次 PK。
+
+**步骤**：
+1. 再次打开 PK launcher
+
+**验证**：
+- [ ] 上次的选手选择被预填（如果 agent 仍可用）
+- [ ] 上次的任务文本被预填
+- [ ] 上次的权限模式被预填
+- [ ] 上次的 effort 被预填
+- [ ] 上次的裸机模式被预填
+- [ ] 上次的裁判选择被预填
+
+---
+
+## API 端点参考
+
+| 端点 | 方法 | 说明 |
+|------|------|------|
+| `/pk_round_list` | POST | 列出所有 round（可按 folder_id 过滤） |
+| `/pk_round_get` | POST | 获取单个 round |
+| `/pk_round_create` | POST | 创建 round |
+| `/pk_round_update_status` | POST | 更新 round 状态 |
+| `/pk_round_delete` | POST | 删除 round（软删除） |
+| `/git_log` | POST | 获取 git 提交历史 |
+| `/git_branch` | POST | 获取当前分支 |
+| `/git_worktree_add` | POST | 创建 worktree |
+| `/git_remove_worktree` | POST | 移除 worktree |
+| `/git_diff` | POST | 获取 diff |
+| `/git_diff_with_branch` | POST | 获取对基准分支的 diff |
+| `/git_init` | POST | 初始化 git 仓库 |
+
+所有请求需要 `Authorization: Bearer <token>` 头。
+
+请求体格式为 JSON，参数名用 snake_case。
diff --git a/docs/STRATEGY-MEMO.md b/docs/STRATEGY-MEMO.md
new file mode 100644
index 000000000..6b27b1c19
--- /dev/null
+++ b/docs/STRATEGY-MEMO.md
@@ -0,0 +1,398 @@
+# Codeg 战略备忘录
+
+> 内部决策记录。整理于一次深度代码评审 + 商业化讨论之后。
+> 目的:把散落在对话里的分析、判断、案例、待办沉淀下来,避免重复讨论。
+> 2026-08-16 第二次更新:性能深度扫描 + 上游 issue 需求验证(见二、三、六、九节标注)。
+
+---
+
+## 一、项目定位(已确认,不再动摇)
+
+**Codeg = 多智能体编码工作台(Multi-Agent Coding Workspace)。**
+
+- 服务对象:**开发者**(不是非开发者,不是垂直行业)
+- 核心能力:**跨进程异构 agent 委托**(不是单进程换模型)
+- 不做:**Cursor 平替、通用 agent 平台、垂直行业方案**
+
+### 定位边界(加宽 vs 跳船)
+
+| 允许 | 禁止 |
+|------|------|
+| 覆盖开发者的更多环节(编码/文档/审查) | 脱离开发者去做通用市场 |
+| 引入更多编码 agent(Pi/GenericAgent) | 引入非编码 agent 后转去做非开发场景 |
+| 加宽定位(开发者全流程) | 跳船(服务完全不同的人群) |
+
+---
+
+## 二、技术资产评审(代码级事实)
+
+### 已完成且扎实的部分
+
+| 模块 | 规模 | 评价 |
+|------|------|------|
+| `acp/delegation/` | ~1.4 万行 Rust,200+ 测试 | **核心护城河**,工程深度极高 |
+| `acp/` 顶层 | ~2.5 万行(connection/manager/lifecycle 等) | ACP 协议完整实现 |
+| `parsers/` | ~1.8 万行,10 个 agent | 会话聚合,覆盖广 |
+| 双模式架构 | codeg / codeg-server / codeg-mcp | 部署形态齐全,`_core` 函数共用 |
+
+### delegation 模块的技术亮点(护城河来源)
+
+1. **跨进程真委托** — `delegate_to_agent` 起独立 PID,不是进程内换 prompt
+2. **异步 fan-out** — 同时开多个子 agent,`get_delegation_status` 批量长轮询
+3. **取消级联** — 四种取消路径全覆盖(外部/子/父连接/父轮次)
+4. **Setup 窗口竞态处理** — inflight 注册 + checkpoint + atomic park,零信任时序
+5. **深度限制** — `depth.rs` 防递归爆炸,带 cap 防脏数据
+6. **安全边界** — 一次性 token + parent scoping + UDS/piped 传输
+7. **测试覆盖** — broker 109 测试、companion 53、listener 25,覆盖全边界条件
+8. **trait 解耦** — `ConnectionSpawner` 为 v3 远程 agent 预留扩展点
+
+### 当前短板(v1 限制,2026-08-16 复测)
+
+1. **v1 是 one-shot** — `broker.rs:2527` `disconnect` 写死,子 agent 跑完即杀。`continue_with_session`/`close_session` 仍不存在,`acp/delegation/mod.rs:29` 注释还挂着 v2 计划
+2. **巨石文件三座山** — `commands/acp.rs` 17020 行、`acp/connection.rs` 16155 行、`broker.rs` 8481 行(此前记 7554,又长了 ~930;前两个比 broker 更大,之前漏记)。broker 约 4750 行是测试,外移到 `broker_tests.rs` 是零风险减半
+3. **没有远程 agent** — 只能调度本机,v3 未实现
+4. **结果不落库(比原记轻)** — 完整文本只在 512MB 内存 FIFO 缓存(`broker.rs:79`);但有界 `text_preview` 已持久化进父会话 tool-call meta(`meta_writer.rs:281`),淘汰后 UI 仍有预览。真缺口是"全文不落库",不是"什么都不落"
+5. **前端两个上帝对象** — `acp-agent-settings.tsx` 11818 行(单个设置页)、`acp-connections-context.tsx` 5606 行(~99 个 switch/case 的事件分发层)
+
+### 性能优化机会(2026-08-16 深度扫描,按收益排序)
+
+1. **侧边栏全量遍历** — `get_sidebar_data`/`list_folders`/`get_stats` 每次都走 `list_conversations_sync`(`commands/conversations.rs:342`),13 个 parser 全目录遍历,但文件夹树只需要 `folder_path`。前端已自己绕开(`skills-settings.tsx:713` 注释承认慢)。改 DB 文件夹索引 = 用户可感知的最大提升
+2. **活跃会话整文件重解析** — 摘要缓存键 `(mtime,size)`(`summary_cache.rs:64`),流式期间每次列表刷新都对整个 JSONL 逐行反序列化(`claude.rs:846`)。`transcript_watermark` 已跟踪字节位置但从未用于增量读(`claude.rs:1866` 注释自认;codex 直接返回 `None`)。基础设施都在,只差接线
+3. **patch 行号解析无缓存** — `resolve_patch_line_numbers` 每个 patch 块全量读目标文件(`parsers/mod.rs:1002`),7 个 parser 共用;同一大文件 N 个 patch = N 次全量读。一次 HashMap memo 即可
+4. **会话文件定位 O(全树)** — Codex 按 id 每次 WalkDir(`codex.rs:336`),Claude 全目录 read_dir(`claude.rs:1060`);id→path 索引变 O(1)
+5. **干净的部分(不用动)** — DB 索引齐全、无 N+1、WAL 配置正确;前端虚拟化(virtua)+ RAF 批处理是真做了的;启动无阻塞扫描,感知慢在首次侧边栏(冷缓存 + 上述第 1 条)
+
+---
+
+## 三、产品演进路线(v1 → v2 → v3)
+
+### v1(现状):一次性委托
+
+- 子 agent 跑完第一轮 `TurnComplete` → broker `disconnect` → 杀掉
+- 父 LLM 拿到结果文本,委托结束
+- 暴露 6 个工具:`delegate_to_agent` / `get_delegation_status` / `cancel_delegation` / `check_user_feedback` / `ask_user_question` / `get_session_info`
+
+### v2:多轮子会话(Continue Session)— 短期 1-2 月
+
+**目标**:子会话长期存活,支持多轮交互
+
+**工具变化**:新增 `continue_with_session` / `close_session`
+
+**为什么不难**:
+- ACP 协议本身支持多轮(Codeg 已实现 `session/load` / `session/resume`,主会话在用)
+- 只需删除 `finalize_delegation` 末尾的 `disconnect`,改成等显式 close
+- 取消级联/深度限制/inflight 注册早已为长期会话设计,现在大材小用
+
+**真正难点**:状态管理(TTL、并发上限、父结束时的级联关闭、中途失败语义)
+
+**价值**:从"工具调用"升级为"Agent 团队",产品形态质变
+
+### v3:远程 Agent(Remote Spawner)— 中期 3-6 月
+
+**目标**:agent 跑在远程,broker 不变
+
+**架构**:新增 `RemoteSpawner` 实现 `ConnectionSpawner` trait,broker 零改动
+
+**难点不在 Codeg**(写 RemoteSpawner 不难),在基础设施:
+- 远程执行环境(sandbox、API key 管理、资源隔离)
+- 网络可靠性(远程超时处理)
+- 安全(权限模型、审计)
+- 认证(多租户隔离)
+- 计费
+
+**价值**:从"本地工具"升级为"云平台",商业化的钥匙
+
+**需求验证(2026-08-16)**:上游 issue #461「以持久 Session 为成员的 Team / Chatroom」——社区独立提出了与功能 B/v2 同构的构想。这是 v2 值得做的最直接外部证据。
+
+### v2 必须先于 v3 的理由
+
+1. 远程 agent 冷启动成本高,只换一个 turn 的结果经济不成立 → 需要 v2 多轮
+2. v2 纯本地,风险低,能快速验证产品形态
+
+---
+
+## 四、商业化分析
+
+### 市场定位的真实判断
+
+**Codeg 的差异化不是"多智能体",而是"多智能体的跨进程编排"。**
+
+- OpenCode / Pi / DriFox 做的是"单进程多模型/多 prompt"(第一层)
+- Codeg 做的是"跨进程真委托"(第二层)
+- **不在一个维度上竞争**
+
+### 四条变现路径(垂直行业已划掉)
+
+| 路径 | 可行性 | 说明 |
+|------|--------|------|
+| 开发者工具变现(企业版/团队) | 🟢 最现实 | 开发者为效率付费,Codeg 主场 |
+| 托管云 | 🟡 有需求 | 但要扛运维成本 |
+| API 计费层 | 🟡 灰色 | 中国市场对接海外模型有法律风险 |
+| ~~垂直行业~~ | ❌ 划掉 | 底座是编码 agent,做不了行业方案 |
+
+### 为什么垂直行业划掉
+
+- 垂直行业(律所/金融/医疗)不会以 Claude Code/Codex 为底座
+- 这些 agent 是通用编码 agent,不具备行业专业性
+- 行业数据不能出境(合规问题)
+- 没有行业知识库
+
+### 最诚实的商业化判断
+
+**最大风险:在"多 agent 协作"需求真正普及前,上游平台方可能下场。**
+- 窗口期 12-18 个月
+- 最该做的:抢心智占有率("多智能体协作 = Codeg")
+
+**最该先验证的问题(未回答)**:
+1. 现在有没有人重度依赖 Codeg 的 delegation?
+2. 你和同事自己日常用 delegation 吗?
+
+> 这两个问题不回答,所有路径都是空中楼阁。先找 10 个真实用户问三个问题:
+> 你用它干过什么?没有它你会怎么做?愿意付多少钱?
+
+---
+
+## 五、案例研究
+
+### CoolVibe(coolvibe.io)— 参照系
+
+| 维度 | 数据 |
+|------|------|
+| 本质 | Agent 的网页查看器(壳子) |
+| 投入 | 4 个月,~3 万美元 |
+| 定价 | 免费 / Pro $29.9/年 |
+| 现状 | "订阅免费送"(还在买用户阶段) |
+| V2EX 热度 | 1054 条回复 |
+| 公开营收 | 查不到 |
+| 团队 | xterminal 团队(有成功经验) |
+
+**启示**:
+1. "壳子"能赚钱,但前提是痛点明确且高频
+2. 定价对齐"省下的时间",不是"技术多复杂"
+3. 免费送订阅是冷启动的合理策略
+4. CoolVibe 比深得多的 Codeg 先验证了"给 agent 做壳"能跑通
+
+### DriFox(github.com/martin98-afk/DriFox)— 反面教材 + 经验库
+
+| 维度 | 数据 |
+|------|------|
+| 本质 | PyQt 桌面对话助手(Cursor 平替) |
+| 规模 | 15 万行 Python |
+| Stars | **24**(2 个月) |
+| 定位错误 | 堆 33 插件做"Cursor 平替",死路 |
+
+**DriFox 走的错路(Codeg 绝不能走)**:
+- 自己做 agent 和 Cursor 正面打(蚂蚁 vs 太阳)
+- 堆功能数量拼不过飞轮(数据/生态/资本)
+- "平替"定位是诅咒(永远活在正品阴影里)
+
+**Cursor 的体量(参照)**:
+- ARR $40 亿(2026.06 年化)
+- 估值 $290-500 亿
+- 日活 100 万+
+- 融资 $23 亿 D 轮
+
+### ACP 协议现状
+
+- 官方 35+ 兼容 agent
+- 已被 Zed / JetBrains / Google / GitHub 采纳
+- 事实标准(类似 LSP 之于语言服务器)
+- **zcode 不在列表**(截至 2026-07)
+
+---
+
+## 六、可执行的功能规划
+
+### 🎯 功能 A:编程 PK(周末项目,优先级最高)
+
+**是什么**:同一个任务同时分发给多个 agent,看谁做得好
+
+**为什么做**:
+1. 成本极低(底层全有,只缺对比 UI)——周末能做完
+2. 硬核技术的最佳展示窗口(把不可见的委托变成可视化)
+3. 赛道真空(DriFox 24 star 不构成威胁,异构 PK 无人做)
+4. 自带传播(天然话题性 + 可视化 + 争议性)
+5. 低成本的市场探测器(PK 没人理 → 大方向要重新考虑)
+
+**为什么 Codeg 能做、别人不能**:
+- Cursor:单进程,没法真异构并行
+- DriFox:单进程,SubAgent 是换 prompt
+- OpenCode/Pi:同上
+- **只有 Codeg 有跨进程 ACP 委托**
+
+**技术可行性(已确认)**:
+- `delegate_to_agent` 已支持 fan-out ✅
+- `get_delegation_status` 已支持批量等 ✅
+- `DelegationSuccess` 已带 `duration_ms`/`token_usage`/`turn_count` ✅
+- `DelegationContext` 已流到前端 ✅
+- **只缺一层横向对比 UI**
+
+**实施档位**:
+
+| 档位 | 内容 | 工作量 |
+|------|------|--------|
+| A 最小可玩 | PK 触发器 + 分屏视图 + 计分板 | 周六一天 |
+| B 好看+分享 | diff 对比 + 实时终端 + 分享截图 + 任务模板 | +周日上午 |
+| C 评判 | 自动测试裁判 + LLM 裁判 | 周日下午(选做) |
+
+**关键代码位置**:
+- 触发器:`src/components/composer/`(加 PK 模式开关)
+- 对比组件:新建 `src/components/chat/agent-pk-arena.tsx`
+- 数据复用:`src/hooks/use-delegation-card-model.ts`(已解出 agent/task/status/childId)
+- 渲染复用:`src/components/message/sub-agent-session-dialog.tsx`(已会渲染单个子 agent)
+- 分享截图:`html-to-image`(package.json 已有依赖)
+
+**传播策略**:
+- V2EX 发帖,标题方向:"周末做了个 AI 编程 PK 场:让 Claude Code、Codex、Gemini 同时写贪吃蛇,看谁快"
+- 每场 PK 都是一次传播机会
+
+**需求验证(2026-08-16)**:上游 issue #428「缺乏派发 subagent 状态的监视」——用户独立要 delegation 可视化监控,与 PK 共用数据层(`use-delegation-card-model.ts`),做完 PK 顺手就有,算免费赠品。
+
+### 🎯 功能 B:角色化 Agent 团队(PK 之后的第二张牌)
+
+**是什么**:预设 leader/build/review 等角色,一键发起"Claude 当 leader 分任务给 Codex(build)和 Gemini(review)"
+
+**为什么做**:
+- 比 PK 更接近"真实有用的工作"(协作 > 竞技)
+- 和 PK 共用同一套 delegation 底层,只换 prompt 和 UI
+- 让 Codeg 从"对比工具"延伸为"团队编排平台"
+
+**来源**:DriFox 的 `plugins/system/agents/*.md`(角色 prompt 设计精良,可借鉴)
+
+**与 v2 的关系**:角色化团队天然需要多轮子会话(v2),但可以先做 one-shot 版本
+
+---
+
+## 七、从 DriFox 可借鉴的具体设计
+
+### 值得偷(按价值排序)
+
+#### 1. 角色化 agent prompt 模板
+- 来源:`plugins/system/agents/{build,leader,review,explore,plan}.md`
+- 用途:Codeg 的角色化团队功能
+- 关键原则(直接抄):
+  - "不做超出需求的功能。一次性代码不做抽象。"
+  - "不要顺手改进相邻代码。不要重构没坏的东西。"
+  - "每一行变更都应该能直接追溯到用户的请求。"
+  - "使用 question 工具提问,优先提供选项"
+
+#### 2. 工具安全分类(三分法)
+- 来源:`app/tools/command_safety.py` + `app/tools/tool_classifier.py`
+- 用途:Codeg 加一层自己的安全护栏(企业版刚需)
+- 规则:
+  - 危险(write/edit/bash/mouse)→ 审批
+  - 安全(read/grep/glob/webfetch)→ 放行
+  - 命令三分法:无元字符直接跑 / 有管道重定向需确认 / 黑名单拒绝
+
+#### 3. "关键文档"记忆机制
+- 来源:`app/core/memory_manager.py` 的 `KeyDocumentsRepository`
+- 用途:解决子 agent 冷启动不懂项目上下文的痛点
+- 做法:用户标记项目重要文件(README/架构文档/API 约定),委托时自动注入 task prompt
+
+#### 4. 任务邮件分发(轻量跨窗口协作)
+- 来源:`app/core/team_manager.py`(文件邮箱)
+- 用途:v3 远程 agent 的备选轻量方案
+- 优先级:低(记住有这个方案)
+
+#### 5. AGENTS.md 作为项目笔记
+- DriFox 印证了这是事实标准,Codeg 已在用,继续走
+
+### 明确不要偷
+
+| 不偷 | 理由 |
+|------|------|
+| PyQt 桌面浮动窗 | 架构不同,非核心价值 |
+| 33 个插件 | 功能堆砌是它 24 star 的原因 |
+| 进程内 SubAgent DAG | Codeg 跨进程委托更强 |
+| ECharts 力导向图 | PK 用并排对比更直观 |
+| LSP 集成(11 种语言) | Cursor 的战场,别送 |
+
+---
+
+## 八、关于接入 zcode 的结论
+
+**结论:暂不接入。**
+
+理由:
+- zcode 不开源,改不了,只能向 Z.ai 提需求
+- zcode 不支持 ACP(不在官方 35+ 兼容列表)
+- 不支持 ACP → 只能做 L1(会话导入 parser),不能做 L2(完整调度)
+- L1 单独价值低(装饰性,用户在 zcode 自己的 app 里已能看会话)
+- zcode 加 ACP 是 Z.ai 的战略决策,Codeg 这边无法推动
+
+**zcode 数据格式(已摸清,备用)**:
+- `~/.zcode/cli/db/db.sqlite` — 主库(session/message/part/todo 表)
+- `~/.zcode/v2/tasks-index.sqlite` — 任务索引
+- `~/.zcode/cli/rollout/*.jsonl` — 原始模型 IO 流
+- `~/.zcode/cli/agents/sess_*/agent_*/` — 子 agent 会话
+
+如果未来 zcode 支持 ACP,接入成本分两档(2026-08-16 修正,依据:上游 DSH 集成案例):
+
+**L1(会话导入,半天,4 处)**:
+1. `models/agent.rs` — `AgentType` 枚举
+2. `acp/registry.rs` — `AcpAgentMeta`
+3. `parsers/mod.rs` — 注册
+4. `parsers/zcode.rs` — 会话导入(可选)
+
+**L2(完整内置 agent,六层 ~25 处,量级 3-5 天)**:
+完整参考:上游提交 `3845e9df`「feat(deepseek): integrate DeepSeek Harness as a built-in agent」,+3271/−50 行,改动约 25 个文件。六层清单:
+
+| 层 | 改动点 | 示例(DSH 提交) |
+|----|--------|----------------|
+| 1. 身份层 | `AgentType` 枚举 + wire 名 + 防自定义 shadow | `models/agent.rs`(+12) |
+| 2. 启动层 | 注册表元数据:npm 包/版本/node 要求/认证方式 | `acp/registry.rs`(+44) |
+| 3. 历史层 | 原生会话解析器(会话进列表/统计/导入,工作量最大) | `parsers/deepseek.rs`(+1291) |
+| 4. 运行时层 | 沙箱根目录 / env 键 / skills 存储 / 只读路径 | `file_system_runtime.rs`、`commands/acp.rs`(+237) |
+| 5. 协议层 | ACP capabilities / MCP 接线 / 传输限制 | `connection.rs`、`commands/mcp.rs`(+398) |
+| 6. 防御层 | 自定义注册表冲突校验 + 文档 | `custom_registry.rs`(+52) |
+
+> **教训**:曾以为"加一个 agent = 改 4 处",实际"内置 agent"是六层全通——只做 1/2 层的 PR 会被上游以"不够一等公民"拒绝(2026-08-16 DSH PR 实测)。以后评估任何"接新 agent"的工作量,按此清单逐层核对。
+
+---
+
+## 九、关键待办与未决问题
+
+### 必须先回答的问题(阻塞所有商业化决策)
+
+- [ ] **现在有没有人重度依赖 Codeg 的 delegation?**(找 10 个真实用户)
+- [ ] **你和同事自己日常用 delegation 吗?**(如果造的人都不用,别指望别人用)
+
+### 功能待办(按优先级)
+
+- [ ] **编程 PK**(周末项目) — 最低成本验证 + 传播
+- [ ] **角色化 Agent 团队**(PK 之后) — 第二个场景
+- [ ] **v2 多轮子会话** — 产品形态质变,1-2 月
+- [ ] **v3 远程 agent** — 商业化钥匙,3-6 月
+
+### 工程待办(2026-08-16 新增,按收益排序)
+
+- [ ] **侧边栏 DB 文件夹索引** — 干掉 13-parser 全量遍历(性能机会 1)
+- [ ] **增量会话解析** — 接通已有但闲置的 `transcript_watermark`(性能机会 2)
+- [ ] **broker.rs 测试外移** — ~4750 行拆到 `broker_tests.rs`,零风险减半
+- [ ] **patch 行号解析加 memo** — 一次 HashMap 的事(性能机会 3)
+
+### 上游影响力机会(刷存在感,非主线)
+
+- [ ] **#391/#387 流式重复文本** — 维护者自己未定位根因(在等用户补 seq 数据);修了就是硬通货
+- [ ] **#396 preferred-config 过滤** — 0xlinn 已给出精确根因:通用路径不按 advertised options 过滤,867 次/23天的重复报错;修法是照抄 grok 路径已有守卫(`connection.rs:1947`)+ `mode` 白名单
+- [x] **#408 接入 qoder cli**(2026-08-17 已完成,待提 PR)— 六层全通:身份/注册表(`qoder-cli`,npx `@qoder-ai/qodercli@1.1.23`,`--acp`)/解析器(Claude 信封格式,`~/.qoder/projects/<encoded-cwd>/<uuid>.jsonl`,state.json 标题加密故走 transcript 明文)/沙箱(`QODER_CONFIG_DIR` RootSlot,实测 `~/.qoder` 可写)/协议(原生 ACP,loadSession+list/resume/fork 全有,MCP 走 settings.json 合并写入+转发跳过)/防御(`qoder-cli` 冲突校验)。规避了既往坑:#396 serde 重命名(测试钉死)、过期 env 误报(important keys 置空)、#468 标题问题(明文派生)。活体验证:server 模式 spawn→握手→prompt→turn_complete→transcript 解析全通。qoder 会话历史与 DSH 等宽(比 DSH 便宜在原生 ACP,贵在 MCP 转发语义相反:qoder 读自己的 settings.json,进跳过名单)
+- [x] **deepseek-acp#2 空 callId 工具调用缺陷**(2026-08-17 已提,跟踪回复中)— 双杀伤实证:live 工具调用全部空 callId/name 被拒(17 个样本,arguments 完整唯头部丢失→解析层问题)+ 持久化后 session/load 校验拒绝整会话("写入不校验、读取强校验"自伤)。附三层修法建议+解包填合成 callId 的手工 workaround(本机验证可行)。注意:deepseek-acp 仓库主人就是 codeg 维护者本人。codeg 侧可做的兜底(未做,等需要时):session/load 失败识别该特定校验错误→自动修复会话文件(备份+填合成 id+重试),救 resume 那一半;live 那一半只能等上游
+  - **2026-08-17 晚结案**:根因找到并修复——`dsh-llm-deepseek` 适配器用 `!== void 0` 守卫 callId/name 捕获,而 flash 经 opencode zen 代理的后续分片用显式 JSON null 重复字段,null 守卫穿透→每片覆盖首片捕获→空名派发。pro 不受影响(其分片是省略字段)。修复=桥接层 fetch 边界改写(把 null 头摘成省略,D4 合规不碰上游),fork 分支 `asteroida123:fix/flash-empty-tool-name`,PR 已提:**xintaofei/deepseek-acp#3**(rc.7 对齐 + fetch 壳 + TC-GUARD-05 四条用例含反向对照,328 测试绿,flash 实测恢复);治本应进 `@deepseek-ai/dsh-llm-deepseek`(守卫改 `!= null`)。用户本机全局 deepseek-acp 已换 PR 版。经验沉淀:①curl 抓原始 SSE 是定位流解析 bug 的终极手段 ②`!== void 0` vs `!= null` 在 JSON null 渗透的现实里必须选后者 ③官方 dsh 包(rc.7)与桥接层(xintaofei)是两个发布方,升级节奏解耦 ④**提 PR 前必读 CONTRIBUTING.md**——本仓 D4 铁律禁止 patch node_modules,第一版方案(补丁版)被文档否决,重做为 fetch 边界改写才合规
+
+### 不做清单(防止分心)
+
+- [x] ~~接入 zcode~~(暂缓,等 ACP)
+- [x] ~~垂直行业方案~~(底座不匹配)
+- [x] ~~做 Cursor 平替~~(蚂蚁 vs 太阳)
+- [x] ~~堆功能数量~~(学 DriFox 的教训)
+- [x] ~~脱离开发者市场~~(丢弃所有资产)
+
+---
+
+## 十、一句话总结
+
+> **Codeg 的硬核技术(跨进程异构委托)是真的,但"硬核"本身不产生收入,产生收入的是"有一群人离不开它"。**
+>
+> **当下的优先级:先用最低成本(PK)验证"多 agent 并行"对开发者有没有吸引力 → 如果有,做 v2/v3 深化 → 如果没有,重新评估方向。**
+>
+> **别再纠结"能不能打过 Cursor"——那不是 Codeg 该问的问题。该问的是:Cursor 用户有什么事想做但 Cursor 架构上做不到?**
diff --git a/docs/images/pk-arena-light.png b/docs/images/pk-arena-light.png
new file mode 100644
index 000000000..5fc57dae2
Binary files /dev/null and b/docs/images/pk-arena-light.png differ
diff --git a/docs/images/pk-launcher-light.png b/docs/images/pk-launcher-light.png
new file mode 100644
index 000000000..57294bec1
Binary files /dev/null and b/docs/images/pk-launcher-light.png differ
diff --git a/docs/images/pk-report-light.png b/docs/images/pk-report-light.png
new file mode 100644
index 000000000..a3013273f
Binary files /dev/null and b/docs/images/pk-report-light.png differ
diff --git a/eslint.config.mjs b/eslint.config.mjs
index e5f5a1c31..f995f8134 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -45,6 +45,7 @@ const eslintConfig = defineConfig([
     // `.gitignore` — but flat config has no such default, so without this
     // `pnpm eslint .` fails the repo on files that are not in the repo.
     ".docs/**",
+    ".codeg-pk/**",
   ]),
   eslintConfigPrettier,
   eslintPluginPrettierRecommended,
diff --git a/package.json b/package.json
index 1d3a0a185..82a6b3e94 100644
--- a/package.json
+++ b/package.json
@@ -94,6 +94,7 @@
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.1.0",
     "@testing-library/user-event": "^14.5.2",
+    "@types/jsdom": "^30.0.0",
     "@types/node": "25.2.2",
     "@types/react": "^19.1.8",
     "@types/react-dom": "^19.1.6",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index acd129f52..f7b3755d2 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -228,6 +228,9 @@ importers:
       '@testing-library/user-event':
         specifier: ^14.5.2
         version: 14.6.3(@testing-library/dom@10.4.1)
+      '@types/jsdom':
+        specifier: ^30.0.0
+        version: 30.0.0
       '@types/node':
         specifier: 25.2.2
         version: 25.2.2
@@ -2948,6 +2951,9 @@ packages:
   '@types/hast@3.0.4':
     resolution: {integrity: sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==}
 
+  '@types/jsdom@30.0.0':
+    resolution: {integrity: sha512-uAHGxujGE0cDaKGdK28zgDotFtNA7MKq5DXl8LrfdxdCI8VHcg15oJz+amHTChPNI5JpgEPQWc2xFdrw3em/nQ==}
+
   '@types/json-schema@7.0.15':
     resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==}
 
@@ -2980,6 +2986,9 @@ packages:
   '@types/statuses@2.0.6':
     resolution: {integrity: sha512-xMAgYwceFhRA2zY+XbEA7mxYbA093wdiW8Vu6gZPGWy9cmOyU9XesH1tNcEWsKFd5Vzrqx5T3D38PWx1FIIXkA==}
 
+  '@types/tough-cookie@4.0.5':
+    resolution: {integrity: sha512-/Ad8+nIOV7Rl++6f1BdKxFSMgmoqEoYbHRpPcx3JEfv8VRsQe9Z4mCXeJBzxs7mbHY/XOZZuXlRNfhpVPbs6ZA==}
+
   '@types/trusted-types@2.0.7':
     resolution: {integrity: sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==}
 
@@ -3982,6 +3991,10 @@ packages:
     resolution: {integrity: sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==}
     engines: {node: '>=0.12'}
 
+  entities@8.0.0:
+    resolution: {integrity: sha512-zwfzJecQ/Uej6tusMqwAqU/6KL2XaB2VZ2Jg54Je6ahNBGNH6Ek6g3jjNCF0fG9EWQKGZNddNjU5F1ZQn/sBnA==}
+    engines: {node: '>=20.19.0'}
+
   env-paths@2.2.1:
     resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==}
     engines: {node: '>=6'}
@@ -4156,6 +4169,7 @@ packages:
   eslint@9.39.2:
     resolution: {integrity: sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    deprecated: This version is no longer supported. Please see https://eslint.org/version-support for other options.
     hasBin: true
     peerDependencies:
       jiti: '*'
@@ -5623,6 +5637,9 @@ packages:
   parse5@7.3.0:
     resolution: {integrity: sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==}
 
+  parse5@8.0.1:
+    resolution: {integrity: sha512-z1e/HMG90obSGeidlli3hj7cbocou0/wa5HacvI3ASx34PecNjNQeaHNo5WIZpWofN9kgkqV1q5YvXe3F0FoPw==}
+
   parseurl@1.3.3:
     resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==}
     engines: {node: '>= 0.8'}
@@ -6499,6 +6516,9 @@ packages:
   undici-types@7.16.0:
     resolution: {integrity: sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==}
 
+  undici-types@8.10.0:
+    resolution: {integrity: sha512-ibvdovq3nCFs8Msrd95BW+zUOq+aOVbT+wpHUoPWhztbHEoPc6oof51iFDB6Es8lTKvNvVW9jNSAB8dwrKTMGg==}
+
   unicorn-magic@0.3.0:
     resolution: {integrity: sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==}
     engines: {node: '>=18'}
@@ -9416,6 +9436,13 @@ snapshots:
     dependencies:
       '@types/unist': 3.0.3
 
+  '@types/jsdom@30.0.0':
+    dependencies:
+      '@types/node': 25.2.2
+      '@types/tough-cookie': 4.0.5
+      parse5: 8.0.1
+      undici-types: 8.10.0
+
   '@types/json-schema@7.0.15': {}
 
   '@types/json5@0.0.29': {}
@@ -9445,6 +9472,8 @@ snapshots:
 
   '@types/statuses@2.0.6': {}
 
+  '@types/tough-cookie@4.0.5': {}
+
   '@types/trusted-types@2.0.7':
     optional: true
 
@@ -10464,6 +10493,8 @@ snapshots:
 
   entities@6.0.1: {}
 
+  entities@8.0.0: {}
+
   env-paths@2.2.1: {}
 
   error-ex@1.3.4:
@@ -12606,6 +12637,10 @@ snapshots:
     dependencies:
       entities: 6.0.1
 
+  parse5@8.0.1:
+    dependencies:
+      entities: 8.0.0
+
   parseurl@1.3.3: {}
 
   path-browserify@1.0.1: {}
@@ -13762,6 +13797,8 @@ snapshots:
 
   undici-types@7.16.0: {}
 
+  undici-types@8.10.0: {}
+
   unicorn-magic@0.3.0: {}
 
   unified@11.0.5:
diff --git a/src-tauri/src/acp/connection.rs b/src-tauri/src/acp/connection.rs
index 9f116b0d8..c999fd07b 100644
--- a/src-tauri/src/acp/connection.rs
+++ b/src-tauri/src/acp/connection.rs
@@ -6402,11 +6402,17 @@ async fn apply_preferred_session_options(
     initial_config_options: Vec<SessionConfigOption>,
 ) -> Vec<SessionConfigOption> {
     if let Some(pref_mode) = preferred_mode_id {
-        let needs_apply = session
+        let is_advertised = session
             .modes()
             .as_ref()
-            .map(|m| m.current_mode_id.to_string() != pref_mode)
+            .map(|m| m.available_modes.iter().any(|mode| mode.id.to_string() == pref_mode))
             .unwrap_or(false);
+        let needs_apply = is_advertised
+            && session
+                .modes()
+                .as_ref()
+                .map(|m| m.current_mode_id.to_string() != pref_mode)
+                .unwrap_or(false);
         if needs_apply {
             if let Err(e) = set_session_mode(session, state, emitter, pref_mode.to_string()).await {
                 tracing::error!("[ACP] failed to apply preferred mode '{pref_mode}' on connect: {e}");
diff --git a/src-tauri/src/acp/lifecycle.rs b/src-tauri/src/acp/lifecycle.rs
index ec3ce9065..c759dd32b 100644
--- a/src-tauri/src/acp/lifecycle.rs
+++ b/src-tauri/src/acp/lifecycle.rs
@@ -280,19 +280,28 @@ pub(crate) async fn handle_event(
                 return Ok(());
             };
             if let Some(ts) = target_status.clone() {
-                // DB write before emit so any downstream subscriber that observes
-                // the ConversationStatusChanged event can assume the row is
-                // already at the target status.
-                conversation_service::update_status(db_conn, cid, ts.clone()).await?;
-                emit_with_state(
-                    &state_arc,
-                    &emitter,
-                    AcpEvent::ConversationStatusChanged {
-                        conversation_id: cid,
-                        status: ts,
-                    },
+                // A system-owned caller (the PK judge) may mark the row
+                // Completed as soon as its verdict is parsed. Only advance a
+                // still-live row so this asynchronous worker cannot overwrite
+                // that terminal state back to PendingReview.
+                let changed = conversation_service::update_status_if(
+                    db_conn,
+                    cid,
+                    ConversationStatus::InProgress,
+                    ts.clone(),
                 )
-                .await;
+                .await?;
+                if changed {
+                    emit_with_state(
+                        &state_arc,
+                        &emitter,
+                        AcpEvent::ConversationStatusChanged {
+                            conversation_id: cid,
+                            status: ts,
+                        },
+                    )
+                    .await;
+                }
             }
 
             // If this conversation was spawned by a delegation, resolve the
@@ -2089,6 +2098,48 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn handle_event_turn_complete_preserves_already_completed_conversation() {
+        let db = test_helpers::fresh_in_memory_db().await;
+        let folder_id = test_helpers::seed_folder(&db, "/tmp/turn-complete-race").await;
+        let conv =
+            conversation_service::create(&db.conn, folder_id, AgentType::Codex, None, None)
+                .await
+                .unwrap();
+        conversation_service::update_status(
+            &db.conn,
+            conv.id,
+            ConversationStatus::Completed,
+        )
+        .await
+        .unwrap();
+
+        let mgr = ConnectionManager::new();
+        {
+            let mut map = mgr.connections.lock().await;
+            map.insert(
+                "judge".to_string(),
+                fake_connection_with_state("judge", Some(conv.id)),
+            );
+        }
+        let env = EventEnvelope {
+            seq: 1,
+            connection_id: "judge".to_string(),
+            payload: AcpEvent::TurnComplete {
+                session_id: "ext-judge".into(),
+                stop_reason: "end_turn".into(),
+                agent_type: "codex".into(),
+            },
+        };
+
+        handle_event(&db.conn, &mgr, &env, None).await.unwrap();
+
+        assert_eq!(
+            read_row_status(&db, conv.id).await,
+            ConversationStatus::Completed
+        );
+    }
+
     #[tokio::test]
     async fn handle_event_writes_cancelled_on_turn_failure_stop_reasons() {
         // OpenCode (and similar agents) maps backend errors to `Refusal`.
diff --git a/src-tauri/src/acp/manager.rs b/src-tauri/src/acp/manager.rs
index 550cbb118..c3a891508 100644
--- a/src-tauri/src/acp/manager.rs
+++ b/src-tauri/src/acp/manager.rs
@@ -1976,6 +1976,7 @@ impl ConnectionManager {
                         deleted_at: Set(None),
                         pinned_at: Set(None),
                         origin_cwd: Set(None),
+                        pk_round_id: Set(None),
                     };
                     let inserted = sibling.insert(txn).await?;
                     Ok(inserted.id)
diff --git a/src-tauri/src/commands/conversations.rs b/src-tauri/src/commands/conversations.rs
index 90641c2ac..dec88784d 100644
--- a/src-tauri/src/commands/conversations.rs
+++ b/src-tauri/src/commands/conversations.rs
@@ -1863,6 +1863,49 @@ pub async fn create_conversation(
     Ok(id)
 }
 
+/// Create a PK arena contestant conversation: `kind = Pk` + `pk_round_id` set,
+/// so the sidebar routes it to the per-round PK section instead of the folder
+/// list. The git branch is detected from the folder path just like a regular
+/// conversation (contestants run inside a worktree under that folder).
+pub async fn create_pk_conversation_core(
+    conn: &sea_orm::DatabaseConnection,
+    folder_id: i32,
+    agent_type: AgentType,
+    title: Option<String>,
+    pk_round_id: i32,
+) -> Result<i32, AppCommandError> {
+    let git_branch = if let Some(folder) = folder_service::get_folder_by_id(conn, folder_id)
+        .await
+        .map_err(AppCommandError::from)?
+    {
+        detect_git_branch(&folder.path).await
+    } else {
+        None
+    };
+
+    let model =
+        conversation_service::create_pk(conn, folder_id, agent_type, title, git_branch, pk_round_id)
+            .await
+            .map_err(AppCommandError::from)?;
+    Ok(model.id)
+}
+
+#[cfg(feature = "tauri-runtime")]
+#[cfg_attr(feature = "tauri-runtime", tauri::command)]
+pub async fn create_pk_conversation(
+    app: tauri::AppHandle,
+    db: tauri::State<'_, AppDatabase>,
+    folder_id: i32,
+    agent_type: AgentType,
+    title: Option<String>,
+    pk_round_id: i32,
+) -> Result<i32, AppCommandError> {
+    let id =
+        create_pk_conversation_core(&db.conn, folder_id, agent_type, title, pk_round_id).await?;
+    emit_conversation_upsert(&EventEmitter::Tauri(app), &db.conn, id).await;
+    Ok(id)
+}
+
 /// Result of [`create_chat_conversation_core`]: the new conversation id plus the
 /// hidden chat folder backing it, so the frontend can drop the folder straight
 /// into `allFolders` (resolving cwd / active-folder) without a refetch.
@@ -2441,6 +2484,7 @@ mod tests {
             parent_tool_use_id: Some(parent_tool_use_id.into()),
             delegation_call_id: Some("call-1".into()),
             origin_cwd: None,
+            pk_round_id: None,
         }
     }
 
@@ -5448,6 +5492,7 @@ mod tests {
                 parent_tool_use_id: None,
                 delegation_call_id: None,
                 origin_cwd: None,
+                pk_round_id: None,
             },
             turns,
             session_stats: None,
diff --git a/src-tauri/src/commands/folders.rs b/src-tauri/src/commands/folders.rs
index 942796834..eaa030207 100644
--- a/src-tauri/src/commands/folders.rs
+++ b/src-tauri/src/commands/folders.rs
@@ -2021,6 +2021,42 @@ pub async fn git_worktree_add(
         );
     }
 
+    // An unborn HEAD (fresh `git init`, no commits yet) makes
+    // `worktree add -b <branch>` fail with "invalid reference: HEAD" — there
+    // is no commit for the new branch to point at. Recover by seeding an
+    // empty initial commit, which every subsequent worktree bases itself on.
+    // Only reachable in a state where the command would have errored anyway,
+    // so existing callers see strictly fewer failures.
+    let head_check = crate::process::tokio_command("git")
+        .args(["rev-parse", "--verify", "HEAD"])
+        .current_dir(&path)
+        .output()
+        .await
+        .map_err(AppCommandError::io)?;
+    if !head_check.status.success() {
+        // Inline identity overrides: a machine with no global user.name/
+        // user.email would otherwise fail the seed commit.
+        let seed = crate::process::tokio_command("git")
+            .args([
+                "-c",
+                "user.name=codeg",
+                "-c",
+                "user.email=codeg@local",
+                "commit",
+                "-q",
+                "--allow-empty",
+                "-m",
+                "codeg: initial commit (repository had no commits)",
+            ])
+            .current_dir(&path)
+            .output()
+            .await
+            .map_err(AppCommandError::io)?;
+        if !seed.status.success() {
+            return Err(git_command_error("commit (seed empty initial)", &seed.stderr));
+        }
+    }
+
     // 执行 git worktree add -b <branch> <path> [<base>]
     // 显式 base（提交/引用）消除「读分支 → 建 worktree」间用户切分支的漂移窗口；
     // 省略时沿用 HEAD（既有调用方行为不变）。
@@ -6427,6 +6463,36 @@ mod tests {
         );
     }
 
+    /// A fresh `git init` leaves HEAD unborn, and `worktree add -b <branch>`
+    /// fails against it ("invalid reference: HEAD") because the new branch
+    /// has no commit to point at. `git_worktree_add` must recover by seeding
+    /// an empty initial commit — with inline identity, so a machine without
+    /// global user.name/user.email still works.
+    #[tokio::test]
+    async fn git_worktree_add_seeds_empty_initial_commit_on_unborn_head() {
+        let dir = tempfile::tempdir().expect("tempdir");
+        git_run(dir.path(), &["init", "-q"]);
+
+        let wt = dir.path().join("wt");
+        git_worktree_add(
+            dir.path().to_str().unwrap().to_string(),
+            "codeg-pk/r1/agent".to_string(),
+            wt.to_str().unwrap().to_string(),
+            None,
+        )
+        .await
+        .expect("worktree add must recover from an unborn HEAD");
+
+        assert!(wt.join(".git").exists(), "worktree must exist");
+        // The seeded commit landed on the default branch, so HEAD resolves.
+        let head = std::process::Command::new("git")
+            .args(["rev-parse", "--verify", "HEAD"])
+            .current_dir(dir.path())
+            .output()
+            .expect("spawn git");
+        assert!(head.status.success(), "HEAD must resolve after seeding");
+    }
+
     #[tokio::test]
     async fn resolve_git_head_handles_non_repo() {
         let dir = tempfile::tempdir().expect("tempdir");
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index dcf009cc3..916b66ff9 100644
--- a/src-tauri/src/commands/mod.rs
+++ b/src-tauri/src/commands/mod.rs
@@ -25,6 +25,7 @@ pub mod office_tools;
 #[cfg(feature = "tauri-runtime")]
 pub mod notification;
 pub mod pet;
+pub mod pk;
 pub mod project_boot;
 pub mod question;
 pub mod quick_messages;
diff --git a/src-tauri/src/commands/pk.rs b/src-tauri/src/commands/pk.rs
new file mode 100644
index 000000000..47503a659
--- /dev/null
+++ b/src-tauri/src/commands/pk.rs
@@ -0,0 +1,391 @@
+//! PK arena round CRUD commands. The `*_core` fns are mode-agnostic and
+//! shared by the Tauri wrappers and the Axum handlers.
+
+use std::path::{Path, PathBuf};
+
+use crate::app_error::AppCommandError;
+use crate::db::entities::pk_round::PkRoundStatus;
+use crate::db::error::DbError;
+use crate::db::service::pk_round_service;
+use crate::db::AppDatabase;
+use crate::models::{PkRoundConfig, PkRoundInfo};
+
+const PK_REPORT_SNAPSHOT_DIR: &str = "pk-report-snapshots";
+const PK_REPORT_SNAPSHOT_MAX_BYTES: usize = 48 * 1024 * 1024;
+
+fn report_snapshot_path(data_dir: &Path, id: i32) -> PathBuf {
+    data_dir
+        .join(PK_REPORT_SNAPSHOT_DIR)
+        .join(format!("{id}.json"))
+}
+
+// -- shared business logic (both modes) --
+
+pub async fn pk_round_list_core(
+    db: &AppDatabase,
+    folder_id: Option<i32>,
+) -> Result<Vec<PkRoundInfo>, DbError> {
+    pk_round_service::list(&db.conn, folder_id).await
+}
+
+pub async fn pk_round_get_core(db: &AppDatabase, id: i32) -> Result<PkRoundInfo, DbError> {
+    pk_round_service::get_info(&db.conn, id).await
+}
+
+pub async fn pk_round_create_core(
+    db: &AppDatabase,
+    folder_id: i32,
+    task: String,
+    config: PkRoundConfig,
+) -> Result<PkRoundInfo, DbError> {
+    let row = pk_round_service::create(&db.conn, folder_id, task, config).await?;
+    pk_round_service::get_info(&db.conn, row.id).await
+}
+
+pub async fn pk_round_update_status_core(
+    db: &AppDatabase,
+    id: i32,
+    status: String,
+) -> Result<(), DbError> {
+    let parsed = match status.as_str() {
+        "ready" => PkRoundStatus::Ready,
+        "running" => PkRoundStatus::Running,
+        "finished" => PkRoundStatus::Finished,
+        "canceled" => PkRoundStatus::Canceled,
+        "interrupted" => PkRoundStatus::Interrupted,
+        other => {
+            return Err(DbError::Validation(format!(
+                "unknown pk_round status: {other}"
+            )));
+        }
+    };
+    pk_round_service::update_status(&db.conn, id, parsed).await
+}
+
+pub async fn pk_round_delete_core(db: &AppDatabase, id: i32) -> Result<(), DbError> {
+    pk_round_service::soft_delete(&db.conn, id).await
+}
+
+pub async fn pk_round_update_judge_core(
+    db: &AppDatabase,
+    id: i32,
+    judge_result: Option<String>,
+    judge_status: String,
+) -> Result<(), DbError> {
+    pk_round_service::update_judge(&db.conn, id, judge_result, judge_status).await
+}
+
+/// Persist the self-contained artifacts and runtime metrics needed to export a
+/// round after its disposable git worktrees have been removed. The payload is
+/// versioned JSON owned by the frontend; the backend deliberately treats it as
+/// opaque data and only enforces a bounded size and a stable per-round path.
+pub async fn pk_round_save_report_snapshot_core(
+    data_dir: &Path,
+    id: i32,
+    snapshot: String,
+) -> Result<(), AppCommandError> {
+    if snapshot.len() > PK_REPORT_SNAPSHOT_MAX_BYTES {
+        return Err(AppCommandError::invalid_input(format!(
+            "PK report snapshot exceeds {} MiB",
+            PK_REPORT_SNAPSHOT_MAX_BYTES / 1024 / 1024
+        )));
+    }
+    let path = report_snapshot_path(data_dir, id);
+    let parent = path
+        .parent()
+        .ok_or_else(|| AppCommandError::invalid_input("invalid PK report snapshot path"))?;
+    tokio::fs::create_dir_all(parent)
+        .await
+        .map_err(AppCommandError::io)?;
+    tokio::fs::write(path, snapshot)
+        .await
+        .map_err(AppCommandError::io)
+}
+
+pub async fn pk_round_get_report_snapshot_core(
+    data_dir: &Path,
+    id: i32,
+) -> Result<Option<String>, AppCommandError> {
+    let path = report_snapshot_path(data_dir, id);
+    match tokio::fs::read_to_string(path).await {
+        Ok(snapshot) => Ok(Some(snapshot)),
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(None),
+        Err(error) => Err(AppCommandError::io(error)),
+    }
+}
+
+pub async fn pk_round_delete_report_snapshot_core(
+    data_dir: &Path,
+    id: i32,
+) -> Result<(), AppCommandError> {
+    match tokio::fs::remove_file(report_snapshot_path(data_dir, id)).await {
+        Ok(()) => Ok(()),
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(()),
+        Err(error) => Err(AppCommandError::io(error)),
+    }
+}
+
+/// Archive is a database operation; deleting its derived report cache is
+/// best-effort. A cache cleanup failure must not turn an already committed
+/// archive into a user-visible failure.
+pub async fn pk_round_archive_core(
+    db: &AppDatabase,
+    data_dir: &Path,
+    id: i32,
+) -> Result<(), DbError> {
+    pk_round_delete_core(db, id).await?;
+    if let Err(error) = pk_round_delete_report_snapshot_core(data_dir, id).await {
+        tracing::warn!(
+            "[PK] round {id} archived, but its report snapshot could not be removed: {error}"
+        );
+    }
+    Ok(())
+}
+
+// -- Tauri command wrappers (desktop mode only) --
+
+#[cfg(feature = "tauri-runtime")]
+fn resolve_desktop_data_dir(app: &tauri::AppHandle) -> Result<PathBuf, AppCommandError> {
+    use tauri::Manager;
+
+    let fallback = app
+        .path()
+        .app_data_dir()
+        .map_err(|error| {
+            AppCommandError::io_error("Resolve app data dir").with_detail(error.to_string())
+        })?;
+    Ok(crate::paths::resolve_effective_data_dir(&fallback))
+}
+
+#[cfg(feature = "tauri-runtime")]
+#[tauri::command]
+pub async fn pk_round_list(
+    db: tauri::State<'_, AppDatabase>,
+    folder_id: Option<i32>,
+) -> Result<Vec<PkRoundInfo>, DbError> {
+    pk_round_list_core(&db, folder_id).await
+}
+
+#[cfg(feature = "tauri-runtime")]
+#[tauri::command]
+pub async fn pk_round_get(
+    db: tauri::State<'_, AppDatabase>,
+    id: i32,
+) -> Result<PkRoundInfo, DbError> {
+    pk_round_get_core(&db, id).await
+}
+
+#[cfg(feature = "tauri-runtime")]
+#[tauri::command]
+pub async fn pk_round_create(
+    db: tauri::State<'_, AppDatabase>,
+    folder_id: i32,
+    task: String,
+    config: PkRoundConfig,
+) -> Result<PkRoundInfo, DbError> {
+    pk_round_create_core(&db, folder_id, task, config).await
+}
+
+#[cfg(feature = "tauri-runtime")]
+#[tauri::command]
+pub async fn pk_round_update_status(
+    db: tauri::State<'_, AppDatabase>,
+    id: i32,
+    status: String,
+) -> Result<(), DbError> {
+    pk_round_update_status_core(&db, id, status).await
+}
+
+#[cfg(feature = "tauri-runtime")]
+#[tauri::command]
+pub async fn pk_round_delete(
+    db: tauri::State<'_, AppDatabase>,
+    app: tauri::AppHandle,
+    id: i32,
+) -> Result<(), AppCommandError> {
+    // Resolve fallible runtime state before committing the archive.
+    let data_dir = resolve_desktop_data_dir(&app)?;
+    pk_round_archive_core(&db, &data_dir, id)
+        .await
+        .map_err(AppCommandError::from)?;
+    Ok(())
+}
+
+#[cfg(feature = "tauri-runtime")]
+#[tauri::command]
+pub async fn pk_round_update_judge(
+    db: tauri::State<'_, AppDatabase>,
+    id: i32,
+    judge_result: Option<String>,
+    judge_status: String,
+) -> Result<(), DbError> {
+    pk_round_update_judge_core(&db, id, judge_result, judge_status).await
+}
+
+#[cfg(feature = "tauri-runtime")]
+#[tauri::command]
+pub async fn pk_round_save_report_snapshot(
+    app: tauri::AppHandle,
+    id: i32,
+    snapshot: String,
+) -> Result<(), AppCommandError> {
+    let data_dir = resolve_desktop_data_dir(&app)?;
+    pk_round_save_report_snapshot_core(&data_dir, id, snapshot).await
+}
+
+#[cfg(feature = "tauri-runtime")]
+#[tauri::command]
+pub async fn pk_round_get_report_snapshot(
+    app: tauri::AppHandle,
+    id: i32,
+) -> Result<Option<String>, AppCommandError> {
+    let data_dir = resolve_desktop_data_dir(&app)?;
+    pk_round_get_report_snapshot_core(&data_dir, id).await
+}
+
+#[cfg(test)]
+mod tests {
+    use sea_orm::EntityTrait;
+
+    use super::*;
+    use crate::db::entities::conversation;
+    use crate::db::service::conversation_service;
+    use crate::db::test_helpers::{fresh_in_memory_db, seed_folder};
+    use crate::models::AgentType;
+
+    fn requires_unmanaged_app_state(source: &str) -> bool {
+        let forbidden = [
+            "tauri::State<'_, crate::app_state::",
+            "AppState>",
+        ]
+        .concat();
+        source.contains(&forbidden)
+    }
+
+    #[test]
+    fn detects_the_unmanaged_state_signature_that_breaks_tauri_invocation() {
+        let broken = [
+            "state: tauri::State<'_, crate::app_state::",
+            "AppState>,",
+        ]
+        .concat();
+        assert!(requires_unmanaged_app_state(&broken));
+    }
+
+    #[test]
+    fn desktop_pk_commands_do_not_require_unmanaged_app_state() {
+        assert!(
+            !requires_unmanaged_app_state(include_str!("pk.rs")),
+            "desktop PK commands must use automatically injected AppHandle or a registered state"
+        );
+    }
+
+    #[tokio::test]
+    async fn archiving_round_also_hides_its_pk_conversations() {
+        let db = fresh_in_memory_db().await;
+        let folder_id = seed_folder(&db, "/tmp/pk-archive").await;
+        let round = pk_round_service::create(
+            &db.conn,
+            folder_id,
+            "test task".into(),
+            PkRoundConfig {
+                agents: Vec::new(),
+                permission_mode: "default".into(),
+                bare_mode: false,
+                effort: "default".into(),
+                judge_agent: None,
+                judge_dimensions: Vec::new(),
+                base_commit: None,
+            },
+        )
+        .await
+        .unwrap();
+        let conversation = conversation_service::create_pk(
+            &db.conn,
+            folder_id,
+            AgentType::Qoder,
+            Some("PK contestant".into()),
+            None,
+            round.id,
+        )
+        .await
+        .unwrap();
+
+        pk_round_delete_core(&db, round.id).await.unwrap();
+
+        assert!(pk_round_service::list(&db.conn, None)
+            .await
+            .unwrap()
+            .is_empty());
+        let archived = conversation::Entity::find_by_id(conversation.id)
+            .one(&db.conn)
+            .await
+            .unwrap()
+            .unwrap();
+        assert!(archived.deleted_at.is_some());
+    }
+
+    #[tokio::test]
+    async fn snapshot_cleanup_failure_does_not_turn_archive_into_failure() {
+        let db = fresh_in_memory_db().await;
+        let folder_id = seed_folder(&db, "/tmp/pk-archive-cache").await;
+        let round = pk_round_service::create(
+            &db.conn,
+            folder_id,
+            "test task".into(),
+            PkRoundConfig {
+                agents: Vec::new(),
+                permission_mode: "default".into(),
+                bare_mode: false,
+                effort: "default".into(),
+                judge_agent: None,
+                judge_dimensions: Vec::new(),
+                base_commit: None,
+            },
+        )
+        .await
+        .unwrap();
+        let data_dir = tempfile::tempdir().unwrap();
+        let snapshot_path = report_snapshot_path(data_dir.path(), round.id);
+        std::fs::create_dir_all(&snapshot_path).unwrap();
+
+        pk_round_archive_core(&db, data_dir.path(), round.id)
+            .await
+            .unwrap();
+
+        assert!(pk_round_service::list(&db.conn, None)
+            .await
+            .unwrap()
+            .is_empty());
+        assert!(snapshot_path.is_dir());
+    }
+
+    #[tokio::test]
+    async fn saved_report_snapshot_survives_worktree_cleanup() {
+        let data_dir = tempfile::tempdir().unwrap();
+        let worktree = tempfile::tempdir().unwrap();
+        std::fs::write(worktree.path().join("index.html"), "<h1>entry</h1>").unwrap();
+        let snapshot = r#"{"version":1,"artifactsBySlot":{"0":[{"path":"index.html","contentBase64":"PGgxPmVudHJ5PC9oMT4="}]}}"#;
+
+        pk_round_save_report_snapshot_core(data_dir.path(), 7, snapshot.into())
+            .await
+            .unwrap();
+        worktree.close().unwrap();
+
+        assert_eq!(
+            pk_round_get_report_snapshot_core(data_dir.path(), 7)
+                .await
+                .unwrap()
+                .as_deref(),
+            Some(snapshot)
+        );
+
+        pk_round_delete_report_snapshot_core(data_dir.path(), 7)
+            .await
+            .unwrap();
+        assert!(pk_round_get_report_snapshot_core(data_dir.path(), 7)
+            .await
+            .unwrap()
+            .is_none());
+    }
+}
diff --git a/src-tauri/src/commands/token_usage.rs b/src-tauri/src/commands/token_usage.rs
index c48009ce2..711d778f7 100644
--- a/src-tauri/src/commands/token_usage.rs
+++ b/src-tauri/src/commands/token_usage.rs
@@ -1337,6 +1337,7 @@ mod tests {
                 parent_tool_use_id: None,
                 delegation_call_id: None,
                 origin_cwd: None,
+                pk_round_id: None,
             },
             turns,
             session_stats: stats,
diff --git a/src-tauri/src/commands/windows.rs b/src-tauri/src/commands/windows.rs
index 7ea73da10..bb9197ccc 100644
--- a/src-tauri/src/commands/windows.rs
+++ b/src-tauri/src/commands/windows.rs
@@ -594,6 +594,56 @@ pub async fn open_folder_window(
     Ok(folder)
 }
 
+#[cfg(feature = "tauri-runtime")]
+#[cfg_attr(feature = "tauri-runtime", tauri::command)]
+pub async fn open_pk_round_window(
+    app: AppHandle,
+    round_id: String,
+    title: String,
+    remote_connection_id: Option<i32>,
+) -> Result<(), AppCommandError> {
+    let parsed_round_id = round_id.parse::<i64>().map_err(|_| {
+        AppCommandError::invalid_input("Invalid PK round id")
+            .with_detail(format!("round_id={round_id}"))
+    })?;
+    let label = match remote_connection_id {
+        Some(remote_id) => format!("remote-pk-round-{remote_id}-{parsed_round_id}"),
+        None => format!("pk-round-{parsed_round_id}"),
+    };
+
+    if let Some(existing) = app.get_webview_window(&label) {
+        let _ = existing.unminimize();
+        existing
+            .set_focus()
+            .map_err(|e| AppCommandError::window("Failed to focus PK window", e.to_string()))?;
+        return Ok(());
+    }
+
+    let (url_str, remote_window_id) = route_with_new_remote_window(
+        format!("workspace?pkRoundId={parsed_round_id}"),
+        remote_connection_id,
+    );
+    let window_title = if title.trim().is_empty() {
+        "PK Arena".to_string()
+    } else {
+        format!("PK - {}", title.trim())
+    };
+    let builder = WebviewWindowBuilder::new(&app, &label, WebviewUrl::App(url_str.into()))
+        .title(window_title)
+        .inner_size(1440.0, 900.0)
+        .min_inner_size(900.0, 600.0)
+        .center();
+    let pk_window = apply_platform_window_style(builder)
+        .build()
+        .map_err(|e| AppCommandError::window("Failed to open PK window", e.to_string()))?;
+    register_remote_window_cleanup(&app, &pk_window, remote_window_id.as_deref());
+    post_window_setup(&pk_window);
+    pk_window
+        .set_focus()
+        .map_err(|e| AppCommandError::window("Failed to focus PK window", e.to_string()))?;
+    Ok(())
+}
+
 #[cfg(feature = "tauri-runtime")]
 #[cfg_attr(feature = "tauri-runtime", tauri::command)]
 pub async fn open_commit_window(
diff --git a/src-tauri/src/db/entities/conversation.rs b/src-tauri/src/db/entities/conversation.rs
index ac4c88366..1d465ca6b 100644
--- a/src-tauri/src/db/entities/conversation.rs
+++ b/src-tauri/src/db/entities/conversation.rs
@@ -21,6 +21,8 @@ pub enum ConversationStatus {
 /// excluded from the sidebar list entirely (no write path yet — reserved for
 /// the loop engine); `delegate` is a delegation child nested under its
 /// parent's tool-call view. Invariant: `kind == Delegate` ⟺ `parent_id IS NOT
+/// NULL`. `pk` is a PK-arena contestant session — grouped under its round in
+/// the sidebar's PK section. Invariant: `kind == Pk` ⟺ `pk_round_id IS NOT
 /// NULL`. Written once at insert, never updated.
 #[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum, Serialize, Deserialize)]
 #[sea_orm(rs_type = "String", db_type = "String(StringLen::None)")]
@@ -34,6 +36,8 @@ pub enum ConversationKind {
     Loop,
     #[sea_orm(string_value = "delegate")]
     Delegate,
+    #[sea_orm(string_value = "pk")]
+    Pk,
 }
 
 #[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
@@ -58,6 +62,9 @@ pub struct Model {
     pub parent_id: Option<i32>,
     pub parent_tool_use_id: Option<String>,
     pub delegation_call_id: Option<String>,
+    /// The PK arena round this contestant session belongs to. NULL for every
+    /// other kind; always set when `kind == Pk`. Written once at insert.
+    pub pk_round_id: Option<i32>,
     pub message_count: i32,
     pub created_at: DateTimeUtc,
     pub updated_at: DateTimeUtc,
diff --git a/src-tauri/src/db/entities/mod.rs b/src-tauri/src/db/entities/mod.rs
index 1506c19c3..eb1dc6825 100644
--- a/src-tauri/src/db/entities/mod.rs
+++ b/src-tauri/src/db/entities/mod.rs
@@ -13,6 +13,7 @@ pub mod folder_command;
 pub mod folder_link;
 pub mod model_provider;
 pub mod opened_tab;
+pub mod pk_round;
 pub mod prelude;
 pub mod quick_message;
 pub mod remote_workspace_connection;
diff --git a/src-tauri/src/db/entities/pk_round.rs b/src-tauri/src/db/entities/pk_round.rs
new file mode 100644
index 000000000..ee04baff0
--- /dev/null
+++ b/src-tauri/src/db/entities/pk_round.rs
@@ -0,0 +1,61 @@
+use sea_orm::entity::prelude::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, EnumIter, DeriveActiveEnum, Serialize, Deserialize)]
+#[sea_orm(rs_type = "String", db_type = "String(StringLen::None)")]
+#[serde(rename_all = "snake_case")]
+pub enum PkRoundStatus {
+    #[sea_orm(string_value = "ready")]
+    Ready,
+    #[sea_orm(string_value = "running")]
+    Running,
+    #[sea_orm(string_value = "finished")]
+    Finished,
+    #[sea_orm(string_value = "canceled")]
+    Canceled,
+    #[sea_orm(string_value = "interrupted")]
+    Interrupted,
+}
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "pk_round")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub folder_id: i32,
+    #[sea_orm(column_type = "Text")]
+    pub task: String,
+    #[sea_orm(column_type = "Text")]
+    pub config: String,
+    pub status: PkRoundStatus,
+    pub failure_reason: Option<String>,
+    /// JSON: serialized judge verdict (scores, summary, raw text). Null if
+    /// no judge was configured or the judge hasn't run yet.
+    #[sea_orm(column_type = "Text", nullable)]
+    pub judge_result: Option<String>,
+    /// idle | running | done | error | skipped
+    #[sea_orm(column_type = "Text", nullable)]
+    pub judge_status: Option<String>,
+    pub created_at: DateTimeUtc,
+    pub updated_at: DateTimeUtc,
+    pub finished_at: Option<DateTimeUtc>,
+    pub deleted_at: Option<DateTimeUtc>,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::folder::Entity",
+        from = "Column::FolderId",
+        to = "super::folder::Column::Id"
+    )]
+    Folder,
+}
+
+impl Related<super::folder::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Folder.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}
diff --git a/src-tauri/src/db/entities/prelude.rs b/src-tauri/src/db/entities/prelude.rs
index aed43e131..d99477d71 100644
--- a/src-tauri/src/db/entities/prelude.rs
+++ b/src-tauri/src/db/entities/prelude.rs
@@ -15,6 +15,7 @@ pub use super::folder_command::Entity as FolderCommand;
 pub use super::folder_link::Entity as FolderLink;
 pub use super::model_provider::Entity as ModelProvider;
 pub use super::opened_tab::Entity as OpenedTab;
+pub use super::pk_round::Entity as PkRound;
 pub use super::quick_message::Entity as QuickMessage;
 pub use super::token_usage_sync::Entity as TokenUsageSync;
 pub use super::token_usage_turn::Entity as TokenUsageTurn;
diff --git a/src-tauri/src/db/migration/m20260819_000001_pk_round.rs b/src-tauri/src/db/migration/m20260819_000001_pk_round.rs
new file mode 100644
index 000000000..d23f33668
--- /dev/null
+++ b/src-tauri/src/db/migration/m20260819_000001_pk_round.rs
@@ -0,0 +1,205 @@
+use sea_orm_migration::prelude::*;
+
+/// PK arena rounds and the conversation↔round link.
+///
+/// `pk_round` stores round-level metadata (task, agents, status, competition
+/// options) that was previously in localStorage — moving it to the DB makes
+/// rounds cross-device, server-mode compatible, and queryable.
+///
+/// `conversation.pk_round_id` links each contestant session to its round,
+/// matching the `kind == 'pk'` invariant. Indexed for the sidebar's
+/// per-round grouping query.
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+const IDX_PK_ROUND_FOLDER: &str = "idx_pk_round_folder";
+const IDX_CONVERSATION_PK_ROUND: &str = "idx_conversation_pk_round";
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .create_table(
+                Table::create()
+                    .table(PkRound::Table)
+                    .if_not_exists()
+                    .col(
+                        ColumnDef::new(PkRound::Id)
+                            .integer()
+                            .not_null()
+                            .auto_increment()
+                            .primary_key(),
+                    )
+                    // Soft reference to the project folder (never a worktree).
+                    .col(ColumnDef::new(PkRound::FolderId).integer().not_null())
+                    .col(ColumnDef::new(PkRound::Task).text().not_null())
+                    // JSON: { agents, permission_mode, bare_mode, effort }
+                    .col(ColumnDef::new(PkRound::Config).text().not_null())
+                    // ready | running | finished | canceled | interrupted
+                    .col(
+                        ColumnDef::new(PkRound::Status)
+                            .string()
+                            .not_null()
+                            .default("ready"),
+                    )
+                    .col(ColumnDef::new(PkRound::FailureReason).string().null())
+                    .col(
+                        ColumnDef::new(PkRound::CreatedAt)
+                            .timestamp_with_time_zone()
+                            .not_null(),
+                    )
+                    .col(
+                        ColumnDef::new(PkRound::UpdatedAt)
+                            .timestamp_with_time_zone()
+                            .not_null(),
+                    )
+                    .col(
+                        ColumnDef::new(PkRound::FinishedAt)
+                            .timestamp_with_time_zone()
+                            .null(),
+                    )
+                    .col(
+                        ColumnDef::new(PkRound::DeletedAt)
+                            .timestamp_with_time_zone()
+                            .null(),
+                    )
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_index(
+                Index::create()
+                    .name(IDX_PK_ROUND_FOLDER)
+                    .table(PkRound::Table)
+                    .col(PkRound::FolderId)
+                    .to_owned(),
+            )
+            .await?;
+
+        // Add pk_round_id column to conversation table.
+        manager
+            .alter_table(
+                Table::alter()
+                    .table(Conversation::Table)
+                    .add_column(ColumnDef::new(Conversation::PkRoundId).integer().null())
+                    .to_owned(),
+            )
+            .await?;
+
+        // SQLite cannot create an index for a column that has not been added
+        // yet, so keep this after the ALTER TABLE above.
+        manager
+            .create_index(
+                Index::create()
+                    .name(IDX_CONVERSATION_PK_ROUND)
+                    .table(Conversation::Table)
+                    .col(Conversation::PkRoundId)
+                    .to_owned(),
+            )
+            .await
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .drop_index(
+                Index::drop()
+                    .if_exists()
+                    .name(IDX_CONVERSATION_PK_ROUND)
+                    .table(Conversation::Table)
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .alter_table(
+                Table::alter()
+                    .table(Conversation::Table)
+                    .drop_column(Conversation::PkRoundId)
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .drop_index(
+                Index::drop()
+                    .if_exists()
+                    .name(IDX_PK_ROUND_FOLDER)
+                    .table(PkRound::Table)
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .drop_table(Table::drop().table(PkRound::Table).if_exists().to_owned())
+            .await
+    }
+}
+
+#[derive(DeriveIden)]
+enum PkRound {
+    Table,
+    Id,
+    FolderId,
+    Task,
+    Config,
+    Status,
+    FailureReason,
+    CreatedAt,
+    UpdatedAt,
+    FinishedAt,
+    DeletedAt,
+}
+
+#[derive(DeriveIden)]
+enum Conversation {
+    Table,
+    PkRoundId,
+}
+
+#[cfg(test)]
+mod tests {
+    use sea_orm::Database;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn conversation_round_index_follows_column_lifecycle() {
+        let connection = Database::connect("sqlite::memory:").await.unwrap();
+        let manager = SchemaManager::new(&connection);
+        manager
+            .create_table(
+                Table::create()
+                    .table(Conversation::Table)
+                    .col(
+                        ColumnDef::new(Alias::new("id"))
+                            .integer()
+                            .not_null()
+                            .primary_key(),
+                    )
+                    .to_owned(),
+            )
+            .await
+            .unwrap();
+
+        Migration.up(&manager).await.unwrap();
+        assert!(manager
+            .has_column("conversation", "pk_round_id")
+            .await
+            .unwrap());
+        assert!(manager
+            .has_index("conversation", IDX_CONVERSATION_PK_ROUND)
+            .await
+            .unwrap());
+
+        Migration.down(&manager).await.unwrap();
+        assert!(!manager
+            .has_column("conversation", "pk_round_id")
+            .await
+            .unwrap());
+        assert!(!manager
+            .has_index("conversation", IDX_CONVERSATION_PK_ROUND)
+            .await
+            .unwrap());
+    }
+}
diff --git a/src-tauri/src/db/migration/m20260819_000002_pk_round_judge.rs b/src-tauri/src/db/migration/m20260819_000002_pk_round_judge.rs
new file mode 100644
index 000000000..3e73f6416
--- /dev/null
+++ b/src-tauri/src/db/migration/m20260819_000002_pk_round_judge.rs
@@ -0,0 +1,65 @@
+use sea_orm_migration::prelude::*;
+
+/// Add `judge_result` and `judge_status` columns to `pk_round`.
+///
+/// The judge agent's structured verdict (scores, summary, raw text) was
+/// previously live-only in the Zustand store — lost on refresh or restart.
+/// Persisting it to the DB makes judge results survive across sessions,
+/// which is essential for the export-report and share-screenshot flows.
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .alter_table(
+                Table::alter()
+                    .table(PkRound::Table)
+                    .add_column(ColumnDef::new(PkRound::JudgeResult).text().null())
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .alter_table(
+                Table::alter()
+                    .table(PkRound::Table)
+                    .add_column(
+                        ColumnDef::new(PkRound::JudgeStatus)
+                            .string()
+                            .not_null()
+                            .default("idle"),
+                    )
+                    .to_owned(),
+            )
+            .await
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .alter_table(
+                Table::alter()
+                    .table(PkRound::Table)
+                    .drop_column(PkRound::JudgeStatus)
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .alter_table(
+                Table::alter()
+                    .table(PkRound::Table)
+                    .drop_column(PkRound::JudgeResult)
+                    .to_owned(),
+            )
+            .await
+    }
+}
+
+#[derive(DeriveIden)]
+enum PkRound {
+    Table,
+    JudgeResult,
+    JudgeStatus,
+}
diff --git a/src-tauri/src/db/migration/mod.rs b/src-tauri/src/db/migration/mod.rs
index 3d2b0dcbd..79cabefa4 100644
--- a/src-tauri/src/db/migration/mod.rs
+++ b/src-tauri/src/db/migration/mod.rs
@@ -40,6 +40,8 @@ mod m20260808_000001_custom_agent_supports_mcp;
 mod m20260817_000001_work_task_conversation_title;
 mod m20260818_000001_work_task_source;
 mod m20260819_000001_work_task_completion_kind;
+mod m20260819_000001_pk_round;
+mod m20260819_000002_pk_round_judge;
 pub struct Migrator;
 
 #[async_trait::async_trait]
@@ -86,6 +88,8 @@ impl MigratorTrait for Migrator {
             Box::new(m20260817_000001_work_task_conversation_title::Migration),
             Box::new(m20260818_000001_work_task_source::Migration),
             Box::new(m20260819_000001_work_task_completion_kind::Migration),
+            Box::new(m20260819_000001_pk_round::Migration),
+            Box::new(m20260819_000002_pk_round_judge::Migration),
         ]
     }
 }
diff --git a/src-tauri/src/db/service/conversation_service.rs b/src-tauri/src/db/service/conversation_service.rs
index 9f109071c..2e72cd9d9 100644
--- a/src-tauri/src/db/service/conversation_service.rs
+++ b/src-tauri/src/db/service/conversation_service.rs
@@ -78,6 +78,46 @@ pub async fn create_with_delegation(
     .await
 }
 
+/// Create a PK arena contestant session: `kind = Pk` + `pk_round_id` set,
+/// so the sidebar routes the row to the per-round PK section.
+pub async fn create_pk(
+    conn: &DatabaseConnection,
+    folder_id: i32,
+    agent_type: AgentType,
+    title: Option<String>,
+    git_branch: Option<String>,
+    pk_round_id: i32,
+) -> Result<conversation::Model, DbError> {
+    let at_str = serde_json::to_value(agent_type)
+        .ok()
+        .and_then(|v| v.as_str().map(String::from))
+        .unwrap_or_default();
+    let now = Utc::now();
+    let model = conversation::ActiveModel {
+        id: NotSet,
+        folder_id: Set(folder_id),
+        title: Set(title),
+        title_locked: Set(true),
+        agent_type: Set(at_str),
+        status: Set(conversation::ConversationStatus::InProgress),
+        kind: Set(ConversationKind::Pk),
+        model: Set(None),
+        git_branch: Set(git_branch),
+        external_id: Set(None),
+        parent_id: Set(None),
+        parent_tool_use_id: Set(None),
+        delegation_call_id: Set(None),
+        pk_round_id: Set(Some(pk_round_id)),
+        message_count: Set(0),
+        created_at: Set(now),
+        updated_at: Set(now),
+        deleted_at: Set(None),
+        pinned_at: Set(None),
+        origin_cwd: Set(None),
+    };
+    Ok(model.insert(conn).await?)
+}
+
 async fn create_inner(
     conn: &DatabaseConnection,
     folder_id: i32,
@@ -120,6 +160,7 @@ async fn create_inner(
         deleted_at: Set(None),
         pinned_at: Set(None),
         origin_cwd: Set(None),
+        pk_round_id: Set(None),
     };
     Ok(model.insert(conn).await?)
 }
@@ -854,6 +895,7 @@ struct CarriedOverRow {
     created_at: chrono::DateTime<Utc>,
     updated_at: chrono::DateTime<Utc>,
     origin_cwd: Option<String>,
+    pk_round_id: Option<i32>,
 }
 
 impl CarriedOverRow {
@@ -892,6 +934,7 @@ impl CarriedOverRow {
             // `origin_cwd ?? folder.path`, so dropping this would break
             // history lookup for a re-parented conversation.
             origin_cwd: row.origin_cwd.clone(),
+            pk_round_id: row.pk_round_id,
         }
     }
 
@@ -921,6 +964,7 @@ impl CarriedOverRow {
             // not to the history.
             pinned_at: Set(None),
             origin_cwd: Set(self.origin_cwd),
+            pk_round_id: Set(self.pk_round_id),
         }
     }
 }
@@ -1038,6 +1082,7 @@ fn conv_to_summary(r: conversation::Model) -> DbConversationSummary {
         parent_tool_use_id: r.parent_tool_use_id,
         delegation_call_id: r.delegation_call_id,
         origin_cwd: r.origin_cwd,
+        pk_round_id: r.pk_round_id,
     }
 }
 
diff --git a/src-tauri/src/db/service/import_service.rs b/src-tauri/src/db/service/import_service.rs
index 96974036c..e7c87edea 100644
--- a/src-tauri/src/db/service/import_service.rs
+++ b/src-tauri/src/db/service/import_service.rs
@@ -454,6 +454,7 @@ async fn import_one(
         deleted_at: Set(None),
         pinned_at: Set(None),
         origin_cwd: Set(None),
+        pk_round_id: Set(None),
     };
     conv.insert(conn).await?;
     Ok(ImportOutcome::Imported)
@@ -1013,6 +1014,7 @@ mod tests {
             deleted_at: Set(None),
             pinned_at: Set(None),
             origin_cwd: Set(None),
+            pk_round_id: Set(None),
         }
         .insert(&db.conn)
         .await
diff --git a/src-tauri/src/db/service/mod.rs b/src-tauri/src/db/service/mod.rs
index edda1d933..83b621cda 100644
--- a/src-tauri/src/db/service/mod.rs
+++ b/src-tauri/src/db/service/mod.rs
@@ -10,6 +10,7 @@ pub mod folder_link_service;
 pub mod folder_service;
 pub mod import_service;
 pub mod model_provider_service;
+pub mod pk_round_service;
 pub mod quick_message_service;
 pub mod remote_workspace_connection_service;
 pub mod sender_context_service;
diff --git a/src-tauri/src/db/service/pk_round_service.rs b/src-tauri/src/db/service/pk_round_service.rs
new file mode 100644
index 000000000..773cd8662
--- /dev/null
+++ b/src-tauri/src/db/service/pk_round_service.rs
@@ -0,0 +1,179 @@
+use chrono::Utc;
+use sea_orm::{
+    ActiveModelTrait, ActiveValue::NotSet, ColumnTrait, DatabaseConnection, EntityTrait,
+    QueryFilter, QueryOrder, Set, TransactionTrait,
+};
+
+use crate::db::entities::{conversation, pk_round};
+use crate::db::error::DbError;
+use crate::models::{PkRoundConfig, PkRoundInfo};
+
+/// Map a DB row to a frontend-facing `PkRoundInfo`, deserialising the JSON
+/// config blob. A corrupt blob falls back to empty defaults rather than
+/// failing the whole list — one bad round should not blank the board.
+fn to_info(m: pk_round::Model) -> PkRoundInfo {
+    let config = serde_json::from_str(&m.config).unwrap_or(PkRoundConfig {
+        agents: Vec::new(),
+        permission_mode: "default".into(),
+        bare_mode: false,
+        effort: "default".into(),
+        judge_agent: None,
+        judge_dimensions: Vec::new(),
+        base_commit: None,
+    });
+    let status = serde_json::to_value(m.status)
+        .ok()
+        .and_then(|v| v.as_str().map(String::from))
+        .unwrap_or_else(|| format!("{:?}", m.status));
+    let judge_result = m
+        .judge_result
+        .as_deref()
+        .and_then(|s| serde_json::from_str::<serde_json::Value>(s).ok());
+    let judge_status = m.judge_status.unwrap_or_else(|| "idle".into());
+    PkRoundInfo {
+        id: m.id,
+        folder_id: m.folder_id,
+        task: m.task,
+        config,
+        status,
+        failure_reason: m.failure_reason,
+        judge_result,
+        judge_status,
+        created_at: m.created_at,
+        updated_at: m.updated_at,
+        finished_at: m.finished_at,
+    }
+}
+
+pub async fn create(
+    conn: &DatabaseConnection,
+    folder_id: i32,
+    task: String,
+    config: PkRoundConfig,
+) -> Result<pk_round::Model, DbError> {
+    let now = Utc::now();
+    let config_json = serde_json::to_string(&config).unwrap_or_else(|_| "{}".into());
+    let model = pk_round::ActiveModel {
+        id: NotSet,
+        folder_id: Set(folder_id),
+        task: Set(task),
+        config: Set(config_json),
+        status: Set(pk_round::PkRoundStatus::Ready),
+        failure_reason: Set(None),
+        judge_result: Set(None),
+        judge_status: Set(Some("idle".into())),
+        created_at: Set(now),
+        updated_at: Set(now),
+        finished_at: Set(None),
+        deleted_at: Set(None),
+    };
+    Ok(model.insert(conn).await?)
+}
+
+pub async fn get(conn: &DatabaseConnection, id: i32) -> Result<Option<pk_round::Model>, DbError> {
+    Ok(pk_round::Entity::find_by_id(id).one(conn).await?)
+}
+
+/// List all non-deleted rounds, optionally filtered by folder. Returns
+/// `PkRoundInfo` ready for the frontend.
+pub async fn list(
+    conn: &DatabaseConnection,
+    folder_id: Option<i32>,
+) -> Result<Vec<PkRoundInfo>, DbError> {
+    let mut query = pk_round::Entity::find()
+        .filter(pk_round::Column::DeletedAt.is_null())
+        .order_by_desc(pk_round::Column::CreatedAt);
+    if let Some(fid) = folder_id {
+        query = query.filter(pk_round::Column::FolderId.eq(fid));
+    }
+    let rows = query.all(conn).await?;
+    Ok(rows.into_iter().map(to_info).collect())
+}
+
+/// Get a single round as `PkRoundInfo`.
+pub async fn get_info(conn: &DatabaseConnection, id: i32) -> Result<PkRoundInfo, DbError> {
+    let row = pk_round::Entity::find_by_id(id)
+        .one(conn)
+        .await?
+        .ok_or_else(|| DbError::Migration(format!("PK round not found: {id}")))?;
+    Ok(to_info(row))
+}
+
+pub async fn list_by_folder(
+    conn: &DatabaseConnection,
+    folder_id: i32,
+) -> Result<Vec<pk_round::Model>, DbError> {
+    Ok(pk_round::Entity::find()
+        .filter(pk_round::Column::FolderId.eq(folder_id))
+        .filter(pk_round::Column::DeletedAt.is_null())
+        .order_by_desc(pk_round::Column::CreatedAt)
+        .all(conn)
+        .await?)
+}
+
+pub async fn update_status(
+    conn: &DatabaseConnection,
+    id: i32,
+    status: pk_round::PkRoundStatus,
+) -> Result<(), DbError> {
+    let round = pk_round::Entity::find_by_id(id)
+        .one(conn)
+        .await?
+        .ok_or_else(|| DbError::Migration(format!("PK round not found: {id}")))?;
+    let mut active: pk_round::ActiveModel = round.into();
+    active.status = Set(status);
+    if status == pk_round::PkRoundStatus::Finished
+        || status == pk_round::PkRoundStatus::Canceled
+        || status == pk_round::PkRoundStatus::Interrupted
+    {
+        active.finished_at = Set(Some(Utc::now()));
+    }
+    active.updated_at = Set(Utc::now());
+    active.update(conn).await?;
+    Ok(())
+}
+
+pub async fn soft_delete(conn: &DatabaseConnection, id: i32) -> Result<(), DbError> {
+    use sea_orm::sea_query::Expr;
+
+    let txn = conn.begin().await?;
+    let round = pk_round::Entity::find_by_id(id)
+        .filter(pk_round::Column::DeletedAt.is_null())
+        .one(&txn)
+        .await?
+        .ok_or_else(|| DbError::Migration(format!("PK round not found: {id}")))?;
+    let now = Utc::now();
+    let mut active: pk_round::ActiveModel = round.into();
+    active.deleted_at = Set(Some(now));
+    active.update(&txn).await?;
+    conversation::Entity::update_many()
+        .col_expr(conversation::Column::DeletedAt, Expr::value(Some(now)))
+        .col_expr(conversation::Column::UpdatedAt, Expr::value(now))
+        .filter(conversation::Column::PkRoundId.eq(id))
+        .filter(conversation::Column::DeletedAt.is_null())
+        .exec(&txn)
+        .await?;
+    txn.commit().await?;
+    Ok(())
+}
+
+/// Persist the judge verdict and status. `judge_result` is a pre-serialized
+/// JSON string (the frontend sends the full PkJudgeResult object); passing
+/// None clears it.
+pub async fn update_judge(
+    conn: &DatabaseConnection,
+    id: i32,
+    judge_result: Option<String>,
+    judge_status: String,
+) -> Result<(), DbError> {
+    let round = pk_round::Entity::find_by_id(id)
+        .one(conn)
+        .await?
+        .ok_or_else(|| DbError::Migration(format!("PK round not found: {id}")))?;
+    let mut active: pk_round::ActiveModel = round.into();
+    active.judge_result = Set(judge_result);
+    active.judge_status = Set(Some(judge_status));
+    active.updated_at = Set(Utc::now());
+    active.update(conn).await?;
+    Ok(())
+}
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index fe7a573ce..d2fb3499f 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -70,7 +70,8 @@ mod tauri_app {
         experts as experts_commands, feedback as feedback_commands, file_io, folder_commands,
         folder_links, office_tools as office_tools_commands,
         folders, logging as logging_commands, mcp as mcp_commands,
-        model_provider as model_provider_commands, notification, pet as pet_commands, project_boot,
+        model_provider as model_provider_commands, notification, pet as pet_commands, pk as pk_commands,
+        project_boot,
         question as question_commands, quick_messages as quick_messages_commands,
         remote_proxy as remote_proxy_commands,
         remote_workspace as remote_workspace_commands, science as science_commands,
@@ -1031,6 +1032,7 @@ mod tauri_app {
                 conversations::get_stats,
                 conversations::get_sidebar_data,
                 conversations::create_conversation,
+                conversations::create_pk_conversation,
                 conversations::create_chat_conversation,
                 conversations::create_chat_dir,
                 conversations::update_conversation_status,
@@ -1132,6 +1134,7 @@ mod tauri_app {
                 folders::git_search_authors,
                 folders::git_commit_branches,
                 windows::open_folder_window,
+                windows::open_pk_round_window,
                 windows::open_commit_window,
                 windows::open_settings_window,
                 windows::open_merge_window,
@@ -1400,6 +1403,14 @@ mod tauri_app {
                 work_task_commands::work_task_template_list,
                 work_task_commands::work_task_template_save,
                 work_task_commands::work_task_template_delete,
+                pk_commands::pk_round_list,
+                pk_commands::pk_round_get,
+                pk_commands::pk_round_create,
+                pk_commands::pk_round_update_status,
+                pk_commands::pk_round_delete,
+                pk_commands::pk_round_update_judge,
+                pk_commands::pk_round_save_report_snapshot,
+                pk_commands::pk_round_get_report_snapshot,
                 forge_commands::folder_forge_remote,
                 forge_commands::forge_list_issues,
                 forge_commands::forge_tab_count,
diff --git a/src-tauri/src/models/conversation.rs b/src-tauri/src/models/conversation.rs
index ac1201496..9f16ceefc 100644
--- a/src-tauri/src/models/conversation.rs
+++ b/src-tauri/src/models/conversation.rs
@@ -68,6 +68,11 @@ pub struct DbConversationSummary {
     /// path (set when a removed task worktree's conversations were re-parented).
     #[serde(skip_serializing_if = "Option::is_none")]
     pub origin_cwd: Option<String>,
+    /// Mirror of `conversation.pk_round_id`: the PK arena round this contestant
+    /// session belongs to. Set only when `kind == Pk`; drives the sidebar's
+    /// per-round grouping.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pk_round_id: Option<i32>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
diff --git a/src-tauri/src/models/mod.rs b/src-tauri/src/models/mod.rs
index efe2e9821..32a73f179 100644
--- a/src-tauri/src/models/mod.rs
+++ b/src-tauri/src/models/mod.rs
@@ -7,6 +7,7 @@ pub mod folder;
 pub mod message;
 pub mod model_provider;
 pub mod pet;
+pub mod pk_round;
 pub mod quick_message;
 pub mod remote_workspace_connection;
 pub mod system;
@@ -35,6 +36,7 @@ pub use message::{
     TurnRole, TurnUsage, UnifiedMessage,
 };
 pub use quick_message::QuickMessageInfo;
+pub use pk_round::{PkRoundConfig, PkRoundInfo};
 pub use remote_workspace_connection::RemoteWorkspaceConnectionInfo;
 pub use token_usage::{
     TokenUsageBreakdownItem, TokenUsageBucket, TokenUsageConversationItem, TokenUsageFacets,
diff --git a/src-tauri/src/models/pk_round.rs b/src-tauri/src/models/pk_round.rs
new file mode 100644
index 000000000..4835c0815
--- /dev/null
+++ b/src-tauri/src/models/pk_round.rs
@@ -0,0 +1,131 @@
+use std::collections::BTreeMap;
+
+use serde::{Deserialize, Serialize};
+
+/// One contestant entry in the round config. Supports both a plain string
+/// (backward compat with old rounds: `"claude_code"`) and a labeled object
+/// (new format: `{"agent":"claude_code","label":"Sonnet", ...}`).
+/// `config_values` is applied to
+/// this slot's ACP session before its first prompt; `label` is the captured
+/// human-readable value used to disambiguate same-agent slots.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum PkContestantEntry {
+    Simple(String),
+    Labeled {
+        agent: String,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        label: Option<String>,
+        #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+        config_values: BTreeMap<String, String>,
+    },
+}
+
+impl PkContestantEntry {
+    pub fn agent(&self) -> &str {
+        match self {
+            PkContestantEntry::Simple(a) => a,
+            PkContestantEntry::Labeled { agent, .. } => agent,
+        }
+    }
+    pub fn label(&self) -> Option<&str> {
+        match self {
+            PkContestantEntry::Simple(_) => None,
+            PkContestantEntry::Labeled { label, .. } => label.as_deref(),
+        }
+    }
+}
+
+/// Config stored as JSON in `pk_round.config`. Mirrors the launcher's options
+/// so a round is fully reproducible from the DB row alone.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PkRoundConfig {
+    /// The agent types selected as contestants, in pick order. Each entry
+    /// is either a plain string (old format) or a labeled object (new format).
+    pub agents: Vec<PkContestantEntry>,
+    /// Round-level permission policy applied to every contestant.
+    #[serde(default = "default_permission_mode")]
+    pub permission_mode: String,
+    /// Bare mode: contestants are instructed to use no skills at all.
+    #[serde(default)]
+    pub bare_mode: bool,
+    /// Uniform reasoning-effort request applied to every contestant.
+    #[serde(default = "default_effort")]
+    pub effort: String,
+    /// Optional judge agent — after all contestants finish, this agent reads
+    /// every diff and produces a structured verdict. Stored in config (not a
+    /// separate column) because it is round-level input, set at creation time.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub judge_agent: Option<String>,
+    /// Optional custom judge evaluation dimensions. Each entry is a free-form
+    /// line that replaces the default 4 (Correctness / Code quality /
+    /// Completeness / Efficiency). Empty or absent = use the defaults.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub judge_dimensions: Vec<String>,
+    /// The git ref each contestant worktree is branched from. Absent or null
+    /// = current HEAD (the default, "from now"). When the launcher picks a
+    /// commit X as the task source, this is set to `X^` so the worktree starts
+    /// one commit BEFORE X — contestants never see X's changes, only its
+    /// message as the task description. Physical isolation, not a prompt
+    /// instruction the agent can ignore.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub base_commit: Option<String>,
+}
+
+fn default_permission_mode() -> String {
+    "default".into()
+}
+
+fn default_effort() -> String {
+    "default".into()
+}
+
+/// A PK round summary as returned to the frontend. Carries the round's own
+/// fields plus the live contestant status (computed from the linked
+/// conversations, not stored on the round row itself).
+#[derive(Debug, Clone, Serialize)]
+pub struct PkRoundInfo {
+    pub id: i32,
+    pub folder_id: i32,
+    pub task: String,
+    pub config: PkRoundConfig,
+    pub status: String,
+    pub failure_reason: Option<String>,
+    /// JSON-serialized judge verdict, or null if no judge / not yet run.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub judge_result: Option<serde_json::Value>,
+    /// idle | running | done | error | skipped
+    pub judge_status: String,
+    pub created_at: chrono::DateTime<chrono::Utc>,
+    pub updated_at: chrono::DateTime<chrono::Utc>,
+    pub finished_at: Option<chrono::DateTime<chrono::Utc>>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::PkContestantEntry;
+
+    #[test]
+    fn contestant_entry_keeps_legacy_formats_compatible() {
+        let simple: PkContestantEntry = serde_json::from_str(r#""codex""#).unwrap();
+        assert_eq!(simple.agent(), "codex");
+        assert_eq!(simple.label(), None);
+
+        let labeled: PkContestantEntry =
+            serde_json::from_str(r#"{"agent":"claude_code","label":"Sonnet"}"#).unwrap();
+        assert_eq!(labeled.agent(), "claude_code");
+        assert_eq!(labeled.label(), Some("Sonnet"));
+    }
+
+    #[test]
+    fn contestant_entry_round_trips_pinned_config_values() {
+        let entry: PkContestantEntry = serde_json::from_str(
+            r#"{"agent":"claude_code","label":"Opus","config_values":{"model":"opus"}}"#,
+        )
+        .unwrap();
+        let json = serde_json::to_value(entry).unwrap();
+        assert_eq!(json["agent"], "claude_code");
+        assert_eq!(json["label"], "Opus");
+        assert_eq!(json["config_values"]["model"], "opus");
+    }
+}
diff --git a/src-tauri/src/web/handlers/conversations.rs b/src-tauri/src/web/handlers/conversations.rs
index a46a20fc1..a03a70a6d 100644
--- a/src-tauri/src/web/handlers/conversations.rs
+++ b/src-tauri/src/web/handlers/conversations.rs
@@ -270,6 +270,32 @@ pub async fn create_conversation(
     Ok(Json(result))
 }
 
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreatePkConversationParams {
+    pub folder_id: i32,
+    pub agent_type: AgentType,
+    pub title: Option<String>,
+    pub pk_round_id: i32,
+}
+
+pub async fn create_pk_conversation(
+    Extension(state): Extension<Arc<AppState>>,
+    Json(params): Json<CreatePkConversationParams>,
+) -> Result<Json<i32>, AppCommandError> {
+    let db = &state.db;
+    let result = conv_commands::create_pk_conversation_core(
+        &db.conn,
+        params.folder_id,
+        params.agent_type,
+        params.title,
+        params.pk_round_id,
+    )
+    .await?;
+    conv_commands::emit_conversation_upsert(&state.emitter, &db.conn, result).await;
+    Ok(Json(result))
+}
+
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CreateChatConversationParams {
diff --git a/src-tauri/src/web/handlers/mod.rs b/src-tauri/src/web/handlers/mod.rs
index 97b7d86f9..5530c9605 100644
--- a/src-tauri/src/web/handlers/mod.rs
+++ b/src-tauri/src/web/handlers/mod.rs
@@ -24,6 +24,7 @@ pub mod model_provider;
 pub mod office_tools;
 pub mod office_watch_proxy;
 pub mod pet;
+pub mod pk;
 pub mod project_boot;
 pub mod question;
 pub mod quick_messages;
diff --git a/src-tauri/src/web/handlers/pk.rs b/src-tauri/src/web/handlers/pk.rs
new file mode 100644
index 000000000..23620b76a
--- /dev/null
+++ b/src-tauri/src/web/handlers/pk.rs
@@ -0,0 +1,135 @@
+use std::sync::Arc;
+
+use axum::{extract::Extension, Json};
+use serde::Deserialize;
+
+use crate::app_error::AppCommandError;
+use crate::app_state::AppState;
+use crate::commands::pk as core;
+use crate::models::PkRoundConfig;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ListParams {
+    #[serde(default)]
+    pub folder_id: Option<i32>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct IdParams {
+    pub id: i32,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreateParams {
+    pub folder_id: i32,
+    pub task: String,
+    pub config: PkRoundConfig,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UpdateStatusParams {
+    pub id: i32,
+    pub status: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UpdateJudgeParams {
+    pub id: i32,
+    pub judge_result: Option<String>,
+    pub judge_status: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SaveReportSnapshotParams {
+    pub id: i32,
+    pub snapshot: String,
+}
+
+pub async fn pk_round_list(
+    Extension(state): Extension<Arc<AppState>>,
+    Json(params): Json<ListParams>,
+) -> Result<Json<Vec<crate::models::PkRoundInfo>>, AppCommandError> {
+    let result = core::pk_round_list_core(&state.db, params.folder_id)
+        .await
+        .map_err(AppCommandError::from)?;
+    Ok(Json(result))
+}
+
+pub async fn pk_round_get(
+    Extension(state): Extension<Arc<AppState>>,
+    Json(params): Json<IdParams>,
+) -> Result<Json<crate::models::PkRoundInfo>, AppCommandError> {
+    let result = core::pk_round_get_core(&state.db, params.id)
+        .await
+        .map_err(AppCommandError::from)?;
+    Ok(Json(result))
+}
+
+pub async fn pk_round_create(
+    Extension(state): Extension<Arc<AppState>>,
+    Json(params): Json<CreateParams>,
+) -> Result<Json<crate::models::PkRoundInfo>, AppCommandError> {
+    let result =
+        core::pk_round_create_core(&state.db, params.folder_id, params.task, params.config)
+            .await
+            .map_err(AppCommandError::from)?;
+    Ok(Json(result))
+}
+
+pub async fn pk_round_update_status(
+    Extension(state): Extension<Arc<AppState>>,
+    Json(params): Json<UpdateStatusParams>,
+) -> Result<Json<()>, AppCommandError> {
+    core::pk_round_update_status_core(&state.db, params.id, params.status)
+        .await
+        .map_err(AppCommandError::from)?;
+    Ok(Json(()))
+}
+
+pub async fn pk_round_delete(
+    Extension(state): Extension<Arc<AppState>>,
+    Json(params): Json<IdParams>,
+) -> Result<Json<()>, AppCommandError> {
+    core::pk_round_archive_core(&state.db, &state.data_dir, params.id)
+        .await
+        .map_err(AppCommandError::from)?;
+    Ok(Json(()))
+}
+
+pub async fn pk_round_update_judge(
+    Extension(state): Extension<Arc<AppState>>,
+    Json(params): Json<UpdateJudgeParams>,
+) -> Result<Json<()>, AppCommandError> {
+    core::pk_round_update_judge_core(
+        &state.db,
+        params.id,
+        params.judge_result,
+        params.judge_status,
+    )
+    .await
+    .map_err(AppCommandError::from)?;
+    Ok(Json(()))
+}
+
+pub async fn pk_round_save_report_snapshot(
+    Extension(state): Extension<Arc<AppState>>,
+    Json(params): Json<SaveReportSnapshotParams>,
+) -> Result<Json<()>, AppCommandError> {
+    core::pk_round_save_report_snapshot_core(&state.data_dir, params.id, params.snapshot).await?;
+    Ok(Json(()))
+}
+
+pub async fn pk_round_get_report_snapshot(
+    Extension(state): Extension<Arc<AppState>>,
+    Json(params): Json<IdParams>,
+) -> Result<Json<Option<String>>, AppCommandError> {
+    Ok(Json(
+        core::pk_round_get_report_snapshot_core(&state.data_dir, params.id).await?,
+    ))
+}
diff --git a/src-tauri/src/web/router.rs b/src-tauri/src/web/router.rs
index 3d420b0ed..92e83fb81 100644
--- a/src-tauri/src/web/router.rs
+++ b/src-tauri/src/web/router.rs
@@ -139,6 +139,10 @@ pub fn build_router(
             "/create_conversation",
             post(handlers::conversations::create_conversation),
         )
+        .route(
+            "/create_pk_conversation",
+            post(handlers::conversations::create_pk_conversation),
+        )
         .route(
             "/create_chat_conversation",
             post(handlers::conversations::create_chat_conversation),
@@ -1425,6 +1429,28 @@ pub fn build_router(
             "/work_task_template_delete",
             post(handlers::work_task::work_task_template_delete),
         )
+        // ─── PK arena rounds ───
+        .route("/pk_round_list", post(handlers::pk::pk_round_list))
+        .route("/pk_round_get", post(handlers::pk::pk_round_get))
+        .route("/pk_round_create", post(handlers::pk::pk_round_create))
+        .route(
+            "/pk_round_update_status",
+            post(handlers::pk::pk_round_update_status),
+        )
+        .route("/pk_round_delete", post(handlers::pk::pk_round_delete))
+        .route(
+            "/pk_round_update_judge",
+            post(handlers::pk::pk_round_update_judge),
+        )
+        .route(
+            "/pk_round_save_report_snapshot",
+            post(handlers::pk::pk_round_save_report_snapshot)
+                .layer(DefaultBodyLimit::max(64 * 1024 * 1024)),
+        )
+        .route(
+            "/pk_round_get_report_snapshot",
+            post(handlers::pk::pk_round_get_report_snapshot),
+        )
         // ─── Workspace background ───
         .route(
             "/background_read",
diff --git a/src-tauri/tests/delegation_columns.rs b/src-tauri/tests/delegation_columns.rs
index 07639e886..031b9e559 100644
--- a/src-tauri/tests/delegation_columns.rs
+++ b/src-tauri/tests/delegation_columns.rs
@@ -38,6 +38,7 @@ async fn delegation_columns_round_trip() {
         deleted_at: Set(None),
         pinned_at: Set(None),
         origin_cwd: Set(None),
+        pk_round_id: Set(None),
     };
     let inserted = active.insert(&db.conn).await.expect("insert");
     let id = inserted.id;
diff --git a/src/app/layout.tsx b/src/app/layout.tsx
index 852464b20..7d802fa1c 100644
--- a/src/app/layout.tsx
+++ b/src/app/layout.tsx
@@ -13,6 +13,7 @@ import { OverlayScrollbarsInit } from "@/components/overlay-scrollbars-init"
 import { ClipboardFallbackInit } from "@/components/clipboard-fallback-init"
 import { WebConnectionGuard } from "@/components/connection/web-connection-guard"
 import { WindowResizeGrips } from "@/components/layout/window-resize-grips"
+import { ChunkLoadRecovery } from "@/components/chunk-load-recovery"
 
 export const viewport: Viewport = {
   width: "device-width",
@@ -69,6 +70,7 @@ export default async function RootLayout({
               disableTransitionOnChange
             >
               <AppearanceProvider>
+                <ChunkLoadRecovery />
                 <OverlayScrollbarsInit />
                 <ClipboardFallbackInit />
                 <WebConnectionGuard />
diff --git a/src/app/workspace/page.tsx b/src/app/workspace/page.tsx
index 1e3a6232a..4cf1227a4 100644
--- a/src/app/workspace/page.tsx
+++ b/src/app/workspace/page.tsx
@@ -1,7 +1,35 @@
 "use client"
 
+import { useEffect, useRef } from "react"
 import { ConversationDetailPanel } from "@/components/conversations/conversation-detail-panel"
+import { PkArenaHost } from "@/components/pk/pk-arena-host"
+import { usePkArenaStore } from "@/stores/pk-arena-store"
+import { useTabActions } from "@/stores/tab-store"
 
 export default function WorkspacePage() {
-  return <ConversationDetailPanel />
+  const rounds = usePkArenaStore((s) => s.rounds)
+  const hydrating = usePkArenaStore((s) => s.hydrating)
+  const { openPkRoundTab } = useTabActions()
+  const openedRoundRef = useRef<string | null>(null)
+
+  useEffect(() => {
+    if (hydrating || typeof window === "undefined") return
+    const roundId = new URLSearchParams(window.location.search).get("pkRoundId")
+    if (!roundId || openedRoundRef.current === roundId) return
+    const round = rounds.find((item) => item.id === roundId)
+    if (!round) return
+    openedRoundRef.current = roundId
+    usePkArenaStore.getState().setActiveRound(round.id)
+    openPkRoundTab(round.id, round.folderId, round.task)
+  }, [hydrating, openPkRoundTab, rounds])
+
+  return (
+    <>
+      <ConversationDetailPanel />
+      {/* Inside the workspace layout's AcpConnectionsProvider — the arena
+          orchestrator needs the connection actions and the acp://event
+          subscription. */}
+      <PkArenaHost />
+    </>
+  )
 }
diff --git a/src/components/ai-elements/reasoning.tsx b/src/components/ai-elements/reasoning.tsx
index 5e9948e17..b06e645c5 100644
--- a/src/components/ai-elements/reasoning.tsx
+++ b/src/components/ai-elements/reasoning.tsx
@@ -24,7 +24,13 @@ import {
 import { Streamdown, defaultRemarkPlugins } from "streamdown"
 
 import { Shimmer } from "./shimmer"
+import type { Components } from "streamdown"
 import { markdownLinkComponents } from "./markdown-link"
+
+/** `<p>` → `<div>`: keeps paragraph spacing without the nesting violation. */
+function ReasoningParagraphSafe({ children }: { children: ReactNode }) {
+  return <div className="py-0.5">{children}</div>
+}
 import { normalizeMathDelimiters } from "./message"
 import { remarkTrimCjkAutolinkTail } from "./remark-cjk-autolink-tail"
 import { remarkRewriteFileUriLinks } from "./remark-file-uri-links"
@@ -257,8 +263,15 @@ export const ReasoningContent = memo(
           plugins={plugins}
           remarkPlugins={remarkPlugins}
           {...props}
-          // Enforce the link icon + safety override after spreading props.
-          components={markdownLinkComponents}
+          // Enforce the link icon + safety override after spreading props,
+          // and render paragraphs as <div>: reasoning text frequently
+          // embeds raw HTML/SVG, and Streamdown's default <p> for the
+          // wrapper plus a nested element rendered as <p> trips React's
+          // nested-paragraph hydration error.
+          components={{
+            ...markdownLinkComponents,
+            p: ReasoningParagraphSafe as Components["p"],
+          }}
         >
           {normalized}
         </Streamdown>
diff --git a/src/components/chat/composer/composer-add-menu.tsx b/src/components/chat/composer/composer-add-menu.tsx
index 4c51a8a5a..8c5110a75 100644
--- a/src/components/chat/composer/composer-add-menu.tsx
+++ b/src/components/chat/composer/composer-add-menu.tsx
@@ -14,6 +14,7 @@ import {
   Plus,
   Search,
   Sparkles,
+  Swords,
   Upload,
 } from "lucide-react"
 
@@ -31,6 +32,8 @@ import { DropdownRadioItemContent } from "@/components/chat/dropdown-radio-item-
 import { rankByTextMatch } from "@/lib/fuzzy-text-match"
 import { isImeCompositionKey } from "@/lib/ime-composition"
 import { cn } from "@/lib/utils"
+import { usePkArenaStore } from "@/stores/pk-arena-store"
+import { useTabStore } from "@/stores/tab-store"
 import type { AvailableCommandInfo } from "@/lib/types"
 
 import { commandInvocationToken } from "@/components/chat/composer/invocation-reference"
@@ -396,6 +399,29 @@ export function ComposerAddMenu({
             </DropdownMenuSub>
           </>
         )}
+        <DropdownMenuItem
+          onClick={() => {
+            const state = usePkArenaStore.getState()
+            // With history to revisit, the menu reopens the ARENA directly
+            // (the dialog otherwise has no way back after it closes);
+            // "新一局" inside the arena opens the launcher.
+            if (state.rounds.length > 0 && state.activeRoundId) {
+              const round = state.rounds.find(
+                (item) => item.id === state.activeRoundId
+              )
+              if (round) {
+                useTabStore
+                  .getState()
+                  .openPkRoundTab(round.id, round.folderId, round.task)
+              }
+            } else {
+              state.setLauncherOpen(true)
+            }
+          }}
+        >
+          <Swords className="size-4" />
+          {t("startPk")}
+        </DropdownMenuItem>
       </DropdownMenuContent>
     </DropdownMenu>
   )
diff --git a/src/components/chat/conversation-context-bar.test.tsx b/src/components/chat/conversation-context-bar.test.tsx
index 2c0b5c84a..469a8c9ac 100644
--- a/src/components/chat/conversation-context-bar.test.tsx
+++ b/src/components/chat/conversation-context-bar.test.tsx
@@ -28,6 +28,7 @@ vi.mock("sonner", () => ({
 // branches) is seeded into the real zustand store in beforeEach.
 let tabs: Array<{
   id: string
+  kind: "conversation"
   folderId: number
   conversationId: number | null
   isChat?: boolean
@@ -93,7 +94,14 @@ describe("ConversationHeaderFolderPicker", () => {
       folders: [repo, other],
       allFolders: [repo, other],
     })
-    tabs = [{ id: "tab-draft", folderId: 1, conversationId: null }]
+    tabs = [
+      {
+        id: "tab-draft",
+        kind: "conversation",
+        folderId: 1,
+        conversationId: null,
+      },
+    ]
     activeTabId = "tab-draft"
 
     const user = userEvent.setup()
@@ -111,7 +119,14 @@ describe("ConversationHeaderFolderPicker", () => {
       folders: [repo, other],
       allFolders: [repo, other],
     })
-    tabs = [{ id: "tab-1", folderId: 1, conversationId: 42 }]
+    tabs = [
+      {
+        id: "tab-1",
+        kind: "conversation",
+        folderId: 1,
+        conversationId: 42,
+      },
+    ]
     activeTabId = "tab-1"
 
     const user = userEvent.setup()
@@ -125,7 +140,13 @@ describe("ConversationHeaderFolderPicker", () => {
 
   it("shows the chat-mode label for a folderless chat tab", () => {
     tabs = [
-      { id: "tab-chat", folderId: 999, conversationId: null, isChat: true },
+      {
+        id: "tab-chat",
+        kind: "conversation",
+        folderId: 999,
+        conversationId: null,
+        isChat: true,
+      },
     ]
     activeTabId = "tab-chat"
 
diff --git a/src/components/chat/conversation-context-bar.tsx b/src/components/chat/conversation-context-bar.tsx
index e9d11424b..98a8dbf20 100644
--- a/src/components/chat/conversation-context-bar.tsx
+++ b/src/components/chat/conversation-context-bar.tsx
@@ -7,6 +7,7 @@ import { Check, ChevronDown, Folder, MessageSquare } from "lucide-react"
 import type { OverlayScrollbarsComponentRef } from "overlayscrollbars-react"
 import { useAppWorkspaceStore } from "@/stores/app-workspace-store"
 import { useTabActions, useTabStore } from "@/contexts/tab-context"
+import { isConversationWorkspaceTab } from "@/lib/workspace-tab"
 import { Button } from "@/components/ui/button"
 import {
   Popover,
@@ -125,7 +126,8 @@ export const ConversationHeaderFolderPicker = memo(
 
     const ownTab = useMemo(() => {
       const lookupId = tabId ?? activeTabId
-      return tabs.find((x) => x.id === lookupId) ?? null
+      const tab = tabs.find((x) => x.id === lookupId)
+      return tab && isConversationWorkspaceTab(tab) ? tab : null
     }, [tabs, tabId, activeTabId])
 
     const ownFolder = useMemo(
@@ -250,7 +252,8 @@ export const ConversationFolderBranchPicker = memo(
 
     const ownTab = useMemo(() => {
       const lookupId = tabId ?? activeTabId
-      return tabs.find((x) => x.id === lookupId) ?? null
+      const tab = tabs.find((x) => x.id === lookupId)
+      return tab && isConversationWorkspaceTab(tab) ? tab : null
     }, [tabs, tabId, activeTabId])
 
     const ownFolder = useMemo(
@@ -369,7 +372,9 @@ export function useConversationFolderBranchPickerVisible(
   const activeTabId = useTabStore((s) => s.activeTabId)
   const allFolders = useAppWorkspaceStore((s) => s.allFolders)
   const lookupId = tabId ?? activeTabId
-  const ownTab = tabs.find((x) => x.id === lookupId) ?? null
+  const matchedTab = tabs.find((x) => x.id === lookupId)
+  const ownTab =
+    matchedTab && isConversationWorkspaceTab(matchedTab) ? matchedTab : null
   const ownFolder = ownTab
     ? (allFolders.find((f) => f.id === ownTab.folderId) ?? null)
     : null
diff --git a/src/components/chunk-load-recovery.test.tsx b/src/components/chunk-load-recovery.test.tsx
new file mode 100644
index 000000000..5bf1e437f
--- /dev/null
+++ b/src/components/chunk-load-recovery.test.tsx
@@ -0,0 +1,36 @@
+import { render } from "@testing-library/react"
+import { afterEach, describe, expect, it, vi } from "vitest"
+import { ChunkLoadRecovery, isChunkLoadError } from "./chunk-load-recovery"
+
+afterEach(() => {
+  window.sessionStorage.clear()
+})
+
+describe("ChunkLoadRecovery", () => {
+  it("recognizes async chunk failures without matching unrelated errors", () => {
+    expect(
+      isChunkLoadError(
+        new Error(
+          "Failed to load chunk http://localhost:3000/_next/static/chunks/opener.js"
+        )
+      )
+    ).toBe(true)
+    expect(isChunkLoadError(new Error("Permission denied"))).toBe(false)
+  })
+
+  it("reloads once when a lazy chunk is stale", () => {
+    const reloadPage = vi.fn()
+    render(<ChunkLoadRecovery reloadPage={reloadPage} />)
+
+    const rejection = new Event("unhandledrejection")
+    Object.defineProperty(rejection, "reason", {
+      value: Object.assign(new Error("Failed to load chunk /opener.js"), {
+        name: "ChunkLoadError",
+      }),
+    })
+    window.dispatchEvent(rejection)
+    window.dispatchEvent(rejection)
+
+    expect(reloadPage).toHaveBeenCalledTimes(1)
+  })
+})
diff --git a/src/components/chunk-load-recovery.tsx b/src/components/chunk-load-recovery.tsx
new file mode 100644
index 000000000..a5721ed73
--- /dev/null
+++ b/src/components/chunk-load-recovery.tsx
@@ -0,0 +1,86 @@
+"use client"
+
+import { useEffect, useRef } from "react"
+
+const RECOVERY_MARKER = "codeg:chunk-load-recovery"
+const HEALTHY_WINDOW_MS = 10_000
+const CHUNK_LOAD_PATTERN =
+  /chunkloaderror|failed to load chunk|loading chunk .+ failed|failed to fetch dynamically imported module|importing a module script failed/i
+
+function errorText(value: unknown): string {
+  if (typeof value === "string") return value
+  if (value == null || typeof value !== "object") return ""
+  const record = value as { name?: unknown; message?: unknown }
+  return [record.name, record.message]
+    .filter((part): part is string => typeof part === "string")
+    .join(": ")
+}
+
+export function isChunkLoadError(value: unknown): boolean {
+  return CHUNK_LOAD_PATTERN.test(errorText(value))
+}
+
+function reloadWindow(): void {
+  window.location.reload()
+}
+
+/**
+ * Recover from a stale Next.js runtime after a deploy or dev-server rebuild.
+ * Lazy chunks surface only when their feature is first used (for example,
+ * opening a generated file), so the initial page can look healthy while its
+ * chunk graph is already invalid. One guarded reload obtains a coherent graph;
+ * sessionStorage prevents a broken deployment from entering a reload loop.
+ */
+export function ChunkLoadRecovery({
+  reloadPage = reloadWindow,
+}: {
+  reloadPage?: () => void
+}) {
+  const attemptedRef = useRef(false)
+
+  useEffect(() => {
+    const pageKey = `${window.location.pathname}${window.location.search}`
+
+    const recover = (reason: unknown) => {
+      if (attemptedRef.current || !isChunkLoadError(reason)) return
+
+      try {
+        if (window.sessionStorage.getItem(RECOVERY_MARKER) === pageKey) return
+        window.sessionStorage.setItem(RECOVERY_MARKER, pageKey)
+      } catch {
+        // A local in-memory guard still prevents repeated reload attempts in
+        // this document when storage is unavailable.
+      }
+
+      attemptedRef.current = true
+      reloadPage()
+    }
+
+    const onError = (event: ErrorEvent) => {
+      recover(event.error ?? event.message)
+    }
+    const onUnhandledRejection = (event: PromiseRejectionEvent) => {
+      recover(event.reason)
+    }
+
+    window.addEventListener("error", onError)
+    window.addEventListener("unhandledrejection", onUnhandledRejection)
+    const healthyTimer = window.setTimeout(() => {
+      try {
+        if (window.sessionStorage.getItem(RECOVERY_MARKER) === pageKey) {
+          window.sessionStorage.removeItem(RECOVERY_MARKER)
+        }
+      } catch {
+        // Storage is optional; there is nothing to clear when it is blocked.
+      }
+    }, HEALTHY_WINDOW_MS)
+
+    return () => {
+      window.removeEventListener("error", onError)
+      window.removeEventListener("unhandledrejection", onUnhandledRejection)
+      window.clearTimeout(healthyTimer)
+    }
+  }, [reloadPage])
+
+  return null
+}
diff --git a/src/components/conversations/conversation-detail-panel-layout.test.ts b/src/components/conversations/conversation-detail-panel-layout.test.ts
index f55ee8700..6bb7748bf 100644
--- a/src/components/conversations/conversation-detail-panel-layout.test.ts
+++ b/src/components/conversations/conversation-detail-panel-layout.test.ts
@@ -284,10 +284,12 @@ describe("ConversationDetailPanel split-group render model", () => {
   it("pairs every split group with its own title bar and gates the global one", () => {
     const shellStart = source.indexOf("const renderGroupShell = (groupId")
     const shellBody = source.slice(shellStart, shellStart + 6000)
-    expect(shellBody).toContain("{isSplit && selTab && (")
+    expect(shellBody).toContain("{isSplit && selConversationTab && (")
     expect(shellBody).toContain("<ConversationDetailHeader")
-    expect(shellBody).toContain("tabId={selTab.id}")
-    expect(source).toContain("{!isSplit && activeTab && (")
+    expect(shellBody).toContain("tabId={selConversationTab.id}")
+    expect(source).toContain(
+      "{!isSplit && activeTab && isConversationWorkspaceTab(activeTab) && ("
+    )
   })
 
   // While split the workspace layout drops its title-bar strip row ENTIRELY —
diff --git a/src/components/conversations/conversation-detail-panel.tsx b/src/components/conversations/conversation-detail-panel.tsx
index 64645c1a6..426a8ef5a 100644
--- a/src/components/conversations/conversation-detail-panel.tsx
+++ b/src/components/conversations/conversation-detail-panel.tsx
@@ -26,6 +26,8 @@ import { useActiveFolder } from "@/contexts/active-folder-context"
 import { useAppWorkspaceStore } from "@/stores/app-workspace-store"
 import { useTabActions, useTabStore } from "@/contexts/tab-context"
 import { groupOfTab, isReparentUnmount } from "@/stores/tab-store"
+import { isConversationWorkspaceTab } from "@/lib/workspace-tab"
+import { PkArenaView } from "@/components/pk/pk-arena-view"
 import { computeRects, leafIds } from "@/lib/tab-group-layout"
 import { useTaskContext } from "@/contexts/task-context"
 import { cn, randomUUID } from "@/lib/utils"
@@ -252,9 +254,10 @@ const ConversationTabView = memo(function ConversationTabView({
   // `tabs` array — so a sibling tab changing, or a tab-switch (isActive rides in
   // as a prop), never re-renders this keep-alive panel. `find` returns the same
   // object reference across derives until this tab itself changes.
-  const ownTab = useTabStore(
-    (s) => s.tabs.find((tab) => tab.id === tabId) ?? null
-  )
+  const ownTab = useTabStore((s) => {
+    const tab = s.tabs.find((item) => item.id === tabId)
+    return tab && isConversationWorkspaceTab(tab) ? tab : null
+  })
   // Resolve this panel's folder from ITS OWN tab, not the global active folder.
   // A keep-alive panel for a background tab must NOT re-render when the active
   // tab switches to a different folder. For the active tab this equals the old
@@ -2228,7 +2231,8 @@ export function ConversationDetailPanel() {
   } = useTabActions()
   const newConversation = useMemo(() => {
     const activeTab = tabs.find((tab) => tab.id === activeTabId)
-    if (!activeTab || activeTab.conversationId != null) return null
+    if (!activeTab || !isConversationWorkspaceTab(activeTab)) return null
+    if (activeTab.conversationId != null) return null
     const workingDir = activeTab.workingDir ?? folder?.path
     if (!workingDir) return null
     return { workingDir, folderId: activeTab.folderId }
@@ -2294,9 +2298,10 @@ export function ConversationDetailPanel() {
         const dbId2 = summary?.id
         const isOpenInTabs = tabs.some(
           (tab) =>
-            tab.conversationId === matchedConversationId ||
-            tab.runtimeConversationId === matchedConversationId ||
-            (dbId2 != null && tab.conversationId === dbId2)
+            isConversationWorkspaceTab(tab) &&
+            (tab.conversationId === matchedConversationId ||
+              tab.runtimeConversationId === matchedConversationId ||
+              (dbId2 != null && tab.conversationId === dbId2))
         )
         if (isOpenInTabs) return
 
@@ -2315,13 +2320,12 @@ export function ConversationDetailPanel() {
   )
 
   const hasNoTabs = tabs.length === 0 && !activeTabId
-  const activeConversationTab = useMemo(
-    () =>
-      tabs.find(
-        (tab) => tab.id === activeTabId && tab.conversationId != null
-      ) ?? null,
-    [tabs, activeTabId]
-  )
+  const activeConversationTab = useMemo(() => {
+    const tab = tabs.find((item) => item.id === activeTabId)
+    return tab && isConversationWorkspaceTab(tab) && tab.conversationId != null
+      ? tab
+      : null
+  }, [tabs, activeTabId])
   const canReloadActiveConversation = activeConversationTab != null
   const handleReloadActiveConversation = useCallback(() => {
     if (!activeConversationTab) return
@@ -2547,18 +2551,21 @@ export function ConversationDetailPanel() {
     // Visible = tiled (all group members shown) or the group's selected tab.
     const visible = canTileG || tab.id === groupSelection[groupId]
     const folderPath = allFolders.find((f) => f.id === tab.folderId)?.path
-    const view = (
-      <ConversationTabView
-        tabId={tab.id}
-        conversationId={tab.conversationId}
-        agentType={tab.agentType}
-        workingDir={tab.workingDir ?? folderPath}
-        isActive={active}
-        showActiveFlow={(isSplit || canTileG) && active}
-        reloadSignal={reloadByTabId[tab.id] ?? 0}
-        groupId={groupId}
-      />
-    )
+    const view =
+      tab.kind === "pk" ? (
+        <PkArenaView roundId={tab.roundId} tabId={tab.id} />
+      ) : (
+        <ConversationTabView
+          tabId={tab.id}
+          conversationId={tab.conversationId}
+          agentType={tab.agentType}
+          workingDir={tab.workingDir ?? folderPath}
+          isActive={active}
+          showActiveFlow={(isSplit || canTileG) && active}
+          reloadSignal={reloadByTabId[tab.id] ?? 0}
+          groupId={groupId}
+        />
+      )
     return (
       <div
         key={tab.id}
@@ -2621,8 +2628,10 @@ export function ConversationDetailPanel() {
       groupTabs.find((tab) => tab.id === groupSelection[groupId]) ??
       groupTabs[0] ??
       null
-    const selTabFolder = selTab
-      ? allFolders.find((f) => f.id === selTab.folderId)
+    const selConversationTab =
+      selTab && isConversationWorkspaceTab(selTab) ? selTab : null
+    const selTabFolder = selConversationTab
+      ? allFolders.find((f) => f.id === selConversationTab.folderId)
       : undefined
     // NOTE: the strip / header / content stay PLAIN SIBLING SLOTS (no fragment
     // around any pair) — a `false` conditional is a reconciliation hole, so the
@@ -2650,7 +2659,7 @@ export function ConversationDetailPanel() {
             {touchesRight && <SplitStripCornerReserve side="right" />}
           </div>
         )}
-        {isSplit && selTab && (
+        {isSplit && selConversationTab && (
           <div
             className="shrink-0"
             // Clicking a non-focused group's title bar focuses that group
@@ -2664,13 +2673,17 @@ export function ConversationDetailPanel() {
             }}
           >
             <ConversationDetailHeader
-              tabId={selTab.id}
-              conversationId={selTab.conversationId}
-              runtimeConversationId={selTab.runtimeConversationId ?? null}
-              folderId={selTab.folderId}
+              tabId={selConversationTab.id}
+              conversationId={selConversationTab.conversationId}
+              runtimeConversationId={
+                selConversationTab.runtimeConversationId ?? null
+              }
+              folderId={selConversationTab.folderId}
               folderPath={selTabFolder?.path}
-              title={selTab.title}
-              status={selTab.status as ConversationStatus | undefined}
+              title={selConversationTab.title}
+              status={
+                selConversationTab.status as ConversationStatus | undefined
+              }
             />
           </div>
         )}
@@ -2710,7 +2723,7 @@ export function ConversationDetailPanel() {
   return (
     <>
       <div className="flex h-full min-h-0 flex-col overflow-hidden">
-        {!isSplit && activeTab && (
+        {!isSplit && activeTab && isConversationWorkspaceTab(activeTab) && (
           <ConversationDetailHeader
             tabId={activeTab.id}
             conversationId={activeTab.conversationId}
diff --git a/src/components/conversations/group-shell-reconciliation.test.tsx b/src/components/conversations/group-shell-reconciliation.test.tsx
index a964fa09f..1b6f52cfd 100644
--- a/src/components/conversations/group-shell-reconciliation.test.tsx
+++ b/src/components/conversations/group-shell-reconciliation.test.tsx
@@ -139,7 +139,7 @@ describe("split group shell source shape", () => {
     expect(shellStart).toBeGreaterThan(-1)
     const shellBody = source.slice(shellStart, shellStart + 6000)
     const stripIdx = shellBody.indexOf("{isSplit && (")
-    const headerIdx = shellBody.indexOf("{isSplit && selTab && (")
+    const headerIdx = shellBody.indexOf("{isSplit && selConversationTab && (")
     const contentIdx = shellBody.indexOf(
       '<div className="relative min-h-0 flex-1 overflow-hidden">'
     )
diff --git a/src/components/conversations/sidebar-conversation-grouping.ts b/src/components/conversations/sidebar-conversation-grouping.ts
index 18882b924..78dc8650f 100644
--- a/src/components/conversations/sidebar-conversation-grouping.ts
+++ b/src/components/conversations/sidebar-conversation-grouping.ts
@@ -262,6 +262,54 @@ export function selectChatConversationsWithReuse(
   return arraysShallowEqual(prev, next) ? prev : next
 }
 
+/**
+ * Select PK-arena contestant conversations (`kind === "pk"`), grouped by their
+ * `pk_round_id`. Returns a Map keyed by round id → conversations (newest-first
+ * within each round). Excludes pinned conversations (they surface in the
+ * Pinned section). `prev` is the Map returned last call for reference reuse.
+ *
+ * Each round's conversations are sorted newest-first; the rounds themselves are
+ * ordered by their newest conversation's `updated_at` (hottest round first) so
+ * the active PK sits at the top.
+ */
+export function selectPkConversationsWithReuse(
+  conversations: readonly DbConversationSummary[],
+  prev: Map<number, DbConversationSummary[]>
+): Map<number, DbConversationSummary[]> {
+  const grouped = new Map<number, DbConversationSummary[]>()
+  for (const conv of conversations) {
+    if (conv.pinned_at != null) continue
+    if (conv.kind !== "pk") continue
+    const rid = conv.pk_round_id
+    if (rid == null) continue
+    const bucket = grouped.get(rid)
+    if (bucket) bucket.push(conv)
+    else grouped.set(rid, [conv])
+  }
+  // Sort conversations within each round newest-first.
+  for (const bucket of grouped.values()) {
+    bucket.sort(compareByUpdatedAtDesc)
+  }
+  // Sort rounds by hottest conversation (newest updated_at among their
+  // conversations) first.
+  const sortedEntries = [...grouped.entries()].sort((a, b) => {
+    const aMax = a[1][0]?.updated_at ?? ""
+    const bMax = b[1][0]?.updated_at ?? ""
+    return bMax.localeCompare(aMax)
+  })
+  const next = new Map(sortedEntries)
+  return mapsShallowEqual(prev, next) ? prev : next
+}
+
+/** Shallow-equal for Map<number, V[]> — same keys and same array refs. */
+function mapsShallowEqual<K, V>(a: Map<K, V[]>, b: Map<K, V[]>): boolean {
+  if (a.size !== b.size) return false
+  for (const [k, v] of a) {
+    if (b.get(k) !== v) return false
+  }
+  return true
+}
+
 /**
  * Select the flat "Recent" bucket: every conversation the sidebar can reach,
  * folder-bound and chat alike, newest first — the whole point of the section is
@@ -297,6 +345,7 @@ export function selectRecentConversationsWithReuse(
   for (const conv of conversations) {
     if (conv.pinned_at != null) continue
     if (!showCompleted && conv.status === "completed") continue
+    if (conv.kind === "pk") continue
     if (conv.kind !== "chat" && !openFolderIds.has(conv.folder_id)) continue
     next.push(conv)
   }
@@ -494,13 +543,33 @@ export interface RecentMoreRow {
 }
 
 /**
- * A collapsible section heading. Four exist: "pinned" (always on top, shown only
- * when there are pinned conversations) plus the three user-reorderable ones —
- * "folders" (wraps the whole folder list), "chats" (a flat list of folderless
- * chat-mode conversations), and "recent" (a flat, folder-agnostic list of the
- * newest conversations, shown only when the user keeps it enabled). All live in
- * the same flat row array so the single Virtualizer windows them like any other
- * row — there is no separate, un-virtualized list.
+ * A PK-arena round sub-group heading inside the "pk" section: shows the round's
+ * task summary and gates its contestant conversations. Follows the section
+ * header; each round is one collapsible group.
+ */
+export interface PkRoundHeaderRow {
+  kind: "pk-round"
+  roundId: number
+  /** Task preview (truncated for the header) — identifies the round. */
+  task: string
+  /** Number of contestant conversations in this round. */
+  count: number
+}
+
+/** Empty hint for the PK section (no PK arena conversations at all). */
+export interface PkEmptyRow {
+  kind: "pk-empty"
+}
+
+/**
+ * A collapsible section heading. Five exist: "pinned" and "pk" (always on top,
+ * shown only when conversations of that kind exist) plus the three
+ * user-reorderable ones — "folders" (wraps the whole folder list), "chats" (a
+ * flat list of folderless chat-mode conversations), and "recent" (a flat,
+ * folder-agnostic list of the newest conversations, shown only when the user
+ * keeps it enabled). All live in the same flat row array so the single
+ * Virtualizer windows them like any other row — there is no separate,
+ * un-virtualized list.
  */
 export interface SectionHeaderRow {
   kind: "section"
@@ -538,6 +607,8 @@ export type SidebarRow =
   | RecentEmptyRow
   | RecentMoreRow
   | SubsessionLoadingRow
+  | PkRoundHeaderRow
+  | PkEmptyRow
 
 const MAX_RENDER_DEPTH = 32
 
@@ -555,6 +626,9 @@ const EMPTY_CONTAINER_CHILDREN: ReadonlyMap<number, readonly number[]> =
 // the row output stays identical to the pre-Recent model for callers that don't
 // pass it.
 const EMPTY_CONVERSATIONS: readonly DbConversationSummary[] = []
+const EMPTY_PK_MAP: ReadonlyMap<number, readonly DbConversationSummary[]> =
+  new Map()
+const EMPTY_ROUND_TASKS: ReadonlyMap<number, string> = new Map()
 
 /**
  * Merge a freshly-fetched children snapshot with child summaries already applied
@@ -684,6 +758,16 @@ function pushConversationRow(
 export function buildRows(args: {
   pinned: readonly DbConversationSummary[]
   pinnedExpanded: boolean
+  /** PK-arena conversations grouped by round id (hottest round first). Empty
+   *  Map = no PK section. */
+  pkConversations?: Map<number, DbConversationSummary[]>
+  /** Whether the PK section's rows are shown. Optional — defaults to expanded. */
+  pkExpanded?: boolean
+  /** Round metadata for the PK section headers: id → task preview. Absent
+   *  entries fall back to a generic "Round N" label. */
+  pkRoundTasks?: ReadonlyMap<number, string>
+  /** Ids whose PK round sub-group is collapsed. Absent = expanded. */
+  pkRoundCollapsed?: ReadonlySet<number>
   orderedFolderIds: readonly number[]
   byFolder: Map<number, DbConversationSummary[]>
   folderExpanded: Record<number, boolean>
@@ -740,6 +824,10 @@ export function buildRows(args: {
   const {
     pinned,
     pinnedExpanded,
+    pkConversations = EMPTY_PK_MAP,
+    pkExpanded = true,
+    pkRoundTasks = EMPTY_ROUND_TASKS,
+    pkRoundCollapsed = EMPTY_EXPANDED,
     orderedFolderIds,
     byFolder,
     folderExpanded,
@@ -812,6 +900,41 @@ export function buildRows(args: {
     }
   }
 
+  const pushPk = () => {
+    if (pkConversations.size === 0) return
+    const totalConvs = [...pkConversations.values()].reduce(
+      (n, bucket) => n + bucket.length,
+      0
+    )
+    rows.push({
+      kind: "section",
+      section: "pk",
+      expanded: pkExpanded,
+      count: totalConvs,
+    })
+    if (!pkExpanded) return
+    for (const [roundId, convs] of pkConversations) {
+      const task = pkRoundTasks.get(roundId) ?? `Round #${roundId}`
+      rows.push({
+        kind: "pk-round",
+        roundId,
+        task,
+        count: convs.length,
+      })
+      if (pkRoundCollapsed.has(roundId)) continue
+      for (const conv of convs) {
+        pushConversationRow(
+          rows,
+          conv,
+          0,
+          conversationExpanded,
+          childrenByParent,
+          childrenLoading
+        )
+      }
+    }
+  }
+
   const pushFolders = () => {
     // The Folders section header is always present (a permanent entry point),
     // mirroring the Chat section — so a workspace with chats but no open folders
@@ -916,6 +1039,11 @@ export function buildRows(args: {
     if (remaining > 0) rows.push({ kind: "recent-more", remaining })
   }
 
+  // The PK section sits right below Pinned (above the reorderable sections).
+  // It is not part of `sectionOrder` — it is always-on-top like Pinned, shown
+  // only when PK arena conversations exist.
+  pushPk()
+
   // Normalized (not consumed raw) so a truncated / repeated / unknown-entry
   // order can never drop a section off the sidebar or emit one twice.
   for (const section of normalizeSectionOrder(sectionOrder)) {
diff --git a/src/components/conversations/sidebar-conversation-list.test.tsx b/src/components/conversations/sidebar-conversation-list.test.tsx
index 8b4ede4ef..ad041db3c 100644
--- a/src/components/conversations/sidebar-conversation-list.test.tsx
+++ b/src/components/conversations/sidebar-conversation-list.test.tsx
@@ -36,6 +36,7 @@ const store = vi.hoisted(() => ({
   activeTabId: null as string | null,
   tabSpec: [] as Array<{
     id: string
+    kind?: string
     conversationId: number | null
     agentType: string
     folderId: number
@@ -735,6 +736,7 @@ describe("SidebarConversationList — scrollToActive across a worktree merge", (
     store.activeTabId = "tab-21"
     store.tabSpec = [
       {
+        kind: "conversation",
         id: "tab-21",
         conversationId: 21,
         agentType: "claude_code",
diff --git a/src/components/conversations/sidebar-conversation-list.tsx b/src/components/conversations/sidebar-conversation-list.tsx
index 8aa06f888..de0d784f2 100644
--- a/src/components/conversations/sidebar-conversation-list.tsx
+++ b/src/components/conversations/sidebar-conversation-list.tsx
@@ -21,6 +21,7 @@ import {
   ChevronDown,
   ChevronRight,
   Download,
+  Archive,
   ExternalLink,
   FolderClosed,
   FolderGit2,
@@ -41,7 +42,9 @@ import {
 } from "lucide-react"
 import { useActiveFolder } from "@/contexts/active-folder-context"
 import { useAppWorkspaceStore } from "@/stores/app-workspace-store"
+import { usePkArenaStore } from "@/stores/pk-arena-store"
 import { useTabActions, useTabStore } from "@/contexts/tab-context"
+import { isConversationWorkspaceTab } from "@/lib/workspace-tab"
 import { useWorkbenchRoute } from "@/contexts/workbench-route-context"
 import { useTerminalContext } from "@/contexts/terminal-context"
 import { useThemeColor, useZoomLevel } from "@/hooks/use-appearance"
@@ -111,6 +114,7 @@ import {
   reuseSet,
   selectChatConversationsWithReuse,
   selectPinnedWithReuse,
+  selectPkConversationsWithReuse,
   selectRecentConversationsWithReuse,
   worktreeChildrenByParent,
   worktreeHeaderAlias,
@@ -797,6 +801,8 @@ export function SidebarConversationList({
   const tabs = useTabStore((s) => s.tabs)
   const {
     openTab,
+    openPkRoundTab,
+    closePkRoundTab,
     closeConversationTab,
     closeTabsByFolder,
     openNewConversationTab,
@@ -837,7 +843,9 @@ export function SidebarConversationList({
   const selectedConversation = useMemo(() => {
     const activeTab = tabs.find((tab) => tab.id === activeTabId)
     const next =
-      !activeTab || activeTab.conversationId == null
+      !activeTab ||
+      !isConversationWorkspaceTab(activeTab) ||
+      activeTab.conversationId == null
         ? null
         : { id: activeTab.conversationId, agentType: activeTab.agentType }
     const reused = reuseSelected(selectedConvRef.current, next)
@@ -849,7 +857,7 @@ export function SidebarConversationList({
   const openTabKeys = useMemo(() => {
     const next = new Set<string>()
     for (const tab of tabs) {
-      if (tab.conversationId != null) {
+      if (isConversationWorkspaceTab(tab) && tab.conversationId != null) {
         next.add(`${tab.agentType}:${tab.conversationId}`)
       }
     }
@@ -876,6 +884,7 @@ export function SidebarConversationList({
   const [sectionCollapsed, setSectionCollapsed] =
     useState<SidebarSectionCollapsed>({})
   const pinnedExpanded = !sectionCollapsed.pinned
+  const pkExpanded = !sectionCollapsed.pk
   const foldersExpanded = !sectionCollapsed.folders
   const chatsExpanded = !sectionCollapsed.chats
   const recentExpanded = !sectionCollapsed.recent
@@ -1100,7 +1109,7 @@ export function SidebarConversationList({
   // section, so exclude both here; then apply the completed filter as before.
   const folderConversations = useMemo(() => {
     const base = conversations.filter(
-      (c) => c.pinned_at == null && c.kind !== "chat"
+      (c) => c.pinned_at == null && c.kind !== "chat" && c.kind !== "pk"
     )
     if (showCompleted) return base
     return base.filter((c) => c.status !== "completed")
@@ -1120,6 +1129,84 @@ export function SidebarConversationList({
     return next
   }, [conversations, showCompleted])
 
+  // PK-arena conversations grouped by round (hottest round first). Each round
+  // renders as a collapsible sub-group under the "PK" section header. The round
+  // task labels come from the PK arena store; a round not yet hydrated shows a
+  // generic "Round #N" fallback.
+  const pkConvsRef = useRef<Map<number, DbConversationSummary[]>>(new Map())
+  const pkConversations = useMemo(() => {
+    const next = selectPkConversationsWithReuse(
+      conversations,
+      pkConvsRef.current
+    )
+    pkConvsRef.current = next
+    return next
+  }, [conversations])
+  const pkRounds = usePkArenaStore((s) => s.rounds)
+  const [pkRoundCollapsed, setPkRoundCollapsed] = useState<Set<number>>(
+    new Set()
+  )
+  const pkRoundTasks = useMemo(() => {
+    const map = new Map<number, string>()
+    for (const r of pkRounds) {
+      map.set(Number(r.id), r.task)
+    }
+    return map
+  }, [pkRounds])
+  const togglePkRound = useCallback((roundId: number) => {
+    setPkRoundCollapsed((prev) => {
+      const next = new Set(prev)
+      if (next.has(roundId)) next.delete(roundId)
+      else next.add(roundId)
+      return next
+    })
+  }, [])
+  const openPkRound = useCallback(
+    (roundId: number) => {
+      const store = usePkArenaStore.getState()
+      const round = store.rounds.find((item) => Number(item.id) === roundId)
+      if (!round) return
+      store.setActiveRound(round.id)
+      openPkRoundTab(round.id, round.folderId, round.task)
+    },
+    [openPkRoundTab]
+  )
+  const archivePkRound = useCallback(
+    async (roundId: number) => {
+      const round = usePkArenaStore
+        .getState()
+        .rounds.find((item) => Number(item.id) === roundId)
+      if (
+        !round ||
+        !window.confirm(t("pkArchiveConfirm", { task: round.task }))
+      ) {
+        return
+      }
+      try {
+        await usePkArenaStore.getState().archiveRound(String(roundId))
+        closePkRoundTab(String(roundId))
+        for (const conversation of pkConversations.get(roundId) ?? []) {
+          closeConversationTab(
+            conversation.folder_id,
+            conversation.id,
+            conversation.agent_type
+          )
+        }
+        await refreshConversations()
+        toast.success(t("pkArchiveSuccess"))
+      } catch (error) {
+        toast.error(t("pkArchiveFailed", { message: String(error) }))
+      }
+    },
+    [
+      closeConversationTab,
+      closePkRoundTab,
+      pkConversations,
+      refreshConversations,
+      t,
+    ]
+  )
+
   // Pinned bucket: the FULL conversation list (ignores "Show completed" — a
   // pinned conversation stays visible regardless), sorted most-recently-pinned
   // first, with reference reuse so an unrelated status event doesn't rebuild it.
@@ -1303,6 +1390,10 @@ export function SidebarConversationList({
       buildRows({
         pinned,
         pinnedExpanded,
+        pkConversations,
+        pkExpanded,
+        pkRoundTasks,
+        pkRoundCollapsed,
         // Top-level (reorderable) folders drive the outer order; buildRows nests
         // each container's root sub-group + worktrees via `containerChildren`.
         orderedFolderIds: reorderableFolderIds,
@@ -1326,6 +1417,10 @@ export function SidebarConversationList({
     [
       pinned,
       pinnedExpanded,
+      pkConversations,
+      pkExpanded,
+      pkRoundTasks,
+      pkRoundCollapsed,
       reorderableFolderIds,
       byFolder,
       folderExpanded,
@@ -2405,6 +2500,62 @@ export function SidebarConversationList({
         </div>
       )
     }
+    if (row.kind === "pk-empty") {
+      return (
+        <div className="px-[0.5rem] py-[0.375rem] text-[0.75rem] text-muted-foreground/70">
+          {t("noPk")}
+        </div>
+      )
+    }
+    if (row.kind === "pk-round") {
+      const collapsed = pkRoundCollapsed.has(row.roundId)
+      const roundStatus = pkRounds.find(
+        (round) => Number(round.id) === row.roundId
+      )?.status
+      const canArchive = roundStatus !== "running" && roundStatus !== "ready"
+      return (
+        <div className="group flex h-[1.75rem] w-full items-center rounded-md px-[0.25rem] hover:bg-sidebar-accent">
+          <button
+            type="button"
+            onClick={() => togglePkRound(row.roundId)}
+            aria-expanded={!collapsed}
+            className="rounded p-1 text-muted-foreground hover:text-sidebar-foreground"
+            title={collapsed ? t("pkExpand") : t("pkCollapse")}
+          >
+            <ChevronRight
+              className={cn(
+                "h-3 w-3 transition-transform",
+                !collapsed && "rotate-90"
+              )}
+            />
+          </button>
+          <button
+            type="button"
+            onClick={() => openPkRound(row.roundId)}
+            className="flex min-w-0 flex-1 items-center gap-1 py-1 text-left"
+            title={t("pkOpenArena")}
+          >
+            <span className="size-1.5 shrink-0 rounded-full bg-amber-400" />
+            <span className="truncate text-[0.75rem] font-medium text-sidebar-foreground/80">
+              {row.task}
+            </span>
+            <span className="ml-auto shrink-0 text-[0.6875rem] text-muted-foreground/70">
+              {row.count}
+            </span>
+          </button>
+          {canArchive ? (
+            <button
+              type="button"
+              onClick={() => void archivePkRound(row.roundId)}
+              className="rounded p-1 text-muted-foreground opacity-0 hover:bg-background/70 hover:text-sidebar-foreground focus:opacity-100 group-hover:opacity-100"
+              title={t("pkArchive")}
+            >
+              <Archive className="size-3" />
+            </button>
+          ) : null}
+        </div>
+      )
+    }
     if (row.kind === "recent-more") {
       // Footer of the paged Recent section — a row, not a hint: each click
       // reveals another page. Its geometry is the conversation card's, so the
@@ -2510,6 +2661,8 @@ export function SidebarConversationList({
     if (row.kind === "folders-empty") return "folders-empty"
     if (row.kind === "recent-empty") return "recent-empty"
     if (row.kind === "recent-more") return "recent-more"
+    if (row.kind === "pk-empty") return "pk-empty"
+    if (row.kind === "pk-round") return `pk-round-${row.roundId}`
     const prefix = row.recent ? "recent-" : ""
     if (row.kind === "subsession-loading") {
       return `${prefix}subloading-${row.parentId}`
diff --git a/src/components/conversations/sidebar-section-header.tsx b/src/components/conversations/sidebar-section-header.tsx
index 2556f8ac4..e0ef0b0a3 100644
--- a/src/components/conversations/sidebar-section-header.tsx
+++ b/src/components/conversations/sidebar-section-header.tsx
@@ -82,11 +82,13 @@ export const SidebarSectionHeader = memo(function SidebarSectionHeader({
   const label =
     section === "pinned"
       ? t("sectionPinned")
-      : section === "chats"
-        ? t("sectionChats")
-        : section === "recent"
-          ? t("sectionRecent")
-          : t("sectionFolders")
+      : section === "pk"
+        ? t("sectionPk")
+        : section === "chats"
+          ? t("sectionChats")
+          : section === "recent"
+            ? t("sectionRecent")
+            : t("sectionFolders")
   // "Recent" gets the same right-edge affordance as "Chats": it is a section
   // people scan to resume work, so "start a new one" belongs at its head too.
   // The label differs — Chats starts a folderless chat, Recent starts a
diff --git a/src/components/layout/aux-panel-file-tree-tab.tsx b/src/components/layout/aux-panel-file-tree-tab.tsx
index 7d3333c46..ec75b4afd 100644
--- a/src/components/layout/aux-panel-file-tree-tab.tsx
+++ b/src/components/layout/aux-panel-file-tree-tab.tsx
@@ -12,7 +12,7 @@ import {
   type KeyboardEvent as ReactKeyboardEvent,
   type ReactNode,
 } from "react"
-import { revealItemInDir, subscribe } from "@/lib/platform"
+import { isLocalDesktop, revealItemInDir, subscribe } from "@/lib/platform"
 import ignore from "ignore"
 import { Check, ChevronRight, Link2 } from "lucide-react"
 import { useTranslations } from "next-intl"
@@ -822,11 +822,13 @@ function RenderNode({
           <ContextMenuSub>
             <ContextMenuSubTrigger>{t("openIn")}</ContextMenuSubTrigger>
             <ContextMenuSubContent>
-              <ContextMenuItem
-                onSelect={() => void handleOpenInSystemExplorer()}
-              >
-                {systemExplorerLabel}
-              </ContextMenuItem>
+              {isLocalDesktop() && (
+                <ContextMenuItem
+                  onSelect={() => void handleOpenInSystemExplorer()}
+                >
+                  {systemExplorerLabel}
+                </ContextMenuItem>
+              )}
               <ContextMenuItem
                 onSelect={() => void onOpenDirInTerminal(dirPath, node.name)}
               >
@@ -1058,11 +1060,13 @@ function RenderNode({
         <ContextMenuSub>
           <ContextMenuSubTrigger>{t("openIn")}</ContextMenuSubTrigger>
           <ContextMenuSubContent>
-            <ContextMenuItem
-              onSelect={() => void handleOpenDirInSystemExplorer()}
-            >
-              {systemExplorerLabel}
-            </ContextMenuItem>
+            {isLocalDesktop() && (
+              <ContextMenuItem
+                onSelect={() => void handleOpenDirInSystemExplorer()}
+              >
+                {systemExplorerLabel}
+              </ContextMenuItem>
+            )}
             <ContextMenuItem
               onSelect={() => void onOpenDirInTerminal(absolutePath, node.name)}
             >
@@ -3002,13 +3006,15 @@ export function FileTreeTab() {
                         {t("openIn")}
                       </ContextMenuSubTrigger>
                       <ContextMenuSubContent>
-                        <ContextMenuItem
-                          onSelect={() => {
-                            void revealItemInDir(folder.path)
-                          }}
-                        >
-                          {systemExplorerLabel}
-                        </ContextMenuItem>
+                        {isLocalDesktop() && (
+                          <ContextMenuItem
+                            onSelect={() => {
+                              void revealItemInDir(folder.path)
+                            }}
+                          >
+                            {systemExplorerLabel}
+                          </ContextMenuItem>
+                        )}
                         <ContextMenuItem
                           onSelect={() => {
                             void handleOpenDirInTerminal(
diff --git a/src/components/layout/aux-panel-session-details-tab.test.tsx b/src/components/layout/aux-panel-session-details-tab.test.tsx
index 70a540a13..763f51de0 100644
--- a/src/components/layout/aux-panel-session-details-tab.test.tsx
+++ b/src/components/layout/aux-panel-session-details-tab.test.tsx
@@ -44,6 +44,7 @@ const mockWorkspace = useAppWorkspaceStore as unknown as Mock
 type TabSlice = {
   tabs: Array<{
     id: number
+    kind: "conversation"
     conversationId: number | null
     runtimeConversationId?: number
   }>
@@ -79,7 +80,9 @@ function setupScene(opts: { hasActiveConversation: boolean }) {
   mockAux.mockReturnValue({ isOpen: true, activeTab: "session_details" })
 
   const tabState: TabSlice = {
-    tabs: opts.hasActiveConversation ? [{ id: 1, conversationId: 7 }] : [],
+    tabs: opts.hasActiveConversation
+      ? [{ id: 1, kind: "conversation", conversationId: 7 }]
+      : [],
     activeTabId: opts.hasActiveConversation ? 1 : null,
   }
   mockTabs.mockImplementation((sel: (s: TabSlice) => unknown) => sel(tabState))
diff --git a/src/components/layout/aux-panel-session-details-tab.tsx b/src/components/layout/aux-panel-session-details-tab.tsx
index 1335f014a..0c75bb372 100644
--- a/src/components/layout/aux-panel-session-details-tab.tsx
+++ b/src/components/layout/aux-panel-session-details-tab.tsx
@@ -11,6 +11,7 @@ import { resolveActiveSessionDetails } from "@/components/conversations/active-s
 import { SessionDetailsContent } from "@/components/conversations/session-details-content"
 import { ScrollArea } from "@/components/ui/scroll-area"
 import { useAuxPanelContext } from "@/contexts/aux-panel-context"
+import { isConversationWorkspaceTab } from "@/lib/workspace-tab"
 
 // Stable empty-turns reference so the `useShallow` slice below stays
 // reference-equal when there's no active session — otherwise a fresh `[]` each
@@ -34,13 +35,12 @@ export function SessionDetailsTab() {
 
   const tabs = useTabStore((s) => s.tabs)
   const activeTabId = useTabStore((s) => s.activeTabId)
-  const activeConversationTab = useMemo(
-    () =>
-      tabs.find(
-        (tab) => tab.id === activeTabId && tab.conversationId != null
-      ) ?? null,
-    [tabs, activeTabId]
-  )
+  const activeConversationTab = useMemo(() => {
+    const tab = tabs.find((item) => item.id === activeTabId)
+    return tab && isConversationWorkspaceTab(tab) && tab.conversationId != null
+      ? tab
+      : null
+  }, [tabs, activeTabId])
 
   // A brand-new conversation streams under its virtual `runtimeConversationId`
   // until it reconciles; key the live-session lookup on it first (mirrors the
diff --git a/src/components/pk/pk-arena-host.tsx b/src/components/pk/pk-arena-host.tsx
new file mode 100644
index 000000000..8f7183612
--- /dev/null
+++ b/src/components/pk/pk-arena-host.tsx
@@ -0,0 +1,143 @@
+"use client"
+
+import { useEffect, useRef } from "react"
+import { PkLauncherDialog } from "@/components/pk/pk-launcher-dialog"
+import { PkMinimizedPill } from "@/components/pk/pk-minimized-pill"
+import { usePkRound, fetchUsage } from "@/hooks/use-pk-round"
+import {
+  usePkArenaStore,
+  dbRoundToStoreRound,
+  type PkRound,
+} from "@/stores/pk-arena-store"
+import { pkRoundList, updateConversationStatus } from "@/lib/api"
+import { getPkConversationStatusRepairs } from "@/lib/pk-conversation-reconciliation"
+import { useAppWorkspaceStore } from "@/stores/app-workspace-store"
+
+/**
+ * Arena mount point — renders global launch/minimized controls and drives the
+ * orchestrator for rounds created by the launcher. Must live inside
+ * `AcpConnectionsProvider` (the workspace layout provides it): the
+ * orchestrator calls `connect`/`sendPrompt` and subscribes to `acp://event`.
+ *
+ * The launcher only writes the round into the store; this host picks it up,
+ * so round creation works from anywhere (composer menu, future entries)
+ * without prop-drilling.
+ *
+ * On mount, hydrates the store from the DB so finished rounds' scoreboards and
+ * diffs remain viewable after a restart. The folder's path is needed to map
+ * each DB round's folderId to its workingDir.
+ */
+export function PkArenaHost() {
+  const { startRound } = usePkRound()
+  const rounds = usePkArenaStore((s) => s.rounds)
+  const hydrating = usePkArenaStore((s) => s.hydrating)
+  const hydrateFromDb = usePkArenaStore((s) => s.hydrateFromDb)
+  const folders = useAppWorkspaceStore((s) => s.allFolders)
+  const conversations = useAppWorkspaceStore((s) => s.conversations)
+  const conversationsLoading = useAppWorkspaceStore(
+    (s) => s.conversationsLoading
+  )
+  const reconciledConversationIdsRef = useRef(new Set<number>())
+
+  // Repair persisted PK conversation rows whose lifecycle no longer agrees
+  // with the authoritative round. This covers both legacy judge rows and
+  // contestant rows left live by an older cancellation path. The normal
+  // conversation event updates the sidebar in place.
+  useEffect(() => {
+    for (const repair of getPkConversationStatusRepairs(
+      rounds,
+      conversations
+    )) {
+      if (reconciledConversationIdsRef.current.has(repair.conversationId)) {
+        continue
+      }
+      reconciledConversationIdsRef.current.add(repair.conversationId)
+      void updateConversationStatus(repair.conversationId, repair.status).catch(
+        () => {
+          reconciledConversationIdsRef.current.delete(repair.conversationId)
+        }
+      )
+    }
+  }, [conversations, rounds])
+
+  // Hydrate each store instance once. Fast Refresh can replace the Zustand
+  // store while preserving this host's React refs; keying the guard by the
+  // store's rounds array lets the replacement hydrate again without issuing
+  // duplicate requests during React Strict Mode's repeated effects.
+  const hydrationSourceRef = useRef<readonly PkRound[] | null>(null)
+  useEffect(() => {
+    if (
+      !hydrating ||
+      hydrationSourceRef.current === rounds ||
+      folders.length === 0 ||
+      conversationsLoading
+    ) {
+      return
+    }
+    hydrationSourceRef.current = rounds
+    void (async () => {
+      try {
+        const dbRounds = await pkRoundList()
+        const storeRounds = dbRounds
+          .map((info) => {
+            const folder = folders.find((f) => f.id === info.folder_id)
+            const workingDir = folder?.path ?? ""
+            return dbRoundToStoreRound(info, workingDir, conversations)
+          })
+          .filter((r) => r.workingDir !== "")
+        hydrateFromDb(storeRounds)
+        // Backfill usage for finished contestants — usage is live-only in
+        // the store (issue #4 / #16), so after a restart it's null. Fetch
+        // it from the conversation turns for any contestant that has a
+        // conversationId and is done/error/canceled.
+        for (const round of storeRounds) {
+          for (const c of round.contestants) {
+            if (
+              c.conversationId != null &&
+              (c.status === "done" ||
+                c.status === "error" ||
+                c.status === "canceled")
+            ) {
+              const usage = await fetchUsage(c.conversationId)
+              if (usage) {
+                usePkArenaStore
+                  .getState()
+                  .updateContestant(round.id, c.slot, { usage })
+              }
+            }
+          }
+        }
+      } catch {
+        hydrateFromDb([])
+      }
+    })()
+  }, [
+    conversations,
+    conversationsLoading,
+    folders,
+    hydrateFromDb,
+    hydrating,
+    rounds,
+  ])
+
+  // Drive any round that still has contestants in "preparing" — exactly the
+  // state the launcher leaves behind. Restarted (interrupted) rounds come
+  // back with settled statuses, so they are never re-driven.
+  const drivenRef = useRef(new Set<string>())
+  useEffect(() => {
+    if (hydrating) return
+    for (const round of rounds) {
+      if (drivenRef.current.has(round.id)) continue
+      if (!round.contestants.some((c) => c.status === "preparing")) continue
+      drivenRef.current.add(round.id)
+      void startRound(round)
+    }
+  }, [rounds, startRound, hydrating])
+
+  return (
+    <>
+      <PkLauncherDialog />
+      <PkMinimizedPill />
+    </>
+  )
+}
diff --git a/src/components/pk/pk-arena-policy.test.ts b/src/components/pk/pk-arena-policy.test.ts
new file mode 100644
index 000000000..7d97bb4c8
--- /dev/null
+++ b/src/components/pk/pk-arena-policy.test.ts
@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest"
+import type { PkRound } from "@/stores/pk-arena-store"
+import { getArenaPillRound, getEffortControl } from "./pk-arena-policy"
+
+describe("PK arena lifecycle policy", () => {
+  it.each(["finished", "canceled", "interrupted"] as const)(
+    "does not show a %s round in the minimized entry",
+    (status) => {
+      const terminal = { id: "7", status } as PkRound
+      expect(getArenaPillRound([terminal], "7")).toBeNull()
+    }
+  )
+
+  it("prefers a live round when the active round is terminal", () => {
+    const finished = { id: "7", status: "finished" } as PkRound
+    const running = { id: "8", status: "running" } as PkRound
+    expect(getArenaPillRound([finished, running], "7")).toBe(running)
+  })
+})
+
+describe("PK contestant reasoning capability", () => {
+  it("shows the exact levels advertised by Qoder", () => {
+    expect(getEffortControl(["low", "medium"], "reasoning_effort")).toEqual({
+      kind: "select",
+      configId: "reasoning_effort",
+      options: ["low", "medium"],
+    })
+  })
+
+  it("shows an unsupported state instead of silently hiding the field", () => {
+    expect(getEffortControl([], null)).toEqual({ kind: "unsupported" })
+  })
+})
diff --git a/src/components/pk/pk-arena-policy.ts b/src/components/pk/pk-arena-policy.ts
new file mode 100644
index 000000000..734cc49c3
--- /dev/null
+++ b/src/components/pk/pk-arena-policy.ts
@@ -0,0 +1,31 @@
+import type { PkRound } from "@/stores/pk-arena-store"
+
+const isLiveRound = (round: PkRound) =>
+  round.status === "ready" || round.status === "running"
+
+/** Pick the live round represented by the minimized entry. */
+export function getArenaPillRound(
+  rounds: readonly PkRound[],
+  activeRoundId: string | null
+): PkRound | null {
+  const activeRound = rounds.find((round) => round.id === activeRoundId)
+  if (activeRound && isLiveRound(activeRound)) return activeRound
+  return rounds.find(isLiveRound) ?? null
+}
+
+export type PkEffortControl =
+  | {
+      kind: "select"
+      configId: string
+      options: readonly string[]
+    }
+  | { kind: "unsupported" }
+
+/** Preserve each agent's advertised effort levels; never invent global ones. */
+export function getEffortControl(
+  options: readonly string[],
+  configId: string | null
+): PkEffortControl {
+  if (!configId || options.length === 0) return { kind: "unsupported" }
+  return { kind: "select", configId, options }
+}
diff --git a/src/components/pk/pk-arena-view.tsx b/src/components/pk/pk-arena-view.tsx
new file mode 100644
index 000000000..c7877664f
--- /dev/null
+++ b/src/components/pk/pk-arena-view.tsx
@@ -0,0 +1,564 @@
+"use client"
+
+import { memo, useEffect, useMemo, useState } from "react"
+import { useLocale, useTranslations } from "next-intl"
+import { toast } from "sonner"
+import { ExternalLink } from "lucide-react"
+import { LiveTranscriptView } from "@/components/message/live-transcript-view"
+import { PkDiffView } from "@/components/pk/pk-diff-view"
+import { PkJudgePanel } from "@/components/pk/pk-judge-panel"
+import { PkScoreboard } from "@/components/pk/pk-scoreboard"
+import { PkHistoryPicker } from "@/components/pk/pk-history-picker"
+import { getEffortControl } from "@/components/pk/pk-arena-policy"
+import { usePkRound } from "@/hooks/use-pk-round"
+import { AgentIcon } from "@/components/agent-icon"
+import { getAgentLabel } from "@/lib/custom-agents"
+import { buildPkReportHtml } from "@/lib/pk-report"
+import { preparePkReportData } from "@/lib/pk-report-data"
+import { savePkReportHtml } from "@/lib/pk-report-export"
+import { openPkRoundWindow } from "@/lib/api"
+import type { PkContestant, PkRound } from "@/stores/pk-arena-store"
+import { cn } from "@/lib/utils"
+import { usePkArenaStore } from "@/stores/pk-arena-store"
+import { useTabActions } from "@/stores/tab-store"
+
+/**
+ * The arena itself: scoreboard on top, one live transcript column per
+ * contestant, a diff tab once the round settles, and a share button that
+ * saves a complete self-contained HTML battle report. Round switching comes from the store's
+ * The view is keyed by `roundId`, so multiple rounds can stay open in separate
+ * workspace tabs or split groups without fighting over one global active id.
+ */
+
+export function PkArenaView({
+  roundId,
+  tabId,
+}: {
+  roundId: string
+  tabId: string
+}) {
+  const t = useTranslations("PkArena.arena")
+  const tWindow = useTranslations("SkillsSettings.actions")
+  const locale = useLocale()
+  const setPillDismissed = usePkArenaStore((s) => s.setPillDismissed)
+  const rounds = usePkArenaStore((s) => s.rounds)
+  const { closeTab } = useTabActions()
+
+  const round = useMemo(
+    () => rounds.find((r) => r.id === roundId) ?? null,
+    [rounds, roundId]
+  )
+
+  const {
+    cancelRound,
+    cleanupRound,
+    fetchDiff,
+    disconnectFinished,
+    startPrompt,
+    sendFollowUp,
+    applyContestantSelection,
+    runJudge,
+  } = usePkRound()
+  const markRound = usePkArenaStore((s) => s.markRound)
+  const retryPersistence = usePkArenaStore((s) => s.retryPersistence)
+  const [tab, setTab] = useState<"battle" | "diff">("battle")
+  const [reportExporting, setReportExporting] = useState(false)
+  const [diffLoading, setDiffLoading] = useState(false)
+
+  // Literal keys — next-intl's typed messages reject dynamic concatenation.
+  const roundStatusLabel = useMemo(
+    () => ({
+      ready: t("roundStatus.ready"),
+      running: t("roundStatus.running"),
+      finished: t("roundStatus.finished"),
+      canceled: t("roundStatus.canceled"),
+      interrupted: t("roundStatus.interrupted"),
+    }),
+    [t]
+  )
+  const tabLabel = useMemo(
+    () => ({ battle: t("tabs.battle"), diff: t("tabs.diff") }) as const,
+    [t]
+  )
+
+  // Diff tab: fetch each contestant's worktree diff once per visit.
+  useEffect(() => {
+    if (tab !== "diff" || !round) return
+    let cancelled = false
+    const pending = round.contestants.filter(
+      (c) => c.diff == null && c.worktreePath
+    )
+    if (pending.length === 0) return
+    setDiffLoading(true)
+    void Promise.allSettled(pending.map((c) => fetchDiff(round, c))).then(
+      () => {
+        if (!cancelled) setDiffLoading(false)
+      }
+    )
+    return () => {
+      cancelled = true
+    }
+  }, [tab, round, fetchDiff])
+
+  // 状态自愈:任何原因导致回合停在 ready/running 而选手已全部结算
+  // (settle 事件漏一帧、重启后回放等),打开竞技场时立即收敛到 finished
+  // 并断开残留连接——否则顶部状态永远停在"就绪"。
+  useEffect(() => {
+    if (!round) return
+    const settled = (s: PkContestant["status"]) =>
+      s === "done" || s === "error" || s === "canceled"
+    if (round.status === "ready" || round.status === "running") {
+      if (
+        round.contestants.length > 0 &&
+        round.contestants.every((c) => settled(c.status))
+      ) {
+        markRound(round.id, "finished")
+        void disconnectFinished(round)
+      }
+    }
+  }, [round, markRound, disconnectFinished])
+
+  const handleExportReport = async () => {
+    if (!round || reportExporting) return
+    setReportExporting(true)
+    try {
+      const fresh = usePkArenaStore
+        .getState()
+        .rounds.find((r) => r.id === round.id)
+      const reportData = await preparePkReportData(fresh ?? round)
+      const html = buildPkReportHtml(
+        reportData.round,
+        reportData.artifactsBySlot,
+        locale
+      )
+      const result = await savePkReportHtml(html, round.id)
+      if (result === "saved") toast.success(t("reportSaved"))
+    } catch (error) {
+      toast.error(t("reportFailed", { message: String(error) }))
+    } finally {
+      setReportExporting(false)
+    }
+  }
+
+  const roundLive = round != null && round.status === "running"
+  const persistenceError = round
+    ? Object.values(round.persistenceErrors ?? {})
+        .filter(Boolean)
+        .join(" · ")
+    : ""
+
+  return (
+    <div className="flex h-full min-h-0 w-full flex-col overflow-hidden bg-background">
+      {round ? (
+        <div className="flex h-full min-h-0 flex-col">
+          <div className="flex items-center gap-3 border-b border-border px-4 py-2 pr-12">
+            <span
+              className="inline-flex h-5 shrink-0 items-center rounded border border-amber-500/35 bg-amber-500/10 px-1.5 font-mono text-[10px] font-bold tracking-[0.12em] text-amber-700 dark:text-amber-300"
+              title={t("title")}
+              aria-label={t("title")}
+            >
+              PK
+            </span>
+            <div className="min-w-0 flex-1">
+              <div className="truncate text-sm font-semibold text-foreground">
+                {round.task}
+              </div>
+              <div className="text-xs text-muted-foreground">
+                {roundStatusLabel[round.status]} ·{" "}
+                {new Date(round.createdAt).toLocaleString()}
+              </div>
+            </div>
+            <PkHistoryPicker activeRound={round} />
+            {round.status === "ready" || roundLive ? (
+              <button
+                type="button"
+                onClick={() => void cancelRound(round)}
+                className="rounded-md border border-border px-3 py-1 text-xs text-foreground hover:bg-muted"
+              >
+                {t("cancelRound")}
+              </button>
+            ) : round.contestants.some((c) => c.worktreePath) ? (
+              <button
+                type="button"
+                onClick={() =>
+                  void cleanupRound(round, true).catch((error) =>
+                    toast.error(t("reportFailed", { message: String(error) }))
+                  )
+                }
+                className="rounded-md border border-border px-3 py-1 text-xs text-foreground hover:bg-muted"
+                title={t("cleanupHint")}
+              >
+                {t("cleanupWorktrees")}
+              </button>
+            ) : null}
+            <button
+              type="button"
+              onClick={() => usePkArenaStore.getState().setLauncherOpen(true)}
+              className="rounded-md border border-border px-3 py-1 text-xs text-foreground hover:bg-muted"
+            >
+              {t("newRound")}
+            </button>
+            <button
+              type="button"
+              onClick={() =>
+                void openPkRoundWindow(round.id, round.task).catch((error) =>
+                  toast.error(String(error))
+                )
+              }
+              className="inline-flex items-center gap-1 rounded-md border border-border px-2 py-1 text-xs text-foreground hover:bg-muted"
+              title={tWindow("openInWindow")}
+              aria-label={tWindow("openInWindow")}
+            >
+              <ExternalLink className="size-3.5" />
+            </button>
+            <button
+              type="button"
+              onClick={() => {
+                setPillDismissed(false)
+                closeTab(tabId)
+              }}
+              className="rounded-md border border-border px-3 py-1 text-xs text-foreground hover:bg-muted"
+            >
+              {t("minimize")}
+            </button>
+            <button
+              type="button"
+              onClick={() => void handleExportReport()}
+              disabled={reportExporting}
+              className="rounded-md bg-primary px-3 py-1 text-xs font-medium text-primary-foreground disabled:opacity-50"
+            >
+              {reportExporting ? t("exporting") : t("shareReport")}
+            </button>
+          </div>
+
+          {persistenceError ? (
+            <div
+              className="flex items-center gap-3 border-b border-destructive/30 bg-destructive/8 px-4 py-2 text-xs text-destructive"
+              title={persistenceError}
+              role="status"
+            >
+              <span className="min-w-0 flex-1">{t("persistenceFailed")}</span>
+              <button
+                type="button"
+                className="shrink-0 rounded border border-destructive/30 px-2 py-1 font-medium hover:bg-destructive/10"
+                onClick={() => retryPersistence(round.id)}
+              >
+                {t("retrySave")}
+              </button>
+            </div>
+          ) : null}
+
+          {round.status === "ready" ? (
+            <div className="flex items-center gap-3 border-b border-border bg-amber-500/5 px-4 py-2">
+              <span className="min-w-0 flex-1 text-xs text-muted-foreground">
+                {t("readyNote")}
+              </span>
+              <button
+                type="button"
+                onClick={() => void startPrompt(round)}
+                disabled={!round.contestants.some((c) => c.status === "ready")}
+                className="rounded-md bg-primary px-4 py-1.5 text-sm font-medium text-primary-foreground disabled:opacity-50"
+              >
+                {t("startMatch")}
+              </button>
+            </div>
+          ) : null}
+          <div>
+            <PkScoreboard contestants={round.contestants} />
+
+            {/* Judge verdict panel — shown when a judge is configured. */}
+            {round.judgeAgent ? (
+              <PkJudgePanel
+                judgeStatus={round.judgeStatus}
+                judgeResult={round.judgeResult}
+                judgeAgent={round.judgeAgent}
+                contestants={round.contestants}
+                onRerun={
+                  round.judgeStatus === "done" || round.judgeStatus === "error"
+                    ? () => void runJudge(round)
+                    : undefined
+                }
+              />
+            ) : null}
+          </div>
+
+          <div className="flex items-center gap-1 border-b border-border px-4">
+            {(["battle", "diff"] as const).map((key) => (
+              <button
+                key={key}
+                type="button"
+                onClick={() => setTab(key)}
+                className={cn(
+                  "-mb-px border-b-2 px-3 py-1.5 text-sm",
+                  tab === key
+                    ? "border-primary font-medium text-foreground"
+                    : "border-transparent text-muted-foreground hover:text-foreground"
+                )}
+              >
+                {tabLabel[key]}
+              </button>
+            ))}
+          </div>
+
+          <div className="min-h-0 flex-1 overflow-hidden">
+            <div className="flex h-full gap-2 overflow-x-auto p-2">
+              {tab === "battle"
+                ? round.contestants.map((contestant) =>
+                    round.status === "ready" ? (
+                      <PkReadyPane
+                        key={contestant.slot}
+                        round={round}
+                        contestant={contestant}
+                        onSelect={applyContestantSelection}
+                      />
+                    ) : (
+                      <PkBattlePane
+                        key={contestant.slot}
+                        contestant={contestant}
+                        conversationId={contestant.conversationId}
+                        connectionId={contestant.connectionId}
+                        agentType={contestant.agentType}
+                        task={round.task}
+                        statusDetail={contestant.statusDetail}
+                        preparingLabel={t("preparing")}
+                        followUpLabel={t("followUp")}
+                        followUpPlaceholder={t("followUpPlaceholder")}
+                        onFollowUp={(message) =>
+                          void sendFollowUp(round, contestant, message)
+                        }
+                      />
+                    )
+                  )
+                : round.contestants.map((contestant) => (
+                    <PkDiffView
+                      key={contestant.slot}
+                      agentType={contestant.agentType}
+                      diff={contestant.diff}
+                      loading={diffLoading && contestant.diff == null}
+                    />
+                  ))}
+            </div>
+          </div>
+        </div>
+      ) : (
+        <div className="flex flex-1 items-center justify-center text-sm text-muted-foreground">
+          {t("noRound")}
+        </div>
+      )}
+    </div>
+  )
+}
+
+/**
+ * One battle column. Memoized on stable props: the dialog re-renders on
+ * every contestant store update (status/usage/diff of ANY contestant), and
+ * an unmemoized pane re-rendered four streaming markdown transcripts each
+ * time — the field-reported arena lag.
+ */
+const PkBattlePane = memo(function PkBattlePane({
+  contestant,
+  conversationId,
+  connectionId,
+  agentType,
+  task,
+  statusDetail,
+  preparingLabel,
+  followUpLabel,
+  followUpPlaceholder,
+  onFollowUp,
+}: {
+  contestant: PkContestant
+  conversationId: number | null
+  connectionId: string | null
+  agentType: PkContestant["agentType"]
+  task: string
+  statusDetail: string | null
+  preparingLabel: string
+  followUpLabel: string
+  followUpPlaceholder: string
+  onFollowUp: (message: string) => void
+}) {
+  // The follow-up box shows when the contestant finished its last turn AND
+  // its connection is still alive (contextKey set). A disconnected contestant
+  // can't receive a new prompt.
+  const canFollowUp =
+    contestant.status === "done" && contestant.contextKey != null
+  const [followUpText, setFollowUpText] = useState("")
+  const [sending, setSending] = useState(false)
+
+  const handleSend = async () => {
+    const trimmed = followUpText.trim()
+    if (!trimmed || sending) return
+    setSending(true)
+    setFollowUpText("")
+    try {
+      await onFollowUp(trimmed)
+    } finally {
+      setSending(false)
+    }
+  }
+
+  return (
+    <div className="flex h-full min-w-80 flex-1 flex-col overflow-hidden rounded-lg border border-border">
+      {conversationId != null ? (
+        <LiveTranscriptView
+          conversationId={conversationId}
+          connectionId={connectionId}
+          agentType={agentType}
+          kickoffText={task}
+        />
+      ) : (
+        <div className="flex flex-1 items-center justify-center px-3 text-xs text-muted-foreground">
+          {statusDetail ?? preparingLabel}
+        </div>
+      )}
+      {canFollowUp ? (
+        <div className="border-t border-border bg-muted/30 p-2">
+          <div className="mb-1 text-[11px] font-medium text-muted-foreground">
+            {followUpLabel}
+          </div>
+          <textarea
+            value={followUpText}
+            onChange={(e) => setFollowUpText(e.target.value)}
+            placeholder={followUpPlaceholder}
+            rows={2}
+            disabled={sending}
+            onKeyDown={(e) => {
+              if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) {
+                e.preventDefault()
+                void handleSend()
+              }
+            }}
+            className="w-full resize-none rounded-md border border-border bg-background px-2 py-1.5 text-xs text-foreground placeholder:text-muted-foreground focus:outline-none focus:ring-1 focus:ring-ring disabled:opacity-50"
+          />
+          <div className="mt-1 flex items-center justify-between">
+            <span className="text-[10px] text-muted-foreground">⌘↩</span>
+            <button
+              type="button"
+              onClick={() => void handleSend()}
+              disabled={!followUpText.trim() || sending}
+              className="rounded-md bg-primary px-3 py-1 text-xs font-medium text-primary-foreground disabled:opacity-50"
+            >
+              {sending ? "…" : followUpLabel}
+            </button>
+          </div>
+        </div>
+      ) : null}
+    </div>
+  )
+})
+
+/**
+ * 准备阶段的面板:模型 + 思考等级选择器(选项来自握手通告的 configOptions)。
+ * 只读竞技场 store 的选项表,变更经 onSelect 直接下发给后端连接。
+ */
+const PkReadyPane = memo(function PkReadyPane({
+  round,
+  contestant,
+  onSelect,
+}: {
+  round: PkRound
+  contestant: PkContestant
+  onSelect: (
+    round: PkRound,
+    contestant: PkContestant,
+    configId: string,
+    value: string
+  ) => Promise<void>
+}) {
+  const t = useTranslations("PkArena.arena")
+  const effortControl = getEffortControl(
+    contestant.effortOptions,
+    contestant.effortConfigId
+  )
+  const effortOptionLabels = {
+    off: t("effortOptions.off"),
+    minimal: t("effortOptions.minimal"),
+    low: t("effortOptions.low"),
+    medium: t("effortOptions.medium"),
+    high: t("effortOptions.high"),
+    max: t("effortOptions.max"),
+  } as const
+  return (
+    <div className="flex h-full min-w-80 flex-1 flex-col overflow-hidden rounded-lg border border-border">
+      <div className="flex items-center gap-2.5 border-b border-border bg-muted/30 px-4 py-3">
+        <span className="flex h-9 w-9 shrink-0 items-center justify-center rounded-lg border border-border bg-background">
+          <AgentIcon agentType={contestant.agentType} className="size-5" />
+        </span>
+        <div className="min-w-0">
+          <div className="truncate text-sm font-semibold text-foreground">
+            {getAgentLabel(contestant.agentType)}
+            {contestant.label ? ` · ${contestant.label}` : ""}
+          </div>
+          <div className="flex items-center gap-1.5 text-xs text-muted-foreground">
+            <span className="size-1.5 rounded-full bg-amber-400" aria-hidden />
+            {t("readyTag")}
+          </div>
+        </div>
+      </div>
+      <div className="flex flex-col gap-4 overflow-auto px-4 py-4">
+        {contestant.modelOptions.length > 0 && contestant.modelConfigId ? (
+          <label className="block">
+            <span className="mb-1.5 block text-xs font-medium text-muted-foreground">
+              {t("modelLabel")}
+            </span>
+            <select
+              value={contestant.selectedModel ?? ""}
+              onChange={(event) =>
+                void onSelect(
+                  round,
+                  contestant,
+                  contestant.modelConfigId as string,
+                  event.target.value
+                )
+              }
+              className="w-full rounded-md border border-border bg-background px-2 py-1 text-xs text-foreground"
+            >
+              {contestant.modelOptions.map((option) => (
+                <option key={option.value} value={option.value}>
+                  {option.name}
+                </option>
+              ))}
+            </select>
+          </label>
+        ) : null}
+        {effortControl.kind === "select" ? (
+          <label className="block">
+            <span className="mb-1.5 block text-xs font-medium text-muted-foreground">
+              {t("effortLabel")}
+            </span>
+            <select
+              value={contestant.selectedEffort ?? ""}
+              onChange={(event) =>
+                void onSelect(
+                  round,
+                  contestant,
+                  effortControl.configId,
+                  event.target.value
+                )
+              }
+              className="w-full rounded-md border border-border bg-background px-2 py-1 text-xs text-foreground"
+            >
+              {effortControl.options.map((value) => (
+                <option key={value} value={value}>
+                  {effortOptionLabels[
+                    value as keyof typeof effortOptionLabels
+                  ] ?? value}
+                </option>
+              ))}
+            </select>
+          </label>
+        ) : (
+          <div>
+            <span className="mb-1.5 block text-xs font-medium text-muted-foreground">
+              {t("effortLabel")}
+            </span>
+            <div className="rounded-md border border-dashed border-border bg-muted/30 px-2 py-1.5 text-xs text-muted-foreground">
+              {t("effortUnsupported")}
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  )
+})
diff --git a/src/components/pk/pk-diff-view.test.ts b/src/components/pk/pk-diff-view.test.ts
new file mode 100644
index 000000000..465656ff1
--- /dev/null
+++ b/src/components/pk/pk-diff-view.test.ts
@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest"
+import { parseUnifiedDiff } from "./pk-diff-view"
+
+describe("parseUnifiedDiff", () => {
+  it("classifies add, delete, hunk and context lines", () => {
+    const diff = [
+      "diff --git a/main.py b/main.py",
+      "index 123..456 100644",
+      "--- a/main.py",
+      "+++ b/main.py",
+      "@@ -1,3 +1,4 @@",
+      " context line",
+      "-removed line",
+      "+added line",
+      "+another addition",
+    ].join("\n")
+
+    const lines = parseUnifiedDiff(diff)
+    // File header lines are dropped entirely.
+    expect(lines.map((l) => l.kind)).toEqual([
+      "hunk",
+      "ctx",
+      "del",
+      "add",
+      "add",
+    ])
+    expect(lines[0].text).toBe("@@ -1,3 +1,4 @@")
+  })
+
+  it("keeps blank context lines as renderable entries", () => {
+    const lines = parseUnifiedDiff("+x\n\n-y")
+    expect(lines).toHaveLength(3)
+    expect(lines[1]).toEqual({ kind: "ctx", text: "" })
+  })
+
+  it("handles an empty diff without inventing lines", () => {
+    expect(parseUnifiedDiff("")).toEqual([])
+  })
+})
diff --git a/src/components/pk/pk-diff-view.tsx b/src/components/pk/pk-diff-view.tsx
new file mode 100644
index 000000000..8c7a668d6
--- /dev/null
+++ b/src/components/pk/pk-diff-view.tsx
@@ -0,0 +1,120 @@
+"use client"
+
+import { useMemo } from "react"
+import { useTranslations } from "next-intl"
+import { AgentIcon } from "@/components/agent-icon"
+import { getAgentLabel } from "@/lib/custom-agents"
+import type { AgentType } from "@/lib/types"
+import { cn } from "@/lib/utils"
+
+/**
+ * Lightweight unified-diff renderer for one contestant's worktree diff —
+ * line-level red/green with hunk headers, deliberately NOT the three-pane
+ * merge editor (that is for conflict resolution, not comparison). Each
+ * contestant renders in its own scrollable column.
+ */
+
+interface DiffLine {
+  kind: "add" | "del" | "hunk" | "ctx"
+  text: string
+}
+
+export function parseUnifiedDiff(diff: string): DiffLine[] {
+  if (diff.trim() === "") return []
+  const lines: DiffLine[] = []
+  for (const raw of diff.split("\n")) {
+    if (
+      raw.startsWith("+++") ||
+      raw.startsWith("---") ||
+      raw.startsWith("diff ") ||
+      raw.startsWith("index ")
+    ) {
+      continue
+    }
+    if (raw.startsWith("@@")) {
+      lines.push({ kind: "hunk", text: raw })
+    } else if (raw.startsWith("+")) {
+      lines.push({ kind: "add", text: raw })
+    } else if (raw.startsWith("-")) {
+      lines.push({ kind: "del", text: raw })
+    } else {
+      lines.push({ kind: "ctx", text: raw })
+    }
+  }
+  return lines
+}
+
+function diffStats(lines: DiffLine[]): { added: number; removed: number } {
+  let added = 0
+  let removed = 0
+  for (const line of lines) {
+    if (line.kind === "add") added += 1
+    if (line.kind === "del") removed += 1
+  }
+  return { added, removed }
+}
+
+const LINE_STYLE: Record<DiffLine["kind"], string> = {
+  add: "bg-emerald-500/10 text-emerald-700 dark:text-emerald-400",
+  del: "bg-red-500/10 text-red-700 dark:text-red-400",
+  hunk: "bg-muted text-muted-foreground",
+  ctx: "text-foreground/80",
+}
+
+export function PkDiffView({
+  agentType,
+  diff,
+  loading,
+}: {
+  agentType: AgentType
+  diff: string | null
+  loading: boolean
+}) {
+  const t = useTranslations("PkArena.diff")
+  const lines = useMemo(() => (diff ? parseUnifiedDiff(diff) : []), [diff])
+  const stats = useMemo(() => diffStats(lines), [lines])
+  const empty = diff != null && diff.trim() === ""
+
+  return (
+    <div className="flex h-full min-h-0 min-w-80 flex-1 flex-col overflow-hidden rounded-lg border border-border">
+      <div className="flex shrink-0 items-center gap-2 border-b border-border px-3 py-2">
+        <AgentIcon agentType={agentType} className="size-4" />
+        <span className="text-sm font-medium text-foreground">
+          {getAgentLabel(agentType)}
+        </span>
+        {diff != null && !empty ? (
+          <span className="ml-auto flex items-baseline gap-2 text-xs tabular-nums">
+            <span className="text-emerald-600 dark:text-emerald-400">
+              +{stats.added}
+            </span>
+            <span className="text-red-600 dark:text-red-400">
+              −{stats.removed}
+            </span>
+          </span>
+        ) : null}
+      </div>
+      <div className="min-h-0 flex-1 overflow-auto">
+        {loading ? (
+          <div className="px-3 py-2 text-xs text-muted-foreground">
+            {t("loading")}
+          </div>
+        ) : empty ? (
+          <div className="px-3 py-2 text-xs text-muted-foreground">
+            {t("empty")}
+          </div>
+        ) : (
+          <pre className="min-w-max px-0 py-1 font-mono text-[11px] leading-5">
+            {lines.map((line, index) => (
+              <div
+                key={index}
+                className={cn("px-3 whitespace-pre", LINE_STYLE[line.kind])}
+              >
+                {line.text === "" ? " " : line.text}
+              </div>
+            ))}
+          </pre>
+        )}
+      </div>
+    </div>
+  )
+}
diff --git a/src/components/pk/pk-history-picker.tsx b/src/components/pk/pk-history-picker.tsx
new file mode 100644
index 000000000..3482e3594
--- /dev/null
+++ b/src/components/pk/pk-history-picker.tsx
@@ -0,0 +1,201 @@
+"use client"
+
+import { useMemo, useState } from "react"
+import { Archive, ChevronRight, History, Search, Trophy } from "lucide-react"
+import { useTranslations } from "next-intl"
+import { toast } from "sonner"
+import {
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+} from "@/components/ui/popover"
+import { cn } from "@/lib/utils"
+import { assignJudgeScoreSlots, contestantForJudgeScore } from "@/lib/pk-judge"
+import { useAppWorkspaceStore } from "@/stores/app-workspace-store"
+import { useTabActions } from "@/contexts/tab-context"
+import { usePkArenaStore, type PkRound } from "@/stores/pk-arena-store"
+
+const STATUS_TONE: Record<PkRound["status"], string> = {
+  ready: "bg-amber-500",
+  running: "bg-emerald-500",
+  finished: "bg-sky-500",
+  canceled: "bg-muted-foreground",
+  interrupted: "bg-orange-500",
+}
+
+export function PkHistoryPicker({ activeRound }: { activeRound: PkRound }) {
+  const t = useTranslations("PkArena.history")
+  const rounds = usePkArenaStore((s) => s.rounds)
+  const setActiveRound = usePkArenaStore((s) => s.setActiveRound)
+  const archiveRound = usePkArenaStore((s) => s.archiveRound)
+  const refreshConversations = useAppWorkspaceStore(
+    (s) => s.refreshConversations
+  )
+  const conversations = useAppWorkspaceStore((s) => s.conversations)
+  const { closeConversationTab, closePkRoundTab, openPkRoundTab } =
+    useTabActions()
+  const [open, setOpen] = useState(false)
+  const [query, setQuery] = useState("")
+  const [archivingId, setArchivingId] = useState<string | null>(null)
+
+  const filtered = useMemo(() => {
+    const needle = query.trim().toLocaleLowerCase()
+    if (!needle) return rounds
+    return rounds.filter((round) => {
+      const agents = round.contestants.map((c) => c.agentType).join(" ")
+      return `${round.task} ${agents}`.toLocaleLowerCase().includes(needle)
+    })
+  }, [query, rounds])
+
+  const statusLabel = (status: PkRound["status"]) =>
+    ({
+      ready: t("status.ready"),
+      running: t("status.running"),
+      finished: t("status.finished"),
+      canceled: t("status.canceled"),
+      interrupted: t("status.interrupted"),
+    })[status]
+
+  const handleArchive = async (round: PkRound) => {
+    if (!window.confirm(t("archiveConfirm", { task: round.task }))) return
+    setArchivingId(round.id)
+    try {
+      await archiveRound(round.id)
+      closePkRoundTab(round.id)
+      for (const conversation of conversations) {
+        if (conversation.pk_round_id !== Number(round.id)) continue
+        closeConversationTab(
+          conversation.folder_id,
+          conversation.id,
+          conversation.agent_type
+        )
+      }
+      await refreshConversations()
+      const remaining = usePkArenaStore.getState().rounds
+      if (round.id === activeRound.id) {
+        if (remaining[0]) setActiveRound(remaining[0].id)
+      }
+      toast.success(t("archiveSuccess"))
+    } catch (error) {
+      toast.error(t("archiveFailed", { message: String(error) }))
+    } finally {
+      setArchivingId(null)
+    }
+  }
+
+  return (
+    <Popover open={open} onOpenChange={setOpen}>
+      <PopoverTrigger asChild>
+        <button
+          type="button"
+          className="inline-flex items-center gap-1.5 rounded-md border border-border bg-background px-2.5 py-1 text-xs text-foreground hover:bg-muted"
+          aria-label={t("title")}
+        >
+          <History className="size-3.5" />
+          {t("trigger", { count: rounds.length })}
+        </button>
+      </PopoverTrigger>
+      <PopoverContent
+        align="end"
+        className="w-[min(30rem,calc(100vw-2rem))] p-0"
+      >
+        <div className="border-b border-border p-3">
+          <div className="mb-2">
+            <div className="text-sm font-semibold">{t("title")}</div>
+            <div className="text-xs text-muted-foreground">{t("hint")}</div>
+          </div>
+          <label className="flex items-center gap-2 rounded-md border border-border bg-background px-2.5 py-1.5">
+            <Search className="size-3.5 text-muted-foreground" />
+            <input
+              value={query}
+              onChange={(event) => setQuery(event.target.value)}
+              placeholder={t("searchPlaceholder")}
+              className="min-w-0 flex-1 bg-transparent text-sm outline-none placeholder:text-muted-foreground"
+              autoFocus
+            />
+          </label>
+        </div>
+        <div className="max-h-[min(32rem,60vh)] overflow-y-auto p-1.5">
+          {filtered.length === 0 ? (
+            <div className="px-3 py-8 text-center text-sm text-muted-foreground">
+              {t("empty")}
+            </div>
+          ) : (
+            filtered.map((round) => {
+              const winner = assignJudgeScoreSlots(
+                round.judgeResult?.scores ?? [],
+                round.contestants.filter(
+                  (contestant) => contestant.status === "done"
+                )
+              ).find((score) => score.rank === 1)
+              const winnerContestant = winner
+                ? contestantForJudgeScore(winner, round.contestants)
+                : undefined
+              const active = round.id === activeRound.id
+              return (
+                <div
+                  key={round.id}
+                  className={cn(
+                    "group flex items-center gap-2 rounded-lg border border-transparent p-2",
+                    active ? "border-border bg-muted/70" : "hover:bg-muted/50"
+                  )}
+                >
+                  <button
+                    type="button"
+                    onClick={() => {
+                      setActiveRound(round.id)
+                      openPkRoundTab(round.id, round.folderId, round.task)
+                      setOpen(false)
+                    }}
+                    className="min-w-0 flex flex-1 items-center gap-2 text-left"
+                  >
+                    <span
+                      className={cn(
+                        "size-2 shrink-0 rounded-full",
+                        STATUS_TONE[round.status]
+                      )}
+                    />
+                    <span className="min-w-0 flex-1">
+                      <span className="block truncate text-sm font-medium">
+                        {round.task}
+                      </span>
+                      <span className="flex flex-wrap items-center gap-x-2 text-xs text-muted-foreground">
+                        <span>{statusLabel(round.status)}</span>
+                        <span>
+                          {new Date(round.createdAt).toLocaleString()}
+                        </span>
+                        <span>
+                          {t("agents", { count: round.contestants.length })}
+                        </span>
+                        {winner ? (
+                          <span className="inline-flex items-center gap-1">
+                            <Trophy className="size-3" /> {winner.agentType}
+                            {winnerContestant?.label
+                              ? ` · ${winnerContestant.label}`
+                              : ""}
+                          </span>
+                        ) : null}
+                      </span>
+                    </span>
+                    <ChevronRight className="size-4 shrink-0 text-muted-foreground" />
+                  </button>
+                  {round.status !== "running" && round.status !== "ready" ? (
+                    <button
+                      type="button"
+                      onClick={() => void handleArchive(round)}
+                      disabled={archivingId === round.id}
+                      className="rounded-md p-1.5 text-muted-foreground opacity-0 hover:bg-background hover:text-foreground focus:opacity-100 disabled:opacity-50 group-hover:opacity-100"
+                      title={t("archive")}
+                    >
+                      <Archive className="size-3.5" />
+                    </button>
+                  ) : null}
+                </div>
+              )
+            })
+          )}
+        </div>
+      </PopoverContent>
+    </Popover>
+  )
+}
diff --git a/src/components/pk/pk-judge-panel.test.tsx b/src/components/pk/pk-judge-panel.test.tsx
new file mode 100644
index 000000000..01e1cff70
--- /dev/null
+++ b/src/components/pk/pk-judge-panel.test.tsx
@@ -0,0 +1,68 @@
+import { render, screen } from "@testing-library/react"
+import { describe, expect, it, vi } from "vitest"
+import type { PkContestant } from "@/stores/pk-arena-store"
+import { PkJudgePanel } from "./pk-judge-panel"
+
+vi.mock("next-intl", () => ({
+  useTranslations: () => (key: string) => key,
+}))
+
+vi.mock("@/components/agent-icon", () => ({
+  AgentIcon: ({ agentType }: { agentType: string }) => (
+    <span data-agent={agentType} />
+  ),
+}))
+
+describe("PkJudgePanel", () => {
+  it("renders repeated agent types as distinct contestant slots", () => {
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => undefined)
+
+    render(
+      <PkJudgePanel
+        judgeStatus="done"
+        judgeAgent="codex"
+        contestants={
+          [
+            {
+              slot: 2,
+              agentType: "qoder",
+              label: "Model A",
+              status: "done",
+            },
+            {
+              slot: 4,
+              agentType: "qoder",
+              label: "Model B",
+              status: "done",
+            },
+          ] as PkContestant[]
+        }
+        judgeResult={{
+          scores: [
+            {
+              agentType: "qoder",
+              score: 46,
+              rank: 3,
+              comment: "first model",
+            },
+            {
+              agentType: "qoder",
+              score: 42,
+              rank: 4,
+              comment: "second model",
+            },
+          ],
+          summary: "done",
+          rawText: "",
+        }}
+      />
+    )
+
+    expect(consoleError.mock.calls.flat().join(" ")).not.toContain("same key")
+    expect(screen.getByText("Model A")).toBeInTheDocument()
+    expect(screen.getByText("Model B")).toBeInTheDocument()
+    consoleError.mockRestore()
+  })
+})
diff --git a/src/components/pk/pk-judge-panel.tsx b/src/components/pk/pk-judge-panel.tsx
new file mode 100644
index 000000000..f3ff90560
--- /dev/null
+++ b/src/components/pk/pk-judge-panel.tsx
@@ -0,0 +1,148 @@
+"use client"
+
+import { useTranslations } from "next-intl"
+import { AgentIcon } from "@/components/agent-icon"
+import { getAgentLabel } from "@/lib/custom-agents"
+import { assignJudgeScoreSlots, contestantForJudgeScore } from "@/lib/pk-judge"
+import { cn } from "@/lib/utils"
+import type {
+  PkContestant,
+  PkJudgeResult,
+  PkJudgeStatus,
+} from "@/stores/pk-arena-store"
+import type { AgentType } from "@/lib/types"
+
+/**
+ * Judge verdict panel — appears below the scoreboard when a judge agent was
+ * configured for the round. Shows the judge's structured scores and rankings
+ * once the judge has finished, or a spinner while it runs.
+ */
+
+function scoreColor(score: number): string {
+  if (score >= 80) return "text-emerald-600 dark:text-emerald-400"
+  if (score >= 60) return "text-amber-600 dark:text-amber-400"
+  if (score >= 40) return "text-orange-600 dark:text-orange-400"
+  return "text-red-600 dark:text-red-400"
+}
+
+function rankBadge(rank: number): string {
+  if (rank === 1) return "🥇"
+  if (rank === 2) return "🥈"
+  if (rank === 3) return "🥉"
+  return `#${rank}`
+}
+
+export function PkJudgePanel({
+  judgeStatus,
+  judgeResult,
+  judgeAgent,
+  contestants,
+  onRerun,
+}: {
+  judgeStatus: PkJudgeStatus
+  judgeResult: PkJudgeResult | null
+  judgeAgent: string
+  contestants: readonly PkContestant[]
+  onRerun?: () => void
+}) {
+  const t = useTranslations("PkArena.judge")
+  const completedContestants = contestants.filter(
+    (contestant) => contestant.status === "done"
+  )
+  const scores = assignJudgeScoreSlots(
+    judgeResult?.scores ?? [],
+    completedContestants
+  )
+
+  if (judgeStatus === "idle" || judgeStatus === "skipped") return null
+
+  return (
+    <div className="border-b border-border bg-muted/30 px-4 py-3">
+      <div className="mb-2 flex items-center gap-2">
+        <AgentIcon agentType={judgeAgent as AgentType} className="size-4" />
+        <span className="text-sm font-medium text-foreground">
+          {t("title")}
+        </span>
+        <span className="text-xs text-muted-foreground">
+          {getAgentLabel(judgeAgent as AgentType)}
+        </span>
+        {judgeStatus === "running" ? (
+          <span className="flex items-center gap-1 text-xs text-muted-foreground">
+            <span className="size-1.5 animate-pulse rounded-full bg-sky-500" />
+            {t("running")}
+          </span>
+        ) : null}
+        {judgeStatus === "error" ? (
+          <span className="text-xs text-red-600 dark:text-red-400">
+            {t("error")}
+          </span>
+        ) : null}
+        {onRerun ? (
+          <button
+            type="button"
+            onClick={onRerun}
+            className="ml-auto inline-flex items-center gap-1 rounded-md border border-border px-2 py-1 text-xs text-muted-foreground transition-colors hover:bg-muted hover:text-foreground"
+          >
+            {t("rerun")}
+          </button>
+        ) : null}
+      </div>
+
+      {judgeResult ? (
+        <div className="space-y-2">
+          {scores.length > 0 ? (
+            <div className="flex flex-wrap gap-2">
+              {scores
+                .slice()
+                .sort((a, b) => a.rank - b.rank)
+                .map((score, index) => {
+                  const contestant = contestantForJudgeScore(score, contestants)
+                  return (
+                    <div
+                      key={
+                        score.slot ??
+                        `${score.agentType}-${score.rank}-${index}`
+                      }
+                      className="flex items-center gap-2 rounded-lg border border-border bg-background px-3 py-1.5"
+                    >
+                      <span className="text-sm">{rankBadge(score.rank)}</span>
+                      <AgentIcon
+                        agentType={score.agentType as AgentType}
+                        className="size-4"
+                      />
+                      <span className="text-sm font-medium text-foreground">
+                        {getAgentLabel(score.agentType as AgentType)}
+                      </span>
+                      {contestant?.label ? (
+                        <span className="max-w-40 truncate text-xs text-muted-foreground">
+                          {contestant.label}
+                        </span>
+                      ) : null}
+                      <span
+                        className={cn(
+                          "text-lg font-bold tabular-nums",
+                          scoreColor(score.score)
+                        )}
+                      >
+                        {score.score}
+                      </span>
+                      {score.comment ? (
+                        <span className="max-w-xs truncate text-xs text-muted-foreground">
+                          {score.comment}
+                        </span>
+                      ) : null}
+                    </div>
+                  )
+                })}
+            </div>
+          ) : null}
+          {judgeResult.summary ? (
+            <p className="text-xs text-muted-foreground">
+              {judgeResult.summary}
+            </p>
+          ) : null}
+        </div>
+      ) : null}
+    </div>
+  )
+}
diff --git a/src/components/pk/pk-launcher-dialog.test.tsx b/src/components/pk/pk-launcher-dialog.test.tsx
new file mode 100644
index 000000000..7c6283ecb
--- /dev/null
+++ b/src/components/pk/pk-launcher-dialog.test.tsx
@@ -0,0 +1,172 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { render, screen, waitFor } from "@testing-library/react"
+import userEvent from "@testing-library/user-event"
+import { NextIntlClientProvider } from "next-intl"
+import enMessages from "@/i18n/messages/en.json"
+import { usePkArenaStore } from "@/stores/pk-arena-store"
+import { PkLauncherDialog } from "./pk-launcher-dialog"
+
+const apiMocks = vi.hoisted(() => ({
+  acpGetAgentStatus: vi.fn(),
+  getGitBranch: vi.fn(),
+  pkRoundCreate: vi.fn(),
+}))
+
+vi.mock("@/lib/api", () => ({
+  acpGetAgentStatus: apiMocks.acpGetAgentStatus,
+  getFolder: vi.fn(),
+  getGitBranch: apiMocks.getGitBranch,
+  gitInit: vi.fn(),
+  gitLog: vi.fn(),
+  pkRoundCreate: apiMocks.pkRoundCreate,
+  pkRoundUpdateStatus: vi.fn(),
+  pkRoundDelete: vi.fn(),
+  pkRoundUpdateJudge: vi.fn(),
+}))
+
+vi.mock("@/hooks/use-acp-agents", () => ({
+  useAcpAgents: () => ({
+    agents: [
+      {
+        agent_type: "claude_code",
+        name: "Claude Code",
+        enabled: true,
+        available: true,
+        installed_version: "1.0.0",
+      },
+    ],
+  }),
+}))
+
+vi.mock("@/components/automations/use-agent-options", () => ({
+  useAgentOptions: () => ({
+    snapshot: {
+      modes: null,
+      config_options: [
+        {
+          id: "model",
+          name: "Model",
+          category: "model",
+          kind: {
+            type: "select",
+            current_value: "sonnet",
+            options: [
+              { value: "sonnet", name: "Sonnet" },
+              { value: "opus", name: "Opus" },
+            ],
+            groups: [],
+          },
+        },
+      ],
+      available_commands: [],
+    },
+    loading: false,
+    error: null,
+    reload: vi.fn(),
+    ensure: vi.fn(),
+  }),
+}))
+
+vi.mock("@/stores/tab-store", () => ({
+  useTabStore: (selector: (state: unknown) => unknown) =>
+    selector({
+      activeTabId: "tab-1",
+      openPkRoundTab: vi.fn(),
+      tabs: [
+        {
+          id: "tab-1",
+          kind: "conversation",
+          folderId: 7,
+          conversationId: null,
+          agentType: "claude-code",
+          title: "New conversation",
+          isPinned: true,
+          workingDir: "/tmp/repo",
+        },
+      ],
+    }),
+}))
+
+describe("PkLauncherDialog", () => {
+  beforeEach(() => {
+    window.localStorage.clear()
+    apiMocks.getGitBranch.mockResolvedValue("main")
+    apiMocks.acpGetAgentStatus.mockResolvedValue({
+      enabled: true,
+      available: true,
+      installed_version: "1.0.0",
+    })
+    apiMocks.pkRoundCreate.mockResolvedValue({
+      id: 12,
+      folder_id: 7,
+      task: "compare models",
+      config: {
+        agents: [],
+        permission_mode: "default",
+        bare_mode: false,
+        effort: "default",
+      },
+      status: "ready",
+      failure_reason: null,
+      judge_status: "idle",
+      created_at: "2026-08-20T00:00:00Z",
+      updated_at: "2026-08-20T00:00:00Z",
+      finished_at: null,
+    })
+    usePkArenaStore.setState({
+      rounds: [],
+      activeRoundId: null,
+      launcherOpen: true,
+      pillDismissed: false,
+      hydrating: false,
+    })
+  })
+
+  it("pins the model selected inside each contestant slot", async () => {
+    const user = userEvent.setup()
+    render(
+      <NextIntlClientProvider locale="en" messages={enMessages}>
+        <PkLauncherDialog />
+      </NextIntlClientProvider>
+    )
+
+    const addContestant = await screen.findByRole("button", {
+      name: "Add Claude Code as contestant",
+    })
+    await user.click(addContestant)
+    await user.click(addContestant)
+
+    const modelSelectors = await screen.findAllByRole("combobox", {
+      name: "Model",
+    })
+    expect(modelSelectors).toHaveLength(2)
+
+    await user.click(modelSelectors[1])
+    await user.click(await screen.findByRole("option", { name: "Opus" }))
+    await user.type(screen.getByLabelText("Task"), "compare models")
+
+    const start = screen.getByRole("button", { name: "Start match" })
+    await waitFor(() => expect(start).toBeEnabled())
+    await user.click(start)
+
+    await waitFor(() => expect(apiMocks.pkRoundCreate).toHaveBeenCalled())
+    expect(apiMocks.pkRoundCreate).toHaveBeenCalledWith(
+      7,
+      "compare models",
+      expect.objectContaining({
+        agents: [
+          {
+            agent: "claude_code",
+            label: "Sonnet",
+            config_values: { model: "sonnet" },
+          },
+          {
+            agent: "claude_code",
+            label: "Opus",
+            config_values: { model: "opus" },
+          },
+        ],
+      })
+    )
+  })
+})
diff --git a/src/components/pk/pk-launcher-dialog.tsx b/src/components/pk/pk-launcher-dialog.tsx
new file mode 100644
index 000000000..98264ee50
--- /dev/null
+++ b/src/components/pk/pk-launcher-dialog.tsx
@@ -0,0 +1,965 @@
+"use client"
+
+import { useEffect, useMemo, useRef, useState } from "react"
+import { useTranslations } from "next-intl"
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogTitle,
+} from "@/components/ui/dialog"
+import { AgentIcon } from "@/components/agent-icon"
+import { Loader2, RefreshCw, X } from "lucide-react"
+import {
+  Select,
+  SelectContent,
+  SelectGroup,
+  SelectItem,
+  SelectLabel,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select"
+import { useAgentOptions } from "@/components/automations/use-agent-options"
+import { useAcpAgents } from "@/hooks/use-acp-agents"
+import {
+  acpGetAgentStatus,
+  getFolder,
+  getGitBranch,
+  gitInit,
+  gitLog,
+} from "@/lib/api"
+import { getAgentLabel } from "@/lib/custom-agents"
+import { PK_TEMPLATES } from "@/lib/pk-templates"
+import type {
+  AgentType,
+  GitLogEntry,
+  SessionConfigOptionInfo,
+} from "@/lib/types"
+import { cn } from "@/lib/utils"
+import {
+  loadLastLauncherConfig,
+  saveLastLauncherConfig,
+  usePkArenaStore,
+  type PkEffortLevel,
+  type PkPermissionMode,
+} from "@/stores/pk-arena-store"
+import { useTabStore } from "@/stores/tab-store"
+
+/**
+ * Arena launcher: pick 2-8 installed agents, write the task, start the round.
+ * Reads the ACTIVE tab for the target folder (an arena needs a real folder —
+ * its git repo provides the per-contestant worktrees; chat mode has none).
+ */
+
+const MIN_CONTESTANTS = 2
+const MAX_CONTESTANTS = 8
+
+interface LauncherSlot {
+  id: number
+  agentType: AgentType
+  label: string
+  configValues: Record<string, string>
+}
+
+export function PkLauncherDialog() {
+  const t = useTranslations("PkArena.launcher")
+  const open = usePkArenaStore((s) => s.launcherOpen)
+  const setLauncherOpen = usePkArenaStore((s) => s.setLauncherOpen)
+  const createRound = usePkArenaStore((s) => s.createRound)
+  const openPkRoundTab = useTabStore((s) => s.openPkRoundTab)
+  const { agents: rawAgents } = useAcpAgents()
+  const nextSlotId = useRef(0)
+  const activeTab = useTabStore((s) =>
+    s.activeTabId
+      ? (s.tabs.find((tab) => tab.id === s.activeTabId) ?? null)
+      : null
+  )
+
+  const [slots, setSlots] = useState<LauncherSlot[]>([])
+  const [task, setTask] = useState("")
+  const [workingDir, setWorkingDir] = useState<string | null>(null)
+  const [folderId, setFolderId] = useState<number | null>(null)
+  // null = unknown (still checking); false disables Start — worktrees need a
+  // real git repo, and `git worktree add` in a plain folder fails instantly.
+  const [isGitRepo, setIsGitRepo] = useState<boolean | null>(null)
+  const [initializing, setInitializing] = useState(false)
+  const [permissionMode, setPermissionMode] =
+    useState<PkPermissionMode>("default")
+  const [bareMode, setBareMode] = useState(false)
+  const [effort, setEffort] = useState<PkEffortLevel>("default")
+  const [judgeAgent, setJudgeAgent] = useState<string | null>(null)
+  const [judgeDimensions, setJudgeDimensions] = useState<string>("")
+  const [startError, setStartError] = useState<string | null>(null)
+  const [commitPickerOpen, setCommitPickerOpen] = useState(false)
+  const [commits, setCommits] = useState<GitLogEntry[]>([])
+  const [commitsLoading, setCommitsLoading] = useState(false)
+  const [commitSkip, setCommitSkip] = useState(0)
+  const [commitsExhausted, setCommitsExhausted] = useState(false)
+  /** The commit chosen as the task source. null = start from current HEAD.
+   * When set, the worktree branches from `<hash>^` (one commit before), so
+   * contestants never see this commit's changes — only its message as the
+   * task. */
+  const [selectedCommit, setSelectedCommit] = useState<GitLogEntry | null>(null)
+
+  const checkGitRepo = (dir: string, cancelledRef: { current: boolean }) => {
+    setIsGitRepo(null)
+    getGitBranch(dir)
+      .then((branch) => {
+        if (!cancelledRef.current) setIsGitRepo(branch != null)
+      })
+      .catch(() => {
+        if (!cancelledRef.current) setIsGitRepo(false)
+      })
+  }
+
+  useEffect(() => {
+    if (!open) return
+    setSlots([])
+    setTask("")
+    setWorkingDir(null)
+    setFolderId(null)
+    setIsGitRepo(null)
+    setPermissionMode("default")
+    setBareMode(false)
+    setEffort("default")
+    setJudgeAgent(null)
+    setJudgeDimensions("")
+    setStartError(null)
+    setCommitPickerOpen(false)
+    setSelectedCommit(null)
+    // 复赛预填:上次配置的选手若仍可参与则沿用。
+    const last = loadLastLauncherConfig()
+    if (last && last.agents.length > 0) {
+      setSlots((prev) =>
+        prev.length > 0
+          ? prev
+          : last.agents.map((a) => ({
+              id: ++nextSlotId.current,
+              agentType: a.agentType,
+              label: a.label ?? "",
+              configValues: a.configValues ?? {},
+            }))
+      )
+      setTask(last.task ?? "")
+      setPermissionMode(last.permissionMode)
+      setBareMode(last.bareMode)
+      setEffort(last.effort)
+      setJudgeAgent(last.judgeAgent ?? null)
+      setJudgeDimensions(last.judgeDimensions?.join("\n") ?? "")
+    }
+    // The active tab decides where the arena runs. Draft tabs may lack a
+    // workingDir; fall back to the folder's own path.
+    if (activeTab?.folderId == null || activeTab.folderId < 0) return
+    const cancelled = { current: false }
+    const resolve = (id: number, dir: string) => {
+      setFolderId(id)
+      setWorkingDir(dir)
+      checkGitRepo(dir, cancelled)
+    }
+    if (activeTab.kind === "conversation" && activeTab.workingDir) {
+      resolve(activeTab.folderId, activeTab.workingDir)
+    } else {
+      getFolder(activeTab.folderId)
+        .then((folder) => {
+          if (!cancelled.current) resolve(folder.id, folder.path)
+        })
+        .catch(() => undefined)
+    }
+    return () => {
+      cancelled.current = true
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [open])
+
+  const handleInitGit = async () => {
+    if (!workingDir || initializing) return
+    setInitializing(true)
+    try {
+      await gitInit(workingDir)
+      setIsGitRepo(true)
+    } catch {
+      setIsGitRepo(false)
+    } finally {
+      setInitializing(false)
+    }
+  }
+
+  // 只列真正能跑的:安装到位(installed_version) + 未禁用 + 可用。
+  // 未安装的 agent 在 connect 的 preflight 会被拦,但那时回合/会话已创建,
+  // 留下的宿主会话会一直空转——所以 PK 干脆只收已就绪的选手。
+  const agents = useMemo(
+    () =>
+      rawAgents.filter(
+        (a) => a.enabled && a.available && a.installed_version != null
+      ),
+    [rawAgents]
+  )
+
+  const noFolder = open && folderId == null && activeTab != null
+  const taskValid = task.trim().length > 0
+  const selectionValid =
+    slots.length >= MIN_CONTESTANTS && slots.length <= MAX_CONTESTANTS
+  const canStart =
+    taskValid &&
+    selectionValid &&
+    folderId != null &&
+    workingDir != null &&
+    isGitRepo === true
+
+  const addSlot = (agentType: AgentType) => {
+    setSlots((prev) =>
+      prev.length >= MAX_CONTESTANTS
+        ? prev
+        : [
+            ...prev,
+            {
+              id: ++nextSlotId.current,
+              agentType,
+              label: "",
+              configValues: {},
+            },
+          ]
+    )
+  }
+
+  const removeSlot = (index: number) => {
+    setSlots((prev) => prev.filter((_, i) => i !== index))
+  }
+
+  const updateSlotModel = (
+    index: number,
+    configId: string,
+    value: string,
+    label: string
+  ) => {
+    setSlots((prev) =>
+      prev.map((slot, i) =>
+        i === index
+          ? {
+              ...slot,
+              label,
+              configValues: { ...slot.configValues, [configId]: value },
+            }
+          : slot
+      )
+    )
+  }
+
+  const handleStart = async () => {
+    if (!canStart || folderId == null || workingDir == null) return
+    // 开赛前预检:任何选手不可用就中止,不建回合、不留残留会话。
+    // Deduplicate agent types — the same agent in two slots only needs one check.
+    const uniqueAgents = Array.from(new Set(slots.map((s) => s.agentType)))
+    for (const agentType of uniqueAgents) {
+      try {
+        const status = await acpGetAgentStatus(agentType)
+        if (!status.enabled || !status.available || !status.installed_version) {
+          setStartError(t("agentNotReady", { agent: getAgentLabel(agentType) }))
+          return
+        }
+      } catch {
+        setStartError(
+          t("agentCheckFailed", { agent: getAgentLabel(agentType) })
+        )
+        return
+      }
+    }
+    setStartError(null)
+    const parsedDimensions = judgeDimensions
+      .split("\n")
+      .map((d) => d.trim())
+      .filter(Boolean)
+    const agentsPayload = slots.map((s) =>
+      s.label.trim() || Object.keys(s.configValues).length > 0
+        ? {
+            agentType: s.agentType,
+            ...(s.label.trim() ? { label: s.label.trim() } : {}),
+            configValues: s.configValues,
+          }
+        : { agentType: s.agentType }
+    )
+    saveLastLauncherConfig({
+      agents: agentsPayload,
+      permissionMode,
+      bareMode,
+      effort,
+      task: task.trim(),
+      judgeAgent,
+      judgeDimensions: parsedDimensions.length > 0 ? parsedDimensions : null,
+    })
+    // Selected a commit → worktree branches from its PARENT, so contestants
+    // start before that commit and never see its changes. null = current HEAD.
+    const baseCommit = selectedCommit ? `${selectedCommit.hash}^` : null
+    const round = await createRound({
+      task: task.trim(),
+      folderId,
+      workingDir,
+      agents: agentsPayload,
+      permissionMode,
+      bareMode,
+      effort,
+      judgeAgent,
+      judgeDimensions: parsedDimensions.length > 0 ? parsedDimensions : null,
+      baseCommit,
+    })
+    setLauncherOpen(false)
+    openPkRoundTab(round.id, round.folderId, round.task)
+    // The orchestrator (in PkArenaHost) picks the new round up from the store.
+  }
+
+  return (
+    <Dialog open={open} onOpenChange={setLauncherOpen}>
+      <DialogContent className="flex max-h-[calc(100dvh-2rem)] w-full max-w-2xl flex-col gap-0 overflow-hidden rounded-2xl p-0">
+        <DialogTitle className="border-b border-border px-6 py-4 text-base font-semibold">
+          {t("title")}
+        </DialogTitle>
+        <DialogDescription className="sr-only">
+          {t("description")}
+        </DialogDescription>
+        <div className="min-h-0 flex-1 space-y-6 overflow-y-auto px-6 py-5">
+          <section className="rounded-xl border border-border bg-muted/20 p-4">
+            <div className="mb-3 flex items-center justify-between gap-3">
+              <div className="text-sm font-medium text-foreground">
+                {t("contestantsLabel", {
+                  min: MIN_CONTESTANTS,
+                  max: MAX_CONTESTANTS,
+                })}
+              </div>
+              <span className="text-xs tabular-nums text-muted-foreground">
+                {slots.length}/{MAX_CONTESTANTS}
+              </span>
+            </div>
+            {noFolder ? (
+              <div className="text-xs text-muted-foreground">
+                {t("noFolderHint")}
+              </div>
+            ) : null}
+            {workingDir != null && isGitRepo === false ? (
+              <div className="flex items-center gap-2 text-xs text-muted-foreground">
+                <span className="min-w-0 flex-1">{t("notAGitRepo")}</span>
+                <button
+                  type="button"
+                  onClick={() => void handleInitGit()}
+                  disabled={initializing}
+                  className="shrink-0 rounded-md border border-border px-2 py-1 text-xs text-foreground hover:bg-muted disabled:opacity-50"
+                >
+                  {initializing ? t("initializing") : t("initGitRepo")}
+                </button>
+              </div>
+            ) : null}
+            <div className="flex flex-wrap gap-2">
+              {agents.map((agent) => {
+                const slotsFull = slots.length >= MAX_CONTESTANTS
+                return (
+                  <button
+                    key={agent.agent_type}
+                    type="button"
+                    onClick={() => addSlot(agent.agent_type)}
+                    disabled={slotsFull}
+                    aria-label={t("addContestant", { agent: agent.name })}
+                    className={cn(
+                      "inline-flex items-center gap-1.5 rounded-full border px-3 py-1.5 text-sm transition-colors",
+                      "border-border text-muted-foreground hover:bg-muted",
+                      "disabled:cursor-not-allowed disabled:opacity-40 disabled:hover:bg-transparent"
+                    )}
+                  >
+                    <AgentIcon
+                      agentType={agent.agent_type}
+                      className="size-4"
+                    />
+                    {agent.name}
+                    <span className="text-xs text-muted-foreground">+</span>
+                  </button>
+                )
+              })}
+            </div>
+            {slots.length > 0 ? (
+              <div className="mt-4 flex flex-col gap-2">
+                {slots.map((slot, index) => {
+                  if (!slot.agentType) return null
+                  const agentName =
+                    agents.find((a) => a.agent_type === slot.agentType)?.name ??
+                    slot.agentType
+                  return (
+                    <div
+                      key={slot.id}
+                      className="flex items-center gap-3 rounded-xl border border-border bg-background px-3 py-2.5 shadow-xs"
+                    >
+                      <span className="flex size-8 shrink-0 items-center justify-center rounded-lg bg-muted">
+                        <AgentIcon
+                          agentType={slot.agentType}
+                          className="size-4"
+                        />
+                      </span>
+                      <div className="w-32 min-w-0 shrink-0">
+                        <div className="truncate text-sm font-medium text-foreground">
+                          {agentName}
+                        </div>
+                        <div className="text-[11px] text-muted-foreground">
+                          {t("slotNumber", { number: index + 1 })}
+                        </div>
+                      </div>
+                      <SlotModelSelect
+                        agentType={slot.agentType}
+                        workingDir={workingDir}
+                        configValues={slot.configValues}
+                        onChange={(configId, value, label) =>
+                          updateSlotModel(index, configId, value, label)
+                        }
+                        loadingLabel={t("modelLoading")}
+                        unavailableLabel={t("modelUnavailable")}
+                        failedLabel={t("modelLoadFailed")}
+                        retryLabel={t("retryModelLoad")}
+                      />
+                      <button
+                        type="button"
+                        onClick={() => removeSlot(index)}
+                        aria-label={t("removeSlot")}
+                        className="shrink-0 rounded-md p-1.5 text-muted-foreground transition-colors hover:bg-muted hover:text-foreground"
+                      >
+                        <X className="size-3.5" />
+                      </button>
+                    </div>
+                  )
+                })}
+              </div>
+            ) : null}
+            {slots.length > 0 && slots.length < MIN_CONTESTANTS ? (
+              <div className="mt-2 text-xs text-muted-foreground">
+                {t("needMore", { count: MIN_CONTESTANTS })}
+              </div>
+            ) : null}
+          </section>
+          <section>
+            <label
+              htmlFor="pk-task"
+              className="mb-2 text-sm font-medium text-foreground"
+            >
+              {t("taskLabel")}
+            </label>
+            {/* ── 创意 PK:一键模板 ── */}
+            <div className="mb-1 text-xs font-medium text-muted-foreground">
+              {t("creativeTemplates")}
+            </div>
+            <div className="mb-3 flex flex-wrap items-center gap-1.5">
+              {PK_TEMPLATES.map((tpl) => (
+                <button
+                  key={tpl.id}
+                  type="button"
+                  title={tpl.task}
+                  onClick={() => setTask(tpl.task)}
+                  className="inline-flex items-center gap-1 rounded-full border border-border px-2.5 py-1 text-xs text-muted-foreground transition-colors hover:bg-muted hover:text-foreground"
+                >
+                  <span>{tpl.emoji}</span>
+                  {t(`templates.${tpl.labelKey}` as "templates.pelican")}
+                </button>
+              ))}
+            </div>
+
+            {/* ── 真实工程 PK:起点选择 ── */}
+            {workingDir != null && isGitRepo === true ? (
+              <>
+                <div className="mb-1 text-xs font-medium text-muted-foreground">
+                  {t("realEngineering")}
+                </div>
+                <div className="mb-2 flex flex-wrap items-center gap-1.5">
+                  <button
+                    type="button"
+                    onClick={async () => {
+                      if (commitPickerOpen) {
+                        setCommitPickerOpen(false)
+                        return
+                      }
+                      setCommitSkip(0)
+                      setCommitsExhausted(false)
+                      setCommitsLoading(true)
+                      setCommitPickerOpen(true)
+                      try {
+                        const result = await gitLog(workingDir, 10)
+                        setCommits(result.entries)
+                        setCommitsExhausted(result.entries.length < 10)
+                      } catch {
+                        setCommits([])
+                      } finally {
+                        setCommitsLoading(false)
+                      }
+                    }}
+                    className={cn(
+                      "inline-flex items-center gap-1 rounded-full border px-2.5 py-1 text-xs transition-colors",
+                      commitPickerOpen || selectedCommit
+                        ? "border-primary bg-primary/10 text-foreground"
+                        : "border-border text-muted-foreground hover:bg-muted hover:text-foreground"
+                    )}
+                  >
+                    {t("startPoint")}
+                  </button>
+                  {selectedCommit ? (
+                    <button
+                      type="button"
+                      onClick={() => {
+                        setSelectedCommit(null)
+                        setCommitPickerOpen(false)
+                      }}
+                      className="inline-flex items-center gap-1 rounded-full border border-border px-2 py-1 text-xs text-muted-foreground hover:bg-muted"
+                    >
+                      <span className="font-mono">
+                        {selectedCommit.hash.slice(0, 7)}
+                      </span>
+                      <span className="max-w-[180px] truncate">
+                        {selectedCommit.message.split("\n")[0]}
+                      </span>
+                      <X className="size-3 shrink-0" />
+                    </button>
+                  ) : (
+                    <span className="text-xs text-muted-foreground">
+                      {t("fromHead")}
+                    </span>
+                  )}
+                </div>
+                {commitPickerOpen ? (
+                  <div className="mb-2 max-h-48 overflow-auto rounded-lg border border-border bg-background">
+                    {commitsLoading ? (
+                      <div className="px-3 py-2 text-xs text-muted-foreground">
+                        {t("loadingCommits")}
+                      </div>
+                    ) : commits.length === 0 ? (
+                      <div className="px-3 py-2 text-xs text-muted-foreground">
+                        {t("noCommits")}
+                      </div>
+                    ) : (
+                      <>
+                        {commits.map((commit) => (
+                          <button
+                            key={commit.hash}
+                            type="button"
+                            onClick={() => {
+                              // Use the commit message as the task so the
+                              // contestant gets a clear goal. The worktree will
+                              // branch from <hash>^ — one commit BEFORE this —
+                              // so the contestant never sees these changes.
+                              setTask(commit.message.split("\n")[0])
+                              setSelectedCommit(commit)
+                              setCommitPickerOpen(false)
+                            }}
+                            className="block w-full px-3 py-2 text-left hover:bg-muted"
+                            title={commit.message}
+                          >
+                            <div className="flex items-center gap-2">
+                              <span className="font-mono text-xs text-muted-foreground">
+                                {commit.hash.slice(0, 7)}
+                              </span>
+                              <span className="truncate text-xs text-foreground">
+                                {commit.message.split("\n")[0]}
+                              </span>
+                            </div>
+                            <div className="mt-0.5 flex items-center gap-3 text-[11px] text-muted-foreground">
+                              <span>{commit.author}</span>
+                              <span>
+                                {new Date(commit.date).toLocaleDateString()}
+                              </span>
+                              {commit.files.length > 0 ? (
+                                <span>📄 {commit.files.length} 文件</span>
+                              ) : null}
+                            </div>
+                          </button>
+                        ))}
+                        {!commitsExhausted ? (
+                          <button
+                            type="button"
+                            onClick={async () => {
+                              const nextSkip = commitSkip + 10
+                              setCommitsLoading(true)
+                              try {
+                                const result = await gitLog(
+                                  workingDir,
+                                  10,
+                                  undefined,
+                                  undefined,
+                                  nextSkip
+                                )
+                                setCommits((prev) => [
+                                  ...prev,
+                                  ...result.entries,
+                                ])
+                                setCommitSkip(nextSkip)
+                                setCommitsExhausted(result.entries.length < 10)
+                              } catch {
+                                // ignore
+                              } finally {
+                                setCommitsLoading(false)
+                              }
+                            }}
+                            disabled={commitsLoading}
+                            className="block w-full border-t border-border px-3 py-2 text-center text-xs text-muted-foreground hover:bg-muted disabled:opacity-50"
+                          >
+                            {commitsLoading ? "…" : t("loadMore")}
+                          </button>
+                        ) : null}
+                      </>
+                    )}
+                  </div>
+                ) : null}
+                {selectedCommit ? (
+                  <p className="mb-2 text-[11px] leading-relaxed text-muted-foreground">
+                    {t("startPointHint")}
+                  </p>
+                ) : null}
+              </>
+            ) : null}
+            <textarea
+              id="pk-task"
+              value={task}
+              onChange={(event) => setTask(event.target.value)}
+              placeholder={t("taskPlaceholder")}
+              rows={5}
+              className="w-full resize-none rounded-lg border border-border bg-background px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground focus:outline-none focus:ring-2 focus:ring-ring"
+            />
+          </section>
+          <section>
+            <div className="mb-2 text-sm font-medium text-foreground">
+              {t("permissionLabel")}
+            </div>
+            <div className="flex flex-col gap-1.5">
+              {(["default", "acceptEdits", "bypassPermissions"] as const).map(
+                (mode) => (
+                  <label
+                    key={mode}
+                    className="flex cursor-pointer items-center gap-2 text-sm text-foreground"
+                  >
+                    <input
+                      type="radio"
+                      name="pk-permission"
+                      checked={permissionMode === mode}
+                      onChange={() => setPermissionMode(mode)}
+                      className="accent-foreground"
+                    />
+                    <span className="font-medium">
+                      {t(`permissionOptions.${mode}`)}
+                    </span>
+                    <span className="text-xs text-muted-foreground">
+                      {t(`permissionHints.${mode}`)}
+                    </span>
+                  </label>
+                )
+              )}
+            </div>
+            <div className="mt-1.5 text-xs text-muted-foreground">
+              {t("permissionNote")}
+            </div>
+          </section>
+          <section>
+            <div className="mb-2 text-sm font-medium text-foreground">
+              {t("effortLabel")}
+            </div>
+            <div className="flex flex-wrap gap-1.5">
+              {(["default", "low", "medium", "high", "max"] as const).map(
+                (level) => (
+                  <button
+                    key={level}
+                    type="button"
+                    onClick={() => setEffort(level)}
+                    aria-pressed={effort === level}
+                    className={cn(
+                      "rounded-full border px-3 py-1 text-xs transition-colors",
+                      effort === level
+                        ? "border-primary bg-primary/10 text-foreground"
+                        : "border-border text-muted-foreground hover:bg-muted"
+                    )}
+                  >
+                    {t(`effortOptions.${level}`)}
+                  </button>
+                )
+              )}
+            </div>
+            <div className="mt-1.5 text-xs text-muted-foreground">
+              {t("effortNote")}
+            </div>
+          </section>
+          <label className="flex cursor-pointer items-start gap-2 text-sm">
+            <input
+              type="checkbox"
+              checked={bareMode}
+              onChange={(event) => setBareMode(event.target.checked)}
+              className="mt-0.5 accent-foreground"
+            />
+            <span>
+              <span className="font-medium text-foreground">
+                {t("bareModeLabel")}
+              </span>
+              <span className="block text-xs text-muted-foreground">
+                {t("bareModeHint")}
+              </span>
+            </span>
+          </label>
+          <section>
+            <div className="mb-2 text-sm font-medium text-foreground">
+              {t("judgeLabel")}
+            </div>
+            <div className="flex flex-wrap gap-2">
+              {/* "No judge" chip */}
+              <button
+                type="button"
+                onClick={() => setJudgeAgent(null)}
+                aria-pressed={judgeAgent === null}
+                className={cn(
+                  "inline-flex items-center gap-1.5 rounded-full border px-3 py-1.5 text-sm transition-colors",
+                  judgeAgent === null
+                    ? "border-primary bg-primary/10 text-foreground"
+                    : "border-border text-muted-foreground hover:bg-muted"
+                )}
+              >
+                {t("judgeNone")}
+              </button>
+              {agents.map((agent) => {
+                const isSelected = judgeAgent === agent.agent_type
+                const isContestant = slots.some(
+                  (s) => s.agentType === agent.agent_type
+                )
+                return (
+                  <button
+                    key={agent.agent_type}
+                    type="button"
+                    onClick={() =>
+                      setJudgeAgent(
+                        judgeAgent === agent.agent_type
+                          ? null
+                          : agent.agent_type
+                      )
+                    }
+                    aria-pressed={isSelected}
+                    className={cn(
+                      "inline-flex items-center gap-1.5 rounded-full border px-3 py-1.5 text-sm transition-colors",
+                      isSelected
+                        ? "border-primary bg-primary/10 text-foreground"
+                        : "border-border text-muted-foreground hover:bg-muted",
+                      isContestant && !isSelected && "opacity-40"
+                    )}
+                  >
+                    <AgentIcon
+                      agentType={agent.agent_type}
+                      className="size-4"
+                    />
+                    {agent.name}
+                  </button>
+                )
+              })}
+            </div>
+            <div className="mt-1.5 text-xs text-muted-foreground">
+              {t("judgeHint")}
+            </div>
+            {judgeAgent != null && (
+              <div className="mt-2.5">
+                <div className="mb-1.5 text-xs font-medium text-foreground">
+                  {t("judgeDimensionsLabel")}
+                </div>
+                <textarea
+                  value={judgeDimensions}
+                  onChange={(e) => setJudgeDimensions(e.target.value)}
+                  placeholder={t("judgeDimensionsPlaceholder")}
+                  rows={3}
+                  className="w-full resize-none rounded-lg border border-border bg-background px-3 py-2 text-xs text-foreground placeholder:text-muted-foreground focus:outline-none focus:ring-2 focus:ring-ring"
+                />
+                <div className="mt-1 text-xs text-muted-foreground">
+                  {t("judgeDimensionsHint")}
+                </div>
+              </div>
+            )}
+          </section>
+        </div>
+        {startError != null ? (
+          <div className="border-t border-border px-5 py-2 text-xs text-red-600 dark:text-red-400">
+            {startError}
+          </div>
+        ) : null}
+        <div className="flex items-center justify-between gap-3 border-t border-border bg-background px-6 py-3.5">
+          <span className="text-xs text-muted-foreground">
+            {t("selectedCount", {
+              selected: slots.length,
+              min: MIN_CONTESTANTS,
+              max: MAX_CONTESTANTS,
+            })}
+          </span>
+          <div className="flex gap-2">
+            <button
+              type="button"
+              onClick={() => setLauncherOpen(false)}
+              className="rounded-md px-3 py-1.5 text-sm text-muted-foreground hover:bg-muted"
+            >
+              {t("cancel")}
+            </button>
+            <button
+              type="button"
+              disabled={!canStart}
+              onClick={() => void handleStart()}
+              className="rounded-md bg-primary px-4 py-1.5 text-sm font-medium text-primary-foreground disabled:opacity-50"
+            >
+              {t("start")}
+            </button>
+          </div>
+        </div>
+      </DialogContent>
+    </Dialog>
+  )
+}
+
+function findModelOption(
+  options: SessionConfigOptionInfo[]
+): SessionConfigOptionInfo | null {
+  return (
+    options.find(
+      (option) =>
+        option.kind.type === "select" &&
+        (option.id === "model" ||
+          option.id === "model_id" ||
+          option.category === "model")
+    ) ?? null
+  )
+}
+
+function modelValueLabel(
+  option: SessionConfigOptionInfo,
+  value: string
+): string {
+  if (option.kind.type !== "select") return value
+  for (const group of option.kind.groups) {
+    const match = group.options.find((item) => item.value === value)
+    if (match) return match.name
+  }
+  return option.kind.options.find((item) => item.value === value)?.name ?? value
+}
+
+function hasModelValue(
+  option: SessionConfigOptionInfo,
+  value: string
+): boolean {
+  if (option.kind.type !== "select") return false
+  return (
+    option.kind.options.some((item) => item.value === value) ||
+    option.kind.groups.some((group) =>
+      group.options.some((item) => item.value === value)
+    )
+  )
+}
+
+function SlotModelSelect({
+  agentType,
+  workingDir,
+  configValues,
+  onChange,
+  loadingLabel,
+  unavailableLabel,
+  failedLabel,
+  retryLabel,
+}: {
+  agentType: AgentType
+  workingDir: string | null
+  configValues: Record<string, string>
+  onChange: (configId: string, value: string, label: string) => void
+  loadingLabel: string
+  unavailableLabel: string
+  failedLabel: string
+  retryLabel: string
+}) {
+  const { snapshot, loading, error, reload } = useAgentOptions(
+    agentType,
+    workingDir
+  )
+  const modelOption = useMemo(
+    () => findModelOption(snapshot?.config_options ?? []),
+    [snapshot]
+  )
+  const configuredValue = modelOption ? configValues[modelOption.id] : null
+  const currentValue =
+    modelOption?.kind.type === "select"
+      ? configuredValue && hasModelValue(modelOption, configuredValue)
+        ? configuredValue
+        : modelOption.kind.current_value
+      : null
+
+  useEffect(() => {
+    if (
+      modelOption?.kind.type !== "select" ||
+      !currentValue ||
+      configValues[modelOption.id] === currentValue
+    ) {
+      return
+    }
+    onChange(
+      modelOption.id,
+      currentValue,
+      modelValueLabel(modelOption, currentValue)
+    )
+  }, [configValues, currentValue, modelOption, onChange])
+
+  if (loading) {
+    return (
+      <div className="flex min-w-0 flex-1 items-center gap-2 text-xs text-muted-foreground">
+        <Loader2 className="size-3.5 animate-spin" aria-hidden />
+        <span className="truncate">{loadingLabel}</span>
+      </div>
+    )
+  }
+  if (error) {
+    return (
+      <div className="flex min-w-0 flex-1 items-center gap-2 text-xs text-destructive">
+        <span className="min-w-0 flex-1 truncate" title={error}>
+          {failedLabel}
+        </span>
+        <button
+          type="button"
+          onClick={reload}
+          aria-label={retryLabel}
+          title={retryLabel}
+          className="rounded-md p-1.5 hover:bg-muted"
+        >
+          <RefreshCw className="size-3.5" />
+        </button>
+      </div>
+    )
+  }
+  if (!modelOption || modelOption.kind.type !== "select") {
+    return (
+      <div className="min-w-0 flex-1 text-xs text-muted-foreground">
+        {unavailableLabel}
+      </div>
+    )
+  }
+
+  return (
+    <Select
+      value={currentValue ?? undefined}
+      onValueChange={(value) =>
+        onChange(modelOption.id, value, modelValueLabel(modelOption, value))
+      }
+    >
+      <SelectTrigger
+        size="sm"
+        className="min-w-0 flex-1 rounded-lg bg-background"
+        aria-label={modelOption.name}
+      >
+        <SelectValue placeholder={modelOption.name} />
+      </SelectTrigger>
+      <SelectContent position="popper" align="start">
+        {modelOption.kind.groups.length > 0
+          ? modelOption.kind.groups.map((group) => (
+              <SelectGroup key={group.group}>
+                <SelectLabel>{group.name}</SelectLabel>
+                {group.options.map((item) => (
+                  <SelectItem
+                    key={`${group.group}-${item.value}`}
+                    value={item.value}
+                  >
+                    {item.name}
+                  </SelectItem>
+                ))}
+              </SelectGroup>
+            ))
+          : modelOption.kind.options.map((item) => (
+              <SelectItem key={item.value} value={item.value}>
+                {item.name}
+              </SelectItem>
+            ))}
+      </SelectContent>
+    </Select>
+  )
+}
diff --git a/src/components/pk/pk-minimized-pill.tsx b/src/components/pk/pk-minimized-pill.tsx
new file mode 100644
index 000000000..4a59cb65a
--- /dev/null
+++ b/src/components/pk/pk-minimized-pill.tsx
@@ -0,0 +1,96 @@
+"use client"
+
+import { useEffect, useState } from "react"
+import { useTranslations } from "next-intl"
+import { Swords, X } from "lucide-react"
+import { getArenaPillRound } from "@/components/pk/pk-arena-policy"
+import { cn } from "@/lib/utils"
+import { usePkArenaStore } from "@/stores/pk-arena-store"
+import { useTabStore } from "@/stores/tab-store"
+
+/**
+ * 竞技场最小化胶囊。大窗关闭后,只要还有进行中(ready/running)的回合,
+ * 右下角常驻这个小胶囊:显示 ⚔ + 已完成/总数,随时点开回到全屏——
+ * 比赛在后台继续,用户该干嘛干嘛。手动 ✕ 只把它藏起来,回合不受影响;
+ * 左上角 ⚔ 或新回合会自动把它唤回来。
+ */
+export function PkMinimizedPill() {
+  const t = useTranslations("PkArena.minimized")
+  const rounds = usePkArenaStore((s) => s.rounds)
+  const activeRoundId = usePkArenaStore((s) => s.activeRoundId)
+  const pillDismissed = usePkArenaStore((s) => s.pillDismissed)
+  const setPillDismissed = usePkArenaStore((s) => s.setPillDismissed)
+  const activeTabId = useTabStore((s) => s.activeTabId)
+  const openPkRoundTab = useTabStore((s) => s.openPkRoundTab)
+
+  const round = getArenaPillRound(rounds, activeRoundId)
+  const isRoundTabActive =
+    round != null && activeTabId === `pk-round-${round.id}`
+  const roundLive = round?.status === "ready" || round?.status === "running"
+  const tStatus = useTranslations("PkArena.arena.roundStatus")
+  const [now, setNow] = useState(() => Date.now())
+  useEffect(() => {
+    if (!round || !roundLive || isRoundTabActive) return
+    const timer = window.setInterval(() => setNow(Date.now()), 1000)
+    return () => window.clearInterval(timer)
+  }, [round, roundLive, isRoundTabActive])
+
+  const visible =
+    round != null && roundLive && !isRoundTabActive && !pillDismissed
+  if (!visible || !round) {
+    return null
+  }
+
+  const done = round.contestants.filter(
+    (c) =>
+      c.status === "done" || c.status === "error" || c.status === "canceled"
+  ).length
+  const total = round.contestants.length
+  const elapsed = Math.round((now - round.createdAt) / 1000)
+
+  return (
+    <div
+      className="fixed bottom-16 right-4 z-50 flex items-center gap-2 rounded-full border border-border bg-card px-3 py-1.5 shadow-lg"
+      data-testid="pk-minimized-pill"
+    >
+      <button
+        type="button"
+        onClick={() => {
+          setPillDismissed(false)
+          openPkRoundTab(round.id, round.folderId, round.task)
+        }}
+        className="flex items-center gap-2 text-sm text-foreground hover:opacity-80"
+        title={t("restore")}
+      >
+        <Swords className="size-4 text-primary" />
+        <span className="tabular-nums font-medium">
+          {done}/{total}
+        </span>
+        <span className="hidden text-xs text-muted-foreground sm:inline">
+          {tStatus(round.status)}
+          {roundLive && elapsed > 0 ? ` · ${elapsed}s` : ""}
+        </span>
+        <span
+          className={cn(
+            "size-2 rounded-full",
+            round.status === "ready" && "bg-amber-500",
+            round.status === "running" && "animate-pulse bg-emerald-500",
+            round.status === "finished" && "bg-emerald-500",
+            round.status === "canceled" && "bg-muted-foreground/60",
+            round.status === "interrupted" && "bg-orange-500"
+          )}
+          aria-hidden
+        />
+      </button>
+      <button
+        type="button"
+        onClick={() => setPillDismissed(true)}
+        className="text-muted-foreground hover:text-foreground"
+        title={t("dismiss")}
+        aria-label={t("dismiss")}
+      >
+        <X className="size-3.5" />
+      </button>
+    </div>
+  )
+}
diff --git a/src/components/pk/pk-scoreboard.tsx b/src/components/pk/pk-scoreboard.tsx
new file mode 100644
index 000000000..1448e2596
--- /dev/null
+++ b/src/components/pk/pk-scoreboard.tsx
@@ -0,0 +1,160 @@
+"use client"
+
+import { forwardRef, useEffect, useState } from "react"
+import { useTranslations } from "next-intl"
+import { AgentIcon } from "@/components/agent-icon"
+import { getAgentLabel } from "@/lib/custom-agents"
+import { cn } from "@/lib/utils"
+import type { PkContestant } from "@/stores/pk-arena-store"
+
+/**
+ * One row per contestant: identity, live status, and the three scoreboard
+ * numbers (duration / output tokens / turns). Forwarded as a ref so the
+ * arena can export it as a share image without the dialog chrome.
+ */
+
+function formatDuration(ms: number): string {
+  const seconds = Math.round(ms / 1000)
+  if (seconds < 60) return `${seconds}s`
+  const minutes = Math.floor(seconds / 60)
+  return `${minutes}m${String(seconds % 60).padStart(2, "0")}s`
+}
+
+function formatTokens(n: number): string {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`
+  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`
+  return String(n)
+}
+
+const STATUS_DOT: Record<PkContestant["status"], string> = {
+  preparing: "bg-muted-foreground/50",
+  connecting: "bg-sky-500 animate-pulse",
+  ready: "bg-amber-400",
+  running: "bg-emerald-500 animate-pulse",
+  done: "bg-emerald-600",
+  error: "bg-red-500",
+  canceled: "bg-muted-foreground/50",
+}
+
+/** Literal keys — next-intl's typed messages reject dynamic concatenation. */
+function useContestantStatusLabel() {
+  const t = useTranslations("PkArena.scoreboard")
+  const labels = {
+    preparing: t("status.preparing"),
+    connecting: t("status.connecting"),
+    ready: t("status.ready"),
+    running: t("status.running"),
+    done: t("status.done"),
+    error: t("status.error"),
+    canceled: t("status.canceled"),
+  }
+  return (status: PkContestant["status"]) => labels[status]
+}
+
+export const PkScoreboard = forwardRef<
+  HTMLDivElement,
+  { contestants: PkContestant[] }
+>(function PkScoreboard({ contestants }, ref) {
+  const t = useTranslations("PkArena.scoreboard")
+  const statusLabel = useContestantStatusLabel()
+
+  // The ticking clock lives HERE, not in the dialog: a dialog-level `now`
+  // re-rendered four streaming transcript panes once a second and made the
+  // arena crawl (field report: "非常卡"). Scoped to the scoreboard, only
+  // these small cards re-render.
+  const anyLive = contestants.some(
+    (c) => c.status === "running" || c.status === "connecting"
+  )
+  const [now, setNow] = useState(() => Date.now())
+  useEffect(() => {
+    if (!anyLive) return
+    const timer = window.setInterval(() => setNow(Date.now()), 1000)
+    return () => window.clearInterval(timer)
+  }, [anyLive])
+
+  return (
+    <div
+      ref={ref}
+      className="flex gap-2 overflow-x-auto bg-background px-3 py-2"
+      data-testid="pk-scoreboard"
+    >
+      {contestants.map((contestant) => {
+        const elapsed =
+          contestant.durationMs ??
+          (contestant.startedAt != null ? now - contestant.startedAt : null)
+        const live =
+          contestant.status === "running" || contestant.status === "connecting"
+        return (
+          <div
+            key={contestant.slot}
+            className="flex w-56 shrink-0 items-center gap-2.5 rounded-lg border border-border bg-card px-3 py-2"
+          >
+            <span
+              className={cn(
+                "size-2 shrink-0 rounded-full",
+                STATUS_DOT[contestant.status]
+              )}
+              aria-hidden
+            />
+            <span className="inline-flex h-7 w-7 shrink-0 items-center justify-center rounded-md border border-border bg-background">
+              <AgentIcon agentType={contestant.agentType} className="size-4" />
+            </span>
+            <div className="min-w-0 flex-1">
+              <div className="truncate text-sm font-medium text-foreground">
+                {getAgentLabel(contestant.agentType)}
+                {contestant.label ? ` · ${contestant.label}` : ""}
+              </div>
+              <div className="flex items-baseline gap-2 text-xs text-muted-foreground">
+                <span className="tabular-nums">
+                  {statusLabel(contestant.status)}
+                </span>
+                {elapsed != null ? (
+                  <>
+                    <span aria-hidden>·</span>
+                    <span
+                      className={cn(
+                        "tabular-nums",
+                        live && "font-medium text-foreground"
+                      )}
+                    >
+                      {formatDuration(elapsed)}
+                    </span>
+                  </>
+                ) : null}
+                {contestant.usage ? (
+                  <>
+                    <span aria-hidden>·</span>
+                    <span
+                      className="tabular-nums"
+                      title={
+                        contestant.usage.tokensReported
+                          ? undefined
+                          : t("tokensUnavailableHint")
+                      }
+                    >
+                      {contestant.usage.tokensReported
+                        ? `${formatTokens(contestant.usage.outputTokens)} ${t("tokensUnit")}`
+                        : t("tokensUnavailable")}
+                    </span>
+                    <span aria-hidden>·</span>
+                    <span className="tabular-nums">
+                      {contestant.usage.turnCount} {t("turnsUnit")}
+                    </span>
+                  </>
+                ) : null}
+              </div>
+              {contestant.statusDetail ? (
+                <div
+                  className="truncate text-xs text-muted-foreground/80"
+                  title={contestant.statusDetail}
+                >
+                  {contestant.statusDetail}
+                </div>
+              ) : null}
+            </div>
+          </div>
+        )
+      })}
+    </div>
+  )
+})
diff --git a/src/components/tabs/tab-bar.tsx b/src/components/tabs/tab-bar.tsx
index fbdae3482..0a9264970 100644
--- a/src/components/tabs/tab-bar.tsx
+++ b/src/components/tabs/tab-bar.tsx
@@ -9,7 +9,7 @@ import { cn } from "@/lib/utils"
 import { useAppWorkspaceStore } from "@/stores/app-workspace-store"
 import { useActiveFolder } from "@/contexts/active-folder-context"
 import { useTabActions, useTabStore } from "@/contexts/tab-context"
-import type { TabItem as TabItemData } from "@/contexts/tab-context"
+import type { WorkspaceTabItem as TabItemData } from "@/contexts/tab-context"
 import { groupOfTab } from "@/stores/tab-store"
 import {
   firstLeafId,
@@ -210,14 +210,18 @@ export function TabBar({ groupId }: TabBarProps) {
       const selFolder = selTab
         ? allFolders.find((f) => f.id === selTab.folderId)
         : undefined
-      if (selTab?.isChat === true || selFolder?.kind === "chat") {
+      if (
+        (selTab?.kind === "conversation" && selTab.isChat === true) ||
+        selFolder?.kind === "chat"
+      ) {
         openChatModeTab(groupOptions)
         return
       }
       if (selTab && selFolder) {
         openNewConversationTab(
           selFolder.id,
-          selTab.workingDir ?? selFolder.path,
+          (selTab.kind === "conversation" ? selTab.workingDir : undefined) ??
+            selFolder.path,
           groupOptions
         )
         return
@@ -320,7 +324,8 @@ export function TabBar({ groupId }: TabBarProps) {
         // Drafts are group-bound: no cross-group drag, no move / split-and-move
         // menu items. Within-group sorting (the Reorder.Group itself) is
         // untouched. See `moveTabToGroup` for why.
-        const isDraft = tab.conversationId == null
+        const isDraft =
+          tab.kind === "conversation" && tab.conversationId == null
         // Neighbours of the active tab inset their workspace-bg baseline so the
         // active tab's transparent reverse-corner foot (which flares over them)
         // doesn't leave a stray line under it (globals.css `data-adjacent-active`).
diff --git a/src/components/tabs/tab-item.tsx b/src/components/tabs/tab-item.tsx
index 88a9f63b3..107f18f5f 100644
--- a/src/components/tabs/tab-item.tsx
+++ b/src/components/tabs/tab-item.tsx
@@ -23,7 +23,7 @@ import {
   ContextMenuTrigger,
 } from "@/components/ui/context-menu"
 import { useLongPressDrag } from "@/hooks/use-long-press-drag"
-import type { TabItem as TabItemData } from "@/contexts/tab-context"
+import type { WorkspaceTabItem as TabItemData } from "@/contexts/tab-context"
 import type { SplitDirection } from "@/lib/tab-group-layout"
 
 /** A group this tab could move to (every group EXCEPT the tab's own), labeled
@@ -326,9 +326,15 @@ export const TabItem = memo(function TabItem({
                   ]
             )}
           >
-            <ConversationStatusDot
-              status={tab.status as ConversationStatus | undefined}
-            />
+            {tab.kind === "pk" ? (
+              <span className="inline-flex h-4 shrink-0 items-center rounded border border-amber-500/35 bg-amber-500/10 px-1 font-mono text-[9px] font-bold tracking-[0.08em] text-amber-700 dark:text-amber-300">
+                PK
+              </span>
+            ) : (
+              <ConversationStatusDot
+                status={tab.status as ConversationStatus | undefined}
+              />
+            )}
             <span
               className={cn(
                 // Embedded: grow + shrink as the tab tightens, but instead of an
diff --git a/src/components/tabs/tab-strip-wiring.test.ts b/src/components/tabs/tab-strip-wiring.test.ts
index e0ce76c1f..32538529e 100644
--- a/src/components/tabs/tab-strip-wiring.test.ts
+++ b/src/components/tabs/tab-strip-wiring.test.ts
@@ -21,7 +21,9 @@ const tabItem = readFileSync(
  */
 describe("tab strip draft gating", () => {
   it("keeps drafts out of every cross-group affordance", () => {
-    expect(tabBar).toContain("const isDraft = tab.conversationId == null")
+    expect(tabBar).toContain(
+      'tab.kind === "conversation" && tab.conversationId == null'
+    )
     expect(tabBar).toContain("canSplitMove={canSplitMove && !isDraft}")
     expect(tabBar).toContain("canMoveToGroup={!isDraft}")
     // Both drag callbacks are withheld for drafts, so a draft drag can never
diff --git a/src/contexts/acp-connections-context.test.tsx b/src/contexts/acp-connections-context.test.tsx
index 409b9b814..98f4db0a7 100644
--- a/src/contexts/acp-connections-context.test.tsx
+++ b/src/contexts/acp-connections-context.test.tsx
@@ -354,7 +354,7 @@ describe("AcpConnectionsProvider cross-client viewer lifecycle", () => {
 
     // Start the viewer connect; it suspends on the pending snapshot AFTER
     // dispatching CONNECTION_CREATED (the entry now exists in the store).
-    let connectPromise: Promise<void> | undefined
+    let connectPromise: Promise<string | undefined> | undefined
     await act(async () => {
       connectPromise = h.actions!.connect(TAB, "claude_code", "/tmp/x", "s", 42)
     })
@@ -926,7 +926,7 @@ describe("AcpConnectionsProvider reconnect (status-icon button)", () => {
         })
     )
 
-    let firstConnect: Promise<void> | undefined
+    let firstConnect: Promise<string | undefined> | undefined
     await act(async () => {
       firstConnect = h.actions!.connect(
         TAB,
@@ -1197,7 +1197,7 @@ describe("AcpConnectionsProvider abandoned connect tears down only what it creat
           resolveConnect = res
         })
     )
-    let connectPromise: Promise<void> | undefined
+    let connectPromise: Promise<string | undefined> | undefined
     await act(async () => {
       connectPromise = h.actions!.connect(
         OTHER_TAB,
@@ -1227,7 +1227,7 @@ describe("AcpConnectionsProvider abandoned connect tears down only what it creat
           resolveConnect = res
         })
     )
-    let connectPromise: Promise<void> | undefined
+    let connectPromise: Promise<string | undefined> | undefined
     await act(async () => {
       connectPromise = h.actions!.connect(
         OTHER_TAB,
@@ -3206,7 +3206,7 @@ describe("connect() teardown races", () => {
           resolveProbe = res
         })
     )
-    let connectPromise: Promise<void> | undefined
+    let connectPromise: Promise<string | undefined> | undefined
     await act(async () => {
       connectPromise = h.actions!.connect(
         TAB,
@@ -3251,7 +3251,7 @@ describe("connect() teardown races", () => {
           resolveConnect = res
         })
     )
-    let connectPromise: Promise<void> | undefined
+    let connectPromise: Promise<string | undefined> | undefined
     await act(async () => {
       connectPromise = h.actions!.connect(
         TAB,
@@ -3283,7 +3283,7 @@ describe("connect() teardown races", () => {
     mountDesktop()
     await act(async () => {})
 
-    let connectPromise: Promise<void> | undefined
+    let connectPromise: Promise<string | undefined> | undefined
     await act(async () => {
       connectPromise = h.actions!.connect(
         TAB,
@@ -3390,7 +3390,7 @@ describe("connect() teardown races", () => {
           resolveProbe = res
         })
     )
-    let stalePromise: Promise<void> | undefined
+    let stalePromise: Promise<string | undefined> | undefined
     await act(async () => {
       stalePromise = h.actions!.connect(TAB, "claude_code", "/tmp/x", "sess-1")
     })
@@ -3455,7 +3455,7 @@ describe("connect() teardown races", () => {
         })
     )
     h.acpConnect.mockResolvedValue("rebuilt-conn")
-    let connectPromise: Promise<void> | undefined
+    let connectPromise: Promise<string | undefined> | undefined
     await act(async () => {
       connectPromise = h.actions!.connect(
         TAB,
@@ -3515,7 +3515,7 @@ describe("connect() teardown races", () => {
         })
     )
     h.acpConnect.mockResolvedValue("rebuilt-conn")
-    let connectPromise: Promise<void> | undefined
+    let connectPromise: Promise<string | undefined> | undefined
     await act(async () => {
       connectPromise = h.actions!.connect(
         TAB,
@@ -3576,7 +3576,7 @@ describe("connect() teardown races", () => {
           resolveProbe = res
         })
     )
-    let stalePromise: Promise<void> | undefined
+    let stalePromise: Promise<string | undefined> | undefined
     await act(async () => {
       stalePromise = h.actions!.connect(TAB, "claude_code", "/tmp/x", "sess-1")
     })
@@ -3616,7 +3616,7 @@ describe("connect() teardown races", () => {
           resolvePreflight = res
         })
     )
-    let inflight: Promise<void> | undefined
+    let inflight: Promise<string | undefined> | undefined
     await act(async () => {
       inflight = h.actions!.connect(TAB, "claude_code", "/tmp/x")
     })
diff --git a/src/contexts/acp-connections-context.tsx b/src/contexts/acp-connections-context.tsx
index c6614cba4..d1bf91d35 100644
--- a/src/contexts/acp-connections-context.tsx
+++ b/src/contexts/acp-connections-context.tsx
@@ -2493,8 +2493,10 @@ export interface AcpActionsValue {
     agentType: AgentType,
     workingDir?: string,
     sessionId?: string,
-    conversationId?: number
-  ): Promise<void>
+    conversationId?: number,
+    modeIdOverride?: string | null,
+    configValuesOverride?: Record<string, string> | null
+  ): Promise<string | undefined>
   /**
    * Release the connection for `contextKey`. The LOCAL entry always goes away
    * — a stranded one would make the next `connect()` take its "already
@@ -4841,7 +4843,9 @@ export function AcpConnectionsProvider({ children }: { children: ReactNode }) {
       agentType: AgentType,
       workingDir?: string,
       sessionId?: string,
-      conversationId?: number
+      conversationId?: number,
+      modeIdOverride?: string | null,
+      configValuesOverride?: Record<string, string> | null
     ) => {
       const request: ConnectRequest = {
         agentType,
@@ -4972,7 +4976,7 @@ export function AcpConnectionsProvider({ children }: { children: ReactNode }) {
             existing.status !== "disconnected" &&
             existing.status !== "error"
           ) {
-            return
+            return existing.connectionId
           }
           if (
             existing.status !== "disconnected" &&
@@ -5062,7 +5066,7 @@ export function AcpConnectionsProvider({ children }: { children: ReactNode }) {
               orphanConn.connectionId,
               orphanCursor
             )
-            return
+            return orphanConn.connectionId
           }
         }
 
@@ -5122,7 +5126,7 @@ export function AcpConnectionsProvider({ children }: { children: ReactNode }) {
             // Attached (or superseded) — done. Otherwise the connection died
             // between discovery and the attach, so fall through and spawn one
             // rather than leaving a viewer bound to a dead id.
-            if (attached) return
+            if (attached) return discovered.connection_id
           }
         }
 
@@ -5145,12 +5149,18 @@ export function AcpConnectionsProvider({ children }: { children: ReactNode }) {
         // re-open (the snapshot frame doesn't carry a `session_modes` event,
         // so the apply-on-event hook never fired).
         const savedPrefs = getSavedPrefsForConnect(agentType)
+        const initialModeId =
+          modeIdOverride !== undefined ? modeIdOverride : savedPrefs.modeId
+        const initialConfigValues =
+          configValuesOverride !== undefined
+            ? configValuesOverride
+            : savedPrefs.configValues
         const connectionId = await acpConnect(
           agentType,
           workingDir,
           sessionId,
-          savedPrefs.modeId,
-          savedPrefs.configValues
+          initialModeId,
+          initialConfigValues
         )
 
         // If disconnect was requested while connect was in flight, tear down
@@ -5260,6 +5270,7 @@ export function AcpConnectionsProvider({ children }: { children: ReactNode }) {
             }
           }
         }
+        return connectionId
       } catch (err) {
         const pendingRequest = pendingConnectRequestsRef.current.get(contextKey)
         const superseded =
@@ -5681,7 +5692,11 @@ export function AcpConnectionsProvider({ children }: { children: ReactNode }) {
   )
 
   const setMode = useCallback(async (contextKey: string, modeId: string) => {
-    const conn = storeRef.current.connections.get(contextKey)
+    const conn =
+      storeRef.current.connections.get(contextKey) ??
+      Array.from(storeRef.current.connections.values()).find(
+        (c) => c.connectionId === contextKey
+      )
     if (!conn) return
     // Persist user's mode selection to localStorage
     const modes =
@@ -5698,7 +5713,11 @@ export function AcpConnectionsProvider({ children }: { children: ReactNode }) {
 
   const setConfigOption = useCallback(
     async (contextKey: string, configId: string, valueId: string) => {
-      const conn = storeRef.current.connections.get(contextKey)
+      const conn =
+        storeRef.current.connections.get(contextKey) ??
+        Array.from(storeRef.current.connections.values()).find(
+          (c) => c.connectionId === contextKey
+        )
       if (!conn) return
       dispatch({
         type: "CONFIG_OPTION_CHANGED",
diff --git a/src/contexts/tab-context.test.tsx b/src/contexts/tab-context.test.tsx
index 6bab472c2..effa941a9 100644
--- a/src/contexts/tab-context.test.tsx
+++ b/src/contexts/tab-context.test.tsx
@@ -25,6 +25,10 @@ import {
   type OpenedDraftTarget,
 } from "@/stores/tab-store"
 import { leafIds } from "@/lib/tab-group-layout"
+import {
+  isConversationDraft,
+  type ConversationWorkspaceTab,
+} from "@/lib/workspace-tab"
 import {
   buildNewConversationDraftStorageKey,
   loadMessageInputDraftV2,
@@ -563,8 +567,12 @@ describe("TabProvider tab state transitions", () => {
     // Explicit caller intent, so the provisional-agent correction pass must not
     // "fix" it back to the resolved default once the agent list goes fresh.
     expect(
-      useTabStore.getState().rawTabs.find((t) => t.id === target?.tabId)
-        ?.agentTypeProvisional
+      useTabStore
+        .getState()
+        .rawTabs.find(
+          (t): t is ConversationWorkspaceTab =>
+            t.kind === "conversation" && t.id === target?.tabId
+        )?.agentTypeProvisional
     ).toBe(false)
   })
 
@@ -630,8 +638,12 @@ describe("TabProvider tab state transitions", () => {
     expect(draft?.agentType).toBe("codex")
     expect(draft?.isChat).toBe(true)
     expect(
-      useTabStore.getState().rawTabs.find((t) => t.id === chatDraftId)
-        ?.agentTypeProvisional
+      useTabStore
+        .getState()
+        .rawTabs.find(
+          (t): t is ConversationWorkspaceTab =>
+            t.kind === "conversation" && t.id === chatDraftId
+        )?.agentTypeProvisional
     ).toBe(false)
   })
 
@@ -1984,7 +1996,7 @@ describe("TabProvider tab groups", () => {
 
     expect(leaves()).toHaveLength(2)
     const g1 = newLeafBeside(home)
-    const draft = store().rawTabs.find((t) => t.conversationId == null)
+    const draft = store().rawTabs.find(isConversationDraft)
     expect(draft).toBeDefined()
     expect(draft?.folderId).toBe(1)
     expect(draft?.agentType).toBe("codex")
@@ -2008,7 +2020,7 @@ describe("TabProvider tab groups", () => {
       store().splitTab(chatDraftId, "right", { move: false })
     })
 
-    const drafts = store().rawTabs.filter((t) => t.conversationId == null)
+    const drafts = store().rawTabs.filter(isConversationDraft)
     expect(drafts).toHaveLength(2)
     const newDraft = drafts.find((t) => t.id !== chatDraftId)
     expect(newDraft?.isChat).toBe(true)
@@ -2219,26 +2231,61 @@ describe("TabProvider tab groups", () => {
       store().splitTab("conv-1-codex-1", "right", { move: false })
     })
     const g1 = newLeafBeside(home)
-    const draftInG1 = store().rawTabs.find((t) => t.conversationId == null)!
+    const draftInG1 = store().rawTabs.find(isConversationDraft)!
 
     // Focused group is g1 (the draft) — reuses that draft, no new tab.
     act(() => {
       store().openNewConversationTab(1, "/repo")
     })
-    expect(
-      store().rawTabs.filter((t) => t.conversationId == null)
-    ).toHaveLength(1)
+    expect(store().rawTabs.filter(isConversationDraft)).toHaveLength(1)
     expect(store().activeTabId).toBe(draftInG1.id)
 
     // Explicitly targeting the home group creates a second, per-group draft.
     act(() => {
       store().openNewConversationTab(1, "/repo", { targetGroup: home })
     })
-    const drafts = store().rawTabs.filter((t) => t.conversationId == null)
+    const drafts = store().rawTabs.filter(isConversationDraft)
     expect(drafts).toHaveLength(2)
     expect(drafts.map((d) => groupOfId(d.id)).sort()).toEqual([home, g1].sort())
   })
 
+  it("keeps multiple PK rounds as local workspace tabs that can be split", async () => {
+    const first = await renderWithTabs([tabItem(1, 1, true)])
+    const home = leaves()[0]
+
+    act(() => {
+      store().openPkRoundTab("41", 1, "First battle")
+      store().openPkRoundTab("42", 1, "Second battle")
+    })
+
+    expect(
+      store()
+        .rawTabs.filter((tab) => tab.kind === "pk")
+        .map((tab) => tab.id)
+    ).toEqual(["pk-round-41", "pk-round-42"])
+
+    act(() => {
+      store().splitTab("pk-round-42", "right", { move: true })
+    })
+
+    expect(selectIsSplit(store())).toBe(true)
+    expect(groupOfId("pk-round-42")).not.toBe(home)
+    const blob = JSON.parse(localStorage.getItem("workspace:tab-groups:v1")!)
+    expect(blob.pkTabs).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ roundId: "41", group: home }),
+        expect.objectContaining({ roundId: "42" }),
+      ])
+    )
+
+    first.unmount()
+    act(() => resetTabStore())
+    await renderWithTabs([tabItem(1, 1, true)])
+
+    expect(store().rawTabs.filter((tab) => tab.kind === "pk")).toHaveLength(2)
+    expect(groupOfId("pk-round-42")).not.toBe(home)
+  })
+
   it("persists the split layout and restores it across a restart", async () => {
     const first = await renderWithTabs([tabItem(1, 1, true), tabItem(1, 2)])
 
@@ -2281,7 +2328,7 @@ describe("TabProvider tab groups", () => {
       store().splitTab("conv-1-codex-1", "right", { move: false })
     })
     const g1 = newLeafBeside(home)
-    const draft = store().rawTabs.find((t) => t.conversationId == null)!
+    const draft = store().rawTabs.find(isConversationDraft)!
     expect(groupOfId(draft.id)).toBe(g1)
 
     const blob = JSON.parse(localStorage.getItem("workspace:tab-groups:v1")!)
@@ -2296,7 +2343,7 @@ describe("TabProvider tab groups", () => {
     await renderWithTabs([tabItem(1, 1, true)])
 
     expect(selectIsSplit(store())).toBe(true)
-    const restoredDraft = store().rawTabs.find((t) => t.conversationId == null)
+    const restoredDraft = store().rawTabs.find(isConversationDraft)
     expect(restoredDraft?.id).toBe(draft.id)
     expect(restoredDraft?.folderId).toBe(1)
     expect(groupOfId(draft.id)).toBe(g1)
@@ -2316,7 +2363,7 @@ describe("TabProvider tab groups", () => {
       store().splitTab("conv-1-codex-1", "right", { move: false })
     })
     const g1 = newLeafBeside(home)
-    const draft = store().rawTabs.find((t) => t.conversationId == null)!
+    const draft = store().rawTabs.find(isConversationDraft)!
     const goodBlob = localStorage.getItem("workspace:tab-groups:v1")!
     // Unsent text in BOTH drafts' composers (per-tab keys).
     saveMessageInputDraftV2(buildNewConversationDraftStorageKey(draft.id), {
@@ -2369,7 +2416,7 @@ describe("TabProvider tab groups", () => {
       store().splitTab("conv-1-codex-1", "right", { move: false })
     })
     const g1 = newLeafBeside(home)
-    const draft = store().rawTabs.find((t) => t.conversationId == null)!
+    const draft = store().rawTabs.find(isConversationDraft)!
 
     first.unmount()
     act(() => {
@@ -2427,7 +2474,7 @@ describe("TabProvider tab groups", () => {
       // Draft on folder 2, moved into its own group.
       store().openNewConversationTab(2, "/other", { targetGroup: home })
     })
-    const draft = store().rawTabs.find((t) => t.conversationId == null)!
+    const draft = store().rawTabs.find(isConversationDraft)!
     act(() => {
       store().splitTab("conv-1-codex-1", "right", { move: true })
     })
@@ -2466,7 +2513,7 @@ describe("TabProvider tab groups", () => {
 
     expect(selectIsSplit(store())).toBe(true)
     expect(groupOfId("conv-1-codex-2")).toBe(movedGroup)
-    expect(store().rawTabs.some((t) => t.conversationId == null)).toBe(false)
+    expect(store().rawTabs.some(isConversationDraft)).toBe(false)
   })
 
   it("prunes a restored group whose tabs no longer exist after hydration", async () => {
@@ -2504,7 +2551,7 @@ describe("TabProvider tab groups", () => {
       store().splitTab("conv-1-codex-1", "right", { move: false })
     })
     const g1 = newLeafBeside(home)
-    const draft = store().rawTabs.find((t) => t.conversationId == null)!
+    const draft = store().rawTabs.find(isConversationDraft)!
     expect(groupOfId(draft.id)).toBe(g1)
 
     act(() => {
@@ -2527,7 +2574,7 @@ describe("TabProvider tab groups", () => {
       store().splitTab("conv-1-codex-1", "right", { move: false })
     })
     const g1 = newLeafBeside(home)
-    const draft = store().rawTabs.find((t) => t.conversationId == null)!
+    const draft = store().rawTabs.find(isConversationDraft)!
 
     act(() => {
       tabsChangedHandler?.({
@@ -2664,7 +2711,8 @@ describe("TabProvider tab groups", () => {
       })
       const g1 = newLeafBeside(home)
       const g1Draft = store().rawTabs.find(
-        (t) => t.conversationId == null && groupOfId(t.id) === g1
+        (t): t is ConversationWorkspaceTab & { conversationId: null } =>
+          isConversationDraft(t) && groupOfId(t.id) === g1
       )!
       expect(g1Draft).toBeTruthy()
 
@@ -2694,7 +2742,7 @@ describe("TabProvider tab groups", () => {
       act(() => {
         store().openNewConversationTab(1, "/w1", { targetGroup: home })
       })
-      const draft = store().rawTabs.find((t) => t.conversationId == null)!
+      const draft = store().rawTabs.find(isConversationDraft)!
       const homeTabs = store().tabs.filter((t) => groupOfId(t.id) === home)
       expect(homeTabs.map((t) => t.id)).toEqual([
         "conv-1-codex-1",
diff --git a/src/contexts/tab-context.tsx b/src/contexts/tab-context.tsx
index b66f2af15..bf9c28393 100644
--- a/src/contexts/tab-context.tsx
+++ b/src/contexts/tab-context.tsx
@@ -15,15 +15,17 @@ import {
   useTabStore,
   type OpenedDraftTarget,
   type TabItem,
+  type WorkspaceTabItem,
 } from "@/stores/tab-store"
 import {
   CONVERSATION_CHANGED_EVENT,
   TABS_CHANGED_EVENT,
+  type AgentType,
   type ConversationChange,
   type TabsChanged,
 } from "@/lib/types"
 
-export type { OpenedDraftTarget, TabItem }
+export type { OpenedDraftTarget, TabItem, WorkspaceTabItem }
 export { useTabStore, useTabActions } from "@/stores/tab-store"
 
 interface TabProviderProps {
@@ -215,15 +217,22 @@ export interface TabContextValue {
   openTab: (
     folderId: number,
     conversationId: number,
-    agentType: TabItem["agentType"],
+    agentType: AgentType,
     pin?: boolean,
     title?: string
   ) => void
+  openPkRoundTab: (
+    roundId: string,
+    folderId: number,
+    title: string,
+    options?: { targetGroup?: string }
+  ) => void
+  closePkRoundTab: (roundId: string) => void
   closeTab: (tabId: string) => void
   closeConversationTab: (
     folderId: number,
     conversationId: number,
-    agentType: TabItem["agentType"]
+    agentType: AgentType
   ) => void
   closeOtherTabs: (tabId: string) => void
   closeAllTabs: () => void
@@ -237,7 +246,7 @@ export interface TabContextValue {
     workingDir: string,
     options?: {
       inheritFromActive?: boolean
-      folderDefaultAgent?: TabItem["agentType"] | null
+      folderDefaultAgent?: AgentType | null
       targetGroup?: string
       forceAgent?: TabItem["agentType"]
     }
@@ -247,15 +256,12 @@ export interface TabContextValue {
     forceAgent?: TabItem["agentType"]
   }) => OpenedDraftTarget
   setChatDraftWorkingDir: (tabId: string, workingDir: string) => void
-  confirmDraftAgent: (tabId: string, agentType: TabItem["agentType"]) => void
-  setDraftAgentFromFallback: (
-    tabId: string,
-    agentType: TabItem["agentType"]
-  ) => void
+  confirmDraftAgent: (tabId: string, agentType: AgentType) => void
+  setDraftAgentFromFallback: (tabId: string, agentType: AgentType) => void
   bindConversationTab: (
     tabId: string,
     conversationId: number,
-    agentType: TabItem["agentType"],
+    agentType: AgentType,
     title: string,
     runtimeConversationId?: number,
     folderId?: number,
@@ -280,11 +286,16 @@ export interface TabContextValue {
 export function useTabContext(): TabContextValue {
   return useTabStore(
     useShallow((s) => ({
-      tabs: s.tabs,
+      // Legacy accessor retained for the conversation-only test harness. The
+      // production workspace consumes `useTabStore` directly and sees the full
+      // discriminated union without allocating a filtered array per snapshot.
+      tabs: s.tabs as TabItem[],
       activeTabId: s.activeTabId,
       tabsHydrated: s.tabsHydrated,
       tileByGroup: s.tileByGroup,
       openTab: s.openTab,
+      openPkRoundTab: s.openPkRoundTab,
+      closePkRoundTab: s.closePkRoundTab,
       closeTab: s.closeTab,
       closeConversationTab: s.closeConversationTab,
       closeOtherTabs: s.closeOtherTabs,
diff --git a/src/hooks/use-connection.ts b/src/hooks/use-connection.ts
index 2fe092296..497832761 100644
--- a/src/hooks/use-connection.ts
+++ b/src/hooks/use-connection.ts
@@ -94,8 +94,10 @@ export interface UseConnectionReturn {
     agentType: AgentType,
     workingDir?: string,
     sessionId?: string,
-    conversationId?: number
-  ) => Promise<void>
+    conversationId?: number,
+    modeIdOverride?: string | null,
+    configValuesOverride?: Record<string, string> | null
+  ) => Promise<string | undefined>
   disconnect: () => Promise<void>
   /** Restart the session (disconnect + resume same sessionId) so it picks up
    *  current agent/model settings. Returns `true` if it actually restarted,
@@ -239,14 +241,18 @@ export function useConnection(contextKey: string): UseConnectionReturn {
       agentType: AgentType,
       workingDir?: string,
       sessionId?: string,
-      conversationId?: number
+      conversationId?: number,
+      modeIdOverride?: string | null,
+      configValuesOverride?: Record<string, string> | null
     ) =>
       actions.connect(
         contextKey,
         agentType,
         workingDir,
         sessionId,
-        conversationId
+        conversationId,
+        modeIdOverride,
+        configValuesOverride
       ),
     [actions, contextKey]
   )
diff --git a/src/hooks/use-is-active-chat-mode.ts b/src/hooks/use-is-active-chat-mode.ts
index 22c6865ed..062fbf300 100644
--- a/src/hooks/use-is-active-chat-mode.ts
+++ b/src/hooks/use-is-active-chat-mode.ts
@@ -2,6 +2,7 @@
 
 import { useActiveFolder } from "@/contexts/active-folder-context"
 import { useTabStore } from "@/contexts/tab-context"
+import { isConversationWorkspaceTab } from "@/lib/workspace-tab"
 
 /**
  * True when the active conversation is folderless "chat mode" — either a bound
@@ -18,5 +19,9 @@ export function useIsActiveChatMode(): boolean {
   const activeTabId = useTabStore((s) => s.activeTabId)
   if (activeFolder?.kind === "chat") return true
   const activeTab = tabs.find((t) => t.id === activeTabId)
-  return activeTab?.isChat === true
+  return Boolean(
+    activeTab &&
+    isConversationWorkspaceTab(activeTab) &&
+    activeTab.isChat === true
+  )
 }
diff --git a/src/hooks/use-pk-round-judge.test.tsx b/src/hooks/use-pk-round-judge.test.tsx
new file mode 100644
index 000000000..d8b1b467d
--- /dev/null
+++ b/src/hooks/use-pk-round-judge.test.tsx
@@ -0,0 +1,166 @@
+import { act, renderHook, waitFor } from "@testing-library/react"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import type { PkRound } from "@/stores/pk-arena-store"
+
+const mocks = vi.hoisted(() => ({
+  eventHandler: null as ((event: Record<string, unknown>) => void) | null,
+  updateConversationStatus: vi.fn(),
+  updateJudge: vi.fn(),
+  disconnect: vi.fn().mockResolvedValue(undefined),
+}))
+
+vi.mock("next-intl", () => ({ useLocale: () => "zh-CN" }))
+
+vi.mock("@/lib/api", () => ({
+  acpRespondPermission: vi.fn(),
+  createPkConversation: vi.fn().mockResolvedValue(81),
+  getFolderConversation: vi.fn().mockResolvedValue({
+    turns: [
+      {
+        role: "assistant",
+        blocks: [
+          {
+            type: "text",
+            text: '{"scores":[],"summary":"done"}',
+          },
+        ],
+      },
+    ],
+  }),
+  getFileTree: vi.fn().mockResolvedValue([]),
+  getGitBranch: vi.fn(),
+  gitDiff: vi.fn(),
+  gitDiffWithBranch: vi.fn(),
+  gitStatus: vi.fn().mockResolvedValue([]),
+  gitRemoveWorktree: vi.fn(),
+  gitWorktreeAdd: vi.fn(),
+  pkRoundCreate: vi.fn(),
+  pkRoundDelete: vi.fn(),
+  pkRoundGetReportSnapshot: vi.fn().mockResolvedValue(null),
+  pkRoundSaveReportSnapshot: vi.fn().mockResolvedValue(undefined),
+  pkRoundUpdateJudge: vi.fn().mockResolvedValue(undefined),
+  pkRoundUpdateStatus: vi.fn().mockResolvedValue(undefined),
+  readWorkspaceFileBase64: vi.fn(),
+  updateConversationStatus: mocks.updateConversationStatus,
+}))
+
+vi.mock("@/contexts/acp-connections-context", () => ({
+  useAcpActions: () => ({
+    connect: vi.fn().mockResolvedValue("judge-connection"),
+    sendPrompt: vi.fn().mockResolvedValue(undefined),
+    cancel: vi.fn(),
+    disconnect: mocks.disconnect,
+    setMode: vi.fn(),
+    setConfigOption: vi.fn(),
+    touchActivity: vi.fn(),
+    respondPermission: vi.fn(),
+    attachDelegationChild: vi.fn(),
+    detachDelegationChild: vi.fn(),
+  }),
+  useConnectionStore: () => ({ getConnection: vi.fn() }),
+  useAcpEvent: (handler: (event: Record<string, unknown>) => void) => {
+    mocks.eventHandler = handler
+  },
+}))
+
+import { usePkRound } from "@/hooks/use-pk-round"
+import { usePkArenaStore } from "@/stores/pk-arena-store"
+
+describe("PK judge conversation lifecycle", () => {
+  beforeEach(() => {
+    mocks.eventHandler = null
+    mocks.updateConversationStatus.mockReset().mockResolvedValue(undefined)
+    mocks.disconnect.mockClear()
+    usePkArenaStore.setState({
+      rounds: [],
+      activeRoundId: null,
+      launcherOpen: false,
+      pillDismissed: false,
+      hydrating: false,
+    })
+  })
+
+  it("marks the judge conversation completed after turn_complete", async () => {
+    const round = {
+      id: "2",
+      task: "judge task",
+      folderId: 1,
+      workingDir: "/repo",
+      status: "finished",
+      judgeAgent: "codex",
+      judgeStatus: "idle",
+      judgeDimensions: null,
+      contestants: [
+        {
+          slot: 0,
+          agentType: "qoder",
+          status: "done",
+          diff: "+done",
+        },
+      ],
+    } as PkRound
+    usePkArenaStore.setState({ rounds: [round] })
+    const { result } = renderHook(() => usePkRound())
+
+    await act(async () => result.current.runJudge(round))
+    expect(mocks.eventHandler).not.toBeNull()
+    act(() => {
+      mocks.eventHandler?.({
+        type: "turn_complete",
+        connection_id: "judge-connection",
+      })
+    })
+
+    await waitFor(() => {
+      expect(mocks.updateConversationStatus).toHaveBeenCalledWith(
+        81,
+        "completed"
+      )
+    })
+    act(() => {
+      mocks.eventHandler?.({
+        type: "status_changed",
+        status: "disconnected",
+        connection_id: "judge-connection",
+      })
+    })
+    expect(mocks.updateConversationStatus).not.toHaveBeenCalledWith(
+      81,
+      "cancelled"
+    )
+  })
+
+  it("settles every live contestant conversation when a round is canceled", async () => {
+    const round = {
+      id: "4",
+      task: "cancel task",
+      folderId: 1,
+      workingDir: "/repo",
+      status: "ready",
+      judgeAgent: null,
+      judgeStatus: "idle",
+      judgeDimensions: null,
+      contestants: [
+        {
+          slot: 0,
+          agentType: "qoder",
+          status: "ready",
+          conversationId: 89,
+        },
+        {
+          slot: 1,
+          agentType: "codex",
+          status: "connecting",
+          conversationId: 90,
+        },
+      ],
+    } as PkRound
+    usePkArenaStore.setState({ rounds: [round] })
+    const { result } = renderHook(() => usePkRound())
+
+    await act(async () => result.current.cancelRound(round))
+
+    expect(mocks.updateConversationStatus).toHaveBeenCalledWith(89, "cancelled")
+    expect(mocks.updateConversationStatus).toHaveBeenCalledWith(90, "cancelled")
+  })
+})
diff --git a/src/hooks/use-pk-round.test.ts b/src/hooks/use-pk-round.test.ts
new file mode 100644
index 000000000..f5767e76c
--- /dev/null
+++ b/src/hooks/use-pk-round.test.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest"
+import { buildJudgePrompt, mapPermissionToAgentMode } from "./use-pk-round"
+
+describe("mapPermissionToAgentMode", () => {
+  it("never maps full auto to Claude's deny-without-asking mode", () => {
+    expect(
+      mapPermissionToAgentMode("bypassPermissions", [
+        "default",
+        "acceptEdits",
+        "dontAsk",
+        "auto",
+      ])
+    ).toBe("auto")
+  })
+})
+
+describe("buildJudgePrompt", () => {
+  it("requires judge prose to follow the current interface locale", () => {
+    const [block] = buildJudgePrompt(
+      "实现一个页面",
+      [{ slot: 2, agentType: "qoder", label: "Qwen3.8-Max", diff: "+hello" }],
+      null,
+      "zh-CN"
+    )
+
+    expect(block.type).toBe("text")
+    if (block.type === "text") {
+      expect(block.text).toContain("locale zh-CN")
+      expect(block.text).toContain("Keep JSON property names unchanged")
+      expect(block.text).toContain("Contestant slot 2: qoder · Qwen3.8-Max")
+      expect(block.text).toContain('"slot":<number>')
+    }
+  })
+})
diff --git a/src/hooks/use-pk-round.ts b/src/hooks/use-pk-round.ts
new file mode 100644
index 000000000..8def5743f
--- /dev/null
+++ b/src/hooks/use-pk-round.ts
@@ -0,0 +1,1421 @@
+"use client"
+
+import { useCallback, useEffect, useRef } from "react"
+import { useLocale } from "next-intl"
+import {
+  acpRespondPermission,
+  createPkConversation,
+  getFolderConversation,
+  getGitBranch,
+  gitDiff,
+  gitDiffWithBranch,
+  gitRemoveWorktree,
+  gitWorktreeAdd,
+  updateConversationStatus,
+} from "@/lib/api"
+import type { PromptInputBlock, SessionConfigOptionInfo } from "@/lib/types"
+import { assignJudgeScoreSlots } from "@/lib/pk-judge"
+import { preparePkReportData } from "@/lib/pk-report-data"
+import {
+  useAcpActions,
+  useAcpEvent,
+  useConnectionStore,
+} from "@/contexts/acp-connections-context"
+import {
+  contestantBranchName,
+  contestantContextKey,
+  usePkArenaStore,
+  type PkContestant,
+  type PkContestantUsage,
+  type PkEffortLevel,
+  type PkJudgeResult,
+  type PkJudgeScore,
+  type PkPermissionMode,
+  type PkRound,
+} from "@/stores/pk-arena-store"
+
+/**
+ * Arena orchestrator — drives one round's contestants through the existing
+ * connection machinery (no broker, no parent agent):
+ *
+ *   worktree → conversation row → connect(own contextKey) → same prompt
+ *
+ * Completion is detected from `status_changed` events per connection
+ * (`prompting` → a settled state means the contestant's single turn ended),
+ * which is exactly the signal the live transcript uses. Duration is measured
+ * client-side between the prompt send and that transition; token/turn stats
+ * are summed from the persisted conversation afterwards.
+ */
+
+/** 公平竞技规则块。裸机模式下追加到任务提示词——软约束(模型仍会看到
+ * 全局技能目录的内容),但统一施加于所有选手,对比保持 apples-to-apples。 */
+const BARE_MODE_RULES = [
+  "FAIR-PLAY RULES (mandatory):",
+  "This is a fair competition. Do NOT use any skills, slash commands, plugins,",
+  "custom agents, or custom instructions — including anything from",
+  "~/.claude/skills, ~/.codex/skills, ~/.agents/skills, or any other global",
+  "skill store, and any .claude/skills / .agents/skills / .codex/skills",
+  "directories in the repository. Use only your built-in capabilities",
+  "(file read/write, running commands, web access).",
+].join("\n")
+
+/** 裁判提示词——在所有选手完成后发送给裁判 agent。要求结构化 JSON 输出
+ * (每个选手:分数、排名、点评;以及总体总结)。裁判不需要 worktree,
+ * 只读取各选手的 diff 文本。 */
+/** Default judge evaluation dimensions, used when the round has no custom
+ * `judge_dimensions` configured. */
+const DEFAULT_JUDGE_DIMENSIONS = [
+  "Correctness — does it fulfill the task?",
+  "Code quality — readability, structure, edge cases",
+  "Completeness — how much of the task is done?",
+  "Efficiency — token count and time are NOT factors here; judge code-level efficiency only",
+]
+
+export function buildJudgePrompt(
+  task: string,
+  contestants: Array<{
+    slot: number
+    agentType: string
+    label?: string | null
+    diff: string
+  }>,
+  dimensions?: string[] | null,
+  outputLocale = "en"
+): PromptInputBlock[] {
+  const sections = contestants.map(
+    (c) =>
+      `--- Contestant slot ${c.slot}: ${c.agentType}${c.label ? ` · ${c.label}` : ""} ---\n${c.diff}\n--- End slot ${c.slot} ---`
+  )
+  const dims =
+    dimensions && dimensions.length > 0 ? dimensions : DEFAULT_JUDGE_DIMENSIONS
+  const numbered = dims.map((d, i) => `${i + 1}. ${d}`).join("\n")
+  const text = [
+    `You are the JUDGE of a coding PK arena.`,
+    "",
+    `Task given to all contestants:`,
+    `"${task}"`,
+    "",
+    `Below are the git diffs from each contestant. Evaluate each one on:`,
+    numbered,
+    "",
+    "Score each contestant 0-100. Rank them (1 = best).",
+    `Write every human-readable comment and summary in the language identified by locale ${outputLocale}. Keep JSON property names unchanged.`,
+    "",
+    "Respond with ONLY a JSON block (no markdown fences, no prose before or after):",
+    "Return exactly one score row for every contestant slot listed below. Preserve each numeric slot exactly.",
+    '{"scores":[{"slot":<number>,"agentType":"<agent>","score":<number>,"rank":<number>,"comment":"<one-line>"}],"summary":"<overall verdict in 1-2 sentences>"}',
+    "",
+    "Here are the diffs:",
+    "",
+    ...sections,
+  ].join("\n")
+  return [{ type: "text", text }]
+}
+
+/** 解析裁判 LLM 的文本输出,提取结构化 JSON 评分。
+ * 容忍 markdown 围栏和前后文本。 */
+function parseJudgeResult(
+  rawText: string,
+  contestants: readonly PkContestant[]
+): PkJudgeResult | null {
+  // Strip markdown code fences if present.
+  const cleaned = rawText
+    .replace(/^```(?:json)?\s*/i, "")
+    .replace(/\s*```\s*$/i, "")
+    .trim()
+  // Find the first { and last } — the JSON blob.
+  const start = cleaned.indexOf("{")
+  const end = cleaned.lastIndexOf("}")
+  if (start === -1 || end === -1 || end <= start) return null
+  const jsonStr = cleaned.slice(start, end + 1)
+  try {
+    const parsed = JSON.parse(jsonStr) as {
+      scores?: Array<{
+        slot?: number
+        agentType?: string
+        score?: number
+        rank?: number
+        comment?: string
+      }>
+      summary?: string
+    }
+    if (!parsed.scores || !Array.isArray(parsed.scores)) return null
+    const scores: PkJudgeScore[] = parsed.scores
+      .filter((s) => s.agentType != null)
+      .map((s) => ({
+        slot: typeof s.slot === "number" ? s.slot : undefined,
+        agentType: String(s.agentType),
+        score: typeof s.score === "number" ? s.score : 0,
+        rank: typeof s.rank === "number" ? s.rank : 0,
+        comment: s.comment ?? "",
+      }))
+    if (scores.length === 0) return null
+    return {
+      scores: assignJudgeScoreSlots(scores, contestants),
+      summary: parsed.summary ?? "",
+      rawText,
+    }
+  } catch {
+    return null
+  }
+}
+
+function taskPromptBlocks(
+  task: string,
+  worktreePath: string,
+  bareMode: boolean
+): PromptInputBlock[] {
+  return [
+    {
+      type: "text",
+      text: [
+        task,
+        "",
+        `Work inside this directory: ${worktreePath}`,
+        "It is a fresh git worktree created for you — this is your isolated arena, no other agent writes here. Commit your work when done.",
+        ...(bareMode ? ["", BARE_MODE_RULES] : []),
+      ].join("\n"),
+    },
+  ]
+}
+
+/**
+ * Apply the round's permission policy via `session/set_mode` once the agent
+ * has advertised its modes. The requested mode id is only sent when the
+ * agent actually advertises it: forcing an unknown id on an agent that would
+ * reject it would fail the whole connect sequence, and an agent without the
+ * mode simply keeps asking, exactly as before. "default" needs no call.
+ *
+ * The modes arrive as a `session_modes` EVENT shortly after session/new —
+ * not in connect()'s resolution. The arena attaches the contestant as a
+ * by-id delegation child right after connect, and the attach RE-ROUTES the
+ * reverseMap to the by-id entry, so the event lands there, never on the
+ * owner (contextKey) entry. Polling only the owner entry therefore times
+ * out and the mode is silently skipped (field report: presets "did not
+ * apply"). Poll both entries: pre-attach events land on the owner, post-
+ * attach on the by-id entry.
+ */
+type ModesStore = {
+  getConnection(key: string):
+    | {
+        modes?: { available_modes?: Array<{ id: string }> } | null
+        configOptions?: SessionConfigOptionInfo[] | null
+      }
+    | undefined
+}
+
+/** 统一的思考等级 → 各 agent 通告值的最近匹配。词表各不相同
+ * (claude: low/medium/high; codex: minimal/low/medium/high/max;
+ * deepseek: off/low/medium/high),按规范序取最近邻,平局取更高档
+ * (公平竞技下宁高勿低)。 */
+const EFFORT_RANK: Record<string, number> = {
+  off: 0,
+  minimal: 1,
+  low: 2,
+  medium: 3,
+  high: 4,
+  max: 5,
+}
+
+function nearestEffort(requested: string, advertised: string[]): string | null {
+  if (advertised.length === 0) return null
+  const exact = advertised.find((v) => v === requested)
+  if (exact) return exact
+  const target = EFFORT_RANK[requested] ?? 3
+  let best: string | null = null
+  let bestDist = Number.POSITIVE_INFINITY
+  for (const value of advertised) {
+    const rank = EFFORT_RANK[value]
+    if (rank === undefined) continue
+    const dist = Math.abs(rank - target)
+    if (
+      dist < bestDist ||
+      (dist === bestDist && best !== null && rank > (EFFORT_RANK[best] ?? 0))
+    ) {
+      best = value
+      bestDist = dist
+    }
+  }
+  return best
+}
+
+/** 把通告的 configOptions 折成竞技场需要的两份选项表。 */
+function selectOptions(configOptions: SessionConfigOptionInfo[] | null): {
+  modelOptions: Array<{ value: string; name: string }>
+  effortOptions: string[]
+} {
+  const modelOptions: Array<{ value: string; name: string }> = []
+  const effortOptions: string[] = []
+  for (const option of configOptions ?? []) {
+    if (option.kind?.type !== "select") continue
+    if (option.id === "model" || option.id === "model_id") {
+      for (const item of option.kind.options) {
+        modelOptions.push({ value: item.value, name: item.name ?? item.value })
+      }
+    } else if (/effort|reasoning/i.test(option.id)) {
+      for (const item of option.kind.options) {
+        if (EFFORT_RANK[item.value] !== undefined)
+          effortOptions.push(item.value)
+      }
+    }
+  }
+  return { modelOptions, effortOptions }
+}
+
+/** 双条目轮询:modes/configOptions 都走 attach 后的 by-id 路由
+ * (见 applyPermissionMode 的注释)。按需等**特定字段**——统一等「任一字段」
+ * 会在 modes 先到时立即返回,此时 configOptions 往往还没到,消费方拿到
+ * null 就静默放弃(实测:模型/思考等级选择器永远不出现)。 */
+function waitForField(
+  connectionStore: ModesStore,
+  contextKey: string,
+  connectionId: string | null,
+  field: "modes" | "configOptions",
+  timeoutMs = 10000
+): Promise<{
+  modes?: { available_modes?: Array<{ id: string }> } | null
+  configOptions?: SessionConfigOptionInfo[] | null
+} | null> {
+  return new Promise((resolve) => {
+    const startedAt = Date.now()
+    const poll = () => {
+      const owner = connectionStore.getConnection(contextKey)
+      const byId =
+        connectionId != null
+          ? connectionStore.getConnection(connectionId)
+          : undefined
+      // 字段优先,不是条目优先:`owner ?? byId` 会在 owner 存在但缺该字段时
+      // 永远选 owner,把带字段的 byId 晾在一边——实测 owner=none byId=N,
+      // 选择器与权限预设全部静默丢失(同一个根).两个条目都查字段,谁有谁算。
+      if (owner != null && owner[field] != null) {
+        resolve(owner)
+        return
+      }
+      if (byId != null && byId[field] != null) {
+        resolve(byId)
+        return
+      }
+      if (Date.now() - startedAt >= timeoutMs) {
+        resolve(null)
+        return
+      }
+      setTimeout(poll, 200)
+    }
+    poll()
+  })
+}
+
+/**
+ * Apply the round's permission policy via `session/set_mode` once the agent
+ * has advertised its modes. The requested mode id is only sent when the
+ * agent actually advertises it: forcing an unknown id on an agent that would
+ * reject it would fail the whole connect sequence, and an agent without the
+ * mode simply keeps asking, exactly as before. "default" needs no call.
+ *
+ * The modes arrive as a `session_modes` EVENT shortly after session/new —
+ * not in connect()'s resolution. The arena attaches the contestant as a
+ * by-id delegation child right after connect, and the attach RE-ROUTES the
+ * reverseMap to the by-id entry, so the event lands there, never on the
+ * owner (contextKey) entry. Polling only the owner entry therefore times
+ * out and the mode is silently skipped (field report: presets "did not
+ * apply"). `waitForOptions` reads whichever entry the event landed on.
+ */
+export function mapPermissionToAgentMode(
+  mode: PkPermissionMode,
+  availableModes: string[]
+): string | null {
+  if (mode === "default") return null
+  if (availableModes.includes(mode)) return mode
+
+  if (mode === "bypassPermissions") {
+    const candidate = [
+      "agent-full-access",
+      "danger-full-access",
+      "full-access",
+      "auto",
+      "acceptEdits",
+      "agent",
+    ].find((m) => availableModes.includes(m))
+    return candidate ?? null
+  }
+
+  if (mode === "acceptEdits") {
+    const candidate = ["acceptEdits", "agent", "auto"].find((m) =>
+      availableModes.includes(m)
+    )
+    return candidate ?? null
+  }
+
+  return null
+}
+
+async function applyPermissionMode(
+  connectionStore: ModesStore,
+  setMode: (contextKey: string, modeId: string) => Promise<void>,
+  setConfigOption: (
+    contextKey: string,
+    configId: string,
+    valueId: string
+  ) => Promise<void>,
+  contextKey: string,
+  connectionId: string | null,
+  mode: PkPermissionMode
+): Promise<void> {
+  if (mode === "default") return
+  const entry = await waitForField(
+    connectionStore,
+    contextKey,
+    connectionId,
+    "modes"
+  )
+  const advertised = entry?.modes?.available_modes?.map((m) => m.id) ?? []
+  const targetMode = mapPermissionToAgentMode(mode, advertised)
+  if (targetMode) {
+    try {
+      await setMode(contextKey, targetMode)
+    } catch {
+      // A rejected mode switch must not kill the round
+    }
+  }
+
+  // Also check if the agent (such as Codex) exposes an approval preset via configOptions
+  const configEntry = await waitForField(
+    connectionStore,
+    contextKey,
+    connectionId,
+    "configOptions"
+  )
+  const modeOption = configEntry?.configOptions?.find(
+    (o) =>
+      o.id === "mode" ||
+      o.id === "permission_mode" ||
+      o.id === "approval_policy"
+  )
+  if (modeOption && modeOption.kind?.type === "select") {
+    const optValues = modeOption.kind.options.map((o) => o.value)
+    if (mode === "bypassPermissions") {
+      const targetVal = [
+        "agent-full-access",
+        "danger-full-access",
+        "never",
+        "auto",
+      ].find((v) => optValues.includes(v))
+      if (targetVal) {
+        try {
+          await setConfigOption(contextKey, modeOption.id, targetVal)
+        } catch {
+          // ignore
+        }
+      }
+    } else if (mode === "acceptEdits") {
+      const targetVal = ["agent", "acceptEdits", "auto"].find((v) =>
+        optValues.includes(v)
+      )
+      if (targetVal) {
+        try {
+          await setConfigOption(contextKey, modeOption.id, targetVal)
+        } catch {
+          // ignore
+        }
+      }
+    }
+  }
+}
+
+async function applyPreparedOptions(
+  connectionStore: ModesStore,
+  setConfigOption: (
+    contextKey: string,
+    configId: string,
+    valueId: string
+  ) => Promise<void>,
+  contextKey: string,
+  connectionId: string | null,
+  effort: PkEffortLevel
+): Promise<{
+  modelOptions: Array<{ value: string; name: string }>
+  modelConfigId: string | null
+  effortOptions: string[]
+  effortConfigId: string | null
+  selectedModel: string | null
+  selectedEffort: string | null
+  diagnostic: string
+}> {
+  const entry = await waitForField(
+    connectionStore,
+    contextKey,
+    connectionId,
+    "configOptions"
+  )
+  const options = entry?.configOptions ?? null
+  const { modelOptions, effortOptions } = selectOptions(options)
+  let selectedModel: string | null = null
+  let selectedEffort: string | null = null
+  const effortConfigId =
+    (options ?? []).find(
+      (o) => o.kind?.type === "select" && /effort|reasoning/i.test(o.id)
+    )?.id ?? null
+  if (effortConfigId) {
+    const option = (options ?? []).find((o) => o.id === effortConfigId)
+    const current =
+      option?.kind?.type === "select" ? option.kind.current_value : null
+    selectedEffort = current ?? null
+  }
+  const modelConfigId =
+    (options ?? []).find(
+      (o) =>
+        o.kind?.type === "select" && (o.id === "model" || o.id === "model_id")
+    )?.id ?? null
+  if (modelConfigId) {
+    const option = (options ?? []).find((o) => o.id === modelConfigId)
+    const current =
+      option?.kind?.type === "select" ? option.kind.current_value : null
+    selectedModel = current ?? null
+  }
+  if (effort !== "default" && effortConfigId) {
+    const target = nearestEffort(effort, effortOptions)
+    if (target) {
+      try {
+        await setConfigOption(contextKey, effortConfigId, target)
+        selectedEffort = target
+      } catch {
+        // 拒绝不致命——选手保持当前档位。
+      }
+    }
+  }
+  return {
+    modelOptions,
+    modelConfigId,
+    effortOptions,
+    effortConfigId,
+    selectedModel,
+    selectedEffort,
+    diagnostic:
+      options === null
+        ? "no configOptions advertised"
+        : `arrived (${options.length} options)`,
+  }
+}
+
+export async function fetchUsage(
+  conversationId: number
+): Promise<PkContestantUsage | null> {
+  try {
+    const detail = await getFolderConversation(conversationId)
+    let inputTokens = 0
+    let outputTokens = 0
+    let turnCount = 0
+    let tokensReported = false
+    for (const turn of detail.turns ?? []) {
+      if (turn.role !== "assistant") continue
+      turnCount += 1
+      inputTokens += turn.usage?.input_tokens ?? 0
+      outputTokens += turn.usage?.output_tokens ?? 0
+      if (
+        (turn.usage?.input_tokens ?? 0) > 0 ||
+        (turn.usage?.output_tokens ?? 0) > 0
+      ) {
+        tokensReported = true
+      }
+    }
+    return { inputTokens, outputTokens, turnCount, tokensReported }
+  } catch {
+    return null
+  }
+}
+
+export function usePkRound(): {
+  startRound: (round: PkRound) => Promise<void>
+  startPrompt: (round: PkRound) => Promise<void>
+  sendFollowUp: (
+    round: PkRound,
+    contestant: PkContestant,
+    message: string
+  ) => Promise<void>
+  applyContestantSelection: (
+    round: PkRound,
+    contestant: PkContestant,
+    configId: string,
+    value: string
+  ) => Promise<void>
+  cancelRound: (round: PkRound) => Promise<void>
+  disconnectFinished: (round: PkRound) => Promise<void>
+  cleanupRound: (round: PkRound, keepBranches: boolean) => Promise<void>
+  fetchDiff: (round: PkRound, contestant: PkContestant) => Promise<void>
+  runJudge: (round: PkRound) => Promise<void>
+} {
+  const locale = useLocale()
+  const {
+    connect,
+    sendPrompt,
+    cancel,
+    disconnect,
+    setMode,
+    setConfigOption,
+    touchActivity,
+    respondPermission,
+    attachDelegationChild,
+    detachDelegationChild,
+  } = useAcpActions()
+  const connectionStore = useConnectionStore()
+  const updateContestant = usePkArenaStore((s) => s.updateContestant)
+  const markRound = usePkArenaStore((s) => s.markRound)
+  const roundsRef = useRef(usePkArenaStore.getState().rounds)
+  useEffect(() => {
+    const unsub = usePkArenaStore.subscribe((state) => {
+      roundsRef.current = state.rounds
+    })
+    return unsub
+  }, [])
+
+  // Map connectionId → {roundId, slot} so the event subscription can
+  // resolve envelopes without re-subscribing as rounds change.
+  // `isJudge: true` marks the judge agent connection — it uses the same
+  // event pipeline but settles into judgeResult instead of contestant state.
+  const contestantsByConnection = useRef(
+    new Map<
+      string,
+      {
+        roundId: string
+        slot: number
+        isJudge?: boolean
+      }
+    >()
+  )
+
+  const disconnectFinished = useCallback(
+    async (round: PkRound | null | undefined) => {
+      if (!round) return
+      await Promise.allSettled(
+        round.contestants
+          .filter((c) => c.connectionId != null)
+          .map(async (contestant) => {
+            if (contestant.connectionId) {
+              detachDelegationChild(contestant.connectionId)
+            }
+            if (contestant.contextKey) {
+              await disconnect(contestant.contextKey).catch(() => undefined)
+            }
+          })
+      )
+    },
+    [detachDelegationChild, disconnect]
+  )
+
+  // 裁判 settled 时的处理:从裁判的 conversation 轮次里提取最后一条
+  // assistant 消息文本,解析 JSON 评分。裁判连接用独立 contextKey,不跟
+  // 选手混在一起。
+  const updateJudge = usePkArenaStore((s) => s.updateJudge)
+
+  const settleJudge = useCallback(
+    async (roundId: string) => {
+      const round = roundsRef.current.find((r) => r.id === roundId)
+      if (!round || !round.judgeAgent) return
+      // 裁判的 conversationId 存在 store 里的 judgeResult 临时字段——但
+      // 我们没地方存 conversationId。改用 contextKey 从 connection store
+      // 拿状态,但文本只能从 conversation 轮次读。这里用 contextKey 去
+      // 读 conversationId——不,contextKey 不映射到 conversationId。
+      //
+      // 方案:裁判的 conversationId 在 runJudge 里创建后存入 ref。
+      const judgeConvId = judgeConvIdRef.current.get(roundId)
+      if (judgeConvId != null) {
+        try {
+          const detail = await getFolderConversation(judgeConvId)
+          const lastAssistant = [...(detail.turns ?? [])]
+            .reverse()
+            .find((turn) => turn.role === "assistant")
+          const rawText =
+            lastAssistant?.blocks
+              ?.filter(
+                (b): b is { type: "text"; text: string } => b.type === "text"
+              )
+              .map((b) => b.text)
+              .join("\n") ?? ""
+          const result = parseJudgeResult(
+            rawText,
+            round.contestants.filter(
+              (contestant) => contestant.status === "done"
+            )
+          )
+          updateJudge(roundId, {
+            judgeStatus: "done",
+            judgeResult: result ?? {
+              scores: [],
+              summary: "Judge response could not be parsed.",
+              rawText,
+            },
+          })
+        } catch {
+          updateJudge(roundId, {
+            judgeStatus: "error",
+            judgeResult: {
+              scores: [],
+              summary: "Failed to read judge response.",
+              rawText: "",
+            },
+          })
+        }
+        // Judge sessions are system-owned terminal work, not user work waiting
+        // for review. Explicitly settle the linked conversation so the sidebar
+        // does not keep rendering an in-progress spinner after the verdict is
+        // already available.
+        await updateConversationStatus(judgeConvId, "completed").catch(
+          () => undefined
+        )
+      } else {
+        updateJudge(roundId, { judgeStatus: "error" })
+      }
+      for (const [connectionId, entry] of contestantsByConnection.current) {
+        if (entry.isJudge && entry.roundId === roundId) {
+          contestantsByConnection.current.delete(connectionId)
+        }
+      }
+      // 断开裁判连接。
+      const judgeCtxKey = `pk:${roundId}:judge`
+      void disconnect(judgeCtxKey).catch(() => undefined)
+    },
+    [disconnect, updateJudge]
+  )
+
+  const settleJudgeError = useCallback(
+    (roundId: string, message: string) => {
+      updateJudge(roundId, {
+        judgeStatus: "error",
+        judgeResult: {
+          scores: [],
+          summary: message,
+          rawText: "",
+        },
+      })
+      const judgeConvId = judgeConvIdRef.current.get(roundId)
+      if (judgeConvId != null) {
+        void updateConversationStatus(judgeConvId, "cancelled").catch(
+          () => undefined
+        )
+      }
+      for (const [connectionId, entry] of contestantsByConnection.current) {
+        if (entry.isJudge && entry.roundId === roundId) {
+          contestantsByConnection.current.delete(connectionId)
+        }
+      }
+      const judgeCtxKey = `pk:${roundId}:judge`
+      void disconnect(judgeCtxKey).catch(() => undefined)
+    },
+    [disconnect, updateJudge]
+  )
+
+  // Store judge conversationId per round — needed by settleJudge to read the
+  // conversation turns after the judge finishes.
+  const judgeConvIdRef = useRef(new Map<string, number>())
+
+  const fetchDiff = useCallback(
+    async (round: PkRound, contestant: PkContestant) => {
+      if (!contestant.worktreePath) return
+      try {
+        // 对比基准分支而不是选手自身分支:worktree 里 `git diff <自身分支>`
+        // 在选手提交后为空,而 diff 的意义是"比起跑点改了什么"。先取回合
+        // 仓库当前分支(main 等),再在 worktree 里对它 diff——既含已提交
+        // 也含未提交的工作区改动。
+        const base = (await getGitBranch(round.workingDir)) ?? null
+        const diff =
+          base == null
+            ? // 取不到基准分支名时退回工作区 diff(仅未提交改动)。
+              await gitDiff(contestant.worktreePath)
+            : await gitDiffWithBranch(contestant.worktreePath, base)
+        updateContestant(round.id, contestant.slot, {
+          diff: diff.trim() === "" ? "（无可比较内容:选手未改动工作区）" : diff,
+        })
+      } catch (error) {
+        updateContestant(round.id, contestant.slot, {
+          diff: `diff unavailable: ${String(error)}`,
+        })
+      }
+    },
+    [updateContestant]
+  )
+
+  const runJudge = useCallback(
+    async (round: PkRound) => {
+      if (!round.judgeAgent) return
+      const roundId = round.id
+      updateJudge(roundId, { judgeStatus: "running" })
+
+      // 收集所有选手的 diff(未加载的先加载)。
+      const contestantsWithDiffs = await Promise.all(
+        round.contestants
+          .filter((c) => c.status === "done")
+          .map(async (contestant) => {
+            if (contestant.diff == null && contestant.worktreePath) {
+              await fetchDiff(round, contestant)
+            }
+            const freshRound = usePkArenaStore
+              .getState()
+              .rounds.find((r) => r.id === roundId)
+            const fresh = freshRound?.contestants.find(
+              (c) => c.slot === contestant.slot
+            )
+            return {
+              agentType: contestant.agentType,
+              slot: contestant.slot,
+              label: contestant.label,
+              diff: fresh?.diff ?? "(no diff available)",
+            }
+          })
+      )
+
+      if (contestantsWithDiffs.length === 0) {
+        updateJudge(roundId, {
+          judgeStatus: "skipped",
+          judgeResult: {
+            scores: [],
+            summary: "No completed contestants to judge.",
+            rawText: "",
+          },
+        })
+        return
+      }
+
+      const contextKey = `pk:${roundId}:judge`
+      try {
+        const connectResult = await connect(
+          contextKey,
+          round.judgeAgent,
+          round.workingDir
+        )
+        const connectionId =
+          connectResult ??
+          connectionStore.getConnection(contextKey)?.connectionId ??
+          null
+        if (connectionId) {
+          contestantsByConnection.current.set(connectionId, {
+            roundId,
+            slot: -1,
+            isJudge: true,
+          })
+        }
+
+        // Create a conversation for the judge so its transcript persists.
+        let conversationId: number | null = null
+        try {
+          const taskPreview = round.task.slice(0, 60)
+          conversationId = await createPkConversation(
+            round.folderId,
+            round.judgeAgent as PkContestant["agentType"],
+            Number(roundId),
+            `PK Judge · ${taskPreview}${round.task.length > 60 ? "…" : ""}`
+          )
+          judgeConvIdRef.current.set(roundId, conversationId)
+        } catch {
+          // 裁判没有 conversation 也能跑,只是 transcript 不持久化。
+        }
+
+        await sendPrompt(
+          contextKey,
+          buildJudgePrompt(
+            round.task,
+            contestantsWithDiffs,
+            round.judgeDimensions,
+            locale
+          ),
+          {
+            folderId: round.folderId,
+            conversationId: conversationId ?? undefined,
+          }
+        )
+      } catch (error) {
+        updateJudge(roundId, {
+          judgeStatus: "error",
+          judgeResult: {
+            scores: [],
+            summary: `Judge failed to start: ${String(error)}`,
+            rawText: "",
+          },
+        })
+      }
+    },
+    [connect, connectionStore, sendPrompt, updateJudge, fetchDiff, locale]
+  )
+  // Keep a ref so settleContestant can call it without circular deps.
+  const runJudgeRef = useRef(runJudge)
+  runJudgeRef.current = runJudge
+
+  const settleContestant = useCallback(
+    async (
+      roundId: string,
+      slot: number,
+      outcome: "done" | "error",
+      detail?: string
+    ) => {
+      const endedAt = Date.now()
+      const round = roundsRef.current.find((r) => r.id === roundId)
+      const contestant = round?.contestants.find((c) => c.slot === slot)
+      if (!round || !contestant) return
+
+      const startedAt = contestant.startedAt ?? endedAt
+      updateContestant(roundId, slot, {
+        status: outcome,
+        statusDetail: detail ?? null,
+        endedAt,
+        durationMs: endedAt - startedAt,
+      })
+      if (contestant.conversationId != null) {
+        const usage = await fetchUsage(contestant.conversationId)
+        if (usage) {
+          updateContestant(roundId, slot, { usage })
+        }
+      }
+
+      const fresh = usePkArenaStore
+        .getState()
+        .rounds.find((r) => r.id === roundId)
+      if (
+        fresh &&
+        fresh.contestants.every(
+          (c) =>
+            c.status === "done" ||
+            c.status === "error" ||
+            c.status === "canceled"
+        )
+      ) {
+        markRound(roundId, "finished")
+        // Capture the disposable worktrees as soon as the round settles. This
+        // makes report export independent from the arena staying open and is
+        // retried synchronously before an explicit worktree cleanup.
+        void preparePkReportData(fresh).catch(() => undefined)
+        // 结算即断开:侧边栏的选手会话立刻停止转圈,结果走向持久化
+        // transcript。想继续追一条会话,把它当普通会话打开重连即可。
+        void disconnectFinished(
+          usePkArenaStore.getState().rounds.find((r) => r.id === roundId)
+        )
+        // 裁判自动触发:所有选手 settled 且配置了 judgeAgent 时启动。
+        // 裁判在选手断开后才连(避免连接数叠加),用独立 contextKey。
+        if (fresh.judgeAgent && fresh.judgeStatus === "idle") {
+          void runJudgeRef.current(fresh)
+        }
+      }
+    },
+    [disconnectFinished, markRound, updateContestant]
+  )
+
+  useEffect(() => {
+    const timer = window.setInterval(() => {
+      for (const round of usePkArenaStore.getState().rounds) {
+        if (round.status !== "ready" && round.status !== "running") continue
+        for (const contestant of round.contestants) {
+          if (contestant.contextKey) {
+            try {
+              touchActivity(contestant.contextKey)
+            } catch {
+              // 保活是尽力而为;失败不影响回合。
+            }
+          }
+        }
+      }
+    }, 20000)
+    return () => window.clearInterval(timer)
+  }, [touchActivity])
+
+  useAcpEvent((envelope) => {
+    if (
+      envelope.type !== "status_changed" &&
+      envelope.type !== "error" &&
+      envelope.type !== "turn_complete" &&
+      envelope.type !== "permission_request"
+    ) {
+      return
+    }
+    const entry = contestantsByConnection.current.get(envelope.connection_id)
+    if (!entry) return
+
+    // Judge connections share the event pipeline but settle differently.
+    if (entry.isJudge) {
+      if (envelope.type === "turn_complete") {
+        void settleJudge(entry.roundId)
+      } else if (envelope.type === "error") {
+        settleJudgeError(entry.roundId, envelope.message)
+      } else if (
+        envelope.type === "status_changed" &&
+        envelope.status === "disconnected"
+      ) {
+        settleJudgeError(entry.roundId, "连接中断(空闲回收或进程退出)")
+      }
+      return
+    }
+
+    const round = roundsRef.current.find((r) => r.id === entry.roundId)
+    const contestant = round?.contestants.find((c) => c.slot === entry.slot)
+    if (!round || !contestant) return
+
+    if (envelope.type === "permission_request") {
+      if (
+        round.permissionMode === "bypassPermissions" ||
+        round.permissionMode === "acceptEdits"
+      ) {
+        const opts =
+          (
+            envelope as {
+              options?: Array<{ option_id: string; name?: string }>
+            }
+          ).options ?? []
+        const allowOpt =
+          opts.find(
+            (o) =>
+              /allow|always|proceed|yes|approve|continue/i.test(o.option_id) ||
+              /allow|always|proceed|yes|approve|continue/i.test(o.name ?? "")
+          ) ?? opts[0]
+        if (allowOpt) {
+          const reqId = (envelope as { request_id: string }).request_id
+          const targetKey = contestant.contextKey ?? envelope.connection_id
+          void respondPermission(targetKey, reqId, allowOpt.option_id).catch(
+            () => {
+              void acpRespondPermission(
+                envelope.connection_id,
+                reqId,
+                allowOpt.option_id
+              ).catch(() => {})
+            }
+          )
+        }
+      }
+      return
+    }
+
+    if (envelope.type === "error") {
+      if (
+        contestant.status === "running" ||
+        contestant.status === "connecting"
+      ) {
+        void settleContestant(
+          entry.roundId,
+          entry.slot,
+          "error",
+          envelope.message
+        )
+      }
+      return
+    }
+
+    // `turn_complete` is the REAL settle signal: the backend flips the turn
+    // status at TurnComplete WITHOUT emitting a status_changed envelope
+    // (session_state.rs: "bypassing StatusChanged entirely"), so waiting for
+    // prompting→settled would leave finished contestants stuck on "running".
+    if (envelope.type === "turn_complete") {
+      if (contestant.status === "running") {
+        void settleContestant(entry.roundId, entry.slot, "done")
+      }
+      return
+    }
+
+    // status_changed: only the prompting edge matters for the running flip;
+    // the settle edge does not exist (see turn_complete above). A disconnect
+    // mid-turn means the backend reaped the connection (idle sweep) or the
+    // agent died — that is a failure, not a stuck running state.
+    if (envelope.status === "disconnected") {
+      if (
+        contestant.status === "running" ||
+        contestant.status === "connecting"
+      ) {
+        void settleContestant(
+          entry.roundId,
+          entry.slot,
+          "error",
+          "连接中断(空闲回收或进程退出)"
+        )
+      }
+      return
+    }
+    if (envelope.status === "prompting") {
+      if (contestant.status === "connecting" || contestant.status === "ready") {
+        updateContestant(entry.roundId, entry.slot, {
+          status: "running",
+          startedAt: Date.now(),
+        })
+      }
+    }
+  })
+
+  const startRound = useCallback(
+    async (round: PkRound) => {
+      for (const contestant of round.contestants) {
+        const { slot, agentType } = contestant
+        const contextKey = contestantContextKey(round.id, slot)
+        const branchName = contestantBranchName(round.id, slot)
+        const worktreePath = `${round.workingDir}/.codeg-pk/${round.id}/${slot}`
+        try {
+          await gitWorktreeAdd(
+            round.workingDir,
+            branchName,
+            worktreePath,
+            round.baseCommit
+          )
+        } catch (error) {
+          updateContestant(round.id, slot, {
+            status: "error",
+            statusDetail: `worktree: ${String(error)}`,
+          })
+          continue
+        }
+        updateContestant(round.id, slot, {
+          branchName,
+          worktreePath,
+        })
+
+        let conversationId: number | null = null
+        try {
+          const taskPreview = round.task.slice(0, 60)
+          conversationId = await createPkConversation(
+            round.folderId,
+            agentType,
+            Number(round.id),
+            `PK · ${taskPreview}${round.task.length > 60 ? "…" : ""}`
+          )
+        } catch (error) {
+          updateContestant(round.id, slot, {
+            status: "error",
+            statusDetail: `conversation: ${String(error)}`,
+          })
+          continue
+        }
+        updateContestant(round.id, slot, {
+          conversationId,
+          contextKey,
+          status: "connecting",
+        })
+
+        let initialModeId: string | null = null
+        let initialConfigValues: Record<string, string> | null =
+          Object.keys(contestant.configValues).length > 0
+            ? { ...contestant.configValues }
+            : null
+        if (agentType === "claude_code") {
+          initialModeId = round.permissionMode
+        } else if (agentType === "codex") {
+          if (round.permissionMode === "bypassPermissions") {
+            initialModeId = "agent-full-access"
+            initialConfigValues = {
+              ...(initialConfigValues ?? {}),
+              mode: "agent-full-access",
+            }
+          } else if (round.permissionMode === "acceptEdits") {
+            initialModeId = "agent"
+            initialConfigValues = {
+              ...(initialConfigValues ?? {}),
+              mode: "agent",
+            }
+          }
+        }
+
+        try {
+          const connectResult = await connect(
+            contextKey,
+            agentType,
+            worktreePath,
+            undefined,
+            undefined,
+            initialModeId,
+            initialConfigValues
+          )
+          const connectionId =
+            connectResult ??
+            connectionStore.getConnection(contextKey)?.connectionId ??
+            null
+          if (connectionId) {
+            contestantsByConnection.current.set(connectionId, {
+              roundId: round.id,
+              slot,
+            })
+            updateContestant(round.id, slot, { connectionId })
+            // LiveTranscriptView resolves its connection via
+            // useConnectionStateById, which looks the store up BY
+            // connectionId — the entry shape only delegation children have
+            // (attach registers contextKey == connectionId). Attach the
+            // contestant the same way so the battle panes mirror the live
+            // stream; done BEFORE the first prompt so the whole turn flows
+            // through the by-id entry (no mid-turn hydrate needed).
+            attachDelegationChild({
+              connectionId,
+              parentConnectionId: connectionId,
+              parentToolUseId: `pk-arena-${round.id}`,
+              agentType,
+            })
+          }
+          await applyPermissionMode(
+            connectionStore,
+            setMode,
+            setConfigOption,
+            contextKey,
+            connectionId,
+            round.permissionMode
+          )
+          const prepared = await applyPreparedOptions(
+            connectionStore,
+            setConfigOption,
+            contextKey,
+            connectionId,
+            round.effort
+          )
+          updateContestant(round.id, slot, {
+            status: "ready",
+            modelOptions: prepared.modelOptions,
+            modelConfigId: prepared.modelConfigId,
+            effortOptions: prepared.effortOptions,
+            effortConfigId: prepared.effortConfigId,
+            selectedModel: prepared.selectedModel,
+            selectedEffort: prepared.selectedEffort,
+            // 诊断:无选择器时把原因写进面板可见的 statusDetail。
+            statusDetail:
+              prepared.modelOptions.length === 0 &&
+              prepared.effortOptions.length === 0
+                ? `no selectors (configOptions ${prepared.diagnostic})`
+                : null,
+          })
+        } catch (error) {
+          updateContestant(round.id, slot, {
+            status: "error",
+            statusDetail: `connect/prompt: ${String(error)}`,
+          })
+        }
+      }
+
+      const fresh = usePkArenaStore
+        .getState()
+        .rounds.find((r) => r.id === round.id)
+      if (fresh && fresh.contestants.every((c) => c.status === "error")) {
+        markRound(round.id, "canceled")
+      }
+    },
+    [
+      connect,
+      connectionStore,
+      markRound,
+      setMode,
+      setConfigOption,
+      updateContestant,
+      attachDelegationChild,
+    ]
+  )
+
+  const cancelRound = useCallback(
+    async (round: PkRound) => {
+      markRound(round.id, "canceled")
+      for (const contestant of round.contestants) {
+        if (
+          contestant.status === "done" ||
+          contestant.status === "error" ||
+          contestant.status === "canceled"
+        ) {
+          continue
+        }
+        if (contestant.connectionId) {
+          detachDelegationChild(contestant.connectionId)
+        }
+        if (contestant.contextKey) {
+          try {
+            await cancel(contestant.contextKey)
+          } catch {
+            // A connection that never came up has nothing to cancel.
+          }
+          void disconnect(contestant.contextKey).catch(() => undefined)
+        }
+        if (contestant.conversationId != null) {
+          await updateConversationStatus(
+            contestant.conversationId,
+            "cancelled"
+          ).catch(() => undefined)
+        }
+        updateContestant(round.id, contestant.slot, {
+          status: "canceled",
+          endedAt: Date.now(),
+        })
+      }
+      // 取消后也触发裁判:已完成的选手(done)仍可参与评分。
+      // 复用 settleContestant 的逻辑——如果配了 judgeAgent 且
+      // judgeStatus === "idle",调 runJudge(修复 issue #1)。
+      const fresh = usePkArenaStore
+        .getState()
+        .rounds.find((r) => r.id === round.id)
+      if (fresh && fresh.judgeAgent && fresh.judgeStatus === "idle") {
+        const hasDone = fresh.contestants.some((c) => c.status === "done")
+        if (hasDone) {
+          void runJudgeRef.current(fresh)
+        }
+      }
+      if (fresh) void preparePkReportData(fresh).catch(() => undefined)
+    },
+    [cancel, detachDelegationChild, disconnect, markRound, updateContestant]
+  )
+
+  const cleanupRound = useCallback(
+    async (round: PkRound, keepBranches: boolean) => {
+      const freshRound =
+        usePkArenaStore
+          .getState()
+          .rounds.find((item) => item.id === round.id) ?? round
+      const reportData = await preparePkReportData(freshRound)
+      if (
+        reportData.source === "empty" &&
+        freshRound.contestants.some((contestant) => contestant.worktreePath)
+      ) {
+        throw new Error(
+          "Could not preserve the PK report; worktrees were not removed"
+        )
+      }
+      // Release the by-id viewer entries before the worktrees go.
+      for (const contestant of round.contestants) {
+        if (contestant.connectionId) {
+          detachDelegationChild(contestant.connectionId)
+        }
+      }
+      await Promise.allSettled(
+        round.contestants
+          .filter((c) => c.worktreePath != null && c.branchName != null)
+          .map((c) =>
+            gitRemoveWorktree(
+              c.worktreePath as string,
+              c.branchName as string,
+              round.folderId,
+              !keepBranches,
+              true
+            )
+          )
+      )
+      for (const contestant of round.contestants) {
+        updateContestant(round.id, contestant.slot, {
+          worktreePath: null,
+        })
+      }
+    },
+    [detachDelegationChild, updateContestant]
+  )
+
+  const startPrompt = useCallback(
+    async (round: PkRound) => {
+      markRound(round.id, "running")
+      await Promise.allSettled(
+        round.contestants
+          .filter((c) => c.status === "ready" && c.contextKey != null)
+          .map(async (contestant) => {
+            const contextKey = contestant.contextKey as string
+            try {
+              await sendPrompt(
+                contextKey,
+                taskPromptBlocks(
+                  round.task,
+                  contestant.worktreePath ?? round.workingDir,
+                  round.bareMode
+                ),
+                {
+                  folderId: round.folderId,
+                  conversationId: contestant.conversationId,
+                }
+              )
+              // sendPrompt 已下发,主动把选手推进到 running。
+              // 不依赖 status_changed(prompting) 事件——server 模式下该事件
+              // 可能因 attach stream 竞态丢失,导致选手永远停在 ready,
+              // 后续 turn_complete 因 status !== "running" 被忽略,round
+              // 卡死、裁判不触发(问题 #0)。
+              updateContestant(round.id, contestant.slot, {
+                status: "running",
+                startedAt: Date.now(),
+              })
+            } catch (error) {
+              updateContestant(round.id, contestant.slot, {
+                status: "error",
+                statusDetail: `prompt: ${String(error)}`,
+              })
+            }
+          })
+      )
+      const fresh = usePkArenaStore
+        .getState()
+        .rounds.find((r) => r.id === round.id)
+      if (fresh && fresh.contestants.every((c) => c.status === "error")) {
+        markRound(round.id, "canceled")
+      }
+    },
+    [markRound, sendPrompt, updateContestant]
+  )
+
+  /** Send a follow-up message to ONE contestant — the multi-turn / human-
+   *  intervention path. Only works when the contestant is done (its previous
+   *  turn settled) AND its connection is still alive (contextKey != null).
+   *  Pushes the contestant back to running so the scoreboard reflects the
+   *  new turn; the round stays "finished" if it was — the follow-up is a
+   *  single-contestant side turn, not a new round. */
+  const sendFollowUp = useCallback(
+    async (round: PkRound, contestant: PkContestant, message: string) => {
+      if (!contestant.contextKey || contestant.conversationId == null) return
+      const trimmed = message.trim()
+      if (!trimmed) return
+      const blocks: PromptInputBlock[] = [
+        {
+          type: "text",
+          text: [
+            trimmed,
+            "",
+            `Continue working inside this directory: ${contestant.worktreePath ?? round.workingDir}`,
+          ].join("\n"),
+        },
+      ]
+      try {
+        await sendPrompt(contestant.contextKey, blocks, {
+          folderId: round.folderId,
+          conversationId: contestant.conversationId,
+        })
+        updateContestant(round.id, contestant.slot, {
+          status: "running",
+          endedAt: null,
+          durationMs: null,
+        })
+      } catch (error) {
+        updateContestant(round.id, contestant.slot, {
+          status: "error",
+          statusDetail: `follow-up: ${String(error)}`,
+        })
+      }
+    },
+    [sendPrompt, updateContestant]
+  )
+
+  const applyContestantSelection = useCallback(
+    async (
+      round: PkRound,
+      contestant: PkContestant,
+      configId: string,
+      value: string
+    ) => {
+      if (!contestant.contextKey) return
+      try {
+        await setConfigOption(contestant.contextKey, configId, value)
+        if (configId === contestant.modelConfigId) {
+          const label = contestant.modelOptions.find(
+            (option) => option.value === value
+          )?.name
+          updateContestant(round.id, contestant.slot, {
+            selectedModel: value,
+            ...(label ? { label } : {}),
+          })
+        } else {
+          updateContestant(round.id, contestant.slot, {
+            selectedEffort: value,
+          })
+        }
+      } catch {
+        // 选择被拒(模型临时下架等)不致命。
+      }
+    },
+    [setConfigOption, updateContestant]
+  )
+
+  return {
+    startRound,
+    startPrompt,
+    sendFollowUp,
+    applyContestantSelection,
+    cancelRound,
+    disconnectFinished,
+    cleanupRound,
+    fetchDiff,
+    runJudge,
+  }
+}
diff --git a/src/i18n/messages/ar.json b/src/i18n/messages/ar.json
index aa5a67fc3..49ea57318 100644
--- a/src/i18n/messages/ar.json
+++ b/src/i18n/messages/ar.json
@@ -1737,8 +1737,17 @@
       "sectionFolders": "المجلدات",
       "sectionChats": "محادثة",
       "sectionRecent": "الأحدث",
+      "sectionPk": "ساحة PK",
       "noChats": "لا توجد محادثات",
       "noRecent": "لا توجد محادثات حديثة",
+      "noPk": "لا توجد جلسات PK",
+      "pkOpenArena": "Open this PK arena",
+      "pkArchive": "Archive the PK round",
+      "pkArchiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "pkArchiveSuccess": "PK round archived",
+      "pkArchiveFailed": "Archive failed: {message}",
+      "pkExpand": "Expand agent sessions",
+      "pkCollapse": "Collapse agent sessions",
       "showMoreRecent": "عرض المزيد ({count})",
       "noFolders": "لا توجد مجلدات مفتوحة",
       "newChatAction": "محادثة جديدة",
@@ -1860,7 +1869,8 @@
       "search": "بحث",
       "openSettings": "فتح الإعدادات",
       "backToConversations": "العودة إلى المحادثات",
-      "withShortcut": "{label} (اختصار: {shortcut})"
+      "withShortcut": "{label} (اختصار: {shortcut})",
+      "pkArena": "ساحة منافسة الوكلاء"
     },
     "statusBar": {
       "connection": {
@@ -2797,7 +2807,8 @@
         "mentionGroupAgent": "الوكلاء",
         "mentionGroupSession": "الجلسات",
         "mentionGroupCommit": "عمليات الإيداع",
-        "mentionGroupSkill": "المهارات"
+        "mentionGroupSkill": "المهارات",
+        "startPk": "منافسة الوكلاء"
       },
       "messageQueue": {
         "addToQueue": "إضافة للقائمة",
@@ -5113,6 +5124,179 @@
     "loadFailed": "تعذّر تحميل بيانات الاستهلاك",
     "truncatedNotice": "هذا النطاق واسع جدًا — الأرقام تغطي أحدث جزء منه فقط."
   },
+  "PkArena": {
+    "launcher": {
+      "title": "منافسة الوكلاء الأذكياء",
+      "description": "أرسل مهمة واحدة إلى عدة وكلاء في آنٍ واحد وقارن النتائج",
+      "contestantsLabel": "المتنافسون ({min}–{max})",
+      "noFolderHint": "تحتاج الساحة إلى مجلد فيه مستودع git — افتح واحدًا أولًا.",
+      "needMore": "اختر {count} وكلاء على الأقل لبدء المنافسة.",
+      "taskLabel": "المهمة",
+      "taskPlaceholder": "المهمة نفسها التي يتلقاها كل متنافس، مثال: \"اكتب لعبة الثعبان في ملف HTML واحد\"",
+      "selectedCount": "تم اختيار {selected}/{max} (الحد الأدنى {min})",
+      "cancel": "إلغاء",
+      "start": "ابدأ المنافسة",
+      "notAGitRepo": "هذا المجلد ليس مستودع git — تحتاج الساحة إلى مستودع لمنح كل متنافس شجرة عمل معزولة.",
+      "initGitRepo": "git init",
+      "initializing": "جارٍ التهيئة…",
+      "permissionLabel": "الأذونات",
+      "permissionOptions": {
+        "default": "اسأل في كل مرة",
+        "acceptEdits": "اقبل التعديلات تلقائيًا",
+        "bypassPermissions": "تشغيل كامل"
+      },
+      "permissionHints": {
+        "default": "كل موافقة توقف المتنافس",
+        "acceptEdits": "تعديلات الملفات دون سؤال",
+        "bypassPermissions": "لا موافقات إطلاقًا"
+      },
+      "permissionNote": "تُطبق على كل متنافس عند بدء الجولة; الوكلاء غير الداعمة يستمرون في السؤال.",
+      "bareModeLabel": "الوضع الأساسي (بدون مهارات)",
+      "bareModeHint": "يُطلب من المتنافسين استخدام قدراتهم الأساسية فقط، دون أي مهارات عامة أو مشروع.",
+      "effortLabel": "مستوى التفكير (موحد لجميع المتنافسين)",
+      "effortOptions": {
+        "default": "افتراضي",
+        "low": "منخفض",
+        "medium": "متوسط",
+        "high": "مرتفع",
+        "max": "أقصى"
+      },
+      "effortNote": "يُطبق أقرب مستوى مُعلن لكل وكيل; الوكلاء غير الداعمين يحتفظون بإعداداتهم.",
+      "agentNotReady": "{agent} غير جاهز (ثبّته من إعدادات الوكلاء أولاً).",
+      "agentCheckFailed": "تعذّر التحقق من {agent}.",
+      "templates": {
+        "pelican": "بجعة",
+        "bouncingBall": "كرة",
+        "jellyBlob": "هلام",
+        "snake": "الثعبان",
+        "flappyBird": "Flappy Bird",
+        "voiceChat": "دردشة صوتية",
+        "blackHole": "ثقب أسود"
+      },
+      "judgeLabel": "حَكَم (اختياري)",
+      "judgeNone": "بدون حَكَم",
+      "judgeHint": "بعد انتهاء جميع المتسابقين، يقرأ هذا الوكيل كل فرق وينتج حكمًا منظماً بالدرجات والترتيب.",
+      "startPoint": "📍 نقطة البداية",
+      "fromHead": "من HEAD الحالي",
+      "startPointHint": "يبدأ المتسابقون من التزام قبل هذا — لا يرون تغييراته، بل رسالته كمهمة. يعيدون نفس الهدف بشكل مستقل.",
+      "loadingCommits": "جارٍ تحميل الالتزامات…",
+      "noCommits": "لم يتم العثور على التزامات.",
+      "creativeTemplates": "قوالب إبداعية",
+      "realEngineering": "هندسة حقيقية",
+      "loadMore": "تحميل المزيد",
+      "judgeDimensionsLabel": "أبعاد التقييم (اختياري)",
+      "judgeDimensionsPlaceholder": "Correctness — does it fulfill the task?\nCode quality — readability, structure, edge cases\nCompleteness — how much of the task is done?\nEfficiency — code-level efficiency (ignore token/time)",
+      "judgeDimensionsHint": "بُعد واحد لكل سطر. اتركه فارغًا لاستخدام الافتراضي.",
+      "addContestant": "إضافة {agent} كمتسابق",
+      "slotLabelPlaceholder": "تسمية (مثل Sonnet، Opus)",
+      "slotNumber": "المتنافس {number}",
+      "modelLoading": "جارٍ تحميل النماذج…",
+      "modelUnavailable": "يستخدم هذا الوكيل نموذجه الافتراضي",
+      "modelLoadFailed": "تعذر تحميل النماذج",
+      "retryModelLoad": "إعادة تحميل النماذج",
+      "removeSlot": "إزالة هذا المتسابق"
+    },
+    "scoreboard": {
+      "status": {
+        "preparing": "قيد التحضير",
+        "connecting": "قيد الاتصال",
+        "running": "قيد التشغيل",
+        "done": "تم",
+        "error": "فشل",
+        "canceled": "ملغى",
+        "ready": "جاهز"
+      },
+      "tokensUnit": "توكن",
+      "tokensUnavailable": "Token not reported",
+      "tokensUnavailableHint": "This agent did not return token usage; this does not mean zero tokens.",
+      "turnsUnit": "أدوار"
+    },
+    "history": {
+      "title": "Round history",
+      "hint": "Search, open, and archive complete rounds.",
+      "trigger": "History {count}",
+      "searchPlaceholder": "Search tasks or agents…",
+      "empty": "No matching rounds",
+      "agents": "{count} agents",
+      "archive": "Archive round",
+      "archiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "archiveSuccess": "PK round archived",
+      "archiveFailed": "Archive failed: {message}",
+      "status": {
+        "ready": "Ready",
+        "running": "Running",
+        "finished": "Finished",
+        "canceled": "Canceled",
+        "interrupted": "Interrupted"
+      }
+    },
+    "arena": {
+      "title": "ساحة منافسة الوكلاء",
+      "description": "مهمة واحدة، عدة وكلاء، جنبًا إلى جنب",
+      "roundStatus": {
+        "running": "مباشر",
+        "finished": "انتهت",
+        "canceled": "ملغاة",
+        "interrupted": "قُطعت بإعادة التشغيل",
+        "ready": "جاهز"
+      },
+      "roundPicker": "الجولة",
+      "cancelRound": "إلغاء الجولة",
+      "cleanupWorktrees": "تنظيف أشجار العمل",
+      "cleanupHint": "إزالة أشجار عمل المتنافسين (تُحفظ الفروع)",
+      "share": "مشاركة",
+      "sharing": "جارٍ التصدير…",
+      "tabs": {
+        "battle": "المنافسة",
+        "diff": "الفروقات"
+      },
+      "preparing": "جارٍ تحضير المتنافس…",
+      "noRound": "لم تُحدد جولة",
+      "contestantsUnit": "وكلاء",
+      "newRound": "جولة جديدة",
+      "startMatch": "ابدأ المباراة",
+      "readyNote": "اختر نموذج ومستوى تفكير كل متنافس ثم ابدأ.",
+      "modelLabel": "النموذج",
+      "effortLabel": "مستوى التفكير",
+      "effortUnsupported": "هذا الوكيل لا يوفّر إعداد مستويات التفكير؛ ستُستخدم قيمته الافتراضية",
+      "effortOptions": {
+        "off": "إيقاف",
+        "minimal": "الحد الأدنى",
+        "low": "منخفض",
+        "medium": "متوسط",
+        "high": "مرتفع",
+        "max": "الأقصى"
+      },
+      "minimize": "تصغير",
+      "exportReport": "تصدير التقرير",
+      "exporting": "جارٍ الإنشاء…",
+      "shareReport": "Save / share report",
+      "reportSaved": "HTML report saved",
+      "reportFailed": "Report export failed: {message}",
+      "persistenceFailed": "تعذر حفظ بعض تغييرات الجولة. أعد المحاولة قبل إغلاق هذه الصفحة.",
+      "retrySave": "إعادة محاولة الحفظ",
+      "readyTag": "جاهز",
+      "deleteRound": "حذف",
+      "deleteConfirm": "حذف هذه الجولة? تبقى أشجار العمل على القرص — استخدم تنظيف أشجار العمل.",
+      "followUp": "متابعة",
+      "followUpPlaceholder": "إرسال إلى هذا المتسابق فقط (⌘↩ للإرسال)"
+    },
+    "diff": {
+      "loading": "جارٍ تحميل الفروقات…",
+      "empty": "لا تغييرات في شجرة العمل هذه"
+    },
+    "judge": {
+      "title": "حكم الحَكَم",
+      "running": "يقيم…",
+      "error": "فشل الحَكَم",
+      "rerun": "إعادة التقييم"
+    },
+    "minimized": {
+      "restore": "العودة إلى الساحة",
+      "live": "منافسة قيد التشغيل",
+      "dismiss": "إخفاء"
+    }
+  },
   "Forge": {
     "title": "لوحة المستودع",
     "pickFolder": "اختر مجلد مشروع",
diff --git a/src/i18n/messages/de.json b/src/i18n/messages/de.json
index 36e66b12c..772876886 100644
--- a/src/i18n/messages/de.json
+++ b/src/i18n/messages/de.json
@@ -1737,8 +1737,17 @@
       "sectionFolders": "Ordner",
       "sectionChats": "Chat",
       "sectionRecent": "Zuletzt",
+      "sectionPk": "PK-Arena",
       "noChats": "Keine Chats",
       "noRecent": "Keine kürzlichen Konversationen",
+      "noPk": "Keine PK-Sitzungen",
+      "pkOpenArena": "Open this PK arena",
+      "pkArchive": "Archive the PK round",
+      "pkArchiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "pkArchiveSuccess": "PK round archived",
+      "pkArchiveFailed": "Archive failed: {message}",
+      "pkExpand": "Expand agent sessions",
+      "pkCollapse": "Collapse agent sessions",
       "showMoreRecent": "Mehr anzeigen ({count})",
       "noFolders": "Keine Ordner geöffnet",
       "newChatAction": "Neuer Chat",
@@ -1860,7 +1869,8 @@
       "search": "Suchen",
       "openSettings": "Einstellungen öffnen",
       "backToConversations": "Zurück zu Konversationen",
-      "withShortcut": "{label} (Tastenkürzel: {shortcut})"
+      "withShortcut": "{label} (Tastenkürzel: {shortcut})",
+      "pkArena": "Agenten-PK-Arena"
     },
     "statusBar": {
       "connection": {
@@ -2797,7 +2807,8 @@
         "mentionGroupAgent": "Agenten",
         "mentionGroupSession": "Sitzungen",
         "mentionGroupCommit": "Commits",
-        "mentionGroupSkill": "Fähigkeiten"
+        "mentionGroupSkill": "Fähigkeiten",
+        "startPk": "Agenten-PK"
       },
       "messageQueue": {
         "addToQueue": "Zur Warteschlange",
@@ -5113,6 +5124,179 @@
     "loadFailed": "Verbrauch konnte nicht geladen werden",
     "truncatedNotice": "Dieser Zeitraum ist sehr groß — die Zahlen decken nur seinen jüngsten Abschnitt ab."
   },
+  "PkArena": {
+    "launcher": {
+      "title": "Agenten-PK",
+      "description": "Eine Aufgabe gleichzeitig an mehrere Agenten senden und die Ergebnisse vergleichen",
+      "contestantsLabel": "Teilnehmer ({min}–{max})",
+      "noFolderHint": "Die Arena braucht einen Ordner mit einem Git-Repository — öffne zuerst einen.",
+      "needMore": "Wähle mindestens {count} Agenten für ein Duell.",
+      "taskLabel": "Aufgabe",
+      "taskPlaceholder": "Die Aufgabe, die jeder Teilnehmer erhält, z. B. \"Schreibe ein Snake-Spiel in einer einzigen HTML-Datei\"",
+      "selectedCount": "{selected}/{max} gewählt (min. {min})",
+      "cancel": "Abbrechen",
+      "start": "Kampf starten",
+      "notAGitRepo": "Dieser Ordner ist kein Git-Repository — die Arena braucht eines, um jedem Teilnehmer einen isolierten Worktree zu geben.",
+      "initGitRepo": "git init",
+      "initializing": "Initialisiere…",
+      "permissionLabel": "Berechtigungen",
+      "permissionOptions": {
+        "default": "Jedes Mal fragen",
+        "acceptEdits": "Bearbeitungen automatisch",
+        "bypassPermissions": "Vollautomatik"
+      },
+      "permissionHints": {
+        "default": "jede Freigabe unterbricht den Teilnehmer",
+        "acceptEdits": "Dateibearbeitungen ohne Nachfrage",
+        "bypassPermissions": "gar keine Freigaben"
+      },
+      "permissionNote": "Wird beim Start auf jeden Teilnehmer angewendet; Agenten ohne Unterstützung fragen weiter.",
+      "bareModeLabel": "Bare-Modus (keine Skills)",
+      "bareModeHint": "Teilnehmer dürfen nur ihre Grundfunktionen nutzen — keine globalen oder Projekt-Skills.",
+      "effortLabel": "Denkaufwand (einheitlich)",
+      "effortOptions": {
+        "default": "Standard",
+        "low": "Niedrig",
+        "medium": "Mittel",
+        "high": "Hoch",
+        "max": "Max"
+      },
+      "effortNote": "Wird als nächste verfügbare Stufe je Agent angewendet; ohne Unterstützung bleibt der Standard.",
+      "agentNotReady": "{agent} nicht bereit (zuerst in den Agent-Einstellungen installieren).",
+      "agentCheckFailed": "{agent} konnte nicht geprüft werden.",
+      "templates": {
+        "pelican": "Pelikan",
+        "bouncingBall": "Ball",
+        "jellyBlob": "Gelee",
+        "snake": "Snake",
+        "flappyBird": "Flappy Bird",
+        "voiceChat": "Sprachchat",
+        "blackHole": "Schwarzes Loch"
+      },
+      "judgeLabel": "Schiedsrichter (optional)",
+      "judgeNone": "Kein Schiedsrichter",
+      "judgeHint": "Nachdem alle Teilnehmer fertig sind, liest dieser Agent jeden Diff und erstellt ein strukturiertes Urteil mit Punktzahlen und Rängen.",
+      "startPoint": "📍 Startpunkt",
+      "fromHead": "ab aktuellem HEAD",
+      "startPointHint": "Teilnehmer beginnen einen Commit davor — sie sehen diese Änderungen nicht, nur die Commit-Nachricht als Aufgabe. Sie machen dasselbe Ziel unabhängig.",
+      "loadingCommits": "Commits laden…",
+      "noCommits": "Keine Commits gefunden.",
+      "creativeTemplates": "Kreative Vorlagen",
+      "realEngineering": "Echte Entwicklung",
+      "loadMore": "Mehr laden",
+      "judgeDimensionsLabel": "Bewertungsdimensionen (optional)",
+      "judgeDimensionsPlaceholder": "Correctness — erfüllt es die Aufgabe?\nCode quality — Lesbarkeit, Struktur, Randfälle\nCompleteness — wie viel ist erledigt?\nEfficiency — Code-Effizienz (ohne Token/Zeit)",
+      "judgeDimensionsHint": "Eine Dimension pro Zeile. Leer lassen für Standardwerte.",
+      "addContestant": "{agent} als Teilnehmer hinzufügen",
+      "slotLabelPlaceholder": "Label (z.B. Sonnet, Opus)",
+      "slotNumber": "Teilnehmer {number}",
+      "modelLoading": "Modelle werden geladen…",
+      "modelUnavailable": "Dieser Agent verwendet sein Standardmodell",
+      "modelLoadFailed": "Modelle konnten nicht geladen werden",
+      "retryModelLoad": "Modelle erneut laden",
+      "removeSlot": "Diesen Teilnehmer-Slot entfernen"
+    },
+    "scoreboard": {
+      "status": {
+        "preparing": "Vorbereitung",
+        "connecting": "Verbinde",
+        "running": "Läuft",
+        "done": "Fertig",
+        "error": "Fehlgeschlagen",
+        "canceled": "Abgebrochen",
+        "ready": "Bereit"
+      },
+      "tokensUnit": "Tok",
+      "tokensUnavailable": "Token not reported",
+      "tokensUnavailableHint": "This agent did not return token usage; this does not mean zero tokens.",
+      "turnsUnit": "Runden"
+    },
+    "history": {
+      "title": "Round history",
+      "hint": "Search, open, and archive complete rounds.",
+      "trigger": "History {count}",
+      "searchPlaceholder": "Search tasks or agents…",
+      "empty": "No matching rounds",
+      "agents": "{count} agents",
+      "archive": "Archive round",
+      "archiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "archiveSuccess": "PK round archived",
+      "archiveFailed": "Archive failed: {message}",
+      "status": {
+        "ready": "Ready",
+        "running": "Running",
+        "finished": "Finished",
+        "canceled": "Canceled",
+        "interrupted": "Interrupted"
+      }
+    },
+    "arena": {
+      "title": "Agenten-PK-Arena",
+      "description": "Eine Aufgabe, mehrere Agenten, Seite an Seite",
+      "roundStatus": {
+        "running": "Live",
+        "finished": "Beendet",
+        "canceled": "Abgebrochen",
+        "interrupted": "Durch Neustart unterbrochen",
+        "ready": "Bereit"
+      },
+      "roundPicker": "Runde",
+      "cancelRound": "Runde abbrechen",
+      "cleanupWorktrees": "Worktrees bereinigen",
+      "cleanupHint": "Worktrees der Teilnehmer entfernen (Branches bleiben)",
+      "share": "Teilen",
+      "sharing": "Exportiere…",
+      "tabs": {
+        "battle": "Kampf",
+        "diff": "Diff"
+      },
+      "preparing": "Teilnehmer wird vorbereitet…",
+      "noRound": "Keine Runde ausgewählt",
+      "contestantsUnit": "Agenten",
+      "newRound": "Neue Runde",
+      "startMatch": "Kampf starten",
+      "readyNote": "Modell und Denkaufwand je Teilnehmer wählen, dann starten.",
+      "modelLabel": "Modell",
+      "effortLabel": "Denkaufwand",
+      "effortUnsupported": "Dieser Agent bietet keine Denkstufen an; sein Standardwert wird verwendet",
+      "effortOptions": {
+        "off": "Aus",
+        "minimal": "Minimal",
+        "low": "Niedrig",
+        "medium": "Mittel",
+        "high": "Hoch",
+        "max": "Maximum"
+      },
+      "minimize": "Minimieren",
+      "exportReport": "Bericht exportieren",
+      "exporting": "Erstelle…",
+      "shareReport": "Save / share report",
+      "reportSaved": "HTML report saved",
+      "reportFailed": "Report export failed: {message}",
+      "persistenceFailed": "Einige Änderungen der Runde konnten nicht gespeichert werden. Wiederhole die Aktion, bevor du diese Seite schließt.",
+      "retrySave": "Speichern wiederholen",
+      "readyTag": "Bereit",
+      "deleteRound": "Löschen",
+      "deleteConfirm": "Diese Runde löschen? Worktrees bleiben auf der Platte — über 'Worktrees bereinigen' entfernen.",
+      "followUp": "Nachfassen",
+      "followUpPlaceholder": "Nur an diesen Teilnehmer senden (⌘↩ zum Senden)"
+    },
+    "diff": {
+      "loading": "Diff wird geladen…",
+      "empty": "Keine Änderungen in diesem Worktree"
+    },
+    "judge": {
+      "title": "Schiedsrichterurteil",
+      "running": "Auswertung…",
+      "error": "Schiedsrichter fehlgeschlagen",
+      "rerun": "Neu bewerten"
+    },
+    "minimized": {
+      "restore": "Zurück zur Arena",
+      "live": "PK läuft",
+      "dismiss": "Ausblenden"
+    }
+  },
   "Forge": {
     "title": "Repository-Panel",
     "pickFolder": "Projektordner wählen",
diff --git a/src/i18n/messages/en.json b/src/i18n/messages/en.json
index 6e9e380e4..2f7f84920 100644
--- a/src/i18n/messages/en.json
+++ b/src/i18n/messages/en.json
@@ -1737,8 +1737,17 @@
       "sectionFolders": "Folders",
       "sectionChats": "Chat",
       "sectionRecent": "Recent",
+      "sectionPk": "PK Arena",
       "noChats": "No chats",
       "noRecent": "No recent conversations",
+      "noPk": "No PK arena sessions",
+      "pkOpenArena": "Open this PK arena",
+      "pkArchive": "Archive the PK round",
+      "pkArchiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "pkArchiveSuccess": "PK round archived",
+      "pkArchiveFailed": "Archive failed: {message}",
+      "pkExpand": "Expand agent sessions",
+      "pkCollapse": "Collapse agent sessions",
       "showMoreRecent": "Show more ({count})",
       "noFolders": "No folders open",
       "newChatAction": "New chat",
@@ -1860,7 +1869,8 @@
       "search": "Search",
       "openSettings": "Open Settings",
       "backToConversations": "Back to Conversations",
-      "withShortcut": "{label} ({shortcut})"
+      "withShortcut": "{label} ({shortcut})",
+      "pkArena": "Agent PK arena"
     },
     "statusBar": {
       "connection": {
@@ -2797,7 +2807,8 @@
         "mentionGroupAgent": "Agents",
         "mentionGroupSession": "Sessions",
         "mentionGroupCommit": "Commits",
-        "mentionGroupSkill": "Skills"
+        "mentionGroupSkill": "Skills",
+        "startPk": "Agent PK"
       },
       "messageQueue": {
         "addToQueue": "Queue message",
@@ -5113,6 +5124,179 @@
     "loadFailed": "Could not load usage",
     "truncatedNotice": "This range is very large — the numbers cover only the most recent slice of it."
   },
+  "PkArena": {
+    "launcher": {
+      "title": "Agent PK",
+      "description": "Send one task to several agents at once and compare the results",
+      "contestantsLabel": "Contestants ({min}–{max})",
+      "noFolderHint": "The arena needs a folder with a git repository — open one first.",
+      "needMore": "Pick at least {count} agents to run a match.",
+      "taskLabel": "Task",
+      "taskPlaceholder": "The task every contestant gets, e.g. \"Write a snake game in a single HTML file\"",
+      "selectedCount": "{selected}/{max} picked (min {min})",
+      "addContestant": "Add {agent} as contestant",
+      "slotLabelPlaceholder": "Label (e.g. Sonnet, Opus)",
+      "slotNumber": "Contestant {number}",
+      "modelLoading": "Loading models…",
+      "modelUnavailable": "This agent uses its default model",
+      "modelLoadFailed": "Could not load models",
+      "retryModelLoad": "Retry loading models",
+      "removeSlot": "Remove this contestant slot",
+      "cancel": "Cancel",
+      "start": "Start match",
+      "notAGitRepo": "This folder is not a git repository — the arena needs one to give each contestant an isolated worktree.",
+      "initGitRepo": "git init",
+      "initializing": "Initializing…",
+      "permissionLabel": "Permissions",
+      "permissionOptions": {
+        "default": "Ask every time",
+        "acceptEdits": "Auto-accept edits",
+        "bypassPermissions": "Full auto"
+      },
+      "permissionHints": {
+        "default": "each approval interrupts the contestant",
+        "acceptEdits": "file edits run without asking",
+        "bypassPermissions": "no approval prompts at all"
+      },
+      "permissionNote": "Applied per contestant when the round starts; agents that don't support a mode keep asking.",
+      "bareModeLabel": "Bare mode (no skills)",
+      "bareModeHint": "Contestants are instructed to use only their built-in capabilities — no global or project skills.",
+      "effortLabel": "Reasoning effort (all contestants)",
+      "effortOptions": {
+        "default": "Default",
+        "low": "Low",
+        "medium": "Medium",
+        "high": "High",
+        "max": "Max"
+      },
+      "effortNote": "Applied as the nearest advertised level per agent; agents without the option keep their default.",
+      "agentNotReady": "{agent} is not ready (install it from Agent Settings first).",
+      "agentCheckFailed": "Could not verify {agent}; check its installation.",
+      "templates": {
+        "pelican": "Pelican",
+        "bouncingBall": "Bouncing Ball",
+        "jellyBlob": "Jelly Blob",
+        "snake": "Snake",
+        "flappyBird": "Flappy Bird",
+        "voiceChat": "Voice Chat",
+        "blackHole": "Black Hole"
+      },
+      "judgeLabel": "Judge (optional)",
+      "judgeNone": "No judge",
+      "judgeHint": "After all contestants finish, this agent reads every diff and produces a structured verdict with scores and rankings.",
+      "judgeDimensionsLabel": "Scoring dimensions (optional)",
+      "judgeDimensionsPlaceholder": "Correctness — does it fulfill the task?\nCode quality — readability, structure, edge cases\nCompleteness — how much of the task is done?\nEfficiency — code-level efficiency (ignore token/time)",
+      "judgeDimensionsHint": "One dimension per line. Leave blank to use the defaults. Each becomes a numbered criterion in the judge prompt.",
+      "startPoint": "📍 Start point",
+      "fromHead": "from current HEAD",
+      "startPointHint": "Contestants branch from one commit BEFORE this — they never see its changes, only its message as the task. So they redo the same goal independently.",
+      "loadingCommits": "Loading commits…",
+      "noCommits": "No commits found.",
+      "creativeTemplates": "Creative templates",
+      "realEngineering": "Real engineering",
+      "loadMore": "Load more"
+    },
+    "scoreboard": {
+      "status": {
+        "preparing": "preparing",
+        "connecting": "connecting",
+        "running": "running",
+        "done": "done",
+        "error": "failed",
+        "canceled": "canceled",
+        "ready": "ready"
+      },
+      "tokensUnit": "tok",
+      "tokensUnavailable": "Token not reported",
+      "tokensUnavailableHint": "This agent did not return token usage; this does not mean zero tokens.",
+      "turnsUnit": "turns"
+    },
+    "history": {
+      "title": "Round history",
+      "hint": "Search, open, and archive complete rounds.",
+      "trigger": "History {count}",
+      "searchPlaceholder": "Search tasks or agents…",
+      "empty": "No matching rounds",
+      "agents": "{count} agents",
+      "archive": "Archive round",
+      "archiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "archiveSuccess": "PK round archived",
+      "archiveFailed": "Archive failed: {message}",
+      "status": {
+        "ready": "Ready",
+        "running": "Running",
+        "finished": "Finished",
+        "canceled": "Canceled",
+        "interrupted": "Interrupted"
+      }
+    },
+    "arena": {
+      "title": "Agent PK arena",
+      "description": "One task, several agents, side by side",
+      "roundStatus": {
+        "running": "Live",
+        "finished": "Finished",
+        "canceled": "Canceled",
+        "interrupted": "Interrupted by restart",
+        "ready": "Ready"
+      },
+      "roundPicker": "Round",
+      "cancelRound": "Cancel round",
+      "cleanupWorktrees": "Clean worktrees",
+      "cleanupHint": "Remove the contestants' worktrees (branches are kept)",
+      "share": "Share",
+      "sharing": "Exporting…",
+      "tabs": {
+        "battle": "Battle",
+        "diff": "Diff"
+      },
+      "preparing": "Preparing contestant…",
+      "noRound": "No round selected",
+      "contestantsUnit": "agents",
+      "newRound": "New round",
+      "startMatch": "Start match",
+      "readyNote": "Confirm the model and reasoning levels each contestant actually supports, then start the match.",
+      "modelLabel": "Model",
+      "effortLabel": "Reasoning effort",
+      "effortUnsupported": "This agent does not expose reasoning levels; its default will be used",
+      "effortOptions": {
+        "off": "Off",
+        "minimal": "Minimal",
+        "low": "Low",
+        "medium": "Medium",
+        "high": "High",
+        "max": "Max"
+      },
+      "minimize": "Minimize",
+      "exportReport": "Export report",
+      "exporting": "Building…",
+      "shareReport": "Save / share report",
+      "reportSaved": "HTML report saved",
+      "reportFailed": "Report export failed: {message}",
+      "persistenceFailed": "Some round changes could not be saved. Retry the action before closing this page.",
+      "retrySave": "Retry save",
+      "readyTag": "Ready",
+      "deleteRound": "Delete",
+      "deleteConfirm": "Delete this round? (worktrees stay on disk — use Clean worktrees to remove them)",
+      "followUp": "Follow-up",
+      "followUpPlaceholder": "Send a follow-up message to this contestant only (⌘↩ to send)"
+    },
+    "diff": {
+      "loading": "Loading diff…",
+      "empty": "No changes in this worktree"
+    },
+    "judge": {
+      "title": "Judge Verdict",
+      "running": "Evaluating…",
+      "error": "Judge failed",
+      "rerun": "Re-evaluate"
+    },
+    "minimized": {
+      "restore": "Back to the arena",
+      "live": "PK in progress",
+      "dismiss": "Hide pill"
+    }
+  },
   "Forge": {
     "title": "Repository panel",
     "pickFolder": "Pick a project folder",
diff --git a/src/i18n/messages/es.json b/src/i18n/messages/es.json
index 0c543e2c9..824c2280b 100644
--- a/src/i18n/messages/es.json
+++ b/src/i18n/messages/es.json
@@ -1737,8 +1737,17 @@
       "sectionFolders": "Carpetas",
       "sectionChats": "Chat",
       "sectionRecent": "Recientes",
+      "sectionPk": "Arena PK",
       "noChats": "Sin chats",
       "noRecent": "Sin conversaciones recientes",
+      "noPk": "Sin sesiones PK",
+      "pkOpenArena": "Open this PK arena",
+      "pkArchive": "Archive the PK round",
+      "pkArchiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "pkArchiveSuccess": "PK round archived",
+      "pkArchiveFailed": "Archive failed: {message}",
+      "pkExpand": "Expand agent sessions",
+      "pkCollapse": "Collapse agent sessions",
       "showMoreRecent": "Mostrar más ({count})",
       "noFolders": "No hay carpetas abiertas",
       "newChatAction": "Nuevo chat",
@@ -1860,7 +1869,8 @@
       "search": "Buscar",
       "openSettings": "Abrir configuración",
       "backToConversations": "Volver a conversaciones",
-      "withShortcut": "{label} (atajo: {shortcut})"
+      "withShortcut": "{label} (atajo: {shortcut})",
+      "pkArena": "Arena PK de agentes"
     },
     "statusBar": {
       "connection": {
@@ -2797,7 +2807,8 @@
         "mentionGroupAgent": "Agentes",
         "mentionGroupSession": "Sesiones",
         "mentionGroupCommit": "Commits",
-        "mentionGroupSkill": "Habilidades"
+        "mentionGroupSkill": "Habilidades",
+        "startPk": "PK de agentes"
       },
       "messageQueue": {
         "addToQueue": "Agregar a la cola",
@@ -5113,6 +5124,179 @@
     "loadFailed": "No se pudo cargar el uso",
     "truncatedNotice": "Este periodo es muy amplio: las cifras cubren solo su tramo más reciente."
   },
+  "PkArena": {
+    "launcher": {
+      "title": "PK de agentes",
+      "description": "Envía una tarea a varios agentes a la vez y compara los resultados",
+      "contestantsLabel": "Contendientes ({min}–{max})",
+      "noFolderHint": "La arena necesita una carpeta con un repositorio git: abre una primero.",
+      "needMore": "Elige al menos {count} agentes para iniciar el duelo.",
+      "taskLabel": "Tarea",
+      "taskPlaceholder": "La tarea que recibe cada contendiente, p. ej. \"Escribe un juego de snake en un solo archivo HTML\"",
+      "selectedCount": "{selected}/{max} elegidos (mín. {min})",
+      "cancel": "Cancelar",
+      "start": "Iniciar duelo",
+      "notAGitRepo": "Esta carpeta no es un repositorio git — la arena necesita uno para dar a cada contendiente un worktree aislado.",
+      "initGitRepo": "git init",
+      "initializing": "Inicializando…",
+      "permissionLabel": "Permisos",
+      "permissionOptions": {
+        "default": "Preguntar siempre",
+        "acceptEdits": "Aceptar ediciones",
+        "bypassPermissions": "Todo automático"
+      },
+      "permissionHints": {
+        "default": "cada aprobación interrumpe al contendiente",
+        "acceptEdits": "ediciones de archivos sin preguntar",
+        "bypassPermissions": "sin aprobaciones"
+      },
+      "permissionNote": "Se aplica a cada contendiente al iniciar; los agentes sin soporte siguen preguntando.",
+      "bareModeLabel": "Modo básico (sin habilidades)",
+      "bareModeHint": "Se pide a los contendientes usar solo sus capacidades básicas, sin habilidades globales ni del proyecto.",
+      "effortLabel": "Esfuerzo de razonamiento (uniforme)",
+      "effortOptions": {
+        "default": "Predeterminado",
+        "low": "Bajo",
+        "medium": "Medio",
+        "high": "Alto",
+        "max": "Máximo"
+      },
+      "effortNote": "Se aplica el nivel más cercano anunciado por cada agente; sin soporte, mantiene el suyo.",
+      "agentNotReady": "{agent} no está listo (instálalo en Configuración de agentes).",
+      "agentCheckFailed": "No se pudo verificar {agent}.",
+      "templates": {
+        "pelican": "Pelícano",
+        "bouncingBall": "Pelota",
+        "jellyBlob": "Gelatina",
+        "snake": "Snake",
+        "flappyBird": "Flappy Bird",
+        "voiceChat": "Chat por voz",
+        "blackHole": "Agujero Negro"
+      },
+      "judgeLabel": "Juez (opcional)",
+      "judgeNone": "Sin juez",
+      "judgeHint": "Cuando todos los concursantes terminen, este agente leerá cada diff y producirá un veredicto estructurado con puntuaciones y clasificaciones.",
+      "startPoint": "📍 Punto de partida",
+      "fromHead": "desde el HEAD actual",
+      "startPointHint": "Los concursantes parten un commit antes de este — no ven sus cambios, solo su mensaje como tarea. Repiten el mismo objetivo de forma independiente.",
+      "loadingCommits": "Cargando commits…",
+      "noCommits": "No se encontraron commits.",
+      "creativeTemplates": "Plantillas creativas",
+      "realEngineering": "Ingeniería real",
+      "loadMore": "Cargar más",
+      "judgeDimensionsLabel": "Dimensiones de evaluación (opcional)",
+      "judgeDimensionsPlaceholder": "Correctness — ¿cumple la tarea?\nCode quality — legibilidad, estructura, casos límite\nCompleteness — ¿cuánto está hecho?\nEfficiency — eficiencia del código (ignorar token/tiempo)",
+      "judgeDimensionsHint": "Una dimensión por línea. Déjalo vacío para usar los valores predeterminados.",
+      "addContestant": "Añadir {agent} como concursante",
+      "slotLabelPlaceholder": "Etiqueta (p. ej. Sonnet, Opus)",
+      "slotNumber": "Contendiente {number}",
+      "modelLoading": "Cargando modelos…",
+      "modelUnavailable": "Este agente usa su modelo predeterminado",
+      "modelLoadFailed": "No se pudieron cargar los modelos",
+      "retryModelLoad": "Volver a cargar los modelos",
+      "removeSlot": "Quitar este puesto de concursante"
+    },
+    "scoreboard": {
+      "status": {
+        "preparing": "preparando",
+        "connecting": "conectando",
+        "running": "ejecutando",
+        "done": "listo",
+        "error": "falló",
+        "canceled": "cancelado",
+        "ready": "listo"
+      },
+      "tokensUnit": "tok",
+      "tokensUnavailable": "Token not reported",
+      "tokensUnavailableHint": "This agent did not return token usage; this does not mean zero tokens.",
+      "turnsUnit": "turnos"
+    },
+    "history": {
+      "title": "Round history",
+      "hint": "Search, open, and archive complete rounds.",
+      "trigger": "History {count}",
+      "searchPlaceholder": "Search tasks or agents…",
+      "empty": "No matching rounds",
+      "agents": "{count} agents",
+      "archive": "Archive round",
+      "archiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "archiveSuccess": "PK round archived",
+      "archiveFailed": "Archive failed: {message}",
+      "status": {
+        "ready": "Ready",
+        "running": "Running",
+        "finished": "Finished",
+        "canceled": "Canceled",
+        "interrupted": "Interrupted"
+      }
+    },
+    "arena": {
+      "title": "Arena PK de agentes",
+      "description": "Una tarea, varios agentes, cara a cara",
+      "roundStatus": {
+        "running": "En vivo",
+        "finished": "Terminada",
+        "canceled": "Cancelada",
+        "interrupted": "Interrumpida por reinicio",
+        "ready": "Lista"
+      },
+      "roundPicker": "Ronda",
+      "cancelRound": "Cancelar ronda",
+      "cleanupWorktrees": "Limpiar worktrees",
+      "cleanupHint": "Elimina los worktrees de los contendientes (las ramas se conservan)",
+      "share": "Compartir",
+      "sharing": "Exportando…",
+      "tabs": {
+        "battle": "Duelo",
+        "diff": "Diff"
+      },
+      "preparing": "Preparando contendiente…",
+      "noRound": "Ninguna ronda seleccionada",
+      "contestantsUnit": "agentes",
+      "newRound": "Nueva ronda",
+      "startMatch": "Iniciar duelo",
+      "readyNote": "Elige modelo y esfuerzo de cada contendiente y luego inicia.",
+      "modelLabel": "Modelo",
+      "effortLabel": "Esfuerzo",
+      "effortUnsupported": "Este agente no permite configurar niveles de razonamiento; se usará su valor predeterminado",
+      "effortOptions": {
+        "off": "Desactivado",
+        "minimal": "Mínimo",
+        "low": "Bajo",
+        "medium": "Medio",
+        "high": "Alto",
+        "max": "Máximo"
+      },
+      "minimize": "Minimizar",
+      "exportReport": "Exportar informe",
+      "exporting": "Generando…",
+      "shareReport": "Save / share report",
+      "reportSaved": "HTML report saved",
+      "reportFailed": "Report export failed: {message}",
+      "persistenceFailed": "No se pudieron guardar algunos cambios de la ronda. Reintenta la acción antes de cerrar esta página.",
+      "retrySave": "Reintentar guardado",
+      "readyTag": "Listo",
+      "deleteRound": "Eliminar",
+      "deleteConfirm": "¿Eliminar esta ronda? Los worktrees permanecen — use Limpiar worktrees.",
+      "followUp": "Continuar",
+      "followUpPlaceholder": "Enviar solo a este concursante (⌘↩ para enviar)"
+    },
+    "diff": {
+      "loading": "Cargando diff…",
+      "empty": "Sin cambios en este worktree"
+    },
+    "judge": {
+      "title": "Veredicto del juez",
+      "running": "Evaluando…",
+      "error": "El juez falló",
+      "rerun": "Reevaluar"
+    },
+    "minimized": {
+      "restore": "Volver a la arena",
+      "live": "PK en curso",
+      "dismiss": "Ocultar"
+    }
+  },
   "Forge": {
     "title": "Panel del repositorio",
     "pickFolder": "Elige una carpeta de proyecto",
diff --git a/src/i18n/messages/fr.json b/src/i18n/messages/fr.json
index 36f3499eb..fe40e7e63 100644
--- a/src/i18n/messages/fr.json
+++ b/src/i18n/messages/fr.json
@@ -1737,8 +1737,17 @@
       "sectionFolders": "Dossiers",
       "sectionChats": "Discussion",
       "sectionRecent": "Récents",
+      "sectionPk": "Arène PK",
       "noChats": "Aucune discussion",
       "noRecent": "Aucune conversation récente",
+      "noPk": "Aucune session PK",
+      "pkOpenArena": "Open this PK arena",
+      "pkArchive": "Archive the PK round",
+      "pkArchiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "pkArchiveSuccess": "PK round archived",
+      "pkArchiveFailed": "Archive failed: {message}",
+      "pkExpand": "Expand agent sessions",
+      "pkCollapse": "Collapse agent sessions",
       "showMoreRecent": "Afficher plus ({count})",
       "noFolders": "Aucun dossier ouvert",
       "newChatAction": "Nouvelle discussion",
@@ -1860,7 +1869,8 @@
       "search": "Rechercher",
       "openSettings": "Ouvrir les paramètres",
       "backToConversations": "Retour aux conversations",
-      "withShortcut": "{label} (raccourci : {shortcut})"
+      "withShortcut": "{label} (raccourci : {shortcut})",
+      "pkArena": "Arène PK d'agents"
     },
     "statusBar": {
       "connection": {
@@ -2797,7 +2807,8 @@
         "mentionGroupAgent": "Agents",
         "mentionGroupSession": "Sessions",
         "mentionGroupCommit": "Commits",
-        "mentionGroupSkill": "Compétences"
+        "mentionGroupSkill": "Compétences",
+        "startPk": "PK d'agents"
       },
       "messageQueue": {
         "addToQueue": "Mettre en file",
@@ -5113,6 +5124,179 @@
     "loadFailed": "Impossible de charger la consommation",
     "truncatedNotice": "Cette période est très large — les chiffres ne couvrent que sa portion la plus récente."
   },
+  "PkArena": {
+    "launcher": {
+      "title": "PK d'agents",
+      "description": "Envoyez une même tâche à plusieurs agents et comparez les résultats",
+      "contestantsLabel": "Participants ({min}–{max})",
+      "noFolderHint": "L'arène nécessite un dossier avec un dépôt git — ouvrez-en d'abord un.",
+      "needMore": "Choisissez au moins {count} agents pour lancer le duel.",
+      "taskLabel": "Tâche",
+      "taskPlaceholder": "La tâche reçue par chaque participant, ex. « Écrire un jeu snake dans un seul fichier HTML »",
+      "selectedCount": "{selected}/{max} choisis (min. {min})",
+      "cancel": "Annuler",
+      "start": "Lancer le duel",
+      "notAGitRepo": "Ce dossier n'est pas un dépôt git — l'arène en nécessite un pour donner à chaque participant un worktree isolé.",
+      "initGitRepo": "git init",
+      "initializing": "Initialisation…",
+      "permissionLabel": "Autorisations",
+      "permissionOptions": {
+        "default": "Demander à chaque fois",
+        "acceptEdits": "Accepter les modifications",
+        "bypassPermissions": "Tout automatique"
+      },
+      "permissionHints": {
+        "default": "chaque validation interrompt le participant",
+        "acceptEdits": "modifications sans demander",
+        "bypassPermissions": "aucune validation"
+      },
+      "permissionNote": "Appliqué à chaque participant au départ ; les agents non compatibles continuent de demander.",
+      "bareModeLabel": "Mode nu (sans compétences)",
+      "bareModeHint": "Les participants n'utilisent que leurs capacités de base, sans compétences globales ni de projet.",
+      "effortLabel": "Effort de raisonnement (uniforme)",
+      "effortOptions": {
+        "default": "Défaut",
+        "low": "Faible",
+        "medium": "Moyen",
+        "high": "Élevé",
+        "max": "Max"
+      },
+      "effortNote": "Applique le niveau annoncé le plus proche par agent ; sans support, garde le défaut.",
+      "agentNotReady": "{agent} n'est pas prêt (installez-le dans les paramètres).",
+      "agentCheckFailed": "Impossible de vérifier {agent}.",
+      "templates": {
+        "pelican": "Pélican",
+        "bouncingBall": "Balle",
+        "jellyBlob": "Gelée",
+        "snake": "Snake",
+        "flappyBird": "Flappy Bird",
+        "voiceChat": "Chat vocal",
+        "blackHole": "Trou Noir"
+      },
+      "judgeLabel": "Juge (optionnel)",
+      "judgeNone": "Pas de juge",
+      "judgeHint": "Une fois tous les concurrents terminés, cet agent lit chaque diff et produit un verdict structuré avec scores et classements.",
+      "startPoint": "📍 Point de départ",
+      "fromHead": "depuis le HEAD actuel",
+      "startPointHint": "Les candidats partent un commit avant celui-ci — ils ne voient pas ses changements, seulement son message comme tâche. Ils refont le même objectif indépendamment.",
+      "loadingCommits": "Chargement des commits…",
+      "noCommits": "Aucun commit trouvé.",
+      "creativeTemplates": "Modèles créatifs",
+      "realEngineering": "Ingénierie réelle",
+      "loadMore": "Charger plus",
+      "judgeDimensionsLabel": "Dimensions d'évaluation (optionnel)",
+      "judgeDimensionsPlaceholder": "Correctness — la tâche est-elle remplie ?\nCode quality — lisibilité, structure, cas limites\nCompleteness — quelle proportion est faite ?\nEfficiency — efficacité du code (ignorer token/temps)",
+      "judgeDimensionsHint": "Une dimension par ligne. Laisser vide pour les valeurs par défaut.",
+      "addContestant": "Ajouter {agent} comme concurrent",
+      "slotLabelPlaceholder": "Étiquette (ex. Sonnet, Opus)",
+      "slotNumber": "Participant {number}",
+      "modelLoading": "Chargement des modèles…",
+      "modelUnavailable": "Cet agent utilise son modèle par défaut",
+      "modelLoadFailed": "Impossible de charger les modèles",
+      "retryModelLoad": "Recharger les modèles",
+      "removeSlot": "Retirer ce créneau de concurrent"
+    },
+    "scoreboard": {
+      "status": {
+        "preparing": "préparation",
+        "connecting": "connexion",
+        "running": "en cours",
+        "done": "terminé",
+        "error": "échec",
+        "canceled": "annulé",
+        "ready": "prêt"
+      },
+      "tokensUnit": "tok",
+      "tokensUnavailable": "Token not reported",
+      "tokensUnavailableHint": "This agent did not return token usage; this does not mean zero tokens.",
+      "turnsUnit": "tours"
+    },
+    "history": {
+      "title": "Round history",
+      "hint": "Search, open, and archive complete rounds.",
+      "trigger": "History {count}",
+      "searchPlaceholder": "Search tasks or agents…",
+      "empty": "No matching rounds",
+      "agents": "{count} agents",
+      "archive": "Archive round",
+      "archiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "archiveSuccess": "PK round archived",
+      "archiveFailed": "Archive failed: {message}",
+      "status": {
+        "ready": "Ready",
+        "running": "Running",
+        "finished": "Finished",
+        "canceled": "Canceled",
+        "interrupted": "Interrupted"
+      }
+    },
+    "arena": {
+      "title": "Arène PK d'agents",
+      "description": "Une tâche, plusieurs agents, côte à côte",
+      "roundStatus": {
+        "running": "En direct",
+        "finished": "Terminée",
+        "canceled": "Annulée",
+        "interrupted": "Interrompue par un redémarrage",
+        "ready": "Prête"
+      },
+      "roundPicker": "Manche",
+      "cancelRound": "Annuler la manche",
+      "cleanupWorktrees": "Nettoyer les worktrees",
+      "cleanupHint": "Supprime les worktrees des participants (les branches sont conservées)",
+      "share": "Partager",
+      "sharing": "Export…",
+      "tabs": {
+        "battle": "Duel",
+        "diff": "Diff"
+      },
+      "preparing": "Préparation du participant…",
+      "noRound": "Aucune manche sélectionnée",
+      "contestantsUnit": "agents",
+      "newRound": "Nouvelle manche",
+      "startMatch": "Lancer le duel",
+      "readyNote": "Choisissez modèle et effort de chaque participant, puis lancez.",
+      "modelLabel": "Modèle",
+      "effortLabel": "Effort",
+      "effortUnsupported": "Cet agent n'expose pas de niveaux de raisonnement; sa valeur par défaut sera utilisée",
+      "effortOptions": {
+        "off": "Désactivé",
+        "minimal": "Minimal",
+        "low": "Faible",
+        "medium": "Moyen",
+        "high": "Élevé",
+        "max": "Maximum"
+      },
+      "minimize": "Réduire",
+      "exportReport": "Exporter le rapport",
+      "exporting": "Génération…",
+      "shareReport": "Save / share report",
+      "reportSaved": "HTML report saved",
+      "reportFailed": "Report export failed: {message}",
+      "persistenceFailed": "Certaines modifications de la manche n’ont pas pu être enregistrées. Réessayez avant de fermer cette page.",
+      "retrySave": "Réessayer l’enregistrement",
+      "readyTag": "Prêt",
+      "deleteRound": "Supprimer",
+      "deleteConfirm": "Supprimer cette manche ? Les worktrees restent — utilisez Nettoyer les worktrees.",
+      "followUp": "Relancer",
+      "followUpPlaceholder": "Envoyer uniquement à ce candidat (⌘↩ pour envoyer)"
+    },
+    "diff": {
+      "loading": "Chargement du diff…",
+      "empty": "Aucune modification dans ce worktree"
+    },
+    "judge": {
+      "title": "Verdict du juge",
+      "running": "Évaluation…",
+      "error": "Le juge a échoué",
+      "rerun": "Réévaluer"
+    },
+    "minimized": {
+      "restore": "Retour à l'arène",
+      "live": "PK en cours",
+      "dismiss": "Masquer"
+    }
+  },
   "Forge": {
     "title": "Panneau du dépôt",
     "pickFolder": "Choisir un dossier de projet",
diff --git a/src/i18n/messages/ja.json b/src/i18n/messages/ja.json
index 600ec4974..f2a9d2022 100644
--- a/src/i18n/messages/ja.json
+++ b/src/i18n/messages/ja.json
@@ -1737,8 +1737,17 @@
       "sectionFolders": "フォルダ",
       "sectionChats": "チャット",
       "sectionRecent": "最近",
+      "sectionPk": "PKアリーナ",
       "noChats": "チャットがありません",
       "noRecent": "最近の会話はありません",
+      "noPk": "PKセッションはありません",
+      "pkOpenArena": "Open this PK arena",
+      "pkArchive": "Archive the PK round",
+      "pkArchiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "pkArchiveSuccess": "PK round archived",
+      "pkArchiveFailed": "Archive failed: {message}",
+      "pkExpand": "Expand agent sessions",
+      "pkCollapse": "Collapse agent sessions",
       "showMoreRecent": "さらに表示（{count}）",
       "noFolders": "開いているフォルダがありません",
       "newChatAction": "新しいチャット",
@@ -1860,7 +1869,8 @@
       "search": "検索",
       "openSettings": "設定を開く",
       "backToConversations": "会話に戻る",
-      "withShortcut": "{label}（{shortcut}）"
+      "withShortcut": "{label}（{shortcut}）",
+      "pkArena": "エージェントPKアリーナ"
     },
     "statusBar": {
       "connection": {
@@ -2797,7 +2807,8 @@
         "mentionGroupAgent": "エージェント",
         "mentionGroupSession": "セッション",
         "mentionGroupCommit": "コミット",
-        "mentionGroupSkill": "スキル"
+        "mentionGroupSkill": "スキル",
+        "startPk": "エージェントPK"
       },
       "messageQueue": {
         "addToQueue": "キューに追加",
@@ -5113,6 +5124,179 @@
     "loadFailed": "使用量を読み込めませんでした",
     "truncatedNotice": "期間が非常に長いため、表示中の数値は直近の一部のみを対象としています。"
   },
+  "PkArena": {
+    "launcher": {
+      "title": "エージェントPK",
+      "description": "同じタスクを複数のエージェントに同時に送り、結果を比較します",
+      "contestantsLabel": "出場者（{min}～{max}体）",
+      "noFolderHint": "アリーナには git リポジトリのフォルダが必要です。先に開いてください。",
+      "needMore": "対戦を開始するには最低 {count} 体選択してください。",
+      "taskLabel": "タスク",
+      "taskPlaceholder": "全出場者が受け取る同じタスク。例:「HTML ファイル1つでスネークゲームを作って」",
+      "selectedCount": "{selected}/{max} 選択中(最小 {min})",
+      "cancel": "キャンセル",
+      "start": "対戦開始",
+      "notAGitRepo": "このフォルダは git リポジトリではありません。アリーナは各出場者に隔離されたワークツリーを与えるためにリポジトリが必要です。",
+      "initGitRepo": "git init",
+      "initializing": "初期化中…",
+      "permissionLabel": "権限",
+      "permissionOptions": {
+        "default": "毎回確認",
+        "acceptEdits": "編集を自動許可",
+        "bypassPermissions": "完全自動"
+      },
+      "permissionHints": {
+        "default": "承認のたびに出場者が停止",
+        "acceptEdits": "ファイル編集は確認なし",
+        "bypassPermissions": "承認ダイアログなし"
+      },
+      "permissionNote": "ラウンド開始時に各出場者へ適用。未対応のエージェントは引き続き確認します。",
+      "bareModeLabel": "ベアモード(スキル無効)",
+      "bareModeHint": "出場者は基本機能のみ使用。グローバル・プロジェクトのスキルは使用禁止。",
+      "effortLabel": "思考レベル(全出場者統一)",
+      "effortOptions": {
+        "default": "デフォルト",
+        "low": "低",
+        "medium": "中",
+        "high": "高",
+        "max": "最大"
+      },
+      "effortNote": "各エージェントが通告する最寄りのレベルを適用。未対応はデフォルトのまま。",
+      "agentNotReady": "{agent} が未準備です(先に設定でインストール)。",
+      "agentCheckFailed": "{agent} を確認できませんでした。",
+      "templates": {
+        "pelican": "ペリカン",
+        "bouncingBall": "ボール",
+        "jellyBlob": "ゼリー",
+        "snake": "スネーク",
+        "flappyBird": "Flappy Bird",
+        "voiceChat": "音声チャット",
+        "blackHole": "ブラックホール"
+      },
+      "judgeLabel": "審査員(任意)",
+      "judgeNone": "審査員なし",
+      "judgeHint": "全選手の完了後、審査員エージェントが各選手の diff を読み、構造化された評価とランキングを生成します。",
+      "startPoint": "📍 開始点",
+      "fromHead": "現在の HEAD から",
+      "startPointHint": "選手はこのコミットの前から開始し、このコミットの変更を見ず、メッセージをタスクとして独立して再現します。",
+      "loadingCommits": "コミットを読み込み中…",
+      "noCommits": "コミットが見つかりません。",
+      "creativeTemplates": "クリエイティブテンプレート",
+      "realEngineering": "リアルエンジニアリング",
+      "loadMore": "もっと読み込む",
+      "judgeDimensionsLabel": "評価 dimension（任意）",
+      "judgeDimensionsPlaceholder": "正確性 — タスクを満たすか?\nコード品質 — 可読性・構造・エッジケース\n完成度 — どの程度完了したか?\n効率 — コード効率（token/時間は除外）",
+      "judgeDimensionsHint": "1 行 1 dimension。空欄でデフォルト使用。",
+      "addContestant": "{agent} を選手として追加",
+      "slotLabelPlaceholder": "ラベル(例: Sonnet、Opus)",
+      "slotNumber": "出場者 {number}",
+      "modelLoading": "モデルを読み込み中…",
+      "modelUnavailable": "このエージェントはデフォルトモデルを使用します",
+      "modelLoadFailed": "モデルを読み込めませんでした",
+      "retryModelLoad": "モデルを再読み込み",
+      "removeSlot": "この選手スロットを削除"
+    },
+    "scoreboard": {
+      "status": {
+        "preparing": "準備中",
+        "connecting": "接続中",
+        "running": "実行中",
+        "done": "完了",
+        "error": "失敗",
+        "canceled": "キャンセル済み",
+        "ready": "準備完了"
+      },
+      "tokensUnit": "tok",
+      "tokensUnavailable": "Token not reported",
+      "tokensUnavailableHint": "This agent did not return token usage; this does not mean zero tokens.",
+      "turnsUnit": "ターン"
+    },
+    "history": {
+      "title": "Round history",
+      "hint": "Search, open, and archive complete rounds.",
+      "trigger": "History {count}",
+      "searchPlaceholder": "Search tasks or agents…",
+      "empty": "No matching rounds",
+      "agents": "{count} agents",
+      "archive": "Archive round",
+      "archiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "archiveSuccess": "PK round archived",
+      "archiveFailed": "Archive failed: {message}",
+      "status": {
+        "ready": "Ready",
+        "running": "Running",
+        "finished": "Finished",
+        "canceled": "Canceled",
+        "interrupted": "Interrupted"
+      }
+    },
+    "arena": {
+      "title": "エージェントPKアリーナ",
+      "description": "1つのタスク、複数のエージェント、横並び対決",
+      "roundStatus": {
+        "running": "進行中",
+        "finished": "終了",
+        "canceled": "キャンセル済み",
+        "interrupted": "再起動により中断",
+        "ready": "準備完了"
+      },
+      "roundPicker": "ラウンド",
+      "cancelRound": "ラウンドをキャンセル",
+      "cleanupWorktrees": "ワークツリーを削除",
+      "cleanupHint": "出場者のワークツリーを削除します(ブランチは保持)",
+      "share": "共有",
+      "sharing": "書き出し中…",
+      "tabs": {
+        "battle": "対戦",
+        "diff": "Diff"
+      },
+      "preparing": "出場者を準備中…",
+      "noRound": "ラウンド未選択",
+      "contestantsUnit": "体",
+      "newRound": "新しいラウンド",
+      "startMatch": "対戦開始",
+      "readyNote": "各出場者のモデルと思考レベルを選んでから対戦開始。",
+      "modelLabel": "モデル",
+      "effortLabel": "思考レベル",
+      "effortUnsupported": "このエージェントは思考レベル設定に対応していないため、既定値を使用します",
+      "effortOptions": {
+        "off": "オフ",
+        "minimal": "最小",
+        "low": "低",
+        "medium": "中",
+        "high": "高",
+        "max": "最大"
+      },
+      "minimize": "最小化",
+      "exportReport": "レポートをエクスポート",
+      "exporting": "生成中…",
+      "shareReport": "Save / share report",
+      "reportSaved": "HTML report saved",
+      "reportFailed": "Report export failed: {message}",
+      "persistenceFailed": "一部のラウンド状態を保存できませんでした。ページを閉じる前に操作を再試行してください。",
+      "retrySave": "保存を再試行",
+      "readyTag": "準備完了",
+      "deleteRound": "削除",
+      "deleteConfirm": "このラウンドを削除?ワークツリーは残ります(「ワークツリーを削除」で除去)",
+      "followUp": "追加",
+      "followUpPlaceholder": "この選手にのみ追加メッセージを送信(⌘↩ で送信)"
+    },
+    "diff": {
+      "loading": "diff を読み込み中…",
+      "empty": "このワークツリーに変更はありません"
+    },
+    "judge": {
+      "title": "審査員の評決",
+      "running": "評価中…",
+      "error": "審査員が失敗しました",
+      "rerun": "再評価"
+    },
+    "minimized": {
+      "restore": "アリーナに戻る",
+      "live": "PK 実行中",
+      "dismiss": "非表示"
+    }
+  },
   "Forge": {
     "title": "リポジトリパネル",
     "pickFolder": "プロジェクトフォルダを選択",
diff --git a/src/i18n/messages/ko.json b/src/i18n/messages/ko.json
index 96913076c..4c35b6888 100644
--- a/src/i18n/messages/ko.json
+++ b/src/i18n/messages/ko.json
@@ -1737,8 +1737,17 @@
       "sectionFolders": "폴더",
       "sectionChats": "채팅",
       "sectionRecent": "최근",
+      "sectionPk": "PK 아레나",
       "noChats": "채팅 없음",
       "noRecent": "최근 대화 없음",
+      "noPk": "PK 세션 없음",
+      "pkOpenArena": "Open this PK arena",
+      "pkArchive": "Archive the PK round",
+      "pkArchiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "pkArchiveSuccess": "PK round archived",
+      "pkArchiveFailed": "Archive failed: {message}",
+      "pkExpand": "Expand agent sessions",
+      "pkCollapse": "Collapse agent sessions",
       "showMoreRecent": "더 보기 ({count})",
       "noFolders": "열린 폴더 없음",
       "newChatAction": "새 채팅",
@@ -1860,7 +1869,8 @@
       "search": "검색",
       "openSettings": "설정 열기",
       "backToConversations": "대화로 돌아가기",
-      "withShortcut": "{label} ({shortcut} 단축키)"
+      "withShortcut": "{label} ({shortcut} 단축키)",
+      "pkArena": "에이전트 PK 아레나"
     },
     "statusBar": {
       "connection": {
@@ -2797,7 +2807,8 @@
         "mentionGroupAgent": "에이전트",
         "mentionGroupSession": "세션",
         "mentionGroupCommit": "커밋",
-        "mentionGroupSkill": "스킬"
+        "mentionGroupSkill": "스킬",
+        "startPk": "에이전트 PK"
       },
       "messageQueue": {
         "addToQueue": "대기열에 추가",
@@ -5113,6 +5124,179 @@
     "loadFailed": "사용량을 불러오지 못했습니다",
     "truncatedNotice": "기간이 매우 길어 표시된 수치는 가장 최근 구간만 반영합니다."
   },
+  "PkArena": {
+    "launcher": {
+      "title": "에이전트 PK",
+      "description": "하나의 작업을 여러 에이전트에 동시에 보내고 결과를 비교합니다",
+      "contestantsLabel": "참가자({min}–{max}개)",
+      "noFolderHint": "아레나에는 git 저장소 폴더가 필요합니다. 먼저 열어 주세요.",
+      "needMore": "대결을 시작하려면 최소 {count}개를 선택하세요.",
+      "taskLabel": "작업",
+      "taskPlaceholder": "모든 참가자가 받을 동일한 작업. 예: \"HTML 파일 하나로 스네이크 게임 만들기\"",
+      "selectedCount": "{selected}/{max} 선택됨(최소 {min})",
+      "cancel": "취소",
+      "start": "대결 시작",
+      "notAGitRepo": "이 폴더는 git 저장소가 아닙니다. 아레나는 각 참가자에게 격리된 워크트리를 제공하기 위해 저장소가 필요합니다.",
+      "initGitRepo": "git init",
+      "initializing": "초기화 중…",
+      "permissionLabel": "권한",
+      "permissionOptions": {
+        "default": "매번 확인",
+        "acceptEdits": "편집 자동 허용",
+        "bypassPermissions": "완전 자동"
+      },
+      "permissionHints": {
+        "default": "승인마다 참가자가 중단됨",
+        "acceptEdits": "파일 편집 확인 없음",
+        "bypassPermissions": "승인 없음"
+      },
+      "permissionNote": "라운드 시작 시 각 참가자에 적용됩니다. 미지원 에이전트는 계속 확인합니다.",
+      "bareModeLabel": "베어 모드(스킬 비활성화)",
+      "bareModeHint": "참가자는 기본 기능만 사용하며 전역·프로젝트 스킬을 사용할 수 없습니다.",
+      "effortLabel": "추론 수준(모든 참가자 동일)",
+      "effortOptions": {
+        "default": "기본",
+        "low": "낮음",
+        "medium": "중간",
+        "high": "높음",
+        "max": "최대"
+      },
+      "effortNote": "각 에이전트가 공지한 가장 가까운 수준을 적용합니다. 미지원 시 기본 유지.",
+      "agentNotReady": "{agent}이 준비되지 않았습니다(설정에서 설치하세요).",
+      "agentCheckFailed": "{agent} 확인 실패.",
+      "templates": {
+        "pelican": "펠리컨",
+        "bouncingBall": "공",
+        "jellyBlob": "젤리",
+        "snake": "스네이크",
+        "flappyBird": "Flappy Bird",
+        "voiceChat": "음성 채팅",
+        "blackHole": "블랙홀"
+      },
+      "judgeLabel": "심판(선택)",
+      "judgeNone": "심판 없음",
+      "judgeHint": "모든 참가자가 완료되면 심판 에이전트가 각 참가자의 diff를 읽고 구조화된 평가와 순위를 생성합니다.",
+      "startPoint": "📍 시작점",
+      "fromHead": "현재 HEAD에서",
+      "startPointHint": "선수들은 이 커밋 이전부터 시작하여 이 커밋의 변경사항을 보지 못하고, 메시지만 과제로 받아 독립적으로 다시 수행합니다.",
+      "loadingCommits": "커밋 로딩 중…",
+      "noCommits": "커밋이 없습니다.",
+      "creativeTemplates": "크리에이티브 템플릿",
+      "realEngineering": "실제 엔지니어링",
+      "loadMore": "더 로드",
+      "judgeDimensionsLabel": "평가 차원 (선택)",
+      "judgeDimensionsPlaceholder": "정확성 — 작업을 충족하는가?\n코드 품질 — 가독성, 구조, 엣지 케이스\n완성도 — 얼마나 완료했는가?\n효율성 — 코드 수준 효율 (token/시간 제외)",
+      "judgeDimensionsHint": "한 줄에 하나씩. 비워두면 기본값 사용.",
+      "addContestant": "{agent}을(를) 참가자로 추가",
+      "slotLabelPlaceholder": "라벨(예: Sonnet, Opus)",
+      "slotNumber": "참가자 {number}",
+      "modelLoading": "모델 불러오는 중…",
+      "modelUnavailable": "이 에이전트는 기본 모델을 사용합니다",
+      "modelLoadFailed": "모델을 불러오지 못했습니다",
+      "retryModelLoad": "모델 다시 불러오기",
+      "removeSlot": "이 참가자 슬롯 제거"
+    },
+    "scoreboard": {
+      "status": {
+        "preparing": "준비 중",
+        "connecting": "연결 중",
+        "running": "실행 중",
+        "done": "완료",
+        "error": "실패",
+        "canceled": "취소됨",
+        "ready": "준비됨"
+      },
+      "tokensUnit": "tok",
+      "tokensUnavailable": "Token not reported",
+      "tokensUnavailableHint": "This agent did not return token usage; this does not mean zero tokens.",
+      "turnsUnit": "턴"
+    },
+    "history": {
+      "title": "Round history",
+      "hint": "Search, open, and archive complete rounds.",
+      "trigger": "History {count}",
+      "searchPlaceholder": "Search tasks or agents…",
+      "empty": "No matching rounds",
+      "agents": "{count} agents",
+      "archive": "Archive round",
+      "archiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "archiveSuccess": "PK round archived",
+      "archiveFailed": "Archive failed: {message}",
+      "status": {
+        "ready": "Ready",
+        "running": "Running",
+        "finished": "Finished",
+        "canceled": "Canceled",
+        "interrupted": "Interrupted"
+      }
+    },
+    "arena": {
+      "title": "에이전트 PK 아레나",
+      "description": "하나의 작업, 여러 에이전트, 나란히 대결",
+      "roundStatus": {
+        "running": "진행 중",
+        "finished": "종료",
+        "canceled": "취소됨",
+        "interrupted": "재시작으로 중단됨",
+        "ready": "준비됨"
+      },
+      "roundPicker": "라운드",
+      "cancelRound": "라운드 취소",
+      "cleanupWorktrees": "워크트리 정리",
+      "cleanupHint": "참가자의 워크트리를 제거합니다(브랜치는 유지)",
+      "share": "공유",
+      "sharing": "내보내는 중…",
+      "tabs": {
+        "battle": "대결",
+        "diff": "Diff"
+      },
+      "preparing": "참가자 준비 중…",
+      "noRound": "라운드 미선택",
+      "contestantsUnit": "개",
+      "newRound": "새 라운드",
+      "startMatch": "대결 시작",
+      "readyNote": "각 참가자의 모델과 추론 수준을 선택한 후 시작하세요.",
+      "modelLabel": "모델",
+      "effortLabel": "추론 수준",
+      "effortUnsupported": "이 에이전트는 추론 수준 설정을 지원하지 않아 기본값을 사용합니다",
+      "effortOptions": {
+        "off": "끄기",
+        "minimal": "최소",
+        "low": "낮음",
+        "medium": "중간",
+        "high": "높음",
+        "max": "최대"
+      },
+      "minimize": "최소화",
+      "exportReport": "보고서 내보내기",
+      "exporting": "생성 중…",
+      "shareReport": "Save / share report",
+      "reportSaved": "HTML report saved",
+      "reportFailed": "Report export failed: {message}",
+      "persistenceFailed": "일부 라운드 상태를 저장하지 못했습니다. 페이지를 닫기 전에 작업을 다시 시도하세요.",
+      "retrySave": "저장 다시 시도",
+      "readyTag": "준비됨",
+      "deleteRound": "삭제",
+      "deleteConfirm": "이 라운드를 삭제? 워크트리는 남아 있습니다(정리로 제거)",
+      "followUp": "추가",
+      "followUpPlaceholder": "이 선수에게만 추가 메시지 전송 (⌘↩ 전송)"
+    },
+    "diff": {
+      "loading": "diff 불러오는 중…",
+      "empty": "이 워크트리에는 변경 사항이 없습니다"
+    },
+    "judge": {
+      "title": "심판 평결",
+      "running": "평가 중…",
+      "error": "심판 실패",
+      "rerun": "재평가"
+    },
+    "minimized": {
+      "restore": "아레나로 돌아가기",
+      "live": "PK 진행 중",
+      "dismiss": "숨기기"
+    }
+  },
   "Forge": {
     "title": "리포지토리 패널",
     "pickFolder": "프로젝트 폴더 선택",
diff --git a/src/i18n/messages/pt.json b/src/i18n/messages/pt.json
index de8a8fd08..d80d4b30a 100644
--- a/src/i18n/messages/pt.json
+++ b/src/i18n/messages/pt.json
@@ -1737,8 +1737,17 @@
       "sectionFolders": "Pastas",
       "sectionChats": "Chat",
       "sectionRecent": "Recentes",
+      "sectionPk": "Arena PK",
       "noChats": "Sem chats",
       "noRecent": "Sem conversas recentes",
+      "noPk": "Sem sessões PK",
+      "pkOpenArena": "Open this PK arena",
+      "pkArchive": "Archive the PK round",
+      "pkArchiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "pkArchiveSuccess": "PK round archived",
+      "pkArchiveFailed": "Archive failed: {message}",
+      "pkExpand": "Expand agent sessions",
+      "pkCollapse": "Collapse agent sessions",
       "showMoreRecent": "Mostrar mais ({count})",
       "noFolders": "Nenhuma pasta aberta",
       "newChatAction": "Novo chat",
@@ -1860,7 +1869,8 @@
       "search": "Buscar",
       "openSettings": "Abrir configurações",
       "backToConversations": "Voltar às conversas",
-      "withShortcut": "{label} (atalho: {shortcut})"
+      "withShortcut": "{label} (atalho: {shortcut})",
+      "pkArena": "Arena PK de agentes"
     },
     "statusBar": {
       "connection": {
@@ -2797,7 +2807,8 @@
         "mentionGroupAgent": "Agentes",
         "mentionGroupSession": "Sessões",
         "mentionGroupCommit": "Commits",
-        "mentionGroupSkill": "Habilidades"
+        "mentionGroupSkill": "Habilidades",
+        "startPk": "PK de agentes"
       },
       "messageQueue": {
         "addToQueue": "Adicionar à fila",
@@ -5113,6 +5124,179 @@
     "loadFailed": "Não foi possível carregar o uso",
     "truncatedNotice": "Este período é muito amplo — os números cobrem apenas o trecho mais recente."
   },
+  "PkArena": {
+    "launcher": {
+      "title": "PK de agentes",
+      "description": "Envie uma tarefa para vários agentes de uma vez e compare os resultados",
+      "contestantsLabel": "Competidores ({min}–{max})",
+      "noFolderHint": "A arena precisa de uma pasta com um repositório git — abra uma primeiro.",
+      "needMore": "Escolha pelo menos {count} agentes para iniciar o duelo.",
+      "taskLabel": "Tarefa",
+      "taskPlaceholder": "A tarefa que cada competidor recebe, ex.: \"Escreva um jogo da cobrinha em um único arquivo HTML\"",
+      "selectedCount": "{selected}/{max} escolhidos (mín. {min})",
+      "cancel": "Cancelar",
+      "start": "Iniciar duelo",
+      "notAGitRepo": "Esta pasta não é um repositório git — a arena precisa de um para dar a cada competidor um worktree isolado.",
+      "initGitRepo": "git init",
+      "initializing": "Inicializando…",
+      "permissionLabel": "Permissões",
+      "permissionOptions": {
+        "default": "Perguntar sempre",
+        "acceptEdits": "Aceitar edições",
+        "bypassPermissions": "Tudo automático"
+      },
+      "permissionHints": {
+        "default": "cada aprovação interrompe o competidor",
+        "acceptEdits": "edições sem perguntar",
+        "bypassPermissions": "sem aprovações"
+      },
+      "permissionNote": "Aplicado a cada competidor no início; agentes sem suporte continuam perguntando.",
+      "bareModeLabel": "Modo básico (sem habilidades)",
+      "bareModeHint": "Os competidores usam apenas capacidades básicas, sem habilidades globais ou do projeto.",
+      "effortLabel": "Esforço de raciocínio (uniforme)",
+      "effortOptions": {
+        "default": "Padrão",
+        "low": "Baixo",
+        "medium": "Médio",
+        "high": "Alto",
+        "max": "Máximo"
+      },
+      "effortNote": "Aplica o nível anunciado mais próximo por agente; sem suporte, mantém o padrão.",
+      "agentNotReady": "{agent} não está pronto (instale nas configurações de agentes).",
+      "agentCheckFailed": "Não foi possível verificar {agent}.",
+      "templates": {
+        "pelican": "Pelicano",
+        "bouncingBall": "Bola",
+        "jellyBlob": "Geleia",
+        "snake": "Snake",
+        "flappyBird": "Flappy Bird",
+        "voiceChat": "Chat por voz",
+        "blackHole": "Buraco Negro"
+      },
+      "judgeLabel": "Juiz (opcional)",
+      "judgeNone": "Sem juiz",
+      "judgeHint": "Após todos os concorrentes terminarem, este agente lê cada diff e produz um veredito estruturado com pontuações e classificações.",
+      "startPoint": "📍 Ponto de partida",
+      "fromHead": "do HEAD atual",
+      "startPointHint": "Os competidores começam um commit antes deste — sem ver suas mudanças, apenas sua mensagem como tarefa. Refazem o mesmo objetivo de forma independente.",
+      "loadingCommits": "Carregando commits…",
+      "noCommits": "Nenhum commit encontrado.",
+      "creativeTemplates": "Modelos criativos",
+      "realEngineering": "Engenharia real",
+      "loadMore": "Carregar mais",
+      "judgeDimensionsLabel": "Dimensões de avaliação (opcional)",
+      "judgeDimensionsPlaceholder": "Correctness — cumpre a tarefa?\nCode quality — legibilidade, estrutura, casos-limite\nCompleteness — quanto está feito?\nEfficiency — eficiência do código (ignorar token/tempo)",
+      "judgeDimensionsHint": "Uma dimensão por linha. Deixe vazio para usar os padrões.",
+      "addContestant": "Adicionar {agent} como concorrente",
+      "slotLabelPlaceholder": "Rótulo (ex. Sonnet, Opus)",
+      "slotNumber": "Competidor {number}",
+      "modelLoading": "Carregando modelos…",
+      "modelUnavailable": "Este agente usa o modelo padrão",
+      "modelLoadFailed": "Não foi possível carregar os modelos",
+      "retryModelLoad": "Recarregar modelos",
+      "removeSlot": "Remover este slot de concorrente"
+    },
+    "scoreboard": {
+      "status": {
+        "preparing": "preparando",
+        "connecting": "conectando",
+        "running": "executando",
+        "done": "concluído",
+        "error": "falhou",
+        "canceled": "cancelado",
+        "ready": "pronto"
+      },
+      "tokensUnit": "tok",
+      "tokensUnavailable": "Token not reported",
+      "tokensUnavailableHint": "This agent did not return token usage; this does not mean zero tokens.",
+      "turnsUnit": "turnos"
+    },
+    "history": {
+      "title": "Round history",
+      "hint": "Search, open, and archive complete rounds.",
+      "trigger": "History {count}",
+      "searchPlaceholder": "Search tasks or agents…",
+      "empty": "No matching rounds",
+      "agents": "{count} agents",
+      "archive": "Archive round",
+      "archiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "archiveSuccess": "PK round archived",
+      "archiveFailed": "Archive failed: {message}",
+      "status": {
+        "ready": "Ready",
+        "running": "Running",
+        "finished": "Finished",
+        "canceled": "Canceled",
+        "interrupted": "Interrupted"
+      }
+    },
+    "arena": {
+      "title": "Arena PK de agentes",
+      "description": "Uma tarefa, vários agentes, lado a lado",
+      "roundStatus": {
+        "running": "Ao vivo",
+        "finished": "Encerrada",
+        "canceled": "Cancelada",
+        "interrupted": "Interrompida por reinício",
+        "ready": "Pronta"
+      },
+      "roundPicker": "Rodada",
+      "cancelRound": "Cancelar rodada",
+      "cleanupWorktrees": "Limpar worktrees",
+      "cleanupHint": "Remove os worktrees dos competidores (as branches são mantidas)",
+      "share": "Compartilhar",
+      "sharing": "Exportando…",
+      "tabs": {
+        "battle": "Duelo",
+        "diff": "Diff"
+      },
+      "preparing": "Preparando competidor…",
+      "noRound": "Nenhuma rodada selecionada",
+      "contestantsUnit": "agentes",
+      "newRound": "Nova rodada",
+      "startMatch": "Iniciar duelo",
+      "readyNote": "Escolha modelo e esforço de cada competidor e inicie.",
+      "modelLabel": "Modelo",
+      "effortLabel": "Esforço",
+      "effortUnsupported": "Este agente não oferece níveis de raciocínio; o padrão dele será usado",
+      "effortOptions": {
+        "off": "Desativado",
+        "minimal": "Mínimo",
+        "low": "Baixo",
+        "medium": "Médio",
+        "high": "Alto",
+        "max": "Máximo"
+      },
+      "minimize": "Minimizar",
+      "exportReport": "Exportar relatório",
+      "exporting": "Gerando…",
+      "shareReport": "Save / share report",
+      "reportSaved": "HTML report saved",
+      "reportFailed": "Report export failed: {message}",
+      "persistenceFailed": "Algumas alterações da rodada não puderam ser salvas. Tente novamente antes de fechar esta página.",
+      "retrySave": "Tentar salvar novamente",
+      "readyTag": "Pronto",
+      "deleteRound": "Excluir",
+      "deleteConfirm": "Excluir esta rodada? Os worktrees permanecem — use Limpar worktrees.",
+      "followUp": "Continuar",
+      "followUpPlaceholder": "Enviar apenas a este concorrente (⌘↩ para enviar)"
+    },
+    "diff": {
+      "loading": "Carregando diff…",
+      "empty": "Sem alterações neste worktree"
+    },
+    "judge": {
+      "title": "Veredito do juiz",
+      "running": "Avaliando…",
+      "error": "O juiz falhou",
+      "rerun": "Reavaliar"
+    },
+    "minimized": {
+      "restore": "Voltar à arena",
+      "live": "PK em andamento",
+      "dismiss": "Ocultar"
+    }
+  },
   "Forge": {
     "title": "Painel do repositório",
     "pickFolder": "Escolha uma pasta de projeto",
diff --git a/src/i18n/messages/zh-CN.json b/src/i18n/messages/zh-CN.json
index 645644d45..db0cc1ccb 100644
--- a/src/i18n/messages/zh-CN.json
+++ b/src/i18n/messages/zh-CN.json
@@ -1737,8 +1737,17 @@
       "sectionFolders": "文件夹",
       "sectionChats": "聊天",
       "sectionRecent": "最近",
+      "sectionPk": "PK 竞技场",
       "noChats": "没有聊天",
       "noRecent": "暂无最近会话",
+      "noPk": "暂无 PK 会话",
+      "pkOpenArena": "打开这场 PK 竞技场",
+      "pkArchive": "归档整场 PK",
+      "pkArchiveConfirm": "归档“{task}”? 该局和所属的智能体会话会从列表隐藏。",
+      "pkArchiveSuccess": "PK 对局已归档",
+      "pkArchiveFailed": "归档失败：{message}",
+      "pkExpand": "展开智能体会话",
+      "pkCollapse": "收起智能体会话",
       "showMoreRecent": "显示更多（{count}）",
       "noFolders": "没有打开的文件夹",
       "newChatAction": "新建聊天",
@@ -1860,7 +1869,8 @@
       "search": "搜索",
       "openSettings": "打开设置",
       "backToConversations": "返回会话",
-      "withShortcut": "{label}（{shortcut}）"
+      "withShortcut": "{label}（{shortcut}）",
+      "pkArena": "智能体 PK 竞技场"
     },
     "statusBar": {
       "connection": {
@@ -2797,7 +2807,8 @@
         "mentionGroupAgent": "智能体",
         "mentionGroupSession": "会话",
         "mentionGroupCommit": "提交",
-        "mentionGroupSkill": "技能"
+        "mentionGroupSkill": "技能",
+        "startPk": "智能体 PK"
       },
       "messageQueue": {
         "addToQueue": "加入队列",
@@ -5113,6 +5124,179 @@
     "loadFailed": "用量加载失败",
     "truncatedNotice": "该范围过大 —— 下面的数字只覆盖了其中最近的一段。"
   },
+  "PkArena": {
+    "launcher": {
+      "title": "智能体 PK",
+      "description": "同一任务同时发给多个智能体,对比结果",
+      "contestantsLabel": "参赛选手（{min}–{max} 个）",
+      "noFolderHint": "竞技场需要一个 git 仓库文件夹——请先打开一个。",
+      "needMore": "至少选择 {count} 个智能体才能开赛。",
+      "taskLabel": "任务",
+      "taskPlaceholder": "所有选手收到的同一任务,例如\"用单个 HTML 文件写一个贪吃蛇游戏\"",
+      "selectedCount": "已选 {selected}/{max}(最少 {min})",
+      "addContestant": "添加 {agent} 为选手",
+      "slotLabelPlaceholder": "标签(如 Sonnet、Opus)",
+      "slotNumber": "选手 {number}",
+      "modelLoading": "正在读取模型…",
+      "modelUnavailable": "该智能体使用默认模型",
+      "modelLoadFailed": "模型列表读取失败",
+      "retryModelLoad": "重新读取模型列表",
+      "removeSlot": "移除该选手槽位",
+      "cancel": "取消",
+      "start": "开始比赛",
+      "notAGitRepo": "该文件夹不是 git 仓库——竞技场需要仓库来为每位选手创建隔离的 worktree。",
+      "initGitRepo": "git init",
+      "initializing": "初始化中…",
+      "permissionLabel": "权限",
+      "permissionOptions": {
+        "default": "每步询问",
+        "acceptEdits": "自动接受编辑",
+        "bypassPermissions": "全自动"
+      },
+      "permissionHints": {
+        "default": "每次审批都会打断选手",
+        "acceptEdits": "文件编辑不再询问",
+        "bypassPermissions": "完全不弹审批"
+      },
+      "permissionNote": "开赛时对每位选手生效;不支持的智能体仍会询问。",
+      "bareModeLabel": "裸机模式(禁用技能)",
+      "bareModeHint": "选手被明确要求只使用基础能力,不加载任何全局或项目技能。",
+      "effortLabel": "思考等级(所有选手统一)",
+      "effortOptions": {
+        "default": "默认",
+        "low": "低",
+        "medium": "中",
+        "high": "高",
+        "max": "最高"
+      },
+      "effortNote": "按各选手通告的最近档位应用;不支持的选手保持默认。",
+      "agentNotReady": "{agent} 未就绪(请先在智能体设置里安装)。",
+      "agentCheckFailed": "无法校验 {agent} 的安装状态。",
+      "templates": {
+        "pelican": "鹈鹕骑车",
+        "bouncingBall": "弹球",
+        "jellyBlob": "果冻 Blob",
+        "snake": "贪吃蛇",
+        "flappyBird": "Flappy Bird",
+        "voiceChat": "语音聊天",
+        "blackHole": "黑洞"
+      },
+      "judgeLabel": "裁判(可选)",
+      "judgeNone": "无裁判",
+      "judgeHint": "所有选手完成后,裁判 agent 会读取每个选手的 diff,给出结构化评分和排名。",
+      "judgeDimensionsLabel": "评分维度(可选)",
+      "judgeDimensionsPlaceholder": "正确性 — 是否完成任务?\n代码质量 — 可读性、结构、边界处理\n完整度 — 完成了多少?\n效率 — 代码层面效率(忽略 token 数和耗时)",
+      "judgeDimensionsHint": "每行一个维度。留空使用默认。每个维度会成为裁判提示词中的编号评分标准。",
+      "startPoint": "📍 起点",
+      "fromHead": "从当前 HEAD 开始",
+      "startPointHint": "选手从此提交的上一次提交开始,看不到这次提交的改动,只把它的提交信息当任务——等于独立重做同一个目标。",
+      "loadingCommits": "加载提交中…",
+      "noCommits": "未找到提交。",
+      "creativeTemplates": "创意 PK",
+      "realEngineering": "真实工程 PK",
+      "loadMore": "加载更多"
+    },
+    "scoreboard": {
+      "status": {
+        "preparing": "准备中",
+        "connecting": "连接中",
+        "running": "运行中",
+        "done": "完成",
+        "error": "失败",
+        "canceled": "已取消",
+        "ready": "就绪"
+      },
+      "tokensUnit": "tok",
+      "tokensUnavailable": "Token 未提供",
+      "tokensUnavailableHint": "该智能体没有返回 Token 用量,不是 0 Token。",
+      "turnsUnit": "轮"
+    },
+    "history": {
+      "title": "历史对局",
+      "hint": "按对局管理、查找和归档，不再把历史塞进下拉框。",
+      "trigger": "历史 {count}",
+      "searchPlaceholder": "搜索任务或智能体…",
+      "empty": "没有匹配的对局",
+      "agents": "{count} 个智能体",
+      "archive": "归档整局",
+      "archiveConfirm": "归档“{task}”? 该局和所属的智能体会话会从列表隐藏。",
+      "archiveSuccess": "PK 对局已归档",
+      "archiveFailed": "归档失败：{message}",
+      "status": {
+        "ready": "就绪",
+        "running": "进行中",
+        "finished": "已结束",
+        "canceled": "已取消",
+        "interrupted": "因重启中断"
+      }
+    },
+    "arena": {
+      "title": "智能体 PK 竞技场",
+      "description": "一个任务,多个智能体,同场竞技",
+      "roundStatus": {
+        "running": "进行中",
+        "finished": "已结束",
+        "canceled": "已取消",
+        "interrupted": "因重启中断",
+        "ready": "就绪"
+      },
+      "roundPicker": "回合",
+      "cancelRound": "取消本轮",
+      "cleanupWorktrees": "清理 worktree",
+      "cleanupHint": "移除选手的 worktree(保留分支)",
+      "share": "分享",
+      "sharing": "导出中…",
+      "tabs": {
+        "battle": "对战",
+        "diff": "Diff"
+      },
+      "preparing": "正在准备选手…",
+      "noRound": "未选择回合",
+      "contestantsUnit": "个智能体",
+      "newRound": "新一局",
+      "startMatch": "开始比赛",
+      "readyNote": "按每位选手实际支持的模型与思考等级确认配置,然后开始比赛。",
+      "modelLabel": "模型",
+      "effortLabel": "思考等级",
+      "effortUnsupported": "该智能体不支持思考等级配置,将使用自身默认值",
+      "effortOptions": {
+        "off": "关闭",
+        "minimal": "最低",
+        "low": "低",
+        "medium": "中",
+        "high": "高",
+        "max": "最高"
+      },
+      "minimize": "缩小",
+      "exportReport": "导出报告",
+      "exporting": "生成中…",
+      "shareReport": "保存 / 分享战报",
+      "reportSaved": "HTML 战报已保存",
+      "reportFailed": "战报导出失败：{message}",
+      "persistenceFailed": "部分回合状态未能保存，请在关闭页面前重试对应操作。",
+      "retrySave": "重试保存",
+      "readyTag": "就绪",
+      "deleteRound": "删除",
+      "deleteConfirm": "删除这个回合?worktree 会留在磁盘上,可用「清理 worktree」移除。",
+      "followUp": "追加",
+      "followUpPlaceholder": "只对这名选手发追加消息(⌘↩ 发送)"
+    },
+    "diff": {
+      "loading": "正在加载 diff…",
+      "empty": "该 worktree 没有变更"
+    },
+    "judge": {
+      "title": "裁判裁决",
+      "running": "评审中…",
+      "error": "裁判失败",
+      "rerun": "重新评分"
+    },
+    "minimized": {
+      "restore": "回到竞技场",
+      "live": "PK 进行中",
+      "dismiss": "隐藏"
+    }
+  },
   "Forge": {
     "title": "仓库面板",
     "pickFolder": "选择项目文件夹",
diff --git a/src/i18n/messages/zh-TW.json b/src/i18n/messages/zh-TW.json
index fa93ddf2d..2af037bbc 100644
--- a/src/i18n/messages/zh-TW.json
+++ b/src/i18n/messages/zh-TW.json
@@ -1737,8 +1737,17 @@
       "sectionFolders": "資料夾",
       "sectionChats": "聊天",
       "sectionRecent": "最近",
+      "sectionPk": "PK 競技場",
       "noChats": "沒有聊天",
       "noRecent": "暫無最近對話",
+      "noPk": "暫無 PK 對話",
+      "pkOpenArena": "Open this PK arena",
+      "pkArchive": "Archive the PK round",
+      "pkArchiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "pkArchiveSuccess": "PK round archived",
+      "pkArchiveFailed": "Archive failed: {message}",
+      "pkExpand": "Expand agent sessions",
+      "pkCollapse": "Collapse agent sessions",
       "showMoreRecent": "顯示更多（{count}）",
       "noFolders": "沒有開啟的資料夾",
       "newChatAction": "新增聊天",
@@ -1860,7 +1869,8 @@
       "search": "搜尋",
       "openSettings": "打開設定",
       "backToConversations": "返回會話",
-      "withShortcut": "{label}（{shortcut}）"
+      "withShortcut": "{label}（{shortcut}）",
+      "pkArena": "智慧體 PK 競技場"
     },
     "statusBar": {
       "connection": {
@@ -2797,7 +2807,8 @@
         "mentionGroupAgent": "智能體",
         "mentionGroupSession": "工作階段",
         "mentionGroupCommit": "提交",
-        "mentionGroupSkill": "技能"
+        "mentionGroupSkill": "技能",
+        "startPk": "智慧體 PK"
       },
       "messageQueue": {
         "addToQueue": "加入佇列",
@@ -5113,6 +5124,179 @@
     "loadFailed": "用量載入失敗",
     "truncatedNotice": "此範圍過大 —— 下面的數字只涵蓋其中最近的一段。"
   },
+  "PkArena": {
+    "launcher": {
+      "title": "智慧體 PK",
+      "description": "同一任務同時發給多個智慧體,對比結果",
+      "contestantsLabel": "參賽選手（{min}–{max} 個）",
+      "noFolderHint": "競技場需要一個 git 儲存庫資料夾——請先開啟一個。",
+      "needMore": "至少選擇 {count} 個智慧體才能開賽。",
+      "taskLabel": "任務",
+      "taskPlaceholder": "所有選手收到的同一任務,例如\"用單一 HTML 檔寫一個貪吃蛇遊戲\"",
+      "selectedCount": "已選 {selected}/{max}(最少 {min})",
+      "cancel": "取消",
+      "start": "開始比賽",
+      "notAGitRepo": "該資料夾不是 git 儲存庫——競技場需要儲存庫來為每位選手建立隔離的 worktree。",
+      "initGitRepo": "git init",
+      "initializing": "初始化中…",
+      "permissionLabel": "權限",
+      "permissionOptions": {
+        "default": "每步詢問",
+        "acceptEdits": "自動接受編輯",
+        "bypassPermissions": "全自動"
+      },
+      "permissionHints": {
+        "default": "每次審批都會打斷選手",
+        "acceptEdits": "檔案編輯不再詢問",
+        "bypassPermissions": "完全不彈審批"
+      },
+      "permissionNote": "開賽時對每位選手生效;不支援的智慧體仍會詢問。",
+      "bareModeLabel": "裸機模式(禁用技能)",
+      "bareModeHint": "選手被明確要求只使用基礎能力,不載入任何全域或專案技能。",
+      "effortLabel": "思考等級(所有選手統一)",
+      "effortOptions": {
+        "default": "預設",
+        "low": "低",
+        "medium": "中",
+        "high": "高",
+        "max": "最高"
+      },
+      "effortNote": "按各選手通告的最近檔位套用;不支援的選手保持預設。",
+      "agentNotReady": "{agent} 未就緒(請先在智慧體設定中安裝)。",
+      "agentCheckFailed": "無法校驗 {agent} 的安裝狀態。",
+      "templates": {
+        "pelican": "鵜鶘騎車",
+        "bouncingBall": "彈球",
+        "jellyBlob": "果凍 Blob",
+        "snake": "貪吃蛇",
+        "flappyBird": "Flappy Bird",
+        "voiceChat": "語音聊天",
+        "blackHole": "黑洞"
+      },
+      "judgeLabel": "裁判(可選)",
+      "judgeNone": "無裁判",
+      "judgeHint": "所有選手完成後,裁判 agent 會讀取每個選手的 diff,給出結構化評分和排名。",
+      "startPoint": "📍 起點",
+      "fromHead": "從目前 HEAD 開始",
+      "startPointHint": "選手從此提交的前一次提交開始,看不到這次提交的改動,只把它的提交訊息當任務——等於獨立重做同一個目標。",
+      "loadingCommits": "載入提交中…",
+      "noCommits": "未找到提交。",
+      "creativeTemplates": "創意 PK",
+      "realEngineering": "真實工程 PK",
+      "loadMore": "加載更多",
+      "judgeDimensionsLabel": "評分維度（可選）",
+      "judgeDimensionsPlaceholder": "正確性 — 是否完成任務?\n程式碼品質 — 可可讀性、結構、邊界處理\n完整度 — 完成了多少?\n效率 — 程式碼層面效率（忽略 token 數和耗時）",
+      "judgeDimensionsHint": "每行一個維度。留空使用預設。每個維度會成為裁判提示詞中的編號評分標準。",
+      "addContestant": "加入 {agent} 為選手",
+      "slotLabelPlaceholder": "標籤(如 Sonnet、Opus)",
+      "slotNumber": "選手 {number}",
+      "modelLoading": "正在讀取模型…",
+      "modelUnavailable": "此智慧體使用預設模型",
+      "modelLoadFailed": "模型清單讀取失敗",
+      "retryModelLoad": "重新讀取模型清單",
+      "removeSlot": "移除該選手位置"
+    },
+    "scoreboard": {
+      "status": {
+        "preparing": "準備中",
+        "connecting": "連線中",
+        "running": "執行中",
+        "done": "完成",
+        "error": "失敗",
+        "canceled": "已取消",
+        "ready": "就緒"
+      },
+      "tokensUnit": "tok",
+      "tokensUnavailable": "Token not reported",
+      "tokensUnavailableHint": "This agent did not return token usage; this does not mean zero tokens.",
+      "turnsUnit": "輪"
+    },
+    "history": {
+      "title": "Round history",
+      "hint": "Search, open, and archive complete rounds.",
+      "trigger": "History {count}",
+      "searchPlaceholder": "Search tasks or agents…",
+      "empty": "No matching rounds",
+      "agents": "{count} agents",
+      "archive": "Archive round",
+      "archiveConfirm": "Archive “{task}”? The round and its agent sessions will be hidden.",
+      "archiveSuccess": "PK round archived",
+      "archiveFailed": "Archive failed: {message}",
+      "status": {
+        "ready": "Ready",
+        "running": "Running",
+        "finished": "Finished",
+        "canceled": "Canceled",
+        "interrupted": "Interrupted"
+      }
+    },
+    "arena": {
+      "title": "智慧體 PK 競技場",
+      "description": "一個任務,多個智慧體,同場競技",
+      "roundStatus": {
+        "running": "進行中",
+        "finished": "已結束",
+        "canceled": "已取消",
+        "interrupted": "因重啟中斷",
+        "ready": "就緒"
+      },
+      "roundPicker": "回合",
+      "cancelRound": "取消本輪",
+      "cleanupWorktrees": "清理 worktree",
+      "cleanupHint": "移除選手的 worktree(保留分支)",
+      "share": "分享",
+      "sharing": "匯出中…",
+      "tabs": {
+        "battle": "對戰",
+        "diff": "Diff"
+      },
+      "preparing": "正在準備選手…",
+      "noRound": "未選擇回合",
+      "contestantsUnit": "個智慧體",
+      "newRound": "新一局",
+      "startMatch": "開始比賽",
+      "readyNote": "選擇每位選手的模型與思考等級,然後開始比賽。",
+      "modelLabel": "模型",
+      "effortLabel": "思考等級",
+      "effortUnsupported": "此智能體不支援思考等級設定,將使用自身預設值",
+      "effortOptions": {
+        "off": "關閉",
+        "minimal": "最低",
+        "low": "低",
+        "medium": "中",
+        "high": "高",
+        "max": "最高"
+      },
+      "minimize": "縮小",
+      "exportReport": "匯出報告",
+      "exporting": "產生中…",
+      "shareReport": "Save / share report",
+      "reportSaved": "HTML report saved",
+      "reportFailed": "Report export failed: {message}",
+      "persistenceFailed": "部分回合狀態未能儲存，請在關閉頁面前重試對應操作。",
+      "retrySave": "重試儲存",
+      "readyTag": "就緒",
+      "deleteRound": "刪除",
+      "deleteConfirm": "刪除這個回合?worktree 會留在磁碟上,可用「清理 worktree」移除。",
+      "followUp": "追加",
+      "followUpPlaceholder": "只對這名選手發追加訊息(⌘↩ 傳送)"
+    },
+    "diff": {
+      "loading": "正在載入 diff…",
+      "empty": "該 worktree 沒有變更"
+    },
+    "judge": {
+      "title": "裁判裁決",
+      "running": "評審中…",
+      "error": "裁判失敗",
+      "rerun": "重新評分"
+    },
+    "minimized": {
+      "restore": "回到競技場",
+      "live": "PK 進行中",
+      "dismiss": "隱藏"
+    }
+  },
   "Forge": {
     "title": "儲存庫面板",
     "pickFolder": "選擇專案資料夾",
diff --git a/src/lib/api-popup-windows.test.ts b/src/lib/api-popup-windows.test.ts
index 60299353f..4c537ae57 100644
--- a/src/lib/api-popup-windows.test.ts
+++ b/src/lib/api-popup-windows.test.ts
@@ -28,7 +28,11 @@ vi.mock("@/lib/transport", () => ({
   notifyRemoteDesktopUnauthorized: mocks.notifyRemoteDesktopUnauthorized,
 }))
 
-import { openCommitWindow, openSettingsWindow } from "@/lib/api"
+import {
+  openCommitWindow,
+  openPkRoundWindow,
+  openSettingsWindow,
+} from "@/lib/api"
 
 /** Stand-in for the reserved WindowProxy: only `location.href` and `close`. */
 function fakePopup(initialHref = "about:blank") {
@@ -201,4 +205,31 @@ describe("web-mode app popup windows", () => {
     )
     expect(open).not.toHaveBeenCalled()
   })
+
+  it("opens a PK round directly in a reusable web workspace window", async () => {
+    const popup = fakePopup()
+    const open = vi.spyOn(window, "open").mockReturnValue(popup as never)
+
+    await openPkRoundWindow("42", "Build a game")
+
+    expect(open).toHaveBeenCalledWith("", "pk-round-42")
+    expect(popup.location.href).toBe("/workspace?pkRoundId=42")
+    expect(mocks.call).not.toHaveBeenCalled()
+  })
+
+  it("delegates PK windows to the desktop shell with remote scope", async () => {
+    const open = vi.spyOn(window, "open").mockReturnValue(null)
+    mocks.isDesktop.mockReturnValue(true)
+    mocks.getActiveRemoteConnectionId.mockReturnValue("8")
+    mocks.shellCall.mockResolvedValue(undefined)
+
+    await openPkRoundWindow("42", "Build a game")
+
+    expect(mocks.shellCall).toHaveBeenCalledWith("open_pk_round_window", {
+      roundId: "42",
+      title: "Build a game",
+      remoteConnectionId: "8",
+    })
+    expect(open).not.toHaveBeenCalled()
+  })
 })
diff --git a/src/lib/api.ts b/src/lib/api.ts
index a26ea3452..871a9db08 100644
--- a/src/lib/api.ts
+++ b/src/lib/api.ts
@@ -157,6 +157,10 @@ import type {
   TokenUsageReport,
   TokenUsageSyncResult,
   TokenUsageSyncStatus,
+  PkRoundConfig,
+  PkRoundInfo,
+  PkRoundStatus,
+  PkJudgeResultDto,
 } from "./types"
 
 export async function listConversations(params?: {
@@ -2116,12 +2120,14 @@ export async function gitNewBranch(
 export async function gitWorktreeAdd(
   path: string,
   branchName: string,
-  worktreePath: string
+  worktreePath: string,
+  base?: string | null
 ): Promise<void> {
   return getTransport().call("git_worktree_add", {
     path,
     branchName,
     worktreePath,
+    base: base ?? undefined,
   })
 }
 
@@ -2317,6 +2323,25 @@ async function openAppWindow(
   releaseAppWindow(name)
 }
 
+/** Open a PK round in its own workspace window. The target route reuses the
+ * normal workspace shell; `WorkspacePage` turns the query into a local PK tab
+ * once round hydration completes. */
+export async function openPkRoundWindow(
+  roundId: string,
+  title: string
+): Promise<void> {
+  if (isDesktop()) {
+    return getShellTransport().call("open_pk_round_window", {
+      roundId,
+      title,
+      remoteConnectionId: getActiveRemoteConnectionId(),
+    })
+  }
+  return openAppWindow(`pk-round-${roundId}`, async () => ({
+    path: `/workspace?pkRoundId=${encodeURIComponent(roundId)}`,
+  }))
+}
+
 export async function openMergeWindow(
   folderId: number,
   operation: string,
@@ -2850,6 +2875,20 @@ export async function createConversation(
   })
 }
 
+export async function createPkConversation(
+  folderId: number,
+  agentType: AgentType,
+  pkRoundId: number,
+  title?: string
+): Promise<number> {
+  return getTransport().call("create_pk_conversation", {
+    folderId,
+    agentType,
+    title: title ?? null,
+    pkRoundId,
+  })
+}
+
 /**
  * Create a folderless "chat mode" conversation. The backend lazily creates a
  * dated per-conversation scratch dir and a dedicated hidden chat folder
@@ -4891,6 +4930,70 @@ export async function scanExternalConflictsWeb(
   )
 }
 
+// ─── PK Arena Rounds ────────────────────────────────────────────────────────
+
+export async function pkRoundList(
+  folderId?: number | null
+): Promise<PkRoundInfo[]> {
+  return getTransport().call("pk_round_list", { folderId: folderId ?? null })
+}
+
+export async function pkRoundGet(id: number): Promise<PkRoundInfo> {
+  return getTransport().call("pk_round_get", { id })
+}
+
+export async function pkRoundCreate(
+  folderId: number,
+  task: string,
+  config: PkRoundConfig
+): Promise<PkRoundInfo> {
+  return getTransport().call("pk_round_create", { folderId, task, config })
+}
+
+export async function pkRoundUpdateStatus(
+  id: number,
+  status: PkRoundStatus
+): Promise<void> {
+  return getTransport().call("pk_round_update_status", { id, status })
+}
+
+export async function pkRoundDelete(id: number): Promise<void> {
+  return getTransport().call("pk_round_delete", { id })
+}
+
+export async function pkRoundUpdateJudge(
+  id: number,
+  judgeResult: PkJudgeResultDto | null,
+  judgeStatus: string
+): Promise<void> {
+  return getTransport().call("pk_round_update_judge", {
+    id,
+    judgeResult: judgeResult != null ? JSON.stringify(judgeResult) : null,
+    judgeStatus,
+  })
+}
+
+export async function pkRoundSaveReportSnapshot(
+  id: number,
+  snapshot: string
+): Promise<void> {
+  return getTransport().call(
+    "pk_round_save_report_snapshot",
+    { id, snapshot },
+    { timeoutMs: 60_000 }
+  )
+}
+
+export async function pkRoundGetReportSnapshot(
+  id: number
+): Promise<string | null> {
+  return getTransport().call(
+    "pk_round_get_report_snapshot",
+    { id },
+    { timeoutMs: 60_000 }
+  )
+}
+
 // ── Forge workbench (Issues/PR) ────────────────────────────────────────────
 
 /** The folder's `origin` remote parsed into forge coordinates, if any. */
diff --git a/src/lib/export-conversation.ts b/src/lib/export-conversation.ts
index ec30d40d1..25208c550 100644
--- a/src/lib/export-conversation.ts
+++ b/src/lib/export-conversation.ts
@@ -71,7 +71,7 @@ export interface ExportConversationData {
  * the browser owns the download manager and we have no per-call status
  * channel, so this path is always reported as `"saved"`.
  */
-async function saveTextFile(opts: {
+export async function saveTextFile(opts: {
   content: string
   suggestedName: string
   mimeType: string
diff --git a/src/lib/pk-conversation-reconciliation.test.ts b/src/lib/pk-conversation-reconciliation.test.ts
new file mode 100644
index 000000000..665c81b47
--- /dev/null
+++ b/src/lib/pk-conversation-reconciliation.test.ts
@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest"
+import type { DbConversationSummary } from "@/lib/types"
+import type { PkRound } from "@/stores/pk-arena-store"
+import { getPkConversationStatusRepairs } from "./pk-conversation-reconciliation"
+
+describe("getPkConversationStatusRepairs", () => {
+  it("settles stale contestant rows after their PK round was canceled", () => {
+    const round = {
+      id: "4",
+      status: "canceled",
+      judgeStatus: "idle",
+    } as PkRound
+    const conversations = [89, 90, 91, 92, 93, 94].map(
+      (id) =>
+        ({
+          id,
+          pk_round_id: 4,
+          title: "PK · 用单个 HTML 文件写一个俄罗斯方块游戏",
+          status: "in_progress",
+        }) as DbConversationSummary
+    )
+
+    expect(getPkConversationStatusRepairs([round], conversations)).toEqual(
+      conversations.map(({ id }) => ({
+        conversationId: id,
+        status: "cancelled",
+      }))
+    )
+  })
+
+  it("does not cancel a judge that may still run after contestant cancellation", () => {
+    const round = {
+      id: "4",
+      status: "canceled",
+      judgeStatus: "running",
+    } as PkRound
+    const judge = {
+      id: 95,
+      pk_round_id: 4,
+      title: "PK Judge · task",
+      status: "in_progress",
+    } as DbConversationSummary
+
+    expect(getPkConversationStatusRepairs([round], [judge])).toEqual([])
+  })
+})
diff --git a/src/lib/pk-conversation-reconciliation.ts b/src/lib/pk-conversation-reconciliation.ts
new file mode 100644
index 000000000..1782fa520
--- /dev/null
+++ b/src/lib/pk-conversation-reconciliation.ts
@@ -0,0 +1,55 @@
+import type { PkRound } from "@/stores/pk-arena-store"
+import type { DbConversationSummary } from "@/lib/types"
+
+export interface PkConversationStatusRepair {
+  conversationId: number
+  status: "completed" | "cancelled"
+}
+
+/**
+ * Derive repairs for PK-owned conversations whose persisted lifecycle no
+ * longer agrees with their authoritative round state.
+ *
+ * Contestant conversations must be terminal once their round is canceled or
+ * interrupted. Judge conversations have their own lifecycle because a judge
+ * may legitimately continue after contestants are canceled.
+ */
+export function getPkConversationStatusRepairs(
+  rounds: readonly PkRound[],
+  conversations: readonly DbConversationSummary[]
+): PkConversationStatusRepair[] {
+  const roundsById = new Map(rounds.map((round) => [Number(round.id), round]))
+  const repairs: PkConversationStatusRepair[] = []
+
+  for (const conversation of conversations) {
+    if (conversation.pk_round_id == null) continue
+    const round = roundsById.get(conversation.pk_round_id)
+    if (!round) continue
+
+    const isJudge = conversation.title?.startsWith("PK Judge ·") ?? false
+    if (isJudge) {
+      const status =
+        round.judgeStatus === "done"
+          ? "completed"
+          : round.judgeStatus === "error"
+            ? "cancelled"
+            : null
+      if (status && conversation.status !== status) {
+        repairs.push({ conversationId: conversation.id, status })
+      }
+      continue
+    }
+
+    if (
+      conversation.status === "in_progress" &&
+      (round.status === "canceled" || round.status === "interrupted")
+    ) {
+      repairs.push({
+        conversationId: conversation.id,
+        status: "cancelled",
+      })
+    }
+  }
+
+  return repairs
+}
diff --git a/src/lib/pk-judge.ts b/src/lib/pk-judge.ts
new file mode 100644
index 000000000..a3eb9bbd3
--- /dev/null
+++ b/src/lib/pk-judge.ts
@@ -0,0 +1,55 @@
+export interface PkJudgeContestantRef {
+  slot: number
+  agentType: string
+  label?: string | null
+}
+
+export interface PkJudgeScoreRef {
+  slot?: number
+  agentType: string
+}
+
+/**
+ * Give legacy judge scores a stable contestant identity.
+ *
+ * New verdicts carry `slot`. Older verdicts only carried `agentType`, so two
+ * models from the same agent were indistinguishable. For those rows, consume
+ * matching contestant slots in their original arena order.
+ */
+export function assignJudgeScoreSlots<T extends PkJudgeScoreRef>(
+  scores: readonly T[],
+  contestants: readonly PkJudgeContestantRef[]
+): Array<T & { slot?: number }> {
+  const usedSlots = new Set<number>()
+
+  return scores.map((score) => {
+    const explicit =
+      score.slot == null
+        ? undefined
+        : contestants.find(
+            (contestant) =>
+              contestant.slot === score.slot &&
+              contestant.agentType === score.agentType &&
+              !usedSlots.has(contestant.slot)
+          )
+    const matched =
+      explicit ??
+      contestants.find(
+        (contestant) =>
+          contestant.agentType === score.agentType &&
+          !usedSlots.has(contestant.slot)
+      )
+
+    if (!matched) return { ...score }
+    usedSlots.add(matched.slot)
+    return { ...score, slot: matched.slot }
+  })
+}
+
+export function contestantForJudgeScore(
+  score: PkJudgeScoreRef,
+  contestants: readonly PkJudgeContestantRef[]
+): PkJudgeContestantRef | undefined {
+  if (score.slot == null) return undefined
+  return contestants.find((contestant) => contestant.slot === score.slot)
+}
diff --git a/src/lib/pk-report-artifact.ts b/src/lib/pk-report-artifact.ts
new file mode 100644
index 000000000..68eb55bbb
--- /dev/null
+++ b/src/lib/pk-report-artifact.ts
@@ -0,0 +1,53 @@
+const STORAGE_COMPATIBILITY_SCRIPT = `<script data-codeg-storage-compat>
+(()=>{
+  const createMemoryStorage=()=>{
+    let values=Object.create(null)
+    return {
+      get length(){return Object.keys(values).length},
+      key(index){return Object.keys(values)[Number(index)]??null},
+      getItem(key){key=String(key);return Object.prototype.hasOwnProperty.call(values,key)?values[key]:null},
+      setItem(key,value){values[String(key)]=String(value)},
+      removeItem(key){delete values[String(key)]},
+      clear(){values=Object.create(null)}
+    }
+  }
+  for(const name of ["localStorage","sessionStorage"]){
+    try{
+      const storage=window[name]
+      if(storage&&typeof storage.getItem==="function")continue
+    }catch{}
+    try{
+      Object.defineProperty(window,name,{configurable:true,enumerable:true,value:createMemoryStorage()})
+    }catch{}
+  }
+})()
+</script>`
+
+/**
+ * Keep standalone contestant HTML runnable inside the report's opaque-origin
+ * iframe. Web Storage access throws in that sandbox, so install a document-
+ * local in-memory implementation before any contestant script can execute.
+ */
+export function preparePkReportArtifactHtml(html: string): string {
+  if (html.includes("data-codeg-storage-compat")) return html
+
+  const doctype = /^\s*<!doctype[^>]*>/i.exec(html)
+  if (!doctype) return `${STORAGE_COMPATIBILITY_SCRIPT}${html}`
+
+  return `${html.slice(0, doctype[0].length)}${STORAGE_COMPATIBILITY_SCRIPT}${html.slice(doctype[0].length)}`
+}
+
+export function decodePkReportArtifact(contentBase64: string): string {
+  const binary = atob(contentBase64)
+  const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0))
+  return new TextDecoder().decode(bytes)
+}
+
+export function encodePkReportArtifact(html: string): string {
+  const bytes = new TextEncoder().encode(html)
+  const chunks: string[] = []
+  for (let offset = 0; offset < bytes.length; offset += 0x8000) {
+    chunks.push(String.fromCharCode(...bytes.subarray(offset, offset + 0x8000)))
+  }
+  return btoa(chunks.join(""))
+}
diff --git a/src/lib/pk-report-data.test.ts b/src/lib/pk-report-data.test.ts
new file mode 100644
index 000000000..aac55b1c3
--- /dev/null
+++ b/src/lib/pk-report-data.test.ts
@@ -0,0 +1,176 @@
+import { describe, expect, it, vi } from "vitest"
+import { decodePkReportArtifact } from "@/lib/pk-report-artifact"
+import {
+  preparePkReportData,
+  type PkReportDataDependencies,
+  type PkReportSnapshot,
+} from "@/lib/pk-report-data"
+import type { PkRound } from "@/stores/pk-arena-store"
+import type { FileTreeNode } from "@/lib/types"
+
+const round = {
+  id: "7",
+  task: "build a game",
+  workingDir: "/repo",
+  contestants: [
+    {
+      slot: 0,
+      agentType: "qoder",
+      worktreePath: null,
+      status: "done",
+      diff: null,
+    },
+  ],
+} as PkRound
+
+function dependencies(
+  overrides: Partial<PkReportDataDependencies> = {}
+): PkReportDataDependencies {
+  return {
+    getFileTree: vi.fn(async () => {
+      throw new Error("missing")
+    }),
+    readWorkspaceFileBase64: vi.fn(async () => {
+      throw new Error("missing")
+    }),
+    listChangedPaths: vi.fn(async () => []),
+    readDiff: vi.fn(async () => null),
+    loadSnapshot: vi.fn(async () => null),
+    saveSnapshot: vi.fn(async () => undefined),
+    ...overrides,
+  }
+}
+
+describe("preparePkReportData", () => {
+  it("recovers a legacy agent-named worktree and inlines its web dependencies", async () => {
+    const files: Record<string, string> = {
+      "index.html": '<script src="assets/game.js"></script><h1>Game</h1>',
+      "assets/game.js": 'document.querySelector("h1").textContent = "Ready"',
+    }
+    const deps = dependencies({
+      getFileTree: vi.fn(async (root): Promise<FileTreeNode[]> => {
+        if (root !== "/repo/.codeg-pk/7/qoder") throw new Error("missing")
+        return [
+          { kind: "file", name: "index.html", path: `${root}/index.html` },
+          {
+            kind: "dir",
+            name: "assets",
+            path: `${root}/assets`,
+            children: [
+              {
+                kind: "file",
+                name: "game.js",
+                path: `${root}/assets/game.js`,
+              },
+            ],
+          },
+        ]
+      }),
+      readWorkspaceFileBase64: vi.fn(async (_root, path) => btoa(files[path])),
+      listChangedPaths: vi.fn(async () => ["index.html", "assets/game.js"]),
+      readDiff: vi.fn(
+        async () =>
+          "diff --git a/index.html b/index.html\n+++ b/index.html\ndiff --git a/assets/game.js b/assets/game.js\n+++ b/assets/game.js"
+      ),
+    })
+
+    const result = await preparePkReportData(round, deps)
+    const artifact = result.artifactsBySlot["0"][0]
+
+    expect(result.source).toBe("fresh")
+    expect(artifact.path).toBe("index.html")
+    expect(decodePkReportArtifact(artifact.contentBase64 ?? "")).toContain(
+      'document.querySelector("h1")'
+    )
+    expect(deps.saveSnapshot).toHaveBeenCalledOnce()
+  })
+
+  it("exports a historical round from its saved snapshot after worktrees are gone", async () => {
+    const snapshot: PkReportSnapshot = {
+      version: 1,
+      roundId: "7",
+      capturedAt: 1,
+      contestants: [{ slot: 0, diff: "+historical", usage: null }],
+      artifactsBySlot: {
+        "0": [{ path: "index.html", contentBase64: btoa("<h1>Saved</h1>") }],
+      },
+    }
+    const deps = dependencies({ loadSnapshot: vi.fn(async () => snapshot) })
+
+    const result = await preparePkReportData(round, deps)
+
+    expect(result.source).toBe("snapshot")
+    expect(result.round.contestants[0].diff).toBe("+historical")
+    expect(result.artifactsBySlot["0"][0].path).toBe("index.html")
+  })
+
+  it("does not present an unchanged repository page as contestant output", async () => {
+    const root = "/repo/.codeg-pk/7/0"
+    const deps = dependencies({
+      getFileTree: vi.fn(
+        async (): Promise<FileTreeNode[]> => [
+          { kind: "file", name: "index.html", path: `${root}/index.html` },
+          { kind: "file", name: "README.md", path: `${root}/README.md` },
+        ]
+      ),
+      readDiff: vi.fn(
+        async () =>
+          "diff --git a/README.md b/README.md\n+++ b/README.md\n+updated"
+      ),
+      listChangedPaths: vi.fn(async () => ["README.md"]),
+    })
+
+    const result = await preparePkReportData(round, deps)
+
+    expect(result.artifactsBySlot["0"]).toEqual([{ path: "README.md" }])
+  })
+
+  it("recognizes a newly created untracked HTML entry when git diff is empty", async () => {
+    const root = "/repo/.codeg-pk/7/0"
+    const deps = dependencies({
+      getFileTree: vi.fn(
+        async (): Promise<FileTreeNode[]> => [
+          { kind: "file", name: "index.html", path: `${root}/index.html` },
+          { kind: "file", name: "README.md", path: `${root}/README.md` },
+        ]
+      ),
+      listChangedPaths: vi.fn(async () => ["index.html"]),
+      readDiff: vi.fn(async () => ""),
+      readWorkspaceFileBase64: vi.fn(async () => btoa("<h1>New game</h1>")),
+    })
+
+    const result = await preparePkReportData(round, deps)
+
+    expect(result.artifactsBySlot["0"]).toEqual([
+      expect.objectContaining({
+        path: "index.html",
+        contentBase64: expect.any(String),
+      }),
+    ])
+  })
+
+  it("recognizes an HTML entry already committed on the contestant branch", async () => {
+    const root = "/repo/.codeg-pk/7/0"
+    const deps = dependencies({
+      getFileTree: vi.fn(
+        async (): Promise<FileTreeNode[]> => [
+          { kind: "file", name: "index.html", path: `${root}/index.html` },
+        ]
+      ),
+      listChangedPaths: vi.fn(async () => []),
+      readDiff: vi.fn(
+        async () =>
+          "diff --git a/index.html b/index.html\n+++ b/index.html\n+committed"
+      ),
+      readWorkspaceFileBase64: vi.fn(async () =>
+        btoa("<h1>Committed game</h1>")
+      ),
+    })
+
+    const result = await preparePkReportData(round, deps)
+
+    expect(result.artifactsBySlot["0"][0]).toEqual(
+      expect.objectContaining({ path: "index.html" })
+    )
+  })
+})
diff --git a/src/lib/pk-report-data.ts b/src/lib/pk-report-data.ts
new file mode 100644
index 000000000..d1c8d2246
--- /dev/null
+++ b/src/lib/pk-report-data.ts
@@ -0,0 +1,307 @@
+import {
+  getFileTree,
+  getGitBranch,
+  gitDiff,
+  gitDiffWithBranch,
+  gitStatus,
+  pkRoundGetReportSnapshot,
+  pkRoundSaveReportSnapshot,
+  readWorkspaceFileBase64,
+} from "@/lib/api"
+import { inlineHtmlResources } from "@/lib/html-preview-inline"
+import {
+  decodePkReportArtifact,
+  encodePkReportArtifact,
+} from "@/lib/pk-report-artifact"
+import {
+  pickRunnableHtmlPath,
+  reportableArtifactPaths,
+  type PkReportArtifact,
+} from "@/lib/pk-report"
+import type { FileTreeNode } from "@/lib/types"
+import type {
+  PkContestant,
+  PkContestantUsage,
+  PkRound,
+} from "@/stores/pk-arena-store"
+
+const MAX_HTML_BYTES = 2_000_000
+const MAX_RESOURCE_BYTES = 8 * 1024 * 1024
+const MAX_INLINE_BYTES = 4 * 1024 * 1024
+
+export interface PkReportSnapshotContestant {
+  slot: number
+  status?: PkContestant["status"]
+  statusDetail?: string | null
+  startedAt?: number | null
+  endedAt?: number | null
+  durationMs?: number | null
+  usage?: PkContestantUsage | null
+  diff?: string | null
+}
+
+export interface PkReportSnapshot {
+  version: 1
+  roundId: string
+  capturedAt: number
+  contestants: PkReportSnapshotContestant[]
+  artifactsBySlot: Record<string, PkReportArtifact[]>
+}
+
+export interface PkReportData {
+  round: PkRound
+  artifactsBySlot: Record<string, PkReportArtifact[]>
+  source: "fresh" | "snapshot" | "empty"
+}
+
+export interface PkReportDataDependencies {
+  getFileTree: (root: string, maxDepth: number) => Promise<FileTreeNode[]>
+  readWorkspaceFileBase64: (
+    root: string,
+    path: string,
+    maxBytes: number
+  ) => Promise<string>
+  listChangedPaths: (root: string) => Promise<string[]>
+  readDiff: (root: string, round: PkRound) => Promise<string | null>
+  loadSnapshot: (roundId: string) => Promise<PkReportSnapshot | null>
+  saveSnapshot: (snapshot: PkReportSnapshot) => Promise<void>
+}
+
+function normalizePath(path: string): string {
+  return path.replace(/\\/g, "/").replace(/\/$/, "")
+}
+
+function joinPath(root: string, relative: string): string {
+  return `${normalizePath(root)}/${relative.replace(/^\.\//, "")}`
+}
+
+function dirname(path: string): string {
+  const normalized = normalizePath(path)
+  const slash = normalized.lastIndexOf("/")
+  return slash <= 0 ? normalized : normalized.slice(0, slash)
+}
+
+function relativeToRoot(root: string, absolutePath: string): string {
+  const normalizedRoot = normalizePath(root)
+  const normalizedPath = normalizePath(absolutePath)
+  if (normalizedPath === normalizedRoot) return ""
+  const prefix = `${normalizedRoot}/`
+  if (!normalizedPath.startsWith(prefix)) {
+    throw new Error("report resource escaped contestant worktree")
+  }
+  return normalizedPath.slice(prefix.length)
+}
+
+function flattenTree(nodes: readonly FileTreeNode[], prefix = ""): string[] {
+  const files: string[] = []
+  for (const node of nodes) {
+    const relative = prefix ? `${prefix}/${node.name}` : node.name
+    if (node.kind === "file") files.push(relative)
+    else files.push(...flattenTree(node.children, relative))
+  }
+  return files
+}
+
+/** Files present in a git diff, including changes already committed on a PK
+ * branch. Status contributes working-tree and untracked files separately. */
+export function changedPathsFromDiff(diff: string | null): string[] {
+  if (!diff) return []
+  const paths = new Set<string>()
+  for (const line of diff.split("\n")) {
+    if (!line.startsWith("+++ b/")) continue
+    const path = line.slice("+++ b/".length).trim()
+    if (path && path !== "/dev/null") paths.add(path)
+  }
+  return [...paths]
+}
+
+function artifactRoots(round: PkRound, contestant: PkContestant): string[] {
+  const roots = [
+    contestant.worktreePath,
+    `${round.workingDir}/.codeg-pk/${round.id}/${contestant.slot}`,
+    // Rounds created before slot identity used the agent wire name here.
+    `${round.workingDir}/.codeg-pk/${round.id}/${contestant.agentType}`,
+  ].filter((root): root is string => Boolean(root))
+  return [...new Set(roots.map(normalizePath))]
+}
+
+function mergeSnapshot(round: PkRound, snapshot: PkReportSnapshot | null) {
+  if (!snapshot || snapshot.roundId !== round.id) return round
+  const bySlot = new Map(snapshot.contestants.map((item) => [item.slot, item]))
+  return {
+    ...round,
+    contestants: round.contestants.map((contestant) => {
+      const saved = bySlot.get(contestant.slot)
+      if (!saved) return contestant
+      const patch = Object.fromEntries(
+        Object.entries(saved).filter(
+          ([key, value]) => key !== "slot" && value !== undefined
+        )
+      )
+      return { ...contestant, ...patch }
+    }),
+  } as PkRound
+}
+
+function snapshotOf(
+  round: PkRound,
+  artifactsBySlot: Record<string, PkReportArtifact[]>
+): PkReportSnapshot {
+  return {
+    version: 1,
+    roundId: round.id,
+    capturedAt: Date.now(),
+    contestants: round.contestants.map((contestant) => ({
+      slot: contestant.slot,
+      status: contestant.status,
+      statusDetail: contestant.statusDetail,
+      startedAt: contestant.startedAt,
+      endedAt: contestant.endedAt,
+      durationMs: contestant.durationMs,
+      usage: contestant.usage,
+      diff: contestant.diff,
+    })),
+    artifactsBySlot,
+  }
+}
+
+function parseSnapshot(raw: string | null, roundId: string) {
+  if (!raw) return null
+  try {
+    const parsed = JSON.parse(raw) as PkReportSnapshot
+    if (
+      parsed.version !== 1 ||
+      parsed.roundId !== roundId ||
+      !Array.isArray(parsed.contestants) ||
+      !parsed.artifactsBySlot
+    ) {
+      return null
+    }
+    return parsed
+  } catch {
+    return null
+  }
+}
+
+const defaultDependencies: PkReportDataDependencies = {
+  getFileTree,
+  readWorkspaceFileBase64,
+  listChangedPaths: async (root) => {
+    const entries = await gitStatus(root, true)
+    return entries.map((entry) => {
+      // Porcelain v1 renders renames as `old -> new`; only the destination can
+      // exist in the current worktree and participate in a runnable report.
+      const separator = entry.file.lastIndexOf(" -> ")
+      return separator >= 0 ? entry.file.slice(separator + 4) : entry.file
+    })
+  },
+  readDiff: async (root, round) => {
+    const base = round.baseCommit ?? (await getGitBranch(round.workingDir))
+    const diff = base
+      ? await gitDiffWithBranch(root, base)
+      : await gitDiff(root)
+    return diff
+  },
+  loadSnapshot: async (roundId) =>
+    parseSnapshot(await pkRoundGetReportSnapshot(Number(roundId)), roundId),
+  saveSnapshot: async (snapshot) =>
+    pkRoundSaveReportSnapshot(
+      Number(snapshot.roundId),
+      JSON.stringify(snapshot)
+    ),
+}
+
+async function collectContestant(
+  root: string,
+  round: PkRound,
+  contestant: PkContestant,
+  dependencies: PkReportDataDependencies
+): Promise<{ artifacts: PkReportArtifact[]; diff: string | null }> {
+  const tree = await dependencies.getFileTree(root, 8)
+  const allPaths = reportableArtifactPaths(flattenTree(tree))
+  const diff = contestant.diff ?? (await dependencies.readDiff(root, round))
+  const changed = new Set([
+    ...(await dependencies.listChangedPaths(root)),
+    ...changedPathsFromDiff(diff),
+  ])
+  const artifactPaths = allPaths.filter((path) => changed.has(path))
+  const runnablePath = pickRunnableHtmlPath(artifactPaths)
+  let runnableBase64: string | undefined
+
+  if (runnablePath) {
+    const encoded = await dependencies.readWorkspaceFileBase64(
+      root,
+      runnablePath,
+      MAX_HTML_BYTES
+    )
+    const html = decodePkReportArtifact(encoded)
+    const inlined = await inlineHtmlResources(html, {
+      fileDir: dirname(joinPath(root, runnablePath)),
+      folderPath: root,
+      maxInlineBytes: MAX_INLINE_BYTES,
+      readFileBase64: (absolutePath) =>
+        dependencies.readWorkspaceFileBase64(
+          root,
+          relativeToRoot(root, absolutePath),
+          MAX_RESOURCE_BYTES
+        ),
+    })
+    runnableBase64 = encodePkReportArtifact(inlined)
+  }
+
+  return {
+    diff,
+    artifacts: artifactPaths.map((path) => ({
+      path,
+      ...(path === runnablePath && runnableBase64
+        ? { contentBase64: runnableBase64 }
+        : {}),
+    })),
+  }
+}
+
+export async function preparePkReportData(
+  inputRound: PkRound,
+  dependencies: PkReportDataDependencies = defaultDependencies
+): Promise<PkReportData> {
+  const saved = await dependencies.loadSnapshot(inputRound.id).catch(() => null)
+  let round = mergeSnapshot(inputRound, saved)
+  const artifactsBySlot: Record<string, PkReportArtifact[]> = {
+    ...(saved?.artifactsBySlot ?? {}),
+  }
+  let fresh = false
+
+  for (const contestant of round.contestants) {
+    for (const root of artifactRoots(round, contestant)) {
+      try {
+        const collected = await collectContestant(
+          root,
+          round,
+          contestant,
+          dependencies
+        )
+        artifactsBySlot[String(contestant.slot)] = collected.artifacts
+        round = {
+          ...round,
+          contestants: round.contestants.map((item) =>
+            item.slot === contestant.slot
+              ? { ...item, diff: collected.diff }
+              : item
+          ),
+        }
+        fresh = true
+        break
+      } catch {
+        // Try the slot path, then the legacy agent-named path, then the saved
+        // snapshot. One missing contestant must not block the whole report.
+      }
+    }
+  }
+
+  if (fresh) {
+    await dependencies.saveSnapshot(snapshotOf(round, artifactsBySlot))
+    return { round, artifactsBySlot, source: "fresh" }
+  }
+  if (saved) return { round, artifactsBySlot, source: "snapshot" }
+  return { round, artifactsBySlot, source: "empty" }
+}
diff --git a/src/lib/pk-report-export.ts b/src/lib/pk-report-export.ts
new file mode 100644
index 000000000..26811d99f
--- /dev/null
+++ b/src/lib/pk-report-export.ts
@@ -0,0 +1,14 @@
+import { saveTextFile, type ExportResult } from "@/lib/export-conversation"
+
+export function savePkReportHtml(
+  html: string,
+  roundId: string
+): Promise<ExportResult> {
+  return saveTextFile({
+    content: html,
+    suggestedName: `codeg-pk-${roundId}.html`,
+    mimeType: "text/html;charset=utf-8",
+    filterName: "HTML battle report",
+    ext: "html",
+  })
+}
diff --git a/src/lib/pk-report-locales.ts b/src/lib/pk-report-locales.ts
new file mode 100644
index 000000000..34cf4c822
--- /dev/null
+++ b/src/lib/pk-report-locales.ts
@@ -0,0 +1,409 @@
+export interface PkReportLabels {
+  title: string
+  status: string
+  finished: string
+  running: string
+  ready: string
+  contestants: string
+  duration: string
+  generated: string
+  ranking: string
+  round: string
+  agent: string
+  score: string
+  time: string
+  tokens: string
+  turns: string
+  changes: string
+  files: string
+  unavailable: string
+  verdict: string
+  details: string
+  outputFiles: string
+  diff: string
+  noFiles: string
+  noDiff: string
+  showcase: string
+  showcaseHint: string
+  shareHint: string
+  preview: string
+  openRun: string
+  runHere: string
+  viewSource: string
+  sandboxHint: string
+  generatedBy: string
+}
+
+const LABELS = {
+  en: {
+    title: "Agent PK Battle Report",
+    status: "Status",
+    finished: "Finished",
+    running: "Running",
+    ready: "Ready",
+    contestants: "Contestants",
+    duration: "Duration",
+    generated: "Generated",
+    ranking: "Results",
+    round: "Round",
+    agent: "Agent",
+    score: "Score",
+    time: "Time",
+    tokens: "Output tokens",
+    turns: "Turns",
+    changes: "Code changes",
+    files: "Files",
+    unavailable: "Not reported",
+    verdict: "Judge verdict",
+    details: "Contestant output",
+    outputFiles: "Output files",
+    diff: "Code diff",
+    noFiles: "No output files",
+    noDiff: "No comparable code changes",
+    showcase: "Play the entries",
+    showcaseHint: "Choose a contestant to run the final HTML entry",
+    shareHint:
+      "Every entry is embedded in this report—share this HTML file as-is",
+    preview: "Live preview",
+    openRun: "Open and run",
+    runHere: "Run above",
+    viewSource: "View HTML source",
+    sandboxHint: "Preview runs in an isolated sandbox",
+    generatedBy: "Generated by Codeg Agent PK Arena",
+  },
+  "zh-CN": {
+    title: "智能体 PK 战报",
+    status: "状态",
+    finished: "已结束",
+    running: "进行中",
+    ready: "就绪",
+    contestants: "参赛智能体",
+    duration: "总用时",
+    generated: "生成时间",
+    ranking: "比赛结果",
+    round: "回合",
+    agent: "智能体",
+    score: "得分",
+    time: "用时",
+    tokens: "输出 Token",
+    turns: "轮次",
+    changes: "代码变更",
+    files: "文件",
+    unavailable: "未提供",
+    verdict: "裁判结论",
+    details: "选手产出",
+    outputFiles: "产出文件",
+    diff: "代码 Diff",
+    noFiles: "没有产出文件",
+    noDiff: "没有可比较的代码变更",
+    showcase: "作品试玩",
+    showcaseHint: "选择选手，直接运行其最终 HTML 作品",
+    shareHint: "报告已完整内嵌作品，直接发送这个 HTML 文件即可分享",
+    preview: "可运行预览",
+    openRun: "新窗口运行",
+    runHere: "在上方运行",
+    viewSource: "查看 HTML 源码",
+    sandboxHint: "预览在隔离环境中运行",
+    generatedBy: "由 Codeg 智能体 PK 竞技场生成",
+  },
+  "zh-TW": {
+    title: "智能體 PK 戰報",
+    status: "狀態",
+    finished: "已結束",
+    running: "進行中",
+    ready: "就緒",
+    contestants: "參賽智能體",
+    duration: "總用時",
+    generated: "產生時間",
+    ranking: "比賽結果",
+    round: "回合",
+    agent: "智能體",
+    score: "得分",
+    time: "用時",
+    tokens: "輸出 Token",
+    turns: "輪次",
+    changes: "程式碼變更",
+    files: "檔案",
+    unavailable: "未提供",
+    verdict: "裁判結論",
+    details: "選手產出",
+    outputFiles: "產出檔案",
+    diff: "程式碼 Diff",
+    noFiles: "沒有產出檔案",
+    noDiff: "沒有可比較的程式碼變更",
+    showcase: "作品試玩",
+    showcaseHint: "選擇選手，直接執行其最終 HTML 作品",
+    shareHint: "報告已完整內嵌作品，直接傳送此 HTML 檔案即可分享",
+    preview: "可執行預覽",
+    openRun: "在新視窗執行",
+    runHere: "在上方執行",
+    viewSource: "查看 HTML 原始碼",
+    sandboxHint: "預覽在隔離環境中執行",
+    generatedBy: "由 Codeg 智能體 PK 競技場產生",
+  },
+  ja: {
+    title: "エージェントPK戦報",
+    status: "状態",
+    finished: "終了",
+    running: "実行中",
+    ready: "準備完了",
+    contestants: "参加エージェント",
+    duration: "合計時間",
+    generated: "生成日時",
+    ranking: "対戦結果",
+    round: "ラウンド",
+    agent: "エージェント",
+    score: "スコア",
+    time: "時間",
+    tokens: "出力トークン",
+    turns: "ターン",
+    changes: "コード変更",
+    files: "ファイル",
+    unavailable: "未報告",
+    verdict: "審査結果",
+    details: "参加者の成果",
+    outputFiles: "成果物",
+    diff: "コード差分",
+    noFiles: "成果物はありません",
+    noDiff: "比較可能なコード変更はありません",
+    showcase: "作品を試す",
+    showcaseHint: "参加者を選んで最終HTML作品を実行できます",
+    shareHint:
+      "全作品が埋め込まれています。このHTMLファイルをそのまま共有できます",
+    preview: "ライブプレビュー",
+    openRun: "新しいウィンドウで実行",
+    runHere: "上で実行",
+    viewSource: "HTMLソースを表示",
+    sandboxHint: "プレビューは隔離環境で実行されます",
+    generatedBy: "Codeg エージェントPKアリーナで生成",
+  },
+  ko: {
+    title: "에이전트 PK 결과 보고서",
+    status: "상태",
+    finished: "종료됨",
+    running: "진행 중",
+    ready: "준비됨",
+    contestants: "참가 에이전트",
+    duration: "총 소요 시간",
+    generated: "생성 시간",
+    ranking: "경기 결과",
+    round: "라운드",
+    agent: "에이전트",
+    score: "점수",
+    time: "시간",
+    tokens: "출력 토큰",
+    turns: "턴",
+    changes: "코드 변경",
+    files: "파일",
+    unavailable: "보고되지 않음",
+    verdict: "심판 판정",
+    details: "참가자 결과물",
+    outputFiles: "결과 파일",
+    diff: "코드 Diff",
+    noFiles: "결과 파일 없음",
+    noDiff: "비교 가능한 코드 변경 없음",
+    showcase: "작품 실행",
+    showcaseHint: "참가자를 선택해 최종 HTML 작품을 실행하세요",
+    shareHint:
+      "모든 작품이 포함되어 있으므로 이 HTML 파일을 그대로 공유할 수 있습니다",
+    preview: "실행 미리보기",
+    openRun: "새 창에서 실행",
+    runHere: "위에서 실행",
+    viewSource: "HTML 소스 보기",
+    sandboxHint: "미리보기는 격리된 환경에서 실행됩니다",
+    generatedBy: "Codeg 에이전트 PK 아레나에서 생성",
+  },
+  es: {
+    title: "Informe de batalla PK de agentes",
+    status: "Estado",
+    finished: "Finalizada",
+    running: "En curso",
+    ready: "Lista",
+    contestants: "Participantes",
+    duration: "Duración",
+    generated: "Generado",
+    ranking: "Resultados",
+    round: "Ronda",
+    agent: "Agente",
+    score: "Puntuación",
+    time: "Tiempo",
+    tokens: "Tokens de salida",
+    turns: "Turnos",
+    changes: "Cambios de código",
+    files: "Archivos",
+    unavailable: "No informado",
+    verdict: "Veredicto del juez",
+    details: "Resultados de los participantes",
+    outputFiles: "Archivos generados",
+    diff: "Diff del código",
+    noFiles: "No hay archivos generados",
+    noDiff: "No hay cambios de código comparables",
+    showcase: "Probar los trabajos",
+    showcaseHint: "Elige un participante para ejecutar su HTML final",
+    shareHint:
+      "Todos los trabajos están incluidos; comparte este archivo HTML tal cual",
+    preview: "Vista previa ejecutable",
+    openRun: "Abrir y ejecutar",
+    runHere: "Ejecutar arriba",
+    viewSource: "Ver fuente HTML",
+    sandboxHint: "La vista previa se ejecuta en un entorno aislado",
+    generatedBy: "Generado por la arena PK de agentes de Codeg",
+  },
+  de: {
+    title: "Agenten-PK-Kampfbericht",
+    status: "Status",
+    finished: "Beendet",
+    running: "Läuft",
+    ready: "Bereit",
+    contestants: "Teilnehmer",
+    duration: "Dauer",
+    generated: "Erstellt",
+    ranking: "Ergebnisse",
+    round: "Runde",
+    agent: "Agent",
+    score: "Punktzahl",
+    time: "Zeit",
+    tokens: "Ausgabe-Token",
+    turns: "Runden",
+    changes: "Codeänderungen",
+    files: "Dateien",
+    unavailable: "Nicht gemeldet",
+    verdict: "Juryurteil",
+    details: "Ergebnisse der Teilnehmer",
+    outputFiles: "Ausgabedateien",
+    diff: "Code-Diff",
+    noFiles: "Keine Ausgabedateien",
+    noDiff: "Keine vergleichbaren Codeänderungen",
+    showcase: "Beiträge ausprobieren",
+    showcaseHint:
+      "Wähle einen Teilnehmer, um dessen finale HTML-Datei auszuführen",
+    shareHint:
+      "Alle Beiträge sind eingebettet – teile diese HTML-Datei unverändert",
+    preview: "Live-Vorschau",
+    openRun: "Öffnen und ausführen",
+    runHere: "Oben ausführen",
+    viewSource: "HTML-Quelltext anzeigen",
+    sandboxHint: "Die Vorschau läuft in einer isolierten Umgebung",
+    generatedBy: "Erstellt mit der Codeg Agenten-PK-Arena",
+  },
+  fr: {
+    title: "Rapport de bataille PK des agents",
+    status: "État",
+    finished: "Terminée",
+    running: "En cours",
+    ready: "Prête",
+    contestants: "Participants",
+    duration: "Durée",
+    generated: "Généré",
+    ranking: "Résultats",
+    round: "Manche",
+    agent: "Agent",
+    score: "Score",
+    time: "Temps",
+    tokens: "Tokens de sortie",
+    turns: "Tours",
+    changes: "Modifications du code",
+    files: "Fichiers",
+    unavailable: "Non communiqué",
+    verdict: "Verdict du juge",
+    details: "Résultats des participants",
+    outputFiles: "Fichiers produits",
+    diff: "Diff du code",
+    noFiles: "Aucun fichier produit",
+    noDiff: "Aucune modification de code comparable",
+    showcase: "Essayer les créations",
+    showcaseHint: "Choisissez un participant pour exécuter son HTML final",
+    shareHint:
+      "Toutes les créations sont intégrées : partagez ce fichier HTML tel quel",
+    preview: "Aperçu exécutable",
+    openRun: "Ouvrir et exécuter",
+    runHere: "Exécuter ci-dessus",
+    viewSource: "Voir la source HTML",
+    sandboxHint: "L’aperçu s’exécute dans un environnement isolé",
+    generatedBy: "Généré par l’arène PK des agents Codeg",
+  },
+  pt: {
+    title: "Relatório de batalha PK de agentes",
+    status: "Status",
+    finished: "Finalizada",
+    running: "Em andamento",
+    ready: "Pronta",
+    contestants: "Participantes",
+    duration: "Duração",
+    generated: "Gerado",
+    ranking: "Resultados",
+    round: "Rodada",
+    agent: "Agente",
+    score: "Pontuação",
+    time: "Tempo",
+    tokens: "Tokens de saída",
+    turns: "Turnos",
+    changes: "Alterações de código",
+    files: "Arquivos",
+    unavailable: "Não informado",
+    verdict: "Veredito do juiz",
+    details: "Resultados dos participantes",
+    outputFiles: "Arquivos gerados",
+    diff: "Diff do código",
+    noFiles: "Nenhum arquivo gerado",
+    noDiff: "Nenhuma alteração de código comparável",
+    showcase: "Experimentar os trabalhos",
+    showcaseHint: "Escolha um participante para executar o HTML final",
+    shareHint:
+      "Todos os trabalhos estão incorporados; compartilhe este HTML como está",
+    preview: "Prévia executável",
+    openRun: "Abrir e executar",
+    runHere: "Executar acima",
+    viewSource: "Ver código-fonte HTML",
+    sandboxHint: "A prévia é executada em um ambiente isolado",
+    generatedBy: "Gerado pela arena PK de agentes do Codeg",
+  },
+  ar: {
+    title: "تقرير منافسة الوكلاء",
+    status: "الحالة",
+    finished: "انتهت",
+    running: "قيد التشغيل",
+    ready: "جاهزة",
+    contestants: "المتسابقون",
+    duration: "المدة",
+    generated: "وقت الإنشاء",
+    ranking: "النتائج",
+    round: "الجولة",
+    agent: "الوكيل",
+    score: "النتيجة",
+    time: "الوقت",
+    tokens: "رموز الإخراج",
+    turns: "الجولات",
+    changes: "تغييرات الشفرة",
+    files: "الملفات",
+    unavailable: "غير مُبلّغ",
+    verdict: "حكم المُحكّم",
+    details: "مخرجات المتسابقين",
+    outputFiles: "ملفات المخرجات",
+    diff: "فروق الشفرة",
+    noFiles: "لا توجد ملفات مخرجات",
+    noDiff: "لا توجد تغييرات قابلة للمقارنة",
+    showcase: "تشغيل الأعمال",
+    showcaseHint: "اختر متسابقًا لتشغيل عمل HTML النهائي",
+    shareHint: "جميع الأعمال مضمّنة؛ شارك ملف HTML هذا كما هو",
+    preview: "معاينة قابلة للتشغيل",
+    openRun: "فتح وتشغيل",
+    runHere: "تشغيل في الأعلى",
+    viewSource: "عرض مصدر HTML",
+    sandboxHint: "تعمل المعاينة في بيئة معزولة",
+    generatedBy: "تم الإنشاء بواسطة ساحة منافسة الوكلاء في Codeg",
+  },
+} satisfies Record<string, PkReportLabels>
+
+export function getPkReportLabels(locale: string): PkReportLabels {
+  const normalized = locale.toLowerCase()
+  if (normalized.startsWith("zh")) {
+    return normalized.includes("tw") || normalized.includes("hant")
+      ? LABELS["zh-TW"]
+      : LABELS["zh-CN"]
+  }
+  for (const language of ["ja", "ko", "es", "de", "fr", "pt", "ar"] as const) {
+    if (normalized.startsWith(language)) return LABELS[language]
+  }
+  return LABELS.en
+}
diff --git a/src/lib/pk-report.test.ts b/src/lib/pk-report.test.ts
new file mode 100644
index 000000000..2956500e9
--- /dev/null
+++ b/src/lib/pk-report.test.ts
@@ -0,0 +1,274 @@
+import { describe, expect, it } from "vitest"
+import { JSDOM } from "jsdom"
+import {
+  buildPkReportHtml,
+  pickRunnableHtmlPath,
+  reportableArtifactPaths,
+} from "@/lib/pk-report"
+import {
+  decodePkReportArtifact,
+  encodePkReportArtifact,
+  preparePkReportArtifactHtml,
+} from "@/lib/pk-report-artifact"
+import type { PkRound } from "@/stores/pk-arena-store"
+
+const round = {
+  id: "7",
+  task: "实现一个中文贪吃蛇",
+  createdAt: Date.parse("2026-08-20T08:00:00Z"),
+  status: "finished",
+  judgeResult: {
+    scores: [
+      {
+        slot: 0,
+        agentType: "qoder",
+        score: 88,
+        rank: 1,
+        comment: "结构清晰",
+      },
+    ],
+    summary: "Qoder 获胜",
+    rawText: "",
+  },
+  contestants: [
+    {
+      slot: 0,
+      agentType: "qoder",
+      label: null,
+      status: "done",
+      durationMs: 1200,
+      usage: {
+        inputTokens: 0,
+        outputTokens: 0,
+        turnCount: 3,
+        tokensReported: false,
+      },
+      diff: "+const snake = true",
+    },
+  ],
+} as PkRound
+
+describe("buildPkReportHtml", () => {
+  it("ignores the worktree .git control file when selecting a runnable HTML artifact", () => {
+    expect(pickRunnableHtmlPath([".git", "index.html"])).toBe("index.html")
+    expect(pickRunnableHtmlPath([".git\\config", "index.html"])).toBe(
+      "index.html"
+    )
+    expect(reportableArtifactPaths([".git", "index.html"])).toEqual([
+      "index.html",
+    ])
+  })
+
+  it("recognizes a conventional HTML entrypoint in a multi-file web project", () => {
+    expect(
+      pickRunnableHtmlPath([
+        ".git",
+        "README.md",
+        "index.html",
+        "assets/game.js",
+        "assets/game.css",
+      ])
+    ).toBe("index.html")
+    expect(
+      pickRunnableHtmlPath([
+        "package.json",
+        "src/main.ts",
+        "dist/index.html",
+        "dist/assets/app.js",
+      ])
+    ).toBe("dist/index.html")
+  })
+
+  it("builds a self-contained localized battle report without inventing tokens", () => {
+    const html = buildPkReportHtml(
+      round,
+      { "0": [{ path: "index.html" }] },
+      "zh-CN"
+    )
+
+    expect(html).toContain("智能体 PK 战报")
+    expect(html).toContain("Qoder 获胜")
+    expect(html).toContain("index.html")
+    expect(html).toContain("未提供")
+    expect(html).not.toContain(">0</td>")
+    expect(html).not.toContain("https://")
+  })
+
+  it("localizes reports for every supported UI language", () => {
+    const expectations = [
+      ["zh-TW", "智能體 PK 戰報"],
+      ["ja", "エージェントPK戦報"],
+      ["ko", "에이전트 PK 결과 보고서"],
+      ["es", "Informe de batalla PK de agentes"],
+      ["de", "Agenten-PK-Kampfbericht"],
+      ["fr", "Rapport de bataille PK des agents"],
+      ["pt", "Relatório de batalha PK de agentes"],
+      ["ar", "تقرير منافسة الوكلاء"],
+    ] as const
+
+    for (const [locale, title] of expectations) {
+      expect(buildPkReportHtml(round, {}, locale)).toContain(title)
+    }
+    expect(buildPkReportHtml(round, {}, "ar")).toContain(
+      '<html lang="ar" dir="rtl">'
+    )
+  })
+
+  it("embeds a single HTML artifact as a sandboxed runnable preview", () => {
+    const contentBase64 = btoa("<h1>Playable</h1><script>game()</script>")
+    const html = buildPkReportHtml(
+      round,
+      { "0": [{ path: "index.html", contentBase64 }] },
+      "en"
+    )
+
+    expect(html).toContain("data-showcase")
+    expect(html).toContain("data-artifact-trigger")
+    expect(html).toContain('sandbox="allow-scripts allow-pointer-lock"')
+    expect(html).toContain("data-open-artifact")
+    expect(html).toContain("Open and run")
+    expect(html.indexOf("data-showcase")).toBeLessThan(html.indexOf("Results"))
+    expect(html).not.toContain("+const snake = true")
+    expect(html).not.toContain("<h1>Playable</h1>")
+
+    const dom = new JSDOM(html)
+    const embedded = dom.window.document
+      .querySelector<HTMLElement>("[data-artifact-html]")
+      ?.getAttribute("data-artifact-html")
+    expect(decodePkReportArtifact(embedded ?? "")).toContain(
+      "data-codeg-storage-compat"
+    )
+  })
+
+  it("injects compatibility after the doctype and only once", () => {
+    const artifact = "<!doctype html><script>game()</script>"
+    const prepared = preparePkReportArtifactHtml(artifact)
+
+    expect(prepared).toMatch(
+      /^<!doctype html><script data-codeg-storage-compat>/
+    )
+    expect(preparePkReportArtifactHtml(prepared)).toBe(prepared)
+  })
+
+  it("round-trips UTF-8 artifact content through report base64", () => {
+    const artifact = "<!doctype html><title>中文作品 🐍</title>"
+    expect(decodePkReportArtifact(encodePkReportArtifact(artifact))).toBe(
+      artifact
+    )
+  })
+
+  it("keeps scores attached to repeated-agent contestant slots", () => {
+    const repeated = {
+      ...round,
+      judgeResult: {
+        scores: [
+          {
+            slot: 0,
+            agentType: "qoder",
+            score: 91,
+            rank: 1,
+            comment: "first",
+          },
+          {
+            slot: 1,
+            agentType: "qoder",
+            score: 42,
+            rank: 2,
+            comment: "second",
+          },
+        ],
+        summary: "first wins",
+        rawText: "",
+      },
+      contestants: [
+        { ...round.contestants[0], slot: 0, label: "Model A" },
+        { ...round.contestants[0], slot: 1, label: "Model B" },
+      ],
+    } as PkRound
+
+    const html = buildPkReportHtml(repeated, {}, "en")
+
+    expect(html).toMatch(
+      /Model A<\/small><\/td>\s*<td><strong class="score">91/
+    )
+    expect(html).toMatch(
+      /Model B<\/small><\/td>\s*<td><strong class="score">42/
+    )
+  })
+
+  it("runs the first embedded entry immediately and switches entries on click", () => {
+    const twoEntries = {
+      ...round,
+      contestants: [
+        { ...round.contestants[0], slot: 0, label: "First" },
+        { ...round.contestants[0], slot: 1, label: "Second" },
+      ],
+    } as PkRound
+    const html = buildPkReportHtml(
+      twoEntries,
+      {
+        "0": [
+          {
+            path: "index.html",
+            contentBase64: btoa("<h1>First entry</h1>"),
+          },
+        ],
+        "1": [
+          {
+            path: "game.html",
+            contentBase64: btoa("<h1>Second entry</h1>"),
+          },
+        ],
+      },
+      "en"
+    )
+    const dom = new JSDOM(html, {
+      runScripts: "dangerously",
+      beforeParse(window) {
+        Object.defineProperty(window, "TextDecoder", { value: TextDecoder })
+      },
+    })
+    const frame = dom.window.document.querySelector("iframe")
+    const triggers = dom.window.document.querySelectorAll<HTMLElement>(
+      "[data-artifact-trigger]"
+    )
+
+    expect(frame?.srcdoc).toContain("First entry")
+    triggers[1].click()
+    expect(frame?.srcdoc).toContain("Second entry")
+    expect(triggers[0].getAttribute("aria-pressed")).toBe("false")
+    expect(triggers[1].getAttribute("aria-pressed")).toBe("true")
+  })
+
+  it("keeps Web Storage-dependent entries runnable inside the opaque-origin sandbox", () => {
+    const artifact = `<!doctype html><html><body><p id="status">booting</p><script>
+      localStorage.setItem("high-score", "7")
+      document.querySelector("#status").textContent = localStorage.getItem("high-score")
+    </script></body></html>`
+    const report = buildPkReportHtml(
+      round,
+      {
+        "0": [
+          {
+            path: "index.html",
+            contentBase64: btoa(artifact),
+          },
+        ],
+      },
+      "en"
+    )
+    const reportDom = new JSDOM(report, {
+      runScripts: "dangerously",
+      beforeParse(window) {
+        Object.defineProperty(window, "TextDecoder", { value: TextDecoder })
+      },
+    })
+    const srcdoc = reportDom.window.document.querySelector("iframe")?.srcdoc
+
+    expect(srcdoc).toBeTruthy()
+    const artifactDom = new JSDOM(srcdoc, { runScripts: "dangerously" })
+    expect(
+      artifactDom.window.document.querySelector("#status")?.textContent
+    ).toBe("7")
+  })
+})
diff --git a/src/lib/pk-report.ts b/src/lib/pk-report.ts
new file mode 100644
index 000000000..431053396
--- /dev/null
+++ b/src/lib/pk-report.ts
@@ -0,0 +1,252 @@
+/** Build a self-contained, shareable PK battle report. */
+import { getAgentLabel } from "@/lib/custom-agents"
+import { assignJudgeScoreSlots, contestantForJudgeScore } from "@/lib/pk-judge"
+import { getPkReportLabels } from "@/lib/pk-report-locales"
+import {
+  decodePkReportArtifact,
+  encodePkReportArtifact,
+  preparePkReportArtifactHtml,
+} from "@/lib/pk-report-artifact"
+import type { PkRound } from "@/stores/pk-arena-store"
+
+export interface PkReportArtifact {
+  path: string
+  /** UTF-8 HTML encoded as base64. Present only for a runnable single-file
+   * artifact; keeping it encoded prevents contestant markup from escaping the
+   * report document while it is being generated. */
+  contentBase64?: string
+}
+
+/** Select a genuinely standalone HTML artifact from a contestant worktree. */
+export function reportableArtifactPaths(paths: readonly string[]): string[] {
+  return paths.filter((path) => {
+    const normalized = path.replace(/\\/g, "/").replace(/^\.\//, "")
+    return normalized !== ".git" && !normalized.startsWith(".git/")
+  })
+}
+
+export function pickRunnableHtmlPath(paths: readonly string[]): string | null {
+  const reportable = reportableArtifactPaths(paths)
+  const htmlPaths = reportable.filter((path) => /\.html?$/i.test(path))
+  if (htmlPaths.length === 1) return htmlPaths[0]
+
+  // Multi-file web entries are the normal case: index.html plus scripts,
+  // styles and assets. Prefer the shallowest conventional entrypoint, while
+  // refusing to guess between several arbitrarily named HTML documents.
+  const indexPaths = htmlPaths
+    .filter((path) => /(^|\/)index\.html?$/i.test(path))
+    .sort((a, b) => {
+      const depth = (path: string) => path.replace(/\\/g, "/").split("/").length
+      return depth(a) - depth(b) || a.localeCompare(b)
+    })
+  return indexPaths[0] ?? null
+}
+
+function esc(raw: string): string {
+  return raw
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+}
+
+function formatMs(ms: number): string {
+  const seconds = Math.round(ms / 1000)
+  if (seconds < 60) return `${seconds}s`
+  return `${Math.floor(seconds / 60)}m ${String(seconds % 60).padStart(2, "0")}s`
+}
+
+function diffStats(diff: string | null) {
+  let added = 0
+  let removed = 0
+  for (const line of diff?.split("\n") ?? []) {
+    if (line.startsWith("+") && !line.startsWith("+++")) added += 1
+    if (line.startsWith("-") && !line.startsWith("---")) removed += 1
+  }
+  return { added, removed }
+}
+
+function renderDiff(diff: string | null, empty: string): string {
+  if (!diff?.trim()) return `<p class="empty">${esc(empty)}</p>`
+  return `<pre>${diff
+    .split("\n")
+    .map((line) => {
+      const cls = line.startsWith("+")
+        ? "add"
+        : line.startsWith("-")
+          ? "del"
+          : line.startsWith("@@")
+            ? "hunk"
+            : ""
+      return `<span class="line ${cls}">${esc(line || " ")}</span>`
+    })
+    .join("")}</pre>`
+}
+
+function runnableHtmlArtifact(
+  artifacts: readonly PkReportArtifact[]
+): PkReportArtifact | null {
+  return (
+    artifacts.find(
+      (artifact) =>
+        artifact.contentBase64 != null && /\.html?$/i.test(artifact.path)
+    ) ?? null
+  )
+}
+
+export function buildPkReportHtml(
+  round: PkRound,
+  artifactsBySlot: Record<string, PkReportArtifact[]>,
+  locale = "zh-CN"
+): string {
+  const l = getPkReportLabels(locale)
+
+  const finished = round.contestants.every((c) =>
+    ["done", "error", "canceled"].includes(c.status)
+  )
+  const statusText = finished
+    ? l.finished
+    : round.status === "ready"
+      ? l.ready
+      : l.running
+  const duration = round.contestants.reduce<number | null>(
+    (max, c) => (c.durationMs == null ? max : Math.max(max ?? 0, c.durationMs)),
+    null
+  )
+  const scores = assignJudgeScoreSlots(
+    round.judgeResult?.scores ?? [],
+    round.contestants.filter((contestant) => contestant.status === "done")
+  ).sort((a, b) => a.rank - b.rank)
+  const scoreBySlot = new Map(
+    scores.flatMap((score) =>
+      score.slot == null ? [] : ([[score.slot, score]] as const)
+    )
+  )
+
+  const runnableEntries = round.contestants
+    .flatMap((contestant) => {
+      const artifact = runnableHtmlArtifact(
+        artifactsBySlot[String(contestant.slot)] ?? []
+      )
+      if (!artifact?.contentBase64) return []
+      const score = scoreBySlot.get(contestant.slot)
+      return [
+        {
+          contestant,
+          artifact: {
+            ...artifact,
+            contentBase64: encodePkReportArtifact(
+              preparePkReportArtifactHtml(
+                decodePkReportArtifact(artifact.contentBase64)
+              )
+            ),
+          },
+          score,
+          agentLabel: `${getAgentLabel(contestant.agentType)}${
+            contestant.label ? ` · ${contestant.label}` : ""
+          }`,
+        },
+      ]
+    })
+    .sort(
+      (a, b) =>
+        (a.score?.rank ?? Number.MAX_SAFE_INTEGER) -
+          (b.score?.rank ?? Number.MAX_SAFE_INTEGER) ||
+        a.contestant.slot - b.contestant.slot
+    )
+
+  const showcase = runnableEntries.length
+    ? `<section class="showcase" data-showcase>
+        <div class="section-head showcase-heading"><div><h2>${l.showcase}</h2><p>${l.showcaseHint}</p></div><span>${l.shareHint}</span></div>
+        <div class="entry-switcher" role="list" aria-label="${esc(l.showcase)}">${runnableEntries
+          .map(
+            ({ contestant, artifact, score, agentLabel }, index) =>
+              `<button type="button" class="entry-trigger${index === 0 ? " is-active" : ""}" data-artifact-trigger data-slot="${contestant.slot}" data-agent-label="${esc(agentLabel)}" data-artifact-path="${esc(artifact.path)}" data-artifact-html="${artifact.contentBase64}" aria-pressed="${index === 0 ? "true" : "false"}"><span class="entry-rank">${score ? `#${score.rank}` : `0${index + 1}`}</span><span class="entry-name"><b>${esc(agentLabel)}</b><small>${score ? `${score.score} pts` : artifact.path}</small></span><span class="entry-play">▶</span></button>`
+          )
+          .join("")}</div>
+        <div class="play-stage">
+          <div class="play-toolbar"><div><b data-active-agent></b><small data-active-path></small></div><button type="button" data-open-artifact>${l.openRun} ↗</button></div>
+          <iframe title="${esc(l.preview)}" sandbox="allow-scripts allow-pointer-lock" referrerpolicy="no-referrer"></iframe>
+        </div>
+      </section>`
+    : ""
+
+  const rows = round.contestants
+    .map((c, index) => {
+      const stat = diffStats(c.diff)
+      const score = scoreBySlot.get(c.slot)
+      const artifacts = artifactsBySlot[String(c.slot)] ?? []
+      const tokenText = c.usage?.tokensReported
+        ? c.usage.outputTokens.toLocaleString(locale)
+        : l.unavailable
+      return `<tr>
+        <td class="rank">${score ? `#${score.rank}` : String(index + 1).padStart(2, "0")}</td>
+        <td><b>${esc(getAgentLabel(c.agentType))}</b>${c.label ? `<small>${esc(c.label)}</small>` : ""}</td>
+        <td>${score ? `<strong class="score">${score.score}</strong>` : "—"}</td>
+        <td>${c.durationMs == null ? "—" : formatMs(c.durationMs)}</td>
+        <td>${tokenText}</td>
+        <td>${c.usage?.turnCount ?? "—"}</td>
+        <td><span class="plus">+${stat.added}</span> <span class="minus">−${stat.removed}</span></td>
+        <td>${artifacts.length}</td>
+      </tr>`
+    })
+    .join("")
+
+  const judge = round.judgeResult
+    ? `<section class="verdict">
+        <div class="eyebrow">${l.verdict}</div>
+        <h2>${esc(round.judgeResult.summary)}</h2>
+        <div class="comments">${scores
+          .map((score) => {
+            const contestant = contestantForJudgeScore(score, round.contestants)
+            return `<article><span>#${score.rank}</span><div><b>${esc(
+              getAgentLabel(score.agentType)
+            )}${contestant?.label ? ` · ${esc(contestant.label)}` : ""} · ${score.score}</b><p>${esc(score.comment)}</p></div></article>`
+          })
+          .join("")}</div>
+      </section>`
+    : ""
+
+  const details = round.contestants
+    .map((c) => {
+      const artifacts = artifactsBySlot[String(c.slot)] ?? []
+      const runnable = runnableHtmlArtifact(artifacts)
+      const fileList = artifacts.length
+        ? `<ul>${artifacts
+            .map((artifact) => `<li>${esc(artifact.path)}</li>`)
+            .join("")}</ul>`
+        : `<p class="empty">${l.noFiles}</p>`
+      const body = runnable
+        ? `<div class="artifact-layout">
+          <div class="artifact-files"><h3>${l.outputFiles}</h3>${fileList}</div>
+          <div class="artifact-note">
+            <h3>${l.preview}</h3><p>${esc(runnable.path)} · ${l.sandboxHint}</p>
+            <button type="button" data-run-slot="${c.slot}">${l.runHere} ↑</button>
+            <details class="source-disclosure"><summary>${l.viewSource}</summary><pre class="artifact-source" data-source-slot="${c.slot}"></pre></details>
+          </div>
+        </div>`
+        : `<div class="detail-grid">
+          <div><h3>${l.outputFiles}</h3>${
+            artifacts.length ? fileList : `<p class="empty">${l.noFiles}</p>`
+          }</div>
+          <div><h3>${l.diff}</h3>${renderDiff(c.diff, l.noDiff)}</div>
+        </div>`
+      return `<details class="contestant-detail">
+        <summary><span>${esc(getAgentLabel(c.agentType))}${c.label ? ` · ${esc(c.label)}` : ""}</span><span>${l.outputFiles} ${artifacts.length} · ${runnable ? l.preview : l.diff}</span></summary>
+        ${body}
+      </details>`
+    })
+    .join("")
+
+  return `<!doctype html>
+<html lang="${esc(locale)}"${locale.toLowerCase().startsWith("ar") ? ' dir="rtl"' : ""}><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${esc(l.title)} · ${esc(round.task)}</title>
+<style>
+:root{--ink:#11110f;--paper:#f3f0e8;--card:#fffdf7;--line:#d8d2c5;--accent:#ffd84d;--muted:#6b675e;--green:#087b45;--red:#b42318}*{box-sizing:border-box}body{margin:0;background:#d9d4c8;color:var(--ink);font:14px/1.55 "Avenir Next","PingFang SC","Microsoft YaHei",sans-serif}.sheet{width:min(1280px,100%);margin:16px auto;background:var(--paper);box-shadow:0 24px 80px #302b2050}.masthead{position:relative;overflow:hidden;background:var(--ink);color:#fff;padding:28px 40px 24px}.masthead:after{content:"PK";position:absolute;right:22px;bottom:-96px;font:900 220px/1 Georgia,serif;color:#ffffff0b;letter-spacing:-20px}.brand{display:flex;align-items:center;gap:12px;font-size:11px;font-weight:700;letter-spacing:.16em;text-transform:uppercase}.brand i{display:block;width:28px;height:5px;background:var(--accent)}h1{position:relative;max-width:980px;margin:24px 0 20px;font:700 clamp(30px,4.2vw,52px)/1.08 Georgia,"Songti SC",serif;letter-spacing:-.035em;text-wrap:balance}.meta{position:relative;display:grid;grid-template-columns:repeat(4,1fr);gap:24px;border-top:1px solid #ffffff28;padding-top:15px}.meta span{display:block;color:#aaa79f;font-size:10px;text-transform:uppercase;letter-spacing:.08em}.meta b{display:block;margin-top:2px;color:#fff;font-size:14px;letter-spacing:0}.content{padding:28px 40px 56px}.section-head{display:flex;align-items:end;justify-content:space-between;margin:0 0 14px}.section-head h2{margin:0;font:700 24px/1.2 Georgia,"Songti SC",serif;letter-spacing:-.02em}.section-head span,.eyebrow{font-size:10px;font-weight:800;letter-spacing:.12em;text-transform:uppercase;color:var(--muted)}.showcase{margin-bottom:34px}.showcase-heading{align-items:start}.showcase-heading p{margin:4px 0 0;color:var(--muted)}.showcase-heading>span{max-width:380px;text-align:right;line-height:1.45}.entry-switcher{display:flex;gap:0;overflow-x:auto;border:1px solid var(--ink);border-bottom:0;background:var(--card)}.entry-trigger{display:grid;grid-template-columns:auto minmax(120px,1fr) auto;align-items:center;gap:10px;min-width:210px;min-height:58px;border:0;border-right:1px solid var(--line);background:transparent;padding:9px 12px;color:var(--ink);cursor:pointer;text-align:left}.entry-trigger:hover{background:#ebe6da}.entry-trigger.is-active{background:var(--accent)}.entry-rank{font:800 16px ui-monospace,monospace}.entry-name{min-width:0}.entry-name b,.entry-name small{display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.entry-name small{color:var(--muted);font-size:10px}.entry-play{font-size:10px}.play-stage{border:1px solid var(--ink);background:#fff}.play-toolbar{display:flex;align-items:center;justify-content:space-between;gap:16px;min-height:52px;padding:9px 12px;border-bottom:1px solid var(--line);background:#ebe6da}.play-toolbar div{min-width:0}.play-toolbar b,.play-toolbar small{display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.play-toolbar small{color:var(--muted);font-size:11px}.play-toolbar button,.artifact-note>button{min-height:36px;border:1px solid var(--ink);background:var(--ink);color:#fff;padding:7px 12px;cursor:pointer;font:700 12px/1 inherit}.play-stage iframe{display:block;width:100%;height:min(680px,70vh);border:0;background:#fff}.table-wrap{overflow:auto;border:1px solid var(--line);background:var(--card)}table{width:100%;border-collapse:collapse;min-width:820px}th,td{padding:15px 14px;border-bottom:1px solid var(--line);text-align:left;white-space:nowrap}th{background:#ebe6da;color:var(--muted);font-size:10px;letter-spacing:.08em;text-transform:uppercase}tr:last-child td{border-bottom:0}.rank{font:800 18px ui-monospace,monospace}.score{display:inline-grid;place-items:center;min-width:42px;padding:3px 8px;background:var(--accent);font-size:17px}td small{display:block;color:var(--muted)}.plus{color:var(--green)}.minus{color:var(--red)}.verdict{margin:34px 0;padding:30px;border:1px solid var(--ink);background:var(--card)}.verdict h2{max-width:900px;margin:10px 0 26px;font:700 24px/1.4 Georgia,"Songti SC",serif;text-wrap:pretty}.comments{display:grid;grid-template-columns:repeat(auto-fit,minmax(240px,1fr));gap:12px}.comments article{display:flex;gap:12px;border-top:1px solid var(--line);padding-top:14px}.comments article>span{font:800 18px ui-monospace,monospace}.comments p{margin:5px 0 0;color:var(--muted);text-wrap:pretty}.details{margin-top:34px}details{border-top:1px solid var(--line);background:var(--card)}details:last-child{border-bottom:1px solid var(--line)}summary{display:flex;justify-content:space-between;gap:20px;padding:18px 20px;cursor:pointer;font-weight:700}summary span:last-child{color:var(--muted);font-size:12px;font-weight:500}.detail-grid{display:grid;grid-template-columns:minmax(220px,.35fr) minmax(0,1fr);gap:24px;border-top:1px solid var(--line);padding:20px}.detail-grid h3,.artifact-layout h3{margin:0 0 10px;font-size:12px;text-transform:uppercase;letter-spacing:.08em}.detail-grid ul,.artifact-files ul{margin:0;padding-left:18px;word-break:break-all}.artifact-layout{display:grid;grid-template-columns:minmax(180px,.28fr) minmax(0,1fr);gap:20px;border-top:1px solid var(--line);padding:20px}.artifact-note p{margin:0 0 12px;color:var(--muted)}.source-disclosure{margin-top:12px;border:1px solid var(--line)}.source-disclosure summary{padding:10px 12px;font-size:12px}.artifact-source{max-height:420px}.empty{color:var(--muted)}pre{max-height:560px;margin:0;overflow:auto;background:#171715;color:#d7d3ca;padding:16px;font:11px/1.55 ui-monospace,SFMono-Regular,Menlo,monospace}.line{display:block;white-space:pre}.line.add{background:#0c7b4530;color:#a9e6c5}.line.del{background:#b4231833;color:#ffb4ab}.line.hunk{color:#ffd84d}.footer{display:flex;justify-content:space-between;border-top:1px solid var(--line);margin-top:42px;padding-top:18px;color:var(--muted);font-size:12px}@media(max-width:720px){.sheet{margin:0}.masthead,.content{padding-left:18px;padding-right:18px}.masthead{padding-top:22px}.meta{grid-template-columns:1fr 1fr}.showcase-heading{display:block}.showcase-heading>span{display:block;margin-top:8px;text-align:left}.entry-trigger{min-width:190px}.play-stage iframe{height:62vh}.detail-grid,.artifact-layout{grid-template-columns:1fr}.footer{display:block}}@media print{body{background:#fff}.sheet{width:100%;margin:0;box-shadow:none}.showcase{display:none}details{break-inside:avoid}.masthead{-webkit-print-color-adjust:exact;print-color-adjust:exact}}
+</style></head><body><main class="sheet">
+<header class="masthead"><div class="brand"><i></i>Codeg · ${esc(l.title)}</div><h1>${esc(round.task)}</h1><div class="meta"><div><span>${l.status}</span><b>${statusText}</b></div><div><span>${l.contestants}</span><b>${round.contestants.length}</b></div><div><span>${l.duration}</span><b>${duration == null ? "—" : formatMs(duration)}</b></div><div><span>${l.generated}</span><b>${new Date().toLocaleString(locale)}</b></div></div></header>
+<div class="content">${showcase}<section><div class="section-head"><h2>${l.ranking}</h2><span>${l.round} ${round.id}</span></div><div class="table-wrap"><table><thead><tr><th>#</th><th>${l.agent}</th><th>${l.score}</th><th>${l.time}</th><th>${l.tokens}</th><th>${l.turns}</th><th>${l.changes}</th><th>${l.files}</th></tr></thead><tbody>${rows}</tbody></table></div></section>${judge}<section class="details"><div class="section-head"><h2>${l.details}</h2></div>${details}</section><footer class="footer"><span>${esc(l.generatedBy)}</span><span>${new Date(round.createdAt).toLocaleString(locale)}</span></footer></div>
+</main><script>
+(()=>{const showcase=document.querySelector("[data-showcase]");if(!showcase)return;const decode=(value)=>{const binary=atob(value);const bytes=Uint8Array.from(binary,(char)=>char.charCodeAt(0));return new TextDecoder().decode(bytes)};const triggers=[...showcase.querySelectorAll("[data-artifact-trigger]")];const frame=showcase.querySelector("iframe");const agent=showcase.querySelector("[data-active-agent]");const path=showcase.querySelector("[data-active-path]");const openButton=showcase.querySelector("[data-open-artifact]");let active=null;const activate=(button)=>{if(!button||!frame)return;active=button;for(const item of triggers){const selected=item===button;item.classList.toggle("is-active",selected);item.setAttribute("aria-pressed",String(selected))}if(agent)agent.textContent=button.dataset.agentLabel||"";if(path)path.textContent=(button.dataset.artifactPath||"")+" · ${l.sandboxHint}";frame.title=(button.dataset.agentLabel||"")+" · ${l.preview}";frame.srcdoc=decode(button.dataset.artifactHtml||"")};for(const button of triggers)button.addEventListener("click",()=>activate(button));if(openButton)openButton.addEventListener("click",()=>{if(!active)return;const html=decode(active.dataset.artifactHtml||"");const url=URL.createObjectURL(new Blob([html],{type:"text/html;charset=utf-8"}));window.open(url,"_blank","noopener");setTimeout(()=>URL.revokeObjectURL(url),60000)});document.addEventListener("click",(event)=>{const target=event.target;if(!(target instanceof Element))return;const runButton=target.closest("[data-run-slot]");if(!runButton)return;const slot=runButton.getAttribute("data-run-slot");const trigger=triggers.find((item)=>item.dataset.slot===slot);if(!trigger)return;activate(trigger);window.scrollTo({top:Math.max(0,showcase.getBoundingClientRect().top+window.scrollY-12),behavior:"smooth"})});document.addEventListener("toggle",(event)=>{const detail=event.target;if(!(detail instanceof HTMLDetailsElement)||!detail.open||!detail.classList.contains("source-disclosure"))return;const source=detail.querySelector("[data-source-slot]");if(!source||source.textContent)return;const slot=source.getAttribute("data-source-slot");const trigger=triggers.find((item)=>item.dataset.slot===slot);if(trigger)source.textContent=decode(trigger.dataset.artifactHtml||"")},true);activate(triggers[0])})();
+</script></body></html>`
+}
diff --git a/src/lib/pk-templates.ts b/src/lib/pk-templates.ts
new file mode 100644
index 000000000..7932ee05d
--- /dev/null
+++ b/src/lib/pk-templates.ts
@@ -0,0 +1,67 @@
+/**
+ * Built-in PK task templates — visually verifiable creative prompts that
+ * are proven conversation starters in the AI community.
+ *
+ * Each template fills the launcher's task textarea in one click, lowering
+ * the barrier to starting a match. Task text is in Chinese (the primary
+ * user base); i18n only translates the short label shown on the chip.
+ *
+ * Sources are documented in docs/PK-ROADMAP.md (功能 1).
+ */
+
+export interface PkTaskTemplate {
+  /** Stable id for the template. */
+  id: string
+  /** Short display label (i18n key under PkArena.templates.<id>). */
+  labelKey: string
+  /** Emoji shown on the template chip. */
+  emoji: string
+  /** The task text to fill into the textarea. */
+  task: string
+}
+
+/** Built-in templates, ordered by visual impact / viral potential. */
+export const PK_TEMPLATES: readonly PkTaskTemplate[] = [
+  {
+    id: "pelican",
+    labelKey: "pelican",
+    emoji: "🦤",
+    task: "生成一幅鹈鹕骑自行车的 SVG 图。",
+  },
+  {
+    id: "bouncingBall",
+    labelKey: "bouncingBall",
+    emoji: "⚽",
+    task: "做一个 HTML 动画:一个小球从三角形中心出发,每次撞到边就加速,并且多边形增加一条边(三角形→正方形→五边形→六边形……)。",
+  },
+  {
+    id: "jellyBlob",
+    labelKey: "jellyBlob",
+    emoji: "🫧",
+    task: "做一个浏览器小玩具:一个果冻 blob,可以戳、抓、拉伸它。没有计分、没有关卡,就是一个手感很好的 blob。",
+  },
+  {
+    id: "blackHole",
+    labelKey: "blackHole",
+    emoji: "🕳️",
+    task: "做一个 HTML 黑洞效果:中心一个吸积盘环绕旋转,背景星空被引力透镜扭曲拉扯,附近的光线被拖入事件视界。用 Canvas 或 WebGL 实现,鼠标移动时可以改变观察视角。",
+  },
+  {
+    id: "snake",
+    labelKey: "snake",
+    emoji: "🐍",
+    task: "用单个 HTML 文件写一个贪吃蛇游戏,键盘控制。",
+  },
+  {
+    id: "flappyBird",
+    labelKey: "flappyBird",
+    emoji: "🐤",
+    task: "用单个 HTML 文件写一个 Flappy Bird 克隆,Canvas 渲染。",
+  },
+  {
+    id: "voiceChat",
+    labelKey: "voiceChat",
+    emoji: "🎙️",
+    task: "用 Web Speech API 做一个支持语音的聊天机器人网页应用。",
+  },
+] as const
diff --git a/src/lib/sidebar-view-mode-storage.ts b/src/lib/sidebar-view-mode-storage.ts
index 93a0ef516..27dad1a8a 100644
--- a/src/lib/sidebar-view-mode-storage.ts
+++ b/src/lib/sidebar-view-mode-storage.ts
@@ -18,12 +18,18 @@ export const SIDEBAR_SECTION_IDS = ["folders", "chats", "recent"] as const
 
 export type SidebarSectionId = (typeof SIDEBAR_SECTION_IDS)[number]
 
-/** Every section that can own a header row — the always-on-top "Pinned" bucket
- *  plus the reorderable ones, in render order. The one list every all-sections
- *  operation walks (collapse/expand all, {@link loadSectionCollapsed}), so a
- *  section added to {@link SIDEBAR_SECTION_IDS} is picked up by all of them
- *  rather than silently missed by whichever one forgot to grow a branch. */
-export const SIDEBAR_SECTION_KEYS = ["pinned", ...SIDEBAR_SECTION_IDS] as const
+/** Every section that can own a header row — the always-on-top "Pinned" bucket,
+ *  the always-on-top "PK" bucket (shown only when PK arena conversations
+ *  exist), plus the reorderable ones, in render order. The one list every
+ *  all-sections operation walks (collapse/expand all,
+ *  {@link loadSectionCollapsed}), so a section added to
+ *  {@link SIDEBAR_SECTION_IDS} is picked up by all of them rather than
+ *  silently missed by whichever one forgot to grow a branch. */
+export const SIDEBAR_SECTION_KEYS = [
+  "pinned",
+  "pk",
+  ...SIDEBAR_SECTION_IDS,
+] as const
 
 export type SidebarSectionKey = (typeof SIDEBAR_SECTION_KEYS)[number]
 
@@ -44,6 +50,7 @@ export const DEFAULT_SECTION_ORDER: SidebarSectionOrder = SIDEBAR_SECTION_IDS
  *  (the default), so a fresh user sees every section open. */
 export interface SidebarSectionCollapsed {
   pinned?: boolean
+  pk?: boolean
   folders?: boolean
   chats?: boolean
   recent?: boolean
diff --git a/src/lib/types.ts b/src/lib/types.ts
index e274aa1c4..f36d54ccb 100644
--- a/src/lib/types.ts
+++ b/src/lib/types.ts
@@ -418,6 +418,9 @@ export interface DbConversationSummary {
    *  worktree path it originally ran in. Drives the "source worktree removed"
    *  badge. */
   origin_cwd?: string | null
+  /** The PK arena round this contestant session belongs to. Set only when
+   *  `kind === "pk"`; drives the sidebar's per-round grouping. */
+  pk_round_id?: number | null
 }
 
 /** Payload for the global `conversation://changed` side-channel that keeps
@@ -656,8 +659,81 @@ export type ConversationStatus =
 
 /** Mirrors Rust `ConversationKind` (src-tauri/src/db/entities/conversation.rs).
  *  `loop` rows belong to the Loop Engineering workbench and never appear in
- *  the sidebar list; `delegate` rows nest under their parent's tool-call view. */
-export type ConversationKind = "regular" | "chat" | "loop" | "delegate"
+ *  the sidebar list; `delegate` rows nest under their parent's tool-call view;
+ *  `pk` rows are PK-arena contestant sessions grouped under their round. */
+export type ConversationKind = "regular" | "chat" | "loop" | "delegate" | "pk"
+
+/** Mirrors Rust `PkRoundStatus` (src-tauri/src/db/entities/pk_round.rs). */
+export type PkRoundStatus =
+  | "ready"
+  | "running"
+  | "finished"
+  | "canceled"
+  | "interrupted"
+
+/** Mirrors Rust `PkContestantEntry` (src-tauri/src/models/pk_round.rs).
+ * Plain strings are legacy entries; objects can pin per-slot ACP config. */
+export type PkContestantEntry =
+  | string
+  | {
+      agent: string
+      label?: string
+      config_values?: Record<string, string>
+    }
+
+/** Mirrors Rust `PkRoundConfig` (src-tauri/src/models/pk_round.rs). Stored as
+ *  JSON in `pk_round.config`. */
+export interface PkRoundConfig {
+  /** Contestants in slot order, optionally carrying per-slot ACP config. */
+  agents: PkContestantEntry[]
+  /** Round-level permission policy applied to every contestant. */
+  permission_mode: string
+  /** Bare mode: contestants are instructed to use no skills at all. */
+  bare_mode: boolean
+  /** Uniform reasoning-effort request applied to every contestant. */
+  effort: string
+  /** Optional judge agent type — reads all diffs and produces a verdict. */
+  judge_agent?: string
+  /** Optional custom judge evaluation dimensions. Each entry is a free-form
+   *  line replacing the default 4 (Correctness / Code quality / Completeness /
+   *  Efficiency). Empty or absent = use the defaults. */
+  judge_dimensions?: string[]
+  /** Git ref each contestant worktree is branched from. Absent = current HEAD.
+   *  When the launcher picks commit X as the task source, this is `X^` so the
+   *  worktree starts before X — physical isolation, not a prompt rule. */
+  base_commit?: string
+}
+
+/** Mirrors Rust `PkRoundInfo` (src-tauri/src/models/pk_round.rs). */
+export interface PkRoundInfo {
+  id: number
+  folder_id: number
+  task: string
+  config: PkRoundConfig
+  status: PkRoundStatus
+  failure_reason: string | null
+  judge_result?: PkJudgeResultDto | null
+  judge_status: string
+  created_at: string
+  updated_at: string
+  finished_at: string | null
+}
+
+/** Serialized judge verdict shape stored in the DB. */
+export interface PkJudgeResultDto {
+  scores: PkJudgeScoreDto[]
+  summary: string
+  rawText: string
+}
+
+/** One contestant's judge verdict. */
+export interface PkJudgeScoreDto {
+  slot?: number
+  agentType: string
+  score: number
+  rank: number
+  comment: string
+}
 
 /** Mirrors Rust `FolderKind` (src-tauri/src/db/entities/folder.rs).
  *  `loop_worktree` is reserved for M2+ — add it here when the variant lands. */
diff --git a/src/lib/workspace-tab.ts b/src/lib/workspace-tab.ts
new file mode 100644
index 000000000..5ad1f7935
--- /dev/null
+++ b/src/lib/workspace-tab.ts
@@ -0,0 +1,41 @@
+import type { AgentType, ConversationStatus } from "@/lib/types"
+
+interface WorkspaceTabBase {
+  id: string
+  folderId: number
+  title: string
+  isPinned: boolean
+}
+
+export interface ConversationWorkspaceTab extends WorkspaceTabBase {
+  kind: "conversation"
+  conversationId: number | null
+  /** Runtime key used before a draft binds to its persisted conversation. */
+  runtimeConversationId?: number
+  agentType: AgentType
+  workingDir?: string
+  status?: ConversationStatus
+  agentTypeProvisional?: boolean
+  isChat?: boolean
+}
+
+/** Device-local view placement for a persisted PK round. Round execution and
+ * data remain owned by the PK store/database. */
+export interface PkWorkspaceTab extends WorkspaceTabBase {
+  kind: "pk"
+  roundId: string
+}
+
+export type WorkspaceTab = ConversationWorkspaceTab | PkWorkspaceTab
+
+export function isConversationWorkspaceTab(
+  tab: WorkspaceTab
+): tab is ConversationWorkspaceTab {
+  return tab.kind === "conversation"
+}
+
+export function isConversationDraft(
+  tab: WorkspaceTab
+): tab is ConversationWorkspaceTab & { conversationId: null } {
+  return tab.kind === "conversation" && tab.conversationId == null
+}
diff --git a/src/stores/pk-arena-store.test.ts b/src/stores/pk-arena-store.test.ts
new file mode 100644
index 000000000..6f5aa8b88
--- /dev/null
+++ b/src/stores/pk-arena-store.test.ts
@@ -0,0 +1,427 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import {
+  contestantBranchName,
+  contestantContextKey,
+  dbRoundToStoreRound,
+  usePkArenaStore,
+  type PkRound,
+} from "./pk-arena-store"
+import type { DbConversationSummary, PkRoundInfo } from "@/lib/types"
+import {
+  pkRoundCreate,
+  pkRoundUpdateJudge,
+  pkRoundUpdateStatus,
+} from "@/lib/api"
+
+// Mock the API calls so createRound/markRound/archiveRound don't hit the network.
+vi.mock("@/lib/api", () => ({
+  pkRoundCreate: vi.fn().mockResolvedValue({
+    id: 1,
+    folder_id: 7,
+    task: "write a snake game",
+    config: {
+      agents: ["claude_code", "codex"],
+      permission_mode: "default",
+      bare_mode: false,
+      effort: "default",
+    },
+    status: "ready",
+    failure_reason: null,
+    created_at: "2026-01-01T00:00:00Z",
+    updated_at: "2026-01-01T00:00:00Z",
+    finished_at: null,
+    judge_status: "idle",
+  }),
+  pkRoundUpdateStatus: vi.fn().mockResolvedValue(undefined),
+  pkRoundDelete: vi.fn().mockResolvedValue(undefined),
+  pkRoundUpdateJudge: vi.fn().mockResolvedValue(undefined),
+}))
+
+function freshStore() {
+  usePkArenaStore.setState({
+    rounds: [],
+    activeRoundId: null,
+    launcherOpen: false,
+    pillDismissed: false,
+    hydrating: false,
+  })
+}
+
+async function makeRound(overrides?: Partial<PkRound>): Promise<PkRound> {
+  const round = await usePkArenaStore.getState().createRound({
+    task: "write a snake game",
+    folderId: 7,
+    workingDir: "/tmp/repo",
+    agents: [
+      { agentType: "claude_code" as const },
+      { agentType: "codex" as const },
+    ],
+  })
+  return overrides ? { ...round, ...overrides } : round
+}
+
+describe("pk arena store", () => {
+  beforeEach(() => {
+    freshStore()
+    vi.clearAllMocks()
+  })
+
+  it("creates a round with one preparing contestant per agent", async () => {
+    const round = await makeRound()
+    expect(round.status).toBe("ready")
+    expect(round.contestants.map((c) => c.agentType)).toEqual([
+      "claude_code",
+      "codex",
+    ])
+    expect(round.contestants.map((c) => c.slot)).toEqual([0, 1])
+    expect(
+      round.contestants.every(
+        (c) =>
+          c.status === "preparing" &&
+          c.contextKey === null &&
+          c.connectionId === null &&
+          c.conversationId === null
+      )
+    ).toBe(true)
+    expect(usePkArenaStore.getState().activeRoundId).toBe(round.id)
+    expect(usePkArenaStore.getState().rounds).toHaveLength(1)
+  })
+
+  it("patches a single contestant without touching its peers", async () => {
+    const round = await makeRound()
+    usePkArenaStore.getState().updateContestant(round.id, 1, {
+      status: "running",
+      startedAt: 1234,
+      connectionId: "conn-1",
+    })
+    const codex = usePkArenaStore
+      .getState()
+      .rounds[0].contestants.find((c) => c.slot === 1)
+    const claude = usePkArenaStore
+      .getState()
+      .rounds[0].contestants.find((c) => c.slot === 0)
+    expect(codex).toMatchObject({ status: "running", connectionId: "conn-1" })
+    expect(claude?.status).toBe("preparing")
+  })
+
+  it("marks round status and removes rounds", async () => {
+    const round = await makeRound()
+    usePkArenaStore.getState().markRound(round.id, "finished")
+    expect(usePkArenaStore.getState().rounds[0].status).toBe("finished")
+
+    await usePkArenaStore.getState().archiveRound(round.id)
+    expect(usePkArenaStore.getState().rounds).toHaveLength(0)
+    expect(usePkArenaStore.getState().activeRoundId).toBeNull()
+  })
+
+  it("surfaces persistence failures until the same field saves successfully", async () => {
+    const consoleError = vi.spyOn(console, "error").mockImplementation(() => {})
+    const round = await makeRound()
+    vi.mocked(pkRoundUpdateStatus).mockRejectedValueOnce(
+      new Error("database unavailable")
+    )
+
+    usePkArenaStore.getState().markRound(round.id, "running")
+
+    await vi.waitFor(() =>
+      expect(
+        usePkArenaStore.getState().rounds[0].persistenceErrors.status
+      ).toBe("database unavailable")
+    )
+
+    usePkArenaStore.getState().retryPersistence(round.id)
+
+    await vi.waitFor(() =>
+      expect(
+        usePkArenaStore.getState().rounds[0].persistenceErrors.status
+      ).toBeNull()
+    )
+    consoleError.mockRestore()
+  })
+
+  it("serializes writes so an older request cannot overwrite a newer value", async () => {
+    const consoleError = vi.spyOn(console, "error").mockImplementation(() => {})
+    const round = await makeRound()
+    let rejectOlder!: (error: Error) => void
+    vi.mocked(pkRoundUpdateStatus).mockImplementationOnce(
+      () =>
+        new Promise<void>((_, reject) => {
+          rejectOlder = reject
+        })
+    )
+
+    usePkArenaStore.getState().markRound(round.id, "running")
+    usePkArenaStore.getState().markRound(round.id, "finished")
+    await vi.waitFor(() => expect(pkRoundUpdateStatus).toHaveBeenCalledTimes(1))
+    rejectOlder(new Error("stale failure"))
+    await vi.waitFor(() => expect(pkRoundUpdateStatus).toHaveBeenCalledTimes(2))
+    await vi.waitFor(() =>
+      expect(
+        usePkArenaStore.getState().rounds[0].persistenceErrors.status
+      ).toBeNull()
+    )
+
+    expect(vi.mocked(pkRoundUpdateStatus).mock.calls).toEqual([
+      [Number(round.id), "running"],
+      [Number(round.id), "finished"],
+    ])
+    consoleError.mockRestore()
+  })
+
+  it("surfaces judge persistence failures independently", async () => {
+    const consoleError = vi.spyOn(console, "error").mockImplementation(() => {})
+    const round = await makeRound()
+    vi.mocked(pkRoundUpdateJudge).mockRejectedValueOnce(
+      new Error("judge write failed")
+    )
+
+    usePkArenaStore.getState().updateJudge(round.id, {
+      judgeStatus: "running",
+    })
+
+    await vi.waitFor(() =>
+      expect(usePkArenaStore.getState().rounds[0].persistenceErrors.judge).toBe(
+        "judge write failed"
+      )
+    )
+    expect(
+      usePkArenaStore.getState().rounds[0].persistenceErrors.status
+    ).toBeNull()
+    consoleError.mockRestore()
+  })
+
+  it("does not implicitly select history during hydration", async () => {
+    const round = await makeRound()
+    usePkArenaStore.setState({
+      rounds: [],
+      activeRoundId: null,
+      hydrating: true,
+    })
+
+    usePkArenaStore.getState().hydrateFromDb([round])
+
+    expect(usePkArenaStore.getState().activeRoundId).toBeNull()
+    expect(usePkArenaStore.getState().hydrating).toBe(false)
+  })
+
+  it("preserves a sidebar-selected round while its history is still hydrating", async () => {
+    const clickedRound = await makeRound({ id: "3" })
+    const newerRound = { ...clickedRound, id: "4", task: "newer round" }
+    usePkArenaStore.setState({
+      rounds: [],
+      activeRoundId: "3",
+      hydrating: true,
+    })
+
+    usePkArenaStore.getState().hydrateFromDb([newerRound, clickedRound])
+
+    expect(usePkArenaStore.getState().activeRoundId).toBe("3")
+  })
+
+  it("derives branch and context keys from the round id and slot", () => {
+    expect(contestantBranchName("r1", 0)).toBe("codeg-pk/r1/0")
+    expect(contestantContextKey("r1", 1)).toBe("pk:r1:1")
+  })
+
+  it("revives a running round as interrupted from DB hydration", () => {
+    const dbRound: PkRoundInfo = {
+      id: 42,
+      folder_id: 7,
+      task: "write a snake game",
+      config: {
+        agents: ["claude_code", "codex"],
+        permission_mode: "default",
+        bare_mode: false,
+        effort: "default",
+      },
+      status: "running",
+      judge_status: "idle",
+      failure_reason: null,
+      created_at: "2026-01-01T00:00:00Z",
+      updated_at: "2026-01-01T00:00:00Z",
+      finished_at: null,
+    }
+    const revived = dbRoundToStoreRound(dbRound, "/tmp/repo")
+    expect(revived.id).toBe("42")
+    expect(revived.status).toBe("interrupted")
+    expect(revived.contestants.map((c) => c.status)).toEqual([
+      "canceled",
+      "canceled",
+    ])
+    expect(revived.contestants.every((c) => c.contextKey === null)).toBe(true)
+    expect(revived.contestants.map((c) => c.slot)).toEqual([0, 1])
+  })
+
+  it("revives a finished round unchanged from DB hydration", () => {
+    const dbRound: PkRoundInfo = {
+      id: 43,
+      folder_id: 7,
+      task: "done task",
+      config: {
+        agents: ["codex"],
+        permission_mode: "default",
+        bare_mode: false,
+        effort: "default",
+      },
+      status: "finished",
+      judge_status: "idle",
+      failure_reason: null,
+      created_at: "2026-01-01T00:00:00Z",
+      updated_at: "2026-01-01T01:00:00Z",
+      finished_at: "2026-01-01T01:00:00Z",
+    }
+    const revived = dbRoundToStoreRound(dbRound, "/tmp/repo")
+    expect(revived.status).toBe("finished")
+    expect(revived.contestants[0].status).toBe("done")
+  })
+
+  it("reattaches persisted PK conversations to contestant slots", () => {
+    const dbRound: PkRoundInfo = {
+      id: 42,
+      folder_id: 7,
+      task: "history",
+      config: {
+        agents: ["claude_code", "qoder"],
+        permission_mode: "default",
+        bare_mode: false,
+        effort: "default",
+      },
+      status: "finished",
+      judge_status: "done",
+      failure_reason: null,
+      created_at: "2026-08-20T08:00:00Z",
+      updated_at: "2026-08-20T08:10:00Z",
+      finished_at: "2026-08-20T08:10:00Z",
+    }
+    const conversations = [
+      {
+        id: 81,
+        pk_round_id: 42,
+        title: "PK Judge · history",
+        created_at: "2026-08-20T08:03:00Z",
+      },
+      {
+        id: 80,
+        pk_round_id: 42,
+        title: "PK · history",
+        model: "qoder-model",
+        status: "cancelled",
+        created_at: "2026-08-20T08:02:00Z",
+      },
+      {
+        id: 79,
+        pk_round_id: 42,
+        title: "PK · history",
+        model: "claude-model",
+        status: "pending_review",
+        created_at: "2026-08-20T08:01:00Z",
+      },
+    ] as DbConversationSummary[]
+
+    const hydrated = dbRoundToStoreRound(dbRound, "/repo", conversations)
+
+    expect(hydrated.contestants.map((c) => c.conversationId)).toEqual([79, 80])
+    expect(hydrated.contestants.map((c) => c.selectedModel)).toEqual([
+      "claude-model",
+      "qoder-model",
+    ])
+    expect(hydrated.contestants.map((c) => c.status)).toEqual([
+      "done",
+      "canceled",
+    ])
+  })
+
+  it("supports same agent in multiple slots (control-variable PK)", async () => {
+    const round = await usePkArenaStore.getState().createRound({
+      task: "write a snake game",
+      folderId: 7,
+      workingDir: "/tmp/repo",
+      agents: [
+        {
+          agentType: "claude_code" as const,
+          label: "Sonnet",
+          configValues: { model: "sonnet" },
+        },
+        {
+          agentType: "claude_code" as const,
+          label: "Opus",
+          configValues: { model: "opus" },
+        },
+      ],
+    })
+    expect(round.contestants).toHaveLength(2)
+    expect(round.contestants.every((c) => c.agentType === "claude_code")).toBe(
+      true
+    )
+    expect(round.contestants.map((c) => c.slot)).toEqual([0, 1])
+    expect(round.contestants.map((c) => c.label)).toEqual(["Sonnet", "Opus"])
+    expect(round.contestants.map((c) => c.configValues.model)).toEqual([
+      "sonnet",
+      "opus",
+    ])
+    expect(vi.mocked(pkRoundCreate)).toHaveBeenCalledWith(
+      7,
+      "write a snake game",
+      expect.objectContaining({
+        agents: [
+          {
+            agent: "claude_code",
+            label: "Sonnet",
+            config_values: { model: "sonnet" },
+          },
+          {
+            agent: "claude_code",
+            label: "Opus",
+            config_values: { model: "opus" },
+          },
+        ],
+      })
+    )
+  })
+
+  it("supports labeled contestant entries in DB hydration", () => {
+    const dbRound: PkRoundInfo = {
+      id: 44,
+      folder_id: 7,
+      task: "control variable test",
+      config: {
+        agents: [
+          {
+            agent: "claude_code",
+            label: "Sonnet",
+            config_values: { model: "sonnet" },
+          },
+          {
+            agent: "claude_code",
+            label: "Opus",
+            config_values: { model: "opus" },
+          },
+        ],
+        permission_mode: "default",
+        bare_mode: false,
+        effort: "default",
+      },
+      status: "finished",
+      judge_status: "idle",
+      failure_reason: null,
+      created_at: "2026-01-01T00:00:00Z",
+      updated_at: "2026-01-01T01:00:00Z",
+      finished_at: "2026-01-01T01:00:00Z",
+    }
+    const revived = dbRoundToStoreRound(dbRound, "/tmp/repo")
+    expect(revived.contestants).toHaveLength(2)
+    expect(
+      revived.contestants.every((c) => c.agentType === "claude_code")
+    ).toBe(true)
+    expect(revived.contestants.map((c) => c.slot)).toEqual([0, 1])
+    expect(revived.contestants.map((c) => c.label)).toEqual(["Sonnet", "Opus"])
+    expect(revived.contestants.map((c) => c.configValues.model)).toEqual([
+      "sonnet",
+      "opus",
+    ])
+    expect(revived.contestants.map((c) => c.selectedModel)).toEqual([
+      "sonnet",
+      "opus",
+    ])
+  })
+})
diff --git a/src/stores/pk-arena-store.ts b/src/stores/pk-arena-store.ts
new file mode 100644
index 000000000..69d4a2a2b
--- /dev/null
+++ b/src/stores/pk-arena-store.ts
@@ -0,0 +1,627 @@
+"use client"
+
+import { create } from "zustand"
+import type {
+  AgentType,
+  DbConversationSummary,
+  PkRoundConfig,
+  PkRoundInfo,
+} from "@/lib/types"
+import {
+  pkRoundCreate,
+  pkRoundUpdateStatus,
+  pkRoundDelete,
+  pkRoundUpdateJudge,
+} from "@/lib/api"
+
+/**
+ * Agent PK arena — one task, N agents, isolated worktrees, a scoreboard.
+ *
+ * Pure data layer: no imports from React contexts so every reducer is
+ * unit-testable. The orchestrator (`hooks/use-pk-round`) drives the state
+ * machine; the view components only read it.
+ *
+ * Persistence: round metadata (task, agents, config, status) lives in the DB
+ * (`pk_round` table). Live-only fields (connectionId, diff, usage) stay in
+ * the Zustand store — they are meaningless across restarts. A round that was
+ * still running at shutdown is marked `interrupted` on hydration.
+ */
+
+export type PkContestantStatus =
+  | "preparing"
+  | "connecting"
+  | "ready"
+  | "running"
+  | "done"
+  | "error"
+  | "canceled"
+
+export interface PkContestantUsage {
+  inputTokens: number
+  outputTokens: number
+  turnCount: number
+  /** False when the upstream agent emitted assistant turns but did not report
+   * token accounting (Qoder currently returns zeroes for some models). */
+  tokensReported: boolean
+}
+
+/** Unified reasoning-effort request — "default" means each contestant uses its own default. */
+export type PkEffortLevel = "default" | "low" | "medium" | "high" | "max"
+
+export interface PkContestant {
+  /** Slot index — unique within a round. Same agent can occupy multiple
+   * slots (control-variable PK: e.g. slot 0 = Claude·Sonnet, slot 1 =
+   * Claude·Opus). The key for all lookups is (roundId, slot), NOT agentType. */
+  slot: number
+  /** Wire name — NOT unique within a round when the same agent is picked
+   * twice (control-variable PK). Use `slot` for identity. */
+  agentType: AgentType
+  /** Captured display name for the pinned model/config (e.g. "Sonnet"). */
+  label: string | null
+  /** Config values pinned in the launcher and applied before the first prompt. */
+  configValues: Record<string, string>
+  /** Advertised model options (handshake `configOptions`), for the arena pickers. */
+  modelOptions: Array<{ value: string; name: string }>
+  modelConfigId: string | null
+  /** Advertised effort option values, for the arena picker. */
+  effortOptions: string[]
+  effortConfigId: string | null
+  selectedModel: string | null
+  selectedEffort: string | null
+  /** Connections-context key; null until the orchestrator connects. */
+  contextKey: string | null
+  connectionId: string | null
+  conversationId: number | null
+  worktreePath: string | null
+  branchName: string | null
+  status: PkContestantStatus
+  statusDetail: string | null
+  startedAt: number | null
+  endedAt: number | null
+  durationMs: number | null
+  usage: PkContestantUsage | null
+  /** Populated lazily when the Diff tab opens; never persisted (can be huge). */
+  diff: string | null
+}
+
+export type PkRoundStatus =
+  | "ready"
+  | "running"
+  | "finished"
+  | "canceled"
+  | "interrupted"
+
+/** Judge verdict for one contestant. */
+export interface PkJudgeScore {
+  /** Unique contestant slot. Optional only for verdicts saved before slot
+   * identity was added; consumers deterministically backfill legacy rows. */
+  slot?: number
+  agentType: string
+  score: number
+  rank: number
+  comment: string
+}
+
+/** Structured verdict from the judge agent. */
+export interface PkJudgeResult {
+  scores: PkJudgeScore[]
+  summary: string
+  /** Raw LLM text (kept for debugging / export). */
+  rawText: string
+}
+
+export type PkJudgeStatus = "idle" | "running" | "done" | "error" | "skipped"
+
+export type PkPersistenceField = "status" | "judge"
+
+export type PkPersistenceErrors = Record<PkPersistenceField, string | null>
+
+/**
+ * Round-level permission policy, applied to every contestant right after
+ * connect via `setMode` — the ACP-standard mode ids (Claude Code, Codex and
+ * Qoder all advertise these exact spellings). Agents that don't advertise a
+ * matching mode keep their default and simply ask, as before.
+ */
+export type PkPermissionMode = "default" | "acceptEdits" | "bypassPermissions"
+
+export interface PkRound {
+  /** DB id of the pk_round row, as a string (used in branch names, context keys). */
+  id: string
+  task: string
+  folderId: number
+  workingDir: string
+  createdAt: number
+  status: PkRoundStatus
+  permissionMode: PkPermissionMode
+  /** Bare mode: contestants are instructed to use no skills at all. */
+  bareMode: boolean
+  /** Uniform reasoning-effort request, applied to every contestant. */
+  effort: PkEffortLevel
+  /** Optional judge agent type — reads all diffs and produces a verdict. */
+  judgeAgent: string | null
+  /** Custom judge evaluation dimensions (null = use defaults). Live copy of
+   *  PkRoundConfig.judge_dimensions. */
+  judgeDimensions: string[] | null
+  /** Git ref each contestant worktree branches from. null = current HEAD.
+   *  Set to `X^` when the round sources its task from commit X, so
+   *  contestants start before X — they never see X's changes. */
+  baseCommit: string | null
+  /** Structured judge verdict, persisted with the round for history/report export. */
+  judgeResult: PkJudgeResult | null
+  /** "idle" → "running" → "done" | "error" | "skipped". Persisted. */
+  judgeStatus: PkJudgeStatus
+  /** Latest persistence failure per independently saved round field. Live-only. */
+  persistenceErrors: PkPersistenceErrors
+  contestants: PkContestant[]
+}
+
+interface PkArenaState {
+  rounds: PkRound[]
+  activeRoundId: string | null
+  launcherOpen: boolean
+  /** The pill was manually dismissed — reset on new round / reopen. */
+  pillDismissed: boolean
+  /** True while the store is loading rounds from the DB on startup. */
+  hydrating: boolean
+}
+
+interface PkArenaActions {
+  createRound(config: {
+    task: string
+    folderId: number
+    workingDir: string
+    agents: Array<{
+      agentType: AgentType
+      label?: string
+      configValues?: Record<string, string>
+    }>
+    permissionMode?: PkPermissionMode
+    bareMode?: boolean
+    effort?: PkEffortLevel
+    judgeAgent?: string | null
+    judgeDimensions?: string[] | null
+    baseCommit?: string | null
+  }): Promise<PkRound>
+  hydrateFromDb(rounds: PkRound[]): void
+  updateContestant(
+    roundId: string,
+    slot: number,
+    patch: Partial<PkContestant>
+  ): void
+  markRound(roundId: string, status: PkRoundStatus): void
+  archiveRound(roundId: string): Promise<void>
+  retryPersistence(roundId: string): void
+  setActiveRound(roundId: string | null): void
+  setLauncherOpen(open: boolean): void
+  setPillDismissed(dismissed: boolean): void
+  updateJudge(
+    roundId: string,
+    patch: { judgeResult?: PkJudgeResult | null; judgeStatus?: PkJudgeStatus }
+  ): void
+}
+
+const LAUNCHER_LAST_KEY = "codeg:pk-launcher-last"
+
+const persistenceRevisions = new Map<string, number>()
+const persistenceQueues = new Map<string, Promise<void>>()
+
+function persistenceKey(roundId: string, field: PkPersistenceField): string {
+  return `${roundId}:${field}`
+}
+
+/**
+ * Serialize writes for one round field and surface only its latest result.
+ * Serialization prevents a slower old request from overwriting a newer DB
+ * value; the revision prevents its stale error from replacing newer UI state.
+ */
+function persistLatest(
+  roundId: string,
+  field: PkPersistenceField,
+  operation: () => Promise<void>
+): void {
+  const key = persistenceKey(roundId, field)
+  const revision = (persistenceRevisions.get(key) ?? 0) + 1
+  persistenceRevisions.set(key, revision)
+  const previous = persistenceQueues.get(key) ?? Promise.resolve()
+  const pending = previous.catch(() => undefined).then(operation)
+  persistenceQueues.set(key, pending)
+
+  void pending
+    .then(() => {
+      if (persistenceRevisions.get(key) !== revision) return
+      usePkArenaStore.setState((state) => ({
+        rounds: state.rounds.map((round) =>
+          round.id === roundId
+            ? {
+                ...round,
+                persistenceErrors: {
+                  ...(round.persistenceErrors ?? { status: null, judge: null }),
+                  [field]: null,
+                },
+              }
+            : round
+        ),
+      }))
+    })
+    .finally(() => {
+      if (persistenceQueues.get(key) === pending) {
+        persistenceQueues.delete(key)
+      }
+    })
+    .catch((error: unknown) => {
+      if (persistenceRevisions.get(key) !== revision) return
+      const message = error instanceof Error ? error.message : String(error)
+      console.error(
+        `[PkArena] failed to persist ${field} for round ${roundId}`,
+        error
+      )
+      usePkArenaStore.setState((state) => ({
+        rounds: state.rounds.map((round) =>
+          round.id === roundId
+            ? {
+                ...round,
+                persistenceErrors: {
+                  ...(round.persistenceErrors ?? { status: null, judge: null }),
+                  [field]: message,
+                },
+              }
+            : round
+        ),
+      }))
+    })
+}
+
+/** Last launcher config, for one-click prefill on rematch. */
+export interface PkLauncherLastConfig {
+  agents: Array<{
+    agentType: AgentType
+    label?: string
+    configValues?: Record<string, string>
+  }>
+  permissionMode: PkPermissionMode
+  bareMode: boolean
+  effort: PkEffortLevel
+  task: string
+  judgeAgent?: string | null
+  judgeDimensions?: string[] | null
+}
+
+export function loadLastLauncherConfig(): PkLauncherLastConfig | null {
+  if (typeof window === "undefined") return null
+  try {
+    const raw = window.localStorage.getItem(LAUNCHER_LAST_KEY)
+    if (!raw) return null
+    const parsed = JSON.parse(raw) as PkLauncherLastConfig
+    // Normalize legacy agents formats. Before the controlled-variable UI (#6),
+    // agents were stored as `string[]` (just agent types); normalize each entry
+    // to `{ agentType, label? }`. Guard against corrupt/missing agentType.
+    if (Array.isArray(parsed.agents)) {
+      parsed.agents = parsed.agents
+        .map((a) => (typeof a === "string" ? { agentType: a as AgentType } : a))
+        .filter(
+          (
+            a
+          ): a is {
+            agentType: AgentType
+            label?: string
+            configValues?: Record<string, string>
+          } => a != null && typeof a.agentType === "string"
+        )
+    }
+    return parsed
+  } catch {
+    return null
+  }
+}
+
+export function saveLastLauncherConfig(config: PkLauncherLastConfig): void {
+  if (typeof window === "undefined") return
+  try {
+    window.localStorage.setItem(LAUNCHER_LAST_KEY, JSON.stringify(config))
+  } catch {
+    // Failing to remember the config doesn't affect the round.
+  }
+}
+
+/** Branch names ride `codeg-pk/<round>/<slot>` — slug-safe and greppable.
+ * Uses slot index (not agentType) so the same agent in two slots gets two
+ * distinct branches. */
+export function contestantBranchName(roundId: string, slot: number): string {
+  return `codeg-pk/${roundId}/${slot}`
+}
+
+export function contestantContextKey(roundId: string, slot: number): string {
+  return `pk:${roundId}:${slot}`
+}
+
+/** Convert a DB PkRoundInfo row to a PkRound for the store, reviving
+ * interrupted rounds and seeding empty live contestant state. */
+export function dbRoundToStoreRound(
+  info: PkRoundInfo,
+  workingDir: string,
+  linkedConversations: readonly DbConversationSummary[] = []
+): PkRound {
+  const wasLive = info.status === "ready" || info.status === "running"
+  const status: PkRoundStatus = wasLive ? "interrupted" : info.status
+  const contestantConversations = linkedConversations
+    .filter(
+      (conversation) =>
+        conversation.pk_round_id === info.id &&
+        !conversation.title?.startsWith("PK Judge ·")
+    )
+    .sort(
+      (a, b) =>
+        new Date(a.created_at).getTime() - new Date(b.created_at).getTime() ||
+        a.id - b.id
+    )
+  return {
+    id: String(info.id),
+    task: info.task,
+    folderId: info.folder_id,
+    workingDir,
+    createdAt: new Date(info.created_at).getTime(),
+    status,
+    permissionMode:
+      (info.config.permission_mode as PkPermissionMode) ?? "default",
+    bareMode: info.config.bare_mode ?? false,
+    effort: (info.config.effort as PkEffortLevel) ?? "default",
+    judgeAgent: info.config.judge_agent ?? null,
+    judgeDimensions: info.config.judge_dimensions?.length
+      ? info.config.judge_dimensions
+      : null,
+    baseCommit: info.config.base_commit ?? null,
+    judgeResult:
+      info.judge_result != null
+        ? {
+            scores: (info.judge_result.scores ?? []).map((s) => ({
+              slot: s.slot,
+              agentType: s.agentType,
+              score: s.score,
+              rank: s.rank,
+              comment: s.comment,
+            })),
+            summary: info.judge_result.summary ?? "",
+            rawText: info.judge_result.rawText ?? "",
+          }
+        : null,
+    judgeStatus: (info.judge_status as PkJudgeStatus) ?? "idle",
+    persistenceErrors: { status: null, judge: null },
+    contestants: info.config.agents.map((entry, slot) => {
+      const linked = contestantConversations[slot]
+      const agentType = typeof entry === "string" ? entry : entry.agent
+      const label = typeof entry === "string" ? null : (entry.label ?? null)
+      const configValues =
+        typeof entry === "string" ? {} : (entry.config_values ?? {})
+      const persistedStatus = linked?.status
+      const contestantStatus: PkContestantStatus = wasLive
+        ? "canceled"
+        : persistedStatus === "cancelled" || persistedStatus === "in_progress"
+          ? "canceled"
+          : "done"
+      return {
+        slot,
+        agentType: agentType as AgentType,
+        label,
+        configValues,
+        modelOptions: [],
+        modelConfigId: null,
+        effortOptions: [],
+        effortConfigId: null,
+        selectedModel: linked?.model ?? configValues.model ?? null,
+        selectedEffort: null,
+        contextKey: null,
+        connectionId: null,
+        conversationId: linked?.id ?? null,
+        worktreePath: null,
+        branchName: null,
+        status: contestantStatus,
+        statusDetail:
+          wasLive || persistedStatus === "in_progress"
+            ? "interrupted"
+            : persistedStatus === "cancelled"
+              ? "conversation cancelled"
+              : null,
+        startedAt: null,
+        endedAt: null,
+        durationMs: null,
+        usage: null,
+        diff: null,
+      }
+    }),
+  }
+}
+
+export const usePkArenaStore = create<PkArenaState & PkArenaActions>((set) => ({
+  rounds: [],
+  activeRoundId: null,
+  launcherOpen: false,
+  pillDismissed: false,
+  hydrating: true,
+
+  hydrateFromDb: (dbRounds) => {
+    set((state) => {
+      const activeRoundStillExists = dbRounds.some(
+        (round) => round.id === state.activeRoundId
+      )
+      return {
+        rounds: dbRounds,
+        hydrating: false,
+        activeRoundId: activeRoundStillExists ? state.activeRoundId : null,
+      }
+    })
+  },
+
+  createRound: async ({
+    task,
+    folderId,
+    workingDir,
+    agents,
+    permissionMode,
+    bareMode,
+    effort,
+    judgeAgent,
+    judgeDimensions,
+    baseCommit,
+  }) => {
+    const config: PkRoundConfig = {
+      agents: agents.map((a) => {
+        const configValues = a.configValues ?? {}
+        if (!a.label && Object.keys(configValues).length === 0) {
+          return a.agentType
+        }
+        return {
+          agent: a.agentType,
+          ...(a.label ? { label: a.label } : {}),
+          ...(Object.keys(configValues).length > 0
+            ? { config_values: configValues }
+            : {}),
+        }
+      }),
+      permission_mode: permissionMode ?? "default",
+      bare_mode: bareMode ?? false,
+      effort: effort ?? "default",
+      judge_agent: judgeAgent ?? undefined,
+      judge_dimensions: judgeDimensions?.filter((d) => d.trim()) ?? [],
+      base_commit: baseCommit ?? undefined,
+    }
+    const info = await pkRoundCreate(folderId, task, config)
+    const round: PkRound = {
+      id: String(info.id),
+      task,
+      folderId,
+      workingDir,
+      createdAt: new Date(info.created_at).getTime(),
+      status: "ready",
+      permissionMode: permissionMode ?? "default",
+      bareMode: bareMode ?? false,
+      effort: effort ?? "default",
+      judgeAgent: judgeAgent ?? null,
+      judgeDimensions: judgeDimensions?.filter((d) => d.trim()) ?? null,
+      baseCommit: baseCommit ?? null,
+      judgeResult: null,
+      judgeStatus: "idle",
+      persistenceErrors: { status: null, judge: null },
+      contestants: agents.map((a, slot) => ({
+        slot,
+        agentType: a.agentType,
+        label: a.label ?? null,
+        configValues: a.configValues ?? {},
+        modelOptions: [],
+        modelConfigId: null,
+        effortOptions: [],
+        effortConfigId: null,
+        selectedModel: null,
+        selectedEffort: null,
+        contextKey: null,
+        connectionId: null,
+        conversationId: null,
+        worktreePath: null,
+        branchName: null,
+        status: "preparing",
+        statusDetail: null,
+        startedAt: null,
+        endedAt: null,
+        durationMs: null,
+        usage: null,
+        diff: null,
+      })),
+    }
+    set((state) => ({
+      rounds: [round, ...state.rounds],
+      activeRoundId: round.id,
+    }))
+    return round
+  },
+
+  updateContestant: (roundId, slot, patch) => {
+    set((state) => ({
+      rounds: state.rounds.map((round) =>
+        round.id !== roundId
+          ? round
+          : {
+              ...round,
+              contestants: round.contestants.map((c) =>
+                c.slot !== slot ? c : { ...c, ...patch }
+              ),
+            }
+      ),
+    }))
+  },
+
+  markRound: (roundId, status) => {
+    set((state) => ({
+      rounds: state.rounds.map((round) =>
+        round.id === roundId ? { ...round, status } : round
+      ),
+    }))
+    persistLatest(roundId, "status", () =>
+      pkRoundUpdateStatus(Number(roundId), status)
+    )
+  },
+
+  archiveRound: async (roundId) => {
+    await pkRoundDelete(Number(roundId))
+    persistenceRevisions.delete(persistenceKey(roundId, "status"))
+    persistenceRevisions.delete(persistenceKey(roundId, "judge"))
+    persistenceQueues.delete(persistenceKey(roundId, "status"))
+    persistenceQueues.delete(persistenceKey(roundId, "judge"))
+    set((state) => ({
+      rounds: state.rounds.filter((round) => round.id !== roundId),
+      activeRoundId:
+        state.activeRoundId === roundId ? null : state.activeRoundId,
+    }))
+  },
+
+  retryPersistence: (roundId) => {
+    const round = usePkArenaStore
+      .getState()
+      .rounds.find((candidate) => candidate.id === roundId)
+    if (!round) return
+    if (round.persistenceErrors?.status) {
+      persistLatest(roundId, "status", () =>
+        pkRoundUpdateStatus(Number(roundId), round.status)
+      )
+    }
+    if (round.persistenceErrors?.judge) {
+      persistLatest(roundId, "judge", () =>
+        pkRoundUpdateJudge(
+          Number(roundId),
+          round.judgeResult,
+          round.judgeStatus
+        )
+      )
+    }
+  },
+
+  setActiveRound: (roundId) => set({ activeRoundId: roundId }),
+  setLauncherOpen: (open) => set({ launcherOpen: open }),
+  setPillDismissed: (dismissed) => set({ pillDismissed: dismissed }),
+
+  updateJudge: (roundId, patch) => {
+    set((state) => ({
+      rounds: state.rounds.map((round) =>
+        round.id !== roundId
+          ? round
+          : {
+              ...round,
+              judgeResult: patch.judgeResult ?? round.judgeResult,
+              judgeStatus: patch.judgeStatus ?? round.judgeStatus,
+            }
+      ),
+    }))
+    // Persist judge verdict + status to DB so it survives refresh/restart.
+    const round = usePkArenaStore
+      .getState()
+      .rounds.find((r) => r.id === roundId)
+    if (round) {
+      const merged = patch.judgeResult ?? round.judgeResult ?? null
+      persistLatest(roundId, "judge", () =>
+        pkRoundUpdateJudge(
+          Number(roundId),
+          merged,
+          patch.judgeStatus ?? round.judgeStatus
+        )
+      )
+    }
+  },
+}))
diff --git a/src/stores/tab-store.ts b/src/stores/tab-store.ts
index 0966227af..afd56a01e 100644
--- a/src/stores/tab-store.ts
+++ b/src/stores/tab-store.ts
@@ -44,6 +44,13 @@ import type {
   OpenedTab,
   TabsChanged,
 } from "@/lib/types"
+import {
+  isConversationDraft,
+  isConversationWorkspaceTab,
+  type ConversationWorkspaceTab,
+  type PkWorkspaceTab,
+  type WorkspaceTab,
+} from "@/lib/workspace-tab"
 
 /**
  * Workspace tab state as a Zustand store. Replaces the former single
@@ -63,47 +70,12 @@ import type {
  * (platform subscriptions, timers, gates).
  */
 
-export interface TabItemInternal {
-  id: string
-  kind: "conversation"
-  folderId: number
-  conversationId: number | null
-  /** The runtime session key used by ConversationRuntimeContext.
-   *  For new conversations this is a virtual (negative) ID that differs
-   *  from the persisted `conversationId`. */
-  runtimeConversationId?: number
-  agentType: AgentType
-  title: string
-  isPinned: boolean
-  workingDir?: string
-  status?: ConversationStatus
-  /**
-   * Marks `agentType` as a system best-guess that should be replaced once
-   * the agent list becomes fresh. True for draft tabs whose default came
-   * from a stale localStorage seed or the AGENT_DISPLAY_ORDER fallback;
-   * cleared by `confirmDraftAgent` (user click), `bindConversationTab`
-   * (draft → real conversation), or the correction effect (fresh agent
-   * list arrives). **Not persisted** to opened_tabs — hydrated drafts
-   * default to false and are re-evaluated only when their agent_type is
-   * no longer in the fresh sorted list (the `!sortedAvailableAgents.
-   * includes(...)` branch of correction). Internal-only: no UI component
-   * reads it, so a stale `true` value is harmless if correction never
-   * runs (e.g. `acpListAgents()` keeps failing).
-   */
-  agentTypeProvisional?: boolean
-  /**
-   * Marks a draft tab as "chat mode" (folderless). Set by `openChatModeTab`,
-   * cleared implicitly once the draft binds to a real conversation (whose hidden
-   * hidden chat folder then drives chat-mode chrome via `useIsActiveChatMode`).
-   * **Internal-only and never persisted** — drafts (`conversationId == null`) are
-   * not written to opened_tabs, so this flag only ever lives in memory for the
-   * pre-send draft. While set, the draft has no resolvable folder, so the
-   * composer hides the branch picker and shows the "no-folder" chip.
-   */
-  isChat?: boolean
-}
-
-export type TabItem = TabItemInternal
+export type TabItemInternal = WorkspaceTab
+/** Legacy public conversation-tab shape. New workspace surfaces should use
+ * `WorkspaceTabItem` or the store selectors directly. */
+export type TabItem = ConversationWorkspaceTab
+export type WorkspaceTabItem = WorkspaceTab
+export type { ConversationWorkspaceTab, PkWorkspaceTab }
 
 interface DraftRetargetRequest {
   tabId: string
@@ -198,6 +170,13 @@ export interface TabStoreState {
     pin?: boolean,
     title?: string
   ) => void
+  openPkRoundTab: (
+    roundId: string,
+    folderId: number,
+    title: string,
+    options?: { targetGroup?: string }
+  ) => void
+  closePkRoundTab: (roundId: string) => void
   closeTab: (tabId: string) => void
   closeConversationTab: (
     folderId: number,
@@ -229,7 +208,7 @@ export interface TabStoreState {
   toggleGroupOrientation: (groupId: string) => void
   dissolveGroup: (groupId: string) => void
   unsplitAll: () => void
-  reorderGroupTabs: (groupId: string, orderedTabs: TabItem[]) => void
+  reorderGroupTabs: (groupId: string, orderedTabs: WorkspaceTab[]) => void
   resizeGroupSplit: (
     splitId: string,
     handleIndex: number,
@@ -270,7 +249,7 @@ export interface TabStoreState {
     tabId: string,
     runtimeConversationId: number
   ) => void
-  reorderTabs: (reorderedTabs: TabItem[]) => void
+  reorderTabs: (reorderedTabs: WorkspaceTab[]) => void
   consumeRemoteActivation: () => boolean
   onPreviewTabReplaced: (callback: (tabId: string) => void) => () => void
 
@@ -372,7 +351,8 @@ let groupPersistTimer: ReturnType<typeof setTimeout> | null = null
 // `hydrate` (kept out of store state: they are an input to hydration, not
 // renderable state). Refreshed whenever `initialTabState()` runs.
 let pendingRestoreDrafts: PersistedDraft[] = []
-let pendingRestoreActiveDraft: string | null = null
+let pendingRestorePkTabs: PersistedPkTab[] = []
+let pendingRestoreActiveLocalTab: string | null = null
 let orphanDraftPruneRan = false
 // True once a tab snapshot has actually been read from the backend (hydration,
 // a refetch, or a remote change). Until then the open-tab set is UNKNOWN — a
@@ -413,7 +393,9 @@ function makeNewConversationTabId(): string {
  *  fields rather than read off `tab.id`. Drafts have no sync identity (they are
  *  device-local and never persisted) → `null`. */
 function tabSyncKey(tab: TabItemInternal): string | null {
-  if (tab.conversationId == null) return null
+  if (!isConversationWorkspaceTab(tab) || tab.conversationId == null) {
+    return null
+  }
   return makeConversationTabId(tab.folderId, tab.agentType, tab.conversationId)
 }
 
@@ -439,6 +421,7 @@ function findTabIndexForConversation(
   if (idx >= 0) return idx
   return tabs.findIndex(
     (t) =>
+      isConversationWorkspaceTab(t) &&
       t.folderId === folderId &&
       t.conversationId === conversationId &&
       t.agentType === agentType
@@ -451,15 +434,21 @@ function findTabIndexForConversation(
  *  can short-circuit. TabItemInternal is a closed shape — keep this list in sync
  *  when adding fields. */
 function sameDerivedTab(a: TabItemInternal, b: TabItemInternal): boolean {
+  if (
+    a.id !== b.id ||
+    a.kind !== b.kind ||
+    a.folderId !== b.folderId ||
+    a.title !== b.title ||
+    a.isPinned !== b.isPinned
+  ) {
+    return false
+  }
+  if (a.kind === "pk" && b.kind === "pk") return a.roundId === b.roundId
+  if (a.kind !== "conversation" || b.kind !== "conversation") return false
   return (
-    a.id === b.id &&
-    a.kind === b.kind &&
-    a.folderId === b.folderId &&
     a.conversationId === b.conversationId &&
     a.runtimeConversationId === b.runtimeConversationId &&
     a.agentType === b.agentType &&
-    a.title === b.title &&
-    a.isPinned === b.isPinned &&
     a.workingDir === b.workingDir &&
     a.status === b.status &&
     a.agentTypeProvisional === b.agentTypeProvisional &&
@@ -476,7 +465,10 @@ function buildPersistItems(
   activeTabId: string | null
 ): OpenedTab[] {
   return tabs
-    .filter((tab) => tab.conversationId != null)
+    .filter(
+      (tab): tab is ConversationWorkspaceTab & { conversationId: number } =>
+        isConversationWorkspaceTab(tab) && tab.conversationId != null
+    )
     .map((tab, i) => ({
       id: 0,
       folder_id: tab.folderId,
@@ -584,6 +576,15 @@ interface PersistedDraft {
   agentType?: AgentType
 }
 
+interface PersistedPkTab {
+  id: string
+  group: string
+  index: number
+  folderId: number
+  roundId: string
+  title: string
+}
+
 function sanitizeDrafts(value: unknown): PersistedDraft[] {
   if (!Array.isArray(value)) return []
   const out: PersistedDraft[] = []
@@ -614,6 +615,33 @@ function sanitizeDrafts(value: unknown): PersistedDraft[] {
   return out
 }
 
+function sanitizePkTabs(value: unknown): PersistedPkTab[] {
+  if (!Array.isArray(value)) return []
+  const out: PersistedPkTab[] = []
+  for (const entry of value) {
+    if (typeof entry !== "object" || entry === null) continue
+    const e = entry as Record<string, unknown>
+    if (typeof e.id !== "string" || e.id.length === 0) continue
+    if (typeof e.group !== "string" || e.group.length === 0) continue
+    if (typeof e.roundId !== "string" || e.roundId.length === 0) continue
+    if (typeof e.title !== "string" || e.title.length === 0) continue
+    if (typeof e.folderId !== "number" || !Number.isFinite(e.folderId)) continue
+    const index =
+      typeof e.index === "number" && Number.isFinite(e.index) && e.index >= 0
+        ? Math.floor(e.index)
+        : out.length
+    out.push({
+      id: e.id,
+      group: e.group,
+      index,
+      folderId: e.folderId,
+      roundId: e.roundId,
+      title: e.title,
+    })
+  }
+  return out
+}
+
 /** Seed group state from the device-local blob (canonical tab ids — they match
  *  nothing until `hydrate` restores canonical-id tabs; `applyGroupInvariants`
  *  defers pruning until then). Falls back to a single group, seeding its tile
@@ -626,7 +654,8 @@ function readPersistedGroupState(): {
   tileByGroup: Record<string, boolean>
 } {
   pendingRestoreDrafts = []
-  pendingRestoreActiveDraft = null
+  pendingRestorePkTabs = []
+  pendingRestoreActiveLocalTab = null
   const fallback = () => ({
     groupLayout: singleGroupLayout() as LayoutNode,
     groupOf: {} as Record<string, string>,
@@ -641,8 +670,13 @@ function readPersistedGroupState(): {
       if (parsed && isLayoutNode(parsed.layout)) {
         // Older blobs predate `drafts`/`activeDraft` — both sanitize to empty.
         pendingRestoreDrafts = sanitizeDrafts(parsed.drafts)
-        pendingRestoreActiveDraft =
-          typeof parsed.activeDraft === "string" ? parsed.activeDraft : null
+        pendingRestorePkTabs = sanitizePkTabs(parsed.pkTabs)
+        pendingRestoreActiveLocalTab =
+          typeof parsed.activeLocalTab === "string"
+            ? parsed.activeLocalTab
+            : typeof parsed.activeDraft === "string"
+              ? parsed.activeDraft
+              : null
         return {
           groupLayout: parsed.layout,
           groupOf: sanitizeStringRecord(parsed.assignments),
@@ -675,8 +709,20 @@ function persistGroupState() {
   if (!st.tabsHydrated || !tabsSnapshotLoaded) return
   const assignments: Record<string, string> = {}
   const drafts: PersistedDraft[] = []
+  const pkTabs: PersistedPkTab[] = []
   st.rawTabs.forEach((tab, index) => {
     const group = groupOfTab(st.groupOf, st.groupLayout, tab.id)
+    if (tab.kind === "pk") {
+      pkTabs.push({
+        id: tab.id,
+        group,
+        index,
+        folderId: tab.folderId,
+        roundId: tab.roundId,
+        title: tab.title,
+      })
+      return
+    }
     if (tab.conversationId != null) {
       assignments[
         makeConversationTabId(tab.folderId, tab.agentType, tab.conversationId)
@@ -702,7 +748,7 @@ function persistGroupState() {
     const tab = st.rawTabs.find((t) => t.id === tabId)
     if (!tab) continue
     selection[groupId] =
-      tab.conversationId != null
+      tab.kind === "conversation" && tab.conversationId != null
         ? makeConversationTabId(tab.folderId, tab.agentType, tab.conversationId)
         : tab.id
   }
@@ -713,10 +759,16 @@ function persistGroupState() {
     selection,
     tileByGroup: st.tileByGroup,
     drafts,
-    // Only a DRAFT focus needs restoring here; conversation focus rides the
-    // synced `opened_tabs.is_active`.
+    pkTabs,
+    // Device-local documents restore focus here; conversation focus rides the
+    // synced `opened_tabs.is_active` flag.
+    activeLocalTab:
+      activeTab && (activeTab.kind === "pk" || activeTab.conversationId == null)
+        ? activeTab.id
+        : null,
+    // Older builds only know `activeDraft`; keep it during the transition.
     activeDraft:
-      activeTab && activeTab.conversationId == null ? activeTab.id : null,
+      activeTab && isConversationDraft(activeTab) ? activeTab.id : null,
   })
   if (blob === lastGroupBlob) return
   lastGroupBlob = blob
@@ -737,13 +789,17 @@ function persistGroupState() {
  * explicit (non-provisional) choice; the title comes from the current locale's
  * label rather than the stale persisted one.
  */
-function mergeRestoredDrafts(restored: TabItemInternal[]): {
+function mergeRestoredLocalTabs(restored: TabItemInternal[]): {
   tabs: TabItemInternal[]
   groupOf: Record<string, string>
 } {
   const pending = pendingRestoreDrafts
+  const pendingPk = pendingRestorePkTabs
   pendingRestoreDrafts = []
-  if (pending.length === 0) return { tabs: restored, groupOf: {} }
+  pendingRestorePkTabs = []
+  if (pending.length === 0 && pendingPk.length === 0) {
+    return { tabs: restored, groupOf: {} }
+  }
 
   const tabs = [...restored]
   const groupOf: Record<string, string> = {}
@@ -769,6 +825,20 @@ function mergeRestoredDrafts(restored: TabItemInternal[]): {
     tabs.splice(Math.min(draft.index, tabs.length), 0, tab)
     groupOf[draft.id] = draft.group
   }
+  for (const persisted of [...pendingPk].sort((a, b) => a.index - b.index)) {
+    if (seen.has(persisted.id)) continue
+    seen.add(persisted.id)
+    const tab: PkWorkspaceTab = {
+      id: persisted.id,
+      kind: "pk",
+      folderId: persisted.folderId,
+      roundId: persisted.roundId,
+      title: persisted.title,
+      isPinned: true,
+    }
+    tabs.splice(Math.min(persisted.index, tabs.length), 0, tab)
+    groupOf[persisted.id] = persisted.group
+  }
   return { tabs, groupOf }
 }
 
@@ -935,7 +1005,7 @@ function recomputeTabs() {
     }
     const prevById = prev.length ? new Map(prev.map((d) => [d.id, d])) : null
     next = rawTabs.map((tab) => {
-      if (tab.conversationId != null) {
+      if (isConversationWorkspaceTab(tab) && tab.conversationId != null) {
         const conv =
           conversationMap.get(
             `${tab.folderId}-${tab.agentType}-${tab.conversationId}`
@@ -1002,7 +1072,9 @@ function makeReplacementDraftTab(preferred?: TabItemInternal): TabItemInternal {
   // and `folders` excludes chat folders after refetch), while the fallback pool
   // reads the user-facing `folders`.
   const preferredIsChat =
-    preferred?.isChat === true ||
+    (preferred != null &&
+      isConversationWorkspaceTab(preferred) &&
+      preferred.isChat === true) ||
     allFolders.find((f) => f.id === preferred?.folderId)?.kind === "chat"
   const nonChatFallbackId = folders.find((f) => f.kind !== "chat")?.id ?? 0
   const folderId = preferredIsChat
@@ -1010,18 +1082,21 @@ function makeReplacementDraftTab(preferred?: TabItemInternal): TabItemInternal {
     : (preferred?.folderId ?? nonChatFallbackId)
   const workingDir = preferredIsChat
     ? (folders.find((f) => f.id === folderId)?.path ?? "")
-    : (preferred?.workingDir ??
+    : ((preferred != null && isConversationWorkspaceTab(preferred)
+        ? preferred.workingDir
+        : undefined) ??
       folders.find((f) => f.id === folderId)?.path ??
       "")
   // If we have a preferred (closing) tab, inherit BOTH its agent and its
   // provisional flag — never silently launder a system best-guess into a
   // confirmed value just because the source tab was closed.
-  const { agentType, provisional } = preferred?.agentType
-    ? {
-        agentType: preferred.agentType,
-        provisional: preferred.agentTypeProvisional ?? false,
-      }
-    : resolveAgentForFolder(folderId, null)
+  const { agentType, provisional } =
+    preferred != null && isConversationWorkspaceTab(preferred)
+      ? {
+          agentType: preferred.agentType,
+          provisional: preferred.agentTypeProvisional ?? false,
+        }
+      : resolveAgentForFolder(folderId, null)
   return {
     id: makeNewConversationTabId(),
     kind: "conversation",
@@ -1154,6 +1229,50 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
     runtime.activateConversationPane()
   },
 
+  openPkRoundTab: (roundId, folderId, title, options) => {
+    const st = get()
+    const tabId = `pk-round-${roundId}`
+    const existing = st.rawTabs.find(
+      (tab) => tab.kind === "pk" && tab.roundId === roundId
+    )
+    if (existing) {
+      if (existing.title !== title || existing.folderId !== folderId) {
+        set({
+          rawTabs: st.rawTabs.map((tab) =>
+            tab.id === existing.id ? { ...tab, title, folderId } : tab
+          ),
+        })
+        recomputeTabs()
+      }
+      focusTab(existing.id)
+      runtime.activateConversationPane()
+      return
+    }
+    const targetGroup = resolveTargetGroup(st, options?.targetGroup)
+    const newTab: PkWorkspaceTab = {
+      id: tabId,
+      kind: "pk",
+      roundId,
+      folderId,
+      title,
+      isPinned: true,
+    }
+    set({
+      rawTabs: [...st.rawTabs, newTab],
+      activeTabId: tabId,
+      groupOf: { ...st.groupOf, [tabId]: targetGroup },
+    })
+    recomputeTabs()
+    runtime.activateConversationPane()
+  },
+
+  closePkRoundTab: (roundId) => {
+    const tab = get().rawTabs.find(
+      (item) => item.kind === "pk" && item.roundId === roundId
+    )
+    if (tab) get().closeTab(tab.id)
+  },
+
   closeTab: (tabId) => {
     const shouldActivateConversation = tabId === get().activeTabId
 
@@ -1165,10 +1284,9 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
       // A closing draft's composer text is scoped to that tab's key. Drop it —
       // unless this close spawns the replacement draft, which continues the same
       // slot and inherits the text instead of losing it silently.
-      const closingDraftKey =
-        closingTab.conversationId == null
-          ? buildNewConversationDraftStorageKey(closingTab.id)
-          : null
+      const closingDraftKey = isConversationDraft(closingTab)
+        ? buildNewConversationDraftStorageKey(closingTab.id)
+        : null
       // An "ask about this selection" prompt parked for this tab has no panel
       // left to drain it. Drop it rather than leave it in the module buffer for
       // the rest of the session — the tab id is never reused, so it could only
@@ -1235,6 +1353,7 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
   closeConversationTab: (folderId, conversationId, agentType) => {
     const target = get().rawTabs.find(
       (tab) =>
+        isConversationWorkspaceTab(tab) &&
         tab.folderId === folderId &&
         tab.conversationId === conversationId &&
         tab.agentType === agentType
@@ -1281,7 +1400,9 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
 
     const prevState = get()
     const seedTab =
-      prevState.rawTabs.find((t) => t.conversationId == null && t.workingDir) ??
+      prevState.rawTabs.find(
+        (t) => isConversationDraft(t) && Boolean(t.workingDir)
+      ) ??
       prevState.rawTabs.find((t) => t.id === prevState.activeTabId) ??
       prevState.rawTabs[0]
     const replacementTab = makeReplacementDraftTab(seedTab)
@@ -1341,7 +1462,7 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
     if (opts.move) {
       // A draft belongs to the group that spawned it (see `moveTabToGroup`);
       // plain split still seeds the new group with its own draft.
-      if (tab.conversationId == null) return
+      if (isConversationDraft(tab)) return
       // Moving the group's only tab would just shift the group — pointless.
       const groupSize = st.rawTabs.filter(
         (t) => groupOfTab(st.groupOf, st.groupLayout, t.id) === sourceGroup
@@ -1375,13 +1496,16 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
       newGroupId
     )
     if (nextLayout === st.groupLayout) return
+    const conversationTab = isConversationWorkspaceTab(tab) ? tab : null
     const inherit =
-      tab.conversationId != null || !tab.agentTypeProvisional
-        ? tab.agentType
+      conversationTab &&
+      (conversationTab.conversationId != null ||
+        !conversationTab.agentTypeProvisional)
+        ? conversationTab.agentType
         : null
     const { allFolders, folders } = useAppWorkspaceStore.getState()
     const contextIsChat =
-      tab.isChat === true ||
+      conversationTab?.isChat === true ||
       allFolders.find((f) => f.id === tab.folderId)?.kind === "chat"
     let newTab: TabItemInternal
     if (contextIsChat) {
@@ -1412,7 +1536,8 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
         title: runtime.labels.newConversation,
         isPinned: true,
         workingDir:
-          tab.workingDir ?? folders.find((f) => f.id === tab.folderId)?.path,
+          conversationTab?.workingDir ??
+          folders.find((f) => f.id === tab.folderId)?.path,
         agentTypeProvisional: provisional,
       }
     }
@@ -1438,7 +1563,7 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
     // without its slot and hand another a second. Reordering WITHIN the group is
     // unaffected (that path never reaches here). The UI hides both move
     // affordances for drafts; this backstops the programmatic path.
-    if (moving.conversationId == null) return
+    if (isConversationDraft(moving)) return
 
     if (opts?.index == null) {
       // Menu move: only the assignment changes — the tab keeps its global
@@ -1614,6 +1739,7 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
       const activeTab = st.rawTabs.find((t) => t.id === st.activeTabId)
       if (
         activeTab &&
+        isConversationWorkspaceTab(activeTab) &&
         (activeTab.conversationId != null || !activeTab.agentTypeProvisional)
       ) {
         inherit = activeTab.agentType
@@ -1634,8 +1760,8 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
     // (regardless of folder), so each group carries at most one draft.
     const targetGroup = resolveTargetGroup(prevState, options?.targetGroup)
     const existingTab = prevState.rawTabs.find(
-      (t) =>
-        t.conversationId == null &&
+      (t): t is ConversationWorkspaceTab & { conversationId: null } =>
+        isConversationDraft(t) &&
         groupOfTab(prevState.groupOf, prevState.groupLayout, t.id) ===
           targetGroup
     )
@@ -1708,6 +1834,7 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
     const activeTab = st.rawTabs.find((x) => x.id === st.activeTabId)
     const inherit =
       activeTab &&
+      isConversationWorkspaceTab(activeTab) &&
       (activeTab.conversationId != null || !activeTab.agentTypeProvisional)
         ? activeTab.agentType
         : null
@@ -1725,7 +1852,8 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
     const inTargetGroup = (t: TabItemInternal) =>
       groupOfTab(st.groupOf, st.groupLayout, t.id) === targetGroup
     const existingDraft = st.rawTabs.find(
-      (t) => t.conversationId == null && inTargetGroup(t)
+      (t): t is ConversationWorkspaceTab & { conversationId: null } =>
+        isConversationDraft(t) && inTargetGroup(t)
     )
     const needsDisconnect =
       existingDraft != null &&
@@ -1734,7 +1862,8 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
     const tabId = makeNewConversationTabId()
     const prevState = get()
     const existingTab = prevState.rawTabs.find(
-      (t) => t.conversationId == null && inTargetGroup(t)
+      (t): t is ConversationWorkspaceTab & { conversationId: null } =>
+        isConversationDraft(t) && inTargetGroup(t)
     )
 
     if (!existingTab) {
@@ -1837,6 +1966,7 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
       // already bound, retargeted, or left chat mode. Only patch a still-unbound
       // chat draft, and skip a redundant write to keep the reference stable.
       if (
+        !isConversationDraft(tab) ||
         tab.conversationId != null ||
         tab.isChat !== true ||
         tab.workingDir === workingDir
@@ -1854,7 +1984,7 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
     const prev = get().rawTabs
     const next = prev.map((t) => {
       if (t.id !== tabId) return t
-      if (t.conversationId != null) return t // not a draft
+      if (!isConversationDraft(t)) return t
       if (t.agentType === agentType && !t.agentTypeProvisional) return t
       return { ...t, agentType, agentTypeProvisional: false }
     })
@@ -1867,7 +1997,7 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
     const prev = get().rawTabs
     const next = prev.map((t) => {
       if (t.id !== tabId) return t
-      if (t.conversationId != null) return t // not a draft
+      if (!isConversationDraft(t)) return t
       if (t.agentType === agentType && t.agentTypeProvisional) return t
       return { ...t, agentType, agentTypeProvisional: true }
     })
@@ -1888,7 +2018,8 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
     const prevState = get()
     const nextTabs = prevState.rawTabs.flatMap((tab) => {
       if (tab.id === tabId) {
-        const nextTab: TabItemInternal = {
+        if (!isConversationWorkspaceTab(tab)) return [tab]
+        const nextTab: ConversationWorkspaceTab = {
           ...tab,
           conversationId,
           agentType,
@@ -1903,6 +2034,7 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
       // Drop any other tab that already represents the same (conversationId,
       // agentType) — conversation IDs are globally unique.
       if (
+        isConversationWorkspaceTab(tab) &&
         tab.conversationId === conversationId &&
         tab.agentType === agentType
       ) {
@@ -1928,12 +2060,18 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
   setTabRuntimeConversationId: (tabId, runtimeConversationId) => {
     const prev = get().rawTabs
     const target = prev.find((tab) => tab.id === tabId)
-    if (!target || target.runtimeConversationId === runtimeConversationId) {
+    if (
+      !target ||
+      !isConversationWorkspaceTab(target) ||
+      target.runtimeConversationId === runtimeConversationId
+    ) {
       return
     }
     set({
       rawTabs: prev.map((tab) =>
-        tab.id === tabId ? { ...tab, runtimeConversationId } : tab
+        tab.id === tabId && isConversationWorkspaceTab(tab)
+          ? { ...tab, runtimeConversationId }
+          : tab
       ),
     })
     recomputeTabs()
@@ -1996,12 +2134,12 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
         // tabs, so the first invariant pass sees complete groups and can't
         // collapse a draft-only one).
         const { tabs: withDrafts, groupOf: draftGroups } =
-          mergeRestoredDrafts(restored)
+          mergeRestoredLocalTabs(restored)
         if (
-          pendingRestoreActiveDraft != null &&
-          withDrafts.some((tab) => tab.id === pendingRestoreActiveDraft)
+          pendingRestoreActiveLocalTab != null &&
+          withDrafts.some((tab) => tab.id === pendingRestoreActiveLocalTab)
         ) {
-          restoredActive = pendingRestoreActiveDraft
+          restoredActive = pendingRestoreActiveLocalTab
         }
         if (!restoredActive && withDrafts.length > 0) {
           restoredActive = withDrafts[0].id
@@ -2031,12 +2169,12 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
           // `tabsSnapshotLoaded` until a snapshot actually lands (the refetch
           // that follows the subscription usually rescues it seconds later).
           const { tabs: draftsOnly, groupOf: draftGroups } =
-            mergeRestoredDrafts(get().rawTabs)
+            mergeRestoredLocalTabs(get().rawTabs)
           if (draftsOnly.length > 0) {
             const focus =
-              pendingRestoreActiveDraft != null &&
-              draftsOnly.some((tab) => tab.id === pendingRestoreActiveDraft)
-                ? pendingRestoreActiveDraft
+              pendingRestoreActiveLocalTab != null &&
+              draftsOnly.some((tab) => tab.id === pendingRestoreActiveLocalTab)
+                ? pendingRestoreActiveLocalTab
                 : draftsOnly[0].id
             set({
               rawTabs: draftsOnly,
@@ -2069,7 +2207,7 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
               () =>
                 new Set(
                   get()
-                    .rawTabs.filter((tab) => tab.conversationId == null)
+                    .rawTabs.filter(isConversationDraft)
                     .map((tab) => tab.id)
                 )
             )
@@ -2172,6 +2310,7 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
     const rawTabs = get().rawTabs
     const openChildIds = new Set<number>()
     for (const tab of rawTabs) {
+      if (!isConversationWorkspaceTab(tab)) continue
       const id = tab.conversationId
       if (id == null) continue
       if (conversationKeys.has(`${tab.folderId}-${tab.agentType}-${id}`)) {
@@ -2203,7 +2342,13 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
           if (seedEpoch !== epoch) return
           const buffered = childSeedBuffer.get(id)
           if (buffered?.deleted) return
-          if (!get().rawTabs.some((tb) => tb.conversationId === id)) return
+          if (
+            !get().rawTabs.some(
+              (tb) => isConversationWorkspaceTab(tb) && tb.conversationId === id
+            )
+          ) {
+            return
+          }
           let summary = buffered?.summary ?? detail.summary
           if (buffered?.status != null) {
             summary = { ...summary, status: buffered.status }
@@ -2338,12 +2483,14 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
   },
 
   correctDraftAgents: () => {
-    const candidates = get().rawTabs.filter((tab) => {
-      if (tab.conversationId != null) return false
-      if (tab.agentTypeProvisional) return true
-      if (!runtime.sortedAvailableAgents.includes(tab.agentType)) return true
-      return false
-    })
+    const candidates = get().rawTabs.filter(
+      (tab): tab is ConversationWorkspaceTab & { conversationId: null } => {
+        if (!isConversationDraft(tab)) return false
+        if (tab.agentTypeProvisional) return true
+        if (!runtime.sortedAvailableAgents.includes(tab.agentType)) return true
+        return false
+      }
+    )
     if (candidates.length === 0) return
 
     for (const tab of candidates) {
@@ -2353,15 +2500,13 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
           null
         )
         const current = get().rawTabs.find((t) => t.id === tab.id)
-        if (!current || current.conversationId != null) return
+        if (!current || !isConversationDraft(current)) return
 
         if (current.agentType === newAgent) {
           if (!current.agentTypeProvisional) return
           const prev = get().rawTabs
           const next = prev.map((t) =>
-            t.id === tab.id &&
-            t.conversationId == null &&
-            t.agentTypeProvisional
+            t.id === tab.id && isConversationDraft(t) && t.agentTypeProvisional
               ? { ...t, agentTypeProvisional: false }
               : t
           )
@@ -2380,8 +2525,7 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
 
         const prev = get().rawTabs
         const target = prev.find((t) => t.id === tab.id)
-        if (!target) return
-        if (target.conversationId != null) return
+        if (!target || !isConversationDraft(target)) return
         if (
           target.agentType !== expectedAgent &&
           !target.agentTypeProvisional
@@ -2462,8 +2606,7 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
 
         const rawTabs = get().rawTabs
         const target = rawTabs.find((tab) => tab.id === request.tabId)
-        if (!target) return
-        if (target.conversationId != null) return
+        if (!target || !isConversationDraft(target)) return
         if (
           target.agentType !== request.expectedAgent &&
           !target.agentTypeProvisional
@@ -2472,7 +2615,7 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
         }
         set({
           rawTabs: rawTabs.map((tab) =>
-            tab.id === request.tabId
+            tab.id === request.tabId && isConversationDraft(tab)
               ? {
                   ...tab,
                   folderId: request.folderId,
@@ -2501,7 +2644,7 @@ export const useTabStore = create<TabStoreState>()((set, get) => ({
     const st = get()
     if (!st.tabsHydrated) return
     const active = st.rawTabs.find((t) => t.id === st.activeTabId)
-    if (!active) return
+    if (!active || !isConversationWorkspaceTab(active)) return
     if (active.conversationId == null) {
       saveLastActiveContext({
         folderId: active.folderId,
@@ -2558,8 +2701,8 @@ export function pruneOrphanDraftsOnce() {
   const st = useTabStore.getState()
   const { allFolders } = useAppWorkspaceStore.getState()
   const orphaned = st.rawTabs.filter(
-    (tab) =>
-      tab.conversationId == null &&
+    (tab): tab is ConversationWorkspaceTab & { conversationId: null } =>
+      isConversationDraft(tab) &&
       tab.isChat !== true &&
       !allFolders.some((folder) => folder.id === tab.folderId)
   )
@@ -2597,6 +2740,8 @@ export function useTabActions() {
   return useTabStore(
     useShallow((s) => ({
       openTab: s.openTab,
+      openPkRoundTab: s.openPkRoundTab,
+      closePkRoundTab: s.closePkRoundTab,
       closeTab: s.closeTab,
       closeConversationTab: s.closeConversationTab,
       closeOtherTabs: s.closeOtherTabs,
@@ -2751,6 +2896,7 @@ function applyRemoteSnapshot(change: TabsChanged) {
       prevById.get(canonicalId) ??
       prev.rawTabs.find(
         (tb) =>
+          isConversationWorkspaceTab(tb) &&
           tb.conversationId === it.conversation_id &&
           tb.folderId === it.folder_id &&
           tb.agentType === it.agent_type
@@ -2763,13 +2909,25 @@ function applyRemoteSnapshot(change: TabsChanged) {
       agentType: it.agent_type,
       title: existing?.title ?? runtime.labels.loadingConversation,
       isPinned: it.is_pinned,
-      runtimeConversationId: existing?.runtimeConversationId,
-      status: existing?.status,
+      runtimeConversationId:
+        existing && isConversationWorkspaceTab(existing)
+          ? existing.runtimeConversationId
+          : undefined,
+      status:
+        existing && isConversationWorkspaceTab(existing)
+          ? existing.status
+          : undefined,
       // Device-local per-tab fields the payload doesn't carry. Rebuilding the
       // tab from the snapshot must not blank them (a bound chat tab would lose
       // the scratch working dir it is connected in).
-      workingDir: existing?.workingDir,
-      isChat: existing?.isChat,
+      workingDir:
+        existing && isConversationWorkspaceTab(existing)
+          ? existing.workingDir
+          : undefined,
+      isChat:
+        existing && isConversationWorkspaceTab(existing)
+          ? existing.isChat
+          : undefined,
     }
   })
 
@@ -2779,6 +2937,10 @@ function applyRemoteSnapshot(change: TabsChanged) {
   // in-progress draft.
   const nextTabs = [...remoteTabs, ...unsyncedLocal]
   for (const localDraft of prev.rawTabs) {
+    if (localDraft.kind === "pk") {
+      nextTabs.push(localDraft)
+      continue
+    }
     if (localDraft.conversationId != null) continue
     if (
       localDraft.isChat === true ||
@@ -2811,6 +2973,7 @@ function applyRemoteSnapshot(change: TabsChanged) {
   const remoteActiveId = remoteActive
     ? (nextTabs.find(
         (tb) =>
+          isConversationWorkspaceTab(tb) &&
           tb.conversationId === remoteActive.conversation_id &&
           tb.folderId === remoteActive.folder_id &&
           tb.agentType === remoteActive.agent_type