@prismshadow/penguin-server 0.0.1 → 0.1.0

package/dist/index.js

@@ -5,7 +5,7 @@ import { serve } from "@hono/node-server";
 // src/app.ts
 import fs16 from "fs";
 import fsp from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 import { Hono as Hono19 } from "hono";
 
 // src/db/database.ts
@@ -15,30 +15,30 @@ import path from "path";
 // src/db/schema.ts
 var SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS users (
-  user_id             TEXT PRIMARY KEY,            -- \u8BED\u4E49 id \u5373\u767B\u5F55\u540D\uFF1A^[a-z][a-z0-9_-]{1,31}$
+  user_id             TEXT PRIMARY KEY,            -- semantic id doubles as login name: ^[a-z][a-z0-9_-]{1,31}$
   password_hash       TEXT NOT NULL,               -- scrypt$N$r$p$salt$hash(base64)
-  is_admin            INTEGER NOT NULL DEFAULT 0,  -- \u5185\u7F6E admin\uFF08\u542F\u52A8\u65F6\u79CD\u5B50\uFF09\u4E3A 1
-  password_is_initial INTEGER NOT NULL DEFAULT 0,  -- 1=\u521D\u59CB\u5BC6\u7801\uFF08\u79CD\u5B50/\u7BA1\u7406\u5458\u8BBE\u7F6E\uFF09\uFF1B\u672C\u4EBA\u6539\u5BC6\u540E\u6E05 0
+  is_admin            INTEGER NOT NULL DEFAULT 0,  -- 1 for the built-in admin (seeded at startup)
+  password_is_initial INTEGER NOT NULL DEFAULT 0,  -- 1=initial password (seeded/admin-set); cleared once the user changes it
   created_at          TEXT NOT NULL
 );
 CREATE TABLE IF NOT EXISTS auth_sessions (
-  token_hash TEXT PRIMARY KEY,               -- sha256(token) hex\uFF1Bcookie \u53EA\u5B58\u539F\u59CB token
+  token_hash TEXT PRIMARY KEY,               -- sha256(token) hex; the cookie stores only the raw token
   user_id    TEXT NOT NULL REFERENCES users(user_id) ON DELETE CASCADE,
   created_at TEXT NOT NULL,
-  expires_at TEXT NOT NULL                   -- 7 \u5929\u6ED1\u52A8\u7EED\u671F\uFF08\u5269\u4F59 <6 \u5929\u5219\u7EED\u6EE1\uFF09
+  expires_at TEXT NOT NULL                   -- 7-day sliding renewal (topped up when <6 days remain)
 );
 CREATE TABLE IF NOT EXISTS projects (
-  project_id    TEXT PRIMARY KEY,            -- \u76EE\u5F55\u540D\u5373 id\uFF1B\u663E\u793A\u540D\u5728 project_config.toml
+  project_id    TEXT PRIMARY KEY,            -- directory name doubles as id; display name lives in project_config.toml
   owner_user_id TEXT NOT NULL REFERENCES users(user_id),
   created_at    TEXT NOT NULL
 );
-CREATE TABLE IF NOT EXISTS project_members (  -- \u4EC5 member \u6388\u6743\u5173\u7CFB\uFF1Bowner \u4E0D\u5165\u6B64\u8868
+CREATE TABLE IF NOT EXISTS project_members (  -- member grants only; owners are not stored here
   project_id TEXT NOT NULL REFERENCES projects(project_id) ON DELETE CASCADE,
   user_id    TEXT NOT NULL REFERENCES users(user_id) ON DELETE CASCADE,
   created_at TEXT NOT NULL,
   PRIMARY KEY (project_id, user_id)
 );
-CREATE TABLE IF NOT EXISTS agents (           -- \u7D22\u5F15\uFF1Bname/description \u5728 system_config.yaml
+CREATE TABLE IF NOT EXISTS agents (           -- index only; name/description live in system_config.yaml
   project_id TEXT NOT NULL,
   agent_id   TEXT NOT NULL,
   created_at TEXT NOT NULL,
@@ -48,64 +48,64 @@ CREATE TABLE IF NOT EXISTS sessions (
   session_id    TEXT PRIMARY KEY,
   project_id    TEXT NOT NULL,
   agent_id      TEXT NOT NULL,
-  provider      TEXT NOT NULL,                     -- \u4F1A\u8BDD\u6A21\u578B\u7684\u5382\u5546\u5206\u7EC4\uFF08\u4E0E model_id \u6210\u5BF9\u6784\u6210\u6A21\u578B\u5F15\u7528\uFF09
-  model_id      TEXT NOT NULL,                     -- \u4E0A\u6E38\u6A21\u578B id\uFF08\u539F\u6837\u53D1\u7ED9 AgentHub\uFF1B\u7981\u6B62 <provider>/<id> \u62FC\u63A5\uFF09
+  provider      TEXT NOT NULL,                     -- provider group of the session model (paired with model_id as a model reference)
+  model_id      TEXT NOT NULL,                     -- upstream model id (sent to AgentHub as-is; never concatenate <provider>/<id>)
   workspace     TEXT NOT NULL,
   approval_mode TEXT NOT NULL DEFAULT 'allow-all',   -- allow-all|deny-all|read-only|always-ask
-  title         TEXT,                                -- \u9996\u6B21\u5BF9\u8BDD\u540E\u7531\u6A21\u578B\u81EA\u52A8\u751F\u6210\uFF1BNULL=\u672A\u751F\u6210\uFF08\u524D\u7AEF\u663E\u793A\u300C\u65B0\u5BF9\u8BDD\u300D\uFF09
-  archived_at   TEXT,                                -- \u5F52\u6863\u65F6\u523B\uFF1BNULL=\u672A\u5F52\u6863\uFF08\u9ED8\u8BA4\u5C55\u793A\uFF1B\u5F52\u6863\u540E\u6536\u8FDB\u300C\u5DF2\u5F52\u6863\u300D\uFF09
-  source        TEXT,                                -- \u4F1A\u8BDD\u6765\u6E90\uFF1ANULL=\u7528\u6237\u521B\u5EFA | schedule\uFF08\u5B9A\u65F6\u4EFB\u52A1\uFF09| subagent\uFF08\u5B50\u4F1A\u8BDD\uFF09
+  title         TEXT,                                -- auto-generated by the model after the first exchange; NULL=not yet (frontend shows "New chat")
+  archived_at   TEXT,                                -- archive time; NULL=not archived (shown by default; archived ones move under "Archived")
+  source        TEXT,                                -- session origin: NULL=user-created | schedule (scheduled task) | subagent (child session)
   created_at    TEXT NOT NULL
 );
 CREATE TABLE IF NOT EXISTS usage_records (
   id                INTEGER PRIMARY KEY AUTOINCREMENT,
   ts                TEXT NOT NULL,
-  date              TEXT NOT NULL,            -- \u672C\u5730\u65E5\u671F yyyy-mm-dd\uFF08\u805A\u5408\u952E\uFF0C\u4E0E Trace \u65E5\u671F\u76EE\u5F55\u540C\u53E3\u5F84\uFF09
+  date              TEXT NOT NULL,            -- local date yyyy-mm-dd (aggregation key; same convention as Trace date directories)
   project_id        TEXT NOT NULL,
   agent_id          TEXT NOT NULL,
-  session_id        TEXT NOT NULL,            -- \u9876\u5C42 Session\uFF08\u5B50\u4F1A\u8BDD\u6D88\u8017\u8BA1\u5165\u6240\u5C5E\u4E3B Session\uFF09
-  origin_session_id TEXT,                     -- \u76F4\u63A5\u6765\u6E90\u5B50 Session\uFF08origin \u94FE\u672B\u9879\uFF09\uFF1BNULL=\u4E3B\u4F1A\u8BDD
-  provider          TEXT NOT NULL,            -- \u5382\u5546\u5206\u7EC4\uFF1A\u4E0E model_id \u6210\u5BF9\u6784\u6210\u5F52\u56E0\u952E\uFF0C\u805A\u5408\u4E00\u5F8B GROUP BY provider, model_id
-  model_id          TEXT NOT NULL,            -- \u4E0A\u6E38\u6A21\u578B id\uFF08\u4E0E provider \u6210\u5BF9\uFF1B\u540C\u540D model_id \u8DE8\u5382\u5546\u5206\u5F00\u805A\u5408\uFF09
+  session_id        TEXT NOT NULL,            -- top-level Session (child-session usage counts toward its main Session)
+  origin_session_id TEXT,                     -- immediate source child Session (last of the origin chain); NULL=main session
+  provider          TEXT NOT NULL,            -- provider group: paired with model_id as the attribution key; always GROUP BY provider, model_id
+  model_id          TEXT NOT NULL,            -- upstream model id (paired with provider; same model_id across providers aggregates separately)
   cache_read        INTEGER NOT NULL,
   cache_write       INTEGER NOT NULL,
   output            INTEGER NOT NULL,
-  total             INTEGER NOT NULL,         -- \u53D6 token_usage.request\uFF08\u6BCF Request \u4E00\u6761\uFF09
-  status            TEXT NOT NULL DEFAULT 'completed'  -- \u8BF7\u6C42\u7ED3\u5C40\uFF1Acompleted=\u6210\u529F\uFF08\u542B token\uFF09\uFF1B\u5176\u4F59=\u5931\u8D25\uFF080 token\uFF0C\u4F9B\u6210\u529F\u7387\uFF09
-);                                            -- \u6210\u672C\u4E0D\u843D\u5E93\uFF1A\u67E5\u8BE2\u65F6\u6309\u5F53\u524D pricing \u5B9E\u65F6\u6298\u7B97
+  total             INTEGER NOT NULL,         -- from token_usage.request (one row per Request)
+  status            TEXT NOT NULL DEFAULT 'completed'  -- request outcome: completed=success (with tokens); others=failure (0 tokens, for success rate)
+);                                            -- cost is not stored: computed at query time from current pricing
 CREATE INDEX IF NOT EXISTS idx_usage_project_date ON usage_records(project_id, date);
 CREATE INDEX IF NOT EXISTS idx_usage_session ON usage_records(session_id);
-CREATE TABLE IF NOT EXISTS error_records (     -- \u670D\u52A1\u7AEF\u5F02\u5E38\u6355\u83B7\uFF08\u7EDF\u8BA1\u4E2D\u5FC3\u300C\u5F02\u5E38\u300D\uFF09
+CREATE TABLE IF NOT EXISTS error_records (     -- server-side error capture (the Costs page's "Errors" tab)
   id         INTEGER PRIMARY KEY AUTOINCREMENT,
   ts         TEXT NOT NULL,
-  date       TEXT NOT NULL,            -- \u672C\u5730\u65E5\u671F yyyy-mm-dd\uFF08\u4E0E usage_records \u540C\u53E3\u5F84\uFF09
-  project_id TEXT,                     -- \u53EF\u7A7A\uFF1A\u767B\u5F55/\u6CE8\u518C\u3001\u8FDB\u7A0B\u7EA7\u5F02\u5E38\u6CA1\u6709 Project \u4E0A\u4E0B\u6587
+  date       TEXT NOT NULL,            -- local date yyyy-mm-dd (same convention as usage_records)
+  project_id TEXT,                     -- nullable: sign-in/registration and process-level errors have no Project context
   agent_id   TEXT,
   session_id TEXT,
   source     TEXT NOT NULL,            -- http | session | usage | title | subagent | process | llm | environment | schedule
-  kind       TEXT NOT NULL,            -- expected\uFF08HttpError\uFF0C\u4E1A\u52A1 4xx\uFF09| unexpected\uFF08500/\u8FD0\u884C\u65F6\uFF09
+  kind       TEXT NOT NULL,            -- expected (HttpError, business 4xx) | unexpected (500/runtime)
   code       TEXT NOT NULL,            -- HttpError.code / internal / session_run_failed / ...
-  status     INTEGER,                  -- HTTP \u72B6\u6001\u7801\uFF1B\u975E HTTP \u6765\u6E90\u4E3A NULL
-  message    TEXT NOT NULL             -- \u622A\u65AD 500 \u5B57\u7B26\uFF08\u4E0D\u5B58\u5806\u6808\uFF1A\u5806\u6808\u53EA\u8FDB\u65E5\u5FD7\uFF09
+  status     INTEGER,                  -- HTTP status code; NULL for non-HTTP sources
+  message    TEXT NOT NULL             -- truncated to 500 chars (no stack stored: stacks go to logs only)
 );
 CREATE INDEX IF NOT EXISTS idx_error_project_date ON error_records(project_id, date);
-CREATE TABLE IF NOT EXISTS schedule_state (    -- \u5B9A\u65F6\u4EFB\u52A1\u8FD0\u884C\u72B6\u6001\uFF08\u6587\u4EF6\u662F\u58F0\u660E\u5F0F\u610F\u56FE\uFF0C\u7CFB\u7EDF\u4E0D\u5199\u56DE\uFF09
+CREATE TABLE IF NOT EXISTS schedule_state (    -- schedule runtime state (files are declarative intent; the system never writes back)
   project_id      TEXT NOT NULL,
   agent_id        TEXT NOT NULL,
-  name            TEXT NOT NULL,               -- \u6587\u4EF6\u540D\uFF08\u53BB .toml\uFF09\u5373\u6807\u8BC6
-  creator_user_id TEXT,                        -- \u521B\u5EFA\u8005\uFF08API \u521B\u5EFA\u65F6\u8BB0\uFF1B\u624B\u7F16\u6587\u4EF6\u5BF9\u8D26\u767B\u8BB0\u56DE\u9000 Project owner\uFF09
-  start_at_ms     INTEGER NOT NULL,            -- \u5B9A\u4E49\u8EAB\u4EFD\uFF1Astart_at \u53D8\u66F4\u89C6\u4E3A\u65B0\u4EFB\u52A1\u5B9E\u4F8B\uFF0C\u91CD\u7F6E\u89E6\u53D1\u72B6\u6001
-  def_hash        TEXT NOT NULL,               -- \u6587\u4EF6\u5185\u5BB9\u6307\u7EB9\uFF1A\u53D8\u66F4\u5373\u6E05\u9664\u5931\u6548\u6807\u8BB0\uFF08\u6587\u4EF6\u4FEE\u6539\u540E\u91CD\u65B0\u751F\u6548\uFF09
-  last_slot_ms    INTEGER,                     -- \u5DF2\u6D88\u5316\u7684\u6700\u8FD1\u5E94\u89E6\u53D1\u65F6\u523B\uFF08\u89E6\u53D1\u6216\u8DF3\u8FC7\u90FD\u63A8\u8FDB\uFF1B\u91CD\u542F\u4E0D\u91CD\u590D\u89E6\u53D1\uFF09
-  last_fired_at   TEXT,                        -- \u6700\u8FD1\u5B9E\u9645\u53D1\u9001\u65F6\u523B\uFF08\u5C55\u793A\u7528\uFF09
-  fired_once      INTEGER NOT NULL DEFAULT 0,  -- \u4E00\u6B21\u6027\u4EFB\u52A1\u5DF2\u89E6\u53D1
-  missed          INTEGER NOT NULL DEFAULT 0,  -- \u4E00\u6B21\u6027\u4EFB\u52A1\u5DF2\u9519\u8FC7\uFF08\u542F\u52A8/\u767B\u8BB0\u5BF9\u8D26\u6807\u8BB0\uFF0C\u9519\u8FC7\u4E0D\u8865\uFF09
-  invalid_reason  TEXT,                        -- \u5931\u6548\u539F\u56E0\uFF08\u5982\u7ED1\u5B9A Session \u5DF2\u5220\u9664\uFF09\uFF1BNULL \u5373\u6B63\u5E38
+  name            TEXT NOT NULL,               -- file name (without .toml) doubles as the identifier
+  creator_user_id TEXT,                        -- creator (recorded on API create; hand-edited file reconciliation falls back to the Project owner)
+  start_at_ms     INTEGER NOT NULL,            -- defines identity: a start_at change counts as a new task instance, resetting fire state
+  def_hash        TEXT NOT NULL,               -- file content fingerprint: any change clears the invalid flag (the file takes effect again after edits)
+  last_slot_ms    INTEGER,                     -- latest due slot already consumed (advances on fire or skip; no re-fire across restarts)
+  last_fired_at   TEXT,                        -- last actual fire time (for display)
+  fired_once      INTEGER NOT NULL DEFAULT 0,  -- one-shot task has fired
+  missed          INTEGER NOT NULL DEFAULT 0,  -- one-shot task was missed (flagged by startup/registration reconciliation; not backfilled)
+  invalid_reason  TEXT,                        -- invalidation reason (e.g. the bound Session was deleted); NULL=healthy
   PRIMARY KEY (project_id, agent_id, name)
 );
 CREATE TABLE IF NOT EXISTS ui_prefs (
   user_id    TEXT PRIMARY KEY REFERENCES users(user_id) ON DELETE CASCADE,
-  prefs_json TEXT NOT NULL                    -- {theme?, lastProjectId?, ...} \u81EA\u7531 JSON
+  prefs_json TEXT NOT NULL                    -- {theme?, lastProjectId?, ...} free-form JSON
 );
 `;
 
@@ -460,7 +460,7 @@ var SchedulesRepo = class {
       ).run(args.defHash, args.projectId, args.agentId, args.name);
     }
     const row = this.find(args.projectId, args.agentId, args.name);
-    if (!row) throw new Error("schedule_state \u767B\u8BB0\u540E\u8BFB\u53D6\u5931\u8D25");
+    if (!row) throw new Error("Failed to read back schedule_state after registration");
     return { row, fresh };
   }
   /** Advance the consumed scheduled time (advances whether triggered or skipped; restarts don't re-trigger). */
@@ -857,15 +857,15 @@ function modelCredentialMissing(modelId) {
   return new HttpError(
     400,
     "model_credential_missing",
-    `\u6A21\u578B ${modelId} \u8FD8\u6CA1\u6709\u53EF\u7528\u7684 API key\uFF0C\u8BF7\u5148\u5728\u300C\u6A21\u578B\u300D\u9875\u4E3A\u5B83\u914D\u7F6E\u3002`
+    `Model ${modelId} has no API key yet. Configure it on the Models page first.`
   );
 }
 function handleError(err, c) {
   if (err instanceof HttpError) {
     return c.json(errorBody(err.code, err.message), err.status);
   }
-  console.error(`[server] \u672A\u5904\u7406\u5F02\u5E38: ${err.stack ?? err.message}`);
-  return c.json(errorBody("internal", "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF\u3002"), 500);
+  console.error(`[server] Unhandled exception: ${err.stack ?? err.message}`);
+  return c.json(errorBody("internal", "Internal server error."), 500);
 }
 
 // src/auth/middleware.ts
@@ -875,7 +875,7 @@ function authMiddleware(auth) {
     const token = getCookie(c, SESSION_COOKIE);
     const user = token ? auth.authenticate(token) : null;
     if (!user) {
-      throw new HttpError(401, "unauthorized", "\u672A\u767B\u5F55\u6216\u767B\u5F55\u5DF2\u8FC7\u671F\u3002");
+      throw new HttpError(401, "unauthorized", "Not signed in or the sign-in has expired.");
     }
     c.set("user", user);
     await next();
@@ -886,7 +886,11 @@ var jsonOnlyWrites = async (c, next) => {
   if (WRITE_METHODS.has(c.req.method)) {
     const contentType = c.req.header("content-type");
     if (contentType && !contentType.toLowerCase().startsWith("application/json")) {
-      throw new HttpError(415, "unsupported_media_type", "\u5199\u8BF7\u6C42\u4EC5\u63A5\u53D7 application/json\u3002");
+      throw new HttpError(
+        415,
+        "unsupported_media_type",
+        "Write requests only accept application/json."
+      );
     }
   }
   await next();
@@ -950,7 +954,7 @@ async function verifyPassword(password, stored) {
 // src/auth/service.ts
 var MIN_PASSWORD_LENGTH = 8;
 var ADMIN_USER_ID = "admin";
-var ADMIN_INITIAL_PASSWORD = "admin123";
+var ADMIN_INITIAL_PASSWORD = "penguin-2026";
 function sha256Hex(value) {
   return createHash("sha256").update(value).digest("hex");
 }
@@ -995,7 +999,7 @@ var AuthService = class {
     const row = this.deps.users.findById(userId);
     const ok = row !== null && await verifyPassword(password, row.passwordHash);
     if (!row || !ok) {
-      throw new HttpError(401, "invalid_credentials", "\u7528\u6237\u540D\u6216\u5BC6\u7801\u9519\u8BEF\u3002");
+      throw new HttpError(401, "invalid_credentials", "Incorrect username or password.");
     }
     this.deps.authSessions.deleteExpired(this.now().toISOString());
     return { user: toUserInfo(row), token: this.issueSession(row.userId) };
@@ -1004,10 +1008,10 @@ var AuthService = class {
   async changePassword(userId, oldPassword, newPassword) {
     const row = this.deps.users.findById(userId);
     if (!row || !await verifyPassword(oldPassword, row.passwordHash)) {
-      throw new HttpError(400, "password_mismatch", "\u5F53\u524D\u5BC6\u7801\u4E0D\u6B63\u786E\u3002");
+      throw new HttpError(400, "password_mismatch", "Current password is incorrect.");
     }
     if (newPassword.length < MIN_PASSWORD_LENGTH) {
-      throw new HttpError(400, "invalid_password", "\u5BC6\u7801\u81F3\u5C11 8 \u4E2A\u5B57\u7B26\u3002");
+      throw new HttpError(400, "invalid_password", "Password must be at least 8 characters.");
     }
     this.deps.users.updatePassword(userId, await hashPassword(newPassword), false);
   }
@@ -1057,28 +1061,29 @@ function badRequest(message) {
 function pathParam(c, name) {
   const v = c.req.param(name);
   if (v === void 0 || v === "") {
-    throw new HttpError(404, "not_found", "\u8DEF\u5F84\u53C2\u6570\u7F3A\u5931\u3002");
+    throw new HttpError(404, "not_found", "Missing path parameter.");
   }
   return v;
 }
 function requireValidId(c, name) {
   const v = pathParam(c, name);
   if (!isValidId(v)) {
-    throw new HttpError(404, "not_found", "\u8D44\u6E90\u4E0D\u5B58\u5728\u6216\u65E0\u6743\u8BBF\u95EE\u3002");
+    throw new HttpError(404, "not_found", "Resource does not exist or you do not have access.");
   }
   return v;
 }
 function positiveIntParam(c, name) {
   const v = Number.parseInt(pathParam(c, name), 10);
-  if (!Number.isInteger(v) || v < 1) throw badRequest(`${name} \u5FC5\u987B\u662F\u6B63\u6574\u6570\u3002`);
+  if (!Number.isInteger(v) || v < 1) throw badRequest(`${name} must be a positive integer.`);
   return v;
 }
 function paginationQuery(c) {
   const offset = Number.parseInt(c.req.query("offset") ?? "0", 10);
   const limit = Number.parseInt(c.req.query("limit") ?? "200", 10);
-  if (!Number.isInteger(offset) || offset < 0) throw badRequest("offset \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570\u3002");
+  if (!Number.isInteger(offset) || offset < 0)
+    throw badRequest("offset must be a non-negative integer.");
   if (!Number.isInteger(limit) || limit < 1 || limit > 1e3) {
-    throw badRequest("limit \u5FC5\u987B\u662F 1~1000 \u7684\u6574\u6570\u3002");
+    throw badRequest("limit must be an integer between 1 and 1000.");
   }
   return { offset, limit };
 }
@@ -1087,25 +1092,25 @@ async function readJson(c) {
   try {
     body = await c.req.json();
   } catch {
-    throw badRequest("\u8BF7\u6C42\u4F53\u5FC5\u987B\u662F\u5408\u6CD5 JSON\u3002");
+    throw badRequest("Request body must be valid JSON.");
   }
   if (body === null || typeof body !== "object" || Array.isArray(body)) {
-    throw badRequest("\u8BF7\u6C42\u4F53\u5FC5\u987B\u662F JSON \u5BF9\u8C61\u3002");
+    throw badRequest("Request body must be a JSON object.");
   }
   return body;
 }
 function requireString(obj, key, rule = {}) {
   const v = obj[key];
   const label = rule.label ?? key;
-  if (typeof v !== "string") throw badRequest(`${label} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u3002`);
+  if (typeof v !== "string") throw badRequest(`${label} must be a string.`);
   if (rule.minLen !== void 0 && v.length < rule.minLen) {
-    throw badRequest(`${label} \u957F\u5EA6\u81F3\u5C11 ${rule.minLen} \u4E2A\u5B57\u7B26\u3002`);
+    throw badRequest(`${label} must be at least ${rule.minLen} characters.`);
   }
   if (rule.maxLen !== void 0 && v.length > rule.maxLen) {
-    throw badRequest(`${label} \u957F\u5EA6\u4E0D\u80FD\u8D85\u8FC7 ${rule.maxLen} \u4E2A\u5B57\u7B26\u3002`);
+    throw badRequest(`${label} must be at most ${rule.maxLen} characters.`);
   }
   if (rule.pattern !== void 0 && !rule.pattern.test(v)) {
-    throw badRequest(`${label} \u683C\u5F0F\u4E0D\u5408\u6CD5\u3002`);
+    throw badRequest(`${label} has an invalid format.`);
   }
   return v;
 }
@@ -1116,7 +1121,7 @@ function optionalString(obj, key, rule = {}) {
 function requireEnum(obj, key, values, label = key) {
   const v = obj[key];
   if (typeof v !== "string" || !values.includes(v)) {
-    throw badRequest(`${label} \u5FC5\u987B\u662F ${values.join(" / ")} \u4E4B\u4E00\u3002`);
+    throw badRequest(`${label} must be one of ${values.join(" / ")}.`);
   }
   return v;
 }
@@ -1128,18 +1133,18 @@ function optionalNumber(obj, key, rule = {}) {
   const v = obj[key];
   if (v === void 0) return void 0;
   const label = rule.label ?? key;
-  if (typeof v !== "number" || !Number.isFinite(v)) throw badRequest(`${label} \u5FC5\u987B\u662F\u6570\u5B57\u3002`);
-  if (rule.integer && !Number.isInteger(v)) throw badRequest(`${label} \u5FC5\u987B\u662F\u6574\u6570\u3002`);
+  if (typeof v !== "number" || !Number.isFinite(v)) throw badRequest(`${label} must be a number.`);
+  if (rule.integer && !Number.isInteger(v)) throw badRequest(`${label} must be an integer.`);
   if (rule.positiveOrMinusOne && !(v > 0 || v === -1)) {
-    throw badRequest(`${label} \u5FC5\u987B\u5927\u4E8E 0 \u6216\u4E3A -1\u3002`);
+    throw badRequest(`${label} must be greater than 0 or equal to -1.`);
   }
-  if (rule.nonNegative && v < 0) throw badRequest(`${label} \u4E0D\u80FD\u4E3A\u8D1F\u6570\u3002`);
+  if (rule.nonNegative && v < 0) throw badRequest(`${label} must not be negative.`);
   return v;
 }
 function optionalDateParam(value, label) {
   if (value === void 0 || value === "") return void 0;
   if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
-    throw badRequest(`${label} \u5FC5\u987B\u662F YYYY-MM-DD \u683C\u5F0F\u3002`);
+    throw badRequest(`${label} must be in YYYY-MM-DD format.`);
   }
   return value;
 }
@@ -1149,7 +1154,7 @@ function adminUsersRoutes(deps2) {
   const app2 = new Hono();
   app2.use("*", async (c, next) => {
     if (!c.var.user.isAdmin) {
-      throw new HttpError(403, "admin_required", "\u8BE5\u64CD\u4F5C\u4EC5\u7BA1\u7406\u5458\u53EF\u6267\u884C\u3002");
+      throw new HttpError(403, "admin_required", "Only an admin can perform this operation.");
     }
     await next();
   });
@@ -1386,7 +1391,7 @@ function membersRoutes(deps2) {
 import { Hono as Hono7 } from "hono";
 function parseRef(value, label) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    throw badRequest(`${label} \u5FC5\u987B\u662F { provider, modelId } \u5BF9\u8C61\u3002`);
+    throw badRequest(`${label} must be a { provider, modelId } object.`);
   }
   const r = value;
   return {
@@ -1395,10 +1400,10 @@ function parseRef(value, label) {
   };
 }
 function parseModelsUpdate(body) {
-  if (!Array.isArray(body.models)) throw badRequest("models \u5FC5\u987B\u662F\u6570\u7EC4\u3002");
+  if (!Array.isArray(body.models)) throw badRequest("models must be an array.");
   const models = body.models.map((item, i) => {
     if (item === null || typeof item !== "object" || Array.isArray(item)) {
-      throw badRequest(`models[${i}] \u5FC5\u987B\u662F\u5BF9\u8C61\u3002`);
+      throw badRequest(`models[${i}] must be an object.`);
     }
     const m = item;
     const entry = {
@@ -1415,7 +1420,7 @@ function parseModelsUpdate(body) {
     };
     if (m.displayName !== void 0) {
       if (typeof m.displayName !== "string" || m.displayName.length > 100) {
-        throw badRequest(`models[${i}].displayName \u5FC5\u987B\u662F\u957F\u5EA6\u4E0D\u8D85\u8FC7 100 \u7684\u5B57\u7B26\u4E32\u3002`);
+        throw badRequest(`models[${i}].displayName must be a string of at most 100 characters.`);
       }
       if (m.displayName) entry.displayName = m.displayName;
     }
@@ -1424,31 +1429,31 @@ function parseModelsUpdate(body) {
     }
     if (m.contextWindow !== void 0) {
       if (typeof m.contextWindow !== "number" || !(m.contextWindow > 0)) {
-        throw badRequest(`models[${i}].contextWindow \u5FC5\u987B\u662F\u6B63\u6570\u3002`);
+        throw badRequest(`models[${i}].contextWindow must be a positive number.`);
       }
       entry.contextWindow = m.contextWindow;
     }
     if (m.clientType !== void 0) {
       if (typeof m.clientType !== "string" || m.clientType.length > 64) {
-        throw badRequest(`models[${i}].clientType \u5FC5\u987B\u662F\u957F\u5EA6\u4E0D\u8D85\u8FC7 64 \u7684\u5B57\u7B26\u4E32\u3002`);
+        throw badRequest(`models[${i}].clientType must be a string of at most 64 characters.`);
       }
       if (m.clientType) entry.clientType = m.clientType;
     }
     if (m.vision !== void 0) {
       if (typeof m.vision !== "boolean") {
-        throw badRequest(`models[${i}].vision \u5FC5\u987B\u662F\u5E03\u5C14\u503C\u3002`);
+        throw badRequest(`models[${i}].vision must be a boolean.`);
       }
       entry.vision = m.vision;
     }
     if (m.pricing !== void 0) {
       const p = m.pricing;
       if (p === null || typeof p !== "object" || Array.isArray(p)) {
-        throw badRequest(`models[${i}].pricing \u5FC5\u987B\u662F\u5BF9\u8C61\u3002`);
+        throw badRequest(`models[${i}].pricing must be an object.`);
       }
       for (const key of ["cacheRead", "cacheWrite", "output"]) {
         const v = p[key];
         if (typeof v !== "number" || !Number.isFinite(v) || v < 0) {
-          throw badRequest(`models[${i}].pricing.${key} \u5FC5\u987B\u662F\u975E\u8D1F\u6570\u5B57\u3002`);
+          throw badRequest(`models[${i}].pricing.${key} must be a non-negative number.`);
         }
       }
       entry.pricing = {
@@ -1459,19 +1464,19 @@ function parseModelsUpdate(body) {
     }
     if (m.apiKey !== void 0) {
       if (typeof m.apiKey !== "string" || m.apiKey.length === 0) {
-        throw badRequest(`models[${i}].apiKey \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u3002`);
+        throw badRequest(`models[${i}].apiKey must be a non-empty string.`);
       }
       entry.apiKey = m.apiKey;
     }
     if (m.clearApiKey !== void 0) {
       if (typeof m.clearApiKey !== "boolean") {
-        throw badRequest(`models[${i}].clearApiKey \u5FC5\u987B\u662F\u5E03\u5C14\u503C\u3002`);
+        throw badRequest(`models[${i}].clearApiKey must be a boolean.`);
       }
       entry.clearApiKey = m.clearApiKey;
     }
     if (m.baseUrl !== void 0) {
       if (m.baseUrl !== null && typeof m.baseUrl !== "string") {
-        throw badRequest(`models[${i}].baseUrl \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6216 null\u3002`);
+        throw badRequest(`models[${i}].baseUrl must be a string or null.`);
       }
       entry.baseUrl = m.baseUrl;
     }
@@ -1508,21 +1513,25 @@ function modelsRoutes(deps2) {
       modelId: requireString(body, "modelId", { minLen: 1, maxLen: 200 })
     };
     if (body.apiKey !== void 0) {
-      if (typeof body.apiKey !== "string") throw badRequest("apiKey \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u3002");
+      if (typeof body.apiKey !== "string") throw badRequest("apiKey must be a string.");
       if (body.apiKey) req.apiKey = body.apiKey;
     }
     if (body.clearApiKey !== void 0) {
-      if (typeof body.clearApiKey !== "boolean") throw badRequest("clearApiKey \u5FC5\u987B\u662F\u5E03\u5C14\u503C\u3002");
+      if (typeof body.clearApiKey !== "boolean") throw badRequest("clearApiKey must be a boolean.");
       req.clearApiKey = body.clearApiKey;
     }
+    if (body.speed !== void 0) {
+      if (typeof body.speed !== "boolean") throw badRequest("speed must be a boolean.");
+      req.speed = body.speed;
+    }
     if (body.baseUrl !== void 0) {
       if (body.baseUrl !== null && typeof body.baseUrl !== "string") {
-        throw badRequest("baseUrl \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6216 null\u3002");
+        throw badRequest("baseUrl must be a string or null.");
       }
       req.baseUrl = body.baseUrl ? body.baseUrl : null;
     }
     if (body.clientType !== void 0) {
-      if (typeof body.clientType !== "string") throw badRequest("clientType \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u3002");
+      if (typeof body.clientType !== "string") throw badRequest("clientType must be a string.");
       if (body.clientType) req.clientType = body.clientType;
     }
     return c.json(await deps2.projectConfigService.testModel(projectId, req));
@@ -1533,10 +1542,10 @@ function modelsRoutes(deps2) {
 // src/http/routes/vault.ts
 import { Hono as Hono8 } from "hono";
 function parseVaultUpdate(body) {
-  if (!Array.isArray(body.entries)) throw badRequest("entries \u5FC5\u987B\u662F\u6570\u7EC4\u3002");
+  if (!Array.isArray(body.entries)) throw badRequest("entries must be an array.");
   const entries = body.entries.map((item, i) => {
     if (item === null || typeof item !== "object" || Array.isArray(item)) {
-      throw badRequest(`entries[${i}] \u5FC5\u987B\u662F\u5BF9\u8C61\u3002`);
+      throw badRequest(`entries[${i}] must be an object.`);
     }
     const e = item;
     const entry = {
@@ -1544,7 +1553,7 @@ function parseVaultUpdate(body) {
     };
     if (e.value !== void 0) {
       if (typeof e.value !== "string" || e.value.length === 0) {
-        throw badRequest(`entries[${i}].value \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u3002`);
+        throw badRequest(`entries[${i}].value must be a non-empty string.`);
       }
       entry.value = e.value;
     }
@@ -1566,6 +1575,7 @@ function vaultRoutes(deps2) {
     deps2.projectService.requireProjectOwner(c.var.user.userId, projectId);
     const req = parseVaultUpdate(await readJson(c));
     const res = await deps2.agentConfigService.updateVault(projectId, agentId, req);
+    deps2.manager.invalidateAgentRuntimes(projectId, agentId);
     return c.json(res);
   });
   return app2;
@@ -1603,72 +1613,77 @@ function parseScheduleFile(name, raw) {
   } catch (err) {
     return {
       ok: false,
-      error: `TOML \u89E3\u6790\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`
+      error: `Failed to parse TOML: ${err instanceof Error ? err.message : String(err)}`
     };
   }
   if (parsed === null || typeof parsed !== "object")
-    return { ok: false, error: "\u5185\u5BB9\u4E0D\u662F TOML \u8868" };
+    return { ok: false, error: "Content is not a TOML table" };
   const t = parsed;
   const prompt = t["prompt"];
   if (typeof prompt !== "string" || prompt.trim() === "") {
-    return { ok: false, error: "\u7F3A\u5C11\u5FC5\u586B\u5B57\u6BB5 prompt" };
+    return { ok: false, error: "Missing required field prompt" };
   }
   const enabled = t["enabled"] === void 0 ? false : t["enabled"];
-  if (typeof enabled !== "boolean") return { ok: false, error: "enabled \u5FC5\u987B\u662F\u5E03\u5C14\u503C" };
+  if (typeof enabled !== "boolean") return { ok: false, error: "enabled must be a boolean" };
   const startAt = parseInstant(t["start_at"]);
-  if (startAt === null) return { ok: false, error: "start_at \u7F3A\u5931\u6216\u4E0D\u662F\u5408\u6CD5\u7684 ISO 8601 \u65F6\u523B" };
+  if (startAt === null)
+    return { ok: false, error: "start_at is missing or not a valid ISO 8601 instant" };
   let period;
   let periodMs;
   if (t["period"] !== void 0) {
-    if (typeof t["period"] !== "string") return { ok: false, error: "period \u5FC5\u987B\u662F\u5B57\u7B26\u4E32" };
+    if (typeof t["period"] !== "string") return { ok: false, error: "period must be a string" };
     const ms = parsePeriod(t["period"]);
-    if (ms === null) return { ok: false, error: "period \u5FC5\u987B\u5F62\u5982 30m / 12h / 7d" };
-    if (ms < MIN_PERIOD_MS) return { ok: false, error: "period \u4F4E\u4E8E\u4E0B\u9650 5m" };
+    if (ms === null) return { ok: false, error: "period must look like 30m / 12h / 7d" };
+    if (ms < MIN_PERIOD_MS) return { ok: false, error: "period is below the 5m minimum" };
     period = t["period"].trim();
     periodMs = ms;
   }
   let endAt;
   if (t["end_at"] !== void 0) {
     const parsedEnd = parseInstant(t["end_at"]);
-    if (parsedEnd === null) return { ok: false, error: "end_at \u4E0D\u662F\u5408\u6CD5\u7684 ISO 8601 \u65F6\u523B" };
-    if (parsedEnd.ms <= startAt.ms) return { ok: false, error: "end_at \u5FC5\u987B\u665A\u4E8E start_at" };
+    if (parsedEnd === null) return { ok: false, error: "end_at is not a valid ISO 8601 instant" };
+    if (parsedEnd.ms <= startAt.ms)
+      return { ok: false, error: "end_at must be later than start_at" };
     endAt = parsedEnd;
   }
   let sessionId;
   if (t["session_id"] !== void 0) {
     if (typeof t["session_id"] !== "string" || t["session_id"] === "") {
-      return { ok: false, error: "session_id \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32" };
+      return { ok: false, error: "session_id must be a non-empty string" };
     }
     sessionId = t["session_id"];
   }
   let workspace;
   if (t["workspace"] !== void 0) {
     if (typeof t["workspace"] !== "string" || t["workspace"] === "") {
-      return { ok: false, error: "workspace \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32" };
+      return { ok: false, error: "workspace must be a non-empty string" };
     }
     workspace = t["workspace"];
   }
   let modelId;
   if (t["model_id"] !== void 0) {
     if (typeof t["model_id"] !== "string" || t["model_id"] === "") {
-      return { ok: false, error: "model_id \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32" };
+      return { ok: false, error: "model_id must be a non-empty string" };
     }
     modelId = t["model_id"];
   }
   let provider;
   if (t["provider"] !== void 0) {
     if (typeof t["provider"] !== "string" || t["provider"] === "") {
-      return { ok: false, error: "provider \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32" };
+      return { ok: false, error: "provider must be a non-empty string" };
     }
     provider = t["provider"];
   }
-  if (provider !== void 0 && modelId === void 0) {
-    return { ok: false, error: "provider \u4EC5\u4E0E model_id \u6210\u5BF9\u4F7F\u7528\uFF08\u6A21\u578B\u5F15\u7528\u987B\u6210\u5BF9\u7ED9\u51FA\uFF09" };
-  }
   if (sessionId !== void 0 && (workspace !== void 0 || modelId !== void 0 || provider !== void 0)) {
     return {
       ok: false,
-      error: "\u76EE\u6807\u4E8C\u9009\u4E00\uFF1Aworkspace \u4E0E provider / model_id \u4EC5\u7528\u4E8E\u65B0\u5EFA Session \u6A21\u5F0F"
+      error: "Pick one target: workspace and provider / model_id are only for new-Session mode"
+    };
+  }
+  if (modelId === void 0 !== (provider === void 0)) {
+    return {
+      ok: false,
+      error: "provider and model_id must be given together (a model reference is always a pair); omit both to use the Project's default model"
     };
   }
   return {
@@ -1763,7 +1778,10 @@ function serializeSchedule(fields) {
 `;
 }
 async function validateScheduleModelRef(root, projectId, def) {
-  if (def.modelId === void 0) return null;
+  if (def.modelId === void 0 && def.provider === void 0) return null;
+  if (def.modelId === void 0 || def.provider === void 0) {
+    return "provider and model_id must be given together (a model reference is always a pair); omit both to use the Project's default model";
+  }
   try {
     const cfg = await loadProjectConfig(root, projectId);
     resolveModelRef(cfg, def.modelId, def.provider);
@@ -1789,7 +1807,7 @@ async function deleteScheduleFile(root, projectId, agentId, name) {
 
 // src/http/routes/schedules.ts
 function parseUpsertBody(body) {
-  if (typeof body.enabled !== "boolean") throw badRequest("enabled \u5FC5\u987B\u662F\u5E03\u5C14\u503C\u3002");
+  if (typeof body.enabled !== "boolean") throw badRequest("enabled must be a boolean.");
   const prompt = requireString(body, "prompt", { minLen: 1, maxLen: 1e5 });
   const startAt = requireString(body, "startAt", { minLen: 1, maxLen: 100 });
   const period = optionalString(body, "period", { minLen: 1, maxLen: 20 });
@@ -1849,7 +1867,7 @@ function toItem(def, state, queued, nowMs) {
   };
 }
 function requireScheduleName(raw) {
-  if (!raw || !isValidId2(raw)) throw badRequest("\u5B9A\u65F6\u4EFB\u52A1\u540D\u975E\u6CD5\u3002");
+  if (!raw || !isValidId2(raw)) throw badRequest("Invalid schedule name.");
   return raw;
 }
 function scheduleRoutes(deps2) {
@@ -1875,7 +1893,7 @@ function scheduleRoutes(deps2) {
     const body = await readJson(c);
     const name = requireScheduleName(requireString(body, "name", { minLen: 1, maxLen: 100 }));
     if (await readScheduleFile(deps2.config.root, projectId, agentId, name)) {
-      throw new HttpError(409, "schedule_exists", `\u5B9A\u65F6\u4EFB\u52A1\u5DF2\u5B58\u5728\uFF1A${name}`);
+      throw new HttpError(409, "schedule_exists", `Schedule already exists: ${name}`);
     }
     await upsert(deps2, c.var.user.userId, projectId, agentId, name, body);
     return c.json(await readItem(deps2, projectId, agentId, name), 201);
@@ -1894,7 +1912,7 @@ function scheduleRoutes(deps2) {
     deps2.projectService.requireProjectOwner(c.var.user.userId, projectId);
     const name = requireScheduleName(c.req.param("name"));
     if (!await readScheduleFile(deps2.config.root, projectId, agentId, name)) {
-      throw new HttpError(404, "schedule_not_found", `\u5B9A\u65F6\u4EFB\u52A1\u4E0D\u5B58\u5728\uFF1A${name}`);
+      throw new HttpError(404, "schedule_not_found", `Schedule does not exist: ${name}`);
     }
     const body = await readJson(c);
     await upsert(deps2, c.var.user.userId, projectId, agentId, name, body);
@@ -1906,7 +1924,8 @@ function scheduleRoutes(deps2) {
     deps2.projectService.requireProjectOwner(c.var.user.userId, projectId);
     const name = requireScheduleName(c.req.param("name"));
     const removed = await deleteScheduleFile(deps2.config.root, projectId, agentId, name);
-    if (!removed) throw new HttpError(404, "schedule_not_found", `\u5B9A\u65F6\u4EFB\u52A1\u4E0D\u5B58\u5728\uFF1A${name}`);
+    if (!removed)
+      throw new HttpError(404, "schedule_not_found", `Schedule does not exist: ${name}`);
     deps2.scheduler.dropEntry(projectId, agentId, name);
     return c.body(null, 204);
   });
@@ -1916,9 +1935,9 @@ async function upsert(deps2, userId, projectId, agentId, name, body) {
   const fields = parseUpsertBody(body);
   const raw = serializeSchedule(fields);
   const parsed = parseScheduleFile(name, raw);
-  if (!parsed.ok) throw badRequest(`\u5B9A\u65F6\u4EFB\u52A1\u914D\u7F6E\u975E\u6CD5\uFF1A${parsed.error}`);
+  if (!parsed.ok) throw badRequest(`Invalid schedule configuration: ${parsed.error}`);
   const refError = await validateScheduleModelRef(deps2.config.root, projectId, parsed.def);
-  if (refError !== null) throw badRequest(`\u5B9A\u65F6\u4EFB\u52A1\u914D\u7F6E\u975E\u6CD5\uFF1A${refError}`);
+  if (refError !== null) throw badRequest(`Invalid schedule configuration: ${refError}`);
   await writeScheduleFile(deps2.config.root, projectId, agentId, name, raw);
   deps2.schedulesRepo.registerOrSync({
     projectId,
@@ -1935,8 +1954,8 @@ async function readItem(deps2, projectId, agentId, name) {
   const entry = entries.find((e) => e.def.name === name);
   if (entry) return toItem(entry.def, entry.state, entry.queued, Date.now());
   const bad = invalid.find((i) => i.name === name);
-  if (bad) throw badRequest(`\u5B9A\u65F6\u4EFB\u52A1\u6587\u4EF6\u975E\u6CD5\uFF1A${bad.error}`);
-  throw new HttpError(404, "schedule_not_found", `\u5B9A\u65F6\u4EFB\u52A1\u4E0D\u5B58\u5728\uFF1A${name}`);
+  if (bad) throw badRequest(`Invalid schedule file: ${bad.error}`);
+  throw new HttpError(404, "schedule_not_found", `Schedule does not exist: ${name}`);
 }
 
 // src/http/routes/benchmarks.ts
@@ -1987,11 +2006,11 @@ function libraryResponse() {
 }
 function parseInstallNames(body) {
   if (!Array.isArray(body.names) || body.names.length === 0) {
-    throw badRequest("names \u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4\u3002");
+    throw badRequest("names must be a non-empty array.");
   }
   return body.names.map((v, i) => {
     if (typeof v !== "string" || v.length === 0) {
-      throw badRequest(`names[${i}] \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u3002`);
+      throw badRequest(`names[${i}] must be a non-empty string.`);
     }
     return v;
   });
@@ -2021,7 +2040,7 @@ function agentSkillsRoutes(deps2) {
     const names = parseInstallNames(await readJson(c));
     const skills = names.map((name) => {
       const skill = librarySkill(name);
-      if (!skill) throw new HttpError(404, "unknown_skill", `Skill \u5E93\u4E2D\u4E0D\u5B58\u5728\uFF1A${name}`);
+      if (!skill) throw new HttpError(404, "unknown_skill", `Skill is not in the library: ${name}`);
       return skill;
     });
     for (const skill of skills) {
@@ -2038,7 +2057,7 @@ function agentSkillsRoutes(deps2) {
     try {
       await fs2.access(file);
     } catch {
-      throw new HttpError(404, "not_found", `Skill \u672A\u5B89\u88C5\uFF1A${name}`);
+      throw new HttpError(404, "not_found", `Skill is not installed: ${name}`);
     }
     await removeSkill(deps2.config.root, projectId, agentId, name);
     return c.body(null, 204);
@@ -2077,10 +2096,11 @@ function agentTransferRoutes(deps2) {
     try {
       archive = Buffer.from(dataBase64, "base64");
     } catch {
-      throw badRequest("dataBase64 \u4E0D\u662F\u5408\u6CD5\u7684 base64\u3002");
+      throw badRequest("dataBase64 is not valid base64.");
     }
-    if (archive.byteLength === 0) throw badRequest("\u5BFC\u5165\u5305\u4E3A\u7A7A\u3002");
-    if (archive.byteLength > MAX_ARCHIVE_BYTES) throw badRequest("\u5BFC\u5165\u5305\u8D85\u8FC7 14MB \u4E0A\u9650\u3002");
+    if (archive.byteLength === 0) throw badRequest("Import package is empty.");
+    if (archive.byteLength > MAX_ARCHIVE_BYTES)
+      throw badRequest("Import package exceeds the 14MB limit.");
     const { version } = await deps2.snapshots.importArchive(projectId, agentId, archive, confirm);
     const res = { version };
     return c.json(res);
@@ -2175,17 +2195,21 @@ function dirsRoutes(deps2) {
     const raw = c.req.query("path");
     const target = raw && raw.trim() ? raw.trim() : os.homedir();
     if (!path4.isAbsolute(target)) {
-      throw new HttpError(400, "dir_not_absolute", "\u76EE\u5F55\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84\u3002");
+      throw new HttpError(400, "dir_not_absolute", "Directory must be an absolute path.");
     }
     let real;
     try {
       real = await fs4.realpath(target);
     } catch {
-      throw new HttpError(404, "dir_not_found", `\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u4E0D\u53EF\u8BBF\u95EE\uFF1A${target}\u3002`);
+      throw new HttpError(
+        404,
+        "dir_not_found",
+        `Directory does not exist or is inaccessible: ${target}.`
+      );
     }
     const stat = await fs4.stat(real);
     if (!stat.isDirectory()) {
-      throw new HttpError(400, "not_a_dir", "\u4E0D\u662F\u76EE\u5F55\u3002");
+      throw new HttpError(400, "not_a_dir", "Not a directory.");
     }
     let dirents = [];
     try {
@@ -2228,7 +2252,7 @@ function agentConfigRoutes(deps2) {
     if (agentsMd !== void 0) req.agentsMd = agentsMd;
     if (body.config !== void 0) {
       if (body.config === null || typeof body.config !== "object" || Array.isArray(body.config)) {
-        throw badRequest("config \u5FC5\u987B\u662F\u5BF9\u8C61\u3002");
+        throw badRequest("config must be an object.");
       }
       req.config = body.config;
     }
@@ -2284,7 +2308,7 @@ function usageRoutes(deps2) {
     deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
     const groupByRaw = c.req.query("groupBy") ?? "date";
     if (!GROUP_BYS.includes(groupByRaw)) {
-      throw badRequest(`groupBy \u5FC5\u987B\u662F ${GROUP_BYS.join(" / ")} \u4E4B\u4E00\u3002`);
+      throw badRequest(`groupBy must be one of ${GROUP_BYS.join(" / ")}.`);
     }
     const from = optionalDateParam(c.req.query("from"), "from");
     const to = optionalDateParam(c.req.query("to"), "to");
@@ -2326,12 +2350,16 @@ async function assertWorkspaceAllowed(args) {
     throw new HttpError(
       400,
       "workspace_not_found",
-      `Workspace \u4E0D\u5B58\u5728\u6216\u4E0D\u53EF\u8BBF\u95EE\uFF1A${args.workspace}\u3002\u8BF7\u6307\u5B9A\u4E00\u4E2A\u5DF2\u5B58\u5728\u7684\u76EE\u5F55\uFF0C\u6216\u7559\u7A7A\u4EE5\u4F7F\u7528\u4E34\u65F6\u76EE\u5F55\u3002`
+      `Workspace does not exist or is inaccessible: ${args.workspace}. Specify an existing directory, or leave it empty to use a temporary directory.`
     );
   }
   const stat = await fs5.stat(ws);
   if (!stat.isDirectory()) {
-    throw new HttpError(400, "workspace_not_found", `Workspace \u4E0D\u662F\u76EE\u5F55\uFF1A${args.workspace}\u3002`);
+    throw new HttpError(
+      400,
+      "workspace_not_found",
+      `Workspace is not a directory: ${args.workspace}.`
+    );
   }
   return ws;
 }
@@ -2373,7 +2401,7 @@ var WorkspaceFilesService = class {
     try {
       return await fs6.realpath(path5.resolve(workspace));
     } catch {
-      throw new HttpError(404, "workspace_missing", "\u8BE5 Session \u7684 Workspace \u5DF2\u4E0D\u5B58\u5728\u3002");
+      throw new HttpError(404, "workspace_missing", "This Session's Workspace no longer exists.");
     }
   }
   /**
@@ -2389,16 +2417,16 @@ var WorkspaceFilesService = class {
   }
   /** Lexical prefix check (a relative path, once resolved, must still be inside the Workspace); returns the absolute target path. */
   lexicalTarget(base, rel) {
-    if (rel.includes("\0")) throw badRequest("path \u975E\u6CD5\u3002");
+    if (rel.includes("\0")) throw badRequest("path is invalid.");
     const target = path5.resolve(base, rel === "" ? "." : rel);
     if (!this.isInside(target, base)) {
-      throw badRequest("path \u5FC5\u987B\u4F4D\u4E8E Workspace \u5185\u3002");
+      throw badRequest("path must be inside the Workspace.");
     }
     return target;
   }
   assertInside(real, realBase) {
     if (!this.isInside(real, realBase)) {
-      throw badRequest("path \u5FC5\u987B\u4F4D\u4E8E Workspace \u5185\u3002");
+      throw badRequest("path must be inside the Workspace.");
     }
   }
   /**
@@ -2416,7 +2444,7 @@ var WorkspaceFilesService = class {
       canonical = await fs6.realpath(target);
     } catch (err) {
       if (err.code === "ENOENT") {
-        throw new HttpError(404, "path_not_found", "\u6587\u4EF6\u4E0D\u5B58\u5728\u3002");
+        throw new HttpError(404, "path_not_found", "File does not exist.");
       }
       throw err;
     }
@@ -2441,7 +2469,7 @@ var WorkspaceFilesService = class {
     const realBase = await this.realBase(workspace);
     const target = this.lexicalTarget(path5.resolve(workspace), rel);
     const name = path5.basename(target);
-    if (name === "" || name === "." || name === "..") throw badRequest("path \u5FC5\u987B\u662F\u6587\u4EF6\u8DEF\u5F84\u3002");
+    if (name === "" || name === "." || name === "..") throw badRequest("path must be a file path.");
     const parent = path5.dirname(target);
     let canonicalParent;
     try {
@@ -2456,7 +2484,7 @@ var WorkspaceFilesService = class {
         } catch (probeErr) {
           if (probeErr.code !== "ENOENT") throw probeErr;
           const up = path5.dirname(probe);
-          if (up === probe) throw badRequest("path \u975E\u6CD5\u3002");
+          if (up === probe) throw badRequest("path is invalid.");
           probe = up;
         }
       }
@@ -2496,10 +2524,10 @@ var WorkspaceFilesService = class {
       dirents = await fs6.readdir(dir, { withFileTypes: true });
     } catch (err) {
       if (err.code === "ENOENT") {
-        throw new HttpError(404, "path_not_found", "\u76EE\u5F55\u4E0D\u5B58\u5728\u3002");
+        throw new HttpError(404, "path_not_found", "Directory does not exist.");
       }
       if (err.code === "ENOTDIR") {
-        throw badRequest("path \u4E0D\u662F\u76EE\u5F55\u3002");
+        throw badRequest("path is not a directory.");
       }
       throw err;
     }
@@ -2535,11 +2563,11 @@ var WorkspaceFilesService = class {
     try {
       stat = await fs6.stat(file);
     } catch {
-      throw new HttpError(404, "path_not_found", "\u6587\u4EF6\u4E0D\u5B58\u5728\u3002");
+      throw new HttpError(404, "path_not_found", "File does not exist.");
     }
-    if (stat.isDirectory()) throw badRequest("path \u662F\u76EE\u5F55\u3002");
+    if (stat.isDirectory()) throw badRequest("path is a directory.");
     if (stat.size > MAX_READ_BYTES) {
-      throw new HttpError(413, "file_too_large", "\u6587\u4EF6\u8D85\u8FC7 50MB \u8BFB\u53D6\u4E0A\u9650\u3002");
+      throw new HttpError(413, "file_too_large", "File exceeds the 50MB read limit.");
     }
     const data = await fs6.readFile(file);
     const ext = path5.extname(file).toLowerCase();
@@ -2559,9 +2587,9 @@ var WorkspaceFilesService = class {
    * sandbox escapes).
    */
   async write(workspace, rel, data) {
-    if (rel === "" || rel.endsWith("/")) throw badRequest("path \u5FC5\u987B\u662F\u6587\u4EF6\u8DEF\u5F84\u3002");
+    if (rel === "" || rel.endsWith("/")) throw badRequest("path must be a file path.");
     if (data.length > MAX_UPLOAD_BYTES) {
-      throw new HttpError(413, "file_too_large", "\u4E0A\u4F20\u6587\u4EF6\u8D85\u8FC7 14MB \u4E0A\u9650\u3002");
+      throw new HttpError(413, "file_too_large", "Uploaded file exceeds the 14MB limit.");
     }
     const { dir, name } = await this.resolveWriteParent(workspace, rel);
     const file = path5.join(dir, name);
@@ -2571,9 +2599,10 @@ var WorkspaceFilesService = class {
       handle = await fs6.open(file, flags, 420);
     } catch (err) {
       const code = err.code;
-      if (code === "ELOOP") throw badRequest("path \u4E0D\u80FD\u662F\u7B26\u53F7\u94FE\u63A5\u3002");
-      if (code === "ENOENT") throw new HttpError(404, "path_not_found", "\u7236\u76EE\u5F55\u4E0D\u5B58\u5728\u3002");
-      if (code === "EISDIR") throw badRequest("path \u662F\u76EE\u5F55\u3002");
+      if (code === "ELOOP") throw badRequest("path must not be a symlink.");
+      if (code === "ENOENT")
+        throw new HttpError(404, "path_not_found", "Parent directory does not exist.");
+      if (code === "EISDIR") throw badRequest("path is a directory.");
       throw err;
     }
     try {
@@ -2597,27 +2626,27 @@ var APPROVAL_MODES = [
 function parseTaskInput(body) {
   const input = body.input;
   if (!Array.isArray(input) || input.length === 0) {
-    throw badRequest("input \u5FC5\u987B\u662F\u81F3\u5C11\u5305\u542B\u4E00\u9879\u7684\u6570\u7EC4\u3002");
+    throw badRequest("input must be an array with at least one item.");
   }
   return input.map((item, i) => {
     if (item === null || typeof item !== "object" || Array.isArray(item)) {
-      throw badRequest(`input[${i}] \u5FC5\u987B\u662F\u5BF9\u8C61\u3002`);
+      throw badRequest(`input[${i}] must be an object.`);
     }
     const part = item;
     if (part.type === "text") {
       if (typeof part.text !== "string" || part.text.length === 0) {
-        throw badRequest(`input[${i}].text \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u3002`);
+        throw badRequest(`input[${i}].text must be a non-empty string.`);
       }
       return userText(part.text);
     }
     if (part.type === "image_url") {
       const url = part.imageUrl;
       if (typeof url !== "string" || !(url.startsWith("data:") || url.startsWith("http://") || url.startsWith("https://"))) {
-        throw badRequest(`input[${i}].imageUrl \u4EC5\u652F\u6301 data: \u6216 http(s) URL\u3002`);
+        throw badRequest(`input[${i}].imageUrl only supports data: or http(s) URLs.`);
       }
       return imageUrlMessage(url);
     }
-    throw badRequest(`input[${i}].type \u5FC5\u987B\u662F text / image_url \u4E4B\u4E00\u3002`);
+    throw badRequest(`input[${i}].type must be one of text / image_url.`);
   });
 }
 function agentSessionsRoutes(deps2) {
@@ -2638,8 +2667,10 @@ function agentSessionsRoutes(deps2) {
     const body = await readJson(c);
     const modelId = optionalString(body, "modelId", { minLen: 1, label: "modelId" });
     const provider = optionalString(body, "provider", { minLen: 1, label: "provider" });
-    if (provider !== void 0 && modelId === void 0) {
-      throw badRequest("\u6307\u5B9A\u4E86 provider \u5374\u672A\u6307\u5B9A modelId\uFF1A\u6A21\u578B\u5F15\u7528\u987B\u6210\u5BF9\u7ED9\u51FA\u3002");
+    if (modelId === void 0 !== (provider === void 0)) {
+      throw badRequest(
+        "modelId and provider must be given together as a model reference pair: specify both, or neither to use the Project's default model."
+      );
     }
     const approvalMode = optionalEnum(body, "approvalMode", APPROVAL_MODES);
     let workspace = optionalString(body, "workspace", { minLen: 1, label: "workspace" });
@@ -2664,12 +2695,20 @@ function sessionsRoutes(deps2) {
     const sessionId = c.req.param("sessionId");
     const row = sessionId ? deps2.sessionsRepo.findById(sessionId) : null;
     if (!row) {
-      throw new HttpError(404, "session_not_found", "Session \u4E0D\u5B58\u5728\u6216\u65E0\u6743\u8BBF\u95EE\u3002");
+      throw new HttpError(
+        404,
+        "session_not_found",
+        "Session does not exist or you do not have access."
+      );
     }
     try {
       deps2.projectService.requireProjectAccess(c.var.user.userId, row.projectId);
     } catch {
-      throw new HttpError(404, "session_not_found", "Session \u4E0D\u5B58\u5728\u6216\u65E0\u6743\u8BBF\u95EE\u3002");
+      throw new HttpError(
+        404,
+        "session_not_found",
+        "Session does not exist or you do not have access."
+      );
     }
     return row;
   };
@@ -2688,15 +2727,23 @@ function sessionsRoutes(deps2) {
     let title;
     if (titleRaw !== void 0) {
       if (typeof titleRaw !== "string") {
-        throw new HttpError(400, "invalid_title", "title \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u3002");
+        throw new HttpError(400, "invalid_title", "title must be a string.");
       }
       title = titleRaw.trim();
       if (!title || title.length > SESSION_TITLE_MAX) {
-        throw new HttpError(400, "invalid_title", `title \u9700\u4E3A 1\u2013${SESSION_TITLE_MAX} \u4E2A\u5B57\u7B26\u3002`);
+        throw new HttpError(
+          400,
+          "invalid_title",
+          `title must be 1\u2013${SESSION_TITLE_MAX} characters.`
+        );
       }
     }
     if (approvalMode === void 0 && archived === void 0 && title === void 0) {
-      throw new HttpError(400, "no_update", "\u7F3A\u5C11\u53EF\u66F4\u65B0\u5B57\u6BB5\uFF08approvalMode / archived / title\uFF09\u3002");
+      throw new HttpError(
+        400,
+        "no_update",
+        "No updatable field provided (approvalMode / archived / title)."
+      );
     }
     let updated = { ...row };
     if (title !== void 0) {
@@ -2742,7 +2789,7 @@ function sessionsRoutes(deps2) {
     const row = resolveSession(c);
     const fileName = c.req.param("fileName") ?? "";
     if (!/^[A-Za-z0-9._-]+$/.test(fileName) || fileName.includes("..")) {
-      throw new HttpError(404, "file_not_found", "\u6587\u4EF6\u4E0D\u5B58\u5728\u3002");
+      throw new HttpError(404, "file_not_found", "File does not exist.");
     }
     const filePath = path6.join(
       scratchpadDir(deps2.config.root, row.projectId, row.agentId),
@@ -2753,7 +2800,7 @@ function sessionsRoutes(deps2) {
     try {
       bytes = await fs7.readFile(filePath);
     } catch {
-      throw new HttpError(404, "file_not_found", "\u6587\u4EF6\u4E0D\u5B58\u5728\u3002");
+      throw new HttpError(404, "file_not_found", "File does not exist.");
     }
     const MIME_BY_EXT = {
       ".png": "image/png",
@@ -2802,7 +2849,11 @@ function sessionsRoutes(deps2) {
     const decision = requireEnum(body, "decision", ["allow", "deny"]);
     const ok = deps2.manager.decideApproval(row.sessionId, pathParam(c, "toolCallId"), decision);
     if (!ok) {
-      throw new HttpError(404, "approval_not_found", "\u8BE5\u5BA1\u6279\u4E0D\u5B58\u5728\u6216\u5DF2\u88AB\u51B3\u5B9A\u3002");
+      throw new HttpError(
+        404,
+        "approval_not_found",
+        "Approval does not exist or has already been decided."
+      );
     }
     return c.body(null, 204);
   });
@@ -2825,18 +2876,22 @@ function sessionsRoutes(deps2) {
     const row = resolveSession(c);
     const rel = c.req.query("path") ?? "";
     const download = c.req.query("download") === "1";
+    const preview = !download && c.req.query("preview") === "1";
     const { data, fileName, contentType, scriptable } = await deps2.workspaceFiles.read(
       row.workspace,
       rel
     );
     const disposition = download ? "attachment" : "inline";
-    const effectiveType = !download && scriptable ? "text/plain; charset=utf-8" : contentType;
+    const effectiveType = !download && scriptable && !preview ? "text/plain; charset=utf-8" : contentType;
     return new Response(new Uint8Array(data), {
       status: 200,
       headers: {
         "Content-Type": effectiveType,
         "Content-Disposition": `${disposition}; filename*=UTF-8''${encodeURIComponent(fileName)}`,
-        "X-Content-Type-Options": "nosniff"
+        "X-Content-Type-Options": "nosniff",
+        ...preview && scriptable ? {
+          "Content-Security-Policy": "sandbox allow-scripts allow-popups allow-modals allow-forms"
+        } : {}
       }
     });
   });
@@ -2846,7 +2901,7 @@ function sessionsRoutes(deps2) {
     const paths = body.paths;
     if (!Array.isArray(paths) || paths.length > STAT_MAX_PATHS || !paths.every((p) => typeof p === "string" && p.length <= STAT_MAX_PATH_LEN)) {
       throw badRequest(
-        `paths \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4\uFF08\u2264${STAT_MAX_PATHS} \u9879\uFF0C\u6BCF\u9879 \u2264${STAT_MAX_PATH_LEN} \u5B57\u7B26\uFF09\u3002`
+        `paths must be an array of strings (\u2264${STAT_MAX_PATHS} items, each \u2264${STAT_MAX_PATH_LEN} characters).`
       );
     }
     const existing = await deps2.workspaceFiles.statExisting(row.workspace, paths);
@@ -2857,11 +2912,11 @@ function sessionsRoutes(deps2) {
     const rel = c.req.query("path") ?? "";
     const body = await readJson(c);
     if (typeof body.dataBase64 !== "string") {
-      throw badRequest("dataBase64 \u5FC5\u987B\u662F base64 \u5B57\u7B26\u4E32\u3002");
+      throw badRequest("dataBase64 must be a base64 string.");
     }
     const data = Buffer.from(body.dataBase64, "base64");
     if (data.length > MAX_UPLOAD_BYTES) {
-      throw new HttpError(413, "file_too_large", "\u4E0A\u4F20\u6587\u4EF6\u8D85\u8FC7 14MB \u4E0A\u9650\u3002");
+      throw new HttpError(413, "file_too_large", "Uploaded file exceeds the 14MB limit.");
     }
     await deps2.workspaceFiles.write(row.workspace, rel, data);
     return c.body(null, 204);
@@ -2898,8 +2953,8 @@ function sessionsRoutes(deps2) {
 
 // src/runtime/channel.ts
 import { randomUUID } from "crypto";
-var DEFAULT_MAX_COUNT = 1e3;
-var DEFAULT_MAX_BYTES = 2 * 1024 * 1024;
+var DEFAULT_MAX_COUNT = 1e4;
+var DEFAULT_MAX_BYTES = 8 * 1024 * 1024;
 var Channel = class {
   /** Channel epoch: generated at instance creation, prefixed onto event ids (necessarily changes after recycle/recreate or restart). */
   epoch = randomUUID().slice(0, 8);
@@ -3169,12 +3224,16 @@ import path7 from "path";
 var TOOL_NAMES_MAX = 1e3;
 var ORIGIN_CTX_MAX = 200;
 var LLM_FAILURES = {
-  failed: { code: "llm_failed", kind: "unexpected", text: "LLM \u8BF7\u6C42\u5931\u8D25\uFF08\u4E0D\u53EF\u91CD\u8BD5\uFF09\u3002" },
-  timeout: { code: "llm_timeout", kind: "expected", text: "LLM \u8BF7\u6C42\u8D85\u65F6\uFF08\u5F15\u64CE\u91CD\u8FDE\u91CD\u8BD5\uFF09\u3002" },
+  failed: { code: "llm_failed", kind: "unexpected", text: "LLM request failed (not retryable)." },
+  timeout: {
+    code: "llm_timeout",
+    kind: "expected",
+    text: "LLM request timed out (the engine reconnects and retries)."
+  },
   malformed: {
     code: "llm_malformed",
     kind: "expected",
-    text: "LLM \u54CD\u5E94\u65E0\u6CD5\u89E3\u6790\uFF08\u5F15\u64CE\u91CD\u8FDE\u91CD\u8BD5\uFF09\u3002"
+    text: "LLM response could not be parsed (the engine reconnects and retries)."
   }
 };
 function isLlmFailure(s) {
@@ -3191,7 +3250,7 @@ function originKey(msg) {
   return origin && origin.length > 0 ? origin[origin.length - 1] : "";
 }
 function toolFailureText(output) {
-  if (!output) return "\u5DE5\u5177\u6267\u884C\u5931\u8D25\uFF08\u65E0\u8F93\u51FA\uFF09\u3002";
+  if (!output) return "Tool execution failed (no output).";
   if (output.length <= MESSAGE_MAX) return output;
   return `\u2026${output.slice(output.length - (MESSAGE_MAX - 1))}`;
 }
@@ -3331,9 +3390,9 @@ var StreamErrorWatcher = class {
 // src/runtime/session-manager.ts
 function compactUnavailable(why) {
   const messages = {
-    unsupported: "\u8BE5 Agent \u672A\u914D\u7F6E\u4E0A\u4E0B\u6587\u538B\u7F29\u80FD\u529B\u3002",
-    empty: "\u5F53\u524D\u4E0A\u4E0B\u6587\u6CA1\u6709\u53EF\u538B\u7F29\u7684\u5185\u5BB9\uFF08\u5C1A\u65E0\u5DF2\u5B8C\u6210\u7684\u5BF9\u8BDD\u8F6E\u6B21\uFF09\u3002",
-    just_compacted: "\u4E0A\u4E0B\u6587\u521A\u538B\u7F29\u8FC7\uFF0C\u6B64\u540E\u8FD8\u6CA1\u6709\u65B0\u7684\u5BF9\u8BDD\uFF0C\u65E0\u9700\u518D\u6B21\u538B\u7F29\u3002"
+    unsupported: "This Agent does not have context compaction configured.",
+    empty: "The current context has nothing to compact (no completed conversation turns yet).",
+    just_compacted: "The context was just compacted and there is no new conversation since; no need to compact again."
   };
   return new HttpError(409, "nothing_to_compact", messages[why]);
 }
@@ -3364,7 +3423,7 @@ function createCoreSessionLoader(root) {
         throw new HttpError(
           409,
           "workspace_missing",
-          `\u8BE5 Session \u7684 Workspace \u5DF2\u4E0D\u5B58\u5728\uFF1A${row.workspace}\uFF0C\u65E0\u6CD5\u7EE7\u7EED\u3002\u8BF7\u65B0\u5EFA Session\u3002`
+          `This Session's Workspace no longer exists: ${row.workspace}, so it cannot continue. Create a new Session.`
         );
       }
       try {
@@ -3391,6 +3450,7 @@ function toUnrecoverableError(err) {
 var ENTRY_IDLE_MS = 30 * 60 * 1e3;
 var ENTRY_SWEEP_INTERVAL_MS = 60 * 1e3;
 var TITLE_EXCERPT_LIMIT = 4e3;
+var EARLY_TITLE_BODY_CHARS = 1e3;
 function agentKey(projectId, agentId) {
   return `${projectId}\0${agentId}`;
 }
@@ -3447,6 +3507,8 @@ var SessionManager = class {
   deletingAgents = /* @__PURE__ */ new Set();
   /** Sessions currently being deleted (guards against the entry/Trace file being rebuilt and reviving it inside the deletion race window). */
   deletingSessions = /* @__PURE__ */ new Set();
+  /** Per-Agent config generation (key = agentKey), bumped by invalidateAgentRuntimes on vault updates. */
+  agentGenerations = /* @__PURE__ */ new Map();
   sweepTimer;
   // —— Query surface (used by Session listing / Agent active-count / SSE subscription replay) ——
   statusOf(sessionId) {
@@ -3479,9 +3541,23 @@ var SessionManager = class {
       approvals: new ApprovalRegistry(),
       abort: null,
       running: null,
+      generation: this.generationOf(row.projectId, row.agentId),
       lastActivityMs: Date.now()
     });
   }
+  /**
+   * After an Agent's vault is updated: bump the Agent's config generation so every
+   * runtime built before the update is discarded on its next idle access and
+   * re-resumed via the loader — resume re-reads agent_state/.vault.toml, so the next
+   * Task on any of this Agent's Sessions runs with the new values (history is
+   * preserved through the Trace). A Task already in flight is neither aborted nor
+   * hot-swapped: it keeps the values it started with, and its entry is rebuilt on
+   * the first access after it returns to idle (see ensureEntry).
+   */
+  invalidateAgentRuntimes(projectId, agentId) {
+    const key = agentKey(projectId, agentId);
+    this.agentGenerations.set(key, this.generationOf(projectId, agentId) + 1);
+  }
   // —— Task / compaction drive ——
   /**
    * Start a Task: get-or-load → 409
@@ -3657,38 +3733,70 @@ var SessionManager = class {
   // —— Internal ——
   assertOpen() {
     if (this.closed) {
-      throw new HttpError(503, "shutting_down", "\u670D\u52A1\u7AEF\u6B63\u5728\u5173\u505C\uFF0C\u6682\u4E0D\u63A5\u53D7\u65B0\u4EFB\u52A1\u3002");
+      throw new HttpError(
+        503,
+        "shutting_down",
+        "Server is shutting down; not accepting new Tasks."
+      );
     }
   }
   /** The Agent owning this Session is being deleted → 409 (guards against directory recreation inside the deletion race window). */
   assertAgentNotDeleting(sessionId) {
     const row = this.deps.sessions.findById(sessionId);
     if (row && this.deletingAgents.has(agentKey(row.projectId, row.agentId))) {
-      throw new HttpError(409, "agent_deleting", "\u8BE5 Agent \u6B63\u5728\u5220\u9664\uFF0C\u6682\u4E0D\u63A5\u53D7\u65B0\u4EFB\u52A1\u3002");
+      throw new HttpError(
+        409,
+        "agent_deleting",
+        "This Agent is being deleted; not accepting new Tasks."
+      );
     }
   }
   /** This Session is being deleted → 409 (guards against the entry/Trace being rebuilt and reviving it inside the deletion race window). */
   assertSessionNotDeleting(sessionId) {
     if (this.deletingSessions.has(sessionId)) {
-      throw new HttpError(409, "session_deleting", "\u8BE5 Session \u6B63\u5728\u5220\u9664\uFF0C\u6682\u4E0D\u63A5\u53D7\u65B0\u4EFB\u52A1\u3002");
+      throw new HttpError(
+        409,
+        "session_deleting",
+        "This Session is being deleted; not accepting new Tasks."
+      );
     }
   }
   assertIdle(entry) {
     if (entry.status === "running") {
-      throw new HttpError(409, "task_in_progress", "\u8BE5 Session \u5DF2\u6709\u8FDB\u884C\u4E2D\u7684 Task\u3002");
+      throw new HttpError(409, "task_in_progress", "This Session already has a Task in progress.");
     }
     if (entry.status === "compacting") {
-      throw new HttpError(409, "compacting", "\u8BE5 Session \u6B63\u5728\u538B\u7F29\u4E0A\u4E0B\u6587\uFF0C\u6682\u4E0D\u63A5\u53D7\u65B0\u8F93\u5165\u3002");
+      throw new HttpError(
+        409,
+        "compacting",
+        "This Session is compacting its context; not accepting new input."
+      );
     }
   }
+  generationOf(projectId, agentId) {
+    return this.agentGenerations.get(agentKey(projectId, agentId)) ?? 0;
+  }
   /** get-or-resume-or-heal: use directly on an active-table hit; otherwise load via the loader, updating the index's primary key on self-heal. */
   async ensureEntry(sessionId) {
     const existing = this.entries.get(sessionId);
-    if (existing) return existing;
+    if (existing) {
+      if (existing.generation === this.generationOf(existing.projectId, existing.agentId)) {
+        return existing;
+      }
+      if (existing.status !== "idle" || existing.running !== null || existing.approvals.size !== 0) {
+        return existing;
+      }
+      this.entries.delete(sessionId);
+    }
     const row = this.deps.sessions.findById(sessionId);
     if (!row) {
-      throw new HttpError(404, "session_not_found", "Session \u4E0D\u5B58\u5728\u6216\u65E0\u6743\u8BBF\u95EE\u3002");
+      throw new HttpError(
+        404,
+        "session_not_found",
+        "Session does not exist or you do not have access."
+      );
     }
+    const generation = this.generationOf(row.projectId, row.agentId);
     const session = await this.deps.loader.load(row);
     this.assertSessionNotDeleting(row.sessionId);
     this.assertAgentNotDeleting(row.sessionId);
@@ -3708,6 +3816,7 @@ var SessionManager = class {
       approvals: new ApprovalRegistry(),
       abort: null,
       running: null,
+      generation,
       lastActivityMs: Date.now()
     };
     this.entries.set(currentId, entry);
@@ -3720,6 +3829,8 @@ var SessionManager = class {
    * a title): it collects model text for automatic title generation.
    */
   async drive(entry, gen, titleSource) {
+    let earlyTitleFired = false;
+    let mainBodyChars = 0;
     const ctx = {
       projectId: entry.projectId,
       agentId: entry.agentId,
@@ -3755,7 +3866,7 @@ var SessionManager = class {
             }
           } catch (err) {
             this.log(
-              `[subagent] \u5B50\u4F1A\u8BDD\u767B\u8BB0\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`
+              `[subagent] Failed to register child session: ${err instanceof Error ? err.message : String(err)}`
             );
             this.deps.errors?.record({
               source: "subagent",
@@ -3771,18 +3882,30 @@ var SessionManager = class {
             child.assistantExcerpt += (child.assistantExcerpt ? "\n" : "") + nested.text;
           }
         }
+        if (!earlyTitleFired && titleSource?.userExcerpt.trim()) {
+          const p = msg.payload;
+          if ((!msg.origin || msg.origin.length === 0) && msg.type === "model_msg" && p.type === "text" && p.role === "assistant" && p.text) {
+            mainBodyChars += p.text.length;
+            if (mainBodyChars >= EARLY_TITLE_BODY_CHARS) {
+              earlyTitleFired = true;
+              this.deps.titles?.maybeGenerate(ctx, entry.session, {
+                fallbackText: titleSource.userExcerpt
+              });
+            }
+          }
+        }
         this.deps.channels.get(entry.sessionId).publish(msg);
         watcher?.observe(msg);
         try {
           await this.deps.recorder.record(ctx, msg);
         } catch (err) {
-          this.log(`[usage] \u843D\u5E93\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`);
+          this.log(`[usage] Insert failed: ${err instanceof Error ? err.message : String(err)}`);
           this.deps.errors?.record({ source: "usage", err, ctx, code: "usage_insert_failed" });
         }
       }
     } catch (err) {
       this.log(
-        `[session] \u8FD0\u884C\u5F02\u5E38: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
+        `[session] Run failed: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
       );
       this.deps.errors?.record({ source: "session", err, ctx, code: "session_run_failed" });
     } finally {
@@ -3913,7 +4036,7 @@ var Scheduler = class {
   now;
   intervalMs;
   timer = null;
-  /** key = `${projectId}${agentId}${name}` */
+  /** key = `${projectId}\0${agentId}\0${name}` */
   pending = /* @__PURE__ */ new Map();
   ticking = false;
   /** Start: run one reconcile immediately (startup semantics: no backfill), then enter the periodic tick. */
@@ -4010,7 +4133,7 @@ var Scheduler = class {
       if (!file.parsed.ok) {
         this.deps.errors.record({
           source: "schedule",
-          err: new Error(`\u5B9A\u65F6\u4EFB\u52A1\u6587\u4EF6\u975E\u6CD5\uFF1A${file.name}.toml\u2014\u2014${file.parsed.error}`),
+          err: new Error(`Invalid schedule file: ${file.name}.toml \u2014 ${file.parsed.error}`),
           code: "schedule_invalid_file",
           ctx: { projectId, agentId }
         });
@@ -4021,7 +4144,7 @@ var Scheduler = class {
       if (refError !== null) {
         this.deps.errors.record({
           source: "schedule",
-          err: new Error(`\u5B9A\u65F6\u4EFB\u52A1\u6587\u4EF6\u975E\u6CD5\uFF1A${file.name}.toml\u2014\u2014${refError}`),
+          err: new Error(`Invalid schedule file: ${file.name}.toml \u2014 ${refError}`),
           code: "schedule_invalid_file",
           ctx: { projectId, agentId }
         });
@@ -4081,7 +4204,9 @@ var Scheduler = class {
       if (!row || row.projectId !== projectId || row.agentId !== agentId) {
         this.deps.errors.record({
           source: "schedule",
-          err: new Error(`\u5B9A\u65F6\u4EFB\u52A1 ${def.name} \u7ED1\u5B9A\u7684 Session \u4E0D\u5B58\u5728\uFF1A${def.sessionId}`),
+          err: new Error(
+            `Schedule ${def.name} is bound to a Session that does not exist: ${def.sessionId}`
+          ),
           code: "schedule_session_missing",
           ctx: { projectId, agentId, sessionId: def.sessionId }
         });
@@ -4179,7 +4304,12 @@ var Scheduler = class {
 };
 
 // src/runtime/title-generator.ts
-import { emptyTokenCounts, sanitizeTitle, tokenUsage } from "@prismshadow/penguin-core";
+import {
+  emptyTokenCounts,
+  sanitizeTitle,
+  stripConversationMarkers,
+  tokenUsage
+} from "@prismshadow/penguin-core";
 var TitleGenerator = class {
   constructor(deps2) {
     this.deps = deps2;
@@ -4195,7 +4325,7 @@ var TitleGenerator = class {
     if (this.inflight.has(ctx.sessionId)) return;
     this.inflight.add(ctx.sessionId);
     void this.generate(ctx, session, req).catch((err) => {
-      this.log(`[title] \u751F\u6210\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`);
+      this.log(`[title] Generation failed: ${err instanceof Error ? err.message : String(err)}`);
       this.deps.errors?.record({ source: "title", err, ctx, code: "title_failed" });
     }).finally(() => {
       this.inflight.delete(ctx.sessionId);
@@ -4212,7 +4342,9 @@ var TitleGenerator = class {
         try {
           await this.deps.recorder.record(ctx, tokenUsage(emptyTokenCounts(), res.usage));
         } catch (err) {
-          this.log(`[title] \u7528\u91CF\u843D\u5E93\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`);
+          this.log(
+            `[title] Usage insert failed: ${err instanceof Error ? err.message : String(err)}`
+          );
           this.deps.errors?.record({
             source: "title",
             err,
@@ -4222,7 +4354,7 @@ var TitleGenerator = class {
         }
       }
     } catch (err) {
-      this.log(`[title] \u6A21\u578B\u8BF7\u6C42\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`);
+      this.log(`[title] Model request failed: ${err instanceof Error ? err.message : String(err)}`);
       this.deps.errors?.record({ source: "title", err, ctx, code: "title_llm_failed" });
     }
     const finalTitle = title ?? fallbackTitle(req.fallbackText);
@@ -4237,7 +4369,7 @@ var TitleGenerator = class {
   }
 };
 function fallbackTitle(text) {
-  const firstLine = text.split("\n").find((l) => l.trim().length > 0);
+  const firstLine = stripConversationMarkers(text).split("\n").find((l) => l.trim().length > 0);
   if (!firstLine) return null;
   return sanitizeTitle(firstLine) ?? firstLine.trim().slice(0, 30);
 }
@@ -4317,7 +4449,7 @@ var SEMANTIC_ID_PATTERN = /^[a-z][a-z0-9_]{1,63}$/;
 var USERNAME_PATTERN = /^[a-z][a-z0-9_]{1,31}$/;
 var PROJECT_SUFFIX_PATTERN = /^[a-z0-9_]+$/;
 var PROJECT_ID_MAX_LENGTH = 64;
-var SEMANTIC_ID_RULE = "\u5C0F\u5199\u5B57\u6BCD\u5F00\u5934\uFF0C\u4EC5\u5C0F\u5199\u5B57\u6BCD\u3001\u6570\u5B57\u4E0E\u4E0B\u5212\u7EBF";
+var SEMANTIC_ID_RULE = "starts with a lowercase letter; lowercase letters, digits and underscores only";
 
 // src/services/admin-service.ts
 var AdminService = class {
@@ -4332,13 +4464,17 @@ var AdminService = class {
   }
   async createUser(userId, password) {
     if (!USERNAME_PATTERN.test(userId)) {
-      throw new HttpError(400, "invalid_user_id", `\u7528\u6237\u540D\u987B\u4E3A 2~32 \u4F4D\uFF1A${SEMANTIC_ID_RULE}\u3002`);
+      throw new HttpError(
+        400,
+        "invalid_user_id",
+        `Username must be 2\u201332 characters: ${SEMANTIC_ID_RULE}.`
+      );
     }
     if (password.length < MIN_PASSWORD_LENGTH) {
-      throw new HttpError(400, "invalid_password", "\u5BC6\u7801\u81F3\u5C11 8 \u4E2A\u5B57\u7B26\u3002");
+      throw new HttpError(400, "invalid_password", "Password must be at least 8 characters.");
     }
     if (this.deps.users.findById(userId)) {
-      throw new HttpError(409, "user_exists", `\u7528\u6237\u5DF2\u5B58\u5728\uFF1A${userId}\u3002`);
+      throw new HttpError(409, "user_exists", `User already exists: ${userId}.`);
     }
     const user = {
       userId,
@@ -4359,10 +4495,10 @@ var AdminService = class {
   /** Reset another user's password: flags it as initial and clears all their sessions (prompts a password change on next login). */
   async resetPassword(userId, password) {
     if (!this.deps.users.findById(userId)) {
-      throw new HttpError(404, "user_not_found", `\u7528\u6237\u4E0D\u5B58\u5728\uFF1A${userId}\u3002`);
+      throw new HttpError(404, "user_not_found", `User does not exist: ${userId}.`);
     }
     if (password.length < MIN_PASSWORD_LENGTH) {
-      throw new HttpError(400, "invalid_password", "\u5BC6\u7801\u81F3\u5C11 8 \u4E2A\u5B57\u7B26\u3002");
+      throw new HttpError(400, "invalid_password", "Password must be at least 8 characters.");
     }
     this.deps.users.updatePassword(userId, await hashPassword(password), true);
     this.deps.authSessions.deleteByUser(userId);
@@ -4371,10 +4507,10 @@ var AdminService = class {
   async deleteUser(userId) {
     const target = this.deps.users.findById(userId);
     if (!target) {
-      throw new HttpError(404, "user_not_found", `\u7528\u6237\u4E0D\u5B58\u5728\uFF1A${userId}\u3002`);
+      throw new HttpError(404, "user_not_found", `User does not exist: ${userId}.`);
     }
     if (target.isAdmin) {
-      throw new HttpError(409, "cannot_delete_admin", "\u5185\u7F6E\u7BA1\u7406\u5458\u4E0D\u80FD\u5220\u9664\u3002");
+      throw new HttpError(409, "cannot_delete_admin", "The built-in admin cannot be deleted.");
     }
     for (const project of this.deps.projects.listByOwner(userId)) {
       await this.deps.projectService.destroyProject(project.projectId);
@@ -4441,6 +4577,8 @@ function refKey(provider, modelId) {
 function showRef(provider, modelId) {
   return `(provider=${provider}, model_id=${modelId})`;
 }
+var PROBE_PROMPT = 'ping - reply with the single word "pong" and nothing else. Do not think or explain.\n<think></think>';
+var SPEED_PROBE_PROMPT = "Count from 1 to 50 as a comma-separated list, and nothing else. Do not think or explain.\n<think></think>";
 var ProjectConfigService = class {
   constructor(root) {
     this.root = root;
@@ -4537,12 +4675,19 @@ var ProjectConfigService = class {
    * as a pair in the request body; sends one minimal request using that model's
    * config (optionally overridden with an unsaved apiKey / baseUrl) — no tools, no
    * system prompt, thinking disabled, a tiny output cap, 20s timeout — just to see
-   * whether it completes normally. The model id sent to AgentHub is `modelId`
+   * whether the endpoint answers. The model id sent to AgentHub is `modelId`
    * itself (the upstream id verbatim; client_type inference follows it).
    *
+   * A reasoning-heavy model may ignore the disabled thinking level and burn the
+   * whole tiny output cap on thinking (finish_reason=length with no text — AgentHub
+   * raises EmptyResponseError, collapsed to a malformed outcome): the endpoint
+   * demonstrably streamed model output, which is everything a connectivity test
+   * proves, so that case counts as ok too (see probeVerdict).
+   *
    * Never throws: the LLM layer collapses auth/parameter/network errors into an
    * `LLMOutcome`, which is translated here into ok / message. Consumes very few
-   * Tokens (single-digit output), and writes no Trace and records no usage.
+   * Tokens (single-digit output; speed mode spends up to its 64-token cap to have a
+   * window worth timing), and writes no Trace and records no usage.
    */
   async testModel(projectId, req) {
     const raw = await this.readRaw(projectId);
@@ -4561,18 +4706,39 @@ var ProjectConfigService = class {
         ...clientType ? { clientType } : {},
         tools: [],
         thinkingLevel: "none",
-        maxTokens: 16,
+        // Speed mode pairs a raised cap with a prompt that keeps generating (see
+        // SPEED_PROBE_PROMPT), so the stream lasts long enough for TTFT/TPS to describe
+        // decoding rather than one round trip; the plain connectivity test keeps the
+        // single-digit-token budget.
+        maxTokens: req.speed ? 64 : 16,
         requestTimeoutMs: 2e4
       });
-      const gen = llm.streamGenerate({ newMessages: [userText3("ping")] });
+      const gen = llm.streamGenerate({
+        newMessages: [userText3(req.speed ? SPEED_PROBE_PROMPT : PROBE_PROMPT)]
+      });
+      let sawContent = false;
+      let firstContentAt = null;
+      let outputTokens = 0;
       for (; ; ) {
         const step = await gen.next();
         if (step.done) {
-          const outcome = step.value;
-          if (outcome.status === "completed")
-            return { ok: true, latencyMs: Date.now() - startedAt };
-          const detail = "message" in outcome && outcome.message ? outcome.message : outcome.status;
-          return { ok: false, message: String(detail).slice(0, 300) };
+          const verdict = probeVerdict(step.value, sawContent);
+          if (!verdict.ok) return verdict;
+          const res = { ok: true, latencyMs: Date.now() - startedAt };
+          if (firstContentAt !== null) {
+            res.ttftMs = firstContentAt - startedAt;
+            const tps = probeTps(outputTokens, Date.now() - firstContentAt);
+            if (tps !== void 0) res.tps = tps;
+          }
+          return res;
+        }
+        if (isProbeContent(step.value)) {
+          sawContent = true;
+          if (firstContentAt === null) firstContentAt = Date.now();
+        }
+        const p = step.value.payload;
+        if (p.type === "token_usage" && typeof p.request?.output === "number") {
+          outputTokens = p.request.output;
         }
       }
     } catch (err) {
@@ -4662,7 +4828,7 @@ var ProjectConfigService = class {
       const key = refKey(entry.provider, entry.modelId);
       if (seen.has(key)) {
         throw badRequest(
-          `models \u4E2D\u5B58\u5728\u91CD\u590D\u7684\u6A21\u578B\u5F15\u7528\uFF1A${showRef(entry.provider, entry.modelId)}\u3002`
+          `models contains a duplicate model reference: ${showRef(entry.provider, entry.modelId)}.`
         );
       }
       seen.add(key);
@@ -4712,7 +4878,7 @@ var ProjectConfigService = class {
     if (req.defaultModel !== void 0) {
       if (!seen.has(refKey(req.defaultModel.provider, req.defaultModel.modelId))) {
         throw badRequest(
-          `defaultModel \u5FC5\u987B\u5305\u542B\u5728 models \u5185\uFF1A${showRef(req.defaultModel.provider, req.defaultModel.modelId)}\u3002`
+          `defaultModel must be included in models: ${showRef(req.defaultModel.provider, req.defaultModel.modelId)}.`
         );
       }
       defaultModel = req.defaultModel;
@@ -4732,12 +4898,12 @@ var ProjectConfigService = class {
     if (req.visionModel !== void 0) {
       if (!seen.has(refKey(req.visionModel.provider, req.visionModel.modelId))) {
         throw badRequest(
-          `visionModel \u5FC5\u987B\u5305\u542B\u5728 models \u5185\uFF1A${showRef(req.visionModel.provider, req.visionModel.modelId)}\u3002`
+          `visionModel must be included in models: ${showRef(req.visionModel.provider, req.visionModel.modelId)}.`
         );
       }
       if (targetOf(req.visionModel)?.vision === false) {
         throw badRequest(
-          `visionModel \u4E0D\u80FD\u6307\u5411\u6807\u6CE8\u4E3A\u4E0D\u652F\u6301\u56FE\u7247\u7684\u6A21\u578B\uFF1A${showRef(req.visionModel.provider, req.visionModel.modelId)}\u3002`
+          `visionModel must not point to a model annotated as not supporting images: ${showRef(req.visionModel.provider, req.visionModel.modelId)}.`
         );
       }
       visionModel = req.visionModel;
@@ -4767,6 +4933,24 @@ var ProjectConfigService = class {
     return this.getModels(projectId);
   }
 };
+function isProbeContent(msg) {
+  const p = msg.payload;
+  if (p.type === "partial_thinking" || p.type === "thinking") return Boolean(p.thinking);
+  if (p.type === "partial_text" || p.type === "text") return Boolean(p.text);
+  return false;
+}
+function probeVerdict(outcome, sawContent) {
+  if (outcome.status === "completed") return { ok: true };
+  if (outcome.status === "malformed" && sawContent) return { ok: true };
+  const detail = "message" in outcome && outcome.message ? outcome.message : outcome.status;
+  return { ok: false, message: String(detail).slice(0, 300) };
+}
+var PROBE_TPS_MIN_TOKENS = 16;
+var PROBE_TPS_MIN_WINDOW_MS = 100;
+function probeTps(outputTokens, windowMs) {
+  if (outputTokens < PROBE_TPS_MIN_TOKENS || windowMs <= PROBE_TPS_MIN_WINDOW_MS) return void 0;
+  return Math.round(outputTokens / (windowMs / 1e3) * 10) / 10;
+}
 
 // src/services/agent-config-service.ts
 var THINKING_LEVELS = ["none", "low", "medium", "high", "xhigh"];
@@ -4790,7 +4974,7 @@ var AgentConfigService = class {
   }
   async requireExists(projectId, agentId) {
     if (!await this.exists(projectId, agentId)) {
-      throw new HttpError(404, "agent_not_found", "Agent \u4E0D\u5B58\u5728\u3002");
+      throw new HttpError(404, "agent_not_found", "Agent does not exist.");
     }
   }
   /**
@@ -4875,8 +5059,8 @@ var AgentConfigService = class {
     const cfg = config2;
     const yamlPath = systemConfigPath(this.root, projectId, agentId);
     const doc = parseDocument(await fs10.readFile(yamlPath, "utf8"));
-    const setIfProvided = (path16, value) => {
-      if (value !== void 0) doc.setIn(path16, value);
+    const setIfProvided = (path17, value) => {
+      if (value !== void 0) doc.setIn(path17, value);
     };
     setIfProvided(["name"], optionalString(cfg, "name", { maxLen: 100, label: "name" }));
     setIfProvided(
@@ -4952,23 +5136,25 @@ var AgentConfigService = class {
     for (const entry of req.entries) {
       if (!isValidVaultKey(entry.key)) {
         throw badRequest(
-          `vault \u952E\u540D\u4E0D\u5408\u6CD5\uFF1A${entry.key}\uFF08\u4EC5\u5B57\u6BCD\u3001\u6570\u5B57\u4E0E\u4E0B\u5212\u7EBF\uFF0C\u4E14\u4E0D\u80FD\u4EE5\u6570\u5B57\u5F00\u5934\uFF09\u3002`
+          `Invalid vault key name: ${entry.key} (letters, digits and underscores only, and must not start with a digit).`
         );
       }
       if (seen.has(entry.key)) {
-        throw badRequest(`entries \u4E2D\u5B58\u5728\u91CD\u590D\u7684\u952E\u540D\uFF1A${entry.key}\u3002`);
+        throw badRequest(`entries contains a duplicate key: ${entry.key}.`);
       }
       seen.add(entry.key);
       const prevValue = prev[entry.key];
       if (entry.value !== void 0) {
         if (entry.value.length > VAULT_VALUE_MAX_LENGTH) {
-          throw badRequest(`vault \u503C\u8FC7\u957F\uFF1A${entry.key}\uFF08\u4E0A\u9650 ${VAULT_VALUE_MAX_LENGTH} \u5B57\u7B26\uFF09\u3002`);
+          throw badRequest(
+            `Vault value too long: ${entry.key} (limit ${VAULT_VALUE_MAX_LENGTH} characters).`
+          );
         }
         nextVault[entry.key] = entry.value;
       } else if (prevValue !== void 0) {
         nextVault[entry.key] = prevValue;
       } else {
-        throw badRequest(`\u65B0\u589E\u952E ${entry.key} \u5FC5\u987B\u63D0\u4F9B value\u3002`);
+        throw badRequest(`New key ${entry.key} must provide a value.`);
       }
     }
     await saveAgentVault(this.root, projectId, agentId, nextVault);
@@ -4976,20 +5162,20 @@ var AgentConfigService = class {
   }
 };
 function validateToolsBuiltin(value) {
-  if (!Array.isArray(value)) throw badRequest("toolsBuiltin \u5FC5\u987B\u662F\u6570\u7EC4\u3002");
+  if (!Array.isArray(value)) throw badRequest("toolsBuiltin must be an array.");
   return value.map((item, i) => {
     const t = asRecord(item);
     if (typeof t.name !== "string" || t.name.length === 0) {
-      throw badRequest(`toolsBuiltin[${i}].name \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u3002`);
+      throw badRequest(`toolsBuiltin[${i}].name must be a non-empty string.`);
     }
     if (typeof t.description !== "string") {
-      throw badRequest(`toolsBuiltin[${i}].description \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u3002`);
+      throw badRequest(`toolsBuiltin[${i}].description must be a string.`);
     }
     if (t.permission !== void 0 && t.permission !== "r" && t.permission !== "rw") {
-      throw badRequest(`toolsBuiltin[${i}].permission \u5FC5\u987B\u662F r / rw \u4E4B\u4E00\u3002`);
+      throw badRequest(`toolsBuiltin[${i}].permission must be one of r / rw.`);
     }
     if (t.forModel !== void 0 && t.forModel !== "vision" && t.forModel !== "text-only") {
-      throw badRequest(`toolsBuiltin[${i}].forModel \u5FC5\u987B\u662F vision / text-only \u4E4B\u4E00\u3002`);
+      throw badRequest(`toolsBuiltin[${i}].forModel must be one of vision / text-only.`);
     }
     optionalNumber(t, "timeoutMs", {
       integer: true,
@@ -5005,14 +5191,14 @@ function validateToolsBuiltin(value) {
   });
 }
 function validateMcpServers(value) {
-  if (!Array.isArray(value)) throw badRequest("mcpServers \u5FC5\u987B\u662F\u6570\u7EC4\u3002");
+  if (!Array.isArray(value)) throw badRequest("mcpServers must be an array.");
   return value.map((item, i) => {
     const s = asRecord(item);
     if (typeof s.name !== "string" || s.name.length === 0) {
-      throw badRequest(`mcpServers[${i}].name \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u3002`);
+      throw badRequest(`mcpServers[${i}].name must be a non-empty string.`);
     }
     if (s.config === null || typeof s.config !== "object" || Array.isArray(s.config)) {
-      throw badRequest(`mcpServers[${i}].config \u5FC5\u987B\u662F\u5BF9\u8C61\u3002`);
+      throw badRequest(`mcpServers[${i}].config must be an object.`);
     }
     return s;
   });
@@ -5020,6 +5206,7 @@ function validateMcpServers(value) {
 
 // src/services/agent-service.ts
 import fs11 from "fs/promises";
+import path10 from "path";
 import {
   agentDir,
   agentsDir as agentsDir2,
@@ -5029,6 +5216,7 @@ import {
   isValidId as isValidId3,
   loadAgentVault as loadAgentVault2,
   scheduleDir as scheduleDir2,
+  skillsDir as skillsDir2,
   systemConfigPath as systemConfigPath2
 } from "@prismshadow/penguin-core";
 var AgentService = class {
@@ -5068,11 +5256,12 @@ var AgentService = class {
     );
     return Promise.all(
       sorted.map(async (row) => {
-        const [meta, updatedAt, vaultKeyCount, scheduleCount] = await Promise.all([
+        const [meta, updatedAt, vaultKeyCount, scheduleCount, skillCount] = await Promise.all([
           this.agentConfig.readCardMeta(projectId, row.agentId),
           this.configUpdatedAt(projectId, row.agentId),
           this.vaultKeyCount(projectId, row.agentId),
-          this.scheduleCount(projectId, row.agentId)
+          this.scheduleCount(projectId, row.agentId),
+          this.skillCount(projectId, row.agentId)
         ]);
         return {
           agentId: row.agentId,
@@ -5080,7 +5269,8 @@ var AgentService = class {
           createdAt: row.createdAt,
           ...updatedAt !== void 0 ? { updatedAt } : {},
           vaultKeyCount,
-          scheduleCount
+          scheduleCount,
+          skillCount
         };
       })
     );
@@ -5102,6 +5292,27 @@ var AgentService = class {
       return 0;
     }
   }
+  /** Number of installed Skills: count of skills/<name>/ directories containing a SKILL.md (0 if the directory doesn't exist). */
+  async skillCount(projectId, agentId) {
+    const base = skillsDir2(this.root, projectId, agentId);
+    let dirents;
+    try {
+      dirents = await fs11.readdir(base, { withFileTypes: true });
+    } catch {
+      return 0;
+    }
+    const present = await Promise.all(
+      dirents.filter((d) => d.isDirectory()).map(async (d) => {
+        try {
+          await fs11.access(path10.join(base, d.name, "SKILL.md"));
+          return true;
+        } catch {
+          return false;
+        }
+      })
+    );
+    return present.filter(Boolean).length;
+  }
   /** Last config modification time: the later of system_config.yaml and AGENTS.md mtime; omitted if neither is readable. */
   async configUpdatedAt(projectId, agentId) {
     const paths = [
@@ -5133,7 +5344,7 @@ var AgentService = class {
       throw new HttpError(
         409,
         "cannot_delete_builtin_agent",
-        "\u5185\u7F6E Agent\uFF08default_agent\uFF09\u968F Project \u4F9B\u7ED9\uFF0C\u4E0D\u80FD\u4ECE Web \u5220\u9664\u3002"
+        "Built-in Agents (default_agent) are provisioned with the Project and cannot be deleted from the web."
       );
     }
     await fs11.rm(agentDir(this.root, projectId, agentId), { recursive: true, force: true });
@@ -5147,14 +5358,18 @@ var AgentService = class {
    */
   async createAgent(projectId, agentId, name, description) {
     if (!SEMANTIC_ID_PATTERN.test(agentId)) {
-      throw new HttpError(400, "invalid_agent_id", `Agent id \u987B\u4E3A 2~64 \u4F4D\uFF1A${SEMANTIC_ID_RULE}\u3002`);
+      throw new HttpError(
+        400,
+        "invalid_agent_id",
+        `Agent id must be 2\u201364 characters: ${SEMANTIC_ID_RULE}.`
+      );
     }
     const taken = this.agents.exists(projectId, agentId) || await fs11.stat(agentDir(this.root, projectId, agentId)).then(
       () => true,
       () => false
     );
     if (taken) {
-      throw new HttpError(409, "agent_exists", `Agent id \u5DF2\u88AB\u5360\u7528\uFF1A${agentId}\u3002`);
+      throw new HttpError(409, "agent_exists", `Agent id is already taken: ${agentId}.`);
     }
     const displayName = name ?? agentId;
     await coreCreateAgent({ root: this.root, projectId, agentId });
@@ -5179,14 +5394,16 @@ var AgentService = class {
       toolCount: meta.toolCount,
       version: meta.version,
       vaultKeyCount: 0,
-      scheduleCount: 0
+      scheduleCount: 0,
+      // Read the real count: coreCreateAgent seeds the default skill set for default_agent.
+      skillCount: await this.skillCount(projectId, agentId)
     };
   }
 };
 
 // src/services/benchmark-service.ts
 import fs12 from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 import { parse as parseToml3 } from "smol-toml";
 import { parse as parseYaml2 } from "yaml";
 import { benchmarksDir } from "@prismshadow/penguin-core";
@@ -5288,7 +5505,7 @@ var BenchmarkService = class {
     }
     const benchmarks = [];
     for (const item of items.filter((i) => i.isDir).sort((a, b) => a.name.localeCompare(b.name))) {
-      benchmarks.push(await this.readBenchmark(path10.join(dir, item.name), item.name));
+      benchmarks.push(await this.readBenchmark(path11.join(dir, item.name), item.name));
     }
     return { benchmarks };
   }
@@ -5298,7 +5515,7 @@ var BenchmarkService = class {
     let runs;
     try {
       const config2 = asRecord2(
-        parseToml3(await fs12.readFile(path10.join(benchDir, "benchmark_config.toml"), "utf8"))
+        parseToml3(await fs12.readFile(path11.join(benchDir, "benchmark_config.toml"), "utf8"))
       );
       if (typeof config2.title === "string" && config2.title !== "") title = config2.title;
       if (typeof config2.description === "string" && config2.description !== "") {
@@ -5313,7 +5530,7 @@ var BenchmarkService = class {
     let evaluations = [];
     try {
       const scoreboard = asRecord2(
-        parseYaml2(await fs12.readFile(path10.join(benchDir, "scoreboard.yaml"), "utf8"))
+        parseYaml2(await fs12.readFile(path11.join(benchDir, "scoreboard.yaml"), "utf8"))
       );
       if (Array.isArray(scoreboard.evaluations)) {
         evaluations = scoreboard.evaluations.map(toEvaluation).filter((e) => e !== null);
@@ -5340,7 +5557,7 @@ var BenchmarkService = class {
 // src/services/snapshot-service.ts
 import { randomBytes as randomBytes4 } from "crypto";
 import fs13 from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 import * as tar from "tar";
 import { parse as parseYaml3 } from "yaml";
 import {
@@ -5353,7 +5570,7 @@ import {
 } from "@prismshadow/penguin-core";
 var VAULT_BASENAME = ".vault.toml";
 function isVaultEntry(entryPath) {
-  return path11.posix.basename(entryPath.replaceAll("\\", "/")) === VAULT_BASENAME;
+  return path12.posix.basename(entryPath.replaceAll("\\", "/")) === VAULT_BASENAME;
 }
 var SnapshotService = class {
   constructor(root) {
@@ -5366,7 +5583,7 @@ var SnapshotService = class {
     try {
       raw = await fs13.readFile(systemConfigPath3(this.root, projectId, agentId), "utf8");
     } catch {
-      throw new HttpError(404, "agent_not_found", "Agent \u4E0D\u5B58\u5728\u3002");
+      throw new HttpError(404, "agent_not_found", "Agent does not exist.");
     }
     const parsed = parseYaml3(raw);
     return agentStateVersion2({
@@ -5377,7 +5594,7 @@ var SnapshotService = class {
   async ensureSnapshot(projectId, agentId) {
     const version = await this.currentVersion(projectId, agentId);
     const dir = snapshotsDir(this.root, projectId, agentId);
-    const file = path11.join(dir, `v${version}.tar.gz`);
+    const file = path12.join(dir, `v${version}.tar.gz`);
     try {
       await fs13.access(file);
       return { version, file };
@@ -5412,12 +5629,12 @@ var SnapshotService = class {
   async importArchive(projectId, agentId, archive, confirm) {
     const current = await this.currentVersion(projectId, agentId);
     const base = agentDir2(this.root, projectId, agentId);
-    const staging = path11.join(base, `.import-${randomBytes4(6).toString("hex")}`);
+    const staging = path12.join(base, `.import-${randomBytes4(6).toString("hex")}`);
     await fs13.mkdir(staging, { recursive: true });
     try {
-      const archiveFile = path11.join(staging, "archive.tar.gz");
+      const archiveFile = path12.join(staging, "archive.tar.gz");
       await fs13.writeFile(archiveFile, archive);
-      const extractDir = path11.join(staging, "extracted");
+      const extractDir = path12.join(staging, "extracted");
       await fs13.mkdir(extractDir, { recursive: true });
       try {
         await tar.extract({
@@ -5426,21 +5643,21 @@ var SnapshotService = class {
           filter: (p) => !isVaultEntry(p)
         });
       } catch {
-        throw badRequest("\u5BFC\u5165\u5931\u8D25\uFF1A\u4E0D\u662F\u5408\u6CD5\u7684 tar.gz \u5FEB\u7167\u5305\u3002");
+        throw badRequest("Import failed: not a valid tar.gz snapshot package.");
       }
-      const configPath = path11.join(extractDir, "agent_state", "system_config.yaml");
+      const configPath = path12.join(extractDir, "agent_state", "system_config.yaml");
       let parsed;
       try {
         parsed = parseYaml3(await fs13.readFile(configPath, "utf8"));
       } catch {
-        throw badRequest("\u5BFC\u5165\u5931\u8D25\uFF1A\u5305\u5185\u7F3A\u5C11 agent_state/system_config.yaml\u3002");
+        throw badRequest("Import failed: the package is missing agent_state/system_config.yaml.");
       }
       if (parsed === null || typeof parsed !== "object" || typeof parsed.system_prompt !== "string") {
-        throw badRequest("\u5BFC\u5165\u5931\u8D25\uFF1A\u5305\u5185 system_config.yaml \u975E\u6CD5\u3002");
+        throw badRequest("Import failed: the package's system_config.yaml is invalid.");
       }
       const incomingRaw = parsed.version;
       if (incomingRaw !== void 0 && (!Number.isInteger(incomingRaw) || incomingRaw < 1)) {
-        throw badRequest("\u5BFC\u5165\u5931\u8D25\uFF1A\u5305\u5185 version \u975E\u6CD5\u3002");
+        throw badRequest("Import failed: the package's version is invalid.");
       }
       const incoming = agentStateVersion2({
         version: typeof incomingRaw === "number" ? incomingRaw : void 0
@@ -5449,21 +5666,21 @@ var SnapshotService = class {
         throw new HttpError(
           409,
           "version_conflict",
-          `\u5305\u7248\u672C v${incoming} \u4E0D\u9AD8\u4E8E\u5F53\u524D v${current}\uFF0C\u9700\u8981\u786E\u8BA4\u540E\u5BFC\u5165\u3002`
+          `Package version v${incoming} is not higher than the current v${current}; confirmation is required to import.`
         );
       }
       await this.ensureSnapshot(projectId, agentId);
       const stateDir = agentStateDir2(this.root, projectId, agentId);
-      const incomingState = path11.join(extractDir, "agent_state");
+      const incomingState = path12.join(extractDir, "agent_state");
       let vault = null;
       try {
         vault = await fs13.readFile(agentVaultPath(this.root, projectId, agentId));
       } catch {
       }
       if (vault !== null) {
-        await fs13.writeFile(path11.join(incomingState, VAULT_BASENAME), vault, { mode: 384 });
+        await fs13.writeFile(path12.join(incomingState, VAULT_BASENAME), vault, { mode: 384 });
       }
-      const trash = path11.join(staging, "replaced-agent_state");
+      const trash = path12.join(staging, "replaced-agent_state");
       await fs13.rename(stateDir, trash);
       try {
         await fs13.rename(incomingState, stateDir);
@@ -5482,9 +5699,9 @@ var SnapshotService = class {
 import fs14 from "fs/promises";
 import { DEFAULT_PROJECT_ID, projectDir, provisionProjectAgents } from "@prismshadow/penguin-core";
 var ABORT_SETTLE_TIMEOUT_MS = 5e3;
-async function dirExists(path16) {
+async function dirExists(path17) {
   try {
-    const stat = await fs14.stat(path16);
+    const stat = await fs14.stat(path17);
     return stat.isDirectory();
   } catch {
     return false;
@@ -5514,7 +5731,11 @@ var ProjectService = class {
   requireProjectAccess(userId, projectId) {
     const row = this.resolveAccess(userId, projectId);
     if (!row) {
-      throw new HttpError(404, "project_not_found", "Project \u4E0D\u5B58\u5728\u6216\u65E0\u6743\u8BBF\u95EE\u3002");
+      throw new HttpError(
+        404,
+        "project_not_found",
+        "Project does not exist or you do not have access."
+      );
     }
     return row;
   }
@@ -5531,7 +5752,11 @@ var ProjectService = class {
   requireProjectOwner(userId, projectId) {
     const row = this.requireProjectAccess(userId, projectId);
     if (row.role !== "owner") {
-      throw new HttpError(403, "owner_required", "\u8BE5\u64CD\u4F5C\u4EC5 Project owner \u53EF\u6267\u884C\u3002");
+      throw new HttpError(
+        403,
+        "owner_required",
+        "Only the Project owner can perform this operation."
+      );
     }
     return row;
   }
@@ -5573,7 +5798,7 @@ var ProjectService = class {
         throw new HttpError(
           400,
           "invalid_project_id",
-          `Project id \u987B\u4E3A 2~64 \u4F4D\uFF1A${SEMANTIC_ID_RULE}\uFF08\u8FDE\u5B57\u7B26\u4FDD\u7559\u4F5C\u7528\u6237\u547D\u540D\u7A7A\u95F4\u5206\u9694\uFF09\u3002`
+          `Project id must be 2\u201364 characters: ${SEMANTIC_ID_RULE} (the hyphen is reserved as the user namespace separator).`
         );
       }
     } else {
@@ -5583,12 +5808,12 @@ var ProjectService = class {
         throw new HttpError(
           400,
           "project_id_prefix_required",
-          `Project id \u987B\u4EE5 ${prefix} \u5F00\u5934\uFF0C\u540E\u63A5\u5C0F\u5199\u5B57\u6BCD\u3001\u6570\u5B57\u6216\u4E0B\u5212\u7EBF\uFF08\u603B\u957F\u4E0D\u8D85\u8FC7 ${PROJECT_ID_MAX_LENGTH}\uFF09\u3002`
+          `Project id must start with ${prefix}, followed by lowercase letters, digits or underscores (at most ${PROJECT_ID_MAX_LENGTH} in total).`
         );
       }
     }
     if (this.deps.projects.findById(projectId) !== null || await dirExists(projectDir(this.deps.root, projectId))) {
-      throw new HttpError(409, "project_exists", `Project id \u5DF2\u88AB\u5360\u7528\uFF1A${projectId}\u3002`);
+      throw new HttpError(409, "project_exists", `Project id is already taken: ${projectId}.`);
     }
     const displayName = name ?? projectId;
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -5596,7 +5821,7 @@ var ProjectService = class {
       this.deps.projects.insert({ projectId, ownerUserId: owner.userId, createdAt });
     } catch (err) {
       if (err instanceof Error && err.message.includes("UNIQUE")) {
-        throw new HttpError(409, "project_exists", `Project id \u5DF2\u88AB\u5360\u7528\uFF1A${projectId}\u3002`);
+        throw new HttpError(409, "project_exists", `Project id is already taken: ${projectId}.`);
       }
       throw err;
     }
@@ -5653,14 +5878,14 @@ var ProjectService = class {
       throw new HttpError(
         409,
         "cannot_delete_default_project",
-        "default_project \u4E0E CLI \u5171\u7528\uFF0C\u4E0D\u80FD\u4ECE Web \u5220\u9664\u3002"
+        "default_project is shared with the CLI and cannot be deleted from the web."
       );
     }
     if (this.deps.projects.listAccessible(userId).length <= 1) {
       throw new HttpError(
         409,
         "cannot_delete_last_project",
-        "\u8FD9\u662F\u5F53\u524D\u8D26\u53F7\u6700\u540E\u4E00\u4E2A Project\uFF0C\u5220\u9664\u540E\u5C06\u65E0 Project \u53EF\u7528\uFF1B\u8BF7\u5148\u521B\u5EFA\u65B0\u7684 Project\u3002"
+        "This is the account's last Project; deleting it would leave no Project available. Create a new Project first."
       );
     }
     await this.destroyProject(projectId);
@@ -5707,13 +5932,21 @@ var ProjectService = class {
     const project = this.requireProjectOwner(userId, projectId);
     const target = this.deps.users.findById(targetUserId);
     if (!target) {
-      throw new HttpError(404, "user_not_found", `\u7528\u6237\u4E0D\u5B58\u5728\uFF1A${targetUserId}\u3002`);
+      throw new HttpError(404, "user_not_found", `User does not exist: ${targetUserId}.`);
     }
     if (target.userId === project.ownerUserId) {
-      throw new HttpError(409, "already_owner", "owner \u65E0\u9700\u6388\u6743\u7ED9\u81EA\u5DF1\u3002");
+      throw new HttpError(
+        409,
+        "already_owner",
+        "The owner does not need to grant access to themselves."
+      );
     }
     if (this.deps.members.isMember(projectId, target.userId)) {
-      throw new HttpError(409, "already_member", `${targetUserId} \u5DF2\u662F\u8BE5 Project \u7684\u6210\u5458\u3002`);
+      throw new HttpError(
+        409,
+        "already_member",
+        `${targetUserId} is already a member of this Project.`
+      );
     }
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
     this.deps.members.insert({ projectId, userId: target.userId, createdAt });
@@ -5723,7 +5956,7 @@ var ProjectService = class {
   removeMember(userId, projectId, targetUserId) {
     this.requireProjectOwner(userId, projectId);
     if (!this.deps.members.isMember(projectId, targetUserId)) {
-      throw new HttpError(404, "member_not_found", `\u8BE5 Project \u6CA1\u6709\u6210\u5458\uFF1A${targetUserId}\u3002`);
+      throw new HttpError(404, "member_not_found", `This Project has no member: ${targetUserId}.`);
     }
     this.deps.members.delete(projectId, targetUserId);
   }
@@ -5749,7 +5982,7 @@ var ProjectService = class {
 };
 
 // src/services/session-service.ts
-import path12 from "path";
+import path13 from "path";
 import { readdir as readdir2 } from "fs/promises";
 import {
   createAgent as createAgent2,
@@ -5828,7 +6061,7 @@ var SessionService = class {
     };
     const dir = tracesDir2(this.deps.root, projectId, agentId);
     for (const dateDir of await listDirsSafe(dir)) {
-      for (const file of await listFilesSafe(path12.join(dir, dateDir))) {
+      for (const file of await listFilesSafe(path13.join(dir, dateDir))) {
         const match = TRACE_FILE_RE.exec(file);
         if (match) mark(dateDir, match[1]);
       }
@@ -5847,23 +6080,32 @@ var SessionService = class {
     return { sessionCount: all.size, activity };
   }
   /**
-   * Create a Session: model reference `(provider, modelId)` as a pair; defaults to
-   * the Project's default reference (400 prompting to configure a model first if
-   * there is none); when provider is omitted, core's resolveModelRef performs
-   * unique resolution (400 on zero matches / ambiguity). `workspace` is already
+   * Create a Session: the model reference is a complete `(provider, modelId)` pair.
+   * Half a reference is a client error, never something to resolve — the missing half
+   * is never guessed, since a guessed provider would send an entry's credential to a
+   * vendor nobody named. Omitting both falls back to the Project's default reference
+   * (400 prompting to configure a model first if there is none). `workspace` is already
    * validated by the route guard. The new Session is added to the active table
    * (idle).
    */
   async createSession(args) {
-    let modelId = args.modelId;
-    let provider = args.provider;
-    if (modelId === void 0) {
+    if (args.modelId === void 0 !== (args.provider === void 0)) {
+      throw badRequest(
+        "modelId and provider must be given together as a (provider, modelId) pair: specify both, or neither to use the Project's default model."
+      );
+    }
+    let modelId;
+    let provider;
+    if (args.modelId !== void 0 && args.provider !== void 0) {
+      modelId = args.modelId;
+      provider = args.provider;
+    } else {
       const def = await this.deps.projectConfig.getDefaultModelRef(args.projectId);
       if (def === void 0) {
         throw new HttpError(
           400,
           "no_default_model",
-          "\u8BE5 Project \u5C1A\u672A\u914D\u7F6E\u9ED8\u8BA4\u6A21\u578B\uFF0C\u8BF7\u5148\u5728\u300C\u6A21\u578B\u300D\u9875\u6DFB\u52A0\u6A21\u578B\u5E76\u8BBE\u4E3A\u9ED8\u8BA4\u3002"
+          "This Project has no default model yet. Add a model on the Models page and set it as the default first."
         );
       }
       modelId = def.model_id;
@@ -5878,7 +6120,7 @@ var SessionService = class {
     try {
       session = await agent.createSession({
         modelId,
-        ...provider !== void 0 ? { provider } : {},
+        provider,
         ...args.workspace !== void 0 ? { workspaceDir: args.workspace } : {}
       });
     } catch (err) {
@@ -5910,7 +6152,7 @@ var SessionService = class {
     const dir = tracesDir2(this.deps.root, projectId, agentId);
     const ids = /* @__PURE__ */ new Set();
     for (const dateDir of await listDirsSafe(dir)) {
-      for (const file of await listFilesSafe(path12.join(dir, dateDir))) {
+      for (const file of await listFilesSafe(path13.join(dir, dateDir))) {
         const match = TRACE_FILE_RE.exec(file);
         if (match) ids.add(match[1]);
       }
@@ -5922,12 +6164,12 @@ var SessionService = class {
     const dir = tracesDir2(this.deps.root, projectId, agentId);
     let earliest = null;
     for (const dateDir of await listDirsSafe(dir)) {
-      for (const file of await listFilesSafe(path12.join(dir, dateDir))) {
+      for (const file of await listFilesSafe(path13.join(dir, dateDir))) {
         const match = TRACE_FILE_RE.exec(file);
         if (!match || match[1] !== sessionId) continue;
         const index = Number(match[2]);
         if (!earliest || index < earliest.index) {
-          earliest = { path: path12.join(dir, dateDir, file), index };
+          earliest = { path: path13.join(dir, dateDir, file), index };
         }
       }
     }
@@ -5980,7 +6222,7 @@ async function listFilesSafe(dir) {
 
 // src/services/trace-service.ts
 import fs15 from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 import { agentsDir as agentsDir3, readTraceTolerant as readTraceTolerant2, tracesDir as tracesDir3 } from "@prismshadow/penguin-core";
 var TRACE_FILE_RE2 = /^(.+)_(\d{3})\.jsonl$/;
 var MAX_SUBAGENT_DEPTH = 4;
@@ -6018,10 +6260,10 @@ var TraceService = class {
     const dir = tracesDir3(this.root, projectId, agentId);
     const out = [];
     for (const dateDir of await listDirs(dir)) {
-      for (const file of await listFiles(path13.join(dir, dateDir))) {
+      for (const file of await listFiles(path14.join(dir, dateDir))) {
         const match = TRACE_FILE_RE2.exec(file);
         if (!match || match[1] !== sessionId) continue;
-        out.push({ path: path13.join(dir, dateDir, file), date: dateDir, index: Number(match[2]) });
+        out.push({ path: path14.join(dir, dateDir, file), date: dateDir, index: Number(match[2]) });
       }
     }
     return out.sort((a, b) => a.index - b.index);
@@ -6068,7 +6310,7 @@ var TraceService = class {
     for (const agentId of await listDirs(agentsDir3(this.root, projectId))) {
       const dir = tracesDir3(this.root, projectId, agentId);
       for (const dateDir of await listDirs(dir)) {
-        for (const file of await listFiles(path13.join(dir, dateDir))) {
+        for (const file of await listFiles(path14.join(dir, dateDir))) {
           const match = TRACE_FILE_RE2.exec(file);
           if (match && !index.has(match[1])) index.set(match[1], agentId);
         }
@@ -6368,11 +6610,11 @@ var TraceService = class {
     const out = { dates: [] };
     for (const date of dates) {
       const bySession = /* @__PURE__ */ new Map();
-      for (const file of await listFiles(path13.join(dir, date))) {
+      for (const file of await listFiles(path14.join(dir, date))) {
         const match = TRACE_FILE_RE2.exec(file);
         if (!match) continue;
         const sessionId = match[1];
-        const stat = await fs15.stat(path13.join(dir, date, file));
+        const stat = await fs15.stat(path14.join(dir, date, file));
         const files = bySession.get(sessionId) ?? [];
         files.push({ index: Number(match[2]), sizeBytes: stat.size });
         bySession.set(sessionId, files);
@@ -6396,7 +6638,7 @@ var TraceService = class {
       throw new HttpError(
         404,
         "trace_not_found",
-        `\u8BE5 Session \u6CA1\u6709 index \u4E3A ${index} \u7684 Trace \u6587\u4EF6\u3002`
+        `This Session has no Trace file with index ${index}.`
       );
     }
     return readTraceTolerant2(file.path);
@@ -6699,7 +6941,7 @@ function createApp(deps2) {
     });
     return handleError(err, c);
   });
-  app2.notFound((c) => c.json(errorBody("not_found", "\u63A5\u53E3\u4E0D\u5B58\u5728\u3002"), 404));
+  app2.notFound((c) => c.json(errorBody("not_found", "Endpoint does not exist."), 404));
   app2.use("*", async (c, next) => {
     const start = performance.now();
     await next();
@@ -6709,7 +6951,7 @@ function createApp(deps2) {
   app2.use("/api/*", async (c, next) => {
     const contentLength = Number(c.req.header("content-length") ?? 0);
     if (contentLength > MAX_BODY_BYTES) {
-      throw new HttpError(413, "payload_too_large", "\u8BF7\u6C42\u4F53\u8D85\u8FC7 20MB \u4E0A\u9650\u3002");
+      throw new HttpError(413, "payload_too_large", "Request body exceeds the 20MB limit.");
     }
     await next();
   });
@@ -6769,27 +7011,27 @@ function registerStaticRoutes(app2, webDist) {
   app2.get("*", async (c) => {
     const reqPath = decodeURIComponent(c.req.path);
     if (reqPath.startsWith("/api/")) {
-      return c.json(errorBody("not_found", "\u63A5\u53E3\u4E0D\u5B58\u5728\u3002"), 404);
+      return c.json(errorBody("not_found", "Endpoint does not exist."), 404);
     }
     const rel = reqPath.replace(/^\/+/, "");
-    const resolved = path14.resolve(webDist, rel === "" ? "index.html" : rel);
-    const base = path14.resolve(webDist);
-    const target = resolved === base || resolved.startsWith(base + path14.sep) ? resolved : path14.join(base, "index.html");
+    const resolved = path15.resolve(webDist, rel === "" ? "index.html" : rel);
+    const base = path15.resolve(webDist);
+    const target = resolved === base || resolved.startsWith(base + path15.sep) ? resolved : path15.join(base, "index.html");
     let file = target;
     try {
       const stat = await fsp.stat(file);
-      if (stat.isDirectory()) file = path14.join(file, "index.html");
+      if (stat.isDirectory()) file = path15.join(file, "index.html");
       await fsp.access(file);
     } catch {
-      file = path14.join(base, "index.html");
+      file = path15.join(base, "index.html");
     }
     let content;
     try {
       content = await fsp.readFile(file);
     } catch {
-      return c.json(errorBody("not_found", "\u8D44\u6E90\u4E0D\u5B58\u5728\u3002"), 404);
+      return c.json(errorBody("not_found", "Resource does not exist."), 404);
     }
-    const type = CONTENT_TYPES2[path14.extname(file).toLowerCase()] ?? "application/octet-stream";
+    const type = CONTENT_TYPES2[path15.extname(file).toLowerCase()] ?? "application/octet-stream";
     return new Response(new Uint8Array(content), {
       status: 200,
       headers: { "Content-Type": type }
@@ -6799,27 +7041,27 @@ function registerStaticRoutes(app2, webDist) {
 
 // src/config.ts
 import fs17 from "fs";
-import path15 from "path";
+import path16 from "path";
 import { fileURLToPath } from "url";
 import { resolveRoot } from "@prismshadow/penguin-core";
 var DAY_MS = 24 * 60 * 60 * 1e3;
 function defaultWebDist() {
-  const here = path15.dirname(fileURLToPath(import.meta.url));
-  const bundled = path15.resolve(here, "..", "web-dist");
+  const here = path16.dirname(fileURLToPath(import.meta.url));
+  const bundled = path16.resolve(here, "..", "web-dist");
   if (fs17.existsSync(bundled)) return bundled;
-  return path15.resolve(here, "..", "..", "web", "dist");
+  return path16.resolve(here, "..", "..", "web", "dist");
 }
 function resolveServerConfig(env = process.env) {
   const root = env.PENGUIN_HOME ?? resolveRoot();
   const port = Number(env.PORT || 7364);
   if (!Number.isInteger(port) || port < 0 || port > 65535) {
-    throw new Error(`\u975E\u6CD5\u7AEF\u53E3\u914D\u7F6E PORT=${env.PORT}`);
+    throw new Error(`Invalid port configuration PORT=${env.PORT}`);
   }
   return {
     root,
     host: env.HOST ?? "127.0.0.1",
     port,
-    dbPath: env.PENGUIN_WEB_DB ?? path15.join(root, "web.db"),
+    dbPath: env.PENGUIN_WEB_DB ?? path16.join(root, "web.db"),
     webDist: env.PENGUIN_WEB_DIST ?? defaultWebDist(),
     authSessionTtlMs: 7 * DAY_MS,
     authSessionRenewMs: 6 * DAY_MS
@@ -6834,15 +7076,15 @@ var app = createApp(deps);
 await deps.authService.seedAdmin();
 await deps.scheduler.start();
 var server = serve({ fetch: app.fetch, hostname: config.host, port: config.port }, (info) => {
-  console.log(`penguin-server \u5DF2\u542F\u52A8: http://${config.host}:${info.port}`);
-  console.log(`\u6570\u636E\u6839\u76EE\u5F55: ${config.root}`);
+  console.log(`penguin-server started: http://${config.host}:${info.port}`);
+  console.log(`Data root: ${config.root}`);
   console.log(`SQLite: ${config.dbPath}`);
 });
 var shuttingDown = false;
 async function shutdown(signal, exitCode = 0) {
   if (shuttingDown) return;
   shuttingDown = true;
-  console.log(`\u6536\u5230 ${signal}\uFF0C\u6B63\u5728\u5173\u505C\u2026`);
+  console.log(`Received ${signal}, shutting down\u2026`);
   deps.scheduler.stop();
   await deps.manager.shutdown(5e3);
   deps.channels.dispose();
@@ -6855,13 +7097,13 @@ async function shutdown(signal, exitCode = 0) {
 process.on("SIGINT", () => void shutdown("SIGINT"));
 process.on("SIGTERM", () => void shutdown("SIGTERM"));
 process.on("uncaughtException", (err) => {
-  console.error(`[server] \u672A\u6355\u83B7\u5F02\u5E38: ${err.stack ?? err.message}`);
+  console.error(`[server] Uncaught exception: ${err.stack ?? err.message}`);
   deps.errors.record({ source: "process", err, code: "uncaught_exception" });
   void shutdown("uncaughtException", 1).catch(() => process.exit(1));
 });
 process.on("unhandledRejection", (reason) => {
   const err = reason instanceof Error ? reason : new Error(String(reason));
-  console.error(`[server] \u672A\u5904\u7406\u7684 Promise \u62D2\u7EDD: ${err.stack ?? err.message}`);
+  console.error(`[server] Unhandled promise rejection: ${err.stack ?? err.message}`);
   deps.errors.record({ source: "process", err, code: "unhandled_rejection" });
 });
 //# sourceMappingURL=index.js.map