From b6a83ed00e7e04dc92f14dccc674a48218eb2ad6 Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Sun, 25 Oct 2026 21:53:24 +0800
Subject: [PATCH 01/19] Show the Feishu process as one timeline under a colored
 header
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The card had lost its colored status header, and its process was split
into separate thinking, commentary and tool-call sections, so following
what the Agent did meant opening three panels. Cards again carry a colored
header, and the process is one chronological timeline: commentary as plain
text, thinking folded behind its first sentence, and each tool call showing
what ran with its duration, failure or 进行中 while its result folds away.
A running card shows the latest four steps and folds the earlier ones; a
finished card puts the answer first and folds the whole process; a failed
card shows the failed step under its cause. The oldest steps leave the card
first to stay within Feishu's size limit.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/README.md             |   2 +-
 example/parsar/README.zh.md          |   4 +-
 example/parsar/server/feishu.mjs     | 134 ++++++++++++++++++---------
 example/parsar/tests/feishu.test.mjs | 116 ++++++++++++-----------
 4 files changed, 158 insertions(+), 98 deletions(-)

diff --git a/example/parsar/README.md b/example/parsar/README.md
index b9a1623ae..e2d6d2c87 100644
--- a/example/parsar/README.md
+++ b/example/parsar/README.md
@@ -123,7 +123,7 @@ Optional business questions use the declared `ask_user` function. They appear in
 4. Text, rich posts, images, files, audio and video, quoted messages and merged forwards are normalized before dispatch. Attachment limits are eight resources and 5 MiB total. Follow-up files wait until the conversation is idle. Quoted messages are read up to four levels; earlier group messages are not read.
 5. `/cancel`, `/answer <call_id> <text>`, `/new` and `/help` work in the same thread. A plain reply answers a single pending business question. Cancellation takes priority over queued follow-ups and recovers an uncertain creation before cancelling it.
 
-Accepted messages are committed to SQLite before the WebSocket ACK; request IDs and frozen payloads survive retries and restarts. The worker edits one compact progress card in place, includes any pending business question in that card, and finishes it with the result. Each reply shows only the current exchange, including answers that resume the same Core Turn. The answer stays visible; while awaiting a business decision, the question takes priority and its supporting context is collapsed, except QR authorization instructions. Available reasoning summaries, progress commentary and tool calls use separate collapsed sections. Tool calls pair with their results and show parameters, output, duration and failure details. The card previews the latest six calls with explicitly marked, byte-bounded excerpts; it counts each call once and does not count failed or incomplete calls as completed. Progress uses five-second polling. Complete history and Artifacts remain in the Web conversation. Settled threads stop polling after five minutes and wake on new messages. **消息记录** lists the latest 100 deliveries plus unresolved ones; **重试** keeps the original identity. A failed inbound message blocks later messages in that thread. Uncertain outbound sends are not replayed beyond 55 minutes. Disabling a bot pauses delivery without cancelling Core work.
+Accepted messages are committed to SQLite before the WebSocket ACK; request IDs and frozen payloads survive retries and restarts. The worker edits one compact progress card in place, includes any pending business question in that card, and finishes it with the result. Each reply shows only the current exchange, including answers that resume the same Core Turn. The answer stays visible; while awaiting a business decision, the question takes priority and its supporting context is collapsed, except QR authorization instructions. The card has a colored header for its status. Its process is one timeline in the order things happened: commentary appears as plain text, thinking folds behind its first sentence, and each tool call shows what ran with its duration, failure or 进行中 while its result (parameters, output, error, exit code) folds away. A running card shows the latest four steps and folds the earlier ones; a finished card puts the answer first and folds the whole process into **处理过程**; a failed card shows the failed step right under its cause. Long content is cut to marked, byte-bounded excerpts, and the oldest steps leave the card first to stay within Feishu's card size limit. Progress uses five-second polling. Complete history and Artifacts remain in the Web conversation. Settled threads stop polling after five minutes and wake on new messages. **消息记录** lists the latest 100 deliveries plus unresolved ones; **重试** keeps the original identity. A failed inbound message blocks later messages in that thread. Uncertain outbound sends are not replayed beyond 55 minutes. Disabling a bot pauses delivery without cancelling Core work.
 
 ### Bot identity
 
diff --git a/example/parsar/README.zh.md b/example/parsar/README.zh.md
index 8c7a64046..e568b32f5 100644
--- a/example/parsar/README.zh.md
+++ b/example/parsar/README.zh.md
@@ -1,6 +1,6 @@
 ---
 source: example/parsar/README.md
-source_hash: 012de696eb00f1550dfa2651d517821f7831e01ad3e6039b5038555a68ef75b7
+source_hash: f400d9bd09523a6bf3a0c5c1a860562bf2d97a98712c1bb11c50be3f46ca0076
 ---
 
 # Parsar 工作空间
@@ -128,7 +128,7 @@ Parsar 会跟踪每一轮正在执行的对话，网页和飞书都一样。出
 4. 文本、富文本、图片、文件、音视频、引用消息和合并转发会在投递前规范化。附件上限为 8 个、合计 5 MiB。后续消息中的文件会等到对话空闲后写入。引用消息最多读取四层；不读取更早的群消息。
 5. `/cancel`、`/answer <call_id> <回答>`、`/new` 和 `/help` 在同一话题中使用。只有一个待回答的业务问题时，直接回复即可作答。取消优先于排队中的追问，并会先确认不确定的创建再取消。
 
-收到的消息在 WebSocket ACK 之前写入 SQLite；请求 ID 和冻结的负载在重试与重启后保持不变。工作器原地更新一张简洁进度卡片，将待回答的问题合并到卡片中，结束后改成结果。每次回复只展示当前交流的内容，包括回答提问后继续同一 Core Turn 的情况。正文突出当前回复；等待业务选择时优先展示问题，将补充说明折叠，二维码授权说明保持可见。已有的思考摘要、过程说明和工具调用分别默认折叠。工具调用与返回结果合并，展开可查看参数、输出、耗时和失败详情。卡片预览最近六次调用，长内容按字节限制截取并明确标注；一次调用只计数一次，失败或未完成不算完成。进度每五秒轮询一次。完整历史和 Artifacts 保留在网页对话中。已结束的话题在五分钟后停止轮询，收到新消息时恢复。**消息记录** 列出最近 100 条投递以及未解决的记录；**重试** 保留原有标识。入站消息失败会阻塞该话题后续消息。不确定的出站消息超过 55 分钟后不再重放。停用机器人会暂停投递，但不会取消 Core 中的执行。
+收到的消息在 WebSocket ACK 之前写入 SQLite；请求 ID 和冻结的负载在重试与重启后保持不变。工作器原地更新一张简洁进度卡片，将待回答的问题合并到卡片中，结束后改成结果。每次回复只展示当前交流的内容，包括回答提问后继续同一 Core Turn 的情况。正文突出当前回复；等待业务选择时优先展示问题，将补充说明折叠，二维码授权说明保持可见。卡片顶部是带颜色的状态标题栏。处理过程按发生顺序排成一条时间线：说明直接显示文字；思考折叠在第一句后面；每次工具调用直接显示运行了什么，以及用时、失败或“进行中”，返回结果（参数、输出、错误、退出码）折叠起来。执行中的卡片显示最近四步，更早的步骤折叠；完成后回复放在最前面，整个过程折叠成 **处理过程**；失败时出错的那一步紧跟在失败原因下面。长内容按字节限制截取并明确标注；为了不超过飞书卡片的大小限制，最早的步骤会先移出卡片。进度每五秒轮询一次。完整历史和 Artifacts 保留在网页对话中。已结束的话题在五分钟后停止轮询，收到新消息时恢复。**消息记录** 列出最近 100 条投递以及未解决的记录；**重试** 保留原有标识。入站消息失败会阻塞该话题后续消息。不确定的出站消息超过 55 分钟后不再重放。停用机器人会暂停投递，但不会取消 Core 中的执行。
 
 ### 机器人身份 {#bot-identity}
 
diff --git a/example/parsar/server/feishu.mjs b/example/parsar/server/feishu.mjs
index fd709ee22..4024f624d 100644
--- a/example/parsar/server/feishu.mjs
+++ b/example/parsar/server/feishu.mjs
@@ -199,9 +199,9 @@ function panel({ title, content, elements }) {
     vertical_spacing: "8px",
     padding: "0px 0px 8px 0px",
     header: {
-      title: { tag: "markdown", content: grey(title) },
+      title: { tag: "markdown", content: title },
       width: "fill",
-      padding: "8px 0px 8px 0px",
+      padding: "6px 0px 6px 0px",
       icon: { tag: "standard_icon", token: "down-small-ccm_outlined", size: "16px 16px" },
       icon_position: "right",
       icon_expanded_angle: -180,
@@ -210,20 +210,21 @@ function panel({ title, content, elements }) {
   };
 }
 
-// One restrained status line replaces the large colored banner.
-function statusCard(status, body, panels = []) {
-  const [title, color] = cardTones[status] || cardTones.failed;
+// Feishu rejects cards above about 30 KB of JSON.
+const cardBudget = 28000;
+const bytes = (value) => Buffer.byteLength(JSON.stringify(value));
+
+function statusCard(status, body, elements = []) {
+  const [title, template] = cardTones[status] || cardTones.failed;
   return JSON.stringify({
     schema: "2.0",
     config: { update_multi: true, summary: { content: title } },
+    // The colored header carries the status, so the body starts with the content.
+    header: { title: { tag: "plain_text", content: title }, template },
     body: {
-      padding: "16px 16px 12px 16px",
+      padding: "12px 16px 12px 16px",
       vertical_spacing: "8px",
-      elements: [
-        { tag: "markdown", text_size: "notation", content: `<font color='${color}'>${title}</font>` },
-        { tag: "markdown", content: excerpt(body, status === "requires_action" ? 8000 : 12000) },
-        ...(panels.length ? [{ tag: "hr" }, ...panels.map(panel)] : []),
-      ],
+      elements: [{ tag: "markdown", content: body }, ...elements],
     },
   });
 }
@@ -258,7 +259,7 @@ function step(item) {
   if (item.type === "command_execution" || typeof item.command === "string") {
     const command = String(item.command || "").replace(/\s+/g, " ").trim()
       .replace(/^\/bin\/(?:ba|z)?sh -lc (['"])([\s\S]*)\1$/, "$2");
-    return ["运行命令", command.length > 56 ? `${command.slice(0, 55)}…` : command];
+    return ["运行", command];
   }
   if (item.type === "mcp_call") return ["调用工具", [item.server_label, item.name].filter(Boolean).join(" · ")];
   if (item.type === "function_call") return ["调用工具", item.name || ""];
@@ -267,21 +268,57 @@ function step(item) {
   return ["执行步骤", item.name || item.type || ""];
 }
 
-function stepPanel(item) {
+const clip = (value, limit) => {
+  const text = String(value ?? "").replace(/\s+/g, " ").trim();
+  return text.length > limit ? `${text.slice(0, limit - 1)}…` : text;
+};
+// Markdown and Feishu tags stay literal inside a one-line title.
+const literal = (value) => value.replace(/[<>]/g, "").replaceAll("`", "'");
+
+// One tool call: what ran stays visible; its result folds away.
+function toolRow(item) {
   const [label, detail] = step(item);
-  const state = { completed: "完成", failed: "失败", incomplete: "未完成", in_progress: "进行中" }[item.status] || "状态未知";
-  const duration = typeof item.duration_ms === "number" ? ` · ${(item.duration_ms / 1000).toFixed(1)}s` : "";
+  const state = item.status === "failed"
+    ? "<font color='red'>失败</font>"
+    : item.status === "in_progress"
+      ? grey("进行中")
+      : item.status === "incomplete"
+        ? grey("未完成")
+        : typeof item.duration_ms === "number"
+        ? grey(`${(item.duration_ms / 1000).toFixed(1)}s`)
+        : "";
+  const title = [grey(label), detail ? `\`${literal(clip(detail, 200))}\`` : "", state].filter(Boolean).join(" ");
   const fields = [
-    ["命令", item.command], ["工作目录", item.cwd], ["参数", item.arguments ?? item.action],
+    ["参数", item.command ? undefined : item.arguments ?? item.action],
     ["输出", item.output], ["错误", item.error], ["退出码", item.exit_code],
   ].filter(([, value]) => value !== undefined && value !== null && value !== "");
+  if (!fields.length) return { tag: "markdown", content: title };
   // Plain text keeps tool output literal, including code fences and mention markup.
   return panel({
-    title: `${state} · ${label}${detail ? ` · ${excerpt(detail, 180).replace(/[<>]/g, "")}` : ""}${duration}`,
-    elements: [{ tag: "div", text: { tag: "plain_text", content: excerpt(fields.map(([name, value]) => `${name}\n${excerpt(value, 700)}`).join("\n\n") || "暂无详细输出。", 1000) } }],
+    title,
+    elements: [{ tag: "div", text: { tag: "plain_text", content: excerpt(fields.map(([name, value]) => `${name}\n${excerpt(value, 1200)}`).join("\n\n"), 1600) } }],
   });
 }
 
+// Thinking folds behind its first sentence; commentary is short and shown as is.
+function timelineRow(entry) {
+  if (entry.type === "say") return { tag: "markdown", content: excerpt(entry.text, 800) };
+  if (entry.type === "think")
+    return panel({ title: `${grey("思考")} ${literal(clip(entry.text.split("\n").find((line) => line.trim()) || "", 40))}`, content: excerpt(entry.text, 1500) });
+  return toolRow(entry.item);
+}
+
+// The oldest rows leave the card first when it would grow past Feishu's limit.
+function fitRows(rows, budget) {
+  const kept = [...rows];
+  let dropped = 0;
+  while (kept.length > 1 && bytes(kept) > budget) {
+    kept.shift();
+    dropped++;
+  }
+  return dropped ? [{ tag: "markdown", content: grey(`更早的 ${dropped} 步见网页对话`) }, ...kept] : kept;
+}
+
 // A tool-result answer resumes the same Core Turn. Display only the exchange
 // after that answer, not every earlier question and command in the Turn.
 function exchangeItems(items) {
@@ -290,6 +327,8 @@ function exchangeItems(items) {
   return items.slice(boundary + 1);
 }
 
+const recentRows = 4;
+
 export function formatTurnCard(status, items = [], error, turn, questions = []) {
   items = exchangeItems(items);
   const text = (item) => (item.content || []).filter((p) => p.type === "output_text").map((p) => (p.text || "").trim()).filter(Boolean).join("\n");
@@ -301,45 +340,54 @@ export function formatTurnCard(status, items = [], error, turn, questions = [])
   const authorization = messages.filter((item) => qrImages(text(item)).length);
   const authorizationText = authorization.map((item) => readable(text(item))).join("\n\n");
   const answer = latest?.phase === "commentary" || authorization.includes(latest) ? "" : latest ? readable(text(latest)) : "";
-  const reasoning = items.filter((x) => x.type === "reasoning").flatMap((x) => x.summary || x.content || [])
-    .map((p) => typeof p === "string" ? p : p?.text || "").filter(Boolean).join("\n\n");
-  const commentary = messages.filter((x) => !authorization.includes(x) && (status === "in_progress" || x !== latest || x.phase === "commentary")).map(text).filter(Boolean).join("\n\n");
   const outputs = new Map(items.filter((x) => x.type === "function_call_output").map((x) => [x.call_id, x]));
-  const steps = items.filter((x) => !["message", "agent_message", "reasoning", "function_call_output"].includes(x.type) && !(x.type === "function_call" && x.name === "ask_user"))
-    .map((x) => {
-      const output = x.type === "function_call" ? outputs.get(x.call_id) : undefined;
-      return output ? { ...x, status: output.status, output: output.output, error: output.error } : x;
-    });
-  const panels = [];
-  if (reasoning) panels.push({ title: "思考摘要", content: excerpt(reasoning, 3000) });
-  if (commentary) panels.push({ title: "过程说明", content: excerpt(commentary, 1500) });
-  if (steps.length) panels.push({
-    title: `工具调用 · ${steps.length} 次`,
-    elements: [
-      ...(steps.length > 6 ? [{ tag: "markdown", content: grey(`展示最近 6 次，共 ${steps.length} 次；完整记录保留在网页会话。`) }] : []),
-      ...steps.slice(-6).map(stepPanel),
-    ],
+  // Thinking, commentary and tool calls in the order they happened.
+  const entries = items.flatMap((x) => {
+    if (x.type === "reasoning") {
+      const thought = (x.summary || x.content || []).map((p) => typeof p === "string" ? p : p?.text || "").filter(Boolean).join("\n\n").trim();
+      return thought ? [{ type: "think", text: thought }] : [];
+    }
+    if (x.type === "message") {
+      const said = x.role === "assistant" && !authorization.includes(x) && (status === "in_progress" || x !== latest || x.phase === "commentary") ? readable(text(x)) : "";
+      return said ? [{ type: "say", text: said }] : [];
+    }
+    if (["agent_message", "function_call_output"].includes(x.type) || (x.type === "function_call" && x.name === "ask_user")) return [];
+    const output = x.type === "function_call" ? outputs.get(x.call_id) : undefined;
+    return [{ type: "tool", item: output ? { ...x, status: output.status, output: output.output, error: output.error } : x }];
   });
+  const rows = entries.map(timelineRow);
+  const tools = entries.filter((entry) => entry.type === "tool").map((entry) => entry.item);
   if (status === "in_progress") {
     const last = items.filter((x) => x.role !== "user" && x.type !== "function_call_output").at(-1);
     const current = !last ? waitingHeadline(turn) : last.type === "message" ? "正在整理回复" : last.type === "reasoning" ? "正在思考" : last.status === "in_progress" ? `正在${step(last)[0]}` : "正在整理结果";
-    const done = steps.filter((x) => x.status === "completed").length;
-    const failed = steps.filter((x) => x.status === "failed").length;
-    const count = steps.length ? `工具调用 ${steps.length} 次 · 完成 ${done} 次${failed ? ` · 失败 ${failed} 次` : ""}` : "";
     const typical = !last && turn?.expected_s && turn.stage !== "retrying" ? typicalWait.replace("{{value0}}", turn.expected_s) : "";
-    return statusCard(status, [`**${current}**`, grey([count, typical].filter(Boolean).join(" · ")), authorizationText].filter(Boolean).join("\n"), panels);
+    const progress = rows.length ? `${rows.length} 步` : typical;
+    const body = excerpt([`**${current}**${progress ? ` ${grey(`· ${progress}`)}` : ""}`, authorizationText].filter(Boolean).join("\n"), 8000);
+    const earlier = rows.slice(0, -recentRows), recent = rows.slice(-recentRows);
+    const budget = cardBudget - bytes(body);
+    const shown = fitRows(recent, budget);
+    const fold = earlier.length ? [panel({ title: grey(`更早的 ${earlier.length} 步`), elements: fitRows(earlier, budget - bytes(shown)) })] : [];
+    return statusCard(status, body, [...fold, ...shown]);
   }
   const context = questions.some((action) => questionText(action, false).trim() === answer.trim()) ? "" : answer;
   // Put the decision first; keep its explanation available without filling the chat.
   // Authorization instructions stay visible alongside the separately sent QR.
   const foldContext = status === "requires_action" && questions.length && context;
-  if (foldContext) panels.unshift({ title: "补充说明", content: excerpt(context, 4000) });
-  const body = status === "requires_action"
+  const body = excerpt(status === "requires_action"
     ? [...questions.map((action) => questionText(action)), authorizationText, foldContext ? "" : context, grey("直接回复这条消息即可继续。")].filter(Boolean).join("\n\n")
     : status === "completed" ? [authorizationText, answer].filter(Boolean).join("\n\n") || "已完成处理。"
     : status === "cancelled" ? [authorizationText, answer].filter(Boolean).join("\n\n") || "已按你的要求停止。"
-    : [authorizationText, answer || "这次没有完成。", error ? `<font color='red'>${error}</font>` : "", grey("直接回复即可重试。")].filter(Boolean).join("\n\n");
-  return statusCard(status, body, panels);
+    : [authorizationText, answer || "这次没有完成。", error ? `<font color='red'>${error}</font>` : "", grey("直接回复即可重试。")].filter(Boolean).join("\n\n"), status === "requires_action" ? 8000 : 12000);
+  const elements = [];
+  if (foldContext) elements.push(panel({ title: grey("补充说明"), content: excerpt(context, 4000) }));
+  // A failure shows the step that failed right under its cause.
+  const failedTool = status === "failed" ? tools.findLast((item) => item.status === "failed") : undefined;
+  if (failedTool) elements.push(toolRow(failedTool));
+  if (rows.length) {
+    const budget = cardBudget - bytes(body) - bytes(elements);
+    elements.push(panel({ title: grey(`处理过程 · ${rows.length} 步`), elements: fitRows(rows, budget) }));
+  }
+  return statusCard(status, body, elements.length ? [{ tag: "hr" }, ...elements] : []);
 }
 
 export async function createFeishuTransport(settings, receive) {
diff --git a/example/parsar/tests/feishu.test.mjs b/example/parsar/tests/feishu.test.mjs
index f5b68ef78..1cc3200c1 100644
--- a/example/parsar/tests/feishu.test.mjs
+++ b/example/parsar/tests/feishu.test.mjs
@@ -1077,20 +1077,15 @@ test("Feishu updates a single card in place with thinking and steps, omits Web t
   const firstCard = JSON.parse(f.sent[0].data.content);
   assert.equal(firstCard.schema, "2.0");
   assert.equal(firstCard.config.summary.content, "处理中");
-  assert.equal(firstCard.header, undefined);
-  const [, current, , thinkingPanel, stepsPanel] = firstCard.body.elements;
+  assert.deepEqual(firstCard.header, { title: { tag: "plain_text", content: "处理中" }, template: "blue" });
+  // One chronological timeline: commentary as text, the command visible.
+  const [current, said, ran] = firstCard.body.elements;
   assert.match(current.content, /正在整理结果/);
-  assert.match(current.content, /工具调用 1 次 · 完成 1 次/);
-  assert.doesNotMatch(current.content, /先读取飞书技能文档/);
-  assert.equal(thinkingPanel.tag, "collapsible_panel");
-  assert.equal(thinkingPanel.expanded, false);
-  assert.match(thinkingPanel.header.title.content, /过程说明/);
-  assert.match(thinkingPanel.elements[0].content, /先读取飞书技能文档/);
-  assert.match(stepsPanel.header.title.content, /工具调用 · 1 次/);
-  assert.match(
-    stepsPanel.elements[0].elements[0].text.content,
-    /cat \/workspace\/\.agents\/skills\/lark-shared\/SKILL\.md/,
-  );
+  assert.match(current.content, /2 步/);
+  assert.equal(said.tag, "markdown");
+  assert.equal(said.content, "先读取飞书技能文档。");
+  assert.equal(ran.tag, "markdown", "a command without output has nothing to fold");
+  assert.match(ran.content, /运行.*`cat \/workspace\/\.agents\/skills\/lark-shared\/SKILL\.md`.*0\.4s/);
 
   finishTurn = true;
   items.push({
@@ -1105,11 +1100,16 @@ test("Feishu updates a single card in place with thinking and steps, omits Web t
   assert.equal(patches.length, 1, "must patch the existing card in place");
   const patchedCard = JSON.parse(patches[0].data.content);
   assert.equal(patchedCard.config.summary.content, "已完成");
-  assert.equal(patchedCard.header, undefined);
-  const [, answer, , thoughts, record] = patchedCard.body.elements;
+  assert.deepEqual(patchedCard.header, { title: { tag: "plain_text", content: "已完成" }, template: "green" });
+  // The answer first; the whole process folds into one row.
+  const [answer, rule, process] = patchedCard.body.elements;
   assert.equal(answer.content, "你好！我是飞书工作助手。");
-  assert.match(thoughts.elements[0].content, /先读取飞书技能文档/);
-  assert.match(record.header.title.content, /工具调用 · 1 次/);
+  assert.equal(rule.tag, "hr");
+  assert.equal(process.tag, "collapsible_panel");
+  assert.equal(process.expanded, false);
+  assert.match(process.header.title.content, /处理过程 · 2 步/);
+  assert.equal(process.elements[0].content, "先读取飞书技能文档。");
+  assert.match(process.elements[1].content, /`cat \/workspace/);
   assert.doesNotMatch(
     JSON.stringify(patchedCard),
     /任务编号|在 Web 会话下载|Parsar/,
@@ -1378,7 +1378,7 @@ test("Feishu private informational and rejected commands retain the active conve
   );
 });
 
-test("failure remains visible without a banner and empty detail panels are omitted", async () => {
+test("a failure shows its cause with the failed step right below, and a plain answer adds no rows", async () => {
   const { formatTurnCard, feishuCard } = await import("../server/feishu.mjs");
   const card = JSON.parse(
     formatTurnCard(
@@ -1394,11 +1394,12 @@ test("failure remains visible without a banner and empty detail panels are omitt
       "permission denied",
     ),
   );
-  assert.equal(card.header, undefined);
+  assert.deepEqual(card.header, { title: { tag: "plain_text", content: "执行失败" }, template: "red" });
   assert.equal(card.config.summary.content, "执行失败");
-  assert.match(card.body.elements[0].content, /color='red'/);
-  assert.match(card.body.elements[1].content, /<font color='red'>permission denied<\/font>/);
-  assert.match(card.body.elements[3].elements[0].header.title.content, /失败 · 运行命令/);
+  const [cause, , failed, process] = card.body.elements;
+  assert.match(cause.content, /<font color='red'>permission denied<\/font>/);
+  assert.match(failed.content, /运行.*`lark-cli docs \+fetch --doc abc`.*<font color='red'>失败<\/font>/);
+  assert.match(process.header.title.content, /处理过程 · 1 步/);
   const quiet = JSON.parse(
     formatTurnCard("completed", [
       { type: "message", role: "assistant", content: [{ type: "output_text", text: "答案" }] },
@@ -1406,13 +1407,13 @@ test("failure remains visible without a banner and empty detail panels are omitt
   );
   assert.deepEqual(
     quiet.body.elements.map((element) => element.tag),
-    ["markdown", "markdown"],
+    ["markdown"],
   );
-  assert.equal(quiet.body.elements[1].content, "答案");
+  assert.equal(quiet.body.elements[0].content, "答案");
   const plain = feishuCard("已请求取消，等待 Agent 确认停止。");
   assert.equal(plain.header, undefined);
   assert.equal(plain.body.elements[0].content, "已请求取消，等待 Agent 确认停止。");
-  assert.match(feishuCard("执行失败\n\n环境准备失败").body.elements[0].content, /color='red'/);
+  assert.equal(feishuCard("执行失败\n\n环境准备失败").header.template, "red");
 });
 
 test("web searches appear as readable steps in the Feishu record", async () => {
@@ -1427,10 +1428,8 @@ test("web searches appear as readable steps in the Feishu record", async () => {
       { type: "message", role: "assistant", content: [{ type: "output_text", text: "Done" }] },
     ]),
   );
-  assert.match(
-    card.body.elements[3].elements[0].header.title.content,
-    /完成 · 搜索网页 · OpenAgentCore release/,
-  );
+  const search = card.body.elements[2].elements[0];
+  assert.match(search.header.title.content, /搜索网页.*`OpenAgentCore release`/);
 });
 
 test("Feishu delivers QR during authorization and artifact media once, retaining uploaded keys after a lost send", async (t) => {
@@ -1557,7 +1556,7 @@ test("Feishu SDK uploads multipart bytes and preserves definite rejection and re
   await assert.rejects(disconnected.upload(Buffer.from("file"), "file.txt"), (error) => error.status === 503 && !error.message.includes("private-network-data"));
 });
 
-test("card details join tool results, retain useful diagnostics and count calls once", async () => {
+test("the timeline joins tool results, keeps commands visible and folds their diagnostics", async () => {
   const { formatTurnCard } = await import("../server/feishu.mjs");
   const card = JSON.parse(formatTurnCard("in_progress", [
     { type: "reasoning", summary: [{ text: "先检查接口，再处理结果。" }] },
@@ -1566,20 +1565,19 @@ test("card details join tool results, retain useful diagnostics and count calls
     { type: "command_execution", command: "pwd", cwd: "/workspace", output: "/workspace", exit_code: 0, duration_ms: 420, status: "completed" },
     { type: "mcp_call", name: "read", server_label: "docs", arguments: { id: 3 }, status: "incomplete" },
   ]));
-  assert.match(card.body.elements[1].content, /工具调用 3 次 · 完成 1 次 · 失败 1 次/);
-  const panels = card.body.elements.filter((x) => x.tag === "collapsible_panel");
-  assert.equal(panels[0].header.title.content.includes("思考摘要"), true);
-  const tools = panels.at(-1);
-  assert.match(tools.header.title.content, /3 次/);
-  assert.match(tools.elements[0].header.title.content, /失败/);
-  const literal = tools.elements[0].elements[0].text;
+  const [current, thought, lookup, pwd, read] = card.body.elements;
+  assert.match(current.content, /4 步/);
+  assert.match(thought.header.title.content, /思考.*先检查接口/);
+  assert.equal(thought.elements[0].content, "先检查接口，再处理结果。");
+  assert.match(lookup.header.title.content, /调用工具.*`lookup`.*<font color='red'>失败<\/font>/);
+  const literal = lookup.elements[0].text;
   assert.equal(literal.tag, "plain_text");
   assert.match(literal.content, /invoice/);
   assert.match(literal.content, /permission denied/);
   assert.match(literal.content, /<at id=all>/);
-  assert.match(tools.elements[1].elements[0].text.content, /退出码\n0/);
-  assert.match(tools.elements[1].header.title.content, /0.4s/);
-  assert.match(tools.elements[2].header.title.content, /未完成/);
+  assert.match(pwd.header.title.content, /运行.*`pwd`.*0\.4s/);
+  assert.match(pwd.elements[0].text.content, /退出码\n0/);
+  assert.match(read.header.title.content, /调用工具.*`docs · read`.*未完成/);
 });
 
 test("resumed questions display only the current exchange, including on completion", async () => {
@@ -1594,9 +1592,9 @@ test("resumed questions display only the current exchange, including on completi
     { type: "function_call", call_id: "q2", name: "ask_user" },
   ];
   const card = JSON.parse(formatTurnCard("requires_action", items, undefined, undefined, [{ arguments: JSON.stringify({ question: "What should the bot do?", options: ["Documents", "Reports"] }) }]));
-  assert.match(card.body.elements[1].content, /^What should the bot do/);
-  assert.doesNotMatch(card.body.elements[1].content, /CURRENT CONTEXT/);
-  assert.match(card.body.elements[3].elements[0].content, /CURRENT CONTEXT/);
+  assert.match(card.body.elements[0].content, /^What should the bot do/);
+  assert.doesNotMatch(card.body.elements[0].content, /CURRENT CONTEXT/);
+  assert.match(card.body.elements[2].elements[0].content, /CURRENT CONTEXT/);
   assert.doesNotMatch(JSON.stringify(card), /OLD INVENTORY|old command|function_call_output|工具调用/);
   items.push({ type: "function_call_output", call_id: "q2", output: "Reports" }, message("DONE"));
   assert.doesNotMatch(formatTurnCard("completed", items), /CURRENT CONTEXT|OLD INVENTORY/);
@@ -1688,10 +1686,10 @@ test("large multilingual diagnostics stay below the Feishu card payload limit",
     ...Array.from({ length: 20 }, (_, i) => ({ type: "mcp_call", name: `tool${i}`, status: "completed", arguments: { input: large }, output: large })),
     { type: "message", role: "assistant", content: [{ type: "output_text", text: large }] },
   ];
-  for (const status of ["completed", "requires_action"]) {
+  for (const status of ["in_progress", "completed", "requires_action"]) {
     const payload = formatTurnCard(status, items, undefined, undefined, [{ arguments: { question: large, options: [large] } }]);
     assert.ok(Buffer.byteLength(payload) < 30000, `${status}: ${Buffer.byteLength(payload)}`);
-    assert.match(payload, /展示最近 6 次/);
+    assert.match(payload, /更早的 \d+ 步见网页对话/, "the oldest rows leave the card first");
     assert.match(payload, /内容较长，已截取/);
   }
 });
@@ -1731,10 +1729,10 @@ test("identical question text is shown once and agent messages do not count as t
     { type: "agent_message", content: "subagent progress" },
     { type: "message", role: "assistant", content: [{ type: "output_text", text: "Which bot?" }] },
   ], undefined, undefined, [{ arguments: { question: "Which bot?", options: ["Writer", "Analyst"] } }]));
-  assert.equal(card.body.elements[1].content.split("Which bot?").length - 1, 1);
-  assert.match(card.body.elements[1].content, /Writer/);
-  assert.match(card.body.elements.at(-1).header.title.content, /工具调用 · 1 次/);
-  assert.doesNotMatch(JSON.stringify(card), /agent_message|状态未知/);
+  assert.equal(card.body.elements[0].content.split("Which bot?").length - 1, 1);
+  assert.match(card.body.elements[0].content, /Writer/);
+  assert.match(card.body.elements.at(-1).header.title.content, /处理过程 · 1 步/);
+  assert.doesNotMatch(JSON.stringify(card), /agent_message|subagent progress/);
 });
 
 
@@ -1747,9 +1745,9 @@ test("authorization instructions stay visible across message phases and later re
         { type: "message", role: "assistant", phase, content: [{ type: "output_text", text: `请应用管理员扫码 [授权](https://open.feishu.cn/page/launcher?user_code=test)\n![QR](/app/feishu/provision/${id}/qrcode)` }] },
         { type: "message", role: "assistant", phase: "commentary", content: [{ type: "output_text", text: "等待授权完成。" }] },
       ], undefined, undefined, [{ arguments: { question: "授权完成后告诉我" } }]));
-      assert.match(card.body.elements[1].content, /请应用管理员扫码/);
-      assert.match(card.body.elements[1].content, /https:\/\/open.feishu.cn/);
-      assert.match(card.body.elements[1].content, /授权二维码见图片消息/);
+      assert.match(card.body.elements[0].content, /请应用管理员扫码/);
+      assert.match(card.body.elements[0].content, /https:\/\/open.feishu.cn/);
+      assert.match(card.body.elements[0].content, /授权二维码见图片消息/);
       assert.equal(JSON.stringify(card).split("user_code=test").length - 1, 1);
     }
   }
@@ -1985,3 +1983,17 @@ test("completed-turn cursors release answered questions before the next turn", a
   await worker.tick();
   assert.ok(patches.some((payload) => payload.includes("SECOND RESULT")) || f.sent.some((row) => row.data.content.includes("SECOND RESULT")));
 });
+
+test("a running card shows the latest four steps and folds the earlier ones", async () => {
+  const { formatTurnCard } = await import("../server/feishu.mjs");
+  const items = Array.from({ length: 7 }, (_, i) => ({ type: "command_execution", command: `step ${i + 1}`, duration_ms: 1000, status: "completed" }));
+  items.push({ type: "command_execution", command: "step 8", status: "in_progress" });
+  const [current, earlier, ...recent] = JSON.parse(formatTurnCard("in_progress", items)).body.elements;
+  assert.match(current.content, /正在运行.*8 步/);
+  assert.equal(earlier.tag, "collapsible_panel");
+  assert.equal(earlier.expanded, false);
+  assert.match(earlier.header.title.content, /更早的 4 步/);
+  assert.deepEqual(earlier.elements.map((row) => row.content.match(/`(.*)`/)[1]), ["step 1", "step 2", "step 3", "step 4"]);
+  assert.deepEqual(recent.map((row) => row.content.match(/`(.*)`/)[1]), ["step 5", "step 6", "step 7", "step 8"]);
+  assert.match(recent.at(-1).content, /进行中/);
+});

From 75b8a81103fcfea7bc6392f5e2a6142784866e6b Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Sun, 25 Oct 2026 22:12:04 +0800
Subject: [PATCH 02/19] Fold Feishu tool calls into one row and add /clear and
 /stop
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Only commentary now stays open in the card timeline: consecutive tool
calls fold into one row with their total time, failures or 进行中, and
each call folds again behind its command. Size fitting reaches into a
folded row when that row alone is too large.

Feishu commands are /clear, which stops running work and makes the next
message start a new conversation (in a private chat or in the same group
topic), /stop for the current task, /answer and /help. They replace /new,
/reset and /cancel.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/README.md             |   6 +-
 example/parsar/README.zh.md          |   8 +-
 example/parsar/server/feishu.mjs     | 128 ++++++++++++++++++---------
 example/parsar/tests/feishu.test.mjs |  72 ++++++++-------
 4 files changed, 133 insertions(+), 81 deletions(-)

diff --git a/example/parsar/README.md b/example/parsar/README.md
index e2d6d2c87..ee75259c1 100644
--- a/example/parsar/README.md
+++ b/example/parsar/README.md
@@ -119,11 +119,11 @@ Optional business questions use the declared `ask_user` function. They appear in
 
 1. On the card, choose the **Agent**, turn on **私聊** and/or **群聊**, then **保存并启用**. Enabling requires credentials, an Agent with an environment template and at least one of the two. With **群聊** on, the bot answers mentions in every group it has joined; adding the bot to a group is all that is needed. Who can add the bot is controlled by the app’s availability in the developer console.
 2. In the developer console, enable the bot, long-connection event delivery and `im.message.receive_v1`, publish the app and add it to the target groups. Grant mention receipt and send-as-bot permissions; direct messages, message resources and reactions need their own scopes. A missing reaction permission does not discard a message.
-3. Private chat keeps one conversation per sender until `/new` or `/reset`. In groups, mentioning the bot starts a topic and each topic is one conversation shared by everyone who replies in it. Follow-ups without a mention arrive only when the app has the sensitive “read all group messages” scope (`im:message.group_msg`); otherwise mention the bot again in the topic. A topic reply that mentions only other people is addressed to them and is ignored. The bot serves its own tenant only: messages from external contacts are ignored. Other bots and `@all` are ignored, as are groups while **群聊** is off and private chats while **私聊** is off. Changing the bound Agent affects new topics and new private conversations.
+3. Private chat keeps one conversation per sender until `/clear`. In groups, mentioning the bot starts a topic and each topic is one conversation shared by everyone who replies in it. Follow-ups without a mention arrive only when the app has the sensitive “read all group messages” scope (`im:message.group_msg`); otherwise mention the bot again in the topic. A topic reply that mentions only other people is addressed to them and is ignored. The bot serves its own tenant only: messages from external contacts are ignored. Other bots and `@all` are ignored, as are groups while **群聊** is off and private chats while **私聊** is off. Changing the bound Agent affects new topics and new private conversations.
 4. Text, rich posts, images, files, audio and video, quoted messages and merged forwards are normalized before dispatch. Attachment limits are eight resources and 5 MiB total. Follow-up files wait until the conversation is idle. Quoted messages are read up to four levels; earlier group messages are not read.
-5. `/cancel`, `/answer <call_id> <text>`, `/new` and `/help` work in the same thread. A plain reply answers a single pending business question. Cancellation takes priority over queued follow-ups and recovers an uncertain creation before cancelling it.
+5. Commands: `/clear` clears the context: it stops any running work and the next message starts a new conversation, in a private chat or in the same group topic. `/stop` stops the current task; it takes priority over queued follow-ups and recovers an uncertain creation before stopping it. `/answer <call_id> <text>` answers a pending business question, and a plain reply answers when only one is pending. `/help` lists the commands.
 
-Accepted messages are committed to SQLite before the WebSocket ACK; request IDs and frozen payloads survive retries and restarts. The worker edits one compact progress card in place, includes any pending business question in that card, and finishes it with the result. Each reply shows only the current exchange, including answers that resume the same Core Turn. The answer stays visible; while awaiting a business decision, the question takes priority and its supporting context is collapsed, except QR authorization instructions. The card has a colored header for its status. Its process is one timeline in the order things happened: commentary appears as plain text, thinking folds behind its first sentence, and each tool call shows what ran with its duration, failure or 进行中 while its result (parameters, output, error, exit code) folds away. A running card shows the latest four steps and folds the earlier ones; a finished card puts the answer first and folds the whole process into **处理过程**; a failed card shows the failed step right under its cause. Long content is cut to marked, byte-bounded excerpts, and the oldest steps leave the card first to stay within Feishu's card size limit. Progress uses five-second polling. Complete history and Artifacts remain in the Web conversation. Settled threads stop polling after five minutes and wake on new messages. **消息记录** lists the latest 100 deliveries plus unresolved ones; **重试** keeps the original identity. A failed inbound message blocks later messages in that thread. Uncertain outbound sends are not replayed beyond 55 minutes. Disabling a bot pauses delivery without cancelling Core work.
+Accepted messages are committed to SQLite before the WebSocket ACK; request IDs and frozen payloads survive retries and restarts. The worker edits one compact progress card in place, includes any pending business question in that card, and finishes it with the result. Each reply shows only the current exchange, including answers that resume the same Core Turn. The answer stays visible; while awaiting a business decision, the question takes priority and its supporting context is collapsed, except QR authorization instructions. The card has a colored header for its status. Its process is one timeline in the order things happened. Only commentary stays open as plain text; thinking folds behind its first sentence, and consecutive tool calls fold into one row (such as `运行 3 条命令` with their total time, failures or 进行中) in which each call folds again behind its command, showing parameters, output, error and exit code. A running card shows the latest four steps and folds the earlier ones; a finished card puts the answer first and folds the whole process into **处理过程**; a failed card shows the failed step right under its cause. Long content is cut to marked, byte-bounded excerpts, and the oldest steps leave the card first to stay within Feishu's card size limit. Progress uses five-second polling. Complete history and Artifacts remain in the Web conversation. Settled threads stop polling after five minutes and wake on new messages. **消息记录** lists the latest 100 deliveries plus unresolved ones; **重试** keeps the original identity. A failed inbound message blocks later messages in that thread. Uncertain outbound sends are not replayed beyond 55 minutes. Disabling a bot pauses delivery without cancelling Core work.
 
 ### Bot identity
 
diff --git a/example/parsar/README.zh.md b/example/parsar/README.zh.md
index e568b32f5..dce57e365 100644
--- a/example/parsar/README.zh.md
+++ b/example/parsar/README.zh.md
@@ -1,6 +1,6 @@
 ---
 source: example/parsar/README.md
-source_hash: f400d9bd09523a6bf3a0c5c1a860562bf2d97a98712c1bb11c50be3f46ca0076
+source_hash: e82aa7249febf32add4459dabd95f6814b2cade69d0bd5ab962cad2f12d10acb
 ---
 
 # Parsar 工作空间
@@ -124,11 +124,11 @@ Parsar 会跟踪每一轮正在执行的对话，网页和飞书都一样。出
 
 1. 在卡片上选择 **Agent**，打开 **私聊** 和/或 **群聊**，然后 **保存并启用**。启用需要应用凭证、已配置环境模板的 Agent，以及两者至少开启一项。打开 **群聊** 后，机器人会回复它所在的任何群里的 @ 消息，把机器人拉进群即可使用。谁能添加机器人由开发者后台中应用的可用范围控制。
 2. 在开发者后台启用机器人、长连接事件推送和 `im.message.receive_v1`，发布应用并把它加入目标群。授予接收 @ 消息和以机器人身份发送消息的权限；私聊、消息资源和表情回复需要各自的权限。缺少表情权限不会丢弃消息。
-3. 私聊为每个发送者保持一个对话，直到发送 `/new` 或 `/reset`。群聊中 @ 机器人会开启一个话题，每个话题是一个对话，所有在其中回复的人共享。只有应用开通了敏感权限“获取群组中所有消息”（`im:message.group_msg`），话题中不带 @ 的后续消息才会推送给机器人；否则需要在话题中再次 @ 机器人。话题中只 @ 了其他人的回复是发给他们的，会被忽略。其他机器人和 机器人只服务自己所在的企业，外部联系人发来的消息会被忽略。`@所有人` 会被忽略；关闭 **群聊** 时忽略群消息，关闭 **私聊** 时忽略私聊。更换绑定的 Agent 只影响新话题和新的私聊对话。
+3. 私聊为每个发送者保持一个对话，直到发送 `/clear`。群聊中 @ 机器人会开启一个话题，每个话题是一个对话，所有在其中回复的人共享。只有应用开通了敏感权限“获取群组中所有消息”（`im:message.group_msg`），话题中不带 @ 的后续消息才会推送给机器人；否则需要在话题中再次 @ 机器人。话题中只 @ 了其他人的回复是发给他们的，会被忽略。其他机器人和 机器人只服务自己所在的企业，外部联系人发来的消息会被忽略。`@所有人` 会被忽略；关闭 **群聊** 时忽略群消息，关闭 **私聊** 时忽略私聊。更换绑定的 Agent 只影响新话题和新的私聊对话。
 4. 文本、富文本、图片、文件、音视频、引用消息和合并转发会在投递前规范化。附件上限为 8 个、合计 5 MiB。后续消息中的文件会等到对话空闲后写入。引用消息最多读取四层；不读取更早的群消息。
-5. `/cancel`、`/answer <call_id> <回答>`、`/new` 和 `/help` 在同一话题中使用。只有一个待回答的业务问题时，直接回复即可作答。取消优先于排队中的追问，并会先确认不确定的创建再取消。
+5. 命令：`/clear` 清空上下文：停止正在执行的任务，下一条消息开始新对话，私聊和群聊话题都适用（群聊仍在同一个话题里）。`/stop` 停止当前任务，优先于排队中的追问，并会先确认不确定的创建再停止。`/answer <call_id> <回答>` 回答待处理的业务问题；只有一个待回答的问题时，直接回复即可。`/help` 列出这些命令。
 
-收到的消息在 WebSocket ACK 之前写入 SQLite；请求 ID 和冻结的负载在重试与重启后保持不变。工作器原地更新一张简洁进度卡片，将待回答的问题合并到卡片中，结束后改成结果。每次回复只展示当前交流的内容，包括回答提问后继续同一 Core Turn 的情况。正文突出当前回复；等待业务选择时优先展示问题，将补充说明折叠，二维码授权说明保持可见。卡片顶部是带颜色的状态标题栏。处理过程按发生顺序排成一条时间线：说明直接显示文字；思考折叠在第一句后面；每次工具调用直接显示运行了什么，以及用时、失败或“进行中”，返回结果（参数、输出、错误、退出码）折叠起来。执行中的卡片显示最近四步，更早的步骤折叠；完成后回复放在最前面，整个过程折叠成 **处理过程**；失败时出错的那一步紧跟在失败原因下面。长内容按字节限制截取并明确标注；为了不超过飞书卡片的大小限制，最早的步骤会先移出卡片。进度每五秒轮询一次。完整历史和 Artifacts 保留在网页对话中。已结束的话题在五分钟后停止轮询，收到新消息时恢复。**消息记录** 列出最近 100 条投递以及未解决的记录；**重试** 保留原有标识。入站消息失败会阻塞该话题后续消息。不确定的出站消息超过 55 分钟后不再重放。停用机器人会暂停投递，但不会取消 Core 中的执行。
+收到的消息在 WebSocket ACK 之前写入 SQLite；请求 ID 和冻结的负载在重试与重启后保持不变。工作器原地更新一张简洁进度卡片，将待回答的问题合并到卡片中，结束后改成结果。每次回复只展示当前交流的内容，包括回答提问后继续同一 Core Turn 的情况。正文突出当前回复；等待业务选择时优先展示问题，将补充说明折叠，二维码授权说明保持可见。卡片顶部是带颜色的状态标题栏。处理过程按发生顺序排成一条时间线。只有说明直接显示文字；思考折叠在第一句后面；连续的工具调用折叠成一行（例如“运行 3 条命令”，附总用时、失败次数或“进行中”），展开后每次调用再折叠在它的命令后面，可查看参数、输出、错误和退出码。执行中的卡片显示最近四步，更早的步骤折叠；完成后回复放在最前面，整个过程折叠成 **处理过程**；失败时出错的那一步紧跟在失败原因下面。长内容按字节限制截取并明确标注；为了不超过飞书卡片的大小限制，最早的步骤会先移出卡片。进度每五秒轮询一次。完整历史和 Artifacts 保留在网页对话中。已结束的话题在五分钟后停止轮询，收到新消息时恢复。**消息记录** 列出最近 100 条投递以及未解决的记录；**重试** 保留原有标识。入站消息失败会阻塞该话题后续消息。不确定的出站消息超过 55 分钟后不再重放。停用机器人会暂停投递，但不会取消 Core 中的执行。
 
 ### 机器人身份 {#bot-identity}
 
diff --git a/example/parsar/server/feishu.mjs b/example/parsar/server/feishu.mjs
index 4024f624d..e5fbf6395 100644
--- a/example/parsar/server/feishu.mjs
+++ b/example/parsar/server/feishu.mjs
@@ -275,19 +275,21 @@ const clip = (value, limit) => {
 // Markdown and Feishu tags stay literal inside a one-line title.
 const literal = (value) => value.replace(/[<>]/g, "").replaceAll("`", "'");
 
-// One tool call: what ran stays visible; its result folds away.
-function toolRow(item) {
-  const [label, detail] = step(item);
-  const state = item.status === "failed"
+const toolState = (item) =>
+  item.status === "failed"
     ? "<font color='red'>失败</font>"
     : item.status === "in_progress"
       ? grey("进行中")
       : item.status === "incomplete"
         ? grey("未完成")
         : typeof item.duration_ms === "number"
-        ? grey(`${(item.duration_ms / 1000).toFixed(1)}s`)
-        : "";
-  const title = [grey(label), detail ? `\`${literal(clip(detail, 200))}\`` : "", state].filter(Boolean).join(" ");
+          ? grey(`${(item.duration_ms / 1000).toFixed(1)}s`)
+          : "";
+
+// One tool call: the command is the title, its result folds below it.
+function toolRow(item) {
+  const [label, detail] = step(item);
+  const title = [grey(label), detail ? `\`${literal(clip(detail, 200))}\`` : "", toolState(item)].filter(Boolean).join(" ");
   const fields = [
     ["参数", item.command ? undefined : item.arguments ?? item.action],
     ["输出", item.output], ["错误", item.error], ["退出码", item.exit_code],
@@ -300,23 +302,44 @@ function toolRow(item) {
   });
 }
 
-// Thinking folds behind its first sentence; commentary is short and shown as is.
+// Consecutive tool calls fold into one row; each call folds again inside it.
+function toolsRow(items) {
+  const failed = items.filter((item) => item.status === "failed").length;
+  const state = items.some((item) => item.status === "in_progress")
+    ? grey("进行中")
+    : failed
+      ? `<font color='red'>失败 ${failed} 次</font>`
+      : items.every((item) => typeof item.duration_ms === "number")
+        ? grey(`${(items.reduce((sum, item) => sum + item.duration_ms, 0) / 1000).toFixed(1)}s`)
+        : "";
+  const [label, detail] = step(items[0]);
+  const title = items.length === 1
+    ? [grey(label), detail ? `\`${literal(clip(detail, 40))}\`` : "", state]
+    : [grey(items.every((item) => step(item)[0] === "运行") ? `运行 ${items.length} 条命令` : `调用 ${items.length} 次工具`), state];
+  return panel({ title: title.filter(Boolean).join(" "), elements: items.map(toolRow) });
+}
+
+// Only commentary stays open; thinking and tool calls fold behind one line.
 function timelineRow(entry) {
   if (entry.type === "say") return { tag: "markdown", content: excerpt(entry.text, 800) };
   if (entry.type === "think")
     return panel({ title: `${grey("思考")} ${literal(clip(entry.text.split("\n").find((line) => line.trim()) || "", 40))}`, content: excerpt(entry.text, 1500) });
-  return toolRow(entry.item);
+  return toolsRow(entry.items);
 }
 
-// The oldest rows leave the card first when it would grow past Feishu's limit.
-function fitRows(rows, budget) {
+// The oldest rows leave the card first when it would grow past Feishu's
+// limit; a single row that is still too large sheds its oldest calls.
+function fitRows(rows, budget, unit = "步") {
   const kept = [...rows];
   let dropped = 0;
   while (kept.length > 1 && bytes(kept) > budget) {
     kept.shift();
     dropped++;
   }
-  return dropped ? [{ tag: "markdown", content: grey(`更早的 ${dropped} 步见网页对话`) }, ...kept] : kept;
+  const [only] = kept;
+  if (kept.length === 1 && bytes(kept) > budget && only.elements?.length > 1)
+    kept[0] = { ...only, elements: fitRows(only.elements, budget - (bytes(only) - bytes(only.elements)), "次调用") };
+  return dropped ? [{ tag: "markdown", content: grey(`更早的 ${dropped} ${unit}见网页对话`) }, ...kept] : kept;
 }
 
 // A tool-result answer resumes the same Core Turn. Display only the exchange
@@ -355,7 +378,13 @@ export function formatTurnCard(status, items = [], error, turn, questions = [])
     const output = x.type === "function_call" ? outputs.get(x.call_id) : undefined;
     return [{ type: "tool", item: output ? { ...x, status: output.status, output: output.output, error: output.error } : x }];
   });
-  const rows = entries.map(timelineRow);
+  const grouped = entries.reduce((rows, entry) => {
+    const last = rows.at(-1);
+    if (entry.type === "tool" && last?.type === "tools") last.items.push(entry.item);
+    else rows.push(entry.type === "tool" ? { type: "tools", items: [entry.item] } : entry);
+    return rows;
+  }, []);
+  const rows = grouped.map(timelineRow);
   const tools = entries.filter((entry) => entry.type === "tool").map((entry) => entry.item);
   if (status === "in_progress") {
     const last = items.filter((x) => x.role !== "user" && x.type !== "function_call_output").at(-1);
@@ -623,7 +652,7 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
     if (store.get("feishu_inbound", id)) return;
     let thread =
       message.chatType === "p2p" &&
-      !["/new", "/reset"].includes(message.content.trim())
+      message.content.trim() !== "/clear"
         ? store
             .list("feishu_threads")
             .find(
@@ -862,25 +891,11 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
   const inbound = async (row) => {
     let thread = store.get("feishu_threads", row.thread_id);
     if (!thread) return reject(row, "话题关联不可用，请在 Web 中检查。");
-    if (["/new", "/reset", "/help"].includes(row.text)) {
-      queueReply(
-        stableId(`${row.id}:command`),
-        thread,
-        row.text === "/help"
-          ? "直接发送消息即可对话。/new 开始新对话（群聊请另开话题并 @机器人）；/cancel 停止执行；/answer <call_id> <回答> 回复 Agent 的提问。"
-          : row.chat_type === "p2p"
-            ? "新对话已就绪，请直接发送消息。"
-            : "群聊请另开话题并 @机器人，开始新对话。当前话题保持不变。",
-      );
-      store.put("feishu_inbound", { ...row, state: "delivered" });
-      return;
-    }
-    const media = await mediaFor(row);
-    row = store.get("feishu_inbound", row.id);
-    const rotateP2PThread = () => {
+    // A new Session for this chat or topic; the next message starts it.
+    const rotateThread = () => {
       thread = {
         ...thread,
-        root_id: row.message_id,
+        root_id: row.chat_type === "p2p" ? row.message_id : thread.root_id,
         agent_id: store.get("feishu_bots", configId).agent_id,
         session_id: randomUUID(),
         session_ids: [
@@ -902,13 +917,40 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
       };
       store.put("feishu_threads", thread);
     };
+    if (["/clear", "/help"].includes(row.text)) {
+      if (row.text === "/clear") {
+        // Work in the cleared conversation would continue unseen; stop it.
+        const previous = row.chat_type === "p2p"
+          ? store.list("feishu_threads").filter((t) => t.id !== thread.id && t.app_id === thread.app_id && t.chat_id === thread.chat_id && t.sender_id === thread.sender_id && t.chat_type === "p2p").at(-1)
+          : thread;
+        const run = previous && store.get("sessions", previous.session_id);
+        if (run?.core_session_id)
+          await core(`/v1/agents/sessions/${run.core_session_id}/events`, "POST", { events: [{ type: "agent.session.input.cancel" }] }, `${row.id}:clear`).catch(() => {});
+        // A private chat already got a fresh thread on receipt; a topic keeps its root.
+        if (row.chat_type !== "p2p" && thread.first_message_id !== row.id) rotateThread();
+      }
+      queueReply(
+        stableId(`${row.id}:command`),
+        thread,
+        row.text === "/help"
+          ? "直接发送消息即可对话。/clear 清空上下文，开始新对话；/stop 停止当前任务；/answer <call_id> <回答> 回复 Agent 的提问。"
+          : row.chat_type === "p2p"
+            ? "已清空上下文，直接发送消息即可开始新对话。"
+            : "已清空这个话题的上下文，接着在话题里发消息即可开始新对话。",
+      );
+      store.put("feishu_inbound", { ...row, state: "delivered" });
+      return;
+    }
+    const media = await mediaFor(row);
+    row = store.get("feishu_inbound", row.id);
+
     if (
       thread.first_message_id !== row.id &&
       row.chat_type === "p2p" &&
       !row.text.startsWith("/") &&
       store.get("sessions", thread.session_id)?.deleted_at
     )
-      rotateP2PThread();
+      rotateThread();
     const progress = (text) => {
       const progressId = stableId(`${row.id}:accepted`);
       thread = {
@@ -955,24 +997,24 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
         return reject(
           row,
           row.chat_type === "p2p"
-            ? "此对话已不可用，请发送 /new 开始新对话。"
+            ? "此对话已不可用，请发送 /clear 开始新对话。"
             : "此对话已不可用，请另开话题并 @机器人。",
         );
       if (!run.core_session_id) run = await sessions(run.id, {});
       if (
         row.text.startsWith("/") &&
-        row.text !== "/cancel" &&
+        row.text !== "/stop" &&
         !row.text.startsWith("/answer ")
       )
         return reject(
           row,
-          "支持的命令：/new、/cancel、/answer、/help。其他消息会交给 Agent。",
+          "支持的命令：/clear、/stop、/answer、/help。其他消息会交给 Agent。",
         );
       try {
         if (
           media.files.length &&
           !row.files_uploaded &&
-          row.text !== "/cancel"
+          row.text !== "/stop"
         ) {
           const session = await core(
             `/v1/agents/sessions/${run.core_session_id}`,
@@ -992,7 +1034,7 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
           store.put("feishu_inbound", row);
         }
         let answer;
-        if (!row.event && row.text !== "/cancel") {
+        if (!row.event && row.text !== "/stop") {
           const session = await core(
             `/v1/agents/sessions/${run.core_session_id}`,
             "GET",
@@ -1021,7 +1063,7 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
         const event =
           row.event ||
           answer ||
-          (row.text === "/cancel"
+          (row.text === "/stop"
             ? { type: "agent.session.input.cancel" }
             : {
                 type: "agent.session.input.message",
@@ -1063,11 +1105,11 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
       } catch (error) {
         if (
           row.chat_type === "p2p" &&
-          row.text !== "/cancel" &&
+          row.text !== "/stop" &&
           (error?.code === "environment_unavailable" ||
             /environment is no longer available/i.test(error?.message || ""))
         ) {
-          rotateP2PThread();
+          rotateThread();
           row = {
             ...row,
             state: "queued",
@@ -1079,7 +1121,7 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
         }
         throw error;
       }
-      if (row.text === "/cancel")
+      if (row.text === "/stop")
         queueReply(
           stableId(`${row.id}:cancel`),
           thread,
@@ -1476,7 +1518,7 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
     const cancellations = new Map();
     for (const row of rows)
       if (
-        row.text === "/cancel" &&
+        row.text === "/stop" &&
         ["queued", "submitting"].includes(row.state)
       )
         cancellations.set(row.thread_id, row);
@@ -1502,7 +1544,7 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
       let row = store.get("feishu_inbound", original.id);
       if (
         !allowed(row.app_id, row.chat_type) ||
-        row.text === "/cancel" ||
+        row.text === "/stop" ||
         ["delivered", "failed", "rejected"].includes(row.state) ||
         blocked.has(row.thread_id)
       )
diff --git a/example/parsar/tests/feishu.test.mjs b/example/parsar/tests/feishu.test.mjs
index 1cc3200c1..453c74ba7 100644
--- a/example/parsar/tests/feishu.test.mjs
+++ b/example/parsar/tests/feishu.test.mjs
@@ -267,7 +267,7 @@ test("Feishu commands do not poison new topics and rejected controls do not bloc
     ...f.message,
     messageId: "om_cancel",
     rootId: "om_first",
-    content: "/cancel",
+    content: "/stop",
   });
   await w.tick();
   assert.ok(
@@ -530,7 +530,7 @@ test("Feishu cancellation bypasses busy follow-ups and withdraws them permanentl
     ...f.message,
     messageId: "om_stop",
     rootId: "om_first",
-    content: "/cancel",
+    content: "/stop",
   });
   await w.tick();
   assert.deepEqual(events, [
@@ -554,7 +554,7 @@ test("Feishu can withdraw an unstarted conversation and recover a lost creation
     ...f.message,
     messageId: "om_stop",
     rootId: "om_first",
-    content: "/cancel",
+    content: "/stop",
   });
   await w.tick();
   assert.equal(f.receipts.size, 0);
@@ -570,7 +570,7 @@ test("Feishu can withdraw an unstarted conversation and recover a lost creation
     ...f.message,
     messageId: "om_cancel_pending",
     rootId: "om_new",
-    content: "/cancel",
+    content: "/stop",
   });
   await w.tick();
   assert.equal(f.store.list("sessions").length, 1);
@@ -924,25 +924,27 @@ test("Feishu context never reads earlier group messages", async () => {
   assert.equal(context.notice, "");
 });
 
-test("Feishu group reset explains how to start a fresh conversation", async (t) => {
+test("/clear in a topic stops its work and the next message there starts a new conversation", async (t) => {
   const f = await feishu(t),
     worker = f.create();
   worker.receive("cli_0123456789abcdef", f.message);
   await worker.tick();
-  const run = f.store.list("sessions")[0];
-  worker.receive("cli_0123456789abcdef", {
-    ...f.message,
-    messageId: "om_reset",
-    rootId: "om_first",
-    content: "/new",
-  });
+  const [run] = f.store.list("sessions");
+  f.resources.get(run.core_session_id).status = "in_progress";
+  worker.receive("cli_0123456789abcdef", { ...f.message, messageId: "om_clear", rootId: "om_first", content: "/clear" });
   await worker.tick();
-  assert.ok(
-    f.store
-      .list("feishu_outbound")
-      .some((row) => row.payload.includes("群聊请另开话题")),
-  );
-  assert.equal(f.store.list("sessions")[0].id, run.id);
+  const stopped = f.calls.find((x) => x.body?.events?.[0].type === "agent.session.input.cancel");
+  assert.ok(stopped, "running work in the cleared conversation is stopped");
+  assert.ok(stopped.path.includes(run.core_session_id));
+  assert.ok(f.store.list("feishu_outbound").some((row) => row.payload.includes("已清空这个话题的上下文")));
+  worker.receive("cli_0123456789abcdef", { ...f.message, messageId: "om_after", rootId: "om_first", content: "Start over" });
+  await worker.tick();
+  const sessions = f.store.list("sessions");
+  assert.equal(sessions.length, 2, "the topic now has a new conversation");
+  const fresh = sessions.find((row) => row.id !== run.id);
+  assert.equal(fresh.name, "Start over");
+  assert.equal(f.store.list("feishu_threads").length, 1, "the topic keeps one thread");
+  assert.equal(f.store.list("feishu_threads")[0].session_id, fresh.id);
 });
 
 test("Feishu terminal results survive histories beyond one hundred pages", async (t) => {
@@ -1078,14 +1080,16 @@ test("Feishu updates a single card in place with thinking and steps, omits Web t
   assert.equal(firstCard.schema, "2.0");
   assert.equal(firstCard.config.summary.content, "处理中");
   assert.deepEqual(firstCard.header, { title: { tag: "plain_text", content: "处理中" }, template: "blue" });
-  // One chronological timeline: commentary as text, the command visible.
+  // One chronological timeline: only commentary stays open.
   const [current, said, ran] = firstCard.body.elements;
   assert.match(current.content, /正在整理结果/);
   assert.match(current.content, /2 步/);
   assert.equal(said.tag, "markdown");
   assert.equal(said.content, "先读取飞书技能文档。");
-  assert.equal(ran.tag, "markdown", "a command without output has nothing to fold");
-  assert.match(ran.content, /运行.*`cat \/workspace\/\.agents\/skills\/lark-shared\/SKILL\.md`.*0\.4s/);
+  assert.equal(ran.tag, "collapsible_panel");
+  assert.equal(ran.expanded, false);
+  assert.match(ran.header.title.content, /运行.*`cat \/workspace\/\.agents\/skills\/lark-shar…`.*0\.4s/);
+  assert.match(ran.elements[0].content, /`cat \/workspace\/\.agents\/skills\/lark-shared\/SKILL\.md`/);
 
   finishTurn = true;
   items.push({
@@ -1109,7 +1113,7 @@ test("Feishu updates a single card in place with thinking and steps, omits Web t
   assert.equal(process.expanded, false);
   assert.match(process.header.title.content, /处理过程 · 2 步/);
   assert.equal(process.elements[0].content, "先读取飞书技能文档。");
-  assert.match(process.elements[1].content, /`cat \/workspace/);
+  assert.match(process.elements[1].elements[0].content, /`cat \/workspace/);
   assert.doesNotMatch(
     JSON.stringify(patchedCard),
     /任务编号|在 Web 会话下载|Parsar/,
@@ -1556,7 +1560,7 @@ test("Feishu SDK uploads multipart bytes and preserves definite rejection and re
   await assert.rejects(disconnected.upload(Buffer.from("file"), "file.txt"), (error) => error.status === 503 && !error.message.includes("private-network-data"));
 });
 
-test("the timeline joins tool results, keeps commands visible and folds their diagnostics", async () => {
+test("consecutive tool calls fold into one row, each joined with its result and folding its diagnostics", async () => {
   const { formatTurnCard } = await import("../server/feishu.mjs");
   const card = JSON.parse(formatTurnCard("in_progress", [
     { type: "reasoning", summary: [{ text: "先检查接口，再处理结果。" }] },
@@ -1565,10 +1569,13 @@ test("the timeline joins tool results, keeps commands visible and folds their di
     { type: "command_execution", command: "pwd", cwd: "/workspace", output: "/workspace", exit_code: 0, duration_ms: 420, status: "completed" },
     { type: "mcp_call", name: "read", server_label: "docs", arguments: { id: 3 }, status: "incomplete" },
   ]));
-  const [current, thought, lookup, pwd, read] = card.body.elements;
-  assert.match(current.content, /4 步/);
+  const [current, thought, calls] = card.body.elements;
+  assert.match(current.content, /2 步/);
   assert.match(thought.header.title.content, /思考.*先检查接口/);
   assert.equal(thought.elements[0].content, "先检查接口，再处理结果。");
+  assert.equal(calls.tag, "collapsible_panel");
+  assert.match(calls.header.title.content, /调用 3 次工具.*<font color='red'>失败 1 次<\/font>/);
+  const [lookup, pwd, read] = calls.elements;
   assert.match(lookup.header.title.content, /调用工具.*`lookup`.*<font color='red'>失败<\/font>/);
   const literal = lookup.elements[0].text;
   assert.equal(literal.tag, "plain_text");
@@ -1689,7 +1696,7 @@ test("large multilingual diagnostics stay below the Feishu card payload limit",
   for (const status of ["in_progress", "completed", "requires_action"]) {
     const payload = formatTurnCard(status, items, undefined, undefined, [{ arguments: { question: large, options: [large] } }]);
     assert.ok(Buffer.byteLength(payload) < 30000, `${status}: ${Buffer.byteLength(payload)}`);
-    assert.match(payload, /更早的 \d+ 步见网页对话/, "the oldest rows leave the card first");
+    assert.match(payload, /更早的 \d+ (步|次调用)见网页对话/, "the oldest rows leave the card first");
     assert.match(payload, /内容较长，已截取/);
   }
 });
@@ -1986,14 +1993,17 @@ test("completed-turn cursors release answered questions before the next turn", a
 
 test("a running card shows the latest four steps and folds the earlier ones", async () => {
   const { formatTurnCard } = await import("../server/feishu.mjs");
-  const items = Array.from({ length: 7 }, (_, i) => ({ type: "command_execution", command: `step ${i + 1}`, duration_ms: 1000, status: "completed" }));
-  items.push({ type: "command_execution", command: "step 8", status: "in_progress" });
+  const items = [1, 2, 3, 4].flatMap((i) => [
+    { type: "message", role: "assistant", content: [{ type: "output_text", text: `说明 ${i}` }] },
+    { type: "command_execution", command: `step ${i}`, duration_ms: 1000, status: i === 4 ? "in_progress" : "completed" },
+  ]);
   const [current, earlier, ...recent] = JSON.parse(formatTurnCard("in_progress", items)).body.elements;
+  const label = (row) => row.tag === "markdown" ? row.content : row.header.title.content.match(/`(.*)`/)[1];
   assert.match(current.content, /正在运行.*8 步/);
   assert.equal(earlier.tag, "collapsible_panel");
   assert.equal(earlier.expanded, false);
   assert.match(earlier.header.title.content, /更早的 4 步/);
-  assert.deepEqual(earlier.elements.map((row) => row.content.match(/`(.*)`/)[1]), ["step 1", "step 2", "step 3", "step 4"]);
-  assert.deepEqual(recent.map((row) => row.content.match(/`(.*)`/)[1]), ["step 5", "step 6", "step 7", "step 8"]);
-  assert.match(recent.at(-1).content, /进行中/);
+  assert.deepEqual(earlier.elements.map(label), ["说明 1", "step 1", "说明 2", "step 2"]);
+  assert.deepEqual(recent.map(label), ["说明 3", "step 3", "说明 4", "step 4"]);
+  assert.match(recent.at(-1).header.title.content, /进行中/);
 });

From 08ba416420aeced647b6064bafaa78f92a774794 Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Sun, 25 Oct 2026 22:24:27 +0800
Subject: [PATCH 03/19] Move the Feishu running status into the header and tint
 folded history

The running card's status line took the first body row. The header now
carries what is happening and how many steps have run, so the timeline
starts the body. Earlier steps and a finished card's process sit in a
tinted, rounded block, and a divider separates earlier steps from the
latest ones.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/README.md             |  2 +-
 example/parsar/README.zh.md          |  4 +--
 example/parsar/server/feishu.mjs     | 39 ++++++++++++++++++----------
 example/parsar/tests/feishu.test.mjs | 25 +++++++++++-------
 4 files changed, 44 insertions(+), 26 deletions(-)

diff --git a/example/parsar/README.md b/example/parsar/README.md
index ee75259c1..4ce16f1bb 100644
--- a/example/parsar/README.md
+++ b/example/parsar/README.md
@@ -123,7 +123,7 @@ Optional business questions use the declared `ask_user` function. They appear in
 4. Text, rich posts, images, files, audio and video, quoted messages and merged forwards are normalized before dispatch. Attachment limits are eight resources and 5 MiB total. Follow-up files wait until the conversation is idle. Quoted messages are read up to four levels; earlier group messages are not read.
 5. Commands: `/clear` clears the context: it stops any running work and the next message starts a new conversation, in a private chat or in the same group topic. `/stop` stops the current task; it takes priority over queued follow-ups and recovers an uncertain creation before stopping it. `/answer <call_id> <text>` answers a pending business question, and a plain reply answers when only one is pending. `/help` lists the commands.
 
-Accepted messages are committed to SQLite before the WebSocket ACK; request IDs and frozen payloads survive retries and restarts. The worker edits one compact progress card in place, includes any pending business question in that card, and finishes it with the result. Each reply shows only the current exchange, including answers that resume the same Core Turn. The answer stays visible; while awaiting a business decision, the question takes priority and its supporting context is collapsed, except QR authorization instructions. The card has a colored header for its status. Its process is one timeline in the order things happened. Only commentary stays open as plain text; thinking folds behind its first sentence, and consecutive tool calls fold into one row (such as `运行 3 条命令` with their total time, failures or 进行中) in which each call folds again behind its command, showing parameters, output, error and exit code. A running card shows the latest four steps and folds the earlier ones; a finished card puts the answer first and folds the whole process into **处理过程**; a failed card shows the failed step right under its cause. Long content is cut to marked, byte-bounded excerpts, and the oldest steps leave the card first to stay within Feishu's card size limit. Progress uses five-second polling. Complete history and Artifacts remain in the Web conversation. Settled threads stop polling after five minutes and wake on new messages. **消息记录** lists the latest 100 deliveries plus unresolved ones; **重试** keeps the original identity. A failed inbound message blocks later messages in that thread. Uncertain outbound sends are not replayed beyond 55 minutes. Disabling a bot pauses delivery without cancelling Core work.
+Accepted messages are committed to SQLite before the WebSocket ACK; request IDs and frozen payloads survive retries and restarts. The worker edits one compact progress card in place, includes any pending business question in that card, and finishes it with the result. Each reply shows only the current exchange, including answers that resume the same Core Turn. The answer stays visible; while awaiting a business decision, the question takes priority and its supporting context is collapsed, except QR authorization instructions. The card has a colored header for its status. Its process is one timeline in the order things happened. Only commentary stays open as plain text; thinking folds behind its first sentence, and consecutive tool calls fold into one row (such as `运行 3 条命令` with their total time, failures or 进行中) in which each call folds again behind its command, showing parameters, output, error and exit code. While running, the header also says what is happening now and how many steps have run. A running card shows the latest four steps and folds the earlier ones into a tinted block above a divider; a finished card puts the answer first and folds the whole process into a tinted **处理过程** block; a failed card shows the failed step right under its cause. Long content is cut to marked, byte-bounded excerpts, and the oldest steps leave the card first to stay within Feishu's card size limit. Progress uses five-second polling. Complete history and Artifacts remain in the Web conversation. Settled threads stop polling after five minutes and wake on new messages. **消息记录** lists the latest 100 deliveries plus unresolved ones; **重试** keeps the original identity. A failed inbound message blocks later messages in that thread. Uncertain outbound sends are not replayed beyond 55 minutes. Disabling a bot pauses delivery without cancelling Core work.
 
 ### Bot identity
 
diff --git a/example/parsar/README.zh.md b/example/parsar/README.zh.md
index dce57e365..df9936711 100644
--- a/example/parsar/README.zh.md
+++ b/example/parsar/README.zh.md
@@ -1,6 +1,6 @@
 ---
 source: example/parsar/README.md
-source_hash: e82aa7249febf32add4459dabd95f6814b2cade69d0bd5ab962cad2f12d10acb
+source_hash: 91f8e0d2abc4d4bb989358f846e6b212fbb38e764a953a1d175c17e6b3c640ea
 ---
 
 # Parsar 工作空间
@@ -128,7 +128,7 @@ Parsar 会跟踪每一轮正在执行的对话，网页和飞书都一样。出
 4. 文本、富文本、图片、文件、音视频、引用消息和合并转发会在投递前规范化。附件上限为 8 个、合计 5 MiB。后续消息中的文件会等到对话空闲后写入。引用消息最多读取四层；不读取更早的群消息。
 5. 命令：`/clear` 清空上下文：停止正在执行的任务，下一条消息开始新对话，私聊和群聊话题都适用（群聊仍在同一个话题里）。`/stop` 停止当前任务，优先于排队中的追问，并会先确认不确定的创建再停止。`/answer <call_id> <回答>` 回答待处理的业务问题；只有一个待回答的问题时，直接回复即可。`/help` 列出这些命令。
 
-收到的消息在 WebSocket ACK 之前写入 SQLite；请求 ID 和冻结的负载在重试与重启后保持不变。工作器原地更新一张简洁进度卡片，将待回答的问题合并到卡片中，结束后改成结果。每次回复只展示当前交流的内容，包括回答提问后继续同一 Core Turn 的情况。正文突出当前回复；等待业务选择时优先展示问题，将补充说明折叠，二维码授权说明保持可见。卡片顶部是带颜色的状态标题栏。处理过程按发生顺序排成一条时间线。只有说明直接显示文字；思考折叠在第一句后面；连续的工具调用折叠成一行（例如“运行 3 条命令”，附总用时、失败次数或“进行中”），展开后每次调用再折叠在它的命令后面，可查看参数、输出、错误和退出码。执行中的卡片显示最近四步，更早的步骤折叠；完成后回复放在最前面，整个过程折叠成 **处理过程**；失败时出错的那一步紧跟在失败原因下面。长内容按字节限制截取并明确标注；为了不超过飞书卡片的大小限制，最早的步骤会先移出卡片。进度每五秒轮询一次。完整历史和 Artifacts 保留在网页对话中。已结束的话题在五分钟后停止轮询，收到新消息时恢复。**消息记录** 列出最近 100 条投递以及未解决的记录；**重试** 保留原有标识。入站消息失败会阻塞该话题后续消息。不确定的出站消息超过 55 分钟后不再重放。停用机器人会暂停投递，但不会取消 Core 中的执行。
+收到的消息在 WebSocket ACK 之前写入 SQLite；请求 ID 和冻结的负载在重试与重启后保持不变。工作器原地更新一张简洁进度卡片，将待回答的问题合并到卡片中，结束后改成结果。每次回复只展示当前交流的内容，包括回答提问后继续同一 Core Turn 的情况。正文突出当前回复；等待业务选择时优先展示问题，将补充说明折叠，二维码授权说明保持可见。卡片顶部是带颜色的状态标题栏。处理过程按发生顺序排成一条时间线。只有说明直接显示文字；思考折叠在第一句后面；连续的工具调用折叠成一行（例如“运行 3 条命令”，附总用时、失败次数或“进行中”），展开后每次调用再折叠在它的命令后面，可查看参数、输出、错误和退出码。执行中时，标题栏还会显示当前在做什么和已执行的步数；卡片显示最近四步，更早的步骤折叠进分隔线上方的浅色区块；完成后回复放在最前面，整个过程折叠进浅色的 **处理过程** 区块；失败时出错的那一步紧跟在失败原因下面。长内容按字节限制截取并明确标注；为了不超过飞书卡片的大小限制，最早的步骤会先移出卡片。进度每五秒轮询一次。完整历史和 Artifacts 保留在网页对话中。已结束的话题在五分钟后停止轮询，收到新消息时恢复。**消息记录** 列出最近 100 条投递以及未解决的记录；**重试** 保留原有标识。入站消息失败会阻塞该话题后续消息。不确定的出站消息超过 55 分钟后不再重放。停用机器人会暂停投递，但不会取消 Core 中的执行。
 
 ### 机器人身份 {#bot-identity}
 
diff --git a/example/parsar/server/feishu.mjs b/example/parsar/server/feishu.mjs
index e5fbf6395..9b0e74382 100644
--- a/example/parsar/server/feishu.mjs
+++ b/example/parsar/server/feishu.mjs
@@ -192,16 +192,18 @@ function excerpt(value, limit) {
   return prefix.join("") + "\n…（内容较长，已截取）";
 }
 
-function panel({ title, content, elements }) {
+// A `block` panel is a tinted, rounded area that holds folded history.
+function panel({ title, content, elements, block = false }) {
   return {
     tag: "collapsible_panel",
     expanded: false,
     vertical_spacing: "8px",
-    padding: "0px 0px 8px 0px",
+    padding: block ? "0px 12px 8px 12px" : "0px 0px 8px 0px",
+    ...(block && { background_color: "grey-50", border: { color: "grey-50", corner_radius: "8px" } }),
     header: {
       title: { tag: "markdown", content: title },
       width: "fill",
-      padding: "6px 0px 6px 0px",
+      padding: block ? "8px 0px 8px 0px" : "6px 0px 6px 0px",
       icon: { tag: "standard_icon", token: "down-small-ccm_outlined", size: "16px 16px" },
       icon_position: "right",
       icon_expanded_angle: -180,
@@ -214,17 +216,24 @@ function panel({ title, content, elements }) {
 const cardBudget = 28000;
 const bytes = (value) => Buffer.byteLength(JSON.stringify(value));
 
-function statusCard(status, body, elements = []) {
+// The colored header carries the status and, while running, what is
+// happening now, so the body starts with the content.
+function statusCard(status, body, elements = [], subtitle = "") {
   const [title, template] = cardTones[status] || cardTones.failed;
+  // A card needs a body; with nothing else to show, what is happening is the body.
+  if (!body && !elements.length && subtitle) [body, subtitle] = [`**${subtitle}**`, ""];
   return JSON.stringify({
     schema: "2.0",
-    config: { update_multi: true, summary: { content: title } },
-    // The colored header carries the status, so the body starts with the content.
-    header: { title: { tag: "plain_text", content: title }, template },
+    config: { update_multi: true, summary: { content: subtitle ? `${title} · ${subtitle}` : title } },
+    header: {
+      title: { tag: "plain_text", content: title },
+      ...(subtitle && { subtitle: { tag: "plain_text", content: subtitle } }),
+      template,
+    },
     body: {
       padding: "12px 16px 12px 16px",
       vertical_spacing: "8px",
-      elements: [{ tag: "markdown", content: body }, ...elements],
+      elements: [...(body ? [{ tag: "markdown", content: body }] : []), ...elements],
     },
   });
 }
@@ -243,7 +252,7 @@ export function feishuCard(payload) {
 }
 
 export function progressCard(text, notice) {
-  return statusCard("in_progress", `**${text}**${notice ? `\n${grey(notice)}` : ""}`);
+  return statusCard("in_progress", notice ? grey(notice) : "", [], text);
 }
 
 function questionText(action, includeOptions = true) {
@@ -391,12 +400,16 @@ export function formatTurnCard(status, items = [], error, turn, questions = [])
     const current = !last ? waitingHeadline(turn) : last.type === "message" ? "正在整理回复" : last.type === "reasoning" ? "正在思考" : last.status === "in_progress" ? `正在${step(last)[0]}` : "正在整理结果";
     const typical = !last && turn?.expected_s && turn.stage !== "retrying" ? typicalWait.replace("{{value0}}", turn.expected_s) : "";
     const progress = rows.length ? `${rows.length} 步` : typical;
-    const body = excerpt([`**${current}**${progress ? ` ${grey(`· ${progress}`)}` : ""}`, authorizationText].filter(Boolean).join("\n"), 8000);
+    const subtitle = [current, progress].filter(Boolean).join(" · ");
+    const body = authorizationText ? excerpt(authorizationText, 8000) : "";
     const earlier = rows.slice(0, -recentRows), recent = rows.slice(-recentRows);
     const budget = cardBudget - bytes(body);
     const shown = fitRows(recent, budget);
-    const fold = earlier.length ? [panel({ title: grey(`更早的 ${earlier.length} 步`), elements: fitRows(earlier, budget - bytes(shown)) })] : [];
-    return statusCard(status, body, [...fold, ...shown]);
+    // Earlier steps sit in a tinted block above a rule that separates the latest ones.
+    const fold = earlier.length
+      ? [panel({ title: grey(`更早的 ${earlier.length} 步`), elements: fitRows(earlier, budget - bytes(shown)), block: true }), { tag: "hr" }]
+      : [];
+    return statusCard(status, body, [...fold, ...shown], subtitle);
   }
   const context = questions.some((action) => questionText(action, false).trim() === answer.trim()) ? "" : answer;
   // Put the decision first; keep its explanation available without filling the chat.
@@ -414,7 +427,7 @@ export function formatTurnCard(status, items = [], error, turn, questions = [])
   if (failedTool) elements.push(toolRow(failedTool));
   if (rows.length) {
     const budget = cardBudget - bytes(body) - bytes(elements);
-    elements.push(panel({ title: grey(`处理过程 · ${rows.length} 步`), elements: fitRows(rows, budget) }));
+    elements.push(panel({ title: grey(`处理过程 · ${rows.length} 步`), elements: fitRows(rows, budget), block: true }));
   }
   return statusCard(status, body, elements.length ? [{ tag: "hr" }, ...elements] : []);
 }
diff --git a/example/parsar/tests/feishu.test.mjs b/example/parsar/tests/feishu.test.mjs
index 453c74ba7..467368b00 100644
--- a/example/parsar/tests/feishu.test.mjs
+++ b/example/parsar/tests/feishu.test.mjs
@@ -1078,12 +1078,14 @@ test("Feishu updates a single card in place with thinking and steps, omits Web t
   assert.equal(f.sent.length, 1);
   const firstCard = JSON.parse(f.sent[0].data.content);
   assert.equal(firstCard.schema, "2.0");
-  assert.equal(firstCard.config.summary.content, "处理中");
-  assert.deepEqual(firstCard.header, { title: { tag: "plain_text", content: "处理中" }, template: "blue" });
-  // One chronological timeline: only commentary stays open.
-  const [current, said, ran] = firstCard.body.elements;
-  assert.match(current.content, /正在整理结果/);
-  assert.match(current.content, /2 步/);
+  assert.equal(firstCard.config.summary.content, "处理中 · 正在整理结果 · 2 步");
+  // The header says what is happening now; the body starts with the timeline.
+  assert.deepEqual(firstCard.header, {
+    title: { tag: "plain_text", content: "处理中" },
+    subtitle: { tag: "plain_text", content: "正在整理结果 · 2 步" },
+    template: "blue",
+  });
+  const [said, ran] = firstCard.body.elements;
   assert.equal(said.tag, "markdown");
   assert.equal(said.content, "先读取飞书技能文档。");
   assert.equal(ran.tag, "collapsible_panel");
@@ -1569,8 +1571,8 @@ test("consecutive tool calls fold into one row, each joined with its result and
     { type: "command_execution", command: "pwd", cwd: "/workspace", output: "/workspace", exit_code: 0, duration_ms: 420, status: "completed" },
     { type: "mcp_call", name: "read", server_label: "docs", arguments: { id: 3 }, status: "incomplete" },
   ]));
-  const [current, thought, calls] = card.body.elements;
-  assert.match(current.content, /2 步/);
+  assert.match(card.header.subtitle.content, /2 步/);
+  const [thought, calls] = card.body.elements;
   assert.match(thought.header.title.content, /思考.*先检查接口/);
   assert.equal(thought.elements[0].content, "先检查接口，再处理结果。");
   assert.equal(calls.tag, "collapsible_panel");
@@ -1997,12 +1999,15 @@ test("a running card shows the latest four steps and folds the earlier ones", as
     { type: "message", role: "assistant", content: [{ type: "output_text", text: `说明 ${i}` }] },
     { type: "command_execution", command: `step ${i}`, duration_ms: 1000, status: i === 4 ? "in_progress" : "completed" },
   ]);
-  const [current, earlier, ...recent] = JSON.parse(formatTurnCard("in_progress", items)).body.elements;
+  const card = JSON.parse(formatTurnCard("in_progress", items));
+  const [earlier, rule, ...recent] = card.body.elements;
   const label = (row) => row.tag === "markdown" ? row.content : row.header.title.content.match(/`(.*)`/)[1];
-  assert.match(current.content, /正在运行.*8 步/);
+  assert.equal(card.header.subtitle.content, "正在运行 · 8 步");
   assert.equal(earlier.tag, "collapsible_panel");
   assert.equal(earlier.expanded, false);
   assert.match(earlier.header.title.content, /更早的 4 步/);
+  assert.equal(earlier.background_color, "grey-50", "earlier steps sit in a tinted block");
+  assert.equal(rule.tag, "hr", "a rule separates them from the latest steps");
   assert.deepEqual(earlier.elements.map(label), ["说明 1", "step 1", "说明 2", "step 2"]);
   assert.deepEqual(recent.map(label), ["说明 3", "step 3", "说明 4", "step 4"]);
   assert.match(recent.at(-1).header.title.content, /进行中/);

From 5020762a33ff75007b91737af44267c4c7d9e576 Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Sun, 25 Oct 2026 22:57:37 +0800
Subject: [PATCH 04/19] Keep Feishu results in their own card and Markdown
 images out of cards
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Feishu treats any Markdown image as an image key and rejects the whole
card. Thinking that quoted the authorization QR image made every edit of
that Turn's card fail, silently, so the card stayed 处理中. When the next
message arrived, the older Turn's result took the new message's progress
card (with its content cut by the new display boundary), and the new
Turn's answer edited the topic's first card instead.

Markdown images now become text in every card row. Each Turn's result goes
to the progress card of the input it answers, found through the Turn
ledger; an older Turn never takes a newer message's card, and there is no
fallback to the conversation's first card. An older Turn shows all of its
items. Observation failures are logged.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/server/feishu.mjs     | 156 +++++++++++++++------------
 example/parsar/server/turns.mjs      |   5 +-
 example/parsar/tests/feishu.test.mjs |  68 +++++++++---
 3 files changed, 141 insertions(+), 88 deletions(-)

diff --git a/example/parsar/server/feishu.mjs b/example/parsar/server/feishu.mjs
index 9b0e74382..d05185268 100644
--- a/example/parsar/server/feishu.mjs
+++ b/example/parsar/server/feishu.mjs
@@ -197,13 +197,14 @@ function panel({ title, content, elements, block = false }) {
   return {
     tag: "collapsible_panel",
     expanded: false,
-    vertical_spacing: "8px",
-    padding: block ? "0px 12px 8px 12px" : "0px 0px 8px 0px",
+    vertical_spacing: "4px",
+    padding: block ? "0px 12px 8px 12px" : "0px 0px 4px 0px",
     ...(block && { background_color: "grey-50", border: { color: "grey-50", corner_radius: "8px" } }),
     header: {
       title: { tag: "markdown", content: title },
       width: "fill",
-      padding: block ? "8px 0px 8px 0px" : "6px 0px 6px 0px",
+      // The header ignores the panel padding, so a block indents its own title.
+      padding: block ? "8px 12px 8px 12px" : "2px 0px 2px 0px",
       icon: { tag: "standard_icon", token: "down-small-ccm_outlined", size: "16px 16px" },
       icon_position: "right",
       icon_expanded_angle: -180,
@@ -217,22 +218,19 @@ const cardBudget = 28000;
 const bytes = (value) => Buffer.byteLength(JSON.stringify(value));
 
 // The colored header carries the status and, while running, what is
-// happening now, so the body starts with the content.
+// happening now on the same line, so the body starts with the content.
 function statusCard(status, body, elements = [], subtitle = "") {
   const [title, template] = cardTones[status] || cardTones.failed;
   // A card needs a body; with nothing else to show, what is happening is the body.
   if (!body && !elements.length && subtitle) [body, subtitle] = [`**${subtitle}**`, ""];
+  const heading = subtitle ? `${title} · ${subtitle}` : title;
   return JSON.stringify({
     schema: "2.0",
-    config: { update_multi: true, summary: { content: subtitle ? `${title} · ${subtitle}` : title } },
-    header: {
-      title: { tag: "plain_text", content: title },
-      ...(subtitle && { subtitle: { tag: "plain_text", content: subtitle } }),
-      template,
-    },
+    config: { update_multi: true, summary: { content: heading } },
+    header: { title: { tag: "plain_text", content: heading }, template },
     body: {
       padding: "12px 16px 12px 16px",
-      vertical_spacing: "8px",
+      vertical_spacing: "6px",
       elements: [...(body ? [{ tag: "markdown", content: body }] : []), ...elements],
     },
   });
@@ -277,12 +275,32 @@ function step(item) {
   return ["执行步骤", item.name || item.type || ""];
 }
 
+// Wide (CJK and full-width) characters take two columns in a card; general
+// punctuation such as the ellipsis is narrow.
+const wide = (char) => {
+  const code = char.codePointAt(0);
+  return code >= 0x1100 && !(code >= 0x2000 && code <= 0x206f);
+};
+const columns = (text) => [...text].reduce((sum, char) => sum + (wide(char) ? 2 : 1), 0);
 const clip = (value, limit) => {
   const text = String(value ?? "").replace(/\s+/g, " ").trim();
-  return text.length > limit ? `${text.slice(0, limit - 1)}…` : text;
+  if (columns(text) <= limit) return text;
+  let kept = "";
+  for (const char of text) {
+    if (columns(kept + char) > limit - 1) break;
+    kept += char;
+  }
+  return `${kept}…`;
 };
 // Markdown and Feishu tags stay literal inside a one-line title.
 const literal = (value) => value.replace(/[<>]/g, "").replaceAll("`", "'");
+// Thinking and tool rows stay on one line: the detail gets what the label
+// and state leave of the row.
+const rowColumns = 52;
+const oneLine = (label, detail, state = "") => {
+  const room = rowColumns - columns(label) - columns(state.replace(/<[^>]*>/g, "")) - 2;
+  return [grey(label), detail ? literal(clip(detail, Math.max(8, room))) : "", state].filter(Boolean).join(" ");
+};
 
 const toolState = (item) =>
   item.status === "failed"
@@ -298,8 +316,10 @@ const toolState = (item) =>
 // One tool call: the command is the title, its result folds below it.
 function toolRow(item) {
   const [label, detail] = step(item);
-  const title = [grey(label), detail ? `\`${literal(clip(detail, 200))}\`` : "", toolState(item)].filter(Boolean).join(" ");
+  const title = oneLine(label, detail, toolState(item));
   const fields = [
+    // A shortened title keeps the whole command one click away.
+    ["命令", item.command && title.includes("…") ? detail : undefined],
     ["参数", item.command ? undefined : item.arguments ?? item.action],
     ["输出", item.output], ["错误", item.error], ["退出码", item.exit_code],
   ].filter(([, value]) => value !== undefined && value !== null && value !== "");
@@ -323,16 +343,16 @@ function toolsRow(items) {
         : "";
   const [label, detail] = step(items[0]);
   const title = items.length === 1
-    ? [grey(label), detail ? `\`${literal(clip(detail, 40))}\`` : "", state]
-    : [grey(items.every((item) => step(item)[0] === "运行") ? `运行 ${items.length} 条命令` : `调用 ${items.length} 次工具`), state];
-  return panel({ title: title.filter(Boolean).join(" "), elements: items.map(toolRow) });
+    ? oneLine(label, detail, state)
+    : [grey(items.every((item) => step(item)[0] === "运行") ? `运行 ${items.length} 条命令` : `调用 ${items.length} 次工具`), state].filter(Boolean).join(" ");
+  return panel({ title, elements: items.map(toolRow) });
 }
 
 // Only commentary stays open; thinking and tool calls fold behind one line.
 function timelineRow(entry) {
   if (entry.type === "say") return { tag: "markdown", content: excerpt(entry.text, 800) };
   if (entry.type === "think")
-    return panel({ title: `${grey("思考")} ${literal(clip(entry.text.split("\n").find((line) => line.trim()) || "", 40))}`, content: excerpt(entry.text, 1500) });
+    return panel({ title: oneLine("思考", entry.text.split("\n").find((line) => line.trim()) || ""), content: excerpt(entry.text, 1500) });
   return toolsRow(entry.items);
 }
 
@@ -366,9 +386,12 @@ export function formatTurnCard(status, items = [], error, turn, questions = [])
   const text = (item) => (item.content || []).filter((p) => p.type === "output_text").map((p) => (p.text || "").trim()).filter(Boolean).join("\n");
   const messages = items.filter((x) => x.type === "message" && x.role === "assistant");
   const latest = messages.at(-1);
+  // Feishu reads any Markdown image as an image key and rejects the whole
+  // card, so images become text; the files themselves are sent as messages.
   const readable = (value) => value
     .replace(/!\[[^\]\n]*\]\((\/app\/feishu\/provision\/[a-f0-9-]{36}\/qrcode)\)/g, "（授权二维码见图片消息）")
-    .replace(/!?\[([^\]]*)\]\((?:\/workspace\/|\.\/)?outputs\/[^)]*\)/g, "$1（见附件）");
+    .replace(/!?\[([^\]]*)\]\((?:\/workspace\/|\.\/)?outputs\/[^)]*\)/g, "$1（见附件）")
+    .replace(/!\[([^\]\n]*)\]\([^)\n]*\)/g, (_, alt) => alt ? `（图片：${alt}）` : "（图片）");
   const authorization = messages.filter((item) => qrImages(text(item)).length);
   const authorizationText = authorization.map((item) => readable(text(item))).join("\n\n");
   const answer = latest?.phase === "commentary" || authorization.includes(latest) ? "" : latest ? readable(text(latest)) : "";
@@ -376,7 +399,7 @@ export function formatTurnCard(status, items = [], error, turn, questions = [])
   // Thinking, commentary and tool calls in the order they happened.
   const entries = items.flatMap((x) => {
     if (x.type === "reasoning") {
-      const thought = (x.summary || x.content || []).map((p) => typeof p === "string" ? p : p?.text || "").filter(Boolean).join("\n\n").trim();
+      const thought = readable((x.summary || x.content || []).map((p) => typeof p === "string" ? p : p?.text || "").filter(Boolean).join("\n\n").trim());
       return thought ? [{ type: "think", text: thought }] : [];
     }
     if (x.type === "message") {
@@ -1231,10 +1254,14 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
         thread,
         `执行失败\n\n${ledger.summary(run.id)?.failure || "执行环境准备失败，请重新发送消息重试。"}`,
       );
-    const progressId =
-      thread.active_outbound_id ||
-      stableId(`${thread.first_message_id}:accepted`);
-    let progress = store.get("feishu_outbound", progressId);
+    let progress = thread.active_outbound_id && store.get("feishu_outbound", thread.active_outbound_id);
+    // The progress card of the input a Turn answers; an older Turn never takes
+    // the card of a newer message.
+    const cardFor = (turn) => {
+      const entry = ledger.entryFor(run.id, turn.id);
+      const own = entry && store.get("feishu_outbound", stableId(`${entry.kind === "first" ? thread.first_message_id : entry.id}:accepted`));
+      return own || (turn.id === turns.at(-1)?.id ? progress : undefined);
+    };
     const progressReplyTo = progress?.reply_to || thread.root_id;
     const questionBase = progress?.sent_message_id ? progress.id : thread.id;
     if ((progress || session.status === "requires_action") && (["in_progress", "requires_action"].includes(session.status) || recovering) && !unseen.length) {
@@ -1304,67 +1331,53 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
         turnItems.some((item) => item.type === "function_call" && item.call_id === callId) &&
         !turnItems.some((item) => item.type === "function_call_output" && item.call_id === callId))) return;
       queueMedia(thread, turnItems, artifacts.filter((file) => file.turn_id === turn.id));
+      const latest = turn.id === turns.at(-1)?.id;
+      const card = cardFor(turn);
+      // The display boundary belongs to the newest input; an older Turn shows all of itself.
       const text = formatTurnCard(
         turn.status,
-        currentItems.filter((item) => item.turn_id === turn.id),
+        latest ? currentItems.filter((item) => item.turn_id === turn.id) : turnItems,
         turn.status === "failed"
           ? ledger.summary(run.id)?.failure || explainFailure(turn.error)
           : turn.error?.message,
       );
       const receiptId = stableId(`${thread.id}:${turn.id}`);
-      if (progress?.sent_message_id) {
+      const receipt = (sentMessageId) => store.put("feishu_outbound", {
+        id: receiptId,
+        app_id: thread.app_id,
+        chat_id: thread.chat_id,
+        chat_type: thread.chat_type,
+        thread_id: thread.id,
+        reply_to: card.reply_to || thread.root_id,
+        payload: text,
+        notify: false,
+        state: "delivered",
+        sent_message_id: sentMessageId,
+        attempts: 1,
+        created_at: stamp(),
+        next_at: 0,
+      });
+      // The newest message's card is free again once its Turn has its result.
+      const release = () => {
+        if (card.id !== progress?.id) return;
+        thread = { ...thread, progress_text: text, active_outbound_id: undefined };
+        progress = undefined;
+      };
+      if (card?.sent_message_id) {
         try {
-          await channel.edit(progress.sent_message_id, text, thread);
-          store.put("feishu_outbound", { ...progress, payload: text, state: "delivered", error: undefined });
-          store.put("feishu_outbound", {
-            id: receiptId,
-            app_id: thread.app_id,
-            chat_id: thread.chat_id,
-            chat_type: thread.chat_type,
-            thread_id: thread.id,
-            reply_to: progress.reply_to || thread.root_id,
-            payload: text,
-            notify: false,
-            state: "delivered",
-            sent_message_id: progress.sent_message_id,
-            attempts: 1,
-            created_at: stamp(),
-            next_at: 0,
-          });
-          thread = {
-            ...thread,
-            progress_text: text,
-            active_outbound_id: undefined,
-          };
-          progress = undefined;
+          await channel.edit(card.sent_message_id, text, thread);
+          store.put("feishu_outbound", { ...card, payload: text, state: "delivered", error: undefined });
+          receipt(card.sent_message_id);
+          release();
           continue;
         } catch (error) {
           if (error.code !== "feishu_card_unavailable") throw error;
           // A confirmed uneditable card falls back to sending a result card.
         }
-      } else if (progress && progress.state === "queued") {
-        store.put("feishu_outbound", { ...progress, payload: text });
-        store.put("feishu_outbound", {
-          id: receiptId,
-          app_id: thread.app_id,
-          chat_id: thread.chat_id,
-          chat_type: thread.chat_type,
-          thread_id: thread.id,
-          reply_to: progress.reply_to || thread.root_id,
-          payload: text,
-          notify: false,
-          state: "delivered",
-          sent_message_id: progress.id,
-          attempts: 1,
-          created_at: stamp(),
-          next_at: 0,
-        });
-        thread = {
-          ...thread,
-          progress_text: text,
-          active_outbound_id: undefined,
-        };
-        progress = undefined;
+      } else if (card?.state === "queued") {
+        store.put("feishu_outbound", { ...card, payload: text });
+        receipt(card.id);
+        release();
         continue;
       }
       queueReply(receiptId, thread, text);
@@ -1598,6 +1611,7 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
       try {
         await observe(thread);
       } catch (error) {
+        console.error(`Feishu thread ${thread.id}: ${error.message}`);
         health("core_unavailable");
         if (
           !(error instanceof AppError) ||
diff --git a/example/parsar/server/turns.mjs b/example/parsar/server/turns.mjs
index 80fff3ea8..5d53fd8f5 100644
--- a/example/parsar/server/turns.mjs
+++ b/example/parsar/server/turns.mjs
@@ -356,6 +356,9 @@ export function turnsAPI(store, core) {
   const superseded = (sessionId, coreTurnId) =>
     (store.get("sessions", sessionId)?.superseded_turns || []).includes(coreTurnId);
   const recovering = (sessionId) => store.list("turns").some((t) => t.session_id === sessionId && t.outcome === "running");
+  // The recorded input that a Core Turn answers.
+  const entryFor = (sessionId, coreTurnId) =>
+    store.list("turns").find((t) => t.session_id === sessionId && t.core_turn_id === coreTurnId);
 
-  return { start, sendPrepared, deliver, send, monitor, summary, overview, health, retry, superseded, recovering };
+  return { start, sendPrepared, deliver, send, monitor, summary, overview, health, retry, superseded, recovering, entryFor };
 }
diff --git a/example/parsar/tests/feishu.test.mjs b/example/parsar/tests/feishu.test.mjs
index 467368b00..447c14bc4 100644
--- a/example/parsar/tests/feishu.test.mjs
+++ b/example/parsar/tests/feishu.test.mjs
@@ -1080,18 +1080,16 @@ test("Feishu updates a single card in place with thinking and steps, omits Web t
   assert.equal(firstCard.schema, "2.0");
   assert.equal(firstCard.config.summary.content, "处理中 · 正在整理结果 · 2 步");
   // The header says what is happening now; the body starts with the timeline.
-  assert.deepEqual(firstCard.header, {
-    title: { tag: "plain_text", content: "处理中" },
-    subtitle: { tag: "plain_text", content: "正在整理结果 · 2 步" },
-    template: "blue",
-  });
+  assert.deepEqual(firstCard.header, { title: { tag: "plain_text", content: "处理中 · 正在整理结果 · 2 步" }, template: "blue" });
   const [said, ran] = firstCard.body.elements;
   assert.equal(said.tag, "markdown");
   assert.equal(said.content, "先读取飞书技能文档。");
   assert.equal(ran.tag, "collapsible_panel");
   assert.equal(ran.expanded, false);
-  assert.match(ran.header.title.content, /运行.*`cat \/workspace\/\.agents\/skills\/lark-shar…`.*0\.4s/);
-  assert.match(ran.elements[0].content, /`cat \/workspace\/\.agents\/skills\/lark-shared\/SKILL\.md`/);
+  // One line per row: a long command is shortened, and its full text is one click away.
+  assert.match(ran.header.title.content, /运行.* cat \/workspace\/\.agents\/skills\/.*….*0\.4s/);
+  assert.match(ran.elements[0].header.title.content, /运行.* cat \/workspace.*…/);
+  assert.match(ran.elements[0].elements[0].text.content, /命令\ncat \/workspace\/\.agents\/skills\/lark-shared\/SKILL\.md/);
 
   finishTurn = true;
   items.push({
@@ -1115,7 +1113,7 @@ test("Feishu updates a single card in place with thinking and steps, omits Web t
   assert.equal(process.expanded, false);
   assert.match(process.header.title.content, /处理过程 · 2 步/);
   assert.equal(process.elements[0].content, "先读取飞书技能文档。");
-  assert.match(process.elements[1].elements[0].content, /`cat \/workspace/);
+  assert.match(process.elements[1].elements[0].header.title.content, /cat \/workspace/);
   assert.doesNotMatch(
     JSON.stringify(patchedCard),
     /任务编号|在 Web 会话下载|Parsar/,
@@ -1404,7 +1402,7 @@ test("a failure shows its cause with the failed step right below, and a plain an
   assert.equal(card.config.summary.content, "执行失败");
   const [cause, , failed, process] = card.body.elements;
   assert.match(cause.content, /<font color='red'>permission denied<\/font>/);
-  assert.match(failed.content, /运行.*`lark-cli docs \+fetch --doc abc`.*<font color='red'>失败<\/font>/);
+  assert.match(failed.content, /运行.* lark-cli docs \+fetch --doc abc .*<font color='red'>失败<\/font>/);
   assert.match(process.header.title.content, /处理过程 · 1 步/);
   const quiet = JSON.parse(
     formatTurnCard("completed", [
@@ -1435,7 +1433,7 @@ test("web searches appear as readable steps in the Feishu record", async () => {
     ]),
   );
   const search = card.body.elements[2].elements[0];
-  assert.match(search.header.title.content, /搜索网页.*`OpenAgentCore release`/);
+  assert.match(search.header.title.content, /搜索网页.* OpenAgentCore release/);
 });
 
 test("Feishu delivers QR during authorization and artifact media once, retaining uploaded keys after a lost send", async (t) => {
@@ -1571,22 +1569,22 @@ test("consecutive tool calls fold into one row, each joined with its result and
     { type: "command_execution", command: "pwd", cwd: "/workspace", output: "/workspace", exit_code: 0, duration_ms: 420, status: "completed" },
     { type: "mcp_call", name: "read", server_label: "docs", arguments: { id: 3 }, status: "incomplete" },
   ]));
-  assert.match(card.header.subtitle.content, /2 步/);
+  assert.match(card.header.title.content, /2 步/);
   const [thought, calls] = card.body.elements;
   assert.match(thought.header.title.content, /思考.*先检查接口/);
   assert.equal(thought.elements[0].content, "先检查接口，再处理结果。");
   assert.equal(calls.tag, "collapsible_panel");
   assert.match(calls.header.title.content, /调用 3 次工具.*<font color='red'>失败 1 次<\/font>/);
   const [lookup, pwd, read] = calls.elements;
-  assert.match(lookup.header.title.content, /调用工具.*`lookup`.*<font color='red'>失败<\/font>/);
+  assert.match(lookup.header.title.content, /调用工具.* lookup .*<font color='red'>失败<\/font>/);
   const literal = lookup.elements[0].text;
   assert.equal(literal.tag, "plain_text");
   assert.match(literal.content, /invoice/);
   assert.match(literal.content, /permission denied/);
   assert.match(literal.content, /<at id=all>/);
-  assert.match(pwd.header.title.content, /运行.*`pwd`.*0\.4s/);
+  assert.match(pwd.header.title.content, /运行.* pwd .*0\.4s/);
   assert.match(pwd.elements[0].text.content, /退出码\n0/);
-  assert.match(read.header.title.content, /调用工具.*`docs · read`.*未完成/);
+  assert.match(read.header.title.content, /调用工具.* docs · read .*未完成/);
 });
 
 test("resumed questions display only the current exchange, including on completion", async () => {
@@ -2001,8 +1999,8 @@ test("a running card shows the latest four steps and folds the earlier ones", as
   ]);
   const card = JSON.parse(formatTurnCard("in_progress", items));
   const [earlier, rule, ...recent] = card.body.elements;
-  const label = (row) => row.tag === "markdown" ? row.content : row.header.title.content.match(/`(.*)`/)[1];
-  assert.equal(card.header.subtitle.content, "正在运行 · 8 步");
+  const label = (row) => row.tag === "markdown" ? row.content : row.header.title.content.match(/(step \d)/)[1];
+  assert.equal(card.header.title.content, "处理中 · 正在运行 · 8 步");
   assert.equal(earlier.tag, "collapsible_panel");
   assert.equal(earlier.expanded, false);
   assert.match(earlier.header.title.content, /更早的 4 步/);
@@ -2012,3 +2010,41 @@ test("a running card shows the latest four steps and folds the earlier ones", as
   assert.deepEqual(recent.map(label), ["说明 3", "step 3", "说明 4", "step 4"]);
   assert.match(recent.at(-1).header.title.content, /进行中/);
 });
+
+test("thinking and tool rows stay on one line while commentary keeps its lines", async () => {
+  const { formatTurnCard } = await import("../server/feishu.mjs");
+  const long = "先确认已有的模型和 Skill，再创建环境，然后检查飞书机器人的绑定和连接状态是否正常，最后试运行";
+  const card = JSON.parse(formatTurnCard("in_progress", [
+    { type: "reasoning", summary: [{ text: long }] },
+    { type: "command_execution", command: `for i in 1 2 3 4; do sleep 30; node parsar.mjs GET /app/runtimes/${"x".repeat(80)}/trial; done`, output: "ok", duration_ms: 128700, status: "completed" },
+    { type: "message", role: "assistant", content: [{ type: "output_text", text: "第一行说明。\n第二行说明。" }] },
+  ]));
+  const columns = (text) => [...text.replace(/<[^>]*>/g, "")].reduce((sum, char) => {
+    const code = char.codePointAt(0);
+    return sum + (code >= 0x1100 && !(code >= 0x2000 && code <= 0x206f) ? 2 : 1);
+  }, 0);
+  const [thought, run, said] = card.body.elements;
+  for (const row of [thought, run]) assert.ok(columns(row.header.title.content) <= 52, row.header.title.content);
+  assert.match(run.header.title.content, /128\.7s<\/font>$/, "the state stays on the row");
+  assert.equal(said.content, "第一行说明。\n第二行说明。");
+});
+
+test("no Markdown image reaches a card, since Feishu rejects the whole card for an invalid image key", async () => {
+  const { formatTurnCard } = await import("../server/feishu.mjs");
+  const qr = "![飞书授权二维码](/app/feishu/provision/1a77dd3d-124b-44b2-8d5d-3d75f1c72e23/qrcode)";
+  const items = [
+    { type: "message", role: "user", content: [{ type: "input_text", text: "给我链接吧" }] },
+    { type: "reasoning", summary: [{ text: `Present the link, then ${qr}` }] },
+    { type: "message", role: "assistant", phase: "commentary", content: [{ type: "output_text", text: "图表如下 ![chart](https://example.com/chart.png)" }] },
+    { type: "command_execution", command: "node parsar.mjs POST /app/feishu/provision/x", output: qr, status: "completed" },
+    { type: "message", role: "assistant", content: [{ type: "output_text", text: `链接：https://open.feishu.cn/page/launcher?user_code=AB-12\n\n${qr}` }] },
+  ];
+  for (const status of ["in_progress", "completed"]) {
+    const card = formatTurnCard(status, items);
+    const markdown = JSON.stringify(JSON.parse(card).body, (key, value) => key === "text" && value?.tag === "plain_text" ? undefined : value);
+    assert.doesNotMatch(markdown, /!\[/, `${status}: Markdown images must not reach the card`);
+  }
+  const done = JSON.parse(formatTurnCard("completed", items)).body.elements[0].content;
+  assert.match(done, /user_code=AB-12/, "the link the Agent gave stays in the answer");
+  assert.match(done, /授权二维码见图片消息/);
+});

From 837d71a035ee486974460cd0a3649bee90e38cdd Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Mon, 26 Oct 2026 14:06:31 +0800
Subject: [PATCH 05/19] Show test and trial results on their buttons
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The 测试 and 试运行 rows added small status text such as "可用 · 首次回复
8 秒" beside the button. The button now shows the result itself; only a
failure adds text, since it says what to fix. Attachment sizes no longer
add small grey text either.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/src/Checks.tsx           | 60 +++++++++----------------
 example/parsar/src/components/Media.tsx |  1 -
 example/parsar/src/lib/en.json          |  2 -
 example/parsar/tests/workflow.spec.ts   | 10 +++++
 4 files changed, 32 insertions(+), 41 deletions(-)

diff --git a/example/parsar/src/Checks.tsx b/example/parsar/src/Checks.tsx
index 4ebcc1c47..01b08c2b6 100644
--- a/example/parsar/src/Checks.tsx
+++ b/example/parsar/src/Checks.tsx
@@ -1,10 +1,24 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { tr } from "./lib/i18n";
 import { product } from "./lib/product";
+import { Check } from "lucide-react";
 import { Button } from "./components/ui/button";
-import { cn } from "./lib/utils";
 
-const seconds = (ms: number) => (ms / 1000).toFixed(1);
+// The button carries the result; only a failure adds text, since it says what to fix.
+function Failure({ text }: { text?: string }) {
+  return text ? (
+    <span role="status" className="max-w-xs truncate text-sm text-danger" title={text}>
+      {text}
+    </span>
+  ) : null;
+}
+
+const passed = (
+  <>
+    <Check className="text-success" />
+    {tr("可用")}
+  </>
+);
 
 // One tiny generation with the saved connection, so a wrong key or model ID
 // shows up here instead of in a conversation.
@@ -16,24 +30,14 @@ export function ModelTest({ id, name }: { id: string; name: string }) {
   const result = test.data;
   return (
     <>
-      {result && (
-        <span
-          role="status"
-          className={cn("max-w-xs truncate text-sm", result.ok ? "text-success" : "text-danger")}
-          title={result.error}
-        >
-          {result.ok
-            ? tr("可用 · {{value0}} 秒", { value0: seconds(result.latency_ms) })
-            : result.error}
-        </span>
-      )}
+      <Failure text={result && !result.ok ? result.error : undefined} />
       <Button
         variant="ghost"
         aria-label={tr("测试 {{value0}}", { value0: name })}
         disabled={test.isPending}
         onClick={() => test.mutate()}
       >
-        {test.isPending ? tr("测试中\u2026") : tr("测试")}
+        {test.isPending ? tr("测试中\u2026") : result?.ok ? passed : tr("测试")}
       </Button>
     </>
   );
@@ -61,38 +65,18 @@ export function RuntimeTrial({ id, name }: { id: string; name: string }) {
   });
   const state = trial.data;
   const running = state?.state === "running" || start.isPending;
-  const text = start.error
-    ? (start.error as Error).message
-    : state?.state === "running"
-      ? tr("试运行中\u2026")
-      : state?.state === "succeeded"
-        ? tr("可用 · 首次回复 {{value0}} 秒", { value0: state.seconds })
-        : state?.failure;
   return (
     <>
-      {text && (
-        <span
-          role="status"
-          className={cn(
-            "max-w-xs truncate text-sm",
-            start.error || state?.state === "failed"
-              ? "text-danger"
-              : state?.state === "succeeded"
-                ? "text-success"
-                : "text-fg",
-          )}
-          title={text}
-        >
-          {text}
-        </span>
-      )}
+      <Failure
+        text={start.error ? (start.error as Error).message : state?.state === "failed" ? state.failure : undefined}
+      />
       <Button
         variant="ghost"
         aria-label={tr("试运行 {{value0}}", { value0: name })}
         disabled={running}
         onClick={() => start.mutate()}
       >
-        {tr("试运行")}
+        {running ? tr("试运行中\u2026") : state?.state === "succeeded" ? passed : tr("试运行")}
       </Button>
     </>
   );
diff --git a/example/parsar/src/components/Media.tsx b/example/parsar/src/components/Media.tsx
index 86d8e6f85..61e1ce1da 100644
--- a/example/parsar/src/components/Media.tsx
+++ b/example/parsar/src/components/Media.tsx
@@ -49,7 +49,6 @@ export function ArtifactAttachment({ sessionId, file, preview = true }: {
     <div className="my-3 max-w-full rounded-xl border border-line p-3">
       {preview && /\.(png|jpe?g|gif|webp)$/i.test(name) && <MediaImage src={src} alt={name} />}
       <button type="button" onClick={() => download.mutate()} disabled={download.isPending} className="cursor-pointer break-all text-left text-sm underline underline-offset-4" aria-label={tr("下载 {{value0}}", { value0: name })}>{name}</button>
-      <span className="ml-2 text-xs text-fg-muted">{Math.ceil(file.size_bytes / 1024)} KiB</span>
       <ErrorNotice error={download.error} />
     </div>
   );
diff --git a/example/parsar/src/lib/en.json b/example/parsar/src/lib/en.json
index eb758b328..60d1823df 100644
--- a/example/parsar/src/lib/en.json
+++ b/example/parsar/src/lib/en.json
@@ -472,12 +472,10 @@
   "已等待 {{value0}} 秒": "waited {{value0}} s",
   "通常约 {{value0}} 秒": "usually about {{value0}} s",
   "重试中…": "Retrying…",
-  "可用 · {{value0}} 秒": "Works · {{value0}} s",
   "测试 {{value0}}": "Test {{value0}}",
   "测试中…": "Testing…",
   "测试": "Test",
   "试运行中…": "Running a trial…",
-  "可用 · 首次回复 {{value0}} 秒": "Works · first reply in {{value0}} s",
   "试运行 {{value0}}": "Trial run {{value0}}",
   "试运行": "Trial run",
   "成功率": "Success rate",
diff --git a/example/parsar/tests/workflow.spec.ts b/example/parsar/tests/workflow.spec.ts
index 70ed5a138..22253900b 100644
--- a/example/parsar/tests/workflow.spec.ts
+++ b/example/parsar/tests/workflow.spec.ts
@@ -1072,3 +1072,13 @@ test("the runs view shows running conversations with their stage, stops them and
   await recent.getByRole("link", { name: /^Review code/ }).click();
   await expect(page.getByLabel("继续对话")).toBeVisible();
 });
+
+test("an environment trial reports its result on the button, without extra status text", async ({ page }) => {
+  await resources(page);
+  await agent(page);
+  await page.goto("/#/runtimes");
+  const trial = page.getByRole("button", { name: /^试运行 / }).first();
+  await trial.click();
+  await expect(trial).toHaveText("可用", { timeout: 30000 });
+  await expect(page.getByText(/首次回复|可用 ·/)).toHaveCount(0);
+});

From 7b11f73f8ca4a29f8d55a3c11bb7419ed410d117 Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Mon, 26 Oct 2026 14:06:31 +0800
Subject: [PATCH 06/19] Use Core's saved Agents and Environment Templates

Parsar kept its Agents and environment templates in SQLite and inlined
all of their configuration into every Session request, so the example
never showed the Agents API's own Agent and Environment Template
resources and kept a second home for that configuration.

Each Agent is now a saved Core Agent (model, instructions, tools, Harness)
and each environment template a Core Environment Template (packages,
setup, variables, files). Parsar writes them on save, rolls a save back
when Core rejects it, deletes them with the record, rewrites them when
anything they bind changes, and recreates them on next use after a Project
move. A Session references both and adds only the bot variables, the
Agent's Skills, Plugins and knowledge, and attachments. The browser proxy
no longer exposes /v1/agents.

Every capability kind (Skills, MCP, prompts, knowledge, Plugins) is one
definition in capability-kinds.mjs that resolves an Agent's bindings and
says where each goes, replacing the per-kind code in Session creation.

Only live configuration blocks deletion: an Agent that binds an item or
uses a template or model, or a bot bound to an Agent. Conversations keep
their snapshot and history. A Skill an Agent binds is not deleted.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/README.md                   |   8 +-
 example/parsar/README.zh.md                |  10 +-
 example/parsar/server.mjs                  |  12 +-
 example/parsar/server/capabilities.mjs     |   7 +-
 example/parsar/server/capability-kinds.mjs | 116 ++++++++++++
 example/parsar/server/core-resources.mjs   | 127 +++++++++++++
 example/parsar/server/product.mjs          |  68 +++----
 example/parsar/server/runtime-profile.mjs  |  18 --
 example/parsar/server/sessions.mjs         | 210 +++++----------------
 example/parsar/server/trials.mjs           |   4 +-
 example/parsar/server/turns.mjs            |   1 +
 example/parsar/src/Records.tsx             |   5 +-
 example/parsar/src/Runs.tsx                |   9 +-
 example/parsar/src/lib/product.ts          |   1 +
 example/parsar/tests/cli.test.mjs          |   3 +-
 example/parsar/tests/core-double.mjs       |  50 +++++
 example/parsar/tests/feishu.test.mjs       |  14 +-
 example/parsar/tests/fixture.mjs           |  28 ++-
 example/parsar/tests/product.test.mjs      | 156 ++++++++++++---
 example/parsar/tests/server.test.mjs       |  47 +++--
 20 files changed, 596 insertions(+), 298 deletions(-)
 create mode 100644 example/parsar/server/capability-kinds.mjs
 create mode 100644 example/parsar/server/core-resources.mjs
 create mode 100644 example/parsar/tests/core-double.mjs

diff --git a/example/parsar/README.md b/example/parsar/README.md
index 4ce16f1bb..fbd9c107e 100644
--- a/example/parsar/README.md
+++ b/example/parsar/README.md
@@ -21,11 +21,11 @@ Open http://127.0.0.1:18180. `OPENAI_BASE_URL` ends in `/v1`; remote endpoints r
 
 | Object | What it is |
 | --- | --- |
-| **资源库** | Building blocks, grouped by what uses them: models for Agent engines; Skills, MCP servers, Plugins, knowledge and instruction fragments for Agents; credentials for MCP. Resources are shared: editing one affects everything that uses it, and an item in use cannot be removed. |
+| **资源库** | Building blocks, grouped by what uses them: models for Agent engines; Skills, MCP servers, Plugins, knowledge and instruction fragments for Agents; credentials for MCP. Resources are shared: editing one affects everything that uses it. Only live configuration blocks removal: an Agent that binds an item, an Agent that uses a template or model, or a bot bound to an Agent. Conversations do not; they keep the configuration snapshot they were created with and their full history. |
 | **环境模板** | The prepared workspace: npm and Python packages, a Bash setup script, environment variables, Feishu bot variables and initial files. |
 | **Agent** | What people talk to: name, description, instructions, how it runs, one required environment template, capabilities and behavior switches. How it runs mirrors a local Codex configuration: Harness, model, reasoning effort, web search and, under **高级**, reasoning summary, verbosity and service tier. **复制** creates an independent copy. |
 | **飞书机器人** | One bot is bound to at most one Agent. It routes its chats to that Agent and is the Agent’s Feishu identity in every conversation, including Web chats. |
-| **对话** | One public Core Session with its own Environment. It freezes the Agent and environment configuration when it starts. |
+| **对话** | One public Core Session with its own Environment, created from the Agent's saved Core Agent and its environment template's Core Environment Template. Core copies both when the Session starts. |
 
 Configuration lives only in templates and Agents; a conversation never overrides it. Edits affect only new conversations. When the Agent or its environment template changes, an existing conversation says so and offers **用新配置开始新对话**.
 
@@ -107,7 +107,7 @@ Optional business questions use the declared `ask_user` function. They appear in
 - **凭据** creates Vaults and write-only bearer credentials. **OAuth 授权** uses the maintained MCP SDK for discovery, dynamic client registration, issuer binding and PKCE, then stores the token through public Vault APIs. OAuth tokens never return to the browser.
 - Instruction fragments and knowledge have immutable numbered versions, defaults, pins and deprecation. Knowledge versions become initial workspace files. Standard Claude/Codex Plugin ZIPs become public Environment Plugins; declared `.mcp.json` servers are listed. Executables required by stdio servers must exist in the environment.
 
-**环境模板** runs only in Core-managed workspaces. Each new conversation installs files and packages and completes setup before starting the Agent; a setup failure stops execution. Initial files use canonical `/workspace/` paths; scripts run from the workspace. Variable values are write-only in product responses: `null` preserves an existing value, a string replaces it and removing the name deletes it. **飞书机器人变量** map variable names to the bound bot’s **App ID**, **App Secret** or region; a conversation with such a template requires the Agent to have a bound bot. Parsar sends templates inline through the public Session Environment contract and does not create a Core Template resource. Core may reuse an identical earlier preparation for up to 24 hours ([preparation reuse](../../contracts/agents-api/environments.md#preparation-reuse)), and a long-idle conversation can move to a new sandbox; in both cases only `/environment` (including `/workspace`) is kept and setup does not run again. Setup must therefore write everything it needs later under `/workspace` or the package directories, never under HOME. The Feishu workspace keeps lark-cli's configuration and encrypted credentials in `/workspace/.lark-cli` through `LARKSUITE_CLI_CONFIG_DIR` and `LARKSUITE_CLI_DATA_DIR`.
+**环境模板** runs only in Core-managed workspaces. Each new conversation installs files and packages and completes setup before starting the Agent; a setup failure stops execution. Initial files use canonical `/workspace/` paths; scripts run from the workspace. Variable values are write-only in product responses: `null` preserves an existing value, a string replaces it and removing the name deletes it. **飞书机器人变量** map variable names to the bound bot’s **App ID**, **App Secret** or region; a conversation with such a template requires the Agent to have a bound bot. Each template is saved as a Core Environment Template and each Agent as a Core Agent. Parsar rewrites them when they or anything they bind change, and recreates them on next use if the Core Project changed. A conversation's Session references both and adds only what differs per conversation: the bot variables, the Agent's Skills, Plugins and knowledge files, and attachments ([template inheritance](../../contracts/agents-api/environments.md#inheritance)). Core may reuse an identical earlier preparation for up to 24 hours ([preparation reuse](../../contracts/agents-api/environments.md#preparation-reuse)), and a long-idle conversation can move to a new sandbox; in both cases only `/environment` (including `/workspace`) is kept and setup does not run again. Setup must therefore write everything it needs later under `/workspace` or the package directories, never under HOME. The Feishu workspace keeps lark-cli's configuration and encrypted credentials in `/workspace/.lark-cli` through `LARKSUITE_CLI_CONFIG_DIR` and `LARKSUITE_CLI_DATA_DIR`.
 
 **提前准备，新对话无需等待安装** keeps one prepared Session for each Agent that uses the template. Parsar creates it without input, so Core prepares its Environment ahead of time, and the next Web or Feishu conversation takes it over with its first message; the conversation keeps its own title. A prepared Session is replaced when the Agent, its environment template, bot or model provider changes, after 12 hours, or once taken; turning the switch off discards it. A first message with images or files starts an ordinary Session. Each prepared Session holds a workspace while it waits.
 
@@ -141,7 +141,7 @@ node example/parsar/examples/feishu/configure.mjs --url http://localhost:3001 --
 
 ## Ownership and local API
 
-Core’s Project key stays server-side. Successful conversation creation leaves a Core reference and product metadata; pending creation retains the frozen public request until confirmed. Core remains authoritative for execution, Items, Turns, Skills, Vaults and Artifacts. SQLite stores product configuration, capability versions, Feishu delivery state and temporary OAuth/registration state. Files live under `~/.oac/data/parsar-example/`; `OAC_EXAMPLE_DATA_DIR` overrides this with an absolute path. Core origin and Project-key fingerprint select the file. Back it up with the server stopped. Provider and bot secrets reside in it; the Core Project key does not. Builds and caches use `${OAC_DEV_HOME:-$HOME/.oac}`.
+Core’s Project key stays server-side. Successful conversation creation leaves a Core reference and product metadata; pending creation retains the frozen public request until confirmed. Core remains authoritative for execution, Items, Turns, Skills, Vaults and Artifacts, and holds each Agent and environment template as a saved Agent and Environment Template written only by Parsar's server. SQLite stores product configuration, capability versions, Feishu delivery state and temporary OAuth/registration state. Files live under `~/.oac/data/parsar-example/`; `OAC_EXAMPLE_DATA_DIR` overrides this with an absolute path. Core origin and Project-key fingerprint select the file. Back it up with the server stopped. Provider and bot secrets reside in it; the Core Project key does not. Builds and caches use `${OAC_DEV_HOME:-$HOME/.oac}`.
 
 | Product route family | Caller and credential |
 | --- | --- |
diff --git a/example/parsar/README.zh.md b/example/parsar/README.zh.md
index df9936711..576f66666 100644
--- a/example/parsar/README.zh.md
+++ b/example/parsar/README.zh.md
@@ -1,6 +1,6 @@
 ---
 source: example/parsar/README.md
-source_hash: 91f8e0d2abc4d4bb989358f846e6b212fbb38e764a953a1d175c17e6b3c640ea
+source_hash: 62934f80a9b631d42ea26739bc2439bc11093975debcbf789fe48f567603a1fe
 ---
 
 # Parsar 工作空间
@@ -26,11 +26,11 @@ pnpm --filter @oac/parsar-example dev
 
 | 对象 | 含义 |
 | --- | --- |
-| **资源库** | 组装用的零件，按使用方分组：模型供 Agent 的执行引擎使用；Skills、MCP 服务、Plugins、知识和指令片段供 Agent 使用；凭据供 MCP 使用。资源是共享的：修改一项会影响所有使用它的对象，正在使用的条目不能移除。 |
+| **资源库** | 组装用的零件，按使用方分组：模型供 Agent 的执行引擎使用；Skills、MCP 服务、Plugins、知识和指令片段供 Agent 使用；凭据供 MCP 使用。资源是共享的：修改一项会影响所有使用它的对象。只有仍然有效的配置会阻止删除：Agent 绑定了这项能力、Agent 使用这个环境模板或模型，或者机器人绑定了这个 Agent。对话不算：它保留创建时的配置快照和完整历史。 |
 | **环境模板** | 准备好的工作区：npm 与 Python 软件包、Bash 初始化脚本、环境变量、飞书机器人变量和初始文件。 |
 | **Agent** | 用户对话的对象：名称、描述、指令、运行方式、一个必选的环境模板、能力和行为开关。运行方式对应本地 Codex 的配置：Harness、模型、推理强度、网页搜索，以及 **高级** 中的推理摘要、输出详细度和服务层级。**复制**会生成一份独立副本。 |
 | **飞书机器人** | 一个机器人最多绑定一个 Agent。它把自己的聊天路由给该 Agent，并在所有对话中（包括网页对话）作为该 Agent 的飞书身份。 |
-| **对话** | 一个公开 Core Session，拥有独立的 Environment，在开始时冻结 Agent 和环境配置。 |
+| **对话** | 一个公开 Core Session，拥有独立的 Environment，由 Agent 对应的 Core Agent 和环境模板对应的 Core Environment Template 创建。Session 开始时，Core 会复制这两份配置。 |
 
 配置只在模板和 Agent 中设定，对话不会覆盖。修改只影响新对话。Agent 或其环境模板变更后，已有对话会给出提示，并提供 **用新配置开始新对话**。
 
@@ -112,7 +112,7 @@ Parsar 会跟踪每一轮正在执行的对话，网页和飞书都一样。出
 - **凭据** 创建 Vault 和只写的 bearer 凭据。**OAuth 授权** 使用维护中的 MCP SDK 完成发现、动态客户端注册、签发方绑定和 PKCE，再通过公开 Vault API 保存令牌。OAuth 令牌不会返回浏览器。
 - 指令片段和知识具有不可变的编号版本、默认版本、固定版本和停用状态。知识版本会成为初始工作区文件。标准 Claude/Codex Plugin ZIP 会成为公开 Environment Plugin，并列出其中声明的 `.mcp.json` 服务。stdio 服务所需的可执行文件必须存在于环境中。
 
-**环境模板** 只在 Core 托管的工作区中运行。每个新对话会先写入文件、安装软件包并完成初始化，再启动 Agent；初始化失败会停止执行。初始文件使用规范的 `/workspace/` 路径，脚本在工作区中运行。变量值在产品响应中只写：`null` 保留已有值，字符串替换，删除名称即删除变量。**飞书机器人变量** 把变量名映射到所绑定机器人的 **App ID**、**App Secret** 或地区；使用这类模板的对话要求 Agent 已绑定机器人。Parsar 通过公开 Session Environment 合约内联发送模板，不创建 Core Template 资源。Core 可能在 24 小时内复用一次完全相同的准备结果（[准备结果复用](../../contracts/agents-api/zh/environments.md#preparation-reuse)），长时间空闲的对话也可能换到新沙箱；这两种情况下只保留 `/environment`（包括 `/workspace`），初始化脚本不会再次执行。因此初始化脚本必须把之后要用的内容写到 `/workspace` 或软件包目录下，不能写在 HOME 中。飞书工作环境通过 `LARKSUITE_CLI_CONFIG_DIR` 和 `LARKSUITE_CLI_DATA_DIR` 把 lark-cli 的配置和加密凭证放在 `/workspace/.lark-cli`。
+**环境模板** 只在 Core 托管的工作区中运行。每个新对话会先写入文件、安装软件包并完成初始化，再启动 Agent；初始化失败会停止执行。初始文件使用规范的 `/workspace/` 路径，脚本在工作区中运行。变量值在产品响应中只写：`null` 保留已有值，字符串替换，删除名称即删除变量。**飞书机器人变量** 把变量名映射到所绑定机器人的 **App ID**、**App Secret** 或地区；使用这类模板的对话要求 Agent 已绑定机器人。每个环境模板保存为一个 Core Environment Template，每个 Agent 保存为一个 Core Agent。它们本身或它们绑定的内容变化时，Parsar 会更新 Core 里的这两份资源；Core Project 更换后，下次使用时会重新创建。对话的 Session 引用这两份资源，只附加每次对话不同的内容：机器人变量、Agent 的 Skills、Plugins 和知识文件，以及附件（见[模板继承](../../contracts/agents-api/environments.md#inheritance)）。Core 可能在 24 小时内复用一次完全相同的准备结果（[准备结果复用](../../contracts/agents-api/zh/environments.md#preparation-reuse)），长时间空闲的对话也可能换到新沙箱；这两种情况下只保留 `/environment`（包括 `/workspace`），初始化脚本不会再次执行。因此初始化脚本必须把之后要用的内容写到 `/workspace` 或软件包目录下，不能写在 HOME 中。飞书工作环境通过 `LARKSUITE_CLI_CONFIG_DIR` 和 `LARKSUITE_CLI_DATA_DIR` 把 lark-cli 的配置和加密凭证放在 `/workspace/.lark-cli`。
 
 **提前准备，新对话无需等待安装** 会为使用该模板的每个 Agent 保留一个准备好的 Session。Parsar 在没有输入的情况下创建它，Core 会提前准备好 Environment；下一个网页或飞书对话发送第一条消息时直接接管它，并保留自己的标题。Agent、其环境模板、机器人或模型服务商变更后，或超过 12 小时、或被接管后，准备好的 Session 会被替换；关闭开关会丢弃它。第一条消息带图片或文件时，会创建普通的 Session。每个准备好的 Session 在等待期间会占用一个工作区。
 
@@ -146,7 +146,7 @@ node example/parsar/examples/feishu/configure.mjs --url http://localhost:3001 --
 
 ## 数据归属与本地 API {#ownership-and-local-api}
 
-Core 的 Project key 只保存在服务端。对话创建成功后，只保留 Core 引用和产品元数据；创建未确认时保留冻结的公开请求直到确认。Core 仍是执行、Items、Turns、Skills、Vaults 和 Artifacts 的权威来源。SQLite 保存产品配置、能力版本、飞书投递状态以及临时 OAuth/注册状态。文件位于 `~/.oac/data/parsar-example/`，可用绝对路径 `OAC_EXAMPLE_DATA_DIR` 覆盖；由 Core 地址和 Project key 指纹选择具体文件。请在服务停止时备份。Provider 和机器人密钥保存在其中，Core Project key 不在其中。构建和缓存使用 `${OAC_DEV_HOME:-$HOME/.oac}`。
+Core 的 Project key 只保存在服务端。对话创建成功后，只保留 Core 引用和产品元数据；创建未确认时保留冻结的公开请求直到确认。Core 仍是执行、Items、Turns、Skills、Vaults 和 Artifacts 的权威来源，并以保存的 Agent 和 Environment Template 存放每个 Agent 和环境模板，这两类资源只由 Parsar 服务端写入。SQLite 保存产品配置、能力版本、飞书投递状态以及临时 OAuth/注册状态。文件位于 `~/.oac/data/parsar-example/`，可用绝对路径 `OAC_EXAMPLE_DATA_DIR` 覆盖；由 Core 地址和 Project key 指纹选择具体文件。请在服务停止时备份。Provider 和机器人密钥保存在其中，Core Project key 不在其中。构建和缓存使用 `${OAC_DEV_HOME:-$HOME/.oac}`。
 
 | 产品路由组 | 调用方与凭据 |
 | --- | --- |
diff --git a/example/parsar/server.mjs b/example/parsar/server.mjs
index bb61ecb04..ebcaa98c9 100644
--- a/example/parsar/server.mjs
+++ b/example/parsar/server.mjs
@@ -9,6 +9,7 @@ import { buildDirectory } from "./paths.mjs";
 import { isIPv4 } from "node:net";
 import { openStore, dataPath, AppError } from "./server/store.mjs";
 import { productAPI } from "./server/product.mjs";
+import { boundAgents } from "./server/capability-kinds.mjs";
 import { createFeishuTransport, feishuWorkers } from "./server/feishu.mjs";
 
 const root = fileURLToPath(new URL(".", import.meta.url));
@@ -31,8 +32,6 @@ const routes = [
   [/^\/v1\/agents\/sessions\/[a-f0-9-]{36}$/, ["GET"]],
   [/^\/v1\/agents\/sessions\/[a-f0-9-]{36}\/(items|turns)$/, ["GET"]],
   [/^\/v1\/agents\/sessions\/[a-f0-9-]{36}\/events$/, ["GET", "POST"]],
-  [/^\/v1\/agents$/, ["GET", "POST"]],
-  [/^\/v1\/agents\/[a-f0-9-]{36}$/, ["GET", "POST"]],
 ];
 routes.push(
   [
@@ -250,6 +249,10 @@ export function createHandler(
           "A same-origin Origin header is required for writes.",
         );
       }
+      // Skills live in Core; one an Agent still binds is not deleted.
+      const skill = req.method === "DELETE" && url.pathname.match(/^\/v1\/skills\/(skill_[A-Za-z0-9_-]+)$/)?.[1];
+      if (skill && store && boundAgents(store, "skills", skill).length)
+        return fail(res, 409, "Skill 仍被 Agent 使用，请先在 Agent 中解除绑定。");
       const streaming =
         req.method === "GET" && url.pathname.endsWith("/events");
       const controller = new AbortController();
@@ -420,6 +423,11 @@ if (
     void productHandler.sessions
       .refreshWarm()
       .catch((error) => console.error("Prepared sessions:", error.message));
+  // Saved Core Agents and Templates that no longer resolve, as after moving to
+  // a new Project, are created again on next use.
+  await productHandler.resources
+    .verify()
+    .catch((error) => console.error("Core resources:", error.message));
   refreshPrepared();
   setInterval(refreshPrepared, 15000).unref();
   // Running Turns are watched for stalls and failed Environments.
diff --git a/example/parsar/server/capabilities.mjs b/example/parsar/server/capabilities.mjs
index 957601555..ad4fa6656 100644
--- a/example/parsar/server/capabilities.mjs
+++ b/example/parsar/server/capabilities.mjs
@@ -1,10 +1,11 @@
 import { AppError, text, uuid } from "./store.mjs";
+import { boundAgents } from "./capability-kinds.mjs";
 import { unzipSync } from "fflate";
 const publicVersion = ({ archive, ...value }) => ({
   ...value,
   has_archive: !!archive,
 });
-export const publicCapability = (row) => ({
+const publicCapability = (row) => ({
   ...row,
   versions: row.versions.map(publicVersion),
 });
@@ -25,9 +26,7 @@ export function capabilityAPI(store) {
     if (old && old.revision !== body.revision)
       throw new AppError(409, "能力已更新，请重新加载。");
     if (method === "DELETE") {
-      if (
-        store.list("agents").some((agent) => agent.capability_ids?.includes(id))
-      )
+      if (boundAgents(store, "capabilities", id).length)
         throw new AppError(409, "能力仍被 Agent 引用。");
       store.remove("capabilities", id);
       return {};
diff --git a/example/parsar/server/capability-kinds.mjs b/example/parsar/server/capability-kinds.mjs
new file mode 100644
index 000000000..91ec022fb
--- /dev/null
+++ b/example/parsar/server/capability-kinds.mjs
@@ -0,0 +1,116 @@
+import { AppError, text, uuid } from "./store.mjs";
+
+// Every kind of capability an Agent can bind, in one place. A kind resolves an
+// Agent's bindings and says where each one goes: into the Core Agent (tools,
+// instructions) or into the Session's Environment (skills, plugins, files).
+
+const libraryEntry = (store, agent, id) => {
+  const capability = store.get("capabilities", id);
+  if (!capability || capability.deprecated)
+    throw new AppError(400, "Agent 绑定的能力已停用或不存在。");
+  const version = capability.versions.find(
+    (row) => row.version === (agent.capability_versions?.[id] || capability.default_version),
+  );
+  if (!version) throw new AppError(400, "Agent 绑定的能力版本不存在。");
+  return { ...capability, ...version };
+};
+const library = (kind, contribute) => ({
+  bound: (agent) => agent.capability_ids || [],
+  resolve: (store, agent) =>
+    (agent.capability_ids || [])
+      .map((id) => libraryEntry(store, agent, id))
+      .filter((row) => row.kind === kind),
+  contribute,
+});
+
+export const capabilityKinds = {
+  skills: {
+    bound: (agent) => agent.skill_ids || [],
+    // Skills live in Core; the binding names a Skill and optionally a version.
+    resolve: (_store, agent) =>
+      (agent.skill_ids || []).map((skill_id) => ({ skill_id, version: agent.skill_versions?.[skill_id] })),
+    contribute: (entry, out) =>
+      out.session.skills.push({ type: "skill_reference", skill_id: entry.skill_id, ...(entry.version ? { version: entry.version } : {}) }),
+  },
+  mcps: {
+    bound: (agent) => agent.mcp_ids || [],
+    resolve: (store, agent) => {
+      const mcps = (agent.mcp_ids || []).map((id) => store.get("mcps", id));
+      if (mcps.some((mcp) => !mcp)) throw new AppError(400, "Agent 绑定的资源已不可用。");
+      if (new Set(mcps.map((mcp) => mcp.label)).size !== mcps.length)
+        throw new AppError(400, "绑定的 MCP 服务标识不能重复。");
+      return mcps;
+    },
+    contribute: (mcp, out, agent) => {
+      out.agent.tools.push({
+        type: "mcp",
+        server_label: mcp.label,
+        transport: { type: "http", server_url: mcp.url },
+        connection_origin: "environment",
+        // MiniMax Code admits only optional MCP initialization.
+        required: agent.harness !== "mcode",
+        ...(mcp.credential_id ? { credential_id: mcp.credential_id } : {}),
+      });
+      if (mcp.vault_id) out.session.vault_ids.push(mcp.vault_id);
+    },
+    // An HTTPS address without credentials; authentication comes from a Vault credential.
+    validate: (body) => {
+      let url;
+      try {
+        url = new URL(body.url);
+      } catch {
+        throw new AppError(400, "请填写有效的 MCP URL。");
+      }
+      if (url.protocol !== "https:" || url.username || url.password || url.hash || url.search)
+        throw new AppError(400, "MCP 使用不含凭据的 HTTPS 地址。");
+      if (body.vault_id && !uuid.test(body.vault_id)) throw new AppError(400, "凭据库标识无效。");
+      if (body.credential_id && (!body.vault_id || !uuid.test(body.credential_id)))
+        throw new AppError(400, "凭据标识无效。");
+      const label = text(body.label, "MCP 标识", 64, true);
+      if (!/^[a-zA-Z0-9_-]+$/.test(label))
+        throw new AppError(400, "MCP 标识仅支持字母、数字、下划线和连字符。");
+      return { url: url.href, vault_id: body.vault_id || "", credential_id: body.credential_id || "", label };
+    },
+  },
+  prompt: library("prompt", (row, out) => out.agent.instructions.push(row.content)),
+  knowledge: library("knowledge", (row, out) => {
+    out.agent.instructions.push(`Knowledge: ${row.name} — ./knowledge/${row.id}.md`);
+    out.session.files.push({
+      type: "inline",
+      path: `/workspace/knowledge/${row.id}.md`,
+      data: Buffer.from(row.content).toString("base64"),
+    });
+  }),
+  plugin: library("plugin", (row, out) =>
+    out.session.plugins.push({
+      type: "inline",
+      name: row.name,
+      description: row.description,
+      source: { type: "base64", media_type: "application/zip", data: row.archive },
+    }),
+  ),
+};
+
+// What an Agent's bindings add to its Core Agent and to each of its Sessions.
+export function contributions(store, agent) {
+  const out = {
+    agent: { tools: [], instructions: [] },
+    session: { skills: [], plugins: [], files: [], vault_ids: [] },
+    summary: { skills: [], mcps: [], capabilities: [] },
+  };
+  for (const [kind, definition] of Object.entries(capabilityKinds))
+    for (const entry of definition.resolve(store, agent)) {
+      definition.contribute(entry, out, agent);
+      if (kind === "skills") out.summary.skills.push({ id: entry.skill_id, version: entry.version || null });
+      else if (kind === "mcps") out.summary.mcps.push(entry.label);
+      else out.summary.capabilities.push({ name: entry.name, kind: entry.kind, version: entry.version });
+    }
+  out.session.vault_ids = [...new Set(out.session.vault_ids)];
+  return out;
+}
+
+// Agents that bind a capability; a bound capability cannot be deleted.
+export function boundAgents(store, kind, id) {
+  const definition = kind === "capabilities" ? capabilityKinds.prompt : capabilityKinds[kind];
+  return store.list("agents").filter((agent) => definition.bound(agent).includes(id));
+}
diff --git a/example/parsar/server/core-resources.mjs b/example/parsar/server/core-resources.mjs
new file mode 100644
index 000000000..90badaeeb
--- /dev/null
+++ b/example/parsar/server/core-resources.mjs
@@ -0,0 +1,127 @@
+import { createHash } from "node:crypto";
+import { AppError } from "./store.mjs";
+import { contributions } from "./capability-kinds.mjs";
+import { harnessOptions } from "../shared/harness-options.mjs";
+
+// Parsar authors Agents and environment templates; Core keeps them as saved
+// Agents and Environment Templates, which Sessions reference by ID. Each Core
+// resource is the projection of a Parsar record and of what it binds, and is
+// rewritten whenever that projection's digest changes.
+
+const digest = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+const withoutNulls = (value) => Object.fromEntries(Object.entries(value).filter(([, v]) => v !== null));
+
+const askUserTool = {
+  type: "function",
+  name: "ask_user",
+  description:
+    "Ask the user a business question when essential information is missing. Never request execution permission or approval; execution is bypass-only.",
+  parameters: {
+    type: "object",
+    properties: { question: { type: "string" }, options: { type: "array", items: { type: "string" } } },
+    required: ["question", "options"],
+    additionalProperties: false,
+  },
+};
+
+// The saved Core Agent: model, instructions, tools and Harness. Cleared
+// settings are sent as null so an update resets them.
+function coreAgent(store, agent) {
+  const model = store.get("models", agent.model_id);
+  if (!model || model.enabled === false) throw new AppError(400, "Agent 绑定的资源已不可用。");
+  if (!harnessOptions[agent.harness]) throw new AppError(400, "请选择执行引擎。");
+  const bound = contributions(store, agent);
+  const reasoning = agent.reasoning_effort || agent.reasoning_summary
+    ? {
+        ...(agent.reasoning_effort ? { effort: agent.reasoning_effort } : {}),
+        ...(agent.reasoning_summary ? { summary: agent.reasoning_summary } : {}),
+      }
+    : null;
+  return {
+    name: agent.name.slice(0, 128),
+    model: model.model,
+    instructions: [agent.instructions, ...bound.agent.instructions].filter(Boolean).join("\n\n") || null,
+    reasoning,
+    service_tier: agent.service_tier || null,
+    text: { verbosity: agent.verbosity || "medium" },
+    tools: [
+      { type: "web_search", mode: agent.web_search || "disabled" },
+      ...(agent.ask_user ? [askUserTool] : []),
+      ...bound.agent.tools,
+    ],
+    multi_agent: { enabled: false },
+    metadata: { application: "parsar-example", parsar_agent_id: agent.id },
+    x_agents_core: { harness: agent.harness },
+  };
+}
+
+export const templateFiles = (runtime) =>
+  (runtime.files || []).map(({ path, content }) => ({
+    type: "inline",
+    path,
+    data: Buffer.from(content).toString("base64"),
+  }));
+
+// The saved Core Environment Template: packages, setup, variables and files.
+function coreTemplate(runtime) {
+  if (runtime.environment !== "openai_hosted")
+    throw new AppError(400, "Parsar 仅支持托管工作环境，请重新配置环境模板。");
+  return {
+    name: runtime.name.slice(0, 256),
+    packages: { npm: runtime.packages?.npm || [], python: runtime.packages?.python || [] },
+    setup_commands: runtime.setup_script ? [{ command: runtime.setup_script, cwd: "/workspace" }] : [],
+    env: { ...runtime.env },
+    files: templateFiles(runtime),
+  };
+}
+
+const targets = {
+  agents: { field: "core_agent_id", path: "/v1/agents", body: coreAgent },
+  runtimes: { field: "core_template_id", path: "/v1/agents/environments/templates", body: (_store, row) => coreTemplate(row) },
+};
+
+export function coreResources(store, core) {
+  // Writes the Core resource when the record or anything it binds changed.
+  // A resource missing in Core, as after moving to a new Project, is created again.
+  const ensure = async (kind, id) => {
+    const { field, path, body: build } = targets[kind];
+    const row = store.get(kind, id);
+    if (!row) throw new AppError(400, "请选择有效的资源。");
+    const body = build(store, row);
+    const print = digest(body);
+    if (row[field] && row.core_digest === print) return row;
+    let coreId = row[field];
+    if (coreId)
+      try {
+        await core(`${path}/${coreId}`, "POST", body);
+      } catch (error) {
+        if (!(error instanceof AppError && error.status === 404)) throw error;
+        coreId = undefined;
+      }
+    if (!coreId) coreId = (await core(path, "POST", withoutNulls(body))).id;
+    const next = { ...store.get(kind, id), [field]: coreId, core_digest: print };
+    store.put(kind, next);
+    return next;
+  };
+  const remove = async (kind, row) => {
+    const { field, path } = targets[kind];
+    if (!row?.[field]) return;
+    await core(`${path}/${row[field]}`, "DELETE").catch((error) => {
+      if (!(error instanceof AppError && error.status === 404)) throw error;
+    });
+  };
+  // Forget Core IDs that no longer resolve, so the next use creates them again.
+  const verify = async () => {
+    for (const kind of Object.keys(targets)) {
+      const { field, path } = targets[kind];
+      for (const row of store.list(kind).filter((row) => row[field]))
+        await core(`${path}/${row[field]}`, "GET").catch((error) => {
+          if (error instanceof AppError && error.status === 404) {
+            const { [field]: _gone, core_digest: _old, ...rest } = store.get(kind, row.id);
+            store.put(kind, rest);
+          }
+        });
+    }
+  };
+  return { ensure, remove, verify };
+}
diff --git a/example/parsar/server/product.mjs b/example/parsar/server/product.mjs
index 3257d2fec..bb74f2569 100644
--- a/example/parsar/server/product.mjs
+++ b/example/parsar/server/product.mjs
@@ -8,6 +8,8 @@ import { runtimeProfile, publicRuntime } from "./runtime-profile.mjs";
 import { feishuAPI } from "./feishu.mjs";
 import { trialAPI } from "./trials.mjs";
 import { sessionAPI } from "./sessions.mjs";
+import { coreResources } from "./core-resources.mjs";
+import { boundAgents, capabilityKinds } from "./capability-kinds.mjs";
 import { AppError, text, uuid } from "./store.mjs";
 import {
   harnessOptions,
@@ -32,7 +34,8 @@ const kinds = new Set([
   "sessions",
 ]);
 export function productAPI(store, core, fetchImpl = fetch, origin) {
-  const sessions = sessionAPI(store, core);
+  const resources = coreResources(store, core);
+  const sessions = sessionAPI(store, core, resources);
   const publicRow = (kind, row) => {
     if (kind === "providers") return publicProvider(row);
     if (kind === "runtimes") return publicRuntime(row);
@@ -47,7 +50,7 @@ export function productAPI(store, core, fetchImpl = fetch, origin) {
   const feishu = feishuAPI(store);
   const registration = feishuRegistrationAPI(store, fetchImpl);
   const providers = providerAPI(store, fetchImpl);
-  const trials = trialAPI(store, core);
+  const trials = trialAPI(store, core, resources);
   const sessionAfter = (run) => async (id, body) => {
     await run(id, body);
     return publicRow("sessions", store.get("sessions", id));
@@ -201,21 +204,15 @@ export function productAPI(store, core, fetchImpl = fetch, origin) {
     }
     const previous = store.get(kind, id);
     if (method === "DELETE") {
+      // Only live configuration blocks deletion. Conversations keep the
+      // snapshot they were created with, and their Core Sessions keep running.
       const used =
         store.list("feishu_bots").some((row) => row.agent_id === id) ||
         store.list("models").some((row) => row.provider_id === id) ||
-        store
-          .list("agents")
-          .some(
-            (row) =>
-              row.model_id === id ||
-              row.runtime_id === id ||
-              row.mcp_ids.includes(id),
-          ) ||
-        store
-          .list("sessions")
-          .some((row) => row.agent_id === id || row.runtime_id === id);
+        store.list("agents").some((row) => row.model_id === id || row.runtime_id === id) ||
+        (kind === "mcps" && boundAgents(store, "mcps", id).length > 0);
       if (used) throw new AppError(409, "资源仍被引用，请先调整绑定。");
+      if (kind === "agents" || kind === "runtimes") await resources.remove(kind, previous);
       store.transaction(() => {
         store.remove(kind, id);
         if (kind === "models") touchProviders(previous?.provider_id);
@@ -264,35 +261,7 @@ export function productAPI(store, core, fetchImpl = fetch, origin) {
       )
         throw new AppError(409, "此 Provider 已有相同的模型 ID。");
     }
-    if (kind === "mcps") {
-      let url;
-      try {
-        url = new URL(body.url);
-      } catch {
-        throw new AppError(400, "请填写有效的 MCP URL。");
-      }
-      if (
-        url.protocol !== "https:" ||
-        url.username ||
-        url.password ||
-        url.hash ||
-        url.search
-      )
-        throw new AppError(400, "MCP 使用不含凭据的 HTTPS 地址。");
-      value.url = url.href;
-      if (body.vault_id && !uuid.test(body.vault_id))
-        throw new AppError(400, "凭据库标识无效。");
-      if (
-        body.credential_id &&
-        (!body.vault_id || !uuid.test(body.credential_id))
-      )
-        throw new AppError(400, "凭据标识无效。");
-      value.vault_id = body.vault_id || "";
-      value.credential_id = body.credential_id || "";
-      value.label = text(body.label, "MCP 标识", 64, true);
-      if (!/^[a-zA-Z0-9_-]+$/.test(value.label))
-        throw new AppError(400, "MCP 标识仅支持字母、数字、下划线和连字符。");
-    }
+    if (kind === "mcps") Object.assign(value, capabilityKinds.mcps.validate(body));
     if (kind === "runtimes") {
       Object.assign(value, runtimeProfile(body, previous));
     }
@@ -380,12 +349,24 @@ export function productAPI(store, core, fetchImpl = fetch, origin) {
         if (version) value.skill_versions[skillId] = version;
       }
     }
+    // The saved Core Agent or Template keeps its identity across edits.
+    for (const field of ["core_agent_id", "core_template_id", "core_digest"])
+      if (previous?.[field]) value[field] = previous[field];
     store.transaction(() => {
       store.put(kind, value);
       if (kind === "models")
         touchProviders(previous?.provider_id, value.provider_id);
     });
-    return publicRow(kind, value);
+    // Core validates the Agent or Template now, so a rejected edit is not kept.
+    if (kind === "agents" || kind === "runtimes")
+      try {
+        await resources.ensure(kind, id);
+      } catch (error) {
+        if (previous) store.put(kind, previous);
+        else store.remove(kind, id);
+        throw error;
+      }
+    return publicRow(kind, store.get(kind, id));
   };
   const handler = async (method, path, body) => {
     const result = await handle(method, path, body);
@@ -399,5 +380,6 @@ export function productAPI(store, core, fetchImpl = fetch, origin) {
     return result;
   };
   handler.sessions = sessions;
+  handler.resources = resources;
   return handler;
 }
diff --git a/example/parsar/server/runtime-profile.mjs b/example/parsar/server/runtime-profile.mjs
index bfcbc2d4f..00860288e 100644
--- a/example/parsar/server/runtime-profile.mjs
+++ b/example/parsar/server/runtime-profile.mjs
@@ -107,21 +107,3 @@ export function publicRuntime({ env, ...row }) {
     env: Object.fromEntries(Object.keys(env || {}).map((key) => [key, null])),
   };
 }
-
-export function runtimeEnvironment(runtime) {
-  if (runtime.environment !== "openai_hosted")
-    throw new AppError(400, "Parsar 仅支持托管工作环境，请重新配置环境模板。");
-  return {
-    type: "openai_hosted",
-    packages: runtime.packages || { npm: [], python: [] },
-    env: { ...runtime.env },
-    setup_commands: runtime.setup_script
-      ? [{ command: runtime.setup_script, cwd: "/workspace" }]
-      : [],
-    files: (runtime.files || []).map(({ path, content }) => ({
-      type: "inline",
-      path,
-      data: Buffer.from(content).toString("base64"),
-    })),
-  };
-}
diff --git a/example/parsar/server/sessions.mjs b/example/parsar/server/sessions.mjs
index f527e3f2c..dc43464ca 100644
--- a/example/parsar/server/sessions.mjs
+++ b/example/parsar/server/sessions.mjs
@@ -1,32 +1,34 @@
 import { createHash, randomUUID } from "node:crypto";
-import { runtimeEnvironment } from "./runtime-profile.mjs";
 import { AppError, text, uuid } from "./store.mjs";
 import { harnessOptions } from "../shared/harness-options.mjs";
+import { contributions } from "./capability-kinds.mjs";
+import { templateFiles } from "./core-resources.mjs";
 import { turnsAPI } from "./turns.mjs";
 
 // A warm Session matches a cold creation only when every frozen byte except the
-// first input and the per-conversation metadata is the same.
-const fingerprint = ({ input, metadata, ...request }) =>
-  createHash("sha256").update(JSON.stringify(request)).digest("hex");
+// first input and the per-conversation metadata is the same, including the
+// content of the Core Agent and Template it references.
+const fingerprint = ({ request: { input, metadata, ...request }, core_digests }) =>
+  createHash("sha256").update(JSON.stringify({ request, core_digests })).digest("hex");
 const warmAge = 12 * 3600_000;
 
 export function sessionBot(store, agentId) {
   return store.list("feishu_bots").find((bot) => bot.agent_id === agentId);
 }
 
-export function prepareSession(store, id, body, origin = {}, warm = false) {
-  const agent = store.get("agents", body.agent_id);
-  if (!agent) throw new AppError(400, "请选择有效的 Agent。");
-  if (agent.enabled === false)
-    throw new AppError(400, "Agent 已停用，请先启用。");
-  const runtime = store.get("runtimes", agent.runtime_id || "");
-  if (!runtime) throw new AppError(400, "Agent 未配置环境模板。");
+// A Session references the Agent's saved Core Agent and its environment
+// template's Core Template, and adds only what differs per conversation: the
+// bot identity, the Agent's Skills, Plugins and knowledge, and attachments.
+export async function prepareSession(store, resources, id, body, origin = {}, warm = false) {
+  const stored = store.get("agents", body.agent_id);
+  if (!stored) throw new AppError(400, "请选择有效的 Agent。");
+  if (stored.enabled === false) throw new AppError(400, "Agent 已停用，请先启用。");
+  const storedRuntime = store.get("runtimes", stored.runtime_id || "");
+  if (!storedRuntime) throw new AppError(400, "Agent 未配置环境模板。");
+  const agent = await resources.ensure("agents", stored.id);
+  const runtime = await resources.ensure("runtimes", storedRuntime.id);
   const model = store.get("models", agent.model_id);
-  const mcps = agent.mcp_ids.map((id) => store.get("mcps", id));
-  if (!model || model.enabled === false || mcps.some((mcp) => !mcp))
-    throw new AppError(400, "Agent 绑定的资源已不可用。");
-  if (new Set(mcps.map((mcp) => mcp.label)).size !== mcps.length)
-    throw new AppError(400, "绑定的 MCP 服务标识不能重复。");
+  const bound = contributions(store, agent);
   const botEnv = Object.entries(runtime.bot_env || {});
   const bot = sessionBot(store, agent.id);
   if (botEnv.length && !bot?.app_secret)
@@ -34,60 +36,12 @@ export function prepareSession(store, id, body, origin = {}, warm = false) {
       400,
       "环境模板需要飞书机器人身份，请先在飞书接入中把机器人绑定到这个 Agent。",
     );
-  const environment = runtimeEnvironment(runtime);
-  for (const [name, field] of botEnv)
-    environment.env[name] = field === "brand" ? bot.brand || "feishu" : bot[field];
   const provider = store.get("providers", model.provider_id);
   if (!provider?.base_url?.startsWith("https://") || !provider.api_key)
     throw new AppError(
       400,
       "请先在模型页面配置所选 Provider 的 HTTPS Base URL 和 API Key。",
     );
-  const modelProvider = {
-    protocol: harnessOptions[agent.harness].protocol,
-    base_url: provider.base_url,
-    api_key: provider.api_key,
-  };
-  const tools = [
-    { type: "web_search", mode: agent.web_search || "disabled" },
-  ];
-  if (agent.ask_user)
-    tools.push({
-      type: "function",
-      name: "ask_user",
-      description:
-        "Ask the user a business question when essential information is missing. Never request execution permission or approval; execution is bypass-only.",
-      parameters: {
-        type: "object",
-        properties: {
-          question: { type: "string" },
-          options: { type: "array", items: { type: "string" } },
-        },
-        required: ["question", "options"],
-        additionalProperties: false,
-      },
-    });
-  tools.push(
-    ...mcps.map((mcp) => ({
-      type: "mcp",
-      server_label: mcp.label,
-      transport: { type: "http", server_url: mcp.url },
-      connection_origin: "environment",
-      // MiniMax Code admits only optional MCP initialization.
-      required: agent.harness !== "mcode",
-      ...(mcp.credential_id ? { credential_id: mcp.credential_id } : {}),
-    })),
-  );
-  {
-    environment.skills = agent.skill_ids.map((skill_id) => ({
-      type: "skill_reference",
-      skill_id,
-      ...(agent.skill_versions?.[skill_id]
-        ? { version: agent.skill_versions[skill_id] }
-        : {}),
-    }));
-    if (mcps.length) environment.network = { access: "enabled" };
-  }
   const images = body.images || [];
   const files = body.files || [];
   if (
@@ -119,60 +73,18 @@ export function prepareSession(store, id, body, origin = {}, warm = false) {
     )
   )
     throw new AppError(400, "附件格式或大小无效。");
-  if (files.length && environment.type !== "openai_hosted")
-    throw new AppError(400, "附件需要托管运行时。");
-  if (files.length) environment.files.push(...files);
-  const capabilities = (agent.capability_ids || []).map((id) => {
-    const capability = store.get("capabilities", id);
-    if (!capability || capability.deprecated)
-      throw new AppError(400, "Agent 绑定的能力已停用或不存在。");
-    const version = capability.versions.find(
-      (row) =>
-        row.version ===
-        (agent.capability_versions?.[id] || capability.default_version),
-    );
-    if (!version) throw new AppError(400, "Agent 绑定的能力版本不存在。");
-    return { ...capability, ...version };
-  });
-  for (const capability of capabilities) {
-    if (capability.kind === "prompt") continue;
-    if (environment.type !== "openai_hosted")
-      throw new AppError(400, "Plugin 和知识文件需要托管运行时。");
-    if (capability.kind === "knowledge")
-      environment.files = [
-        ...(environment.files || []),
-        {
-          type: "inline",
-          path: `/workspace/knowledge/${capability.id}.md`,
-          data: Buffer.from(capability.content).toString("base64"),
-        },
-      ];
-    if (capability.kind === "plugin")
-      environment.plugins = [
-        ...(environment.plugins || []),
-        {
-          type: "inline",
-          name: capability.name,
-          description: capability.description,
-          source: {
-            type: "base64",
-            media_type: "application/zip",
-            data: capability.archive,
-          },
-        },
-      ];
-  }
-  const instructions = [
-    agent.instructions,
-    ...capabilities
-      .filter((row) => row.kind === "prompt")
-      .map((row) => row.content),
-    ...capabilities
-      .filter((row) => row.kind === "knowledge")
-      .map((row) => `Knowledge: ${row.name} — ./knowledge/${row.id}.md`),
-  ]
-    .filter(Boolean)
-    .join("\n\n");
+  // Session files replace the Template's set, so they include the Template's own.
+  const extraFiles = [...files, ...bound.session.files];
+  const environment = {
+    type: "openai_hosted",
+    environment_template_id: runtime.core_template_id,
+    ...(botEnv.length
+      ? { env: Object.fromEntries(botEnv.map(([name, field]) => [name, field === "brand" ? bot.brand || "feishu" : bot[field]])) }
+      : {}),
+    ...(bound.session.skills.length ? { skills: bound.session.skills } : {}),
+    ...(bound.session.plugins.length ? { plugins: bound.session.plugins } : {}),
+    ...(extraFiles.length ? { files: [...templateFiles(runtime), ...extraFiles] } : {}),
+  };
   const name = warm ? "" : text(body.name, "会话名称", 80, true);
   const input = warm ? "" : text(body.input, "消息", 100000, true);
   return {
@@ -185,6 +97,7 @@ export function prepareSession(store, id, body, origin = {}, warm = false) {
       ? { feishu_chat_type: origin.feishu_chat_type }
       : {}),
     pricing: model.pricing,
+    core_digests: [agent.core_digest, runtime.core_digest],
     configuration: {
       agent_name: agent.name,
       agent_revision: agent.revision,
@@ -201,48 +114,13 @@ export function prepareSession(store, id, body, origin = {}, warm = false) {
         ...botEnv.map(([name]) => name),
       ],
       file_paths: (runtime.files || []).map((file) => file.path),
-      skills: agent.skill_ids.map((id) => ({
-        id,
-        version: agent.skill_versions?.[id] || null,
-      })),
-      mcps: mcps.map((mcp) => mcp.label),
-      capabilities: capabilities.map((row) => ({
-        name: row.name,
-        kind: row.kind,
-        version: row.version,
-      })),
+      ...bound.summary,
     },
     created_at: Math.floor(Date.now() / 1000),
     request: {
-      agent: {
-        model: model.model,
-        instructions,
-        ...(agent.reasoning_effort || agent.reasoning_summary
-          ? {
-              reasoning: {
-                ...(agent.reasoning_effort
-                  ? { effort: agent.reasoning_effort }
-                  : {}),
-                ...(agent.reasoning_summary
-                  ? { summary: agent.reasoning_summary }
-                  : {}),
-              },
-            }
-          : {}),
-        ...(agent.service_tier ? { service_tier: agent.service_tier } : {}),
-        x_agents_core: { harness: agent.harness },
-        multi_agent: { enabled: false },
-        text: { verbosity: agent.verbosity || "medium" },
-        tools,
-      },
+      agent_id: agent.core_agent_id,
       environment,
-      ...(mcps.some((mcp) => mcp.vault_id)
-        ? {
-            vault_ids: [
-              ...new Set(mcps.map((mcp) => mcp.vault_id).filter(Boolean)),
-            ],
-          }
-        : {}),
+      ...(bound.session.vault_ids.length ? { vault_ids: bound.session.vault_ids } : {}),
       ...(input
         ? {
             input: images.length
@@ -261,7 +139,14 @@ export function prepareSession(store, id, body, origin = {}, warm = false) {
               : input,
           }
         : {}),
-      x_agents_core: { model_provider: modelProvider },
+      // The Provider key stays in Parsar's model settings and travels per Session.
+      x_agents_core: {
+        model_provider: {
+          protocol: harnessOptions[agent.harness].protocol,
+          base_url: provider.base_url,
+          api_key: provider.api_key,
+        },
+      },
       metadata: {
         application: "parsar-example",
         agent_id: agent.id,
@@ -272,7 +157,7 @@ export function prepareSession(store, id, body, origin = {}, warm = false) {
   };
 }
 
-export function sessionAPI(store, core) {
+export function sessionAPI(store, core, resources) {
   const running = new Map();
   const turns = turnsAPI(store, core);
   // Hand a prepared Session to this conversation when one matches its frozen
@@ -280,7 +165,7 @@ export function sessionAPI(store, core) {
   // normally if the prepared one does not start.
   const claim = (row) => {
     if (typeof row.request.input !== "string") return;
-    const print = fingerprint(row.request);
+    const print = fingerprint(row);
     const warm = store
       .list("warm_sessions")
       .find((entry) => entry.agent_id === row.agent_id && entry.fingerprint === print);
@@ -297,7 +182,7 @@ export function sessionAPI(store, core) {
     if (row?.pending_input) return turns.sendPrepared(row);
     if (row?.core_session_id) return row;
     if (!row) {
-      row = prepareSession(store, id, body, origin);
+      row = await prepareSession(store, resources, id, body, origin);
       store.put("sessions", row);
       const claimed = claim(row);
       if (claimed) return claimed;
@@ -359,8 +244,7 @@ export function sessionAPI(store, core) {
       )
         try {
           print = fingerprint(
-            prepareSession(store, randomUUID(), { agent_id: agent.id }, {}, true)
-              .request,
+            await prepareSession(store, resources, randomUUID(), { agent_id: agent.id }, {}, true),
           );
         } catch {
           print = undefined;
@@ -379,7 +263,7 @@ export function sessionAPI(store, core) {
       if (!print || entries.some((entry) => entry.fingerprint === print && now - entry.created_at <= warmAge))
         continue;
       const id = randomUUID();
-      const { request } = prepareSession(store, id, { agent_id: agent.id }, {}, true);
+      const { request } = await prepareSession(store, resources, id, { agent_id: agent.id }, {}, true);
       const session = await core("/v1/agents/sessions", "POST", {
         ...request,
         metadata: { ...request.metadata, title: "", warm: "true" },
diff --git a/example/parsar/server/trials.mjs b/example/parsar/server/trials.mjs
index 89b2c9e70..e0fd9c59e 100644
--- a/example/parsar/server/trials.mjs
+++ b/example/parsar/server/trials.mjs
@@ -8,7 +8,7 @@ const prompt = "只回复 OK，不要调用任何工具。";
 
 // A trial run creates one real Session for an Agent that uses the environment
 // template, waits for its first reply, records the outcome and deletes the Session.
-export function trialAPI(store, core) {
+export function trialAPI(store, core, resources) {
   const get = (runtimeId) => {
     const trial = store.get("runtime_trials", runtimeId);
     if (trial?.state === "running" && Date.now() - trial.started_at > limitMs + 30_000)
@@ -46,7 +46,7 @@ export function trialAPI(store, core) {
     if (running?.state === "running") return running;
     const agent = store.list("agents").find((a) => a.runtime_id === runtimeId && a.enabled !== false);
     if (!agent) throw new AppError(400, "先把这个环境模板绑定到一个 Agent，再试运行。");
-    const { request } = prepareSession(store, randomUUID(), { agent_id: agent.id, name: "试运行", input: prompt });
+    const { request } = await prepareSession(store, resources, randomUUID(), { agent_id: agent.id, name: "试运行", input: prompt });
     request.metadata = { ...request.metadata, application: "parsar-trial", title: "试运行" };
     const started_at = Date.now();
     const session = await core("/v1/agents/sessions", "POST", request, randomUUID());
diff --git a/example/parsar/server/turns.mjs b/example/parsar/server/turns.mjs
index 5d53fd8f5..6c864f5ce 100644
--- a/example/parsar/server/turns.mjs
+++ b/example/parsar/server/turns.mjs
@@ -296,6 +296,7 @@ export function turnsAPI(store, core) {
         session_id: t.session_id,
         core_session_id: t.core_session_id,
         agent_id: t.agent_id,
+        agent_name: record.configuration?.agent_name,
         conversation: record.name,
         source: t.source,
         chat_type: record.feishu_chat_type,
diff --git a/example/parsar/src/Records.tsx b/example/parsar/src/Records.tsx
index 023e4feb2..82e837a51 100644
--- a/example/parsar/src/Records.tsx
+++ b/example/parsar/src/Records.tsx
@@ -302,9 +302,12 @@ export function Records({ view }: { view: "conversations" | "usage" }) {
               )}
             </LedgerHeader>
             {data.flatMap((row) => {
+              // A deleted Agent keeps the name its conversation was created with.
               const agent =
                 agents.data?.find((agent) => agent.id === row.record.agent_id)
-                  ?.name || "—";
+                  ?.name ||
+                row.record.configuration?.agent_name ||
+                "—";
               if (view === "usage")
                 return [
                   <LedgerRow key={row.record.id}>
diff --git a/example/parsar/src/Runs.tsx b/example/parsar/src/Runs.tsx
index 2149106b2..55abcdec7 100644
--- a/example/parsar/src/Runs.tsx
+++ b/example/parsar/src/Runs.tsx
@@ -223,8 +223,9 @@ export function Runs() {
     const timer = setInterval(() => setNow(Date.now()), 1000);
     return () => clearInterval(timer);
   }, []);
-  const name = (id: string) =>
-    agents.data?.find((agent) => agent.id === id)?.name || "—";
+  // A deleted Agent keeps the name its conversation was created with.
+  const name = (row: TurnRow) =>
+    agents.data?.find((agent) => agent.id === row.agent_id)?.name || row.agent_name || "—";
   const keep = (row: TurnRow) =>
     (!agentFilter || row.agent_id === agentFilter) &&
     (!source || row.source === source);
@@ -286,7 +287,7 @@ export function Runs() {
                 <Running
                   key={row.id}
                   row={row}
-                  agent={name(row.agent_id)}
+                  agent={name(row)}
                   now={now}
                 />
               ))}
@@ -306,7 +307,7 @@ export function Runs() {
           {recent.length ? (
             <div className="divide-y divide-line-muted overflow-hidden rounded-2xl border border-line bg-surface app-shadow-card">
               {recent.map((row) => (
-                <Recent key={row.id} row={row} agent={name(row.agent_id)} />
+                <Recent key={row.id} row={row} agent={name(row)} />
               ))}
             </div>
           ) : (
diff --git a/example/parsar/src/lib/product.ts b/example/parsar/src/lib/product.ts
index a3dfd6590..9c9b9bc76 100644
--- a/example/parsar/src/lib/product.ts
+++ b/example/parsar/src/lib/product.ts
@@ -69,6 +69,7 @@ export interface TurnRow extends TurnSummary {
   session_id: string;
   core_session_id: string;
   agent_id: string;
+  agent_name?: string;
   conversation: string;
   source: "web" | "feishu";
   chat_type?: "p2p" | "group";
diff --git a/example/parsar/tests/cli.test.mjs b/example/parsar/tests/cli.test.mjs
index 5824870b7..03291e72f 100644
--- a/example/parsar/tests/cli.test.mjs
+++ b/example/parsar/tests/cli.test.mjs
@@ -7,6 +7,7 @@ import { fileURLToPath } from "node:url";
 import { createParsarClient } from "../cli.mjs";
 import { createHandler } from "../server.mjs";
 import { openStore } from "../server/store.mjs";
+import { savedResourcesFetch } from "./core-double.mjs";
 
 const cli = fileURLToPath(new URL('../cli.mjs', import.meta.url));
 const configure = fileURLToPath(new URL('../examples/manager/configure.mjs', import.meta.url));
@@ -15,7 +16,7 @@ async function fixture(t, fetchImpl = async () => { throw new Error('Unexpected
   const modelId = randomUUID();
   store.put('models', { id: modelId, name: 'Test model', enabled: true });
   const config = { host: '127.0.0.1', port: 0, target: 'https://core.example', key: 'server-only-core-key' };
-  const server = createServer(createHandler(config, { store, fetchImpl }));
+  const server = createServer(createHandler(config, { store, fetchImpl: savedResourcesFetch(fetchImpl) }));
   await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
   config.port = server.address().port;
   t.after(() => { server.closeAllConnections(); server.close(); store.close(); });
diff --git a/example/parsar/tests/core-double.mjs b/example/parsar/tests/core-double.mjs
new file mode 100644
index 000000000..0686fb899
--- /dev/null
+++ b/example/parsar/tests/core-double.mjs
@@ -0,0 +1,50 @@
+import { randomUUID } from "node:crypto";
+import { AppError } from "../server/store.mjs";
+
+// Core's saved Agents and Environment Templates for tests, in front of a test's
+// own Core for everything else. `saved` holds what Parsar wrote.
+const resource = /^\/v1\/agents(\/environments\/templates)?(?:\/([^/?]+))?$/;
+function handle(saved, path, method, body) {
+  const match = path.match(resource);
+  if (!match || ["sessions", "environments"].includes(match[2])) return;
+  const [, , id] = match;
+  if (!id && method === "POST") {
+    const row = { id: randomUUID(), ...body };
+    saved.set(row.id, row);
+    return { status: 201, value: row };
+  }
+  const row = id && saved.get(id);
+  if (!row) return { status: 404, value: { error: { message: "not found" } } };
+  if (method === "DELETE") {
+    saved.delete(id);
+    return { status: 200, value: { id, deleted: true } };
+  }
+  if (method === "POST") Object.assign(row, body);
+  return { status: 200, value: row };
+}
+
+export function withSavedResources(core) {
+  const saved = new Map();
+  const wrapped = async (path, method, body, key) => {
+    const result = handle(saved, path, method, body);
+    if (!result) return core(path, method, body, key);
+    if (result.status >= 400) throw new AppError(result.status, result.value.error.message);
+    return result.value;
+  };
+  wrapped.saved = saved;
+  // The saved Core Agent a Session request references.
+  wrapped.agentOf = (request) => saved.get(request.agent_id);
+  return wrapped;
+}
+
+export function savedResourcesFetch(fetchImpl) {
+  const saved = new Map();
+  const wrapped = async (url, init = {}) => {
+    const { pathname } = new URL(url);
+    if (!resource.test(pathname)) return fetchImpl(url, init);
+    const result = handle(saved, pathname, init.method || "GET", init.body ? JSON.parse(init.body) : undefined);
+    return result ? Response.json(result.value, { status: result.status }) : fetchImpl(url, init);
+  };
+  wrapped.saved = saved;
+  return wrapped;
+}
diff --git a/example/parsar/tests/feishu.test.mjs b/example/parsar/tests/feishu.test.mjs
index 447c14bc4..8b191195c 100644
--- a/example/parsar/tests/feishu.test.mjs
+++ b/example/parsar/tests/feishu.test.mjs
@@ -3,6 +3,7 @@ import assert from "node:assert/strict";
 import { randomUUID } from "node:crypto";
 import { openStore, AppError } from "../server/store.mjs";
 import { productAPI } from "../server/product.mjs";
+import { withSavedResources } from "./core-double.mjs";
 import { feishuOperations } from "../server/feishu.mjs";
 import { feishuWorker as workerForBot } from "../server/feishu.mjs";
 
@@ -49,7 +50,8 @@ async function setup(t) {
     if (path.includes("/artifacts")) return { data: [], has_more: false };
     return { id, status: resource.status };
   };
-  const api = productAPI(store, core);
+  const savedCore = withSavedResources(core);
+  const api = productAPI(store, savedCore);
   const put = (kind, body, id = randomUUID()) =>
     api("PUT", `/app/${kind}/${id}`, body);
   const provider = await put("providers", {
@@ -77,7 +79,7 @@ async function setup(t) {
   });
   return {
     store,
-    core,
+    core: savedCore,
     api,
     put,
     agent,
@@ -581,7 +583,7 @@ test("Feishu can withdraw an unstarted conversation and recover a lost creation
   );
 });
 
-test("capability versions freeze into dispatch and retired capabilities cannot start new work", async (t) => {
+test("pinned capability versions reach the saved Agent and retired capabilities cannot start new work", async (t) => {
   const f = await setup(t),
     id = randomUUID();
   const cap = await f.api("PUT", `/app/capabilities/${id}`, {
@@ -609,8 +611,10 @@ test("capability versions freeze into dispatch and retired capabilities cannot s
     agent_id: agent.id,
     input: "Work",
   });
-  assert.match(f.calls[0].body.agent.instructions, /Always verify/);
-  assert.doesNotMatch(f.calls[0].body.agent.instructions, /Updated rules/);
+  // A pinned version reaches the saved Core Agent the Session references.
+  const saved = f.core.agentOf(f.calls[0].body);
+  assert.match(saved.instructions, /Always verify/);
+  assert.doesNotMatch(saved.instructions, /Updated rules/);
   const current = await f.api("GET", `/app/capabilities/${id}`);
   await f.api("PUT", `/app/capabilities/${id}`, {
     ...current,
diff --git a/example/parsar/tests/fixture.mjs b/example/parsar/tests/fixture.mjs
index 927ff156f..e76fe7a52 100644
--- a/example/parsar/tests/fixture.mjs
+++ b/example/parsar/tests/fixture.mjs
@@ -115,7 +115,7 @@ createServer(async (req, res) => {
     executorConnected = true;
     return reply({});
   }
-  if (/^\/v1\/agents\/environments\/[^/]+$/.test(url.pathname)) {
+  if (/^\/v1\/agents\/environments\/(?!templates$)[^/]+$/.test(url.pathname)) {
     return reply({
       id: url.pathname.split("/").at(-1),
       object: "agent.environment",
@@ -255,7 +255,11 @@ createServer(async (req, res) => {
       agents = agents.filter((row) => row !== agent);
       return reply({ id: agent.id, object: "agent.deleted", deleted: true });
     }
-    if (req.method === "POST") Object.assign(agent, body);
+    // A null field resets the saved Agent to its default.
+    if (req.method === "POST")
+      for (const [key, value] of Object.entries(body))
+        if (value === null) delete agent[key];
+        else agent[key] = value;
     return reply(agent);
   }
   if (
@@ -266,6 +270,15 @@ createServer(async (req, res) => {
     templates.push(template);
     return reply(template, 201);
   }
+  const template = templates.find((t) => url.pathname === `/v1/agents/environments/templates/${t.id}`);
+  if (template) {
+    if (req.method === "DELETE") {
+      templates = templates.filter((row) => row !== template);
+      return reply({ id: template.id, deleted: true });
+    }
+    if (req.method === "POST") Object.assign(template, body);
+    return reply(template);
+  }
   if (url.pathname === "/v1/skills" && req.method === "GET")
     return reply(page(skills));
   const versionMatch = url.pathname.match(/^\/v1\/skills\/([^/]+)\/versions$/);
@@ -348,12 +361,21 @@ createServer(async (req, res) => {
       );
     const key = req.headers["idempotency-key"];
     if (receipts.has(key)) return reply(receipts.get(key));
+    // A saved Agent supplies the configuration; an inline `agent` overrides it.
+    const reference = body.agent_id && agents.find((a) => a.id === body.agent_id);
+    if (body.agent_id && !reference)
+      return reply({ error: { message: "Agent not found" } }, 404);
+    if (body.environment.environment_template_id && !templates.some((t) => t.id === body.environment.environment_template_id))
+      return reply({ error: { message: "Environment template not found" } }, 404);
+    // A Session's Agent snapshot carries configuration only, not the saved Agent's identity or name.
+    const { id: _id, object: _object, created_at: _created, updated_at: _updated, metadata: _metadata, name: _name, ...referenced } = reference || {};
     const saved = {
       id: randomUUID(),
       name: null,
       service_tier: "auto",
+      ...referenced,
       ...body.agent,
-      reasoning: { effort: null, summary: null, ...body.agent?.reasoning },
+      reasoning: { effort: null, summary: null, ...referenced.reasoning, ...body.agent?.reasoning },
       multi_agent: { enabled: false, max_concurrent_subagents: null },
       text: { format: { type: "text" }, verbosity: "medium" },
     };
diff --git a/example/parsar/tests/product.test.mjs b/example/parsar/tests/product.test.mjs
index 45c5c9384..beb8243c5 100644
--- a/example/parsar/tests/product.test.mjs
+++ b/example/parsar/tests/product.test.mjs
@@ -6,13 +6,14 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import { openStore, dataPath, AppError } from "../server/store.mjs";
 import { productAPI } from "../server/product.mjs";
+import { withSavedResources } from "./core-double.mjs";
 
 test("environment templates prepare hosted Sessions, protect variables and freeze retries", async (t) => {
   const store = openStore(":memory:");
   t.after(() => store.close());
   let failed = true;
   const calls = [];
-  const { api, put, agent: base } = await setup(
+  const { api, put, core, agent: base } = await setup(
     store,
     async (_path, _method, body) => {
       calls.push(structuredClone(body));
@@ -48,14 +49,15 @@ test("environment templates prepare hosted Sessions, protect variables and freez
     ),
     /lost response/,
   );
+  // The saved Core Template holds the preparation; the Session references it.
   const frozen = calls[0];
   assert.equal(frozen.environment.type, "openai_hosted");
-  assert.equal(frozen.environment.env.OFFICE_TOKEN, "private-env");
-  assert.deepEqual(frozen.environment.packages, runtime.packages);
-  assert.equal(
-    frozen.environment.setup_commands[0].command,
-    runtime.setup_script,
-  );
+  const template = core.saved.get(frozen.environment.environment_template_id);
+  assert.equal(template.env.OFFICE_TOKEN, "private-env");
+  assert.deepEqual(template.packages, runtime.packages);
+  assert.equal(template.setup_commands[0].command, runtime.setup_script);
+  assert.ok(!JSON.stringify(frozen).includes("private-env"), "variables stay in the Template");
+  // Session files replace the Template's set, so they carry the Template's own too.
   assert.deepEqual(
     frozen.environment.files.map((f) => f.path),
     ["/workspace/config.txt", "/workspace/inputs/input.txt"],
@@ -205,7 +207,8 @@ test("Provider discovery reports failures without leaking keys or upstream bodie
   store.close();
 });
 
-async function setup(store, core, fetchImpl) {
+async function setup(store, test, fetchImpl) {
+  const core = withSavedResources(test);
   const api = productAPI(store, core, fetchImpl);
   const put = (kind, body, id = randomUUID()) =>
     api("PUT", `/app/${kind}/${id}`, body);
@@ -240,6 +243,7 @@ async function setup(store, core, fetchImpl) {
   return {
     api,
     put,
+    core,
     model,
     runtime,
     agent,
@@ -250,7 +254,7 @@ async function setup(store, core, fetchImpl) {
     },
   };
 }
-test("one Agent creates independent Sessions; edits do not mutate prior execution; retries survive restart", async (t) => {
+test("Sessions reference one saved Core Agent that edits update in place; retries survive restart", async (t) => {
   const root = join(homedir(), ".oac", "tests");
   await mkdir(root, { recursive: true });
   const dir = await mkdtemp(join(root, "parsar-store-"));
@@ -269,7 +273,7 @@ test("one Agent creates independent Sessions; edits do not mutate prior executio
     }
     return receipts.get(key);
   };
-  const { api, put, agent, model, input } = await setup(store, core);
+  const { api, put, core: saved, agent, model, input } = await setup(store, core);
   assert.equal(calls.length, 0);
   const first = await put("sessions", input);
   assert.deepEqual(calls[0].body.environment.skills, [
@@ -281,21 +285,23 @@ test("one Agent creates independent Sessions; edits do not mutate prior executio
     api_key: "provider-secret",
   });
   assert.equal(JSON.stringify(first).includes("provider-secret"), false);
-  assert.equal(calls[0].body.agent.tools.length, 2);
-  assert.deepEqual(calls[0].body.agent.tools[1], {
+  assert.equal(calls[0].body.agent, undefined, "the Session references the saved Agent");
+  const savedAgent = saved.agentOf(calls[0].body);
+  assert.equal(savedAgent.tools.length, 2);
+  assert.deepEqual(savedAgent.tools[1], {
     type: "mcp",
     server_label: "docs",
     transport: { type: "http", server_url: "https://mcp.example/docs" },
     connection_origin: "environment",
     required: true,
   });
-  await put("agents", { ...agent, instructions: "Updated" }, agent.id);
+  assert.equal(savedAgent.instructions, "Review carefully");
+  await put("agents", { ...store.get("agents", agent.id), instructions: "Updated" }, agent.id);
   const second = await put("sessions", input);
   assert.notEqual(first.core_session_id, second.core_session_id);
-  assert.equal(calls[0].body.agent.instructions, "Review carefully");
-  assert.equal(calls[1].body.agent.instructions, "Updated");
+  assert.equal(calls[1].body.agent_id, calls[0].body.agent_id, "an edit updates the same saved Agent");
+  assert.equal(saved.agentOf(calls[1].body).instructions, "Updated");
   await assert.rejects(api("DELETE", `/app/models/${model.id}`), /仍被引用/);
-  await assert.rejects(api("DELETE", `/app/agents/${agent.id}`), /仍被引用/);
   const pending = randomUUID();
   lose = true;
   await assert.rejects(put("sessions", input, pending), /lost response/);
@@ -303,7 +309,7 @@ test("one Agent creates independent Sessions; edits do not mutate prior executio
   store.close();
   store = openStore(path);
   t.after(() => store.close());
-  const resumed = await productAPI(store, core)(
+  const resumed = await productAPI(store, saved)(
     "PUT",
     `/app/sessions/${pending}`,
     {},
@@ -672,7 +678,7 @@ test("the Agent's bound Feishu bot supplies mapped identity variables without ex
   const store = openStore(":memory:");
   t.after(() => store.close());
   const calls = [];
-  const { api, put, agent, input } = await setup(store, async (_p, _m, body) => {
+  const { api, put, core, agent, input } = await setup(store, async (_p, _m, body) => {
     calls.push(body);
     return { id: randomUUID() };
   });
@@ -710,12 +716,13 @@ test("the Agent's bound Feishu bot supplies mapped identity variables without ex
     /已绑定另一个机器人/,
   );
   const record = await put("sessions", input);
+  // The Template keeps its own variables; each Session adds the bot's identity on top.
   assert.deepEqual(calls.at(-1).environment.env, {
-    LARKSUITE_CLI_DEFAULT_AS: "bot",
     FEISHU_APP_ID: "cli_0123456789abcdef",
     FEISHU_APP_SECRET: "bot-secret",
     FEISHU_BRAND: "lark",
   });
+  assert.deepEqual(core.saved.get(calls.at(-1).environment.environment_template_id).env, { LARKSUITE_CLI_DEFAULT_AS: "bot" });
   assert.equal(record.configuration.bot_name, "Assistant");
   assert.ok(record.configuration.env_names.includes("FEISHU_APP_SECRET"));
   assert.ok(!JSON.stringify(await api("GET", "/app/sessions")).includes("bot-secret"));
@@ -724,11 +731,11 @@ test("the Agent's bound Feishu bot supplies mapped identity variables without ex
   await assert.rejects(api("DELETE", `/app/agents/${agent.id}`), /仍被引用/);
 });
 
-test("Agents carry Harness options into the Session request and reject undeclared values", async (t) => {
+test("Agents carry Harness options into the saved Core Agent and reject undeclared values", async (t) => {
   const store = openStore(":memory:");
   t.after(() => store.close());
   const sent = [];
-  const { api, put, agent, input } = await setup(store, async (_path, _method, body) => {
+  const { api, put, core, agent, input } = await setup(store, async (_path, _method, body) => {
     sent.push(body);
     return { id: randomUUID() };
   });
@@ -747,12 +754,13 @@ test("Agents carry Harness options into the Session request and reject undeclare
   );
   await put("sessions", input);
   const request = sent[0];
-  assert.deepEqual(request.agent.x_agents_core, { harness: "codex" });
-  assert.deepEqual(request.agent.reasoning, { effort: "high", summary: "auto" });
-  assert.deepEqual(request.agent.text, { verbosity: "low" });
-  assert.equal(request.agent.service_tier, "priority");
+  const saved = core.agentOf(request);
+  assert.deepEqual(saved.x_agents_core, { harness: "codex" });
+  assert.deepEqual(saved.reasoning, { effort: "high", summary: "auto" });
+  assert.deepEqual(saved.text, { verbosity: "low" });
+  assert.equal(saved.service_tier, "priority");
   assert.deepEqual(
-    request.agent.tools.find((tool) => tool.type === "web_search"),
+    saved.tools.find((tool) => tool.type === "web_search"),
     { type: "web_search", mode: "live" },
   );
   assert.equal(request.x_agents_core.model_provider.protocol, "responses");
@@ -763,9 +771,10 @@ test("Agents carry Harness options into the Session request and reject undeclare
   );
   assert.equal(plain.web_search, "disabled");
   await put("sessions", { ...input, name: "Plain" });
-  assert.equal(sent[1].agent.reasoning, undefined);
-  assert.equal(sent[1].agent.service_tier, undefined);
-  assert.deepEqual(sent[1].agent.text, { verbosity: "medium" });
+  // Cleared settings reset the saved Agent instead of keeping old values.
+  assert.equal(core.agentOf(sent[1]).reasoning, null);
+  assert.equal(core.agentOf(sent[1]).service_tier, null);
+  assert.deepEqual(core.agentOf(sent[1]).text, { verbosity: "medium" });
   assert.equal(sent[1].x_agents_core.model_provider.protocol, "anthropic");
   for (const [patch, message] of [
     [{ reasoning_summary: "auto" }, /Claude Code 不支持所选的推理摘要/],
@@ -853,7 +862,7 @@ test("Agent resources follow Core's Environment limits instead of one shared bud
   const make = (kind, n) =>
     Array.from({ length: n }, (_, i) => {
       const id = randomUUID();
-      store.put("capabilities", { id, kind, name: `${kind} ${i}`, default_version: "1", versions: [{ version: "1" }] });
+      store.put("capabilities", { id, kind, name: `${kind} ${i}`, default_version: "1", versions: [{ version: "1", content: "x", archive: "UEsFBgAAAAAAAAAAAAAAAAAAAAAAAA==" }] });
       return id;
     });
   const prompts = make("prompt", 12),
@@ -1115,3 +1124,90 @@ test("the run overview lists running and recent Turns with their stage, counts a
   assert.equal(overview.stats.concurrency.length, 31);
   assert.equal(overview.stats.concurrency.at(-1), 1);
 });
+
+test("Agents and templates live in Core as saved resources that follow every change", async (t) => {
+  const store = openStore(":memory:");
+  t.after(() => store.close());
+  const sent = [];
+  let rejectAgents = false;
+  const { api, put, core, agent, runtime, input } = await setup(store, async (_path, _method, body) => {
+    sent.push(body);
+    return { id: randomUUID() };
+  });
+  const coreAgentId = store.get("agents", agent.id).core_agent_id;
+  const coreTemplateId = store.get("runtimes", runtime.id).core_template_id;
+  assert.equal(core.saved.get(coreAgentId).metadata.parsar_agent_id, agent.id);
+  assert.ok(core.saved.has(coreTemplateId));
+
+  // An edit updates the same saved Agent.
+  await put("agents", { ...store.get("agents", agent.id), instructions: "Edited" }, agent.id);
+  assert.equal(store.get("agents", agent.id).core_agent_id, coreAgentId);
+  assert.equal(core.saved.get(coreAgentId).instructions, "Edited");
+
+  // An edit Core rejects is not kept.
+  const rejecting = async (path, method, body, key) => {
+    if (rejectAgents && path.startsWith("/v1/agents/") && method === "POST") throw new AppError(400, "invalid agent");
+    return core(path, method, body, key);
+  };
+  const guarded = productAPI(store, rejecting);
+  rejectAgents = true;
+  await assert.rejects(
+    guarded("PUT", `/app/agents/${agent.id}`, { ...store.get("agents", agent.id), instructions: "Rejected" }),
+    /invalid agent/,
+  );
+  assert.equal(store.get("agents", agent.id).instructions, "Edited");
+  rejectAgents = false;
+
+  // What an Agent binds reaches its saved Agent when the next Session starts.
+  const mcpId = store.get("agents", agent.id).mcp_ids[0];
+  await put("mcps", { ...store.get("mcps", mcpId), url: "https://mcp.example/v2" }, mcpId);
+  await put("sessions", input);
+  assert.equal(sent.at(-1).agent_id, coreAgentId);
+  assert.equal(sent.at(-1).environment.environment_template_id, coreTemplateId);
+  assert.equal(core.saved.get(coreAgentId).tools.find((tool) => tool.type === "mcp").transport.server_url, "https://mcp.example/v2");
+
+  // A new Project loses the saved resources; the next use creates them again.
+  core.saved.clear();
+  await api.resources.verify();
+  assert.equal(store.get("agents", agent.id).core_agent_id, undefined);
+  await put("sessions", { ...input, name: "After move" });
+  assert.ok(core.saved.has(sent.at(-1).agent_id));
+  assert.ok(core.saved.has(sent.at(-1).environment.environment_template_id));
+
+  // Deleting a template deletes its saved Core Template.
+  const spare = await put("runtimes", { name: "Spare" });
+  const spareTemplate = store.get("runtimes", spare.id).core_template_id;
+  await api("DELETE", `/app/runtimes/${spare.id}`, {});
+  assert.equal(core.saved.has(spareTemplate), false);
+});
+
+test("only live configuration blocks deletion; conversations keep their snapshot and history", async (t) => {
+  const store = openStore(":memory:");
+  t.after(() => store.close());
+  const calls = [];
+  const { api, put, core, agent, runtime, model, input } = await setup(store, async (path, method, body) => {
+    calls.push({ path, method });
+    return { id: randomUUID() };
+  });
+  const conversation = await put("sessions", input);
+  // An Agent that uses a template, model or MCP keeps them.
+  await assert.rejects(api("DELETE", `/app/runtimes/${runtime.id}`), /仍被引用/);
+  await assert.rejects(api("DELETE", `/app/models/${model.id}`), /仍被引用/);
+  await assert.rejects(api("DELETE", `/app/mcps/${agent.mcp_ids[0]}`), /仍被引用/);
+  // A bot bound to the Agent keeps it.
+  store.put("feishu_bots", { id: randomUUID(), agent_id: agent.id });
+  await assert.rejects(api("DELETE", `/app/agents/${agent.id}`), /仍被引用/);
+  store.remove("feishu_bots", store.list("feishu_bots")[0].id);
+  // A conversation is history, not a dependency.
+  const coreAgentId = store.get("agents", agent.id).core_agent_id;
+  await api("DELETE", `/app/agents/${agent.id}`, {});
+  assert.equal(core.saved.has(coreAgentId), false);
+  await api("DELETE", `/app/runtimes/${runtime.id}`, {});
+  await api("DELETE", `/app/mcps/${agent.mcp_ids[0]}`, {});
+  await api("DELETE", `/app/models/${model.id}`, {});
+  const kept = await api("GET", `/app/sessions/${conversation.id}`);
+  assert.equal(kept.core_session_id, conversation.core_session_id);
+  assert.equal(kept.configuration.agent_name, "Reviewer");
+  assert.ok((await api("GET", "/app/sessions")).some((row) => row.id === conversation.id));
+  assert.equal(calls.some((call) => call.method === "DELETE" && call.path.includes("/sessions/")), false, "its Core Session and messages stay");
+});
diff --git a/example/parsar/tests/server.test.mjs b/example/parsar/tests/server.test.mjs
index 3c7cf36f3..0c676a67f 100644
--- a/example/parsar/tests/server.test.mjs
+++ b/example/parsar/tests/server.test.mjs
@@ -1,7 +1,9 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import { createServer, request } from "node:http";
+import { randomUUID } from "node:crypto";
 import { configuration, createHandler } from "../server.mjs";
+import { openStore } from "../server/store.mjs";
 
 test("oversized writes return a definite 413 without contacting Core", async (t) => {
   let called = false;
@@ -9,7 +11,7 @@ test("oversized writes return a definite 413 without contacting Core", async (t)
     called = true;
     return Response.json({});
   });
-  const response = await fetch(`${url}/v1/agents`, {
+  const response = await fetch(`${url}/v1/vaults`, {
     method: "POST",
     headers: { origin: url },
     body: "x".repeat(1024 * 1024 + 1),
@@ -18,14 +20,14 @@ test("oversized writes return a definite 413 without contacting Core", async (t)
   assert.equal(called, false);
 });
 
-async function serve(t, fetchImpl, host) {
+async function serve(t, fetchImpl, host, store) {
   const config = {
     port: 0,
     key: "server-only-secret",
     target: "https://core.example",
     ...(host ? { host } : {}),
   };
-  const server = createServer(createHandler(config, { fetchImpl }));
+  const server = createServer(createHandler(config, { fetchImpl, store }));
   await new Promise((done) => server.listen(0, "127.0.0.1", done));
   config.port = server.address().port;
   t.after(() => {
@@ -39,7 +41,7 @@ test("server injects only the project key and preserves request identity", async
   let called = false;
   const url = await serve(t, async (target, init) => {
     called = true;
-    assert.equal(target, "https://core.example/v1/agents");
+    assert.equal(target, "https://core.example/v1/vaults");
     assert.equal(init.headers.Authorization, "Bearer server-only-secret");
     assert.equal(init.headers["Idempotency-Key"], "same-operation");
     assert.equal(init.headers["OpenAI-Beta"], "agents=v1");
@@ -47,7 +49,7 @@ test("server injects only the project key and preserves request identity", async
     assert.equal(init.headers.cookie, undefined);
     return Response.json({ id: "session" }, { status: 201 });
   });
-  const result = await fetch(`${url}/v1/agents`, {
+  const result = await fetch(`${url}/v1/vaults`, {
     method: "POST",
     body: "{}",
     headers: {
@@ -67,14 +69,17 @@ test("cross-origin, rebinding, management and encoded paths never reach Core", a
     throw new Error("must not reach Core");
   });
   for (const [path, headers, method, status] of [
-    ["/v1/agents", { origin: "https://evil.example" }, "GET", 403],
-    ["/v1/agents", { host: "evil.example" }, "GET", 403],
-    ["/v1/agents", { "sec-fetch-site": "cross-site" }, "GET", 403],
-    ["/v1/agents", {}, "POST", 403],
+    ["/v1/vaults", { origin: "https://evil.example" }, "GET", 403],
+    ["/v1/vaults", { host: "evil.example" }, "GET", 403],
+    ["/v1/vaults", { "sec-fetch-site": "cross-site" }, "GET", 403],
+    ["/v1/vaults", {}, "POST", 403],
     ["/core/v1/projects", {}, "GET", 404],
     ["/api/v1/devices", {}, "GET", 404],
     ["/v1/agents%2fsessions", {}, "GET", 404],
-    ["/v1/agents", {}, "DELETE", 404],
+    ["/v1/vaults", {}, "DELETE", 404],
+    // Saved Agents and Templates are written only by Parsar's server.
+    ["/v1/agents", {}, "GET", 404],
+    ["/v1/agents/environments/templates", {}, "GET", 404],
   ]) {
     const received = await new Promise((done, reject) => {
       const req = request(`${url}${path}`, { method, headers }, (res) => {
@@ -104,7 +109,7 @@ test("redirects and transport errors do not expose credentials or follow another
     },
   ]) {
     const url = await serve(t, reply);
-    const result = await fetch(`${url}/v1/agents`);
+    const result = await fetch(`${url}/v1/vaults`);
     assert.equal(result.status, 502);
     assert.equal((await result.text()).includes("server-only-secret"), false);
   }
@@ -359,7 +364,7 @@ test("loopback port forwarding preserves exact-origin writes and rejects non-loo
   ]) {
     const actual = await new Promise((resolve, reject) => {
       const req = request(
-        `${url}/v1/agents`,
+        `${url}/v1/vaults`,
         { method: "POST", headers: { host, ...(origin ? { origin } : {}) } },
         (res) => {
           res.resume();
@@ -391,7 +396,7 @@ test("a configured LAN address is the only accepted Host", async (t) => {
   ]) {
     const actual = await new Promise((resolve, reject) => {
       const req = request(
-        `${url}/v1/agents`,
+        `${url}/v1/vaults`,
         { method: "POST", headers: { host, origin: `http://${host}` } },
         (res) => {
           res.resume();
@@ -404,3 +409,19 @@ test("a configured LAN address is the only accepted Host", async (t) => {
     assert.equal(actual, status, host);
   }
 });
+
+test("a Skill an Agent binds is not deleted", async (t) => {
+  const store = openStore(":memory:");
+  t.after(() => store.close());
+  store.put("agents", { id: randomUUID(), skill_ids: ["skill_bound"] });
+  const deleted = [];
+  const url = await serve(t, async (target) => {
+    deleted.push(String(target));
+    return Response.json({ id: "skill_free", deleted: true });
+  }, undefined, store);
+  const remove = (id) => fetch(`${url}/v1/skills/${id}`, { method: "DELETE", headers: { Origin: url } });
+  assert.equal((await remove("skill_bound")).status, 409);
+  assert.equal(deleted.length, 0);
+  assert.equal((await remove("skill_free")).status, 200);
+  assert.equal(deleted.length, 1);
+});

From aaaf6dcca8d56a2d13e722ff5ee4e5637be1f95a Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Mon, 26 Oct 2026 15:15:22 +0800
Subject: [PATCH 07/19] Unify the capability library and give the bound bot's
 identity to every conversation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The library listed each capability kind on its own page, credentials were
bound to MCP servers for every Agent alike, and a bot's identity reached a
conversation only when its environment template mapped the bot's fields
to variables, which templates easily missed: an Agent with a bound bot then
ran without identity and tried to register a new app.

资源库 now has 能力, 模型 and 凭据. 能力 lists every Skill, MCP, Plugin,
instruction fragment and knowledge item with its version, enabled Agents
and the credentials it needs, and 新建能力 adds any kind. Skills, Plugins
and environment templates declare the variables they need; each Agent
chooses a secret (凭据 → 密钥, write-only) for each, and a Vault credential
for each MCP marked as needing one. An Agent cannot be saved with a
credential missing, and choices nothing needs are dropped.

A bound bot's identity reaches every conversation of its Agent as
FEISHU_APP_ID, FEISHU_APP_SECRET and FEISHU_BRAND; only the bot supplies
these names. Declaring them marks a need for a bot. The template mapping
and its editor are removed. A bot takes the name its app has in Feishu
when it connects.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/README.md                      |  18 +-
 example/parsar/README.zh.md                   |  20 +-
 .../parsar/examples/feishu/environment.json   |   6 +-
 example/parsar/examples/manager/GUIDE.md      |   6 +-
 example/parsar/server/capabilities.mjs        |   4 +-
 example/parsar/server/capability-kinds.mjs    |  91 ++++-
 example/parsar/server/feishu.mjs              |   9 +-
 example/parsar/server/product.mjs             |  51 ++-
 example/parsar/server/runtime-profile.mjs     |  26 +-
 example/parsar/server/sessions.mjs            |  28 +-
 example/parsar/shared/bot-bindings.d.mts      |   2 +
 example/parsar/shared/bot-bindings.mjs        |  11 +-
 example/parsar/src/AgentPage.tsx              |   1 +
 example/parsar/src/App.tsx                    |   6 +-
 example/parsar/src/Capabilities.tsx           | 172 +++-------
 example/parsar/src/ConfigurationFields.tsx    | 211 ++++++++----
 example/parsar/src/Credentials.tsx            | 158 ++++++++-
 example/parsar/src/EnvironmentFields.tsx      |  87 +----
 example/parsar/src/Feishu.tsx                 |  18 -
 example/parsar/src/Library.tsx                | 316 ++++++++++++++++++
 example/parsar/src/Resources.tsx              | 246 +++-----------
 example/parsar/src/Skills.tsx                 | 132 ++------
 example/parsar/src/lib/en.json                |  61 ++--
 example/parsar/src/lib/product.ts             |  22 +-
 example/parsar/src/lib/usage.ts               |  17 +-
 example/parsar/tests/feishu.test.mjs          |  14 +
 example/parsar/tests/product.test.mjs         |  83 ++++-
 example/parsar/tests/workflow.spec.ts         |  65 +++-
 28 files changed, 1154 insertions(+), 727 deletions(-)
 create mode 100644 example/parsar/shared/bot-bindings.d.mts
 create mode 100644 example/parsar/src/Library.tsx

diff --git a/example/parsar/README.md b/example/parsar/README.md
index fbd9c107e..1f789952f 100644
--- a/example/parsar/README.md
+++ b/example/parsar/README.md
@@ -22,7 +22,7 @@ Open http://127.0.0.1:18180. `OPENAI_BASE_URL` ends in `/v1`; remote endpoints r
 | Object | What it is |
 | --- | --- |
 | **资源库** | Building blocks, grouped by what uses them: models for Agent engines; Skills, MCP servers, Plugins, knowledge and instruction fragments for Agents; credentials for MCP. Resources are shared: editing one affects everything that uses it. Only live configuration blocks removal: an Agent that binds an item, an Agent that uses a template or model, or a bot bound to an Agent. Conversations do not; they keep the configuration snapshot they were created with and their full history. |
-| **环境模板** | The prepared workspace: npm and Python packages, a Bash setup script, environment variables, Feishu bot variables and initial files. |
+| **环境模板** | The prepared workspace: npm and Python packages, a Bash setup script, environment variables, the secrets it needs and initial files. |
 | **Agent** | What people talk to: name, description, instructions, how it runs, one required environment template, capabilities and behavior switches. How it runs mirrors a local Codex configuration: Harness, model, reasoning effort, web search and, under **高级**, reasoning summary, verbosity and service tier. **复制** creates an independent copy. |
 | **飞书机器人** | One bot is bound to at most one Agent. It routes its chats to that Agent and is the Agent’s Feishu identity in every conversation, including Web chats. |
 | **对话** | One public Core Session with its own Environment, created from the Agent's saved Core Agent and its environment template's Core Environment Template. Core copies both when the Session starts. |
@@ -102,12 +102,16 @@ Optional business questions use the declared `ask_user` function. They appear in
 
 **模型** groups model IDs under Providers. Fetch a Provider’s OpenAI-shaped `GET /v1/models` catalog or enter IDs manually. Keys remain server-side; blank edits preserve the saved key. **测试** sends one tiny generation with the saved connection and shows the latency or the provider's error, never the key. Discovery sends only that Provider’s key and never follows redirects. Every Harness uses the selected HTTPS Provider: Responses for Codex, Anthropic for Claude Code and MiniMax Code. Unsupported combinations fail explicitly; consult the [Harness coverage ledger](../../contracts/agents-api/index.md).
 
-- **Skills** supports SKILL.md creation, ZIP upload, versions, default selection, per-Agent version pins and bounded file previews. **浏览目录** searches the skills.sh index; previews use the pinned `skills@1.5.23` CLI in a temporary directory and the normal public Skill upload. This requires `npx` and network access on the Parsar host. Imported archives are bounded to 32 MiB and 1,000 files.
-- **MCP** provides a static service directory and HTTPS endpoint configuration. Optional Vault credentials use official public MCP tools with environment origin.
-- **凭据** creates Vaults and write-only bearer credentials. **OAuth 授权** uses the maintained MCP SDK for discovery, dynamic client registration, issuer binding and PKCE, then stores the token through public Vault APIs. OAuth tokens never return to the browser.
+**资源库** has three tabs: **能力**, **模型** and **凭据**.
+
+- **能力** lists every capability Agents can bind in one table, with its type, version, the number of enabled Agents that bind it and the credentials it needs; filters narrow it to Skill, MCP, Plugin, 指令片段 or 知识. **新建能力** adds any kind: an HTTP MCP, one from the MCP directory, a written or uploaded Skill, one from the Skill directory, a Plugin, an instruction fragment or knowledge.
+- **Skills** have versions, default selection, per-Agent version pins and bounded file previews. The Skill directory searches the skills.sh index; previews use the pinned `skills@1.5.23` CLI in a temporary directory and the normal public Skill upload, which requires `npx` and network access on the Parsar host. Imported archives are bounded to 32 MiB and 1,000 files.
+- **MCP** servers are HTTPS endpoints using official public MCP tools with environment origin. One marked **需要凭据** uses the Vault credential each Agent that binds it chooses.
 - Instruction fragments and knowledge have immutable numbered versions, defaults, pins and deprecation. Knowledge versions become initial workspace files. Standard Claude/Codex Plugin ZIPs become public Environment Plugins; declared `.mcp.json` servers are listed. Executables required by stdio servers must exist in the environment.
+- A Skill or Plugin can list the variables it needs (**需要的密钥**). Each Agent that binds it chooses a secret for each in its **凭据** section, and a conversation receives the values as environment variables. An Agent cannot be saved until every credential its capabilities need is chosen; a choice nothing needs any more is dropped.
+- **凭据** holds **密钥**, write-only values for those variables, and **MCP 凭据**: Vaults with write-only bearer credentials. **OAuth 授权** uses the maintained MCP SDK for discovery, dynamic client registration, issuer binding and PKCE, then stores the token through public Vault APIs. Secret values and OAuth tokens never return to the browser.
 
-**环境模板** runs only in Core-managed workspaces. Each new conversation installs files and packages and completes setup before starting the Agent; a setup failure stops execution. Initial files use canonical `/workspace/` paths; scripts run from the workspace. Variable values are write-only in product responses: `null` preserves an existing value, a string replaces it and removing the name deletes it. **飞书机器人变量** map variable names to the bound bot’s **App ID**, **App Secret** or region; a conversation with such a template requires the Agent to have a bound bot. Each template is saved as a Core Environment Template and each Agent as a Core Agent. Parsar rewrites them when they or anything they bind change, and recreates them on next use if the Core Project changed. A conversation's Session references both and adds only what differs per conversation: the bot variables, the Agent's Skills, Plugins and knowledge files, and attachments ([template inheritance](../../contracts/agents-api/environments.md#inheritance)). Core may reuse an identical earlier preparation for up to 24 hours ([preparation reuse](../../contracts/agents-api/environments.md#preparation-reuse)), and a long-idle conversation can move to a new sandbox; in both cases only `/environment` (including `/workspace`) is kept and setup does not run again. Setup must therefore write everything it needs later under `/workspace` or the package directories, never under HOME. The Feishu workspace keeps lark-cli's configuration and encrypted credentials in `/workspace/.lark-cli` through `LARKSUITE_CLI_CONFIG_DIR` and `LARKSUITE_CLI_DATA_DIR`.
+**环境模板** runs only in Core-managed workspaces. Each new conversation installs files and packages and completes setup before starting the Agent; a setup failure stops execution. Initial files use canonical `/workspace/` paths; scripts run from the workspace. Variable values are write-only in product responses: `null` preserves an existing value, a string replaces it and removing the name deletes it. **需要的密钥** lists variables the Agent supplies, as for Skills and Plugins. Each template is saved as a Core Environment Template and each Agent as a Core Agent. Parsar rewrites them when they or anything they bind change, and recreates them on next use if the Core Project changed. A conversation's Session references both and adds only what differs per conversation: the bot variables, the Agent's Skills, Plugins and knowledge files, and attachments ([template inheritance](../../contracts/agents-api/environments.md#inheritance)). Core may reuse an identical earlier preparation for up to 24 hours ([preparation reuse](../../contracts/agents-api/environments.md#preparation-reuse)), and a long-idle conversation can move to a new sandbox; in both cases only `/environment` (including `/workspace`) is kept and setup does not run again. Setup must therefore write everything it needs later under `/workspace` or the package directories, never under HOME. The Feishu workspace keeps lark-cli's configuration and encrypted credentials in `/workspace/.lark-cli` through `LARKSUITE_CLI_CONFIG_DIR` and `LARKSUITE_CLI_DATA_DIR`.
 
 **提前准备，新对话无需等待安装** keeps one prepared Session for each Agent that uses the template. Parsar creates it without input, so Core prepares its Environment ahead of time, and the next Web or Feishu conversation takes it over with its first message; the conversation keeps its own title. A prepared Session is replaced when the Agent, its environment template, bot or model provider changes, after 12 hours, or once taken; turning the switch off discards it. A first message with images or files starts an ordinary Session. Each prepared Session holds a workspace while it waits.
 
@@ -127,11 +131,11 @@ Accepted messages are committed to SQLite before the WebSocket ACK; request IDs
 
 ### Bot identity
 
-The Agent acts as its bound bot. With **飞书机器人变量**, Parsar puts the bot’s App ID and App Secret into the conversation’s Environment variables. The Feishu case maps them to `FEISHU_*` names and its setup script runs `lark-cli config init --app-secret-stdin`, so the CLI mints and refreshes tenant tokens itself and long conversations keep working. Do not map them to `LARKSUITE_CLI_APP_ID` or `LARKSUITE_CLI_APP_SECRET`: those switch lark-cli to environment credentials, which require a ready-made tenant token. Anyone who can talk to the bot can use the bot’s permissions, and tools in the Environment can read the secret. Grant the bot only the scopes its Agent needs and prefer one bot per Agent. A rotated secret applies to new conversations only.
+The Agent acts as its bound bot. Every conversation of an Agent with a bound bot, Web ones included, receives the bot’s identity as `FEISHU_APP_ID`, `FEISHU_APP_SECRET` and `FEISHU_BRAND`; nothing needs to be mapped. A template, Skill or Plugin that needs the bot lists these names under **需要的密钥**: the library shows **飞书机器人** as its requirement, the Agent page shows the bot that provides it, and an Agent without a bot cannot be saved. Only the bound bot supplies these names. The Feishu case's setup script runs `lark-cli config init --app-secret-stdin`, so the CLI mints and refreshes tenant tokens itself and long conversations keep working. Do not pass them as `LARKSUITE_CLI_APP_ID` or `LARKSUITE_CLI_APP_SECRET`: those switch lark-cli to environment credentials, which require a ready-made tenant token. Anyone who can talk to the bot can use the bot’s permissions, and tools in the Environment can read the secret. Grant the bot only the scopes its Agent needs and prefer one bot per Agent. A rotated secret applies to new conversations only.
 
 ### Feishu workspace case
 
-[The Feishu workspace](examples/feishu/) is assembled from ordinary templates. [environment.json](examples/feishu/environment.json) declares packages, bot variables and files, [setup.sh](examples/feishu/setup.sh) installs the checksum-verified official CLI binary and configures it with the bot credentials, [agent.json](examples/feishu/agent.json) defines a Codex Agent. Configure a model, import the official `lark-shared` Skill and the business Skills you need, add a bot, then run:
+[The Feishu workspace](examples/feishu/) is assembled from ordinary templates. [environment.json](examples/feishu/environment.json) declares packages, the bot identity it needs and files, [setup.sh](examples/feishu/setup.sh) installs the checksum-verified official CLI binary and configures it with the bot credentials, [agent.json](examples/feishu/agent.json) defines a Codex Agent. Configure a model, import the official `lark-shared` Skill and the business Skills you need, add a bot, then run:
 
 ```bash
 node example/parsar/examples/feishu/configure.mjs --url http://localhost:3001 --model MODEL_ID --bot BOT_ID --skills SHARED_SKILL_ID,DOMAIN_SKILL_ID
diff --git a/example/parsar/README.zh.md b/example/parsar/README.zh.md
index 576f66666..c3b3331ed 100644
--- a/example/parsar/README.zh.md
+++ b/example/parsar/README.zh.md
@@ -1,6 +1,6 @@
 ---
 source: example/parsar/README.md
-source_hash: 62934f80a9b631d42ea26739bc2439bc11093975debcbf789fe48f567603a1fe
+source_hash: bf6d042037c030463b3ad1723b7d8789edd471c4f1f3b96ef3f11843ca6fa158
 ---
 
 # Parsar 工作空间
@@ -27,7 +27,7 @@ pnpm --filter @oac/parsar-example dev
 | 对象 | 含义 |
 | --- | --- |
 | **资源库** | 组装用的零件，按使用方分组：模型供 Agent 的执行引擎使用；Skills、MCP 服务、Plugins、知识和指令片段供 Agent 使用；凭据供 MCP 使用。资源是共享的：修改一项会影响所有使用它的对象。只有仍然有效的配置会阻止删除：Agent 绑定了这项能力、Agent 使用这个环境模板或模型，或者机器人绑定了这个 Agent。对话不算：它保留创建时的配置快照和完整历史。 |
-| **环境模板** | 准备好的工作区：npm 与 Python 软件包、Bash 初始化脚本、环境变量、飞书机器人变量和初始文件。 |
+| **环境模板** | 准备好的工作区：npm 与 Python 软件包、Bash 初始化脚本、环境变量、需要的密钥和初始文件。 |
 | **Agent** | 用户对话的对象：名称、描述、指令、运行方式、一个必选的环境模板、能力和行为开关。运行方式对应本地 Codex 的配置：Harness、模型、推理强度、网页搜索，以及 **高级** 中的推理摘要、输出详细度和服务层级。**复制**会生成一份独立副本。 |
 | **飞书机器人** | 一个机器人最多绑定一个 Agent。它把自己的聊天路由给该 Agent，并在所有对话中（包括网页对话）作为该 Agent 的飞书身份。 |
 | **对话** | 一个公开 Core Session，拥有独立的 Environment，由 Agent 对应的 Core Agent 和环境模板对应的 Core Environment Template 创建。Session 开始时，Core 会复制这两份配置。 |
@@ -107,12 +107,16 @@ Parsar 会跟踪每一轮正在执行的对话，网页和飞书都一样。出
 
 **模型** 按 Provider 分组管理模型 ID。可获取 Provider 的 OpenAI 格式 `GET /v1/models` 目录，也可手动填写。密钥只保存在服务端，留空编辑会保留已保存的密钥。**测试** 会用已保存的连接发起一次极小的生成，显示耗时或服务商返回的错误，不会显示密钥。获取目录时只发送该 Provider 的密钥，且不跟随重定向。所有 Harness 都使用所选的 HTTPS Provider：Codex 使用 Responses 协议，Claude Code 和 MiniMax Code 使用 Anthropic 协议。不支持的组合会明确失败，请参阅 [Harness 覆盖记录](../../contracts/agents-api/zh/index.md)。
 
-- **Skills** 支持创建 SKILL.md、上传 ZIP、版本管理、默认版本选择、按 Agent 固定版本以及有限的文件预览。**浏览目录** 搜索 skills.sh 索引；预览在临时目录中使用固定版本的 `skills@1.5.23` CLI，再走常规公开 Skill 上传。这需要 Parsar 主机具备 `npx` 和网络访问。导入的压缩包限制为 32 MiB 和 1,000 个文件。
-- **MCP** 提供静态服务目录和 HTTPS 端点配置。可选的 Vault 凭据使用官方公开 MCP 工具，连接来源为 environment。
-- **凭据** 创建 Vault 和只写的 bearer 凭据。**OAuth 授权** 使用维护中的 MCP SDK 完成发现、动态客户端注册、签发方绑定和 PKCE，再通过公开 Vault API 保存令牌。OAuth 令牌不会返回浏览器。
+**资源库** 有三个标签页：**能力**、**模型** 和 **凭据**。
+
+- **能力** 把 Agent 可以绑定的所有能力放在一张表里，显示类型、版本、绑定它的已启用 Agent 数量和它需要的凭据；可以按 Skill、MCP、Plugin、指令片段或知识筛选。**新建能力** 可以添加任意一种：HTTP MCP、从 MCP 目录添加、编写或上传 Skill、从 Skill 目录导入、Plugin、指令片段或知识。
+- **Skills** 支持版本管理、默认版本选择、按 Agent 固定版本以及有限的文件预览。Skill 目录搜索 skills.sh 索引；预览在临时目录中使用固定版本的 `skills@1.5.23` CLI，再走常规公开 Skill 上传，这需要 Parsar 主机具备 `npx` 和网络访问。导入的压缩包限制为 32 MiB 和 1,000 个文件。
+- **MCP** 服务是 HTTPS 端点，使用官方公开 MCP 工具，连接来源为 environment。标记为 **需要凭据** 的 MCP，使用绑定它的每个 Agent 各自选择的 Vault 凭据。
 - 指令片段和知识具有不可变的编号版本、默认版本、固定版本和停用状态。知识版本会成为初始工作区文件。标准 Claude/Codex Plugin ZIP 会成为公开 Environment Plugin，并列出其中声明的 `.mcp.json` 服务。stdio 服务所需的可执行文件必须存在于环境中。
+- Skill 或 Plugin 可以列出它需要的变量（**需要的密钥**）。绑定它的每个 Agent 在自己的 **凭据** 部分为每个变量选择一个密钥，对话以环境变量的形式拿到这些值。能力需要的凭据没有全部选好之前，Agent 不能保存；不再需要的选择会被自动去掉。
+- **凭据** 包括 **密钥**（这些变量的只写值）和 **MCP 凭据**（Vault 及其中只写的 bearer 凭据）。**OAuth 授权** 使用维护中的 MCP SDK 完成发现、动态客户端注册、签发方绑定和 PKCE，再通过公开 Vault API 保存令牌。密钥的值和 OAuth 令牌都不会返回浏览器。
 
-**环境模板** 只在 Core 托管的工作区中运行。每个新对话会先写入文件、安装软件包并完成初始化，再启动 Agent；初始化失败会停止执行。初始文件使用规范的 `/workspace/` 路径，脚本在工作区中运行。变量值在产品响应中只写：`null` 保留已有值，字符串替换，删除名称即删除变量。**飞书机器人变量** 把变量名映射到所绑定机器人的 **App ID**、**App Secret** 或地区；使用这类模板的对话要求 Agent 已绑定机器人。每个环境模板保存为一个 Core Environment Template，每个 Agent 保存为一个 Core Agent。它们本身或它们绑定的内容变化时，Parsar 会更新 Core 里的这两份资源；Core Project 更换后，下次使用时会重新创建。对话的 Session 引用这两份资源，只附加每次对话不同的内容：机器人变量、Agent 的 Skills、Plugins 和知识文件，以及附件（见[模板继承](../../contracts/agents-api/environments.md#inheritance)）。Core 可能在 24 小时内复用一次完全相同的准备结果（[准备结果复用](../../contracts/agents-api/zh/environments.md#preparation-reuse)），长时间空闲的对话也可能换到新沙箱；这两种情况下只保留 `/environment`（包括 `/workspace`），初始化脚本不会再次执行。因此初始化脚本必须把之后要用的内容写到 `/workspace` 或软件包目录下，不能写在 HOME 中。飞书工作环境通过 `LARKSUITE_CLI_CONFIG_DIR` 和 `LARKSUITE_CLI_DATA_DIR` 把 lark-cli 的配置和加密凭证放在 `/workspace/.lark-cli`。
+**环境模板** 只在 Core 托管的工作区中运行。每个新对话会先写入文件、安装软件包并完成初始化，再启动 Agent；初始化失败会停止执行。初始文件使用规范的 `/workspace/` 路径，脚本在工作区中运行。变量值在产品响应中只写：`null` 保留已有值，字符串替换，删除名称即删除变量。**需要的密钥** 列出由 Agent 提供的变量，和 Skill、Plugin 的写法相同。每个环境模板保存为一个 Core Environment Template，每个 Agent 保存为一个 Core Agent。它们本身或它们绑定的内容变化时，Parsar 会更新 Core 里的这两份资源；Core Project 更换后，下次使用时会重新创建。对话的 Session 引用这两份资源，只附加每次对话不同的内容：机器人变量、Agent 的 Skills、Plugins 和知识文件，以及附件（见[模板继承](../../contracts/agents-api/environments.md#inheritance)）。Core 可能在 24 小时内复用一次完全相同的准备结果（[准备结果复用](../../contracts/agents-api/zh/environments.md#preparation-reuse)），长时间空闲的对话也可能换到新沙箱；这两种情况下只保留 `/environment`（包括 `/workspace`），初始化脚本不会再次执行。因此初始化脚本必须把之后要用的内容写到 `/workspace` 或软件包目录下，不能写在 HOME 中。飞书工作环境通过 `LARKSUITE_CLI_CONFIG_DIR` 和 `LARKSUITE_CLI_DATA_DIR` 把 lark-cli 的配置和加密凭证放在 `/workspace/.lark-cli`。
 
 **提前准备，新对话无需等待安装** 会为使用该模板的每个 Agent 保留一个准备好的 Session。Parsar 在没有输入的情况下创建它，Core 会提前准备好 Environment；下一个网页或飞书对话发送第一条消息时直接接管它，并保留自己的标题。Agent、其环境模板、机器人或模型服务商变更后，或超过 12 小时、或被接管后，准备好的 Session 会被替换；关闭开关会丢弃它。第一条消息带图片或文件时，会创建普通的 Session。每个准备好的 Session 在等待期间会占用一个工作区。
 
@@ -132,11 +136,11 @@ Parsar 会跟踪每一轮正在执行的对话，网页和飞书都一样。出
 
 ### 机器人身份 {#bot-identity}
 
-Agent 以绑定的机器人身份工作。使用 **飞书机器人变量** 时，Parsar 会把机器人的 App ID 和 App Secret 写入对话 Environment 的变量。飞书案例把它们映射为 `FEISHU_*` 变量，初始化脚本运行 `lark-cli config init --app-secret-stdin`，由 CLI 自行获取并刷新租户令牌，长对话也能持续工作。不要映射为 `LARKSUITE_CLI_APP_ID` 或 `LARKSUITE_CLI_APP_SECRET`：这两个变量会让 lark-cli 进入环境凭据模式，该模式要求直接提供租户令牌。任何能与机器人对话的人都能使用机器人的权限，Environment 中的工具也能读取该密钥。只为机器人授予其 Agent 需要的权限，尽量一个 Agent 使用一个机器人。轮换后的密钥只对新对话生效。
+Agent 以绑定的机器人身份工作。绑定了机器人的 Agent，它的每个对话（包括网页对话）都会以 `FEISHU_APP_ID`、`FEISHU_APP_SECRET` 和 `FEISHU_BRAND` 拿到机器人身份，不需要任何映射。需要机器人身份的模板、Skill 或 Plugin 在 **需要的密钥** 里列出这几个名字：能力列表里它的凭据需求显示为 **飞书机器人**，Agent 页面显示由哪个机器人提供，没有绑定机器人的 Agent 不能保存。这几个名字只能由绑定的机器人提供。飞书案例的初始化脚本运行 `lark-cli config init --app-secret-stdin`，由 CLI 自行获取并刷新租户令牌，长对话也能持续工作。不要以 `LARKSUITE_CLI_APP_ID` 或 `LARKSUITE_CLI_APP_SECRET` 传入：这两个变量会让 lark-cli 进入环境凭据模式，该模式要求直接提供租户令牌。任何能与机器人对话的人都能使用机器人的权限，Environment 中的工具也能读取该密钥。只为机器人授予其 Agent 需要的权限，尽量一个 Agent 使用一个机器人。轮换后的密钥只对新对话生效。
 
 ### 飞书工作环境案例 {#feishu-workspace-case}
 
-[飞书工作环境](examples/feishu/)由普通模板组装而成。[environment.json](examples/feishu/environment.json) 声明软件包、机器人变量和文件，[setup.sh](examples/feishu/setup.sh) 安装经过校验和验证的官方 CLI 并用机器人凭证完成配置，[agent.json](examples/feishu/agent.json) 定义一个 Codex Agent。配置好模型，导入官方 `lark-shared` Skill 和需要的业务 Skill，添加机器人后运行：
+[飞书工作环境](examples/feishu/)由普通模板组装而成。[environment.json](examples/feishu/environment.json) 声明软件包、需要的机器人身份和文件，[setup.sh](examples/feishu/setup.sh) 安装经过校验和验证的官方 CLI 并用机器人凭证完成配置，[agent.json](examples/feishu/agent.json) 定义一个 Codex Agent。配置好模型，导入官方 `lark-shared` Skill 和需要的业务 Skill，添加机器人后运行：
 
 ```bash
 node example/parsar/examples/feishu/configure.mjs --url http://localhost:3001 --model MODEL_ID --bot BOT_ID --skills SHARED_SKILL_ID,DOMAIN_SKILL_ID
diff --git a/example/parsar/examples/feishu/environment.json b/example/parsar/examples/feishu/environment.json
index 4f25681b6..765ae449b 100644
--- a/example/parsar/examples/feishu/environment.json
+++ b/example/parsar/examples/feishu/environment.json
@@ -12,11 +12,7 @@
     "LARKSUITE_CLI_CONFIG_DIR": "/workspace/.lark-cli",
     "LARKSUITE_CLI_DATA_DIR": "/workspace/.lark-cli/data"
   },
-  "bot_env": {
-    "FEISHU_APP_ID": "app_id",
-    "FEISHU_APP_SECRET": "app_secret",
-    "FEISHU_BRAND": "brand"
-  },
+  "credentials": ["FEISHU_APP_ID", "FEISHU_APP_SECRET"],
   "files": [
     { "path": "/workspace/WORKSPACE.md", "content": "# 飞书工作环境\n\n官方 lark-cli 已在 Agent 启动前安装，以 Agent 绑定的飞书机器人身份运行。禁止输出 App Secret、令牌或环境变量。读取 Skill 后使用具体业务命令。网络错误与权限不足分别报告。产物写到 ./outputs。\n" }
   ]
diff --git a/example/parsar/examples/manager/GUIDE.md b/example/parsar/examples/manager/GUIDE.md
index 16b7b1d0d..6645af40a 100644
--- a/example/parsar/examples/manager/GUIDE.md
+++ b/example/parsar/examples/manager/GUIDE.md
@@ -40,7 +40,7 @@ Write a JSON file, then call `PUT /app/runtimes/<that UUID> --file environment.j
   "packages": { "npm": [], "python": ["openpyxl"] },
   "setup_script": "mkdir -p /workspace/outputs",
   "env": {},
-  "bot_env": {},
+  "credentials": [],
   "files": [],
   "prepare": false
 }
@@ -48,7 +48,7 @@ Write a JSON file, then call `PUT /app/runtimes/<that UUID> --file environment.j
 
 Use only needed packages and files. Initial files are `{ "path": "/workspace/name", "content": "text" }`. Setup runs in the hosted workspace before the Agent starts; it is executable code, so review it as part of the requested configuration. Keep persistent files under `/workspace`; HOME is not persistent. Environment preparation may be reused. Never put the management CLI or its address in ordinary business templates unless the user explicitly asks for management access.
 
-Environment variable values are write-only: GET returns `null`, and PUT with `null` keeps the saved value. Retain untouched names. Removing a name removes its value. Do not ask users to paste secrets into chat; direct them to the existing configuration UI. A template with `bot_env` needs an Agent bound to a Feishu bot before it can run.
+Environment variable values are write-only: GET returns `null`, and PUT with `null` keeps the saved value. Retain untouched names. Removing a name removes its value. Do not ask users to paste secrets into chat; direct them to the existing configuration UI. `credentials` lists variables the Agent must supply. `FEISHU_APP_ID`, `FEISHU_APP_SECRET` and `FEISHU_BRAND` come from the Agent's bound Feishu bot, so list them when setup or a capability needs the bot's identity; an Agent without a bot cannot then be saved. Any other name is supplied from a secret the Agent chooses in its `credentials` map (name to `/app/secrets` ID). Skills (`PUT /app/skills/<skill_id>/credentials`) and Plugins declare the same list.
 
 ## Create an Agent
 
@@ -80,7 +80,7 @@ When a user asks to open or connect a Feishu bot, guide the whole setup rather t
 
 Read `/app/agents`, `/app/runtimes` and `/app/feishu/bots`. Identify the intended business Agent from the user's goal; if it does not exist, create it using the workflow above. Do not bind the management Agent unless the user explicitly wants management access through that bot. Each bot binds one Agent and each Agent binds at most one bot. Reuse the intended Agent's existing bot; do not replace another binding, rotate credentials or create a duplicate to resolve a conflict. Ask only for unresolved choices such as which Agent or whether to use an existing Feishu application.
 
-For a new setup, default to private chat only and tell the user. Enable group chat only when requested: it permits replies to mentions in any group the bot joins, not a list of selected group IDs. Preserve the chat choices of an existing bot unless the user asks to change them. Binding a bot supplies that bot's identity to new Agent conversations, including Web conversations when the environment maps `bot_env`; do not copy credentials into files or ordinary Agent instructions.
+For a new setup, default to private chat only and tell the user. Enable group chat only when requested: it permits replies to mentions in any group the bot joins, not a list of selected group IDs. Preserve the chat choices of an existing bot unless the user asks to change them. Binding a bot supplies that bot's identity as `FEISHU_APP_ID`, `FEISHU_APP_SECRET` and `FEISHU_BRAND` to every new conversation of its Agent, Web ones included; do not copy credentials into files or ordinary Agent instructions.
 
 ### Register a new application
 
diff --git a/example/parsar/server/capabilities.mjs b/example/parsar/server/capabilities.mjs
index ad4fa6656..92dc25ef5 100644
--- a/example/parsar/server/capabilities.mjs
+++ b/example/parsar/server/capabilities.mjs
@@ -1,5 +1,5 @@
 import { AppError, text, uuid } from "./store.mjs";
-import { boundAgents } from "./capability-kinds.mjs";
+import { boundAgents, credentialNames } from "./capability-kinds.mjs";
 import { unzipSync } from "fflate";
 const publicVersion = ({ archive, ...value }) => ({
   ...value,
@@ -106,6 +106,8 @@ export function capabilityAPI(store) {
       kind,
       versions,
       default_version,
+      // A Plugin's programs may read variables the Agent supplies from its secrets.
+      credentials: kind === "plugin" ? credentialNames(body.credentials ?? old?.credentials) : [],
       deprecated: body.deprecated === true,
       revision: (old?.revision || 0) + 1,
     };
diff --git a/example/parsar/server/capability-kinds.mjs b/example/parsar/server/capability-kinds.mjs
index 91ec022fb..20b3a5c0b 100644
--- a/example/parsar/server/capability-kinds.mjs
+++ b/example/parsar/server/capability-kinds.mjs
@@ -1,8 +1,18 @@
-import { AppError, text, uuid } from "./store.mjs";
+import { AppError, text } from "./store.mjs";
+import { botVariables, environmentVariableName } from "../shared/bot-bindings.mjs";
 
 // Every kind of capability an Agent can bind, in one place. A kind resolves an
-// Agent's bindings and says where each one goes: into the Core Agent (tools,
-// instructions) or into the Session's Environment (skills, plugins, files).
+// Agent's bindings, says which credentials each needs, and where each one goes:
+// into the Core Agent (tools, instructions) or into the Session's Environment
+// (skills, plugins, files, variables).
+
+// Variable names a capability needs the Agent to supply from a secret.
+export function credentialNames(value) {
+  if (value === undefined) return [];
+  if (!Array.isArray(value) || value.length > 20 || value.some((name) => !environmentVariableName(name)))
+    throw new AppError(400, "凭据需求是有效的环境变量名，最多 20 个，且不能使用运行环境保留的名称。");
+  return [...new Set(value)];
+}
 
 const libraryEntry = (store, agent, id) => {
   const capability = store.get("capabilities", id);
@@ -27,8 +37,13 @@ export const capabilityKinds = {
   skills: {
     bound: (agent) => agent.skill_ids || [],
     // Skills live in Core; the binding names a Skill and optionally a version.
-    resolve: (_store, agent) =>
-      (agent.skill_ids || []).map((skill_id) => ({ skill_id, version: agent.skill_versions?.[skill_id] })),
+    // Parsar keeps only the credentials a Skill needs.
+    resolve: (store, agent) =>
+      (agent.skill_ids || []).map((skill_id) => ({
+        skill_id,
+        version: agent.skill_versions?.[skill_id],
+        credentials: store.get("skill_credentials", skill_id)?.credentials || [],
+      })),
     contribute: (entry, out) =>
       out.session.skills.push({ type: "skill_reference", skill_id: entry.skill_id, ...(entry.version ? { version: entry.version } : {}) }),
   },
@@ -41,7 +56,11 @@ export const capabilityKinds = {
         throw new AppError(400, "绑定的 MCP 服务标识不能重复。");
       return mcps;
     },
+    // An MCP that needs authentication uses the Vault credential the Agent chose for it.
     contribute: (mcp, out, agent) => {
+      const credential = mcp.requires_credential && agent.mcp_credentials?.[mcp.id];
+      if (mcp.requires_credential && !credential)
+        throw new AppError(400, `请在 Agent 中为 MCP「${mcp.name}」选择凭据。`);
       out.agent.tools.push({
         type: "mcp",
         server_label: mcp.label,
@@ -49,9 +68,9 @@ export const capabilityKinds = {
         connection_origin: "environment",
         // MiniMax Code admits only optional MCP initialization.
         required: agent.harness !== "mcode",
-        ...(mcp.credential_id ? { credential_id: mcp.credential_id } : {}),
+        ...(credential ? { credential_id: credential.credential_id } : {}),
       });
-      if (mcp.vault_id) out.session.vault_ids.push(mcp.vault_id);
+      if (credential) out.session.vault_ids.push(credential.vault_id);
     },
     // An HTTPS address without credentials; authentication comes from a Vault credential.
     validate: (body) => {
@@ -63,13 +82,10 @@ export const capabilityKinds = {
       }
       if (url.protocol !== "https:" || url.username || url.password || url.hash || url.search)
         throw new AppError(400, "MCP 使用不含凭据的 HTTPS 地址。");
-      if (body.vault_id && !uuid.test(body.vault_id)) throw new AppError(400, "凭据库标识无效。");
-      if (body.credential_id && (!body.vault_id || !uuid.test(body.credential_id)))
-        throw new AppError(400, "凭据标识无效。");
       const label = text(body.label, "MCP 标识", 64, true);
       if (!/^[a-zA-Z0-9_-]+$/.test(label))
         throw new AppError(400, "MCP 标识仅支持字母、数字、下划线和连字符。");
-      return { url: url.href, vault_id: body.vault_id || "", credential_id: body.credential_id || "", label };
+      return { url: url.href, label, requires_credential: body.requires_credential === true };
     },
   },
   prompt: library("prompt", (row, out) => out.agent.instructions.push(row.content)),
@@ -92,23 +108,62 @@ export const capabilityKinds = {
 };
 
 // What an Agent's bindings add to its Core Agent and to each of its Sessions.
+export const boundBot = (store, agent) =>
+  store.list("feishu_bots").find((bot) => bot.agent_id === agent.id && bot.app_secret);
+
+// What needs credentials: every bound capability and the Agent's environment template.
+function needers(store, agent) {
+  const out = [];
+  for (const [kind, definition] of Object.entries(capabilityKinds))
+    for (const entry of definition.resolve(store, agent)) out.push({ kind, entry });
+  const runtime = store.get("runtimes", agent.runtime_id || "");
+  if (runtime) out.push({ kind: "runtimes", entry: runtime });
+  return out;
+}
+
+// What an Agent's bindings add to its Core Agent and to each of its Sessions.
+// A bound bot's identity reaches every conversation; any other variable comes
+// from the secret the Agent chose for it.
 export function contributions(store, agent) {
   const out = {
     agent: { tools: [], instructions: [] },
-    session: { skills: [], plugins: [], files: [], vault_ids: [] },
+    session: { skills: [], plugins: [], files: [], vault_ids: [], env: {} },
     summary: { skills: [], mcps: [], capabilities: [] },
   };
-  for (const [kind, definition] of Object.entries(capabilityKinds))
-    for (const entry of definition.resolve(store, agent)) {
-      definition.contribute(entry, out, agent);
-      if (kind === "skills") out.summary.skills.push({ id: entry.skill_id, version: entry.version || null });
-      else if (kind === "mcps") out.summary.mcps.push(entry.label);
-      else out.summary.capabilities.push({ name: entry.name, kind: entry.kind, version: entry.version });
+  const bot = boundBot(store, agent);
+  for (const { kind, entry } of needers(store, agent)) {
+    if (kind !== "runtimes") capabilityKinds[kind].contribute(entry, out, agent);
+    for (const name of entry.credentials || []) {
+      const label = entry.name || entry.skill_id;
+      if (Object.hasOwn(botVariables, name)) {
+        if (!bot) throw new AppError(400, `「${label}」需要飞书机器人身份，请先在飞书接入中给这个 Agent 绑定机器人。`);
+        continue;
+      }
+      const secret = store.get("secrets", agent.credentials?.[name] || "");
+      if (!secret) throw new AppError(400, `请在 Agent 中为「${label}」所需的 ${name} 选择密钥。`);
+      out.session.env[name] = secret.value;
     }
+    if (kind === "skills") out.summary.skills.push({ id: entry.skill_id, version: entry.version || null });
+    else if (kind === "mcps") out.summary.mcps.push(entry.label);
+    else if (kind !== "runtimes") out.summary.capabilities.push({ name: entry.name, kind: entry.kind, version: entry.version });
+  }
+  if (bot)
+    for (const [name, field] of Object.entries(botVariables))
+      out.session.env[name] = field === "brand" ? bot.brand || "feishu" : bot[field];
   out.session.vault_ids = [...new Set(out.session.vault_ids)];
   return out;
 }
 
+// The secrets and MCP credentials an Agent must choose for its bindings now.
+export function requiredCredentials(store, agent) {
+  const env = new Set(), mcps = new Set();
+  for (const { kind, entry } of needers(store, agent)) {
+    for (const name of entry.credentials || []) if (!Object.hasOwn(botVariables, name)) env.add(name);
+    if (kind === "mcps" && entry.requires_credential) mcps.add(entry.id);
+  }
+  return { env, mcps };
+}
+
 // Agents that bind a capability; a bound capability cannot be deleted.
 export function boundAgents(store, kind, id) {
   const definition = kind === "capabilities" ? capabilityKinds.prompt : capabilityKinds[kind];
diff --git a/example/parsar/server/feishu.mjs b/example/parsar/server/feishu.mjs
index d05185268..8b3c3ec94 100644
--- a/example/parsar/server/feishu.mjs
+++ b/example/parsar/server/feishu.mjs
@@ -110,8 +110,9 @@ export function feishuAPI(store) {
       throw new AppError(409, "配置已更新，请重新加载。");
     if (body.brand !== undefined && !["feishu", "lark"].includes(body.brand))
       throw new AppError(400, "机器人地区无效。");
-    const name = text(body.name || "Feishu", "机器人名称", 80, true);
     const app_id = text(body.app_id, "App ID", 100).trim();
+    // The name comes from Feishu once the bot connects; until then it shows the App ID.
+    const name = app_id === old.app_id && old.name ? old.name : app_id || "Feishu";
     if (
       app_id &&
       store
@@ -481,6 +482,8 @@ export async function createFeishuTransport(settings, receive) {
       const bot = result.bot || result.data?.bot;
       if (result.code !== 0 || !bot?.open_id)
         throw new Error("Cannot resolve Feishu bot identity");
+      // The name people see in Feishu.
+      this.name = bot.app_name;
       readContext = feishuContextReader(client, {
         openId: bot.open_id,
         name: bot.app_name || "Parsar",
@@ -1527,6 +1530,10 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
       try {
         await channel.connect();
         active = config;
+        // The bot keeps the name it has in Feishu; renaming the app there renames it here.
+        const saved = store.get("feishu_bots", configId);
+        if (channel.name && saved && saved.name !== channel.name)
+          store.put("feishu_bots", { ...saved, name: channel.name });
       } catch {
         await channel.disconnect();
         channel = undefined;
diff --git a/example/parsar/server/product.mjs b/example/parsar/server/product.mjs
index bb74f2569..40d87cc2c 100644
--- a/example/parsar/server/product.mjs
+++ b/example/parsar/server/product.mjs
@@ -9,7 +9,7 @@ import { feishuAPI } from "./feishu.mjs";
 import { trialAPI } from "./trials.mjs";
 import { sessionAPI } from "./sessions.mjs";
 import { coreResources } from "./core-resources.mjs";
-import { boundAgents, capabilityKinds } from "./capability-kinds.mjs";
+import { boundAgents, capabilityKinds, credentialNames, requiredCredentials } from "./capability-kinds.mjs";
 import { AppError, text, uuid } from "./store.mjs";
 import {
   harnessOptions,
@@ -32,13 +32,17 @@ const kinds = new Set([
   "runtimes",
   "agents",
   "sessions",
+  "secrets",
 ]);
+// A secret's value is write-only: reads say only whether one is saved.
+const publicSecret = ({ value, ...row }) => ({ ...row, has_value: !!value });
 export function productAPI(store, core, fetchImpl = fetch, origin) {
   const resources = coreResources(store, core);
   const sessions = sessionAPI(store, core, resources);
   const publicRow = (kind, row) => {
     if (kind === "providers") return publicProvider(row);
     if (kind === "runtimes") return publicRuntime(row);
+    if (kind === "secrets") return publicSecret(row);
     if (kind === "sessions") {
       const { request, ...record } = row;
       return { ...record, turn: sessions.turns.summary(record.id) };
@@ -139,6 +143,16 @@ export function productAPI(store, core, fetchImpl = fetch, origin) {
       return store.list("audit").sort((a, b) => b.created_at - a.created_at);
     if (path === "/app/skills/registry/preview" && method === "POST")
       return previewRegistrySkill(body);
+    if (path === "/app/skills/credentials" && method === "GET") return store.list("skill_credentials");
+    // The credentials a Core Skill needs; the Skill itself stays in Core.
+    const skillCredentials = path.match(/^\/app\/skills\/(skill_[A-Za-z0-9][A-Za-z0-9_-]{0,127})\/credentials$/)?.[1];
+    if (skillCredentials) {
+      if (method === "GET") return store.get("skill_credentials", skillCredentials) || { id: skillCredentials, credentials: [] };
+      if (method !== "PUT") throw new AppError(405, "Method not allowed.");
+      const value = { id: skillCredentials, credentials: credentialNames(body.credentials) };
+      store.put("skill_credentials", value);
+      return value;
+    }
     if (path.startsWith("/app/feishu/provision/"))
       return registration(method, path, body);
     if (path === "/app/feishu" || path.startsWith("/app/feishu/"))
@@ -210,7 +224,8 @@ export function productAPI(store, core, fetchImpl = fetch, origin) {
         store.list("feishu_bots").some((row) => row.agent_id === id) ||
         store.list("models").some((row) => row.provider_id === id) ||
         store.list("agents").some((row) => row.model_id === id || row.runtime_id === id) ||
-        (kind === "mcps" && boundAgents(store, "mcps", id).length > 0);
+        (kind === "mcps" && boundAgents(store, "mcps", id).length > 0) ||
+        (kind === "secrets" && store.list("agents").some((row) => Object.values(row.credentials || {}).includes(id)));
       if (used) throw new AppError(409, "资源仍被引用，请先调整绑定。");
       if (kind === "agents" || kind === "runtimes") await resources.remove(kind, previous);
       store.transaction(() => {
@@ -262,6 +277,13 @@ export function productAPI(store, core, fetchImpl = fetch, origin) {
         throw new AppError(409, "此 Provider 已有相同的模型 ID。");
     }
     if (kind === "mcps") Object.assign(value, capabilityKinds.mcps.validate(body));
+    if (kind === "secrets") {
+      // Omitting the value keeps the saved one.
+      const secret = body.value ?? previous?.value;
+      if (typeof secret !== "string" || !secret || secret.includes("\0") || secret.length > 8192)
+        throw new AppError(400, "请填写密钥的值。");
+      value.value = secret;
+    }
     if (kind === "runtimes") {
       Object.assign(value, runtimeProfile(body, previous));
     }
@@ -318,6 +340,25 @@ export function productAPI(store, core, fetchImpl = fetch, origin) {
         if (version) value.capability_versions[capabilityId] = version;
       }
       value.mcp_ids = references("mcps", body.mcp_ids);
+      // Which secret supplies each required variable, and which Vault
+      // credential each MCP that needs one uses. Completeness is checked when
+      // the saved Core Agent is built.
+      const credentials = body.credentials ?? {};
+      if (!credentials || typeof credentials !== "object" || Array.isArray(credentials))
+        throw new AppError(400, "凭据选择无效。");
+      credentialNames(Object.keys(credentials));
+      value.credentials = Object.fromEntries(
+        Object.entries(credentials).map(([name, secretId]) => [name, requireReference("secrets", secretId)]),
+      );
+      const mcpCredentials = body.mcp_credentials ?? {};
+      if (!mcpCredentials || typeof mcpCredentials !== "object" || Array.isArray(mcpCredentials))
+        throw new AppError(400, "MCP 凭据选择无效。");
+      value.mcp_credentials = {};
+      for (const [mcpId, choice] of Object.entries(mcpCredentials)) {
+        if (!value.mcp_ids.includes(mcpId) || !uuid.test(choice?.vault_id || "") || !uuid.test(choice?.credential_id || ""))
+          throw new AppError(400, "MCP 凭据选择无效。");
+        value.mcp_credentials[mcpId] = { vault_id: choice.vault_id, credential_id: choice.credential_id };
+      }
       if (Array.isArray(body.skill_ids) && body.skill_ids.length > maxSkills)
         throw new AppError(400, `最多选择 ${maxSkills} 个 Skill。`);
       if (
@@ -349,6 +390,12 @@ export function productAPI(store, core, fetchImpl = fetch, origin) {
         if (version) value.skill_versions[skillId] = version;
       }
     }
+    // Choices for credentials the bindings no longer need are dropped.
+    if (kind === "agents") {
+      const needed = requiredCredentials(store, value);
+      value.credentials = Object.fromEntries(Object.entries(value.credentials).filter(([name]) => needed.env.has(name)));
+      value.mcp_credentials = Object.fromEntries(Object.entries(value.mcp_credentials).filter(([id]) => needed.mcps.has(id)));
+    }
     // The saved Core Agent or Template keeps its identity across edits.
     for (const field of ["core_agent_id", "core_template_id", "core_digest"])
       if (previous?.[field]) value[field] = previous[field];
diff --git a/example/parsar/server/runtime-profile.mjs b/example/parsar/server/runtime-profile.mjs
index 00860288e..e36344b9c 100644
--- a/example/parsar/server/runtime-profile.mjs
+++ b/example/parsar/server/runtime-profile.mjs
@@ -1,4 +1,5 @@
-import { botFields, environmentVariableName } from "../shared/bot-bindings.mjs";
+import { environmentVariableName } from "../shared/bot-bindings.mjs";
+import { credentialNames } from "./capability-kinds.mjs";
 import { posix } from "node:path";
 import { AppError, text } from "./store.mjs";
 
@@ -50,26 +51,6 @@ export function runtimeProfile(body, previous) {
       throw new AppError(400, "请填写新环境变量的值；已有变量留空可保留。");
     env[name] = selected;
   }
-  const bot_env = body.bot_env ?? {};
-  if (
-    !bot_env ||
-    typeof bot_env !== "object" ||
-    Array.isArray(bot_env) ||
-    Object.keys(bot_env).length > 20
-  )
-    throw new AppError(400, "机器人变量映射格式无效。");
-  for (const [name, source] of Object.entries(bot_env)) {
-    if (
-      !environmentVariableName(name) ||
-      Object.hasOwn(env, name) ||
-      typeof source !== "string" ||
-      !Object.hasOwn(botFields, source)
-    )
-      throw new AppError(
-        400,
-        "机器人变量名称必须有效、不能与固定变量重复，且只能选择机器人字段。",
-      );
-  }
   const files = body.files ?? [];
   if (!Array.isArray(files) || files.length > 20)
     throw new AppError(400, "初始文件最多 20 个。");
@@ -95,7 +76,8 @@ export function runtimeProfile(body, previous) {
     packages,
     setup_script: text(body.setup_script || "", "初始化脚本", 100000),
     env,
-    bot_env,
+    // Variables the Agent supplies: the bound bot's identity or chosen secrets.
+    credentials: credentialNames(body.credentials),
     files: normalized,
     prepare: body.prepare === true,
   };
diff --git a/example/parsar/server/sessions.mjs b/example/parsar/server/sessions.mjs
index dc43464ca..542056dc5 100644
--- a/example/parsar/server/sessions.mjs
+++ b/example/parsar/server/sessions.mjs
@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import { AppError, text, uuid } from "./store.mjs";
 import { harnessOptions } from "../shared/harness-options.mjs";
-import { contributions } from "./capability-kinds.mjs";
+import { boundBot, contributions } from "./capability-kinds.mjs";
 import { templateFiles } from "./core-resources.mjs";
 import { turnsAPI } from "./turns.mjs";
 
@@ -12,10 +12,6 @@ const fingerprint = ({ request: { input, metadata, ...request }, core_digests })
   createHash("sha256").update(JSON.stringify({ request, core_digests })).digest("hex");
 const warmAge = 12 * 3600_000;
 
-export function sessionBot(store, agentId) {
-  return store.list("feishu_bots").find((bot) => bot.agent_id === agentId);
-}
-
 // A Session references the Agent's saved Core Agent and its environment
 // template's Core Template, and adds only what differs per conversation: the
 // bot identity, the Agent's Skills, Plugins and knowledge, and attachments.
@@ -29,13 +25,7 @@ export async function prepareSession(store, resources, id, body, origin = {}, wa
   const runtime = await resources.ensure("runtimes", storedRuntime.id);
   const model = store.get("models", agent.model_id);
   const bound = contributions(store, agent);
-  const botEnv = Object.entries(runtime.bot_env || {});
-  const bot = sessionBot(store, agent.id);
-  if (botEnv.length && !bot?.app_secret)
-    throw new AppError(
-      400,
-      "环境模板需要飞书机器人身份，请先在飞书接入中把机器人绑定到这个 Agent。",
-    );
+  const bot = boundBot(store, agent);
   const provider = store.get("providers", model.provider_id);
   if (!provider?.base_url?.startsWith("https://") || !provider.api_key)
     throw new AppError(
@@ -75,12 +65,13 @@ export async function prepareSession(store, resources, id, body, origin = {}, wa
     throw new AppError(400, "附件格式或大小无效。");
   // Session files replace the Template's set, so they include the Template's own.
   const extraFiles = [...files, ...bound.session.files];
+  // Variables overlay the Template's own: the bound bot's identity and the
+  // secrets the Agent chose for what its capabilities need.
+  const env = bound.session.env;
   const environment = {
     type: "openai_hosted",
     environment_template_id: runtime.core_template_id,
-    ...(botEnv.length
-      ? { env: Object.fromEntries(botEnv.map(([name, field]) => [name, field === "brand" ? bot.brand || "feishu" : bot[field]])) }
-      : {}),
+    ...(Object.keys(env).length ? { env } : {}),
     ...(bound.session.skills.length ? { skills: bound.session.skills } : {}),
     ...(bound.session.plugins.length ? { plugins: bound.session.plugins } : {}),
     ...(extraFiles.length ? { files: [...templateFiles(runtime), ...extraFiles] } : {}),
@@ -102,17 +93,14 @@ export async function prepareSession(store, resources, id, body, origin = {}, wa
       agent_name: agent.name,
       agent_revision: agent.revision,
       runtime_revision: runtime.revision,
-      bot_name: botEnv.length ? bot.name : undefined,
+      bot_name: bot?.name,
       model: model.model,
       harness: agent.harness,
       environment: runtime.environment,
       environment_name: runtime.name,
       packages: runtime.packages || { npm: [], python: [] },
       setup_configured: Boolean(runtime.setup_script),
-      env_names: [
-        ...Object.keys(runtime.env || {}),
-        ...botEnv.map(([name]) => name),
-      ],
+      env_names: [...new Set([...Object.keys(runtime.env || {}), ...Object.keys(env)])],
       file_paths: (runtime.files || []).map((file) => file.path),
       ...bound.summary,
     },
diff --git a/example/parsar/shared/bot-bindings.d.mts b/example/parsar/shared/bot-bindings.d.mts
new file mode 100644
index 000000000..21c3899da
--- /dev/null
+++ b/example/parsar/shared/bot-bindings.d.mts
@@ -0,0 +1,2 @@
+export const botVariables: Record<string, "app_id" | "app_secret" | "brand">;
+export function environmentVariableName(name: string): boolean;
diff --git a/example/parsar/shared/bot-bindings.mjs b/example/parsar/shared/bot-bindings.mjs
index 864937620..ecab4f6ac 100644
--- a/example/parsar/shared/bot-bindings.mjs
+++ b/example/parsar/shared/bot-bindings.mjs
@@ -1,8 +1,9 @@
-// Fields of the Agent's Feishu bot that an environment template may expose to tools.
-export const botFields = {
-  app_id: "App ID",
-  app_secret: "App Secret",
-  brand: "地区",
+// The bound Feishu bot's identity reaches every conversation of its Agent as
+// these variables. Only the bot supplies them.
+export const botVariables = {
+  FEISHU_APP_ID: "app_id",
+  FEISHU_APP_SECRET: "app_secret",
+  FEISHU_BRAND: "brand",
 };
 export const environmentVariableName = (name) =>
   /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) &&
diff --git a/example/parsar/src/AgentPage.tsx b/example/parsar/src/AgentPage.tsx
index 701ec11e4..a246cf826 100644
--- a/example/parsar/src/AgentPage.tsx
+++ b/example/parsar/src/AgentPage.tsx
@@ -260,6 +260,7 @@ function AgentEditor({
         </Section>
         {!creating && <AgentHealth id={initial.id} />}
         <ConfigurationFields
+          agentId={form.id}
           value={form}
           errors={errors}
           change={(configuration) => setForm({ ...form, ...configuration })}
diff --git a/example/parsar/src/App.tsx b/example/parsar/src/App.tsx
index ebee2ac89..babc656a9 100644
--- a/example/parsar/src/App.tsx
+++ b/example/parsar/src/App.tsx
@@ -166,7 +166,7 @@ export function App() {
       href: "/capabilities",
       label: tr("资源库"),
       icon: BookOpen,
-      match: ["/capabilities", "/models", "/skills", "/mcps", "/credentials"],
+      match: ["/capabilities", "/models", "/credentials"],
     },
   ];
   const connect = [
@@ -204,10 +204,6 @@ export function App() {
       <Settings />
     ) : path === "/models" ? (
       <Capabilities key={path} initialTab="models" />
-    ) : path === "/skills" ? (
-      <Capabilities key={path} initialTab="skills" />
-    ) : path === "/mcps" ? (
-      <Capabilities key={path} initialTab="mcps" />
     ) : path === "/credentials" ? (
       <Capabilities key={path} initialTab="credentials" />
     ) : path === "/capabilities" ? (
diff --git a/example/parsar/src/Capabilities.tsx b/example/parsar/src/Capabilities.tsx
index 5ac5d28af..bc6384151 100644
--- a/example/parsar/src/Capabilities.tsx
+++ b/example/parsar/src/Capabilities.tsx
@@ -1,18 +1,15 @@
 import { tr } from "./lib/i18n";
 import { useState } from "react";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { Plus, Package, BookOpen, FileText } from "lucide-react";
 import { product } from "./lib/product";
 import { Models } from "./Models";
 import { Credentials } from "./Credentials";
-import { Skills } from "./Skills";
-import { MCPs } from "./Resources";
+import { Library } from "./Library";
 import { PageHeader, ErrorNotice, Field } from "./components/shared";
 import { Button } from "./components/ui/button";
 import { Input } from "./components/ui/input";
 import { Textarea } from "./components/ui/textarea";
 import { Select, SelectOption } from "./components/ui/select";
-import { Ledger, LedgerHeader, LedgerRow } from "./components/ui/ledger";
 import {
   Dialog,
   DialogContent,
@@ -20,13 +17,13 @@ import {
   DialogTitle,
   DialogFooter,
 } from "./components/ui/dialog";
-import { EmptyState } from "./components/ui/empty-state";
-import { randomUuid } from "@oac/agents-client";
 export interface Capability {
   id: string;
   name: string;
   description: string;
   kind: "prompt" | "knowledge" | "plugin";
+  // Variables a Plugin's programs need; each Agent supplies them from a secret.
+  credentials?: string[];
   revision: number;
   deprecated: boolean;
   default_version: string;
@@ -44,23 +41,16 @@ export const useCapabilities = () =>
     queryFn: () => product<Capability[]>("capabilities"),
   });
 export function Capabilities({
-  initialTab = "models",
+  initialTab = "capabilities",
 }: {
   initialTab?: string;
 }) {
-  const [tab, setTab] = useState(initialTab);
-  // Building blocks are grouped by what uses them: Agent engines, Agent
-  // capabilities, and MCP authentication.
-  const groups: [string, string][][] = [
-    [["models", tr("模型")]],
-    [
-      ["skills", "Skills"],
-      ["mcps", "MCP"],
-      ["plugin", "Plugins"],
-      ["knowledge", tr("知识")],
-      ["prompt", tr("指令片段")],
-    ],
-    [["credentials", tr("凭据")]],
+  // Each tab is a route, so reloading or going back keeps it.
+  const tab = initialTab;
+  const tabs: [string, string][] = [
+    ["capabilities", tr("能力")],
+    ["models", tr("模型")],
+    ["credentials", tr("凭据")],
   ];
   return (
     <>
@@ -69,107 +59,26 @@ export function Capabilities({
         <div
           className="flex items-center gap-6 overflow-x-auto border-b border-line"
           role="tablist"
-          aria-label={tr("能力类型")}
+          aria-label={tr("资源库")}
         >
-          {groups.map((group, index) => (
-            <div key={group[0]![0]} className="flex shrink-0 items-center gap-6">
-              {index > 0 && <span aria-hidden className="h-4 w-px bg-line" />}
-              {group.map(([key, label]) => (
-                <button
-                  key={key}
-                  role="tab"
-                  aria-selected={tab === key}
-                  className={
-                    tab === key
-                      ? "-mb-px h-10 shrink-0 border-b-2 border-fg text-sm font-medium text-fg"
-                      : "-mb-px h-10 shrink-0 border-b-2 border-transparent text-sm text-fg-muted hover:text-fg"
-                  }
-                  onClick={() => setTab(key)}
-                >
-                  {label}
-                </button>
-              ))}
-            </div>
-          ))}
-        </div>
-      </div>
-      {tab === "models" ? (
-        <Models />
-      ) : tab === "credentials" ? (
-        <Credentials />
-      ) : tab === "skills" ? (
-        <Skills />
-      ) : tab === "mcps" ? (
-        <MCPs />
-      ) : (
-        <CapabilityList key={tab} kind={tab as Capability["kind"]} />
-      )}
-    </>
-  );
-}
-const labels = {
-  prompt: tr("指令片段"),
-  knowledge: tr("知识"),
-  plugin: "Plugins",
-};
-function CapabilityList({ kind }: { kind: Capability["kind"] }) {
-  const query = useCapabilities();
-  const [editing, setEditing] = useState<Capability | null>(null);
-  const rows = query.data?.filter((row) => row.kind === kind);
-  const Icon =
-    kind === "plugin" ? Package : kind === "knowledge" ? BookOpen : FileText;
-  return (
-    <>
-      <div className="mx-auto flex w-full max-w-6xl flex-wrap items-center justify-between gap-3 px-6 pt-6 pb-1 sm:px-10">
-        <h2 className="text-lg font-semibold tracking-tight text-fg">{labels[kind]}</h2>
-        <Button
-          onClick={() =>
-            setEditing({
-              id: randomUuid(),
-              name: "",
-              description: "",
-              kind,
-              revision: 0,
-              deprecated: false,
-              default_version: "",
-              versions: [],
-            })
-          }
-        >
-          <Plus />
-          {tr("添加能力")}
-        </Button>
-      </div>
-      <ErrorNotice page error={query.error} />
-      <Ledger columns="18px minmax(160px,2fr) minmax(180px,2fr) 90px 90px">
-        <LedgerHeader>
-          <span />
-          <span>{tr("名称")}</span>
-          <span>{tr("说明")}</span>
-          <span>{tr("默认版本")}</span>
-          <span>{tr("状态")}</span>
-        </LedgerHeader>
-        {rows?.map((row) => (
-          <LedgerRow key={row.id}>
-            <Icon className="h-4 w-4 text-fg-muted" />
+          {tabs.map(([key, label]) => (
             <button
-              className="truncate text-left font-medium hover:text-accent"
-              onClick={() => setEditing(row)}
+              key={key}
+              role="tab"
+              aria-selected={tab === key}
+              className={
+                tab === key
+                  ? "-mb-px h-10 shrink-0 border-b-2 border-fg text-sm font-medium text-fg"
+                  : "-mb-px h-10 shrink-0 border-b-2 border-transparent text-sm text-fg-muted hover:text-fg"
+              }
+              onClick={() => (location.hash = `#/${key}`)}
             >
-              {row.name}
+              {label}
             </button>
-            <span className="text-fg-muted">{row.description || "—"}</span>
-            <span className="font-mono text-fg-muted">
-              v{row.default_version}
-            </span>
-            <span>{row.deprecated ? tr("已停用") : tr("可用")}</span>
-          </LedgerRow>
-        ))}
-        {!rows?.length && <EmptyState title={tr("暂无能力")} />}
-      </Ledger>
-      {editing && (
-        <CapabilityEditor value={editing} close={() => setEditing(null)} />
-      )}
+          ))}
+        </div>
+      </div>
+      {tab === "models" ? <Models /> : tab === "credentials" ? <Credentials /> : <Library />}
     </>
   );
 }
@@ -307,6 +216,10 @@ export function CapabilityEditor({
                   {selected.files.join("\n")}
                 </pre>
               )}
+              <CredentialNames
+                value={form.credentials || []}
+                change={(credentials) => setForm({ ...form, credentials })}
+              />
             </>
           ) : (
             <Field label={tr("内容（修改后保存为新版本）")} id="cap-content">
@@ -355,3 +268,28 @@ export function CapabilityEditor({
     </Dialog>
   );
 }
+
+// The variables a capability needs, one per line. Each Agent that binds it
+// chooses which secret supplies each.
+export function CredentialNames({
+  value,
+  change,
+}: {
+  value: string[];
+  change: (names: string[]) => void;
+}) {
+  return (
+    <Field label={tr("需要的密钥（环境变量名，每行一个）")} id="capability-credentials">
+      <Textarea
+        id="capability-credentials"
+        rows={3}
+        className="font-mono"
+        placeholder="GITHUB_TOKEN"
+        value={value.join("\n")}
+        onChange={(event) =>
+          change(event.target.value.split("\n").map((line) => line.trim()).filter(Boolean))
+        }
+      />
+    </Field>
+  );
+}
diff --git a/example/parsar/src/ConfigurationFields.tsx b/example/parsar/src/ConfigurationFields.tsx
index 3d4d0de51..321f65bac 100644
--- a/example/parsar/src/ConfigurationFields.tsx
+++ b/example/parsar/src/ConfigurationFields.tsx
@@ -1,21 +1,23 @@
 import { useState } from "react";
 import { ResourceEditor } from "./Resources";
 import { ExecutionFields } from "./ExecutionFields";
-import { SkillCreate, SkillDetail, useSkills } from "./Skills";
+import { useSkills } from "./Skills";
+import { CapabilityEditorFor, type EditorTarget } from "./Library";
+import { SecretEditor, useAllVaultCredentials } from "./Credentials";
 import { useQuery } from "@tanstack/react-query";
 import { api, readHistory } from "./lib/api";
 import { tr } from "./lib/i18n";
-import {
-  CapabilityEditor,
-  useCapabilities,
-  type Capability,
-} from "./Capabilities";
+import { useCapabilities, type Capability } from "./Capabilities";
 import {
   useModels,
   useMCPs,
   useRuntimes,
+  useFeishuBots,
+  useSecrets,
+  useSkillCredentials,
   type AgentProfile,
 } from "./lib/product";
+import { botVariables } from "../shared/bot-bindings.mjs";
 import { ResourceField } from "./components/ResourceField";
 import {
   maxFiles,
@@ -26,6 +28,8 @@ import { Select, SelectOption } from "./components/ui/select";
 import { Textarea } from "./components/ui/textarea";
 import { ErrorNotice, Field, Section, Toggle } from "./components/shared";
 import { randomUuid } from "@oac/agents-client";
+import { Plus } from "lucide-react";
+import { Button } from "./components/ui/button";
 export type Configuration = Pick<
   AgentProfile,
   | "harness"
@@ -44,6 +48,8 @@ export type Configuration = Pick<
   | "ask_user"
   | "capability_ids"
   | "capability_versions"
+  | "credentials"
+  | "mcp_credentials"
 >;
 export const emptyConfiguration: Configuration = {
   harness: "codex",
@@ -58,10 +64,12 @@ export const emptyConfiguration: Configuration = {
   mcp_ids: [],
 };
 export function ConfigurationFields({
+  agentId,
   value,
   change,
   errors = {},
 }: {
+  agentId: string;
   value: Configuration;
   change: (value: Configuration) => void;
   errors?: { model_id?: string; runtime_id?: string };
@@ -251,6 +259,7 @@ export function ConfigurationFields({
             />
           ))}
       </Section>
+      <CredentialFields agentId={agentId} value={value} change={change} />
       <Section title={tr("行为")}>
         <div className="space-y-3">
           <Toggle
@@ -265,72 +274,31 @@ export function ConfigurationFields({
           />
         </div>
       </Section>
-      {editor?.kind === "skills" &&
-        (editor.creating ? (
-          <SkillCreate
-            close={close}
-            onSaved={(id) =>
-              change({ ...value, skill_ids: [...value.skill_ids, id] })
-            }
-          />
-        ) : (
-          <SkillDetail
-            skill={skills.data!.find((row) => row.id === editor.id)!}
-            close={close}
-          />
-        ))}
-      {(editor?.kind === "mcps" || editor?.kind === "runtimes") && (
+      {editor?.kind === "runtimes" && (
         <ResourceEditor
-          kind={editor.kind}
-          title={editor.kind === "mcps" ? "MCP" : tr("环境模板")}
+          kind="runtimes"
+          title={tr("环境模板")}
           value={
             editor.creating
-              ? editor.kind === "mcps"
-                ? { id: editor.id, revision: 0, name: "", label: "", url: "" }
-                : {
-                    id: editor.id,
-                    revision: 0,
-                    name: "",
-                    environment: "openai_hosted",
-                  }
-              : editor.kind === "mcps"
-                ? mcps.data!.find((row) => row.id === editor.id)!
-                : runtimes.data!.find((row) => row.id === editor.id)!
+              ? { id: editor.id, revision: 0, name: "", environment: "openai_hosted" }
+              : runtimes.data!.find((row) => row.id === editor.id)!
           }
           close={close}
-          onSaved={(id) =>
-            change(
-              editor.kind === "mcps"
-                ? { ...value, mcp_ids: [...new Set([...value.mcp_ids, id])] }
-                : { ...value, runtime_id: id },
-            )
-          }
+          onSaved={(id) => change({ ...value, runtime_id: id })}
         />
       )}
-      {editor && ["prompt", "knowledge", "plugin"].includes(editor.kind) && (
-        <CapabilityEditor
-          value={
-            editor.creating
-              ? {
-                  id: editor.id,
-                  name: "",
-                  description: "",
-                  kind: editor.kind as Capability["kind"],
-                  revision: 0,
-                  deprecated: false,
-                  default_version: "",
-                  versions: [],
-                }
-              : capabilities.data!.find((row) => row.id === editor.id)!
-          }
+      {editor && editor.kind !== "runtimes" && (
+        <CapabilityEditorFor
+          target={editor as EditorTarget}
           close={close}
           onSaved={(id) =>
-            change({
-              ...value,
-              capability_ids: [
-                ...new Set([...(value.capability_ids || []), id]),
-              ],
-            })
+            change(
+              editor.kind === "skills"
+                ? { ...value, skill_ids: [...new Set([...value.skill_ids, id])] }
+                : editor.kind === "mcps"
+                  ? { ...value, mcp_ids: [...new Set([...value.mcp_ids, id])] }
+                  : { ...value, capability_ids: [...new Set([...(value.capability_ids || []), id])] },
+            )
           }
         />
       )}
@@ -380,3 +348,120 @@ function SkillVersionSelect({
     </div>
   );
 }
+
+// Where each credential the bound capabilities need comes from: a secret for
+// each variable, and a Vault credential for each MCP that needs one.
+function CredentialFields({
+  agentId,
+  value,
+  change,
+}: {
+  agentId: string;
+  value: Configuration;
+  change: (value: Configuration) => void;
+}) {
+  const capabilities = useCapabilities(),
+    skillCredentials = useSkillCredentials(),
+    mcps = useMCPs(),
+    runtimes = useRuntimes(),
+    bots = useFeishuBots(),
+    secrets = useSecrets(),
+    vaultCredentials = useAllVaultCredentials();
+  const [creating, setCreating] = useState<string | null>(null);
+  const needed = [
+    ...new Set([
+      ...value.skill_ids.flatMap((id) => skillCredentials.data?.find((row) => row.id === id)?.credentials || []),
+      ...(capabilities.data || [])
+        .filter((row) => value.capability_ids?.includes(row.id))
+        .flatMap((row) => row.credentials || []),
+      ...(runtimes.data?.find((row) => row.id === value.runtime_id)?.credentials || []),
+    ]),
+  ];
+  // The bot's identity comes from the bot bound to this Agent; the rest from chosen secrets.
+  const needsBot = needed.some((name) => name in botVariables);
+  const names = needed.filter((name) => !(name in botVariables));
+  const bot = bots.data?.find((row) => row.agent_id === agentId);
+  const authMcps = (mcps.data || []).filter((row) => value.mcp_ids.includes(row.id) && row.requires_credential);
+  if (!needed.length && !authMcps.length) return null;
+  const choose = (name: string, secretId: string) =>
+    change({ ...value, credentials: { ...value.credentials, [name]: secretId } });
+  return (
+    <Section title={tr("凭据")}>
+      {needsBot && (
+        <Field label={tr("飞书机器人身份")} id="credential-bot">
+          {bot ? (
+            <p id="credential-bot" className="text-sm text-fg">
+              {tr("由绑定的飞书机器人「{{value0}}」提供", { value0: bot.name })}
+            </p>
+          ) : (
+            <p id="credential-bot" className="text-sm text-danger">
+              {tr("请先在飞书接入中给这个 Agent 绑定机器人")}
+            </p>
+          )}
+        </Field>
+      )}
+      {names.map((name) => (
+        <Field key={name} label={name} id={`credential-${name}`}>
+          <div className="flex gap-2">
+            <Select
+              id={`credential-${name}`}
+              aria-label={tr("{{value0}} 使用的密钥", { value0: name })}
+              value={value.credentials?.[name] || ""}
+              onValueChange={(secretId) => choose(name, secretId)}
+            >
+              <SelectOption value="">{tr("选择密钥")}</SelectOption>
+              {secrets.data?.map((secret) => (
+                <SelectOption key={secret.id} value={secret.id}>
+                  {secret.name}
+                </SelectOption>
+              ))}
+            </Select>
+            <Button
+              variant="outline"
+              aria-label={tr("新建 {{value0}} 的密钥", { value0: name })}
+              onClick={() => setCreating(name)}
+            >
+              <Plus />
+              {tr("新建")}
+            </Button>
+          </div>
+        </Field>
+      ))}
+      {authMcps.map((mcp) => {
+        const choice = value.mcp_credentials?.[mcp.id];
+        const options = (vaultCredentials.data || []).filter(({ credential }) => credential.auth.mcp_server_url === mcp.url);
+        return (
+          <Field key={mcp.id} label={mcp.name} id={`mcp-credential-${mcp.id}`}>
+            <Select
+              id={`mcp-credential-${mcp.id}`}
+              aria-label={tr("{{value0}} 使用的凭据", { value0: mcp.name })}
+              value={choice ? `${choice.vault_id}/${choice.credential_id}` : ""}
+              onValueChange={(selected) => {
+                const [vault_id, credential_id] = selected.split("/");
+                change({
+                  ...value,
+                  mcp_credentials: { ...value.mcp_credentials, [mcp.id]: { vault_id: vault_id!, credential_id: credential_id! } },
+                });
+              }}
+            >
+              <SelectOption value="">{options.length ? tr("选择凭据") : tr("先在凭据中为这个地址添加 MCP 凭据")}</SelectOption>
+              {options.map(({ vault, credential }) => (
+                <SelectOption key={credential.id} value={`${vault.id}/${credential.id}`}>
+                  {`${vault.name || vault.id} / ${credential.name}`}
+                </SelectOption>
+              ))}
+            </Select>
+          </Field>
+        );
+      })}
+      <ErrorNotice error={secrets.error || vaultCredentials.error || skillCredentials.error} />
+      {creating && (
+        <SecretEditor
+          value={{ id: randomUuid(), name: creating, revision: 0 }}
+          close={() => setCreating(null)}
+          onSaved={(id) => choose(creating, id)}
+        />
+      )}
+    </Section>
+  );
+}
diff --git a/example/parsar/src/Credentials.tsx b/example/parsar/src/Credentials.tsx
index d8f8e2327..dfdaa4998 100644
--- a/example/parsar/src/Credentials.tsx
+++ b/example/parsar/src/Credentials.tsx
@@ -3,7 +3,8 @@ import { OAuthCredentialDialog } from "./OAuthCredential";
 import { useState } from "react";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { Plus, KeyRound, Trash2 } from "lucide-react";
-import type { VaultCredential } from "@oac/agents-client";
+import { randomUuid, type VaultCredential } from "@oac/agents-client";
+import { product, useSecrets, type Secret } from "./lib/product";
 import { api, readHistory } from "./lib/api";
 import { ErrorNotice, Field } from "./components/shared";
 import { Ledger, LedgerHeader, LedgerRow } from "./components/ui/ledger";
@@ -24,7 +25,160 @@ export const useVaults = () =>
     queryFn: ({ signal }) =>
       readHistory((options) => api.listVaults(options), signal),
   });
+// Every MCP credential across Vaults, with the Vault that holds it.
+export const useAllVaultCredentials = () => {
+  const vaults = useVaults();
+  return useQuery({
+    queryKey: ["vault-credentials", "all", vaults.data?.map((vault) => vault.id).join(",")],
+    enabled: !!vaults.data,
+    queryFn: async ({ signal }) =>
+      (
+        await Promise.all(
+          vaults.data!.map(async (vault) =>
+            (await readHistory((options) => api.listVaultCredentials(vault.id, options), signal)).map(
+              (credential) => ({ vault, credential }),
+            ),
+          ),
+        )
+      ).flat(),
+  });
+};
+
 export function Credentials() {
+  return (
+    <>
+      <Secrets />
+      <VaultCredentials />
+    </>
+  );
+}
+
+// Values capabilities read as variables. A value is write-only: it is never
+// shown again, and saving without one keeps it.
+function Secrets() {
+  const usage = useUsage();
+  const secrets = useSecrets();
+  const cache = useQueryClient();
+  const [editing, setEditing] = useState<Secret | null>(null);
+  const remove = useMutation({
+    mutationFn: (id: string) => product(`secrets/${id}`, "DELETE"),
+    onSuccess: () => cache.invalidateQueries({ queryKey: ["secrets"] }),
+  });
+  return (
+    <>
+      <div className="mx-auto flex w-full max-w-6xl flex-wrap items-center justify-between gap-4 px-6 pt-6 pb-1 sm:px-10">
+        <h2 className="text-lg font-semibold tracking-tight text-fg">{tr("密钥")}</h2>
+        <Button onClick={() => setEditing({ id: randomUuid(), name: "", revision: 0 })}>
+          <Plus />
+          {tr("添加密钥")}
+        </Button>
+      </div>
+      <ErrorNotice page error={secrets.error || remove.error} />
+      <Ledger columns="16px minmax(160px,1fr) 160px 130px">
+        <LedgerHeader>
+          <span />
+          <span>{tr("名称")}</span>
+          <span>{tr("使用情况")}</span>
+          <span />
+        </LedgerHeader>
+        {secrets.data?.map((row) => (
+          <LedgerRow key={row.id}>
+            <KeyRound className="h-3.5 w-3.5 text-fg-muted" />
+            <span>{row.name}</span>
+            <span className="text-fg-muted">{usage.secret(row.id) || tr("未使用")}</span>
+            <div className="flex justify-end">
+              <Button variant="ghost" onClick={() => setEditing(row)}>
+                {tr("更换")}
+              </Button>
+              <Button
+                variant="ghost"
+                size="icon"
+                aria-label={tr("删除密钥 {{value0}}", { value0: row.name })}
+                title={usage.secret(row.id) ? tr("仍在使用中，不能移除") : undefined}
+                disabled={!!usage.secret(row.id) || remove.isPending}
+                onClick={() => {
+                  if (confirm(tr("删除密钥 {{value0}}？", { value0: row.name }))) remove.mutate(row.id);
+                }}
+              >
+                <Trash2 />
+              </Button>
+            </div>
+          </LedgerRow>
+        ))}
+      </Ledger>
+      {editing && <SecretEditor value={editing} close={() => setEditing(null)} />}
+    </>
+  );
+}
+
+export function SecretEditor({
+  value,
+  close,
+  onSaved,
+}: {
+  value: Secret;
+  close: () => void;
+  onSaved?: (id: string) => void;
+}) {
+  const cache = useQueryClient();
+  const [name, setName] = useState(value.name);
+  const [secret, setSecret] = useState("");
+  const save = useMutation({
+    mutationFn: () =>
+      product(`secrets/${value.id}`, "PUT", {
+        revision: value.revision,
+        name,
+        ...(secret ? { value: secret } : {}),
+      }),
+    onSuccess: () => {
+      void cache.invalidateQueries({ queryKey: ["secrets"] });
+      onSaved?.(value.id);
+      close();
+    },
+  });
+  return (
+    <Dialog open onOpenChange={(open) => !open && !save.isPending && close()}>
+      <DialogContent aria-describedby={undefined}>
+        <DialogHeader>
+          <DialogTitle>{value.revision ? tr("更换密钥") : tr("添加密钥")}</DialogTitle>
+        </DialogHeader>
+        <form
+          id="secret-form"
+          className="space-y-4"
+          onSubmit={(event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            save.mutate();
+          }}
+        >
+          <Field label={tr("名称")} id="secret-name">
+            <Input id="secret-name" required value={name} onChange={(e) => setName(e.target.value)} />
+          </Field>
+          <Field label={tr("值")} id="secret-value">
+            <Input
+              id="secret-value"
+              type="password"
+              autoComplete="new-password"
+              required={!value.revision}
+              placeholder={value.revision ? tr("留空保留已保存的值") : undefined}
+              value={secret}
+              onChange={(e) => setSecret(e.target.value)}
+            />
+          </Field>
+          <ErrorNotice error={save.error} />
+        </form>
+        <DialogFooter>
+          <Button type="submit" form="secret-form" disabled={save.isPending}>
+            {tr("保存")}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+// Bearer and OAuth credentials for HTTP MCP servers, kept in Core Vaults.
+function VaultCredentials() {
   const usage = useUsage();
   const vaults = useVaults(),
     cache = useQueryClient(),
@@ -81,7 +235,7 @@ export function Credentials() {
     <>
       <div className="mx-auto flex w-full max-w-6xl flex-wrap items-center justify-between gap-4 px-6 pt-6 pb-1 sm:px-10">
         <div className="flex flex-wrap items-center gap-3">
-          <h2 className="text-lg font-semibold tracking-tight text-fg">{tr("凭据")}</h2>
+          <h2 className="text-lg font-semibold tracking-tight text-fg">{tr("MCP 凭据")}</h2>
           <Select
             aria-label={tr("凭据库")}
             value={selected}
diff --git a/example/parsar/src/EnvironmentFields.tsx b/example/parsar/src/EnvironmentFields.tsx
index 0ead69047..186d3278f 100644
--- a/example/parsar/src/EnvironmentFields.tsx
+++ b/example/parsar/src/EnvironmentFields.tsx
@@ -1,5 +1,5 @@
-import { botFields } from "../shared/bot-bindings.mjs";
-import { Select, SelectOption } from "./components/ui/select";
+import { botVariables } from "../shared/bot-bindings.mjs";
+import { CredentialNames } from "./Capabilities";
 import { useState } from "react";
 import { tr } from "./lib/i18n";
 import type { RuntimeProfile } from "./lib/product";
@@ -170,83 +170,10 @@ export function EnvironmentFields({
           </div>
         ))}
       </Group>
-      <Group
-        title={tr("飞书机器人变量")}
-        action={
-          <Button
-            type="button"
-            variant="outline"
-            onClick={() => {
-              let name = "FEISHU_APP_ID";
-              while (name in (value.bot_env || {}) || name in (value.env || {}))
-                name += "_";
-              onChange({
-                ...value,
-                bot_env: { ...value.bot_env, [name]: "app_id" },
-              });
-            }}
-          >
-            {tr("添加机器人变量")}
-          </Button>
-        }
-      >
-        {Object.entries(value.bot_env || {}).map(
-          ([name, source], index, rows) => (
-            <div key={index} className="flex gap-2">
-              <Input
-                aria-label={tr("机器人变量名称")}
-                value={name}
-                onChange={(event) => {
-                  if (
-                    event.target.value !== name &&
-                    event.target.value in (value.bot_env || {})
-                  ) {
-                    event.target.setCustomValidity(tr("变量名称不能重复"));
-                    return;
-                  }
-                  event.target.setCustomValidity("");
-                  const updated = [...rows];
-                  updated[index] = [event.target.value, source];
-                  onChange({
-                    ...value,
-                    bot_env: Object.fromEntries(updated),
-                  });
-                }}
-              />
-              <Select
-                aria-label={tr("机器人字段")}
-                value={source}
-                onValueChange={(field) =>
-                  onChange({
-                    ...value,
-                    bot_env: { ...value.bot_env, [name]: field },
-                  })
-                }
-              >
-                {Object.entries(botFields).map(([field, label]) => (
-                  <SelectOption key={field} value={field}>
-                    {tr(label)}
-                  </SelectOption>
-                ))}
-              </Select>
-              <Button
-                type="button"
-                variant="ghost"
-                onClick={() =>
-                  onChange({
-                    ...value,
-                    bot_env: Object.fromEntries(
-                      rows.filter((_, i) => i !== index),
-                    ),
-                  })
-                }
-              >
-                {tr("移除")}
-              </Button>
-            </div>
-          ),
-        )}
-      </Group>
+      <CredentialNames
+        value={value.credentials || []}
+        change={(credentials) => onChange({ ...value, credentials })}
+      />
       <Group
         title={tr("初始文件")}
         action={
@@ -321,7 +248,7 @@ export function environmentSummary(value: RuntimeProfile) {
       value.setup_script ? tr("初始化脚本") : "",
       Object.keys(value.env || {}).length ? tr("环境变量") : "",
       value.files?.length ? tr("初始文件") : "",
-      Object.keys(value.bot_env || {}).length ? tr("飞书机器人身份") : "",
+      value.credentials?.some((name) => name in botVariables) ? tr("飞书机器人身份") : "",
     ]
       .filter(Boolean)
       .join(" · ") || tr("空白工作环境")
diff --git a/example/parsar/src/Feishu.tsx b/example/parsar/src/Feishu.tsx
index 578e0de8e..2b4c6fe28 100644
--- a/example/parsar/src/Feishu.tsx
+++ b/example/parsar/src/Feishu.tsx
@@ -188,14 +188,6 @@ function BotCard({ bot }: { bot: FeishuBot }) {
         </div>
         {credentials && (
           <div className="grid gap-4 border-t border-line-muted pt-6 sm:grid-cols-2">
-            <Field label={tr("机器人名称")} id={`bot-name-${bot.id}`}>
-              <Input
-                id={`bot-name-${bot.id}`}
-                value={form.name}
-                maxLength={80}
-                onChange={(e) => setForm({ ...form, name: e.target.value })}
-              />
-            </Field>
             <Field label={tr("地区")} id={`bot-brand-${bot.id}`}>
               <Select
                 id={`bot-brand-${bot.id}`}
@@ -490,7 +482,6 @@ function QrCreate({ close }: { close: () => void }) {
 function ManualCreate({ close }: { close: () => void }) {
   const cache = useQueryClient();
   const [form, setForm] = useState({
-    name: "",
     app_id: "",
     app_secret: "",
     brand: "feishu" as "feishu" | "lark",
@@ -518,15 +509,6 @@ function ManualCreate({ close }: { close: () => void }) {
         save.mutate();
       }}
     >
-      <Field label={tr("机器人名称")} id="new-bot-name">
-        <Input
-          id="new-bot-name"
-          required
-          maxLength={80}
-          value={form.name}
-          onChange={(e) => setForm({ ...form, name: e.target.value })}
-        />
-      </Field>
       <Field label="App ID" id="new-bot-app">
         <Input
           id="new-bot-app"
diff --git a/example/parsar/src/Library.tsx b/example/parsar/src/Library.tsx
new file mode 100644
index 000000000..8c4a1bf3a
--- /dev/null
+++ b/example/parsar/src/Library.tsx
@@ -0,0 +1,316 @@
+import { useState } from "react";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { Pencil, Plus, Search } from "lucide-react";
+import { randomUuid } from "@oac/agents-client";
+import catalog from "./lib/mcp-catalog.json";
+import { tr } from "./lib/i18n";
+import { botVariables } from "../shared/bot-bindings.mjs";
+import { api } from "./lib/api";
+import {
+  useAgents,
+  useMCPs,
+  useSkillCredentials,
+  type AgentProfile,
+  type MCPProfile,
+} from "./lib/product";
+import { CapabilityEditor, useCapabilities, type Capability } from "./Capabilities";
+import { ResourceEditor } from "./Resources";
+import { SkillCreate, SkillDetail, SkillsDirectory, useSkills } from "./Skills";
+import { Button } from "./components/ui/button";
+import { Input } from "./components/ui/input";
+import { Ledger, LedgerHeader, LedgerRow } from "./components/ui/ledger";
+import { EmptyState } from "./components/ui/empty-state";
+import { Dialog, DialogContent, DialogHeader, DialogTitle } from "./components/ui/dialog";
+import { ErrorNotice } from "./components/shared";
+
+export type CapabilityKind = "skills" | "mcps" | Capability["kind"];
+export const kindLabels: Record<CapabilityKind, string> = {
+  skills: "Skill",
+  mcps: "MCP",
+  plugin: "Plugin",
+  prompt: tr("指令片段"),
+  knowledge: tr("知识"),
+};
+export type EditorTarget = { kind: CapabilityKind; id: string; creating?: boolean; value?: MCPProfile };
+
+// The editor for one capability, wherever it is opened from.
+export function CapabilityEditorFor({
+  target,
+  close,
+  onSaved,
+}: {
+  target: EditorTarget;
+  close: () => void;
+  onSaved?: (id: string) => void;
+}) {
+  const skills = useSkills(),
+    mcps = useMCPs(),
+    capabilities = useCapabilities();
+  if (target.kind === "skills")
+    return target.creating ? (
+      <SkillCreate close={close} onSaved={onSaved} />
+    ) : (
+      <SkillDetail skill={skills.data!.find((row) => row.id === target.id)!} close={close} />
+    );
+  if (target.kind === "mcps")
+    return (
+      <ResourceEditor
+        kind="mcps"
+        title="MCP"
+        value={
+          target.value ||
+          (target.creating
+            ? { id: target.id, revision: 0, name: "", label: "", url: "" }
+            : mcps.data!.find((row) => row.id === target.id)!)
+        }
+        close={close}
+        onSaved={onSaved}
+      />
+    );
+  return (
+    <CapabilityEditor
+      value={
+        target.creating
+          ? { id: target.id, name: "", description: "", kind: target.kind, revision: 0, deprecated: false, default_version: "", versions: [] }
+          : capabilities.data!.find((row) => row.id === target.id)!
+      }
+      close={close}
+      onSaved={onSaved}
+    />
+  );
+}
+
+// Enabled Agents that bind a capability.
+const enabledAgents = (agents: AgentProfile[], kind: CapabilityKind, id: string) =>
+  agents.filter(
+    (agent) =>
+      agent.enabled !== false &&
+      (kind === "skills" ? agent.skill_ids : kind === "mcps" ? agent.mcp_ids : agent.capability_ids || []).includes(id),
+  ).length;
+
+// Every capability Agents can bind, in one list.
+export function Library() {
+  const skills = useSkills(),
+    mcps = useMCPs(),
+    capabilities = useCapabilities(),
+    agents = useAgents(),
+    skillCredentials = useSkillCredentials();
+  const cache = useQueryClient();
+  const [kind, setKind] = useState<CapabilityKind | "">("");
+  const [search, setSearch] = useState("");
+  const [editor, setEditor] = useState<EditorTarget | null>(null);
+  const [adding, setAdding] = useState(false);
+  const [directory, setDirectory] = useState<"skills" | "mcps" | "">("");
+  const upload = useMutation({
+    mutationFn: (file: File) => api.uploadSkill({ kind: "zip", file, filename: file.name }),
+    onSuccess: () => cache.invalidateQueries({ queryKey: ["skills"] }),
+  });
+  const all = agents.data || [];
+  // The bot's identity variables read as one requirement: the bound Feishu bot.
+  const needs = (names: string[]) =>
+    [
+      ...(names.some((name) => name in botVariables) ? [tr("飞书机器人")] : []),
+      ...names.filter((name) => !(name in botVariables)),
+    ].join("、") || tr("无需凭据");
+  const rows = [
+    ...(skills.data || []).map((row) => ({
+      kind: "skills" as const,
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      version: `v${row.default_version}`,
+      credentials: needs(skillCredentials.data?.find((entry) => entry.id === row.id)?.credentials || []),
+    })),
+    ...(mcps.data || []).map((row) => ({
+      kind: "mcps" as const,
+      id: row.id,
+      name: row.name,
+      description: row.url,
+      version: "—",
+      credentials: row.requires_credential ? tr("凭据库凭据") : tr("无需凭据"),
+    })),
+    ...(capabilities.data || []).map((row) => ({
+      kind: row.kind,
+      id: row.id,
+      name: row.name,
+      description: row.deprecated ? tr("已停用") : row.description,
+      version: `v${row.default_version}`,
+      credentials: needs(row.credentials || []),
+    })),
+  ].filter(
+    (row) =>
+      (!kind || row.kind === kind) &&
+      `${row.name} ${row.description}`.toLowerCase().includes(search.toLowerCase()),
+  );
+  const loading = skills.isPending || mcps.isPending || capabilities.isPending;
+  const create = (target: CapabilityKind) => {
+    setAdding(false);
+    setEditor({ kind: target, id: randomUuid(), creating: true });
+  };
+  return (
+    <>
+      <div className="mx-auto flex w-full max-w-6xl flex-wrap items-center justify-between gap-3 px-6 pt-6 pb-1 sm:px-10">
+        <div role="tablist" aria-label={tr("能力类型")} className="flex flex-wrap gap-2">
+          {(["", "skills", "mcps", "plugin", "prompt", "knowledge"] as const).map((value) => (
+            <button
+              key={value || "all"}
+              role="tab"
+              aria-selected={kind === value}
+              onClick={() => setKind(value)}
+              className={
+                kind === value
+                  ? "h-9 rounded-full bg-fg px-4 text-sm font-medium text-surface"
+                  : "h-9 rounded-full px-4 text-sm text-fg-muted hover:bg-surface-muted hover:text-fg"
+              }
+            >
+              {value ? kindLabels[value] : tr("全部")}
+            </button>
+          ))}
+        </div>
+        <div className="flex items-center gap-3">
+          <div className="relative w-56">
+            <Search className="absolute left-3 top-2.5 h-4 w-4 text-fg-muted" />
+            <Input
+              className="pl-9"
+              aria-label={tr("搜索能力")}
+              placeholder={tr("搜索能力")}
+              value={search}
+              onChange={(event) => setSearch(event.target.value)}
+            />
+          </div>
+          <Button onClick={() => setAdding(true)}>
+            <Plus />
+            {tr("新建能力")}
+          </Button>
+        </div>
+      </div>
+      <ErrorNotice page error={skills.error || mcps.error || capabilities.error || agents.error || upload.error} />
+      <Ledger columns="minmax(220px,2fr) 100px 100px 120px minmax(140px,1fr) 48px">
+        <LedgerHeader>
+          <span>{tr("能力")}</span>
+          <span>{tr("类型")}</span>
+          <span>{tr("版本")}</span>
+          <span>{tr("已启用 Agent")}</span>
+          <span>{tr("凭据需求")}</span>
+          <span />
+        </LedgerHeader>
+        {rows.map((row) => (
+          <LedgerRow key={`${row.kind}:${row.id}`}>
+            <button className="min-w-0 text-left" onClick={() => setEditor({ kind: row.kind, id: row.id })}>
+              <span className="block truncate font-medium text-fg">{row.name}</span>
+              <span className="block truncate text-fg-muted">{row.description}</span>
+            </button>
+            <span>{kindLabels[row.kind]}</span>
+            <span className="font-mono text-fg-muted">{row.version}</span>
+            <span className="tabular-nums">{enabledAgents(all, row.kind, row.id)}</span>
+            <span className="truncate text-fg-muted">{row.credentials}</span>
+            <Button
+              variant="ghost"
+              size="icon"
+              aria-label={tr("编辑 {{value0}}", { value0: row.name })}
+              onClick={() => setEditor({ kind: row.kind, id: row.id })}
+            >
+              <Pencil />
+            </Button>
+          </LedgerRow>
+        ))}
+        {!loading && !rows.length && <EmptyState title={tr("暂无能力")} />}
+      </Ledger>
+      {adding && (
+        <Dialog open onOpenChange={setAdding}>
+          <DialogContent aria-describedby={undefined} className="sm:max-w-lg">
+            <DialogHeader>
+              <DialogTitle>{tr("新建能力")}</DialogTitle>
+            </DialogHeader>
+            <div className="grid gap-2">
+              <Button variant="outline" className="justify-start" onClick={() => create("mcps")}>{tr("添加 HTTP MCP")}</Button>
+              <Button variant="outline" className="justify-start" onClick={() => { setAdding(false); setDirectory("mcps"); }}>{tr("从 MCP 目录添加")}</Button>
+              <Button variant="outline" className="justify-start" onClick={() => create("skills")}>{tr("编写 Skill")}</Button>
+              <Button variant="outline" className="justify-start" asChild>
+                <label className="cursor-pointer">
+                  {upload.isPending ? tr("上传中\u2026") : tr("上传 Skill ZIP")}
+                  <input
+                    aria-label={tr("上传 Skill ZIP")}
+                    type="file"
+                    accept=".zip"
+                    className="sr-only"
+                    disabled={upload.isPending}
+                    onChange={(event) => {
+                      const file = event.target.files?.[0];
+                      if (file) upload.mutate(file, { onSuccess: () => setAdding(false) });
+                      event.target.value = "";
+                    }}
+                  />
+                </label>
+              </Button>
+              <Button variant="outline" className="justify-start" onClick={() => { setAdding(false); setDirectory("skills"); }}>{tr("从 Skill 目录导入")}</Button>
+              <Button variant="outline" className="justify-start" onClick={() => create("plugin")}>{tr("上传 Plugin")}</Button>
+              <Button variant="outline" className="justify-start" onClick={() => create("prompt")}>{tr("编写指令片段")}</Button>
+              <Button variant="outline" className="justify-start" onClick={() => create("knowledge")}>{tr("添加知识")}</Button>
+            </div>
+          </DialogContent>
+        </Dialog>
+      )}
+      {directory === "skills" && <SkillsDirectory close={() => setDirectory("")} />}
+      {directory === "mcps" && (
+        <McpDirectory
+          close={() => setDirectory("")}
+          pick={(value) => {
+            setDirectory("");
+            setEditor({ kind: "mcps", id: value.id, creating: true, value });
+          }}
+        />
+      )}
+      {editor && <CapabilityEditorFor target={editor} close={() => setEditor(null)} />}
+    </>
+  );
+}
+
+// Known HTTP MCP services; picking one prefills a new MCP.
+function McpDirectory({ close, pick }: { close: () => void; pick: (value: MCPProfile) => void }) {
+  const [search, setSearch] = useState("");
+  return (
+    <Dialog open onOpenChange={(open) => !open && close()}>
+      <DialogContent aria-describedby={undefined} className="max-h-[85dvh] overflow-auto">
+        <DialogHeader>
+          <DialogTitle>{tr("MCP 目录")}</DialogTitle>
+        </DialogHeader>
+        <Input
+          aria-label={tr("搜索 MCP 目录")}
+          value={search}
+          onChange={(event) => setSearch(event.target.value)}
+          placeholder={tr("搜索服务")}
+        />
+        <div className="divide-y divide-line">
+          {catalog.items
+            .filter((item) => `${item.name} ${item.description}`.toLowerCase().includes(search.toLowerCase()))
+            .map((item) => (
+              <div key={item.id} className="flex items-center justify-between gap-4 py-3">
+                <div className="min-w-0">
+                  <a href={item.homepage_url} target="_blank" rel="noreferrer" className="text-sm font-medium underline">
+                    {item.name}
+                  </a>
+                  <p className="mt-1 text-sm text-fg-muted">{item.description}</p>
+                </div>
+                <Button
+                  variant="outline"
+                  onClick={() =>
+                    pick({
+                      id: randomUuid(),
+                      revision: 0,
+                      name: item.name,
+                      label: item.server.name,
+                      url: item.server.url,
+                      requires_credential: "authentication" in item,
+                    })
+                  }
+                >
+                  {tr("添加服务")}
+                </Button>
+              </div>
+            ))}
+        </div>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/example/parsar/src/Resources.tsx b/example/parsar/src/Resources.tsx
index 6abbadbde..51e92a47a 100644
--- a/example/parsar/src/Resources.tsx
+++ b/example/parsar/src/Resources.tsx
@@ -2,15 +2,12 @@ import { EnvironmentFields, environmentSummary } from "./EnvironmentFields";
 // The Feishu workspace preset is the shipped example, so both stay one definition.
 import feishuEnvironment from "../examples/feishu/environment.json";
 import feishuSetupScript from "../examples/feishu/setup.sh?raw";
-import catalog from "./lib/mcp-catalog.json";
 import { tr } from "./lib/i18n";
-import { useVaults } from "./Credentials";
 import { useState } from "react";
 import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { Plus, Pencil, Trash2, Plug, Server } from "lucide-react";
+import { Plus, Pencil, Trash2, Server } from "lucide-react";
 import {
   product,
-  useMCPs,
   useRuntimes,
   type MCPProfile,
   type RuntimeProfile,
@@ -25,165 +22,36 @@ import {
   DialogTitle,
   DialogFooter,
 } from "./components/ui/dialog";
-import { Field, ErrorNotice, PageHeader } from "./components/shared";
+import { Field, ErrorNotice, PageHeader, Toggle } from "./components/shared";
 import { EmptyState } from "./components/ui/empty-state";
 import { randomUuid } from "@oac/agents-client";
 import { useUsage } from "./lib/usage";
 import { RuntimeTrial } from "./Checks";
-export function MCPs() {
-  const query = useMCPs();
-  return (
-    <ResourceList
-      kind="mcps"
-      title="MCP"
-      rows={query.data || []}
-      error={query.error}
-    />
-  );
-}
 export function Runtimes() {
   const query = useRuntimes();
-  return (
-    <ResourceList
-      kind="runtimes"
-      title={tr("环境模板")}
-      rows={query.data || []}
-      error={query.error}
-    />
-  );
-}
-function ResourceList({
-  kind,
-  title,
-  rows,
-  error,
-}: {
-  kind: "mcps" | "runtimes";
-  title: string;
-  rows: (MCPProfile | RuntimeProfile)[];
-  error: unknown;
-}) {
-  const [editing, setEditing] = useState<MCPProfile | RuntimeProfile | null>(
-    null,
-  );
-  const [directory, setDirectory] = useState(false),
-    [search, setSearch] = useState("");
+  const rows = query.data || [];
+  const [editing, setEditing] = useState<RuntimeProfile | null>(null);
   const cache = useQueryClient();
   const usage = useUsage();
-  const used = (id: string) =>
-    kind === "mcps" ? usage.mcp(id) : usage.runtime(id);
   const remove = useMutation({
-    mutationFn: (id: string) => product(`${kind}/${id}`, "DELETE"),
-    onSuccess: () => cache.invalidateQueries({ queryKey: [kind] }),
+    mutationFn: (id: string) => product(`runtimes/${id}`, "DELETE"),
+    onSuccess: () => cache.invalidateQueries({ queryKey: ["runtimes"] }),
   });
-  const Icon = kind === "mcps" ? Plug : Server;
-  const actions = (
-    <>
-      {kind === "mcps" && (
-        <Button variant="outline" onClick={() => setDirectory(true)}>
-          {tr("浏览目录")}
-        </Button>
-      )}
-      <Button
-        onClick={() =>
-          setEditing(
-            kind === "mcps"
-              ? {
-                  id: randomUuid(),
-                  name: "",
-                  label: "",
-                  url: "",
-                  revision: 0,
-                }
-              : {
-                  id: randomUuid(),
-                  name: "",
-                  environment: "openai_hosted",
-                  revision: 0,
-                },
-          )
-        }
-      >
-        <Plus />
-        {tr("添加")}
-        {title}
-      </Button>
-    </>
-  );
+  const title = tr("环境模板");
   return (
     <>
-      {kind === "runtimes" ? (
-        <PageHeader title={title}>{actions}</PageHeader>
-      ) : (
-        <div className="mx-auto flex w-full max-w-6xl flex-wrap items-center justify-between gap-3 px-6 pt-6 pb-1 sm:px-10">
-          <h2 className="text-lg font-semibold tracking-tight text-fg">{title}</h2>
-          <div className="flex flex-wrap items-center gap-2">{actions}</div>
-        </div>
-      )}
-      {directory && (
-        <Dialog open onOpenChange={setDirectory}>
-          <DialogContent
-            aria-describedby={undefined}
-            className="max-h-[85dvh] overflow-auto"
-          >
-            <DialogHeader>
-              <DialogTitle>{tr("MCP 目录")}</DialogTitle>
-            </DialogHeader>
-            <Input
-              aria-label={tr("搜索 MCP 目录")}
-              value={search}
-              onChange={(event) => setSearch(event.target.value)}
-              placeholder={tr("搜索服务")}
-            />
-            <div className="divide-y divide-line">
-              {catalog.items
-                .filter((item) =>
-                  `${item.name} ${item.description}`
-                    .toLowerCase()
-                    .includes(search.toLowerCase()),
-                )
-                .map((item) => (
-                  <div key={item.id} className="py-3">
-                    <div className="flex items-center justify-between">
-                      <a
-                        href={item.homepage_url}
-                        target="_blank"
-                        rel="noreferrer"
-                        className="text-sm font-medium underline"
-                      >
-                        {item.name}
-                      </a>
-                      <Button
-                        variant="outline"
-                        onClick={() => {
-                          setDirectory(false);
-                          setEditing({
-                            id: randomUuid(),
-                            revision: 0,
-                            name: item.name,
-                            label: item.server.name,
-                            url: item.server.url,
-                          });
-                        }}
-                      >
-                        {tr("添加服务")}
-                      </Button>
-                    </div>
-                    <p className="mt-1 text-sm text-fg-muted">
-                      {item.description}
-                    </p>
-                    {"authentication" in item && (
-                      <p className="mt-1 text-sm">
-                        {tr("此服务需要认证，请绑定对应服务的凭据。")}
-                      </p>
-                    )}
-                  </div>
-                ))}
-            </div>
-          </DialogContent>
-        </Dialog>
-      )}
-      <ErrorNotice page error={error || remove.error} />
+      <PageHeader title={title}>
+        <Button
+          onClick={() =>
+            setEditing({ id: randomUuid(), name: "", environment: "openai_hosted", revision: 0 })
+          }
+        >
+          <Plus />
+          {tr("添加")}
+          {title}
+        </Button>
+      </PageHeader>
+      <ErrorNotice page error={query.error || remove.error} />
       <div className="mx-auto w-full max-w-6xl px-6 pb-12 pt-1 sm:px-10">
         {rows.length > 0 ? (
           <div className="divide-y divide-line-muted overflow-hidden rounded-2xl border border-line bg-surface app-shadow-card">
@@ -194,19 +62,15 @@ function ResourceList({
               >
                 <div className="flex min-w-0 flex-1 items-center gap-4">
                   <span className="flex h-9 w-9 shrink-0 items-center justify-center rounded-xl bg-surface-muted">
-                    <Icon strokeWidth={1.7} className="h-4 w-4 text-fg-muted" />
+                    <Server strokeWidth={1.7} className="h-4 w-4 text-fg-muted" />
                   </span>
                   <div className="min-w-0 flex-1">
-                    <h2 className="truncate text-sm font-semibold text-fg">
-                      {row.name}
-                    </h2>
+                    <h2 className="truncate text-sm font-semibold text-fg">{row.name}</h2>
                     <p className="mt-0.5 truncate text-sm text-fg-muted">
-                      {"url" in row
-                        ? row.url
-                        : row.description || environmentSummary(row)}
+                      {row.description || environmentSummary(row)}
                     </p>
                   </div>
-                  {kind === "runtimes" && <RuntimeTrial id={row.id} name={row.name} />}
+                  <RuntimeTrial id={row.id} name={row.name} />
                   <Button
                     variant="ghost"
                     size="icon"
@@ -219,11 +83,10 @@ function ResourceList({
                     variant="ghost"
                     size="icon"
                     aria-label={tr("移除 {{value0}}", { value0: row.name })}
-                    title={used(row.id) ? tr("仍在使用中，不能移除") : undefined}
-                    disabled={remove.isPending || !!used(row.id)}
+                    title={usage.runtime(row.id) ? tr("仍在使用中，不能移除") : undefined}
+                    disabled={remove.isPending || !!usage.runtime(row.id)}
                     onClick={() => {
-                      if (confirm(tr("移除 {{value0}}？", { value0: row.name })))
-                        remove.mutate(row.id);
+                      if (confirm(tr("移除 {{value0}}？", { value0: row.name }))) remove.mutate(row.id);
                     }}
                   >
                     <Trash2 />
@@ -233,18 +96,11 @@ function ResourceList({
             ))}
           </div>
         ) : (
-          <EmptyState
-            title={tr("添加可供 Agent 使用的{{value0}}", { value0: title })}
-          />
+          <EmptyState title={tr("添加可供 Agent 使用的{{value0}}", { value0: title })} />
         )}
       </div>
       {editing && (
-        <ResourceEditor
-          kind={kind}
-          title={title}
-          value={editing}
-          close={() => setEditing(null)}
-        />
+        <ResourceEditor kind="runtimes" title={title} value={editing} close={() => setEditing(null)} />
       )}
     </>
   );
@@ -263,10 +119,17 @@ export function ResourceEditor({
   value: MCPProfile | RuntimeProfile;
   close: () => void;
 }) {
-  const vaults = useVaults();
   const [form, setForm] = useState(value);
   const [preset, setPreset] = useState("");
   const cache = useQueryClient();
+  const usage = useUsage();
+  const remove = useMutation({
+    mutationFn: () => product(`${kind}/${form.id}`, "DELETE"),
+    onSuccess: () => {
+      void cache.invalidateQueries({ queryKey: [kind] });
+      close();
+    },
+  });
   const save = useMutation({
     mutationFn: () =>
       product(
@@ -352,22 +215,6 @@ export function ResourceEditor({
           </Field>
           {"url" in form ? (
             <>
-              <Field label={tr("凭据库")} id="mcp-vault">
-                <Select
-                  id="mcp-vault"
-                  value={form.vault_id || ""}
-                  onValueChange={(vault_id) =>
-                    setForm({ ...form, vault_id, credential_id: "" })
-                  }
-                >
-                  <SelectOption value="">{tr("无需认证")}</SelectOption>
-                  {vaults.data?.map((vault) => (
-                    <SelectOption key={vault.id} value={vault.id}>
-                      {vault.name || vault.id}
-                    </SelectOption>
-                  ))}
-                </Select>
-              </Field>
               <Field label={tr("服务标识")} id="mcp-label">
                 <Input
                   id="mcp-label"
@@ -388,14 +235,31 @@ export function ResourceEditor({
                   onChange={(e) => setForm({ ...form, url: e.target.value })}
                 />
               </Field>
+              <Toggle
+                label={tr("需要凭据（由使用它的 Agent 选择）")}
+                checked={!!form.requires_credential}
+                onChange={(requires_credential) => setForm({ ...form, requires_credential })}
+              />
             </>
           ) : (
             <EnvironmentFields value={form} onChange={setForm} />
           )}
-          <ErrorNotice error={save.error} />
+          <ErrorNotice error={save.error || remove.error} />
         </form>
         <DialogFooter>
-          <Button type="submit" form="resource-form" disabled={save.isPending}>
+          {kind === "mcps" && value.revision > 0 && (
+            <Button
+              variant="ghost"
+              title={usage.mcp(value.id) ? tr("仍在使用中，不能移除") : undefined}
+              disabled={remove.isPending || !!usage.mcp(value.id)}
+              onClick={() => {
+                if (confirm(tr("移除 {{value0}}？", { value0: value.name }))) remove.mutate();
+              }}
+            >
+              {tr("删除 MCP")}
+            </Button>
+          )}
+          <Button type="submit" form="resource-form" disabled={save.isPending || remove.isPending}>
             {tr("保存")}
           </Button>
         </DialogFooter>
diff --git a/example/parsar/src/Skills.tsx b/example/parsar/src/Skills.tsx
index 2b15d83fb..f1082739c 100644
--- a/example/parsar/src/Skills.tsx
+++ b/example/parsar/src/Skills.tsx
@@ -1,10 +1,11 @@
-import { product } from "./lib/product";
+import { product, useSkillCredentials } from "./lib/product";
+import { CredentialNames } from "./Capabilities";
 import { Select, SelectOption } from "./components/ui/select";
 import { unzipSync, strFromU8 } from "fflate";
 import { tr } from "./lib/i18n";
 import { useState } from "react";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { BookOpen, Plus, Upload, Trash2 } from "lucide-react";
+import { Upload, Trash2 } from "lucide-react";
 import type { Skill } from "@oac/agents-client";
 import { api, readHistory } from "./lib/api";
 import { Button } from "./components/ui/button";
@@ -18,111 +19,12 @@ import {
   DialogFooter,
 } from "./components/ui/dialog";
 import { ErrorNotice, Field } from "./components/shared";
-import { EmptyState } from "./components/ui/empty-state";
 export const useSkills = () =>
   useQuery({
     queryKey: ["skills"],
     queryFn: ({ signal }) =>
       readHistory((options) => api.listSkills(options), signal),
   });
-export function Skills() {
-  const query = useSkills();
-  const cache = useQueryClient();
-  const [selected, setSelected] = useState<Skill | null>(null);
-  const [creating, setCreating] = useState(false);
-  const [directory, setDirectory] = useState(false);
-  const [search, setSearch] = useState("");
-  const upload = useMutation({
-    mutationFn: (file: File) =>
-      api.uploadSkill({ kind: "zip", file, filename: file.name }),
-    onSuccess: () => cache.invalidateQueries({ queryKey: ["skills"] }),
-  });
-  return (
-    <>
-      <div className="mx-auto flex w-full max-w-6xl flex-wrap items-center justify-between gap-3 px-6 pt-6 pb-2 sm:px-10">
-        <div className="flex min-w-0 flex-1 flex-wrap items-center gap-4">
-          <h2 className="text-lg font-semibold tracking-tight text-fg">Skills</h2>
-          <Input
-            aria-label={tr("搜索 Skills")}
-            placeholder={tr("搜索技能")}
-            value={search}
-            onChange={(e) => setSearch(e.target.value)}
-            className="max-w-xs"
-          />
-        </div>
-        <div className="flex flex-wrap items-center gap-2">
-          <Button variant="outline" onClick={() => setDirectory(true)}>
-            {tr("浏览目录")}
-          </Button>
-          <Button variant="outline" asChild>
-            <label className="cursor-pointer">
-              <Upload />
-              {upload.isPending ? tr("上传中\u2026") : tr("上传 ZIP")}
-              <input
-                aria-label={tr("上传 Skill ZIP")}
-                type="file"
-                accept=".zip"
-                className="sr-only"
-                disabled={upload.isPending}
-                onChange={(e) => {
-                  const file = e.target.files?.[0];
-                  if (file) upload.mutate(file);
-                  e.target.value = "";
-                }}
-              />
-            </label>
-          </Button>
-          <Button onClick={() => setCreating(true)}>
-            <Plus />
-            {tr("创建 Skill")}
-          </Button>
-        </div>
-      </div>
-      <ErrorNotice page error={query.error || upload.error} />
-      <div className="mx-auto w-full max-w-6xl px-6 py-4 sm:px-10">
-        {query.data && query.data.length > 0 ? (
-          <div className="flex flex-col divide-y divide-line-muted overflow-hidden rounded-2xl border border-line bg-surface app-shadow-card">
-            {query.data
-              .filter((skill) =>
-                `${skill.name} ${skill.description}`
-                  .toLowerCase()
-                  .includes(search.toLowerCase()),
-              )
-              .map((skill) => (
-                <button
-                  key={skill.id}
-                  onClick={() => setSelected(skill)}
-                  className="flex min-h-13 items-center gap-6 px-5 py-3 text-left transition-colors hover:bg-surface-hover/60 focus-visible:ring-2 focus-visible:ring-accent"
-                >
-                  <div className="flex min-w-0 flex-1 items-center gap-3">
-                    <BookOpen className="h-4 w-4 shrink-0 text-fg-muted" />
-                    <h2 className="min-w-0 flex-1 truncate text-sm font-medium text-fg">
-                      {skill.name}
-                    </h2>
-                    <span className="rounded-md bg-surface-subtle px-2 py-0.5 font-mono text-sm text-fg-muted ring-1 ring-line">
-                      v{skill.default_version}
-                    </span>
-                  </div>
-                  <p className="w-1/2 truncate text-sm text-fg-muted">
-                    {skill.description}
-                  </p>
-                </button>
-              ))}
-          </div>
-        ) : (
-          !query.isPending && (
-            <EmptyState title={tr("把常用方法保存为 Skill")} />
-          )
-        )}
-      </div>
-      {directory && <SkillsDirectory close={() => setDirectory(false)} />}
-      {creating && <SkillCreate close={() => setCreating(false)} />}
-      {selected && (
-        <SkillDetail skill={selected} close={() => setSelected(null)} />
-      )}
-    </>
-  );
-}
 export function SkillCreate({
   close,
   onSaved,
@@ -289,6 +191,7 @@ export function SkillDetail({
           <DialogTitle>{current.data.name}</DialogTitle>
         </DialogHeader>
         <p className="text-base leading-relaxed">{current.data.description}</p>
+        <SkillCredentials id={skill.id} />
         <h3 className="font-semibold">{tr("版本")}</h3>
         <ErrorNotice
           error={
@@ -433,7 +336,7 @@ interface RegistryPreview {
   files: string[];
   instructions: string;
 }
-function SkillsDirectory({ close }: { close: () => void }) {
+export function SkillsDirectory({ close }: { close: () => void }) {
   const [search, setSearch] = useState(""),
     [source, setSource] = useState(""),
     [slug, setSlug] = useState(""),
@@ -605,3 +508,28 @@ function SkillsDirectory({ close }: { close: () => void }) {
     </Dialog>
   );
 }
+
+// The variables this Skill needs; Parsar keeps them beside the Core Skill.
+function SkillCredentials({ id }: { id: string }) {
+  const cache = useQueryClient();
+  const saved = useSkillCredentials().data?.find((row) => row.id === id)?.credentials || [];
+  const [names, setNames] = useState<string[] | undefined>();
+  const save = useMutation({
+    mutationFn: () => product(`skills/${id}/credentials`, "PUT", { credentials: names }),
+    onSuccess: () => {
+      setNames(undefined);
+      void cache.invalidateQueries({ queryKey: ["skill-credentials"] });
+    },
+  });
+  return (
+    <div className="space-y-2">
+      <CredentialNames value={names ?? saved} change={setNames} />
+      {names !== undefined && (
+        <Button variant="outline" disabled={save.isPending} onClick={() => save.mutate()}>
+          {tr("保存凭据需求")}
+        </Button>
+      )}
+      <ErrorNotice error={save.error} />
+    </div>
+  );
+}
diff --git a/example/parsar/src/lib/en.json b/example/parsar/src/lib/en.json
index 60d1823df..64ae5b2e3 100644
--- a/example/parsar/src/lib/en.json
+++ b/example/parsar/src/lib/en.json
@@ -26,7 +26,6 @@
   "提交回答": "Submit answers",
   "操作": "Operation",
   "新建 Agent": "New Agent",
-  "无需认证": "No authentication",
   "时间": "Time",
   "显示名称": "Display name",
   "未选择": "Not selected",
@@ -49,7 +48,6 @@
   "配置": "Configure",
   "飞书": "Feishu",
   "Agent 回复": "Agent response",
-  "Agent 执行中": "Agent is working",
   "Core 暂不可用": "Core is unavailable",
   "HTTPS MCP 地址": "HTTPS MCP URL",
   "MCP 地址": "MCP URL",
@@ -58,7 +56,6 @@
   "· 已选": "· Selected",
   "上传 Skill ZIP": "Upload Skill ZIP",
   "上传 Skill 新版本": "Upload Skill version",
-  "上传 ZIP": "Upload ZIP",
   "上传文件": "Upload file",
   "上传新版本": "Upload version",
   "下载失败，请重试。": "Download failed. Try again.",
@@ -123,10 +120,8 @@
   "执行方法": "Instructions",
   "执行记录": "Execution history",
   "技能名称": "Skill name",
-  "把常用方法保存为 Skill": "Save reusable methods as Skills",
   "指令": "Instructions",
   "搜索 Agent": "Search Agents",
-  "搜索 Skills": "Search Skills",
   "搜索审计": "Search audit log",
   "搜索技能": "Search Skills",
   "搜索模型": "Search models",
@@ -145,7 +140,6 @@
   "更换密钥": "Replace secret",
   "服务标识": "Server label",
   "未报告": "Not reported",
-  "机器人名称": "Bot name",
   "模型 ID": "Model ID",
   "模型连接": "Model connection",
   "次": "times",
@@ -182,7 +176,6 @@
   "输入 Token": "Input tokens",
   "输入应用密钥": "Enter app secret",
   "输出 Token": "Output tokens",
-  "运行记录": "Runs",
   "返回 Agent": "Back to Agent",
   "还没有生成的文件。": "No generated files yet.",
   "连接中": "Connecting",
@@ -200,7 +193,6 @@
   "页": "page",
   "飞书接入": "Feishu connections",
   "默认版本": "Default version",
-  "（此示例不加载外部图片）": "(external images are not loaded)",
   "界面语言": "Interface language",
   "{{value0}} 副本": "{{value0}} copy",
   "删除 Agent {{value0}}？": "Delete Agent {{value0}}?",
@@ -210,7 +202,6 @@
   "删除凭据 {{value0}}？": "Delete credential {{value0}}?",
   "编辑 Provider {{value0}}": "Edit provider {{value0}}",
   "移除 Provider {{value0}}": "Remove provider {{value0}}",
-  "移除 Provider {{value0}}？请先移除其中的模型。": "Remove provider {{value0}}? Remove its models first.",
   "编辑 {{value0}}": "Edit {{value0}}",
   "移除 {{value0}}": "Remove {{value0}}",
   "移除模型 {{value0}}？": "Remove model {{value0}}?",
@@ -253,13 +244,10 @@
   "全部 Agent": "All Agents",
   "来源": "Source",
   "全部来源": "All sources",
-  "耗时": "Duration",
-  "浏览目录": "Browse directory",
   "MCP 目录": "MCP directory",
   "搜索 MCP 目录": "Search MCP directory",
   "搜索服务": "Search services",
   "添加服务": "Add service",
-  "此服务需要认证，请绑定对应服务的凭据。": "This service requires authentication. Bind a credential for this server.",
   "技能目录暂不可用，可直接输入仓库和技能名称。": "The directory is unavailable. Enter a repository and Skill name directly.",
   "技能目录返回了无法识别的数据。": "The directory returned an unsupported response.",
   "Skills 目录": "Skills directory",
@@ -302,7 +290,6 @@
   "初始文件": "Initial files",
   "变量值": "Variable value",
   "变量名称": "Variable name",
-  "变量名称不能重复": "Variable names must be unique",
   "填写值": "Enter a value",
   "已配置": "Configured",
   "已配置，留空保留": "Configured; leave blank to keep",
@@ -318,9 +305,6 @@
   "主指令": "Main instructions",
   "指令片段": "Instruction fragments",
   "描述它负责什么、如何工作，以及输出什么结果。": "Describe its responsibilities, approach and expected results.",
-  "模型与环境": "Model and environment",
-  "工具与知识": "Tools and knowledge",
-  "选择已有资源": "Select existing resources",
   "更换选择": "Change selection",
   "查看或编辑 {{name}}": "View or edit {{name}}",
   "移除绑定 {{name}}": "Unbind {{name}}",
@@ -361,10 +345,6 @@
   "添加MCP": "Add MCP",
   "行为": "Behavior",
   "允许 Agent 向用户提问": "Let the Agent ask questions",
-  "飞书机器人变量": "Feishu bot variables",
-  "添加机器人变量": "Add bot variable",
-  "机器人变量名称": "Bot variable name",
-  "机器人字段": "Bot field",
   "飞书机器人身份": "Feishu bot identity",
   "把 Agent 接入飞书": "Bring your Agents to Feishu",
   "每个机器人对应一个 Agent，并以机器人身份工作。": "Each bot serves one Agent, which works as that bot.",
@@ -424,7 +404,6 @@
   "低": "Low",
   "高": "High",
   "网页搜索": "Web search",
-  "开启": "On",
   "关闭": "Off",
   "搜索网页": "Web search",
   "请填写名称": "Enter a name",
@@ -505,5 +484,43 @@
   "现在没有正在执行的对话": "Nothing is running right now",
   "最近完成": "Recently finished",
   "已停止": "Stopped",
-  "{{value0}} 个进行中": "{{value0}} running"
+  "{{value0}} 个进行中": "{{value0}} running",
+  "全部": "All",
+  "搜索能力": "Search capabilities",
+  "新建能力": "New capability",
+  "类型": "Type",
+  "已启用 Agent": "Enabled Agents",
+  "凭据需求": "Credentials needed",
+  "无需凭据": "None",
+  "凭据库凭据": "Vault credential",
+  "添加 HTTP MCP": "Add an HTTP MCP",
+  "从 MCP 目录添加": "Add from the MCP directory",
+  "编写 Skill": "Write a Skill",
+  "从 Skill 目录导入": "Import from the Skill directory",
+  "上传 Plugin": "Upload a Plugin",
+  "编写指令片段": "Write an instruction fragment",
+  "添加知识": "Add knowledge",
+  "需要的密钥（环境变量名，每行一个）": "Secrets it needs (variable names, one per line)",
+  "保存凭据需求": "Save credentials needed",
+  "需要凭据（由使用它的 Agent 选择）": "Needs a credential (each Agent that uses it chooses one)",
+  "删除 MCP": "Delete MCP",
+  "密钥": "Secrets",
+  "添加密钥": "Add secret",
+  "使用情况": "Used by",
+  "未使用": "Unused",
+  "更换": "Replace",
+  "删除密钥 {{value0}}": "Delete secret {{value0}}",
+  "删除密钥 {{value0}}？": "Delete secret {{value0}}?",
+  "值": "Value",
+  "留空保留已保存的值": "Leave empty to keep the saved value",
+  "MCP 凭据": "MCP credentials",
+  "{{value0}} 使用的密钥": "Secret for {{value0}}",
+  "选择密钥": "Choose a secret",
+  "{{value0}} 使用的凭据": "Credential for {{value0}}",
+  "选择凭据": "Choose a credential",
+  "先在凭据中为这个地址添加 MCP 凭据": "Add an MCP credential for this address under Credentials first",
+  "新建 {{value0}} 的密钥": "New secret for {{value0}}",
+  "由绑定的飞书机器人「{{value0}}」提供": "Provided by the bound Feishu bot {{value0}}",
+  "请先在飞书接入中给这个 Agent 绑定机器人": "Bind a bot to this Agent under Feishu first",
+  "变量名称不能重复": "Variable names must be unique"
 }
diff --git a/example/parsar/src/lib/product.ts b/example/parsar/src/lib/product.ts
index 9c9b9bc76..d3a8ad81e 100644
--- a/example/parsar/src/lib/product.ts
+++ b/example/parsar/src/lib/product.ts
@@ -16,17 +16,22 @@ export interface ModelProfile extends NamedResource {
   model: string;
 }
 export interface MCPProfile extends NamedResource {
-  vault_id?: string;
-  credential_id?: string;
   label: string;
   url: string;
+  // Each Agent that binds it chooses the Vault credential.
+  requires_credential?: boolean;
+}
+export interface Secret extends NamedResource {
+  has_value?: boolean;
+  value?: string;
 }
 export interface RuntimeProfile extends NamedResource {
   environment: "openai_hosted";
   description?: string;
   packages?: { npm?: string[]; python?: string[] };
   setup_script?: string;
-  bot_env?: Record<string, string>;
+  // Variables the Agent supplies: the bound bot's identity or chosen secrets.
+  credentials?: string[];
   env?: Record<string, string | null>;
   prepare?: boolean;
   files?: { path: string; content: string }[];
@@ -49,6 +54,10 @@ export interface AgentProfile extends NamedResource {
   skill_ids: string[];
   skill_versions?: Record<string, string>;
   mcp_ids: string[];
+  // The secret that supplies each variable a bound capability needs.
+  credentials?: Record<string, string>;
+  // The Vault credential each bound MCP that needs one uses.
+  mcp_credentials?: Record<string, { vault_id: string; credential_id: string }>;
 }
 export interface TurnSummary {
   outcome: "running" | "completed" | "failed" | "cancelled";
@@ -140,6 +149,13 @@ export const useResources = <T>(kind: string) =>
 export const useProviders = () => useResources<ProviderProfile>("providers");
 export const useModels = () => useResources<ModelProfile>("models");
 export const useAgents = () => useResources<AgentProfile>("agents");
+export const useSecrets = () => useResources<Secret>("secrets");
+// The variables each Skill needs; Skills themselves live in Core.
+export const useSkillCredentials = () =>
+  useQuery({
+    queryKey: ["skill-credentials"],
+    queryFn: () => product<{ id: string; credentials: string[] }[]>("skills/credentials"),
+  });
 // Running and recent Turns; the sidebar count and the 运行 view share it.
 export const useTurnOverview = () =>
   useQuery({
diff --git a/example/parsar/src/lib/usage.ts b/example/parsar/src/lib/usage.ts
index a3a3e9b00..7a429f507 100644
--- a/example/parsar/src/lib/usage.ts
+++ b/example/parsar/src/lib/usage.ts
@@ -1,10 +1,9 @@
 import { tr } from "./i18n";
-import { useAgents, useMCPs } from "./product";
+import { useAgents } from "./product";
 
 // Who uses a building block, so lists can show it and block removal up front.
 export function useUsage() {
-  const agents = useAgents().data || [],
-    mcps = useMCPs().data || [];
+  const agents = useAgents().data || [];
   const count = (n: number, unit: string) =>
     n ? tr("被 {{count}} 个{{unit}}使用", { count: n, unit }) : "";
   return {
@@ -22,6 +21,16 @@ export function useUsage() {
         "Agent",
       ),
     credential: (id: string) =>
-      count(mcps.filter((row) => row.credential_id === id).length, "MCP"),
+      count(
+        agents.filter((row) =>
+          Object.values(row.mcp_credentials || {}).some((choice) => choice.credential_id === id),
+        ).length,
+        "Agent",
+      ),
+    secret: (id: string) =>
+      count(
+        agents.filter((row) => Object.values(row.credentials || {}).includes(id)).length,
+        "Agent",
+      ),
   };
 }
diff --git a/example/parsar/tests/feishu.test.mjs b/example/parsar/tests/feishu.test.mjs
index 8b191195c..96381d0be 100644
--- a/example/parsar/tests/feishu.test.mjs
+++ b/example/parsar/tests/feishu.test.mjs
@@ -2052,3 +2052,17 @@ test("no Markdown image reaches a card, since Feishu rejects the whole card for
   assert.match(done, /user_code=AB-12/, "the link the Agent gave stays in the answer");
   assert.match(done, /授权二维码见图片消息/);
 });
+
+test("a bot takes the name its app has in Feishu when it connects", async (t) => {
+  const f = await feishu(t);
+  f.channel.connect = async function () {
+    this.name = "OddjobHandler";
+  };
+  const worker = f.create();
+  await worker.tick();
+  const bot = f.store.get("feishu_bots", botId);
+  assert.equal(bot.name, "OddjobHandler");
+  // Saving the bot again keeps the name Feishu gave it.
+  const saved = await f.api("PUT", `/app/feishu/bots/${botId}`, { ...bot, name: "Something else" });
+  assert.equal(saved.name, "OddjobHandler");
+});
diff --git a/example/parsar/tests/product.test.mjs b/example/parsar/tests/product.test.mjs
index beb8243c5..6e182beb2 100644
--- a/example/parsar/tests/product.test.mjs
+++ b/example/parsar/tests/product.test.mjs
@@ -94,8 +94,8 @@ test("environment templates prepare hosted Sessions, protect variables and freez
     { env: { PATH: "x" } },
     { env: { OAC_KEY: "x" } },
     { env: { NEW: null } },
-    { bot_env: { TOKEN: "access_token" } },
-    { env: { A: "x" }, bot_env: { A: "app_id" } },
+    { credentials: ["PATH"] },
+    { credentials: "FEISHU_APP_ID" },
     { files: [{ path: "/workspace/../outside", content: "x" }] },
     {
       files: [
@@ -674,25 +674,23 @@ test("model availability and pricing remain product-owned and freeze with a Sess
   );
 });
 
-test("the Agent's bound Feishu bot supplies mapped identity variables without exposing the secret", async (t) => {
+test("a bound Feishu bot's identity reaches every conversation, and what declares it needs a bot", async (t) => {
   const store = openStore(":memory:");
   t.after(() => store.close());
   const calls = [];
-  const { api, put, core, agent, input } = await setup(store, async (_p, _m, body) => {
+  const { api, put, core, agent, runtime: setupRuntime, input } = await setup(store, async (_p, _m, body) => {
     calls.push(body);
     return { id: randomUUID() };
   });
   const runtime = await put("runtimes", {
     name: "Feishu",
     env: { LARKSUITE_CLI_DEFAULT_AS: "bot" },
-    bot_env: {
-      FEISHU_APP_ID: "app_id",
-      FEISHU_APP_SECRET: "app_secret",
-      FEISHU_BRAND: "brand",
-    },
+    credentials: ["FEISHU_APP_ID", "FEISHU_APP_SECRET"],
   });
-  await put("agents", { ...agent, runtime_id: runtime.id }, agent.id);
-  await assert.rejects(put("sessions", input), /飞书机器人身份/);
+  // A template that declares the bot's identity needs an Agent with a bot.
+  await assert.rejects(put("agents", { ...agent, runtime_id: runtime.id }, agent.id), /需要飞书机器人身份/);
+  store.put("agents", { ...store.get("agents", agent.id), runtime_id: runtime.id });
+  await assert.rejects(put("sessions", input), /需要飞书机器人身份/);
   const botId = randomUUID();
   await api("PUT", `/app/feishu/bots/${botId}`, {
     revision: 0,
@@ -716,14 +714,19 @@ test("the Agent's bound Feishu bot supplies mapped identity variables without ex
     /已绑定另一个机器人/,
   );
   const record = await put("sessions", input);
-  // The Template keeps its own variables; each Session adds the bot's identity on top.
+  // The Template keeps its own variables; each Session adds the bound bot's identity on top.
   assert.deepEqual(calls.at(-1).environment.env, {
     FEISHU_APP_ID: "cli_0123456789abcdef",
     FEISHU_APP_SECRET: "bot-secret",
     FEISHU_BRAND: "lark",
   });
   assert.deepEqual(core.saved.get(calls.at(-1).environment.environment_template_id).env, { LARKSUITE_CLI_DEFAULT_AS: "bot" });
-  assert.equal(record.configuration.bot_name, "Assistant");
+  // Until the bot first connects, Feishu has not told Parsar its name.
+  assert.equal(record.configuration.bot_name, "cli_0123456789abcdef");
+  // Binding is enough: a template that declares nothing gets the identity too.
+  store.put("agents", { ...store.get("agents", agent.id), runtime_id: setupRuntime.id });
+  await put("sessions", { ...input, name: "Plain" });
+  assert.equal(calls.at(-1).environment.env.FEISHU_APP_SECRET, "bot-secret");
   assert.ok(record.configuration.env_names.includes("FEISHU_APP_SECRET"));
   assert.ok(!JSON.stringify(await api("GET", "/app/sessions")).includes("bot-secret"));
   assert.ok(!JSON.stringify(await api("GET", "/app/runtimes")).includes("bot-secret"));
@@ -1211,3 +1214,57 @@ test("only live configuration blocks deletion; conversations keep their snapshot
   assert.ok((await api("GET", "/app/sessions")).some((row) => row.id === conversation.id));
   assert.equal(calls.some((call) => call.method === "DELETE" && call.path.includes("/sessions/")), false, "its Core Session and messages stay");
 });
+
+test("capabilities declare the credentials they need and each Agent chooses where they come from", async (t) => {
+  const store = openStore(":memory:");
+  t.after(() => store.close());
+  const sent = [];
+  const { api, put, core, agent, input } = await setup(store, async (_path, _method, body) => {
+    sent.push(body);
+    return { id: randomUUID() };
+  });
+  // Secrets keep their values out of every read.
+  const token = await put("secrets", { name: "GitHub token", value: "ghp_private" });
+  assert.equal(token.has_value, true);
+  assert.ok(!JSON.stringify(await api("GET", "/app/secrets")).includes("ghp_private"));
+  const renamed = await put("secrets", { ...token, name: "GitHub" }, token.id);
+  assert.equal(store.get("secrets", token.id).value, "ghp_private", "omitting the value keeps it");
+
+  // A Plugin and a Skill need variables; an MCP needs a Vault credential.
+  const plugin = randomUUID();
+  store.put("capabilities", { id: plugin, kind: "plugin", name: "Git tools", credentials: ["GITHUB_TOKEN"], default_version: "1", versions: [{ version: "1", archive: "UEsFBgAAAAAAAAAAAAAAAAAAAAAAAA==" }], revision: 1 });
+  await api("PUT", "/app/skills/skill_review/credentials", { credentials: ["REVIEW_KEY"] });
+  const mcpId = store.get("agents", agent.id).mcp_ids[0];
+  await put("mcps", { ...store.get("mcps", mcpId), requires_credential: true }, mcpId);
+  const base = { ...store.get("agents", agent.id), capability_ids: [plugin] };
+  await assert.rejects(put("agents", base, agent.id), /选择密钥/);
+  const review = await put("secrets", { name: "Review", value: "review-private" });
+  const vault = randomUUID(), credential = randomUUID();
+  await assert.rejects(
+    put("agents", { ...base, credentials: { GITHUB_TOKEN: token.id, REVIEW_KEY: review.id } }, agent.id),
+    /为 MCP「Docs」选择凭据/,
+  );
+  await put("agents", {
+    ...base,
+    credentials: { GITHUB_TOKEN: renamed.id, REVIEW_KEY: review.id },
+    mcp_credentials: { [mcpId]: { vault_id: vault, credential_id: credential } },
+  }, agent.id);
+
+  // Values reach each Session's variables, never the saved Agent; the MCP uses the chosen credential.
+  await put("sessions", input);
+  const request = sent.at(-1);
+  assert.deepEqual(request.environment.env, { GITHUB_TOKEN: "ghp_private", REVIEW_KEY: "review-private" });
+  assert.deepEqual(request.vault_ids, [vault]);
+  const saved = core.agentOf(request);
+  assert.equal(saved.tools.find((tool) => tool.type === "mcp").credential_id, credential);
+  assert.ok(!JSON.stringify(saved).includes("ghp_private"));
+  assert.ok(!JSON.stringify(await api("GET", "/app/agents")).includes("ghp_private"));
+
+  // A secret an Agent uses stays until the Agent stops using it.
+  await assert.rejects(api("DELETE", `/app/secrets/${token.id}`), /仍被引用/);
+  const unbound = await put("agents", { ...store.get("agents", agent.id), capability_ids: [] }, agent.id);
+  assert.deepEqual(Object.keys(unbound.credentials), ["REVIEW_KEY"], "a choice nothing needs is dropped");
+  await api("DELETE", `/app/secrets/${token.id}`, {});
+  for (const body of [{ credentials: ["PATH"] }, { credentials: ["bad name"] }])
+    await assert.rejects(api("PUT", "/app/skills/skill_review/credentials", body), (error) => error.status === 400);
+});
diff --git a/example/parsar/tests/workflow.spec.ts b/example/parsar/tests/workflow.spec.ts
index 22253900b..006ba7610 100644
--- a/example/parsar/tests/workflow.spec.ts
+++ b/example/parsar/tests/workflow.spec.ts
@@ -1,7 +1,7 @@
 import { test, expect, type Page } from "@playwright/test";
 const appOrigin = `http://127.0.0.1:${process.env.OAC_EXAMPLE_PORT || "18180"}`;
 async function navigate(page: Page, name: string) {
-  if (["Skills", "MCP", "模型", "凭据"].includes(name)) {
+  if (["能力", "模型", "凭据"].includes(name)) {
     await page.getByRole("link", { name: "资源库", exact: true }).click();
     await page.getByRole("tab", { name, exact: true }).click();
   } else
@@ -41,15 +41,13 @@ async function resources(page: Page) {
   await page.getByLabel("名称", { exact: true }).fill("开发沙箱");
   await page.getByRole("button", { name: "保存", exact: true }).click();
   await expect(page.getByRole("dialog")).toHaveCount(0);
-  await navigate(page, "MCP");
-  await page.getByRole("button", { name: "添加MCP" }).click();
+  await addCapability(page, "添加 HTTP MCP");
   await page.getByLabel("名称", { exact: true }).fill("文档服务");
   await page.getByLabel("服务标识").fill("docs");
   await page.getByLabel("MCP 地址").fill("https://mcp.example/docs");
   await page.getByRole("button", { name: "保存", exact: true }).click();
   await expect(page.getByRole("dialog")).toHaveCount(0);
-  await navigate(page, "Skills");
-  await page.getByRole("button", { name: "创建 Skill" }).click();
+  await addCapability(page, "编写 Skill");
   await page.getByLabel("技能名称").fill("code-review");
   await page.getByLabel("用途").fill("检查代码质量");
   await page
@@ -58,6 +56,12 @@ async function resources(page: Page) {
   await page.getByRole("button", { name: "保存", exact: true }).click();
   await expect(page.getByRole("dialog")).toHaveCount(0);
 }
+// The library has one entry for every kind of capability.
+async function addCapability(page: Page, choice: string) {
+  await navigate(page, "能力");
+  await page.getByRole("button", { name: "新建能力", exact: true }).click();
+  await page.getByRole("button", { name: choice, exact: true }).click();
+}
 async function agent(page: Page, name = "审查助手") {
   await page.goto("/#/agents/new");
   await page.getByLabel("名称", { exact: true }).fill(name);
@@ -143,10 +147,7 @@ test("environment template edits preparation and hides saved variable values", a
   await page.getByRole("button", { name: "添加变量" }).click();
   await page.getByLabel("变量名称").fill("OFFICE_TOKEN");
   await page.getByLabel("变量值").fill("private-fixture-token");
-  await page.getByRole("button", { name: "添加机器人变量" }).click();
-  await page.getByLabel("机器人变量名称").fill("FEISHU_APP_SECRET");
-  await page.getByLabel("机器人字段").click();
-  await page.getByRole("option", { name: "App Secret", exact: true }).click();
+  await page.getByLabel("需要的密钥（环境变量名，每行一个）").fill("FEISHU_APP_SECRET");
   await page.getByRole("button", { name: "添加文件", exact: true }).click();
   await page.getByLabel("文件路径").fill("/workspace/settings.txt");
   await page.getByLabel("文件内容").fill("office=true");
@@ -177,7 +178,7 @@ test("environment template edits preparation and hides saved variable values", a
     (row: { name: string }) => row.name === "飞书办公",
   );
   expect(template.env).toEqual({ OFFICE_TOKEN: null });
-  expect(template.bot_env).toEqual({ FEISHU_APP_SECRET: "app_secret" });
+  expect(template.credentials).toEqual(["FEISHU_APP_SECRET"]);
   expect(template.files).toEqual([
     { path: "/workspace/settings.txt", content: "office=true" },
   ]);
@@ -203,7 +204,7 @@ test("model edits persist and bound resources cannot be removed", async ({
 
 test("Skill version upload and default selection", async ({ page }) => {
   await resources(page);
-  await page.getByRole("button", { name: /code-review v1/ }).click();
+  await page.getByRole("button", { name: "编辑 code-review", exact: true }).click();
   await page.getByRole("button", { name: "查看文件", exact: true }).click();
   await expect(
     page.getByText("Inspect changed files and report actionable issues.", {
@@ -748,12 +749,12 @@ test("a Feishu bot binds one Agent, which then shows the bot as its identity", a
   const id = await agent(page);
   await navigate(page, "飞书");
   await page.getByRole("button", { name: "使用已有应用" }).click();
-  await page.getByLabel("机器人名称").fill("工作助手");
   await page.getByLabel("App ID").fill("cli_0123456789abcdef");
   await page.getByLabel("App Secret").fill("fixture-bot-secret");
   await page.getByRole("button", { name: "添加", exact: true }).click();
   await expect(page.getByRole("dialog")).toHaveCount(0);
-  const card = page.getByRole("region", { name: "工作助手" });
+  // Feishu supplies the bot's name when it connects; until then it shows the App ID.
+  const card = page.getByRole("region", { name: "cli_0123456789abcdef" });
   await card.getByLabel("Agent", { exact: true }).click();
   await page.getByRole("option", { name: "审查助手", exact: true }).click();
   await card.getByRole("switch", { name: "私聊" }).check({ force: true });
@@ -771,9 +772,9 @@ test("a Feishu bot binds one Agent, which then shows the bot as its identity", a
   expect(JSON.stringify(bot)).not.toContain("fixture-bot-secret");
   await page.screenshot({ path: testInfo.outputPath("feishu.png") });
   await page.goto(`/#/agents/${id}`);
-  await expect(page.getByText("工作助手", { exact: true })).toBeVisible();
+  await expect(page.getByText("cli_0123456789abcdef", { exact: true }).first()).toBeVisible();
   await page.getByRole("link", { name: "Agent", exact: true }).click();
-  await expect(page.getByText("工作助手", { exact: true })).toBeVisible();
+  await expect(page.getByText("cli_0123456789abcdef", { exact: true }).first()).toBeVisible();
 });
 
 test("workspace settings retain the name and switch the complete navigation between languages", async ({
@@ -1082,3 +1083,37 @@ test("an environment trial reports its result on the button, without extra statu
   await expect(trial).toHaveText("可用", { timeout: 30000 });
   await expect(page.getByText(/首次回复|可用 ·/)).toHaveCount(0);
 });
+
+test("the library lists every capability with its enabled Agents and credentials, and Agents choose the secrets", async ({ page }) => {
+  await resources(page);
+  const agentId = await agent(page);
+  await navigate(page, "能力");
+  // A Skill declares the variable it needs.
+  await page.getByRole("button", { name: "编辑 code-review", exact: true }).click();
+  await page.getByLabel("需要的密钥（环境变量名，每行一个）").fill("REVIEW_KEY");
+  await page.getByRole("button", { name: "保存凭据需求", exact: true }).click();
+  await expect(page.getByRole("button", { name: "保存凭据需求" })).toHaveCount(0);
+  await page.keyboard.press("Escape");
+  // Every kind is one list; filters narrow it.
+  const rowOf = (name: string) => page.getByRole("button", { name: `编辑 ${name}`, exact: true }).locator("..");
+  const row = rowOf("code-review");
+  await expect(row).toContainText("Skill");
+  await expect(row).toContainText("REVIEW_KEY");
+  await expect(row).toContainText("1");
+  await expect(rowOf("文档服务")).toContainText("无需凭据");
+  await page.getByRole("tab", { name: "MCP", exact: true }).click();
+  await expect(rowOf("code-review")).toHaveCount(0);
+  // The Agent supplies the variable from a secret it creates in place.
+  await page.goto(`/#/agents/${agentId}`);
+  const choice = page.getByLabel("REVIEW_KEY 使用的密钥");
+  await page.getByRole("button", { name: "新建 REVIEW_KEY 的密钥" }).click();
+  await expect(page.getByLabel("名称", { exact: true }).last()).toHaveValue("REVIEW_KEY");
+  await page.getByLabel("值", { exact: true }).fill("review-secret");
+  await page.getByRole("dialog").getByRole("button", { name: "保存", exact: true }).click();
+  await expect(choice).toContainText("REVIEW_KEY");
+  await page.getByRole("button", { name: "保存", exact: true }).click();
+  await expect(page.getByRole("button", { name: "已保存" })).toBeVisible();
+  await navigate(page, "凭据");
+  await expect(page.getByRole("button", { name: "删除密钥 REVIEW_KEY" }).locator("../..")).toContainText("被 1 个Agent使用");
+  await expect(page.getByText("review-secret")).toHaveCount(0);
+});

From 998ce5b201015ac3f3d903f2c031287952640949 Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Mon, 26 Oct 2026 15:33:28 +0800
Subject: [PATCH 08/19] Count a message sent during a running Turn as part of
 that Turn
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Core folds a message sent while a Turn runs into that Turn, but Parsar's
ledger recorded every message as a Turn of its own. 运行 then showed two
running rows for one task, and Feishu opened a second progress card while
the first one stopped updating.

A message that arrives while the conversation's Turn is still running in
Core is now recorded on that Turn and resent with it if the Turn is
retried. Feishu keeps the running Turn's card instead of opening another.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/README.md              |  2 +-
 example/parsar/README.zh.md           |  4 +--
 example/parsar/server/feishu.mjs      |  6 +++--
 example/parsar/server/turns.mjs       | 28 +++++++++++++++-----
 example/parsar/tests/feishu.test.mjs  | 33 ++++++++++++++++++++++--
 example/parsar/tests/product.test.mjs | 37 ++++++++++++++++++++++++++-
 6 files changed, 95 insertions(+), 15 deletions(-)

diff --git a/example/parsar/README.md b/example/parsar/README.md
index 1f789952f..a16ee2148 100644
--- a/example/parsar/README.md
+++ b/example/parsar/README.md
@@ -86,7 +86,7 @@ Quick Tunnel URLs last only for that tunnel process and may change after restart
 
 **新对话** opens the home page: choose an Agent, describe the work and send. The sidebar lists recent conversations; **全部对话** opens the full list with search, Agent, source and date filters, plus **运行**, **用量** and **审计日志**. **运行** also sits directly under **新对话** with the number of running conversations. It lists every running turn from Web and Feishu with its stage, waiting time and the Agent's usual first-reply time, and the recently finished ones with their duration, automatic recoveries and plain-language failures; it also shows how many conversations are running, waiting for an answer or failed in the last five minutes. Running turns can be stopped and the latest failed turn of a conversation retried there. Date filters use the browser’s local dates. Usage totals cover all matching records; missing usage remains unknown. Optional model prices are USD per million input/output tokens, frozen when a conversation starts; costs are estimates, not provider bills.
 
-A conversation streams replies and tool activity, groups work steps, navigates user turns with the turn rail, supports follow-ups and cancellation and reopens durable history. Messages sent while the Agent is working reach the running task; answer business questions on their card. Enter sends; Shift+Enter adds a line. Drafts survive reloads in the same browser tab. The folder button uploads inputs up to 5 MiB while idle, inserts their path into the draft and downloads Artifacts after the live workspace is gone; ask the Agent to save deliverables under `./outputs`. The info button shows the Agent, model, Harness, environment template, Feishu identity, source and the configuration recorded at creation, without variable values, script contents or credentials. When a creation response is lost, the conversation page offers **恢复创建**, which reuses the frozen request and idempotency key.
+A conversation streams replies and tool activity, groups work steps, navigates user turns with the turn rail, supports follow-ups and cancellation and reopens durable history. Messages sent while the Agent is working, from Web or Feishu, join the running task: **运行** shows it once, and in Feishu it keeps its progress card. Answer business questions on their card. Enter sends; Shift+Enter adds a line. Drafts survive reloads in the same browser tab. The folder button uploads inputs up to 5 MiB while idle, inserts their path into the draft and downloads Artifacts after the live workspace is gone; ask the Agent to save deliverables under `./outputs`. The info button shows the Agent, model, Harness, environment template, Feishu identity, source and the configuration recorded at creation, without variable values, script contents or credentials. When a creation response is lost, the conversation page offers **恢复创建**, which reuses the frozen request and idempotency key.
 
 To show thinking, set the Agent’s **高级 → 推理摘要** to `auto` and start a new conversation. When the Harness emits a native summary, **思考过程** appears directly in the conversation, separate from tool steps. While thinking is in progress it shows the latest text; after completion it defaults to a single row. Click to read the full summary, which is restored from history after reconnection. Existing conversations keep the configuration recorded at creation; enabling summaries does not add thinking to old history.
 
diff --git a/example/parsar/README.zh.md b/example/parsar/README.zh.md
index c3b3331ed..7c73d8862 100644
--- a/example/parsar/README.zh.md
+++ b/example/parsar/README.zh.md
@@ -1,6 +1,6 @@
 ---
 source: example/parsar/README.md
-source_hash: bf6d042037c030463b3ad1723b7d8789edd471c4f1f3b96ef3f11843ca6fa158
+source_hash: 952864302053048e8618fa5e4760b46d789b195d27450ec6b63d73f4fbb4badb
 ---
 
 # Parsar 工作空间
@@ -91,7 +91,7 @@ Quick Tunnel 地址只在该隧道进程运行期间有效，重启可能换地
 
 **新对话** 打开首页：选择 Agent、描述工作并发送。侧栏列出最近对话；**全部对话** 打开完整列表，支持搜索以及按 Agent、来源和日期筛选，并提供 **运行**、**用量** 和 **审计日志**。**运行** 也直接放在 **新对话** 下方，并显示正在进行的对话数。它列出网页和飞书中每一轮正在执行的对话，显示所处阶段、已等待时间和这个 Agent 通常的首次回复时间；也列出最近完成的轮次，显示用时、自动恢复次数和通俗的失败原因，并统计正在进行、等你回复和近 5 分钟失败的数量。可以在这里停止正在执行的轮次，或重试对话中最近失败的一轮。日期筛选按浏览器本地日期计算；用量汇总覆盖所有匹配记录，缺失用量保持未知。模型可配置每百万输入/输出 Token 的美元价格，在对话开始时冻结；费用为估算，不是服务商账单。
 
-对话会流式展示回复和工具活动，归组工作步骤，可用对话导航条跳转用户轮次，支持追问和取消，并可重新打开持久历史。Agent 执行中发送的消息会进入正在运行的任务；业务提问请在提问卡片上回答。Enter 发送，Shift+Enter 换行。草稿在同一浏览器标签页中刷新后保留。文件夹按钮可在空闲时上传最大 5 MiB 的输入文件，并把路径插入草稿；实时工作区回收后仍可下载 Artifacts，请让 Agent 将交付物保存到 `./outputs`。信息按钮展示 Agent、模型、Harness、环境模板、飞书身份、来源以及创建时记录的配置，不含变量值、脚本内容或凭据。创建响应丢失时，对话页提供 **恢复创建**，复用冻结的请求和幂等键。
+对话会流式展示回复和工具活动，归组工作步骤，可用对话导航条跳转用户轮次，支持追问和取消，并可重新打开持久历史。Agent 执行中发送的消息（网页和飞书都一样）会并入正在运行的任务：**运行** 里只显示这一轮，飞书里沿用这一轮的进度卡片。业务提问请在提问卡片上回答。Enter 发送，Shift+Enter 换行。草稿在同一浏览器标签页中刷新后保留。文件夹按钮可在空闲时上传最大 5 MiB 的输入文件，并把路径插入草稿；实时工作区回收后仍可下载 Artifacts，请让 Agent 将交付物保存到 `./outputs`。信息按钮展示 Agent、模型、Harness、环境模板、飞书身份、来源以及创建时记录的配置，不含变量值、脚本内容或凭据。创建响应丢失时，对话页提供 **恢复创建**，复用冻结的请求和幂等键。
 
 如需展示 thinking，将 Agent 的 **高级 → 推理摘要** 设为 `auto`，再新建对话。Harness 返回原生摘要时，**思考过程** 会直接出现在对话中，与工具步骤分开。生成时显示最新片段，结束后默认收成一行；点击可阅读完整摘要，断线后从历史恢复。已有对话保留创建时的配置；开启摘要不会为旧历史补出思考内容。
 
diff --git a/example/parsar/server/feishu.mjs b/example/parsar/server/feishu.mjs
index 8b3c3ec94..ecc5fa6aa 100644
--- a/example/parsar/server/feishu.mjs
+++ b/example/parsar/server/feishu.mjs
@@ -1049,6 +1049,7 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
           row,
           "支持的命令：/clear、/stop、/answer、/help。其他消息会交给 Agent。",
         );
+      let steered = false;
       try {
         if (
           media.files.length &&
@@ -1133,7 +1134,7 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
         store.put("feishu_inbound", row);
         // Messages go through the Turn ledger; answers and cancellations go to Core directly.
         if (event.type === "agent.session.input.message")
-          await ledger.deliver(run, event.input, { id: row.id, key: row.id, source: "feishu" });
+          steered = (await ledger.deliver(run, event.input, { id: row.id, key: row.id, source: "feishu" })).id !== row.id;
         else
           await core(
             `/v1/agents/sessions/${run.core_session_id}/events`,
@@ -1166,7 +1167,8 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
           thread,
           "已请求取消，等待 Agent 确认停止。",
         );
-      else progress(thinking);
+      // A message that steered the running Turn keeps that Turn's card.
+      else if (!steered) progress(thinking);
     }
     store.put("feishu_inbound", {
       ...row,
diff --git a/example/parsar/server/turns.mjs b/example/parsar/server/turns.mjs
index 6c864f5ce..ed0f9bf7e 100644
--- a/example/parsar/server/turns.mjs
+++ b/example/parsar/server/turns.mjs
@@ -91,15 +91,27 @@ export function turnsAPI(store, core) {
   };
 
   // Records and sends a follow-up input. The entry is written first so a
-  // retried send (same id and key) keeps its original baseline.
+  // retried send (same id and key) keeps its original baseline. A message sent
+  // while this conversation's Turn runs steers that Turn, as in Core, and is
+  // recorded on it instead of as a Turn of its own. Returns the Turn it is part of.
   const deliver = async (record, input, { id, key, source }) => {
-    const turn =
-      store.get("turns", id) ||
-      start(record, { id, kind: "followup", input, source, base: await baseline(record.core_session_id) });
+    let turn = store.get("turns", id) || store.list("turns").find((t) => t.steers?.some((steer) => steer.id === id));
+    if (!turn) {
+      const base = await baseline(record.core_session_id);
+      const running = base.base_running &&
+        store.list("turns").find((t) => t.session_id === record.id && t.outcome === "running" && (!t.core_turn_id || t.core_turn_id === base.base_turn_id));
+      turn = running
+        ? { ...running, steers: [...(running.steers || []), { id, input: asInput(input) }] }
+        : start(record, { id, kind: "followup", input, source, base });
+      store.put("turns", turn);
+    }
+    const steer = turn.steers?.find((entry) => entry.id === id);
     try {
-      await post(record.core_session_id, message(turn.input), key);
+      await post(record.core_session_id, message(steer ? steer.input : turn.input), key);
     } catch (error) {
-      if (error instanceof AppError && error.status >= 400 && error.status < 500) store.remove("turns", id);
+      if (error instanceof AppError && error.status >= 400 && error.status < 500)
+        if (steer) store.put("turns", { ...store.get("turns", turn.id), steers: turn.steers.filter((entry) => entry.id !== id) });
+        else store.remove("turns", id);
       throw error;
     }
     return turn;
@@ -169,7 +181,9 @@ export function turnsAPI(store, core) {
       ...record,
       superseded_turns: [...new Set([...(record.superseded_turns || []), coreTurnId])],
     });
-    await post(record.core_session_id, message(turn.input), `${turn.id}:resend:${retries}`);
+    // Messages that steered the Turn go with it again.
+    const input = [...asInput(turn.input), ...(turn.steers || []).flatMap((steer) => steer.input)];
+    await post(record.core_session_id, message(input), `${turn.id}:resend:${retries}`);
     store.put("turns", { ...turn, retries, stage: "retrying", pending_cancel: undefined, core_turn_id: undefined });
   };
 
diff --git a/example/parsar/tests/feishu.test.mjs b/example/parsar/tests/feishu.test.mjs
index 96381d0be..1724708d9 100644
--- a/example/parsar/tests/feishu.test.mjs
+++ b/example/parsar/tests/feishu.test.mjs
@@ -1815,10 +1815,11 @@ test("ordinary follow-ups exclude old content while Core publishes a delayed inp
   const items = [{ id: "old", turn_id: "same-turn", type: "message", role: "assistant", content: [{ type: "output_text", text: "OLD EXCHANGE" }] }];
   const patches = [];
   f.channel.rawClient.im.message.patch = async (payload) => { patches.push(payload); return { code: 0 }; };
+  // The earlier Turn has ended, so each follow-up starts a Turn of its own.
   const core = async (path, method, ...rest) => {
-    if (method === "GET" && path.includes("/turns")) return { data: [{ id: "same-turn", status: "in_progress" }], has_more: false };
+    if (method === "GET" && path.includes("/turns")) return { data: [{ id: "same-turn", status: "completed" }], has_more: false };
     if (method === "GET" && path.includes("/items")) return { data: items, has_more: false };
-    if (method === "GET" && /^\/v1\/agents\/sessions\/[^/]+$/.test(path)) return { id: path.split("/")[4], status: "in_progress" };
+    if (method === "GET" && /^\/v1\/agents\/sessions\/[^/]+$/.test(path)) return { id: path.split("/")[4], status: "idle" };
     return f.core(path, method, ...rest);
   };
   let worker = feishuWorker(f.store, core, f.api, async () => f.channel);
@@ -2066,3 +2067,31 @@ test("a bot takes the name its app has in Feishu when it connects", async (t) =>
   const saved = await f.api("PUT", `/app/feishu/bots/${botId}`, { ...bot, name: "Something else" });
   assert.equal(saved.name, "OddjobHandler");
 });
+
+test("a message sent while the Turn runs steers it and keeps that Turn's card", async (t) => {
+  const f = await feishu(t);
+  const config = await f.api("GET", `/app/feishu/bots/${botId}`);
+  await f.api("PUT", `/app/feishu/bots/${botId}`, { ...config, direct: true });
+  const items = [];
+  const posted = [];
+  const core = async (path, method, body, ...rest) => {
+    if (method === "GET" && path.includes("/turns")) return { data: [{ id: "running-turn", status: "in_progress" }], has_more: false };
+    if (method === "GET" && path.includes("/items")) return { data: items, has_more: false };
+    if (method === "GET" && /^\/v1\/agents\/sessions\/[^/]+$/.test(path)) return { id: path.split("/")[4], status: "in_progress" };
+    if (method === "POST" && path.endsWith("/events")) posted.push(body.events[0]);
+    return f.core(path, method, body, ...rest);
+  };
+  const worker = feishuWorker(f.store, core, f.api, async () => f.channel);
+  const dm = { ...f.message, chatType: "p2p", mentionedBot: false };
+  worker.receive("cli_0123456789abcdef", dm);
+  await worker.tick();
+  assert.equal(f.sent.length, 1);
+  worker.receive("cli_0123456789abcdef", { ...dm, messageId: "steer", content: "我明天要去开发者大会" });
+  await worker.tick();
+  // The steer reaches the running Turn, gets no card of its own and adds no Turn.
+  assert.ok(posted.some((event) => event.type === "agent.session.input.message" && JSON.stringify(event.input).includes("开发者大会")));
+  assert.equal(f.sent.length, 1);
+  assert.equal(f.store.list("turns").length, 1);
+  assert.equal(f.store.list("turns")[0].steers.length, 1);
+  assert.equal(f.store.list("feishu_inbound").find((row) => row.message_id === "steer").state, "delivered");
+});
diff --git a/example/parsar/tests/product.test.mjs b/example/parsar/tests/product.test.mjs
index 6e182beb2..ebac86a2f 100644
--- a/example/parsar/tests/product.test.mjs
+++ b/example/parsar/tests/product.test.mjs
@@ -943,7 +943,12 @@ function scriptedCore(plan) {
         const running = session.turns.find((t) => t.status === "in_progress");
         if (running) running.status = "cancelled";
         session.status = "idle";
-      } else addTurn(session, event.input);
+      } else {
+        // As in Core, a message sent while a Turn runs steers that Turn.
+        const running = session.turns.find((t) => t.status === "in_progress");
+        if (running) session.items.push({ id: randomUUID(), type: "message", role: "user", turn_id: running.id, content: event.input?.[0]?.content || [] });
+        else addTurn(session, event.input);
+      }
       return {};
     }
     throw new Error(`unexpected ${method} ${path}`);
@@ -1268,3 +1273,33 @@ test("capabilities declare the credentials they need and each Agent chooses wher
   for (const body of [{ credentials: ["PATH"] }, { credentials: ["bad name"] }])
     await assert.rejects(api("PUT", "/app/skills/skill_review/credentials", body), (error) => error.status === 400);
 });
+
+test("a message sent while a Turn runs steers it: one running Turn, resent together", async (t) => {
+  const store = openStore(":memory:");
+  t.after(() => store.close());
+  const plan = { environments: [], turns: ["run", "run"] };
+  const fake = scriptedCore(plan);
+  const { api, put, input } = await setup(store, fake.core);
+  const turns = api.sessions.turns;
+  const id = randomUUID();
+  await put("sessions", input, id);
+  await turns.monitor();
+  const first = turns.overview().running;
+  assert.equal(first.length, 1);
+  // The steer joins the running Turn instead of becoming a second one.
+  const steered = await turns.send(id, { text: "我明天要去开发者大会", key: "steer-1" });
+  assert.equal(steered.id, first[0].id);
+  await turns.send(id, { text: "我明天要去开发者大会", key: "steer-1" });
+  assert.equal(store.get("turns", first[0].id).steers.length, 1, "a retried steer is recorded once");
+  await turns.monitor();
+  assert.equal(turns.overview().running.length, 1);
+  assert.equal(store.list("turns").length, 1);
+  // A message after the Turn ended starts a Turn of its own.
+  const session = fake.sessions.get(store.get("sessions", id).core_session_id);
+  session.turns[0].status = "completed";
+  session.status = "idle";
+  await turns.monitor();
+  const next = await turns.send(id, { text: "再来一个", key: "next" });
+  assert.notEqual(next.id, first[0].id);
+  assert.equal(store.list("turns").length, 2);
+});

From caa3d77b339a966f1fdba85f2151ddd7f986446a Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Mon, 26 Oct 2026 16:11:34 +0800
Subject: [PATCH 09/19] Request im:message.group_msg when a bot is created by
 scanning

A bot created by scanning lacked the "read all group messages" scope, so
it never received topic replies that did not mention it. The QR code now
carries the official SDKs' addons parameter, so the confirmation page after
scanning requests im:message.group_msg on top of the default template, and
pre-fills the app name entered in Parsar.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/README.md                      | 4 ++--
 example/parsar/README.zh.md                   | 6 +++---
 example/parsar/server/feishu-registration.mjs | 9 +++++++++
 example/parsar/tests/feishu.test.mjs          | 7 +++++++
 4 files changed, 21 insertions(+), 5 deletions(-)

diff --git a/example/parsar/README.md b/example/parsar/README.md
index a16ee2148..97762f52d 100644
--- a/example/parsar/README.md
+++ b/example/parsar/README.md
@@ -119,11 +119,11 @@ Optional business questions use the declared `ask_user` function. They appear in
 
 ## Feishu
 
-**飞书接入** shows one card per bot. **添加机器人** offers **扫码创建**, which provisions an application through Feishu’s device flow, or **已有应用** with an App ID and App Secret. A new bot stays disabled until configured. Secrets stay in the restricted local database. The official SDK owns authentication, normalization and long connections; no inbound public callback is needed.
+**飞书接入** shows one card per bot. **添加机器人** offers **扫码创建**, which provisions an application through Feishu’s device flow with the entered name and the `im:message.group_msg` scope pre-filled on the confirmation page, or **已有应用** with an App ID and App Secret. A new bot stays disabled until configured. Secrets stay in the restricted local database. The official SDK owns authentication, normalization and long connections; no inbound public callback is needed.
 
 1. On the card, choose the **Agent**, turn on **私聊** and/or **群聊**, then **保存并启用**. Enabling requires credentials, an Agent with an environment template and at least one of the two. With **群聊** on, the bot answers mentions in every group it has joined; adding the bot to a group is all that is needed. Who can add the bot is controlled by the app’s availability in the developer console.
 2. In the developer console, enable the bot, long-connection event delivery and `im.message.receive_v1`, publish the app and add it to the target groups. Grant mention receipt and send-as-bot permissions; direct messages, message resources and reactions need their own scopes. A missing reaction permission does not discard a message.
-3. Private chat keeps one conversation per sender until `/clear`. In groups, mentioning the bot starts a topic and each topic is one conversation shared by everyone who replies in it. Follow-ups without a mention arrive only when the app has the sensitive “read all group messages” scope (`im:message.group_msg`); otherwise mention the bot again in the topic. A topic reply that mentions only other people is addressed to them and is ignored. The bot serves its own tenant only: messages from external contacts are ignored. Other bots and `@all` are ignored, as are groups while **群聊** is off and private chats while **私聊** is off. Changing the bound Agent affects new topics and new private conversations.
+3. Private chat keeps one conversation per sender until `/clear`. In groups, mentioning the bot starts a topic and each topic is one conversation shared by everyone who replies in it. Follow-ups without a mention arrive only when the app has the “read all group messages” scope (`im:message.group_msg`). **扫码创建** requests it; for **已有应用**, enable it in the Feishu developer console. A topic reply that mentions only other people is addressed to them and is ignored. The bot serves its own tenant only: messages from external contacts are ignored. Other bots and `@all` are ignored, as are groups while **群聊** is off and private chats while **私聊** is off. Changing the bound Agent affects new topics and new private conversations.
 4. Text, rich posts, images, files, audio and video, quoted messages and merged forwards are normalized before dispatch. Attachment limits are eight resources and 5 MiB total. Follow-up files wait until the conversation is idle. Quoted messages are read up to four levels; earlier group messages are not read.
 5. Commands: `/clear` clears the context: it stops any running work and the next message starts a new conversation, in a private chat or in the same group topic. `/stop` stops the current task; it takes priority over queued follow-ups and recovers an uncertain creation before stopping it. `/answer <call_id> <text>` answers a pending business question, and a plain reply answers when only one is pending. `/help` lists the commands.
 
diff --git a/example/parsar/README.zh.md b/example/parsar/README.zh.md
index 7c73d8862..01a14778d 100644
--- a/example/parsar/README.zh.md
+++ b/example/parsar/README.zh.md
@@ -1,6 +1,6 @@
 ---
 source: example/parsar/README.md
-source_hash: 952864302053048e8618fa5e4760b46d789b195d27450ec6b63d73f4fbb4badb
+source_hash: 02cf5bb2228fca4278bdbaa1f2c52416347481b7c4491fd2ec61f9c046941272
 ---
 
 # Parsar 工作空间
@@ -124,11 +124,11 @@ Parsar 会跟踪每一轮正在执行的对话，网页和飞书都一样。出
 
 ## 飞书 {#feishu}
 
-**飞书接入** 为每个机器人展示一张卡片。**添加机器人** 提供 **扫码创建**（通过飞书设备流创建应用）和 **已有应用**（填写 App ID 与 App Secret）。新机器人在配置完成前保持停用。密钥保存在受限的本地数据库中。官方 SDK 负责鉴权、消息规范化和长连接，不需要公网回调。
+**飞书接入** 为每个机器人展示一张卡片。**添加机器人** 提供 **扫码创建**（通过飞书设备流创建应用，扫码后的确认页会预先填好输入的名称和 `im:message.group_msg` 权限）和 **已有应用**（填写 App ID 与 App Secret）。新机器人在配置完成前保持停用。密钥保存在受限的本地数据库中。官方 SDK 负责鉴权、消息规范化和长连接，不需要公网回调。
 
 1. 在卡片上选择 **Agent**，打开 **私聊** 和/或 **群聊**，然后 **保存并启用**。启用需要应用凭证、已配置环境模板的 Agent，以及两者至少开启一项。打开 **群聊** 后，机器人会回复它所在的任何群里的 @ 消息，把机器人拉进群即可使用。谁能添加机器人由开发者后台中应用的可用范围控制。
 2. 在开发者后台启用机器人、长连接事件推送和 `im.message.receive_v1`，发布应用并把它加入目标群。授予接收 @ 消息和以机器人身份发送消息的权限；私聊、消息资源和表情回复需要各自的权限。缺少表情权限不会丢弃消息。
-3. 私聊为每个发送者保持一个对话，直到发送 `/clear`。群聊中 @ 机器人会开启一个话题，每个话题是一个对话，所有在其中回复的人共享。只有应用开通了敏感权限“获取群组中所有消息”（`im:message.group_msg`），话题中不带 @ 的后续消息才会推送给机器人；否则需要在话题中再次 @ 机器人。话题中只 @ 了其他人的回复是发给他们的，会被忽略。其他机器人和 机器人只服务自己所在的企业，外部联系人发来的消息会被忽略。`@所有人` 会被忽略；关闭 **群聊** 时忽略群消息，关闭 **私聊** 时忽略私聊。更换绑定的 Agent 只影响新话题和新的私聊对话。
+3. 私聊为每个发送者保持一个对话，直到发送 `/clear`。群聊中 @ 机器人会开启一个话题，每个话题是一个对话，所有在其中回复的人共享。只有应用开通了“获取群组中所有消息”权限（`im:message.group_msg`），话题中不带 @ 的后续消息才会推送给机器人。**扫码创建** 会申请这个权限；**已有应用** 需要在飞书开发者后台开通。话题中只 @ 了其他人的回复是发给他们的，会被忽略。其他机器人和 机器人只服务自己所在的企业，外部联系人发来的消息会被忽略。`@所有人` 会被忽略；关闭 **群聊** 时忽略群消息，关闭 **私聊** 时忽略私聊。更换绑定的 Agent 只影响新话题和新的私聊对话。
 4. 文本、富文本、图片、文件、音视频、引用消息和合并转发会在投递前规范化。附件上限为 8 个、合计 5 MiB。后续消息中的文件会等到对话空闲后写入。引用消息最多读取四层；不读取更早的群消息。
 5. 命令：`/clear` 清空上下文：停止正在执行的任务，下一条消息开始新对话，私聊和群聊话题都适用（群聊仍在同一个话题里）。`/stop` 停止当前任务，优先于排队中的追问，并会先确认不确定的创建再停止。`/answer <call_id> <回答>` 回答待处理的业务问题；只有一个待回答的问题时，直接回复即可。`/help` 列出这些命令。
 
diff --git a/example/parsar/server/feishu-registration.mjs b/example/parsar/server/feishu-registration.mjs
index 2cda4fe70..69153cc3a 100644
--- a/example/parsar/server/feishu-registration.mjs
+++ b/example/parsar/server/feishu-registration.mjs
@@ -1,7 +1,13 @@
+import { gzipSync } from "node:zlib";
 import QRCode from "qrcode";
 import { qrImagePattern } from "../shared/media.mjs";
 import { AppError, uuid, text } from "./store.mjs";
 
+// Scopes the new app requests on top of the platform's default template, in
+// the official SDKs' QR `addons` encoding. Without im:message.group_msg the bot
+// never receives topic replies that do not mention it.
+const addons = gzipSync(JSON.stringify({ scopes: { tenant: ["im:message.group_msg"] } })).toString("base64url");
+
 // The SDK registerApp helper runs an in-memory polling loop and cannot resume a
 // persisted device code after restart. This adapter implements the same device
 // flow with durable polling state; codes and credentials never leave the server.
@@ -97,6 +103,9 @@ export function feishuRegistrationAPI(store, fetchImpl = fetch) {
           verification.password
         )
           throw new AppError(502, "飞书返回的授权地址无效。");
+        // The confirmation page after scanning pre-fills the app's name and scopes.
+        verification.searchParams.set("name", name);
+        verification.searchParams.set("addons", addons);
         row = {
           id,
           name,
diff --git a/example/parsar/tests/feishu.test.mjs b/example/parsar/tests/feishu.test.mjs
index 1724708d9..628f218d3 100644
--- a/example/parsar/tests/feishu.test.mjs
+++ b/example/parsar/tests/feishu.test.mjs
@@ -1,4 +1,5 @@
 import { test } from "node:test";
+import { gunzipSync } from "node:zlib";
 import assert from "node:assert/strict";
 import { randomUUID } from "node:crypto";
 import { openStore, AppError } from "../server/store.mjs";
@@ -717,6 +718,12 @@ test("Feishu QR registration throttles polling, persists credentials without ret
   const path = `/app/feishu/provision/${id}`;
   const begin = await api("POST", path, { action: "begin", name: "Assistant" });
   assert.equal(begin.status, "pending");
+  // Scanning creates the app with its name and the group-message scope pre-filled.
+  const scan = new URL(begin.verification_url);
+  assert.equal(scan.searchParams.get("name"), "Assistant");
+  assert.deepEqual(JSON.parse(gunzipSync(Buffer.from(scan.searchParams.get("addons"), "base64url"))), {
+    scopes: { tenant: ["im:message.group_msg"] },
+  });
   assert.equal(JSON.stringify(begin).includes("private-device"), false);
   await api("POST", path, { action: "begin" });
   assert.deepEqual(calls, ["init", "begin"]);

From 13202a0480c11c036bb8c5dc7000d6fb4f939532 Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Mon, 26 Oct 2026 16:21:02 +0800
Subject: [PATCH 10/19] Generate Parsar's Harness options from the Harness
 declarations

Parsar kept its own copy of each Harness's model protocol and execution
options and chose behavior by Harness name, and the copy had already
drifted: Codex lacked the fast service tier and Claude Code's auto
reasoning summary was rejected. make generate-harness-catalog now projects
the declared protocols, execution options, image input and required HTTP
MCP support into example/parsar/shared/harness-catalog.mjs, and Parsar's
image and MCP checks read those capabilities instead of the Harness name.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 contracts/agents-api/harness-onboarding.md    |  2 +-
 contracts/agents-api/zh/harness-onboarding.md |  4 +-
 example/parsar/README.md                      |  2 +-
 example/parsar/README.zh.md                   |  2 +-
 example/parsar/server/capability-kinds.mjs    |  5 +-
 example/parsar/server/sessions.mjs            |  7 +-
 example/parsar/shared/harness-catalog.mjs     | 96 +++++++++++++++++++
 example/parsar/shared/harness-options.d.mts   | 15 ++-
 example/parsar/shared/harness-options.mjs     | 40 ++------
 example/parsar/tests/product.test.mjs         | 21 +++-
 scripts/generate-harness-catalog.py           | 20 ++++
 scripts/harness-catalog/main.go               | 40 +++++++-
 12 files changed, 203 insertions(+), 51 deletions(-)
 create mode 100644 example/parsar/shared/harness-catalog.mjs

diff --git a/contracts/agents-api/harness-onboarding.md b/contracts/agents-api/harness-onboarding.md
index c6f6e8ede..afc5a7ec7 100644
--- a/contracts/agents-api/harness-onboarding.md
+++ b/contracts/agents-api/harness-onboarding.md
@@ -176,7 +176,7 @@ The runnable test-only example [`testdata/onboarding/main.go`](https://github.co
 
 ## Declare the Harness
 
-Each Harness is one `var Declaration = harnessconfig.Declaration{...}` in `internal/harnessconfig/<package>/declaration.go`. The package name is the kind without underscores. Creating the file registers the Harness: `make generate-harness-catalog` generates the Core registry, the Runtime's `harnessDeclarations`, the client identifiers and display names and the [registration reference](./harness-catalog.md), and `make check-harness-catalog` rejects stale projections. `make openapi` derives the Harness enums from the same declarations, so do not add handwritten enums to DTO tags or route annotations. There is no dynamic plugin loader, and a declaration cannot state a machine's availability.
+Each Harness is one `var Declaration = harnessconfig.Declaration{...}` in `internal/harnessconfig/<package>/declaration.go`. The package name is the kind without underscores. Creating the file registers the Harness: `make generate-harness-catalog` generates the Core registry, the Runtime's `harnessDeclarations`, the client identifiers and display names, the Parsar example's protocols and execution options and the [registration reference](./harness-catalog.md), and `make check-harness-catalog` rejects stale projections. `make openapi` derives the Harness enums from the same declarations, so do not add handwritten enums to DTO tags or route annotations. There is no dynamic plugin loader, and a declaration cannot state a machine's availability.
 
 The declaration holds:
 
diff --git a/contracts/agents-api/zh/harness-onboarding.md b/contracts/agents-api/zh/harness-onboarding.md
index c160dffb0..45c86bb14 100644
--- a/contracts/agents-api/zh/harness-onboarding.md
+++ b/contracts/agents-api/zh/harness-onboarding.md
@@ -1,7 +1,7 @@
 ---
 title: "Harness 协议"
 source: contracts/agents-api/harness-onboarding.md
-source_hash: 9be8782db19e5d68342b751f9b9aeaeac4566e3489320294ca06fcebd422bf78
+source_hash: fce6b6b0b690f252c250b100cf800712237b8ed5c8abfbc7f464a6fb2e55c586
 ---
 
 **Harness** 是一种运行模型和工具循环的原生代理引擎（Codex、Claude Code、MiniMax Code）；**Harness 适配器**将 Runtime 的 Executor 和 Turn 契约转换到该引擎的 SDK 或协议。Harness 协议是 Runtime 与适配器之间的契约：适配器接口及其生命周期义务、声明、注册和验收。本文面向添加或维护 Harness 的开发者。
@@ -178,7 +178,7 @@ Runtime 统一解析[状态目录](../../../docs/zh/configuration.md#runtime-res
 
 ## 声明 Harness {#declare-the-harness}
 
-每个 Harness 是 `internal/harnessconfig/<package>/declaration.go` 中的一个 `var Declaration = harnessconfig.Declaration{...}`。包名是去掉下划线的 kind。创建该文件即注册 Harness：`make generate-harness-catalog` 生成 Core 注册表、Runtime 的 `harnessDeclarations`、客户端标识符和显示名称以及[注册参考](harness-catalog.md)，`make check-harness-catalog` 拒绝过期的投影。`make openapi` 从同一批声明派生 Harness 枚举，因此不要在 DTO 标签或路由注解中手写枚举。没有动态插件加载器，声明也不能表示机器的可用性。
+每个 Harness 是 `internal/harnessconfig/<package>/declaration.go` 中的一个 `var Declaration = harnessconfig.Declaration{...}`。包名是去掉下划线的 kind。创建该文件即注册 Harness：`make generate-harness-catalog` 生成 Core 注册表、Runtime 的 `harnessDeclarations`、客户端标识符和显示名称、Parsar 示例使用的协议和执行选项，以及[注册参考](harness-catalog.md)，`make check-harness-catalog` 拒绝过期的投影。`make openapi` 从同一批声明派生 Harness 枚举，因此不要在 DTO 标签或路由注解中手写枚举。没有动态插件加载器，声明也不能表示机器的可用性。
 
 声明包含：
 
diff --git a/example/parsar/README.md b/example/parsar/README.md
index 97762f52d..241b20d07 100644
--- a/example/parsar/README.md
+++ b/example/parsar/README.md
@@ -98,7 +98,7 @@ Optional business questions use the declared `ask_user` function. They appear in
 
 ## Agents and resources
 
-**Agent** lists Agents as cards with their engine, model, environment template and bound Feishu bot. The Agent page groups **基本信息**, **执行与环境**, **指令**, **能力** and **行为**. **主指令** is the Agent’s own instruction text; optional **指令片段** are appended in selection order to produce one system prompt. Selection limits follow Core's [Environment limits](../../contracts/agents-api/environments.md#plugins-and-capability-directories): up to 50 Skills and 50 Plugins, and up to 50 knowledge items and environment-template files together; instruction fragments and MCP servers have no count limit. Bind only what the Agent needs, since every Skill and tool adds to what the model reads. In **执行与环境**, the Harness narrows every option to its declared values ([Harness capabilities](../../contracts/agents-api/harness-capabilities.md)); switching Harness resets values the new one does not accept and says which. Empty options keep the Harness default; web search defaults to **关闭**. Web conversations and Feishu step records show searches as **搜索网页**. Creating or editing a model, Skill, MCP, environment template or capability from the Agent page keeps unsaved fields, and a newly created resource is selected automatically. Unsaved Agent edits are restored when you return to the page in the same browser tab, and **保存** points to any missing required field. An existing Agent's page shows the last seven days: success rate, median first reply and automatic recoveries.
+**Agent** lists Agents as cards with their engine, model, environment template and bound Feishu bot. The Agent page groups **基本信息**, **执行与环境**, **指令**, **能力** and **行为**. **主指令** is the Agent’s own instruction text; optional **指令片段** are appended in selection order to produce one system prompt. Selection limits follow Core's [Environment limits](../../contracts/agents-api/environments.md#plugins-and-capability-directories): up to 50 Skills and 50 Plugins, and up to 50 knowledge items and environment-template files together; instruction fragments and MCP servers have no count limit. Bind only what the Agent needs, since every Skill and tool adds to what the model reads. In **执行与环境**, the Harness narrows every option to its declared values ([Harness capabilities](../../contracts/agents-api/harness-capabilities.md)), which `make generate-harness-catalog` projects into [shared/harness-catalog.mjs](shared/harness-catalog.mjs); switching Harness resets values the new one does not accept and says which. Empty options keep the Harness default; web search defaults to **关闭**. Web conversations and Feishu step records show searches as **搜索网页**. Creating or editing a model, Skill, MCP, environment template or capability from the Agent page keeps unsaved fields, and a newly created resource is selected automatically. Unsaved Agent edits are restored when you return to the page in the same browser tab, and **保存** points to any missing required field. An existing Agent's page shows the last seven days: success rate, median first reply and automatic recoveries.
 
 **模型** groups model IDs under Providers. Fetch a Provider’s OpenAI-shaped `GET /v1/models` catalog or enter IDs manually. Keys remain server-side; blank edits preserve the saved key. **测试** sends one tiny generation with the saved connection and shows the latency or the provider's error, never the key. Discovery sends only that Provider’s key and never follows redirects. Every Harness uses the selected HTTPS Provider: Responses for Codex, Anthropic for Claude Code and MiniMax Code. Unsupported combinations fail explicitly; consult the [Harness coverage ledger](../../contracts/agents-api/index.md).
 
diff --git a/example/parsar/README.zh.md b/example/parsar/README.zh.md
index 01a14778d..5ea1e65f8 100644
--- a/example/parsar/README.zh.md
+++ b/example/parsar/README.zh.md
@@ -1,6 +1,6 @@
 ---
 source: example/parsar/README.md
-source_hash: 02cf5bb2228fca4278bdbaa1f2c52416347481b7c4491fd2ec61f9c046941272
+source_hash: 9fd24c6684193572391f8cd279cd681548c2918b4f0c487271c90b9836940a44
 ---
 
 # Parsar 工作空间
diff --git a/example/parsar/server/capability-kinds.mjs b/example/parsar/server/capability-kinds.mjs
index 20b3a5c0b..7e4186a36 100644
--- a/example/parsar/server/capability-kinds.mjs
+++ b/example/parsar/server/capability-kinds.mjs
@@ -1,5 +1,6 @@
 import { AppError, text } from "./store.mjs";
 import { botVariables, environmentVariableName } from "../shared/bot-bindings.mjs";
+import { harnessOptions } from "../shared/harness-options.mjs";
 
 // Every kind of capability an Agent can bind, in one place. A kind resolves an
 // Agent's bindings, says which credentials each needs, and where each one goes:
@@ -66,8 +67,8 @@ export const capabilityKinds = {
         server_label: mcp.label,
         transport: { type: "http", server_url: mcp.url },
         connection_origin: "environment",
-        // MiniMax Code admits only optional MCP initialization.
-        required: agent.harness !== "mcode",
+        // Required only where the Harness declares required HTTP MCP servers.
+        required: harnessOptions[agent.harness]?.mcp_http_required === true,
         ...(credential ? { credential_id: credential.credential_id } : {}),
       });
       if (credential) out.session.vault_ids.push(credential.vault_id);
diff --git a/example/parsar/server/sessions.mjs b/example/parsar/server/sessions.mjs
index 542056dc5..5dcca3466 100644
--- a/example/parsar/server/sessions.mjs
+++ b/example/parsar/server/sessions.mjs
@@ -45,11 +45,8 @@ export async function prepareSession(store, resources, id, body, origin = {}, wa
     JSON.stringify(images).length > 900000
   )
     throw new AppError(400, "图片格式或大小无效。");
-  if (images.length && agent.harness === "mcode")
-    throw new AppError(
-      400,
-      "当前运行配置不支持图片输入，请使用托管 Codex 或 Claude Code。",
-    );
+  if (images.length && !harnessOptions[agent.harness].message_images)
+    throw new AppError(400, `${harnessOptions[agent.harness].label} 不支持图片输入，请换用支持图片的执行引擎。`);
   if (
     !Array.isArray(files) ||
     files.length > 8 ||
diff --git a/example/parsar/shared/harness-catalog.mjs b/example/parsar/shared/harness-catalog.mjs
new file mode 100644
index 000000000..d3a59ca56
--- /dev/null
+++ b/example/parsar/shared/harness-catalog.mjs
@@ -0,0 +1,96 @@
+// Code generated by scripts/generate-harness-catalog.py; DO NOT EDIT.
+
+// What each built-in Harness declares in internal/harnessconfig/<package>/declaration.go.
+export const harnessCatalog = {
+  "claude_sdk": {
+    "label": "Claude Code",
+    "protocols": [
+      "anthropic"
+    ],
+    "reasoning_effort": [
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max"
+    ],
+    "reasoning_summary": [
+      "auto"
+    ],
+    "web_search": [
+      "disabled",
+      "live"
+    ],
+    "verbosity": [
+      "medium"
+    ],
+    "service_tier": [],
+    "message_images": true,
+    "mcp_http_required": true
+  },
+  "codex": {
+    "label": "Codex",
+    "protocols": [
+      "responses"
+    ],
+    "reasoning_effort": [
+      "none",
+      "minimal",
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max"
+    ],
+    "reasoning_summary": [
+      "concise",
+      "detailed",
+      "auto"
+    ],
+    "web_search": [
+      "disabled",
+      "cached",
+      "live"
+    ],
+    "verbosity": [
+      "low",
+      "medium",
+      "high"
+    ],
+    "service_tier": [
+      "default",
+      "flex",
+      "priority",
+      "fast"
+    ],
+    "message_images": true,
+    "mcp_http_required": true
+  },
+  "mcode": {
+    "label": "MiniMax Code",
+    "protocols": [
+      "anthropic",
+      "responses",
+      "chat_completions"
+    ],
+    "reasoning_effort": [
+      "none",
+      "minimal",
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max"
+    ],
+    "reasoning_summary": [],
+    "web_search": [
+      "disabled"
+    ],
+    "verbosity": [
+      "medium"
+    ],
+    "service_tier": [],
+    "message_images": false,
+    "mcp_http_required": false
+  }
+};
diff --git a/example/parsar/shared/harness-options.d.mts b/example/parsar/shared/harness-options.d.mts
index 8dc722e1b..42d7dc5f0 100644
--- a/example/parsar/shared/harness-options.d.mts
+++ b/example/parsar/shared/harness-options.d.mts
@@ -1,4 +1,6 @@
-export type HarnessKind = "codex" | "claude_sdk" | "mcode";
+import type { CoreHarnessKind, ModelProviderProtocol } from "@oac/agents-client";
+
+export type HarnessKind = CoreHarnessKind;
 export type ExecutionOptionField =
   | "reasoning_effort"
   | "reasoning_summary"
@@ -7,10 +9,13 @@ export type ExecutionOptionField =
   | "service_tier";
 export const harnessOptions: Record<
   HarnessKind,
-  { label: string; protocol: "responses" | "anthropic" } & Record<
-    ExecutionOptionField,
-    string[]
-  >
+  {
+    label: string;
+    protocol: ModelProviderProtocol;
+    protocols: ModelProviderProtocol[];
+    message_images: boolean;
+    mcp_http_required: boolean;
+  } & Record<ExecutionOptionField, string[]>
 >;
 export const executionOptionFields: ExecutionOptionField[];
 export function unsupportedOption(
diff --git a/example/parsar/shared/harness-options.mjs b/example/parsar/shared/harness-options.mjs
index 93eae7ef7..e99efc8e6 100644
--- a/example/parsar/shared/harness-options.mjs
+++ b/example/parsar/shared/harness-options.mjs
@@ -1,35 +1,11 @@
-// Execution options each Harness admits, mirroring Core's Harness declarations
-// (contracts/agents-api/harness-capabilities.md). An empty value means the
-// Harness default and is never sent.
-export const harnessOptions = {
-  codex: {
-    label: "Codex",
-    protocol: "responses",
-    reasoning_effort: ["none", "minimal", "low", "medium", "high", "xhigh", "max"],
-    reasoning_summary: ["concise", "detailed", "auto"],
-    web_search: ["disabled", "cached", "live"],
-    verbosity: ["low", "medium", "high"],
-    service_tier: ["default", "flex", "priority"],
-  },
-  claude_sdk: {
-    label: "Claude Code",
-    protocol: "anthropic",
-    reasoning_effort: ["low", "medium", "high", "xhigh", "max"],
-    reasoning_summary: [],
-    web_search: ["disabled", "live"],
-    verbosity: ["medium"],
-    service_tier: [],
-  },
-  mcode: {
-    label: "MiniMax Code",
-    protocol: "anthropic",
-    reasoning_effort: ["none", "minimal", "low", "medium", "high", "xhigh", "max"],
-    reasoning_summary: [],
-    web_search: ["disabled"],
-    verbosity: ["medium"],
-    service_tier: [],
-  },
-};
+import { harnessCatalog } from "./harness-catalog.mjs";
+
+// Execution options each Harness admits, as Core's Harness declarations state
+// them. An empty value means the Harness default and is never sent. Parsar
+// connects a Provider with the Harness's first declared protocol.
+export const harnessOptions = Object.fromEntries(
+  Object.entries(harnessCatalog).map(([kind, declared]) => [kind, { ...declared, protocol: declared.protocols[0] }]),
+);
 
 export const executionOptionFields = [
   "reasoning_effort",
diff --git a/example/parsar/tests/product.test.mjs b/example/parsar/tests/product.test.mjs
index ebac86a2f..b505e816d 100644
--- a/example/parsar/tests/product.test.mjs
+++ b/example/parsar/tests/product.test.mjs
@@ -780,7 +780,7 @@ test("Agents carry Harness options into the saved Core Agent and reject undeclar
   assert.deepEqual(core.agentOf(sent[1]).text, { verbosity: "medium" });
   assert.equal(sent[1].x_agents_core.model_provider.protocol, "anthropic");
   for (const [patch, message] of [
-    [{ reasoning_summary: "auto" }, /Claude Code 不支持所选的推理摘要/],
+    [{ reasoning_summary: "concise" }, /Claude Code 不支持所选的推理摘要/],
     [{ harness: "mcode", web_search: "live" }, /MiniMax Code 不支持所选的网页搜索方式/],
     [{ reasoning_effort: "minimal" }, /Claude Code 不支持所选的推理强度/],
     [{ harness: "local" }, /请选择执行引擎/],
@@ -1303,3 +1303,22 @@ test("a message sent while a Turn runs steers it: one running Turn, resent toget
   assert.notEqual(next.id, first[0].id);
   assert.equal(store.list("turns").length, 2);
 });
+
+test("image input and required MCP servers follow what the Harness declares", async (t) => {
+  const store = openStore(":memory:");
+  t.after(() => store.close());
+  const sent = [];
+  const { put, core, agent, input } = await setup(store, async (_path, _method, body) => {
+    sent.push(body);
+    return { id: randomUUID() };
+  });
+  const image = "data:image/png;base64,iVBORw0KGgo=";
+  // Claude Code declares both.
+  await put("sessions", { ...input, images: [image] });
+  assert.equal(core.agentOf(sent.at(-1)).tools.find((tool) => tool.type === "mcp").required, true);
+  // MiniMax Code declares neither.
+  await put("agents", { ...store.get("agents", agent.id), harness: "mcode" }, agent.id);
+  await assert.rejects(put("sessions", { ...input, images: [image] }), /MiniMax Code 不支持图片输入/);
+  await put("sessions", input);
+  assert.equal(core.agentOf(sent.at(-1)).tools.find((tool) => tool.type === "mcp").required, false);
+});
diff --git a/scripts/generate-harness-catalog.py b/scripts/generate-harness-catalog.py
index 3b92174f0..6d4c0879a 100644
--- a/scripts/generate-harness-catalog.py
+++ b/scripts/generate-harness-catalog.py
@@ -54,6 +54,25 @@ def render_client(harnesses, protocols):
 """
 
 
+def render_parsar(harnesses):
+    """The Parsar example's copy of each Harness's model protocols and execution options."""
+    entries = {
+        h["kind"]: {
+            "label": h["label"],
+            "protocols": h["protocols"],
+            "reasoning_effort": h["execution"]["reasoning_efforts"],
+            "reasoning_summary": h["execution"]["reasoning_summaries"],
+            "web_search": h["execution"]["web_search_modes"],
+            "verbosity": h["execution"]["text_verbosities"],
+            "service_tier": h["execution"]["service_tiers"],
+            "message_images": h["message_images"],
+            "mcp_http_required": h["mcp_http_required"],
+        }
+        for h in harnesses
+    }
+    return HEADER + "\n// What each built-in Harness declares in internal/harnessconfig/<package>/declaration.go.\nexport const harnessCatalog = " + json.dumps(entries, indent=2, ensure_ascii=False) + ";\n"
+
+
 def render_registrations(names):
     """Go projections that need only the package names."""
     imports = "\n".join(f'\t"{MODULE}/internal/harnessconfig/{name}"' for name in names)
@@ -201,6 +220,7 @@ def projection(relative, content):
     if native:
         raise SystemExit("Native pins differ from the declarations; edit these files to match:\n" + "\n".join(native))
     projection(Path("packages/agents-client/src/harness-catalog.ts"), render_client(harnesses, declared["protocols"]))
+    projection(Path("example/parsar/shared/harness-catalog.mjs"), render_parsar(harnesses))
     if stale:
         raise SystemExit("Stale Harness catalog projections; run make generate-harness-catalog:\n" + "\n".join(stale))
 
diff --git a/scripts/harness-catalog/main.go b/scripts/harness-catalog/main.go
index 14f31baa4..2c1053f1a 100644
--- a/scripts/harness-catalog/main.go
+++ b/scripts/harness-catalog/main.go
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"os"
 
+	"github.com/MiniMax-AI/OpenAgentCore/internal/agentdaemon/proto"
 	"github.com/MiniMax-AI/OpenAgentCore/internal/harnessconfig/builtin"
 	"github.com/MiniMax-AI/OpenAgentCore/internal/modelprovider"
 )
@@ -16,13 +17,50 @@ type harness struct {
 	// Component and Version name the native installer component and its pin.
 	Component string `json:"component"`
 	Version   string `json:"version"`
+	// Protocols are the model-provider protocols, in declaration order.
+	Protocols []string  `json:"protocols"`
+	Execution execution `json:"execution"`
+	// MessageImages and MCPHTTPRequired report the declared capabilities.
+	MessageImages   bool `json:"message_images"`
+	MCPHTTPRequired bool `json:"mcp_http_required"`
+}
+
+// execution lists the execution option values the Harness admits.
+type execution struct {
+	WebSearchModes     []string `json:"web_search_modes"`
+	ReasoningEfforts   []string `json:"reasoning_efforts"`
+	ReasoningSummaries []string `json:"reasoning_summaries"`
+	ServiceTiers       []string `json:"service_tiers"`
+	TextVerbosities    []string `json:"text_verbosities"`
+}
+
+func values(list []string) []string {
+	if list == nil {
+		return []string{}
+	}
+	return list
 }
 
 func declarations() []harness {
 	var result []harness
 	for _, kind := range builtin.Kinds() {
 		declaration, _ := builtin.Registry().Lookup(kind)
-		result = append(result, harness{Kind: kind, Label: declaration.Label, Component: declaration.Native.Component, Version: declaration.Native.Version})
+		protocols := []string{}
+		for _, provider := range declaration.Configuration.Providers {
+			protocols = append(protocols, string(provider.Protocol))
+		}
+		options := declaration.Execution
+		result = append(result, harness{
+			Kind: kind, Label: declaration.Label, Component: declaration.Native.Component, Version: declaration.Native.Version,
+			Protocols: protocols,
+			Execution: execution{
+				WebSearchModes: values(options.WebSearchModes), ReasoningEfforts: values(options.ReasoningEfforts),
+				ReasoningSummaries: values(options.ReasoningSummaries), ServiceTiers: values(options.ServiceTiers),
+				TextVerbosities: values(options.TextVerbosities),
+			},
+			MessageImages:   declaration.Capabilities.MessageImages == proto.CapabilitySupported,
+			MCPHTTPRequired: declaration.Capabilities.MCPHTTPRequired == proto.CapabilitySupported,
+		})
 	}
 	return result
 }

From a7da3fb7bafc8f76d66574d147f3d36c9bf55ac7 Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Mon, 26 Oct 2026 17:13:39 +0800
Subject: [PATCH 11/19] Request common Feishu scopes, name each message's
 source and link missing scopes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A bot created by scanning had only the default template's scopes, so an
Agent working with Base or Calendar failed on its first call and its users
had to find and apply for each scope. The QR code now also requests
reading and writing Base, Calendar, Docs, Drive, Sheets, Wiki and Tasks and
basic contact information.

When the Agent's tools report scopes the bot's app lacks, the card now says
需要开通权限, lists them and links to the developer console's apply page,
with the Agent's explanation folded below, instead of a long reply.

Skills keyed to Feishu messages could not see which message they were
answering and treated Feishu input as Web input. Each Feishu message now
reaches the Agent after a line naming its message_id, chat_id, chat type and
sender; Parsar's views hide that line.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/README.md                      |  4 +-
 example/parsar/README.zh.md                   |  6 +--
 example/parsar/server/feishu-registration.mjs | 26 ++++++++--
 example/parsar/server/feishu.mjs              | 51 +++++++++++++++++--
 example/parsar/shared/feishu-source.d.mts     |  2 +
 example/parsar/shared/feishu-source.mjs       |  6 +++
 example/parsar/src/SessionDetail.tsx          |  3 +-
 example/parsar/src/components/Activity.tsx    |  3 +-
 example/parsar/tests/feishu.test.mjs          | 47 ++++++++++++++---
 9 files changed, 127 insertions(+), 21 deletions(-)
 create mode 100644 example/parsar/shared/feishu-source.d.mts
 create mode 100644 example/parsar/shared/feishu-source.mjs

diff --git a/example/parsar/README.md b/example/parsar/README.md
index 3909a7e71..66feb0c30 100644
--- a/example/parsar/README.md
+++ b/example/parsar/README.md
@@ -121,7 +121,7 @@ Optional business questions use the declared `ask_user` function. They appear in
 
 ## Feishu
 
-**飞书接入** shows one card per bot. **添加机器人** offers **扫码创建**, which provisions an application through Feishu’s device flow with the entered name and the `im:message.group_msg` scope pre-filled on the confirmation page, or **已有应用** with an App ID and App Secret. A new bot stays disabled until configured. Secrets stay in the restricted local database. The official SDK owns authentication, normalization and long connections; no inbound public callback is needed.
+**飞书接入** shows one card per bot. **添加机器人** offers **扫码创建**, which provisions an application through Feishu’s device flow with the entered name and app-identity scopes pre-filled on the confirmation page: `im:message.group_msg` plus reading and writing Base, Calendar, Docs, Drive, Sheets, Wiki and Tasks and basic contact information ([the list](server/feishu-registration.mjs)), or **已有应用** with an App ID and App Secret. A new bot stays disabled until configured. Secrets stay in the restricted local database. The official SDK owns authentication, normalization and long connections; no inbound public callback is needed.
 
 1. On the card, choose the **Agent**, turn on **私聊** and/or **群聊**, then **保存并启用**. Enabling requires credentials, an Agent with an environment template and at least one of the two. With **群聊** on, the bot answers mentions in every group it has joined; adding the bot to a group is all that is needed. Who can add the bot is controlled by the app’s availability in the developer console.
 2. In the developer console, enable the bot, long-connection event delivery and `im.message.receive_v1`, publish the app and add it to the target groups. Grant mention receipt and send-as-bot permissions; direct messages, message resources and reactions need their own scopes. A missing reaction permission does not discard a message.
@@ -133,7 +133,7 @@ Accepted messages are committed to SQLite before the WebSocket ACK; request IDs
 
 ### Bot identity
 
-The Agent acts as its bound bot. Every conversation of an Agent with a bound bot, Web ones included, receives the bot’s identity as `FEISHU_APP_ID`, `FEISHU_APP_SECRET` and `FEISHU_BRAND`; nothing needs to be mapped. A template, Skill or Plugin that needs the bot lists these names under **需要的密钥**: the library shows **飞书机器人** as its requirement, the Agent page shows the bot that provides it, and an Agent without a bot cannot be saved. Only the bound bot supplies these names. The Feishu case's setup script runs `lark-cli config init --app-secret-stdin`, so the CLI mints and refreshes tenant tokens itself and long conversations keep working. Do not pass them as `LARKSUITE_CLI_APP_ID` or `LARKSUITE_CLI_APP_SECRET`: those switch lark-cli to environment credentials, which require a ready-made tenant token. Anyone who can talk to the bot can use the bot’s permissions, and tools in the Environment can read the secret. Grant the bot only the scopes its Agent needs and prefer one bot per Agent. A rotated secret applies to new conversations only.
+The Agent acts as its bound bot. Each Feishu message reaches it after a first line naming its `message_id`, `chat_id`, chat type and sender `open_id`, so a Skill can key work to the message; Parsar's own views hide that line. When the Agent's tools report that the bot's app lacks scopes, the card says **需要开通权限**, lists them and links to applying for them in the Feishu developer console, with the Agent's explanation folded below; once an administrator approves the new version, replying continues. Every conversation of an Agent with a bound bot, Web ones included, receives the bot’s identity as `FEISHU_APP_ID`, `FEISHU_APP_SECRET` and `FEISHU_BRAND`; nothing needs to be mapped. A template, Skill or Plugin that needs the bot lists these names under **需要的密钥**: the library shows **飞书机器人** as its requirement, the Agent page shows the bot that provides it, and an Agent without a bot cannot be saved. Only the bound bot supplies these names. The Feishu case's setup script runs `lark-cli config init --app-secret-stdin`, so the CLI mints and refreshes tenant tokens itself and long conversations keep working. Do not pass them as `LARKSUITE_CLI_APP_ID` or `LARKSUITE_CLI_APP_SECRET`: those switch lark-cli to environment credentials, which require a ready-made tenant token. Anyone who can talk to the bot can use the bot’s permissions, and tools in the Environment can read the secret. Grant the bot only the scopes its Agent needs and prefer one bot per Agent. A rotated secret applies to new conversations only.
 
 ### Feishu workspace case
 
diff --git a/example/parsar/README.zh.md b/example/parsar/README.zh.md
index baa5be405..70299d1c0 100644
--- a/example/parsar/README.zh.md
+++ b/example/parsar/README.zh.md
@@ -1,6 +1,6 @@
 ---
 source: example/parsar/README.md
-source_hash: cc34789487f4a254154af1dcdb473e429c1bffc977367e3a26b119901a18b177
+source_hash: 7ae8e170b6cc280187a0f1687deec84955a91e44efc6124f2a858ef7f4f902e0
 ---
 
 # Parsar 工作空间
@@ -126,7 +126,7 @@ Parsar 会跟踪每一轮正在执行的对话，网页和飞书都一样。出
 
 ## 飞书 {#feishu}
 
-**飞书接入** 为每个机器人展示一张卡片。**添加机器人** 提供 **扫码创建**（通过飞书设备流创建应用，扫码后的确认页会预先填好输入的名称和 `im:message.group_msg` 权限）和 **已有应用**（填写 App ID 与 App Secret）。新机器人在配置完成前保持停用。密钥保存在受限的本地数据库中。官方 SDK 负责鉴权、消息规范化和长连接，不需要公网回调。
+**飞书接入** 为每个机器人展示一张卡片。**添加机器人** 提供 **扫码创建**（通过飞书设备流创建应用，扫码后的确认页会预先填好输入的名称和应用身份权限：`im:message.group_msg`，以及多维表格、日历、文档、云空间、电子表格、知识库、任务的读写和通讯录基本信息，[完整清单](server/feishu-registration.mjs)）和 **已有应用**（填写 App ID 与 App Secret）。新机器人在配置完成前保持停用。密钥保存在受限的本地数据库中。官方 SDK 负责鉴权、消息规范化和长连接，不需要公网回调。
 
 1. 在卡片上选择 **Agent**，打开 **私聊** 和/或 **群聊**，然后 **保存并启用**。启用需要应用凭证、已配置环境模板的 Agent，以及两者至少开启一项。打开 **群聊** 后，机器人会回复它所在的任何群里的 @ 消息，把机器人拉进群即可使用。谁能添加机器人由开发者后台中应用的可用范围控制。
 2. 在开发者后台启用机器人、长连接事件推送和 `im.message.receive_v1`，发布应用并把它加入目标群。授予接收 @ 消息和以机器人身份发送消息的权限；私聊、消息资源和表情回复需要各自的权限。缺少表情权限不会丢弃消息。
@@ -138,7 +138,7 @@ Parsar 会跟踪每一轮正在执行的对话，网页和飞书都一样。出
 
 ### 机器人身份 {#bot-identity}
 
-Agent 以绑定的机器人身份工作。绑定了机器人的 Agent，它的每个对话（包括网页对话）都会以 `FEISHU_APP_ID`、`FEISHU_APP_SECRET` 和 `FEISHU_BRAND` 拿到机器人身份，不需要任何映射。需要机器人身份的模板、Skill 或 Plugin 在 **需要的密钥** 里列出这几个名字：能力列表里它的凭据需求显示为 **飞书机器人**，Agent 页面显示由哪个机器人提供，没有绑定机器人的 Agent 不能保存。这几个名字只能由绑定的机器人提供。飞书案例的初始化脚本运行 `lark-cli config init --app-secret-stdin`，由 CLI 自行获取并刷新租户令牌，长对话也能持续工作。不要以 `LARKSUITE_CLI_APP_ID` 或 `LARKSUITE_CLI_APP_SECRET` 传入：这两个变量会让 lark-cli 进入环境凭据模式，该模式要求直接提供租户令牌。任何能与机器人对话的人都能使用机器人的权限，Environment 中的工具也能读取该密钥。只为机器人授予其 Agent 需要的权限，尽量一个 Agent 使用一个机器人。轮换后的密钥只对新对话生效。
+Agent 以绑定的机器人身份工作。每条飞书消息转给 Agent 时，正文前会附一行来源信息：`message_id`、`chat_id`、会话类型和发送者 `open_id`，Skill 可以据此对消息做幂等处理；Parsar 自己的页面不显示这一行。Agent 的工具报告机器人应用缺少权限时，卡片标题显示 **需要开通权限**，列出缺少的权限，并附上在飞书开发者后台申请开通的链接，Agent 的说明折叠在下方；管理员批准并发布新版本后，直接回复即可继续。绑定了机器人的 Agent，它的每个对话（包括网页对话）都会以 `FEISHU_APP_ID`、`FEISHU_APP_SECRET` 和 `FEISHU_BRAND` 拿到机器人身份，不需要任何映射。需要机器人身份的模板、Skill 或 Plugin 在 **需要的密钥** 里列出这几个名字：能力列表里它的凭据需求显示为 **飞书机器人**，Agent 页面显示由哪个机器人提供，没有绑定机器人的 Agent 不能保存。这几个名字只能由绑定的机器人提供。飞书案例的初始化脚本运行 `lark-cli config init --app-secret-stdin`，由 CLI 自行获取并刷新租户令牌，长对话也能持续工作。不要以 `LARKSUITE_CLI_APP_ID` 或 `LARKSUITE_CLI_APP_SECRET` 传入：这两个变量会让 lark-cli 进入环境凭据模式，该模式要求直接提供租户令牌。任何能与机器人对话的人都能使用机器人的权限，Environment 中的工具也能读取该密钥。只为机器人授予其 Agent 需要的权限，尽量一个 Agent 使用一个机器人。轮换后的密钥只对新对话生效。
 
 ### 飞书工作环境案例 {#feishu-workspace-case}
 
diff --git a/example/parsar/server/feishu-registration.mjs b/example/parsar/server/feishu-registration.mjs
index 69153cc3a..b300e1f99 100644
--- a/example/parsar/server/feishu-registration.mjs
+++ b/example/parsar/server/feishu-registration.mjs
@@ -3,10 +3,26 @@ import QRCode from "qrcode";
 import { qrImagePattern } from "../shared/media.mjs";
 import { AppError, uuid, text } from "./store.mjs";
 
-// Scopes the new app requests on top of the platform's default template, in
-// the official SDKs' QR `addons` encoding. Without im:message.group_msg the bot
-// never receives topic replies that do not mention it.
-const addons = gzipSync(JSON.stringify({ scopes: { tenant: ["im:message.group_msg"] } })).toString("base64url");
+// App-identity scopes the new app requests on top of the platform's default
+// template, so an Agent can work with Feishu data without its users applying
+// for each scope later. Without im:message.group_msg the bot never receives
+// topic replies that do not mention it.
+export const botScopes = [
+  "im:message.group_msg", "im:chat.members:read",
+  "contact:user.base:readonly", "contact:user.id:readonly", "contact:department.base:readonly",
+  "bitable:app", "base:app:read", "base:app:create", "base:app:update", "base:table:read", "base:table:create", "base:table:update",
+  "base:field:read", "base:field:create", "base:field:update", "base:record:read", "base:record:create", "base:record:update",
+  "base:record:delete", "base:view:read",
+  "calendar:calendar", "calendar:calendar:readonly", "calendar:calendar:read", "calendar:calendar.calendar:readonly",
+  "calendar:calendar.event:read", "calendar:calendar.event:create", "calendar:calendar.event:update", "calendar:calendar.event:delete",
+  "calendar:calendar.free_busy:read",
+  "docx:document", "docx:document:create", "drive:drive", "drive:drive:readonly", "drive:file", "drive:file:upload", "drive:file:download",
+  "sheets:spreadsheet", "sheets:spreadsheet:readonly", "sheets:spreadsheet:create",
+  "wiki:wiki", "wiki:wiki:readonly", "wiki:node:read", "wiki:node:create", "wiki:space:read",
+  "task:task:read", "task:task:write", "task:tasklist:read", "task:tasklist:write",
+];
+// The official SDKs' QR `addons` encoding.
+const addons = gzipSync(JSON.stringify({ scopes: { tenant: botScopes } })).toString("base64url");
 
 // The SDK registerApp helper runs an in-memory polling loop and cannot resume a
 // persisted device code after restart. This adapter implements the same device
@@ -61,7 +77,7 @@ export function feishuRegistrationAPI(store, fetchImpl = fetch) {
       if (!row) throw new AppError(404, "注册会话不存在。");
       if (row.status !== "pending" || row.expires_at <= Date.now())
         throw new AppError(410, "授权二维码已失效，请重新发起注册。");
-      return QRCode.toBuffer(row.verification_url, { width: 320, margin: 4 });
+      return QRCode.toBuffer(row.verification_url, { width: 480, margin: 4 });
     }
     const id = path.match(/^\/app\/feishu\/provision\/([a-f0-9-]{36})$/)?.[1];
     if (!id || !uuid.test(id)) throw new AppError(404, "Not found.");
diff --git a/example/parsar/server/feishu.mjs b/example/parsar/server/feishu.mjs
index ecc5fa6aa..fbbc16508 100644
--- a/example/parsar/server/feishu.mjs
+++ b/example/parsar/server/feishu.mjs
@@ -7,6 +7,7 @@ const stableId = (value) => {
 import { feishuContextReader } from "./feishu-context.mjs";
 import { explainFailure, turnsAPI } from "./turns.mjs";
 import { typicalWait, waitingHeadline } from "../shared/turn-status.mjs";
+import { feishuSource } from "../shared/feishu-source.mjs";
 import { AppError, text, uuid, transientError } from "./store.mjs";
 
 const stamp = () => Date.now();
@@ -176,6 +177,7 @@ const cardTones = {
   completed: ["已完成", "green"],
   cancelled: ["已停止", "grey"],
   failed: ["执行失败", "red"],
+  missing_scopes: ["需要开通权限", "orange"],
 };
 const grey = (text) => `<font color='grey'>${text}</font>`;
 
@@ -382,7 +384,36 @@ function exchangeItems(items) {
 
 const recentRows = 4;
 
-export function formatTurnCard(status, items = [], error, turn, questions = []) {
+// Scopes Feishu says the bot's app lacks, from the Agent's tool output: the
+// platform's "One of the following scopes is required: [...]", lark-cli's
+// "required scope(s): ...", and permission_violations subjects.
+export function missingScopes(items) {
+  const found = new Set();
+  const scope = /^[a-z][a-z0-9_]*:[a-z0-9_.:-]+$/;
+  for (const item of items) {
+    if (!["command_execution", "function_call_output", "mcp_call"].includes(item.type)) continue;
+    const output = [item.output, item.error].map((value) => (typeof value === "string" ? value : JSON.stringify(value ?? ""))).join("\n");
+    if (!/99991672|99991679|app_scope_not_applied|scopes? (?:is )?required|required scope/i.test(output)) continue;
+    for (const [, list] of output.matchAll(/(?:scopes is required: \[|required scope\(s\): )([^\]"\n]+)/g))
+      for (const name of list.split(/[,\s]+/)) if (scope.test(name)) found.add(name);
+    for (const [, name] of output.matchAll(/"subject":\s*"([^"]+)"/g)) if (scope.test(name)) found.add(name);
+  }
+  return [...found];
+}
+
+// What to tell people when the bot's app lacks scopes: which, and where to apply.
+function scopeNotice(app, scopes) {
+  const host = app.brand === "lark" ? "open.larksuite.com" : "open.feishu.cn";
+  const url = `https://${host}/page/scope-apply?clientID=${encodeURIComponent(app.app_id)}&scopes=${encodeURIComponent(scopes.join(","))}`;
+  return [
+    `**机器人「${app.name || app.app_id}」还缺少飞书权限**，这次没能完成。`,
+    `需要开通：${scopes.map((name) => `\`${name}\``).join("、")}`,
+    `[申请开通权限](${url})`,
+    grey("管理员批准并发布新版本后，直接回复这条消息即可继续。"),
+  ].join("\n\n");
+}
+
+export function formatTurnCard(status, items = [], error, turn, questions = [], app) {
   items = exchangeItems(items);
   const text = (item) => (item.content || []).filter((p) => p.type === "output_text").map((p) => (p.text || "").trim()).filter(Boolean).join("\n");
   const messages = items.filter((x) => x.type === "message" && x.role === "assistant");
@@ -445,6 +476,13 @@ export function formatTurnCard(status, items = [], error, turn, questions = [])
     : status === "cancelled" ? [authorizationText, answer].filter(Boolean).join("\n\n") || "已按你的要求停止。"
     : [authorizationText, answer || "这次没有完成。", error ? `<font color='red'>${error}</font>` : "", grey("直接回复即可重试。")].filter(Boolean).join("\n\n"), status === "requires_action" ? 8000 : 12000);
   const elements = [];
+  // Missing scopes come first: the Agent's own explanation folds below the link.
+  const scopes = app ? missingScopes(items) : [];
+  if (scopes.length) {
+    elements.push(panel({ title: grey("Agent 的说明"), content: excerpt([body, foldContext ? context : ""].filter(Boolean).join("\n\n"), 4000) }));
+    if (rows.length) elements.push(panel({ title: grey(`处理过程 · ${rows.length} 步`), elements: fitRows(rows, cardBudget - bytes(elements) - 2000), block: true }));
+    return statusCard("missing_scopes", scopeNotice(app, scopes), [{ tag: "hr" }, ...elements]);
+  }
   if (foldContext) elements.push(panel({ title: grey("补充说明"), content: excerpt(context, 4000) }));
   // A failure shows the step that failed right under its cause.
   const failedTool = status === "failed" ? tools.findLast((item) => item.status === "failed") : undefined;
@@ -872,10 +910,12 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
       ((context.resources || []).some((resource) => resource.type === "image")
         ? "图片消息"
         : "文件消息");
+    // The Agent sees where the message came from, so Skills can key work to it.
+    const source = feishuSource(row);
     const media = {
       images: [],
       files: [],
-      text: input.trim() || title,
+      text: `${source}\n${input.trim() || title}`,
       title,
       notice: context.notice,
     };
@@ -1259,6 +1299,8 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
         thread,
         `执行失败\n\n${ledger.summary(run.id)?.failure || "执行环境准备失败，请重新发送消息重试。"}`,
       );
+    // The bot's app, so a card can link to applying for scopes it lacks.
+    const app = store.list("feishu_bots").find((bot) => bot.app_id === thread.app_id);
     let progress = thread.active_outbound_id && store.get("feishu_outbound", thread.active_outbound_id);
     // The progress card of the input a Turn answers; an older Turn never takes
     // the card of a newer message.
@@ -1282,7 +1324,7 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
         (item) => item.turn_id === turns.at(-1)?.id && !ledger.superseded(run.id, item.turn_id),
       );
       queueMedia(thread, items);
-      const text = formatTurnCard(session.status === "requires_action" && questions.length ? "requires_action" : "in_progress", items, undefined, ledger.summary(run.id), questions);
+      const text = formatTurnCard(session.status === "requires_action" && questions.length ? "requires_action" : "in_progress", items, undefined, ledger.summary(run.id), questions, app);
       if (progress?.sent_message_id) {
         if (thread.progress_text !== text) {
           try {
@@ -1345,6 +1387,9 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
         turn.status === "failed"
           ? ledger.summary(run.id)?.failure || explainFailure(turn.error)
           : turn.error?.message,
+        undefined,
+        [],
+        app,
       );
       const receiptId = stableId(`${thread.id}:${turn.id}`);
       const receipt = (sentMessageId) => store.put("feishu_outbound", {
diff --git a/example/parsar/shared/feishu-source.d.mts b/example/parsar/shared/feishu-source.d.mts
new file mode 100644
index 000000000..4f8823d5d
--- /dev/null
+++ b/example/parsar/shared/feishu-source.d.mts
@@ -0,0 +1,2 @@
+export function feishuSource(row: { message_id: string; chat_id: string; chat_type: string; sender_id: string }): string;
+export function withoutFeishuSource(text: string): string;
diff --git a/example/parsar/shared/feishu-source.mjs b/example/parsar/shared/feishu-source.mjs
new file mode 100644
index 000000000..36b4af324
--- /dev/null
+++ b/example/parsar/shared/feishu-source.mjs
@@ -0,0 +1,6 @@
+// The line that tells an Agent which Feishu message it is answering. Parsar's
+// own views show the message without it.
+export const feishuSource = (row) =>
+  `[飞书消息 message_id=${row.message_id} chat_id=${row.chat_id} chat_type=${row.chat_type} sender_open_id=${row.sender_id}]`;
+
+export const withoutFeishuSource = (text) => text.replace(/^\[飞书消息 message_id=\S+ chat_id=\S+ chat_type=\S+ sender_open_id=\S+\]\n/, "");
diff --git a/example/parsar/src/SessionDetail.tsx b/example/parsar/src/SessionDetail.tsx
index 222f1613c..fb0b9dd1f 100644
--- a/example/parsar/src/SessionDetail.tsx
+++ b/example/parsar/src/SessionDetail.tsx
@@ -1,3 +1,4 @@
+import { withoutFeishuSource } from "../shared/feishu-source.mjs";
 import {
   TurnNavRail,
   turnPreview,
@@ -89,7 +90,7 @@ export function SessionDetail({
     .map((item) => ({
       key: item.id,
       preview: turnPreview(
-        item.content?.map((part) => part.text || "").join("\n") || "",
+        withoutFeishuSource(item.content?.map((part) => part.text || "").join("\n") || ""),
       ),
     }));
   const activeTurn = useActiveTurnKey(
diff --git a/example/parsar/src/components/Activity.tsx b/example/parsar/src/components/Activity.tsx
index cbc99956b..26f831847 100644
--- a/example/parsar/src/components/Activity.tsx
+++ b/example/parsar/src/components/Activity.tsx
@@ -1,3 +1,4 @@
+import { withoutFeishuSource } from "../../shared/feishu-source.mjs";
 import { MediaImage, ArtifactAttachment } from "./Media";
 import { artifactContentPath, qrImagePattern } from "../../shared/media.mjs";
 import { tr } from "../lib/i18n";
@@ -127,7 +128,7 @@ export function Activity({ item, sessionId = "", artifacts = [] }: { item: Sessi
       return (
         <div className="flex justify-end py-3">
           <div className="max-w-[80%] whitespace-pre-wrap break-words rounded-3xl bg-surface-muted px-5 py-3 text-base leading-relaxed">
-            {text}
+            {withoutFeishuSource(text)}
             {item.content?.filter((part) => part.type === "input_image").map((part, index) =>
               typeof part.image_url === "string" && /^data:image\/(png|jpeg|webp);base64,[A-Za-z0-9+/=]+$/.test(part.image_url)
                 ? <img key={index} src={part.image_url} alt={tr("图片")} className="mt-2 max-h-80 max-w-full rounded-lg object-contain" /> : null)}
diff --git a/example/parsar/tests/feishu.test.mjs b/example/parsar/tests/feishu.test.mjs
index 628f218d3..887dfbf44 100644
--- a/example/parsar/tests/feishu.test.mjs
+++ b/example/parsar/tests/feishu.test.mjs
@@ -191,7 +191,8 @@ test("Feishu settings redact secrets, default-deny chat dispatch and persist ing
   assert.equal(
     f.calls.find((x) => x.path.endsWith("/events")).body.events[0].input[0]
       .content[0].text,
-    "Also check mobile",
+    // The Agent sees which Feishu message it is answering.
+    "[飞书消息 message_id=om_next chat_id=oc_test chat_type=group sender_open_id=ou_user]\nAlso check mobile",
   );
 });
 
@@ -671,7 +672,7 @@ test("Agent Skill version selectors are validated and frozen in public requests"
 });
 
 test("Feishu QR registration throttles polling, persists credentials without returning them, and resumes safely", async (t) => {
-  const { feishuRegistrationAPI } = await import(
+  const { botScopes, feishuRegistrationAPI } = await import(
     "../server/feishu-registration.mjs"
   );
   const store = openStore(":memory:");
@@ -721,9 +722,9 @@ test("Feishu QR registration throttles polling, persists credentials without ret
   // Scanning creates the app with its name and the group-message scope pre-filled.
   const scan = new URL(begin.verification_url);
   assert.equal(scan.searchParams.get("name"), "Assistant");
-  assert.deepEqual(JSON.parse(gunzipSync(Buffer.from(scan.searchParams.get("addons"), "base64url"))), {
-    scopes: { tenant: ["im:message.group_msg"] },
-  });
+  const requested = JSON.parse(gunzipSync(Buffer.from(scan.searchParams.get("addons"), "base64url")));
+  assert.deepEqual(requested, { scopes: { tenant: botScopes } });
+  assert.ok(botScopes.includes("im:message.group_msg"));
   assert.equal(JSON.stringify(begin).includes("private-device"), false);
   await api("POST", path, { action: "begin" });
   assert.deepEqual(calls, ["init", "begin"]);
@@ -1164,7 +1165,7 @@ test("Feishu updates a single card in place with thinking and steps, omits Web t
   );
   assert.equal(
     f.calls.findLast((call) => call.path === "/v1/agents/sessions").body.input,
-    "收到请回复",
+    "[飞书消息 message_id=om_dm_3 chat_id=oc_dm_single chat_type=p2p sender_open_id=ou_user]\n收到请回复",
   );
   const listedSessions = await f.api("GET", "/app/sessions");
   assert.equal(
@@ -2102,3 +2103,37 @@ test("a message sent while the Turn runs steers it and keeps that Turn's card",
   assert.equal(f.store.list("turns")[0].steers.length, 1);
   assert.equal(f.store.list("feishu_inbound").find((row) => row.message_id === "steer").state, "delivered");
 });
+
+test("a turn blocked by missing Feishu scopes answers with the scopes and a link to apply", async () => {
+  const { formatTurnCard, missingScopes } = await import("../server/feishu.mjs");
+  const cli = JSON.stringify({ ok: false, identity: "bot", error: { type: "authorization", subtype: "app_scope_not_applied", code: 99991672, message: "access denied: app cli_0123456789abcdef has not applied for the required scope(s): base:field:read, base:record:read" } });
+  const api = '{"code":99991672,"msg":"Access denied. One of the following scopes is required: [calendar:calendar:readonly, calendar:calendar]."}';
+  const items = [
+    { type: "command_execution", command: "lark-cli base +field-list", output: cli, status: "failed" },
+    { type: "command_execution", command: "curl calendar", output: api, status: "completed" },
+    { type: "command_execution", command: "echo", output: "scope: not an error", status: "completed" },
+    { type: "message", role: "assistant", content: [{ type: "output_text", text: "很长的一段解释和三个选项" }] },
+  ];
+  assert.deepEqual(missingScopes(items), ["base:field:read", "base:record:read", "calendar:calendar:readonly", "calendar:calendar"]);
+  const app = { app_id: "cli_0123456789abcdef", brand: "feishu", name: "日程助手" };
+  const card = JSON.parse(formatTurnCard("requires_action", items, undefined, undefined, [], app));
+  const body = card.body.elements[0].content;
+  assert.equal(card.header.title.content, "需要开通权限");
+  assert.match(body, /机器人「日程助手」还缺少飞书权限/);
+  assert.match(body, /https:\/\/open\.feishu\.cn\/page\/scope-apply\?clientID=cli_0123456789abcdef&scopes=base%3Afield%3Aread%2Cbase%3Arecord%3Aread%2Ccalendar%3Acalendar%3Areadonly%2Ccalendar%3Acalendar/);
+  assert.doesNotMatch(body, /很长的一段解释/, "the Agent's explanation folds below");
+  assert.match(JSON.stringify(card.body.elements.slice(1)), /很长的一段解释/);
+  // Without scope errors, the card is unchanged.
+  const plain = JSON.parse(formatTurnCard("completed", items.slice(2), undefined, undefined, [], app));
+  assert.equal(plain.header.title.content, "已完成");
+  // Lark apps apply on the Lark console.
+  assert.match(formatTurnCard("failed", items, "x", undefined, [], { ...app, brand: "lark" }), /open\.larksuite\.com\/page\/scope-apply/);
+});
+
+test("Parsar's views show a Feishu message without the source line the Agent sees", async () => {
+  const { feishuSource, withoutFeishuSource } = await import("../shared/feishu-source.mjs");
+  const line = feishuSource({ message_id: "om_1", chat_id: "oc_1", chat_type: "p2p", sender_id: "ou_1" });
+  assert.equal(line, "[飞书消息 message_id=om_1 chat_id=oc_1 chat_type=p2p sender_open_id=ou_1]");
+  assert.equal(withoutFeishuSource(`${line}\n记一下明天的 meetup`), "记一下明天的 meetup");
+  assert.equal(withoutFeishuSource("[飞书消息] 不是来源行"), "[飞书消息] 不是来源行");
+});

From 3032d228a2a9bc7b4d4546d91ea80a9d03479169 Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Mon, 26 Oct 2026 17:32:16 +0800
Subject: [PATCH 12/19] Keep Feishu chats tidy and drop the usual-time hint
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A bolded /clear from Feishu's rich-text box did not count as a command, so
it started a conversation the Agent answered with a self-check. Commands
now count with their surrounding formatting removed.

Every file a turn wrote under ./outputs was posted to the chat as a reply
to the conversation's first message, including evidence and intermediate
files. Feishu now sends only the files the Agent's reply names, as replies
to the message the turn answers; all files stay in the Web conversation.

The "通常约 N 秒" hint is gone from Feishu cards, the conversation page and
运行; the usual time still decides when a turn reads as slow.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/README.md                |  6 ++--
 example/parsar/README.zh.md             |  8 ++---
 example/parsar/server/feishu.mjs        | 45 +++++++++++++++----------
 example/parsar/server/turns.mjs         |  1 -
 example/parsar/shared/turn-status.d.mts |  1 -
 example/parsar/shared/turn-status.mjs   |  2 --
 example/parsar/src/Runs.tsx             | 12 +------
 example/parsar/src/TurnStatus.tsx       |  3 +-
 example/parsar/src/lib/en.json          |  1 -
 example/parsar/src/lib/product.ts       |  1 -
 example/parsar/tests/feishu.test.mjs    | 11 +++++-
 11 files changed, 46 insertions(+), 45 deletions(-)

diff --git a/example/parsar/README.md b/example/parsar/README.md
index 66feb0c30..dd2cdfbde 100644
--- a/example/parsar/README.md
+++ b/example/parsar/README.md
@@ -84,7 +84,7 @@ Quick Tunnel URLs last only for that tunnel process and may change after restart
 
 ## Web chat
 
-**新对话** opens the home page: choose an Agent, describe the work and send. The sidebar lists recent conversations; **全部对话** opens the full list with search, Agent, source and date filters, plus **运行**, **用量** and **审计日志**. **运行** also sits directly under **新对话** with the number of running conversations. It lists every running turn from Web and Feishu with its stage, waiting time and the Agent's usual first-reply time, and the recently finished ones with their duration, automatic recoveries and plain-language failures; it also shows how many conversations are running, waiting for an answer or failed in the last five minutes. Running turns can be stopped and the latest failed turn of a conversation retried there. Date filters use the browser’s local dates. Usage totals cover all matching records; missing usage remains unknown. Optional model prices are USD per million input/output tokens, frozen when a conversation starts; costs are estimates, not provider bills.
+**新对话** opens the home page: choose an Agent, describe the work and send. The sidebar lists recent conversations; **全部对话** opens the full list with search, Agent, source and date filters, plus **运行**, **用量** and **审计日志**. **运行** also sits directly under **新对话** with the number of running conversations. It lists every running turn from Web and Feishu with its stage and waiting time, and the recently finished ones with their duration, automatic recoveries and plain-language failures; it also shows how many conversations are running, waiting for an answer or failed in the last five minutes. Running turns can be stopped and the latest failed turn of a conversation retried there. Date filters use the browser’s local dates. Usage totals cover all matching records; missing usage remains unknown. Optional model prices are USD per million input/output tokens, frozen when a conversation starts; costs are estimates, not provider bills.
 
 A conversation streams replies and tool activity, groups work steps, navigates user turns with the turn rail, supports follow-ups and cancellation and reopens durable history. Messages sent while the Agent is working, from Web or Feishu, join the running task: **运行** shows it once, and in Feishu it keeps its progress card. Answer business questions on their card. Enter sends; Shift+Enter adds a line. Drafts survive reloads in the same browser tab. The folder button uploads inputs up to 5 MiB while idle, inserts their path into the draft and downloads Artifacts after the live workspace is gone; ask the Agent to save deliverables under `./outputs`. The info button shows the Agent, model, Harness, environment template, Feishu identity, source and the configuration recorded at creation, without variable values, script contents or credentials. When a creation response is lost, the conversation page offers **恢复创建**, which reuses the frozen request and idempotency key.
 
@@ -92,7 +92,7 @@ When a follow-up response is lost while Core resumes the environment, Web keeps
 
 To show thinking, set the Agent’s **高级 → 推理摘要** to `auto` and start a new conversation. When the Harness emits a native summary, **思考过程** appears directly in the conversation, separate from tool steps. While thinking is in progress it shows the latest text; after completion it defaults to a single row. Click to read the full summary, which is restored from history after reconnection. Existing conversations keep the configuration recorded at creation; enabling summaries does not add thinking to old history.
 
-Parsar watches every running turn, from Web and Feishu alike. Before the first output it shows the stage (**正在准备工作环境**, **正在启动**) with the waiting time and the Agent's usual first-reply time from the last seven days. Recovery is automatic and happens only while nothing has run: an Environment that fails to initialize, or a claimed prepared conversation whose first turn has not started within 45 seconds, is replaced once with the configuration the conversation was created with, sent inline, so later edits to the Agent or its template do not reach it; a turn without any output 45 seconds after it started is cancelled and its input resent once; a turn that fails before any output is resent once. Replaced turns are hidden from the conversation and never reported in Feishu. A final failure is explained in plain language with **重试**. **产物** lists the files recent conversations produced, linked to their conversation.
+Parsar watches every running turn, from Web and Feishu alike. Before the first output it shows the stage (**正在准备工作环境**, **正在启动**) with the waiting time. Recovery is automatic and happens only while nothing has run: an Environment that fails to initialize, or a claimed prepared conversation whose first turn has not started within 45 seconds, is replaced once with the configuration the conversation was created with, sent inline, so later edits to the Agent or its template do not reach it; a turn without any output 45 seconds after it started is cancelled and its input resent once; a turn that fails before any output is resent once. Replaced turns are hidden from the conversation and never reported in Feishu. A final failure is explained in plain language with **重试**. **产物** lists the files recent conversations produced, linked to their conversation.
 
 Optional business questions use the declared `ask_user` function. They appear in the conversation and return through public function-result events with stable request IDs. This is information gathering, not execution approval.
 
@@ -180,6 +180,6 @@ It executes a real model and leaves resources for inspection. Live Feishu accept
 
 ### Chat media
 
-Web conversations preview PNG, JPEG, GIF and WebP Session Artifacts beside the reply and provide file downloads. Save outputs under `./outputs`; Markdown image/file links to their `/workspace/outputs/` paths resolve to the persisted artifacts. Other formats, including SVG, remain downloads; external image URLs are not fetched. Feishu sends each artifact as an image or file message, with a 5 MiB limit per nonempty attachment. Upload keys and message identities persist across retries; failed deliveries remain in **消息记录**. Audio and video are downloadable files, without inline playback.
+Web conversations preview PNG, JPEG, GIF and WebP Session Artifacts beside the reply and provide file downloads. Save outputs under `./outputs`; Markdown image/file links to their `/workspace/outputs/` paths resolve to the persisted artifacts. Other formats, including SVG, remain downloads; external image URLs are not fetched. Feishu sends the artifacts the Agent's reply names as image or file messages, replying to the message the turn answers, with a 5 MiB limit per nonempty attachment; other artifacts stay in the Web conversation. Upload keys and message identities persist across retries; failed deliveries remain in **消息记录**. Audio and video are downloadable files, without inline playback.
 
 Bot registration returns `verification_url` and a relative `qr_url`. Show the authorization link and `![飞书授权二维码](<qr_url>)` with the returned path substituted. The PNG is generated inside Parsar, and `GET /app/feishu/provision/<bot_id>/qrcode` rejects expired or completed registrations. Web and Feishu use the same image; neither sends authorization URLs to a third-party QR service.
diff --git a/example/parsar/README.zh.md b/example/parsar/README.zh.md
index 70299d1c0..a16e27ac6 100644
--- a/example/parsar/README.zh.md
+++ b/example/parsar/README.zh.md
@@ -1,6 +1,6 @@
 ---
 source: example/parsar/README.md
-source_hash: 7ae8e170b6cc280187a0f1687deec84955a91e44efc6124f2a858ef7f4f902e0
+source_hash: 6987e7575ecc7fb00bcbf89c676e50ce70f93e9c9fe76e189337ff78bbb661fe
 ---
 
 # Parsar 工作空间
@@ -89,7 +89,7 @@ Quick Tunnel 地址只在该隧道进程运行期间有效，重启可能换地
 
 ## 网页聊天 {#web-chat}
 
-**新对话** 打开首页：选择 Agent、描述工作并发送。侧栏列出最近对话；**全部对话** 打开完整列表，支持搜索以及按 Agent、来源和日期筛选，并提供 **运行**、**用量** 和 **审计日志**。**运行** 也直接放在 **新对话** 下方，并显示正在进行的对话数。它列出网页和飞书中每一轮正在执行的对话，显示所处阶段、已等待时间和这个 Agent 通常的首次回复时间；也列出最近完成的轮次，显示用时、自动恢复次数和通俗的失败原因，并统计正在进行、等你回复和近 5 分钟失败的数量。可以在这里停止正在执行的轮次，或重试对话中最近失败的一轮。日期筛选按浏览器本地日期计算；用量汇总覆盖所有匹配记录，缺失用量保持未知。模型可配置每百万输入/输出 Token 的美元价格，在对话开始时冻结；费用为估算，不是服务商账单。
+**新对话** 打开首页：选择 Agent、描述工作并发送。侧栏列出最近对话；**全部对话** 打开完整列表，支持搜索以及按 Agent、来源和日期筛选，并提供 **运行**、**用量** 和 **审计日志**。**运行** 也直接放在 **新对话** 下方，并显示正在进行的对话数。它列出网页和飞书中每一轮正在执行的对话，显示所处阶段和已等待时间；也列出最近完成的轮次，显示用时、自动恢复次数和通俗的失败原因，并统计正在进行、等你回复和近 5 分钟失败的数量。可以在这里停止正在执行的轮次，或重试对话中最近失败的一轮。日期筛选按浏览器本地日期计算；用量汇总覆盖所有匹配记录，缺失用量保持未知。模型可配置每百万输入/输出 Token 的美元价格，在对话开始时冻结；费用为估算，不是服务商账单。
 
 对话会流式展示回复和工具活动，归组工作步骤，可用对话导航条跳转用户轮次，支持追问和取消，并可重新打开持久历史。Agent 执行中发送的消息（网页和飞书都一样）会并入正在运行的任务：**运行** 里只显示这一轮，飞书里沿用这一轮的进度卡片。业务提问请在提问卡片上回答。Enter 发送，Shift+Enter 换行。草稿在同一浏览器标签页中刷新后保留。文件夹按钮可在空闲时上传最大 5 MiB 的输入文件，并把路径插入草稿；实时工作区回收后仍可下载 Artifacts，请让 Agent 将交付物保存到 `./outputs`。信息按钮展示 Agent、模型、Harness、环境模板、飞书身份、来源以及创建时记录的配置，不含变量值、脚本内容或凭据。创建响应丢失时，对话页提供 **恢复创建**，复用冻结的请求和幂等键。
 
@@ -97,7 +97,7 @@ Quick Tunnel 地址只在该隧道进程运行期间有效，重启可能换地
 
 如需展示 thinking，将 Agent 的 **高级 → 推理摘要** 设为 `auto`，再新建对话。Harness 返回原生摘要时，**思考过程** 会直接出现在对话中，与工具步骤分开。生成时显示最新片段，结束后默认收成一行；点击可阅读完整摘要，断线后从历史恢复。已有对话保留创建时的配置；开启摘要不会为旧历史补出思考内容。
 
-Parsar 会跟踪每一轮正在执行的对话，网页和飞书都一样。出现第一条输出之前，会显示所处阶段（**正在准备工作环境**、**正在启动**）、已等待的时间，以及这个 Agent 近 7 天通常的首次回复时间。自动恢复只在还没有执行任何内容时进行：环境初始化失败，或接管的提前准备会话 45 秒内仍未开始第一轮时，用对话创建时的配置（内联发送）重建一次，之后对 Agent 或环境模板的修改不会影响它；一轮对话开始 45 秒后仍没有任何输出，会取消并重新发送一次输入；在任何输出之前就失败的一轮，会重新发送一次。被替换的轮次不会出现在对话中，也不会发到飞书。最终失败会用通俗的话说明原因，并提供 **重试**。**产物** 汇总最近对话生成的文件，并链接到对应的对话。
+Parsar 会跟踪每一轮正在执行的对话，网页和飞书都一样。出现第一条输出之前，会显示所处阶段（**正在准备工作环境**、**正在启动**）和已等待的时间。自动恢复只在还没有执行任何内容时进行：环境初始化失败，或接管的提前准备会话 45 秒内仍未开始第一轮时，用对话创建时的配置（内联发送）重建一次，之后对 Agent 或环境模板的修改不会影响它；一轮对话开始 45 秒后仍没有任何输出，会取消并重新发送一次输入；在任何输出之前就失败的一轮，会重新发送一次。被替换的轮次不会出现在对话中，也不会发到飞书。最终失败会用通俗的话说明原因，并提供 **重试**。**产物** 汇总最近对话生成的文件，并链接到对应的对话。
 
 可选的业务提问使用声明的 `ask_user` 函数。问题出现在对话中，并通过带稳定请求 ID 的公开 function-result 事件返回。这是收集信息，不是执行审批。
 
@@ -185,6 +185,6 @@ pnpm --filter @oac/parsar-example test:live
 
 ### 聊天中的图片与文件
 
-网页会话在回复旁预览 PNG、JPEG、GIF 和 WebP 产物，并提供文件下载。将输出保存到 `./outputs`；Markdown 中指向 `/workspace/outputs/` 的图片和文件链接会对应到已保存的产物。SVG 等其他格式只提供下载，不加载外部图片地址。飞书将每个产物发送为图片或文件消息，单个附件不能为空且不能超过 5 MiB。上传标识和消息标识会保留以供重试，失败记录显示在**消息记录**中。音视频作为文件下载，暂不在聊天中播放。
+网页会话在回复旁预览 PNG、JPEG、GIF 和 WebP 产物，并提供文件下载。将输出保存到 `./outputs`；Markdown 中指向 `/workspace/outputs/` 的图片和文件链接会对应到已保存的产物。SVG 等其他格式只提供下载，不加载外部图片地址。飞书只发送 Agent 回复里提到的产物，以图片或文件消息回复这一轮所回答的那条消息，单个附件不能为空且不能超过 5 MiB；其他产物留在网页对话中。上传标识和消息标识会保留以供重试，失败记录显示在**消息记录**中。音视频作为文件下载，暂不在聊天中播放。
 
 机器人注册返回 `verification_url` 和相对地址 `qr_url`。同时展示授权链接和 `![飞书授权二维码](<qr_url>)`，将占位符替换为返回的路径。PNG 由 Parsar 本地生成；注册过期或完成后，`GET /app/feishu/provision/<bot_id>/qrcode` 返回失效提示。网页和飞书使用同一张二维码，不会把授权地址发送给第三方二维码服务。
diff --git a/example/parsar/server/feishu.mjs b/example/parsar/server/feishu.mjs
index fbbc16508..270e8331a 100644
--- a/example/parsar/server/feishu.mjs
+++ b/example/parsar/server/feishu.mjs
@@ -6,7 +6,7 @@ const stableId = (value) => {
 };
 import { feishuContextReader } from "./feishu-context.mjs";
 import { explainFailure, turnsAPI } from "./turns.mjs";
-import { typicalWait, waitingHeadline } from "../shared/turn-status.mjs";
+import { waitingHeadline } from "../shared/turn-status.mjs";
 import { feishuSource } from "../shared/feishu-source.mjs";
 import { AppError, text, uuid, transientError } from "./store.mjs";
 
@@ -171,6 +171,13 @@ export function feishuAPI(store) {
   };
 }
 
+// Feishu's rich-text box can bold or code-format a command; the command is
+// what remains without that formatting.
+export function asCommand(text) {
+  const plain = text.replace(/^[*_~`]+|[*_~`]+$/g, "").trim();
+  return /^\/(clear|stop|help)$/.test(plain) || /^\/answer\s/.test(plain) ? plain : text;
+}
+
 const cardTones = {
   in_progress: ["处理中", "blue"],
   requires_action: ["需要你补充信息", "orange"],
@@ -453,9 +460,7 @@ export function formatTurnCard(status, items = [], error, turn, questions = [],
   if (status === "in_progress") {
     const last = items.filter((x) => x.role !== "user" && x.type !== "function_call_output").at(-1);
     const current = !last ? waitingHeadline(turn) : last.type === "message" ? "正在整理回复" : last.type === "reasoning" ? "正在思考" : last.status === "in_progress" ? `正在${step(last)[0]}` : "正在整理结果";
-    const typical = !last && turn?.expected_s && turn.stage !== "retrying" ? typicalWait.replace("{{value0}}", turn.expected_s) : "";
-    const progress = rows.length ? `${rows.length} 步` : typical;
-    const subtitle = [current, progress].filter(Boolean).join(" · ");
+    const subtitle = [current, rows.length ? `${rows.length} 步` : ""].filter(Boolean).join(" · ");
     const body = authorizationText ? excerpt(authorizationText, 8000) : "";
     const earlier = rows.slice(0, -recentRows), recent = rows.slice(-recentRows);
     const budget = cardBudget - bytes(body);
@@ -727,9 +732,10 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
     if (!message.content?.trim() || message.content.length > 40000) return;
     const id = stableId(`${appId}:${message.messageId}`);
     if (store.get("feishu_inbound", id)) return;
+    const content = asCommand(message.content.trim());
     let thread =
       message.chatType === "p2p" &&
-      message.content.trim() !== "/clear"
+      content !== "/clear"
         ? store
             .list("feishu_threads")
             .find(
@@ -783,7 +789,7 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
         thread_id: threadId,
         message_id: message.messageId,
         sender_id: message.senderId,
-        text: message.content.trim(),
+        text: content,
         raw_content_type: message.rawContentType,
         reply_to_message_id: message.replyToMessageId,
         occurred_at: message.createTime || stamp(),
@@ -821,22 +827,25 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
         next_at: 0,
       });
   };
-  const queueMedia = (thread, items, artifacts = []) => {
-    const sources = artifacts.map((file) => ({
-      id: `artifact:${file.id}`,
-      path: artifactContentPath(file.session_id, file.id),
-      name: file.path.split("/").at(-1) || "attachment",
-    }));
-    for (const item of items.filter((item) => item.type === "message" && item.role === "assistant")) {
-      const text = (item.content || []).filter((part) => part.type === "output_text").map((part) => part.text).join("\n");
+  // A Turn's files reply to the message it answers. Only files its reply names
+  // reach the chat; every file stays downloadable in the Web conversation.
+  const queueMedia = (thread, items, artifacts = [], replyTo = thread.root_id) => {
+    const replies = items
+      .filter((item) => item.type === "message" && item.role === "assistant")
+      .map((item) => ({ item, text: (item.content || []).filter((part) => part.type === "output_text").map((part) => part.text).join("\n") }));
+    const said = replies.map(({ text }) => text).join("\n");
+    const sources = artifacts
+      .map((file) => ({ file, name: file.path.split("/").at(-1) || "attachment" }))
+      .filter(({ name }) => said.includes(name))
+      .map(({ file, name }) => ({ id: `artifact:${file.id}`, path: artifactContentPath(file.session_id, file.id), name }));
+    for (const { item, text } of replies)
       for (const path of qrImages(text))
         sources.push({ id: `${item.turn_id}:${path}`, path, name: "feishu-authorization.png" });
-    }
     for (const source of sources) {
       const id = stableId(`${thread.id}:media:${source.id}`);
       if (store.get("feishu_outbound", id)) continue;
       store.transaction(() => {
-        queueReply(id, thread, "");
+        queueReply(id, thread, "", false, replyTo);
         store.put("feishu_outbound", { ...store.get("feishu_outbound", id), media: source });
       });
     }
@@ -1323,7 +1332,7 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
       const items = currentItems.filter(
         (item) => item.turn_id === turns.at(-1)?.id && !ledger.superseded(run.id, item.turn_id),
       );
-      queueMedia(thread, items);
+      queueMedia(thread, items, [], progress?.reply_to);
       const text = formatTurnCard(session.status === "requires_action" && questions.length ? "requires_action" : "in_progress", items, undefined, ledger.summary(run.id), questions, app);
       if (progress?.sent_message_id) {
         if (thread.progress_text !== text) {
@@ -1377,9 +1386,9 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
       if (turn.status === "completed" && (thread.answered_call_ids || []).some((callId) =>
         turnItems.some((item) => item.type === "function_call" && item.call_id === callId) &&
         !turnItems.some((item) => item.type === "function_call_output" && item.call_id === callId))) return;
-      queueMedia(thread, turnItems, artifacts.filter((file) => file.turn_id === turn.id));
       const latest = turn.id === turns.at(-1)?.id;
       const card = cardFor(turn);
+      queueMedia(thread, turnItems, artifacts.filter((file) => file.turn_id === turn.id), card?.reply_to);
       // The display boundary belongs to the newest input; an older Turn shows all of itself.
       const text = formatTurnCard(
         turn.status,
diff --git a/example/parsar/server/turns.mjs b/example/parsar/server/turns.mjs
index 149defb60..9481e2427 100644
--- a/example/parsar/server/turns.mjs
+++ b/example/parsar/server/turns.mjs
@@ -318,7 +318,6 @@ export function turnsAPI(store, core) {
       started_at: turn.started_at,
       done_at: turn.done_at,
       elapsed_s,
-      expected_s,
       first_output_s: turn.output_at ? Math.round((turn.output_at - turn.started_at) / 100) / 10 : null,
       slow: turn.outcome === "running" && !turn.output_at && elapsed_s > Math.max(2 * expected_s, expected_s + 15),
       retries: turn.retries,
diff --git a/example/parsar/shared/turn-status.d.mts b/example/parsar/shared/turn-status.d.mts
index 3938f69a5..63882af55 100644
--- a/example/parsar/shared/turn-status.d.mts
+++ b/example/parsar/shared/turn-status.d.mts
@@ -1,3 +1,2 @@
-export const typicalWait: string;
 export function waitingHeadline(turn?: { stage?: string; slow?: boolean }): string;
 export function stageLabel(turn?: { stage?: string; slow?: boolean }): string;
diff --git a/example/parsar/shared/turn-status.mjs b/example/parsar/shared/turn-status.mjs
index ac1bc5999..c3f6f929d 100644
--- a/example/parsar/shared/turn-status.mjs
+++ b/example/parsar/shared/turn-status.mjs
@@ -1,7 +1,5 @@
 // What a conversation shows about a running Turn. Web and Feishu cards read
 // the same copy; Web translates it, Feishu shows it as is.
-export const typicalWait = "通常约 {{value0}} 秒";
-
 // Before the first output: where the time goes.
 export function waitingHeadline(turn) {
   if (turn?.stage === "retrying") return "响应较慢，正在自动重试";
diff --git a/example/parsar/src/Runs.tsx b/example/parsar/src/Runs.tsx
index 55abcdec7..b6c257097 100644
--- a/example/parsar/src/Runs.tsx
+++ b/example/parsar/src/Runs.tsx
@@ -5,7 +5,7 @@ import { Play } from "lucide-react";
 import { tr } from "./lib/i18n";
 import { api, dateTime } from "./lib/api";
 import { product, useAgents, useTurnOverview, type TurnRow } from "./lib/product";
-import { stageLabel, typicalWait } from "../shared/turn-status.mjs";
+import { stageLabel } from "../shared/turn-status.mjs";
 import { ErrorNotice, PageHeader, RecordTabs } from "./components/shared";
 import { Button } from "./components/ui/button";
 import { EmptyState } from "./components/ui/empty-state";
@@ -106,10 +106,6 @@ function Running({
     mutationFn: () => api.cancelTurn(row.core_session_id, randomUuid()),
   });
   const elapsed = Math.max(0, Math.round((now - row.started_at) / 1000));
-  const waiting =
-    !row.first_output_s &&
-    row.stage !== "waiting_user" &&
-    row.stage !== "retrying";
   return (
     <article className="flex items-center gap-4 px-6 py-4">
       <StatusIcon status="running" />
@@ -128,12 +124,6 @@ function Running({
         )}
       >
         {tr(stageLabel(row))} · {tr("{{value0}} 秒", { value0: elapsed })}
-        {waiting && (
-          <span className="text-fg-muted">
-            {" "}
-            · {tr(typicalWait, { value0: row.expected_s })}
-          </span>
-        )}
       </p>
       {row.stage === "waiting_user" ? (
         <span className="w-16 shrink-0" />
diff --git a/example/parsar/src/TurnStatus.tsx b/example/parsar/src/TurnStatus.tsx
index 823cccd1d..72e3eb817 100644
--- a/example/parsar/src/TurnStatus.tsx
+++ b/example/parsar/src/TurnStatus.tsx
@@ -4,7 +4,7 @@ import { tr } from "./lib/i18n";
 import { product, type SessionRecord } from "./lib/product";
 import { Button } from "./components/ui/button";
 import { ErrorNotice } from "./components/shared";
-import { typicalWait, waitingHeadline } from "../shared/turn-status.mjs";
+import { waitingHeadline } from "../shared/turn-status.mjs";
 
 // Where a running Turn spends its time before the first output, and a plain
 // explanation with a retry when it failed.
@@ -57,7 +57,6 @@ export function TurnStatus({ record }: { record: SessionRecord }) {
         className="rounded-xl bg-surface-subtle px-4 py-3 text-sm text-fg"
       >
         {tr(waitingHeadline(turn))} · {tr("已等待 {{value0}} 秒", { value0: elapsed })}
-        {turn.stage !== "retrying" && ` · ${tr(typicalWait, { value0: turn.expected_s })}`}
       </p>
     </div>
   );
diff --git a/example/parsar/src/lib/en.json b/example/parsar/src/lib/en.json
index 64ae5b2e3..843db3ee3 100644
--- a/example/parsar/src/lib/en.json
+++ b/example/parsar/src/lib/en.json
@@ -449,7 +449,6 @@
   "响应较慢，正在自动重试": "Slow response, retrying automatically",
   "比平时慢，请稍候": "Slower than usual, please wait",
   "已等待 {{value0}} 秒": "waited {{value0}} s",
-  "通常约 {{value0}} 秒": "usually about {{value0}} s",
   "重试中…": "Retrying…",
   "测试 {{value0}}": "Test {{value0}}",
   "测试中…": "Testing…",
diff --git a/example/parsar/src/lib/product.ts b/example/parsar/src/lib/product.ts
index d3a8ad81e..8fcaf9695 100644
--- a/example/parsar/src/lib/product.ts
+++ b/example/parsar/src/lib/product.ts
@@ -65,7 +65,6 @@ export interface TurnSummary {
   kind: "cold" | "prepared" | "followup";
   started_at: number;
   elapsed_s: number;
-  expected_s: number;
   slow: boolean;
   retries: number;
   failure?: string;
diff --git a/example/parsar/tests/feishu.test.mjs b/example/parsar/tests/feishu.test.mjs
index 887dfbf44..b2e0663d7 100644
--- a/example/parsar/tests/feishu.test.mjs
+++ b/example/parsar/tests/feishu.test.mjs
@@ -1471,10 +1471,12 @@ test("Feishu delivers QR during authorization and artifact media once, retaining
     if (path.endsWith(`/${fileId}/content`)) return Buffer.from("report content");
     const value = await f.core(path, ...args);
     if (path.includes("/turns")) return { data: [{ id: turnId, status: waiting ? "in_progress" : "completed" }], has_more: false };
-    if (path.includes("/items")) return { data: [{ id: itemId, turn_id: turnId, type: "message", role: "assistant", content: [{ type: "output_text", text: `Scan [authorize](https://open.feishu.cn/page/cli?user_code=test-code)\n![飞书授权二维码](/app/feishu/provision/${registrationId}/qrcode)` }] }], has_more: false };
+    if (path.includes("/items")) return { data: [{ id: itemId, turn_id: turnId, type: "message", role: "assistant", content: [{ type: "output_text", text: `Scan [authorize](https://open.feishu.cn/page/cli?user_code=test-code)\n![飞书授权二维码](/app/feishu/provision/${registrationId}/qrcode)\n见 chart.png 和 report.txt。` }] }], has_more: false };
+    // Only files the reply names reach the chat; evidence.json stays in the Web conversation.
     if (path.includes("/artifacts")) return { data: waiting ? [] : [
       { id: imageId, session_id: path.split("/")[4], turn_id: turnId, path: "/workspace/outputs/chart.png", size_bytes: png.length },
       { id: fileId, session_id: path.split("/")[4], turn_id: turnId, path: "/workspace/outputs/report.txt", size_bytes: 14 },
+      { id: randomUUID(), session_id: path.split("/")[4], turn_id: turnId, path: "/workspace/outputs/evidence/evidence.json", size_bytes: 2 },
     ], has_more: false };
     if (args[0] === "GET") return { ...value, status: waiting ? "requires_action" : "idle" };
     return value;
@@ -2137,3 +2139,10 @@ test("Parsar's views show a Feishu message without the source line the Agent see
   assert.equal(withoutFeishuSource(`${line}\n记一下明天的 meetup`), "记一下明天的 meetup");
   assert.equal(withoutFeishuSource("[飞书消息] 不是来源行"), "[飞书消息] 不是来源行");
 });
+
+test("a command keeps working when Feishu's rich-text box formats it", async () => {
+  const { asCommand } = await import("../server/feishu.mjs");
+  for (const text of ["/clear", "**/clear**", "`/clear`", "~~/stop~~", "_/help_"]) assert.match(asCommand(text), /^\/(clear|stop|help)$/);
+  assert.equal(asCommand("**/answer call_1 好的**"), "/answer call_1 好的");
+  assert.equal(asCommand("**重点** 明天开会"), "**重点** 明天开会", "ordinary text keeps its formatting");
+});

From dd1d450fb0bf4220aef22fe26df41aac71cb89bd Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Mon, 26 Oct 2026 18:07:36 +0800
Subject: [PATCH 13/19] Keep one Feishu private-chat thread per sender

A private chat got a new thread on every /clear, and later messages found
the sender's first thread rather than the newest, so a /clear could clear
one thread while the next message continued an older conversation. A
private chat now keeps one thread per sender, and /clear starts the next
conversation in it.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/server/feishu.mjs     | 17 ++++++++---------
 example/parsar/tests/feishu.test.mjs | 25 +++++++++++++++++++++++++
 2 files changed, 33 insertions(+), 9 deletions(-)

diff --git a/example/parsar/server/feishu.mjs b/example/parsar/server/feishu.mjs
index 270e8331a..145b97c17 100644
--- a/example/parsar/server/feishu.mjs
+++ b/example/parsar/server/feishu.mjs
@@ -733,18 +733,20 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
     const id = stableId(`${appId}:${message.messageId}`);
     if (store.get("feishu_inbound", id)) return;
     const content = asCommand(message.content.trim());
+    // A private chat is one thread per sender; /clear starts a new conversation
+    // in it. The newest one wins if earlier versions left several.
     let thread =
-      message.chatType === "p2p" &&
-      content !== "/clear"
+      message.chatType === "p2p"
         ? store
             .list("feishu_threads")
-            .find(
+            .filter(
               (row) =>
                 row.app_id === appId &&
                 row.chat_id === message.chatId &&
                 row.sender_id === message.senderId &&
                 row.chat_type === "p2p",
             )
+            .sort((a, b) => (b.created_at || 0) - (a.created_at || 0))[0]
         : threadFor(appId, message);
     if (
       thread &&
@@ -1008,14 +1010,11 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
     if (["/clear", "/help"].includes(row.text)) {
       if (row.text === "/clear") {
         // Work in the cleared conversation would continue unseen; stop it.
-        const previous = row.chat_type === "p2p"
-          ? store.list("feishu_threads").filter((t) => t.id !== thread.id && t.app_id === thread.app_id && t.chat_id === thread.chat_id && t.sender_id === thread.sender_id && t.chat_type === "p2p").at(-1)
-          : thread;
-        const run = previous && store.get("sessions", previous.session_id);
+        const run = store.get("sessions", thread.session_id);
         if (run?.core_session_id)
           await core(`/v1/agents/sessions/${run.core_session_id}/events`, "POST", { events: [{ type: "agent.session.input.cancel" }] }, `${row.id}:clear`).catch(() => {});
-        // A private chat already got a fresh thread on receipt; a topic keeps its root.
-        if (row.chat_type !== "p2p" && thread.first_message_id !== row.id) rotateThread();
+        // The thread starts its next conversation, unless this /clear opened it.
+        if (thread.first_message_id !== row.id) rotateThread();
       }
       queueReply(
         stableId(`${row.id}:command`),
diff --git a/example/parsar/tests/feishu.test.mjs b/example/parsar/tests/feishu.test.mjs
index b2e0663d7..646aaa5a8 100644
--- a/example/parsar/tests/feishu.test.mjs
+++ b/example/parsar/tests/feishu.test.mjs
@@ -2146,3 +2146,28 @@ test("a command keeps working when Feishu's rich-text box formats it", async ()
   assert.equal(asCommand("**/answer call_1 好的**"), "/answer call_1 好的");
   assert.equal(asCommand("**重点** 明天开会"), "**重点** 明天开会", "ordinary text keeps its formatting");
 });
+
+test("a private chat keeps one thread per sender, and /clear always starts its next conversation", async (t) => {
+  const f = await feishu(t);
+  const config = await f.api("GET", `/app/feishu/bots/${botId}`);
+  await f.api("PUT", `/app/feishu/bots/${botId}`, { ...config, direct: true });
+  const worker = f.create();
+  const dm = { ...f.message, chatType: "p2p", mentionedBot: false };
+  const say = async (messageId, content) => {
+    worker.receive("cli_0123456789abcdef", { ...dm, messageId, content });
+    await worker.tick();
+  };
+  const sessionOf = (messageId) => {
+    const row = f.store.list("feishu_inbound").find((r) => r.message_id === messageId);
+    return f.store.get("feishu_threads", row.thread_id).session_id;
+  };
+  await say("om_a", "记一下 meetup");
+  const first = sessionOf("om_a");
+  await say("om_clear_1", "**/clear**");
+  await say("om_clear_2", "/clear");
+  await say("om_b", "再记一下 meetup");
+  assert.equal(f.store.list("feishu_threads").filter((row) => row.chat_type === "p2p").length, 1);
+  assert.notEqual(sessionOf("om_b"), first, "the message after /clear starts a new conversation");
+  await say("om_c", "补充：下午三点");
+  assert.equal(sessionOf("om_c"), sessionOf("om_b"));
+});

From 712f049b973b1c368dc54b4d7db9b9af3de93ccf Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Mon, 26 Oct 2026 18:23:14 +0800
Subject: [PATCH 14/19] Keep every step in Feishu cards and never send people
 to the Web
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A long turn dropped its oldest steps from the card and said "更早的 N 步见
网页对话", and a few Feishu replies told people to check the Web. Every step
now stays in the card: the oldest first lose their tool output, then
shrink to one line, and only a turn with hundreds of steps summarizes its
oldest ones in one line. Feishu replies no longer mention the Web.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/README.md             |  2 +-
 example/parsar/README.zh.md          |  4 +-
 example/parsar/server/feishu.mjs     | 69 ++++++++++++++++------------
 example/parsar/tests/feishu.test.mjs |  3 +-
 4 files changed, 45 insertions(+), 33 deletions(-)

diff --git a/example/parsar/README.md b/example/parsar/README.md
index dd2cdfbde..a812eab35 100644
--- a/example/parsar/README.md
+++ b/example/parsar/README.md
@@ -129,7 +129,7 @@ Optional business questions use the declared `ask_user` function. They appear in
 4. Text, rich posts, images, files, audio and video, quoted messages and merged forwards are normalized before dispatch. Attachment limits are eight resources and 5 MiB total. Follow-up files wait until the conversation is idle. Quoted messages are read up to four levels; earlier group messages are not read.
 5. Commands: `/clear` clears the context: it stops any running work and the next message starts a new conversation, in a private chat or in the same group topic. `/stop` stops the current task; it takes priority over queued follow-ups and recovers an uncertain creation before stopping it. `/answer <call_id> <text>` answers a pending business question, and a plain reply answers when only one is pending. `/help` lists the commands.
 
-Accepted messages are committed to SQLite before the WebSocket ACK; request IDs and frozen payloads survive retries and restarts. The worker edits one compact progress card in place, includes any pending business question in that card, and finishes it with the result. Each reply shows only the current exchange, including answers that resume the same Core Turn. The answer stays visible; while awaiting a business decision, the question takes priority and its supporting context is collapsed, except QR authorization instructions. The card has a colored header for its status. Its process is one timeline in the order things happened. Only commentary stays open as plain text; thinking folds behind its first sentence, and consecutive tool calls fold into one row (such as `运行 3 条命令` with their total time, failures or 进行中) in which each call folds again behind its command, showing parameters, output, error and exit code. While running, the header also says what is happening now and how many steps have run. A running card shows the latest four steps and folds the earlier ones into a tinted block above a divider; a finished card puts the answer first and folds the whole process into a tinted **处理过程** block; a failed card shows the failed step right under its cause. Long content is cut to marked, byte-bounded excerpts, and the oldest steps leave the card first to stay within Feishu's card size limit. Progress uses five-second polling. Complete history and Artifacts remain in the Web conversation. Settled threads stop polling after five minutes and wake on new messages. **消息记录** lists the latest 100 deliveries plus unresolved ones; **重试** keeps the original identity. A failed inbound message blocks later messages in that thread. Uncertain outbound sends are not replayed beyond 55 minutes. Disabling a bot pauses delivery without cancelling Core work.
+Accepted messages are committed to SQLite before the WebSocket ACK; request IDs and frozen payloads survive retries and restarts. The worker edits one compact progress card in place, includes any pending business question in that card, and finishes it with the result. Each reply shows only the current exchange, including answers that resume the same Core Turn. The answer stays visible; while awaiting a business decision, the question takes priority and its supporting context is collapsed, except QR authorization instructions. The card has a colored header for its status. Its process is one timeline in the order things happened. Only commentary stays open as plain text; thinking folds behind its first sentence, and consecutive tool calls fold into one row (such as `运行 3 条命令` with their total time, failures or 进行中) in which each call folds again behind its command, showing parameters, output, error and exit code. While running, the header also says what is happening now and how many steps have run. A running card shows the latest four steps and folds the earlier ones into a tinted block above a divider; a finished card puts the answer first and folds the whole process into a tinted **处理过程** block; a failed card shows the failed step right under its cause. Long content is cut to marked, byte-bounded excerpts. Every step stays in the card: to stay within Feishu's card size limit, the oldest steps first drop their tool output, then shrink to one line, and only a turn with hundreds of steps summarizes its oldest ones in one line. Feishu messages never send people to the Web. Progress uses five-second polling. Complete history and Artifacts remain in the Web conversation. Settled threads stop polling after five minutes and wake on new messages. **消息记录** lists the latest 100 deliveries plus unresolved ones; **重试** keeps the original identity. A failed inbound message blocks later messages in that thread. Uncertain outbound sends are not replayed beyond 55 minutes. Disabling a bot pauses delivery without cancelling Core work.
 
 ### Bot identity
 
diff --git a/example/parsar/README.zh.md b/example/parsar/README.zh.md
index a16e27ac6..4d8187da1 100644
--- a/example/parsar/README.zh.md
+++ b/example/parsar/README.zh.md
@@ -1,6 +1,6 @@
 ---
 source: example/parsar/README.md
-source_hash: 6987e7575ecc7fb00bcbf89c676e50ce70f93e9c9fe76e189337ff78bbb661fe
+source_hash: 8a1c39be702ff67649505fede10d84d6fdbafe04807a17c3bff093be80731b13
 ---
 
 # Parsar 工作空间
@@ -134,7 +134,7 @@ Parsar 会跟踪每一轮正在执行的对话，网页和飞书都一样。出
 4. 文本、富文本、图片、文件、音视频、引用消息和合并转发会在投递前规范化。附件上限为 8 个、合计 5 MiB。后续消息中的文件会等到对话空闲后写入。引用消息最多读取四层；不读取更早的群消息。
 5. 命令：`/clear` 清空上下文：停止正在执行的任务，下一条消息开始新对话，私聊和群聊话题都适用（群聊仍在同一个话题里）。`/stop` 停止当前任务，优先于排队中的追问，并会先确认不确定的创建再停止。`/answer <call_id> <回答>` 回答待处理的业务问题；只有一个待回答的问题时，直接回复即可。`/help` 列出这些命令。
 
-收到的消息在 WebSocket ACK 之前写入 SQLite；请求 ID 和冻结的负载在重试与重启后保持不变。工作器原地更新一张简洁进度卡片，将待回答的问题合并到卡片中，结束后改成结果。每次回复只展示当前交流的内容，包括回答提问后继续同一 Core Turn 的情况。正文突出当前回复；等待业务选择时优先展示问题，将补充说明折叠，二维码授权说明保持可见。卡片顶部是带颜色的状态标题栏。处理过程按发生顺序排成一条时间线。只有说明直接显示文字；思考折叠在第一句后面；连续的工具调用折叠成一行（例如“运行 3 条命令”，附总用时、失败次数或“进行中”），展开后每次调用再折叠在它的命令后面，可查看参数、输出、错误和退出码。执行中时，标题栏还会显示当前在做什么和已执行的步数；卡片显示最近四步，更早的步骤折叠进分隔线上方的浅色区块；完成后回复放在最前面，整个过程折叠进浅色的 **处理过程** 区块；失败时出错的那一步紧跟在失败原因下面。长内容按字节限制截取并明确标注；为了不超过飞书卡片的大小限制，最早的步骤会先移出卡片。进度每五秒轮询一次。完整历史和 Artifacts 保留在网页对话中。已结束的话题在五分钟后停止轮询，收到新消息时恢复。**消息记录** 列出最近 100 条投递以及未解决的记录；**重试** 保留原有标识。入站消息失败会阻塞该话题后续消息。不确定的出站消息超过 55 分钟后不再重放。停用机器人会暂停投递，但不会取消 Core 中的执行。
+收到的消息在 WebSocket ACK 之前写入 SQLite；请求 ID 和冻结的负载在重试与重启后保持不变。工作器原地更新一张简洁进度卡片，将待回答的问题合并到卡片中，结束后改成结果。每次回复只展示当前交流的内容，包括回答提问后继续同一 Core Turn 的情况。正文突出当前回复；等待业务选择时优先展示问题，将补充说明折叠，二维码授权说明保持可见。卡片顶部是带颜色的状态标题栏。处理过程按发生顺序排成一条时间线。只有说明直接显示文字；思考折叠在第一句后面；连续的工具调用折叠成一行（例如“运行 3 条命令”，附总用时、失败次数或“进行中”），展开后每次调用再折叠在它的命令后面，可查看参数、输出、错误和退出码。执行中时，标题栏还会显示当前在做什么和已执行的步数；卡片显示最近四步，更早的步骤折叠进分隔线上方的浅色区块；完成后回复放在最前面，整个过程折叠进浅色的 **处理过程** 区块；失败时出错的那一步紧跟在失败原因下面。长内容按字节限制截取并明确标注。每一步都留在卡片里：为了不超过飞书卡片的大小限制，最早的步骤先去掉命令输出，再压成一行；只有几百步的任务，才会把最早的若干步合成一行摘要。飞书消息里从不引导用户去网页。进度每五秒轮询一次。完整历史和 Artifacts 保留在网页对话中。已结束的话题在五分钟后停止轮询，收到新消息时恢复。**消息记录** 列出最近 100 条投递以及未解决的记录；**重试** 保留原有标识。入站消息失败会阻塞该话题后续消息。不确定的出站消息超过 55 分钟后不再重放。停用机器人会暂停投递，但不会取消 Core 中的执行。
 
 ### 机器人身份 {#bot-identity}
 
diff --git a/example/parsar/server/feishu.mjs b/example/parsar/server/feishu.mjs
index 145b97c17..da9ed2fe0 100644
--- a/example/parsar/server/feishu.mjs
+++ b/example/parsar/server/feishu.mjs
@@ -342,7 +342,8 @@ function toolRow(item) {
 }
 
 // Consecutive tool calls fold into one row; each call folds again inside it.
-function toolsRow(items) {
+// With less room, calls keep only their titles, then the group is one line.
+function toolsRow(items, level = 0) {
   const failed = items.filter((item) => item.status === "failed").length;
   const state = items.some((item) => item.status === "in_progress")
     ? grey("进行中")
@@ -355,30 +356,41 @@ function toolsRow(items) {
   const title = items.length === 1
     ? oneLine(label, detail, state)
     : [grey(items.every((item) => step(item)[0] === "运行") ? `运行 ${items.length} 条命令` : `调用 ${items.length} 次工具`), state].filter(Boolean).join(" ");
-  return panel({ title, elements: items.map(toolRow) });
+  if (level >= 2 || (level === 1 && items.length === 1)) return { tag: "markdown", content: title };
+  const calls = level === 1
+    ? items.map((item) => ({ tag: "markdown", content: oneLine(...step(item), toolState(item)) }))
+    : items.map(toolRow);
+  return panel({ title, elements: calls });
 }
 
-// Only commentary stays open; thinking and tool calls fold behind one line.
-function timelineRow(entry) {
-  if (entry.type === "say") return { tag: "markdown", content: excerpt(entry.text, 800) };
-  if (entry.type === "think")
-    return panel({ title: oneLine("思考", entry.text.split("\n").find((line) => line.trim()) || ""), content: excerpt(entry.text, 1500) });
-  return toolsRow(entry.items);
+// One step at decreasing detail: everything; tool calls without their output;
+// thinking and tool groups as one line; commentary shortened.
+function timelineRow(entry, level = 0) {
+  if (entry.type === "say") return { tag: "markdown", content: excerpt(entry.text, level < 3 ? 4000 : 400) };
+  if (entry.type === "think") {
+    const title = oneLine("思考", entry.text.split("\n").find((line) => line.trim()) || "");
+    return level < 2 ? panel({ title, content: excerpt(entry.text, 1500) }) : { tag: "markdown", content: title };
+  }
+  return toolsRow(entry.items, level);
 }
 
-// The oldest rows leave the card first when it would grow past Feishu's
-// limit; a single row that is still too large sheds its oldest calls.
-function fitRows(rows, budget, unit = "步") {
-  const kept = [...rows];
-  let dropped = 0;
-  while (kept.length > 1 && bytes(kept) > budget) {
-    kept.shift();
-    dropped++;
-  }
-  const [only] = kept;
-  if (kept.length === 1 && bytes(kept) > budget && only.elements?.length > 1)
-    kept[0] = { ...only, elements: fitRows(only.elements, budget - (bytes(only) - bytes(only.elements)), "次调用") };
-  return dropped ? [{ tag: "markdown", content: grey(`更早的 ${dropped} ${unit}见网页对话`) }, ...kept] : kept;
+// Every step stays in the card. When it would pass Feishu's size limit, the
+// oldest steps give up detail first.
+function fitRows(entries, budget) {
+  const rows = entries.map((entry) => timelineRow(entry));
+  for (let level = 1; level <= 3 && bytes(rows) > budget; level++)
+    for (let i = 0; i < entries.length && bytes(rows) > budget; i++) {
+      rows[i] = timelineRow(entries[i], level);
+    }
+  // Hundreds of steps: the oldest become one summary line.
+  let merged = 0;
+  while (merged < entries.length - 1 && bytes(rows.slice(merged)) + 200 > budget) merged++;
+  if (!merged) return rows;
+  const counted = entries.slice(0, merged);
+  const commands = counted.flatMap((entry) => entry.items || []).length;
+  const thoughts = counted.filter((entry) => entry.type === "think").length;
+  const summary = [commands && `运行 ${commands} 条命令`, thoughts && `思考 ${thoughts} 次`].filter(Boolean).join("、");
+  return [{ tag: "markdown", content: grey(`第 1–${merged} 步${summary ? `：${summary}` : ""}`) }, ...rows.slice(merged)];
 }
 
 // A tool-result answer resumes the same Core Turn. Display only the exchange
@@ -455,19 +467,18 @@ export function formatTurnCard(status, items = [], error, turn, questions = [],
     else rows.push(entry.type === "tool" ? { type: "tools", items: [entry.item] } : entry);
     return rows;
   }, []);
-  const rows = grouped.map(timelineRow);
+  const rows = grouped;
   const tools = entries.filter((entry) => entry.type === "tool").map((entry) => entry.item);
   if (status === "in_progress") {
     const last = items.filter((x) => x.role !== "user" && x.type !== "function_call_output").at(-1);
     const current = !last ? waitingHeadline(turn) : last.type === "message" ? "正在整理回复" : last.type === "reasoning" ? "正在思考" : last.status === "in_progress" ? `正在${step(last)[0]}` : "正在整理结果";
     const subtitle = [current, rows.length ? `${rows.length} 步` : ""].filter(Boolean).join(" · ");
     const body = authorizationText ? excerpt(authorizationText, 8000) : "";
-    const earlier = rows.slice(0, -recentRows), recent = rows.slice(-recentRows);
-    const budget = cardBudget - bytes(body);
-    const shown = fitRows(recent, budget);
+    const fitted = fitRows(rows, cardBudget - bytes(body) - 600);
+    const earlier = fitted.slice(0, -recentRows), shown = fitted.slice(-recentRows);
     // Earlier steps sit in a tinted block above a rule that separates the latest ones.
     const fold = earlier.length
-      ? [panel({ title: grey(`更早的 ${earlier.length} 步`), elements: fitRows(earlier, budget - bytes(shown)), block: true }), { tag: "hr" }]
+      ? [panel({ title: grey(`更早的 ${earlier.length} 步`), elements: earlier, block: true }), { tag: "hr" }]
       : [];
     return statusCard(status, body, [...fold, ...shown], subtitle);
   }
@@ -865,7 +876,7 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
   };
   const cancel = async (row) => {
     const thread = store.get("feishu_threads", row.thread_id);
-    if (!thread) return reject(row, "话题关联不可用，请在 Web 中检查。");
+    if (!thread) return reject(row, "这条消息没能接上对话，请重新发送。");
     let run = store.get("sessions", thread.session_id);
     // Resolve an uncertain initial creation before cancelling its actual Session.
     if (run && !run.core_session_id && !run.deleted_at)
@@ -980,7 +991,7 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
   };
   const inbound = async (row) => {
     let thread = store.get("feishu_threads", row.thread_id);
-    if (!thread) return reject(row, "话题关联不可用，请在 Web 中检查。");
+    if (!thread) return reject(row, "这条消息没能接上对话，请重新发送。");
     // A new Session for this chat or topic; the next message starts it.
     const rotateThread = () => {
       thread = {
@@ -1523,7 +1534,7 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
             ? await product("GET", row.media.path, {})
             : await core(row.media.path, "GET");
           if (!Buffer.isBuffer(bytes) || !bytes.length || bytes.length > maxMediaBytes)
-            throw new AppError(413, "附件为空或超过 5 MiB，请在网页会话中下载。");
+            throw new AppError(413, "附件为空或超过 5 MiB，飞书发送不了。");
           uploaded = await channel.upload(bytes, row.media.name);
           store.put("feishu_outbound", { ...store.get("feishu_outbound", row.id), uploaded_media: uploaded });
         }
diff --git a/example/parsar/tests/feishu.test.mjs b/example/parsar/tests/feishu.test.mjs
index 646aaa5a8..ee9df2413 100644
--- a/example/parsar/tests/feishu.test.mjs
+++ b/example/parsar/tests/feishu.test.mjs
@@ -1710,7 +1710,8 @@ test("large multilingual diagnostics stay below the Feishu card payload limit",
   for (const status of ["in_progress", "completed", "requires_action"]) {
     const payload = formatTurnCard(status, items, undefined, undefined, [{ arguments: { question: large, options: [large] } }]);
     assert.ok(Buffer.byteLength(payload) < 30000, `${status}: ${Buffer.byteLength(payload)}`);
-    assert.match(payload, /更早的 \d+ (步|次调用)见网页对话/, "the oldest rows leave the card first");
+    assert.doesNotMatch(payload, /网页/, "the card never sends people to the Web");
+    assert.match(payload, /调用 20 次工具|第 1–\d+ 步/, "every step stays in the card, at less detail");
     assert.match(payload, /内容较长，已截取/);
   }
 });

From d8fabe64c6e0c8f27210dc0c8a8d9b90c49b9149 Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Mon, 26 Oct 2026 18:33:19 +0800
Subject: [PATCH 15/19] Delete a Feishu bot at once

Deleting a bot required stopping it first and refused while any message
was still queued for it, so a stuck delivery made a bot impossible to
delete. Deleting now stops the bot and drops what it had not delivered;
conversations and delivered messages stay.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/server/feishu.mjs     | 21 ++++++++-------------
 example/parsar/src/Feishu.tsx        |  4 ++--
 example/parsar/src/lib/en.json       |  1 -
 example/parsar/tests/feishu.test.mjs | 15 +++++++++++++++
 4 files changed, 25 insertions(+), 16 deletions(-)

diff --git a/example/parsar/server/feishu.mjs b/example/parsar/server/feishu.mjs
index da9ed2fe0..b0bd28a72 100644
--- a/example/parsar/server/feishu.mjs
+++ b/example/parsar/server/feishu.mjs
@@ -90,20 +90,15 @@ export function feishuAPI(store) {
       groups: false,
     };
     if (method === "GET") return publicFeishu(old);
+    // Deleting a bot stops it and drops what it had not delivered yet;
+    // conversations and delivered messages stay.
     if (method === "DELETE") {
-      if (old.enabled) throw new AppError(409, "请先停用机器人。");
-      if (
-        [
-          ...store.list("feishu_inbound"),
-          ...store.list("feishu_outbound"),
-        ].some(
-          (row) =>
-            row.app_id === old.app_id &&
-            !["delivered", "rejected"].includes(row.state),
-        )
-      )
-        throw new AppError(409, "机器人仍有未完成投递，请先处理。");
-      store.remove("feishu_bots", id);
+      store.transaction(() => {
+        for (const kind of ["feishu_inbound", "feishu_outbound"])
+          for (const row of store.list(kind))
+            if (row.app_id === old.app_id && !["delivered", "rejected"].includes(row.state)) store.remove(kind, row.id);
+        store.remove("feishu_bots", id);
+      });
       return {};
     }
     if (method !== "PUT") throw new AppError(405, "Method not allowed.");
diff --git a/example/parsar/src/Feishu.tsx b/example/parsar/src/Feishu.tsx
index 2b4c6fe28..7931a174e 100644
--- a/example/parsar/src/Feishu.tsx
+++ b/example/parsar/src/Feishu.tsx
@@ -239,8 +239,8 @@ function BotCard({ bot }: { bot: FeishuBot }) {
             variant="ghost"
             size="icon"
             aria-label={tr("删除机器人")}
-            title={bot.enabled ? tr("请先停用机器人") : tr("删除机器人")}
-            disabled={bot.enabled || remove.isPending}
+            title={tr("删除机器人")}
+            disabled={remove.isPending}
             onClick={() => {
               if (confirm(tr("删除机器人 {{value0}}？", { value0: bot.name })))
                 remove.mutate();
diff --git a/example/parsar/src/lib/en.json b/example/parsar/src/lib/en.json
index 843db3ee3..4b32e9341 100644
--- a/example/parsar/src/lib/en.json
+++ b/example/parsar/src/lib/en.json
@@ -353,7 +353,6 @@
   "收起应用凭证": "Hide app credentials",
   "应用凭证": "App credentials",
   "删除机器人": "Delete bot",
-  "请先停用机器人": "Disable the bot first",
   "删除机器人 {{value0}}？": "Delete bot {{value0}}?",
   "停用": "Disable",
   "保存并启用": "Save and enable",
diff --git a/example/parsar/tests/feishu.test.mjs b/example/parsar/tests/feishu.test.mjs
index ee9df2413..e358ac7ed 100644
--- a/example/parsar/tests/feishu.test.mjs
+++ b/example/parsar/tests/feishu.test.mjs
@@ -2172,3 +2172,18 @@ test("a private chat keeps one thread per sender, and /clear always starts its n
   await say("om_c", "补充：下午三点");
   assert.equal(sessionOf("om_c"), sessionOf("om_b"));
 });
+
+test("a bot deletes at once, running or with deliveries pending; delivered history stays", async (t) => {
+  const f = await feishu(t);
+  const bot = await f.api("GET", `/app/feishu/bots/${botId}`);
+  await f.api("PUT", `/app/feishu/bots/${botId}`, { ...bot, enabled: true });
+  const appId = "cli_0123456789abcdef";
+  f.store.put("feishu_outbound", { id: "pending", app_id: appId, state: "queued" });
+  f.store.put("feishu_inbound", { id: "waiting", app_id: appId, state: "queued" });
+  f.store.put("feishu_outbound", { id: "sent", app_id: appId, state: "delivered" });
+  await f.api("DELETE", `/app/feishu/bots/${botId}`, {});
+  assert.equal(f.store.get("feishu_bots", botId), null);
+  assert.equal(f.store.get("feishu_outbound", "pending"), null);
+  assert.equal(f.store.get("feishu_inbound", "waiting"), null);
+  assert.equal(f.store.get("feishu_outbound", "sent").state, "delivered");
+});

From af416253eb81334837850c76e51c57eb7bd7d199 Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Mon, 26 Oct 2026 18:59:45 +0800
Subject: [PATCH 16/19] Request only Feishu scopes the organization grants
 without review

The QR code requested 48 hand-picked scopes, a dozen of which need review
in the organization: calendar event, Drive and task write scopes. It now
requests 137 useful app-identity scopes from the organization's list of
scopes granted without review, so a new bot works with messages, Base,
Calendar, Docs, Sheets, Slides, Wiki, Tasks and meetings at once, and
leaves scopes that need review for when an Agent truly needs them. The QR
image grows to 640 pixels for the longer address.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/README.md                      |  2 +-
 example/parsar/README.zh.md                   |  4 +-
 example/parsar/server/feishu-registration.mjs | 63 ++++++++++++++-----
 3 files changed, 51 insertions(+), 18 deletions(-)

diff --git a/example/parsar/README.md b/example/parsar/README.md
index a812eab35..3cc73d1a9 100644
--- a/example/parsar/README.md
+++ b/example/parsar/README.md
@@ -121,7 +121,7 @@ Optional business questions use the declared `ask_user` function. They appear in
 
 ## Feishu
 
-**飞书接入** shows one card per bot. **添加机器人** offers **扫码创建**, which provisions an application through Feishu’s device flow with the entered name and app-identity scopes pre-filled on the confirmation page: `im:message.group_msg` plus reading and writing Base, Calendar, Docs, Drive, Sheets, Wiki and Tasks and basic contact information ([the list](server/feishu-registration.mjs)), or **已有应用** with an App ID and App Secret. A new bot stays disabled until configured. Secrets stay in the restricted local database. The official SDK owns authentication, normalization and long connections; no inbound public callback is needed.
+**飞书接入** shows one card per bot. **添加机器人** offers **扫码创建**, which provisions an application through Feishu’s device flow with the entered name and app-identity scopes pre-filled on the confirmation page: `im:message.group_msg` and the messaging, Base, Calendar, Docs, Sheets, Slides, Wiki, Tasks, meetings and contact scopes the organization grants without review ([the list](server/feishu-registration.mjs)); scopes that need review are applied for only when an Agent needs them, or **已有应用** with an App ID and App Secret. A new bot stays disabled until configured. Secrets stay in the restricted local database. The official SDK owns authentication, normalization and long connections; no inbound public callback is needed.
 
 1. On the card, choose the **Agent**, turn on **私聊** and/or **群聊**, then **保存并启用**. Enabling requires credentials, an Agent with an environment template and at least one of the two. With **群聊** on, the bot answers mentions in every group it has joined; adding the bot to a group is all that is needed. Who can add the bot is controlled by the app’s availability in the developer console.
 2. In the developer console, enable the bot, long-connection event delivery and `im.message.receive_v1`, publish the app and add it to the target groups. Grant mention receipt and send-as-bot permissions; direct messages, message resources and reactions need their own scopes. A missing reaction permission does not discard a message.
diff --git a/example/parsar/README.zh.md b/example/parsar/README.zh.md
index 4d8187da1..7ff4a8042 100644
--- a/example/parsar/README.zh.md
+++ b/example/parsar/README.zh.md
@@ -1,6 +1,6 @@
 ---
 source: example/parsar/README.md
-source_hash: 8a1c39be702ff67649505fede10d84d6fdbafe04807a17c3bff093be80731b13
+source_hash: 5813b35ccdceece56c8a2463186d89e1f50b20577073d9f2a6ffc7b276647305
 ---
 
 # Parsar 工作空间
@@ -126,7 +126,7 @@ Parsar 会跟踪每一轮正在执行的对话，网页和飞书都一样。出
 
 ## 飞书 {#feishu}
 
-**飞书接入** 为每个机器人展示一张卡片。**添加机器人** 提供 **扫码创建**（通过飞书设备流创建应用，扫码后的确认页会预先填好输入的名称和应用身份权限：`im:message.group_msg`，以及多维表格、日历、文档、云空间、电子表格、知识库、任务的读写和通讯录基本信息，[完整清单](server/feishu-registration.mjs)）和 **已有应用**（填写 App ID 与 App Secret）。新机器人在配置完成前保持停用。密钥保存在受限的本地数据库中。官方 SDK 负责鉴权、消息规范化和长连接，不需要公网回调。
+**飞书接入** 为每个机器人展示一张卡片。**添加机器人** 提供 **扫码创建**（通过飞书设备流创建应用，扫码后的确认页会预先填好输入的名称和应用身份权限：`im:message.group_msg`，以及企业免审的消息、多维表格、日历、文档、电子表格、幻灯片、知识库、任务、会议和通讯录权限，[完整清单](server/feishu-registration.mjs)；需要审核的权限只在 Agent 确实用到时再申请）和 **已有应用**（填写 App ID 与 App Secret）。新机器人在配置完成前保持停用。密钥保存在受限的本地数据库中。官方 SDK 负责鉴权、消息规范化和长连接，不需要公网回调。
 
 1. 在卡片上选择 **Agent**，打开 **私聊** 和/或 **群聊**，然后 **保存并启用**。启用需要应用凭证、已配置环境模板的 Agent，以及两者至少开启一项。打开 **群聊** 后，机器人会回复它所在的任何群里的 @ 消息，把机器人拉进群即可使用。谁能添加机器人由开发者后台中应用的可用范围控制。
 2. 在开发者后台启用机器人、长连接事件推送和 `im.message.receive_v1`，发布应用并把它加入目标群。授予接收 @ 消息和以机器人身份发送消息的权限；私聊、消息资源和表情回复需要各自的权限。缺少表情权限不会丢弃消息。
diff --git a/example/parsar/server/feishu-registration.mjs b/example/parsar/server/feishu-registration.mjs
index b300e1f99..253569598 100644
--- a/example/parsar/server/feishu-registration.mjs
+++ b/example/parsar/server/feishu-registration.mjs
@@ -5,21 +5,54 @@ import { AppError, uuid, text } from "./store.mjs";
 
 // App-identity scopes the new app requests on top of the platform's default
 // template, so an Agent can work with Feishu data without its users applying
-// for each scope later. Without im:message.group_msg the bot never receives
-// topic replies that do not mention it.
+// for each scope later. All of them are ones the organization grants without
+// review; scopes that need review are left for when an Agent truly needs them.
+// Without im:message.group_msg the bot never receives topic replies that do
+// not mention it.
 export const botScopes = [
-  "im:message.group_msg", "im:chat.members:read",
-  "contact:user.base:readonly", "contact:user.id:readonly", "contact:department.base:readonly",
-  "bitable:app", "base:app:read", "base:app:create", "base:app:update", "base:table:read", "base:table:create", "base:table:update",
-  "base:field:read", "base:field:create", "base:field:update", "base:record:read", "base:record:create", "base:record:update",
-  "base:record:delete", "base:view:read",
-  "calendar:calendar", "calendar:calendar:readonly", "calendar:calendar:read", "calendar:calendar.calendar:readonly",
-  "calendar:calendar.event:read", "calendar:calendar.event:create", "calendar:calendar.event:update", "calendar:calendar.event:delete",
-  "calendar:calendar.free_busy:read",
-  "docx:document", "docx:document:create", "drive:drive", "drive:drive:readonly", "drive:file", "drive:file:upload", "drive:file:download",
-  "sheets:spreadsheet", "sheets:spreadsheet:readonly", "sheets:spreadsheet:create",
-  "wiki:wiki", "wiki:wiki:readonly", "wiki:node:read", "wiki:node:create", "wiki:space:read",
-  "task:task:read", "task:task:write", "task:tasklist:read", "task:tasklist:write",
+  // Messages and groups
+  "im:message", "im:message:readonly", "im:message:send_as_bot", "im:message:send_multi_users", "im:message:update",
+  "im:message.group_msg", "im:message.group_msg.include_bot:read", "im:message.group_at_msg:readonly",
+  "im:message.group_at_msg.include_bot:readonly", "im:message.p2p_msg:readonly", "im:message.pins:read", "im:message.pins:write_only",
+  "im:message.reactions:read", "im:message.reactions:write_only", "im:resource",
+  "im:chat", "im:chat:read", "im:chat:readonly", "im:chat:create", "im:chat:update", "im:chat.members:read",
+  "im:chat.members:write_only", "im:chat.members:bot_access", "im:chat.announcement:read", "im:chat.announcement:write_only",
+  "im:chat.moderation:read", "im:chat.tabs:read", "im:chat.access_event.bot_p2p_chat:read", "search:message",
+  // The bot itself, cards
+  "application:application:self_manage", "application:bot.basic_info:read", "application:bot.menu:readonly",
+  "application:bot.menu:write", "application:app_slash_command:read", "application:app_slash_command:write",
+  "cardkit:card:read", "cardkit:card:write", "cardkit:template:read",
+  // People
+  "contact:contact.base:readonly", "contact:user.base:readonly", "contact:user.id:readonly", "contact:user.employee_id:readonly",
+  "contact:user.email:readonly", "contact:department.base:readonly", "tenant:tenant:readonly",
+  // Base
+  "bitable:app", "bitable:app:readonly", "base:app:read", "base:app:create", "base:app:update", "base:app:copy",
+  "base:table:read", "base:table:create", "base:table:update", "base:field:read", "base:field:create", "base:field:update",
+  "base:record:read", "base:record:retrieve", "base:record:create", "base:record:update", "base:record:delete",
+  "base:view:read", "base:view:write_only", "base:dashboard:read", "base:form:read", "base:workspace:list", "base:workspace:read",
+  // Calendar and meetings
+  "calendar:calendar", "calendar:calendar:readonly",
+  "vc:meeting.search:read", "vc:note:read", "vc:reserve:readonly", "vc:room:readonly",
+  "minutes:minutes.artifacts:read", "minutes:minutes.search:read",
+  // Documents
+  "docx:document", "docx:document:create", "docx:document:readonly", "docx:document:write_only", "docx:document.block:convert",
+  "docs:document.content:read", "docs:document.media:download", "docs:document.media:upload", "docs:document:copy",
+  "docs:document:export", "docs:document:import", "docs:document.comment:read", "docs:document.comment:create",
+  "docs:document.comment:update", "docs:document.comment:delete", "docs:document.comment:write_only",
+  "docs:permission.member:create", "docs:permission.member:retrieve", "docs:permission.setting:read",
+  "drive:drive.metadata:readonly", "drive:file:download", "drive:file:upload", "drive:drive:version:readonly", "space:folder:create",
+  "sheets:spreadsheet", "sheets:spreadsheet:read", "sheets:spreadsheet:readonly", "sheets:spreadsheet:create",
+  "sheets:spreadsheet:write_only", "sheets:spreadsheet.meta:read",
+  "slides:presentation:create", "slides:presentation:read", "slides:presentation:update", "slides:presentation:write_only",
+  "board:whiteboard:node:read", "board:whiteboard:node:create", "board:whiteboard:node:update",
+  "mindnote:node:read", "mindnote:node:create",
+  "wiki:wiki", "wiki:wiki:readonly", "wiki:space:read", "wiki:space:retrieve", "wiki:node:read", "wiki:node:retrieve",
+  "wiki:node:create", "wiki:node:update", "wiki:node:copy",
+  // Tasks
+  "task:task", "task:task:read", "task:task:readonly", "task:tasklist:read", "task:comment:read", "task:comment:write",
+  "task:attachment:read", "task:attachment:write", "task:section:read", "task:custom_field:read",
+  // Translation, OCR and speech
+  "translation:text", "optical_char_recognition:image", "speech_to_text:speech",
 ];
 // The official SDKs' QR `addons` encoding.
 const addons = gzipSync(JSON.stringify({ scopes: { tenant: botScopes } })).toString("base64url");
@@ -77,7 +110,7 @@ export function feishuRegistrationAPI(store, fetchImpl = fetch) {
       if (!row) throw new AppError(404, "注册会话不存在。");
       if (row.status !== "pending" || row.expires_at <= Date.now())
         throw new AppError(410, "授权二维码已失效，请重新发起注册。");
-      return QRCode.toBuffer(row.verification_url, { width: 480, margin: 4 });
+      return QRCode.toBuffer(row.verification_url, { width: 640, margin: 4 });
     }
     const id = path.match(/^\/app\/feishu\/provision\/([a-f0-9-]{36})$/)?.[1];
     if (!id || !uuid.test(id)) throw new AppError(404, "Not found.");

From 2169648565202e75ab4219580e6b8e853e42473a Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Mon, 26 Oct 2026 19:11:26 +0800
Subject: [PATCH 17/19] Name a Feishu bot after its app as soon as it is added

A scanned bot was named "Parsar", the name Parsar preset on the
confirmation page, and an added app showed its App ID, until the bot
first connected. Parsar no longer presets a name, so the app is named on
the confirmation page, and it reads the app's Feishu name with the app's
own credentials as soon as the bot is created or added.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/README.md                      |  2 +-
 example/parsar/README.zh.md                   |  4 +-
 example/parsar/server/feishu-registration.mjs | 31 +++++++++++++--
 example/parsar/server/feishu.mjs              |  9 +++--
 example/parsar/server/product.mjs             |  2 +-
 example/parsar/src/Feishu.tsx                 |  5 +--
 example/parsar/tests/feishu.test.mjs          | 38 ++++++++++++++++++-
 example/parsar/tests/product.test.mjs         |  2 +-
 8 files changed, 76 insertions(+), 17 deletions(-)

diff --git a/example/parsar/README.md b/example/parsar/README.md
index 3cc73d1a9..248b51d82 100644
--- a/example/parsar/README.md
+++ b/example/parsar/README.md
@@ -121,7 +121,7 @@ Optional business questions use the declared `ask_user` function. They appear in
 
 ## Feishu
 
-**飞书接入** shows one card per bot. **添加机器人** offers **扫码创建**, which provisions an application through Feishu’s device flow with the entered name and app-identity scopes pre-filled on the confirmation page: `im:message.group_msg` and the messaging, Base, Calendar, Docs, Sheets, Slides, Wiki, Tasks, meetings and contact scopes the organization grants without review ([the list](server/feishu-registration.mjs)); scopes that need review are applied for only when an Agent needs them, or **已有应用** with an App ID and App Secret. A new bot stays disabled until configured. Secrets stay in the restricted local database. The official SDK owns authentication, normalization and long connections; no inbound public callback is needed.
+**飞书接入** shows one card per bot. **添加机器人** offers **扫码创建**, which provisions an application through Feishu’s device flow with app-identity scopes pre-filled on the confirmation page, where you also name the app: `im:message.group_msg` and the messaging, Base, Calendar, Docs, Sheets, Slides, Wiki, Tasks, meetings and contact scopes the organization grants without review ([the list](server/feishu-registration.mjs)); scopes that need review are applied for only when an Agent needs them, or **已有应用** with an App ID and App Secret. A bot's name is its app's name in Feishu: Parsar reads it when the bot is created or added, and again whenever it connects. A new bot stays disabled until configured. Secrets stay in the restricted local database. The official SDK owns authentication, normalization and long connections; no inbound public callback is needed.
 
 1. On the card, choose the **Agent**, turn on **私聊** and/or **群聊**, then **保存并启用**. Enabling requires credentials, an Agent with an environment template and at least one of the two. With **群聊** on, the bot answers mentions in every group it has joined; adding the bot to a group is all that is needed. Who can add the bot is controlled by the app’s availability in the developer console.
 2. In the developer console, enable the bot, long-connection event delivery and `im.message.receive_v1`, publish the app and add it to the target groups. Grant mention receipt and send-as-bot permissions; direct messages, message resources and reactions need their own scopes. A missing reaction permission does not discard a message.
diff --git a/example/parsar/README.zh.md b/example/parsar/README.zh.md
index 7ff4a8042..e808a990f 100644
--- a/example/parsar/README.zh.md
+++ b/example/parsar/README.zh.md
@@ -1,6 +1,6 @@
 ---
 source: example/parsar/README.md
-source_hash: 5813b35ccdceece56c8a2463186d89e1f50b20577073d9f2a6ffc7b276647305
+source_hash: 12b211e2892cdae0109a397dcf9a96cc083b43f018f85fb712ca68200841401d
 ---
 
 # Parsar 工作空间
@@ -126,7 +126,7 @@ Parsar 会跟踪每一轮正在执行的对话，网页和飞书都一样。出
 
 ## 飞书 {#feishu}
 
-**飞书接入** 为每个机器人展示一张卡片。**添加机器人** 提供 **扫码创建**（通过飞书设备流创建应用，扫码后的确认页会预先填好输入的名称和应用身份权限：`im:message.group_msg`，以及企业免审的消息、多维表格、日历、文档、电子表格、幻灯片、知识库、任务、会议和通讯录权限，[完整清单](server/feishu-registration.mjs)；需要审核的权限只在 Agent 确实用到时再申请）和 **已有应用**（填写 App ID 与 App Secret）。新机器人在配置完成前保持停用。密钥保存在受限的本地数据库中。官方 SDK 负责鉴权、消息规范化和长连接，不需要公网回调。
+**飞书接入** 为每个机器人展示一张卡片。**添加机器人** 提供 **扫码创建**（通过飞书设备流创建应用，扫码后的确认页会预先填好应用身份权限，应用名称在确认页里自己填写：`im:message.group_msg`，以及企业免审的消息、多维表格、日历、文档、电子表格、幻灯片、知识库、任务、会议和通讯录权限，[完整清单](server/feishu-registration.mjs)；需要审核的权限只在 Agent 确实用到时再申请）和 **已有应用**（填写 App ID 与 App Secret）。机器人的名称就是它在飞书里的应用名：创建或添加机器人时，Parsar 会读取一次，之后每次连接时再同步。新机器人在配置完成前保持停用。密钥保存在受限的本地数据库中。官方 SDK 负责鉴权、消息规范化和长连接，不需要公网回调。
 
 1. 在卡片上选择 **Agent**，打开 **私聊** 和/或 **群聊**，然后 **保存并启用**。启用需要应用凭证、已配置环境模板的 Agent，以及两者至少开启一项。打开 **群聊** 后，机器人会回复它所在的任何群里的 @ 消息，把机器人拉进群即可使用。谁能添加机器人由开发者后台中应用的可用范围控制。
 2. 在开发者后台启用机器人、长连接事件推送和 `im.message.receive_v1`，发布应用并把它加入目标群。授予接收 @ 消息和以机器人身份发送消息的权限；私聊、消息资源和表情回复需要各自的权限。缺少表情权限不会丢弃消息。
diff --git a/example/parsar/server/feishu-registration.mjs b/example/parsar/server/feishu-registration.mjs
index 253569598..d2c7a2cec 100644
--- a/example/parsar/server/feishu-registration.mjs
+++ b/example/parsar/server/feishu-registration.mjs
@@ -54,6 +54,27 @@ export const botScopes = [
   // Translation, OCR and speech
   "translation:text", "optical_char_recognition:image", "speech_to_text:speech",
 ];
+// The name the app has in Feishu, read with its own credentials; undefined
+// when Feishu cannot say.
+export async function feishuAppName(fetchImpl, { app_id, app_secret, brand }) {
+  const host = brand === "lark" ? "open.larksuite.com" : "open.feishu.cn";
+  const call = async (path, init) =>
+    (await fetchImpl(`https://${host}${path}`, { ...init, redirect: "error", signal: AbortSignal.timeout(10000) })).json();
+  try {
+    const { tenant_access_token: token } = await call("/open-apis/auth/v3/tenant_access_token/internal", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ app_id, app_secret }),
+    });
+    if (!token) return;
+    const info = await call("/open-apis/bot/v3/info", { headers: { Authorization: `Bearer ${token}` } });
+    const name = (info.bot || info.data?.bot)?.app_name;
+    return typeof name === "string" && name.trim() ? name.trim().slice(0, 80) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 // The official SDKs' QR `addons` encoding.
 const addons = gzipSync(JSON.stringify({ scopes: { tenant: botScopes } })).toString("base64url");
 
@@ -127,7 +148,7 @@ export function feishuRegistrationAPI(store, fetchImpl = fetch) {
         const bot = store.get("feishu_bots", id);
         if (bot?.app_id)
           throw new AppError(409, "机器人已有应用，请新建机器人进行扫码注册。");
-        const name = text(body.name || "Feishu", "机器人名称", 80, true);
+        const name = body.name ? text(body.name, "机器人名称", 80, true) : "";
         await call("init");
         const value = await call("begin", {
           archetype: "PersonalAgent",
@@ -152,8 +173,8 @@ export function feishuRegistrationAPI(store, fetchImpl = fetch) {
           verification.password
         )
           throw new AppError(502, "飞书返回的授权地址无效。");
-        // The confirmation page after scanning pre-fills the app's name and scopes.
-        verification.searchParams.set("name", name);
+        // The confirmation page after scanning pre-fills the app's scopes, and its name when one was given.
+        if (name) verification.searchParams.set("name", name);
         verification.searchParams.set("addons", addons);
         row = {
           id,
@@ -214,11 +235,13 @@ export function feishuRegistrationAPI(store, fetchImpl = fetch) {
             .some((bot) => bot.app_id === value.client_id)
         )
           throw new AppError(409, "应用已绑定，请检查机器人配置。");
+        const brand = row.brand === "lark" ? "lark" : "feishu";
+        const appName = await feishuAppName(fetchImpl, { app_id: value.client_id, app_secret: value.client_secret, brand });
         store.transaction(() => {
           store.put("feishu_bots", {
             ...bot,
             id,
-            name: bot?.name || row.name,
+            name: appName || row.name || value.client_id,
             app_id: value.client_id,
             app_secret: value.client_secret,
             brand: row.brand === "lark" ? "lark" : "feishu",
diff --git a/example/parsar/server/feishu.mjs b/example/parsar/server/feishu.mjs
index b0bd28a72..f2ed0d357 100644
--- a/example/parsar/server/feishu.mjs
+++ b/example/parsar/server/feishu.mjs
@@ -8,6 +8,7 @@ import { feishuContextReader } from "./feishu-context.mjs";
 import { explainFailure, turnsAPI } from "./turns.mjs";
 import { waitingHeadline } from "../shared/turn-status.mjs";
 import { feishuSource } from "../shared/feishu-source.mjs";
+import { feishuAppName } from "./feishu-registration.mjs";
 import { AppError, text, uuid, transientError } from "./store.mjs";
 
 const stamp = () => Date.now();
@@ -16,7 +17,7 @@ export const publicFeishu = ({ app_secret, ...record }) => ({
   ...record,
   has_app_secret: !!app_secret,
 });
-export function feishuAPI(store) {
+export function feishuAPI(store, fetchImpl = fetch) {
   return async (method, path, body) => {
     const retryMatch = path.match(
       /^\/app\/feishu\/deliveries\/(inbound|outbound)\/([a-f0-9-]{36})$/,
@@ -107,8 +108,10 @@ export function feishuAPI(store) {
     if (body.brand !== undefined && !["feishu", "lark"].includes(body.brand))
       throw new AppError(400, "机器人地区无效。");
     const app_id = text(body.app_id, "App ID", 100).trim();
-    // The name comes from Feishu once the bot connects; until then it shows the App ID.
-    const name = app_id === old.app_id && old.name ? old.name : app_id || "Feishu";
+    // A new app takes the name it has in Feishu; connecting keeps it current.
+    const name = app_id === old.app_id && old.name
+      ? old.name
+      : (app_id && body.app_secret && (await feishuAppName(fetchImpl, { app_id, app_secret: body.app_secret.trim(), brand: body.brand ?? old.brand }))) || app_id || "Feishu";
     if (
       app_id &&
       store
diff --git a/example/parsar/server/product.mjs b/example/parsar/server/product.mjs
index 062c9ce4e..576a11303 100644
--- a/example/parsar/server/product.mjs
+++ b/example/parsar/server/product.mjs
@@ -51,7 +51,7 @@ export function productAPI(store, core, fetchImpl = fetch, origin) {
   };
   const capabilities = capabilityAPI(store);
   const oauth = mcpOAuthAPI(store, core, origin, fetchImpl);
-  const feishu = feishuAPI(store);
+  const feishu = feishuAPI(store, fetchImpl);
   const registration = feishuRegistrationAPI(store, fetchImpl);
   const providers = providerAPI(store, fetchImpl);
   const trials = trialAPI(store, core, resources);
diff --git a/example/parsar/src/Feishu.tsx b/example/parsar/src/Feishu.tsx
index 7931a174e..f5b25c7c9 100644
--- a/example/parsar/src/Feishu.tsx
+++ b/example/parsar/src/Feishu.tsx
@@ -410,10 +410,7 @@ function QrCreate({ close }: { close: () => void }) {
   const [started, setStarted] = useState(false);
   const begin = useMutation({
     mutationFn: () =>
-      product<RegistrationState>(`feishu/provision/${id}`, "POST", {
-        action: "begin",
-        name: "Parsar",
-      }),
+      product<RegistrationState>(`feishu/provision/${id}`, "POST", { action: "begin" }),
     onSuccess: (value) => {
       cache.setQueryData(["feishu-registration", id], value);
       setStarted(true);
diff --git a/example/parsar/tests/feishu.test.mjs b/example/parsar/tests/feishu.test.mjs
index e358ac7ed..8f3d619b6 100644
--- a/example/parsar/tests/feishu.test.mjs
+++ b/example/parsar/tests/feishu.test.mjs
@@ -5,6 +5,11 @@ import { randomUUID } from "node:crypto";
 import { openStore, AppError } from "../server/store.mjs";
 import { productAPI } from "../server/product.mjs";
 import { withSavedResources } from "./core-double.mjs";
+
+// Tests never reach Feishu; a name lookup falls back to the App ID.
+const offline = async () => {
+  throw new TypeError("offline");
+};
 import { feishuOperations } from "../server/feishu.mjs";
 import { feishuWorker as workerForBot } from "../server/feishu.mjs";
 
@@ -52,7 +57,7 @@ async function setup(t) {
     return { id, status: resource.status };
   };
   const savedCore = withSavedResources(core);
-  const api = productAPI(store, savedCore);
+  const api = productAPI(store, savedCore, offline);
   const put = (kind, body, id = randomUUID()) =>
     api("PUT", `/app/${kind}/${id}`, body);
   const provider = await put("providers", {
@@ -2187,3 +2192,34 @@ test("a bot deletes at once, running or with deliveries pending; delivered histo
   assert.equal(f.store.get("feishu_inbound", "waiting"), null);
   assert.equal(f.store.get("feishu_outbound", "sent").state, "delivered");
 });
+
+test("a new bot takes the name its app has in Feishu, scanned or added", async (t) => {
+  const { feishuRegistrationAPI } = await import("../server/feishu-registration.mjs");
+  const { feishuAPI } = await import("../server/feishu.mjs");
+  const store = openStore(":memory:");
+  t.after(() => store.close());
+  const feishuFetch = async (url, init = {}) => {
+    const path = new URL(url).pathname;
+    if (path === "/open-apis/auth/v3/tenant_access_token/internal")
+      return Response.json({ tenant_access_token: JSON.parse(init.body).app_secret === "right" ? "token" : undefined });
+    if (path === "/open-apis/bot/v3/info") return Response.json({ bot: { app_name: "reldev日程" } });
+    const action = new URLSearchParams(init.body).get("action");
+    if (action === "begin")
+      return Response.json({ device_code: "device", user_code: "CODE", verification_uri_complete: "https://open.feishu.cn/page/cli?user_code=CODE", expires_in: 300, interval: 1 });
+    if (action === "poll") return Response.json({ client_id: "cli_0123456789abcdef", client_secret: "right" });
+    return Response.json({});
+  };
+  const registration = feishuRegistrationAPI(store, feishuFetch);
+  const id = randomUUID();
+  const begin = await registration("POST", `/app/feishu/provision/${id}`, { action: "begin" });
+  assert.equal(new URL(begin.verification_url).searchParams.get("name"), null, "people name the app on the confirmation page");
+  await registration("POST", `/app/feishu/provision/${id}`, { action: "poll" });
+  assert.equal(store.get("feishu_bots", id).name, "reldev日程");
+  // An app added by App ID and App Secret takes its Feishu name too.
+  const bots = feishuAPI(store, feishuFetch);
+  const added = await bots("PUT", `/app/feishu/bots/${randomUUID()}`, { revision: 0, app_id: "cli_fedcba9876543210", app_secret: "right", enabled: false });
+  assert.equal(added.name, "reldev日程");
+  // When Feishu cannot say, the App ID stands in until the bot connects.
+  const unnamed = await bots("PUT", `/app/feishu/bots/${randomUUID()}`, { revision: 0, app_id: "cli_aaaaaaaaaaaaaaaa", app_secret: "wrong", enabled: false });
+  assert.equal(unnamed.name, "cli_aaaaaaaaaaaaaaaa");
+});
diff --git a/example/parsar/tests/product.test.mjs b/example/parsar/tests/product.test.mjs
index 4a817919e..e77c37810 100644
--- a/example/parsar/tests/product.test.mjs
+++ b/example/parsar/tests/product.test.mjs
@@ -207,7 +207,7 @@ test("Provider discovery reports failures without leaking keys or upstream bodie
   store.close();
 });
 
-async function setup(store, test, fetchImpl) {
+async function setup(store, test, fetchImpl = async () => { throw new TypeError("offline"); }) {
   const core = withSavedResources(test);
   const api = productAPI(store, core, fetchImpl);
   const put = (kind, body, id = randomUUID()) =>

From c8c640b09acc92131aa53fb132d121785e27361a Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Mon, 26 Oct 2026 19:55:56 +0800
Subject: [PATCH 18/19] Keep steers recorded and ask only for scopes the Agent
 names

The monitor wrote back a copy of a Turn it read before its Core calls, so
a message that joined the Turn meanwhile was lost, and Feishu then gave
that message a progress card of its own that never finished. The monitor
now keeps steers recorded meanwhile, and a Feishu message sent while Core
runs a Turn keeps that Turn's card.

The missing-scope card replaced the Agent's reply with every scope any
probe had hit, so a Base collaborator problem showed Drive scopes. The
reply now stays the card's body, and only scopes it names get an apply
link. Folded panels share one block style so they line up.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/README.md              |  2 +-
 example/parsar/README.zh.md           |  4 ++--
 example/parsar/server/feishu.mjs      | 23 +++++++++++---------
 example/parsar/server/turns.mjs       | 22 +++++++++++++-------
 example/parsar/tests/feishu.test.mjs  | 30 ++++++++++++++-------------
 example/parsar/tests/product.test.mjs | 24 +++++++++++++++++++++
 6 files changed, 71 insertions(+), 34 deletions(-)

diff --git a/example/parsar/README.md b/example/parsar/README.md
index 248b51d82..04a853575 100644
--- a/example/parsar/README.md
+++ b/example/parsar/README.md
@@ -133,7 +133,7 @@ Accepted messages are committed to SQLite before the WebSocket ACK; request IDs
 
 ### Bot identity
 
-The Agent acts as its bound bot. Each Feishu message reaches it after a first line naming its `message_id`, `chat_id`, chat type and sender `open_id`, so a Skill can key work to the message; Parsar's own views hide that line. When the Agent's tools report that the bot's app lacks scopes, the card says **需要开通权限**, lists them and links to applying for them in the Feishu developer console, with the Agent's explanation folded below; once an administrator approves the new version, replying continues. Every conversation of an Agent with a bound bot, Web ones included, receives the bot’s identity as `FEISHU_APP_ID`, `FEISHU_APP_SECRET` and `FEISHU_BRAND`; nothing needs to be mapped. A template, Skill or Plugin that needs the bot lists these names under **需要的密钥**: the library shows **飞书机器人** as its requirement, the Agent page shows the bot that provides it, and an Agent without a bot cannot be saved. Only the bound bot supplies these names. The Feishu case's setup script runs `lark-cli config init --app-secret-stdin`, so the CLI mints and refreshes tenant tokens itself and long conversations keep working. Do not pass them as `LARKSUITE_CLI_APP_ID` or `LARKSUITE_CLI_APP_SECRET`: those switch lark-cli to environment credentials, which require a ready-made tenant token. Anyone who can talk to the bot can use the bot’s permissions, and tools in the Environment can read the secret. Grant the bot only the scopes its Agent needs and prefer one bot per Agent. A rotated secret applies to new conversations only.
+The Agent acts as its bound bot. Each Feishu message reaches it after a first line naming its `message_id`, `chat_id`, chat type and sender `open_id`, so a Skill can key work to the message; Parsar's own views hide that line. When the Agent's reply names scopes its tools reported missing, the card says **需要开通权限** and adds, under the reply, a link to applying for those scopes in the Feishu developer console; scopes the Agent only ran into while exploring are not asked for. Once an administrator approves the new version, replying continues. Every conversation of an Agent with a bound bot, Web ones included, receives the bot’s identity as `FEISHU_APP_ID`, `FEISHU_APP_SECRET` and `FEISHU_BRAND`; nothing needs to be mapped. A template, Skill or Plugin that needs the bot lists these names under **需要的密钥**: the library shows **飞书机器人** as its requirement, the Agent page shows the bot that provides it, and an Agent without a bot cannot be saved. Only the bound bot supplies these names. The Feishu case's setup script runs `lark-cli config init --app-secret-stdin`, so the CLI mints and refreshes tenant tokens itself and long conversations keep working. Do not pass them as `LARKSUITE_CLI_APP_ID` or `LARKSUITE_CLI_APP_SECRET`: those switch lark-cli to environment credentials, which require a ready-made tenant token. Anyone who can talk to the bot can use the bot’s permissions, and tools in the Environment can read the secret. Grant the bot only the scopes its Agent needs and prefer one bot per Agent. A rotated secret applies to new conversations only.
 
 ### Feishu workspace case
 
diff --git a/example/parsar/README.zh.md b/example/parsar/README.zh.md
index e808a990f..2766abb73 100644
--- a/example/parsar/README.zh.md
+++ b/example/parsar/README.zh.md
@@ -1,6 +1,6 @@
 ---
 source: example/parsar/README.md
-source_hash: 12b211e2892cdae0109a397dcf9a96cc083b43f018f85fb712ca68200841401d
+source_hash: 411111ed42b7fc1c6c473c280b044fed7eb03a16bc8433d9240eb9951545ec2b
 ---
 
 # Parsar 工作空间
@@ -138,7 +138,7 @@ Parsar 会跟踪每一轮正在执行的对话，网页和飞书都一样。出
 
 ### 机器人身份 {#bot-identity}
 
-Agent 以绑定的机器人身份工作。每条飞书消息转给 Agent 时，正文前会附一行来源信息：`message_id`、`chat_id`、会话类型和发送者 `open_id`，Skill 可以据此对消息做幂等处理；Parsar 自己的页面不显示这一行。Agent 的工具报告机器人应用缺少权限时，卡片标题显示 **需要开通权限**，列出缺少的权限，并附上在飞书开发者后台申请开通的链接，Agent 的说明折叠在下方；管理员批准并发布新版本后，直接回复即可继续。绑定了机器人的 Agent，它的每个对话（包括网页对话）都会以 `FEISHU_APP_ID`、`FEISHU_APP_SECRET` 和 `FEISHU_BRAND` 拿到机器人身份，不需要任何映射。需要机器人身份的模板、Skill 或 Plugin 在 **需要的密钥** 里列出这几个名字：能力列表里它的凭据需求显示为 **飞书机器人**，Agent 页面显示由哪个机器人提供，没有绑定机器人的 Agent 不能保存。这几个名字只能由绑定的机器人提供。飞书案例的初始化脚本运行 `lark-cli config init --app-secret-stdin`，由 CLI 自行获取并刷新租户令牌，长对话也能持续工作。不要以 `LARKSUITE_CLI_APP_ID` 或 `LARKSUITE_CLI_APP_SECRET` 传入：这两个变量会让 lark-cli 进入环境凭据模式，该模式要求直接提供租户令牌。任何能与机器人对话的人都能使用机器人的权限，Environment 中的工具也能读取该密钥。只为机器人授予其 Agent 需要的权限，尽量一个 Agent 使用一个机器人。轮换后的密钥只对新对话生效。
+Agent 以绑定的机器人身份工作。每条飞书消息转给 Agent 时，正文前会附一行来源信息：`message_id`、`chat_id`、会话类型和发送者 `open_id`，Skill 可以据此对消息做幂等处理；Parsar 自己的页面不显示这一行。Agent 的回复里写出了工具报告缺少的权限时，卡片标题显示 **需要开通权限**，并在回复下方附上在飞书开发者后台申请这些权限的链接；Agent 排查时顺带碰到的权限不会列出。管理员批准并发布新版本后，直接回复即可继续。绑定了机器人的 Agent，它的每个对话（包括网页对话）都会以 `FEISHU_APP_ID`、`FEISHU_APP_SECRET` 和 `FEISHU_BRAND` 拿到机器人身份，不需要任何映射。需要机器人身份的模板、Skill 或 Plugin 在 **需要的密钥** 里列出这几个名字：能力列表里它的凭据需求显示为 **飞书机器人**，Agent 页面显示由哪个机器人提供，没有绑定机器人的 Agent 不能保存。这几个名字只能由绑定的机器人提供。飞书案例的初始化脚本运行 `lark-cli config init --app-secret-stdin`，由 CLI 自行获取并刷新租户令牌，长对话也能持续工作。不要以 `LARKSUITE_CLI_APP_ID` 或 `LARKSUITE_CLI_APP_SECRET` 传入：这两个变量会让 lark-cli 进入环境凭据模式，该模式要求直接提供租户令牌。任何能与机器人对话的人都能使用机器人的权限，Environment 中的工具也能读取该密钥。只为机器人授予其 Agent 需要的权限，尽量一个 Agent 使用一个机器人。轮换后的密钥只对新对话生效。
 
 ### 飞书工作环境案例 {#feishu-workspace-case}
 
diff --git a/example/parsar/server/feishu.mjs b/example/parsar/server/feishu.mjs
index f2ed0d357..470c8ea4a 100644
--- a/example/parsar/server/feishu.mjs
+++ b/example/parsar/server/feishu.mjs
@@ -423,8 +423,7 @@ function scopeNotice(app, scopes) {
   const host = app.brand === "lark" ? "open.larksuite.com" : "open.feishu.cn";
   const url = `https://${host}/page/scope-apply?clientID=${encodeURIComponent(app.app_id)}&scopes=${encodeURIComponent(scopes.join(","))}`;
   return [
-    `**机器人「${app.name || app.app_id}」还缺少飞书权限**，这次没能完成。`,
-    `需要开通：${scopes.map((name) => `\`${name}\``).join("、")}`,
+    `需要为机器人「${app.name || app.app_id}」开通：${scopes.map((name) => `\`${name}\``).join("、")}`,
     `[申请开通权限](${url})`,
     grey("管理员批准并发布新版本后，直接回复这条消息即可继续。"),
   ].join("\n\n");
@@ -490,14 +489,15 @@ export function formatTurnCard(status, items = [], error, turn, questions = [],
     : status === "cancelled" ? [authorizationText, answer].filter(Boolean).join("\n\n") || "已按你的要求停止。"
     : [authorizationText, answer || "这次没有完成。", error ? `<font color='red'>${error}</font>` : "", grey("直接回复即可重试。")].filter(Boolean).join("\n\n"), status === "requires_action" ? 8000 : 12000);
   const elements = [];
-  // Missing scopes come first: the Agent's own explanation folds below the link.
-  const scopes = app ? missingScopes(items) : [];
+  // Scopes the Agent's reply names as missing get a link to apply for them,
+  // under the reply; scopes it only ran into while exploring do not.
+  const said = [answer, ...questions.map((action) => questionText(action))].join("\n");
+  const scopes = app ? missingScopes(items).filter((name) => said.includes(name)) : [];
+  if (foldContext) elements.push(panel({ title: grey("补充说明"), content: excerpt(context, 4000), block: true }));
   if (scopes.length) {
-    elements.push(panel({ title: grey("Agent 的说明"), content: excerpt([body, foldContext ? context : ""].filter(Boolean).join("\n\n"), 4000) }));
-    if (rows.length) elements.push(panel({ title: grey(`处理过程 · ${rows.length} 步`), elements: fitRows(rows, cardBudget - bytes(elements) - 2000), block: true }));
-    return statusCard("missing_scopes", scopeNotice(app, scopes), [{ tag: "hr" }, ...elements]);
+    if (rows.length) elements.push(panel({ title: grey(`处理过程 · ${rows.length} 步`), elements: fitRows(rows, cardBudget - bytes(body) - 3000), block: true }));
+    return statusCard("missing_scopes", [body, scopeNotice(app, scopes)].join("\n\n"), [{ tag: "hr" }, ...elements]);
   }
-  if (foldContext) elements.push(panel({ title: grey("补充说明"), content: excerpt(context, 4000) }));
   // A failure shows the step that failed right under its cause.
   const failedTool = status === "failed" ? tools.findLast((item) => item.status === "failed") : undefined;
   if (failedTool) elements.push(toolRow(failedTool));
@@ -1190,8 +1190,11 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
         row = { ...row, state: "submitting", event };
         store.put("feishu_inbound", row);
         // Messages go through the Turn ledger; answers and cancellations go to Core directly.
-        if (event.type === "agent.session.input.message")
-          steered = (await ledger.deliver(run, event.input, { id: row.id, key: row.id, source: "feishu" })).id !== row.id;
+        // A message sent while a Turn runs joins it in Core and keeps its card.
+        if (event.type === "agent.session.input.message") {
+          const delivered = await ledger.deliver(run, event.input, { id: row.id, key: row.id, source: "feishu" });
+          steered = delivered.id !== row.id || delivered.base_running === true;
+        }
         else
           await core(
             `/v1/agents/sessions/${run.core_session_id}/events`,
diff --git a/example/parsar/server/turns.mjs b/example/parsar/server/turns.mjs
index 9481e2427..f05bac6d1 100644
--- a/example/parsar/server/turns.mjs
+++ b/example/parsar/server/turns.mjs
@@ -152,7 +152,7 @@ export function turnsAPI(store, core) {
       () => {
         const turn = store.get("turns", id);
         if (turn?.outcome === "running" && turn.core_session_id === record.core_session_id)
-          store.put("turns", { ...turn, unsent: true });
+          save({ ...turn, unsent: true });
       },
     );
     return record;
@@ -168,12 +168,20 @@ export function turnsAPI(store, core) {
     return deliver(record, text, { id: `${sessionId}:${key}`, key, source: "web" });
   };
 
+  // The monitor writes back a copy it read before its Core calls; a message
+  // that joined the Turn meanwhile stays recorded.
+  const save = (turn) => {
+    const steers = store.get("turns", turn.id)?.steers;
+    const saved = steers ? { ...turn, steers } : turn;
+    store.put("turns", saved);
+    return saved;
+  };
+
   const finish = (turn, outcome, failure) => {
     const done = { ...turn, outcome, stage: undefined, done_at: now(), pending_cancel: undefined };
     if (failure) done.failure = failure;
     if (outcome === "completed" && !done.output_at) done.output_at = done.done_at;
-    store.put("turns", done);
-    return done;
+    return save(done);
   };
 
   // Replaces a Session whose first Turn never ran (its Environment failed, or a
@@ -188,7 +196,7 @@ export function turnsAPI(store, core) {
       // Feishu cursors belong to the replaced Core Session.
       for (const thread of store.list("feishu_threads").filter((t) => t.session_id === record.id))
         store.put("feishu_threads", { ...thread, turn_cursor: undefined, item_cursor: undefined, artifact_cursor: undefined });
-      store.put("turns", { ...turn, core_session_id: created.id, retries, prepared: false, unsent: undefined, stage: "preparing" });
+      save({ ...turn, core_session_id: created.id, retries, prepared: false, unsent: undefined, stage: "preparing" });
     });
     await core(`/v1/agents/sessions/${record.core_session_id}`, "DELETE").catch(() => {});
   };
@@ -205,14 +213,14 @@ export function turnsAPI(store, core) {
     // Messages that steered the Turn go with it again.
     const input = [...asInput(turn.input), ...(turn.steers || []).flatMap((steer) => steer.input)];
     await post(record.core_session_id, message(input), `${turn.id}:resend:${retries}`);
-    store.put("turns", { ...turn, retries, stage: "retrying", pending_cancel: undefined, core_turn_id: undefined });
+    save({ ...turn, retries, stage: "retrying", pending_cancel: undefined, core_turn_id: undefined });
   };
 
   const check = async (turn) => {
     const record = store.get("sessions", turn.session_id);
     if (!record || record.deleted_at) return finish(turn, "cancelled");
     if (record.core_session_id !== turn.core_session_id) {
-      store.put("turns", { ...turn, core_session_id: record.core_session_id });
+      save({ ...turn, core_session_id: record.core_session_id });
       return;
     }
     // Confirm uncertain Web submissions before attributing any Core Turn to
@@ -284,7 +292,7 @@ export function turnsAPI(store, core) {
       await post(sid, { type: "agent.session.input.cancel" }, `${turn.id}:cancel:${current.retries + 1}`);
       current = { ...current, pending_cancel: coreTurn.id, stage: "retrying" };
     } else if (stalled) current.failure = unresponsive;
-    store.put("turns", current);
+    save(current);
   };
 
   let monitoring = false;
diff --git a/example/parsar/tests/feishu.test.mjs b/example/parsar/tests/feishu.test.mjs
index 8f3d619b6..62bc93599 100644
--- a/example/parsar/tests/feishu.test.mjs
+++ b/example/parsar/tests/feishu.test.mjs
@@ -2112,30 +2112,32 @@ test("a message sent while the Turn runs steers it and keeps that Turn's card",
   assert.equal(f.store.list("feishu_inbound").find((row) => row.message_id === "steer").state, "delivered");
 });
 
-test("a turn blocked by missing Feishu scopes answers with the scopes and a link to apply", async () => {
+test("a reply that names missing Feishu scopes gets a link to apply for them", async () => {
   const { formatTurnCard, missingScopes } = await import("../server/feishu.mjs");
   const cli = JSON.stringify({ ok: false, identity: "bot", error: { type: "authorization", subtype: "app_scope_not_applied", code: 99991672, message: "access denied: app cli_0123456789abcdef has not applied for the required scope(s): base:field:read, base:record:read" } });
-  const api = '{"code":99991672,"msg":"Access denied. One of the following scopes is required: [calendar:calendar:readonly, calendar:calendar]."}';
-  const items = [
+  const api = '{"code":99991672,"msg":"Access denied. One of the following scopes is required: [drive:drive, drive:drive:readonly]."}';
+  const tools = [
     { type: "command_execution", command: "lark-cli base +field-list", output: cli, status: "failed" },
-    { type: "command_execution", command: "curl calendar", output: api, status: "completed" },
+    { type: "command_execution", command: "lark-cli drive files list", output: api, status: "completed" },
     { type: "command_execution", command: "echo", output: "scope: not an error", status: "completed" },
-    { type: "message", role: "assistant", content: [{ type: "output_text", text: "很长的一段解释和三个选项" }] },
   ];
-  assert.deepEqual(missingScopes(items), ["base:field:read", "base:record:read", "calendar:calendar:readonly", "calendar:calendar"]);
+  assert.deepEqual(missingScopes(tools), ["base:field:read", "base:record:read", "drive:drive", "drive:drive:readonly"]);
+  const reply = (text) => [...tools, { type: "message", role: "assistant", content: [{ type: "output_text", text }] }];
   const app = { app_id: "cli_0123456789abcdef", brand: "feishu", name: "日程助手" };
-  const card = JSON.parse(formatTurnCard("requires_action", items, undefined, undefined, [], app));
+  // The reply names the Base scopes; Drive came up only while exploring.
+  const card = JSON.parse(formatTurnCard("completed", reply("登记没完成：缺少 base:field:read 和 base:record:read。"), undefined, undefined, [], app));
   const body = card.body.elements[0].content;
   assert.equal(card.header.title.content, "需要开通权限");
-  assert.match(body, /机器人「日程助手」还缺少飞书权限/);
-  assert.match(body, /https:\/\/open\.feishu\.cn\/page\/scope-apply\?clientID=cli_0123456789abcdef&scopes=base%3Afield%3Aread%2Cbase%3Arecord%3Aread%2Ccalendar%3Acalendar%3Areadonly%2Ccalendar%3Acalendar/);
-  assert.doesNotMatch(body, /很长的一段解释/, "the Agent's explanation folds below");
-  assert.match(JSON.stringify(card.body.elements.slice(1)), /很长的一段解释/);
-  // Without scope errors, the card is unchanged.
-  const plain = JSON.parse(formatTurnCard("completed", items.slice(2), undefined, undefined, [], app));
+  assert.match(body, /^登记没完成：缺少 base:field:read 和 base:record:read。/, "the reply stays the body");
+  assert.match(body, /需要为机器人「日程助手」开通/);
+  assert.match(body, /https:\/\/open\.feishu\.cn\/page\/scope-apply\?clientID=cli_0123456789abcdef&scopes=base%3Afield%3Aread%2Cbase%3Arecord%3Aread\)/);
+  assert.doesNotMatch(body, /drive/, "scopes met only while exploring are not asked for");
+  // A reply that names no scope keeps the ordinary card.
+  const plain = JSON.parse(formatTurnCard("completed", reply("请让管理员把机器人加为多维表的协作者。"), undefined, undefined, [], app));
   assert.equal(plain.header.title.content, "已完成");
+  assert.doesNotMatch(JSON.stringify(plain), /scope-apply/);
   // Lark apps apply on the Lark console.
-  assert.match(formatTurnCard("failed", items, "x", undefined, [], { ...app, brand: "lark" }), /open\.larksuite\.com\/page\/scope-apply/);
+  assert.match(formatTurnCard("failed", reply("缺少 base:field:read"), "x", undefined, [], { ...app, brand: "lark" }), /open\.larksuite\.com\/page\/scope-apply/);
 });
 
 test("Parsar's views show a Feishu message without the source line the Agent sees", async () => {
diff --git a/example/parsar/tests/product.test.mjs b/example/parsar/tests/product.test.mjs
index e77c37810..80cdb4b4f 100644
--- a/example/parsar/tests/product.test.mjs
+++ b/example/parsar/tests/product.test.mjs
@@ -1440,3 +1440,27 @@ test("an uncertain message confirmed while its Turn still runs joins that Turn",
   assert.deepEqual(store.get("turns", `${id}:first`).steers.map((steer) => steer.id), [`${id}:uncertain`]);
   assert.equal(api.sessions.turns.overview().running.length, 1);
 });
+
+test("a message that joins a Turn while the monitor checks it stays recorded", async (t) => {
+  const store = openStore(":memory:");
+  t.after(() => store.close());
+  const fake = scriptedCore({ environments: [], turns: ["run"] });
+  let gate;
+  const core = async (path, method, body, key) => {
+    // Hold the monitor's Turn listing until the message has joined.
+    if (gate && method === "GET" && path.includes("/turns?order=desc&limit=100")) await gate.promise;
+    return fake.core(path, method, body, key);
+  };
+  const { api, put, input } = await setup(store, core);
+  const id = randomUUID();
+  await put("sessions", input, id);
+  await api.sessions.turns.monitor();
+  gate = Promise.withResolvers();
+  const pass = api.sessions.turns.monitor();
+  await new Promise((resolve) => setTimeout(resolve, 20));
+  await api("POST", `/app/sessions/${id}/messages`, { text: "补充一句", key: "steer" });
+  gate.resolve();
+  await pass;
+  assert.deepEqual(store.get("turns", `${id}:first`).steers?.map((steer) => steer.id), [`${id}:steer`]);
+  assert.equal(store.get("turns", `${id}:steer`), null);
+});

From 29aaf0c4abea9e27f1890024a86ebc3c45842aa8 Mon Sep 17 00:00:00 2001
From: saladday <1203511142@qq.com>
Date: Mon, 26 Oct 2026 21:11:37 +0800
Subject: [PATCH 19/19] Hand files to Agents through Core's Files API, up to 50
 MiB

Feishu attachments and Web uploads were written into the workspace inline,
which Core caps at 5 MiB, so most slide decks were refused. They now go to
Core's Files API first and reach the workspace by File ID, which Core takes
up to 50 MiB; a Feishu message keeps only the File ID across retries.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 example/parsar/README.md              |  4 ++--
 example/parsar/README.zh.md           |  6 +++---
 example/parsar/server.mjs             | 23 ++++++++++++++---------
 example/parsar/server/feishu.mjs      | 17 +++++++++--------
 example/parsar/server/sessions.mjs    |  6 ++----
 example/parsar/shared/media.mjs       |  3 +++
 example/parsar/src/SessionFiles.tsx   | 17 +++++++----------
 example/parsar/src/lib/en.json        |  5 +++--
 example/parsar/tests/feishu.test.mjs  | 27 +++++++++++++++++++++++++++
 example/parsar/tests/fixture.mjs      | 25 ++++++++++++++++++++++++-
 example/parsar/tests/product.test.mjs |  2 +-
 example/parsar/tests/workflow.spec.ts | 20 +++++++++++---------
 12 files changed, 106 insertions(+), 49 deletions(-)

diff --git a/example/parsar/README.md b/example/parsar/README.md
index 04a853575..b881e808c 100644
--- a/example/parsar/README.md
+++ b/example/parsar/README.md
@@ -86,7 +86,7 @@ Quick Tunnel URLs last only for that tunnel process and may change after restart
 
 **新对话** opens the home page: choose an Agent, describe the work and send. The sidebar lists recent conversations; **全部对话** opens the full list with search, Agent, source and date filters, plus **运行**, **用量** and **审计日志**. **运行** also sits directly under **新对话** with the number of running conversations. It lists every running turn from Web and Feishu with its stage and waiting time, and the recently finished ones with their duration, automatic recoveries and plain-language failures; it also shows how many conversations are running, waiting for an answer or failed in the last five minutes. Running turns can be stopped and the latest failed turn of a conversation retried there. Date filters use the browser’s local dates. Usage totals cover all matching records; missing usage remains unknown. Optional model prices are USD per million input/output tokens, frozen when a conversation starts; costs are estimates, not provider bills.
 
-A conversation streams replies and tool activity, groups work steps, navigates user turns with the turn rail, supports follow-ups and cancellation and reopens durable history. Messages sent while the Agent is working, from Web or Feishu, join the running task: **运行** shows it once, and in Feishu it keeps its progress card. Answer business questions on their card. Enter sends; Shift+Enter adds a line. Drafts survive reloads in the same browser tab. The folder button uploads inputs up to 5 MiB while idle, inserts their path into the draft and downloads Artifacts after the live workspace is gone; ask the Agent to save deliverables under `./outputs`. The info button shows the Agent, model, Harness, environment template, Feishu identity, source and the configuration recorded at creation, without variable values, script contents or credentials. When a creation response is lost, the conversation page offers **恢复创建**, which reuses the frozen request and idempotency key.
+A conversation streams replies and tool activity, groups work steps, navigates user turns with the turn rail, supports follow-ups and cancellation and reopens durable history. Messages sent while the Agent is working, from Web or Feishu, join the running task: **运行** shows it once, and in Feishu it keeps its progress card. Answer business questions on their card. Enter sends; Shift+Enter adds a line. Drafts survive reloads in the same browser tab. The folder button uploads inputs up to 50 MiB while idle through Core's Files API, inserts their path into the draft and downloads Artifacts after the live workspace is gone; ask the Agent to save deliverables under `./outputs`. The info button shows the Agent, model, Harness, environment template, Feishu identity, source and the configuration recorded at creation, without variable values, script contents or credentials. When a creation response is lost, the conversation page offers **恢复创建**, which reuses the frozen request and idempotency key.
 
 When a follow-up response is lost while Core resumes the environment, Web keeps the input in the running ledger and confirms receipt with the original idempotency key before monitoring its outcome. Explicit request rejections still return an error; input that never starts is reported after its reservation expires.
 
@@ -126,7 +126,7 @@ Optional business questions use the declared `ask_user` function. They appear in
 1. On the card, choose the **Agent**, turn on **私聊** and/or **群聊**, then **保存并启用**. Enabling requires credentials, an Agent with an environment template and at least one of the two. With **群聊** on, the bot answers mentions in every group it has joined; adding the bot to a group is all that is needed. Who can add the bot is controlled by the app’s availability in the developer console.
 2. In the developer console, enable the bot, long-connection event delivery and `im.message.receive_v1`, publish the app and add it to the target groups. Grant mention receipt and send-as-bot permissions; direct messages, message resources and reactions need their own scopes. A missing reaction permission does not discard a message.
 3. Private chat keeps one conversation per sender until `/clear`. In groups, mentioning the bot starts a topic and each topic is one conversation shared by everyone who replies in it. Follow-ups without a mention arrive only when the app has the “read all group messages” scope (`im:message.group_msg`). **扫码创建** requests it; for **已有应用**, enable it in the Feishu developer console. A topic reply that mentions only other people is addressed to them and is ignored. The bot serves its own tenant only: messages from external contacts are ignored. Other bots and `@all` are ignored, as are groups while **群聊** is off and private chats while **私聊** is off. Changing the bound Agent affects new topics and new private conversations.
-4. Text, rich posts, images, files, audio and video, quoted messages and merged forwards are normalized before dispatch. Attachment limits are eight resources and 5 MiB total. Follow-up files wait until the conversation is idle. Quoted messages are read up to four levels; earlier group messages are not read.
+4. Text, rich posts, images, files, audio and video, quoted messages and merged forwards are normalized before dispatch. Attachment limits are eight resources and 50 MiB total; files reach the workspace through Core's Files API. Follow-up files wait until the conversation is idle. Quoted messages are read up to four levels; earlier group messages are not read.
 5. Commands: `/clear` clears the context: it stops any running work and the next message starts a new conversation, in a private chat or in the same group topic. `/stop` stops the current task; it takes priority over queued follow-ups and recovers an uncertain creation before stopping it. `/answer <call_id> <text>` answers a pending business question, and a plain reply answers when only one is pending. `/help` lists the commands.
 
 Accepted messages are committed to SQLite before the WebSocket ACK; request IDs and frozen payloads survive retries and restarts. The worker edits one compact progress card in place, includes any pending business question in that card, and finishes it with the result. Each reply shows only the current exchange, including answers that resume the same Core Turn. The answer stays visible; while awaiting a business decision, the question takes priority and its supporting context is collapsed, except QR authorization instructions. The card has a colored header for its status. Its process is one timeline in the order things happened. Only commentary stays open as plain text; thinking folds behind its first sentence, and consecutive tool calls fold into one row (such as `运行 3 条命令` with their total time, failures or 进行中) in which each call folds again behind its command, showing parameters, output, error and exit code. While running, the header also says what is happening now and how many steps have run. A running card shows the latest four steps and folds the earlier ones into a tinted block above a divider; a finished card puts the answer first and folds the whole process into a tinted **处理过程** block; a failed card shows the failed step right under its cause. Long content is cut to marked, byte-bounded excerpts. Every step stays in the card: to stay within Feishu's card size limit, the oldest steps first drop their tool output, then shrink to one line, and only a turn with hundreds of steps summarizes its oldest ones in one line. Feishu messages never send people to the Web. Progress uses five-second polling. Complete history and Artifacts remain in the Web conversation. Settled threads stop polling after five minutes and wake on new messages. **消息记录** lists the latest 100 deliveries plus unresolved ones; **重试** keeps the original identity. A failed inbound message blocks later messages in that thread. Uncertain outbound sends are not replayed beyond 55 minutes. Disabling a bot pauses delivery without cancelling Core work.
diff --git a/example/parsar/README.zh.md b/example/parsar/README.zh.md
index 2766abb73..58839946c 100644
--- a/example/parsar/README.zh.md
+++ b/example/parsar/README.zh.md
@@ -1,6 +1,6 @@
 ---
 source: example/parsar/README.md
-source_hash: 411111ed42b7fc1c6c473c280b044fed7eb03a16bc8433d9240eb9951545ec2b
+source_hash: d05354ccb35c01aa32ac2f2cd88bf3543748e4b0c8d8bbf965c087a8d88ffbe9
 ---
 
 # Parsar 工作空间
@@ -91,7 +91,7 @@ Quick Tunnel 地址只在该隧道进程运行期间有效，重启可能换地
 
 **新对话** 打开首页：选择 Agent、描述工作并发送。侧栏列出最近对话；**全部对话** 打开完整列表，支持搜索以及按 Agent、来源和日期筛选，并提供 **运行**、**用量** 和 **审计日志**。**运行** 也直接放在 **新对话** 下方，并显示正在进行的对话数。它列出网页和飞书中每一轮正在执行的对话，显示所处阶段和已等待时间；也列出最近完成的轮次，显示用时、自动恢复次数和通俗的失败原因，并统计正在进行、等你回复和近 5 分钟失败的数量。可以在这里停止正在执行的轮次，或重试对话中最近失败的一轮。日期筛选按浏览器本地日期计算；用量汇总覆盖所有匹配记录，缺失用量保持未知。模型可配置每百万输入/输出 Token 的美元价格，在对话开始时冻结；费用为估算，不是服务商账单。
 
-对话会流式展示回复和工具活动，归组工作步骤，可用对话导航条跳转用户轮次，支持追问和取消，并可重新打开持久历史。Agent 执行中发送的消息（网页和飞书都一样）会并入正在运行的任务：**运行** 里只显示这一轮，飞书里沿用这一轮的进度卡片。业务提问请在提问卡片上回答。Enter 发送，Shift+Enter 换行。草稿在同一浏览器标签页中刷新后保留。文件夹按钮可在空闲时上传最大 5 MiB 的输入文件，并把路径插入草稿；实时工作区回收后仍可下载 Artifacts，请让 Agent 将交付物保存到 `./outputs`。信息按钮展示 Agent、模型、Harness、环境模板、飞书身份、来源以及创建时记录的配置，不含变量值、脚本内容或凭据。创建响应丢失时，对话页提供 **恢复创建**，复用冻结的请求和幂等键。
+对话会流式展示回复和工具活动，归组工作步骤，可用对话导航条跳转用户轮次，支持追问和取消，并可重新打开持久历史。Agent 执行中发送的消息（网页和飞书都一样）会并入正在运行的任务：**运行** 里只显示这一轮，飞书里沿用这一轮的进度卡片。业务提问请在提问卡片上回答。Enter 发送，Shift+Enter 换行。草稿在同一浏览器标签页中刷新后保留。文件夹按钮可在空闲时通过 Core 的 Files API 上传最大 50 MiB 的输入文件，并把路径插入草稿；实时工作区回收后仍可下载 Artifacts，请让 Agent 将交付物保存到 `./outputs`。信息按钮展示 Agent、模型、Harness、环境模板、飞书身份、来源以及创建时记录的配置，不含变量值、脚本内容或凭据。创建响应丢失时，对话页提供 **恢复创建**，复用冻结的请求和幂等键。
 
 恢复环境时，如果后续消息的请求响应超时或丢失，网页会保留运行记录，使用原幂等键确认接收后继续跟踪执行结果，不会重复执行。明确被拒绝的请求仍返回错误；始终未开始执行的输入会在预留期结束后报告失败。
 
@@ -131,7 +131,7 @@ Parsar 会跟踪每一轮正在执行的对话，网页和飞书都一样。出
 1. 在卡片上选择 **Agent**，打开 **私聊** 和/或 **群聊**，然后 **保存并启用**。启用需要应用凭证、已配置环境模板的 Agent，以及两者至少开启一项。打开 **群聊** 后，机器人会回复它所在的任何群里的 @ 消息，把机器人拉进群即可使用。谁能添加机器人由开发者后台中应用的可用范围控制。
 2. 在开发者后台启用机器人、长连接事件推送和 `im.message.receive_v1`，发布应用并把它加入目标群。授予接收 @ 消息和以机器人身份发送消息的权限；私聊、消息资源和表情回复需要各自的权限。缺少表情权限不会丢弃消息。
 3. 私聊为每个发送者保持一个对话，直到发送 `/clear`。群聊中 @ 机器人会开启一个话题，每个话题是一个对话，所有在其中回复的人共享。只有应用开通了“获取群组中所有消息”权限（`im:message.group_msg`），话题中不带 @ 的后续消息才会推送给机器人。**扫码创建** 会申请这个权限；**已有应用** 需要在飞书开发者后台开通。话题中只 @ 了其他人的回复是发给他们的，会被忽略。其他机器人和 机器人只服务自己所在的企业，外部联系人发来的消息会被忽略。`@所有人` 会被忽略；关闭 **群聊** 时忽略群消息，关闭 **私聊** 时忽略私聊。更换绑定的 Agent 只影响新话题和新的私聊对话。
-4. 文本、富文本、图片、文件、音视频、引用消息和合并转发会在投递前规范化。附件上限为 8 个、合计 5 MiB。后续消息中的文件会等到对话空闲后写入。引用消息最多读取四层；不读取更早的群消息。
+4. 文本、富文本、图片、文件、音视频、引用消息和合并转发会在投递前规范化。附件上限为 8 个、合计 50 MiB，文件通过 Core 的 Files API 写入工作区。后续消息中的文件会等到对话空闲后写入。引用消息最多读取四层；不读取更早的群消息。
 5. 命令：`/clear` 清空上下文：停止正在执行的任务，下一条消息开始新对话，私聊和群聊话题都适用（群聊仍在同一个话题里）。`/stop` 停止当前任务，优先于排队中的追问，并会先确认不确定的创建再停止。`/answer <call_id> <回答>` 回答待处理的业务问题；只有一个待回答的问题时，直接回复即可。`/help` 列出这些命令。
 
 收到的消息在 WebSocket ACK 之前写入 SQLite；请求 ID 和冻结的负载在重试与重启后保持不变。工作器原地更新一张简洁进度卡片，将待回答的问题合并到卡片中，结束后改成结果。每次回复只展示当前交流的内容，包括回答提问后继续同一 Core Turn 的情况。正文突出当前回复；等待业务选择时优先展示问题，将补充说明折叠，二维码授权说明保持可见。卡片顶部是带颜色的状态标题栏。处理过程按发生顺序排成一条时间线。只有说明直接显示文字；思考折叠在第一句后面；连续的工具调用折叠成一行（例如“运行 3 条命令”，附总用时、失败次数或“进行中”），展开后每次调用再折叠在它的命令后面，可查看参数、输出、错误和退出码。执行中时，标题栏还会显示当前在做什么和已执行的步数；卡片显示最近四步，更早的步骤折叠进分隔线上方的浅色区块；完成后回复放在最前面，整个过程折叠进浅色的 **处理过程** 区块；失败时出错的那一步紧跟在失败原因下面。长内容按字节限制截取并明确标注。每一步都留在卡片里：为了不超过飞书卡片的大小限制，最早的步骤先去掉命令输出，再压成一行；只有几百步的任务，才会把最早的若干步合成一行摘要。飞书消息里从不引导用户去网页。进度每五秒轮询一次。完整历史和 Artifacts 保留在网页对话中。已结束的话题在五分钟后停止轮询，收到新消息时恢复。**消息记录** 列出最近 100 条投递以及未解决的记录；**重试** 保留原有标识。入站消息失败会阻塞该话题后续消息。不确定的出站消息超过 55 分钟后不再重放。停用机器人会暂停投递，但不会取消 Core 中的执行。
diff --git a/example/parsar/server.mjs b/example/parsar/server.mjs
index ebcaa98c9..674db53b9 100644
--- a/example/parsar/server.mjs
+++ b/example/parsar/server.mjs
@@ -1,4 +1,4 @@
-import { readMediaBytes } from "./shared/media.mjs";
+import { maxUploadBytes, readMediaBytes } from "./shared/media.mjs";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createServer } from "node:http";
@@ -24,6 +24,7 @@ const routes = [
   ],
   [/^\/v1\/agents\/environments\/[a-f0-9-]{36}$/, ["GET"]],
   [/^\/v1\/agents\/environments\/[a-f0-9-]{36}\/files$/, ["GET", "POST"]],
+  [/^\/v1\/files$/, ["POST"]],
   [/^\/v1\/agents\/sessions\/[a-f0-9-]{36}\/artifacts$/, ["GET"]],
   [
     /^\/v1\/agents\/sessions\/[a-f0-9-]{36}\/artifacts\/[a-f0-9-]{36}\/content$/,
@@ -97,16 +98,18 @@ function fail(res, status, message) {
 
 export function coreClient(config, fetchImpl = fetch) {
   return async (path, method, body, key) => {
+    // A FormData body is a multipart upload, which sets its own Content-Type.
+    const form = body instanceof FormData;
     const response = await fetchImpl(`${config.target}${path}`, {
       method,
-      ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+      ...(body === undefined ? {} : { body: form ? body : JSON.stringify(body) }),
       redirect: "manual",
-      signal: AbortSignal.timeout(30_000),
+      signal: AbortSignal.timeout(form ? 300_000 : 30_000),
       headers: {
         ...(key ? { "Idempotency-Key": key } : {}),
         Authorization: `Bearer ${config.key}`,
         "OpenAI-Beta": "agents=v1",
-        "Content-Type": "application/json",
+        ...(form ? {} : { "Content-Type": "application/json" }),
       },
     });
     if (response.status >= 300 && response.status < 400)
@@ -270,10 +273,12 @@ export function createHandler(
           size += chunk.length;
           if (
             size >
-            (url.pathname.startsWith("/v1/skills") ||
-            url.pathname.endsWith("/files")
-              ? 8 * 1024 * 1024
-              : 1024 * 1024)
+            (url.pathname === "/v1/files"
+              ? maxUploadBytes + 64 * 1024
+              : url.pathname.startsWith("/v1/skills") ||
+                  url.pathname.endsWith("/files")
+                ? 8 * 1024 * 1024
+                : 1024 * 1024)
           )
             return fail(res, 413, "Request too large.");
           chunks.push(chunk);
@@ -284,7 +289,7 @@ export function createHandler(
           "Content-Type": req.headers["content-type"] || "application/json",
           ...(streaming ? { Accept: "text/event-stream" } : {}),
         };
-        if (url.pathname.startsWith("/v1/skills"))
+        if (url.pathname.startsWith("/v1/skills") || url.pathname === "/v1/files")
           delete headers["OpenAI-Beta"];
         if (req.headers["idempotency-key"])
           headers["Idempotency-Key"] = req.headers["idempotency-key"];
diff --git a/example/parsar/server/feishu.mjs b/example/parsar/server/feishu.mjs
index 470c8ea4a..46d4baefd 100644
--- a/example/parsar/server/feishu.mjs
+++ b/example/parsar/server/feishu.mjs
@@ -1,4 +1,4 @@
-import { artifactContentPath, imageMime, maxMediaBytes, qrImages, qrImagePattern } from "../shared/media.mjs";
+import { artifactContentPath, imageMime, maxMediaBytes, maxUploadBytes, qrImages, qrImagePattern } from "../shared/media.mjs";
 import { createHash, randomUUID } from "node:crypto";
 const stableId = (value) => {
   const hex = createHash("sha256").update(value).digest("hex");
@@ -947,8 +947,8 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
       const chunks = [];
       for await (const chunk of response) {
         total += chunk.length;
-        if (total > 5 * 1024 * 1024)
-          throw new AppError(413, "附件合计不能超过 5 MiB。");
+        if (total > maxUploadBytes)
+          throw new AppError(413, "附件合计不能超过 50 MiB。");
         chunks.push(chunk);
       }
       const bytes = Buffer.concat(chunks);
@@ -976,11 +976,12 @@ export function feishuWorker(store, core, product, makeChannel, configId) {
           .replace(/[^a-zA-Z0-9_.-]/g, "_")
           .slice(-100);
         const path = `/workspace/inputs/${row.id}-${media.files.length}-${filename}`;
-        media.files.push({
-          type: "inline",
-          path,
-          data: bytes.toString("base64"),
-        });
+        // Uploaded once: the message keeps only the File ID across retries.
+        const form = new FormData();
+        form.append("file", new Blob([bytes]), filename);
+        form.append("purpose", "user_data");
+        const file = await core("/v1/files", "POST", form);
+        media.files.push({ type: "file_id", path, file_id: file.id });
         media.text += `\nAttachment: ${path.replace("/workspace/", "./")}`;
       }
     }
diff --git a/example/parsar/server/sessions.mjs b/example/parsar/server/sessions.mjs
index abdb07149..2ec623960 100644
--- a/example/parsar/server/sessions.mjs
+++ b/example/parsar/server/sessions.mjs
@@ -50,13 +50,11 @@ export async function prepareSession(store, resources, id, body, origin = {}, wa
   if (
     !Array.isArray(files) ||
     files.length > 8 ||
-    JSON.stringify(files).length > 7000000 ||
     files.some(
       (file) =>
-        file.type !== "inline" ||
+        file.type !== "file_id" ||
         !/^\/workspace\/inputs\/[a-zA-Z0-9_.-]+$/.test(file.path) ||
-        typeof file.data !== "string" ||
-        !/^[A-Za-z0-9+/]*={0,2}$/.test(file.data),
+        !/^file-[A-Za-z0-9_-]+$/.test(file.file_id),
     )
   )
     throw new AppError(400, "附件格式或大小无效。");
diff --git a/example/parsar/shared/media.mjs b/example/parsar/shared/media.mjs
index 5b566e5e4..fa2fd7351 100644
--- a/example/parsar/shared/media.mjs
+++ b/example/parsar/shared/media.mjs
@@ -1,6 +1,9 @@
 // Only persisted product QR images and public Session Artifacts are media sources.
 export const qrImagePattern = /^\/app\/feishu\/provision\/([a-f0-9-]{36})\/qrcode$/;
 export const maxMediaBytes = 5 * 1024 * 1024;
+// Files people hand to an Agent go to Core's Files API, then into the
+// workspace by File ID, which Core takes up to 50 MiB.
+export const maxUploadBytes = 50 * 1024 * 1024;
 export const artifactContentPath = (sessionId, artifactId) =>
   `/v1/agents/sessions/${encodeURIComponent(sessionId)}/artifacts/${encodeURIComponent(artifactId)}/content`;
 export function qrImages(text) {
diff --git a/example/parsar/src/SessionFiles.tsx b/example/parsar/src/SessionFiles.tsx
index cfdf43264..94598830c 100644
--- a/example/parsar/src/SessionFiles.tsx
+++ b/example/parsar/src/SessionFiles.tsx
@@ -1,4 +1,5 @@
 import { tr } from "./lib/i18n";
+import { maxUploadBytes } from "../shared/media.mjs";
 import { useRef } from "react";
 import { useInfiniteQuery, useMutation } from "@tanstack/react-query";
 import { Upload, Download } from "lucide-react";
@@ -12,9 +13,9 @@ import {
   DialogTitle,
 } from "./components/ui/dialog";
 import { ErrorNotice } from "./components/shared";
-const maxUploadBytes = 5 * 1024 * 1024;
 async function upload(environmentId: string, file: File) {
-  if (file.size > maxUploadBytes) throw new Error(tr("文件不能超过 5 MiB。"));
+  if (!file.size) throw new Error(tr("文件不能为空。"));
+  if (file.size > maxUploadBytes) throw new Error(tr("文件不能超过 50 MiB。"));
   let name = "";
   const encoder = new TextEncoder();
   for (const character of file.name.replace(
@@ -26,17 +27,13 @@ async function upload(environmentId: string, file: File) {
   }
   name ||= "file";
   const path = `/workspace/inputs/${randomUuid()}-${name}`;
-  const data = await new Promise<string>((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onload = () => resolve(String(reader.result).split(",")[1] || "");
-    reader.onerror = () => reject(new Error(tr("无法读取文件，请重新选择。")));
-    reader.readAsDataURL(file);
-  });
+  // Core's Files API takes the bytes; the workspace gets the file by its ID.
+  const uploaded = await api.uploadSourceFile({ file, filename: name });
   try {
     await api.createEnvironmentFile(environmentId, {
-      type: "inline",
+      type: "file_id",
       path,
-      data,
+      file_id: uploaded.id,
     });
   } catch (error) {
     const reason = error instanceof Error ? error.message : tr("请求失败");
diff --git a/example/parsar/src/lib/en.json b/example/parsar/src/lib/en.json
index 4b32e9341..5150ba085 100644
--- a/example/parsar/src/lib/en.json
+++ b/example/parsar/src/lib/en.json
@@ -128,7 +128,6 @@
   "搜索资源或操作": "Search resources or operations",
   "文件": "Files",
   "文件不能超过 32 MiB。": "Files must not exceed 32 MiB.",
-  "文件不能超过 5 MiB。": "Files must not exceed 5 MiB.",
   "新建凭据库": "New vault",
   "无法读取产物。": "Unable to read artifacts.",
   "无法读取文件。": "Unable to read file.",
@@ -520,5 +519,7 @@
   "新建 {{value0}} 的密钥": "New secret for {{value0}}",
   "由绑定的飞书机器人「{{value0}}」提供": "Provided by the bound Feishu bot {{value0}}",
   "请先在飞书接入中给这个 Agent 绑定机器人": "Bind a bot to this Agent under Feishu first",
-  "变量名称不能重复": "Variable names must be unique"
+  "变量名称不能重复": "Variable names must be unique",
+  "文件不能为空。": "The file is empty.",
+  "文件不能超过 50 MiB。": "Files can be at most 50 MiB."
 }
diff --git a/example/parsar/tests/feishu.test.mjs b/example/parsar/tests/feishu.test.mjs
index 62bc93599..ff70446ac 100644
--- a/example/parsar/tests/feishu.test.mjs
+++ b/example/parsar/tests/feishu.test.mjs
@@ -26,6 +26,8 @@ async function setup(t) {
     reject = false;
   const core = async (path, method, body, key) => {
     calls.push({ path, method, body, key });
+    if (method === "POST" && path === "/v1/files")
+      return { id: `file-${randomUUID()}`, bytes: body.get("file").size };
     if (method === "POST") {
       if (reject) throw new AppError(422, "invalid");
       if (!receipts.has(key)) {
@@ -2225,3 +2227,28 @@ test("a new bot takes the name its app has in Feishu, scanned or added", async (
   const unnamed = await bots("PUT", `/app/feishu/bots/${randomUUID()}`, { revision: 0, app_id: "cli_aaaaaaaaaaaaaaaa", app_secret: "wrong", enabled: false });
   assert.equal(unnamed.name, "cli_aaaaaaaaaaaaaaaa");
 });
+
+test("a Feishu file reaches the workspace through Core's Files API, up to 50 MiB", async (t) => {
+  const f = await feishu(t);
+  const worker = f.create();
+  const pdf = Buffer.alloc(6 * 1024 * 1024, 1);
+  f.channel.rawClient.im.messageResource = {
+    get: async () => ({ getReadableStream: async function* () { yield pdf; } }),
+  };
+  worker.receive("cli_0123456789abcdef", {
+    ...f.message,
+    messageId: "om_file",
+    content: '<file key="file_key" name="share.pptx"/>',
+    resources: [{ type: "file", fileKey: "file_key", fileName: "share.pptx" }],
+  });
+  await worker.tick();
+  const upload = f.calls.find((call) => call.path === "/v1/files");
+  assert.equal(upload.body.get("purpose"), "user_data");
+  assert.equal(upload.body.get("file").size, pdf.length, "a 6 MiB file is no longer refused");
+  const creation = f.calls.findLast((call) => call.path === "/v1/agents/sessions" && call.method === "POST");
+  const [file] = creation.body.environment.files.filter((entry) => entry.path.startsWith("/workspace/inputs/"));
+  assert.equal(file.type, "file_id");
+  assert.match(file.file_id, /^file-/);
+  assert.match(file.path, /share\.pptx$/);
+  assert.doesNotMatch(JSON.stringify(f.store.list("feishu_inbound")), /AQEBAQEB/, "the message keeps no file bytes");
+});
diff --git a/example/parsar/tests/fixture.mjs b/example/parsar/tests/fixture.mjs
index e76fe7a52..9517e8d67 100644
--- a/example/parsar/tests/fixture.mjs
+++ b/example/parsar/tests/fixture.mjs
@@ -44,6 +44,8 @@ const page = (data) => ({
   first_id: data[0]?.id || null,
   last_id: data.at(-1)?.id || null,
 });
+// Files uploaded through the Files API, by ID, with their sizes.
+const uploads = new Map();
 createServer(async (req, res) => {
   const url = new URL(req.url, "http://localhost");
   const chunks = [];
@@ -475,6 +477,27 @@ createServer(async (req, res) => {
     }
     return reply(session, 201);
   }
+  if (url.pathname === "/v1/files" && req.method === "POST") {
+    const form = await new Request("http://fixture/", {
+      method: "POST",
+      headers: { "content-type": req.headers["content-type"] },
+      body: bytes,
+    }).formData();
+    const file = form.get("file");
+    const id = `file-${randomUUID()}`;
+    uploads.set(id, file.size);
+    return reply({
+      id,
+      object: "file",
+      bytes: file.size,
+      created_at: Math.floor(Date.now() / 1000),
+      filename: file.name,
+      purpose: form.get("purpose"),
+      status: "processed",
+      expires_at: null,
+      status_details: null,
+    });
+  }
   const fileMatch = url.pathname.match(
     /^\/v1\/agents\/environments\/([^/]+)\/files$/,
   );
@@ -485,7 +508,7 @@ createServer(async (req, res) => {
           object: "agent.environment.file",
           environment_id: fileMatch[1],
           path: body.path,
-          size_bytes: Buffer.from(body.data, "base64").length,
+          size_bytes: body.type === "file_id" ? uploads.get(body.file_id) : Buffer.from(body.data, "base64").length,
         },
         201,
       );
diff --git a/example/parsar/tests/product.test.mjs b/example/parsar/tests/product.test.mjs
index 80cdb4b4f..c0e1b1aa5 100644
--- a/example/parsar/tests/product.test.mjs
+++ b/example/parsar/tests/product.test.mjs
@@ -42,7 +42,7 @@ test("environment templates prepare hosted Sessions, protect variables and freez
         input: "Read config",
         agent_id: agent.id,
         files: [
-          { type: "inline", path: "/workspace/inputs/input.txt", data: "eA==" },
+          { type: "file_id", path: "/workspace/inputs/input.txt", file_id: "file-input" },
         ],
       },
       id,
diff --git a/example/parsar/tests/workflow.spec.ts b/example/parsar/tests/workflow.spec.ts
index 006ba7610..997760c4b 100644
--- a/example/parsar/tests/workflow.spec.ts
+++ b/example/parsar/tests/workflow.spec.ts
@@ -1,4 +1,5 @@
 import { test, expect, type Page } from "@playwright/test";
+import { writeFile } from "node:fs/promises";
 const appOrigin = `http://127.0.0.1:${process.env.OAC_EXAMPLE_PORT || "18180"}`;
 async function navigate(page: Page, name: string) {
   if (["能力", "模型", "凭据"].includes(name)) {
@@ -612,18 +613,17 @@ test("an active reply without a replayed item baseline refreshes immediately on
 
 test("conversation uploads insert a file path and download binary artifacts without leaving the conversation", async ({
   page,
-}) => {
+}, testInfo) => {
   await resources(page);
   await agent(page);
   await converse(page);
   await expect(page.getByLabel("继续对话")).toBeVisible();
   await page.getByRole("button", { name: "文件", exact: true }).click();
-  await page.getByLabel("选择上传文件").setInputFiles({
-    name: "large.bin",
-    mimeType: "application/octet-stream",
-    buffer: Buffer.alloc(5 * 1024 * 1024 + 1),
-  });
-  await expect(page.getByRole("alert")).toContainText("文件不能超过 5 MiB");
+  // Playwright passes buffers only up to 50 MB, so the oversized file is on disk.
+  const large = testInfo.outputPath("large.bin");
+  await writeFile(large, Buffer.alloc(50 * 1024 * 1024 + 1));
+  await page.getByLabel("选择上传文件").setInputFiles(large);
+  await expect(page.getByRole("alert")).toContainText("文件不能超过 50 MiB");
   await page.getByLabel("选择上传文件").setInputFiles({
     name: "numbers.csv",
     mimeType: "text/csv",
@@ -636,14 +636,16 @@ test("conversation uploads insert a file path and download binary artifacts with
   await page.getByRole("button", { name: "文件", exact: true }).click();
   const uploaded = page.waitForRequest(
     (request) =>
-      request.method() === "POST" && request.url().endsWith("/files"),
+      request.method() === "POST" && /\/environments\/[^/]+\/files$/.test(request.url()),
   );
   await page.getByLabel("选择上传文件").setInputFiles({
     name: "中".repeat(80) + ".txt",
     mimeType: "text/plain",
     buffer: Buffer.from("small"),
   });
-  const uploadedPath = (await uploaded).postDataJSON().path;
+  const written = (await uploaded).postDataJSON();
+  expect(written.type, "the workspace gets the file by its Files API ID").toBe("file_id");
+  const uploadedPath = written.path;
   expect(
     Buffer.byteLength(uploadedPath.split("/").at(-1), "utf8"),
   ).toBeLessThanOrEqual(255);