@epoch-agent/server 0.1.0

package/dist/index.js

@@ -0,0 +1,3785 @@
+import { createServer } from 'http';
+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 { 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';
+import { stat, readFile } from 'fs/promises';
+import { execFile } from 'child_process';
+import { fileURLToPath } from 'url';
+
+// src/index.ts
+var LOOPBACK_HOSTNAMES = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]"]);
+function createAuthGuard(opts) {
+  const { token, port, lanExposed } = opts;
+  const setCookie = `${WIRE_AUTH_COOKIE}=${token}; ${WIRE_AUTH_COOKIE_ATTRS}`;
+  return (request) => {
+    const host = request.host ?? "";
+    if (!isAllowedHost(host, port, lanExposed)) {
+      return { ok: false, status: 403, reason: "bad-host" };
+    }
+    if (!isSafeMethod(request.method) && !isAllowedOrigin(request.origin, host, port, lanExposed)) {
+      return { ok: false, status: 403, reason: "bad-origin" };
+    }
+    const fromUrl = readQueryToken(request.url);
+    if (fromUrl !== void 0) {
+      return sameToken(fromUrl, token) ? { ok: true, setCookie } : { ok: false, status: 401, reason: "bad-token" };
+    }
+    const fromCookie = readCookie(request.cookie, WIRE_AUTH_COOKIE);
+    if (fromCookie === void 0) return { ok: false, status: 401, reason: "missing-credential" };
+    if (!sameToken(fromCookie, token)) return { ok: false, status: 401, reason: "bad-token" };
+    return { ok: true };
+  };
+}
+function isSafeMethod(method) {
+  return method === "GET" || method === "HEAD";
+}
+function splitAuthority(authority) {
+  if (authority.length === 0) return null;
+  try {
+    const url = new URL(`http://${authority}`);
+    return { hostname: url.hostname, port: url.port === "" ? 80 : Number(url.port) };
+  } catch {
+    return null;
+  }
+}
+function isAllowedHost(host, port, lanExposed) {
+  const parsed = splitAuthority(host);
+  if (!parsed || parsed.port !== port) return false;
+  return LOOPBACK_HOSTNAMES.has(parsed.hostname) || lanExposed;
+}
+function isAllowedOrigin(origin, host, port, lanExposed) {
+  if (origin === void 0 || origin.length === 0) return false;
+  let parsed;
+  try {
+    parsed = new URL(origin);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol !== "http:") return false;
+  if (parsed.host !== host) return false;
+  return isAllowedHost(host, port, lanExposed);
+}
+function readQueryToken(url) {
+  try {
+    const value = new URL(url, "http://127.0.0.1").searchParams.get(WIRE_AUTH_TOKEN_PARAM);
+    return value === null ? void 0 : value;
+  } catch {
+    return void 0;
+  }
+}
+function readCookie(header, name) {
+  if (!header) return void 0;
+  for (const pair of header.split(";")) {
+    const eq = pair.indexOf("=");
+    if (eq < 0) continue;
+    if (pair.slice(0, eq).trim() !== name) continue;
+    return pair.slice(eq + 1).trim();
+  }
+  return void 0;
+}
+function sameToken(given, expected) {
+  const a = Buffer.from(given, "utf8");
+  const b = Buffer.from(expected, "utf8");
+  if (a.length !== b.length) return false;
+  return timingSafeEqual(a, b);
+}
+var DEFAULT_WEB_PORT = 4400;
+var DEFAULT_WEB_HOST = "127.0.0.1";
+function isLoopbackHost(host) {
+  const h = host.toLowerCase();
+  if (h === "localhost" || h === "::1" || h === "[::1]") return true;
+  return /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h);
+}
+function displayHost(host) {
+  if (host === "0.0.0.0" || host === "::" || host === "[::]") return DEFAULT_WEB_HOST;
+  return host;
+}
+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)}` };
+  }
+  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)"`
+    };
+  }
+  return { ok: true, host, port, lanExposed, token: token || generateToken() };
+}
+function generateToken() {
+  return randomBytes(32).toString("base64url");
+}
+var UI_THEME_PARAM = "theme";
+var UI_LANG_PARAM = "lang";
+function firstScreenUrl(host, port, token, ui = {}) {
+  const shown = displayHost(host);
+  const authority = shown.includes(":") && !shown.startsWith("[") ? `[${shown}]` : shown;
+  const params = [`${WIRE_AUTH_TOKEN_PARAM}=${encodeURIComponent(token)}`];
+  if (ui.theme) params.push(`${UI_THEME_PARAM}=${encodeURIComponent(ui.theme)}`);
+  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 {
+  constructor(capacity = DEFAULT_RING_CAPACITY) {
+    this.capacity = capacity;
+    if (!Number.isInteger(capacity) || capacity < 1) {
+      throw new Error(`\u73AF\u5F62\u7F13\u51B2\u5BB9\u91CF\u5FC5\u987B\u662F >= 1 \u7684\u6574\u6570\uFF0C\u6536\u5230 ${capacity}`);
+    }
+  }
+  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 [];
+    }
+    const { latestSeq, oldestSeq } = this;
+    if (lastEventId === latestSeq) return [];
+    if (lastEventId > latestSeq) return null;
+    if (oldestSeq === void 0 || lastEventId + 1 < oldestSeq) return null;
+    return this.frames.filter((f) => f.seq > lastEventId);
+  }
+};
+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 };
+    this.cooled.delete(id);
+    this.entries.set(id, {
+      session,
+      state: "idle",
+      relay: new ApprovalRelay(),
+      questions: new QuestionRelay(),
+      controller: null,
+      turnStartedAt: null,
+      lastFinish: null,
+      queue: [],
+      lastActiveTick: ++this.tick
+    });
+    return { added: true, cooled: this.coolIfCrowded(id) };
+  }
+  get(sessionId) {
+    return this.entries.get(sessionId);
+  }
+  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;
+    let oldest = Number.POSITIVE_INFINITY;
+    for (const [id, entry] of this.entries) {
+      if (id === keep || entry.state !== "idle") continue;
+      if (entry.lastActiveTick < oldest) {
+        oldest = entry.lastActiveTick;
+        victim = id;
+      }
+    }
+    if (victim === null) return null;
+    this.entries.delete(victim);
+    this.rememberCooled(victim);
+    return victim;
+  }
+  /** 冷却名单也要有界 —— 它只是给错误信息用的，不该跟着进程一直长 */
+  rememberCooled(sessionId) {
+    this.cooled.add(sessionId);
+    const limit = this.maxActive * 4;
+    while (this.cooled.size > limit) {
+      const oldest = this.cooled.values().next();
+      if (oldest.done) break;
+      this.cooled.delete(oldest.value);
+    }
+  }
+};
+function toWireSessionWorkspace(bound) {
+  const root = bound.workspace.root;
+  return {
+    root,
+    name: displayName(root),
+    extraRoots: bound.workspace.extra,
+    trusted: bound.trust.trusted,
+    instructionFiles: bound.projectContext.instructions.map((i) => i.path),
+    skippedInstructionFiles: bound.projectContext.skippedInstructions
+  };
+}
+function toWireBinding(state, bound) {
+  if (state === "bound" && bound)
+    return { state: "bound", workspace: toWireSessionWorkspace(bound) };
+  return { state: state === "bound" ? "unbound" : state };
+}
+function toWireWorkspaceRef(bound) {
+  if (!bound) return null;
+  return workspaceRefOf(bound.workspace.root);
+}
+function workspaceRefOf(root) {
+  return { root, name: displayName(root) };
+}
+function toWireKnownWorkspaces(known) {
+  return known.map((w) => ({ root: w.root, name: w.name }));
+}
+function displayName(root) {
+  return basename(root) || root;
+}
+function readWorkspaceField(body, lang) {
+  const raw = body["workspace"];
+  if (raw === void 0 || raw === null) return { ok: true, dir: null };
+  if (typeof raw !== "string" || raw.trim().length === 0) {
+    return { ok: false, message: t("web.workspace_must_be_string", void 0, lang) };
+  }
+  return { ok: true, dir: raw.trim() };
+}
+function readBindWorkspaceBody(body, lang) {
+  const rawRoot = body["root"];
+  const wantsNone = body["none"] === true;
+  const hasRoot = rawRoot !== void 0 && rawRoot !== null;
+  if (hasRoot && wantsNone) {
+    return { ok: false, message: t("web.workspace_bind_both", void 0, lang) };
+  }
+  if (wantsNone) return { ok: true, kind: "none" };
+  if (!hasRoot) return { ok: false, message: t("web.workspace_bind_neither", void 0, lang) };
+  if (typeof rawRoot !== "string" || rawRoot.trim().length === 0) {
+    return { ok: false, message: t("web.workspace_must_be_string", void 0, lang) };
+  }
+  return { ok: true, kind: "root", root: rawRoot.trim() };
+}
+function bindFailureToHttp(failure, lang) {
+  if (failure.reason === "locked") {
+    return {
+      status: 409,
+      code: "workspace-locked",
+      message: t("web.workspace_locked", { detail: failure.detail }, 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
+  };
+}
+var DEFAULT_SESSION_LIST_LIMIT = 50;
+var OFFLINE = {
+  state: "idle",
+  pendingApprovals: 0,
+  pendingQuestions: 0,
+  // 「从什么时候起被拦住」在这一档也是 null，理由和上面那条一样：挂起的账只活在
+  // Hub 的内存里。⚠️ 它**不是**「没在等」——是「这个进程不知道」，而两者在读的
+  // 那一侧下一步相同（那一格整个不画），所以归同一档。判据全文在
+  // `WireSessionSummary.pendingSince` 的最后一节
+  pendingSince: null,
+  turnStartedAt: null,
+  lastFinish: null
+};
+function toWireSummary(id, hub, row, extra = {}) {
+  const live = hub !== void 0;
+  const state = hub ?? OFFLINE;
+  return {
+    id,
+    state: state.state,
+    live,
+    title: row?.title ?? null,
+    model: row?.model ?? null,
+    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 }
+  };
+}
+function toWireSummaryWorkspace(bound, live, row) {
+  const ref = toWireWorkspaceRef(bound);
+  if (ref) return { state: "bound", ref };
+  if (live) return { state: "none" };
+  if (row?.workspaceState === "bound" && row.workspaceRoot) {
+    return { state: "bound", ref: workspaceRefOf(row.workspaceRoot) };
+  }
+  return row?.workspaceState === "none" ? { state: "none" } : { state: "unknown" };
+}
+function listSessionSummaries(hubStates, catalog, query, workspaceOf = () => null, roleOf = () => null, limit = DEFAULT_SESSION_LIST_LIMIT) {
+  const byId = new Map(hubStates.map((s) => [s.id, s]));
+  if (query) {
+    if (!catalog) return [];
+    const seen = /* @__PURE__ */ new Set();
+    const hits = [];
+    for (const hit of catalog.search(query, limit)) {
+      if (seen.has(hit.sessionId)) continue;
+      seen.add(hit.sessionId);
+      hits.push(
+        toWireSummary(hit.sessionId, byId.get(hit.sessionId), catalog.get(hit.sessionId), {
+          snippet: hit.snippet,
+          workspace: workspaceOf(hit.sessionId),
+          role: roleOf(hit.sessionId)
+        })
+      );
+    }
+    return hits;
+  }
+  const rows = catalog?.list(limit) ?? [];
+  const summaries = rows.map(
+    (row) => toWireSummary(row.id, byId.get(row.id), row, {
+      workspace: workspaceOf(row.id),
+      role: roleOf(row.id)
+    })
+  );
+  const known = new Set(rows.map((r) => r.id));
+  const fresh = hubStates.filter((s) => !known.has(s.id)).map((s) => toWireSummary(s.id, s, null, { workspace: workspaceOf(s.id), role: roleOf(s.id) }));
+  return [...fresh, ...summaries].sort(compareSummaries).slice(0, limit);
+}
+function compareSummaries(a, b) {
+  if (a.live !== b.live) return a.live ? -1 : 1;
+  const at = a.updatedAt ?? Number.POSITIVE_INFINITY;
+  const bt = b.updatedAt ?? Number.POSITIVE_INFINITY;
+  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;
+  constructor(opts = {}) {
+    this.ring = new EnvelopeRing(opts.ringCapacity ?? DEFAULT_RING_CAPACITY);
+    this.idleGraceMs = opts.idleGraceMs ?? 3e4;
+    this.clock = opts.clock ?? Date.now;
+    this.onCooled = opts.onCooled;
+    this.registry = new SessionRegistry({
+      ...opts.maxActiveSessions === void 0 ? {} : { maxActive: opts.maxActiveSessions },
+      ...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;
+    if (cooled === null) return;
+    this.publish(cooled, { type: "session-cooled" });
+    this.onCooled?.(cooled);
+  }
+  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,
+      state: entry.state,
+      pendingApprovals: entry.relay.pendingCount,
+      pendingQuestions: entry.questions.pendingCount,
+      pendingSince: earlierOf(entry.relay.pendingSince, entry.questions.pendingSince),
+      queued: entry.queue.length,
+      turnStartedAt: entry.turnStartedAt,
+      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;
+    entry.queue.length = 0;
+    entry.relay.abandon();
+    entry.questions.abandon();
+    entry.controller?.abort();
+    for (const [requestId, owner] of this.requestOwner) {
+      if (owner === sessionId) this.requestOwner.delete(requestId);
+    }
+    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) {
+      const replay = this.ring.since(lastEventId);
+      if (replay === null) {
+        sink(this.connectionFrame({ type: "stream-reset", reason: "buffer-overflow" }));
+      } else {
+        for (const frame of replay) sink(frame);
+      }
+    }
+    this.sinks.add(sink);
+    this.clearGrace();
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.sinks.delete(sink);
+      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 () => {
+    };
+    this.observers.add(sink);
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      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) {
+      return this.registry.isCooled(sessionId) ? { ok: false, reason: "cooled" } : { ok: false, reason: "unknown-session" };
+    }
+    const queued = { message, ...decorate ? { decorate } : {} };
+    if (entry.state !== "idle") {
+      if (!this.registry.enqueue(entry, queued)) {
+        return { ok: false, reason: "queue-full", state: entry.state };
+      }
+      return { ok: true, queued: true };
+    }
+    this.beginTurn(entry, queued);
+    return { ok: true, queued: false };
+  }
+  /**
+   * 中止本轮，并**丢掉排在后面的消息**。
+   *
+   * 排队的一起丢是刻意的：用户按下「停」要的是「现在别干了」，而不是
+   * 「停掉这一轮然后立刻开始下一轮」—— 后者的表现是按了停之后 agent 又动起来了。
+   *
+   * @returns 是否真有一轮在跑（**只看这个**，丢掉的队列不算）。
+   *          `false` 表示这一轮本来就没在跑，不是失败
+   */
+  abort(sessionId) {
+    const entry = this.registry.get(sessionId);
+    if (!entry) return false;
+    entry.queue.length = 0;
+    if (!entry.controller) return false;
+    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);
+    if (!entry || !sessionId) return false;
+    if (!entry.relay.respond(requestId, outcome, note)) return false;
+    this.requestOwner.delete(requestId);
+    this.publish(sessionId, { type: "approval-resolved", requestId });
+    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);
+    if (!entry || !sessionId) return false;
+    if (!entry.questions.respond(requestId, answer)) return false;
+    this.requestOwner.delete(requestId);
+    this.publish(sessionId, { type: "question-resolved", requestId });
+    this.syncApprovalState(entry);
+    return true;
+  }
+  /**
+   * 收摊：撤掉倒计时、放弃所有挂起的审批、中止所有在跑的回合。
+   *
+   * 进程收到 SIGINT 时立即调它（§4.3 最后一行），之后宿主再 `dispose()`。
+   * 幂等。
+   */
+  shutdown() {
+    if (this.closed) return;
+    this.closed = true;
+    this.clearGrace();
+    this.reap();
+    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);
+    for (const sink of this.sinks) sink(frame);
+    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) {
+      this.setState(entry, "awaiting-approval");
+      return;
+    }
+    this.setState(entry, entry.questions.pendingCount > 0 ? "awaiting-question" : "running");
+  }
+  // -------------------------------------------------------------------------
+  // 私有：跑一轮
+  // -------------------------------------------------------------------------
+  /**
+   * 开一轮：换一副新的登记表、拉起中止闸、广播状态、然后驱动。
+   *
+   * 状态帧必须在 `start()` 返回前就广播出去：POST 拿到 202 之后前端立刻可能
+   * 再问一次状态，而第二个标签页只靠这一帧才知道「现在正在跑」。
+   */
+  beginTurn(entry, queued) {
+    entry.relay = new ApprovalRelay();
+    entry.questions = new QuestionRelay();
+    entry.controller = new AbortController();
+    entry.lastFinish = null;
+    this.registry.touch(entry.session.sessionId);
+    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;
+    try {
+      const run = entry.session.run(queued.message, signal ? { signal } : {});
+      const raw = queued.decorate ? queued.decorate(run) : run;
+      for await (const event of serializeStream(raw, entry.relay, entry.questions)) {
+        const blocking = event.type === "approval-request" || event.type === "question";
+        if (blocking) this.requestOwner.set(event.requestId, sessionId);
+        const frame = this.publish(sessionId, stripArtifactData(event));
+        if (event.type === "finish") {
+          entry.lastFinish = toWireFinish(event, frame.ts, entry.turnStartedAt);
+        }
+        if (blocking) this.syncApprovalState(entry);
+      }
+    } catch (err) {
+      this.publish(sessionId, { type: "error", message: describeError(err) });
+    } finally {
+      entry.controller = null;
+      for (const [requestId, owner] of this.requestOwner) {
+        if (owner === sessionId) this.requestOwner.delete(requestId);
+      }
+      this.registry.touch(sessionId);
+      entry.turnStartedAt = null;
+      this.setState(entry, "idle");
+      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) {
+      entry.queue.length = 0;
+      return;
+    }
+    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(() => {
+      this.graceTimer = null;
+      this.reap();
+    }, this.idleGraceMs);
+    this.graceTimer.unref();
+  }
+  clearGrace() {
+    if (!this.graceTimer) return;
+    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()) {
+      entry.queue.length = 0;
+      if (entry.state === "idle") continue;
+      entry.relay.abandon();
+      entry.questions.abandon();
+      entry.controller?.abort();
+    }
+  }
+};
+function earlierOf(a, b) {
+  if (a === null) return b;
+  if (b === null) return a;
+  return Math.min(a, b);
+}
+function describeError(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function stripArtifactData(event) {
+  if (event.type !== "tool-result" || !event.artifacts) return event;
+  return { ...event, artifacts: event.artifacts.map(withoutData) };
+}
+function withoutData(artifact) {
+  if (artifact.data === void 0) return artifact;
+  const copy = { ...artifact };
+  delete copy.data;
+  return copy;
+}
+var JSON_BODY_LIMIT = 16 * 1024 * 1024;
+var BASE_HEADERS = {
+  "Cache-Control": "no-store",
+  "Referrer-Policy": "no-referrer",
+  "X-Content-Type-Options": "nosniff"
+};
+function toAuthView(req) {
+  return {
+    method: (req.method ?? "GET").toUpperCase(),
+    url: req.url ?? "/",
+    ...typeof req.headers.cookie === "string" ? { cookie: req.headers.cookie } : {},
+    ...typeof req.headers.origin === "string" ? { origin: req.headers.origin } : {},
+    ...typeof req.headers.host === "string" ? { host: req.headers.host } : {}
+  };
+}
+function pathnameOf(url) {
+  try {
+    return new URL(url ?? "/", "http://127.0.0.1").pathname;
+  } catch {
+    return "/";
+  }
+}
+function langOf(url) {
+  let raw;
+  try {
+    raw = new URL(url ?? "/", "http://127.0.0.1").searchParams.get(WIRE_LANG_PARAM);
+  } catch {
+    return void 0;
+  }
+  return raw && isLang(raw) ? raw : void 0;
+}
+function sendJson(res, status, body, extra = {}) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    ...BASE_HEADERS,
+    ...extra,
+    "Content-Type": "application/json; charset=utf-8",
+    "Content-Length": Buffer.byteLength(payload)
+  });
+  res.end(payload);
+}
+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 baseHeaders() {
+  return { ...BASE_HEADERS };
+}
+async function readJsonBody(req, limit = JSON_BODY_LIMIT) {
+  const chunks = [];
+  let size = 0;
+  try {
+    for await (const chunk of req) {
+      const buf = chunk;
+      size += buf.length;
+      if (size > limit) {
+        req.destroy();
+        return { ok: false, status: 413, message: `\u8BF7\u6C42\u4F53\u8D85\u8FC7 ${limit} \u5B57\u8282` };
+      }
+      chunks.push(buf);
+    }
+  } catch (err) {
+    return { ok: false, status: 400, message: `\u8BFB\u53D6\u8BF7\u6C42\u4F53\u5931\u8D25\uFF1A${describe(err)}` };
+  }
+  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)}` };
+  }
+}
+function describe(err) {
+  return err instanceof Error ? err.message : String(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"],
+  [".jpg", "image/jpeg"],
+  [".jpeg", "image/jpeg"],
+  [".gif", "image/gif"],
+  [".webp", "image/webp"],
+  [".bmp", "image/bmp"],
+  [".wav", "audio/wav"],
+  [".mp3", "audio/mpeg"],
+  [".ogg", "audio/ogg"],
+  [".m4a", "audio/mp4"]
+]);
+var STATIC_TYPES = /* @__PURE__ */ new Map([
+  [".html", "text/html; charset=utf-8"],
+  [".js", "text/javascript; charset=utf-8"],
+  [".mjs", "text/javascript; charset=utf-8"],
+  [".css", "text/css; charset=utf-8"],
+  [".json", "application/json; charset=utf-8"],
+  [".svg", "image/svg+xml"],
+  [".png", "image/png"],
+  [".jpg", "image/jpeg"],
+  [".webp", "image/webp"],
+  [".ico", "image/x-icon"],
+  [".woff2", "font/woff2"],
+  [".map", "application/json; charset=utf-8"]
+]);
+function isInside(root, child) {
+  return child === root || child.startsWith(root + sep);
+}
+function resolveArtifactPath(root, sessionId, name) {
+  if (sessionId.includes("\0") || name.includes("\0")) return null;
+  if (/[/\\]/.test(name) || name.length === 0) return null;
+  try {
+    const realRoot = realpathSync(resolve(root));
+    const target = resolve(realRoot, sessionId, name);
+    if (!isInside(realRoot, target)) return null;
+    const real = realpathSync(target);
+    if (!isInside(realRoot, real)) return null;
+    if (!statSync(real).isFile()) return null;
+    return real;
+  } catch {
+    return null;
+  }
+}
+function artifactDisposition(path) {
+  const known = INLINE_ARTIFACT_TYPES.get(extname(path).toLowerCase());
+  return known ? { type: known, inline: true } : { type: "application/octet-stream", inline: false };
+}
+function staticContentType(path) {
+  return STATIC_TYPES.get(extname(path).toLowerCase()) ?? "application/octet-stream";
+}
+function sendFile(res, path, headers) {
+  let size;
+  try {
+    size = statSync(path).size;
+  } catch {
+    res.writeHead(404, baseHeaders());
+    res.end();
+    return;
+  }
+  res.writeHead(200, { ...baseHeaders(), ...headers, "Content-Length": String(size) });
+  const stream = createReadStream(path);
+  stream.on("error", () => res.destroy());
+  stream.pipe(res);
+}
+function resolveStaticPath(webRoot, pathname) {
+  try {
+    const realRoot = realpathSync(resolve(webRoot));
+    const requested = pathname === "/" ? "/index.html" : pathname;
+    const target = resolve(realRoot, `.${requested}`);
+    if (isInside(realRoot, target)) {
+      try {
+        if (statSync(target).isFile()) return realpathSync(target);
+      } catch {
+      }
+    }
+    const index = resolve(realRoot, "index.html");
+    return statSync(index).isFile() ? index : null;
+  } catch {
+    return null;
+  }
+}
+function placeholderPage(version) {
+  return `<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Epoch Agent Web</title>
+<style>
+body{margin:0;display:grid;place-items:center;min-height:100vh;
+font:14px/1.7 ui-monospace,SFMono-Regular,Menlo,monospace;background:#111418;color:#c8d0da}
+main{max-width:34rem;padding:2rem}
+h1{font-size:1rem;font-weight:600;color:#e8eef5;margin:0 0 .75rem}
+code{background:#1b2027;padding:.1rem .35rem;border-radius:3px}
+</style>
+</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>
+</main></body></html>`;
+}
+function escapeHtml(text) {
+  return text.replace(
+    /[&<>"']/g,
+    (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c] ?? c
+  );
+}
+function builtinConnectors(tools) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    if (tool.source === "builtin" || tool.source.startsWith("mcp:")) continue;
+    counts.set(tool.source, (counts.get(tool.source) ?? 0) + 1);
+  }
+  return [...counts.entries()].map(([name, toolCount]) => ({ name, toolCount })).sort((a, b) => a.name.localeCompare(b.name));
+}
+function toWireRole(role, notices) {
+  return {
+    name: role.name,
+    description: role.description,
+    source: role.source,
+    // `?? null` 而不是 `?? []`：不给 tools 的角色是「不限」，空数组是
+    // 「一个都不给」。合并成同一个值之后，`general` 会显示成一个废掉的角色
+    tools: role.tools ?? null,
+    maxTurns: role.maxTurns ?? null,
+    toolsCut: notices.find((n) => n.role === role.name)?.cut ?? []
+  };
+}
+function toWireSkill(skill) {
+  const description = skillIndexDescription(skill.description);
+  return {
+    name: skill.name,
+    category: skill.category || "general",
+    description,
+    // 索引里的那一行是 `- <名字>: <描述>`，按它整行估才是这条技能的真实占用
+    tokens: estimateIndexTokens(`- ${skill.name}: ${description}`),
+    scope: skill.scope,
+    type: skill.type
+  };
+}
+function estimateIndexTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function toWireMcp(server) {
+  const state = server.needsLogin ? "needs-login" : server.connected ? "connected" : "failed";
+  return {
+    name: server.name,
+    state,
+    toolCount: server.toolCount,
+    reconnectAttempts: server.reconnectAttempts,
+    ...server.lastError ? { lastError: server.lastError } : {},
+    // **原样转发，这一层不判也不补**：来源是装配层的结论（`connectAll(…, source)`），
+    // 在这儿再猜一次（比如「名字里有 `__` 就算宿主的」）等于给同一件事第二个答案
+    source: server.source
+  };
+}
+function collectCapabilities(runtime, tools, bound) {
+  return {
+    roles: runtime.agentRoles.map((r) => toWireRole(r, runtime.agentRoleNotices)),
+    skills: runtime.skills.map(toWireSkill),
+    builtinConnectors: builtinConnectors(tools),
+    mcpServers: runtime.mcpServers.map(toWireMcp),
+    project: {
+      root: bound?.workspace.root ?? null,
+      // 没绑工作区时报 `false` 而不是 `true`：界面拿它决定要不要画那句
+      // 「不受信任的目录连读都不读」，而没有工作区时那句话是对的
+      // —— 项目层确实一个字都没读
+      trusted: bound?.trust.trusted ?? false
+    }
+  };
+}
+var MAX_SKILL_BODY_BYTES = 256 * 1024;
+function toWireSkillBody(name, body) {
+  const bytes = Buffer.byteLength(body, "utf-8");
+  if (bytes <= MAX_SKILL_BODY_BYTES) return { name, body, truncated: false, bytes };
+  const cut = Buffer.from(body, "utf-8").subarray(0, MAX_SKILL_BODY_BYTES).toString("utf-8");
+  const safe = Buffer.byteLength(cut, "utf-8") > MAX_SKILL_BODY_BYTES ? cut.slice(0, -1) : cut;
+  return { name, body: safe, truncated: true, bytes };
+}
+function getSkillBody(ctx, res, sessionId, name, lang) {
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  const body = ctx.runtime.skillBody(name);
+  if (body === null) {
+    return sendError(res, 404, "unknown-skill", t("web.skill_unknown", { name }, lang));
+  }
+  sendJson(res, 200, toWireSkillBody(name, body));
+}
+function toWireCommand(def) {
+  return {
+    name: def.name,
+    description: def.description,
+    // 没写就不带这个键（不是空串）：空串会被画成一个空的参数提示位，
+    // 于是「这条命令不吃参数」和「作者忘了写提示」看起来一样
+    ...def.argumentHint ? { argumentHint: def.argumentHint } : {}
+  };
+}
+function parseSlashInput(text) {
+  if (!text.startsWith("/")) return null;
+  if (text.includes("\n")) return null;
+  const body = text.slice(1);
+  const spaceIdx = body.search(/\s/);
+  const name = (spaceIdx === -1 ? body : body.slice(0, spaceIdx)).toLowerCase();
+  if (!name) return null;
+  return { name, args: spaceIdx === -1 ? "" : body.slice(spaceIdx).trim() };
+}
+function expandUserContent(runtime, message, model, role) {
+  const text = leadingText(message);
+  const parsed = text === null ? null : parseSlashInput(text);
+  const expanded = parsed ? runtime.commands.expand(parsed.name, parsed.args) : void 0;
+  const wraps = role !== null || expanded?.allowedTools !== void 0 || expanded?.model !== void 0;
+  return {
+    message: expanded ? replaceLeadingText(message, expanded.prompt) : message,
+    ...wraps ? { decorate: (stream) => scopeTurn(runtime, model, role, expanded, stream) } : {},
+    ...parsed && expanded ? { notice: { name: parsed.name, warnings: expanded.warnings ?? [] } } : {}
+  };
+}
+function scopeTurn(runtime, model, role, expanded, stream) {
+  return withRoleScope(
+    role?.control ?? null,
+    role?.name,
+    withModelScope(
+      model,
+      expanded?.model,
+      withToolScope(runtime.commands, expanded?.allowedTools, stream)
+    )
+  );
+}
+function leadingText(message) {
+  if (typeof message === "string") return message;
+  const first = message[0];
+  return first && first.type === "text" ? first.text : null;
+}
+function replaceLeadingText(message, prompt) {
+  if (typeof message === "string") return prompt;
+  const head = { type: "text", text: prompt };
+  return [head, ...message.slice(1)];
+}
+function toWireSandbox(iso) {
+  return {
+    level: iso.level,
+    backend: iso.backend,
+    reason: iso.reason,
+    platform: iso.platform,
+    covers: SANDBOX_COVERS,
+    excludes: SANDBOX_EXCLUDES
+  };
+}
+function toWireRule(rule) {
+  return { verdict: rule.bucket, rule: rule.rule, layer: rule.layer };
+}
+function toWireShadow(finding) {
+  return { kind: finding.kind, rule: finding.rule, by: finding.by };
+}
+function toWireAudit(audit) {
+  const rows = audit.entries.map((e) => ({
+    at: e.at,
+    toolName: e.toolName,
+    type: e.type,
+    target: e.target,
+    outcome: e.outcome,
+    code: e.code
+  }));
+  return { rows, dropped: audit.dropped };
+}
+function toWireManaged(managed) {
+  return {
+    present: managed.present,
+    path: managed.path,
+    rulesOnly: managed.rulesOnly,
+    bypassDisabled: managed.bypassDisabled
+  };
+}
+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 }
+};
+function toWirePolicy(policy) {
+  const dirs = policy.dirs.map((d) => ({
+    dir: d.dir,
+    source: d.source,
+    ruleCount: d.ruleCount
+  }));
+  return { dirs, projectSkipped: policy.projectSkipped, skippedDir: policy.skippedDir };
+}
+function toWireSecurityWorkspace(bound) {
+  return {
+    ...toWireSessionWorkspace(bound),
+    trustLevel: bound.trust.level,
+    unloadedExtraInstructionFiles: bound.unloadedInstructions
+  };
+}
+function toWireTrustList(known, workspaces, currentRoot) {
+  return known.map((w) => {
+    const decision = workspaces.trustOf(w.root);
+    return {
+      root: w.root,
+      name: w.name,
+      level: decision.level,
+      trusted: decision.trusted,
+      current: currentRoot !== null && w.root === currentRoot
+    };
+  });
+}
+function collectSecurity(runtime, workspaces, bound, session) {
+  const perms = runtime.permissions;
+  return {
+    // `null` 是第三种状态（沙箱没建起来），不是「仅进程隔离」
+    sandbox: runtime.isolation ? toWireSandbox(runtime.isolation) : 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())
+    } : 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 }
+  };
+}
+function unavailableToHttp(lang) {
+  return {
+    status: 503,
+    code: "no-provider",
+    message: t("web.session_unavailable", void 0, lang)
+  };
+}
+function unknownRoleToHttp(role, lang) {
+  return {
+    status: 400,
+    code: "unknown-role",
+    message: t("web.session_unknown_role", { role }, lang)
+  };
+}
+
+// src/sessions/revive.ts
+function persistedDecision(row) {
+  if (!row) return null;
+  if (row.workspaceState === "none") return { state: "none" };
+  if (row.workspaceState === "bound" && row.workspaceRoot) {
+    return { state: "bound", root: row.workspaceRoot };
+  }
+  return null;
+}
+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) {
+    ctx.hub.register(outcome.live.session);
+    return { ok: true };
+  }
+  if (outcome.reason === "no-decision") return { ok: false, kind: "skipped" };
+  if (outcome.reason === "unavailable") {
+    return { ok: false, kind: "failed", ...unavailableToHttp(lang) };
+  }
+  return { ok: false, kind: "failed", ...bindFailureToHttp(outcome, lang) };
+}
+function toWireSettingRow(row) {
+  return {
+    key: row.key,
+    ...row.value === void 0 ? {} : { value: row.value },
+    layer: row.layer,
+    chain: row.chain.map(toWireSettingStep),
+    overridable: row.overridable,
+    writes: row.writes.map(toWireSettingWrite)
+  };
+}
+function toWireSettingStep(step) {
+  return { layer: step.layer, ...step.value === void 0 ? {} : { value: step.value } };
+}
+function toWireSettingWrite(write) {
+  return {
+    layer: write.layer,
+    path: write.path,
+    ...write.futile ? { futile: toWireSettingFutile(write.futile) } : {},
+    apply: write.apply
+  };
+}
+function toWireSettingFutile(futile) {
+  return { reason: futile.reason, ...futile.by === void 0 ? {} : { by: futile.by } };
+}
+function collectSettings(runtime, sessionId) {
+  const managed = runtime.permissions?.managed();
+  return {
+    rows: runtime.settings.rows(sessionId).map(toWireSettingRow),
+    overridableKeys: [...runtime.settings.overridableKeys()],
+    managedPath: managed?.present ? managed.path : null
+  };
+}
+var WRITE_FAILURE = {
+  "unknown-key": { status: 400, key: "web.settings_write_unknown_key" },
+  "bad-value": { status: 400, key: "web.settings_write_bad_value" },
+  "unwritable-file": { status: 409, key: "web.settings_write_unwritable" },
+  io: { status: 500, key: "web.settings_write_io" }
+};
+function settingWriteFailure(report) {
+  const { status, key } = WRITE_FAILURE[report.reason];
+  return { status, code: report.reason, key, path: report.path ?? "" };
+}
+function toWireSettingsWrite(done) {
+  return {
+    key: done.key,
+    layer: done.layer,
+    path: done.path,
+    value: done.value,
+    ...done.futile ? { futile: toWireSettingFutile(done.futile) } : {},
+    apply: done.apply
+  };
+}
+function readSettingWriteBody(body) {
+  const { key, layer, value } = body;
+  if (typeof key !== "string" || key.length === 0) return { ok: false };
+  if (!isWireSettingWriteLayer(layer)) return { ok: false };
+  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+    return { ok: false };
+  }
+  return { ok: true, key, layer, value };
+}
+function callCounts(runtime, sessionId) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const message of runtime.sessionStore?.loadMessages(sessionId) ?? []) {
+    for (const call of message.toolCalls ?? []) {
+      counts.set(call.toolName, (counts.get(call.toolName) ?? 0) + 1);
+    }
+  }
+  return counts;
+}
+function toWireGate(row) {
+  return {
+    verdict: row.verdict,
+    by: row.by,
+    ...row.rule === void 0 ? {} : { rule: row.rule },
+    ...row.layer === void 0 ? {} : { layer: row.layer },
+    conditional: row.conditional
+  };
+}
+function collectTools(runtime, sessionId, session) {
+  const counts = callCounts(runtime, sessionId);
+  const raw = session?.level();
+  const level = raw !== void 0 && isPermissionLevel(raw) ? raw : null;
+  const gates = /* @__PURE__ */ new Map();
+  if (level !== null) {
+    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);
+    return {
+      name: tool.name,
+      description: tool.description,
+      source: tool.source,
+      // 类型只有 `gates` 那一路知道（core 的 `mapOperation()` 三级回退）。
+      // 拿不到时回 `command` ——「最保守的那一类」而不是「最常见的那一类」：
+      // 这一格此刻只被界面拿去分组，而分错组的代价远小于按工具名前缀猜一个
+      // （那种猜法在第一个不按前缀命名的工具上就错，判据在 `WireToolSummary.source`）
+      type: gate?.type ?? "command",
+      calls: counts.get(tool.name) ?? 0,
+      ...gate === void 0 ? {} : { gate: toWireGate(gate) }
+    };
+  });
+  return { tools, level: level ?? "unknown" };
+}
+
+// src/api.ts
+var APPROVAL_OUTCOMES = /* @__PURE__ */ new Set([
+  "allow-once",
+  "allow-session",
+  "allow-always",
+  "deny",
+  ...PLAN_OUTCOMES
+]);
+function health(ctx, res) {
+  sendJson(res, 200, { ok: true, version: ctx.version });
+}
+function config(ctx, res, lang) {
+  const { runtime } = ctx;
+  const bound = runtime.workspaces.of(runtime.sessionId);
+  sendJson(res, 200, {
+    sessionId: runtime.sessionId,
+    model: runtime.config.model,
+    permission: runtime.config.permission,
+    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
+  });
+}
+function listSessions(ctx, res, query, _lang) {
+  const sessions = listSessionSummaries(
+    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) {
+  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);
+  sendJson(res, 200, {
+    session: toWireSummary(sessionId, hub, row, {
+      workspace: ctx.runtime.workspaces.of(sessionId),
+      role: ctx.runtime.sessionFactory.get(sessionId)?.role ?? null
+    })
+  });
+}
+async function deleteSession(ctx, res, sessionId, lang) {
+  const inHub = ctx.hub.unregister(sessionId);
+  ctx.runtime.sessionFactory.release(sessionId);
+  ctx.runtime.workspaces.release(sessionId);
+  const catalog = ctx.runtime.sessions;
+  if (!catalog) {
+    if (inHub) {
+      return sendJson(res, 200, {
+        deleted: false,
+        checkpointsRemoved: false
+      });
+    }
+    return sendError(
+      res,
+      503,
+      "no-session-store",
+      t("web.session_store_unavailable", void 0, lang)
+    );
+  }
+  const outcome = await catalog.delete(sessionId);
+  if (!outcome.deleted && !inHub) return sendUnknownSession(res, sessionId);
+  sendJson(res, 200, outcome);
+}
+async function patchSession(ctx, req, res, sessionId, lang) {
+  const body = await readJsonBody(req);
+  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() : "";
+  if (title.length === 0) {
+    return sendError(res, 400, "bad-title", t("web.title_required", void 0, lang));
+  }
+  const catalog = ctx.runtime.sessions;
+  if (!catalog) {
+    return sendError(
+      res,
+      503,
+      "no-session-store",
+      t("web.session_store_unavailable", void 0, lang)
+    );
+  }
+  const row = catalog.rename(sessionId, title);
+  if (!row) return sendUnknownSession(res, sessionId);
+  const hub = ctx.hub.listSessions().find((s) => s.id === sessionId);
+  sendJson(res, 200, {
+    session: toWireSummary(sessionId, hub, row, {
+      workspace: ctx.runtime.workspaces.of(sessionId),
+      role: ctx.runtime.sessionFactory.get(sessionId)?.role ?? null
+    })
+  });
+}
+function listMessages(ctx, res, sessionId, _lang) {
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  const messages = ctx.runtime.sessionStore?.loadMessages(sessionId) ?? [];
+  sendJson(res, 200, { messages });
+}
+async function postMessage(ctx, req, res, sessionId, lang) {
+  if (!ctx.hub.has(sessionId)) {
+    const revived = reviveSession(ctx, sessionId, lang);
+    if (!revived.ok && revived.kind === "failed") {
+      return sendError(res, revived.status, revived.code, revived.message);
+    }
+    if (!revived.ok && !ctx.hub.isCooled(sessionId)) {
+      return sendUnknownSession(res, sessionId);
+    }
+  }
+  const body = await readJsonBody(req);
+  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[]");
+  }
+  const live = ctx.runtime.sessionFactory.get(sessionId);
+  const picked = pickTurnRole(live, asRecord(body.value)["role"]);
+  if (!picked.ok) {
+    const mapped = unknownRoleToHttp(picked.detail, 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);
+  if (started.ok) {
+    return sendJson(res, 202, {
+      accepted: true,
+      queued: started.queued,
+      // 不是命令时**整个键缺席**（不是空对象）：界面据此区分「认成命令了、
+      // 只是没话要说」和「原样发给模型了」，见 `WireSendMessageResponse.command`
+      ...expansion.notice ? { command: expansion.notice } : {}
+    });
+  }
+  if (started.reason === "unknown-session") return sendUnknownSession(res, sessionId);
+  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`, {
+    "X-Epoch-Turn-State": started.state
+  });
+}
+function pickTurnRole(live, raw) {
+  const name = typeof raw === "string" ? raw.trim() : "";
+  if (name === "") return { ok: true, role: null };
+  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);
+  sendJson(res, 200, { aborted: ctx.hub.abort(sessionId) });
+}
+function listApprovals(ctx, res, sessionId, _lang) {
+  if (!ctx.hub.has(sessionId)) return sendUnknownSession(res, sessionId);
+  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);
+  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("/")}`);
+  }
+  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`);
+  }
+  sendJson(res, 200, { resolved: true });
+}
+function listQuestions(ctx, res, sessionId, _lang) {
+  if (!ctx.hub.has(sessionId)) return sendUnknownSession(res, sessionId);
+  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);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const payload = asRecord(body.value);
+  if (!isQuestionAnswerMap(payload.answers)) {
+    return sendError(
+      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}'
+    );
+  }
+  const answer = {
+    answers: payload.answers,
+    ...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`);
+  }
+  sendJson(res, 200, { resolved: true });
+}
+function listCapabilities(ctx, res, sessionId, _lang) {
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  const payload = collectCapabilities(
+    ctx.runtime,
+    ctx.runtime.tools,
+    ctx.runtime.workspaces.of(sessionId)
+  );
+  sendJson(res, 200, payload);
+}
+function listCommands(ctx, res, sessionId, _lang) {
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  const commands = ctx.runtime.commands.list.map(toWireCommand);
+  sendJson(res, 200, { commands });
+}
+function getSecurity(ctx, res, sessionId, _lang) {
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  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) {
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  const payload = collectTools(
+    ctx.runtime,
+    sessionId,
+    ctx.runtime.sessionFactory.get(sessionId)?.permissions ?? null
+  );
+  sendJson(res, 200, payload);
+}
+function getSettings(ctx, res, sessionId, _lang) {
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  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);
+  }
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const input = readSettingWriteBody(asRecord(body.value));
+  if (!input.ok) {
+    return sendError(
+      res,
+      400,
+      "bad-request",
+      t("web.settings_write_bad_request", { layers: WIRE_SETTING_WRITE_LAYERS.join("/") }, lang)
+    );
+  }
+  const report = ctx.runtime.settings.write({ ...input, sessionId });
+  if (!report.ok) {
+    const failure = settingWriteFailure(report);
+    return sendError(
+      res,
+      failure.status,
+      failure.code,
+      t(failure.key, { path: failure.path }, lang)
+    );
+  }
+  sendJson(res, 200, toWireSettingsWrite(report));
+}
+function getArtifacts(ctx, res, sessionId, _lang) {
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  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) {
+  const path = resolveArtifactPath(ctx.artifactsRoot, sessionId, name);
+  if (!path) return sendError(res, 404, "not-found", "artifact \u4E0D\u5B58\u5728");
+  const { type, inline } = artifactDisposition(path);
+  sendFile(res, path, {
+    "Content-Type": type,
+    // 不认识的类型一律 attachment：让浏览器把 artifact 当 HTML 渲染，
+    // 等于在本服务的同源里执行任意脚本，而这个源上挂着全部 agent API
+    "Content-Disposition": inline ? "inline" : `attachment; filename="${encodeURIComponent(name)}"`
+  });
+}
+function parseUserContent(raw) {
+  if (typeof raw === "string") return raw.trim().length > 0 ? raw : null;
+  if (Array.isArray(raw) && raw.length > 0) return raw;
+  return null;
+}
+function toWireCheckpoint(summary) {
+  return {
+    turnIndex: summary.turnIndex,
+    createdAt: summary.createdAt,
+    // 用户自己那句原话，**照原样过** —— 它不是我们写的字，不进任何 catalog
+    preview: summary.preview,
+    fileCount: summary.fileCount,
+    incomplete: summary.incomplete
+  };
+}
+function toWirePlan(plan) {
+  return { path: plan.path, action: plan.action, drift: plan.drift };
+}
+function toWirePreview(preview) {
+  return {
+    turnIndex: preview.turnIndex,
+    createdAt: preview.createdAt,
+    preview: preview.preview,
+    // 引擎算好的那个布尔，**不在这一层从 cursor 重算** —— 镜像上压根没有 cursor
+    canRewindConversation: preview.canRewindConversation,
+    incomplete: preview.incomplete,
+    files: preview.files.map(toWirePlan),
+    conflicts: preview.conflicts.map(toWirePlan)
+  };
+}
+function toWireOutcome(outcome) {
+  return {
+    restored: [...outcome.restored],
+    deleted: [...outcome.deleted],
+    recreated: [...outcome.recreated],
+    skippedConflicts: [...outcome.skippedConflicts],
+    // 成功时**整个不给这个键**（同 `note` / `skipped` 的规矩）：契约里它就是
+    // 「可以不给」，而 `failed: undefined` 会被 JSON.stringify 抹掉之后长得一样，
+    // 写成条件展开是把「没有失败」这件事说明白
+    ...outcome.failed === void 0 ? {} : { failed: outcome.failed }
+  };
+}
+function toWireRewindResult(result) {
+  return {
+    files: result.files === null ? null : toWireOutcome(result.files),
+    messagesRemoved: result.messagesRemoved
+  };
+}
+function isTurnIndex(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function readRewindInput(body, lang) {
+  const record = asRecord(body);
+  const turnIndex = record["turnIndex"];
+  if (!isTurnIndex(turnIndex))
+    return { ok: false, code: "bad-turn", message: t("web.rewind_bad_turn", void 0, lang) };
+  const scope = record["scope"];
+  if (typeof scope !== "string" || !isWireRewindScope(scope)) {
+    return {
+      ok: false,
+      code: "bad-scope",
+      message: t("web.rewind_bad_scope", { scopes: WIRE_REWIND_SCOPES.join("/") }, lang)
+    };
+  }
+  const raw = record["overwrite"];
+  if (raw !== void 0 && (!Array.isArray(raw) || raw.some((p) => typeof p !== "string"))) {
+    return {
+      ok: false,
+      code: "bad-overwrite",
+      message: t("web.rewind_bad_overwrite", void 0, lang)
+    };
+  }
+  const overwrite = raw === void 0 ? void 0 : raw;
+  return {
+    ok: true,
+    // 空数组和「没给」在引擎那边是一回事（`new Set(opts.overwrite ?? [])`），
+    // 但这里照样原样转：客户端发了空数组是它在说「一个都不覆盖」，那是一句话
+    value: { turnIndex, scope, ...overwrite === void 0 ? {} : { overwrite } }
+  };
+}
+function checkpointsOf(ctx, sessionId) {
+  return ctx.runtime.sessionFactory.get(sessionId)?.checkpoints ?? null;
+}
+async function listCheckpoints(ctx, res, sessionId, _lang) {
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  const control = checkpointsOf(ctx, sessionId);
+  if (!control) {
+    return sendJson(res, 200, { checkpoints: [] });
+  }
+  let checkpoints = [];
+  try {
+    checkpoints = await control.list();
+  } catch {
+  }
+  sendJson(res, 200, {
+    checkpoints: checkpoints.map(toWireCheckpoint)
+  });
+}
+async function previewCheckpoint(ctx, res, sessionId, rawTurn, lang) {
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  const control = checkpointsOf(ctx, sessionId);
+  if (!control) {
+    return sendError(res, 409, "not-live-session", t("web.rewind_not_live", void 0, lang));
+  }
+  const turnIndex = Number(rawTurn);
+  if (!isTurnIndex(turnIndex)) {
+    return sendError(res, 400, "bad-turn", t("web.rewind_bad_turn", void 0, lang));
+  }
+  const preview = await control.preview(turnIndex);
+  if (!preview) {
+    return sendError(
+      res,
+      404,
+      "unknown-checkpoint",
+      t("web.rewind_no_checkpoint", { turn: turnIndex }, lang)
+    );
+  }
+  sendJson(res, 200, toWirePreview(preview));
+}
+async function rewind(ctx, req, res, sessionId, lang) {
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  const control = checkpointsOf(ctx, sessionId);
+  if (!control) {
+    return sendError(res, 409, "not-live-session", t("web.rewind_not_live", void 0, lang));
+  }
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const input = readRewindInput(body.value, lang);
+  if (!input.ok) return sendError(res, 400, input.code, input.message);
+  const { turnIndex, scope, overwrite } = input.value;
+  const result = await control.rewind(turnIndex, {
+    scope,
+    // ⚠️ **只转用户点过头的那几个**。这里绝不能顺手把 `preview.conflicts` 并进去 ——
+    // 那正是「全部覆盖」那个按钮的等价物，而它毁掉的是用户自己刚写的东西
+    ...overwrite === void 0 ? {} : { overwrite }
+  });
+  sendJson(res, 200, toWireRewindResult(result));
+}
+function readConfig(ctx, res, lang) {
+  if (ctx.lanExposed) return sendLanExposed(res, lang);
+  const outcome = ctx.runtime.mcp.readConfig();
+  if (!outcome.ok) {
+    return sendError(
+      res,
+      409,
+      "mcp-config-unreadable",
+      t("web.mcp_config_unreadable", { detail: outcome.detail }, lang)
+    );
+  }
+  const { snapshot } = outcome;
+  sendJson(res, 200, {
+    configPath: snapshot.configPath,
+    text: snapshot.text,
+    exists: snapshot.exists,
+    revision: snapshot.revision,
+    issues: toWireIssues(snapshot.issues)
+  });
+}
+async function saveConfig(ctx, req, res, lang) {
+  if (ctx.lanExposed) return sendLanExposed(res, lang);
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const payload = asRecord(body.value);
+  const text = payload["text"];
+  const revision = payload["revision"];
+  if (typeof text !== "string" || typeof revision !== "string") {
+    return sendError(
+      res,
+      400,
+      "bad-mcp-config-body",
+      t("web.mcp_config_bad_body", void 0, lang)
+    );
+  }
+  const outcome = ctx.runtime.mcp.writeConfig(text, revision, lang);
+  if (!outcome.ok) return sendError(res, ...saveFailure(outcome.reason, outcome.detail, lang));
+  sendJson(res, 200, {
+    configPath: outcome.configPath,
+    revision: outcome.revision,
+    issues: toWireIssues(outcome.issues)
+  });
+}
+async function applyConfig(ctx, req, res, lang) {
+  if (ctx.lanExposed) return sendLanExposed(res, lang);
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const revision = asRecord(body.value)["revision"];
+  if (typeof revision !== "string") {
+    return sendError(
+      res,
+      400,
+      "bad-mcp-config-body",
+      t("web.mcp_config_bad_body", void 0, lang)
+    );
+  }
+  const outcome = await ctx.runtime.mcp.applyConfig(revision, lang);
+  if (!outcome.ok) return sendError(res, ...applyFailure(outcome.reason, outcome.detail, lang));
+  sendJson(res, 200, {
+    configPath: outcome.configPath,
+    revision: outcome.revision,
+    issues: toWireIssues(outcome.issues),
+    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 }
+    }))
+  });
+}
+function sendLanExposed(res, lang) {
+  sendError(res, 403, "mcp-config-lan-exposed", t("web.mcp_config_lan_exposed", void 0, lang));
+}
+function saveFailure(reason, detail, lang) {
+  if (reason === "stale") {
+    return [409, "mcp-config-stale", t("web.mcp_config_stale", void 0, lang)];
+  }
+  if (reason === "invalid-json") return [400, "mcp-config-invalid-json", detail];
+  return [409, "mcp-config-unwritable", t("web.mcp_config_unwritable", { detail }, lang)];
+}
+function applyFailure(reason, detail, lang) {
+  if (reason === "unreadable") {
+    return [409, "mcp-config-unreadable", t("web.mcp_config_unreadable", { detail }, lang)];
+  }
+  if (reason === "stale") {
+    return [409, "mcp-config-stale", t("web.mcp_config_stale", void 0, lang)];
+  }
+  if (reason === "invalid-json") return [400, "mcp-config-invalid-json", detail];
+  return [409, "mcp-config-no-servers", t("web.mcp_config_no_servers", { detail }, lang)];
+}
+function toWireIssues(issues) {
+  return issues.map((issue) => ({ path: issue.path, message: issue.message }));
+}
+async function reconnectMcp(ctx, res, name, lang) {
+  const outcome = await ctx.runtime.mcp.reconnect(name);
+  if (!outcome.ok) {
+    if (outcome.reason === "unknown") {
+      return sendError(res, 404, "unknown-mcp-server", t("web.mcp_unknown_server", { name }, lang));
+    }
+    const status = {
+      ...outcome.status,
+      ...outcome.detail === void 0 ? {} : { lastError: outcome.detail }
+    };
+    return sendJson(res, 200, {
+      ok: false,
+      server: toWireMcp(status)
+    });
+  }
+  sendJson(res, 200, {
+    ok: true,
+    server: toWireMcp(outcome.status)
+  });
+}
+async function addMcp(ctx, req, res, lang) {
+  if (ctx.lanExposed) {
+    return sendError(
+      res,
+      403,
+      "mcp-add-lan-exposed",
+      t("web.mcp_add_lan_exposed", void 0, lang)
+    );
+  }
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const payload = asRecord(body.value);
+  const name = typeof payload["name"] === "string" ? payload["name"].trim() : "";
+  const transport = payload["transport"];
+  if (transport !== "stdio" && transport !== "sse" && transport !== "http") {
+    return sendError(res, 400, "bad-mcp-config", t("web.mcp_add_bad_transport", void 0, lang));
+  }
+  const outcome = await ctx.runtime.mcp.add({
+    name,
+    transport,
+    ...typeof payload["command"] === "string" ? { command: payload["command"].trim() } : {},
+    ...Array.isArray(payload["args"]) ? { args: stringList(payload["args"]) } : {},
+    ...typeof payload["url"] === "string" ? { url: payload["url"].trim() } : {},
+    ...payload["env"] === void 0 ? {} : { env: stringMap(payload["env"]) }
+  });
+  if (!outcome.ok) {
+    return sendError(res, ...addFailure(outcome.reason, outcome.detail, name, lang));
+  }
+  sendJson(res, 200, {
+    server: toWireMcp(outcome.status),
+    configPath: outcome.configPath
+  });
+}
+function addFailure(reason, detail, name, lang) {
+  if (reason === "invalid-name") {
+    return [400, "bad-mcp-name", t("web.mcp_add_bad_name", { name }, lang)];
+  }
+  if (reason === "invalid-config") return [400, "bad-mcp-config", detail];
+  if (reason === "duplicate")
+    return [409, "mcp-name-taken", t("web.mcp_add_taken", { name }, lang)];
+  return [409, "mcp-config-unwritable", t("web.mcp_add_unwritable", { detail }, lang)];
+}
+function stringList(value) {
+  return value.filter((v) => typeof v === "string");
+}
+function stringMap(value) {
+  const out = {};
+  for (const [k, v] of Object.entries(asRecord(value))) {
+    if (typeof v === "string") out[k] = v;
+  }
+  return out;
+}
+function toRef(raw) {
+  return parseModelRef(raw);
+}
+function toWireSelection(selection) {
+  return { provider: selection.provider, model: selection.model, origin: selection.origin };
+}
+function sessionHasImages(session) {
+  const history = session?.getHistory() ?? [];
+  return history.some((m) => m.parts?.some((p) => p.type === "image"));
+}
+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
+  });
+}
+async function setModel(ctx, req, res, sessionId, lang) {
+  const live = ctx.runtime.sessionFactory.get(sessionId);
+  if (!live) return sendUnknownSession(res, sessionId);
+  const control = live.model;
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const input = readModelSetBody(asRecord(body.value));
+  if (!input.ok)
+    return sendError(res, 400, "bad-model", t("web.model_bad_request", void 0, lang));
+  const ref = input.model === null ? null : toRef(input.model);
+  if (ref === void 0) {
+    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 }
+  };
+  const result = ref === null ? control.reset(selectionCtx) : control.set(ref, selectionCtx);
+  const payload = result.ok ? {
+    ok: true,
+    selection: toWireSelection(result.selection),
+    contextLength: result.contextLength,
+    // **空数组也照发**，不判长度：那是界面的事。在这儿吞掉一个空数组
+    // 等于让「没有代价」和「这个字段不存在」在契约上长得一样
+    caveats: result.caveats
+  } : { ok: false, rejection: result.rejection };
+  sendJson(res, 200, payload);
+}
+function readModelSetBody(body) {
+  const { model, usedTokens } = body;
+  if (model !== null && (typeof model !== "string" || model.trim() === "")) return { ok: false };
+  const used = typeof usedTokens === "number" && Number.isFinite(usedTokens) && usedTokens >= 0 ? Math.floor(usedTokens) : void 0;
+  return {
+    ok: true,
+    model: model === null ? null : model.trim(),
+    ...used === void 0 ? {} : { usedTokens: used }
+  };
+}
+function planModeState(ctx, sessionId) {
+  if (!ctx.runtime.plan) return null;
+  const plan = ctx.runtime.sessionFactory.get(sessionId)?.plan;
+  if (!plan) return { active: false, from: null };
+  return { active: plan.active(), from: plan.from() };
+}
+async function setPlanMode(ctx, req, res, sessionId, lang) {
+  const live = ctx.runtime.sessionFactory.get(sessionId);
+  if (!live) return sendUnknownSession(res, sessionId);
+  const plan = live.plan;
+  if (!plan) {
+    return sendError(res, 503, "no-plan-mode", t("web.plan_mode_unavailable", void 0, lang));
+  }
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const action = asRecord(body.value)["action"];
+  if (typeof action !== "string" || !isWirePlanAction(action)) {
+    return sendError(
+      res,
+      400,
+      "bad-action",
+      t("web.plan_mode_bad_action", { actions: WIRE_PLAN_ACTIONS.join("/") }, lang)
+    );
+  }
+  const changed = action === "enter" ? plan.enter().ok : plan.leave() !== null;
+  sendJson(res, 200, {
+    mode: { active: plan.active(), from: plan.from() },
+    changed
+  });
+}
+
+// src/permission.ts
+var REFUSAL = {
+  "managed-bypass-disabled": "managed"
+};
+function blockedLevels(managed) {
+  return managed.bypassDisabled ? [{ level: "bypass", reason: "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)
+  };
+}
+function getPermission(ctx, res, sessionId, _lang) {
+  if (!ctx.hub.has(sessionId)) return sendUnknownSession(res, sessionId);
+  sendJson(res, 200, permissionState(ctx, sessionId));
+}
+async function setPermission(ctx, req, res, sessionId, lang) {
+  const live = ctx.runtime.sessionFactory.get(sessionId);
+  if (!live) return sendUnknownSession(res, sessionId);
+  const perms = live.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 level = asRecord(body.value)["level"];
+  if (typeof level !== "string" || !isPermissionLevel(level)) {
+    return sendError(
+      res,
+      400,
+      "bad-level",
+      t("web.permission_bad_level", { levels: PERMISSION_LEVELS.join("/") }, lang)
+    );
+  }
+  const before = perms.level();
+  const result = perms.setLevel(level);
+  const state = permissionState(ctx, sessionId);
+  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)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  const live = ctx.runtime.sessionFactory.get(sessionId);
+  const markdown = live ? live.plan?.approvedPlan() ?? null : ctx.runtime.sessionStore?.loadPlan(sessionId) ?? null;
+  sendJson(res, 200, {
+    plan: normalize(markdown),
+    mode: planModeState(ctx, sessionId)
+  });
+}
+function normalize(markdown) {
+  return markdown?.trim() ? markdown : null;
+}
+function toWireProvider(option) {
+  return {
+    type: option.type,
+    label: option.label,
+    envVar: option.envVar,
+    hasKey: option.hasKey
+  };
+}
+function toWireSuggestions(view) {
+  return {
+    provider: view.provider,
+    models: view.models,
+    source: view.source,
+    status: view.status
+  };
+}
+function listProviders(ctx, res, _lang) {
+  sendJson(res, 200, {
+    providers: ctx.runtime.modelCatalog.providers().map(toWireProvider)
+  });
+}
+async function discoverProviderModels(ctx, req, res, type, lang) {
+  if (!isProviderType(type)) {
+    return sendError(res, 404, "unknown-provider", t("web.provider_unknown", { name: type }, lang));
+  }
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const refresh = asRecord(body.value).refresh === true;
+  const suggestions = await ctx.runtime.modelCatalog.discover(type, { refresh });
+  sendJson(res, 200, {
+    suggestions: toWireSuggestions(suggestions)
+  });
+}
+async function addRole(ctx, req, res, lang) {
+  if (ctx.lanExposed) {
+    return sendError(
+      res,
+      403,
+      "role-add-lan-exposed",
+      t("web.role_add_lan_exposed", void 0, lang)
+    );
+  }
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const payload = asRecord(body.value);
+  const outcome = ctx.runtime.roleWrite.add(
+    {
+      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"]) } : {},
+      ...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
+  });
+}
+function addFailure2(reason, detail, lang) {
+  if (reason === "invalid-name") return [400, "bad-role-name", detail];
+  if (reason === "invalid-field")
+    return [400, "bad-role-field", t("web.role_add_bad_field", { detail }, lang)];
+  if (reason === "unknown-tool") return [400, "bad-role-tools", detail];
+  if (reason === "duplicate") return [409, "role-name-taken", detail];
+  return [409, "role-unwritable", detail];
+}
+function stringList2(value) {
+  return value.filter((v) => typeof v === "string");
+}
+function stringList3(value) {
+  if (!Array.isArray(value)) return null;
+  const out = [];
+  for (const item of value) {
+    if (typeof item !== "string" || item.trim().length === 0) return null;
+    out.push(item);
+  }
+  return out;
+}
+function operationList(value) {
+  if (!Array.isArray(value)) return null;
+  const out = [];
+  for (const item of value) {
+    if (typeof item !== "string" || !isOperationType(item)) return null;
+    out.push(item);
+  }
+  return out;
+}
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function parseTrigger(value) {
+  const raw = asRecord(value);
+  const kind = raw["kind"];
+  const at = raw["at"];
+  if (kind === "interval") {
+    const every = finite(raw["everyMinutes"]);
+    return every === null ? null : { kind: "interval", everyMinutes: every };
+  }
+  if (typeof at !== "string") return null;
+  if (kind === "once") {
+    const date = raw["date"];
+    return typeof date === "string" ? { kind: "once", date, at } : null;
+  }
+  if (kind !== "cron") return null;
+  const cycle = raw["cycle"];
+  if (cycle === "daily") return { kind: "cron", cycle: "daily", at };
+  if (cycle === "weekly") {
+    const days = weekdayList(raw["weekdays"]);
+    return days === null ? null : { kind: "cron", cycle: "weekly", at, weekdays: days };
+  }
+  if (cycle === "monthly") {
+    const days = numberList(raw["days"]);
+    return days === null ? null : { kind: "cron", cycle: "monthly", at, days };
+  }
+  return null;
+}
+function weekdayList(value) {
+  if (!Array.isArray(value)) return null;
+  const out = [];
+  for (const item of value) {
+    if (typeof item !== "number" || !Number.isInteger(item) || item < 0 || item > 6) return null;
+    out.push(item);
+  }
+  return out;
+}
+function numberList(value) {
+  if (!Array.isArray(value)) return null;
+  const out = [];
+  for (const item of value) {
+    if (typeof item !== "number" || !Number.isInteger(item)) return null;
+    out.push(item);
+  }
+  return out;
+}
+function optionals(raw, lang) {
+  const out = {};
+  for (const key of ["name", "prompt", "model", "workDir", "startDate", "endDate"]) {
+    const value = raw[key];
+    if (value === void 0) continue;
+    if (value === null) {
+      if (key === "name" || key === "prompt") {
+        return { ok: false, message: t("web.schedule_bad_field", { field: key }, lang) };
+      }
+      out[key] = "";
+      continue;
+    }
+    if (typeof value !== "string") {
+      return { ok: false, message: t("web.schedule_bad_field", { field: key }, lang) };
+    }
+    out[key] = value;
+  }
+  for (const key of ["maxTurns", "maxBudgetUsd", "timeoutMs"]) {
+    const value = raw[key];
+    if (value === void 0) continue;
+    const num = finite(value);
+    if (num === null)
+      return { ok: false, message: t("web.schedule_bad_field", { field: key }, lang) };
+    out[key] = num;
+  }
+  for (const key of ["allowTools", "allowRules"]) {
+    const value = raw[key];
+    if (value === void 0) continue;
+    const list = stringList3(value);
+    if (list === null)
+      return { ok: false, message: t("web.schedule_bad_field", { field: key }, lang) };
+    out[key] = list;
+  }
+  if (raw["allowOperations"] !== void 0) {
+    const ops = operationList(raw["allowOperations"]);
+    if (ops === null) {
+      return {
+        ok: false,
+        message: t("web.schedule_bad_operation", { types: OPERATION_TYPES.join("/") }, lang)
+      };
+    }
+    out.allowOperations = ops;
+  }
+  if (raw["enabled"] !== void 0) {
+    if (typeof raw["enabled"] !== "boolean") {
+      return { ok: false, message: t("web.schedule_bad_field", { field: "enabled" }, lang) };
+    }
+    out.enabled = raw["enabled"];
+  }
+  if (raw["permission"] !== void 0) {
+    const level = raw["permission"];
+    if (typeof level !== "string" || !isPermissionLevel(level)) {
+      return { ok: false, message: t("web.schedule_bad_permission", void 0, lang) };
+    }
+    out.permission = level;
+  }
+  if (raw["trigger"] !== void 0) {
+    const trigger = parseTrigger(raw["trigger"]);
+    if (trigger === null)
+      return { ok: false, message: t("web.schedule_bad_trigger", void 0, lang) };
+    out.trigger = trigger;
+  }
+  return { ok: true, value: out };
+}
+function bypassAcknowledged(body) {
+  return asRecord(body)["bypassAcknowledged"] === true;
+}
+function parseCreate(body, lang) {
+  const raw = asRecord(body);
+  const name = raw["name"];
+  const prompt = raw["prompt"];
+  const permission = raw["permission"];
+  const budget = finite(raw["maxBudgetUsd"]);
+  if (typeof name !== "string" || typeof prompt !== "string") {
+    return { ok: false, message: t("web.schedule_create_incomplete", void 0, lang) };
+  }
+  if (typeof permission !== "string" || !isPermissionLevel(permission)) {
+    return { ok: false, message: t("web.schedule_bad_permission", void 0, lang) };
+  }
+  const trigger = parseTrigger(raw["trigger"]);
+  if (trigger === null)
+    return { ok: false, message: t("web.schedule_bad_trigger", void 0, lang) };
+  if (budget === null)
+    return { ok: false, message: t("web.schedule_budget_required", void 0, lang) };
+  const rest = optionals(raw, lang);
+  if (!rest.ok) return rest;
+  return {
+    ok: true,
+    // 顺序有意义：`rest` 里那几格已经收窄过，五个必填的**后写**，
+    // 于是一个把 `name` 同时写在两处的请求体不会得到两个答案
+    value: { ...rest.value, name, prompt, permission, trigger, maxBudgetUsd: budget }
+  };
+}
+function parseUpdate(body, lang) {
+  return optionals(asRecord(body), lang);
+}
+function parseFix(body, lang) {
+  const runId = asRecord(body)["runId"];
+  if (typeof runId !== "string" || runId.trim().length === 0) {
+    return { ok: false, message: t("web.schedule_fix_needs_run", void 0, 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 toWireRow(control, def) {
+  return {
+    schedule: def,
+    nextRunAt: def.enabled ? nextRunAt(def.trigger, Date.now(), def.startDate, def.endDate) : null,
+    allowlistApplies: control.needsAllowlist(def.permission)
+  };
+}
+function defaultsOf() {
+  return {
+    maxTurns: SCHEDULE_DEFAULTS.maxTurns,
+    timeoutMs: SCHEDULE_DEFAULTS.timeoutMs,
+    allowTools: SCHEDULE_DEFAULT_ALLOWLIST.allowTools,
+    allowOperations: SCHEDULE_DEFAULT_ALLOWLIST.allowOperations,
+    allowRules: SCHEDULE_DEFAULT_ALLOWLIST.allowRules
+  };
+}
+async function listSchedules(ctx, res, _lang) {
+  const control = schedulesOf(ctx);
+  const payload = {
+    schedules: control.list().map((def) => toWireRow(control, def)),
+    capability: await control.capability(),
+    defaults: defaultsOf(),
+    recentRuns: control.recentRuns(RECENT_RUNS_LIMIT)
+  };
+  sendJson(res, 200, payload);
+}
+function getSchedule(ctx, res, id, lang) {
+  const control = schedulesOf(ctx);
+  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);
+  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);
+  if (!parsed.ok) return sendError(res, 400, "bad-schedule", parsed.message);
+  const control = schedulesOf(ctx);
+  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);
+  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);
+  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);
+  sendJson(res, 200, { removed });
+}
+async function runSchedule(ctx, res, id, lang) {
+  const control = schedulesOf(ctx);
+  if (!control.get(id)) return sendNotFound(res, id, lang);
+  const result = await control.fire(id, { manual: true });
+  const payload = {
+    status: result.status,
+    exitCode: result.exitCode,
+    ...result.run ? { run: result.run } : {},
+    ...result.detail === void 0 ? {} : { detail: result.detail }
+  };
+  sendJson(res, 200, payload);
+}
+async function fixSchedule(ctx, req, res, id, lang) {
+  const control = schedulesOf(ctx);
+  const def = control.get(id);
+  if (!def) return sendNotFound(res, id, lang);
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const parsed = parseFix(body.value, lang);
+  if (!parsed.ok) return sendError(res, 400, "bad-schedule", parsed.message);
+  const run = control.runs(id, RUNS_LIMIT).find((one) => one.id === parsed.value);
+  if (!run) {
+    return sendError(
+      res,
+      404,
+      "not-found",
+      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);
+  }
+  if (added.length === 0) {
+    return sendJson(res, 200, {
+      added: [],
+      row: toWireRow(control, def)
+    });
+  }
+  const saved = await control.update(id, { allowRules: [...existing] });
+  const next = saved.schedule ?? def;
+  sendJson(res, 200, {
+    added,
+    row: toWireRow(control, next)
+  });
+}
+function getRecording(ctx, res, id, runId, lang) {
+  const control = schedulesOf(ctx);
+  if (!control.get(id)) return sendNotFound(res, id, lang);
+  const run = control.runs(id, RUNS_LIMIT).find((one) => one.id === runId);
+  if (!run) {
+    return sendError(res, 404, "not-found", t("web.schedule_run_unknown", { runId }, lang));
+  }
+  sendJson(res, 200, toRecording(run));
+}
+function toRecording(run) {
+  if (run.logPath === void 0) {
+    return { runId: run.id, frames: [], missing: true, truncated: false };
+  }
+  const frames = readRecording(run.logPath);
+  if (frames.length === 0) {
+    return { runId: run.id, frames: [], missing: true, truncated: false };
+  }
+  const truncated = frames.length > MAX_RECORDING_FRAMES;
+  return {
+    runId: run.id,
+    frames: truncated ? frames.slice(0, MAX_RECORDING_FRAMES) : frames,
+    missing: false,
+    truncated
+  };
+}
+function toSaveResponse(control, saved) {
+  return {
+    ok: saved.issues.length === 0,
+    issues: saved.issues,
+    ...saved.schedule ? { row: toWireRow(control, saved.schedule) } : {},
+    ...saved.registration ? { registration: saved.registration } : {}
+  };
+}
+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() : "";
+}
+function toWireIssues2(issues) {
+  return (issues ?? []).map((i) => ({ path: i.path, message: i.message }));
+}
+function toWireEntry(entry) {
+  return {
+    name: entry.name,
+    category: entry.category,
+    description: entry.description,
+    files: entry.files,
+    bytes: entry.bytes,
+    conflict: entry.conflict ?? null
+  };
+}
+async function previewSkillImport(ctx, req, res, lang) {
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const source = pathOf(asRecord(body.value));
+  const outcome = await ctx.runtime.skillImport.preview(source, lang);
+  if (!outcome.ok) {
+    return sendJson(res, 200, {
+      ok: false,
+      source,
+      form: null,
+      skills: [],
+      issues: toWireIssues2(outcome.issues),
+      token: "",
+      detail: outcome.detail,
+      reason: outcome.reason
+    });
+  }
+  const preview = outcome.preview;
+  sendJson(res, 200, {
+    ok: true,
+    source: preview.source,
+    form: preview.form,
+    skills: preview.skills.map(toWireEntry),
+    issues: toWireIssues2(preview.issues),
+    token: preview.token,
+    detail: null,
+    reason: null
+  });
+}
+async function importSkills(ctx, req, res, lang) {
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const payload = asRecord(body.value);
+  const source = pathOf(payload);
+  const token = typeof payload["token"] === "string" ? payload["token"] : "";
+  const outcome = await ctx.runtime.skillImport.import(source, token, lang);
+  if (!outcome.ok) {
+    return sendJson(res, 200, {
+      ok: false,
+      imported: [],
+      skipped: toWireIssues2(outcome.issues),
+      detail: outcome.detail,
+      reason: outcome.reason
+    });
+  }
+  sendJson(res, 200, {
+    // 一个都没落地时**回 `ok: false`**：这一格答的是「这次导入达成了没有」，
+    // 而不是「这次请求跑通了没有」。全都撞名的那一次要是回 true，界面上会出现
+    // 一句「导入成功」加一张空列表 —— 判据同 `WireMcpReconnectResponse.ok`
+    // 那条「别从别的字段反推」
+    ok: outcome.imported.length > 0,
+    imported: [...outcome.imported],
+    skipped: toWireIssues2(outcome.skipped),
+    detail: null,
+    reason: null
+  });
+}
+
+// src/sse.ts
+var DEFAULT_HEARTBEAT_MS = 15e3;
+function parseLastEventId(req) {
+  const raw = req.headers["last-event-id"];
+  const value = Array.isArray(raw) ? raw[0] : raw;
+  if (typeof value !== "string" || value.trim().length === 0) return void 0;
+  const parsed = Number(value.trim());
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : void 0;
+}
+var SseConnection = class {
+  constructor(res, heartbeatMs = DEFAULT_HEARTBEAT_MS) {
+    this.res = res;
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+      "Referrer-Policy": "no-referrer",
+      "X-Content-Type-Options": "nosniff"
+    });
+    res.flushHeaders();
+    this.heartbeat = setInterval(() => this.ping(), heartbeatMs);
+    this.heartbeat.unref();
+  }
+  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}
+` : "";
+    this.res.write(`${body}data: ${JSON.stringify(frame)}
+
+`);
+  }
+  /** 注释行心跳：SSE 规范里以 `:` 开头的行被客户端忽略，纯粹用来探活 */
+  ping() {
+    if (this.closed) return;
+    this.res.write(": ping\n\n");
+  }
+  /** 幂等：客户端断开和服务端 close 会各调一次 */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    clearInterval(this.heartbeat);
+    this.res.end();
+  }
+};
+var TASK_TAIL_BYTES = 8 * 1024;
+var LIVE_TASKS = {
+  list: (sessionId) => listBackgroundTasks(sessionId),
+  output: (sessionId, id, since) => backgroundTaskOutput(sessionId, id, since)
+};
+function toWireTask(sessionId, info, registry) {
+  const since = Math.max(0, info.outputBytes - TASK_TAIL_BYTES);
+  const chunk = registry.output(sessionId, info.id, since);
+  if (!chunk) return { info, output: "", omittedBytes: info.outputBytes };
+  return {
+    info,
+    output: chunk.output,
+    omittedBytes: Math.max(0, chunk.nextCursor - chunk.output.length)
+  };
+}
+function collectTasks(sessionId, registry) {
+  return { tasks: registry.list(sessionId).map((info) => toWireTask(sessionId, info, registry)) };
+}
+function getTasks(ctx, res, sessionId, _lang, registry = LIVE_TASKS) {
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  sendJson(res, 200, collectTasks(sessionId, registry));
+}
+var DIR_PAGE_LIMIT = 1e3;
+function workspaceAnchors(workspaces) {
+  const seen = /* @__PURE__ */ new Set();
+  const entries = [];
+  const known = new Set(workspaces.known().map((one) => resolve(one.root)));
+  const push = (raw, group) => {
+    const path = resolve(raw);
+    if (seen.has(path)) return;
+    seen.add(path);
+    entries.push({
+      name: displayName2(path),
+      path,
+      known: known.has(path),
+      readable: canList(path),
+      group
+    });
+  };
+  push(homedir(), "home");
+  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
+  };
+}
+function listWorkspaceDirs(workspaces, raw, opts = {}) {
+  if (raw.length === 0 || !isAbsolute(raw)) {
+    return { ok: false, reason: "not-absolute", path: raw };
+  }
+  const path = resolve(raw);
+  let dirents;
+  try {
+    dirents = readdirSync(path, { withFileTypes: true });
+  } catch (cause) {
+    return { ok: false, reason: readdirFailure(cause), path };
+  }
+  const known = new Set(workspaces.known().map((one) => resolve(one.root)));
+  const kept = [];
+  let omitted = 0;
+  let hidden = 0;
+  for (const dirent of dirents) {
+    if (!dirent.isDirectory()) continue;
+    if (!opts.hidden && dirent.name.startsWith(".")) {
+      hidden += 1;
+      continue;
+    }
+    if (kept.length >= DIR_PAGE_LIMIT) {
+      omitted += 1;
+      continue;
+    }
+    const child = resolve(path, dirent.name);
+    kept.push({
+      name: dirent.name,
+      path: child,
+      known: known.has(child),
+      // 列不开的行**照样画出来**，只是点不动 —— 藏掉的话用户会以为它不存在
+      readable: canList(child),
+      group: "child"
+    });
+  }
+  return {
+    ok: true,
+    view: {
+      path,
+      // 已经在根上时 `dirname` 回它自己 —— 那时没有「上一层」可去
+      parent: parentOf(path),
+      entries: kept,
+      omitted,
+      // 带 `?hidden=1` 那一发这一格必然是 0：那时上面那一支根本不进
+      hidden
+    }
+  };
+}
+function readdirFailure(cause) {
+  const code = cause?.code;
+  if (code === "EACCES" || code === "EPERM") return "denied";
+  if (code === "ENOTDIR") return "not-a-directory";
+  return "missing";
+}
+function canList(path) {
+  try {
+    accessSync(path, constants.R_OK | constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parentOf(path) {
+  const up = dirname(path);
+  return up === path ? null : up;
+}
+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;
+  const path = dirsQuery(query);
+  if (path === void 0) {
+    return sendJson(res, 200, workspaceAnchors(ctx.runtime.workspaces));
+  }
+  const outcome = listWorkspaceDirs(ctx.runtime.workspaces, path, {
+    hidden: hiddenQuery(query)
+  });
+  if (outcome.ok) return sendJson(res, 200, outcome.view);
+  if (outcome.reason === "denied") {
+    return sendError(
+      res,
+      403,
+      "workspace-denied",
+      t("web.dirs_denied", { path: outcome.path }, lang)
+    );
+  }
+  if (outcome.reason === "missing") {
+    return sendError(res, 404, "not-found", t("web.dirs_missing", { path: outcome.path }, lang));
+  }
+  sendError(
+    res,
+    400,
+    "bad-workspace",
+    outcome.reason === "not-absolute" ? t("web.dirs_not_absolute", { path: outcome.path }, lang) : t("web.dirs_not_a_directory", { path: outcome.path }, lang)
+  );
+}
+function dirsQuery(query) {
+  const value = query.get("path")?.trim();
+  return value ? value : void 0;
+}
+function hiddenQuery(query) {
+  const value = query.get("hidden")?.trim().toLowerCase();
+  return value === "1" || value === "true";
+}
+async function createWorkspaceDir(req, res, lang) {
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const payload = asRecord(body.value);
+  const parent = typeof payload["parent"] === "string" ? payload["parent"].trim() : "";
+  const name = typeof payload["name"] === "string" ? payload["name"].trim() : "";
+  if (parent.length === 0 || !isAbsolute(parent)) {
+    return sendError(
+      res,
+      400,
+      "bad-workspace",
+      t("web.mkdir_parent_not_absolute", { parent }, lang)
+    );
+  }
+  if (!isSingleSegment(name)) {
+    return sendError(res, 400, "bad-workspace", t("web.mkdir_bad_name", { name }, lang));
+  }
+  const path = resolve(parent, name);
+  try {
+    mkdirSync(path);
+  } catch (cause) {
+    return sendError(res, ...mkdirFailure(cause, path, lang));
+  }
+  sendJson(res, 200, {
+    entry: {
+      // `basename` 就是 `name`（上面校验过它是单段），这儿不再算一次
+      name,
+      path,
+      // 两个字段**钉死**，判据在 `WireCreateWorkspaceResponse` 上：刚建的空目录
+      // 必然读得开，而且它**不在**「已知工作区」清单里（这条路不记那一笔）
+      readable: true,
+      known: false,
+      group: "child"
+    }
+  });
+}
+function isSingleSegment(name) {
+  if (name.length === 0) return false;
+  if (name === "." || name === "..") return false;
+  return !name.includes("/") && !name.includes(sep);
+}
+function mkdirFailure(cause, path, lang) {
+  const code = cause?.code;
+  if (code === "EEXIST") return [409, "workspace-exists", t("web.mkdir_exists", { path }, lang)];
+  if (code === "EACCES" || code === "EPERM") {
+    return [403, "workspace-denied", t("web.mkdir_denied", { path }, lang)];
+  }
+  if (code === "ENOENT") return [404, "not-found", t("web.mkdir_parent_missing", { path }, lang)];
+  return [500, "internal", t("web.mkdir_failed", { path }, lang)];
+}
+var GIT_TIMEOUT_MS = 1e4;
+var GIT_MAX_BUFFER = 16 * 1024 * 1024;
+function runGit(cwd, args) {
+  return new Promise((resolve4) => {
+    execFile(
+      "git",
+      [...args],
+      { cwd, timeout: GIT_TIMEOUT_MS, maxBuffer: GIT_MAX_BUFFER, encoding: "buffer" },
+      (err, stdout) => {
+        if (err) return resolve4({ ok: false, error: err.message });
+        resolve4({ ok: true, stdout });
+      }
+    );
+  });
+}
+async function repoRoot(cwd) {
+  const result = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
+  if (!result.ok) return null;
+  const root = result.stdout.toString("utf-8").trim();
+  return root.length > 0 ? root : null;
+}
+async function hasHead(root) {
+  return (await runGit(root, ["rev-parse", "--verify", "--quiet", "HEAD"])).ok;
+}
+var NULL_SHA = /^0+$/;
+async function rawChanges(root) {
+  const result = await runGit(root, ["diff", "--raw", "-z", "HEAD", "--"]);
+  if (!result.ok) return [];
+  return parseRawZ(result.stdout.toString("utf-8"));
+}
+function parseRawZ(text) {
+  const tokens = text.split("\0");
+  const changes = [];
+  let i = 0;
+  while (i < tokens.length) {
+    const meta = tokens[i];
+    if (meta === void 0 || !meta.startsWith(":")) {
+      i += 1;
+      continue;
+    }
+    const parts = meta.slice(1).split(" ");
+    const oldSha = parts[2] ?? "";
+    const status = (parts[4] ?? "").trim();
+    const renamed = status.startsWith("R") || status.startsWith("C");
+    const first = tokens[i + 1];
+    const second = renamed ? tokens[i + 2] : void 0;
+    i += renamed ? 3 : 2;
+    if (first === void 0 || renamed && second === void 0) break;
+    const path = renamed ? second : first;
+    changes.push({
+      status: status.charAt(0),
+      path,
+      ...renamed ? { oldPath: first } : {},
+      oldSha: NULL_SHA.test(oldSha) ? null : oldSha
+    });
+  }
+  return changes;
+}
+async function treeBlobSizes(root) {
+  const sizes = /* @__PURE__ */ new Map();
+  const result = await runGit(root, ["ls-tree", "-r", "-l", "-z", "HEAD"]);
+  if (!result.ok) return sizes;
+  for (const record of splitZ(result.stdout.toString("utf-8"))) {
+    const tab = record.indexOf("	");
+    if (tab < 0) continue;
+    const columns = record.slice(0, tab).split(/\s+/).filter(Boolean);
+    const sha = columns[2];
+    const size = Number(columns[3]);
+    if (columns[1] === "blob" && sha && Number.isFinite(size)) sizes.set(sha, size);
+  }
+  return sizes;
+}
+async function untrackedFiles(root) {
+  const result = await runGit(root, ["ls-files", "-z", "--others", "--exclude-standard"]);
+  if (!result.ok) return [];
+  return splitZ(result.stdout.toString("utf-8"));
+}
+async function trackedFiles(root) {
+  const result = await runGit(root, ["ls-files", "-z"]);
+  if (!result.ok) return [];
+  return splitZ(result.stdout.toString("utf-8"));
+}
+async function catFileBlob(root, sha) {
+  const result = await runGit(root, ["cat-file", "blob", sha]);
+  return result.ok ? result.stdout : null;
+}
+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;
+var BINARY_SNIFF_BYTES = 8e3;
+var ABSENT = { kind: "absent" };
+async function collectWorkspaceDiff(opts) {
+  const root = await repoRoot(opts.workDir);
+  return root === null ? await checkpointDiff(opts) : await gitDiff(root);
+}
+async function gitDiff(root) {
+  const wanted = await collectGitPaths(root);
+  const notes = [];
+  const truncated = wanted.length > MAX_DIFF_FILES;
+  const picked = truncated ? wanted.slice(0, MAX_DIFF_FILES) : wanted;
+  if (truncated) notes.push("truncated");
+  if (wanted.length === 0) notes.push("no-changes");
+  const sizes = picked.some((p) => p.oldSha !== null) ? await treeBlobSizes(root) : /* @__PURE__ */ new Map();
+  const files = [];
+  for (const item of picked) {
+    const old = await gitSide(root, item.oldSha, sizes);
+    const fresh = await worktreeSide(join(root, ...item.path.split("/")));
+    files.push(describe2(item.path, old, fresh));
+  }
+  return { source: "git", root, files, truncated, notes };
+}
+async function collectGitPaths(root) {
+  const byPath = /* @__PURE__ */ new Map();
+  if (await hasHead(root)) {
+    for (const change of await rawChanges(root)) {
+      if (change.oldPath !== void 0) {
+        byPath.set(change.oldPath, { path: change.oldPath, oldSha: change.oldSha });
+      }
+      byPath.set(change.path, {
+        path: change.path,
+        oldSha: change.oldPath === void 0 ? change.oldSha : null
+      });
+    }
+  } else {
+    for (const path of await trackedFiles(root)) byPath.set(path, { path, oldSha: null });
+  }
+  for (const path of await untrackedFiles(root)) {
+    if (!byPath.has(path)) byPath.set(path, { path, oldSha: null });
+  }
+  return [...byPath.values()].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+async function gitSide(root, sha, sizes) {
+  if (sha === null) return ABSENT;
+  const known = sizes.get(sha);
+  if (known !== void 0 && known > MAX_DIFF_BYTES) return { kind: "oversize", bytes: known };
+  const data = await catFileBlob(root, sha);
+  if (data === null) return { kind: "oversize", bytes: known ?? -1 };
+  return { kind: "content", data };
+}
+async function checkpointDiff(opts) {
+  const notes = ["not-a-git-repo"];
+  const paths = await checkpointPaths(opts.checkpoints);
+  if (paths.length === 0) {
+    notes.push(opts.checkpoints === null ? "no-workspace-history" : "no-changes");
+    return { source: "none", root: opts.workDir, files: [], truncated: false, notes };
+  }
+  const truncated = paths.length > MAX_DIFF_FILES;
+  const picked = truncated ? paths.slice(0, MAX_DIFF_FILES) : paths;
+  if (truncated) notes.push("truncated");
+  const files = [];
+  for (const absolute of picked) {
+    const fresh = await worktreeSide(absolute);
+    files.push(
+      describe2(displayPath(opts.workDir, absolute), ABSENT, fresh, {
+        status: fresh.kind === "absent" ? "deleted" : "modified",
+        omitted: "no-snapshot"
+      })
+    );
+  }
+  return { source: "checkpoints", root: opts.workDir, files, truncated, notes };
+}
+async function checkpointPaths(checkpoints) {
+  if (!checkpoints) return [];
+  const paths = /* @__PURE__ */ new Set();
+  try {
+    for (const summary of await checkpoints.list()) {
+      const preview = await checkpoints.preview(summary.turnIndex);
+      if (!preview) continue;
+      for (const plan of [...preview.files, ...preview.conflicts]) {
+        if (plan.action !== "skip") paths.add(plan.path);
+      }
+    }
+  } catch {
+  }
+  return [...paths].sort();
+}
+function displayPath(workDir, absolute) {
+  const rel = relative(workDir, absolute);
+  if (rel.length === 0 || rel.startsWith("..") || isAbsolute(rel)) return absolute;
+  return rel.split(sep).join("/");
+}
+async function worktreeSide(absolute) {
+  try {
+    const info = await stat(absolute);
+    if (!info.isFile()) return ABSENT;
+    if (info.size > MAX_DIFF_BYTES) return { kind: "oversize", bytes: info.size };
+    return { kind: "content", data: await readFile(absolute) };
+  } catch {
+    return ABSENT;
+  }
+}
+function describe2(path, old, fresh, override = {}) {
+  const status = override.status ?? (old.kind === "absent" ? "added" : fresh.kind === "absent" ? "deleted" : "modified");
+  const oldBytes = bytesOf(old);
+  const newBytes = bytesOf(fresh);
+  const hard = omitReason(old, fresh);
+  if (hard !== void 0) {
+    return { path, status, oldContent: null, newContent: null, oldBytes, newBytes, omitted: hard };
+  }
+  return {
+    path,
+    status,
+    oldContent: textOf(old),
+    newContent: textOf(fresh),
+    oldBytes,
+    newBytes,
+    ...override.omitted === void 0 ? {} : { omitted: override.omitted }
+  };
+}
+function bytesOf(side) {
+  if (side.kind === "absent") return null;
+  if (side.kind === "oversize") return side.bytes < 0 ? null : side.bytes;
+  return side.data.byteLength;
+}
+function textOf(side) {
+  return side.kind === "content" ? side.data.toString("utf-8") : null;
+}
+function omitReason(old, fresh) {
+  if (isBinary(old) || isBinary(fresh)) return "binary";
+  if (old.kind === "oversize" || fresh.kind === "oversize") return "too-large";
+  return void 0;
+}
+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);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const payload = asRecord(body.value);
+  const field = readWorkspaceField(payload, lang);
+  if (!field.ok) return sendError(res, 400, "bad-workspace", field.message);
+  const defer = payload["deferWorkspace"] === true;
+  if (defer && field.dir !== null) {
+    return sendError(res, 400, "bad-request", t("web.workspace_defer_with_root", void 0, lang));
+  }
+  if (defer && payload["create"] !== true) {
+    return sendError(
+      res,
+      400,
+      "bad-request",
+      t("web.workspace_defer_needs_create", void 0, lang)
+    );
+  }
+  if (field.dir === null && payload["create"] !== true) {
+    const sessionId = ctx.runtime.sessionId;
+    const bound = ctx.runtime.workspaces.of(sessionId);
+    return sendJson(res, 200, {
+      sessionId,
+      created: false,
+      workspace: bound ? toWireSessionWorkspace(bound) : null
+    });
+  }
+  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 }
+  });
+  if (!outcome.ok) {
+    if (outcome.reason === "unavailable") {
+      const mapped2 = unavailableToHttp(lang);
+      return sendError(res, mapped2.status, mapped2.code, mapped2.message);
+    }
+    if (outcome.reason === "unknown-role") {
+      const mapped2 = unknownRoleToHttp(outcome.detail, lang);
+      return sendError(res, mapped2.status, mapped2.code, mapped2.message);
+    }
+    const mapped = bindFailureToHttp(outcome, lang);
+    return sendError(res, mapped.status, mapped.code, mapped.message);
+  }
+  ctx.hub.register(outcome.live.session);
+  if (defer) ctx.runtime.workspaces.defer(outcome.live.sessionId);
+  sendJson(res, 200, {
+    sessionId: outcome.live.sessionId,
+    created: outcome.created,
+    workspace: outcome.live.workspace ? toWireSessionWorkspace(outcome.live.workspace) : null
+  });
+}
+function sessionWorkspace(ctx, res, sessionId, lang) {
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  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))
+    });
+  }
+  if (ctx.hub.has(sessionId) || ctx.hub.isCooled(sessionId)) {
+    return sendJson(res, 200, {
+      binding: { state: "none" }
+    });
+  }
+  sendError(res, 409, "not-live-session", t("web.workspace_not_live", void 0, lang));
+}
+async function bindWorkspace(ctx, req, res, sessionId, lang) {
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  const body = await readJsonBody(req);
+  if (!body.ok) return sendError(res, body.status, "bad-body", body.message);
+  const parsed = readBindWorkspaceBody(asRecord(body.value), lang);
+  if (!parsed.ok) return sendError(res, 400, "bad-workspace", parsed.message);
+  const state = ctx.runtime.workspaces.stateOf(sessionId);
+  if (state !== "unbound") {
+    return sendError(
+      res,
+      409,
+      "workspace-locked",
+      t("web.workspace_already_decided", void 0, lang)
+    );
+  }
+  if (parsed.kind === "none") {
+    ctx.runtime.workspaces.decideNone(sessionId);
+    return sendJson(res, 200, {
+      binding: { state: "none" }
+    });
+  }
+  const outcome = ctx.runtime.workspaces.bind(sessionId, parsed.root, lang);
+  if (!outcome.ok) {
+    const mapped = bindFailureToHttp(outcome, lang);
+    return sendError(res, mapped.status, mapped.code, mapped.message);
+  }
+  sendJson(res, 200, {
+    binding: { state: "bound", workspace: toWireSessionWorkspace(outcome.bound) }
+  });
+}
+async function sessionDiff(ctx, res, sessionId, _lang) {
+  if (!ctx.hub.has(sessionId) && !ctx.runtime.sessions?.get(sessionId)) {
+    return sendUnknownSession(res, sessionId);
+  }
+  const bound = ctx.runtime.workspaces.of(sessionId);
+  if (!bound) {
+    return sendJson(res, 200, {
+      source: "none",
+      root: "",
+      files: [],
+      truncated: false,
+      notes: ["no-workspace"]
+    });
+  }
+  sendJson(
+    res,
+    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"
+};
+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();
+    });
+  };
+}
+async function dispatch(opts, req, res) {
+  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]);
+  }
+  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);
+}
+function isRead(method) {
+  return method === "GET" || method === "HEAD";
+}
+function splitPath(pathname) {
+  return pathname.split("/").filter((s) => s.length > 0).map((s) => {
+    try {
+      return decodeURIComponent(s);
+    } catch {
+      return s;
+    }
+  });
+}
+async function handleApi(opts, req, res, method, segments) {
+  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);
+  if (resource === "sessions") {
+    return handleSessions(opts, req, res, method, first, second, detail, lang);
+  }
+  if (resource === "approvals" && first !== void 0 && method === "POST") {
+    return respondApproval(ctx, req, res, first);
+  }
+  if (resource === "questions" && first !== void 0 && method === "POST") {
+    return respondQuestion(ctx, req, res, first);
+  }
+  if (resource === "artifacts" && first !== void 0 && second !== void 0 && isRead(method)) {
+    return getArtifact(ctx, res, first, second);
+  }
+  if (resource === "mcp" && first === "config" && second === void 0 && isRead(method)) {
+    return readConfig(ctx, res, lang);
+  }
+  if (resource === "mcp" && first === "config" && second === void 0 && method === "PUT") {
+    return saveConfig(ctx, req, res, lang);
+  }
+  if (resource === "mcp" && first === "config" && second === "apply" && method === "POST") {
+    return applyConfig(ctx, req, res, lang);
+  }
+  if (resource === "mcp" && first !== void 0 && second === "reconnect" && method === "POST") {
+    return reconnectMcp(ctx, res, first, lang);
+  }
+  if (resource === "mcp" && first === void 0 && method === "POST") {
+    return addMcp(ctx, req, res, lang);
+  }
+  if (resource === "roles" && first === void 0 && method === "POST") {
+    return addRole(ctx, req, res, lang);
+  }
+  if (resource === "skills" && first === "import" && second === "preview" && method === "POST") {
+    return previewSkillImport(ctx, req, res, lang);
+  }
+  if (resource === "skills" && first === "import" && second === void 0 && method === "POST") {
+    return importSkills(ctx, req, res, lang);
+  }
+  if (resource === "providers" && first === void 0 && isRead(method)) {
+    return listProviders(ctx, res);
+  }
+  if (resource === "providers" && first !== void 0 && second === "models" && method === "POST") {
+    return discoverProviderModels(ctx, req, res, first, lang);
+  }
+  if (resource === "workspaces" && first === "dirs" && isRead(method)) {
+    return browseWorkspaceDirs(ctx, res, req.url, lang);
+  }
+  if (resource === "workspaces" && first === void 0 && method === "POST") {
+    return createWorkspaceDir(req, res, lang);
+  }
+  if (resource === "schedules") {
+    return handleSchedules(ctx, req, res, method, first, second, detail, tail, lang);
+  }
+  sendNoEndpoint(res, method, `/${segments.join("/")}`);
+}
+async function handleSchedules(ctx, req, res, method, scheduleId, action, runId, tail, lang) {
+  if (scheduleId === void 0) {
+    if (isRead(method)) return listSchedules(ctx, res);
+    if (method === "POST") return createSchedule(ctx, req, res, lang);
+    return methodNotAllowed(res, "GET, POST");
+  }
+  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 (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");
+  }
+  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}`);
+}
+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");
+  }
+  if (action === void 0) {
+    if (isRead(method)) return getSession(ctx, res, sessionId);
+    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");
+  }
+  if (action === "messages") {
+    if (isRead(method)) return listMessages(ctx, res, sessionId);
+    if (method === "POST") return postMessage(ctx, req, res, sessionId, lang);
+    return methodNotAllowed(res, "GET, POST");
+  }
+  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 === "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);
+  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" && 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 === "tasks" && isRead(method)) return getTasks(ctx, res, sessionId);
+  if (action === "plan" && isRead(method)) return getPlan(ctx, res, sessionId);
+  if (action === "plan" && method === "POST")
+    return setPlanMode(ctx, req, res, sessionId, lang);
+  if (action === "permission" && isRead(method)) {
+    return getPermission(ctx, res, sessionId);
+  }
+  if (action === "permission" && method === "POST") {
+    return setPermission(ctx, req, res, sessionId, lang);
+  }
+  if (action === "checkpoints" && isRead(method)) {
+    return detail === void 0 ? listCheckpoints(ctx, res, sessionId) : previewCheckpoint(ctx, res, sessionId, detail, lang);
+  }
+  if (action === "rewind" && method === "POST")
+    return rewind(ctx, req, res, sessionId, lang);
+  if (action === "workspace" && isRead(method)) {
+    return sessionWorkspace(ctx, res, sessionId, lang);
+  }
+  if (action === "workspace" && method === "POST") {
+    return bindWorkspace(ctx, req, res, sessionId, lang);
+  }
+  if (action === "diff" && isRead(method)) return sessionDiff(ctx, res, sessionId);
+  sendNoEndpoint(res, method, `/api/sessions/${sessionId}`);
+}
+function openStream(opts, req, res) {
+  const connection = new SseConnection(res, opts.heartbeatMs);
+  const unsubscribe = opts.ctx.hub.subscribe(
+    (frame) => connection.send(frame),
+    parseLastEventId(req)
+  );
+  const finish = () => {
+    unsubscribe();
+    connection.close();
+  };
+  req.on("close", finish);
+  res.on("close", finish);
+}
+function handleStatic(opts, res, pathname) {
+  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);
+  res.writeHead(200, {
+    ...baseHeaders(),
+    "Content-Type": "text/html; charset=utf-8",
+    "Content-Length": Buffer.byteLength(html)
+  });
+  res.end(html);
+}
+function searchQuery(rawUrl) {
+  const value = new URL(rawUrl ?? "/", "http://127.0.0.1").searchParams.get("q")?.trim();
+  return value ? value : void 0;
+}
+function redirectWithoutToken(res, rawUrl) {
+  const url = new URL(rawUrl ?? "/", "http://127.0.0.1");
+  url.searchParams.delete(WIRE_AUTH_TOKEN_PARAM);
+  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 methodNotAllowed(res, allow) {
+  sendError(res, 405, "method-not-allowed", `\u53EA\u652F\u6301 ${allow}`, { 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({
+    ...opts.host === void 0 ? {} : { host: opts.host },
+    ...opts.port === void 0 ? {} : { port: opts.port },
+    ...opts.token === void 0 ? {} : { token: opts.token }
+  });
+  if (!binding.ok) return binding;
+  const hub = new SessionHub({
+    ...opts.ringCapacity === void 0 ? {} : { ringCapacity: opts.ringCapacity },
+    ...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);
+  let handle = null;
+  const server = createServer((req, res) => {
+    if (handle) return handle(req, res);
+    res.writeHead(503, { "Cache-Control": "no-store" });
+    res.end();
+  });
+  const webRoot = opts.webRoot ?? defaultWebRoot();
+  const listened = await listen(server, binding.host, binding.port);
+  if (!listened.ok) return listened;
+  handle = buildHandler(opts, hub, binding, listened.port, webRoot);
+  return {
+    ok: true,
+    server: {
+      url: firstScreenUrl(binding.host, listened.port, binding.token, opts.ui ?? {}),
+      port: listened.port,
+      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)
+    }
+  };
+}
+function buildHandler(opts, hub, binding, port, webRoot) {
+  return createRequestHandler({
+    ctx: {
+      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 }),
+    ...webRoot === void 0 ? {} : { webRoot },
+    ...opts.heartbeatMs === void 0 ? {} : { heartbeatMs: opts.heartbeatMs }
+  });
+}
+function listen(server, host, port) {
+  return new Promise((resolve4) => {
+    const onError = (err) => {
+      server.removeListener("error", onError);
+      resolve4({ ok: false, error: describeListenError(err, host, port) });
+    };
+    server.once("error", onError);
+    server.listen(port, host, () => {
+      server.removeListener("error", onError);
+      const address = server.address();
+      resolve4({ ok: true, port: typeof address === "object" && address ? address.port : 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}`;
+  }
+  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`;
+  }
+  if (err.code === "EADDRNOTAVAIL") {
+    return `\u672C\u673A\u6CA1\u6709 ${host} \u8FD9\u4E2A\u5730\u5740`;
+  }
+  return `\u76D1\u542C ${host}:${port} \u5931\u8D25\uFF1A${err.message}`;
+}
+function makeCloser(server, hub, runtime) {
+  let closing = null;
+  return () => {
+    closing ??= (async () => {
+      hub.shutdown();
+      server.closeAllConnections();
+      await new Promise((resolve4) => server.close(() => resolve4()));
+      await runtime.dispose();
+    })();
+    return closing;
+  };
+}
+
+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 };