@epoch-agent/server 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import { createServer } from 'http';
+import { t, ApprovalRelay, QuestionRelay, serializeStream, withRoleScope, withModelScope, withToolScope, nextRunAt, skillIndexDescription, SANDBOX_EXCLUDES, SANDBOX_COVERS, backgroundTaskOutput, listBackgroundTasks, providerLabel, MAX_REASON_CHARS, MAX_OBJECTIVE_CHARS, MAX_GOAL_MAX_ROUNDS, DEFAULT_GOAL_MAX_ROUNDS, SCHEDULE_DEFAULT_ALLOWLIST, SCHEDULE_DEFAULTS, readRecording } from '@epoch-agent/runtime';
 import { timingSafeEqual, randomBytes } from 'crypto';
-import { PLAN_OUTCOMES, WIRE_AUTH_COOKIE, WIRE_AUTH_COOKIE_ATTRS, WIRE_AUTH_TOKEN_PARAM, isWireRewindScope, WIRE_REWIND_SCOPES, WIRE_LANG_PARAM, isLang, isQuestionAnswerMap, isProviderType, WIRE_SETTING_WRITE_LAYERS, isWirePlanAction, WIRE_PLAN_ACTIONS, isPermissionLevel, PERMISSION_LEVELS, isWireSettingWriteLayer, parseModelRef, OPERATION_TYPES, isOperationType } from '@epoch-agent/protocol';
-import { ApprovalRelay, QuestionRelay, serializeStream, withRoleScope, withModelScope, withToolScope, t, nextRunAt, skillIndexDescription, SANDBOX_EXCLUDES, SANDBOX_COVERS, backgroundTaskOutput, listBackgroundTasks, SCHEDULE_DEFAULT_ALLOWLIST, SCHEDULE_DEFAULTS, readRecording } from '@epoch-agent/runtime';
+import { PLAN_OUTCOMES, WIRE_AUTH_COOKIE, WIRE_AUTH_COOKIE_ATTRS, WIRE_AUTH_TOKEN_PARAM, extractAllMentions, MAX_ATTACH_FILES, utf8ByteLength, MAX_SESSION_REFS, attachSessionSurface, isWireRewindScope, WIRE_REWIND_SCOPES, MAX_ATTACH_TOTAL_BYTES, MAX_ATTACH_BYTES, WIRE_LANG_PARAM, isLang, isQuestionAnswerMap, isProviderType, WIRE_SETTING_WRITE_LAYERS, isWirePlanAction, WIRE_PLAN_ACTIONS, isPermissionLevel, PERMISSION_LEVELS, collectPendingApprovals, unfixedRules, isWireSettingWriteLayer, parseModelRef, WIRE_GOAL_ACTIONS, OPERATION_TYPES, isOperationType } from '@epoch-agent/protocol';
 import { resolve, join, relative, isAbsolute, sep, dirname, basename, extname } from 'path';
 import { existsSync, realpathSync, statSync, mkdirSync, createReadStream, readdirSync, accessSync, constants } from 'fs';
 import { homedir } from 'os';
@@ -100,16 +100,25 @@ function decideBinding(req = {}) {
   const host = req.host?.trim() || DEFAULT_WEB_HOST;
   const port = req.port ?? DEFAULT_WEB_PORT;
   if (!Number.isInteger(port) || port < 0 || port > 65535) {
-    return { ok: false, error: `\u7AEF\u53E3\u5FC5\u987B\u662F 0-65535 \u7684\u6574\u6570\uFF0C\u6536\u5230 ${String(req.port)}` };
+    return {
+      ok: false,
+      error: t("web.bad_port", { value: String(req.port) }, void 0)
+    };
   }
   const lanExposed = !isLoopbackHost(host);
   const token = req.token?.trim();
   if (lanExposed && !token) {
     return {
       ok: false,
-      error: `--host ${host} \u4F1A\u628A\u670D\u52A1\u66B4\u9732\u5230\u56DE\u73AF\u4E4B\u5916\uFF0C\u5FC5\u987B\u540C\u65F6\u7ED9 --token <\u968F\u673A\u4E32>\uFF0C\u62D2\u7EDD\u542F\u52A8\u3002
-  \u672C\u5730\u4F7F\u7528\u8BF7\u53BB\u6389 --host\uFF08\u9ED8\u8BA4\u53EA\u7ED1 127.0.0.1\uFF09\u3002
-  \u771F\u8981\u7ED9\u5C40\u57DF\u7F51\u7528\uFF1Aepoch web --host 0.0.0.0 --token "$(openssl rand -base64 32)"`
+      error: [
+        t("web.lan_needs_token", { host }, void 0),
+        "  " + t("web.lan_needs_token_local", void 0, void 0),
+        "  " + t(
+          "web.lan_needs_token_lan",
+          { cmd: 'epoch web --host 0.0.0.0 --token "$(openssl rand -base64 32)"' },
+          void 0
+        )
+      ].join("\n")
     };
   }
   return { ok: true, host, port, lanExposed, token: token || generateToken() };
@@ -127,7 +136,6 @@ function firstScreenUrl(host, port, token, ui = {}) {
   if (ui.lang) params.push(`${UI_LANG_PARAM}=${encodeURIComponent(ui.lang)}`);
   return `http://${authority}:${port}/?${params.join("&")}`;
 }
-
 // src/ring.ts
 var DEFAULT_RING_CAPACITY = 512;
 var EnvelopeRing = class {
@@ -138,53 +146,21 @@ var EnvelopeRing = class {
     }
   }
   capacity;
-  /**
-   * 按 seq 升序、**连续无洞**的一段。
-   *
-   * 连续性是 `since()` 能只靠首尾两个 seq 判定的前提：每个广播帧都让全局计数器
-   * 恰好 +1，所以缓冲里存的一定是 `[latest-size+1, latest]` 这个闭区间。
-   * 哪天出现「某些帧不进缓冲」的需求，这条前提就断了，`since()` 必须跟着改。
-   */
   frames = [];
-  /**
-   * 收一帧。**只收广播帧**（`seq >= 1`）。
-   *
-   * 连接级帧（`connected` / `stream-reset`，`seq: 0`）不进来：它们只发给刚接上来
-   * 的那一个连接，进了缓冲就会在下一次续传时被当成历史补给别人。
-   */
   push(frame) {
     if (frame.seq < 1) throw new Error(`\u8FDE\u63A5\u7EA7\u5E27\uFF08seq=${frame.seq}\uFF09\u4E0D\u8BE5\u8FDB\u73AF\u5F62\u7F13\u51B2`);
     this.frames.push(frame);
     if (this.frames.length > this.capacity) this.frames.shift();
   }
-  /** 缓冲里最新那一帧的 seq；空缓冲是 0（= 还没发过任何广播帧） */
   get latestSeq() {
     return this.frames[this.frames.length - 1]?.seq ?? 0;
   }
-  /** 缓冲里最老那一帧的 seq；空缓冲是 undefined */
   get oldestSeq() {
     return this.frames[0]?.seq;
   }
-  /** 现存帧数 */
   get size() {
     return this.frames.length;
   }
-  /**
-   * 断点之后的帧。
-   *
-   * @param lastEventId 客户端带上来的 `Last-Event-ID`（它已经收到的最后一个 seq）
-   * @returns 要补发的帧（可能是空数组 = 一条没落下）；
-   *          **`null` 表示续不上**，调用方必须回 `stream-reset`
-   *
-   * 四种边界，全都在这里一次判掉：
-   *
-   * | 情况                        | 返回        | 为什么                                             |
-   * | --------------------------- | ----------- | -------------------------------------------------- |
-   * | `last === latest`           | `[]`        | 断得很干净，一条没落下                             |
-   * | `last > latest`             | `null`      | 游标比我们发过的还新 —— 换了个进程，seq 从头数过了 |
-   * | `last + 1 < oldest`         | `null`      | 中间那段被挤掉了，这就是验收第 4 条                |
-   * | 其余                        | `(last, ∞)` | 正常续传，一条不丢一条不重（验收第 3 条）          |
-   */
   since(lastEventId) {
     if (!Number.isInteger(lastEventId) || lastEventId < 1) {
       return [];
@@ -200,29 +176,14 @@ var DEFAULT_MAX_ACTIVE_SESSIONS = 8;
 var DEFAULT_MAX_QUEUED_MESSAGES = 8;
 var SessionRegistry = class {
   entries = /* @__PURE__ */ new Map();
-  /**
-   * 被冷却过的 id。**只留 id，不留会话对象** —— 留着对象就等于什么都没释放，
-   * 而释放内存里那份对话历史正是冷却的全部意义。
-   *
-   * 它存在的唯一理由是让「往一个被冷却的会话发消息」能回一句准话
-   * （409 `session-cooled`）而不是 404「没有这个会话」—— 后者会让调用方
-   * 以为自己拼错了 id。插入序即冷却序，超出容量时从最早的开始丢。
-   */
   cooled = /* @__PURE__ */ new Set();
   maxActive;
   maxQueued;
-  /** 单调递增的逻辑刻度，见 `SessionEntry.lastActiveTick` */
   tick = 0;
   constructor(opts = {}) {
     this.maxActive = Math.max(1, opts.maxActive ?? DEFAULT_MAX_ACTIVE_SESSIONS);
     this.maxQueued = Math.max(0, opts.maxQueued ?? DEFAULT_MAX_QUEUED_MESSAGES);
   }
-  /**
-   * 把一个会话放进表里。重复注册同一个 id 是空操作。
-   *
-   * 注册一个**曾被冷却**的 id 就是「重新打开它」：从冷却名单里摘掉，
-   * 之后它和别的活跃会话没有区别（历史由 `GET /messages` 回放，不在这里恢复）。
-   */
   register(session) {
     const id = session.sessionId;
     if (this.entries.has(id)) return { added: false, cooled: null };
@@ -246,54 +207,33 @@ var SessionRegistry = class {
   has(sessionId) {
     return this.entries.has(sessionId);
   }
-  /** 这个 id 是被冷却掉的（而不是从来没存在过）吗 */
   isCooled(sessionId) {
     return this.cooled.has(sessionId);
   }
   get size() {
     return this.entries.size;
   }
-  /** 遍历。插入序 = 注册序 */
   all() {
     return this.entries.entries();
   }
-  /** 从表里摘掉（会话被删除时）。**不进冷却名单** —— 它是真没了，不是被挤走 */
   remove(sessionId) {
     const entry = this.entries.get(sessionId);
     if (entry) this.entries.delete(sessionId);
     this.cooled.delete(sessionId);
     return entry;
   }
-  /** 记一次活动。开轮和收轮都要调 —— LRU 挑的就是这个刻度最小的那个 */
   touch(sessionId) {
     const entry = this.entries.get(sessionId);
     if (entry) entry.lastActiveTick = ++this.tick;
   }
-  /**
-   * 排一条消息。
-   *
-   * @returns `false` = 队列满了，调用方回 409。**不悄悄丢**：丢掉的表现是
-   *          用户发了一条消息，服务端回 202，然后什么都没发生
-   */
   enqueue(entry, queued) {
     if (entry.queue.length >= this.maxQueued) return false;
     entry.queue.push(queued);
     return true;
   }
-  /** 取下一条排队的消息。空队列时 `undefined` */
   dequeue(entry) {
     return entry.queue.shift();
   }
-  /**
-   * 挤掉一个最久没动过的**空闲**会话。
-   *
-   * 三条判据都不能少：
-   *   - **只挑 idle 的**：冷却一个正在跑的会话等于中途把它的历史扔了
-   *   - **不挑刚注册的那个**（`keep`）：否则「注册第 9 个」的结果可能是
-   *     「第 9 个自己被冷却」，调用方会看到一个刚建好就不见了的会话
-   *   - **一个都挑不出来就不挤**（全在跑）：上限是软的。硬挤的代价是丢一轮
-   *     正在跑的对话，那比多占一份内存严重得多
-   */
   coolIfCrowded(keep) {
     if (this.entries.size <= this.maxActive) return null;
     let victim = null;
@@ -310,7 +250,6 @@ var SessionRegistry = class {
     this.rememberCooled(victim);
     return victim;
   }
-  /** 冷却名单也要有界 —— 它只是给错误信息用的，不该跟着进程一直长 */
   rememberCooled(sessionId) {
     this.cooled.add(sessionId);
     const limit = this.maxActive * 4;
@@ -382,12 +321,10 @@ function bindFailureToHttp(failure, lang) {
   }
   return { status: 400, code: "bad-workspace", message: failure.detail };
 }
-
 // src/sessions/summary.ts
 function toWireFinish(event, ts, turnStartedAt) {
   return {
     reason: event.reason,
-    // 起点不知道就给 null，**不给 0** —— 0 在界面上是「0s」，那是个假事实
     durationMs: turnStartedAt === null ? null : Math.max(0, ts - turnStartedAt),
     runUsage: event.runUsage ?? null
   };
@@ -397,10 +334,6 @@ var OFFLINE = {
   state: "idle",
   pendingApprovals: 0,
   pendingQuestions: 0,
-  // 「从什么时候起被拦住」在这一档也是 null，理由和上面那条一样：挂起的账只活在
-  // Hub 的内存里。⚠️ 它**不是**「没在等」——是「这个进程不知道」，而两者在读的
-  // 那一侧下一步相同（那一格整个不画），所以归同一档。判据全文在
-  // `WireSessionSummary.pendingSince` 的最后一节
   pendingSince: null,
   turnStartedAt: null,
   lastFinish: null
@@ -417,26 +350,14 @@ function toWireSummary(id, hub, row, extra = {}) {
     messageCount: row?.messageCount ?? 0,
     costUsd: row?.costUsd ?? null,
     startedAt: row?.startedAt ?? null,
-    // 和 `startedAt` 同生共死：两者的 null 都只有一个含义 ——「DB 里查不到这段
-    // 会话」。**这一层不拿 `startedAt` 兜它**：兜了就等于把「不知道」写成
-    // 「刚建出来那一刻动过」，而那正是加这一列之前界面上那句假话
     updatedAt: row?.updatedAt ?? null,
     endedAt: row?.endedAt ?? null,
     pendingApprovals: state.pendingApprovals,
     pendingQuestions: state.pendingQuestions,
-    // 原样透传，这一层**一个字都不加工**：两张登记表合成一格那一步在 Hub 里
-    // 就着两个 relay 做完了（`earlierOf`），在这儿再合一次就是第二个口径 ——
-    // 同下面回合那两格的判据
     pendingSince: state.pendingSince,
-    // 这一格是**两个真源真的合在一起**的唯一一处（其余每一格各归各家）。
-    // 合法和它推翻了哪一条上一轮的规矩，全在 `toWireSummaryWorkspace` 上
     workspace: toWireSummaryWorkspace(extra.workspace ?? null, live, row),
-    // 回合那两格原样透传，这一层不做任何加工：`durationMs` 的减法在 Hub 里
-    // 就着那一帧算完了（见 `hub.ts` 的 `finishOf`），在这儿再算一次就是第二个口径
     turnStartedAt: state.turnStartedAt,
     lastFinish: state.lastFinish,
-    // 同 `workspace` 那一格：不给就是 null，**不去 DB 兜一手**。身份决定 system
-    // prompt 和工具表，只有活着的那份内存说得出它现在是谁
     role: extra.role ?? null,
     ...extra.snippet === void 0 ? {} : { snippet: extra.snippet }
   };
@@ -487,28 +408,16 @@ function compareSummaries(a, b) {
   if (at !== bt) return bt - at;
   return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
 }
-
 // src/hub.ts
 var SessionHub = class {
   ring;
   idleGraceMs;
   clock;
-  /** 见 {@link SessionHubOptions.onCooled} */
   onCooled;
   registry;
   sinks = /* @__PURE__ */ new Set();
-  /**
-   * 同进程旁听者（方案 54 §三）。**故意是第二个集合，而不是 `sinks` 上的一个标记位。**
-   *
-   * 标记位那种写法要求每一处 `sinks.size` 都改成「数一下里面有几个不是标记的」，
-   * 而那四处判定里有两处（`reap()` / `drainQueue()`）的错法是**静默的**：
-   * 挂起的审批永远不被放弃、没人看着的时候凭空开始跑一条排队的消息。
-   * 两个集合的写法让那四处一个字都不用改。
-   */
   observers = /* @__PURE__ */ new Set();
-  /** requestId → sessionId。`POST /api/approvals/:requestId` 上没有会话 id */
   requestOwner = /* @__PURE__ */ new Map();
-  /** 全局广播游标。0 是保留值（连接级帧），所以广播帧从 1 开始 */
   seq = 0;
   graceTimer = null;
   closed = false;
@@ -522,13 +431,6 @@ var SessionHub = class {
       ...opts.maxQueuedMessages === void 0 ? {} : { maxQueued: opts.maxQueuedMessages }
     });
   }
-  /**
-   * 把一个会话交给 Hub 管。重复注册同一个 id 是空操作。
-   *
-   * 活跃会话超过上限时，最久没动过的**空闲**会话会被顺带冷却掉 ——
-   * 它从此不在 Hub 里，但**仍然在会话列表里**（列表的另一半来自 DB），
-   * 重新打开时历史走 `GET /api/sessions/:id/messages` 回放。
-   */
   register(session) {
     const { added, cooled } = this.registry.register(session);
     if (!added) return;
@@ -539,15 +441,12 @@ var SessionHub = class {
   has(sessionId) {
     return this.registry.has(sessionId);
   }
-  /** 这个 id 是被冷却掉的（而不是从来没存在过）吗 */
   isCooled(sessionId) {
     return this.registry.isCooled(sessionId);
   }
-  /** 不认识的会话按 idle 报 —— 调用方要区分的话先问 `has()` */
   stateOf(sessionId) {
     return this.registry.get(sessionId)?.state ?? "idle";
   }
-  /** Hub 手里这些会话此刻的样子。Map 的插入序 = 注册序 */
   listSessions() {
     return [...this.registry.all()].map(([id, entry]) => ({
       id,
@@ -560,14 +459,6 @@ var SessionHub = class {
       lastFinish: entry.lastFinish
     }));
   }
-  /**
-   * 把一个会话从 Hub 里摘掉（`DELETE /api/sessions/:id`）。
-   *
-   * 收尾按 §4.3 那套：**放弃**挂起的请求（不是逐个 deny）+ 中止在跑的回合 +
-   * 丢掉排队的消息。删掉的会话不进冷却名单 —— 它是真没了，不是被挤走。
-   *
-   * @returns Hub 里本来有没有它
-   */
   unregister(sessionId) {
     const entry = this.registry.remove(sessionId);
     if (!entry) return false;
@@ -580,20 +471,9 @@ var SessionHub = class {
     }
     return true;
   }
-  /** 当前活着的 SSE 连接数。给 `/api/config` 和用例看 */
   get connectionCount() {
     return this.sinks.size;
   }
-  /**
-   * 接一条 SSE 连接。
-   *
-   * 同步完成三件事，顺序不能换：先 `connected`（把响应头刷出去、证明流通了），
-   * 再按 `Last-Event-ID` 补发或回 `stream-reset`，最后才登记进扇出集合 ——
-   * 反过来的话补发和实时帧会交织，页面上就是一段乱序的对话。
-   *
-   * @param lastEventId 客户端带上来的断点。省略 = 全新的流（历史归 GET /messages）
-   * @returns 取消订阅。**幂等**，连接关闭和服务 close 会各调一次
-   */
   subscribe(sink, lastEventId) {
     sink(this.connectionFrame({ type: "connected" }));
     if (lastEventId !== void 0) {
@@ -614,24 +494,6 @@ var SessionHub = class {
       if (this.sinks.size === 0) this.armGrace();
     };
   }
-  /**
-   * 同进程旁听广播（方案 54 §三）。**不是一条连接。**
-   *
-   * 和 `subscribe()` 的差别不是「少发一帧」，是它整条不进那套连接语义：
-   *
-   * - **不进 `sinks`**：不计入 `connectionCount`，不影响 idle-grace 的收摊
-   *   （`armGrace()` → `reap()`），也不影响 `drainQueue()` 的「全断了就丢队列」。
-   *   那三处判的是「**人**还在不在」，而旁听者是宿主的代码，不是一双眼睛
-   * - **不发 `connected`、不认 `Last-Event-ID`、不从环形缓冲补帧**：补帧机制存在的
-   *   理由是网线断过一段，而同进程的函数调用不会丢帧。真要历史就走
-   *   `GET /api/sessions/:id/messages`，和浏览器同一条路
-   *
-   * 收到的是**和 SSE 上同一个信封对象**（同一个 `seq`），所以「宿主看到的和浏览器
-   * 看到的是同一条流」不需要额外的对齐机制。四种状态怎么映射到宿主界面上的一枚灯，
-   * 那是宿主的产品决定，不在这里做。
-   *
-   * @returns 取消旁听。**幂等** —— 多调几次不会误删后来注册的同一个函数
-   */
   observe(sink) {
     if (this.closed) return () => {
     };
@@ -643,21 +505,6 @@ var SessionHub = class {
       this.observers.delete(sink);
     };
   }
-  /**
-   * 发一条消息。会话空闲就立刻开一轮，否则**排队**（方案 30 §2.3 第 4 条）。
-   *
-   * 排队而不是并发：`AgentSession` 的历史累积发生在 `run()` 的末尾，两轮并发跑
-   * 会让历史顺序变成不确定的 —— 那不是「偶尔乱序」，是每次重开会话看到的对话
-   * 都可能不一样。**不同会话之间不受这条限制**，它们各跑各的。
-   *
-   * 这是对方案 20 验收第 7 条（「running 时第二个 POST 直接 409」）的**有意
-   * 修改**：那时只有一个会话，409 是唯一能给的答复；现在排队和「不交织」
-   * 这个不变量并不冲突，而 409 会逼每个客户端自己实现一遍重试。
-   *
-   * @param decorate 给这一轮的事件流套一层（见 {@link TurnDecorator}）。
-   *   自定义斜杠命令的工具收窄和临时模型走的就是它 —— Hub 自己不认识命令这个概念，
-   *   只负责把这个函数**跟着消息一路带到轮次真正开始的那一刻**（排队也带着）。
-   */
   start(sessionId, message, decorate) {
     const entry = this.registry.get(sessionId);
     if (!entry) {
@@ -673,15 +520,6 @@ var SessionHub = class {
     this.beginTurn(entry, queued);
     return { ok: true, queued: false };
   }
-  /**
-   * 中止本轮，并**丢掉排在后面的消息**。
-   *
-   * 排队的一起丢是刻意的：用户按下「停」要的是「现在别干了」，而不是
-   * 「停掉这一轮然后立刻开始下一轮」—— 后者的表现是按了停之后 agent 又动起来了。
-   *
-   * @returns 是否真有一轮在跑（**只看这个**，丢掉的队列不算）。
-   *          `false` 表示这一轮本来就没在跑，不是失败
-   */
   abort(sessionId) {
     const entry = this.registry.get(sessionId);
     if (!entry) return false;
@@ -690,20 +528,12 @@ var SessionHub = class {
     entry.controller.abort();
     return true;
   }
-  /** 补拉挂起的审批 —— 新连上来的页面靠它把弹层恢复出来（§4.3） */
   listPending(sessionId) {
     return this.registry.get(sessionId)?.relay.listPending() ?? [];
   }
-  /** 补拉挂起的提问（方案 34 验收 9）。与 `listPending` 同构 */
   listPendingQuestions(sessionId) {
     return this.registry.get(sessionId)?.questions.listPending() ?? [];
   }
-  /**
-   * 答复一个审批。
-   *
-   * @returns `false` = 这个 requestId 不认识（重复答复 / 上一轮的 ID / 已被放弃）。
-   *          调用方该回 404 而不是 500：用户在两个标签页上各点一下就会走到这里。
-   */
   respondApproval(requestId, outcome, note) {
     const sessionId = this.requestOwner.get(requestId);
     const entry = sessionId === void 0 ? void 0 : this.registry.get(sessionId);
@@ -714,16 +544,6 @@ var SessionHub = class {
     this.syncApprovalState(entry);
     return true;
   }
-  /**
-   * 答复一个提问（方案 34）。
-   *
-   * **另一个方法而不是给 `respondApproval` 加个联合入参**：两者的载荷没有交集，
-   * 合成一个之后路由层要先猜「这个 requestId 是审批还是提问」，
-   * 而猜错的表现是一个拼错的答案被判成合法的 `deny`。
-   *
-   * @returns `false` = 这个 requestId 不认识（重复答复 / 上一轮的 / 已被放弃）。
-   *          调用方回 404，同审批。
-   */
   respondQuestion(requestId, answer) {
     const sessionId = this.requestOwner.get(requestId);
     const entry = sessionId === void 0 ? void 0 : this.registry.get(sessionId);
@@ -734,12 +554,6 @@ var SessionHub = class {
     this.syncApprovalState(entry);
     return true;
   }
-  /**
-   * 收摊：撤掉倒计时、放弃所有挂起的审批、中止所有在跑的回合。
-   *
-   * 进程收到 SIGINT 时立即调它（§4.3 最后一行），之后宿主再 `dispose()`。
-   * 幂等。
-   */
   shutdown() {
     if (this.closed) return;
     this.closed = true;
@@ -748,17 +562,6 @@ var SessionHub = class {
     this.sinks.clear();
     this.observers.clear();
   }
-  // -------------------------------------------------------------------------
-  // 私有：发帧
-  // -------------------------------------------------------------------------
-  /**
-   * 广播一帧：占一个全局序号、进环形缓冲、扇出给所有连接和旁听者。
-   *
-   * **回传发出去的那个信封**（调用方绝大多数不看）。这是「一轮跑了多久」
-   * 唯一合法的取数口：`clock` 上钉着「每产出一个信封恰好读一次」的不变量
-   * （见 `sessions/registry.ts` 的 `lastActiveTick`），想知道某一帧的时刻
-   * 只能从那一帧上拿，**不许再读一次挂钟**。
-   */
   publish(sessionId, event) {
     const frame = { seq: ++this.seq, sessionId, ts: this.clock(), event };
     this.ring.push(frame);
@@ -766,30 +569,14 @@ var SessionHub = class {
     for (const sink of this.observers) sink(frame);
     return frame;
   }
-  /** 连接级帧：`seq: 0`、没有 `sessionId`、不进缓冲、不写 SSE 的 `id:` */
   connectionFrame(event) {
     return { seq: 0, ts: this.clock(), event };
   }
-  /**
-   * 状态迁移。**只在真的变了的时候发帧** —— 否则并行审批会刷出一串重复状态。
-   *
-   * 回传那一帧的时刻（没发帧时 undefined），给 {@link beginTurn} 记回合起点用。
-   */
   setState(entry, state) {
     if (entry.state === state) return void 0;
     entry.state = state;
     return this.publish(entry.session.sessionId, { type: "session-state", state }).ts;
   }
-  /**
-   * 按「还挂着几条请求」把状态摆正。
-   *
-   * 只在回合真的在跑的时候动（`controller !== null`）：回合已经收尾之后
-   * 状态该是 idle，这里不能把它拽回 running。
-   *
-   * **审批优先于提问**：两者同时挂着时报 `awaiting-approval`。理由是界面上
-   * 审批层压在提问层上面（它是安全边界，不该被一个选择题挡住），
-   * 而状态栏那句话得和用户眼前看到的那个框对上。
-   */
   syncApprovalState(entry) {
     if (!entry.controller) return;
     if (entry.relay.pendingCount > 0) {
@@ -798,15 +585,6 @@ var SessionHub = class {
     }
     this.setState(entry, entry.questions.pendingCount > 0 ? "awaiting-question" : "running");
   }
-  // -------------------------------------------------------------------------
-  // 私有：跑一轮
-  // -------------------------------------------------------------------------
-  /**
-   * 开一轮：换一副新的登记表、拉起中止闸、广播状态、然后驱动。
-   *
-   * 状态帧必须在 `start()` 返回前就广播出去：POST 拿到 202 之后前端立刻可能
-   * 再问一次状态，而第二个标签页只靠这一帧才知道「现在正在跑」。
-   */
   beginTurn(entry, queued) {
     entry.relay = new ApprovalRelay();
     entry.questions = new QuestionRelay();
@@ -816,18 +594,6 @@ var SessionHub = class {
     entry.turnStartedAt = this.setState(entry, "running") ?? null;
     void this.drive(entry, queued);
   }
-  /**
-   * 独占那个 for-await，把事件扇出去。
-   *
-   * `serializeStream` 负责把 `approval-request` 里的闭包摘成 `requestId` 并登记
-   * 进 relay —— 这一段是 runtime 现成的，不在这里重写一遍。
-   *
-   * ## `decorate` 套在**最里面**，紧贴 `run()`
-   *
-   * 顺序不能换：那一层管的是「这一轮引擎能看见哪些工具、用哪个模型」，
-   * 而 `serializeStream` 只是把事件里的闭包摘掉 —— 套反了的话，收窄会在
-   * 序列化那一层进出，而真正跑工具的 `run()` 在它外面，等于整层白做。
-   */
   async drive(entry, queued) {
     const sessionId = entry.session.sessionId;
     const signal = entry.controller?.signal;
@@ -856,12 +622,6 @@ var SessionHub = class {
       this.drainQueue(entry);
     }
   }
-  /**
-   * 一轮跑完，把排在后面的那条接上（方案 30 §2.3 第 4 条）。
-   *
-   * 三个前提缺一不可，缺了就是「浏览器早就关了，服务端自己接着聊」：
-   * 会话还在表里（没被删）、Hub 没收摊、且**还有连接活着**。
-   */
   drainQueue(entry) {
     if (this.closed || !this.registry.has(entry.session.sessionId)) return;
     if (this.sinks.size === 0) {
@@ -871,9 +631,6 @@ var SessionHub = class {
     const next = this.registry.dequeue(entry);
     if (next !== void 0) this.beginTurn(entry, next);
   }
-  // -------------------------------------------------------------------------
-  // 私有：全断之后的收尾（§4.3）
-  // -------------------------------------------------------------------------
   armGrace() {
     if (this.closed || this.graceTimer) return;
     this.graceTimer = setTimeout(() => {
@@ -887,13 +644,6 @@ var SessionHub = class {
     clearTimeout(this.graceTimer);
     this.graceTimer = null;
   }
-  /**
-   * 放弃挂起的审批并中止在跑的回合。
-   *
-   * **`abandon()` 而不是逐个 `deny`**：前者一个 promise 都不 resolve，随后的
-   * `abort()` 让流收尾，引擎侧的 finally 才去兜底 —— 模型看到的是「这一轮被中止
-   * 了」而不是「用户否了我五次」。后者会让模型换个方式再试一遍。
-   */
   reap() {
     if (this.sinks.size > 0 && !this.closed) return;
     for (const [, entry] of this.registry.all()) {
@@ -967,13 +717,13 @@ function sendJson(res, status, body, extra = {}) {
 function sendError(res, status, code, message, extra = {}) {
   sendJson(res, status, { error: { code, message } }, extra);
 }
-function sendUnknownSession(res, sessionId) {
-  sendError(res, 404, "unknown-session", `\u6CA1\u6709\u4F1A\u8BDD ${sessionId}`);
+function sendUnknownSession(res, sessionId, lang) {
+  sendError(res, 404, "unknown-session", t("web.unknown_session", { id: sessionId }, lang));
 }
 function baseHeaders() {
   return { ...BASE_HEADERS };
 }
-async function readJsonBody(req, limit = JSON_BODY_LIMIT) {
+async function readJsonBody(req, limit = JSON_BODY_LIMIT, lang) {
   const chunks = [];
   let size = 0;
   try {
@@ -982,19 +732,31 @@ async function readJsonBody(req, limit = JSON_BODY_LIMIT) {
       size += buf.length;
       if (size > limit) {
         req.destroy();
-        return { ok: false, status: 413, message: `\u8BF7\u6C42\u4F53\u8D85\u8FC7 ${limit} \u5B57\u8282` };
+        return {
+          ok: false,
+          status: 413,
+          message: t("web.body_too_large", { limit }, lang)
+        };
       }
       chunks.push(buf);
     }
   } catch (err) {
-    return { ok: false, status: 400, message: `\u8BFB\u53D6\u8BF7\u6C42\u4F53\u5931\u8D25\uFF1A${describe(err)}` };
+    return {
+      ok: false,
+      status: 400,
+      message: t("web.body_read_failed", { reason: describe(err) }, lang)
+    };
   }
   const text = Buffer.concat(chunks).toString("utf8");
   if (text.trim().length === 0) return { ok: true, value: {} };
   try {
     return { ok: true, value: JSON.parse(text) };
   } catch (err) {
-    return { ok: false, status: 400, message: `\u8BF7\u6C42\u4F53\u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${describe(err)}` };
+    return {
+      ok: false,
+      status: 400,
+      message: t("web.body_bad_json", { reason: describe(err) }, lang)
+    };
   }
 }
 function describe(err) {
@@ -1003,7 +765,6 @@ function describe(err) {
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
-
 // src/assets.ts
 var INLINE_ARTIFACT_TYPES = /* @__PURE__ */ new Map([
   [".png", "image/png"],
@@ -1087,9 +848,9 @@ function resolveStaticPath(webRoot, pathname) {
     return null;
   }
 }
-function placeholderPage(version) {
+function placeholderPage(version, lang) {
   return `<!doctype html>
-<html lang="zh-CN">
+<html lang="${t("web.placeholder_html_lang", void 0, lang)}">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width,initial-scale=1">
@@ -1104,10 +865,21 @@ code{background:#1b2027;padding:.1rem .35rem;border-radius:3px}
 </head>
 <body><main>
 <h1>Epoch Agent Web \xB7 ${escapeHtml(version)}</h1>
-<p>\u670D\u52A1\u7AEF\u5DF2\u5C31\u7EEA\uFF0C\u9274\u6743 cookie \u5DF2\u4E0B\u53D1\u3002<strong>\u524D\u7AEF\u4EA7\u7269\u5C1A\u672A\u6784\u5EFA</strong>\uFF0C
-\u5148\u8DD1\u4E00\u6B21 <code>pnpm build</code>\u3002</p>
-<p>\u73B0\u5728\u53EF\u4EE5\u76F4\u63A5\u7528 REST / SSE\uFF1A<code>GET /api/health</code>\u3001<code>GET /api/config</code>\u3001
-<code>GET /api/events</code>\u3002</p>
+<p>${t("web.placeholder_ready", void 0, lang)}${t(
+    "web.placeholder_needs_build",
+    {
+      no_build: `<strong>${t("web.placeholder_no_build", void 0, lang)}</strong>`,
+      cmd: "<code>pnpm build</code>"
+    },
+    lang
+  )}</p>
+<p>${t(
+    "web.placeholder_rest",
+    {
+      endpoints: ["/api/health", "/api/config", "/api/events"].map((path) => `<code>GET ${path}</code>`).join(t("web.placeholder_endpoint_sep", void 0, lang))
+    },
+    lang
+  )}</p>
 </main></body></html>`;
 }
 function escapeHtml(text) {
@@ -1125,25 +897,26 @@ function builtinConnectors(tools) {
   return [...counts.entries()].map(([name, toolCount]) => ({ name, toolCount })).sort((a, b) => a.name.localeCompare(b.name));
 }
 function toWireRole(role, notices) {
+  const cutOf = (kind) => notices.find((n) => n.role === role.name && n.kind === kind)?.cut ?? [];
   return {
     name: role.name,
     description: role.description,
     source: role.source,
-    // `?? null` 而不是 `?? []`：不给 tools 的角色是「不限」，空数组是
-    // 「一个都不给」。合并成同一个值之后，`general` 会显示成一个废掉的角色
     tools: role.tools ?? null,
+    skills: role.skills ?? null,
     maxTurns: role.maxTurns ?? null,
-    toolsCut: notices.find((n) => n.role === role.name)?.cut ?? []
+    toolsCut: cutOf("tools"),
+    skillsCut: cutOf("skills")
   };
 }
-function toWireSkill(skill) {
+function toWireSkill(skill, residency) {
   const description = skillIndexDescription(skill.description);
   return {
     name: skill.name,
     category: skill.category || "general",
     description,
-    // 索引里的那一行是 `- <名字>: <描述>`，按它整行估才是这条技能的真实占用
-    tokens: estimateIndexTokens(`- ${skill.name}: ${description}`),
+    tokens: estimateIndexTokens(`    - ${skill.name}: ${description}`),
+    residency,
     scope: skill.scope,
     type: skill.type
   };
@@ -1159,22 +932,18 @@ function toWireMcp(server) {
     toolCount: server.toolCount,
     reconnectAttempts: server.reconnectAttempts,
     ...server.lastError ? { lastError: server.lastError } : {},
-    // **原样转发，这一层不判也不补**：来源是装配层的结论（`connectAll(…, source)`），
-    // 在这儿再猜一次（比如「名字里有 `__` 就算宿主的」）等于给同一件事第二个答案
     source: server.source
   };
 }
-function collectCapabilities(runtime, tools, bound) {
+function collectCapabilities(runtime, tools, bound, role) {
+  const residency = runtime.skillIndexResidency(role);
   return {
     roles: runtime.agentRoles.map((r) => toWireRole(r, runtime.agentRoleNotices)),
-    skills: runtime.skills.map(toWireSkill),
+    skills: runtime.skills.map((s) => toWireSkill(s, residency.get(s.name) ?? "indexed")),
     builtinConnectors: builtinConnectors(tools),
     mcpServers: runtime.mcpServers.map(toWireMcp),
     project: {
       root: bound?.workspace.root ?? null,
-      // 没绑工作区时报 `false` 而不是 `true`：界面拿它决定要不要画那句
-      // 「不受信任的目录连读都不读」，而没有工作区时那句话是对的
-      // —— 项目层确实一个字都没读
       trusted: bound?.trust.trusted ?? false
     }
   };
@@ -1201,8 +970,6 @@ function toWireCommand(def) {
   return {
     name: def.name,
     description: def.description,
-    // 没写就不带这个键（不是空串）：空串会被画成一个空的参数提示位，
-    // 于是「这条命令不吃参数」和「作者忘了写提示」看起来一样
     ...def.argumentHint ? { argumentHint: def.argumentHint } : {}
   };
 }
@@ -1247,14 +1014,179 @@ function replaceLeadingText(message, prompt) {
   const head = { type: "text", text: prompt };
   return [head, ...message.slice(1)];
 }
-function toWireSandbox(iso) {
+var MAX_CANDIDATES = 20;
+var MAX_CANDIDATE_LIMIT = 50;
+function visibilityOf(ctx, sessionId) {
+  const root = ctx.runtime.workspaces.of(sessionId)?.projectContext.rootDir;
+  return {
+    currentSessionId: sessionId,
+    ...root ? { workspaceCwd: root } : {},
+    allWorkspaces: ctx.runtime.config.sessionSearch?.allWorkspaces === true
+  };
+}
+function toWireCandidate(row) {
+  return {
+    sessionId: row.sessionId,
+    title: row.title,
+    ...row.cwd ? { cwd: row.cwd } : {},
+    updatedAt: row.updatedAt,
+    messageCount: row.messageCount,
+    sameWorkspace: row.sameWorkspace
+  };
+}
+function toWireReference(part) {
+  const { type: _type, text: _text, ...rest } = part;
+  return rest;
+}
+function candidateQuery(rawUrl) {
+  const params = new URL(rawUrl ?? "/", "http://127.0.0.1").searchParams;
+  const asked = Number.parseInt(params.get("limit") ?? "", 10);
+  const limit = Number.isFinite(asked) && asked > 0 ? Math.min(asked, MAX_CANDIDATE_LIMIT) : MAX_CANDIDATES;
+  return { query: params.get("q")?.trim() ?? "", limit };
+}
+function listReferenceCandidates(ctx, res, sessionId, rawUrl, lang) {
+  const references = ctx.runtime.sessionReferences;
+  if (!references) {
+    return sendError(
+      res,
+      503,
+      "no-session-store",
+      t("web.reference_store_unavailable", void 0, lang)
+    );
+  }
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  const { query, limit } = candidateQuery(rawUrl);
+  const rows = references.candidates({ ...visibilityOf(ctx, sessionId), query, limit });
+  sendJson(res, 200, {
+    candidates: rows.map(toWireCandidate)
+  });
+}
+function workspaceRootOf(ctx, sessionId) {
+  return ctx.runtime.workspaces.of(sessionId)?.projectContext.rootDir ?? null;
+}
+function listFileCandidates(ctx, res, sessionId, rawUrl, lang) {
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  const root = workspaceRootOf(ctx, sessionId);
+  if (!root) {
+    return sendError(
+      res,
+      409,
+      "no-workspace",
+      t("web.file_candidates_no_workspace", void 0, lang)
+    );
+  }
+  const { query, limit } = candidateQuery(rawUrl);
+  const result = ctx.runtime.workspaceFiles.candidates(query, limit, root);
+  if (!result) {
+    return sendError(
+      res,
+      503,
+      "file-list-unavailable",
+      t("web.file_list_unavailable", void 0, lang)
+    );
+  }
+  sendJson(res, 200, {
+    candidates: result.candidates.map((path) => ({ path })),
+    unmentionable: result.unmentionable,
+    truncated: result.truncated
+  });
+}
+function attachMentions(ctx, sessionId, message) {
+  const text = leadingText2(message);
+  if (text === null) return { message, references: [], files: [] };
+  const mentions = extractAllMentions(text);
+  if (mentions.files.length === 0 && mentions.sessions.length === 0) {
+    return { message, references: [], files: [] };
+  }
+  const parts = [];
+  let used = 0;
+  const fileReceipts = [];
+  for (const [index, path] of mentions.files.entries()) {
+    const part = index >= MAX_ATTACH_FILES ? { type: "file", path, omitted: "over-limit" } : readOneFile(ctx, sessionId, path, used);
+    parts.push(part);
+    if (part.text !== void 0) used += utf8ByteLength(part.text);
+    fileReceipts.push(toWireFileReference(part));
+  }
+  const refParts = [];
+  for (const [index, ref] of mentions.sessions.entries()) {
+    if (index >= MAX_SESSION_REFS) {
+      refParts.push({ type: "session", ref, omitted: "too-many" });
+      continue;
+    }
+    const outcome = resolveOne(ctx, sessionId, ref, used);
+    refParts.push(outcome);
+    if (outcome.text !== void 0) used += utf8ByteLength(outcome.text);
+  }
+  parts.push(...refParts);
+  return {
+    message: [...parts, ...asParts(message)],
+    references: refParts.map(toWireReference),
+    files: fileReceipts
+  };
+}
+function readOneFile(ctx, sessionId, path, usedBytes) {
+  const remaining = MAX_ATTACH_TOTAL_BYTES - usedBytes;
+  if (remaining <= 0) return { type: "file", path, omitted: "over-limit" };
+  const budget = Math.min(MAX_ATTACH_BYTES, remaining);
+  const root = workspaceRootOf(ctx, sessionId);
+  if (!root) return { type: "file", path, omitted: "denied" };
+  const out = ctx.runtime.workspaceFiles.readFile(path, root);
+  if (!out.ok) {
+    return {
+      type: "file",
+      path,
+      omitted: out.reason,
+      ...out.bytes === void 0 ? {} : { bytes: out.bytes }
+    };
+  }
+  if (out.bytes <= budget) {
+    return { type: "file", path, text: out.text, bytes: out.bytes };
+  }
+  const raw = new TextEncoder().encode(out.text);
+  return {
+    type: "file",
+    path,
+    text: new TextDecoder().decode(raw.slice(0, budget)),
+    truncatedTo: budget,
+    bytes: out.bytes
+  };
+}
+function resolveOne(ctx, sessionId, ref, usedBytes) {
+  const references = ctx.runtime.sessionReferences;
+  if (!references) return { type: "session", ref, omitted: "invalid-reference" };
+  const resolved = references.resolve({ ...visibilityOf(ctx, sessionId), ref });
+  if (resolved.reason || !resolved.sessionId) {
+    return { type: "session", ref, omitted: resolved.reason ?? "invalid-reference" };
+  }
+  const surface = references.surface(resolved.sessionId);
+  if (!surface) return { type: "session", ref, omitted: "invalid-reference" };
+  return attachSessionSurface(ref, surface, usedBytes).part;
+}
+function toWireFileReference(part) {
+  const { type: _type, text: _text, ...rest } = part;
+  return rest;
+}
+function leadingText2(message) {
+  if (typeof message === "string") return message;
+  const first = message[0];
+  return first && first.type === "text" ? first.text : null;
+}
+function asParts(message) {
+  return typeof message === "string" ? [{ type: "text", text: message }] : message;
+}
+function toWireSandbox(iso, terminalEnabled) {
   return {
     level: iso.level,
     backend: iso.backend,
     reason: iso.reason,
     platform: iso.platform,
     covers: SANDBOX_COVERS,
-    excludes: SANDBOX_EXCLUDES
+    excludes: SANDBOX_EXCLUDES,
+    terminalEnabled
   };
 }
 function toWireRule(rule) {
@@ -1274,6 +1206,16 @@ function toWireAudit(audit) {
   }));
   return { rows, dropped: audit.dropped };
 }
+function toWireApproval(row) {
+  return {
+    id: row.id,
+    toolName: row.toolName,
+    target: row.target,
+    scope: row.scope,
+    decision: row.decision,
+    at: row.createdAt
+  };
+}
 function toWireManaged(managed) {
   return {
     present: managed.present,
@@ -1284,15 +1226,12 @@ function toWireManaged(managed) {
 }
 var PERMISSIONS_UNAVAILABLE = {
   level: "unknown",
-  // 配置里那一档同样说不出来（方案 56 §1.3）：`PermissionsControl` 整个没起来，
-  // 而这两格都是从它上面读的。⚠️ **不在这儿回落成 `default`** —— 那是一个
-  // 看起来确切、其实没人核过的值；`unknown` 会被界面原样印出来，正是要的效果。
-  // `configuredLayer` 跟着报 `unknown`：那一档的含义就是「分不出」
   configured: "unknown",
   configuredLayer: "unknown",
   rules: [],
   shadows: [],
-  managed: { present: false, path: "", rulesOnly: false, bypassDisabled: false }
+  managed: { present: false, path: "", rulesOnly: false, bypassDisabled: false },
+  cached: []
 };
 function toWirePolicy(policy) {
   const dirs = policy.dirs.map((d) => ({
@@ -1324,36 +1263,19 @@ function toWireTrustList(known, workspaces, currentRoot) {
 function collectSecurity(runtime, workspaces, bound, session) {
   const perms = runtime.permissions;
   return {
-    // `null` 是第三种状态（沙箱没建起来），不是「仅进程隔离」
-    sandbox: runtime.isolation ? toWireSandbox(runtime.isolation) : null,
+    sandbox: runtime.isolation ? toWireSandbox(runtime.isolation, runtime.config.sandbox?.terminal !== false) : null,
     permission: perms ? {
-      /*
-       * **这个会话**那一档，取不到才退回进程那一份。
-       *
-       * 退回去的那一支不是兜底措辞，是一句真话：这个进程没在跑那段会话
-       * （只剩历史 / 被冷却）时，「它此刻是哪一档」没有答案，而进程那一档
-       * 是这台机器上此刻真在生效的那个。判据逐字同 `permission.ts` 的
-       * `permissionState()`。⚠️ 下面四样**刻意不跟着分家**，见文件头。
-       */
       level: session?.level() ?? perms.level(),
-      /*
-       * 配置里那一档（方案 56 §1.3）。**刻意不跟着上面那一格走会话** ——
-       * 它答的是「新会话开出来是哪一档」，一个进程一份。这两格经常真的
-       * 不同（在底栏改过一次档就当场分家），而那正是界面画两行的理由：
-       * 只画一行的话，「此刻在跑的是 bypass」和「配置里赢在②的是 default」
-       * 会被混成一句话
-       */
       configured: perms.configured().level,
       configuredLayer: perms.configured().layer,
       rules: perms.rules().map(toWireRule),
       shadows: perms.shadows().map(toWireShadow),
-      managed: toWireManaged(perms.managed())
+      managed: toWireManaged(perms.managed()),
+      cached: perms.approvals().map(toWireApproval)
     } : PERMISSIONS_UNAVAILABLE,
     workspace: bound ? toWireSecurityWorkspace(bound) : null,
     knownWorkspaces: toWireTrustList(workspaces.known(), workspaces, bound?.workspace.root ?? null),
     policy: toWirePolicy(runtime.policy),
-    // 权限层起不来时是**空账**而不是别的什么：没有权限层就等于什么都没判过，
-    // 而那句话是真的（同 runtime 那边 `audit()` 的兜底，两处必须一致）
     audit: perms ? toWireAudit(perms.audit()) : { rows: [], dropped: 0 }
   };
 }
@@ -1371,7 +1293,6 @@ function unknownRoleToHttp(role, lang) {
     message: t("web.session_unknown_role", { role }, lang)
   };
 }
-
 // src/sessions/revive.ts
 function persistedDecision(row) {
   if (!row) return null;
@@ -1385,7 +1306,6 @@ function reviveSession(ctx, sessionId, lang) {
   const outcome = ctx.runtime.sessionFactory.revive({
     sessionId,
     decision: persistedDecision(ctx.runtime.sessions?.get(sessionId) ?? null),
-    // 绑不上那句 `detail` 跟着请求语言走，同建会话那条路（方案 58 PR-2）
     ...lang === void 0 ? {} : { lang }
   });
   if (outcome.ok) {
@@ -1486,23 +1406,18 @@ function collectTools(runtime, sessionId, session) {
     for (const row of runtime.permissions?.gates(level) ?? []) gates.set(row.name, row);
   }
   const tools = runtime.tools.map((tool) => {
-    const gate = gates.get(tool.name);
+    const gate2 = gates.get(tool.name);
     return {
       name: tool.name,
       description: tool.description,
       source: tool.source,
-      // 类型只有 `gates` 那一路知道（core 的 `mapOperation()` 三级回退）。
-      // 拿不到时回 `command` ——「最保守的那一类」而不是「最常见的那一类」：
-      // 这一格此刻只被界面拿去分组，而分错组的代价远小于按工具名前缀猜一个
-      // （那种猜法在第一个不按前缀命名的工具上就错，判据在 `WireToolSummary.source`）
-      type: gate?.type ?? "command",
+      type: gate2?.type ?? "command",
       calls: counts.get(tool.name) ?? 0,
-      ...gate === void 0 ? {} : { gate: toWireGate(gate) }
+      ...gate2 === void 0 ? {} : { gate: toWireGate(gate2) }
     };
   });
   return { tools, level: level ?? "unknown" };
 }
-
 // src/api.ts
 var APPROVAL_OUTCOMES = /* @__PURE__ */ new Set([
   "allow-once",
@@ -1524,39 +1439,20 @@ function config(ctx, res, lang) {
     workspace: bound ? toWireSessionWorkspace(bound) : null,
     knownWorkspaces: toWireKnownWorkspaces(runtime.workspaces.known()),
     usageScope: runtime.usageScope,
-    // 原样转发，**一个字段都不在这儿重算**：窗口是 `AgentLoop` 手里那一份本体、
-    // 阈值走的是 core 那个「装配层唯一的入口」。在这一层拿 `runtime.config` 拼一份
-    // 出来，就是给同一条线第二个说法（同 `artifactsRoot` 那条判据）
     compression: runtime.compression,
-    // 没配就**不带这个键**（决定 8）。写成 `?? null` 之类的话，浏览器那边
-    // 「配没配上限」就要靠判空值，而金额显不显示正是挂在这一个判断上
     ...runtime.config.budget?.maxCostUsd !== void 0 ? { maxCostUsd: runtime.config.budget.maxCostUsd } : {},
-    // 品牌词标同上：**没配就不带这个键**（决定 19）。侧栏那一格「显不显示」
-    // 挂在这一个判断上 —— 给一个 `null` 或者空串的话，「宿主没给」就成了
-    // 浏览器要自己解读的东西，而它的硬约束是不给就什么都不画
     ...runtime.config.brand !== void 0 ? { brand: runtime.config.brand } : {},
     provider: runtime.providerInfo,
     tools: runtime.tools,
-    // 请求带了语言、而且宿主给得出「换个语言说一遍」时才走那条；两个条件缺一个
-    // 就是 `diagnosticList`（进程语言）——判据在 `WebRuntimeView.diagnosticsIn` 上
     diagnostics: (lang && runtime.diagnosticsIn?.(lang)) ?? runtime.diagnosticList,
     about: {
-      // 版本从 `ctx.version` 取 —— 那是**宿主传进来的**那一个（`/api/health` 回的
-      // 也是它）。在这儿读 `package.json` 会给同一个数第二个说法，而嵌入宿主的
-      // 版本号本来就不是我们的版本号
       version: ctx.version,
       nodeVersion: process.version,
       platform: `${process.platform}-${process.arch}`,
       homeDir: runtime.config.homeDir,
       dbPath: runtime.config.dbPath,
-      // 缺省档（字面量 `default`）时**不带这个键** —— 判据在 `WireAbout.profile`：
-      // 恒发一行「配置档：default」对没换过档的人是噪声
       ...runtime.config.profile !== "default" ? { profile: runtime.config.profile } : {}
     },
-    // 绑在回环之外了没有（2026-08-18）。**原样转发 `ctx.lanExposed`，这一层不判
-    // 也不改名** —— 它是一个事实，不是一个结论（判据在 `WireConfigResponse.lanExposed`
-    // 上）。今天的消费方只有能力页那张「新建身份」：它据此在**按下去之前**画出
-    // 「这一档下建不了」，而真正拦住那一发的是 `role-add.ts` 里那道 403
     lanExposed: ctx.lanExposed
   });
 }
@@ -1565,22 +1461,15 @@ function listSessions(ctx, res, query, _lang) {
     ctx.hub.listSessions(),
     ctx.runtime.sessions,
     query ?? null,
-    // 每行带上**这个进程手里**那份绑定（决定 18）—— 侧栏按「任务 / 空间」分组要用它。
-    // ⚠️ 手里没有不等于那一行就说不出地盘：会话库 v7 之后落盘的那次决定会接着答
-    // （顺序在 `sessions/summary.ts` 的 `toWireSummaryWorkspace` 那张表上）
     (id) => ctx.runtime.workspaces.of(id),
-    // 以及它以什么身份跑（2026-08-18）。只有活着的那几行答得出 —— 身份只活在
-    // 内存里。⚠️ **2026-08-19 起这句话和 `workspace` 那格不再是同一条边界**：
-    // 那一格落盘了，这一格没有 —— 那是一笔明写的欠账，记在
-    // `WireSessionSummary.role` 上（复活的旧会话会以 `general` 接着跑）
     (id) => ctx.runtime.sessionFactory.get(id)?.role ?? null
   );
   sendJson(res, 200, { sessions });
 }
-function getSession(ctx, res, sessionId, _lang) {
+function getSession(ctx, res, sessionId, lang) {
   const hub = ctx.hub.listSessions().find((one) => one.id === sessionId);
   const row = ctx.runtime.sessions?.get(sessionId) ?? null;
-  if (hub === void 0 && row === null) return sendUnknownSession(res, sessionId);
+  if (hub === void 0 && row === null) return sendUnknownSession(res, sessionId, lang);
   sendJson(res, 200, {
     session: toWireSummary(sessionId, hub, row, {
       workspace: ctx.runtime.workspaces.of(sessionId),
@@ -1608,11 +1497,11 @@ async function deleteSession(ctx, res, sessionId, lang) {
     );
   }
   const outcome = await catalog.delete(sessionId);
-  if (!outcome.deleted && !inHub) return sendUnknownSession(res, sessionId);
+  if (!outcome.deleted && !inHub) return sendUnknownSession(res, sessionId, lang);
   sendJson(res, 200, outcome);
 }
 async function patchSession(ctx, req, res, sessionId, lang) {
-  const body = await readJsonBody(req);
+  const body = await readJsonBody(req, void 0, lang);
   if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
   const raw = asRecord(body.value).title;
   const title = typeof raw === "string" ? raw.trim() : "";
@@ -1629,7 +1518,7 @@ async function patchSession(ctx, req, res, sessionId, lang) {
     );
   }
   const row = catalog.rename(sessionId, title);
-  if (!row) return sendUnknownSession(res, sessionId);
+  if (!row) return sendUnknownSession(res, sessionId, lang);
   const hub = ctx.hub.listSessions().find((s) => s.id === sessionId);
   sendJson(res, 200, {
     session: toWireSummary(sessionId, hub, row, {
@@ -1638,9 +1527,9 @@ async function patchSession(ctx, req, res, sessionId, lang) {
     })
   });
 }
-function listMessages(ctx, res, sessionId, _lang) {
+function listMessages(ctx, res, sessionId, lang) {
   if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
-    return sendUnknownSession(res, sessionId);
+    return sendUnknownSession(res, sessionId, lang);
   }
   const messages = ctx.runtime.sessionStore?.loadMessages(sessionId) ?? [];
   sendJson(res, 200, { messages });
@@ -1652,14 +1541,14 @@ async function postMessage(ctx, req, res, sessionId, lang) {
       return sendError(res, revived.status, revived.code, revived.message);
     }
     if (!revived.ok && !ctx.hub.isCooled(sessionId)) {
-      return sendUnknownSession(res, sessionId);
+      return sendUnknownSession(res, sessionId, lang);
     }
   }
-  const body = await readJsonBody(req);
+  const body = await readJsonBody(req, void 0, lang);
   if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
   const message = parseUserContent(asRecord(body.value).message);
   if (message === null) {
-    return sendError(res, 400, "bad-message", "message \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u6216 EpochContentPart[]");
+    return sendError(res, 400, "bad-message", t("web.bad_message", void 0, lang));
   }
   const live = ctx.runtime.sessionFactory.get(sessionId);
   const picked = pickTurnRole(live, asRecord(body.value)["role"]);
@@ -1668,21 +1557,22 @@ async function postMessage(ctx, req, res, sessionId, lang) {
     return sendError(res, mapped.status, mapped.code, mapped.message);
   }
   const expansion = expandUserContent(ctx.runtime, message, live?.model ?? null, picked.role);
-  const started = ctx.hub.start(sessionId, expansion.message, expansion.decorate);
+  const attached = attachMentions(ctx, sessionId, expansion.message);
+  const started = ctx.hub.start(sessionId, attached.message, expansion.decorate);
   if (started.ok) {
     return sendJson(res, 202, {
       accepted: true,
       queued: started.queued,
-      // 不是命令时**整个键缺席**（不是空对象）：界面据此区分「认成命令了、
-      // 只是没话要说」和「原样发给模型了」，见 `WireSendMessageResponse.command`
-      ...expansion.notice ? { command: expansion.notice } : {}
+      ...expansion.notice ? { command: expansion.notice } : {},
+      ...attached.references.length > 0 ? { references: attached.references } : {},
+      ...attached.files.length > 0 ? { files: attached.files } : {}
     });
   }
-  if (started.reason === "unknown-session") return sendUnknownSession(res, sessionId);
+  if (started.reason === "unknown-session") return sendUnknownSession(res, sessionId, lang);
   if (started.reason === "cooled") {
     return sendError(res, 409, "session-cooled", t("web.session_cooled", void 0, lang));
   }
-  sendError(res, 409, "busy", `\u4F1A\u8BDD\u6B63\u5728 ${started.state}\uFF0C\u6392\u961F\u5DF2\u6EE1\uFF0C\u7B49\u8FD9\u4E00\u8F6E\u7ED3\u675F\u518D\u53D1`, {
+  sendError(res, 409, "busy", t("web.session_busy", { state: started.state }, lang), {
     "X-Epoch-Turn-State": started.state
   });
 }
@@ -1692,40 +1582,45 @@ function pickTurnRole(live, raw) {
   if (!live?.roles.has(name)) return { ok: false, detail: name };
   return { ok: true, role: { control: live.roles, name } };
 }
-function abortSession(ctx, res, sessionId, _lang) {
-  if (!ctx.hub.has(sessionId)) return sendUnknownSession(res, sessionId);
+function abortSession(ctx, res, sessionId, lang) {
+  if (!ctx.hub.has(sessionId)) return sendUnknownSession(res, sessionId, lang);
   sendJson(res, 200, { aborted: ctx.hub.abort(sessionId) });
 }
-function listApprovals(ctx, res, sessionId, _lang) {
-  if (!ctx.hub.has(sessionId)) return sendUnknownSession(res, sessionId);
+function listApprovals(ctx, res, sessionId, lang) {
+  if (!ctx.hub.has(sessionId)) return sendUnknownSession(res, sessionId, lang);
   sendJson(res, 200, {
     state: ctx.hub.stateOf(sessionId),
     approvals: ctx.hub.listPending(sessionId)
   });
 }
-async function respondApproval(ctx, req, res, requestId, _lang) {
-  const body = await readJsonBody(req);
+async function respondApproval(ctx, req, res, requestId, lang) {
+  const body = await readJsonBody(req, void 0, lang);
   if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
   const payload = asRecord(body.value);
   const outcome = payload.outcome;
   if (typeof outcome !== "string" || !APPROVAL_OUTCOMES.has(outcome)) {
-    return sendError(res, 400, "bad-outcome", `outcome \u5FC5\u987B\u662F ${[...APPROVAL_OUTCOMES].join("/")}`);
+    return sendError(
+      res,
+      400,
+      "bad-outcome",
+      t("web.bad_outcome", { choices: [...APPROVAL_OUTCOMES].join("/") }, lang)
+    );
   }
   const note = typeof payload.note === "string" ? payload.note : void 0;
   if (!ctx.hub.respondApproval(requestId, outcome, note)) {
-    return sendError(res, 404, "unknown-request", `\u5BA1\u6279 ${requestId} \u5DF2\u88AB\u7B54\u590D\u6216\u5DF2\u5931\u6548`);
+    return sendError(res, 404, "unknown-request", t("web.approval_gone", { id: requestId }, lang));
   }
   sendJson(res, 200, { resolved: true });
 }
-function listQuestions(ctx, res, sessionId, _lang) {
-  if (!ctx.hub.has(sessionId)) return sendUnknownSession(res, sessionId);
+function listQuestions(ctx, res, sessionId, lang) {
+  if (!ctx.hub.has(sessionId)) return sendUnknownSession(res, sessionId, lang);
   sendJson(res, 200, {
     state: ctx.hub.stateOf(sessionId),
     questions: ctx.hub.listPendingQuestions(sessionId)
   });
 }
-async function respondQuestion(ctx, req, res, requestId, _lang) {
-  const body = await readJsonBody(req);
+async function respondQuestion(ctx, req, res, requestId, lang) {
+  const body = await readJsonBody(req, void 0, lang);
   if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
   const payload = asRecord(body.value);
   if (!isQuestionAnswerMap(payload.answers)) {
@@ -1733,7 +1628,7 @@ async function respondQuestion(ctx, req, res, requestId, _lang) {
       res,
       400,
       "bad-answers",
-      'answers \u5FC5\u987B\u662F\u300C\u95EE\u53E5 \u2192 \u5B57\u7B26\u4E32\u6216\u5B57\u7B26\u4E32\u6570\u7EC4\u300D\u7684\u5BF9\u8C61\u3002\u7B54\u4E0D\u4E0A\u6765\u5C31\u53D1 {"answers":{},"skipped":true}'
+      t("web.bad_answers", { json: '{"answers":{},"skipped":true}' }, lang)
     );
   }
   const answer = {
@@ -1741,47 +1636,44 @@ async function respondQuestion(ctx, req, res, requestId, _lang) {
     ...payload.skipped === true ? { skipped: true } : {}
   };
   if (!ctx.hub.respondQuestion(requestId, answer)) {
-    return sendError(res, 404, "unknown-request", `\u63D0\u95EE ${requestId} \u5DF2\u88AB\u7B54\u590D\u6216\u5DF2\u5931\u6548`);
+    return sendError(res, 404, "unknown-request", t("web.question_gone", { id: requestId }, lang));
   }
   sendJson(res, 200, { resolved: true });
 }
-function listCapabilities(ctx, res, sessionId, _lang) {
+function listCapabilities(ctx, res, sessionId, lang) {
   if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
-    return sendUnknownSession(res, sessionId);
+    return sendUnknownSession(res, sessionId, lang);
   }
   const payload = collectCapabilities(
     ctx.runtime,
     ctx.runtime.tools,
-    ctx.runtime.workspaces.of(sessionId)
+    ctx.runtime.workspaces.of(sessionId),
+    ctx.runtime.sessionFactory.get(sessionId)?.role?.name ?? null
   );
   sendJson(res, 200, payload);
 }
-function listCommands(ctx, res, sessionId, _lang) {
+function listCommands(ctx, res, sessionId, lang) {
   if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
-    return sendUnknownSession(res, sessionId);
+    return sendUnknownSession(res, sessionId, lang);
   }
   const commands = ctx.runtime.commands.list.map(toWireCommand);
   sendJson(res, 200, { commands });
 }
-function getSecurity(ctx, res, sessionId, _lang) {
+function getSecurity(ctx, res, sessionId, lang) {
   if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
-    return sendUnknownSession(res, sessionId);
+    return sendUnknownSession(res, sessionId, lang);
   }
   const payload = collectSecurity(
     ctx.runtime,
     ctx.runtime.workspaces,
     ctx.runtime.workspaces.of(sessionId),
-    // **档位按会话取**（2026-08-16 那一轮之后 `PermissionManager` 一个会话一份）。
-    // 少了这个实参，这一屏印的是引导会话那一档，而那张卡的色带跟着一起答错人 ——
-    // 判据全文在 `security.ts` 文件头。工厂手里没有（只剩历史）时传 null，
-    // 投影自己退回进程那一份
     ctx.runtime.sessionFactory.get(sessionId)?.permissions ?? null
   );
   sendJson(res, 200, payload);
 }
-function getTools(ctx, res, sessionId, _lang) {
+function getTools(ctx, res, sessionId, lang) {
   if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
-    return sendUnknownSession(res, sessionId);
+    return sendUnknownSession(res, sessionId, lang);
   }
   const payload = collectTools(
     ctx.runtime,
@@ -1790,17 +1682,17 @@ function getTools(ctx, res, sessionId, _lang) {
   );
   sendJson(res, 200, payload);
 }
-function getSettings(ctx, res, sessionId, _lang) {
+function getSettings(ctx, res, sessionId, lang) {
   if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
-    return sendUnknownSession(res, sessionId);
+    return sendUnknownSession(res, sessionId, lang);
   }
   sendJson(res, 200, collectSettings(ctx.runtime, sessionId));
 }
 async function writeSetting(ctx, req, res, sessionId, lang) {
   if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
-    return sendUnknownSession(res, sessionId);
+    return sendUnknownSession(res, sessionId, lang);
   }
-  const body = await readJsonBody(req);
+  const body = await readJsonBody(req, void 0, lang);
   if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
   const input = readSettingWriteBody(asRecord(body.value));
   if (!input.ok) {
@@ -1823,22 +1715,20 @@ async function writeSetting(ctx, req, res, sessionId, lang) {
   }
   sendJson(res, 200, toWireSettingsWrite(report));
 }
-function getArtifacts(ctx, res, sessionId, _lang) {
+function getArtifacts(ctx, res, sessionId, lang) {
   if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
-    return sendUnknownSession(res, sessionId);
+    return sendUnknownSession(res, sessionId, lang);
   }
   const root = ctx.runtime.workspaces.of(sessionId)?.workspace.root ?? null;
   const changes = root === null ? [] : ctx.runtime.sessionStore?.fileChanges(sessionId, root) ?? [];
   sendJson(res, 200, { changes, root });
 }
-function getArtifact(ctx, res, sessionId, name, _lang) {
+function getArtifact(ctx, res, sessionId, name, lang) {
   const path = resolveArtifactPath(ctx.artifactsRoot, sessionId, name);
-  if (!path) return sendError(res, 404, "not-found", "artifact \u4E0D\u5B58\u5728");
+  if (!path) return sendError(res, 404, "not-found", t("web.artifact_missing", void 0, lang));
   const { type, inline } = artifactDisposition(path);
   sendFile(res, path, {
     "Content-Type": type,
-    // 不认识的类型一律 attachment：让浏览器把 artifact 当 HTML 渲染，
-    // 等于在本服务的同源里执行任意脚本，而这个源上挂着全部 agent API
     "Content-Disposition": inline ? "inline" : `attachment; filename="${encodeURIComponent(name)}"`
   });
 }
@@ -1847,11 +1737,42 @@ function parseUserContent(raw) {
   if (Array.isArray(raw) && raw.length > 0) return raw;
   return null;
 }
+async function revokeApprovalCache(ctx, req, res, sessionId, lang) {
+  if (!ctx.hub.has(sessionId)) return sendUnknownSession(res, sessionId, lang);
+  const perms = ctx.runtime.permissions;
+  if (!perms) {
+    return sendError(
+      res,
+      503,
+      "no-permission-layer",
+      t("web.permission_unavailable", void 0, lang)
+    );
+  }
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const id = asRecord(body.value)["id"];
+  if (typeof id !== "string" || id === "") {
+    return sendError(res, 400, "bad-id", t("web.approval_cache_bad_id", void 0, lang));
+  }
+  const result = perms.revokeApproval(id);
+  if (!result.ok && result.reason === "no-permission-layer") {
+    return sendError(
+      res,
+      503,
+      "no-permission-layer",
+      t("web.permission_unavailable", void 0, lang)
+    );
+  }
+  const payload = {
+    revoked: result.ok,
+    cached: perms.approvals().map(toWireApproval)
+  };
+  sendJson(res, 200, payload);
+}
 function toWireCheckpoint(summary) {
   return {
     turnIndex: summary.turnIndex,
     createdAt: summary.createdAt,
-    // 用户自己那句原话，**照原样过** —— 它不是我们写的字，不进任何 catalog
     preview: summary.preview,
     fileCount: summary.fileCount,
     incomplete: summary.incomplete
@@ -1865,7 +1786,6 @@ function toWirePreview(preview) {
     turnIndex: preview.turnIndex,
     createdAt: preview.createdAt,
     preview: preview.preview,
-    // 引擎算好的那个布尔，**不在这一层从 cursor 重算** —— 镜像上压根没有 cursor
     canRewindConversation: preview.canRewindConversation,
     incomplete: preview.incomplete,
     files: preview.files.map(toWirePlan),
@@ -1878,9 +1798,6 @@ function toWireOutcome(outcome) {
     deleted: [...outcome.deleted],
     recreated: [...outcome.recreated],
     skippedConflicts: [...outcome.skippedConflicts],
-    // 成功时**整个不给这个键**（同 `note` / `skipped` 的规矩）：契约里它就是
-    // 「可以不给」，而 `failed: undefined` 会被 JSON.stringify 抹掉之后长得一样，
-    // 写成条件展开是把「没有失败」这件事说明白
     ...outcome.failed === void 0 ? {} : { failed: outcome.failed }
   };
 }
@@ -1917,8 +1834,6 @@ function readRewindInput(body, lang) {
   const overwrite = raw === void 0 ? void 0 : raw;
   return {
     ok: true,
-    // 空数组和「没给」在引擎那边是一回事（`new Set(opts.overwrite ?? [])`），
-    // 但这里照样原样转：客户端发了空数组是它在说「一个都不覆盖」，那是一句话
     value: { turnIndex, scope, ...overwrite === void 0 ? {} : { overwrite } }
   };
 }
@@ -1980,12 +1895,200 @@ async function rewind(ctx, req, res, sessionId, lang) {
   const { turnIndex, scope, overwrite } = input.value;
   const result = await control.rewind(turnIndex, {
     scope,
-    // ⚠️ **只转用户点过头的那几个**。这里绝不能顺手把 `preview.conflicts` 并进去 ——
-    // 那正是「全部覆盖」那个按钮的等价物，而它毁掉的是用户自己刚写的东西
     ...overwrite === void 0 ? {} : { overwrite }
   });
   sendJson(res, 200, toWireRewindResult(result));
 }
+// src/context-budget.ts
+function toolSourceLookup(tools) {
+  const byName = new Map(tools.map((tool) => [tool.name, tool.source]));
+  return (name) => byName.get(name);
+}
+function contextBreakdownOf(ctx, live) {
+  const historyText = live.session.getHistory().map((m) => m.content).join("\n");
+  return {
+    breakdown: live.agent.contextBreakdown({
+      historyText,
+      toolSource: toolSourceLookup(ctx.runtime.tools)
+    })
+  };
+}
+function getContext(ctx, res, sessionId, lang) {
+  const live = ctx.runtime.sessionFactory.get(sessionId);
+  if (!live) return sendUnknownSession(res, sessionId, lang);
+  sendJson(res, 200, contextBreakdownOf(ctx, live));
+}
+async function postCompact(ctx, req, res, sessionId, lang) {
+  const live = ctx.runtime.sessionFactory.get(sessionId);
+  if (!live) return sendUnknownSession(res, sessionId, lang);
+  const body = await readJsonBody(req);
+  const raw = body.ok ? asRecord(body.value)["instruction"] : void 0;
+  const instruction = typeof raw === "string" && raw.trim() ? raw.trim() : void 0;
+  const result = await live.session.compact(instruction);
+  sendJson(res, 200, {
+    ran: result.ran,
+    before: result.before,
+    after: result.after,
+    ...result.reason === void 0 ? {} : { reason: result.reason }
+  });
+}
+function str(value) {
+  return typeof value === "string" ? value : null;
+}
+function rounds(value) {
+  return typeof value === "number" && Number.isInteger(value) ? value : null;
+}
+function parseCreate(body, lang) {
+  const raw = asRecord(body);
+  const objective = str(raw.objective);
+  if (objective === null) {
+    return { ok: false, message: t("web.goal_bad_objective", void 0, lang) };
+  }
+  if (raw.maxRounds === void 0) return { ok: true, value: { objective } };
+  const maxRounds = rounds(raw.maxRounds);
+  if (maxRounds === null) {
+    return { ok: false, message: t("web.goal_bad_rounds", void 0, lang) };
+  }
+  return { ok: true, value: { objective, maxRounds } };
+}
+function parseUpdate(body, lang) {
+  const raw = asRecord(body);
+  const action = str(raw.action);
+  if (action === null || !WIRE_GOAL_ACTIONS.includes(action)) {
+    return {
+      ok: false,
+      message: t(
+        "web.goal_bad_action",
+        { action: action ?? String(raw.action), known: WIRE_GOAL_ACTIONS.join(" / ") },
+        lang
+      )
+    };
+  }
+  if (action === "pause") return { ok: true, value: { action: "pause" } };
+  if (action === "resume") return { ok: true, value: { action: "resume" } };
+  if (action === "edit") {
+    const objective = str(raw.objective);
+    return objective === null ? { ok: false, message: t("web.goal_bad_objective", void 0, lang) } : { ok: true, value: { action: "edit", objective } };
+  }
+  if (action === "budget") {
+    const maxRounds = rounds(raw.maxRounds);
+    return maxRounds === null ? { ok: false, message: t("web.goal_bad_rounds", void 0, lang) } : { ok: true, value: { action: "budget", maxRounds } };
+  }
+  const evidence = str(raw.evidence);
+  return evidence === null ? { ok: false, message: t("web.goal_bad_evidence", void 0, lang) } : { ok: true, value: { action: "complete", evidence } };
+}
+// src/goal/handlers.ts
+var BLOCKED_SCAN_LIMIT = 50;
+function goalsOf(ctx) {
+  return ctx.runtime.goalCatalog;
+}
+function limitsOf() {
+  return {
+    defaultMaxRounds: DEFAULT_GOAL_MAX_ROUNDS,
+    maxRounds: MAX_GOAL_MAX_ROUNDS,
+    maxObjectiveChars: MAX_OBJECTIVE_CHARS,
+    maxReasonChars: MAX_REASON_CHARS
+  };
+}
+function toWireGoal(goal) {
+  return {
+    objective: goal.objective,
+    phase: goal.phase,
+    ...goal.block ? { block: { code: goal.block.code, message: goal.block.message } } : {},
+    maxRounds: goal.maxRounds,
+    roundsUsed: goal.roundsUsed,
+    ...goal.completeEvidence === void 0 ? {} : { completeEvidence: goal.completeEvidence },
+    createdAt: goal.createdAt,
+    updatedAt: goal.updatedAt
+  };
+}
+function toWriteResponse(result) {
+  return result.ok ? { ok: true, goal: toWireGoal(result.goal) } : { ok: false, goal: null, reason: result.reason };
+}
+function gate(ctx, res, sessionId, lang) {
+  const goals = goalsOf(ctx);
+  if (!goals) {
+    sendError(res, 503, "no-goal-store", t("web.goal_store_unavailable", void 0, lang));
+    return null;
+  }
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    sendUnknownSession(res, sessionId);
+    return null;
+  }
+  return goals;
+}
+function getGoal(ctx, res, sessionId, lang) {
+  const goals = gate(ctx, res, sessionId, lang);
+  if (!goals) return;
+  const goal = goals.current(sessionId);
+  sendJson(res, 200, {
+    goal: goal ? toWireGoal(goal) : null,
+    limits: limitsOf()
+  });
+}
+async function createGoal(ctx, req, res, sessionId, lang) {
+  const goals = gate(ctx, res, sessionId, lang);
+  if (!goals) return;
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const parsed = parseCreate(body.value, lang);
+  if (!parsed.ok) return sendError(res, 400, "bad-goal", parsed.message);
+  const { objective, maxRounds } = parsed.value;
+  const result = maxRounds === void 0 ? goals.create(sessionId, objective) : goals.create(sessionId, objective, maxRounds);
+  sendJson(res, 200, toWriteResponse(result));
+}
+async function patchGoal(ctx, req, res, sessionId, lang) {
+  const goals = gate(ctx, res, sessionId, lang);
+  if (!goals) return;
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const parsed = parseUpdate(body.value, lang);
+  if (!parsed.ok) return sendError(res, 400, "bad-goal", parsed.message);
+  sendJson(res, 200, toWriteResponse(apply(goals, sessionId, parsed.value)));
+}
+function apply(goals, sessionId, patch) {
+  switch (patch.action) {
+    case "edit":
+      return goals.edit(sessionId, patch.objective);
+    case "budget":
+      return goals.setBudget(sessionId, patch.maxRounds);
+    case "pause":
+      return goals.pause(sessionId);
+    case "resume":
+      return goals.resume(sessionId);
+    case "complete":
+      return goals.complete(sessionId, patch.evidence);
+    default: {
+      const exhaustive = patch;
+      return exhaustive;
+    }
+  }
+}
+async function deleteGoal(ctx, res, sessionId, lang) {
+  const goals = gate(ctx, res, sessionId, lang);
+  if (!goals) return;
+  const result = goals.clear(sessionId);
+  sendJson(
+    res,
+    200,
+    result.ok ? { ok: true, cleared: result.cleared } : { ok: false, cleared: false, reason: result.reason }
+  );
+}
+function listBlockedGoals(ctx, res, _lang) {
+  const goals = goalsOf(ctx);
+  const rows = ctx.runtime.sessions?.list(BLOCKED_SCAN_LIMIT) ?? [];
+  if (!goals) return sendJson(res, 200, { items: [] });
+  const items = [];
+  for (const row of rows) {
+    const goal = goals.current(row.id);
+    if (!goal || goal.phase !== "blocked") continue;
+    items.push({ sessionId: row.id, sessionTitle: row.title, goal: toWireGoal(goal) });
+  }
+  items.sort(
+    (a, b) => a.goal.updatedAt === b.goal.updatedAt ? a.sessionId < b.sessionId ? -1 : 1 : a.goal.updatedAt - b.goal.updatedAt
+  );
+  sendJson(res, 200, { items });
+}
 function readConfig(ctx, res, lang) {
   if (ctx.lanExposed) return sendLanExposed(res, lang);
   const outcome = ctx.runtime.mcp.readConfig();
@@ -2051,8 +2154,6 @@ async function applyConfig(ctx, req, res, lang) {
     changes: outcome.changes.map((change) => ({
       name: change.name,
       action: change.action,
-      // 投影借的是能力页那一栏**同一个函数**（`toWireMcp`）：这几行会被界面
-      // 直接换进那张列表，形状对不上的话它们在那一栏里长得和别的行不一样
       ...change.status === void 0 ? {} : { server: toWireMcp(change.status) },
       ...change.reason === void 0 ? {} : { reason: change.reason }
     }))
@@ -2167,12 +2268,7 @@ function getModel(ctx, res, sessionId, _lang) {
   const { runtime } = ctx;
   const selection = runtime.sessionFactory.get(sessionId)?.model.get();
   sendJson(res, 200, {
-    // 问不到就是**这个进程没在跑这段会话**（只剩历史 / 被冷却了 / provider 层
-    // 起不来）。三种情形合成一个 null 照旧是刻意的：界面在三档下该做的事
-    // 一模一样（不画菜单）
     selection: selection ? toWireSelection(selection) : null,
-    // 空串当没配。`configured` 的语义是「`reset` 会把你送回哪儿」，
-    // 而一个空字符串答不了这个问题 —— 那时菜单上那一项整个不画
     configured: runtime.config.model || null
   });
 }
@@ -2190,10 +2286,6 @@ async function setModel(ctx, req, res, sessionId, lang) {
     return sendError(res, 400, "bad-model", t("web.model_bad_request", void 0, lang));
   }
   const selectionCtx = {
-    // **问的是这段会话自己的历史**（2026-08-16）。上一版读的是
-    // `ctx.runtime.session` —— 引导会话那一段。这条路只对引导会话开放的时候
-    // 那是对的；现在它对任意一个活着的会话开放，拿别人的历史当闸门的表现是：
-    // A 那段里有图片，于是 B 换一个不认图的模型会被一道莫名其妙的闸拦下来
     hasImages: sessionHasImages(live.session),
     ...input.usedTokens === void 0 ? {} : { usedTokens: input.usedTokens }
   };
@@ -2202,8 +2294,6 @@ async function setModel(ctx, req, res, sessionId, lang) {
     ok: true,
     selection: toWireSelection(result.selection),
     contextLength: result.contextLength,
-    // **空数组也照发**，不判长度：那是界面的事。在这儿吞掉一个空数组
-    // 等于让「没有代价」和「这个字段不存在」在契约上长得一样
     caveats: result.caveats
   } : { ok: false, rejection: result.rejection };
   sendJson(res, 200, payload);
@@ -2248,7 +2338,6 @@ async function setPlanMode(ctx, req, res, sessionId, lang) {
     changed
   });
 }
-
 // src/permission.ts
 var REFUSAL = {
   "managed-bypass-disabled": "managed"
@@ -2259,12 +2348,7 @@ function blockedLevels(managed) {
 function permissionState(ctx, sessionId) {
   const perms = ctx.runtime.sessionFactory.get(sessionId)?.permissions ?? null;
   return {
-    // 权限层没起来 / 这个进程没在跑这段会话时退回 `config.permission`，
-    // 那仍然是一句真话：那时配置里那一档就是这台机器上的档位
     level: perms?.level() ?? ctx.runtime.config.permission,
-    // 改得动 = 这个会话在这个进程里活着、**而且**它有权限层。两种成因合成一个
-    // 布尔，判据在 `WirePermissionState.editable` 上：界面在两档下要做的事
-    // 一模一样（画回只读事实）
     editable: perms !== null,
     blocked: perms ? blockedLevels(perms.managed()) : [],
     planMode: planModeState(ctx, sessionId)
@@ -2303,7 +2387,6 @@ async function setPermission(ctx, req, res, sessionId, lang) {
   const payload = result.ok ? { ok: true, changed: state.level !== before, state } : { ok: false, refused: REFUSAL[result.reason], changed: false, state };
   sendJson(res, 200, payload);
 }
-
 // src/plan.ts
 function getPlan(ctx, res, sessionId, _lang) {
   if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
@@ -2319,10 +2402,190 @@ function getPlan(ctx, res, sessionId, _lang) {
 function normalize(markdown) {
   return markdown?.trim() ? markdown : null;
 }
-function toWireProvider(option) {
+function toWireCounts(counts) {
+  return {
+    commands: counts.commands,
+    roles: counts.roles,
+    skills: counts.skills,
+    hooks: counts.hooks,
+    denyRules: counts.denyRules,
+    mcpServers: counts.mcpServers
+  };
+}
+function toWirePluginEntry(entry) {
+  return {
+    name: entry.name,
+    version: entry.version,
+    source: entry.source,
+    sourceType: entry.sourceType,
+    path: entry.path,
+    linked: entry.linked,
+    enabled: entry.enabled,
+    installedAt: entry.installedAt,
+    marketplace: entry.marketplace ?? null,
+    active: entry.active,
+    counts: entry.counts ? toWireCounts(entry.counts) : null
+  };
+}
+function toWirePluginHit(hit, installedNames) {
+  return {
+    marketplace: hit.marketplace,
+    ref: hit.ref,
+    name: hit.entry.name,
+    description: hit.entry.description ?? "",
+    category: hit.entry.category ?? null,
+    keywords: [...hit.entry.keywords ?? []],
+    sourceType: hit.sourceType ?? null,
+    installable: hit.installable,
+    installed: installedNames.has(hit.entry.name)
+  };
+}
+function toWirePreview2(preview) {
+  const { manifest, source, inventory } = preview;
+  return {
+    name: manifest.name,
+    version: manifest.version,
+    description: manifest.description ?? "",
+    source: source.raw,
+    sourceType: source.type,
+    checksum: source.sha256 ?? null,
+    author: manifest.author?.name ?? null,
+    homepage: manifest.homepage ?? null,
+    commands: [...inventory.commands],
+    roles: [...inventory.roles],
+    skills: [...inventory.skills],
+    hooks: inventory.hooks.map((h) => ({ type: h.type, count: h.count })),
+    denyRules: inventory.denyRules,
+    mcpServers: [...inventory.mcpServers],
+    ignoredBuckets: [...inventory.ignoredBuckets],
+    hasJsTools: inventory.jsTools,
+    conflict: preview.conflict ? { name: preview.conflict.name, version: preview.conflict.version } : null
+  };
+}
+function controlOf(ctx, res, lang) {
+  const control = ctx.runtime.plugins;
+  if (!control) {
+    sendError(res, 503, "no-plugin-control", t("web.plugin_not_available", void 0, lang));
+    return null;
+  }
+  return control;
+}
+function refusedByLan(ctx, res, lang) {
+  if (!ctx.lanExposed) return false;
+  sendError(
+    res,
+    403,
+    "plugin-write-lan-exposed",
+    t("web.plugin_write_lan_exposed", void 0, lang)
+  );
+  return true;
+}
+function fieldOf(payload, key) {
+  const value = payload[key];
+  return typeof value === "string" ? value.trim() : "";
+}
+function listPlugins(ctx, res, lang) {
+  const control = controlOf(ctx, res, lang);
+  if (!control) return;
+  const installed = control.list();
+  const installedNames = new Set(installed.map((p) => p.name));
+  sendJson(res, 200, {
+    installed: installed.map(toWirePluginEntry),
+    hits: control.search().map((hit) => toWirePluginHit(hit, installedNames)),
+    pendingRestart: control.pendingRestart
+  });
+}
+function sendPreview(res, outcome) {
+  if (!outcome.ok) {
+    return sendJson(res, 200, {
+      ok: false,
+      preview: null,
+      token: null,
+      reason: outcome.reason,
+      detail: outcome.detail
+    });
+  }
+  sendJson(res, 200, {
+    ok: true,
+    preview: toWirePreview2(outcome.preview),
+    token: outcome.token,
+    reason: null,
+    detail: null
+  });
+}
+async function previewPluginInstall(ctx, req, res, lang) {
+  if (refusedByLan(ctx, res, lang)) return;
+  const control = controlOf(ctx, res, lang);
+  if (!control) return;
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  sendPreview(res, await control.preview(fieldOf(asRecord(body.value), "ref"), lang));
+}
+async function previewPluginUpdate(ctx, req, res, lang) {
+  if (refusedByLan(ctx, res, lang)) return;
+  const control = controlOf(ctx, res, lang);
+  if (!control) return;
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  sendPreview(res, await control.previewUpdate(fieldOf(asRecord(body.value), "name"), lang));
+}
+function sendAction(res, control, outcome) {
+  if (!outcome.ok) {
+    return sendJson(res, 200, {
+      ok: false,
+      entry: null,
+      pendingRestart: control.pendingRestart,
+      detail: outcome.detail,
+      reason: outcome.reason
+    });
+  }
+  const fresh = "record" in outcome ? control.list().find((p) => p.name === outcome.record.name) : void 0;
+  sendJson(res, 200, {
+    ok: true,
+    entry: fresh ? toWirePluginEntry(fresh) : null,
+    pendingRestart: control.pendingRestart,
+    detail: "detail" in outcome ? outcome.detail : null,
+    reason: null
+  });
+}
+async function installPluginFromMarket(ctx, req, res, lang) {
+  if (refusedByLan(ctx, res, lang)) return;
+  const control = controlOf(ctx, res, lang);
+  if (!control) return;
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const payload = asRecord(body.value);
+  sendAction(
+    res,
+    control,
+    await control.install(fieldOf(payload, "ref"), fieldOf(payload, "token"), lang)
+  );
+}
+async function updateInstalledPlugin(ctx, req, res, lang) {
+  if (refusedByLan(ctx, res, lang)) return;
+  const control = controlOf(ctx, res, lang);
+  if (!control) return;
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const payload = asRecord(body.value);
+  sendAction(
+    res,
+    control,
+    await control.update(fieldOf(payload, "name"), fieldOf(payload, "token"), lang)
+  );
+}
+async function uninstallPluginByName(ctx, req, res, lang) {
+  if (refusedByLan(ctx, res, lang)) return;
+  const control = controlOf(ctx, res, lang);
+  if (!control) return;
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  sendAction(res, control, await control.uninstall(fieldOf(asRecord(body.value), "name"), lang));
+}
+function toWireProvider(option, lang) {
   return {
     type: option.type,
-    label: option.label,
+    label: providerLabel(option, lang),
     envVar: option.envVar,
     hasKey: option.hasKey
   };
@@ -2335,9 +2598,9 @@ function toWireSuggestions(view) {
     status: view.status
   };
 }
-function listProviders(ctx, res, _lang) {
+function listProviders(ctx, res, lang) {
   sendJson(res, 200, {
-    providers: ctx.runtime.modelCatalog.providers().map(toWireProvider)
+    providers: ctx.runtime.modelCatalog.providers().map((o) => toWireProvider(o, lang))
   });
 }
 async function discoverProviderModels(ctx, req, res, type, lang) {
@@ -2369,19 +2632,14 @@ async function addRole(ctx, req, res, lang) {
       name: typeof payload["name"] === "string" ? payload["name"].trim() : "",
       description: typeof payload["description"] === "string" ? payload["description"].trim() : "",
       ...typeof payload["prompt"] === "string" ? { prompt: payload["prompt"] } : {},
-      // ⚠️ `tools` 用 `Array.isArray` 而不是「有没有给」：一个空数组是**一档真实的
-      // 意思**（一个工具都不给），而 `undefined` 是「不限」。两者合成同一个值之后，
-      // 一个用户明确清空了工具表的身份会拿到全部工具
       ...Array.isArray(payload["tools"]) ? { tools: stringList2(payload["tools"]) } : {},
+      ...Array.isArray(payload["skills"]) ? { skills: stringList2(payload["skills"]) } : {},
       ...typeof payload["maxTurns"] === "number" ? { maxTurns: payload["maxTurns"] } : {}
     },
     lang
   );
   if (!outcome.ok) return sendError(res, ...addFailure2(outcome.reason, outcome.detail, lang));
   sendJson(res, 200, {
-    // 投影走 `toWireRole`，**和能力页那一栏同一个函数** —— 各写一份的话，
-    // 刚插进列表的那一行和刷新之后那一行会在 `tools: null` / `toolsCut` 这种
-    // 事上长得不一样，而那是这一屏最容易被当成 bug 的差别
     role: toWireRole(outcome.role, ctx.runtime.agentRoleNotices),
     path: outcome.path
   });
@@ -2529,7 +2787,7 @@ function optionals(raw, lang) {
 function bypassAcknowledged(body) {
   return asRecord(body)["bypassAcknowledged"] === true;
 }
-function parseCreate(body, lang) {
+function parseCreate2(body, lang) {
   const raw = asRecord(body);
   const name = raw["name"];
   const prompt = raw["prompt"];
@@ -2550,12 +2808,10 @@ function parseCreate(body, lang) {
   if (!rest.ok) return rest;
   return {
     ok: true,
-    // 顺序有意义：`rest` 里那几格已经收窄过，五个必填的**后写**，
-    // 于是一个把 `name` 同时写在两处的请求体不会得到两个答案
     value: { ...rest.value, name, prompt, permission, trigger, maxBudgetUsd: budget }
   };
 }
-function parseUpdate(body, lang) {
+function parseUpdate2(body, lang) {
   return optionals(asRecord(body), lang);
 }
 function parseFix(body, lang) {
@@ -2565,13 +2821,17 @@ function parseFix(body, lang) {
   }
   return { ok: true, value: runId };
 }
-
 // src/schedule/handlers.ts
 var RECENT_RUNS_LIMIT = 100;
 var RUNS_LIMIT = 20;
 var MAX_RECORDING_FRAMES = 4e3;
-function schedulesOf(ctx) {
-  return ctx.runtime.schedules;
+function schedulesOf(ctx, res, lang) {
+  const control = ctx.runtime.schedules;
+  if (!control.storeAvailable) {
+    sendError(res, 503, "no-schedule-store", t("web.schedule_store_unavailable", void 0, lang));
+    return null;
+  }
+  return control;
 }
 function toWireRow(control, def) {
   return {
@@ -2589,56 +2849,71 @@ function defaultsOf() {
     allowRules: SCHEDULE_DEFAULT_ALLOWLIST.allowRules
   };
 }
-async function listSchedules(ctx, res, _lang) {
-  const control = schedulesOf(ctx);
+async function listSchedules(ctx, res, lang) {
+  const control = schedulesOf(ctx, res, lang);
+  if (!control) return;
+  const capability = await control.capability();
   const payload = {
     schedules: control.list().map((def) => toWireRow(control, def)),
-    capability: await control.capability(),
+    capability: { backend: capability.backend, canRegister: capability.canRegister },
     defaults: defaultsOf(),
     recentRuns: control.recentRuns(RECENT_RUNS_LIMIT)
   };
   sendJson(res, 200, payload);
 }
+function listPending(ctx, res, lang) {
+  const control = schedulesOf(ctx, res, lang);
+  if (!control) return;
+  const items = collectPendingApprovals(control.list(), control.recentRuns(RECENT_RUNS_LIMIT));
+  sendJson(res, 200, { items });
+}
 function getSchedule(ctx, res, id, lang) {
-  const control = schedulesOf(ctx);
+  const control = schedulesOf(ctx, res, lang);
+  if (!control) return;
   const def = control.get(id);
   if (!def) return sendNotFound(res, id, lang);
   sendJson(res, 200, { row: toWireRow(control, def) });
 }
 function listRuns(ctx, res, id, lang) {
-  const control = schedulesOf(ctx);
+  const control = schedulesOf(ctx, res, lang);
+  if (!control) return;
   if (!control.get(id)) return sendNotFound(res, id, lang);
   sendJson(res, 200, { runs: control.runs(id, RUNS_LIMIT) });
 }
 async function createSchedule(ctx, req, res, lang) {
   const body = await readJsonBody(req);
   if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
-  const parsed = parseCreate(body.value, lang);
+  const parsed = parseCreate2(body.value, lang);
   if (!parsed.ok) return sendError(res, 400, "bad-schedule", parsed.message);
-  const control = schedulesOf(ctx);
+  const control = schedulesOf(ctx, res, lang);
+  if (!control) return;
   const saved = await control.create(parsed.value, {
     bypassAcknowledged: bypassAcknowledged(body.value)
   });
   sendJson(res, 200, toSaveResponse(control, saved));
 }
 async function patchSchedule(ctx, req, res, id, lang) {
-  const control = schedulesOf(ctx);
+  const control = schedulesOf(ctx, res, lang);
+  if (!control) return;
   if (!control.get(id)) return sendNotFound(res, id, lang);
   const body = await readJsonBody(req);
   if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
-  const parsed = parseUpdate(body.value, lang);
+  const parsed = parseUpdate2(body.value, lang);
   if (!parsed.ok) return sendError(res, 400, "bad-schedule", parsed.message);
   const saved = await control.update(id, parsed.value, {
     bypassAcknowledged: bypassAcknowledged(body.value)
   });
   sendJson(res, 200, toSaveResponse(control, saved));
 }
-async function deleteSchedule(ctx, res, id, _lang) {
-  const removed = await schedulesOf(ctx).remove(id);
+async function deleteSchedule(ctx, res, id, lang) {
+  const control = schedulesOf(ctx, res, lang);
+  if (!control) return;
+  const removed = await control.remove(id);
   sendJson(res, 200, { removed });
 }
 async function runSchedule(ctx, res, id, lang) {
-  const control = schedulesOf(ctx);
+  const control = schedulesOf(ctx, res, lang);
+  if (!control) return;
   if (!control.get(id)) return sendNotFound(res, id, lang);
   const result = await control.fire(id, { manual: true });
   const payload = {
@@ -2650,7 +2925,8 @@ async function runSchedule(ctx, res, id, lang) {
   sendJson(res, 200, payload);
 }
 async function fixSchedule(ctx, req, res, id, lang) {
-  const control = schedulesOf(ctx);
+  const control = schedulesOf(ctx, res, lang);
+  if (!control) return;
   const def = control.get(id);
   if (!def) return sendNotFound(res, id, lang);
   const body = await readJsonBody(req);
@@ -2666,20 +2942,14 @@ async function fixSchedule(ctx, req, res, id, lang) {
       t("web.schedule_run_unknown", { runId: parsed.value }, lang)
     );
   }
-  const existing = new Set(def.allowRules);
-  const added = [];
-  for (const item of run.pendingApprovals) {
-    if (!item.suggestedRule || existing.has(item.suggestedRule)) continue;
-    existing.add(item.suggestedRule);
-    added.push(item.suggestedRule);
-  }
+  const added = unfixedRules(def.allowRules, run.pendingApprovals);
   if (added.length === 0) {
     return sendJson(res, 200, {
       added: [],
       row: toWireRow(control, def)
     });
   }
-  const saved = await control.update(id, { allowRules: [...existing] });
+  const saved = await control.update(id, { allowRules: [...def.allowRules, ...added] });
   const next = saved.schedule ?? def;
   sendJson(res, 200, {
     added,
@@ -2687,7 +2957,8 @@ async function fixSchedule(ctx, req, res, id, lang) {
   });
 }
 function getRecording(ctx, res, id, runId, lang) {
-  const control = schedulesOf(ctx);
+  const control = schedulesOf(ctx, res, lang);
+  if (!control) return;
   if (!control.get(id)) return sendNotFound(res, id, lang);
   const run = control.runs(id, RUNS_LIMIT).find((one) => one.id === runId);
   if (!run) {
@@ -2722,7 +2993,6 @@ function toSaveResponse(control, saved) {
 function sendNotFound(res, id, lang) {
   sendError(res, 404, "unknown-schedule", t("web.schedule_unknown", { id }, lang));
 }
-
 // src/skill-import.ts
 function pathOf(payload) {
   return typeof payload["path"] === "string" ? payload["path"].trim() : "";
@@ -2786,10 +3056,6 @@ async function importSkills(ctx, req, res, lang) {
     });
   }
   sendJson(res, 200, {
-    // 一个都没落地时**回 `ok: false`**：这一格答的是「这次导入达成了没有」，
-    // 而不是「这次请求跑通了没有」。全都撞名的那一次要是回 true，界面上会出现
-    // 一句「导入成功」加一张空列表 —— 判据同 `WireMcpReconnectResponse.ok`
-    // 那条「别从别的字段反推」
     ok: outcome.imported.length > 0,
     imported: [...outcome.imported],
     skipped: toWireIssues2(outcome.skipped),
@@ -2797,7 +3063,6 @@ async function importSkills(ctx, req, res, lang) {
     reason: null
   });
 }
-
 // src/sse.ts
 var DEFAULT_HEARTBEAT_MS = 15e3;
 function parseLastEventId(req) {
@@ -2825,13 +3090,6 @@ var SseConnection = class {
   res;
   heartbeat;
   closed = false;
-  /**
-   * 发一帧。
-   *
-   * **`seq: 0` 不写 `id:` 行**：连接级帧（`connected` / `stream-reset`）不占广播
-   * 序号，写进 `id:` 就会把这个连接的续传游标推到 0，下次重连时 `Last-Event-ID: 0`
-   * 等于说「我什么都没收到」。
-   */
   send(frame) {
     if (this.closed) return;
     const body = frame.seq > 0 ? `id: ${frame.seq}
@@ -2840,12 +3098,10 @@ var SseConnection = class {
 
 `);
   }
-  /** 注释行心跳：SSE 规范里以 `:` 开头的行被客户端忽略，纯粹用来探活 */
   ping() {
     if (this.closed) return;
     this.res.write(": ping\n\n");
   }
-  /** 幂等：客户端断开和服务端 close 会各调一次 */
   close() {
     if (this.closed) return;
     this.closed = true;
@@ -2898,14 +3154,10 @@ function workspaceAnchors(workspaces) {
   push(process.cwd(), "cwd");
   for (const one of workspaces.known()) push(one.root, "known");
   return {
-    // 锚屏不是一个目录，所以这两格是 null（判据在契约那两个字段上）
     path: null,
     parent: null,
     entries,
-    // 锚这一发**不截断**：`known` 上游就是 ≤20 条，加上 home / cwd 也就 22 行
     omitted: 0,
-    // 锚这一发也**不过滤**：三组锚是「用户自己去过的地方」，`~/.config/some-tree`
-    // 真在已知清单里的话它照样画出来 —— 那个开关管的是「往下点一层」看得见什么
     hidden: 0
   };
 }
@@ -2939,7 +3191,6 @@ function listWorkspaceDirs(workspaces, raw, opts = {}) {
       name: dirent.name,
       path: child,
       known: known.has(child),
-      // 列不开的行**照样画出来**，只是点不动 —— 藏掉的话用户会以为它不存在
       readable: canList(child),
       group: "child"
     });
@@ -2948,11 +3199,9 @@ function listWorkspaceDirs(workspaces, raw, opts = {}) {
     ok: true,
     view: {
       path,
-      // 已经在根上时 `dirname` 回它自己 —— 那时没有「上一层」可去
       parent: parentOf(path),
       entries: kept,
       omitted,
-      // 带 `?hidden=1` 那一发这一格必然是 0：那时上面那一支根本不进
       hidden
     }
   };
@@ -2978,7 +3227,6 @@ function parentOf(path) {
 function displayName2(path) {
   return basename(path) || path;
 }
-
 // src/workspace/dirs.ts
 function browseWorkspaceDirs(ctx, res, rawUrl, lang) {
   const query = new URL(rawUrl ?? "/", "http://127.0.0.1").searchParams;
@@ -3041,11 +3289,8 @@ async function createWorkspaceDir(req, res, lang) {
   }
   sendJson(res, 200, {
     entry: {
-      // `basename` 就是 `name`（上面校验过它是单段），这儿不再算一次
       name,
       path,
-      // 两个字段**钉死**，判据在 `WireCreateWorkspaceResponse` 上：刚建的空目录
-      // 必然读得开，而且它**不在**「已知工作区」清单里（这条路不记那一笔）
       readable: true,
       known: false,
       group: "child"
@@ -3155,7 +3400,6 @@ async function catFileBlob(root, sha) {
 function splitZ(text) {
   return text.split("\0").filter((s) => s.length > 0);
 }
-
 // src/workspace/diff.ts
 var MAX_DIFF_BYTES = 512 * 1024;
 var MAX_DIFF_FILES = 200;
@@ -3295,7 +3539,6 @@ function omitReason(old, fresh) {
 function isBinary(side) {
   return side.kind === "content" && side.data.subarray(0, BINARY_SNIFF_BYTES).includes(0);
 }
-
 // src/workspace/handlers.ts
 async function createSession(ctx, req, res, lang) {
   const body = await readJsonBody(req);
@@ -3327,12 +3570,7 @@ async function createSession(ctx, req, res, lang) {
   const role = typeof payload["role"] === "string" ? payload["role"].trim() : "";
   const outcome = ctx.runtime.sessionFactory.create({
     workspace: field.dir,
-    // 建会话那一路也会渲染文案（路径不对 / 目录不存在 那几句在 runtime 的
-    // `SessionWorkspaces.bind()` 里），所以 `lang` 一路递进工厂 —— 判据见
-    // `routes.ts` 文件头「三、`lang` 怎么穿」
     ...lang === void 0 ? {} : { lang },
-    // `create: true` = 别复用。只认 `=== true`：一个拼错的值该走保守那一侧
-    // （复用），而不是凭空多建一个会话出来
     reuse: payload["create"] !== true,
     ...role === "" ? {} : { role }
   });
@@ -3363,9 +3601,6 @@ function sessionWorkspace(ctx, res, sessionId, lang) {
   const state = ctx.runtime.workspaces.stateOf(sessionId);
   if (state !== "none") {
     return sendJson(res, 200, {
-      // **复用 `toWireBinding` / `toWireSessionWorkspace`**，不在这儿另拼一份：
-      // 那三处不对称（`extraRoots` / `trusted` / `skippedInstructionFiles`）少一个，
-      // 界面上就少一句决定 18 要求必须说出来的话，而编译器拦不住少发一个可选字段的投影
       binding: toWireBinding(state, ctx.runtime.workspaces.of(sessionId))
     });
   }
@@ -3393,6 +3628,12 @@ async function bindWorkspace(ctx, req, res, sessionId, lang) {
       t("web.workspace_already_decided", void 0, lang)
     );
   }
+  const turn = ctx.hub.stateOf(sessionId);
+  if (turn !== "idle") {
+    return sendError(res, 409, "busy", t("web.workspace_turn_running", void 0, lang), {
+      "X-Epoch-Turn-State": turn
+    });
+  }
   if (parsed.kind === "none") {
     ctx.runtime.workspaces.decideNone(sessionId);
     return sendJson(res, 200, {
@@ -3427,50 +3668,49 @@ async function sessionDiff(ctx, res, sessionId, _lang) {
     200,
     await collectWorkspaceDiff({
       workDir: bound.workspace.root,
-      // **这个会话自己那一份**，不是 `EpochRuntime.checkpoints`（引导会话那份）。
-      // 非 git 目录那条退路就是拿检查点当改动清单，而 `workDir` 已经是这个会话
-      // 绑的那个 —— 两样来自两个会话的话，画出来的是「A 改过的文件」挂在
-      // 「B 的根目录」下，一屏全是查无此文件。判据同三条回退端点（方案 30 §9.5）。
-      //
-      // 拿不到（被冷却过、上个进程留下的）就是 null：diff 退化成
-      // `no-workspace-history`。**空清单比错清单强**
       checkpoints: checkpointsOf(ctx, sessionId)
     })
   );
 }
-
 // src/routes.ts
-var DENY_MESSAGE = {
-  "missing-credential": "\u7F3A\u5C11\u51ED\u636E\uFF1A\u7528 epoch web \u6253\u5370\u7684\u90A3\u6761\u5E26 ?token= \u7684\u5730\u5740\u6253\u5F00",
-  "bad-token": "token \u4E0D\u5BF9\u3002\u670D\u52A1\u6BCF\u6B21\u542F\u52A8\u90FD\u4F1A\u6362\u4E00\u4E2A\uFF0C\u8BF7\u7528\u6700\u65B0\u90A3\u6761\u5730\u5740",
-  "bad-origin": "Origin \u4E0D\u88AB\u5141\u8BB8\uFF08\u9632 DNS rebinding\uFF09",
-  "bad-host": "Host \u4E0E\u672C\u670D\u52A1\u76D1\u542C\u7684\u5730\u5740\u5BF9\u4E0D\u4E0A\uFF08\u9632 DNS rebinding\uFF09"
+var DENY_KEY = {
+  "missing-credential": "web.route.deny_missing_credential",
+  "bad-token": "web.route.deny_bad_token",
+  "bad-origin": "web.route.deny_bad_origin",
+  "bad-host": "web.route.deny_bad_host"
 };
 function createRequestHandler(opts) {
   return (req, res) => {
-    dispatch(opts, req, res).catch(() => {
-      if (!res.headersSent) sendError(res, 500, "internal", "\u670D\u52A1\u7AEF\u5185\u90E8\u9519\u8BEF");
-      else res.destroy();
+    const lang = langOf(req.url);
+    dispatch(opts, req, res, lang).catch(() => {
+      if (!res.headersSent) {
+        sendError(res, 500, "internal", t("web.route.internal_error", void 0, lang));
+      } else res.destroy();
     });
   };
 }
-async function dispatch(opts, req, res) {
+async function dispatch(opts, req, res, lang) {
   const { ctx, guard } = opts;
   const pathname = pathnameOf(req.url);
   const method = (req.method ?? "GET").toUpperCase();
   if (pathname === "/api/health" && isRead(method)) return health(ctx, res);
   const verdict = guard(toAuthView(req));
   if (!verdict.ok) {
-    return sendError(res, verdict.status, verdict.reason, DENY_MESSAGE[verdict.reason]);
+    return sendError(
+      res,
+      verdict.status,
+      verdict.reason,
+      t(DENY_KEY[verdict.reason], void 0, lang)
+    );
   }
   if (verdict.setCookie) res.setHeader("Set-Cookie", verdict.setCookie);
   if (verdict.setCookie && isRead(method) && !pathname.startsWith("/api/")) {
     return redirectWithoutToken(res, req.url);
   }
   const segments = splitPath(pathname);
-  if (segments[0] === "api") return handleApi(opts, req, res, method, segments);
-  if (!isRead(method)) return methodNotAllowed(res, "GET, HEAD");
-  return handleStatic(opts, res, pathname);
+  if (segments[0] === "api") return handleApi(opts, req, res, method, segments, lang);
+  if (!isRead(method)) return methodNotAllowed(res, "GET, HEAD", lang);
+  return handleStatic(opts, res, pathname, lang);
 }
 function isRead(method) {
   return method === "GET" || method === "HEAD";
@@ -3484,9 +3724,8 @@ function splitPath(pathname) {
     }
   });
 }
-async function handleApi(opts, req, res, method, segments) {
+async function handleApi(opts, req, res, method, segments, lang) {
   const { ctx } = opts;
-  const lang = langOf(req.url);
   const [, resource, first, second, detail, tail] = segments;
   if (resource === "config" && isRead(method)) return config(ctx, res, lang);
   if (resource === "events" && method === "GET") return openStream(opts, req, res);
@@ -3494,13 +3733,13 @@ async function handleApi(opts, req, res, method, segments) {
     return handleSessions(opts, req, res, method, first, second, detail, lang);
   }
   if (resource === "approvals" && first !== void 0 && method === "POST") {
-    return respondApproval(ctx, req, res, first);
+    return respondApproval(ctx, req, res, first, lang);
   }
   if (resource === "questions" && first !== void 0 && method === "POST") {
-    return respondQuestion(ctx, req, res, first);
+    return respondQuestion(ctx, req, res, first, lang);
   }
   if (resource === "artifacts" && first !== void 0 && second !== void 0 && isRead(method)) {
-    return getArtifact(ctx, res, first, second);
+    return getArtifact(ctx, res, first, second, lang);
   }
   if (resource === "mcp" && first === "config" && second === void 0 && isRead(method)) {
     return readConfig(ctx, res, lang);
@@ -3526,8 +3765,26 @@ async function handleApi(opts, req, res, method, segments) {
   if (resource === "skills" && first === "import" && second === void 0 && method === "POST") {
     return importSkills(ctx, req, res, lang);
   }
+  if (resource === "plugins" && first === void 0 && isRead(method)) {
+    return listPlugins(ctx, res, lang);
+  }
+  if (resource === "plugins" && first === "install" && second === "preview" && method === "POST") {
+    return previewPluginInstall(ctx, req, res, lang);
+  }
+  if (resource === "plugins" && first === "install" && second === void 0 && method === "POST") {
+    return installPluginFromMarket(ctx, req, res, lang);
+  }
+  if (resource === "plugins" && first === "update" && second === "preview" && method === "POST") {
+    return previewPluginUpdate(ctx, req, res, lang);
+  }
+  if (resource === "plugins" && first === "update" && second === void 0 && method === "POST") {
+    return updateInstalledPlugin(ctx, req, res, lang);
+  }
+  if (resource === "plugins" && first === "uninstall" && second === void 0 && method === "POST") {
+    return uninstallPluginByName(ctx, req, res, lang);
+  }
   if (resource === "providers" && first === void 0 && isRead(method)) {
-    return listProviders(ctx, res);
+    return listProviders(ctx, res, lang);
   }
   if (resource === "providers" && first !== void 0 && second === "models" && method === "POST") {
     return discoverProviderModels(ctx, req, res, first, lang);
@@ -3541,73 +3798,101 @@ async function handleApi(opts, req, res, method, segments) {
   if (resource === "schedules") {
     return handleSchedules(ctx, req, res, method, first, second, detail, tail, lang);
   }
-  sendNoEndpoint(res, method, `/${segments.join("/")}`);
+  if (resource === "goals") {
+    if (first === "blocked" && second === void 0) {
+      if (isRead(method)) return listBlockedGoals(ctx, res);
+      return methodNotAllowed(res, "GET", lang);
+    }
+    return sendNoEndpoint(res, method, `/api/goals/${first ?? ""}`, lang);
+  }
+  sendNoEndpoint(res, method, `/${segments.join("/")}`, lang);
 }
 async function handleSchedules(ctx, req, res, method, scheduleId, action, runId, tail, lang) {
   if (scheduleId === void 0) {
-    if (isRead(method)) return listSchedules(ctx, res);
+    if (isRead(method)) return listSchedules(ctx, res, lang);
     if (method === "POST") return createSchedule(ctx, req, res, lang);
-    return methodNotAllowed(res, "GET, POST");
+    return methodNotAllowed(res, "GET, POST", lang);
+  }
+  if (action === void 0 && scheduleId === "pending") {
+    if (isRead(method)) return listPending(ctx, res, lang);
+    return methodNotAllowed(res, "GET", lang);
   }
   if (action === void 0) {
     if (isRead(method)) return getSchedule(ctx, res, scheduleId, lang);
     if (method === "PATCH") return patchSchedule(ctx, req, res, scheduleId, lang);
-    if (method === "DELETE") return deleteSchedule(ctx, res, scheduleId);
-    return methodNotAllowed(res, "GET, PATCH, DELETE");
+    if (method === "DELETE") return deleteSchedule(ctx, res, scheduleId, lang);
+    return methodNotAllowed(res, "GET, PATCH, DELETE", lang);
   }
   if (action === "runs") {
     if (runId === void 0 && isRead(method)) return listRuns(ctx, res, scheduleId, lang);
     if (runId !== void 0 && tail === "recording" && isRead(method)) {
       return getRecording(ctx, res, scheduleId, runId, lang);
     }
-    return methodNotAllowed(res, "GET");
+    return methodNotAllowed(res, "GET", lang);
   }
   if (action === "run" && method === "POST")
     return runSchedule(ctx, res, scheduleId, lang);
   if (action === "fix" && method === "POST") {
     return fixSchedule(ctx, req, res, scheduleId, lang);
   }
-  sendNoEndpoint(res, method, `/api/schedules/${scheduleId}`);
+  sendNoEndpoint(res, method, `/api/schedules/${scheduleId}`, lang);
 }
 async function handleSessions(opts, req, res, method, sessionId, action, detail, lang) {
   const { ctx } = opts;
   if (sessionId === void 0) {
     if (isRead(method)) return listSessions(ctx, res, searchQuery(req.url));
     if (method === "POST") return createSession(ctx, req, res, lang);
-    return methodNotAllowed(res, "GET, POST");
+    return methodNotAllowed(res, "GET, POST", lang);
   }
   if (action === void 0) {
-    if (isRead(method)) return getSession(ctx, res, sessionId);
+    if (isRead(method)) return getSession(ctx, res, sessionId, lang);
     if (method === "DELETE") return deleteSession(ctx, res, sessionId, lang);
     if (method === "PATCH") return patchSession(ctx, req, res, sessionId, lang);
-    return methodNotAllowed(res, "GET, DELETE, PATCH");
+    return methodNotAllowed(res, "GET, DELETE, PATCH", lang);
   }
   if (action === "messages") {
-    if (isRead(method)) return listMessages(ctx, res, sessionId);
+    if (isRead(method)) return listMessages(ctx, res, sessionId, lang);
     if (method === "POST") return postMessage(ctx, req, res, sessionId, lang);
-    return methodNotAllowed(res, "GET, POST");
+    return methodNotAllowed(res, "GET, POST", lang);
   }
-  if (action === "abort" && method === "POST") return abortSession(ctx, res, sessionId);
-  if (action === "approvals" && isRead(method)) return listApprovals(ctx, res, sessionId);
-  if (action === "questions" && isRead(method)) return listQuestions(ctx, res, sessionId);
+  if (action === "abort" && method === "POST") return abortSession(ctx, res, sessionId, lang);
+  if (action === "reference-candidates" && isRead(method)) {
+    return listReferenceCandidates(ctx, res, sessionId, req.url, lang);
+  }
+  if (action === "file-candidates" && isRead(method)) {
+    return listFileCandidates(ctx, res, sessionId, req.url, lang);
+  }
+  if (action === "approvals" && isRead(method)) return listApprovals(ctx, res, sessionId, lang);
+  if (action === "questions" && isRead(method)) return listQuestions(ctx, res, sessionId, lang);
   if (action === "capabilities" && isRead(method))
-    return listCapabilities(ctx, res, sessionId);
-  if (action === "commands" && isRead(method)) return listCommands(ctx, res, sessionId);
-  if (action === "security" && isRead(method)) return getSecurity(ctx, res, sessionId);
-  if (action === "tools" && isRead(method)) return getTools(ctx, res, sessionId);
+    return listCapabilities(ctx, res, sessionId, lang);
+  if (action === "commands" && isRead(method)) return listCommands(ctx, res, sessionId, lang);
+  if (action === "security" && isRead(method)) return getSecurity(ctx, res, sessionId, lang);
+  if (action === "tools" && isRead(method)) return getTools(ctx, res, sessionId, lang);
   if (action === "skills" && detail !== void 0 && isRead(method)) {
     return getSkillBody(ctx, res, sessionId, detail, lang);
   }
-  if (action === "settings" && isRead(method)) return getSettings(ctx, res, sessionId);
+  if (action === "settings" && isRead(method)) return getSettings(ctx, res, sessionId, lang);
   if (action === "settings" && method === "POST") {
     return writeSetting(ctx, req, res, sessionId, lang);
   }
   if (action === "model" && isRead(method)) return getModel(ctx, res, sessionId);
   if (action === "model" && method === "POST")
     return setModel(ctx, req, res, sessionId, lang);
-  if (action === "artifacts" && isRead(method)) return getArtifacts(ctx, res, sessionId);
+  if (action === "artifacts" && isRead(method)) return getArtifacts(ctx, res, sessionId, lang);
   if (action === "tasks" && isRead(method)) return getTasks(ctx, res, sessionId);
+  if (action === "context" && isRead(method)) return getContext(ctx, res, sessionId, lang);
+  if (action === "compact" && method === "POST") {
+    return postCompact(ctx, req, res, sessionId, lang);
+  }
   if (action === "plan" && isRead(method)) return getPlan(ctx, res, sessionId);
+  if (action === "goal") {
+    if (isRead(method)) return getGoal(ctx, res, sessionId, lang);
+    if (method === "POST") return createGoal(ctx, req, res, sessionId, lang);
+    if (method === "PATCH") return patchGoal(ctx, req, res, sessionId, lang);
+    if (method === "DELETE") return deleteGoal(ctx, res, sessionId, lang);
+    return methodNotAllowed(res, "GET, POST, PATCH, DELETE", lang);
+  }
   if (action === "plan" && method === "POST")
     return setPlanMode(ctx, req, res, sessionId, lang);
   if (action === "permission" && isRead(method)) {
@@ -3616,6 +3901,9 @@ async function handleSessions(opts, req, res, method, sessionId, action, detail,
   if (action === "permission" && method === "POST") {
     return setPermission(ctx, req, res, sessionId, lang);
   }
+  if (action === "approval-cache" && method === "POST") {
+    return revokeApprovalCache(ctx, req, res, sessionId, lang);
+  }
   if (action === "checkpoints" && isRead(method)) {
     return detail === void 0 ? listCheckpoints(ctx, res, sessionId) : previewCheckpoint(ctx, res, sessionId, detail, lang);
   }
@@ -3628,7 +3916,7 @@ async function handleSessions(opts, req, res, method, sessionId, action, detail,
     return bindWorkspace(ctx, req, res, sessionId, lang);
   }
   if (action === "diff" && isRead(method)) return sessionDiff(ctx, res, sessionId);
-  sendNoEndpoint(res, method, `/api/sessions/${sessionId}`);
+  sendNoEndpoint(res, method, `/api/sessions/${sessionId}`, lang);
 }
 function openStream(opts, req, res) {
   const connection = new SseConnection(res, opts.heartbeatMs);
@@ -3643,13 +3931,20 @@ function openStream(opts, req, res) {
   req.on("close", finish);
   res.on("close", finish);
 }
-function handleStatic(opts, res, pathname) {
+function handleStatic(opts, res, pathname, lang) {
   if (opts.webRoot) {
     const file = resolveStaticPath(opts.webRoot, pathname);
     if (file) return sendFile(res, file, { "Content-Type": staticContentType(file) });
   }
-  if (pathname !== "/") return sendError(res, 404, "not-found", `\u627E\u4E0D\u5230 ${pathname}`);
-  const html = placeholderPage(opts.ctx.version);
+  if (pathname !== "/") {
+    return sendError(
+      res,
+      404,
+      "not-found",
+      t("web.route.static_not_found", { path: pathname }, lang)
+    );
+  }
+  const html = placeholderPage(opts.ctx.version, lang);
   res.writeHead(200, {
     ...baseHeaders(),
     "Content-Type": "text/html; charset=utf-8",
@@ -3667,18 +3962,19 @@ function redirectWithoutToken(res, rawUrl) {
   res.writeHead(303, { ...baseHeaders(), Location: `${url.pathname}${url.search}` });
   res.end();
 }
-function sendNoEndpoint(res, method, path) {
-  sendError(res, 404, "not-found", `\u6CA1\u6709\u8FD9\u4E2A\u7AEF\u70B9\uFF1A${method} ${path}`);
+function sendNoEndpoint(res, method, path, lang) {
+  sendError(res, 404, "not-found", t("web.no_endpoint", { method, path }, lang));
 }
-function methodNotAllowed(res, allow) {
-  sendError(res, 405, "method-not-allowed", `\u53EA\u652F\u6301 ${allow}`, { Allow: allow });
+function methodNotAllowed(res, allow, lang) {
+  sendError(res, 405, "method-not-allowed", t("web.method_not_allowed", { allow }, lang), {
+    Allow: allow
+  });
 }
 function defaultWebRoot(baseDir = dirname(fileURLToPath(import.meta.url)), exists = existsSync) {
   return [join(baseDir, "web"), join(baseDir, "..", "dist", "web")].find(
     (dir) => exists(join(dir, "index.html"))
   );
 }
-
 // src/index.ts
 async function createWebServer(opts) {
   const binding = decideBinding({
@@ -3692,9 +3988,6 @@ async function createWebServer(opts) {
     ...opts.idleGraceMs === void 0 ? {} : { idleGraceMs: opts.idleGraceMs },
     ...opts.clock === void 0 ? {} : { clock: opts.clock },
     ...opts.maxActiveSessions === void 0 ? {} : { maxActiveSessions: opts.maxActiveSessions },
-    // 被挤走的那个会话，引擎那一侧的东西也要放掉（方案 30 §2.3 的上限）。
-    // 不接这条线的话，上限只挡住了 Hub 那张表变长，而对话历史、`AgentLoop`、
-    // 审批桥全留着 —— 那正是冷却要还回来的东西。判据见 `SessionHubOptions.onCooled`
     onCooled: (sessionId) => opts.runtime.sessionFactory.release(sessionId)
   });
   if (opts.runtime.session) hub.register(opts.runtime.session);
@@ -3716,8 +4009,6 @@ async function createWebServer(opts) {
       host: binding.host,
       token: binding.token,
       ...webRoot === void 0 ? {} : { webRoot },
-      // 两个都是直接转 hub 上那一对，**没有中间层** —— 转出去的就是浏览器
-      // 收到的那条流和 `GET /api/sessions` 读的那张表，不是它们的复制品
       observe: (sink) => hub.observe(sink),
       snapshot: () => hub.listSessions(),
       close: makeCloser(server, hub, opts.runtime)
@@ -3730,12 +4021,7 @@ function buildHandler(opts, hub, binding, port, webRoot) {
       hub,
       runtime: opts.runtime,
       version: opts.version,
-      // 缺省问引擎要（方案 54 §二）。`??` 而不是 `||`：宿主传空字符串是它自己
-      // 的错，静默替换成引擎那个会把「我明明配了别处」变成一个查不出的怪现象
       artifactsRoot: opts.artifactsRoot ?? opts.runtime.artifactsRoot,
-      // 绑定策略那一格原样递下去（2026-08-18）。**同一个 `binding.lanExposed`
-      // 同时喂着下面 `createAuthGuard`（放宽 Host 白名单）和 `POST /api/roles`
-      // 那道 403** —— 一个事实一个来源，判据在 `ApiContext.lanExposed` 上
       lanExposed: binding.lanExposed
     },
     guard: createAuthGuard({ token: binding.token, port, lanExposed: binding.lanExposed }),
@@ -3759,15 +4045,15 @@ function listen(server, host, port) {
 }
 function describeListenError(err, host, port) {
   if (err.code === "EADDRINUSE") {
-    return `\u7AEF\u53E3 ${port} \u5DF2\u88AB\u5360\u7528\uFF0C\u6362\u4E00\u4E2A\uFF1Aepoch web --port ${port + 1}`;
+    return t("web.listen_in_use", { port, next: port + 1 }, void 0);
   }
   if (err.code === "EACCES") {
-    return `\u6CA1\u6709\u6743\u9650\u76D1\u542C ${host}:${port}\uFF081024 \u4EE5\u4E0B\u7684\u7AEF\u53E3\u9700\u8981\u7BA1\u7406\u5458\u6743\u9650\uFF09`;
+    return t("web.listen_no_permission", { host, port }, void 0);
   }
   if (err.code === "EADDRNOTAVAIL") {
-    return `\u672C\u673A\u6CA1\u6709 ${host} \u8FD9\u4E2A\u5730\u5740`;
+    return t("web.listen_no_address", { host }, void 0);
   }
-  return `\u76D1\u542C ${host}:${port} \u5931\u8D25\uFF1A${err.message}`;
+  return t("web.listen_failed", { host, port, reason: err.message }, void 0);
 }
 function makeCloser(server, hub, runtime) {
   let closing = null;
@@ -3782,4 +4068,4 @@ function makeCloser(server, hub, runtime) {
   };
 }
 
-export { DEFAULT_MAX_ACTIVE_SESSIONS, DEFAULT_MAX_QUEUED_MESSAGES, DEFAULT_RING_CAPACITY, DEFAULT_WEB_HOST, DEFAULT_WEB_PORT, EnvelopeRing, MAX_DIFF_BYTES, MAX_DIFF_FILES, MAX_RECORDING_FRAMES, MAX_SKILL_BODY_BYTES, SessionHub, TASK_TAIL_BYTES, UI_LANG_PARAM, UI_THEME_PARAM, collectCapabilities, collectSecurity, collectSettings, collectTasks, collectWorkspaceDiff, createAuthGuard, createWebServer, decideBinding, defaultWebRoot, expandUserContent, firstScreenUrl, generateToken, readRewindInput, resolveArtifactPath, toWireCheckpoint, toWireCommand, toWirePreview, toWireRewindResult, toWireRow, toWireSkillBody, toWireTask, unavailableToHttp };
+export { DEFAULT_MAX_ACTIVE_SESSIONS, DEFAULT_MAX_QUEUED_MESSAGES, DEFAULT_RING_CAPACITY, DEFAULT_WEB_HOST, DEFAULT_WEB_PORT, EnvelopeRing, MAX_CANDIDATES, MAX_DIFF_BYTES, MAX_DIFF_FILES, MAX_RECORDING_FRAMES, MAX_SKILL_BODY_BYTES, SessionHub, TASK_TAIL_BYTES, UI_LANG_PARAM, UI_THEME_PARAM, attachMentions, collectCapabilities, collectSecurity, collectSettings, collectTasks, collectWorkspaceDiff, createAuthGuard, createWebServer, decideBinding, defaultWebRoot, expandUserContent, firstScreenUrl, generateToken, listFileCandidates, listReferenceCandidates, readRewindInput, resolveArtifactPath, toWireCheckpoint, toWireCommand, toWirePluginEntry, toWirePreview, toWireRewindResult, toWireRow, toWireSkillBody, toWireTask, unavailableToHttp };