agent-loft 0.2.31 → 0.2.33

package/src/channels/web/api.ts

@@ -61,8 +61,10 @@ import {
   takeAttempt,
 } from "./auth.js";
 import { canSeeConv, pushOwnedBy, sessionVisibleTo } from "./access.js";
+import { clampLimit, dirsOf, inDir, inRecent, pageOf, parseCursor } from "./conv-pages.js";
 import { clientIp, cookies, HttpError, isHttps, readBody, readJsonBody, SECURITY_HEADERS, sendJson } from "./http.js";
 import { handleTasksApi } from "./tasks-api.js";
+import { handleSkillsApi } from "./skills-api.js";
 import { addSubscription, listSubscriptions, pushToAll, removeSubscription, removeSubscriptionsOf, vapidPublicKey } from "./push.js";
 
 export const COOKIE = "aim_session";
@@ -468,6 +470,45 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
 
   // ----- 总览 -----
   if (p === "/api/bootstrap" && method === "GET") {
+    // 会话只给侧栏第一屏要的（见 conv-pages.ts）：「最近」的前 recent 棵树、展开着的目录各自的前几棵，
+    // 每个飞书机器人最近的一条，再加上正在跑的、等你处理的（侧栏要显示状态）。其余点「展开显示」再拉
+    const all = hub.list(visible).filter((c) => !c.hidden);
+    const pending = interactions.listPending().filter((i) => visible(getConversation(i.convKey)));
+    const recent = pageOf(all.filter(inRecent), null, clampLimit(url.searchParams.get("recent"), 10));
+    let open: [string, number][] = [];
+    try {
+      const raw: unknown = JSON.parse(url.searchParams.get("open") ?? "[]");
+      if (Array.isArray(raw)) {
+        open = raw
+          .slice(0, 50)
+          .filter((x): x is [string, unknown] => Array.isArray(x) && typeof x[0] === "string")
+          .map(([dir, n]) => [dir, clampLimit(n, 5)]);
+      }
+    } catch {
+      // 参数坏了就当没有展开的目录
+    }
+    const dirPages = new Map(open.map(([dir, n]) => [dir, pageOf(all.filter(inDir(dir)), null, n)]));
+    const byKey = new Map(all.map((c) => [c.key, c]));
+    const keep = new Map(recent.conversations.map((c) => [c.key, c]));
+    for (const page of dirPages.values()) for (const c of page.conversations) keep.set(c.key, c);
+    const asking = new Set(pending.map((i) => i.convKey));
+    const bots = new Set<string>();
+    for (const c of all) {
+      // all 已按活跃时间从新到旧：每个机器人遇到的第一条就是它最近的
+      if (c.channel === "feishu" && !bots.has(c.channelId)) {
+        bots.add(c.channelId);
+        keep.set(c.key, c);
+      }
+      if (c.busy || asking.has(c.key)) keep.set(c.key, c);
+    }
+    // 正开着的会话（可能是后面几页里的，重连时页面上还显示着它）
+    const current = byKey.get(url.searchParams.get("current") ?? "");
+    if (current) keep.set(current.key, current);
+    // 分叉来源：提示里要写它的标题
+    for (const c of [...keep.values()]) {
+      const parent = c.forkOf ? byKey.get(c.forkOf) : undefined;
+      if (parent) keep.set(parent.key, parent);
+    }
     sendJson(res, 200, {
       agents: [...AGENT_IDS].map((id) => {
         const d = hub.driver(id);
@@ -487,8 +528,13 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
       workspaceRoot: config().workspaceRoot,
       quotaRefreshMin: config().web.quotaRefreshMin,
       quotaEnabled: config().web.quotaEnabled,
-      conversations: hub.list(visible),
-      pending: interactions.listPending().filter((i) => visible(getConversation(i.convKey))),
+      conversations: [...keep.values()],
+      sidebar: {
+        recent: { next: recent.next },
+        // 展开着的目录带上翻页游标（没带 next 的目录前端还没拉过）
+        dirs: dirsOf(all).map((d) => (dirPages.has(d.dir) ? { ...d, next: dirPages.get(d.dir)!.next } : d)),
+      },
+      pending,
       user: publicMe(user),
       serverTime: Date.now(),
     });
@@ -527,6 +573,7 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
 
   // ----- 定时任务 -----
   if (p.startsWith("/api/tasks") && (await handleTasksApi(req, res, p, user))) return;
+  if (p.startsWith("/api/skills") && (await handleSkillsApi(req, res, url, user))) return;
 
   // ----- 目录选择器：列工作区内的子目录 -----
   if (p === "/api/dirs" && method === "GET") {
@@ -537,6 +584,21 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
   }
 
   // ----- 会话 -----
+  // 侧栏按页拉：scope=recent（最近）/ dir（某个项目目录）按树分页；bot（某个飞书机器人的全部聊天）平铺
+  if (p === "/api/conversations/page" && method === "GET") {
+    const all = hub.list(visible).filter((c) => !c.hidden);
+    const scope = url.searchParams.get("scope");
+    if (scope === "bot") {
+      const bot = url.searchParams.get("bot") ?? "";
+      sendJson(res, 200, { conversations: all.filter((c) => c.channel === "feishu" && c.channelId === bot).slice(0, 200), next: null });
+      return;
+    }
+    if (scope !== "recent" && scope !== "dir") throw new HttpError(400, "scope 只能是 recent / dir / bot");
+    const list = scope === "recent" ? all.filter(inRecent) : all.filter(inDir(url.searchParams.get("dir") ?? ""));
+    const before = parseCursor(url.searchParams.get("at"), url.searchParams.get("key"));
+    sendJson(res, 200, pageOf(list, before, clampLimit(url.searchParams.get("limit"), 10)));
+    return;
+  }
   if (p === "/api/conversations" && method === "GET") {
     sendJson(res, 200, hub.list(visible));
     return;
@@ -651,6 +713,8 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
         info: hub.info(key),
         messages,
         live,
+        // 进行中这一轮弹过的卡（已经处理了的也要）：重放到 ix 事件时放回原位
+        interactions: live.flatMap((e) => (e.ev.type === "ix" ? [interactions.get(e.ev.id)].filter((i) => !!i) : [])),
         seq,
         pending: interactions.listPending(key),
         allowedAgents: allowedAgentsFor(key),
@@ -736,6 +800,10 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
         case "stop":
           text = await hub.stop(key);
           break;
+        // 打断并发送：value 是排队中那条消息的编号
+        case "jump":
+          text = await hub.jump(key, value);
+          break;
         case "cd":
           text = await hub.cd(key, value);
           break;
@@ -844,6 +912,8 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
         allowedAgents: hub.enabledAgents().map((d) => d.id),
         // 带 key 是输入框补全：只列 Web 能用的；不带是设置页排序，全列
         ...(conv ? { channel: "web" } : {}),
+        // 成员看不到机器上装的技能
+        ...(admin ? {} : { member: true }),
       });
       sendJson(res, 200, { commands });
       return;

package/src/channels/web/conv-pages.ts

@@ -0,0 +1,68 @@
+// 侧栏会话列表分页：打开页面只拿第一页，点「展开显示」再按页拉。
+//
+// 一页按「树」算：主对话连同从它分叉出来的对话算一条（和前端 sidebar.js 的 forkForest 一样），
+// 按整棵树里最近的活跃时间从新到旧排。翻页用游标（上一页最后一棵树的活跃时间 + 根的 key），
+// 期间有会话变活跃、被删，也不会漏掉或重复一页的边界。
+import type { ConversationInfo } from "../../core/hub.js";
+
+export type Cursor = { at: number; key: string };
+export type Page = { conversations: ConversationInfo[]; next: Cursor | null };
+type Tree = { root: ConversationInfo; convs: ConversationInfo[]; at: number };
+
+/** 最近：飞书以外的会话（飞书按机器人各占一行，另外给） */
+export const inRecent = (c: ConversationInfo): boolean => c.channel !== "feishu";
+/** 项目：Web 会话按工作目录分组 */
+export const inDir = (dir: string) => (c: ConversationInfo): boolean => c.channel === "web" && c.cwd === dir;
+
+/** 按分叉关系成树：父对话也在这一组里的挂到下面，其余的是根。父链绕回自己（数据坏了）就当根 */
+export function forkTrees(list: ConversationInfo[]): Tree[] {
+  const byKey = new Map(list.map((c) => [c.key, c]));
+  const rootOf = (c: ConversationInfo): ConversationInfo => {
+    let cur = c;
+    for (let n = 0; n < 50; n++) {
+      const parent = cur.forkOf ? byKey.get(cur.forkOf) : undefined;
+      if (!parent || parent.key === c.key) return cur;
+      cur = parent;
+    }
+    return c;
+  };
+  const trees = new Map<string, Tree>();
+  for (const c of list) {
+    const root = rootOf(c);
+    let t = trees.get(root.key);
+    if (!t) trees.set(root.key, (t = { root, convs: [], at: 0 }));
+    t.convs.push(c);
+    t.at = Math.max(t.at, c.activeAt);
+  }
+  return [...trees.values()].sort((a, b) => b.at - a.at || (a.root.key < b.root.key ? 1 : -1));
+}
+
+/** 游标之后的 limit 棵树 */
+export function pageOf(list: ConversationInfo[], before: Cursor | null, limit: number): Page {
+  const trees = forkTrees(list);
+  const start = before ? trees.findIndex((t) => t.at < before.at || (t.at === before.at && t.root.key < before.key)) : 0;
+  if (start < 0) return { conversations: [], next: null };
+  const slice = trees.slice(start, start + limit);
+  const last = slice[slice.length - 1];
+  return {
+    conversations: slice.flatMap((t) => t.convs),
+    next: last && start + limit < trees.length ? { at: last.at, key: last.root.key } : null,
+  };
+}
+
+/** 项目目录：每个目录最近的活跃时间（目录行本身要全部显示，会话再按需拉） */
+export function dirsOf(list: ConversationInfo[]): { dir: string; at: number }[] {
+  const at = new Map<string, number>();
+  for (const c of list) if (c.channel === "web") at.set(c.cwd, Math.max(at.get(c.cwd) ?? 0, c.activeAt));
+  return [...at].map(([dir, t]) => ({ dir, at: t })).sort((a, b) => b.at - a.at);
+}
+
+export function parseCursor(at: string | null, key: string | null): Cursor | null {
+  const n = Number(at);
+  return key && Number.isFinite(n) ? { at: n, key } : null;
+}
+
+export const clampLimit = (v: unknown, def: number): number => {
+  const n = Math.floor(Number(v));
+  return Number.isFinite(n) && n > 0 ? Math.min(n, 200) : def;
+};

package/src/channels/web/http.ts

@@ -89,8 +89,8 @@ export async function readBody(req: IncomingMessage, limit: number): Promise<Buf
   return Buffer.concat(chunks);
 }
 
-export async function readJsonBody<T = Record<string, unknown>>(req: IncomingMessage): Promise<T> {
-  const raw = await readBody(req, 1024 * 1024);
+export async function readJsonBody<T = Record<string, unknown>>(req: IncomingMessage, limit = 1024 * 1024): Promise<T> {
+  const raw = await readBody(req, limit);
   if (raw.length === 0) return {} as T;
   try {
     return JSON.parse(raw.toString("utf8")) as T;

package/src/channels/web/server.ts

@@ -14,6 +14,7 @@ import { GLOBAL_ALWAYS_DENIED, hub, type EventEnvelope } from "../../core/hub.js
 import { interactions, type Interaction } from "../../core/interactions.js";
 import { getConversation } from "../../core/store.js";
 import { taskEvents } from "../../core/tasks.js";
+import { skillEvents } from "../../core/skills.js";
 import { RUNNING_VERSION } from "../../core/upgrade.js";
 import type { Settlement } from "../../core/types.js";
 import { getUser, isAdmin, legacyOwnerId, type User } from "../../core/users.js";
@@ -142,6 +143,8 @@ type Client = {
   /** 页面在前台，且正看着哪条会话（前端在切会话、切前后台时上报） */
   visible: boolean;
   viewing: string | null;
+  /** 最后一次收到这个页面的消息（含 ping） */
+  seen: number;
 };
 
 /** 每次进程启动换一个：客户端发现变了，就知道 seq 已经从头计数，得整页重拉 */
@@ -186,11 +189,22 @@ function broadcastTasks(owner: string): void {
   for (const client of clients) if (client.user.id === owner) send(client, { t: "tasks" });
 }
 
+/** 技能变了：以前装过别人技能的人也受影响，通知所有人重新拉（列表很小） */
+function broadcastSkills(): void {
+  for (const client of clients) send(client, { t: "skills" });
+}
+
 // ---------- 系统通知（Web Push） ----------
 
-/** 有页面正在前台看着这条会话：人就在眼前，不用推 */
+/**
+ * 有页面正在前台看着这条会话：人就在眼前，不用推。
+ * 页面每 25 秒发一次 ping；40 秒没收到它的任何消息就不算（手机切走后网络断了，连接还没被心跳清掉，
+ * 最后报的还是「在看」）
+ */
+const SEEN_MS = 40_000;
 function watching(key: string): boolean {
-  for (const client of clients) if (client.visible && client.viewing === key) return true;
+  const now = Date.now();
+  for (const client of clients) if (client.visible && client.viewing === key && now - client.seen < SEEN_MS) return true;
   return false;
 }
 
@@ -269,6 +283,7 @@ function handleClientMessage(client: Client, raw: string): void {
   // 每条消息都复查登录态：握手时有效不代表现在还有效（改了密码、被踢了）
   const user = checkClient(client);
   if (!user) return;
+  client.seen = Date.now();
   let msg: Record<string, unknown>;
   try {
     const parsed: unknown = JSON.parse(raw);
@@ -442,7 +457,7 @@ export async function startWeb(): Promise<void> {
       }
       const token = cookies(req)[COOKIE] ?? "";
       wss!.handleUpgrade(req, socket, head, (ws) => {
-        const client: Client = { ws, subs: new Set(), alive: true, token, user, visible: false, viewing: null };
+        const client: Client = { ws, subs: new Set(), alive: true, token, user, visible: false, viewing: null, seen: Date.now() };
         clients.add(client);
         ws.on("pong", () => (client.alive = true));
         ws.on("message", (data) => {
@@ -485,6 +500,7 @@ export async function startWeb(): Promise<void> {
   interactions.on("updated", broadcastInteraction);
   interactions.on("settled", broadcastInteraction);
   taskEvents.on("changed", broadcastTasks);
+  skillEvents.on("changed", broadcastSkills);
 
   await listen(server, host, port);
   console.log(`[web] 已监听 http://${host}:${port}`);
@@ -515,6 +531,7 @@ export async function stopWeb(): Promise<void> {
   interactions.off("updated", broadcastInteraction);
   interactions.off("settled", broadcastInteraction);
   taskEvents.off("changed", broadcastTasks);
+  skillEvents.off("changed", broadcastSkills);
   if (heartbeat) clearInterval(heartbeat);
   for (const client of clients) client.ws.close(1001, "服务重启");
   clients.clear();

package/src/channels/web/skills-api.ts

@@ -0,0 +1,225 @@
+// 技能页面的接口：/api/skills。看得到的技能（自己的、公开的、指名给自己的）、安装 / 停用、变量、上传。
+// 只有作者能改；管理员能删别人公开或分享出来的（下架），但看不到、删不了别人私有的。
+import fs from "node:fs";
+import path from "node:path";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { machineSkills, mentionTargets } from "../../core/skill-runtime.js";
+import {
+  canDelete,
+  canSee,
+  createSkill,
+  declaredHosts,
+  deleteSkill,
+  getSkill,
+  installCount,
+  installSkill,
+  listAllSkills,
+  listFiles,
+  parseSkillMd,
+  prepareUpload,
+  readSkillFile,
+  readSkillMd,
+  setSkillEnabled,
+  setSkillVars,
+  SKILL_LIMITS,
+  updateSkill,
+  userPrefs,
+  type Skill,
+  type SkillInput,
+} from "../../core/skills.js";
+import { readZip } from "../../core/zip.js";
+import { getUser, isAdmin, listUsers, type User } from "../../core/users.js";
+import { HttpError, readJsonBody, sendJson } from "./http.js";
+
+function view(s: Skill, user: User) {
+  const prefs = userPrefs(user.id);
+  const mine = s.owner === user.id;
+  return {
+    id: s.id,
+    name: s.name,
+    description: s.description,
+    owner: s.owner,
+    ownerName: getUser(s.owner)?.name ?? "（已删除的用户）",
+    mine,
+    visibility: s.visibility,
+    // 分享给了谁只有作者看得到
+    ...(mine ? { sharedWith: s.sharedWith, installs: installCount(s.id) } : {}),
+    vars: s.vars,
+    source: s.source,
+    createdAt: s.createdAt,
+    updatedAt: s.updatedAt,
+    installed: mine || prefs.installed.includes(s.id),
+    enabled: !prefs.disabled.includes(s.id),
+    canDelete: canDelete({ id: user.id, role: user.role }, s),
+  };
+}
+
+/**
+ * 变量：值按名字存；密钥（任何一个看得到的技能把它标成密钥）不回显，只说填没填。
+ * 受保护的密钥再带上确认过的地址（hosts），作者后来加了没确认过的地址就列在 pending 里。
+ */
+function varsView(user: User, skills: Skill[]) {
+  const secret = new Set(skills.flatMap((s) => s.vars.filter((v) => v.secret).map((v) => v.name)));
+  const prefs = userPrefs(user.id);
+  const mineOrInstalled = skills.filter((s) => s.owner === user.id || prefs.installed.includes(s.id));
+  return Object.fromEntries(
+    Object.entries(prefs.vars).map(([k, v]) => {
+      const declared = declaredHosts(mineOrInstalled, k);
+      const approved = prefs.approved[k] ?? [];
+      const pending = declared.filter((h) => !approved.includes(h));
+      return [
+        k,
+        {
+          set: true,
+          ...(secret.has(k) ? {} : { value: v }),
+          ...(declared.length ? { hosts: approved } : {}),
+          ...(pending.length ? { pending } : {}),
+        },
+      ];
+    }),
+  );
+}
+
+type UploadBody = { zip?: string; files?: { path?: string; data?: string }[] };
+
+/** 上传：zip（.zip / .skill）或者一堆文件（选文件夹 / 单个 SKILL.md），内容都是 base64 */
+function uploadOf(raw: UploadBody | undefined): ReturnType<typeof prepareUpload> | undefined {
+  if (!raw) return undefined;
+  if (typeof raw.zip === "string") {
+    const entries = readZip(Buffer.from(raw.zip, "base64"), SKILL_LIMITS.totalBytes * 2, SKILL_LIMITS.files * 2);
+    return prepareUpload(entries);
+  }
+  if (Array.isArray(raw.files)) {
+    if (raw.files.length > SKILL_LIMITS.files * 2) throw new Error(`文件太多（最多 ${SKILL_LIMITS.files} 个）`);
+    return prepareUpload(raw.files.map((f) => ({ path: String(f.path ?? ""), data: Buffer.from(String(f.data ?? ""), "base64") })));
+  }
+  throw new Error("上传的内容不对");
+}
+
+const bad = (err: unknown) => (err instanceof HttpError ? err : new HttpError(400, err instanceof Error ? err.message : String(err)));
+
+/** 处理了就返回 true */
+export async function handleSkillsApi(req: IncomingMessage, res: ServerResponse, url: URL, user: User): Promise<boolean> {
+  const method = req.method ?? "GET";
+  const p = url.pathname;
+  const viewer = { id: user.id, role: user.role };
+
+  if (p === "/api/skills" && method === "GET") {
+    const visible = listAllSkills().filter((s) => canSee(viewer, s));
+    sendJson(res, 200, {
+      skills: visible.map((s) => view(s, user)),
+      vars: varsView(user, visible),
+      // 分享给谁：列出其他还能登录的用户
+      users: listUsers()
+        .filter((u) => !u.disabled && u.id !== user.id)
+        .map((u) => ({ id: u.id, name: u.name })),
+      ...(isAdmin(user) ? { machine: machineSkills().map((m) => ({ name: m.name, description: m.description, dir: m.dir, agents: m.agents })) } : {}),
+      limits: SKILL_LIMITS,
+    });
+    return true;
+  }
+
+  // 输入框 @ 的补全：自己能用的（管理员加上机器上原有的）
+  if (p === "/api/skills/mention" && method === "GET") {
+    sendJson(res, 200, { skills: mentionTargets(user.id).map((t) => ({ name: t.name, description: t.description, kind: t.kind })) });
+    return true;
+  }
+
+  // 管理员看机器上原有技能的 SKILL.md
+  if (p === "/api/skills/machine" && method === "GET") {
+    if (!isAdmin(user)) throw new HttpError(403, "只有管理员能看机器上的技能");
+    const m = machineSkills().find((x) => x.name === url.searchParams.get("name"));
+    if (!m) throw new HttpError(404, "没有这个技能");
+    let md = "";
+    try {
+      md = fs.readFileSync(path.join(m.dir, "SKILL.md"), "utf8");
+    } catch {
+      md = "（读不到 SKILL.md）";
+    }
+    sendJson(res, 200, { ...m, skillMd: md });
+    return true;
+  }
+
+  if (p === "/api/skills/vars" && method === "PUT") {
+    const body = await readJsonBody<{ values?: Record<string, unknown>; approve?: unknown }>(req);
+    try {
+      setSkillVars(user.id, body.values ?? {}, Array.isArray(body.approve) ? body.approve.map(String) : []);
+    } catch (err) {
+      throw bad(err);
+    }
+    sendJson(res, 200, { vars: varsView(user, listAllSkills().filter((s) => canSee(viewer, s))) });
+    return true;
+  }
+
+  if (p === "/api/skills" && method === "POST") {
+    const body = await readJsonBody<SkillInput & { upload?: UploadBody }>(req, 16 * 1024 * 1024);
+    let skill: Skill;
+    try {
+      const upload = uploadOf(body.upload);
+      const { upload: _u, ...input } = body;
+      skill = createSkill(user.id, input, upload ? "upload" : "manual", upload);
+    } catch (err) {
+      throw bad(err);
+    }
+    sendJson(res, 200, view(skill, user));
+    return true;
+  }
+
+  const m = /^\/api\/skills\/(s_[a-f0-9]+)(?:\/(install|enable|file))?$/.exec(p);
+  if (!m) return false;
+  const skill = getSkill(m[1]!);
+  if (!skill || !canSee(viewer, skill)) throw new HttpError(404, "这个技能不存在");
+
+  if (!m[2] && method === "GET") {
+    const md = parseSkillMd(readSkillMd(skill.id));
+    sendJson(res, 200, { ...view(skill, user), body: md.body, extra: md.extra, files: listFiles(skill.id) });
+    return true;
+  }
+  if (m[2] === "file" && method === "GET") {
+    const data = readSkillFile(skill.id, url.searchParams.get("path") ?? "");
+    if (!data) throw new HttpError(404, "没有这个文件");
+    // 只当文本看：二进制的给个提示
+    const text = data.includes(0) ? null : data.toString("utf8");
+    sendJson(res, 200, { text, size: data.length });
+    return true;
+  }
+  if (m[2] === "install" && method === "POST") {
+    const body = await readJsonBody<{ on?: boolean }>(req);
+    try {
+      installSkill(user.id, skill.id, body.on !== false);
+    } catch (err) {
+      throw bad(err);
+    }
+    sendJson(res, 200, view(skill, user));
+    return true;
+  }
+  if (m[2] === "enable" && method === "POST") {
+    const body = await readJsonBody<{ on?: boolean }>(req);
+    setSkillEnabled(user.id, skill.id, body.on !== false);
+    sendJson(res, 200, view(skill, user));
+    return true;
+  }
+  if (!m[2] && method === "PATCH") {
+    const body = await readJsonBody<SkillInput & { upload?: UploadBody }>(req, 16 * 1024 * 1024);
+    let updated: Skill;
+    try {
+      const upload = uploadOf(body.upload);
+      const { upload: _u, name: _n, ...input } = body;
+      updated = updateSkill(user.id, skill.id, input, upload ? { upload } : {});
+    } catch (err) {
+      throw bad(err);
+    }
+    sendJson(res, 200, view(updated, user));
+    return true;
+  }
+  if (!m[2] && method === "DELETE") {
+    try {
+      deleteSkill(viewer, skill.id);
+    } catch (err) {
+      throw bad(err);
+    }
+    sendJson(res, 200, { ok: true });
+    return true;
+  }
+  return false;
+}

package/src/core/chat-mode.ts

@@ -36,13 +36,13 @@ export function chatSystemPrompt(search: string, memory?: string): string {
 const OPEN = "<agent-loft-context>";
 const CLOSE = "</agent-loft-context>";
 
-/** Codex：附在会话进程第一条消息后面的背景（模式 + 记忆） */
-export function contextBlock(mode: "chat" | "work", memory: string | undefined, search: string): string {
+/** Codex：附在会话进程第一条消息后面的背景（模式 + 记忆 + 工作模式下的技能清单） */
+export function contextBlock(mode: "chat" | "work", memory: string | undefined, search: string, skills: string[] = []): string {
   const head =
     mode === "chat"
       ? ["当前是「聊天模式」，你作为用户的私人 AI 助手和他聊天：", ...chatRules(search)]
       : ["当前是「工作模式」：可以执行命令、读写文件，按平常的方式干活。之前如果说过「聊天模式下不能做」，那个限制已经解除。"];
-  return wrapContext([...head, ...(memory ? ["", memory] : [])]);
+  return wrapContext([...head, ...(memory ? ["", memory] : []), ...(mode === "work" && skills.length ? ["", ...skills] : [])]);
 }
 
 /** 包成 agent-loft 附上的背景：用户看不到（读历史、实时显示时都剥掉），agent 照着做 */

package/src/core/command-catalog.ts

@@ -24,6 +24,7 @@ export const BUILTIN_COMMANDS: BuiltinSpec[] = [
   { name: "effort", args: "[程度]", description: "切换思考程度" },
   { name: "chat", description: "切到聊天模式：精简、只能联网搜索，每轮开销小很多" },
   { name: "work", description: "切到工作模式：agent 原装的全部能力" },
+  { name: "skills", description: "列出能用的技能（消息里写 @名字 点名使用）" },
   { name: "status", description: "查看当前会话、模型、目录、剩余额度" },
   { name: "sessions", args: "[all]", description: "列出历史会话，点按钮恢复；加 all 列所有目录" },
   { name: "resume", args: "<会话ID>", description: "恢复指定会话" },
@@ -42,7 +43,13 @@ export const BUILTIN_COMMANDS: BuiltinSpec[] = [
 ];
 
 /** agent 自己报上来的命令 */
-export type AgentCommand = { name: string; description: string; args?: string };
+export type AgentCommand = {
+  name: string;
+  description: string;
+  args?: string;
+  /** agent 自己带的（Claude Code 的 /compact、自带的技能），不是机器上另外装的 */
+  builtin?: boolean;
+};
 
 /**
  * 用户自定义命令。prompt 里的 $ARGUMENTS 换成命令后面跟的参数；

package/src/core/commands.ts

@@ -20,6 +20,7 @@ export type ParsedCommand =
   | { kind: "autoedit"; on?: boolean }
   | { kind: "mode"; mode: "chat" | "work" }
   | { kind: "help" }
+  | { kind: "skills" }
   /** 只发了一个「/」：列出可用命令 */
   | { kind: "commands" }
   | { kind: "approve"; requestId: string; decision: ApprovalDecision }
@@ -75,6 +76,8 @@ export function parseCommand(raw: string): ParsedCommand {
       return arg ? { kind: "chat", text } : { kind: "mode", mode: head.toLowerCase() as "chat" | "work" };
     case "help":
       return { kind: "help" };
+    case "skills":
+      return arg ? { kind: "chat", text } : { kind: "skills" };
     case "approve": {
       const [requestId, decision] = rest;
       if (!requestId || !decision) return { kind: "chat", text };