refactor(create-issue): unify agent/manual modes under one Dialog shell

Recasts Quick/Advanced as Agent/Manual and lets users flip between modes
in-place from a footer switch button instead of a separate Advanced
shortcut. The two old modal types now route through one CreateIssueDialog
shell that owns the single <Dialog> and <DialogContent> — only the inner
panel body swaps on mode change, so the Portal/Backdrop/Popup stay
mounted and the switch is instant (no close→open animation flash).

Mode preference is persisted globally in localStorage via a small
useCreateModeStore, so the `c` shortcut always opens whichever mode the
user last used (or switched to). Carry payload (description / agent /
prompt) hands off through the shell's local state plus the existing
issue-draft store, so nothing the user typed is lost across switches.

Also drops the Shift+C → manual branch — `c` is now mode-agnostic and
the in-modal switch covers the same intent without users having to
remember a second shortcut.

Visible labels: "Quick create" → "Create with agent",
"New issue" → "Create manually".

.env.example

@@ -63,9 +63,6 @@ GOOGLE_CLIENT_SECRET=
 GOOGLE_REDIRECT_URI=http://localhost:3000/auth/callback
 
 # S3 / CloudFront
-# S3_BUCKET — bucket NAME only (e.g. "my-bucket"). Do NOT include the
-# ".s3.<region>.amazonaws.com" suffix; the server builds the public URL
-# from S3_BUCKET + S3_REGION. S3_REGION must match the bucket's real region.
 S3_BUCKET=
 S3_REGION=us-west-2
 CLOUDFRONT_KEY_PAIR_ID=

.github/PULL_REQUEST_TEMPLATE.md

@@ -40,8 +40,6 @@ Closes #
 - [ ] I have added or updated tests where applicable
 - [ ] If this change affects the UI, I have included before/after screenshots
 - [ ] I have updated relevant documentation to reflect my changes
-- [ ] If I added a new runtime / coding tool / UI tab, I synced the change to **landing copy** (`apps/web/features/landing/i18n/`), **starter-content** (`packages/views/onboarding/utils/starter-content-content-*.ts`), and **relevant docs** (`apps/docs/content/docs/`)
-- [ ] If this PR touches Chinese product copy, I checked it against `apps/docs/content/docs/developers/conventions.zh.mdx` (terminology, mixed-rule for `task` / `issue` / `skill`)
 - [ ] I have considered and documented any risks above
 - [ ] I will address all reviewer comments before requesting merge
 

.github/workflows/ci.yml

@@ -29,8 +29,8 @@ jobs:
       - name: Install dependencies
         run: pnpm install
 
-      - name: Build, type check, lint, and test
-        run: pnpm exec turbo build typecheck lint test --filter='!@multica/docs'
+      - name: Build, type check, and test
+        run: pnpm exec turbo build typecheck test --filter='!@multica/docs'
 
   backend:
     runs-on: ubuntu-latest

CLAUDE.md

@@ -2,21 +2,6 @@
 
 This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
 
-## Conventions reference
-
-The single source of truth for **code naming, the i18n translation glossary, and the Chinese voice guide** is the docs site:
-
-- **`apps/docs/content/docs/developers/conventions.mdx`** (English)
-- **`apps/docs/content/docs/developers/conventions.zh.mdx`** (Chinese)
-
-Read that page before:
-
-- Writing or editing translations (`packages/views/locales/`)
-- Naming a new route, package, file, DB column, or TS type
-- Writing Chinese product copy (UI strings, error messages, docs)
-
-The legacy `packages/views/locales/glossary.md` is now a stub redirecting to the docs page; do not rely on it.
-
 ## Project Context
 
 Multica is an AI-native task management platform — like Linear, but with AI agents as first-class citizens.

CLI_AND_DAEMON.md

@@ -70,10 +70,10 @@ Opens your browser for OAuth authentication, creates a 90-day personal access to
 ### Token Login
 
 ```bash
-multica login --token <mul_...>
+multica login --token
 ```
 
-Authenticate using a personal access token directly. Useful for headless environments. Pass `--token=` with an empty value to be prompted interactively (so the token never lands in shell history).
+Authenticate by pasting a personal access token directly. Useful for headless environments.
 
 ### Check Status
 
@@ -140,7 +140,6 @@ The daemon auto-detects these AI CLIs on your PATH:
 |-----|---------|-------------|
 | [Claude Code](https://docs.anthropic.com/en/docs/claude-code) | `claude` | Anthropic's coding agent |
 | [Codex](https://github.com/openai/codex) | `codex` | OpenAI's coding agent |
-| [GitHub Copilot CLI](https://docs.github.com/en/copilot) | `copilot` | GitHub's coding agent (model routed by your GitHub entitlement) |
 | OpenCode | `opencode` | Open-source coding agent |
 | OpenClaw | `openclaw` | Open-source coding agent |
 | Hermes | `hermes` | Nous Research coding agent |
@@ -175,22 +174,6 @@ Daemon behavior is configured via flags or environment variables:
 | Device name | `--device-name` | `MULTICA_DAEMON_DEVICE_NAME` | hostname |
 | Runtime name | `--runtime-name` | `MULTICA_AGENT_RUNTIME_NAME` | `Local Agent` |
 | Workspaces root | — | `MULTICA_WORKSPACES_ROOT` | `~/multica_workspaces` |
-| GC enabled | — | `MULTICA_GC_ENABLED` | `true` (set `false`/`0` to disable) |
-| GC scan interval | — | `MULTICA_GC_INTERVAL` | `1h` |
-| GC TTL (done/cancelled issues) | — | `MULTICA_GC_TTL` | `24h` |
-| GC orphan TTL (no `.gc_meta.json`) | — | `MULTICA_GC_ORPHAN_TTL` | `72h` |
-| GC artifact TTL (open issues) | — | `MULTICA_GC_ARTIFACT_TTL` | `12h` (set `0` to disable) |
-| GC artifact patterns | — | `MULTICA_GC_ARTIFACT_PATTERNS` | `node_modules,.next,.turbo` |
-
-#### Workspace garbage collection
-
-The daemon periodically scans `MULTICA_WORKSPACES_ROOT` and reclaims disk space in three modes:
-
-- **Full task cleanup** — when an issue's status is `done` or `cancelled` and has been idle for `MULTICA_GC_TTL`, the entire task directory is removed.
-- **Orphan cleanup** — task directories with no `.gc_meta.json` (e.g. left over from a daemon crash) are removed once they exceed `MULTICA_GC_ORPHAN_TTL`.
-- **Artifact-only cleanup** — when a task has been completed for at least `MULTICA_GC_ARTIFACT_TTL` but the issue is still open, regenerable build outputs whose directory basename matches `MULTICA_GC_ARTIFACT_PATTERNS` are removed; the rest of the workdir (source, `.git`, `output/`, `logs/`, `.gc_meta.json`) is preserved so the agent can resume the same workdir on the next task.
-
-Patterns are basename-only — entries containing `/` or `\` are silently dropped — and `.git` subtrees are never descended into. The default list (`node_modules`, `.next`, `.turbo`) is intentionally narrow; extend it per deployment if your repos consistently produce other regenerable directories (for example, `MULTICA_GC_ARTIFACT_PATTERNS=node_modules,.next,.turbo,target,__pycache__`). To disable artifact cleanup entirely, set `MULTICA_GC_ARTIFACT_TTL=0`.
 
 Agent-specific overrides:
 
@@ -198,12 +181,8 @@ Agent-specific overrides:
 |----------|-------------|
 | `MULTICA_CLAUDE_PATH` | Custom path to the `claude` binary |
 | `MULTICA_CLAUDE_MODEL` | Override the Claude model used |
-| `MULTICA_CLAUDE_ARGS` | Default extra arguments for Claude Code runs |
 | `MULTICA_CODEX_PATH` | Custom path to the `codex` binary |
 | `MULTICA_CODEX_MODEL` | Override the Codex model used |
-| `MULTICA_CODEX_ARGS` | Default extra arguments for Codex runs |
-| `MULTICA_COPILOT_PATH` | Custom path to the `copilot` binary |
-| `MULTICA_COPILOT_MODEL` | Override the Copilot model used (note: GitHub Copilot routes models through your account entitlement, so this may not be honoured) |
 | `MULTICA_OPENCODE_PATH` | Custom path to the `opencode` binary |
 | `MULTICA_OPENCODE_MODEL` | Override the OpenCode model used |
 | `MULTICA_OPENCLAW_PATH` | Custom path to the `openclaw` binary |
@@ -221,8 +200,6 @@ Agent-specific overrides:
 | `MULTICA_KIRO_PATH` | Custom path to the `kiro-cli` binary |
 | `MULTICA_KIRO_MODEL` | Override the Kiro model used |
 
-`MULTICA_CLAUDE_ARGS` and `MULTICA_CODEX_ARGS` are parsed with POSIX shellword quoting, so values such as `--model "gpt-5.1 codex" --sandbox read-only` are split like a shell command line. Agent arguments are applied in this order: hardcoded Multica defaults, daemon-wide env defaults, then per-agent `custom_args` from the task.
-
 ### Self-Hosted Server
 
 When connecting to a self-hosted Multica instance, the easiest approach is:
@@ -305,11 +282,10 @@ multica workspace members <workspace-id>
 multica issue list
 multica issue list --status in_progress
 multica issue list --priority urgent --assignee "Agent Name"
-multica issue list --assignee-id 5fb87ac7-23b5-4a7a-81fa-ed295a54545d
 multica issue list --limit 20 --output json
 ```
 
-Available filters: `--status`, `--priority`, `--assignee` / `--assignee-id`, `--project`, `--limit`. Use `--assignee-id <uuid>` for unambiguous filtering when names overlap.
+Available filters: `--status`, `--priority`, `--assignee`, `--project`, `--limit`.
 
 ### Get Issue
 
@@ -322,10 +298,9 @@ multica issue get <id> --output json
 
 ```bash
 multica issue create --title "Fix login bug" --description "..." --priority high --assignee "Lambda"
-multica issue create --title "Fix login bug" --assignee-id 5fb87ac7-23b5-4a7a-81fa-ed295a54545d
 ```
 
-Flags: `--title` (required), `--description`, `--status`, `--priority`, `--assignee` / `--assignee-id`, `--parent`, `--project`, `--due-date`. Pass `--assignee-id <uuid>` (mutually exclusive with `--assignee`) when scripting against the IDs returned by `multica workspace members --output json` / `multica agent list --output json`.
+Flags: `--title` (required), `--description`, `--status`, `--priority`, `--assignee`, `--parent`, `--project`, `--due-date`.
 
 ### Update Issue
 
@@ -337,12 +312,9 @@ multica issue update <id> --title "New title" --priority urgent
 
 ```bash
 multica issue assign <id> --to "Lambda"
-multica issue assign <id> --to-id 5fb87ac7-23b5-4a7a-81fa-ed295a54545d
 multica issue assign <id> --unassign
 ```
 
-Pass `--to-id <uuid>` to assign by canonical UUID (mutually exclusive with `--to`); useful when names overlap across members and agents.
-
 ### Change Status
 
 ```bash

CLI_INSTALL.md

@@ -140,7 +140,7 @@ multica auth status
 Expected output should show the authenticated user and server URL.
 
 **If login fails:**
-- If no browser is available (headless environment), the user can generate a Personal Access Token at `https://app.multica.ai/settings` and run: `multica login --token <mul_...>` (use `--token=` with an empty value to be prompted interactively).
+- If no browser is available (headless environment), the user can generate a Personal Access Token at `https://app.multica.ai/settings` and run: `multica login --token`
 - If the server URL needs to be customized: `multica config set server_url <url>` before logging in.
 
 ---
@@ -166,12 +166,12 @@ Wait 3 seconds, then verify:
 multica daemon status
 ```
 
-Expected output should show `running` status with detected agents (e.g. `claude`, `codex`, `copilot`, `opencode`, `openclaw`, `hermes`, `gemini`, `pi`, `cursor-agent`).
+Expected output should show `running` status with detected agents (e.g. `claude`, `codex`, `opencode`, `openclaw`, `hermes`, `gemini`, `pi`, `cursor-agent`).
 
 **If daemon fails to start:**
 - Check logs: `multica daemon logs`
 - If a port conflict occurs, the daemon may already be running under a different profile.
-- If no agents are detected, ensure at least one AI CLI (`claude`, `codex`, `copilot`, `opencode`, `openclaw`, `hermes`, `gemini`, `pi`, or `cursor-agent`) is installed and on the `$PATH`.
+- If no agents are detected, ensure at least one AI CLI (`claude`, `codex`, `opencode`, `openclaw`, `hermes`, `gemini`, `pi`, or `cursor-agent`) is installed and on the `$PATH`.
 
 ---
 
@@ -185,12 +185,12 @@ multica daemon status
 
 Confirm:
 1. Status is `running`
-2. At least one agent is listed (e.g. `claude`, `codex`, `copilot`, `opencode`, `openclaw`, `hermes`, `gemini`, `pi`, or `cursor-agent`)
+2. At least one agent is listed (e.g. `claude`, `codex`, `opencode`, `openclaw`, `hermes`, `gemini`, `pi`, or `cursor-agent`)
 3. At least one workspace is being watched
 
 If the agents list is empty, tell the user:
 
-> "The Multica daemon is running but no AI agent CLIs were detected. Please install at least one supported CLI (`claude`, `codex`, `copilot`, `opencode`, `openclaw`, `hermes`, `gemini`, `pi`, or `cursor-agent`), then restart the daemon with `multica daemon stop && multica daemon start`."
+> "The Multica daemon is running but no AI agent CLIs were detected. Please install at least one supported CLI (`claude`, `codex`, `opencode`, `openclaw`, `hermes`, `gemini`, `pi`, or `cursor-agent`), then restart the daemon with `multica daemon stop && multica daemon start`."
 
 ---
 

HANDOFF_ARCHITECTURE_AUDIT.md

@@ -0,0 +1,383 @@
+# Architecture Audit — Workspace & Realtime Cache
+
+> 基于代码审计整理的 4 个任务。优先级：P0 一个、P1 一个、P2 两个。每个任务都包含问题、根因、受影响的 issue、复现步骤、修复方案、改动范围。
+
+---
+
+## 任务 1 — [P0] 空闲后列表数据陈旧
+
+**关联 issue**：[#951](https://github.com/multica-ai/multica/issues/951)
+
+### 问题
+
+用户登录后静置一段时间，Issue 列表里缺失一部分数据（其他成员期间新建/变更的 issue 不出现）。登出再登入可以恢复。`ec5af33b` 声称 "Closes #951"，但 issue 仍为 OPEN 状态 —— 因为它只修了 401 一种场景，没修 WS 半开这一种。
+
+### 根因
+
+系统把 cache 新鲜度的全部责任压给了 WebSocket 推送：
+
+- `packages/core/query-client.ts:7` — `staleTime: Infinity`，cache 永不主动过期
+- `packages/core/query-client.ts:9` — `refetchOnWindowFocus: false`，tab 重新获得焦点也不 refetch
+- 依赖 WS 推送 `issue:created` / `issue:updated` 事件 invalidate cache
+
+但 WS 层存在一个**不对称**：
+
+- **服务端**：`server/internal/realtime/hub.go:83-96, 420-475` 有 54s ping / 60s pongWait，会清理死连接
+- **客户端**：`packages/core/api/ws-client.ts`（142 行全貌）**完全没有心跳检测**，只靠 `onclose` 事件触发重连
+
+浏览器原生 `WebSocket` API 不把 ping/pong 帧暴露给 JS，所以 JS 层无法主动探测 "半开" 连接。当 NAT / 负载均衡器 / 笔记本睡眠导致 TCP 连接被静默切断时：
+
+1. 浏览器 `readyState` 仍是 `OPEN`
+2. `onclose` 不触发
+3. `ws-client.ts:70-73` 的 3 秒重连逻辑不跑
+4. `packages/core/realtime/use-realtime-sync.ts:462-487` 的 `onReconnect` 全量 invalidate 不跑
+5. 期间的 WS 事件进黑洞
+6. cache 保持旧快照
+
+### 复现
+
+**浏览器 DevTools 里的 "Block request URL" 不行** —— 那会触发 `onclose`，走正常重连 → 不复现。真正的半开需要在网络层静默丢包。
+
+**方法 A（推荐，最接近真实场景）**：macOS 用 pfctl 丢包
+
+```bash
+# 假设后端在 8080
+sudo pfctl -E
+echo "block drop out quick proto tcp to any port 8080" | sudo pfctl -f -
+
+# 观察:
+# - Console 里没有 "disconnected, reconnecting in 3s" 日志
+# - Network 里 WS 连接仍显示 Pending / 101
+# 用另一个账号/CLI 创建一个 issue
+# 回到原客户端: 列表不更新
+# 登出再登入: 列表恢复完整
+
+sudo pfctl -d  # 解除
+```
+
+**方法 B（不动网络）**：临时修改代码，在 `packages/core/api/ws-client.ts:52` 的 `onmessage` 处理器里加一行 `return;` 在前面，吞掉所有入站消息。效果等价于半开。
+
+### 修复方案（三个选项，推荐 C）
+
+#### 选项 A — 浏览器端心跳探活（治本，改动大）
+
+在 `ws-client.ts` 加客户端侧的心跳检测：记录 `lastMessageTime`，定时器检查若超过 N 秒没收到任何消息就主动 `ws.close()`，触发现有重连逻辑。
+
+- 优点：从根本上解决半开问题
+- 缺点：浏览器原生 API 没有 ping 能力，需要服务端配合发"应用层 heartbeat"消息供客户端更新 `lastMessageTime`；服务端改 + 客户端改
+
+#### 选项 B — Page Visibility API 触发 invalidate（治标，改动小）
+
+在 `packages/core/platform/core-provider.tsx` 加 `visibilitychange` 监听，tab 重新可见时强制 `queryClient.invalidateQueries({ queryKey: issueKeys.all(wsId) })`（及其他关键 key）。
+
+- 优点：~10 行代码，能兜住 80% 场景（睡眠、切后台 tab）
+- 缺点：treats symptom, 不是真正的半开检测；对"一直保持 tab 可见但网络层断了"的场景无效
+
+#### 选项 C — **A + B 组合**（推荐）
+
+- 短期上 B，立刻止血
+- 中期上 A，把 cache 新鲜度从"只信 WS"改成"WS 是优化，Visibility 是兜底"
+- 可选加 `refetchOnWindowFocus: true` 或把 `staleTime` 改成一个有限值（比如 5 min），作为第三层保险
+
+### 改动范围
+
+| 方案 | 文件 | 改动规模 |
+|---|---|---|
+| B | `packages/core/platform/core-provider.tsx` | ~10 行 |
+| A 客户端 | `packages/core/api/ws-client.ts` | ~30 行 |
+| A 服务端 | `server/internal/realtime/hub.go` | 加 app-level heartbeat message |
+
+### 验证
+
+修完之后：
+
+1. 跑方法 A 复现流程，确认数据不再丢失
+2. 加 e2e 测试：模拟 `document.dispatchEvent(new Event('visibilitychange'))` + 验证 issue list 被 refetch
+
+---
+
+## 任务 2 — [P1] Workspace 不在 URL 路径中
+
+**关联 issue**：MUL-723（slug 不在 URL）、MUL-43（切换 workspace 报错）、MUL-509（手机端无法切换）
+
+> **注意**：审计中提到的 MUL-43 / MUL-476 issue 编号需要当面核对一次 —— agent 查询 GitHub 后返回的标题对不上（看起来是别的 PR）。交接时请让执行人以具体症状为准。
+
+### 问题
+
+当前 workspace 身份完全靠 `X-Workspace-ID` HTTP header + Zustand store + localStorage 承载，URL 里没有 workspace 信息。所有路径都是 `/issues`、`/issues/:id` 这种 workspace-agnostic 的。
+
+### 根因
+
+**数据库和 API 已经支持 slug**：
+
+- `server/migrations/001_init.up.sql:15-23` — workspace 表有 `slug TEXT UNIQUE NOT NULL`
+- `server/pkg/db/queries/workspace.sql:11-13` — 有 `GetWorkspaceBySlug` 查询
+- `packages/core/types/workspace.ts:8-19` — Workspace 类型里有 slug 字段
+
+**但前端路由和导航层没用它**：
+
+- Web 路由：`apps/web/app/(dashboard)/` 下 25 个 route file 都是 workspace-implicit
+- Desktop 路由：`apps/desktop/src/renderer/src/routes.tsx:71-143` 同样
+- Navigation 适配器 `apps/web/platform/navigation.tsx` 直接透传 `router.push`，没有任何 workspace 前缀逻辑
+
+**workspace 切换只靠 sidebar UI**（`packages/views/layout/app-sidebar.tsx:284-286`）：
+
+```tsx
+if (ws.id !== workspace?.id) {
+  push("/issues");              // 硬跳 /issues（workspace-implicit！）
+  switchWorkspace(ws);           // 然后改 store
+}
+```
+
+这种设计使得：
+
+- 手机端因为没 sidebar UI，也没 URL 层切换入口，**完全切不了 workspace**（MUL-509）
+- 把 `/issues/xxx` 链接发给处于不同 workspace 的同事，会打开错误 workspace 下的 issue，或找不到报错（MUL-43 系列）
+- 分享链接没有 workspace 上下文，接收方必须先手动切对 workspace
+
+### 复现
+
+1. **MUL-723**：登录 → 观察地址栏，没有任何 workspace 标识
+2. **MUL-43**：
+   - 加入两个 workspace A 和 B
+   - 在 A 中打开某个 issue `/issues/abc123`
+   - 切到 B，URL 不变 → 访问失败 / 显示错数据
+3. **MUL-509**：手机浏览器打开，尝试切 workspace → 无法切换（UI 不显示 sidebar 触发器或触发器无法切）
+
+### 修复方案（三个选项，推荐 A）
+
+#### 选项 A — `/ws/:slug/...` URL 前缀（根本方案，推荐）
+
+所有路径加上 workspace slug 前缀。例如 `/issues/abc123` → `/ws/my-team/issues/abc123`。
+
+**要改的地方**：
+
+1. **Web 路由目录结构**：`apps/web/app/(dashboard)/` 下全部搬到 `apps/web/app/(dashboard)/ws/[slug]/...`（~25 个文件）
+2. **Desktop 路由**：`apps/desktop/src/renderer/src/routes.tsx:71-143` 给所有路径加 `/ws/:slug` 前缀
+3. **Navigation 适配器**：
+   - `apps/web/platform/navigation.tsx` — `push(path)` 内部前置 `/ws/${workspace.slug}`，`pathname` 读取时去掉前缀
+   - `apps/desktop/src/renderer/src/platform/navigation.tsx` — 同上
+4. **Sidebar 切换逻辑**：`packages/views/layout/app-sidebar.tsx:284-286` 改成 `push('/ws/${ws.slug}/issues')`（或依赖适配器自动加前缀就不用改）
+5. **服务端中间件**：`server/internal/middleware/workspace.go:41-46` 增加 "从 URL path 解析 slug → 查 ID → 校验 membership" 的逻辑，header 继续作为 fallback（迁移期兼容）
+
+**预计改动**：~50-100 个文件（大部分是 route 搬迁，不是逻辑改动）、~5-7 人天
+
+**不改也能工作的部分**：
+- `packages/core/api/client.ts` — 仍旧走 header，不用改
+- 所有 `packages/views/` 下的组件 —— 它们用 `useNavigation().push()` 抽象，适配器层处理前缀就行
+
+**风险**：
+- 旧的 bookmark URL 失效（如果产品还没正式 ship，问题不大）
+- E2E 测试需要更新所有 URL 断言
+
+#### 选项 B — `?ws=slug` query param（折中）
+
+URL 形如 `/issues?ws=my-team`。改动更小（~30 个文件），URL 丑但向后兼容。推荐度低于 A。
+
+#### 选项 C — 只修症状不动架构
+
+在 `switchWorkspace` 和各个 query 之间加 debounce、error boundary 等 workaround。不解决根因，技术债越攒越多。**不推荐**。
+
+### 改动范围（选项 A）
+
+| 模块 | 文件数 | 备注 |
+|---|---|---|
+| Web routes | ~25 | 目录搬迁 |
+| Desktop routes | 1 | 路径前缀 |
+| Navigation adapters | 2 | 前缀逻辑 |
+| Server middleware | 1-2 | slug → ID 解析 |
+| 组件（不用改） | 30-40 | 用 `useNavigation` 的不受影响 |
+| E2E tests | 20-30 | URL 断言更新 |
+
+---
+
+## 任务 3 — [P1] Workspace 切换时 navigation 状态未隔离
+
+**关联 issue**：MUL-43（切换报错）、MUL-476（本地缓存未按 workspace 隔离）
+
+> 同上，这两个编号建议交接时核对症状。
+
+### 问题
+
+绝大多数 workspace-scoped 的 Zustand store 都正确使用了 `createWorkspaceAwareStorage`（key 后缀加 wsId 自动隔离），但 **`useNavigationStore` 是个例外**：它持久化了 `lastPath`，但用的是 global storage，切换 workspace 后里面仍是上个 workspace 的路径。
+
+### 根因
+
+**`packages/core/navigation/store.ts:15-31`**：
+
+```typescript
+export const useNavigationStore = create<NavigationState>()(
+  persist(
+    (set) => ({
+      lastPath: "/issues",
+      onPathChange: (path) => { /* ... */ set({ lastPath: path }); },
+    }),
+    {
+      name: "multica_navigation",
+      storage: createJSONStorage(() => createPersistStorage(defaultStorage)), // ← 这里用的是 global，不是 workspace-aware
+      partialize: (state) => ({ lastPath: state.lastPath }),
+    }
+  )
+);
+// ← 没有调 registerForWorkspaceRehydration
+```
+
+**对比：其他 store 都是正确的**：
+
+| Store | 是否 workspace-aware | 是否注册 rehydration |
+|---|---|---|
+| useNavigationStore | ❌ | ❌ |
+| useIssuesScopeStore | ✅ | ✅ |
+| useIssueDraftStore | ✅ | ✅ |
+| useRecentIssuesStore | ✅ | ✅ |
+| useIssueViewStore | ✅ | ✅ |
+| myIssuesViewStore | ✅ | ✅ |
+| useChatStore | ✅（手动用 wsKey）| ✅ |
+
+另外 `packages/core/platform/storage-cleanup.ts:10-19` 的 `WORKSPACE_SCOPED_KEYS` 列表里也漏了 `multica_navigation`。
+
+**现有的 workaround**：`packages/views/layout/app-sidebar.tsx:285` 切 workspace 时硬跳到 `/issues`，正是为了绕开这个 bug。修好 navigation store 之后这行 hack 可以删掉。
+
+### 复现
+
+1. 在 workspace A 中打开一个具体 issue `/issues/abc123`
+2. 切到 workspace B
+3. 观察：如果没有 sidebar 的硬跳 workaround，会尝试恢复到 `/issues/abc123`，但那个 issue 不属于 B，导致 404 或错误
+
+目前因为有硬跳 workaround，症状表现为"切 workspace 后总是回到 issue 首页"—— 这本身也是 bug（用户期望记住上次位置）。
+
+### 修复方案（推荐 Option C：组合）
+
+**三处改动**：
+
+1. `packages/core/navigation/store.ts:28` —— 把 `createPersistStorage(defaultStorage)` 改成 `createWorkspaceAwareStorage(defaultStorage)`
+2. 同文件在末尾加：`registerForWorkspaceRehydration(() => useNavigationStore.persist.rehydrate());`
+3. `packages/core/platform/storage-cleanup.ts:10-19` 的 `WORKSPACE_SCOPED_KEYS` 数组里加 `"multica_navigation"`
+
+**可选**：清理 `packages/views/layout/app-sidebar.tsx:285` 的 `push("/issues")` workaround（改完之后不再需要）。
+
+### 改动范围
+
+| 文件 | 改动 |
+|---|---|
+| `packages/core/navigation/store.ts` | 改 storage 类型、加 rehydration 注册（~3 行） |
+| `packages/core/platform/storage-cleanup.ts` | 数组加一行 |
+| `packages/core/platform/workspace-storage.test.ts` | 加 rehydration 的单测 |
+| `packages/views/layout/app-sidebar.tsx`（可选） | 移除硬跳 workaround |
+
+**风险**：极低。只是把 navigation store 对齐到其他 store 已经在用的模式。
+
+---
+
+## 任务 4 — [P2] Workspace 生命周期副作用散落
+
+**关联 issue**：MUL-727（创建后闪页）、MUL-728（删除确认）、MUL-820（接受邀请不自动切）
+
+### 问题
+
+创建 / 删除 / 切换 / 加入 workspace 的副作用分散在 mutation 的 `onSuccess` 和各处 UI 回调里，没有统一抽象。几个具体 bug：
+
+### 4.1 MUL-727 — 创建 workspace 后闪一下 `/issues` 再跳 `/onboarding`
+
+**根因**：两个 `onSuccess` 回调同时跑，顺序不确定。
+
+- `packages/core/workspace/mutations.ts:7-21` 的 `useCreateWorkspace.onSuccess` 里调了 `switchWorkspace(newWs)` —— 同步改 Zustand，`/issues` 路由开始用新 workspace 渲染
+- `packages/views/modals/create-workspace.tsx:68-70` 的 UI `onSuccess` 里调了 `router.push("/onboarding")` —— 异步 schedule 导航
+
+于是：`/issues` 先渲染（闪一下）→ 导航到 `/onboarding`。
+
+**修复**：把 `switchWorkspace` 从 mutation 里拿出来，让 UI 层主导。在 `create-workspace.tsx` 的 `onSuccess` 里先 `switchWorkspace` 再 `push`，保证同一个微任务里完成。
+
+**文件**：`packages/core/workspace/mutations.ts`、`packages/views/modals/create-workspace.tsx`、可能 `packages/views/onboarding/step-workspace.tsx`
+
+### 4.2 MUL-728 — 删除 workspace 的"缺少确认"
+
+**核查结果**：`packages/views/settings/components/workspace-tab.tsx:102-119, 236-255` **已经有 AlertDialog 确认**了。
+
+**真实问题**：删除成功后**没有导航**，用户停在 `/settings`，而当前 workspace 已经是删除后系统挑的另一个。
+
+**修复**：在 `handleDeleteWorkspace` 的 `onConfirm` 成功分支里加 `push("/issues")`。
+
+**文件**：`packages/views/settings/components/workspace-tab.tsx`（加一行）
+
+### 4.3 MUL-820 — 接受邀请不自动切换 workspace
+
+**核查结果**：有两条路径：
+
+- ✅ `/invite/:id` 独立页（`packages/views/invite/invite-page.tsx:32-52`）是**正确的**：accept → switchWorkspace → push("/issues")
+- ❌ **Sidebar 下拉里的 "Join" 按钮**（`packages/views/layout/app-sidebar.tsx:203-209, 321-324`）**是错的**：只 invalidate cache，不切也不跳
+
+**修复（推荐 Option 2）**：Sidebar 的 "Join" 改成跳转到 `/invite/:id` 页面，不再就地接受。单一入口、单一行为。
+
+```tsx
+<DropdownMenuItem onClick={() => push(`/invite/${inv.id}`)}>
+  {inv.workspace_name}
+</DropdownMenuItem>
+```
+
+**文件**：`packages/views/layout/app-sidebar.tsx`（~10 行）
+
+### 复现
+
+| Issue | 步骤 |
+|---|---|
+| MUL-727 | 创建新 workspace → 仔细看是否闪了一下 `/issues` 再跳 `/onboarding` |
+| MUL-728 | 删除当前 workspace → 观察删完后是否留在 `/settings` 页面（BUG: 没有自动跳走） |
+| MUL-820 | 被邀请用户登录 → sidebar 下拉 → 点 "Join" → 观察当前 workspace 是否切过去（BUG: 不切）|
+
+### 长期架构建议（可选）
+
+抽一个 `useWorkspaceLifecycle` hook 统一管这些副作用。Agent 报告里有完整设计，文件：`packages/core/workspace/hooks.ts`（新建）。但建议先修 MUL-727/728/820 三个具体 bug，hook 抽象作为后续迭代。
+
+### 改动范围
+
+| Issue | 文件 | 改动规模 |
+|---|---|---|
+| MUL-727 | mutations.ts + create-workspace.tsx | ~10 行 |
+| MUL-728 | workspace-tab.tsx | ~1 行 |
+| MUL-820 | app-sidebar.tsx | ~10 行 |
+
+---
+
+## 总览
+
+| 任务 | Issue | 优先级 | 预估规模 | 风险 |
+|---|---|---|---|---|
+| 1. WS 半开 + 陈旧 cache | #951 | **P0** | Option B ~10 行；Option C ~1-2 天 | 低 |
+| 2. Workspace URL 化 | MUL-723/43/509 | P1 | 5-7 人天（大部分是搬迁）| 中（影响面大、e2e 要改）|
+| 3. Navigation store 隔离 | MUL-43/476 | P1 | ~0.5 天 | 低 |
+| 4. Workspace 生命周期 bug | MUL-727/728/820 | P2 | ~1 天 | 低 |
+
+### 建议推进顺序
+
+1. **立刻做**：任务 1 的 Option B（visibilitychange 触发 invalidate）—— 代码最少、收益最明显，能当天止血
+2. **同步开始**：任务 3（navigation store 隔离）—— 影响小、风险低、顺便清掉一个 workaround
+3. **规划立项**：任务 2（URL 化）—— 大改造，需要单独开一个 iteration
+4. **次要修补**：任务 4 的三个小 bug —— 可以拆成独立 PR，各自 review
+
+### 重要澄清
+
+- **Issue 编号核对**：MUL-43 / MUL-476 的编号需要核对一次，agent 查询 GitHub 返回的标题看起来对不上（可能是内部 issue tracker 编号 vs GitHub 编号混用）。以症状为准。
+- **MUL-728 实际状态**：确认对话框已经存在，真实缺的是"删除后跳走"。
+- **MUL-820 实际状态**：`/invite/:id` 页面路径工作正常，只是 sidebar 下拉按钮坏了。
+
+### 所有关键代码位置索引
+
+```
+packages/core/query-client.ts:7-10          # staleTime: Infinity
+packages/core/api/ws-client.ts:1-142        # 客户端 WS，无心跳
+packages/core/realtime/use-realtime-sync.ts:462-487  # onReconnect 全量 invalidate
+packages/core/platform/core-provider.tsx    # 加 visibilitychange 的位置
+packages/core/navigation/store.ts:15-31     # lastPath 未隔离
+packages/core/platform/storage-cleanup.ts:10-19  # WORKSPACE_SCOPED_KEYS
+packages/core/workspace/store.ts:43-77      # hydrateWorkspace / switchWorkspace
+packages/core/workspace/mutations.ts:7-57   # create/leave/delete 三个 mutation
+packages/views/layout/app-sidebar.tsx:203-324  # 侧边栏切 workspace、接受邀请入口
+packages/views/modals/create-workspace.tsx:63-82  # 创建 workspace 入口
+packages/views/settings/components/workspace-tab.tsx:102-119  # 删除 workspace 入口
+packages/views/invite/invite-page.tsx:32-52 # 接受邀请正确实现参考
+
+server/internal/realtime/hub.go:83-96       # 服务端 WS 心跳
+server/internal/middleware/workspace.go:41-46  # wsId resolution
+server/migrations/001_init.up.sql:15-23     # workspace.slug 已存在
+```

README.md

@@ -30,24 +30,12 @@ Turn coding agents into real teammates — assign tasks, track progress, compoun
 
 Multica turns coding agents into real teammates. Assign issues to an agent like you'd assign to a colleague — they'll pick up the work, write code, report blockers, and update statuses autonomously.
 
-No more copy-pasting prompts. No more babysitting runs. Your agents show up on the board, participate in conversations, and compound reusable skills over time. Think of it as open-source infrastructure for managed agents — vendor-neutral, self-hosted, and designed for human + AI teams. Works with **Claude Code**, **Codex**, **GitHub Copilot CLI**, **OpenClaw**, **OpenCode**, **Hermes**, **Gemini**, **Pi**, **Cursor Agent**, **Kimi**, and **Kiro CLI**.
+No more copy-pasting prompts. No more babysitting runs. Your agents show up on the board, participate in conversations, and compound reusable skills over time. Think of it as open-source infrastructure for managed agents — vendor-neutral, self-hosted, and designed for human + AI teams. Works with **Claude Code**, **Codex**, **OpenClaw**, **OpenCode**, **Hermes**, **Gemini**, **Pi**, **Cursor Agent**, **Kimi**, and **Kiro CLI**.
 
 <p align="center">
   <img src="docs/assets/hero-screenshot.png" alt="Multica board view" width="800">
 </p>
 
-## Why "Multica"?
-
-Multica — **Mul**tiplexed **I**nformation and **C**omputing **A**gent.
-
-The name is a nod to Multics, the pioneering operating system of the 1960s that introduced time-sharing — letting multiple users share a single machine as if each had it to themselves. Unix was born as a deliberate simplification of Multics: one user, one task, one elegant philosophy.
-
-We think the same inflection is happening again. For decades, software teams have been single-threaded — one engineer, one task, one context switch at a time. AI agents change that equation. Multica brings time-sharing back, but for an era where the "users" multiplexing the system are both humans and autonomous agents.
-
-In Multica, agents are first-class teammates. They get assigned issues, report progress, raise blockers, and ship code — just like their human colleagues. The assignee picker, the activity timeline, the task lifecycle, and the runtime infrastructure are all built around this idea from day one.
-
-Like Multics before it, the bet is on multiplexing: a small team shouldn't feel small. With the right system, two engineers and a fleet of agents can move like twenty.
-
 ## Features
 
 Multica manages the full agent lifecycle: from task assignment to execution monitoring to skill reuse.
@@ -110,7 +98,7 @@ multica setup          # Connect to Multica Cloud, log in, start daemon
 multica setup           # Configure, authenticate, and start the daemon
 ```
 
-The daemon runs in the background and auto-detects agent CLIs (`claude`, `codex`, `copilot`, `openclaw`, `opencode`, `hermes`, `gemini`, `pi`, `cursor-agent`, `kimi`, `kiro-cli`) on your PATH.
+The daemon runs in the background and auto-detects agent CLIs (`claude`, `codex`, `openclaw`, `opencode`, `hermes`, `gemini`, `pi`, `cursor-agent`, `kimi`, `kiro-cli`) on your PATH.
 
 ### 2. Verify your runtime
 
@@ -120,7 +108,7 @@ Open your workspace in the Multica web app. Navigate to **Settings → Runtimes*
 
 ### 3. Create an agent
 
-Go to **Settings → Agents** and click **New Agent**. Pick the runtime you just connected and choose a provider (Claude Code, Codex, GitHub Copilot CLI, OpenClaw, OpenCode, Hermes, Gemini, Pi, Cursor Agent, Kimi, or Kiro CLI). Give your agent a name — this is how it will appear on the board, in comments, and in assignments.
+Go to **Settings → Agents** and click **New Agent**. Pick the runtime you just connected and choose a provider (Claude Code, Codex, OpenClaw, OpenCode, Hermes, Gemini, Pi, Cursor Agent, Kimi, or Kiro CLI). Give your agent a name — this is how it will appear on the board, in comments, and in assignments.
 
 ### 4. Assign your first task
 
@@ -172,9 +160,10 @@ See the [CLI and Daemon Guide](CLI_AND_DAEMON.md) for the full command reference
                             │
                      ┌──────┴───────┐
                      │ Agent Daemon │  runs on your machine
-                     └──────────────┘  (Claude Code, Codex, GitHub Copilot CLI,
-                                        OpenCode, OpenClaw, Hermes, Gemini,
-                                        Pi, Cursor Agent, Kimi, Kiro CLI)
+                     └──────────────┘  (Claude Code, Codex, OpenCode,
+                                        OpenClaw, Hermes, Gemini,
+                                        Pi, Cursor Agent, Kimi,
+                                        Kiro CLI)
 ```
 
 | Layer | Stack |
@@ -182,7 +171,7 @@ See the [CLI and Daemon Guide](CLI_AND_DAEMON.md) for the full command reference
 | Frontend | Next.js 16 (App Router) |
 | Backend | Go (Chi router, sqlc, gorilla/websocket) |
 | Database | PostgreSQL 17 with pgvector |
-| Agent Runtime | Local daemon executing Claude Code, Codex, GitHub Copilot CLI, OpenClaw, OpenCode, Hermes, Gemini, Pi, Cursor Agent, Kimi, or Kiro CLI |
+| Agent Runtime | Local daemon executing Claude Code, Codex, OpenClaw, OpenCode, Hermes, Gemini, Pi, Cursor Agent, Kimi, or Kiro CLI |
 
 ## Development
 

README.zh-CN.md

@@ -30,24 +30,12 @@
 
 Multica 将编码 Agent 变成真正的队友。像分配给同事一样分配给 Agent——它们会自主接手工作、编写代码、报告阻塞问题、更新状态。
 
-不再需要复制粘贴 prompt，不再需要盯着运行过程。你的 Agent 出现在看板上、参与对话、随着时间积累可复用的技能。可以理解为开源的 Managed Agents 基础设施——厂商中立、可自部署、专为人类 + AI 团队设计。支持 **Claude Code**、**Codex**、**GitHub Copilot CLI**、**OpenClaw**、**OpenCode**、**Hermes**、**Gemini**、**Pi**、**Cursor Agent**、**Kimi** 和 **Kiro CLI**。
+不再需要复制粘贴 prompt，不再需要盯着运行过程。你的 Agent 出现在看板上、参与对话、随着时间积累可复用的技能。可以理解为开源的 Managed Agents 基础设施——厂商中立、可自部署、专为人类 + AI 团队设计。支持 **Claude Code**、**Codex**、**OpenClaw**、**OpenCode**、**Hermes**、**Gemini**、**Pi** 和 **Cursor Agent**。
 
 <p align="center">
   <img src="docs/assets/hero-screenshot.png" alt="Multica 看板视图" width="800">
 </p>
 
-## 为什么叫 "Multica"？
-
-Multica——**Mul**tiplexed **I**nformation and **C**omputing **A**gent。
-
-这个名字是在向 20 世纪 60 年代具有开创意义的操作系统 Multics 致意。Multics 首创了分时系统，让多个用户能够共享同一台机器，同时又像各自独占它一样使用。Unix 则是在有意简化 Multics 的基础上诞生的，强调一个用户、一个任务、一种优雅的哲学。
-
-我们认为，类似的转折点正在再次出现。几十年来，软件团队一直处于一种单线程的工作模式，一个工程师处理一个任务，一次只专注于一个上下文。AI agents 改变了这个等式。Multica 将"分时"重新带回这个时代，只不过今天在系统中进行多路复用的"用户"，既包括人类，也包括自主代理。
-
-在 Multica 中，agents 是一级团队成员。它们会被分配 issue，汇报进展，提出阻塞，并交付代码，就像人类同事一样。任务分配、活动时间线、任务生命周期，以及运行时基础设施，Multica 从第一天起就是围绕这一理念构建的。
-
-和当年的 Multics 一样，这一判断建立在"多路复用"之上。一个小团队不该因为人数少就显得能力有限。有了合适的系统，两名工程师加上一组 agents，就能发挥出二十人团队的推进速度。
-
 ## 功能特性
 
 Multica 管理完整的 Agent 生命周期：从任务分配到执行监控再到技能复用。
@@ -111,7 +99,7 @@ multica setup          # 连接 Multica Cloud，登录，启动 daemon
 multica setup           # 配置、认证、启动 daemon（一条命令搞定）
 ```
 
-daemon 在后台运行，保持你的机器与 Multica 的连接。它会自动检测 PATH 中可用的 Agent CLI（`claude`、`codex`、`copilot`、`openclaw`、`opencode`、`hermes`、`gemini`、`pi`、`cursor-agent`、`kimi`、`kiro-cli`）。
+daemon 在后台运行，保持你的机器与 Multica 的连接。它会自动检测 PATH 中可用的 Agent CLI（`claude`、`codex`、`openclaw`、`opencode`、`hermes`、`gemini`、`pi`、`cursor-agent`）。
 
 ### 2. 确认运行时已连接
 
@@ -121,7 +109,7 @@ daemon 在后台运行，保持你的机器与 Multica 的连接。它会自动
 
 ### 3. 创建 Agent
 
-进入 **设置 → Agents**，点击 **新建 Agent**。选择你刚连接的 Runtime，选择 Provider（Claude Code、Codex、GitHub Copilot CLI、OpenClaw、OpenCode、Hermes、Gemini、Pi、Cursor Agent、Kimi 或 Kiro CLI），并为 Agent 起个名字——它将以这个名字出现在看板、评论和任务分配中。
+进入 **设置 → Agents**，点击 **新建 Agent**。选择你刚连接的 Runtime，选择 Provider（Claude Code、Codex、OpenClaw、OpenCode、Hermes、Gemini、Pi 或 Cursor Agent），并为 Agent 起个名字——它将以这个名字出现在看板、评论和任务分配中。
 
 ### 4. 分配你的第一个任务
 
@@ -154,9 +142,9 @@ daemon 在后台运行，保持你的机器与 Multica 的连接。它会自动
                             │
                      ┌──────┴───────┐
                      │ Agent Daemon │  运行在你的机器上
-                     └──────────────┘  （Claude Code、Codex、GitHub Copilot CLI、
-                                        OpenCode、OpenClaw、Hermes、Gemini、
-                                        Pi、Cursor Agent、Kimi、Kiro CLI）
+                     └──────────────┘  （Claude Code、Codex、OpenCode、
+                                        OpenClaw、Hermes、Gemini、
+                                        Pi、Cursor Agent）
 ```
 
 | 层级 | 技术栈 |
@@ -164,7 +152,7 @@ daemon 在后台运行，保持你的机器与 Multica 的连接。它会自动
 | 前端 | Next.js 16 (App Router) |
 | 后端 | Go (Chi router, sqlc, gorilla/websocket) |
 | 数据库 | PostgreSQL 17 with pgvector |
-| Agent 运行时 | 本地 daemon 执行 Claude Code、Codex、GitHub Copilot CLI、OpenClaw、OpenCode、Hermes、Gemini、Pi、Cursor Agent、Kimi 或 Kiro CLI |
+| Agent 运行时 | 本地 daemon 执行 Claude Code、Codex、OpenClaw、OpenCode、Hermes、Gemini、Pi 或 Cursor Agent |
 
 ## 开发
 

SELF_HOSTING.md

@@ -92,7 +92,6 @@ brew install multica-ai/tap/multica
 You also need at least one AI agent CLI installed:
 - [Claude Code](https://docs.anthropic.com/en/docs/claude-code) (`claude` on PATH)
 - [Codex](https://github.com/openai/codex) (`codex` on PATH)
-- [GitHub Copilot CLI](https://docs.github.com/en/copilot) (`copilot` on PATH)
 - [OpenClaw](https://github.com/openclaw/openclaw) (`openclaw` on PATH)
 - [OpenCode](https://github.com/anomalyco/opencode) (`opencode` on PATH)
 - [Hermes](https://github.com/NousResearch/hermes) (`hermes` on PATH)

SELF_HOSTING_ADVANCED.md

@@ -56,15 +56,13 @@ Changes take effect after restarting the backend / compose stack. The web UI rea
 
 ### File Storage (Optional)
 
-For file uploads and attachments, configure S3 and (optionally) CloudFront:
+For file uploads and attachments, configure S3 and CloudFront:
 
 | Variable | Description |
 |----------|-------------|
-| `S3_BUCKET` | Bucket name only (e.g. `my-bucket`). Do **not** include the `.s3.<region>.amazonaws.com` suffix — the server constructs the public URL from `S3_BUCKET` + `S3_REGION` |
-| `S3_REGION` | AWS region (default: `us-west-2`). Must match the bucket's actual region — used for both SDK signing and public URLs |
-| `AWS_ACCESS_KEY_ID` / `AWS_SECRET_ACCESS_KEY` | Static credentials. When both are unset, the AWS SDK default credential chain is used |
-| `AWS_ENDPOINT_URL` | Custom S3-compatible endpoint (e.g. MinIO, R2, B2). Setting this switches the public URL to path-style |
-| `CLOUDFRONT_DOMAIN` | CloudFront distribution domain — when set, public URLs use this host instead of the S3 host |
+| `S3_BUCKET` | S3 bucket name |
+| `S3_REGION` | AWS region (default: `us-west-2`) |
+| `CLOUDFRONT_DOMAIN` | CloudFront distribution domain |
 | `CLOUDFRONT_KEY_PAIR_ID` | CloudFront key pair ID for signed URLs |
 | `CLOUDFRONT_PRIVATE_KEY` | CloudFront private key (PEM format) |
 
@@ -105,8 +103,6 @@ Agent-specific overrides:
 | `MULTICA_CLAUDE_MODEL` | Override the Claude model used |
 | `MULTICA_CODEX_PATH` | Custom path to the `codex` binary |
 | `MULTICA_CODEX_MODEL` | Override the Codex model used |
-| `MULTICA_COPILOT_PATH` | Custom path to the `copilot` (GitHub Copilot CLI) binary |
-| `MULTICA_COPILOT_MODEL` | Override the Copilot model used (note: GitHub Copilot routes models through your account entitlement, so this may not be honoured) |
 | `MULTICA_OPENCODE_PATH` | Custom path to the `opencode` binary |
 | `MULTICA_OPENCODE_MODEL` | Override the OpenCode model used |
 | `MULTICA_OPENCLAW_PATH` | Custom path to the `openclaw` binary |

apps/desktop/.env.production

@@ -0,0 +1,12 @@
+# Production environment for `pnpm package` / `pnpm build`.
+# electron-vite (Vite under the hood) reads this automatically in
+# production mode and inlines the values into the renderer bundle via
+# import.meta.env.VITE_*. These are public URLs, not secrets.
+
+# Backend API + websocket the desktop app talks to.
+VITE_API_URL=https://api.multica.ai
+VITE_WS_URL=wss://api.multica.ai/ws
+
+# Public web app URL — used to build shareable links like "Copy link to
+# issue" that users paste into Slack / messages. See platform/navigation.tsx.
+VITE_APP_URL=https://multica.ai

apps/desktop/src/main/app-version.ts

@@ -1,33 +0,0 @@
-import { app } from "electron";
-import { execSync } from "node:child_process";
-
-/**
- * Resolve the running app version. In packaged builds this is the value
- * `electron-builder` baked into package.json via `extraMetadata.version`
- * (driven by `git describe` — see `apps/desktop/scripts/package.mjs`), so
- * `app.getVersion()` matches the GitHub Release tag exactly.
- *
- * In dev (`pnpm dev:desktop`) `app.getVersion()` only sees the static
- * `apps/desktop/package.json` value, which is "0.1.0" and never bumped —
- * the Settings → Updates panel and any other UI surfacing the version
- * would mislead developers into thinking they're running ancient builds.
- * Fall back to `git describe --tags --always --dirty` (same source the
- * packager uses) so dev shows e.g. `0.2.19-14-gabcdef-dirty`. If git is
- * unavailable for whatever reason, we just return the package.json value.
- */
-export function getAppVersion(): string {
-  if (app.isPackaged) {
-    return app.getVersion();
-  }
-  try {
-    const raw = execSync("git describe --tags --always --dirty", {
-      cwd: app.getAppPath(),
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-    if (!raw) return app.getVersion();
-    return raw.replace(/^v/, "");
-  } catch {
-    return app.getVersion();
-  }
-}

apps/desktop/src/main/index.ts

@@ -7,9 +7,6 @@ import { setupAutoUpdater } from "./updater";
 import { setupDaemonManager } from "./daemon-manager";
 import { openExternalSafely } from "./external-url";
 import { installContextMenu } from "./context-menu";
-import { getAppVersion } from "./app-version";
-import { loadRuntimeConfig } from "./runtime-config-loader";
-import type { RuntimeConfigResult } from "../shared/runtime-config";
 
 // Bundled icon used for dev-mode dock/taskbar branding. In production the
 // app bundle icon (from electron-builder) wins; this path is only consumed
@@ -39,10 +36,6 @@ if (process.platform !== "win32") {
 const PROTOCOL = "multica";
 
 let mainWindow: BrowserWindow | null = null;
-let runtimeConfigResult: RuntimeConfigResult = {
-  ok: false,
-  error: { message: "Runtime config has not loaded yet" },
-};
 
 // --- Deep link helpers ---------------------------------------------------
 
@@ -78,25 +71,7 @@ function handleDeepLink(url: string): void {
 
 // --- Window creation -----------------------------------------------------
 
-// Tracks the OS-preferred language as last seen by the running process.
-// Updated on each window-focus check so we can emit a `locale:system-changed`
-// event to the renderer when the user changes their OS language without
-// quitting the app — without restart, app.getPreferredSystemLanguages()
-// would still report the boot value forever.
-let lastKnownSystemLocale = "en";
-
-function getSystemLocale(): string {
-  return app.getPreferredSystemLanguages()[0] ?? "en";
-}
-
 function createWindow(): void {
-  // Pass the OS-preferred language to the renderer via additionalArguments
-  // instead of a sync IPC call. process.argv is available to the preload
-  // script before the first network request, so the renderer's i18next
-  // instance can initialize with the right locale on the very first paint.
-  const systemLocale = getSystemLocale();
-  lastKnownSystemLocale = systemLocale;
-
   mainWindow = new BrowserWindow({
     width: 1280,
     height: 800,
@@ -113,7 +88,6 @@ function createWindow(): void {
       preload: join(__dirname, "../preload/index.js"),
       sandbox: false,
       webSecurity: false,
-      additionalArguments: [`--multica-locale=${systemLocale}`],
     },
   });
 
@@ -131,39 +105,11 @@ function createWindow(): void {
     mainWindow?.show();
   });
 
-  // Detect OS language changes while the app is running. Electron has no
-  // dedicated event for this on any platform, so we poll on focus regain —
-  // catches the common case where users switch System Settings → Language
-  // and bring the app back. The renderer decides whether to act (it ignores
-  // the signal when the user has an explicit Settings choice).
-  mainWindow.on("focus", () => {
-    const current = getSystemLocale();
-    if (current === lastKnownSystemLocale) return;
-    lastKnownSystemLocale = current;
-    mainWindow?.webContents.send("locale:system-changed", current);
-  });
-
   mainWindow.webContents.setWindowOpenHandler((details) => {
     openExternalSafely(details.url);
     return { action: "deny" };
   });
 
-  // Prevent Cmd+R / Ctrl+R / Shift+Cmd+R / Shift+Ctrl+R / F5 from
-  // reloading the page. In a desktop app an accidental reload destroys
-  // in-memory state (tabs, drafts, WS connections) with no URL bar to
-  // navigate back. DevTools refresh (via the DevTools UI) still works.
-  mainWindow.webContents.on("before-input-event", (_event, input) => {
-    if (input.type !== "keyDown") return;
-    const cmdOrCtrl =
-      process.platform === "darwin" ? input.meta : input.control;
-    if (
-      (cmdOrCtrl && input.key.toLowerCase() === "r") ||
-      input.key === "F5"
-    ) {
-      _event.preventDefault();
-    }
-  });
-
   installContextMenu(mainWindow.webContents);
 
   if (is.dev && process.env["ELECTRON_RENDERER_URL"]) {
@@ -224,25 +170,7 @@ if (!gotTheLock) {
     if (deepLinkUrl) handleDeepLink(deepLinkUrl);
   });
 
-  app.whenReady().then(async () => {
-    const viteEnv = import.meta.env as ImportMetaEnv & {
-      readonly VITE_API_URL?: string;
-      readonly VITE_WS_URL?: string;
-      readonly VITE_APP_URL?: string;
-    };
-
-    runtimeConfigResult = await loadRuntimeConfig({
-      isDev: is.dev,
-      // electron-vite exposes VITE_* on import.meta.env for the main process;
-      // keep dev URL overrides on the same source the renderer used before
-      // runtime config moved endpoint resolution into main/preload.
-      env: {
-        apiUrl: viteEnv.VITE_API_URL,
-        wsUrl: viteEnv.VITE_WS_URL,
-        appUrl: viteEnv.VITE_APP_URL,
-      },
-    });
-
+  app.whenReady().then(() => {
     electronApp.setAppUserModelId(
       is.dev ? "ai.multica.desktop.dev" : "ai.multica.desktop",
     );
@@ -275,14 +203,7 @@ if (!gotTheLock) {
     ipcMain.on("app:get-info", (event) => {
       const p = process.platform;
       const os = p === "darwin" ? "macos" : p === "win32" ? "windows" : p === "linux" ? "linux" : "unknown";
-      event.returnValue = { version: getAppVersion(), os };
-    });
-
-    // Sync IPC: preload exposes the validated runtime config before renderer
-    // boot. If desktop.json exists but is invalid, renderer receives the
-    // blocking error and must not silently fall back to the cloud defaults.
-    ipcMain.on("runtime-config:get", (event) => {
-      event.returnValue = runtimeConfigResult;
+      event.returnValue = { version: app.getVersion(), os };
     });
 
     // IPC: toggle immersive mode — hides the macOS traffic lights so full-screen

apps/desktop/src/main/runtime-config-loader.test.ts

@@ -1,90 +0,0 @@
-import { mkdtemp, writeFile } from "fs/promises";
-import { join } from "path";
-import { tmpdir } from "os";
-import { describe, expect, it } from "vitest";
-import { loadRuntimeConfig } from "./runtime-config-loader";
-
-describe("loadRuntimeConfig", () => {
-  it("uses dev env and ignores desktop.json during electron-vite dev", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "multica-desktop-config-"));
-    const configPath = join(dir, "desktop.json");
-    await writeFile(
-      configPath,
-      JSON.stringify({ schemaVersion: 1, apiUrl: "https://prod.example.com" }),
-    );
-
-    await expect(
-      loadRuntimeConfig({
-        isDev: true,
-        configPath,
-        env: {
-          apiUrl: "http://localhost:8080",
-          wsUrl: "ws://localhost:8080/ws",
-          appUrl: "http://localhost:3000",
-        },
-      }),
-    ).resolves.toEqual({
-      ok: true,
-      config: {
-        schemaVersion: 1,
-        apiUrl: "http://localhost:8080",
-        wsUrl: "ws://localhost:8080/ws",
-        appUrl: "http://localhost:3000",
-      },
-    });
-  });
-
-  it("uses cloud defaults when packaged config is absent", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "multica-desktop-config-"));
-    await expect(
-      loadRuntimeConfig({
-        isDev: false,
-        configPath: join(dir, "missing.json"),
-        env: {},
-      }),
-    ).resolves.toEqual({
-      ok: true,
-      config: {
-        schemaVersion: 1,
-        apiUrl: "https://api.multica.ai",
-        wsUrl: "wss://api.multica.ai/ws",
-        appUrl: "https://multica.ai",
-      },
-    });
-  });
-
-  it("parses a valid packaged desktop.json", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "multica-desktop-config-"));
-    const configPath = join(dir, "desktop.json");
-    await writeFile(
-      configPath,
-      JSON.stringify({ schemaVersion: 1, apiUrl: "https://api.example.com" }),
-    );
-
-    await expect(
-      loadRuntimeConfig({ isDev: false, configPath, env: {} }),
-    ).resolves.toEqual({
-      ok: true,
-      config: {
-        schemaVersion: 1,
-        apiUrl: "https://api.example.com",
-        wsUrl: "wss://api.example.com/ws",
-        appUrl: "https://api.example.com",
-      },
-    });
-  });
-
-  it("fails closed when packaged desktop.json is invalid", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "multica-desktop-config-"));
-    const configPath = join(dir, "desktop.json");
-    await writeFile(configPath, "{");
-
-    const result = await loadRuntimeConfig({ isDev: false, configPath, env: {} });
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.message).toContain(configPath);
-      expect(result.error.message).toContain("Invalid desktop runtime config JSON");
-    }
-  });
-});

apps/desktop/src/main/runtime-config-loader.ts

@@ -1,60 +0,0 @@
-import { app } from "electron";
-import { readFile } from "fs/promises";
-import { join } from "path";
-import {
-  DEFAULT_RUNTIME_CONFIG,
-  parseRuntimeConfig,
-  runtimeConfigFromDevEnv,
-  type RuntimeConfig,
-  type RuntimeConfigEnv,
-  type RuntimeConfigResult,
-} from "../shared/runtime-config";
-
-export async function loadRuntimeConfig(options: {
-  isDev: boolean;
-  env: RuntimeConfigEnv;
-  configPath?: string;
-}): Promise<RuntimeConfigResult> {
-  if (options.isDev) {
-    try {
-      return { ok: true, config: runtimeConfigFromDevEnv(options.env) };
-    } catch (err) {
-      return { ok: false, error: { message: errorMessage(err) } };
-    }
-  }
-
-  const configPath = options.configPath ?? desktopConfigPath();
-  try {
-    const raw = await readFile(configPath, "utf-8");
-    return { ok: true, config: parseRuntimeConfig(raw) };
-  } catch (err) {
-    if (isMissingFileError(err)) {
-      return { ok: true, config: { ...DEFAULT_RUNTIME_CONFIG } };
-    }
-    return {
-      ok: false,
-      error: {
-        message: `Invalid ${configPath}: ${errorMessage(err)}`,
-      },
-    };
-  }
-}
-
-export function desktopConfigPath(): string {
-  return join(app.getPath("home"), ".multica", "desktop.json");
-}
-
-function isMissingFileError(err: unknown): boolean {
-  return Boolean(
-    err &&
-      typeof err === "object" &&
-      "code" in err &&
-      (err as NodeJS.ErrnoException).code === "ENOENT",
-  );
-}
-
-function errorMessage(err: unknown): string {
-  return err instanceof Error ? err.message : String(err);
-}
-
-export type { RuntimeConfig, RuntimeConfigResult };

apps/desktop/src/preload/index.d.ts

@@ -1,5 +1,4 @@
 import { ElectronAPI } from "@electron-toolkit/preload";
-import type { RuntimeConfigResult } from "../shared/runtime-config";
 
 interface DesktopAPI {
   /** App version + normalized OS, captured synchronously at preload time. */
@@ -7,12 +6,6 @@ interface DesktopAPI {
     version: string;
     os: "macos" | "windows" | "linux" | "unknown";
   };
-  /** OS-preferred locale (BCP 47) injected by main via additionalArguments. */
-  systemLocale: string;
-  /** Subscribe to OS language changes detected after boot. Returns an unsubscribe function. */
-  onSystemLocaleChanged: (callback: (locale: string) => void) => () => void;
-  /** Validated runtime endpoint config, or a blocking config error. */
-  runtimeConfig: RuntimeConfigResult;
   /** Listen for auth token delivered via deep link. Returns an unsubscribe function. */
   onAuthToken: (callback: (token: string) => void) => () => void;
   /** Listen for invitation IDs delivered via deep link. Returns an unsubscribe function. */

apps/desktop/src/preload/index.ts

@@ -1,6 +1,5 @@
 import { contextBridge, ipcRenderer } from "electron";
 import { electronAPI } from "@electron-toolkit/preload";
-import type { RuntimeConfigResult } from "../shared/runtime-config";
 
 // Synchronously fetch app metadata from main at preload time so the renderer
 // can pass it into CoreProvider during the initial render — the alternative
@@ -22,53 +21,12 @@ function fetchAppInfo(): { version: string; os: "macos" | "windows" | "linux" |
   return { version: "unknown", os };
 }
 
-function fetchRuntimeConfig(): RuntimeConfigResult {
-  try {
-    const result = ipcRenderer.sendSync("runtime-config:get") as RuntimeConfigResult | undefined;
-    if (result && typeof result === "object" && "ok" in result) return result;
-  } catch (err) {
-    return {
-      ok: false,
-      error: {
-        message: err instanceof Error ? err.message : String(err),
-      },
-    };
-  }
-  return { ok: false, error: { message: "Runtime config unavailable" } };
-}
-
 const appInfo = fetchAppInfo();
-const runtimeConfig = fetchRuntimeConfig();
-
-// Read the OS-preferred locale that main injected via additionalArguments.
-// Zero IPC, zero blocking — process.argv is populated before preload runs.
-function fetchSystemLocale(): string {
-  const arg = process.argv.find((a) => a.startsWith("--multica-locale="));
-  return arg?.split("=")[1] ?? "en";
-}
-
-const systemLocale = fetchSystemLocale();
 
 const desktopAPI = {
   /** App version + normalized OS. Read once at preload time so the renderer
    *  can use it synchronously when initializing the API client. */
   appInfo,
-  /** OS-preferred locale (BCP 47), passed from main via additionalArguments.
-   *  Used by the renderer's LocaleAdapter as the system-preference signal. */
-  systemLocale,
-  /** Subscribe to OS language changes detected after boot. The renderer
-   *  decides whether to act (no-op when the user has an explicit Settings
-   *  choice). Returns an unsubscribe function. */
-  onSystemLocaleChanged: (callback: (locale: string) => void) => {
-    const handler = (_event: Electron.IpcRendererEvent, locale: string) =>
-      callback(locale);
-    ipcRenderer.on("locale:system-changed", handler);
-    return () => {
-      ipcRenderer.removeListener("locale:system-changed", handler);
-    };
-  },
-  /** Validated runtime endpoint config, or a blocking config error. */
-  runtimeConfig,
   /** Listen for auth token delivered via deep link */
   onAuthToken: (callback: (token: string) => void) => {
     const handler = (_event: Electron.IpcRendererEvent, token: string) =>

apps/desktop/src/renderer/src/App.tsx

@@ -1,14 +1,13 @@
 import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { CoreProvider } from "@multica/core/platform";
-import { pickLocale } from "@multica/core/i18n";
 import { useAuthStore } from "@multica/core/auth";
 import { workspaceKeys, workspaceListOptions } from "@multica/core/workspace/queries";
 import { api } from "@multica/core/api";
 import { useHasOnboarded } from "@multica/core/paths";
 import { ThemeProvider } from "@multica/ui/components/common/theme-provider";
 import { MulticaIcon } from "@multica/ui/components/common/multica-icon";
-import { Toaster } from "@multica/ui/components/ui/sonner";
+import { Toaster } from "sonner";
 import { DesktopLoginPage } from "./pages/login";
 import { DesktopShell } from "./components/desktop-layout";
 import { PageviewTracker } from "./components/pageview-tracker";
@@ -16,8 +15,6 @@ import { UpdateNotification } from "./components/update-notification";
 import { useTabStore } from "./stores/tab-store";
 import { useWindowOverlayStore } from "./stores/window-overlay-store";
 import { useDaemonIPCBridge } from "./platform/daemon-ipc-bridge";
-import { createDesktopLocaleAdapter } from "./platform/i18n-adapter";
-import { RESOURCES } from "@multica/views/locales";
 
 
 function AppContent() {
@@ -33,16 +30,11 @@ function AppContent() {
   // first render.
   const [bootstrapping, setBootstrapping] = useState(false);
 
-  const runtimeConfig = window.desktopAPI.runtimeConfig.ok
-    ? window.desktopAPI.runtimeConfig.config
-    : null;
-
   // Tell the main process which backend URL we talk to, so daemon-manager
   // can pick the matching CLI profile (server_url from ~/.multica config).
   useEffect(() => {
-    if (!runtimeConfig) return;
-    window.daemonAPI.setTargetApiUrl(runtimeConfig.apiUrl);
-  }, [runtimeConfig]);
+    window.daemonAPI.setTargetApiUrl(DAEMON_TARGET_API_URL);
+  }, []);
 
   // Listen for invite IDs delivered via deep link (multica://invite/<id>).
   // We open the overlay regardless of login state — if the user isn't logged
@@ -118,58 +110,21 @@ function AppContent() {
     : undefined;
   useDaemonIPCBridge(activeWsId);
 
-  // Pre-workspace overlay routing for desktop. Mirrors the web entry-point
-  // judgment in callback / login:
-  //   un-onboarded:
-  //     pending invites on email → /invitations overlay
-  //     no invites               → /onboarding overlay
-  //   already onboarded:
-  //     zero workspaces          → /workspaces/new overlay
-  //     ≥1 workspaces            → no overlay, fall through to dashboard
-  //
-  // The "un-onboarded but in workspace" state is now physically impossible
-  // because backend transactions atomically set onboarded_at when a user
-  // joins the `member` table. Anyone with workspaces is by definition
-  // onboarded.
+  // Onboarding and zero-workspace both resolve to an overlay, but
+  // onboarding wins: a user who hasn't completed it gets the onboarding
+  // overlay regardless of how many workspaces already exist.
   useEffect(() => {
-    if (!user || !workspaceListFetched) return undefined;
+    if (!user || !workspaceListFetched) return;
     const { overlay, open } = useWindowOverlayStore.getState();
-    if (overlay) return undefined;
-    if (wsCount > 0) return undefined;
+    if (overlay) return;
     if (!hasOnboarded) {
-      // Look up pending invitations by email. Network blip is non-fatal —
-      // fall through to onboarding so the user isn't stuck on a blank
-      // window. The sidebar's pending-invitations dropdown will surface
-      // missed invites later once they're onboarded.
-      let cancelled = false;
-      void api
-        .listMyInvitations()
-        .then((invites) => {
-          if (cancelled) return;
-          const { overlay: latestOverlay, open: latestOpen } =
-            useWindowOverlayStore.getState();
-          if (latestOverlay) return;
-          if (invites.length > 0) {
-            qc.setQueryData(workspaceKeys.myInvitations(), invites);
-            latestOpen({ type: "invitations" });
-          } else {
-            latestOpen({ type: "onboarding" });
-          }
-        })
-        .catch(() => {
-          if (cancelled) return;
-          const { overlay: latestOverlay, open: latestOpen } =
-            useWindowOverlayStore.getState();
-          if (latestOverlay) return;
-          latestOpen({ type: "onboarding" });
-        });
-      return () => {
-        cancelled = true;
-      };
+      open({ type: "onboarding" });
+      return;
     }
-    open({ type: "new-workspace" });
-    return undefined;
-  }, [user, workspaceListFetched, wsCount, workspaces, hasOnboarded, qc]);
+    if (wsCount === 0) {
+      open({ type: "new-workspace" });
+    }
+  }, [user, workspaceListFetched, wsCount, workspaces, hasOnboarded]);
 
   // Validate persisted tab state against the current user's workspace list,
   // and pick an active workspace if none is set. Runs in useLayoutEffect
@@ -234,21 +189,9 @@ function AppContent() {
   );
 }
 
-function BlockingRuntimeConfigError({ message }: { message: string }) {
-  return (
-    <div className="flex h-screen items-center justify-center bg-background p-8 text-foreground">
-      <div className="max-w-xl rounded-lg border bg-card p-6 shadow-sm">
-        <h1 className="text-lg font-semibold">Desktop configuration error</h1>
-        <p className="mt-3 text-sm text-muted-foreground">
-          Multica Desktop could not load <code>~/.multica/desktop.json</code>. Fix or remove the file and restart the app.
-        </p>
-        <pre className="mt-4 whitespace-pre-wrap rounded-md bg-muted p-3 text-xs text-muted-foreground">
-          {message}
-        </pre>
-      </div>
-    </div>
-  );
-}
+// Backend the daemon should connect to — same URL the renderer talks to.
+const DAEMON_TARGET_API_URL =
+  import.meta.env.VITE_API_URL || "http://localhost:8080";
 
 // On logout, wipe desktop-only in-memory state and stop the daemon so that
 // a subsequent login as a different user never inherits the previous user's
@@ -272,61 +215,22 @@ async function handleDaemonLogout() {
 
 export default function App() {
   const { version, os } = window.desktopAPI.appInfo;
-  const systemLocale = window.desktopAPI.systemLocale;
-  const runtimeConfigResult = window.desktopAPI.runtimeConfig;
   // Stable identity reference so downstream effects (WS reconnect) don't
   // tear down on every parent render.
   const identity = useMemo(
     () => ({ platform: "desktop", version, os }),
     [version, os],
   );
-  // Locale resolution happens once at app boot. Switching language goes
-  // through window.location.reload() to avoid hydration mismatch.
-  const localeAdapter = useMemo(
-    () => createDesktopLocaleAdapter(systemLocale),
-    [systemLocale],
-  );
-  const locale = useMemo(() => pickLocale(localeAdapter), [localeAdapter]);
-  const resources = useMemo(
-    () => ({ [locale]: RESOURCES[locale] }),
-    [locale],
-  );
-
-  // React to OS-level language changes detected by main on focus regain.
-  // Only act when the user is following the system signal (no explicit
-  // Settings choice) — otherwise their preference wins. Cross-device sync
-  // for the explicit-choice case is handled inside CoreProvider.
-  useEffect(() => {
-    return window.desktopAPI.onSystemLocaleChanged((nextSystemLocale) => {
-      if (localeAdapter.getUserChoice()) return;
-      const next = pickLocale({
-        ...localeAdapter,
-        getSystemPreferences: () =>
-          nextSystemLocale ? [nextSystemLocale] : [],
-      });
-      if (next === locale) return;
-      localeAdapter.persist(next);
-      window.location.reload();
-    });
-  }, [localeAdapter, locale]);
-
   return (
     <ThemeProvider>
-      {runtimeConfigResult.ok ? (
-        <CoreProvider
-          apiBaseUrl={runtimeConfigResult.config.apiUrl}
-          wsUrl={runtimeConfigResult.config.wsUrl}
-          onLogout={handleDaemonLogout}
-          identity={identity}
-          locale={locale}
-          resources={resources}
-          localeAdapter={localeAdapter}
-        >
-          <AppContent />
-        </CoreProvider>
-      ) : (
-        <BlockingRuntimeConfigError message={runtimeConfigResult.error.message} />
-      )}
+      <CoreProvider
+        apiBaseUrl={import.meta.env.VITE_API_URL || "http://localhost:8080"}
+        wsUrl={import.meta.env.VITE_WS_URL || "ws://localhost:8080/ws"}
+        onLogout={handleDaemonLogout}
+        identity={identity}
+      >
+        <AppContent />
+      </CoreProvider>
       <Toaster />
       <UpdateNotification />
     </ThemeProvider>

apps/desktop/src/renderer/src/components/pageview-tracker.test.tsx

@@ -1,243 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { render } from "@testing-library/react";
-
-// vi.hoisted shared state — every store mock reads the same object so each
-// test can mutate it then re-render to drive the tracker.
-const state = vi.hoisted(() => ({
-  user: null as { id: string } | null,
-  overlay: null as { type: string; invitationId?: string } | null,
-  activeWorkspaceSlug: null as string | null,
-  byWorkspace: {} as Record<
-    string,
-    { activeTabId: string; tabs: { id: string; path: string }[] }
-  >,
-  capturePageview: vi.fn<(path?: string) => void>(),
-}));
-
-vi.mock("@multica/core/analytics", () => ({
-  capturePageview: state.capturePageview,
-}));
-
-// Auth store — single selector pattern (`s => s.user`).
-vi.mock("@multica/core/auth", () => {
-  const useAuthStore = (selector: (s: typeof state) => unknown) =>
-    selector(state);
-  return { useAuthStore };
-});
-
-// Window overlay store — same shape.
-vi.mock("@/stores/window-overlay-store", () => {
-  const useWindowOverlayStore = (selector: (s: typeof state) => unknown) =>
-    selector(state);
-  return { useWindowOverlayStore };
-});
-
-// Tab store — selectors read activeWorkspaceSlug + byWorkspace. Also expose
-// getState() for the seed pass and the helpers the tracker imports
-// (useActiveTabIdentity, getActiveTab) so we don't have to re-import them
-// from the real store inside a mocked module.
-vi.mock("@/stores/tab-store", () => {
-  const useTabStore = Object.assign(
-    (selector: (s: typeof state) => unknown) => selector(state),
-    { getState: () => state },
-  );
-  const getActiveTab = (s: typeof state) => {
-    const slug = s.activeWorkspaceSlug;
-    if (!slug) return null;
-    const group = s.byWorkspace[slug];
-    if (!group) return null;
-    return group.tabs.find((t) => t.id === group.activeTabId) ?? null;
-  };
-  const useActiveTabIdentity = () => ({
-    slug: state.activeWorkspaceSlug,
-    tabId: state.activeWorkspaceSlug
-      ? (state.byWorkspace[state.activeWorkspaceSlug]?.activeTabId ?? null)
-      : null,
-  });
-  return { useTabStore, getActiveTab, useActiveTabIdentity };
-});
-
-import { PageviewTracker } from "./pageview-tracker";
-
-function reset() {
-  state.user = { id: "u1" };
-  state.overlay = null;
-  state.activeWorkspaceSlug = null;
-  state.byWorkspace = {};
-  state.capturePageview.mockClear();
-}
-
-beforeEach(() => {
-  reset();
-});
-
-describe("PageviewTracker", () => {
-  it("suppresses pageview when switching to a previously-visible tab on its existing path", () => {
-    state.byWorkspace = {
-      acme: {
-        activeTabId: "tA",
-        tabs: [
-          { id: "tA", path: "/acme/issues" },
-          { id: "tB", path: "/acme/inbox" },
-        ],
-      },
-    };
-    state.activeWorkspaceSlug = "acme";
-
-    const { rerender } = render(<PageviewTracker />);
-    // Initial mount on tA — seeded as observed, no pageview because both
-    // tabs were already in the persisted store before the tracker mounted.
-    expect(state.capturePageview).not.toHaveBeenCalled();
-
-    // Switch to tB (already-known tab on its already-known path).
-    state.byWorkspace = {
-      acme: {
-        activeTabId: "tB",
-        tabs: [
-          { id: "tA", path: "/acme/issues" },
-          { id: "tB", path: "/acme/inbox" },
-        ],
-      },
-    };
-    rerender(<PageviewTracker />);
-    expect(state.capturePageview).not.toHaveBeenCalled();
-
-    // Switch back to tA — still no pageview.
-    state.byWorkspace = {
-      acme: {
-        activeTabId: "tA",
-        tabs: [
-          { id: "tA", path: "/acme/issues" },
-          { id: "tB", path: "/acme/inbox" },
-        ],
-      },
-    };
-    rerender(<PageviewTracker />);
-    expect(state.capturePageview).not.toHaveBeenCalled();
-  });
-
-  it("fires pageview when a new tab is opened (openInNewTab / addTab)", () => {
-    state.byWorkspace = {
-      acme: {
-        activeTabId: "tA",
-        tabs: [{ id: "tA", path: "/acme/issues" }],
-      },
-    };
-    state.activeWorkspaceSlug = "acme";
-
-    const { rerender } = render(<PageviewTracker />);
-    state.capturePageview.mockClear();
-
-    // Simulate openInNewTab("/acme/agents") → new tab tC added and activated.
-    state.byWorkspace = {
-      acme: {
-        activeTabId: "tC",
-        tabs: [
-          { id: "tA", path: "/acme/issues" },
-          { id: "tC", path: "/acme/agents" },
-        ],
-      },
-    };
-    rerender(<PageviewTracker />);
-
-    expect(state.capturePageview).toHaveBeenCalledTimes(1);
-    expect(state.capturePageview).toHaveBeenCalledWith("/acme/agents");
-  });
-
-  it("fires pageview when switchWorkspace opens a new path in another workspace", () => {
-    state.byWorkspace = {
-      acme: {
-        activeTabId: "tA",
-        tabs: [{ id: "tA", path: "/acme/issues" }],
-      },
-    };
-    state.activeWorkspaceSlug = "acme";
-
-    const { rerender } = render(<PageviewTracker />);
-    state.capturePageview.mockClear();
-
-    // Cross-workspace navigation: switchWorkspace("butter", "/butter/inbox")
-    // creates a fresh tab in the destination workspace and makes it active.
-    state.byWorkspace = {
-      acme: { activeTabId: "tA", tabs: [{ id: "tA", path: "/acme/issues" }] },
-      butter: {
-        activeTabId: "tD",
-        tabs: [{ id: "tD", path: "/butter/inbox" }],
-      },
-    };
-    state.activeWorkspaceSlug = "butter";
-    rerender(<PageviewTracker />);
-
-    expect(state.capturePageview).toHaveBeenCalledTimes(1);
-    expect(state.capturePageview).toHaveBeenCalledWith("/butter/inbox");
-  });
-
-  it("fires pageview on intra-tab navigation (path changes for the same tabId)", () => {
-    state.byWorkspace = {
-      acme: {
-        activeTabId: "tA",
-        tabs: [{ id: "tA", path: "/acme/issues" }],
-      },
-    };
-    state.activeWorkspaceSlug = "acme";
-
-    const { rerender } = render(<PageviewTracker />);
-    state.capturePageview.mockClear();
-
-    state.byWorkspace = {
-      acme: {
-        activeTabId: "tA",
-        tabs: [{ id: "tA", path: "/acme/issues/123" }],
-      },
-    };
-    rerender(<PageviewTracker />);
-
-    expect(state.capturePageview).toHaveBeenCalledTimes(1);
-    expect(state.capturePageview).toHaveBeenCalledWith("/acme/issues/123");
-  });
-
-  it("fires overlay and login pageviews and suppresses re-entry into the same tab afterward", () => {
-    state.byWorkspace = {
-      acme: {
-        activeTabId: "tA",
-        tabs: [{ id: "tA", path: "/acme/issues" }],
-      },
-    };
-    state.activeWorkspaceSlug = "acme";
-
-    const { rerender } = render(<PageviewTracker />);
-    state.capturePageview.mockClear();
-
-    // Open onboarding overlay.
-    state.overlay = { type: "onboarding" };
-    rerender(<PageviewTracker />);
-    expect(state.capturePageview).toHaveBeenLastCalledWith("/onboarding");
-
-    // Close overlay back to the tab — the tab is already observed on
-    // /acme/issues so this is a re-activation, no pageview.
-    state.capturePageview.mockClear();
-    state.overlay = null;
-    rerender(<PageviewTracker />);
-    expect(state.capturePageview).not.toHaveBeenCalled();
-
-    // Logout fires /login.
-    state.user = null;
-    rerender(<PageviewTracker />);
-    expect(state.capturePageview).toHaveBeenLastCalledWith("/login");
-  });
-
-  it("suppresses on initial mount when the active tab was restored from persistence", () => {
-    state.byWorkspace = {
-      acme: {
-        activeTabId: "tA",
-        tabs: [{ id: "tA", path: "/acme/issues" }],
-      },
-    };
-    state.activeWorkspaceSlug = "acme";
-
-    render(<PageviewTracker />);
-    // Restored tab — seeded, treated as a re-activation.
-    expect(state.capturePageview).not.toHaveBeenCalled();
-  });
-});
-

apps/desktop/src/renderer/src/components/pageview-tracker.tsx

@@ -1,17 +1,11 @@
-import { useEffect, useRef } from "react";
+import { useEffect } from "react";
 import { capturePageview } from "@multica/core/analytics";
 import { useAuthStore } from "@multica/core/auth";
-import {
-  getActiveTab,
-  useActiveTabIdentity,
-  useTabStore,
-} from "@/stores/tab-store";
+import { useTabStore } from "@/stores/tab-store";
 import { useWindowOverlayStore, type WindowOverlay } from "@/stores/window-overlay-store";
 
 /**
- * Fires a PostHog $pageview whenever the user's visible surface changes,
- * EXCEPT for re-activations of an already-known tab on its already-known
- * path.
+ * Fires a PostHog $pageview whenever the user's visible surface changes.
  *
  * Desktop has three layers that can own the visible page:
  *
@@ -23,18 +17,10 @@ import { useWindowOverlayStore, type WindowOverlay } from "@/stores/window-overl
  *   3. Otherwise → the active tab's path (workspace-scoped, e.g.
  *      `/acme/issues/123`). Kept in sync by `useTabRouterSync`.
  *
- * Tab-switch suppression: re-activating an already-open tab surfaces a
- * previously-visited path under a `(workspace, tabId)` we have already
- * seen — the pageview was emitted when the user originally navigated
- * there, so re-emitting on every switch just inflates PostHog billing
- * without adding signal (real-data audit: desktop tab switches were
- * ~50% of all `$pageview` events).
- *
- * Newly opened tabs (`openInNewTab`, `addTab`) and cross-workspace
- * `switchWorkspace(slug, path)` to a previously-unseen tab still fire,
- * because their key is not in the observed map yet. The map is seeded
- * from the persisted tab store on first render so tabs restored from a
- * previous session don't all re-emit on first activation.
+ * The overlay takes precedence over the tab path because it is visually in
+ * front of the tab system; the logged-out state shadows both because the
+ * shell doesn't render at all yet. This keeps the `$pageview` stream aligned
+ * with what the user actually sees.
  *
  * PostHog's `capture_pageview: true` auto-capture is intentionally off (see
  * `initAnalytics`) so this component owns the event shape, matching the web
@@ -43,75 +29,34 @@ import { useWindowOverlayStore, type WindowOverlay } from "@/stores/window-overl
 export function PageviewTracker() {
   const user = useAuthStore((s) => s.user);
   const overlay = useWindowOverlayStore((s) => s.overlay);
-  const { slug: activeWorkspaceSlug, tabId: activeTabId } = useActiveTabIdentity();
-  const activeTabPath = useTabStore((s) => getActiveTab(s)?.path ?? null);
+  const activeTabPath = useTabStore((s) => {
+    const slug = s.activeWorkspaceSlug;
+    if (!slug) return null;
+    const group = s.byWorkspace[slug];
+    if (!group) return null;
+    return group.tabs.find((t) => t.id === group.activeTabId)?.path ?? null;
+  });
 
-  // (slug:tabId) → last path observed while that tab was visible. Lets us
-  // tell "re-activating a tab on a path we already saw" (suppress) apart
-  // from "newly opened tab" or "intra-tab navigation" (fire). Seeded
-  // synchronously on first render from the persisted tab store so
-  // session-restored tabs don't re-emit on first click.
-  const observedTabsRef = useRef<Map<string, string> | null>(null);
-  if (observedTabsRef.current === null) {
-    const seed = new Map<string, string>();
-    for (const [slug, group] of Object.entries(useTabStore.getState().byWorkspace)) {
-      for (const tab of group.tabs) {
-        seed.set(`${slug}:${tab.id}`, tab.path);
-      }
-    }
-    observedTabsRef.current = seed;
-  }
-  const lastSurfaceRef = useRef<{
-    kind: "login" | "overlay" | "tab" | null;
-    key: string | null;
-    path: string | null;
-  }>({ kind: null, key: null, path: null });
+  const path = resolvePath(user, overlay, activeTabPath);
 
   useEffect(() => {
-    let kind: "login" | "overlay" | "tab";
-    let path: string;
-    let key: string | null = null;
-
-    if (!user) {
-      kind = "login";
-      path = "/login";
-    } else if (overlay) {
-      kind = "overlay";
-      path = overlayPath(overlay);
-    } else if (activeTabPath && activeTabId && activeWorkspaceSlug) {
-      kind = "tab";
-      key = `${activeWorkspaceSlug}:${activeTabId}`;
-      path = activeTabPath;
-    } else {
-      return;
-    }
-
-    const observed = observedTabsRef.current!;
-    const last = lastSurfaceRef.current;
-    const next = { kind, key, path };
-
-    if (kind === "tab" && key !== null) {
-      const knownPath = observed.get(key);
-      const isReactivation =
-        last.key !== key && knownPath !== undefined && knownPath === path;
-      observed.set(key, path);
-      if (isReactivation) {
-        lastSurfaceRef.current = next;
-        return;
-      }
-    }
-
-    const unchanged =
-      last.kind === kind && last.key === key && last.path === path;
-    if (unchanged) return;
-
+    if (!path) return;
     capturePageview(path);
-    lastSurfaceRef.current = next;
-  }, [user, overlay, activeWorkspaceSlug, activeTabId, activeTabPath]);
+  }, [path]);
 
   return null;
 }
 
+function resolvePath(
+  user: unknown,
+  overlay: WindowOverlay | null,
+  activeTabPath: string | null,
+): string | null {
+  if (!user) return "/login";
+  if (overlay) return overlayPath(overlay);
+  return activeTabPath;
+}
+
 function overlayPath(overlay: WindowOverlay): string {
   switch (overlay.type) {
     case "new-workspace":
@@ -120,7 +65,5 @@ function overlayPath(overlay: WindowOverlay): string {
       return "/onboarding";
     case "invite":
       return `/invite/${overlay.invitationId}`;
-    case "invitations":
-      return "/invitations";
   }
 }

apps/desktop/src/renderer/src/components/updates-settings-tab.tsx

@@ -5,13 +5,12 @@ import { Button } from "@multica/ui/components/ui/button";
 type CheckState =
   | { status: "idle" }
   | { status: "checking" }
-  | { status: "up-to-date" }
+  | { status: "up-to-date"; currentVersion: string }
   | { status: "available"; latestVersion: string }
   | { status: "error"; message: string };
 
 export function UpdatesSettingsTab() {
   const [state, setState] = useState<CheckState>({ status: "idle" });
-  const currentVersion = window.desktopAPI.appInfo.version;
 
   const handleCheck = useCallback(async () => {
     setState({ status: "checking" });
@@ -23,7 +22,7 @@ export function UpdatesSettingsTab() {
     setState(
       result.available
         ? { status: "available", latestVersion: result.latestVersion }
-        : { status: "up-to-date" },
+        : { status: "up-to-date", currentVersion: result.currentVersion },
     );
   }, []);
 
@@ -36,15 +35,6 @@ export function UpdatesSettingsTab() {
       </p>
 
       <div className="mt-6 divide-y">
-        <div className="flex items-center justify-between gap-6 py-4">
-          <div className="min-w-0">
-            <p className="text-sm font-medium">Current version</p>
-            <p className="text-sm text-muted-foreground mt-0.5 font-mono">
-              v{currentVersion}
-            </p>
-          </div>
-        </div>
-
         <div className="flex items-start justify-between gap-6 py-4">
           <div className="min-w-0">
             <p className="text-sm font-medium">Check for updates</p>
@@ -55,7 +45,7 @@ export function UpdatesSettingsTab() {
             {state.status === "up-to-date" && (
               <p className="text-sm text-muted-foreground mt-2 inline-flex items-center gap-1.5">
                 <Check className="size-3.5 text-success" />
-                You&apos;re on the latest version.
+                You&apos;re on the latest version (v{state.currentVersion}).
               </p>
             )}
             {state.status === "available" && (

apps/desktop/src/renderer/src/components/window-overlay.tsx

@@ -1,7 +1,6 @@
 import { useQuery } from "@tanstack/react-query";
 import { NewWorkspacePage } from "@multica/views/workspace/new-workspace-page";
 import { InvitePage } from "@multica/views/invite";
-import { InvitationsPage } from "@multica/views/invitations";
 import { OnboardingFlow } from "@multica/views/onboarding";
 import { useNavigation } from "@multica/views/navigation";
 import { paths } from "@multica/core/paths";
@@ -59,7 +58,6 @@ function WindowOverlayInner() {
           onBack={onBack}
         />
       )}
-      {overlay.type === "invitations" && <InvitationsPage />}
       {overlay.type === "onboarding" && (
         <OnboardingFlow
           onComplete={(ws) => {

apps/desktop/src/renderer/src/pages/login.tsx

@@ -2,23 +2,14 @@ import { LoginPage } from "@multica/views/auth";
 import { DragStrip } from "@multica/views/platform";
 import { MulticaIcon } from "@multica/ui/components/common/multica-icon";
 
-function requireRuntimeAppUrl(): string {
-  const runtimeConfig = window.desktopAPI.runtimeConfig;
-  if (!runtimeConfig.ok) {
-    throw new Error(
-      "Invariant violated: DesktopLoginPage rendered before App accepted runtime config",
-    );
-  }
-  return runtimeConfig.config.appUrl;
-}
+const WEB_URL = import.meta.env.VITE_APP_URL || "http://localhost:3000";
 
 export function DesktopLoginPage() {
-  const webUrl = requireRuntimeAppUrl();
   const handleGoogleLogin = () => {
     // Open web login page in the default browser with platform=desktop flag.
     // The web callback will redirect back via multica:// deep link with the token.
     window.desktopAPI.openExternal(
-      `${webUrl}/login?platform=desktop`,
+      `${WEB_URL}/login?platform=desktop`,
     );
   };
 

apps/desktop/src/renderer/src/platform/i18n-adapter.ts

@@ -1,31 +0,0 @@
-import type { LocaleAdapter, SupportedLocale } from "@multica/core/i18n";
-
-const STORAGE_KEY = "multica-locale";
-
-// Desktop adapter:
-//   - User choice: localStorage (set by Settings switcher).
-//   - System preference: locale main injected via additionalArguments
-//     (read from preload, exposed on window.desktopAPI.systemLocale).
-//   - Persist: localStorage. The Settings switcher additionally PATCHes
-//     /api/me when logged in so user.language follows the user across devices.
-export function createDesktopLocaleAdapter(systemLocale: string): LocaleAdapter {
-  return {
-    getUserChoice() {
-      try {
-        return window.localStorage.getItem(STORAGE_KEY);
-      } catch {
-        return null;
-      }
-    },
-    getSystemPreferences() {
-      return systemLocale ? [systemLocale] : [];
-    },
-    persist(locale: SupportedLocale) {
-      try {
-        window.localStorage.setItem(STORAGE_KEY, locale);
-      } catch {
-        // Best-effort
-      }
-    },
-  };
-}

apps/desktop/src/renderer/src/platform/navigation.tsx

@@ -15,15 +15,11 @@ import {
 } from "@/stores/tab-store";
 import { useWindowOverlayStore } from "@/stores/window-overlay-store";
 
-function requireRuntimeAppUrl(scope: string): string {
-  const runtimeConfig = window.desktopAPI.runtimeConfig;
-  if (!runtimeConfig.ok) {
-    throw new Error(
-      `Invariant violated: ${scope} rendered before App accepted runtime config`,
-    );
-  }
-  return runtimeConfig.config.appUrl;
-}
+// Public web app URL — injected at build time via .env.production. In dev
+// (no VITE_APP_URL set) falls back to the local web dev server so "Copy
+// link" in a dev build yields a URL that points at the running dev
+// frontend, not the prod host. Matches the fallback used in pages/login.tsx.
+const APP_URL = import.meta.env.VITE_APP_URL || "http://localhost:3000";
 
 /**
  * Extract the leading workspace slug from a path, or null if the path isn't
@@ -65,13 +61,6 @@ function tryRouteToOverlay(path: string, router?: DataRouter): boolean {
     }
     return true;
   }
-  if (path === "/invitations") {
-    overlay.open({ type: "invitations" });
-    if (router && router.state.location.pathname !== "/") {
-      router.navigate("/", { replace: true });
-    }
-    return true;
-  }
   if (path.startsWith("/invite/")) {
     let id = "";
     try {
@@ -120,7 +109,6 @@ export function DesktopNavigationProvider({
 }: {
   children: React.ReactNode;
 }) {
-  const appUrl = requireRuntimeAppUrl("DesktopNavigationProvider");
   // Primitive-only subscriptions so this component doesn't re-render on
   // unrelated store updates (e.g. an inactive tab's router tick). We
   // resolve the active router here only to subscribe once per tab switch.
@@ -191,9 +179,9 @@ export function DesktopNavigationProvider({
         const tabId = store.openTab(path, title ?? path, icon);
         if (tabId) store.setActiveTab(tabId);
       },
-      getShareableUrl: (path: string) => `${appUrl}${path}`,
+      getShareableUrl: (path: string) => `${APP_URL}${path}`,
     }),
-    [appUrl, location],
+    [location],
   );
 
   return <NavigationProvider value={adapter}>{children}</NavigationProvider>;
@@ -216,7 +204,6 @@ export function TabNavigationProvider({
   router: DataRouter;
   children: React.ReactNode;
 }) {
-  const appUrl = requireRuntimeAppUrl("TabNavigationProvider");
   const [location, setLocation] = useState(router.state.location);
 
   useEffect(() => {
@@ -252,9 +239,9 @@ export function TabNavigationProvider({
         const tabId = store.openTab(path, title ?? path, icon);
         if (tabId) store.setActiveTab(tabId);
       },
-      getShareableUrl: (path: string) => `${appUrl}${path}`,
+      getShareableUrl: (path: string) => `${APP_URL}${path}`,
     }),
-    [appUrl, router, location],
+    [router, location],
   );
 
   return <NavigationProvider value={adapter}>{children}</NavigationProvider>;

apps/desktop/src/renderer/src/stores/window-overlay-store.ts

@@ -15,7 +15,6 @@ import { create } from "zustand";
 export type WindowOverlay =
   | { type: "new-workspace" }
   | { type: "invite"; invitationId: string }
-  | { type: "invitations" }
   | { type: "onboarding" };
 
 interface WindowOverlayStore {

apps/desktop/src/shared/runtime-config.test.ts

@@ -1,99 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  DEFAULT_RUNTIME_CONFIG,
-  deriveWsUrl,
-  parseRuntimeConfig,
-  runtimeConfigFromDevEnv,
-} from "./runtime-config";
-
-describe("runtime config", () => {
-  it("uses cloud defaults without a desktop.json file", () => {
-    expect(DEFAULT_RUNTIME_CONFIG).toEqual({
-      schemaVersion: 1,
-      apiUrl: "https://api.multica.ai",
-      wsUrl: "wss://api.multica.ai/ws",
-      appUrl: "https://multica.ai",
-    });
-  });
-
-  it("derives https/wss compatible URLs from apiUrl", () => {
-    expect(
-      parseRuntimeConfig(
-        JSON.stringify({
-          schemaVersion: 1,
-          apiUrl: "https://congvc-x99.taila6fa8a.ts.net:18443",
-        }),
-      ),
-    ).toEqual({
-      schemaVersion: 1,
-      apiUrl: "https://congvc-x99.taila6fa8a.ts.net:18443",
-      wsUrl: "wss://congvc-x99.taila6fa8a.ts.net:18443/ws",
-      appUrl: "https://congvc-x99.taila6fa8a.ts.net:18443",
-    });
-  });
-
-  it("derives ws for http api URLs", () => {
-    expect(deriveWsUrl("http://localhost:8080")).toBe("ws://localhost:8080/ws");
-  });
-
-  it("accepts explicit appUrl and wsUrl", () => {
-    expect(
-      parseRuntimeConfig(
-        JSON.stringify({
-          schemaVersion: 1,
-          apiUrl: "https://api.example.com/",
-          wsUrl: "wss://ws.example.com/socket/",
-          appUrl: "https://app.example.com/",
-        }),
-      ),
-    ).toEqual({
-      schemaVersion: 1,
-      apiUrl: "https://api.example.com",
-      wsUrl: "wss://ws.example.com/socket",
-      appUrl: "https://app.example.com",
-    });
-  });
-
-  it("rejects invalid JSON", () => {
-    expect(() => parseRuntimeConfig("{")).toThrow(/Invalid desktop runtime config JSON/);
-  });
-
-  it("rejects unsupported schema versions", () => {
-    expect(() =>
-      parseRuntimeConfig(JSON.stringify({ schemaVersion: 2, apiUrl: "https://api.example.com" })),
-    ).toThrow(/schemaVersion/);
-  });
-
-  it("rejects non-http api schemes", () => {
-    expect(() =>
-      parseRuntimeConfig(JSON.stringify({ schemaVersion: 1, apiUrl: "file:///tmp/multica" })),
-    ).toThrow(/apiUrl must use http or https/);
-  });
-
-  it("rejects non-ws websocket schemes", () => {
-    expect(() =>
-      parseRuntimeConfig(
-        JSON.stringify({
-          schemaVersion: 1,
-          apiUrl: "https://api.example.com",
-          wsUrl: "https://api.example.com/ws",
-        }),
-      ),
-    ).toThrow(/wsUrl must use ws or wss/);
-  });
-
-  it("preserves electron-vite dev env precedence", () => {
-    expect(
-      runtimeConfigFromDevEnv({
-        apiUrl: "http://dev-api.example.test:8080/",
-        wsUrl: "ws://dev-api.example.test:8080/ws/",
-        appUrl: "http://dev-app.example.test:3000/",
-      }),
-    ).toEqual({
-      schemaVersion: 1,
-      apiUrl: "http://dev-api.example.test:8080",
-      wsUrl: "ws://dev-api.example.test:8080/ws",
-      appUrl: "http://dev-app.example.test:3000",
-    });
-  });
-});

apps/desktop/src/shared/runtime-config.ts

@@ -1,157 +0,0 @@
-export interface RuntimeConfig {
-  schemaVersion: 1;
-  apiUrl: string;
-  wsUrl: string;
-  appUrl: string;
-}
-
-export interface RuntimeConfigError {
-  message: string;
-}
-
-export type RuntimeConfigResult =
-  | { ok: true; config: RuntimeConfig }
-  | { ok: false; error: RuntimeConfigError };
-
-export const DEFAULT_RUNTIME_CONFIG: RuntimeConfig = Object.freeze({
-  schemaVersion: 1,
-  apiUrl: "https://api.multica.ai",
-  wsUrl: "wss://api.multica.ai/ws",
-  appUrl: "https://multica.ai",
-});
-
-const LOCAL_DEV_RUNTIME_CONFIG: RuntimeConfig = Object.freeze({
-  schemaVersion: 1,
-  apiUrl: "http://localhost:8080",
-  wsUrl: "ws://localhost:8080/ws",
-  appUrl: "http://localhost:3000",
-});
-
-export interface RuntimeConfigEnv {
-  apiUrl?: string;
-  wsUrl?: string;
-  appUrl?: string;
-}
-
-export function runtimeConfigFromDevEnv(env: RuntimeConfigEnv): RuntimeConfig {
-  const apiUrl = normalizeHttpUrl(
-    env.apiUrl || LOCAL_DEV_RUNTIME_CONFIG.apiUrl,
-    "VITE_API_URL",
-  );
-  return {
-    schemaVersion: 1,
-    apiUrl,
-    wsUrl: env.wsUrl
-      ? normalizeWsUrl(env.wsUrl, "VITE_WS_URL")
-      : deriveWsUrl(apiUrl),
-    appUrl: normalizeHttpUrl(
-      env.appUrl || LOCAL_DEV_RUNTIME_CONFIG.appUrl,
-      "VITE_APP_URL",
-    ),
-  };
-}
-
-export function parseRuntimeConfig(raw: string): RuntimeConfig {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err) {
-    throw new Error(
-      `Invalid desktop runtime config JSON: ${err instanceof Error ? err.message : "parse failed"}`,
-    );
-  }
-
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error("Invalid desktop runtime config: expected a JSON object");
-  }
-
-  const obj = parsed as Record<string, unknown>;
-  if (obj.schemaVersion !== 1) {
-    throw new Error("Unsupported desktop runtime config schemaVersion: expected 1");
-  }
-
-  const apiUrl = requiredString(obj.apiUrl, "apiUrl");
-  const appUrl = optionalString(obj.appUrl, "appUrl");
-  const wsUrl = optionalString(obj.wsUrl, "wsUrl");
-
-  const normalizedApiUrl = normalizeHttpUrl(apiUrl, "apiUrl");
-  return {
-    schemaVersion: 1,
-    apiUrl: normalizedApiUrl,
-    wsUrl: wsUrl ? normalizeWsUrl(wsUrl, "wsUrl") : deriveWsUrl(normalizedApiUrl),
-    appUrl: appUrl ? normalizeHttpUrl(appUrl, "appUrl") : deriveAppUrl(normalizedApiUrl),
-  };
-}
-
-export function deriveWsUrl(apiUrl: string): string {
-  const url = new URL(apiUrl);
-  if (url.protocol === "https:") url.protocol = "wss:";
-  else if (url.protocol === "http:") url.protocol = "ws:";
-  else throw new Error("apiUrl must use http or https");
-  url.pathname = joinPath(url.pathname, "/ws");
-  url.search = "";
-  url.hash = "";
-  return trimTrailingSlash(url.toString());
-}
-
-export function deriveAppUrl(apiUrl: string): string {
-  const url = new URL(apiUrl);
-  url.pathname = "";
-  url.search = "";
-  url.hash = "";
-  return trimTrailingSlash(url.toString());
-}
-
-function requiredString(value: unknown, field: string): string {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new Error(`Invalid desktop runtime config: ${field} must be a non-empty string`);
-  }
-  return value;
-}
-
-function optionalString(value: unknown, field: string): string | undefined {
-  if (value === undefined) return undefined;
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new Error(`Invalid desktop runtime config: ${field} must be a non-empty string when set`);
-  }
-  return value;
-}
-
-function normalizeHttpUrl(value: string, field: string): string {
-  let url: URL;
-  try {
-    url = new URL(value.trim());
-  } catch {
-    throw new Error(`Invalid desktop runtime config: ${field} must be a valid URL`);
-  }
-  if (url.protocol !== "http:" && url.protocol !== "https:") {
-    throw new Error(`Invalid desktop runtime config: ${field} must use http or https`);
-  }
-  url.search = "";
-  url.hash = "";
-  return trimTrailingSlash(url.toString());
-}
-
-function normalizeWsUrl(value: string, field: string): string {
-  let url: URL;
-  try {
-    url = new URL(value.trim());
-  } catch {
-    throw new Error(`Invalid desktop runtime config: ${field} must be a valid URL`);
-  }
-  if (url.protocol !== "ws:" && url.protocol !== "wss:") {
-    throw new Error(`Invalid desktop runtime config: ${field} must use ws or wss`);
-  }
-  url.search = "";
-  url.hash = "";
-  return trimTrailingSlash(url.toString());
-}
-
-function joinPath(base: string, suffix: string): string {
-  const normalizedBase = base.endsWith("/") ? base.slice(0, -1) : base;
-  return `${normalizedBase}${suffix}`;
-}
-
-function trimTrailingSlash(value: string): string {
-  return value.replace(/\/+$/, "");
-}

apps/desktop/test/setup.ts

@@ -1,38 +1 @@
 import "@testing-library/jest-dom/vitest";
-
-function createMemoryStorage(): Storage {
-  const values = new Map<string, string>();
-
-  return {
-    get length() {
-      return values.size;
-    },
-    clear: () => values.clear(),
-    getItem: (key: string) => values.get(key) ?? null,
-    key: (index: number) => Array.from(values.keys())[index] ?? null,
-    removeItem: (key: string) => {
-      values.delete(key);
-    },
-    setItem: (key: string, value: string) => {
-      values.set(key, value);
-    },
-  };
-}
-
-const localStorageIsUsable =
-  typeof globalThis.localStorage?.getItem === "function" &&
-  typeof globalThis.localStorage?.setItem === "function" &&
-  typeof globalThis.localStorage?.removeItem === "function" &&
-  typeof globalThis.localStorage?.clear === "function";
-
-if (!localStorageIsUsable) {
-  const storage = createMemoryStorage();
-  Object.defineProperty(globalThis, "localStorage", {
-    configurable: true,
-    value: storage,
-  });
-  Object.defineProperty(window, "localStorage", {
-    configurable: true,
-    value: storage,
-  });
-}

apps/desktop/vitest.config.ts

@@ -1,14 +1,8 @@
-import { resolve } from "path";
 import { defineConfig } from "vitest/config";
 import react from "@vitejs/plugin-react";
 
 export default defineConfig({
   plugins: [react()],
-  resolve: {
-    alias: {
-      "@": resolve(__dirname, "src/renderer/src"),
-    },
-  },
   test: {
     globals: true,
     include: ["src/**/*.test.{ts,tsx}", "scripts/**/*.test.mjs"],

apps/docs/app/[lang]/[...slug]/page.tsx

@@ -9,14 +9,6 @@ import { notFound } from "next/navigation";
 import defaultMdxComponents from "fumadocs-ui/mdx";
 import type { Metadata } from "next";
 import { docsAlternates } from "@/lib/site";
-import { i18n, type Lang } from "@/lib/i18n";
-import { DocsLocaleProvider, LocaleLink } from "@/components/locale-link";
-
-function asLang(lang: string): Lang {
-  return (i18n.languages as readonly string[]).includes(lang)
-    ? (lang as Lang)
-    : (i18n.defaultLanguage as Lang);
-}
 
 export default async function Page(props: {
   params: Promise<{ lang: string; slug: string[] }>;
@@ -26,16 +18,13 @@ export default async function Page(props: {
   if (!page) notFound();
 
   const MDX = page.data.body;
-  const lang = asLang(params.lang);
 
   return (
     <DocsPage toc={page.data.toc}>
       <DocsTitle>{page.data.title}</DocsTitle>
       <DocsDescription>{page.data.description}</DocsDescription>
       <DocsBody>
-        <DocsLocaleProvider lang={lang}>
-          <MDX components={{ ...defaultMdxComponents, a: LocaleLink }} />
-        </DocsLocaleProvider>
+        <MDX components={{ ...defaultMdxComponents }} />
       </DocsBody>
     </DocsPage>
   );

apps/docs/app/[lang]/page.tsx

@@ -8,7 +8,6 @@ import { Byline, NumberedCards, NumberedCard, NumberedSteps, Step } from "@/comp
 import { i18n, type Lang } from "@/lib/i18n";
 import { homeCopy } from "@/lib/translations";
 import { docsAlternates } from "@/lib/site";
-import { DocsLocaleProvider, LocaleLink } from "@/components/locale-link";
 
 function asLang(lang: string): Lang {
   return (i18n.languages as readonly string[]).includes(lang)
@@ -53,18 +52,15 @@ export default async function Page({
       />
       <Byline items={[...copy.byline]} />
       <DocsBody>
-        <DocsLocaleProvider lang={lang}>
-          <MDX
-            components={{
-              ...defaultMdxComponents,
-              a: LocaleLink,
-              NumberedCards,
-              NumberedCard,
-              NumberedSteps,
-              Step,
-            }}
-          />
-        </DocsLocaleProvider>
+        <MDX
+          components={{
+            ...defaultMdxComponents,
+            NumberedCards,
+            NumberedCard,
+            NumberedSteps,
+            Step,
+          }}
+        />
       </DocsBody>
     </DocsPage>
   );

apps/docs/components/editorial.tsx

@@ -1,9 +1,5 @@
-"use client";
-
 import Link from "next/link";
 import type { ReactNode } from "react";
-import { useDocsLocale } from "@/components/locale-link";
-import { prefixLocale } from "@/lib/locale-link";
 
 /**
  * Byline — editorial metadata strip with ruled top + bottom borders.
@@ -59,10 +55,9 @@ export function NumberedCard({
   tag?: string;
   children: ReactNode;
 }) {
-  const lang = useDocsLocale();
   return (
     <Link
-      href={prefixLocale(href, lang)}
+      href={href}
       className="group flex flex-col gap-2.5 border-r border-border px-0 py-5 pr-4 no-underline last:border-r-0 md:px-4 md:first:pl-0 md:last:pr-0"
     >
       <div className="font-mono text-[0.6875rem] uppercase tracking-[0.08em] text-muted-foreground">

apps/docs/components/locale-link.tsx

@@ -1,48 +0,0 @@
-"use client";
-
-import Link from "next/link";
-import {
-  createContext,
-  useContext,
-  type AnchorHTMLAttributes,
-  type ReactNode,
-} from "react";
-import { i18n, type Lang } from "@/lib/i18n";
-import { prefixLocale } from "@/lib/locale-link";
-
-const DocsLocaleContext = createContext<Lang>(i18n.defaultLanguage as Lang);
-
-// Wraps the rendered MDX subtree so descendant <LocaleLink>s and any
-// editorial component using `useDocsLocale()` know which language the page
-// was rendered in. Mounted at each docs page entry; never elsewhere.
-export function DocsLocaleProvider({
-  lang,
-  children,
-}: {
-  lang: Lang;
-  children: ReactNode;
-}) {
-  return (
-    <DocsLocaleContext.Provider value={lang}>
-      {children}
-    </DocsLocaleContext.Provider>
-  );
-}
-
-export function useDocsLocale(): Lang {
-  return useContext(DocsLocaleContext);
-}
-
-// Drop-in replacement for the MDX-rendered `<a>` element. Keeps the same
-// surface shape as the default `a` from `defaultMdxComponents` but routes
-// internal links through the locale prefixer + next/link so client-side
-// navigation stays inside the active locale.
-export function LocaleLink({
-  href,
-  ...rest
-}: AnchorHTMLAttributes<HTMLAnchorElement> & { href?: string }) {
-  const lang = useDocsLocale();
-  if (!href) return <a {...rest} />;
-  const final = prefixLocale(href, lang);
-  return <Link href={final} {...rest} />;
-}

apps/docs/content/docs/assigning-issues.mdx

@@ -32,10 +32,9 @@ The command-line equivalent:
 
 ```bash
 multica issue assign MUL-42 --to alice
-multica issue assign MUL-42 --to-id 5fb87ac7-23b5-4a7a-81fa-ed295a54545d
 ```
 
-`--to` takes a member username or an agent name (fuzzy match). When names overlap — e.g. an agent `J` alongside `Cursor - J` — pass `--to-id <uuid>` instead, using the `user_id` (member) or `id` (agent) from `multica workspace members --output json` / `multica agent list --output json`. UUID matching is strict and unambiguous, which is what you want from scripts and from agents driving the CLI. `--to` and `--to-id` are mutually exclusive.
+`--to` takes a member username or an agent name. Giving agents memorable names makes this step smoother — if multiple agents share a name in the workspace, the first one listed wins, so rename before assigning.
 
 Unassign:
 

apps/docs/content/docs/assigning-issues.zh.mdx

@@ -32,10 +32,9 @@ import { Callout } from "fumadocs-ui/components/callout";
 
 ```bash
 multica issue assign MUL-42 --to alice
-multica issue assign MUL-42 --to-id 5fb87ac7-23b5-4a7a-81fa-ed295a54545d
 ```
 
-`--to` 后跟成员用户名或智能体名字（模糊匹配）。如果工作区里有同名 / 互相含子串的成员或智能体（例如 agent `J` 旁边还有 `Cursor - J`），改用 `--to-id <uuid>`：UUID 来自 `multica workspace members --output json` 的 `user_id` 或 `multica agent list --output json` 的 `id`，是唯一精确的方式，特别适合脚本和驱动 CLI 的智能体。`--to` 和 `--to-id` 互斥。
+`--to` 后跟成员用户名或智能体名字。给智能体起个好记的名字会让这一步顺很多——工作区里重名的会按列出顺序选第一个，建议先改名再分配。
 
 取消分配：
 

apps/docs/content/docs/cli/reference.zh.mdx

@@ -18,10 +18,10 @@ Opens your browser for OAuth authentication, creates a 90-day personal access to
 ### Token Login
 
 ```bash
-multica login --token <mul_...>
+multica login --token
 ```
 
-Authenticate using a personal access token directly. Useful for headless environments. Pass `--token=` with an empty value to be prompted interactively (so the token never lands in shell history).
+Authenticate by pasting a personal access token directly. Useful for headless environments.
 
 ### Check Status
 
@@ -221,11 +221,10 @@ multica workspace members <workspace-id>
 multica issue list
 multica issue list --status in_progress
 multica issue list --priority urgent --assignee "Agent Name"
-multica issue list --assignee-id 5fb87ac7-23b5-4a7a-81fa-ed295a54545d
 multica issue list --limit 20 --output json
 ```
 
-Available filters: `--status`, `--priority`, `--assignee` / `--assignee-id`, `--project`, `--limit`. 在重名 workspace 下用 `--assignee-id <uuid>` 可以精确锁定一个成员或 agent。
+Available filters: `--status`, `--priority`, `--assignee`, `--project`, `--limit`.
 
 ### Get Issue
 
@@ -238,10 +237,9 @@ multica issue get <id> --output json
 
 ```bash
 multica issue create --title "Fix login bug" --description "..." --priority high --assignee "Lambda"
-multica issue create --title "Fix login bug" --assignee-id 5fb87ac7-23b5-4a7a-81fa-ed295a54545d
 ```
 
-Flags: `--title` (required), `--description`, `--status`, `--priority`, `--assignee` / `--assignee-id`, `--parent`, `--project`, `--due-date`. 脚本里如果已经拿到了 UUID（例如来自 `multica workspace members --output json`），传 `--assignee-id <uuid>`（与 `--assignee` 互斥）以精确锁定。
+Flags: `--title` (required), `--description`, `--status`, `--priority`, `--assignee`, `--parent`, `--project`, `--due-date`.
 
 ### Update Issue
 
@@ -253,12 +251,9 @@ multica issue update <id> --title "New title" --priority urgent
 
 ```bash
 multica issue assign <id> --to "Lambda"
-multica issue assign <id> --to-id 5fb87ac7-23b5-4a7a-81fa-ed295a54545d
 multica issue assign <id> --unassign
 ```
 
-`--to-id <uuid>`（与 `--to` 互斥）按 UUID 精确分配；适合重名 workspace 下脚本化场景。
-
 ### Change Status
 
 ```bash

apps/docs/content/docs/cloud-quickstart.mdx

@@ -99,7 +99,7 @@ Assign the issue to the agent you just created — click its avatar in the web U
 multica issue assign MUL-1 --to my-agent-name
 ```
 
-`--to` takes the **name** of an agent or member. A substring match works — if the agent is called `my-code-reviewer`, `reviewer` resolves to it. If your workspace has overlapping names, pass `--to-id <uuid>` instead (mutually exclusive with `--to`); look up the UUID via `multica agent list --output json` or `multica workspace members --output json`.
+`--to` takes the **name** of an agent or member. A substring match works — if the agent is called `my-code-reviewer`, `reviewer` resolves to it.
 
 **What happens next from the daemon**:
 

apps/docs/content/docs/cloud-quickstart.zh.mdx

@@ -99,7 +99,7 @@ multica issue create --title "给 README 加一段 ASCII 架构图"
 multica issue assign MUL-1 --to my-agent-name
 ```
 
-`--to` 后面填智能体或成员的**名字**，子串就行——如果智能体叫 `my-code-reviewer`，填 `reviewer` 也能命中。如果工作区里名字相互重叠或冲突，改用 `--to-id <uuid>`（与 `--to` 互斥）；UUID 来自 `multica agent list --output json` 或 `multica workspace members --output json`。
+`--to` 后面填智能体或成员的**名字**，子串就行——如果智能体叫 `my-code-reviewer`，填 `reviewer` 也能命中。
 
 **接下来守护进程会**：
 

apps/docs/content/docs/daemon-runtimes.mdx

@@ -37,7 +37,7 @@ Common commands:
 
 Full CLI reference in [CLI commands](/cli).
 
-**The desktop app ships with a daemon.** If you use the [desktop app](/desktop-app), you don't need to run `multica daemon start` manually — it launches the daemon automatically on startup. See the [Desktop app](/desktop-app) page for which option fits your workflow.
+**The desktop app ships with a daemon.** If you use the [desktop app](/desktop-app), you don't need to run `multica daemon start` manually — it launches the daemon automatically on startup.
 
 ## Why one machine has multiple runtimes
 

apps/docs/content/docs/daemon-runtimes.zh.mdx

@@ -37,7 +37,7 @@ multica daemon start
 
 完整 CLI 参考见 [CLI 命令速查](/cli)。
 
-**桌面应用自带守护进程。**用 [桌面应用](/desktop-app) 就不必手动 `multica daemon start`——它启动时会自动拉起守护进程。哪种方式更适合你的工作流，详见 [桌面应用](/desktop-app) 页面。
+**桌面应用自带守护进程。**用 [桌面应用](/desktop-app) 就不必手动 `multica daemon start`——它启动时会自动拉起守护进程。
 
 ## 为什么一台机器会有多个运行时
 

apps/docs/content/docs/desktop-app.mdx

@@ -5,7 +5,7 @@ description: What Multica Desktop is, how it differs from the web app, and when
 
 import { Callout } from "fumadocs-ui/components/callout";
 
-Multica Desktop is a native desktop app for macOS, Windows, and Linux. For the environment it is configured for, it talks to the same backend as the web app and shows the same data. By default Desktop uses Multica Cloud; self-hosted instances can be configured with a local runtime config file. Desktop also adds a few things the browser can't: **independent tab groups per [workspace](/workspaces)**, **automatic [daemon](/daemon-runtimes) startup**, and **one-click upgrades**.
+Multica Desktop is a native desktop app for macOS, Windows, and Linux. It talks to the same backend as the web app and shows the same data, but it adds a few things the browser can't: **independent tab groups per [workspace](/workspaces)**, **automatic [daemon](/daemon-runtimes) startup**, and **one-click upgrades**.
 
 ## Desktop or web — which to pick
 
@@ -66,34 +66,25 @@ Grab the installer for your platform from the [Multica downloads page](https://m
 
 On first launch you'll need to sign in — the same email + verification code flow as the web app. Once you're in, Desktop syncs your workspace list automatically.
 
-<Callout type="info">
-**Desktop defaults to Multica Cloud, but can be pointed at a self-hosted instance with a local config file.** There is still no in-app "connect to self-host" picker. Desktop reads `~/.multica/desktop.json` before the renderer starts; if the file is missing, it uses the Cloud defaults.
+<Callout type="warning">
+**Released Desktop builds are pinned to Multica Cloud.** The backend, websocket, and web URLs are baked in at build time (`VITE_API_URL` / `VITE_WS_URL` / `VITE_APP_URL`) — there is no in-app option to point Desktop at a self-hosted instance. To use Desktop against a self-hosted backend you need to build it yourself:
 
-Minimal self-host config:
-
-```json
-{
-  "schemaVersion": 1,
-  "apiUrl": "https://api.your-domain"
-}
+```bash
+git clone https://github.com/multica-ai/multica.git
+cd multica
+# Edit apps/desktop/.env.production:
+#   VITE_API_URL=https://api.your-domain
+#   VITE_WS_URL=wss://api.your-domain/ws
+#   VITE_APP_URL=https://your-domain
+pnpm install
+pnpm --filter @multica/desktop package
 ```
 
-`apiUrl` is required and must use `http` or `https`. Desktop derives `wsUrl` as `/ws` on the same origin (`wss` for `https`, `ws` for `http`) and derives `appUrl` from the API origin. If your deployment uses different origins, set them explicitly:
-
-```json
-{
-  "schemaVersion": 1,
-  "apiUrl": "https://api.your-domain",
-  "wsUrl": "wss://api.your-domain/ws",
-  "appUrl": "https://your-domain"
-}
-```
-
-If `desktop.json` exists but is invalid, Desktop fails closed and shows a blocking config error instead of silently falling back to Cloud. For development builds, `VITE_API_URL` / `VITE_WS_URL` / `VITE_APP_URL` still take precedence during `electron-vite dev`. Runtime Desktop self-host configuration was implemented for [issue #1371](https://github.com/multica-ai/multica/issues/1371).
+If you'd rather not build from source, the supported self-hosted path is **web frontend + CLI** — see [Self-host quickstart](/self-host-quickstart). Runtime backend configuration in Desktop is tracked in [issue #1371](https://github.com/multica-ai/multica/issues/1371).
 </Callout>
 
 ## Next steps
 
 - [Cloud Quickstart](/cloud-quickstart) — the Cloud onboarding flow for Desktop
-- [Self-Host Quickstart](/self-host-quickstart) — running your own backend and connecting with the CLI or Desktop runtime config
+- [Self-Host Quickstart](/self-host-quickstart) — running your own backend (Desktop against self-host requires a custom build, see the callout above)
 - [Daemon and runtimes](/daemon-runtimes) — how the daemon works (Desktop starts it for you, but the behavior is the same)

apps/docs/content/docs/desktop-app.zh.mdx

@@ -5,7 +5,7 @@ description: Multica Desktop 是什么、和 Web 有什么区别、什么时候
 
 import { Callout } from "fumadocs-ui/components/callout";
 
-Multica Desktop 是原生桌面应用——macOS / Windows / Linux 三个平台。对它当前配置的环境来说，它和 Web 版连同一个后端、看到的数据完全一样。Desktop 默认使用 Multica Cloud；自部署实例可以通过本地运行时配置文件接入。它还给了几个 Web 做不到的能力：**[工作区](/workspaces) 独立的多标签页**、**自动启动 [守护进程](/daemon-runtimes)**、**一键升级**。
+Multica Desktop 是原生桌面应用——macOS / Windows / Linux 三个平台。它和 Web 版连同一个后端，看到的数据完全一样，但给了几个 Web 做不到的能力：**[工作区](/workspaces) 独立的多标签页**、**自动启动 [守护进程](/daemon-runtimes)**、**一键升级**。
 
 ## Desktop 和 Web 该用哪个
 
@@ -66,34 +66,25 @@ macOS 版本已经签名 + 公证，第一次打开不会有"未知开发者"的
 
 安装后第一次打开需要登录——和 Web 版一样的 email + 验证码流程。登录成功后 Desktop 自动把工作区列表同步下来。
 
-<Callout type="info">
-**Desktop 默认连接 Multica Cloud，但可以通过本地配置文件指向自部署实例。** 应用内仍然没有“连接自部署”的切换入口。Desktop 会在 renderer 启动前读取 `~/.multica/desktop.json`；如果这个文件不存在，就使用 Cloud 默认值。
+<Callout type="warning">
+**发布版的 Desktop 是锁死连 Multica Cloud 的**。后端 / WebSocket / Web 前端 URL（`VITE_API_URL` / `VITE_WS_URL` / `VITE_APP_URL`）在构建时就写死了，应用内**没有切换后端的入口**。要让 Desktop 连自部署后端，需要你自己从源码 build：
 
-最小自部署配置：
-
-```json
-{
-  "schemaVersion": 1,
-  "apiUrl": "https://api.your-domain"
-}
+```bash
+git clone https://github.com/multica-ai/multica.git
+cd multica
+# 编辑 apps/desktop/.env.production：
+#   VITE_API_URL=https://api.your-domain
+#   VITE_WS_URL=wss://api.your-domain/ws
+#   VITE_APP_URL=https://your-domain
+pnpm install
+pnpm --filter @multica/desktop package
 ```
 
-`apiUrl` 是必填项，必须使用 `http` 或 `https`。Desktop 会自动从它推导 `wsUrl`（同源 `/ws`，`https` 对应 `wss`，`http` 对应 `ws`）和 `appUrl`（API 的同源地址）。如果你的部署使用不同域名，可以显式设置：
-
-```json
-{
-  "schemaVersion": 1,
-  "apiUrl": "https://api.your-domain",
-  "wsUrl": "wss://api.your-domain/ws",
-  "appUrl": "https://your-domain"
-}
-```
-
-如果 `desktop.json` 存在但内容无效，Desktop 会 fail closed，显示阻塞式配置错误，而不是悄悄回退到 Cloud。开发构建里，`electron-vite dev` 仍然优先使用 `VITE_API_URL` / `VITE_WS_URL` / `VITE_APP_URL`。Desktop 运行时自部署配置能力对应 [issue #1371](https://github.com/multica-ai/multica/issues/1371)。
+不想自己 build 的话，自部署的官方路径是 **Web 前端 + CLI**——见 [自部署快速上手](/self-host-quickstart)。Desktop 运行时切换后端的能力跟踪在 [issue #1371](https://github.com/multica-ai/multica/issues/1371)。
 </Callout>
 
 ## 下一步
 
 - [Cloud Quickstart](/cloud-quickstart) —— Desktop 版的 Cloud 接入流程
-- [Self-Host Quickstart](/self-host-quickstart) —— 自部署后端，并通过 CLI 或 Desktop 运行时配置连接
+- [Self-Host Quickstart](/self-host-quickstart) —— 自部署后端（Desktop 连自部署需要自行构建，见上方提示）
 - [守护进程与运行时](/daemon-runtimes) —— 守护进程机制（Desktop 自动起它，但行为一样）

apps/docs/content/docs/developers/conventions.mdx

@@ -1,301 +0,0 @@
----
-title: Conventions
-description: Single source of truth for code naming, i18n translation glossary, and Chinese voice guide.
----
-
-This page is the single source of truth for code naming, the i18n translation glossary, and the Chinese voice guide. Anything that used to live in `packages/views/locales/glossary.md` or in scattered comments now lives here.
-
-If you write Multica code, change a translation, or write Chinese product copy, this is the page to reference.
-
----
-
-## 1. Code naming
-
-### Routes
-
-Pre-workspace routes (the routes that exist before the user is in a workspace) MUST use either a single word or the `/{noun}/{verb}` pattern.
-
-- ✅ `/login`, `/inbox`, `/workspaces/new`
-- ❌ `/new-workspace`, `/create-team`, `/accept-invite`
-
-Hyphenated word groups at the root collide with user-chosen workspace slugs and force endless reserved-slug audits. Reserving the noun (`workspaces`) automatically protects the entire `/workspaces/*` subtree.
-
-### Workspace-scoped routes
-
-Always live under `/{slug}/{section}` — `/{slug}/issues`, `/{slug}/agents`, `/{slug}/settings`. Never duplicate workspace routing logic; use `useNavigation().push()` from shared code, never framework-specific link APIs.
-
-### Packages and modules
-
-The monorepo enforces strict package boundaries:
-
-| Package | May depend on | Must NOT depend on |
-| --- | --- | --- |
-| `packages/core` | nothing app-specific | `react-dom`, `localStorage`, `process.env`, `next/*`, UI libraries |
-| `packages/ui` | nothing | `@multica/core`, business logic |
-| `packages/views` | `core/`, `ui/` | `next/*`, `react-router-dom`, stores |
-| `apps/web/platform/` | `next/*` | other apps |
-| `apps/desktop/.../platform/` | `react-router-dom`, electron | other apps |
-
-If logic appears in both apps, it MUST be extracted to a shared package. There are no exceptions for "small" duplication.
-
-### Files and components
-
-- Files: `kebab-case.tsx` / `kebab-case.ts` (e.g. `agent-row-actions.tsx`)
-- Components: `PascalCase` (e.g. `AgentRowActions`)
-- Hooks: `useCamelCase` (e.g. `useWorkspaceId`)
-- Tests: colocated as `<file>.test.ts(x)`
-- Stores (Zustand): `<feature>-store.ts`, exported as `use<Feature>Store`
-
-### Database (Go + sqlc)
-
-- Tables: `snake_case` singular (`user`, `workspace`, `agent_runtime`)
-- Columns: `snake_case` (`workspace_id`, `created_at`, `last_seen_at`)
-- Foreign keys: `<table>_id`
-- Booleans: `is_<state>` or `<state>_at` (timestamp form preferred for state changes)
-- Migration files: `NNN_descriptive_name.up.sql` + `.down.sql` — always provide both directions
-
-### Go
-
-- Standard `gofmt` + `go vet`. No exceptions.
-- Handler files mirror domain: `agent.go`, `auth.go`, `runtime.go`
-- Tests: `<file>_test.go` colocated
-- For UUID parsing in handlers, follow the rule in the root `CLAUDE.md` — `parseUUIDOrBadRequest` for boundary input, `parseUUID` (panicking) for trusted round-trips, never `util.ParseUUID` directly without checking the error.
-
-### TypeScript
-
-- API responses on the wire are `snake_case`; the api client converts to `camelCase` at the boundary. Inside TS code, **always camelCase**.
-- Types: `PascalCase` (`Issue`, `AgentRuntime`); never `IPrefix`, never `_t` suffix.
-- Enums: prefer string literal unions; reserve `enum` for runtime-iterable cases.
-- TanStack Query keys: factory functions in `<feature>/queries.ts`, e.g. `issueKeys.detail(id)`.
-
-### Issue keys
-
-Every issue has a human-readable key like `MUL-123`: workspace `issue_prefix` (3 letters, uppercase) + sequence number. The prefix is set at workspace creation and is never changed afterward.
-
-### Comments in code
-
-English only. The repo enforces this for both Go and TypeScript. If you find a Chinese comment in code, it's a bug — replace it.
-
-### Commit messages
-
-Conventional format: `feat(scope)`, `fix(scope)`, `refactor(scope)`, `docs`, `test(scope)`, `chore(scope)`. Atomic commits grouped by intent.
-
----
-
-## 2. i18n translation glossary
-
-This is the **mandatory** glossary for every translation PR. It used to live at `packages/views/locales/glossary.md`; that file is now a stub pointing here.
-
-### The core distinction: entity vs concept
-
-Multica's product nouns split into two categories:
-
-- **Entity** — has a URL, a database row, an API type. In Chinese text, render as **lowercase English** so it visually reads like a type name and signals "this is a Multica system entity".
-- **Concept** — generic noun, not a database entity. **Translate fully** so Chinese users don't see jagged English embedded in flowing text.
-
-This rule is aligned with `apps/docs/content/docs/*.zh.mdx` — the docs are the de facto Chinese voice standard and have been battle-tested across 20+ pages.
-
-### Entities — mixed rule (`issue` / `skill` / `task`)
-
-`issue` / `skill` / `task` are Multica's core entities. They have schema columns, API fields, and product UI labels that are all English. In Chinese text, they follow a **mixed rule** — what to use depends on where the word appears:
-
-| Context | Render | Example |
-| --- | --- | --- |
-| **UI strings, state names, code references** | lowercase English | "排队中的 task"、"创建子 issue"、"为智能体注入 skill" |
-| **Doc titles / section headings** | Title-case English **or** the Chinese term | "Issue 与 project"、"Skills"、"执行任务" |
-| **Long-form doc prose, when the entity is the running subject** | Chinese term, with English in parentheses on first mention | "**执行任务**（task）是智能体每一次工作的单位" |
-| **API / DB fields** | always `task` / `issue` / `skill` | `task_id`, `issue_status`, `skill_uuid` |
-
-Chinese term reference:
-
-- `task` ↔ `执行任务` (or shortened to `任务` once context is clear)
-- `issue` has no settled Chinese translation — leave English; titles may capitalize as `Issue`
-- `skill` has no settled Chinese translation — leave English; titles may capitalize as `Skills`
-
-**Why `issue` / `skill` / `task` aren't forced into Chinese the way `project` / `autopilot` are**:
-
-- **`issue` / `task`**: dev teams talk in English. The Chinese candidates ("任务" — too vague, almost synonymous with "工作"; "工单" — IT ticket connotation; "议题" — GitHub-style but doesn't match the product feel) all read worse than `issue`. **But** in long-form doc prose, repeating lowercase `task` 50× breaks the rhythm — so prose is allowed to use `执行任务`, while UI strings and state names stay lowercase English.
-- **`skill`**: Multica-specific concept with no established Chinese term.
-- **`project` → "项目"**: settled mainstream Chinese word. Feishu / Tower / Teambition / PingCode / GitHub Projects — every Chinese product translates it. No product keeps `project` in Chinese context.
-- **`autopilot` → "自动化"**: in Chinese, "autopilot" associates with Tesla's "自动驾驶" and doesn't match what the feature does (run tasks on a schedule). Notion and Feishu both use "自动化"; that's the industry consensus.
-
-### Don't translate — brands and acronyms
-
-| Category | Terms |
-| --- | --- |
-| Brands | **Multica**, GitHub, Slack, Google, Anthropic, OpenAI, Claude, Codex, Cursor, Linear, Jira |
-| Acronyms | API, CLI, URL, SDK, OAuth, JWT, SSO, WebSocket, HTTP, JSON, YAML, SQL |
-
-### Translate fully — concepts
-
-| English | Chinese |
-| --- | --- |
-| Workspace | **工作区** |
-| Agent | **智能体** |
-| Project | **项目** |
-| Autopilot | **自动化** |
-| Daemon | **守护进程** |
-| Runtime | **运行时** |
-| Inbox | **收件箱** |
-| Comment | **评论** |
-| Reply | **回复** |
-| Notifications | **通知** |
-| Member | **成员** |
-| Label | **标签** |
-| Settings | **设置** |
-| Onboarding | **上手引导** |
-
-### Translate fully — generic UI words
-
-| English | Chinese |
-| --- | --- |
-| Invite / Invitation | 邀请 |
-| Search | 搜索 |
-| Email | 邮箱 (label) / 邮件 (action) |
-| Password | 密码 |
-| Sign in / Log in | 登录 |
-| Sign up | 注册 |
-| Sign out / Log out | 退出登录 |
-| Save / Cancel / Delete | 保存 / 取消 / 删除 |
-| Confirm / Continue / Back | 确认 / 继续 / 返回 |
-| Edit / New / Create / Add | 编辑 / 新建 / 创建 / 添加 |
-| Remove / Send / Open / Close | 移除 / 发送 / 打开 / 关闭 |
-| Done / Loading... | 完成 / 加载中... |
-| Profile / Account / Appearance | 个人资料 / 账号 / 外观 |
-| Theme / Language | 主题 / 语言 |
-| Light / Dark / System | 浅色 / 深色 / 跟随系统 |
-| Active / Archived | 活跃 (or 启用) / 已归档 |
-| Status / Priority | 状态 / 优先级 |
-| Assignee / Reporter | 负责人 / 报告人 |
-| Description / Title | 描述 / 标题 |
-| Date / Time | 日期 / 时间 |
-| Today / Yesterday / Tomorrow | 今天 / 昨天 / 明天 |
-| Empty / Failed / Success | 空 / 失败 / 成功 |
-| Error / Warning | 错误 / 警告 |
-
-### Roles and status enums (lowercase English, not translated)
-
-These are schema-level identifiers; render as lowercase English even in Chinese context.
-
-- Roles: `owner` / `admin` / `member`
-- Issue status: `backlog` / `todo` / `in_progress` / `in_review` / `done` / `blocked` / `cancelled`
-
-In UI, surface them in English (optionally `code-style` wrapped):
-
-- "你需要 owner 权限"
-- "已切换到 in_progress"
-
-### Word combination rules
-
-Always put **a single space** between an English word (entity / brand / acronym) and surrounding Chinese:
-
-- "Create new issue" → "新建 issue"
-- "Assign to agent" → "分配给智能体"
-- "Configure runtime" → "配置运行时"
-- "Stop daemon" → "停止守护进程"
-
-### Plurals and counts
-
-i18next uses `_one` / `_other`; Chinese has no grammatical number, only fill `_other`.
-
-```json
-// en/issues.json
-{
-  "issue_count_one": "{{count}} issue",
-  "issue_count_other": "{{count}} issues"
-}
-
-// zh-Hans/issues.json
-{
-  "issue_count_other": "{{count}} 个 issue"
-}
-```
-
-Common count formats:
-
-- `{{count}} issues` → `{{count}} 个 issue`
-- `{{count}} agents` → `{{count}} 个智能体`
-- `{{count}} workspaces` → `{{count}} 个工作区`
-- `{{count}} comments` → `{{count}} 条评论`
-- `{{count}} members` → `{{count}} 位成员`
-- `{{count}} skills` → `{{count}} 个 skill`
-
-### Interpolation
-
-Use `{{var}}`. Chinese translations may reorder for natural sentence flow.
-
-```json
-// en
-{ "welcome_message": "Welcome back, {{name}}!" }
-
-// zh-Hans
-{ "welcome_message": "欢迎回来，{{name}}！" }
-```
-
-### Translation key naming
-
-Three-level nesting: `feature.component.action`.
-
-```json
-{
-  "feature_or_component": {
-    "subcomponent_or_section": {
-      "action_or_label": "..."
-    }
-  }
-}
-```
-
-Examples:
-
-- `issues.toolbar.batch_update_success`
-- `issues.detail.comment_form.placeholder`
-- `inbox.empty.title`
-- `settings.preferences.language.title`
-
-### Web-only / desktop-only copy
-
-- Shared copy: top level of the namespace JSON
-- Web-only: `web` section
-- Desktop-only: `desktop` section
-
-See `auth.json` for the canonical example (the `web` section contains `prefer_desktop` / `desktop_handoff.*`).
-
----
-
-## 3. Chinese voice and style
-
-### Punctuation
-
-- Full-width punctuation in Chinese: `，。：；！？`
-- Quotes: straight double quotes `"..."` to match the English source. Do not use `「」` or curly quotes.
-- Ellipsis: three dots `...` not the single character `…`. Match the English source.
-- Mixed Chinese-English: a single space on each side of the English word (see Word combination rules).
-
-### Style principles
-
-- **Concise and direct.** Avoid translation-ese: "对于 X 来说"、"作为 X"、"我们的"。
-- **Error messages**: gentle but clear. "无法保存修改" beats "保存修改失败了！".
-- **Buttons**: verb first, 2–4 characters. "取消"、"保存修改"、"立即同步".
-- **Tooltips**: full short sentence. "复制链接到剪贴板".
-- **Placeholders**: example-style. "输入 issue 标题...".
-
-### Where to look when in doubt
-
-When the glossary doesn't cover a term, look at:
-
-1. `apps/docs/content/docs/*.zh.mdx` — the de facto Chinese voice standard, 20+ pages of consistent translation
-2. `packages/views/locales/zh-Hans/auth.json` and `editor.json` — JSON structure + selector API patterns
-3. `packages/views/auth/login-page.tsx` — component-level selector API call site
-4. `packages/views/settings/components/preferences-tab.tsx` — language switcher reference
-
----
-
-## Updating this page
-
-If you change a rule here, also:
-
-1. Apply it in the relevant locale JSONs / CLAUDE.md / docs page
-2. Note the change in the PR description so reviewers know to look for downstream sweep
-
-This page is the contract; nothing else overrides it.

apps/docs/content/docs/developers/conventions.zh.mdx

@@ -1,301 +0,0 @@
----
-title: 规范
-description: 代码命名规范、i18n 翻译术语表、中文风格指南的唯一权威来源。
----
-
-本页是代码命名规范、i18n 翻译术语表、中文风格指南的唯一权威来源。原本散落在 `packages/views/locales/glossary.md` 和各处注释里的规则现在都收拢到这里。
-
-写 Multica 代码、改翻译、写中文产品文案，都从这一页查。
-
----
-
-## 1. 代码命名
-
-### 路由
-
-工作区前置路由（用户进入工作区之前能访问的路由）必须用单个单词，或者 `/{noun}/{verb}` 格式。
-
-- ✅ `/login`、`/inbox`、`/workspaces/new`
-- ❌ `/new-workspace`、`/create-team`、`/accept-invite`
-
-根目录的连字符词组会跟用户自选 workspace slug 冲突，逼着团队不停审保留字列表。把名词（`workspaces`）保留下来，整个 `/workspaces/*` 子树自动受保护。
-
-### 工作区路由
-
-永远用 `/{slug}/{section}` —— `/{slug}/issues`、`/{slug}/agents`、`/{slug}/settings`。共享代码不要复制路由逻辑，统一走 `useNavigation().push()`，不要直接用框架的 link API。
-
-### 包与模块
-
-monorepo 的包边界是硬约束：
-
-| 包 | 可依赖 | 不能依赖 |
-| --- | --- | --- |
-| `packages/core` | 仅平台无关基础库 | `react-dom`、`localStorage`、`process.env`、`next/*`、UI 库 |
-| `packages/ui` | 无业务依赖 | `@multica/core`、业务逻辑 |
-| `packages/views` | `core/`、`ui/` | `next/*`、`react-router-dom`、stores |
-| `apps/web/platform/` | `next/*` | 其他 app |
-| `apps/desktop/.../platform/` | `react-router-dom`、electron | 其他 app |
-
-两个 app 都有的逻辑，**必须**抽到共享包。"小段重复"也不算例外。
-
-### 文件与组件
-
-- 文件名：`kebab-case.tsx` / `kebab-case.ts`（如 `agent-row-actions.tsx`）
-- 组件：`PascalCase`（如 `AgentRowActions`）
-- Hook：`useCamelCase`（如 `useWorkspaceId`）
-- 测试：与源文件同目录，命名 `<file>.test.ts(x)`
-- Zustand store：`<feature>-store.ts`，导出名 `use<Feature>Store`
-
-### 数据库（Go + sqlc）
-
-- 表名：`snake_case` 单数（`user`、`workspace`、`agent_runtime`）
-- 字段：`snake_case`（`workspace_id`、`created_at`、`last_seen_at`）
-- 外键：`<table>_id`
-- 布尔：`is_<state>` 或者 `<state>_at`（状态变化优先用时间戳形式）
-- 迁移文件：`NNN_descriptive_name.up.sql` + `.down.sql`，**永远写双向**
-
-### Go
-
-- 标准 `gofmt` + `go vet`，无例外
-- Handler 文件按域命名：`agent.go`、`auth.go`、`runtime.go`
-- 测试：`<file>_test.go` 同目录
-- handler 里 UUID 解析遵守根 `CLAUDE.md` 的规则：边界输入用 `parseUUIDOrBadRequest`，可信回环用 `parseUUID`（panic 版），永远不要直接用 `util.ParseUUID` 不查 error
-
-### TypeScript
-
-- 网络上 API 响应是 `snake_case`，api client 在边界处转成 `camelCase`。**TS 代码内部一律 camelCase**
-- 类型：`PascalCase`（`Issue`、`AgentRuntime`），不加 `IPrefix`，不加 `_t` 后缀
-- 枚举：优先用 string literal union，需要 runtime 迭代时才用 `enum`
-- TanStack Query key：用 `<feature>/queries.ts` 里的工厂函数，例如 `issueKeys.detail(id)`
-
-### Issue 编号
-
-每个 issue 有人类可读的编号，比如 `MUL-123`：工作区 `issue_prefix`（3 个大写字母）+ 流水号。前缀在工作区创建时定，之后不可改。
-
-### 代码注释
-
-**只允许英文**。Go 和 TypeScript 都强制。如果在代码里看到中文注释，那就是 bug，替换掉。
-
-### Commit message
-
-Conventional 格式：`feat(scope)`、`fix(scope)`、`refactor(scope)`、`docs`、`test(scope)`、`chore(scope)`。按意图原子化分组。
-
----
-
-## 2. i18n 翻译术语表
-
-这是每个翻译 PR 都必须遵守的术语表。原本在 `packages/views/locales/glossary.md`，那个文件现在是个 stub，指向这一页。
-
-### 核心区分：实体 vs 概念
-
-Multica 的产品名词分两类：
-
-- **实体（typed entity）** —— 有 URL、有数据库 row、是 API 响应里某种 type 的东西。中文里**用小写英文**呈现，视觉上像类型名，告诉读者"这是 Multica 系统里的特定实体"。
-- **概念（concept）** —— 不是数据库实体的普通名词。**完整翻译成中文**，CN 用户看不到生硬的英文。
-
-这套规则与 `apps/docs/content/docs/*.zh.mdx` 完全对齐 —— docs 是已经实战 20+ 篇的 CN voice 标准。
-
-### 实体词的混合规则（`issue` / `skill` / `task`）
-
-`issue` / `skill` / `task` 是 Multica 的核心实体。schema 字段、API 字段、产品 UI 标签都用英文。中文里采用**混合规则** —— 词出现在哪里决定怎么写：
-
-| 场景 | 写法 | 例 |
-| --- | --- | --- |
-| **UI 短句 / 状态名 / 代码上下文** | 小写英文 | "排队中的 task"、"创建子 issue"、"为智能体注入 skill" |
-| **doc 标题 / 章节标题** | 首字母大写英文，**或**对应中文术语 | "Issue 与 project"、"Skills"、"执行任务" |
-| **doc 正文长篇讨论中作为主语** | 中文术语，首次出现配括号英文 | "**执行任务**（task）是智能体每一次工作的单位" |
-| **API / DB 字段** | 永远 `task` / `issue` / `skill` | `task_id`、`issue_status`、`skill_uuid` |
-
-中文术语对照：
-
-- `task` ↔ `执行任务`（上下文清楚后可简写为「任务」）
-- `issue` 没有公认中文译法 —— 保留英文；标题可大写为 `Issue`
-- `skill` 没有公认中文译法 —— 保留英文；标题可大写为 `Skills`
-
-**为什么 `issue` / `skill` / `task` 不强制译，而 `project` / `autopilot` 必译**：
-
-- **`issue` / `task`**：dev 团队习惯说英文，"任务"在中文里和"工作"几乎同义太空泛，"工单"是 IT 工单语义，"议题"是 GitHub 风格但用户场景不匹配 —— 三个候选都不如 `issue` 准确。**但**在长篇 doc 正文里，重复 50 次 `task` 节奏不顺，所以正文允许用 `执行任务`，UI 短句、状态名仍保持小写英文。
-- **`skill`**：Multica 特有概念，没有公认中文译法。
-- **`project` 翻成「项目」**：中文里早就稳定的日常词。飞书 / Tower / Teambition / PingCode / GitHub Projects 中文版 0 例外都翻译成「项目」，没有产品保留 `project`。
-- **`autopilot` 翻成「自动化」**：autopilot 在中文里联想到特斯拉的「自动驾驶」，跟产品功能（按周期跑 task）对应不上。Notion / 飞书都用「自动化」，是行业共识。
-
-### 完整翻译 —— 概念词
-
-| 英 | 中 |
-| --- | --- |
-| Workspace | **工作区** |
-| Agent | **智能体** |
-| Project | **项目** |
-| Autopilot | **自动化** |
-| Daemon | **守护进程** |
-| Runtime | **运行时** |
-| Inbox | **收件箱** |
-| Comment | **评论** |
-| Reply | **回复** |
-| Notifications | **通知** |
-| Member | **成员** |
-| Label | **标签** |
-| Settings | **设置** |
-| Onboarding | **上手引导** |
-
-### 不翻 —— 品牌名 + 通用缩写
-
-| 类别 | 词 |
-| --- | --- |
-| 品牌 | **Multica**、GitHub、Slack、Google、Anthropic、OpenAI、Claude、Codex、Cursor、Linear、Jira |
-| 缩写 | API、CLI、URL、SDK、OAuth、JWT、SSO、WebSocket、HTTP、JSON、YAML、SQL |
-
-### 完整翻译 —— 通用 UI 词
-
-| 英 | 中 |
-| --- | --- |
-| Invite / Invitation | 邀请 |
-| Search | 搜索 |
-| Email | 邮箱（label）/ 邮件（action） |
-| Password | 密码 |
-| Sign in / Log in | 登录 |
-| Sign up | 注册 |
-| Sign out / Log out | 退出登录 |
-| Save / Cancel / Delete | 保存 / 取消 / 删除 |
-| Confirm / Continue / Back | 确认 / 继续 / 返回 |
-| Edit / New / Create / Add | 编辑 / 新建 / 创建 / 添加 |
-| Remove / Send / Open / Close | 移除 / 发送 / 打开 / 关闭 |
-| Done / Loading... | 完成 / 加载中... |
-| Profile / Account / Appearance | 个人资料 / 账号 / 外观 |
-| Theme / Language | 主题 / 语言 |
-| Light / Dark / System | 浅色 / 深色 / 跟随系统 |
-| Active / Archived | 活跃（或 启用）/ 已归档 |
-| Status / Priority | 状态 / 优先级 |
-| Assignee / Reporter | 负责人 / 报告人 |
-| Description / Title | 描述 / 标题 |
-| Date / Time | 日期 / 时间 |
-| Today / Yesterday / Tomorrow | 今天 / 昨天 / 明天 |
-| Empty / Failed / Success | 空 / 失败 / 成功 |
-| Error / Warning | 错误 / 警告 |
-
-### 角色名 + 状态名（小写英文，不翻）
-
-这些是 schema-level 标识符，中文环境也保持小写英文：
-
-- 角色：`owner` / `admin` / `member`
-- Issue 状态：`backlog` / `todo` / `in_progress` / `in_review` / `done` / `blocked` / `cancelled`
-
-UI 里展示这些值时保持英文（必要时用 code-style 包起来）：
-
-- "你需要 owner 权限"
-- "已切换到 in_progress"
-
-### 词组组合规则
-
-英文词（实体名 + 品牌名 + 缩写）与中文之间**加单空格**：
-
-- "Create new issue" → "新建 issue"
-- "Assign to agent" → "分配给智能体"
-- "Configure runtime" → "配置运行时"
-- "Stop daemon" → "停止守护进程"
-
-### 复数与计数
-
-i18next 用 `_one` / `_other`；中文不区分语法单复数，只填 `_other`。
-
-```json
-// en/issues.json
-{
-  "issue_count_one": "{{count}} issue",
-  "issue_count_other": "{{count}} issues"
-}
-
-// zh-Hans/issues.json
-{
-  "issue_count_other": "{{count}} 个 issue"
-}
-```
-
-常见计数格式：
-
-- `{{count}} issues` → `{{count}} 个 issue`
-- `{{count}} agents` → `{{count}} 个智能体`
-- `{{count}} workspaces` → `{{count}} 个工作区`
-- `{{count}} comments` → `{{count}} 条评论`
-- `{{count}} members` → `{{count}} 位成员`
-- `{{count}} skills` → `{{count}} 个 skill`
-
-### 插值
-
-用 `{{var}}` 形式。中文翻译可以调整位置以符合中文语序。
-
-```json
-// en
-{ "welcome_message": "Welcome back, {{name}}!" }
-
-// zh-Hans
-{ "welcome_message": "欢迎回来，{{name}}！" }
-```
-
-### Key 命名约定
-
-3 层嵌套：`feature.component.action`。
-
-```json
-{
-  "feature_or_component": {
-    "subcomponent_or_section": {
-      "action_or_label": "..."
-    }
-  }
-}
-```
-
-实例：
-
-- `issues.toolbar.batch_update_success`
-- `issues.detail.comment_form.placeholder`
-- `inbox.empty.title`
-- `settings.preferences.language.title`
-
-### Web-only / Desktop-only 文案位置
-
-- 共享文案：放 namespace JSON 顶层
-- Web-only：放 `web` 段
-- Desktop-only：放 `desktop` 段
-
-参考 `auth.json`（`web` 段含 `prefer_desktop` / `desktop_handoff.*`）。
-
----
-
-## 3. 中文风格
-
-### 标点
-
-- 中文用全角标点：`，。：；！？`
-- 引号：用 `"..."`（直引号），与英文 source 保持一致。**不要**用 `「」` 或弯引号
-- 省略号：用 `...`（三点）而非 `…`（单字符），与英文 source 保持一致
-- 中英混排：英文词左右各加 1 个空格（详见词组组合规则）
-
-### 风格原则
-
-- **简洁直白**：避免翻译腔，"对于 X 来说"、"作为 X"、"我们的"
-- **错误信息**：温和但明确，"无法保存修改" 优于 "保存修改失败了！"
-- **按钮**：动词开头，2-4 字最佳。"取消"、"保存修改"、"立即同步"
-- **Tooltip**：完整短句。"复制链接到剪贴板"
-- **placeholder**：示例性提示。"输入 issue 标题..."
-
-### 拿不准的时候去哪查
-
-术语表没覆盖的词，按这个顺序查：
-
-1. `apps/docs/content/docs/*.zh.mdx` —— CN voice 事实标准，20+ 篇高度一致
-2. `packages/views/locales/zh-Hans/auth.json` 和 `editor.json` —— JSON 结构 + selector API 用法参考
-3. `packages/views/auth/login-page.tsx` —— 组件层 selector API 调用参考
-4. `packages/views/settings/components/preferences-tab.tsx` —— 语言切换器参考
-
----
-
-## 修改这一页时
-
-改本页规则的同时还要：
-
-1. 把规则在相关 locale JSON / CLAUDE.md / docs 页面里同步落地
-2. PR 描述里写明改了什么，方便 reviewer 检查下游是否跟着改了
-
-本页是契约，其他文档不能 override。

apps/docs/content/docs/developers/meta.json

@@ -1,4 +0,0 @@
-{
-  "title": "Developers",
-  "pages": ["conventions"]
-}

apps/docs/content/docs/developers/meta.zh.json

@@ -1,4 +1,4 @@
 {
   "title": "Developers",
-  "pages": ["contributing", "architecture", "conventions"]
+  "pages": ["contributing", "architecture"]
 }

apps/docs/content/docs/environment-variables.mdx

@@ -66,19 +66,13 @@ Multica stores user-uploaded attachments (images and files in comments). **S3 is
 
 | Variable | Default | Description |
 |---|---|---|
-| `S3_BUCKET` | empty | **Bucket name only** (for example `my-bucket`). Do **not** include the `.s3.<region>.amazonaws.com` suffix — the server constructs the public host from `S3_BUCKET` + `S3_REGION`. Setting this enables S3 storage |
-| `S3_REGION` | `us-west-2` | AWS region. Must match the bucket's actual region — it is used both for SDK signing and for building the public URL |
+| `S3_BUCKET` | empty | Setting this enables S3 storage |
+| `S3_REGION` | `us-west-2` | AWS region |
 | `AWS_ACCESS_KEY_ID` / `AWS_SECRET_ACCESS_KEY` | empty | Static credentials. When both are unset, the AWS SDK default credential chain is used (IAM role / environment credentials) |
 | `AWS_ENDPOINT_URL` | empty | Custom S3-compatible endpoint (for example [MinIO](https://min.io/)). Setting this switches to path-style URLs |
 
 **When `S3_BUCKET` is unset**: the server logs `"S3_BUCKET not set, cloud upload disabled"` at startup, and all uploads fall back to local disk.
 
-**Public URLs** are constructed in this order of priority:
-
-1. `https://<CLOUDFRONT_DOMAIN>/<key>` if `CLOUDFRONT_DOMAIN` is set.
-2. `<AWS_ENDPOINT_URL>/<S3_BUCKET>/<key>` (path-style) if `AWS_ENDPOINT_URL` is set.
-3. `https://<S3_BUCKET>.s3.<S3_REGION>.amazonaws.com/<key>` (virtual-hosted-style). When `S3_BUCKET` contains dots, the server falls back to `https://s3.<S3_REGION>.amazonaws.com/<S3_BUCKET>/<key>` (path-style) because the AWS-issued wildcard TLS certificate does not validate dotted bucket hosts.
-
 ### Local disk (when S3 is not configured)
 
 | Variable | Default | Description |

apps/docs/content/docs/environment-variables.zh.mdx

@@ -66,19 +66,13 @@ Multica 存储用户上传的附件（评论里的图片、文件等）。**优
 
 | 环境变量 | 默认值 | 说明 |
 |---|---|---|
-| `S3_BUCKET` | 空 | **只填 bucket 名**（例如 `my-bucket`），**不要**带 `.s3.<region>.amazonaws.com` 后缀——server 会用 `S3_BUCKET` + `S3_REGION` 自己拼公开 host。设了就启用 S3 存储 |
-| `S3_REGION` | `us-west-2` | AWS 区域。必须和 bucket 所在区域一致——SDK 签名和公开 URL 都用它 |
+| `S3_BUCKET` | 空 | 设了就启用 S3 存储 |
+| `S3_REGION` | `us-west-2` | AWS 区域 |
 | `AWS_ACCESS_KEY_ID` / `AWS_SECRET_ACCESS_KEY` | 空 | 静态凭证。全未设时用 AWS SDK 默认凭证链（IAM role / 环境凭证）|
 | `AWS_ENDPOINT_URL` | 空 | 自定义 S3 兼容端点（例如 [MinIO](https://min.io/)）。设了会切到 path-style URL |
 
 **`S3_BUCKET` 未设时**：server 启动时打 info 日志 `"S3_BUCKET not set, cloud upload disabled"`，所有上传回落到本地磁盘。
 
-**公开 URL** 按优先级拼装：
-
-1. 设了 `CLOUDFRONT_DOMAIN` → `https://<CLOUDFRONT_DOMAIN>/<key>`
-2. 设了 `AWS_ENDPOINT_URL` → `<AWS_ENDPOINT_URL>/<S3_BUCKET>/<key>`（path-style）
-3. 默认走 AWS S3 → `https://<S3_BUCKET>.s3.<S3_REGION>.amazonaws.com/<key>`（virtual-hosted-style）。bucket 名含点时会回落到 `https://s3.<S3_REGION>.amazonaws.com/<S3_BUCKET>/<key>`（path-style），因为 AWS 通配证书无法覆盖含点 host。
-
 ### 本地磁盘（S3 未配时）
 
 | 环境变量 | 默认值 | 说明 |

apps/docs/content/docs/getting-started/self-hosting.zh.mdx

@@ -212,15 +212,13 @@ Changes take effect after restarting the backend / compose stack. The web UI rea
 
 ### File Storage (Optional)
 
-For file uploads and attachments, configure S3 and (optionally) CloudFront:
+For file uploads and attachments, configure S3 and CloudFront:
 
 | Variable | Description |
 |----------|-------------|
-| `S3_BUCKET` | Bucket name only (e.g. `my-bucket`). Do **not** include the `.s3.<region>.amazonaws.com` suffix — the server constructs the public URL from `S3_BUCKET` + `S3_REGION` |
-| `S3_REGION` | AWS region (default: `us-west-2`). Must match the bucket's actual region — used for both SDK signing and public URLs |
-| `AWS_ACCESS_KEY_ID` / `AWS_SECRET_ACCESS_KEY` | Static credentials. When both are unset, the AWS SDK default credential chain is used |
-| `AWS_ENDPOINT_URL` | Custom S3-compatible endpoint (e.g. MinIO, R2, B2). Setting this switches the public URL to path-style |
-| `CLOUDFRONT_DOMAIN` | CloudFront distribution domain — when set, public URLs use this host instead of the S3 host |
+| `S3_BUCKET` | S3 bucket name |
+| `S3_REGION` | AWS region (default: `us-west-2`) |
+| `CLOUDFRONT_DOMAIN` | CloudFront distribution domain |
 | `CLOUDFRONT_KEY_PAIR_ID` | CloudFront key pair ID for signed URLs |
 | `CLOUDFRONT_PRIVATE_KEY` | CloudFront private key (PEM format) |
 

apps/docs/content/docs/guides/agents.zh.mdx

@@ -40,7 +40,7 @@ The daemon auto-detects which CLIs are available on your PATH and registers them
 
 Multica supports two layers of skills:
 
-- **Local skills** — Skills already installed in your local runtime (e.g., `.claude/skills/`, `.opencode/skills/`) are automatically discovered and used by agents. You do **not** need to upload them to Multica.
+- **Local skills** — Skills already installed in your local runtime (e.g., `.claude/skills/`, `.config/opencode/skills/`) are automatically discovered and used by agents. You do **not** need to upload them to Multica.
 - **Workspace skills** — Skills created or imported in the Multica Skills page are shared across the workspace. They are automatically injected into agent runs as supplementary context, so every team member's agents benefit from them.
 
 Workspace skills are designed for team-wide sharing and collaboration — codify your team's best practices once, and every agent can leverage them:

apps/docs/content/docs/meta.json

@@ -9,9 +9,7 @@
     "workspaces",
     "members-roles",
     "issues",
-    "projects",
     "comments",
-    "project-resources",
     "---Agents---",
     "agents",
     "agents-create",
@@ -34,8 +32,6 @@
     "---Reference---",
     "cli",
     "auth-tokens",
-    "desktop-app",
-    "---Developers---",
-    "developers"
+    "desktop-app"
   ]
 }

apps/docs/content/docs/meta.zh.json

@@ -9,7 +9,6 @@
     "workspaces",
     "members-roles",
     "issues",
-    "projects",
     "comments",
     "---智能体---",
     "agents",
@@ -33,8 +32,6 @@
     "---参考---",
     "cli",
     "auth-tokens",
-    "desktop-app",
-    "---开发者---",
-    "developers"
+    "desktop-app"
   ]
 }

apps/docs/content/docs/project-resources.mdx

@@ -1,144 +0,0 @@
----
-title: Project Resources
-description: Attach typed pointers (Git repos today, more later) to a project so agents can pick them up as scoped context.
----
-
-A **Project Resource** is a typed pointer — a Git repo URL today, a Notion page or document link tomorrow — attached to a [project](/workspaces). When an [agent](/agents) runs against an issue inside that project, the daemon automatically writes the project's resource list into the agent's working directory and into its [meta-skill](/skills) prompt.
-
-The result: the agent knows which repo to check out, which docs are the "primary references" for this project, without anyone copy-pasting context into the issue body.
-
-## Mental model
-
-A project is no longer just a label. It is a small **resource container**:
-
-- A project has 0..N **resources**.
-- A resource has a `resource_type` (e.g. `github_repo`) and a `resource_ref` (a JSON payload typed by `resource_type`).
-- New resource types add a string + a handler. **No schema migration. No frontend rewrite.**
-
-This shape is intentional — it's the same pattern Multica already uses for agent providers: a `type` discriminator and a typed payload. It keeps the schema stable so adding "Notion page", "Google Doc", "uploaded file", or "external URL" later is a small, additive change.
-
-## Today: `github_repo`
-
-The first resource type ships ready to use:
-
-```json
-{
-  "resource_type": "github_repo",
-  "resource_ref": {
-    "url": "https://github.com/owner/repo",
-    "default_branch_hint": "main"
-  }
-}
-```
-
-`default_branch_hint` is optional — if present, the daemon surfaces it in the meta-skill so the agent knows which branch to base its work on.
-
-## Attaching repos at project creation
-
-In the **Web** or **Desktop** app, opening *New project* now shows a **Repos** pill alongside Status / Priority / Lead. Selecting workspace-bound repos (or pasting an ad-hoc URL) attaches them as `github_repo` resources the moment the project is created.
-
-From the **CLI**:
-
-```bash
-# Create + attach in one shot. The server attaches resources in the same
-# transaction as the project create — invalid resources roll back the whole
-# operation, so you never end up with a project that has half its resources.
-multica project create \
-  --title "Agent UX 2026" \
-  --repo https://github.com/multica-ai/multica
-
-# Manage resources later
-multica project resource list <project-id>
-multica project resource add  <project-id> --type github_repo --url <url>
-multica project resource remove <project-id> <resource-id>
-
-# Generic escape hatch for any resource_type the server understands —
-# no CLI change needed when a new type ships:
-multica project resource add <project-id> \
-  --type notion_page \
-  --ref '{"page_id":"…","title":"…"}'
-```
-
-`--repo` may be repeated; each value is attached as a separate `github_repo` resource.
-
-## What the agent sees at runtime
-
-When the daemon spawns an agent for an issue inside a project, two things happen:
-
-### 1. `.multica/project/resources.json`
-
-A structured pass-through of the API response, written into the agent's working directory:
-
-```json
-{
-  "project_id": "…",
-  "project_title": "Agent UX 2026",
-  "resources": [
-    {
-      "id": "…",
-      "resource_type": "github_repo",
-      "resource_ref": {
-        "url": "https://github.com/multica-ai/multica",
-        "default_branch_hint": "main"
-      }
-    }
-  ]
-}
-```
-
-Skills, helper scripts, or the agent itself can parse this file when they need the *exact* set of resources for the run.
-
-### 2. A "Project Context" section in the meta-skill prompt
-
-The agent's `CLAUDE.md` / `AGENTS.md` (depending on provider) now includes a human-readable summary:
-
-```
-## Project Context
-
-This issue belongs to **Agent UX 2026**.
-
-Project resources (also written to `.multica/project/resources.json`):
-
-- **GitHub repo**: https://github.com/multica-ai/multica (default branch: `main`)
-
-Resources are pointers — open them only when relevant to the task. For
-`github_repo` resources, use `multica repo checkout <url>` to fetch the code.
-```
-
-The text is intentionally minimal. The full payload is on disk; the prompt only orients the agent so it knows the project exists and what's attached.
-
-### Failure mode
-
-Resource fetch is **best-effort**. If the API call fails, the project section is omitted from the prompt and the file is not written, but the task still starts. Agents never block on missing project context.
-
-## Adding a new resource type
-
-The whole point of the abstraction is that new types are cheap. The full path:
-
-1. **Server validator** (`server/internal/handler/project_resource.go`) — add a case in `validateAndNormalizeResourceRef` that parses and normalizes the new payload.
-2. **Daemon meta-skill formatter** (`server/internal/daemon/execenv/runtime_config.go`) — add a case in `formatProjectResource` so the agent prompt renders the new type as a readable bullet.
-3. **TypeScript types** (`packages/core/types/project.ts`) — extend `ProjectResourceType` and add the payload interface.
-4. **UI renderer** (`packages/views/projects/components/project-resources-section.tsx`) — add a case in `ResourceRow` for the new type.
-
-There is **no schema migration**, no new sqlc query, no new endpoint, **and no CLI change** — the CLI's generic `--ref '<json>'` flag accepts any payload the validator understands, so day-one support for a new type is purely the four steps above. (You may *optionally* add a per-type CLI shortcut later; not required.)
-
-The same `project_resource` table and the same three CRUD calls handle every type.
-
-## Workspace repos vs. project repos
-
-The repo list shown to the agent (`## Repositories` block in `CLAUDE.md` / `AGENTS.md`) is chosen by the daemon claim handler with this precedence:
-
-- **Project has at least one `github_repo` resource** → only those repos are surfaced to the agent. Workspace-bound repos are intentionally hidden so the agent doesn't have to guess which one belongs to this issue.
-- **Project has no `github_repo` resources (or the issue isn't in a project)** → fall back to the workspace's repo list as before.
-
-This keeps the agent's working set tight: when a project is explicit about its repos, that's the authoritative answer. The structured resource list at `.multica/project/resources.json` always carries the full set, so a skill that wants to inspect everything still can.
-
-The daemon mirrors this on the checkout side: when a task arrives with project-scoped `github_repo` URLs, those URLs are merged into the per-workspace allowlist *and* synced into the local repo cache before the agent spawns. So a project repo URL that isn't bound at the workspace level is still a valid argument to `multica repo checkout` — the daemon won't reject it as "not configured." The allowlist split is internal: workspace-bound URLs and task-scoped URLs are tracked separately, so a workspace-repos refresh doesn't accidentally revoke a project URL mid-run.
-
-## What's intentionally **not** in scope here
-
-- **Cross-project sharing.** Each resource lives on exactly one project today.
-- **Per-skill resource scoping.** All resources are visible to every skill on the agent's run; type-aware filtering is a follow-up.
-- **Caching / sync.** `github_repo` is just metadata — checkout still happens via `multica repo checkout` on demand. Cached document text for Notion / Google Docs will arrive with those types.
-
-These are deliberate omissions — the goal of the first cut is to validate the abstraction with the smallest set of moving parts.

apps/docs/content/docs/projects.mdx

@@ -1,49 +0,0 @@
----
-title: Projects
-description: Group related issues and track them as one unit — with priority, status, progress, and an owner.
----
-
-import { Callout } from "fumadocs-ui/components/callout";
-
-A **project** in Multica is a container for related [issues](/issues). Use it when a body of work is bigger than one issue but smaller than a full workspace — a launch, a migration, a feature with multiple parts, an investigation that branches into several threads.
-
-Each project has a name, an icon, a description, a **lead** (a member or an [agent](/agents)), a **status** (`planned` / `in_progress` / `paused` / `completed` / `cancelled`), a **priority** (`urgent` / `high` / `medium` / `low` / `none`), and a **progress** percentage that's auto-derived from the status of its linked issues.
-
-## How projects relate to issues
-
-Projects and issues are independent objects with a many-to-one relationship: an issue can belong to **at most one** project; a project holds **any number of** issues. Linking and unlinking is reversible at any time — drag in the board view, or use the project picker on the issue's right-side properties panel.
-
-The progress bar on a project is computed from its linked issues — the more issues hit `done`, the further it fills. Issues that are `cancelled` are excluded from the count; issues in `backlog` count toward the denominator but not the numerator.
-
-## Pinning to the sidebar
-
-Click the pin icon in a project's top-right corner to add it to your sidebar's pinned list. Pinned projects stay one click away no matter where you are in the workspace; everyone on the team can pin independently — pins are personal.
-
-The sidebar **Workspace → Projects** link always shows every project in the workspace; pinning is a personal shortcut on top of that.
-
-## Attaching resources
-
-Each project has a **Resources** section where you attach GitHub repositories. Once attached, any [agent](/agents) assigned to issues in this project can read and write to those repos when executing tasks — Multica passes the repo URLs as context to the [daemon](/daemon-runtimes).
-
-Resources are per-project; if multiple projects share a repo, attach it to each one.
-
-## Deleting a project
-
-Deleting a project **does not delete its issues**. The linked issues are simply unlinked and revert to the workspace's flat issue list. This is intentional — work that was scoped to a project is rarely throwaway, even when the framing of the project changes.
-
-<Callout type="info">
-If you want to delete the work too, archive or delete the issues first, then delete the project.
-</Callout>
-
-## Project lead
-
-The lead is the person — or agent — accountable for the project. It's a soft signal, not an access control: any workspace member can edit a project regardless of who's lead. A project's lead can be:
-
-- A workspace member (human teammate)
-- An [agent](/agents) — useful when the project's work is mostly delegated to an agent (e.g., "Weekly bug triage" led by a triage agent)
-
-## Next
-
-- [Issues](/issues) — the unit of work that lives inside projects
-- [Agents as project lead](/agents) — when an agent is the right owner
-- [How Multica works](/how-multica-works) — the broader picture

apps/docs/content/docs/projects.zh.mdx

@@ -1,49 +0,0 @@
----
-title: 项目
-description: 把相关的 issue 归为一组当成一个单元来跟进 —— 有优先级、状态、进度和负责人。
----
-
-import { Callout } from "fumadocs-ui/components/callout";
-
-Multica 里的**项目**（project）是相关 [issue](/issues) 的容器。当一摊工作比单个 issue 大、又比整个工作区小的时候用它 —— 一次发布、一次迁移、一个分多块做的功能、一个会拆出多个线索的调研。
-
-每个项目有名字、图标、描述、**负责人**（lead，可以是成员，也可以是 [智能体](/agents)）、**状态**（`planned` / `in_progress` / `paused` / `completed` / `cancelled`）、**优先级**（`urgent` / `high` / `medium` / `low` / `none`），以及一个根据关联 issue 状态自动算出来的**进度**百分比。
-
-## 项目和 issue 的关系
-
-项目和 issue 是独立对象，多对一关系：一个 issue **最多属于一个**项目；一个项目可以容纳**任意多个** issue。关联和解除关联随时可逆 —— 在看板视图里拖动，或者在 issue 右侧 properties 面板用项目选择器。
-
-项目的进度条是按关联 issue 状态自动算出来的 —— 越多 issue 到 `done`，进度条越满。`cancelled` 的 issue 不计入分母；`backlog` 的 issue 计入分母但不计入分子。
-
-## pin 到侧边栏
-
-点项目右上角的 pin 图标，可以把这个项目加到侧边栏的固定区。pin 过的项目无论你在工作区哪里都一键可达；每个人独立 pin —— pin 是个人偏好。
-
-侧边栏 **Workspace → Projects** 链接始终展示工作区里所有项目；pin 只是在这之上的个人快捷方式。
-
-## 关联 resources
-
-每个项目有一个 **Resources** 区，可以挂 GitHub 仓库。挂上之后，被分配到这个项目里 issue 的 [智能体](/agents) 在执行 task 时可以读写这些仓库 —— Multica 会把仓库 URL 作为上下文传给 [守护进程](/daemon-runtimes)。
-
-Resources 是项目级别的；多个项目要共享同一个仓库，要分别挂上。
-
-## 删除项目
-
-删除项目**不会**删除它的 issue。关联的 issue 只是解除关联，回到工作区的扁平 issue 列表。这是刻意的 —— 即使项目本身的框架变了，里面的工作通常也不会是一次性的。
-
-<Callout type="info">
-如果你确实想把工作也删掉，先归档或删除 issue，再删除项目。
-</Callout>
-
-## 项目负责人
-
-负责人是为这个项目负总责的人 —— 或者智能体。这是一个软信号，不是权限控制：工作区任何成员都可以编辑项目，不管谁是负责人。项目负责人可以是：
-
-- 工作区里的成员（人）
-- [智能体](/agents) —— 当项目里的工作大部分要交给智能体时合适（例如"每周 bug 巡检"由一个巡检智能体担任 lead）
-
-## 下一步
-
-- [Issues](/issues) —— 项目里装的工作单元
-- [智能体担任项目负责人](/agents) —— 什么时候由智能体当 lead 合适
-- [Multica 怎么运转](/how-multica-works) —— 整体视图

apps/docs/content/docs/providers.mdx

@@ -21,7 +21,7 @@ For guidance on picking a tool when creating an agent, see [Creating and configu
 | **Hermes** | Nous Research | ✅ | ❌ | `.agent_context/skills/` (fallback) | Dynamic discovery |
 | **Kimi** | Moonshot | ✅ | ❌ | `.kimi/skills/` | Dynamic discovery |
 | **Kiro CLI** | Amazon | ✅ | ❌ | `.kiro/skills/` | Dynamic discovery |
-| **OpenCode** | SST | ✅ | ❌ | `.opencode/skills/` | Dynamic discovery |
+| **OpenCode** | SST | ✅ | ❌ | `.config/opencode/skills/` | Dynamic discovery |
 | **OpenClaw** | Open source | ✅ | ❌ | `.agent_context/skills/` (fallback) | Bound to the agent, can't be switched per task |
 | **Pi** | Inflection AI | ✅ (session is a file path) | ❌ | `.pi/skills/` | Dynamic discovery |
 
@@ -103,7 +103,7 @@ Each tool uses **its own** skill discovery path. Before a task runs, the Multica
 | Cursor | `.cursor/skills/` | ✅ Native |
 | Kimi | `.kimi/skills/` | ✅ Native |
 | Kiro CLI | `.kiro/skills/` | ✅ Native |
-| OpenCode | `.opencode/skills/` | ✅ Native |
+| OpenCode | `.config/opencode/skills/` | ✅ Native |
 | Pi | `.pi/skills/` | ✅ Native |
 | Gemini | `.agent_context/skills/` | ⚠️ Generic fallback |
 | Hermes | `.agent_context/skills/` | ⚠️ Generic fallback |

apps/docs/content/docs/providers.zh.mdx

@@ -21,7 +21,7 @@ Multica 内置支持 **11 款 AI 编程工具**。它们都实现了同一套接
 | **Hermes** | Nous Research | ✅ | ❌ | `.agent_context/skills/` （fallback）| 动态发现 |
 | **Kimi** | Moonshot | ✅ | ❌ | `.kimi/skills/` | 动态发现 |
 | **Kiro CLI** | Amazon | ✅ | ❌ | `.kiro/skills/` | 动态发现 |
-| **OpenCode** | SST | ✅ | ❌ | `.opencode/skills/` | 动态发现 |
+| **OpenCode** | SST | ✅ | ❌ | `.config/opencode/skills/` | 动态发现 |
 | **OpenClaw** | 开源项目 | ✅ | ❌ | `.agent_context/skills/` （fallback）| 绑定在智能体上，不能在任务里切换 |
 | **Pi** | Inflection AI | ✅（session 为文件路径）| ❌ | `.pi/skills/` | 动态发现 |
 
@@ -103,7 +103,7 @@ Inflection AI 出品，极简主义。**会话恢复机制特殊**——session
 | Cursor | `.cursor/skills/` | ✅ 原生 |
 | Kimi | `.kimi/skills/` | ✅ 原生 |
 | Kiro CLI | `.kiro/skills/` | ✅ 原生 |
-| OpenCode | `.opencode/skills/` | ✅ 原生 |
+| OpenCode | `.config/opencode/skills/` | ✅ 原生 |
 | Pi | `.pi/skills/` | ✅ 原生 |
 | Gemini | `.agent_context/skills/` | ⚠️ 通用 fallback |
 | Hermes | `.agent_context/skills/` | ⚠️ 通用 fallback |

apps/docs/content/docs/self-host-quickstart.mdx

@@ -116,4 +116,4 @@ Same flow as Cloud — see [Cloud quickstart → Steps 5-6](/cloud-quickstart#5-
 - [Environment variables](/environment-variables) — full env reference
 - [Auth setup](/auth-setup) — Resend / OAuth / signup allowlist in detail
 - [Troubleshooting](/troubleshooting) — start here when things go wrong
-- [Desktop app](/desktop-app) — optional Desktop setup via `~/.multica/desktop.json`; the web frontend + CLI remains the quickest self-host path
+- [Desktop app](/desktop-app) — released Desktop builds connect to Multica Cloud only; using Desktop with self-host requires a custom build (see the callout in the desktop-app page)

apps/docs/content/docs/self-host-quickstart.zh.mdx

@@ -115,4 +115,4 @@ multica setup self-host
 - [环境变量](/environment-variables) —— 完整 env 清单
 - [登录与注册配置](/auth-setup) —— Resend / OAuth / 注册白名单详细配置
 - [故障排查](/troubleshooting) —— 遇到问题先来这里
-- [桌面应用](/desktop-app) —— 可以通过 `~/.multica/desktop.json` 连接 Desktop；Web 前端 + CLI 仍然是最快的自部署路径
+- [桌面应用](/desktop-app) —— 发布版 Desktop 只连 Multica Cloud；要让 Desktop 连自部署后端需要自行构建（详见 desktop-app 页的提示）

apps/docs/content/docs/tasks.mdx

@@ -63,8 +63,6 @@ Automatic retry also has two extra conditions:
 
 <Callout type="warning">
 **Autopilot tasks don't retry automatically** by design. An Autopilot has its own firing cadence (e.g. daily); automatic retries on failure would overlap with the next scheduled run. If you need an immediate re-run after failure, use a manual rerun (next section).
-
-**How you'll know an Autopilot task failed**: a notification lands in your [Inbox](/inbox), and the associated issue's status reverts from `in_progress` back to `todo`. The [Autopilots](/autopilots) page also shows the latest run result per autopilot.
 </Callout>
 
 ## Manual rerun vs. automatic retry

apps/docs/content/docs/tasks.zh.mdx

@@ -63,8 +63,6 @@ Multica 服务器每 30 秒扫描一次，有两种超时会触发失败：
 
 <Callout type="warning">
 **Autopilots 任务不自动重试**是刻意设计。Autopilot 有自己的触发周期（例如每天一次）；如果失败又自动重试，会和下一个周期的任务重叠。需要失败后立即重跑，用手动重跑（下一节）。
-
-**怎么知道 Autopilot 失败了**：失败的 Autopilot 任务会在你的 [收件箱](/inbox) 里出现一条通知，关联的 issue 状态也会从 `in_progress` 退回 `todo`。直接打开 [Autopilots](/autopilots) 页面也能看到每条 autopilot 的最近运行结果。
 </Callout>
 
 ## 手动重跑和自动重试的区别

apps/docs/lib/locale-link.test.ts

@@ -1,52 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { prefixLocale } from "./locale-link";
-
-describe("prefixLocale", () => {
-  it("prefixes root-relative paths with the active non-default locale", () => {
-    expect(prefixLocale("/workspaces", "zh")).toBe("/zh/workspaces");
-    expect(prefixLocale("/agents-create", "zh")).toBe("/zh/agents-create");
-  });
-
-  it("preserves anchors and query strings on prefixed paths", () => {
-    expect(prefixLocale("/providers#claude-code", "zh")).toBe(
-      "/zh/providers#claude-code",
-    );
-    expect(prefixLocale("/agents?from=docs", "zh")).toBe(
-      "/zh/agents?from=docs",
-    );
-  });
-
-  it("rewrites the bare root path to the locale root", () => {
-    expect(prefixLocale("/", "zh")).toBe("/zh");
-  });
-
-  it("leaves the default language untouched (URLs are prefix-less)", () => {
-    expect(prefixLocale("/workspaces", "en")).toBe("/workspaces");
-    expect(prefixLocale("/", "en")).toBe("/");
-  });
-
-  it("does not double-prefix paths that already carry a known locale", () => {
-    expect(prefixLocale("/zh/workspaces", "zh")).toBe("/zh/workspaces");
-    expect(prefixLocale("/en/workspaces", "zh")).toBe("/en/workspaces");
-  });
-
-  it("leaves external URLs alone", () => {
-    expect(prefixLocale("https://multica.ai/download", "zh")).toBe(
-      "https://multica.ai/download",
-    );
-    expect(prefixLocale("mailto:hello@multica.ai", "zh")).toBe(
-      "mailto:hello@multica.ai",
-    );
-    expect(prefixLocale("tel:+1234567890", "zh")).toBe("tel:+1234567890");
-  });
-
-  it("leaves in-page anchors and relative paths alone", () => {
-    expect(prefixLocale("#section", "zh")).toBe("#section");
-    expect(prefixLocale("./sibling", "zh")).toBe("./sibling");
-    expect(prefixLocale("../sibling", "zh")).toBe("../sibling");
-  });
-
-  it("returns empty/undefined hrefs unchanged", () => {
-    expect(prefixLocale("", "zh")).toBe("");
-  });
-});

apps/docs/lib/locale-link.ts

@@ -1,31 +0,0 @@
-import { i18n } from "./i18n";
-
-// Add the active locale prefix to root-relative MDX links so internal
-// navigation inside Chinese (or any non-default-language) docs stays in
-// that language. Without this, `[xx](/workspaces)` written in a `*.zh.mdx`
-// renders as `<a href="/workspaces">`, which Next's basePath rewrites to
-// `/docs/workspaces` and the docs middleware then routes to English —
-// leaking the reader out of their chosen locale.
-//
-// We deliberately do NOT touch:
-//   - external links (`https:`, `mailto:`, `tel:`, etc.)
-//   - in-page anchors (`#section`)
-//   - relative paths (`./foo`, `../bar`)
-//   - paths already prefixed with a known locale
-//   - the default language (URLs are intentionally prefix-less under
-//     `hideLocale: 'default-locale'`)
-export function prefixLocale(href: string, lang: string): string {
-  if (!href) return href;
-  if (lang === i18n.defaultLanguage) return href;
-  if (/^[a-z][a-z0-9+.-]*:/i.test(href)) return href;
-  if (href.startsWith("#")) return href;
-  if (!href.startsWith("/")) return href;
-
-  const segments = href.split("/").filter(Boolean);
-  const first = segments[0];
-  if (first && (i18n.languages as readonly string[]).includes(first)) {
-    return href;
-  }
-
-  return href === "/" ? `/${lang}` : `/${lang}${href}`;
-}

apps/docs/package.json

@@ -8,7 +8,6 @@
     "build": "fumadocs-mdx && next build",
     "start": "next start",
     "typecheck": "fumadocs-mdx && tsc --noEmit",
-    "test": "vitest run",
     "postinstall": "fumadocs-mdx"
   },
   "dependencies": {
@@ -28,7 +27,6 @@
     "@types/react": "catalog:",
     "@types/react-dom": "catalog:",
     "tailwindcss": "catalog:",
-    "typescript": "catalog:",
-    "vitest": "catalog:"
+    "typescript": "catalog:"
   }
 }

apps/docs/vitest.config.ts

@@ -1,16 +0,0 @@
-import { defineConfig } from "vitest/config";
-import path from "path";
-
-export default defineConfig({
-  test: {
-    environment: "node",
-    globals: true,
-    include: ["**/*.test.{ts,tsx}"],
-    exclude: ["node_modules/**", ".next/**", ".source/**"],
-  },
-  resolve: {
-    alias: {
-      "@": path.resolve(__dirname, "."),
-    },
-  },
-});

apps/web/app/(auth)/invitations/page.tsx

@@ -1,28 +0,0 @@
-"use client";
-
-import { useEffect } from "react";
-import { useRouter } from "next/navigation";
-import { useAuthStore } from "@multica/core/auth";
-import { paths } from "@multica/core/paths";
-import { InvitationsPage } from "@multica/views/invitations";
-
-export default function InvitationsRoutePage() {
-  const router = useRouter();
-  const user = useAuthStore((s) => s.user);
-  const isLoading = useAuthStore((s) => s.isLoading);
-
-  // Unauthenticated users have nowhere meaningful to land here — kick them
-  // through login and bring them back. The login page will eventually run
-  // its own listMyInvitations() check and route them here again.
-  useEffect(() => {
-    if (!isLoading && !user) {
-      router.replace(
-        `${paths.login()}?next=${encodeURIComponent(paths.invitations())}`,
-      );
-    }
-  }, [isLoading, user, router]);
-
-  if (isLoading || !user) return null;
-
-  return <InvitationsPage />;
-}

apps/web/app/(auth)/login/page.test.tsx

@@ -2,22 +2,12 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 import { render, screen, waitFor } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { I18nProvider } from "@multica/core/i18n/react";
-import enCommon from "@multica/views/locales/en/common.json";
-import enAuth from "@multica/views/locales/en/auth.json";
-import enSettings from "@multica/views/locales/en/settings.json";
 import type { ReactNode } from "react";
 
-const TEST_RESOURCES = {
-  en: { common: enCommon, auth: enAuth, settings: enSettings },
-};
-
 function createWrapper() {
   const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
   return ({ children }: { children: ReactNode }) => (
-    <I18nProvider locale="en" resources={TEST_RESOURCES}>
-      <QueryClientProvider client={qc}>{children}</QueryClientProvider>
-    </I18nProvider>
+    <QueryClientProvider client={qc}>{children}</QueryClientProvider>
   );
 }
 

apps/web/app/(auth)/login/page.tsx

@@ -2,7 +2,7 @@
 
 import { Suspense, useEffect, useState } from "react";
 import { useSearchParams, useRouter } from "next/navigation";
-import { useQueryClient, type QueryClient } from "@tanstack/react-query";
+import { useQueryClient } from "@tanstack/react-query";
 import { sanitizeNextUrl, useAuthStore } from "@multica/core/auth";
 import { useConfigStore } from "@multica/core/config";
 import { workspaceKeys } from "@multica/core/workspace/queries";
@@ -26,38 +26,10 @@ import { captureDownloadIntent } from "@multica/core/analytics";
 import { setLoggedInCookie } from "@/features/auth/auth-cookie";
 import Link from "next/link";
 import { LoginPage, validateCliCallback } from "@multica/views/auth";
-import { useT } from "@multica/views/i18n";
-
-/**
- * Pick where a logged-in user with no explicit `?next=` should land.
- * Un-onboarded users with pending invitations on their email get routed to
- * the batch /invitations page; everyone else falls through to the standard
- * resolver. A network blip on listMyInvitations is non-fatal — we fall
- * through rather than trap the user on an error screen.
- */
-async function resolveLoggedInDestination(
-  qc: QueryClient,
-  hasOnboarded: boolean,
-  workspaces: Workspace[],
-): Promise<string> {
-  if (!hasOnboarded) {
-    try {
-      const invites = await api.listMyInvitations();
-      if (invites.length > 0) {
-        qc.setQueryData(workspaceKeys.myInvitations(), invites);
-        return paths.invitations();
-      }
-    } catch {
-      // fall through
-    }
-  }
-  return resolvePostAuthDestination(workspaces, hasOnboarded);
-}
 
 function LoginPageContent() {
   const router = useRouter();
   const qc = useQueryClient();
-  const { t } = useT("auth");
   const googleClientId = useConfigStore((state) => state.googleClientId);
   const user = useAuthStore((s) => s.user);
   const isLoading = useAuthStore((s) => s.isLoading);
@@ -95,35 +67,38 @@ function LoginPageContent() {
         })
         .catch((err) => {
           setDesktopError(
-            err instanceof Error
-              ? err.message
-              : t(($) => $.web.desktop_handoff.prepare_failed),
+            err instanceof Error ? err.message : "Failed to prepare Desktop sign-in",
           );
         });
       return;
     }
+    if (!hasOnboarded) {
+      router.replace(paths.onboarding());
+      return;
+    }
     if (nextUrl) {
       router.replace(nextUrl);
       return;
     }
     const list = qc.getQueryData<Workspace[]>(workspaceKeys.list()) ?? [];
-    void resolveLoggedInDestination(qc, hasOnboarded, list).then((dest) =>
-      router.replace(dest),
-    );
+    router.replace(resolvePostAuthDestination(list, hasOnboarded));
   }, [isLoading, user, router, nextUrl, cliCallbackRaw, isDesktopHandoff, hasOnboarded, qc]);
 
-  const handleSuccess = async () => {
+  const handleSuccess = () => {
     // Read the latest user snapshot directly — the closure's `hasOnboarded`
     // was captured before login completed and would be stale here.
     const currentUser = useAuthStore.getState().user;
     const onboarded = currentUser?.onboarded_at != null;
+    if (!onboarded) {
+      router.push(paths.onboarding());
+      return;
+    }
     if (nextUrl) {
       router.push(nextUrl);
       return;
     }
     const list = qc.getQueryData<Workspace[]>(workspaceKeys.list()) ?? [];
-    const dest = await resolveLoggedInDestination(qc, onboarded, list);
-    router.push(dest);
+    router.push(resolvePostAuthDestination(list, onboarded));
   };
 
   // Build Google OAuth state: encode platform + next URL so the callback
@@ -144,9 +119,7 @@ function LoginPageContent() {
         <div className="flex min-h-screen items-center justify-center">
           <Card className="w-full max-w-sm">
             <CardHeader className="text-center">
-              <CardTitle className="text-2xl">
-                {t(($) => $.web.desktop_handoff.failed_title)}
-              </CardTitle>
+              <CardTitle className="text-2xl">Sign-in Failed</CardTitle>
               <CardDescription>{desktopError}</CardDescription>
             </CardHeader>
           </Card>
@@ -157,13 +130,11 @@ function LoginPageContent() {
       <div className="flex min-h-screen items-center justify-center">
         <Card className="w-full max-w-sm">
           <CardHeader className="text-center">
-            <CardTitle className="text-2xl">
-              {t(($) => $.web.desktop_handoff.opening_title)}
-            </CardTitle>
+            <CardTitle className="text-2xl">Opening Multica</CardTitle>
             <CardDescription>
               {desktopToken
-                ? t(($) => $.web.desktop_handoff.opening_description)
-                : t(($) => $.web.desktop_handoff.preparing)}
+                ? "You should see a prompt to open the Multica desktop app. If nothing happens, click the button below."
+                : "Preparing Desktop sign-in..."}
             </CardDescription>
           </CardHeader>
           <CardContent className="flex justify-center">
@@ -174,7 +145,7 @@ function LoginPageContent() {
                   window.location.href = `multica://auth/callback?token=${encodeURIComponent(desktopToken)}`;
                 }}
               >
-                {t(($) => $.web.desktop_handoff.open_button)}
+                Open Multica Desktop
               </Button>
             ) : (
               <Loader2 className="h-6 w-6 animate-spin text-muted-foreground" />
@@ -204,14 +175,18 @@ function LoginPageContent() {
       }
       onTokenObtained={setLoggedInCookie}
       extra={
+        // Web-only nudge toward the desktop app. Copy is hardcoded EN
+        // for now because the login route sits outside the landing
+        // group's LocaleProvider — if this page ever becomes
+        // locale-aware, the strings live in positioning doc §3.3.
         <span className="text-xs text-muted-foreground">
-          {t(($) => $.web.prefer_desktop)}{" "}
+          Prefer the desktop app?{" "}
           <Link
             href="/download"
             onClick={() => captureDownloadIntent("login")}
             className="font-medium text-foreground underline decoration-foreground/30 underline-offset-4 hover:decoration-foreground/70"
           >
-            {t(($) => $.web.download)}
+            Download
           </Link>
         </span>
       }

apps/web/app/(auth)/onboarding/page.tsx

@@ -32,7 +32,7 @@ export default function OnboardingPage() {
   const hasOnboarded = useHasOnboarded();
   const { data: workspaces = [], isFetched: workspacesFetched } = useQuery({
     ...workspaceListOptions(),
-    enabled: !!user,
+    enabled: !!user && hasOnboarded,
   });
 
   useEffect(() => {
@@ -40,15 +40,7 @@ export default function OnboardingPage() {
       if (!isLoading && !user) router.replace(paths.login());
       return;
     }
-    if (!workspacesFetched) return;
-    // Bounce out only when onboarding genuinely doesn't apply: the user is
-    // already onboarded. We deliberately don't bounce on `workspaces.length`
-    // here — Step 3 of the flow creates a workspace mid-onboarding, and a
-    // hasWorkspaces bounce here would kick the user out before Steps 4–5
-    // (runtime / agent / first issue) can run. The new entry-point
-    // judgment in callback / login handles "where should this user go on
-    // login" so OnboardingPage no longer needs to second-guess it.
-    if (hasOnboarded) {
+    if (hasOnboarded && workspacesFetched) {
       router.replace(resolvePostAuthDestination(workspaces, hasOnboarded));
     }
   }, [isLoading, user, hasOnboarded, workspacesFetched, workspaces, router]);

apps/web/app/(landing)/layout.tsx

@@ -1,6 +1,5 @@
 import { cookies, headers } from "next/headers";
 import { Instrument_Serif, Noto_Serif_SC } from "next/font/google";
-import { LOCALE_COOKIE } from "@multica/core/i18n";
 import { LocaleProvider } from "@/features/landing/i18n";
 import type { Locale } from "@/features/landing/i18n";
 
@@ -44,7 +43,7 @@ const jsonLd = {
 async function getInitialLocale(): Promise<Locale> {
   // 1. User's explicit preference (cookie set when they switch language)
   const cookieStore = await cookies();
-  const stored = cookieStore.get(LOCALE_COOKIE)?.value;
+  const stored = cookieStore.get("multica-locale")?.value;
   if (stored === "en" || stored === "zh") return stored;
 
   // 2. Detect from Accept-Language header

apps/web/app/auth/callback/page.test.tsx

@@ -2,21 +2,13 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 import { render, waitFor } from "@testing-library/react";
 import { paths } from "@multica/core/paths";
 
-const {
-  mockPush,
-  mockSearchParams,
-  mockLoginWithGoogle,
-  mockListWorkspaces,
-  mockListMyInvitations,
-  mockSetQueryData,
-} = vi.hoisted(() => ({
-  mockPush: vi.fn(),
-  mockSearchParams: new URLSearchParams(),
-  mockLoginWithGoogle: vi.fn(),
-  mockListWorkspaces: vi.fn(),
-  mockListMyInvitations: vi.fn(),
-  mockSetQueryData: vi.fn(),
-}));
+const { mockPush, mockSearchParams, mockLoginWithGoogle, mockListWorkspaces } =
+  vi.hoisted(() => ({
+    mockPush: vi.fn(),
+    mockSearchParams: new URLSearchParams(),
+    mockLoginWithGoogle: vi.fn(),
+    mockListWorkspaces: vi.fn(),
+  }));
 
 const makeUser = (overrides: Partial<{ onboarded_at: string | null }> = {}) => ({
   id: "user-1",
@@ -36,7 +28,7 @@ vi.mock("next/navigation", () => ({
 }));
 
 vi.mock("@tanstack/react-query", () => ({
-  useQueryClient: () => ({ setQueryData: mockSetQueryData }),
+  useQueryClient: () => ({ setQueryData: vi.fn() }),
 }));
 
 // Preserve the real sanitizeNextUrl so the "drop unsafe ?next=" behavior is
@@ -54,16 +46,12 @@ vi.mock("@multica/core/auth", async () => {
 });
 
 vi.mock("@multica/core/workspace/queries", () => ({
-  workspaceKeys: {
-    list: () => ["workspaces"],
-    myInvitations: () => ["invitations", "mine"],
-  },
+  workspaceKeys: { list: () => ["workspaces"] },
 }));
 
 vi.mock("@multica/core/api", () => ({
   api: {
     listWorkspaces: mockListWorkspaces,
-    listMyInvitations: mockListMyInvitations,
     googleLogin: vi.fn(),
   },
 }));
@@ -73,78 +61,26 @@ import CallbackPage from "./page";
 describe("CallbackPage", () => {
   beforeEach(() => {
     vi.clearAllMocks();
-    // Snapshot keys before deleting — forEach + delete skips entries because
-    // the iteration index advances while the underlying list shrinks.
-    Array.from(mockSearchParams.keys()).forEach((k) =>
-      mockSearchParams.delete(k),
-    );
+    mockSearchParams.forEach((_v, k) => mockSearchParams.delete(k));
     mockSearchParams.set("code", "test-code");
     mockLoginWithGoogle.mockResolvedValue(makeUser());
     mockListWorkspaces.mockResolvedValue([]);
-    mockListMyInvitations.mockResolvedValue([]);
   });
 
-  it("unonboarded user honors a safe next= (e.g. /invite/{id}) so invitees aren't trapped", async () => {
+  it("unonboarded user lands on /onboarding regardless of next=", async () => {
     mockSearchParams.set("state", "next:/invite/abc123");
-    render(<CallbackPage />);
-    await waitFor(() => {
-      expect(mockPush).toHaveBeenCalledWith("/invite/abc123");
-    });
-    expect(mockPush).not.toHaveBeenCalledWith(paths.onboarding());
-    // nextUrl is a fast path — listMyInvitations should not be queried.
-    expect(mockListMyInvitations).not.toHaveBeenCalled();
-  });
-
-  it("unonboarded user with no next= and no pending invitations lands on /onboarding", async () => {
     render(<CallbackPage />);
     await waitFor(() => {
       expect(mockPush).toHaveBeenCalledWith(paths.onboarding());
     });
-    expect(mockListMyInvitations).toHaveBeenCalled();
+    expect(mockPush).not.toHaveBeenCalledWith("/invite/abc123");
   });
 
-  it("unonboarded user with pending invitations lands on /invitations", async () => {
-    mockListMyInvitations.mockResolvedValue([
-      {
-        id: "inv-1",
-        workspace_id: "ws-1",
-        workspace_name: "Acme",
-        role: "member",
-        status: "pending",
-      },
-    ]);
+  it("unonboarded user with no next= also lands on /onboarding", async () => {
     render(<CallbackPage />);
     await waitFor(() => {
-      expect(mockPush).toHaveBeenCalledWith(paths.invitations());
+      expect(mockPush).toHaveBeenCalledWith(paths.onboarding());
     });
-    expect(mockPush).not.toHaveBeenCalledWith(paths.onboarding());
-  });
-
-  it("onboarded user with workspace lands in that workspace", async () => {
-    mockLoginWithGoogle.mockResolvedValue(
-      makeUser({ onboarded_at: "2026-01-01T00:00:00Z" }),
-    );
-    mockListWorkspaces.mockResolvedValue([
-      {
-        id: "ws-1",
-        name: "Acme",
-        slug: "acme",
-        description: null,
-        context: null,
-        settings: {},
-        repos: [],
-        issue_prefix: "ACME",
-        created_at: "",
-        updated_at: "",
-      },
-    ]);
-    render(<CallbackPage />);
-    await waitFor(() => {
-      expect(mockPush).toHaveBeenCalledWith(paths.workspace("acme").issues());
-    });
-    // Already-onboarded users skip the listMyInvitations check; new invites
-    // surface in the sidebar instead of the wall.
-    expect(mockListMyInvitations).not.toHaveBeenCalled();
   });
 
   it("onboarded user ignores unsafe next= targets and lands on the default destination", async () => {
@@ -173,12 +109,4 @@ describe("CallbackPage", () => {
       expect(mockPush).toHaveBeenCalledWith("/invite/abc123");
     });
   });
-
-  it("falls through to /onboarding when listMyInvitations errors", async () => {
-    mockListMyInvitations.mockRejectedValue(new Error("network"));
-    render(<CallbackPage />);
-    await waitFor(() => {
-      expect(mockPush).toHaveBeenCalledWith(paths.onboarding());
-    });
-  });
 });

apps/web/app/auth/callback/page.tsx

@@ -66,42 +66,13 @@ function CallbackContent() {
           const wsList = await api.listWorkspaces();
           qc.setQueryData(workspaceKeys.list(), wsList);
           const onboarded = loggedInUser.onboarded_at != null;
-
-          // 1. nextUrl wins: a `next=/invite/<id>` always survives the OAuth
-          //    round-trip — the user clicked a specific link and we should
-          //    honor exactly that destination.
-          if (nextUrl) {
-            router.push(nextUrl);
+          if (!onboarded) {
+            router.push(paths.onboarding());
             return;
           }
-
-          // 2. Un-onboarded users may have pending invitations on their
-          //    email even when no `next=` was carried (came from a fresh
-          //    login on app.multica.ai instead of clicking the email link,
-          //    or `state` was lost across the round-trip). Look them up by
-          //    email and route to the batch /invitations page if any.
-          //    Already-onboarded users skip this lookup — their new invites
-          //    surface in the sidebar dropdown, not as a forced wall.
-          if (!onboarded) {
-            try {
-              const invites = await api.listMyInvitations();
-              if (invites.length > 0) {
-                qc.setQueryData(workspaceKeys.myInvitations(), invites);
-                router.push(paths.invitations());
-                return;
-              }
-            } catch {
-              // Network blip on the invite lookup is non-fatal — fall through
-              // to the normal post-auth destination so the user isn't stuck
-              // on a blank callback screen. Worst case they land on
-              // /onboarding and the sidebar will surface invites later.
-            }
-          }
-
-          // 3. Default: hand off to the resolver (onboarding for first-timers,
-          //    first workspace for returning users, /workspaces/new for
-          //    onboarded users with zero workspaces).
-          router.push(resolvePostAuthDestination(wsList, onboarded));
+          router.push(
+            nextUrl || resolvePostAuthDestination(wsList, onboarded),
+          );
         })
         .catch((err) => {
           setError(err instanceof Error ? err.message : "Login failed");

apps/web/app/layout.tsx

@@ -1,16 +1,10 @@
 import type { Metadata, Viewport } from "next";
-import { headers } from "next/headers";
 import { Inter, Geist_Mono, Source_Serif_4 } from "next/font/google";
 import { ThemeProvider } from "@/components/theme-provider";
 import { Toaster } from "@multica/ui/components/ui/sonner";
 import { cn } from "@multica/ui/lib/utils";
 import { WebProviders } from "@/components/web-providers";
-import {
-  DEFAULT_LOCALE,
-  SUPPORTED_LOCALES,
-  type SupportedLocale,
-} from "@multica/core/i18n";
-import { RESOURCES } from "@multica/views/locales";
+import { LocaleSync } from "@/components/locale-sync";
 import "./globals.css";
 
 // Font stack: Inter for Latin UI text + system Chinese fonts for zh content.
@@ -103,40 +97,21 @@ export const metadata: Metadata = {
   },
 };
 
-function isSupportedLocale(value: string | null): value is SupportedLocale {
-  return value !== null && (SUPPORTED_LOCALES as readonly string[]).includes(value);
-}
-
-// HTML lang attribute uses BCP-47 region tags that screen readers and font
-// stacks recognize widely. i18next keeps `zh-Hans` as its internal locale
-// (script subtag is what we actually translate against), but the html element
-// expects a region-flavoured tag for accessibility tooling and CJK fallback.
-const HTML_LANG: Record<SupportedLocale, string> = {
-  en: "en",
-  "zh-Hans": "zh-CN",
-};
-
-export default async function RootLayout({
+export default function RootLayout({
   children,
 }: {
   children: React.ReactNode;
 }) {
-  const h = await headers();
-  const headerLocale = h.get("x-multica-locale");
-  const locale: SupportedLocale = isSupportedLocale(headerLocale)
-    ? headerLocale
-    : DEFAULT_LOCALE;
-  const resources = { [locale]: RESOURCES[locale] };
-
   return (
     <html
-      lang={HTML_LANG[locale]}
+      lang="en"
       suppressHydrationWarning
       className={cn("antialiased font-sans h-full", inter.variable, geistMono.variable, sourceSerif.variable)}
     >
       <body className="h-full overflow-hidden">
+        <LocaleSync />
         <ThemeProvider>
-          <WebProviders locale={locale} resources={resources}>
+          <WebProviders>
             {children}
           </WebProviders>
           <Toaster />

apps/web/app/not-found.tsx

@@ -1,19 +0,0 @@
-"use client";
-
-import Link from "next/link";
-import { buttonVariants } from "@multica/ui/components/ui/button";
-
-export default function NotFound() {
-  return (
-    <main className="flex min-h-screen flex-col items-center justify-center gap-6 px-6 py-24 text-center">
-      <p className="text-sm font-medium text-muted-foreground">404</p>
-      <h1 className="text-2xl font-semibold tracking-tight">Page not found</h1>
-      <p className="max-w-md text-sm text-muted-foreground">
-        The page you are looking for doesn&rsquo;t exist or has been moved.
-      </p>
-      <Link href="/" className={buttonVariants({ className: "mt-2" })}>
-        Back to Multica
-      </Link>
-    </main>
-  );
-}

apps/web/components/locale-sync.tsx

@@ -0,0 +1,20 @@
+"use client";
+
+import { useEffect } from "react";
+
+/**
+ * Reads the locale cookie on the client and updates <html lang>.
+ * This avoids calling cookies() in the root Server Component layout,
+ * which would mark the entire app as dynamic and disable the Router Cache.
+ */
+export function LocaleSync() {
+  useEffect(() => {
+    const match = document.cookie.match(/(?:^|;\s*)multica-locale=(\w+)/);
+    const locale = match?.[1];
+    if (locale === "zh") {
+      document.documentElement.lang = "zh";
+    }
+  }, []);
+
+  return null;
+}

apps/web/components/web-providers.tsx

@@ -2,8 +2,6 @@
 
 import { Suspense, useMemo } from "react";
 import { CoreProvider } from "@multica/core/platform";
-import { createBrowserCookieLocaleAdapter } from "@multica/core/i18n/browser";
-import type { LocaleResources, SupportedLocale } from "@multica/core/i18n";
 import packageJson from "../package.json";
 import { WebNavigationProvider } from "@/platform/navigation";
 import {
@@ -43,15 +41,7 @@ function deriveWsUrl(): string | undefined {
 const WEB_VERSION =
   process.env.NEXT_PUBLIC_APP_VERSION || packageJson.version || "dev";
 
-export function WebProviders({
-  children,
-  locale,
-  resources,
-}: {
-  children: React.ReactNode;
-  locale: SupportedLocale;
-  resources: Record<string, LocaleResources>;
-}) {
+export function WebProviders({ children }: { children: React.ReactNode }) {
   const cookieAuth = !hasLegacyToken();
   // Stable identity reference so downstream effects keyed on it don't see a
   // new object on every parent render.
@@ -59,7 +49,6 @@ export function WebProviders({
     () => ({ platform: "web", version: WEB_VERSION }),
     [],
   );
-  const localeAdapter = useMemo(() => createBrowserCookieLocaleAdapter(), []);
   return (
     <CoreProvider
       apiBaseUrl={process.env.NEXT_PUBLIC_API_URL}
@@ -68,9 +57,6 @@ export function WebProviders({
       onLogin={setLoggedInCookie}
       onLogout={clearLoggedInCookie}
       identity={identity}
-      locale={locale}
-      resources={resources}
-      localeAdapter={localeAdapter}
     >
       {/* Suspense boundary is required by Next.js for useSearchParams in
           a client component mounted this high in the tree. */}

apps/web/features/landing/i18n/context.tsx

@@ -2,7 +2,6 @@
 
 import { createContext, useContext, useState, useCallback, useMemo } from "react";
 import { useConfigStore } from "@multica/core/config";
-import { LOCALE_COOKIE } from "@multica/core/i18n";
 import { createEnDict } from "./en";
 import { createZhDict } from "./zh";
 import type { LandingDict, Locale } from "./types";
@@ -12,6 +11,7 @@ const dictionaryFactories: Record<Locale, (allowSignup: boolean) => LandingDict>
   zh: createZhDict,
 };
 
+const COOKIE_NAME = "multica-locale";
 const COOKIE_MAX_AGE = 60 * 60 * 24 * 365; // 1 year
 
 type LocaleContextValue = {
@@ -38,11 +38,7 @@ export function LocaleProvider({
 
   const setLocale = useCallback((l: Locale) => {
     setLocaleState(l);
-    const secure =
-      typeof location !== "undefined" && location.protocol === "https:"
-        ? "; Secure"
-        : "";
-    document.cookie = `${LOCALE_COOKIE}=${l}; path=/; max-age=${COOKIE_MAX_AGE}; SameSite=Lax${secure}`;
+    document.cookie = `${COOKIE_NAME}=${l}; path=/; max-age=${COOKIE_MAX_AGE}; SameSite=Lax`;
   }, []);
 
   return (

apps/web/features/landing/i18n/en.ts

@@ -94,7 +94,7 @@ export function createEnDict(allowSignup: boolean): LandingDict {
       label: "RUNTIMES",
       title: "One dashboard for all your compute",
       description:
-        "Local daemons and cloud runtimes, managed from a single panel. Real-time monitoring of online/offline status, usage charts, and activity heatmaps. Auto-detects 11 supported coding tools on your machine.",
+        "Local daemons and cloud runtimes, managed from a single panel. Real-time monitoring of online/offline status, usage charts, and activity heatmaps. Auto-detects local CLIs \u2014 plug in and go.",
       cards: [
         {
           title: "Unified runtime panel",
@@ -107,9 +107,9 @@ export function createEnDict(allowSignup: boolean): LandingDict {
             "Online/offline status, usage charts, and activity heatmaps. Know exactly what your compute is doing at any moment.",
         },
         {
-          title: "Auto-detection on first run",
+          title: "Auto-detection & plug-and-play",
           description:
-            "Multica scans for 11 supported coding tools \u2014 Claude Code, Codex, Cursor, Copilot, Gemini, Hermes, Kimi, Kiro CLI, OpenCode, OpenClaw, and Pi \u2014 and registers a runtime for each one it finds.",
+            "Multica detects available CLIs like Claude Code, Codex, OpenClaw, and OpenCode automatically. Connect a machine, and it\u2019s ready to work.",
         },
       ],
     },
@@ -129,7 +129,7 @@ export function createEnDict(allowSignup: boolean): LandingDict {
       {
         title: "Install the CLI & connect your machine",
         description:
-          "Run multica setup \u2014 it walks you through OAuth, starts the daemon, and scans for the 11 supported coding tools (Claude Code, Codex, Cursor, Copilot, Gemini, Hermes, Kimi, Kiro CLI, OpenCode, OpenClaw, Pi). Whichever ones you already have installed get registered as runtimes automatically.",
+          "Run multica setup to configure, authenticate, and start the daemon. It auto-detects Claude Code, Codex, OpenClaw, and OpenCode on your machine \u2014 plug in and go.",
       },
       {
         title: "Create your first agent",
@@ -185,7 +185,7 @@ export function createEnDict(allowSignup: boolean): LandingDict {
       {
         question: "What coding agents does Multica support?",
         answer:
-          "Multica supports 11 coding tools out of the box: Claude Code, Codex, Cursor, Copilot, Gemini, Hermes, Kimi, Kiro CLI, OpenCode, OpenClaw, and Pi. The daemon auto-detects whichever CLIs you already have installed and registers a runtime for each one. Since it's open source, you can also add your own backends.",
+          "Multica currently supports Claude Code, Codex, OpenClaw, and OpenCode out of the box. The daemon auto-detects whichever CLIs you have installed. Since it\u2019s open source, you can also add your own backends.",
       },
       {
         question: "Do I need to self-host, or is there a cloud version?",
@@ -283,121 +283,6 @@ export function createEnDict(allowSignup: boolean): LandingDict {
       fixes: "Bug Fixes",
     },
     entries: [
-      {
-        version: "0.2.26",
-        date: "2026-05-06",
-        title: "Full i18n Rollout, Long-Issue Timeline & System Notifications Toggle",
-        changes: [],
-        features: [
-          "Web app fully translated to Simplified Chinese (21 namespaces), with per-user locale",
-          "System Notifications toggle in Settings",
-          "Delete chat sessions; History panel surfaced on the chat header",
-          "Runtime liveness backed by Redis, with DB fallback",
-          "Desktop loads runtime self-host config",
-          "CLI adds `--assignee-id` / `--to-id` / `--user-id` for unambiguous targeting",
-        ],
-        improvements: [
-          "Settings 'Appearance' tab is renamed to 'Preferences', and the active tab is reflected in the URL so deep links work",
-          "Long issues open instantly — Timeline switched to cursor-based keyset pagination, and repeated `task_completed` / `task_failed` activity entries are coalesced",
-          "Runtime poll and heartbeat schedules are isolated per-runtime, so one busy runtime can no longer starve others",
-          "CLI update requests persist in Redis, so a server restart no longer drops them",
-          "Runtime cost usage window narrowed from 180 days to 14 days, dropping query load",
-          "Project list returns a `resource_count` instead of inlining all resources, keeping responses lean",
-          "404 page redesigned, with the No-Access redirect loop fixed",
-          "Quick Create exempts git-describe daemons from the CLI version gate",
-          "CI now enforces lint on every PR, and the existing lint debt has been cleared",
-        ],
-        fixes: [
-          "Daemon cancels the running agent when the task is deleted server-side, eliminating orphan processes",
-          "Daemon refreshes a stale Codex `auth.json` when reusing an exec env, fixing intermittent auth errors",
-          "Daemon refuses to write `.gc_meta.json` when `issue_id` is empty",
-          "Session / resume across ACP backends now trusts the agent-reported session id, fixing cross-session bleed",
-          "OpenCode skills are written under `.opencode/skills/` so they are discovered natively",
-          "404 task-not-found semantics tightened on both server and the final guard",
-          "Pinned sidebar rows are auto-unpinned when the underlying entity disappears",
-          "Project detail page splits desktop and mobile sidebar state",
-          "Runtime detail page hides archived agents",
-          "Already-attached repos in Add Resource show a URL tooltip; empty project state has a New Issue button",
-          "S3 public URLs are region-qualified, fixing cross-region access",
-          "Windows installer parses version numbers and decodes checksums correctly",
-          "Quick Create submit button no longer shows a duplicate keyboard shortcut",
-        ],
-      },
-      {
-        version: "0.2.24",
-        date: "2026-05-03",
-        title: "Repo Checkout `--ref`, Hermes Replay Fix & Multi-Replica Model Picker",
-        changes: [],
-        features: [
-          "`multica repo checkout --ref` targets a branch, tag, or specific commit when pulling a repo into the workspace",
-          "`multica agent avatar` uploads an agent avatar straight from the CLI",
-          "Inbox shows an archive button on done tasks; the redundant mark-as-done hover button is gone",
-        ],
-        improvements: [
-          "Long-timeline issues open instantly from Inbox — the markdown render pipeline is memoized so unrelated WS events no longer re-render thousands of comments",
-          "Model picker works on multi-replica deployments — pending requests persist via Redis, with daemon retries on transient report failures",
-          "Daemon empty-claim cache TTL bumped, further reducing idle DB load",
-        ],
-        fixes: [
-          "Newly created agents show up everywhere immediately — the agent cache is hydrated on create",
-          "Hermes no longer replays the previous answer when a new turn starts — historical chunks are gated behind a per-turn flag",
-          "Codex runtime model picker exposes the GPT-5.5 family",
-          "`multica login --token <PAT>` accepts the PAT as a flag value instead of rejecting it",
-          "CLI update completion status is now reliable",
-          "Session resume is guarded by runtime, preventing cross-runtime resume",
-          "Kanban display settings survive when dragging issues across columns",
-          "Autopilot list is responsive on mobile viewports",
-          "Quick Create prompts produce higher-fidelity descriptions from the user's input",
-          "Skill upsert sanitizes null bytes, fixing a PostgreSQL UTF8 error",
-          "Connect Remote dialog points to the correct install script URL",
-        ],
-      },
-      {
-        version: "0.2.21",
-        date: "2026-04-30",
-        title: "Quick Capture Overhaul, Mermaid Diagrams & Typed Project Resources",
-        changes: [],
-        features: [
-          "Quick Capture replaces the old New Issue dialog — continuous-create mode, file uploads, and automatic enrichment from pasted URLs",
-          "Mermaid diagrams render inline in markdown, with a fullscreen lightbox for complex graphs",
-          "Projects can bind their own repo, separate from the workspace default",
-          "Permission-aware UI across agents, comments, runtimes, and skills — actions you can't take are no longer offered",
-        ],
-        improvements: [
-          "Daemon `/tasks/claim` polling uses a Redis empty-claim fast-path, dropping idle DB load and reclaiming disk on long-open issues",
-          "Multica Agent commits include a `Co-authored-by` trailer for proper Git attribution",
-          "Desktop blocks Cmd+R / Ctrl+R / F5 from reloading the app and shows the real version in dev and Updates settings",
-        ],
-        fixes: [
-          "Quick Create no longer invents requirements beyond user input, and subscribes the requester to the issue it creates",
-          "Inbox jumps straight to the targeted comment, and auto-archives when the issue is marked Done from the detail page",
-          "Task rerun starts a fresh session and skips poisoned resume state",
-          "Invitees land on their workspace after sign-in instead of being forced through `/onboarding`",
-        ],
-      },
-      {
-        version: "0.2.20",
-        date: "2026-04-29",
-        title: "Create Issue by Agent, Agent Presence v3 & Daemon WebSocket Heartbeat",
-        changes: [],
-        features: [
-          "Create Issue by Agent — press `c`, write one line, pick an agent; issue creation runs async and the result lands in your inbox",
-          "Agent Presence v3 — availability and last-task split into clearer signals, with an execution log on the issue panel showing active and recent runs",
-          "Daemon ↔ server heartbeat now flows over WebSocket with HTTP fallback, cutting task wakeup latency",
-          "Mention picker ranks suggestions by your local recency",
-        ],
-        improvements: [
-          "Server caches PAT / daemon token lookups in Redis, so large fleets stop hammering the database on every request",
-          "Backend default agent CLI args via `MULTICA_CLAUDE_ARGS` / `MULTICA_CODEX_ARGS` env vars",
-          "Manual and agent create-issue flows share one dialog shell, and picker agents become the default assignee",
-        ],
-        fixes: [
-          "Create-issue-by-agent no longer leaves tasks stuck queued, and no longer duplicates the issue when an attachment upload fails",
-          "Agent comments respect newlines instead of rendering literal `\\n`, and multi-line replies keep their formatting",
-          "Agent-authored root comments no longer inherit parent @mentions, breaking accidental agent loops",
-          "Cursor agent on Windows preserves multi-line prompts",
-        ],
-      },
       {
         version: "0.2.19",
         date: "2026-04-28",

apps/web/features/landing/i18n/zh.ts

@@ -13,42 +13,42 @@ export function createZhDict(allowSignup: boolean): LandingDict {
     headlineLine1: "\u4f60\u7684\u4e0b\u4e00\u6279\u5458\u5de5",
     headlineLine2: "\u4e0d\u662f\u4eba\u7c7b\u3002",
     subheading:
-      "Multica \u662f\u4e00\u4e2a\u5f00\u6e90\u5e73\u53f0\uff0c\u5c06\u7f16\u7801 智能体 \u53d8\u6210\u771f\u6b63\u7684\u961f\u53cb\u3002\u5206\u914d\u4efb\u52a1\u3001\u8ddf\u8e2a\u8fdb\u5ea6\u3001\u79ef\u7d2f\u6280\u80fd\u2014\u2014\u5728\u4e00\u4e2a\u5730\u65b9\u7ba1\u7406\u4f60\u7684\u4eba\u7c7b + 智能体 \u56e2\u961f\u3002",
+      "Multica \u662f\u4e00\u4e2a\u5f00\u6e90\u5e73\u53f0\uff0c\u5c06\u7f16\u7801 Agent \u53d8\u6210\u771f\u6b63\u7684\u961f\u53cb\u3002\u5206\u914d\u4efb\u52a1\u3001\u8ddf\u8e2a\u8fdb\u5ea6\u3001\u79ef\u7d2f\u6280\u80fd\u2014\u2014\u5728\u4e00\u4e2a\u5730\u65b9\u7ba1\u7406\u4f60\u7684\u4eba\u7c7b + Agent \u56e2\u961f\u3002",
     cta: "免费开始",
     downloadDesktop: "下载桌面端",
     worksWith: "支持",
-    imageAlt: "Multica \u770b\u677f\u89c6\u56fe\u2014\u2014\u4eba\u7c7b\u548c 智能体 \u534f\u540c\u7ba1\u7406\u4efb\u52a1",
+    imageAlt: "Multica \u770b\u677f\u89c6\u56fe\u2014\u2014\u4eba\u7c7b\u548c Agent \u534f\u540c\u7ba1\u7406\u4efb\u52a1",
   },
 
   features: {
     teammates: {
       label: "\u56e2\u961f\u534f\u4f5c",
-      title: "\u50cf\u5206\u914d\u7ed9\u540c\u4e8b\u4e00\u6837\u5206\u914d\u7ed9 智能体",
+      title: "\u50cf\u5206\u914d\u7ed9\u540c\u4e8b\u4e00\u6837\u5206\u914d\u7ed9 Agent",
       description:
-        "智能体 \u4e0d\u662f\u88ab\u52a8\u5de5\u5177\u2014\u2014\u5b83\u4eec\u662f\u4e3b\u52a8\u53c2\u4e0e\u8005\u3002\u5b83\u4eec\u62e5\u6709\u4e2a\u4eba\u8d44\u6599\u3001\u62a5\u544a\u72b6\u6001\u3001\u521b\u5efa Issue\u3001\u53d1\u8868\u8bc4\u8bba\u3001\u66f4\u65b0\u72b6\u6001\u3002\u4f60\u7684\u6d3b\u52a8\u6d41\u5c55\u793a\u4eba\u7c7b\u548c 智能体 \u5e76\u80a9\u5de5\u4f5c\u3002",
+        "Agent \u4e0d\u662f\u88ab\u52a8\u5de5\u5177\u2014\u2014\u5b83\u4eec\u662f\u4e3b\u52a8\u53c2\u4e0e\u8005\u3002\u5b83\u4eec\u62e5\u6709\u4e2a\u4eba\u8d44\u6599\u3001\u62a5\u544a\u72b6\u6001\u3001\u521b\u5efa Issue\u3001\u53d1\u8868\u8bc4\u8bba\u3001\u66f4\u65b0\u72b6\u6001\u3002\u4f60\u7684\u6d3b\u52a8\u6d41\u5c55\u793a\u4eba\u7c7b\u548c Agent \u5e76\u80a9\u5de5\u4f5c\u3002",
       cards: [
         {
-          title: "智能体 \u51fa\u73b0\u5728\u6307\u6d3e\u4eba\u9009\u62e9\u5668\u4e2d",
+          title: "Agent \u51fa\u73b0\u5728\u6307\u6d3e\u4eba\u9009\u62e9\u5668\u4e2d",
           description:
-            "\u4eba\u7c7b\u548c 智能体 \u51fa\u73b0\u5728\u540c\u4e00\u4e2a\u4e0b\u62c9\u83dc\u5355\u91cc\u3002\u628a\u4efb\u52a1\u5206\u914d\u7ed9 智能体 \u548c\u5206\u914d\u7ed9\u540c\u4e8b\u6ca1\u6709\u4efb\u4f55\u533a\u522b\u3002",
+            "\u4eba\u7c7b\u548c Agent \u51fa\u73b0\u5728\u540c\u4e00\u4e2a\u4e0b\u62c9\u83dc\u5355\u91cc\u3002\u628a\u4efb\u52a1\u5206\u914d\u7ed9 Agent \u548c\u5206\u914d\u7ed9\u540c\u4e8b\u6ca1\u6709\u4efb\u4f55\u533a\u522b\u3002",
         },
         {
           title: "\u81ea\u4e3b\u53c2\u4e0e",
           description:
-            "智能体 \u4e3b\u52a8\u521b\u5efa Issue\u3001\u53d1\u8868\u8bc4\u8bba\u3001\u66f4\u65b0\u72b6\u6001\u2014\u2014\u800c\u4e0d\u662f\u53ea\u5728\u88ab\u63d0\u793a\u65f6\u624d\u884c\u52a8\u3002",
+            "Agent \u4e3b\u52a8\u521b\u5efa Issue\u3001\u53d1\u8868\u8bc4\u8bba\u3001\u66f4\u65b0\u72b6\u6001\u2014\u2014\u800c\u4e0d\u662f\u53ea\u5728\u88ab\u63d0\u793a\u65f6\u624d\u884c\u52a8\u3002",
         },
         {
           title: "\u7edf\u4e00\u7684\u6d3b\u52a8\u65f6\u95f4\u7ebf",
           description:
-            "\u6574\u4e2a\u56e2\u961f\u5171\u7528\u4e00\u4e2a\u6d3b\u52a8\u6d41\u3002\u4eba\u7c7b\u548c 智能体 \u7684\u64cd\u4f5c\u4ea4\u66ff\u5c55\u793a\uff0c\u4f60\u59cb\u7ec8\u77e5\u9053\u53d1\u751f\u4e86\u4ec0\u4e48\u3001\u662f\u8c01\u505a\u7684\u3002",
+            "\u6574\u4e2a\u56e2\u961f\u5171\u7528\u4e00\u4e2a\u6d3b\u52a8\u6d41\u3002\u4eba\u7c7b\u548c Agent \u7684\u64cd\u4f5c\u4ea4\u66ff\u5c55\u793a\uff0c\u4f60\u59cb\u7ec8\u77e5\u9053\u53d1\u751f\u4e86\u4ec0\u4e48\u3001\u662f\u8c01\u505a\u7684\u3002",
         },
       ],
     },
     autonomous: {
       label: "\u81ea\u4e3b\u6267\u884c",
-      title: "\u8bbe\u7f6e\u540e\u65e0\u9700\u7ba1\u7406\u2014\u2014智能体 \u5728\u4f60\u7761\u89c9\u65f6\u5de5\u4f5c",
+      title: "\u8bbe\u7f6e\u540e\u65e0\u9700\u7ba1\u7406\u2014\u2014Agent \u5728\u4f60\u7761\u89c9\u65f6\u5de5\u4f5c",
       description:
-        "\u4e0d\u53ea\u662f\u63d0\u793a-\u54cd\u5e94\u3002\u5b8c\u6574\u7684\u4efb\u52a1\u751f\u547d\u5468\u671f\u7ba1\u7406\uff1a\u5165\u961f\u3001\u9886\u53d6\u3001\u542f\u52a8\u3001\u5b8c\u6210\u6216\u5931\u8d25\u3002智能体 \u4e3b\u52a8\u62a5\u544a\u963b\u585e\uff0c\u4f60\u901a\u8fc7 WebSocket \u83b7\u53d6\u5b9e\u65f6\u8fdb\u5ea6\u3002",
+        "\u4e0d\u53ea\u662f\u63d0\u793a-\u54cd\u5e94\u3002\u5b8c\u6574\u7684\u4efb\u52a1\u751f\u547d\u5468\u671f\u7ba1\u7406\uff1a\u5165\u961f\u3001\u9886\u53d6\u3001\u542f\u52a8\u3001\u5b8c\u6210\u6216\u5931\u8d25\u3002Agent \u4e3b\u52a8\u62a5\u544a\u963b\u585e\uff0c\u4f60\u901a\u8fc7 WebSocket \u83b7\u53d6\u5b9e\u65f6\u8fdb\u5ea6\u3002",
       cards: [
         {
           title: "\u5b8c\u6574\u7684\u4efb\u52a1\u751f\u547d\u5468\u671f",
@@ -58,12 +58,12 @@ export function createZhDict(allowSignup: boolean): LandingDict {
         {
           title: "\u4e3b\u52a8\u62a5\u544a\u963b\u585e",
           description:
-            "\u5f53 智能体 \u9047\u5230\u56f0\u96be\u65f6\uff0c\u4f1a\u7acb\u5373\u53d1\u51fa\u8b66\u62a5\u3002\u4e0d\u7528\u7b49\u51e0\u4e2a\u5c0f\u65f6\u540e\u624d\u53d1\u73b0\u4ec0\u4e48\u90fd\u6ca1\u53d1\u751f\u3002",
+            "\u5f53 Agent \u9047\u5230\u56f0\u96be\u65f6\uff0c\u4f1a\u7acb\u5373\u53d1\u51fa\u8b66\u62a5\u3002\u4e0d\u7528\u7b49\u51e0\u4e2a\u5c0f\u65f6\u540e\u624d\u53d1\u73b0\u4ec0\u4e48\u90fd\u6ca1\u53d1\u751f\u3002",
         },
         {
           title: "\u5b9e\u65f6\u8fdb\u5ea6\u63a8\u9001",
           description:
-            "\u57fa\u4e8e WebSocket \u7684\u5b9e\u65f6\u66f4\u65b0\u3002\u5b9e\u65f6\u89c2\u770b 智能体 \u5de5\u4f5c\uff0c\u6216\u968f\u65f6\u67e5\u770b\u2014\u2014\u65f6\u95f4\u7ebf\u59cb\u7ec8\u662f\u6700\u65b0\u7684\u3002",
+            "\u57fa\u4e8e WebSocket \u7684\u5b9e\u65f6\u66f4\u65b0\u3002\u5b9e\u65f6\u89c2\u770b Agent \u5de5\u4f5c\uff0c\u6216\u968f\u65f6\u67e5\u770b\u2014\u2014\u65f6\u95f4\u7ebf\u59cb\u7ec8\u662f\u6700\u65b0\u7684\u3002",
         },
       ],
     },
@@ -71,22 +71,22 @@ export function createZhDict(allowSignup: boolean): LandingDict {
       label: "\u6280\u80fd\u5e93",
       title: "\u6bcf\u4e2a\u89e3\u51b3\u65b9\u6848\u90fd\u6210\u4e3a\u5168\u56e2\u961f\u53ef\u590d\u7528\u7684\u6280\u80fd",
       description:
-        "\u6280\u80fd\u662f\u53ef\u590d\u7528\u7684\u80fd\u529b\u5b9a\u4e49\u2014\u2014\u4ee3\u7801\u3001\u914d\u7f6e\u548c\u4e0a\u4e0b\u6587\u6253\u5305\u5728\u4e00\u8d77\u3002\u53ea\u9700\u7f16\u5199\u4e00\u6b21\uff0c\u56e2\u961f\u4e2d\u6bcf\u4e2a 智能体 \u90fd\u80fd\u4f7f\u7528\u3002\u4f60\u7684\u6280\u80fd\u5e93\u968f\u65f6\u95f4\u4e0d\u65ad\u79ef\u7d2f\u3002",
+        "\u6280\u80fd\u662f\u53ef\u590d\u7528\u7684\u80fd\u529b\u5b9a\u4e49\u2014\u2014\u4ee3\u7801\u3001\u914d\u7f6e\u548c\u4e0a\u4e0b\u6587\u6253\u5305\u5728\u4e00\u8d77\u3002\u53ea\u9700\u7f16\u5199\u4e00\u6b21\uff0c\u56e2\u961f\u4e2d\u6bcf\u4e2a Agent \u90fd\u80fd\u4f7f\u7528\u3002\u4f60\u7684\u6280\u80fd\u5e93\u968f\u65f6\u95f4\u4e0d\u65ad\u79ef\u7d2f\u3002",
       cards: [
         {
           title: "\u53ef\u590d\u7528\u7684\u6280\u80fd\u5b9a\u4e49",
           description:
-            "\u5c06\u77e5\u8bc6\u5c01\u88c5\u6210\u4efb\u4f55 智能体 \u90fd\u80fd\u6267\u884c\u7684\u6280\u80fd\u3002\u90e8\u7f72\u5230\u6d4b\u8bd5\u73af\u5883\u3001\u7f16\u5199\u8fc1\u79fb\u3001\u5ba1\u67e5 PR\u2014\u2014\u5168\u90e8\u4ee3\u7801\u5316\u3002",
+            "\u5c06\u77e5\u8bc6\u5c01\u88c5\u6210\u4efb\u4f55 Agent \u90fd\u80fd\u6267\u884c\u7684\u6280\u80fd\u3002\u90e8\u7f72\u5230\u6d4b\u8bd5\u73af\u5883\u3001\u7f16\u5199\u8fc1\u79fb\u3001\u5ba1\u67e5 PR\u2014\u2014\u5168\u90e8\u4ee3\u7801\u5316\u3002",
         },
         {
           title: "\u5168\u56e2\u961f\u5171\u4eab",
           description:
-            "\u4e00\u4e2a\u4eba\u7684\u6280\u80fd\u5c31\u662f\u6bcf\u4e2a 智能体 \u7684\u6280\u80fd\u3002\u7f16\u5199\u4e00\u6b21\uff0c\u5168\u56e2\u961f\u53d7\u76ca\u3002",
+            "\u4e00\u4e2a\u4eba\u7684\u6280\u80fd\u5c31\u662f\u6bcf\u4e2a Agent \u7684\u6280\u80fd\u3002\u7f16\u5199\u4e00\u6b21\uff0c\u5168\u56e2\u961f\u53d7\u76ca\u3002",
         },
         {
           title: "\u590d\u5408\u589e\u957f",
           description:
-            "\u7b2c 1 \u5929\uff1a\u4f60\u6559 智能体 \u90e8\u7f72\u3002\u7b2c 30 \u5929\uff1a\u6bcf\u4e2a 智能体 \u90fd\u80fd\u90e8\u7f72\u3001\u5199\u6d4b\u8bd5\u3001\u505a\u4ee3\u7801\u5ba1\u67e5\u3002\u56e2\u961f\u80fd\u529b\u6307\u6570\u7ea7\u589e\u957f\u3002",
+            "\u7b2c 1 \u5929\uff1a\u4f60\u6559 Agent \u90e8\u7f72\u3002\u7b2c 30 \u5929\uff1a\u6bcf\u4e2a Agent \u90fd\u80fd\u90e8\u7f72\u3001\u5199\u6d4b\u8bd5\u3001\u505a\u4ee3\u7801\u5ba1\u67e5\u3002\u56e2\u961f\u80fd\u529b\u6307\u6570\u7ea7\u589e\u957f\u3002",
         },
       ],
     },
@@ -94,7 +94,7 @@ export function createZhDict(allowSignup: boolean): LandingDict {
       label: "\u8fd0\u884c\u65f6",
       title: "\u4e00\u4e2a\u63a7\u5236\u53f0\u7ba1\u7406\u6240\u6709\u7b97\u529b",
       description:
-        "\u672c\u5730\u5b88\u62a4\u8fdb\u7a0b\u548c\u4e91\u7aef\u8fd0\u884c\u65f6\uff0c\u5728\u540c\u4e00\u4e2a\u9762\u677f\u4e2d\u7ba1\u7406\u3002\u5b9e\u65f6\u76d1\u63a7\u5728\u7ebf/\u79bb\u7ebf\u72b6\u6001\u3001\u4f7f\u7528\u91cf\u56fe\u8868\u548c\u6d3b\u52a8\u70ed\u529b\u56fe\u3002\u81ea\u52a8\u68c0\u6d4b\u672c\u673a\u5df2\u5b89\u88c5\u7684 11 \u6b3e\u652f\u6301\u7684 AI \u7f16\u7a0b\u5de5\u5177\u3002",
+        "\u672c\u5730\u5b88\u62a4\u8fdb\u7a0b\u548c\u4e91\u7aef\u8fd0\u884c\u65f6\uff0c\u5728\u540c\u4e00\u4e2a\u9762\u677f\u4e2d\u7ba1\u7406\u3002\u5b9e\u65f6\u76d1\u63a7\u5728\u7ebf/\u79bb\u7ebf\u72b6\u6001\u3001\u4f7f\u7528\u91cf\u56fe\u8868\u548c\u6d3b\u52a8\u70ed\u529b\u56fe\u3002\u81ea\u52a8\u68c0\u6d4b\u672c\u5730 CLI\u2014\u2014\u63d2\u4e0a\u5c31\u7528\u3002",
       cards: [
         {
           title: "\u7edf\u4e00\u8fd0\u884c\u65f6\u9762\u677f",
@@ -107,9 +107,9 @@ export function createZhDict(allowSignup: boolean): LandingDict {
             "\u5728\u7ebf/\u79bb\u7ebf\u72b6\u6001\u3001\u4f7f\u7528\u91cf\u56fe\u8868\u548c\u6d3b\u52a8\u70ed\u529b\u56fe\u3002\u968f\u65f6\u4e86\u89e3\u4f60\u7684\u7b97\u529b\u5728\u505a\u4ec0\u4e48\u3002",
         },
         {
-          title: "\u9996\u6b21\u542f\u52a8\u81ea\u52a8\u6ce8\u518c",
+          title: "\u81ea\u52a8\u68c0\u6d4b\u4e0e\u5373\u63d2\u5373\u7528",
           description:
-            "Multica \u626b\u63cf\u672c\u673a\u7684 11 \u6b3e\u652f\u6301\u7684 AI \u7f16\u7a0b\u5de5\u5177\u2014\u2014Claude Code\u3001Codex\u3001Cursor\u3001Copilot\u3001Gemini\u3001Hermes\u3001Kimi\u3001Kiro CLI\u3001OpenCode\u3001OpenClaw\u3001Pi\u2014\u2014\u5e76\u4e3a\u6bcf\u6b3e\u5df2\u5b89\u88c5\u7684\u5de5\u5177\u6ce8\u518c\u4e00\u4e2a\u8fd0\u884c\u65f6\u3002",
+            "Multica \u81ea\u52a8\u68c0\u6d4b Claude Code\u3001Codex\u3001OpenClaw \u548c OpenCode \u7b49\u53ef\u7528 CLI\u3002\u8fde\u63a5\u4e00\u53f0\u673a\u5668\uff0c\u5373\u53ef\u5f00\u59cb\u5de5\u4f5c\u3002",
         },
       ],
     },
@@ -129,17 +129,17 @@ export function createZhDict(allowSignup: boolean): LandingDict {
       {
         title: "\u5b89\u88c5 CLI \u5e76\u8fde\u63a5\u4f60\u7684\u673a\u5668",
         description:
-          "运行 multica setup——它会引导你完成 OAuth 登录、启动守护进程、并扫描 11 款支持的 AI 编程工具（Claude Code、Codex、Cursor、Copilot、Gemini、Hermes、Kimi、Kiro CLI、OpenCode、OpenClaw、Pi）。本机已安装的工具会被自动注册成运行时。",
+          "运行 multica setup 一键完成配置、认证和启动。守护进程自动检测你机器上的 Claude Code、Codex、OpenClaw 和 OpenCode——插上就用。",
       },
       {
-        title: "\u521b\u5efa\u4f60\u7684\u7b2c\u4e00\u4e2a 智能体",
+        title: "\u521b\u5efa\u4f60\u7684\u7b2c\u4e00\u4e2a Agent",
         description:
           "\u7ed9\u5b83\u8d77\u4e2a\u540d\u5b57\uff0c\u5199\u597d\u6307\u4ee4\uff0c\u9644\u52a0\u6280\u80fd\uff0c\u8bbe\u7f6e\u89e6\u53d1\u5668\u3002\u9009\u62e9\u5b83\u4f55\u65f6\u6fc0\u6d3b\uff1a\u88ab\u6307\u6d3e\u65f6\u3001\u6709\u8bc4\u8bba\u65f6\u3001\u88ab @\u63d0\u53ca\u65f6\u3002",
       },
       {
         title: "\u6307\u6d3e\u4e00\u4e2a Issue \u5e76\u89c2\u5bdf\u5b83\u5de5\u4f5c",
         description:
-          "\u4ece\u6307\u6d3e\u4eba\u4e0b\u62c9\u83dc\u5355\u4e2d\u9009\u62e9\u4f60\u7684 智能体\u2014\u2014\u5c31\u50cf\u6307\u6d3e\u7ed9\u540c\u4e8b\u4e00\u6837\u3002\u4efb\u52a1\u81ea\u52a8\u5165\u961f\u3001\u9886\u53d6\u3001\u6267\u884c\u3002\u5b9e\u65f6\u89c2\u770b\u8fdb\u5ea6\u3002",
+          "\u4ece\u6307\u6d3e\u4eba\u4e0b\u62c9\u83dc\u5355\u4e2d\u9009\u62e9\u4f60\u7684 Agent\u2014\u2014\u5c31\u50cf\u6307\u6d3e\u7ed9\u540c\u4e8b\u4e00\u6837\u3002\u4efb\u52a1\u81ea\u52a8\u5165\u961f\u3001\u9886\u53d6\u3001\u6267\u884c\u3002\u5b9e\u65f6\u89c2\u770b\u8fdb\u5ea6\u3002",
       },
     ],
     cta: "\u5f00\u59cb\u4f7f\u7528",
@@ -152,7 +152,7 @@ export function createZhDict(allowSignup: boolean): LandingDict {
     headlineLine1: "\u5f00\u6e90",
     headlineLine2: "\u4e3a\u6240\u6709\u4eba\u3002",
     description:
-      "Multica \u5b8c\u5168\u5f00\u6e90\u3002\u5ba1\u67e5\u6bcf\u4e00\u884c\u4ee3\u7801\uff0c\u6309\u4f60\u7684\u65b9\u5f0f\u81ea\u6258\u7ba1\uff0c\u5851\u9020\u4eba\u7c7b + 智能体 \u534f\u4f5c\u7684\u672a\u6765\u3002",
+      "Multica \u5b8c\u5168\u5f00\u6e90\u3002\u5ba1\u67e5\u6bcf\u4e00\u884c\u4ee3\u7801\uff0c\u6309\u4f60\u7684\u65b9\u5f0f\u81ea\u6258\u7ba1\uff0c\u5851\u9020\u4eba\u7c7b + Agent \u534f\u4f5c\u7684\u672a\u6765\u3002",
     cta: "\u5728 GitHub \u4e0a Star",
     highlights: [
       {
@@ -163,17 +163,17 @@ export function createZhDict(allowSignup: boolean): LandingDict {
       {
         title: "\u65e0\u4f9b\u5e94\u5546\u9501\u5b9a",
         description:
-          "\u81ea\u5e26 LLM \u63d0\u4f9b\u5546\u3001\u66f4\u6362 智能体 \u540e\u7aef\u3001\u6269\u5c55 API\u3002\u4f60\u62e5\u6709\u6574\u4e2a\u6280\u672f\u6808\u7684\u63a7\u5236\u6743\u3002",
+          "\u81ea\u5e26 LLM \u63d0\u4f9b\u5546\u3001\u66f4\u6362 Agent \u540e\u7aef\u3001\u6269\u5c55 API\u3002\u4f60\u62e5\u6709\u6574\u4e2a\u6280\u672f\u6808\u7684\u63a7\u5236\u6743\u3002",
       },
       {
         title: "\u9ed8\u8ba4\u900f\u660e",
         description:
-          "\u6bcf\u4e00\u884c\u4ee3\u7801\u90fd\u53ef\u5ba1\u8ba1\u3002\u786e\u5207\u4e86\u89e3\u4f60\u7684 智能体 \u5982\u4f55\u505a\u51b3\u7b56\u3001\u4efb\u52a1\u5982\u4f55\u8def\u7531\u3001\u6570\u636e\u6d41\u5411\u4f55\u65b9\u3002",
+          "\u6bcf\u4e00\u884c\u4ee3\u7801\u90fd\u53ef\u5ba1\u8ba1\u3002\u786e\u5207\u4e86\u89e3\u4f60\u7684 Agent \u5982\u4f55\u505a\u51b3\u7b56\u3001\u4efb\u52a1\u5982\u4f55\u8def\u7531\u3001\u6570\u636e\u6d41\u5411\u4f55\u65b9\u3002",
       },
       {
         title: "\u793e\u533a\u9a71\u52a8",
         description:
-          "\u4e0e\u793e\u533a\u4e00\u8d77\u5efa\u8bbe\uff0c\u800c\u4e0d\u4ec5\u4ec5\u662f\u4e3a\u793e\u533a\u5efa\u8bbe\u3002\u8d21\u732e\u6280\u80fd\u3001\u96c6\u6210\u548c 智能体 \u540e\u7aef\uff0c\u8ba9\u6bcf\u4e2a\u4eba\u53d7\u76ca\u3002",
+          "\u4e0e\u793e\u533a\u4e00\u8d77\u5efa\u8bbe\uff0c\u800c\u4e0d\u4ec5\u4ec5\u662f\u4e3a\u793e\u533a\u5efa\u8bbe\u3002\u8d21\u732e\u6280\u80fd\u3001\u96c6\u6210\u548c Agent \u540e\u7aef\uff0c\u8ba9\u6bcf\u4e2a\u4eba\u53d7\u76ca\u3002",
       },
     ],
   },
@@ -183,9 +183,9 @@ export function createZhDict(allowSignup: boolean): LandingDict {
     headline: "\u95ee\u4e0e\u7b54\u3002",
     items: [
       {
-        question: "Multica \u652f\u6301\u54ea\u4e9b\u7f16\u7801 智能体\uff1f",
+        question: "Multica \u652f\u6301\u54ea\u4e9b\u7f16\u7801 Agent\uff1f",
         answer:
-          "Multica \u5f00\u7bb1\u5373\u7528\u652f\u6301 11 \u6b3e AI \u7f16\u7a0b\u5de5\u5177\uff1aClaude Code\u3001Codex\u3001Cursor\u3001Copilot\u3001Gemini\u3001Hermes\u3001Kimi\u3001Kiro CLI\u3001OpenCode\u3001OpenClaw\u3001Pi\u3002\u5b88\u62a4\u8fdb\u7a0b\u4f1a\u81ea\u52a8\u68c0\u6d4b\u672c\u673a\u5df2\u5b89\u88c5\u7684 CLI \u5e76\u4e3a\u6bcf\u6b3e\u6ce8\u518c\u4e00\u4e2a\u8fd0\u884c\u65f6\u3002\u56e0\u4e3a\u5f00\u6e90\uff0c\u4f60\u4e5f\u53ef\u4ee5\u81ea\u5df1\u6dfb\u52a0\u540e\u7aef\u3002",
+          "Multica \u76ee\u524d\u5f00\u7bb1\u5373\u7528\u652f\u6301 Claude Code\u3001Codex\u3001OpenClaw \u548c OpenCode\u3002\u5b88\u62a4\u8fdb\u7a0b\u81ea\u52a8\u68c0\u6d4b\u4f60\u5b89\u88c5\u7684 CLI\u3002\u56e0\u4e3a\u5f00\u6e90\uff0c\u4f60\u4e5f\u53ef\u4ee5\u81ea\u5df1\u6dfb\u52a0\u540e\u7aef\u3002",
       },
       {
         question: "\u9700\u8981\u81ea\u6258\u7ba1\u5417\uff0c\u8fd8\u662f\u6709\u4e91\u7248\u672c\uff1f",
@@ -194,31 +194,31 @@ export function createZhDict(allowSignup: boolean): LandingDict {
       },
       {
         question:
-          "\u8fd9\u548c\u76f4\u63a5\u7528\u7f16\u7801 智能体 \u6709\u4ec0\u4e48\u533a\u522b\uff1f",
+          "\u8fd9\u548c\u76f4\u63a5\u7528\u7f16\u7801 Agent \u6709\u4ec0\u4e48\u533a\u522b\uff1f",
         answer:
-          "\u7f16\u7801 智能体 \u64c5\u957f\u6267\u884c\u3002Multica \u6dfb\u52a0\u7684\u662f\u7ba1\u7406\u5c42\uff1a\u4efb\u52a1\u961f\u5217\u3001\u56e2\u961f\u534f\u4f5c\u3001\u6280\u80fd\u590d\u7528\u3001\u8fd0\u884c\u65f6\u76d1\u63a7\uff0c\u4ee5\u53ca\u6bcf\u4e2a 智能体 \u5728\u505a\u4ec0\u4e48\u7684\u7edf\u4e00\u89c6\u56fe\u3002\u628a\u5b83\u60f3\u8c61\u6210\u4f60\u7684 智能体 \u7684\u9879\u76ee\u7ecf\u7406\u3002",
+          "\u7f16\u7801 Agent \u64c5\u957f\u6267\u884c\u3002Multica \u6dfb\u52a0\u7684\u662f\u7ba1\u7406\u5c42\uff1a\u4efb\u52a1\u961f\u5217\u3001\u56e2\u961f\u534f\u4f5c\u3001\u6280\u80fd\u590d\u7528\u3001\u8fd0\u884c\u65f6\u76d1\u63a7\uff0c\u4ee5\u53ca\u6bcf\u4e2a Agent \u5728\u505a\u4ec0\u4e48\u7684\u7edf\u4e00\u89c6\u56fe\u3002\u628a\u5b83\u60f3\u8c61\u6210\u4f60\u7684 Agent \u7684\u9879\u76ee\u7ecf\u7406\u3002",
       },
       {
-        question: "智能体 \u80fd\u81ea\u4e3b\u5904\u7406\u957f\u65f6\u95f4\u4efb\u52a1\u5417\uff1f",
+        question: "Agent \u80fd\u81ea\u4e3b\u5904\u7406\u957f\u65f6\u95f4\u4efb\u52a1\u5417\uff1f",
         answer:
-          "\u53ef\u4ee5\u3002Multica \u7ba1\u7406\u5b8c\u6574\u7684\u4efb\u52a1\u751f\u547d\u5468\u671f\u2014\u2014\u5165\u961f\u3001\u9886\u53d6\u3001\u6267\u884c\u3001\u5b8c\u6210\u6216\u5931\u8d25\u3002智能体 \u4e3b\u52a8\u62a5\u544a\u963b\u585e\u5e76\u5b9e\u65f6\u63a8\u9001\u8fdb\u5ea6\u3002\u4f60\u53ef\u4ee5\u968f\u65f6\u67e5\u770b\uff0c\u4e5f\u53ef\u4ee5\u8ba9\u5b83\u4eec\u8fd0\u884c\u6574\u665a\u3002",
+          "\u53ef\u4ee5\u3002Multica \u7ba1\u7406\u5b8c\u6574\u7684\u4efb\u52a1\u751f\u547d\u5468\u671f\u2014\u2014\u5165\u961f\u3001\u9886\u53d6\u3001\u6267\u884c\u3001\u5b8c\u6210\u6216\u5931\u8d25\u3002Agent \u4e3b\u52a8\u62a5\u544a\u963b\u585e\u5e76\u5b9e\u65f6\u63a8\u9001\u8fdb\u5ea6\u3002\u4f60\u53ef\u4ee5\u968f\u65f6\u67e5\u770b\uff0c\u4e5f\u53ef\u4ee5\u8ba9\u5b83\u4eec\u8fd0\u884c\u6574\u665a\u3002",
       },
       {
-        question: "\u6211\u7684\u4ee3\u7801\u5b89\u5168\u5417\uff1f智能体 \u5728\u54ea\u91cc\u6267\u884c\uff1f",
+        question: "\u6211\u7684\u4ee3\u7801\u5b89\u5168\u5417\uff1fAgent \u5728\u54ea\u91cc\u6267\u884c\uff1f",
         answer:
-          "智能体 \u5728\u4f60\u7684\u673a\u5668\uff08\u672c\u5730\u5b88\u62a4\u8fdb\u7a0b\uff09\u6216\u4f60\u81ea\u5df1\u7684\u4e91\u57fa\u7840\u8bbe\u65bd\u4e0a\u6267\u884c\u3002\u4ee3\u7801\u6c38\u8fdc\u4e0d\u4f1a\u7ecf\u8fc7 Multica \u670d\u52a1\u5668\u3002\u5e73\u53f0\u53ea\u534f\u8c03\u4efb\u52a1\u72b6\u6001\u548c\u5e7f\u64ad\u4e8b\u4ef6\u3002",
+          "Agent \u5728\u4f60\u7684\u673a\u5668\uff08\u672c\u5730\u5b88\u62a4\u8fdb\u7a0b\uff09\u6216\u4f60\u81ea\u5df1\u7684\u4e91\u57fa\u7840\u8bbe\u65bd\u4e0a\u6267\u884c\u3002\u4ee3\u7801\u6c38\u8fdc\u4e0d\u4f1a\u7ecf\u8fc7 Multica \u670d\u52a1\u5668\u3002\u5e73\u53f0\u53ea\u534f\u8c03\u4efb\u52a1\u72b6\u6001\u548c\u5e7f\u64ad\u4e8b\u4ef6\u3002",
       },
       {
-        question: "\u6211\u53ef\u4ee5\u8fd0\u884c\u591a\u5c11\u4e2a 智能体\uff1f",
+        question: "\u6211\u53ef\u4ee5\u8fd0\u884c\u591a\u5c11\u4e2a Agent\uff1f",
         answer:
-          "\u53d6\u51b3\u4e8e\u4f60\u7684\u786c\u4ef6\u3002\u6bcf\u4e2a 智能体 \u6709\u53ef\u914d\u7f6e\u7684\u5e76\u53d1\u9650\u5236\uff0c\u4f60\u53ef\u4ee5\u8fde\u63a5\u591a\u53f0\u673a\u5668\u4f5c\u4e3a\u8fd0\u884c\u65f6\u3002\u5f00\u6e90\u7248\u672c\u6ca1\u6709\u4efb\u4f55\u4eba\u4e3a\u9650\u5236\u3002",
+          "\u53d6\u51b3\u4e8e\u4f60\u7684\u786c\u4ef6\u3002\u6bcf\u4e2a Agent \u6709\u53ef\u914d\u7f6e\u7684\u5e76\u53d1\u9650\u5236\uff0c\u4f60\u53ef\u4ee5\u8fde\u63a5\u591a\u53f0\u673a\u5668\u4f5c\u4e3a\u8fd0\u884c\u65f6\u3002\u5f00\u6e90\u7248\u672c\u6ca1\u6709\u4efb\u4f55\u4eba\u4e3a\u9650\u5236\u3002",
       },
     ],
   },
 
   footer: {
     tagline:
-      "\u4eba\u7c7b + 智能体 \u56e2\u961f\u7684\u9879\u76ee\u7ba1\u7406\u3002\u5f00\u6e90\u3001\u53ef\u81ea\u6258\u7ba1\u3001\u4e3a\u672a\u6765\u7684\u5de5\u4f5c\u65b9\u5f0f\u800c\u5efa\u3002",
+      "\u4eba\u7c7b + Agent \u56e2\u961f\u7684\u9879\u76ee\u7ba1\u7406\u3002\u5f00\u6e90\u3001\u53ef\u81ea\u6258\u7ba1\u3001\u4e3a\u672a\u6765\u7684\u5de5\u4f5c\u65b9\u5f0f\u800c\u5efa\u3002",
     cta: "\u5f00\u59cb\u4f7f\u7528",
     groups: {
       product: {
@@ -283,121 +283,6 @@ export function createZhDict(allowSignup: boolean): LandingDict {
       fixes: "问题修复",
     },
     entries: [
-      {
-        version: "0.2.26",
-        date: "2026-05-06",
-        title: "i18n 全量铺开、长 Issue Timeline 提速与系统通知开关",
-        changes: [],
-        features: [
-          "Web 端完成简中翻译，21 个命名空间齐全，语言偏好按账号同步",
-          "Settings 新增 System Notifications 开关",
-          "支持删除 Chat 会话，History 面板移至 chat header",
-          "Runtime 在线判断改走 Redis（DB 兜底）",
-          "Desktop 支持加载 runtime 自托管配置",
-          "CLI 新增 `--assignee-id` / `--to-id` / `--user-id`，重名时定位更准",
-        ],
-        improvements: [
-          "Settings 的 Appearance Tab 改名为 Preferences，并把当前激活的 Tab 反映到 URL，深链可分享",
-          "长 Issue 打开秒开 —— Timeline 改为基于游标的 keyset 分页，重复的 `task_completed` / `task_failed` 活动条目合并展示",
-          "Runtime poll 与 heartbeat 调度按 runtime 隔离，单个忙碌 runtime 不再拖慢其他",
-          "CLI 更新请求落 Redis，server 重启也不丢",
-          "Runtime 用量统计窗口由 180 天收窄到 14 天，降低查询压力",
-          "项目列表返回 `resource_count` 摘要，不再内联全部 resource，响应体更小",
-          "404 页面重新设计，并修复 No-Access 重定向死循环",
-          "Quick Create 对 git-describe 类 daemon 跳过 CLI 版本闸",
-          "CI 启用 lint 强制门禁，历史 lint 债同步清理完毕",
-        ],
-        fixes: [
-          "Task 在服务端被删后，daemon 主动取消正在运行的 agent，避免孤儿进程",
-          "复用 execenv 时刷新陈旧的 Codex `auth.json`，修复偶发鉴权失败",
-          "`issue_id` 为空时拒绝写入 `.gc_meta.json`",
-          "跨 ACP 后端的 session/resume 信任 agent 自报的 session id，修复串号问题",
-          "OpenCode 的 skills 写到 `.opencode/skills/` 让其原生发现",
-          "Daemon 对 task-not-found 的 404 语义在 server 和最终 guard 双重收紧",
-          "侧边栏中失效的 Pin 自动取消挂载",
-          "项目详情页桌面端与移动端侧边栏状态独立保存",
-          "Runtime 详情页隐藏已归档的 agent",
-          "Add Resource 列表中已挂载的 repo 显示 URL tooltip；空项目页加上 New Issue 入口",
-          "S3 公开 URL 携带 region，修复跨区访问失败",
-          "Windows 安装器修正版本号解析与 checksum 解码",
-          "Quick Create 提交按钮去掉重复的快捷键提示",
-        ],
-      },
-      {
-        version: "0.2.24",
-        date: "2026-05-03",
-        title: "Repo Checkout `--ref`、Hermes 历史回放修复与多副本 Model Picker",
-        changes: [],
-        features: [
-          "`multica repo checkout --ref` 支持按分支、tag 或指定 commit 拉取仓库",
-          "`multica agent avatar` 命令支持直接通过 CLI 上传 Agent 头像",
-          "Inbox 中已完成任务新增 archive 按钮，移除冗余的 mark-as-done 悬浮按钮",
-        ],
-        improvements: [
-          "长 timeline 的 Issue 从 Inbox 打开不再卡顿 —— Markdown 渲染管线已 memoize，无关的 WS 事件不会再重渲染数千条评论",
-          "Model Picker 在多副本部署下可用 —— pending 请求改走 Redis 持久化，Daemon 上报失败也会自动重试",
-          "Daemon 空认领缓存 TTL 调高，空闲态 DB 压力进一步下降",
-        ],
-        fixes: [
-          "新创建的 Agent 立刻在各处可见 —— 创建时即 hydrate Agent 缓存",
-          "Hermes 在新一轮对话开始时不再重放上一轮答案 —— 历史 chunk 受单轮门禁限制",
-          "Codex runtime 模型选择器开放 GPT-5.5 系列",
-          "`multica login --token <PAT>` 正确接收 PAT 作为参数值",
-          "CLI update 完成状态上报更可靠",
-          "Session resume 按 runtime 正确守卫，避免跨 runtime 复用 session",
-          "看板拖拽 Issue 时显示设置不再丢失",
-          "Autopilot 列表在移动端 viewport 下响应式排版",
-          "Quick Create 生成的描述更贴合用户输入",
-          "Skill upsert 清理 null bytes，修复 PostgreSQL UTF8 错误",
-          "Connect Remote 弹窗的安装脚本 URL 修正",
-        ],
-      },
-      {
-        version: "0.2.21",
-        date: "2026-04-30",
-        title: "Quick Capture 全面升级、Mermaid 图表与 Typed Project Resources",
-        changes: [],
-        features: [
-          "Quick Capture 取代旧的 New Issue 弹窗 —— 支持连续创建、文件上传，并能根据粘贴的 URL 自动丰富标题与描述",
-          "Markdown 内联渲染 Mermaid 图表，复杂图支持全屏 lightbox",
-          "Project 支持单独绑定 repo，无需依赖 workspace 默认配置",
-          "Agent / 评论 / Runtime / Skill 全面接入权限感知 UI，没有权限的操作不再展示",
-        ],
-        improvements: [
-          "Daemon `/tasks/claim` 轮询走 Redis 空认领 fast-path，空闲态 DB 压力下降，长期 open 的 Issue 自动回收磁盘",
-          "Multica Agent 的 Git 提交自动追加 `Co-authored-by` trailer，归属更清晰",
-          "Desktop 拦截 Cmd+R / Ctrl+R / F5 防止意外刷新，开发模式与 Updates 设置中均展示真实版本号",
-        ],
-        fixes: [
-          "Quick Create 不再凭空脑补需求，并自动把发起人订阅到 Issue",
-          "Inbox 点击通知后立即跳到目标评论；从 Issue 详情页 Mark as Done 时自动归档",
-          "Task rerun 启动全新 session，跳过被污染的 resume 状态",
-          "受邀成员登录后路由到所在 workspace，不再强制带去 `/onboarding`",
-        ],
-      },
-      {
-        version: "0.2.20",
-        date: "2026-04-29",
-        title: "Create Issue by Agent、Agent Presence v3 与 Daemon WebSocket 心跳",
-        changes: [],
-        features: [
-          "Create Issue by Agent —— 按 `c` 输入一句话并选 Agent，Issue 异步创建，结果回执送达 Inbox",
-          "Agent Presence v3 —— 可用性与最近任务拆成两条更清晰的信号；Issue 详情右侧新增 Execution Log，可看到当前 active run 与历史 run",
-          "Daemon ↔ Server 心跳改走 WebSocket，HTTP 自动 fallback，任务起跑延迟更低",
-          "Mention 选择器按本机最近使用排序",
-        ],
-        improvements: [
-          "Server 用 Redis 缓存 PAT / Daemon Token 校验，大型团队不再让 DB 抗下每次请求",
-          "后端支持通过 `MULTICA_CLAUDE_ARGS` / `MULTICA_CODEX_ARGS` 配置 Agent CLI 默认参数",
-          "Manual 与 Agent 创建 Issue 共享同一个 Dialog 外壳，picker Agent 会被默认设为 assignee",
-        ],
-        fixes: [
-          "Create Issue by Agent 不再卡住 queued 任务，也不再因附件上传失败而重复创建 Issue",
-          "Agent 评论保留换行，不再渲染成字面量 `\\n`，多行回复的格式也被完整保留",
-          "Agent 自身发出的根评论不再继承父评论的 @mention，避免互相唤起的死循环",
-          "Windows 下 Cursor Agent 启动时保留多行 prompt",
-        ],
-      },
       {
         version: "0.2.19",
         date: "2026-04-28",

apps/web/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/dev/types/routes.d.ts";
+import "./.next/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

apps/web/proxy.ts

@@ -1,5 +1,4 @@
 import { NextResponse, type NextRequest } from "next/server";
-import { matchLocale, LOCALE_COOKIE } from "@multica/core/i18n";
 
 // Old workspace-scoped route segments that existed before the URL refactor
 // (pre-#1131). Any URL with these as the FIRST segment is a legacy URL that
@@ -17,34 +16,7 @@ const LEGACY_ROUTE_SEGMENTS = new Set([
   "settings",
 ]);
 
-// Resolve the active locale per request. Cookie wins over Accept-Language;
-// matchLocale() falls back to DEFAULT_LOCALE when neither yields a match.
-function resolveLocale(req: NextRequest): string {
-  const cookieLocale = req.cookies.get(LOCALE_COOKIE)?.value;
-  const acceptLanguage = req.headers.get("accept-language") ?? "";
-  const candidates: string[] = [];
-  if (cookieLocale) candidates.push(cookieLocale);
-  for (const part of acceptLanguage.split(",")) {
-    const tag = part.split(";")[0]?.trim();
-    if (tag) candidates.push(tag);
-  }
-  return matchLocale(candidates);
-}
-
-// Forward the resolved locale to RSC layouts via the `x-multica-locale`
-// request header. layout.tsx reads it through `await headers()`. The
-// `request: { headers }` form is what makes the header land on the upstream
-// request — without it the value would only sit on the response.
-function nextWithLocale(req: NextRequest): NextResponse {
-  const headers = new Headers(req.headers);
-  headers.set("x-multica-locale", resolveLocale(req));
-  return NextResponse.next({ request: { headers } });
-}
-
-// Next.js 16 renamed `middleware` → `proxy`. API surface (NextRequest /
-// NextResponse / cookies / matcher) is identical; the only behavioral
-// change is the runtime — proxy is forced to nodejs and cannot opt into
-// edge.
+// Next.js 16 renamed `middleware` → `proxy`. The runtime API is identical.
 export function proxy(req: NextRequest) {
   const { pathname } = req.nextUrl;
   const hasSession = req.cookies.has("multica_logged_in");
@@ -76,21 +48,34 @@ export function proxy(req: NextRequest) {
   }
 
   // --- Root path: redirect logged-in users to their last workspace ---
-  if (pathname === "/" && hasSession && lastSlug) {
-    const url = req.nextUrl.clone();
-    url.pathname = `/${lastSlug}/issues`;
-    return NextResponse.redirect(url);
+  if (pathname === "/") {
+    if (!hasSession) return NextResponse.next();
+
+    if (lastSlug) {
+      const url = req.nextUrl.clone();
+      url.pathname = `/${lastSlug}/issues`;
+      return NextResponse.redirect(url);
+    }
+
+    // No last_workspace_slug cookie → let landing page pick the first workspace
+    // client-side (features/landing/components/redirect-if-authenticated.tsx).
+    return NextResponse.next();
   }
 
-  // --- Default: forward locale header to RSC, no redirect/rewrite ---
-  // Covers logged-out root path, /login, /:slug/*, and everything else.
-  return nextWithLocale(req);
+  return NextResponse.next();
 }
 
 export const config = {
-  // i18n header must land on every page request, so we use the standard
-  // negative-lookahead pattern from Next's i18n guide: skip API routes
-  // (Go backend), Next internals, and any path with a file extension
-  // (favicons, sw.js, public/* assets).
-  matcher: ["/((?!api|_next/static|_next/image|favicon.ico|.*\\.).*)"],
+  matcher: [
+    "/",
+    "/issues/:path*",
+    "/projects/:path*",
+    "/agents/:path*",
+    "/inbox/:path*",
+    "/my-issues/:path*",
+    "/autopilots/:path*",
+    "/runtimes/:path*",
+    "/skills/:path*",
+    "/settings/:path*",
+  ],
 };

apps/web/test/helpers.tsx

@@ -14,7 +14,6 @@ export const mockUser: User = {
   // Matches real server behavior for anyone who onboarded before this
   // field shipped — migration 054 backfills 'skipped_legacy'.
   starter_content_state: "skipped_legacy",
-  language: null,
   created_at: "2026-01-01T00:00:00Z",
   updated_at: "2026-01-01T00:00:00Z",
 };

docs/agent-runtime-status-redesign.md

@@ -0,0 +1,802 @@
+# Agent / Runtime 状态系统重设计
+
+> **文档定位**：这是一份完整的设计 + 实施方案。任何一个新加入的工程师 / 设计师 / 产品，看完这份文档应该能：
+> - 理解我们要解决的问题、为什么这么解决
+> - 知道每个阶段做什么、按什么顺序做、产出什么
+> - 在不读代码的前提下能独立讨论方案
+>
+> 本文档是 [agent-status-design-brief.md](./agent-status-design-brief.md) 和 [agent-status-redesign-plan.md](./agent-status-redesign-plan.md) 的合并升级版，达成共识后会取代它们。
+
+---
+
+## 目录
+
+1. [背景与目标](#一背景与目标)
+2. [核心思想](#二核心思想)
+3. [状态系统规范](#三状态系统规范)
+4. [数据架构](#四数据架构)
+5. [跨平台策略](#五跨平台策略)
+6. [设计语言](#六设计语言)
+7. [实施分阶段](#七实施分阶段)
+8. [验收标准](#八验收标准)
+9. [边界与不做的事](#九边界与不做的事)
+10. [风险与注意事项](#十风险与注意事项)
+11. [参考](#十一参考)
+
+---
+
+## 一、背景与目标
+
+### 1.1 Multica 的产品定位提醒
+
+Multica 是 AI-native 的任务管理平台——agent 是和人对等的"同事"。一个工作区里同时有人和 agent 在协作，相互分配任务、评论、订阅。
+
+理解这个定位很重要，因为它直接决定了状态系统的需求：**用户对 agent 的预期跟"对同事的预期"是相同的**——我希望随时知道这个同事现在能不能接活、在不在线、是不是出问题了。
+
+### 1.2 当前的核心问题
+
+**所有界面都在直接展示后端的原始字段，缺少"用户视角"的状态翻译层。**
+
+具体表现（按用户感知严重度排序）：
+
+1. **Agent 列表的 "Idle" 绿点会骗人**——daemon 已经死了，agent 仍然显示 Idle。用户分配任务后没有任何反馈，长时间困惑"为什么 agent 不动"。
+2. **Runtime 列表只有一个圆点**——"刚断线 5 分钟"和"3 个月前断线"视觉一模一样，用户判断不出严重程度。
+3. **Issue 详情页多个 agent 同时工作时只有 1 个可见**——其他 agent 的卡片埋在下方滚动区，没有总览。
+4. **任务失败时只有红色 X**——`agent_error`（agent 自己挂了）和 `runtime_offline`（daemon 离线）处理方式完全不同，但视觉上不区分。
+5. **Chat 发消息后只有一个 spinner 转数分钟**——无法区分"排队"、"思考"、"调用工具"、"生成回答"四个阶段。
+
+### 1.3 根本原因
+
+后端字段是**任务调度的内部状态**（`agent.status` = idle/working/blocked/error），不是给用户看的。当前前端把后端字段直接渲染给用户，就把"调度内部视角"暴露成了"用户视角"。
+
+但用户不关心 agent 的内部调度状态，用户关心的是：
+
+- **能不能用？**（在线 / 离线）
+- **如果在用，在干什么？**（工作中 / 排队中 / 失败了）
+- **如果不能用，为什么？**（daemon 离线 / CLI 没装 / 任务超时）
+
+这些问题的答案，**没有任何一个能从单一字段直接得到**——它们都需要把多个数据源聚合后才能算出来。
+
+### 1.4 目标
+
+**做一套"用户视角"的状态系统**，覆盖三类对象：
+
+- **Agent**：5 态（available / working / pending / failed / offline），跨界面一致
+- **Runtime**：4 态（online / recently_lost / offline / about_to_gc）
+- **Task**：阶段化（queued / dispatched / thinking / using_tool / generating / completed / failed）
+
+完成这套系统后，下列现有界面会自然变好：
+
+- Agents 列表 / 详情：看到真实可用性
+- Runtimes 列表 / 详情：看到机器健康度
+- Issue Detail：多 agent 全景 + 失败原因显示
+- 跨界面 hover card（issue assignee / autopilot / chat / @mention）：状态一致
+- Chat：分阶段进度
+
+---
+
+## 二、核心思想
+
+### 2.1 一句话
+
+**把"用户视角的状态"做成前端的派生量**——后端只暴露真相（任务存在、心跳到达），前端按 UI 需要把这些真相聚合成"用户能理解的状态"。
+
+### 2.2 三个设计原则
+
+#### 原则 1：派生函数住在前端，不污染后端
+
+`agent.status` / `runtime.status` 这些后端字段是 **物理事实**：
+- "task X 现在 running"
+- "daemon Y 45 秒前发了心跳"
+
+而 "Available / Working / Pending / Failed / Offline" 这些是 **UI 翻译**：
+- "FAILED 状态保持 2 分钟" 是设计决策
+- "蓝色表示 working" 是视觉决策
+- 不同界面可能要不同视角（issue 里看"任务阶段"、列表里看"是否可分配"）
+
+**UI 翻译应该住在前端，跟着设计需求一起迭代。** 把它放进后端，每改一次都要 migration + WS payload 兼容 + 老客户端处理，迭代周期从分钟变周。
+
+#### 原则 2：服务器状态住在 TanStack Query cache，不复制进 Zustand
+
+我们的全局状态有两套：
+- **Zustand** 管 client state（UI 选中、筛选器、modal 开关）
+- **TanStack Query cache** 管 server state（来自 API 的所有数据）
+
+TQ cache 不是组件级缓存，**它本身就是 server state 的全局状态管理**。跨组件共享、按 key 索引、自动去重。
+
+派生状态是 server data 的纯函数。结果不存——每次组件渲染时按需用 `useMemo` 算一遍。算的成本是几个 filter + some 调用，可忽略。
+
+#### 原则 3：聚合在前端做，但要避免 N+1
+
+派生状态需要 3 份原始数据：
+- agents 列表
+- runtimes 列表
+- 当前活跃任务列表（active tasks）
+
+朴素做法：每个组件 `useAgentTasks(agentId)`——一个 issues 列表 30 个 agent 头像 = 30 次请求。这就是 N+1。
+
+正解：**进工作区时一次性拉"全工作区的活跃任务"**（数据量天然不大，活跃任务永远是少数），存进 TQ cache。所有组件共享这一份缓存，按 agentId 在内存里 filter——零额外请求。
+
+这是把"per-agent 的数据需求"转换成"全工作区的集合数据需求"。集合数据天然只需要 1 次请求。
+
+---
+
+## 三、状态系统规范
+
+### 3.1 Agent 五态
+
+| 状态 | 颜色 | 用户语义 | 出现条件 |
+|---|---|---|---|
+| **Available** | 🟢 绿 | 在线空闲，可以接活 | runtime 在线 + 没有活跃任务 |
+| **Working** | 🔵 蓝 | 正在干活 | runtime 在线 + 至少一个任务在执行 |
+| **Pending** | 🟡 黄 | 任务排着但没在跑 | runtime 在线 + 0 个执行中 + ≥1 个排队 |
+| **Failed** | 🔴 红 | 最近一次失败 | 最近 2 分钟内有任务失败 |
+| **Offline** | ⚫ 灰 | Daemon 离线，不可用 | runtime 离线（包含 CLI 未安装） |
+
+**复合维度**：当 agent 是 Working 但同时有任务排队，主状态保持 Working，旁边带 `+N` 角标（"还有 N 个排队"）。
+
+**派生规则**（按优先级匹配，命中即返回）：
+
+```ts
+type AgentPresence = "available" | "working" | "pending" | "failed" | "offline"
+
+function deriveAgentPresence(input: {
+  agent: Agent
+  runtime: AgentRuntime
+  recentTasks: AgentTask[]   // 该 agent 最近 N 个任务
+  now: number                // 当前时间戳
+}): AgentPresence {
+  // 1. Runtime 离线（含 CLI 未安装）→ offline
+  if (input.runtime.status === "offline") return "offline"
+
+  // 2. 最近窗口内有 failed task → failed
+  const recentFailed = input.recentTasks.find(
+    t => t.status === "failed" &&
+         (input.now - new Date(t.completed_at).getTime()) < FAILED_WINDOW_MS
+  )
+  if (recentFailed) return "failed"
+
+  // 3. 有 running task → working
+  if (input.recentTasks.some(t => t.status === "running")) return "working"
+
+  // 4. 有 queued/dispatched task → pending
+  if (input.recentTasks.some(t => t.status === "queued" || t.status === "dispatched")) {
+    return "pending"
+  }
+
+  // 5. Otherwise → available
+  return "available"
+}
+```
+
+**复合维度的派生**：
+
+```ts
+function deriveAgentPresenceDetail(...): {
+  presence: AgentPresence
+  runningCount: number
+  queuedCount: number
+  failureReason?: TaskFailureReason  // 仅 presence === "failed" 时有值
+}
+```
+
+**待确认常量**：
+
+- `FAILED_WINDOW_MS = 2 * 60 * 1000`（2 分钟）。
+  - 短到避免污染（任务失败的红点不会一直黏着）
+  - 长到让用户能看见（不会还没看就消失）
+  - **未来可能扩展**：2 分钟内强提示（红色动效），之后降级为 tooltip 的"最近失败"摘要——这样既不刺眼，又不丢信息。本期先用固定 2 分钟。
+
+### 3.2 Runtime 四态
+
+| 状态 | 触发条件 | 用户语义 |
+|---|---|---|
+| **Online** | 最近 45 秒内有心跳 | 健康，能接任务 |
+| **Recently Lost** | 离线但 < 5 分钟 | 可能短暂网络抖动 |
+| **Offline** | 离线 5 分钟 ~ 7 天 | 长期离线，需要排查 |
+| **About to GC** | 离线接近 7 天阈值 | 系统将自动清理 |
+
+```ts
+function deriveRuntimeHealth(runtime: AgentRuntime, now: number): RuntimeHealth {
+  if (runtime.status === "online") return "online"
+
+  const lastSeen = runtime.last_seen_at
+    ? new Date(runtime.last_seen_at).getTime()
+    : 0
+  const offlineFor = now - lastSeen
+
+  if (offlineFor < 5 * 60 * 1000) return "recently_lost"
+  if (offlineFor > 6 * 24 * 3600 * 1000) return "about_to_gc"  // 7d - 1d
+  return "offline"
+}
+```
+
+> **关于 CLI 未安装等"runtime 在线但跑不了"的场景**：归并到 `offline`，tooltip 写明具体原因（"CLI 未安装"、"Daemon 启动中"）。不为此引入第六态——状态空间膨胀代价高，分辨率应该用 tooltip / detail 而不是顶层枚举。
+
+### 3.3 Task 阶段化
+
+用于 Issue Detail 和 Chat 显示当前任务在哪一步：
+
+```ts
+type TaskStage =
+  | "queued"
+  | "dispatched"     // dispatched 但进程没起来
+  | "thinking"       // running，最后一条 message 是 thinking
+  | "using_tool"     // running，最后一条是 tool_use / tool_result
+  | "generating"     // running，最后一条是 text
+  | "completed"
+  | "failed"
+  | "cancelled"
+```
+
+派生函数读 task 状态 + 最后一条 message 的 type 即可决定阶段。
+
+### 3.4 失败原因映射
+
+`task.failure_reason` 来自后端 migration 055，5 个值映射到中文标签：
+
+```ts
+const FAILURE_REASON_LABEL: Record<TaskFailureReason, string> = {
+  agent_error:      "Agent 执行报错",
+  timeout:          "执行超时",
+  runtime_offline:  "Daemon 离线",
+  runtime_recovery: "Daemon 重启回收",
+  manual:           "用户取消",
+}
+```
+
+每种原因要给用户对应的处理建议（具体文案待设计师定）。
+
+> ⚠️ **当前差异**：后端 schema 已有 `failure_reason`（migration 055），但前端 `packages/core/types/agent.ts` 的 `AgentTask` 接口**未暴露此字段**。阶段 0 必须同步：
+> - 前端类型补 `failure_reason: TaskFailureReason | null`
+> - 检查后端 `ListAgentTasks` / 新增的 `ListActiveTasksByWorkspace` 是否 SELECT 了这个字段
+
+---
+
+## 四、数据架构
+
+### 4.1 数据流
+
+```
+                 后端真相
+   ┌────────────┬─────────────┬──────────────┐
+   │  agents    │  runtimes   │  active_tasks│
+   │  (HTTP)    │  (HTTP)     │  (HTTP)      │
+   └─────┬──────┴──────┬──────┴───────┬──────┘
+         │             │              │
+         └─────────────┴──────────────┘
+                       ▼
+            TanStack Query cache
+                  (全局共享)
+                       ▼
+            派生函数（纯函数）
+       ┌───────────────┴───────────────┐
+       ▼                               ▼
+   AgentPresence                 RuntimeHealth
+       │                               │
+       ▼                               ▼
+   组件渲染（5 态视觉）         组件渲染（4 态视觉）
+
+   ──────────────────────────────────────────────
+   
+                    实时更新
+                  
+   后端 WS 事件 ──→ 前端 invalidate query ──→ 重拉 ──→ 派生重算 ──→ UI 更新
+   
+   桌面端额外：本机 IPC ──→ setQueryData 直接预填 ──→ 亚秒级响应
+```
+
+### 4.2 三个 query
+
+```ts
+// 进工作区时一次性拉
+useQuery(['ws', wsId, 'agents'])         // listAgents
+useQuery(['ws', wsId, 'runtimes'])       // listRuntimes
+useQuery(['ws', wsId, 'active-tasks'])   // ★ 新增：getActiveTasksForWorkspace
+```
+
+**`active-tasks` 是新增 query**——返回当前工作区所有 status ∈ {queued, dispatched, running} 的任务。这份数据天然小（活跃任务不会很多），值得做成"全工作区一次拉"。
+
+> ⚠️ **当前差异**：后端**没有此 endpoint**。现有只有 `listAgentTasks(agentId)`（per-agent）和 `getActiveTasksForIssue(issueId)`（per-issue）。阶段 0 必须新增 `GET /api/workspaces/:slug/active-tasks`——它仍然返回原始 task 列表，不做任何派生，**不违反"零后端聚合"原则**。
+
+#### Runtime → Agents 是 reverse query
+
+后端没有 "runtime 服务的 agent 列表" API。Agent 持有 `runtime_id` 外键，但 Runtime 没有反向关联。
+
+**前端处理**：从已缓存的 `agents` 列表 `filter(a => a.runtime_id === rtId)` 即可。这不算 N+1（agents 列表本来就要拉），是免费的 join。
+
+### 4.3 WS 事件接线表
+
+| WS 事件 | 触发的 invalidate |
+|---|---|
+| `agent:created` / `agent:archived` / `agent:updated` | `['ws', wsId, 'agents']` |
+| `agent:status` | `['ws', wsId, 'agents']`（即使我们不用这个值，缓存 fresh 仍要） |
+| `daemon:register` | `['ws', wsId, 'runtimes']` |
+| `task:dispatch` / `task:completed` / `task:failed` / `task:cancelled` | `['ws', wsId, 'active-tasks']` |
+| `task:progress` | （考虑节流，避免高频任务刷新缓存） |
+| `daemon:heartbeat` | **故意忽略** —— 后端发送但前端不订阅，避免每 15 秒过度 refetch。后果：runtime online → recently_lost 切换最坏延迟 75 秒（45s sweeper + 30s 间隔）。设计上接受这个延迟。 |
+
+**关键不变量**：每个派生函数依赖的字段都必须有对应 WS 事件覆盖。任何字段没事件覆盖，状态会卡住。每次新增派生维度都要回头检查这张表。
+
+### 4.4 桌面端 IPC 桥接
+
+桌面端通过 Electron IPC 直接读本机 daemon。这份数据：
+- 比 server WS **快 75 秒**（IPC 亚秒，server sweep 最坏 75s）
+- 包含 server 看不到的 `starting` / `stopping` / `cli_not_found` 等中间态
+
+**不修改派生函数签名**——桌面端把 IPC 数据用 `setQueryData` 直接写进 runtime cache：
+
+```ts
+// 仅桌面端：apps/desktop/src/renderer/src/platform/daemon-ipc-bridge.ts
+window.electron.onDaemonStatus((status) => {
+  queryClient.setQueryData(
+    ['ws', wsId, 'runtimes'],
+    (old) => old?.map(rt =>
+      rt.id === status.runtimeId ? mergeDaemonStatus(rt, status) : rt
+    )
+  )
+})
+```
+
+派生函数完全不知道数据从哪来——它只读 cache。**桌面端自动获得亚秒级体验，零派生函数改动**。
+
+---
+
+## 五、跨平台策略
+
+### 5.1 状态系统是平台无关的
+
+派生函数、5 态/4 态规范、UI 视觉——**两端共享同一套**。设计稿只画一份。
+
+### 5.2 数据源平台相关
+
+| 平台 | Runtime 数据来源 | 状态变化感知延迟 |
+|---|---|---|
+| Web | server WS / HTTP | 最坏 75 秒 |
+| Desktop（本机 daemon） | IPC + server | < 1 秒 |
+| Desktop（别人的 daemon） | server WS / HTTP | 跟 Web 一样 |
+
+数据源不同不影响 UI——派生函数读 cache，cache 是"哪边更新就更新"。
+
+### 5.3 操作能力平台相关
+
+| 操作 | Web | Desktop（自己机器） | Desktop（别人机器） |
+|---|---|---|---|
+| 看状态 | ✅ | ✅ | ✅ |
+| 重启 daemon | ❌ | ✅ | ❌ |
+| 看 daemon logs | ❌ | ✅ | ❌ |
+| 看 CLI 安装详情 | ❌ | ✅ | ❌ |
+
+实现方式：组件按 `isLocalDaemon && isOwner` 条件渲染按钮。**不需要写进派生函数 / 状态系统**，是 UI 局部决策。
+
+### 5.4 Daemon 卡片视觉对齐
+
+桌面端 settings 里的"本机 daemon 卡片"必须跟云端 runtime 列表项视觉一致。同一台机器同一个概念，不能两套设计。
+
+---
+
+## 六、设计语言
+
+### 6.1 直接复用 Skills 界面（PR #1607、#1614、#1618、#1610）
+
+Skills 界面已经在 2026-04 完成重设计，是当前产品的视觉锚点。Agents / Runtimes 直接照搬其规则：
+
+1. **统一页头** `PageHeader`（h-12 + mobile sidebar trigger）
+2. **响应式网格列表**：`grid-cols-[minmax(0,1.6fr)_minmax(0,0.8fr)_minmax(0,1.2fr)_minmax(0,6rem)_auto]`
+3. **每行三层信息**：主标题 → 描述（line-clamp-1 muted）→ 元数据（xs muted）
+4. **关联对象用头像堆栈**：最多 3 + `+N`，size=22 + `ring-2 ring-background` + `-space-x-1.5`
+5. **卡片化列表 + 卡片内工具栏**：搜索和 scope tab 在 `CardToolbar`（h-12），不在页面级
+6. **创建用多步 dialog**：chooser → 表单，可回退；宽度按方法切换，300ms 过渡
+7. **空状态分文案**：图标 + 标题 + 三行说明 + 清晰 CTA
+8. **长列表 `useScrollFade`**：上下边缘淡出
+9. **头像统一 `ActorAvatar`**：传 `size`，自动支持 agent / 人
+10. **权限检查 hook 化**：`useCanEdit...`，UI 提前隐藏/禁用
+
+### 6.2 状态视觉的三个层级
+
+每种派生状态在三个层级要保持一致：
+
+- **Dot**（圆点）：列表项、头像旁，最紧凑
+- **Badge**（徽章）：详情页头部、卡片角落，带图标 + 文字
+- **Tooltip / Hover Card**：鼠标悬停展开完整信息
+
+**跨界面一致性**：同一个 agent 无论出现在哪（agents 列表 / issue assignee picker / autopilot 编辑 / chat 选择面板 / 评论 @），状态视觉必须完全一致。
+
+---
+
+## 七、实施分阶段
+
+### 阶段 0 — 数据层地基（无 UI 改动）
+
+**目标**：派生函数 + cache + WS + IPC 桥接全部就位。UI 暂不动。完成后所有 UI 阶段都能放心假设"派生状态可用、零额外请求"。
+
+#### 后端工作（Go）
+
+| 文件 | 改动 |
+|---|---|
+| `server/pkg/db/queries/agent_task.sql` | 新增 sqlc query：`ListActiveTasksByWorkspace`，SELECT 所有字段含 `failure_reason`，过滤 status ∈ {queued, dispatched, running} |
+| `server/pkg/db/agent_task.sql.go` | `make sqlc` 自动生成 |
+| `server/internal/handler/agent.go`（或新建 task handler） | `ListActiveTasksByWorkspace` handler，权限校验：用户必须是 workspace member |
+| `server/cmd/server/router.go` | 注册路由 `GET /api/workspaces/{slug}/active-tasks` |
+| **核查**：现有 `ListAgentTasks` query | 确认 SELECT `failure_reason` 字段；如未 SELECT，补上 |
+
+#### 前端类型补全
+
+| 文件 | 改动 |
+|---|---|
+| `packages/core/types/agent.ts` | `AgentTask` 接口加 `failure_reason: TaskFailureReason \| null`；新增 `TaskFailureReason = "agent_error" \| "timeout" \| "runtime_offline" \| "runtime_recovery" \| "manual"` |
+
+#### 前端 API client
+
+| 文件 | 改动 |
+|---|---|
+| `packages/core/api/client.ts` | 新增方法 `getActiveTasksForWorkspace(wsSlug): Promise<AgentTask[]>` |
+
+#### 前端派生函数 + 类型
+
+| 文件 | 内容 |
+|---|---|
+| `packages/core/agents/types.ts`（如不存在则新建） | `AgentPresence` / `AgentPresenceDetail` / `RuntimeHealth` 等类型 |
+| `packages/core/agents/derive-presence.ts` | `deriveAgentPresence` / `deriveAgentPresenceDetail` 纯函数 |
+| `packages/core/agents/derive-presence.test.ts` | 5 态全分支 + 边界 case（runtime null / tasks 空 / 时钟边界） |
+| `packages/core/runtimes/derive-health.ts` | `deriveRuntimeHealth` |
+| `packages/core/runtimes/derive-health.test.ts` | 4 态全分支 |
+
+#### 前端 query + hook
+
+| 文件 | 内容 |
+|---|---|
+| `packages/core/agents/active-tasks-query.ts` | `activeTasksOptions(wsId)` query options |
+| `packages/core/agents/use-agent-presence.ts` | `useAgentPresence(agentId)` hook：读 3 份 cache → 派生 |
+| `packages/core/runtimes/use-runtime-health.ts` | `useRuntimeHealth(runtimeId)` hook |
+| `packages/core/runtimes/use-runtime-agents.ts` | `useRuntimeAgents(runtimeId)` hook：从 agents cache filter 出绑定的 agents |
+
+#### 前端 WS 接线
+
+| 文件 | 改动 |
+|---|---|
+| `packages/core/realtime/agent-runtime-sync.ts` | 新增专用 sync。订阅 `agent:*` / `task:dispatch` / `task:completed` / `task:failed` / `task:cancelled` / `daemon:register` → invalidate 对应 query。**显式不订阅 `daemon:heartbeat`**（接受 75 秒延迟） |
+| `packages/core/realtime/use-realtime-sync.ts`（如已有全局 hook） | 集成新 sync |
+
+#### 桌面端 IPC 桥接
+
+| 文件 | 内容 |
+|---|---|
+| `apps/desktop/src/renderer/src/platform/daemon-ipc-bridge.ts` | 监听 `window.daemonAPI.onStatus(...)`，用 `queryClient.setQueryData` 把本机 daemon status merge 进对应 runtime cache |
+
+#### 完成标准
+
+- [ ] 后端 `GET /api/workspaces/:slug/active-tasks` 通 curl 测试，返回 active tasks 列表
+- [ ] `deriveAgentPresence` / `deriveRuntimeHealth` 单测全部通过
+- [ ] 控制台调用 `useActiveTasks(wsId)` 能拿到全工作区活跃任务
+- [ ] 控制台调用 `useAgentPresence(agentId)` 能拿到正确的 5 态状态
+- [ ] WS 接线表里所有事件都能正确 invalidate（手测覆盖）
+- [ ] 关本机 daemon 后桌面端 runtime cache **1 秒内**变 offline
+- [ ] 不动任何 UI 文件——这阶段 zero UI delta
+
+### 阶段 1 — Agents + Runtimes 列表页
+
+**目标**：两个列表用上派生状态，互相能看到对方。
+
+#### 设计师产出（先于代码）
+
+- 5 态 dot / badge / tooltip 三层视觉规范
+- Working + 排队角标的复合视觉
+- Failed 状态的 2 分钟时间窗口动效
+- Runtime 4 态的视觉差异（不能再是同一个浅灰圆点）
+
+#### 改造文件
+
+| 文件 | 改动 |
+|---|---|
+| `packages/views/agents/components/agent-list-item.tsx` | 替换 `statusConfig[agent.status]` 为 `useAgentPresence(agentId)` |
+| `packages/views/agents/components/agents-page.tsx` | 接 WS 订阅 |
+| `packages/views/agents/config.ts` | 删除 `statusConfig`，新建 `presenceConfig` |
+| `packages/views/runtimes/components/runtime-list.tsx` | 用派生 4 态；展示 last_seen、关联 agent 数、当前任务数 |
+| `packages/views/runtimes/components/runtimes-page.tsx` | 接 WS 订阅 |
+| `apps/desktop/.../local-daemon-card.tsx` | 视觉对齐云端 runtime 卡片 |
+
+### 阶段 2 — Agents + Runtimes 详情页
+
+**目标**：详情页头部、profile card 状态联动；Runtime token usage 信息架构整理。
+
+#### 改造文件
+
+| 文件 | 改动 |
+|---|---|
+| `packages/views/agents/components/agent-detail.tsx` | 头部 status badge 用派生 |
+| `packages/views/agents/components/agent-profile-card.tsx` | 状态行和 runtime 行联动；展示当前任务数 + 最近失败原因 |
+| `packages/views/runtimes/components/runtime-detail.tsx` | Token usage 主次重排：核心指标置顶，5 个图表折叠 / 下沉 |
+| `packages/views/runtimes/components/usage-section.tsx` | API 调用按时间窗口拉（不再总是 90 天） |
+
+### 阶段 3 — Issue Detail 任务展示
+
+**目标**：多 agent 全景视图；任务阶段化；失败原因显式。
+
+#### 新增文件
+
+| 文件 | 内容 |
+|---|---|
+| `packages/core/agents/derive-task-stage.ts` | `deriveTaskStage` |
+| `packages/core/agents/derive-task-stage.test.ts` | 单测 |
+| `packages/views/issues/components/agent-task-row.tsx` | 单 agent 单任务一行 |
+
+#### 改造文件
+
+| 文件 | 改动 |
+|---|---|
+| `packages/views/issues/components/agent-live-card.tsx` | 从"sticky 一个 + 折叠列表"改为"每个 agent 一行" |
+| `packages/views/issues/components/agent-transcript-dialog.tsx` | 失败时展示 failure_reason |
+
+### 阶段 4 — 跨界面 Hover Card
+
+**目标**：所有 agent 头像出现的位置都用统一的 hover card。
+
+#### Hover Card 必须显示的内容（按重要度排序）
+
+1. 派生 5 态状态
+2. Runtime 健康（在线性 + last_seen 相对时间）
+3. 当前任务（N running / M queued）
+4. 最近失败（如果有）：原因 + 时间
+5. Agent 名称 + description
+6. 关联 skills（前 3 个 + `+N`）
+7. Owner
+
+#### 必须接入的位置
+
+| 位置 | 当前状态 |
+|---|---|
+| Agents 列表 / 详情 | ✅ 已有 |
+| Issue Assignee Picker | ❌ 仅头像无状态 |
+| Issue Detail 头部 assignee | ❌ 仅头像无状态 |
+| Issue 列表 / 看板的分配头像 | ❌ 仅头像 |
+| Autopilot 列表 / 编辑（assignee） | ❌ 仅头像 |
+| Project lead picker | ❌ 仅头像 |
+| Chat 选择 agent 面板 | ❌ 待确认 |
+| 评论里的 @agent | ❌ 仅头像 |
+
+#### 实施
+
+`ActorAvatar` 组件挂载 hover card——一处改动，上面所有位置自动获得统一卡片。
+
+**N+1 风险已经被阶段 0 的"全工作区 active-tasks"消除**——hover card 只读 cache，零额外请求。
+
+### 阶段 5 — Chat 状态分阶段（独立 PR）
+
+工作量较大，跟流式渲染相关，单独排期。
+
+#### 改造文件
+
+| 文件 | 改动 |
+|---|---|
+| `packages/views/chat/components/chat-message-list.tsx` | `AssistantMessage` 用 `deriveTaskStage` 替代单 spinner |
+| `packages/views/chat/components/chat-page.tsx` | WS 断线重连后的消息回拉 fallback |
+
+#### 必须解决
+
+- 取代单 spinner，按阶段显示
+- Failed task 显示原因
+- WS 断线重连后能拉回历史消息
+
+#### 加分项
+
+- Typing indicator（generating 阶段的逐字感）
+- 全局任务进度 FAB
+- Stop 按钮的明确反馈
+
+---
+
+## 八、验收标准
+
+### 阶段 0
+
+- [ ] `deriveAgentPresence` / `deriveRuntimeHealth` 单测覆盖所有分支 + 边界 case（runtime null / tasks 空 / 时钟边界）
+- [ ] 控制台调用 `useActiveTasks(wsId)` 能拿到数据
+- [ ] WS 事件接线表里每个事件都能正确 invalidate（手测）
+- [ ] 桌面端关本机 daemon 后 runtime cache 在 1s 内变 offline
+
+### 阶段 1
+
+- [ ] Daemon 关闭后，Agent 列表项 75 秒内变成 Offline 灰点
+- [ ] Agent 跑任务时，列表项变成 Working 蓝点；排队 N 个时带 `+N` 角标
+- [ ] Agent 任务失败后，列表项 2 分钟内显示 Failed 红点 + tooltip 含失败原因，2 分钟后自动恢复
+- [ ] Runtime 列表能区分 Online / Recently Lost / Offline / About to GC 四态
+- [ ] Runtime 列表行展示关联 agent 数 + 当前任务数
+- [ ] 桌面端本机 daemon 卡片视觉跟云端 runtime 列表项一致
+- [ ] 全局 grep `agent.status` 在 views 层无引用
+
+### 阶段 2
+
+- [ ] Agent 详情头部状态跟列表一致
+- [ ] Profile card 状态行 + runtime 行不再自相矛盾
+- [ ] Runtime 详情页能在不展开图表的前提下看到本期成本
+- [ ] Token usage API 按选中的时间窗口拉（不再总是 90 天）
+
+### 阶段 3
+
+- [ ] 同一 issue 多 agent 工作时，每个 agent 一行实时状态
+- [ ] queued / dispatched / running 三态视觉差异清晰
+- [ ] 任务失败时，行内显示中文 failure reason + 处理建议
+- [ ] 不支持 live log 的 provider 显式说明"等任务完成后查看结果"
+
+### 阶段 4
+
+- [ ] 所有展示 agent 头像的位置 hover 都能看到完整状态卡
+- [ ] 渲染 30+ agent 头像的页面，hover 不触发任何新 HTTP 请求
+
+### 阶段 5
+
+- [ ] Chat 中能看到任务在哪个阶段
+- [ ] WS 断线后重连能补齐历史消息
+- [ ] Failed task 显示原因
+
+---
+
+## 九、边界与不做的事
+
+明确**不在本次范围内**：
+
+1. **不改后端 schema**——`agent.status` / `blocked` / `error` 字段保留（迁移风险大，无收益）
+2. **不让后端做派生**——所有派生在前端做（迭代速度 + UI 解耦）
+3. **不新增 WS 事件类型**——只订阅现有但未用的（如 `agent:status`）
+4. **不动 `agent_runtime.status` 的 online/offline 二态**——前端从这两态 + `last_seen_at` 派生四态
+5. **不重构 Skills 界面**——它已经是参考样板
+6. **Phase 5 不做"逐字流式渲染"**——后端 stream-json 是批量推送，typing indicator 是视觉技巧
+7. **不做"agent 健康综合评分"**——只暴露原始信号，不算综合分
+8. **不为 CLI 未安装等场景引入第六态**——归到 offline 的 tooltip 子分类
+9. **不在 Zustand 里存派生结果**——server data 不能复制进 store
+
+---
+
+## 十、风险与注意事项
+
+### 10.1 WS 事件覆盖完整性
+
+派生函数的"实时性"靠的是依赖 query 都被 WS 正确 invalidate。一个事件没接好，状态就会卡住。
+
+**缓解**：阶段 0 的接线表是必须维护的"契约"。每次新增派生维度，回头检查这张表，确保新依赖的字段有事件覆盖。
+
+### 10.2 时钟一致性
+
+Failed 状态依赖客户端时间和 `completed_at` 的差。客户端时钟漂移会让 2 分钟窗口不准。
+
+**缓解**：2 分钟 ± 30 秒不影响判断，可接受。需要时可用 server 在 WS 心跳里携带的时间作为参考。
+
+### 10.3 旧字段引用残留
+
+`statusConfig` 删除后，遗漏的引用会运行时错误。
+
+**缓解**：
+- TypeScript 严格模式 + 改类型
+- 全局 grep 验证
+- 长期防御：在 `packages/core/agents/types.ts` 把 `agent.status` 从外部消费的 Agent 类型里 omit 掉，仅保留在 RawAgent 内部类型里给 API 层用
+
+### 10.4 跨界面状态一致性
+
+不同地方调用同一个 agent 的派生函数，必须结果一致。
+
+**缓解**：所有调用方走 `useAgentPresence(agentId)` 这个唯一 hook，不允许直接调派生函数。Hook 集中管理输入数据收集。
+
+### 10.5 active-tasks 数据量
+
+如果工作区某天有 1000+ 活跃任务，全工作区一次拉的设计会受影响。
+
+**缓解**：
+- 当前活跃任务有天然上限（受 `max_concurrent_tasks` × agent 数量约束）
+- 监控加上：cache 大小超过阈值时上报
+- 必要时再考虑 windowing（最近 N 个）或 server 端聚合
+
+---
+
+## 十一、参考
+
+- [产品全景文档](./product-overview.md) —— Agent / Runtime / Daemon 的产品定位
+- [Skills 界面源代码](../packages/views/skills/) —— 设计语言样板
+- 关键 PR：#1607（Skills 重设计）、#1614（Card + PageHeader）、#1618（描述恢复）、#1610（Dialog 闪烁修复）
+- 后端关键代码：
+  - `server/internal/service/task.go` —— `agent.status` 更新逻辑（`ReconcileAgentStatus`）
+  - `server/cmd/server/runtime_sweeper.go` —— Runtime 心跳 / sweeper 时间常量
+  - `server/migrations/055_task_lease_and_retry.up.sql` —— Task `failure_reason` 五态
+  - `server/migrations/037_fix_pending_task_unique_index.up.sql` —— 一个 issue 多 agent 处理的设计依据
+
+---
+
+## 附录 A：当前现状清单（保留作为重设计前的存档）
+
+> 这部分原本在 design-brief.md 里，迁移过来作为重设计前的现状记录。设计师在画稿前可以贴上当前界面截图作为对照。
+
+### A.1 Agent 字段可见性
+
+| 字段 | 当前状态 | 备注 |
+|---|---|---|
+| `name` / `avatar_url` / `description` | ✅ | 列表 + 详情都展示 |
+| `archived_at` | ✅ | 列表项灰显 + 详情头部 banner |
+| `status`（idle/working/...） | ✅ 但语义错误 | **要替换成派生 5 态** |
+| `runtime_mode`（local/cloud） | ✅ 图标 | 列表项右侧 Cloud / Monitor 图标 |
+| `instructions` | ✅ | Instructions tab |
+| `custom_env` / `custom_env_redacted` | ✅ | Env tab |
+| `custom_args` | ✅ | Custom Args tab |
+| `visibility`（workspace / private） | ✅ | Settings tab |
+| `max_concurrent_tasks` | ✅ | Settings tab |
+| `model` | ✅ | Settings tab |
+| `runtime_id` 关联 | ✅ | Settings tab |
+| `skills` | ✅ | Skills tab + profile card 前 3 个 |
+| `owner_id` | ✅ | Profile card |
+| `created_at` / `updated_at` | 🆕 | 后端有，UI 完全没展示 |
+| `archived_by` | 🆕 | 后端有，UI 隐藏 |
+
+### A.2 Runtime 字段可见性
+
+| 字段 | 当前状态 | 备注 |
+|---|---|---|
+| `name` | ✅ | 列表 + 详情头部 |
+| `provider` | ✅ Logo | 9 种 |
+| `runtime_mode` | ✅ 文字 | `RuntimeModeIcon` 组件存在但从未被调用 |
+| `status`（online/offline） | ✅ 圆点 + 徽章 | 离线圆点浅色主题下几乎不可见 |
+| `last_seen_at` | ✅ 仅详情页 | **列表完全看不到** |
+| `device_info` | ✅ 详情页 | 没有人类可读化 |
+| `daemon_id` | ✅ mono 字体 | 不可复制 |
+| `metadata.cli_version` | ✅ | CLI 更新部分 |
+| `metadata.launched_by` | ✅ | "Managed by Desktop" |
+| `owner_id` | ✅ | 头像 + 名字 |
+| `created_at` / `updated_at` | ✅ | ISO 时间戳 |
+
+### A.3 桌面端 IPC 数据
+
+```
+DaemonStatus (本地 IPC)
+├─ state: running / stopped / starting / stopping / installing_cli / cli_not_found
+├─ pid, uptime
+├─ daemonId, deviceName, serverUrl
+├─ agents: 当前运行的 agent IDs
+├─ workspaceCount
+└─ profile
+```
+
+### A.4 截图占位区
+
+设计师拿到这份文档后，请把以下界面的当前截图贴在对应位置：
+
+- **Agents 界面**：列表页 / 详情页（每 tab 一张）/ 创建对话框
+- **Runtimes 界面**：列表页 / 详情页（含 5 个图表）/ 桌面端 daemon 卡片
+- **Issue Detail**：无任务执行时 / 单 agent 执行中 / 多 agent 并发 / 全屏 transcript dialog
+
+### A.5 Token Usage 5 个图表的数据细节
+
+Runtime 详情页底部 token usage 部分，5 个图表 + 1 张表格全部展开，没有主次。阶段 2 改造时按下表理解每个图表的数据契约：
+
+| 图表 | 数据源 | 时间粒度 | 维度 | 度量 |
+|---|---|---|---|---|
+| **Activity Heatmap** | `getRuntimeUsage?days=90` | 日 | date | 4 级强度，按 token 总量百分位分级 |
+| **Hourly Activity** | `getRuntimeTaskActivity` | 小时（0-23） | hour | 任务数 |
+| **Daily Token Chart** | 同 Heatmap，客户端聚合 | 日 | date | input/output/cacheRead/cacheWrite 总和 |
+| **Daily Cost Chart** | 同上 + 客户端定价计算 | 日 | date | 美元成本，按 model pricing 表 |
+| **Model Distribution** | 同上聚合 by model | 全周期 | model | tokens 占比 + cost |
+
+**当前实现的问题**：API 总是取 90 天数据，客户端做 7d/30d 过滤——浪费服务端资源，首次加载慢。改造时按选中窗口拉。
+
+### A.6 Issue Detail 任务展示的当前实现
+
+主要组件：`packages/views/issues/components/agent-live-card.tsx`
+
+#### 已有能力
+
+- 多 agent 并发执行同一 issue 时，第一个卡片是 sticky（顶部固定），其他在下方滚动
+- 每个 task 卡片可展开 timeline，显示 tool_use / tool_result / thinking / text / error 五种消息类型
+- 实时滚动：WS 事件 `task:message` 到达时追加 timeline
+- 工具调用计数 badge
+- Stop 按钮可取消任务
+- 全屏 transcript dialog（支持事件类型筛选 + 复制）
+- 已完成/失败/取消的任务进入 TaskRunHistory 折叠区
+
+#### 数据来源
+
+| 数据 | API |
+|---|---|
+| 当前 issue 的活跃 task 列表 | `getActiveTasksForIssue(issueId)` |
+| 每个 task 的历史消息 | `listTaskMessages(taskId)` |
+| 实时消息流 | WS `task:message` |
+| 状态变化 | WS `task:dispatch` / `task:completed` / `task:failed` / `task:cancelled` |
+| 取消任务 | `cancelTask(issueId, taskId)` |
+
+阶段 3 在此基础上重构成"每个 agent 一行的全景视图"。

docs/agent-runtime-ui-design-brief.md

@@ -0,0 +1,530 @@
+# Agents & Runtimes 界面重设计 · 设计师 Brief
+
+> **文档定位**：这份文档专门给负责重设计 Agents 和 Runtimes 界面的 UI/UX 设计师。
+>
+> 看完这份文档，你应该能：
+> - 理解我们在解决什么问题、目标体感是什么
+> - 知道每个界面有哪些数据可用、哪些是新展示的、哪些需要工程补
+> - 知道有哪些现有交互不能动（避免破坏用户已建立的习惯）
+> - 知道可以参考哪些已经做完的设计（Skills 是样板）
+> - 直接进入设计稿环节
+>
+> **必读伴侣文档**：[Agent / Runtime 状态系统重设计](./agent-runtime-status-redesign.md) —— 完整的工程方案、状态规范、实施阶段。本 brief 是它的"设计师视角切片"。
+
+---
+
+## 目录
+
+1. [一句话目标](#一一句话目标)
+2. [必读：状态视觉规范](#二必读状态视觉规范)
+3. [Agents 界面](#三agents-界面)
+4. [Runtimes 界面](#四runtimes-界面)
+5. [跨界面统一：Agent Hover Card](#五跨界面统一agent-hover-card)
+6. [跨平台差异处理](#六跨平台差异处理)
+7. [设计语言参考：Skills 界面](#七设计语言参考skills-界面)
+8. [工程会同步交付的能力](#八工程会同步交付的能力)
+9. [设计师产出清单](#九设计师产出清单)
+10. [附录：截图占位区](#十附录截图占位区)
+
+---
+
+## 一、一句话目标
+
+**当前所有界面都在直接展示后端字段，缺少"用户视角"的状态翻译层。**
+
+用户看到 `Idle` / `Online` / spinner，但这些词没有回答"agent 现在能不能用 / 在做什么 / 出问题了没"。我们要做的是一套**用户视角的状态系统**：让用户一眼就知道一个 agent / runtime 的健康状况，跨界面一致。
+
+---
+
+## 二、必读：状态视觉规范
+
+这套规范是所有界面的共同基础。**先输出这套规范，再画具体界面**。
+
+### 2.1 Agent 五态
+
+| 状态 | 颜色 | 用户语义 | 出现条件 |
+|---|---|---|---|
+| **Available** | 🟢 绿 | 在线空闲，可以接活 | runtime 在线 + 没有活跃任务 |
+| **Working** | 🔵 蓝（品牌色） | 正在干活 | runtime 在线 + 至少一个任务在执行 |
+| **Pending** | 🟡 黄 | 任务排着但没在跑 | runtime 在线 + 0 个执行中 + ≥1 个排队 |
+| **Failed** | 🔴 红 | 最近一次失败 | 最近 2 分钟内有任务失败 |
+| **Offline** | ⚫ 灰 | Daemon 离线，不可用 | runtime 离线 |
+
+**复合维度**：当 agent 是 Working 但同时有任务排队，主状态保持 Working，旁边带 `+N` 角标（"还有 N 个排队"）。
+
+**Failed 状态特别说明**：失败显示**保持 2 分钟**，之后自动恢复（避免红点黏太久）。设计上要表达"这是临时强提示"。
+
+### 2.2 Runtime 四态
+
+| 状态 | 触发条件 | 用户语义 |
+|---|---|---|
+| **Online** | 最近 45 秒内有心跳 | 健康 |
+| **Recently Lost** | 离线但 < 5 分钟 | 可能短暂网络抖动 |
+| **Offline** | 离线 5 分钟 ~ 7 天 | 长期离线，需排查 |
+| **About to GC** | 离线接近 7 天阈值 | 系统将自动清理 |
+
+> **关于 CLI 未安装等"runtime 在线但跑不了"的场景**：归并到 Offline，tooltip 写明具体原因（"CLI 未安装"、"Daemon 启动中"）。**不要为这些子情况新设状态色**，色彩枚举太多反而失去信号。
+
+### 2.3 视觉表达分三层
+
+每种状态在以下三个层级要保持一致：
+
+- **Dot**（圆点）：列表项、头像旁的小圆点，最紧凑场景
+- **Badge**（徽章）：详情页头部、卡片角落，带图标 + 文字
+- **Tooltip / Hover Card**：鼠标悬停时展开完整信息
+
+**跨界面一致性**：同一个 agent，无论出现在哪（agents 列表 / issue assignee picker / autopilot 编辑 / chat 选择面板 / 评论 @），状态视觉**必须完全一致**。这是这次设计能立住的关键。
+
+---
+
+## 三、Agents 界面
+
+### 3.1 当前界面长什么样
+
+主要文件：
+- `packages/views/agents/components/agents-page.tsx` — 列表页容器
+- `packages/views/agents/components/agent-list-item.tsx` — 列表项
+- `packages/views/agents/components/agent-detail.tsx` — 详情页（含 tabs：Instructions / Skills / Tasks / Environment / Custom Args / Settings）
+- `packages/views/agents/components/agent-profile-card.tsx` — 详情顶部的 profile 卡片
+- `packages/views/agents/components/create-agent-dialog.tsx` — 创建对话框
+
+**当前的视觉语言跟 Skills 重设计前一样——这次目标是迁到 Skills 风格。**
+
+### 3.2 当前的核心痛点
+
+按用户感知严重度排列：
+
+1. **列表上的 "Idle" 绿点会骗人**——daemon 已经死了，agent 仍然显示 Idle。用户分配任务后没有任何反馈。**根因**：`agent-list-item.tsx` 完全忽略 runtime 在线性，只读 `agent.status` 这个后端字段。
+2. **`agent-profile-card` 状态行和 runtime 行不联动**——状态显 Idle，runtime 显 Offline，自相矛盾。
+3. **跨界面状态展示不一致**——issue assignee picker、autopilot picker、chat 选择 agent 时**完全不显示状态**，用户做选择时不知道哪个能用。
+4. **创建 agent 时无法预知能否立即跑起来**——dialog 显示了 runtime 在线点，但不知道 model 是否合法、初始化会不会失败。
+5. **Archived agent 和 active agent 混在同一列表**——切换视图全靠手动按钮，不够清晰。
+6. **零 WS 订阅**——离线/上线必须手动刷新页面才能感知。
+
+### 3.3 重设计目标
+
+#### 必须达成
+
+- 列表项一眼能看出 agent 是否真的可用（融合 runtime 在线性的派生 5 态）
+- Hover card 内必须看到：派生状态、当前任务数、runtime 健康、最近失败原因
+- 跨界面一致：所有显示 agent 头像的位置都用同一个 hover card（详见第 5 节）
+- 创建/编辑 agent 时，能预看"如果保存，agent 会变成什么状态"
+- 实时更新——状态变化 75 秒内反映到 UI
+
+#### 加分项
+
+- Archived agent 独立 tab/折叠区，不再和 active 混在一起
+- 列表支持按"最近活动时间"排序
+- 支持按状态筛选（"显示所有 Failed"、"显示所有 Pending"）
+
+### 3.4 可用数据清单（设计稿可以放心假设可用）
+
+> **图例**：✅ = 当前已展示；🆕 = 已可用但当前 UI 没用；🔧 = 工程会在阶段 0 补上；📡 = 实时事件可用
+
+#### Agent 主体字段（来自 `Agent` type）
+
+| 字段 | 类型 | 当前状态 | 说明 |
+|---|---|---|---|
+| `name` / `avatar_url` / `description` | string | ✅ | 已展示 |
+| `archived_at` / `archived_by` | string | ✅ / 🆕 | 列表灰显；archived_by 后端有但 UI 隐藏 |
+| `runtime_mode` | "local" / "cloud" | ✅ 图标 | Cloud / Monitor 图标区分 |
+| `instructions` | string | ✅ | Instructions tab |
+| `custom_env` / `custom_env_redacted` | KV / bool | ✅ | Env tab，权限控制隐藏值 |
+| `custom_args` | string[] | ✅ | Custom Args tab |
+| `visibility` | "workspace" / "private" | ✅ | Settings tab |
+| `max_concurrent_tasks` | number | ✅ | Settings tab，默认 6 |
+| `model` | string | ✅ | Settings tab |
+| `runtime_id` | string | ✅ 选择器 | Settings tab |
+| `skills` | Skill[] | ✅ | Skills tab + profile card 前 3 个 |
+| `owner_id` | string | ✅ | Profile card 显示名字 |
+| `created_at` / `updated_at` | string | 🆕 | **后端有，UI 完全没展示** —— 可以做"最近创建"、"最近修改"标签 |
+| ~~`status`~~（idle/working/blocked/error/offline） | enum | ✅ 但**已废弃**展示 | 后端字段保留但 UI 完全不读 |
+
+#### 派生数据（工程在阶段 0 提供，设计稿可放心引用）
+
+| 派生信息 | 来源 |
+|---|---|
+| **Agent 派生 5 态状态** | 🔧 由 agent + runtime + active tasks 派生 |
+| **当前 running 任务数** | 🔧 派生 |
+| **当前 queued 任务数** | 🔧 派生 |
+| **最近一次失败的原因**（5 种 enum） | 🔧 派生 |
+| **关联 runtime 健康状态** | 🔧 派生 |
+| **runtime last_seen 相对时间** | 🔧 已有工具函数 |
+
+**失败原因 5 个枚举（中文文案待你定）**：
+- `agent_error` — Agent 执行报错
+- `timeout` — 执行超时
+- `runtime_offline` — Daemon 离线
+- `runtime_recovery` — Daemon 重启回收
+- `manual` — 用户取消
+
+每种原因用户的处理方式不同，UI 应给出对应建议（你来设计文案）。
+
+#### 实时事件（WS）
+
+| 事件 | 状态 | 用途 |
+|---|---|---|
+| `agent:status` | 📡 后端发，工程接 | agent 字段变化 |
+| `agent:created` / `agent:archived` / `agent:restored` | 📡 工程接 | 列表增删 |
+| `task:dispatch` / `task:completed` / `task:failed` / `task:cancelled` | 📡 工程接 | 状态派生关键信号 |
+| `daemon:register` | 📡 工程接 | runtime 上下线 |
+
+设计上**不需要为"加载/loading"过度设计**——状态变化是实时的，几乎不会出现"等数据"的 loading 态。
+
+### 3.5 不能动的现有交互（必须保留）
+
+- 创建 agent dialog 的 chooser → 表单两步流（见 Skills 的 `create-skill-dialog`）
+- 各 tab 的编辑能力：Instructions / Env / Custom Args / Settings 全部可编辑
+- Archive / Restore 操作
+- Tasks tab：展示该 agent 的历史 task 列表（按状态分组：活跃 → 完成）
+- Skills tab：可挂载/卸载 skills
+
+### 3.6 关键问题留给你定的
+
+1. **Archived agent 怎么收纳**：独立 tab、折叠区、还是 segment 切换？
+2. **状态筛选**是 chips 还是 dropdown？
+3. **Failed 红点的 2 分钟动效**：脉冲？颜色渐变？
+4. **复合状态（Working + 排队 N）**：角标位置（dot 旁 / 头像下角 / Badge 内嵌）？
+5. **创建 dialog 的"预览状态"**：怎么不打扰主流程的同时让用户知道"这个 agent 创建出来会是什么色"？
+
+---
+
+## 四、Runtimes 界面
+
+### 4.1 当前界面长什么样
+
+主要文件：
+- `packages/views/runtimes/components/runtimes-page.tsx` — 容器，含 owner filter（mine/all）
+- `packages/views/runtimes/components/runtime-list.tsx` — 列表
+- `packages/views/runtimes/components/runtime-detail.tsx` — 详情头部
+- `packages/views/runtimes/components/usage-section.tsx` — Token usage 主区
+- `packages/views/runtimes/components/charts/` — 5 个图表组件
+- `packages/views/runtimes/components/update-section.tsx` — CLI 更新流程
+- `apps/desktop/src/renderer/src/components/daemon-runtime-card.tsx` — 桌面端独有：本机 daemon 卡片（通过 IPC，独立于 server runtime 列表）
+
+### 4.2 当前的核心痛点
+
+按严重度排列：
+
+1. **离线圆点几乎不可见**——浅色主题下 `bg-muted-foreground/40` 视觉上消失。
+2. **列表无 last_seen**——无法区分"刚断线 5 分钟"和"3 个月前断线"。
+3. **看不到 runtime 服务了哪些 agent / 当前有几个 task 在跑**——runtime 在用户心智里成了"孤岛"。
+4. **7 天 GC 阈值无任何 UI 提示**——runtime 突然消失，用户不知道为什么。
+5. **桌面端 daemon 卡片和云端 runtime 卡片视觉分裂**——同一台机器同一概念，两套设计。
+6. **Token usage 信息过载**——5 个图表 + 1 张表全部展开，普通用户找不到"本月花了多少钱"。
+7. **无 ping / 诊断按钮**——遇到断线没法主动验证。
+8. **`RuntimeModeIcon` 死代码**——本地 vs 云端在列表项里没有图标区分。
+
+### 4.3 重设计目标
+
+#### 必须达成
+
+- 列表项一眼区分四态：Online / Recently Lost / Offline / About to GC
+- 列表项展示**关联 agent 数量** + **当前任务数**（runtime 不再是孤岛）
+- 桌面端 daemon 卡片和云端 runtime 卡片用统一视觉语言
+- Token usage 区分主次：核心指标（本期成本、token 总量）放顶部，详细图表折叠或下沉
+
+#### 加分项
+
+- Runtime 健康综合评分（在线 + 心跳新鲜度 + 任务负载）
+- 7 天 GC 倒计时提示
+- Ping / 诊断按钮
+- 高使用量 runtime 的视觉强调（成本警告、利用率热图 sparkline）
+- Local vs Cloud 图标区分（启用废弃组件 `RuntimeModeIcon`）
+
+### 4.4 可用数据清单
+
+#### Runtime 主体字段（来自 `RuntimeDevice` type）
+
+| 字段 | 类型 | 当前状态 | 说明 |
+|---|---|---|---|
+| `name` | string | ✅ | 列表 + 详情头部 |
+| `provider` | string | ✅ Logo | 9 种：claude / codex / opencode / openclaw / hermes / gemini / pi / cursor 等 |
+| `runtime_mode` | "local" / "cloud" | ✅ 文字 | 列表项里没图标（死代码） |
+| `status` | "online" / "offline" | ✅ 圆点 | 浅色主题下离线几乎不可见 |
+| `last_seen_at` | string | ✅ 仅详情页 | **列表完全看不到** |
+| `device_info` | string | ✅ 详情页 | 显示原始字符串如 `darwin-arm64`，无人类可读化 |
+| `daemon_id` | string | ✅ mono 字体 | 不可复制 / 不可点击 |
+| `metadata.cli_version` | string | ✅ | CLI 更新部分用 |
+| `metadata.launched_by` | string | ✅ | 桌面端启动时显示 "Managed by Desktop" |
+| `owner_id` | string | ✅ | 头像 + 名字 |
+| `created_at` / `updated_at` | string | ✅ | 详情页底部 ISO 时间戳 |
+
+#### 派生数据（工程阶段 0 提供）
+
+| 派生信息 | 来源 |
+|---|---|
+| **Runtime 4 态健康** | 🔧 由 status + last_seen_at 派生 |
+| **服务的 agent 列表 + 数量** | 🔧 前端 join（agent 持有 runtime_id，列表数据已在 cache） |
+| **当前在跑 task 数** | 🔧 前端 filter active-tasks |
+| **last_seen 相对时间字符串**（"5 minutes ago"） | 🔧 工具函数已有 |
+
+#### Token Usage 5 个图表的数据契约
+
+| 图表 | 数据源 | 时间粒度 | 维度 | 度量 |
+|---|---|---|---|---|
+| **Activity Heatmap** | `getRuntimeUsage?days=90` | 日 | date | 4 级强度，按 token 总量百分位分级 |
+| **Hourly Activity** | `getRuntimeTaskActivity` | 小时（0-23） | hour | 任务数 |
+| **Daily Token Chart** | 同 Heatmap，客户端聚合 | 日 | date | input/output/cacheRead/cacheWrite 总和 |
+| **Daily Cost Chart** | 同上 + 客户端定价 | 日 | date | 美元成本 |
+| **Model Distribution** | 同上聚合 by model | 全周期 | model | tokens 占比 + cost |
+
+**当前实现的问题**：API 总是取 90 天数据，客户端做 7d/30d 过滤——浪费服务端资源。改造时按选中窗口拉。
+
+#### 实时事件
+
+| 事件 | 状态 |
+|---|---|
+| `daemon:register` | 📡 已订阅，触发列表刷新 |
+| `daemon:heartbeat` | 📡 后端发但前端**故意忽略**（防过度刷新）。设计时假设状态变化最坏 75 秒内可见 |
+
+#### 桌面端独有的本机 IPC 数据（仅桌面端可见）
+
+```
+DaemonStatus (本机 IPC，亚秒级实时)
+├─ state: running / stopped / starting / stopping / installing_cli / cli_not_found
+├─ pid, uptime, daemonId, deviceName, serverUrl
+├─ agents: 当前运行的 agent IDs
+├─ workspaceCount
+└─ profile
+```
+
+工程会把这份数据自动喂进 cache，**设计上不要为"桌面端有更多数据"做特殊视觉**——派生状态对设计师而言是统一的，只是桌面端响应更快。但桌面端**对自己的本机 daemon 有更多操作能力**（见第 6 节）。
+
+### 4.5 不能动的现有交互（必须保留）
+
+- Owner filter（mine/all toggle）
+- Delete runtime 操作（含权限检查）
+- CLI 更新流程（`update-section.tsx`）：检查更新、触发更新、查看更新状态
+- 5 个图表的数据展示（信息架构可以重排，但数据本身要保留）
+- 桌面端：start/stop/restart 本机 daemon 的按钮
+
+### 4.6 关键问题留给你定的
+
+1. **列表项到底放多少信息**：last_seen + agent count + active tasks 放哪？避免拥挤
+2. **桌面端 daemon 卡片和云端 runtime 卡片"视觉对齐"的尺度**：100% 同模板？还是同卡片框 + 内容差异化？
+3. **Token usage 主次怎么排**：本期成本数字 + 单图表 + "查看更多" 折叠？或者 dashboard 化？
+4. **About to GC 怎么提示**：横幅？badge？倒计时？
+5. **Ping / 诊断按钮的位置**：详情页头部？右上角菜单？
+6. **关联 agent 列表展示**：堆叠头像？文字 "3 agents"？还是子区块？
+
+---
+
+## 五、跨界面统一：Agent Hover Card
+
+### 5.1 现有组件
+
+`packages/views/agents/components/agent-profile-card.tsx`——已经存在，但只在 Agents 主页 hover 时出现。
+
+这次会把它升级成**统一 hover card**，挂到所有展示 agent 头像的地方。
+
+### 5.2 必须出现的位置
+
+| 位置 | 当前状态 |
+|---|---|
+| Agents 列表 / 详情 | ✅ 已有 |
+| Issue Assignee Picker | ❌ 仅头像无状态 |
+| Issue Detail 头部 assignee | ❌ 仅头像无状态 |
+| Issue 列表 / 看板的分配头像 | ❌ 仅头像 |
+| Autopilot 列表 / 编辑（assignee） | ❌ 仅头像 |
+| Project lead picker | ❌ 仅头像 |
+| Chat 选择 agent 面板 | ❌ 待确认 |
+| 评论里的 @agent | ❌ 仅头像 |
+
+### 5.3 卡片必须显示什么（按重要度）
+
+1. **派生 5 态状态**（不是 `agent.status` 原始值）
+2. **Runtime 健康**：在线性 + last_seen 相对时间
+3. **当前任务**：N running / M queued
+4. **最近失败**（如果有）：原因 + 时间
+5. **Agent 名称 + description**
+6. **关联 skills**（前 3 个 + `+N`）
+7. **Owner**
+
+### 5.4 设计要点
+
+- 卡片宽度跨多种使用场景要适配（issue 列表很窄、设置页很宽）
+- 触发延迟（hover delay）跟 Skills 已有的卡片保持一致
+- 暗色主题下信息层级要清晰
+
+---
+
+## 六、跨平台差异处理
+
+### 6.1 状态视觉是平台无关的
+
+派生 5 态 / 4 态、视觉规范、hover card——**两端共享同一套设计**。设计稿只画一份。
+
+### 6.2 数据响应速度差异（不影响视觉）
+
+| 平台 | Runtime 状态变化感知延迟 |
+|---|---|
+| Web | 最坏 75 秒 |
+| Desktop（看自己机器） | < 1 秒（IPC） |
+| Desktop（看别人机器） | 最坏 75 秒（跟 Web 一样） |
+
+设计上不需要透出"快慢"——用户感知不到这是 IPC 还是 server。
+
+### 6.3 操作能力差异（影响按钮可见性）
+
+| 操作 | Web | Desktop（自己机器） | Desktop（别人机器） |
+|---|---|---|---|
+| 看状态 | ✅ | ✅ | ✅ |
+| 重启 daemon | ❌ | ✅ | ❌ |
+| 看 daemon logs | ❌ | ✅ | ❌ |
+| 看 CLI 安装详情 | ❌ | ✅ | ❌ |
+
+**设计要点**：操作按钮在不该有权限的位置应该**直接隐藏**，不要灰显（避免视觉噪音）。
+
+### 6.4 桌面端独有的"本机 daemon 卡片"
+
+当前桌面端有一个独立卡片显示本机 daemon。重设计后：
+- 视觉上跟云端 runtime 列表项**用同一套视觉语言**
+- 但承载更多本地操作（重启、看日志、安装 CLI、profile 切换）
+- 位置：列表顶部 sticky / 列表头部突出 / 右侧独立 panel —— 由你定
+
+---
+
+## 七、设计语言参考：Skills 界面
+
+### 7.1 Skills 是这次重设计的视觉锚点
+
+Skills 界面已经在 2026-04 完成重设计（PR #1607、#1614、#1618、#1610）。这次 Agents 和 Runtimes **直接照搬 Skills 的视觉语言**，保持产品体感一致。
+
+参考目录：`packages/views/skills/`
+
+### 7.2 必须复用的 10 条规则
+
+1. **统一页头** `PageHeader`（h-12 + mobile sidebar trigger）
+2. **响应式网格列表**：`grid-cols-[minmax(0,1.6fr)_minmax(0,0.8fr)_minmax(0,1.2fr)_minmax(0,6rem)_auto]`，不用 flexbox
+3. **每行三层信息**：主标题（font-medium）→ 描述（line-clamp-1 muted）→ 元数据（xs muted）
+4. **关联对象用头像堆栈**：最多 3 + `+N`，size=22 + `ring-2 ring-background` + `-space-x-1.5`
+5. **卡片化列表 + 卡片内工具栏**：搜索和 scope tab 在 `CardToolbar`（h-12），不在页面级
+6. **创建用多步 dialog**：chooser → 表单可回退；Dialog 宽度按方法切换（manual/url 用 `!max-w-md`，runtime 用 `!max-w-2xl`），300ms 平滑过渡
+7. **空状态 / 筛选无结果分别有详细文案**：图标 + 标题 + 三行说明 + 清晰 CTA
+8. **长列表加 `useScrollFade`**：滚动容器上下边缘淡出
+9. **头像统一用 `ActorAvatar`**：传 `size`，自动支持 agent / 人员
+10. **权限检查 hook 化**：`useCanEdit...`，UI 提前隐藏/禁用操作按钮
+
+---
+
+## 八、工程会同步交付的能力
+
+阶段 0（数据层地基）完成后，**设计稿可以放心假设以下能力都到位**：
+
+- 任意位置都能拿到一个 agent 的派生 5 态状态
+- 任意位置都能拿到 agent 的当前任务数（running / queued）
+- 任意位置都能拿到 agent 关联的 runtime 4 态健康
+- 任意位置都能拿到 runtime 服务的 agent 列表 + 数量
+- 任意位置都能拿到 runtime 当前任务数
+- 状态变化是实时的（订阅 WS 事件后会自动更新）
+- 桌面端会自动获得"亚秒级"响应——不需要为此画两套稿
+
+### 已有 API（不需要新加，可放心引用）
+
+- `listAgents` / `getAgent` / `createAgent` / `updateAgent` / `archiveAgent` / `restoreAgent`
+- `listAgentTasks(agentId)` — 单 agent 历史任务
+- `listRuntimes` / `deleteRuntime`
+- `getRuntimeUsage(runtimeId, { days })` — token 用量
+- `getRuntimeTaskActivity(runtimeId)` — 小时级活动
+
+### 工程要在阶段 0 补的（设计稿可以假设有，但要知道这是新增）
+
+- **后端**：`GET /api/workspaces/:slug/active-tasks` — 全工作区活跃任务一次拉
+- **后端**：诊断 / Ping API（如果你的设计稿用到，工程要评估优先级）
+- **前端类型**：`AgentTask.failure_reason` 字段（5 枚举：agent_error / timeout / runtime_offline / runtime_recovery / manual）暴露到前端类型
+- **前端**：派生函数（`deriveAgentPresence` / `deriveRuntimeHealth`）+ 全工作区 active-tasks query + WS 接线
+
+### 工程不会做的（设计稿不要假设有）
+
+- 不引入"agent 健康综合评分"——只暴露原始信号
+- 不做"从历史 task 自动推断 agent 类型"等 AI 派生
+- 不为 runtime 引入新状态色（稳定在 4 态）
+- 不做后端聚合 API（除了 active-tasks 这个补全）
+
+---
+
+## 九、设计师产出清单
+
+按优先级排列，**P0 必须先于 P1**。
+
+### P0 — 状态视觉规范（基础，所有界面共用）
+
+- 5 态颜色 token（Available / Working / Pending / Failed / Offline）
+- 4 态颜色 token（Online / Recently Lost / Offline / About to GC）
+- Dot / Badge / Tooltip 三层视觉规范
+- 复合维度（Working + 排队角标）的视觉表达
+- Failed 状态的 2 分钟时间窗口动效（强提示 + 自动消失）
+
+### P0 — Agents 界面
+
+- 列表页（含派生状态、关联 runtime 健康、最近活动时间）
+- 详情页头部 + Profile Card（状态行联动）
+- 创建对话框（保留两步流，加入 runtime 在线状态预览）
+
+### P0 — Runtimes 界面
+
+- 列表页（暴露 last_seen、关联 agents、当前 task 数）
+- 详情页头部（4 态 badge、device info 人类可读化）
+- Token usage 信息架构重整：核心指标置顶，详细图表下沉/折叠
+
+### P1 — Hover Card 跨界面统一
+
+- 一个适配多场景宽度的卡片设计
+- 7 项内容的信息层级
+- hover 触发交互（与 Skills 一致）
+
+### P1 — 桌面端本机 daemon 卡片
+
+- 视觉对齐云端 runtime 卡片
+- 本机操作按钮（重启 / 日志 / CLI 安装）的位置
+- Profile 切换（如果做多 profile）
+
+### P2 — 加分项
+
+- Runtime 健康综合评分（视觉化）
+- 7 天 GC 倒计时
+- 高使用量 runtime 的成本警告
+- Local vs Cloud 图标区分
+- Agent archived 独立 tab/折叠区
+- 列表按"最近活动"排序、按状态筛选
+
+---
+
+## 十、附录：截图占位区
+
+> 设计师拿到这份文档后，请把以下三个界面的当前截图贴在对应位置，作为重设计前的现状记录，方便对比。
+
+### 10.1 Agents 界面
+
+- 列表页截图：__待贴__
+- 详情页截图（每个 tab 一张：Instructions / Skills / Tasks / Environment / Custom Args / Settings）：__待贴__
+- Profile Card 截图：__待贴__
+- 创建对话框截图（chooser + form 两步）：__待贴__
+- Hover card 当前样式截图：__待贴__
+
+### 10.2 Runtimes 界面
+
+- 列表页截图（mine / all 两态）：__待贴__
+- 详情页截图（含 5 个图表全部展开）：__待贴__
+- 桌面端 daemon 卡片截图：__待贴__
+- CLI 更新流程截图：__待贴__
+
+### 10.3 跨界面 agent 头像出现的位置
+
+- Issue Assignee Picker：__待贴__
+- Issue Detail 头部 assignee：__待贴__
+- Issue 列表 / 看板：__待贴__
+- Autopilot 列表 / 编辑：__待贴__
+- Project lead picker：__待贴__
+- Chat agent 选择面板：__待贴__
+- 评论 @agent：__待贴__
+
+---
+
+## 参考文档
+
+- [Agent / Runtime 状态系统重设计（主文档）](./agent-runtime-status-redesign.md) — 完整工程方案、状态规范、实施阶段
+- [产品全景文档](./product-overview.md) — 理解 agent / runtime / daemon 在整个产品里的位置
+- [Skills 界面源代码](../packages/views/skills/) — 直接参考的设计语言样板
+- 相关 PR：#1607（Skills 重设计）、#1614（Card + PageHeader）、#1618（描述恢复）、#1610（Dialog 闪烁修复）

docs/product-overview.md

@@ -372,7 +372,7 @@ skill
 3. **注入**：当 agent 认领任务时，daemon 把挂载的 skill 内容写到任务工作目录的 **provider 原生位置**：
    - Claude Code → `.claude/skills/{name}/SKILL.md`
    - Codex → `CODEX_HOME/skills/{name}/`
-   - OpenCode → `.opencode/skills/{name}/SKILL.md`
+   - OpenCode → `.config/opencode/skills/{name}/SKILL.md`
    - Pi → `.pi/skills/{name}/SKILL.md`
    - Cursor → `.cursor/skills/{name}/SKILL.md`
    - GitHub Copilot → `.github/skills/{name}/SKILL.md`

packages/core/agents/constants.ts

@@ -1,4 +0,0 @@
-// User-facing limits enforced symmetrically on the front-end (UI counter +
-// disabled save) and the back-end (handler validation + DB CHECK constraint).
-// Kept in core so both apps and the test suite read from one source.
-export const AGENT_DESCRIPTION_MAX_LENGTH = 255;

packages/core/agents/derive-presence.test.ts

@@ -1,11 +1,10 @@
 import { describe, expect, it } from "vitest";
-import type { Agent, AgentRuntime, AgentTask } from "../types";
+import type { Agent, AgentRuntime, AgentTask, TaskFailureReason } from "../types";
 import {
   buildPresenceMap,
   deriveAgentAvailability,
   deriveAgentPresenceDetail,
-  deriveWorkload,
-  deriveWorkloadDetail,
+  deriveLastTaskState,
 } from "./derive-presence";
 
 function makeAgent(overrides: Partial<Agent> = {}): Agent {
@@ -81,7 +80,8 @@ function makeTask(overrides: Partial<AgentTask> = {}): AgentTask {
 
 describe("deriveAgentAvailability", () => {
   // Reachability dimension only — runtime + clock decide it; tasks are
-  // irrelevant to this axis.
+  // irrelevant. The whole point of splitting from LastTaskState is that
+  // these tests can ignore task fixtures entirely.
 
   it("returns online when runtime is fresh-online", () => {
     expect(deriveAgentAvailability(makeRuntime(), NOW)).toBe("online");
@@ -120,111 +120,128 @@ describe("deriveAgentAvailability", () => {
   });
 });
 
-describe("deriveWorkload", () => {
-  // Atomic 3-way classifier — used by both Agent (per-agent task counts)
-  // and Runtime (per-runtime aggregated counts). Pure functional mapping
-  // from a count pair to a workload label.
-
-  it("returns working when runningCount > 0", () => {
-    expect(deriveWorkload({ runningCount: 1, queuedCount: 0 })).toBe("working");
-    expect(deriveWorkload({ runningCount: 3, queuedCount: 5 })).toBe("working");
-  });
-
-  it("returns queued when nothing running but queuedCount > 0", () => {
-    expect(deriveWorkload({ runningCount: 0, queuedCount: 1 })).toBe("queued");
-    expect(deriveWorkload({ runningCount: 0, queuedCount: 5 })).toBe("queued");
-  });
-
-  it("returns idle when both counts are zero", () => {
-    expect(deriveWorkload({ runningCount: 0, queuedCount: 0 })).toBe("idle");
-  });
-});
-
-describe("deriveWorkloadDetail", () => {
-  // Aggregates a task list into running/queued counts before classifying.
-  // Terminal statuses (completed / failed / cancelled) are silently
-  // ignored — workload is "what's on the plate right now", not history.
+describe("deriveLastTaskState", () => {
+  // Task dimension only — runtime status is not consulted.
 
   it("returns idle when no tasks at all", () => {
-    const r = deriveWorkloadDetail([]);
-    expect(r.workload).toBe("idle");
+    const r = deriveLastTaskState([]);
+    expect(r.state).toBe("idle");
     expect(r.runningCount).toBe(0);
     expect(r.queuedCount).toBe(0);
   });
 
-  it("returns working when at least one task is running", () => {
-    const r = deriveWorkloadDetail([makeTask({ status: "running" })]);
-    expect(r.workload).toBe("working");
+  it("returns running when at least one task is running", () => {
+    const r = deriveLastTaskState([makeTask({ status: "running" })]);
+    expect(r.state).toBe("running");
     expect(r.runningCount).toBe(1);
-    expect(r.queuedCount).toBe(0);
   });
 
-  it("returns queued when only queued / dispatched tasks exist (no running)", () => {
-    // The "stuck on offline runtime" scenario in isolation: runningCount=0,
-    // queuedCount>0 surfaces as `queued` so the UI can honestly say
-    // "Queued · N" instead of misleading "Running 0/3 +Nq".
-    const r = deriveWorkloadDetail([
+  it("returns running when only queued / dispatched tasks exist (no running yet)", () => {
+    const r = deriveLastTaskState([
       makeTask({ status: "queued" }),
       makeTask({ id: "t2", status: "dispatched" }),
     ]);
-    expect(r.workload).toBe("queued");
+    expect(r.state).toBe("running");
     expect(r.runningCount).toBe(0);
     expect(r.queuedCount).toBe(2);
   });
 
-  it("returns working when running coexists with queued (overflow)", () => {
-    // Capacity-saturated agent: still running, but with a queue building.
-    // The chip says "Working" with the queue expressed as a `+Nq` badge.
-    const r = deriveWorkloadDetail([
-      makeTask({ id: "t1", status: "running" }),
-      makeTask({ id: "t2", status: "queued" }),
-      makeTask({ id: "t3", status: "queued" }),
+  it("returns running even when an older terminal exists (active wins over historical)", () => {
+    const r = deriveLastTaskState([
+      makeTask({
+        id: "old-failed",
+        status: "failed",
+        completed_at: "2026-04-27T10:00:00Z",
+      }),
+      makeTask({ id: "new-running", status: "running" }),
     ]);
-    expect(r.workload).toBe("working");
-    expect(r.runningCount).toBe(1);
-    expect(r.queuedCount).toBe(2);
+    expect(r.state).toBe("running");
   });
 
-  it("ignores terminal statuses entirely (no historical state in workload)", () => {
-    // Failed / completed / cancelled tasks contribute no count and don't
-    // change the verdict — Recent Work + Inbox handle history, not workload.
-    const r = deriveWorkloadDetail([
+  it("returns the latest terminal state when no tasks are active (latest = failed)", () => {
+    const r = deriveLastTaskState([
       makeTask({
-        id: "t-failed",
+        id: "old",
+        status: "completed",
+        completed_at: "2026-04-27T10:00:00Z",
+      }),
+      makeTask({
+        id: "new",
         status: "failed",
         completed_at: "2026-04-27T11:30:00Z",
       }),
-      makeTask({
-        id: "t-completed",
-        status: "completed",
-        completed_at: "2026-04-27T11:00:00Z",
-      }),
-      makeTask({
-        id: "t-cancelled",
-        status: "cancelled",
-        completed_at: "2026-04-27T10:30:00Z",
-      }),
     ]);
-    expect(r.workload).toBe("idle");
-    expect(r.runningCount).toBe(0);
-    expect(r.queuedCount).toBe(0);
+    expect(r.state).toBe("failed");
+    expect(r.lastTaskCompletedAt).toBe("2026-04-27T11:30:00Z");
   });
 
-  it("classifies running over queued when both present, regardless of order", () => {
-    const r = deriveWorkloadDetail([
-      makeTask({ id: "t1", status: "queued" }),
-      makeTask({ id: "t2", status: "running" }),
+  it("returns the latest terminal state when no tasks are active (latest = completed)", () => {
+    const r = deriveLastTaskState([
+      makeTask({
+        id: "old",
+        status: "failed",
+        completed_at: "2026-04-27T10:00:00Z",
+      }),
+      makeTask({
+        id: "new",
+        status: "completed",
+        completed_at: "2026-04-27T11:30:00Z",
+      }),
     ]);
-    expect(r.workload).toBe("working");
+    expect(r.state).toBe("completed");
+  });
+
+  it("surfaces failure_reason on a failed latest terminal", () => {
+    const reason: TaskFailureReason = "runtime_offline";
+    const r = deriveLastTaskState([
+      makeTask({
+        status: "failed",
+        completed_at: "2026-04-27T11:30:00Z",
+        failure_reason: reason,
+      }),
+    ]);
+    expect(r.state).toBe("failed");
+    expect(r.failureReason).toBe(reason);
+  });
+
+  it("leaves failureReason undefined when the failed terminal has empty failure_reason", () => {
+    const r = deriveLastTaskState([
+      makeTask({
+        status: "failed",
+        completed_at: "2026-04-27T11:30:00Z",
+        failure_reason: "",
+      }),
+    ]);
+    expect(r.state).toBe("failed");
+    expect(r.failureReason).toBeUndefined();
+  });
+
+  it("returns cancelled when the latest terminal is cancelled", () => {
+    // Under the new model cancelled is a real state — the dot is
+    // availability-driven so honestly surfacing it doesn't lie.
+    const r = deriveLastTaskState([
+      makeTask({
+        status: "cancelled",
+        completed_at: "2026-04-27T11:30:00Z",
+      }),
+    ]);
+    expect(r.state).toBe("cancelled");
+  });
+
+  it("ignores terminals without completed_at (treated as not-terminal)", () => {
+    // Defensive: a malformed row (no completed_at) shouldn't derail the
+    // latest-terminal scan. With nothing else in flight, idle.
+    const r = deriveLastTaskState([makeTask({ status: "failed", completed_at: null })]);
+    expect(r.state).toBe("idle");
   });
 });
 
 describe("deriveAgentPresenceDetail", () => {
   // Composition: the two dimensions are derived independently and the
-  // detail object exposes both. No cross-axis override — workload never
-  // colours the dot, availability never overrides workload.
+  // detail object exposes both. No cross-axis override (the old "unstable
+  // overrides failed" rule is gone — they coexist now).
 
-  it("composes online + working for the common busy case", () => {
+  it("composes online + running for the common busy case", () => {
     const detail = deriveAgentPresenceDetail({
       agent: makeAgent(),
       runtime: makeRuntime(),
@@ -235,53 +252,53 @@ describe("deriveAgentPresenceDetail", () => {
       now: NOW,
     });
     expect(detail.availability).toBe("online");
-    expect(detail.workload).toBe("working");
+    expect(detail.lastTask).toBe("running");
     expect(detail.runningCount).toBe(1);
     expect(detail.queuedCount).toBe(1);
     expect(detail.capacity).toBe(6);
   });
 
-  it("composes offline + queued — the canonical 'stuck' case (was previously misleading 'running 0/N')", () => {
-    // The motivation for the redesign: runtime offline + queued tasks
-    // used to surface as `running` with `0/3 +2q` counts (literally false).
-    // Workload now returns `queued` honestly, paired with offline
-    // availability — UI reads "Offline · Queued · 2".
+  it("composes online + failed — agent is reachable but last task failed (no longer sticky red dot)", () => {
+    // The whole motivation for the split: this combination was previously
+    // collapsed to a single red "failed" state, hiding the fact that the
+    // runtime is fine. Now the two dimensions are visible separately.
     const detail = deriveAgentPresenceDetail({
       agent: makeAgent(),
-      runtime: makeRuntime({
-        status: "offline",
-        last_seen_at: "2026-04-27T11:50:00Z",
-      }),
+      runtime: makeRuntime(),
       tasks: [
-        makeTask({ status: "queued" }),
-        makeTask({ id: "t2", status: "queued" }),
+        makeTask({
+          status: "failed",
+          completed_at: "2026-04-27T11:30:00Z",
+          failure_reason: "agent_error",
+        }),
       ],
       now: NOW,
     });
-    expect(detail.availability).toBe("offline");
-    expect(detail.workload).toBe("queued");
-    expect(detail.runningCount).toBe(0);
-    expect(detail.queuedCount).toBe(2);
+    expect(detail.availability).toBe("online");
+    expect(detail.lastTask).toBe("failed");
+    expect(detail.failureReason).toBe("agent_error");
+    expect(detail.lastTaskCompletedAt).toBe("2026-04-27T11:30:00Z");
   });
 
-  it("composes unstable + working — runtime hiccup with tasks still in flight", () => {
-    // Recently-lost runtime, but a task is still recorded as running.
-    // Both signals surface independently — amber dot AND working chip —
-    // so the user sees "connection wobbling" alongside "agent is busy".
+  it("composes unstable + running — runtime hiccup with queued tasks still in flight", () => {
+    // Previously "unstable" overrode "working"; now both signals are
+    // surfaced. The UI shows amber dot AND running chip — user sees both
+    // "connection issue" and "queue is paused".
     const detail = deriveAgentPresenceDetail({
       agent: makeAgent(),
       runtime: makeRuntime({
         status: "offline",
         last_seen_at: "2026-04-27T11:59:00Z",
       }),
-      tasks: [makeTask({ status: "running" })],
+      tasks: [makeTask({ status: "queued" })],
       now: NOW,
     });
     expect(detail.availability).toBe("unstable");
-    expect(detail.workload).toBe("working");
+    expect(detail.lastTask).toBe("running");
+    expect(detail.queuedCount).toBe(1);
   });
 
-  it("composes offline + idle for an unreachable agent with no tasks pending", () => {
+  it("composes offline + idle for a brand-new agent on a dead runtime", () => {
     const detail = deriveAgentPresenceDetail({
       agent: makeAgent(),
       runtime: makeRuntime({
@@ -292,34 +309,34 @@ describe("deriveAgentPresenceDetail", () => {
       now: NOW,
     });
     expect(detail.availability).toBe("offline");
-    expect(detail.workload).toBe("idle");
+    expect(detail.lastTask).toBe("idle");
   });
 
-  it("handles a missing runtime by reporting offline + the task-driven workload", () => {
+  it("handles a missing runtime by reporting offline + the task-driven last state", () => {
     const detail = deriveAgentPresenceDetail({
       agent: makeAgent(),
       runtime: null,
-      tasks: [makeTask({ status: "running" })],
-      now: NOW,
-    });
-    expect(detail.availability).toBe("offline");
-    expect(detail.workload).toBe("working");
-  });
-
-  it("returns idle workload when only terminal tasks are present (history doesn't bleed in)", () => {
-    const detail = deriveAgentPresenceDetail({
-      agent: makeAgent(),
-      runtime: makeRuntime(),
       tasks: [
         makeTask({
-          status: "failed",
+          status: "completed",
           completed_at: "2026-04-27T11:30:00Z",
         }),
       ],
       now: NOW,
     });
-    expect(detail.availability).toBe("online");
-    expect(detail.workload).toBe("idle");
+    expect(detail.availability).toBe("offline");
+    expect(detail.lastTask).toBe("completed");
+  });
+
+  it("leaves failureReason / lastTaskCompletedAt undefined when not relevant", () => {
+    const detail = deriveAgentPresenceDetail({
+      agent: makeAgent(),
+      runtime: makeRuntime(),
+      tasks: [makeTask({ status: "running" })],
+      now: NOW,
+    });
+    expect(detail.failureReason).toBeUndefined();
+    expect(detail.lastTaskCompletedAt).toBeUndefined();
   });
 
   it("mirrors agent.max_concurrent_tasks into capacity", () => {
@@ -342,16 +359,21 @@ describe("buildPresenceMap", () => {
       runtimes: [makeRuntime()],
       snapshot: [
         makeTask({ id: "t1", agent_id: "a", status: "running" }),
-        makeTask({ id: "t2", agent_id: "b", status: "queued" }),
+        makeTask({
+          id: "t2",
+          agent_id: "b",
+          status: "failed",
+          completed_at: "2026-04-27T11:30:00Z",
+        }),
       ],
       now: NOW,
     });
     const a = map.get("a");
     const b = map.get("b");
     expect(a?.availability).toBe("online");
-    expect(a?.workload).toBe("working");
+    expect(a?.lastTask).toBe("running");
     expect(b?.availability).toBe("online");
-    expect(b?.workload).toBe("queued");
+    expect(b?.lastTask).toBe("failed");
   });
 
   it("returns offline availability for agents whose runtime_id has no matching runtime", () => {
@@ -364,8 +386,8 @@ describe("buildPresenceMap", () => {
     });
     const o = map.get("orphan");
     expect(o?.availability).toBe("offline");
-    // Workload still resolves independently — running task counts.
-    expect(o?.workload).toBe("working");
+    // Task dimension still resolves independently — running task counts.
+    expect(o?.lastTask).toBe("running");
   });
 
   it("threads the same `now` so every agent on a shared runtime gets the same availability", () => {
@@ -384,35 +406,19 @@ describe("buildPresenceMap", () => {
       ],
       snapshot: [
         makeTask({ id: "t1", agent_id: "a", status: "queued" }),
-        makeTask({ id: "t2", agent_id: "b", status: "running" }),
+        makeTask({
+          id: "t2",
+          agent_id: "b",
+          status: "failed",
+          completed_at: "2026-04-27T11:00:00Z",
+        }),
       ],
       now: NOW,
     });
     expect(map.get("a")?.availability).toBe("unstable");
     expect(map.get("b")?.availability).toBe("unstable");
-    // Workload remains independent: a is queued (waiting), b is working.
-    expect(map.get("a")?.workload).toBe("queued");
-    expect(map.get("b")?.workload).toBe("working");
-  });
-
-  it("ignores terminal tasks in the snapshot when building per-agent workload", () => {
-    // Snapshot intentionally still includes each agent's most recent
-    // terminal task (back-end SQL didn't change); the front-end now
-    // filters them out at the workload-derivation step.
-    const agentA = makeAgent({ id: "a", runtime_id: "rt-1" });
-    const map = buildPresenceMap({
-      agents: [agentA],
-      runtimes: [makeRuntime()],
-      snapshot: [
-        makeTask({
-          id: "t-terminal",
-          agent_id: "a",
-          status: "failed",
-          completed_at: "2026-04-27T11:30:00Z",
-        }),
-      ],
-      now: NOW,
-    });
-    expect(map.get("a")?.workload).toBe("idle");
+    // Last-task remains independent: a is running (queued), b is failed.
+    expect(map.get("a")?.lastTask).toBe("running");
+    expect(map.get("b")?.lastTask).toBe("failed");
   });
 });

packages/core/agents/derive-presence.ts

@@ -4,19 +4,18 @@
 // dimensions:
 //
 //   1. AgentAvailability — derived from runtime reachability only.
-//   2. Workload          — derived from the task counts only.
+//   2. LastTaskState     — derived from the task snapshot only.
 //
 // They are computed independently and assembled into AgentPresenceDetail.
-// Workload is strictly "what's on the plate right now" — no historical
-// terminal state. Past failures / completions live on the detail page
-// (Recent Work, failure_reason) and Inbox.
+// No cross-dimension override logic — that was the source of the previous
+// model's "sticky red dot" confusion.
 
 import { deriveRuntimeHealth } from "../runtimes/derive-health";
-import type { Agent, AgentRuntime, AgentTask } from "../types";
+import type { Agent, AgentRuntime, AgentTask, TaskFailureReason } from "../types";
 import type {
   AgentAvailability,
   AgentPresenceDetail,
-  Workload,
+  LastTaskState,
 } from "./types";
 
 // AgentAvailability mirrors RuntimeHealth's reachability buckets but folds
@@ -34,44 +33,76 @@ export function deriveAgentAvailability(
   return "offline"; // offline | about_to_gc collapse here
 }
 
-// Atomic workload derivation: pure 3-way classification of running/queued
-// counts. Exported so Runtime-level views (which already aggregate counts
-// per-runtime in their own indices) can plug into the same vocabulary
-// without re-deriving from raw task arrays.
-export function deriveWorkload(counts: {
+interface LastTaskResult {
+  state: LastTaskState;
   runningCount: number;
   queuedCount: number;
-}): Workload {
-  if (counts.runningCount > 0) return "working";
-  if (counts.queuedCount > 0) return "queued";
-  return "idle";
+  failureReason?: TaskFailureReason;
+  lastTaskCompletedAt?: string;
 }
 
-interface WorkloadDetail {
-  workload: Workload;
-  runningCount: number;
-  queuedCount: number;
-}
-
-// Aggregates a task list into running/queued counts, then classifies via
-// deriveWorkload. Caller pre-filters to the relevant scope (per-agent or
-// per-runtime) — we don't filter again here.
-export function deriveWorkloadDetail(tasks: readonly AgentTask[]): WorkloadDetail {
+// Single pass: count actives + track latest terminal by completed_at. A
+// running OR queued task means the agent is currently busy ("running"
+// state); only when nothing is in flight do we fall through to the latest
+// terminal (which can be completed / failed / cancelled). With no terminal
+// history at all, we report `idle`.
+//
+// Cancelled is no longer filtered out — under the new model the dot is
+// availability-driven so honestly surfacing "cancelled" doesn't risk
+// lying about whether the agent works. The previous "exclude cancelled
+// to keep red sticky" hack is gone.
+export function deriveLastTaskState(tasks: readonly AgentTask[]): LastTaskResult {
   let runningCount = 0;
   let queuedCount = 0;
+  let latestTerminal: AgentTask | null = null;
+  let latestTerminalAt = -Infinity;
+
   for (const t of tasks) {
     if (t.status === "running") {
       runningCount += 1;
     } else if (t.status === "queued" || t.status === "dispatched") {
       queuedCount += 1;
+    } else if (t.completed_at) {
+      const ts = new Date(t.completed_at).getTime();
+      if (!Number.isNaN(ts) && ts > latestTerminalAt) {
+        latestTerminalAt = ts;
+        latestTerminal = t;
+      }
     }
-    // Terminal statuses (completed / failed / cancelled) intentionally
-    // ignored — workload is "what's on the plate right now", not history.
   }
+
+  if (runningCount + queuedCount > 0) {
+    return { state: "running", runningCount, queuedCount };
+  }
+
+  if (!latestTerminal) {
+    return { state: "idle", runningCount: 0, queuedCount: 0 };
+  }
+
+  const completedAt = latestTerminal.completed_at ?? undefined;
+  if (latestTerminal.status === "failed") {
+    return {
+      state: "failed",
+      runningCount: 0,
+      queuedCount: 0,
+      failureReason: latestTerminal.failure_reason || undefined,
+      lastTaskCompletedAt: completedAt,
+    };
+  }
+  if (latestTerminal.status === "cancelled") {
+    return {
+      state: "cancelled",
+      runningCount: 0,
+      queuedCount: 0,
+      lastTaskCompletedAt: completedAt,
+    };
+  }
+  // completed
   return {
-    workload: deriveWorkload({ runningCount, queuedCount }),
-    runningCount,
-    queuedCount,
+    state: "completed",
+    runningCount: 0,
+    queuedCount: 0,
+    lastTaskCompletedAt: completedAt,
   };
 }
 
@@ -88,14 +119,16 @@ interface DerivePresenceInput {
 
 export function deriveAgentPresenceDetail(input: DerivePresenceInput): AgentPresenceDetail {
   const availability = deriveAgentAvailability(input.runtime, input.now);
-  const detail = deriveWorkloadDetail(input.tasks);
+  const last = deriveLastTaskState(input.tasks);
 
   return {
     availability,
-    workload: detail.workload,
-    runningCount: detail.runningCount,
-    queuedCount: detail.queuedCount,
+    lastTask: last.state,
+    runningCount: last.runningCount,
+    queuedCount: last.queuedCount,
     capacity: input.agent.max_concurrent_tasks,
+    failureReason: last.failureReason,
+    lastTaskCompletedAt: last.lastTaskCompletedAt,
   };
 }
 
@@ -105,10 +138,9 @@ export function deriveAgentPresenceDetail(input: DerivePresenceInput): AgentPres
 export function buildPresenceMap(args: {
   agents: readonly Agent[];
   runtimes: readonly AgentRuntime[];
-  // The workspace agent task snapshot: every active task plus each agent's
+  // The workspace agent task snapshot: every active task + each agent's
   // most recent terminal task. Comes straight from getAgentTaskSnapshot()
-  // — no pre-filtering needed. Terminal rows are silently ignored by
-  // deriveWorkloadDetail (workload is current-state only).
+  // — no pre-filtering needed.
   snapshot: readonly AgentTask[];
   now: number;
 }): Map<string, AgentPresenceDetail> {

packages/core/agents/index.ts

@@ -4,6 +4,3 @@ export * from "./queries";
 export * from "./use-agent-presence";
 export * from "./use-agent-activity";
 export * from "./use-workspace-presence-prefetch";
-export * from "./constants";
-export * from "./visibility-label";
-export * from "./use-workspace-agent-availability";

packages/core/agents/types.ts

@@ -3,25 +3,23 @@
 // front-end from raw server data (agent + runtime + recent tasks); the
 // back-end never knows about these enums.
 //
-// Two orthogonal dimensions, derived independently and answering only
-// "what's true right now?" — historical / error context lives on the
-// agent detail page (Recent Work, failure_reason) and Inbox, not in the
-// list-level summary state:
+// Two orthogonal dimensions, derived independently:
 //
 //   1. AgentAvailability — "Can this agent take work right now?"
 //      Depends only on runtime reachability. The dot colour everywhere in
 //      the app reflects this single dimension; never sticky-red because of
 //      a past task outcome.
 //
-//   2. Workload — "What is on this agent's plate right now?"
-//      Depends only on the workspace task snapshot. Three states, each
-//      pointing at a clear user action:
-//        working → tasks running, normal
-//        queued  → tasks queued but nothing running (= stuck if availability
-//                  is offline/unstable; momentary if online)
-//        idle    → nothing to do
-//      No `failed` / `completed` / `cancelled` states — those are historical,
-//      surfaced via Recent Work + Inbox.
+//   2. LastTaskState — "What was the last thing this agent did?"
+//      Depends only on the workspace task snapshot. Surfaced as text + icon
+//      on focused surfaces (hover card, agent detail, agent list, runtime
+//      detail). Never colours the dot.
+//
+// The previous single 5-state union conflated the two: a runtime-healthy
+// agent whose last task failed would show a red dot indistinguishable from
+// a daemon-dead agent. Splitting them lets each signal be unambiguous.
+
+import type { TaskFailureReason } from "../types";
 
 // Runtime-reachability dimension. `unstable` is the transient amber state
 // during the runtime sweeper's grace window (offline < 5 min); it decays
@@ -32,31 +30,40 @@ export type AgentAvailability =
   | "unstable" // 🟡 runtime recently_lost (< 5 min) — transient
   | "offline"; // ⚫ runtime long offline / missing / never registered
 
-// Current task load on this agent. Three states — never historical,
-// never an error predictor (Inbox + Recent Work handle that):
+// Last-task dimension. Active and terminal merged into one enum because
+// only one applies at a time: while there's any in-flight task the state
+// is `running`; once everything terminates we read the latest outcome;
+// with no history at all, `idle`.
 //
-//   working → runningCount > 0. The runningCount/queuedCount on the detail
-//             object preserve the breakdown for display.
-//   queued  → no running task but ≥1 queued/dispatched. Most often means
-//             the runtime is offline and tasks are stuck waiting; a brief
-//             flash on online runtimes between dispatch and run is a
-//             harmless race.
-//   idle    → nothing on the plate.
+// `running` covers both `running` and `queued/dispatched` tasks because
+// from the user's perspective "agent is busy" is the same answer; the
+// running/queued counts on the detail object preserve the breakdown.
 //
-// Pair with availability for the full picture: `online + working` is
-// normal; `offline + queued` is the "stuck" state we explicitly surface;
-// `offline + idle` is "agent unavailable, nothing waiting" — both honest.
-export type Workload =
-  | "working" // ≥1 task currently running
-  | "queued" // nothing running, but ≥1 queued/dispatched
-  | "idle"; // nothing on the plate
+// `cancelled` is included as a discrete state (vs. folding into the
+// previous filter that excluded cancelled from terminal selection). With
+// the dot no longer colour-coded by task state, surfacing "cancelled"
+// honestly is fine — it doesn't risk lying about availability.
+export type LastTaskState =
+  | "running" // ≥1 task running or queued right now
+  | "completed" // latest terminal: completed
+  | "failed" // latest terminal: failed
+  | "cancelled" // latest terminal: cancelled
+  | "idle"; // no active task and no terminal history
 
 export interface AgentPresenceDetail {
   availability: AgentAvailability;
-  workload: Workload;
+  lastTask: LastTaskState;
   runningCount: number;
   queuedCount: number;
   // Mirrors agent.max_concurrent_tasks — pulled into the detail so the UI
   // can render `running / capacity` ratios without re-fetching the agent.
   capacity: number;
+  // Set only when lastTask === "failed". The label lookup happens at the
+  // UI layer; deriving exposes the raw classifier so the UI can choose copy.
+  failureReason?: TaskFailureReason;
+  // Wall-clock timestamp of the latest terminal task. Set whenever
+  // lastTask is one of completed / failed / cancelled. Used to render
+  // "Last run: failed · 12 min ago" copy. Undefined for `running` (no
+  // terminal yet) and `idle` (no history).
+  lastTaskCompletedAt?: string;
 }

packages/core/agents/use-agent-presence.ts

@@ -110,7 +110,7 @@ export function useWorkspacePresenceMap(wsId: string | undefined): {
 // skeleton spinning forever.
 const MISSING_AGENT_DETAIL: AgentPresenceDetail = {
   availability: "offline",
-  workload: "idle",
+  lastTask: "idle",
   runningCount: 0,
   queuedCount: 0,
   capacity: 0,

packages/core/agents/use-workspace-agent-availability.ts

@@ -1,60 +0,0 @@
-"use client";
-
-import { useQuery } from "@tanstack/react-query";
-import { useWorkspaceId } from "../hooks";
-import { useAuthStore } from "../auth";
-import { agentListOptions, memberListOptions } from "../workspace/queries";
-import { canAssignAgentToIssue } from "../permissions";
-
-/**
- * Three-state availability for "does the current user have any agent
- * they can chat with in this workspace?".
- *
- * Why three states (not a boolean): the answer to "is there an agent?"
- * lives on the server. Until the agent-list query resolves, the answer
- * is genuinely *unknown*. Callers must distinguish "loading" from
- * "confirmed empty" — collapsing them to a boolean causes UIs to flash
- * disabled/empty states for the first few hundred ms after mount, even
- * when the workspace actually has agents.
- *
- *   "loading"   — agent or member list still in flight (be neutral in UI)
- *   "none"      — both queries resolved, user has zero assignable agents
- *   "available" — at least one agent passes archive + visibility filters
- */
-export type WorkspaceAgentAvailability = "loading" | "none" | "available";
-
-/**
- * Mirrors the per-agent visibility/archived filter used by AssigneePicker
- * and the chat agent dropdown, so the three pickers can never disagree on
- * "is this agent reachable?".
- *
- * Members are queried because `canAssignAgentToIssue` reads the caller's
- * role to decide visibility for `private` agents — without member data,
- * a freshly-loaded agent list could still produce wrong answers.
- */
-export function useWorkspaceAgentAvailability(): WorkspaceAgentAvailability {
-  const wsId = useWorkspaceId();
-  const userId = useAuthStore((s) => s.user?.id);
-  const { data: agents, isFetched: agentsFetched } = useQuery(
-    agentListOptions(wsId),
-  );
-  const { data: members, isFetched: membersFetched } = useQuery(
-    memberListOptions(wsId),
-  );
-
-  if (!agentsFetched || !membersFetched) return "loading";
-
-  const rawRole = members?.find((m) => m.user_id === userId)?.role;
-  const role =
-    rawRole === "owner" || rawRole === "admin" || rawRole === "member"
-      ? rawRole
-      : null;
-
-  const hasVisibleAgent = (agents ?? []).some(
-    (a) =>
-      !a.archived_at &&
-      canAssignAgentToIssue(a, { userId: userId ?? null, role }).allowed,
-  );
-
-  return hasVisibleAgent ? "available" : "none";
-}

packages/core/agents/visibility-label.ts

@@ -1,31 +0,0 @@
-import type { AgentVisibility } from "../types";
-
-/**
- * Display labels for agent visibility. The DB stores `private` as the value
- * but the UI surface name is "Personal" — better matches what the field
- * actually means now that workspace admins can also assign private agents.
- */
-export const VISIBILITY_LABEL: Record<AgentVisibility, string> = {
-  workspace: "Workspace",
-  private: "Personal",
-};
-
-/**
- * Honest descriptions for assignability. The previous "Only you can assign"
- * text was a lie — workspace owners and admins can assign private agents too
- * (server `issue.go:1471-1490`).
- */
-export const VISIBILITY_DESCRIPTION: Record<AgentVisibility, string> = {
-  workspace: "All members can assign",
-  private: "Only you and workspace admins can assign",
-};
-
-/** Tooltip suitable for read-only badges on hover/list rows. */
-export const VISIBILITY_TOOLTIP: Record<AgentVisibility, string> = {
-  workspace: "Workspace — all members can assign",
-  private: "Personal — only you and workspace admins can assign",
-};
-
-export function visibilityLabel(v: AgentVisibility): string {
-  return VISIBILITY_LABEL[v];
-}

packages/core/api/client.ts

@@ -26,7 +26,6 @@ import type {
   MemberWithUser,
   User,
   Skill,
-  SkillSummary,
   CreateSkillRequest,
   UpdateSkillRequest,
   SetAgentSkillsRequest,
@@ -43,8 +42,7 @@ import type {
   RuntimeLocalSkillListRequest,
   CreateRuntimeLocalSkillImportRequest,
   RuntimeLocalSkillImportRequest,
-  TimelinePage,
-  TimelinePageParam,
+  TimelineEntry,
   AssigneeFrequencyEntry,
   TaskMessagePayload,
   Attachment,
@@ -57,9 +55,6 @@ import type {
   CreateProjectRequest,
   UpdateProjectRequest,
   ListProjectsResponse,
-  ProjectResource,
-  CreateProjectResourceRequest,
-  ListProjectResourcesResponse,
   Label,
   CreateLabelRequest,
   UpdateLabelRequest,
@@ -80,8 +75,6 @@ import type {
   ListAutopilotsResponse,
   GetAutopilotResponse,
   ListAutopilotRunsResponse,
-  NotificationPreferenceResponse,
-  NotificationPreferences,
 } from "../types";
 import type { OnboardingCompletionPath } from "../onboarding/types";
 import { type Logger, noopLogger } from "../logger";
@@ -496,17 +489,8 @@ export class ApiClient {
     });
   }
 
-  async listTimeline(
-    issueId: string,
-    pageParam: TimelinePageParam = { mode: "latest" },
-    limit = 50,
-  ): Promise<TimelinePage> {
-    const params = new URLSearchParams();
-    params.set("limit", String(limit));
-    if (pageParam.mode === "before") params.set("before", pageParam.cursor);
-    else if (pageParam.mode === "after") params.set("after", pageParam.cursor);
-    else if (pageParam.mode === "around") params.set("around", pageParam.id);
-    return this.fetch(`/api/issues/${issueId}/timeline?${params.toString()}`);
+  async listTimeline(issueId: string): Promise<TimelineEntry[]> {
+    return this.fetch(`/api/issues/${issueId}/timeline`);
   }
 
   async getAssigneeFrequency(): Promise<AssigneeFrequencyEntry[]> {
@@ -799,18 +783,6 @@ export class ApiClient {
     return this.fetch("/api/inbox/archive-completed", { method: "POST" });
   }
 
-  // Notification preferences
-  async getNotificationPreferences(): Promise<NotificationPreferenceResponse> {
-    return this.fetch("/api/notification-preferences");
-  }
-
-  async updateNotificationPreferences(preferences: NotificationPreferences): Promise<NotificationPreferenceResponse> {
-    return this.fetch("/api/notification-preferences", {
-      method: "PUT",
-      body: JSON.stringify({ preferences }),
-    });
-  }
-
   // App Config
   async getConfig(): Promise<{
     cdn_domain: string;
@@ -914,7 +886,7 @@ export class ApiClient {
   }
 
   // Skills
-  async listSkills(): Promise<SkillSummary[]> {
+  async listSkills(): Promise<Skill[]> {
     return this.fetch("/api/skills");
   }
 
@@ -947,7 +919,7 @@ export class ApiClient {
     });
   }
 
-  async listAgentSkills(agentId: string): Promise<SkillSummary[]> {
+  async listAgentSkills(agentId: string): Promise<Skill[]> {
     return this.fetch(`/api/agents/${agentId}/skills`);
   }
 
@@ -1020,7 +992,7 @@ export class ApiClient {
     });
   }
 
-  async deleteChatSession(id: string): Promise<void> {
+  async archiveChatSession(id: string): Promise<void> {
     await this.fetch(`/api/chat/sessions/${id}`, { method: "DELETE" });
   }
 
@@ -1088,32 +1060,6 @@ export class ApiClient {
     await this.fetch(`/api/projects/${id}`, { method: "DELETE" });
   }
 
-  // Project resources
-  async listProjectResources(
-    projectId: string,
-  ): Promise<ListProjectResourcesResponse> {
-    return this.fetch(`/api/projects/${projectId}/resources`);
-  }
-
-  async createProjectResource(
-    projectId: string,
-    data: CreateProjectResourceRequest,
-  ): Promise<ProjectResource> {
-    return this.fetch(`/api/projects/${projectId}/resources`, {
-      method: "POST",
-      body: JSON.stringify(data),
-    });
-  }
-
-  async deleteProjectResource(
-    projectId: string,
-    resourceId: string,
-  ): Promise<void> {
-    await this.fetch(`/api/projects/${projectId}/resources/${resourceId}`, {
-      method: "DELETE",
-    });
-  }
-
   // Labels
   async listLabels(): Promise<ListLabelsResponse> {
     return this.fetch(`/api/labels`);

packages/core/auth/utils.ts

@@ -15,7 +15,6 @@
 export function sanitizeNextUrl(raw: string | null): string | null {
   if (!raw) return null;
   if (!raw.startsWith("/") || raw.startsWith("//")) return null;
-  // eslint-disable-next-line no-control-regex -- intentional: rejecting control chars is the whole point
   if (/[\x00-\x1f\\]/.test(raw)) return null;
   return raw;
 }

packages/core/chat/mutations.ts

@@ -70,20 +70,14 @@ export function useMarkChatSessionRead() {
   });
 }
 
-/**
- * Hard-deletes a chat session. Optimistically removes the row from both
- * the active and all-sessions lists so the history panel updates instantly;
- * rolls back on error. The matching `chat:session_deleted` WS event keeps
- * other tabs/devices in sync — see use-realtime-sync.ts.
- */
-export function useDeleteChatSession() {
+export function useArchiveChatSession() {
   const qc = useQueryClient();
   const wsId = useWorkspaceId();
 
   return useMutation({
     mutationFn: (sessionId: string) => {
-      logger.info("deleteChatSession.start", { sessionId });
-      return api.deleteChatSession(sessionId);
+      logger.info("archiveChatSession.start", { sessionId });
+      return api.archiveChatSession(sessionId);
     },
     onMutate: async (sessionId) => {
       await qc.cancelQueries({ queryKey: chatKeys.sessions(wsId) });
@@ -92,20 +86,26 @@ export function useDeleteChatSession() {
       const prevSessions = qc.getQueryData<ChatSession[]>(chatKeys.sessions(wsId));
       const prevAll = qc.getQueryData<ChatSession[]>(chatKeys.allSessions(wsId));
 
-      const drop = (old?: ChatSession[]) => old?.filter((s) => s.id !== sessionId);
-      qc.setQueryData<ChatSession[]>(chatKeys.sessions(wsId), drop);
-      qc.setQueryData<ChatSession[]>(chatKeys.allSessions(wsId), drop);
+      // Optimistic: remove from active, mark as archived in allSessions
+      qc.setQueryData<ChatSession[]>(chatKeys.sessions(wsId), (old) =>
+        old ? old.filter((s) => s.id !== sessionId) : old,
+      );
+      qc.setQueryData<ChatSession[]>(chatKeys.allSessions(wsId), (old) =>
+        old?.map((s) =>
+          s.id === sessionId ? { ...s, status: "archived" as const } : s,
+        ),
+      );
 
-      logger.debug("deleteChatSession.optimistic", { sessionId });
+      logger.debug("archiveChatSession.optimistic", { sessionId });
       return { prevSessions, prevAll };
     },
     onError: (err, sessionId, ctx) => {
-      logger.error("deleteChatSession.error.rollback", { sessionId, err });
+      logger.error("archiveChatSession.error.rollback", { sessionId, err });
       if (ctx?.prevSessions) qc.setQueryData(chatKeys.sessions(wsId), ctx.prevSessions);
       if (ctx?.prevAll) qc.setQueryData(chatKeys.allSessions(wsId), ctx.prevAll);
     },
     onSettled: (_data, _err, sessionId) => {
-      logger.debug("deleteChatSession.settled", { sessionId });
+      logger.debug("archiveChatSession.settled", { sessionId });
       qc.invalidateQueries({ queryKey: chatKeys.sessions(wsId) });
       qc.invalidateQueries({ queryKey: chatKeys.allSessions(wsId) });
     },

packages/core/chat/store.ts

@@ -16,14 +16,6 @@ const CHAT_HEIGHT_KEY = "multica:chat:height";
 const CHAT_EXPANDED_KEY = "multica:chat:expanded";
 /** Focus mode is a personal preference — global across workspaces/sessions. */
 const FOCUS_MODE_KEY = "multica:chat:focusMode";
-/**
- * Open/closed preference, persisted globally (not per-workspace) — most users
- * have one habitual chat-panel preference across workspaces. Missing key =
- * new user (or cleared storage); default to OPEN so the chat is discoverable.
- * Once the user toggles even once, their explicit choice is respected on
- * every subsequent reload.
- */
-const OPEN_KEY = "multica:chat:isOpen";
 
 function readDrafts(storage: StorageAdapter, key: string): Record<string, string> {
   const raw = storage.getItem(key);
@@ -51,7 +43,7 @@ function writeDrafts(storage: StorageAdapter, key: string, drafts: Record<string
 
 export const CHAT_MIN_W = 360;
 export const CHAT_MIN_H = 480;
-export const CHAT_DEFAULT_W = 380;
+export const CHAT_DEFAULT_W = 420;
 export const CHAT_DEFAULT_H = 600;
 
 /**
@@ -126,14 +118,8 @@ export function createChatStore(options: ChatStoreOptions) {
     return slug ? `${base}:${slug}` : base;
   };
 
-  // Resolve initial isOpen from storage. The three-state read (null /
-  // "true" / "false") is what enables the "new user → open" default while
-  // still honouring an explicit "I closed it" choice on every reload.
-  const storedOpen = storage.getItem(OPEN_KEY);
-  const initialIsOpen = storedOpen === null ? true : storedOpen === "true";
-
   const store = create<ChatState>((set, get) => ({
-    isOpen: initialIsOpen,
+    isOpen: false,
     activeSessionId: storage.getItem(wsKey(SESSION_STORAGE_KEY)),
     selectedAgentId: storage.getItem(wsKey(AGENT_STORAGE_KEY)),
     showHistory: false,
@@ -144,13 +130,11 @@ export function createChatStore(options: ChatStoreOptions) {
     isExpanded: storage.getItem(wsKey(CHAT_EXPANDED_KEY)) === "true",
     setOpen: (open) => {
       logger.debug("setOpen", { from: get().isOpen, to: open });
-      storage.setItem(OPEN_KEY, String(open));
       set({ isOpen: open });
     },
     toggle: () => {
       const next = !get().isOpen;
       logger.debug("toggle", { to: next });
-      storage.setItem(OPEN_KEY, String(next));
       set({ isOpen: next });
     },
     setActiveSession: (id) => {

packages/core/feedback/draft-store.ts

@@ -1,41 +0,0 @@
-import { create } from "zustand";
-import { createJSONStorage, persist } from "zustand/middleware";
-import { createWorkspaceAwareStorage, registerForWorkspaceRehydration } from "../platform/workspace-storage";
-import { defaultStorage } from "../platform/storage";
-
-interface FeedbackDraft {
-  message: string;
-}
-
-const EMPTY_DRAFT: FeedbackDraft = {
-  message: "",
-};
-
-interface FeedbackDraftStore {
-  draft: FeedbackDraft;
-  setDraft: (patch: Partial<FeedbackDraft>) => void;
-  clearDraft: () => void;
-  hasDraft: () => boolean;
-}
-
-export const useFeedbackDraftStore = create<FeedbackDraftStore>()(
-  persist(
-    (set, get) => ({
-      draft: { ...EMPTY_DRAFT },
-      setDraft: (patch) =>
-        set((s) => ({ draft: { ...s.draft, ...patch } })),
-      clearDraft: () =>
-        set({ draft: { ...EMPTY_DRAFT } }),
-      hasDraft: () => {
-        const { draft } = get();
-        return !!draft.message;
-      },
-    }),
-    {
-      name: "multica_feedback_draft",
-      storage: createJSONStorage(() => createWorkspaceAwareStorage(defaultStorage)),
-    },
-  ),
-);
-
-registerForWorkspaceRehydration(() => useFeedbackDraftStore.persist.rehydrate());