diff --git a/.gitignore b/.gitignore
index 4aebc103..de6dbc5f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,7 @@
 # Workspace/editor
 .vscode/
 frontend-web/.vscode/
-
+node_modules/
 # Claude Code local-only settings (per-user permissions, not shared)
 .claude/settings.local.json
 
@@ -84,6 +84,9 @@ offline-backend-20260512/backend/tests/*
 deploy
 .history
 
+# Cloned third-party repos (local only)
+git-clone/
+
 # Repo-root offline dependency pack (local only)
 /dist/
 
diff --git a/browser-extension/deer-web-clipper/README.md b/browser-extension/deer-web-clipper/README.md
new file mode 100644
index 00000000..608c3303
--- /dev/null
+++ b/browser-extension/deer-web-clipper/README.md
@@ -0,0 +1,136 @@
+# zncm Web Clipper
+
+这是给 zncm 使用的 Chrome 插件，安装后默认连接 `config.js` 中配置好的服务地址。
+
+默认地址配置在 `browser-extension/deer-web-clipper/config.js`：
+
+```js
+globalThis.ZNCM_WEB_CLIPPER_CONFIG = Object.freeze({
+  defaultWebBaseUrl: "http://47.94.209.59:2026",
+  defaultApiBaseUrl: "http://47.94.209.59:2026",
+});
+```
+
+如果部署地址变化，只需要修改 `config.js` 里的这两个字段，然后重新加载插件。
+
+正常情况下不需要手动配置 URL，也不需要手动复制 token。
+
+## 能做什么
+
+1. 把当前浏览器标签页发送到 zncm，作为 Markdown 附件进入聊天。
+2. 接收 zncm 聊天中由 `browser_fetch_page` 工具创建的网页抓取任务。
+3. 插件在 Chrome 中打开目标网页，读取可见文本和表格，再把结果回传给 zncm。
+4. 在普通网页右下角显示“zncm 页面问答”浮窗，直接把当前页面内容交给 zncm 问答。
+5. 接收 zncm 的 `browser_act` 交互式操作任务：在 Chrome 中打开页面并按 zncm 的指令**操作页面**——点击、输入、滚动、等待、页内跳转，每一步把页面上的可交互元素清单和正文回传给 zncm，由 zncm 决定下一步（observe→act 循环）。
+
+## 页面操作（browser_act）
+
+除了只读抓取，zncm 还能驱动插件**实际操作网页**，完成登录、填表、翻页找数据等多步任务：
+
+1. zncm 调用 `browser_act` 工具，先 `navigate` 打开页面。
+2. 插件打开标签页（同一会话会复用这个标签页），扫描页面上的可交互元素，给每个元素编号后连同正文回传给 zncm。
+3. zncm 根据元素编号决定下一步（点第 3 个按钮、在第 1 个输入框填字……），再次调用 `browser_act`。
+4. 插件执行动作、重新扫描页面、回传新状态，如此循环，直到任务完成。
+5. 任务结束时 zncm 用 `action="close"` 关闭该会话标签页。
+
+支持的动作：`navigate`（打开/跳转 URL）、`click`（点击元素）、`type`（输入文字，可选回车提交）、`scroll`（滚动到元素或下翻一屏）、`wait`（等待某 CSS 选择器出现）、`extract`（重新读取正文）、`observe`（仅重新扫描）、`close`（关闭会话标签页）。
+
+> 提示：页面操作能力较强（可点击任意按钮、提交表单），可在后端 `config.yaml` 用 `browser_context.actions_enabled: false` 关闭，只保留只读抓取。
+
+## 后端启用
+
+在 `offline-backend-20260512/backend/config.yaml` 中保持：
+
+```yaml
+browser_context:
+  enabled: true          # 只读抓取 + 页面问答
+  actions_enabled: true  # 交互式页面操作 browser_act（不需要可设为 false）
+```
+
+修改配置后需要重启后端。
+
+## 安装插件
+
+1. 打开 Chrome 的 `chrome://extensions`。
+2. 开启右上角的“开发者模式”。
+3. 点击“加载已解压的扩展程序”。
+4. 选择目录：`browser-extension/deer-web-clipper`。
+5. 安装后插件名会显示为 `zncm Web Clipper`。
+
+## 安装即用
+
+插件默认已经开启：
+
+- 自动识别已打开 zncm 页面的服务地址。
+- 自动同步已登录 zncm 的 token。
+- 自动轮询 zncm 聊天触发的浏览器抓取任务。
+- 页面问答框默认开启。
+
+如果你打开的是 `config.js` 里配置的默认服务器，通常无需进入设置页。
+
+如果部署地址变了，保持一个已登录的 zncm 页面打开，然后在插件设置里点击：
+
+- `重新识别服务地址`
+- `同步 token`
+
+## 自动同步 Token
+
+插件会自动从两个位置获取登录 token：
+
+1. zncm API 域名下的 `access_token` Cookie，包括 HttpOnly Cookie。
+2. 已登录 zncm 前端页面里的浏览器本地登录态。
+
+切换登录账号后，插件后台每次轮询任务前都会重新同步 token；点击插件里的“同步 token”也可以立即刷新。
+
+如果当前浏览器已经登出 zncm，且打开的 zncm 页面里没有 token，插件会清空旧 token，避免继续用上一个账号请求。
+
+## 页面问答框
+
+安装插件后，普通 `http` / `https` 页面右下角会出现 `AI` 按钮。点击后可以在当前网页上直接提问，例如：
+
+```text
+总结这页的核心结论
+提取页面里的价格和时间
+这张表里哪个指标最高？
+```
+
+插件会读取当前页面可见文本和表格，发送到 zncm，并把 zncm 的回答显示回浮窗里。多轮追问会复用同一个 zncm 会话；如果页面 URL 变化，会自动重新开始当前页会话。
+
+是否显示问答框可以自己控制：
+
+- 插件弹窗里勾选或取消“启用页面问答框”。
+- 插件设置页里勾选或取消“启用页面问答框”。
+
+关闭问答框只会隐藏页面浮窗，不会影响“发送当前页”和 zncm 聊天中的 `browser_fetch_page` 抓取任务。
+
+## 手动发送当前网页
+
+点击插件图标，选择“发送当前页”。
+
+插件会读取当前页面的可见文本和表格，发送到 zncm，并打开一个新的 zncm 聊天页面。zncm 会把网页内容作为上传文件注入到首条问题里。
+
+## 在 zncm 聊天中触发浏览器抓取
+
+在 zncm 中输入带有明确 URL 的问题，例如：
+
+```text
+使用 browser_fetch_page 打开 https://example.com/report，提取页面里的关键表格数据并总结。
+```
+
+执行流程：
+
+1. zncm 调用 `browser_fetch_page` 工具创建浏览器任务。
+2. 插件后台轮询到任务。
+3. 插件在 Chrome 中打开目标网页。
+4. 插件提取页面文本和表格。
+5. 插件把结果回传给 zncm。
+6. zncm 基于回传内容回答你的问题。
+
+这个方式适合读取需要浏览器登录态、内网权限或当前 Chrome 环境才能访问的页面。
+
+## 注意事项
+
+- 目标 URL 必须是明确的 `http` 或 `https` 地址。
+- 插件不能读取 `chrome://` 等浏览器内部页面。
+- 如果目标网站阻止扩展脚本注入，抓取可能失败。
+- 后台任务默认会打开新标签页；是否抓取完成后关闭标签页，可在插件设置里配置。
diff --git a/browser-extension/deer-web-clipper/background.js b/browser-extension/deer-web-clipper/background.js
new file mode 100644
index 00000000..104380f7
--- /dev/null
+++ b/browser-extension/deer-web-clipper/background.js
@@ -0,0 +1,905 @@
+importScripts("config.js", "shared.js");
+
+const ALARM_NAME = "deer-browser-task-poll";
+const LEGACY_LOCAL_API_BASE_URL = "http://localhost:8001";
+const LEGACY_LOCAL_WEB_BASE_URL = "http://localhost:5174";
+let pollTimer = null;
+let isPolling = false;
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function getSettings() {
+  const settings = await chrome.storage.sync.get(DEER_CLIPPER_DEFAULTS);
+  const updates = {};
+  if (!settings.apiBaseUrl || settings.apiBaseUrl === LEGACY_LOCAL_API_BASE_URL) {
+    updates.apiBaseUrl = DEER_CLIPPER_DEFAULTS.apiBaseUrl;
+  }
+  if (!settings.webBaseUrl || settings.webBaseUrl === LEGACY_LOCAL_WEB_BASE_URL) {
+    updates.webBaseUrl = DEER_CLIPPER_DEFAULTS.webBaseUrl;
+  }
+  if (!settings.workerId) {
+    updates.workerId = deerMakeWorkerId();
+  }
+  if (Object.keys(updates).length > 0) {
+    await chrome.storage.sync.set(updates);
+    Object.assign(settings, updates);
+  }
+  return settings;
+}
+
+function pollIntervalMs(settings) {
+  const seconds = Number(settings.taskPollIntervalSeconds || DEER_CLIPPER_DEFAULTS.taskPollIntervalSeconds);
+  return Math.max(3, seconds) * 1000;
+}
+
+function originMatchPattern(value) {
+  try {
+    const url = new URL(deerNormalizeBaseUrl(value));
+    return `${url.protocol}//${url.host}/*`;
+  } catch {
+    return "";
+  }
+}
+
+function normalizeServiceBase(value) {
+  return deerNormalizeBaseUrl(value || "");
+}
+
+function serviceBaseFromTabUrl(value) {
+  try {
+    const url = new URL(value);
+    const path = url.pathname.replace(/\/+$/, "");
+    if (path === "/deerflow" || path.startsWith("/deerflow/")) {
+      return `${url.origin}/deerflow`;
+    }
+    return url.origin;
+  } catch {
+    return "";
+  }
+}
+
+function apiCandidatesForWebBase(webBase, currentApiBase) {
+  const candidates = [];
+  const add = (value) => {
+    const normalized = normalizeServiceBase(value);
+    if (normalized && !candidates.includes(normalized)) {
+      candidates.push(normalized);
+    }
+  };
+
+  add(currentApiBase);
+  add(webBase);
+  add(DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+  add(LEGACY_LOCAL_API_BASE_URL);
+
+  try {
+    const url = new URL(normalizeServiceBase(webBase));
+    if (["5173", "5174", "3000"].includes(url.port)) {
+      const apiUrl = new URL(url.href);
+      apiUrl.port = "8001";
+      add(apiUrl.href);
+    }
+  } catch {
+    // Ignore invalid candidates.
+  }
+
+  return candidates;
+}
+
+async function browserContextStatus(apiBaseUrl) {
+  try {
+    const response = await fetch(`${apiBaseUrl}/api/browser-context/status`, {
+      credentials: "include",
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json().catch(() => null);
+    if (data && typeof data.enabled === "boolean") {
+      return data;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+function tabLooksLikeZncm(tab) {
+  const value = `${tab.url || ""} ${tab.title || ""}`.toLowerCase();
+  return (
+    value.includes("deerflow") ||
+    value.includes("deer") ||
+    value.includes("zncm") ||
+    value.includes("/page/workspace") ||
+    value.includes("/chats/") ||
+    value.includes("#/login")
+  );
+}
+
+async function findOpenZncmTabs(settings) {
+  const tabs = [];
+  const seen = new Set();
+  const addTabs = (items) => {
+    for (const tab of items || []) {
+      if (tab?.id && !seen.has(tab.id)) {
+        seen.add(tab.id);
+        tabs.push(tab);
+      }
+    }
+  };
+
+  for (const pattern of [
+    originMatchPattern(settings.webBaseUrl || DEER_CLIPPER_DEFAULTS.webBaseUrl),
+    originMatchPattern(DEER_CLIPPER_DEFAULTS.webBaseUrl),
+  ]) {
+    if (!pattern) {
+      continue;
+    }
+    try {
+      addTabs(await chrome.tabs.query({ url: pattern }));
+    } catch {
+      // Continue with broader discovery below.
+    }
+  }
+
+  try {
+    const allTabs = await chrome.tabs.query({ url: ["http://*/*", "https://*/*"] });
+    addTabs(allTabs.filter(tabLooksLikeZncm));
+  } catch {
+    // Ignore tab discovery failures.
+  }
+
+  return tabs;
+}
+
+async function discoverServiceBases(settings, force = false) {
+  if (!settings.autoDiscoverServiceUrl && !force) {
+    return settings;
+  }
+
+  let webBaseUrl = normalizeServiceBase(settings.webBaseUrl || DEER_CLIPPER_DEFAULTS.webBaseUrl);
+  let discoveredWebBaseUrl = webBaseUrl;
+  let source = "configured";
+  const tabs = await findOpenZncmTabs(settings);
+  if (tabs.length > 0) {
+    const tabBase = serviceBaseFromTabUrl(tabs[0].url);
+    if (tabBase) {
+      discoveredWebBaseUrl = tabBase;
+      source = `tab:${tabs[0].url || tabBase}`;
+    }
+  }
+
+  let apiBaseUrl = normalizeServiceBase(settings.apiBaseUrl || DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+  let verified = false;
+  for (const candidate of apiCandidatesForWebBase(discoveredWebBaseUrl, apiBaseUrl)) {
+    const status = await browserContextStatus(candidate);
+    if (status) {
+      apiBaseUrl = candidate;
+      webBaseUrl = discoveredWebBaseUrl;
+      verified = true;
+      source = status.enabled ? `${source}:browser_context_enabled` : `${source}:browser_context_disabled`;
+      break;
+    }
+  }
+  if (!verified && force) {
+    source = `${source}:api_not_verified`;
+  }
+
+  const next = {
+    ...settings,
+    apiBaseUrl,
+    webBaseUrl,
+    lastServiceSyncAt: new Date().toISOString(),
+    lastServiceSyncSource: source,
+  };
+
+  if (
+    force ||
+    settings.apiBaseUrl !== next.apiBaseUrl ||
+    settings.webBaseUrl !== next.webBaseUrl ||
+    settings.lastServiceSyncSource !== next.lastServiceSyncSource
+  ) {
+    await chrome.storage.sync.set({
+      apiBaseUrl: next.apiBaseUrl,
+      webBaseUrl: next.webBaseUrl,
+      lastServiceSyncAt: next.lastServiceSyncAt,
+      lastServiceSyncSource: next.lastServiceSyncSource,
+    });
+  }
+  return next;
+}
+
+async function getCookieToken(settings) {
+  if (!chrome.cookies?.get) {
+    return null;
+  }
+  const apiBaseUrl = deerNormalizeBaseUrl(settings.apiBaseUrl || DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+  try {
+    const cookie = await chrome.cookies.get({ url: apiBaseUrl, name: "access_token" });
+    if (cookie?.value) {
+      return { token: cookie.value, source: `cookie:${new URL(apiBaseUrl).host}:access_token` };
+    }
+  } catch (error) {
+    console.warn("Failed to read zncm access_token cookie", error);
+  }
+  return null;
+}
+
+async function getTokenFromOpenZncmTab(settings) {
+  const tabs = await findOpenZncmTabs(settings);
+  let sawZncmTab = false;
+
+  for (const tab of tabs) {
+    if (!tab.id) {
+      continue;
+    }
+    sawZncmTab = true;
+    try {
+      const [result] = await chrome.scripting.executeScript({
+        target: { tabId: tab.id },
+        func: deerExtractAuthTokenFromPage,
+      });
+      const tokenInfo = result?.result;
+      if (tokenInfo?.token) {
+        const tabBase = serviceBaseFromTabUrl(tab.url);
+        if (tabBase && settings.autoDiscoverServiceUrl && settings.webBaseUrl !== tabBase) {
+          await chrome.storage.sync.set({
+            webBaseUrl: tabBase,
+            lastServiceSyncAt: new Date().toISOString(),
+            lastServiceSyncSource: `token-tab:${tab.url || tabBase}`,
+          });
+        }
+        return {
+          token: tokenInfo.token,
+          source: tokenInfo.source || `tab:${tab.url || "open-deer-tab"}`,
+        };
+      }
+    } catch (error) {
+      console.warn("Failed to read zncm token from tab", tab.id, error);
+    }
+  }
+
+  if (sawZncmTab) {
+    return { token: "", source: "open-deer-tab", clearStale: true };
+  }
+  return null;
+}
+
+async function syncAuthToken(settings = null, forceStatus = false) {
+  let current = settings || (await getSettings());
+  current = await discoverServiceBases(current);
+  if (!current.tokenSyncEnabled && !forceStatus) {
+    return current;
+  }
+
+  const tokenInfo = (await getTokenFromOpenZncmTab(current)) || (await getCookieToken(current));
+  if (!tokenInfo?.token) {
+    if (tokenInfo?.clearStale && current.accessToken) {
+      const next = {
+        ...current,
+        accessToken: "",
+        lastTokenSyncSource: "cleared:open-deer-tab-no-token",
+        lastTokenSyncAt: new Date().toISOString(),
+      };
+      await chrome.storage.sync.set({
+        accessToken: "",
+        lastTokenSyncSource: next.lastTokenSyncSource,
+        lastTokenSyncAt: next.lastTokenSyncAt,
+      });
+      return next;
+    }
+    return current;
+  }
+
+  const next = {
+    ...current,
+    accessToken: tokenInfo.token,
+    lastTokenSyncSource: tokenInfo.source,
+    lastTokenSyncAt: new Date().toISOString(),
+  };
+  if (
+    forceStatus ||
+    current.accessToken !== next.accessToken ||
+    current.lastTokenSyncSource !== next.lastTokenSyncSource
+  ) {
+    await chrome.storage.sync.set({
+      accessToken: next.accessToken,
+      lastTokenSyncSource: next.lastTokenSyncSource,
+      lastTokenSyncAt: next.lastTokenSyncAt,
+    });
+  }
+  return next;
+}
+
+async function refreshAlarm(settings) {
+  await chrome.alarms.clear(ALARM_NAME);
+  if (!settings.taskPollingEnabled) {
+    return;
+  }
+  const minutes = Math.max(0.5, pollIntervalMs(settings) / 60000);
+  await chrome.alarms.create(ALARM_NAME, { delayInMinutes: minutes, periodInMinutes: minutes });
+}
+
+async function scheduleNextPoll(delayMs = null) {
+  if (pollTimer) {
+    clearTimeout(pollTimer);
+    pollTimer = null;
+  }
+  const settings = await getSettings();
+  if (!settings.taskPollingEnabled) {
+    return;
+  }
+  const ms = delayMs ?? pollIntervalMs(settings);
+  pollTimer = setTimeout(() => {
+    void pollOnce().catch((error) => console.warn("zncm task poll failed", error));
+  }, ms);
+}
+
+async function waitForTabLoad(tabId, timeoutSeconds) {
+  const timeoutMs = Math.max(5, Number(timeoutSeconds || 30)) * 1000;
+  try {
+    const tab = await chrome.tabs.get(tabId);
+    if (tab.status === "complete") {
+      return true;
+    }
+  } catch {
+    return false;
+  }
+
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      chrome.tabs.onUpdated.removeListener(listener);
+      resolve(false);
+    }, timeoutMs);
+
+    function listener(updatedTabId, changeInfo) {
+      if (updatedTabId === tabId && changeInfo.status === "complete") {
+        clearTimeout(timer);
+        chrome.tabs.onUpdated.removeListener(listener);
+        resolve(true);
+      }
+    }
+
+    chrome.tabs.onUpdated.addListener(listener);
+  });
+}
+
+async function captureFromTab(tabId, maxContentChars) {
+  const [result] = await chrome.scripting.executeScript({
+    target: { tabId },
+    func: deerExtractCurrentPage,
+  });
+  const page = result?.result;
+  if (!page?.content) {
+    throw new Error("当前页面没有可读取的文本。");
+  }
+  const limit = Math.max(1000, Number(maxContentChars || 200000));
+  if (page.content.length > limit) {
+    page.content = `${page.content.slice(0, limit)}\n\n[Truncated by zncm browser task limit]`;
+  }
+  return page;
+}
+
+async function postTaskResult(taskId, settings, payload) {
+  const apiBaseUrl = deerNormalizeBaseUrl(settings.apiBaseUrl || DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+  const response = await fetch(`${apiBaseUrl}/api/browser-context/tasks/${encodeURIComponent(taskId)}/result`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...deerAuthHeaders(settings),
+    },
+    body: JSON.stringify(payload),
+  });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    const detail = typeof data.detail === "string" ? data.detail : JSON.stringify(data.detail || data);
+    throw new Error(detail || `HTTP ${response.status}`);
+  }
+  return data;
+}
+
+function zncmApiBaseCandidates(settings) {
+  const candidates = [];
+  const add = (value) => {
+    const normalized = deerNormalizeBaseUrl(value || "");
+    if (normalized && !candidates.includes(normalized)) {
+      candidates.push(normalized);
+    }
+  };
+
+  add(settings.apiBaseUrl || DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+  try {
+    const url = new URL(deerNormalizeBaseUrl(settings.apiBaseUrl || ""));
+    if (url.pathname && url.pathname !== "/") {
+      add(url.origin);
+    }
+  } catch {
+    // Ignore invalid configured API URL.
+  }
+  add(DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+  return candidates;
+}
+
+async function zncmFetchJson(settings, path, options) {
+  let lastError = null;
+  for (const apiBaseUrl of zncmApiBaseCandidates(settings)) {
+    try {
+      const response = await fetch(`${apiBaseUrl}${path}`, options);
+      const contentType = response.headers.get("content-type") || "";
+      const data = contentType.includes("application/json")
+        ? await response.json().catch(() => ({}))
+        : { detail: await response.text().catch(() => "") };
+      if (response.ok) {
+        return { data, apiBaseUrl, status: response.status };
+      }
+      const detail = typeof data.detail === "string" ? data.detail : JSON.stringify(data.detail || data);
+      lastError = new Error(detail || `HTTP ${response.status}`);
+      lastError.status = response.status;
+      lastError.detail = detail;
+      lastError.apiBaseUrl = apiBaseUrl;
+      if (response.status !== 404) {
+        throw lastError;
+      }
+    } catch (error) {
+      lastError = error;
+      if (error?.status && error.status !== 404) {
+        throw error;
+      }
+    }
+  }
+  throw lastError || new Error("zncm 服务请求失败。");
+}
+
+function zncmMakeThreadId() {
+  if (globalThis.crypto?.randomUUID) {
+    return globalThis.crypto.randomUUID();
+  }
+  return `zncm-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+function zncmBuildPagePrompt(page, content, truncated, followUp) {
+  const title = page.title || "未知标题";
+  const url = page.url || "未知 URL";
+  const capturedAt = new Date().toISOString();
+  if (followUp) {
+    return [
+      "你是 zncm 页面问答助手。请继续基于本会话里已经读取的网页内容回答用户问题。",
+      "如果已有网页内容不足以回答，请说明缺少哪些信息；不要编造，也不要再尝试抓取其它网页。",
+      `当前页面标题：${title}`,
+      `当前页面 URL：${url}`,
+      `本轮提问时间：${capturedAt}`,
+    ].join("\n\n");
+  }
+
+  return [
+    "你是 zncm 页面问答助手。请直接基于当前网页内容回答用户问题。",
+    "如果网页内容不足以回答，请说明缺少哪些信息；不要编造，也不要再尝试抓取其它网页。",
+    `页面标题：${title}`,
+    `页面 URL：${url}`,
+    `读取时间：${capturedAt}`,
+    truncated ? "说明：页面内容较长，本次已按插件限制截断。" : "说明：页面内容如下。",
+    "当前网页内容：",
+    page.contentType === "text" ? `\`\`\`text\n${content}\n\`\`\`` : content,
+  ].join("\n\n");
+}
+
+function zncmExtractLatestAnswer(values) {
+  const messages = Array.isArray(values?.messages) ? values.messages : [];
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index] || {};
+    const type = String(message.type || message.role || "").toLowerCase();
+    if (type !== "ai" && type !== "assistant") {
+      continue;
+    }
+    const content = message.content;
+    if (typeof content === "string" && content.trim()) {
+      return content.trim();
+    }
+    if (Array.isArray(content)) {
+      const text = content
+        .map((part) => {
+          if (typeof part === "string") return part;
+          if (part && typeof part.text === "string") return part.text;
+          return "";
+        })
+        .filter(Boolean)
+        .join("\n")
+        .trim();
+      if (text) {
+        return text;
+      }
+    }
+  }
+  return "";
+}
+
+async function askZncmViaRunsWait(settings, payload, page, question) {
+  const contentLimit = 60000;
+  const rawContent = String(page.content || "");
+  const truncated = rawContent.length > contentLimit;
+  const content = truncated ? `${rawContent.slice(0, contentLimit)}\n\n[Truncated locally by zncm Web Clipper]` : rawContent;
+  const threadId = payload.threadId || zncmMakeThreadId();
+  const promptPrefix = zncmBuildPagePrompt(page, content, truncated, Boolean(payload.threadId));
+  const { data } = await zncmFetchJson(settings, "/api/runs/wait", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...deerAuthHeaders(settings),
+    },
+    body: JSON.stringify({
+      assistant_id: "lead_agent",
+      input: {
+        messages: [
+          {
+            type: "human",
+            content: question,
+            additional_kwargs: {
+              prompt_prefix: promptPrefix,
+            },
+          },
+        ],
+      },
+      config: {
+        configurable: {
+          thread_id: threadId,
+        },
+      },
+      metadata: {
+        source: "zncm_page_assistant",
+        browser_context_url: page.url || "",
+        browser_context_title: page.title || "",
+        browser_context_fallback: true,
+      },
+      stream_mode: ["values"],
+      on_disconnect: "continue",
+      multitask_strategy: "reject",
+    }),
+  });
+  return {
+    success: true,
+    thread_id: threadId,
+    run_id: "",
+    answer: zncmExtractLatestAnswer(data) || "zncm 没有返回可显示的答案。",
+    truncated,
+    message: "zncm 页面问答已完成。",
+  };
+}
+
+async function askZncmAboutPage(payload) {
+  let settings = await getSettings();
+  settings = await discoverServiceBases(settings);
+  settings = await syncAuthToken(settings);
+  if (!settings.pageAssistantEnabled) {
+    throw new Error("页面问答框已关闭。");
+  }
+
+  const page = payload?.page || {};
+  const question = String(payload?.question || "").trim();
+  if (!question) {
+    throw new Error("请输入要询问的问题。");
+  }
+  if (!page.content) {
+    throw new Error("当前页面没有可读取的正文。");
+  }
+
+  try {
+    const { data } = await zncmFetchJson(settings, "/api/browser-context/ask", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...deerAuthHeaders(settings),
+      },
+      body: JSON.stringify({
+        thread_id: payload.threadId || null,
+        title: page.title || "",
+        url: page.url || "",
+        content: page.content || "",
+        content_type: page.contentType || "markdown",
+        question,
+      }),
+    });
+    return data;
+  } catch (error) {
+    const detail = String(error?.detail || error?.message || "");
+    if (error?.status === 404 && !/browser context integration is disabled/i.test(detail)) {
+      return askZncmViaRunsWait(settings, payload, page, question);
+    }
+    throw error;
+  }
+}
+
+async function getActSessionMap() {
+  try {
+    const stored = await chrome.storage.session.get({ actSessions: {} });
+    return stored.actSessions && typeof stored.actSessions === "object" ? stored.actSessions : {};
+  } catch {
+    return {};
+  }
+}
+
+async function setActSessionTab(sessionId, tabId) {
+  if (!sessionId) return;
+  const map = await getActSessionMap();
+  map[sessionId] = tabId;
+  await chrome.storage.session.set({ actSessions: map }).catch(() => {});
+}
+
+async function removeActSession(sessionId) {
+  if (!sessionId) return;
+  const map = await getActSessionMap();
+  if (sessionId in map) {
+    delete map[sessionId];
+    await chrome.storage.session.set({ actSessions: map }).catch(() => {});
+  }
+}
+
+async function resolveSessionTabId(sessionId) {
+  const map = await getActSessionMap();
+  const tabId = map[sessionId];
+  if (!tabId) return null;
+  try {
+    await chrome.tabs.get(tabId);
+    return tabId;
+  } catch {
+    await removeActSession(sessionId);
+    return null;
+  }
+}
+
+async function performActionInTab(tabId, action) {
+  const [result] = await chrome.scripting.executeScript({
+    target: { tabId },
+    func: deerPerformAction,
+    args: [action],
+  });
+  return result?.result || { status: "ok", message: "" };
+}
+
+async function observeTab(tabId, maxElements) {
+  const [result] = await chrome.scripting.executeScript({
+    target: { tabId },
+    func: deerObservePage,
+    args: [maxElements],
+  });
+  const observation = result?.result;
+  if (!observation) {
+    throw new Error("当前页面无法读取交互元素。");
+  }
+  return observation;
+}
+
+async function runActTask(task, settings) {
+  const sessionId = task.session_id || "";
+  const action = task.action || {};
+  const actionType = String(action.type || "").toLowerCase();
+  const maxElements = 150;
+
+  try {
+    if (!sessionId) {
+      throw new Error("act 任务缺少 session_id。");
+    }
+
+    if (actionType === "close") {
+      const tabId = await resolveSessionTabId(sessionId);
+      if (tabId) {
+        await chrome.tabs.remove(tabId).catch(() => {});
+      }
+      await removeActSession(sessionId);
+      await postTaskResult(task.id, settings, {
+        kind: "act",
+        observation: { action_status: "ok", message: "Tab closed.", url: "", title: "", elements: [], text: "" },
+        metadata: { source: "zncm-web-clipper", worker_id: settings.workerId, session_id: sessionId },
+      });
+      return;
+    }
+
+    let tabId = await resolveSessionTabId(sessionId);
+
+    if (actionType === "navigate") {
+      const url = String(action.url || task.url || "");
+      if (!url) {
+        throw new Error("navigate 动作缺少 url。");
+      }
+      if (tabId) {
+        await chrome.tabs.update(tabId, { url });
+      } else {
+        const tab = await chrome.tabs.create({ url, active: false });
+        tabId = tab.id;
+        await setActSessionTab(sessionId, tabId);
+      }
+      await waitForTabLoad(tabId, settings.taskPageLoadTimeoutSeconds);
+      await delay(800);
+    } else {
+      if (!tabId) {
+        throw new Error("会话标签页不存在，请先用 navigate 打开页面。");
+      }
+      const outcome = await performActionInTab(tabId, action);
+      // Give the page a moment to react / navigate, then settle.
+      await delay(400);
+      await waitForTabLoad(tabId, settings.taskPageLoadTimeoutSeconds);
+      await delay(500);
+      if (outcome.status === "error") {
+        const observation = await observeTab(tabId, maxElements).catch(() => ({ elements: [], text: "", url: "", title: "" }));
+        await postTaskResult(task.id, settings, {
+          kind: "act",
+          observation: { ...observation, action_status: outcome.status, message: outcome.message },
+          metadata: { source: "zncm-web-clipper", worker_id: settings.workerId, session_id: sessionId },
+        });
+        return;
+      }
+    }
+
+    const observation = await observeTab(tabId, maxElements);
+    await postTaskResult(task.id, settings, {
+      kind: "act",
+      title: observation.title || "",
+      url: observation.url || "",
+      observation: { ...observation, action_status: "ok", message: "" },
+      metadata: { source: "zncm-web-clipper", worker_id: settings.workerId, session_id: sessionId },
+    });
+  } catch (error) {
+    await postTaskResult(task.id, settings, {
+      kind: "act",
+      error: error instanceof Error ? error.message : String(error),
+      metadata: { source: "zncm-web-clipper", worker_id: settings.workerId, session_id: sessionId },
+    }).catch((submitError) => console.warn("Failed to submit zncm act task error", submitError));
+  }
+}
+
+async function runFetchTask(task, settings) {
+  let tabId = null;
+  try {
+    const tab = await chrome.tabs.create({ url: task.url, active: false });
+    tabId = tab.id;
+    await waitForTabLoad(tabId, settings.taskPageLoadTimeoutSeconds);
+    await delay(750);
+    const page = await captureFromTab(tabId, task.max_content_chars);
+    await postTaskResult(task.id, settings, {
+      kind: "fetch",
+      title: page.title,
+      url: page.url,
+      content: page.content,
+      content_type: page.contentType || "markdown",
+      metadata: {
+        source: "zncm-web-clipper",
+        worker_id: settings.workerId,
+        instruction: task.instruction || "",
+      },
+    });
+  } catch (error) {
+    await postTaskResult(task.id, settings, {
+      kind: "fetch",
+      error: error instanceof Error ? error.message : String(error),
+      metadata: {
+        source: "zncm-web-clipper",
+        worker_id: settings.workerId,
+      },
+    }).catch((submitError) => console.warn("Failed to submit zncm task error", submitError));
+  } finally {
+    if (tabId && settings.closeTaskTabs) {
+      await chrome.tabs.remove(tabId).catch(() => {});
+    }
+  }
+}
+
+async function runTask(task, settings) {
+  if ((task.kind || "fetch") === "act") {
+    await runActTask(task, settings);
+    return;
+  }
+  await runFetchTask(task, settings);
+}
+
+async function pollOnce() {
+  if (isPolling) {
+    return { ok: true, message: "任务轮询正在运行。" };
+  }
+
+  isPolling = true;
+  try {
+    let settings = await getSettings();
+    settings = await discoverServiceBases(settings);
+    settings = await syncAuthToken(settings);
+    if (!settings.taskPollingEnabled) {
+      return { ok: false, message: "任务轮询已关闭。" };
+    }
+
+    const apiBaseUrl = deerNormalizeBaseUrl(settings.apiBaseUrl || DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+    const url = `${apiBaseUrl}/api/browser-context/tasks/next?worker_id=${encodeURIComponent(settings.workerId)}`;
+    const response = await fetch(url, { headers: deerAuthHeaders(settings) });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      const detail = typeof data.detail === "string" ? data.detail : JSON.stringify(data.detail || data);
+      throw new Error(detail || `HTTP ${response.status}`);
+    }
+    if (!data.task) {
+      return { ok: true, message: "暂无待处理的 zncm 浏览器任务。" };
+    }
+
+    await runTask(data.task, settings);
+    return { ok: true, message: `已完成 zncm 浏览器任务 ${data.task.id}。` };
+  } finally {
+    isPolling = false;
+    await scheduleNextPoll();
+  }
+}
+
+async function startup() {
+  let settings = await getSettings();
+  settings = await discoverServiceBases(settings);
+  settings = await syncAuthToken(settings);
+  await refreshAlarm(settings);
+  await scheduleNextPoll(1000);
+}
+
+chrome.runtime.onInstalled.addListener(() => void startup());
+chrome.runtime.onStartup.addListener(() => void startup());
+chrome.storage.onChanged.addListener((changes, areaName) => {
+  if (areaName === "sync") {
+    void startup();
+  }
+});
+chrome.alarms.onAlarm.addListener((alarm) => {
+  if (alarm.name === ALARM_NAME) {
+    void pollOnce().catch((error) => console.warn("zncm alarm poll failed", error));
+  }
+});
+chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+  if (message?.type === "zncm-discover-service") {
+    getSettings()
+      .then((settings) => discoverServiceBases(settings, true))
+      .then((settings) =>
+        sendResponse({
+          ok: Boolean(settings.apiBaseUrl && settings.webBaseUrl),
+          message: `服务地址：${settings.webBaseUrl}；API：${settings.apiBaseUrl}`,
+          apiBaseUrl: settings.apiBaseUrl,
+          webBaseUrl: settings.webBaseUrl,
+          source: settings.lastServiceSyncSource || "",
+        }),
+      )
+      .catch((error) => sendResponse({ ok: false, message: error instanceof Error ? error.message : String(error) }));
+    return true;
+  }
+
+  if (message?.type === "zncm-sync-token") {
+    syncAuthToken(null, true)
+      .then((settings) => {
+        const hasToken = Boolean(settings.accessToken);
+        sendResponse({
+          ok: hasToken,
+          message: hasToken
+            ? `Token 已从 ${settings.lastTokenSyncSource || "zncm"} 同步。`
+            : "没有找到 zncm token。请打开已登录的 zncm 页面后重试。",
+          source: settings.lastTokenSyncSource || "",
+        });
+      })
+      .catch((error) => sendResponse({ ok: false, message: error instanceof Error ? error.message : String(error) }));
+    return true;
+  }
+
+  if (message?.type === "zncm-page-agent-ask") {
+    askZncmAboutPage(message)
+      .then((result) => sendResponse({ ok: true, ...result }))
+      .catch((error) => sendResponse({ ok: false, message: error instanceof Error ? error.message : String(error) }));
+    return true;
+  }
+
+  if (message?.type === "zncm-open-options") {
+    chrome.runtime.openOptionsPage()
+      .then(() => sendResponse({ ok: true }))
+      .catch((error) => sendResponse({ ok: false, message: error instanceof Error ? error.message : String(error) }));
+    return true;
+  }
+
+  if (message?.type !== "zncm-poll-now") {
+    return false;
+  }
+  pollOnce()
+    .then((result) => sendResponse(result))
+    .catch((error) => sendResponse({ ok: false, message: error instanceof Error ? error.message : String(error) }));
+  return true;
+});
+
+void startup();
diff --git a/browser-extension/deer-web-clipper/config.js b/browser-extension/deer-web-clipper/config.js
new file mode 100644
index 00000000..5ab04b8d
--- /dev/null
+++ b/browser-extension/deer-web-clipper/config.js
@@ -0,0 +1,9 @@
+// Default deployment settings for zncm Web Clipper.
+//
+// Change these two values before loading or packaging the extension when the
+// zncm service address changes. Users can still override them in the extension
+// settings page after installation.
+globalThis.ZNCM_WEB_CLIPPER_CONFIG = Object.freeze({
+  defaultWebBaseUrl: "http://47.94.209.59:2026",
+  defaultApiBaseUrl: "http://47.94.209.59:2026",
+});
diff --git a/browser-extension/deer-web-clipper/content.js b/browser-extension/deer-web-clipper/content.js
new file mode 100644
index 00000000..1c387461
--- /dev/null
+++ b/browser-extension/deer-web-clipper/content.js
@@ -0,0 +1,737 @@
+(() => {
+  if (window.top !== window || window.__zncmPageAssistantLoaded) {
+    return;
+  }
+  window.__zncmPageAssistantLoaded = true;
+
+  const HOST_ID = "zncm-page-assistant-host";
+  const state = {
+    enabled: true,
+    open: false,
+    busy: false,
+    threadId: "",
+    pageUrl: location.href,
+    messages: [],
+  };
+
+  let host = null;
+  let shadow = null;
+  let ui = {};
+
+  function sendRuntimeMessage(message) {
+    return new Promise((resolve, reject) => {
+      chrome.runtime.sendMessage(message, (response) => {
+        const error = chrome.runtime.lastError;
+        if (error) {
+          reject(new Error(error.message));
+          return;
+        }
+        resolve(response || {});
+      });
+    });
+  }
+
+  function makeElement(tag, className = "", text = "") {
+    const element = document.createElement(tag);
+    if (className) {
+      element.className = className;
+    }
+    if (text) {
+      element.textContent = text;
+    }
+    return element;
+  }
+
+  function setStatus(message) {
+    if (ui.status) {
+      ui.status.textContent = message || "";
+    }
+  }
+
+  function setBusy(busy) {
+    state.busy = busy;
+    if (ui.send) ui.send.disabled = busy;
+    if (ui.input) ui.input.disabled = busy;
+    if (ui.panel) ui.panel.classList.toggle("is-busy", busy);
+  }
+
+  function resetThreadIfPageChanged() {
+    if (state.pageUrl === location.href) {
+      return;
+    }
+    state.pageUrl = location.href;
+    state.threadId = "";
+    state.messages = [];
+    renderMessages();
+    setStatus("页面已变化，下一次提问会重新读取当前页面。");
+  }
+
+  function destroyWidget() {
+    if (host) {
+      host.remove();
+    }
+    host = null;
+    shadow = null;
+    ui = {};
+  }
+
+  function renderMessages() {
+    if (!ui.messages) {
+      return;
+    }
+    ui.messages.replaceChildren();
+    if (state.messages.length === 0) {
+      const empty = makeElement("div", "empty");
+      const emptyTitle = makeElement("strong", "", "问问当前页面");
+      const emptyText = makeElement("span", "", "可以提问页面里的数据、表格、段落和结论。");
+      empty.append(emptyTitle, emptyText);
+      ui.messages.appendChild(empty);
+      return;
+    }
+
+    for (const message of state.messages) {
+      const item = makeElement("div", `message ${message.role}`);
+      const avatar = makeElement("div", "avatar", message.role === "user" ? "你" : "zn");
+      const bubble = makeElement("div", "bubble");
+      const label = makeElement("div", "message-label", message.role === "user" ? "你" : "zncm");
+      const body = makeElement("div", "message-body", message.text);
+      if (message.pending) {
+        body.classList.add("pending");
+      }
+      bubble.append(label, body);
+      item.append(avatar, bubble);
+      ui.messages.appendChild(item);
+    }
+    ui.messages.scrollTop = ui.messages.scrollHeight;
+  }
+
+  function setOpen(open) {
+    state.open = open;
+    if (!ui.panel || !ui.launcher) {
+      return;
+    }
+    ui.panel.classList.toggle("open", open);
+    ui.launcher.classList.toggle("open", open);
+    ui.launcher.setAttribute("aria-expanded", String(open));
+    if (open) {
+      resetThreadIfPageChanged();
+      setTimeout(() => ui.input?.focus(), 50);
+    }
+  }
+
+  async function ask(question) {
+    const normalized = String(question || "").trim();
+    if (!normalized || state.busy) {
+      return;
+    }
+
+    resetThreadIfPageChanged();
+    setBusy(true);
+    setStatus("正在读取页面并发送给 zncm...");
+    state.messages.push({ role: "user", text: normalized });
+    const pending = { role: "assistant", text: "zncm 正在理解当前页面...", pending: true };
+    state.messages.push(pending);
+    renderMessages();
+    ui.input.value = "";
+
+    try {
+      if (typeof deerExtractCurrentPage !== "function") {
+        throw new Error("页面读取脚本未加载，请刷新当前页面后重试。");
+      }
+      const page = deerExtractCurrentPage();
+      const response = await sendRuntimeMessage({
+        type: "zncm-page-agent-ask",
+        page,
+        question: normalized,
+        threadId: state.threadId || "",
+      });
+      if (!response.ok) {
+        throw new Error(response.message || "zncm 没有返回答案。");
+      }
+      state.threadId = response.thread_id || state.threadId;
+      pending.text = response.answer || "zncm 没有返回答案。";
+      pending.pending = false;
+      setStatus(response.truncated ? "已回答。页面内容较长，本次按配置做了截断。" : "已回答。");
+    } catch (error) {
+      pending.text = error instanceof Error ? error.message : "页面问答失败。";
+      pending.pending = false;
+      setStatus("本次问答失败。");
+    } finally {
+      setBusy(false);
+      renderMessages();
+      ui.input.focus();
+    }
+  }
+
+  function buildWidget() {
+    host = document.createElement("div");
+    host.id = HOST_ID;
+    document.documentElement.appendChild(host);
+    shadow = host.attachShadow({ mode: "open" });
+
+    const style = document.createElement("style");
+    style.textContent = `
+      :host {
+        all: initial;
+        color-scheme: light;
+        font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      }
+
+      .launcher,
+      .panel {
+        position: fixed;
+        z-index: 2147483647;
+        font: 14px/1.45 Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      }
+
+      .launcher {
+        right: 20px;
+        bottom: 20px;
+        display: grid;
+        grid-template-columns: auto 1fr;
+        align-items: center;
+        gap: 8px;
+        height: 44px;
+        min-width: 112px;
+        border: 1px solid rgba(15, 118, 110, 0.28);
+        border-radius: 8px;
+        padding: 0 12px 0 10px;
+        background: #0f766e;
+        color: #fff;
+        box-shadow: 0 12px 34px rgba(15, 118, 110, 0.28), 0 2px 8px rgba(17, 24, 39, 0.12);
+        cursor: pointer;
+        font-weight: 750;
+        transition: transform 160ms ease, box-shadow 160ms ease, background 160ms ease;
+      }
+
+      .launcher:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 16px 40px rgba(15, 118, 110, 0.32), 0 4px 12px rgba(17, 24, 39, 0.14);
+      }
+
+      .launcher-mark {
+        display: grid;
+        place-items: center;
+        width: 24px;
+        height: 24px;
+        border-radius: 7px;
+        background: rgba(255, 255, 255, 0.18);
+        font-size: 12px;
+        letter-spacing: 0;
+        box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.2);
+      }
+
+      .launcher.open {
+        background: #115e59;
+      }
+
+      .panel {
+        right: 20px;
+        bottom: 72px;
+        width: min(430px, calc(100vw - 24px));
+        max-height: min(640px, calc(100vh - 96px));
+        display: none;
+        grid-template-rows: auto auto minmax(180px, 1fr) auto;
+        overflow: hidden;
+        border: 1px solid #d6d8dc;
+        border-radius: 8px;
+        background: #ffffff;
+        color: #171717;
+        box-shadow: 0 24px 70px rgba(17, 24, 39, 0.2), 0 1px 2px rgba(17, 24, 39, 0.08);
+      }
+
+      .panel.open {
+        display: grid;
+        animation: zncm-panel-in 160ms ease-out;
+      }
+
+      @keyframes zncm-panel-in {
+        from {
+          opacity: 0;
+          transform: translateY(8px) scale(0.985);
+        }
+        to {
+          opacity: 1;
+          transform: translateY(0) scale(1);
+        }
+      }
+
+      .header {
+        display: grid;
+        gap: 10px;
+        padding: 14px;
+        background: linear-gradient(180deg, #f4fffc 0%, #ffffff 84%);
+        border-bottom: 1px solid #e5e7eb;
+      }
+
+      .header-top {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 12px;
+      }
+
+      .brand {
+        display: flex;
+        align-items: center;
+        min-width: 0;
+        gap: 10px;
+      }
+
+      .brand-mark {
+        display: grid;
+        place-items: center;
+        width: 34px;
+        height: 34px;
+        flex: 0 0 auto;
+        border-radius: 8px;
+        background: #0f766e;
+        color: #fff;
+        font-weight: 800;
+        box-shadow: 0 8px 20px rgba(15, 118, 110, 0.18);
+      }
+
+      .brand-copy {
+        display: grid;
+        min-width: 0;
+        gap: 1px;
+      }
+
+      .brand-copy strong {
+        color: #111827;
+        font-size: 15px;
+        line-height: 1.25;
+      }
+
+      .brand-copy span {
+        overflow: hidden;
+        color: #6b7280;
+        font-size: 12px;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+
+      .header-actions {
+        display: flex;
+        flex: 0 0 auto;
+        gap: 6px;
+      }
+
+      .icon-button {
+        display: grid;
+        place-items: center;
+        width: auto;
+        min-width: 34px;
+        height: 30px;
+        padding: 0 8px;
+        border: 1px solid #dfe3e8;
+        border-radius: 7px;
+        background: #fff;
+        color: #374151;
+        cursor: pointer;
+        font: inherit;
+        font-size: 12px;
+        white-space: nowrap;
+        transition: background 140ms ease, border-color 140ms ease, color 140ms ease;
+      }
+
+      .icon-button:hover {
+        border-color: #0f766e;
+        color: #0f766e;
+        background: #f0fdfa;
+      }
+
+      .page-chip {
+        display: grid;
+        grid-template-columns: auto 1fr;
+        align-items: center;
+        gap: 8px;
+        min-width: 0;
+        border: 1px solid #dbeafe;
+        border-radius: 8px;
+        padding: 8px 10px;
+        background: #f8fbff;
+        color: #334155;
+        box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.8);
+      }
+
+      .page-chip-dot {
+        width: 8px;
+        height: 8px;
+        border-radius: 999px;
+        background: #0f766e;
+      }
+
+      .page-chip-text {
+        overflow: hidden;
+        font-size: 12px;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+
+      .status {
+        min-height: 20px;
+        padding: 9px 14px;
+        border-bottom: 1px solid #f0f2f5;
+        color: #475569;
+        background: #fbfcfd;
+        font-size: 12px;
+      }
+
+      .messages {
+        display: grid;
+        align-content: start;
+        gap: 12px;
+        overflow: auto;
+        padding: 14px;
+        background: linear-gradient(180deg, #f7f8fa 0%, #f3f6f8 100%);
+      }
+
+      .empty {
+        display: grid;
+        gap: 5px;
+        padding: 16px;
+        border: 1px solid #dfe7ed;
+        border-radius: 8px;
+        background: linear-gradient(180deg, #ffffff 0%, #fbfefd 100%);
+        color: #4b5563;
+        box-shadow: 0 8px 20px rgba(15, 23, 42, 0.04);
+      }
+
+      .empty strong {
+        color: #111827;
+        font-size: 14px;
+      }
+
+      .empty span {
+        font-size: 13px;
+      }
+
+      .message {
+        display: grid;
+        grid-template-columns: 28px minmax(0, 1fr);
+        gap: 8px;
+        align-items: start;
+      }
+
+      .message.user {
+        grid-template-columns: minmax(0, 1fr) 28px;
+      }
+
+      .message.user .avatar {
+        grid-column: 2;
+      }
+
+      .message.user .bubble {
+        grid-column: 1;
+        justify-self: end;
+      }
+
+      .avatar {
+        display: grid;
+        place-items: center;
+        width: 28px;
+        height: 28px;
+        border-radius: 8px;
+        background: #e6fffb;
+        color: #0f766e;
+        font-size: 11px;
+        font-weight: 800;
+      }
+
+      .message.user .avatar {
+        background: #111827;
+        color: #fff;
+      }
+
+      .bubble {
+        display: grid;
+        gap: 4px;
+        max-width: 100%;
+      }
+
+      .message-label {
+        color: #6b7280;
+        font-size: 11px;
+      }
+
+      .message.user .message-label {
+        text-align: right;
+      }
+
+      .message-body {
+        max-width: 330px;
+        padding: 10px 12px;
+        border: 1px solid #e5e7eb;
+        border-radius: 8px;
+        background: #fff;
+        color: #171717;
+        white-space: pre-wrap;
+        overflow-wrap: anywhere;
+        box-shadow: 0 1px 2px rgba(15, 23, 42, 0.04);
+      }
+
+      .message.user .message-body {
+        border-color: #0f172a;
+        background: #0f172a;
+        color: #fff;
+      }
+
+      .message-body.pending {
+        color: #6b7280;
+      }
+
+      .message-body.pending::after {
+        content: "";
+        display: inline-block;
+        width: 18px;
+        height: 4px;
+        margin-left: 6px;
+        border-radius: 999px;
+        background: linear-gradient(90deg, #0f766e 0 33%, transparent 33% 100%);
+        background-size: 9px 4px;
+        animation: zncm-thinking 900ms linear infinite;
+        vertical-align: middle;
+      }
+
+      @keyframes zncm-thinking {
+        from {
+          background-position: 0 0;
+        }
+        to {
+          background-position: 18px 0;
+        }
+      }
+
+      .composer-wrap {
+        display: grid;
+        gap: 10px;
+        padding: 12px 14px 14px;
+        background: #fff;
+        border-top: 1px solid #e5e7eb;
+      }
+
+      .quick {
+        display: grid;
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+        gap: 7px;
+      }
+
+      .quick button {
+        border: 1px solid #d6d8dc;
+        border-radius: 8px;
+        padding: 8px 10px;
+        background: #fbfcfd;
+        color: #374151;
+        cursor: pointer;
+        font: inherit;
+        font-size: 12px;
+        text-align: left;
+        transition: background 140ms ease, border-color 140ms ease, color 140ms ease, transform 140ms ease;
+      }
+
+      .quick button:hover {
+        border-color: #0f766e;
+        color: #0f766e;
+        background: #f0fdfa;
+        transform: translateY(-1px);
+      }
+
+      .composer {
+        display: grid;
+        grid-template-columns: 1fr auto;
+        gap: 8px;
+        align-items: end;
+      }
+
+      .composer textarea {
+        min-height: 46px;
+        max-height: 130px;
+        resize: vertical;
+        border: 1px solid #cfd6dd;
+        border-radius: 8px;
+        padding: 10px 11px;
+        color: #171717;
+        background: #fbfcfd;
+        font: inherit;
+        outline: none;
+      }
+
+      .composer textarea:focus {
+        border-color: #0f766e;
+        box-shadow: 0 0 0 3px rgba(15, 118, 110, 0.12);
+      }
+
+      .composer button {
+        height: 42px;
+        border: 0;
+        border-radius: 8px;
+        padding: 0 14px;
+        background: #0f766e;
+        color: #fff;
+        cursor: pointer;
+        font: inherit;
+        font-weight: 750;
+        box-shadow: 0 8px 18px rgba(15, 118, 110, 0.2);
+        transition: transform 140ms ease, background 140ms ease, box-shadow 140ms ease;
+      }
+
+      .composer button:hover {
+        background: #115e59;
+        transform: translateY(-1px);
+        box-shadow: 0 10px 22px rgba(15, 118, 110, 0.24);
+      }
+
+      .panel.is-busy .brand-mark,
+      .panel.is-busy .launcher-mark {
+        opacity: 0.82;
+      }
+
+      .composer button:disabled,
+      .quick button:disabled,
+      .icon-button:disabled {
+        cursor: not-allowed;
+        opacity: 0.6;
+      }
+
+      @media (max-width: 480px) {
+        .launcher {
+          right: 12px;
+          bottom: 12px;
+          min-width: 96px;
+        }
+
+        .panel {
+          right: 12px;
+          bottom: 64px;
+          width: calc(100vw - 24px);
+          max-height: calc(100vh - 80px);
+        }
+
+        .message-body {
+          max-width: calc(100vw - 104px);
+        }
+
+        .quick {
+          grid-template-columns: 1fr;
+        }
+      }
+    `;
+
+    const launcher = makeElement("button", "launcher");
+    launcher.type = "button";
+    launcher.title = "打开 zncm 页面问答";
+    launcher.setAttribute("aria-expanded", "false");
+    launcher.append(makeElement("span", "launcher-mark", "zn"), makeElement("span", "", "页面问答"));
+
+    const panel = makeElement("section", "panel");
+    const header = makeElement("header", "header");
+    const headerTop = makeElement("div", "header-top");
+    const brand = makeElement("div", "brand");
+    const brandCopy = makeElement("div", "brand-copy");
+    const title = makeElement("strong", "", "zncm 页面问答");
+    const subtitle = makeElement("span", "", "读取当前页面并回答");
+    brandCopy.append(title, subtitle);
+    brand.append(makeElement("div", "brand-mark", "zn"), brandCopy);
+
+    const actions = makeElement("div", "header-actions");
+    const settings = makeElement("button", "icon-button", "设置");
+    settings.type = "button";
+    settings.title = "打开插件设置";
+    const minimize = makeElement("button", "icon-button", "－");
+    minimize.type = "button";
+    minimize.title = "收起";
+    actions.append(settings, minimize);
+    headerTop.append(brand, actions);
+
+    const pageChip = makeElement("div", "page-chip");
+    const pageTitle = makeElement("span", "page-chip-text", document.title || location.hostname);
+    pageChip.append(makeElement("span", "page-chip-dot"), pageTitle);
+    header.append(headerTop, pageChip);
+
+    const status = makeElement("div", "status", "已连接当前页面。");
+    const messages = makeElement("div", "messages");
+
+    const composerWrap = makeElement("div", "composer-wrap");
+    const quick = makeElement("div", "quick");
+    for (const text of ["总结此页", "提取关键数据", "列出待办", "解释表格"]) {
+      const chip = makeElement("button", "", text);
+      chip.type = "button";
+      chip.addEventListener("click", () => ask(text));
+      quick.appendChild(chip);
+    }
+
+    const composer = makeElement("form", "composer");
+    const input = makeElement("textarea");
+    input.placeholder = "问当前页面...";
+    input.rows = 2;
+    const send = makeElement("button", "", "发送");
+    send.type = "submit";
+    composer.append(input, send);
+    composerWrap.append(quick, composer);
+
+    panel.append(header, status, messages, composerWrap);
+    shadow.append(style, panel, launcher);
+
+    ui = { launcher, panel, subtitle, pageTitle, status, messages, input, send };
+    renderMessages();
+
+    launcher.addEventListener("click", () => setOpen(!state.open));
+    minimize.addEventListener("click", () => setOpen(false));
+    settings.addEventListener("click", () => {
+      sendRuntimeMessage({ type: "zncm-open-options" }).catch((error) => {
+        setStatus(error instanceof Error ? error.message : "无法打开插件设置。");
+      });
+    });
+    composer.addEventListener("submit", (event) => {
+      event.preventDefault();
+      ask(input.value);
+    });
+    input.addEventListener("keydown", (event) => {
+      if (event.key === "Enter" && !event.shiftKey) {
+        event.preventDefault();
+        ask(input.value);
+      }
+    });
+  }
+
+  function ensureWidget() {
+    if (!state.enabled) {
+      destroyWidget();
+      return;
+    }
+    if (document.getElementById(HOST_ID)) {
+      return;
+    }
+    buildWidget();
+  }
+
+  async function loadSettings() {
+    const settings = await chrome.storage.sync.get(DEER_CLIPPER_DEFAULTS);
+    state.enabled = Boolean(settings.pageAssistantEnabled);
+    ensureWidget();
+  }
+
+  chrome.storage.onChanged.addListener((changes, areaName) => {
+    if (areaName !== "sync" || !changes.pageAssistantEnabled) {
+      return;
+    }
+    state.enabled = Boolean(changes.pageAssistantEnabled.newValue);
+    ensureWidget();
+    if (state.enabled) {
+      setStatus("页面问答框已开启。");
+    }
+  });
+
+  setInterval(() => {
+    if (!state.enabled || !ui.pageTitle) {
+      return;
+    }
+    if (state.pageUrl !== location.href) {
+      resetThreadIfPageChanged();
+    }
+    ui.pageTitle.textContent = document.title || location.hostname;
+  }, 1200);
+
+  void loadSettings();
+})();
diff --git a/browser-extension/deer-web-clipper/manifest.json b/browser-extension/deer-web-clipper/manifest.json
new file mode 100644
index 00000000..637adddb
--- /dev/null
+++ b/browser-extension/deer-web-clipper/manifest.json
@@ -0,0 +1,24 @@
+{
+  "manifest_version": 3,
+  "name": "zncm Web Clipper",
+  "version": "0.2.0",
+  "description": "Send pages to zncm and execute browser-backed fetch tasks.",
+  "permissions": ["activeTab", "alarms", "cookies", "scripting", "storage", "tabs"],
+  "host_permissions": ["<all_urls>"],
+  "background": {
+    "service_worker": "background.js"
+  },
+  "action": {
+    "default_title": "zncm Web Clipper",
+    "default_popup": "popup.html"
+  },
+  "options_page": "options.html",
+  "content_scripts": [
+    {
+      "matches": ["http://*/*", "https://*/*"],
+      "js": ["config.js", "shared.js", "content.js"],
+      "run_at": "document_idle",
+      "all_frames": false
+    }
+  ]
+}
diff --git a/browser-extension/deer-web-clipper/options.html b/browser-extension/deer-web-clipper/options.html
new file mode 100644
index 00000000..107964e1
--- /dev/null
+++ b/browser-extension/deer-web-clipper/options.html
@@ -0,0 +1,74 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <title>zncm Web Clipper Settings</title>
+    <link rel="stylesheet" href="styles.css" />
+  </head>
+  <body>
+    <main class="options">
+      <h1>zncm Web Clipper Settings</h1>
+      <label>
+        API 地址
+        <input id="apiBaseUrl" />
+      </label>
+      <label>
+        前端地址
+        <input id="webBaseUrl" />
+      </label>
+      <label class="checkbox">
+        <input id="autoDiscoverServiceUrl" type="checkbox" />
+        自动识别已打开 zncm 页面的服务地址
+      </label>
+      <div class="actions">
+        <button id="discoverService" type="button">重新识别服务地址</button>
+      </div>
+      <p id="serviceStatus" class="status"></p>
+      <label>
+        Access Token
+        <textarea id="accessToken" rows="5" placeholder="会自动从已登录 zncm 页面或 access_token Cookie 获取。也可以手动粘贴。"></textarea>
+      </label>
+      <label class="checkbox">
+        <input id="tokenSyncEnabled" type="checkbox" />
+        自动同步已登录 zncm 的 token
+      </label>
+      <div class="actions">
+        <button id="syncToken" type="button">Sync token now</button>
+      </div>
+      <p id="tokenStatus" class="status"></p>
+      <label class="checkbox">
+        <input id="pageAssistantEnabled" type="checkbox" />
+        启用页面问答框
+      </label>
+      <label>
+        默认首问
+        <textarea id="defaultPrompt" rows="4"></textarea>
+      </label>
+      <label class="checkbox">
+        <input id="taskPollingEnabled" type="checkbox" />
+        启用 zncm 聊天触发的浏览器抓取任务
+      </label>
+      <label>
+        Worker ID
+        <input id="workerId" placeholder="自动生成" />
+      </label>
+      <label>
+        任务轮询间隔秒数
+        <input id="taskPollIntervalSeconds" type="number" min="3" step="1" />
+      </label>
+      <label>
+        页面加载超时秒数
+        <input id="taskPageLoadTimeoutSeconds" type="number" min="5" step="1" />
+      </label>
+      <label class="checkbox">
+        <input id="closeTaskTabs" type="checkbox" />
+        抓取完成后关闭任务标签页
+      </label>
+      <button id="save" type="button">保存</button>
+      <p id="status" class="status"></p>
+    </main>
+    <script src="config.js"></script>
+    <script src="shared.js"></script>
+    <script src="options.js"></script>
+  </body>
+</html>
diff --git a/browser-extension/deer-web-clipper/options.js b/browser-extension/deer-web-clipper/options.js
new file mode 100644
index 00000000..855a6589
--- /dev/null
+++ b/browser-extension/deer-web-clipper/options.js
@@ -0,0 +1,148 @@
+const textFields = [
+  "apiBaseUrl",
+  "webBaseUrl",
+  "accessToken",
+  "defaultPrompt",
+  "workerId",
+  "taskPollIntervalSeconds",
+  "taskPageLoadTimeoutSeconds",
+];
+const checkboxFields = [
+  "autoDiscoverServiceUrl",
+  "tokenSyncEnabled",
+  "pageAssistantEnabled",
+  "taskPollingEnabled",
+  "closeTaskTabs",
+];
+
+function formatServiceStatus(settings) {
+  if (!settings.lastServiceSyncAt) {
+    return `当前服务地址：${settings.webBaseUrl || DEER_CLIPPER_DEFAULTS.webBaseUrl}；API：${settings.apiBaseUrl || DEER_CLIPPER_DEFAULTS.apiBaseUrl}`;
+  }
+  return `当前服务地址：${settings.webBaseUrl || ""}；API：${settings.apiBaseUrl || ""}\n上次识别：${settings.lastServiceSyncAt}（${settings.lastServiceSyncSource || "unknown source"}）`;
+}
+
+function formatTokenStatus(settings) {
+  if (!settings.lastTokenSyncAt) {
+    return "Token 尚未自动同步。";
+  }
+  return `上次 token 同步：${settings.lastTokenSyncAt}（${settings.lastTokenSyncSource || "unknown source"}）`;
+}
+
+async function loadSettings() {
+  const settings = await chrome.storage.sync.get(DEER_CLIPPER_DEFAULTS);
+  if (!settings.workerId) {
+    settings.workerId = deerMakeWorkerId();
+    await chrome.storage.sync.set({ workerId: settings.workerId });
+  }
+  document.getElementById("apiBaseUrl").placeholder =
+    DEER_CLIPPER_DEFAULTS.apiBaseUrl || "在 config.js 中配置默认 API 地址";
+  document.getElementById("webBaseUrl").placeholder =
+    DEER_CLIPPER_DEFAULTS.webBaseUrl || "在 config.js 中配置默认前端地址";
+  for (const field of textFields) {
+    document.getElementById(field).value = settings[field] ?? "";
+  }
+  for (const field of checkboxFields) {
+    document.getElementById(field).checked = Boolean(settings[field]);
+  }
+  document.getElementById("serviceStatus").textContent = formatServiceStatus(settings);
+  document.getElementById("tokenStatus").textContent = formatTokenStatus(settings);
+}
+
+async function saveSettings() {
+  const next = {};
+  for (const field of textFields) {
+    next[field] = document.getElementById(field).value.trim();
+  }
+  for (const field of checkboxFields) {
+    next[field] = document.getElementById(field).checked;
+  }
+  next.apiBaseUrl = deerNormalizeBaseUrl(next.apiBaseUrl || DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+  next.webBaseUrl = deerNormalizeBaseUrl(next.webBaseUrl || DEER_CLIPPER_DEFAULTS.webBaseUrl);
+  next.defaultPrompt = next.defaultPrompt || DEER_CLIPPER_DEFAULT_PROMPT;
+  next.workerId = next.workerId || deerMakeWorkerId();
+  next.taskPollIntervalSeconds = Math.max(3, Number(next.taskPollIntervalSeconds || DEER_CLIPPER_DEFAULTS.taskPollIntervalSeconds));
+  next.taskPageLoadTimeoutSeconds = Math.max(5, Number(next.taskPageLoadTimeoutSeconds || DEER_CLIPPER_DEFAULTS.taskPageLoadTimeoutSeconds));
+  await chrome.storage.sync.set(next);
+  const settings = await chrome.storage.sync.get(DEER_CLIPPER_DEFAULTS);
+  document.getElementById("status").textContent = "已保存。";
+  document.getElementById("serviceStatus").textContent = formatServiceStatus(settings);
+  document.getElementById("tokenStatus").textContent = formatTokenStatus(settings);
+}
+
+function sendDiscoverServiceMessage() {
+  return new Promise((resolve, reject) => {
+    chrome.runtime.sendMessage({ type: "zncm-discover-service" }, (response) => {
+      const error = chrome.runtime.lastError;
+      if (error) {
+        reject(new Error(error.message));
+        return;
+      }
+      resolve(response || { ok: false, message: "服务地址识别没有返回结果。" });
+    });
+  });
+}
+
+function sendSyncTokenMessage() {
+  return new Promise((resolve, reject) => {
+    chrome.runtime.sendMessage({ type: "zncm-sync-token" }, (response) => {
+      const error = chrome.runtime.lastError;
+      if (error) {
+      reject(new Error(error.message));
+        return;
+      }
+      resolve(response || { ok: false, message: "Token 同步没有返回结果。" });
+    });
+  });
+}
+
+async function discoverServiceNow() {
+  const button = document.getElementById("discoverService");
+  button.disabled = true;
+  document.getElementById("serviceStatus").textContent = "正在识别服务地址...";
+  try {
+    await chrome.storage.sync.set({
+      autoDiscoverServiceUrl: document.getElementById("autoDiscoverServiceUrl").checked,
+      apiBaseUrl: deerNormalizeBaseUrl(document.getElementById("apiBaseUrl").value || DEER_CLIPPER_DEFAULTS.apiBaseUrl),
+      webBaseUrl: deerNormalizeBaseUrl(document.getElementById("webBaseUrl").value || DEER_CLIPPER_DEFAULTS.webBaseUrl),
+    });
+    const response = await sendDiscoverServiceMessage();
+    const settings = await chrome.storage.sync.get(DEER_CLIPPER_DEFAULTS);
+    document.getElementById("apiBaseUrl").value = settings.apiBaseUrl || "";
+    document.getElementById("webBaseUrl").value = settings.webBaseUrl || "";
+    document.getElementById("serviceStatus").textContent = response.message || formatServiceStatus(settings);
+  } catch (error) {
+    document.getElementById("serviceStatus").textContent = error instanceof Error ? error.message : "服务地址识别失败。";
+  } finally {
+    button.disabled = false;
+  }
+}
+
+async function syncTokenNow() {
+  const button = document.getElementById("syncToken");
+  button.disabled = true;
+  document.getElementById("tokenStatus").textContent = "正在同步 zncm token...";
+  try {
+    await chrome.storage.sync.set({
+      tokenSyncEnabled: document.getElementById("tokenSyncEnabled").checked,
+      apiBaseUrl: deerNormalizeBaseUrl(document.getElementById("apiBaseUrl").value || DEER_CLIPPER_DEFAULTS.apiBaseUrl),
+      webBaseUrl: deerNormalizeBaseUrl(document.getElementById("webBaseUrl").value || DEER_CLIPPER_DEFAULTS.webBaseUrl),
+    });
+    const response = await sendSyncTokenMessage();
+    const settings = await chrome.storage.sync.get(DEER_CLIPPER_DEFAULTS);
+    document.getElementById("accessToken").value = settings.accessToken || "";
+    document.getElementById("apiBaseUrl").value = settings.apiBaseUrl || "";
+    document.getElementById("webBaseUrl").value = settings.webBaseUrl || "";
+    document.getElementById("serviceStatus").textContent = formatServiceStatus(settings);
+    document.getElementById("tokenStatus").textContent = response.message || formatTokenStatus(settings);
+  } catch (error) {
+    document.getElementById("tokenStatus").textContent = error instanceof Error ? error.message : "Token 同步失败。";
+  } finally {
+    button.disabled = false;
+  }
+}
+
+document.getElementById("save").addEventListener("click", saveSettings);
+document.getElementById("discoverService").addEventListener("click", discoverServiceNow);
+document.getElementById("syncToken").addEventListener("click", syncTokenNow);
+void loadSettings();
diff --git a/browser-extension/deer-web-clipper/popup.html b/browser-extension/deer-web-clipper/popup.html
new file mode 100644
index 00000000..14f81811
--- /dev/null
+++ b/browser-extension/deer-web-clipper/popup.html
@@ -0,0 +1,31 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <title>zncm Web Clipper</title>
+    <link rel="stylesheet" href="styles.css" />
+  </head>
+  <body>
+    <main class="popup">
+      <h1>zncm Web Clipper</h1>
+      <label>
+        首问
+        <textarea id="prompt" rows="4"></textarea>
+      </label>
+      <label class="checkbox">
+        <input id="pageAssistantEnabled" type="checkbox" />
+        启用页面问答框
+      </label>
+      <div class="actions">
+        <button id="send" type="button">发送当前页</button>
+        <button id="syncToken" type="button">同步 token</button>
+        <button id="pollNow" type="button">检查任务</button>
+        <button id="options" type="button" class="secondary">设置</button>
+      </div>
+      <p id="status" class="status"></p>
+    </main>
+    <script src="config.js"></script>
+    <script src="shared.js"></script>
+    <script src="popup.js"></script>
+  </body>
+</html>
diff --git a/browser-extension/deer-web-clipper/popup.js b/browser-extension/deer-web-clipper/popup.js
new file mode 100644
index 00000000..2bf7d403
--- /dev/null
+++ b/browser-extension/deer-web-clipper/popup.js
@@ -0,0 +1,151 @@
+function setStatus(message) {
+  document.getElementById("status").textContent = message;
+}
+
+async function getActiveTab() {
+  const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!tab?.id) {
+    throw new Error("No readable active tab found.");
+  }
+  return tab;
+}
+
+async function captureFromActiveTab(tabId) {
+  const [result] = await chrome.scripting.executeScript({
+    target: { tabId },
+    func: deerExtractCurrentPage,
+  });
+  if (!result?.result?.content) {
+    throw new Error("The current page has no readable text to send.");
+  }
+  return result.result;
+}
+
+async function submitToZncm(page, settings, prompt) {
+  const apiBaseUrl = deerNormalizeBaseUrl(settings.apiBaseUrl || DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+  const response = await fetch(`${apiBaseUrl}/api/browser-context/capture`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...deerAuthHeaders(settings),
+    },
+    body: JSON.stringify({
+      title: page.title,
+      url: page.url,
+      content: page.content,
+      content_type: page.contentType,
+      prompt,
+    }),
+  });
+
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    const detail = typeof data.detail === "string" ? data.detail : JSON.stringify(data.detail || data);
+    throw new Error(detail || `HTTP ${response.status}`);
+  }
+  return data;
+}
+
+async function sendCurrentPage() {
+  const sendButton = document.getElementById("send");
+  sendButton.disabled = true;
+  setStatus("正在读取当前页面...");
+  try {
+    await syncToken({ silent: true });
+    const settings = await chrome.storage.sync.get(DEER_CLIPPER_DEFAULTS);
+    const prompt = document.getElementById("prompt").value.trim() || settings.defaultPrompt || DEER_CLIPPER_DEFAULT_PROMPT;
+    const tab = await getActiveTab();
+    const page = await captureFromActiveTab(tab.id);
+    setStatus("正在发送到 zncm...");
+    const result = await submitToZncm(page, settings, prompt);
+    const webBaseUrl = deerNormalizeBaseUrl(settings.webBaseUrl || DEER_CLIPPER_DEFAULTS.webBaseUrl);
+    await chrome.tabs.create({ url: `${webBaseUrl}/${result.chat_url}`.replace(/\/#/g, "/#") });
+    setStatus("已发送，zncm 聊天页面已打开。");
+  } catch (error) {
+    setStatus(error instanceof Error ? error.message : "发送失败。");
+  } finally {
+    sendButton.disabled = false;
+  }
+}
+
+function sendSyncTokenMessage() {
+  return new Promise((resolve, reject) => {
+    chrome.runtime.sendMessage({ type: "zncm-sync-token" }, (response) => {
+      const error = chrome.runtime.lastError;
+      if (error) {
+        reject(new Error(error.message));
+        return;
+      }
+      resolve(response || { ok: false, message: "Token 同步没有返回结果。" });
+    });
+  });
+}
+
+function sendPollNowMessage() {
+  return new Promise((resolve, reject) => {
+    chrome.runtime.sendMessage({ type: "zncm-poll-now" }, (response) => {
+      const error = chrome.runtime.lastError;
+      if (error) {
+        reject(new Error(error.message));
+        return;
+      }
+      resolve(response || { ok: true, message: "Poll requested." });
+    });
+  });
+}
+
+async function syncToken(options = {}) {
+  const button = document.getElementById("syncToken");
+  button.disabled = true;
+  if (!options.silent) {
+    setStatus("正在同步 zncm token...");
+  }
+  try {
+    const response = await sendSyncTokenMessage();
+    if (!options.silent) {
+      setStatus(response.message || "Token sync finished.");
+    }
+    return response;
+  } catch (error) {
+    if (!options.silent) {
+      setStatus(error instanceof Error ? error.message : "Token 同步失败。");
+    }
+    return { ok: false, message: error instanceof Error ? error.message : "Token 同步失败。" };
+  } finally {
+    button.disabled = false;
+  }
+}
+
+async function pollNow() {
+  const button = document.getElementById("pollNow");
+  button.disabled = true;
+  setStatus("正在检查 zncm 浏览器任务...");
+  try {
+    await syncToken({ silent: true });
+    const response = await sendPollNowMessage();
+    setStatus(response.message || "任务检查完成。");
+  } catch (error) {
+    setStatus(error instanceof Error ? error.message : "任务检查失败。");
+  } finally {
+    button.disabled = false;
+  }
+}
+
+async function togglePageAssistant() {
+  const enabled = document.getElementById("pageAssistantEnabled").checked;
+  await chrome.storage.sync.set({ pageAssistantEnabled: enabled });
+  setStatus(enabled ? "页面问答框已开启。" : "页面问答框已关闭。");
+}
+
+async function init() {
+  const settings = await chrome.storage.sync.get(DEER_CLIPPER_DEFAULTS);
+  document.getElementById("prompt").value = settings.defaultPrompt || DEER_CLIPPER_DEFAULT_PROMPT;
+  document.getElementById("pageAssistantEnabled").checked = Boolean(settings.pageAssistantEnabled);
+  document.getElementById("send").addEventListener("click", sendCurrentPage);
+  document.getElementById("syncToken").addEventListener("click", () => syncToken());
+  document.getElementById("pollNow").addEventListener("click", pollNow);
+  document.getElementById("pageAssistantEnabled").addEventListener("change", togglePageAssistant);
+  document.getElementById("options").addEventListener("click", () => chrome.runtime.openOptionsPage());
+}
+
+void init();
diff --git a/browser-extension/deer-web-clipper/shared.js b/browser-extension/deer-web-clipper/shared.js
new file mode 100644
index 00000000..35cf3f08
--- /dev/null
+++ b/browser-extension/deer-web-clipper/shared.js
@@ -0,0 +1,389 @@
+const DEER_CLIPPER_DEFAULT_PROMPT =
+  "\u8bf7\u57fa\u4e8e\u521a\u521a\u53d1\u9001\u7684\u7f51\u9875\u5185\u5bb9\uff0c\u5148\u7528\u4e2d\u6587\u603b\u7ed3\u8981\u70b9\uff0c\u5e76\u7b49\u5f85\u6211\u7ee7\u7eed\u63d0\u95ee\u3002";
+
+const ZNCM_EXTENSION_CONFIG = globalThis.ZNCM_WEB_CLIPPER_CONFIG || {};
+const ZNCM_DEFAULT_WEB_BASE_URL = String(ZNCM_EXTENSION_CONFIG.defaultWebBaseUrl || "").trim().replace(/\/+$/, "");
+const ZNCM_DEFAULT_API_BASE_URL = String(ZNCM_EXTENSION_CONFIG.defaultApiBaseUrl || "").trim().replace(/\/+$/, "");
+
+const DEER_CLIPPER_DEFAULTS = {
+  apiBaseUrl: ZNCM_DEFAULT_API_BASE_URL,
+  webBaseUrl: ZNCM_DEFAULT_WEB_BASE_URL,
+  autoDiscoverServiceUrl: true,
+  lastServiceSyncAt: "",
+  lastServiceSyncSource: "",
+  accessToken: "",
+  tokenSyncEnabled: true,
+  lastTokenSyncAt: "",
+  lastTokenSyncSource: "",
+  defaultPrompt: DEER_CLIPPER_DEFAULT_PROMPT,
+  pageAssistantEnabled: true,
+  taskPollingEnabled: true,
+  workerId: "",
+  taskPollIntervalSeconds: 5,
+  taskPageLoadTimeoutSeconds: 30,
+  closeTaskTabs: false,
+};
+
+function deerNormalizeBaseUrl(value) {
+  return String(value || "").trim().replace(/\/+$/, "");
+}
+
+function deerAuthHeaders(settings) {
+  const token = String(settings.accessToken || "").trim();
+  if (!token) {
+    return {};
+  }
+  return {
+    Authorization: /^bearer\s+/i.test(token) ? token : `Bearer ${token}`,
+  };
+}
+
+function deerMakeWorkerId() {
+  return `zncm-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+function deerExtractAuthTokenFromPage() {
+  const storageKeys = ["deerflow.auth"];
+  const tokenFieldNames = new Set(["access_token", "accessToken", "token", "id_token", "idToken"]);
+
+  function looksLikeToken(value) {
+    const text = String(value || "").trim();
+    return text.length > 20 && !/\s/.test(text);
+  }
+
+  function findToken(value, depth = 0) {
+    if (value == null || depth > 4) {
+      return "";
+    }
+    if (typeof value === "string") {
+      const text = value.trim();
+      if (!text) {
+        return "";
+      }
+      if ((text.startsWith("{") && text.endsWith("}")) || (text.startsWith("[") && text.endsWith("]"))) {
+        try {
+          return findToken(JSON.parse(text), depth + 1);
+        } catch {
+          return looksLikeToken(text) ? text : "";
+        }
+      }
+      return looksLikeToken(text) ? text : "";
+    }
+    if (typeof value !== "object") {
+      return "";
+    }
+    for (const [key, nested] of Object.entries(value)) {
+      if (tokenFieldNames.has(key) && looksLikeToken(nested)) {
+        return String(nested).trim();
+      }
+    }
+    for (const nested of Object.values(value)) {
+      const token = findToken(nested, depth + 1);
+      if (token) {
+        return token;
+      }
+    }
+    return "";
+  }
+
+  function scanStorage(storage, storageName) {
+    for (const key of storageKeys) {
+      const token = findToken(storage.getItem(key));
+      if (token) {
+        return { token, source: `${storageName}:${key}` };
+      }
+    }
+
+    for (let index = 0; index < storage.length; index += 1) {
+      const key = storage.key(index);
+      if (!key || !/(auth|token|session)/i.test(key)) {
+        continue;
+      }
+      const token = findToken(storage.getItem(key));
+      if (token) {
+        return { token, source: `${storageName}:${key}` };
+      }
+    }
+    return null;
+  }
+
+  try {
+    return scanStorage(window.localStorage, "localStorage") || scanStorage(window.sessionStorage, "sessionStorage");
+  } catch (error) {
+    return { token: "", source: "", error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function deerExtractCurrentPage() {
+  const maxLocalChars = 220000;
+
+  function cleanText(value) {
+    return String(value || "")
+      .replace(/\s+\n/g, "\n")
+      .replace(/\n{3,}/g, "\n\n")
+      .trim();
+  }
+
+  function escapeCell(value) {
+    return cleanText(value).replace(/\|/g, "\\|").replace(/\n/g, " ");
+  }
+
+  function tableToMarkdown(table, index) {
+    const rows = Array.from(table.rows || []).map((row) =>
+      Array.from(row.cells || []).map((cell) => escapeCell(cell.innerText)),
+    );
+    if (rows.length === 0 || rows.every((row) => row.length === 0)) {
+      return "";
+    }
+    const width = Math.max(...rows.map((row) => row.length));
+    const normalized = rows.map((row) => {
+      const next = row.slice();
+      while (next.length < width) next.push("");
+      return next;
+    });
+    const header = normalized[0];
+    const divider = Array.from({ length: width }, () => "---");
+    const body = normalized.slice(1);
+    return [
+      `### Table ${index + 1}`,
+      "",
+      `| ${header.join(" | ")} |`,
+      `| ${divider.join(" | ")} |`,
+      ...body.map((row) => `| ${row.join(" | ")} |`),
+    ].join("\n");
+  }
+
+  const clone = document.body ? document.body.cloneNode(true) : null;
+  if (clone) {
+    clone.querySelectorAll("script, style, noscript, svg, canvas, iframe").forEach((node) => node.remove());
+  }
+
+  const title = document.title || "";
+  const url = location.href;
+  const description = document.querySelector('meta[name="description"]')?.getAttribute("content") || "";
+  const main = clone?.querySelector("article, main, [role='main']") || clone;
+  const text = cleanText(main?.innerText || document.body?.innerText || "");
+  const tables = Array.from(document.querySelectorAll("table"))
+    .map((table, index) => tableToMarkdown(table, index))
+    .filter(Boolean);
+
+  const parts = [];
+  if (description.trim()) {
+    parts.push(`## Meta Description\n\n${cleanText(description)}`);
+  }
+  if (text) {
+    parts.push(`## Page Text\n\n${text}`);
+  }
+  if (tables.length > 0) {
+    parts.push(`## Tables\n\n${tables.join("\n\n")}`);
+  }
+
+  let content = parts.join("\n\n");
+  if (content.length > maxLocalChars) {
+    content = `${content.slice(0, maxLocalChars)}\n\n[Truncated locally by zncm Web Clipper]`;
+  }
+
+  return { title, url, content, contentType: "markdown" };
+}
+
+// Injected into the page to build an indexed list of interactive elements plus
+// the visible page text. Each interactive element is tagged with
+// `data-deer-index` so a follow-up deerPerformAction call can find it by index.
+function deerObservePage(maxElements) {
+  const limit = Math.max(10, Number(maxElements || 150));
+  const DEER_ATTR = "data-deer-index";
+
+  document.querySelectorAll(`[${DEER_ATTR}]`).forEach((node) => node.removeAttribute(DEER_ATTR));
+
+  function isVisible(el) {
+    if (!(el instanceof Element)) return false;
+    const rect = el.getBoundingClientRect();
+    if (rect.width <= 1 && rect.height <= 1) return false;
+    const style = window.getComputedStyle(el);
+    if (style.visibility === "hidden" || style.display === "none" || style.opacity === "0") return false;
+    if (el.disabled) return false;
+    return true;
+  }
+
+  function labelFor(el) {
+    const aria = el.getAttribute("aria-label");
+    if (aria && aria.trim()) return aria.trim();
+    const placeholder = el.getAttribute("placeholder");
+    const title = el.getAttribute("title");
+    const name = el.getAttribute("name");
+    const text = (el.innerText || el.textContent || "").trim();
+    if (text) return text.replace(/\s+/g, " ");
+    if (placeholder && placeholder.trim()) return placeholder.trim();
+    if (title && title.trim()) return title.trim();
+    if (el.value && String(el.value).trim()) return String(el.value).trim();
+    if (name && name.trim()) return name.trim();
+    const alt = el.querySelector?.("img[alt]")?.getAttribute("alt");
+    if (alt && alt.trim()) return alt.trim();
+    return "";
+  }
+
+  const selector = [
+    "a[href]",
+    "button",
+    "input:not([type=hidden])",
+    "select",
+    "textarea",
+    "[role=button]",
+    "[role=link]",
+    "[role=tab]",
+    "[role=menuitem]",
+    "[role=checkbox]",
+    "[role=radio]",
+    "[role=switch]",
+    "[contenteditable=true]",
+    "[onclick]",
+  ].join(",");
+
+  const seen = new Set();
+  const elements = [];
+  let index = 0;
+  for (const el of document.querySelectorAll(selector)) {
+    if (index >= limit) break;
+    if (seen.has(el) || !isVisible(el)) continue;
+    seen.add(el);
+    el.setAttribute(DEER_ATTR, String(index));
+    const tag = el.tagName.toLowerCase();
+    let label = labelFor(el);
+    if (label.length > 200) label = label.slice(0, 200);
+    const entry = { index, tag, label };
+    const type = el.getAttribute("type") || el.getAttribute("role");
+    if (type) entry.type = type;
+    if (tag === "input" || tag === "textarea" || tag === "select") {
+      const value = String(el.value || "");
+      if (value) entry.value = value.slice(0, 80);
+    }
+    if (tag === "a") {
+      const href = el.getAttribute("href") || "";
+      if (href) entry.href = href.slice(0, 200);
+    }
+    elements.push(entry);
+    index += 1;
+  }
+
+  // Inline text extraction so this function stays self-contained when injected
+  // via chrome.scripting.executeScript (no dependency on other content-script fns).
+  let text = "";
+  try {
+    const clone = document.body ? document.body.cloneNode(true) : null;
+    if (clone) {
+      clone.querySelectorAll(`script, style, noscript, svg, canvas, iframe, [${DEER_ATTR}-skip]`).forEach((node) => node.remove());
+    }
+    const main = clone?.querySelector("article, main, [role='main']") || clone;
+    text = String(main?.innerText || document.body?.innerText || "")
+      .replace(/\s+\n/g, "\n")
+      .replace(/\n{3,}/g, "\n\n")
+      .trim();
+  } catch {
+    text = "";
+  }
+
+  return {
+    url: location.href,
+    title: document.title || "",
+    elements,
+    text,
+  };
+}
+
+// Injected into the page to perform a single action on the element previously
+// tagged by deerObservePage (by index). Returns {status, message}.
+async function deerPerformAction(action) {
+  const DEER_ATTR = "data-deer-index";
+  const type = String(action?.type || "").toLowerCase();
+
+  function findByIndex(idx) {
+    if (idx === undefined || idx === null || idx < 0) return null;
+    return document.querySelector(`[${DEER_ATTR}="${idx}"]`);
+  }
+
+  function fireInput(el, value) {
+    const proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+    const setter = Object.getOwnPropertyDescriptor(proto, "value")?.set;
+    if (setter) {
+      setter.call(el, value);
+    } else {
+      el.value = value;
+    }
+    el.dispatchEvent(new Event("input", { bubbles: true }));
+    el.dispatchEvent(new Event("change", { bubbles: true }));
+  }
+
+  try {
+    if (type === "observe" || type === "extract") {
+      return { status: "ok", message: type === "extract" ? "Page text re-read." : "Observed page." };
+    }
+
+    if (type === "scroll") {
+      const el = findByIndex(action.index);
+      if (el) {
+        el.scrollIntoView({ block: "center", behavior: "instant" });
+        return { status: "ok", message: "Scrolled element into view." };
+      }
+      window.scrollBy(0, Math.round(window.innerHeight * 0.85));
+      return { status: "ok", message: "Scrolled down one viewport." };
+    }
+
+    if (type === "wait") {
+      const selector = String(action.wait_for || "").trim();
+      const timeoutMs = Math.max(500, Number(action.timeout_ms || 8000));
+      if (!selector) {
+        await new Promise((resolve) => setTimeout(resolve, Math.min(timeoutMs, 3000)));
+        return { status: "ok", message: "Waited." };
+      }
+      const start = Date.now();
+      while (Date.now() - start < timeoutMs) {
+        if (document.querySelector(selector)) {
+          return { status: "ok", message: `Element ${selector} appeared.` };
+        }
+        await new Promise((resolve) => setTimeout(resolve, 200));
+      }
+      return { status: "timeout", message: `Element ${selector} did not appear within ${timeoutMs}ms.` };
+    }
+
+    if (type === "click") {
+      const el = findByIndex(action.index);
+      if (!el) return { status: "error", message: `No element with index ${action.index}. Re-observe the page.` };
+      el.scrollIntoView({ block: "center", behavior: "instant" });
+      if (typeof el.focus === "function") el.focus();
+      el.click();
+      return { status: "ok", message: `Clicked element ${action.index}.` };
+    }
+
+    if (type === "type") {
+      const el = findByIndex(action.index);
+      if (!el) return { status: "error", message: `No element with index ${action.index}. Re-observe the page.` };
+      el.scrollIntoView({ block: "center", behavior: "instant" });
+      if (typeof el.focus === "function") el.focus();
+      const value = String(action.text ?? "");
+      if (el.isContentEditable) {
+        el.textContent = value;
+        el.dispatchEvent(new Event("input", { bubbles: true }));
+      } else {
+        fireInput(el, value);
+      }
+      if (action.submit) {
+        const enterInit = { bubbles: true, cancelable: true, key: "Enter", code: "Enter", keyCode: 13, which: 13 };
+        el.dispatchEvent(new KeyboardEvent("keydown", enterInit));
+        el.dispatchEvent(new KeyboardEvent("keyup", enterInit));
+        const form = el.form || el.closest("form");
+        if (form && typeof form.requestSubmit === "function") {
+          try {
+            form.requestSubmit();
+          } catch {
+            form.submit?.();
+          }
+        }
+      }
+      return { status: "ok", message: `Typed into element ${action.index}${action.submit ? " and submitted" : ""}.` };
+    }
+
+    return { status: "error", message: `Unsupported action type: ${type}` };
+  } catch (error) {
+    return { status: "error", message: error instanceof Error ? error.message : String(error) };
+  }
+}
diff --git a/browser-extension/deer-web-clipper/styles.css b/browser-extension/deer-web-clipper/styles.css
new file mode 100644
index 00000000..9b971b15
--- /dev/null
+++ b/browser-extension/deer-web-clipper/styles.css
@@ -0,0 +1,96 @@
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  color: #171717;
+  background: #fafafa;
+  font: 14px/1.5 system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+h1 {
+  margin: 0 0 14px;
+  font-size: 16px;
+}
+
+.popup,
+.options {
+  display: grid;
+  gap: 12px;
+  padding: 14px;
+}
+
+.popup {
+  width: 340px;
+}
+
+.options {
+  max-width: 720px;
+}
+
+label {
+  display: grid;
+  gap: 6px;
+  font-weight: 600;
+}
+
+label.checkbox {
+  grid-template-columns: auto 1fr;
+  align-items: center;
+  font-weight: 500;
+}
+
+label.checkbox input {
+  width: auto;
+}
+
+.actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+input,
+textarea {
+  width: 100%;
+  border: 1px solid #d4d4d4;
+  border-radius: 6px;
+  padding: 8px;
+  background: #fff;
+  color: inherit;
+  font: inherit;
+  font-weight: 400;
+}
+
+textarea {
+  resize: vertical;
+}
+
+button {
+  border: 0;
+  border-radius: 6px;
+  padding: 9px 12px;
+  background: #111827;
+  color: #fff;
+  cursor: pointer;
+  font: inherit;
+  font-weight: 600;
+}
+
+button.secondary {
+  background: #e5e7eb;
+  color: #111827;
+}
+
+button:disabled {
+  cursor: not-allowed;
+  opacity: 0.6;
+}
+
+.status {
+  min-height: 20px;
+  margin: 0;
+  color: #525252;
+  white-space: pre-wrap;
+}
diff --git a/frontend-web/.env.development b/frontend-web/.env.development
index 31f7a268..d5dfe0f9 100644
--- a/frontend-web/.env.development
+++ b/frontend-web/.env.development
@@ -1,6 +1,9 @@
 # 本地开发（pnpm dev）— 与原先 .env 保持一致
 # 个人覆盖请新建 .env.development.local（已 gitignore，优先级更高）
 
+# 任务看板数据源：true=真实接口（默认）；改成 false 可让任务分析/三情分析两页走本地假数据。
+VITE_USE_REAL_DATA=true
+
 # Gateway / DeerFlow API
 VITE_BACKEND_BASE_URL=http://127.0.0.1:8001
 VITE_LANGGRAPH_BASE_URL=http://127.0.0.1:8001/api
diff --git a/frontend-web/.env.example b/frontend-web/.env.example
index 2b6fe040..5939e301 100644
--- a/frontend-web/.env.example
+++ b/frontend-web/.env.example
@@ -27,6 +27,12 @@
 # --- 生产打包（见 .env.production）---
 # 部署前修改 .env.production 中的地址，再执行 pnpm build
 
+# --- 任务看板（任务分析 / 三情分析）数据源开关 ---
+# true=走真实接口；false 或未设=这两页使用本地假数据（演示用，无需后端）。
+# .env.development / .env.production / .env.network / .env.sit 均默认 true（真实数据），
+# 仅本机 .env 默认 false（假数据）。改后需重启 dev / 重新打包生效。
+# VITE_USE_REAL_DATA=true
+
 # MaxKey 鉴权根地址（无界 onlineTicket 换 token）
 # VITE_AUTH_BASE_URL=https://auth.y.sit.4.cn
 # VITE_AIPI_CONSUMER_URL=https://ch1.b.uat.4.cn/consumer
diff --git a/frontend-web/.env.network b/frontend-web/.env.network
index 13dfdec3..569b8422 100644
--- a/frontend-web/.env.network
+++ b/frontend-web/.env.network
@@ -1,6 +1,9 @@
 # 本地开发（pnpm dev）— 与原先 .env 保持一致
 # 个人覆盖请新建 .env.development.local（已 gitignore，优先级更高）
 
+# 任务看板数据源：true=真实接口（默认）；改成 false 可让任务分析/三情分析两页走本地假数据。
+VITE_USE_REAL_DATA=true
+
 # Gateway / DeerFlow API
 VITE_BACKEND_BASE_URL=http://47.88.25.99:7001
 VITE_LANGGRAPH_BASE_URL=http://47.88.25.99:7001/api
diff --git a/frontend-web/.env.production b/frontend-web/.env.production
index c04d50dc..08bf2a70 100644
--- a/frontend-web/.env.production
+++ b/frontend-web/.env.production
@@ -1,12 +1,17 @@
 # 生产打包（pnpm build）— 部署前请改成实际内网/生产地址
 # 打包后变量会写入 dist，运行时不可再改
 
+# 任务看板数据源：true=真实接口（默认）；改成 false 可让任务分析/三情分析两页走本地假数据。
+VITE_USE_REAL_DATA=true
+
 # Gateway / DeerFlow API
 VITE_BACKEND_BASE_URL=https://ch1.b.uat.4.cn/deerflow
 VITE_LANGGRAPH_BASE_URL=https://ch1.b.uat.4.cn/deerflow/api
 
 # 轻应用「新建笔记」系列接口
 VITE_NOTE_API_BASE_URL=https://your-intranet-host/note-api
+# CMZS后端接口
+VITE_API_BASE_URL=https://ch1.b.uat.4.cn/zncm
 # 佳来模型对话接口
 VITE_AIPI_CHAT_URL=https://ch1.b.uat.4.cn/gpt
 # 多轮检索接口
diff --git a/frontend-web/.env.sit b/frontend-web/.env.sit
index 1d9a6652..d4a4af7b 100644
--- a/frontend-web/.env.sit
+++ b/frontend-web/.env.sit
@@ -1,12 +1,17 @@
 # SIT 环境打包（pnpm build:sit / npm run build:sit）— 接口地址为 UAT 的 sit 版本
 # 打包后变量会写入 dist，运行时不可再改
 
+# 任务看板数据源：true=真实接口（默认）；改成 false 可让任务分析/三情分析两页走本地假数据。
+VITE_USE_REAL_DATA=true
+
 # Gateway / DeerFlow API
 VITE_BACKEND_BASE_URL=https://ch1.b.sit.4.cn/deerflow
 VITE_LANGGRAPH_BASE_URL=https://ch1.b.sit.4.cn/deerflow/api
 
 # 轻应用「新建笔记」系列接口
 VITE_NOTE_API_BASE_URL=https://your-intranet-host/note-api
+# CMZS后端接口
+VITE_API_BASE_URL=https://ch1.b.sit.4.cn/zncm
 # 佳来模型对话接口
 VITE_AIPI_CHAT_URL=https://ch1.b.sit.4.cn/gpt
 # 多轮检索接口
@@ -21,6 +26,11 @@ VITE_AIPI_KNOWLEDGE_IFRAME_SKIN=red
 VITE_AIPI_MOPECHAT_URL=https://ch1.b.sit.4.cn/likun_b1_mope
 # 工作室/空间后端接口（侧边栏“工作室”列表、空间详情等都走这里，不是 VITE_NOTE_API_BASE_URL）
 VITE_AIPI_BACKENP_URL=https://knowledgetoolserver.b.sit.4.cn
+VITE_NOTEBOOK_API_BASE_URL=https://knowledgetoolserver.b.sit.4.cn
+# 工作室侧边栏显示开关；仅控制入口显示，展开内容仍依赖 notebook 接口成功返回数据
+VITE_STUDIO_ENABLED=true
+# 工作室/笔记本前端地址（用于 auth/callback 等跳转）
+VITE_AIPI_FRONTEND_URL=https://knowledgetoolserver.b.sit.4.cn
 VITE_AIPI_CONSUMER_URL=https://ch1.b.sit.4.cn/consumer
 # A 系统跳转地址（人物/组织/事件等列表项打开链接）
 VITE_AIPI_PRESENT_URL=http://present.a.sit.4.cn/present/domain
diff --git a/frontend-web/docs/product-knowledge-base-dev.md b/frontend-web/docs/product-knowledge-base-dev.md
new file mode 100644
index 00000000..be287bfc
--- /dev/null
+++ b/frontend-web/docs/product-knowledge-base-dev.md
@@ -0,0 +1,1243 @@
+# 产品内知识库沉淀系统开发文档
+
+## 1. 背景
+
+当前项目是一个 DeerFlow 定制化离线部署系统，包含：
+
+- 前端：`frontend-web/`，Vite + React 19 + TypeScript。
+- 后端：`offline-backend-20260512/backend/`，FastAPI Gateway + LangGraph agent runtime。
+- 现有能力：对话线程、工具搜索、引用来源、Markdown 渲染、外部知识库 iframe 页面。
+
+本需求希望将“每次问答、搜索、工具调用、生成报告”等高价值内容自动或手动沉淀为产品内知识库，并在后续问答中可被检索和召回。
+
+本方案以 `ar9av/obsidian-wiki` 为底层知识组织规范：优先复用它的 vault 目录结构、Markdown frontmatter、`index.md`、`log.md`、`hot.md`、`.manifest.json`、wikilink、`wiki-capture`、`wiki-query`、`wiki-export`、`graph-colorize` 等原生技能/页面产物。产品侧负责把这些能力封装成后端 API 和 React 页面。
+
+## 2. 目标
+
+实现一套产品内知识库系统：
+
+1. 支持从单次对话线程沉淀知识。
+2. 支持从搜索结果、工具调用结果沉淀知识。
+3. 支持自动抽取摘要、标签、实体、来源、关键结论。
+4. 支持知识列表、详情、搜索、编辑、删除。
+5. 支持保存 Obsidian 兼容 Markdown 文件。
+6. 支持后续问答时召回相关知识，并显示引用来源。
+7. 首版支持知识图谱页面，后续可增强实体关系抽取、自动去重、知识合并。
+
+## 3. 首版交付范围
+
+首版必须实现：
+
+- 产品内知识库页面：列表、详情、搜索、编辑、删除/归档。
+- 产品内 Markdown 编辑体验：支持编辑正文、预览 Markdown、编辑标题/标签/状态/来源信息。
+- 当前对话沉淀：在聊天线程页面点击“保存到知识库”，生成 obsidian-wiki 兼容 Markdown 笔记。
+- 历史线程批量入库：提供后台接口和前端入口，可批量扫描已有线程并沉淀为知识库内容。
+- 搜索和工具结果沉淀：保存 query、结果标题、摘要、URL、工具名等来源信息。
+- 全局共享知识库：所有用户共用同一套 vault 和数据库索引，不按用户隔离。
+- 审计记录：写入、更新、删除记录 `created_by` / `updated_by`，用于追踪操作来源。
+- Obsidian 兼容 vault：后端自行维护 `index.md`、`log.md`、`hot.md`、`.manifest.json`、wikilinks 和 frontmatter。
+- 图谱页面：后端自行生成 `wiki-export/graph.html` 和 `graph.json`，前端直接 iframe 展示 `graph.html`。
+- 不安装、不调用 `obsidian-wiki` CLI。
+- 知识库功能由新增 `knowledge` 模块独立实现。
+
+首版暂缓实现：
+
+- 精确复刻 Obsidian 桌面端所有交互细节。
+- 图数据库服务。首版图谱用 Markdown wikilinks + `graph.json` / `graph.html` 实现，不额外引入图数据库中间件。
+- 向量 RAG 自动注入。首版先完成知识沉淀、管理、关键词搜索和图谱，向量召回后续增强。
+
+## 4. 总体架构
+
+数据流：
+
+```text
+用户问答 / 搜索 / 工具调用 / 生成文档
+        ↓
+Knowledge Event 采集
+        ↓
+Obsidian Wiki Adapter
+按 obsidian-wiki 原生技能规范抽取、分类、写入 vault
+        ↓
+三类存储
+1. Markdown Vault：obsidian-wiki 原生目录、frontmatter、wikilinks
+2. 数据库：产品检索、列表、来源映射、创建/修改审计
+3. 向量索引：语义检索和 RAG 召回
+        ↓
+前端知识库页面
+列表、搜索、详情、来源、编辑、图谱
+        ↓
+后续问答自动召回相关知识
+```
+
+推荐新增后端模块：
+
+```text
+offline-backend-20260512/backend/app/gateway/routers/knowledge.py
+offline-backend-20260512/backend/packages/harness/deerflow/knowledge/
+```
+
+推荐新增前端模块：
+
+```text
+frontend-web/src/core/knowledge/
+frontend-web/src/pages/KnowledgeBasePage.tsx
+frontend-web/src/components/knowledge/
+```
+
+## 4.1 obsidian-wiki 原生复用策略
+
+必须优先复用 `obsidian-wiki` 的原生约定，而不是另起一套知识库格式。
+
+### 4.1.1 复用对象
+
+从 `ar9av/obsidian-wiki` 复用以下内容：
+
+- `.skills/wiki-capture/SKILL.md`
+  - 用作“对话沉淀为知识笔记”的抽取和写作模板。
+  - 关键要求：写成 declarative knowledge，不保存聊天流水账。
+
+- `.skills/wiki-query/SKILL.md`
+  - 用作知识检索策略参考。
+  - 关键要求：先读 `hot.md` / `index.md` / frontmatter，再逐步升级到正文。
+
+- `.skills/wiki-export/SKILL.md`
+  - 用作知识图谱导出规范。
+  - 复用输出：`wiki-export/graph.json`、`graph.graphml`、`cypher.txt`、`graph.html`。
+
+- `.skills/graph-colorize/SKILL.md`
+  - 后续用于 Obsidian graph 配色。
+
+- `.skills/wiki-status/SKILL.md`
+  - 后续用于知识库状态、孤立页面、delta 分析。
+
+- `.skills/cross-linker/SKILL.md`
+  - 后续用于自动补充 wikilinks。
+
+- `.skills/wiki-dedup/SKILL.md`
+  - 后续用于重复知识合并。
+
+- vault 文件：
+  - `index.md`
+  - `log.md`
+  - `hot.md`
+  - `.manifest.json`
+  - `_insights.md`
+  - `_meta/taxonomy.md`
+
+### 4.1.2 产品封装原则
+
+产品后端新增 `ObsidianWikiAdapter`，负责：
+
+- 初始化 vault。
+- 调用或模拟 `wiki-capture` 的写入流程。
+- 写入 `index.md`、`log.md`、`hot.md`。
+- 维护 `.manifest.json`。
+- 按 `wiki-export` 规范生成 `wiki-export/graph.html/json`。
+- 将 vault 页面同步到产品数据库索引。
+
+前端不直接依赖 obsidian-wiki 技能文件。前端只调用 `/api/knowledge/*`。
+
+### 4.1.3 调用方式优先级
+
+优先级如下：
+
+1. 运行时不使用 `obsidian-wiki` CLI。
+2. 后端内置 obsidian-wiki 兼容实现，输出必须兼容 obsidian-wiki vault。
+3. 后端自行初始化 vault、写入 Markdown、维护 `index.md` / `log.md` / `hot.md` / `.manifest.json`。
+4. 后端自行按 `wiki-export` 规范生成 `wiki-export/graph.html` / `graph.json`。
+5. 对 `wiki-export/graph.html` 这类原生产物，优先直接作为静态页面 iframe 到产品内。
+6. 对 Markdown 笔记列表、详情、编辑，使用产品自研 React 页面读取同一个 vault。
+
+## 5. 与现有系统的关系
+
+可复用现有能力：
+
+- `app/gateway/routers/threads.py`
+  - `GET /api/threads/{thread_id}/state` 可读取线程 messages。
+  - `GET /api/threads/{thread_id}/reference-batches` 可读取工具搜索/引用来源。
+
+- 前端 Markdown 能力
+  - `frontend-web/src/strategy-components/MarkdownRenderer.tsx`
+  - `frontend-web/src/core/threads/export.ts`
+
+- 现有知识库入口
+  - `frontend-web/src/strategy-components/components/resource-management/KnowledgeBaseResourceManagement.tsx`
+  - 当前是 iframe，后续可替换为原生知识库管理页面。
+
+必须复用/兼容的外部项目能力：
+
+- `git-clone/obsidian-wiki/.skills/wiki-capture/SKILL.md`
+- `git-clone/obsidian-wiki/.skills/wiki-query/SKILL.md`
+- `git-clone/obsidian-wiki/.skills/wiki-export/SKILL.md`
+- `git-clone/obsidian-wiki/.skills/wiki-status/SKILL.md`
+- `git-clone/obsidian-wiki/.skills/wiki-dedup/SKILL.md`
+- `git-clone/obsidian-wiki/.skills/cross-linker/SKILL.md`
+
+## 6. 分阶段实现
+
+### 阶段一：首版完整交付
+
+目标：交付可用的产品内共享知识库。用户可以手动沉淀当前对话，也可以批量沉淀历史线程；所有知识写入同一套 obsidian-wiki 兼容 vault，并在产品内完成浏览、搜索、编辑、删除和图谱查看。
+
+范围：
+
+- 新增知识笔记数据库表。
+- 新增 `ObsidianWikiAdapter`。
+- 新增 obsidian-wiki 兼容 Markdown vault 写入能力。
+- 初始化并维护 `index.md`、`log.md`、`hot.md`、`.manifest.json`。
+- 新增 `POST /api/knowledge/ingest/thread/{thread_id}`。
+- 新增 `POST /api/knowledge/ingest/threads/batch`，支持批量扫描并沉淀历史线程。
+- 新增 `POST /api/knowledge/ingest/search`，支持搜索和工具结果来源沉淀。
+- 新增 `GET /api/knowledge/notes`。
+- 新增 `GET /api/knowledge/notes/{note_id}`。
+- 新增 `PUT /api/knowledge/notes/{note_id}`。
+- 新增 `DELETE /api/knowledge/notes/{note_id}`。
+- 新增 `POST /api/knowledge/search`，首版支持关键词/frontmatter/Markdown 内容检索。
+- 新增 `POST /api/knowledge/export/graph`，生成 `wiki-export/graph.html` 和 `graph.json`。
+- 前端新增“保存到知识库”按钮。
+- 前端新增“批量导入历史线程”入口。
+- 前端新增知识库列表、详情、编辑、搜索、删除/归档页面。
+- 前端新增图谱页面，iframe 展示 `wiki-export/graph.html`。
+- 知识库全局共享，不按用户隔离。
+
+阶段一暂缓：
+
+- 向量检索。
+- 自动合并重复知识。
+- agent 回答前的向量 RAG 自动注入。
+
+### 阶段二：向量检索和 RAG 召回
+
+目标：用户后续提问时，自动检索知识库并注入 agent 上下文。
+
+范围：
+
+- 先实现 obsidian-wiki 原生 `wiki-query` 风格的分层检索：
+  - `hot.md`
+  - `index.md`
+  - frontmatter
+  - 相关正文片段
+- 新增 Markdown 分块。
+- 新增 embedding 生成与索引。
+- 新增 `POST /api/knowledge/search`。
+- 在 agent 调用前执行知识召回。
+- 回答中展示引用的知识笔记和来源。
+
+### 阶段三：自动沉淀和知识治理
+
+目标：聊天完成后自动判断是否值得沉淀，并支持去重、合并、编辑审核。
+
+范围：
+
+- 后台任务队列。
+- 价值判断：是否值得入库。
+- 重复检测。
+- 版本记录。
+- 合并建议。
+- 敏感信息过滤。
+- 审核状态：draft、approved、archived。
+
+### 阶段四：图谱增强
+
+目标：在首版 `graph.html` / `graph.json` 基础上增强实体、关系和交互能力。
+
+范围：
+
+- 优先复用 obsidian-wiki `wiki-export` 输出。
+- 直接生成/服务 `wiki-export/graph.html` 作为第一版图谱页面。
+- 读取 `wiki-export/graph.json` 给产品自研图谱组件使用。
+- 后续再做实体抽取、关系抽取和自定义图谱。
+- `GET /api/knowledge/graph`。
+- 前端图谱页面。
+
+## 7. 数据库设计
+
+首版可使用当前项目已有数据库体系。字段名建议使用 snake_case。
+
+### 7.1 knowledge_notes
+
+知识笔记主表。
+
+```sql
+CREATE TABLE knowledge_notes (
+  id VARCHAR(64) PRIMARY KEY,
+  title VARCHAR(512) NOT NULL,
+  summary TEXT,
+  content_md LONGTEXT NOT NULL,
+  vault_path VARCHAR(1024),
+  source_type VARCHAR(64) NOT NULL,
+  source_id VARCHAR(256),
+  status VARCHAR(32) NOT NULL DEFAULT 'approved',
+  confidence FLOAT DEFAULT 0,
+  created_by VARCHAR(128),
+  updated_by VARCHAR(128),
+  created_at DATETIME NOT NULL,
+  updated_at DATETIME NOT NULL
+);
+```
+
+`source_type` 可选：
+
+- `thread`
+- `search`
+- `tool`
+- `file`
+- `manual`
+- `report`
+
+`status` 可选：
+
+- `draft`
+- `approved`
+- `archived`
+
+### 7.2 knowledge_sources
+
+知识来源表。
+
+```sql
+CREATE TABLE knowledge_sources (
+  id VARCHAR(64) PRIMARY KEY,
+  note_id VARCHAR(64) NOT NULL,
+  source_type VARCHAR(64) NOT NULL,
+  thread_id VARCHAR(128),
+  message_id VARCHAR(128),
+  tool_name VARCHAR(128),
+  title VARCHAR(512),
+  url TEXT,
+  snippet TEXT,
+  raw_json LONGTEXT,
+  created_by VARCHAR(128),
+  created_at DATETIME NOT NULL
+);
+```
+
+### 7.3 knowledge_tags
+
+```sql
+CREATE TABLE knowledge_tags (
+  id VARCHAR(64) PRIMARY KEY,
+  name VARCHAR(128) NOT NULL,
+  created_at DATETIME NOT NULL
+);
+```
+
+### 7.4 knowledge_note_tags
+
+```sql
+CREATE TABLE knowledge_note_tags (
+  note_id VARCHAR(64) NOT NULL,
+  tag_id VARCHAR(64) NOT NULL,
+  PRIMARY KEY (note_id, tag_id)
+);
+```
+
+### 7.5 knowledge_entities
+
+阶段五使用。
+
+```sql
+CREATE TABLE knowledge_entities (
+  id VARCHAR(64) PRIMARY KEY,
+  name VARCHAR(256) NOT NULL,
+  entity_type VARCHAR(64),
+  created_at DATETIME NOT NULL
+);
+```
+
+### 7.6 knowledge_relations
+
+阶段五使用。
+
+```sql
+CREATE TABLE knowledge_relations (
+  id VARCHAR(64) PRIMARY KEY,
+  from_note_id VARCHAR(64),
+  to_note_id VARCHAR(64),
+  from_entity_id VARCHAR(64),
+  to_entity_id VARCHAR(64),
+  relation_type VARCHAR(128) NOT NULL,
+  weight FLOAT DEFAULT 1,
+  created_at DATETIME NOT NULL
+);
+```
+
+### 7.7 knowledge_embeddings
+
+阶段三使用。如果使用外部向量库，此表只保存索引映射。
+
+```sql
+CREATE TABLE knowledge_embeddings (
+  id VARCHAR(64) PRIMARY KEY,
+  note_id VARCHAR(64) NOT NULL,
+  chunk_index INT NOT NULL,
+  content TEXT NOT NULL,
+  vector_id VARCHAR(256),
+  created_at DATETIME NOT NULL
+);
+```
+
+## 8. Markdown Vault 设计
+
+默认存储路径：
+
+```text
+offline-backend-20260512/backend/data/knowledge/obsidian-vault/
+```
+
+也可以通过配置项指定：
+
+```yaml
+knowledge:
+  enabled: true
+  provider: obsidian_wiki
+  vault_dir: data/knowledge/obsidian-vault
+  auto_ingest_enabled: false
+  max_thread_messages: 80
+```
+
+必须兼容 obsidian-wiki 原生结构：
+
+```text
+vault/
+  index.md
+  log.md
+  hot.md
+  .manifest.json
+  _meta/
+    taxonomy.md
+  concepts/
+  entities/
+  skills/
+  references/
+  synthesis/
+  journal/
+  projects/
+    deerflow/
+      concepts/
+      references/
+      synthesis/
+      journal/
+  wiki-export/
+    graph.json
+    graph.graphml
+    cypher.txt
+    graph.html
+```
+
+页面分类遵循 `wiki-capture`：
+
+- `synthesis`：多步骤分析、方案、结论。
+- `concepts`：概念、框架、模型。
+- `references`：外部来源、搜索结果、文章资料。
+- `synthesis` decision 类型：架构或设计决策。
+- `journal`：完整会话摘要。
+- `projects/<project-name>/...`：项目相关知识优先进入项目空间。
+
+Markdown frontmatter 必须优先兼容 `wiki-capture`：
+
+```markdown
+---
+title: >-
+  知识标题
+category: synthesis
+tags: [deerflow, knowledge-base, agent]
+sources:
+  - conversation:2026-06-08
+  - thread:thread_id
+  - message:message_id
+created: 2026-06-08T15:30:00+08:00
+updated: 2026-06-08T15:30:00+08:00
+summary: >-
+  一到两句话说明这页知识保存了什么。
+provenance:
+  extracted: 0.7
+  inferred: 0.2
+  ambiguous: 0.1
+base_confidence: 0.82
+lifecycle: draft
+lifecycle_changed: 2026-06-08
+relationships:
+  - target: "[[concepts/knowledge-graph]]"
+    type: uses
+---
+
+# 知识标题
+
+## Context
+
+问题背景或触发场景。
+
+## Finding / Decision
+
+沉淀后的知识本体。不要写成“用户问了什么，AI 回答了什么”的聊天摘要。
+
+## Reasoning
+
+为什么成立、取舍是什么、不确定性在哪里。推断内容使用 `^[inferred]` 标记。
+
+## Implications
+
+后续使用建议、风险、下一步。
+
+## Related
+
+- [[concepts/knowledge-graph]]
+- [[projects/deerflow/synthesis/product-knowledge-base]]
+```
+
+写入任何页面后必须同步：
+
+- `index.md`：加入页面索引。
+- `log.md`：追加 `CAPTURE` / `INGEST` / `QUERY` / `EXPORT` 记录。
+- `hot.md`：更新近期活动摘要。
+- `.manifest.json`：记录 source、hash、vault path、更新时间，用于去重和 delta。
+
+## 9. 后端接口设计
+
+统一前缀：
+
+```text
+/api/knowledge
+```
+
+### 9.1 从线程沉淀知识
+
+```http
+POST /api/knowledge/ingest/thread/{thread_id}
+```
+
+请求：
+
+```json
+{
+  "mode": "summary",
+  "title": "",
+  "status": "approved",
+  "tags": ["DeerFlow"],
+  "include_sources": true
+}
+```
+
+字段说明：
+
+- `mode`: `summary` 或 `full`
+- `title`: 可选，空时自动生成
+- `status`: `draft` 或 `approved`
+- `tags`: 用户手动附加标签
+- `include_sources`: 是否解析工具/搜索来源
+
+响应：
+
+```json
+{
+  "note": {
+    "id": "kb_xxx",
+    "title": "多智能体任务调度方案",
+    "summary": "...",
+    "source_type": "thread",
+    "source_id": "thread_id",
+    "vault_path": "threads/2026/06/xxx.md",
+    "created_at": "2026-06-08T15:30:00+08:00"
+  }
+}
+```
+
+### 9.2 批量沉淀历史线程
+
+```http
+POST /api/knowledge/ingest/threads/batch
+```
+
+请求：
+
+```json
+{
+  "limit": 100,
+  "offset": 0,
+  "status": "approved",
+  "include_sources": true,
+  "skip_existing": true
+}
+```
+
+字段说明：
+
+- `limit`: 本次最多处理多少个线程。
+- `offset`: 线程分页偏移。
+- `status`: 生成知识的默认状态。
+- `include_sources`: 是否解析工具/搜索来源。
+- `skip_existing`: 是否根据 `.manifest.json` / source hash 跳过已沉淀线程。
+
+响应：
+
+```json
+{
+  "ok": true,
+  "processed": 80,
+  "created": 52,
+  "skipped": 28,
+  "failed": 0,
+  "items": [
+    {
+      "thread_id": "thread_id",
+      "note_id": "kb_xxx",
+      "status": "created"
+    }
+  ]
+}
+```
+
+### 9.3 从搜索结果沉淀知识
+
+```http
+POST /api/knowledge/ingest/search
+```
+
+请求：
+
+```json
+{
+  "query": "LangGraph checkpoint",
+  "results": [
+    {
+      "title": "Example",
+      "url": "https://example.com",
+      "snippet": "..."
+    }
+  ],
+  "thread_id": "optional_thread_id",
+  "message_id": "optional_message_id"
+}
+```
+
+### 9.4 手动创建知识
+
+```http
+POST /api/knowledge/notes
+```
+
+请求：
+
+```json
+{
+  "title": "知识标题",
+  "content_md": "# 知识标题\n\n正文",
+  "tags": ["业务"],
+  "status": "approved"
+}
+```
+
+### 9.5 知识列表
+
+```http
+GET /api/knowledge/notes?keyword=&tag=&source_type=&status=&limit=20&offset=0
+```
+
+响应：
+
+```json
+{
+  "items": [
+    {
+      "id": "kb_xxx",
+      "title": "知识标题",
+      "summary": "摘要",
+      "tags": ["DeerFlow"],
+      "source_type": "thread",
+      "source_id": "thread_id",
+      "updated_at": "2026-06-08T15:30:00+08:00"
+    }
+  ],
+  "total": 1
+}
+```
+
+### 9.6 知识详情
+
+```http
+GET /api/knowledge/notes/{note_id}
+```
+
+响应：
+
+```json
+{
+  "id": "kb_xxx",
+  "title": "知识标题",
+  "summary": "摘要",
+  "content_md": "# 知识标题...",
+  "tags": ["DeerFlow"],
+  "sources": [
+    {
+      "id": "src_xxx",
+      "source_type": "thread",
+      "thread_id": "thread_id",
+      "message_id": "message_id",
+      "title": "来源标题",
+      "url": "https://example.com",
+      "snippet": "..."
+    }
+  ]
+}
+```
+
+### 9.7 更新知识
+
+```http
+PUT /api/knowledge/notes/{note_id}
+```
+
+请求：
+
+```json
+{
+  "title": "新标题",
+  "content_md": "# 新内容",
+  "tags": ["新标签"],
+  "status": "approved"
+}
+```
+
+### 9.8 删除知识
+
+```http
+DELETE /api/knowledge/notes/{note_id}
+```
+
+建议默认软删除：设置 `status = archived`。
+
+### 9.9 知识搜索
+
+阶段三实现。
+
+```http
+POST /api/knowledge/search
+```
+
+请求：
+
+```json
+{
+  "query": "如何做多智能体调度",
+  "mode": "hybrid",
+  "limit": 8
+}
+```
+
+`mode` 可选：
+
+- `keyword`
+- `vector`
+- `hybrid`
+
+响应：
+
+```json
+{
+  "items": [
+    {
+      "note_id": "kb_xxx",
+      "chunk_id": "chunk_xxx",
+      "title": "多智能体任务调度方案",
+      "snippet": "相关片段",
+      "score": 0.87,
+      "sources": []
+    }
+  ]
+}
+```
+
+### 9.10 知识图谱
+
+阶段五实现。
+
+```http
+GET /api/knowledge/graph?keyword=&limit=100
+```
+
+响应：
+
+```json
+{
+  "nodes": [
+    {
+      "id": "kb_xxx",
+      "type": "note",
+      "label": "知识标题"
+    }
+  ],
+  "edges": [
+    {
+      "id": "rel_xxx",
+      "source": "kb_a",
+      "target": "kb_b",
+      "label": "related",
+      "weight": 1
+    }
+  ]
+}
+```
+
+### 9.11 Export Obsidian Wiki Graph
+
+First implementation should reuse obsidian-wiki `wiki-export` compatible output.
+
+```http
+POST /api/knowledge/export/graph
+```
+
+Response:
+
+```json
+{
+  "ok": true,
+  "files": {
+    "graph_json": "/api/knowledge/export/files/graph.json",
+    "graph_html": "/api/knowledge/export/files/graph.html",
+    "graph_graphml": "/api/knowledge/export/files/graph.graphml",
+    "cypher": "/api/knowledge/export/files/cypher.txt"
+  },
+  "stats": {
+    "nodes": 12,
+    "edges": 18
+  }
+}
+```
+
+### 9.12 Serve Obsidian Wiki Export Files
+
+```http
+GET /api/knowledge/export/files/{filename}
+```
+
+Allowed files:
+
+- `graph.json`
+- `graph.graphml`
+- `cypher.txt`
+- `graph.html`
+
+Frontend graph page first version:
+
+```text
+iframe src="/api/knowledge/export/files/graph.html"
+```
+
+## 10. 后端服务设计
+
+建议拆分：
+
+```text
+deerflow/knowledge/
+  __init__.py
+  models.py
+  repository.py
+  obsidian_adapter.py
+  skill_templates.py
+  markdown_vault.py
+  extractor.py
+  sources.py
+  manifest.py
+  exporter.py
+  chunking.py
+  embeddings.py
+  search.py
+```
+
+职责：
+
+- `models.py`
+  - Pydantic/领域模型。
+
+- `repository.py`
+  - 数据库读写。
+  - 不直接调用 LLM。
+
+- `obsidian_adapter.py`
+  - 核心适配器。
+  - 对外提供 `capture_thread`、`capture_search`、`list_notes`、`read_note`、`update_note`、`export_graph`。
+  - 输出必须兼容 obsidian-wiki vault。
+
+- `skill_templates.py`
+  - 读取或内置 `wiki-capture`、`wiki-query`、`wiki-export` 的关键模板。
+  - 后端 LLM 抽取 prompt 应以这些技能为准。
+
+- `markdown_vault.py`
+  - 负责生成 obsidian-wiki 兼容 frontmatter。
+  - 负责安全文件名。
+  - 负责写入/更新 Markdown 文件。
+  - 负责 wikilink 解析和基础 frontmatter 解析。
+
+- `extractor.py`
+  - 负责从 thread/search/tool 中抽取知识。
+  - 首版可用规则生成摘要，正式版可调用 LLM。
+  - LLM 输出必须映射为 `wiki-capture` 的类型：synthesis、concept、source、decision、session。
+
+- `sources.py`
+  - 负责归一化来源。
+  - 复用 `threads.py` 里的 reference normalize 逻辑时，建议抽公共函数，避免复制大段代码。
+
+- `manifest.py`
+  - 读写 `.manifest.json`。
+  - 记录 source hash，避免重复沉淀。
+
+- `exporter.py`
+  - 内置实现 obsidian-wiki `wiki-export` 等价逻辑。
+  - 生成 `wiki-export/graph.json` 和 `wiki-export/graph.html`。
+  - 前端图谱优先 iframe `graph.html`。
+
+- `chunking.py`
+  - Markdown 分块。
+
+- `embeddings.py`
+  - embedding 生成和索引写入。
+
+- `search.py`
+  - 关键词、向量、混合搜索。
+
+## 11. 知识抽取策略
+
+抽取策略必须优先遵循 obsidian-wiki 的 `wiki-capture`：
+
+- 保存知识本体，不保存聊天流水账。
+- 使用 declarative knowledge，不写“用户问了什么，AI 回答了什么”。
+- 明确分类为 `synthesis`、`concept`、`source`、`decision`、`session`。
+- 项目相关内容写入 `projects/<project-name>/...`。
+- 推断内容使用 `^[inferred]`。
+- 不确定或冲突内容使用 `^[ambiguous]`。
+- 每篇笔记尽量包含至少 2 个 `[[wikilinks]]`。
+
+从线程抽取时，只保留高价值内容：
+
+- 用户明确提问。
+- 助手最终回答。
+- 工具搜索结果。
+- 被引用的来源。
+- 生成的结论、方案、计划、代码设计。
+
+过滤：
+
+- 空消息。
+- 纯寒暄。
+- 中间推理内容。
+- 重复 token 流。
+- 错误堆栈中无价值的噪声。
+- 过长原文全文。
+
+首版规则：
+
+1. 读取 thread state 的 `messages`。
+2. 按 human 消息切分 turn。
+3. 找每个 turn 的最后一个有正文的 ai 消息。
+4. 拼成沉淀上下文。
+5. 自动生成标题：
+   - 优先使用 thread title。
+   - 没有 title 时使用第一条用户问题的前 40 字。
+6. 自动生成 summary：
+   - 首版可截取或简单规则总结。
+   - 正式版用 LLM 生成结构化 JSON。
+
+LLM 抽取推荐输出：
+
+```json
+{
+  "title": "知识标题",
+  "summary": "摘要",
+  "key_points": ["要点一", "要点二"],
+  "actions": ["建议一"],
+  "tags": ["标签"],
+  "entities": [
+    {"name": "LangGraph", "type": "technology"}
+  ],
+  "relations": [
+    {"from": "LangGraph", "to": "checkpoint", "type": "uses"}
+  ],
+  "confidence": 0.82,
+  "should_ingest": true,
+  "reason": "包含可复用架构决策"
+}
+```
+
+## 12. 前端页面设计
+
+### 12.1 路由
+
+新增路由建议：
+
+```text
+/page/knowledge
+/page/knowledge/:noteId
+```
+
+如果必须放在工作台内，可放：
+
+```text
+/page/workspace/knowledge
+```
+
+### 12.2 页面结构
+
+知识库主页面：
+
+```text
+顶部工具栏
+- 搜索框
+- 来源类型筛选
+- 标签筛选
+- 新建知识按钮
+
+左侧/主区域
+- 知识列表
+- 标题
+- 摘要
+- 标签
+- 来源类型
+- 更新时间
+
+右侧/详情区域
+- Markdown 内容
+- 来源列表
+- 编辑按钮
+- 删除/归档按钮
+```
+
+### 12.3 对话页入口
+
+在聊天线程页面增加按钮：
+
+```text
+保存到知识库
+```
+
+交互：
+
+1. 用户点击按钮。
+2. 弹窗展示：
+   - 标题输入框。
+   - 标签输入。
+   - 状态：草稿/正式。
+   - 是否包含搜索来源。
+3. 调用 `POST /api/knowledge/ingest/thread/{thread_id}`。
+4. 成功后 toast 提示。
+5. 可点击进入知识详情。
+
+### 12.4 知识详情页
+
+功能：
+
+- Markdown 渲染。
+- 显示 frontmatter 中的标签、来源、更新时间。
+- 来源区支持跳转：
+  - thread 来源跳回原对话。
+  - url 来源打开外链。
+- 编辑模式：
+  - 标题。
+  - Markdown 内容。
+  - 标签。
+  - 状态。
+
+## 13. RAG 召回接入
+
+阶段二再做，不建议首版强行接入。
+
+召回策略优先复用 obsidian-wiki `wiki-query` 的分层检索，而不是直接上向量库：
+
+1. 读取 `hot.md`，获取近期知识上下文。
+2. 读取 `index.md`，用标题、摘要、标签筛候选页面。
+3. 扫描 frontmatter：`title`、`tags`、`aliases`、`summary`、`tier`。
+4. 只读取候选页面相关片段。
+5. 必要时才读取全文。
+6. 向量检索作为增强，不作为首个唯一检索方式。
+
+推荐接入点：
+
+1. 用户发送问题。
+2. 后端进入 agent 运行前。
+3. 调用 `KnowledgeSearchService.search(query, limit=5)`。
+4. 将搜索结果转换为系统上下文：
+
+```text
+以下是产品知识库中与本问题相关的资料。回答时优先参考，若使用其中信息，请在回答中标注来源。
+
+[知识 1] 标题
+摘要/片段
+来源：note_id / url
+```
+
+注意：
+
+- 不要注入过多内容，建议限制 3-5 条。
+- 每条只注入 snippet，不要注入整篇 Markdown。
+- 必须携带来源 id，方便前端引用展示。
+- 知识库为全局共享，检索所有已批准的公共知识。
+
+## 14. 权限与安全
+
+必须实现：
+
+- 知识库为全局共享，不按用户隔离。
+- 所有用户读取同一套 vault 和知识索引。
+- 写入、更新、删除操作记录 `created_by` / `updated_by`，用于审计。
+- Markdown 文件路径必须防止路径穿越。
+- 文件名必须 sanitize。
+- 删除默认软删除。
+
+建议实现：
+
+- 自动沉淀前做敏感信息检测。
+- 对 token、密钥、手机号、身份证等内容做脱敏。
+- 提供“不要沉淀本次对话”的用户开关。
+
+## 15. 配置项
+
+建议在 `config.yaml` 中新增：
+
+```yaml
+knowledge:
+  enabled: true
+  provider: obsidian_wiki
+  vault_dir: data/knowledge/obsidian-vault
+  project_name: deerflow
+  auto_ingest_enabled: false
+  auto_ingest_min_chars: 300
+  max_thread_messages: 80
+  max_source_items: 20
+  export:
+    enabled: true
+    graph_html_enabled: true
+    graph_json_enabled: true
+  rag_enabled: false
+  rag_limit: 5
+  query:
+    use_hot_md: true
+    use_index_md: true
+    use_frontmatter_scan: true
+  embedding:
+    enabled: false
+    provider: local
+    model: ""
+```
+
+## 16. 验收标准
+
+阶段一验收：
+
+- 可以从一个已有 thread 生成知识笔记。
+- 可以批量扫描历史线程并生成知识笔记。
+- 搜索结果/工具结果能作为 sources 保存。
+- 数据库中存在 `knowledge_notes` 记录。
+- vault 中生成 Markdown 文件。
+- `index.md`、`log.md`、`hot.md`、`.manifest.json` 会同步更新。
+- 前端可以看到知识列表。
+- 前端可以查看知识详情。
+- 前端可以编辑标题、标签、状态和 Markdown 正文。
+- 前端可以关键词搜索知识。
+- 前端可以删除/归档知识。
+- 前端可以打开图谱页面，iframe 展示 `wiki-export/graph.html`。
+- 所有用户都能看到已批准的全局知识。
+- 删除知识后列表不再显示。
+
+阶段二验收：
+
+- `POST /api/knowledge/search` 能返回相关知识。
+- agent 回答能使用知识库内容。
+- 回答中能显示知识来源。
+
+阶段三验收：
+
+- 可配置自动沉淀开关。
+- 自动沉淀不会保存明显无价值寒暄。
+- 重复内容不会无限新增。
+- 用户可编辑和归档自动沉淀的知识。
+
+## 17. 推荐开发顺序
+
+1. 创建后端数据模型和 repository。
+2. 创建 `ObsidianWikiAdapter`，初始化 obsidian-wiki 兼容 vault。
+3. 创建 Markdown vault 写入工具，同步 `index.md`、`log.md`、`hot.md`、`.manifest.json`。
+4. 实现 `POST /api/knowledge/ingest/thread/{thread_id}`。
+5. 实现 `POST /api/knowledge/ingest/threads/batch`。
+6. 实现 `POST /api/knowledge/ingest/search`。
+7. 实现 `GET /api/knowledge/notes` 和详情接口。
+8. 实现 `PUT /api/knowledge/notes/{note_id}` 和 `DELETE /api/knowledge/notes/{note_id}`。
+9. 实现 `POST /api/knowledge/search` 的关键词/frontmatter/Markdown 内容检索。
+10. 增加 `POST /api/knowledge/export/graph`，生成并服务 `wiki-export/graph.html`。
+11. 前端创建 `core/knowledge/api.ts`。
+12. 前端实现知识列表、详情、编辑、搜索、图谱页面。
+13. 对话页增加“保存到知识库”按钮。
+14. 前端增加“批量导入历史线程”入口。
+15. 补充基础测试。
+16. 再进入向量 RAG、自动沉淀、自动合并阶段。
+
+## 18. 测试建议
+
+后端测试：
+
+- 从 thread state 生成知识。
+- 批量历史线程入库。
+- 搜索/工具来源入库。
+- 空 thread 返回合理错误。
+- 任意可读取的 thread 都可沉淀到全局知识库；需要按现有 thread 权限判断是否可读取来源。
+- Markdown 文件路径安全。
+- 知识列表分页正确。
+- 更新知识同步更新 vault 文件。
+- 删除知识为软删除。
+
+前端测试：
+
+- 知识列表加载态、空态、错误态。
+- 搜索和筛选。
+- 详情 Markdown 渲染。
+- 知识编辑和保存。
+- 图谱 iframe 页面。
+- 批量导入历史线程入口。
+- 保存到知识库弹窗。
+- 保存成功后跳转详情。
+
+手动测试：
+
+1. 新建一轮对话。
+2. 点击保存到知识库。
+3. 打开知识库页面。
+4. 查看生成的知识笔记。
+5. 编辑标题和内容。
+6. 批量导入历史线程。
+7. 打开图谱页面。
+8. 删除或归档知识。
+
+## 19. 给开发模型的任务提示词
+
+可将下面提示词交给其他模型：
+
+```text
+请基于 frontend-web/docs/product-knowledge-base-dev.md 实现阶段一：首版完整交付。
+
+要求：
+1. 后端新增 /api/knowledge 相关接口。
+2. 从 /api/threads/{thread_id}/state 读取 messages，生成知识笔记。
+3. 新增独立 knowledge 模块，知识库相关能力都在该模块内实现。
+4. 新增 ObsidianWikiAdapter，复用 ar9av/obsidian-wiki 的原生规范和技能思路。
+5. 将知识元数据写入数据库，将 content_md 写入 obsidian-wiki 兼容 Markdown vault。
+6. 写入后必须同步 index.md、log.md、hot.md、.manifest.json。
+7. Markdown frontmatter 和正文结构参考 obsidian-wiki 的 wiki-capture 技能。
+8. 前端新增知识库列表、详情、编辑、搜索、图谱页面。
+9. 在聊天线程页面增加“保存到知识库”入口。
+10. 增加批量导入历史线程入口。
+11. 知识库为全局共享，不做 user_id 隔离；写入时记录 created_by / updated_by 作为审计。
+12. 图谱第一版生成并服务 wiki-export 兼容的 graph.html/json。
+13. 首版实现关键词/frontmatter/Markdown 内容搜索；向量 RAG 后续增强。
+14. 遵循当前项目已有 FastAPI、SQLAlchemy、React、TanStack Query、UI 组件风格。
+15. 完成后运行后端相关测试和前端 typecheck/build。
+```
+
+## 20. 风险与注意事项
+
+- 知识库模块独立实现，相关能力都收敛在新增 `knowledge` 模块内。
+- 不要另起一套与 obsidian-wiki 不兼容的 Markdown 结构。
+- 不要忽略 `index.md`、`log.md`、`hot.md`、`.manifest.json`，这些是 obsidian-wiki 的关键原生资产。
+- 不要让前端直接读服务器 Markdown 文件，应通过 API。
+- 不要同步阻塞聊天流式响应，自动沉淀应后台执行。
+- 不要保存完整工具 raw_json 到前端展示，详情页只展示必要字段。
+- 不要把所有搜索结果无脑入库，应先关联来源，再由知识笔记引用。
+- 首版不额外引入图数据库中间件，图谱优先使用 `wiki-export/graph.html` 和 `graph.json`。
diff --git a/frontend-web/src/App.tsx b/frontend-web/src/App.tsx
index a24f9b53..752afc7a 100644
--- a/frontend-web/src/App.tsx
+++ b/frontend-web/src/App.tsx
@@ -15,8 +15,11 @@ import { HashRouter, useLocation } from "react-router-dom";
 import LandingPage from "./pages/LandingPage";
 import LoginPage from "./pages/LoginPage";
 import PageRoutes from "./pages/PageRoutes";
-import PublicScheduledTaskPage from "./pages/PublicScheduledTaskPage";
+import PublicScheduledTaskPage, {
+  PublicScheduledTaskFullscreenPage,
+} from "./pages/PublicScheduledTaskPage";
 import PublicSharePage from "./pages/PublicSharePage";
+import PublicLeaderboardPage from "./pages/PublicLeaderboardPage";
 import PublicRoundtableSharePage from "./pages/PublicRoundtableSharePage";
 import EmbedChatPage from "./pages/EmbedChatPage";
 import { ChatRuntime } from "./pages/WorkspaceRoutes";
@@ -64,6 +67,8 @@ export function App() {
           <Route path="/landing" element={<LandingPage />} />
           {/* Public read-only conversation viewer — no authentication. */}
           <Route path="/share/:shareCode" element={<PublicSharePage />} />
+          {/* Public read-only user leaderboard publish page — no authentication. */}
+          <Route path="/public/leaderboard" element={<PublicLeaderboardPage />} />
           {/* Public read-only roundtable share — landing + full result report. */}
           <Route
             path="/roundtable-share/:shareCode"
@@ -78,6 +83,10 @@ export function App() {
             path="/public/scheduled-tasks/:taskId"
             element={<PublicScheduledTaskPage />}
           />
+          <Route
+            path="/public/scheduled-tasks/:taskId/runs/:runId/fullscreen"
+            element={<PublicScheduledTaskFullscreenPage />}
+          />
           {/* Embedded workspace Q&A — no page/workspace sidebars; parent passes message/username/theme */}
           <Route
             path="/embed/chats/:thread_id"
diff --git a/frontend-web/src/components/workspace/agents/agent-card.tsx b/frontend-web/src/components/workspace/agents/agent-card.tsx
index 60be77f8..f47b010d 100644
--- a/frontend-web/src/components/workspace/agents/agent-card.tsx
+++ b/frontend-web/src/components/workspace/agents/agent-card.tsx
@@ -8,12 +8,14 @@ import {
   LockIcon,
   MessageSquareIcon,
   PinIcon,
+  SearchIcon,
   ShieldIcon,
   SparklesIcon,
   SquarePenIcon,
   StarIcon,
   TagsIcon,
   Trash2Icon,
+  UserIcon,
 } from "lucide-react";
 import { useRouter } from "next/navigation";
 import {
@@ -73,6 +75,9 @@ interface AgentCardProps {
   /** "card" (default) renders the full gallery card; "list" renders a compact
    * single-row layout for the list view. All dialogs/actions are shared. */
   layout?: "card" | "list";
+  /** Click the 发布者 line to filter the gallery to that publisher. Receives the
+   * owner user_id + its desensitized display label. */
+  onPublisherClick?: (publisher: { id: string; label: string }) => void;
 }
 
 interface BadgeItem {
@@ -184,7 +189,7 @@ function ClampedBadgeRow({ items }: { items: BadgeItem[] }) {
   );
 }
 
-export function AgentCard({ agent, layout = "card" }: AgentCardProps) {
+export function AgentCard({ agent, layout = "card", onPublisherClick }: AgentCardProps) {
   const isList = layout === "list";
   const { t } = useI18n();
   const router = useRouter();
@@ -207,6 +212,7 @@ export function AgentCard({ agent, layout = "card" }: AgentCardProps) {
   const [selectedSkills, setSelectedSkills] = useState<string[]>(
     agent.skills ?? [],
   );
+  const [skillSearch, setSkillSearch] = useState("");
   const [detailSkillName, setDetailSkillName] = useState<string | null>(null);
 
   // The /api/agents list response intentionally omits `soul` (perf optimization
@@ -244,6 +250,7 @@ export function AgentCard({ agent, layout = "card" }: AgentCardProps) {
     setEditPublished(agent.published);
     setEditIsPrivate(agent.is_private);
     setSelectedSkills(agent.skills ?? []);
+    setSkillSearch("");
   }, [
     agent.description,
     agent.is_private,
@@ -436,7 +443,24 @@ export function AgentCard({ agent, layout = "card" }: AgentCardProps) {
     });
   }
 
-  const enabledSkills = skills.filter((skill) => skill.enabled);
+  const enabledSkills = useMemo(
+    () => skills.filter((skill) => skill.enabled),
+    [skills],
+  );
+
+  // Search over English name, Chinese name (name_zh) and description, so both
+  // 中英文 work. Already-selected skills stay searchable too (selection is
+  // independent of this filter).
+  const filteredSkills = useMemo(() => {
+    const q = skillSearch.trim().toLowerCase();
+    if (!q) return enabledSkills;
+    return enabledSkills.filter(
+      (skill) =>
+        skill.name.toLowerCase().includes(q) ||
+        (skill.name_zh ?? "").toLowerCase().includes(q) ||
+        (skill.description ?? "").toLowerCase().includes(q),
+    );
+  }, [enabledSkills, skillSearch]);
 
   // Status badges (内置 / 我的 / 来自他人 / 已发布 / 私密 / 首页推荐) — shared by
   // both the card header and the compact list row.
@@ -497,6 +521,47 @@ export function AgentCard({ agent, layout = "card" }: AgentCardProps) {
     </>
   );
 
+  // 发布者（仅自定义/已发布的智能体显示；内置无 owner 不显示）。点击可按发布者筛选。
+  const publisherLabel = agent.owner_username
+    ? desensitize(agent.owner_username)
+    : "";
+  const canFilterByPublisher =
+    !isBuiltin && !!agent.owner_username && !!agent.user_id && !!onPublisherClick;
+  const publisherNode =
+    !isBuiltin && agent.owner_username ? (
+      <button
+        type="button"
+        disabled={!canFilterByPublisher}
+        onClick={(e) => {
+          if (!canFilterByPublisher) return;
+          e.stopPropagation();
+          onPublisherClick!({ id: agent.user_id!, label: publisherLabel });
+        }}
+        className={cn(
+          "text-muted-foreground flex max-w-full items-center gap-1 text-sm font-medium",
+          canFilterByPublisher &&
+            "hover:text-primary cursor-pointer transition-colors hover:underline",
+        )}
+        title={
+          canFilterByPublisher
+            ? `点击筛选发布者：${publisherLabel}`
+            : `发布者：${publisherLabel}`
+        }
+      >
+        <UserIcon className="size-3.5 shrink-0" />
+        <span className="truncate">发布者：{publisherLabel}</span>
+      </button>
+    ) : null;
+
+  // 技能英文名 → 中文名映射,用于把智能体的技能徽章显示为中文(agent.skills 只存英文名)。
+  const skillNameZhMap = useMemo(() => {
+    const map = new Map<string, string>();
+    for (const s of skills) {
+      if (s.name_zh?.trim()) map.set(s.name, s.name_zh.trim());
+    }
+    return map;
+  }, [skills]);
+
   const skillBadgeItems = [
     ...(agent.tool_groups ?? []).map((group) => ({
       key: `tg:${group}`,
@@ -519,7 +584,7 @@ export function AgentCard({ agent, layout = "card" }: AgentCardProps) {
             setDetailSkillName(skill);
           }}
         >
-          {desensitize(skill)}
+          {skillNameZhMap.get(skill) ?? desensitize(skill)}
         </Badge>
       ),
     })),
@@ -585,15 +650,15 @@ export function AgentCard({ agent, layout = "card" }: AgentCardProps) {
           <SparklesIcon className="h-3.5 w-3.5" />
         </Button>
       )}
-      <Button
-        size="icon"
-        variant="ghost"
-        className="h-8 w-8 shrink-0"
-        onClick={() => setTagPickerOpen(true)}
-        title={t.adminTags.manageTags}
-      >
-        <TagsIcon className="h-3.5 w-3.5" />
-      </Button>
+      <Button
+        size="icon"
+        variant="ghost"
+        className="h-8 w-8 shrink-0"
+        onClick={() => setTagPickerOpen(true)}
+        title={t.adminTags.manageTags}
+      >
+        <TagsIcon className="h-3.5 w-3.5" />
+      </Button>
       {isOwned && (
         <Button
           size="icon"
@@ -702,6 +767,7 @@ export function AgentCard({ agent, layout = "card" }: AgentCardProps) {
             {desensitize(agent.description)}
           </CardDescription>
         )}
+        {publisherNode && <div className="mt-2">{publisherNode}</div>}
       </CardHeader>
 
       {(agent.tags?.length ?? 0) > 0 && (
@@ -747,6 +813,7 @@ export function AgentCard({ agent, layout = "card" }: AgentCardProps) {
             {desensitize(agent.description)}
           </p>
         )}
+        {publisherNode && <div className="mt-0.5">{publisherNode}</div>}
       </div>
       <div className="flex shrink-0 items-center gap-1">
         {showActionRow && actionButtons}
@@ -792,6 +859,17 @@ export function AgentCard({ agent, layout = "card" }: AgentCardProps) {
                   已选 {selectedSkills.length} 个
                 </span>
               </div>
+              {enabledSkills.length > 0 && (
+                <div className="relative">
+                  <SearchIcon className="text-muted-foreground absolute left-2 top-1/2 size-3.5 -translate-y-1/2" />
+                  <Input
+                    placeholder="搜索技能(支持中英文名称、描述)…"
+                    value={skillSearch}
+                    onChange={(e) => setSkillSearch(e.currentTarget.value)}
+                    className="h-8 pl-7 text-xs"
+                  />
+                </div>
+              )}
               <div className="max-h-[240px] overflow-y-auto rounded-md border p-2">
                 {isSkillsLoading ? (
                   <p className="text-muted-foreground text-sm">技能加载中...</p>
@@ -799,9 +877,11 @@ export function AgentCard({ agent, layout = "card" }: AgentCardProps) {
                   <p className="text-muted-foreground text-sm">
                     当前没有可用技能
                   </p>
+                ) : filteredSkills.length === 0 ? (
+                  <p className="text-muted-foreground text-sm">没有匹配的技能</p>
                 ) : (
                   <div className="grid grid-cols-1 gap-2 sm:grid-cols-2">
-                    {enabledSkills.map((skill) => {
+                    {filteredSkills.map((skill) => {
                       const checked = selectedSkills.includes(skill.name);
                       return (
                         <div
@@ -816,7 +896,11 @@ export function AgentCard({ agent, layout = "card" }: AgentCardProps) {
                             title={desensitize(skill.description ?? "")}
                             className="h-8 min-w-0 flex-1 rounded-r-none"
                           >
-                            <span className="truncate">{desensitize(skill.name)}</span>
+                            <span className="truncate">
+                              {skill.name_zh?.trim()
+                                ? skill.name_zh
+                                : desensitize(skill.name)}
+                            </span>
                           </Button>
                           <Button
                             type="button"
@@ -934,13 +1018,13 @@ export function AgentCard({ agent, layout = "card" }: AgentCardProps) {
         </DialogContent>
       </Dialog>
 
-      <TagPickerDialog
-        open={tagPickerOpen}
-        onOpenChange={setTagPickerOpen}
-        targetType="agent"
-        targetId={agent.id}
-        currentTags={agent.tags ?? []}
-      />
+      <TagPickerDialog
+        open={tagPickerOpen}
+        onOpenChange={setTagPickerOpen}
+        targetType="agent"
+        targetId={agent.id}
+        currentTags={agent.tags ?? []}
+      />
 
 
       <SkillDetailDialog
diff --git a/frontend-web/src/components/workspace/agents/agent-gallery.tsx b/frontend-web/src/components/workspace/agents/agent-gallery.tsx
index 3be26cef..ff0e453d 100644
--- a/frontend-web/src/components/workspace/agents/agent-gallery.tsx
+++ b/frontend-web/src/components/workspace/agents/agent-gallery.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { ArrowDownUpIcon, BotIcon, LockIcon, PlusIcon, ShieldIcon } from "lucide-react";
+import { ArrowDownUpIcon, BotIcon, LockIcon, PlusIcon, ShieldIcon, XIcon } from "lucide-react";
 import { useRouter } from "next/navigation";
 import { useEffect, useState } from "react";
 import { toast } from "sonner";
@@ -36,6 +36,11 @@ export function AgentGallery() {
   const [search, setSearch] = useState("");
   const [tagIds, setTagIds] = useState<string[]>([]);
   const [sort, setSort] = useState<AgentSort>("time_desc");
+  // Publisher filter: click a card's 发布者 to keep only that user's agents.
+  // {id} is the owner user_id (server filter), {label} the desensitized name.
+  const [publisher, setPublisher] = useState<{ id: string; label: string } | null>(
+    null,
+  );
   // Per-tab 1-based page index, preserved while switching tabs.
   const [pages, setPages] = useState<{ all: number; mine: number; private: number }>(
     { all: 1, mine: 1, private: 1 },
@@ -48,7 +53,7 @@ export function AgentGallery() {
   const tagKey = tagIds.join(",");
   useEffect(() => {
     setPages({ all: 1, mine: 1, private: 1 });
-  }, [search, tagKey, sort]);
+  }, [search, tagKey, sort, publisher?.id]);
 
   const { data: privateStatus } = usePrivateSquareStatus();
   const privateFeatureAvailable = !!privateStatus?.enabled;
@@ -69,6 +74,7 @@ export function AgentGallery() {
     agents: mainAgents,
     total: mainTotal,
     isLoading: mainLoading,
+    isFetching: mainFetching,
   } = useAgentsPaginated({
     scope: mainScope,
     search,
@@ -77,12 +83,14 @@ export function AgentGallery() {
     page: mainPage,
     pageSize: PAGE_SIZE,
     enabled: activeTab !== "private",
+    owner: publisher?.id,
   });
 
   const {
     agents: privateAgents,
     total: privateTotal,
     isLoading: isPrivateLoading,
+    isFetching: isPrivateFetching,
     error: privateError,
   } = usePrivateAgentsPaginated(privatePassword, {
     search,
@@ -91,6 +99,7 @@ export function AgentGallery() {
     page: pages.private,
     pageSize: PAGE_SIZE,
     enabled: activeTab === "private",
+    owner: publisher?.id,
   });
 
   // If the server reports the stored password no longer works (likely the
@@ -103,6 +112,12 @@ export function AgentGallery() {
     }
   }, [privateError, privatePassword]);
 
+  // The private tab is only "unlocked" once the feature is usable and a
+  // password has been verified. Until then we show the gate (or the lock
+  // prompt) and hide the keyword/tag search bar — there is no list to filter.
+  const privateUnlocked = privateFeatureUsable && !!privatePassword;
+  const showSearchBar = activeTab !== "private" || privateUnlocked;
+
   const activeTotal = activeTab === "private" ? privateTotal : mainTotal;
   const setTabPage = (tab: "all" | "mine" | "private", page: number) =>
     setPages((prev) => ({ ...prev, [tab]: page }));
@@ -127,17 +142,29 @@ export function AgentGallery() {
     setPrivatePassword(null);
   };
 
+  const handlePublisherClick = (p: { id: string; label: string }) =>
+    setPublisher(p);
+
   const renderGrid = (list: Agent[]) =>
     viewMode === "list" ? (
       <div className="flex flex-col gap-2">
         {list.map((agent) => (
-          <AgentCard key={agent.id} agent={agent} layout="list" />
+          <AgentCard
+            key={agent.id}
+            agent={agent}
+            layout="list"
+            onPublisherClick={handlePublisherClick}
+          />
         ))}
       </div>
     ) : (
       <div className="grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4">
         {list.map((agent) => (
-          <AgentCard key={agent.id} agent={agent} />
+          <AgentCard
+            key={agent.id}
+            agent={agent}
+            onPublisherClick={handlePublisherClick}
+          />
         ))}
       </div>
     );
@@ -296,9 +323,16 @@ export function AgentGallery() {
       {/* Tabs */}
       <Tabs
         value={activeTab}
-        onValueChange={(v) =>
-          setActiveTab(v as "all" | "mine" | "private")
-        }
+        onValueChange={(v) => {
+          setActiveTab(v as "all" | "mine" | "private");
+          // Each tab starts from a clean slate: switching tabs clears the
+          // keyword / tag / sort / publisher filters instead of carrying them
+          // over. The TagSearchBar's own input box is reset via its key below.
+          setSearch("");
+          setTagIds([]);
+          setSort("time_desc");
+          setPublisher(null);
+        }}
         className="flex flex-1 flex-col overflow-hidden"
       >
         <div className="mx-6 mt-4 flex flex-col gap-3">
@@ -331,31 +365,53 @@ export function AgentGallery() {
               )}
             </div>
           </div>
-          <TagSearchBar
-            targetType="agent"
-            onSearchChange={setSearch}
-            tagIds={tagIds}
-            onTagIdsChange={setTagIds}
-            actions={
-              <Select value={sort} onValueChange={(v) => setSort(v as AgentSort)}>
-                <SelectTrigger
-                  className="h-9 w-full gap-2 px-3 text-xs sm:w-[148px]"
-                  title="排序"
-                >
-                  <ArrowDownUpIcon className="text-muted-foreground size-3.5" />
-                  <SelectValue />
-                </SelectTrigger>
-                <SelectContent position="popper" side="bottom" sideOffset={4}>
-                  <SelectItem value="time_desc">最新创建</SelectItem>
-                  <SelectItem value="time_asc">最早创建</SelectItem>
-                  <SelectItem value="updated_desc">最近更新</SelectItem>
-                  <SelectItem value="updated_asc">最早更新</SelectItem>
-                  <SelectItem value="name_asc">名称 A-Z</SelectItem>
-                  <SelectItem value="name_desc">名称 Z-A</SelectItem>
-                </SelectContent>
-              </Select>
-            }
-          />
+          {showSearchBar && (
+            <TagSearchBar
+              // Remount per tab so the internal keyword input / 展开 state also
+              // resets when the parent-owned filters are cleared on tab switch.
+              key={activeTab}
+              targetType="agent"
+              searching={
+                activeTab === "private" ? isPrivateFetching : mainFetching
+              }
+              onSearchChange={setSearch}
+              tagIds={tagIds}
+              onTagIdsChange={setTagIds}
+              actions={
+                <Select value={sort} onValueChange={(v) => setSort(v as AgentSort)}>
+                  <SelectTrigger
+                    className="h-9 w-full gap-2 px-3 text-xs sm:w-[148px]"
+                    title="排序"
+                  >
+                    <ArrowDownUpIcon className="text-muted-foreground size-3.5" />
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent position="popper" side="bottom" sideOffset={4}>
+                    <SelectItem value="time_desc">最新创建</SelectItem>
+                    <SelectItem value="time_asc">最早创建</SelectItem>
+                    <SelectItem value="updated_desc">最近更新</SelectItem>
+                    <SelectItem value="updated_asc">最早更新</SelectItem>
+                    <SelectItem value="name_asc">名称 A-Z</SelectItem>
+                    <SelectItem value="name_desc">名称 Z-A</SelectItem>
+                  </SelectContent>
+                </Select>
+              }
+            />
+          )}
+          {publisher && (
+            <div className="flex items-center gap-2">
+              <span className="text-muted-foreground text-xs">筛选发布者：</span>
+              <button
+                type="button"
+                onClick={() => setPublisher(null)}
+                className="bg-primary/10 text-primary hover:bg-primary/20 inline-flex items-center gap-1 rounded-full px-3 py-1 text-xs font-medium transition-colors"
+                title="点击清除发布者筛选"
+              >
+                {publisher.label}
+                <XIcon className="size-3.5" />
+              </button>
+            </div>
+          )}
         </div>
 
         <TabsContent value="all" className="flex-1 overflow-y-auto p-6 mt-0">
diff --git a/frontend-web/src/components/workspace/knowledge-rag-toggle.tsx b/frontend-web/src/components/workspace/knowledge-rag-toggle.tsx
new file mode 100644
index 00000000..42c12c40
--- /dev/null
+++ b/frontend-web/src/components/workspace/knowledge-rag-toggle.tsx
@@ -0,0 +1,44 @@
+"use client";
+
+import { Database } from "lucide-react";
+
+import { Button } from "@/components/ui/button";
+import { useThreadSettings } from "@/core/settings";
+import { cn } from "@/lib/utils";
+
+import { Tooltip } from "./tooltip";
+
+/**
+ * Per-conversation toggle for knowledge-base RAG injection (phase 2).
+ *
+ * Writes ``context.knowledge_rag_enabled`` into the thread settings, which the
+ * run forwards as ``runtime.context`` so ``KnowledgeRagMiddleware`` injects
+ * recalled knowledge before each model call for this conversation only.
+ */
+export function KnowledgeRagToggle({ threadId }: { threadId: string }) {
+  const [settings, setSettings] = useThreadSettings(threadId);
+  const enabled = settings.context.knowledge_rag_enabled === true;
+
+  const toggle = () => {
+    setSettings("context", {
+      ...settings.context,
+      knowledge_rag_enabled: !enabled,
+    });
+  };
+
+  return (
+    <Tooltip content={enabled ? "知识库召回：已开启" : "知识库召回：已关闭"}>
+      <Button
+        variant="ghost"
+        onClick={toggle}
+        className={cn(
+          "text-muted-foreground hover:text-foreground",
+          enabled && "text-primary hover:text-primary",
+        )}
+      >
+        <Database />
+        知识库
+      </Button>
+    </Tooltip>
+  );
+}
diff --git a/frontend-web/src/components/workspace/knowledge-save-trigger.tsx b/frontend-web/src/components/workspace/knowledge-save-trigger.tsx
new file mode 100644
index 00000000..17cd62ba
--- /dev/null
+++ b/frontend-web/src/components/workspace/knowledge-save-trigger.tsx
@@ -0,0 +1,59 @@
+"use client";
+
+import { BookMarked } from "lucide-react";
+import { useState } from "react";
+import { toast } from "sonner";
+
+import { Button } from "@/components/ui/button";
+import { useKnowledgeActions } from "@/core/knowledge/hooks";
+
+import { ModelNameSelect } from "./model-name-select";
+import { useThread } from "./messages/context";
+import { Tooltip } from "./tooltip";
+
+export function KnowledgeSaveTrigger({ threadId }: { threadId: string }) {
+  const { thread } = useThread();
+  const { ingestThread } = useKnowledgeActions();
+  // Optional model override for the extraction (null = configured default).
+  const [model, setModel] = useState<string | null>(null);
+
+  if (thread.messages.length === 0) {
+    return null;
+  }
+
+  // One click → fire-and-forget. The backend sediments the thread into the
+  // wiki asynchronously (title/tags auto-generated), so the click never blocks.
+  const handleSave = async () => {
+    try {
+      await ingestThread.mutateAsync({
+        threadId,
+        payload: { background: true, model_name: model },
+      });
+      toast.success("已加入知识库保存队列，正在后台整理…");
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : "保存失败");
+    }
+  };
+
+  return (
+    <div className="flex items-center gap-1.5">
+      <ModelNameSelect
+        value={model}
+        onChange={setModel}
+        disabled={ingestThread.isPending}
+        triggerClassName="h-8 w-[8.5rem]"
+      />
+      <Tooltip content="保存到知识库（用所选大模型后台异步整理）">
+        <Button
+          className="text-muted-foreground hover:text-foreground"
+          variant="ghost"
+          onClick={() => void handleSave()}
+          disabled={ingestThread.isPending}
+        >
+          <BookMarked />
+          {ingestThread.isPending ? "保存中…" : "保存"}
+        </Button>
+      </Tooltip>
+    </div>
+  );
+}
diff --git a/frontend-web/src/components/workspace/model-name-select.tsx b/frontend-web/src/components/workspace/model-name-select.tsx
new file mode 100644
index 00000000..327aaa63
--- /dev/null
+++ b/frontend-web/src/components/workspace/model-name-select.tsx
@@ -0,0 +1,59 @@
+"use client";
+
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { useModels } from "@/core/models/hooks";
+import { cn } from "@/lib/utils";
+
+/** Sentinel for "use the backend's default/configured model" (no override). */
+const DEFAULT_VALUE = "__default__";
+
+/**
+ * Compact dropdown to optionally pick an LLM model for a one-off action
+ * (skill-name generation, knowledge ingestion, …). The value is the model
+ * `name`; `null` means "use the configured default" (no override sent).
+ */
+export function ModelNameSelect({
+  value,
+  onChange,
+  disabled,
+  className,
+  triggerClassName,
+  defaultLabel = "默认模型",
+}: {
+  value: string | null;
+  onChange: (modelName: string | null) => void;
+  disabled?: boolean;
+  className?: string;
+  triggerClassName?: string;
+  defaultLabel?: string;
+}) {
+  const { models } = useModels();
+  return (
+    <Select
+      value={value ?? DEFAULT_VALUE}
+      onValueChange={(v) => onChange(v === DEFAULT_VALUE ? null : v)}
+      disabled={disabled}
+    >
+      <SelectTrigger
+        className={cn("h-8 gap-1.5 text-xs", triggerClassName, className)}
+        title="选择用于本次操作的大模型(默认使用系统配置的模型)"
+      >
+        <SelectValue placeholder={defaultLabel} />
+      </SelectTrigger>
+      <SelectContent position="popper" side="bottom" sideOffset={4}>
+        <SelectItem value={DEFAULT_VALUE}>{defaultLabel}</SelectItem>
+        {models.map((m) => (
+          <SelectItem key={m.name} value={m.name}>
+            {m.display_name || m.name}
+          </SelectItem>
+        ))}
+      </SelectContent>
+    </Select>
+  );
+}
diff --git a/frontend-web/src/components/workspace/recent-chat-list.tsx b/frontend-web/src/components/workspace/recent-chat-list.tsx
index 7def3260..46026eb8 100644
--- a/frontend-web/src/components/workspace/recent-chat-list.tsx
+++ b/frontend-web/src/components/workspace/recent-chat-list.tsx
@@ -7,7 +7,10 @@ import {
   FileText,
   MoreHorizontal,
   Pencil,
+  Pin,
+  PinOff,
   Share2,
+  Star,
   Trash2,
 } from "lucide-react";
 import Link from "next/link";
@@ -54,9 +57,17 @@ import {
   useDeleteThread,
   useRenameThread,
   useThreads,
+  useToggleThreadFavorite,
+  useToggleThreadPin,
 } from "@/core/threads/hooks";
 import type { AgentThread, AgentThreadState } from "@/core/threads/types";
-import { pathOfThread, titleOfThread } from "@/core/threads/utils";
+import {
+  isThreadFavorite,
+  isThreadPinned,
+  pathOfThread,
+  sortThreadsPinnedFirst,
+  titleOfThread,
+} from "@/core/threads/utils";
 import { env } from "@/env";
 import { desensitize } from "@/lib/desensitize";
 import { isIMEComposing } from "@/lib/ime";
@@ -82,6 +93,8 @@ export function RecentChatList() {
   const { data: threads = [] } = useThreads();
   const { mutate: deleteThread } = useDeleteThread();
   const { mutate: renameThread } = useRenameThread();
+  const { toggle: togglePin } = useToggleThreadPin();
+  const { toggle: toggleFavorite } = useToggleThreadFavorite();
 
   // Rename dialog state
   const [renameDialogOpen, setRenameDialogOpen] = useState(false);
@@ -160,11 +173,13 @@ export function RecentChatList() {
     [t],
   );
 
-  const visibleThreads = threads.filter(
-    (thread) =>
-      thread.metadata?.thread_type !== "scheduler" &&
-      thread.metadata?.thread_type !== "bootstrap" &&
-      thread.metadata?.thread_type !== "roundtable",
+  const visibleThreads = sortThreadsPinnedFirst(
+    threads.filter(
+      (thread) =>
+        thread.metadata?.thread_type !== "scheduler" &&
+        thread.metadata?.thread_type !== "bootstrap" &&
+        thread.metadata?.thread_type !== "roundtable",
+    ),
   );
 
   if (visibleThreads.length === 0) {
@@ -195,6 +210,8 @@ export function RecentChatList() {
             <div className="flex w-full flex-col gap-0.5">
               {visibleThreads.map((thread) => {
                 const isActive = pathOfThread(thread) === pathname;
+                const pinned = isThreadPinned(thread);
+                const favorited = isThreadFavorite(thread);
                 return (
                   <SidebarMenuItem
                     key={thread.thread_id}
@@ -210,10 +227,15 @@ export function RecentChatList() {
                       }
                     >
                       <Link
-                        className="block w-full whitespace-nowrap group-hover/side-menu-item:overflow-hidden"
+                        className="flex w-full items-center gap-1 whitespace-nowrap group-hover/side-menu-item:overflow-hidden"
                         href={pathOfThread(thread)}
                       >
-                        {desensitize(titleOfThread(thread, t.pages.newChat))}
+                        {pinned && (
+                          <Pin className="size-3 shrink-0 text-muted-foreground/70" />
+                        )}
+                        <span className="truncate">
+                          {desensitize(titleOfThread(thread, t.pages.newChat))}
+                        </span>
                       </Link>
                     </SidebarMenuButton>
                     {env.NEXT_PUBLIC_STATIC_WEBSITE_ONLY !== "true" && (
@@ -243,6 +265,36 @@ export function RecentChatList() {
                             <Pencil className="text-muted-foreground" />
                             <span>{t.common.rename}</span>
                           </DropdownMenuItem>
+                          <DropdownMenuItem
+                            onSelect={() =>
+                              togglePin(thread.thread_id, !pinned)
+                            }
+                          >
+                            {pinned ? (
+                              <PinOff className="text-muted-foreground" />
+                            ) : (
+                              <Pin className="text-muted-foreground" />
+                            )}
+                            <span>{pinned ? t.common.unpin : t.common.pin}</span>
+                          </DropdownMenuItem>
+                          <DropdownMenuItem
+                            onSelect={() =>
+                              toggleFavorite(thread.thread_id, !favorited)
+                            }
+                          >
+                            <Star
+                              className={
+                                favorited
+                                  ? "fill-amber-400 text-amber-400"
+                                  : "text-muted-foreground"
+                              }
+                            />
+                            <span>
+                              {favorited
+                                ? t.common.unfavorite
+                                : t.common.favorite}
+                            </span>
+                          </DropdownMenuItem>
                           <DropdownMenuItem
                             onSelect={() => handleShare(thread)}
                           >
diff --git a/frontend-web/src/components/workspace/settings/appearance-settings-page.tsx b/frontend-web/src/components/workspace/settings/appearance-settings-page.tsx
index 6e530a7c..2796265f 100644
--- a/frontend-web/src/components/workspace/settings/appearance-settings-page.tsx
+++ b/frontend-web/src/components/workspace/settings/appearance-settings-page.tsx
@@ -30,6 +30,10 @@ import {
 } from "@/core/system-settings/hooks";
 import { cn } from "@/lib/utils";
 
+import PrivateSquareSettingsPage from "@/pages/PrivateSquareSettingsPage";
+import PromptPrefixSettingsPage from "@/pages/PromptPrefixSettingsPage";
+import RecommendedQuestionsPage from "@/pages/RecommendedQuestionsPage";
+
 import { SettingsSection } from "./settings-section";
 
 const languageOptions: { value: Locale; label: string }[] = [
@@ -336,6 +340,17 @@ export function AppearanceSettingsPage() {
           </div>
         )}
       </SettingsSection>
+
+      {isAdmin && (
+        <>
+          <Separator />
+          <RecommendedQuestionsPage embedded />
+          <Separator />
+          <PromptPrefixSettingsPage embedded />
+          <Separator />
+          <PrivateSquareSettingsPage embedded />
+        </>
+      )}
     </div>
   );
 }
diff --git a/frontend-web/src/components/workspace/settings/memory-settings-page.tsx b/frontend-web/src/components/workspace/settings/memory-settings-page.tsx
index 477f039e..a33e9562 100644
--- a/frontend-web/src/components/workspace/settings/memory-settings-page.tsx
+++ b/frontend-web/src/components/workspace/settings/memory-settings-page.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { PenLineIcon, PlusIcon, SearchIcon, Trash2Icon, Heart, BookOpen, Map, Zap, Target, ShieldAlert } from "lucide-react";
+import { PenLineIcon, PlusIcon, SearchIcon, Trash2Icon, Heart, BookOpen, Map, Zap, Target, ShieldAlert, Briefcase, UserRound, Sparkles, Clock, History, Archive } from "lucide-react";
 import { useMemo, useState } from "react";
 import { toast } from "sonner";
 
@@ -458,12 +458,24 @@ const CTX_LABELS: Record<string, string> = {
   topOfMind: "当前重点",
 };
 
+const CTX_ICONS: Record<string, React.ElementType> = {
+  workContext: Briefcase,
+  personalContext: UserRound,
+  topOfMind: Sparkles,
+};
+
 const HISTORY_LABELS: Record<string, string> = {
   recentMonths: "近期",
   earlierContext: "早期背景",
   longTermBackground: "长期背景",
 };
 
+const HISTORY_ICONS: Record<string, React.ElementType> = {
+  recentMonths: Clock,
+  earlierContext: History,
+  longTermBackground: Archive,
+};
+
 const CATEGORY_LABELS: Record<string, Record<string, string>> = {
   zh: {
     preference: "偏好",
@@ -572,12 +584,15 @@ function MemoryV1View({
                             <Icon className="w-3.5 h-3.5" />
                             {categoryLabel}
                           </span>
-                          <div className="flex flex-col items-end gap-1">
-                            <span className="text-[11px] text-muted-foreground font-semibold tracking-wider">
-                              {Math.round(fact.confidence * 100)}%
+                          <div
+                            className="flex flex-col items-end gap-1"
+                            title={`置信度：系统对这条记忆准确性的把握程度，${Math.round(fact.confidence * 100)}%`}
+                          >
+                            <span className="text-[11px] text-muted-foreground font-semibold tracking-wide">
+                              置信度 {Math.round(fact.confidence * 100)}%
                             </span>
                             {/* Confidence Progress Bar */}
-                            <div className="h-1 w-12 rounded-full bg-muted overflow-hidden">
+                            <div className="h-1 w-16 rounded-full bg-muted overflow-hidden">
                               <div
                                 className="h-full rounded-full bg-primary transition-all duration-500"
                                 style={{ width: `${Math.round(fact.confidence * 100)}%` }}
@@ -611,44 +626,77 @@ function MemoryV1View({
         </TabsContent>
 
         {/* 用户画像 & 历史摘要 Tab */}
-        <TabsContent value="profile" className="mt-3 space-y-4">
+        <TabsContent value="profile" className="mt-3 space-y-5">
           {/* 用户画像 (userContext) */}
-          <div className="rounded-lg border p-4 space-y-2 dark:border-[#213D5E] dark:bg-[#022248]">
-            <h3 className="text-base font-medium">用户画像</h3>
+          <section className="rounded-xl border border-border/60 bg-card/40 p-4 space-y-3 dark:border-[#213D5E] dark:bg-[#022248]/50">
+            <div className="flex items-center gap-2">
+              <span className="inline-flex h-7 w-7 items-center justify-center rounded-lg bg-primary/10 text-primary dark:bg-primary/20">
+                <UserRound className="h-4 w-4" />
+              </span>
+              <h3 className="text-base font-semibold">用户画像</h3>
+            </div>
             {ctxEntries.length === 0 ? (
-              <p className="text-sm text-muted-foreground">暂无画像信息，对话后系统会自动归纳。</p>
+              <p className="rounded-lg border border-dashed p-3 text-sm text-muted-foreground dark:border-[#213D5E]">
+                暂无画像信息，对话后系统会自动归纳。
+              </p>
             ) : (
-              <dl className="space-y-2">
-                {ctxEntries.map(([key, value]) => (
-                  <div key={key} className="text-sm">
-                    <dt className="font-medium text-muted-foreground mb-0.5">
-                      {CTX_LABELS[key] ?? key}
-                    </dt>
-                    <dd className="whitespace-pre-wrap [overflow-wrap:anywhere]">{desensitize(value)}</dd>
-                  </div>
-                ))}
-              </dl>
+              <div className="grid grid-cols-1 gap-3 sm:grid-cols-2">
+                {ctxEntries.map(([key, value]) => {
+                  const Icon = CTX_ICONS[key] ?? UserRound;
+                  return (
+                    <div
+                      key={key}
+                      className="group rounded-lg border border-border/50 bg-gradient-to-br from-card to-card/40 p-3.5 shadow-sm transition-all hover:border-primary/30 hover:shadow-md dark:border-[#213D5E]/60 dark:from-[#022248]/40 dark:to-[#022248]/10"
+                    >
+                      <div className="mb-1.5 flex items-center gap-1.5 text-xs font-semibold uppercase tracking-wide text-muted-foreground">
+                        <Icon className="h-3.5 w-3.5 text-primary/80" />
+                        {CTX_LABELS[key] ?? key}
+                      </div>
+                      <p className="whitespace-pre-wrap text-sm leading-relaxed text-foreground/90 [overflow-wrap:anywhere]">
+                        {desensitize(value)}
+                      </p>
+                    </div>
+                  );
+                })}
+              </div>
             )}
-          </div>
+          </section>
 
           {/* 历史摘要 (history) */}
-          <div className="rounded-lg border p-4 space-y-2 dark:border-[#213D5E] dark:bg-[#022248]">
-            <h3 className="text-base font-medium">历史摘要</h3>
+          <section className="rounded-xl border border-border/60 bg-card/40 p-4 space-y-3 dark:border-[#213D5E] dark:bg-[#022248]/50">
+            <div className="flex items-center gap-2">
+              <span className="inline-flex h-7 w-7 items-center justify-center rounded-lg bg-primary/10 text-primary dark:bg-primary/20">
+                <History className="h-4 w-4" />
+              </span>
+              <h3 className="text-base font-semibold">历史摘要</h3>
+            </div>
             {historyEntries.length === 0 ? (
-              <p className="text-sm text-muted-foreground">暂无历史摘要。</p>
+              <p className="rounded-lg border border-dashed p-3 text-sm text-muted-foreground dark:border-[#213D5E]">
+                暂无历史摘要。
+              </p>
             ) : (
-              <dl className="space-y-2">
-                {historyEntries.map(([key, value]) => (
-                  <div key={key} className="text-sm">
-                    <dt className="font-medium text-muted-foreground mb-0.5">
-                      {HISTORY_LABELS[key] ?? key}
-                    </dt>
-                    <dd className="whitespace-pre-wrap [overflow-wrap:anywhere]">{desensitize(value)}</dd>
-                  </div>
-                ))}
-              </dl>
+              <div className="space-y-3">
+                {historyEntries.map(([key, value]) => {
+                  const Icon = HISTORY_ICONS[key] ?? History;
+                  return (
+                    <div
+                      key={key}
+                      className="relative rounded-lg border border-border/50 bg-card/60 p-3.5 pl-4 shadow-sm transition-all hover:border-primary/30 hover:shadow-md dark:border-[#213D5E]/60 dark:bg-[#022248]/30"
+                    >
+                      <span className="absolute inset-y-2 left-0 w-1 rounded-full bg-primary/30" />
+                      <div className="mb-1.5 flex items-center gap-1.5 text-xs font-semibold text-muted-foreground">
+                        <Icon className="h-3.5 w-3.5 text-primary/80" />
+                        {HISTORY_LABELS[key] ?? key}
+                      </div>
+                      <p className="whitespace-pre-wrap text-sm leading-relaxed text-foreground/90 [overflow-wrap:anywhere]">
+                        {desensitize(value)}
+                      </p>
+                    </div>
+                  );
+                })}
+              </div>
             )}
-          </div>
+          </section>
         </TabsContent>
       </Tabs>
     </div>
diff --git a/frontend-web/src/components/workspace/settings/skill-settings-page.tsx b/frontend-web/src/components/workspace/settings/skill-settings-page.tsx
index afd3cfc3..10e3d3d1 100644
--- a/frontend-web/src/components/workspace/settings/skill-settings-page.tsx
+++ b/frontend-web/src/components/workspace/settings/skill-settings-page.tsx
@@ -22,6 +22,8 @@ import {
   Trash2Icon,
   TrendingUpIcon,
   Upload,
+  UserIcon,
+  XIcon,
 } from "lucide-react";
 import { useRouter } from "next/navigation";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
@@ -55,6 +57,7 @@ import {
 import { Input } from "@/components/ui/input";
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
 import { Tabs, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { ModelNameSelect } from "@/components/workspace/model-name-select";
 import { SkillDetailDialog } from "@/components/workspace/skills/skill-detail-dialog";
 import { TagChipList } from "@/components/workspace/tags/tag-chip";
 import { TagPickerDialog } from "@/components/workspace/tags/tag-picker-dialog";
@@ -67,9 +70,12 @@ import type { ValidateSkillUploadResponse } from "@/core/skills/api";
 import {
   useDeleteCustomSkill,
   useDuplicateSkill,
+  useGenerateMissingSkillNameZh,
+  useGenerateSkillNameZh,
   useInstallSkillUpload,
   useReconcileCustomSkills,
   useSetSkillFeatured,
+  useSetSkillNameZh,
   useSetSkillPinned,
   useSetSkillPublished,
   useSkills,
@@ -152,8 +158,16 @@ function SkillSettingsList({ onClose }: { onClose?: () => void }) {
   const [tagIds, setTagIds] = useState<string[]>([]);
   const [sort, setSort] = useState<SkillSort>("time_desc");
   const [page, setPage] = useState(1);
+  // Publisher filter: click a skill's 发布者 to keep only that user's skills.
+  // {id} is owner_user_id; {label} the desensitized display name.
+  const [publisher, setPublisher] = useState<{ id: string; label: string } | null>(
+    null,
+  );
   const [viewMode, setViewMode] = useViewMode("skill");
   const reconcileMutation = useReconcileCustomSkills();
+  const fillNamesMutation = useGenerateMissingSkillNameZh();
+  // Optional model override for the admin "一键补充中文名" action (null = default).
+  const [fillModel, setFillModel] = useState<string | null>(null);
   // Name + tag filtering is resolved server-side via the /api/skills query.
   const { skills, isLoading, error } = useSkills({ search, tagIds, sort });
 
@@ -200,7 +214,14 @@ function SkillSettingsList({ onClose }: { onClose?: () => void }) {
     };
   }, [skills, currentUserId]);
 
-  const filteredSkills = filter === "mine" ? activeMine : activeAll;
+  const scopedSkills = filter === "mine" ? activeMine : activeAll;
+  const filteredSkills = useMemo(
+    () =>
+      publisher
+        ? scopedSkills.filter((s) => s.owner_user_id === publisher.id)
+        : scopedSkills,
+    [scopedSkills, publisher],
+  );
   const orderedSkills = useMemo(
     () =>
       filteredSkills
@@ -225,12 +246,34 @@ function SkillSettingsList({ onClose }: { onClose?: () => void }) {
   }, [page, totalPages]);
   useEffect(() => {
     setPage(1);
-  }, [search, tagIds, sort]);
+  }, [search, tagIds, sort, publisher?.id, filter]);
   const pagedSkills = useMemo(
     () => orderedSkills.slice((page - 1) * PAGE_SIZE, page * PAGE_SIZE),
     [orderedSkills, page],
   );
 
+  const handleFillNames = async () => {
+    try {
+      const result = await fillNamesMutation.mutateAsync(fillModel);
+      const okCount = result.generated.length;
+      const failCount = result.failed.length;
+      if (okCount === 0 && failCount === 0) {
+        toast.info("所有技能均已配置中文名称");
+      } else if (failCount === 0) {
+        toast.success(`已为 ${okCount} 个技能补充中文名称`);
+      } else if (result.model_error) {
+        // Failures came from the model itself — say so explicitly.
+        toast.warning(
+          `已补充 ${okCount} 个,${failCount} 个因大模型报错失败:${result.model_error}`,
+        );
+      } else {
+        toast.warning(`已补充 ${okCount} 个,${failCount} 个生成失败,可稍后重试或手动填写`);
+      }
+    } catch (err) {
+      toast.error(err instanceof Error ? err.message : String(err));
+    }
+  };
+
   const handleRescan = async () => {
     try {
       const result = await reconcileMutation.mutateAsync();
@@ -321,6 +364,37 @@ function SkillSettingsList({ onClose }: { onClose?: () => void }) {
               ? t.settings.skills.rescanSkillsRunning
               : t.settings.skills.rescanSkills}
           </Button>
+          {isAdmin && (
+            <>
+              <ModelNameSelect
+                value={fillModel}
+                onChange={setFillModel}
+                disabled={
+                  fillNamesMutation.isPending ||
+                  env.NEXT_PUBLIC_STATIC_WEBSITE_ONLY === "true"
+                }
+                triggerClassName="h-8 w-[9.5rem]"
+              />
+              <Button
+                size="sm"
+                variant="outline"
+                className="gap-1.5 border-violet-300 bg-violet-50 font-medium text-violet-700 hover:bg-violet-100 hover:text-violet-800 dark:border-violet-500/40 dark:bg-violet-500/15 dark:text-violet-300 dark:hover:bg-violet-500/25"
+                onClick={() => void handleFillNames()}
+                disabled={
+                  fillNamesMutation.isPending ||
+                  env.NEXT_PUBLIC_STATIC_WEBSITE_ONLY === "true"
+                }
+                title="用所选大模型为所有尚未配置中文名称的技能自动生成中文名(仅管理员)"
+              >
+                {fillNamesMutation.isPending ? (
+                  <Loader2 className="size-4 animate-spin" />
+                ) : (
+                  <SparklesIcon className="size-4" />
+                )}
+                {fillNamesMutation.isPending ? "补充中…" : "一键补充中文名"}
+              </Button>
+            </>
+          )}
           <Button
             size="sm"
             variant="outline"
@@ -362,6 +436,20 @@ function SkillSettingsList({ onClose }: { onClose?: () => void }) {
           </div>
         }
       />
+      {publisher && (
+        <div className="flex items-center gap-2">
+          <span className="text-muted-foreground text-xs">筛选发布者：</span>
+          <button
+            type="button"
+            onClick={() => setPublisher(null)}
+            className="bg-primary/10 text-primary hover:bg-primary/20 inline-flex items-center gap-1 rounded-full px-3 py-1 text-xs font-medium transition-colors"
+            title="点击清除发布者筛选"
+          >
+            {publisher.label}
+            <XIcon className="size-3.5" />
+          </button>
+        </div>
+      )}
       {isLoading && (
         <div className="text-muted-foreground text-sm">{t.common.loading}</div>
       )}
@@ -384,6 +472,7 @@ function SkillSettingsList({ onClose }: { onClose?: () => void }) {
               currentUserId={currentUserId}
               isAdmin={isAdmin}
               layout={viewMode === "card" ? "card" : "row"}
+              onPublisherClick={setPublisher}
             />
           ))}
         </div>
@@ -441,12 +530,16 @@ export function SkillRow({
   currentUserId,
   isAdmin,
   layout = "row",
+  onPublisherClick,
 }: {
   skill: Skill;
   currentUserId: string | null;
   isAdmin: boolean;
   /** "row" = full-width horizontal item (default); "card" = grid card cell. */
   layout?: "row" | "card";
+  /** Click the 发布者 line to filter the list to that publisher. Receives the
+   * owner_user_id + its desensitized display label. */
+  onPublisherClick?: (publisher: { id: string; label: string }) => void;
 }) {
   const isCard = layout === "card";
   const { t } = useI18n();
@@ -549,8 +642,13 @@ export function SkillRow({
   const badgeGroup = (
     <div className="flex flex-wrap items-center gap-2">
       <span className={cn(isCard && "truncate font-medium")}>
-        {desensitize(skill.name)}
+        {skill.name_zh?.trim() ? skill.name_zh : desensitize(skill.name)}
       </span>
+      {skill.name_zh?.trim() && (
+        <span className="text-muted-foreground truncate text-xs font-normal">
+          {desensitize(skill.name)}
+        </span>
+      )}
       {isBuiltin && (
         <Badge variant="secondary" className="text-xs">
           {t.settings.skills.badgeBuiltin}
@@ -631,6 +729,33 @@ export function SkillRow({
 
   const metaNodes = (
     <>
+      {!isBuiltin && skill.owner_username && (
+        <button
+          type="button"
+          disabled={!skill.owner_user_id || !onPublisherClick}
+          onClick={(e) => {
+            if (!skill.owner_user_id || !onPublisherClick) return;
+            e.stopPropagation();
+            onPublisherClick({
+              id: skill.owner_user_id,
+              label: desensitize(skill.owner_username!),
+            });
+          }}
+          className={cn(
+            "text-muted-foreground mt-1 flex max-w-full items-center gap-1 text-sm font-medium",
+            skill.owner_user_id && onPublisherClick &&
+              "hover:text-primary cursor-pointer transition-colors hover:underline",
+          )}
+          title={
+            skill.owner_user_id && onPublisherClick
+              ? `点击筛选发布者：${desensitize(skill.owner_username)}`
+              : `发布者：${desensitize(skill.owner_username)}`
+          }
+        >
+          <UserIcon className="size-3.5 shrink-0" />
+          <span className="truncate">发布者：{desensitize(skill.owner_username)}</span>
+        </button>
+      )}
       {skill.use_count !== undefined && (
         <div className="text-muted-foreground mt-1 text-xs">
           {skill.use_count > 0
@@ -649,15 +774,15 @@ export function SkillRow({
 
   const actionButtons = (
     <>
-      <Button
-        size="icon"
-        variant="ghost"
-        className="h-8 w-8 shrink-0"
-        onClick={() => setTagPickerOpen(true)}
-        title={t.adminTags.manageTags}
-      >
-        <TagsIcon className="size-3.5" />
-      </Button>
+      <Button
+        size="icon"
+        variant="ghost"
+        className="h-8 w-8 shrink-0"
+        onClick={() => setTagPickerOpen(true)}
+        title={t.adminTags.manageTags}
+      >
+        <TagsIcon className="size-3.5" />
+      </Button>
       {canManage && (
         <Button
           size="icon"
@@ -842,13 +967,13 @@ export function SkillRow({
           </DialogFooter>
         </DialogContent>
       </Dialog>
-      <TagPickerDialog
-        open={tagPickerOpen}
-        onOpenChange={setTagPickerOpen}
-        targetType="skill"
-        targetId={skill.name}
-        currentTags={skill.tags ?? []}
-      />
+      <TagPickerDialog
+        open={tagPickerOpen}
+        onOpenChange={setTagPickerOpen}
+        targetType="skill"
+        targetId={skill.name}
+        currentTags={skill.tags ?? []}
+      />
       <SkillDetailDialog
         skillName={skill.name}
         open={detailOpen}
@@ -892,8 +1017,16 @@ function InstallSkillDialog({
   const [validationError, setValidationError] = useState<string | null>(null);
   const [isDragging, setIsDragging] = useState(false);
   const [targetCategory, setTargetCategory] = useState<"custom" | "public">("custom");
+  // After a successful install the dialog switches to a "set Chinese name" step.
+  // `installedName` holds the just-installed skill name (null = still on the upload step).
+  const [installedName, setInstalledName] = useState<string | null>(null);
+  const [nameZhDraft, setNameZhDraft] = useState("");
+  // Optional model override for the "AI generate" button (null = configured default).
+  const [nameZhModel, setNameZhModel] = useState<string | null>(null);
   const validateMutation = useValidateSkillUpload();
   const installMutation = useInstallSkillUpload();
+  const setNameZhMutation = useSetSkillNameZh();
+  const generateNameZhMutation = useGenerateSkillNameZh();
 
   const reset = useCallback(() => {
     setFile(null);
@@ -901,14 +1034,30 @@ function InstallSkillDialog({
     setValidationError(null);
     setIsDragging(false);
     setTargetCategory("custom");
+    setInstalledName(null);
+    setNameZhDraft("");
+    setNameZhModel(null);
     if (inputRef.current) inputRef.current.value = "";
   }, []);
 
   const handleClose = useCallback(() => {
-    if (validateMutation.isPending || installMutation.isPending) return;
+    if (
+      validateMutation.isPending ||
+      installMutation.isPending ||
+      setNameZhMutation.isPending ||
+      generateNameZhMutation.isPending
+    )
+      return;
     reset();
     onClose();
-  }, [installMutation.isPending, onClose, reset, validateMutation.isPending]);
+  }, [
+    generateNameZhMutation.isPending,
+    installMutation.isPending,
+    onClose,
+    reset,
+    setNameZhMutation.isPending,
+    validateMutation.isPending,
+  ]);
 
   const acceptFile = useCallback(
     async (selected: File) => {
@@ -964,15 +1113,47 @@ function InstallSkillDialog({
             result.skill_name,
           ),
         );
-        reset();
-        onClose();
+        // Stay open and advance to the optional "set Chinese name" step.
+        setInstalledName(result.skill_name);
+        setNameZhDraft("");
+        setNameZhModel(null);
       } catch (err) {
         toast.error(err instanceof Error ? err.message : String(err));
       }
     },
-    [dialog.installSuccess, dialog.installSuccessReplaced, file, installMutation, onClose, reset, targetCategory],
+    [dialog.installSuccess, dialog.installSuccessReplaced, file, installMutation, targetCategory],
   );
 
+  const handleGenerateNameZh = useCallback(async () => {
+    if (!installedName) return;
+    try {
+      const result = await generateNameZhMutation.mutateAsync({
+        skillName: installedName,
+        modelName: nameZhModel,
+      });
+      setNameZhDraft(result.name_zh ?? "");
+      toast.success(dialog.nameZhGenerated);
+    } catch (err) {
+      toast.error(err instanceof Error ? err.message : String(err));
+    }
+  }, [dialog.nameZhGenerated, generateNameZhMutation, installedName, nameZhModel]);
+
+  const handleSaveNameZh = useCallback(async () => {
+    if (!installedName) return;
+    const trimmed = nameZhDraft.trim();
+    try {
+      // Empty draft = keep whatever is stored (or none); just close.
+      if (trimmed) {
+        await setNameZhMutation.mutateAsync({ skillName: installedName, nameZh: trimmed });
+        toast.success(dialog.nameZhSaved);
+      }
+      reset();
+      onClose();
+    } catch (err) {
+      toast.error(err instanceof Error ? err.message : String(err));
+    }
+  }, [dialog.nameZhSaved, installedName, nameZhDraft, onClose, reset, setNameZhMutation]);
+
   const isPublicConflict = validation?.conflict && validation.conflict_kind === "public";
   const isCustomConflict = validation?.conflict && validation.conflict_kind === "custom";
   // Admin targeting public directory can overwrite an existing public skill.
@@ -984,8 +1165,70 @@ function InstallSkillDialog({
     <Dialog open={open} onOpenChange={(o) => !o && handleClose()}>
       <DialogContent className="max-w-xl">
         <DialogHeader>
-          <DialogTitle>{dialog.title}</DialogTitle>
+          <DialogTitle>{installedName ? dialog.nameZhStepTitle : dialog.title}</DialogTitle>
         </DialogHeader>
+
+        {installedName && (
+          <>
+            <div className="flex flex-col gap-4">
+              <p className="text-muted-foreground text-sm">
+                {dialog.nameZhStepHint.replace("{name}", desensitize(installedName))}
+              </p>
+              <div className="flex items-center gap-2">
+                <Input
+                  value={nameZhDraft}
+                  onChange={(e) => setNameZhDraft(e.currentTarget.value)}
+                  onKeyDown={(e) => {
+                    if (e.key === "Enter") void handleSaveNameZh();
+                  }}
+                  placeholder={dialog.nameZhPlaceholder}
+                  className="h-9 flex-1"
+                  autoFocus
+                  disabled={setNameZhMutation.isPending || generateNameZhMutation.isPending}
+                />
+                <ModelNameSelect
+                  value={nameZhModel}
+                  onChange={setNameZhModel}
+                  disabled={setNameZhMutation.isPending || generateNameZhMutation.isPending}
+                  triggerClassName="h-9 w-[9rem] shrink-0"
+                />
+                <Button
+                  variant="outline"
+                  className="h-9 shrink-0 gap-1 border-violet-300 bg-violet-50 text-violet-700 hover:bg-violet-100 hover:text-violet-800 dark:border-violet-500/40 dark:bg-violet-500/15 dark:text-violet-300 dark:hover:bg-violet-500/25"
+                  onClick={() => void handleGenerateNameZh()}
+                  disabled={setNameZhMutation.isPending || generateNameZhMutation.isPending}
+                  title={dialog.nameZhGenerate}
+                >
+                  {generateNameZhMutation.isPending ? (
+                    <Loader2 className="size-4 animate-spin" />
+                  ) : (
+                    <SparklesIcon className="size-4" />
+                  )}
+                  {dialog.nameZhGenerate}
+                </Button>
+              </div>
+            </div>
+            <DialogFooter>
+              <Button
+                variant="outline"
+                onClick={handleClose}
+                disabled={setNameZhMutation.isPending || generateNameZhMutation.isPending}
+              >
+                {dialog.nameZhSkip}
+              </Button>
+              <Button
+                onClick={() => void handleSaveNameZh()}
+                disabled={setNameZhMutation.isPending || generateNameZhMutation.isPending}
+              >
+                {setNameZhMutation.isPending && <Loader2 className="size-4 animate-spin" />}
+                {t.common.save}
+              </Button>
+            </DialogFooter>
+          </>
+        )}
+
+        {!installedName && (
+        <>
         <div className="flex flex-col gap-4">
           <div
             onDragOver={(e) => {
@@ -1148,6 +1391,8 @@ function InstallSkillDialog({
             {installMutation.isPending ? dialog.installing : dialog.install}
           </Button>
         </DialogFooter>
+        </>
+        )}
       </DialogContent>
     </Dialog>
   );
diff --git a/frontend-web/src/components/workspace/skills/skill-detail-dialog.tsx b/frontend-web/src/components/workspace/skills/skill-detail-dialog.tsx
index 94148451..733cbf27 100644
--- a/frontend-web/src/components/workspace/skills/skill-detail-dialog.tsx
+++ b/frontend-web/src/components/workspace/skills/skill-detail-dialog.tsx
@@ -11,6 +11,7 @@ import {
   PencilIcon,
   SlidersHorizontalIcon,
   SparklesIcon,
+  XIcon,
 } from "lucide-react";
 import { useEffect, useMemo, useState } from "react";
 import { toast } from "sonner";
@@ -24,16 +25,20 @@ import {
   DialogHeader,
   DialogTitle,
 } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
 import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
 import { Textarea } from "@/components/ui/textarea";
 import { MarkdownContent } from "@/components/workspace/messages/markdown-content";
+import { ModelNameSelect } from "@/components/workspace/model-name-select";
 import { SkillDisplayAdapterPanel } from "@/components/workspace/skill-display-adapter-panel";
 import { SkillFilePreviewDialog } from "@/components/workspace/skills/skill-file-preview-dialog";
 import { SkillFileTree } from "@/components/workspace/skills/skill-file-tree";
 import { getStoredAuth } from "@/core/auth";
 import { useI18n } from "@/core/i18n/hooks";
 import {
+  useGenerateSkillNameZh,
   useSetSkillDetail,
+  useSetSkillNameZh,
   useSkill,
   useSkillContent,
   useSkillFiles,
@@ -98,9 +103,15 @@ export function SkillDetailDialog({
   const activeName = open ? skillName : null;
   const { data: skill, isLoading: isSkillLoading } = useSkill(activeName);
   const setDetail = useSetSkillDetail();
+  const setNameZh = useSetSkillNameZh();
+  const generateNameZh = useGenerateSkillNameZh();
 
   const [editing, setEditing] = useState(false);
   const [draft, setDraft] = useState("");
+  const [editingNameZh, setEditingNameZh] = useState(false);
+  const [nameZhDraft, setNameZhDraft] = useState("");
+  // Optional model override for the "AI 生成" button (null = configured default).
+  const [nameZhModel, setNameZhModel] = useState<string | null>(null);
   const [activeTab, setActiveTab] = useState<
     "detail" | "display" | "source" | "files" | null
   >(null);
@@ -109,13 +120,20 @@ export function SkillDetailDialog({
 
   const canManage = useMemo(() => canManageSkill(skill), [skill]);
   const isOwner = useMemo(() => isSkillOwner(skill), [skill]);
+  // Admins may browse any skill's files (the backend authorizes this); owners
+  // may browse their own custom skill. Edit-ability is decided separately by
+  // the backend's `filesData.editable` flag.
+  const canViewFiles = useMemo(() => {
+    if (!skill) return false;
+    return isOwner || getStoredAuth()?.system_role === "admin";
+  }, [skill, isOwner]);
   const {
     data: contentData,
     isLoading: isContentLoading,
     error: contentError,
   } = useSkillContent(open ? skillName : null);
 
-  const filesEnabled = open && isOwner && activeTab === "files";
+  const filesEnabled = open && canViewFiles && activeTab === "files";
   const {
     data: filesData,
     isLoading: isFilesLoading,
@@ -124,11 +142,16 @@ export function SkillDetailDialog({
 
   useEffect(() => {
     setEditing(false);
+    setEditingNameZh(false);
     setActiveTab(null);
     setShowRawSource(false);
     setOpenedFilePath(null);
   }, [open, skillName]);
 
+  useEffect(() => {
+    setNameZhDraft(skill?.name_zh ?? "");
+  }, [skill?.name, skill?.name_zh]);
+
   const skillBody = useMemo(() => {
     return stripYamlFrontmatter(contentData?.content ?? "");
   }, [contentData]);
@@ -152,6 +175,39 @@ export function SkillDetailDialog({
     }
   }
 
+  function startEditingNameZh() {
+    setNameZhDraft(skill?.name_zh ?? "");
+    setEditingNameZh(true);
+  }
+
+  async function handleSaveNameZh() {
+    if (!skill) return;
+    try {
+      await setNameZh.mutateAsync({
+        skillName: skill.name,
+        nameZh: nameZhDraft.trim(),
+      });
+      toast.success("中文名称已保存");
+      setEditingNameZh(false);
+    } catch (err) {
+      toast.error(err instanceof Error ? err.message : String(err));
+    }
+  }
+
+  async function handleGenerateNameZh() {
+    if (!skill) return;
+    try {
+      const result = await generateNameZh.mutateAsync({
+        skillName: skill.name,
+        modelName: nameZhModel,
+      });
+      setNameZhDraft(result.name_zh ?? "");
+      toast.success("已生成中文名称");
+    } catch (err) {
+      toast.error(err instanceof Error ? err.message : String(err));
+    }
+  }
+
   async function copySource() {
     await navigator.clipboard.writeText(contentData?.content ?? "");
     toast.success("Copied SKILL.md content");
@@ -174,25 +230,105 @@ export function SkillDetailDialog({
               <SparklesIcon className="size-5" />
             </div>
             <div className="min-w-0 flex-1">
-              <div className="flex flex-wrap items-center gap-2">
-                <DialogTitle className="truncate text-base">
-                  {desensitize(skill?.name ?? skillName ?? "")}
-                </DialogTitle>
-                {skill?.builtin && (
-                  <Badge variant="secondary" className="text-xs">
-                    {tx.badgeBuiltin}
-                  </Badge>
-                )}
-                {skill?.published && (
-                  <Badge
+              {editingNameZh ? (
+                <div className="flex items-center gap-1.5">
+                  <DialogTitle className="sr-only">
+                    {desensitize(skill?.name ?? skillName ?? "")}
+                  </DialogTitle>
+                  <Input
+                    value={nameZhDraft}
+                    onChange={(event) => setNameZhDraft(event.currentTarget.value)}
+                    onKeyDown={(event) => {
+                      if (event.key === "Enter") void handleSaveNameZh();
+                      if (event.key === "Escape") setEditingNameZh(false);
+                    }}
+                    placeholder={desensitize(skill?.name ?? skillName ?? "")}
+                    className="h-8 max-w-[14rem] flex-1 text-sm"
+                    autoFocus
+                    disabled={generateNameZh.isPending || setNameZh.isPending}
+                  />
+                  <ModelNameSelect
+                    value={nameZhModel}
+                    onChange={setNameZhModel}
+                    disabled={generateNameZh.isPending || setNameZh.isPending}
+                    triggerClassName="h-8 w-[8.5rem] shrink-0"
+                  />
+                  <Button
+                    size="sm"
                     variant="outline"
-                    className="border-sky-500/30 text-xs text-sky-700 dark:text-sky-300"
+                    className="h-8 shrink-0 gap-1 border-violet-300 bg-violet-50 px-2.5 text-xs font-medium text-violet-700 hover:bg-violet-100 hover:text-violet-800 dark:border-violet-500/40 dark:bg-violet-500/15 dark:text-violet-300 dark:hover:bg-violet-500/25"
+                    onClick={() => void handleGenerateNameZh()}
+                    disabled={generateNameZh.isPending || setNameZh.isPending}
+                    title="用所选大模型自动生成中文名"
                   >
-                    <GlobeIcon className="size-3" />
-                    {tx.badgePublished}
-                  </Badge>
-                )}
-              </div>
+                    {generateNameZh.isPending ? (
+                      <Loader2 className="size-3.5 animate-spin" />
+                    ) : (
+                      <SparklesIcon className="size-3.5" />
+                    )}
+                    AI 生成
+                  </Button>
+                  <Button
+                    size="sm"
+                    className="h-8 shrink-0 px-3 text-xs"
+                    onClick={() => void handleSaveNameZh()}
+                    disabled={setNameZh.isPending || generateNameZh.isPending}
+                  >
+                    {setNameZh.isPending && (
+                      <Loader2 className="size-3.5 animate-spin" />
+                    )}
+                    {t.common.save}
+                  </Button>
+                  <Button
+                    size="icon"
+                    variant="ghost"
+                    className="text-muted-foreground hover:text-foreground size-8 shrink-0"
+                    onClick={() => setEditingNameZh(false)}
+                    disabled={setNameZh.isPending}
+                    title={t.common.cancel}
+                  >
+                    <XIcon className="size-4" />
+                  </Button>
+                </div>
+              ) : (
+                <div className="group flex flex-wrap items-center gap-2">
+                  <DialogTitle className="truncate text-base">
+                    {skill?.name_zh?.trim()
+                      ? skill.name_zh
+                      : desensitize(skill?.name ?? skillName ?? "")}
+                  </DialogTitle>
+                  {skill?.name_zh?.trim() && (
+                    <span className="text-muted-foreground truncate font-mono text-xs">
+                      {desensitize(skill?.name ?? skillName ?? "")}
+                    </span>
+                  )}
+                  {canManage && (
+                    <Button
+                      size="icon"
+                      variant="ghost"
+                      className="text-muted-foreground hover:text-foreground size-6 shrink-0 opacity-60 transition-opacity hover:opacity-100"
+                      onClick={startEditingNameZh}
+                      title={skill?.name_zh?.trim() ? "编辑中文名" : "设置中文名"}
+                    >
+                      <PencilIcon className="size-3" />
+                    </Button>
+                  )}
+                  {skill?.builtin && (
+                    <Badge variant="secondary" className="text-xs">
+                      {tx.badgeBuiltin}
+                    </Badge>
+                  )}
+                  {skill?.published && (
+                    <Badge
+                      variant="outline"
+                      className="border-sky-500/30 text-xs text-sky-700 dark:text-sky-300"
+                    >
+                      <GlobeIcon className="size-3" />
+                      {tx.badgePublished}
+                    </Badge>
+                  )}
+                </div>
+              )}
               <DialogDescription className="mt-1 line-clamp-2 text-sm leading-relaxed">
                 {skill?.description ? desensitize(skill.description) : "-"}
               </DialogDescription>
@@ -227,7 +363,7 @@ export function SkillDetailDialog({
                   展示适配
                 </TabsTrigger>
               )}
-              {isOwner && (
+              {canViewFiles && (
                 <TabsTrigger value="files" className="text-xs">
                   <FilesIcon className="mr-1 size-3.5" />
                   {tx.filesSectionTitle}
@@ -349,7 +485,7 @@ export function SkillDetailDialog({
             </TabsContent>
           )}
 
-          {isOwner && (
+          {canViewFiles && (
             <TabsContent
               value="files"
               className="m-0 min-h-0 flex-1 overscroll-contain px-6 py-4 data-[state=inactive]:hidden"
diff --git a/frontend-web/src/components/workspace/tags/tag-search-bar.tsx b/frontend-web/src/components/workspace/tags/tag-search-bar.tsx
index 399f9d84..c302b8f9 100644
--- a/frontend-web/src/components/workspace/tags/tag-search-bar.tsx
+++ b/frontend-web/src/components/workspace/tags/tag-search-bar.tsx
@@ -1,8 +1,9 @@
 "use client";
 
-import { CheckIcon, ChevronDownIcon, ChevronUpIcon, SearchIcon } from "lucide-react";
+import { CheckIcon, ChevronDownIcon, ChevronUpIcon, Loader2, SearchIcon } from "lucide-react";
 import { useEffect, useRef, useState, type ReactNode } from "react";
 
+import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { useI18n } from "@/core/i18n/hooks";
 import { useTags, type TagType } from "@/core/tags";
@@ -18,27 +19,42 @@ const COLLAPSE_THRESHOLD = 16;
  *
  * The name input is debounced (300ms) before ``onSearchChange`` fires, so the
  * caller can feed the value straight into a server-side query without a
- * request per keystroke.
+ * request per keystroke. Pressing Enter or clicking the 搜索 button flushes the
+ * pending debounce immediately, so users never wait on the timer.
+ *
+ * Pass ``searching`` while a query is in flight to show an inline spinner — it
+ * makes server-side searches feel responsive instead of looking like they kept
+ * the previous results.
  *
  * Tags are rendered inline as a multi-select chip row (instead of a dropdown):
  * "全部" is selected when no tag is picked, and any number of tags can be
  * toggled. Filtering is OR — a resource matches if it carries any picked tag.
- * When there are many tags the row collapses behind a 展开/收起 toggle.
+ * When there are many tags the row collapses behind a 展开/收起 toggle. Pass
+ * ``hideTags`` for resources without tags (e.g. the published-task plaza).
  */
 export function TagSearchBar({
   targetType,
   onSearchChange,
-  tagIds,
+  tagIds = [],
   onTagIdsChange,
   className,
   actions,
+  searching = false,
+  hideTags = false,
+  searchPlaceholder,
 }: {
   targetType: TagType;
   onSearchChange: (value: string) => void;
-  tagIds: string[];
-  onTagIdsChange: (value: string[]) => void;
+  tagIds?: string[];
+  onTagIdsChange?: (value: string[]) => void;
   className?: string;
   actions?: ReactNode;
+  /** Show an inline spinner while the caller's query is fetching. */
+  searching?: boolean;
+  /** Hide the tag chip row for resources that have no tags. */
+  hideTags?: boolean;
+  /** Override the search input placeholder. */
+  searchPlaceholder?: string;
 }) {
   const { t } = useI18n();
   const { data: tags } = useTags(targetType);
@@ -47,11 +63,21 @@ export function TagSearchBar({
   const [expanded, setExpanded] = useState(false);
   const cbRef = useRef(onSearchChange);
   cbRef.current = onSearchChange;
+  // Keep the pending debounce timer so an explicit search (Enter / 搜索 button)
+  // can cancel it and fire immediately instead of racing the 300ms delay.
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   useEffect(() => {
-    const id = setTimeout(() => cbRef.current(input.trim()), 300);
-    return () => clearTimeout(id);
+    timerRef.current = setTimeout(() => cbRef.current(input.trim()), 300);
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+    };
   }, [input]);
 
+  const flushSearch = () => {
+    if (timerRef.current) clearTimeout(timerRef.current);
+    cbRef.current(input.trim());
+  };
+
   const allTags = tags ?? [];
   const canCollapse = allTags.length > COLLAPSE_THRESHOLD;
   // When collapsed, always keep the selected tags visible so the active
@@ -62,7 +88,7 @@ export function TagSearchBar({
       : allTags;
 
   const toggleTag = (id: string) => {
-    onTagIdsChange(
+    onTagIdsChange?.(
       tagIds.includes(id) ? tagIds.filter((x) => x !== id) : [...tagIds, id],
     );
   };
@@ -75,8 +101,14 @@ export function TagSearchBar({
           <Input
             value={input}
             onChange={(e) => setInput(e.target.value)}
-            placeholder={t.adminTags.searchPlaceholder}
-            className="pl-8"
+            onKeyDown={(e) => {
+              if (e.key === "Enter") {
+                e.preventDefault();
+                flushSearch();
+              }
+            }}
+            placeholder={searchPlaceholder ?? t.adminTags.searchPlaceholder}
+            className={cn("pl-8", searching && "pr-9")}
             name="tag-search"
             // A `type="password"` field elsewhere on the page (e.g. the private
             // square access gate) makes browsers / password managers pick the
@@ -88,7 +120,24 @@ export function TagSearchBar({
             data-lpignore="true"
             data-form-type="other"
           />
+          {searching && (
+            <Loader2 className="text-muted-foreground absolute right-2.5 top-1/2 size-4 -translate-y-1/2 animate-spin" />
+          )}
         </div>
+        <Button
+          type="button"
+          variant="outline"
+          onClick={flushSearch}
+          className="shrink-0 gap-1.5"
+          title="搜索"
+        >
+          {searching ? (
+            <Loader2 className="size-4 animate-spin" />
+          ) : (
+            <SearchIcon className="size-4" />
+          )}
+          搜索
+        </Button>
         {actions && (
           <div className="flex w-full shrink-0 justify-end sm:w-auto">
             {actions}
@@ -96,11 +145,11 @@ export function TagSearchBar({
         )}
       </div>
 
-      {allTags.length > 0 && (
+      {!hideTags && allTags.length > 0 && (
         <div className="flex flex-wrap items-center gap-1.5">
           <button
             type="button"
-            onClick={() => onTagIdsChange([])}
+            onClick={() => onTagIdsChange?.([])}
             className={cn(
               "inline-flex items-center rounded-full border px-3 py-1 text-xs font-medium transition-all",
               tagIds.length === 0
diff --git a/frontend-web/src/components/workspace/workspace-nav-chat-list.tsx b/frontend-web/src/components/workspace/workspace-nav-chat-list.tsx
index 2fca2ddf..6b3ab2fe 100644
--- a/frontend-web/src/components/workspace/workspace-nav-chat-list.tsx
+++ b/frontend-web/src/components/workspace/workspace-nav-chat-list.tsx
@@ -14,7 +14,7 @@ import {
 } from "@/components/ui/sidebar";
 import { useI18n } from "@/core/i18n/hooks";
 // import { BotIcon, BrainIcon, ListChecks, MessageSquarePlus, MessagesSquare, SparklesIcon, UsersIcon } from "lucide-react";
-import { BotIcon, BrainIcon, ListChecks, MessageSquarePlus, MessagesSquare, PenLine, SparklesIcon, Users } from "lucide-react";
+import { BookOpen, BotIcon, BrainIcon, ListChecks, MessageSquarePlus, MessagesSquare, PenLine, SparklesIcon, Users } from "lucide-react";
 
 import { SidebarCollapseButton } from "./workspace-header";
 import { WorkspaceNavStudio } from "./workspace-nav-studio";
@@ -161,6 +161,18 @@ export function WorkspaceNavChatList({
                 </Link>
               </SidebarMenuButton>
             </SidebarMenuItem>
+            <SidebarMenuItem>
+              <SidebarMenuButton
+                isActive={pathname.startsWith("/page/workspace/knowledge")}
+                asChild
+                className={NAV_ITEM_CLASS}
+              >
+                <Link href="/page/workspace/knowledge">
+                  <BookOpen />
+                  <span>知识库</span>
+                </Link>
+              </SidebarMenuButton>
+            </SidebarMenuItem>
           </>
         )}
       </SidebarMenu>
diff --git a/frontend-web/src/components/workspace/workspace-nav-menu.tsx b/frontend-web/src/components/workspace/workspace-nav-menu.tsx
index 7bf03a18..73cf8a72 100644
--- a/frontend-web/src/components/workspace/workspace-nav-menu.tsx
+++ b/frontend-web/src/components/workspace/workspace-nav-menu.tsx
@@ -9,15 +9,12 @@ import {
   DatabaseZapIcon,
   GaugeIcon,
   HistoryIcon,
-  MessageSquareCodeIcon,
-  MessageSquarePlusIcon,
   ScrollTextIcon,
   Settings2Icon,
   SettingsIcon,
-  ShieldCheckIcon,
   SparklesIcon,
   TagsIcon,
-  UsersIcon,
+  TrophyIcon,
 } from "lucide-react";
 import { useEffect, useState } from "react";
 
@@ -148,36 +145,6 @@ export function WorkspaceNavMenu() {
                     <Settings2Icon />
                     {t.common.settings}
                   </DropdownMenuItem>
-                  {isAdmin && (
-                    <DropdownMenuItem
-                      onClick={() =>
-                        navigate("/page/workspace/settings/recommended-questions")
-                      }
-                    >
-                      <MessageSquarePlusIcon />
-                      推荐问题配置
-                    </DropdownMenuItem>
-                  )}
-                  {isAdmin && (
-                    <DropdownMenuItem
-                      onClick={() =>
-                        navigate("/page/workspace/settings/prompt-prefix")
-                      }
-                    >
-                      <MessageSquareCodeIcon />
-                      问答前缀配置
-                    </DropdownMenuItem>
-                  )}
-                  {isAdmin && (
-                    <DropdownMenuItem
-                      onClick={() =>
-                        navigate("/page/workspace/settings/private-square")
-                      }
-                    >
-                      <ShieldCheckIcon />
-                      私密广场配置
-                    </DropdownMenuItem>
-                  )}
                   {isAdmin && (
                     <DropdownMenuItem
                       onClick={() =>
@@ -200,10 +167,12 @@ export function WorkspaceNavMenu() {
                   )}
                   {isAdmin && (
                     <DropdownMenuItem
-                      onClick={() => navigate("/page/workspace/admin")}
+                      onClick={() =>
+                        navigate("/page/strategy/admin/user-leaderboard")
+                      }
                     >
-                      <UsersIcon />
-                      用户中心
+                      <TrophyIcon />
+                      用户排行榜
                     </DropdownMenuItem>
                   )}
                   {isAdmin && (
@@ -232,12 +201,12 @@ export function WorkspaceNavMenu() {
                       技能管理
                     </DropdownMenuItem>
                   )}
-                  <DropdownMenuItem
-                    onClick={() => navigate("/page/workspace/admin/tags")}
-                  >
-                    <TagsIcon />
-                    {t.adminTags.title}
-                  </DropdownMenuItem>
+                  <DropdownMenuItem
+                    onClick={() => navigate("/page/workspace/admin/tags")}
+                  >
+                    <TagsIcon />
+                    {t.adminTags.title}
+                  </DropdownMenuItem>
                   {isAdmin && logSystem?.enabled && logSystem.url && (
                     <DropdownMenuItem
                       onClick={() =>
diff --git a/frontend-web/src/core/admin/api.ts b/frontend-web/src/core/admin/api.ts
index 70d99b4a..62f1be45 100644
--- a/frontend-web/src/core/admin/api.ts
+++ b/frontend-web/src/core/admin/api.ts
@@ -247,6 +247,32 @@ export async function getUserLeaderboard(
   );
 }
 
+/**
+ * Force a synchronous rebuild of *today's* leaderboard snapshot so the latest
+ * real-time records are included, then return the leaderboard for `range`.
+ */
+export async function refreshTodayLeaderboard(
+  range: {
+    since: string;
+    until: string;
+    days?: number;
+  },
+  limit = 20,
+): Promise<AdminLeaderboardResponse> {
+  const params = new URLSearchParams({
+    days: String(range.days ?? 30),
+    since: range.since,
+    until: range.until,
+    limit: String(limit),
+  });
+  return parse(
+    await apiFetch(`${base()}/leaderboard/refresh-today?${params}`, {
+      method: "POST",
+    }),
+    "Failed to refresh today's leaderboard",
+  );
+}
+
 export async function getUserAnalytics(
   userId: string,
   range: { since: string; until: string; days?: number },
diff --git a/frontend-web/src/core/admin/hooks.ts b/frontend-web/src/core/admin/hooks.ts
index cf75c366..228dad1c 100644
--- a/frontend-web/src/core/admin/hooks.ts
+++ b/frontend-web/src/core/admin/hooks.ts
@@ -9,6 +9,7 @@ import {
   getUserMemory,
   getUserAnalytics,
   getUserLeaderboard,
+  refreshTodayLeaderboard,
   listUserQa,
   listUserThreadMessages,
   listUserThreads,
@@ -41,6 +42,36 @@ export function useUserLeaderboard(
   });
 }
 
+/**
+ * Force-rebuild today's snapshot, then prime + invalidate the matching
+ * leaderboard query so the page shows the freshly recomputed numbers.
+ */
+export function useRefreshTodayLeaderboard() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({
+      range,
+      limit = 20,
+    }: {
+      range: { since: string; until: string; days?: number };
+      limit?: number;
+    }) => refreshTodayLeaderboard(range, limit),
+    onSuccess: (data, variables) => {
+      qc.setQueryData(
+        [
+          "admin-activity",
+          "leaderboard",
+          variables.range.since,
+          variables.range.until,
+          variables.limit ?? 20,
+        ],
+        data,
+      );
+      qc.invalidateQueries({ queryKey: ["admin-activity", "leaderboard"] });
+    },
+  });
+}
+
 export function useUserAnalytics(
   userId: string | null,
   range: { since: string; until: string; days?: number },
diff --git a/frontend-web/src/core/agents/api.ts b/frontend-web/src/core/agents/api.ts
index 0ec29e98..15224a64 100644
--- a/frontend-web/src/core/agents/api.ts
+++ b/frontend-web/src/core/agents/api.ts
@@ -2,13 +2,13 @@ import { getBackendBaseURL } from "@/core/config";
 import { apiFetch } from "@/core/api";
 
 import type {
-  Agent,
-  AgentSelectorResponse,
-  AgentSort,
-  CreateAgentRequest,
-  PaginatedAgents,
-  UpdateAgentRequest,
-} from "./types";
+  Agent,
+  AgentSelectorResponse,
+  AgentSort,
+  CreateAgentRequest,
+  PaginatedAgents,
+  UpdateAgentRequest,
+} from "./types";
 
 const BACKEND_UNAVAILABLE_STATUSES = new Set([502, 503, 504]);
 
@@ -28,21 +28,24 @@ export interface ListAgentsParams {
   /** Pagination scope. Omit for the legacy combined-visibility list. */
   scope?: "mine" | "square";
   /** 1-based page index. Providing this (or scope) enables server-side pagination. */
-  page?: number;
-  pageSize?: number;
-  sort?: AgentSort;
-}
+  page?: number;
+  pageSize?: number;
+  sort?: AgentSort;
+  /** Keep only agents published by this user id (the card's publisher). */
+  owner?: string;
+}
 
 function buildAgentsQuery(params: ListAgentsParams): string {
   const qs = new URLSearchParams();
   if (params.search) qs.set("search", params.search);
   for (const id of params.tagIds ?? []) qs.append("tag_ids", id);
   if (params.scope) qs.set("scope", params.scope);
-  if (params.page != null) qs.set("page", String(params.page));
-  if (params.pageSize != null) qs.set("page_size", String(params.pageSize));
-  if (params.sort) qs.set("sort", params.sort);
-  return qs.toString();
-}
+  if (params.page != null) qs.set("page", String(params.page));
+  if (params.pageSize != null) qs.set("page_size", String(params.pageSize));
+  if (params.sort) qs.set("sort", params.sort);
+  if (params.owner) qs.set("owner", params.owner);
+  return qs.toString();
+}
 
 export async function listAgents(params: ListAgentsParams = {}): Promise<Agent[]> {
   const query = buildAgentsQuery(params);
@@ -129,13 +132,13 @@ export async function deleteAgent(id: string): Promise<void> {
   if (!res.ok) throw new Error(`Failed to delete agent: ${res.statusText}`);
 }
 
-export async function getAgentSelector(): Promise<AgentSelectorResponse> {
+export async function getAgentSelector(): Promise<AgentSelectorResponse> {
   const res = await apiFetch(`${getBackendBaseURL()}/api/agents/selector`);
   if (!res.ok) throw new Error(`Failed to load agent selector: ${res.statusText}`);
   return res.json() as Promise<AgentSelectorResponse>;
-}
-
-export async function favoriteAgent(id: string): Promise<void> {
+}
+
+export async function favoriteAgent(id: string): Promise<void> {
   const res = await apiFetch(`${getBackendBaseURL()}/api/agents/${id}/favorite`, {
     method: "POST",
   });
@@ -145,35 +148,35 @@ export async function favoriteAgent(id: string): Promise<void> {
   }
 }
 
-export async function unfavoriteAgent(id: string): Promise<void> {
+export async function unfavoriteAgent(id: string): Promise<void> {
   const res = await apiFetch(`${getBackendBaseURL()}/api/agents/${id}/favorite`, {
     method: "DELETE",
   });
   if (!res.ok) {
     const err = (await res.json().catch(() => ({}))) as { detail?: string };
     throw new Error(err.detail ?? `Failed to unfavorite agent: ${res.statusText}`);
-  }
-}
-
-export async function pinAgent(id: string): Promise<void> {
-  const res = await apiFetch(`${getBackendBaseURL()}/api/agents/${id}/pin`, {
-    method: "POST",
-  });
-  if (!res.ok) {
-    const err = (await res.json().catch(() => ({}))) as { detail?: string };
-    throw new Error(err.detail ?? `Failed to pin agent: ${res.statusText}`);
-  }
-}
-
-export async function unpinAgent(id: string): Promise<void> {
-  const res = await apiFetch(`${getBackendBaseURL()}/api/agents/${id}/pin`, {
-    method: "DELETE",
-  });
-  if (!res.ok) {
-    const err = (await res.json().catch(() => ({}))) as { detail?: string };
-    throw new Error(err.detail ?? `Failed to unpin agent: ${res.statusText}`);
-  }
-}
+  }
+}
+
+export async function pinAgent(id: string): Promise<void> {
+  const res = await apiFetch(`${getBackendBaseURL()}/api/agents/${id}/pin`, {
+    method: "POST",
+  });
+  if (!res.ok) {
+    const err = (await res.json().catch(() => ({}))) as { detail?: string };
+    throw new Error(err.detail ?? `Failed to pin agent: ${res.statusText}`);
+  }
+}
+
+export async function unpinAgent(id: string): Promise<void> {
+  const res = await apiFetch(`${getBackendBaseURL()}/api/agents/${id}/pin`, {
+    method: "DELETE",
+  });
+  if (!res.ok) {
+    const err = (await res.json().catch(() => ({}))) as { detail?: string };
+    throw new Error(err.detail ?? `Failed to unpin agent: ${res.statusText}`);
+  }
+}
 
 export async function reorderFeaturedAgents(agentIds: string[]): Promise<void> {
   const res = await apiFetch(
@@ -211,14 +214,16 @@ export async function listPrivateAgents(password: string): Promise<Agent[]> {
   return data.agents;
 }
 
-export interface ListPrivateAgentsParams {
-  password: string;
-  search?: string;
-  tagIds?: string[];
-  page?: number;
-  pageSize?: number;
-  sort?: AgentSort;
-}
+export interface ListPrivateAgentsParams {
+  password: string;
+  search?: string;
+  tagIds?: string[];
+  page?: number;
+  pageSize?: number;
+  sort?: AgentSort;
+  /** Keep only agents published by this user id (the card's publisher). */
+  owner?: string;
+}
 
 /** Paginated private-square listing (password-gated). */
 export async function listPrivateAgentsPaginated(
@@ -232,11 +237,12 @@ export async function listPrivateAgentsPaginated(
       body: JSON.stringify({
         password: params.password,
         search: params.search || undefined,
-        tag_ids: params.tagIds && params.tagIds.length ? params.tagIds : undefined,
-        page: params.page,
-        page_size: params.pageSize,
-        sort: params.sort,
-      }),
+        tag_ids: params.tagIds && params.tagIds.length ? params.tagIds : undefined,
+        page: params.page,
+        page_size: params.pageSize,
+        sort: params.sort,
+        owner: params.owner || undefined,
+      }),
     },
   );
   if (!res.ok) {
diff --git a/frontend-web/src/core/agents/hooks.ts b/frontend-web/src/core/agents/hooks.ts
index b1c6fbed..c0698d87 100644
--- a/frontend-web/src/core/agents/hooks.ts
+++ b/frontend-web/src/core/agents/hooks.ts
@@ -3,34 +3,34 @@ import {
   useMutation,
   useQuery,
   useQueryClient,
-} from "@tanstack/react-query";
-
-import {
+} from "@tanstack/react-query";
+
+import {
   adminSyncAgentSkills,
   createAgent,
   deleteAgent,
   favoriteAgent,
   getAgent,
   getAgentSelector,
-  listAgents,
-  listAgentsPaginated,
-  listAllAgentsAdmin,
-  listPrivateAgents,
-  listPrivateAgentsPaginated,
-  pinAgent,
-  reorderFeaturedAgents,
-  setAgentFeatured,
-  setAgentPrivate,
-  unfavoriteAgent,
-  unpinAgent,
-  updateAgent,
-} from "./api";
-import type {
-  Agent,
-  AgentSort,
-  CreateAgentRequest,
-  PaginatedAgents,
-  UpdateAgentRequest,
+  listAgents,
+  listAgentsPaginated,
+  listAllAgentsAdmin,
+  listPrivateAgents,
+  listPrivateAgentsPaginated,
+  pinAgent,
+  reorderFeaturedAgents,
+  setAgentFeatured,
+  setAgentPrivate,
+  unfavoriteAgent,
+  unpinAgent,
+  updateAgent,
+} from "./api";
+import type {
+  Agent,
+  AgentSort,
+  CreateAgentRequest,
+  PaginatedAgents,
+  UpdateAgentRequest,
 } from "./types";
 
 /** A cached agent listing is either a plain ``Agent[]`` (legacy ``useAgents``)
@@ -79,31 +79,43 @@ export function useAgents(params: { search?: string; tagIds?: string[] } = {}) {
 /** Server-side paginated agent listing for one gallery tab (scope). Returns
  * the page of agents plus the total count for the "共 N 个" header. */
 export function useAgentsPaginated(params: {
-  scope: "mine" | "square";
-  search?: string;
-  tagIds?: string[];
-  sort?: AgentSort;
-  page: number;
-  pageSize: number;
-  enabled?: boolean;
-}) {
-  const { scope, page, pageSize, enabled = true } = params;
-  const search = params.search ?? "";
-  const tagIds = params.tagIds ?? [];
-  const sort = params.sort ?? "time_desc";
-  const { data, isLoading, error } = useQuery({
+  scope: "mine" | "square";
+  search?: string;
+  tagIds?: string[];
+  sort?: AgentSort;
+  page: number;
+  pageSize: number;
+  enabled?: boolean;
+  /** Keep only agents published by this user id (the card's publisher). */
+  owner?: string;
+}) {
+  const { scope, page, pageSize, enabled = true } = params;
+  const search = params.search ?? "";
+  const tagIds = params.tagIds ?? [];
+  const sort = params.sort ?? "time_desc";
+  const owner = params.owner ?? "";
+  const { data, isLoading, isFetching, error } = useQuery({
     queryKey: [
       "agents",
       "paginated",
-      scope,
-      search,
-      [...tagIds].sort(),
-      sort,
-      page,
-      pageSize,
-    ],
-    queryFn: () =>
-      listAgentsPaginated({ scope, search, tagIds, sort, page, pageSize }),
+      scope,
+      search,
+      [...tagIds].sort(),
+      sort,
+      page,
+      pageSize,
+      owner,
+    ],
+    queryFn: () =>
+      listAgentsPaginated({
+        scope,
+        search,
+        tagIds,
+        sort,
+        page,
+        pageSize,
+        owner: owner || undefined,
+      }),
     enabled,
     placeholderData: keepPreviousData,
   });
@@ -111,6 +123,9 @@ export function useAgentsPaginated(params: {
     agents: data?.agents ?? [],
     total: data?.total ?? 0,
     isLoading,
+    // keepPreviousData keeps isLoading false on subsequent searches; expose
+    // isFetching so callers can show a "searching" indicator on every query.
+    isFetching,
     error,
   };
 }
@@ -180,7 +195,7 @@ export function useDeleteAgent() {
 /** Toggle a user's favorite (收藏) on an agent, with an optimistic flip of
  * ``is_favorite`` across every cached agent listing + detail so the star
  * reacts instantly before the round-trip completes. */
-export function useToggleAgentFavorite() {
+export function useToggleAgentFavorite() {
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: ({ id, favorite }: { id: string; favorite: boolean }) =>
@@ -196,30 +211,30 @@ export function useToggleAgentFavorite() {
     onSettled: () => {
       void queryClient.invalidateQueries({ queryKey: ["agents"] });
     },
-  });
-}
-
-export function useToggleAgentPin() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: ({ id, pinned }: { id: string; pinned: boolean }) =>
-      pinned ? pinAgent(id) : unpinAgent(id),
-    onMutate: ({ id, pinned }) => {
-      mapCachedAgents(queryClient, (a) =>
-        a.id === id ? { ...a, is_pinned: pinned } : a,
-      );
-      queryClient.setQueryData<Agent | undefined>(["agents", id], (old) =>
-        old ? { ...old, is_pinned: pinned } : old,
-      );
-    },
-    onSuccess: async () => {
-      await queryClient.invalidateQueries({ queryKey: ["agents"] });
-      await queryClient.refetchQueries({ queryKey: ["agents"], type: "active" });
-    },
-  });
-}
-
-export function useAgentSelector() {
+  });
+}
+
+export function useToggleAgentPin() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, pinned }: { id: string; pinned: boolean }) =>
+      pinned ? pinAgent(id) : unpinAgent(id),
+    onMutate: ({ id, pinned }) => {
+      mapCachedAgents(queryClient, (a) =>
+        a.id === id ? { ...a, is_pinned: pinned } : a,
+      );
+      queryClient.setQueryData<Agent | undefined>(["agents", id], (old) =>
+        old ? { ...old, is_pinned: pinned } : old,
+      );
+    },
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: ["agents"] });
+      await queryClient.refetchQueries({ queryKey: ["agents"], type: "active" });
+    },
+  });
+}
+
+export function useAgentSelector() {
   const { data, isLoading, error } = useQuery({
     queryKey: ["agents", "selector"],
     queryFn: () => getAgentSelector(),
@@ -230,9 +245,9 @@ export function useAgentSelector() {
     isLoading,
     error,
   };
-}
-
-function invalidateAgentQueries(queryClient: ReturnType<typeof useQueryClient>) {
+}
+
+function invalidateAgentQueries(queryClient: ReturnType<typeof useQueryClient>) {
   void queryClient.invalidateQueries({ queryKey: ["agents"] });
 }
 
@@ -277,39 +292,44 @@ export function usePrivateAgents(password: string | null) {
  * password-gated private square plus the total count. */
 export function usePrivateAgentsPaginated(
   password: string | null,
-  params: {
-    search?: string;
-    tagIds?: string[];
-    sort?: AgentSort;
-    page: number;
-    pageSize: number;
-    enabled?: boolean;
-  },
-) {
-  const { page, pageSize, enabled = true } = params;
-  const search = params.search ?? "";
-  const tagIds = params.tagIds ?? [];
-  const sort = params.sort ?? "time_desc";
-  const { data, isLoading, error, refetch } = useQuery({
+  params: {
+    search?: string;
+    tagIds?: string[];
+    sort?: AgentSort;
+    page: number;
+    pageSize: number;
+    enabled?: boolean;
+    /** Keep only agents published by this user id (the card's publisher). */
+    owner?: string;
+  },
+) {
+  const { page, pageSize, enabled = true } = params;
+  const search = params.search ?? "";
+  const tagIds = params.tagIds ?? [];
+  const sort = params.sort ?? "time_desc";
+  const owner = params.owner ?? "";
+  const { data, isLoading, isFetching, error, refetch } = useQuery({
     queryKey: [
       "agents",
       "private-square",
       password ?? "",
-      "paginated",
-      search,
-      [...tagIds].sort(),
-      sort,
-      page,
-      pageSize,
+      "paginated",
+      search,
+      [...tagIds].sort(),
+      sort,
+      page,
+      pageSize,
+      owner,
     ],
     queryFn: () =>
       listPrivateAgentsPaginated({
-        password: password!,
-        search,
-        tagIds,
-        sort,
-        page,
-        pageSize,
+        password: password!,
+        search,
+        tagIds,
+        sort,
+        page,
+        pageSize,
+        owner: owner || undefined,
       }),
     enabled: !!password && enabled,
     staleTime: 30_000,
@@ -320,6 +340,7 @@ export function usePrivateAgentsPaginated(
     agents: data?.agents ?? [],
     total: data?.total ?? 0,
     isLoading,
+    isFetching,
     error,
     refetch,
   };
diff --git a/frontend-web/src/core/agents/types.ts b/frontend-web/src/core/agents/types.ts
index 3919659a..21b4ceb7 100644
--- a/frontend-web/src/core/agents/types.ts
+++ b/frontend-web/src/core/agents/types.ts
@@ -1,10 +1,12 @@
 import type { Tag } from "@/core/tags";
 
-export interface Agent {
+export interface Agent {
   id: string;
   name: string;
   description: string;
   user_id: string | null;
+  /** Publisher username (email local part); null for built-in agents. */
+  owner_username?: string | null;
   published: boolean;
   is_private: boolean;
   builtin: boolean;
@@ -17,15 +19,15 @@ export interface Agent {
   tags?: Tag[];
   featured_order?: number | null;
   /** Whether the current user has favorited (收藏) this agent. */
-  is_favorite?: boolean;
-  is_pinned?: boolean;
-}
-
-export type AgentSort = "time_desc" | "time_asc" | "updated_desc" | "updated_asc" | "name_asc" | "name_desc";
-
-export interface AgentSelectorResponse {
-  agents: Agent[];
-}
+  is_favorite?: boolean;
+  is_pinned?: boolean;
+}
+
+export type AgentSort = "time_desc" | "time_asc" | "updated_desc" | "updated_asc" | "name_asc" | "name_desc";
+
+export interface AgentSelectorResponse {
+  agents: Agent[];
+}
 
 /** Pagination envelope returned by the server-side paginated agent listings. */
 export interface PaginatedAgents {
diff --git a/frontend-web/src/core/i18n/locales/en-US.ts b/frontend-web/src/core/i18n/locales/en-US.ts
index 01520e16..943dbcd5 100644
--- a/frontend-web/src/core/i18n/locales/en-US.ts
+++ b/frontend-web/src/core/i18n/locales/en-US.ts
@@ -25,6 +25,10 @@ export const enUS: Translations = {
     edit: "Edit",
     rename: "Rename",
     share: "Share",
+    pin: "Pin",
+    unpin: "Unpin",
+    favorite: "Favorite",
+    unfavorite: "Unfavorite",
     openInNewWindow: "Open in new window",
     close: "Close",
     more: "More",
@@ -255,6 +259,14 @@ export const enUS: Translations = {
   // Chats
   chats: {
     searchChats: "Search chats",
+    pinnedSection: "Pinned",
+    allChats: "All",
+    favorites: "Favorites",
+    onlyFavorites: "Favorites only",
+    prevPage: "Previous",
+    nextPage: "Next",
+    noChats: "No conversations yet",
+    noFavorites: "No favorited conversations yet",
   },
 
   // Conversation sharing
@@ -586,6 +598,14 @@ export const enUS: Translations = {
         targetCategoryLabel: "Install to",
         categoryCustom: "Custom skill",
         categoryPublic: "Built-in (admin)",
+        nameZhStepTitle: "Set Chinese name",
+        nameZhStepHint:
+          "Skill '{name}' is installed. You can give it a Chinese display name, or let the model generate a default one (leave blank to use the English name).",
+        nameZhPlaceholder: "Enter a Chinese name (optional)",
+        nameZhGenerate: "AI generate",
+        nameZhSkip: "Skip",
+        nameZhGenerated: "Chinese name generated",
+        nameZhSaved: "Chinese name saved",
       },
     },
     skillEvolution: {
diff --git a/frontend-web/src/core/i18n/locales/types.ts b/frontend-web/src/core/i18n/locales/types.ts
index c3c374a3..4e0e4b65 100644
--- a/frontend-web/src/core/i18n/locales/types.ts
+++ b/frontend-web/src/core/i18n/locales/types.ts
@@ -26,6 +26,10 @@ export interface Translations {
     edit: string;
     rename: string;
     share: string;
+    pin: string;
+    unpin: string;
+    favorite: string;
+    unfavorite: string;
     openInNewWindow: string;
     close: string;
     more: string;
@@ -198,6 +202,14 @@ export interface Translations {
   // Chats
   chats: {
     searchChats: string;
+    pinnedSection: string;
+    allChats: string;
+    favorites: string;
+    onlyFavorites: string;
+    prevPage: string;
+    nextPage: string;
+    noChats: string;
+    noFavorites: string;
   };
 
   // Conversation sharing
@@ -511,6 +523,13 @@ export interface Translations {
         targetCategoryLabel: string;
         categoryCustom: string;
         categoryPublic: string;
+        nameZhStepTitle: string;
+        nameZhStepHint: string;
+        nameZhPlaceholder: string;
+        nameZhGenerate: string;
+        nameZhSkip: string;
+        nameZhGenerated: string;
+        nameZhSaved: string;
       };
     };
     skillEvolution: {
diff --git a/frontend-web/src/core/i18n/locales/zh-CN.ts b/frontend-web/src/core/i18n/locales/zh-CN.ts
index 50ecf6fe..9c1215c1 100644
--- a/frontend-web/src/core/i18n/locales/zh-CN.ts
+++ b/frontend-web/src/core/i18n/locales/zh-CN.ts
@@ -25,6 +25,10 @@ export const zhCN: Translations = {
     edit: "编辑",
     rename: "重命名",
     share: "分享",
+    pin: "置顶",
+    unpin: "取消置顶",
+    favorite: "收藏",
+    unfavorite: "取消收藏",
     openInNewWindow: "在新窗口打开",
     close: "关闭",
     more: "更多",
@@ -242,6 +246,14 @@ export const zhCN: Translations = {
   // Chats
   chats: {
     searchChats: "搜索对话",
+    pinnedSection: "置顶",
+    allChats: "全部",
+    favorites: "收藏",
+    onlyFavorites: "只看收藏",
+    prevPage: "上一页",
+    nextPage: "下一页",
+    noChats: "暂无对话",
+    noFavorites: "暂无收藏的对话",
   },
 
   // Conversation sharing
@@ -559,6 +571,14 @@ export const zhCN: Translations = {
         targetCategoryLabel: `安装到`,
         categoryCustom: `自定义技能`,
         categoryPublic: `内置技能（管理员）`,
+        nameZhStepTitle: "设置中文名",
+        nameZhStepHint:
+          "技能 “{name}” 已安装。你可以为它填写一个中文名，或让大模型自动生成一个默认中文名（留空则使用英文名）。",
+        nameZhPlaceholder: "请输入中文名（可留空）",
+        nameZhGenerate: "AI 生成",
+        nameZhSkip: "跳过",
+        nameZhGenerated: "已生成中文名称",
+        nameZhSaved: "已保存中文名",
       },
     },
     skillEvolution: {
diff --git a/frontend-web/src/core/knowledge/api.ts b/frontend-web/src/core/knowledge/api.ts
new file mode 100644
index 00000000..bc4ce250
--- /dev/null
+++ b/frontend-web/src/core/knowledge/api.ts
@@ -0,0 +1,226 @@
+import { apiFetch } from "@/core/api";
+import { getBackendBaseURL } from "@/core/config";
+
+import type {
+  BatchIngestPayload,
+  BatchIngestResult,
+  GraphExportResult,
+  IngestThreadPayload,
+  KnowledgeListParams,
+  KnowledgeListResponse,
+  KnowledgeNote,
+  KnowledgeSearchItem,
+  VaultPage,
+  WikilinkResolutionMap,
+} from "./types";
+
+const baseUrl = () => `${getBackendBaseURL()}/api/knowledge`;
+
+async function parseResponse<T>(response: Response): Promise<T> {
+  if (!response.ok) {
+    const error = await response
+      .json()
+      .catch(() => ({ detail: "Request failed" }));
+    const detail = error.detail;
+    if (typeof detail === "string") throw new Error(detail);
+    throw new Error("请求失败");
+  }
+  return response.json() as Promise<T>;
+}
+
+export async function listKnowledgeNotes(params: KnowledgeListParams = {}) {
+  const qs = new URLSearchParams();
+  if (params.keyword) qs.set("keyword", params.keyword);
+  if (params.tag) qs.set("tag", params.tag);
+  if (params.source_type) qs.set("source_type", params.source_type);
+  if (params.status) qs.set("status", params.status);
+  qs.set("limit", String(params.limit ?? 20));
+  qs.set("offset", String(params.offset ?? 0));
+  return parseResponse<KnowledgeListResponse>(
+    await apiFetch(`${baseUrl()}/notes?${qs.toString()}`),
+  );
+}
+
+export async function getKnowledgeNote(noteId: string) {
+  return parseResponse<KnowledgeNote>(
+    await apiFetch(`${baseUrl()}/notes/${encodeURIComponent(noteId)}`),
+  );
+}
+
+export async function createKnowledgeNote(data: {
+  title: string;
+  content_md: string;
+  summary?: string | null;
+  tags?: string[];
+  status?: string;
+}) {
+  const res = await parseResponse<{ note: KnowledgeNote }>(
+    await apiFetch(`${baseUrl()}/notes`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data),
+    }),
+  );
+  return res.note;
+}
+
+export async function updateKnowledgeNote(
+  noteId: string,
+  data: Partial<{
+    title: string;
+    content_md: string;
+    summary: string | null;
+    tags: string[];
+    status: string;
+  }>,
+) {
+  return parseResponse<KnowledgeNote>(
+    await apiFetch(`${baseUrl()}/notes/${encodeURIComponent(noteId)}`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data),
+    }),
+  );
+}
+
+export async function deleteKnowledgeNote(noteId: string, hard = false) {
+  return parseResponse<{ ok: boolean; note_id: string }>(
+    await apiFetch(
+      `${baseUrl()}/notes/${encodeURIComponent(noteId)}${hard ? "?hard=true" : ""}`,
+      { method: "DELETE" },
+    ),
+  );
+}
+
+export async function searchKnowledge(query: string, limit = 8) {
+  const res = await parseResponse<{ items: KnowledgeSearchItem[] }>(
+    await apiFetch(`${baseUrl()}/search`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ query, mode: "keyword", limit }),
+    }),
+  );
+  return res.items;
+}
+
+export async function ingestThread(threadId: string, payload: IngestThreadPayload = {}) {
+  return parseResponse<{
+    note?: KnowledgeNote;
+    created?: boolean;
+    queued?: boolean;
+  }>(
+    await apiFetch(`${baseUrl()}/ingest/thread/${encodeURIComponent(threadId)}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    }),
+  );
+}
+
+export async function ingestThreadsBatch(payload: BatchIngestPayload = {}) {
+  return parseResponse<BatchIngestResult>(
+    await apiFetch(`${baseUrl()}/ingest/threads/batch`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    }),
+  );
+}
+
+/** Resolve `[[wikilink]]` targets to note ids / vault pages. */
+export async function resolveWikilinks(targets: string[]) {
+  const res = await parseResponse<{ resolved: WikilinkResolutionMap }>(
+    await apiFetch(`${baseUrl()}/resolve`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ targets }),
+    }),
+  );
+  return res.resolved;
+}
+
+/** Resolve every `[[wikilink]]` inside a note's body in one call. */
+export async function resolveNoteWikilinks(noteId: string) {
+  const res = await parseResponse<{ resolved: WikilinkResolutionMap }>(
+    await apiFetch(
+      `${baseUrl()}/notes/${encodeURIComponent(noteId)}/wikilinks`,
+    ),
+  );
+  return res.resolved;
+}
+
+/** Fetch a raw vault meta/hub Markdown page (no DB note) by its path. */
+export async function fetchVaultPage(path: string) {
+  return parseResponse<VaultPage>(
+    await apiFetch(`${baseUrl()}/vault-page?path=${encodeURIComponent(path)}`),
+  );
+}
+
+export async function exportKnowledgeGraph() {
+  return parseResponse<GraphExportResult>(
+    await apiFetch(`${baseUrl()}/export/graph`, { method: "POST" }),
+  );
+}
+
+/** Absolute URL of a served wiki-export file (for iframe / download). */
+export function knowledgeExportFileUrl(filename: string) {
+  return `${baseUrl()}/export/files/${encodeURIComponent(filename)}`;
+}
+
+// --- phase 2/3/4 ---
+
+export interface KnowledgeVersion {
+  id: string;
+  note_id: string;
+  title: string;
+  summary?: string | null;
+  content_md: string;
+  status: string;
+  tags: string[];
+  edited_by?: string | null;
+  created_at?: string | null;
+}
+
+export async function listNoteVersions(noteId: string) {
+  const res = await parseResponse<{ items: KnowledgeVersion[] }>(
+    await apiFetch(`${baseUrl()}/notes/${encodeURIComponent(noteId)}/versions`),
+  );
+  return res.items;
+}
+
+export interface DuplicateGroup {
+  primary: { id: string; title: string | null };
+  duplicates: Array<{ id: string; title: string | null; score: number }>;
+}
+
+export async function listDuplicates() {
+  const res = await parseResponse<{ groups: DuplicateGroup[] }>(
+    await apiFetch(`${baseUrl()}/duplicates`),
+  );
+  return res.groups;
+}
+
+export async function mergeKnowledgeNotes(primaryId: string, duplicateIds: string[]) {
+  return parseResponse<{ note: KnowledgeNote }>(
+    await apiFetch(`${baseUrl()}/merge`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ primary_id: primaryId, duplicate_ids: duplicateIds }),
+    }),
+  );
+}
+
+export async function reindexKnowledge() {
+  return parseResponse<{ reindexed: number; embedding_enabled: number }>(
+    await apiFetch(`${baseUrl()}/reindex`, { method: "POST" }),
+  );
+}
+
+export interface KnowledgeGraph {
+  nodes: Array<{ id: string; type: string; label: string; category?: string | null }>;
+  edges: Array<{ id: string; source: string; target: string; label: string; weight: number }>;
+}
+
+export async function getKnowledgeGraph() {
+  return parseResponse<KnowledgeGraph>(await apiFetch(`${baseUrl()}/graph`));
+}
diff --git a/frontend-web/src/core/knowledge/hooks.ts b/frontend-web/src/core/knowledge/hooks.ts
new file mode 100644
index 00000000..b3a9b9fb
--- /dev/null
+++ b/frontend-web/src/core/knowledge/hooks.ts
@@ -0,0 +1,125 @@
+import {
+  keepPreviousData,
+  useMutation,
+  useQuery,
+  useQueryClient,
+} from "@tanstack/react-query";
+
+import {
+  createKnowledgeNote,
+  deleteKnowledgeNote,
+  exportKnowledgeGraph,
+  fetchVaultPage,
+  getKnowledgeNote,
+  ingestThread,
+  ingestThreadsBatch,
+  listDuplicates,
+  listKnowledgeNotes,
+  mergeKnowledgeNotes,
+  resolveNoteWikilinks,
+  searchKnowledge,
+  updateKnowledgeNote,
+} from "./api";
+import type { KnowledgeListParams } from "./types";
+
+const ROOT_KEY = ["knowledge"] as const;
+
+export function useKnowledgeNotes(params: KnowledgeListParams = {}) {
+  return useQuery({
+    queryKey: [...ROOT_KEY, "list", params],
+    queryFn: () => listKnowledgeNotes(params),
+    placeholderData: keepPreviousData,
+    refetchOnWindowFocus: false,
+  });
+}
+
+export function useKnowledgeNote(noteId: string | undefined) {
+  return useQuery({
+    queryKey: [...ROOT_KEY, "note", noteId],
+    queryFn: () => getKnowledgeNote(noteId as string),
+    enabled: !!noteId,
+    refetchOnWindowFocus: false,
+  });
+}
+
+export function useNoteWikilinks(noteId: string | undefined) {
+  return useQuery({
+    queryKey: [...ROOT_KEY, "wikilinks", noteId],
+    queryFn: () => resolveNoteWikilinks(noteId as string),
+    enabled: !!noteId,
+    refetchOnWindowFocus: false,
+  });
+}
+
+export function useVaultPage(path: string | undefined) {
+  return useQuery({
+    queryKey: [...ROOT_KEY, "vault-page", path],
+    queryFn: () => fetchVaultPage(path as string),
+    enabled: !!path,
+    refetchOnWindowFocus: false,
+  });
+}
+
+export function useKnowledgeSearch(query: string, enabled: boolean) {
+  return useQuery({
+    queryKey: [...ROOT_KEY, "search", query],
+    queryFn: () => searchKnowledge(query),
+    enabled: enabled && query.trim().length > 0,
+    placeholderData: keepPreviousData,
+    refetchOnWindowFocus: false,
+  });
+}
+
+export function useKnowledgeActions() {
+  const queryClient = useQueryClient();
+  const invalidate = () =>
+    queryClient.invalidateQueries({ queryKey: ROOT_KEY });
+
+  return {
+    create: useMutation({ mutationFn: createKnowledgeNote, onSuccess: invalidate }),
+    update: useMutation({
+      mutationFn: ({
+        noteId,
+        data,
+      }: {
+        noteId: string;
+        data: Parameters<typeof updateKnowledgeNote>[1];
+      }) => updateKnowledgeNote(noteId, data),
+      onSuccess: invalidate,
+    }),
+    remove: useMutation({
+      mutationFn: ({ noteId, hard }: { noteId: string; hard?: boolean }) =>
+        deleteKnowledgeNote(noteId, hard),
+      onSuccess: invalidate,
+    }),
+    ingestThread: useMutation({
+      mutationFn: ({
+        threadId,
+        payload,
+      }: {
+        threadId: string;
+        payload?: Parameters<typeof ingestThread>[1];
+      }) => ingestThread(threadId, payload),
+      onSuccess: invalidate,
+    }),
+    batchIngest: useMutation({
+      mutationFn: ingestThreadsBatch,
+      onSuccess: invalidate,
+    }),
+    exportGraph: useMutation({ mutationFn: exportKnowledgeGraph }),
+    merge: useMutation({
+      mutationFn: ({ primaryId, duplicateIds }: { primaryId: string; duplicateIds: string[] }) =>
+        mergeKnowledgeNotes(primaryId, duplicateIds),
+      onSuccess: invalidate,
+    }),
+  };
+}
+
+export function useKnowledgeDuplicates(enabled: boolean) {
+  return useQuery({
+    queryKey: [...ROOT_KEY, "duplicates"],
+    queryFn: listDuplicates,
+    enabled,
+    refetchOnWindowFocus: false,
+  });
+}
diff --git a/frontend-web/src/core/knowledge/types.ts b/frontend-web/src/core/knowledge/types.ts
new file mode 100644
index 00000000..676b7ab2
--- /dev/null
+++ b/frontend-web/src/core/knowledge/types.ts
@@ -0,0 +1,144 @@
+export type KnowledgeStatus = "draft" | "approved" | "archived";
+export type KnowledgeSourceType =
+  | "thread"
+  | "search"
+  | "tool"
+  | "file"
+  | "manual"
+  | "report";
+
+export interface KnowledgeSource {
+  id: string;
+  note_id: string;
+  source_type: string;
+  thread_id?: string | null;
+  message_id?: string | null;
+  tool_name?: string | null;
+  title?: string | null;
+  url?: string | null;
+  snippet?: string | null;
+  created_at?: string | null;
+}
+
+export interface KnowledgeEntity {
+  name: string;
+  entity_type?: string | null;
+}
+
+export interface KnowledgeNote {
+  id: string;
+  title: string;
+  summary?: string | null;
+  content_md: string;
+  vault_path?: string | null;
+  source_type: string;
+  source_id?: string | null;
+  status: KnowledgeStatus;
+  confidence?: number;
+  created_by?: string | null;
+  updated_by?: string | null;
+  created_by_name?: string | null;
+  updated_by_name?: string | null;
+  created_at?: string | null;
+  updated_at?: string | null;
+  tags: string[];
+  entities?: KnowledgeEntity[];
+  sources?: KnowledgeSource[];
+}
+
+export interface KnowledgeListResponse {
+  items: KnowledgeNote[];
+  total: number;
+}
+
+export interface KnowledgeListParams {
+  keyword?: string;
+  tag?: string;
+  source_type?: string;
+  status?: string;
+  limit?: number;
+  offset?: number;
+}
+
+export type WikilinkKind = "note" | "vault" | "missing";
+
+export interface WikilinkResolution {
+  target: string;
+  normalized?: string;
+  kind: WikilinkKind;
+  exists: boolean;
+  note_id?: string;
+  vault_path?: string;
+  title?: string;
+}
+
+/** Map of original `[[target]]` string → its resolution. */
+export type WikilinkResolutionMap = Record<string, WikilinkResolution>;
+
+export interface VaultPage {
+  path: string;
+  title: string;
+  content_md: string;
+}
+
+export interface KnowledgeSearchItem {
+  note_id: string;
+  chunk_id?: string | null;
+  title?: string | null;
+  summary?: string | null;
+  snippet?: string | null;
+  score: number;
+  tags: string[];
+  source_type?: string | null;
+  updated_at?: string | null;
+}
+
+export interface IngestThreadPayload {
+  mode?: "summary" | "full";
+  title?: string | null;
+  status?: KnowledgeStatus;
+  tags?: string[];
+  include_sources?: boolean;
+  /** When true the backend sediments asynchronously and returns immediately. */
+  background?: boolean;
+  /** Optional model override for knowledge extraction (null = configured default). */
+  model_name?: string | null;
+}
+
+export interface BatchIngestPayload {
+  limit?: number;
+  offset?: number;
+  status?: KnowledgeStatus;
+  include_sources?: boolean;
+  skip_existing?: boolean;
+  mode?: "summary" | "full";
+  /** Optional model override for knowledge extraction (null = configured default). */
+  model_name?: string | null;
+}
+
+export interface BatchIngestResult {
+  ok: boolean;
+  processed: number;
+  created: number;
+  skipped: number;
+  failed: number;
+  /** Notes that fell back to rule-based extraction because the model failed. */
+  llm_fallback?: number;
+  items: Array<{
+    thread_id: string;
+    note_id: string | null;
+    status: string;
+    llm_fallback?: boolean;
+  }>;
+}
+
+export interface GraphExportResult {
+  ok: boolean;
+  files: {
+    graph_json: string;
+    graph_html: string;
+    graph_graphml: string;
+    cypher: string;
+  };
+  stats: { nodes: number; edges: number };
+}
diff --git a/frontend-web/src/core/page-layout/sidebar-menu.ts b/frontend-web/src/core/page-layout/sidebar-menu.ts
index b959d0b2..d2133107 100644
--- a/frontend-web/src/core/page-layout/sidebar-menu.ts
+++ b/frontend-web/src/core/page-layout/sidebar-menu.ts
@@ -9,6 +9,7 @@
  */
 import type { ElementType } from "react";
 import {
+  BookOpen,
   Bot,
   Brain,
   CalendarClock,
@@ -21,20 +22,20 @@ import {
   Grid3X3,
   HelpCircle,
   History,
+  Layers,
   Layout,
   Library,
   List,
   ListChecks,
   ListTodo,
   MessageSquareCode,
-  MessageSquarePlus,
   Network,
   NotebookPen,
   Plus,
   Settings,
-  ShieldCheck,
   Sparkles,
   Target,
+  Trophy,
   Users,
 } from "lucide-react";
 
@@ -61,8 +62,13 @@ export const sidebarMenuItems: MenuItem[] = [
         path: "/page/strategy/qa/multi-agent-roundtable",
       },
       // { id: "expert-qa", label: "专家问答", icon: Brain, path: "/page/strategy/qa/expert-qa" },
-      { id: "qa-zzjc", label: "zzjc支持", icon: Bot },
-      { id: "qa-zzxd", label: "zzXD应用", icon: Layout },
+      {
+        id: "qa-zzjc",
+        label: "zzjc支持",
+        icon: Bot,
+        path: "/page/strategy/agents/6bf/chats/new",
+      },
+      { id: "qa-zzxd", label: "zzXD应用", icon: Layout, path: "/page/strategy/agents/10d69686718349688e58a8790cb61024/chats/new", },
       { id: "qa-research", label: "课题研究", icon: FileText, path: "/page/canvas/ai-writing" },
     ],
   },
@@ -209,10 +215,16 @@ export const sidebarMenuItems: MenuItem[] = [
       { id: "mgmt-agents", label: "智能体管理", icon: Bot, path: "/page/strategy/agents" },
       {
         id: "mgmt-business-chain-mapping",
-        label: "业务链条管理",
+        label: "配置管理",
         icon: Network,
         path: "/page/strategy/business-chain-mapping",
       },
+      {
+        id: "mgmt-business-chains",
+        label: "业务链条配置",
+        icon: Layers,
+        path: "/page/strategy/business-chains",
+      },
       { id: "mgmt-skills", label: "技能管理", icon: Sparkles, path: "/page/strategy/skills" },
       { id: "mgmt-memory", label: "记忆管理", icon: Brain, path: "/page/strategy/memory" },
       {
@@ -221,27 +233,6 @@ export const sidebarMenuItems: MenuItem[] = [
         icon: ListChecks,
         path: "/page/strategy/scheduled/tasks",
       },
-      {
-        id: "mgmt-recommended-questions",
-        label: "推荐问题配置",
-        icon: MessageSquarePlus,
-        path: "/page/strategy/settings/recommended-questions",
-        adminOnly: true,
-      },
-      {
-        id: "mgmt-prompt-prefix",
-        label: "问答前缀配置",
-        icon: MessageSquareCode,
-        path: "/page/strategy/settings/prompt-prefix",
-        adminOnly: true,
-      },
-      {
-        id: "mgmt-private-square",
-        label: "私密广场配置",
-        icon: ShieldCheck,
-        path: "/page/strategy/settings/private-square",
-        adminOnly: true,
-      },
       {
         id: "mgmt-llm-metrics",
         label: "大模型调用统计",
@@ -256,6 +247,13 @@ export const sidebarMenuItems: MenuItem[] = [
         path: "/page/strategy/admin/users",
         adminOnly: true,
       },
+      {
+        id: "mgmt-user-leaderboard",
+        label: "用户排行榜",
+        icon: Trophy,
+        path: "/page/strategy/admin/user-leaderboard",
+        adminOnly: true,
+      },
       {
         id: "mgmt-admin-scheduled-tasks",
         label: "定时任务管理",
@@ -283,6 +281,12 @@ export const sidebarMenuItems: MenuItem[] = [
         icon: Network,
         path: "/page/strategy/resource-management/resource-network-actor",
       },
+      {
+        id: "resource-knowledge-native",
+        label: "知识库",
+        icon: BookOpen,
+        path: "/page/workspace/knowledge",
+      },
       {
         id: "resource-knowledge-base",
         label: "知识库资源管理",
@@ -306,6 +310,7 @@ export const defaultExpandedIds: ReadonlySet<string> = new Set([
   "light-app-note-management",
   "task-management",
   "xk-center-task",
+  "comprehensive-management",
 ]);
 
 /** 按 admin 角色过滤菜单：非 admin 不展示 ``adminOnly: true`` 的项及其子项 */
diff --git a/frontend-web/src/core/skills/api.ts b/frontend-web/src/core/skills/api.ts
index 351be813..d3a44bac 100644
--- a/frontend-web/src/core/skills/api.ts
+++ b/frontend-web/src/core/skills/api.ts
@@ -430,6 +430,78 @@ export async function saveSkillFile(
   return response.json() as Promise<SkillFileSaveResponse>;
 }
 
+export interface SkillNameZhResponse {
+  name: string;
+  name_zh: string | null;
+}
+
+export interface GenerateMissingSkillNameZhResponse {
+  generated: SkillNameZhResponse[];
+  failed: string[];
+  skipped: number;
+  /** Representative model error when some skills failed due to the LLM. */
+  model_error?: string | null;
+}
+
+/**
+ * Set a skill's Chinese display name. An empty string clears it (falls back to
+ * the English name).
+ */
+export async function setSkillNameZh(
+  skillName: string,
+  nameZh: string,
+): Promise<SkillNameZhResponse> {
+  const response = await apiFetch(
+    `${getBackendBaseURL()}/api/skills/${encodeURIComponent(skillName)}/name-zh`,
+    {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name_zh: nameZh }),
+    },
+  );
+  if (!response.ok) {
+    throw await parseDetailedError(response, "Failed to set skill Chinese name");
+  }
+  return response.json() as Promise<SkillNameZhResponse>;
+}
+
+/** Ask the LLM to generate and persist a Chinese name for a single skill. */
+export async function generateSkillNameZh(
+  skillName: string,
+  modelName?: string | null,
+): Promise<SkillNameZhResponse> {
+  const response = await apiFetch(
+    `${getBackendBaseURL()}/api/skills/${encodeURIComponent(skillName)}/name-zh/generate`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model_name: modelName ?? null }),
+    },
+  );
+  if (!response.ok) {
+    throw await parseDetailedError(response, "Failed to generate skill Chinese name");
+  }
+  return response.json() as Promise<SkillNameZhResponse>;
+}
+
+/** One-click (admin): generate Chinese names for every skill that lacks one. */
+export async function generateMissingSkillNameZh(
+  modelName?: string | null,
+): Promise<GenerateMissingSkillNameZhResponse> {
+  const response = await apiFetch(
+    `${getBackendBaseURL()}/api/skills/name-zh/generate-missing`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model_name: modelName ?? null }),
+    },
+  );
+  if (!response.ok) {
+    throw await parseDetailedError(response, "Failed to bulk-generate skill Chinese names");
+  }
+  return response.json() as Promise<GenerateMissingSkillNameZhResponse>;
+}
+
 export interface SetSkillDetailResponse {
   name: string;
   detail: string | null;
diff --git a/frontend-web/src/core/skills/hooks.ts b/frontend-web/src/core/skills/hooks.ts
index 676f12e4..a552d1de 100644
--- a/frontend-web/src/core/skills/hooks.ts
+++ b/frontend-web/src/core/skills/hooks.ts
@@ -9,6 +9,8 @@ import {
   deleteCustomSkill,
   duplicateSkill,
   enableSkill,
+  generateMissingSkillNameZh,
+  generateSkillNameZh,
   getSkill,
   getSkillContent,
   getSkillFileContent,
@@ -17,6 +19,7 @@ import {
   reconcileCustomSkills,
   saveSkillFile,
   setSkillDetail,
+  setSkillNameZh,
   setSkillDisplay,
   setSkillPinned,
   setSkillFeatured,
@@ -90,6 +93,40 @@ export function useSetSkillDetail() {
   });
 }
 
+export function useSetSkillNameZh() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ skillName, nameZh }: { skillName: string; nameZh: string }) =>
+      setSkillNameZh(skillName, nameZh),
+    onSuccess: (_data, { skillName }) => {
+      void queryClient.invalidateQueries({ queryKey: ["skills"] });
+      void queryClient.invalidateQueries({ queryKey: ["skill", skillName] });
+    },
+  });
+}
+
+export function useGenerateSkillNameZh() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ skillName, modelName }: { skillName: string; modelName?: string | null }) =>
+      generateSkillNameZh(skillName, modelName),
+    onSuccess: (_data, { skillName }) => {
+      void queryClient.invalidateQueries({ queryKey: ["skills"] });
+      void queryClient.invalidateQueries({ queryKey: ["skill", skillName] });
+    },
+  });
+}
+
+export function useGenerateMissingSkillNameZh() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (modelName?: string | null) => generateMissingSkillNameZh(modelName),
+    onSuccess: () => {
+      void queryClient.invalidateQueries({ queryKey: ["skills"] });
+    },
+  });
+}
+
 export function useSetSkillDisplay() {
   const queryClient = useQueryClient();
   return useMutation({
diff --git a/frontend-web/src/core/skills/type.ts b/frontend-web/src/core/skills/type.ts
index 7a13322c..f30984fe 100644
--- a/frontend-web/src/core/skills/type.ts
+++ b/frontend-web/src/core/skills/type.ts
@@ -42,6 +42,8 @@ export interface SkillDisplayConfig extends Omit<SkillDisplayResultSetConfig, "k
 
 export interface Skill {
   name: string;
+  // 用户配置或大模型生成的中文名称;为空时界面回退到使用英文 name。
+  name_zh?: string | null;
   description: string;
   category: string;
   license: string;
@@ -49,6 +51,9 @@ export interface Skill {
   // Multitenancy fields — owner_user_id is null for built-in / public skills.
   // ``builtin`` mirrors that nullness for explicit branching on the UI side.
   owner_user_id?: string | null;
+  // Publisher username (email local part) resolved from owner_user_id by the
+  // backend. Null for built-in / public skills with no human owner.
+  owner_username?: string | null;
   published?: boolean;
   builtin?: boolean;
   // Long-form detail/introduction authored by the skill owner or an admin.
diff --git a/frontend-web/src/core/threads/hooks.ts b/frontend-web/src/core/threads/hooks.ts
index 983bbf3b..6a021e46 100644
--- a/frontend-web/src/core/threads/hooks.ts
+++ b/frontend-web/src/core/threads/hooks.ts
@@ -621,15 +621,15 @@ export function useThreadStream({
           lockThreadRagMode(threadId);
         }
 
-        const mergedContext = {
-          ...context,
-          ...extraContext,
-        };
-
-        await thread.submit(
-          {
-            messages: [
-              {
+        const mergedContext = {
+          ...context,
+          ...extraContext,
+        };
+
+        await thread.submit(
+          {
+            messages: [
+              {
                 type: "human",
                 content: [
                   {
@@ -647,33 +647,33 @@ export function useThreadStream({
               },
             ],
           },
-          {
-            threadId: threadId,
-            streamSubgraphs: true,
-            streamResumable: true,
-            config: {
-              recursion_limit: 1000,
-            },
-            context: {
-              ...mergedContext,
-              thinking_enabled: mergedContext.mode !== "flash",
-              is_plan_mode:
-                mergedContext.mode === "pro" || mergedContext.mode === "ultra",
-              subagent_enabled: mergedContext.mode === "ultra",
-              reasoning_effort:
-                mergedContext.reasoning_effort ??
-                (mergedContext.mode === "ultra"
-                  ? "high"
-                  : mergedContext.mode === "pro"
-                    ? "medium"
-                    : mergedContext.mode === "thinking"
-                      ? "low"
-                      : undefined),
-              memory_injection_enabled:
-                mergedContext.memory_injection_enabled ?? true,
-              rag_mode_enabled: ragModeEnabled,
-              thread_id: threadId,
-            },
+          {
+            threadId: threadId,
+            streamSubgraphs: true,
+            streamResumable: true,
+            config: {
+              recursion_limit: 1000,
+            },
+            context: {
+              ...mergedContext,
+              thinking_enabled: mergedContext.mode !== "flash",
+              is_plan_mode:
+                mergedContext.mode === "pro" || mergedContext.mode === "ultra",
+              subagent_enabled: mergedContext.mode === "ultra",
+              reasoning_effort:
+                mergedContext.reasoning_effort ??
+                (mergedContext.mode === "ultra"
+                  ? "high"
+                  : mergedContext.mode === "pro"
+                    ? "medium"
+                    : mergedContext.mode === "thinking"
+                      ? "low"
+                      : undefined),
+              memory_injection_enabled:
+                mergedContext.memory_injection_enabled ?? true,
+              rag_mode_enabled: ragModeEnabled,
+              thread_id: threadId,
+            },
           },
         );
         void queryClient.invalidateQueries({ queryKey: ["threads", "search"] });
@@ -853,6 +853,86 @@ export function useDeleteMessage() {
   });
 }
 
+/**
+ * Merge metadata into a conversation's record via the Gateway
+ * `PATCH /api/threads/{id}` route. Used to persist per-conversation flags such
+ * as `is_pinned` (置顶) and `is_favorite` (收藏) — a conversation belongs to a
+ * single user, so these live directly on the thread metadata (no join table).
+ * Updates the `["threads", "search"]` cache optimistically so the UI reflects
+ * the toggle immediately, mirroring `useRenameThread`.
+ */
+export function useUpdateThreadMetadata() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({
+      threadId,
+      metadata,
+    }: {
+      threadId: string;
+      metadata: Record<string, unknown>;
+    }) => {
+      const response = await apiFetch(
+        `${getBackendBaseURL()}/api/threads/${encodeURIComponent(threadId)}`,
+        {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ metadata }),
+        },
+      );
+      if (!response.ok) {
+        const error = await response
+          .json()
+          .catch(() => ({ detail: "更新对话失败。" }));
+        throw new Error(error.detail ?? "更新对话失败。");
+      }
+    },
+    onSuccess(_, { threadId, metadata }) {
+      queryClient.setQueriesData(
+        {
+          queryKey: ["threads", "search"],
+          exact: false,
+        },
+        (oldData: Array<AgentThread> | undefined) => {
+          if (oldData == null) {
+            return oldData;
+          }
+          return oldData.map((t) =>
+            t.thread_id === threadId
+              ? {
+                  ...t,
+                  metadata: {
+                    ...(t.metadata as Record<string, unknown> | null),
+                    ...metadata,
+                  },
+                }
+              : t,
+          );
+        },
+      );
+    },
+  });
+}
+
+/** Toggle a conversation's pinned (置顶) flag. */
+export function useToggleThreadPin() {
+  const { mutate, ...rest } = useUpdateThreadMetadata();
+  return {
+    ...rest,
+    toggle: (threadId: string, pinned: boolean) =>
+      mutate({ threadId, metadata: { is_pinned: pinned } }),
+  };
+}
+
+/** Toggle a conversation's favorite (收藏) flag. */
+export function useToggleThreadFavorite() {
+  const { mutate, ...rest } = useUpdateThreadMetadata();
+  return {
+    ...rest,
+    toggle: (threadId: string, favorite: boolean) =>
+      mutate({ threadId, metadata: { is_favorite: favorite } }),
+  };
+}
+
 export function useRenameThread() {
   const queryClient = useQueryClient();
   const apiClient = getAPIClient();
diff --git a/frontend-web/src/core/threads/types.ts b/frontend-web/src/core/threads/types.ts
index 57a566a6..475269a7 100644
--- a/frontend-web/src/core/threads/types.ts
+++ b/frontend-web/src/core/threads/types.ts
@@ -18,9 +18,11 @@ export interface AgentThreadContext extends Record<string, unknown> {
   reasoning_effort?: "minimal" | "low" | "medium" | "high";
   writing_mode?: boolean;
   writing_artifact_path?: string;
-  memory_injection_enabled?: boolean;
-  rag_mode_enabled?: boolean;
-  agent_id?: string;
+  memory_injection_enabled?: boolean;
+  rag_mode_enabled?: boolean;
+  /** Per-conversation switch for knowledge-base RAG injection (phase 2). */
+  knowledge_rag_enabled?: boolean;
+  agent_id?: string;
   /** @deprecated kept for reading legacy thread metadata; prefer agent_id */
   agent_name?: string;
 }
diff --git a/frontend-web/src/core/threads/utils.ts b/frontend-web/src/core/threads/utils.ts
index 6148a239..7a3d8769 100644
--- a/frontend-web/src/core/threads/utils.ts
+++ b/frontend-web/src/core/threads/utils.ts
@@ -81,6 +81,28 @@ export function titleOfThread(thread: AgentThread, fallback = "Untitled") {
   return fallback;
 }
 
+export function isThreadPinned(thread: AgentThread): boolean {
+  return (thread.metadata as Record<string, unknown> | null)?.is_pinned === true;
+}
+
+export function isThreadFavorite(thread: AgentThread): boolean {
+  return (thread.metadata as Record<string, unknown> | null)?.is_favorite === true;
+}
+
+/**
+ * Stable sort that lifts pinned (置顶) threads to the top while preserving the
+ * incoming order (typically `updated_at` desc) within both the pinned and the
+ * unpinned group.
+ */
+export function sortThreadsPinnedFirst(threads: AgentThread[]): AgentThread[] {
+  const pinned: AgentThread[] = [];
+  const rest: AgentThread[] = [];
+  for (const thread of threads) {
+    (isThreadPinned(thread) ? pinned : rest).push(thread);
+  }
+  return [...pinned, ...rest];
+}
+
 export function sanitizeThreadTitleForDisplay(title: string | null | undefined) {
   if (!title) return "Untitled";
 
diff --git a/frontend-web/src/core/user-qa/api.ts b/frontend-web/src/core/user-qa/api.ts
new file mode 100644
index 00000000..1ce9bc93
--- /dev/null
+++ b/frontend-web/src/core/user-qa/api.ts
@@ -0,0 +1,47 @@
+import { apiFetch } from "@/core/api";
+import { getBackendBaseURL } from "@/core/config";
+
+export interface UserQaItem {
+  run_id: string;
+  thread_id: string;
+  thread_title: string;
+  assistant_id: string;
+  status: string;
+  model_name: string;
+  question: string;
+  answer: string;
+  total_tokens: number;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface UserQaPageResponse {
+  user_id: string;
+  page: number;
+  page_size: number;
+  total: number;
+  items: UserQaItem[];
+}
+
+async function parse<T>(res: Response, what: string): Promise<T> {
+  if (!res.ok) {
+    const err = (await res.json().catch(() => ({}))) as { detail?: string };
+    throw new Error(err.detail ?? `${what} (HTTP ${res.status})`);
+  }
+  return res.json() as Promise<T>;
+}
+
+export async function listMyQa(
+  params: { page?: number; pageSize?: number; q?: string } = {},
+): Promise<UserQaPageResponse> {
+  const search = new URLSearchParams({
+    page: String(params.page ?? 1),
+    page_size: String(params.pageSize ?? 20),
+  });
+  const query = (params.q ?? "").trim();
+  if (query) search.set("q", query);
+  return parse(
+    await apiFetch(`${getBackendBaseURL()}/api/users/me/qa?${search}`),
+    "Failed to load my Q&A",
+  );
+}
diff --git a/frontend-web/src/pages/AdminUserLeaderboardPage.tsx b/frontend-web/src/pages/AdminUserLeaderboardPage.tsx
index 0122e7b2..de98095f 100644
--- a/frontend-web/src/pages/AdminUserLeaderboardPage.tsx
+++ b/frontend-web/src/pages/AdminUserLeaderboardPage.tsx
@@ -9,6 +9,7 @@ import {
   Bot,
   CalendarDays,
   Crown,
+  ExternalLink,
   FileDown,
   Gauge,
   Layers3,
@@ -17,6 +18,7 @@ import {
   Medal,
   MessageSquareText,
   MousePointerClick,
+  RefreshCw,
   Search,
   Settings2,
   Sparkles,
@@ -54,7 +56,7 @@ import type {
   AdminLeaderboardUser,
 } from "@/core/admin/api";
 import { streamUserLeaderboardReport } from "@/core/admin/api";
-import { useUserAnalytics, useUserLeaderboard } from "@/core/admin/hooks";
+import { useRefreshTodayLeaderboard, useUserAnalytics, useUserLeaderboard } from "@/core/admin/hooks";
 import { useModels } from "@/core/models/hooks";
 import { downloadMarkdownAsDocx } from "@/core/scheduled-tasks/markdown-docx";
 import { cn } from "@/lib/utils";
@@ -68,10 +70,10 @@ const LEADERBOARD_PAGE_SIZE = 20;
 
 const accentClasses: Record<LeaderboardAccent, { soft: string; text: string; bar: string; border: string }> = {
   crimson: {
-    soft: "bg-[#FFF1F1] dark:bg-[#C1121F]/15",
-    text: "text-[#C1121F] dark:text-[#F2B8BB]",
-    bar: "bg-[#C1121F]",
-    border: "border-[#F1D6D6] dark:border-[#462123]",
+    soft: "bg-[#FFF1F1] dark:bg-[#2563EB]/15",
+    text: "text-[#C1121F] dark:text-[#7FACF2]",
+    bar: "bg-[#C1121F] dark:bg-[#2563EB]",
+    border: "border-[#F1D6D6] dark:border-[#213D5E]",
   },
   rose: {
     soft: "bg-[#FFF1F2] dark:bg-rose-400/15",
@@ -284,7 +286,7 @@ function StatCard({
 }) {
   const color = accentClasses[accent];
   return (
-    <div className={cn("rounded-lg border bg-white p-4 shadow-sm dark:bg-[#230D0F]", color.border)}>
+    <div className={cn("rounded-lg border bg-white p-4 shadow-sm dark:bg-[#02244C]", color.border)}>
       <div className="flex items-center justify-between gap-3">
         <span className="text-sm text-[#5F6368] dark:text-slate-300">{label}</span>
         <span className={cn("flex size-8 items-center justify-center rounded-md", color.soft, color.text)}>
@@ -337,13 +339,13 @@ function InsightStrip({ overview }: { overview: AdminLeaderboardOverview }) {
   return (
     <section className="grid gap-3 md:grid-cols-5">
       {items.map((item) => (
-        <div key={item.label} className="rounded-lg border border-[#F1D6D6] bg-white p-3 shadow-sm dark:border-[#462123] dark:bg-[#230D0F]" title={item.description}>
-          <div className="text-xs font-medium text-[#7A5A5A] dark:text-[#D8B8B8]">{item.label}</div>
+        <div key={item.label} className="rounded-lg border border-[#F1D6D6] bg-white p-3 shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]" title={item.description}>
+          <div className="text-xs font-medium text-[#7A5A5A] dark:text-[#7FACF2]">{item.label}</div>
           <div className="mt-1 text-xl font-semibold tabular-nums text-[#231815] dark:text-white">
             {Number(item.value).toFixed(item.unit === "%" || String(item.value).includes(".") ? 1 : 0)}
-            <span className="ml-1 text-xs font-normal text-[#8B6B6B]">{item.unit}</span>
+            <span className="ml-1 text-xs font-normal text-[#8B6B6B] dark:text-[#7FACF2]">{item.unit}</span>
           </div>
-          <p className="mt-2 line-clamp-2 text-[11px] leading-4 text-[#8B6B6B] dark:text-[#D8B8B8]">{item.description}</p>
+          <p className="mt-2 line-clamp-2 text-[11px] leading-4 text-[#8B6B6B] dark:text-[#7FACF2]">{item.description}</p>
         </div>
       ))}
     </section>
@@ -365,14 +367,14 @@ function GroupComparison({
   const groups = buildGroupStats(users, rules);
 
   return (
-    <section className="rounded-lg border border-[#F1D6D6] bg-white p-4 shadow-sm dark:border-[#462123] dark:bg-[#230D0F]">
+    <section className="rounded-lg border border-[#F1D6D6] bg-white p-4 shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]">
       <div className="mb-4 flex flex-wrap items-start justify-between gap-3">
         <div>
           <div className="flex items-center gap-2 font-semibold text-[#231815] dark:text-white">
-            <Users className="size-4 text-[#C1121F]" />
+            <Users className="size-4 text-[#C1121F] dark:text-[#7FACF2]" />
             分组统计
           </div>
-          <p className="mt-1 text-sm text-[#7A5A5A] dark:text-[#D8B8B8]">
+          <p className="mt-1 text-sm text-[#7A5A5A] dark:text-[#7FACF2]">
             输入账号前缀或关键字，用逗号分隔，例如 zero,two；未命中的用户归入其他。
           </p>
         </div>
@@ -380,12 +382,12 @@ function GroupComparison({
           value={rulesText}
           onChange={(event) => onRulesChange(event.target.value)}
           placeholder="zero,two"
-          className="h-9 w-72 border-[#F1D6D6] bg-white dark:bg-[#19090A]"
+          className="h-9 w-72 border-[#F1D6D6] bg-white dark:bg-[#011226]"
         />
       </div>
       <div className="grid gap-3 xl:grid-cols-3">
         {groups.map((group) => (
-          <div key={group.name} className="rounded-lg border border-[#F1D6D6] bg-[#FFF7F7] p-3 dark:border-[#462123] dark:bg-[#19090A]">
+          <div key={group.name} className="rounded-lg border border-[#F1D6D6] bg-[#FFF7F7] p-3 dark:border-[#213D5E] dark:bg-[#011226]">
             <div className="mb-3 flex items-center justify-between gap-2">
               <div className="font-semibold text-[#231815] dark:text-white">{group.name}</div>
               <Badge variant="outline">{group.userCount} 人</Badge>
@@ -402,9 +404,9 @@ function GroupComparison({
                   key={user.user_id}
                   type="button"
                   onClick={() => onSelectUser(user)}
-                  className="grid w-full grid-cols-[24px_minmax(0,1fr)_64px] items-center gap-2 rounded-md px-2 py-1.5 text-left text-xs hover:bg-white dark:hover:bg-[#230D0F]"
+                  className="grid w-full grid-cols-[24px_minmax(0,1fr)_64px] items-center gap-2 rounded-md px-2 py-1.5 text-left text-xs hover:bg-white dark:hover:bg-[#02244C]"
                 >
-                  <span className="font-semibold text-[#C1121F]">{index + 1}</span>
+                  <span className="font-semibold text-[#C1121F] dark:text-[#7FACF2]">{index + 1}</span>
                   <span className="truncate">{user.email || user.user_id}</span>
                   <span className="text-right tabular-nums">{fmtNumber(userScore(user, "activity"))}</span>
                 </button>
@@ -438,8 +440,8 @@ function PodiumCard({
 
   if (!user) {
     return (
-      <div className="flex min-h-40 flex-col justify-between rounded-lg border border-dashed border-[#DADCE0] bg-white/70 p-4 dark:border-[#462123] dark:bg-[#230D0F]/70">
-        <div className="text-sm text-[#5F6368]">第 {rank} 名</div>
+      <div className="flex min-h-40 flex-col justify-between rounded-lg border border-dashed border-[#DADCE0] bg-white/70 p-4 dark:border-[#213D5E] dark:bg-[#02244C]/70">
+        <div className="text-sm text-[#5F6368] dark:text-slate-400">第 {rank} 名</div>
         <div className="text-sm text-[#80868B]">暂无数据</div>
       </div>
     );
@@ -450,8 +452,8 @@ function PodiumCard({
       type="button"
       onClick={() => onSelect(user)}
       className={cn(
-        "flex min-h-40 flex-col justify-between rounded-lg border bg-white p-4 text-left shadow-sm transition hover:-translate-y-0.5 hover:shadow-md dark:bg-[#230D0F]",
-        active ? "border-[#C1121F] ring-2 ring-[#F1D6D6] dark:border-[#F2B8BB] dark:ring-[#C1121F]/20" : "border-[#DADCE0] dark:border-[#462123]",
+        "flex min-h-40 flex-col justify-between rounded-lg border bg-white p-4 text-left shadow-sm transition hover:-translate-y-0.5 hover:shadow-md dark:bg-[#02244C]",
+        active ? "border-[#C1121F] dark:border-[#2563EB] ring-2 ring-[#F1D6D6] dark:border-[#7FACF2] dark:ring-[#2563EB]/20" : "border-[#DADCE0] dark:border-[#213D5E]",
       )}
     >
       <div className="flex items-start justify-between gap-3">
@@ -462,11 +464,11 @@ function PodiumCard({
         {user.system_role === "admin" && <Badge variant="outline">管理员</Badge>}
       </div>
       <div>
-        <div className="mb-3 flex size-11 items-center justify-center rounded-lg bg-[#C1121F] text-base font-semibold text-white shadow-sm">
+        <div className="mb-3 flex size-11 items-center justify-center rounded-lg bg-[#C1121F] dark:bg-[#2563EB] text-base font-semibold text-white shadow-sm">
           {initials(user)}
         </div>
         <div className="truncate font-semibold text-[#202124] dark:text-white">{user.email || user.user_id}</div>
-        <div className="mt-1 text-sm font-medium text-[#C1121F] dark:text-[#F2B8BB]">{scoreLabel(user, tab)}</div>
+        <div className="mt-1 text-sm font-medium text-[#C1121F] dark:text-[#7FACF2]">{scoreLabel(user, tab)}</div>
         <div className="mt-2 flex flex-wrap gap-x-3 gap-y-1 text-xs text-[#5F6368] dark:text-slate-400">
           <span>运行 {fmtNumber(user.run_count)}</span>
           <span>问答 {fmtNumber(user.qa_count)}</span>
@@ -482,15 +484,15 @@ function TrendBars({ points, compact = false }: { points: AdminLeaderboardTrendP
   const [metric, setMetric] = useState<"all" | TrendMetric>("all");
   const chartId = useId().replace(/:/g, "");
   if (points.length === 0) {
-    return <div className="flex h-56 items-center justify-center text-sm text-[#5F6368]">暂无趋势数据</div>;
+    return <div className="flex h-56 items-center justify-center text-sm text-[#5F6368] dark:text-slate-400">暂无趋势数据</div>;
   }
 
   const visible = points.slice(-32);
   const series = [
-    { key: "runs", label: "运行", color: "#C1121F", soft: "bg-[#FFF1F1] text-[#C1121F]", description: "每天发起的运行次数" },
-    { key: "questions", label: "问答", color: "#0F766E", soft: "bg-[#ECFDF5] text-[#0F766E]", description: "每天产生的有效提问次数" },
-    { key: "users", label: "活跃", color: "#B45309", soft: "bg-[#FFFBEB] text-[#B45309]", description: "每天有行为的用户数量" },
-    { key: "tokens", label: "Token", color: "#7C3AED", soft: "bg-[#F5F3FF] text-[#7C3AED]", description: "每天模型输入输出 Token 总量" },
+    { key: "runs", label: "运行", color: "#C1121F", soft: "bg-[#FFF1F1] text-[#C1121F] dark:text-[#7FACF2] dark:bg-[#2563EB]/15 dark:text-[#7FACF2]", description: "每天发起的运行次数" },
+    { key: "questions", label: "问答", color: "#0F766E", soft: "bg-[#ECFDF5] text-[#0F766E] dark:bg-teal-300/15 dark:text-teal-100", description: "每天产生的有效提问次数" },
+    { key: "users", label: "活跃", color: "#B45309", soft: "bg-[#FFFBEB] text-[#B45309] dark:bg-amber-300/15 dark:text-amber-100", description: "每天有行为的用户数量" },
+    { key: "tokens", label: "Token", color: "#7C3AED", soft: "bg-[#F5F3FF] text-[#7C3AED] dark:bg-violet-300/15 dark:text-violet-100", description: "每天模型输入输出 Token 总量" },
   ] as const;
   const activeMetric: TrendMetric = metric === "all" ? "runs" : metric;
   const activeSeries = series.find((item) => item.key === activeMetric) ?? series[0];
@@ -533,15 +535,15 @@ function TrendBars({ points, compact = false }: { points: AdminLeaderboardTrendP
             "min-w-0 rounded-lg border px-3 py-2 text-left transition hover:-translate-y-0.5 hover:shadow-sm",
             large && "px-4 py-3",
             metric === "all"
-              ? "border-[#C1121F] bg-[#FFF1F1] shadow-sm dark:border-[#F2B8BB]/40 dark:bg-[#3A1215]"
-              : "border-[#F1D6D6] bg-white dark:border-[#462123] dark:bg-[#230D0F]",
+              ? "border-[#C1121F] dark:border-[#2563EB] bg-[#FFF1F1] shadow-sm dark:border-[#7FACF2]/40 dark:bg-[#0D2D54]"
+              : "border-[#F1D6D6] bg-white dark:border-[#213D5E] dark:bg-[#02244C]",
           )}
         >
-          <span className="inline-flex rounded-full bg-[#FFF1F1] px-2 py-0.5 text-xs font-medium text-[#C1121F]">全部趋势</span>
+          <span className="inline-flex rounded-full bg-[#FFF1F1] px-2 py-0.5 text-xs font-medium text-[#C1121F] dark:text-[#7FACF2] dark:bg-[#2563EB]/15 dark:text-[#7FACF2]">全部趋势</span>
           <span className={cn("mt-2 block font-semibold tabular-nums text-[#231815] dark:text-white", large ? "text-2xl" : "text-lg")}>
             {fmtNumber(visible.reduce((sum, point) => sum + point.runs + point.questions + point.users, 0))}
           </span>
-          {large && <span className="mt-1 block truncate text-xs text-[#8B6B6B] dark:text-[#D8B8B8]">同时显示运行、问答、活跃与 Token</span>}
+          {large && <span className="mt-1 block truncate text-xs text-[#8B6B6B] dark:text-[#7FACF2]">同时显示运行、问答、活跃与 Token</span>}
         </button>
       )}
       {series.map((item) => (
@@ -553,8 +555,8 @@ function TrendBars({ points, compact = false }: { points: AdminLeaderboardTrendP
             "min-w-0 rounded-lg border px-3 py-2 text-left transition hover:-translate-y-0.5 hover:shadow-sm",
             large && "px-4 py-3",
             metric === item.key
-              ? "border-[#C1121F] bg-[#FFF1F1] shadow-sm dark:border-[#F2B8BB]/40 dark:bg-[#3A1215]"
-              : "border-[#F1D6D6] bg-white dark:border-[#462123] dark:bg-[#230D0F]",
+              ? "border-[#C1121F] dark:border-[#2563EB] bg-[#FFF1F1] shadow-sm dark:border-[#7FACF2]/40 dark:bg-[#0D2D54]"
+              : "border-[#F1D6D6] bg-white dark:border-[#213D5E] dark:bg-[#02244C]",
           )}
           title={item.description}
         >
@@ -562,7 +564,7 @@ function TrendBars({ points, compact = false }: { points: AdminLeaderboardTrendP
           <span className={cn("mt-2 block truncate font-semibold tabular-nums text-[#111827] dark:text-white", large ? "text-2xl" : compact ? "text-base" : "text-lg")}>
             {fmtNumber(totalFor(item.key))}
           </span>
-          {(large || compact) && <span className="mt-1 block truncate text-[11px] text-[#8B6B6B] dark:text-[#D8B8B8]">{item.description}</span>}
+          {(large || compact) && <span className="mt-1 block truncate text-[11px] text-[#8B6B6B] dark:text-[#7FACF2]">{item.description}</span>}
         </button>
       ))}
     </div>
@@ -583,15 +585,15 @@ function TrendBars({ points, compact = false }: { points: AdminLeaderboardTrendP
         </DialogHeader>
         <div className="shrink-0">{metricCards({ includeAll: true, large: true })}</div>
         <div className="grid min-h-0 flex-1 gap-3 lg:grid-cols-[260px_minmax(0,1fr)]">
-          <div className="rounded-lg border border-[#F1D6D6] bg-white p-4 dark:border-[#462123] dark:bg-[#230D0F]">
-            <div className="text-xs text-[#7A5A5A] dark:text-[#D8B8B8]">当前查看</div>
+          <div className="rounded-lg border border-[#F1D6D6] bg-white p-4 dark:border-[#213D5E] dark:bg-[#02244C]">
+            <div className="text-xs text-[#7A5A5A] dark:text-[#7FACF2]">当前查看</div>
             <div className="mt-2 text-2xl font-semibold text-[#111827] dark:text-white">{metric === "all" ? "全部指标" : activeSeries.label}</div>
-            <div className="mt-5 text-xs text-[#7A5A5A] dark:text-[#D8B8B8]">最新 {metric === "all" ? "运行" : activeSeries.label}</div>
+            <div className="mt-5 text-xs text-[#7A5A5A] dark:text-[#7FACF2]">最新 {metric === "all" ? "运行" : activeSeries.label}</div>
             <div className="mt-2 text-4xl font-semibold tabular-nums text-[#111827] dark:text-white">{fmtNumber(latestValue)}</div>
-            <div className={cn("mt-3 text-sm", delta >= 0 ? "text-[#C1121F]" : "text-[#7F1D1D] dark:text-[#FCA5A5]")}>
+            <div className={cn("mt-3 text-sm", delta >= 0 ? "text-[#C1121F] dark:text-[#7FACF2]" : "text-[#7F1D1D] dark:text-[#FCA5A5]")}>
               较上一日 {delta >= 0 ? "+" : ""}{fmtNumber(delta)}
             </div>
-            <div className="mt-5 text-xs text-[#7A5A5A] dark:text-[#D8B8B8]">
+            <div className="mt-5 text-xs text-[#7A5A5A] dark:text-[#7FACF2]">
               峰值 {peak.date} / {fmtNumber(Number(peak[activeMetric] ?? 0))}
             </div>
           </div>
@@ -679,7 +681,7 @@ function TrendBars({ points, compact = false }: { points: AdminLeaderboardTrendP
     return (
       <div className="min-w-0 space-y-3">
         {metricCards({ includeAll: false })}
-        <div className="flex flex-wrap items-center justify-between gap-2 text-xs text-[#7A5A5A] dark:text-[#D8B8B8]">
+        <div className="flex flex-wrap items-center justify-between gap-2 text-xs text-[#7A5A5A] dark:text-[#7FACF2]">
           <span>每个点代表 1 天；当前显示 {metric === "all" ? "全部指标" : activeSeries.label}，覆盖 {activeDays} 个活跃日。</span>
           {analysisDialog(
             "个人使用趋势",
@@ -693,7 +695,7 @@ function TrendBars({ points, compact = false }: { points: AdminLeaderboardTrendP
 
   return (
     <div className="space-y-4">
-      <p className="text-xs leading-5 text-[#7A5A5A] dark:text-[#D8B8B8]">
+      <p className="text-xs leading-5 text-[#7A5A5A] dark:text-[#7FACF2]">
         每个折线点代表一天；点击指标卡可单独查看运行、问答、活跃或 Token，全部趋势会同时展示四条多色折线。
       </p>
       <div className="flex flex-wrap items-center justify-between gap-3">
@@ -704,13 +706,13 @@ function TrendBars({ points, compact = false }: { points: AdminLeaderboardTrendP
         )}
       </div>
       <div className="grid gap-3 lg:grid-cols-[220px_minmax(0,1fr)]">
-        <div className="rounded-xl border border-[#F1D6D6] bg-white p-4 dark:border-[#462123] dark:bg-[#230D0F]">
-          <div className="text-xs text-[#7A5A5A] dark:text-[#D8B8B8]">最新 {metric === "all" ? "运行" : activeSeries.label}</div>
+        <div className="rounded-xl border border-[#F1D6D6] bg-white p-4 dark:border-[#213D5E] dark:bg-[#02244C]">
+          <div className="text-xs text-[#7A5A5A] dark:text-[#7FACF2]">最新 {metric === "all" ? "运行" : activeSeries.label}</div>
           <div className="mt-2 text-3xl font-semibold tabular-nums text-[#111827] dark:text-white">{fmtNumber(latestValue)}</div>
-          <div className={cn("mt-2 text-sm", delta >= 0 ? "text-[#C1121F]" : "text-[#7F1D1D] dark:text-[#FCA5A5]")}>
+          <div className={cn("mt-2 text-sm", delta >= 0 ? "text-[#C1121F] dark:text-[#7FACF2]" : "text-[#7F1D1D] dark:text-[#FCA5A5]")}>
             较上一日 {delta >= 0 ? "+" : ""}{fmtNumber(delta)}
           </div>
-          <div className="mt-3 text-xs text-[#7A5A5A] dark:text-[#D8B8B8]">
+          <div className="mt-3 text-xs text-[#7A5A5A] dark:text-[#7FACF2]">
             峰值 {peak.date.slice(5)} / {fmtNumber(Number(peak[activeMetric] ?? 0))}
           </div>
         </div>
@@ -735,11 +737,11 @@ function UserTable({
 }) {
   const max = Math.max(1, ...users.map((user) => userScore(user, tab)));
   if (users.length === 0) {
-    return <div className="py-14 text-center text-sm text-[#5F6368]">暂无用户统计</div>;
+    return <div className="py-14 text-center text-sm text-[#5F6368] dark:text-slate-400">暂无用户统计</div>;
   }
 
   return (
-    <div className="overflow-hidden rounded-lg border border-[#F1D6D6] bg-white dark:border-[#462123] dark:bg-[#230D0F]">
+    <div className="overflow-hidden rounded-lg border border-[#F1D6D6] bg-white dark:border-[#213D5E] dark:bg-[#02244C]">
       {users.map((user, index) => {
         const score = userScore(user, tab);
         return (
@@ -748,11 +750,11 @@ function UserTable({
             type="button"
             onClick={() => onSelect(user)}
             className={cn(
-              "grid w-full grid-cols-[44px_minmax(0,1fr)_minmax(160px,240px)_120px] items-center gap-4 border-b border-[#F1D6D6] px-4 py-3 text-left last:border-b-0 hover:bg-[#FFF7F7] dark:border-[#462123] dark:hover:bg-[#19090A]",
-              selectedUserId === user.user_id && "bg-[#FFF1F1] dark:bg-[#C1121F]/10",
+              "grid w-full grid-cols-[44px_minmax(0,1fr)_minmax(160px,240px)_120px] items-center gap-4 border-b border-[#F1D6D6] px-4 py-3 text-left last:border-b-0 hover:bg-[#FFF7F7] dark:border-[#213D5E] dark:hover:bg-[#011226]",
+              selectedUserId === user.user_id && "bg-[#FFF1F1] dark:bg-[#2563EB]/10",
             )}
           >
-            <div className="flex size-8 items-center justify-center rounded-md bg-[#FFF1F1] text-sm font-semibold text-[#C1121F] dark:bg-[#3A1215] dark:text-[#F2B8BB]">
+            <div className="flex size-8 items-center justify-center rounded-md bg-[#FFF1F1] text-sm font-semibold text-[#C1121F] dark:text-[#7FACF2] dark:bg-[#0D2D54] dark:text-[#7FACF2]">
               {rankOffset + index + 1}
             </div>
             <div className="min-w-0">
@@ -765,9 +767,9 @@ function UserTable({
               </div>
             </div>
             <div>
-              <div className="h-2 rounded-full bg-[#F1D6D6] dark:bg-[#3A1215]">
+              <div className="h-2 rounded-full bg-[#F1D6D6] dark:bg-[#0D2D54]">
                 <div
-                  className="h-2 rounded-full bg-[#C1121F]"
+                  className="h-2 rounded-full bg-[#C1121F] dark:bg-[#2563EB]"
                   style={{ width: `${Math.max(4, (score / max) * 100)}%` }}
                 />
               </div>
@@ -801,7 +803,7 @@ function SkillRanking({
 }) {
   const max = Math.max(1, ...items.map((item) => item.call_count));
   return (
-    <section className="rounded-lg border border-[#F1D6D6] bg-white p-4 shadow-sm dark:border-[#462123] dark:bg-[#230D0F]">
+    <section className="rounded-lg border border-[#F1D6D6] bg-white p-4 shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]">
       <div className="mb-4 flex items-center justify-between gap-3">
         <div className="flex items-center gap-2">
           <Icon className="size-4 text-[#5F6368] dark:text-slate-300" />
@@ -810,7 +812,7 @@ function SkillRanking({
         <Badge variant="outline">{items.length} 项</Badge>
       </div>
       <div className="space-y-3">
-        {items.length === 0 && <div className="py-10 text-center text-sm text-[#5F6368]">{empty}</div>}
+        {items.length === 0 && <div className="py-10 text-center text-sm text-[#5F6368] dark:text-slate-400">{empty}</div>}
         {items.slice(0, 10).map((item, index) => (
           <div key={item.name} className="grid grid-cols-[28px_minmax(0,1fr)_72px] items-center gap-3">
             <span className="text-sm font-medium text-[#80868B] tabular-nums">{index + 1}</span>
@@ -821,7 +823,7 @@ function SkillRanking({
                   {fmtNumber(item.user_count)} 人
                 </span>
               </div>
-              <div className="mt-2 h-2 rounded-full bg-[#F1D6D6] dark:bg-[#3A1215]">
+              <div className="mt-2 h-2 rounded-full bg-[#F1D6D6] dark:bg-[#0D2D54]">
                 <div
                   className="h-2 rounded-full"
                   style={{
@@ -859,7 +861,7 @@ function DimensionRanking({
 }) {
   const max = Math.max(1, ...items.map((item) => item.count));
   return (
-    <section className="rounded-lg border border-[#F1D6D6] bg-white p-4 shadow-sm dark:border-[#462123] dark:bg-[#230D0F]">
+    <section className="rounded-lg border border-[#F1D6D6] bg-white p-4 shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]">
       <div className="mb-4 flex items-center justify-between gap-3">
         <div className="flex items-center gap-2">
           <Icon className="size-4 text-[#5F6368] dark:text-slate-300" />
@@ -868,7 +870,7 @@ function DimensionRanking({
         <Badge variant="outline">{items.length} 项</Badge>
       </div>
       <div className="space-y-3">
-        {items.length === 0 && <div className="py-10 text-center text-sm text-[#5F6368]">{empty}</div>}
+        {items.length === 0 && <div className="py-10 text-center text-sm text-[#5F6368] dark:text-slate-400">{empty}</div>}
         {items.slice(0, 8).map((item, index) => (
           <div key={item.name} className="grid grid-cols-[28px_minmax(0,1fr)_88px] items-center gap-3">
             <span className="text-sm font-medium text-[#80868B] tabular-nums">{index + 1}</span>
@@ -879,7 +881,7 @@ function DimensionRanking({
                   {fmtNumber(item.user_count)} 人
                 </span>
               </div>
-              <div className="mt-2 h-2 rounded-full bg-[#F1D6D6] dark:bg-[#3A1215]">
+              <div className="mt-2 h-2 rounded-full bg-[#F1D6D6] dark:bg-[#0D2D54]">
                 <div
                   className="h-2 rounded-full"
                   style={{
@@ -913,8 +915,8 @@ function QuestionPanel({
   showUser?: boolean;
 }) {
   return (
-    <section className="flex h-[430px] flex-col overflow-hidden rounded-lg border border-[#F1D6D6] bg-white shadow-sm dark:border-[#462123] dark:bg-[#230D0F]">
-      <div className="flex items-center justify-between gap-3 border-b border-[#F1D6D6] px-4 py-3 dark:border-[#462123]">
+    <section className="flex h-[430px] flex-col overflow-hidden rounded-lg border border-[#F1D6D6] bg-white shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]">
+      <div className="flex items-center justify-between gap-3 border-b border-[#F1D6D6] px-4 py-3 dark:border-[#213D5E]">
         <div className="flex items-center gap-2">
           <MessageSquareText className="size-4 text-[#5F6368] dark:text-slate-300" />
           <h2 className="font-semibold text-[#202124] dark:text-white">{title}</h2>
@@ -922,8 +924,8 @@ function QuestionPanel({
         <Badge variant="outline">{items.length}</Badge>
       </div>
       <ScrollArea className="min-h-0 flex-1">
-        <div className="divide-y divide-[#F1D6D6] dark:divide-[#462123]">
-          {items.length === 0 && <div className="py-12 text-center text-sm text-[#5F6368]">暂无问题记录</div>}
+        <div className="divide-y divide-[#F1D6D6] dark:divide-[#213D5E]">
+          {items.length === 0 && <div className="py-12 text-center text-sm text-[#5F6368] dark:text-slate-400">暂无问题记录</div>}
           {items.map((item, index) => (
             <div key={`${item.run_id || item.text}-${index}`} className="px-4 py-3">
               <div className="text-sm leading-6 text-[#202124] dark:text-slate-100">{clampText(item.text, 180)}</div>
@@ -942,8 +944,8 @@ function QuestionPanel({
 
 function Metric({ label, value }: { label: string; value: number }) {
   return (
-    <div className="min-w-0 border-r border-[#F1D6D6] px-3 py-2 last:border-r-0 dark:border-[#462123]">
-      <div className="truncate text-xs text-[#7A5A5A] dark:text-[#D8B8B8]">{label}</div>
+    <div className="min-w-0 border-r border-[#F1D6D6] px-3 py-2 last:border-r-0 dark:border-[#213D5E]">
+      <div className="truncate text-xs text-[#7A5A5A] dark:text-[#7FACF2]">{label}</div>
       <div className="mt-1 truncate font-semibold text-[#231815] tabular-nums dark:text-white">{fmtNumber(value)}</div>
     </div>
   );
@@ -971,7 +973,7 @@ function UserDetailPanel({
 
   if (isLoading || !data) {
     return (
-      <div className="flex h-full items-center justify-center gap-2 text-sm text-[#5F6368]">
+      <div className="flex h-full items-center justify-center gap-2 text-sm text-[#5F6368] dark:text-slate-400">
         <Loader2 className="size-4 animate-spin" />
         加载用户详情
       </div>
@@ -981,13 +983,13 @@ function UserDetailPanel({
   return (
     <ScrollArea className="h-full">
       <div className="space-y-4 p-4">
-        <section className="rounded-lg border border-[#F1D6D6] bg-white p-4 dark:border-[#462123] dark:bg-[#230D0F]">
+        <section className="rounded-lg border border-[#F1D6D6] bg-white p-4 dark:border-[#213D5E] dark:bg-[#02244C]">
           <div className="flex items-start justify-between gap-3">
             <div className="min-w-0">
               <div className="truncate text-lg font-semibold text-[#231815] dark:text-white">
                 {data.user.email || data.user.user_id}
               </div>
-              <div className="mt-1 text-xs text-[#7A5A5A] dark:text-[#D8B8B8]">
+              <div className="mt-1 text-xs text-[#7A5A5A] dark:text-[#7FACF2]">
                 最近活跃 {fmtTime(data.user.last_active_at)}
               </div>
             </div>
@@ -996,7 +998,7 @@ function UserDetailPanel({
               <ArrowRight className="ml-1 size-3.5" />
             </Button>
           </div>
-          <div className="mt-4 grid grid-cols-4 overflow-hidden rounded-lg border border-[#F1D6D6] bg-[#FFF7F7] text-sm dark:border-[#462123] dark:bg-[#19090A]">
+          <div className="mt-4 grid grid-cols-4 overflow-hidden rounded-lg border border-[#F1D6D6] bg-[#FFF7F7] text-sm dark:border-[#213D5E] dark:bg-[#011226]">
             <Metric label="问答次数" value={data.user.qa_count} />
             <Metric label="运行次数" value={data.user.run_count} />
             <Metric label="技能调用" value={data.user.skill_call_count} />
@@ -1016,7 +1018,7 @@ function UserDetailPanel({
           </TabsContent>
           <TabsContent value="trend" className="min-h-[420px]">
             <div className="mb-3 flex items-center gap-2 font-semibold text-[#231815] dark:text-white">
-              <TrendingUp className="size-4 text-[#C1121F]" />
+              <TrendingUp className="size-4 text-[#C1121F] dark:text-[#7FACF2]" />
               个人使用趋势
             </div>
             <TrendBars points={data.trends} compact />
@@ -1051,6 +1053,7 @@ export default function AdminUserLeaderboardPage() {
     [range],
   );
   const { data, isLoading, error } = useUserLeaderboard(apiRange, 100);
+  const refreshToday = useRefreshTodayLeaderboard();
   const [reportOpen, setReportOpen] = useState(false);
   const { models: reportModels, isLoading: reportModelsLoading } = useModels({ enabled: reportOpen });
   const [reportModelName, setReportModelName] = useState(DEFAULT_REPORT_MODEL);
@@ -1226,31 +1229,38 @@ export default function AdminUserLeaderboardPage() {
   }, [apiRange.since, apiRange.until, reportModelName]);
 
   return (
-    <div className="flex size-full min-h-0 bg-[#FFF7F7] text-[#231815] dark:bg-[#19090A] dark:text-white">
+    <div className="flex size-full min-h-0 bg-[#FFF7F7] text-[#231815] dark:bg-[#011226] dark:text-white">
       <main className="flex min-w-0 flex-1 flex-col">
-        <div className="border-b border-[#F1D6D6] bg-white px-6 py-5 dark:border-[#462123] dark:bg-[#230D0F]">
-          <div className="flex flex-wrap items-end justify-between gap-4">
-            <div>
-              <div className="mb-2 flex items-center gap-2 text-sm text-[#9F343A] dark:text-[#F2B8BB]">
-                <Award className="size-4" />
-                管理员分析
+        {/* 整页统一滚动：标题与操作工具条不再固定置顶，随内容一起滚动，避免可视区域被压缩 */}
+        <ScrollArea className="min-h-0 flex-1">
+        <div className="border-b border-[#F1D6D6] bg-white px-6 py-5 dark:border-[#213D5E] dark:bg-[#02244C]">
+          <div className="flex flex-col gap-4">
+            {/* 标题维度：仅承载页面标题与说明 */}
+            <div className="flex flex-wrap items-start justify-between gap-4">
+              <div>
+                <div className="mb-2 flex items-center gap-2 text-sm text-[#9F343A] dark:text-[#7FACF2]">
+                  <Award className="size-4" />
+                  管理员分析
+                </div>
+                <h1 className="text-2xl font-semibold tracking-normal">用户排行榜</h1>
+                <p className="mt-1 text-sm text-[#7A5A5A] dark:text-[#7FACF2]">
+                  统计用户活跃、问答、Token 消耗、技能热度和近期问题，用于运营和审计。
+                </p>
               </div>
-              <h1 className="text-2xl font-semibold tracking-normal">用户排行榜</h1>
-              <p className="mt-1 text-sm text-[#7A5A5A] dark:text-[#D8B8B8]">
-                统计用户活跃、问答、Token 消耗、技能热度和近期问题，用于运营和审计。
-              </p>
-            </div>
-
-            <div className="flex flex-wrap items-end gap-2">
               <Button
                 variant="outline"
                 size="sm"
                 onClick={() => navigate("/page/workspace/chats/new")}
-                className="h-9"
+                className="h-9 shrink-0"
               >
                 <ArrowLeft className="mr-1 size-4" />
                 返回系统
               </Button>
+            </div>
+
+            {/* 操作维度：与标题区分开的控制工具条（操作按钮 + 时间筛选） */}
+            <div className="flex flex-wrap items-end justify-between gap-3 rounded-xl border border-[#F1D6D6] bg-white/70 px-3 py-3 dark:border-[#213D5E] dark:bg-[#02244C]/70">
+              <div className="flex flex-wrap items-center gap-2">
               <Button
                 variant="outline"
                 size="sm"
@@ -1261,6 +1271,30 @@ export default function AdminUserLeaderboardPage() {
               >
                 <Settings2 className="size-4" />
               </Button>
+              <Button
+                variant="outline"
+                size="sm"
+                disabled={refreshToday.isPending}
+                onClick={() =>
+                  refreshToday.mutate(
+                    { range: apiRange, limit: 100 },
+                    {
+                      onSuccess: () => toast.success("已刷新当天最新统计数据"),
+                      onError: (err) =>
+                        toast.error(err instanceof Error ? err.message : "刷新当天数据失败"),
+                    },
+                  )
+                }
+                className="h-9"
+                title="强制重算今天的统计，把最新的实时记录纳入榜单"
+              >
+                {refreshToday.isPending ? (
+                  <Loader2 className="mr-1 size-4 animate-spin" />
+                ) : (
+                  <RefreshCw className="mr-1 size-4" />
+                )}
+                {refreshToday.isPending ? "刷新中" : "刷新当天"}
+              </Button>
               <Button
                 variant="outline"
                 size="sm"
@@ -1271,6 +1305,16 @@ export default function AdminUserLeaderboardPage() {
                 <FileDown className="mr-1 size-4" />
                 导出 Excel
               </Button>
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={() => window.open("#/public/leaderboard", "_blank", "noopener")}
+                className="h-9"
+                title="打开免登录的公开发布页"
+              >
+                <ExternalLink className="mr-1 size-4" />
+                公开页
+              </Button>
               <Dialog open={reportOpen} onOpenChange={handleReportOpenChange}>
                 <DialogTrigger asChild>
                   <Button variant="outline" size="sm" disabled={!data} className="h-9">
@@ -1279,16 +1323,16 @@ export default function AdminUserLeaderboardPage() {
                   </Button>
                 </DialogTrigger>
                 <DialogContent className="flex h-[92vh] w-[96vw] max-w-none flex-col gap-0 overflow-hidden p-0 sm:max-w-none">
-                  <DialogHeader className="shrink-0 border-b border-[#F1D6D6] px-6 py-5 pr-12 dark:border-[#462123]">
+                  <DialogHeader className="shrink-0 border-b border-[#F1D6D6] px-6 py-5 pr-12 dark:border-[#213D5E]">
                     <DialogTitle>AI 榜单分析报告</DialogTitle>
                     <DialogDescription>
                       基于当前时间段的问答、用户、技能、模型和趋势统计生成运营分析。
                     </DialogDescription>
                   </DialogHeader>
-                  <div className="mx-6 mt-4 flex shrink-0 flex-wrap items-center justify-between gap-3 rounded-lg border border-[#F1D6D6] bg-white p-3 dark:border-[#462123] dark:bg-[#230D0F]">
+                  <div className="mx-6 mt-4 flex shrink-0 flex-wrap items-center justify-between gap-3 rounded-lg border border-[#F1D6D6] bg-white p-3 dark:border-[#213D5E] dark:bg-[#02244C]">
                     <div className="flex min-w-0 flex-wrap items-center gap-2">
                       <Select value={reportModelName} onValueChange={setReportModelName} disabled={reportGenerating || reportModelsLoading}>
-                        <SelectTrigger className="h-9 w-[260px] border-[#F1D6D6] bg-white dark:border-[#462123] dark:bg-[#19090A]">
+                        <SelectTrigger className="h-9 w-[260px] border-[#F1D6D6] bg-white dark:border-[#213D5E] dark:bg-[#011226]">
                           <SelectValue placeholder="选择报告模型" />
                         </SelectTrigger>
                         <SelectContent>
@@ -1302,7 +1346,7 @@ export default function AdminUserLeaderboardPage() {
                       </Select>
                       {reportStatus === "cached" && <Badge variant="outline">已读取缓存</Badge>}
                       {reportResolvedModel && <Badge variant="outline">模型 {reportResolvedModel}</Badge>}
-                      {reportGeneratedAt && <span className="text-xs text-[#7A5A5A] dark:text-[#D8B8B8]">生成于 {fmtTime(reportGeneratedAt)}</span>}
+                      {reportGeneratedAt && <span className="text-xs text-[#7A5A5A] dark:text-[#7FACF2]">生成于 {fmtTime(reportGeneratedAt)}</span>}
                     </div>
                     <Button size="sm" onClick={startReportGeneration} disabled={!data || reportGenerating}>
                       {reportGenerating ? <Loader2 className="mr-1 size-4 animate-spin" /> : <Sparkles className="mr-1 size-4" />}
@@ -1311,24 +1355,24 @@ export default function AdminUserLeaderboardPage() {
                   </div>
                   {data && reportStatus === "idle" && !reportText && (
                     <div className="mx-6 mt-4 grid shrink-0 gap-3 md:grid-cols-3">
-                      <section className="rounded-lg border border-[#F1D6D6] bg-white p-3 dark:border-[#462123] dark:bg-[#230D0F]">
+                      <section className="rounded-lg border border-[#F1D6D6] bg-white p-3 dark:border-[#213D5E] dark:bg-[#02244C]">
                         <div className="mb-2 flex items-center gap-2 text-sm font-semibold text-[#231815] dark:text-white">
-                          <MessageSquareText className="size-4 text-[#C1121F]" />
+                          <MessageSquareText className="size-4 text-[#C1121F] dark:text-[#7FACF2]" />
                           最近关注
                         </div>
                         <div className="space-y-2">
                           {data.recent_questions.slice(0, 3).map((item, index) => (
                             <div key={`${item.run_id || item.text}-${index}`} className="text-xs leading-5 text-[#5F6368] dark:text-slate-300">
-                              <span className="font-medium text-[#C1121F]">{fmtTime(item.asked_at)}</span>
+                              <span className="font-medium text-[#C1121F] dark:text-[#7FACF2]">{fmtTime(item.asked_at)}</span>
                               <span className="ml-1">{clampText(item.text, 58)}</span>
                             </div>
                           ))}
-                          {data.recent_questions.length === 0 && <div className="text-xs text-[#8B6B6B]">暂无数据</div>}
+                          {data.recent_questions.length === 0 && <div className="text-xs text-[#8B6B6B] dark:text-[#7FACF2]">暂无数据</div>}
                         </div>
                       </section>
-                      <section className="rounded-lg border border-[#F1D6D6] bg-white p-3 dark:border-[#462123] dark:bg-[#230D0F]">
+                      <section className="rounded-lg border border-[#F1D6D6] bg-white p-3 dark:border-[#213D5E] dark:bg-[#02244C]">
                         <div className="mb-2 flex items-center gap-2 text-sm font-semibold text-[#231815] dark:text-white">
-                          <TrendingUp className="size-4 text-[#C1121F]" />
+                          <TrendingUp className="size-4 text-[#C1121F] dark:text-[#7FACF2]" />
                           高频问题
                         </div>
                         <div className="space-y-2">
@@ -1337,34 +1381,34 @@ export default function AdminUserLeaderboardPage() {
                               {index + 1}. {clampText(item.text, 72)}
                             </div>
                           ))}
-                          {data.frequent_questions.length === 0 && <div className="text-xs text-[#8B6B6B]">暂无数据</div>}
+                          {data.frequent_questions.length === 0 && <div className="text-xs text-[#8B6B6B] dark:text-[#7FACF2]">暂无数据</div>}
                         </div>
                       </section>
-                      <section className="rounded-lg border border-[#F1D6D6] bg-white p-3 dark:border-[#462123] dark:bg-[#230D0F]">
+                      <section className="rounded-lg border border-[#F1D6D6] bg-white p-3 dark:border-[#213D5E] dark:bg-[#02244C]">
                         <div className="mb-2 flex items-center gap-2 text-sm font-semibold text-[#231815] dark:text-white">
-                          <Sparkles className="size-4 text-[#C1121F]" />
+                          <Sparkles className="size-4 text-[#C1121F] dark:text-[#7FACF2]" />
                           使用频率
                         </div>
                         <div className="space-y-2">
                           {[...data.skills.slice(0, 2), ...data.tools.slice(0, 1)].map((item, index) => (
                             <div key={`${item.name}-${index}`} className="flex items-center justify-between gap-2 text-xs leading-5 text-[#5F6368] dark:text-slate-300">
                               <span className="truncate">{item.name}</span>
-                              <span className="shrink-0 font-semibold text-[#C1121F]">{fmtNumber(item.call_count)} 次</span>
+                              <span className="shrink-0 font-semibold text-[#C1121F] dark:text-[#7FACF2]">{fmtNumber(item.call_count)} 次</span>
                             </div>
                           ))}
-                          {data.skills.length + data.tools.length === 0 && <div className="text-xs text-[#8B6B6B]">暂无数据</div>}
+                          {data.skills.length + data.tools.length === 0 && <div className="text-xs text-[#8B6B6B] dark:text-[#7FACF2]">暂无数据</div>}
                         </div>
                       </section>
                     </div>
                   )}
-                  <ScrollArea className="mx-6 mt-4 min-h-0 flex-1 rounded-lg border border-[#F1D6D6] bg-[#FFF7F7] p-5 dark:border-[#462123] dark:bg-[#19090A]">
+                  <ScrollArea className="mx-6 mt-4 min-h-0 flex-1 rounded-lg border border-[#F1D6D6] bg-[#FFF7F7] p-5 dark:border-[#213D5E] dark:bg-[#011226]">
                     {reportStatus === "idle" && !reportText && (
-                      <div className="flex items-center justify-center py-12 text-sm text-[#7A5A5A] dark:text-[#D8B8B8]">
+                      <div className="flex items-center justify-center py-12 text-sm text-[#7A5A5A] dark:text-[#7FACF2]">
                         选择模型后点击生成；同一时间段、同一模型和同一统计设置会直接读取已保存报告。
                       </div>
                     )}
                     {reportGenerating && !reportText && (
-                      <div className="flex items-center justify-center gap-2 py-12 text-sm text-[#7A5A5A] dark:text-[#D8B8B8]">
+                      <div className="flex items-center justify-center gap-2 py-12 text-sm text-[#7A5A5A] dark:text-[#7FACF2]">
                         <Loader2 className="size-4 animate-spin" />
                         正在调用大模型生成报告，内容会流式显示
                       </div>
@@ -1375,13 +1419,13 @@ export default function AdminUserLeaderboardPage() {
                       </div>
                     )}
                     {reportText && (
-                      <div className="rounded-lg bg-white px-8 py-6 text-base leading-8 text-[#231815] shadow-sm dark:bg-[#230D0F] dark:text-white [&_blockquote]:border-l-4 [&_blockquote]:border-[#C1121F] [&_blockquote]:bg-[#FFF7F7] [&_blockquote]:px-4 [&_blockquote]:py-3 [&_code]:rounded [&_code]:bg-[#FFF1F1] [&_code]:px-1.5 [&_h1]:mb-5 [&_h1]:text-2xl [&_h1]:font-semibold [&_h2]:mb-4 [&_h2]:mt-7 [&_h2]:border-b [&_h2]:border-[#F1D6D6] [&_h2]:pb-3 [&_h2]:text-xl [&_h2]:font-semibold [&_h3]:mb-3 [&_h3]:mt-5 [&_h3]:text-lg [&_h3]:font-semibold [&_li]:my-1.5 [&_ol]:pl-6 [&_p]:my-3 [&_strong]:text-[#C1121F] [&_table]:my-4 [&_table]:w-full [&_table]:border-collapse [&_td]:border [&_td]:border-[#F1D6D6] [&_td]:p-3 [&_th]:border [&_th]:border-[#F1D6D6] [&_th]:bg-[#FFF1F1] [&_th]:p-3 [&_ul]:pl-6 dark:[&_blockquote]:bg-[#19090A] dark:[&_code]:bg-[#19090A] dark:[&_strong]:text-[#F2B8BB] dark:[&_th]:bg-[#19090A]">
+                      <div className="rounded-lg bg-white px-8 py-6 text-base leading-8 text-[#231815] shadow-sm dark:bg-[#02244C] dark:text-white [&_blockquote]:border-l-4 [&_blockquote]:border-[#C1121F] dark:border-[#2563EB] [&_blockquote]:bg-[#FFF7F7] [&_blockquote]:px-4 [&_blockquote]:py-3 [&_code]:rounded [&_code]:bg-[#FFF1F1] [&_code]:px-1.5 [&_h1]:mb-5 [&_h1]:text-2xl [&_h1]:font-semibold [&_h2]:mb-4 [&_h2]:mt-7 [&_h2]:border-b [&_h2]:border-[#F1D6D6] [&_h2]:pb-3 [&_h2]:text-xl [&_h2]:font-semibold [&_h3]:mb-3 [&_h3]:mt-5 [&_h3]:text-lg [&_h3]:font-semibold [&_li]:my-1.5 [&_ol]:pl-6 [&_p]:my-3 [&_strong]:text-[#C1121F] dark:text-[#7FACF2] [&_table]:my-4 [&_table]:w-full [&_table]:border-collapse [&_td]:border [&_td]:border-[#F1D6D6] [&_td]:p-3 [&_th]:border [&_th]:border-[#F1D6D6] [&_th]:bg-[#FFF1F1] [&_th]:p-3 [&_ul]:pl-6 dark:[&_blockquote]:bg-[#011226] dark:[&_code]:bg-[#011226] dark:[&_strong]:text-[#7FACF2] dark:[&_th]:bg-[#011226]">
                         <MarkdownContent content={reportText} isLoading={reportGenerating} rehypePlugins={[]} />
                       </div>
                     )}
                   </ScrollArea>
                   {reportText && (
-                    <div className="mt-4 flex shrink-0 justify-end border-t border-[#F1D6D6] px-6 py-4 dark:border-[#462123]">
+                    <div className="mt-4 flex shrink-0 justify-end border-t border-[#F1D6D6] px-6 py-4 dark:border-[#213D5E]">
                       <Button
                         variant="outline"
                         onClick={exportReportAsWord}
@@ -1394,6 +1438,8 @@ export default function AdminUserLeaderboardPage() {
                   )}
                 </DialogContent>
               </Dialog>
+              </div>
+              <div className="flex flex-wrap items-end gap-2">
               <div className="flex flex-col gap-1">
                 <label className="text-xs text-[#5F6368] dark:text-slate-400">开始日期</label>
                 <Input
@@ -1402,7 +1448,7 @@ export default function AdminUserLeaderboardPage() {
                   onClick={(event) => event.currentTarget.showPicker?.()}
                   onFocus={(event) => event.currentTarget.showPicker?.()}
                   onChange={(event) => setRange((prev) => ({ ...prev, since: event.target.value }))}
-                  className="h-9 w-36 bg-white dark:bg-[#19090A]"
+                  className="h-9 w-36 bg-white dark:bg-[#011226]"
                 />
               </div>
               <div className="flex flex-col gap-1">
@@ -1413,7 +1459,7 @@ export default function AdminUserLeaderboardPage() {
                   onClick={(event) => event.currentTarget.showPicker?.()}
                   onFocus={(event) => event.currentTarget.showPicker?.()}
                   onChange={(event) => setRange((prev) => ({ ...prev, until: event.target.value }))}
-                  className="h-9 w-36 bg-white dark:bg-[#19090A]"
+                  className="h-9 w-36 bg-white dark:bg-[#011226]"
                 />
               </div>
               <Button variant="outline" size="sm" onClick={() => setQuickRange(7)}>
@@ -1425,19 +1471,19 @@ export default function AdminUserLeaderboardPage() {
               <Button variant="outline" size="sm" onClick={() => setQuickRange(90)}>
                 近 90 天
               </Button>
+              </div>
             </div>
           </div>
         </div>
 
-        <ScrollArea className="min-h-0 flex-1">
           <div className="space-y-5 p-6">
             {isLoading && (
-              <div className="flex flex-col items-center justify-center gap-3 py-20 text-center text-sm text-[#5F6368]">
+              <div className="flex flex-col items-center justify-center gap-3 py-20 text-center text-sm text-[#5F6368] dark:text-slate-400">
                 <div className="flex items-center gap-2">
                   <Loader2 className="size-4 animate-spin" />
                   <span>正在统计排行榜数据</span>
                 </div>
-                <div className="max-w-md text-xs leading-5 text-[#7A5A5A] dark:text-[#D8B8B8]">
+                <div className="max-w-md text-xs leading-5 text-[#7A5A5A] dark:text-[#7FACF2]">
                   线上用户较多或时间范围较大时，统计时间可能较长，请耐心等待。为避免影响其他接口，系统会限制排行榜统计的并发数量。
                 </div>
               </div>
@@ -1450,12 +1496,12 @@ export default function AdminUserLeaderboardPage() {
             )}
 
             {!isLoading && !error && leaderboardPending && !leaderboardHasRows && (
-              <div className="flex flex-col items-center justify-center gap-3 rounded-lg border border-[#F1D6D6] bg-white px-6 py-16 text-center text-sm text-[#5F6368] shadow-sm dark:border-[#462123] dark:bg-[#230D0F]">
+              <div className="flex flex-col items-center justify-center gap-3 rounded-lg border border-[#F1D6D6] bg-white px-6 py-16 text-center text-sm text-[#5F6368] shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]">
                 <div className="flex items-center gap-2 font-medium text-[#202124] dark:text-white">
-                  <Loader2 className="size-4 animate-spin text-[#C1121F]" />
+                  <Loader2 className="size-4 animate-spin text-[#C1121F] dark:text-[#7FACF2]" />
                   <span>排行榜正在后台统计</span>
                 </div>
-                <div className="max-w-lg text-xs leading-5 text-[#7A5A5A] dark:text-[#D8B8B8]">
+                <div className="max-w-lg text-xs leading-5 text-[#7A5A5A] dark:text-[#7FACF2]">
                   {data?.message || "统计任务已放到后台执行，页面会自动刷新结果。这样排行榜慢慢算，不会长时间占住当前接口请求。"}
                 </div>
               </div>
@@ -1495,7 +1541,7 @@ export default function AdminUserLeaderboardPage() {
                   />
                 )}
 
-                <section className="rounded-lg border border-[#F1D6D6] bg-white p-4 shadow-sm dark:border-[#462123] dark:bg-[#230D0F]">
+                <section className="rounded-lg border border-[#F1D6D6] bg-white p-4 shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]">
                   <div className="mb-4 flex flex-wrap items-center justify-between gap-3">
                     <div>
                       <h2 className="font-semibold text-[#202124] dark:text-white">榜单前三</h2>
@@ -1534,7 +1580,7 @@ export default function AdminUserLeaderboardPage() {
                           value={query}
                           onChange={(event) => setQuery(event.target.value)}
                           placeholder="搜索用户邮箱或 ID"
-                          className="h-9 w-64 bg-white pl-8 dark:bg-[#19090A]"
+                          className="h-9 w-64 bg-white pl-8 dark:bg-[#011226]"
                         />
                       </div>
                     </div>
@@ -1558,8 +1604,8 @@ export default function AdminUserLeaderboardPage() {
                     </div>
                   </section>
 
-                  <section className="overflow-hidden rounded-lg border border-[#F1D6D6] bg-white shadow-sm dark:border-[#462123] dark:bg-[#230D0F]">
-                    <div className="flex items-center gap-2 border-b border-[#F1D6D6] px-4 py-3 dark:border-[#462123]">
+                  <section className="overflow-hidden rounded-lg border border-[#F1D6D6] bg-white shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]">
+                    <div className="flex items-center gap-2 border-b border-[#F1D6D6] px-4 py-3 dark:border-[#213D5E]">
                       <UserRound className="size-4 text-[#5F6368] dark:text-slate-300" />
                       <h2 className="font-semibold text-[#202124] dark:text-white">用户详情</h2>
                     </div>
@@ -1575,7 +1621,7 @@ export default function AdminUserLeaderboardPage() {
                   </section>
                 </div>
 
-                <section className="rounded-lg border border-[#F1D6D6] bg-white p-4 shadow-sm dark:border-[#462123] dark:bg-[#230D0F]">
+                <section className="rounded-lg border border-[#F1D6D6] bg-white p-4 shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]">
                   <div className="mb-4 flex flex-wrap items-center justify-between gap-3">
                     <div className="flex items-center gap-2">
                       <TrendingUp className="size-4 text-[#5F6368] dark:text-slate-300" />
diff --git a/frontend-web/src/pages/AdminUserLeaderboardSettingsPage.tsx b/frontend-web/src/pages/AdminUserLeaderboardSettingsPage.tsx
index 4113c4c1..712c97d1 100644
--- a/frontend-web/src/pages/AdminUserLeaderboardSettingsPage.tsx
+++ b/frontend-web/src/pages/AdminUserLeaderboardSettingsPage.tsx
@@ -61,17 +61,17 @@ export default function AdminUserLeaderboardSettingsPage() {
   };
 
   return (
-    <div className="flex size-full min-h-0 bg-[#FFF7F7] text-[#231815] dark:bg-[#19090A] dark:text-white">
+    <div className="flex size-full min-h-0 bg-[#FFF7F7] text-[#231815] dark:bg-[#011226] dark:text-white">
       <main className="flex min-w-0 flex-1 flex-col">
-        <div className="border-b border-[#F1D6D6] bg-white px-6 py-5 dark:border-[#462123] dark:bg-[#230D0F]">
+        <div className="border-b border-[#F1D6D6] bg-white px-6 py-5 dark:border-[#213D5E] dark:bg-[#02244C]">
           <div className="flex flex-wrap items-center justify-between gap-3">
             <div>
-              <div className="mb-2 flex items-center gap-2 text-sm text-[#9F343A]">
+              <div className="mb-2 flex items-center gap-2 text-sm text-[#9F343A] dark:text-[#7FACF2]">
                 <SlidersHorizontal className="size-4" />
                 管理员设置
               </div>
               <h1 className="text-2xl font-semibold">排行榜设置</h1>
-              <p className="mt-1 text-sm text-[#7A5A5A] dark:text-[#D8B8B8]">
+              <p className="mt-1 text-sm text-[#7A5A5A] dark:text-[#7FACF2]">
                 这里的规则会影响用户排行榜、趋势、技能、模型、问题与个人详情统计。
               </p>
             </div>
@@ -86,14 +86,14 @@ export default function AdminUserLeaderboardSettingsPage() {
 
         <ScrollArea className="min-h-0 flex-1">
           <div className="mx-auto max-w-6xl space-y-5 p-6">
-            <section className="rounded-lg border border-[#F1D6D6] bg-white p-5 shadow-sm dark:border-[#462123] dark:bg-[#230D0F]">
+            <section className="rounded-lg border border-[#F1D6D6] bg-white p-5 shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]">
               <div className="mb-4 flex items-start justify-between gap-3">
                 <div>
                   <div className="flex items-center gap-2 font-semibold">
-                    <ShieldOff className="size-4 text-[#C1121F]" />
+                    <ShieldOff className="size-4 text-[#C1121F] dark:text-[#7FACF2]" />
                     统计排除名单
                   </div>
-                  <p className="mt-1 text-sm text-[#7A5A5A] dark:text-[#D8B8B8]">
+                  <p className="mt-1 text-sm text-[#7A5A5A] dark:text-[#7FACF2]">
                     名单中的账号不会进入排行榜、趋势、问题、模型和技能统计。
                   </p>
                 </div>
@@ -111,21 +111,21 @@ export default function AdminUserLeaderboardSettingsPage() {
                     value={query}
                     onChange={(event) => setQuery(event.target.value)}
                     placeholder="搜索账号邮箱或 ID"
-                    className="h-10 border-[#F1D6D6] bg-white pl-9"
+                    className="h-10 border-[#F1D6D6] bg-white pl-9 dark:border-[#213D5E] dark:bg-[#011226] dark:text-white"
                   />
                   {query.trim() && candidates.length > 0 && (
-                    <div className="absolute z-20 mt-2 max-h-72 w-full overflow-hidden rounded-lg border border-[#F1D6D6] bg-white shadow-lg dark:border-[#462123] dark:bg-[#230D0F]">
+                    <div className="absolute z-20 mt-2 max-h-72 w-full overflow-hidden rounded-lg border border-[#F1D6D6] bg-white shadow-lg dark:border-[#213D5E] dark:bg-[#02244C]">
                       <ScrollArea className="max-h-72">
                         {candidates.map((user) => (
                           <button
                             key={user.id}
                             type="button"
                             onClick={() => addUser(user.id)}
-                            className="flex w-full items-center justify-between gap-3 border-b border-[#F8EAEA] px-3 py-2 text-left text-sm last:border-b-0 hover:bg-[#FFF1F1] dark:border-[#462123] dark:hover:bg-[#361315]"
+                            className="flex w-full items-center justify-between gap-3 border-b border-[#F8EAEA] px-3 py-2 text-left text-sm last:border-b-0 hover:bg-[#FFF1F1] dark:border-[#213D5E] dark:hover:bg-[#361315]"
                           >
                             <span className="min-w-0">
                               <span className="block truncate font-medium">{user.email}</span>
-                              <span className="block truncate text-xs text-[#8B6B6B]">{user.id}</span>
+                              <span className="block truncate text-xs text-[#8B6B6B] dark:text-[#7FACF2]">{user.id}</span>
                             </span>
                             <Badge variant="outline">{user.system_role === "admin" ? "管理员" : "用户"}</Badge>
                           </button>
@@ -134,15 +134,15 @@ export default function AdminUserLeaderboardSettingsPage() {
                     </div>
                   )}
                 </div>
-                <div className="min-h-10 rounded-lg bg-[#FFF7F7] p-3 dark:bg-[#19090A]">
+                <div className="min-h-10 rounded-lg bg-[#FFF7F7] p-3 dark:bg-[#011226]">
                   {selectedUsers.length === 0 ? (
-                    <span className="text-sm text-[#8B6B6B]">暂无排除账号</span>
+                    <span className="text-sm text-[#8B6B6B] dark:text-[#7FACF2]">暂无排除账号</span>
                   ) : (
                     <div className="flex flex-wrap gap-2">
                       {selectedUsers.map((user) => (
                         <span
                           key={user.id}
-                          className="inline-flex max-w-[280px] items-center gap-1.5 rounded-full border border-[#F1D6D6] bg-white px-3 py-1.5 text-xs text-[#7A1F25] shadow-sm dark:border-[#462123] dark:bg-[#230D0F] dark:text-[#F2B8BB]"
+                          className="inline-flex max-w-[280px] items-center gap-1.5 rounded-full border border-[#F1D6D6] bg-white px-3 py-1.5 text-xs text-[#7A1F25] shadow-sm dark:border-[#213D5E] dark:bg-[#02244C] dark:text-[#7FACF2]"
                           title={userLabel(user)}
                         >
                           <span className="truncate">{userLabel(user)}</span>
@@ -157,14 +157,14 @@ export default function AdminUserLeaderboardSettingsPage() {
               </div>
             </section>
 
-            <section className="rounded-lg border border-[#F1D6D6] bg-white p-5 shadow-sm dark:border-[#462123] dark:bg-[#230D0F]">
+            <section className="rounded-lg border border-[#F1D6D6] bg-white p-5 shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]">
               <div className="mb-4 flex items-start justify-between gap-3">
                 <div>
                   <div className="flex items-center gap-2 font-semibold">
-                    <Save className="size-4 text-[#C1121F]" />
+                    <Save className="size-4 text-[#C1121F] dark:text-[#7FACF2]" />
                     统计规则
                   </div>
-                  <p className="mt-1 text-sm text-[#7A5A5A] dark:text-[#D8B8B8]">
+                  <p className="mt-1 text-sm text-[#7A5A5A] dark:text-[#7FACF2]">
                     关闭某项后，该类数据会从榜单、趋势、问题列表和个人统计中移除。
                   </p>
                 </div>
@@ -180,11 +180,11 @@ export default function AdminUserLeaderboardSettingsPage() {
                 ].map(([key, title, desc]) => (
                   <label
                     key={key}
-                    className="flex min-h-28 cursor-pointer items-start justify-between gap-4 rounded-lg border border-[#F1D6D6] bg-[#FFF7F7] p-4 dark:border-[#462123] dark:bg-[#19090A]"
+                    className="flex min-h-28 cursor-pointer items-start justify-between gap-4 rounded-lg border border-[#F1D6D6] bg-[#FFF7F7] p-4 dark:border-[#213D5E] dark:bg-[#011226]"
                   >
                     <span>
                       <span className="block font-medium">{title}</span>
-                      <span className="mt-1 block text-sm leading-6 text-[#7A5A5A] dark:text-[#D8B8B8]">{desc}</span>
+                      <span className="mt-1 block text-sm leading-6 text-[#7A5A5A] dark:text-[#7FACF2]">{desc}</span>
                     </span>
                     <Switch
                       checked={Boolean(settings?.[key as keyof typeof settings])}
diff --git a/frontend-web/src/pages/BusinessChainMappingPage.tsx b/frontend-web/src/pages/BusinessChainMappingPage.tsx
index a3d05703..ae2db62d 100644
--- a/frontend-web/src/pages/BusinessChainMappingPage.tsx
+++ b/frontend-web/src/pages/BusinessChainMappingPage.tsx
@@ -1,5 +1,5 @@
 /**
- * 业务链条管理页 —— 把固定业务码（3Q/6BF/7BF/8BF）绑定到「智能体」+「业务链」。
+ * 配置管理页 —— 把固定业务码（3Q/6BF/7BF/8BF）绑定到「智能体」+「业务链」。
  *
  * 表格三列：业务（只读）/ 智能体 / 业务链。编辑模式下后两列为可搜索下拉：
  *  - 智能体来自 `/api/agents`
@@ -129,7 +129,7 @@ export default function BusinessChainMappingPage() {
       <div className="mx-auto flex min-h-full max-w-[1280px] flex-col gap-5 px-6 py-6 lg:px-8">
         <div className="space-y-1">
           <h1 className={`text-[26px] font-semibold tracking-[0.02em] ${isDark ? "text-slate-50" : "text-[#222222]"}`}>
-            业务链条管理
+            配置管理
           </h1>
           <p className={`text-sm ${isDark ? "text-slate-300/80" : "text-slate-500"}`}>
             为每个业务绑定智能体与业务链。多智能体会商从对应业务自动取用此处配置的业务链。业务链仅可选择「公共」链条。
diff --git a/frontend-web/src/pages/ChatPage.tsx b/frontend-web/src/pages/ChatPage.tsx
index f96db7f6..dacfbe6b 100644
--- a/frontend-web/src/pages/ChatPage.tsx
+++ b/frontend-web/src/pages/ChatPage.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { useRouter } from "next/navigation";
+import { useRouter, useSearchParams } from "next/navigation";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { toast } from "sonner";
 
@@ -15,6 +15,8 @@ import {
   useThreadChat,
 } from "@/components/workspace/chats";
 import { ExportTrigger } from "@/components/workspace/export-trigger";
+import { KnowledgeSaveTrigger } from "@/components/workspace/knowledge-save-trigger";
+import { KnowledgeRagToggle } from "@/components/workspace/knowledge-rag-toggle";
 import { InputBox } from "@/components/workspace/input-box";
 import {
   MessageList,
@@ -41,9 +43,47 @@ import { textOfMessage } from "@/core/threads/utils";
 import { env } from "@/env";
 import { cn } from "@/lib/utils";
 
+const BROWSER_CONTEXT_PARAM_KEYS = [
+  "browser_context",
+  "bc_filename",
+  "bc_size",
+  "bc_path",
+  "bc_prompt",
+] as const;
+
+function clearBrowserContextParamsFromHash() {
+  if (typeof window === "undefined") return;
+  const hash = window.location.hash;
+  if (!hash.startsWith("#")) return;
+  const hashBody = hash.slice(1);
+  const queryStart = hashBody.indexOf("?");
+  if (queryStart < 0) return;
+
+  const path = hashBody.slice(0, queryStart);
+  const search = hashBody.slice(queryStart + 1);
+  const params = new URLSearchParams(search);
+  let changed = false;
+  for (const key of BROWSER_CONTEXT_PARAM_KEYS) {
+    if (params.has(key)) {
+      params.delete(key);
+      changed = true;
+    }
+  }
+  if (!changed) return;
+
+  const nextSearch = params.toString();
+  const nextHash = nextSearch ? `#${path}?${nextSearch}` : `#${path}`;
+  window.history.replaceState(
+    null,
+    "",
+    `${window.location.pathname}${window.location.search}${nextHash}`,
+  );
+}
+
 export default function ChatPage() {
   const routeBase = useRouteBase();
   const router = useRouter();
+  const searchParams = useSearchParams();
   const { t } = useI18n();
   const [showFollowups, setShowFollowups] = useState(false);
   const [hasStartedConversation, setHasStartedConversation] = useState(false);
@@ -62,6 +102,7 @@ export default function ChatPage() {
   const [selectedAgentId, setSelectedAgentId] = useState<string | null>(null);
   const [agentHandoffPending, setAgentHandoffPending] = useState(false);
   const agentHandoffPendingRef = useRef(false);
+  const browserContextAutoSubmitRef = useRef<string | null>(null);
   const { agents: selectorAgents, isLoading: selectorLoading } =
     useAgentSelector();
   const { selectedArtifact } = useArtifacts();
@@ -242,6 +283,75 @@ export default function ChatPage() {
     [sendMessage, threadId],
   );
 
+  useEffect(() => {
+    const token = searchParams.get("browser_context")?.trim();
+    if (!token || browserContextAutoSubmitRef.current === token) {
+      return;
+    }
+    if (!threadId || isNewThread || thread.isLoading || agentHandoffPending) {
+      return;
+    }
+
+    const consumedKey = `deerflow.browser-context.consumed.${token}`;
+    if (window.sessionStorage.getItem(consumedKey)) {
+      browserContextAutoSubmitRef.current = token;
+      clearBrowserContextParamsFromHash();
+      return;
+    }
+
+    const filename = searchParams.get("bc_filename")?.trim();
+    const path = searchParams.get("bc_path")?.trim();
+    const size = Number(searchParams.get("bc_size") ?? "0");
+    const prompt =
+      searchParams.get("bc_prompt")?.trim() ||
+      "请基于刚刚发送的网页内容，先用中文总结要点，并等待我继续提问。";
+
+    if (!filename || !path || !Number.isFinite(size) || size < 0) {
+      browserContextAutoSubmitRef.current = token;
+      clearBrowserContextParamsFromHash();
+      toast.error("网页上下文参数不完整，无法自动发送到 Deer");
+      return;
+    }
+
+    browserContextAutoSubmitRef.current = token;
+    window.sessionStorage.setItem(consumedKey, "1");
+    clearBrowserContextParamsFromHash();
+    setHasStartedConversation(true);
+
+    void sendMessage(
+      threadId,
+      { text: prompt, files: [] },
+      undefined,
+      {
+        additionalKwargs: {
+          browser_context: {
+            source: "chrome-extension",
+            token,
+          },
+          files: [
+            {
+              filename,
+              size,
+              path,
+              status: "uploaded",
+            },
+          ],
+        },
+      },
+    ).catch((err) => {
+      toast.error(
+        err instanceof Error ? err.message : "网页上下文发送失败，请重试",
+      );
+    });
+  }, [
+    searchParams,
+    threadId,
+    isNewThread,
+    thread.isLoading,
+    agentHandoffPending,
+    sendMessage,
+  ]);
+
   // Persist the picked agent the moment it changes so the next new chat
   // defaults to it — even if the user never sends a message this session.
   // Passing null (the ✕ clear) wipes the stored preference.
@@ -300,7 +410,9 @@ export default function ChatPage() {
                 enabled={tokenUsageEnabled}
                 messages={thread.messages}
               />
+              <KnowledgeRagToggle threadId={threadId} />
               <ExportTrigger threadId={threadId} />
+              <KnowledgeSaveTrigger threadId={threadId} />
               <ArtifactTrigger />
             </div>
           </header>
diff --git a/frontend-web/src/pages/ChatsPage.tsx b/frontend-web/src/pages/ChatsPage.tsx
index d4ba237c..ed2a3f9c 100644
--- a/frontend-web/src/pages/ChatsPage.tsx
+++ b/frontend-web/src/pages/ChatsPage.tsx
@@ -1,95 +1,256 @@
-"use client";
-
-import { DownloadIcon } from "lucide-react";
-import Link from "next/link";
-import { useEffect, useMemo, useState } from "react";
-
-import { Button } from "@/components/ui/button";
-import { Input } from "@/components/ui/input";
-import { ScrollArea } from "@/components/ui/scroll-area";
-import { ImportConversationsDialog } from "@/components/workspace/thread-share-dialogs";
-import {
-  WorkspaceBody,
-  WorkspaceContainer,
-  WorkspaceHeader,
-} from "@/components/workspace/workspace-container";
-import { useI18n } from "@/core/i18n/hooks";
-import { useThreads } from "@/core/threads/hooks";
-import { usePathOfThread, titleOfThread } from "@/core/threads/utils";
-import { formatTimeAgo } from "@/core/utils/datetime";
-import { desensitize } from "@/lib/desensitize";
-
-export default function ChatsPage() {
-  const pathOfThread = usePathOfThread();
-  const { t } = useI18n();
-  const { data: threads } = useThreads();
-  const [search, setSearch] = useState("");
-  const [importOpen, setImportOpen] = useState(false);
-
-  useEffect(() => {
-    document.title = `${t.pages.chats} - ${t.pages.appName}`;
-  }, [t.pages.chats, t.pages.appName]);
-
-  const filteredThreads = useMemo(() => {
-    return threads?.filter((thread) => {
-      return (
-        thread.metadata?.thread_type !== "scheduler" &&
-        thread.metadata?.thread_type !== "roundtable" &&
-        titleOfThread(thread).toLowerCase().includes(search.toLowerCase())
-      );
-    });
-  }, [threads, search]);
-  return (
-    <WorkspaceContainer>
-      <WorkspaceHeader></WorkspaceHeader>
-      <WorkspaceBody>
-        <div className="flex size-full flex-col">
-          <header className="flex shrink-0 flex-col items-center gap-3 pt-8">
-            <div className="flex w-full max-w-(--container-width-md) items-center justify-end">
-              <Button
-                variant="outline"
-                size="sm"
-                onClick={() => setImportOpen(true)}
-              >
-                <DownloadIcon className="size-4" />
-                {t.threadShare.importChats}
-              </Button>
-            </div>
-            <Input
-              type="search"
-              className="h-12 w-full max-w-(--container-width-md) text-xl"
-              placeholder={t.chats.searchChats}
-              autoFocus
-              value={search}
-              onChange={(e) => setSearch(e.target.value)}
-            />
-          </header>
-          <main className="min-h-0 flex-1">
-            <ScrollArea className="size-full py-4">
-              <div className="mx-auto flex size-full max-w-(--container-width-md) flex-col">
-                {filteredThreads?.map((thread) => (
-                  <Link key={thread.thread_id} href={pathOfThread(thread)}>
-                    <div className="flex flex-col gap-2 border-b p-4">
-                      <div>
-                        <div>{desensitize(titleOfThread(thread, t.pages.newChat))}</div>
-                      </div>
-                      {thread.updated_at && (
-                        <div className="text-muted-foreground text-sm">
-                          {formatTimeAgo(thread.updated_at)}
-                        </div>
-                      )}
-                    </div>
-                  </Link>
-                ))}
-              </div>
-            </ScrollArea>
-          </main>
-        </div>
-      </WorkspaceBody>
-      <ImportConversationsDialog
-        open={importOpen}
-        onOpenChange={setImportOpen}
-      />
-    </WorkspaceContainer>
-  );
-}
+"use client";
+
+import {
+  ChevronLeft,
+  ChevronRight,
+  DownloadIcon,
+  Pin,
+  PinOff,
+  Star,
+} from "lucide-react";
+import Link from "next/link";
+import { useEffect, useMemo, useState } from "react";
+
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { ImportConversationsDialog } from "@/components/workspace/thread-share-dialogs";
+import {
+  WorkspaceBody,
+  WorkspaceContainer,
+  WorkspaceHeader,
+} from "@/components/workspace/workspace-container";
+import { useI18n } from "@/core/i18n/hooks";
+import {
+  useThreads,
+  useToggleThreadFavorite,
+  useToggleThreadPin,
+} from "@/core/threads/hooks";
+import type { AgentThread } from "@/core/threads/types";
+import {
+  isThreadFavorite,
+  isThreadPinned,
+  usePathOfThread,
+  titleOfThread,
+} from "@/core/threads/utils";
+import { formatTimeAgo } from "@/core/utils/datetime";
+import { desensitize } from "@/lib/desensitize";
+import { cn } from "@/lib/utils";
+
+const PAGE_SIZE = 20;
+
+export default function ChatsPage() {
+  const pathOfThread = usePathOfThread();
+  const { t } = useI18n();
+  const { data: threads } = useThreads();
+  const { toggle: togglePin } = useToggleThreadPin();
+  const { toggle: toggleFavorite } = useToggleThreadFavorite();
+  const [search, setSearch] = useState("");
+  const [onlyFavorites, setOnlyFavorites] = useState(false);
+  const [page, setPage] = useState(1);
+  const [importOpen, setImportOpen] = useState(false);
+
+  useEffect(() => {
+    document.title = `${t.pages.chats} - ${t.pages.appName}`;
+  }, [t.pages.chats, t.pages.appName]);
+
+  // Reset to the first page whenever the filtered result set changes.
+  useEffect(() => {
+    setPage(1);
+  }, [search, onlyFavorites]);
+
+  const filteredThreads = useMemo(() => {
+    return (threads ?? []).filter((thread) => {
+      if (
+        thread.metadata?.thread_type === "scheduler" ||
+        thread.metadata?.thread_type === "roundtable"
+      ) {
+        return false;
+      }
+      if (onlyFavorites && !isThreadFavorite(thread)) {
+        return false;
+      }
+      return titleOfThread(thread)
+        .toLowerCase()
+        .includes(search.toLowerCase());
+    });
+  }, [threads, search, onlyFavorites]);
+
+  // Pinned conversations are surfaced in their own section on the first page
+  // only, and excluded from the paginated list (so they don't repeat on every
+  // page as the user pages through history).
+  const pinnedThreads = useMemo(
+    () => filteredThreads.filter(isThreadPinned),
+    [filteredThreads],
+  );
+  const restThreads = useMemo(
+    () => filteredThreads.filter((t) => !isThreadPinned(t)),
+    [filteredThreads],
+  );
+
+  const totalPages = Math.max(1, Math.ceil(restThreads.length / PAGE_SIZE));
+  const currentPage = Math.min(page, totalPages);
+  const pagedThreads = restThreads.slice(
+    (currentPage - 1) * PAGE_SIZE,
+    currentPage * PAGE_SIZE,
+  );
+
+  const renderThread = (thread: AgentThread) => {
+    const pinned = isThreadPinned(thread);
+    const favorited = isThreadFavorite(thread);
+    return (
+      <div
+        key={thread.thread_id}
+        className="group/chat-row relative flex flex-col gap-2 border-b"
+      >
+        <Link href={pathOfThread(thread)} className="block p-4 pr-24">
+          <div className="flex items-center gap-1.5">
+            {pinned && (
+              <Pin className="size-3.5 shrink-0 text-muted-foreground/70" />
+            )}
+            <span className="truncate">
+              {desensitize(titleOfThread(thread, t.pages.newChat))}
+            </span>
+          </div>
+          {thread.updated_at && (
+            <div className="text-muted-foreground mt-2 text-sm">
+              {formatTimeAgo(thread.updated_at)}
+            </div>
+          )}
+        </Link>
+        {/* Row actions — kept out of the Link so clicks don't navigate. */}
+        <div className="absolute right-3 top-3 flex items-center gap-1 opacity-0 transition-opacity group-hover/chat-row:opacity-100 focus-within:opacity-100">
+          <Button
+            variant="ghost"
+            size="icon"
+            className="size-8"
+            title={favorited ? t.common.unfavorite : t.common.favorite}
+            onClick={() => toggleFavorite(thread.thread_id, !favorited)}
+          >
+            <Star
+              className={cn(
+                "size-4",
+                favorited
+                  ? "fill-amber-400 text-amber-400"
+                  : "text-muted-foreground",
+              )}
+            />
+          </Button>
+          <Button
+            variant="ghost"
+            size="icon"
+            className="size-8"
+            title={pinned ? t.common.unpin : t.common.pin}
+            onClick={() => togglePin(thread.thread_id, !pinned)}
+          >
+            {pinned ? (
+              <PinOff className="size-4 text-muted-foreground" />
+            ) : (
+              <Pin className="size-4 text-muted-foreground" />
+            )}
+          </Button>
+        </div>
+      </div>
+    );
+  };
+
+  const isEmpty = filteredThreads.length === 0;
+
+  return (
+    <WorkspaceContainer>
+      <WorkspaceHeader></WorkspaceHeader>
+      <WorkspaceBody>
+        <div className="flex size-full flex-col">
+          <header className="flex shrink-0 flex-col items-center gap-3 pt-8">
+            <div className="flex w-full max-w-(--container-width-md) items-center justify-between gap-2">
+              <div className="flex items-center gap-1">
+                <Button
+                  variant={onlyFavorites ? "outline" : "secondary"}
+                  size="sm"
+                  onClick={() => setOnlyFavorites(false)}
+                >
+                  {t.chats.allChats}
+                </Button>
+                <Button
+                  variant={onlyFavorites ? "secondary" : "outline"}
+                  size="sm"
+                  onClick={() => setOnlyFavorites(true)}
+                >
+                  <Star className="size-4" />
+                  {t.chats.favorites}
+                </Button>
+              </div>
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={() => setImportOpen(true)}
+              >
+                <DownloadIcon className="size-4" />
+                {t.threadShare.importChats}
+              </Button>
+            </div>
+            <Input
+              type="search"
+              className="h-12 w-full max-w-(--container-width-md) text-xl"
+              placeholder={t.chats.searchChats}
+              autoFocus
+              value={search}
+              onChange={(e) => setSearch(e.target.value)}
+            />
+          </header>
+          <main className="min-h-0 flex-1">
+            <ScrollArea className="size-full py-4">
+              <div className="mx-auto flex size-full max-w-(--container-width-md) flex-col">
+                {currentPage === 1 && pinnedThreads.length > 0 && (
+                  <>
+                    <div className="text-muted-foreground/70 px-4 pb-1 pt-2 text-xs font-semibold tracking-wider uppercase">
+                      {t.chats.pinnedSection}
+                    </div>
+                    {pinnedThreads.map(renderThread)}
+                  </>
+                )}
+                {pagedThreads.map(renderThread)}
+                {isEmpty && (
+                  <div className="text-muted-foreground py-16 text-center text-sm">
+                    {onlyFavorites ? t.chats.noFavorites : t.chats.noChats}
+                  </div>
+                )}
+                {totalPages > 1 && (
+                  <div className="flex items-center justify-center gap-3 py-6">
+                    <Button
+                      variant="outline"
+                      size="sm"
+                      disabled={currentPage <= 1}
+                      onClick={() => setPage((p) => Math.max(1, p - 1))}
+                    >
+                      <ChevronLeft className="size-4" />
+                      {t.chats.prevPage}
+                    </Button>
+                    <span className="text-muted-foreground text-sm tabular-nums">
+                      {currentPage} / {totalPages}
+                    </span>
+                    <Button
+                      variant="outline"
+                      size="sm"
+                      disabled={currentPage >= totalPages}
+                      onClick={() =>
+                        setPage((p) => Math.min(totalPages, p + 1))
+                      }
+                    >
+                      {t.chats.nextPage}
+                      <ChevronRight className="size-4" />
+                    </Button>
+                  </div>
+                )}
+              </div>
+            </ScrollArea>
+          </main>
+        </div>
+      </WorkspaceBody>
+      <ImportConversationsDialog
+        open={importOpen}
+        onOpenChange={setImportOpen}
+      />
+    </WorkspaceContainer>
+  );
+}
diff --git a/frontend-web/src/pages/KnowledgeBasePage.tsx b/frontend-web/src/pages/KnowledgeBasePage.tsx
new file mode 100644
index 00000000..59c2a3e0
--- /dev/null
+++ b/frontend-web/src/pages/KnowledgeBasePage.tsx
@@ -0,0 +1,821 @@
+import {
+  BookOpen,
+  Copy,
+  ExternalLink,
+  Loader2,
+  Network,
+  Pencil,
+  Plus,
+  RefreshCw,
+  Save,
+  Search,
+  Sparkles,
+  Trash2,
+  X,
+} from "lucide-react";
+import { useEffect, useMemo, useState } from "react";
+import { useNavigate, useParams } from "react-router-dom";
+import { toast } from "sonner";
+
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { Textarea } from "@/components/ui/textarea";
+import { ModelNameSelect } from "@/components/workspace/model-name-select";
+import {
+  useKnowledgeActions,
+  useKnowledgeDuplicates,
+  useKnowledgeNote,
+  useKnowledgeNotes,
+  useNoteWikilinks,
+  useVaultPage,
+} from "@/core/knowledge/hooks";
+import type { KnowledgeNote } from "@/core/knowledge/types";
+import { cn } from "@/lib/utils";
+import MarkdownRenderer, {
+  type WikiLinkTarget,
+} from "@/strategy-components/MarkdownRenderer";
+
+const SOURCE_TYPE_LABELS: Record<string, string> = {
+  thread: "对话",
+  search: "检索",
+  tool: "工具",
+  file: "文件",
+  manual: "手动",
+  report: "报告",
+};
+
+const STATUS_LABELS: Record<string, string> = {
+  draft: "草稿",
+  approved: "已批准",
+  archived: "已归档",
+};
+
+/** Human label for an audit actor: prefer the resolved name (email), else a short id. */
+function actorLabel(name?: string | null, id?: string | null): string {
+  if (name && name.trim()) return name.trim();
+  if (id && id.trim()) return `${id.trim().slice(0, 8)}…`;
+  return "—";
+}
+
+const ENTITY_TYPE_META: Record<string, { label: string; className: string }> = {
+  person: { label: "人物", className: "bg-rose-50 text-rose-700 border-rose-200 dark:bg-rose-500/15 dark:text-rose-300 dark:border-rose-500/30" },
+  org: { label: "机构", className: "bg-blue-50 text-blue-700 border-blue-200 dark:bg-blue-500/15 dark:text-blue-300 dark:border-blue-500/30" },
+  product: { label: "产品", className: "bg-violet-50 text-violet-700 border-violet-200 dark:bg-violet-500/15 dark:text-violet-300 dark:border-violet-500/30" },
+  technology: { label: "技术", className: "bg-cyan-50 text-cyan-700 border-cyan-200 dark:bg-cyan-500/15 dark:text-cyan-300 dark:border-cyan-500/30" },
+  concept: { label: "概念", className: "bg-amber-50 text-amber-700 border-amber-200 dark:bg-amber-500/15 dark:text-amber-300 dark:border-amber-500/30" },
+  region: { label: "地区", className: "bg-emerald-50 text-emerald-700 border-emerald-200 dark:bg-emerald-500/15 dark:text-emerald-300 dark:border-emerald-500/30" },
+  country: { label: "国家", className: "bg-emerald-50 text-emerald-700 border-emerald-200 dark:bg-emerald-500/15 dark:text-emerald-300 dark:border-emerald-500/30" },
+};
+
+function entityMeta(type?: string | null) {
+  return (
+    ENTITY_TYPE_META[(type || "").toLowerCase()] ?? {
+      label: "其他",
+      className: "bg-slate-100 text-slate-600 border-slate-200 dark:bg-slate-700/40 dark:text-slate-300 dark:border-slate-600",
+    }
+  );
+}
+
+function useDebounced<T>(value: T, delay = 350): T {
+  const [debounced, setDebounced] = useState(value);
+  useEffect(() => {
+    const id = window.setTimeout(() => setDebounced(value), delay);
+    return () => window.clearTimeout(id);
+  }, [value, delay]);
+  return debounced;
+}
+
+function NoteListItem({
+  note,
+  active,
+  onClick,
+}: {
+  note: KnowledgeNote;
+  active: boolean;
+  onClick: () => void;
+}) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      className={cn(
+        "flex w-full flex-col gap-1 rounded-md border p-3 text-left transition-colors",
+        active
+          ? "border-primary bg-primary/5"
+          : "border-border/70 hover:bg-muted/50",
+      )}
+    >
+      <div className="flex items-center justify-between gap-2">
+        <span className="line-clamp-1 text-sm font-medium">{note.title}</span>
+        <Badge variant="outline" className="shrink-0 text-[10px]">
+          {SOURCE_TYPE_LABELS[note.source_type] ?? note.source_type}
+        </Badge>
+      </div>
+      {note.summary ? (
+        <span className="text-muted-foreground line-clamp-2 text-xs">
+          {note.summary}
+        </span>
+      ) : null}
+      <div className="mt-1 flex flex-wrap items-center gap-1">
+        {note.tags.slice(0, 4).map((tag) => (
+          <span
+            key={tag}
+            className="bg-muted text-muted-foreground rounded px-1.5 py-0.5 text-[10px]"
+          >
+            #{tag}
+          </span>
+        ))}
+        <span className="text-muted-foreground ml-auto text-[10px]">
+          {note.updated_at?.slice(0, 10)}
+        </span>
+      </div>
+    </button>
+  );
+}
+
+function CreateNoteDialog({
+  open,
+  onOpenChange,
+}: {
+  open: boolean;
+  onOpenChange: (v: boolean) => void;
+}) {
+  const { create } = useKnowledgeActions();
+  const navigate = useNavigate();
+  const [title, setTitle] = useState("");
+  const [tags, setTags] = useState("");
+  const [content, setContent] = useState("");
+
+  const reset = () => {
+    setTitle("");
+    setTags("");
+    setContent("");
+  };
+
+  const handleSubmit = async () => {
+    if (!title.trim()) {
+      toast.error("请输入标题");
+      return;
+    }
+    try {
+      const note = await create.mutateAsync({
+        title: title.trim(),
+        content_md: content || `# ${title.trim()}\n\n`,
+        tags: tags
+          .split(/[,，\s]+/)
+          .map((t) => t.trim())
+          .filter(Boolean),
+        status: "approved",
+      });
+      toast.success("知识已创建");
+      onOpenChange(false);
+      reset();
+      navigate(`/page/workspace/knowledge/${note.id}`);
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : "创建失败");
+    }
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="max-w-2xl">
+        <DialogHeader>
+          <DialogTitle>新建知识</DialogTitle>
+          <DialogDescription>手动创建一条知识笔记，写入共享知识库 vault。</DialogDescription>
+        </DialogHeader>
+        <div className="flex flex-col gap-3">
+          <Input
+            placeholder="标题"
+            value={title}
+            onChange={(e) => setTitle(e.target.value)}
+          />
+          <Input
+            placeholder="标签，使用逗号分隔"
+            value={tags}
+            onChange={(e) => setTags(e.target.value)}
+          />
+          <Textarea
+            placeholder="Markdown 正文"
+            rows={12}
+            value={content}
+            onChange={(e) => setContent(e.target.value)}
+            className="font-mono text-sm"
+          />
+        </div>
+        <DialogFooter>
+          <Button variant="outline" onClick={() => onOpenChange(false)}>
+            取消
+          </Button>
+          <Button onClick={() => void handleSubmit()} disabled={create.isPending}>
+            {create.isPending ? "创建中..." : "创建"}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+function BatchImportDialog({
+  open,
+  onOpenChange,
+}: {
+  open: boolean;
+  onOpenChange: (v: boolean) => void;
+}) {
+  const { batchIngest } = useKnowledgeActions();
+  const [limit, setLimit] = useState(50);
+  const [skipExisting, setSkipExisting] = useState(true);
+  // Optional model override for extraction (null = configured default).
+  const [model, setModel] = useState<string | null>(null);
+
+  const handleRun = async () => {
+    try {
+      const result = await batchIngest.mutateAsync({
+        limit,
+        skip_existing: skipExisting,
+        status: "approved",
+        include_sources: true,
+        model_name: model,
+      });
+      const base = `批量导入完成：新增 ${result.created}，跳过 ${result.skipped}，失败 ${result.failed}`;
+      if (result.llm_fallback && result.llm_fallback > 0) {
+        // The model failed on some threads — they were saved via rule-based
+        // extraction instead. Say so explicitly per the requirement.
+        toast.warning(
+          `${base}；其中 ${result.llm_fallback} 条因大模型异常改用了规则抽取(草稿)`,
+        );
+      } else {
+        toast.success(base);
+      }
+      onOpenChange(false);
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : "批量导入失败");
+    }
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="max-w-md">
+        <DialogHeader>
+          <DialogTitle>批量导入历史线程</DialogTitle>
+          <DialogDescription>
+            扫描你最近的对话线程并沉淀为知识库内容。已沉淀的线程可自动跳过。
+          </DialogDescription>
+        </DialogHeader>
+        <div className="flex flex-col gap-4">
+          <label className="flex items-center justify-between gap-2 text-sm">
+            处理数量上限
+            <Input
+              type="number"
+              min={1}
+              max={500}
+              value={limit}
+              onChange={(e) => setLimit(Number(e.target.value) || 1)}
+              className="w-28"
+            />
+          </label>
+          <label className="flex items-center justify-between gap-2 text-sm">
+            跳过已沉淀线程
+            <input
+              type="checkbox"
+              checked={skipExisting}
+              onChange={(e) => setSkipExisting(e.target.checked)}
+              className="size-4"
+            />
+          </label>
+          <label className="flex items-center justify-between gap-2 text-sm">
+            提炼大模型
+            <ModelNameSelect
+              value={model}
+              onChange={setModel}
+              disabled={batchIngest.isPending}
+              triggerClassName="h-9 w-[11rem]"
+            />
+          </label>
+        </div>
+        <DialogFooter>
+          <Button variant="outline" onClick={() => onOpenChange(false)}>
+            取消
+          </Button>
+          <Button onClick={() => void handleRun()} disabled={batchIngest.isPending}>
+            {batchIngest.isPending ? "导入中..." : "开始导入"}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+function DedupDialog({
+  open,
+  onOpenChange,
+}: {
+  open: boolean;
+  onOpenChange: (v: boolean) => void;
+}) {
+  const { data: groups = [], isLoading } = useKnowledgeDuplicates(open);
+  const { merge } = useKnowledgeActions();
+
+  const handleMerge = async (primaryId: string, duplicateIds: string[]) => {
+    try {
+      await merge.mutateAsync({ primaryId, duplicateIds });
+      toast.success("已合并重复知识");
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : "合并失败");
+    }
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="max-w-2xl">
+        <DialogHeader>
+          <DialogTitle>查重与合并</DialogTitle>
+          <DialogDescription>
+            基于标题/摘要相似度与内容哈希检测重复知识；合并会把重复项归档并把来源并入主条目。
+          </DialogDescription>
+        </DialogHeader>
+        <div className="max-h-[60vh] overflow-auto">
+          {isLoading ? (
+            <div className="text-muted-foreground p-4 text-sm">检测中...</div>
+          ) : groups.length === 0 ? (
+            <div className="text-muted-foreground rounded-md border border-dashed p-6 text-center text-sm">
+              未发现明显重复的知识。
+            </div>
+          ) : (
+            <ul className="flex flex-col gap-3">
+              {groups.map((g) => (
+                <li key={g.primary.id} className="rounded-md border p-3">
+                  <div className="mb-2 text-sm font-medium">
+                    保留：{g.primary.title || g.primary.id}
+                  </div>
+                  <ul className="mb-2 flex flex-col gap-1">
+                    {g.duplicates.map((d) => (
+                      <li key={d.id} className="text-muted-foreground text-xs">
+                        合并：{d.title || d.id}（相似度 {Math.round(d.score * 100)}%）
+                      </li>
+                    ))}
+                  </ul>
+                  <Button
+                    size="sm"
+                    variant="outline"
+                    onClick={() =>
+                      void handleMerge(
+                        g.primary.id,
+                        g.duplicates.map((d) => d.id),
+                      )
+                    }
+                    disabled={merge.isPending}
+                  >
+                    合并到主条目
+                  </Button>
+                </li>
+              ))}
+            </ul>
+          )}
+        </div>
+        <DialogFooter>
+          <Button variant="outline" onClick={() => onOpenChange(false)}>
+            关闭
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+function VaultPageDialog({
+  path,
+  onOpenChange,
+}: {
+  path: string | null;
+  onOpenChange: (open: boolean) => void;
+}) {
+  const { data: page, isLoading } = useVaultPage(path ?? undefined);
+  return (
+    <Dialog open={!!path} onOpenChange={onOpenChange}>
+      <DialogContent className="max-w-2xl">
+        <DialogHeader>
+          <DialogTitle>{page?.title || "知识库页面"}</DialogTitle>
+          <DialogDescription>{path}</DialogDescription>
+        </DialogHeader>
+        <ScrollArea className="max-h-[60vh]">
+          <div className="p-1">
+            {isLoading ? (
+              <div className="text-muted-foreground p-4 text-sm">加载中...</div>
+            ) : page ? (
+              <MarkdownRenderer content={page.content_md} />
+            ) : (
+              <div className="text-muted-foreground p-4 text-sm">页面不存在</div>
+            )}
+          </div>
+        </ScrollArea>
+        <DialogFooter>
+          <Button variant="outline" onClick={() => onOpenChange(false)}>
+            关闭
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+function NoteDetail({ noteId }: { noteId: string }) {
+  const navigate = useNavigate();
+  const { data: note, isLoading } = useKnowledgeNote(noteId);
+  const { data: wikiLinks } = useNoteWikilinks(noteId);
+  const { update, remove } = useKnowledgeActions();
+  const [vaultPath, setVaultPath] = useState<string | null>(null);
+
+  const handleWikiLink = (link: WikiLinkTarget) => {
+    if (link.kind === "note" && link.note_id) {
+      navigate(`/page/workspace/knowledge/${link.note_id}`);
+    } else if (link.kind === "vault" && link.vault_path) {
+      setVaultPath(link.vault_path);
+    }
+  };
+  const [editing, setEditing] = useState(false);
+  const [draftTitle, setDraftTitle] = useState("");
+  const [draftTags, setDraftTags] = useState("");
+  const [draftContent, setDraftContent] = useState("");
+  const [draftStatus, setDraftStatus] = useState("approved");
+
+  useEffect(() => {
+    setEditing(false);
+    setVaultPath(null);
+  }, [noteId]);
+
+  useEffect(() => {
+    if (note) {
+      setDraftTitle(note.title);
+      setDraftTags(note.tags.join(", "));
+      setDraftContent(note.content_md);
+      setDraftStatus(note.status);
+    }
+  }, [note]);
+
+  if (isLoading || !note) {
+    return (
+      <div className="text-muted-foreground flex h-full items-center justify-center text-sm">
+        {isLoading ? "加载中..." : "知识不存在"}
+      </div>
+    );
+  }
+
+  const handleSave = async () => {
+    try {
+      await update.mutateAsync({
+        noteId: note.id,
+        data: {
+          title: draftTitle.trim() || note.title,
+          content_md: draftContent,
+          tags: draftTags
+            .split(/[,，\s]+/)
+            .map((t) => t.trim())
+            .filter(Boolean),
+          status: draftStatus,
+        },
+      });
+      toast.success("已保存");
+      setEditing(false);
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : "保存失败");
+    }
+  };
+
+  const handleArchive = async () => {
+    try {
+      await remove.mutateAsync({ noteId: note.id });
+      toast.success("已归档");
+      navigate("/page/workspace/knowledge");
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : "归档失败");
+    }
+  };
+
+  return (
+    <div className="flex h-full flex-col">
+      <div className="flex items-center justify-between gap-2 border-b p-3">
+        <div className="flex items-center gap-2">
+          <Badge variant="outline">
+            {SOURCE_TYPE_LABELS[note.source_type] ?? note.source_type}
+          </Badge>
+          <Badge variant="secondary">{STATUS_LABELS[note.status] ?? note.status}</Badge>
+        </div>
+        <div className="flex items-center gap-2">
+          {editing ? (
+            <>
+              <Button size="sm" variant="ghost" onClick={() => setEditing(false)}>
+                <X className="size-4" /> 取消
+              </Button>
+              <Button size="sm" onClick={() => void handleSave()} disabled={update.isPending}>
+                <Save className="size-4" /> 保存
+              </Button>
+            </>
+          ) : (
+            <>
+              <Button size="sm" variant="ghost" onClick={() => setEditing(true)}>
+                <Pencil className="size-4" /> 编辑
+              </Button>
+              <Button
+                size="sm"
+                variant="ghost"
+                className="text-destructive"
+                onClick={() => void handleArchive()}
+                disabled={remove.isPending}
+              >
+                <Trash2 className="size-4" /> 归档
+              </Button>
+            </>
+          )}
+        </div>
+      </div>
+
+      <ScrollArea className="min-h-0 flex-1">
+        <div className="p-4">
+          {editing ? (
+            <div className="flex flex-col gap-3">
+              <Input
+                value={draftTitle}
+                onChange={(e) => setDraftTitle(e.target.value)}
+                placeholder="标题"
+              />
+              <div className="flex items-center gap-2">
+                <Input
+                  value={draftTags}
+                  onChange={(e) => setDraftTags(e.target.value)}
+                  placeholder="标签，逗号分隔"
+                />
+                <Select value={draftStatus} onValueChange={setDraftStatus}>
+                  <SelectTrigger className="w-32">
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="draft">草稿</SelectItem>
+                    <SelectItem value="approved">已批准</SelectItem>
+                    <SelectItem value="archived">已归档</SelectItem>
+                  </SelectContent>
+                </Select>
+              </div>
+              <Textarea
+                rows={20}
+                value={draftContent}
+                onChange={(e) => setDraftContent(e.target.value)}
+                className="font-mono text-sm"
+              />
+            </div>
+          ) : (
+            <>
+              <h1 className="mb-3 text-xl font-semibold">{note.title}</h1>
+
+              {note.tags.length > 0 ? (
+                <div className="mb-2 flex flex-wrap items-center gap-1.5">
+                  {note.tags.map((tag) => (
+                    <span
+                      key={tag}
+                      className="border-primary/20 bg-primary/5 text-primary/90 hover:bg-primary/10 inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-medium transition-colors"
+                    >
+                      #{tag}
+                    </span>
+                  ))}
+                </div>
+              ) : null}
+
+              {note.entities && note.entities.length > 0 ? (
+                <div className="mb-4 flex flex-wrap items-center gap-1.5">
+                  <span className="text-muted-foreground mr-0.5 inline-flex items-center gap-1 text-xs">
+                    <Sparkles className="size-3" /> 实体
+                  </span>
+                  {note.entities.map((ent) => {
+                    const meta = entityMeta(ent.entity_type);
+                    return (
+                      <span
+                        key={`${ent.name}-${ent.entity_type ?? ""}`}
+                        title={meta.label}
+                        className={cn(
+                          "inline-flex items-center gap-1.5 rounded-full border py-1 pl-2 pr-1 text-xs font-medium",
+                          meta.className,
+                        )}
+                      >
+                        <span className="size-1.5 shrink-0 rounded-full bg-current opacity-70" />
+                        <span>{ent.name}</span>
+                        <span className="rounded-full bg-current/15 px-1.5 py-0.5 text-[10px] leading-none opacity-90">
+                          {meta.label}
+                        </span>
+                      </span>
+                    );
+                  })}
+                </div>
+              ) : null}
+
+              <MarkdownRenderer
+                content={note.content_md}
+                wikiLinks={wikiLinks}
+                onWikiLinkClick={handleWikiLink}
+              />
+
+              {note.sources && note.sources.length > 0 ? (
+                <div className="mt-6 border-t pt-4">
+                  <h2 className="mb-2 text-sm font-semibold">来源</h2>
+                  <ul className="flex flex-col gap-2">
+                    {note.sources.map((src) => (
+                      <li key={src.id} className="text-sm">
+                        {src.url ? (
+                          <a
+                            href={src.url}
+                            target="_blank"
+                            rel="noreferrer"
+                            className="text-primary inline-flex items-center gap-1 hover:underline"
+                          >
+                            {src.title || src.url}
+                            <ExternalLink className="size-3" />
+                          </a>
+                        ) : src.thread_id ? (
+                          <button
+                            type="button"
+                            className="text-primary hover:underline"
+                            onClick={() =>
+                              navigate(`/page/workspace/chats/${src.thread_id}`)
+                            }
+                          >
+                            {src.title || `对话 ${src.thread_id.slice(0, 8)}`}
+                          </button>
+                        ) : (
+                          <span>{src.title || src.tool_name || "来源"}</span>
+                        )}
+                        {src.snippet ? (
+                          <p className="text-muted-foreground mt-0.5 line-clamp-2 text-xs">
+                            {src.snippet}
+                          </p>
+                        ) : null}
+                      </li>
+                    ))}
+                  </ul>
+                </div>
+              ) : null}
+
+              <div className="text-muted-foreground mt-6 border-t pt-3 text-xs">
+                创建人 {actorLabel(note.created_by_name, note.created_by)} · 更新人{" "}
+                {actorLabel(note.updated_by_name, note.updated_by)} · 更新于{" "}
+                {note.updated_at?.slice(0, 19).replace("T", " ")}
+              </div>
+            </>
+          )}
+        </div>
+      </ScrollArea>
+      <VaultPageDialog
+        path={vaultPath}
+        onOpenChange={(open) => {
+          if (!open) setVaultPath(null);
+        }}
+      />
+    </div>
+  );
+}
+
+export default function KnowledgeBasePage() {
+  const navigate = useNavigate();
+  const { noteId } = useParams<{ noteId: string }>();
+  const [keyword, setKeyword] = useState("");
+  const debouncedKeyword = useDebounced(keyword);
+  const [sourceType, setSourceType] = useState("all");
+  const [status, setStatus] = useState("all");
+  const [createOpen, setCreateOpen] = useState(false);
+  const [batchOpen, setBatchOpen] = useState(false);
+  const [dedupOpen, setDedupOpen] = useState(false);
+
+  const params = useMemo(
+    () => ({
+      keyword: debouncedKeyword || undefined,
+      source_type: sourceType === "all" ? undefined : sourceType,
+      status: status === "all" ? undefined : status,
+      limit: 50,
+    }),
+    [debouncedKeyword, sourceType, status],
+  );
+
+  const { data, isLoading } = useKnowledgeNotes(params);
+  const notes = data?.items ?? [];
+
+  return (
+    <div className="flex size-full min-h-0 flex-col">
+      <header className="flex flex-wrap items-center gap-2 border-b p-3">
+        <BookOpen className="size-5" />
+        <h1 className="mr-2 text-base font-semibold">知识库</h1>
+        <div className="relative">
+          <Search className="text-muted-foreground absolute left-2 top-1/2 size-4 -translate-y-1/2" />
+          <Input
+            value={keyword}
+            onChange={(e) => setKeyword(e.target.value)}
+            placeholder="搜索标题 / 摘要 / 正文 / 标签"
+            className="w-64 pl-8"
+          />
+        </div>
+        <Select value={sourceType} onValueChange={setSourceType}>
+          <SelectTrigger className="w-28">
+            <SelectValue placeholder="来源" />
+          </SelectTrigger>
+          <SelectContent>
+            <SelectItem value="all">全部来源</SelectItem>
+            {Object.entries(SOURCE_TYPE_LABELS).map(([v, label]) => (
+              <SelectItem key={v} value={v}>
+                {label}
+              </SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+        <Select value={status} onValueChange={setStatus}>
+          <SelectTrigger className="w-28">
+            <SelectValue placeholder="状态" />
+          </SelectTrigger>
+          <SelectContent>
+            <SelectItem value="all">全部状态</SelectItem>
+            <SelectItem value="draft">草稿</SelectItem>
+            <SelectItem value="approved">已批准</SelectItem>
+            <SelectItem value="archived">已归档</SelectItem>
+          </SelectContent>
+        </Select>
+        <div className="ml-auto flex items-center gap-2">
+          <Button variant="outline" size="sm" onClick={() => setBatchOpen(true)}>
+            <RefreshCw className="size-4" /> 批量导入
+          </Button>
+          <Button variant="outline" size="sm" onClick={() => setDedupOpen(true)}>
+            <Copy className="size-4" /> 查重
+          </Button>
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={() => navigate("/page/workspace/knowledge/graph")}
+          >
+            <Network className="size-4" /> 图谱
+          </Button>
+          <Button size="sm" onClick={() => setCreateOpen(true)}>
+            <Plus className="size-4" /> 新建
+          </Button>
+        </div>
+      </header>
+
+      <div className="grid min-h-0 flex-1 grid-cols-1 lg:grid-cols-[360px_minmax(0,1fr)]">
+        <div className="flex min-h-0 flex-col border-r">
+          <ScrollArea className="min-h-0 flex-1">
+            <div className="flex flex-col gap-2 p-3">
+              {isLoading ? (
+                <div className="text-muted-foreground flex items-center gap-2 p-4 text-sm">
+                  <Loader2 className="size-4 animate-spin" /> 加载中...
+                </div>
+              ) : notes.length === 0 ? (
+                <div className="text-muted-foreground rounded-md border border-dashed p-6 text-center text-sm">
+                  暂无知识。点击「新建」或在对话页「保存到知识库」。
+                </div>
+              ) : (
+                notes.map((note) => (
+                  <NoteListItem
+                    key={note.id}
+                    note={note}
+                    active={note.id === noteId}
+                    onClick={() => navigate(`/page/workspace/knowledge/${note.id}`)}
+                  />
+                ))
+              )}
+            </div>
+          </ScrollArea>
+          {data ? (
+            <div className="text-muted-foreground border-t p-2 text-center text-xs">
+              共 {data.total} 条知识
+            </div>
+          ) : null}
+        </div>
+
+        <div className="min-h-0">
+          {noteId ? (
+            <NoteDetail noteId={noteId} />
+          ) : (
+            <div className="text-muted-foreground flex h-full items-center justify-center text-sm">
+              从左侧选择一条知识查看详情
+            </div>
+          )}
+        </div>
+      </div>
+
+      <CreateNoteDialog open={createOpen} onOpenChange={setCreateOpen} />
+      <BatchImportDialog open={batchOpen} onOpenChange={setBatchOpen} />
+      <DedupDialog open={dedupOpen} onOpenChange={setDedupOpen} />
+    </div>
+  );
+}
diff --git a/frontend-web/src/pages/KnowledgeGraphPage.tsx b/frontend-web/src/pages/KnowledgeGraphPage.tsx
new file mode 100644
index 00000000..4cacc1a9
--- /dev/null
+++ b/frontend-web/src/pages/KnowledgeGraphPage.tsx
@@ -0,0 +1,79 @@
+import { ArrowLeft, Loader2, RefreshCw } from "lucide-react";
+import { useCallback, useEffect, useState } from "react";
+import { useNavigate } from "react-router-dom";
+import { toast } from "sonner";
+
+import { Button } from "@/components/ui/button";
+import { knowledgeExportFileUrl } from "@/core/knowledge/api";
+import { useKnowledgeActions } from "@/core/knowledge/hooks";
+
+export default function KnowledgeGraphPage() {
+  const navigate = useNavigate();
+  const { exportGraph } = useKnowledgeActions();
+  const [src, setSrc] = useState<string | null>(null);
+  const [stats, setStats] = useState<{ nodes: number; edges: number } | null>(null);
+
+  const regenerate = useCallback(async () => {
+    try {
+      const result = await exportGraph.mutateAsync();
+      setStats(result.stats);
+      // Cache-bust the iframe so it reflects the freshly generated graph.
+      setSrc(`${knowledgeExportFileUrl("graph.html")}?t=${Date.now()}`);
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : "生成图谱失败");
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  useEffect(() => {
+    void regenerate();
+  }, [regenerate]);
+
+  return (
+    <div className="flex size-full min-h-0 flex-col">
+      <header className="flex items-center gap-2 border-b p-3">
+        <Button
+          variant="ghost"
+          size="sm"
+          onClick={() => navigate("/page/workspace/knowledge")}
+        >
+          <ArrowLeft className="size-4" /> 返回
+        </Button>
+        <h1 className="text-base font-semibold">知识图谱</h1>
+        {stats ? (
+          <span className="text-muted-foreground text-xs">
+            {stats.nodes} 个节点 · {stats.edges} 条关系
+          </span>
+        ) : null}
+        <Button
+          variant="outline"
+          size="sm"
+          className="ml-auto"
+          onClick={() => void regenerate()}
+          disabled={exportGraph.isPending}
+        >
+          {exportGraph.isPending ? (
+            <Loader2 className="size-4 animate-spin" />
+          ) : (
+            <RefreshCw className="size-4" />
+          )}
+          重新生成
+        </Button>
+      </header>
+      <div className="min-h-0 flex-1">
+        {src ? (
+          <iframe
+            src={src}
+            title="知识图谱"
+            className="size-full border-0"
+            sandbox="allow-scripts allow-same-origin"
+          />
+        ) : (
+          <div className="text-muted-foreground flex h-full items-center justify-center text-sm">
+            <Loader2 className="mr-2 size-4 animate-spin" /> 生成图谱中...
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/frontend-web/src/pages/NewAgentPage.tsx b/frontend-web/src/pages/NewAgentPage.tsx
index a99e8407..3a954322 100644
--- a/frontend-web/src/pages/NewAgentPage.tsx
+++ b/frontend-web/src/pages/NewAgentPage.tsx
@@ -105,6 +105,7 @@ export default function NewAgentPage() {
     return enabledSkills.filter(
       (skill) =>
         skill.name.toLowerCase().includes(q) ||
+        (skill.name_zh ?? "").toLowerCase().includes(q) ||
         (skill.description ?? "").toLowerCase().includes(q),
     );
   }, [enabledSkills, skillSearch]);
@@ -590,7 +591,9 @@ export default function NewAgentPage() {
                                   !checked && "text-muted-foreground",
                                 )}
                               >
-                                <span className="truncate">{skill.name}</span>
+                                <span className="truncate">
+                                  {skill.name_zh?.trim() ? skill.name_zh : skill.name}
+                                </span>
                               </Button>
                               <Button
                                 type="button"
diff --git a/frontend-web/src/pages/PrivateSquareSettingsPage.tsx b/frontend-web/src/pages/PrivateSquareSettingsPage.tsx
index 49c79fd5..c679c806 100644
--- a/frontend-web/src/pages/PrivateSquareSettingsPage.tsx
+++ b/frontend-web/src/pages/PrivateSquareSettingsPage.tsx
@@ -35,7 +35,11 @@ const errorToastDarkOptions = {
   icon: <AlertCircle className="size-4 shrink-0 text-[#F5222D]" />,
 } as const;
 
-export default function PrivateSquareSettingsPage() {
+export default function PrivateSquareSettingsPage({
+  embedded = false,
+}: {
+  embedded?: boolean;
+} = {}) {
   const { data, isLoading, error } = usePrivateSquareStatus();
   const update = useUpdatePrivateSquareSettings();
   const { theme } = useTheme();
@@ -95,9 +99,15 @@ export default function PrivateSquareSettingsPage() {
   };
 
   return (
-    <div className="mx-auto flex w-full max-w-2xl flex-col gap-6 px-6 py-10">
+    <div
+      className={
+        embedded
+          ? "flex w-full flex-col gap-6"
+          : "mx-auto flex w-full max-w-2xl flex-col gap-6 px-6 py-10"
+      }
+    >
       <div>
-        <h1 className="text-xl font-semibold">私密广场配置</h1>
+        <h1 className={embedded ? "text-base font-semibold" : "text-xl font-semibold"}>私密广场配置</h1>
         <p className="text-muted-foreground mt-1 text-sm">
           管理员可在此开启「私密广场」，并配置访问密码。开启后，用户可将自己发布的智能体放入私密广场；
           其他用户只有输入下方设置的密码后，才能在「智能体 → 私密广场」页签下查看到这些智能体。
diff --git a/frontend-web/src/pages/PromptPrefixSettingsPage.tsx b/frontend-web/src/pages/PromptPrefixSettingsPage.tsx
index 1250c4e1..65e722c9 100644
--- a/frontend-web/src/pages/PromptPrefixSettingsPage.tsx
+++ b/frontend-web/src/pages/PromptPrefixSettingsPage.tsx
@@ -35,7 +35,11 @@ const errorToastDarkOptions = {
   },
   icon: <AlertCircle className="size-4 shrink-0 text-[#F5222D]" />,
 } as const;
-export default function PromptPrefixSettingsPage() {
+export default function PromptPrefixSettingsPage({
+  embedded = false,
+}: {
+  embedded?: boolean;
+} = {}) {
   const { data, isLoading, error } = usePromptPrefixSettings();
   const update = useUpdatePromptPrefixSettings();
   const { theme } = useTheme();
@@ -83,9 +87,15 @@ export default function PromptPrefixSettingsPage() {
   };
 
   return (
-    <div className="mx-auto flex w-full max-w-2xl flex-col gap-6 px-6 py-10">
+    <div
+      className={
+        embedded
+          ? "flex w-full flex-col gap-6"
+          : "mx-auto flex w-full max-w-2xl flex-col gap-6 px-6 py-10"
+      }
+    >
       <div>
-        <h1 className="text-xl font-semibold">问答前缀配置</h1>
+        <h1 className={embedded ? "text-base font-semibold" : "text-xl font-semibold"}>问答前缀配置</h1>
         <p className="text-muted-foreground mt-1 text-sm">
           管理员可在此配置问答页输入框中的「前缀开关」。开启后，用户在新会话中第一次提问时，
           会将下方配置的前缀文本和原问题拼接后再发送给模型。
diff --git a/frontend-web/src/pages/PublicLeaderboardPage.tsx b/frontend-web/src/pages/PublicLeaderboardPage.tsx
new file mode 100644
index 00000000..df783113
--- /dev/null
+++ b/frontend-web/src/pages/PublicLeaderboardPage.tsx
@@ -0,0 +1,947 @@
+"use client";
+
+import {
+  Activity,
+  Award,
+  BarChart3,
+  Bot,
+  CalendarDays,
+  Crown,
+  Gauge,
+  Layers3,
+  Loader2,
+  Maximize2,
+  Medal,
+  MessageSquareText,
+  MousePointerClick,
+  Search,
+  Sparkles,
+  TrendingUp,
+  Users,
+  type LucideIcon,
+} from "lucide-react";
+import { useEffect, useId, useMemo, useState, type ReactNode } from "react";
+
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Pagination } from "@/components/ui/pagination";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { Tabs, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import type {
+  AdminLeaderboardDimension,
+  AdminLeaderboardOverview,
+  AdminLeaderboardQuestion,
+  AdminLeaderboardResponse,
+  AdminLeaderboardSkill,
+  AdminLeaderboardTrendPoint,
+  AdminLeaderboardUser,
+} from "@/core/admin/api";
+import { getBackendBaseURL } from "@/core/config";
+import { cn } from "@/lib/utils";
+
+type UserRankTab = "activity" | "questions" | "tokens" | "skills" | "efficiency";
+type LeaderboardAccent = "crimson" | "rose" | "amber" | "teal";
+
+const RANK_COLORS = ["#C1121F", "#E11D48", "#F59E0B", "#991B1B", "#B45309"] as const;
+const LEADERBOARD_PAGE_SIZE = 20;
+const RANGE_DAYS = 30;
+
+const accentClasses: Record<LeaderboardAccent, { soft: string; text: string; bar: string; border: string }> = {
+  crimson: {
+    soft: "bg-[#FFF1F1] dark:bg-[#2563EB]/15",
+    text: "text-[#C1121F] dark:text-[#7FACF2]",
+    bar: "bg-[#C1121F] dark:bg-[#2563EB]",
+    border: "border-[#F1D6D6] dark:border-[#213D5E]",
+  },
+  rose: {
+    soft: "bg-[#FFF1F2] dark:bg-rose-400/15",
+    text: "text-[#E11D48] dark:text-rose-200",
+    bar: "bg-[#E11D48]",
+    border: "border-[#FECDD3] dark:border-rose-300/25",
+  },
+  amber: {
+    soft: "bg-[#FFFBEB] dark:bg-amber-300/15",
+    text: "text-[#B45309] dark:text-amber-100",
+    bar: "bg-[#F59E0B]",
+    border: "border-[#FDE68A] dark:border-amber-200/25",
+  },
+  teal: {
+    soft: "bg-[#ECFDF5] dark:bg-teal-300/15",
+    text: "text-[#0F766E] dark:text-teal-100",
+    bar: "bg-[#0F766E]",
+    border: "border-[#A7F3D0] dark:border-teal-200/25",
+  },
+};
+
+function fmtNumber(value?: number | null): string {
+  return Number(value ?? 0).toLocaleString();
+}
+
+function fmtTime(value?: string | null): string {
+  if (!value) return "-";
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? value : date.toLocaleString();
+}
+
+function fmtDate(value?: string | null): string {
+  if (!value) return "";
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? "" : date.toLocaleString("zh-CN", { hour12: false });
+}
+
+function clampText(value: string, max = 120): string {
+  const text = value.trim();
+  return text.length > max ? `${text.slice(0, max)}...` : text;
+}
+
+function userScore(user: AdminLeaderboardUser, tab: UserRankTab): number {
+  if (tab === "questions") return user.qa_count;
+  if (tab === "tokens") return user.total_tokens;
+  if (tab === "skills") return user.skill_call_count;
+  if (tab === "efficiency") {
+    return user.run_count > 0 ? Math.round((user.qa_count / user.run_count) * 100) : 0;
+  }
+  return user.run_count + user.tool_call_count;
+}
+
+function scoreLabel(user: AdminLeaderboardUser, tab: UserRankTab): string {
+  if (tab === "questions") return `${fmtNumber(user.qa_count)} 次问答`;
+  if (tab === "tokens") return `${fmtNumber(user.total_tokens)} tokens`;
+  if (tab === "skills") return `${fmtNumber(user.skill_call_count)} 次技能`;
+  if (tab === "efficiency") {
+    return `${(user.run_count > 0 ? user.qa_count / user.run_count : 0).toFixed(1)} 问答/运行`;
+  }
+  return `${fmtNumber(userScore(user, tab))} 次使用`;
+}
+
+function rankTabDescription(tab: UserRankTab): string {
+  if (tab === "questions") return "问答排行按用户提出有效问题的运行次数排序。";
+  if (tab === "tokens") return "消耗排行按模型输入与输出 Token 总量排序。";
+  if (tab === "skills") return "技能排行按带有技能名称的工具调用次数排序。";
+  if (tab === "efficiency") return "效率排行 = 问答次数 / 运行次数，用来衡量每次运行承载的问答密度。";
+  return "使用排行按运行次数与工具调用次数合计排序。";
+}
+
+function initials(user: AdminLeaderboardUser): string {
+  const source = user.email || user.user_id || "?";
+  return source.slice(0, 1).toUpperCase();
+}
+
+async function fetchPublicLeaderboard(days: number): Promise<AdminLeaderboardResponse> {
+  const res = await fetch(
+    `${getBackendBaseURL()}/api/public/leaderboard?days=${days}&limit=100`,
+    { headers: { Accept: "application/json" } },
+  );
+  if (!res.ok) {
+    const err = (await res.json().catch(() => ({}))) as { detail?: string };
+    throw new Error(err.detail ?? `加载排行榜失败 (HTTP ${res.status})`);
+  }
+  return (await res.json()) as AdminLeaderboardResponse;
+}
+
+export default function PublicLeaderboardPage() {
+  const [data, setData] = useState<AdminLeaderboardResponse | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [tab, setTab] = useState<UserRankTab>("activity");
+  const [query, setQuery] = useState("");
+  const [userPage, setUserPage] = useState(1);
+  const days = RANGE_DAYS;
+
+  useEffect(() => {
+    let cancelled = false;
+    setLoading(true);
+    fetchPublicLeaderboard(days)
+      .then((res) => {
+        if (!cancelled) {
+          setData(res);
+          setError(null);
+        }
+      })
+      .catch((e) => {
+        if (!cancelled) setError(e instanceof Error ? e.message : String(e));
+      })
+      .finally(() => {
+        if (!cancelled) setLoading(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [days]);
+
+  const pending = data?.status === "running" || data?.status === "refreshing";
+
+  // The snapshot may still be computing on first load — poll briefly until ready.
+  useEffect(() => {
+    if (!pending) return;
+    const timer = setInterval(() => {
+      fetchPublicLeaderboard(days)
+        .then((res) => setData(res))
+        .catch(() => undefined);
+    }, 3000);
+    return () => clearInterval(timer);
+  }, [pending, days]);
+
+  const rankedUsers = useMemo(() => {
+    const base = data?.users_by_activity ?? [];
+    const source =
+      tab === "questions"
+        ? data?.users_by_questions
+        : tab === "tokens"
+          ? data?.users_by_tokens
+          : tab === "skills"
+            ? [...base].sort((a, b) => b.skill_call_count - a.skill_call_count)
+            : tab === "efficiency"
+              ? [...base].sort((a, b) => userScore(b, "efficiency") - userScore(a, "efficiency"))
+              : data?.users_by_activity;
+    const needle = query.trim().toLowerCase();
+    return (source ?? []).filter((user) =>
+      needle ? `${user.email} ${user.user_id}`.toLowerCase().includes(needle) : true,
+    );
+  }, [data, query, tab]);
+
+  const overview = data?.overview;
+  const hasRows = rankedUsers.length > 0 || (overview?.total_runs ?? 0) > 0 || (overview?.total_users ?? 0) > 0;
+  const topUsers = rankedUsers.slice(0, 3);
+  const userPageCount = Math.max(1, Math.ceil(rankedUsers.length / LEADERBOARD_PAGE_SIZE));
+  const visibleUsers = useMemo(() => {
+    const start = (userPage - 1) * LEADERBOARD_PAGE_SIZE;
+    return rankedUsers.slice(start, start + LEADERBOARD_PAGE_SIZE);
+  }, [rankedUsers, userPage]);
+
+  useEffect(() => {
+    setUserPage(1);
+  }, [query, tab]);
+
+  useEffect(() => {
+    setUserPage((page) => Math.min(page, userPageCount));
+  }, [userPageCount]);
+
+  return (
+    <div className="min-h-screen w-full bg-[#FFF7F7] text-[#231815] dark:bg-[#011226] dark:text-white">
+      <div className="mx-auto w-full max-w-6xl px-4 py-8 sm:px-6 sm:py-10">
+        {/* 标题区：仅展示，不含任何操作按钮 */}
+        <header className="mb-6">
+          <div className="mb-2 flex items-center gap-2 text-sm text-[#9F343A] dark:text-[#7FACF2]">
+            <Award className="size-4" />
+            公开榜单
+          </div>
+          <h1 className="text-2xl font-semibold tracking-normal sm:text-3xl">用户排行榜</h1>
+          <p className="mt-1 text-sm text-[#7A5A5A] dark:text-[#7FACF2]">
+            展示近 {data?.range_days ?? days} 天用户活跃、问答、Token 消耗、技能与工具热度、模型与 Agent 使用及近期问题。
+            {data?.since && data?.until && (
+              <span className="ml-1">
+                （{fmtDate(data.since).slice(0, 10)} ~ {fmtDate(data.until).slice(0, 10)}）
+              </span>
+            )}
+          </p>
+        </header>
+
+        {loading && !data && (
+          <div className="flex flex-col items-center justify-center gap-3 py-24 text-center text-sm text-[#5F6368] dark:text-slate-400">
+            <Loader2 className="size-5 animate-spin" />
+            正在加载排行榜数据
+          </div>
+        )}
+
+        {error && (
+          <div className="rounded-lg border border-[#FAD2CF] bg-[#FCE8E6] p-5 text-sm text-[#DB4437] dark:border-[#DB4437]/30 dark:bg-[#DB4437]/10 dark:text-[#F28B82]">
+            加载失败：{error}
+          </div>
+        )}
+
+        {data && overview && (
+          <div className="space-y-6">
+            {/* 仅在首次统计、尚无数据时提示；已有数据时后台静默刷新，不再常驻横幅 */}
+            {pending && !hasRows && (
+              <div className="rounded-lg border border-[#F1D6D6] bg-white px-4 py-3 text-sm text-[#7A5A5A] dark:border-[#213D5E] dark:bg-[#02244C] dark:text-[#7FACF2]">
+                <Loader2 className="mr-1 inline size-4 animate-spin" />
+                排行榜正在后台统计，数据会自动刷新。
+              </div>
+            )}
+
+            {/* 概览指标 */}
+            <section className="grid gap-3 md:grid-cols-2 xl:grid-cols-4">
+              <StatCard icon={Users} accent="crimson" label="总用户" value={fmtNumber(overview.total_users)} note={`${fmtNumber(overview.active_users)} 位在当前时间段活跃`} />
+              <StatCard icon={MousePointerClick} accent="teal" label="使用次数" value={fmtNumber(overview.total_runs)} note={`${fmtNumber(overview.total_threads)} 个会话被创建`} />
+              <StatCard icon={MessageSquareText} accent="amber" label="问答次数" value={fmtNumber(overview.total_questions)} note={`失败运行 ${fmtNumber(overview.error_runs)} 次`} />
+              <StatCard icon={Sparkles} accent="rose" label="技能调用" value={fmtNumber(overview.total_skill_calls)} note={`工具总调用 ${fmtNumber(overview.total_tool_calls)} 次`} />
+            </section>
+
+            {/* 衍生洞察 */}
+            <InsightStrip overview={overview} />
+
+            {/* 榜单前三 */}
+            <section className="rounded-lg border border-[#F1D6D6] bg-white p-4 shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]">
+              <div className="mb-4 flex flex-wrap items-center justify-between gap-3">
+                <div>
+                  <h2 className="font-semibold text-[#202124] dark:text-white">榜单前三</h2>
+                  <p className="mt-1 text-sm text-[#5F6368] dark:text-slate-400">{rankTabDescription(tab)}</p>
+                </div>
+                <Tabs value={tab} onValueChange={(value) => setTab(value as UserRankTab)}>
+                  <TabsList>
+                    <TabsTrigger value="activity">使用排行</TabsTrigger>
+                    <TabsTrigger value="questions">问答排行</TabsTrigger>
+                    <TabsTrigger value="tokens">消耗排行</TabsTrigger>
+                    <TabsTrigger value="skills">技能排行</TabsTrigger>
+                    <TabsTrigger value="efficiency">效率排行</TabsTrigger>
+                  </TabsList>
+                </Tabs>
+              </div>
+              <div className="grid gap-3 lg:grid-cols-3">
+                <PodiumCard user={topUsers[0]} rank={1} tab={tab} />
+                <PodiumCard user={topUsers[1]} rank={2} tab={tab} />
+                <PodiumCard user={topUsers[2]} rank={3} tab={tab} />
+              </div>
+            </section>
+
+            {/* 完整排行榜 */}
+            <section className="space-y-4">
+              <div className="flex flex-wrap items-center justify-between gap-3">
+                <div className="flex items-center gap-2">
+                  <BarChart3 className="size-4 text-[#5F6368] dark:text-slate-300" />
+                  <div>
+                    <h2 className="font-semibold text-[#202124] dark:text-white">完整排行榜</h2>
+                    <p className="mt-1 text-xs text-[#6B7280] dark:text-slate-400">{rankTabDescription(tab)}</p>
+                  </div>
+                </div>
+                <div className="relative">
+                  <Search className="absolute left-2.5 top-1/2 size-4 -translate-y-1/2 text-[#80868B]" />
+                  <Input
+                    value={query}
+                    onChange={(event) => setQuery(event.target.value)}
+                    placeholder="搜索用户"
+                    className="h-9 w-56 bg-white pl-8 dark:bg-[#011226]"
+                  />
+                </div>
+              </div>
+              <UserTable users={visibleUsers} tab={tab} rankOffset={(userPage - 1) * LEADERBOARD_PAGE_SIZE} />
+              <div className="flex flex-wrap items-center justify-between gap-3 text-xs text-[#6B7280] dark:text-slate-400">
+                <span>
+                  共 {fmtNumber(rankedUsers.length)} 位用户，当前第 {userPage} / {userPageCount} 页
+                </span>
+                <Pagination
+                  page={userPage}
+                  pageSize={LEADERBOARD_PAGE_SIZE}
+                  total={rankedUsers.length}
+                  onPageChange={setUserPage}
+                />
+              </div>
+            </section>
+
+            {/* 时间趋势 */}
+            <section className="rounded-lg border border-[#F1D6D6] bg-white p-4 shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]">
+              <div className="mb-4 flex flex-wrap items-center justify-between gap-3">
+                <div className="flex items-center gap-2">
+                  <TrendingUp className="size-4 text-[#5F6368] dark:text-slate-300" />
+                  <h2 className="font-semibold text-[#202124] dark:text-white">时间趋势</h2>
+                </div>
+                {data.since && data.until && (
+                  <div className="flex items-center gap-2 text-xs text-[#5F6368] dark:text-slate-400">
+                    <CalendarDays className="size-3.5" />
+                    {fmtDate(data.since).slice(0, 10)} 至 {fmtDate(data.until).slice(0, 10)}
+                  </div>
+                )}
+              </div>
+              <TrendBars points={data.trends} />
+            </section>
+
+            {/* 技能与工具热度 */}
+            <div className="grid gap-5 xl:grid-cols-2">
+              <SkillRanking title="最常用技能" icon={Sparkles} items={data.skills} empty="当前时间段暂无技能调用" />
+              <SkillRanking title="最常用工具" icon={Activity} items={data.tools} empty="当前时间段暂无工具调用" />
+            </div>
+
+            {/* 模型 / Agent / 运行状态 */}
+            <div className="grid gap-5 xl:grid-cols-3">
+              <DimensionRanking title="模型使用排行" icon={Layers3} items={data.models} empty="当前时间段暂无模型调用" />
+              <DimensionRanking title="Agent 使用排行" icon={Bot} items={data.agents} empty="当前时间段暂无 Agent 运行" />
+              <DimensionRanking title="运行状态分布" icon={Gauge} items={data.run_statuses} empty="当前时间段暂无运行状态" />
+            </div>
+
+            {/* 问题 */}
+            <div className="grid gap-5 xl:grid-cols-2">
+              <QuestionPanel title="最近经常问的问题" items={data.frequent_questions} />
+              <QuestionPanel title="最新问题" items={data.recent_questions} />
+            </div>
+          </div>
+        )}
+
+        <footer className="mt-10 border-t border-[#F1D6D6] pt-4 text-center text-xs text-[#8B6B6B] dark:border-[#213D5E] dark:text-[#7FACF2]">
+          {data?.generated_at ? `数据生成于 ${fmtDate(data.generated_at)}` : "仅供查看"}
+        </footer>
+      </div>
+    </div>
+  );
+}
+
+function StatCard({
+  icon: Icon,
+  label,
+  value,
+  note,
+  accent,
+}: {
+  icon: LucideIcon;
+  label: string;
+  value: string;
+  note: string;
+  accent: LeaderboardAccent;
+}) {
+  const color = accentClasses[accent];
+  return (
+    <div className={cn("rounded-lg border bg-white p-4 shadow-sm dark:bg-[#02244C]", color.border)}>
+      <div className="flex items-center justify-between gap-3">
+        <span className="text-sm text-[#5F6368] dark:text-slate-300">{label}</span>
+        <span className={cn("flex size-8 items-center justify-center rounded-md", color.soft, color.text)}>
+          <Icon className="size-4" />
+        </span>
+      </div>
+      <div className="mt-3 text-2xl font-semibold tracking-normal text-[#202124] tabular-nums dark:text-white">
+        {value}
+      </div>
+      <div className="mt-1 text-xs text-[#5F6368] dark:text-slate-400">{note}</div>
+    </div>
+  );
+}
+
+function InsightStrip({ overview }: { overview: AdminLeaderboardOverview }) {
+  const activeUsers = Math.max(1, overview.active_users);
+  const totalRuns = Math.max(1, overview.total_runs);
+  const items = [
+    {
+      label: "人均使用",
+      value: overview.total_runs / activeUsers,
+      unit: "次/活跃用户",
+      description: "当前时间段内，平均每位活跃用户发起了多少次运行。",
+    },
+    {
+      label: "问答密度",
+      value: overview.total_questions / totalRuns,
+      unit: "问答/运行",
+      description: "问答次数 ÷ 运行次数，用来判断每次使用承载了多少有效提问。",
+    },
+    {
+      label: "平均 Token",
+      value: overview.total_tokens / totalRuns,
+      unit: "Token/运行",
+      description: "总 Token ÷ 运行次数，反映单次使用的模型消耗强度。",
+    },
+    {
+      label: "技能覆盖",
+      value: overview.total_tool_calls ? (overview.total_skill_calls / overview.total_tool_calls) * 100 : 0,
+      unit: "%",
+      description: "技能调用 ÷ 工具总调用，越高说明用户越多依赖已配置技能能力。",
+    },
+    {
+      label: "失败率",
+      value: (overview.error_runs / totalRuns) * 100,
+      unit: "%",
+      description: "失败运行 ÷ 总运行，用来快速发现稳定性或配置问题。",
+    },
+  ];
+  return (
+    <section className="grid gap-3 md:grid-cols-5">
+      {items.map((item) => (
+        <div key={item.label} className="rounded-lg border border-[#F1D6D6] bg-white p-3 shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]" title={item.description}>
+          <div className="text-xs font-medium text-[#7A5A5A] dark:text-[#7FACF2]">{item.label}</div>
+          <div className="mt-1 text-xl font-semibold tabular-nums text-[#231815] dark:text-white">
+            {Number(item.value).toFixed(item.unit === "%" || String(item.value).includes(".") ? 1 : 0)}
+            <span className="ml-1 text-xs font-normal text-[#8B6B6B] dark:text-[#7FACF2]">{item.unit}</span>
+          </div>
+          <p className="mt-2 line-clamp-2 text-[11px] leading-4 text-[#8B6B6B] dark:text-[#7FACF2]">{item.description}</p>
+        </div>
+      ))}
+    </section>
+  );
+}
+
+function PodiumCard({
+  user,
+  rank,
+  tab,
+}: {
+  user?: AdminLeaderboardUser;
+  rank: 1 | 2 | 3;
+  tab: UserRankTab;
+}) {
+  const styles = {
+    1: "border-[#FEEFC3] bg-[#FEF7E0] text-[#B06000] dark:border-[#F4B400]/40 dark:bg-[#F4B400]/10 dark:text-[#FDD663]",
+    2: "border-[#E5E7EB] bg-[#F8FAFC] text-[#4B5563] dark:border-[#6B7280]/40 dark:bg-white/5 dark:text-[#E5E7EB]",
+    3: "border-[#FAD2CF] bg-[#FCE8E6] text-[#DB4437] dark:border-[#DB4437]/40 dark:bg-[#DB4437]/10 dark:text-[#F28B82]",
+  }[rank];
+
+  if (!user) {
+    return (
+      <div className="flex min-h-40 flex-col justify-between rounded-lg border border-dashed border-[#DADCE0] bg-white/70 p-4 dark:border-[#213D5E] dark:bg-[#02244C]/70">
+        <div className="text-sm text-[#5F6368] dark:text-slate-400">第 {rank} 名</div>
+        <div className="text-sm text-[#80868B]">暂无数据</div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex min-h-40 flex-col justify-between rounded-lg border border-[#DADCE0] bg-white p-4 shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]">
+      <div className="flex items-start justify-between gap-3">
+        <span className={cn("inline-flex items-center gap-1 rounded-full border px-2 py-1 text-xs font-medium", styles)}>
+          {rank === 1 ? <Crown className="size-3.5" /> : <Medal className="size-3.5" />}
+          第 {rank} 名
+        </span>
+        {user.system_role === "admin" && <Badge variant="outline">管理员</Badge>}
+      </div>
+      <div>
+        <div className="mb-3 flex size-11 items-center justify-center rounded-lg bg-[#C1121F] dark:bg-[#2563EB] text-base font-semibold text-white shadow-sm">
+          {initials(user)}
+        </div>
+        <div className="truncate font-semibold text-[#202124] dark:text-white">{user.email || user.user_id}</div>
+        <div className="mt-1 text-sm font-medium text-[#C1121F] dark:text-[#7FACF2]">{scoreLabel(user, tab)}</div>
+        <div className="mt-2 flex flex-wrap gap-x-3 gap-y-1 text-xs text-[#5F6368] dark:text-slate-400">
+          <span>运行 {fmtNumber(user.run_count)}</span>
+          <span>问答 {fmtNumber(user.qa_count)}</span>
+          <span>技能 {fmtNumber(user.skill_call_count)}</span>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function UserTable({
+  users,
+  tab,
+  rankOffset = 0,
+}: {
+  users: AdminLeaderboardUser[];
+  tab: UserRankTab;
+  rankOffset?: number;
+}) {
+  const max = Math.max(1, ...users.map((user) => userScore(user, tab)));
+  if (users.length === 0) {
+    return <div className="py-14 text-center text-sm text-[#5F6368] dark:text-slate-400">暂无用户统计</div>;
+  }
+
+  return (
+    <div className="overflow-hidden rounded-lg border border-[#F1D6D6] bg-white dark:border-[#213D5E] dark:bg-[#02244C]">
+      {users.map((user, index) => {
+        const score = userScore(user, tab);
+        return (
+          <div
+            key={user.user_id}
+            className="grid w-full grid-cols-[44px_minmax(0,1fr)_minmax(160px,240px)_120px] items-center gap-4 border-b border-[#F1D6D6] px-4 py-3 text-left last:border-b-0 dark:border-[#213D5E]"
+          >
+            <div className="flex size-8 items-center justify-center rounded-md bg-[#FFF1F1] text-sm font-semibold text-[#C1121F] dark:text-[#7FACF2] dark:bg-[#0D2D54] dark:text-[#7FACF2]">
+              {rankOffset + index + 1}
+            </div>
+            <div className="min-w-0">
+              <div className="flex items-center gap-2">
+                <span className="truncate font-medium text-[#202124] dark:text-white">{user.email || user.user_id}</span>
+                {user.system_role === "admin" && <Badge variant="outline">管理员</Badge>}
+              </div>
+              <div className="mt-1 text-xs text-[#5F6368] dark:text-slate-400">
+                最近活跃 {fmtTime(user.last_active_at)}
+              </div>
+            </div>
+            <div>
+              <div className="h-2 rounded-full bg-[#F1D6D6] dark:bg-[#0D2D54]">
+                <div
+                  className="h-2 rounded-full bg-[#C1121F] dark:bg-[#2563EB]"
+                  style={{ width: `${Math.max(4, (score / max) * 100)}%` }}
+                />
+              </div>
+              <div className="mt-1 text-xs text-[#5F6368] dark:text-slate-400">
+                会话 {fmtNumber(user.thread_count)} · LLM {fmtNumber(user.llm_call_count)}
+              </div>
+            </div>
+            <div className="text-right">
+              <div className="font-semibold text-[#202124] tabular-nums dark:text-white">{scoreLabel(user, tab)}</div>
+              <div className="mt-1 text-xs text-[#5F6368] dark:text-slate-400">
+                {fmtNumber(user.total_tokens)} tokens
+              </div>
+            </div>
+          </div>
+        );
+      })}
+    </div>
+  );
+}
+
+function SkillRanking({
+  title,
+  icon: Icon,
+  items,
+  empty,
+}: {
+  title: string;
+  icon: LucideIcon;
+  items: AdminLeaderboardSkill[];
+  empty: string;
+}) {
+  const max = Math.max(1, ...items.map((item) => item.call_count));
+  return (
+    <section className="rounded-lg border border-[#F1D6D6] bg-white p-4 shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]">
+      <div className="mb-4 flex items-center justify-between gap-3">
+        <div className="flex items-center gap-2">
+          <Icon className="size-4 text-[#5F6368] dark:text-slate-300" />
+          <h2 className="font-semibold text-[#202124] dark:text-white">{title}</h2>
+        </div>
+        <Badge variant="outline">{items.length} 项</Badge>
+      </div>
+      <div className="space-y-3">
+        {items.length === 0 && <div className="py-10 text-center text-sm text-[#5F6368] dark:text-slate-400">{empty}</div>}
+        {items.slice(0, 10).map((item, index) => (
+          <div key={item.name} className="grid grid-cols-[28px_minmax(0,1fr)_72px] items-center gap-3">
+            <span className="text-sm font-medium text-[#80868B] tabular-nums">{index + 1}</span>
+            <div className="min-w-0">
+              <div className="flex items-center justify-between gap-2">
+                <span className="truncate text-sm font-medium text-[#202124] dark:text-slate-100">{item.name}</span>
+                <span className="text-xs text-[#5F6368] dark:text-slate-400">
+                  {fmtNumber(item.user_count)} 人
+                </span>
+              </div>
+              <div className="mt-2 h-2 rounded-full bg-[#F1D6D6] dark:bg-[#0D2D54]">
+                <div
+                  className="h-2 rounded-full"
+                  style={{
+                    width: `${Math.max(4, (item.call_count / max) * 100)}%`,
+                    backgroundColor: RANK_COLORS[index % RANK_COLORS.length],
+                  }}
+                />
+              </div>
+            </div>
+            <div className="text-right">
+              <div className="text-sm font-semibold tabular-nums text-[#202124] dark:text-white">
+                {fmtNumber(item.call_count)}
+              </div>
+              <div className="text-xs text-[#5F6368] dark:text-slate-400">
+                失败 {fmtNumber(item.error_count)}
+              </div>
+            </div>
+          </div>
+        ))}
+      </div>
+    </section>
+  );
+}
+
+function DimensionRanking({
+  title,
+  icon: Icon,
+  items,
+  empty,
+}: {
+  title: string;
+  icon: LucideIcon;
+  items: AdminLeaderboardDimension[];
+  empty: string;
+}) {
+  const max = Math.max(1, ...items.map((item) => item.count));
+  return (
+    <section className="rounded-lg border border-[#F1D6D6] bg-white p-4 shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]">
+      <div className="mb-4 flex items-center justify-between gap-3">
+        <div className="flex items-center gap-2">
+          <Icon className="size-4 text-[#5F6368] dark:text-slate-300" />
+          <h2 className="font-semibold text-[#202124] dark:text-white">{title}</h2>
+        </div>
+        <Badge variant="outline">{items.length} 项</Badge>
+      </div>
+      <div className="space-y-3">
+        {items.length === 0 && <div className="py-10 text-center text-sm text-[#5F6368] dark:text-slate-400">{empty}</div>}
+        {items.slice(0, 8).map((item, index) => (
+          <div key={item.name} className="grid grid-cols-[28px_minmax(0,1fr)_88px] items-center gap-3">
+            <span className="text-sm font-medium text-[#80868B] tabular-nums">{index + 1}</span>
+            <div className="min-w-0">
+              <div className="flex items-center justify-between gap-2">
+                <span className="truncate text-sm font-medium text-[#202124] dark:text-slate-100">{item.name}</span>
+                <span className="text-xs text-[#5F6368] dark:text-slate-400">
+                  {fmtNumber(item.user_count)} 人
+                </span>
+              </div>
+              <div className="mt-2 h-2 rounded-full bg-[#F1D6D6] dark:bg-[#0D2D54]">
+                <div
+                  className="h-2 rounded-full"
+                  style={{
+                    width: `${Math.max(4, (item.count / max) * 100)}%`,
+                    backgroundColor: RANK_COLORS[index % RANK_COLORS.length],
+                  }}
+                />
+              </div>
+              <div className="mt-1 text-xs text-[#5F6368] dark:text-slate-400">
+                成功 {fmtNumber(item.success_count)} · 失败 {fmtNumber(item.error_count)} · {fmtNumber(item.total_tokens)} tokens
+              </div>
+            </div>
+            <div className="text-right">
+              <div className="text-sm font-semibold text-[#202124] tabular-nums dark:text-white">{fmtNumber(item.count)}</div>
+              <div className="text-xs text-[#5F6368] dark:text-slate-400">次</div>
+            </div>
+          </div>
+        ))}
+      </div>
+    </section>
+  );
+}
+
+function QuestionPanel({
+  title,
+  items,
+}: {
+  title: string;
+  items: AdminLeaderboardQuestion[];
+}) {
+  return (
+    <section className="flex h-[430px] flex-col overflow-hidden rounded-lg border border-[#F1D6D6] bg-white shadow-sm dark:border-[#213D5E] dark:bg-[#02244C]">
+      <div className="flex items-center justify-between gap-3 border-b border-[#F1D6D6] px-4 py-3 dark:border-[#213D5E]">
+        <div className="flex items-center gap-2">
+          <MessageSquareText className="size-4 text-[#5F6368] dark:text-slate-300" />
+          <h2 className="font-semibold text-[#202124] dark:text-white">{title}</h2>
+        </div>
+        <Badge variant="outline">{items.length}</Badge>
+      </div>
+      <ScrollArea className="min-h-0 flex-1">
+        <div className="divide-y divide-[#F1D6D6] dark:divide-[#213D5E]">
+          {items.length === 0 && <div className="py-12 text-center text-sm text-[#5F6368] dark:text-slate-400">暂无问题记录</div>}
+          {items.map((item, index) => (
+            <div key={`${item.run_id || item.text}-${index}`} className="px-4 py-3">
+              <div className="text-sm leading-6 text-[#202124] dark:text-slate-100">{clampText(item.text, 180)}</div>
+              <div className="mt-2 flex flex-wrap gap-x-3 gap-y-1 text-xs text-[#5F6368] dark:text-slate-400">
+                <span>{item.email || item.user_id || "未知用户"}</span>
+                <span>{fmtTime(item.asked_at)}</span>
+              </div>
+            </div>
+          ))}
+        </div>
+      </ScrollArea>
+    </section>
+  );
+}
+
+function TrendBars({ points }: { points: AdminLeaderboardTrendPoint[] }) {
+  type TrendMetric = keyof Pick<AdminLeaderboardTrendPoint, "runs" | "questions" | "users" | "tokens">;
+  const [metric, setMetric] = useState<"all" | TrendMetric>("all");
+  const chartId = useId().replace(/:/g, "");
+  if (points.length === 0) {
+    return <div className="flex h-56 items-center justify-center text-sm text-[#5F6368] dark:text-slate-400">暂无趋势数据</div>;
+  }
+
+  const visible = points.slice(-32);
+  const series = [
+    { key: "runs", label: "运行", color: "#C1121F", soft: "bg-[#FFF1F1] text-[#C1121F] dark:text-[#7FACF2] dark:bg-[#2563EB]/15 dark:text-[#7FACF2]", description: "每天发起的运行次数" },
+    { key: "questions", label: "问答", color: "#0F766E", soft: "bg-[#ECFDF5] text-[#0F766E] dark:bg-teal-300/15 dark:text-teal-100", description: "每天产生的有效提问次数" },
+    { key: "users", label: "活跃", color: "#B45309", soft: "bg-[#FFFBEB] text-[#B45309] dark:bg-amber-300/15 dark:text-amber-100", description: "每天有行为的用户数量" },
+    { key: "tokens", label: "Token", color: "#7C3AED", soft: "bg-[#F5F3FF] text-[#7C3AED] dark:bg-violet-300/15 dark:text-violet-100", description: "每天模型输入输出 Token 总量" },
+  ] as const;
+  const activeMetric: TrendMetric = metric === "all" ? "runs" : metric;
+  const activeSeries = series.find((item) => item.key === activeMetric) ?? series[0];
+  const metricMax = Math.max(1, ...visible.map((point) => Number(point[activeMetric] ?? 0)));
+  const latest = visible[visible.length - 1];
+  const previous = visible[visible.length - 2];
+  const latestValue = Number(latest?.[activeMetric] ?? 0);
+  const previousValue = Number(previous?.[activeMetric] ?? 0);
+  const delta = latestValue - previousValue;
+  const width = 920;
+  const height = 280;
+  const padding = { top: 22, right: 28, bottom: 36, left: 48 };
+  const chartWidth = width - padding.left - padding.right;
+  const chartHeight = height - padding.top - padding.bottom;
+  const xFor = (index: number) =>
+    padding.left + (visible.length <= 1 ? chartWidth / 2 : (index / (visible.length - 1)) * chartWidth);
+  const yFor = (value: number, max: number) => padding.top + chartHeight - (value / max) * chartHeight;
+  const gridLines = [0, 0.25, 0.5, 0.75, 1];
+  const selectedPath = visible
+    .map((point, index) => {
+      const value = Number(point[activeMetric] ?? 0);
+      return `${index === 0 ? "M" : "L"} ${xFor(index).toFixed(2)} ${yFor(value, metricMax).toFixed(2)}`;
+    })
+    .join(" ");
+  const selectedArea = `${selectedPath} L ${xFor(visible.length - 1).toFixed(2)} ${padding.top + chartHeight} L ${xFor(0).toFixed(2)} ${padding.top + chartHeight} Z`;
+  const peak = visible.reduce(
+    (best, point) => (Number(point[activeMetric] ?? 0) > Number(best[activeMetric] ?? 0) ? point : best),
+    visible[0],
+  );
+  const displayedSeries = metric === "all" ? series : [activeSeries];
+  const totalFor = (key: TrendMetric) => visible.reduce((sum, point) => sum + Number(point[key] ?? 0), 0);
+  const metricCards = ({ large = false }: { large?: boolean } = {}) => (
+    <div className="grid gap-2 sm:grid-cols-2 xl:grid-cols-5">
+      <button
+        type="button"
+        onClick={() => setMetric("all")}
+        className={cn(
+          "min-w-0 rounded-lg border px-3 py-2 text-left transition hover:-translate-y-0.5 hover:shadow-sm",
+          large && "px-4 py-3",
+          metric === "all"
+            ? "border-[#C1121F] dark:border-[#2563EB] bg-[#FFF1F1] shadow-sm dark:border-[#7FACF2]/40 dark:bg-[#0D2D54]"
+            : "border-[#F1D6D6] bg-white dark:border-[#213D5E] dark:bg-[#02244C]",
+        )}
+      >
+        <span className="inline-flex rounded-full bg-[#FFF1F1] px-2 py-0.5 text-xs font-medium text-[#C1121F] dark:text-[#7FACF2] dark:bg-[#2563EB]/15 dark:text-[#7FACF2]">全部趋势</span>
+        <span className={cn("mt-2 block font-semibold tabular-nums text-[#231815] dark:text-white", large ? "text-2xl" : "text-lg")}>
+          {fmtNumber(visible.reduce((sum, point) => sum + point.runs + point.questions + point.users, 0))}
+        </span>
+        {large && <span className="mt-1 block truncate text-xs text-[#8B6B6B] dark:text-[#7FACF2]">同时显示运行、问答、活跃与 Token</span>}
+      </button>
+      {series.map((item) => (
+        <button
+          key={item.key}
+          type="button"
+          onClick={() => setMetric(item.key)}
+          className={cn(
+            "min-w-0 rounded-lg border px-3 py-2 text-left transition hover:-translate-y-0.5 hover:shadow-sm",
+            large && "px-4 py-3",
+            metric === item.key
+              ? "border-[#C1121F] dark:border-[#2563EB] bg-[#FFF1F1] shadow-sm dark:border-[#7FACF2]/40 dark:bg-[#0D2D54]"
+              : "border-[#F1D6D6] bg-white dark:border-[#213D5E] dark:bg-[#02244C]",
+          )}
+          title={item.description}
+        >
+          <span className={cn("inline-flex rounded-full px-2 py-0.5 text-xs font-medium", item.soft)}>{item.label}</span>
+          <span className={cn("mt-2 block truncate font-semibold tabular-nums text-[#111827] dark:text-white", large ? "text-2xl" : "text-lg")}>
+            {fmtNumber(totalFor(item.key))}
+          </span>
+          {large && <span className="mt-1 block truncate text-[11px] text-[#8B6B6B] dark:text-[#7FACF2]">{item.description}</span>}
+        </button>
+      ))}
+    </div>
+  );
+
+  const analysisDialog = (title: string, description: ReactNode) => (
+    <Dialog>
+      <DialogTrigger asChild>
+        <Button variant="outline" size="sm">
+          <Maximize2 className="mr-1 size-4" />
+          放大分析
+        </Button>
+      </DialogTrigger>
+      <DialogContent className="flex h-[92vh] w-[96vw] max-w-none flex-col gap-4 overflow-hidden p-5 sm:max-w-none">
+        <DialogHeader className="shrink-0 pr-10">
+          <DialogTitle>{title}</DialogTitle>
+          <DialogDescription>{description}</DialogDescription>
+        </DialogHeader>
+        <div className="shrink-0">{metricCards({ large: true })}</div>
+        <div className="grid min-h-0 flex-1 gap-3 lg:grid-cols-[260px_minmax(0,1fr)]">
+          <div className="rounded-lg border border-[#F1D6D6] bg-white p-4 dark:border-[#213D5E] dark:bg-[#02244C]">
+            <div className="text-xs text-[#7A5A5A] dark:text-[#7FACF2]">当前查看</div>
+            <div className="mt-2 text-2xl font-semibold text-[#111827] dark:text-white">{metric === "all" ? "全部指标" : activeSeries.label}</div>
+            <div className="mt-5 text-xs text-[#7A5A5A] dark:text-[#7FACF2]">最新 {metric === "all" ? "运行" : activeSeries.label}</div>
+            <div className="mt-2 text-4xl font-semibold tabular-nums text-[#111827] dark:text-white">{fmtNumber(latestValue)}</div>
+            <div className={cn("mt-3 text-sm", delta >= 0 ? "text-[#C1121F] dark:text-[#7FACF2]" : "text-[#7F1D1D] dark:text-[#FCA5A5]")}>
+              较上一日 {delta >= 0 ? "+" : ""}{fmtNumber(delta)}
+            </div>
+            <div className="mt-5 text-xs text-[#7A5A5A] dark:text-[#7FACF2]">
+              峰值 {peak.date} / {fmtNumber(Number(peak[activeMetric] ?? 0))}
+            </div>
+          </div>
+          {chart(true)}
+        </div>
+      </DialogContent>
+    </Dialog>
+  );
+
+  const chart = (large = false) => (
+    <div className={cn("min-w-0 overflow-hidden rounded-xl border border-[#E5E7EB] bg-[#F9FAFB] p-3 dark:border-[#3F3F46] dark:bg-[#18181B]", large && "flex min-h-0 p-5")}>
+      <svg viewBox={`0 0 ${width} ${height}`} className={cn("w-full", large ? "h-full min-h-[420px]" : "h-72")} role="img" aria-label="使用趋势折线图">
+        <defs>
+          <linearGradient id={`trend-area-${chartId}-${activeMetric}`} x1="0" x2="0" y1="0" y2="1">
+            <stop offset="0%" stopColor={activeSeries.color} stopOpacity="0.22" />
+            <stop offset="100%" stopColor={activeSeries.color} stopOpacity="0.02" />
+          </linearGradient>
+        </defs>
+        {gridLines.map((ratio) => {
+          const y = padding.top + chartHeight * ratio;
+          return (
+            <g key={ratio}>
+              <line
+                x1={padding.left}
+                x2={width - padding.right}
+                y1={y}
+                y2={y}
+                stroke="currentColor"
+                className="text-[#E5E7EB] dark:text-[#3F3F46]"
+                strokeWidth="1"
+              />
+              <text x={12} y={y + 4} className="fill-[#9CA3AF] text-[11px]">
+                {fmtNumber(Math.round(metricMax * (1 - ratio)))}
+              </text>
+            </g>
+          );
+        })}
+        {metric !== "all" && <path d={selectedArea} fill={`url(#trend-area-${chartId}-${activeMetric})`} />}
+        {displayedSeries.map((item) => {
+          const max = Math.max(1, ...visible.map((point) => Number(point[item.key] ?? 0)));
+          const path = visible
+            .map((point, index) => {
+              const value = Number(point[item.key] ?? 0);
+              return `${index === 0 ? "M" : "L"} ${xFor(index).toFixed(2)} ${yFor(value, max).toFixed(2)}`;
+            })
+            .join(" ");
+          return (
+            <g key={item.key}>
+              <path d={path} fill="none" stroke={item.color} strokeWidth={large ? "4" : "3"} strokeLinecap="round" strokeLinejoin="round" opacity={metric === "all" ? 0.9 : 1} />
+              {metric !== "all" &&
+                visible.map((point, index) => {
+                  const value = Number(point[item.key] ?? 0);
+                  const isPeak = point.date === peak.date;
+                  const isLast = index === visible.length - 1;
+                  return (
+                    <circle
+                      key={`${item.key}-${point.date}`}
+                      cx={xFor(index)}
+                      cy={yFor(value, max)}
+                      r={isPeak || isLast ? 5 : 3}
+                      fill="#fff"
+                      stroke={item.color}
+                      strokeWidth={isPeak || isLast ? "3" : "2"}
+                    >
+                      <title>{`${point.date} ${item.label}: ${fmtNumber(value)}`}</title>
+                    </circle>
+                  );
+                })}
+            </g>
+          );
+        })}
+        {visible.map((point, index) => {
+          if (index !== 0 && index !== visible.length - 1 && index % Math.ceil(visible.length / 6) !== 0) return null;
+          return (
+            <text key={point.date} x={xFor(index)} y={height - 12} textAnchor="middle" className="fill-[#6B7280] text-[11px]">
+              {point.date.slice(5)}
+            </text>
+          );
+        })}
+      </svg>
+    </div>
+  );
+
+  return (
+    <div className="space-y-4">
+      <p className="text-xs leading-5 text-[#7A5A5A] dark:text-[#7FACF2]">
+        每个折线点代表一天；点击指标卡可单独查看运行、问答、活跃或 Token，全部趋势会同时展示四条多色折线。
+      </p>
+      <div className="flex flex-wrap items-center justify-between gap-3">
+        <div className="min-w-0 flex-1">{metricCards()}</div>
+        {analysisDialog(
+          "时间趋势分析",
+          <>当前查看 {metric === "all" ? "全部指标" : activeSeries.label}，峰值 {peak.date} / {fmtNumber(Number(peak[activeMetric] ?? 0))}。</>,
+        )}
+      </div>
+      <div className="grid gap-3 lg:grid-cols-[220px_minmax(0,1fr)]">
+        <div className="rounded-xl border border-[#F1D6D6] bg-white p-4 dark:border-[#213D5E] dark:bg-[#02244C]">
+          <div className="text-xs text-[#7A5A5A] dark:text-[#7FACF2]">最新 {metric === "all" ? "运行" : activeSeries.label}</div>
+          <div className="mt-2 text-3xl font-semibold tabular-nums text-[#111827] dark:text-white">{fmtNumber(latestValue)}</div>
+          <div className={cn("mt-2 text-sm", delta >= 0 ? "text-[#C1121F] dark:text-[#7FACF2]" : "text-[#7F1D1D] dark:text-[#FCA5A5]")}>
+            较上一日 {delta >= 0 ? "+" : ""}{fmtNumber(delta)}
+          </div>
+          <div className="mt-3 text-xs text-[#7A5A5A] dark:text-[#7FACF2]">
+            峰值 {peak.date.slice(5)} / {fmtNumber(Number(peak[activeMetric] ?? 0))}
+          </div>
+        </div>
+        {chart(false)}
+      </div>
+    </div>
+  );
+}
diff --git a/frontend-web/src/pages/PublicScheduledTaskPage.tsx b/frontend-web/src/pages/PublicScheduledTaskPage.tsx
index a57f653c..e3e251f3 100644
--- a/frontend-web/src/pages/PublicScheduledTaskPage.tsx
+++ b/frontend-web/src/pages/PublicScheduledTaskPage.tsx
@@ -6,16 +6,18 @@ import {
   ChevronLeft,
   ChevronRight,
   Download,
+  ExternalLink,
   FileText,
   List,
   Loader2,
+  Maximize2,
   Pencil,
   Trash2,
   X,
 } from "lucide-react";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type { PointerEvent as ReactPointerEvent } from "react";
-import { useParams } from "react-router-dom";
+import { useParams, useSearchParams } from "react-router-dom";
 import { toast } from "sonner";
 
 import { Badge } from "@/components/ui/badge";
@@ -127,6 +129,10 @@ async function fetchPublicTaskRuns(taskId: string): Promise<PublicRunsResponse>
   return fetchJson<PublicRunsResponse>(`${publicBaseUrl()}/${encodeURIComponent(taskId)}/runs?limit=200`);
 }
 
+async function fetchPublicRun(runId: string): Promise<PublicRun> {
+  return fetchJson<PublicRun>(`${publicBaseUrl()}/runs/${encodeURIComponent(runId)}`);
+}
+
 async function fetchPublicRunFile(runId: string, index: number): Promise<PublicFileContent> {
   return fetchJson<PublicFileContent>(
     `${publicBaseUrl()}/runs/${encodeURIComponent(runId)}/files/${index}`,
@@ -667,12 +673,61 @@ type ContentTab = {
   fileName?: string;
 };
 
+type PublicFullscreenPreview =
+  | { mode: "html"; title: string; html: string }
+  | { mode: "markdown"; title: string; content: string }
+  | { mode: "text"; title: string; content: string }
+  | { mode: "file"; title: string; file: PublicFileContent };
+
+function PublicFullscreenPreviewContent({ preview }: { preview: PublicFullscreenPreview }) {
+  if (preview.mode === "html") {
+    return <HtmlPreviewFrame html={preview.html} className="h-full w-full border-0 bg-white" />;
+  }
+  if (preview.mode === "markdown") {
+    return (
+      <MarkdownContent
+        className="max-w-none"
+        content={preview.content || "无正文内容"}
+        isLoading={false}
+        remarkPlugins={reasoningPlugins.remarkPlugins}
+        rehypePlugins={reasoningPlugins.rehypePlugins}
+      />
+    );
+  }
+  if (preview.mode === "file") {
+    const content = preview.file.content || "无文件内容";
+    if (isMarkdownFile(preview.file)) {
+      return (
+        <MarkdownContent
+          className="max-w-none"
+          content={content}
+          isLoading={false}
+          remarkPlugins={reasoningPlugins.remarkPlugins}
+          rehypePlugins={reasoningPlugins.rehypePlugins}
+        />
+      );
+    }
+    return <pre className="whitespace-pre-wrap break-words text-sm">{content}</pre>;
+  }
+  return <pre className="whitespace-pre-wrap break-words text-sm">{preview.content || "无正文内容"}</pre>;
+}
+
+function publicFullscreenHref(taskId: string, runId: string, tab: ContentTab): string {
+  const params = new URLSearchParams();
+  params.set("tab", tab.kind);
+  if (tab.kind === "file" && tab.fileIndex != null) {
+    params.set("file", String(tab.fileIndex));
+  }
+  return `#/public/scheduled-tasks/${encodeURIComponent(taskId)}/runs/${encodeURIComponent(runId)}/fullscreen?${params.toString()}`;
+}
+
 /**
  * Right-pane controller for a single run: builds the tab list (body + MDs),
  * fetches each tab's source text, and hosts the view/edit toggle.
  */
 function RunDetailPane({ run, taskId }: { run: PublicRun; taskId: string }) {
   const queryClient = useQueryClient();
+  const [fullscreenPreview, setFullscreenPreview] = useState<PublicFullscreenPreview | null>(null);
 
   // HTML page run: render a sandboxed iframe preview instead of the MD tabs.
   const isHtmlRun =
@@ -837,9 +892,67 @@ function RunDetailPane({ run, taskId }: { run: PublicRun; taskId: string }) {
   const fileIndex = activeTabMeta?.fileIndex;
   const fileIsLoading = isFileTab && fileIndex != null ? !!fileLoading[fileIndex] : false;
   const showEmptyHint = !activeSource && !fileIsLoading;
+  const fullscreenHref = activeTabMeta ? publicFullscreenHref(taskId, run.id, activeTabMeta) : "";
+  const fullscreenDisabled =
+    !activeTabMeta ||
+    (activeTabMeta.kind === "html" ? !htmlContent : activeTabMeta.kind === "file" ? fileIsLoading : false);
+
+  const handleOpenFullscreen = useCallback(() => {
+    if (!activeTabMeta) return;
+    if (activeTabMeta.kind === "html") {
+      if (!htmlContent) return;
+      setFullscreenPreview({
+        mode: "html",
+        title: run.result?.title || "HTML 预览",
+        html: htmlContent,
+      });
+      return;
+    }
+    if (activeTabMeta.kind === "body") {
+      setFullscreenPreview({
+        mode: run.result?.format === "markdown" || run.result?.format === "mixed" ? "markdown" : "text",
+        title: run.result?.title || "正文预览",
+        content: activeSource || "无正文内容",
+      });
+      return;
+    }
+    const sourceFile = markdownFiles.find((file) => file.index === activeTabMeta.fileIndex);
+    setFullscreenPreview({
+      mode: "file",
+      title: activeTabMeta.fileName || sourceFile?.name || "文件预览",
+      file: {
+        index: activeTabMeta.fileIndex ?? 0,
+        name: activeTabMeta.fileName || sourceFile?.name || "result.md",
+        mime_type: sourceFile?.mime_type ?? "text/markdown",
+        kind: sourceFile?.kind ?? "markdown",
+        size: sourceFile?.size ?? activeSource.length,
+        previewable: true,
+        content: activeSource,
+      },
+    });
+  }, [activeTabMeta, activeSource, htmlContent, markdownFiles, run.result?.format, run.result?.title]);
 
   return (
     <>
+      <Dialog open={fullscreenPreview !== null} onOpenChange={(open) => !open && setFullscreenPreview(null)}>
+        <DialogContent className="flex h-[96vh] w-[96vw] max-w-none flex-col gap-0 p-0 sm:max-w-none">
+          <DialogHeader className="shrink-0 border-b px-4 py-3 pr-12">
+            <DialogTitle className="truncate text-base">
+              {fullscreenPreview?.title ?? "预览"}
+            </DialogTitle>
+          </DialogHeader>
+          {fullscreenPreview && (
+            <div
+              className={cn(
+                "min-h-0 flex-1",
+                fullscreenPreview.mode === "html" ? "" : "overflow-auto p-4",
+              )}
+            >
+              <PublicFullscreenPreviewContent preview={fullscreenPreview} />
+            </div>
+          )}
+        </DialogContent>
+      </Dialog>
       <CardHeader className="flex flex-wrap items-start justify-between gap-2 space-y-0">
         <div className="min-w-0 flex-1">
           <Tooltip>
@@ -859,6 +972,30 @@ function RunDetailPane({ run, taskId }: { run: PublicRun; taskId: string }) {
           </p>
         </div>
         <div className="flex flex-wrap items-center gap-2">
+          {!isEditing && activeTabMeta && (
+            <>
+              <Button
+                size="sm"
+                variant="outline"
+                onClick={handleOpenFullscreen}
+                disabled={fullscreenDisabled}
+                title="全屏查看"
+              >
+                <Maximize2 className="size-4" />
+                全屏
+              </Button>
+              <Button
+                size="sm"
+                variant="outline"
+                onClick={() => window.open(fullscreenHref, "_blank", "noopener,noreferrer")}
+                disabled={fullscreenDisabled}
+                title="新页面打开全屏预览"
+              >
+                <ExternalLink className="size-4" />
+                新页面
+              </Button>
+            </>
+          )}
           {isFileTab && fileIndex != null && (
             <a
               className="bg-background hover:bg-accent inline-flex h-9 items-center gap-1 rounded-md border px-3 text-xs"
@@ -999,3 +1136,153 @@ function RunDetailPane({ run, taskId }: { run: PublicRun; taskId: string }) {
     </>
   );
 }
+
+export function PublicScheduledTaskFullscreenPage() {
+  const { taskId, runId } = useParams<{ taskId: string; runId: string }>();
+  const [searchParams] = useSearchParams();
+  const requestedTab = searchParams.get("tab");
+  const tabKind: ContentTab["kind"] =
+    requestedTab === "body" || requestedTab === "file" || requestedTab === "html"
+      ? requestedTab
+      : "html";
+  const fileIndexValue = Number(searchParams.get("file"));
+  const fileIndexValid = Number.isInteger(fileIndexValue) && fileIndexValue >= 0;
+
+  const { data: run, isLoading, isError, error } = useQuery({
+    queryKey: ["public-scheduled-task", "run", runId],
+    queryFn: () => fetchPublicRun(runId!),
+    enabled: !!runId,
+    refetchOnWindowFocus: false,
+    retry: false,
+  });
+
+  const isHtmlRun =
+    run?.result?.format === "html" ||
+    (run?.result?.files ?? []).some(
+      (file) => file.kind === "html" || (file.name ?? "").toLowerCase().endsWith(".html"),
+    );
+
+  const { data: htmlData, isLoading: htmlLoading } = useQuery({
+    queryKey: ["public-scheduled-task", "html", runId],
+    queryFn: () => fetchPublicRunHtml(runId!),
+    enabled: !!runId && tabKind === "html" && isHtmlRun && !run?.result?.html,
+    refetchOnWindowFocus: false,
+    retry: false,
+  });
+
+  const {
+    data: fileData,
+    isLoading: fileLoading,
+    isError: fileIsError,
+    error: fileError,
+  } = useQuery({
+    queryKey: ["public-scheduled-task", "file", runId, fileIndexValue],
+    queryFn: () => fetchPublicRunFile(runId!, fileIndexValue),
+    enabled: !!runId && tabKind === "file" && fileIndexValid,
+    refetchOnWindowFocus: false,
+    retry: false,
+  });
+
+  const htmlContent = run?.result?.html ?? htmlData?.html ?? null;
+  const backHref = taskId ? `#/public/scheduled-tasks/${encodeURIComponent(taskId)}` : "#/public/scheduled-tasks";
+  const pageTitle =
+    tabKind === "file"
+      ? fileData?.name || "文件预览"
+      : tabKind === "body"
+        ? run?.result?.title || "正文预览"
+        : htmlData?.title || run?.result?.title || "HTML 预览";
+
+  return (
+    <TooltipProvider delayDuration={150}>
+      <div className="bg-background flex h-screen min-h-0 flex-col">
+        <div className="flex h-12 shrink-0 items-center gap-2 border-b px-3">
+          <Button asChild variant="ghost" size="sm" className="h-8 px-2 text-xs">
+            <a href={backHref}>
+              <ChevronLeft className="size-3" />
+              返回列表
+            </a>
+          </Button>
+          <div className="min-w-0 flex-1 truncate text-sm font-medium" title={pageTitle}>
+            {pageTitle}
+          </div>
+          {tabKind === "file" && runId && fileIndexValid && (
+            <Button asChild variant="outline" size="sm" className="h-8 px-2 text-xs">
+              <a
+                href={publicRunFileDownloadUrl(runId, fileIndexValue)}
+                target="_blank"
+                rel="noopener noreferrer"
+              >
+                <Download className="size-3" />
+                下载
+              </a>
+            </Button>
+          )}
+        </div>
+
+        <div className="min-h-0 flex-1">
+          {!runId || !taskId ? (
+            <div className="text-muted-foreground flex h-full items-center justify-center text-sm">
+              缺少任务或执行记录 ID。
+            </div>
+          ) : isLoading ? (
+            <div className="text-muted-foreground flex h-full items-center justify-center gap-2 text-sm">
+              <Loader2 className="size-4 animate-spin" />
+              正在加载预览...
+            </div>
+          ) : isError ? (
+            <div className="text-destructive flex h-full items-center justify-center text-sm">
+              加载失败：{error instanceof Error ? error.message : "未知错误"}
+            </div>
+          ) : tabKind === "html" ? (
+            htmlContent ? (
+              <HtmlPreviewFrame html={htmlContent} className="h-full w-full border-0 bg-white" />
+            ) : (
+              <div className="text-muted-foreground flex h-full items-center justify-center gap-2 text-sm">
+                {htmlLoading && <Loader2 className="size-4 animate-spin" />}
+                HTML 页面尚未生成或正在生成中。
+              </div>
+            )
+          ) : tabKind === "file" ? (
+            fileLoading ? (
+              <div className="text-muted-foreground flex h-full items-center justify-center gap-2 text-sm">
+                <Loader2 className="size-4 animate-spin" />
+                正在加载文件...
+              </div>
+            ) : !fileIndexValid || fileIsError || !fileData ? (
+              <div className="text-destructive flex h-full items-center justify-center text-sm">
+                文件加载失败：{fileError instanceof Error ? fileError.message : "文件不存在或不可预览"}
+              </div>
+            ) : (
+              <ScrollArea className="h-full">
+                <div className="mx-auto max-w-5xl p-6">
+                  <PublicFullscreenPreviewContent
+                    preview={{
+                      mode: "file",
+                      title: fileData.name,
+                      file: fileData,
+                    }}
+                  />
+                </div>
+              </ScrollArea>
+            )
+          ) : (
+            <ScrollArea className="h-full">
+              <div className="mx-auto max-w-5xl p-6">
+                <PublicFullscreenPreviewContent
+                  preview={{
+                    mode:
+                      run?.result?.format === "markdown" || run?.result?.format === "mixed"
+                        ? "markdown"
+                        : "text",
+                    title: run?.result?.title || "正文预览",
+                    content: run?.result?.content || "无正文内容",
+                  }}
+                />
+              </div>
+            </ScrollArea>
+          )}
+        </div>
+      </div>
+    </TooltipProvider>
+  );
+}
diff --git a/frontend-web/src/pages/RecommendedQuestionsPage.tsx b/frontend-web/src/pages/RecommendedQuestionsPage.tsx
index 6a22170c..3877fd1f 100644
--- a/frontend-web/src/pages/RecommendedQuestionsPage.tsx
+++ b/frontend-web/src/pages/RecommendedQuestionsPage.tsx
@@ -59,7 +59,11 @@ const errorToastDarkOptions = {
   icon: <AlertCircle className="size-4 shrink-0 text-[#F5222D]" />,
 } as const;
 
-export default function RecommendedQuestionsPage() {
+export default function RecommendedQuestionsPage({
+  embedded = false,
+}: {
+  embedded?: boolean;
+} = {}) {
   const { theme } = useTheme();
   const { questions, isLoading, error } = useRecommendedQuestions();
   const createMutation = useCreateRecommendedQuestion();
@@ -176,10 +180,16 @@ export default function RecommendedQuestionsPage() {
       : { success: undefined, error: undefined };
 
   return (
-    <div className="mx-auto flex w-full max-w-2xl flex-col gap-6 px-6 py-10">
+    <div
+      className={
+        embedded
+          ? "flex w-full flex-col gap-6"
+          : "mx-auto flex w-full max-w-2xl flex-col gap-6 px-6 py-10"
+      }
+    >
       <div className="flex items-center justify-between">
         <div>
-          <h1 className="text-xl font-semibold">推荐问题配置</h1>
+          <h1 className={embedded ? "text-base font-semibold" : "text-xl font-semibold"}>推荐问题配置</h1>
           <p className="text-muted-foreground mt-1 text-sm">
             管理首页展示的推荐问题，点击后直接发送到对话。拖拽可调整顺序。
           </p>
diff --git a/frontend-web/src/pages/ScheduledTasksPage.tsx b/frontend-web/src/pages/ScheduledTasksPage.tsx
index 6a527443..ae93d9e7 100644
--- a/frontend-web/src/pages/ScheduledTasksPage.tsx
+++ b/frontend-web/src/pages/ScheduledTasksPage.tsx
@@ -21,6 +21,7 @@ import {
   RefreshCw,
   TagsIcon,
   Trash2,
+  X,
 } from "lucide-react";
 import { useSearchParams } from "react-router-dom";
 import { useRouteNavigate as useNavigate } from "@/core/route-base";
@@ -148,8 +149,16 @@ export default function ScheduledTasksPage() {
   const initialTaskId = searchParams.get("task");
   const [search, setSearch] = useState("");
   const [tagIds, setTagIds] = useState<string[]>([]);
+  // Plaza (广场) name search is resolved client-side over the fetched published
+  // list, kept separate from the server-side 我的任务 search above.
+  const [plazaSearch, setPlazaSearch] = useState("");
+  // Publisher (创建者) filter for the 我的任务 tab — click a task's 创建者 to keep
+  // only that creator's tasks. {id} is creator_user_id; {label} the display name.
+  const [publisher, setPublisher] = useState<{ id: string; label: string } | null>(
+    null,
+  );
   // Name + tag filtering is resolved server-side via the /api/scheduled-tasks query.
-  const { data: tasks = [], isLoading } = useScheduledTasks({ search, tagIds });
+  const { data: tasks = [], isLoading, isFetching } = useScheduledTasks({ search, tagIds });
   const { data: deliveryProfile } = useScheduledTaskDeliveryProfile();
   const { agents } = useAgents();
   const actions = useScheduledTaskActions();
@@ -199,6 +208,34 @@ export default function ScheduledTasksPage() {
       }),
     [tasks],
   );
+  // The rendered 我的任务 list, optionally narrowed to one creator. Selection
+  // logic still runs against the full sortedTasks so the detail panel keeps
+  // working even when the picked task is from a filtered-out creator.
+  const visibleTasks = useMemo(
+    () =>
+      publisher
+        ? sortedTasks.filter((task) => task.creator_user_id === publisher.id)
+        : sortedTasks,
+    [sortedTasks, publisher],
+  );
+  // Plaza search: filter the fetched published list client-side. Match against
+  // both the raw and desensitized forms so typing what's shown on screen (the
+  // desensitized name) and the underlying text both hit.
+  const visiblePublished = useMemo(() => {
+    const q = plazaSearch.trim().toLowerCase();
+    if (!q) return published;
+    return published.filter((item) =>
+      [
+        item.name,
+        desensitize(item.name),
+        item.prompt_summary,
+        desensitize(item.prompt_summary ?? ""),
+        item.schedule_text,
+        displayUsername(item.creator_email),
+      ].some((field) => (field ?? "").toLowerCase().includes(q)),
+    );
+  }, [published, plazaSearch]);
+
   const selectedTask = sortedTasks.find((task) => task.task_id === selectedTaskId) ?? null;
   const selectedTaskCanEditRuns = !!selectedTask && selectedTask.role !== "subscriber";
   const { data: runs = [], isLoading: runsLoading } = useScheduledTaskRuns(selectedTaskId);
@@ -449,8 +486,32 @@ export default function ScheduledTasksPage() {
                   onSearchChange={setSearch}
                   tagIds={tagIds}
                   onTagIdsChange={setTagIds}
+                  searching={isFetching}
                 />
               )}
+              {activeTab === "plaza" && (
+                <TagSearchBar
+                  targetType="scheduled_task"
+                  hideTags
+                  onSearchChange={setPlazaSearch}
+                  searching={publishedLoading}
+                  searchPlaceholder="搜索广场任务（名称 / 摘要 / 创建者）"
+                />
+              )}
+              {activeTab === "mine" && publisher && (
+                <div className="flex items-center gap-2">
+                  <span className="text-muted-foreground text-xs">筛选创建者：</span>
+                  <button
+                    type="button"
+                    onClick={() => setPublisher(null)}
+                    className="bg-primary/10 text-primary hover:bg-primary/20 inline-flex items-center gap-1 rounded-full px-3 py-1 text-xs font-medium transition-colors"
+                    title="点击清除创建者筛选"
+                  >
+                    {publisher.label}
+                    <X className="size-3.5" />
+                  </button>
+                </div>
+              )}
             </CardHeader>
             <CardContent className="min-h-0 flex-1 p-0">
               <ScrollArea className="size-full">
@@ -459,12 +520,14 @@ export default function ScheduledTasksPage() {
                     {isLoading && (
                       <div className="text-muted-foreground text-sm">正在加载任务...</div>
                     )}
-                    {!isLoading && sortedTasks.length === 0 && (
+                    {!isLoading && visibleTasks.length === 0 && (
                       <div className="text-muted-foreground rounded-md border p-4 text-sm">
-                        还没有定时任务。点击新建创建第一个任务，或去“广场”收藏他人发布的任务。
+                        {publisher
+                          ? `没有「${publisher.label}」创建的任务。`
+                          : "还没有定时任务。点击新建创建第一个任务，或去“广场”收藏他人发布的任务。"}
                       </div>
                     )}
-                    {sortedTasks.map((task) => {
+                    {visibleTasks.map((task) => {
                       const isOwner = task.role !== "subscriber";
                       const isSubscriber = task.role === "subscriber";
                       const notifyOn = !!task._subscription?.notify_element;
@@ -539,11 +602,36 @@ export default function ScheduledTasksPage() {
                               )}
                             </div>
                             {(task.creator_email || task.creator_user_id) && (
-                              <div className="truncate">
+                              // The card itself is a <button>, so this clickable
+                              // creator must be a <span> (no nested buttons).
+                              <span
+                                role={task.creator_user_id ? "button" : undefined}
+                                tabIndex={task.creator_user_id ? 0 : undefined}
+                                onClick={(event) => {
+                                  if (!task.creator_user_id) return;
+                                  event.stopPropagation();
+                                  setPublisher({
+                                    id: task.creator_user_id,
+                                    label:
+                                      displayUsername(task.creator_email) ||
+                                      task.creator_user_id,
+                                  });
+                                }}
+                                className={cn(
+                                  "block max-w-full truncate text-sm font-medium",
+                                  task.creator_user_id &&
+                                    "hover:text-primary cursor-pointer transition-colors hover:underline",
+                                )}
+                                title={
+                                  task.creator_user_id
+                                    ? `点击筛选创建者：${displayUsername(task.creator_email) || task.creator_user_id}`
+                                    : undefined
+                                }
+                              >
                                 创建者：
                                 {displayUsername(task.creator_email) ||
                                   task.creator_user_id}
-                              </div>
+                              </span>
                             )}
                           </div>
                           {(task.tags?.length ?? 0) > 0 && (
@@ -694,14 +782,19 @@ export default function ScheduledTasksPage() {
                 ) : (
                   <div className="flex flex-col gap-3 p-4 pt-0">
                     {publishedLoading && (
-                      <div className="text-muted-foreground text-sm">正在加载广场任务...</div>
-                    )}
-                    {!publishedLoading && published.length === 0 && (
-                      <div className="text-muted-foreground rounded-md border p-4 text-sm">
-                        广场上还没有发布的任务。
+                      <div className="text-muted-foreground flex items-center gap-2 text-sm">
+                        <Loader2 className="size-4 animate-spin" />
+                        正在加载广场任务...
                       </div>
                     )}
-                    {published.map((item) => {
+                    {!publishedLoading && visiblePublished.length === 0 && (
+                      <div className="text-muted-foreground rounded-md border p-4 text-sm">
+                        {plazaSearch.trim()
+                          ? `没有匹配「${plazaSearch.trim()}」的任务。`
+                          : "广场上还没有发布的任务。"}
+                      </div>
+                    )}
+                    {visiblePublished.map((item) => {
                       const subscribed = tasks.some((t) => t.task_id === item.task_id);
                       return (
                         <div key={item.task_id} className="bg-card rounded-md border p-4">
@@ -781,7 +874,7 @@ export default function ScheduledTasksPage() {
                 {selectedTask ? desensitize(selectedTask.name) : "请选择左侧任务"}
               </p>
               {selectedTask && (selectedTask.creator_email || selectedTask.creator_user_id) && (
-                <p className="text-muted-foreground text-xs">
+                <p className="text-muted-foreground text-sm font-medium">
                   创建者：
                   {displayUsername(selectedTask.creator_email) ||
                     selectedTask.creator_user_id}
diff --git a/frontend-web/src/pages/StrategyRoutes.tsx b/frontend-web/src/pages/StrategyRoutes.tsx
index 5f0129ed..dd8180b4 100644
--- a/frontend-web/src/pages/StrategyRoutes.tsx
+++ b/frontend-web/src/pages/StrategyRoutes.tsx
@@ -17,6 +17,8 @@ import { ActionAnalyzes } from "@/strategy-components/components/task-components
 import KnowledgeBaseResourceManagement from "@/strategy-components/components/resource-management/KnowledgeBaseResourceManagement";
 import NetworkActorResourceManagement from "@/strategy-components/components/resource-management/NetworkActorResourceManagement";
 import RoundtablePlanningPage from "@/roundtable-planning/pages/RoundtablePlanningPage";
+import BusinessChainListPage from "@/roundtable-planning/pages/BusinessChainListPage";
+import BusinessChainEditorPage from "@/roundtable-planning/pages/BusinessChainEditorPage";
 import "@/roundtable-planning/styles/roundtable-planning.css";
 import AgentChatPage from "./AgentChatPage";
 import AgentsPage from "./AgentsPage";
@@ -174,6 +176,8 @@ export default function StrategyRoutes() {
             <Route path="skills/evolution" element={<SkillEvolutionPage />} />
             <Route path="memory" element={<MemoryPage />} />
             <Route path="business-chain-mapping" element={<BusinessChainMappingPage />} />
+            <Route path="business-chains" element={<BusinessChainListPage />} />
+            <Route path="roundtable/chains" element={<BusinessChainEditorPage />} />
 
             <Route
               path="scheduled"
diff --git a/frontend-web/src/pages/WorkspaceRoutes.tsx b/frontend-web/src/pages/WorkspaceRoutes.tsx
index 2f2a40c0..bc5579e9 100644
--- a/frontend-web/src/pages/WorkspaceRoutes.tsx
+++ b/frontend-web/src/pages/WorkspaceRoutes.tsx
@@ -24,6 +24,8 @@ import AdminScheduledTasksPage from './AdminScheduledTasksPage';
 import AdminSkillsPage from './AdminSkillsPage';
 import ScheduledTaskRunDetailPage from './ScheduledTaskRunDetailPage';
 import ScheduledTasksPage from './ScheduledTasksPage';
+import KnowledgeBasePage from './KnowledgeBasePage';
+import KnowledgeGraphPage from './KnowledgeGraphPage';
 import LlmMetricsPage from './LlmMetricsPage';
 import CheckpointMigrationPage from './CheckpointMigrationPage';
 import MemoryPage from './MemoryPage';
@@ -42,6 +44,7 @@ import StudioNotebooksPage from './StudioNotebooksPage';
 import StudioNotebookDetailPage from './StudioNotebookDetailPage';
 import RoundtablePlanningPage from '@/roundtable-planning/pages/RoundtablePlanningPage';
 import BusinessChainEditorPage from '@/roundtable-planning/pages/BusinessChainEditorPage';
+import BusinessChainListPage from '@/roundtable-planning/pages/BusinessChainListPage';
 import DispatchChainPreviewPage from '@/roundtable-planning/pages/DispatchChainPreviewPage';
 import '@/roundtable-planning/styles/roundtable-planning.css';
 import { cn } from '@/lib/utils';
@@ -326,6 +329,14 @@ export default function WorkspaceRoutes({
             </WorkspaceLayout>
           }
         />
+        <Route
+          path="business-chains"
+          element={
+            <WorkspaceLayout {...layoutProps}>
+              <BusinessChainListPage />
+            </WorkspaceLayout>
+          }
+        />
         {/* Phase 7 临时预览入口：派活链路流程图弹窗（假数据自测，接通后台后可删） */}
         <Route
           path="roundtable/chain-preview"
@@ -335,6 +346,30 @@ export default function WorkspaceRoutes({
             </WorkspaceLayout>
           }
         />
+        <Route
+          path="knowledge"
+          element={
+            <WorkspaceLayout {...layoutProps}>
+              <KnowledgeBasePage />
+            </WorkspaceLayout>
+          }
+        />
+        <Route
+          path="knowledge/graph"
+          element={
+            <WorkspaceLayout {...layoutProps}>
+              <KnowledgeGraphPage />
+            </WorkspaceLayout>
+          }
+        />
+        <Route
+          path="knowledge/:noteId"
+          element={
+            <WorkspaceLayout {...layoutProps}>
+              <KnowledgeBasePage />
+            </WorkspaceLayout>
+          }
+        />
         <Route
           path="scheduled"
           element={<Navigate to="/page/workspace/scheduled/tasks" replace />}
diff --git a/frontend-web/src/roundtable-planning/api/intent.ts b/frontend-web/src/roundtable-planning/api/intent.ts
index f88e2327..1fa934e1 100644
--- a/frontend-web/src/roundtable-planning/api/intent.ts
+++ b/frontend-web/src/roundtable-planning/api/intent.ts
@@ -142,10 +142,24 @@ export interface IntentSummary {
  */
 export type IntentStreamPhase = "connecting" | "connected" | "streaming" | "tool_calling";
 
+/**
+ * 用户上传文件的引用（已经过 `/api/threads/{thread_id}/uploads`）。透传给后端
+ * `additional_kwargs.files`，由 UploadsMiddleware 注入文件清单并解锁 read_file 等工具。
+ * 字段与普通聊天的 `FileInMessage` 对齐：`path` 用上传返回的 `virtual_path`。
+ */
+export interface IntentFileRef {
+  filename: string;
+  size: number;
+  path: string;
+  status?: "uploading" | "uploaded";
+}
+
 export interface StreamIntentRequest {
   threadId: string;
   message: string;
   model?: string;
+  /** Step 1 用户上传的参考文件（可选）。 */
+  files?: IntentFileRef[];
   signal?: AbortSignal;
   /** Fires for every AI text chunk parsed out of LangGraph messages-tuple frames. */
   onTextDelta?: (text: string, messageId: string) => void;
@@ -318,6 +332,8 @@ export async function streamIntent(req: StreamIntentRequest): Promise<StreamInte
       thread_id: req.threadId,
       message: req.message,
       model: req.model,
+      // 仅在有文件时带上，空数组后端也安全忽略。
+      files: req.files && req.files.length > 0 ? req.files : undefined,
     }),
     signal: req.signal,
   });
diff --git a/frontend-web/src/roundtable-planning/api/multi-agent.ts b/frontend-web/src/roundtable-planning/api/multi-agent.ts
index cfb76908..961fab42 100644
--- a/frontend-web/src/roundtable-planning/api/multi-agent.ts
+++ b/frontend-web/src/roundtable-planning/api/multi-agent.ts
@@ -227,6 +227,12 @@ export interface StreamMultiAgentRequest {
    * (平时只看广播摘要)。不进 prompt → 不调工具就不耗 token。
    */
   peerDeliveries?: Array<{ name: string; content: string }>;
+  /**
+   * 用户随干预消息上传的参考文件（已经过 `/api/threads/{thread_id}/uploads`）。
+   * 透传给后端 `additional_kwargs.files`，由 UploadsMiddleware 注入清单 + 解锁
+   * read_file 等工具。字段 `path` 用上传返回的 `virtual_path`。
+   */
+  files?: Array<{ filename: string; size: number; path: string; status?: string }>;
   signal?: AbortSignal;
   /** Fires for every non-status data frame the upstream emits. */
   onUpstreamFrame?: (frame: unknown) => void;
@@ -447,6 +453,8 @@ export async function streamMultiAgent(
       parallel_no_file: req.parallelNoFile ?? false,
       // 仅 special 用;前序席位完整交付,后端注入 context 供 read_peer_delivery 按需取全文。
       peer_deliveries: req.peerDeliveries ?? [],
+      // 用户随干预上传的参考文件;仅在有文件时带上,后端注入 additional_kwargs.files。
+      files: req.files && req.files.length > 0 ? req.files : undefined,
     }),
     signal: req.signal,
   });
diff --git a/frontend-web/src/roundtable-planning/components/BusinessChainListDialog.tsx b/frontend-web/src/roundtable-planning/components/BusinessChainListDialog.tsx
index 1e961c58..107d33d7 100644
--- a/frontend-web/src/roundtable-planning/components/BusinessChainListDialog.tsx
+++ b/frontend-web/src/roundtable-planning/components/BusinessChainListDialog.tsx
@@ -40,11 +40,30 @@ export interface BusinessChainListDialogProps {
   onConfigure: (chainId?: string) => void;
 }
 
-export function BusinessChainListDialog({
-  open,
-  onOpenChange,
+export interface BusinessChainListBodyProps {
+  /**
+   * 是否激活（控制何时拉取列表）：弹窗里传 `open`（打开才拉），
+   * 独立页面里恒为 `true`。
+   */
+  active: boolean;
+  /** 进入配置页。带 chainId = 打开并切到该链条；不带 = 空白新建。 */
+  onConfigure: (chainId?: string) => void;
+  /** 列表为空时的「去创建」引导文案差异（弹窗说「点下方配置」，页面说「点右上配置」）。 */
+  emptyHint?: string;
+}
+
+/**
+ * 业务链条列表主体（筛选 tab + 滚动卡片列表）。
+ *
+ * 从 `BusinessChainListDialog` 抽出，供弹窗与独立配置页（`BusinessChainListPage`）
+ * 复用，保证两处的加载 / 发布 / 卡片渲染逻辑完全一致。外层负责标题栏与「配置」入口、
+ * 以及撑出 `flex flex-col` 高度（本组件用 `flex-1` 占满剩余空间）。
+ */
+export function BusinessChainListBody({
+  active,
   onConfigure,
-}: BusinessChainListDialogProps) {
+  emptyHint,
+}: BusinessChainListBodyProps) {
   const [chains, setChains] = useState<BusinessChain[]>([]);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
@@ -65,9 +84,9 @@ export function BusinessChainListDialog({
     }
   }, []);
 
-  // 每次打开 / 切换筛选都重新拉，保证配置页改动后回来看到的是最新列表。
+  // 每次激活 / 切换筛选都重新拉，保证配置页改动后回来看到的是最新列表。
   useEffect(() => {
-    if (!open) return;
+    if (!active) return;
     let cancelled = false;
     void (async () => {
       setLoading(true);
@@ -84,7 +103,7 @@ export function BusinessChainListDialog({
     return () => {
       cancelled = true;
     };
-  }, [open, scope]);
+  }, [active, scope]);
 
   const handleTogglePublic = useCallback(
     async (chain: BusinessChain) => {
@@ -101,6 +120,73 @@ export function BusinessChainListDialog({
     [refresh, scope],
   );
 
+  return (
+    <>
+      {/* 筛选：我的 / 公共 */}
+      <div className="shrink-0 flex items-center gap-1 rounded-lg border border-border bg-muted/40 p-0.5 self-start">
+        {(["mine", "public"] as const).map((s) => (
+          <button
+            key={s}
+            type="button"
+            onClick={() => setScope(s)}
+            className={cn(
+              "rounded-md px-3 py-1 text-xs font-medium transition",
+              scope === s
+                ? "bg-primary text-primary-foreground shadow-sm"
+                : "text-muted-foreground hover:text-foreground",
+            )}
+          >
+            {s === "mine" ? "我的" : "公共"}
+          </button>
+        ))}
+      </div>
+
+      <div className="custom-scrollbar -mr-1 min-h-0 flex-1 overflow-y-auto py-3 pr-1">
+        {loading ? (
+          <div className="flex items-center gap-2 px-1 py-10 text-sm text-muted-foreground">
+            <Loader2Icon className="size-4 animate-spin" />
+            正在加载业务链条…
+          </div>
+        ) : error ? (
+          <div className="rounded-md border border-destructive/30 bg-destructive/5 p-4 text-sm text-destructive">
+            加载业务链条失败：{error}
+          </div>
+        ) : chains.length === 0 ? (
+          <div className="flex flex-col items-center justify-center gap-3 px-6 py-12 text-center">
+            <LayersIcon className="size-10 text-primary/40" />
+            <div className="text-sm font-semibold">
+              {scope === "public" ? "还没有公共链条" : "还没有业务链条"}
+            </div>
+            <p className="max-w-sm text-xs leading-relaxed text-muted-foreground">
+              {scope === "public"
+                ? "公共链条是其他账号（或你自己）发布出来、所有人可见的链条。去「我的」里发布一条试试。"
+                : emptyHint ??
+                  "业务链条是可复用的有序智能体编排。点击下方「配置」去创建第一条链条。"}
+            </p>
+          </div>
+        ) : (
+          <div className="space-y-3.5">
+            {chains.map((chain) => (
+              <ChainRow
+                key={chain.id}
+                chain={chain}
+                publishing={publishingId === chain.id}
+                onSettings={() => onConfigure(chain.id)}
+                onTogglePublic={() => handleTogglePublic(chain)}
+              />
+            ))}
+          </div>
+        )}
+      </div>
+    </>
+  );
+}
+
+export function BusinessChainListDialog({
+  open,
+  onOpenChange,
+  onConfigure,
+}: BusinessChainListDialogProps) {
   return (
     <Dialog open={open} onOpenChange={onOpenChange}>
       <DialogContent className="flex max-h-[85vh] flex-col gap-0 sm:max-w-2xl">
@@ -114,61 +200,7 @@ export function BusinessChainListDialog({
           </DialogDescription>
         </DialogHeader>
 
-        {/* 筛选：我的 / 公共 */}
-        <div className="shrink-0 flex items-center gap-1 rounded-lg border border-border bg-muted/40 p-0.5 self-start">
-          {(["mine", "public"] as const).map((s) => (
-            <button
-              key={s}
-              type="button"
-              onClick={() => setScope(s)}
-              className={cn(
-                "rounded-md px-3 py-1 text-xs font-medium transition",
-                scope === s
-                  ? "bg-primary text-primary-foreground shadow-sm"
-                  : "text-muted-foreground hover:text-foreground",
-              )}
-            >
-              {s === "mine" ? "我的" : "公共"}
-            </button>
-          ))}
-        </div>
-
-        <div className="custom-scrollbar -mr-1 min-h-0 flex-1 overflow-y-auto py-3 pr-1">
-          {loading ? (
-            <div className="flex items-center gap-2 px-1 py-10 text-sm text-muted-foreground">
-              <Loader2Icon className="size-4 animate-spin" />
-              正在加载业务链条…
-            </div>
-          ) : error ? (
-            <div className="rounded-md border border-destructive/30 bg-destructive/5 p-4 text-sm text-destructive">
-              加载业务链条失败：{error}
-            </div>
-          ) : chains.length === 0 ? (
-            <div className="flex flex-col items-center justify-center gap-3 px-6 py-12 text-center">
-              <LayersIcon className="size-10 text-primary/40" />
-              <div className="text-sm font-semibold">
-                {scope === "public" ? "还没有公共链条" : "还没有业务链条"}
-              </div>
-              <p className="max-w-sm text-xs leading-relaxed text-muted-foreground">
-                {scope === "public"
-                  ? "公共链条是其他账号（或你自己）发布出来、所有人可见的链条。去「我的」里发布一条试试。"
-                  : "业务链条是可复用的有序智能体编排。点击下方「配置」去创建第一条链条。"}
-              </p>
-            </div>
-          ) : (
-            <div className="space-y-3.5">
-              {chains.map((chain) => (
-                <ChainRow
-                  key={chain.id}
-                  chain={chain}
-                  publishing={publishingId === chain.id}
-                  onSettings={() => onConfigure(chain.id)}
-                  onTogglePublic={() => handleTogglePublic(chain)}
-                />
-              ))}
-            </div>
-          )}
-        </div>
+        <BusinessChainListBody active={open} onConfigure={onConfigure} />
 
         <DialogFooter className="shrink-0 border-t pt-3 sm:justify-end">
           <Button onClick={() => onConfigure()} className="gap-1.5">
@@ -246,22 +278,70 @@ function ChainRow({
         <div className="mt-1.5 line-clamp-2 text-sm text-muted-foreground">{chain.description}</div>
       )}
 
-      {/* 席位名 tag（按顺序，→ 箭头连接发言次序） */}
-      <div className="mt-3.5 flex flex-wrap items-center gap-1.5">
-        {chain.seats.map((seat, i) => (
-          <Fragment key={seat.agent_id}>
-            {i > 0 && <ArrowRightIcon className="size-3.5 shrink-0 text-muted-foreground/50" />}
-            <span
-              className={cn(
-                "rounded-md border px-2 py-1 text-xs font-medium",
-                chainTagClasses(getAvatarTypeFor(seat.agent_id, i)),
-              )}
-            >
-              {seat.name || seat.agent_id}
-            </span>
-          </Fragment>
-        ))}
-      </div>
+      {/* 席位编排：按 stage 分组——并行阶段竖向并列在虚线框里，阶段之间用 → 串联。 */}
+      <ChainSeatsFlow chain={chain} />
+    </div>
+  );
+}
+
+// ── 链条席位编排流（体现「同层并行 · 层间串行」）─────────────────────────────
+
+function ChainSeatsFlow({ chain }: { chain: BusinessChain }) {
+  // 名称回退表：用落库快照（seats）解析 stage 里的 agent_id。
+  const seatById = new Map(chain.seats.map((s) => [s.agent_id, s] as const));
+
+  // 分层来源：带 stages（分层编排）就按 stages 渲染（过滤空阶段）；否则每个席位各成
+  // 一段、顺序串行（线性链，与旧版展示一致）。
+  const stages =
+    chain.stages && chain.stages.length > 0
+      ? chain.stages.filter((s) => s.length > 0)
+      : chain.seats.map((s) => [s.agent_id]);
+
+  // 跨阶段累加的全局序号 —— 决定头像配色，与编辑器 / 展平 seats 顺序对齐。
+  const orderById = new Map<string, number>();
+  let counter = 0;
+  for (const stageIds of stages) {
+    for (const id of stageIds) {
+      orderById.set(id, counter);
+      counter += 1;
+    }
+  }
+
+  const seatTag = (agentId: string) => {
+    const seat = seatById.get(agentId);
+    return (
+      <span
+        key={agentId}
+        className={cn(
+          "rounded-md border px-2 py-1 text-xs font-medium",
+          chainTagClasses(getAvatarTypeFor(agentId, orderById.get(agentId) ?? 0)),
+        )}
+      >
+        {seat?.name || agentId}
+      </span>
+    );
+  };
+
+  return (
+    <div className="mt-3.5 flex flex-wrap items-center gap-1.5">
+      {stages.map((stageIds, stageIdx) => (
+        <Fragment key={stageIdx}>
+          {stageIdx > 0 && (
+            <ArrowRightIcon className="size-3.5 shrink-0 text-muted-foreground/50" />
+          )}
+          {stageIds.length > 1 ? (
+            // 并行阶段：席位竖向并列在虚线框里，左上角标「并行 N」。
+            <div className="relative flex flex-col gap-1 rounded-lg border border-dashed border-primary/40 bg-primary/[0.04] px-1.5 pb-1.5 pt-2.5">
+              <span className="pointer-events-none absolute -top-2 left-1.5 rounded-full bg-card px-1.5 text-[10px] font-semibold leading-tight text-primary">
+                并行 {stageIds.length}
+              </span>
+              {stageIds.map((id) => seatTag(id))}
+            </div>
+          ) : (
+            seatTag(stageIds[0])
+          )}
+        </Fragment>
+      ))}
     </div>
   );
 }
diff --git a/frontend-web/src/roundtable-planning/components/BusinessChainPicker.tsx b/frontend-web/src/roundtable-planning/components/BusinessChainPicker.tsx
index 05dda9b6..bb431011 100644
--- a/frontend-web/src/roundtable-planning/components/BusinessChainPicker.tsx
+++ b/frontend-web/src/roundtable-planning/components/BusinessChainPicker.tsx
@@ -289,6 +289,43 @@ function ChainCard({
   const deletedCount = chain.seats.length - survivingCount;
   const usable = survivingCount >= CHAIN_MIN_SEATS;
 
+  // ── 席位编排（体现「同层并行 · 层间串行」）─────────────────────────────
+  // 名称回退表：实时 name（nameById）→ 落库快照（seat.name）→ agent_id。
+  const seatById = new Map(chain.seats.map((s) => [s.agent_id, s] as const));
+  // 带 stages（分层编排）按 stages 渲染（过滤空阶段）；否则每席位各成一段、顺序串行。
+  const stages =
+    chain.stages && chain.stages.length > 0
+      ? chain.stages.filter((s) => s.length > 0)
+      : chain.seats.map((s) => [s.agent_id]);
+  // 跨阶段累加的全局序号 —— 决定头像配色，与展平 seats 顺序对齐。
+  const orderById = new Map<string, number>();
+  let seatOrder = 0;
+  for (const stageIds of stages) {
+    for (const id of stageIds) {
+      orderById.set(id, seatOrder);
+      seatOrder += 1;
+    }
+  }
+  // 单个席位 tag：存活按配色，已删除置灰删除线（保留旧行为）。
+  const seatTag = (agentId: string) => {
+    const alive = isExisting(agentId);
+    const label = nameById.get(agentId) ?? seatById.get(agentId)?.name ?? agentId;
+    return (
+      <span
+        key={`tag-${agentId}`}
+        className={cn(
+          "rounded border px-1.5 py-0.5 text-[11px] font-medium",
+          alive
+            ? chainTagClasses(getAvatarTypeFor(agentId, orderById.get(agentId) ?? 0))
+            : "border-dashed border-border bg-muted text-muted-foreground/60 line-through",
+        )}
+        title={alive ? undefined : "该智能体已不存在"}
+      >
+        {label}
+      </span>
+    );
+  };
+
   return (
     <button
       type="button"
@@ -322,36 +359,36 @@ function ChainCard({
         <div className="mt-1 line-clamp-1 text-xs text-muted-foreground">{chain.description}</div>
       )}
 
-      {/* 智能体名 tag（按顺序，← 箭头连接） */}
+      {/* 席位编排：按 stage 分组——并行阶段竖向并列在虚线框里，阶段之间用 → 串联。
+          不用 <Fragment>：dev 期 tagger 会往 Fragment 注入 data-lov-id 触发 React 警告，
+          这里用带 key 的扁平数组（箭头 + 阶段），注入落到真实元素上即可。 */}
       <div className="mt-2 flex flex-wrap items-center gap-1">
-        {chain.seats.flatMap((seat, i) => {
-          const alive = isExisting(seat.agent_id);
-          const label = nameById.get(seat.agent_id) ?? seat.name ?? seat.agent_id;
-          // 不用 <Fragment>：dev 期 tagger 会往 Fragment 注入 data-lov-id 触发 React 警告，
-          // 这里改成带 key 的扁平数组（箭头 + tag），注入落到真实元素上即可。
+        {stages.flatMap((stageIds, stageIdx) => {
           const nodes: ReactNode[] = [];
-          if (i > 0) {
+          if (stageIdx > 0) {
             nodes.push(
               <ArrowRightIcon
-                key={`arrow-${seat.agent_id}`}
+                key={`arrow-${stageIdx}`}
                 className="size-3 shrink-0 text-muted-foreground/50"
               />,
             );
           }
-          nodes.push(
-            <span
-              key={`tag-${seat.agent_id}`}
-              className={cn(
-                "rounded border px-1.5 py-0.5 text-[11px] font-medium",
-                alive
-                  ? chainTagClasses(getAvatarTypeFor(seat.agent_id, i))
-                  : "border-dashed border-border bg-muted text-muted-foreground/60 line-through",
-              )}
-              title={alive ? undefined : "该智能体已不存在"}
-            >
-              {label}
-            </span>,
-          );
+          if (stageIds.length > 1) {
+            // 并行阶段：席位竖向并列在虚线框里，左上角标「并行 N」。
+            nodes.push(
+              <div
+                key={`stage-${stageIdx}`}
+                className="relative flex flex-col gap-1 rounded-lg border border-dashed border-primary/40 bg-primary/[0.04] px-1.5 pb-1.5 pt-2.5"
+              >
+                <span className="pointer-events-none absolute -top-2 left-1.5 rounded-full bg-card px-1.5 text-[10px] font-semibold leading-tight text-primary">
+                  并行 {stageIds.length}
+                </span>
+                {stageIds.map((id) => seatTag(id))}
+              </div>,
+            );
+          } else {
+            nodes.push(seatTag(stageIds[0]));
+          }
           return nodes;
         })}
       </div>
diff --git a/frontend-web/src/roundtable-planning/components/Step1Panel.tsx b/frontend-web/src/roundtable-planning/components/Step1Panel.tsx
index d27c53b1..168b4c23 100644
--- a/frontend-web/src/roundtable-planning/components/Step1Panel.tsx
+++ b/frontend-web/src/roundtable-planning/components/Step1Panel.tsx
@@ -14,8 +14,10 @@
 import { useRef, useState } from "react";
 import {
   CheckCircle,
+  FileText,
   Loader2,
   MessageSquare,
+  Paperclip,
   Pause,
   Repeat,
   Save,
@@ -25,6 +27,13 @@ import {
   X,
 } from "lucide-react";
 
+/** 人类可读的文件大小（B / KB / MB）。 */
+function formatFileSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+
 import { Button } from "@/components/ui/button";
 import { Man1Avatar, RobotAvatar } from "@/roundtable-planning/components/Avatars";
 import {
@@ -62,7 +71,7 @@ export interface Step1PanelProps {
   setIntentClarificationSelections: React.Dispatch<
     React.SetStateAction<Map<string, IntentClarificationSelection>>
   >;
-  onSendMessage: (text: string) => void;
+  onSendMessage: (text: string, files?: File[]) => void;
   onStopIntent: () => void;
   onSkipQuestion: () => void;
   onFollowUp: () => void;
@@ -101,13 +110,34 @@ export function Step1Panel(props: Step1PanelProps) {
 
   // 输入框完全是本地状态 —— 提到 Page 层会导致每次打字都重渲整页。
   const [inputText, setInputText] = useState<string>("");
+  // 待发送的本地附件（点发送时连同文本一起上传）。
+  const [attachedFiles, setAttachedFiles] = useState<File[]>([]);
+  const fileInputRef = useRef<HTMLInputElement>(null);
 
   const charactersLeft = inputText.length;
 
+  const handlePickFiles = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const picked = Array.from(e.target.files ?? []);
+    if (picked.length > 0) {
+      // 去重（按 名称+大小），追加到已选列表。
+      setAttachedFiles((prev) => {
+        const seen = new Set(prev.map((f) => `${f.name}:${f.size}`));
+        return [...prev, ...picked.filter((f) => !seen.has(`${f.name}:${f.size}`))];
+      });
+    }
+    // 清空 input 值，允许再次选同名文件。
+    e.target.value = "";
+  };
+
+  const removeAttachedFile = (idx: number) => {
+    setAttachedFiles((prev) => prev.filter((_, i) => i !== idx));
+  };
+
   const handleSend = () => {
-    if (!inputText.trim()) return;
-    onSendMessage(inputText);
+    if (!inputText.trim() && attachedFiles.length === 0) return;
+    onSendMessage(inputText, attachedFiles.length > 0 ? attachedFiles : undefined);
     setInputText("");
+    setAttachedFiles([]);
   };
 
   return (
@@ -150,6 +180,33 @@ export function Step1Panel(props: Step1PanelProps) {
       {/* Bottom input area */}
       <div className="shrink-0 p-4 border-t border-slate-100 bg-[#fcfcfd]">
         <div className="relative border border-slate-200 focus-within:border-primary focus-within:ring-2 focus-within:ring-[var(--brand-200)]/50 transition-all rounded-xl overflow-hidden bg-white px-3 py-2.5">
+          {/* 已选附件预览（点发送时随消息上传） */}
+          {attachedFiles.length > 0 && (
+            <div className="flex flex-wrap gap-1.5 pb-2 mb-2 border-b border-slate-100">
+              {attachedFiles.map((file, idx) => (
+                <span
+                  key={`${file.name}-${file.size}-${idx}`}
+                  className="inline-flex items-center gap-1.5 bg-slate-50 border border-slate-200 rounded-lg pl-2 pr-1 py-1 text-[11px] text-slate-600 max-w-[200px]"
+                >
+                  <FileText className="w-3 h-3 shrink-0 text-primary" />
+                  <span className="truncate font-medium" title={file.name}>
+                    {file.name}
+                  </span>
+                  <span className="shrink-0 text-slate-400">
+                    {formatFileSize(file.size)}
+                  </span>
+                  <button
+                    type="button"
+                    onClick={() => removeAttachedFile(idx)}
+                    className="shrink-0 p-0.5 rounded hover:bg-slate-200 text-slate-400 hover:text-slate-600 transition"
+                    title="移除"
+                  >
+                    <X className="w-3 h-3" />
+                  </button>
+                </span>
+              ))}
+            </div>
+          )}
           <textarea
             id="input-text-area"
             value={inputText}
@@ -177,6 +234,21 @@ export function Step1Panel(props: Step1PanelProps) {
               >
                 <Smile className="w-4 h-4" />
               </button>
+              <input
+                ref={fileInputRef}
+                type="file"
+                multiple
+                className="hidden"
+                onChange={handlePickFiles}
+              />
+              <button
+                type="button"
+                onClick={() => fileInputRef.current?.click()}
+                title="上传参考文件（智能体将读取文件内容辅助理解任务）"
+                className="p-1 hover:text-primary hover:bg-slate-50 rounded transition"
+              >
+                <Paperclip className="w-4 h-4" />
+              </button>
             </div>
 
             <span className="text-[10px] font-mono text-slate-400">{charactersLeft}/500</span>
@@ -422,8 +494,30 @@ function Step1Message({
           )}
         </div>
       ) : (
-        <div className="roundtable-chat-message text-slate-700 font-medium whitespace-pre-wrap break-words">
-          {msg.content}
+        <div className="space-y-2">
+          {msg.files && msg.files.length > 0 && (
+            <div className="flex flex-wrap gap-1.5">
+              {msg.files.map((file, i) => (
+                <span
+                  key={`${file.filename}-${i}`}
+                  className="inline-flex items-center gap-1.5 bg-white/70 border border-slate-200 rounded-lg px-2 py-1 text-[11px] text-slate-600 max-w-[200px]"
+                >
+                  <FileText className="w-3 h-3 shrink-0 text-primary" />
+                  <span className="truncate font-medium" title={file.filename}>
+                    {file.filename}
+                  </span>
+                  <span className="shrink-0 text-slate-400">
+                    {formatFileSize(file.size)}
+                  </span>
+                </span>
+              ))}
+            </div>
+          )}
+          {msg.content && (
+            <div className="roundtable-chat-message text-slate-700 font-medium whitespace-pre-wrap break-words">
+              {msg.content}
+            </div>
+          )}
         </div>
       )}
     </MessageBubble>
diff --git a/frontend-web/src/roundtable-planning/components/Step2Panel.tsx b/frontend-web/src/roundtable-planning/components/Step2Panel.tsx
index e90ca228..cddfe6a4 100644
--- a/frontend-web/src/roundtable-planning/components/Step2Panel.tsx
+++ b/frontend-web/src/roundtable-planning/components/Step2Panel.tsx
@@ -23,11 +23,20 @@ import {
   HelpCircle,
   Loader2,
   Network,
+  Paperclip,
   Pause,
   Play,
   Sparkles,
+  X,
 } from "lucide-react";
 
+/** 人类可读的文件大小（B / KB / MB）。 */
+function formatFileSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+
 import {
   Dialog,
   DialogContent,
@@ -124,7 +133,7 @@ export interface Step2PanelProps {
   // ─── Handlers ─────────────────────────────────────────────────
   onPauseRoundtable: () => void;
   onResumeRoundtable: () => void;
-  onHandleInjectToRoundtable: () => void;
+  onHandleInjectToRoundtable: (files?: File[]) => void;
   onSubmitClarification: (answer: string) => void;
   onSavePersona: (id: number) => void;
   onProceedToStep3: () => void;
@@ -251,11 +260,34 @@ export function Step2Panel(props: Step2PanelProps) {
   // 干预研审:记录指令并自动恢复会商,右上角按钮状态由 isRoundTableRunning 驱动
   const [pauseFlash, setPauseFlash] = useState(false);
 
+  // 干预消息携带的本地附件（点「干预并发送」时连同指令一起上传）。
+  const [injectFiles, setInjectFiles] = useState<File[]>([]);
+  const injectFileInputRef = useRef<HTMLInputElement>(null);
+
+  const handlePickInjectFiles = useCallback(
+    (e: React.ChangeEvent<HTMLInputElement>) => {
+      const picked = Array.from(e.target.files ?? []);
+      if (picked.length > 0) {
+        setInjectFiles((prev) => {
+          const seen = new Set(prev.map((f) => `${f.name}:${f.size}`));
+          return [...prev, ...picked.filter((f) => !seen.has(`${f.name}:${f.size}`))];
+        });
+      }
+      e.target.value = "";
+    },
+    [],
+  );
+
+  const removeInjectFile = useCallback((idx: number) => {
+    setInjectFiles((prev) => prev.filter((_, i) => i !== idx));
+  }, []);
+
   const handleInject = useCallback(() => {
-    onHandleInjectToRoundtable();
+    onHandleInjectToRoundtable(injectFiles.length > 0 ? injectFiles : undefined);
+    setInjectFiles([]);
     setPauseFlash(true);
     window.setTimeout(() => setPauseFlash(false), 1600);
-  }, [onHandleInjectToRoundtable]);
+  }, [onHandleInjectToRoundtable, injectFiles]);
 
   const isSandboxStreaming =
     isOrchestrating ||
@@ -530,7 +562,35 @@ export function Step2Panel(props: Step2PanelProps) {
       )}
 
       {/* Console + intervention bar */}
-      <div className="shrink-0 p-4 bg-slate-50 border-t border-slate-100 flex items-center gap-3">
+      <div className="shrink-0 p-4 bg-slate-50 border-t border-slate-100 flex flex-col gap-2">
+        {/* 已选附件预览（点「干预并发送」时随指令上传） */}
+        {injectFiles.length > 0 && (
+          <div className="flex flex-wrap gap-1.5">
+            {injectFiles.map((file, idx) => (
+              <span
+                key={`${file.name}-${file.size}-${idx}`}
+                className="inline-flex items-center gap-1.5 bg-white border border-slate-200 rounded-lg pl-2 pr-1 py-1 text-[11px] text-slate-600 max-w-[200px]"
+              >
+                <FileIcon className="w-3 h-3 shrink-0 text-primary" />
+                <span className="truncate font-medium" title={file.name}>
+                  {file.name}
+                </span>
+                <span className="shrink-0 text-slate-400">
+                  {formatFileSize(file.size)}
+                </span>
+                <button
+                  type="button"
+                  onClick={() => removeInjectFile(idx)}
+                  className="shrink-0 p-0.5 rounded hover:bg-slate-200 text-slate-400 hover:text-slate-600 transition"
+                  title="移除"
+                >
+                  <X className="w-3 h-3" />
+                </button>
+              </span>
+            ))}
+          </div>
+        )}
+        <div className="flex items-center gap-3">
         <input
           type="text"
           value={customAgentInput}
@@ -542,6 +602,22 @@ export function Step2Panel(props: Step2PanelProps) {
           className="flex-1 bg-white border border-slate-200 rounded-xl px-3.5 py-2.5 text-xs focus:outline-none focus:border-primary focus:ring-1 focus:ring-[var(--brand-200)]/50 font-medium"
         />
 
+        <input
+          ref={injectFileInputRef}
+          type="file"
+          multiple
+          className="hidden"
+          onChange={handlePickInjectFiles}
+        />
+        <button
+          type="button"
+          onClick={() => injectFileInputRef.current?.click()}
+          title="上传参考文件（席位/总控将读取文件内容辅助研讨）"
+          className="bg-white border border-slate-200 hover:bg-slate-50 text-slate-500 hover:text-primary p-2.5 rounded-xl transition shrink-0 cursor-pointer active:scale-95"
+        >
+          <Paperclip className="w-4 h-4" />
+        </button>
+
         <button
           type="button"
           onClick={handleInject}
@@ -581,6 +657,7 @@ export function Step2Panel(props: Step2PanelProps) {
           <Sparkles className="w-3.5 h-3.5 text-emerald-100" />
           达成共识生成全案成果 &gt;
         </button>
+        </div>
       </div>
     </>
   );
diff --git a/frontend-web/src/roundtable-planning/hooks/useStep1Intent.ts b/frontend-web/src/roundtable-planning/hooks/useStep1Intent.ts
index 89ec494e..fa9f26d4 100644
--- a/frontend-web/src/roundtable-planning/hooks/useStep1Intent.ts
+++ b/frontend-web/src/roundtable-planning/hooks/useStep1Intent.ts
@@ -19,9 +19,11 @@ import {
   initIntent,
   streamIntent,
   type IntentErrorDetail,
+  type IntentFileRef,
   type IntentStreamPhase,
   type IntentSummary,
 } from "@/roundtable-planning/api/intent";
+import { uploadFiles } from "@/core/uploads/api";
 import {
   clarificationKey,
   formatIntentClarificationAnswer,
@@ -42,6 +44,8 @@ export type InteractiveMessage = {
   time: string;
   streaming?: boolean;
   phase?: string;
+  /** 用户气泡里附带的上传文件（仅展示用：文件名 + 大小）。 */
+  files?: Array<{ filename: string; size: number }>;
   /** First clarification (back-compat); prefer `clarifications`. */
   clarification?: ClarificationPayload;
   /**
@@ -109,8 +113,12 @@ export interface UseStep1IntentReturn {
   // ─── Handlers ────────────────────────────────────────────────────────
   /** 清空当前 Step 1 状态并重新拉取 intent thread。 */
   runStep1Init: () => void;
-  /** 把 `userText` 作为用户气泡发给 intent agent,流式渲染回复。 */
-  sendIntentMessage: (userText: string) => Promise<void>;
+  /**
+   * 把 `userText` 作为用户气泡发给 intent agent,流式渲染回复。
+   * `files`:可选的本地文件,发送前先上传到 intent thread,再把引用随消息提交(后端
+   * 注入 additional_kwargs.files,意图智能体即可 read_file 读取)。允许「仅文件无文本」。
+   */
+  sendIntentMessage: (userText: string, files?: File[]) => Promise<void>;
   /**
    * 提交某条 agent 消息的全部澄清问题答案 —— 逐题取各自选择,拼成一条合并消息
    * 发回。至少答一题才会发送。单题时退化为发送该题答案。
@@ -123,6 +131,12 @@ export interface UseStep1IntentReturn {
     clarifications: ClarificationPayload[],
     overrideByKey?: Record<string, IntentClarificationSelection>,
   ) => void;
+  /**
+   * 用户在「当前意图摘要」卡里手动编辑后保存：直接覆盖 `intentReady`。下游(Step 2 seed
+   * `buildInitialIntent`、左右侧栏摘要卡、step2Locked 判定)都读 `intentReady`,改这里即全局生效。
+   * 持久化由调用方(页面)在更新后触发草稿保存。
+   */
+  updateIntentReady: (next: IntentSummary) => void;
   /** Abort 当前 intent 流。气泡尾部追加「(已暂停)」并 toast。 */
   stopIntentStream: () => void;
   /** 从草稿加载:批量 setState + 标记 init 已完成,跳过自动 runStep1Init。 */
@@ -269,9 +283,10 @@ export function useStep1Intent(options: UseStep1IntentOptions): UseStep1IntentRe
   }, [interactiveMessages, intentReady]);
 
   const sendIntentMessage = useCallback(
-    async (userText: string) => {
+    async (userText: string, files?: File[]) => {
       const trimmed = userText.trim();
-      if (!trimmed) return;
+      const hasFiles = !!(files && files.length > 0);
+      if (!trimmed && !hasFiles) return;
       if (!intentThreadId) {
         triggerToast("⚠️ 任务理解智能体尚未就绪,请稍候");
         return;
@@ -298,16 +313,24 @@ export function useStep1Intent(options: UseStep1IntentOptions): UseStep1IntentRe
         senderName: "用户",
         content: trimmed,
         time: userMsgTime,
+        files: hasFiles
+          ? files!.map((f) => ({ filename: f.name, size: f.size }))
+          : undefined,
       };
       setInteractiveMessages((prev) => [...prev, userMsg]);
 
+      const timelineDesc = trimmed
+        ? trimmed.length > 25
+          ? trimmed.substring(0, 25) + "..."
+          : trimmed
+        : `上传了 ${files!.length} 个文件`;
       setTimelineEntries((prev) => [
         ...prev,
         {
           id: prev.length + 1,
           time: userMsgTime,
           title: "用户实时反馈",
-          desc: trimmed.length > 25 ? trimmed.substring(0, 25) + "..." : trimmed,
+          desc: timelineDesc,
         },
       ]);
 
@@ -327,10 +350,49 @@ export function useStep1Intent(options: UseStep1IntentOptions): UseStep1IntentRe
 
       setIsIntentSending(true);
       try {
+        // 先把本地文件上传到 intent thread —— 与普通聊天同一上传接口/技能链路。
+        // 拿到 virtual_path 后随消息提交，后端注入 additional_kwargs.files。
+        let fileRefs: IntentFileRef[] | undefined;
+        if (hasFiles) {
+          setInteractiveMessages((prev) =>
+            prev.map((m) =>
+              m.id === agentMsgId ? { ...m, phase: "正在上传文件" } : m,
+            ),
+          );
+          try {
+            const up = await uploadFiles(intentThreadId, files!);
+            fileRefs = up.files.map((f) => ({
+              filename: f.filename,
+              size: f.size,
+              path: f.virtual_path,
+              status: "uploaded" as const,
+            }));
+          } catch (err) {
+            setInteractiveMessages((prev) =>
+              prev.map((m) =>
+                m.id === agentMsgId
+                  ? {
+                      ...m,
+                      content: `(文件上传失败) ${(err as Error).message}`,
+                      streaming: false,
+                    }
+                  : m,
+              ),
+            );
+            triggerToast(`❌ 文件上传失败: ${(err as Error).message}`);
+            if (intentAborterRef.current === aborter) {
+              intentAborterRef.current = null;
+            }
+            setIsIntentSending(false);
+            return;
+          }
+        }
+
         const res = await streamIntent({
           threadId: intentThreadId,
           message: trimmed,
           model: selectedModelRef.current || undefined,
+          files: fileRefs,
           signal: aborter.signal,
           onTextDelta: (delta) => {
             setInteractiveMessages((prev) =>
@@ -568,6 +630,12 @@ export function useStep1Intent(options: UseStep1IntentOptions): UseStep1IntentRe
     setInteractiveMessages((prev) => [...prev, msg]);
   }, []);
 
+  const updateIntentReady = useCallback((next: IntentSummary) => {
+    // 用户手动改完意图 → 覆盖为权威值,并清掉「待澄清」态(已确认意图,无需再答问)。
+    setIntentReady(next);
+    setPendingIntentClarificationMsgId(null);
+  }, []);
+
   return {
     intentThreadId,
     intentReady,
@@ -582,6 +650,7 @@ export function useStep1Intent(options: UseStep1IntentOptions): UseStep1IntentRe
     runStep1Init,
     sendIntentMessage,
     submitIntentClarifications,
+    updateIntentReady,
     stopIntentStream,
     hydrateFromDraft,
     appendLocalMessage,
diff --git a/frontend-web/src/roundtable-planning/hooks/useStep2Orchestration.ts b/frontend-web/src/roundtable-planning/hooks/useStep2Orchestration.ts
index 8dcc2820..72089437 100644
--- a/frontend-web/src/roundtable-planning/hooks/useStep2Orchestration.ts
+++ b/frontend-web/src/roundtable-planning/hooks/useStep2Orchestration.ts
@@ -23,8 +23,20 @@ import {
   type ClarificationPayload,
   type LeaderDispatch,
   type StreamPhase,
+  type StreamMultiAgentRequest,
   type ThreadIdMap,
 } from "@/roundtable-planning/api/multi-agent";
+import { uploadFiles } from "@/core/uploads/api";
+
+/** 干预消息携带的上传文件引用（与 streamMultiAgent 的 files 字段同形）。 */
+type RunFileRef = NonNullable<StreamMultiAgentRequest["files"]>[number];
+
+/** 读取并清空 ref（consume-once）：首个 leader run 拿到文件后清空，后续轮次不再带。 */
+function takeOnce<T>(ref: { current: T | null }): T | undefined {
+  const v = ref.current ?? undefined;
+  ref.current = null;
+  return v;
+}
 import {
   buildDagStageLeaderTask,
   pickDagSeatTask,
@@ -305,8 +317,11 @@ export interface UseStep2OrchestrationReturn {
   recordInjectMessage: () => void;
   /** 中断所有 in-flight SSE(给新建任务 / 加载草稿用)。 */
   abortAllInFlight: () => void;
-  /** 一键干预:记录指令 + 自动恢复会商 + 触发新一轮编排(替代 pause + record + resume 组合)。 */
-  handleInjectToRoundtable: () => void;
+  /**
+   * 一键干预:记录指令 + 自动恢复会商 + 触发新一轮编排(替代 pause + record + resume 组合)。
+   * `files`:可选的参考文件,发送前先上传到总控 thread,首轮 leader run 据此 read_file 读取。
+   */
+  handleInjectToRoundtable: (files?: File[]) => void;
   /** 总控澄清回复 —— 把回答拼到 prompt 里再起一轮编排。 */
   submitClarification: (rawAnswer: string) => void;
   /** 预算滑块(本地演示,非编排真实输入)。 */
@@ -464,6 +479,11 @@ export function useStep2Orchestration(
   const activeAbortersRef = useRef<Set<AbortController>>(new Set());
   /** 干预研审:恢复会商后待执行的 leader prompt。 */
   const pendingInjectPromptRef = useRef<string | null>(null);
+  /**
+   * 干预消息携带的上传文件引用：由下一轮编排的**首个 leader run**消费一次后清空，
+   * 总控据此 read_file 读取文件再派活。consume-once 语义避免后续轮次重复带文件。
+   */
+  const pendingInjectFilesRef = useRef<RunFileRef[] | null>(null);
   // selectedModel / agentConfigs / agentNameToRole / threadIds / coordinatorName
   // 等等被 runOrchestration 在循环里反复读取。把它们打到 ref 上,可以让
   // runOrchestration 的 useCallback deps 大幅收窄,避免每次模型切换、agentConfigs
@@ -1353,6 +1373,8 @@ export function useStep2Orchestration(
               // 第 2 轮起(已有席位交付)才是「综合轮」:让后端注入各席位完整交付供总控收口。
               // 首轮纯派活、无交付,传 false 保持上下文精简。
               synthesisMode: safetyCounter > 1,
+              // 用户随干预上传的参考文件(consume-once:仅首轮 leader 带,之后清空)。
+              files: takeOnce(pendingInjectFilesRef),
               model: selectedModelRef.current || undefined,
               signal: leaderAborter.signal,
               onTextDelta: (text) => appendToDialogue(leaderBubbleId, text),
@@ -1600,6 +1622,8 @@ export function useStep2Orchestration(
               dAgentThreadId: ids,
               agentName: coord,
               newMessage: leaderTask,
+              // 用户随干预上传的参考文件(consume-once:仅首轮 leader 带,之后清空)。
+              files: takeOnce(pendingInjectFilesRef),
               model: selectedModelRef.current || undefined,
               signal: leaderAborter.signal,
               onTextDelta: (text) => appendToDialogue(leaderBubbleId, text),
@@ -1887,6 +1911,8 @@ export function useStep2Orchestration(
               // 抑制预广播:别把总控的派活 prompt 播进席位 thread(否则弱模型从历史里捡到派活
               // 意图、跟着模仿派活 / 绕道 bash 调内部接口)。席位任务由 pickDagSeatTask 干净下发。
               suppressPreBroadcast: true,
+              // 用户随干预上传的参考文件(consume-once:仅首轮 leader 带,之后清空)。
+              files: takeOnce(pendingInjectFilesRef),
               model: selectedModelRef.current || undefined,
               signal: leaderAborter.signal,
               onTextDelta: (text) => appendToDialogue(leaderBubbleId, text),
@@ -2289,38 +2315,75 @@ export function useStep2Orchestration(
     triggerToast("干预指令已记录,会商已自动恢复执行");
   }, [appendDialogue, customAgentInput, triggerToast]);
 
-  const handleInjectToRoundtable = useCallback(() => {
-    const userText = customAgentInput.trim();
-    if (!userText) return;
-    if (!threadIdsRef.current || !coordinatorNameRef.current) {
-      triggerToast("⚠️ 圆桌尚未就绪,无法记录干预指令");
-      return;
-    }
+  const handleInjectToRoundtable = useCallback(
+    async (files?: File[]) => {
+      const userText = customAgentInput.trim();
+      const hasFiles = !!(files && files.length > 0);
+      if (!userText && !hasFiles) return;
+      if (!threadIdsRef.current || !coordinatorNameRef.current) {
+        triggerToast("⚠️ 圆桌尚未就绪,无法记录干预指令");
+        return;
+      }
 
-    // 中止当前编排（如有）
-    orchestrationCancelRef.current = true;
-    abortAllInFlight();
-    // 强制标记非编排中,使后续 runOrchestration 可立即启动
-    isOrchestratingRef.current = false;
-    setIsOrchestrating(false);
+      // 先把文件上传到总控 thread（与普通聊天同一上传接口/技能链路）。拿到 virtual_path
+      // 存进 consume-once ref,供下一轮首个 leader run 注入 additional_kwargs.files。
+      // 上传失败则中止本次干预,不打断当前会商。
+      if (hasFiles) {
+        const coordThreadId = resolveSeatThreadId(
+          threadIdsRef.current,
+          coordinatorNameRef.current,
+        );
+        try {
+          const up = await uploadFiles(coordThreadId, files!);
+          pendingInjectFilesRef.current = up.files.map((f) => ({
+            filename: f.filename,
+            size: f.size,
+            path: f.virtual_path,
+            status: "uploaded",
+          }));
+        } catch (err) {
+          triggerToast(`❌ 文件上传失败: ${(err as Error).message}`);
+          return;
+        }
+      }
 
-    setCustomAgentInput("");
-    appendDialogue({
-      sender: "用户 (插话干预)",
-      avatarType: "human",
-      content: `💡 (人工指令介入) ${userText}`,
-      confidence: "最高指令",
-    });
+      // 中止当前编排（如有）
+      orchestrationCancelRef.current = true;
+      abortAllInFlight();
+      // 强制标记非编排中,使后续 runOrchestration 可立即启动
+      isOrchestratingRef.current = false;
+      setIsOrchestrating(false);
 
-    const prompt = `用户人工干预新指令:${userText}\n\n请优先按这条新指令,通过 agent_orchestration 把活派给相关的真实席位去获取交付;若用户点名了某个席位(如"前端实现"),必须派给清单里对应的那个 agent_name。**不要**自己代答,也**不要**在没有真正看到该席位「完成…交付内容为:…」的情况下臆造交付或直接收口。只有当用户明确要求收口、或相关席位都已真实交付时,才综合输出结论。`;
+      setCustomAgentInput("");
+      const fileNote = hasFiles ? `（附 ${files!.length} 个文件）` : "";
+      const shownText = userText || "(上传了参考文件)";
+      appendDialogue({
+        sender: "用户 (插话干预)",
+        avatarType: "human",
+        content: `💡 (人工指令介入) ${shownText}${fileNote}`,
+        confidence: "最高指令",
+      });
 
-    // 确保处于运行状态（同步更新按钮 UI）
-    setIsRoundTableRunning(true);
-    triggerToast("干预指令已发送,会商继续执行");
+      const promptText =
+        userText || "我上传了参考文件,请先阅读文件内容,再据此推进研讨。";
+      const prompt = `用户人工干预新指令:${promptText}\n\n请优先按这条新指令,通过 agent_orchestration 把活派给相关的真实席位去获取交付;若用户点名了某个席位(如"前端实现"),必须派给清单里对应的那个 agent_name。**不要**自己代答,也**不要**在没有真正看到该席位「完成…交付内容为:…」的情况下臆造交付或直接收口。只有当用户明确要求收口、或相关席位都已真实交付时,才综合输出结论。`;
 
-    // 直接启动新一轮编排
-    void runActiveOrchestration(prompt, threadIdsRef.current, coordinatorNameRef.current);
-  }, [customAgentInput, appendDialogue, abortAllInFlight, runActiveOrchestration, triggerToast]);
+      // 确保处于运行状态（同步更新按钮 UI）
+      setIsRoundTableRunning(true);
+      triggerToast("干预指令已发送,会商继续执行");
+
+      // 直接启动新一轮编排
+      void runActiveOrchestration(prompt, threadIdsRef.current, coordinatorNameRef.current);
+    },
+    [
+      customAgentInput,
+      appendDialogue,
+      abortAllInFlight,
+      runActiveOrchestration,
+      resolveSeatThreadId,
+      triggerToast,
+    ],
+  );
 
   const submitClarification = useCallback(
     (rawAnswer: string) => {
diff --git a/frontend-web/src/roundtable-planning/pages/BusinessChainListPage.tsx b/frontend-web/src/roundtable-planning/pages/BusinessChainListPage.tsx
new file mode 100644
index 00000000..0929ce46
--- /dev/null
+++ b/frontend-web/src/roundtable-planning/pages/BusinessChainListPage.tsx
@@ -0,0 +1,64 @@
+/**
+ * 业务链条配置页（独立页面版）。
+ *
+ * 把原本挂在圆桌页顶栏「业务链条」按钮上的 `BusinessChainListDialog` 弹窗内容，
+ * 单独画成一个全屏页面：综合管理 → 业务链条配置 入口进来即是本页。
+ *
+ *  - 列表主体复用 `BusinessChainListBody`（与弹窗同一份加载 / 发布 / 卡片逻辑）。
+ *  - 顶部「配置」按钮 = 进入编辑器空白新建；卡片「设置」= 进入编辑器并切到该链条。
+ *
+ * 路由 base 感知：用 `useRouteNavigate` 跳转，strategy / workspace 两套路由树下
+ * 都能落到当前 base 的编辑器（`roundtable/chains`）。
+ */
+import { LayersIcon, SettingsIcon } from "lucide-react";
+
+import { Button } from "@/components/ui/button";
+import { useRouteNavigate } from "@/core/route-base";
+
+import { BusinessChainListBody } from "@/roundtable-planning/components/BusinessChainListDialog";
+
+export default function BusinessChainListPage() {
+  const navigate = useRouteNavigate();
+
+  // 进入编辑器：带 chainId = 打开并切到该链条；不带 = 空白新建。
+  // 路径写 workspace base，`useRouteNavigate` 会按当前路由 base 改写。
+  const goConfigure = (chainId?: string) => {
+    navigate(
+      chainId
+        ? `/page/workspace/roundtable/chains?chainId=${encodeURIComponent(chainId)}`
+        : "/page/workspace/roundtable/chains",
+    );
+  };
+
+  return (
+    <div className="flex h-full min-h-0 flex-col bg-muted/40 text-foreground">
+      {/* 顶栏：标题 + 描述 + 配置入口 */}
+      <header className="shrink-0 border-b border-border bg-card px-6 py-4">
+        <div className="mx-auto flex w-full max-w-3xl items-start justify-between gap-4">
+          <div className="min-w-0">
+            <div className="flex items-center gap-2 text-base font-bold text-foreground">
+              <LayersIcon className="size-5 text-primary" />
+              业务链条配置
+            </div>
+            <p className="mt-1 text-xs leading-relaxed text-muted-foreground">
+              可复用的有序智能体编排。点击卡片「设置」可进入编辑器修改该链条；「发布」后所有账号都能在「公共」里查看 / 选用。
+            </p>
+          </div>
+          <Button onClick={() => goConfigure()} className="shrink-0 gap-1.5">
+            <SettingsIcon className="size-4" />
+            配置
+          </Button>
+        </div>
+      </header>
+
+      {/* 列表主体（与弹窗共用 BusinessChainListBody） */}
+      <div className="mx-auto flex w-full min-h-0 max-w-3xl flex-1 flex-col px-6 py-4">
+        <BusinessChainListBody
+          active
+          onConfigure={goConfigure}
+          emptyHint="业务链条是可复用的有序智能体编排。点击右上角「配置」去创建第一条链条。"
+        />
+      </div>
+    </div>
+  );
+}
diff --git a/frontend-web/src/roundtable-planning/pages/RoundtablePlanningPage.tsx b/frontend-web/src/roundtable-planning/pages/RoundtablePlanningPage.tsx
index e4d75d7f..6ed9b8c0 100644
--- a/frontend-web/src/roundtable-planning/pages/RoundtablePlanningPage.tsx
+++ b/frontend-web/src/roundtable-planning/pages/RoundtablePlanningPage.tsx
@@ -41,12 +41,14 @@ import {
   ListOrdered,
   Loader2,
   Pencil,
+  Plus,
   Save,
   Settings,
   Sparkles,
   Trash2,
   Upload,
   Users,
+  X,
 } from "lucide-react";
 
 import { useTheme } from "@/contexts/ThemeContext";
@@ -89,6 +91,7 @@ import {
   type SeatSelectionResult,
 } from "@/roundtable-planning/lib/business-chain";
 import type { OrchestrationPlan } from "@/roundtable-planning/lib/dag-types";
+import type { IntentSummary } from "@/roundtable-planning/api/intent";
 import { getJobByDraft, startJob } from "@/roundtable-planning/api/roundtable-jobs";
 import { getChain } from "@/roundtable-planning/api/chains";
 import { filterRecommendCandidates } from "@/roundtable-planning/api/recommend";
@@ -499,6 +502,26 @@ export default function RoundtablePlanningPage() {
     loadedFromDraftRefHolder.current = drafts.loadedFromDraftRef.current;
   });
 
+  // ─── 用户手动编辑「当前意图摘要」并保存 ───────────────────────
+  // 先 updateIntentReady 覆盖意图,再 bump 计数触发一次草稿保存。**必须用计数 + effect**
+  // 而非直接调 handleManualSave:enqueueSave 闭包捕获的 getStep1Snapshot 读的是本次渲染的
+  // step1.intentReady,同步调用会在 setState flush 前存进旧意图(踩坑);放到 effect 里,等
+  // 重渲染后再保存,getStep1Snapshot 才读到新值(与 step2/step3 的计数触发器同构)。
+  const [intentEditTick, setIntentEditTick] = useState(0);
+  const handleSaveIntent = useCallback(
+    (next: IntentSummary) => {
+      step1.updateIntentReady(next);
+      setIntentEditTick((t) => t + 1);
+    },
+    [step1],
+  );
+  useEffect(() => {
+    if (intentEditTick === 0) return;
+    drafts.handleManualSave();
+    // 仅在 tick 递增时保存;handleManualSave 取最新闭包(effect 跑在重渲染之后)。
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [intentEditTick]);
+
   // ─── 从侧边栏「多智能体会商」记录进入 ───────────────────────
   // 侧边栏点击某条草稿时:不在本页 → 把 id 存进 sessionStorage 再跳转,挂载时消费;
   // 已在本页 → 直接派 `roundtable:open-draft` 事件。两条路径都走 handleLoadDraft。
@@ -987,7 +1010,7 @@ export default function RoundtablePlanningPage() {
               pendingIntentClarificationMsgId={step1.pendingIntentClarificationMsgId}
               intentClarificationSelections={step1.intentClarificationSelections}
               setIntentClarificationSelections={step1.setIntentClarificationSelections}
-              onSendMessage={(text) => void step1.sendIntentMessage(text)}
+              onSendMessage={(text, files) => void step1.sendIntentMessage(text, files)}
               onStopIntent={step1.stopIntentStream}
               onSkipQuestion={handleSkipQuestion}
               onFollowUp={handleAgentFollowUp}
@@ -1106,6 +1129,7 @@ export default function RoundtablePlanningPage() {
           intentReady={step1.intentReady}
           timelineEntries={step1.timelineEntries}
           triggerToast={triggerToast}
+          onSaveIntent={handleSaveIntent}
         />
       </main>
     </div>
@@ -1763,6 +1787,148 @@ function ModelSelectorCard({
   );
 }
 
+/**
+ * 「当前意图摘要」编辑态：目标(单行/多行文本)、约束、关键假设(均为可增删的列表)。
+ * 受控本地草稿,保存时过滤空行、要求目标非空,再上抛 {@link IntentSummary}。
+ */
+function IntentSummaryEditor({
+  initial,
+  title,
+  onSave,
+  onCancel,
+}: {
+  initial: IntentSummary;
+  title: string;
+  onSave: (next: IntentSummary) => void;
+  onCancel: () => void;
+}) {
+  const [objective, setObjective] = useState(initial.objective ?? "");
+  const [constraints, setConstraints] = useState<string[]>(
+    initial.constraints?.length ? [...initial.constraints] : [""],
+  );
+  const [assumptions, setAssumptions] = useState<string[]>(
+    initial.assumptions?.length ? [...initial.assumptions] : [],
+  );
+
+  const objectiveInvalid = objective.trim().length === 0;
+
+  const updateRow = (
+    setter: React.Dispatch<React.SetStateAction<string[]>>,
+    idx: number,
+    value: string,
+  ) => setter((prev) => prev.map((v, i) => (i === idx ? value : v)));
+  const removeRow = (setter: React.Dispatch<React.SetStateAction<string[]>>, idx: number) =>
+    setter((prev) => prev.filter((_, i) => i !== idx));
+  const addRow = (setter: React.Dispatch<React.SetStateAction<string[]>>) =>
+    setter((prev) => [...prev, ""]);
+
+  const handleSave = () => {
+    if (objectiveInvalid) return;
+    onSave({
+      objective: objective.trim(),
+      constraints: constraints.map((c) => c.trim()).filter(Boolean),
+      assumptions: assumptions.map((a) => a.trim()).filter(Boolean),
+    });
+  };
+
+  const rowList = (
+    label: string,
+    rows: string[],
+    setter: React.Dispatch<React.SetStateAction<string[]>>,
+    placeholder: string,
+  ) => (
+    <div className="space-y-1.5">
+      <span className="text-[10px] font-bold text-slate-500 uppercase tracking-wider">{label}</span>
+      <div className="space-y-1.5">
+        {rows.map((row, i) => (
+          <div key={i} className="flex items-center gap-1.5">
+            <input
+              value={row}
+              onChange={(e) => updateRow(setter, i, e.target.value)}
+              placeholder={placeholder}
+              maxLength={200}
+              className="min-w-0 flex-1 rounded-lg border border-slate-200 bg-white px-2.5 py-1.5 text-[11.5px] text-slate-700 focus:border-primary focus:outline-none focus:ring-1 focus:ring-[var(--brand-200)]/50"
+            />
+            <button
+              type="button"
+              onClick={() => removeRow(setter, i)}
+              title="删除该项"
+              className="flex h-7 w-7 shrink-0 items-center justify-center rounded-lg text-slate-400 hover:bg-rose-50 hover:text-rose-500 transition-colors"
+            >
+              <Trash2 className="h-3.5 w-3.5" />
+            </button>
+          </div>
+        ))}
+        <button
+          type="button"
+          onClick={() => addRow(setter)}
+          className="inline-flex items-center gap-1 text-[11px] font-bold text-slate-500 hover:text-primary transition-colors"
+        >
+          <Plus className="h-3.5 w-3.5" />
+          添加{label}
+        </button>
+      </div>
+    </div>
+  );
+
+  return (
+    <div className="bg-white border border-primary/30 rounded-2xl p-4.5 shadow-[0_2px_8px_rgba(0,0,0,0.01)]">
+      <div className="flex items-center justify-between gap-2 border-b border-slate-100 pb-2.5 mb-3">
+        <div className="flex items-center gap-2 min-w-0">
+          <IntentSectionIcon className="w-4 h-4" />
+          <h2 className="text-xs font-bold text-slate-900 uppercase tracking-widest truncate">
+            编辑{title}
+          </h2>
+        </div>
+        <div className="flex items-center gap-1 shrink-0">
+          <button
+            type="button"
+            onClick={handleSave}
+            disabled={objectiveInvalid}
+            title="保存"
+            className="flex h-7 items-center gap-1 rounded-lg bg-primary px-2.5 text-[11px] font-bold text-white hover:bg-[var(--brand-900)] disabled:bg-slate-300 disabled:cursor-not-allowed transition-colors"
+          >
+            <Check className="h-3.5 w-3.5" />
+            保存
+          </button>
+          <button
+            type="button"
+            onClick={onCancel}
+            title="取消"
+            className="flex h-7 w-7 items-center justify-center rounded-lg text-slate-500 hover:bg-slate-50 hover:text-slate-700 transition-colors"
+          >
+            <X className="h-4 w-4" />
+          </button>
+        </div>
+      </div>
+
+      <div className="space-y-3">
+        <div className="space-y-1.5">
+          <span className="text-[10px] font-bold text-slate-500 uppercase tracking-wider">核心目标</span>
+          <textarea
+            value={objective}
+            onChange={(e) => setObjective(e.target.value)}
+            rows={3}
+            maxLength={500}
+            placeholder="一句话说明本次要达成什么"
+            className={cn(
+              "w-full resize-y rounded-lg border bg-white px-2.5 py-1.5 text-[11.5px] leading-relaxed text-slate-700 focus:outline-none focus:ring-1",
+              objectiveInvalid
+                ? "border-rose-300 focus:border-rose-400 focus:ring-rose-200/50"
+                : "border-slate-200 focus:border-primary focus:ring-[var(--brand-200)]/50",
+            )}
+          />
+          {objectiveInvalid && (
+            <p className="text-[10px] text-rose-500">核心目标不能为空</p>
+          )}
+        </div>
+        {rowList("约束", constraints, setConstraints, "如：预算 / 时间 / 合规 / 范围")}
+        {rowList("假设", assumptions, setAssumptions, "智能体为你做的假设（可选）")}
+      </div>
+    </div>
+  );
+}
+
 interface IntentSummaryCardProps {
   intentReady: ReturnType<typeof useStep1Intent>["intentReady"];
   title?: string;
@@ -1773,6 +1939,11 @@ interface IntentSummaryCardProps {
     expanded: boolean;
     onToggle: () => void;
   };
+  /**
+   * 提供则显示「编辑」按钮,允许用户手动修改识别出的意图(目标 / 约束 / 假设)并保存。
+   * 保存后回调上抛新意图,由页面覆盖 `intentReady` 并持久化草稿。不传 = 只读。
+   */
+  onSave?: (next: IntentSummary) => void;
 }
 
 function IntentSummaryCard({
@@ -1780,9 +1951,25 @@ function IntentSummaryCard({
   title = "当前意图摘要",
   collapsible = false,
   sidebarToggle,
+  onSave,
 }: IntentSummaryCardProps) {
   const [expanded, setExpanded] = useState(!collapsible);
   const showFullDetail = !collapsible || expanded;
+  const [editing, setEditing] = useState(false);
+
+  if (editing && intentReady) {
+    return (
+      <IntentSummaryEditor
+        initial={intentReady}
+        title={title}
+        onCancel={() => setEditing(false)}
+        onSave={(next) => {
+          onSave?.(next);
+          setEditing(false);
+        }}
+      />
+    );
+  }
 
   return (
     <div className="bg-white border border-slate-200/50 rounded-2xl p-4.5 shadow-[0_2px_8px_rgba(0,0,0,0.01)]">
@@ -1791,21 +1978,33 @@ function IntentSummaryCard({
           <IntentSectionIcon className="w-4 h-4" />
           <h2 className="text-xs font-bold text-slate-900 uppercase tracking-widest truncate">{title}</h2>
         </div>
-        {sidebarToggle && (
-          <button
-            type="button"
-            onClick={sidebarToggle.onToggle}
-            title={sidebarToggle.expanded ? "收起侧栏" : "展开侧栏"}
-            aria-expanded={sidebarToggle.expanded}
-            className="shrink-0 flex h-7 w-7 items-center justify-center rounded-lg text-slate-500 hover:text-primary hover:bg-slate-50 transition-colors"
-          >
-            {sidebarToggle.expanded ? (
-              <PanelLeftClose className="h-4 w-4" />
-            ) : (
-              <PanelLeftOpen className="h-4 w-4" />
-            )}
-          </button>
-        )}
+        <div className="flex items-center gap-1 shrink-0">
+          {onSave && intentReady && (
+            <button
+              type="button"
+              onClick={() => setEditing(true)}
+              title="编辑意图"
+              className="flex h-7 w-7 items-center justify-center rounded-lg text-slate-500 hover:text-primary hover:bg-slate-50 transition-colors"
+            >
+              <Pencil className="h-3.5 w-3.5" />
+            </button>
+          )}
+          {sidebarToggle && (
+            <button
+              type="button"
+              onClick={sidebarToggle.onToggle}
+              title={sidebarToggle.expanded ? "收起侧栏" : "展开侧栏"}
+              aria-expanded={sidebarToggle.expanded}
+              className="flex h-7 w-7 items-center justify-center rounded-lg text-slate-500 hover:text-primary hover:bg-slate-50 transition-colors"
+            >
+              {sidebarToggle.expanded ? (
+                <PanelLeftClose className="h-4 w-4" />
+              ) : (
+                <PanelLeftOpen className="h-4 w-4" />
+              )}
+            </button>
+          )}
+        </div>
       </div>
 
       <div className="p-3 bg-slate-50/50 border border-slate-100 rounded-xl space-y-3 mr-0.5">
@@ -2052,6 +2251,8 @@ interface RightSidebarProps {
   intentReady: ReturnType<typeof useStep1Intent>["intentReady"];
   timelineEntries: ReturnType<typeof useStep1Intent>["timelineEntries"];
   triggerToast: (msg: string) => void;
+  /** 用户编辑并保存意图的回调（透传给 IntentSummaryCard）。 */
+  onSaveIntent: (next: IntentSummary) => void;
 }
 
 function RightSidebar({
@@ -2063,6 +2264,7 @@ function RightSidebar({
   intentReady,
   timelineEntries,
   triggerToast,
+  onSaveIntent,
 }: RightSidebarProps) {
   // Step 2 侧栏内容已迁至左侧;Step 3 沿用原逻辑不展示右侧栏。
   if (currentStep !== 1) return null;
@@ -2078,7 +2280,7 @@ function RightSidebar({
         modelsLoading={modelsLoading}
       />
 
-      <IntentSummaryCard intentReady={intentReady} />
+      <IntentSummaryCard intentReady={intentReady} onSave={onSaveIntent} />
 
       {/* 澄清记录 Timeline */}
       <div className="bg-white border border-slate-200/50 rounded-2xl p-4.5 shadow-[0_2px_8px_rgba(0,0,0,0.01)] flex-1 flex flex-col min-h-[300px]">
diff --git a/frontend-web/src/strategy-components/MarkdownRenderer.tsx b/frontend-web/src/strategy-components/MarkdownRenderer.tsx
index 51821967..42e5879a 100644
--- a/frontend-web/src/strategy-components/MarkdownRenderer.tsx
+++ b/frontend-web/src/strategy-components/MarkdownRenderer.tsx
@@ -16,12 +16,33 @@ import tsx from 'react-syntax-highlighter/dist/esm/languages/prism/tsx';
 import typescript from 'react-syntax-highlighter/dist/esm/languages/prism/typescript';
 import { oneDark } from 'react-syntax-highlighter/dist/esm/styles/prism';
 
+export interface WikiLinkTarget {
+  target: string;
+  kind: 'note' | 'vault' | 'missing';
+  exists: boolean;
+  note_id?: string;
+  vault_path?: string;
+  title?: string;
+}
+
+export type WikiLinkMap = Record<string, WikiLinkTarget>;
+
 interface MarkdownRendererProps {
   content: string;
   className?: string;
   onCitationClick?: (index: number) => void;
+  /** Resolved `[[wikilink]]` targets; when provided, non-numeric `[[...]]` render as links. */
+  wikiLinks?: WikiLinkMap;
+  onWikiLinkClick?: (link: WikiLinkTarget) => void;
 }
 
+const escapeHtmlAttr = (value: string): string =>
+  value
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+
 SyntaxHighlighter.registerLanguage('bash', bash);
 SyntaxHighlighter.registerLanguage('css', css);
 SyntaxHighlighter.registerLanguage('html', markup);
@@ -126,8 +147,48 @@ const CodeBlock: React.FC<{ children: React.ReactNode; className?: string }> = (
   );
 };
 
-const MarkdownRenderer: React.FC<MarkdownRendererProps> = ({ content, className = '', onCitationClick }) => {
-  const contentWithCitationBadge = content.replace(
+const MarkdownRenderer: React.FC<MarkdownRendererProps> = ({
+  content,
+  className = '',
+  onCitationClick,
+  wikiLinks,
+  onWikiLinkClick,
+}) => {
+  // 1) Non-numeric [[wikilinks]] → clickable (or greyed-out) links, driven by the
+  //    resolver map. Numeric [[123]] are left untouched here for the citation pass.
+  let processed = content;
+  if (wikiLinks) {
+    processed = processed.replace(
+      /\[\[([^\]\n|]+)(?:\|([^\]\n]+))?\]\]/g,
+      (match, rawTarget: string, alias?: string) => {
+        const target = String(rawTarget).trim();
+        if (/^\d+$/.test(target)) return match; // citation badge, handled below
+        const resolved = wikiLinks[target];
+        const label = (alias?.trim() || resolved?.title || target);
+        const safeLabel = escapeHtmlAttr(label);
+        const safeTarget = escapeHtmlAttr(target);
+        if (resolved && resolved.exists) {
+          return `<button type="button" data-wikilink-target="${safeTarget}" class="inline items-center font-medium text-blue-600 dark:text-blue-400 hover:underline cursor-pointer align-baseline">${safeLabel}</button>`;
+        }
+        return `<span data-wikilink-missing="${safeTarget}" title="页面不存在" class="text-muted-foreground underline decoration-dashed decoration-from-font cursor-not-allowed">${safeLabel}</span>`;
+      },
+    );
+  }
+  // 2) wiki-capture provenance markers ^[inferred] / ^[ambiguous] → small badges
+  //    (otherwise they render as raw text). They mark model-inferred / uncertain
+  //    statements per the wiki-capture spec.
+  processed = processed
+    .replace(
+      /\s*\^\[inferred\]/g,
+      ' <sup title="模型推断，非原文直接得出" class="ml-0.5 rounded bg-amber-50 px-1 text-[10px] font-medium text-amber-600 align-super dark:bg-amber-500/15 dark:text-amber-300">推测</sup>',
+    )
+    .replace(
+      /\s*\^\[ambiguous\]/g,
+      ' <sup title="不确定 / 存在冲突" class="ml-0.5 rounded bg-rose-50 px-1 text-[10px] font-medium text-rose-600 align-super dark:bg-rose-500/15 dark:text-rose-300">存疑</sup>',
+    );
+
+  // 3) Numeric [[123]] citation badges.
+  const contentWithCitationBadge = processed.replace(
     /\[\[(\d+)\]\]/g,
     '<button type="button" data-citation-index="$1" class="inline-flex items-center justify-center min-w-[1.5rem] h-6 px-2 mx-0.5 rounded-md border text-xs font-semibold align-middle bg-red-50 text-red-600 border-red-200 dark:bg-slate-700 dark:text-slate-100 dark:border-slate-500 cursor-pointer transition-all hover:opacity-85">[$1]</button>',
   );
@@ -136,8 +197,17 @@ const MarkdownRenderer: React.FC<MarkdownRendererProps> = ({ content, className
     <div
       className={`markdown-content ${className}`}
       onClick={(event) => {
-        if (!onCitationClick) return;
         const target = event.target as HTMLElement;
+        const wikiButton = target.closest('[data-wikilink-target]') as HTMLElement | null;
+        if (wikiButton && onWikiLinkClick && wikiLinks) {
+          const key = wikiButton.dataset.wikilinkTarget || '';
+          const link = wikiLinks[key];
+          if (link) {
+            onWikiLinkClick(link);
+            return;
+          }
+        }
+        if (!onCitationClick) return;
         const button = target.closest('[data-citation-index]') as HTMLElement | null;
         if (!button) return;
         const index = Number(button.dataset.citationIndex || '0');
diff --git a/frontend-web/src/strategy-components/components/task-components/KanbanColumn.tsx b/frontend-web/src/strategy-components/components/task-components/KanbanColumn.tsx
index 237c30d3..d59ede02 100644
--- a/frontend-web/src/strategy-components/components/task-components/KanbanColumn.tsx
+++ b/frontend-web/src/strategy-components/components/task-components/KanbanColumn.tsx
@@ -37,10 +37,10 @@ export const KanbanColumn: React.FC<KanbanColumnProps> = ({
 
   const columnClass = isDark
     ? 'border border-[rgba(67,89,124,0.46)] bg-[linear-gradient(180deg,rgba(18,36,67,0.96),rgba(12,28,54,0.96))] shadow-[0_18px_40px_rgba(3,10,22,0.18)]'
-    : 'border border-[#E8E8E8] bg-[linear-gradient(180deg,#FFFFFF_0%,#FFF9F9_100%)] shadow-[0_14px_28px_rgba(245,34,45,0.06)]';
+    : 'border border-[#E8E8E8] bg-[linear-gradient(180deg,#FFFFFF_0%,#FFF9F9_100%)] shadow-[0_2px_8px_rgba(34,34,34,0.08)]';
 
   return (
-    <section className={`flex h-full flex-col rounded-[28px] p-4 ${columnClass}`}>
+    <section className={`flex h-full flex-col rounded p-4 ${columnClass}`}>
       <div className="flex items-center justify-between gap-4">
         <div className="flex min-w-0 items-center gap-2">
           <div className="flex min-w-0 items-center gap-2">
@@ -53,7 +53,7 @@ export const KanbanColumn: React.FC<KanbanColumnProps> = ({
               {title}
             </h2>
             <span
-              className={`inline-flex rounded-full px-2 py-0.5 text-xs ${
+              className={`inline-flex rounded-sm px-2 py-0.5 text-xs ${
                 isDark ? 'bg-[rgba(77,141,255,0.14)] text-[#9CCBFF]' : 'bg-[#FFF1F0] text-[#CF1322]'
               }`}
             >
@@ -76,14 +76,14 @@ export const KanbanColumn: React.FC<KanbanColumnProps> = ({
         />
       </div>
 
-      <p className={`mt-2 text-xs leading-6 ${isDark ? 'text-slate-400' : 'text-[#8C8C8C]'}`}>
+      <p className={`mt-1.5 text-xs leading-5 ${isDark ? 'text-slate-400' : 'text-[#A6A6A6]'}`}>
         按时间倒序展示，支持分页切换。
       </p>
 
-      <div className="mt-4 flex-1 space-y-4">
+      <div className="mt-3 flex-1 space-y-3">
         {tasks.length === 0 ? (
           <div
-            className={`flex h-full min-h-[220px] flex-col items-center justify-center rounded-[22px] border border-dashed ${
+            className={`flex h-full min-h-[220px] flex-col items-center justify-center rounded border border-dashed ${
               isDark
                 ? 'border-[rgba(87,111,149,0.42)] bg-[rgba(12,24,44,0.46)] text-slate-400'
                 : 'border-[#F3C4C8] bg-[#FFF7F7] text-[#A6A6A6]'
diff --git a/frontend-web/src/strategy-components/components/task-components/SentimentAnalyzes.tsx b/frontend-web/src/strategy-components/components/task-components/SentimentAnalyzes.tsx
index d7aa1d58..2d9156e5 100644
--- a/frontend-web/src/strategy-components/components/task-components/SentimentAnalyzes.tsx
+++ b/frontend-web/src/strategy-components/components/task-components/SentimentAnalyzes.tsx
@@ -1,5 +1,5 @@
 import React, { useEffect, useMemo, useRef, useState } from 'react';
-import { ArrowRight, Bot, Layers, Plus, Search, Users, X } from 'lucide-react';
+import { ArrowRight, Bot, CircleCheck, Inbox, Layers, Loader, Plus, Search, Users, X } from 'lucide-react';
 import dayjs from 'dayjs';
 import { DateRangePicker, DateRangePickerProps, DateRangeValue, Loading } from 'tdesign-react';
 import { useNavigate } from 'react-router-dom';
@@ -170,7 +170,7 @@ const SentimentAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCa
     setShowAnalysisModal(false);
   };
 
-  // 单智能体分析：用「业务链条管理」里为本业务配置的智能体，跳转到其问答页（新会话），
+  // 单智能体分析：用「配置管理」里为本业务配置的智能体，跳转到其问答页（新会话），
   // 把任务名称/简介作为开场消息暂存，由 AgentChatPage 读取 sessionStorage.pendingAgentMessage
   // 自动发出并开始问答。未配置智能体则提示去配置。
   const handleSingleAgentAnalysis = async () => {
@@ -184,7 +184,7 @@ const SentimentAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCa
       /* ignore → 下面按未配置处理 */
     }
     if (!agentId) {
-      toast.error('该业务尚未在「业务链条管理」中配置单智能体');
+      toast.error('该业务尚未在「配置管理」中配置单智能体');
       return;
     }
     const text = [
@@ -226,7 +226,7 @@ const SentimentAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCa
 
   const toolbarClass = isDark
     ? 'border border-[rgba(67,89,124,0.46)] bg-[rgba(10,23,42,0.94)] text-white shadow-[0_16px_36px_rgba(3,10,22,0.2)]'
-    : 'border border-[#E8E8E8] bg-white text-[#222222] shadow-[0_14px_30px_rgba(245,34,45,0.06)]';
+    : 'border border-[#E8E8E8] bg-white text-[#222222] shadow-[0_2px_8px_rgba(34,34,34,0.08)]';
 
   const metricClass = isDark
     ? 'border border-[rgba(67,89,124,0.46)] bg-[rgba(12,29,54,0.94)]'
@@ -237,31 +237,31 @@ const SentimentAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCa
     : 'border-[#E8E8E8] bg-white text-[#222222] placeholder:text-[#A6A6A6]';
 
   const metrics = [
-    { label: '全部任务', value: unanalyzedTotal + runningTotal + completedTotal },
-    { label: '未分析', value: unanalyzedTotal },
-    { label: '分析中', value: runningTotal },
-    { label: '已完成', value: completedTotal },
+    { label: '全部任务', value: unanalyzedTotal + runningTotal + completedTotal, icon: Layers, fg: '#222222', chipBg: '#F5F5F5', chipFg: '#7F7F7F' },
+    { label: '未分析', value: unanalyzedTotal, icon: Inbox, fg: '#F5222D', chipBg: '#FEEDED', chipFg: '#F5222D' },
+    { label: '分析中', value: runningTotal, icon: Loader, fg: '#1677FF', chipBg: '#EAF4FF', chipFg: '#1677FF' },
+    { label: '已完成', value: completedTotal, icon: CircleCheck, fg: '#52C41A', chipBg: '#EEFCF7', chipFg: '#189D72' },
   ];
 
   return (
     <div className={shellClass}>
       <div className="mx-auto flex min-h-full max-w-[1680px] flex-col gap-4 px-6 py-6 lg:px-8">
-        <section className={`rounded-[28px] p-5 ${toolbarClass}`}>
+        <section className={`rounded px-6 py-5 ${toolbarClass}`}>
           <div className="flex flex-col gap-4 xl:flex-row xl:items-start xl:justify-between">
-            <div className="space-y-3">
-              <div className="flex items-center gap-2 text-xs">
-                <span className={`rounded-full px-3 py-1 ${isDark ? 'bg-[rgba(77,141,255,0.16)] text-[#9CCBFF]' : 'bg-[#FFF1F0] text-[#CF1322]'}`}>
+            <div className="space-y-2.5">
+              <div className="flex items-center gap-1.5 text-xs">
+                <span className={`rounded-sm border px-2 py-0.5 font-medium ${isDark ? 'border-[rgba(108,161,255,0.24)] bg-[rgba(77,141,255,0.16)] text-[#9CCBFF]' : 'border-[#FFD6D6] bg-[#FFF1F0] text-[#CF1322]'}`}>
                   {category}
                 </span>
-                <ArrowRight className={`h-3.5 w-3.5 ${isDark ? 'text-slate-500' : 'text-[#A6A6A6]'}`} />
-                <span className={`rounded-full px-3 py-1 ${isDark ? 'bg-[rgba(34,197,94,0.14)] text-[#89E8B8]' : 'bg-[#FFF6E8] text-[#D46B08]'}`}>
+                <ArrowRight className={`h-3 w-3 ${isDark ? 'text-slate-500' : 'text-[#A6A6A6]'}`} />
+                <span className={`rounded-sm border px-2 py-0.5 font-medium ${isDark ? 'border-[rgba(103,232,165,0.2)] bg-[rgba(34,197,94,0.14)] text-[#89E8B8]' : 'border-[#FFE2B8] bg-[#FFF6E8] text-[#D46B08]'}`}>
                   {subCategory}
                 </span>
               </div>
 
               <div>
-                <h1 className={`text-[28px] font-semibold ${isDark ? 'text-white' : 'text-[#222222]'}`}>{title}</h1>
-                <p className={`mt-2 text-sm ${isDark ? 'text-slate-300' : 'text-[#575757]'}`}>
+                <h1 className={`text-[24px] font-semibold leading-8 ${isDark ? 'text-white' : 'text-[#222222]'}`}>{title}</h1>
+                <p className={`mt-1.5 text-sm ${isDark ? 'text-slate-300' : 'text-[#575757]'}`}>
                   面向规划任务的情绪与倾向分析看板，支持快速检索、会商启动与结果回看。
                 </p>
               </div>
@@ -269,7 +269,7 @@ const SentimentAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCa
 
             <div className="flex flex-col gap-3 xl:items-end">
               <div className="flex flex-wrap items-center gap-3">
-                <label className={`flex h-11 min-w-[320px] items-center gap-3 rounded-xl border px-4 ${inputClass}`}>
+                <label className={`flex h-10 min-w-[300px] items-center gap-2 rounded-sm border px-3 ${inputClass}`}>
                   <Search className={`h-4 w-4 ${isDark ? 'text-slate-400' : 'text-[#A6A6A6]'}`} />
                   <input
                     value={searchQuery}
@@ -281,6 +281,7 @@ const SentimentAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCa
                 </label>
                 <DateRangePicker
                   className="sentiment-date-range"
+                  size="large"
                   value={range}
                   presets={presets}
                   onChange={setRangeChange}
@@ -292,7 +293,7 @@ const SentimentAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCa
 
               <button
                 type="button"
-                className={`inline-flex items-center gap-2 rounded-xl px-4 py-2 text-sm ${isDark ? 'bg-[rgba(77,141,255,0.16)] text-[#9CCBFF]' : 'bg-[#FFF1F0] text-[#CF1322]'}`}
+                className={`inline-flex items-center gap-2 rounded-sm px-4 py-2 text-sm ${isDark ? 'bg-[rgba(77,141,255,0.16)] text-[#9CCBFF]' : 'bg-[#F5222D] text-white hover:bg-[#CF1322]'}`}
               >
                 <Plus className="h-4 w-4" />
                 新建任务
@@ -302,21 +303,30 @@ const SentimentAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCa
         </section>
 
         <section className="grid grid-cols-1 gap-4 md:grid-cols-2 xl:grid-cols-4">
-          {metrics.map((item, index) => (
-            <div key={item.label} className={`rounded-[24px] p-5 ${metricClass}`}>
-              <div className="flex items-center justify-between">
-                <div>
-                  <p className={`text-sm ${isDark ? 'text-slate-400' : 'text-[#8C8C8C]'}`}>{item.label}</p>
-                  <p className={`mt-3 text-[36px] font-semibold ${isDark ? 'text-white' : index === 0 ? 'text-[#222222]' : 'text-[#F5222D]'}`}>
-                    {item.value}
-                  </p>
-                </div>
-                <div className={`flex h-12 w-12 items-center justify-center rounded-2xl ${isDark ? 'bg-[rgba(77,141,255,0.18)] text-[#9CCBFF]' : 'bg-[#FFF1F0] text-[#CF1322]'}`}>
-                  <Layers className="h-5 w-5" />
+          {metrics.map((item) => {
+            const Icon = item.icon;
+            return (
+              <div key={item.label} className={`rounded p-4 ${metricClass}`}>
+                <div className="flex items-center justify-between">
+                  <div>
+                    <p className={`text-sm ${isDark ? 'text-slate-400' : 'text-[#7F7F7F]'}`}>{item.label}</p>
+                    <p
+                      className={`mt-2 text-[30px] font-semibold leading-none ${isDark ? 'text-white' : ''}`}
+                      style={isDark ? undefined : { color: item.fg }}
+                    >
+                      {item.value}
+                    </p>
+                  </div>
+                  <div
+                    className={`flex h-11 w-11 items-center justify-center rounded ${isDark ? 'bg-[rgba(77,141,255,0.18)] text-[#9CCBFF]' : ''}`}
+                    style={isDark ? undefined : { backgroundColor: item.chipBg, color: item.chipFg }}
+                  >
+                    <Icon className="h-5 w-5" />
+                  </div>
                 </div>
               </div>
-            </div>
-          ))}
+            );
+          })}
         </section>
 
         <section className="grid grid-cols-1 items-stretch gap-4 xl:grid-cols-3">
@@ -375,7 +385,7 @@ const SentimentAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCa
 
       {showAnalysisModal && selectedTask ? (
         <div className="fixed inset-0 z-[2000] flex items-center justify-center bg-black/45 px-4">
-          <div className={`w-full max-w-[560px] rounded-[28px] border p-6 ${isDark ? 'border-[rgba(67,89,124,0.46)] bg-[rgba(10,23,42,0.98)] text-white' : 'border-[#E8E8E8] bg-white text-[#222222] shadow-[0_18px_36px_rgba(0,0,0,0.12)]'}`}>
+          <div className={`w-full max-w-[560px] rounded border p-6 ${isDark ? 'border-[rgba(67,89,124,0.46)] bg-[rgba(10,23,42,0.98)] text-white' : 'border-[#E8E8E8] bg-white text-[#222222] shadow-[0_8px_32px_rgba(34,34,34,0.16)]'}`}>
             <div className="flex items-start justify-between gap-4">
               <div>
                 <h3 className="text-xl font-semibold">选择分析模式</h3>
@@ -386,7 +396,7 @@ const SentimentAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCa
               <button
                 type="button"
                 onClick={() => setShowAnalysisModal(false)}
-                className={`rounded-xl p-2 ${isDark ? 'hover:bg-[rgba(21,42,72,0.9)]' : 'hover:bg-[#FFF1F0]'}`}
+                className={`rounded-sm p-2 ${isDark ? 'hover:bg-[rgba(21,42,72,0.9)]' : 'hover:bg-[#FFF1F0]'}`}
               >
                 <X className="h-4 w-4" />
               </button>
@@ -396,7 +406,7 @@ const SentimentAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCa
               <button
                 type="button"
                 onClick={handleOpenTaskDetail}
-                className={`flex w-full items-center justify-between rounded-[22px] border px-5 py-4 text-left transition ${isDark ? 'border-[rgba(67,89,124,0.46)] bg-[rgba(15,33,60,0.92)] hover:border-[rgba(110,168,255,0.46)]' : 'border-[#E8E8E8] bg-[#FFF9F9] hover:border-[#F6B0B4]'}`}
+                className={`flex w-full items-center justify-between rounded border px-5 py-4 text-left transition ${isDark ? 'border-[rgba(67,89,124,0.46)] bg-[rgba(15,33,60,0.92)] hover:border-[rgba(110,168,255,0.46)]' : 'border-[#E8E8E8] bg-[#FFF9F9] hover:border-[#F6B0B4]'}`}
               >
                 <div>
                   <div className="font-medium">查看任务详情</div>
@@ -410,7 +420,7 @@ const SentimentAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCa
               <button
                 type="button"
                 onClick={handleOpenConsultation}
-                className={`flex w-full items-center justify-between rounded-[22px] border px-5 py-4 text-left transition ${isDark ? 'border-[rgba(67,89,124,0.46)] bg-[rgba(15,33,60,0.92)] hover:border-[rgba(103,232,165,0.42)]' : 'border-[#E8E8E8] bg-[#FFF9F9] hover:border-[#F6B0B4]'}`}
+                className={`flex w-full items-center justify-between rounded border px-5 py-4 text-left transition ${isDark ? 'border-[rgba(67,89,124,0.46)] bg-[rgba(15,33,60,0.92)] hover:border-[rgba(103,232,165,0.42)]' : 'border-[#E8E8E8] bg-[#FFF9F9] hover:border-[#F6B0B4]'}`}
               >
                 <div className="flex items-start gap-3">
                   <Users className={`mt-0.5 h-5 w-5 ${isDark ? 'text-[#89E8B8]' : 'text-[#CF1322]'}`} />
@@ -427,7 +437,7 @@ const SentimentAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCa
               <button
                 type="button"
                 onClick={handleSingleAgentAnalysis}
-                className={`flex w-full items-center justify-between rounded-[22px] border px-5 py-4 text-left transition ${isDark ? 'border-[rgba(67,89,124,0.46)] bg-[rgba(15,33,60,0.92)] hover:border-[rgba(167,139,250,0.46)]' : 'border-[#E8E8E8] bg-[#FFF9F9] hover:border-[#F6B0B4]'}`}
+                className={`flex w-full items-center justify-between rounded border px-5 py-4 text-left transition ${isDark ? 'border-[rgba(67,89,124,0.46)] bg-[rgba(15,33,60,0.92)] hover:border-[rgba(167,139,250,0.46)]' : 'border-[#E8E8E8] bg-[#FFF9F9] hover:border-[#F6B0B4]'}`}
               >
                 <div className="flex items-start gap-3">
                   <Bot className={`mt-0.5 h-5 w-5 ${isDark ? 'text-[#C4B5FD]' : 'text-[#7C3AED]'}`} />
diff --git a/frontend-web/src/strategy-components/components/task-components/TaskAnalyzes.tsx b/frontend-web/src/strategy-components/components/task-components/TaskAnalyzes.tsx
index 5b689846..5ceb856a 100644
--- a/frontend-web/src/strategy-components/components/task-components/TaskAnalyzes.tsx
+++ b/frontend-web/src/strategy-components/components/task-components/TaskAnalyzes.tsx
@@ -1,5 +1,5 @@
 import React, { useEffect, useMemo, useRef, useState } from 'react';
-import { ArrowRight, Bot, Layers, Plus, Search, Users, X } from 'lucide-react';
+import { ArrowRight, Bot, CircleCheck, Inbox, Layers, Loader, Plus, Search, Users, X } from 'lucide-react';
 import { DateRangePicker, DateRangePickerProps, DateRangeValue, Loading } from 'tdesign-react';
 import dayjs from 'dayjs';
 import { useNavigate } from 'react-router-dom';
@@ -170,7 +170,7 @@ const TaskAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCategor
     setShowAnalysisModal(false);
   };
 
-  // 单智能体分析：用「业务链条管理」里为本业务配置的智能体，跳转到其问答页（新会话），
+  // 单智能体分析：用「配置管理」里为本业务配置的智能体，跳转到其问答页（新会话），
   // 把任务名称/简介作为开场消息暂存，由 AgentChatPage 读取 sessionStorage.pendingAgentMessage
   // 自动发出并开始问答。未配置智能体则提示去配置。
   const handleSingleAgentAnalysis = async () => {
@@ -184,7 +184,7 @@ const TaskAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCategor
       /* ignore → 下面按未配置处理 */
     }
     if (!agentId) {
-      toast.error('该业务尚未在「业务链条管理」中配置单智能体');
+      toast.error('该业务尚未在「配置管理」中配置单智能体');
       return;
     }
     const text = [
@@ -224,115 +224,105 @@ const TaskAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCategor
     ? 'strategy-data h-full overflow-y-auto bg-[radial-gradient(circle_at_top_left,rgba(27,94,168,0.28),transparent_32%),linear-gradient(180deg,#081322_0%,#0d1d33_42%,#0a1628_100%)] text-slate-100'
     : 'strategy-data h-full overflow-y-auto bg-[radial-gradient(circle_at_top_left,rgba(245,34,45,0.08),transparent_26%),linear-gradient(180deg,#fffdfd_0%,#fff7f7_42%,#fafafa_100%)] text-[#222222]';
 
+  const toolbarClass = isDark
+    ? 'border border-[rgba(110,136,176,0.24)] bg-[rgba(10,23,42,0.94)] text-slate-100 shadow-[0_16px_36px_rgba(3,10,22,0.2)]'
+    : 'border border-[#E8E8E8] bg-white text-[#222222] shadow-[0_2px_8px_rgba(34,34,34,0.08)]';
+
   const metricCardClass = isDark
     ? 'border border-[rgba(110,136,176,0.24)] bg-[linear-gradient(180deg,rgba(13,31,55,0.98),rgba(8,19,34,0.98))] shadow-[0_14px_42px_rgba(2,8,20,0.30)]'
-    : 'border border-[#E8E8E8] bg-white shadow-[0_12px_30px_rgba(245,34,45,0.06)]';
+    : 'border border-[#E8E8E8] bg-white';
 
   const inputClass = isDark
     ? 'border-[rgba(110,136,176,0.3)] bg-[rgba(8,23,42,0.92)] text-slate-100 placeholder:text-slate-500'
-    : 'border-[#E8E8E8] bg-white text-[#222222] placeholder:text-[#A6A6A6] shadow-[0_4px_14px_rgba(245,34,45,0.04)]';
+    : 'border-[#E8E8E8] bg-white text-[#222222] placeholder:text-[#A6A6A6]';
 
   const panelGlowClass = isDark
     ? 'before:pointer-events-none before:absolute before:inset-x-8 before:top-0 before:h-px before:bg-[linear-gradient(90deg,transparent,rgba(96,165,250,0.45),transparent)]'
     : '';
 
   const metrics = [
-    {
-      label: '全部任务',
-      value: unanalyzedTotal + runningTotal + completedTotal,
-      icon: Layers,
-      accent: 'from-[#4D8DFF] to-[#7CC9FF]',
-    },
-    {
-      label: '未分析',
-      value: unanalyzedTotal,
-      icon: Bot,
-      accent: 'from-[#7C9BFF] to-[#5EEAD4]',
-    },
-    {
-      label: '分析中',
-      value: runningTotal,
-      icon: Layers,
-      accent: 'from-[#22C55E] to-[#67E8F9]',
-    },
-    {
-      label: '已完成',
-      value: completedTotal,
-      icon: Bot,
-      accent: 'from-[#38BDF8] to-[#A78BFA]',
-    },
+    { label: '全部任务', value: unanalyzedTotal + runningTotal + completedTotal, icon: Layers, fg: '#222222', chipBg: '#F5F5F5', chipFg: '#7F7F7F' },
+    { label: '未分析', value: unanalyzedTotal, icon: Inbox, fg: '#F5222D', chipBg: '#FEEDED', chipFg: '#F5222D' },
+    { label: '分析中', value: runningTotal, icon: Loader, fg: '#1677FF', chipBg: '#EAF4FF', chipFg: '#1677FF' },
+    { label: '已完成', value: completedTotal, icon: CircleCheck, fg: '#52C41A', chipBg: '#EEFCF7', chipFg: '#189D72' },
   ];
 
   return (
     <div className={shellClass}>
-      <div className={`relative mx-auto flex min-h-full max-w-[1680px] flex-col gap-5 px-6 py-6 lg:px-8 ${panelGlowClass}`}>
-        <div className="flex flex-col gap-4 xl:flex-row xl:items-end xl:justify-between">
-          <div className="space-y-3">
-            <div className="flex items-center gap-3">
-              <div>
-                <h1 className={`text-[26px] font-semibold tracking-[0.02em] ${isDark ? 'text-slate-50' : 'text-[#222222]'}`}>
-                  {title}
-                </h1>
-                <p className={`mt-1 text-sm ${isDark ? 'text-slate-300/80' : 'text-slate-500'}`}>
-                  面向规划任务的任务分析看板，聚焦目标拆解、受众判断和策略阻力识别，支持快速检索、启动分析和查看会商结果。
-                </p>
-              </div>
-            </div>
-            <div className={`inline-flex items-center gap-2 rounded-full border px-3 py-1 text-xs ${isDark ? 'border-[rgba(110,136,176,0.28)] bg-[rgba(9,25,46,0.72)] text-slate-300' : 'border-slate-200 bg-white text-slate-600'}`}>
-              <span>{category}</span>
-              <ArrowRight className="h-3.5 w-3.5 opacity-70" />
-              <span>{subCategory}</span>
+      <div className={`relative mx-auto flex min-h-full max-w-[1680px] flex-col gap-4 px-6 py-6 lg:px-8 ${panelGlowClass}`}>
+        <section className={`rounded px-6 py-5 ${toolbarClass}`}>
+          <div className="flex flex-wrap items-center gap-x-3 gap-y-2">
+            <h1 className={`text-[24px] font-semibold leading-8 ${isDark ? 'text-slate-50' : 'text-[#222222]'}`}>{title}</h1>
+            <div className="flex items-center gap-1.5 text-xs">
+              <span className={`rounded-sm border px-2 py-0.5 font-medium ${isDark ? 'border-[rgba(108,161,255,0.24)] bg-[rgba(77,141,255,0.16)] text-[#9CCBFF]' : 'border-[#FFD6D6] bg-[#FFF1F0] text-[#CF1322]'}`}>
+                {category}
+              </span>
+              <ArrowRight className={`h-3 w-3 ${isDark ? 'text-slate-500' : 'text-[#A6A6A6]'}`} />
+              <span className={`rounded-sm border px-2 py-0.5 font-medium ${isDark ? 'border-[rgba(103,232,165,0.2)] bg-[rgba(34,197,94,0.14)] text-[#89E8B8]' : 'border-[#FFE2B8] bg-[#FFF6E8] text-[#D46B08]'}`}>
+                {subCategory}
+              </span>
             </div>
           </div>
+          <p className={`mt-1.5 text-sm ${isDark ? 'text-slate-300' : 'text-[#575757]'}`}>
+            面向规划任务的任务分析看板，聚焦目标拆解、受众判断和策略阻力识别，支持快速检索、启动分析和查看会商结果。
+          </p>
 
-          <div className="flex flex-col gap-3 xl:items-end">
-            <div className="flex flex-wrap items-center gap-3">
-              <label className={`flex h-11 min-w-[320px] items-center gap-3 rounded-2xl border px-4 ${inputClass}`}>
-                <Search className="h-4 w-4 text-[#7CC9FF]" />
-                <input
-                  value={searchQuery}
-                  onChange={(event) => setSearchQuery(event.target.value)}
-                  onKeyDown={handleKeyDown}
-                  className="w-full bg-transparent text-sm outline-none"
-                  placeholder="搜索任务名称、摘要或负责人"
-                />
-              </label>
-              <DateRangePicker
-                className="sentiment-date-range"
-                value={dateRange}
-                presets={presets}
-                enableTimePicker
-                clearable
-                popupProps={{ overlayClassName: 'sentiment-date-range-popup' }}
-                onChange={setRangeChange}
+          <div className="mt-4 flex flex-wrap items-center gap-3">
+            <label className={`flex h-10 min-w-[240px] flex-1 items-center gap-2 rounded-sm border px-3 ${inputClass}`}>
+              <Search className={`h-4 w-4 ${isDark ? 'text-slate-400' : 'text-[#A6A6A6]'}`} />
+              <input
+                value={searchQuery}
+                onChange={(event) => setSearchQuery(event.target.value)}
+                onKeyDown={handleKeyDown}
+                className="w-full bg-transparent text-sm outline-none"
+                placeholder="搜索任务名称、摘要或负责人"
               />
-            </div>
+            </label>
+            <DateRangePicker
+              className="sentiment-date-range"
+              size="large"
+              value={dateRange}
+              presets={presets}
+              enableTimePicker
+              clearable
+              popupProps={{ overlayClassName: 'sentiment-date-range-popup' }}
+              onChange={setRangeChange}
+            />
             <button
               type="button"
-              className={`inline-flex items-center gap-2 rounded-xl px-4 py-2 text-sm ${isDark ? 'bg-[rgba(77,141,255,0.16)] text-[#9CCBFF]' : 'bg-[#FFF1F0] text-[#CF1322]'}`}
+              className={`inline-flex shrink-0 items-center gap-2 whitespace-nowrap rounded-sm px-4 py-2 text-sm ${isDark ? 'bg-[rgba(77,141,255,0.16)] text-[#9CCBFF]' : 'bg-[#F5222D] text-white hover:bg-[#CF1322]'}`}
             >
               <Plus className="h-4 w-4" />
               新建任务
             </button>
           </div>
-        </div>
+        </section>
 
         <div className="grid grid-cols-1 gap-4 md:grid-cols-2 xl:grid-cols-4">
-          {metrics.map(({ label, value, icon: Icon, accent }) => (
-            <div key={label} className={`rounded-3xl p-5 ${metricCardClass}`}>
-              <div className="flex items-center justify-between">
-                <div>
-                  <p className={`text-sm ${isDark ? 'text-slate-300/78' : 'text-slate-500'}`}>{label}</p>
-                  <p className={`mt-3 text-3xl font-semibold tracking-[0.03em] ${isDark ? 'text-white' : 'text-[#222222]'}`}>
-                    {value}
-                  </p>
-                </div>
-                <div className={`flex h-12 w-12 items-center justify-center rounded-2xl bg-gradient-to-br ${accent} shadow-[inset_0_1px_0_rgba(255,255,255,0.18)]`}>
-                  <Icon className="h-5 w-5 text-white" />
+          {metrics.map((item) => {
+            const Icon = item.icon;
+            return (
+              <div key={item.label} className={`rounded p-4 ${metricCardClass}`}>
+                <div className="flex items-center justify-between">
+                  <div>
+                    <p className={`text-sm ${isDark ? 'text-slate-400' : 'text-[#7F7F7F]'}`}>{item.label}</p>
+                    <p
+                      className={`mt-2 text-[30px] font-semibold leading-none ${isDark ? 'text-white' : ''}`}
+                      style={isDark ? undefined : { color: item.fg }}
+                    >
+                      {item.value}
+                    </p>
+                  </div>
+                  <div
+                    className={`flex h-11 w-11 items-center justify-center rounded ${isDark ? 'bg-[rgba(77,141,255,0.18)] text-[#9CCBFF]' : ''}`}
+                    style={isDark ? undefined : { backgroundColor: item.chipBg, color: item.chipFg }}
+                  >
+                    <Icon className="h-5 w-5" />
+                  </div>
                 </div>
               </div>
-            </div>
-          ))}
+            );
+          })}
         </div>
 
         <div className="grid auto-rows-auto grid-cols-1 items-stretch gap-4 xl:grid-cols-3">
@@ -342,7 +332,7 @@ const TaskAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCategor
                 <KanbanColumn
                   title="未分析"
                   count={unanalyzedTotal}
-                  color="bg-[#7C9BFF]"
+                  color={isDark ? 'bg-[#7CC9FF]' : 'bg-[#F5222D]'}
                   tasks={unanalyzedList}
                   taskType="unanalyzed"
                   pageIndexSearch={pageIndexChange}
@@ -358,7 +348,7 @@ const TaskAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCategor
                 <KanbanColumn
                   title="分析中"
                   count={runningTotal}
-                  color="bg-[#22C55E]"
+                  color={isDark ? 'bg-[#5EEAD4]' : 'bg-[#1677FF]'}
                   tasks={runningList}
                   taskType="running"
                   pageIndexSearch={pageIndexChange}
@@ -374,7 +364,7 @@ const TaskAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCategor
                 <KanbanColumn
                   title="已完成"
                   count={completedTotal}
-                  color="bg-[#38BDF8]"
+                  color={isDark ? 'bg-[#67E8A5]' : 'bg-[#52C41A]'}
                   tasks={completedList}
                   taskType="completed"
                   pageIndexSearch={pageIndexChange}
@@ -387,19 +377,19 @@ const TaskAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCategor
       </div>
 
       {showAnalysisModal && selectedTask ? (
-        <div className="fixed inset-0 z-[2000] flex items-center justify-center bg-[rgba(3,10,22,0.62)] px-4 backdrop-blur-sm">
-          <div className={`w-full max-w-[560px] rounded-[28px] border p-6 ${isDark ? 'border-[rgba(110,136,176,0.26)] bg-[linear-gradient(180deg,rgba(10,29,54,0.98),rgba(8,20,37,0.98))] text-slate-100 shadow-[0_28px_80px_rgba(2,8,20,0.42)]' : 'border-slate-200 bg-white text-slate-900 shadow-xl'}`}>
+        <div className="fixed inset-0 z-[2000] flex items-center justify-center bg-black/45 px-4">
+          <div className={`w-full max-w-[560px] rounded border p-6 ${isDark ? 'border-[rgba(110,136,176,0.26)] bg-[linear-gradient(180deg,rgba(10,29,54,0.98),rgba(8,20,37,0.98))] text-slate-100 shadow-[0_28px_80px_rgba(2,8,20,0.42)]' : 'border-[#E8E8E8] bg-white text-[#222222] shadow-[0_8px_32px_rgba(34,34,34,0.16)]'}`}>
             <div className="flex items-start justify-between gap-4">
               <div>
                 <h3 className="text-xl font-semibold">选择分析模式</h3>
-                <p className={`mt-2 text-sm ${isDark ? 'text-slate-300/78' : 'text-slate-500'}`}>
+                <p className={`mt-2 text-sm ${isDark ? 'text-slate-300' : 'text-[#575757]'}`}>
                   当前任务：{selectedTask.taskName}
                 </p>
               </div>
               <button
                 type="button"
                 onClick={() => setShowAnalysisModal(false)}
-                className={`rounded-xl p-2 transition ${isDark ? 'hover:bg-[rgba(15,41,74,0.88)]' : 'hover:bg-slate-100'}`}
+                className={`rounded-sm p-2 transition ${isDark ? 'hover:bg-[rgba(15,41,74,0.88)]' : 'hover:bg-[#FFF1F0]'}`}
               >
                 <X className="h-4 w-4" />
               </button>
@@ -409,15 +399,18 @@ const TaskAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCategor
               <button
                 type="button"
                 onClick={handleOpenTaskDetail}
-                className={`group flex items-center justify-between rounded-2xl border px-5 py-4 text-left transition ${isDark ? 'border-[rgba(110,136,176,0.24)] bg-[rgba(10,30,54,0.9)] hover:border-[rgba(96,165,250,0.48)] hover:bg-[rgba(12,38,69,0.96)]' : 'border-slate-200 bg-slate-50 hover:border-sky-200 hover:bg-sky-50'}`}
+                className={`group flex items-center justify-between rounded border px-5 py-4 text-left transition ${isDark ? 'border-[rgba(110,136,176,0.24)] bg-[rgba(10,30,54,0.9)] hover:border-[rgba(96,165,250,0.48)] hover:bg-[rgba(12,38,69,0.96)]' : 'border-[#E8E8E8] bg-[#FFF9F9] hover:border-[#F6B0B4]'}`}
               >
                 <div className="flex items-center gap-4">
-                  <div className="flex h-11 w-11 items-center justify-center rounded-2xl bg-[linear-gradient(180deg,#1677FF,#0EA5E9)]">
-                    <Layers className="h-5 w-5 text-white" />
+                  <div
+                    className={`flex h-10 w-10 items-center justify-center rounded-sm ${isDark ? 'bg-[linear-gradient(180deg,#1677FF,#0EA5E9)] text-white' : ''}`}
+                    style={isDark ? undefined : { backgroundColor: '#EAF4FF', color: '#0079FE' }}
+                  >
+                    <Layers className="h-5 w-5" />
                   </div>
                   <div>
                     <div className="font-medium">查看任务详情</div>
-                    <div className={`mt-1 text-sm ${isDark ? 'text-slate-300/72' : 'text-slate-500'}`}>
+                    <div className={`mt-1 text-sm ${isDark ? 'text-slate-300/72' : 'text-[#575757]'}`}>
                       进入 B1 系统查看任务详情。
                     </div>
                   </div>
@@ -428,15 +421,18 @@ const TaskAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCategor
               <button
                 type="button"
                 onClick={handleOpenConsultation}
-                className={`group flex items-center justify-between rounded-2xl border px-5 py-4 text-left transition ${isDark ? 'border-[rgba(110,136,176,0.24)] bg-[rgba(10,30,54,0.9)] hover:border-[rgba(45,212,191,0.48)] hover:bg-[rgba(10,42,58,0.96)]' : 'border-slate-200 bg-slate-50 hover:border-emerald-200 hover:bg-emerald-50'}`}
+                className={`group flex items-center justify-between rounded border px-5 py-4 text-left transition ${isDark ? 'border-[rgba(110,136,176,0.24)] bg-[rgba(10,30,54,0.9)] hover:border-[rgba(45,212,191,0.48)] hover:bg-[rgba(10,42,58,0.96)]' : 'border-[#E8E8E8] bg-[#FFF9F9] hover:border-[#F6B0B4]'}`}
               >
                 <div className="flex items-center gap-4">
-                  <div className="flex h-11 w-11 items-center justify-center rounded-2xl bg-[linear-gradient(180deg,#14B8A6,#22C55E)]">
-                    <Users className="h-5 w-5 text-white" />
+                  <div
+                    className={`flex h-10 w-10 items-center justify-center rounded-sm ${isDark ? 'bg-[linear-gradient(180deg,#14B8A6,#22C55E)] text-white' : ''}`}
+                    style={isDark ? undefined : { backgroundColor: '#FEEDED', color: '#CF1322' }}
+                  >
+                    <Users className="h-5 w-5" />
                   </div>
                   <div>
                     <div className="font-medium">多智能体会商</div>
-                    <div className={`mt-1 text-sm ${isDark ? 'text-slate-300/72' : 'text-slate-500'}`}>
+                    <div className={`mt-1 text-sm ${isDark ? 'text-slate-300/72' : 'text-[#575757]'}`}>
                       多个 AI 智能体从不同视角开展讨论并形成共识。
                     </div>
                   </div>
@@ -447,15 +443,18 @@ const TaskAnalyzes: React.FC<TaskListPageProps> = ({ title, category, subCategor
               <button
                 type="button"
                 onClick={handleSingleAgentAnalysis}
-                className={`group flex items-center justify-between rounded-2xl border px-5 py-4 text-left transition ${isDark ? 'border-[rgba(110,136,176,0.24)] bg-[rgba(10,30,54,0.9)] hover:border-[rgba(167,139,250,0.48)] hover:bg-[rgba(28,24,58,0.96)]' : 'border-slate-200 bg-slate-50 hover:border-violet-200 hover:bg-violet-50'}`}
+                className={`group flex items-center justify-between rounded border px-5 py-4 text-left transition ${isDark ? 'border-[rgba(110,136,176,0.24)] bg-[rgba(10,30,54,0.9)] hover:border-[rgba(167,139,250,0.48)] hover:bg-[rgba(28,24,58,0.96)]' : 'border-[#E8E8E8] bg-[#FFF9F9] hover:border-[#F6B0B4]'}`}
               >
                 <div className="flex items-center gap-4">
-                  <div className="flex h-11 w-11 items-center justify-center rounded-2xl bg-[linear-gradient(180deg,#7C3AED,#A78BFA)]">
-                    <Bot className="h-5 w-5 text-white" />
+                  <div
+                    className={`flex h-10 w-10 items-center justify-center rounded-sm ${isDark ? 'bg-[linear-gradient(180deg,#7C3AED,#A78BFA)] text-white' : ''}`}
+                    style={isDark ? undefined : { backgroundColor: '#F3EDFF', color: '#7C3AED' }}
+                  >
+                    <Bot className="h-5 w-5" />
                   </div>
                   <div>
                     <div className="font-medium">单智能体分析</div>
-                    <div className={`mt-1 text-sm ${isDark ? 'text-slate-300/72' : 'text-slate-500'}`}>
+                    <div className={`mt-1 text-sm ${isDark ? 'text-slate-300/72' : 'text-[#575757]'}`}>
                       由单个 AI 智能体直接对该任务进行分析问答。
                     </div>
                   </div>
diff --git a/frontend-web/src/strategy-components/components/task-components/TaskCard.tsx b/frontend-web/src/strategy-components/components/task-components/TaskCard.tsx
index 2eabb746..c885558f 100644
--- a/frontend-web/src/strategy-components/components/task-components/TaskCard.tsx
+++ b/frontend-web/src/strategy-components/components/task-components/TaskCard.tsx
@@ -118,7 +118,7 @@ export const TaskCard: React.FC<TaskCardProps> = ({
 
   const panelClass = isDark
     ? 'border border-[rgba(67,89,124,0.46)] bg-[rgba(19,39,72,0.9)] shadow-[0_14px_34px_rgba(3,10,22,0.2)] hover:border-[rgba(110,168,255,0.52)]'
-    : 'border border-[#E8E8E8] bg-white shadow-[0_10px_24px_rgba(245,34,45,0.06)] hover:border-[#F6B0B4] hover:shadow-[0_16px_32px_rgba(245,34,45,0.12)]';
+    : 'border border-[#E8E8E8] bg-white shadow-[0_2px_8px_rgba(34,34,34,0.08)] hover:border-[#F6B0B4] hover:shadow-[0_4px_16px_rgba(34,34,34,0.12)]';
 
   const typeBadgeClass = isDark
     ? 'bg-[rgba(77,141,255,0.14)] text-[#A9D2FF] border border-[rgba(108,161,255,0.24)]'
@@ -151,25 +151,25 @@ export const TaskCard: React.FC<TaskCardProps> = ({
 
   return (
     <article
-      className={`group rounded-[24px] p-4 transition-all duration-200 ${panelClass}`}
+      className={`group rounded p-4 transition-all duration-200 ${panelClass}`}
       onClick={handleCardClick}
     >
       <div className="flex items-start justify-between gap-3">
         <span
-          className={`inline-flex items-center gap-1.5 rounded-full px-3 py-1 text-xs font-medium ${typeBadgeClass}`}
+          className={`inline-flex items-center gap-1.5 rounded-sm px-2 py-1 text-xs font-medium ${typeBadgeClass}`}
         >
           <TypeIcon className="h-3.5 w-3.5" />
           {typeConfig.label}
         </span>
         <span
-          className={`inline-flex items-center rounded-full px-3 py-1 text-xs font-medium ${statusClass}`}
+          className={`inline-flex items-center rounded-sm px-2 py-1 text-xs font-medium ${statusClass}`}
         >
           {getColumnLabel(task.column)}
         </span>
       </div>
 
       <h3
-        className={`mt-5 text-[16px] font-semibold leading-7 ${
+        className={`mt-4 text-[16px] font-semibold leading-6 ${
           isDark ? 'text-white' : 'text-[#222222]'
         }`}
       >
@@ -177,9 +177,10 @@ export const TaskCard: React.FC<TaskCardProps> = ({
       </h3>
 
       <p
-        className={`mt-3 min-h-[56px] text-sm leading-7 ${
+        className={`mt-3 line-clamp-3 min-h-[63px] text-sm leading-[21px] ${
           isDark ? 'text-slate-300' : 'text-[#575757]'
         }`}
+        title={task.overview || undefined}
       >
         {task.overview || '暂无任务摘要'}
       </p>
@@ -204,9 +205,9 @@ export const TaskCard: React.FC<TaskCardProps> = ({
       <button
         type="button"
         onClick={handleActionClick}
-        className={`mt-5 flex h-12 w-full items-center justify-center gap-2 rounded-full text-sm font-medium transition ${actionClass}`}
+        className={`mt-4 flex h-9 w-full items-center justify-center gap-1.5 rounded-sm text-sm font-medium transition ${actionClass}`}
       >
-        {isCompleted ? <Eye className="h-4 w-4" /> : <Play className="h-4 w-4" />}
+        {isCompleted ? <Eye className="h-3.5 w-3.5" /> : <Play className="h-3.5 w-3.5" />}
         {isCompleted ? '查看结果' : '开始分析'}
       </button>
     </article>
diff --git a/frontend-web/src/strategy-components/components/task-components/task-mock-data.ts b/frontend-web/src/strategy-components/components/task-components/task-mock-data.ts
new file mode 100644
index 00000000..dfad039b
--- /dev/null
+++ b/frontend-web/src/strategy-components/components/task-components/task-mock-data.ts
@@ -0,0 +1,443 @@
+import { TaskListItem } from './TaskManagement';
+
+/**
+ * 任务看板假数据 —— 给「任务分析」「三情分析」两个页面提供演示数据，
+ * 用于没有后端 `/task/cop-tasks` / `/three/cop-three-tasks` 接口时本地预览。
+ *
+ * 是否启用由环境变量 `VITE_USE_REAL_DATA` 控制（见 `utils/request.ts`）：
+ *   - `VITE_USE_REAL_DATA=true`  → 走真实接口（不挂本 mock）
+ *   - 其它（含未设置）           → 这两个接口走本地假数据
+ * 提交的 .env.development / .env.production / .env.network / .env.sit 默认 true（真实），
+ * 仅本机 .env 默认 false（假数据）。
+ *
+ * 实现方式：作为一个临时 axios adapter 挂在请求拦截器上（命中两个 url 时直接返回 mock body，
+ * 不发真实请求），业务组件 `SentimentAnalyzes.tsx` / `TaskAnalyzes.tsx` 一行不用改。
+ * 返回结构与真实接口一致：`{ code, message, data: { records, total } }`。
+ */
+
+export type MockColumnType = 'unanalyzed' | 'running' | 'completed';
+export type MockDataset = 'task' | 'sentiment';
+
+interface MockTaskSeed {
+  taskName: string;
+  overview: string;
+  taskDirection: string;
+  taskLevel: number; // 1 一般 / 2 紧急 / 3 加急
+  taskType: number; // 1 单任务 / 2 场景 / 3 会商 / 4 多智能体 / 5 检索
+}
+
+/** 列 → 状态码，与组件内 taskStatusMap 对齐。 */
+const COLUMN_STATUS: Record<MockColumnType, number> = {
+  unanalyzed: 0,
+  running: 20,
+  completed: 30,
+};
+
+/** 生成一条完整的 TaskListItem，仅覆盖有意义的字段，其余给安全默认值。 */
+function makeTask(
+  id: number,
+  column: MockColumnType,
+  seed: MockTaskSeed,
+  createTime: string,
+  updateTime: string,
+): TaskListItem {
+  return {
+    createBy: 1001,
+    createTime,
+    deptId: null,
+    id,
+    isTop: 0,
+    issuingDept: '战略规划处',
+    keywords: null,
+    overview: seed.overview,
+    planTaskTop: 0,
+    platform: null,
+    ptaskId: null,
+    recommendedBasis: null,
+    scene: '',
+    sourceType: 1,
+    step: null,
+    taskContent: seed.overview,
+    taskDirection: seed.taskDirection,
+    taskEndDate: '2026-06-30 18:00:00',
+    taskLevel: seed.taskLevel,
+    taskName: seed.taskName,
+    taskNo: `T-${String(id).padStart(6, '0')}`,
+    taskStartDate: '2026-06-01 09:00:00',
+    taskStatus: COLUMN_STATUS[column],
+    taskSuperiorFlag: 0,
+    taskType: seed.taskType,
+    column,
+    updateBy: 1001,
+    updateTime,
+    endCount: column === 'completed' ? 1 : 0,
+    sumAll: 1,
+    progress: column === 'completed' ? 100 : column === 'running' ? 60 : 0,
+    taskStatusData: null,
+  } as TaskListItem;
+}
+
+/** 「任务分析」页（业务码 6BF）数据种子。 */
+const TASK_SEEDS: Record<MockColumnType, MockTaskSeed[]> = {
+  unanalyzed: [
+    {
+      taskName: '夏季文旅消费季传播任务分析',
+      overview:
+        '围绕"夏季文旅消费季"主题，梳理传播目标、核心受众与潜在策略阻力，输出可执行的任务拆解建议。',
+      taskDirection: '王磊',
+      taskLevel: 2,
+      taskType: 1,
+    },
+    {
+      taskName: '新能源补贴政策解读专题',
+      overview:
+        '针对新一轮新能源汽车补贴政策，分析公众关注焦点与误读风险点，形成政策解读传播要点清单。',
+      taskDirection: '李婷',
+      taskLevel: 1,
+      taskType: 5,
+    },
+    {
+      taskName: '城市更新片区舆论引导任务',
+      overview:
+        '对老城区改造涉及的拆迁、安置等敏感议题进行任务目标拆解，识别需要重点回应的群体诉求。',
+      taskDirection: '张伟',
+      taskLevel: 3,
+      taskType: 2,
+    },
+    {
+      taskName: '高校毕业季就业服务宣传',
+      overview:
+        '梳理面向应届毕业生的就业服务政策传播任务，明确分阶段触达节奏与渠道组合。',
+      taskDirection: '赵敏',
+      taskLevel: 1,
+      taskType: 1,
+    },
+    {
+      taskName: '防汛应急科普传播任务',
+      overview:
+        '汛期来临前，分析防汛减灾科普内容的传播目标与受众分层，制定预警信息发布预案。',
+      taskDirection: '陈昊',
+      taskLevel: 2,
+      taskType: 1,
+    },
+    {
+      taskName: '乡村振兴成果展示任务',
+      overview:
+        '围绕本地乡村振兴典型案例，拆解成果展示传播任务，确定故事化表达与素材采集方向。',
+      taskDirection: '周琳',
+      taskLevel: 1,
+      taskType: 2,
+    },
+  ],
+  running: [
+    {
+      taskName: '社区养老服务满意度专题分析',
+      overview:
+        '正在对社区居家养老服务的群众反馈进行任务分析，重点判断受众诉求与服务短板。',
+      taskDirection: '孙强',
+      taskLevel: 2,
+      taskType: 4,
+    },
+    {
+      taskName: '中小企业纾困政策落地评估',
+      overview:
+        '多智能体协同分析纾困政策落地过程中的执行阻力与企业关切，形成阶段性研判。',
+      taskDirection: '吴静',
+      taskLevel: 3,
+      taskType: 4,
+    },
+    {
+      taskName: '城市轨道交通延误舆情研判',
+      overview:
+        '针对近期地铁延误事件，正在拆解舆论传播路径与关键节点，评估引导策略有效性。',
+      taskDirection: '郑凯',
+      taskLevel: 2,
+      taskType: 3,
+    },
+    {
+      taskName: '食品安全抽检结果发布任务',
+      overview:
+        '正在分析食品安全抽检通报的发布口径与受众反应，优化信息透明度与安抚策略。',
+      taskDirection: '冯雪',
+      taskLevel: 1,
+      taskType: 1,
+    },
+  ],
+  completed: [
+    {
+      taskName: '春节文化活动传播复盘',
+      overview:
+        '已完成春节系列文化活动的传播任务分析，沉淀受众画像与高互动内容规律。',
+      taskDirection: '黄涛',
+      taskLevel: 1,
+      taskType: 3,
+    },
+    {
+      taskName: '医保改革政策宣传任务',
+      overview:
+        '已完成医保改革政策的传播目标拆解与受众分层，输出分群体沟通话术。',
+      taskDirection: '宋佳',
+      taskLevel: 2,
+      taskType: 4,
+    },
+    {
+      taskName: '城市营商环境优化宣传',
+      overview:
+        '已完成营商环境优化举措的任务分析，明确企业端与公众端的差异化传播重点。',
+      taskDirection: '高鹏',
+      taskLevel: 1,
+      taskType: 2,
+    },
+    {
+      taskName: '老旧小区加装电梯议题分析',
+      overview:
+        '已完成加装电梯涉及的邻里诉求与阻力识别，形成多方协商沟通建议。',
+      taskDirection: '何丽',
+      taskLevel: 2,
+      taskType: 3,
+    },
+    {
+      taskName: '生态环保主题宣传周复盘',
+      overview:
+        '已完成环保宣传周的传播效果分析，总结渠道贡献度与可复用素材。',
+      taskDirection: '罗勇',
+      taskLevel: 1,
+      taskType: 1,
+    },
+    {
+      taskName: '青年人才引进政策解读',
+      overview:
+        '已完成人才引进政策的受众判断与策略阻力分析，输出落地传播节奏表。',
+      taskDirection: '谭芳',
+      taskLevel: 1,
+      taskType: 5,
+    },
+  ],
+};
+
+/** 「三情分析」页（业务码 3Q）数据种子。 */
+const SENTIMENT_SEEDS: Record<MockColumnType, MockTaskSeed[]> = {
+  unanalyzed: [
+    {
+      taskName: '暑期旅游热点情绪监测',
+      overview:
+        '对暑期热门景区相关讨论进行情绪与倾向分析，识别游客吐槽集中点与正向口碑话题。',
+      taskDirection: '王磊',
+      taskLevel: 2,
+      taskType: 1,
+    },
+    {
+      taskName: '电价调整公众情绪研判',
+      overview:
+        '围绕居民阶梯电价调整，分析公众情绪走向与主要担忧，判断需要重点疏导的群体。',
+      taskDirection: '李婷',
+      taskLevel: 3,
+      taskType: 5,
+    },
+    {
+      taskName: '校园周边交通安全舆情',
+      overview:
+        '对校园周边交通安全话题进行三情分析，梳理家长群体情绪与诉求强度。',
+      taskDirection: '张伟',
+      taskLevel: 2,
+      taskType: 1,
+    },
+    {
+      taskName: '景区门票预约制讨论分析',
+      overview:
+        '分析门票预约制相关讨论的情绪分布，识别便利性与公平性两类核心关切。',
+      taskDirection: '赵敏',
+      taskLevel: 1,
+      taskType: 2,
+    },
+    {
+      taskName: '夜间经济噪音投诉情绪',
+      overview:
+        '对夜市、夜间演出引发的噪音投诉进行情绪分析，区分居民与商户的不同立场。',
+      taskDirection: '陈昊',
+      taskLevel: 1,
+      taskType: 1,
+    },
+  ],
+  running: [
+    {
+      taskName: '台风预警信息传播情绪追踪',
+      overview:
+        '正在分析台风预警发布后的公众情绪变化，评估恐慌情绪与配合度的动态走势。',
+      taskDirection: '孙强',
+      taskLevel: 3,
+      taskType: 4,
+    },
+    {
+      taskName: '学区划分调整舆论情绪',
+      overview:
+        '多智能体协同追踪学区调整话题的情绪热度与对立观点，研判潜在升级风险。',
+      taskDirection: '吴静',
+      taskLevel: 2,
+      taskType: 4,
+    },
+    {
+      taskName: '网络热点事件情绪态势',
+      overview:
+        '正在对近期网络热点事件进行三情分析，识别情绪峰值节点与关键意见领袖。',
+      taskDirection: '郑凯',
+      taskLevel: 2,
+      taskType: 3,
+    },
+  ],
+  completed: [
+    {
+      taskName: '春运出行体验情绪复盘',
+      overview:
+        '已完成春运期间出行体验的情绪与倾向分析，沉淀满意度变化与高频抱怨主题。',
+      taskDirection: '黄涛',
+      taskLevel: 1,
+      taskType: 3,
+    },
+    {
+      taskName: '惠民政策落地情绪评估',
+      overview:
+        '已完成惠民政策落地后的公众情绪评估，输出正向反馈与改进诉求清单。',
+      taskDirection: '宋佳',
+      taskLevel: 2,
+      taskType: 4,
+    },
+    {
+      taskName: '城市内涝应对情绪分析',
+      overview:
+        '已完成强降雨内涝事件的三情分析，总结情绪演化曲线与有效安抚措施。',
+      taskDirection: '高鹏',
+      taskLevel: 2,
+      taskType: 1,
+    },
+    {
+      taskName: '景区限流措施满意度分析',
+      overview:
+        '已完成节假日景区限流措施的情绪分析，明确游客接受度与体验改进方向。',
+      taskDirection: '何丽',
+      taskLevel: 1,
+      taskType: 2,
+    },
+    {
+      taskName: '公共交通票价听证情绪',
+      overview:
+        '已完成票价听证会相关讨论的情绪与立场分析，输出分群体沟通建议。',
+      taskDirection: '罗勇',
+      taskLevel: 1,
+      taskType: 5,
+    },
+  ],
+};
+
+const SEEDS: Record<MockDataset, Record<MockColumnType, MockTaskSeed[]>> = {
+  task: TASK_SEEDS,
+  sentiment: SENTIMENT_SEEDS,
+};
+
+/** 给同一列里的卡片生成错落有致的时间，便于「按时间倒序」展示。 */
+function buildTimes(index: number): { createTime: string; updateTime: string } {
+  const day = String(28 - index).padStart(2, '0');
+  const hour = String(9 + (index % 8)).padStart(2, '0');
+  return {
+    createTime: `2026-05-${day} ${hour}:15:00`,
+    updateTime: `2026-06-0${(index % 9) + 1} ${hour}:40:00`,
+  };
+}
+
+/** 数据集 → 列 → 完整任务列表（按 id 区分，避免两页 key 冲突）。 */
+function buildPool(dataset: MockDataset, column: MockColumnType): TaskListItem[] {
+  const base = dataset === 'task' ? 10000 : 20000;
+  const columnOffset = column === 'unanalyzed' ? 0 : column === 'running' ? 300 : 600;
+  return SEEDS[dataset][column].map((seed, index) => {
+    const { createTime, updateTime } = buildTimes(index);
+    return makeTask(base + columnOffset + index, column, seed, createTime, updateTime);
+  });
+}
+
+interface MockCopTasksPayload {
+  content?: string;
+  pageNum?: number;
+  pageSize?: number;
+  taskStatus?: number[];
+}
+
+/** 根据请求里的 taskStatus 数组反推当前查询的是哪一列。 */
+function resolveColumn(taskStatus?: number[]): MockColumnType {
+  const list = Array.isArray(taskStatus) ? taskStatus : [];
+  if (list.includes(20)) return 'running';
+  if (list.includes(0) || list.includes(10)) return 'unanalyzed';
+  return 'completed';
+}
+
+/**
+ * 模拟 `/task/cop-tasks` / `/three/cop-three-tasks` 接口的 body：
+ * 按列返回分页后的假数据，支持按 `content` 对任务名/摘要做模糊过滤。
+ */
+function buildCopTasksBody(dataset: MockDataset, payload: MockCopTasksPayload) {
+  const { content = '', pageNum = 1, pageSize = 10, taskStatus } = payload;
+  const column = resolveColumn(taskStatus);
+
+  let pool = buildPool(dataset, column);
+  const keyword = content.trim();
+  if (keyword) {
+    pool = pool.filter(
+      (item) =>
+        item.taskName.includes(keyword) || item.overview.includes(keyword),
+    );
+  }
+
+  const total = pool.length;
+  const start = (pageNum - 1) * pageSize;
+  const records = pool.slice(start, start + pageSize);
+
+  return { code: 0, message: 'ok', data: { records, total } };
+}
+
+/** 命中本 mock 的接口路径 → 对应数据集。 */
+const MOCK_ROUTES: Array<{ match: string; dataset: MockDataset }> = [
+  { match: '/three/cop-three-tasks', dataset: 'sentiment' },
+  { match: '/task/cop-tasks', dataset: 'task' },
+];
+
+/** 判断某个请求 url 是否应走假数据。 */
+export function matchTaskBoardMock(url?: string): MockDataset | null {
+  if (!url) return null;
+  const hit = MOCK_ROUTES.find((route) => url.includes(route.match));
+  return hit ? hit.dataset : null;
+}
+
+/**
+ * 临时假数据 axios adapter：命中任务看板接口时直接返回 mock body，不发真实请求。
+ * 仅在 `VITE_USE_REAL_DATA !== 'true'` 时由 request.ts 挂上（见那里的请求拦截器）。
+ */
+export function taskBoardMockAdapter(config: {
+  url?: string;
+  data?: unknown;
+}): Promise<{ data: unknown; status: number; statusText: string; headers: Record<string, unknown>; config: unknown }> {
+  const dataset = matchTaskBoardMock(config.url) ?? 'task';
+
+  let payload: MockCopTasksPayload = {};
+  try {
+    payload =
+      typeof config.data === 'string'
+        ? JSON.parse(config.data)
+        : ((config.data as MockCopTasksPayload) ?? {});
+  } catch {
+    payload = {};
+  }
+
+  const body = buildCopTasksBody(dataset, payload);
+
+  return new Promise((resolve) => {
+    // 模拟网络延迟，让 Loading 态可见。
+    setTimeout(() => {
+      resolve({
+        data: body,
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        config,
+      });
+    }, 280);
+  });
+}
diff --git a/frontend-web/src/utils/request.ts b/frontend-web/src/utils/request.ts
index 17c6a139..6666aa95 100644
--- a/frontend-web/src/utils/request.ts
+++ b/frontend-web/src/utils/request.ts
@@ -1,4 +1,12 @@
 import axios from 'axios'
+import { matchTaskBoardMock, taskBoardMockAdapter } from '@/strategy-components/components/task-components/task-mock-data'
+
+// 任务看板（任务分析 / 三情分析）数据源开关：
+//   VITE_USE_REAL_DATA=true → 走真实接口；其它（含未设置）→ 这两个接口走本地假数据。
+// 提交的 .env.development/.env.production/.env.network/.env.sit 默认 true（真实数据），
+// 仅本机 .env 默认 false（假数据）。改 env 后需重启 dev server 生效。
+const USE_REAL_DATA = import.meta.env.VITE_USE_REAL_DATA === 'true'
+
 // axios.interceptors
 const service = axios.create({
     // baseURL: '', // url = base url + request url
@@ -31,6 +39,10 @@ service.interceptors.response.use(
 )
 service.interceptors.request.use(
     config => {
+        // 假数据模式：任务看板两个接口直接走本地 mock，不发真实请求（VITE_USE_REAL_DATA=true 时跳过）。
+        if (!USE_REAL_DATA && matchTaskBoardMock(config.url)) {
+            config.adapter = taskBoardMockAdapter as any;
+        }
         // let token: any = localStorage.getItem('token');
         config.headers['Authorization'] = `Bearer admin`;
         // if (token) {
diff --git a/offline-backend-20260512/backend/CLAUDE.md b/offline-backend-20260512/backend/CLAUDE.md
index f6bfc4c9..e8944de1 100644
--- a/offline-backend-20260512/backend/CLAUDE.md
+++ b/offline-backend-20260512/backend/CLAUDE.md
@@ -250,9 +250,18 @@ FastAPI application on port 8001 with health check at `GET /health`. Set `GATEWA
 | **Scheduled Tasks** (`/api/scheduled-tasks`) | Per-user cron-like agent tasks. `GET/POST /` - list/create owned tasks; `PATCH/DELETE /{id}` - update/delete (owner); `POST /{id}/{pause,resume,trigger}`; `GET /{id}/runs`, `GET /runs/{rid}`, run-file preview/edit/download; `GET /runs/{rid}/messages` - agent messages for the run's underlying agent run (used to inspect a stuck/running run; authorized via `_load_run`); `GET /runs/{rid}/html` - generated HTML document for an `html_page` run; `DELETE /runs/{rid}` - owner-scoped, with an admin fallback so admins can delete any user's run; publish/subscribe under `/{id}/{publish,unpublish,subscribe}` and `GET /published`. **Admin (cross-user):** `GET /admin/all` - every task; `PATCH/DELETE /admin/{id}` - edit/delete any task; `POST /admin/{id}/trigger`; `GET /admin/{id}/runs`. Admin routes require `system_role == "admin"`. |
 | **HTML Page Favorites** (`/api/html-page-favorites`) | Bookmarked generated HTML pages, owner-scoped. `GET /` - list; `POST /` `{page_id, title?, description?, tags?}` - bookmark a `scheduled_html_pages` row (extracts a reusable style/layout summary via GLM5 at favorite time); a page can only be favorited once per user (`DuplicateFavoriteError` → HTTP 409). `GET/DELETE /{id}` - read/delete (the create-task reference picker deletes favorites here). A favorite can be selected as a style reference when creating a new `html_page` task. |
 | **Public Scheduled Tasks** (`/api/public/scheduled-tasks`) | **Unauthenticated** mirror for embedding. Adds `GET /runs/{rid}/html` and `GET /{task_id}/latest-html` for the `html_page` preview; the run result keeps `result.html` (only file paths are redacted). |
+| **Knowledge** (`/api/knowledge`) | Product knowledge base, **global/shared** (no user isolation; writes record `created_by`/`updated_by` for audit). `POST /ingest/thread/{thread_id}` - sediment one thread into a note (reads messages from the checkpointer, `threads:read` owner-checked); `POST /ingest/threads/batch` - batch-sediment the caller's recent threads (`skip_existing` via `.manifest.json` dedup). **Optional model selection**: both ingest endpoints accept `model_name` (overrides `knowledge.extract_model_name` for that capture; threaded through `KnowledgeService.capture_thread` → `extract_thread_llm_multi`). **Model-error surfacing**: when the chosen model produces nothing usable (timeout / API error / non-JSON) capture still **falls back to rule-based extraction and lands a draft** (`llm_fallback:true`); the single-thread (non-background) response and the batch response (`llm_fallback` count) carry this so the UI tells the user "已改用规则抽取". The "保存到知识库" chat button stays background/fire-and-forget (passes `model_name`, no per-save error toast); the batch-import dialog is synchronous and shows the fallback count. `POST /ingest/search` - sediment search/tool results as a reference note; `POST /notes` - manual note; `GET /notes` (keyword/tag/source_type/status + pagination); `GET/PUT/DELETE /notes/{id}` (DELETE is soft = archive, `?hard=true` removes the vault file); `POST /search` - `mode=keyword\|vector\|hybrid` (vector→keyword fallback when no embedding endpoint); `GET /notes/{id}/versions` - edit history; `GET /duplicates` + `POST /merge` - dedup; `POST /reindex` - rebuild vector index; `GET /graph` - product graph data (notes + entities); `POST /export/graph` + `GET /export/files/{graph.json\|graph.html\|graph.graphml\|cypher.txt}` - obsidian-wiki `wiki-export` artifacts (self-contained `graph.html` for iframe); `POST /resolve` `{targets:[…]}` + `GET /notes/{id}/wikilinks` - resolve `[[wikilink]]` targets to a note id / vault page / missing (powers clickable wikilinks); `GET /vault-page?path=` - read a raw vault meta/hub Markdown page (no DB note). Backed by the `deerflow.knowledge` module (see below). |
 
 Proxied through nginx: `/api/langgraph/*` → LangGraph, all other `/api/*` → Gateway.
 
+### Admin Leaderboard Snapshots (`/api/admin/users/leaderboard*`)
+
+The admin 用户排行榜 is served from **precomputed per-day snapshots** in `admin_leaderboard_daily_stats` (keyed by `(stat_date, settings_hash)`), not by aggregating raw rows on every request. A background scheduler inside the Gateway (`_leaderboard_snapshot_scheduler_loop` in `app/gateway/app.py`, singleton file-locked) ticks every `ADMIN_LEADERBOARD_BACKGROUND_INTERVAL_SECONDS` (default 300s): it prewarms recent days, then builds any `queued`/`error`/stale-`running` day. `GET /leaderboard` merges the per-day snapshots for the requested range. **Today** is rebuilt whenever its snapshot is older than `ADMIN_LEADERBOARD_TODAY_TTL_SECONDS` (default 300s); a past day, once `ready`, is treated as fresh forever.
+
+Two on-demand/automatic refresh paths layer on top:
+- **Manual "刷新当天"** — `POST /leaderboard/refresh-today` force-rebuilds *today's* snapshot **synchronously** (bounded by the same semaphore/timeout the scheduler uses), then returns the merged range. Lets an admin pull the latest real-time records into the stats without waiting for the TTL. Frontend: a "刷新当天" button on `AdminUserLeaderboardPage` → `useRefreshTodayLeaderboard` (`core/admin/hooks.ts`), which primes + invalidates the `["admin-activity","leaderboard"]` query.
+- **Daily finalize of the previous day** — once per day, on/after `ADMIN_LEADERBOARD_FINALIZE_HOUR` (local Beijing, default `1` = 凌晨 1 点), the scheduler tick force-recomputes *yesterday* a single time so runs/tool-calls that only landed near midnight are fully captured. The decision is the pure `deerflow.persistence.admin_stats.finalize.should_finalize_previous_day` (status/generated_at/now/hour) — the rebuild stamps `generated_at` to today, which self-debounces it for the rest of the day (no extra state file). Tests: `tests/test_leaderboard_finalize.py`.
+
 ### Scheduled Task Runtime
 
 `ScheduledTaskService` (`deerflow/runtime/scheduler/service.py`) polls due tasks every `poll_interval_seconds` and executes each in its own throwaway thread, serialized by a shared `_agent_run_lock`.
@@ -273,11 +282,32 @@ Proxied through nginx: `/api/langgraph/*` → LangGraph, all other `/api/*` →
 
 **HTML skills (tools the render step uses).** Two offline skills under `skills/public/` shape the generated HTML and are toggled in the skills settings page (enabled by default): `html-page-builder` (a self-contained inline-CSS design system — colors/cards/tables/KPI/responsive) and `html-charts` (inline-SVG charts that render in the no-`allow-scripts` preview iframe; optional local ECharts documented in its `assets/README.md`). A skill opts into HTML injection via `metadata.kind: html_page` in its SKILL.md frontmatter; `_collect_html_skill_instructions()` reads the bodies of **enabled** such skills and `build_generation_prompt(skill_instructions=…)` injects them, so the (raw-model) render step honors the user's skill selection. The data-gathering step and the render/repair/style passes all use the task's selected `model_name` (no silent fallback to the default model — and there is **no hardcoded GLM-5**; an unset selection falls back to config `models[0]`). To stop auxiliary LLM calls from leaking onto the default model, **`TitleMiddleware` is skipped when `is_scheduled_run` is set** (`_build_middlewares` in `lead_agent/agent.py`) — scheduled/HTML runs use throwaway threads whose titles are never shown, and `config.title.model_name` is usually unset (→ would call `models[0]`, not the chosen model). The completeness gate (`validate_html`) also requires a non-empty `<title>` and forbids external stylesheets, on top of the doctype/html/head/body + non-empty-body + no-script checks.
 
+### Knowledge Base (`packages/harness/deerflow/knowledge/`)
+
+Self-contained product knowledge base. **All knowledge capability lives in this one module** (harness layer, `deerflow.*` only — no `app.*` imports). Wired as `app.state.knowledge_service` in `deps.py` via `make_knowledge_service(sf, config.knowledge)` (returns `None` on the memory backend or when `knowledge.enabled=false` → router 503). Surfaced by `app/gateway/routers/knowledge.py` (`/api/knowledge`). Config: `config.yaml` → `knowledge` (`deerflow/config/knowledge_config.py`).
+
+**Two stores, kept in sync on every write:**
+- **DB mirror** — tables `knowledge_notes` / `knowledge_sources` / `knowledge_tags` / `knowledge_note_tags` (`knowledge/models.py`, registered in `persistence/models/__init__.py`, auto-created by `Base.metadata.create_all`; portable types `PortableLongText`/`BeijingDateTime`). Powers listing/filter/search/audit. Global/shared — no `user_id` column; `created_by`/`updated_by` are audit-only (resolved via `get_effective_user_id()`).
+- **Markdown vault** — obsidian-wiki compatible, default `{$DEER_FLOW_HOME}/data/knowledge/obsidian-vault`. `ObsidianWikiAdapter` (`obsidian_adapter.py`) writes wiki-capture frontmatter+body, and after **every** write syncs `index.md` / `log.md` (CAPTURE/INGEST/UPDATE/ARCHIVE/EXPORT) / `hot.md` / `.manifest.json` (source-hash dedup for `skip_existing`). `markdown_vault.py` handles frontmatter build/parse, slugging, wikilink extraction and **path-traversal-proof** resolution.
+
+**Module layout:** `models.py` (ORM: notes/sources/tags/note_tags + embeddings/versions/entities/relations) · `repository.py` (DB only, no LLM) · `schemas.py` (NoteDraft/SourceDraft DTOs) · `skill_templates.py` · `markdown_vault.py` · `manifest.py` · `extractor.py` (rule-based fallback) · `llm_extractor.py` (**default**: distills declarative knowledge per wiki-capture, structured JSON incl. entities/relations; falls back to `extractor.py`) · `sources.py` · `exporter.py` (`graph.json`/`graph.graphml`/`cypher.txt` + self-contained vanilla-JS `graph.html`; entity nodes + relation edges) · `chunking.py` + `embeddings.py` (OpenAI-compatible embedding client, keyword fallback) + `search.py` (keyword/vector/hybrid) · `sensitive.py` (secret/PII redaction) · `dedup.py` (Jaccard + hash dedup) · `auto_ingest.py` (background queue/worker) · `obsidian_adapter.py` · `service.py` (`KnowledgeService` orchestrator — the only thing the router touches). Tests: `tests/test_knowledge.py` (20 cases). Frontend: `frontend-web/src/core/knowledge/*` + `pages/KnowledgeBasePage.tsx` / `KnowledgeGraphPage.tsx` + chat `knowledge-save-trigger.tsx` / `knowledge-rag-toggle.tsx`; spec at `frontend-web/docs/product-knowledge-base-dev.md`.
+
+**Wikilinks & multi-note capture** (`knowledge.{related_notes_enabled,related_notes_limit,multi_note_enabled}`, all default-on; `project_name` defaults to `zncm`):
+- **Navigable `[[wikilinks]]`** — `service.resolve_wikilink(s)` maps a `[[target]]` to a knowledge note (by id → `vault_path` → title) or a vault meta page (`read_vault_page`, path-traversal-proof), else `missing`. `markdown_vault.normalize_wikilink_target` canonicalizes targets (drops `|alias`, slashes, `.md`). The frontend `MarkdownRenderer` renders non-numeric `[[...]]` as clickable links from the resolver map (numeric `[[123]]` stay citation badges); note links navigate, vault links open a `VaultPageDialog`, missing links are greyed.
+- **Real related notes only (no structural meta-links)** — `extractor.related_links()` now returns `[]`: notes no longer auto-link `index` / `_meta/taxonomy` / a project hub (they were noise in every `## Related`). On capture, `service._find_related_notes` cross-links **only by shared *distinctive* tags** (project/`knowledge-base` defaults excluded; free-text title/summary matching was removed because CJK tokenization linked unrelated notes via generic words like 助手/知识图谱) and `_inject_related_notes` writes real `[[Title]]` links into `## Related` (plus note→note `related` graph edges); no distinctive tags → no related notes. The renderers omit the `## Related` section entirely when there are no related notes and no sources. The vault's own `index.md`/`_meta/taxonomy.md` still exist (obsidian scaffold) and remain resolvable for manually-written links. The router enriches `GET /notes/{id}` with `created_by_name`/`updated_by_name` (auth-provider email lookup) so the UI shows a person, not a UUID. The frontend `MarkdownRenderer` renders wiki-capture provenance markers `^[inferred]`/`^[ambiguous]` as small "推测"/"存疑" badges.
+- **LLM-extraction outcomes** — capture distinguishes three LLM outcomes: (1) **success** → declarative note(s); (2) **deliberate rejection** — the model returns `should_ingest:false` with no notes (greeting / meta chatter) → `extract_thread_llm_multi` raises `LLMRejectedIngest` and `capture_thread` raises `EmptyThreadError` (skip — nothing persisted, so worthless chats never enter the KB); (3) **genuine failure** — API error / non-JSON → returns `[]`, capture falls back to the rule-based verbatim extractor and lands the note as a **`draft`** (not `approved`), logs a WARNING, and returns `llm_fallback:true` (surfaced by the router). `llm_extractor` logs an actionable WARNING/INFO for each non-success path so extraction issues are diagnosable.
+- **Multi-note split** — `llm_extractor.extract_thread_llm_multi` lets one conversation distill into 1–4 cross-linked notes (`notes:[…]` JSON array; legacy single-object output still accepted). `capture_thread` persists each, sibling-cross-links them by title, and returns `{note, created, notes:[…]}`. Gated by `multi_note_enabled` (false → first note only). Tests: `tests/test_knowledge_wikilinks.py`.
+
+**Phases 2–4 (all config-gated, defaults safe):**
+- **Phase 2 — vector RAG**: `knowledge.embedding.{enabled,base_url,api_key,model,...}` enables an OpenAI-compatible embedding endpoint; notes are chunked + embedded on write (`knowledge_embeddings`), `POST /search` supports `mode=keyword|vector|hybrid` (vector degrades to keyword when unconfigured). `KnowledgeRagMiddleware` (lead-agent chain) injects a transient `<knowledge-context>` recall before the model call, gated **per-conversation** by the `knowledge_rag_enabled` runtime flag (frontend chat toggle) falling back to global `knowledge.rag_enabled`. `POST /reindex` rebuilds the index.
+- **Phase 3 — governance**: `sensitive.py` redacts secrets/PII before persistence (`sensitive_redaction_enabled`); every update snapshots `knowledge_note_versions` (`GET /notes/{id}/versions`); `GET /duplicates` + `POST /merge` for dedup; background `AutoIngestQueue` (wired in `deps.py`, started/stopped in the gateway lifespan) auto-sediments finished conversations **off the chat path** when `auto_ingest_enabled` — enqueued from `KnowledgeRagMiddleware.after_agent`, value-judged by min-chars + `skip_existing`, landing as `draft`.
+- **Phase 4 — graph**: LLM extraction also yields entities/relations → `knowledge_entities`/`knowledge_relations`; `exporter.build_graph` adds entity nodes + note→entity/entity→entity edges (reflected in `graph.html`/`graph.json`); `GET /graph` returns product graph data.
+
 ### Custom Agent Persistence
 
 Custom agent metadata lives in the `agents` ORM table (`deerflow.persistence.agents`). `agents.id` is the stable runtime id and the filesystem directory name under `.deer-flow/agents/{id}/`; `agents.name` is display-only, can contain Chinese characters, and is not unique. `user_id IS NULL` marks built-in agents, user-owned agents are visible only to their owner unless `published = true`, and update/delete operations require ownership. The runtime accepts `agent_id` in context/configurable, and non-default `assistant_id` values are treated as agent ids after visibility checks.
 
-**Listing cache + pagination** — to keep `GET /api/agents` fast, the gallery's per-card extras (skills + tool_groups) are denormalized into two cache tables instead of reading every agent's `config.yaml` on each request: `agent_skills` (relational, one row per (agent, skill) with `position`) and `agent_extras` (one row per agent: `tool_groups` JSON + `model` + `skills_synced_at`). `config.yaml` remains authoritative for the agent runtime; these tables are a read cache, write-through on create/update and backfilled from disk by `_sync_legacy_agents` (mtime-vs-`skills_synced_at` drift check). The list endpoint enriches via `AgentStore.get_extras_for([ids])` (two batched `IN` queries). Both tables are auto-created by `Base.metadata.create_all` (no migration needed). `GET /api/agents` supports **opt-in server-side pagination**: `scope` (`mine` = owned + favorited / `square` = built-in/published public), `page`, `page_size`, returning `{agents, total, page, page_size}`; omitting `scope`/`page` preserves the legacy "return everything" behavior. Name `search` matches the raw OR desensitized name (the frontend's static term→abbrev map is mirrored server-side in `deerflow/config/agent_name_desensitize.py`); `tag_ids` is an SQL OR-filter. `POST /api/agents/private-square/list` takes the same pagination params. Repository entry point: `AgentStore.list_paginated(...)`.
+**Listing cache + pagination** — to keep `GET /api/agents` fast, the gallery's per-card extras (skills + tool_groups) are denormalized into two cache tables instead of reading every agent's `config.yaml` on each request: `agent_skills` (relational, one row per (agent, skill) with `position`) and `agent_extras` (one row per agent: `tool_groups` JSON + `model` + `skills_synced_at`). `config.yaml` remains authoritative for the agent runtime; these tables are a read cache, write-through on create/update and backfilled from disk by `_sync_legacy_agents` (mtime-vs-`skills_synced_at` drift check). The list endpoint enriches via `AgentStore.get_extras_for([ids])` (two batched `IN` queries). Both tables are auto-created by `Base.metadata.create_all` (no migration needed). `GET /api/agents` supports **opt-in server-side pagination**: `scope` (`mine` = owned + favorited / `square` = built-in/published public), `page`, `page_size`, returning `{agents, total, page, page_size}`; omitting `scope`/`page` preserves the legacy "return everything" behavior. Name `search` matches the raw OR desensitized name (the frontend's static term→abbrev map is mirrored server-side in `deerflow/config/agent_name_desensitize.py`); `tag_ids` is an SQL OR-filter; `owner` keeps only agents published by that user id (the card's 发布者 — built-in agents never match), powering the gallery's click-发布者-to-filter. `POST /api/agents/private-square/list` takes the same pagination params (incl. `owner`). Repository entry point: `AgentStore.list_paginated(...)`. Tests: `tests/test_agent_listing_cache.py::test_list_paginated_owner_filter_keeps_one_publisher`.
 
 **Homepage selector (agent picker on the new-chat page)** — single admin-curated list backed by `agents.featured_order` (nullable BIGINT). NULL = not featured. Only `published = true` agents can be featured (router enforces on writes); any published agent is eligible regardless of ownership. Cleared with `order: null`. The list rendered to end users is `WHERE featured_order IS NOT NULL` + visibility-filter, sorted by `featured_order ASC`. Admins reorder by sending the desired ids to `PUT /api/agents/featured/order` (assigns indices 0..N-1). BIGINT is used rather than INT so the management UI can seed initial values from `Date.now()` (overflows INT on MySQL).
 
@@ -289,6 +319,16 @@ Two `TypeDecorator`s keep ORM columns correct across the `sqlite` / `postgres` /
 - **`PortableLongText`** — a large text column: maps to MySQL `LONGTEXT` (4 GB) and plain `TEXT` on SQLite/Postgres (already unbounded). Use for big JSON/markdown blobs that would overflow MySQL's 64 KB `TEXT` cap — e.g. `ai_writing_sessions.transcript`.
 - **`BeijingDateTime`** — stores timestamps as Beijing (UTC+8) wall-clock time. The app records time with `datetime.now(UTC)`, but MySQL `DATETIME` / SQLite have no timezone and persist whatever wall clock the driver serializes — so a raw `DateTime` column would store UTC and read 8 hours behind Beijing. `BeijingDateTime` converts UTC→Beijing on bind and re-attaches `+08:00` on result, so the database holds Beijing time while Python still gets timezone-aware datetimes (instant comparisons stay correct, including in WHERE clauses). PostgreSQL `timestamptz` stores the instant unambiguously, so values pass through unchanged there. Uses a fixed UTC+8 offset (China has no DST), so no `tzdata` dependency.
 
+### Schema Migrations / Manual Column-Add SQL (`scripts/sql/`)
+
+Alembic auto-migration is **disabled** — `_run_alembic_upgrade(url)` is commented out in `persistence/engine.py`. On startup only `Base.metadata.create_all` runs, which creates **new tables** but never patches **existing** ones (no new columns, no new indexes). So a column added to an ORM model appears automatically on a brand-new deployment, but is **missing on any existing MySQL database** — and code reading/writing that column will error there until the column is added by hand.
+
+**Convention (required):** whenever code adds a field to an existing table (a new `mapped_column` on an ORM model), you must, in the same change:
+1. Keep the matching alembic version file under `persistence/migrations/versions/` (guarded with `_has_table`/`_has_column`), and
+2. Append the idempotent `ADD COLUMN` statement to **`scripts/sql/column_additions_mysql.sql`**, with a definition matching the ORM column exactly (type, length, nullability).
+
+Operators upgrading an existing DB run the whole file (`USE <db>;` then execute) — it is idempotent (existing columns are skipped via `information_schema.columns`), so it is safe to re-run. Index-only changes go in the sibling `scripts/sql/leaderboard_indexes_mysql.sql` (same idempotent pattern).
+
 ### Sandbox System (`packages/harness/deerflow/sandbox/`)
 
 **Interface**: Abstract `Sandbox` with `execute_command`, `read_file`, `write_file`, `list_dir`
@@ -358,6 +398,7 @@ Two `TypeDecorator`s keep ORM columns correct across the `sqlite` / `postgres` /
 - **Loading**: `load_skills()` recursively scans `skills/{public,custom}` for `SKILL.md`, parses metadata, and reads enabled state from extensions_config.json
 - **Injection**: Enabled skills listed in agent system prompt with container paths
 - **Installation**: `POST /api/skills/install` extracts .skill ZIP archive to custom/ directory
+- **Chinese name (`name_zh`)**: a Chinese display name stored in the **`skills` DB table** (`SkillRow.name_zh`, `String(128)`, migration `20260609_01`) — never written to the on-disk SKILL.md, so it works for built-in skills too. Threaded through `SkillStore` create/ensure_legacy/update/update_admin exactly like `detail`; surfaced on `SkillResponse.name_zh` from the ownership record in `_skill_to_response`. Authorization mirrors `detail`: custom skill → owner or admin; built-in/public → admin only (row materialized on demand via `ensure_legacy`). Endpoints (in `app/gateway/routers/skills.py`): `PUT /api/skills/{name}/name-zh` (set/clear), `POST /api/skills/{name}/name-zh/generate` (LLM generates one), `POST /api/skills/name-zh/generate-missing` (一键补充: **admin-only** bulk-generate for every skill that lacks one, bounded-concurrency `asyncio.gather`). **Optional model selection**: both generate endpoints accept an optional JSON body `{model_name}` — an explicit name wins, else the curator model setting, else the main model (`_resolve_skill_name_zh_model_name`). **Model-error surfacing**: `_generate_skill_name_zh` raises `SkillNameZhModelError` when the model itself fails (build/timeout/API error) — distinct from the model returning an unusable name (→ `None`). The single endpoint maps that to `502 大模型报错,无法补全技能中文名:…`; the bulk endpoint fails fast on a model-build error (502) and otherwise carries a representative `model_error` string in `SkillNameZhBulkResponse` so the UI can say "N 个因大模型报错失败". The frontend (`skill-settings-page.tsx` list + `skill-detail-dialog.tsx` editor, plus the agent skill pickers/badges in `NewAgentPage.tsx` + `agent-card.tsx`) shows `name_zh || name`, offers per-skill "AI 生成" plus an **admin-only** header "一键补充中文名" button, and a compact model dropdown (`components/workspace/model-name-select.tsx`, default = configured model) beside each action.
 
 #### Skill Curator (`packages/harness/deerflow/skills/curator.py`)
 
diff --git a/offline-backend-20260512/backend/app/gateway/app.py b/offline-backend-20260512/backend/app/gateway/app.py
index 5eb1accc..78bcde73 100644
--- a/offline-backend-20260512/backend/app/gateway/app.py
+++ b/offline-backend-20260512/backend/app/gateway/app.py
@@ -6,6 +6,8 @@ import sys
 import threading
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
+from datetime import datetime
+from time import perf_counter
 
 from dotenv import load_dotenv
 from fastapi import FastAPI
@@ -30,12 +32,14 @@ from app.gateway.routers import (
     artifacts,
     assistants_compat,
     auth,
+    browser_context,
     business_mapping,
     channels,
     checkpoint_migration,
     feedback,
     html_page_favorites,
     intent,
+    knowledge,
     llm_metrics,
     mcp,
     memory,
@@ -45,6 +49,7 @@ from app.gateway.routers import (
     parallel_agent_tasks,
     parallel_agents,
     public_embed,
+    public_leaderboard,
     public_scheduled_tasks,
     recommend,
     recommended_questions,
@@ -469,6 +474,91 @@ _LEADERBOARD_SNAPSHOT_STARTUP_DELAY_SECONDS = _env_float(
     "ADMIN_LEADERBOARD_BACKGROUND_STARTUP_DELAY_SECONDS",
     60.0,
 )
+# Hour (local Beijing time, 0-23) after which the scheduler force-recomputes the
+# *previous* day's snapshot once, so records that landed near midnight are fully
+# captured. Default 1 → "每天凌晨 1 点重新统计前一天".
+_LEADERBOARD_FINALIZE_HOUR = min(
+    23,
+    _env_int("ADMIN_LEADERBOARD_FINALIZE_HOUR", 1, minimum=0),
+)
+
+
+def _leaderboard_scheduler_sql_for_log(stmt) -> str:
+    try:
+        return str(stmt.compile(compile_kwargs={"literal_binds": True}))
+    except Exception:
+        return str(stmt)
+
+
+async def _execute_leaderboard_scheduler_query(session, step: str, stmt, **context):
+    sql = _leaderboard_scheduler_sql_for_log(stmt)
+    logger.info(
+        "Leaderboard snapshot DB query start: step=%s stat_date=%s job=%s settings_hash=%s started_at=%s sql=%s",
+        step,
+        context.get("stat_date") or context.get("stat_dates") or "",
+        context.get("job_key") or "",
+        context.get("settings_hash") or "",
+        datetime.now().isoformat(),
+        sql,
+    )
+    start = perf_counter()
+    try:
+        result = await session.execute(stmt)
+    except Exception:
+        logger.exception(
+            "Leaderboard snapshot DB query failed: step=%s stat_date=%s job=%s settings_hash=%s elapsed_ms=%.2f",
+            step,
+            context.get("stat_date") or context.get("stat_dates") or "",
+            context.get("job_key") or "",
+            context.get("settings_hash") or "",
+            (perf_counter() - start) * 1000,
+        )
+        raise
+    logger.info(
+        "Leaderboard snapshot DB query done: step=%s stat_date=%s job=%s settings_hash=%s finished_at=%s elapsed_ms=%.2f",
+        step,
+        context.get("stat_date") or context.get("stat_dates") or "",
+        context.get("job_key") or "",
+        context.get("settings_hash") or "",
+        datetime.now().isoformat(),
+        (perf_counter() - start) * 1000,
+    )
+    return result
+
+
+async def _time_leaderboard_scheduler_db_operation(step: str, operation, *, sql: str = "", **context):
+    logger.info(
+        "Leaderboard snapshot DB query start: step=%s stat_date=%s job=%s settings_hash=%s started_at=%s sql=%s",
+        step,
+        context.get("stat_date") or context.get("stat_dates") or "",
+        context.get("job_key") or "",
+        context.get("settings_hash") or "",
+        datetime.now().isoformat(),
+        sql,
+    )
+    start = perf_counter()
+    try:
+        result = await operation()
+    except Exception:
+        logger.exception(
+            "Leaderboard snapshot DB query failed: step=%s stat_date=%s job=%s settings_hash=%s elapsed_ms=%.2f",
+            step,
+            context.get("stat_date") or context.get("stat_dates") or "",
+            context.get("job_key") or "",
+            context.get("settings_hash") or "",
+            (perf_counter() - start) * 1000,
+        )
+        raise
+    logger.info(
+        "Leaderboard snapshot DB query done: step=%s stat_date=%s job=%s settings_hash=%s finished_at=%s elapsed_ms=%.2f",
+        step,
+        context.get("stat_date") or context.get("stat_dates") or "",
+        context.get("job_key") or "",
+        context.get("settings_hash") or "",
+        datetime.now().isoformat(),
+        (perf_counter() - start) * 1000,
+    )
+    return result
 
 
 def _recent_leaderboard_stat_dates(days: int) -> list[str]:
@@ -496,21 +586,27 @@ async def _leaderboard_snapshot_due_dates(
 
     cutoff = datetime.now(UTC) - timedelta(seconds=running_ttl_seconds)
     async with session_factory() as session:
-        rows = (
-            await session.execute(
-                select(AdminLeaderboardDailyStatRow.stat_date)
-                .where(
-                    AdminLeaderboardDailyStatRow.settings_hash == settings_hash,
-                    or_(
-                        AdminLeaderboardDailyStatRow.status.in_(["queued", "error"]),
-                        and_(
-                            AdminLeaderboardDailyStatRow.status == "running",
-                            AdminLeaderboardDailyStatRow.updated_at < cutoff,
-                        ),
+        stmt = (
+            select(AdminLeaderboardDailyStatRow.stat_date)
+            .where(
+                AdminLeaderboardDailyStatRow.settings_hash == settings_hash,
+                or_(
+                    AdminLeaderboardDailyStatRow.status.in_(["queued", "error"]),
+                    and_(
+                        AdminLeaderboardDailyStatRow.status == "running",
+                        AdminLeaderboardDailyStatRow.updated_at < cutoff,
                     ),
-                )
-                .order_by(AdminLeaderboardDailyStatRow.stat_date.desc())
-                .limit(limit)
+                ),
+            )
+            .order_by(AdminLeaderboardDailyStatRow.stat_date.desc())
+            .limit(limit)
+        )
+        rows = (
+            await _execute_leaderboard_scheduler_query(
+                session,
+                "scheduler.due_dates",
+                stmt,
+                settings_hash=settings_hash,
             )
         ).all()
     return [str(row[0]) for row in rows]
@@ -530,9 +626,15 @@ async def _claim_leaderboard_snapshot(
     from deerflow.persistence.types import BEIJING_TZ
 
     async with session_factory() as session:
-        row = await session.get(
-            AdminLeaderboardDailyStatRow,
-            {"stat_date": stat_date, "settings_hash": settings_hash},
+        row = await _time_leaderboard_scheduler_db_operation(
+            "scheduler.claim.get",
+            lambda: session.get(
+                AdminLeaderboardDailyStatRow,
+                {"stat_date": stat_date, "settings_hash": settings_hash},
+            ),
+            sql="SELECT admin_leaderboard_daily_stats by primary key",
+            stat_date=stat_date,
+            settings_hash=settings_hash,
         )
         if row is None or _snapshot_is_fresh(row, stat_date):
             return False
@@ -548,10 +650,68 @@ async def _claim_leaderboard_snapshot(
         row.message = "排行榜后台统计任务已认领。"
         row.error = None
         row.updated_at = datetime.now(UTC)
-        await session.commit()
+        await _time_leaderboard_scheduler_db_operation(
+            "scheduler.claim.commit",
+            lambda: session.commit(),
+            sql="COMMIT",
+            stat_date=stat_date,
+            settings_hash=settings_hash,
+        )
     return True
 
 
+async def _maybe_finalize_previous_leaderboard_day(session_factory, settings_hash: str) -> bool:
+    """Once per day after ``_LEADERBOARD_FINALIZE_HOUR``, force-recompute yesterday.
+
+    A ``ready`` past-day snapshot is otherwise treated as fresh forever and never
+    rebuilt. But the previous day's snapshot is usually generated before midnight,
+    so it can miss runs/tool-calls that only land in the DB around the day
+    boundary. This re-queues yesterday (``force=True``) a single time; the rebuild
+    stamps ``generated_at`` to today, which stops it from re-firing for the rest of
+    the day.
+    """
+    from datetime import timedelta
+
+    from app.gateway.routers.admin_users import (
+        _as_beijing,
+        _queue_daily_leaderboard_snapshots,
+    )
+    from deerflow.persistence.admin_stats.finalize import should_finalize_previous_day
+    from deerflow.persistence.admin_stats.model import AdminLeaderboardDailyStatRow
+    from deerflow.persistence.types import BEIJING_TZ
+
+    now = datetime.now(BEIJING_TZ)
+    yesterday = (now.date() - timedelta(days=1)).isoformat()
+    async with session_factory() as session:
+        row = await session.get(
+            AdminLeaderboardDailyStatRow,
+            {"stat_date": yesterday, "settings_hash": settings_hash},
+        )
+    generated_at = _as_beijing(row.generated_at) if (row is not None and row.generated_at is not None) else None
+    if not should_finalize_previous_day(
+        status=(row.status if row is not None else None),
+        generated_at=generated_at,
+        now=now,
+        finalize_hour=_LEADERBOARD_FINALIZE_HOUR,
+    ):
+        return False
+    queued = await _queue_daily_leaderboard_snapshots(
+        session_factory,
+        [yesterday],
+        settings_hash,
+        force=True,
+        message="每日凌晨重新统计前一天完整数据，确保全部记录纳入统计。",
+    )
+    if queued:
+        logger.info(
+            "Leaderboard snapshot finalize: queued previous day %s for full recompute (hash=%s)",
+            yesterday,
+            settings_hash[:10],
+        )
+        return True
+    return False
+
+
 async def _run_leaderboard_snapshot_tick() -> tuple[int, int]:
     from app.gateway.routers.admin_users import (
         _daily_job_key,
@@ -576,6 +736,12 @@ async def _run_leaderboard_snapshot_tick() -> tuple[int, int]:
         message="排行榜后台统计任务定期预热/补算队列。",
     )
 
+    # 每天凌晨（默认 1 点）后强制重算"前一天"的完整快照一次，覆盖跨午夜才落库的记录。
+    try:
+        await _maybe_finalize_previous_leaderboard_day(session_factory, settings_hash)
+    except Exception:
+        logger.exception("Leaderboard snapshot finalize check failed (non-fatal)")
+
     due_dates = await _leaderboard_snapshot_due_dates(
         session_factory,
         settings_hash=settings_hash,
@@ -1115,6 +1281,9 @@ This gateway provides custom endpoints for models, MCP configuration, skills, an
     # Uploads API is mounted at /api/threads/{thread_id}/uploads
     app.include_router(uploads.router)
 
+    # Optional Chrome-extension page capture API is mounted at /api/browser-context
+    app.include_router(browser_context.router)
+
     # Thread cleanup API is mounted at /api/threads/{thread_id}
     app.include_router(threads.router)
 
@@ -1162,10 +1331,16 @@ This gateway provides custom endpoints for models, MCP configuration, skills, an
     # surface results without a DeerFlow login.
     app.include_router(public_scheduled_tasks.router)
 
+    # Public read-only user leaderboard publish page (/api/public/leaderboard)
+    app.include_router(public_leaderboard.router)
+
     # Public embed Q&A status polling (/api/public/embed/*)
     app.include_router(public_embed.router)
     app.include_router(html_page_favorites.router)
 
+    # Product knowledge base API is mounted at /api/knowledge
+    app.include_router(knowledge.router)
+
     # System settings API is mounted at /api/system-settings
     app.include_router(system_settings.router)
 
@@ -1174,6 +1349,7 @@ This gateway provides custom endpoints for models, MCP configuration, skills, an
 
     # Admin window into other users' threads / messages / memory
     app.include_router(admin_users.router)
+    app.include_router(admin_users.self_router)
 
     # Admin tool / skill call metrics audit + export
     app.include_router(tool_metrics.router)
diff --git a/offline-backend-20260512/backend/app/gateway/auth_middleware.py b/offline-backend-20260512/backend/app/gateway/auth_middleware.py
index ff3bb86c..ae124dfb 100644
--- a/offline-backend-20260512/backend/app/gateway/auth_middleware.py
+++ b/offline-backend-20260512/backend/app/gateway/auth_middleware.py
@@ -20,6 +20,7 @@ from app.gateway.auth.disabled_mode import get_assumed_user_for_disabled_auth, i
 from app.gateway.auth.errors import AuthErrorCode, AuthErrorResponse
 from app.gateway.authz import _ALL_PERMISSIONS, AuthContext
 from app.gateway.internal_auth import INTERNAL_AUTH_HEADER_NAME, get_internal_user, is_valid_internal_auth_token
+from app.gateway.proxy_path import app_relative_path
 from deerflow.runtime.user_context import reset_current_user, set_current_user
 
 # Paths that never require authentication.
@@ -84,7 +85,9 @@ class AuthMiddleware(BaseHTTPMiddleware):
         super().__init__(app)
 
     async def dispatch(self, request: Request, call_next: Callable) -> Response:
-        if _is_public(request.url.path):
+        # Match the application-relative path so a reverse-proxy prefix
+        # (e.g. /xxx/api/public/...) does not defeat the public whitelist.
+        if _is_public(app_relative_path(request)):
             return await call_next(request)
 
         if is_auth_disabled():
diff --git a/offline-backend-20260512/backend/app/gateway/csrf_middleware.py b/offline-backend-20260512/backend/app/gateway/csrf_middleware.py
index 07b46047..c5494277 100644
--- a/offline-backend-20260512/backend/app/gateway/csrf_middleware.py
+++ b/offline-backend-20260512/backend/app/gateway/csrf_middleware.py
@@ -8,6 +8,7 @@ import secrets
 from collections.abc import Callable
 
 from app.gateway.auth.disabled_mode import is_auth_disabled
+from app.gateway.proxy_path import app_relative_path
 from fastapi import Request, Response
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.responses import JSONResponse
@@ -37,7 +38,9 @@ def should_check_csrf(request: Request) -> bool:
     if request.method not in ("POST", "PUT", "DELETE", "PATCH"):
         return False
 
-    path = request.url.path
+    # Match the application-relative path so a reverse-proxy prefix
+    # (e.g. /xxx/api/v1/auth/me) does not defeat these whitelists.
+    path = app_relative_path(request)
     stripped = path.rstrip("/")
     # Exempt /api/v1/auth/me endpoint
     if stripped == "/api/v1/auth/me":
@@ -56,6 +59,10 @@ _AUTH_EXEMPT_PATHS: frozenset[str] = frozenset(
     {
         "/api/v1/auth/login/local",
         "/api/v1/auth/login/username",
+        # Token-exchange login is sessionless on first call (no CSRF cookie yet),
+        # exactly like the other login endpoints — mirror auth_middleware's
+        # _PUBLIC_EXACT_PATHS, which already whitelists it.
+        "/api/v1/auth/login/token",
         "/api/v1/auth/logout",
         "/api/v1/auth/register",
         "/api/v1/auth/initialize",
@@ -69,8 +76,10 @@ def is_auth_endpoint(request: Request) -> bool:
     """Check if the request is to an auth endpoint.
 
     Auth endpoints don't need CSRF validation on first call (no token).
+    Matches the application-relative path so a reverse-proxy prefix does not
+    defeat the whitelist.
     """
-    return request.url.path.rstrip("/") in _AUTH_EXEMPT_PATHS
+    return app_relative_path(request).rstrip("/") in _AUTH_EXEMPT_PATHS
 
 
 def _has_bearer_auth(request: Request) -> bool:
@@ -82,6 +91,22 @@ def _has_bearer_auth(request: Request) -> bool:
     return scheme.lower() == "bearer" and bool(token.strip())
 
 
+def _has_cookie_session(request: Request) -> bool:
+    """Return True when the request carries a cookie-based session.
+
+    Double-Submit-Cookie CSRF only protects requests the browser authenticates
+    **automatically via cookies** — that is the exact surface a cross-site
+    forgery can ride. A request with no ``access_token`` session cookie has no
+    session for an attacker to exploit, so enforcing CSRF on it is both
+    pointless and harmful: a freshly-loaded browser (e.g. one that just cleared
+    its cache/cookies) hitting the login endpoint would otherwise be rejected
+    with "CSRF token missing" before it can even sign in. Such an
+    unauthenticated request, if forged, is rejected by the auth layer (401)
+    anyway.
+    """
+    return bool(request.cookies.get("access_token"))
+
+
 class CSRFMiddleware(BaseHTTPMiddleware):
     """Middleware that implements CSRF protection using Double Submit Cookie pattern."""
 
@@ -95,8 +120,11 @@ class CSRFMiddleware(BaseHTTPMiddleware):
             return await call_next(request)
 
         # Double-submit-cookie CSRF applies to cookie-based browser sessions.
-        # API clients using explicit Bearer tokens are not CSRF-prone.
-        if should_check_csrf(request) and not _is_auth and not _has_bearer_auth(request):
+        # API clients using explicit Bearer tokens are not CSRF-prone, and a
+        # request with no session cookie at all (e.g. a fresh browser signing
+        # in) has no session to forge — only enforce when an ``access_token``
+        # cookie is actually present.
+        if should_check_csrf(request) and not _is_auth and not _has_bearer_auth(request) and _has_cookie_session(request):
             cookie_token = request.cookies.get(CSRF_COOKIE_NAME)
             header_token = request.headers.get(CSRF_HEADER_NAME)
 
diff --git a/offline-backend-20260512/backend/app/gateway/deps.py b/offline-backend-20260512/backend/app/gateway/deps.py
index cfc86437..62ae4daa 100644
--- a/offline-backend-20260512/backend/app/gateway/deps.py
+++ b/offline-backend-20260512/backend/app/gateway/deps.py
@@ -143,6 +143,8 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
 
         from deerflow.persistence.ai_writing_sessions import (
             make_ai_writing_session_store,
+        )
+        from deerflow.persistence.ai_writing_sessions import (
             register_default_store as _register_ai_writing_default_store,
         )
 
@@ -159,6 +161,25 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
 
         app.state.memory_config_store = make_user_memory_config_store(sf)
 
+        from deerflow.knowledge import make_knowledge_service
+
+        app.state.knowledge_service = make_knowledge_service(sf, config.knowledge)
+
+        # Background auto-sedimentation queue (phase 3) — drains finished
+        # conversations off the chat path. Worker only does work when
+        # ``knowledge.auto_ingest_enabled`` is set; the queue is always wired so
+        # the middleware can enqueue without a hard dependency.
+        from deerflow.knowledge.auto_ingest import AutoIngestQueue, set_auto_ingest_queue
+
+        if app.state.knowledge_service is not None:
+            _auto_ingest_queue = AutoIngestQueue(
+                lambda: getattr(app.state, "knowledge_service", None),
+                min_chars=config.knowledge.auto_ingest_min_chars,
+            )
+            _auto_ingest_queue.start()
+            set_auto_ingest_queue(_auto_ingest_queue)
+            app.state.knowledge_auto_ingest_queue = _auto_ingest_queue
+
         from deerflow.persistence.user_prompts import make_user_prompt_store
 
         app.state.user_prompt_store = make_user_prompt_store(sf)
@@ -189,6 +210,8 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
 
         from deerflow.persistence.roundtable_jobs import (
             make_roundtable_job_store,
+        )
+        from deerflow.persistence.roundtable_jobs import (
             register_default_store as _register_roundtable_job_default_store,
         )
 
@@ -246,6 +269,12 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
             from deerflow.persistence.notifications import set_notification_store
 
             set_notification_store(None)
+            queue = getattr(app.state, "knowledge_auto_ingest_queue", None)
+            if queue is not None:
+                from deerflow.knowledge.auto_ingest import set_auto_ingest_queue
+
+                await queue.stop()
+                set_auto_ingest_queue(None)
             await close_engine()
 
 
@@ -380,6 +409,14 @@ def get_memory_config_store(request: Request):
     return val
 
 
+def get_knowledge_service(request: Request):
+    """Return the knowledge base service (503 when disabled / memory backend)."""
+    val = getattr(request.app.state, "knowledge_service", None)
+    if val is None:
+        raise HTTPException(status_code=503, detail="Knowledge base not available")
+    return val
+
+
 def get_run_context(request: Request) -> RunContext:
     """Build a :class:`RunContext` from ``app.state`` singletons.
 
diff --git a/offline-backend-20260512/backend/app/gateway/langgraph_auth.py b/offline-backend-20260512/backend/app/gateway/langgraph_auth.py
index 0929b193..581a8020 100644
--- a/offline-backend-20260512/backend/app/gateway/langgraph_auth.py
+++ b/offline-backend-20260512/backend/app/gateway/langgraph_auth.py
@@ -40,6 +40,13 @@ def _check_csrf(request) -> None:
         # CSRF protection is for cookie-auth browser flows.
         return
 
+    # No cookie-based session → nothing for a cross-site forgery to ride, so
+    # CSRF is moot. Enforcing it here would reject a freshly-loaded browser
+    # (just cleared its cookies) before it can authenticate; such a request is
+    # rejected as unauthenticated (401) below anyway.
+    if not request.cookies.get("access_token"):
+        return
+
     cookie_token = request.cookies.get("csrf_token")
     header_token = request.headers.get("x-csrf-token")
 
diff --git a/offline-backend-20260512/backend/app/gateway/proxy_path.py b/offline-backend-20260512/backend/app/gateway/proxy_path.py
new file mode 100644
index 00000000..22942978
--- /dev/null
+++ b/offline-backend-20260512/backend/app/gateway/proxy_path.py
@@ -0,0 +1,39 @@
+"""Resolve the application-relative request path behind a reverse proxy.
+
+A reverse proxy may forward requests under a path prefix, e.g.
+``/xxx/api/v1/auth/login/token``. FastAPI strips that prefix for **routing**
+when it is told about it via the ASGI ``root_path`` (uvicorn ``--root-path`` /
+``--proxy-headers``, or ``X-Forwarded-Prefix`` from the proxy) — which is why
+the route still matches and the request reaches a handler.
+
+Starlette middleware, however, runs *before* routing and sees the full,
+prefixed ``request.url.path``. Middlewares that match that raw path against
+fixed whitelists — the CSRF-exempt auth paths and the AuthMiddleware public
+paths — then mis-match, so login and ``/api/public/*`` endpoints get wrongly
+rejected (``CSRF token missing`` / ``401``) on a prefixed deployment.
+
+``app_relative_path`` returns the path with the proxy prefix removed so that
+whitelist matching is prefix-agnostic. It is a no-op when no prefix is present
+(direct deployment), and tolerates the prefix already being stripped from the
+path (it only strips when the path actually starts with the prefix).
+"""
+
+from fastapi import Request
+
+
+def app_relative_path(request: Request) -> str:
+    """Return ``request.url.path`` with any reverse-proxy prefix removed.
+
+    Prefix source order: ASGI ``root_path`` (set by the server when the proxy
+    forwards it), then the ``X-Forwarded-Prefix`` header (proxies that add a
+    prefix without informing the ASGI server). Returns ``"/"`` for an empty
+    result so downstream ``rstrip("/")`` / ``startswith`` checks stay sane.
+    """
+    path = request.url.path or "/"
+    prefix = (request.scope.get("root_path") or request.headers.get("x-forwarded-prefix") or "").rstrip("/")
+    if prefix and path.startswith(prefix):
+        stripped = path[len(prefix):]
+        if not stripped:
+            return "/"
+        return stripped if stripped.startswith("/") else "/" + stripped
+    return path
diff --git a/offline-backend-20260512/backend/app/gateway/roundtable_run_policy.py b/offline-backend-20260512/backend/app/gateway/roundtable_run_policy.py
index 784e0fb8..9526e80d 100644
--- a/offline-backend-20260512/backend/app/gateway/roundtable_run_policy.py
+++ b/offline-backend-20260512/backend/app/gateway/roundtable_run_policy.py
@@ -19,24 +19,30 @@
     并配合 ``SkillStopMiddleware`` 在 ``agent_orchestration`` 调用后停图，便于网关从
     AIMessage.tool_calls 解析派活列表。
   - ``seat``    —— 子智能体交付：开 thinking + medium reasoning；**可写文件**
-    （``write_file`` / ``str_replace`` 产出 md 等成品文档），但禁派活 / 澄清 /
-    展示文件 / 看图 / 联网搜索 / **``bash``**。禁 ``bash`` 的原因：圆桌席位是
-    「文档产出者」，弱模型爱写 ``.py`` 脚本再跑出产物（乱且抓不到预览），与
-    ``report`` 角色禁 ``bash`` 同理；让它**直接 write_file 写成品文档**。
+    （``write_file`` / ``str_replace`` 产出 md 等成品文档）+ **可跑 ``bash``**
+    （2026-06 放开:业务需要跑知识库检索 / Python 辅助分析）。禁派活 / 澄清 /
+    展示文件 / 看图 / 联网搜索。``report`` 通过 ``[*_SEAT_EXCLUDED, ...]`` 继承本角色,
+    所以 Step3 报告也跟着拿到 bash;只有 ``leader`` 和 ``seat_parallel`` 仍各自显式禁。
+    历史警示（保留）：弱模型用 ``bash`` 跑 ``python xxx.py > out.md`` 生成产物会
+    **绕过前端虚拟预览**（预览只拦截 ``write_file.args.content``）→ 沙箱里有文件但
+    Step2 右侧预览空白。席位 SOUL 必须明确「bash 只用于辅助查询拿数据，**最终交付
+    必须用 write_file 写 .md 落盘**，不要让脚本生成最终产物」。
   - ``seat_parallel`` —— **DAG 快速(fast)模式的并行席位（方案 A，2026-06）**：**禁写文件**
-    （``write_file`` / ``str_replace``，产物走正文）+ 禁 ``bash`` + 禁「打断 / 越权」类，
+    （``write_file`` / ``str_replace``，产物走正文）+ **禁 ``bash``** + 禁「打断 / 越权」类，
     **放开 ``web_search`` 与技能**（搜索不碰 sandbox；技能靠 ``read_file`` SKILL.md）——
     否则并行席位几乎调不动工具、产生不了步骤（步骤条不显示）。
+    并行席位同时跑 bash 会在共享 sandbox 里抢路径 / 占进程数；且 fast 模式整体不
+    写文件，bash 跑出来的产物既不能预览也没意义。
     「写文件产出 md」归 **沙箱(sandbox)模式**（走 ``seat`` policy，单列 + 沙箱跟随预览）；
     fast 模式快、双列、产物走正文 —— 用户明确要求 fast 不生成文件。详见
     ``docs/roundtable-dag-orchestration.md`` §4 / §12.1 / §12.8 / §12.10。
     与 ``seat`` 的差异：``seat`` 禁 ``web_search``（旧「圆桌一律禁搜索」），
-    ``seat_parallel`` **放开搜索**（本期诉求）。
-  - ``report``  —— Step3 报告绘制：在 ``seat``（已禁 ``bash``）基础上**额外禁
-    ``str_replace``**：
-      * ``bash`` 已在 ``seat`` 禁 → 杜绝写 Python 脚本再跑出 HTML（脚本产物落在
-        outputs，但前端虚拟预览只抓 ``write_file`` 的 ``args.content``，抓不到脚本
-        产物 → 预览停在半截 ``write_file``，正是「没写完就去生成 py 文件」的现象）；
+    ``seat_parallel`` **放开搜索**（本期诉求）；``seat`` 已放开 ``bash``，本角色仍禁。
+  - ``report``  —— Step3 报告绘制：在 ``seat`` 基础上**额外禁 ``str_replace``**：
+      * 继承 ``seat`` 的 bash 放开（2026-06）—— Step3 也可跑 bash 做辅助查询,同
+        ``seat`` 警示:**结果必须 write_file 落盘**,否则前端虚拟预览会空白
+        （预览只抓 ``write_file.args.content``,抓不到脚本产物 → 预览停在半截
+        ``write_file``,正是「没写完就去生成 py 文件」的现象）。
       * 禁 ``str_replace`` → 强制返工用整文件 ``write_file`` 重写
         （``str_replace`` 没有 ``content`` 字段，会让前端虚拟预览读到 undefined
         而清空沙箱）。
@@ -72,16 +78,21 @@ _LEADER_EXCLUDED: list[str] = [
     "hindsight_retain",
     "read_peer_delivery",  # 总控靠 _collect_delivery_status 直读各席位,不需要这个席位侧工具
 ]
-# seat：席位**可以写文件**(write_file / str_replace)产出 md 等成品文档,但**禁 bash** ——
-# 圆桌席位是「文档产出者」,不该跑 shell/python 脚本(弱模型爱写 .py 脚本再跑生成产物,既乱又
-# 抓不到产物预览,与 report 角色禁 bash 同理)。禁 web_search(圆桌串行一律禁搜索,旧决策)。
+# seat：席位**可以写文件**(write_file / str_replace)产出 md 等成品文档,**bash 放开**
+# (2026-06 决策,业务需要 bash 跑知识库检索 / Python 辅助分析)。禁派活 / 澄清 /
+# 展示文件 / 看图 / 联网搜索。``report`` 通过 ``[*_SEAT_EXCLUDED, ...]`` 继承本角色,
+# 所以 Step3 报告跟着拿到 bash;只有 leader / seat_parallel 仍各自显式禁。
+#
+# **历史警示（保留）**：弱模型用 bash 跑 ``python xxx.py > out.md`` 生成最终产物会
+# 绕过前端虚拟预览(只拦 write_file.args.content) → 沙箱里有文件但 Step2 右侧预览
+# 空白。必须靠席位 SOUL 强约束「bash 只用于辅助查询拿数据,最终交付必须用 write_file
+# 写 .md 落盘」。
 _SEAT_EXCLUDED: list[str] = [
     "web_search",
     "ask_clarification",
     "present_files",
     "view_image",
     "agent_orchestration",
-    "bash",
 ]
 # 并行席位 = **快速(fast)模式**(双列):**禁写文件**(产物走正文)+ 禁跑命令 +「打断/越权」类。
 # **禁 web_search** —— 离线内网部署无外网,席位检索一律走「技能(skill)」(靠 read_file 读
diff --git a/offline-backend-20260512/backend/app/gateway/routers/admin_users.py b/offline-backend-20260512/backend/app/gateway/routers/admin_users.py
index 753471ea..ead24625 100644
--- a/offline-backend-20260512/backend/app/gateway/routers/admin_users.py
+++ b/offline-backend-20260512/backend/app/gateway/routers/admin_users.py
@@ -19,8 +19,11 @@ import logging
 import os
 import re
 from collections.abc import AsyncIterator
+from contextvars import ContextVar
 from difflib import SequenceMatcher
 from hashlib import sha256
+from time import perf_counter
+from typing import Any
 
 from datetime import UTC, datetime, timedelta, time as datetime_time
 
@@ -56,6 +59,7 @@ from deerflow.persistence.user.model import UserRow
 
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/api/admin/users", tags=["admin-users"])
+self_router = APIRouter(prefix="/api/users/me", tags=["user-qa"])
 
 _LEADERBOARD_MAX_CONCURRENT = max(
     1,
@@ -99,6 +103,119 @@ _LEADERBOARD_QUEUE_ON_REQUEST_ENABLED = os.getenv(
     "off",
 }
 _leaderboard_semaphore = asyncio.Semaphore(_LEADERBOARD_MAX_CONCURRENT)
+_LEADERBOARD_TRACE_CONTEXT: ContextVar[dict[str, object] | None] = ContextVar(
+    "leaderboard_trace_context",
+    default=None,
+)
+
+
+def _leaderboard_log_context(**context: object) -> dict[str, object] | None:
+    current = _LEADERBOARD_TRACE_CONTEXT.get()
+    merged: dict[str, object] = dict(current or {})
+    for key, value in context.items():
+        if value is None or value == "":
+            continue
+        merged[key] = value
+    return merged or None
+
+
+def _leaderboard_sql_for_log(stmt) -> str:
+    try:
+        return str(stmt.compile(compile_kwargs={"literal_binds": True}))
+    except Exception:
+        return str(stmt)
+
+
+async def _execute_leaderboard_query(session, step: str, stmt, **context: object):
+    log_context = _leaderboard_log_context(**context)
+    if not log_context:
+        return await session.execute(stmt)
+
+    started_at = datetime.now(BEIJING_TZ).isoformat()
+    sql = _leaderboard_sql_for_log(stmt)
+    logger.info(
+        "Leaderboard snapshot DB query start: step=%s stat_date=%s job=%s settings_hash=%s started_at=%s sql=%s",
+        step,
+        log_context.get("stat_date") or log_context.get("stat_dates") or "",
+        log_context.get("job_key") or "",
+        log_context.get("settings_hash") or "",
+        started_at,
+        sql,
+    )
+    start = perf_counter()
+    try:
+        result = await session.execute(stmt)
+    except Exception:
+        elapsed_ms = (perf_counter() - start) * 1000
+        logger.exception(
+            "Leaderboard snapshot DB query failed: step=%s stat_date=%s job=%s settings_hash=%s elapsed_ms=%.2f",
+            step,
+            log_context.get("stat_date") or log_context.get("stat_dates") or "",
+            log_context.get("job_key") or "",
+            log_context.get("settings_hash") or "",
+            elapsed_ms,
+        )
+        raise
+
+    elapsed_ms = (perf_counter() - start) * 1000
+    logger.info(
+        "Leaderboard snapshot DB query done: step=%s stat_date=%s job=%s settings_hash=%s finished_at=%s elapsed_ms=%.2f",
+        step,
+        log_context.get("stat_date") or log_context.get("stat_dates") or "",
+        log_context.get("job_key") or "",
+        log_context.get("settings_hash") or "",
+        datetime.now(BEIJING_TZ).isoformat(),
+        elapsed_ms,
+    )
+    return result
+
+
+async def _time_leaderboard_db_operation(
+    step: str,
+    operation,
+    *,
+    sql: str = "",
+    **context: object,
+):
+    log_context = _leaderboard_log_context(**context)
+    if not log_context:
+        return await operation()
+
+    logger.info(
+        "Leaderboard snapshot DB query start: step=%s stat_date=%s job=%s settings_hash=%s started_at=%s sql=%s",
+        step,
+        log_context.get("stat_date") or log_context.get("stat_dates") or "",
+        log_context.get("job_key") or "",
+        log_context.get("settings_hash") or "",
+        datetime.now(BEIJING_TZ).isoformat(),
+        sql,
+    )
+    start = perf_counter()
+    try:
+        result = await operation()
+    except Exception:
+        elapsed_ms = (perf_counter() - start) * 1000
+        logger.exception(
+            "Leaderboard snapshot DB query failed: step=%s stat_date=%s job=%s settings_hash=%s elapsed_ms=%.2f",
+            step,
+            log_context.get("stat_date") or log_context.get("stat_dates") or "",
+            log_context.get("job_key") or "",
+            log_context.get("settings_hash") or "",
+            elapsed_ms,
+        )
+        raise
+
+    elapsed_ms = (perf_counter() - start) * 1000
+    logger.info(
+        "Leaderboard snapshot DB query done: step=%s stat_date=%s job=%s settings_hash=%s finished_at=%s elapsed_ms=%.2f",
+        step,
+        log_context.get("stat_date") or log_context.get("stat_dates") or "",
+        log_context.get("job_key") or "",
+        log_context.get("settings_hash") or "",
+        datetime.now(BEIJING_TZ).isoformat(),
+        elapsed_ms,
+    )
+    return result
 
 
 async def _require_admin(request: Request) -> None:
@@ -285,6 +402,13 @@ def _parse_datetime(value: str | None, fallback: datetime) -> datetime:
         raise HTTPException(status_code=400, detail=f"Invalid datetime: {value}") from exc
 
 
+def _parse_optional_datetime(value: str | None) -> datetime | None:
+    if not value:
+        return None
+    parsed = _parse_datetime(value, _now())
+    return parsed if parsed.tzinfo is not None else parsed.replace(tzinfo=BEIJING_TZ)
+
+
 def _resolve_range(days: int, since: str | None, until: str | None) -> tuple[datetime, datetime, int]:
     end = _parse_datetime(until, _now())
     start = _parse_datetime(since, end - timedelta(days=max(1, min(days, 365))))
@@ -325,7 +449,7 @@ def _bounds_for_stat_date(stat_date: str) -> tuple[datetime, datetime]:
 
 async def _try_set_session_value(session, sql: str) -> None:
     try:
-        await session.execute(text(sql))
+        await _execute_leaderboard_query(session, "session_setting", text(sql))
     except Exception:
         logger.debug("Failed to apply analytics session setting: %s", sql, exc_info=True)
         try:
@@ -334,13 +458,36 @@ async def _try_set_session_value(session, sql: str) -> None:
             logger.debug("Failed to rollback after analytics session setting failure", exc_info=True)
 
 
+def _is_mariadb(dialect) -> bool:
+    """SQLAlchemy reports ``dialect.name == 'mysql'`` for MariaDB too."""
+    if getattr(dialect, "_is_mariadb", False) or getattr(dialect, "is_mariadb", False):
+        return True
+    version_info = getattr(dialect, "server_version_info", None) or ()
+    return any("mariadb" in str(part).lower() for part in version_info)
+
+
 async def _set_analytics_read_timeout(session) -> None:
+    """Best-effort per-statement read timeout for the analytics queries.
+
+    The right knob differs by server, and some servers have none at all:
+      - MySQL >= 5.7.4: ``max_execution_time`` (milliseconds)
+      - MariaDB:        ``max_statement_time`` (seconds)
+      - MySQL <= 5.6:   no per-statement timeout variable — skip it entirely
+                        (5.6 raises "Unknown system variable" otherwise)
+      - PostgreSQL:     ``statement_timeout`` (milliseconds)
+    """
     conn = await session.connection()
-    dialect = conn.dialect.name
-    if dialect == "mysql":
-        await _try_set_session_value(session, f"SET SESSION max_execution_time = {_LEADERBOARD_QUERY_TIMEOUT_MS}")
+    dialect = conn.dialect
+    name = dialect.name
+    if name == "mysql":
+        if _is_mariadb(dialect):
+            # MariaDB: max_statement_time is in SECONDS (fractional ok).
+            await _try_set_session_value(session, f"SET SESSION max_statement_time = {_LEADERBOARD_QUERY_TIMEOUT_MS / 1000}")
+        elif (getattr(dialect, "server_version_info", None) or ()) >= (5, 7, 4):
+            await _try_set_session_value(session, f"SET SESSION max_execution_time = {_LEADERBOARD_QUERY_TIMEOUT_MS}")
+        # else: MySQL <= 5.6 has no statement-timeout variable — skip silently.
         await _try_set_session_value(session, f"SET SESSION innodb_lock_wait_timeout = {_LEADERBOARD_LOCK_WAIT_SECONDS}")
-    elif dialect == "postgresql":
+    elif name == "postgresql":
         await _try_set_session_value(session, f"SET LOCAL statement_timeout = {_LEADERBOARD_QUERY_TIMEOUT_MS}")
 
 
@@ -661,11 +808,15 @@ async def _query_user_leaderboard(
     if user_id:
         stmt = stmt.where(UserRow.id == user_id)
     stmt = _apply_user_scope(stmt, UserRow.id, exclude_user_ids=exclude_user_ids, include_admins=include_admins)
+    # 排行榜只统计真正产生过问答的用户；从未问答的账号（仅注册、零活跃）不计入榜单与人数。
+    # 个人分析（指定 user_id）不受此限制，仍可查看任意单个用户。
+    if user_id is None:
+        stmt = stmt.where(func.coalesce(run_agg.c.qa_count, 0) > 0)
     stmt = stmt.order_by(
         desc(func.coalesce(run_agg.c.run_count, 0) + func.coalesce(tool_agg.c.tool_call_count, 0)),
         desc(func.coalesce(run_agg.c.total_tokens, 0)),
     )
-    rows = (await session.execute(stmt)).all()
+    rows = (await _execute_leaderboard_query(session, "users", stmt)).all()
     return [
         AdminLeaderboardUser(
             user_id=r[0],
@@ -725,7 +876,7 @@ async def _query_call_rankings(
         include_admins=include_admins,
         include_scheduled=include_scheduled,
     )
-    rows = (await session.execute(stmt)).all()
+    rows = (await _execute_leaderboard_query(session, f"{field}_rankings", stmt)).all()
     return [
         AdminLeaderboardSkill(
             name=r[0] or "",
@@ -791,7 +942,7 @@ async def _query_run_dimensions(
         include_failed=include_failed,
         include_scheduled=include_scheduled,
     )
-    rows = (await session.execute(stmt)).all()
+    rows = (await _execute_leaderboard_query(session, f"{field}_dimensions", stmt)).all()
     return [
         AdminLeaderboardDimension(
             name=r[0] or "",
@@ -848,7 +999,7 @@ async def _query_model_rankings(
         stmt = stmt.where(LlmCallMetricRow.status != "error")
     if not include_scheduled:
         stmt = stmt.where(or_(LlmCallMetricRow.run_id.is_(None), LlmCallMetricRow.run_id.not_in(_scheduled_run_ids_stmt())))
-    rows = (await session.execute(stmt)).all()
+    rows = (await _execute_leaderboard_query(session, "model_rankings", stmt)).all()
     return [
         AdminLeaderboardDimension(
             name=r[0] or "",
@@ -895,7 +1046,7 @@ async def _query_recent_questions(
         include_failed=include_failed,
         include_scheduled=include_scheduled,
     )
-    rows = (await session.execute(stmt)).all()
+    rows = (await _execute_leaderboard_query(session, "recent_questions", stmt)).all()
     questions: list[AdminLeaderboardQuestion] = []
     for r in rows:
         text = _clean_question_text(r[0]) if cleanup_system_questions else str(r[0] or "").strip()
@@ -947,7 +1098,7 @@ async def _query_frequent_questions(
         include_failed=include_failed,
         include_scheduled=include_scheduled,
     )
-    rows = (await session.execute(stmt)).all()
+    rows = (await _execute_leaderboard_query(session, "frequent_questions", stmt)).all()
     groups: list[dict] = []
     for r in rows:
         text = _clean_question_text(r[0]) if cleanup_system_questions else str(r[0] or "").strip()
@@ -1022,7 +1173,7 @@ async def _query_trends(
         include_failed=include_failed,
         include_scheduled=include_scheduled,
     )
-    rows = (await session.execute(stmt)).all()
+    rows = (await _execute_leaderboard_query(session, "trends", stmt)).all()
     return [
         AdminLeaderboardTrendPoint(
             date=str(r[0]),
@@ -1071,8 +1222,8 @@ async def _query_overview(
 
     total_users_stmt = select(func.count(UserRow.id))
     total_users_stmt = _apply_user_scope(total_users_stmt, UserRow.id, exclude_user_ids=exclude_user_ids, include_admins=include_admins)
-    total_users = 1 if user_id else (await session.execute(total_users_stmt)).scalar_one()
-    run_row = (await session.execute(
+    total_users = 1 if user_id else (await _execute_leaderboard_query(session, "overview.total_users", total_users_stmt)).scalar_one()
+    run_summary_stmt = (
         select(
             func.count(RunRow.run_id),
             _question_count_expr(),
@@ -1080,16 +1231,19 @@ async def _query_overview(
             func.count(func.distinct(RunRow.user_id)),
             func.sum(case((RunRow.status == "error", 1), else_=0)),
         ).where(*run_where)
-    )).one()
-    thread_count = (await session.execute(select(func.count(ThreadMetaRow.thread_id)).where(*thread_where))).scalar_one()
-    tool_row = (await session.execute(
+    )
+    run_row = (await _execute_leaderboard_query(session, "overview.run_summary", run_summary_stmt)).one()
+    thread_count_stmt = select(func.count(ThreadMetaRow.thread_id)).where(*thread_where)
+    thread_count = (await _execute_leaderboard_query(session, "overview.thread_count", thread_count_stmt)).scalar_one()
+    tool_summary_stmt = (
         select(
             func.count(ToolCallMetricRow.id),
             func.sum(case((func.nullif(ToolCallMetricRow.skill_name, "").is_not(None), 1), else_=0)),
         )
         .outerjoin(RunRow, RunRow.run_id == ToolCallMetricRow.run_id)
         .where(*tool_where)
-    )).one()
+    )
+    tool_row = (await _execute_leaderboard_query(session, "overview.tool_summary", tool_summary_stmt)).one()
 
     return AdminLeaderboardOverview(
         total_users=int(total_users or 0),
@@ -1579,13 +1733,12 @@ async def _load_daily_snapshot_rows(
     if not stat_dates:
         return {}
     async with session_factory() as session:
+        stmt = select(AdminLeaderboardDailyStatRow).where(
+            AdminLeaderboardDailyStatRow.stat_date.in_(stat_dates),
+            AdminLeaderboardDailyStatRow.settings_hash == settings_hash,
+        )
         rows = (
-            await session.execute(
-                select(AdminLeaderboardDailyStatRow).where(
-                    AdminLeaderboardDailyStatRow.stat_date.in_(stat_dates),
-                    AdminLeaderboardDailyStatRow.settings_hash == settings_hash,
-                )
-            )
+            await _execute_leaderboard_query(session, "snapshot_rows.load", stmt)
         ).scalars().all()
     return {row.stat_date: row for row in rows}
 
@@ -1603,9 +1756,15 @@ async def _store_daily_snapshot(
 ) -> None:
     async with session_factory() as session:
         now = datetime.now(UTC)
-        row = await session.get(
-            AdminLeaderboardDailyStatRow,
-            {"stat_date": stat_date, "settings_hash": settings_hash},
+        row = await _time_leaderboard_db_operation(
+            "snapshot.store.get",
+            lambda: session.get(
+                AdminLeaderboardDailyStatRow,
+                {"stat_date": stat_date, "settings_hash": settings_hash},
+            ),
+            sql="SELECT admin_leaderboard_daily_stats by primary key",
+            stat_date=stat_date,
+            settings_hash=settings_hash,
         )
         if row is None:
             row = AdminLeaderboardDailyStatRow(
@@ -1630,7 +1789,13 @@ async def _store_daily_snapshot(
             if generated_at is not None:
                 row.generated_at = generated_at
             row.updated_at = now
-        await session.commit()
+        await _time_leaderboard_db_operation(
+            "snapshot.store.commit",
+            lambda: session.commit(),
+            sql="COMMIT",
+            stat_date=stat_date,
+            settings_hash=settings_hash,
+        )
 
 
 async def _queue_daily_leaderboard_snapshots(
@@ -1646,12 +1811,17 @@ async def _queue_daily_leaderboard_snapshots(
         return queued
     async with session_factory() as session:
         now = datetime.now(UTC)
+        stmt = select(AdminLeaderboardDailyStatRow).where(
+            AdminLeaderboardDailyStatRow.stat_date.in_(stat_dates),
+            AdminLeaderboardDailyStatRow.settings_hash == settings_hash,
+        )
         rows = (
-            await session.execute(
-                select(AdminLeaderboardDailyStatRow).where(
-                    AdminLeaderboardDailyStatRow.stat_date.in_(stat_dates),
-                    AdminLeaderboardDailyStatRow.settings_hash == settings_hash,
-                )
+            await _execute_leaderboard_query(
+                session,
+                "snapshot_queue.load_existing",
+                stmt,
+                stat_dates=stat_dates,
+                settings_hash=settings_hash,
             )
         ).scalars().all()
         rows_by_date = {row.stat_date: row for row in rows}
@@ -1680,7 +1850,13 @@ async def _queue_daily_leaderboard_snapshots(
             row.updated_at = now
             queued.append(stat_date)
         if queued:
-            await session.commit()
+            await _time_leaderboard_db_operation(
+                "snapshot_queue.commit",
+                lambda: session.commit(),
+                sql="COMMIT",
+                stat_dates=queued,
+                settings_hash=settings_hash,
+            )
     return queued
 
 
@@ -1722,7 +1898,22 @@ async def _refresh_daily_leaderboard_snapshot(
     include_failed: bool,
 ) -> None:
     acquired = False
+    trace_token = _LEADERBOARD_TRACE_CONTEXT.set(
+        {
+            "job_key": job_key,
+            "stat_date": stat_date,
+            "settings_hash": settings_hash,
+        }
+    )
+    snapshot_start = perf_counter()
     try:
+        logger.info(
+            "Leaderboard snapshot build start: job=%s stat_date=%s settings_hash=%s started_at=%s",
+            job_key,
+            stat_date,
+            settings_hash,
+            datetime.now(BEIJING_TZ).isoformat(),
+        )
         if _LEADERBOARD_START_DELAY_SECONDS > 0:
             await asyncio.sleep(_LEADERBOARD_START_DELAY_SECONDS)
         await _store_daily_snapshot(
@@ -1758,6 +1949,14 @@ async def _refresh_daily_leaderboard_snapshot(
             error=None,
             generated_at=generated_at,
         )
+        logger.info(
+            "Leaderboard snapshot build done: job=%s stat_date=%s settings_hash=%s finished_at=%s elapsed_ms=%.2f",
+            job_key,
+            stat_date,
+            settings_hash,
+            datetime.now(BEIJING_TZ).isoformat(),
+            (perf_counter() - snapshot_start) * 1000,
+        )
     except asyncio.TimeoutError:
         logger.warning("Daily leaderboard snapshot timed out: %s", job_key)
         await _store_daily_snapshot(
@@ -1781,6 +1980,7 @@ async def _refresh_daily_leaderboard_snapshot(
     finally:
         if acquired:
             _leaderboard_semaphore.release()
+        _LEADERBOARD_TRACE_CONTEXT.reset(trace_token)
 
 
 async def _load_or_schedule_daily_leaderboard(
@@ -1978,6 +2178,72 @@ async def queue_leaderboard_snapshot_backfill(
     )
 
 
+@router.post("/leaderboard/refresh-today", response_model=AdminLeaderboardResponse)
+async def refresh_today_leaderboard(
+    request: Request,
+    days: int = Query(default=30, ge=1, le=365),
+    since: str | None = Query(default=None, description="Inclusive range start, ISO datetime"),
+    until: str | None = Query(default=None, description="Inclusive range end, ISO datetime"),
+    exclude_user_ids: list[str] | None = Query(default=None, description="User ids excluded from this leaderboard aggregation"),
+    include_scheduled: bool | None = Query(default=None, description="Include runs created by scheduled tasks"),
+    include_admins: bool | None = Query(default=None, description="Include admin accounts in leaderboard aggregation"),
+    include_failed: bool | None = Query(default=None, description="Include failed runs and LLM calls"),
+    limit: int = Query(default=20, ge=5, le=100),
+) -> AdminLeaderboardResponse:
+    """Force a synchronous rebuild of *today's* snapshot, then return the range.
+
+    Today's snapshot otherwise refreshes only every ``_LEADERBOARD_TODAY_TTL_SECONDS``
+    (~5 min) via the background scheduler. This endpoint lets an admin pull the
+    latest real-time records into the stats on demand: it rebuilds today's daily
+    snapshot immediately (bounded by the same semaphore/timeout the scheduler uses)
+    and then returns the merged leaderboard for the requested range.
+    """
+    await _require_admin(request)
+    session_factory = get_session_factory()
+    if session_factory is None:
+        raise HTTPException(status_code=503, detail="Analytics requires database persistence")
+
+    settings = load_system_settings().leaderboard
+    (
+        excluded,
+        resolved_include_scheduled,
+        resolved_include_admins,
+        resolved_include_failed,
+        settings_hash,
+    ) = _resolve_leaderboard_snapshot_scope(
+        settings,
+        exclude_user_ids=exclude_user_ids,
+        include_scheduled=include_scheduled,
+        include_admins=include_admins,
+        include_failed=include_failed,
+    )
+    today = _today_stat_date()
+    await _refresh_daily_leaderboard_snapshot(
+        _daily_job_key(today, settings_hash),
+        session_factory=session_factory,
+        settings=settings,
+        stat_date=today,
+        settings_hash=settings_hash,
+        excluded=excluded,
+        include_scheduled=resolved_include_scheduled,
+        include_admins=resolved_include_admins,
+        include_failed=resolved_include_failed,
+    )
+
+    since_dt, until_dt, _range_days = _resolve_range(days, since, until)
+    return await _load_or_schedule_daily_leaderboard(
+        session_factory,
+        settings,
+        since_dt,
+        until_dt,
+        limit=limit,
+        exclude_user_ids=exclude_user_ids,
+        include_scheduled=include_scheduled,
+        include_admins=include_admins,
+        include_failed=include_failed,
+    )
+
+
 async def _build_leaderboard_report_prompt(
     session_factory,
     settings,
@@ -2248,22 +2514,182 @@ class AdminUserQaPageResponse(BaseModel):
     items: list[AdminUserQaItem] = Field(default_factory=list)
 
 
-@router.get("/{user_id}/qa", response_model=AdminUserQaPageResponse)
-async def list_user_qa(
-    user_id: str,
-    request: Request,
-    page: int = Query(default=1, ge=1),
-    page_size: int = Query(default=20, ge=1, le=100),
-    q: str | None = Query(default=None, description="Search question, answer, run id, or thread id"),
-    since: str | None = Query(default=None, description="Inclusive range start, ISO datetime"),
-    until: str | None = Query(default=None, description="Inclusive range end, ISO datetime"),
-) -> AdminUserQaPageResponse:
-    """Return one user's Q&A runs from lightweight run summary fields."""
-    await _require_admin(request)
-    session_factory = get_session_factory()
-    if session_factory is None:
-        raise HTTPException(status_code=503, detail="Q&A audit requires database persistence")
+def _qa_sort_datetime(value: str | None) -> datetime:
+    if not value:
+        return datetime.min.replace(tzinfo=BEIJING_TZ)
+    text_value = str(value).strip()
+    if text_value.endswith("Z"):
+        text_value = text_value[:-1] + "+00:00"
+    try:
+        parsed = datetime.fromisoformat(text_value)
+    except ValueError:
+        return datetime.min.replace(tzinfo=BEIJING_TZ)
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=BEIJING_TZ)
+    return parsed.astimezone(BEIJING_TZ)
 
+
+def _qa_dedupe_key(item: AdminUserQaItem) -> tuple[str, str, str]:
+    question_key = _question_similarity_key(item.question)[:160]
+    answer_key = _question_similarity_key(item.answer)[:160]
+    return (item.thread_id, question_key, answer_key)
+
+
+def _message_value(message: Any, key: str, default: Any = None) -> Any:
+    if isinstance(message, dict):
+        return message.get(key, default)
+    return getattr(message, key, default)
+
+
+def _qa_message_type(message: Any) -> str:
+    value = _message_value(message, "type") or _message_value(message, "role") or ""
+    if value == "user":
+        return "human"
+    if value == "assistant":
+        return "ai"
+    return str(value)
+
+
+def _qa_message_id(message: Any, fallback: str) -> str:
+    return str(_message_value(message, "id") or fallback)
+
+
+def _qa_message_text(message: Any) -> str:
+    return _message_content_to_text(_message_value(message, "content")).strip()
+
+
+async def _read_thread_checkpoint_messages(checkpointer, thread_id: str) -> list[dict]:
+    config = {"configurable": {"thread_id": thread_id, "checkpoint_ns": ""}}
+    try:
+        checkpoint_tuple = await checkpointer.aget_tuple(config)
+    except Exception:
+        logger.warning("Failed to read checkpoint while listing Q&A: thread=%s", thread_id, exc_info=True)
+        return []
+    if checkpoint_tuple is None:
+        return []
+    checkpoint = getattr(checkpoint_tuple, "checkpoint", {}) or {}
+    channel_values = checkpoint.get("channel_values", {}) if isinstance(checkpoint, dict) else {}
+    values = serialize_channel_values(channel_values)
+    messages = values.get("messages", [])
+    return messages if isinstance(messages, list) else []
+
+
+def _qa_items_from_checkpoint_messages(
+    *,
+    user_id: str,
+    thread_id: str,
+    thread_title: str,
+    assistant_id: str,
+    thread_time: str,
+    messages: list[dict],
+) -> list[AdminUserQaItem]:
+    items: list[AdminUserQaItem] = []
+    current_question = ""
+    current_answer = ""
+    current_id = ""
+    current_index = 0
+
+    def flush() -> None:
+        nonlocal current_question, current_answer, current_id, current_index
+        question = _clean_question_text(current_question)
+        if not _is_displayable_question(question):
+            current_question = ""
+            current_answer = ""
+            current_id = ""
+            return
+        items.append(
+            AdminUserQaItem(
+                run_id=current_id or f"{thread_id}:checkpoint:{current_index}",
+                thread_id=thread_id,
+                thread_title=thread_title,
+                assistant_id=assistant_id,
+                status="checkpoint",
+                question=question[:2000],
+                answer=current_answer.strip()[:6000],
+                created_at=thread_time,
+                updated_at=thread_time,
+            )
+        )
+        current_question = ""
+        current_answer = ""
+        current_id = ""
+
+    for index, message in enumerate(messages):
+        msg_type = _qa_message_type(message)
+        if msg_type == "human":
+            if current_question:
+                flush()
+            current_question = _qa_message_text(message)
+            current_answer = ""
+            current_id = _qa_message_id(message, f"{thread_id}:checkpoint:{index}")
+            current_index = index
+            continue
+        if msg_type == "ai" and current_question:
+            text = _qa_message_text(message)
+            if text:
+                current_answer = text
+
+    if current_question:
+        flush()
+
+    return items
+
+
+async def _list_thread_checkpoint_qa_items(
+    *,
+    request: Request,
+    user_id: str,
+) -> list[AdminUserQaItem]:
+    repo = get_thread_store(request)
+    checkpointer = get_checkpointer(request)
+    items: list[AdminUserQaItem] = []
+    offset = 0
+    page_size = 200
+    while True:
+        rows = await repo.search(limit=page_size, offset=offset, user_id=user_id)
+        if not rows:
+            break
+        for row in rows:
+            thread_id = str(row.get("thread_id") or "")
+            if not thread_id:
+                continue
+            messages = await _read_thread_checkpoint_messages(checkpointer, thread_id)
+            if not messages:
+                continue
+            metadata = row.get("metadata") if isinstance(row.get("metadata"), dict) else {}
+            context = row.get("context") if isinstance(row.get("context"), dict) else {}
+            assistant_id = str(
+                row.get("assistant_id")
+                or (context or {}).get("agent_id")
+                or (metadata or {}).get("agent_id")
+                or (context or {}).get("agent_name")
+                or (metadata or {}).get("agent_name")
+                or ""
+            )
+            thread_time = str(row.get("updated_at") or row.get("created_at") or "")
+            items.extend(
+                _qa_items_from_checkpoint_messages(
+                    user_id=user_id,
+                    thread_id=thread_id,
+                    thread_title=str(row.get("display_name") or ""),
+                    assistant_id=assistant_id,
+                    thread_time=thread_time,
+                    messages=messages,
+                )
+            )
+        if len(rows) < page_size:
+            break
+        offset += len(rows)
+    return items
+
+
+async def _list_run_summary_qa_items(
+    *,
+    session_factory,
+    user_id: str,
+    since: str | None,
+    until: str | None,
+) -> list[AdminUserQaItem]:
     filters = [
         RunRow.user_id == user_id,
         RunRow.first_human_message.is_not(None),
@@ -2272,26 +2698,9 @@ async def list_user_qa(
     if since or until:
         since_dt, until_dt, _range_days = _resolve_range(365, since, until)
         filters.append(_run_time_filter(since_dt, until_dt))
-    needle = (q or "").strip()
-    if needle:
-        like = f"%{needle}%"
-        filters.append(
-            or_(
-                RunRow.first_human_message.like(like),
-                RunRow.last_ai_message.like(like),
-                RunRow.run_id.like(like),
-                RunRow.thread_id.like(like),
-            )
-        )
 
-    offset = (page - 1) * page_size
     async with session_factory() as session:
         await _set_analytics_read_timeout(session)
-        total = (
-            await session.execute(
-                select(func.count(RunRow.run_id)).where(*filters)
-            )
-        ).scalar_one()
         rows = (
             await session.execute(
                 select(
@@ -2316,32 +2725,152 @@ async def list_user_qa(
                 )
                 .where(*filters)
                 .order_by(RunRow.created_at.desc(), RunRow.run_id.desc())
-                .limit(page_size)
-                .offset(offset)
             )
         ).all()
 
+    return [
+        AdminUserQaItem(
+            run_id=r[0] or "",
+            thread_id=r[1] or "",
+            thread_title=r[2] or "",
+            assistant_id=r[3] or "",
+            status=r[4] or "",
+            model_name=r[5] or "",
+            question=_clean_question_text(r[6])[:2000],
+            answer=str(r[7] or "").strip()[:6000],
+            total_tokens=int(r[8] or 0),
+            created_at=_iso(r[9]),
+            updated_at=_iso(r[10]),
+        )
+        for r in rows
+        if _is_displayable_question(r[6])
+    ]
+
+
+def _filter_qa_items(
+    items: list[AdminUserQaItem],
+    *,
+    q: str | None,
+    since: str | None,
+    until: str | None,
+) -> list[AdminUserQaItem]:
+    needle = (q or "").strip().lower()
+    since_dt = _parse_optional_datetime(since) if since else None
+    until_dt = _parse_optional_datetime(until) if until else None
+    filtered: list[AdminUserQaItem] = []
+    for item in items:
+        item_dt = _qa_sort_datetime(item.created_at or item.updated_at)
+        if since_dt and item_dt < since_dt:
+            continue
+        if until_dt and item_dt > until_dt:
+            continue
+        if needle:
+            haystack = "\n".join(
+                [
+                    item.question,
+                    item.answer,
+                    item.run_id,
+                    item.thread_id,
+                    item.thread_title,
+                    item.assistant_id,
+                ]
+            ).lower()
+            if needle not in haystack:
+                continue
+        filtered.append(item)
+    return filtered
+
+
+async def _list_user_qa_page(
+    *,
+    request: Request,
+    user_id: str,
+    page: int,
+    page_size: int,
+    q: str | None,
+    since: str | None,
+    until: str | None,
+    include_checkpoints: bool = True,
+) -> AdminUserQaPageResponse:
+    session_factory = get_session_factory()
+    if session_factory is None:
+        raise HTTPException(status_code=503, detail="Q&A audit requires database persistence")
+
+    items = await _list_run_summary_qa_items(
+        session_factory=session_factory,
+        user_id=user_id,
+        since=since,
+        until=until,
+    )
+    if include_checkpoints:
+        items.extend(await _list_thread_checkpoint_qa_items(request=request, user_id=user_id))
+
+    by_key: dict[tuple[str, str, str], AdminUserQaItem] = {}
+    for item in items:
+        key = _qa_dedupe_key(item)
+        existing = by_key.get(key)
+        if existing is None or (existing.status == "checkpoint" and item.status != "checkpoint"):
+            by_key[key] = item
+
+    filtered = _filter_qa_items(list(by_key.values()), q=q, since=since, until=until)
+    filtered.sort(
+        key=lambda item: (_qa_sort_datetime(item.created_at or item.updated_at), item.thread_id, item.run_id),
+        reverse=True,
+    )
+    offset = (page - 1) * page_size
     return AdminUserQaPageResponse(
         user_id=user_id,
         page=page,
         page_size=page_size,
-        total=int(total or 0),
-        items=[
-            AdminUserQaItem(
-                run_id=r[0] or "",
-                thread_id=r[1] or "",
-                thread_title=r[2] or "",
-                assistant_id=r[3] or "",
-                status=r[4] or "",
-                model_name=r[5] or "",
-                question=_clean_question_text(r[6])[:2000],
-                answer=str(r[7] or "").strip()[:6000],
-                total_tokens=int(r[8] or 0),
-                created_at=_iso(r[9]),
-                updated_at=_iso(r[10]),
-            )
-            for r in rows
-        ],
+        total=len(filtered),
+        items=filtered[offset : offset + page_size],
+    )
+
+
+@router.get("/{user_id}/qa", response_model=AdminUserQaPageResponse)
+async def list_user_qa(
+    user_id: str,
+    request: Request,
+    page: int = Query(default=1, ge=1),
+    page_size: int = Query(default=20, ge=1, le=100),
+    q: str | None = Query(default=None, description="Search question, answer, run id, or thread id"),
+    since: str | None = Query(default=None, description="Inclusive range start, ISO datetime"),
+    until: str | None = Query(default=None, description="Inclusive range end, ISO datetime"),
+) -> AdminUserQaPageResponse:
+    """Return one user's Q&A runs, including older checkpoint-only threads."""
+    await _require_admin(request)
+    return await _list_user_qa_page(
+        request=request,
+        user_id=user_id,
+        page=page,
+        page_size=page_size,
+        q=q,
+        since=since,
+        until=until,
+    )
+
+
+@self_router.get("/qa", response_model=AdminUserQaPageResponse)
+async def list_my_qa(
+    request: Request,
+    page: int = Query(default=1, ge=1),
+    page_size: int = Query(default=20, ge=1, le=100),
+    q: str | None = Query(default=None, description="Search question, answer, run id, or thread id"),
+    since: str | None = Query(default=None, description="Inclusive range start, ISO datetime"),
+    until: str | None = Query(default=None, description="Inclusive range end, ISO datetime"),
+) -> AdminUserQaPageResponse:
+    """Return the current user's own Q&A history."""
+    user = getattr(request.state, "user", None)
+    if user is None:
+        user = await get_current_user_from_request(request)
+    return await _list_user_qa_page(
+        request=request,
+        user_id=str(user.id),
+        page=page,
+        page_size=page_size,
+        q=q,
+        since=since,
+        until=until,
     )
 
 
diff --git a/offline-backend-20260512/backend/app/gateway/routers/agents.py b/offline-backend-20260512/backend/app/gateway/routers/agents.py
index a75df4c8..7848dc8c 100644
--- a/offline-backend-20260512/backend/app/gateway/routers/agents.py
+++ b/offline-backend-20260512/backend/app/gateway/routers/agents.py
@@ -15,7 +15,7 @@ from fastapi import APIRouter, Depends, HTTPException, Query, Request
 from pydantic import BaseModel, Field
 
 from app.gateway.auth.password import verify_password_async
-from app.gateway.deps import get_agent_store, get_config, get_tag_store
+from app.gateway.deps import get_agent_store, get_config, get_tag_store
 from deerflow.agents.lead_agent.prompt import refresh_skills_system_prompt_cache_async
 from deerflow.config.agents_api_config import get_agents_api_config
 from deerflow.config.agents_config import list_custom_agents, load_agent_config, load_agent_soul, validate_agent_id
@@ -39,6 +39,7 @@ class AgentResponse(BaseModel):
     name: str = Field(..., description="Display name. Chinese and duplicate names are allowed.")
     description: str = Field(default="", description="Agent description")
     user_id: str | None = Field(default=None, description="Owner user id. Null means built-in.")
+    owner_username: str | None = Field(default=None, description="Publisher username (email local part). Null for built-in agents.")
     published: bool = Field(default=False, description="Whether a user-created agent is public")
     is_private: bool = Field(default=False, description="Whether the agent lives in the password-gated private square instead of the public one")
     builtin: bool = Field(default=False, description="True when user_id is null")
@@ -62,15 +63,15 @@ class AgentResponse(BaseModel):
     is_favorite: bool = Field(
         default=False,
         description="Whether the requesting user has favorited (收藏) this agent.",
-    )
-
-    is_pinned: bool = Field(
-        default=False,
-        description="Whether the requesting user has pinned this agent.",
-    )
-
-
-class AgentsListResponse(BaseModel):
+    )
+
+    is_pinned: bool = Field(
+        default=False,
+        description="Whether the requesting user has pinned this agent.",
+    )
+
+
+class AgentsListResponse(BaseModel):
     """Response model for listing agents.
 
     ``total`` / ``page`` / ``page_size`` describe server-side pagination. When
@@ -115,7 +116,7 @@ class AgentUpdateRequest(BaseModel):
     tool_groups: list[str] | None = Field(default=None, description="Updated tool group whitelist (config.yaml)")
 
 
-class AgentSelectorResponse(BaseModel):
+class AgentSelectorResponse(BaseModel):
     """Response for the homepage agent selector dropdown.
 
     The list is fully curated by admins (``featured_order`` on each row).
@@ -125,10 +126,10 @@ class AgentSelectorResponse(BaseModel):
     agents: list[AgentResponse] = Field(
         default_factory=list,
         description="Admin-curated agents, sorted by featured_order ascending.",
-    )
-
-
-class AgentFeaturedRequest(BaseModel):
+    )
+
+
+class AgentFeaturedRequest(BaseModel):
     """Request body for setting/clearing an agent's homepage featured rank."""
 
     order: int | None = Field(
@@ -159,6 +160,41 @@ def _is_admin_user(request: Request) -> bool:
     return getattr(user, "system_role", None) == "admin"
 
 
+def _email_local_part(email: str | None) -> str | None:
+    """Return the username portion (before ``@``) of an email address."""
+    if not email:
+        return None
+    at = email.find("@")
+    return email[:at] if at > 0 else email
+
+
+async def _resolve_usernames(user_ids: set[str]) -> dict[str, str]:
+    """Batch-resolve owner user ids to friendly usernames (email local part).
+
+    One lookup per distinct id; tolerates missing accounts (deleted users) and
+    an uninitialised auth provider by simply omitting those ids from the map.
+    """
+    user_ids = {uid for uid in user_ids if uid}
+    if not user_ids:
+        return {}
+    try:
+        from app.gateway.deps import get_local_provider
+
+        provider = get_local_provider()
+    except Exception:
+        return {}
+    names: dict[str, str] = {}
+    for uid in user_ids:
+        try:
+            user = await provider.get_user(uid)
+        except Exception:
+            user = None
+        local = _email_local_part(getattr(user, "email", None)) if user is not None else None
+        if local:
+            names[uid] = local
+    return names
+
+
 def _validate_display_name(name: str) -> str:
     normalized = name.strip()
     if not normalized:
@@ -348,7 +384,7 @@ def _ensure_agent_dir_from_record(record: dict[str, Any]) -> None:
         logger.exception("Failed to self-heal agent dir for '%s'", agent_id)
 
 
-def _record_to_response(
+def _record_to_response(
     record: dict[str, Any],
     *,
     include_soul: bool = False,
@@ -390,21 +426,21 @@ def _record_to_response(
         tool_groups=extras["tool_groups"],
         skills=extras["skills"],
         featured_order=record.get("featured_order"),
-    )
-
-
-def _sort_agent_responses(responses: list[AgentResponse], sort: str) -> list[AgentResponse]:
-    reverse = sort not in {"time_asc", "updated_asc", "name_asc"}
-    if sort in {"name_asc", "name_desc"}:
-        ordered = sorted(responses, key=lambda r: (r.name or "").lower(), reverse=reverse)
-    elif sort in {"updated_desc", "updated_asc"}:
-        ordered = sorted(responses, key=lambda r: str(r.updated_at or ""), reverse=reverse)
-    else:
-        ordered = sorted(responses, key=lambda r: str(r.created_at or ""), reverse=reverse)
-    return sorted(ordered, key=lambda r: 0 if r.is_pinned else 1)
-
-
-async def _record_to_response_async(
+    )
+
+
+def _sort_agent_responses(responses: list[AgentResponse], sort: str) -> list[AgentResponse]:
+    reverse = sort not in {"time_asc", "updated_asc", "name_asc"}
+    if sort in {"name_asc", "name_desc"}:
+        ordered = sorted(responses, key=lambda r: (r.name or "").lower(), reverse=reverse)
+    elif sort in {"updated_desc", "updated_asc"}:
+        ordered = sorted(responses, key=lambda r: str(r.updated_at or ""), reverse=reverse)
+    else:
+        ordered = sorted(responses, key=lambda r: str(r.created_at or ""), reverse=reverse)
+    return sorted(ordered, key=lambda r: 0 if r.is_pinned else 1)
+
+
+async def _record_to_response_async(
     record: dict[str, Any],
     *,
     include_soul: bool = False,
@@ -478,20 +514,23 @@ async def _build_list_responses(
         _record_to_response(a, include_soul=False, include_extras=False) for a in records
     ]
     ids = [r.id for r in responses]
-    extras = await store.get_extras_for(ids)
-    assignments = await tag_store.list_assignments("agent", ids)
-    favorite_ids = await store.list_favorite_ids(user_id)
-    pin_ids = await store.list_pin_ids(user_id)
-    for resp in responses:
+    extras = await store.get_extras_for(ids)
+    assignments = await tag_store.list_assignments("agent", ids)
+    favorite_ids = await store.list_favorite_ids(user_id)
+    pin_ids = await store.list_pin_ids(user_id)
+    usernames = await _resolve_usernames({r.user_id for r in responses if r.user_id})
+    for resp in responses:
         cached = extras.get(resp.id)
         if cached is not None:
             resp.skills = cached.get("skills")
             resp.tool_groups = cached.get("tool_groups")
             resp.model = cached.get("model")
-        resp.tags = assignments.get(resp.id, [])
-        resp.is_favorite = resp.id in favorite_ids
-        resp.is_pinned = resp.id in pin_ids
-    return responses
+        resp.tags = assignments.get(resp.id, [])
+        resp.is_favorite = resp.id in favorite_ids
+        resp.is_pinned = resp.id in pin_ids
+        if resp.user_id:
+            resp.owner_username = usernames.get(resp.user_id)
+    return responses
 
 
 @router.get(
@@ -509,14 +548,18 @@ async def list_agents(
         pattern="^(mine|square)$",
         description="Pagination scope. 'mine' = owned + favorited; 'square' = built-in/published public. Omit for the default combined visibility list.",
     ),
-    page: int | None = Query(default=None, ge=1, description="1-based page index. Providing this (or 'scope') enables server-side pagination."),
-    page_size: int = Query(default=20, ge=1, le=200, description="Items per page when paginating."),
-    sort: str = Query(
-        default="time_desc",
-        pattern="^(time_desc|time_asc|updated_desc|updated_asc|name_asc|name_desc)$",
-        description="Sort order. Default is newest created first.",
-    ),
-    admin: bool = Query(
+    page: int | None = Query(default=None, ge=1, description="1-based page index. Providing this (or 'scope') enables server-side pagination."),
+    page_size: int = Query(default=20, ge=1, le=200, description="Items per page when paginating."),
+    sort: str = Query(
+        default="time_desc",
+        pattern="^(time_desc|time_asc|updated_desc|updated_asc|name_asc|name_desc)$",
+        description="Sort order. Default is newest created first.",
+    ),
+    owner: str | None = Query(
+        default=None,
+        description="Keep only agents published by this user id (the card's publisher). Built-in agents never match.",
+    ),
+    admin: bool = Query(
         default=False,
         description=(
             "Admin-only override. When ``true`` and the caller is a system admin, "
@@ -543,11 +586,12 @@ async def list_agents(
                 scope=scope,
                 search=search,
                 tag_ids=tag_ids,
-                page=eff_page,
-                page_size=page_size,
-                admin=admin,
-                sort=sort,
-            )
+                page=eff_page,
+                page_size=page_size,
+                admin=admin,
+                sort=sort,
+                owner=owner,
+            )
             responses = await _build_list_responses(store, tag_store, user_id, rows)
             return AgentsListResponse(agents=responses, total=total, page=eff_page, page_size=page_size)
 
@@ -559,11 +603,13 @@ async def list_agents(
         if search:
             needle = search.strip().lower()
             responses = [r for r in responses if needle in r.name.lower()]
-        if tag_ids:
-            wanted = set(tag_ids)
-            responses = [r for r in responses if any(t.get("id") in wanted for t in r.tags)]
-        responses = _sort_agent_responses(responses, sort)
-        return AgentsListResponse(agents=responses, total=len(responses), page=1, page_size=len(responses))
+        if tag_ids:
+            wanted = set(tag_ids)
+            responses = [r for r in responses if any(t.get("id") in wanted for t in r.tags)]
+        if owner and owner.strip():
+            responses = [r for r in responses if r.user_id == owner.strip()]
+        responses = _sort_agent_responses(responses, sort)
+        return AgentsListResponse(agents=responses, total=len(responses), page=1, page_size=len(responses))
     except HTTPException:
         raise
     except Exception as e:
@@ -576,14 +622,14 @@ async def list_agents(
     summary="Check Agent Name",
     description="Validate an agent display name. Duplicate names are allowed.",
 )
-async def check_agent_name(name: str) -> dict[str, Any]:
-    _require_agents_api_enabled()
-    normalized = _validate_display_name(name)
-    return {"available": True, "name": normalized}
-
-
-@router.get(
-    "/agents/selector",
+async def check_agent_name(name: str) -> dict[str, Any]:
+    _require_agents_api_enabled()
+    normalized = _validate_display_name(name)
+    return {"available": True, "name": normalized}
+
+
+@router.get(
+    "/agents/selector",
     response_model=AgentSelectorResponse,
     summary="Agent Homepage Selector",
     description=(
@@ -635,12 +681,12 @@ async def get_agent(agent_id: str, request: Request) -> AgentResponse:
         # Detail view legitimately reads SOUL.md + config.yaml — hop to a
         # worker thread so the asyncio loop stays responsive under concurrent
         # detail fetches.
-        response = await _record_to_response_async(record, include_soul=True, include_extras=True)
-        favorite_ids = await store.list_favorite_ids(user_id)
-        pin_ids = await store.list_pin_ids(user_id)
-        response.is_favorite = agent_id in favorite_ids
-        response.is_pinned = agent_id in pin_ids
-        return response
+        response = await _record_to_response_async(record, include_soul=True, include_extras=True)
+        favorite_ids = await store.list_favorite_ids(user_id)
+        pin_ids = await store.list_pin_ids(user_id)
+        response.is_favorite = agent_id in favorite_ids
+        response.is_pinned = agent_id in pin_ids
+        return response
     except HTTPException:
         raise
     except Exception as e:
@@ -874,16 +920,16 @@ async def delete_agent(agent_id: str, request: Request) -> None:
             await get_tag_store(request).unassign_all("agent", agent_id)
         except Exception:  # noqa: BLE001 — tag cleanup must not block deletion
             pass
-        try:
-            await store.delete_favorites_for_agent(agent_id)
-        except Exception:  # noqa: BLE001 — favorite cleanup must not block deletion
-            pass
-        try:
-            await store.delete_pins_for_agent(agent_id)
-        except Exception:  # noqa: BLE001 - pin cleanup must not block deletion
-            pass
-        try:
-            await store.delete_extras_for_agent(agent_id)
+        try:
+            await store.delete_favorites_for_agent(agent_id)
+        except Exception:  # noqa: BLE001 — favorite cleanup must not block deletion
+            pass
+        try:
+            await store.delete_pins_for_agent(agent_id)
+        except Exception:  # noqa: BLE001 - pin cleanup must not block deletion
+            pass
+        try:
+            await store.delete_extras_for_agent(agent_id)
         except Exception:  # noqa: BLE001 — cache cleanup must not block deletion
             pass
         logger.info("Deleted agent '%s' from %s", agent_id, agent_dir)
@@ -925,7 +971,7 @@ async def favorite_agent(agent_id: str, request: Request) -> None:
     summary="Unfavorite Agent",
     description="Remove an agent from the current user's favorites. No-op when not favorited.",
 )
-async def unfavorite_agent(agent_id: str, request: Request) -> None:
+async def unfavorite_agent(agent_id: str, request: Request) -> None:
     _require_agents_api_enabled()
     agent_id = _validate_storage_id(agent_id)
 
@@ -936,60 +982,60 @@ async def unfavorite_agent(agent_id: str, request: Request) -> None:
         logger.info("User '%s' unfavorited agent '%s'", user_id, agent_id)
     except HTTPException:
         raise
-    except Exception as e:
-        logger.error("Failed to unfavorite agent '%s': %s", agent_id, e, exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to unfavorite agent: {str(e)}") from e
-
-
-@router.post(
-    "/agents/{agent_id}/pin",
-    status_code=204,
-    summary="Pin Agent",
-    description="Pin a visible agent to the top of the current user's lists. Idempotent.",
-)
-async def pin_agent(agent_id: str, request: Request) -> None:
-    _require_agents_api_enabled()
-    agent_id = _validate_storage_id(agent_id)
-
-    try:
-        store = get_agent_store(request)
-        user_id = _current_user_id(request)
-        record = await store.get_visible(agent_id, user_id)
-        if record is None:
-            raise HTTPException(status_code=404, detail=f"Agent '{agent_id}' not found")
-        await store.add_pin(user_id, agent_id)
-        logger.info("User '%s' pinned agent '%s'", user_id, agent_id)
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error("Failed to pin agent '%s': %s", agent_id, e, exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to pin agent: {str(e)}") from e
-
-
-@router.delete(
-    "/agents/{agent_id}/pin",
-    status_code=204,
-    summary="Unpin Agent",
-    description="Remove the current user's pin from an agent. No-op when not pinned.",
-)
-async def unpin_agent(agent_id: str, request: Request) -> None:
-    _require_agents_api_enabled()
-    agent_id = _validate_storage_id(agent_id)
-
-    try:
-        store = get_agent_store(request)
-        user_id = _current_user_id(request)
-        await store.remove_pin(user_id, agent_id)
-        logger.info("User '%s' unpinned agent '%s'", user_id, agent_id)
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error("Failed to unpin agent '%s': %s", agent_id, e, exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to unpin agent: {str(e)}") from e
-
-
-@router.put(
-    "/agents/{agent_id}/featured",
+    except Exception as e:
+        logger.error("Failed to unfavorite agent '%s': %s", agent_id, e, exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Failed to unfavorite agent: {str(e)}") from e
+
+
+@router.post(
+    "/agents/{agent_id}/pin",
+    status_code=204,
+    summary="Pin Agent",
+    description="Pin a visible agent to the top of the current user's lists. Idempotent.",
+)
+async def pin_agent(agent_id: str, request: Request) -> None:
+    _require_agents_api_enabled()
+    agent_id = _validate_storage_id(agent_id)
+
+    try:
+        store = get_agent_store(request)
+        user_id = _current_user_id(request)
+        record = await store.get_visible(agent_id, user_id)
+        if record is None:
+            raise HTTPException(status_code=404, detail=f"Agent '{agent_id}' not found")
+        await store.add_pin(user_id, agent_id)
+        logger.info("User '%s' pinned agent '%s'", user_id, agent_id)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Failed to pin agent '%s': %s", agent_id, e, exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Failed to pin agent: {str(e)}") from e
+
+
+@router.delete(
+    "/agents/{agent_id}/pin",
+    status_code=204,
+    summary="Unpin Agent",
+    description="Remove the current user's pin from an agent. No-op when not pinned.",
+)
+async def unpin_agent(agent_id: str, request: Request) -> None:
+    _require_agents_api_enabled()
+    agent_id = _validate_storage_id(agent_id)
+
+    try:
+        store = get_agent_store(request)
+        user_id = _current_user_id(request)
+        await store.remove_pin(user_id, agent_id)
+        logger.info("User '%s' unpinned agent '%s'", user_id, agent_id)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Failed to unpin agent '%s': %s", agent_id, e, exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Failed to unpin agent: {str(e)}") from e
+
+
+@router.put(
+    "/agents/{agent_id}/featured",
     response_model=AgentResponse,
     summary="Set Agent Featured Rank (admin)",
     description=(
@@ -1031,19 +1077,20 @@ async def set_agent_featured(
         raise HTTPException(status_code=500, detail=f"Failed to set featured: {str(e)}") from e
 
 
-class PrivateSquareListRequest(BaseModel):
+class PrivateSquareListRequest(BaseModel):
     """Request body for listing all private-square agents."""
 
     password: str = Field(..., description="Plain-text private-square password. Verified against the admin-configured hash before the listing is returned.")
     search: str | None = Field(default=None, description="Case-insensitive fuzzy match on agent name (raw or desensitized).")
     tag_ids: list[str] | None = Field(default=None, description="Keep agents carrying any of these tags (OR).")
-    page: int | None = Field(default=None, ge=1, description="1-based page index. Providing this enables server-side pagination.")
-    page_size: int = Field(default=20, ge=1, le=200, description="Items per page when paginating.")
-    sort: str = Field(
-        default="time_desc",
-        pattern="^(time_desc|time_asc|updated_desc|updated_asc|name_asc|name_desc)$",
-        description="Sort order. Default is newest created first.",
-    )
+    page: int | None = Field(default=None, ge=1, description="1-based page index. Providing this enables server-side pagination.")
+    page_size: int = Field(default=20, ge=1, le=200, description="Items per page when paginating.")
+    sort: str = Field(
+        default="time_desc",
+        pattern="^(time_desc|time_asc|updated_desc|updated_asc|name_asc|name_desc)$",
+        description="Sort order. Default is newest created first.",
+    )
+    owner: str | None = Field(default=None, description="Keep only agents published by this user id (the card's publisher).")
 
 
 class AgentPrivateUpdateRequest(BaseModel):
@@ -1086,17 +1133,18 @@ async def list_private_square(body: PrivateSquareListRequest, request: Request)
                 scope="private",
                 search=body.search,
                 tag_ids=body.tag_ids,
-                page=body.page,
-                page_size=body.page_size,
-                sort=body.sort,
-            )
+                page=body.page,
+                page_size=body.page_size,
+                sort=body.sort,
+                owner=body.owner,
+            )
             responses = await _build_list_responses(store, tag_store, user_id, rows)
             return AgentsListResponse(agents=responses, total=total, page=body.page, page_size=body.page_size)
 
         records = await store.list_private()
-        responses = await _build_list_responses(store, tag_store, user_id, records)
-        responses = _sort_agent_responses(responses, body.sort)
-        return AgentsListResponse(agents=responses, total=len(responses), page=1, page_size=len(responses))
+        responses = await _build_list_responses(store, tag_store, user_id, records)
+        responses = _sort_agent_responses(responses, body.sort)
+        return AgentsListResponse(agents=responses, total=len(responses), page=1, page_size=len(responses))
     except HTTPException:
         raise
     except Exception as e:
diff --git a/offline-backend-20260512/backend/app/gateway/routers/browser_context.py b/offline-backend-20260512/backend/app/gateway/routers/browser_context.py
new file mode 100644
index 00000000..3a2237c0
--- /dev/null
+++ b/offline-backend-20260512/backend/app/gateway/routers/browser_context.py
@@ -0,0 +1,590 @@
+"""Browser page context capture endpoints.
+
+This router is intentionally isolated behind ``config.yaml``:
+
+    browser_context:
+      enabled: true
+
+When disabled, mutating endpoints behave as if the integration is unavailable.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+from datetime import UTC, datetime
+from typing import Any, Literal
+from urllib.parse import urlencode
+from uuid import uuid4
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from pydantic import BaseModel, Field
+
+from app.gateway.authz import require_permission
+from app.gateway.deps import get_checkpointer, get_config, get_thread_store
+from app.gateway.routers.thread_runs import RunCreateRequest
+from app.gateway.routers.threads import ThreadCreateRequest, create_thread
+from app.gateway.routers.uploads import _make_file_sandbox_writable
+from app.gateway.services import start_run
+from deerflow.browser_context.tasks import claim_next_browser_task, complete_browser_task, prune_browser_tasks
+from deerflow.config.app_config import AppConfig
+from deerflow.config.browser_context_config import BrowserContextConfig
+from deerflow.runtime import serialize_channel_values
+from deerflow.runtime.user_context import get_effective_user_id
+from deerflow.sandbox.sandbox_provider import get_sandbox_provider
+from deerflow.uploads.manager import (
+    UnsafeUploadPathError,
+    ensure_uploads_dir,
+    normalize_filename,
+    open_upload_file_no_symlink,
+    upload_artifact_url,
+    upload_virtual_path,
+)
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/browser-context", tags=["browser-context"])
+DEFAULT_BROWSER_CONTEXT_PROMPT = "\u8bf7\u57fa\u4e8e\u521a\u521a\u53d1\u9001\u7684\u7f51\u9875\u5185\u5bb9\uff0c\u5148\u7528\u4e2d\u6587\u603b\u7ed3\u8981\u70b9\uff0c\u5e76\u7b49\u5f85\u6211\u7ee7\u7eed\u63d0\u95ee\u3002"
+
+
+class BrowserContextStatusResponse(BaseModel):
+    enabled: bool
+    max_content_chars: int
+    max_title_chars: int
+    max_url_chars: int
+    task_result_timeout_seconds: int
+    task_poll_interval_seconds: float
+    task_lease_seconds: int
+    tool_result_max_chars: int
+
+
+class BrowserContextCaptureRequest(BaseModel):
+    thread_id: str | None = Field(default=None, description="Existing or caller-generated zncm thread id")
+    title: str | None = Field(default=None, description="Current browser page title")
+    url: str | None = Field(default=None, description="Current browser page URL")
+    content: str = Field(description="Captured page content, preferably Markdown")
+    content_type: Literal["markdown", "text"] = Field(default="markdown")
+    prompt: str | None = Field(default=None, description="Optional first question to ask in zncm after capture")
+
+
+class BrowserContextFileInfo(BaseModel):
+    filename: str
+    size: int
+    path: str
+    virtual_path: str
+    artifact_url: str
+
+
+class BrowserContextCaptureResponse(BaseModel):
+    success: bool
+    thread_id: str
+    file: BrowserContextFileInfo
+    chat_path: str
+    chat_url: str
+    browser_context_token: str
+    prompt: str
+    truncated: bool = False
+    message: str
+
+
+class BrowserContextAskRequest(BaseModel):
+    thread_id: str | None = Field(default=None, description="Existing zncm thread id for follow-up questions")
+    title: str | None = Field(default=None, description="Current browser page title")
+    url: str | None = Field(default=None, description="Current browser page URL")
+    content: str = Field(description="Captured page content, preferably Markdown")
+    content_type: Literal["markdown", "text"] = Field(default="markdown")
+    question: str = Field(description="Question asked from the in-page assistant")
+
+
+class BrowserContextAskResponse(BaseModel):
+    success: bool
+    thread_id: str
+    run_id: str
+    answer: str
+    truncated: bool = False
+    message: str
+
+
+class BrowserContextTaskPayload(BaseModel):
+    id: str
+    kind: str = "fetch"
+    url: str
+    instruction: str = ""
+    session_id: str = ""
+    action: dict[str, Any] | None = None
+    created_at: str
+    updated_at: str
+    max_content_chars: int
+
+
+class BrowserContextTaskNextResponse(BaseModel):
+    task: BrowserContextTaskPayload | None = None
+
+
+class BrowserContextTaskResultRequest(BaseModel):
+    kind: str = Field(default="fetch", description="Task kind the extension processed: fetch or act")
+    title: str | None = Field(default=None, description="Captured page title")
+    url: str | None = Field(default=None, description="Final page URL after redirects")
+    content: str | None = Field(default=None, description="Captured page content")
+    content_type: Literal["markdown", "text"] = Field(default="markdown")
+    observation: dict[str, Any] | None = Field(default=None, description="Structured observation for an act step (elements, text, status)")
+    error: str | None = Field(default=None, description="Extension-side task error")
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class BrowserContextTaskResultResponse(BaseModel):
+    success: bool
+    task_id: str
+    status: str
+    truncated: bool = False
+
+
+def _settings(config: AppConfig) -> BrowserContextConfig:
+    value = getattr(config, "browser_context", None)
+    if isinstance(value, BrowserContextConfig):
+        return value
+    if isinstance(value, dict):
+        return BrowserContextConfig.model_validate(value)
+    return BrowserContextConfig()
+
+
+def _require_enabled(config: AppConfig) -> BrowserContextConfig:
+    settings = _settings(config)
+    if not settings.enabled:
+        raise HTTPException(status_code=404, detail="Browser context integration is disabled")
+    return settings
+
+
+def _trim(value: str | None, limit: int) -> str:
+    if not value:
+        return ""
+    return value.strip()[:limit]
+
+
+def _limit_utf8_bytes(value: str, max_bytes: int) -> str:
+    text = value
+    while len(text.encode("utf-8")) > max_bytes:
+        text = text[:-1]
+    return text
+
+
+def _filename_part(value: str, fallback: str, *, max_bytes: int) -> str:
+    text = value.strip() or fallback
+    # Keep unicode word chars so Chinese titles remain readable, while removing
+    # path separators and shell-hostile punctuation.
+    text = re.sub(r"[^\w.-]+", "-", text, flags=re.UNICODE).strip("-._")
+    text = _limit_utf8_bytes(text, max_bytes)
+    return text or fallback
+
+
+def _build_markdown(
+    *,
+    title: str,
+    url: str,
+    content: str,
+    content_type: str,
+    captured_at: str,
+    truncated: bool,
+) -> str:
+    lines = [
+        f"# {title or 'Captured Web Page'}",
+        "",
+        f"- Source URL: {url or '(unknown)'}",
+        f"- Captured at: {captured_at}",
+    ]
+    if truncated:
+        lines.append("- Note: Content was truncated by the browser_context.max_content_chars limit.")
+    lines.extend(["", "---", ""])
+
+    if content_type == "markdown":
+        lines.append(content.strip())
+    else:
+        lines.append("```text")
+        lines.append(content.strip())
+        lines.append("```")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _build_ask_prompt(
+    *,
+    title: str,
+    url: str,
+    content: str,
+    content_type: str,
+    captured_at: str,
+    truncated: bool,
+) -> str:
+    note = "页面内容已按配置截断，请只基于可见内容回答。" if truncated else "页面内容如下。"
+    body = content.strip()
+    if content_type == "text":
+        body = f"```text\n{body}\n```"
+    return "\n\n".join(
+        [
+            "你是 zncm 页面问答助手。请直接基于当前网页内容回答用户问题。",
+            "如果网页内容不足以回答，请说明缺少哪些信息；不要编造，也不要再尝试抓取其它网页。",
+            f"页面标题：{title or '未知标题'}",
+            f"页面 URL：{url or '未知 URL'}",
+            f"读取时间：{captured_at}",
+            f"说明：{note}",
+            "当前网页内容：",
+            body,
+        ]
+    )
+
+
+def _message_type(message: Any) -> str:
+    if isinstance(message, dict):
+        return str(message.get("type") or message.get("role") or "").lower()
+    return str(getattr(message, "type", "") or getattr(message, "role", "") or "").lower()
+
+
+def _content_to_text(content: Any) -> str:
+    if isinstance(content, str):
+        return content.strip()
+    if isinstance(content, list):
+        parts: list[str] = []
+        for item in content:
+            if isinstance(item, str):
+                parts.append(item)
+            elif isinstance(item, dict):
+                if isinstance(item.get("text"), str):
+                    parts.append(item["text"])
+                elif item.get("type") == "text" and isinstance(item.get("content"), str):
+                    parts.append(item["content"])
+        return "\n".join(part.strip() for part in parts if part and part.strip()).strip()
+    return ""
+
+
+def _latest_ai_answer(values: dict[str, Any]) -> str:
+    messages = values.get("messages")
+    if not isinstance(messages, list):
+        return ""
+    for message in reversed(messages):
+        if _message_type(message) not in {"ai", "assistant"}:
+            continue
+        answer = _content_to_text(message.get("content") if isinstance(message, dict) else getattr(message, "content", None))
+        if answer:
+            return answer
+    return ""
+
+
+async def _sync_to_sandbox_if_needed(thread_id: str, virtual_path: str, file_path, data: bytes) -> None:
+    sandbox_provider = get_sandbox_provider()
+    if bool(getattr(sandbox_provider, "uses_thread_data_mounts", False)):
+        return
+    sandbox_id = sandbox_provider.acquire(thread_id)
+    sandbox = sandbox_provider.get(sandbox_id)
+    if sandbox is None:
+        raise HTTPException(status_code=500, detail="Failed to acquire sandbox")
+    _make_file_sandbox_writable(file_path)
+    sandbox.update_file(virtual_path, data)
+
+
+@router.get("/status", response_model=BrowserContextStatusResponse)
+async def get_browser_context_status(
+    config: AppConfig = Depends(get_config),
+) -> BrowserContextStatusResponse:
+    settings = _settings(config)
+    return BrowserContextStatusResponse(
+        enabled=settings.enabled,
+        max_content_chars=settings.max_content_chars,
+        max_title_chars=settings.max_title_chars,
+        max_url_chars=settings.max_url_chars,
+        task_result_timeout_seconds=settings.task_result_timeout_seconds,
+        task_poll_interval_seconds=settings.task_poll_interval_seconds,
+        task_lease_seconds=settings.task_lease_seconds,
+        tool_result_max_chars=settings.tool_result_max_chars,
+    )
+
+
+@router.get("/tasks/next", response_model=BrowserContextTaskNextResponse)
+@require_permission("runs", "create")
+async def claim_browser_context_task(
+    request: Request,
+    worker_id: str | None = None,
+    config: AppConfig = Depends(get_config),
+) -> BrowserContextTaskNextResponse:
+    settings = _require_enabled(config)
+    prune_browser_tasks()
+    task = claim_next_browser_task(
+        user_id=get_effective_user_id(),
+        worker_id=worker_id or "chrome-extension",
+        lease_seconds=settings.task_lease_seconds,
+    )
+    if task is None:
+        return BrowserContextTaskNextResponse(task=None)
+    return BrowserContextTaskNextResponse(task=BrowserContextTaskPayload.model_validate(task))
+
+
+@router.post("/tasks/{task_id}/result", response_model=BrowserContextTaskResultResponse)
+@require_permission("runs", "create")
+async def submit_browser_context_task_result(
+    task_id: str,
+    body: BrowserContextTaskResultRequest,
+    request: Request,
+    config: AppConfig = Depends(get_config),
+) -> BrowserContextTaskResultResponse:
+    settings = _require_enabled(config)
+    error = _trim(body.error, 4000)
+    content = body.content or ""
+    is_act = (body.kind or "fetch") == "act"
+    if not error and not is_act and not content.strip():
+        raise HTTPException(status_code=400, detail="Captured page content is empty")
+    if not error and is_act and not isinstance(body.observation, dict):
+        raise HTTPException(status_code=400, detail="Act task result requires an observation")
+
+    task = complete_browser_task(
+        task_id=task_id,
+        user_id=get_effective_user_id(),
+        title=_trim(body.title, settings.max_title_chars),
+        url=_trim(body.url, settings.max_url_chars),
+        content=content,
+        content_type=body.content_type,
+        error=error,
+        metadata=body.metadata,
+        observation=body.observation,
+    )
+    if task is None:
+        raise HTTPException(status_code=404, detail=f"Browser task {task_id} not found")
+
+    result = task.get("result") or {}
+    return BrowserContextTaskResultResponse(
+        success=True,
+        task_id=task_id,
+        status=str(task.get("status") or "unknown"),
+        truncated=bool(result.get("truncated")),
+    )
+
+
+@router.post("/capture", response_model=BrowserContextCaptureResponse)
+@require_permission("threads", "write")
+async def capture_browser_context(
+    body: BrowserContextCaptureRequest,
+    request: Request,
+    config: AppConfig = Depends(get_config),
+) -> BrowserContextCaptureResponse:
+    settings = _require_enabled(config)
+
+    raw_content = (body.content or "").strip()
+    if not raw_content:
+        raise HTTPException(status_code=400, detail="Captured page content is empty")
+
+    title = _trim(body.title, settings.max_title_chars)
+    url = _trim(body.url, settings.max_url_chars)
+    truncated = len(raw_content) > settings.max_content_chars
+    content = raw_content[: settings.max_content_chars] if truncated else raw_content
+
+    requested_thread_id = (body.thread_id or "").strip() or None
+    if requested_thread_id:
+        thread_store = get_thread_store(request)
+        allowed = await thread_store.check_access(
+            requested_thread_id,
+            get_effective_user_id(),
+            require_existing=False,
+        )
+        if not allowed:
+            raise HTTPException(status_code=404, detail=f"Thread {requested_thread_id} not found")
+
+    thread_response = await create_thread(
+        ThreadCreateRequest(
+            thread_id=requested_thread_id,
+            metadata={
+                "source": "browser_context",
+                "browser_context_url": url,
+                "browser_context_title": title,
+            },
+        ),
+        request,
+    )
+    thread_id = thread_response.thread_id
+
+    captured_at = datetime.now(UTC).isoformat()
+    markdown = _build_markdown(
+        title=title,
+        url=url,
+        content=content,
+        content_type=body.content_type,
+        captured_at=captured_at,
+        truncated=truncated,
+    )
+    data = markdown.encode("utf-8")
+
+    timestamp = datetime.now(UTC).strftime("%Y%m%d-%H%M%S")
+    prefix = _filename_part(settings.filename_prefix, "webpage", max_bytes=40)
+    title_part = _filename_part(title, "page", max_bytes=120)
+    filename = normalize_filename(f"{prefix}-{timestamp}-{title_part}.md")
+
+    try:
+        uploads_dir = ensure_uploads_dir(thread_id)
+        file_path, fh = open_upload_file_no_symlink(uploads_dir, filename)
+        with fh:
+            fh.write(data)
+    except UnsafeUploadPathError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except Exception as exc:
+        logger.exception("Failed to save browser context capture for thread %s", thread_id)
+        raise HTTPException(status_code=500, detail="Failed to save captured page") from exc
+
+    virtual_path = upload_virtual_path(filename)
+    await _sync_to_sandbox_if_needed(thread_id, virtual_path, file_path, data)
+
+    prompt = (body.prompt or "").strip() or DEFAULT_BROWSER_CONTEXT_PROMPT
+    token = uuid4().hex
+    route_base = settings.route_base.rstrip("/") or "/page/workspace"
+    chat_path = f"{route_base}/chats/{thread_id}"
+    query = urlencode(
+        {
+            "browser_context": token,
+            "bc_filename": filename,
+            "bc_size": str(len(data)),
+            "bc_path": virtual_path,
+            "bc_prompt": prompt,
+        }
+    )
+    chat_url = f"#{chat_path}?{query}"
+
+    return BrowserContextCaptureResponse(
+        success=True,
+        thread_id=thread_id,
+        file=BrowserContextFileInfo(
+            filename=filename,
+            size=len(data),
+            path=virtual_path,
+            virtual_path=virtual_path,
+            artifact_url=upload_artifact_url(thread_id, filename),
+        ),
+        chat_path=chat_path,
+        chat_url=chat_url,
+        browser_context_token=token,
+        prompt=prompt,
+        truncated=truncated,
+        message="Captured page saved as a zncm upload",
+    )
+
+
+@router.post("/ask", response_model=BrowserContextAskResponse)
+@require_permission("runs", "create")
+async def ask_browser_context(
+    body: BrowserContextAskRequest,
+    request: Request,
+    config: AppConfig = Depends(get_config),
+) -> BrowserContextAskResponse:
+    settings = _require_enabled(config)
+
+    raw_content = (body.content or "").strip()
+    if not raw_content:
+        raise HTTPException(status_code=400, detail="Captured page content is empty")
+
+    question = (body.question or "").strip()
+    if not question:
+        raise HTTPException(status_code=400, detail="Question is empty")
+
+    title = _trim(body.title, settings.max_title_chars)
+    url = _trim(body.url, settings.max_url_chars)
+    content_limit = max(1_000, min(settings.max_content_chars, settings.tool_result_max_chars))
+    truncated = len(raw_content) > content_limit
+    content = raw_content[:content_limit] if truncated else raw_content
+
+    requested_thread_id = (body.thread_id or "").strip() or None
+    if requested_thread_id:
+        thread_store = get_thread_store(request)
+        allowed = await thread_store.check_access(
+            requested_thread_id,
+            get_effective_user_id(),
+            require_existing=False,
+        )
+        if not allowed:
+            raise HTTPException(status_code=404, detail=f"Thread {requested_thread_id} not found")
+
+    thread_response = await create_thread(
+        ThreadCreateRequest(
+            thread_id=requested_thread_id,
+            assistant_id="lead_agent",
+            metadata={
+                "source": "browser_context_page_assistant",
+                "browser_context_url": url,
+                "browser_context_title": title,
+            },
+        ),
+        request,
+    )
+    thread_id = thread_response.thread_id
+    captured_at = datetime.now(UTC).isoformat()
+    is_follow_up = requested_thread_id is not None
+    if is_follow_up:
+        prompt_prefix = "\n\n".join(
+            [
+                "你是 zncm 页面问答助手。请继续基于本会话里已经读取的网页内容回答用户问题。",
+                "如果本会话里的网页内容不足以回答，请说明缺少哪些信息；不要编造，也不要再尝试抓取其它网页。",
+                f"当前页面标题：{title or '未知标题'}",
+                f"当前页面 URL：{url or '未知 URL'}",
+                f"本轮提问时间：{captured_at}",
+            ]
+        )
+    else:
+        prompt_prefix = _build_ask_prompt(
+            title=title,
+            url=url,
+            content=content,
+            content_type=body.content_type,
+            captured_at=captured_at,
+            truncated=truncated,
+        )
+
+    run_body = RunCreateRequest(
+        assistant_id="lead_agent",
+        input={
+            "messages": [
+                {
+                    "type": "human",
+                    "content": question,
+                    "additional_kwargs": {
+                        "prompt_prefix": prompt_prefix,
+                    },
+                }
+            ]
+        },
+        metadata={
+            "source": "browser_context_page_assistant",
+            "browser_context_url": url,
+            "browser_context_title": title,
+            "browser_context_truncated": truncated,
+        },
+        stream_mode=["values"],
+        on_disconnect="continue",
+        multitask_strategy="reject",
+    )
+
+    record = await start_run(run_body, thread_id, request)
+    if record.task is not None:
+        try:
+            await record.task
+        except asyncio.CancelledError:
+            pass
+
+    checkpointer = get_checkpointer(request)
+    values: dict[str, Any] = {}
+    try:
+        checkpoint_tuple = await checkpointer.aget_tuple({"configurable": {"thread_id": thread_id}})
+        if checkpoint_tuple is not None:
+            checkpoint = getattr(checkpoint_tuple, "checkpoint", {}) or {}
+            values = serialize_channel_values(checkpoint.get("channel_values", {}) or {})
+    except Exception:
+        logger.exception("Failed to fetch browser context answer for run %s", record.run_id)
+
+    answer = _latest_ai_answer(values)
+    if not answer:
+        answer = record.error or "zncm did not return an answer."
+
+    return BrowserContextAskResponse(
+        success=bool(answer),
+        thread_id=thread_id,
+        run_id=record.run_id,
+        answer=answer,
+        truncated=truncated,
+        message="zncm page assistant answer completed",
+    )
diff --git a/offline-backend-20260512/backend/app/gateway/routers/intent.py b/offline-backend-20260512/backend/app/gateway/routers/intent.py
index 249c4a1b..d4d0f7c0 100644
--- a/offline-backend-20260512/backend/app/gateway/routers/intent.py
+++ b/offline-backend-20260512/backend/app/gateway/routers/intent.py
@@ -328,9 +328,15 @@ async def stream_intent(request: Request, payload: dict = Body(...)) -> Streamin
     # config.yaml 的 models[0],与 /api/ai-writing 等其它路由一致,内网部署只配
     # 自己的本地模型即可工作。
     model_name = str(payload.get("model") or "")
+    # 用户在 Step 1 上传的参考文件（已经过 /api/threads/{thread_id}/uploads）。
+    # 前端传 [{filename, size, path, status}, ...]，这里原样透传给 _run_payload →
+    # additional_kwargs.files → UploadsMiddleware 自动注入清单 + 解锁 read_file 等工具。
+    raw_files = payload.get("files")
+    files = raw_files if isinstance(raw_files, list) else []
     if not thread_id:
         raise HTTPException(status_code=400, detail="thread_id is required")
-    if not message:
+    # 允许「仅文件、无文本」的回合：带了文件就不强制要求 message。
+    if not message and not files:
         raise HTTPException(status_code=400, detail="message is required")
 
     # 调用前自检:防御性二次检查——若管理员在 init 之后手动删了目录,这里也能自愈。
@@ -381,8 +387,17 @@ async def stream_intent(request: Request, payload: dict = Body(...)) -> Streamin
                         _MAX_CLARIFICATION_ROUNDS,
                     )
 
+                # 带了上传文件时，解锁「读」类工具（read_file / ls / grep / view_image），
+                # 否则 UploadsMiddleware 注入了文件清单、模型却没工具读取。仍保留对
+                # write_file / str_replace / present_files / bash / agent_orchestration 的封锁，
+                # 防止意图阶段越界做方案/派活。
+                if files:
+                    read_tools = {"read_file", "ls", "grep", "view_image"}
+                    base_excluded_tools = [t for t in base_excluded_tools if t not in read_tools]
+
                 # 2. message 前缀——给模型一个明确的"本轮必须收敛"信号。
-                effective_message = message
+                # 仅文件、无文本时给一句兜底引导，让模型先读文件再澄清意图。
+                effective_message = message or "我上传了文件，请先阅读文件内容，再据此理解并澄清我的任务意图。"
                 if past_clarifications >= _MAX_CLARIFICATION_ROUNDS:
                     effective_message = (
                         f"[系统强制] 已澄清 {past_clarifications} 轮,触发硬上限。"
@@ -409,6 +424,7 @@ async def stream_intent(request: Request, payload: dict = Body(...)) -> Streamin
                     # not reliable on its own, hard exclusion is.
                     excluded_tools=base_excluded_tools,
                     skill_stop_names=[],
+                    files=files,
                 )
 
                 # captured：上游 SSE 全部 data 行，用于流结束后从 values 快照取 messages。
diff --git a/offline-backend-20260512/backend/app/gateway/routers/knowledge.py b/offline-backend-20260512/backend/app/gateway/routers/knowledge.py
new file mode 100644
index 00000000..9512f0f9
--- /dev/null
+++ b/offline-backend-20260512/backend/app/gateway/routers/knowledge.py
@@ -0,0 +1,521 @@
+"""Knowledge base API (``/api/knowledge``).
+
+Sediments threads / searches into an obsidian-wiki compatible vault, mirrors
+metadata into the database, and serves listing, detail, edit, delete, search
+and graph export. The knowledge base is **global / shared** — no per-user
+isolation; writes record ``created_by`` / ``updated_by`` for audit.
+
+All obsidian-wiki specifics live in :mod:`deerflow.knowledge`; this router only
+adapts HTTP ↔ the :class:`~deerflow.knowledge.service.KnowledgeService`.
+"""
+
+from __future__ import annotations
+
+import logging
+import mimetypes
+from typing import Any
+
+from fastapi import APIRouter, BackgroundTasks, HTTPException, Request
+from fastapi.responses import FileResponse
+from pydantic import BaseModel, Field
+
+from app.gateway.authz import require_auth, require_permission
+from app.gateway.deps import get_checkpointer, get_knowledge_service, get_local_provider, get_thread_store
+from app.gateway.utils import sanitize_log_param
+from deerflow.knowledge.service import EmptyThreadError
+from deerflow.runtime import serialize_channel_values
+from deerflow.runtime.references import build_reference_batches
+from deerflow.runtime.user_context import get_effective_user_id
+
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/api/knowledge", tags=["knowledge"])
+
+
+# --------------------------------------------------------------------------- #
+# Request / response models
+# --------------------------------------------------------------------------- #
+class IngestThreadRequest(BaseModel):
+    mode: str = Field(default="summary", description="summary | full")
+    title: str | None = None
+    status: str = Field(default="approved", description="draft | approved")
+    tags: list[str] = Field(default_factory=list)
+    include_sources: bool = True
+    background: bool = Field(
+        default=False,
+        description="When true, sediment the thread asynchronously in a background task and return immediately.",
+    )
+    model_name: str | None = Field(default=None, description="可选:指定用于知识提炼的大模型名称;留空使用默认配置")
+
+
+class BatchIngestRequest(BaseModel):
+    limit: int = Field(default=100, ge=1, le=500)
+    offset: int = Field(default=0, ge=0)
+    status: str = "approved"
+    include_sources: bool = True
+    skip_existing: bool = True
+    mode: str = "summary"
+    model_name: str | None = Field(default=None, description="可选:指定用于知识提炼的大模型名称;留空使用默认配置")
+
+
+class SearchResultItem(BaseModel):
+    title: str | None = None
+    url: str | None = None
+    snippet: str | None = None
+    tool_name: str | None = None
+    score: float | None = None
+
+
+class IngestSearchRequest(BaseModel):
+    query: str
+    results: list[SearchResultItem] = Field(default_factory=list)
+    thread_id: str | None = None
+    message_id: str | None = None
+    title: str | None = None
+    tags: list[str] = Field(default_factory=list)
+    status: str = "approved"
+
+
+class CreateNoteRequest(BaseModel):
+    title: str
+    content_md: str
+    summary: str | None = None
+    tags: list[str] = Field(default_factory=list)
+    status: str = "approved"
+
+
+class UpdateNoteRequest(BaseModel):
+    title: str | None = None
+    content_md: str | None = None
+    summary: str | None = None
+    tags: list[str] | None = None
+    status: str | None = None
+
+
+class SearchRequest(BaseModel):
+    query: str
+    mode: str = Field(default="keyword", description="keyword | vector | hybrid (vector/hybrid fall back to keyword in v1)")
+    limit: int = Field(default=8, ge=1, le=50)
+
+
+class ResolveWikilinksRequest(BaseModel):
+    targets: list[str] = Field(default_factory=list, description="`[[wikilink]]` targets to resolve to note ids / vault pages.")
+
+
+# --------------------------------------------------------------------------- #
+# Helpers
+# --------------------------------------------------------------------------- #
+async def _read_thread_values(checkpointer, thread_id: str) -> dict[str, Any]:
+    """Return serialized channel values for a thread, or raise 404/500."""
+    config = {"configurable": {"thread_id": thread_id, "checkpoint_ns": ""}}
+    try:
+        checkpoint_tuple = await checkpointer.aget_tuple(config)
+    except Exception:
+        logger.exception("Failed to read thread %s for knowledge ingest", sanitize_log_param(thread_id))
+        raise HTTPException(status_code=500, detail="Failed to read thread state")
+    if checkpoint_tuple is None:
+        raise HTTPException(status_code=404, detail=f"Thread {thread_id} not found")
+    checkpoint = getattr(checkpoint_tuple, "checkpoint", {}) or {}
+    return serialize_channel_values(checkpoint.get("channel_values", {}) or {})
+
+
+async def _enrich_actor_names(note: dict[str, Any]) -> None:
+    """Resolve created_by/updated_by user ids to a human label (email).
+
+    Adds ``created_by_name`` / ``updated_by_name`` to the note dict so the UI can
+    show a person instead of a raw UUID. Best-effort: unresolved ids fall back to
+    ``None`` and the frontend then shows a shortened id.
+    """
+    provider = get_local_provider()
+    cache: dict[str, str | None] = {}
+
+    async def name_of(uid: str | None) -> str | None:
+        if not uid:
+            return None
+        if uid not in cache:
+            try:
+                user = await provider.get_user(uid)
+                cache[uid] = user.email if user else None
+            except Exception:
+                cache[uid] = None
+        return cache[uid]
+
+    note["created_by_name"] = await name_of(note.get("created_by"))
+    note["updated_by_name"] = await name_of(note.get("updated_by"))
+
+
+def _messages_and_meta(values: dict[str, Any]) -> tuple[list[dict[str, Any]], str | None, list[dict[str, Any]]]:
+    messages = values.get("messages")
+    if not isinstance(messages, list):
+        messages = []
+    title = values.get("title") if isinstance(values.get("title"), str) else None
+    batches = build_reference_batches(messages) if messages else []
+    return messages, title, batches
+
+
+async def _ingest_thread_background(service, checkpointer, thread_id: str, body: IngestThreadRequest, created_by: str | None) -> None:
+    """Sediment a thread into a note without an HTTP context.
+
+    Runs after the response is sent (FastAPI ``BackgroundTasks``); ``created_by``
+    must be captured by the request handler since the user contextvar is gone
+    by the time this executes. All failures are swallowed (logged) — the user
+    has already been told the save was queued.
+    """
+    try:
+        values = await _read_thread_values(checkpointer, thread_id)
+        messages, title, batches = _messages_and_meta(values)
+        if not messages:
+            logger.warning("Background knowledge ingest skipped: thread %s has no messages", sanitize_log_param(thread_id))
+            return
+        await service.capture_thread(
+            thread_id=thread_id,
+            messages=messages,
+            thread_title=title,
+            mode=body.mode,
+            title=body.title,
+            status=body.status,
+            tags=body.tags,
+            include_sources=body.include_sources,
+            reference_batches=batches,
+            created_by=created_by,
+            model_name=body.model_name,
+        )
+    except EmptyThreadError:
+        logger.warning("Background knowledge ingest skipped: thread %s has no sediment-able content", sanitize_log_param(thread_id))
+    except Exception:
+        logger.exception("Background knowledge ingest failed for thread %s", sanitize_log_param(thread_id))
+
+
+# --------------------------------------------------------------------------- #
+# Ingest
+# --------------------------------------------------------------------------- #
+@router.post("/ingest/thread/{thread_id}")
+@require_auth
+@require_permission("threads", "read", owner_check=True)
+async def ingest_thread(thread_id: str, body: IngestThreadRequest, request: Request, background_tasks: BackgroundTasks) -> dict[str, Any]:
+    """Sediment a single thread into a knowledge note.
+
+    With ``background=true`` the heavy capture (read checkpoint → extract →
+    write vault + DB) is deferred to a background task and the endpoint returns
+    ``{"queued": true}`` immediately, so the user's "保存" click never blocks.
+    """
+    service = get_knowledge_service(request)
+    checkpointer = get_checkpointer(request)
+    if body.background:
+        # Capture the user id now — the contextvar is gone once the task runs.
+        background_tasks.add_task(
+            _ingest_thread_background,
+            service,
+            checkpointer,
+            thread_id,
+            body,
+            get_effective_user_id(),
+        )
+        return {"queued": True}
+    values = await _read_thread_values(checkpointer, thread_id)
+    messages, title, batches = _messages_and_meta(values)
+    if not messages:
+        raise HTTPException(status_code=400, detail="Thread has no messages to sediment")
+    try:
+        result = await service.capture_thread(
+            thread_id=thread_id,
+            messages=messages,
+            thread_title=title,
+            mode=body.mode,
+            title=body.title,
+            status=body.status,
+            tags=body.tags,
+            include_sources=body.include_sources,
+            reference_batches=batches,
+            created_by=get_effective_user_id(),
+            model_name=body.model_name,
+        )
+    except EmptyThreadError:
+        raise HTTPException(status_code=400, detail="Thread has no sediment-able content")
+    return {
+        "note": result["note"],
+        "created": result["created"],
+        "notes": result.get("notes", [result["note"]]),
+        "llm_fallback": result.get("llm_fallback", False),
+    }
+
+
+@router.post("/ingest/threads/batch")
+@require_auth
+async def ingest_threads_batch(body: BatchIngestRequest, request: Request) -> dict[str, Any]:
+    """Batch-sediment the caller's recent threads into knowledge notes."""
+    service = get_knowledge_service(request)
+    checkpointer = get_checkpointer(request)
+    thread_store = get_thread_store(request)
+
+    threads = await thread_store.search(limit=body.limit, offset=body.offset)
+    created = skipped = failed = 0
+    # Notes that landed via the rule-based fallback because the chosen model
+    # produced nothing usable (timeout / API error / non-JSON). Surfaced so the
+    # caller can tell the user "X 条因大模型异常改用了规则抽取".
+    llm_fallback = 0
+    items: list[dict[str, Any]] = []
+    for meta in threads:
+        thread_id = meta.get("thread_id")
+        if not thread_id:
+            continue
+        try:
+            values = await _read_thread_values(checkpointer, thread_id)
+            messages, title, batches = _messages_and_meta(values)
+            if not messages:
+                skipped += 1
+                items.append({"thread_id": thread_id, "note_id": None, "status": "skipped"})
+                continue
+            result = await service.capture_thread(
+                thread_id=thread_id,
+                messages=messages,
+                thread_title=title or meta.get("display_name"),
+                mode=body.mode,
+                status=body.status,
+                include_sources=body.include_sources,
+                reference_batches=batches,
+                created_by=get_effective_user_id(),
+                skip_existing=body.skip_existing,
+                model_name=body.model_name,
+            )
+            if result.get("llm_fallback"):
+                llm_fallback += 1
+            if result["created"]:
+                created += 1
+                items.append({"thread_id": thread_id, "note_id": result["note"]["id"], "status": "created", "llm_fallback": bool(result.get("llm_fallback"))})
+            else:
+                skipped += 1
+                items.append({"thread_id": thread_id, "note_id": result["note"]["id"], "status": "skipped"})
+        except EmptyThreadError:
+            skipped += 1
+            items.append({"thread_id": thread_id, "note_id": None, "status": "skipped"})
+        except HTTPException:
+            failed += 1
+            items.append({"thread_id": thread_id, "note_id": None, "status": "failed"})
+        except Exception:
+            logger.exception("Batch ingest failed for thread %s", sanitize_log_param(str(thread_id)))
+            failed += 1
+            items.append({"thread_id": thread_id, "note_id": None, "status": "failed"})
+
+    return {"ok": True, "processed": len(items), "created": created, "skipped": skipped, "failed": failed, "llm_fallback": llm_fallback, "items": items}
+
+
+@router.post("/ingest/search")
+@require_auth
+async def ingest_search(body: IngestSearchRequest, request: Request) -> dict[str, Any]:
+    """Sediment search/tool results as a reference note."""
+    service = get_knowledge_service(request)
+    note = await service.capture_search(
+        query=body.query,
+        results=[r.model_dump() for r in body.results],
+        thread_id=body.thread_id,
+        message_id=body.message_id,
+        title=body.title,
+        tags=body.tags,
+        status=body.status,
+        created_by=get_effective_user_id(),
+    )
+    return {"note": note}
+
+
+# --------------------------------------------------------------------------- #
+# CRUD
+# --------------------------------------------------------------------------- #
+@router.post("/notes")
+@require_auth
+async def create_note(body: CreateNoteRequest, request: Request) -> dict[str, Any]:
+    service = get_knowledge_service(request)
+    note = await service.create_manual_note(
+        title=body.title,
+        content_md=body.content_md,
+        summary=body.summary,
+        tags=body.tags,
+        status=body.status,
+        created_by=get_effective_user_id(),
+    )
+    return {"note": note}
+
+
+@router.get("/notes")
+@require_auth
+async def list_notes(
+    request: Request,
+    keyword: str | None = None,
+    tag: str | None = None,
+    source_type: str | None = None,
+    status: str | None = None,
+    limit: int = 20,
+    offset: int = 0,
+) -> dict[str, Any]:
+    service = get_knowledge_service(request)
+    limit = max(1, min(limit, 100))
+    offset = max(0, offset)
+    return await service.list_notes(keyword=keyword, tag=tag, source_type=source_type, status=status, limit=limit, offset=offset)
+
+
+@router.get("/notes/{note_id}")
+@require_auth
+async def get_note(note_id: str, request: Request) -> dict[str, Any]:
+    service = get_knowledge_service(request)
+    note = await service.get_note(note_id)
+    if note is None:
+        raise HTTPException(status_code=404, detail="Knowledge note not found")
+    await _enrich_actor_names(note)
+    return note
+
+
+@router.put("/notes/{note_id}")
+@require_auth
+async def update_note(note_id: str, body: UpdateNoteRequest, request: Request) -> dict[str, Any]:
+    service = get_knowledge_service(request)
+    note = await service.update_note(
+        note_id,
+        title=body.title,
+        content_md=body.content_md,
+        summary=body.summary,
+        tags=body.tags,
+        status=body.status,
+        updated_by=get_effective_user_id(),
+    )
+    if note is None:
+        raise HTTPException(status_code=404, detail="Knowledge note not found")
+    return note
+
+
+@router.delete("/notes/{note_id}")
+@require_auth
+async def delete_note(note_id: str, request: Request, hard: bool = False) -> dict[str, Any]:
+    service = get_knowledge_service(request)
+    ok = await service.delete_note(note_id, updated_by=get_effective_user_id(), hard=hard)
+    if not ok:
+        raise HTTPException(status_code=404, detail="Knowledge note not found")
+    return {"ok": True, "note_id": note_id}
+
+
+# --------------------------------------------------------------------------- #
+# Search & graph
+# --------------------------------------------------------------------------- #
+@router.post("/search")
+@require_auth
+async def search(body: SearchRequest, request: Request) -> dict[str, Any]:
+    service = get_knowledge_service(request)
+    items = await service.search(body.query, mode=body.mode, limit=body.limit)
+    return {"items": items}
+
+
+# --------------------------------------------------------------------------- #
+# Wikilinks ([[...]] resolution + vault meta-page viewer)
+# --------------------------------------------------------------------------- #
+@router.post("/resolve")
+@require_auth
+async def resolve_wikilinks(body: ResolveWikilinksRequest, request: Request) -> dict[str, Any]:
+    """Resolve ``[[wikilink]]`` targets to navigable destinations.
+
+    Each target resolves to a knowledge note (``kind=note``), a vault meta/hub
+    page (``kind=vault``), or nothing (``kind=missing``). Powers clickable
+    wikilinks in the knowledge UI.
+    """
+    service = get_knowledge_service(request)
+    return {"resolved": await service.resolve_wikilinks(body.targets)}
+
+
+@router.get("/notes/{note_id}/wikilinks")
+@require_auth
+async def resolve_note_wikilinks(note_id: str, request: Request) -> dict[str, Any]:
+    """Resolve every ``[[wikilink]]`` found in a note's body in one call."""
+    service = get_knowledge_service(request)
+    resolved = await service.resolve_note_wikilinks(note_id)
+    if resolved is None:
+        raise HTTPException(status_code=404, detail="Knowledge note not found")
+    return {"resolved": resolved}
+
+
+@router.get("/vault-page")
+@require_auth
+async def get_vault_page(request: Request, path: str) -> dict[str, Any]:
+    """Return a raw vault Markdown meta/hub page (no DB note) by its path."""
+    service = get_knowledge_service(request)
+    page = service.read_vault_page(path)
+    if page is None:
+        raise HTTPException(status_code=404, detail="Vault page not found")
+    return page
+
+
+class MergeRequest(BaseModel):
+    primary_id: str
+    duplicate_ids: list[str] = Field(default_factory=list)
+
+
+@router.get("/duplicates")
+@require_auth
+async def list_duplicates(request: Request) -> dict[str, Any]:
+    """Return suggested duplicate groups (phase 3, heuristic)."""
+    service = get_knowledge_service(request)
+    return {"groups": await service.find_duplicates()}
+
+
+@router.post("/merge")
+@require_auth
+async def merge_notes(body: MergeRequest, request: Request) -> dict[str, Any]:
+    """Merge duplicate notes into a primary note (sources moved, dups archived)."""
+    service = get_knowledge_service(request)
+    note = await service.merge_notes(body.primary_id, body.duplicate_ids, updated_by=get_effective_user_id())
+    if note is None:
+        raise HTTPException(status_code=404, detail="Primary note not found")
+    return {"note": note}
+
+
+@router.post("/reindex")
+@require_auth
+async def reindex_embeddings(request: Request) -> dict[str, Any]:
+    """Rebuild the vector index for all notes (maintenance; no-op if embeddings off)."""
+    service = get_knowledge_service(request)
+    return await service.reindex_all()
+
+
+@router.get("/notes/{note_id}/versions")
+@require_auth
+async def list_note_versions(note_id: str, request: Request) -> dict[str, Any]:
+    """Return the edit history (pre-update snapshots) for a note."""
+    service = get_knowledge_service(request)
+    return {"items": await service.list_versions(note_id)}
+
+
+@router.get("/graph")
+@require_auth
+async def get_graph(request: Request) -> dict[str, Any]:
+    """Return product knowledge-graph data (notes + entities + relations)."""
+    service = get_knowledge_service(request)
+    return await service.get_graph()
+
+
+@router.post("/export/graph")
+@require_auth
+async def export_graph(request: Request) -> dict[str, Any]:
+    service = get_knowledge_service(request)
+    result = await service.export_graph()
+    base = "/api/knowledge/export/files"
+    return {
+        "ok": True,
+        "files": {
+            "graph_json": f"{base}/graph.json",
+            "graph_html": f"{base}/graph.html",
+            "graph_graphml": f"{base}/graph.graphml",
+            "cypher": f"{base}/cypher.txt",
+        },
+        "stats": result["stats"],
+    }
+
+
+@router.get("/export/files/{filename}")
+@require_auth
+async def export_file(filename: str, request: Request) -> FileResponse:
+    service = get_knowledge_service(request)
+    path = service.export_file_path(filename)
+    if path is None:
+        # Lazily build the export on first access so the iframe never 404s.
+        await service.export_graph()
+        path = service.export_file_path(filename)
+    if path is None:
+        raise HTTPException(status_code=404, detail="Export file not found")
+    media_type = mimetypes.guess_type(filename)[0] or "application/octet-stream"
+    return FileResponse(path, media_type=media_type)
diff --git a/offline-backend-20260512/backend/app/gateway/routers/multi_agent.py b/offline-backend-20260512/backend/app/gateway/routers/multi_agent.py
index eb5f7179..cf3a1590 100644
--- a/offline-backend-20260512/backend/app/gateway/routers/multi_agent.py
+++ b/offline-backend-20260512/backend/app/gateway/routers/multi_agent.py
@@ -638,6 +638,7 @@ def _run_payload(
     reasoning_effort: str = "medium",
     multitask_strategy: str = "reject",
     extra_context: dict[str, Any] | None = None,
+    files: list[dict[str, Any]] | None = None,
 ) -> dict[str, Any]:
     """构造 ``POST /api/threads/{thread_id}/runs/stream`` 的请求体。
 
@@ -650,13 +651,19 @@ def _run_payload(
       应传 ``thinking_enabled=False`` + ``reasoning_effort="low"``，省掉模型先吐
       reasoning tokens 才开口的时间，显著降低前端"调度中"首字节延迟。
     """
+    # 用户上传的文件元数据透传给 UploadsMiddleware（与普通聊天同链路）：
+    # before_agent 钩子读 additional_kwargs.files，生成 <uploaded_files> 清单注入消息，
+    # 之后席位/总控用内置 read_file / grep / view_image 工具按需读取。空时落空 dict，行为不变。
+    additional_kwargs: dict[str, Any] = {}
+    if files:
+        additional_kwargs["files"] = files
     payload: dict[str, Any] = {
         "input": {
             "messages": [
                 {
                     "type": "human",
                     "content": [{"type": "text", "text": new_message}],
-                    "additional_kwargs": {},
+                    "additional_kwargs": additional_kwargs,
                 }
             ]
         },
@@ -1258,6 +1265,7 @@ async def _leader_run(
     seat_meta: dict[str, dict[str, Any]] | None = None,
     synthesis_mode: bool = False,
     suppress_pre_broadcast: bool = False,
+    files: list[dict[str, Any]] | None = None,
 ) -> AsyncIterator[str | dict[str, Any]]:
     """总控（leader）单轮：透传上游 SSE + 末尾 yield 一个 dict 状态帧（由路由层 ``json.dumps``）。
 
@@ -1346,18 +1354,26 @@ async def _leader_run(
     # 调用方可再叠加自己的 skill_stop。后台进程内网关用同一份 policy，保证传参一致。
     policy = roundtable_run_policy("leader")
     effective_stop_names = merge_skill_stop_names(policy.skill_stop_names, skill_stop_names)
+    # 带了上传文件时，给总控解锁「读」类工具（leader policy 默认禁 read_file/ls/view_image），
+    # 否则文件清单注入了却无工具读取。写/派活类仍按 policy 封锁，不放开。
+    leader_excluded = policy.excluded_tools
+    if files:
+        _read_tools = {"read_file", "ls", "grep", "view_image"}
+        leader_excluded = [t for t in leader_excluded if t not in _read_tools]
     body = _run_payload(
         agent_name=agent_name,
         model_name=model_name,
         thread_id=thread_id,
         # 注入了席位清单的输入(leader_input);seat_roster 为空时等同 new_message。
         new_message=leader_input,
-        excluded_tools=policy.excluded_tools,
+        excluded_tools=leader_excluded,
         skill_stop_names=effective_stop_names,
         thinking_enabled=policy.thinking_enabled,
         reasoning_effort=policy.reasoning_effort,
         # 人工干预/恢复会重发 leader run 到同一总控 thread;抢占掉没结束的旧 run,避免 409。
         multitask_strategy="rollback",
+        # 用户随干预上传的参考文件 → 总控可用 read_file 等工具读取后再派活。
+        files=files,
     )
     t_payload_built = time.perf_counter()
     logger.info(
@@ -1532,6 +1548,7 @@ async def _special_run(
     display_name: str = "",
     no_file: bool = False,
     peer_deliveries: list[dict[str, Any]] | None = None,
+    files: list[dict[str, Any]] | None = None,
 ) -> AsyncIterator[str | dict[str, Any]]:
     """子智能体（special）单轮：执行总控下发的 task 文本，交付 content。
 
@@ -1560,12 +1577,18 @@ async def _special_run(
     else:
         role = "seat"
     policy = roundtable_run_policy(role)
+    # 带了上传文件时，给席位解锁「读」类工具（view_image 默认被禁；read_file 本就可用），
+    # 让席位能读取/识别用户上传的文件。写/派活类仍按 policy 封锁。
+    seat_excluded = policy.excluded_tools
+    if files:
+        _read_tools = {"read_file", "ls", "grep", "view_image"}
+        seat_excluded = [t for t in seat_excluded if t not in _read_tools]
     body = _run_payload(
         agent_name=agent_name,
         model_name=model_name,
         thread_id=thread_id,
         new_message=new_message,
-        excluded_tools=policy.excluded_tools,
+        excluded_tools=seat_excluded,
         skill_stop_names=merge_skill_stop_names(policy.skill_stop_names, skill_stop_names),
         thinking_enabled=policy.thinking_enabled,
         reasoning_effort=policy.reasoning_effort,
@@ -1575,6 +1598,8 @@ async def _special_run(
         extra_context=(
             {"roundtable_peer_deliveries": peer_deliveries} if peer_deliveries else None
         ),
+        # 用户随干预上传的参考文件 → 席位可用 read_file 等工具读取。
+        files=files,
     )
     t_payload_built = time.perf_counter()
     logger.info(
@@ -1677,6 +1702,11 @@ async def run_multi_agent_stream(request: Request, payload: dict = Body(...)) ->
     display_name: str = str(payload.get("display_name") or "").strip()
     new_message: str = str(payload.get("new_message") or "")
     skill_stop_names: list[str] = payload.get("skill_stop_names") or []
+    # 用户随干预消息上传的参考文件（已经过 /api/threads/{thread_id}/uploads）。
+    # 前端传 [{filename, size, path, status}, ...]，透传给 _run_payload →
+    # additional_kwargs.files → UploadsMiddleware 注入清单 + 解锁 read_file 等工具。
+    _files_raw = payload.get("files")
+    files: list[dict[str, Any]] = _files_raw if isinstance(_files_raw, list) else []
     # 综合轮标记(仅 leader 用):前端在「派活后让总控判断继续/综合」的轮次置真,网关据此
     # 额外把各已交付席位的完整交付正文注入总控输入,供其写最终方案。缺省 False(派活决策轮
     # 只给摘要,保持上下文精简)。旧前端不传 → False,行为安全退化。
@@ -1741,6 +1771,7 @@ async def run_multi_agent_stream(request: Request, payload: dict = Body(...)) ->
                         seat_meta=seat_meta,
                         synthesis_mode=synthesis_mode,
                         suppress_pre_broadcast=suppress_pre_broadcast,
+                        files=files,
                     )
                 else:
                     gen = _special_run(
@@ -1748,6 +1779,7 @@ async def run_multi_agent_stream(request: Request, payload: dict = Body(...)) ->
                         display_name=display_name,
                         no_file=no_file,
                         peer_deliveries=peer_deliveries,
+                        files=files,
                     )
                 async for chunk in gen:
                     if isinstance(chunk, dict):
diff --git a/offline-backend-20260512/backend/app/gateway/routers/parallel_agent_tasks.py b/offline-backend-20260512/backend/app/gateway/routers/parallel_agent_tasks.py
index e8c41080..e8c529a6 100644
--- a/offline-backend-20260512/backend/app/gateway/routers/parallel_agent_tasks.py
+++ b/offline-backend-20260512/backend/app/gateway/routers/parallel_agent_tasks.py
@@ -70,6 +70,14 @@ class TaskUpdateRequest(BaseModel):
     messages: list[dict[str, Any]] | None = None
 
 
+class TaskEnsureRequest(BaseModel):
+    """get-or-create：宿主传的 taskId 不固定，新 id 直接**初始化**一条空记录返回（不 404）。"""
+    id: str = Field(min_length=1, max_length=64)
+    title: str = Field(default="", max_length=512)
+    brief: str | None = None
+    agents: list[TaskAgentSchema] = []
+
+
 # ── helpers ──────────────────────────────────────────────────────────────
 
 
@@ -115,6 +123,30 @@ async def create_task(request: Request, body: TaskCreateRequest) -> TaskResponse
     return TaskResponse(**row)
 
 
+@router.post("/ensure", response_model=TaskResponse)
+async def ensure_task(request: Request, body: TaskEnsureRequest) -> TaskResponse:
+    """存在则返回（含 messages 供回显）；不存在则用该 id **初始化**一条空记录返回。
+
+    宿主传的 taskId 不固定：新 id 不再 404，而是即时建好、可直接回显/保存。幂等。
+    """
+    store = _get_store(request)
+    user_id = _current_user_id(request)
+    existing = await store.get_task(body.id, user_id)
+    if existing is not None:
+        return TaskResponse(**existing)
+    row = await store.create_task(
+        user_id,
+        {
+            "id": body.id,
+            "title": body.title.strip(),
+            "brief": body.brief,
+            "agents": [a.model_dump() for a in body.agents],
+            "messages": [],
+        },
+    )
+    return TaskResponse(**row)
+
+
 @router.get("/{task_id}", response_model=TaskResponse)
 async def get_task(request: Request, task_id: str) -> TaskResponse:
     store = _get_store(request)
diff --git a/offline-backend-20260512/backend/app/gateway/routers/parallel_agents.py b/offline-backend-20260512/backend/app/gateway/routers/parallel_agents.py
index be57f4cd..26adaa85 100644
--- a/offline-backend-20260512/backend/app/gateway/routers/parallel_agents.py
+++ b/offline-backend-20260512/backend/app/gateway/routers/parallel_agents.py
@@ -276,6 +276,13 @@ def _build_task_message(task_name: str, brief: str) -> str:
         "调度对象 / 分配给『…』的任务 / agent_name」之类调度内容，严禁罗列或转派其他席位的任务，严禁调用"
         "任何派活 / 调度类工具，也不要用脚本（bash / python）去调用内部接口或翻找派活脚本。"
     )
+    # 澄清护栏：要向用户确认时，必须用 ask_clarification 工具发起（前端据此渲染可点击的协作
+    # 卡片），不能只把问题写在正文里 —— 否则用户看不到卡片、无法回应。能合理假设就先假设并标注。
+    parts.append(
+        "【需要向用户确认时】如果确实缺少完成分析所必需的关键信息，请**调用 `ask_clarification` 工具**"
+        "发起确认（这样用户会看到一张可点击的协作卡片来回答）；**不要只把问题写在正文里**，否则用户无法回应。"
+        "能基于已有信息合理假设的，就先假设并在正文中标注你的假设；只有当不同假设会显著改变结论时，才发起确认。"
+    )
     return "\n\n".join(parts)
 
 
diff --git a/offline-backend-20260512/backend/app/gateway/routers/public_leaderboard.py b/offline-backend-20260512/backend/app/gateway/routers/public_leaderboard.py
new file mode 100644
index 00000000..b856d6e2
--- /dev/null
+++ b/offline-backend-20260512/backend/app/gateway/routers/public_leaderboard.py
@@ -0,0 +1,97 @@
+"""Public (unauthenticated) read-only user leaderboard.
+
+Mounted under the ``/api/public/`` prefix so the auth middleware lets this route
+through without a session cookie. Powers the public "publish" page for the user
+leaderboard — a view-only snapshot with no admin controls and no mutations.
+
+The snapshot honors the same system-wide leaderboard settings (excluded users,
+scheduled/admin/failed inclusion) as the authenticated admin endpoint, so any
+accounts an admin chose to hide stay hidden on the public page as well.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+
+from fastapi import APIRouter, HTTPException, Query
+
+from app.gateway.routers.admin_users import (
+    AdminLeaderboardResponse,
+    _load_or_schedule_daily_leaderboard,
+    _resolve_range,
+)
+from deerflow.config.system_settings import load_system_settings
+from deerflow.persistence.engine import get_session_factory
+
+logger = logging.getLogger(__name__)
+
+# Whitelisted under ``auth_middleware._PUBLIC_PATH_PREFIXES`` (``/api/public/``).
+router = APIRouter(prefix="/api/public/leaderboard", tags=["public-leaderboard"])
+
+
+def _mask_email(email: str | None) -> str:
+    """Reduce an email to its local part so the public page can show a
+    recognizable handle without leaking the full address (domain).
+
+    The leaderboard only makes sense if it names its top users, so the local
+    part is kept intentionally; the privacy gain is dropping the domain and the
+    raw account id from the unauthenticated payload.
+    """
+    if not email:
+        return ""
+    return email.split("@", 1)[0].strip() or ""
+
+
+def _anonymize(resp: AdminLeaderboardResponse) -> AdminLeaderboardResponse:
+    """Strip PII from a leaderboard snapshot before it leaves over the public,
+    unauthenticated endpoint: email → local part, account/thread ids → opaque
+    short hashes (kept stable so they still work as React keys)."""
+
+    def hashed(value: str | None) -> str:
+        if not value:
+            return ""
+        return hashlib.sha1(value.encode("utf-8")).hexdigest()[:12]
+
+    seen_users: set[int] = set()
+    for bucket in (resp.users_by_activity, resp.users_by_questions, resp.users_by_tokens):
+        for user in bucket:
+            if id(user) in seen_users:
+                continue
+            seen_users.add(id(user))
+            user.email = _mask_email(user.email)
+            user.user_id = hashed(user.user_id)
+
+    for bucket in (resp.recent_questions, resp.frequent_questions):
+        for question in bucket:
+            question.email = _mask_email(question.email)
+            question.user_id = hashed(question.user_id)
+            question.thread_id = ""
+            question.run_id = ""
+
+    return resp
+
+
+@router.get("", response_model=AdminLeaderboardResponse)
+@router.get("/", response_model=AdminLeaderboardResponse)
+async def get_public_leaderboard(
+    days: int = Query(default=30, ge=1, le=365),
+    since: str | None = Query(default=None, description="Inclusive range start, ISO datetime"),
+    until: str | None = Query(default=None, description="Inclusive range end, ISO datetime"),
+    limit: int = Query(default=20, ge=5, le=100),
+) -> AdminLeaderboardResponse:
+    """Return a read-only leaderboard snapshot for the public publish page."""
+    session_factory = get_session_factory()
+    if session_factory is None:
+        raise HTTPException(status_code=503, detail="Analytics requires database persistence")
+
+    settings = load_system_settings().leaderboard
+    since_dt, until_dt, _range_days = _resolve_range(days, since, until)
+    resp = await _load_or_schedule_daily_leaderboard(
+        session_factory,
+        settings,
+        since_dt,
+        until_dt,
+        limit=limit,
+    )
+    return _anonymize(resp)
diff --git a/offline-backend-20260512/backend/app/gateway/routers/skills.py b/offline-backend-20260512/backend/app/gateway/routers/skills.py
index ac18e1d7..0d317ba8 100644
--- a/offline-backend-20260512/backend/app/gateway/routers/skills.py
+++ b/offline-backend-20260512/backend/app/gateway/routers/skills.py
@@ -56,6 +56,44 @@ def _is_admin_user(request: Request) -> bool:
     return getattr(user, "system_role", None) == "admin"
 
 
+def _email_local_part(email: str | None) -> str | None:
+    """Return the username portion (before ``@``) of an email address."""
+    if not email:
+        return None
+    at = email.find("@")
+    return email[:at] if at > 0 else email
+
+
+async def _attach_owner_usernames(responses: list["SkillResponse"]) -> list["SkillResponse"]:
+    """Resolve each custom skill's ``owner_user_id`` to a friendly username.
+
+    One lookup per distinct owner id; tolerates deleted accounts and an
+    uninitialised auth provider by leaving ``owner_username`` as None.
+    """
+    owner_ids = {r.owner_user_id for r in responses if r.owner_user_id}
+    if not owner_ids:
+        return responses
+    try:
+        from app.gateway.deps import get_local_provider
+
+        provider = get_local_provider()
+    except Exception:
+        return responses
+    names: dict[str, str] = {}
+    for uid in owner_ids:
+        try:
+            user = await provider.get_user(uid)
+        except Exception:
+            user = None
+        local = _email_local_part(getattr(user, "email", None)) if user is not None else None
+        if local:
+            names[uid] = local
+    for resp in responses:
+        if resp.owner_user_id:
+            resp.owner_username = names.get(resp.owner_user_id)
+    return responses
+
+
 def _can_view_skill_source(
     category: SkillCategory,
     owner_user_id: str | None,
@@ -111,6 +149,7 @@ class SkillResponse(BaseModel):
     """Response model for skill information."""
 
     name: str = Field(..., description="Name of the skill")
+    name_zh: str | None = Field(default=None, description="用户配置或大模型生成的中文名称")
     description: str = Field(..., description="Description of what the skill does")
     license: str | None = Field(None, description="License information")
     category: SkillCategory = Field(..., description="Category of the skill (public or custom)")
@@ -125,6 +164,7 @@ class SkillResponse(BaseModel):
     featured: bool = Field(default=False, description="Whether this skill is pinned to the top of the list (sort only)")
     source: str = Field(default="upload", description="Origin: 'agent' for agent-created, 'upload' for user-uploaded")
     owner_user_id: str | None = Field(default=None, description="Custom skill owner (null = built-in or legacy)")
+    owner_username: str | None = Field(default=None, description="Publisher username (email local part). Null for built-in skills.")
     published: bool = Field(default=False, description="Whether the owner has made this skill visible to other users")
     builtin: bool = Field(default=False, description="True when owner_user_id is null (no human owner)")
     detail: str | None = Field(default=None, description="Human-authored long-form detail text (Markdown), editable by owner/admin")
@@ -267,11 +307,13 @@ def _skill_to_response(
     published = False
     builtin = skill.category != SkillCategory.CUSTOM
     detail: str | None = None
+    name_zh: str | None = None
     if ownership is not None:
         owner_user_id = ownership.get("owner_user_id")
         published = bool(ownership.get("published", False))
         builtin = bool(ownership.get("builtin", owner_user_id is None))
         detail = ownership.get("detail")
+        name_zh = ownership.get("name_zh")
 
     display = None if display_override is _UNSET else display_override
     if display_override is _UNSET:
@@ -284,6 +326,7 @@ def _skill_to_response(
 
     return SkillResponse(
         name=skill.name,
+        name_zh=name_zh,
         description=skill.description,
         license=skill.license,
         category=skill.category,
@@ -697,7 +740,8 @@ async def _attach_and_filter_tags(
         resp.tags = assignments.get(resp.name, [])
     if search:
         needle = search.strip().lower()
-        responses = [r for r in responses if needle in r.name.lower()]
+        # Match the English name OR the Chinese display name so 中文 search works.
+        responses = [r for r in responses if needle in r.name.lower() or (r.name_zh or "").lower().find(needle) >= 0]
     if tag_ids:
         wanted = set(tag_ids)
         responses = [r for r in responses if any(t.get("id") in wanted for t in r.tags)]
@@ -726,7 +770,7 @@ async def list_skills(
     config: AppConfig = Depends(get_config),
     skill_store: SkillStore = Depends(get_skill_store),
     tag_store: TagStore = Depends(get_tag_store),
-    search: str | None = Query(default=None, description="Case-insensitive fuzzy match on skill name"),
+    search: str | None = Query(default=None, description="Case-insensitive fuzzy match on skill name or Chinese name (name_zh)"),
     tag_ids: list[str] | None = Query(default=None, description="Keep skills carrying any of these tags (OR)"),
     sort: str = Query(
         default="time_desc",
@@ -786,6 +830,7 @@ async def list_skills(
                 )
             )
         responses = await _attach_and_filter_tags(tag_store, responses, search, tag_ids)
+        responses = await _attach_owner_usernames(responses)
         responses = _sort_skill_responses(responses, sort)
         return SkillsListResponse(skills=responses)
     except HTTPException:
@@ -1176,6 +1221,7 @@ async def list_custom_skills(
                     display_sample=adapter.get("sample") if adapter else None,
                 )
             )
+        responses = await _attach_owner_usernames(responses)
         return SkillsListResponse(skills=responses)
     except Exception as e:
         logger.error("Failed to list custom skills: %s", e, exc_info=True)
@@ -2309,6 +2355,324 @@ async def update_skill_detail(
         raise HTTPException(status_code=500, detail=f"Failed to update skill detail: {str(e)}")
 
 
+# ---------------------------------------------------------------------------
+# 技能中文名称(用户可配置 + 大模型自动生成 + 一键补充)
+# ---------------------------------------------------------------------------
+
+_SKILL_NAME_ZH_SYSTEM_PROMPT = (
+    "你是一名中文产品命名助手。根据给定技能的英文名与功能描述,生成一个简洁、自然、"
+    "易懂的中文名称。要求:2 到 10 个汉字;准确概括技能用途;不要包含标点、引号、英文、"
+    "解释或多余文字;只输出中文名称本身。"
+)
+
+
+class SkillNameZhModelError(Exception):
+    """The LLM call backing skill-name generation failed (a *model-side* problem).
+
+    Distinguishes a genuine model failure (timeout / API error / unbuildable
+    model) — which must be surfaced to the user as "大模型报错导致无法补全" — from
+    the model merely returning an unusable name (callers get ``None`` instead).
+    """
+
+
+def _clean_generated_name_zh(raw: str) -> str | None:
+    """Normalise an LLM-produced Chinese name: first line, strip quotes/punct, cap length."""
+    if not raw:
+        return None
+    text = str(raw).strip()
+    # Take the first non-empty line only.
+    for line in text.splitlines():
+        line = line.strip()
+        if line:
+            text = line
+            break
+    # Strip wrapping quotes / common trailing punctuation.
+    text = text.strip().strip("\"'“”‘’`「」《》【】()()[]").strip()
+    text = text.rstrip("。.,,、!!??;;:：")
+    if not text:
+        return None
+    # Keep it short — guard against the model returning a sentence.
+    if len(text) > 20:
+        text = text[:20]
+    return text or None
+
+
+def _resolve_skill_name_zh_model_name(app_config: AppConfig, model_name: str | None) -> str | None:
+    """Pick the model name for skill-name generation.
+
+    An explicit ``model_name`` (user-selected in the UI) wins; otherwise fall
+    back to the curator/security-scan model setting (itself falling back to the
+    main model when unset).
+    """
+    if model_name and model_name.strip():
+        return model_name.strip()
+    if app_config.skill_evolution and app_config.skill_evolution.curator:
+        return app_config.skill_evolution.curator.model_name
+    return None
+
+
+async def _generate_skill_name_zh(skill: Skill, app_config: AppConfig, model: Any = None, *, model_name: str | None = None) -> str | None:
+    """Generate a Chinese display name for ``skill`` via the LLM.
+
+    An explicit ``model_name`` lets the caller pick the model; otherwise it
+    reuses the curator/security-scan model setting (falls back to the main
+    model). Returns ``None`` only when the model replies but the output cannot be
+    normalised into a short Chinese name. Raises :class:`SkillNameZhModelError`
+    when the model itself fails (cannot be built / times out / API error), so the
+    caller can tell the user it was a *model* problem.
+    """
+    user_prompt = (
+        f"技能英文名:{skill.name}\n"
+        f"功能描述:{skill.description or '(无描述)'}\n\n"
+        "请为该技能起一个中文名称。"
+    )
+    if model is None:
+        try:
+            from deerflow.models import create_chat_model
+
+            resolved = _resolve_skill_name_zh_model_name(app_config, model_name)
+            model = create_chat_model(name=resolved, thinking_enabled=False, app_config=app_config)
+        except Exception as e:
+            logger.warning("Skill name_zh model build failed for %s", skill.name, exc_info=True)
+            raise SkillNameZhModelError(str(e) or "无法初始化所选大模型") from e
+    try:
+        response = await asyncio.wait_for(
+            model.ainvoke(
+                [
+                    {"role": "system", "content": _SKILL_NAME_ZH_SYSTEM_PROMPT},
+                    {"role": "user", "content": user_prompt},
+                ],
+                config={"run_name": "skill_name_zh"},
+            ),
+            timeout=60,
+        )
+    except asyncio.TimeoutError as e:
+        logger.warning("Skill name_zh LLM call timed out for %s", skill.name)
+        raise SkillNameZhModelError("大模型响应超时(60 秒)") from e
+    except Exception as e:
+        logger.warning("Skill name_zh LLM call failed for %s", skill.name, exc_info=True)
+        raise SkillNameZhModelError(str(e) or "大模型调用失败") from e
+    return _clean_generated_name_zh(str(getattr(response, "content", "") or ""))
+
+
+async def _persist_skill_name_zh(
+    skill: Skill,
+    name_zh: str | None,
+    skill_store: SkillStore,
+    user_id: str,
+    *,
+    is_admin: bool,
+) -> str | None:
+    """Persist ``name_zh`` into the ``skills`` DB table (never the on-disk SKILL.md).
+
+    Authorization mirrors the ``detail`` annotation: a custom skill is editable by
+    its owner or an admin; a built-in / public skill only by an admin (its DB row
+    is materialized on demand). Returns the stored value.
+    """
+    if skill.category == SkillCategory.CUSTOM:
+        _record, mode = await _get_editable_skill_or_raise(skill_store, skill.name, user_id, is_admin=is_admin)
+        if mode == "admin":
+            updated = await skill_store.update_admin(skill.name, {"name_zh": name_zh})
+        else:
+            updated = await skill_store.update(skill.name, user_id, {"name_zh": name_zh})
+    else:
+        if not is_admin:
+            raise HTTPException(status_code=403, detail="Only admin users can edit built-in skill Chinese names")
+        if await skill_store.get_any(skill.name) is None:
+            await skill_store.ensure_legacy({"name": skill.name, "owner_user_id": None, "published": True})
+        updated = await skill_store.update_admin(skill.name, {"name_zh": name_zh})
+
+    if updated is None:
+        raise HTTPException(status_code=500, detail="Failed to persist skill Chinese name")
+    return updated.get("name_zh")
+
+
+class SkillNameZhRequest(BaseModel):
+    """Request body for setting a skill's Chinese display name."""
+
+    name_zh: str = Field(default="", description="中文名称;传空字符串表示清空")
+
+
+class SkillNameZhResponse(BaseModel):
+    """Response model for a single skill's Chinese-name update."""
+
+    name: str = Field(..., description="Skill name")
+    name_zh: str | None = Field(default=None, description="中文名称(为空表示已清空)")
+
+
+class SkillNameZhBulkResponse(BaseModel):
+    """Response model for the one-click bulk fill of missing Chinese names."""
+
+    generated: list[SkillNameZhResponse] = Field(default_factory=list, description="本次成功生成中文名的技能")
+    failed: list[str] = Field(default_factory=list, description="生成失败的技能英文名")
+    skipped: int = Field(default=0, description="已有中文名而被跳过的技能数")
+    model_error: str | None = Field(default=None, description="若有技能因大模型报错而失败,这里给出代表性的报错信息")
+
+
+class GenerateSkillNameZhRequest(BaseModel):
+    """Optional body for skill-name generation: pick the model to use."""
+
+    model_name: str | None = Field(default=None, description="可选:指定用于生成的大模型名称;留空使用默认配置")
+
+
+def _can_edit_skill_name_zh(skill: Skill, record: dict[str, Any] | None, user_id: str, *, is_admin: bool) -> bool:
+    """Whether ``user_id`` may set this skill's Chinese name (mirrors detail auth)."""
+    if is_admin:
+        return True
+    if skill.category != SkillCategory.CUSTOM:
+        return False
+    return record is not None and record.get("owner_user_id") == user_id
+
+
+@router.put(
+    "/skills/{skill_name}/name-zh",
+    response_model=SkillNameZhResponse,
+    summary="Set Skill Chinese Name",
+    description="设置技能的中文名称(存数据库,不改源文件)。自定义技能由其所有者或管理员编辑;内置/公开技能仅管理员可编辑。传空字符串表示清空,回退到使用英文名。",
+)
+async def set_skill_name_zh(
+    skill_name: str,
+    body: SkillNameZhRequest,
+    request: Request,
+    config: AppConfig = Depends(get_config),
+    skill_store: SkillStore = Depends(get_skill_store),
+) -> SkillNameZhResponse:
+    try:
+        skill_name = skill_name.replace("\r\n", "").replace("\n", "")
+        user_id = _current_user_id(request)
+        is_admin = _is_admin_user(request)
+        skills = get_or_new_skill_storage(app_config=config).load_skills(enabled_only=False)
+        skill = next((s for s in skills if s.name == skill_name), None)
+        if skill is None:
+            raise HTTPException(status_code=404, detail=f"Skill '{skill_name}' not found")
+        name_zh = body.name_zh.strip() or None
+        stored = await _persist_skill_name_zh(skill, name_zh, skill_store, user_id, is_admin=is_admin)
+        return SkillNameZhResponse(name=skill_name, name_zh=stored)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Failed to set name_zh for %s: %s", skill_name, e, exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Failed to set skill Chinese name: {str(e)}")
+
+
+@router.post(
+    "/skills/{skill_name}/name-zh/generate",
+    response_model=SkillNameZhResponse,
+    summary="Generate Skill Chinese Name",
+    description="用大模型为该技能生成一个中文名称并保存到数据库。可在请求体里通过 model_name 指定使用的大模型。",
+)
+async def generate_skill_name_zh(
+    skill_name: str,
+    request: Request,
+    body: GenerateSkillNameZhRequest | None = None,
+    config: AppConfig = Depends(get_config),
+    skill_store: SkillStore = Depends(get_skill_store),
+) -> SkillNameZhResponse:
+    try:
+        body = body or GenerateSkillNameZhRequest()
+        skill_name = skill_name.replace("\r\n", "").replace("\n", "")
+        user_id = _current_user_id(request)
+        is_admin = _is_admin_user(request)
+        skills = get_or_new_skill_storage(app_config=config).load_skills(enabled_only=False)
+        skill = next((s for s in skills if s.name == skill_name), None)
+        if skill is None:
+            raise HTTPException(status_code=404, detail=f"Skill '{skill_name}' not found")
+        try:
+            name_zh = await _generate_skill_name_zh(skill, config, model_name=body.model_name)
+        except SkillNameZhModelError as e:
+            raise HTTPException(status_code=502, detail=f"大模型报错,无法补全技能中文名:{e}")
+        if not name_zh:
+            raise HTTPException(status_code=502, detail="大模型未能生成有效的中文名称,请稍后重试或手动填写")
+        stored = await _persist_skill_name_zh(skill, name_zh, skill_store, user_id, is_admin=is_admin)
+        return SkillNameZhResponse(name=skill_name, name_zh=stored)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Failed to generate name_zh for %s: %s", skill_name, e, exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Failed to generate skill Chinese name: {str(e)}")
+
+
+@router.post(
+    "/skills/name-zh/generate-missing",
+    response_model=SkillNameZhBulkResponse,
+    summary="Bulk Generate Missing Skill Chinese Names",
+    description="管理员一键为库中所有尚未配置中文名称的技能生成中文名(存数据库)。可在请求体里通过 model_name 指定使用的大模型。",
+)
+async def generate_missing_skill_names_zh(
+    request: Request,
+    body: GenerateSkillNameZhRequest | None = None,
+    config: AppConfig = Depends(get_config),
+    skill_store: SkillStore = Depends(get_skill_store),
+) -> SkillNameZhBulkResponse:
+    try:
+        from deerflow.models import create_chat_model
+
+        body = body or GenerateSkillNameZhRequest()
+        user_id = _current_user_id(request)
+        is_admin = _is_admin_user(request)
+        # 一键补充技能中文名仅对管理员开放。
+        if not is_admin:
+            raise HTTPException(status_code=403, detail="仅管理员可一键补充技能中文名")
+        skills = get_or_new_skill_storage(app_config=config).load_skills(enabled_only=False)
+
+        # Admin sees every row, so existing name_zh values come from the full set.
+        records = {r["name"]: r for r in await skill_store.list_all()}
+
+        pending: list[Skill] = []
+        skipped = 0
+        for skill in skills:
+            record = records.get(skill.name)
+            if record and record.get("name_zh"):
+                skipped += 1
+                continue
+            pending.append(skill)
+
+        generated: list[SkillNameZhResponse] = []
+        failed: list[str] = []
+        model_error: str | None = None
+        if pending:
+            # Build the model once and reuse it for every skill. A build failure
+            # is a model problem — fail fast with a clear message rather than
+            # silently producing zero results.
+            try:
+                resolved_name = _resolve_skill_name_zh_model_name(config, body.model_name)
+                model = create_chat_model(name=resolved_name, thinking_enabled=False, app_config=config)
+            except Exception as e:
+                logger.warning("Failed to build model for bulk name_zh generation", exc_info=True)
+                raise HTTPException(status_code=502, detail=f"大模型报错,无法补全技能中文名:{str(e) or '无法初始化所选大模型'}")
+
+            # Generate concurrently with a small bound to avoid overloading the model.
+            semaphore = asyncio.Semaphore(4)
+
+            async def _one(skill: Skill) -> tuple[Skill, str | None, str | None]:
+                async with semaphore:
+                    try:
+                        return skill, await _generate_skill_name_zh(skill, config, model=model), None
+                    except SkillNameZhModelError as e:
+                        return skill, None, str(e)
+
+            results = await asyncio.gather(*[_one(s) for s in pending])
+            for skill, name_zh, err in results:
+                if err and model_error is None:
+                    model_error = err
+                if not name_zh:
+                    failed.append(skill.name)
+                    continue
+                try:
+                    stored = await _persist_skill_name_zh(skill, name_zh, skill_store, user_id, is_admin=is_admin)
+                    generated.append(SkillNameZhResponse(name=skill.name, name_zh=stored))
+                except HTTPException:
+                    # Permission / persistence issue for this one skill — skip it.
+                    failed.append(skill.name)
+
+        return SkillNameZhBulkResponse(generated=generated, failed=failed, skipped=skipped, model_error=model_error)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Failed to bulk-generate skill Chinese names: %s", e, exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Failed to bulk-generate skill Chinese names: {str(e)}")
+
+
 class SkillPinRequest(BaseModel):
     pinned: bool = Field(..., description="Whether to pin or unpin the skill")
 
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/agents/lead_agent/agent.py b/offline-backend-20260512/backend/packages/harness/deerflow/agents/lead_agent/agent.py
index 20bebfcc..21bdd019 100644
--- a/offline-backend-20260512/backend/packages/harness/deerflow/agents/lead_agent/agent.py
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/agents/lead_agent/agent.py
@@ -299,6 +299,16 @@ def _build_middlewares(
     if not is_bootstrap and not is_writing_setup:
         middlewares.append(MemoryMiddleware(agent_name=agent_name, memory_config=resolved_app_config.memory, injection_enabled=memory_injection_enabled))
 
+    # KnowledgeRagMiddleware — inject knowledge-base recall (phase 2). Gated
+    # per-conversation by the ``knowledge_rag_enabled`` runtime flag, defaulting
+    # to the global ``knowledge.rag_enabled`` config. No-op when knowledge is
+    # disabled. Skipped in bootstrap/writing-setup like MemoryMiddleware.
+    knowledge_cfg = getattr(resolved_app_config, "knowledge", None)
+    if not is_bootstrap and not is_writing_setup and knowledge_cfg is not None and knowledge_cfg.enabled:
+        from deerflow.agents.middlewares.knowledge_rag_middleware import KnowledgeRagMiddleware
+
+        middlewares.append(KnowledgeRagMiddleware(limit=knowledge_cfg.rag_limit, default_enabled=knowledge_cfg.rag_enabled))
+
     # Add ViewImageMiddleware only for the NATIVE-vision path (main model
     # ingests raw image data). In delegated mode the view_image tool already
     # returns a text description and stores nothing in `viewed_images`, so the
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/agents/middlewares/knowledge_rag_middleware.py b/offline-backend-20260512/backend/packages/harness/deerflow/agents/middlewares/knowledge_rag_middleware.py
new file mode 100644
index 00000000..9ddfd683
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/agents/middlewares/knowledge_rag_middleware.py
@@ -0,0 +1,190 @@
+"""KnowledgeRagMiddleware — inject knowledge-base recall before the model call.
+
+Phase 2 of the product knowledge base. When enabled (per-conversation runtime
+flag ``knowledge_rag_enabled``, falling back to the global
+``knowledge.rag_enabled`` config), the latest user question is used to retrieve
+the most relevant knowledge notes, which are injected as a transient
+``<knowledge-context>`` system message — not persisted to state, so it never
+leaks to the frontend transcript.
+
+Retrieval is hybrid (vector + keyword) when an embedding endpoint is
+configured, else keyword/wiki-query layered search. Failures are swallowed: RAG
+must never break a conversation.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any, override
+
+from langchain.agents import AgentState
+from langchain.agents.middleware import AgentMiddleware
+from langchain_core.messages import HumanMessage
+from langgraph.runtime import Runtime
+
+logger = logging.getLogger(__name__)
+
+_TAG = "knowledge-context"
+
+
+def _coerce_text(content: Any) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for block in content:
+            if isinstance(block, str):
+                parts.append(block)
+            elif isinstance(block, dict) and block.get("type") == "text":
+                parts.append(str(block.get("text", "")))
+        return " ".join(parts)
+    return str(content or "")
+
+
+def _latest_human_text(messages: list) -> str:
+    for msg in reversed(messages or []):
+        if isinstance(msg, HumanMessage):
+            return _coerce_text(msg.content).strip()
+    return ""
+
+
+class KnowledgeRagMiddleware(AgentMiddleware[AgentState]):
+    """Inject knowledge-base recall as transient system context."""
+
+    state_schema = AgentState
+
+    def __init__(self, *, limit: int = 5, default_enabled: bool = False) -> None:
+        super().__init__()
+        self._limit = limit
+        self._default_enabled = default_enabled
+        self._service = None  # lazy
+
+    def _get_service(self):
+        if self._service is not None:
+            return self._service
+        try:
+            from deerflow.config import get_app_config
+            from deerflow.knowledge import make_knowledge_service
+            from deerflow.persistence.engine import get_session_factory
+
+            config = get_app_config()
+            self._service = make_knowledge_service(get_session_factory(), config.knowledge)
+        except Exception:
+            logger.exception("KnowledgeRagMiddleware: failed to build knowledge service")
+            self._service = None
+        return self._service
+
+    def _enabled_for(self, request: Any) -> bool:
+        runtime = getattr(request, "runtime", None)
+        if runtime is not None and getattr(runtime, "context", None):
+            flag = runtime.context.get("knowledge_rag_enabled")
+            if flag is not None:
+                return bool(flag)
+        return self._default_enabled
+
+    async def _build_context_message(self, request: Any) -> HumanMessage | None:
+        if not self._enabled_for(request):
+            return None
+        service = self._get_service()
+        if service is None:
+            return None
+        query = _latest_human_text(getattr(request, "messages", None) or [])
+        if not query:
+            return None
+        try:
+            result = await service.build_rag_context(query, limit=self._limit)
+        except Exception:
+            logger.exception("KnowledgeRagMiddleware: recall failed (non-fatal)")
+            return None
+        text = result.get("text") if isinstance(result, dict) else ""
+        if not text:
+            return None
+        fenced = (
+            f"<{_TAG}>\n"
+            "[系统提示：以下是知识库召回的背景资料，不是用户的新输入。回答时优先参考，"
+            "并在使用到时标注来源 note_id。]\n\n"
+            f"{text}\n"
+            f"</{_TAG}>"
+        )
+        return HumanMessage(content=fenced)
+
+    @override
+    async def awrap_model_call(self, request: Any, handler: Any) -> Any:
+        msg = await self._build_context_message(request)
+        if msg is not None:
+            request = request.override(messages=[*request.messages, msg])
+        return await handler(request)
+
+    @override
+    def wrap_model_call(self, request: Any, handler: Any) -> Any:
+        # Sync path: best-effort. The gateway runtime is async, so this is rarely
+        # hit; run the async recall in a private loop when there is none.
+        if not self._enabled_for(request):
+            return handler(request)
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # Cannot block a running loop from sync code; skip injection.
+                return handler(request)
+            msg = loop.run_until_complete(self._build_context_message(request))
+        except Exception:
+            msg = None
+        if msg is not None:
+            request = request.override(messages=[*request.messages, msg])
+        return handler(request)
+
+    # ---- after_agent: enqueue background auto-sedimentation -------------
+    def _resolve_thread_id(self, runtime: Runtime | None) -> str | None:
+        if runtime is not None and getattr(runtime, "context", None):
+            tid = runtime.context.get("thread_id")
+            if tid:
+                return str(tid)
+        try:
+            from langgraph.config import get_config
+
+            return get_config().get("configurable", {}).get("thread_id")
+        except Exception:
+            return None
+
+    @override
+    def after_agent(self, state: AgentState, runtime: Runtime) -> dict | None:
+        """When auto-ingest is on, hand the finished turn to the background queue."""
+        try:
+            from deerflow.config import get_app_config
+
+            knowledge_cfg = getattr(get_app_config(), "knowledge", None)
+            if knowledge_cfg is None or not knowledge_cfg.enabled or not knowledge_cfg.auto_ingest_enabled:
+                return None
+
+            from deerflow.knowledge.auto_ingest import AutoIngestItem, get_auto_ingest_queue
+
+            queue = get_auto_ingest_queue()
+            if queue is None:
+                return None
+
+            messages = state.get("messages") if isinstance(state, dict) else getattr(state, "messages", None)
+            if not messages:
+                return None
+
+            from deerflow.runtime.references import build_reference_batches
+            from deerflow.runtime.serialization import serialize_lc_object
+            from deerflow.runtime.user_context import get_effective_user_id
+
+            serialized = [serialize_lc_object(m) for m in messages]
+            thread_id = self._resolve_thread_id(runtime)
+            if not thread_id:
+                return None
+            title = state.get("title") if isinstance(state, dict) else getattr(state, "title", None)
+            queue.enqueue(
+                AutoIngestItem(
+                    thread_id=thread_id,
+                    user_id=get_effective_user_id(),
+                    messages=serialized,
+                    thread_title=title if isinstance(title, str) else None,
+                    reference_batches=build_reference_batches(serialized),
+                )
+            )
+        except Exception:
+            logger.exception("KnowledgeRagMiddleware.after_agent enqueue failed (non-fatal)")
+        return None
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/browser_context/__init__.py b/offline-backend-20260512/backend/packages/harness/deerflow/browser_context/__init__.py
new file mode 100644
index 00000000..4fcd9227
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/browser_context/__init__.py
@@ -0,0 +1,2 @@
+"""Browser-backed page context helpers."""
+
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/browser_context/tasks.py b/offline-backend-20260512/backend/packages/harness/deerflow/browser_context/tasks.py
new file mode 100644
index 00000000..9a8d2f51
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/browser_context/tasks.py
@@ -0,0 +1,303 @@
+"""Small file-backed task queue for browser page fetch requests."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import re
+import threading
+import time
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+from typing import Any
+from uuid import uuid4
+
+from deerflow.config.runtime_paths import runtime_home
+
+logger = logging.getLogger(__name__)
+
+_LOCK = threading.RLock()
+_TASK_ID_RE = re.compile(r"^[a-f0-9]{32}$")
+_TERMINAL_STATUSES = {"done", "error", "expired"}
+
+
+def tasks_dir() -> Path:
+    """Return the browser-context task directory, creating it if needed."""
+
+    path = runtime_home() / "browser-context" / "tasks"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _now() -> datetime:
+    return datetime.now(UTC)
+
+
+def _iso(value: datetime | None = None) -> str:
+    return (value or _now()).isoformat()
+
+
+def _parse_iso(value: Any) -> datetime | None:
+    if not isinstance(value, str) or not value:
+        return None
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=UTC)
+    return parsed.astimezone(UTC)
+
+
+def _task_path(task_id: str) -> Path | None:
+    if not _TASK_ID_RE.fullmatch(task_id or ""):
+        return None
+    return tasks_dir() / f"{task_id}.json"
+
+
+def _read_task(path: Path) -> dict[str, Any] | None:
+    try:
+        with path.open("r", encoding="utf-8") as fh:
+            data = json.load(fh)
+    except FileNotFoundError:
+        return None
+    except Exception:
+        logger.warning("Ignoring unreadable browser task file: %s", path, exc_info=True)
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def _write_task(path: Path, data: dict[str, Any]) -> None:
+    tmp = path.with_name(f"{path.name}.{uuid4().hex}.tmp")
+    with tmp.open("w", encoding="utf-8") as fh:
+        json.dump(data, fh, ensure_ascii=False, separators=(",", ":"))
+    tmp.replace(path)
+
+
+def _public_task(data: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "id": data.get("id"),
+        "kind": data.get("kind") or "fetch",
+        "url": data.get("url") or "",
+        "instruction": data.get("instruction") or "",
+        "session_id": data.get("session_id") or "",
+        "action": data.get("action") or None,
+        "created_at": data.get("created_at") or "",
+        "updated_at": data.get("updated_at") or "",
+        "max_content_chars": int(data.get("max_content_chars") or 200_000),
+    }
+
+
+def _expire_if_needed(path: Path, data: dict[str, Any], now: datetime) -> dict[str, Any]:
+    if data.get("status") in _TERMINAL_STATUSES:
+        return data
+    expires_at = _parse_iso(data.get("expires_at"))
+    if expires_at is not None and now >= expires_at:
+        data = dict(data)
+        data["status"] = "expired"
+        data["error"] = "Browser task expired before the extension returned a result."
+        data["updated_at"] = _iso(now)
+        _write_task(path, data)
+    return data
+
+
+def prune_browser_tasks(max_age_seconds: int = 86_400) -> int:
+    """Delete old terminal tasks and return the number removed."""
+
+    cutoff = _now() - timedelta(seconds=max(60, int(max_age_seconds)))
+    removed = 0
+    with _LOCK:
+        for path in tasks_dir().glob("*.json"):
+            data = _read_task(path)
+            if not data or data.get("status") not in _TERMINAL_STATUSES:
+                continue
+            updated_at = _parse_iso(data.get("updated_at")) or _parse_iso(data.get("created_at"))
+            if updated_at is None or updated_at < cutoff:
+                try:
+                    path.unlink()
+                    removed += 1
+                except OSError:
+                    logger.debug("Failed to delete old browser task: %s", path, exc_info=True)
+    return removed
+
+
+def create_browser_task(
+    *,
+    user_id: str,
+    url: str,
+    instruction: str = "",
+    timeout_seconds: int = 60,
+    max_content_chars: int = 200_000,
+    metadata: dict[str, Any] | None = None,
+    kind: str = "fetch",
+    session_id: str = "",
+    action: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Create a browser task for the current user's extension to pick up.
+
+    ``kind`` is ``"fetch"`` for one-shot page captures (the legacy behavior) or
+    ``"act"`` for an interactive observe/act step driven by ``action`` within a
+    long-lived ``session_id`` (a tab kept open by the extension).
+    """
+
+    now = _now()
+    task_id = uuid4().hex
+    task = {
+        "id": task_id,
+        "user_id": str(user_id or "default"),
+        "status": "pending",
+        "kind": kind if kind in {"fetch", "act"} else "fetch",
+        "url": url,
+        "instruction": instruction or "",
+        "session_id": str(session_id or ""),
+        "action": action or None,
+        "created_at": _iso(now),
+        "updated_at": _iso(now),
+        "expires_at": _iso(now + timedelta(seconds=max(5, int(timeout_seconds)))),
+        "max_content_chars": max(1_000, int(max_content_chars)),
+        "worker_id": None,
+        "claimed_at": None,
+        "result": None,
+        "error": None,
+        "metadata": metadata or {},
+    }
+    path = tasks_dir() / f"{task_id}.json"
+    with _LOCK:
+        _write_task(path, task)
+    return task
+
+
+def get_browser_task(*, task_id: str, user_id: str) -> dict[str, Any] | None:
+    """Read a task if it belongs to the requested user."""
+
+    path = _task_path(task_id)
+    if path is None:
+        return None
+    with _LOCK:
+        data = _read_task(path)
+        if not data or str(data.get("user_id") or "") != str(user_id or "default"):
+            return None
+        return _expire_if_needed(path, data, _now())
+
+
+def claim_next_browser_task(
+    *,
+    user_id: str,
+    worker_id: str,
+    lease_seconds: int = 120,
+) -> dict[str, Any] | None:
+    """Claim the oldest pending task for a user."""
+
+    now = _now()
+    user_id = str(user_id or "default")
+    worker_id = (worker_id or "chrome-extension").strip()[:128] or "chrome-extension"
+    lease_seconds = max(10, int(lease_seconds))
+
+    with _LOCK:
+        paths = sorted(tasks_dir().glob("*.json"), key=lambda p: p.stat().st_mtime)
+        for path in paths:
+            data = _read_task(path)
+            if not data or str(data.get("user_id") or "") != user_id:
+                continue
+
+            data = _expire_if_needed(path, data, now)
+            status = data.get("status")
+            if status == "running":
+                updated_at = _parse_iso(data.get("updated_at")) or now
+                if (now - updated_at).total_seconds() <= lease_seconds:
+                    continue
+                status = "pending"
+                data = dict(data)
+                data["status"] = status
+
+            if status != "pending":
+                continue
+
+            data = dict(data)
+            data["status"] = "running"
+            data["worker_id"] = worker_id
+            data["claimed_at"] = _iso(now)
+            data["updated_at"] = _iso(now)
+            _write_task(path, data)
+            return _public_task(data)
+
+    return None
+
+
+def complete_browser_task(
+    *,
+    task_id: str,
+    user_id: str,
+    title: str = "",
+    url: str = "",
+    content: str = "",
+    content_type: str = "markdown",
+    error: str = "",
+    metadata: dict[str, Any] | None = None,
+    observation: dict[str, Any] | None = None,
+) -> dict[str, Any] | None:
+    """Mark a browser task complete or failed.
+
+    For ``act`` tasks the extension returns a structured ``observation`` (final
+    URL/title, interactive element list, page text) instead of a captured
+    markdown document; it is stored alongside the result verbatim.
+    """
+
+    path = _task_path(task_id)
+    if path is None:
+        return None
+
+    now = _now()
+    with _LOCK:
+        data = _read_task(path)
+        if not data or str(data.get("user_id") or "") != str(user_id or "default"):
+            return None
+
+        data = dict(data)
+        if error:
+            data["status"] = "error"
+            data["error"] = str(error).strip()[:4000]
+            data["result"] = None
+        else:
+            raw_content = str(content or "").strip()
+            max_content_chars = max(1_000, int(data.get("max_content_chars") or 200_000))
+            truncated = len(raw_content) > max_content_chars
+            data["status"] = "done"
+            data["error"] = None
+            data["result"] = {
+                "title": str(title or "").strip()[:500],
+                "url": str(url or data.get("url") or "").strip()[:4096],
+                "content": raw_content[:max_content_chars] if truncated else raw_content,
+                "content_type": content_type if content_type in {"markdown", "text"} else "markdown",
+                "truncated": truncated,
+                "observation": observation if isinstance(observation, dict) else None,
+                "captured_at": _iso(now),
+                "metadata": metadata or {},
+            }
+        data["updated_at"] = _iso(now)
+        _write_task(path, data)
+        return data
+
+
+async def wait_for_browser_task_result(
+    *,
+    task_id: str,
+    user_id: str,
+    timeout_seconds: int,
+    poll_interval_seconds: float = 1.0,
+) -> dict[str, Any] | None:
+    """Wait for a browser task to reach a terminal state."""
+
+    deadline = time.monotonic() + max(1, int(timeout_seconds))
+    interval = max(0.25, float(poll_interval_seconds))
+    while True:
+        task = get_browser_task(task_id=task_id, user_id=user_id)
+        if task is None:
+            return None
+        if task.get("status") in _TERMINAL_STATUSES:
+            return task
+        if time.monotonic() >= deadline:
+            return task
+        await asyncio.sleep(interval)
+
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/config/app_config.py b/offline-backend-20260512/backend/packages/harness/deerflow/config/app_config.py
index f1494bb6..543e546d 100644
--- a/offline-backend-20260512/backend/packages/harness/deerflow/config/app_config.py
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/config/app_config.py
@@ -10,11 +10,13 @@ from pydantic import BaseModel, ConfigDict, Field
 
 from deerflow.config.acp_config import ACPAgentConfig, load_acp_config_from_dict
 from deerflow.config.agents_api_config import AgentsApiConfig, load_agents_api_config_from_dict
+from deerflow.config.browser_context_config import BrowserContextConfig
 from deerflow.config.checkpointer_config import CheckpointerConfig, load_checkpointer_config_from_dict
 from deerflow.config.database_config import DatabaseConfig
 from deerflow.config.extensions_config import ExtensionsConfig
 from deerflow.config.gateway_config import GatewayConfig
 from deerflow.config.guardrails_config import GuardrailsConfig, load_guardrails_config_from_dict
+from deerflow.config.knowledge_config import KnowledgeConfig
 from deerflow.config.log_system_config import LogSystemConfig
 from deerflow.config.login_config import AuthLoginConfig
 from deerflow.config.memory_config import MemoryConfig, load_memory_config_from_dict
@@ -133,6 +135,8 @@ class AppConfig(BaseModel):
     run_events: RunEventsConfig = Field(default_factory=RunEventsConfig, description="Run event storage configuration")
     checkpointer: CheckpointerConfig | None = Field(default=None, description="Checkpointer configuration")
     stream_bridge: StreamBridgeConfig | None = Field(default=None, description="Stream bridge configuration")
+    browser_context: BrowserContextConfig = Field(default_factory=BrowserContextConfig, description="Optional browser page capture integration")
+    knowledge: KnowledgeConfig = Field(default_factory=KnowledgeConfig, description="Product knowledge base (obsidian-wiki compatible vault) configuration")
 
     @classmethod
     def resolve_config_path(cls, config_path: str | None = None) -> Path:
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/config/browser_context_config.py b/offline-backend-20260512/backend/packages/harness/deerflow/config/browser_context_config.py
new file mode 100644
index 00000000..fdbfed8b
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/config/browser_context_config.py
@@ -0,0 +1,74 @@
+"""Configuration for browser page context capture."""
+
+from pydantic import BaseModel, Field
+
+
+class BrowserContextConfig(BaseModel):
+    """Controls the optional Chrome-extension page capture integration."""
+
+    enabled: bool = Field(
+        default=False,
+        description="Enable /api/browser-context endpoints for Chrome extension page capture.",
+    )
+    max_content_chars: int = Field(
+        default=200_000,
+        ge=1_000,
+        description="Maximum captured page text stored per request. Longer content is truncated.",
+    )
+    max_title_chars: int = Field(
+        default=300,
+        ge=20,
+        description="Maximum title length accepted from the browser extension.",
+    )
+    max_url_chars: int = Field(
+        default=2_048,
+        ge=100,
+        description="Maximum source URL length accepted from the browser extension.",
+    )
+    filename_prefix: str = Field(
+        default="webpage",
+        description="Prefix used for Markdown files created from captured pages.",
+    )
+    route_base: str = Field(
+        default="/page/workspace",
+        description="Frontend route base used when returning chat paths to the extension.",
+    )
+    task_result_timeout_seconds: int = Field(
+        default=60,
+        ge=5,
+        description="Maximum time the browser_fetch_page tool waits for the extension result.",
+    )
+    task_poll_interval_seconds: float = Field(
+        default=1.0,
+        ge=0.25,
+        description="How often the backend tool checks for a returned browser task result.",
+    )
+    task_lease_seconds: int = Field(
+        default=120,
+        ge=10,
+        description="How long a claimed browser task is reserved before another extension may retry it.",
+    )
+    tool_result_max_chars: int = Field(
+        default=60_000,
+        ge=1_000,
+        description="Maximum page characters returned from browser_fetch_page into the model context.",
+    )
+    actions_enabled: bool = Field(
+        default=True,
+        description="Enable the interactive browser_act tool (click/type/scroll/wait/navigate on the user's page).",
+    )
+    action_result_timeout_seconds: int = Field(
+        default=45,
+        ge=5,
+        description="Maximum time the browser_act tool waits for the extension to perform one step and return an observation.",
+    )
+    max_observed_elements: int = Field(
+        default=150,
+        ge=10,
+        description="Maximum number of interactive elements returned in a browser_act observation.",
+    )
+    observation_text_max_chars: int = Field(
+        default=12_000,
+        ge=500,
+        description="Maximum page text characters returned alongside a browser_act observation.",
+    )
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/config/extensions_config.py b/offline-backend-20260512/backend/packages/harness/deerflow/config/extensions_config.py
index 78ebbf6c..0a0c9f1f 100644
--- a/offline-backend-20260512/backend/packages/harness/deerflow/config/extensions_config.py
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/config/extensions_config.py
@@ -3,7 +3,7 @@
 import json
 import os
 from pathlib import Path
-from typing import Any, Literal
+from typing import Any, Literal
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -53,115 +53,115 @@ class McpServerConfig(BaseModel):
     model_config = ConfigDict(extra="allow", populate_by_name=True)
 
 
-class SkillDisplayTableColumn(BaseModel):
-    """A configured table column for structured skill result display."""
-
-    label: str = Field(description="Column label shown in the frontend table")
-    field: str = Field(description="Field name or dot path read from each result item")
-    width: str | None = Field(default=None, description="Optional CSS width for this column")
-    model_config = ConfigDict(extra="allow", populate_by_name=True)
-
-
-class SkillDisplayResultSetConfig(BaseModel):
-    """Display adapter for one result array inside a skill response."""
-
-    key: str = Field(description="Stable key for this result set")
-    label: str | None = Field(default=None, description="Human-readable result set label")
-    enabled: bool = Field(default=True, description="Whether this result set is enabled")
-    mode: Literal["citation", "list", "table", "card", "custom", "none"] = Field(
-        default="citation",
-        description="How the frontend should render this result set",
-    )
-    result_path: str = Field(default="results", description="Dot path to the array of result items", alias="resultPath")
-    title_field: str | None = Field(default=None, description="Field used as item title", alias="titleField")
-    summary_field: str | None = Field(default=None, description="Field used as short summary/snippet", alias="summaryField")
-    content_field: str | None = Field(default=None, description="Field used as full item content", alias="contentField")
-    source_field: str | None = Field(default=None, description="Field used as source label", alias="sourceField")
-    author_field: str | None = Field(default=None, description="Field used as author/byline label", alias="authorField")
-    type_field: str | None = Field(default=None, description="Field used as source/type badge", alias="typeField")
-    time_field: str | None = Field(default=None, description="Field used as publication/update time", alias="timeField")
-    score_field: str | None = Field(default=None, description="Field used as relevance score", alias="scoreField")
-    url_field: str | None = Field(default=None, description="Field containing a direct URL", alias="urlField")
-    id_field: str | None = Field(default=None, description="Field containing an ID for template URLs", alias="idField")
-    link_strategy: Literal["auto", "url", "id"] = Field(
-        default="auto",
-        description="Whether links use a URL field, an ID template, or automatic fallback",
-        alias="linkStrategy",
-    )
-    link_template: str | None = Field(default=None, description="Template used when linkStrategy is id", alias="linkTemplate")
-    citation_token: Literal["doubleBracket", "singleBracket"] = Field(
-        default="singleBracket",
-        description="Citation token style expected in model output",
-        alias="citationToken",
-    )
-    max_items: int = Field(default=100, ge=1, le=100, description="Maximum displayed items", alias="maxItems")
-    custom_instruction: str = Field(
-        default="",
-        description="User-authored instruction for custom rendering schema generation",
-        alias="customInstruction",
-    )
-    table_columns: list[SkillDisplayTableColumn] = Field(
-        default_factory=list,
-        description="Columns used when mode is table",
-        alias="tableColumns",
-    )
-    model_config = ConfigDict(extra="allow", populate_by_name=True)
-
-
-class SkillDisplayConfig(BaseModel):
-    """Frontend display adapter for structured skill results."""
-
-    enabled: bool = Field(default=False, description="Whether result display adaptation is enabled")
-    mode: Literal["citation", "list", "table", "card", "custom", "none"] = Field(
-        default="none",
-        description="How the frontend should render this skill's structured results",
-    )
-    result_path: str = Field(default="results", description="Dot path to the array of result items", alias="resultPath")
-    title_field: str | None = Field(default=None, description="Field used as item title", alias="titleField")
-    summary_field: str | None = Field(default=None, description="Field used as short summary/snippet", alias="summaryField")
-    content_field: str | None = Field(default=None, description="Field used as full item content", alias="contentField")
-    source_field: str | None = Field(default=None, description="Field used as source label", alias="sourceField")
-    author_field: str | None = Field(default=None, description="Field used as author/byline label", alias="authorField")
-    type_field: str | None = Field(default=None, description="Field used as source/type badge", alias="typeField")
-    time_field: str | None = Field(default=None, description="Field used as publication/update time", alias="timeField")
-    score_field: str | None = Field(default=None, description="Field used as relevance score", alias="scoreField")
-    url_field: str | None = Field(default=None, description="Field containing a direct URL", alias="urlField")
-    id_field: str | None = Field(default=None, description="Field containing an ID for template URLs", alias="idField")
-    link_strategy: Literal["auto", "url", "id"] = Field(
-        default="auto",
-        description="Whether links use a URL field, an ID template, or automatic fallback",
-        alias="linkStrategy",
-    )
-    link_template: str | None = Field(default=None, description="Template used when linkStrategy is id", alias="linkTemplate")
-    citation_token: Literal["doubleBracket", "singleBracket"] = Field(
-        default="doubleBracket",
-        description="Citation token style expected in model output",
-        alias="citationToken",
-    )
-    max_items: int = Field(default=8, ge=1, le=100, description="Maximum displayed items", alias="maxItems")
-    custom_instruction: str = Field(
-        default="",
-        description="User-authored instruction for custom rendering schema generation",
-        alias="customInstruction",
-    )
-    table_columns: list[SkillDisplayTableColumn] = Field(
-        default_factory=list,
-        description="Columns used when mode is table",
-        alias="tableColumns",
-    )
-    result_sets: list[SkillDisplayResultSetConfig] = Field(
-        default_factory=list,
-        description="Optional per-result-array display adapters",
-        alias="resultSets",
-    )
-    model_config = ConfigDict(extra="allow", populate_by_name=True)
-
-
-class SkillStateConfig(BaseModel):
-    """Configuration for a single skill's state."""
-
-    enabled: bool = Field(default=True, description="Whether this skill is enabled")
-    display: SkillDisplayConfig | None = Field(default=None, description="Optional frontend display adapter")
+class SkillDisplayTableColumn(BaseModel):
+    """A configured table column for structured skill result display."""
+
+    label: str = Field(description="Column label shown in the frontend table")
+    field: str = Field(description="Field name or dot path read from each result item")
+    width: str | None = Field(default=None, description="Optional CSS width for this column")
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+
+class SkillDisplayResultSetConfig(BaseModel):
+    """Display adapter for one result array inside a skill response."""
+
+    key: str = Field(description="Stable key for this result set")
+    label: str | None = Field(default=None, description="Human-readable result set label")
+    enabled: bool = Field(default=True, description="Whether this result set is enabled")
+    mode: Literal["citation", "list", "table", "card", "custom", "none"] = Field(
+        default="citation",
+        description="How the frontend should render this result set",
+    )
+    result_path: str = Field(default="results", description="Dot path to the array of result items", alias="resultPath")
+    title_field: str | None = Field(default=None, description="Field used as item title", alias="titleField")
+    summary_field: str | None = Field(default=None, description="Field used as short summary/snippet", alias="summaryField")
+    content_field: str | None = Field(default=None, description="Field used as full item content", alias="contentField")
+    source_field: str | None = Field(default=None, description="Field used as source label", alias="sourceField")
+    author_field: str | None = Field(default=None, description="Field used as author/byline label", alias="authorField")
+    type_field: str | None = Field(default=None, description="Field used as source/type badge", alias="typeField")
+    time_field: str | None = Field(default=None, description="Field used as publication/update time", alias="timeField")
+    score_field: str | None = Field(default=None, description="Field used as relevance score", alias="scoreField")
+    url_field: str | None = Field(default=None, description="Field containing a direct URL", alias="urlField")
+    id_field: str | None = Field(default=None, description="Field containing an ID for template URLs", alias="idField")
+    link_strategy: Literal["auto", "url", "id"] = Field(
+        default="auto",
+        description="Whether links use a URL field, an ID template, or automatic fallback",
+        alias="linkStrategy",
+    )
+    link_template: str | None = Field(default=None, description="Template used when linkStrategy is id", alias="linkTemplate")
+    citation_token: Literal["doubleBracket", "singleBracket"] = Field(
+        default="singleBracket",
+        description="Citation token style expected in model output",
+        alias="citationToken",
+    )
+    max_items: int = Field(default=100, ge=1, le=100, description="Maximum displayed items", alias="maxItems")
+    custom_instruction: str = Field(
+        default="",
+        description="User-authored instruction for custom rendering schema generation",
+        alias="customInstruction",
+    )
+    table_columns: list[SkillDisplayTableColumn] = Field(
+        default_factory=list,
+        description="Columns used when mode is table",
+        alias="tableColumns",
+    )
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+
+class SkillDisplayConfig(BaseModel):
+    """Frontend display adapter for structured skill results."""
+
+    enabled: bool = Field(default=False, description="Whether result display adaptation is enabled")
+    mode: Literal["citation", "list", "table", "card", "custom", "none"] = Field(
+        default="none",
+        description="How the frontend should render this skill's structured results",
+    )
+    result_path: str = Field(default="results", description="Dot path to the array of result items", alias="resultPath")
+    title_field: str | None = Field(default=None, description="Field used as item title", alias="titleField")
+    summary_field: str | None = Field(default=None, description="Field used as short summary/snippet", alias="summaryField")
+    content_field: str | None = Field(default=None, description="Field used as full item content", alias="contentField")
+    source_field: str | None = Field(default=None, description="Field used as source label", alias="sourceField")
+    author_field: str | None = Field(default=None, description="Field used as author/byline label", alias="authorField")
+    type_field: str | None = Field(default=None, description="Field used as source/type badge", alias="typeField")
+    time_field: str | None = Field(default=None, description="Field used as publication/update time", alias="timeField")
+    score_field: str | None = Field(default=None, description="Field used as relevance score", alias="scoreField")
+    url_field: str | None = Field(default=None, description="Field containing a direct URL", alias="urlField")
+    id_field: str | None = Field(default=None, description="Field containing an ID for template URLs", alias="idField")
+    link_strategy: Literal["auto", "url", "id"] = Field(
+        default="auto",
+        description="Whether links use a URL field, an ID template, or automatic fallback",
+        alias="linkStrategy",
+    )
+    link_template: str | None = Field(default=None, description="Template used when linkStrategy is id", alias="linkTemplate")
+    citation_token: Literal["doubleBracket", "singleBracket"] = Field(
+        default="doubleBracket",
+        description="Citation token style expected in model output",
+        alias="citationToken",
+    )
+    max_items: int = Field(default=8, ge=1, le=100, description="Maximum displayed items", alias="maxItems")
+    custom_instruction: str = Field(
+        default="",
+        description="User-authored instruction for custom rendering schema generation",
+        alias="customInstruction",
+    )
+    table_columns: list[SkillDisplayTableColumn] = Field(
+        default_factory=list,
+        description="Columns used when mode is table",
+        alias="tableColumns",
+    )
+    result_sets: list[SkillDisplayResultSetConfig] = Field(
+        default_factory=list,
+        description="Optional per-result-array display adapters",
+        alias="resultSets",
+    )
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+
+class SkillStateConfig(BaseModel):
+    """Configuration for a single skill's state."""
+
+    enabled: bool = Field(default=True, description="Whether this skill is enabled")
+    display: SkillDisplayConfig | None = Field(default=None, description="Optional frontend display adapter")
 
 
 class ExtensionsConfig(BaseModel):
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/config/knowledge_config.py b/offline-backend-20260512/backend/packages/harness/deerflow/config/knowledge_config.py
new file mode 100644
index 00000000..d30d0c4c
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/config/knowledge_config.py
@@ -0,0 +1,75 @@
+"""Configuration for the product knowledge base (obsidian-wiki compatible)."""
+
+from pydantic import BaseModel, Field
+
+
+class KnowledgeExportConfig(BaseModel):
+    """Knowledge graph export switches (``wiki-export`` compatible output)."""
+
+    enabled: bool = Field(default=True, description="Master switch for graph export.")
+    graph_html_enabled: bool = Field(default=True, description="Generate wiki-export/graph.html.")
+    graph_json_enabled: bool = Field(default=True, description="Generate wiki-export/graph.json.")
+
+
+class KnowledgeQueryConfig(BaseModel):
+    """Layered query strategy flags (``wiki-query`` style)."""
+
+    use_hot_md: bool = Field(default=True, description="Consult hot.md when searching.")
+    use_index_md: bool = Field(default=True, description="Consult index.md when searching.")
+    use_frontmatter_scan: bool = Field(default=True, description="Scan frontmatter when searching.")
+
+
+class KnowledgeEmbeddingConfig(BaseModel):
+    """Vector embedding config (phase 2).
+
+    Vector RAG is opt-in: set ``enabled: true`` and point ``base_url`` at an
+    OpenAI-compatible ``/embeddings`` endpoint. When disabled or unreachable,
+    search transparently falls back to keyword scoring, so the feature degrades
+    gracefully on offline deployments without an embedding model.
+    """
+
+    enabled: bool = Field(default=False, description="Enable vector embeddings.")
+    provider: str = Field(default="openai", description="Embedding provider (openai-compatible).")
+    model: str = Field(default="", description="Embedding model name, e.g. text-embedding-3-small / bge-m3.")
+    base_url: str = Field(default="", description="OpenAI-compatible base URL (…/v1). Empty disables vector mode.")
+    api_key: str = Field(default="", description="API key for the embedding endpoint ($ENV resolved like other config).")
+    dimensions: int | None = Field(default=None, description="Optional embedding dimensions hint sent to the endpoint.")
+    batch_size: int = Field(default=32, description="Texts per embedding request.")
+    timeout_seconds: int = Field(default=30, description="HTTP timeout per embedding request.")
+
+
+class KnowledgeConfig(BaseModel):
+    """Product knowledge base configuration.
+
+    The first release ships a global, shared, obsidian-wiki compatible vault.
+    Knowledge metadata is mirrored into the database for fast listing/search,
+    while ``content_md`` is written to a Markdown vault that stays compatible
+    with ``ar9av/obsidian-wiki`` (index.md / log.md / hot.md / .manifest.json,
+    frontmatter, wikilinks, wiki-export graph artifacts).
+    """
+
+    enabled: bool = Field(default=True, description="Enable the knowledge base feature.")
+    provider: str = Field(default="obsidian_wiki", description="Knowledge organization provider.")
+    vault_dir: str = Field(
+        default="data/knowledge/obsidian-vault",
+        description="Vault directory (relative to DEER_FLOW_HOME, or absolute).",
+    )
+    project_name: str = Field(default="zncm", description="Project namespace for projects/<name>/ pages.")
+    auto_ingest_enabled: bool = Field(default=False, description="Auto-sediment conversations in the background (phase 3).")
+    auto_ingest_min_chars: int = Field(default=300, description="Minimum characters before auto-ingest considers a turn.")
+    llm_extract_enabled: bool = Field(default=True, description="Distill notes with an LLM (wiki-capture style) instead of the rule-based fallback.")
+    extract_model_name: str | None = Field(default=None, description="Model (from models[]) used to distill knowledge. Falls back to models[0] when unset.")
+    extract_max_input_chars: int = Field(default=12000, description="Max characters of conversation transcript fed to the extraction LLM.")
+    max_thread_messages: int = Field(default=80, description="Maximum thread messages to scan when capturing.")
+    max_source_items: int = Field(default=20, description="Maximum source items recorded per note.")
+    related_notes_enabled: bool = Field(default=True, description="On capture, find existing notes on the same topic and link them under ## Related (real cross-references instead of placeholders).")
+    related_notes_limit: int = Field(default=3, description="Maximum real related notes linked into each captured note.")
+    multi_note_enabled: bool = Field(default=True, description="Allow the LLM extractor to split one conversation into multiple cross-linked knowledge notes.")
+    rag_enabled: bool = Field(default=False, description="Enable RAG injection before agent runs (phase 2).")
+    rag_limit: int = Field(default=5, description="Maximum knowledge snippets injected per query.")
+    sensitive_redaction_enabled: bool = Field(default=True, description="Redact secrets/PII (tokens, keys, phone, id-card, email) before persisting notes (phase 3).")
+    dedup_similarity_threshold: float = Field(default=0.82, description="Title/summary similarity above which two notes are flagged as duplicates (phase 3).")
+    entity_extraction_enabled: bool = Field(default=True, description="Extract entities/relations during LLM distillation and feed them into the graph (phase 4).")
+    export: KnowledgeExportConfig = Field(default_factory=KnowledgeExportConfig, description="Graph export configuration.")
+    query: KnowledgeQueryConfig = Field(default_factory=KnowledgeQueryConfig, description="Layered query configuration.")
+    embedding: KnowledgeEmbeddingConfig = Field(default_factory=KnowledgeEmbeddingConfig, description="Embedding configuration.")
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/__init__.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/__init__.py
new file mode 100644
index 00000000..ee3e83e5
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/__init__.py
@@ -0,0 +1,41 @@
+"""Product knowledge base module (obsidian-wiki compatible).
+
+Self-contained: knowledge ingestion, storage (DB mirror + Markdown vault),
+search and graph export all live here. The Gateway only depends on
+:class:`KnowledgeService` via :func:`make_knowledge_service`.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from deerflow.knowledge.obsidian_adapter import ObsidianWikiAdapter
+from deerflow.knowledge.repository import KnowledgeRepository
+from deerflow.knowledge.service import EmptyThreadError, KnowledgeService
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+    from deerflow.config.knowledge_config import KnowledgeConfig
+
+__all__ = [
+    "EmptyThreadError",
+    "KnowledgeRepository",
+    "KnowledgeService",
+    "ObsidianWikiAdapter",
+    "make_knowledge_service",
+]
+
+
+def make_knowledge_service(
+    session_factory: async_sessionmaker[AsyncSession] | None,
+    config: KnowledgeConfig,
+) -> KnowledgeService | None:
+    """Build the knowledge service.
+
+    Returns ``None`` when persistence is memory-only (no session factory) or
+    the feature is disabled — the router then responds 503.
+    """
+    if session_factory is None or not config.enabled:
+        return None
+    return KnowledgeService(KnowledgeRepository(session_factory), config)
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/auto_ingest.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/auto_ingest.py
new file mode 100644
index 00000000..a3c5cef5
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/auto_ingest.py
@@ -0,0 +1,125 @@
+"""Background auto-sediment queue (phase 3).
+
+A single asyncio worker drains a bounded queue of finished conversations and
+sediments the worthwhile ones into the knowledge base — entirely off the chat
+request path, so it never adds latency to a reply. Enqueue happens from
+``KnowledgeRagMiddleware.after_agent`` when ``knowledge.auto_ingest_enabled``.
+
+Value judgment is intentionally cheap (min assistant chars + dedup via
+``skip_existing``); the LLM still distills the kept conversations via the normal
+``capture_thread`` path.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_QUEUE: AutoIngestQueue | None = None
+
+
+@dataclass
+class _QueueUser:
+    """Minimal CurrentUser stand-in (only ``.id`` is needed for context)."""
+
+    id: str
+
+
+@dataclass
+class AutoIngestItem:
+    thread_id: str
+    user_id: str
+    messages: list[dict[str, Any]]
+    thread_title: str | None = None
+    reference_batches: list[dict[str, Any]] = field(default_factory=list)
+
+
+class AutoIngestQueue:
+    """Bounded background queue + single worker for auto-sedimentation."""
+
+    def __init__(self, service_provider: Callable[[], Any], *, min_chars: int = 300, maxsize: int = 256) -> None:
+        self._provider = service_provider
+        self._min_chars = min_chars
+        self._queue: asyncio.Queue[AutoIngestItem] = asyncio.Queue(maxsize=maxsize)
+        self._task: asyncio.Task | None = None
+
+    def start(self) -> None:
+        if self._task is None or self._task.done():
+            self._task = asyncio.create_task(self._worker(), name="knowledge-auto-ingest")
+            logger.info("Knowledge auto-ingest worker started")
+
+    async def stop(self) -> None:
+        if self._task is not None:
+            self._task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._task
+            self._task = None
+
+    def enqueue(self, item: AutoIngestItem) -> None:
+        try:
+            self._queue.put_nowait(item)
+        except asyncio.QueueFull:
+            logger.warning("Knowledge auto-ingest queue full; dropping thread %s", item.thread_id)
+
+    def _worth_ingesting(self, item: AutoIngestItem) -> bool:
+        chars = 0
+        for m in item.messages:
+            if str(m.get("type") or m.get("role") or "").lower() == "ai":
+                content = m.get("content")
+                chars += len(content) if isinstance(content, str) else len(str(content or ""))
+        return chars >= self._min_chars
+
+    async def _process(self, item: AutoIngestItem) -> None:
+        service = self._provider()
+        if service is None:
+            return
+        if not self._worth_ingesting(item):
+            logger.debug("Auto-ingest skipped (below min chars) thread=%s", item.thread_id)
+            return
+        from deerflow.runtime.user_context import reset_current_user, set_current_user
+
+        token = set_current_user(_QueueUser(id=item.user_id))
+        try:
+            result = await service.capture_thread(
+                thread_id=item.thread_id,
+                messages=item.messages,
+                thread_title=item.thread_title,
+                status="draft",  # auto-sedimented notes land as drafts for review
+                include_sources=True,
+                reference_batches=item.reference_batches,
+                created_by=item.user_id,
+                skip_existing=True,
+            )
+            if result.get("created"):
+                logger.info("Auto-ingested thread %s -> note %s", item.thread_id, result["note"]["id"])
+        except Exception:
+            logger.exception("Auto-ingest failed for thread %s", item.thread_id)
+        finally:
+            reset_current_user(token)
+
+    async def _worker(self) -> None:
+        while True:
+            item = await self._queue.get()
+            try:
+                await self._process(item)
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                logger.exception("Auto-ingest worker error")
+            finally:
+                self._queue.task_done()
+
+
+def set_auto_ingest_queue(queue: AutoIngestQueue | None) -> None:
+    global _QUEUE
+    _QUEUE = queue
+
+
+def get_auto_ingest_queue() -> AutoIngestQueue | None:
+    return _QUEUE
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/chunking.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/chunking.py
new file mode 100644
index 00000000..7897d8c1
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/chunking.py
@@ -0,0 +1,60 @@
+"""Markdown chunking for embedding/index (phase 2).
+
+Splits a note body into overlapping chunks along Markdown structure (headings →
+paragraphs) so each embedded chunk is semantically coherent and bounded in
+size. Frontmatter is assumed already stripped by the caller.
+"""
+
+from __future__ import annotations
+
+import re
+
+_HEADING_RE = re.compile(r"^#{1,6}\s+", re.MULTILINE)
+
+
+def _split_paragraphs(text: str) -> list[str]:
+    return [p.strip() for p in re.split(r"\n\s*\n", text) if p.strip()]
+
+
+def chunk_markdown(content: str, *, max_chars: int = 800, overlap: int = 120) -> list[str]:
+    """Return a list of text chunks for ``content``.
+
+    Sections are cut at Markdown headings; long sections are further split into
+    ~``max_chars`` windows with ``overlap`` characters of carry-over.
+    """
+    text = (content or "").strip()
+    if not text:
+        return []
+
+    # Split into heading-delimited sections, keeping the heading with its body.
+    sections: list[str] = []
+    last = 0
+    for m in _HEADING_RE.finditer(text):
+        if m.start() > last:
+            sections.append(text[last : m.start()].strip())
+        last = m.start()
+    sections.append(text[last:].strip())
+    sections = [s for s in sections if s]
+
+    chunks: list[str] = []
+    for section in sections:
+        if len(section) <= max_chars:
+            chunks.append(section)
+            continue
+        # Pack paragraphs into windows, then hard-split anything still too long.
+        buf = ""
+        for para in _split_paragraphs(section):
+            if len(buf) + len(para) + 2 <= max_chars:
+                buf = f"{buf}\n\n{para}".strip()
+            else:
+                if buf:
+                    chunks.append(buf)
+                if len(para) <= max_chars:
+                    buf = para
+                else:
+                    for i in range(0, len(para), max_chars - overlap):
+                        chunks.append(para[i : i + max_chars])
+                    buf = ""
+        if buf:
+            chunks.append(buf)
+    return [c for c in chunks if c.strip()]
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/dedup.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/dedup.py
new file mode 100644
index 00000000..936bd9e0
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/dedup.py
@@ -0,0 +1,75 @@
+"""Duplicate detection for knowledge notes (phase 3).
+
+First-release heuristic: token Jaccard over ``title + summary + tags`` plus an
+exact ``content_md`` hash match. Cheap, deterministic and embedding-free so it
+works on offline deployments. Returns *suggestions*; merging is an explicit,
+user-driven action.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from deerflow.knowledge.manifest import content_hash
+
+_TOKEN_RE = re.compile(r"[\w一-鿿]+", re.UNICODE)
+
+
+def _tokens(*texts: str) -> set[str]:
+    out: set[str] = set()
+    for t in texts:
+        out.update(m.lower() for m in _TOKEN_RE.findall(t or ""))
+    return out
+
+
+def _jaccard(a: set[str], b: set[str]) -> float:
+    if not a or not b:
+        return 0.0
+    inter = len(a & b)
+    union = len(a | b)
+    return inter / union if union else 0.0
+
+
+def find_duplicate_groups(notes: list[dict[str, Any]], *, threshold: float = 0.82, max_notes: int = 800) -> list[dict[str, Any]]:
+    """Return groups ``{primary, duplicates:[{id,title,score,reason}]}``.
+
+    ``primary`` is the most recently updated note in each cluster.
+    """
+    notes = notes[:max_notes]
+    feats: list[tuple[dict[str, Any], set[str], str]] = []
+    for n in notes:
+        toks = _tokens(n.get("title") or "", n.get("summary") or "", " ".join(n.get("tags") or []))
+        feats.append((n, toks, content_hash(n.get("content_md") or "")))
+
+    used: set[str] = set()
+    groups: list[dict[str, Any]] = []
+    for i in range(len(feats)):
+        ni, ti, hi = feats[i]
+        if ni["id"] in used:
+            continue
+        dups: list[dict[str, Any]] = []
+        for j in range(i + 1, len(feats)):
+            nj, tj, hj = feats[j]
+            if nj["id"] in used:
+                continue
+            if hi and hi == hj:
+                score, reason = 1.0, "identical-content"
+            else:
+                score = _jaccard(ti, tj)
+                reason = "similar-title-summary"
+            if score >= threshold:
+                dups.append({"id": nj["id"], "title": nj.get("title"), "score": round(score, 4), "reason": reason})
+                used.add(nj["id"])
+        if dups:
+            used.add(ni["id"])
+            # Primary = newest by updated_at.
+            cluster = [ni, *[next(f[0] for f in feats if f[0]["id"] == d["id"]) for d in dups]]
+            primary = max(cluster, key=lambda x: x.get("updated_at") or "")
+            others = [
+                {"id": c["id"], "title": c.get("title"), "score": next((d["score"] for d in dups if d["id"] == c["id"]), 1.0)}
+                for c in cluster
+                if c["id"] != primary["id"]
+            ]
+            groups.append({"primary": {"id": primary["id"], "title": primary.get("title")}, "duplicates": others})
+    return groups
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/embeddings.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/embeddings.py
new file mode 100644
index 00000000..b28843e4
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/embeddings.py
@@ -0,0 +1,79 @@
+"""Embedding generation for vector RAG (phase 2).
+
+Talks to an OpenAI-compatible ``/embeddings`` endpoint configured under
+``knowledge.embedding``. Everything here is **best-effort**: if embeddings are
+disabled, unconfigured, or the endpoint errors, callers get an empty result and
+the search layer falls back to keyword scoring — so vector RAG never breaks a
+deployment that has no embedding model.
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from deerflow.config.knowledge_config import KnowledgeEmbeddingConfig
+
+logger = logging.getLogger(__name__)
+
+
+def cosine_similarity(a: list[float], b: list[float]) -> float:
+    """Cosine similarity of two equal-length vectors (0 when degenerate)."""
+    if not a or not b or len(a) != len(b):
+        return 0.0
+    dot = sum(x * y for x, y in zip(a, b, strict=False))
+    na = math.sqrt(sum(x * x for x in a))
+    nb = math.sqrt(sum(y * y for y in b))
+    if na == 0 or nb == 0:
+        return 0.0
+    return dot / (na * nb)
+
+
+class EmbeddingClient:
+    """Thin async client over an OpenAI-compatible embeddings endpoint."""
+
+    def __init__(self, config: KnowledgeEmbeddingConfig) -> None:
+        self.config = config
+
+    def is_enabled(self) -> bool:
+        return bool(self.config.enabled and self.config.base_url and self.config.model)
+
+    async def embed_texts(self, texts: list[str]) -> list[list[float]]:
+        """Return one vector per input text; ``[]`` on any failure/disabled."""
+        if not self.is_enabled() or not texts:
+            return []
+        try:
+            import httpx
+        except Exception:  # pragma: no cover - httpx is a core dep
+            logger.warning("httpx unavailable; knowledge embeddings disabled")
+            return []
+
+        url = self.config.base_url.rstrip("/") + "/embeddings"
+        headers = {"Content-Type": "application/json"}
+        if self.config.api_key:
+            headers["Authorization"] = f"Bearer {self.config.api_key}"
+
+        vectors: list[list[float]] = []
+        batch = max(1, self.config.batch_size)
+        try:
+            async with httpx.AsyncClient(timeout=self.config.timeout_seconds) as client:
+                for start in range(0, len(texts), batch):
+                    chunk = texts[start : start + batch]
+                    payload: dict = {"model": self.config.model, "input": chunk}
+                    if self.config.dimensions:
+                        payload["dimensions"] = self.config.dimensions
+                    resp = await client.post(url, headers=headers, json=payload)
+                    resp.raise_for_status()
+                    data = resp.json()
+                    items = sorted(data.get("data", []), key=lambda d: d.get("index", 0))
+                    vectors.extend([item.get("embedding", []) for item in items])
+        except Exception:
+            logger.exception("Knowledge embedding request failed; falling back to keyword search")
+            return []
+        return vectors
+
+    async def embed_query(self, text: str) -> list[float]:
+        vecs = await self.embed_texts([text])
+        return vecs[0] if vecs else []
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/exporter.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/exporter.py
new file mode 100644
index 00000000..2f91a5ee
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/exporter.py
@@ -0,0 +1,227 @@
+"""obsidian-wiki ``wiki-export`` compatible graph generation.
+
+Builds a knowledge graph from the notes (nodes) plus their wikilinks and shared
+tags (edges) and writes the four native artifacts into ``<vault>/wiki-export/``:
+``graph.json``, ``graph.graphml``, ``cypher.txt`` and a self-contained
+``graph.html`` (no external CDN, safe to iframe offline).
+"""
+
+from __future__ import annotations
+
+import html
+import json
+from pathlib import Path
+from typing import Any
+
+from deerflow.knowledge.markdown_vault import extract_wikilinks
+
+
+def _vault_key(vault_path: str | None) -> str | None:
+    if not vault_path:
+        return None
+    key = vault_path.replace("\\", "/")
+    if key.endswith(".md"):
+        key = key[:-3]
+    return key
+
+
+def build_graph(
+    notes: list[dict[str, Any]],
+    entities: list[dict[str, Any]] | None = None,
+    relations: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Return ``{nodes, edges}`` from notes (+ optional entities/relations).
+
+    Note nodes come from ``notes`` (id, title, tags, vault_path, content_md);
+    when ``entities``/``relations`` are supplied (phase 4), entity nodes and
+    note→entity / entity→entity edges are added on top of the wikilink and
+    shared-tag edges.
+    """
+    nodes = []
+    by_key: dict[str, str] = {}
+    note_ids: set[str] = set()
+    for n in notes:
+        nodes.append({"id": n["id"], "type": "note", "label": n.get("title") or n["id"], "category": n.get("source_type")})
+        note_ids.add(n["id"])
+        key = _vault_key(n.get("vault_path"))
+        if key:
+            by_key[key] = n["id"]
+
+    # Only surface entities that are still mentioned by a LIVE note. Entities whose
+    # only referencing notes were deleted/archived would otherwise linger forever
+    # as orphan nodes ("graph doesn't follow my deletions").
+    mentioned: set[str] = set()
+    for rel in relations or []:
+        if rel.get("from_note_id") in note_ids and rel.get("to_entity_id"):
+            mentioned.add(rel["to_entity_id"])
+
+    entity_ids: set[str] = set()
+    for ent in entities or []:
+        if ent["id"] not in mentioned:
+            continue
+        nodes.append({"id": ent["id"], "type": "entity", "label": ent.get("name") or ent["id"], "category": ent.get("entity_type")})
+        entity_ids.add(ent["id"])
+
+    edges: list[dict[str, Any]] = []
+    edge_seen: set[tuple[str, str, str]] = set()
+
+    def add_edge(a: str, b: str, label: str, weight: float) -> None:
+        if a == b:
+            return
+        key = (min(a, b), max(a, b), label)
+        if key in edge_seen:
+            return
+        edge_seen.add(key)
+        edges.append({"id": f"rel_{len(edges) + 1}", "source": a, "target": b, "label": label, "weight": weight})
+
+    # Wikilink edges.
+    for n in notes:
+        for target in extract_wikilinks(n.get("content_md") or ""):
+            tid = by_key.get(target.replace("\\", "/").removesuffix(".md"))
+            if tid:
+                add_edge(n["id"], tid, "links", 2)
+
+    # Shared-tag edges.
+    tag_to_notes: dict[str, list[str]] = {}
+    for n in notes:
+        for tag in n.get("tags") or []:
+            tag_to_notes.setdefault(tag.lower(), []).append(n["id"])
+    for tag, ids in tag_to_notes.items():
+        if len(ids) < 2 or len(ids) > 50:  # skip ubiquitous tags (e.g. knowledge-base)
+            continue
+        for i in range(len(ids)):
+            for j in range(i + 1, len(ids)):
+                add_edge(ids[i], ids[j], "related", 1)
+
+    # Entity / relation edges (phase 4) — only when both endpoints exist as nodes.
+    valid = note_ids | entity_ids
+    for rel in relations or []:
+        src = rel.get("from_note_id") or rel.get("from_entity_id")
+        tgt = rel.get("to_note_id") or rel.get("to_entity_id")
+        if src in valid and tgt in valid:
+            add_edge(src, tgt, rel.get("relation_type") or "related", float(rel.get("weight") or 1))
+
+    return {"nodes": nodes, "edges": edges}
+
+
+def to_graphml(graph: dict[str, Any]) -> str:
+    lines = [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<graphml xmlns="http://graphml.graphdrawing.org/xmlns">',
+        '  <key id="label" for="node" attr.name="label" attr.type="string"/>',
+        '  <key id="elabel" for="edge" attr.name="label" attr.type="string"/>',
+        '  <graph edgedefault="undirected">',
+    ]
+    for n in graph["nodes"]:
+        lines.append(f'    <node id="{html.escape(str(n["id"]))}"><data key="label">{html.escape(str(n["label"]))}</data></node>')
+    for e in graph["edges"]:
+        lines.append(
+            f'    <edge id="{html.escape(str(e["id"]))}" source="{html.escape(str(e["source"]))}" '
+            f'target="{html.escape(str(e["target"]))}"><data key="elabel">{html.escape(str(e["label"]))}</data></edge>'
+        )
+    lines += ["  </graph>", "</graphml>"]
+    return "\n".join(lines)
+
+
+def to_cypher(graph: dict[str, Any]) -> str:
+    lines = []
+    for n in graph["nodes"]:
+        label = str(n["label"]).replace("'", "\\'")
+        lines.append(f"CREATE (:Note {{id:'{n['id']}', title:'{label}'}});")
+    for e in graph["edges"]:
+        rel = str(e["label"]).upper()
+        lines.append(f"MATCH (a:Note {{id:'{e['source']}'}}),(b:Note {{id:'{e['target']}'}}) CREATE (a)-[:{rel} {{weight:{e['weight']}}}]->(b);")
+    return "\n".join(lines)
+
+
+def to_html(graph: dict[str, Any]) -> str:
+    """Self-contained force-directed graph (canvas + vanilla JS, no CDN)."""
+    data_json = json.dumps(graph, ensure_ascii=False)
+    return _HTML_TEMPLATE.replace("__GRAPH_DATA__", data_json)
+
+
+def export_all(
+    vault_root: Path | str,
+    notes: list[dict[str, Any]],
+    *,
+    entities: list[dict[str, Any]] | None = None,
+    relations: list[dict[str, Any]] | None = None,
+    write_html: bool = True,
+    write_json: bool = True,
+) -> dict[str, Any]:
+    """Generate graph artifacts under ``<vault>/wiki-export/`` and return stats."""
+    out_dir = Path(vault_root).resolve() / "wiki-export"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    graph = build_graph(notes, entities, relations)
+    written: list[str] = []
+    if write_json:
+        (out_dir / "graph.json").write_text(json.dumps(graph, ensure_ascii=False, indent=2), encoding="utf-8")
+        written.append("graph.json")
+    (out_dir / "graph.graphml").write_text(to_graphml(graph), encoding="utf-8")
+    written.append("graph.graphml")
+    (out_dir / "cypher.txt").write_text(to_cypher(graph), encoding="utf-8")
+    written.append("cypher.txt")
+    if write_html:
+        (out_dir / "graph.html").write_text(to_html(graph), encoding="utf-8")
+        written.append("graph.html")
+    return {
+        "files": written,
+        "stats": {"nodes": len(graph["nodes"]), "edges": len(graph["edges"])},
+        "graph": graph,
+    }
+
+
+_HTML_TEMPLATE = """<!DOCTYPE html>
+<html lang="zh">
+<head>
+<meta charset="utf-8"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>Knowledge Graph</title>
+<style>
+  html,body{margin:0;height:100%;background:#0b1020;color:#e7ecff;font-family:system-ui,Segoe UI,Arial,sans-serif;overflow:hidden}
+  #hud{position:fixed;top:10px;left:12px;font-size:12px;opacity:.8;z-index:2}
+  #tip{position:fixed;padding:4px 8px;background:#111a36;border:1px solid #2a3a66;border-radius:4px;font-size:12px;pointer-events:none;display:none;z-index:3}
+  canvas{display:block}
+  #empty{position:fixed;inset:0;display:flex;align-items:center;justify-content:center;opacity:.6}
+</style>
+</head>
+<body>
+<div id="hud"></div>
+<div id="tip"></div>
+<canvas id="c"></canvas>
+<script>
+const GRAPH = __GRAPH_DATA__;
+const canvas = document.getElementById('c'), ctx = canvas.getContext('2d');
+const hud = document.getElementById('hud'), tip = document.getElementById('tip');
+let W=0,H=0;
+function resize(){W=canvas.width=innerWidth;H=canvas.height=innerHeight;}
+addEventListener('resize',resize);resize();
+hud.textContent = GRAPH.nodes.length + ' 个知识节点 · ' + GRAPH.edges.length + ' 条关系';
+if(!GRAPH.nodes.length){document.body.insertAdjacentHTML('beforeend','<div id=\"empty\">暂无知识图谱数据</div>');}
+const idx={};GRAPH.nodes.forEach((n,i)=>{idx[n.id]=n;n.x=W/2+Math.cos(i)*200*Math.random()+(Math.random()-.5)*200;n.y=H/2+Math.sin(i)*200*Math.random()+(Math.random()-.5)*200;n.vx=0;n.vy=0;});
+const edges=GRAPH.edges.map(e=>({s:idx[e.source],t:idx[e.target],w:e.w||e.weight||1})).filter(e=>e.s&&e.t);
+let cam={x:0,y:0,k:1},drag=null,pan=null;
+function step(){
+  for(const n of GRAPH.nodes){for(const m of GRAPH.nodes){if(n===m)continue;let dx=n.x-m.x,dy=n.y-m.y,d2=dx*dx+dy*dy+0.01,f=1200/d2;n.vx+=dx*f*0.0006;n.vy+=dy*f*0.0006;}}
+  for(const e of edges){let dx=e.t.x-e.s.x,dy=e.t.y-e.s.y,d=Math.sqrt(dx*dx+dy*dy)||1,f=(d-110)*0.01;e.s.vx+=dx/d*f;e.s.vy+=dy/d*f;e.t.vx-=dx/d*f;e.t.vy-=dy/d*f;}
+  for(const n of GRAPH.nodes){n.vx+=(W/2-n.x)*0.0008;n.vy+=(H/2-n.y)*0.0008;n.x+=n.vx*=0.85;n.y+=n.vy*=0.85;}
+}
+function draw(){
+  ctx.setTransform(cam.k,0,0,cam.k,cam.x,cam.y);ctx.clearRect(-cam.x/cam.k,-cam.y/cam.k,W/cam.k,H/cam.k);
+  ctx.strokeStyle='rgba(120,150,255,.25)';
+  for(const e of edges){ctx.lineWidth=e.w*0.6;ctx.beginPath();ctx.moveTo(e.s.x,e.s.y);ctx.lineTo(e.t.x,e.t.y);ctx.stroke();}
+  for(const n of GRAPH.nodes){const r=6;ctx.fillStyle='#5b8cff';ctx.beginPath();ctx.arc(n.x,n.y,r,0,7);ctx.fill();
+    ctx.fillStyle='rgba(231,236,255,.85)';ctx.font='11px system-ui';ctx.fillText((n.label||'').slice(0,18),n.x+9,n.y+3);}
+}
+function loop(){step();draw();requestAnimationFrame(loop);}loop();
+function toWorld(x,y){return {x:(x-cam.x)/cam.k,y:(y-cam.y)/cam.k};}
+canvas.addEventListener('mousedown',ev=>{const p=toWorld(ev.clientX,ev.clientY);let hit=null;
+  for(const n of GRAPH.nodes){if((n.x-p.x)**2+(n.y-p.y)**2<100){hit=n;break;}}if(hit)drag=hit;else pan={x:ev.clientX,y:ev.clientY,cx:cam.x,cy:cam.y};});
+addEventListener('mousemove',ev=>{const p=toWorld(ev.clientX,ev.clientY);if(drag){drag.x=p.x;drag.y=p.y;drag.vx=drag.vy=0;}else if(pan){cam.x=pan.cx+ev.clientX-pan.x;cam.y=pan.cy+ev.clientY-pan.y;}
+  let hov=null;for(const n of GRAPH.nodes){if((n.x-p.x)**2+(n.y-p.y)**2<100){hov=n;break;}}
+  if(hov){tip.style.display='block';tip.style.left=(ev.clientX+12)+'px';tip.style.top=(ev.clientY+12)+'px';tip.textContent=hov.label;}else{tip.style.display='none';}});
+addEventListener('mouseup',()=>{drag=null;pan=null;});
+canvas.addEventListener('wheel',ev=>{ev.preventDefault();const s=ev.deltaY<0?1.1:0.9;cam.k*=s;cam.x=ev.clientX-(ev.clientX-cam.x)*s;cam.y=ev.clientY-(ev.clientY-cam.y)*s;},{passive:false});
+</script>
+</body>
+</html>"""
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/extractor.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/extractor.py
new file mode 100644
index 00000000..a9dbbe63
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/extractor.py
@@ -0,0 +1,262 @@
+"""Extract knowledge notes from threads / searches / tool results.
+
+First-release strategy is rule-based (wiki-capture aligned, §11 of the dev doc):
+keep high-value content (user questions, final assistant answers, cited
+sources), drop noise (empty/greeting/intermediate reasoning), and write a
+*declarative* note rather than a chat transcript. An LLM extractor can later
+replace :func:`extract_thread` while keeping the same :class:`NoteDraft` output.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from deerflow.knowledge.schemas import NoteDraft, SourceDraft
+
+# Greeting / low-value lines filtered from extracted turns.
+_GREETING_RE = re.compile(r"^(你好|您好|hi|hello|hey|thanks?|谢谢|好的|ok|okay)[\s!！。.,，~]*$", re.IGNORECASE)
+_WS_RE = re.compile(r"\s+")
+
+
+def _one_line(text: str, limit: int = 300) -> str:
+    """Collapse whitespace and clip ``text`` to a single line."""
+    collapsed = _WS_RE.sub(" ", text or "").strip()
+    return collapsed[:limit]
+
+
+def message_text(msg: dict[str, Any]) -> str:
+    """Return the plain-text content of a serialized LangChain message."""
+    content = msg.get("content")
+    if isinstance(content, str):
+        return content.strip()
+    if isinstance(content, list):
+        parts: list[str] = []
+        for block in content:
+            if isinstance(block, str):
+                parts.append(block)
+            elif isinstance(block, dict):
+                if block.get("type") in (None, "text") and isinstance(block.get("text"), str):
+                    parts.append(block["text"])
+        return "\n".join(p for p in parts if p).strip()
+    return ""
+
+
+def _msg_type(msg: dict[str, Any]) -> str:
+    return str(msg.get("type") or msg.get("role") or "").lower()
+
+
+def split_turns(messages: list[dict[str, Any]], *, max_messages: int = 80) -> list[dict[str, str]]:
+    """Split messages into ``{user, ai}`` turns keyed by human messages.
+
+    For each turn we keep the last substantial AI message (with text body).
+    """
+    msgs = messages[-max_messages:] if max_messages and len(messages) > max_messages else list(messages)
+    turns: list[dict[str, str]] = []
+    current: dict[str, str] | None = None
+    for msg in msgs:
+        mtype = _msg_type(msg)
+        text = message_text(msg)
+        if mtype == "human":
+            if current and (current.get("user") or current.get("ai")):
+                turns.append(current)
+            current = {"user": text, "ai": ""}
+        elif mtype == "ai" and text:
+            if current is None:
+                current = {"user": "", "ai": text}
+            else:
+                current["ai"] = text  # last substantial AI message wins
+    if current and (current.get("user") or current.get("ai")):
+        turns.append(current)
+    # Drop turns that are pure greetings with no answer.
+    cleaned = []
+    for t in turns:
+        user = (t.get("user") or "").strip()
+        ai = (t.get("ai") or "").strip()
+        if not ai and _GREETING_RE.match(user):
+            continue
+        if not user and not ai:
+            continue
+        cleaned.append({"user": user, "ai": ai})
+    return cleaned
+
+
+def _auto_title(thread_title: str | None, turns: list[dict[str, str]]) -> str:
+    if thread_title and thread_title.strip() and thread_title.strip().lower() != "untitled":
+        return thread_title.strip()[:200]
+    for t in turns:
+        if t.get("user"):
+            first = t["user"].splitlines()[0].strip()
+            return (first[:40] + ("…" if len(first) > 40 else "")) or "知识笔记"
+    return "知识笔记"
+
+
+def _summary(turns: list[dict[str, str]], *, limit: int = 280) -> str:
+    """Simple rule-based summary: the first answer, clipped."""
+    for t in turns:
+        if t.get("ai"):
+            text = re.sub(r"\s+", " ", t["ai"]).strip()
+            return text[:limit] + ("…" if len(text) > limit else "")
+    for t in turns:
+        if t.get("user"):
+            text = re.sub(r"\s+", " ", t["user"]).strip()
+            return text[:limit] + ("…" if len(text) > limit else "")
+    return ""
+
+
+def related_links(project_name: str | None) -> list[str]:  # noqa: ARG001
+    """Structural wikilinks every note used to carry.
+
+    Product decision: notes no longer auto-link the vault meta/hub pages
+    (``index`` / ``_meta/taxonomy`` / the project hub) — they were noise in every
+    note's ``## Related``. Only real, content-specific related notes (injected by
+    the service layer, which has DB access) are linked now. Kept as a function
+    (returns empty) so existing callers and the wiki-capture contract stay intact.
+    """
+    return []
+
+
+# Backwards-compatible internal alias.
+_related_links = related_links
+
+
+def _related_section_md(related_lines: list[str], source_lines: list[str]) -> str:
+    """Render the ``## Related`` section, or ``""`` when there is nothing to show."""
+    if not related_lines and not source_lines:
+        return ""
+    inner = "\n".join(related_lines)
+    if source_lines:
+        sources_block = "### Sources\n\n" + "\n".join(source_lines)
+        inner = (inner + "\n\n" + sources_block) if inner else sources_block
+    return f"## Related\n\n{inner}\n"
+
+
+def _build_body(
+    *,
+    title: str,
+    turns: list[dict[str, str]],
+    mode: str,
+    project_name: str | None,
+    sources: list[SourceDraft],
+) -> str:
+    """Render the wiki-capture 5-section declarative body."""
+    full = mode == "full"
+    answer_clip = 4000 if full else 800
+
+    context_lines = []
+    for t in turns:
+        if t.get("user"):
+            q = re.sub(r"\s+", " ", t["user"]).strip()
+            context_lines.append(f"- {q[:300]}")
+    context = "\n".join(context_lines[:8]) or "- 来自一次对话沉淀。^[inferred]"
+
+    finding_lines = []
+    for i, t in enumerate(turns, 1):
+        if t.get("ai"):
+            ans = t["ai"].strip()
+            ans = ans if full else (ans[:answer_clip] + ("…" if len(ans) > answer_clip else ""))
+            finding_lines.append(f"### 结论 {i}\n\n{ans}")
+    finding = "\n\n".join(finding_lines) or "_暂无可提炼的结论。_"
+
+    reasoning = "本页由对话自动沉淀而成，结论来自助手最终回答；过程性推理已省略。判断与归纳部分标记为 ^[inferred]。"
+
+    implications = "- 后续可在相关问答中参考本页知识。\n- 如内容过期或冲突，请编辑或归档。"
+
+    related_lines = [f"- {link}" for link in _related_links(project_name)]
+    source_lines = [f"- {s.title or s.url or '来源'}" + (f" — {s.url}" if s.url else "") for s in sources[:20]]
+    related_section = _related_section_md(related_lines, source_lines)
+
+    return (
+        f"# {title}\n\n"
+        f"## Context\n\n{context}\n\n"
+        f"## Finding / Decision\n\n{finding}\n\n"
+        f"## Reasoning\n\n{reasoning}\n\n"
+        f"## Implications\n\n{implications}\n\n"
+        f"{related_section}"
+    )
+
+
+def extract_thread(
+    messages: list[dict[str, Any]],
+    *,
+    thread_id: str,
+    thread_title: str | None = None,
+    mode: str = "summary",
+    title: str | None = None,
+    tags: list[str] | None = None,
+    project_name: str | None = "zncm",
+    sources: list[SourceDraft] | None = None,
+    max_messages: int = 80,
+) -> NoteDraft | None:
+    """Build a :class:`NoteDraft` from thread messages, or ``None`` if empty."""
+    turns = split_turns(messages, max_messages=max_messages)
+    if not turns:
+        return None
+    final_title = (title or "").strip() or _auto_title(thread_title, turns)
+    summary = _summary(turns)
+    sources = sources or []
+    body = _build_body(title=final_title, turns=turns, mode=mode, project_name=project_name, sources=sources)
+    base_tags = list(tags or [])
+    for default in (project_name or "zncm", "knowledge-base"):
+        if default and default not in base_tags:
+            base_tags.append(default)
+    return NoteDraft(
+        title=final_title,
+        summary=summary,
+        content_md=body,
+        category="synthesis",
+        source_type="thread",
+        source_id=thread_id,
+        tags=base_tags,
+        confidence=0.6,
+        related=_related_links(project_name),
+        sources=sources,
+        source_key=f"thread:{thread_id}",
+    )
+
+
+def extract_search(
+    query: str,
+    sources: list[SourceDraft],
+    *,
+    thread_id: str | None = None,
+    project_name: str | None = "zncm",
+    title: str | None = None,
+    tags: list[str] | None = None,
+) -> NoteDraft:
+    """Build a reference-category :class:`NoteDraft` from search/tool results."""
+    final_title = (title or "").strip() or f"检索：{query[:40]}"
+    body_lines = [f"# {final_title}\n", "## Context\n", f"- 检索关键词：{query}\n", "## Finding / Decision\n"]
+    for s in sources:
+        label = s.title or s.url or "来源"
+        line = f"- **{label}**"
+        if s.url:
+            line += f" — {s.url}"
+        if s.snippet:
+            line += "\n  - " + _one_line(s.snippet)
+        body_lines.append(line)
+    body_lines += [
+        "\n## Reasoning\n",
+        "本页汇总外部检索来源，供后续问答引用。来源可信度需结合原文判断。^[ambiguous]\n",
+        "## Implications\n",
+        "- 引用前请核对原始来源。\n",
+        "## Related\n",
+        *[f"- {link}" for link in _related_links(project_name)],
+    ]
+    base_tags = list(tags or [])
+    for default in (project_name or "zncm", "knowledge-base", "reference"):
+        if default and default not in base_tags:
+            base_tags.append(default)
+    return NoteDraft(
+        title=final_title,
+        summary=f"检索“{query}”的来源汇总，共 {len(sources)} 条。",
+        content_md="\n".join(body_lines),
+        category="references",
+        source_type="search",
+        source_id=f"search:{query[:120]}",
+        tags=base_tags,
+        confidence=0.4,
+        related=_related_links(project_name),
+        sources=sources,
+        source_key=None,
+    )
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/llm_extractor.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/llm_extractor.py
new file mode 100644
index 00000000..5c86f697
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/llm_extractor.py
@@ -0,0 +1,354 @@
+"""LLM-based knowledge extraction (wiki-capture style).
+
+Turns a conversation into a *declarative* knowledge note instead of dumping the
+raw chat. Follows the obsidian-wiki ``wiki-capture`` skill: classify the note,
+keep only high-value findings/decisions, drop greetings / intermediate
+reasoning / verbatim transcripts, mark inferred content, and emit structured
+JSON that we render into the Context / Finding / Reasoning / Implications /
+Related body.
+
+Falls back to the rule-based :func:`deerflow.knowledge.extractor.extract_thread`
+when the LLM is unavailable or returns something unusable, so capture never
+hard-fails.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from typing import Any
+
+from deerflow.knowledge import extractor
+from deerflow.knowledge.schemas import NoteDraft, SourceDraft
+from deerflow.knowledge.skill_templates import WIKI_CAPTURE_GUIDANCE
+
+logger = logging.getLogger(__name__)
+
+_VALID_CATEGORIES = {"synthesis", "concepts", "references", "decision", "journal"}
+
+
+class LLMRejectedIngest(Exception):
+    """The LLM judged the conversation as having no knowledge value.
+
+    Raised (instead of returning ``[]``) when the model explicitly sets
+    ``should_ingest: false`` with no notes — so callers can *skip* ingestion
+    entirely rather than falling back to the rule-based verbatim dump.
+    """
+
+
+def _is_falsey(value: Any) -> bool:
+    if value is False:
+        return True
+    if isinstance(value, str):
+        return value.strip().lower() in ("false", "0", "no")
+    return False
+
+_SYSTEM_PROMPT = """\
+你是知识库整理专家，遵循 obsidian-wiki 的 wiki-capture 规范，把一次对话提炼成\
+**陈述式知识（declarative knowledge）**，而不是聊天流水账。
+
+要求：
+- 只保留高价值内容：明确结论、方案、决策、关键事实、被引用的来源。
+- 丢弃：寒暄、客套、中间推理过程、重复内容、无意义的原文堆砌。
+- 不要写“用户问了什么、AI 回答了什么”，要写“结论是什么、为什么成立”。
+- 推断内容用 ^[inferred] 标记，不确定/冲突用 ^[ambiguous] 标记。
+- 分类 category 取值之一：synthesis（分析/方案/结论）、concepts（概念/框架）、\
+references（外部来源汇总）、decision（架构/设计决策）、journal（会话纪要）。
+- 用中文输出。
+
+一次对话可能只讲一个主题，也可能覆盖多个相互独立的主题。请把它拆成 1~4 页知识：
+- 默认只产出 **1 页**；只有当对话明确包含**多个彼此独立、可各自成文**的主题时才拆成多页。
+- 每一页聚焦单一主题，标题与 summary 必须彼此区分，不要把同一结论拆到多页。
+- 不值得沉淀时返回空的 notes 数组。
+
+只输出一个 JSON 对象，不要任何额外文字或 Markdown 代码块，结构如下：
+{
+  "should_ingest": true,
+  "reason": "为什么值得/不值得沉淀",
+  "notes": [
+    {
+      "title": "简洁的知识标题（不超过 40 字）",
+      "summary": "1-2 句话概括这页知识",
+      "category": "synthesis",
+      "context": "问题背景或触发场景，1-3 句",
+      "findings": ["结论/要点（陈述式，可含 ^[inferred]）", "..."],
+      "reasoning": "为什么成立、取舍、不确定性",
+      "implications": ["后续建议/风险/下一步", "..."],
+      "tags": ["标签1", "标签2"],
+      "entities": [{"name": "实体名", "type": "technology|concept|person|org|product|other"}],
+      "relations": [{"from": "实体A", "to": "实体B", "type": "uses|relates_to|part_of|depends_on"}],
+      "confidence": 0.0
+    }
+  ]
+}"""
+
+
+def _build_transcript(turns: list[dict[str, str]], sources: list[SourceDraft], *, max_chars: int) -> str:
+    parts: list[str] = []
+    for i, t in enumerate(turns, 1):
+        if t.get("user"):
+            parts.append(f"[用户 {i}] {t['user']}")
+        if t.get("ai"):
+            parts.append(f"[助手 {i}] {t['ai']}")
+    if sources:
+        parts.append("\n[来源]")
+        for s in sources[:20]:
+            label = s.title or s.url or s.tool_name or "来源"
+            parts.append(f"- {label}" + (f" ({s.url})" if s.url else ""))
+    text = "\n\n".join(parts)
+    if len(text) > max_chars:
+        text = text[:max_chars] + "\n…（已截断）"
+    return text
+
+
+def _parse_json(raw: str) -> dict[str, Any] | None:
+    if not raw:
+        return None
+    text = raw.strip()
+    # Strip ```json fences if present.
+    fence = re.search(r"```(?:json)?\s*(.*?)```", text, re.DOTALL)
+    if fence:
+        text = fence.group(1).strip()
+    # Otherwise grab the outermost { ... }.
+    if not text.startswith("{"):
+        start = text.find("{")
+        end = text.rfind("}")
+        if start >= 0 and end > start:
+            text = text[start : end + 1]
+    try:
+        data = json.loads(text)
+        return data if isinstance(data, dict) else None
+    except json.JSONDecodeError:
+        logger.warning("Knowledge LLM returned non-JSON output; falling back to rule-based")
+        return None
+
+
+def _render_body(data: dict[str, Any], title: str, related: list[str], sources: list[SourceDraft]) -> str:
+    def _bullets(items: Any) -> str:
+        if isinstance(items, str):
+            items = [items]
+        if not isinstance(items, list):
+            return ""
+        return "\n".join(f"- {str(x).strip()}" for x in items if str(x).strip())
+
+    context = str(data.get("context") or "").strip() or "- 来自一次对话沉淀。^[inferred]"
+    findings = _bullets(data.get("findings")) or "_暂无可提炼的结论。_"
+    reasoning = str(data.get("reasoning") or "").strip() or "（未提供推理说明）"
+    implications = _bullets(data.get("implications")) or "- 如内容过期或冲突，请编辑或归档。"
+
+    related_lines = [f"- {link}" for link in related]
+    source_lines = [f"- {s.title or s.url or '来源'}" + (f" — {s.url}" if s.url else "") for s in sources[:20]]
+    related_section = extractor._related_section_md(related_lines, source_lines)
+
+    return (
+        f"# {title}\n\n"
+        f"## Context\n\n{context}\n\n"
+        f"## Finding / Decision\n\n{findings}\n\n"
+        f"## Reasoning\n\n{reasoning}\n\n"
+        f"## Implications\n\n{implications}\n\n"
+        f"{related_section}"
+    )
+
+
+def _notes_from_data(data: dict[str, Any]) -> list[dict[str, Any]]:
+    """Normalize the LLM JSON into a list of per-note dicts.
+
+    Accepts the multi-note shape ``{"notes": [...]}`` as well as the legacy
+    single-note shape (``{"title": ..., "findings": ...}``) for backward
+    compatibility. Notes without any title/findings are dropped.
+    """
+    raw_notes = data.get("notes")
+    if isinstance(raw_notes, list):
+        candidates = [n for n in raw_notes if isinstance(n, dict)]
+    elif data.get("title") or data.get("findings") or data.get("context"):
+        candidates = [data]  # legacy single-object output
+    else:
+        candidates = []
+    return [n for n in candidates if str(n.get("title") or "").strip() or n.get("findings")]
+
+
+def _build_note_draft(
+    note_data: dict[str, Any],
+    *,
+    thread_id: str,
+    thread_title: str | None,
+    turns: list[dict[str, str]],
+    title_override: str | None,
+    tags: list[str] | None,
+    project_name: str | None,
+    sources: list[SourceDraft],
+    source_key_suffix: str = "",
+) -> NoteDraft:
+    """Render one note dict into a :class:`NoteDraft`."""
+    category = str(note_data.get("category") or "synthesis").strip().lower()
+    if category not in _VALID_CATEGORIES:
+        category = "synthesis"
+
+    final_title = (title_override or "").strip() or str(note_data.get("title") or "").strip() or extractor._auto_title(thread_title, turns)
+    summary = str(note_data.get("summary") or "").strip()
+    related = extractor.related_links(project_name)
+    body = _render_body(note_data, final_title, related, sources)
+
+    base_tags = list(tags or [])
+    llm_tags = note_data.get("tags") if isinstance(note_data.get("tags"), list) else []
+    for tag in [*llm_tags, project_name or "zncm", "knowledge-base"]:
+        tag = str(tag).strip()
+        if tag and tag not in base_tags:
+            base_tags.append(tag)
+
+    try:
+        confidence = float(note_data.get("confidence") or 0.7)
+    except (TypeError, ValueError):
+        confidence = 0.7
+
+    entities = note_data.get("entities") if isinstance(note_data.get("entities"), list) else []
+    relations = note_data.get("relations") if isinstance(note_data.get("relations"), list) else []
+
+    return NoteDraft(
+        title=final_title,
+        summary=summary or final_title,
+        content_md=body,
+        category=category,
+        source_type="thread",
+        source_id=thread_id,
+        tags=base_tags,
+        confidence=max(0.0, min(confidence, 1.0)),
+        related=related,
+        sources=sources,
+        entities=[e for e in entities if isinstance(e, dict) and e.get("name")],
+        relations=[r for r in relations if isinstance(r, dict) and r.get("from") and r.get("to")],
+        source_key=f"thread:{thread_id}{source_key_suffix}",
+    )
+
+
+async def extract_thread_llm_multi(
+    messages: list[dict[str, Any]],
+    *,
+    thread_id: str,
+    thread_title: str | None = None,
+    mode: str = "summary",
+    title: str | None = None,
+    tags: list[str] | None = None,
+    project_name: str | None = "zncm",
+    sources: list[SourceDraft] | None = None,
+    max_messages: int = 80,
+    model_name: str | None = None,
+    max_input_chars: int = 12000,
+    allow_multi: bool = True,
+    max_notes: int = 4,
+) -> list[NoteDraft]:
+    """Distill a thread into one *or several* cross-linkable knowledge notes.
+
+    The LLM may split a conversation that covers multiple independent topics into
+    several declarative notes. Returns ``[]`` when there is nothing to sediment
+    or the LLM path fails — callers should fall back to the rule-based extractor.
+    When ``allow_multi`` is false only the first note is kept.
+    """
+    turns = extractor.split_turns(messages, max_messages=max_messages)
+    if not turns:
+        return []
+    sources = sources or []
+
+    try:
+        from langchain_core.messages import HumanMessage, SystemMessage
+
+        from deerflow.models import create_chat_model
+
+        model = create_chat_model(name=model_name or None, thinking_enabled=False)
+        transcript = _build_transcript(turns, sources, max_chars=max_input_chars)
+        prompt = [
+            SystemMessage(content=_SYSTEM_PROMPT + "\n\n" + WIKI_CAPTURE_GUIDANCE),
+            HumanMessage(content=f"以下是一次对话，请按规范提炼为知识 JSON：\n\n{transcript}"),
+        ]
+        response = await model.ainvoke(prompt)
+        raw = response.content if isinstance(response.content, str) else str(response.content)
+        data = _parse_json(raw)
+    except Exception:
+        logger.exception("[knowledge] thread %s — LLM extraction call failed; using rule-based fallback", thread_id)
+        return []
+
+    if not data:
+        logger.warning("[knowledge] thread %s — LLM returned no parsable JSON; using rule-based fallback", thread_id)
+        return []
+
+    note_dicts = _notes_from_data(data)
+    if not note_dicts:
+        reason = str(data.get("reason") or "")[:200]
+        if _is_falsey(data.get("should_ingest")):
+            # The model deliberately judged this conversation worthless (greeting,
+            # meta chatter, no findings). Skip ingestion entirely — do NOT fall
+            # back to the rule-based verbatim dump.
+            logger.warning("[knowledge] thread %s SKIPPED — model judged not worth ingesting: %s", thread_id, reason)
+            raise LLMRejectedIngest(reason or "no knowledge value")
+        logger.warning(
+            "[knowledge] thread %s — LLM produced no notes (should_ingest=%s, reason=%r); using rule-based fallback",
+            thread_id,
+            data.get("should_ingest"),
+            reason,
+        )
+        return []
+    if not allow_multi:
+        note_dicts = note_dicts[:1]
+    else:
+        note_dicts = note_dicts[: max(1, max_notes)]
+
+    drafts: list[NoteDraft] = []
+    for i, nd in enumerate(note_dicts):
+        # The user-supplied title override only applies to a single-note result;
+        # multi-note splits keep each note's own LLM title.
+        override = title if (len(note_dicts) == 1) else None
+        suffix = "" if len(note_dicts) == 1 else f"#{i}"
+        drafts.append(
+            _build_note_draft(
+                nd,
+                thread_id=thread_id,
+                thread_title=thread_title,
+                turns=turns,
+                title_override=override,
+                tags=tags,
+                project_name=project_name,
+                sources=sources,
+                source_key_suffix=suffix,
+            )
+        )
+    return drafts
+
+
+async def extract_thread_llm(
+    messages: list[dict[str, Any]],
+    *,
+    thread_id: str,
+    thread_title: str | None = None,
+    mode: str = "summary",
+    title: str | None = None,
+    tags: list[str] | None = None,
+    project_name: str | None = "zncm",
+    sources: list[SourceDraft] | None = None,
+    max_messages: int = 80,
+    model_name: str | None = None,
+    max_input_chars: int = 12000,
+) -> NoteDraft | None:
+    """Distill a thread into a single :class:`NoteDraft` (backward-compatible).
+
+    Thin wrapper over :func:`extract_thread_llm_multi` that returns the first
+    note, or ``None`` when nothing was produced.
+    """
+    try:
+        drafts = await extract_thread_llm_multi(
+            messages,
+            thread_id=thread_id,
+            thread_title=thread_title,
+            mode=mode,
+            title=title,
+            tags=tags,
+            project_name=project_name,
+            sources=sources,
+            max_messages=max_messages,
+            model_name=model_name,
+            max_input_chars=max_input_chars,
+            allow_multi=False,
+        )
+    except LLMRejectedIngest:
+        return None
+    return drafts[0] if drafts else None
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/manifest.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/manifest.py
new file mode 100644
index 00000000..7dc67ab9
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/manifest.py
@@ -0,0 +1,74 @@
+""".manifest.json read/write for the vault.
+
+The manifest records, per page, the source key, content hash, vault path and
+update time — so batch ingest can skip already-sedimented threads (delta/dedup)
+exactly like obsidian-wiki's native ``.manifest.json``.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+
+def content_hash(text: str) -> str:
+    """Stable sha256 hex digest of ``text`` (used for dedup)."""
+    return hashlib.sha256((text or "").encode("utf-8")).hexdigest()
+
+
+class Manifest:
+    """JSON manifest stored at ``<vault>/.manifest.json``."""
+
+    def __init__(self, root: Path | str) -> None:
+        self.path = Path(root).resolve() / ".manifest.json"
+
+    def load(self) -> dict[str, Any]:
+        if not self.path.exists():
+            return {"version": 1, "updated": None, "pages": {}, "sources": {}}
+        try:
+            data = json.loads(self.path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            return {"version": 1, "updated": None, "pages": {}, "sources": {}}
+        data.setdefault("pages", {})
+        data.setdefault("sources", {})
+        return data
+
+    def save(self, data: dict[str, Any]) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    def record_page(
+        self,
+        *,
+        note_id: str,
+        vault_path: str,
+        source_key: str | None,
+        hash_value: str,
+        updated: str,
+    ) -> None:
+        data = self.load()
+        data["pages"][note_id] = {
+            "vault_path": vault_path,
+            "source": source_key,
+            "hash": hash_value,
+            "updated": updated,
+        }
+        if source_key:
+            data["sources"][source_key] = {"note_id": note_id, "hash": hash_value, "updated": updated}
+        data["updated"] = updated
+        self.save(data)
+
+    def remove_page(self, note_id: str) -> None:
+        data = self.load()
+        page = data["pages"].pop(note_id, None)
+        if page and page.get("source"):
+            data["sources"].pop(page["source"], None)
+        self.save(data)
+
+    def has_source(self, source_key: str) -> bool:
+        return source_key in self.load().get("sources", {})
+
+    def get_source(self, source_key: str) -> dict[str, Any] | None:
+        return self.load().get("sources", {}).get(source_key)
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/markdown_vault.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/markdown_vault.py
new file mode 100644
index 00000000..d36e028d
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/markdown_vault.py
@@ -0,0 +1,213 @@
+"""obsidian-wiki compatible Markdown vault writer/reader.
+
+Responsibilities (dev doc §10 ``markdown_vault.py``):
+
+- Generate obsidian-wiki compatible frontmatter.
+- Produce safe, path-traversal-proof file names/paths.
+- Write/update/read Markdown note files.
+- Parse frontmatter + extract ``[[wikilinks]]``.
+
+The vault layout follows §8 of the dev doc and stays compatible with
+``ar9av/obsidian-wiki`` (concepts/ references/ synthesis/ journal/ projects/…,
+plus index.md / log.md / hot.md / .manifest.json / _meta/taxonomy.md /
+wiki-export/).
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+_WIKILINK_RE = re.compile(r"\[\[([^\]|]+)(?:\|[^\]]+)?\]\]")
+_FRONTMATTER_RE = re.compile(r"^---\s*\n(.*?)\n---\s*\n?(.*)$", re.DOTALL)
+_UNSAFE_CHARS_RE = re.compile(r"[^\w一-鿿-]+")
+
+# Top-level vault directories that must exist (obsidian-wiki native layout).
+_VAULT_DIRS = ("concepts", "entities", "skills", "references", "synthesis", "journal", "projects", "_meta", "wiki-export")
+
+
+def slugify(title: str, *, max_len: int = 60) -> str:
+    """Return a filesystem-safe slug (ASCII + CJK), never empty."""
+    text = unicodedata.normalize("NFKC", (title or "").strip()).lower()
+    text = text.replace(" ", "-")
+    text = _UNSAFE_CHARS_RE.sub("-", text).strip("-")
+    text = re.sub(r"-{2,}", "-", text)
+    if len(text) > max_len:
+        text = text[:max_len].rstrip("-")
+    return text or "note"
+
+
+def extract_wikilinks(text: str) -> list[str]:
+    """Return the targets of every ``[[wikilink]]`` in ``text`` (de-duplicated)."""
+    seen: list[str] = []
+    for match in _WIKILINK_RE.finditer(text or ""):
+        target = match.group(1).strip()
+        if target and target not in seen:
+            seen.append(target)
+    return seen
+
+
+def normalize_wikilink_target(target: str) -> str:
+    """Canonicalize a ``[[wikilink]]`` target for resolution/comparison.
+
+    Drops any ``|alias`` part, normalizes slashes, strips a leading ``/`` and a
+    trailing ``.md`` — so ``[[index]]``, ``index.md`` and ``/index`` all map to
+    the same canonical ``index`` key used by the index/graph/resolver layers.
+    """
+    t = (target or "").strip()
+    if not t:
+        return ""
+    t = t.split("|", 1)[0].strip()
+    t = t.replace("\\", "/").lstrip("/")
+    if t.lower().endswith(".md"):
+        t = t[:-3]
+    return t
+
+
+class VaultPathError(ValueError):
+    """Raised when a requested vault path escapes the vault root."""
+
+
+class MarkdownVault:
+    """Reads/writes Markdown files inside a single vault root directory."""
+
+    def __init__(self, root: Path | str) -> None:
+        self.root = Path(root).resolve()
+
+    # -- path safety ------------------------------------------------------
+    def resolve(self, rel_path: str) -> Path:
+        """Resolve ``rel_path`` under the vault root, blocking traversal."""
+        rel = str(rel_path).replace("\\", "/").lstrip("/")
+        candidate = (self.root / rel).resolve()
+        try:
+            candidate.relative_to(self.root)
+        except ValueError as exc:
+            raise VaultPathError(f"Path escapes vault root: {rel_path!r}") from exc
+        return candidate
+
+    def note_relpath(self, *, category: str, project_name: str | None, slug: str, note_id: str) -> str:
+        """Build a vault-relative path for a note.
+
+        Project knowledge goes under ``projects/<project>/<category>/`` per
+        wiki-capture; a short id suffix guarantees uniqueness.
+        """
+        from deerflow.knowledge.skill_templates import category_to_dir
+
+        cat_dir = category_to_dir(category)
+        safe_slug = slugify(slug)
+        suffix = note_id.split("_")[-1][:8]
+        filename = f"{safe_slug}-{suffix}.md"
+        if project_name:
+            return f"projects/{slugify(project_name)}/{cat_dir}/{filename}"
+        return f"{cat_dir}/{filename}"
+
+    # -- scaffold ---------------------------------------------------------
+    def ensure_scaffold(self, *, project_name: str | None = None) -> None:
+        """Create the vault directory tree + base files if missing."""
+        self.root.mkdir(parents=True, exist_ok=True)
+        for d in _VAULT_DIRS:
+            (self.root / d).mkdir(parents=True, exist_ok=True)
+        if project_name:
+            base = self.root / "projects" / slugify(project_name)
+            for d in ("concepts", "references", "synthesis", "journal"):
+                (base / d).mkdir(parents=True, exist_ok=True)
+        # Base vault files.
+        index = self.root / "index.md"
+        if not index.exists():
+            index.write_text("# Knowledge Index\n\n_页面索引。每次写入新页面后自动更新。_\n\n", encoding="utf-8")
+        log = self.root / "log.md"
+        if not log.exists():
+            log.write_text("# Activity Log\n\n_CAPTURE / INGEST / QUERY / EXPORT 记录。_\n\n", encoding="utf-8")
+        hot = self.root / "hot.md"
+        if not hot.exists():
+            hot.write_text("# Hot\n\n_近期活动摘要。_\n\n", encoding="utf-8")
+        taxonomy = self.root / "_meta" / "taxonomy.md"
+        if not taxonomy.exists():
+            taxonomy.write_text(
+                "# Taxonomy\n\n- synthesis — 多步骤分析、方案、结论\n- concepts — 概念、框架、模型\n"
+                "- references — 外部来源、搜索结果、文章资料\n- decision — 架构或设计决策\n- journal — 完整会话摘要\n",
+                encoding="utf-8",
+            )
+
+    # -- frontmatter ------------------------------------------------------
+    @staticmethod
+    def build_frontmatter(
+        *,
+        note_id: str,
+        title: str,
+        category: str,
+        tags: list[str],
+        sources: list[str],
+        summary: str,
+        created: str,
+        updated: str,
+        base_confidence: float,
+        lifecycle: str,
+        provenance: dict[str, float] | None = None,
+        relationships: list[dict[str, str]] | None = None,
+    ) -> dict[str, Any]:
+        """Build an obsidian-wiki / wiki-capture compatible frontmatter dict."""
+        created_date = (created or "")[:10]
+        return {
+            "id": note_id,
+            "title": title,
+            "category": category,
+            "tags": list(tags or []),
+            "sources": list(sources or []),
+            "created": created,
+            "updated": updated,
+            "summary": summary or "",
+            "provenance": provenance or {"extracted": 0.7, "inferred": 0.2, "ambiguous": 0.1},
+            "base_confidence": round(float(base_confidence or 0.0), 2),
+            "lifecycle": lifecycle,
+            "lifecycle_changed": created_date,
+            "relationships": relationships or [],
+        }
+
+    # -- IO ---------------------------------------------------------------
+    def write_note(self, rel_path: str, frontmatter: dict[str, Any], body: str) -> Path:
+        """Write ``frontmatter`` + ``body`` to ``rel_path`` (creates dirs)."""
+        path = self.resolve(rel_path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        fm = yaml.safe_dump(frontmatter, allow_unicode=True, sort_keys=False, default_flow_style=False)
+        path.write_text(f"---\n{fm}---\n\n{body.strip()}\n", encoding="utf-8")
+        return path
+
+    def read_note(self, rel_path: str) -> tuple[dict[str, Any], str] | None:
+        """Return ``(frontmatter, body)`` for a note, or ``None`` if missing."""
+        path = self.resolve(rel_path)
+        if not path.exists():
+            return None
+        return self.parse(path.read_text(encoding="utf-8"))
+
+    @staticmethod
+    def parse(text: str) -> tuple[dict[str, Any], str]:
+        """Split raw Markdown into ``(frontmatter dict, body)``."""
+        match = _FRONTMATTER_RE.match(text or "")
+        if not match:
+            return {}, text or ""
+        try:
+            fm = yaml.safe_load(match.group(1)) or {}
+        except yaml.YAMLError:
+            fm = {}
+        if not isinstance(fm, dict):
+            fm = {}
+        return fm, match.group(2) or ""
+
+    def delete_note(self, rel_path: str) -> None:
+        """Remove a note file if present (used on hard delete; archive keeps it)."""
+        path = self.resolve(rel_path)
+        if path.exists():
+            path.unlink()
+
+
+def now_iso_with_tz(dt: datetime) -> str:
+    """ISO-8601 string with timezone offset (frontmatter ``created``/``updated``)."""
+    if dt.tzinfo is None:
+        return dt.isoformat()
+    return dt.isoformat(timespec="seconds")
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/models.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/models.py
new file mode 100644
index 00000000..07a4e338
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/models.py
@@ -0,0 +1,141 @@
+"""ORM models for the product knowledge base.
+
+Tables mirror the obsidian-wiki vault into the database so the product can
+list, filter, search and audit notes quickly without re-parsing Markdown. The
+vault Markdown remains the source-of-truth for ``content_md`` / frontmatter /
+graph; these rows are an index + audit layer.
+
+The knowledge base is **global / shared** — there is no ``user_id`` isolation.
+Writes record ``created_by`` / ``updated_by`` for auditing only.
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+from sqlalchemy import Float, ForeignKey, Integer, String, Text, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column
+
+from deerflow.persistence.base import Base
+from deerflow.persistence.types import BeijingDateTime, PortableJSON, PortableLongText
+
+
+class KnowledgeNoteRow(Base):
+    """Knowledge note main table (mirrors ``knowledge_notes``)."""
+
+    __tablename__ = "knowledge_notes"
+
+    id: Mapped[str] = mapped_column(String(64), primary_key=True)
+    title: Mapped[str] = mapped_column(String(512))
+    summary: Mapped[str | None] = mapped_column(Text)
+    content_md: Mapped[str] = mapped_column(PortableLongText())
+    vault_path: Mapped[str | None] = mapped_column(String(1024), index=True)
+    source_type: Mapped[str] = mapped_column(String(64), index=True)
+    source_id: Mapped[str | None] = mapped_column(String(256), index=True)
+    status: Mapped[str] = mapped_column(String(32), default="approved", index=True)
+    confidence: Mapped[float] = mapped_column(Float, default=0.0)
+    created_by: Mapped[str | None] = mapped_column(String(128), index=True)
+    updated_by: Mapped[str | None] = mapped_column(String(128))
+    created_at: Mapped[datetime] = mapped_column(BeijingDateTime(), default=lambda: datetime.now(UTC), index=True)
+    updated_at: Mapped[datetime] = mapped_column(BeijingDateTime(), default=lambda: datetime.now(UTC), onupdate=lambda: datetime.now(UTC), index=True)
+
+
+class KnowledgeSourceRow(Base):
+    """Knowledge source table (mirrors ``knowledge_sources``)."""
+
+    __tablename__ = "knowledge_sources"
+
+    id: Mapped[str] = mapped_column(String(64), primary_key=True)
+    note_id: Mapped[str] = mapped_column(String(64), ForeignKey("knowledge_notes.id", ondelete="CASCADE"), index=True)
+    source_type: Mapped[str] = mapped_column(String(64))
+    thread_id: Mapped[str | None] = mapped_column(String(128), index=True)
+    message_id: Mapped[str | None] = mapped_column(String(128))
+    tool_name: Mapped[str | None] = mapped_column(String(128))
+    title: Mapped[str | None] = mapped_column(String(512))
+    url: Mapped[str | None] = mapped_column(Text)
+    snippet: Mapped[str | None] = mapped_column(Text)
+    raw_json: Mapped[str | None] = mapped_column(PortableLongText())
+    created_by: Mapped[str | None] = mapped_column(String(128))
+    created_at: Mapped[datetime] = mapped_column(BeijingDateTime(), default=lambda: datetime.now(UTC))
+
+
+class KnowledgeTagRow(Base):
+    """Tag table (mirrors ``knowledge_tags``)."""
+
+    __tablename__ = "knowledge_tags"
+
+    id: Mapped[str] = mapped_column(String(64), primary_key=True)
+    name: Mapped[str] = mapped_column(String(128), unique=True, index=True)
+    created_at: Mapped[datetime] = mapped_column(BeijingDateTime(), default=lambda: datetime.now(UTC))
+
+
+class KnowledgeNoteTagRow(Base):
+    """Note ↔ tag join table (mirrors ``knowledge_note_tags``)."""
+
+    __tablename__ = "knowledge_note_tags"
+    __table_args__ = (UniqueConstraint("note_id", "tag_id", name="uq_knowledge_note_tags"),)
+
+    note_id: Mapped[str] = mapped_column(String(64), ForeignKey("knowledge_notes.id", ondelete="CASCADE"), primary_key=True)
+    tag_id: Mapped[str] = mapped_column(String(64), ForeignKey("knowledge_tags.id", ondelete="CASCADE"), primary_key=True)
+
+
+class KnowledgeEmbeddingRow(Base):
+    """Per-chunk embedding index (phase 2, mirrors ``knowledge_embeddings``).
+
+    The vector is stored as a JSON float array; first-release similarity is
+    computed in Python (no external vector DB). ``vector_id`` is reserved for a
+    future external store mapping.
+    """
+
+    __tablename__ = "knowledge_embeddings"
+
+    id: Mapped[str] = mapped_column(String(64), primary_key=True)
+    note_id: Mapped[str] = mapped_column(String(64), ForeignKey("knowledge_notes.id", ondelete="CASCADE"), index=True)
+    chunk_index: Mapped[int] = mapped_column(Integer, default=0)
+    content: Mapped[str] = mapped_column(Text)
+    vector: Mapped[list] = mapped_column(PortableJSON(), default=list)
+    vector_id: Mapped[str | None] = mapped_column(String(256))
+    created_at: Mapped[datetime] = mapped_column(BeijingDateTime(), default=lambda: datetime.now(UTC))
+
+
+class KnowledgeNoteVersionRow(Base):
+    """Immutable snapshot of a note before each update (phase 3 versioning)."""
+
+    __tablename__ = "knowledge_note_versions"
+
+    id: Mapped[str] = mapped_column(String(64), primary_key=True)
+    note_id: Mapped[str] = mapped_column(String(64), ForeignKey("knowledge_notes.id", ondelete="CASCADE"), index=True)
+    title: Mapped[str] = mapped_column(String(512))
+    summary: Mapped[str | None] = mapped_column(Text)
+    content_md: Mapped[str] = mapped_column(PortableLongText())
+    status: Mapped[str] = mapped_column(String(32))
+    tags_json: Mapped[list] = mapped_column(PortableJSON(), default=list)
+    edited_by: Mapped[str | None] = mapped_column(String(128))
+    created_at: Mapped[datetime] = mapped_column(BeijingDateTime(), default=lambda: datetime.now(UTC), index=True)
+
+
+class KnowledgeEntityRow(Base):
+    """Knowledge entity (phase 4, mirrors ``knowledge_entities``)."""
+
+    __tablename__ = "knowledge_entities"
+    __table_args__ = (UniqueConstraint("name", "entity_type", name="uq_knowledge_entities_name_type"),)
+
+    id: Mapped[str] = mapped_column(String(64), primary_key=True)
+    name: Mapped[str] = mapped_column(String(256), index=True)
+    entity_type: Mapped[str | None] = mapped_column(String(64))
+    created_at: Mapped[datetime] = mapped_column(BeijingDateTime(), default=lambda: datetime.now(UTC))
+
+
+class KnowledgeRelationRow(Base):
+    """Relation between notes/entities (phase 4, mirrors ``knowledge_relations``)."""
+
+    __tablename__ = "knowledge_relations"
+
+    id: Mapped[str] = mapped_column(String(64), primary_key=True)
+    from_note_id: Mapped[str | None] = mapped_column(String(64), index=True)
+    to_note_id: Mapped[str | None] = mapped_column(String(64), index=True)
+    from_entity_id: Mapped[str | None] = mapped_column(String(64), index=True)
+    to_entity_id: Mapped[str | None] = mapped_column(String(64), index=True)
+    relation_type: Mapped[str] = mapped_column(String(128))
+    weight: Mapped[float] = mapped_column(Float, default=1.0)
+    created_at: Mapped[datetime] = mapped_column(BeijingDateTime(), default=lambda: datetime.now(UTC))
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/obsidian_adapter.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/obsidian_adapter.py
new file mode 100644
index 00000000..fef599bc
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/obsidian_adapter.py
@@ -0,0 +1,254 @@
+"""ObsidianWikiAdapter — the obsidian-wiki vault facade.
+
+Owns the Markdown vault: writes notes with wiki-capture frontmatter/body, keeps
+``index.md`` / ``log.md`` / ``hot.md`` / ``.manifest.json`` in sync after every
+write, and produces wiki-export graph artifacts. Output stays compatible with
+``ar9av/obsidian-wiki`` without ever invoking its CLI.
+
+This class is storage-only (no DB, no LLM). The :class:`KnowledgeService`
+combines it with the repository + extractor.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from deerflow.knowledge import exporter
+from deerflow.knowledge.manifest import Manifest, content_hash
+from deerflow.knowledge.markdown_vault import MarkdownVault
+from deerflow.knowledge.schemas import NoteDraft
+
+_INDEX_PAGES_HEADER = "## Pages"
+_HOT_HEADER = "## Recent"
+_HOT_MAX = 20
+
+
+class ObsidianWikiAdapter:
+    """Read/write an obsidian-wiki compatible vault."""
+
+    def __init__(self, vault_root: Path | str, *, project_name: str = "zncm", export_html: bool = True, export_json: bool = True) -> None:
+        self.vault = MarkdownVault(vault_root)
+        self.root = self.vault.root
+        self.manifest = Manifest(self.root)
+        self.project_name = project_name
+        self.export_html = export_html
+        self.export_json = export_json
+
+    def ensure_ready(self) -> None:
+        self.vault.ensure_scaffold(project_name=self.project_name)
+
+    # -- writes -----------------------------------------------------------
+    def write_note(
+        self,
+        note_id: str,
+        draft: NoteDraft,
+        *,
+        created: str,
+        updated: str,
+        status: str,
+    ) -> str:
+        """Write the note file, sync vault metadata, return the vault path."""
+        self.ensure_ready()
+        rel = self.vault.note_relpath(category=draft.category, project_name=self.project_name, slug=draft.title, note_id=note_id)
+        sources_fm = self._frontmatter_sources(draft)
+        relationships = [{"target": link, "type": "related"} for link in (draft.related or [])[:8]]
+        frontmatter = self.vault.build_frontmatter(
+            note_id=note_id,
+            title=draft.title,
+            category=draft.category,
+            tags=draft.tags,
+            sources=sources_fm,
+            summary=draft.summary,
+            created=created,
+            updated=updated,
+            base_confidence=draft.confidence,
+            lifecycle=status,
+            relationships=relationships,
+        )
+        self.vault.write_note(rel, frontmatter, draft.content_md)
+        self.manifest.record_page(
+            note_id=note_id,
+            vault_path=rel,
+            source_key=draft.source_key,
+            hash_value=content_hash(draft.content_md),
+            updated=updated,
+        )
+        self._update_index(note_id, rel, draft.title, draft.summary)
+        self._append_log("CAPTURE" if draft.source_type in ("thread", "search", "tool") else "INGEST", note_id, draft.title, updated)
+        self._update_hot(draft.title, rel, updated)
+        return rel
+
+    def update_note_file(
+        self,
+        note_id: str,
+        vault_path: str | None,
+        *,
+        title: str,
+        content_md: str,
+        tags: list[str],
+        status: str,
+        summary: str,
+        category: str,
+        created: str,
+        updated: str,
+    ) -> str:
+        """Rewrite a note file in place (frontmatter refreshed), sync metadata."""
+        self.ensure_ready()
+        rel = vault_path
+        if not rel:
+            rel = self.vault.note_relpath(category=category, project_name=self.project_name, slug=title, note_id=note_id)
+        # Preserve original `sources`/`provenance`/`category` frontmatter when present.
+        existing = self.vault.read_note(rel)
+        sources_fm = existing[0].get("sources", []) if existing else []
+        provenance = existing[0].get("provenance") if existing else None
+        relationships = existing[0].get("relationships") if existing else []
+        effective_category = (existing[0].get("category") if existing else None) or category
+        frontmatter = self.vault.build_frontmatter(
+            note_id=note_id,
+            title=title,
+            category=effective_category,
+            tags=tags,
+            sources=sources_fm,
+            summary=summary,
+            created=created,
+            updated=updated,
+            base_confidence=float((existing[0].get("base_confidence") if existing else 0.0) or 0.0),
+            lifecycle=status,
+            provenance=provenance,
+            relationships=relationships,
+        )
+        self.vault.write_note(rel, frontmatter, content_md)
+        self.manifest.record_page(
+            note_id=note_id,
+            vault_path=rel,
+            source_key=self.manifest.load().get("pages", {}).get(note_id, {}).get("source"),
+            hash_value=content_hash(content_md),
+            updated=updated,
+        )
+        self._update_index(note_id, rel, title, summary)
+        self._append_log("UPDATE", note_id, title, updated)
+        self._update_hot(title, rel, updated)
+        return rel
+
+    def archive_note(self, note_id: str, vault_path: str | None, *, updated: str) -> None:
+        """Mark a note archived in its frontmatter + log (soft delete)."""
+        if vault_path:
+            parsed = self.vault.read_note(vault_path)
+            if parsed:
+                fm, body = parsed
+                fm["lifecycle"] = "archived"
+                fm["updated"] = updated
+                self.vault.write_note(vault_path, fm, body)
+        self._remove_from_index(note_id)
+        self._append_log("ARCHIVE", note_id, "", updated)
+
+    def export_graph(
+        self,
+        notes: list[dict[str, Any]],
+        *,
+        entities: list[dict[str, Any]] | None = None,
+        relations: list[dict[str, Any]] | None = None,
+        updated: str,
+    ) -> dict[str, Any]:
+        self.ensure_ready()
+        result = exporter.export_all(
+            self.root,
+            notes,
+            entities=entities,
+            relations=relations,
+            write_html=self.export_html,
+            write_json=self.export_json,
+        )
+        self._append_log("EXPORT", "graph", f"nodes={result['stats']['nodes']} edges={result['stats']['edges']}", updated)
+        return result
+
+    def export_file_path(self, filename: str) -> Path | None:
+        allowed = {"graph.json", "graph.graphml", "cypher.txt", "graph.html"}
+        if filename not in allowed:
+            return None
+        path = (self.root / "wiki-export" / filename).resolve()
+        try:
+            path.relative_to(self.root)
+        except ValueError:
+            return None
+        return path if path.exists() else None
+
+    # -- frontmatter source serialization ---------------------------------
+    @staticmethod
+    def _frontmatter_sources(draft: NoteDraft) -> list[str]:
+        out: list[str] = []
+        if draft.source_type == "thread" and draft.source_id:
+            out.append(f"thread:{draft.source_id}")
+        for s in draft.sources[:20]:
+            if s.url:
+                out.append(f"url:{s.url}")
+            elif s.thread_id:
+                out.append(f"thread:{s.thread_id}")
+            elif s.tool_name:
+                out.append(f"tool:{s.tool_name}")
+        # De-dup preserving order.
+        seen: set[str] = set()
+        deduped = []
+        for item in out:
+            if item not in seen:
+                seen.add(item)
+                deduped.append(item)
+        return deduped
+
+    # -- index.md ---------------------------------------------------------
+    def _index_path(self) -> Path:
+        return self.root / "index.md"
+
+    def _update_index(self, note_id: str, rel: str, title: str, summary: str | None) -> None:
+        path = self._index_path()
+        text = path.read_text(encoding="utf-8") if path.exists() else "# Knowledge Index\n\n"
+        link = rel[:-3] if rel.endswith(".md") else rel
+        summary_txt = (summary or "").strip().replace("\n", " ")
+        if len(summary_txt) > 120:
+            summary_txt = summary_txt[:120] + "…"
+        line = f"- [[{link}|{title}]]" + (f" — {summary_txt}" if summary_txt else "") + f" <!-- id:{note_id} -->"
+        lines = text.splitlines()
+        # Drop any existing line for this note id.
+        lines = [ln for ln in lines if f"<!-- id:{note_id} -->" not in ln]
+        if _INDEX_PAGES_HEADER not in text:
+            lines.append("")
+            lines.append(_INDEX_PAGES_HEADER)
+            lines.append("")
+        # Insert after the Pages header.
+        try:
+            insert_at = lines.index(_INDEX_PAGES_HEADER) + 1
+        except ValueError:
+            insert_at = len(lines)
+        lines.insert(insert_at, line)
+        path.write_text("\n".join(lines).rstrip() + "\n", encoding="utf-8")
+
+    def _remove_from_index(self, note_id: str) -> None:
+        path = self._index_path()
+        if not path.exists():
+            return
+        lines = [ln for ln in path.read_text(encoding="utf-8").splitlines() if f"<!-- id:{note_id} -->" not in ln]
+        path.write_text("\n".join(lines).rstrip() + "\n", encoding="utf-8")
+
+    # -- log.md -----------------------------------------------------------
+    def _append_log(self, action: str, note_id: str, label: str, updated: str) -> None:
+        path = self.root / "log.md"
+        text = path.read_text(encoding="utf-8") if path.exists() else "# Activity Log\n\n"
+        entry = f"- {updated} {action} {note_id}" + (f" — {label}" if label else "")
+        path.write_text(text.rstrip() + "\n" + entry + "\n", encoding="utf-8")
+
+    # -- hot.md -----------------------------------------------------------
+    def _update_hot(self, title: str, rel: str, updated: str) -> None:
+        path = self.root / "hot.md"
+        link = rel[:-3] if rel.endswith(".md") else rel
+        new_line = f"- {updated} [[{link}|{title}]]"
+        existing_lines: list[str] = []
+        if path.exists():
+            for ln in path.read_text(encoding="utf-8").splitlines():
+                if ln.startswith("- ") and "[[" in ln:
+                    existing_lines.append(ln)
+        existing_lines = [ln for ln in existing_lines if f"[[{link}" not in ln]
+        existing_lines.insert(0, new_line)
+        existing_lines = existing_lines[:_HOT_MAX]
+        body = "# Hot\n\n_近期活动摘要。_\n\n" + _HOT_HEADER + "\n\n" + "\n".join(existing_lines) + "\n"
+        path.write_text(body, encoding="utf-8")
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/repository.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/repository.py
new file mode 100644
index 00000000..6481d79f
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/repository.py
@@ -0,0 +1,528 @@
+"""Database read/write for the knowledge base.
+
+This layer never calls an LLM and never touches the Markdown vault — it only
+persists/queries the relational mirror (notes, sources, tags). The vault and
+extraction live in :mod:`deerflow.knowledge.markdown_vault` and
+:mod:`deerflow.knowledge.extractor`; orchestration lives in the service.
+"""
+
+from __future__ import annotations
+
+import uuid
+from datetime import UTC, datetime
+from typing import Any
+
+from sqlalchemy import delete, func, or_, select
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from deerflow.knowledge.models import (
+    KnowledgeEmbeddingRow,
+    KnowledgeEntityRow,
+    KnowledgeNoteRow,
+    KnowledgeNoteTagRow,
+    KnowledgeNoteVersionRow,
+    KnowledgeRelationRow,
+    KnowledgeSourceRow,
+    KnowledgeTagRow,
+)
+from deerflow.knowledge.schemas import SourceDraft
+
+
+def _new_id(prefix: str) -> str:
+    return f"{prefix}_{uuid.uuid4().hex[:24]}"
+
+
+def _iso(value: Any) -> Any:
+    if isinstance(value, datetime):
+        return value.isoformat()
+    return value
+
+
+class KnowledgeRepository:
+    """SQLAlchemy-backed repository for knowledge notes/sources/tags."""
+
+    def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
+        self._sf = session_factory
+
+    # -- serialization ----------------------------------------------------
+    @staticmethod
+    def _note_to_dict(row: KnowledgeNoteRow) -> dict[str, Any]:
+        d = row.to_dict()
+        d["created_at"] = _iso(d.get("created_at"))
+        d["updated_at"] = _iso(d.get("updated_at"))
+        return d
+
+    @staticmethod
+    def _source_to_dict(row: KnowledgeSourceRow) -> dict[str, Any]:
+        d = row.to_dict()
+        d["created_at"] = _iso(d.get("created_at"))
+        return d
+
+    # -- tags -------------------------------------------------------------
+    async def _get_or_create_tags(self, session: AsyncSession, names: list[str]) -> list[KnowledgeTagRow]:
+        cleaned = []
+        seen: set[str] = set()
+        for raw in names or []:
+            name = (raw or "").strip()
+            if not name or name.lower() in seen:
+                continue
+            seen.add(name.lower())
+            cleaned.append(name)
+        if not cleaned:
+            return []
+        existing = {
+            r.name.lower(): r
+            for r in (await session.execute(select(KnowledgeTagRow).where(func.lower(KnowledgeTagRow.name).in_([n.lower() for n in cleaned])))).scalars()
+        }
+        result: list[KnowledgeTagRow] = []
+        for name in cleaned:
+            row = existing.get(name.lower())
+            if row is None:
+                row = KnowledgeTagRow(id=_new_id("kbtag"), name=name, created_at=datetime.now(UTC))
+                session.add(row)
+                await session.flush()
+                existing[name.lower()] = row
+            result.append(row)
+        return result
+
+    async def _tags_for(self, session: AsyncSession, note_id: str) -> list[str]:
+        stmt = (
+            select(KnowledgeTagRow.name)
+            .join(KnowledgeNoteTagRow, KnowledgeNoteTagRow.tag_id == KnowledgeTagRow.id)
+            .where(KnowledgeNoteTagRow.note_id == note_id)
+            .order_by(KnowledgeTagRow.name)
+        )
+        return list((await session.execute(stmt)).scalars())
+
+    async def _tags_for_many(self, session: AsyncSession, note_ids: list[str]) -> dict[str, list[str]]:
+        if not note_ids:
+            return {}
+        stmt = (
+            select(KnowledgeNoteTagRow.note_id, KnowledgeTagRow.name)
+            .join(KnowledgeTagRow, KnowledgeNoteTagRow.tag_id == KnowledgeTagRow.id)
+            .where(KnowledgeNoteTagRow.note_id.in_(note_ids))
+            .order_by(KnowledgeTagRow.name)
+        )
+        out: dict[str, list[str]] = {nid: [] for nid in note_ids}
+        for note_id, name in (await session.execute(stmt)).all():
+            out.setdefault(note_id, []).append(name)
+        return out
+
+    async def _replace_note_tags(self, session: AsyncSession, note_id: str, names: list[str]) -> None:
+        await session.execute(delete(KnowledgeNoteTagRow).where(KnowledgeNoteTagRow.note_id == note_id))
+        tags = await self._get_or_create_tags(session, names)
+        for tag in tags:
+            session.add(KnowledgeNoteTagRow(note_id=note_id, tag_id=tag.id))
+
+    # -- notes ------------------------------------------------------------
+    async def create_note(
+        self,
+        *,
+        title: str,
+        summary: str | None,
+        content_md: str,
+        source_type: str,
+        source_id: str | None,
+        status: str,
+        confidence: float = 0.0,
+        vault_path: str | None = None,
+        tags: list[str] | None = None,
+        created_by: str | None = None,
+    ) -> dict[str, Any]:
+        note_id = _new_id("kb")
+        now = datetime.now(UTC)
+        row = KnowledgeNoteRow(
+            id=note_id,
+            title=title[:512],
+            summary=summary,
+            content_md=content_md,
+            vault_path=vault_path,
+            source_type=source_type,
+            source_id=source_id,
+            status=status,
+            confidence=confidence,
+            created_by=created_by,
+            updated_by=created_by,
+            created_at=now,
+            updated_at=now,
+        )
+        async with self._sf() as session:
+            session.add(row)
+            await session.flush()
+            await self._replace_note_tags(session, note_id, tags or [])
+            await session.commit()
+            await session.refresh(row)
+            d = self._note_to_dict(row)
+            d["tags"] = await self._tags_for(session, note_id)
+            return d
+
+    async def set_vault_path(self, note_id: str, vault_path: str) -> None:
+        async with self._sf() as session:
+            row = await session.get(KnowledgeNoteRow, note_id)
+            if row is None:
+                return
+            row.vault_path = vault_path
+            await session.commit()
+
+    async def update_note(
+        self,
+        note_id: str,
+        *,
+        title: str | None = None,
+        summary: str | None = None,
+        content_md: str | None = None,
+        status: str | None = None,
+        tags: list[str] | None = None,
+        vault_path: str | None = None,
+        updated_by: str | None = None,
+    ) -> dict[str, Any] | None:
+        async with self._sf() as session:
+            row = await session.get(KnowledgeNoteRow, note_id)
+            if row is None:
+                return None
+            if title is not None:
+                row.title = title[:512]
+            if summary is not None:
+                row.summary = summary
+            if content_md is not None:
+                row.content_md = content_md
+            if status is not None:
+                row.status = status
+            if vault_path is not None:
+                row.vault_path = vault_path
+            if updated_by is not None:
+                row.updated_by = updated_by
+            row.updated_at = datetime.now(UTC)
+            if tags is not None:
+                await self._replace_note_tags(session, note_id, tags)
+            await session.commit()
+            await session.refresh(row)
+            d = self._note_to_dict(row)
+            d["tags"] = await self._tags_for(session, note_id)
+            return d
+
+    async def set_status(self, note_id: str, status: str, *, updated_by: str | None = None) -> dict[str, Any] | None:
+        return await self.update_note(note_id, status=status, updated_by=updated_by)
+
+    async def get_note(self, note_id: str, *, with_sources: bool = True) -> dict[str, Any] | None:
+        async with self._sf() as session:
+            row = await session.get(KnowledgeNoteRow, note_id)
+            if row is None:
+                return None
+            d = self._note_to_dict(row)
+            d["tags"] = await self._tags_for(session, note_id)
+            if with_sources:
+                stmt = select(KnowledgeSourceRow).where(KnowledgeSourceRow.note_id == note_id).order_by(KnowledgeSourceRow.created_at)
+                d["sources"] = [self._source_to_dict(r) for r in (await session.execute(stmt)).scalars()]
+            return d
+
+    async def find_by_vault_path(self, vault_path: str) -> dict[str, Any] | None:
+        """Return the first (non-archived) note whose vault_path matches.
+
+        ``vault_path`` is matched both with and without the ``.md`` suffix, since
+        wikilink targets are stored without it while ``vault_path`` keeps it.
+        """
+        stripped = vault_path[:-3] if vault_path.endswith(".md") else vault_path
+        candidates = {vault_path, stripped, f"{stripped}.md"}
+        async with self._sf() as session:
+            stmt = (
+                select(KnowledgeNoteRow)
+                .where(KnowledgeNoteRow.vault_path.in_(list(candidates)))
+                .where(KnowledgeNoteRow.status != "archived")
+                .limit(1)
+            )
+            row = (await session.execute(stmt)).scalars().first()
+            if row is None:
+                return None
+            d = self._note_to_dict(row)
+            d["tags"] = await self._tags_for(session, row.id)
+            return d
+
+    async def find_by_title(self, title: str) -> dict[str, Any] | None:
+        """Return the first (non-archived) note with a case-insensitive title match."""
+        name = (title or "").strip()
+        if not name:
+            return None
+        async with self._sf() as session:
+            stmt = (
+                select(KnowledgeNoteRow)
+                .where(func.lower(KnowledgeNoteRow.title) == name.lower())
+                .where(KnowledgeNoteRow.status != "archived")
+                .order_by(KnowledgeNoteRow.updated_at.desc())
+                .limit(1)
+            )
+            row = (await session.execute(stmt)).scalars().first()
+            if row is None:
+                return None
+            d = self._note_to_dict(row)
+            d["tags"] = await self._tags_for(session, row.id)
+            return d
+
+    async def find_by_source(self, source_type: str, source_id: str) -> dict[str, Any] | None:
+        """Return the first (non-archived) note for a (source_type, source_id)."""
+        async with self._sf() as session:
+            stmt = (
+                select(KnowledgeNoteRow)
+                .where(KnowledgeNoteRow.source_type == source_type, KnowledgeNoteRow.source_id == source_id)
+                .where(KnowledgeNoteRow.status != "archived")
+                .limit(1)
+            )
+            row = (await session.execute(stmt)).scalars().first()
+            return self._note_to_dict(row) if row else None
+
+    async def list_notes(
+        self,
+        *,
+        keyword: str | None = None,
+        tag: str | None = None,
+        source_type: str | None = None,
+        status: str | None = None,
+        include_archived: bool = False,
+        limit: int = 20,
+        offset: int = 0,
+    ) -> tuple[list[dict[str, Any]], int]:
+        async with self._sf() as session:
+            stmt = select(KnowledgeNoteRow)
+            count_stmt = select(func.count()).select_from(KnowledgeNoteRow)
+
+            conditions = []
+            if status:
+                conditions.append(KnowledgeNoteRow.status == status)
+            elif not include_archived:
+                conditions.append(KnowledgeNoteRow.status != "archived")
+            if source_type:
+                conditions.append(KnowledgeNoteRow.source_type == source_type)
+            if keyword:
+                like = f"%{keyword}%"
+                conditions.append(or_(KnowledgeNoteRow.title.like(like), KnowledgeNoteRow.summary.like(like), KnowledgeNoteRow.content_md.like(like)))
+            if tag:
+                tag_subq = (
+                    select(KnowledgeNoteTagRow.note_id)
+                    .join(KnowledgeTagRow, KnowledgeNoteTagRow.tag_id == KnowledgeTagRow.id)
+                    .where(func.lower(KnowledgeTagRow.name) == tag.lower())
+                )
+                conditions.append(KnowledgeNoteRow.id.in_(tag_subq))
+
+            for cond in conditions:
+                stmt = stmt.where(cond)
+                count_stmt = count_stmt.where(cond)
+
+            total = (await session.execute(count_stmt)).scalar_one()
+            stmt = stmt.order_by(KnowledgeNoteRow.updated_at.desc()).limit(limit).offset(offset)
+            rows = list((await session.execute(stmt)).scalars())
+            ids = [r.id for r in rows]
+            tags_map = await self._tags_for_many(session, ids)
+            items = []
+            for r in rows:
+                d = self._note_to_dict(r)
+                d["tags"] = tags_map.get(r.id, [])
+                items.append(d)
+            return items, int(total)
+
+    async def list_all(self, *, include_archived: bool = False) -> list[dict[str, Any]]:
+        """Return every note (light fields + tags) for graph export."""
+        async with self._sf() as session:
+            stmt = select(KnowledgeNoteRow)
+            if not include_archived:
+                stmt = stmt.where(KnowledgeNoteRow.status != "archived")
+            rows = list((await session.execute(stmt)).scalars())
+            tags_map = await self._tags_for_many(session, [r.id for r in rows])
+            out = []
+            for r in rows:
+                d = self._note_to_dict(r)
+                d["tags"] = tags_map.get(r.id, [])
+                out.append(d)
+            return out
+
+    # -- embeddings (phase 2) --------------------------------------------
+    async def replace_embeddings(self, note_id: str, chunks: list[tuple[int, str, list[float]]]) -> None:
+        """Replace all embedding rows for a note with ``(index, content, vector)``."""
+        async with self._sf() as session:
+            await session.execute(delete(KnowledgeEmbeddingRow).where(KnowledgeEmbeddingRow.note_id == note_id))
+            for idx, content, vector in chunks:
+                session.add(
+                    KnowledgeEmbeddingRow(
+                        id=_new_id("kbemb"),
+                        note_id=note_id,
+                        chunk_index=idx,
+                        content=content,
+                        vector=list(vector),
+                        created_at=datetime.now(UTC),
+                    )
+                )
+            await session.commit()
+
+    async def delete_embeddings(self, note_id: str) -> None:
+        async with self._sf() as session:
+            await session.execute(delete(KnowledgeEmbeddingRow).where(KnowledgeEmbeddingRow.note_id == note_id))
+            await session.commit()
+
+    async def all_embeddings(self) -> list[dict[str, Any]]:
+        """Return every embedding chunk joined to its (non-archived) note."""
+        async with self._sf() as session:
+            stmt = (
+                select(KnowledgeEmbeddingRow, KnowledgeNoteRow.title, KnowledgeNoteRow.status)
+                .join(KnowledgeNoteRow, KnowledgeNoteRow.id == KnowledgeEmbeddingRow.note_id)
+                .where(KnowledgeNoteRow.status != "archived")
+            )
+            out = []
+            for emb, title, _status in (await session.execute(stmt)).all():
+                out.append({"note_id": emb.note_id, "chunk_index": emb.chunk_index, "content": emb.content, "vector": emb.vector or [], "title": title})
+            return out
+
+    async def has_embeddings(self) -> bool:
+        async with self._sf() as session:
+            row = (await session.execute(select(KnowledgeEmbeddingRow.id).limit(1))).first()
+            return row is not None
+
+    # -- versions (phase 3) ----------------------------------------------
+    async def add_version(self, note: dict[str, Any], *, edited_by: str | None) -> None:
+        async with self._sf() as session:
+            session.add(
+                KnowledgeNoteVersionRow(
+                    id=_new_id("kbver"),
+                    note_id=note["id"],
+                    title=note.get("title") or "",
+                    summary=note.get("summary"),
+                    content_md=note.get("content_md") or "",
+                    status=note.get("status") or "approved",
+                    tags_json=note.get("tags") or [],
+                    edited_by=edited_by,
+                    created_at=datetime.now(UTC),
+                )
+            )
+            await session.commit()
+
+    async def list_versions(self, note_id: str) -> list[dict[str, Any]]:
+        async with self._sf() as session:
+            stmt = select(KnowledgeNoteVersionRow).where(KnowledgeNoteVersionRow.note_id == note_id).order_by(KnowledgeNoteVersionRow.created_at.desc())
+            out = []
+            for r in (await session.execute(stmt)).scalars():
+                d = r.to_dict()
+                d["tags"] = d.pop("tags_json", [])
+                d["created_at"] = _iso(d.get("created_at"))
+                out.append(d)
+            return out
+
+    # -- entities & relations (phase 4) ----------------------------------
+    async def get_or_create_entity(self, name: str, entity_type: str | None) -> dict[str, Any]:
+        name = (name or "").strip()
+        async with self._sf() as session:
+            stmt = select(KnowledgeEntityRow).where(func.lower(KnowledgeEntityRow.name) == name.lower())
+            row = (await session.execute(stmt)).scalars().first()
+            if row is None:
+                row = KnowledgeEntityRow(id=_new_id("kbent"), name=name, entity_type=entity_type, created_at=datetime.now(UTC))
+                session.add(row)
+                await session.commit()
+                await session.refresh(row)
+            return {"id": row.id, "name": row.name, "entity_type": row.entity_type}
+
+    async def add_relation(
+        self,
+        *,
+        from_note_id: str | None = None,
+        to_note_id: str | None = None,
+        from_entity_id: str | None = None,
+        to_entity_id: str | None = None,
+        relation_type: str,
+        weight: float = 1.0,
+    ) -> None:
+        async with self._sf() as session:
+            session.add(
+                KnowledgeRelationRow(
+                    id=_new_id("kbrel"),
+                    from_note_id=from_note_id,
+                    to_note_id=to_note_id,
+                    from_entity_id=from_entity_id,
+                    to_entity_id=to_entity_id,
+                    relation_type=relation_type,
+                    weight=weight,
+                    created_at=datetime.now(UTC),
+                )
+            )
+            await session.commit()
+
+    async def clear_note_relations(self, note_id: str) -> None:
+        async with self._sf() as session:
+            await session.execute(delete(KnowledgeRelationRow).where(KnowledgeRelationRow.from_note_id == note_id))
+            await session.commit()
+
+    async def list_note_entities(self, note_id: str) -> list[dict[str, Any]]:
+        """Return the entities mentioned by a note (for note-detail display)."""
+        async with self._sf() as session:
+            stmt = (
+                select(KnowledgeEntityRow.name, KnowledgeEntityRow.entity_type)
+                .join(KnowledgeRelationRow, KnowledgeRelationRow.to_entity_id == KnowledgeEntityRow.id)
+                .where(KnowledgeRelationRow.from_note_id == note_id)
+                .order_by(KnowledgeEntityRow.name)
+            )
+            seen: set[str] = set()
+            out: list[dict[str, Any]] = []
+            for name, etype in (await session.execute(stmt)).all():
+                key = (name or "").lower()
+                if not name or key in seen:
+                    continue
+                seen.add(key)
+                out.append({"name": name, "entity_type": etype})
+            return out
+
+    async def prune_orphan_entities(self) -> int:
+        """Delete entity rows no longer referenced by any relation. Returns count."""
+        async with self._sf() as session:
+            referenced: set[str] = set()
+            for col in (KnowledgeRelationRow.from_entity_id, KnowledgeRelationRow.to_entity_id):
+                for (eid,) in (await session.execute(select(col).where(col.isnot(None)))).all():
+                    referenced.add(eid)
+            all_ids = list((await session.execute(select(KnowledgeEntityRow.id))).scalars())
+            orphans = [eid for eid in all_ids if eid not in referenced]
+            if orphans:
+                await session.execute(delete(KnowledgeEntityRow).where(KnowledgeEntityRow.id.in_(orphans)))
+                await session.commit()
+            return len(orphans)
+
+    async def list_entities(self) -> list[dict[str, Any]]:
+        async with self._sf() as session:
+            rows = (await session.execute(select(KnowledgeEntityRow))).scalars()
+            return [{"id": r.id, "name": r.name, "entity_type": r.entity_type} for r in rows]
+
+    async def list_relations(self) -> list[dict[str, Any]]:
+        async with self._sf() as session:
+            rows = (await session.execute(select(KnowledgeRelationRow))).scalars()
+            return [
+                {
+                    "id": r.id,
+                    "from_note_id": r.from_note_id,
+                    "to_note_id": r.to_note_id,
+                    "from_entity_id": r.from_entity_id,
+                    "to_entity_id": r.to_entity_id,
+                    "relation_type": r.relation_type,
+                    "weight": r.weight,
+                }
+                for r in rows
+            ]
+
+    # -- sources ----------------------------------------------------------
+    async def add_sources(self, note_id: str, sources: list[SourceDraft], *, created_by: str | None = None) -> None:
+        if not sources:
+            return
+        import json
+
+        async with self._sf() as session:
+            for src in sources:
+                session.add(
+                    KnowledgeSourceRow(
+                        id=_new_id("kbsrc"),
+                        note_id=note_id,
+                        source_type=src.source_type,
+                        thread_id=src.thread_id,
+                        message_id=src.message_id,
+                        tool_name=src.tool_name,
+                        title=(src.title or "")[:512] or None,
+                        url=src.url,
+                        snippet=src.snippet,
+                        raw_json=json.dumps(src.raw, ensure_ascii=False) if src.raw else None,
+                        created_by=created_by,
+                        created_at=datetime.now(UTC),
+                    )
+                )
+            await session.commit()
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/schemas.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/schemas.py
new file mode 100644
index 00000000..c46cfdec
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/schemas.py
@@ -0,0 +1,75 @@
+"""Internal domain models for the knowledge module.
+
+These are plain dataclasses passed between the extractor, the vault writer and
+the repository. The Gateway router defines its own Pydantic request/response
+models on top of the dicts the service returns.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+# Allowed note source types (see product-knowledge-base-dev.md §7.1).
+SOURCE_TYPES = ("thread", "search", "tool", "file", "manual", "report")
+# Allowed lifecycle states.
+STATUSES = ("draft", "approved", "archived")
+# obsidian-wiki wiki-capture categories.
+CATEGORIES = ("synthesis", "concepts", "references", "decision", "journal")
+
+
+@dataclass
+class SourceDraft:
+    """A normalized knowledge source (search result, tool call, thread, …)."""
+
+    source_type: str
+    thread_id: str | None = None
+    message_id: str | None = None
+    tool_name: str | None = None
+    title: str | None = None
+    url: str | None = None
+    snippet: str | None = None
+    raw: dict | None = None
+
+
+@dataclass
+class NoteDraft:
+    """A knowledge note ready to be persisted + written to the vault.
+
+    Produced by the extractor (from a thread / search / tool result) or built
+    directly for a manual note. ``content_md`` here is the *body* — the vault
+    writer prepends obsidian-wiki frontmatter.
+    """
+
+    title: str
+    summary: str
+    content_md: str
+    category: str = "synthesis"
+    source_type: str = "manual"
+    source_id: str | None = None
+    status: str = "approved"
+    confidence: float = 0.0
+    tags: list[str] = field(default_factory=list)
+    key_points: list[str] = field(default_factory=list)
+    actions: list[str] = field(default_factory=list)
+    related: list[str] = field(default_factory=list)
+    sources: list[SourceDraft] = field(default_factory=list)
+    # Phase 4: extracted graph signal. entities=[{name,type}],
+    # relations=[{from,to,type}] (names refer to entities or this note's title).
+    entities: list[dict] = field(default_factory=list)
+    relations: list[dict] = field(default_factory=list)
+    # Stable identity hint used for manifest dedup (e.g. ``thread:thread_id``).
+    source_key: str | None = None
+
+
+def normalize_status(status: str | None) -> str:
+    """Coerce an arbitrary status string to a valid lifecycle state."""
+    if status in STATUSES:
+        return status
+    return "approved"
+
+
+def normalize_source_type(source_type: str | None) -> str:
+    """Coerce an arbitrary source-type string to a valid value."""
+    if source_type in SOURCE_TYPES:
+        return source_type
+    return "manual"
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/search.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/search.py
new file mode 100644
index 00000000..f3430e17
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/search.py
@@ -0,0 +1,160 @@
+"""Knowledge search: keyword / vector / hybrid (phase 1 + 2).
+
+- ``keyword`` — title>tags>summary>body scoring over the DB mirror (always works).
+- ``vector``  — cosine over per-chunk embeddings (requires a configured
+  embedding endpoint; otherwise transparently falls back to ``keyword``).
+- ``hybrid``  — min-max-normalized blend of keyword + vector.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING, Any
+
+from deerflow.knowledge.embeddings import cosine_similarity
+from deerflow.knowledge.repository import KnowledgeRepository
+
+if TYPE_CHECKING:
+    from deerflow.knowledge.embeddings import EmbeddingClient
+
+_TOKEN_RE = re.compile(r"[\w一-鿿]+", re.UNICODE)
+
+
+def _tokens(text: str) -> list[str]:
+    return [t.lower() for t in _TOKEN_RE.findall(text or "")]
+
+
+def _snippet(content: str, terms: list[str], *, width: int = 160) -> str:
+    body = re.sub(r"\s+", " ", content or "").strip()
+    low = body.lower()
+    for term in terms:
+        idx = low.find(term)
+        if idx >= 0:
+            start = max(0, idx - width // 3)
+            end = min(len(body), start + width)
+            prefix = "…" if start > 0 else ""
+            suffix = "…" if end < len(body) else ""
+            return f"{prefix}{body[start:end]}{suffix}"
+    return body[:width] + ("…" if len(body) > width else "")
+
+
+async def _keyword_scores(repo: KnowledgeRepository, query: str, *, candidate_cap: int) -> dict[str, tuple[float, dict[str, Any]]]:
+    terms = _tokens(query)
+    if not terms:
+        return {}
+    candidates, _total = await repo.list_notes(limit=candidate_cap, offset=0)
+    scored: dict[str, tuple[float, dict[str, Any]]] = {}
+    for note in candidates:
+        title = (note.get("title") or "").lower()
+        summary = (note.get("summary") or "").lower()
+        content = (note.get("content_md") or "").lower()
+        tags = " ".join(note.get("tags") or []).lower()
+        score = 0.0
+        for term in terms:
+            if term in title:
+                score += 3.0
+            if term in tags:
+                score += 2.0
+            if term in summary:
+                score += 2.0
+            score += min(content.count(term), 5) * 0.5
+        if score > 0:
+            scored[note["id"]] = (score, note)
+    return scored
+
+
+async def _vector_scores(
+    repo: KnowledgeRepository,
+    query: str,
+    embedding_client: EmbeddingClient,
+) -> dict[str, tuple[float, dict[str, Any]]]:
+    qvec = await embedding_client.embed_query(query)
+    if not qvec:
+        return {}
+    embeddings = await repo.all_embeddings()
+    best: dict[str, tuple[float, str, str]] = {}  # note_id -> (score, title, snippet)
+    for emb in embeddings:
+        sim = cosine_similarity(qvec, emb.get("vector") or [])
+        if sim <= 0:
+            continue
+        nid = emb["note_id"]
+        if nid not in best or sim > best[nid][0]:
+            best[nid] = (sim, emb.get("title") or "", emb.get("content") or "")
+    return {nid: (score, {"id": nid, "title": title, "_chunk": chunk}) for nid, (score, title, chunk) in best.items()}
+
+
+def _normalize(scores: dict[str, float]) -> dict[str, float]:
+    if not scores:
+        return {}
+    mx = max(scores.values())
+    if mx <= 0:
+        return {k: 0.0 for k in scores}
+    return {k: v / mx for k, v in scores.items()}
+
+
+async def search_notes(
+    repo: KnowledgeRepository,
+    query: str,
+    *,
+    mode: str = "keyword",
+    limit: int = 8,
+    candidate_cap: int = 500,
+    embedding_client: EmbeddingClient | None = None,
+) -> list[dict[str, Any]]:
+    """Score notes against ``query`` and return the top ``limit`` matches."""
+    terms = _tokens(query)
+    if not terms:
+        return []
+
+    want_vector = mode in ("vector", "hybrid") and embedding_client is not None and embedding_client.is_enabled()
+    keyword = await _keyword_scores(repo, query, candidate_cap=candidate_cap) if mode != "vector" or not want_vector else {}
+    vector = await _vector_scores(repo, query, embedding_client) if want_vector else {}
+
+    # Pure vector (when available); else keyword; hybrid blends both.
+    if mode == "vector" and want_vector:
+        combined = {nid: (sc, meta) for nid, (sc, meta) in vector.items()}
+        ranked = sorted(combined.items(), key=lambda kv: kv[1][0], reverse=True)[:limit]
+        return await _materialize(repo, ranked, terms)
+
+    if mode == "hybrid" and want_vector:
+        kw_norm = _normalize({k: v[0] for k, v in keyword.items()})
+        vec_norm = _normalize({k: v[0] for k, v in vector.items()})
+        ids = set(kw_norm) | set(vec_norm)
+        blended: dict[str, tuple[float, dict[str, Any]]] = {}
+        for nid in ids:
+            score = 0.5 * kw_norm.get(nid, 0.0) + 0.5 * vec_norm.get(nid, 0.0)
+            meta = keyword.get(nid, (0, None))[1] or vector.get(nid, (0, {}))[1]
+            blended[nid] = (score, meta)
+        ranked = sorted(blended.items(), key=lambda kv: kv[1][0], reverse=True)[:limit]
+        return await _materialize(repo, ranked, terms)
+
+    # keyword (default, and fallback when vector unavailable)
+    ranked = sorted(keyword.items(), key=lambda kv: kv[1][0], reverse=True)[:limit]
+    if not ranked and vector:  # mode=vector requested but keyword empty: use vector
+        ranked = sorted(vector.items(), key=lambda kv: kv[1][0], reverse=True)[:limit]
+    return await _materialize(repo, ranked, terms)
+
+
+async def _materialize(repo: KnowledgeRepository, ranked: list[tuple[str, tuple[float, dict[str, Any]]]], terms: list[str]) -> list[dict[str, Any]]:
+    max_score = ranked[0][1][0] if ranked else 1.0
+    results: list[dict[str, Any]] = []
+    for nid, (score, meta) in ranked:
+        note = meta if (meta and meta.get("content_md")) else await repo.get_note(nid, with_sources=False)
+        if note is None:
+            continue
+        snippet_src = note.get("content_md") or meta.get("_chunk") or note.get("summary") or ""
+        results.append(
+            {
+                "note_id": nid,
+                "chunk_id": None,
+                "title": note.get("title") or meta.get("title"),
+                "summary": note.get("summary"),
+                "snippet": _snippet(snippet_src, terms),
+                "score": round(score / max_score, 4) if max_score else 0.0,
+                "tags": note.get("tags") or [],
+                "source_type": note.get("source_type"),
+                "updated_at": note.get("updated_at"),
+                "sources": [],
+            }
+        )
+    return results
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/sensitive.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/sensitive.py
new file mode 100644
index 00000000..ac7e3555
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/sensitive.py
@@ -0,0 +1,54 @@
+"""Sensitive-information redaction for knowledge content (phase 3).
+
+Best-effort masking of secrets / PII before a note is persisted: API keys,
+bearer tokens, generic ``key=secret`` assignments, Chinese mobile numbers,
+ID-card numbers and email addresses. Conservative by design — it favours not
+mangling legitimate prose over catching every possible secret.
+"""
+
+from __future__ import annotations
+
+import re
+
+_MASK = "[REDACTED]"
+
+# Order matters: more specific patterns first.
+_PATTERNS: list[tuple[str, re.Pattern[str]]] = [
+    ("openai_key", re.compile(r"\bsk-[A-Za-z0-9]{20,}\b")),
+    ("aws_key", re.compile(r"\b(?:AKIA|ASIA)[A-Z0-9]{16}\b")),
+    ("github_token", re.compile(r"\bgh[pousr]_[A-Za-z0-9]{20,}\b")),
+    ("bearer", re.compile(r"(?i)\bBearer\s+[A-Za-z0-9._\-]{16,}")),
+    # key/secret/password/token assignment: keep the field name, mask the value.
+    ("assignment", re.compile(r"(?i)\b(api[_-]?key|secret|password|passwd|token|access[_-]?token)\b\s*[:=]\s*[\"']?[^\s\"']{6,}[\"']?")),
+    ("cn_id_card", re.compile(r"\b\d{17}[\dXx]\b")),
+    ("cn_mobile", re.compile(r"(?<!\d)1[3-9]\d{9}(?!\d)")),
+    ("email", re.compile(r"\b[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}\b")),
+]
+
+
+def redact(text: str | None) -> tuple[str, list[str]]:
+    """Return ``(redacted_text, hit_kinds)``.
+
+    ``hit_kinds`` lists which detectors fired (for logging/audit). When ``text``
+    is falsy it is returned unchanged with no hits.
+    """
+    if not text:
+        return text or "", []
+    hits: list[str] = []
+    out = text
+    for kind, pattern in _PATTERNS:
+        def _sub(m: re.Match[str], _kind: str = kind) -> str:
+            # For assignments keep the field name + delimiter, mask only the value.
+            if _kind == "assignment":
+                head = re.split(r"[:=]", m.group(0), maxsplit=1)[0]
+                sep = ":" if ":" in m.group(0) else "="
+                return f"{head}{sep} {_MASK}"
+            if _kind == "bearer":
+                return f"Bearer {_MASK}"
+            return _MASK
+
+        new_out, n = pattern.subn(_sub, out)
+        if n:
+            hits.append(kind)
+            out = new_out
+    return out, hits
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/service.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/service.py
new file mode 100644
index 00000000..d1fbe3f9
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/service.py
@@ -0,0 +1,689 @@
+"""KnowledgeService — high-level orchestration for the knowledge base.
+
+Ties together the repository (DB mirror), the :class:`ObsidianWikiAdapter`
+(Markdown vault + index/log/hot/manifest + graph export) and the extractor
+(thread/search → :class:`NoteDraft`). The Gateway router only talks to this
+service; everything obsidian-wiki specific stays inside the ``knowledge``
+module.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from deerflow.config.knowledge_config import KnowledgeConfig
+from deerflow.config.runtime_paths import runtime_home
+from deerflow.knowledge import extractor, llm_extractor
+from deerflow.knowledge.chunking import chunk_markdown
+from deerflow.knowledge.embeddings import EmbeddingClient
+from deerflow.knowledge.markdown_vault import MarkdownVault, VaultPathError, extract_wikilinks, normalize_wikilink_target
+from deerflow.knowledge.obsidian_adapter import ObsidianWikiAdapter
+from deerflow.knowledge.repository import KnowledgeRepository
+from deerflow.knowledge.schemas import NoteDraft, SourceDraft, normalize_source_type, normalize_status
+from deerflow.knowledge.search import search_notes
+from deerflow.knowledge.sources import from_reference_batches, from_search_results
+
+logger = logging.getLogger(__name__)
+
+
+class EmptyThreadError(ValueError):
+    """Raised when a thread has no sediment-able content."""
+
+
+def _resolve_vault_dir(vault_dir: str) -> Path:
+    path = Path(vault_dir)
+    if path.is_absolute():
+        return path.resolve()
+    return (runtime_home() / vault_dir).resolve()
+
+
+def _inject_related_notes(body: str, links: list[str]) -> str:
+    """Insert real related-note ``[[wikilinks]]`` into the Related block.
+
+    Notes carry only content-specific related notes now (the structural meta-links
+    were dropped), so this is the sole writer of ``## Related`` links. When the
+    body has no ``## Related`` section yet, one is appended.
+    """
+    if not links:
+        return body
+    bullets = "\n".join(f"- {link}" for link in links)
+    marker = "## Related\n"
+    idx = body.find(marker)
+    if idx == -1:
+        return body.rstrip() + "\n\n## Related\n\n" + bullets + "\n"
+    insert_at = idx + len(marker)
+    return body[:insert_at] + "\n" + bullets + "\n" + body[insert_at:]
+
+
+class KnowledgeService:
+    """Application-facing knowledge base API."""
+
+    def __init__(self, repo: KnowledgeRepository, config: KnowledgeConfig) -> None:
+        self.repo = repo
+        self.config = config
+        self.project_name = config.project_name
+        vault_root = _resolve_vault_dir(config.vault_dir)
+        self.adapter = ObsidianWikiAdapter(
+            vault_root,
+            project_name=config.project_name,
+            export_html=config.export.graph_html_enabled,
+            export_json=config.export.graph_json_enabled,
+        )
+        self.embedding_client = EmbeddingClient(config.embedding)
+        try:
+            self.adapter.ensure_ready()
+        except Exception:  # pragma: no cover - vault init best-effort
+            logger.exception("Failed to initialize knowledge vault at %s", vault_root)
+
+    # -- internal helpers -------------------------------------------------
+    def _redact_draft(self, draft: NoteDraft) -> NoteDraft:
+        """Mask secrets/PII in a draft before persistence (phase 3)."""
+        if not self.config.sensitive_redaction_enabled:
+            return draft
+        from deerflow.knowledge.sensitive import redact
+
+        draft.content_md, body_hits = redact(draft.content_md)
+        draft.summary, _ = redact(draft.summary)
+        for src in draft.sources:
+            if src.snippet:
+                src.snippet, _ = redact(src.snippet)
+        if body_hits:
+            logger.info("Knowledge redaction applied to note '%s': %s", draft.title, ",".join(sorted(set(body_hits))))
+        return draft
+
+    async def _find_related_notes(self, draft: NoteDraft) -> list[dict[str, Any]]:
+        """Find existing notes to cross-link under ## Related — by **shared tags**.
+
+        Matching is strictly tag-based: a candidate must share at least one of the
+        draft's *distinctive* tags (the per-note project / ``knowledge-base``
+        defaults are dropped, else everything matches everything). Free-text
+        title/summary matching was removed because CJK tokenization made generic
+        words (助手 / 知识图谱 / 页面) link unrelated notes. No distinctive tags →
+        no related notes (better empty than noisy). Best-effort.
+        """
+        if not self.config.related_notes_enabled:
+            return []
+        default_tags = {t.lower() for t in (self.project_name or "", "knowledge-base", "zncm") if t}
+        distinctive = [t for t in (draft.tags or []) if t and t.lower() not in default_tags]
+        if not distinctive:
+            return []
+        own_title = (draft.title or "").strip().lower()
+        # Rank candidates by how many distinctive tags they share with the draft.
+        shared: dict[str, dict[str, Any]] = {}
+        for tag in distinctive:
+            try:
+                items, _total = await self.repo.list_notes(tag=tag, limit=50, offset=0)
+            except Exception:
+                logger.exception("Related-notes tag lookup failed for tag '%s'", tag)
+                continue
+            for it in items:
+                nid = it.get("id")
+                title = (it.get("title") or "").strip()
+                if not nid or not title or title.lower() == own_title:
+                    continue
+                entry = shared.setdefault(nid, {"id": nid, "title": title, "count": 0})
+                entry["count"] += 1
+        ranked = sorted(shared.values(), key=lambda e: e["count"], reverse=True)
+        limit = max(1, self.config.related_notes_limit)
+        return [{"id": e["id"], "title": e["title"]} for e in ranked[:limit]]
+
+    async def _persist_draft(self, draft: NoteDraft, *, created_by: str | None) -> dict[str, Any]:
+        """Create a DB row, write the vault file, attach sources, return note."""
+        draft = self._redact_draft(draft)
+        related_notes = await self._find_related_notes(draft)
+        if related_notes:
+            real_links = [f"[[{n['title']}]]" for n in related_notes]
+            draft.content_md = _inject_related_notes(draft.content_md, real_links)
+            draft.related = list(dict.fromkeys([*real_links, *draft.related]))
+        note = await self.repo.create_note(
+            title=draft.title,
+            summary=draft.summary,
+            content_md=draft.content_md,
+            source_type=draft.source_type,
+            source_id=draft.source_id,
+            status=draft.status,
+            confidence=draft.confidence,
+            tags=draft.tags,
+            created_by=created_by,
+        )
+        note_id = note["id"]
+        try:
+            rel = self.adapter.write_note(note_id, draft, created=note["created_at"], updated=note["updated_at"], status=draft.status)
+            await self.repo.set_vault_path(note_id, rel)
+            note["vault_path"] = rel
+        except Exception:
+            logger.exception("Failed to write knowledge note %s to vault", note_id)
+        if draft.sources:
+            await self.repo.add_sources(note_id, draft.sources, created_by=created_by)
+        await self._reindex_embeddings(note_id, draft.content_md)
+        await self._store_entities(note_id, draft)
+        # Record note→note "related" edges (after _store_entities, which clears
+        # this note's relations) so the graph reflects the cross-links too.
+        for rel_note in related_notes:
+            try:
+                await self.repo.add_relation(from_note_id=note_id, to_note_id=rel_note["id"], relation_type="related")
+            except Exception:
+                logger.exception("Failed to link related note %s -> %s", note_id, rel_note["id"])
+        return await self.repo.get_note(note_id) or note
+
+    async def _store_entities(self, note_id: str, draft: NoteDraft) -> None:
+        """Persist extracted entities/relations and link them to the note (phase 4)."""
+        if not self.config.entity_extraction_enabled or not draft.entities:
+            return
+        try:
+            await self.repo.clear_note_relations(note_id)
+            name_to_id: dict[str, str] = {}
+            for ent in draft.entities:
+                name = str(ent.get("name") or "").strip()
+                if not name:
+                    continue
+                row = await self.repo.get_or_create_entity(name, ent.get("type"))
+                name_to_id[name.lower()] = row["id"]
+                # note -> entity "mentions"
+                await self.repo.add_relation(from_note_id=note_id, to_entity_id=row["id"], relation_type="mentions")
+            for rel in draft.relations:
+                a = name_to_id.get(str(rel.get("from") or "").strip().lower())
+                b = name_to_id.get(str(rel.get("to") or "").strip().lower())
+                if a and b and a != b:
+                    await self.repo.add_relation(from_entity_id=a, to_entity_id=b, relation_type=str(rel.get("type") or "relates_to"))
+        except Exception:
+            logger.exception("Failed to store entities/relations for note %s", note_id)
+
+    async def _reindex_embeddings(self, note_id: str, content_md: str) -> None:
+        """Best-effort: (re)build the per-chunk embedding index for a note."""
+        if not self.embedding_client.is_enabled():
+            return
+        try:
+            chunks = chunk_markdown(content_md)
+            if not chunks:
+                await self.repo.delete_embeddings(note_id)
+                return
+            vectors = await self.embedding_client.embed_texts(chunks)
+            if not vectors or len(vectors) != len(chunks):
+                return
+            await self.repo.replace_embeddings(note_id, [(i, c, v) for i, (c, v) in enumerate(zip(chunks, vectors, strict=False))])
+        except Exception:
+            logger.exception("Failed to (re)index embeddings for note %s", note_id)
+
+    # -- capture ----------------------------------------------------------
+    async def capture_thread(
+        self,
+        *,
+        thread_id: str,
+        messages: list[dict[str, Any]],
+        thread_title: str | None = None,
+        mode: str = "summary",
+        title: str | None = None,
+        status: str = "approved",
+        tags: list[str] | None = None,
+        include_sources: bool = True,
+        reference_batches: list[dict[str, Any]] | None = None,
+        created_by: str | None = None,
+        skip_existing: bool = False,
+        model_name: str | None = None,
+    ) -> dict[str, Any]:
+        """Sediment a thread into a knowledge note.
+
+        ``model_name`` optionally overrides the configured extraction model for
+        this one capture (falls back to ``config.extract_model_name``).
+
+        Returns ``{"note": <note>, "created": bool}``. Raises
+        :class:`EmptyThreadError` when there is nothing worth keeping.
+        """
+        # Always-on entry log: proves a capture was triggered for this thread,
+        # regardless of how it ends (success / skip / fallback). Lets you tell
+        # "capture never ran" apart from "logs not visible" via one grep.
+        logger.info(
+            "[knowledge] capturing thread %s (msgs=%d, llm_extract=%s, skip_existing=%s)",
+            thread_id,
+            len(messages or []),
+            self.config.llm_extract_enabled,
+            skip_existing,
+        )
+        if skip_existing:
+            existing = await self.repo.find_by_source("thread", thread_id)
+            if existing is None and self.adapter.manifest.has_source(f"thread:{thread_id}"):
+                existing = await self.repo.find_by_source("thread", thread_id)
+            if existing:
+                logger.info("[knowledge] thread %s already captured (note %s); skipping", thread_id, existing.get("id"))
+                return {"note": existing, "created": False}
+
+        sources = []
+        if include_sources and reference_batches:
+            sources = from_reference_batches(reference_batches, thread_id=thread_id, max_items=self.config.max_source_items)
+
+        drafts: list[NoteDraft] = []
+        # Prefer LLM distillation (wiki-capture style) so notes are declarative
+        # knowledge, not raw chat. A single conversation may split into several
+        # cross-linked notes. Falls back to the rule-based extractor (always one
+        # note) when the LLM is disabled/unavailable or returns nothing usable.
+        llm_attempted = self.config.llm_extract_enabled
+        llm_fallback = False
+        if llm_attempted:
+            try:
+                drafts = await llm_extractor.extract_thread_llm_multi(
+                    messages,
+                    thread_id=thread_id,
+                    thread_title=thread_title,
+                    mode=mode,
+                    title=title,
+                    tags=tags,
+                    project_name=self.project_name,
+                    sources=sources,
+                    max_messages=self.config.max_thread_messages,
+                    model_name=model_name or self.config.extract_model_name,
+                    max_input_chars=self.config.extract_max_input_chars,
+                    allow_multi=self.config.multi_note_enabled,
+                )
+            except llm_extractor.LLMRejectedIngest as exc:
+                # The model judged this conversation worthless (greeting / meta
+                # chatter). Skip ingestion entirely — do NOT dump the raw chat.
+                raise EmptyThreadError(f"Thread {thread_id} judged not worth ingesting: {exc}") from exc
+            if not drafts:
+                # The LLM path was supposed to run but produced nothing usable
+                # (API error / non-JSON). We will fall back to the rule-based
+                # extractor, which yields a low-quality verbatim dump with no
+                # entities/tags — flag it so it lands as a draft.
+                llm_fallback = True
+        if not drafts:
+            single = extractor.extract_thread(
+                messages,
+                thread_id=thread_id,
+                thread_title=thread_title,
+                mode=mode,
+                title=title,
+                tags=tags,
+                project_name=self.project_name,
+                sources=sources,
+                max_messages=self.config.max_thread_messages,
+            )
+            drafts = [single] if single else []
+        if not drafts:
+            logger.info("[knowledge] thread %s has no sediment-able content; skipping", thread_id)
+            raise EmptyThreadError(f"Thread {thread_id} has no sediment-able content")
+
+        # When the LLM was enabled but silently fell back to rule-based extraction,
+        # the note is a verbatim dump (no distillation / entities / tags). Land it
+        # as a *draft* for review instead of silently approving it, and log loudly
+        # so the extraction failure is diagnosable (see also the WARNING/EXCEPTION
+        # logged inside llm_extractor.extract_thread_llm_multi).
+        effective_status = status
+        if llm_fallback:
+            logger.warning(
+                "[knowledge] thread %s — capture fell back to rule-based extraction "
+                "(LLM distillation produced nothing usable); landing as DRAFT. "
+                "Check extraction model '%s' / earlier [knowledge] logs for the cause.",
+                thread_id,
+                self.config.extract_model_name or "models[0]",
+            )
+            if normalize_status(status) == "approved":
+                effective_status = "draft"
+
+        normalized = normalize_status(effective_status)
+        for draft in drafts:
+            draft.status = normalized
+        # Cross-link sibling notes from the same conversation by title, so the
+        # split pages reference each other (resolved once all are persisted).
+        if len(drafts) > 1:
+            for i, draft in enumerate(drafts):
+                siblings = [f"[[{o.title}]]" for j, o in enumerate(drafts) if j != i and o.title]
+                if siblings:
+                    draft.content_md = _inject_related_notes(draft.content_md, siblings)
+                    draft.related = list(dict.fromkeys([*siblings, *draft.related]))
+
+        notes = [await self._persist_draft(draft, created_by=created_by) for draft in drafts]
+        logger.info(
+            "[knowledge] thread %s captured → %d note(s) [%s], status=%s, llm_fallback=%s",
+            thread_id,
+            len(notes),
+            ", ".join(n.get("title", "") for n in notes),
+            normalized,
+            llm_fallback,
+        )
+        return {"note": notes[0], "created": True, "notes": notes, "llm_fallback": llm_fallback}
+
+    async def capture_search(
+        self,
+        *,
+        query: str,
+        results: list[dict[str, Any]] | None,
+        thread_id: str | None = None,
+        message_id: str | None = None,
+        title: str | None = None,
+        tags: list[str] | None = None,
+        status: str = "approved",
+        created_by: str | None = None,
+    ) -> dict[str, Any]:
+        """Sediment search/tool results into a reference note."""
+        sources = from_search_results(query, results, thread_id=thread_id, message_id=message_id, max_items=self.config.max_source_items)
+        draft = extractor.extract_search(query, sources, thread_id=thread_id, project_name=self.project_name, title=title, tags=tags)
+        draft.status = normalize_status(status)
+        return await self._persist_draft(draft, created_by=created_by)
+
+    async def create_manual_note(
+        self,
+        *,
+        title: str,
+        content_md: str,
+        tags: list[str] | None = None,
+        status: str = "approved",
+        summary: str | None = None,
+        created_by: str | None = None,
+    ) -> dict[str, Any]:
+        """Create a note directly from product-edited Markdown."""
+        # Strip any frontmatter the user may have pasted; vault writer adds its own.
+        _, body = MarkdownVault.parse(content_md)
+        body = body or content_md
+        base_tags = list(tags or [])
+        for default in (self.project_name, "knowledge-base"):
+            if default and default not in base_tags:
+                base_tags.append(default)
+        draft = NoteDraft(
+            title=title.strip() or "知识笔记",
+            summary=(summary or body.strip().splitlines()[0] if body.strip() else "")[:280],
+            content_md=body,
+            category="synthesis",
+            source_type="manual",
+            source_id=None,
+            status=normalize_status(status),
+            tags=base_tags,
+            confidence=0.5,
+            related=extractor.related_links(self.project_name),
+        )
+        return await self._persist_draft(draft, created_by=created_by)
+
+    # -- CRUD -------------------------------------------------------------
+    async def list_notes(
+        self,
+        *,
+        keyword: str | None = None,
+        tag: str | None = None,
+        source_type: str | None = None,
+        status: str | None = None,
+        limit: int = 20,
+        offset: int = 0,
+    ) -> dict[str, Any]:
+        items, total = await self.repo.list_notes(
+            keyword=keyword,
+            tag=tag,
+            source_type=normalize_source_type(source_type) if source_type else None,
+            status=status,
+            limit=limit,
+            offset=offset,
+        )
+        return {"items": items, "total": total}
+
+    async def get_note(self, note_id: str) -> dict[str, Any] | None:
+        note = await self.repo.get_note(note_id)
+        if note is not None:
+            note["entities"] = await self.repo.list_note_entities(note_id)
+        return note
+
+    async def update_note(
+        self,
+        note_id: str,
+        *,
+        title: str | None = None,
+        content_md: str | None = None,
+        tags: list[str] | None = None,
+        status: str | None = None,
+        summary: str | None = None,
+        updated_by: str | None = None,
+    ) -> dict[str, Any] | None:
+        current = await self.repo.get_note(note_id, with_sources=False)
+        if current is None:
+            return None
+        # Snapshot the pre-edit state for version history (phase 3).
+        try:
+            await self.repo.add_version(current, edited_by=updated_by)
+        except Exception:
+            logger.exception("Failed to snapshot version for note %s", note_id)
+        body = content_md
+        if body is not None:
+            _, parsed = MarkdownVault.parse(body)
+            body = parsed or body
+        note = await self.repo.update_note(
+            note_id,
+            title=title,
+            summary=summary,
+            content_md=body,
+            status=normalize_status(status) if status else None,
+            tags=tags,
+            updated_by=updated_by,
+        )
+        if note is None:
+            return None
+        try:
+            rel = self.adapter.update_note_file(
+                note_id,
+                current.get("vault_path"),
+                title=note["title"],
+                content_md=note["content_md"],
+                tags=note.get("tags") or [],
+                status=note["status"],
+                summary=note.get("summary") or "",
+                category="synthesis",
+                created=note["created_at"],
+                updated=note["updated_at"],
+            )
+            if rel and rel != current.get("vault_path"):
+                await self.repo.set_vault_path(note_id, rel)
+        except Exception:
+            logger.exception("Failed to update knowledge note %s in vault", note_id)
+        if note.get("content_md") is not None:
+            await self._reindex_embeddings(note_id, note["content_md"])
+        return await self.repo.get_note(note_id)
+
+    async def list_versions(self, note_id: str) -> list[dict[str, Any]]:
+        return await self.repo.list_versions(note_id)
+
+    async def delete_note(self, note_id: str, *, updated_by: str | None = None, hard: bool = False) -> bool:
+        """Soft delete (archive) by default; hard delete removes the vault file."""
+        current = await self.repo.get_note(note_id, with_sources=False)
+        if current is None:
+            return False
+        note = await self.repo.set_status(note_id, "archived", updated_by=updated_by)
+        try:
+            self.adapter.archive_note(note_id, current.get("vault_path"), updated=(note or current)["updated_at"])
+            if hard and current.get("vault_path"):
+                self.adapter.vault.delete_note(current["vault_path"])
+                self.adapter.manifest.remove_page(note_id)
+                await self.repo.delete_embeddings(note_id)
+        except Exception:
+            logger.exception("Failed to archive knowledge note %s in vault", note_id)
+        # Drop this note's entity mentions + any now-orphaned entities so the graph
+        # follows the deletion (no lingering nodes from removed notes).
+        try:
+            await self.repo.clear_note_relations(note_id)
+            pruned = await self.repo.prune_orphan_entities()
+            if pruned:
+                logger.info("[knowledge] deleted note %s → pruned %d orphan entities", note_id, pruned)
+        except Exception:
+            logger.exception("Failed to prune relations/entities for deleted note %s", note_id)
+        return True
+
+    # -- wikilinks --------------------------------------------------------
+    async def resolve_wikilink(self, target: str) -> dict[str, Any]:
+        """Resolve a single ``[[wikilink]]`` target to a navigable destination.
+
+        Returns one of:
+        - ``{"kind": "note", "note_id", "title", "exists": True}`` — a knowledge note
+        - ``{"kind": "vault", "vault_path", "title", "exists": True}`` — a vault meta/hub page
+        - ``{"kind": "missing", "exists": False}`` — nothing matches
+
+        Resolution order: note id → note vault_path → note title → vault file.
+        """
+        norm = normalize_wikilink_target(target)
+        base = {"target": target, "normalized": norm}
+        if not norm:
+            return {**base, "kind": "missing", "exists": False}
+
+        # 1) Direct note id (e.g. "kb_abc...").
+        if norm.startswith("kb_"):
+            note = await self.repo.get_note(norm, with_sources=False)
+            if note and note.get("status") != "archived":
+                return {**base, "kind": "note", "note_id": note["id"], "title": note["title"], "exists": True}
+
+        # 2) Note by vault path (links from index.md / hot.md / structural hub).
+        note = await self.repo.find_by_vault_path(norm)
+        if note:
+            return {**base, "kind": "note", "note_id": note["id"], "title": note["title"], "exists": True}
+
+        # 3) Note by title (the real related-note cross-links use [[Title]]).
+        note = await self.repo.find_by_title(norm) or await self.repo.find_by_title(norm.split("/")[-1])
+        if note:
+            return {**base, "kind": "note", "note_id": note["id"], "title": note["title"], "exists": True}
+
+        # 4) A vault meta/hub page that has no DB note (index, _meta/taxonomy, hub…).
+        page = self.read_vault_page(norm)
+        if page is not None:
+            return {**base, "kind": "vault", "vault_path": page["path"], "title": page["title"], "exists": True}
+
+        return {**base, "kind": "missing", "exists": False}
+
+    async def resolve_wikilinks(self, targets: list[str]) -> dict[str, dict[str, Any]]:
+        """Resolve many targets at once; returns ``{original_target: resolution}``."""
+        out: dict[str, dict[str, Any]] = {}
+        for target in dict.fromkeys(t for t in targets if t and t.strip()):
+            out[target] = await self.resolve_wikilink(target)
+        return out
+
+    async def resolve_note_wikilinks(self, note_id: str) -> dict[str, dict[str, Any]] | None:
+        """Extract every ``[[wikilink]]`` in a note's body and resolve them.
+
+        Returns ``{target: resolution}`` or ``None`` when the note is missing.
+        Numeric ``[[123]]`` citation badges are skipped (handled by the renderer).
+        """
+        note = await self.repo.get_note(note_id, with_sources=False)
+        if note is None:
+            return None
+        targets = [t for t in extract_wikilinks(note.get("content_md") or "") if not t.isdigit()]
+        return await self.resolve_wikilinks(targets)
+
+    def read_vault_page(self, path: str) -> dict[str, Any] | None:
+        """Read a raw vault Markdown page (meta/hub pages without a DB note).
+
+        Returns ``{"path", "title", "content_md"}`` or ``None`` if the page does
+        not exist or the path escapes the vault root.
+        """
+        norm = normalize_wikilink_target(path)
+        if not norm:
+            return None
+        rel = f"{norm}.md"
+        try:
+            parsed = self.adapter.vault.read_note(rel)
+        except VaultPathError:
+            return None
+        if parsed is None:
+            return None
+        fm, body = parsed
+        title = str(fm.get("title") or "").strip() or norm.split("/")[-1]
+        return {"path": norm, "title": title, "content_md": body}
+
+    # -- search & graph ---------------------------------------------------
+    async def search(self, query: str, *, mode: str = "keyword", limit: int = 8) -> list[dict[str, Any]]:
+        return await search_notes(self.repo, query, mode=mode, limit=limit, embedding_client=self.embedding_client)
+
+    async def build_rag_context(self, query: str, *, limit: int = 5) -> dict[str, Any]:
+        """Retrieve top knowledge for ``query`` and format an injectable block.
+
+        Returns ``{"text": <system context or "">, "items": [...]}``. Uses hybrid
+        search when embeddings are available, else keyword (wiki-query style).
+        """
+        mode = "hybrid" if self.embedding_client.is_enabled() else "keyword"
+        items = await search_notes(self.repo, query, mode=mode, limit=limit, embedding_client=self.embedding_client)
+        if not items:
+            return {"text": "", "items": []}
+        lines = [
+            "以下是产品知识库中与本问题相关的资料。回答时优先参考；若使用其中信息，请在回答中标注来源（note_id）。",
+            "",
+        ]
+        for i, it in enumerate(items, 1):
+            lines.append(f"[知识 {i}] {it.get('title') or ''}")
+            if it.get("snippet"):
+                lines.append(it["snippet"])
+            lines.append(f"来源：{it['note_id']}")
+            lines.append("")
+        return {"text": "\n".join(lines).strip(), "items": items}
+
+    # -- dedup & merge (phase 3) -----------------------------------------
+    async def find_duplicates(self) -> list[dict[str, Any]]:
+        from deerflow.knowledge.dedup import find_duplicate_groups
+
+        notes = await self.repo.list_all()
+        return find_duplicate_groups(notes, threshold=self.config.dedup_similarity_threshold)
+
+    async def merge_notes(self, primary_id: str, duplicate_ids: list[str], *, updated_by: str | None = None) -> dict[str, Any] | None:
+        """Merge ``duplicate_ids`` into ``primary_id``.
+
+        Sources from each duplicate are re-attached to the primary, a wikilink
+        + "Merged from" note is appended to the primary body, the duplicates are
+        archived (soft delete), and a ``merged_into`` relation is recorded.
+        """
+        primary = await self.repo.get_note(primary_id)
+        if primary is None:
+            return None
+        merged_titles: list[str] = []
+        for dup_id in duplicate_ids:
+            if dup_id == primary_id:
+                continue
+            dup = await self.repo.get_note(dup_id)
+            if dup is None:
+                continue
+            # Move sources.
+            for src in dup.get("sources") or []:
+                await self.repo.add_sources(
+                    primary_id,
+                    [
+                        SourceDraft(
+                            source_type=src.get("source_type") or "tool",
+                            thread_id=src.get("thread_id"),
+                            message_id=src.get("message_id"),
+                            tool_name=src.get("tool_name"),
+                            title=src.get("title"),
+                            url=src.get("url"),
+                            snippet=src.get("snippet"),
+                        )
+                    ],
+                    created_by=updated_by,
+                )
+            await self.repo.add_relation(from_note_id=dup_id, to_note_id=primary_id, relation_type="merged_into")
+            await self.delete_note(dup_id, updated_by=updated_by)
+            merged_titles.append(dup.get("title") or dup_id)
+
+        if merged_titles:
+            appended = primary["content_md"].rstrip() + "\n\n## Merged\n\n" + "\n".join(f"- {t}" for t in merged_titles) + "\n"
+            await self.update_note(primary_id, content_md=appended, updated_by=updated_by)
+        return await self.repo.get_note(primary_id)
+
+    async def reindex_all(self) -> dict[str, int]:
+        """Rebuild embeddings for every non-archived note (admin/maintenance)."""
+        notes = await self.repo.list_all()
+        count = 0
+        for note in notes:
+            await self._reindex_embeddings(note["id"], note.get("content_md") or "")
+            count += 1
+        return {"reindexed": count, "embedding_enabled": int(self.embedding_client.is_enabled())}
+
+    async def export_graph(self) -> dict[str, Any]:
+        from deerflow.utils.time import now_iso
+
+        notes = await self.repo.list_all()
+        entities = await self.repo.list_entities() if self.config.entity_extraction_enabled else []
+        relations = await self.repo.list_relations() if self.config.entity_extraction_enabled else []
+        result = self.adapter.export_graph(notes, entities=entities, relations=relations, updated=now_iso())
+        return {"files": result["files"], "stats": result["stats"]}
+
+    async def get_graph(self) -> dict[str, Any]:
+        """Return product graph data ``{nodes, edges}`` (notes + entities)."""
+        from deerflow.knowledge import exporter
+
+        notes = await self.repo.list_all()
+        entities = await self.repo.list_entities() if self.config.entity_extraction_enabled else []
+        relations = await self.repo.list_relations() if self.config.entity_extraction_enabled else []
+        return exporter.build_graph(notes, entities, relations)
+
+    def export_file_path(self, filename: str) -> Path | None:
+        return self.adapter.export_file_path(filename)
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/skill_templates.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/skill_templates.py
new file mode 100644
index 00000000..bad928f4
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/skill_templates.py
@@ -0,0 +1,51 @@
+"""Built-in obsidian-wiki skill templates.
+
+Mirrors the key intent of ``ar9av/obsidian-wiki`` skills so the backend can
+write vault content that stays compatible with the original tooling without
+shelling out to its CLI:
+
+- ``wiki-capture`` — how a conversation becomes a *declarative* knowledge note
+  (frontmatter schema + Context/Finding/Reasoning/Implications/Related body).
+- ``wiki-query``   — layered retrieval (hot.md → index.md → frontmatter → body).
+- ``wiki-export``  — graph artifacts (graph.json / graph.html / graphml / cypher).
+
+These are intentionally lightweight: the structures here are what
+:mod:`deerflow.knowledge.markdown_vault` and :mod:`deerflow.knowledge.extractor`
+produce, and what the first-release LLM prompt (future enhancement) should
+target.
+"""
+
+from __future__ import annotations
+
+# Category → vault sub-directory (wiki-capture page taxonomy, §8 of the dev doc).
+CATEGORY_DIRS = {
+    "synthesis": "synthesis",
+    "concepts": "concepts",
+    "concept": "concepts",
+    "references": "references",
+    "reference": "references",
+    "source": "references",
+    "decision": "synthesis",
+    "journal": "journal",
+    "session": "journal",
+}
+
+# Body section headings (wiki-capture). Declarative knowledge, never a chat log.
+BODY_SECTIONS = ("Context", "Finding / Decision", "Reasoning", "Implications", "Related")
+
+# Inline provenance markers reused from wiki-capture.
+INFERRED_MARKER = "^[inferred]"
+AMBIGUOUS_MARKER = "^[ambiguous]"
+
+WIKI_CAPTURE_GUIDANCE = """\
+Capture *declarative* knowledge, not a chat transcript. Classify the note as one
+of: synthesis, concept, source, decision, session. Prefer at least two
+[[wikilinks]]. Mark inferred content with ^[inferred] and uncertain/conflicting
+content with ^[ambiguous]. Project-specific knowledge belongs under
+projects/<project-name>/...
+"""
+
+
+def category_to_dir(category: str | None) -> str:
+    """Map a wiki-capture category to its vault sub-directory."""
+    return CATEGORY_DIRS.get((category or "").strip().lower(), "synthesis")
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/sources.py b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/sources.py
new file mode 100644
index 00000000..824bc2c1
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/knowledge/sources.py
@@ -0,0 +1,82 @@
+"""Normalize knowledge sources from threads / searches / tool results.
+
+Source items come from a few shapes: backend reference-batches (built by
+``deerflow.runtime.references``), raw search-result payloads, and tool-call
+messages. They are all normalized into :class:`SourceDraft` so the repository
+and frontend see one consistent structure.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from deerflow.knowledge.schemas import SourceDraft
+
+
+def _clip(value: Any, limit: int = 2000) -> str | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    if not text:
+        return None
+    return text[:limit]
+
+
+def from_reference_batches(batches: list[dict[str, Any]] | None, *, thread_id: str | None = None, max_items: int = 20) -> list[SourceDraft]:
+    """Convert backend reference-batches into :class:`SourceDraft`."""
+    out: list[SourceDraft] = []
+    seen: set[str] = set()
+    for batch in batches or []:
+        msg_id = batch.get("assistant_message_id") or batch.get("id")
+        for src in batch.get("sources", []) or []:
+            if not isinstance(src, dict):
+                continue
+            url = _clip(src.get("url"), 1024)
+            title = _clip(src.get("title"), 512) or _clip(src.get("source"), 512) or "来源"
+            dedup_key = url or f"{title}:{_clip(src.get('snippet'), 80)}"
+            if dedup_key in seen:
+                continue
+            seen.add(dedup_key)
+            out.append(
+                SourceDraft(
+                    source_type="search" if url else "tool",
+                    thread_id=thread_id,
+                    message_id=_clip(msg_id, 128),
+                    tool_name=_clip(src.get("skillName"), 128),
+                    title=title,
+                    url=url,
+                    snippet=_clip(src.get("snippet")),
+                    raw=None,
+                )
+            )
+            if len(out) >= max_items:
+                return out
+    return out
+
+
+def from_search_results(
+    query: str,
+    results: list[dict[str, Any]] | None,
+    *,
+    thread_id: str | None = None,
+    message_id: str | None = None,
+    max_items: int = 20,
+) -> list[SourceDraft]:
+    """Convert raw search results (title/url/snippet) into :class:`SourceDraft`."""
+    out: list[SourceDraft] = []
+    for item in (results or [])[:max_items]:
+        if not isinstance(item, dict):
+            continue
+        out.append(
+            SourceDraft(
+                source_type="search",
+                thread_id=thread_id,
+                message_id=message_id,
+                tool_name=_clip(item.get("tool_name") or item.get("tool"), 128),
+                title=_clip(item.get("title"), 512) or query[:200],
+                url=_clip(item.get("url"), 1024),
+                snippet=_clip(item.get("snippet") or item.get("content")),
+                raw={k: item.get(k) for k in ("score",) if item.get(k) is not None} or None,
+            )
+        )
+    return out
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/persistence/admin_stats/finalize.py b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/admin_stats/finalize.py
new file mode 100644
index 00000000..39212bae
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/admin_stats/finalize.py
@@ -0,0 +1,47 @@
+"""Pure scheduling helpers for the admin leaderboard daily snapshots.
+
+Kept import-light on purpose (only stdlib ``datetime``) so the decision logic
+is unit-testable without standing up the FastAPI app, the DB engine, or the
+ORM. The background scheduler in ``app/gateway/app.py`` wires this to the real
+snapshot rows.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+
+def should_finalize_previous_day(
+    *,
+    status: str | None,
+    generated_at: datetime | None,
+    now: datetime,
+    finalize_hour: int,
+) -> bool:
+    """Decide whether *yesterday's* snapshot should be force-recomputed once.
+
+    The previous day's snapshot is normally built before midnight, so it can
+    miss runs / tool calls whose rows only land in the database shortly before
+    or after the day boundary. Once per day, on/after ``finalize_hour`` (local
+    Beijing time), we recompute it a single time so the full day is captured.
+
+    ``now`` and ``generated_at`` are expected to be timezone-aware Beijing
+    datetimes (``generated_at`` may be ``None`` for legacy rows).
+
+    Returns ``True`` only when all hold:
+      - it is already on/after ``finalize_hour`` today;
+      - a snapshot row exists (``status`` is not ``None`` — a missing day is
+        left to the normal prewarm/queue path);
+      - that snapshot is not already ``queued``/``running`` (a finalize already
+        in flight, or normal processing);
+      - it was generated before today (i.e. not yet finalized for this day).
+    """
+    if status is None:
+        return False
+    if now.hour < finalize_hour:
+        return False
+    if status in ("queued", "running"):
+        return False
+    if generated_at is not None and generated_at.date() >= now.date():
+        return False
+    return True
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/persistence/agents/base.py b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/agents/base.py
index 0ff4ae33..d2fc32cd 100644
--- a/offline-backend-20260512/backend/packages/harness/deerflow/persistence/agents/base.py
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/agents/base.py
@@ -119,18 +119,19 @@ class AgentStore(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    async def list_paginated(
-        self,
-        *,
-        user_id: str,
-        scope: str | None,
-        search: str | None,
-        tag_ids: list[str] | None,
-        page: int,
-        page_size: int,
-        admin: bool = False,
-        sort: str = "time_desc",
-    ) -> tuple[list[dict[str, Any]], int]:
+    async def list_paginated(
+        self,
+        *,
+        user_id: str,
+        scope: str | None,
+        search: str | None,
+        tag_ids: list[str] | None,
+        page: int,
+        page_size: int,
+        admin: bool = False,
+        sort: str = "time_desc",
+        owner: str | None = None,
+    ) -> tuple[list[dict[str, Any]], int]:
         """Return one page of agents plus the total matching count.
 
         ``scope``:
@@ -142,13 +143,15 @@ class AgentStore(ABC):
         agent), but still honors ``search`` / ``tag_ids``. Caller authorizes.
 
         ``search`` matches the raw name OR its desensitized display form.
-        ``tag_ids`` keeps agents carrying ANY of the tags (OR). Both filters,
-        the COUNT, and LIMIT/OFFSET all execute in SQL.
+        ``tag_ids`` keeps agents carrying ANY of the tags (OR). ``owner`` keeps
+        only agents published by that user (``user_id`` equality) — built-in
+        agents (no owner) never match. All filters, the COUNT, and LIMIT/OFFSET
+        all execute in SQL.
 
         Returns ``(rows, total)`` where ``rows`` is at most ``page_size`` items
-        for the 1-based ``page``.
-        """
-        raise NotImplementedError
+        for the 1-based ``page``.
+        """
+        raise NotImplementedError
 
     # --- Listing cache (skills / tool_groups / model) ---
 
@@ -199,28 +202,28 @@ class AgentStore(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    async def delete_favorites_for_agent(self, agent_id: str) -> None:
-        """Drop every user's favorite of ``agent_id`` (called on agent delete)."""
-        raise NotImplementedError
-
-    # --- Per-user pins ("置顶") ---
-
-    @abstractmethod
-    async def add_pin(self, user_id: str, agent_id: str) -> None:
-        """Pin ``agent_id`` for ``user_id``. Idempotent."""
-        raise NotImplementedError
-
-    @abstractmethod
-    async def remove_pin(self, user_id: str, agent_id: str) -> bool:
-        """Remove a per-user pin. Returns ``False`` when none existed."""
-        raise NotImplementedError
-
-    @abstractmethod
-    async def list_pin_ids(self, user_id: str) -> set[str]:
-        """Return the set of agent ids pinned by ``user_id``."""
-        raise NotImplementedError
-
-    @abstractmethod
-    async def delete_pins_for_agent(self, agent_id: str) -> None:
-        """Drop every user's pin of ``agent_id`` (called on agent delete)."""
-        raise NotImplementedError
+    async def delete_favorites_for_agent(self, agent_id: str) -> None:
+        """Drop every user's favorite of ``agent_id`` (called on agent delete)."""
+        raise NotImplementedError
+
+    # --- Per-user pins ("置顶") ---
+
+    @abstractmethod
+    async def add_pin(self, user_id: str, agent_id: str) -> None:
+        """Pin ``agent_id`` for ``user_id``. Idempotent."""
+        raise NotImplementedError
+
+    @abstractmethod
+    async def remove_pin(self, user_id: str, agent_id: str) -> bool:
+        """Remove a per-user pin. Returns ``False`` when none existed."""
+        raise NotImplementedError
+
+    @abstractmethod
+    async def list_pin_ids(self, user_id: str) -> set[str]:
+        """Return the set of agent ids pinned by ``user_id``."""
+        raise NotImplementedError
+
+    @abstractmethod
+    async def delete_pins_for_agent(self, agent_id: str) -> None:
+        """Drop every user's pin of ``agent_id`` (called on agent delete)."""
+        raise NotImplementedError
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/persistence/agents/memory.py b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/agents/memory.py
index 762e3aa2..484dd7f9 100644
--- a/offline-backend-20260512/backend/packages/harness/deerflow/persistence/agents/memory.py
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/agents/memory.py
@@ -21,9 +21,9 @@ def _copy(data: dict[str, Any]) -> dict[str, Any]:
 
 class MemoryAgentStore(AgentStore):
     def __init__(self) -> None:
-        self._agents: dict[str, dict[str, Any]] = {}
-        self._favorites: set[tuple[str, str]] = set()
-        self._pins: set[tuple[str, str]] = set()
+        self._agents: dict[str, dict[str, Any]] = {}
+        self._favorites: set[tuple[str, str]] = set()
+        self._pins: set[tuple[str, str]] = set()
         # Listing cache mirrors (see AgentExtrasRow / AgentSkillRow):
         self._skills: dict[str, list[str]] = {}
         self._extras: dict[str, dict[str, Any]] = {}
@@ -186,51 +186,54 @@ class MemoryAgentStore(AgentStore):
             return bool(agent.get("is_private"))
         return self._is_visible(agent, user_id)
 
-    async def list_paginated(
-        self,
-        *,
-        user_id: str,
-        scope: str | None,
+    async def list_paginated(
+        self,
+        *,
+        user_id: str,
+        scope: str | None,
         search: str | None,
-        tag_ids: list[str] | None,
-        page: int,
-        page_size: int,
-        admin: bool = False,
-        sort: str = "time_desc",
-    ) -> tuple[list[dict[str, Any]], int]:
+        tag_ids: list[str] | None,
+        page: int,
+        page_size: int,
+        admin: bool = False,
+        sort: str = "time_desc",
+        owner: str | None = None,
+    ) -> tuple[list[dict[str, Any]], int]:
         # NOTE: the in-memory store has no tag-assignment data, so ``tag_ids``
         # is ignored here. Tag-filter behavior is covered by the SQL repo tests.
+        owner_key = owner.strip() if owner and owner.strip() else None
         matched = [
             a
             for a in self._agents.values()
             if self._matches_scope(a, user_id=user_id, scope=scope, admin=admin)
             and (not search or not search.strip() or name_matches(a.get("name") or "", search))
+            and (owner_key is None or a.get("user_id") == owner_key)
         ]
-        if sort == "time_asc":
-            matched.sort(key=lambda a: (a.get("created_at") or "", a.get("id") or ""))
-        elif sort == "updated_desc":
-            matched.sort(
-                key=lambda a: (a.get("updated_at") or "", a.get("id") or ""),
-                reverse=True,
-            )
-        elif sort == "updated_asc":
-            matched.sort(key=lambda a: (a.get("updated_at") or "", a.get("id") or ""))
-        elif sort == "name_asc":
-            matched.sort(key=lambda a: ((a.get("name") or "").lower(), a.get("id") or ""))
-        elif sort == "name_desc":
-            matched.sort(
-                key=lambda a: ((a.get("name") or "").lower(), a.get("id") or ""),
-                reverse=True,
-            )
-        else:
-            matched.sort(
-                key=lambda a: (a.get("created_at") or "", a.get("id") or ""),
-                reverse=True,
-            )
-        pin_ids = {agent_id for uid, agent_id in self._pins if uid == user_id}
-        matched.sort(key=lambda a: (0 if a.get("id") in pin_ids else 1,))
-        total = len(matched)
-        start = max(page - 1, 0) * page_size
+        if sort == "time_asc":
+            matched.sort(key=lambda a: (a.get("created_at") or "", a.get("id") or ""))
+        elif sort == "updated_desc":
+            matched.sort(
+                key=lambda a: (a.get("updated_at") or "", a.get("id") or ""),
+                reverse=True,
+            )
+        elif sort == "updated_asc":
+            matched.sort(key=lambda a: (a.get("updated_at") or "", a.get("id") or ""))
+        elif sort == "name_asc":
+            matched.sort(key=lambda a: ((a.get("name") or "").lower(), a.get("id") or ""))
+        elif sort == "name_desc":
+            matched.sort(
+                key=lambda a: ((a.get("name") or "").lower(), a.get("id") or ""),
+                reverse=True,
+            )
+        else:
+            matched.sort(
+                key=lambda a: (a.get("created_at") or "", a.get("id") or ""),
+                reverse=True,
+            )
+        pin_ids = {agent_id for uid, agent_id in self._pins if uid == user_id}
+        matched.sort(key=lambda a: (0 if a.get("id") in pin_ids else 1,))
+        total = len(matched)
+        start = max(page - 1, 0) * page_size
         page_rows = matched[start : start + page_size]
         return [_copy(a) for a in page_rows], total
 
@@ -275,23 +278,23 @@ class MemoryAgentStore(AgentStore):
     async def list_favorite_ids(self, user_id: str) -> set[str]:
         return {agent_id for (uid, agent_id) in self._favorites if uid == user_id}
 
-    async def delete_favorites_for_agent(self, agent_id: str) -> None:
-        self._favorites = {(uid, aid) for (uid, aid) in self._favorites if aid != agent_id}
-
-    # --- Pins ("置顶") ---
-
-    async def add_pin(self, user_id: str, agent_id: str) -> None:
-        self._pins.add((user_id, agent_id))
-
-    async def remove_pin(self, user_id: str, agent_id: str) -> bool:
-        key = (user_id, agent_id)
-        if key not in self._pins:
-            return False
-        self._pins.remove(key)
-        return True
-
-    async def list_pin_ids(self, user_id: str) -> set[str]:
-        return {agent_id for uid, agent_id in self._pins if uid == user_id}
-
-    async def delete_pins_for_agent(self, agent_id: str) -> None:
-        self._pins = {(uid, aid) for (uid, aid) in self._pins if aid != agent_id}
+    async def delete_favorites_for_agent(self, agent_id: str) -> None:
+        self._favorites = {(uid, aid) for (uid, aid) in self._favorites if aid != agent_id}
+
+    # --- Pins ("置顶") ---
+
+    async def add_pin(self, user_id: str, agent_id: str) -> None:
+        self._pins.add((user_id, agent_id))
+
+    async def remove_pin(self, user_id: str, agent_id: str) -> bool:
+        key = (user_id, agent_id)
+        if key not in self._pins:
+            return False
+        self._pins.remove(key)
+        return True
+
+    async def list_pin_ids(self, user_id: str) -> set[str]:
+        return {agent_id for uid, agent_id in self._pins if uid == user_id}
+
+    async def delete_pins_for_agent(self, agent_id: str) -> None:
+        self._pins = {(uid, aid) for (uid, aid) in self._pins if aid != agent_id}
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/persistence/agents/sql.py b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/agents/sql.py
index 965c93ae..aa0f5096 100644
--- a/offline-backend-20260512/backend/packages/harness/deerflow/persistence/agents/sql.py
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/agents/sql.py
@@ -6,19 +6,19 @@ from datetime import UTC, datetime
 from typing import Any
 from uuid import uuid4
 
-from sqlalchemy import and_, case, delete, func, or_, select
+from sqlalchemy import and_, case, delete, func, or_, select
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
 
 from deerflow.config.agent_name_desensitize import source_terms_for_needle
 from deerflow.persistence.agents.base import AgentStore
 from deerflow.persistence.agents.model import (
-    AgentExtrasRow,
-    AgentFavoriteRow,
-    AgentPinRow,
-    AgentRow,
-    AgentSkillRow,
-)
+    AgentExtrasRow,
+    AgentFavoriteRow,
+    AgentPinRow,
+    AgentRow,
+    AgentSkillRow,
+)
 from deerflow.persistence.tags.model import TagAssignmentRow
 
 
@@ -278,18 +278,19 @@ class AgentRepository(AgentStore):
         )
         return AgentRow.id.in_(subq)
 
-    async def list_paginated(
-        self,
-        *,
-        user_id: str,
-        scope: str | None,
+    async def list_paginated(
+        self,
+        *,
+        user_id: str,
+        scope: str | None,
         search: str | None,
-        tag_ids: list[str] | None,
-        page: int,
-        page_size: int,
-        admin: bool = False,
-        sort: str = "time_desc",
-    ) -> tuple[list[dict[str, Any]], int]:
+        tag_ids: list[str] | None,
+        page: int,
+        page_size: int,
+        admin: bool = False,
+        sort: str = "time_desc",
+        owner: str | None = None,
+    ) -> tuple[list[dict[str, Any]], int]:
         filters = []
         scope_filter = self._scope_filter(user_id=user_id, scope=scope, admin=admin)
         if scope_filter is not None:
@@ -298,30 +299,33 @@ class AgentRepository(AgentStore):
             filters.append(self._search_clause(search))
         if tag_ids:
             filters.append(self._tag_clause(tag_ids))
+        if owner and owner.strip():
+            # Filter to one publisher. Built-in agents (user_id IS NULL) never match.
+            filters.append(AgentRow.user_id == owner.strip())
 
         count_stmt = select(func.count()).select_from(AgentRow)
-        pin_subq = select(AgentPinRow.agent_id).where(AgentPinRow.user_id == user_id)
-        pin_rank = case((AgentRow.id.in_(pin_subq), 0), else_=1)
-
-        if sort == "time_asc":
-            order_by = (AgentRow.created_at.asc(), AgentRow.id.asc())
-        elif sort == "updated_desc":
-            order_by = (AgentRow.updated_at.desc(), AgentRow.id.asc())
-        elif sort == "updated_asc":
-            order_by = (AgentRow.updated_at.asc(), AgentRow.id.asc())
-        elif sort == "name_asc":
-            order_by = (func.lower(AgentRow.name).asc(), AgentRow.id.asc())
-        elif sort == "name_desc":
-            order_by = (func.lower(AgentRow.name).desc(), AgentRow.id.asc())
-        else:
-            order_by = (AgentRow.created_at.desc(), AgentRow.id.asc())
-
-        page_stmt = (
-            select(AgentRow)
-            .order_by(pin_rank.asc(), *order_by)
-            .limit(page_size)
-            .offset(max(page - 1, 0) * page_size)
-        )
+        pin_subq = select(AgentPinRow.agent_id).where(AgentPinRow.user_id == user_id)
+        pin_rank = case((AgentRow.id.in_(pin_subq), 0), else_=1)
+
+        if sort == "time_asc":
+            order_by = (AgentRow.created_at.asc(), AgentRow.id.asc())
+        elif sort == "updated_desc":
+            order_by = (AgentRow.updated_at.desc(), AgentRow.id.asc())
+        elif sort == "updated_asc":
+            order_by = (AgentRow.updated_at.asc(), AgentRow.id.asc())
+        elif sort == "name_asc":
+            order_by = (func.lower(AgentRow.name).asc(), AgentRow.id.asc())
+        elif sort == "name_desc":
+            order_by = (func.lower(AgentRow.name).desc(), AgentRow.id.asc())
+        else:
+            order_by = (AgentRow.created_at.desc(), AgentRow.id.asc())
+
+        page_stmt = (
+            select(AgentRow)
+            .order_by(pin_rank.asc(), *order_by)
+            .limit(page_size)
+            .offset(max(page - 1, 0) * page_size)
+        )
         if filters:
             where = and_(*filters)
             count_stmt = count_stmt.where(where)
@@ -441,49 +445,49 @@ class AgentRepository(AgentStore):
             )
             return {row[0] for row in result.all()}
 
-    async def delete_favorites_for_agent(self, agent_id: str) -> None:
-        async with self._sf() as session:
-            await session.execute(delete(AgentFavoriteRow).where(AgentFavoriteRow.agent_id == agent_id))
-            await session.commit()
-
-    # --- Pins ("置顶") ---
-
-    async def add_pin(self, user_id: str, agent_id: str) -> None:
-        async with self._sf() as session:
-            existing = (
-                await session.execute(
-                    select(AgentPinRow.id)
-                    .where(AgentPinRow.user_id == user_id, AgentPinRow.agent_id == agent_id)
-                    .limit(1)
-                )
-            ).scalar_one_or_none()
-            if existing is not None:
-                return
-            session.add(AgentPinRow(id=uuid4().hex, user_id=user_id, agent_id=agent_id))
-            try:
-                await session.commit()
-            except IntegrityError:
-                await session.rollback()
-
-    async def remove_pin(self, user_id: str, agent_id: str) -> bool:
-        async with self._sf() as session:
-            result = await session.execute(
-                delete(AgentPinRow).where(
-                    AgentPinRow.user_id == user_id,
-                    AgentPinRow.agent_id == agent_id,
-                )
-            )
-            await session.commit()
-            return (result.rowcount or 0) > 0
-
-    async def list_pin_ids(self, user_id: str) -> set[str]:
-        async with self._sf() as session:
-            result = await session.execute(
-                select(AgentPinRow.agent_id).where(AgentPinRow.user_id == user_id)
-            )
-            return {row[0] for row in result.all()}
-
-    async def delete_pins_for_agent(self, agent_id: str) -> None:
-        async with self._sf() as session:
-            await session.execute(delete(AgentPinRow).where(AgentPinRow.agent_id == agent_id))
-            await session.commit()
+    async def delete_favorites_for_agent(self, agent_id: str) -> None:
+        async with self._sf() as session:
+            await session.execute(delete(AgentFavoriteRow).where(AgentFavoriteRow.agent_id == agent_id))
+            await session.commit()
+
+    # --- Pins ("置顶") ---
+
+    async def add_pin(self, user_id: str, agent_id: str) -> None:
+        async with self._sf() as session:
+            existing = (
+                await session.execute(
+                    select(AgentPinRow.id)
+                    .where(AgentPinRow.user_id == user_id, AgentPinRow.agent_id == agent_id)
+                    .limit(1)
+                )
+            ).scalar_one_or_none()
+            if existing is not None:
+                return
+            session.add(AgentPinRow(id=uuid4().hex, user_id=user_id, agent_id=agent_id))
+            try:
+                await session.commit()
+            except IntegrityError:
+                await session.rollback()
+
+    async def remove_pin(self, user_id: str, agent_id: str) -> bool:
+        async with self._sf() as session:
+            result = await session.execute(
+                delete(AgentPinRow).where(
+                    AgentPinRow.user_id == user_id,
+                    AgentPinRow.agent_id == agent_id,
+                )
+            )
+            await session.commit()
+            return (result.rowcount or 0) > 0
+
+    async def list_pin_ids(self, user_id: str) -> set[str]:
+        async with self._sf() as session:
+            result = await session.execute(
+                select(AgentPinRow.agent_id).where(AgentPinRow.user_id == user_id)
+            )
+            return {row[0] for row in result.all()}
+
+    async def delete_pins_for_agent(self, agent_id: str) -> None:
+        async with self._sf() as session:
+            await session.execute(delete(AgentPinRow).where(AgentPinRow.agent_id == agent_id))
+            await session.commit()
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/persistence/migrations/versions/20260609_01_skill_name_zh.py b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/migrations/versions/20260609_01_skill_name_zh.py
new file mode 100644
index 00000000..b660c0ac
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/migrations/versions/20260609_01_skill_name_zh.py
@@ -0,0 +1,42 @@
+"""Add name_zh column to skills table.
+
+Revision ID: 20260609_01
+Revises: 20260608_01
+Create Date: 2026-06-09
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy import inspect
+
+
+revision = "20260609_01"
+down_revision = "20260608_01"
+branch_labels = None
+depends_on = None
+
+
+def _has_table(table_name: str) -> bool:
+    inspector = inspect(op.get_bind())
+    return table_name in inspector.get_table_names()
+
+
+def _has_column(table_name: str, column_name: str) -> bool:
+    if not _has_table(table_name):
+        return False
+    inspector = inspect(op.get_bind())
+    return any(col["name"] == column_name for col in inspector.get_columns(table_name))
+
+
+def upgrade() -> None:
+    # ``skills`` may not exist yet on a brand-new DB — create_all handles that
+    # case with the column already present, so only patch existing tables.
+    if _has_table("skills") and not _has_column("skills", "name_zh"):
+        op.add_column("skills", sa.Column("name_zh", sa.String(length=128), nullable=True))
+
+
+def downgrade() -> None:
+    if _has_column("skills", "name_zh"):
+        op.drop_column("skills", "name_zh")
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/persistence/migrations/versions/20260609_02_merge_skill_name_zh_and_chain_heads.py b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/migrations/versions/20260609_02_merge_skill_name_zh_and_chain_heads.py
new file mode 100644
index 00000000..f8095d73
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/migrations/versions/20260609_02_merge_skill_name_zh_and_chain_heads.py
@@ -0,0 +1,30 @@
+"""Merge the skill_name_zh and chain-stages migration heads.
+
+Two lineages both descend from ``20260608_01`` (admin_leaderboard_daily_stats):
+``20260608_02`` … ``20260608_06`` (the chain-stages / parallel-agent branch) and
+``20260609_01`` (skills.name_zh), which branched directly off ``20260608_01``
+instead of off the latest head. That left the graph with two heads and made
+``alembic upgrade head`` fail with "Multiple head revisions are present". This
+no-op merge revision joins both lineages so ``upgrade head`` resolves to a single
+head again.
+
+Revision ID: 20260609_02
+Revises: 20260608_06, 20260609_01
+Create Date: 2026-06-10
+"""
+
+from __future__ import annotations
+
+
+revision = "20260609_02"
+down_revision = ("20260608_06", "20260609_01")
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    pass
+
+
+def downgrade() -> None:
+    pass
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/persistence/models/__init__.py b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/models/__init__.py
index 26e5cfef..18566d1f 100644
--- a/offline-backend-20260512/backend/packages/harness/deerflow/persistence/models/__init__.py
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/models/__init__.py
@@ -25,6 +25,16 @@ from deerflow.persistence.admin_stats.model import AdminLeaderboardDailyStatRow
 from deerflow.persistence.business_mapping.model import BusinessMappingRow
 from deerflow.persistence.memory_config.model import UserMemoryConfigRow
 from deerflow.persistence.feedback.model import FeedbackRow
+from deerflow.knowledge.models import (
+    KnowledgeEmbeddingRow,
+    KnowledgeEntityRow,
+    KnowledgeNoteRow,
+    KnowledgeNoteTagRow,
+    KnowledgeNoteVersionRow,
+    KnowledgeRelationRow,
+    KnowledgeSourceRow,
+    KnowledgeTagRow,
+)
 from deerflow.persistence.llm_metrics.model import LlmCallMetricRow
 from deerflow.persistence.models.run_event import RunEventRow
 from deerflow.persistence.notifications.model import NotificationRow
@@ -63,6 +73,14 @@ __all__ = [
     "AgentSkillRow",
     "AdminLeaderboardDailyStatRow",
     "BusinessMappingRow",
+    "KnowledgeEmbeddingRow",
+    "KnowledgeEntityRow",
+    "KnowledgeNoteRow",
+    "KnowledgeNoteTagRow",
+    "KnowledgeNoteVersionRow",
+    "KnowledgeRelationRow",
+    "KnowledgeSourceRow",
+    "KnowledgeTagRow",
     "LlmCallMetricRow",
     "NotificationRow",
     "ParallelAgentTaskRow",
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/persistence/skills/memory.py b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/skills/memory.py
index d774f560..8b341b18 100644
--- a/offline-backend-20260512/backend/packages/harness/deerflow/persistence/skills/memory.py
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/skills/memory.py
@@ -70,6 +70,7 @@ class MemorySkillStore(SkillStore):
             "owner_user_id": data.get("owner_user_id"),
             "published": bool(data.get("published", False)),
             "detail": data.get("detail"),
+            "name_zh": data.get("name_zh"),
             "created_at": _now(),
             "updated_at": _now(),
         }
@@ -85,6 +86,7 @@ class MemorySkillStore(SkillStore):
                 "owner_user_id": data.get("owner_user_id"),
                 "published": bool(data.get("published", True)),
                 "detail": data.get("detail"),
+                "name_zh": data.get("name_zh"),
                 "created_at": _now(),
                 "updated_at": _now(),
             }
@@ -102,6 +104,8 @@ class MemorySkillStore(SkillStore):
             record["published"] = bool(data["published"])
         if "detail" in data:
             record["detail"] = data["detail"]
+        if "name_zh" in data:
+            record["name_zh"] = data["name_zh"]
         record["updated_at"] = _now()
         return _with_derived(_copy(record))  # type: ignore[arg-type]
 
@@ -115,6 +119,8 @@ class MemorySkillStore(SkillStore):
             record["owner_user_id"] = data["owner_user_id"]
         if "detail" in data:
             record["detail"] = data["detail"]
+        if "name_zh" in data:
+            record["name_zh"] = data["name_zh"]
         record["updated_at"] = _now()
         return _with_derived(_copy(record))  # type: ignore[arg-type]
 
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/persistence/skills/model.py b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/skills/model.py
index ff981c15..b71a794f 100644
--- a/offline-backend-20260512/backend/packages/harness/deerflow/persistence/skills/model.py
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/skills/model.py
@@ -29,6 +29,10 @@ class SkillRow(Base):
     # kept in the DB so admins can annotate built-in skills without rewriting
     # the shared on-disk SKILL.md file.
     detail: Mapped[str | None] = mapped_column(Text, nullable=True, default=None)
+    # User-configured or LLM-generated Chinese display name. Kept in the DB (not
+    # the on-disk SKILL.md) so it can be set for built-in skills too, and so the
+    # shared source file is never rewritten.
+    name_zh: Mapped[str | None] = mapped_column(String(128), nullable=True, default=None)
     created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, default=lambda: datetime.now(UTC))
     updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, default=lambda: datetime.now(UTC), onupdate=lambda: datetime.now(UTC))
 
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/persistence/skills/sql.py b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/skills/sql.py
index e17dd015..3cefe180 100644
--- a/offline-backend-20260512/backend/packages/harness/deerflow/persistence/skills/sql.py
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/persistence/skills/sql.py
@@ -64,6 +64,7 @@ class SkillRepository(SkillStore):
             owner_user_id=data.get("owner_user_id"),
             published=bool(data.get("published", False)),
             detail=data.get("detail"),
+            name_zh=data.get("name_zh"),
             created_at=now,
             updated_at=now,
         )
@@ -83,6 +84,7 @@ class SkillRepository(SkillStore):
                     owner_user_id=data.get("owner_user_id"),
                     published=bool(data.get("published", True)),
                     detail=data.get("detail"),
+                    name_zh=data.get("name_zh"),
                     created_at=now,
                     updated_at=now,
                 )
@@ -105,6 +107,8 @@ class SkillRepository(SkillStore):
                 row.published = bool(data["published"])
             if "detail" in data:
                 row.detail = data["detail"]
+            if "name_zh" in data:
+                row.name_zh = data["name_zh"]
             row.updated_at = datetime.now(UTC)
             await session.commit()
             await session.refresh(row)
@@ -121,6 +125,8 @@ class SkillRepository(SkillStore):
                 row.owner_user_id = data["owner_user_id"]
             if "detail" in data:
                 row.detail = data["detail"]
+            if "name_zh" in data:
+                row.name_zh = data["name_zh"]
             row.updated_at = datetime.now(UTC)
             await session.commit()
             await session.refresh(row)
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/runtime/checkpointer/async_provider.py b/offline-backend-20260512/backend/packages/harness/deerflow/runtime/checkpointer/async_provider.py
index ef5d412e..d7fa14e5 100644
--- a/offline-backend-20260512/backend/packages/harness/deerflow/runtime/checkpointer/async_provider.py
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/runtime/checkpointer/async_provider.py
@@ -1,295 +1,302 @@
-"""Async checkpointer factory.
-
-Provides an **async context manager** for long-running async servers that need
-proper resource cleanup.
-
-Supported backends: memory, sqlite, postgres.
-
-Usage (e.g. FastAPI lifespan)::
-
-    from deerflow.runtime.checkpointer.async_provider import make_checkpointer
-
-    async with make_checkpointer() as checkpointer:
-        app.state.checkpointer = checkpointer  # InMemorySaver if not configured
-
-For sync usage see :mod:`deerflow.runtime.checkpointer.provider`.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import logging
-from collections.abc import AsyncIterator
-import os
-from pathlib import Path
-
-from langgraph.types import Checkpointer
-
-from deerflow.config.app_config import AppConfig, get_app_config
-from deerflow.runtime.checkpointer.provider import (
-    POSTGRES_CONN_REQUIRED,
-    POSTGRES_INSTALL,
-    SQLITE_INSTALL,
-)
-from deerflow.runtime.store._sqlite_utils import ensure_sqlite_parent_dir, resolve_sqlite_conn_str
-
-logger = logging.getLogger(__name__)
-
-
-def _csv_env(name: str) -> list[str]:
-    raw = os.getenv(name, "")
-    return [part.strip() for part in raw.split(",") if part.strip()]
-
-
-def _dual_read_enabled(config) -> bool:
-    if getattr(config, "dual_read_enabled", False):
-        return True
-    return os.getenv("DEER_FLOW_CHECKPOINT_DUAL_READ", "").strip().lower() in {"1", "true", "yes", "on"}
-
-
-def _use_postgres_enabled(config) -> bool:
-    raw = os.getenv("DEER_FLOW_USE_PG_CHECKPOINTER")
-    if raw:
-        return raw.strip().lower() not in {"0", "false", "no", "off"}
-    return bool(getattr(config, "use_postgres", True))
-
-
-def _dual_read_paths(config) -> list[str]:
-    paths = list(getattr(config, "dual_read_sqlite_paths", []) or [])
-    paths.extend(_csv_env("DEER_FLOW_CHECKPOINT_SQLITE_PATHS"))
-    resolved: list[str] = []
-    seen: set[str] = set()
-    for path in paths:
-        conn_str = resolve_sqlite_conn_str(path)
-        if conn_str == ":memory:" or conn_str.startswith("file:"):
-            logger.warning("Skipping unsupported checkpoint migration SQLite path: %s", path)
-            continue
-        if conn_str not in seen:
-            resolved.append(conn_str)
-            seen.add(conn_str)
-    return resolved
-
-
-def _sqlite_conn_str_for_postgres_fallback(config) -> str:
-    configured = getattr(config, "sqlite_connection_string", None)
-    if configured:
-        return configured
-    paths = _dual_read_paths(config)
-    return paths[0] if paths else "store.db"
-
-
-@contextlib.asynccontextmanager
-async def _pg_pool_saver(conn_str: str) -> AsyncIterator[Checkpointer]:
-    """Pool-backed ``AsyncPostgresSaver``, resilient to idle-closed connections.
-
-    ``AsyncPostgresSaver.from_conn_string`` opens **one** long-lived connection.
-    对远程 Postgres(本项目 47.88.25.99 这类),空闲几分钟后连接会被服务端 / NAT /
-    连接池中间件断开,而 psycopg **不会自动重连** —— 下一次 checkpoint 操作就抛
-    ``OperationalError: the connection is closed``,整个 run 直接失败(实测:圆桌第二步
-    完成后闲置 ~6 分钟,用户再人工干预 → leader run 读 checkpoint 时撞死连接 → 前端
-    "(无文本输出)")。
-
-    用带健康检查的连接池根治:``check=AsyncConnectionPool.check_connection`` 在把连接交给
-    调用方前先验活,坏连接直接丢弃重建;``max_idle`` 主动回收久闲连接,赶在远程 idle 超时
-    之前。这样上层永远拿不到失效连接。``prepare_threshold=0`` 关预备语句,兼容 pgbouncer
-    一类连接池(8432 非标准端口很可能就是)。
-    """
-    try:
-        from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
-    except ImportError as exc:
-        raise ImportError(POSTGRES_INSTALL) from exc
-    from psycopg_pool import AsyncConnectionPool
-
-    try:
-        max_size = int(os.getenv("DEER_FLOW_PG_POOL_MAX", "20"))
-    except ValueError:
-        max_size = 20
-
-    pool = AsyncConnectionPool(
-        conninfo=conn_str,
-        min_size=1,
-        max_size=max_size,
-        open=False,
-        kwargs={"autocommit": True, "prepare_threshold": 0},
-        check=AsyncConnectionPool.check_connection,
-        max_idle=120.0,
-        max_lifetime=1800.0,
-    )
-    await pool.open(wait=True)
-    try:
-        saver = AsyncPostgresSaver(pool)
-        await saver.setup()
-        logger.info("Checkpointer: Postgres connection pool ready (max_size=%d, health-checked)", max_size)
-        yield saver
-    finally:
-        await pool.close()
-
-
-@contextlib.asynccontextmanager
-async def _sqlite_checkpointer_from_conn_str(raw: str) -> AsyncIterator[Checkpointer]:
-    try:
-        from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
-    except ImportError as exc:
-        raise ImportError(SQLITE_INSTALL) from exc
-
-    conn_str = resolve_sqlite_conn_str(raw)
-    await asyncio.to_thread(ensure_sqlite_parent_dir, conn_str)
-    async with AsyncSqliteSaver.from_conn_string(conn_str) as saver:
-        await saver.setup()
-        yield saver
-
-
-# ---------------------------------------------------------------------------
-# Async factory
-# ---------------------------------------------------------------------------
-
-
-@contextlib.asynccontextmanager
-async def _async_checkpointer(config) -> AsyncIterator[Checkpointer]:
-    """Async context manager that constructs and tears down a checkpointer."""
-    if config.type == "memory":
-        from langgraph.checkpoint.memory import InMemorySaver
-
-        yield InMemorySaver()
-        return
-
-    if config.type == "sqlite":
-        async with _sqlite_checkpointer_from_conn_str(config.connection_string or "store.db") as saver:
-            yield saver
-        return
-
-    if config.type == "postgres":
-        if not _use_postgres_enabled(config):
-            conn_str = _sqlite_conn_str_for_postgres_fallback(config)
-            logger.info("Checkpointer: use_postgres=false; using SQLite fallback (%s)", conn_str)
-            async with _sqlite_checkpointer_from_conn_str(conn_str) as saver:
-                yield saver
-            return
-
-        if not config.connection_string:
-            raise ValueError(POSTGRES_CONN_REQUIRED)
-
-        # 连接池 + 健康检查,根治远程 Postgres 单连接空闲被关导致的 run 崩溃(见 _pg_pool_saver)。
-        async with _pg_pool_saver(config.connection_string) as saver:
-            if not _dual_read_enabled(config):
-                yield saver
-                return
-
-            from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
-
-            from deerflow.runtime.checkpointer.checkpoint_migration import (
-                DualReadCheckpointer,
-                SQLiteCheckpointSource,
-            )
-
-            sources: list[SQLiteCheckpointSource] = []
-            for sqlite_path in _dual_read_paths(config):
-                if not Path(sqlite_path).exists():
-                    logger.info("Checkpoint dual-read source does not exist, skipping: %s", sqlite_path)
-                    continue
-                ctx = AsyncSqliteSaver.from_conn_string(sqlite_path)
-                source_saver = await ctx.__aenter__()
-                await source_saver.setup()
-                sources.append(
-                    SQLiteCheckpointSource(
-                        path=sqlite_path,
-                        saver=source_saver,
-                        context=ctx,
-                        progress_path=Path(sqlite_path).with_suffix(Path(sqlite_path).suffix + ".pg-migration.json"),
-                    )
-                )
-
-            if not sources:
-                logger.info("Checkpoint dual-read enabled but no SQLite sources were opened; using Postgres only")
-                yield saver
-                return
-
-            proxy = DualReadCheckpointer(
-                saver,
-                sources,
-            )
-            try:
-                yield proxy
-            finally:
-                await proxy.aclose_sources()
-        return
-
-    raise ValueError(f"Unknown checkpointer type: {config.type!r}")
-
-
-# ---------------------------------------------------------------------------
-# Public async context manager
-# ---------------------------------------------------------------------------
-
-
-@contextlib.asynccontextmanager
-async def _async_checkpointer_from_database(db_config) -> AsyncIterator[Checkpointer]:
-    """Async context manager that constructs a checkpointer from unified DatabaseConfig."""
-    if db_config.backend == "memory":
-        from langgraph.checkpoint.memory import InMemorySaver
-
-        yield InMemorySaver()
-        return
-
-    if db_config.backend == "sqlite":
-        try:
-            from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
-        except ImportError as exc:
-            raise ImportError(SQLITE_INSTALL) from exc
-
-        conn_str = db_config.checkpointer_sqlite_path
-        ensure_sqlite_parent_dir(conn_str)
-        async with AsyncSqliteSaver.from_conn_string(conn_str) as saver:
-            await saver.setup()
-            yield saver
-        return
-
-    if db_config.backend == "postgres":
-        if not db_config.postgres_url:
-            raise ValueError("database.postgres_url is required for the postgres backend")
-
-        # 连接池 + 健康检查(见 _pg_pool_saver),避免单连接空闲被关。
-        async with _pg_pool_saver(db_config.postgres_url) as saver:
-            yield saver
-        return
-
-    raise ValueError(f"Unknown database backend: {db_config.backend!r}")
-
-
-@contextlib.asynccontextmanager
-async def make_checkpointer(app_config: AppConfig | None = None) -> AsyncIterator[Checkpointer]:
-    """Async context manager that yields a checkpointer for the caller's lifetime.
-    Resources are opened on enter and closed on exit -- no global state::
-
-        async with make_checkpointer(app_config) as checkpointer:
-            app.state.checkpointer = checkpointer
-
-    Yields an ``InMemorySaver`` when no checkpointer is configured in *config.yaml*.
-
-    Priority:
-    1. Legacy ``checkpointer:`` config section (backward compatible)
-    2. Unified ``database:`` config section
-    3. Default InMemorySaver
-    """
-
-    if app_config is None:
-        app_config = get_app_config()
-
-    # Legacy: standalone checkpointer config takes precedence
-    if app_config.checkpointer is not None:
-        async with _async_checkpointer(app_config.checkpointer) as saver:
-            yield saver
-            return
-
-    # Unified database config
-    db_config = getattr(app_config, "database", None)
-    if db_config is not None and db_config.backend != "memory":
-        async with _async_checkpointer_from_database(db_config) as saver:
-            yield saver
-            return
-
-    # Default: in-memory
-    from langgraph.checkpoint.memory import InMemorySaver
-
-    yield InMemorySaver()
+"""Async checkpointer factory.
+
+Provides an **async context manager** for long-running async servers that need
+proper resource cleanup.
+
+Supported backends: memory, sqlite, postgres.
+
+Usage (e.g. FastAPI lifespan)::
+
+    from deerflow.runtime.checkpointer.async_provider import make_checkpointer
+
+    async with make_checkpointer() as checkpointer:
+        app.state.checkpointer = checkpointer  # InMemorySaver if not configured
+
+For sync usage see :mod:`deerflow.runtime.checkpointer.provider`.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+from collections.abc import AsyncIterator
+import os
+from pathlib import Path
+
+from langgraph.types import Checkpointer
+
+from deerflow.config.app_config import AppConfig, get_app_config
+from deerflow.runtime.checkpointer.provider import (
+    POSTGRES_CONN_REQUIRED,
+    POSTGRES_INSTALL,
+    SQLITE_INSTALL,
+)
+from deerflow.runtime.store._sqlite_utils import ensure_sqlite_parent_dir, resolve_sqlite_conn_str
+
+logger = logging.getLogger(__name__)
+
+
+def _csv_env(name: str) -> list[str]:
+    raw = os.getenv(name, "")
+    return [part.strip() for part in raw.split(",") if part.strip()]
+
+
+def _dual_read_enabled(config) -> bool:
+    if getattr(config, "dual_read_enabled", False):
+        return True
+    return os.getenv("DEER_FLOW_CHECKPOINT_DUAL_READ", "").strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _use_postgres_enabled(config) -> bool:
+    raw = os.getenv("DEER_FLOW_USE_PG_CHECKPOINTER")
+    if raw:
+        return raw.strip().lower() not in {"0", "false", "no", "off"}
+    return bool(getattr(config, "use_postgres", True))
+
+
+def _dual_read_paths(config) -> list[str]:
+    paths = list(getattr(config, "dual_read_sqlite_paths", []) or [])
+    paths.extend(_csv_env("DEER_FLOW_CHECKPOINT_SQLITE_PATHS"))
+    resolved: list[str] = []
+    seen: set[str] = set()
+    for path in paths:
+        conn_str = resolve_sqlite_conn_str(path)
+        if conn_str == ":memory:" or conn_str.startswith("file:"):
+            logger.warning("Skipping unsupported checkpoint migration SQLite path: %s", path)
+            continue
+        if conn_str not in seen:
+            resolved.append(conn_str)
+            seen.add(conn_str)
+    return resolved
+
+
+def _sqlite_conn_str_for_postgres_fallback(config) -> str:
+    configured = getattr(config, "sqlite_connection_string", None)
+    if configured:
+        return configured
+    paths = _dual_read_paths(config)
+    return paths[0] if paths else "store.db"
+
+
+def _pool_size_env(name: str, default: int) -> int:
+    raw = os.getenv(name, "").strip()
+    if not raw:
+        return default
+    try:
+        return max(0, int(raw))
+    except ValueError:
+        logger.warning("Invalid %s=%r; using default %d", name, raw, default)
+        return default
+
+
+@contextlib.asynccontextmanager
+async def _postgres_saver_from_pool(conn_string: str) -> AsyncIterator[Checkpointer]:
+    """Yield an ``AsyncPostgresSaver`` backed by a self-healing connection pool.
+
+    ``AsyncPostgresSaver.from_conn_string`` opens a *single* long-lived
+    connection. If that one connection dies (Postgres restart, idle timeout,
+    network blip, or a prior broken pipeline), every later checkpointer call
+    fails permanently with "the connection is closed" until the process is
+    restarted. A pool with ``check=check_connection`` validates each connection
+    on checkout and transparently replaces dead ones, so the runtime recovers
+    on its own.
+    """
+    from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
+    from psycopg.rows import dict_row
+    from psycopg_pool import AsyncConnectionPool
+
+    pool = AsyncConnectionPool(
+        conninfo=conn_string,
+        min_size=_pool_size_env("DEER_FLOW_PG_POOL_MIN", 1),
+        max_size=_pool_size_env("DEER_FLOW_PG_POOL_MAX", 10),
+        max_idle=300.0,
+        max_lifetime=3600.0,
+        check=AsyncConnectionPool.check_connection,
+        kwargs={"autocommit": True, "prepare_threshold": 0, "row_factory": dict_row},
+        open=False,
+    )
+    await pool.open(wait=True)
+    try:
+        saver = AsyncPostgresSaver(pool)
+        await saver.setup()
+        yield saver
+    finally:
+        await pool.close()
+
+
+@contextlib.asynccontextmanager
+async def _sqlite_checkpointer_from_conn_str(raw: str) -> AsyncIterator[Checkpointer]:
+    try:
+        from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
+    except ImportError as exc:
+        raise ImportError(SQLITE_INSTALL) from exc
+
+    conn_str = resolve_sqlite_conn_str(raw)
+    await asyncio.to_thread(ensure_sqlite_parent_dir, conn_str)
+    async with AsyncSqliteSaver.from_conn_string(conn_str) as saver:
+        await saver.setup()
+        yield saver
+
+
+# ---------------------------------------------------------------------------
+# Async factory
+# ---------------------------------------------------------------------------
+
+
+@contextlib.asynccontextmanager
+async def _async_checkpointer(config) -> AsyncIterator[Checkpointer]:
+    """Async context manager that constructs and tears down a checkpointer."""
+    if config.type == "memory":
+        from langgraph.checkpoint.memory import InMemorySaver
+
+        yield InMemorySaver()
+        return
+
+    if config.type == "sqlite":
+        async with _sqlite_checkpointer_from_conn_str(config.connection_string or "store.db") as saver:
+            yield saver
+        return
+
+    if config.type == "postgres":
+        if not _use_postgres_enabled(config):
+            conn_str = _sqlite_conn_str_for_postgres_fallback(config)
+            logger.info("Checkpointer: use_postgres=false; using SQLite fallback (%s)", conn_str)
+            async with _sqlite_checkpointer_from_conn_str(conn_str) as saver:
+                yield saver
+            return
+
+        try:
+            from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver  # noqa: F401
+        except ImportError as exc:
+            raise ImportError(POSTGRES_INSTALL) from exc
+
+        if not config.connection_string:
+            raise ValueError(POSTGRES_CONN_REQUIRED)
+
+        async with _postgres_saver_from_pool(config.connection_string) as saver:
+            if not _dual_read_enabled(config):
+                yield saver
+                return
+
+            from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
+
+            from deerflow.runtime.checkpointer.checkpoint_migration import (
+                DualReadCheckpointer,
+                SQLiteCheckpointSource,
+            )
+
+            sources: list[SQLiteCheckpointSource] = []
+            for sqlite_path in _dual_read_paths(config):
+                if not Path(sqlite_path).exists():
+                    logger.info("Checkpoint dual-read source does not exist, skipping: %s", sqlite_path)
+                    continue
+                ctx = AsyncSqliteSaver.from_conn_string(sqlite_path)
+                source_saver = await ctx.__aenter__()
+                await source_saver.setup()
+                sources.append(
+                    SQLiteCheckpointSource(
+                        path=sqlite_path,
+                        saver=source_saver,
+                        context=ctx,
+                        progress_path=Path(sqlite_path).with_suffix(Path(sqlite_path).suffix + ".pg-migration.json"),
+                    )
+                )
+
+            if not sources:
+                logger.info("Checkpoint dual-read enabled but no SQLite sources were opened; using Postgres only")
+                yield saver
+                return
+
+            proxy = DualReadCheckpointer(
+                saver,
+                sources,
+            )
+            try:
+                yield proxy
+            finally:
+                await proxy.aclose_sources()
+        return
+
+    raise ValueError(f"Unknown checkpointer type: {config.type!r}")
+
+
+# ---------------------------------------------------------------------------
+# Public async context manager
+# ---------------------------------------------------------------------------
+
+
+@contextlib.asynccontextmanager
+async def _async_checkpointer_from_database(db_config) -> AsyncIterator[Checkpointer]:
+    """Async context manager that constructs a checkpointer from unified DatabaseConfig."""
+    if db_config.backend == "memory":
+        from langgraph.checkpoint.memory import InMemorySaver
+
+        yield InMemorySaver()
+        return
+
+    if db_config.backend == "sqlite":
+        try:
+            from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
+        except ImportError as exc:
+            raise ImportError(SQLITE_INSTALL) from exc
+
+        conn_str = db_config.checkpointer_sqlite_path
+        ensure_sqlite_parent_dir(conn_str)
+        async with AsyncSqliteSaver.from_conn_string(conn_str) as saver:
+            await saver.setup()
+            yield saver
+        return
+
+    if db_config.backend == "postgres":
+        try:
+            from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver  # noqa: F401
+        except ImportError as exc:
+            raise ImportError(POSTGRES_INSTALL) from exc
+
+        if not db_config.postgres_url:
+            raise ValueError("database.postgres_url is required for the postgres backend")
+
+        async with _postgres_saver_from_pool(db_config.postgres_url) as saver:
+            yield saver
+        return
+
+    raise ValueError(f"Unknown database backend: {db_config.backend!r}")
+
+
+@contextlib.asynccontextmanager
+async def make_checkpointer(app_config: AppConfig | None = None) -> AsyncIterator[Checkpointer]:
+    """Async context manager that yields a checkpointer for the caller's lifetime.
+    Resources are opened on enter and closed on exit -- no global state::
+
+        async with make_checkpointer(app_config) as checkpointer:
+            app.state.checkpointer = checkpointer
+
+    Yields an ``InMemorySaver`` when no checkpointer is configured in *config.yaml*.
+
+    Priority:
+    1. Legacy ``checkpointer:`` config section (backward compatible)
+    2. Unified ``database:`` config section
+    3. Default InMemorySaver
+    """
+
+    if app_config is None:
+        app_config = get_app_config()
+
+    # Legacy: standalone checkpointer config takes precedence
+    if app_config.checkpointer is not None:
+        async with _async_checkpointer(app_config.checkpointer) as saver:
+            yield saver
+            return
+
+    # Unified database config
+    db_config = getattr(app_config, "database", None)
+    if db_config is not None and db_config.backend != "memory":
+        async with _async_checkpointer_from_database(db_config) as saver:
+            yield saver
+            return
+
+    # Default: in-memory
+    from langgraph.checkpoint.memory import InMemorySaver
+
+    yield InMemorySaver()
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/runtime/store/async_provider.py b/offline-backend-20260512/backend/packages/harness/deerflow/runtime/store/async_provider.py
index 25156b01..94966e0d 100644
--- a/offline-backend-20260512/backend/packages/harness/deerflow/runtime/store/async_provider.py
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/runtime/store/async_provider.py
@@ -28,6 +28,42 @@ from deerflow.runtime.store.provider import POSTGRES_CONN_REQUIRED, POSTGRES_STO
 
 logger = logging.getLogger(__name__)
 
+
+def _pool_size_env(name: str, default: int) -> int:
+    import os
+
+    raw = os.getenv(name, "").strip()
+    if not raw:
+        return default
+    try:
+        return max(0, int(raw))
+    except ValueError:
+        logger.warning("Invalid %s=%r; using default %d", name, raw, default)
+        return default
+
+
+def _postgres_pool_config() -> dict:
+    """Pool config for the Postgres store.
+
+    A single long-lived connection (the default ``from_conn_string`` behavior)
+    dies permanently on a server restart / idle timeout / network blip — every
+    later store call then fails with "server closed the connection
+    unexpectedly". A pool with ``check=check_connection`` validates each
+    connection on checkout and replaces dead ones, so the runtime self-heals.
+    Extra keys (``check``/``max_idle``/``max_lifetime``) are passed straight
+    through to ``AsyncConnectionPool`` by ``from_conn_string``.
+    """
+    from psycopg_pool import AsyncConnectionPool
+
+    return {
+        "min_size": _pool_size_env("DEER_FLOW_PG_POOL_MIN", 1),
+        "max_size": _pool_size_env("DEER_FLOW_PG_POOL_MAX", 10),
+        "check": AsyncConnectionPool.check_connection,
+        "max_idle": 300.0,
+        "max_lifetime": 3600.0,
+    }
+
+
 # ---------------------------------------------------------------------------
 # Internal backend factory
 # ---------------------------------------------------------------------------
@@ -71,9 +107,9 @@ async def _async_store(config) -> AsyncIterator[BaseStore]:
         if not config.connection_string:
             raise ValueError(POSTGRES_CONN_REQUIRED)
 
-        async with AsyncPostgresStore.from_conn_string(config.connection_string) as store:
+        async with AsyncPostgresStore.from_conn_string(config.connection_string, pool_config=_postgres_pool_config()) as store:
             await store.setup()
-            logger.info("Store: using AsyncPostgresStore")
+            logger.info("Store: using AsyncPostgresStore (pooled, self-healing)")
             yield store
         return
 
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/tools/builtins/browser_act_tool.py b/offline-backend-20260512/backend/packages/harness/deerflow/tools/builtins/browser_act_tool.py
new file mode 100644
index 00000000..ed6797ae
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/tools/builtins/browser_act_tool.py
@@ -0,0 +1,225 @@
+"""Interactive browser action tool backed by the user's Chrome extension.
+
+Unlike ``browser_fetch_page`` (a one-shot read), this tool drives an
+*observe -> act* loop on a live page the extension keeps open:
+
+1. The model calls ``browser_act`` with an action (navigate/click/type/...).
+2. The extension performs the action on the session tab, then re-scans the page
+   and returns an *observation*: the final URL/title, an indexed list of
+   interactive elements, and the visible page text.
+3. The model reads the observation, picks the next element by its index, and
+   calls ``browser_act`` again with the same ``session_id``.
+
+The element ``index`` values are only valid for the most recent observation of a
+session; always act on indices from the latest result.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import urlparse
+from uuid import uuid4
+
+from langchain.tools import tool
+
+from deerflow.browser_context.tasks import create_browser_task, wait_for_browser_task_result
+from deerflow.config import get_app_config
+from deerflow.config.browser_context_config import BrowserContextConfig
+from deerflow.runtime.user_context import get_effective_user_id
+
+_ACTIONS = {"navigate", "click", "type", "scroll", "wait", "extract", "observe", "close"}
+_NEEDS_INDEX = {"click", "type"}
+
+
+def _settings() -> BrowserContextConfig:
+    value = getattr(get_app_config(), "browser_context", None)
+    if isinstance(value, BrowserContextConfig):
+        return value
+    if isinstance(value, dict):
+        return BrowserContextConfig.model_validate(value)
+    return BrowserContextConfig()
+
+
+def _validate_url(raw_url: str) -> str | None:
+    url = (raw_url or "").strip()
+    parsed = urlparse(url)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        return None
+    return url
+
+
+def _format_elements(elements: list[dict[str, Any]] | None) -> str:
+    if not elements:
+        return "(no interactive elements detected)"
+    lines: list[str] = []
+    for el in elements:
+        idx = el.get("index")
+        tag = str(el.get("tag") or "?")
+        el_type = str(el.get("type") or "").strip()
+        label = str(el.get("label") or "").strip().replace("\n", " ")
+        if len(label) > 120:
+            label = label[:120] + "…"
+        descriptor = f"{tag}" + (f"[{el_type}]" if el_type else "")
+        extra = ""
+        if el.get("value"):
+            value = str(el["value"]).strip().replace("\n", " ")
+            extra = f' value="{value[:60]}"'
+        lines.append(f"[{idx}] {descriptor} \"{label}\"{extra}".rstrip())
+    return "\n".join(lines)
+
+
+def _format_observation(action: str, observation: dict[str, Any] | None, session_id: str, settings: BrowserContextConfig) -> str:
+    observation = observation or {}
+    status = str(observation.get("action_status") or "ok")
+    message = str(observation.get("message") or "").strip()
+    url = str(observation.get("url") or "").strip() or "(unknown)"
+    title = str(observation.get("title") or "").strip() or "(untitled)"
+    elements = observation.get("elements") if isinstance(observation.get("elements"), list) else []
+    text = str(observation.get("text") or "").strip()
+    text_limit = max(500, int(settings.observation_text_max_chars))
+    text_truncated = len(text) > text_limit
+    if text_truncated:
+        text = text[:text_limit]
+
+    parts = [
+        f"Browser session: {session_id}",
+        f"Last action: {action} -> {status}",
+    ]
+    if message:
+        parts.append(f"Note: {message}")
+    parts.extend(
+        [
+            f"URL: {url}",
+            f"Title: {title}",
+            "",
+            "Interactive elements (use the [index] with click/type):",
+            _format_elements(elements),
+            "",
+            "Page text:",
+            text or "(empty page text)",
+        ]
+    )
+    if text_truncated:
+        parts.append("\n[Page text truncated by browser_context.observation_text_max_chars]")
+    parts.append(
+        "\nNext step: call browser_act again with this session_id and the index of the element to act on. "
+        "When the task is finished, call browser_act with action=\"close\" to release the tab."
+    )
+    return "\n".join(parts)
+
+
+@tool("browser_act", parse_docstring=True)
+async def browser_act_tool(
+    action: str,
+    session_id: str = "",
+    url: str = "",
+    index: int = -1,
+    text: str = "",
+    submit: bool = False,
+    wait_for: str = "",
+    wait_seconds: int = 0,
+) -> str:
+    """Drive an interactive observe/act loop on a page in the user's Chrome browser.
+
+    Use this to operate a real web page on the user's behalf — log in, fill forms,
+    click through navigation, and read pages that need the user's session or local
+    network. Start every task with ``action="navigate"`` and a URL to open a tab
+    and get the first observation, then keep calling this tool with the same
+    ``session_id``, choosing elements by the ``index`` shown in the observation.
+    Call ``action="close"`` when done to free the tab.
+
+    Args:
+        action: One of navigate, click, type, scroll, wait, extract, observe, close.
+        session_id: Session id from a previous observation. Leave empty to start a new session (requires navigate + url).
+        url: Target http(s) URL. Required for navigate (and to start a new session).
+        index: Index of the interactive element to act on, taken from the latest observation. Required for click and type.
+        text: Text to enter for the type action.
+        submit: For type, press Enter / submit the form after typing.
+        wait_for: For wait, a CSS selector to wait for before observing.
+        wait_seconds: Optional extra seconds to wait for this step's result. Zero uses the configured default.
+    """
+
+    settings = _settings()
+    if not settings.enabled:
+        return "browser_act is disabled by config.yaml: browser_context.enabled is false."
+    if not settings.actions_enabled:
+        return "browser_act is disabled by config.yaml: browser_context.actions_enabled is false."
+
+    action = (action or "").strip().lower()
+    if action not in _ACTIONS:
+        return f"browser_act: unknown action {action!r}. Use one of: {', '.join(sorted(_ACTIONS))}."
+
+    session_id = (session_id or "").strip()
+    safe_url = _validate_url(url) if url else None
+
+    if action == "navigate" and safe_url is None:
+        return "browser_act navigate requires an exact http(s) URL, for example https://example.com/page."
+
+    if not session_id:
+        if action != "navigate":
+            return "browser_act: no session_id yet. Start with action=\"navigate\" and a url to open the page first."
+        session_id = uuid4().hex
+
+    if action in _NEEDS_INDEX and index < 0:
+        return f"browser_act {action} requires a non-negative element index from the latest observation."
+    if action == "type" and not text:
+        return "browser_act type requires the text to enter."
+
+    action_payload: dict[str, Any] = {"type": action}
+    if safe_url is not None:
+        action_payload["url"] = safe_url
+    if index >= 0:
+        action_payload["index"] = int(index)
+    if text:
+        action_payload["text"] = text
+    if submit:
+        action_payload["submit"] = True
+    if wait_for.strip():
+        action_payload["wait_for"] = wait_for.strip()[:300]
+
+    configured_timeout = max(5, int(settings.action_result_timeout_seconds))
+    requested_timeout = int(wait_seconds or configured_timeout)
+    timeout = min(max(5, requested_timeout), configured_timeout)
+    user_id = get_effective_user_id()
+
+    task = create_browser_task(
+        user_id=user_id,
+        url=safe_url or "",
+        instruction="",
+        kind="act",
+        session_id=session_id,
+        action=action_payload,
+        timeout_seconds=timeout + int(settings.task_lease_seconds),
+        max_content_chars=settings.max_content_chars,
+        metadata={"source": "browser_act_tool"},
+    )
+
+    completed = await wait_for_browser_task_result(
+        task_id=task["id"],
+        user_id=user_id,
+        timeout_seconds=timeout,
+        poll_interval_seconds=settings.task_poll_interval_seconds,
+    )
+    if completed is None:
+        return f"Browser task {task['id']} was not found after it was created."
+
+    status = completed.get("status")
+    if status == "error":
+        return f"browser_act session {session_id}: step failed: {completed.get('error') or 'unknown error'}"
+    if status == "expired":
+        return (
+            f"browser_act session {session_id}: the Chrome extension did not respond in time. "
+            "Check that Deer Web Clipper is installed, the same user is logged in, and task polling is enabled."
+        )
+    if status != "done":
+        return (
+            f"browser_act session {session_id}: step is still {status or 'pending'} after {timeout} seconds. "
+            "Keep the Deer Web Clipper extension running with task polling enabled, then try again."
+        )
+
+    if action == "close":
+        return f"browser_act session {session_id}: tab closed."
+
+    result = completed.get("result") or {}
+    observation = result.get("observation") if isinstance(result.get("observation"), dict) else None
+    return _format_observation(action, observation, session_id, settings)
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/tools/builtins/browser_context_tool.py b/offline-backend-20260512/backend/packages/harness/deerflow/tools/builtins/browser_context_tool.py
new file mode 100644
index 00000000..6b065834
--- /dev/null
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/tools/builtins/browser_context_tool.py
@@ -0,0 +1,117 @@
+"""Browser extension backed page fetch tool."""
+
+from __future__ import annotations
+
+from urllib.parse import urlparse
+
+from langchain.tools import tool
+
+from deerflow.browser_context.tasks import create_browser_task, wait_for_browser_task_result
+from deerflow.config import get_app_config
+from deerflow.config.browser_context_config import BrowserContextConfig
+from deerflow.runtime.user_context import get_effective_user_id
+
+
+def _settings() -> BrowserContextConfig:
+    value = getattr(get_app_config(), "browser_context", None)
+    if isinstance(value, BrowserContextConfig):
+        return value
+    if isinstance(value, dict):
+        return BrowserContextConfig.model_validate(value)
+    return BrowserContextConfig()
+
+
+def _validate_url(raw_url: str) -> str | None:
+    url = (raw_url or "").strip()
+    parsed = urlparse(url)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        return None
+    return url
+
+
+@tool("browser_fetch_page", parse_docstring=True)
+async def browser_fetch_page_tool(url: str, question: str = "", wait_seconds: int = 0) -> str:
+    """Ask the user's paired Chrome extension to fetch a page and return visible page text.
+
+    Use this when the user explicitly asks to use the browser extension or asks
+    for data from a page that may require their browser session, login state, or
+    local network access. The URL must be an exact http(s) URL provided by the
+    user. If the user did not provide a URL, ask for the URL instead of guessing.
+
+    Args:
+        url: Exact http(s) URL to open in the user's Chrome browser.
+        question: Optional instruction describing what data the user wants from the page.
+        wait_seconds: Optional seconds to wait for the extension result. Zero uses the configured default.
+    """
+
+    settings = _settings()
+    if not settings.enabled:
+        return "browser_fetch_page is disabled by config.yaml: browser_context.enabled is false."
+
+    safe_url = _validate_url(url)
+    if safe_url is None:
+        return "browser_fetch_page requires an exact http(s) URL, for example https://example.com/page."
+
+    configured_timeout = max(5, int(settings.task_result_timeout_seconds))
+    requested_timeout = int(wait_seconds or configured_timeout)
+    timeout = min(max(5, requested_timeout), configured_timeout)
+    user_id = get_effective_user_id()
+
+    task = create_browser_task(
+        user_id=user_id,
+        url=safe_url,
+        instruction=(question or "").strip(),
+        timeout_seconds=timeout + int(settings.task_lease_seconds),
+        max_content_chars=settings.max_content_chars,
+        metadata={"source": "browser_fetch_page_tool"},
+    )
+
+    completed = await wait_for_browser_task_result(
+        task_id=task["id"],
+        user_id=user_id,
+        timeout_seconds=timeout,
+        poll_interval_seconds=settings.task_poll_interval_seconds,
+    )
+    if completed is None:
+        return f"Browser task {task['id']} was not found after it was created."
+
+    status = completed.get("status")
+    if status == "error":
+        return f"Browser task {task['id']} failed: {completed.get('error') or 'unknown error'}"
+    if status == "expired":
+        return (
+            f"Browser task {task['id']} expired before the Chrome extension returned a result. "
+            "Check that Deer Web Clipper is installed, configured with the same access token, and task polling is enabled."
+        )
+    if status != "done":
+        return (
+            f"Browser task {task['id']} is still {status or 'pending'} after {timeout} seconds. "
+            "Keep the Deer Web Clipper extension running with task polling enabled, then try again."
+        )
+
+    result = completed.get("result") or {}
+    content = str(result.get("content") or "").strip()
+    tool_limit = max(1_000, int(settings.tool_result_max_chars))
+    tool_truncated = len(content) > tool_limit
+    if tool_truncated:
+        content = content[:tool_limit]
+
+    notes: list[str] = []
+    if result.get("truncated"):
+        notes.append("The browser capture was truncated by browser_context.max_content_chars.")
+    if tool_truncated:
+        notes.append("The tool response was truncated by browser_context.tool_result_max_chars.")
+
+    parts = [
+        "Browser page fetched through the user's Chrome extension.",
+        f"Task ID: {task['id']}",
+        f"Title: {result.get('title') or '(untitled)'}",
+        f"URL: {result.get('url') or safe_url}",
+    ]
+    if question:
+        parts.extend(["", "Requested extraction:", question.strip()])
+    if notes:
+        parts.extend(["", "Notes:", "\n".join(f"- {note}" for note in notes)])
+    parts.extend(["", "Page content:", content or "(empty page text)"])
+    return "\n".join(parts)
+
diff --git a/offline-backend-20260512/backend/packages/harness/deerflow/tools/tools.py b/offline-backend-20260512/backend/packages/harness/deerflow/tools/tools.py
index 8a14e0a1..2bf592ee 100644
--- a/offline-backend-20260512/backend/packages/harness/deerflow/tools/tools.py
+++ b/offline-backend-20260512/backend/packages/harness/deerflow/tools/tools.py
@@ -11,6 +11,11 @@ from deerflow.tools.builtins.tool_search import reset_deferred_registry
 
 logger = logging.getLogger(__name__)
 
+BROWSER_CONTEXT_TOOL_USE = "deerflow.tools.builtins.browser_context_tool:browser_fetch_page_tool"
+BROWSER_ACT_TOOL_USE = "deerflow.tools.builtins.browser_act_tool:browser_act_tool"
+BROWSER_CONTEXT_TOOL_USES = {BROWSER_CONTEXT_TOOL_USE, BROWSER_ACT_TOOL_USE}
+BROWSER_CONTEXT_TOOL_NAMES = {"browser_fetch_page", "browser_act"}
+
 BUILTIN_TOOLS = [
     present_file_tool,
     ask_clarification_tool,
@@ -34,6 +39,14 @@ def _is_host_bash_tool(tool: object) -> bool:
     return False
 
 
+def _is_browser_context_tool(tool: object) -> bool:
+    """Return True if the tool config represents the browser extension bridge."""
+
+    use = getattr(tool, "use", None)
+    name = getattr(tool, "name", None)
+    return use in BROWSER_CONTEXT_TOOL_USES or name in BROWSER_CONTEXT_TOOL_NAMES
+
+
 def get_available_tools(
     groups: list[str] | None = None,
     include_mcp: bool = True,
@@ -64,6 +77,18 @@ def get_available_tools(
     config = app_config or get_app_config()
     tool_configs = [tool for tool in config.tools if groups is None or tool.group in groups]
 
+    browser_context_config = getattr(config, "browser_context", None)
+    if not getattr(browser_context_config, "enabled", False):
+        tool_configs = [tool for tool in tool_configs if not _is_browser_context_tool(tool)]
+    elif not getattr(browser_context_config, "actions_enabled", True):
+        # browser_context is on, but interactive page actions are disabled — keep
+        # the read-only browser_fetch_page tool, drop only browser_act.
+        tool_configs = [
+            tool
+            for tool in tool_configs
+            if getattr(tool, "use", None) != BROWSER_ACT_TOOL_USE and getattr(tool, "name", None) != "browser_act"
+        ]
+
     # Do not expose host bash by default when LocalSandboxProvider is active.
     if not is_host_bash_allowed(config):
         tool_configs = [tool for tool in tool_configs if not _is_host_bash_tool(tool)]
diff --git a/offline-backend-20260512/backend/scripts/sql/column_additions_mysql.sql b/offline-backend-20260512/backend/scripts/sql/column_additions_mysql.sql
new file mode 100644
index 00000000..51c1e20c
--- /dev/null
+++ b/offline-backend-20260512/backend/scripts/sql/column_additions_mysql.sql
@@ -0,0 +1,74 @@
+-- ============================================================================
+-- 给【已存在的表】补列(ADD COLUMN)—— MySQL 手动执行版
+-- ============================================================================
+--
+-- 背景:
+--   本项目的 alembic 自动迁移是【关闭】的(engine.py 中
+--   `# await _run_alembic_upgrade(url)` 被注释)。`Base.metadata.create_all`
+--   只会建【新表】,对【已存在的表】既不会补建索引、也不会补加新列。
+--   因此当我们在某个 ORM model 上新增了一列时,【全新部署】会随建表一并带上,
+--   但【已有数据的 MySQL 部署】上这一列并不会自动出现,代码读写该列会报错。
+--
+-- 约定(重要):
+--   今后只要有代码给某张【已存在的表】新增字段(在 ORM model 上加列),就必须
+--   把对应的 `ADD COLUMN` 语句以下面的【幂等】写法补进本文件,并在迁移目录里
+--   保留对应的 alembic 版本文件,二者保持一致。运维在升级老库时整文件执行本脚本
+--   即可补齐所有缺失的列。
+--
+-- 用法:
+--   1) 先选中目标库(与 database.mysql_url 里的库名一致):
+--        USE your_deerflow_db;
+--   2) 直接整文件执行即可。本脚本是【幂等】的:已存在的列会跳过,不会报错,
+--      可重复执行。
+--
+-- 注意:
+--   * 列定义必须与 ORM model / alembic migration 完全一致(类型、长度、可空性)。
+--   * 新增列一律建议 NULL 或带 DEFAULT,避免在大表上回填导致长时间锁表。
+--   * MySQL 8.0 在线 DDL 默认 ALGORITHM=INPLACE 一般不阻塞写入,但仍建议低峰执行。
+-- ============================================================================
+
+-- ---- 通用幂等封装:仅当列不存在时才新增 --------------------------------------
+DELIMITER //
+DROP PROCEDURE IF EXISTS _add_column_if_missing //
+CREATE PROCEDURE _add_column_if_missing(
+    IN p_table      VARCHAR(64),
+    IN p_column     VARCHAR(64),
+    IN p_definition VARCHAR(255)   -- 列定义,如 'VARCHAR(128) NULL DEFAULT NULL'
+)
+BEGIN
+    DECLARE v_exists INT DEFAULT 0;
+    SELECT COUNT(*) INTO v_exists
+      FROM information_schema.columns
+     WHERE table_schema = DATABASE()
+       AND table_name   = p_table
+       AND column_name  = p_column;
+
+    IF v_exists = 0 THEN
+        SET @ddl = CONCAT('ALTER TABLE `', p_table, '` ADD COLUMN `', p_column, '` ', p_definition);
+        PREPARE stmt FROM @ddl;
+        EXECUTE stmt;
+        DEALLOCATE PREPARE stmt;
+        SELECT CONCAT('ADDED    ', p_table, '.', p_column) AS result;
+    ELSE
+        SELECT CONCAT('SKIPPED  ', p_table, '.', p_column, ' (already exists)') AS result;
+    END IF;
+END //
+DELIMITER ;
+
+-- ---- skills ------------------------------------------------------------------
+-- name_zh: 技能的中文显示名(用户配置或 LLM 生成),对应 migration 20260609_01。
+--          ORM: SkillRow.name_zh = String(128), nullable=True。
+CALL _add_column_if_missing('skills', 'name_zh', 'VARCHAR(128) NULL DEFAULT NULL');
+-- detail: 技能的长文介绍,对应 migration 20260518_01。
+--          ORM: SkillRow.detail = Text, nullable=True。
+CALL _add_column_if_missing('skills', 'detail', 'TEXT NULL DEFAULT NULL');
+
+-- ---- 清理临时存储过程 --------------------------------------------------------
+DROP PROCEDURE IF EXISTS _add_column_if_missing;
+
+-- ---- 执行后自检:确认本批次涉及的列都已存在 ---------------------------------
+SELECT table_name, column_name
+  FROM information_schema.columns
+ WHERE table_schema = DATABASE()
+   AND (table_name = 'skills' AND column_name IN ('name_zh', 'detail'))
+ ORDER BY table_name, column_name;
diff --git a/offline-backend-20260512/backend/tests/test_browser_act.py b/offline-backend-20260512/backend/tests/test_browser_act.py
new file mode 100644
index 00000000..3dee216a
--- /dev/null
+++ b/offline-backend-20260512/backend/tests/test_browser_act.py
@@ -0,0 +1,158 @@
+"""Tests for the interactive browser_act tool and its act-task queue support."""
+
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+
+from deerflow.browser_context import tasks as task_queue
+from deerflow.config.browser_context_config import BrowserContextConfig
+from deerflow.tools.builtins import browser_act_tool as act_mod
+
+
+@pytest.fixture(autouse=True)
+def _isolated_task_home(tmp_path, monkeypatch):
+    """Point the file-backed task queue at a throwaway directory."""
+    monkeypatch.setenv("DEER_FLOW_HOME", str(tmp_path))
+    yield
+
+
+def _enable_actions(monkeypatch, *, enabled=True, actions_enabled=True):
+    cfg = BrowserContextConfig(
+        enabled=enabled,
+        actions_enabled=actions_enabled,
+        action_result_timeout_seconds=5,
+        task_poll_interval_seconds=0.25,
+        task_lease_seconds=30,
+    )
+    monkeypatch.setattr(act_mod, "_settings", lambda: cfg)
+    return cfg
+
+
+# --- task queue layer -------------------------------------------------------
+
+
+def test_act_task_round_trip_carries_session_and_observation():
+    task = task_queue.create_browser_task(
+        user_id="u1",
+        url="https://example.com",
+        kind="act",
+        session_id="sess-1",
+        action={"type": "navigate", "url": "https://example.com"},
+    )
+    assert task["kind"] == "act"
+    assert task["session_id"] == "sess-1"
+
+    claimed = task_queue.claim_next_browser_task(user_id="u1", worker_id="w1")
+    assert claimed is not None
+    assert claimed["kind"] == "act"
+    assert claimed["session_id"] == "sess-1"
+    assert claimed["action"] == {"type": "navigate", "url": "https://example.com"}
+
+    observation = {
+        "action_status": "ok",
+        "url": "https://example.com/home",
+        "title": "Home",
+        "elements": [{"index": 0, "tag": "button", "label": "Login"}],
+        "text": "welcome",
+    }
+    done = task_queue.complete_browser_task(
+        task_id=task["id"],
+        user_id="u1",
+        observation=observation,
+    )
+    assert done is not None
+    assert done["status"] == "done"
+    assert done["result"]["observation"] == observation
+
+
+def test_fetch_task_default_kind_is_fetch():
+    task = task_queue.create_browser_task(user_id="u1", url="https://example.com")
+    assert task["kind"] == "fetch"
+    claimed = task_queue.claim_next_browser_task(user_id="u1", worker_id="w1")
+    assert claimed["kind"] == "fetch"
+    assert claimed["session_id"] == ""
+    assert claimed["action"] is None
+
+
+# --- tool validation --------------------------------------------------------
+
+
+async def _invoke(**kwargs) -> str:
+    return await act_mod.browser_act_tool.ainvoke(kwargs)
+
+
+@pytest.mark.asyncio
+async def test_browser_act_disabled_when_actions_off(monkeypatch):
+    _enable_actions(monkeypatch, enabled=True, actions_enabled=False)
+    out = await _invoke(action="navigate", url="https://example.com")
+    assert "actions_enabled is false" in out
+
+
+@pytest.mark.asyncio
+async def test_browser_act_unknown_action(monkeypatch):
+    _enable_actions(monkeypatch)
+    out = await _invoke(action="frobnicate")
+    assert "unknown action" in out
+
+
+@pytest.mark.asyncio
+async def test_browser_act_navigate_requires_url(monkeypatch):
+    _enable_actions(monkeypatch)
+    out = await _invoke(action="navigate")
+    assert "requires an exact http(s) URL" in out
+
+
+@pytest.mark.asyncio
+async def test_browser_act_non_navigate_needs_session(monkeypatch):
+    _enable_actions(monkeypatch)
+    out = await _invoke(action="click", index=0)
+    assert "no session_id yet" in out
+
+
+@pytest.mark.asyncio
+async def test_browser_act_click_requires_index(monkeypatch):
+    _enable_actions(monkeypatch)
+    out = await _invoke(action="click", session_id="sess-1")
+    assert "requires a non-negative element index" in out
+
+
+# --- tool success path (simulated extension) --------------------------------
+
+
+@pytest.mark.asyncio
+async def test_browser_act_returns_formatted_observation(monkeypatch):
+    _enable_actions(monkeypatch)
+
+    async def fake_extension():
+        # Wait for the tool to create the pending act task, then complete it.
+        for _ in range(40):
+            claimed = task_queue.claim_next_browser_task(user_id="default", worker_id="ext")
+            if claimed is not None:
+                task_queue.complete_browser_task(
+                    task_id=claimed["id"],
+                    user_id="default",
+                    observation={
+                        "action_status": "ok",
+                        "url": "https://example.com/home",
+                        "title": "Home Page",
+                        "elements": [
+                            {"index": 0, "tag": "input", "type": "search", "label": "Search", "value": ""},
+                            {"index": 1, "tag": "button", "label": "Go"},
+                        ],
+                        "text": "Welcome to the home page.",
+                    },
+                )
+                return
+            await asyncio.sleep(0.1)
+
+    ext = asyncio.create_task(fake_extension())
+    out = await _invoke(action="navigate", url="https://example.com")
+    await ext
+
+    assert "Browser session:" in out
+    assert "Home Page" in out
+    assert "[0] input[search]" in out
+    assert "[1] button" in out
+    assert "Welcome to the home page." in out
diff --git a/offline-backend-20260512/config.yaml b/offline-backend-20260512/config.yaml
index 1956e4df..751c0156 100644
--- a/offline-backend-20260512/config.yaml
+++ b/offline-backend-20260512/config.yaml
@@ -1,76 +1,76 @@
 config_version: 8
 log_level: info
 models:
-- name: deepseek-chat
-  display_name: DeepSeek Chat
+# - name: deepseek-chat
+#   display_name: DeepSeek Chat
+#   use: langchain_openai:ChatOpenAI
+#   model: deepseek-chat
+#   api_key: sk-9808fb2375534112ac275541aec14b9b
+#   base_url: https://api.deepseek.com
+#   request_timeout: 600.0
+#   max_retries: 2
+#   max_tokens: 4096
+#   temperature: 1.0
+#   supports_vision: false
+#   supports_thinking: true
+# - name: zai-org/GLM-5-FP8
+#   display_name: zai-org/GLM-5-FP8
+#   use: langchain_openai:ChatOpenAI
+#   model: zai-org/GLM-5-FP8
+#   api_key: modalresearch_gWu46FDpVLYZWPVEA3b_2fq8Jw2UJiKMgEm_Rxmn1SA
+#   base_url: https://api.us-west-2.modal.direct/v1
+#   request_timeout: 600.0
+#   max_retries: 2
+#   max_tokens: 4096
+#   temperature: 1.0
+#   supports_vision: true
+#   supports_thinking: true
+# - name: deepseek-v4-pro
+#   display_name: DeepSeek V4 Pro
+#   use: langchain_openai:ChatOpenAI
+#   model: deepseek-v4-pro
+#   api_key: sk-e1c22b7931dc446f8b67e57878edd105
+#   base_url: https://api.deepseek.com
+#   request_timeout: 600.0
+#   max_retries: 2
+#   max_tokens: 4096
+#   temperature: 1.0
+#   supports_vision: false
+#   supports_thinking: true
+# - name: minimax-m2.7
+#   display_name: MiniMax M2.7
+#   use: langchain_openai:ChatOpenAI
+#   model: MiniMax-M2.7
+#   api_key: sk-cp-mrsAGtzDpUl0TpOBPVoiRG_pWF1kDDN9_mDAnONBs6HIPcNUexSKtSbx2QOxfKBvJT6Xw6hDTV6hdkJYFWfNA8UtHQ08TiGJiosdRoW6q1sGb6Cb7D85NHk
+#   base_url: https://api.minimaxi.com
+#   max_tokens: 4096
+#   temperature: 1.0
+#   supports_vision: true
+#   supports_thinking: true
+# - name: minimax-m2.5
+#   display_name: MiniMax M2.5
+#   use: langchain_openai:ChatOpenAI
+#   model: MiniMax-M2.5
+#   api_key: sk-cp-mrsAGtzDpUl0TpOBPVoiRG_pWF1kDDN9_mDAnONBs6HIPcNUexSKtSbx2QOxfKBvJT6Xw6hDTV6hdkJYFWfNA8UtHQ08TiGJiosdRoW6q1sGb6Cb7D85NHk
+#   base_url: https://api.minimaxi.com
+#   max_tokens: 4096
+#   temperature: 1.0
+#   supports_vision: true
+#   supports_thinking: true
+# - name: deepseek-ai/DeepSeek-OCR
+#   display_name: deepseek-ai/DeepSeek-OCR
+#   use: langchain_openai:ChatOpenAI
+#   model: deepseek-ai/DeepSeek-OCR
+#   api_key: sk-beshfxfxfrllsczpqfrgjbugfbpzxgqgedbehceytpcvvtyb
+#   base_url: https://api.siliconflow.cn/v1/
+#   max_tokens: 4096
+#   temperature: 1.0
+#   supports_vision: true
+#   supports_thinking: true
+- name: deepseek-ai/DeepSeek-V4-Flash
+  display_name: deepseek-ai/DeepSeek-V4-Flash
   use: langchain_openai:ChatOpenAI
-  model: deepseek-chat
-  api_key: sk-9808fb2375534112ac275541aec14b9b
-  base_url: https://api.deepseek.com
-  request_timeout: 600.0
-  max_retries: 2
-  max_tokens: 4096
-  temperature: 1.0
-  supports_vision: false
-  supports_thinking: true
-- name: zai-org/GLM-5-FP8
-  display_name: zai-org/GLM-5-FP8
-  use: langchain_openai:ChatOpenAI
-  model: zai-org/GLM-5-FP8
-  api_key: modalresearch_gWu46FDpVLYZWPVEA3b_2fq8Jw2UJiKMgEm_Rxmn1SA
-  base_url: https://api.us-west-2.modal.direct/v1
-  request_timeout: 600.0
-  max_retries: 2
-  max_tokens: 4096
-  temperature: 1.0
-  supports_vision: true
-  supports_thinking: true
-- name: deepseek-v4-pro
-  display_name: DeepSeek V4 Pro
-  use: langchain_openai:ChatOpenAI
-  model: deepseek-v4-pro
-  api_key: sk-e1c22b7931dc446f8b67e57878edd105
-  base_url: https://api.deepseek.com
-  request_timeout: 600.0
-  max_retries: 2
-  max_tokens: 4096
-  temperature: 1.0
-  supports_vision: false
-  supports_thinking: true
-- name: minimax-m2.7
-  display_name: MiniMax M2.7
-  use: langchain_openai:ChatOpenAI
-  model: MiniMax-M2.7
-  api_key: sk-cp-mrsAGtzDpUl0TpOBPVoiRG_pWF1kDDN9_mDAnONBs6HIPcNUexSKtSbx2QOxfKBvJT6Xw6hDTV6hdkJYFWfNA8UtHQ08TiGJiosdRoW6q1sGb6Cb7D85NHk
-  base_url: https://api.minimaxi.com
-  max_tokens: 4096
-  temperature: 1.0
-  supports_vision: true
-  supports_thinking: true
-- name: minimax-m2.5
-  display_name: MiniMax M2.5
-  use: langchain_openai:ChatOpenAI
-  model: MiniMax-M2.5
-  api_key: sk-cp-mrsAGtzDpUl0TpOBPVoiRG_pWF1kDDN9_mDAnONBs6HIPcNUexSKtSbx2QOxfKBvJT6Xw6hDTV6hdkJYFWfNA8UtHQ08TiGJiosdRoW6q1sGb6Cb7D85NHk
-  base_url: https://api.minimaxi.com
-  max_tokens: 4096
-  temperature: 1.0
-  supports_vision: true
-  supports_thinking: true
-- name: deepseek-ai/DeepSeek-OCR
-  display_name: deepseek-ai/DeepSeek-OCR
-  use: langchain_openai:ChatOpenAI
-  model: deepseek-ai/DeepSeek-OCR
-  api_key: sk-beshfxfxfrllsczpqfrgjbugfbpzxgqgedbehceytpcvvtyb
-  base_url: https://api.siliconflow.cn/v1/
-  max_tokens: 4096
-  temperature: 1.0
-  supports_vision: true
-  supports_thinking: true
-- name: Qwen/Qwen3.6-27B
-  display_name: Qwen/Qwen3.6-27B
-  use: langchain_openai:ChatOpenAI
-  model: Qwen/Qwen3.6-27B
+  model: deepseek-ai/DeepSeek-V4-Flash
   api_key: sk-qwwwvjompnzxqhndctlwmmomvqdgaqqqgxvibfxchsikvgod
   base_url: https://api.siliconflow.cn/v1/
   max_tokens: 4096
diff --git a/parallel-agents-vue/README.md b/parallel-agents-vue/README.md
index c4602f35..fa0169a3 100644
--- a/parallel-agents-vue/README.md
+++ b/parallel-agents-vue/README.md
@@ -25,11 +25,23 @@ pnpm build:lib  # 产出 dist/parallel-agents-vue.{js,umd.cjs} + dist/parallel-a
 
 ## 嵌入其它 Vue 项目
 
+两种方式（详见 [docs/07-使用说明.md](./docs/07-使用说明.md)）：
+
+**A. 按包引入**（已 `build:lib`）：
+
 ```ts
 import { ParallelAgentsPanel } from "parallel-agents-vue";
 import "parallel-agents-vue/style.css";
 ```
 
+**B. 直接拷源码**（适合要改源码的人）：把整个 **`src/parallel-agents/` 文件夹**拷进你的项目 `src/` 下，
+样式由其 `index.ts` 自动引入，**无需 Tailwind / 任何 CSS 框架**：
+
+```ts
+import { ParallelAgentsPanel } from "@/parallel-agents"; // 或 "./parallel-agents"
+```
+> 仅需 `vue` 与 `markdown-it` 两个运行依赖。
+
 ```vue
 <!-- 放进你自己的抽屉 / 弹窗里，面板会自适应容器（h-full w-full）。
      接口地址走配置文件默认（src/config.ts），登录只需把用户名传进来（免密自动登录）。 -->
@@ -76,4 +88,5 @@ import "parallel-agents-vue/style.css";
 - `@saved="(task) => ..."` —— 保存成功（含新建/更新）后回传 `SavedTask`。
 - `@update:taskId="(id) => ..."` —— 当前任务 id 变化（保存 / 加载历史时）。
 
-> 样式作用域全部包在根类 `.parallel-agents` 下，且**不引入 Tailwind preflight**，不会污染宿主全局样式。
+> 样式作用域全部包在根类 `.parallel-agents` 下，**不依赖 Tailwind**（布局类是面板自带的作用域工具类子集），
+> 不会污染宿主全局样式。
diff --git a/parallel-agents-vue/docs/05-嵌入与深色样式.md b/parallel-agents-vue/docs/05-嵌入与深色样式.md
index c6f22d13..708cc970 100644
--- a/parallel-agents-vue/docs/05-嵌入与深色样式.md
+++ b/parallel-agents-vue/docs/05-嵌入与深色样式.md
@@ -84,15 +84,15 @@ pnpm build:lib
 
 ## PA-EMBED-06 · 不污染宿主全局样式（P0）
 
-**目的**：核对**未引入 Tailwind preflight**（不重置宿主全局标签样式）。
+**目的**：核对面板**不依赖 Tailwind**、不重置宿主全局标签样式（无任何裸标签选择器 / reset）。
 
 **操作步骤**
-1. 在一个有自己样式的宿主页里嵌入面板（页面有 `h1/p/button/ul` 等默认样式）。
+1. 在一个有自己样式、且**没装 Tailwind** 的宿主页里嵌入面板（页面有 `h1/p/button/ul` 等默认样式）。
 
 **预期结果**
-- 嵌入后，宿主页面**自身**的 `h1/p/button/列表/边距` 等样式**不被改变**（没有被 Tailwind 的 reset 抹平）。
-- 面板内部样式正常（不依赖宿主提供 Tailwind）。
-- 类名都在 `.parallel-agents` 作用域下，不与宿主类名冲突。
+- 嵌入后，宿主页面**自身**的 `h1/p/button/列表/边距` 等样式**不被改变**（面板样式无全局 reset、无裸标签规则）。
+- 面板内部样式正常（**不需要宿主提供 Tailwind**；布局类是面板自带的作用域工具类子集）。
+- 所有规则都在 `.parallel-agents` 作用域下，不与宿主类名冲突。
 
 ---
 
diff --git a/parallel-agents-vue/docs/07-使用说明.md b/parallel-agents-vue/docs/07-使用说明.md
index 6a5c2e1d..afe4febb 100644
--- a/parallel-agents-vue/docs/07-使用说明.md
+++ b/parallel-agents-vue/docs/07-使用说明.md
@@ -4,6 +4,14 @@
 `ParallelSeatStrip` / `Avatar` / `MarkdownContent` 都是它的内部子组件，**无需也不要单独引入**）。
 宿主只管把它放进自己的页面 / 抽屉 / 弹窗，并传几个 prop。
 
+> **⚠️ 契约变更（纯展示版）**：面板**不再自带顶部表单与按钮**。
+> - **任务名称 / 简介 / 模型** 全部由宿主通过 props 传入（`taskName` / `brief` 支持 `v-model`）；
+> - **「重新分析 / 保存 / 停止」按钮由宿主自己渲染**，通过模板 ref 调用面板 `defineExpose` 出的
+>   `reanalyze()` / `save()` / `cancel()` 等方法（见 [§六·二](#六二暴露的方法与状态模板-ref)）；
+> - 面板本体只展示「席位状态条 + 并行会话 + 错误提示」。
+>
+> 完整的宿主参考实现见仓库 `src/App.vue`（弹窗里宿主自渲染工具条 + 调用 ref 方法）。
+
 ---
 
 ## 一、要引入的东西（就这两样）
@@ -12,6 +20,8 @@
 2. **样式**：`parallel-agents-vue/style.css`（一次性引入即可，样式作用域全在 `.parallel-agents` 下）
 
 > 依赖说明：`vue ^3.4`（宿主提供，库不打包 vue）；`markdown-it` 已打进库内，无需宿主安装。
+> **无需 Tailwind 或任何 CSS 框架**：布局样式已内置为 `parallel-agents.css` 末尾的「最小工具类子集」
+> （全部作用域在 `.parallel-agents` 下，不污染宿主）。宿主项目**不用**装 / 配 Tailwind。
 
 ---
 
@@ -33,21 +43,32 @@
    import "parallel-agents-vue/style.css";
    ```
 
-### 方式 B：直接拷贝源码（无需发包）
+### 方式 B：直接拷贝源码（无需发包，**推荐给需要改源码的人**）
 
-把本项目 `src/` 下这些拷进宿主项目（保持相对结构），按相对路径引入 `ParallelAgentsPanel.vue` +
-`styles/parallel-agents.css` 即可：
+所有实现已收进**一个自包含文件夹** `src/parallel-agents/`。把**整个文件夹**拷进宿主项目的 `src/`
+下即可，内部全是相对路径引用、不依赖任何构建别名：
 
 ```
-src/
-  components/   ParallelAgentsPanel.vue · MessageBubble.vue · MessageStepsCard.vue
-                ParallelSeatStrip.vue · Avatar.vue · MarkdownContent.vue
-  composables/  useParallelRun.ts
-  lib/          avatar-constants.ts
-  styles/       parallel-agents.css
-  api.ts · config.ts · types.ts
+src/parallel-agents/          ← 整个文件夹拷走即用
+  index.ts                    入口：自动引样式 + 导出组件/类型
+  ParallelAgentsPanel.vue     主组件
+  ParallelSeatStrip.vue · MessageBubble.vue · MessageStepsCard.vue · StepIcon.vue
+  ClarificationCard.vue · MarkdownContent.vue · Avatar.vue   （子组件）
+  useParallelRun.ts           并行运行编排
+  api.ts · types.ts · config.ts · avatar-constants.ts · step-display.ts
+  parallel-agents.css         作用域样式（深色 token + 语义类 + 工具类子集，无 Tailwind）
+  README.md                   本文件夹的速用说明
 ```
+
+引入（样式由 `index.ts` 自动引入，无需手动 import css）：
+
+```ts
+import { ParallelAgentsPanel } from "@/parallel-agents";
+// 或相对路径： import { ParallelAgentsPanel } from "./parallel-agents";
+```
+
 宿主需有 `markdown-it` 依赖（`pnpm add markdown-it`），并保证构建支持 `.vue`（Vite/@vitejs/plugin-vue）。
+**不需要 Tailwind**。
 
 ---
 
@@ -55,8 +76,11 @@ src/
 
 ### 局部引入（推荐）
 
+宿主持有任务名 / 简介 / 模型，并自渲染按钮调用面板暴露的方法：
+
 ```vue
 <script setup lang="ts">
+import { ref } from "vue";
 import { ParallelAgentsPanel } from "parallel-agents-vue";
 import "parallel-agents-vue/style.css";
 
@@ -64,15 +88,43 @@ const agents = [
   { agent_id: "roundtable-solution-design", name: "方案设计" },
   { agent_id: "roundtable-risk-review", name: "风险审查" },
 ];
+
+// 宿主持有这三项（面板不再渲染输入框）
+const taskName = ref("");
+const brief = ref("");
+const model = ref("");
+
+// 模板 ref：拿到面板暴露的方法 / 状态
+const panel = ref<InstanceType<typeof ParallelAgentsPanel> | null>(null);
 </script>
 
 <template>
-  <div style="height: 80vh">
-    <ParallelAgentsPanel :username="'demo'" :agents="agents" />
+  <div style="display: flex; flex-direction: column; height: 80vh">
+    <!-- 宿主自己的工具条 -->
+    <input v-model="taskName" placeholder="任务名称" />
+    <textarea v-model="brief" placeholder="任务简介" />
+    <button :disabled="!panel?.canStart" @click="panel?.reanalyze()">
+      {{ panel?.hasResults ? "重新分析" : "开始分析" }}
+    </button>
+    <button :disabled="panel?.saving || !panel?.hasResults" @click="panel?.save()">保存</button>
+
+    <!-- 面板：纯展示，需父容器给高度 -->
+    <ParallelAgentsPanel
+      ref="panel"
+      style="flex: 1; min-height: 0"
+      :username="'demo'"
+      :agents="agents"
+      v-model:task-name="taskName"
+      v-model:brief="brief"
+      :model="model"
+    />
   </div>
 </template>
 ```
 
+> 面板暴露出的 `running` / `saving` / `hasResults` / `canStart` 等是 ref，**在组件实例上会自动解包**，
+> 模板里直接 `panel?.canStart` 读，**无需 `.value`**。
+
 ### 全局注册（可选）
 
 ```ts
@@ -90,8 +142,20 @@ app.use(ParallelAgentsVue); // 之后任意模板可直接用 <ParallelAgentsPan
 
 ```vue
 <YourDrawer v-model="open" size="large">
-  <div style="height: 86vh">
-    <ParallelAgentsPanel :username="currentUsername" :agents="agents" @saved="onSaved" />
+  <div style="display: flex; flex-direction: column; height: 86vh">
+    <!-- 宿主工具条：任务名/简介/模型 + 按钮，由你自己渲染 -->
+    <MyToolbar v-model:task-name="taskName" v-model:brief="brief"
+               @start="panel?.reanalyze()" @save="panel?.save()" />
+    <ParallelAgentsPanel
+      ref="panel"
+      style="flex: 1; min-height: 0"
+      :username="currentUsername"
+      :agents="agents"
+      v-model:task-name="taskName"
+      v-model:brief="brief"
+      :model="model"
+      @saved="onSaved"
+    />
   </div>
 </YourDrawer>
 ```
@@ -122,14 +186,66 @@ app.use(ParallelAgentsVue); // 之后任意模板可直接用 <ParallelAgentsPan
 | `getToken`      | `() => string \| Promise<string>`       |      | 动态取 token                                    |
 | `loginPassword` | `string`                                |      | 仅当后端开启口令门时需要                        |
 | `taskId`        | `string`                                |      | 传入则挂载时自动加载并回显该任务                |
-| `model`         | `string`                                |      | 可选模型名（不传走默认 / 后端回退）             |
+| `taskName`      | `string`                                |      | **任务名称（宿主持有）**，支持 `v-model:task-name` |
+| `brief`         | `string`                                |      | **任务简介（宿主持有）**，支持 `v-model:brief`  |
+| `model`         | `string`                                |      | 模型名（宿主持有；空 = 默认 / 后端回退）        |
 | `dark`          | `boolean`（默认 `true`）                |      | 深色面板（自带成色，不依赖宿主主题）            |
 
+> `taskName` / `brief` 用 `v-model` 是为了**回显**：加载已保存任务时，面板会通过 `update:taskName` /
+> `update:brief` 把存档里的标题 / 简介回传给宿主，宿主据此同步自己的输入框。
+
 `AgentInput`/`SavedTask`/`AgentResult` 等类型也从包里导出：
 `import type { AgentInput, SavedTask, AgentResult } from "parallel-agents-vue"`。
 
 ---
 
+## 六·二、暴露的方法与状态（模板 ref）
+
+面板通过 `defineExpose` 暴露下列**方法**与**状态**，供宿主用模板 ref 调用 / 读取。
+拿 ref：`const panel = ref<InstanceType<typeof ParallelAgentsPanel> | null>(null)`，模板 `<ParallelAgentsPanel ref="panel" .../>`。
+
+**方法**
+
+| 方法                  | 等价于            | 说明                                         |
+| --------------------- | ----------------- | -------------------------------------------- |
+| `reanalyze()`         | 旧「重新分析」按钮 | 用当前 `taskName`/`brief`/`model` 开始 / 重跑一轮 |
+| `start()`             | 同 `reanalyze()`  | 别名，语义同上                               |
+| `save()`              | 旧「保存」按钮     | 保存 / 更新当前聊天记录（按 `taskId` upsert）|
+| `cancel()`            | 旧「停止」按钮     | 中止本轮并行运行                             |
+| `loadTask(id)`        | 旧「历史」选择     | 加载并回显某条任务（同时回传标题/简介）      |
+| `refreshHistory()`    | —                 | 重新拉取历史列表（结果在 `history` 里）      |
+| `getResults()`        | —                 | 取所有智能体返回内容 `AgentResult[]`         |
+| `getResult(id)`       | —                 | 取某个智能体返回内容 `AgentResult \| null`   |
+
+**状态（ref，组件实例上自动解包，模板里直接读无需 `.value`）**
+
+| 状态           | 类型             | 说明                                |
+| -------------- | ---------------- | ----------------------------------- |
+| `running`      | `boolean`        | 是否正在并行运行（用于切「停止」按钮）|
+| `saving`       | `boolean`        | 是否正在保存                        |
+| `hasResults`   | `boolean`        | 是否已有结果（「开始」/「重新」文案 & 保存可用）|
+| `canStart`     | `boolean`        | 是否满足开始条件（有 agents + 任务名或简介）|
+| `history`      | `SavedTask[]`    | 已保存任务列表（宿主可自建历史下拉）|
+| `errorMsg`     | `string \| null` | 最近一次错误（面板内也会展示一条）  |
+
+```vue
+<script setup lang="ts">
+const panel = ref<InstanceType<typeof ParallelAgentsPanel> | null>(null);
+// JS 里读 ref 状态要带 .value：
+function onClickStart() {
+  if (panel.value?.canStart) panel.value.reanalyze();
+}
+</script>
+<template>
+  <!-- 模板里自动解包，直接读 -->
+  <button :disabled="!panel?.canStart" @click="panel?.reanalyze()">
+    {{ panel?.hasResults ? "重新分析" : "开始分析" }}
+  </button>
+</template>
+```
+
+---
+
 ## 六·一、每个参数怎么传（逐个举例）
 
 ### `agents`（必填）——「智能体参数」怎么传
@@ -171,11 +287,24 @@ const agents = [
 <ParallelAgentsPanel :get-token="() => authStore.getAccessToken()" :agents="agents" />
 ```
 
-### `model`——指定模型（不传走默认/后端回退；也可在面板右上角下拉切）
+### `model`——指定模型（宿主持有；不传走默认/后端回退）
 
 ```vue
-<ParallelAgentsPanel :model="'deepseek-chat'" :username="'demo'" :agents="agents" />
+<ParallelAgentsPanel :model="model" :username="'demo'" :agents="agents" />
 ```
+> 模型下拉已移到宿主侧：宿主自己渲染下拉（可调后端 `/api/models`），把选中的模型名用 `:model` 传进来。
+
+### `taskName` / `brief`——任务名 / 简介（宿主持有，支持 v-model）
+
+```vue
+<ParallelAgentsPanel
+  v-model:task-name="taskName"
+  v-model:brief="brief"
+  :username="'demo'"
+  :agents="agents"
+/>
+```
+> 用 `v-model` 是为了**回显**：加载已保存任务时面板会把存档标题 / 简介回传给宿主。
 
 ### `dark`——深色（默认 true，自带成色）
 
@@ -208,6 +337,11 @@ const agents: AgentInput[] = [
   { agent_id: "roundtable-risk-review", name: "风险审查" },
 ];
 const taskId = ref("task-001");
+const taskName = ref("");
+const brief = ref("");
+const model = ref("deepseek-chat");
+const panel = ref<InstanceType<typeof ParallelAgentsPanel> | null>(null);
+
 function onSaved(t: SavedTask) {
   console.log("已保存", t.id);
 }
@@ -217,13 +351,26 @@ function onCompleted(results: AgentResult[]) {
 </script>
 
 <template>
-  <div style="height: 86vh">
+  <div style="display: flex; flex-direction: column; height: 86vh">
+    <!-- 宿主工具条 -->
+    <input v-model="taskName" placeholder="任务名称" />
+    <textarea v-model="brief" placeholder="任务简介" />
+    <button v-if="!panel?.running" :disabled="!panel?.canStart" @click="panel?.reanalyze()">
+      {{ panel?.hasResults ? "重新分析" : "开始分析" }}
+    </button>
+    <button v-else @click="panel?.cancel()">停止</button>
+    <button :disabled="panel?.saving || !panel?.hasResults" @click="panel?.save()">保存</button>
+
     <ParallelAgentsPanel
+      ref="panel"
+      style="flex: 1; min-height: 0"
       :base-url="'http://localhost:8001'"
       :username="'demo'"
       :agents="agents"
       :task-id="taskId"
-      :model="'deepseek-chat'"
+      v-model:task-name="taskName"
+      v-model:brief="brief"
+      :model="model"
       :dark="true"
       @saved="onSaved"
       @update:taskId="(id) => (taskId = id)"
@@ -237,9 +384,12 @@ function onCompleted(results: AgentResult[]) {
 
 | 事件              | 载荷               | 触发时机                                |
 | ----------------- | ------------------ | --------------------------------------- |
-| `saved`           | `SavedTask`        | 保存成功（新建或更新）后                |
+| `saved`           | `SavedTask`        | 保存成功（新建或更新）后；**含自动保存** |
 | `update:taskId`   | `string`           | 当前任务 id 变化（保存 / 加载历史时）   |
-| `completed`       | `AgentResult[]`    | 一轮并行分析结束时，回传各智能体返回内容 |
+| `update:taskName` | `string`           | 加载已保存任务回显标题（配合 `v-model:task-name`）|
+| `update:brief`    | `string`           | 加载已保存任务回显简介（配合 `v-model:brief`）|
+| `agent-completed` | `AgentResult`      | **每个**智能体一分析完就回传它单个的结果（各席位各触发一次）|
+| `completed`       | `AgentResult[]`    | 一轮并行分析**全部**结束时，回传所有智能体返回内容 |
 
 ```vue
 <ParallelAgentsPanel
@@ -254,9 +404,22 @@ function onCompleted(results: AgentResult[]) {
 
 ## 七·一、如何获取模型返回的内容
 
-每个智能体（模型）返回的正文是 `AgentResult.content`。两种方式，任选其一：
+每个智能体（模型）返回的正文是 `AgentResult.content`。组件会**自动把结果推给宿主**，无需轮询：
 
-**A. 事件**：监听 `@completed`，一轮分析结束时自动回传 `AgentResult[]`：
+**A·1. 单个完成就推**：监听 `@agent-completed`，**哪个智能体先分析完就先回传哪个**（各触发一次）：
+
+```vue
+<ParallelAgentsPanel
+  :username="'demo'"
+  :agents="agents"
+  @agent-completed="(r) => {
+    // r: { agent_id, name, content, status } —— 单个智能体
+    console.log('完成一个：', r.name, '→', r.content);
+  }"
+/>
+```
+
+**A·2. 全部完成再推一次**：监听 `@completed`，一轮分析**全部**结束时回传 `AgentResult[]`：
 
 ```vue
 <ParallelAgentsPanel
@@ -269,6 +432,8 @@ function onCompleted(results: AgentResult[]) {
 />
 ```
 
+> 两个事件可同时用：`agent-completed` 做「来一个渲染一个」的增量更新，`completed` 做「全部到齐」的汇总。
+
 **B. 方法（模板 ref）**：随时主动取（不必等事件）：
 
 ```vue
@@ -294,14 +459,25 @@ function readOne(id: string) {
 ```
 
 `AgentResult = { agent_id, name, content, status }`，`content` 即该智能体模型返回的正文（Markdown）。
-`defineExpose` 还暴露了 `start()` / `cancel()`，可由宿主代替按钮触发开始 / 停止。
+`status` 取值：`pending | running | done | clarify | error`。**`clarify` = 该智能体在等用户协助
+（待确认），不是已完成**——宿主判断「是否全部完成」时应排除 `clarify`（例如
+`results.every(r => r.status === "done")`），不要把待协助当成 done。
+`defineExpose` 还暴露了 `reanalyze()` / `start()` / `save()` / `cancel()` / `loadTask(id)` 等方法及
+`running` / `saving` / `hasResults` / `canStart` / `history` 等状态，完整清单见 [§六·二](#六二暴露的方法与状态模板-ref)。
 
 ## 七·二、如何保存 + 回显聊天记录
 
-**保存**：面板里点「保存」即把当前整段聊天记录（各智能体气泡 + 步骤条等）存到后端，按用户隔离。
+**保存**：宿主调用 `panel.save()` 即把当前整段聊天记录（各智能体气泡 + 步骤条等）存到后端，按用户隔离。
 传 `:task-id` 时**以它为存储主键**做 upsert（已存在→更新；不存在→用该 id 新建）；不传则首次保存由后端
 生成 id（通过 `@update:taskId` 回传，下次再保存即更新这条）。
 
+> **自动保存**：每轮分析（含单席位重跑）**结束后会自动保存一次**，宿主无需手动点保存也不丢记录；
+> 自动保存同样走 upsert，并照常触发 `saved` / `update:taskId` 事件（首轮会回传新生成的 id）。
+> `panel.save()` 仍保留，供宿主想随时手动存档时调用。
+
+> **进入默认显示最新**：组件挂载时若**没传 `taskId`**，会自动加载并回显**该用户最新的一条**聊天记录
+> （历史按更新时间倒序，取第一条）；传了 `taskId` 则优先回显指定那条。
+
 **回显（两种方式）**：
 
 ```vue
@@ -316,7 +492,20 @@ const taskId = ref<string>("");          // 留空=新任务
 taskId.value = "task-001";               // 改了之后面板自动回显 task-001
 ```
 
-> 方式 2：面板**右上角内置「历史」下拉**——点开选一条历史任务即回显，**无需写任何代码**。
+> 方式 2：**历史下拉已移到宿主侧**（面板不再内置）。宿主读 `panel.history`（`SavedTask[]`）自建下拉，
+> 选中某条时调 `panel.loadTask(id)` 回显；面板会通过 `update:taskName` / `update:brief` 把存档标题 / 简介
+> 回传给宿主，配合 `v-model` 同步宿主自己的输入框。需要刷新列表调 `panel.refreshHistory()`。
+
+```vue
+<template>
+  <!-- 宿主自建历史下拉 -->
+  <select @change="(e) => panel?.loadTask((e.target as HTMLSelectElement).value)">
+    <option v-for="t in panel?.history || []" :key="t.id" :value="t.id">
+      {{ t.title || "未命名任务" }}
+    </option>
+  </select>
+</template>
+```
 
 要点：先**保存过**、再用**同一个 taskId**（或从历史里选）才会有内容回显；没存过的新 id 第一次进去是空白
 （后台会探测一次 `GET /…/{id}` 返回 404，属正常，面板静默处理）。
@@ -325,20 +514,27 @@ taskId.value = "task-001";               // 改了之后面板自动回显 task-
 
 ## 八、交互要点（与圆桌 Step2 一致）
 
-- 输入「任务名称 + 简介」→「开始分析」→ 各智能体**并行**输出。运行期间禁用**写文件**（`write_file`/
-  `str_replace`）与**派活/脚本**（`agent_orchestration`/`bash`，防子智能体模仿总控调度）；检索、查看、
-  `ask_clarification` 等照常 —— 所以**步骤条 / 协作卡片正常显示**，每个智能体只做自己那份分析。
+- 宿主备好「任务名称 + 简介（+ 模型）」props → 调 `panel.reanalyze()` → 各智能体**并行**输出。
+  运行期间禁用**写文件**（`write_file`/`str_replace`）与**派活/脚本**（`agent_orchestration`/`bash`，
+  防子智能体模仿总控调度）；检索、查看、`ask_clarification` 等照常 —— 所以**步骤条 / 协作卡片正常
+  显示**，每个智能体只做自己那份分析。
 - 主区每次只显示**一个**席位的消息列表；**点席位头像切换**要看哪个（单选）。
-- 顶部席位状态条显示每个智能体的进行中 / 完成 / 出错。
-- 操作区右侧有**模型切换**下拉（拉取后端 `/api/models`）；选「默认」则用 `model` prop / 配置 / 后端回退。
-  切换作用于**下一次**「开始分析 / 重新分析」，运行中禁用。
-- 「保存」存档；「历史」里选回**回显**；「重新分析」清空重跑。
+- 顶部席位状态条显示每个智能体的进行中 / 完成 / **待协助** / 出错；待协助数量会单独标「N 待协助」。
+- **用户协助（澄清）**：智能体要澄清时该席位变「待协助」（不是完成），气泡里弹协作卡片。多个智能体
+  同时待协助时**可分别点协助、互不阻塞**（协助 A 不会禁用 B/C 的卡片）；提交回答后该席位自动带上
+  补充重跑。
+- **任务名 / 简介 / 模型 / 按钮 / 历史下拉全部在宿主侧**：模型空 = `model` prop / 配置 / 后端回退；
+  模型作用于**下一次**`reanalyze()`。
+- `panel.save()` 存档；`panel.loadTask(id)` 回显；`panel.reanalyze()` 清空重跑；`panel.cancel()` 停止。
+- **每轮分析结束自动保存一次**；挂载时没传 `taskId` 会**默认回显最新一条**记录。
+- 结果自动推给宿主：`@agent-completed`（来一个推一个）+ `@completed`（全部到齐再推一次）。
 
 ---
 
 ## 九、注意事项
 
-- **不会污染宿主全局样式**：库未引入 Tailwind preflight，类名都在 `.parallel-agents` 作用域内。
+- **不会污染宿主全局样式**：**不依赖 Tailwind**，布局类已内置为作用域工具类子集，所有规则都在
+  `.parallel-agents` 下，绝不外泄到宿主页面。
 - **深色自带成色**：面板始终深蓝深色，不随宿主明暗切换（与圆桌 Step2 观感一致）。
 - **跨域**：若宿主与后端不同源，后端需允许该来源的 CORS + 带 `credentials`；登录端点公共且 CSRF 豁免，
   业务请求用 Bearer 头已绕过 CSRF。
diff --git a/parallel-agents-vue/docs/08-开发文档.md b/parallel-agents-vue/docs/08-开发文档.md
index 0cf3cd45..ea547043 100644
--- a/parallel-agents-vue/docs/08-开发文档.md
+++ b/parallel-agents-vue/docs/08-开发文档.md
@@ -23,7 +23,7 @@
 | 框架     | Vue 3（`<script setup>` + Composition API）                       |
 | 构建     | Vite 6（dev app + `build:lib` 组件库双产物）                       |
 | 语言     | TypeScript（`strict` + `noUnusedLocals/Parameters`）              |
-| 样式     | TailwindCSS v4（**仅 utilities，不引 preflight**）+ 作用域 `.pa-*` token |
+| 样式     | **零 CSS 框架**：作用域 `.pa-*` token + 内置「最小工具类子集」（不依赖 Tailwind） |
 | Markdown | `markdown-it`（打进库，宿主无需安装）                              |
 | peer dep | `vue ^3.4`（宿主提供，库不打包 vue）                              |
 
@@ -31,31 +31,35 @@
 
 ## 3. 目录结构与各文件职责
 
+实现全部收在**一个自包含文件夹** `src/parallel-agents/`（内部相对路径引用、不依赖构建别名，
+整个文件夹可直接拷给宿主用）。`src/` 顶层只剩 demo 与库入口。
+
 ```
 src/
-├─ index.ts                  库入口：导出 ParallelAgentsPanel + install 插件 + 类型；import 样式
+├─ index.ts                  库入口：从 ./parallel-agents 再导出 + install 插件
 ├─ main.ts / App.vue         dev demo（仅本地调试用，不进库）
-├─ config.ts                 配置：DEFAULT_BASE_URL / DEFAULT_MODEL / TOKEN_PATH
-├─ types.ts                  共享类型：Dialogue / SeatView / DialogueStep / ClarificationPayload
-│                            / AgentInput / AgentResult / SavedTask / StreamEvent（事件协议）
-├─ api.ts                    后端访问层：鉴权(取 token+缓存+401 重登) / SSE 流 / 任务 CRUD / 模型列表
-├─ composables/
-│  └─ useParallelRun.ts      运行编排（前端态核心）：消费合并 SSE → 维护 dialogues/seats；
-│                            start / cancel / hydrate(回显) / reset / rerunAgent(单席位重跑)
-├─ lib/
-│  ├─ avatar-constants.ts    头像配色 + getAvatarTypeFor（轮转）
-│  └─ step-display.ts        步骤条：getStepDisplay(图标+中文文案) / getStepArgs(参数子节点)
-├─ styles/
-│  └─ parallel-agents.css    作用域深色 token(--pa-*) + .pa-* 语义类 + Markdown 样式（无 preflight）
-└─ components/
-   ├─ ParallelAgentsPanel.vue 主组件：输入区/操作区/模型切换/历史/席位条/会话区 + 全部状态编排
-   ├─ ParallelSeatStrip.vue   席位状态条（头像 + running/done/error 角标，点击切换单显）
+└─ parallel-agents/          ← 自包含组件文件夹（拷走即用）
+   ├─ index.ts               文件夹入口：import 样式 + 导出组件/类型
+   ├─ config.ts              配置：DEFAULT_BASE_URL / DEFAULT_MODEL / TOKEN_PATH
+   ├─ types.ts               共享类型：Dialogue / SeatView / SeatStatus / DialogueStep /
+   │                         ClarificationPayload / AgentInput / AgentResult / SavedTask / StreamEvent
+   ├─ api.ts                 后端访问层：鉴权(取 token+缓存+401 重登) / SSE 流 / 任务 CRUD / 模型列表
+   ├─ useParallelRun.ts      运行编排（前端态核心）：消费合并 SSE → 维护 dialogues/seats/busy；
+   │                         start / cancel / hydrate(回显) / reset / rerunAgent(单席位重跑，可并发协助)
+   ├─ avatar-constants.ts    头像配色 + getAvatarTypeFor（轮转）
+   ├─ step-display.ts        步骤条：getStepDisplay(图标+中文文案) / getStepArgs(参数子节点)
+   ├─ parallel-agents.css    作用域深色 token(--pa-*) + .pa-* 语义类 + Markdown 样式 + 工具类子集（无 Tailwind）
+   ├─ ParallelAgentsPanel.vue 主组件：席位条/会话区 + 全部状态编排（表单/按钮在宿主侧）
+   ├─ ParallelSeatStrip.vue   席位状态条（头像 + running/done/clarify/error 角标，点击切换单显）
+   ├─ AutoScrollPane.vue      自动下滑滚动窗格：包住单席位消息，超高出滚动条 + 流式自动钉底 +
+   │                          用户滚动暂停 + 半透明「自动滚动」浮动按钮（每席位一实例，互不影响）
    ├─ MessageBubble.vue       单条气泡：头像/发言人/徽标/时间/步骤条/正文/光标/协作卡片
    ├─ MessageStepsCard.vue    步骤条（ChainOfThought 结构，1:1 对齐 Step2）
    ├─ StepIcon.vue            步骤图标（lucide 风格 inline SVG，按 IconKey）
    ├─ ClarificationCard.vue   协作 / 澄清卡片（1:1 对齐圆桌第一步 IntentClarificationCard）
    ├─ MarkdownContent.vue     markdown-it 渲染
-   └─ Avatar.vue              机器人 / 真人 SVG 头像
+   ├─ Avatar.vue              机器人 / 真人 SVG 头像
+   └─ README.md               文件夹速用说明
 ```
 
 ---
@@ -98,7 +102,7 @@ panel emit "completed"(AgentResult[])；可点「保存」(按 taskId upsert) /
 | `agent_start`         | `agent_id`                                                                                    | 该席位置 running                  |
 | `delta`               | `agent_id, text`                                                                              | 追加正文（节流）                  |
 | `step`                | `agent_id, key(=`tool_calling:<tool>`), label, args`                                          | 步骤条加一步（含完整 args）        |
-| `agent_clarification` | `agent_id, content, question, clarification_type, clarification_context, options, allow_*`    | 设 `dialogue.clarification` → 卡片 |
+| `agent_clarification` | `agent_id, content, question, clarification_type, clarification_context, options, allow_*`    | 设 `dialogue.clarification` → 卡片；席位置 **clarify**（待协助，非 done）。澄清卡片**任何时候都可点**（即便整批仍在跑），用户答完 → `panel.onClarify` → `rerunAgent` 重跑该席位 |
 | `agent_done`          | `agent_id, content`                                                                           | 收口，正文以终态为准              |
 | `agent_error`         | `agent_id, message`                                                                           | 该席位置 error                    |
 | `all_done`            | —                                                                                             | 全部结束                          |
@@ -106,9 +110,10 @@ panel emit "completed"(AgentResult[])；可点「保存」(按 taskId upsert) /
 **核心数据模型**（`types.ts`）：
 - `Dialogue { id, agentId, sender, avatarType, content, time, confidence, streaming?, steps?, clarification? }`
 - `DialogueStep { id, key, label, ts, args? }`（`key` 形如 `tool_calling:web_search`）
-- `SeatView { agentId, name, avatarType, status: pending|running|done|error, bubbleId }`
+- `SeatView { agentId, name, avatarType, status: SeatStatus, bubbleId }`
+- `SeatStatus = pending | running | done | clarify | error`（**`clarify` = 待用户协助，非完成**）
 - `ClarificationPayload { question, clarificationType, context, options, allowCustom, allowMultiple }`
-- `AgentResult { agent_id, name, content, status }`（宿主读取用）
+- `AgentResult { agent_id, name, content, status }`（宿主读取用；`status` 同 `SeatStatus`）
 
 > 改协议时：`types.ts` 的 `StreamEvent` 与后端 `parallel_agents.py` 的事件 dict **必须同步**。
 
@@ -119,17 +124,30 @@ panel emit "completed"(AgentResult[])；可点「保存」(按 taskId upsert) /
 ```
 ParallelAgentsPanel
 ├─ ParallelSeatStrip ── Avatar           (席位条，点头像切换单显)
-└─ MessageBubble (当前选中席位)
-   ├─ Avatar
-   ├─ MessageStepsCard ── StepIcon        (步骤条；getStepDisplay/getStepArgs 翻译 key+args)
-   ├─ MarkdownContent                      (markdown-it)
-   └─ ClarificationCard                    (msg.clarification 存在时；提交→panel.onClarify→rerunAgent)
+└─ AutoScrollPane (当前选中席位；限高滚动 + 流式自动下滑 + 浮动「自动滚动」按钮)
+   └─ MessageBubble
+      ├─ Avatar
+      ├─ MessageStepsCard ── StepIcon     (步骤条；getStepDisplay/getStepArgs 翻译 key+args)
+      ├─ MarkdownContent                   (markdown-it)
+      └─ ClarificationCard                 (msg.clarification 存在时；提交→panel.onClarify→rerunAgent)
 ```
 
+> **自动下滑 / 高度自适应**（`AutoScrollPane.vue`）：会话区只负责限高（`min-h-0 flex-1 overflow-hidden`），
+> 真正的滚动与自动下滑下放到**每个席位卡片内部**的窗格 —— 父元素不够高时窗格内出现滚动条；模型流式输出时
+> 用 `ResizeObserver` 监听内容增高并钉到底部；用户向上滚动（离开底部）即暂停自动下滑、滚回底部自动恢复；
+> 暂停且内容可滚动时底部居中浮出半透明「自动滚动」按钮（`.pa-autoscroll-btn`），点击恢复并滚到底。
+> 每个席位各一个实例（`v-for :key=agentId`），autoScroll / 滚动位置都在实例内，**多智能体互不影响**。
+> 席位卡片靠 `.pa-rows-fill`（`grid-auto-rows: minmax(0,1fr)`）受限于会话区高度，从而内部滚动而非撑破容器。
+
 `ParallelAgentsPanel` 的对外接口（详见 [07-使用说明.md](./07-使用说明.md)）：
 - props：`agents`(必填) / `username` / `baseUrl` / `token` / `getToken` / `taskId` / `model` / `dark`
-- emits：`saved(SavedTask)` / `update:taskId(string)` / `completed(AgentResult[])`
-- `defineExpose`：`getResults()` / `getResult(id)` / `start()` / `cancel()`
+- emits：
+  - `agent-completed(AgentReply)` —— **单个**智能体**真正完成（done）**时各触发一次；`AgentReply = {agent_id, name, content}`
+    （智能体名称 + 模型返回结果，**不含 status**）。待用户协助（clarify）/ 出错（error）**不触发**。
+  - `completed(AgentReply[])` —— **所有**智能体都完成（done/error、**没有任何 clarify 在等用户**）后，整批触发一次；
+    若有席位在等用户协助，本轮不发，待其答完重跑完成后再发。
+  - `saved(SavedTask)` / `update:taskId(string)` / `update:taskName(string)` / `update:brief(string)`
+- `defineExpose`：`getResults()`(返回 `AgentResult[]`，含 status) / `getResult(id)` / `start()` / `reanalyze()` / `save()` / `cancel()` / `loadTask(id)`
 
 ---
 
@@ -159,21 +177,32 @@ ParallelAgentsPanel
 **后端运行策略（重要）**：每个并行席位是「执行席位」，不是总控。
 - **禁用工具** `_EXCLUDED_TOOLS = [write_file, str_replace, agent_orchestration, bash]`：①禁写文件（并行
   不互相打架）；②禁 `agent_orchestration`/`bash`（防弱模型模仿总控**派活**或绕道脚本逃逸）。
-- **保留** 只读 / 检索工具 + `ask_clarification` → 步骤条、协作卡片正常。
+- **保留** 只读 / 检索工具 + `ask_clarification` → 步骤条、协作卡片正常（**用户协助开启**）。
 - 任务消息带**角色边界护栏**（「执行席位、不要模仿总控调度 / 派活」）。
 - 步骤 `args` 通过累积 `tool_call_chunks` + 终态全量 `tool_calls` 补全（流式期间空 args 不发，防钉死）。
 - `ask_clarification` 从终态 messages 抽成结构化 `agent_clarification` 事件。
 
+**前端澄清（用户协助）交互要点**（`useParallelRun` / `ClarificationCard` / `ParallelAgentsPanel`）：
+- 协作卡片**不再因 `submitting` 禁用**：整批仍在跑时也能立刻回答某个已澄清的席位。
+- `rerunAgent` 放开了「整批 running 时禁止重跑」的限制（澄清是该席位合并流里的终态，不会再抢气泡），
+  只拦同一席位的并发重跑；收尾循环（`start` 的 finally）**跳过 busy 席位**，交给 `rerunAgent` 自己结算。
+- 答澄清后**不立刻清空**正文/步骤：先移除卡片、置流式并标记 `rerunPending`，等重跑产出**第一条新事件**
+  时（`maybeStartRerun`）再清空替换，避免单选视图整列空白闪烁。
+- 「单席位结算回传」`onAgentSettled`：**`clarify` 不回传**（待用户协助≠模型完成），等重跑出 `done/error` 再回传。
+
 ---
 
 ## 9. 样式系统（嵌入安全）
 
-`styles/parallel-agents.css`：
-- **不引 Tailwind preflight**（`@import "tailwindcss/theme.css"` + `utilities.css`），避免重置宿主全局样式。
+`parallel-agents.css`（**零依赖、不再用 Tailwind**）：
 - 颜色全用作用域内的 `--pa-*` 深蓝 token（取自《深蓝 UI 规范》，与圆桌 Step2 深色一致），全部包在
   根类 `.parallel-agents` 下，**不污染宿主**。
 - 语义类 `.pa-card / .pa-surface / .pa-border / .pa-text(-muted/-primary) / .pa-input / .pa-btn-* /
-  .pa-badge / .pa-md(Markdown)` —— 组件**上色用这些类**，布局用 Tailwind 工具类。
+  .pa-badge / .pa-dot-*(席位角标，含 .pa-dot-clarify) / .pa-md(Markdown)` —— 组件**上色用这些类**。
+- 布局用文件**末尾的「最小工具类子集」**（`flex` / `gap-*` / `rounded-*` / `text-[11px]` /
+  `lg:grid-cols-2` 等，模板用到的逐条手写成纯 CSS）。它包在 `@layer pa-utilities` 里，所以无层级的
+  `.pa-*` 语义类在同属性冲突时**仍压过**工具类（复刻原先 Tailwind-utilities-在-layer 的优先级）。
+  **维护**：模板新增布局类时，在该子集补一条对应规则即可（或写组件 scoped `<style>`）。
 - 面板**自带深色成色**，不随宿主明暗变化；根元素 `h-full w-full flex flex-col min-h-0` 自适应容器。
 
 ---
@@ -181,7 +210,7 @@ ParallelAgentsPanel
 ## 10. 步骤条 / 协作卡片（与圆桌的对应）
 
 - **步骤条** `MessageStepsCard.vue` ← 圆桌 `MessageStepsCard.tsx` + `ChainOfThought`：图标列(带竖向连接线)
-  + 中文文案 + 时间 + 参数子节点。文案/图标映射在 `lib/step-display.ts`（`getStepDisplay`），参数子节点
+  + 中文文案 + 时间 + 参数子节点。文案/图标映射在 `step-display.ts`（`getStepDisplay`），参数子节点
   在 `getStepArgs`（chip / code / text / kv）。加新工具图标：在 `step-display.ts` 的 switch + `StepIcon.vue`
   各加一条。
 - **协作卡片** `ClarificationCard.vue` ← 圆桌第一步 `IntentClarificationCard.tsx`：标题/类型标签/背景/选项
@@ -208,10 +237,12 @@ pnpm build:lib    # 组件库：dist/parallel-agents-vue.{js,umd.cjs,css}
 | 需求                         | 改哪里                                                                                  |
 | ---------------------------- | --------------------------------------------------------------------------------------- |
 | 新增一个 SSE 事件类型        | `types.ts` 的 `StreamEvent` + `useParallelRun.handleEvent` + 后端 `parallel_agents.py`  |
-| 步骤条支持新工具的图标/文案  | `lib/step-display.ts`（`getStepDisplay`/`getStepArgs`）+ `StepIcon.vue`                  |
-| 改深色配色 / 加浅色主题      | `styles/parallel-agents.css` 的 `--pa-*`（浅色可在 `.parallel-agents--light` 下覆盖）   |
+| 步骤条支持新工具的图标/文案  | `step-display.ts`（`getStepDisplay`/`getStepArgs`）+ `StepIcon.vue`                      |
+| 改深色配色 / 加浅色主题      | `parallel-agents.css` 的 `--pa-*`（浅色可在 `.parallel-agents--light` 下覆盖）          |
+| 改布局类 / 加新工具类        | `parallel-agents.css` 末尾的「工具类子集」补规则，或组件 scoped `<style>`（不要装 Tailwind） |
 | 改默认后端地址 / 模型        | `config.ts`（`DEFAULT_BASE_URL` / `DEFAULT_MODEL`）                                     |
 | 多席位并排显示（取消单选）   | `ParallelAgentsPanel.vue` 的 `selected` / `visibleSeats` / `toggleSeat` 逻辑            |
+| 改自动下滑 / 浮动按钮行为     | `AutoScrollPane.vue`（`BOTTOM_TOLERANCE` 容差 / `onScroll` 暂停恢复逻辑）+ `.pa-autoscroll-btn` 样式 |
 | 宿主自定义存储（不走后端）   | 用 `@completed` + `getResults()` 取数据，自行存；不调用 `createTask/updateTask`         |
 | 改鉴权方式                   | `api.ts` 的 `resolveToken` / `loginByUsername` / `authedFetch` + `config.ts` 的 `TOKEN_PATH` |
 
@@ -221,6 +252,8 @@ pnpm build:lib    # 组件库：dist/parallel-agents-vue.{js,umd.cjs,css}
 
 - **agent_id 必须真实**（后端注册过的 id），只填名字不行；可用 id 见 [06-可用智能体清单.md](./06-可用智能体清单.md)。
 - 并行席位**禁派活/脚本/写文件**：本面板里每个智能体只做自己那份分析，产出走正文。
+- **用户协助（澄清）已启用**：`ask_clarification` 保留；席位信息不足时可弹协作卡片。卡片任何时候都可点
+  （含整批仍在跑时），用户答完即重跑该席位；待协助（clarify）不算完成、不回传给宿主。
 - 协作卡片回答是**重跑单个智能体**（新线程 + 把回答拼进任务），不是 LangGraph 原地 resume。
 - token 取自公共端点（无门槛旁路）—— 适合内网；若网关要暴露公网，建议给取 token 端点加共享密钥校验。
 - 跨域：宿主与后端不同源时，后端需放开该来源 CORS + `credentials`。
diff --git a/parallel-agents-vue/package.json b/parallel-agents-vue/package.json
index c7aef0fc..cb5ca0b7 100644
--- a/parallel-agents-vue/package.json
+++ b/parallel-agents-vue/package.json
@@ -29,10 +29,8 @@
     "markdown-it": "^14.1.0"
   },
   "devDependencies": {
-    "@tailwindcss/vite": "^4.1.0",
     "@types/markdown-it": "^14.1.2",
     "@vitejs/plugin-vue": "^5.2.0",
-    "tailwindcss": "^4.1.0",
     "typescript": "^5.6.0",
     "vite": "^6.0.0",
     "vue": "^3.5.0",
diff --git a/parallel-agents-vue/src/App.vue b/parallel-agents-vue/src/App.vue
index 6422be50..4e910f28 100644
--- a/parallel-agents-vue/src/App.vue
+++ b/parallel-agents-vue/src/App.vue
@@ -1,10 +1,15 @@
 <script setup lang="ts">
-/** Dev demo 调试页：填后端地址 / token / 智能体 id，把面板塞进一个弹窗，验证嵌入与流式。 */
+/**
+ * Dev demo 调试页：填后端地址 / token / 智能体 id，把面板塞进一个弹窗，验证嵌入与流式。
+ *
+ * 同时作为「新契约」的参考实现：任务名 / 简介 / 模型由宿主持有并通过 props 传入，
+ * 「重新分析 / 保存 / 停止」等按钮由宿主渲染，通过模板 ref 调用面板 expose 出的方法。
+ */
 import { reactive, ref } from "vue";
-import ParallelAgentsPanel from "./components/ParallelAgentsPanel.vue";
-import type { AgentInput, AgentResult } from "./types";
+import { ParallelAgentsPanel } from "./parallel-agents";
+import type { AgentInput, AgentReply } from "./parallel-agents";
 
-import { DEFAULT_BASE_URL } from "./config";
+import { DEFAULT_BASE_URL } from "./parallel-agents/config";
 
 const cfg = reactive({
   baseUrl: localStorage.getItem("pa.baseUrl") || DEFAULT_BASE_URL,
@@ -16,13 +21,24 @@ const cfg = reactive({
 const open = ref(false);
 const agents = ref<AgentInput[]>([]);
 
+// 宿主持有：任务名 / 简介 / 模型（面板不再渲染这些输入）。
+const taskName = ref(localStorage.getItem("pa.taskName") || "");
+const brief = ref(localStorage.getItem("pa.brief") || "");
+const model = ref(localStorage.getItem("pa.model") || "");
+
+// 模板 ref：拿到面板暴露的方法 / 状态。
+const panel = ref<InstanceType<typeof ParallelAgentsPanel> | null>(null);
+
 // 面板保存 / 生成 id 时回填，方便复制下来下次填进去测「按 taskId 回显」。
 function onTaskId(id: string) {
   cfg.taskId = id;
   localStorage.setItem("pa.taskId", id);
 }
-function onCompleted(results: AgentResult[]) {
-  console.log("[demo] completed → 各智能体返回内容:", results);
+function onAgentCompleted(result: AgentReply) {
+  console.log("[demo] agent-completed → 某智能体分析完:", result.name, result.content);
+}
+function onCompleted(results: AgentReply[]) {
+  console.log("[demo] completed → 全部分析完，各智能体返回内容:", results);
 }
 
 function parseAgents(): AgentInput[] {
@@ -68,21 +84,74 @@ function launch() {
       </button>
     </div>
 
-    <!-- 模拟宿主弹窗：面板自适应容器 -->
+    <!-- 模拟宿主弹窗：宿主自己渲染「任务名 / 简介 / 模型 + 按钮」，面板只展示会话 -->
     <div
       v-if="open"
       style="position: fixed; inset: 0; background: rgba(0,0,0,0.5); display: flex; align-items: center; justify-content: center; z-index: 50"
       @click.self="open = false"
     >
-      <div style="width: 92vw; max-width: 1080px; height: 86vh; border-radius: 12px; overflow: hidden; box-shadow: 0 20px 60px rgba(0,0,0,0.5)">
-        <ParallelAgentsPanel
-          :base-url="cfg.baseUrl"
-          :username="cfg.username || undefined"
-          :task-id="cfg.taskId || undefined"
-          :agents="agents"
-          @update:taskId="onTaskId"
-          @completed="onCompleted"
-        />
+      <div style="width: 92vw; max-width: 1080px; height: 86vh; border-radius: 12px; overflow: hidden; box-shadow: 0 20px 60px rgba(0,0,0,0.5); display: flex; flex-direction: column; background: #0d1526">
+        <!-- 宿主工具条：这部分原来在面板内，现在由宿主自己掌控 -->
+        <div style="display: flex; flex-direction: column; gap: 8px; padding: 12px 16px; border-bottom: 1px solid #1e2d4d">
+          <input
+            v-model="taskName"
+            placeholder="任务名称"
+            style="padding: 6px 10px; background: #111c33; color: #e5edf7; border: 1px solid #2d4473; border-radius: 6px"
+          />
+          <textarea
+            v-model="brief"
+            rows="2"
+            placeholder="任务简介：把背景、目标、约束写清楚"
+            style="padding: 6px 10px; background: #111c33; color: #e5edf7; border: 1px solid #2d4473; border-radius: 6px; resize: vertical"
+          />
+          <div style="display: flex; flex-wrap: wrap; align-items: center; gap: 8px">
+            <!-- expose 出的 ref 在组件实例上会自动解包，直接读，无需 .value -->
+            <button
+              v-if="!panel?.running"
+              :disabled="!panel?.canStart"
+              @click="panel?.reanalyze()"
+              style="padding: 6px 14px; background: #1677ff; color: #fff; border: 0; border-radius: 6px; cursor: pointer"
+            >
+              {{ panel?.hasResults ? "重新分析" : "开始分析" }}
+            </button>
+            <button
+              v-else
+              @click="panel?.cancel()"
+              style="padding: 6px 14px; background: #2d4473; color: #e5edf7; border: 0; border-radius: 6px; cursor: pointer"
+            >
+              停止
+            </button>
+            <button
+              :disabled="panel?.saving || !panel?.hasResults"
+              @click="panel?.save()"
+              style="padding: 6px 14px; background: #2d4473; color: #e5edf7; border: 0; border-radius: 6px; cursor: pointer"
+            >
+              {{ panel?.saving ? "保存中…" : cfg.taskId ? "更新保存" : "保存" }}
+            </button>
+            <input
+              v-model="model"
+              placeholder="模型（留空=默认）"
+              style="margin-left: auto; width: 200px; padding: 6px 10px; background: #111c33; color: #e5edf7; border: 1px solid #2d4473; border-radius: 6px"
+            />
+          </div>
+        </div>
+
+        <!-- 面板：自适应容器，纯展示会话 -->
+        <div style="flex: 1; min-height: 0">
+          <ParallelAgentsPanel
+            ref="panel"
+            :base-url="cfg.baseUrl"
+            :username="cfg.username || undefined"
+            :task-id="cfg.taskId || undefined"
+            v-model:task-name="taskName"
+            v-model:brief="brief"
+            :model="model"
+            :agents="agents"
+            @update:taskId="onTaskId"
+            @agent-completed="onAgentCompleted"
+            @completed="onCompleted"
+          />
+        </div>
       </div>
     </div>
   </div>
diff --git a/parallel-agents-vue/src/components/ParallelAgentsPanel.vue b/parallel-agents-vue/src/components/ParallelAgentsPanel.vue
deleted file mode 100644
index 0e4cfe3c..00000000
--- a/parallel-agents-vue/src/components/ParallelAgentsPanel.vue
+++ /dev/null
@@ -1,375 +0,0 @@
-<script setup lang="ts">
-/**
- * 并行多智能体面板（主组件，可嵌入）。
- *
- * 输入「任务名称 + 简介」，并行调用宿主传入的多个智能体（后端固定禁写文件），消息列表
- * 照搬圆桌 Step2 并行多席位的深色样式与结构（步骤条 / 并行双列 / 席位状态条），支持保存
- * 聊天记录 + 回显 + 重新分析。
- *
- * 自适应容器：根元素 `h-full w-full flex flex-col min-h-0`，宿主直接塞进抽屉 / 弹窗即可。
- */
-import { computed, onMounted, reactive, ref, watch } from "vue";
-import type { AgentInput, AgentResult, Dialogue, SavedTask, SeatView } from "@/types";
-import { useParallelRun } from "@/composables/useParallelRun";
-import { createTask, getTask, listModels, listTasks, updateTask, type ApiConfig, type ModelItem } from "@/api";
-import { DEFAULT_BASE_URL, DEFAULT_MODEL } from "@/config";
-import ParallelSeatStrip from "./ParallelSeatStrip.vue";
-import MessageBubble from "./MessageBubble.vue";
-
-const props = withDefaults(
-  defineProps<{
-    /** 后端地址；不传用配置文件默认（config.ts 的 DEFAULT_BASE_URL）。 */
-    baseUrl?: string;
-    /** 已有 token（Bearer），与 username 二选一；都不传走配置默认地址 + 免密登录失败提示。 */
-    token?: string;
-    getToken?: () => string | Promise<string>;
-    /** 免密自动登录用户名（由宿主自己传）。不传 token 时用它登录换 token。 */
-    username?: string;
-    /** 仅当后端开启口令门时需要。 */
-    loginPassword?: string;
-    agents: AgentInput[];
-    taskId?: string;
-    model?: string;
-    dark?: boolean;
-  }>(),
-  { dark: true },
-);
-
-const emit = defineEmits<{
-  (e: "saved", task: SavedTask): void;
-  (e: "update:taskId", id: string): void;
-  /** 一轮并行分析结束时回传各智能体的返回内容。 */
-  (e: "completed", results: AgentResult[]): void;
-}>();
-
-const cfg = computed<ApiConfig>(() => ({
-  baseUrl: props.baseUrl || DEFAULT_BASE_URL,
-  token: props.token,
-  getToken: props.getToken,
-  username: props.username,
-  loginPassword: props.loginPassword,
-}));
-
-const run = useParallelRun();
-const { dialogues, seats, running } = run;
-
-const form = reactive({ taskName: "", brief: "" });
-const currentTaskId = ref<string | null>(props.taskId ?? null);
-const selected = ref<string[]>([]);
-const saving = ref(false);
-const history = ref<SavedTask[]>([]);
-const showHistory = ref(false);
-const errorMsg = ref<string | null>(null);
-
-// 模型切换：拉后端模型列表，空字符串 = 用默认（prop/config/后端回退）。
-const models = ref<ModelItem[]>([]);
-const selectedModel = ref<string>(props.model ?? DEFAULT_MODEL ?? "");
-
-const dialogueById = computed(() => {
-  const m = new Map<number, Dialogue>();
-  for (const d of dialogues.value) m.set(d.id, d);
-  return m;
-});
-
-const hasResults = computed(() => dialogues.value.length > 0);
-const canStart = computed(
-  () => !running.value && props.agents.length > 0 && (form.taskName.trim() || form.brief.trim()),
-);
-
-// 单选：主区每次只显示**一个**席位的消息列表，点头像切换。
-watch(
-  seats,
-  (s) => {
-    if (!s.length) {
-      selected.value = [];
-      return;
-    }
-    // 保留仍存在的当前选中；首次 / 失效时默认显示第 1 个席位。
-    const cur = selected.value[0];
-    const keep = cur && s.some((x) => x.agentId === cur) ? cur : s[0].agentId;
-    selected.value = [keep];
-  },
-  { immediate: true },
-);
-
-// 宿主传入 / 改变 taskId：作为存储主键，并尝试加载回显该任务（不存在则只设 id）。
-watch(
-  () => props.taskId,
-  (id) => {
-    currentTaskId.value = id ?? null;
-    if (id) void loadTask(id);
-  },
-);
-
-/** 点头像切换显示：单选，始终切到点击的那个席位。 */
-function toggleSeat(agentId: string) {
-  selected.value = [agentId];
-}
-
-const visibleSeats = computed(() => {
-  const id = selected.value[0] ?? seats.value[0]?.agentId;
-  const seat = seats.value.find((s) => s.agentId === id);
-  return seat ? [seat] : [];
-});
-
-// ── 给宿主读取「每个智能体模型返回的内容」的简单方法 ──────────────────────────
-function _statusOf(agentId: string, streaming?: boolean): SeatView["status"] {
-  return seats.value.find((s) => s.agentId === agentId)?.status ?? (streaming ? "running" : "done");
-}
-/** 取所有智能体的返回内容（按席位顺序）。宿主：`panelRef.value.getResults()`。 */
-function getResults(): AgentResult[] {
-  return dialogues.value.map((d) => ({
-    agent_id: d.agentId,
-    name: d.sender,
-    content: d.content,
-    status: _statusOf(d.agentId, d.streaming),
-  }));
-}
-/** 取某个智能体的返回内容；不存在返回 null。 */
-function getResult(agentId: string): AgentResult | null {
-  return getResults().find((r) => r.agent_id === agentId) ?? null;
-}
-// 模板 ref 用：`<ParallelAgentsPanel ref="panelRef" />` → panelRef.value.getResults()
-defineExpose({ getResults, getResult, start: () => onStart(), cancel: () => run.cancel() });
-
-/** 用户在某智能体的协作卡片里提交了回答 → 带上回答重跑该智能体。 */
-async function onClarify(agentId: string, answer: string) {
-  errorMsg.value = null;
-  const brief = `${form.brief}\n\n【用户补充】${answer}`.trim();
-  try {
-    await run.rerunAgent(cfg.value, {
-      taskName: form.taskName,
-      brief,
-      agentId,
-      model: selectedModel.value || undefined,
-    });
-    emit("completed", getResults());
-  } catch (err) {
-    errorMsg.value = err instanceof Error ? err.message : String(err);
-  }
-}
-
-async function onStart() {
-  if (!canStart.value) return;
-  errorMsg.value = null;
-  try {
-    await run.start(cfg.value, {
-      taskName: form.taskName,
-      brief: form.brief,
-      agents: props.agents,
-      model: selectedModel.value || undefined,
-    });
-    // 一轮结束：回传各智能体返回内容（宿主也可用 ref 调 getResults()）。
-    emit("completed", getResults());
-  } catch (err) {
-    errorMsg.value = err instanceof Error ? err.message : String(err);
-  }
-}
-
-async function onSave() {
-  if (saving.value || !hasResults.value) return;
-  saving.value = true;
-  errorMsg.value = null;
-  try {
-    const title = form.taskName.trim() || "未命名任务";
-    const agentsSnapshot: AgentInput[] = props.agents.map((a) => ({ ...a }));
-    const payload = { title, brief: form.brief, agents: agentsSnapshot, messages: dialogues.value };
-    // 按宿主传入的 taskId **upsert**：有 id 先更新，不存在（404）再用该 id 创建；无 id 则新建。
-    let saved: SavedTask | null;
-    const id = currentTaskId.value;
-    if (id) {
-      saved = await updateTask(cfg.value, id, payload);
-      if (!saved) saved = await createTask(cfg.value, { id, ...payload });
-    } else {
-      saved = await createTask(cfg.value, payload);
-    }
-    if (saved) {
-      currentTaskId.value = saved.id;
-      emit("update:taskId", saved.id);
-      emit("saved", saved);
-      await refreshHistory();
-    }
-  } catch (err) {
-    errorMsg.value = err instanceof Error ? err.message : String(err);
-  } finally {
-    saving.value = false;
-  }
-}
-
-async function refreshHistory() {
-  try {
-    history.value = await listTasks(cfg.value);
-  } catch {
-    /* 历史拉取失败不阻断主流程 */
-  }
-}
-
-async function loadTask(id: string) {
-  showHistory.value = false;
-  errorMsg.value = null;
-  try {
-    const task = await getTask(cfg.value, id);
-    if (!task) return;
-    currentTaskId.value = task.id;
-    form.taskName = task.title ?? "";
-    form.brief = task.brief ?? "";
-    selected.value = [];
-    run.hydrate(task.messages ?? []);
-    emit("update:taskId", task.id);
-  } catch (err) {
-    errorMsg.value = err instanceof Error ? err.message : String(err);
-  }
-}
-
-async function refreshModels() {
-  const list = await listModels(cfg.value);
-  models.value = list;
-  // 当前选择不在列表里（且非空）时，回退为默认（空 = 后端回退）。
-  if (selectedModel.value && !list.some((m) => m.name === selectedModel.value)) {
-    selectedModel.value = "";
-  }
-}
-
-onMounted(() => {
-  void refreshHistory();
-  void refreshModels();
-  if (props.taskId) void loadTask(props.taskId);
-});
-</script>
-
-<template>
-  <div
-    class="parallel-agents pa-bg flex h-full w-full min-h-0 flex-col"
-    :class="dark ? 'parallel-agents--dark' : ''"
-  >
-    <!-- 顶部：任务名 + 操作 -->
-    <div class="pa-border flex shrink-0 flex-col gap-2 border-b px-4 py-3">
-      <div class="flex items-center gap-2">
-        <input
-          v-model="form.taskName"
-          class="pa-input min-w-0 flex-1 px-3 py-1.5 text-sm"
-          placeholder="任务名称"
-        />
-        <div class="relative shrink-0">
-          <button
-            type="button"
-            class="pa-btn-ghost px-2.5 py-1.5 text-xs"
-            @click="showHistory = !showHistory"
-          >
-            历史 ▾
-          </button>
-          <div
-            v-if="showHistory"
-            class="pa-card pa-border absolute right-0 z-20 mt-1 max-h-72 w-72 overflow-auto rounded-lg border p-1 shadow-lg"
-          >
-            <div v-if="!history.length" class="px-3 py-4 text-center text-xs pa-text-muted">
-              暂无保存的任务
-            </div>
-            <button
-              v-for="t in history"
-              :key="t.id"
-              type="button"
-              class="pa-btn-ghost block w-full truncate px-2.5 py-1.5 text-left text-xs"
-              style="border: 0"
-              @click="loadTask(t.id)"
-            >
-              <span class="font-semibold">{{ t.title || "未命名任务" }}</span>
-              <span class="pa-text-muted"> · {{ (t.updated_at || "").slice(0, 16).replace("T", " ") }}</span>
-            </button>
-          </div>
-        </div>
-      </div>
-      <textarea
-        v-model="form.brief"
-        rows="2"
-        class="pa-input w-full resize-y px-3 py-1.5 text-sm"
-        placeholder="任务简介：把背景、目标、约束写清楚，会并行下发给各智能体"
-      />
-      <div class="flex flex-wrap items-center gap-2">
-        <button
-          v-if="!running"
-          type="button"
-          class="pa-btn-primary px-3.5 py-1.5 text-sm font-semibold"
-          :disabled="!canStart"
-          @click="onStart"
-        >
-          {{ hasResults ? "重新分析" : "开始分析" }}
-        </button>
-        <button
-          v-else
-          type="button"
-          class="pa-btn-ghost px-3.5 py-1.5 text-sm font-semibold"
-          @click="run.cancel()"
-        >
-          停止
-        </button>
-        <button
-          type="button"
-          class="pa-btn-ghost px-3.5 py-1.5 text-sm font-semibold"
-          :disabled="saving || !hasResults"
-          @click="onSave"
-        >
-          {{ saving ? "保存中…" : currentTaskId ? "更新保存" : "保存" }}
-        </button>
-
-        <!-- 模型切换：作用于下一次「开始分析 / 重新分析」 -->
-        <label class="ml-auto flex items-center gap-1.5 text-xs pa-text-muted">
-          模型
-          <select
-            v-model="selectedModel"
-            :disabled="running"
-            class="pa-input px-2 py-1 text-xs"
-            title="选择本次并行分析使用的模型"
-          >
-            <option value="">默认</option>
-            <option v-for="m in models" :key="m.name" :value="m.name">
-              {{ m.display_name || m.name }}
-            </option>
-          </select>
-        </label>
-
-        <span v-if="props.agents.length === 0" class="text-xs pa-text-muted">
-          ⚠️ 未传入任何智能体（agents 为空）
-        </span>
-      </div>
-      <p v-if="errorMsg" class="text-xs" style="color: var(--pa-rose)">{{ errorMsg }}</p>
-    </div>
-
-    <!-- 席位状态条 -->
-    <div v-if="seats.length" class="pa-border shrink-0 border-b px-4">
-      <ParallelSeatStrip :seats="seats" :selected="selected" @toggle="toggleSeat" />
-    </div>
-
-    <!-- 会话区：并行双列 -->
-    <div class="min-h-0 flex-1 overflow-y-auto p-4">
-      <div
-        v-if="hasResults"
-        class="grid gap-4"
-        :class="visibleSeats.length > 1 ? 'grid-cols-1 lg:grid-cols-2' : 'grid-cols-1'"
-      >
-        <div
-          v-for="seat in visibleSeats"
-          :key="seat.agentId"
-          class="pa-surface-soft pa-border flex min-w-0 flex-col rounded-xl border p-3"
-        >
-          <MessageBubble
-            v-if="dialogueById.get(seat.bubbleId)"
-            :msg="dialogueById.get(seat.bubbleId)!"
-            :submitting="running"
-            @clarify="onClarify"
-          />
-          <div v-else class="py-6 text-center text-xs pa-text-muted">
-            {{ seat.name }} · 等待输出…
-          </div>
-        </div>
-      </div>
-      <div
-        v-else
-        class="flex h-full flex-col items-center justify-center gap-2 text-center"
-      >
-        <p class="text-sm pa-text-muted">填写任务名称与简介，点「开始分析」并行调用各智能体。</p>
-        <p class="text-xs pa-text-muted">并行运行期间禁止写文件，产出直接呈现在正文。</p>
-      </div>
-    </div>
-  </div>
-</template>
diff --git a/parallel-agents-vue/src/index.ts b/parallel-agents-vue/src/index.ts
index 010d65c5..d1627e02 100644
--- a/parallel-agents-vue/src/index.ts
+++ b/parallel-agents-vue/src/index.ts
@@ -3,13 +3,24 @@
  *   import { ParallelAgentsPanel } from "parallel-agents-vue";
  *   import "parallel-agents-vue/style.css";
  * 或全局注册：app.use(ParallelAgentsVue)。
+ *
+ * 实现全部收在自包含的 `./parallel-agents/` 文件夹里（含样式，零 Tailwind 依赖）。需要直接拷
+ * 源码的用户，整个 parallel-agents/ 文件夹拷走即用，见该目录下 README.md。
  */
-import "./styles/parallel-agents.css";
 import type { App } from "vue";
-import ParallelAgentsPanel from "./components/ParallelAgentsPanel.vue";
+import { ParallelAgentsPanel } from "./parallel-agents";
 
 export { ParallelAgentsPanel };
-export type { AgentInput, AgentResult, Dialogue, SavedTask, SeatView, StreamEvent } from "./types";
+export type {
+  AgentInput,
+  AgentReply,
+  AgentResult,
+  Dialogue,
+  SavedTask,
+  SeatStatus,
+  SeatView,
+  StreamEvent,
+} from "./parallel-agents";
 
 export default {
   install(app: App) {
diff --git a/parallel-agents-vue/src/main.ts b/parallel-agents-vue/src/main.ts
index 4a05fe35..b670de8b 100644
--- a/parallel-agents-vue/src/main.ts
+++ b/parallel-agents-vue/src/main.ts
@@ -1,5 +1,4 @@
 import { createApp } from "vue";
 import App from "./App.vue";
-import "./styles/parallel-agents.css";
 
 createApp(App).mount("#app");
diff --git a/parallel-agents-vue/src/parallel-agents/AutoScrollPane.vue b/parallel-agents-vue/src/parallel-agents/AutoScrollPane.vue
new file mode 100644
index 00000000..b7dd4e59
--- /dev/null
+++ b/parallel-agents-vue/src/parallel-agents/AutoScrollPane.vue
@@ -0,0 +1,108 @@
+<script setup lang="ts">
+/**
+ * 自动下滑滚动窗格 —— 包住单个席位的消息内容，提供：
+ *  ① 高度自适应：父元素不够高时，内容超出即在**本窗格内**出现滚动条（不撑破容器）。
+ *  ② 流式自动下滑：模型输出（内容变高）时自动钉到底部。
+ *  ③ 用户接管：用户向上滚动离开底部 → 暂停自动下滑；滚回底部 → 自动恢复。
+ *  ④ 暂停且可滚动时，窗格底部居中浮出半透明「自动滚动」按钮，点击恢复并滚到底。
+ *
+ * **每个席位各渲染一个本组件实例**（父级 `v-for :key=agentId`），状态（autoScroll / 滚动位置 /
+ * 观察器）都在实例内，因此多个智能体之间的自动下滑**互不影响**。
+ *
+ * 设计要点：滚动容器（viewport）与浮动按钮是**兄弟**关系，按钮挂在不滚动的 relative 根上，
+ * 所以按钮不会跟着内容一起滚走。自动下滑一律用瞬时跳转（behavior:auto）——既能跟上流式速度，
+ * 又避免平滑滚动过程中的中间帧把 autoScroll 误判成「离开底部」。
+ */
+import { computed, nextTick, onBeforeUnmount, onMounted, ref } from "vue";
+
+/** 判定「已在底部」的容差（px）：避免亚像素/缩放导致永远差 1px 到不了底。 */
+const BOTTOM_TOLERANCE = 24;
+
+const viewport = ref<HTMLElement | null>(null);
+const content = ref<HTMLElement | null>(null);
+
+/** 是否处于「跟随底部」状态（true = 自动下滑开启）。 */
+const autoScroll = ref(true);
+/** 内容是否超出窗格（只有可滚动时浮动按钮才有意义）。 */
+const canScroll = ref(false);
+
+let ro: ResizeObserver | null = null;
+
+function atBottom(el: HTMLElement): boolean {
+  return el.scrollHeight - el.scrollTop - el.clientHeight <= BOTTOM_TOLERANCE;
+}
+
+function scrollToBottom(): void {
+  const el = viewport.value;
+  if (!el) return;
+  // 瞬时跳转：跟上流式、且不产生平滑滚动的中间帧（否则 onScroll 会误判离开底部）。
+  el.scrollTop = el.scrollHeight;
+}
+
+function refreshMetrics(): void {
+  const el = viewport.value;
+  canScroll.value = !!el && el.scrollHeight - el.clientHeight > BOTTOM_TOLERANCE;
+}
+
+/** 用户滚动：到底→跟随，离开底部→暂停。程序化跳到底后这里也会判为到底，故保持开启。 */
+function onScroll(): void {
+  const el = viewport.value;
+  if (!el) return;
+  autoScroll.value = atBottom(el);
+  refreshMetrics();
+}
+
+/** 点击浮动按钮：恢复自动下滑并立即滚到底。 */
+function resume(): void {
+  autoScroll.value = true;
+  scrollToBottom();
+  refreshMetrics();
+}
+
+const showButton = computed(() => canScroll.value && !autoScroll.value);
+
+onMounted(() => {
+  // 首屏（含切到一个已在后台流式的席位）：先钉到底部。
+  void nextTick(() => {
+    scrollToBottom();
+    refreshMetrics();
+  });
+  // 内容高度变化（流式追加正文 / 步骤条 / 表格渲染等）→ 跟随时钉底，并刷新可滚动态。
+  ro = new ResizeObserver(() => {
+    if (autoScroll.value) scrollToBottom();
+    refreshMetrics();
+  });
+  if (content.value) ro.observe(content.value);
+  if (viewport.value) ro.observe(viewport.value);
+});
+
+onBeforeUnmount(() => {
+  ro?.disconnect();
+  ro = null;
+});
+</script>
+
+<template>
+  <div class="pa-autoscroll">
+    <div ref="viewport" class="pa-autoscroll-view" @scroll.passive="onScroll">
+      <div ref="content">
+        <slot />
+      </div>
+    </div>
+
+    <button
+      v-if="showButton"
+      type="button"
+      class="pa-autoscroll-btn"
+      title="恢复自动滚动"
+      aria-label="恢复自动滚动"
+      @click="resume"
+    >
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+        <path d="M12 5v14" />
+        <path d="m19 12-7 7-7-7" />
+      </svg>
+      <span>自动滚动</span>
+    </button>
+  </div>
+</template>
diff --git a/parallel-agents-vue/src/components/Avatar.vue b/parallel-agents-vue/src/parallel-agents/Avatar.vue
similarity index 95%
rename from parallel-agents-vue/src/components/Avatar.vue
rename to parallel-agents-vue/src/parallel-agents/Avatar.vue
index 615a3011..bad99494 100644
--- a/parallel-agents-vue/src/components/Avatar.vue
+++ b/parallel-agents-vue/src/parallel-agents/Avatar.vue
@@ -1,6 +1,6 @@
 <script setup lang="ts">
 import { computed } from "vue";
-import { avatarColor, isHuman } from "@/lib/avatar-constants";
+import { avatarColor, isHuman } from "./avatar-constants";
 
 const props = withDefaults(defineProps<{ type: string; size?: number }>(), { size: 36 });
 const color = computed(() => avatarColor(props.type));
diff --git a/parallel-agents-vue/src/components/ClarificationCard.vue b/parallel-agents-vue/src/parallel-agents/ClarificationCard.vue
similarity index 89%
rename from parallel-agents-vue/src/components/ClarificationCard.vue
rename to parallel-agents-vue/src/parallel-agents/ClarificationCard.vue
index e27e0827..0ddfc97a 100644
--- a/parallel-agents-vue/src/components/ClarificationCard.vue
+++ b/parallel-agents-vue/src/parallel-agents/ClarificationCard.vue
@@ -5,7 +5,7 @@
  * 自定义输入 + 发送按钮。提交时回传格式化好的回答文本。
  */
 import { computed, reactive } from "vue";
-import type { ClarificationPayload, ClarOption } from "@/types";
+import type { ClarificationPayload, ClarOption } from "./types";
 
 const props = defineProps<{ payload: ClarificationPayload; submitting?: boolean }>();
 const emit = defineEmits<{ (e: "submit", answer: string): void }>();
@@ -24,7 +24,9 @@ function norm(opts: ClarOption[]): NormOption[] {
 }
 
 const options = computed(() => norm(props.payload.options));
-const allowMultiple = computed(() => !!props.payload.allowMultiple);
+// 产品约定：协作卡片的选项**默认多选**（勾选多个 + 自定义补充，再点「发送回答」），
+// 不再受后端 allow_multiple 影响，避免单选「点击即发」误触。
+const allowMultiple = computed(() => true);
 const allowCustom = computed(() => props.payload.allowCustom !== false);
 const deferSubmit = computed(() => allowCustom.value); // 允许自定义时不在单击即发，给机会补充
 const showSubmit = computed(() => allowMultiple.value || allowCustom.value || options.value.length === 0);
@@ -44,7 +46,7 @@ function buildAnswer(ids: string[]): string | null {
 }
 
 function clickOption(id: string) {
-  if (props.submitting) return;
+  // 注意：不再因 submitting 禁止点击 —— 并行批次仍在跑（running）时也允许用户立刻回答澄清。
   if (!allowMultiple.value) {
     if (deferSubmit.value) {
       sel.ids = [id];
@@ -58,7 +60,8 @@ function clickOption(id: string) {
 
 const canSubmit = computed(() => sel.ids.length > 0 || sel.custom.trim().length > 0);
 function submit() {
-  if (props.submitting || !canSubmit.value) return;
+  // 同上：不因 submitting 拦截，只要求至少选了/填了内容。
+  if (!canSubmit.value) return;
   const ans = buildAnswer(sel.ids);
   if (ans) emit("submit", ans);
 }
@@ -93,7 +96,6 @@ function submit() {
         v-for="opt in options"
         :key="opt.id"
         type="button"
-        :disabled="submitting"
         class="flex w-full items-start justify-between gap-2 rounded-xl border px-3 py-2 text-left transition"
         :class="
           sel.ids.includes(opt.id)
@@ -116,7 +118,6 @@ function submit() {
     <div v-if="allowCustom" class="mt-3 flex flex-col gap-2">
       <textarea
         v-model="sel.custom"
-        :disabled="submitting"
         rows="2"
         class="pa-input min-h-16 resize-none px-2.5 py-1.5 text-xs"
         :placeholder="
@@ -134,10 +135,10 @@ function submit() {
       <button
         type="button"
         class="pa-btn-primary h-8 rounded-xl px-4 text-xs font-bold"
-        :disabled="submitting || !canSubmit"
+        :disabled="!canSubmit"
         @click="submit"
       >
-        {{ submitting ? "发送中…" : "发送回答" }}
+        发送回答
       </button>
     </div>
   </div>
diff --git a/parallel-agents-vue/src/components/MarkdownContent.vue b/parallel-agents-vue/src/parallel-agents/MarkdownContent.vue
similarity index 100%
rename from parallel-agents-vue/src/components/MarkdownContent.vue
rename to parallel-agents-vue/src/parallel-agents/MarkdownContent.vue
diff --git a/parallel-agents-vue/src/components/MessageBubble.vue b/parallel-agents-vue/src/parallel-agents/MessageBubble.vue
similarity index 98%
rename from parallel-agents-vue/src/components/MessageBubble.vue
rename to parallel-agents-vue/src/parallel-agents/MessageBubble.vue
index 8e3dd79c..272e50ff 100644
--- a/parallel-agents-vue/src/components/MessageBubble.vue
+++ b/parallel-agents-vue/src/parallel-agents/MessageBubble.vue
@@ -2,7 +2,7 @@
 /** 单条消息气泡（对齐 Step2 MessageBubble + Step2Message 结构）：头像 / 发言人 / 状态徽标 /
  *  时间 / 步骤条 / Markdown 正文 / 流式光标 / loading 占位。 */
 import { computed } from "vue";
-import type { Dialogue } from "@/types";
+import type { Dialogue } from "./types";
 import Avatar from "./Avatar.vue";
 import MessageStepsCard from "./MessageStepsCard.vue";
 import MarkdownContent from "./MarkdownContent.vue";
diff --git a/parallel-agents-vue/src/components/MessageStepsCard.vue b/parallel-agents-vue/src/parallel-agents/MessageStepsCard.vue
similarity index 96%
rename from parallel-agents-vue/src/components/MessageStepsCard.vue
rename to parallel-agents-vue/src/parallel-agents/MessageStepsCard.vue
index 8fcaffbb..f63849ea 100644
--- a/parallel-agents-vue/src/components/MessageStepsCard.vue
+++ b/parallel-agents-vue/src/parallel-agents/MessageStepsCard.vue
@@ -4,8 +4,8 @@
  * slate 边框卡 + 每步「图标列(带竖向连接线) + 中文文案 + 时间 + 参数子节点」。
  */
 import { computed, ref } from "vue";
-import type { DialogueStep } from "@/types";
-import { getStepArgs, getStepDisplay } from "@/lib/step-display";
+import type { DialogueStep } from "./types";
+import { getStepArgs, getStepDisplay } from "./step-display";
 import StepIcon from "./StepIcon.vue";
 
 const props = defineProps<{ steps: DialogueStep[]; streaming?: boolean }>();
diff --git a/parallel-agents-vue/src/parallel-agents/ParallelAgentsPanel.vue b/parallel-agents-vue/src/parallel-agents/ParallelAgentsPanel.vue
new file mode 100644
index 00000000..04b5d564
--- /dev/null
+++ b/parallel-agents-vue/src/parallel-agents/ParallelAgentsPanel.vue
@@ -0,0 +1,386 @@
+<script setup lang="ts">
+/**
+ * 并行多智能体面板（主组件，可嵌入）—— 纯展示 + 暴露方法版本。
+ *
+ * 「任务名称 / 简介 / 模型」全部由宿主通过 props 传入；本组件不再渲染顶部表单与按钮，
+ * 只展示「席位状态条 + 并行会话」。宿主自行渲染「重新分析 / 保存」等按钮，并通过模板 ref
+ * 调用本组件暴露的 `reanalyze()` / `save()` / `cancel()` 等方法。
+ *
+ * 并行调用宿主传入的多个智能体（后端固定禁写文件），消息列表照搬圆桌 Step2 并行多席位的
+ * 深色样式与结构（步骤条 / 并行双列 / 席位状态条），支持保存聊天记录 + 回显 + 重新分析。
+ *
+ * 自适应容器：根元素 `h-full w-full flex flex-col min-h-0`，宿主直接塞进抽屉 / 弹窗即可。
+ */
+import { computed, onMounted, ref, watch } from "vue";
+import type { AgentInput, AgentReply, AgentResult, Dialogue, SavedTask, SeatView } from "./types";
+import { useParallelRun } from "./useParallelRun";
+import {
+  createTask,
+  ensureTask,
+  listTasks,
+  updateTask,
+  type ApiConfig,
+} from "./api";
+import { DEFAULT_BASE_URL } from "./config";
+import ParallelSeatStrip from "./ParallelSeatStrip.vue";
+import MessageBubble from "./MessageBubble.vue";
+import AutoScrollPane from "./AutoScrollPane.vue";
+
+const props = withDefaults(
+  defineProps<{
+    /** 后端地址；不传用配置文件默认（config.ts 的 DEFAULT_BASE_URL）。 */
+    baseUrl?: string;
+    /** 已有 token（Bearer），与 username 二选一；都不传走配置默认地址 + 免密登录失败提示。 */
+    token?: string;
+    getToken?: () => string | Promise<string>;
+    /** 免密自动登录用户名（由宿主自己传）。不传 token 时用它登录换 token。 */
+    username?: string;
+    /** 仅当后端开启口令门时需要。 */
+    loginPassword?: string;
+    agents: AgentInput[];
+    taskId?: string;
+    /** 任务名称：由宿主传入（可配合 update:taskName 做 v-model）。 */
+    taskName?: string;
+    /** 任务简介：由宿主传入（可配合 update:brief 做 v-model）。 */
+    brief?: string;
+    /** 本次并行分析使用的模型；空 = 后端回退默认。 */
+    model?: string;
+    dark?: boolean;
+  }>(),
+  { dark: true, taskName: "", brief: "", model: "" },
+);
+
+const emit = defineEmits<{
+  (e: "saved", task: SavedTask): void;
+  (e: "update:taskId", id: string): void;
+  /** 回显已保存任务时回传标题，宿主可据此同步自己的输入框。 */
+  (e: "update:taskName", name: string): void;
+  /** 回显已保存任务时回传简介。 */
+  (e: "update:brief", brief: string): void;
+  /** 单个智能体**真正完成（done）**时回传它的结果对象 `{ agent_id, name, content }`（待协助/出错不发）。 */
+  (e: "agent-completed", result: AgentReply): void;
+  /** **所有**智能体都完成（done/error、无待协助）后，回传各智能体的返回结果数组。 */
+  (e: "completed", results: AgentReply[]): void;
+}>();
+
+const cfg = computed<ApiConfig>(() => ({
+  baseUrl: props.baseUrl || DEFAULT_BASE_URL,
+  token: props.token,
+  getToken: props.getToken,
+  username: props.username,
+  loginPassword: props.loginPassword,
+}));
+
+// 单个智能体完成即回传它的结果（一分析完就给宿主）。
+const run = useParallelRun({
+  onAgentSettled: (agentId, status) => {
+    // 只在**真正完成（done）**时回传单个结果；待用户协助（clarify）/出错（error）都不算完成，不回传，
+    // 免得宿主把「在等用户回答澄清」的中间态当成已出结果。等用户答完、该席位重跑出 done 时再回传。
+    if (status === "done") {
+      const r = getResult(agentId);
+      if (r) emit("agent-completed", toReply(r));
+    }
+    // 每有一个席位收尾就检查：是否**所有**席位都完成了 → 是则发一次批量结果。
+    maybeEmitCompleted();
+  },
+});
+const { dialogues, seats, running, busy } = run;
+
+// 任务名 / 简介 / 模型全部由宿主 props 提供（本组件不再持有可编辑表单）。
+const taskName = computed(() => props.taskName ?? "");
+const brief = computed(() => props.brief ?? "");
+const model = computed(() => (props.model || "").trim() || undefined);
+
+const currentTaskId = ref<string | null>(props.taskId ?? null);
+const selected = ref<string[]>([]);
+const saving = ref(false);
+const history = ref<SavedTask[]>([]);
+const errorMsg = ref<string | null>(null);
+
+const dialogueById = computed(() => {
+  const m = new Map<number, Dialogue>();
+  for (const d of dialogues.value) m.set(d.id, d);
+  return m;
+});
+
+const hasResults = computed(() => dialogues.value.length > 0);
+const canStart = computed(
+  () => !running.value && props.agents.length > 0 && !!(taskName.value.trim() || brief.value.trim()),
+);
+
+// 单选：主区每次只显示**一个**席位的消息列表，点头像切换。
+watch(
+  seats,
+  (s) => {
+    if (!s.length) {
+      selected.value = [];
+      return;
+    }
+    // 保留仍存在的当前选中；首次 / 失效时默认显示第 1 个席位。
+    const cur = selected.value[0];
+    const keep = cur && s.some((x) => x.agentId === cur) ? cur : s[0].agentId;
+    selected.value = [keep];
+  },
+  { immediate: true },
+);
+
+// 宿主传入 / 改变 taskId：作为存储主键，并尝试加载回显该任务（不存在则只设 id）。
+watch(
+  () => props.taskId,
+  (id) => {
+    currentTaskId.value = id ?? null;
+    if (id) void loadTask(id);
+  },
+);
+
+/** 点头像切换显示：单选，始终切到点击的那个席位。 */
+function toggleSeat(agentId: string) {
+  selected.value = [agentId];
+}
+
+const visibleSeats = computed(() => {
+  const id = selected.value[0] ?? seats.value[0]?.agentId;
+  const seat = seats.value.find((s) => s.agentId === id);
+  return seat ? [seat] : [];
+});
+
+// ── 给宿主读取「每个智能体模型返回的内容」的简单方法 ──────────────────────────
+function _statusOf(agentId: string, streaming?: boolean): SeatView["status"] {
+  return seats.value.find((s) => s.agentId === agentId)?.status ?? (streaming ? "running" : "done");
+}
+/** 取所有智能体的返回内容（按席位顺序）。宿主：`panelRef.value.getResults()`。 */
+function getResults(): AgentResult[] {
+  return dialogues.value.map((d) => ({
+    agent_id: d.agentId,
+    name: d.sender,
+    content: d.content,
+    status: _statusOf(d.agentId, d.streaming),
+  }));
+}
+/** 取某个智能体的返回内容；不存在返回 null。 */
+function getResult(agentId: string): AgentResult | null {
+  return getResults().find((r) => r.agent_id === agentId) ?? null;
+}
+/** AgentResult → 回传给宿主的精简对象（智能体名称 + 模型返回结果），去掉 status。 */
+function toReply(r: AgentResult): AgentReply {
+  return { agent_id: r.agent_id, name: r.name, content: r.content };
+}
+/** 是否所有席位都已收尾：done / error 都算「已返回」，只要还有 clarify（待协助）/ running / pending 就不算。 */
+function allAgentsDone(): boolean {
+  const list = seats.value;
+  if (!list.length) return false;
+  return list.every((s) => s.status === "done" || s.status === "error");
+}
+/** 仅当**所有**智能体都完成时，才把全部结果作为批量 completed 发给宿主（待协助未答完不发）。 */
+function maybeEmitCompleted() {
+  if (!allAgentsDone()) return;
+  emit("completed", getResults().map(toReply));
+}
+// 模板 ref 用：`<ParallelAgentsPanel ref="panelRef" />`
+// 宿主自行渲染按钮，调用下面这些方法 / 读取状态：
+//   panelRef.value.reanalyze()  // 开始 / 重新分析
+//   panelRef.value.save()       // 保存 / 更新保存
+//   panelRef.value.cancel()     // 停止
+//   panelRef.value.loadTask(id) // 回显某条历史
+//   panelRef.value.running / saving / hasResults / canStart  // 按钮态（ref）
+defineExpose({
+  getResults,
+  getResult,
+  start: () => onStart(),
+  reanalyze: () => onStart(),
+  save: () => onSave(),
+  cancel: () => run.cancel(),
+  loadTask: (id: string) => loadTask(id),
+  refreshHistory: () => refreshHistory(),
+  history,
+  running,
+  saving,
+  hasResults,
+  canStart,
+  errorMsg,
+});
+
+/** 用户在某智能体的协作卡片里提交了回答 → 带上回答重跑该智能体。 */
+async function onClarify(agentId: string, answer: string) {
+  errorMsg.value = null;
+  const merged = `${brief.value}\n\n【用户补充】${answer}`.trim();
+  try {
+    await run.rerunAgent(cfg.value, {
+      taskName: taskName.value,
+      brief: merged,
+      agentId,
+      model: model.value,
+      userNote: answer, // 在该席位历史里展示「我的补充」，协助前的内容不丢
+    });
+    // 批量 completed 由 onAgentSettled→maybeEmitCompleted 在「全部完成」时统一发；这里不再直接发。
+    void autoSave(); // 重跑完也自动存一次
+  } catch (err) {
+    errorMsg.value = err instanceof Error ? err.message : String(err);
+  }
+}
+
+async function onStart() {
+  if (!canStart.value) return;
+  errorMsg.value = null;
+  try {
+    await run.start(cfg.value, {
+      taskName: taskName.value,
+      brief: brief.value,
+      agents: props.agents,
+      model: model.value,
+    });
+    // 批量 completed 改由 onAgentSettled→maybeEmitCompleted 在「全部智能体完成」时统一发：
+    // 若有席位在等用户协助（clarify），本轮不发批量，待其答完重跑完成后再发。
+    void autoSave(); // 分析完自动保存一次
+  } catch (err) {
+    errorMsg.value = err instanceof Error ? err.message : String(err);
+  }
+}
+
+/** 一轮分析结束后自动保存一次（有结果才存；失败静默，不打断主流程）。 */
+async function autoSave() {
+  if (!hasResults.value || saving.value) return;
+  try {
+    await onSave();
+  } catch {
+    /* 自动保存失败不打扰用户，错误已在 onSave 内记录 */
+  }
+}
+
+async function onSave() {
+  if (saving.value || !hasResults.value) return;
+  saving.value = true;
+  errorMsg.value = null;
+  try {
+    const title = taskName.value.trim() || "未命名任务";
+    const agentsSnapshot: AgentInput[] = props.agents.map((a) => ({ ...a }));
+    const payload = { title, brief: brief.value, agents: agentsSnapshot, messages: dialogues.value };
+    // 按宿主传入的 taskId **upsert**：有 id 先更新，不存在（404）再用该 id 创建；无 id 则新建。
+    let saved: SavedTask | null;
+    const id = currentTaskId.value;
+    if (id) {
+      saved = await updateTask(cfg.value, id, payload);
+      if (!saved) saved = await createTask(cfg.value, { id, ...payload });
+    } else {
+      saved = await createTask(cfg.value, payload);
+    }
+    if (saved) {
+      currentTaskId.value = saved.id;
+      emit("update:taskId", saved.id);
+      emit("saved", saved);
+      await refreshHistory();
+    }
+  } catch (err) {
+    errorMsg.value = err instanceof Error ? err.message : String(err);
+  } finally {
+    saving.value = false;
+  }
+}
+
+async function refreshHistory() {
+  try {
+    const list = await listTasks(cfg.value);
+    // 按更新时间倒序，最新的在最前（供「进入默认显示最新一条」用）。
+    history.value = [...list].sort((a, b) =>
+      (b.updated_at || b.created_at || "").localeCompare(a.updated_at || a.created_at || ""),
+    );
+  } catch {
+    /* 历史拉取失败不阻断主流程 */
+  }
+}
+
+async function loadTask(id: string) {
+  errorMsg.value = null;
+  try {
+    // get-or-create：新 id 直接初始化空记录（不 404）；已存在则回显其聊天记录。
+    const task = await ensureTask(cfg.value, {
+      id,
+      agents: props.agents.map((a) => ({ ...a })),
+    });
+    currentTaskId.value = task.id;
+    selected.value = [];
+    if (task.messages && task.messages.length) {
+      // 标题 / 简介由宿主持有：回传让宿主同步自己的输入框（v-model）。
+      emit("update:taskName", task.title ?? "");
+      emit("update:brief", task.brief ?? "");
+      run.hydrate(task.messages);
+    } else {
+      // 空记录（新初始化）：清空当前会话，等宿主填任务 / 触发分析。
+      run.reset();
+    }
+    emit("update:taskId", task.id);
+  } catch (err) {
+    errorMsg.value = err instanceof Error ? err.message : String(err);
+  }
+}
+
+onMounted(async () => {
+  await refreshHistory();
+  if (props.taskId) {
+    void loadTask(props.taskId);
+  } else if (history.value.length) {
+    // 没指定 taskId：默认回显最新一条聊天记录。
+    void loadTask(history.value[0].id);
+  }
+});
+</script>
+
+<template>
+  <div
+    class="parallel-agents pa-bg flex h-full w-full min-h-0 flex-col"
+    :class="dark ? 'parallel-agents--dark' : ''"
+  >
+    <!-- 顶部表单与按钮已移除：任务名 / 简介 / 模型由宿主 props 传入，
+         「重新分析 / 保存 / 停止」由宿主调用本组件 expose 出的方法。 -->
+
+    <!-- 错误提示（保留，便于宿主无需额外处理也能看到失败原因） -->
+    <p
+      v-if="errorMsg"
+      class="pa-border shrink-0 border-b px-4 py-2 text-xs"
+      style="color: var(--pa-rose)"
+    >
+      {{ errorMsg }}
+    </p>
+
+    <!-- 席位状态条 -->
+    <div v-if="seats.length" class="pa-border shrink-0 border-b px-4">
+      <ParallelSeatStrip :seats="seats" :selected="selected" @toggle="toggleSeat" />
+    </div>
+
+    <!-- 会话区：并行双列。本容器只负责限高（min-h-0 flex-1），不整体滚动；
+         滚动条与自动下滑下放到每个席位卡片内部的 AutoScrollPane（各智能体互不影响）。 -->
+    <div class="flex min-h-0 flex-1 flex-col overflow-hidden p-4">
+      <div
+        v-if="hasResults"
+        class="grid min-h-0 flex-1 gap-4 pa-rows-fill"
+        :class="visibleSeats.length > 1 ? 'grid-cols-1 lg:grid-cols-2' : 'grid-cols-1'"
+      >
+        <div
+          v-for="seat in visibleSeats"
+          :key="seat.agentId"
+          class="pa-surface-soft pa-border relative flex min-h-0 min-w-0 flex-col overflow-hidden rounded-xl border"
+        >
+          <AutoScrollPane v-if="dialogueById.get(seat.bubbleId)">
+            <div class="p-3">
+              <MessageBubble
+                :msg="dialogueById.get(seat.bubbleId)!"
+                :submitting="running || busy.has(seat.agentId)"
+                @clarify="onClarify"
+              />
+            </div>
+          </AutoScrollPane>
+          <div v-else class="flex flex-1 items-center justify-center py-6 text-center text-xs pa-text-muted">
+            {{ seat.name }} · 等待输出…
+          </div>
+        </div>
+      </div>
+      <div
+        v-else
+        class="flex h-full flex-col items-center justify-center gap-2 text-center"
+      >
+        <p class="text-sm pa-text-muted">等待宿主触发「开始 / 重新分析」，并行调用各智能体。</p>
+        <p class="text-xs pa-text-muted">并行运行期间禁止写文件，产出直接呈现在正文。</p>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/parallel-agents-vue/src/components/ParallelSeatStrip.vue b/parallel-agents-vue/src/parallel-agents/ParallelSeatStrip.vue
similarity index 86%
rename from parallel-agents-vue/src/components/ParallelSeatStrip.vue
rename to parallel-agents-vue/src/parallel-agents/ParallelSeatStrip.vue
index e58aa88e..892ba6f9 100644
--- a/parallel-agents-vue/src/components/ParallelSeatStrip.vue
+++ b/parallel-agents-vue/src/parallel-agents/ParallelSeatStrip.vue
@@ -2,13 +2,14 @@
 /** 并行席位状态条（对齐 Step2 ParallelSeatStrip）：席位头像 + running/done/error 角标，
  *  点击可切换主区显示哪两列。 */
 import { computed } from "vue";
-import type { SeatView } from "@/types";
+import type { SeatView } from "./types";
 import Avatar from "./Avatar.vue";
 
 const props = defineProps<{ seats: SeatView[]; selected: string[] }>();
 const emit = defineEmits<{ (e: "toggle", agentId: string): void }>();
 
 const runningCount = computed(() => props.seats.filter((s) => s.status === "running").length);
+const clarifyCount = computed(() => props.seats.filter((s) => s.status === "clarify").length);
 </script>
 
 <template>
@@ -16,6 +17,7 @@ const runningCount = computed(() => props.seats.filter((s) => s.status === "runn
     <span class="shrink-0 text-[11px] font-bold pa-text-muted">
       并行 {{ seats.length }} 席
       <span v-if="runningCount > 0" class="pa-text-primary">（{{ runningCount }} 进行中）</span>
+      <span v-if="clarifyCount > 0" style="color: var(--pa-amber)">（{{ clarifyCount }} 待协助）</span>
       <span v-if="seats.length > 1" class="font-normal pa-text-muted">· 点头像切换显示</span>
     </span>
     <div class="flex items-center gap-2">
@@ -46,12 +48,14 @@ const runningCount = computed(() => props.seats.filter((s) => s.status === "runn
           :class="{
             'pa-dot-running': seat.status === 'running',
             'pa-dot-done': seat.status === 'done',
+            'pa-dot-clarify': seat.status === 'clarify',
             'pa-dot-error': seat.status === 'error',
           }"
           :style="seat.status === 'pending' ? 'background: var(--pa-border)' : ''"
         >
           <span v-if="seat.status === 'running'" class="pa-spin">◜</span>
           <span v-else-if="seat.status === 'done'">✓</span>
+          <span v-else-if="seat.status === 'clarify'">?</span>
           <span v-else-if="seat.status === 'error'">✕</span>
         </span>
       </button>
diff --git a/parallel-agents-vue/src/parallel-agents/README.md b/parallel-agents-vue/src/parallel-agents/README.md
new file mode 100644
index 00000000..7f4f8313
--- /dev/null
+++ b/parallel-agents-vue/src/parallel-agents/README.md
@@ -0,0 +1,61 @@
+# 并行多智能体面板（parallel-agents）
+
+一个**自包含**的 Vue 3 可嵌入组件：输入任务名 + 简介，并行调用多个智能体，深色消息列表 +
+步骤条 + 协作卡片 + 保存回显 + 重新分析。
+
+## 怎么用（复制即用）
+
+把**整个 `parallel-agents/` 文件夹**拷到你项目的 `src/` 下，然后：
+
+```ts
+import { ParallelAgentsPanel } from "@/parallel-agents";
+// 或： import { ParallelAgentsPanel } from "./parallel-agents";
+```
+
+```vue
+<ParallelAgentsPanel
+  ref="panel"
+  :base-url="'http://localhost:8001'"
+  :username="'demo'"
+  :task-id="taskId || undefined"
+  v-model:task-name="taskName"
+  v-model:brief="brief"
+  :model="model"
+  :agents="agents"
+  @agent-completed="onAgentCompleted"
+  @completed="onCompleted"
+/>
+```
+
+样式由入口 `index.ts` 自动 `import "./parallel-agents.css"`，**无需** Tailwind / 任何 CSS 框架。
+若你不走 `index.ts` 而是直接 import 组件，请自行引一次该 CSS。
+
+## 依赖
+
+- `vue` ^3.4
+- `markdown-it` ^14（正文 Markdown 渲染）—— `pnpm add markdown-it`
+
+> 不再依赖 Tailwind：布局类已内置为 `parallel-agents.css` 末尾的「最小工具类子集」，全部作用域
+> 在根类 `.parallel-agents` 下，绝不外泄污染宿主页面。
+
+## 文件结构（都在本文件夹内，可随意改源码）
+
+| 文件 | 作用 |
+|------|------|
+| `ParallelAgentsPanel.vue` | 主组件（席位条 + 并行会话，暴露 start/save/cancel 等方法） |
+| `ParallelSeatStrip.vue` | 席位状态条（running / done / **clarify 待协助** / error） |
+| `MessageBubble.vue` | 单条消息气泡（头像 / 步骤条 / 正文 / 协作卡片） |
+| `MessageStepsCard.vue` · `StepIcon.vue` | 执行步骤条 / 思维链卡 + 图标 |
+| `ClarificationCard.vue` | 协作 / 澄清卡片（用户协助） |
+| `MarkdownContent.vue` | Markdown 正文渲染（markdown-it） |
+| `Avatar.vue` | 头像（机器人 / 真人 SVG） |
+| `useParallelRun.ts` | 并行运行编排（消费合并 SSE、按席位路由、待协助/并发协助） |
+| `api.ts` | 后端访问层（鉴权 + 扇出 SSE + 任务 CRUD） |
+| `types.ts` · `config.ts` · `avatar-constants.ts` · `step-display.ts` | 类型 / 配置 / 头像配色 / 步骤文案 |
+| `parallel-agents.css` | 作用域样式（深蓝深色 token + 语义类 + 工具类子集） |
+
+## 关键状态
+
+席位/结果状态 `SeatStatus`：`pending | running | done | clarify | error`。其中 **`clarify`** 表示
+该智能体在等用户协助（待确认），**不是已完成**——宿主据此判断「未完成」，多个智能体同时待协助
+时可分别协助、互不阻塞。
diff --git a/parallel-agents-vue/src/components/StepIcon.vue b/parallel-agents-vue/src/parallel-agents/StepIcon.vue
similarity index 97%
rename from parallel-agents-vue/src/components/StepIcon.vue
rename to parallel-agents-vue/src/parallel-agents/StepIcon.vue
index 78027228..9473dac2 100644
--- a/parallel-agents-vue/src/components/StepIcon.vue
+++ b/parallel-agents-vue/src/parallel-agents/StepIcon.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import type { IconKey } from "@/lib/step-display";
+import type { IconKey } from "./step-display";
 defineProps<{ name: IconKey; size?: number }>();
 </script>
 
diff --git a/parallel-agents-vue/src/api.ts b/parallel-agents-vue/src/parallel-agents/api.ts
similarity index 93%
rename from parallel-agents-vue/src/api.ts
rename to parallel-agents-vue/src/parallel-agents/api.ts
index 53c23cf7..0d1305a8 100644
--- a/parallel-agents-vue/src/api.ts
+++ b/parallel-agents-vue/src/parallel-agents/api.ts
@@ -190,6 +190,21 @@ export async function createTask(
   return readJson<SavedTask>(res, "create task");
 }
 
+/**
+ * get-or-create：存在则返回（含 messages 回显），不存在则用该 id 初始化一条空记录。
+ * 宿主传的 taskId 不固定，新 id 不再 404。幂等。
+ */
+export async function ensureTask(
+  cfg: ApiConfig,
+  payload: { id: string; title?: string; brief?: string; agents?: AgentInput[] },
+): Promise<SavedTask> {
+  const res = await authedFetch(cfg, `${TASKS(cfg)}/ensure`, {
+    method: "POST",
+    body: JSON.stringify({ title: "", agents: [], ...payload }),
+  });
+  return readJson<SavedTask>(res, "ensure task");
+}
+
 export async function updateTask(
   cfg: ApiConfig,
   id: string,
diff --git a/parallel-agents-vue/src/lib/avatar-constants.ts b/parallel-agents-vue/src/parallel-agents/avatar-constants.ts
similarity index 100%
rename from parallel-agents-vue/src/lib/avatar-constants.ts
rename to parallel-agents-vue/src/parallel-agents/avatar-constants.ts
diff --git a/parallel-agents-vue/src/config.ts b/parallel-agents-vue/src/parallel-agents/config.ts
similarity index 100%
rename from parallel-agents-vue/src/config.ts
rename to parallel-agents-vue/src/parallel-agents/config.ts
diff --git a/parallel-agents-vue/src/parallel-agents/index.ts b/parallel-agents-vue/src/parallel-agents/index.ts
new file mode 100644
index 00000000..3404c622
--- /dev/null
+++ b/parallel-agents-vue/src/parallel-agents/index.ts
@@ -0,0 +1,28 @@
+/**
+ * 并行多智能体面板 —— 自包含文件夹入口。
+ *
+ * 使用方式（把整个 parallel-agents/ 文件夹拷进你的项目 src 下即可）：
+ *
+ *   import { ParallelAgentsPanel } from "@/parallel-agents";
+ *   // 或相对路径： import { ParallelAgentsPanel } from "./parallel-agents";
+ *
+ * 样式会被这里自动引入（零依赖、作用域在 .parallel-agents 下，不污染宿主，无需 Tailwind）。
+ * 仅依赖 vue 与 markdown-it（正文 Markdown 渲染）。详见同目录 README.md。
+ */
+import "./parallel-agents.css";
+
+export { default as ParallelAgentsPanel } from "./ParallelAgentsPanel.vue";
+export type {
+  AgentInput,
+  AgentReply,
+  AgentResult,
+  ClarificationPayload,
+  ClarOption,
+  Dialogue,
+  DialogueStep,
+  SavedTask,
+  SeatStatus,
+  SeatView,
+  StreamEvent,
+} from "./types";
+export type { ApiConfig } from "./api";
diff --git a/parallel-agents-vue/src/parallel-agents/parallel-agents.css b/parallel-agents-vue/src/parallel-agents/parallel-agents.css
new file mode 100644
index 00000000..7ea77721
--- /dev/null
+++ b/parallel-agents-vue/src/parallel-agents/parallel-agents.css
@@ -0,0 +1,520 @@
+/* 并行多智能体面板样式 —— 零依赖、不污染宿主。
+ *
+ * 不再依赖 Tailwind：本文件自带一份「最小布局工具类子集」（文件末尾），全部作用域在根类
+ * `.parallel-agents` 下，绝不外泄到宿主页面。其它项目把整个 parallel-agents/ 文件夹拷走、
+ * 只 `import "./parallel-agents.css"` 即可，无需安装或配置 Tailwind。
+ *
+ * 颜色用作用域内的 `--pa-*` 深蓝 token（取自《深蓝 UI 规范》ZS-004 / ZS-002，与圆桌 Step2
+ * 深色一致）。语义颜色用 `.pa-*` 类，布局用末尾的工具类子集。 */
+
+/* ── 作用域 token（深色深蓝，自带成色，不依赖宿主主题）─────────────────────── */
+.parallel-agents {
+  --pa-bg: #0c1836; /* 页面背景 zs-004-09 */
+  --pa-card: #122347; /* 卡片 / 气泡容器 zs-004-08 */
+  --pa-muted: #16294d; /* 次级表面（步骤卡 / 并行列底） */
+  --pa-accent: #1a2f5a; /* hover / 软高亮 */
+  --pa-fg: #c5cfe0; /* 正文 zs-004-02 */
+  --pa-fg-muted: #6e88b0; /* 次级文字 zs-004-04 */
+  --pa-border: #2d4473; /* 容器边框 zs-004-06 */
+  --pa-input: #4a6491; /* 控件描边 */
+  --pa-primary: #1677ff; /* 主操作 zs-002-06 */
+  --pa-primary-fg: #ffffff;
+  --pa-chip-bg: #16335f; /* badge 底 */
+  --pa-chip-fg: #4096ff; /* badge 文字 */
+  --pa-amber: #f59e0b;
+  --pa-emerald: #10b981;
+  --pa-rose: #ef4444;
+
+  color: var(--pa-fg);
+  background-color: var(--pa-bg);
+  font-size: 14px;
+  line-height: 1.6;
+  box-sizing: border-box;
+
+  /* 根容器布局：必须写在这里，不能只靠模板上的 .h-full/.flex/.flex-col 工具类 ——
+   * 那些工具类是后代选择器（.parallel-agents .flex），匹配不到「自身就带 .parallel-agents
+   * 类」的根元素，于是 height:100% / display:flex 在根上从不生效，整条高度链断裂、不出滚动条。
+   * 这里直接给根定死：撑满宿主给定的高度并作纵向 flex 容器（min-height:0 允许子项内部滚动）。 */
+  display: flex;
+  flex-direction: column;
+  width: 100%;
+  height: 100%;
+  min-height: 0;
+}
+.parallel-agents *,
+.parallel-agents *::before,
+.parallel-agents *::after {
+  box-sizing: border-box;
+}
+
+/* 滚动条 */
+.parallel-agents ::-webkit-scrollbar {
+  width: 8px;
+  height: 8px;
+}
+.parallel-agents ::-webkit-scrollbar-thumb {
+  background: color-mix(in oklch, var(--pa-primary) 40%, var(--pa-border));
+  border-radius: 999px;
+}
+.parallel-agents ::-webkit-scrollbar-thumb:hover {
+  background: color-mix(in oklch, var(--pa-primary) 60%, var(--pa-border));
+}
+
+/* ── 语义颜色类（组件用这些上色，布局用文件末尾的工具类子集）──────────────────── */
+.parallel-agents .pa-bg {
+  background-color: var(--pa-bg);
+}
+.parallel-agents .pa-card {
+  background-color: var(--pa-card);
+}
+.parallel-agents .pa-surface {
+  background-color: var(--pa-muted);
+}
+.parallel-agents .pa-surface-soft {
+  background-color: color-mix(in oklch, var(--pa-muted) 55%, transparent);
+}
+.parallel-agents .pa-border {
+  border-color: var(--pa-border);
+}
+.parallel-agents .pa-text {
+  color: var(--pa-fg);
+}
+.parallel-agents .pa-text-muted {
+  color: var(--pa-fg-muted);
+}
+.parallel-agents .pa-text-primary {
+  color: var(--pa-primary);
+}
+
+/* 输入框 / 文本域 */
+.parallel-agents .pa-input {
+  background-color: var(--pa-card);
+  border: 1px solid var(--pa-border);
+  color: var(--pa-fg);
+  border-radius: 8px;
+}
+.parallel-agents .pa-input::placeholder {
+  color: color-mix(in oklch, var(--pa-fg-muted) 80%, transparent);
+}
+.parallel-agents .pa-input:focus {
+  outline: none;
+  border-color: color-mix(in oklch, var(--pa-primary) 55%, var(--pa-border));
+}
+
+/* 主按钮 / 次按钮 */
+.parallel-agents .pa-btn-primary {
+  background-color: var(--pa-primary);
+  color: var(--pa-primary-fg);
+  border-radius: 8px;
+  transition: filter 0.15s ease;
+}
+.parallel-agents .pa-btn-primary:hover {
+  filter: brightness(1.08);
+}
+.parallel-agents .pa-btn-primary:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+.parallel-agents .pa-btn-ghost {
+  border: 1px solid var(--pa-border);
+  color: var(--pa-fg);
+  background-color: transparent;
+  border-radius: 8px;
+  transition: background-color 0.15s ease;
+}
+.parallel-agents .pa-btn-ghost:hover {
+  background-color: var(--pa-accent);
+}
+.parallel-agents .pa-btn-ghost:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+/* 状态徽标（"实时输出" / "已完成" …）—— 对齐 Step2 confidence chip */
+.parallel-agents .pa-badge {
+  background-color: var(--pa-chip-bg);
+  color: var(--pa-chip-fg);
+  border: 1px solid var(--pa-border);
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-weight: 800;
+  text-transform: uppercase;
+  border-radius: 4px;
+  padding: 1px 6px;
+  font-size: 11px;
+  letter-spacing: 0.02em;
+}
+
+/* 席位状态角标色 */
+.parallel-agents .pa-dot-running {
+  background-color: var(--pa-primary);
+  color: #fff;
+}
+.parallel-agents .pa-dot-done {
+  background-color: var(--pa-emerald);
+  color: #fff;
+}
+.parallel-agents .pa-dot-error {
+  background-color: var(--pa-rose);
+  color: #fff;
+}
+.parallel-agents .pa-dot-clarify {
+  background-color: var(--pa-amber);
+  color: #fff;
+}
+
+/* 流式光标 + loading 点 */
+.parallel-agents .pa-cursor {
+  display: inline-block;
+  width: 4px;
+  height: 13px;
+  margin-left: 2px;
+  vertical-align: middle;
+  background: var(--pa-primary);
+  animation: pa-pulse 1s ease-in-out infinite;
+}
+@keyframes pa-pulse {
+  0%,
+  100% {
+    opacity: 1;
+  }
+  50% {
+    opacity: 0.25;
+  }
+}
+.parallel-agents .pa-bounce {
+  animation: pa-bounce 0.9s infinite;
+}
+@keyframes pa-bounce {
+  0%,
+  100% {
+    transform: translateY(0);
+  }
+  50% {
+    transform: translateY(-3px);
+  }
+}
+@keyframes pa-spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+.parallel-agents .pa-spin {
+  animation: pa-spin 0.8s linear infinite;
+}
+@keyframes pa-ping {
+  75%,
+  100% {
+    transform: scale(1.8);
+    opacity: 0;
+  }
+}
+.parallel-agents .pa-ping {
+  animation: pa-ping 1.2s cubic-bezier(0, 0, 0.2, 1) infinite;
+}
+
+/* ── 自动下滑窗格（AutoScrollPane.vue）────────────────────────────────────────
+ * 根 = 不滚动的 relative 容器，靠 flex-1 填满席位卡片（卡片高度受会话区限制）；
+ * viewport = 绝对定位铺满根，自己滚动 —— 内部高度不依赖逐层 flex 传导，只要卡片
+ * 有确定高度就一定能正确限高出滚动条。浮动按钮是 viewport 的兄弟，挂在不滚动的根上。 */
+.parallel-agents .pa-autoscroll {
+  position: relative;
+  flex: 1 1 0%;
+  min-height: 0;
+  width: 100%;
+}
+.parallel-agents .pa-autoscroll-view {
+  position: absolute;
+  inset: 0;
+  overflow-y: auto;
+  overflow-x: hidden;
+}
+
+/* 浮动「自动滚动」按钮：半透明、底部居中、悬浮在内容之上；不随内容滚走。 */
+.parallel-agents .pa-autoscroll-btn {
+  position: absolute;
+  left: 50%;
+  bottom: 12px;
+  transform: translateX(-50%);
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 6px 14px;
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--pa-fg);
+  background: color-mix(in oklch, var(--pa-card) 70%, transparent);
+  border: 1px solid color-mix(in oklch, var(--pa-primary) 45%, var(--pa-border));
+  border-radius: 9999px;
+  cursor: pointer;
+  opacity: 0.82;
+  backdrop-filter: blur(6px);
+  box-shadow: 0 6px 18px rgba(0, 0, 0, 0.28);
+  transition: opacity 0.15s ease, background-color 0.15s ease, transform 0.15s ease;
+  z-index: 5;
+}
+.parallel-agents .pa-autoscroll-btn:hover {
+  opacity: 1;
+  background: color-mix(in oklch, var(--pa-card) 88%, transparent);
+}
+.parallel-agents .pa-autoscroll-btn:active {
+  transform: translateX(-50%) translateY(1px);
+}
+.parallel-agents .pa-autoscroll-btn svg {
+  width: 14px;
+  height: 14px;
+}
+
+/* ── Markdown 正文（对齐 Step2 sharedMarkdownComponents 的深色观感）──────────── */
+.parallel-agents .pa-md {
+  color: var(--pa-fg);
+  font-size: 14px;
+  line-height: 1.7;
+  word-break: break-word;
+}
+.parallel-agents .pa-md p {
+  margin: 0.35em 0;
+}
+.parallel-agents .pa-md h1,
+.parallel-agents .pa-md h2,
+.parallel-agents .pa-md h3,
+.parallel-agents .pa-md h4 {
+  font-weight: 700;
+  margin: 0.7em 0 0.35em;
+  color: var(--pa-fg);
+}
+.parallel-agents .pa-md h1 {
+  font-size: 1.3em;
+}
+.parallel-agents .pa-md h2 {
+  font-size: 1.18em;
+}
+.parallel-agents .pa-md h3 {
+  font-size: 1.06em;
+}
+.parallel-agents .pa-md ul,
+.parallel-agents .pa-md ol {
+  margin: 0.35em 0;
+  padding-left: 1.4em;
+}
+.parallel-agents .pa-md li {
+  margin: 0.2em 0;
+}
+.parallel-agents .pa-md a {
+  color: var(--pa-chip-fg);
+  text-decoration: underline;
+}
+.parallel-agents .pa-md code {
+  background: var(--pa-muted);
+  border: 1px solid var(--pa-border);
+  border-radius: 4px;
+  padding: 0.1em 0.35em;
+  font-size: 0.9em;
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+}
+.parallel-agents .pa-md pre {
+  background: var(--pa-muted);
+  border: 1px solid var(--pa-border);
+  border-radius: 8px;
+  padding: 0.75em;
+  overflow-x: auto;
+  margin: 0.5em 0;
+}
+.parallel-agents .pa-md pre code {
+  background: transparent;
+  border: 0;
+  padding: 0;
+}
+.parallel-agents .pa-md blockquote {
+  border-left: 3px solid var(--pa-border);
+  padding-left: 0.75em;
+  color: var(--pa-fg-muted);
+  margin: 0.5em 0;
+}
+.parallel-agents .pa-md table {
+  border-collapse: collapse;
+  margin: 0.5em 0;
+  width: 100%;
+}
+.parallel-agents .pa-md th,
+.parallel-agents .pa-md td {
+  border: 1px solid var(--pa-border);
+  padding: 0.35em 0.6em;
+  text-align: left;
+}
+.parallel-agents .pa-md th {
+  background: var(--pa-muted);
+}
+
+/* ════════════════════════════════════════════════════════════════════════════
+ * 最小布局工具类子集（替代 Tailwind）
+ * 只实现本组件模板用到的类，全部作用域在 .parallel-agents 下，不影响宿主。
+ * 维护提示：模板里新增布局类时，在此处补一条对应规则即可（或直接写 scoped <style>）。
+ *
+ * 放进 @layer：让无层级的 `.pa-*` 语义类（颜色/按钮/徽标）在同名属性冲突时仍**压过**这里的
+ * 工具类，复刻原先 Tailwind utilities 在 @layer、pa-* 无层级时的优先级（如 pa-btn-primary
+ * 的 8px 圆角压过 rounded-xl）。
+ * ════════════════════════════════════════════════════════════════════════════ */
+
+@layer pa-utilities {
+
+/* display */
+.parallel-agents .flex { display: flex; }
+.parallel-agents .inline-flex { display: inline-flex; }
+.parallel-agents .inline-block { display: inline-block; }
+.parallel-agents .block { display: block; }
+.parallel-agents .grid { display: grid; }
+
+/* flex */
+.parallel-agents .flex-col { flex-direction: column; }
+.parallel-agents .flex-1 { flex: 1 1 0%; }
+.parallel-agents .flex-wrap { flex-wrap: wrap; }
+.parallel-agents .items-center { align-items: center; }
+.parallel-agents .items-start { align-items: flex-start; }
+.parallel-agents .justify-center { justify-content: center; }
+.parallel-agents .justify-between { justify-content: space-between; }
+.parallel-agents .justify-end { justify-content: flex-end; }
+.parallel-agents .shrink-0 { flex-shrink: 0; }
+
+/* grid */
+.parallel-agents .grid-cols-1 { grid-template-columns: repeat(1, minmax(0, 1fr)); }
+@media (min-width: 1024px) {
+  .parallel-agents .lg\:grid-cols-2 { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+}
+/* 行等高填充容器：让席位卡片高度受限于会话区，从而卡片内部出现滚动条而非撑破容器 */
+.parallel-agents .pa-rows-fill { grid-auto-rows: minmax(0, 1fr); }
+
+/* position */
+.parallel-agents .relative { position: relative; }
+.parallel-agents .absolute { position: absolute; }
+.parallel-agents .inset-0 { inset: 0; }
+.parallel-agents .left-1\/2 { left: 50%; }
+.parallel-agents .-bottom-0\.5 { bottom: -0.125rem; }
+.parallel-agents .-right-0\.5 { right: -0.125rem; }
+
+/* sizing */
+.parallel-agents .w-full { width: 100%; }
+.parallel-agents .w-px { width: 1px; }
+.parallel-agents .h-full { height: 100%; }
+.parallel-agents .h-8 { height: 2rem; }
+.parallel-agents .min-w-0 { min-width: 0; }
+.parallel-agents .min-h-0 { min-height: 0; }
+.parallel-agents .min-h-16 { min-height: 4rem; }
+.parallel-agents .max-w-full { max-width: 100%; }
+.parallel-agents .max-h-60 { max-height: 15rem; }
+.parallel-agents .size-1 { width: 0.25rem; height: 0.25rem; }
+.parallel-agents .size-3\.5 { width: 0.875rem; height: 0.875rem; }
+
+/* gap */
+.parallel-agents .gap-0\.5 { gap: 0.125rem; }
+.parallel-agents .gap-1 { gap: 0.25rem; }
+.parallel-agents .gap-1\.5 { gap: 0.375rem; }
+.parallel-agents .gap-2 { gap: 0.5rem; }
+.parallel-agents .gap-3 { gap: 0.75rem; }
+.parallel-agents .gap-4 { gap: 1rem; }
+
+/* space-y（子元素纵向间距） */
+.parallel-agents .space-y-1 > * + * { margin-top: 0.25rem; }
+.parallel-agents .space-y-1\.5 > * + * { margin-top: 0.375rem; }
+.parallel-agents .space-y-2 > * + * { margin-top: 0.5rem; }
+
+/* padding */
+.parallel-agents .p-0\.5 { padding: 0.125rem; }
+.parallel-agents .p-2 { padding: 0.5rem; }
+.parallel-agents .p-3 { padding: 0.75rem; }
+.parallel-agents .p-4 { padding: 1rem; }
+.parallel-agents .px-1\.5 { padding-left: 0.375rem; padding-right: 0.375rem; }
+.parallel-agents .px-2 { padding-left: 0.5rem; padding-right: 0.5rem; }
+.parallel-agents .px-2\.5 { padding-left: 0.625rem; padding-right: 0.625rem; }
+.parallel-agents .px-3 { padding-left: 0.75rem; padding-right: 0.75rem; }
+.parallel-agents .px-4 { padding-left: 1rem; padding-right: 1rem; }
+.parallel-agents .py-0\.5 { padding-top: 0.125rem; padding-bottom: 0.125rem; }
+.parallel-agents .py-1 { padding-top: 0.25rem; padding-bottom: 0.25rem; }
+.parallel-agents .py-1\.5 { padding-top: 0.375rem; padding-bottom: 0.375rem; }
+.parallel-agents .py-2 { padding-top: 0.5rem; padding-bottom: 0.5rem; }
+.parallel-agents .py-6 { padding-top: 1.5rem; padding-bottom: 1.5rem; }
+.parallel-agents .pt-0\.5 { padding-top: 0.125rem; }
+.parallel-agents .pb-2 { padding-bottom: 0.5rem; }
+
+/* margin */
+.parallel-agents .mt-0\.5 { margin-top: 0.125rem; }
+.parallel-agents .mt-2 { margin-top: 0.5rem; }
+.parallel-agents .mt-3 { margin-top: 0.75rem; }
+.parallel-agents .mb-2 { margin-bottom: 0.5rem; }
+.parallel-agents .ml-2 { margin-left: 0.5rem; }
+.parallel-agents .-mx-px { margin-left: -1px; margin-right: -1px; }
+
+/* border + radius */
+.parallel-agents .border { border-width: 1px; border-style: solid; }
+.parallel-agents .border-b { border-bottom-width: 1px; border-bottom-style: solid; }
+.parallel-agents .rounded { border-radius: 0.25rem; }
+.parallel-agents .rounded-md { border-radius: 0.375rem; }
+.parallel-agents .rounded-lg { border-radius: 0.5rem; }
+.parallel-agents .rounded-xl { border-radius: 0.75rem; }
+.parallel-agents .rounded-full { border-radius: 9999px; }
+
+/* font-size（含任意值） */
+.parallel-agents .text-\[8px\] { font-size: 8px; }
+.parallel-agents .text-\[10px\] { font-size: 10px; }
+.parallel-agents .text-\[11px\] { font-size: 11px; }
+.parallel-agents .text-xs { font-size: 0.75rem; line-height: 1rem; }
+.parallel-agents .text-sm { font-size: 0.875rem; line-height: 1.25rem; }
+
+/* font-weight */
+.parallel-agents .font-normal { font-weight: 400; }
+.parallel-agents .font-medium { font-weight: 500; }
+.parallel-agents .font-semibold { font-weight: 600; }
+.parallel-agents .font-bold { font-weight: 700; }
+.parallel-agents .font-extrabold { font-weight: 800; }
+.parallel-agents .font-black { font-weight: 900; }
+
+/* font 其它 */
+.parallel-agents .font-mono {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+}
+.parallel-agents .italic { font-style: italic; }
+.parallel-agents .uppercase { text-transform: uppercase; }
+.parallel-agents .tracking-wide { letter-spacing: 0.025em; }
+
+/* line-height */
+.parallel-agents .leading-snug { line-height: 1.375; }
+.parallel-agents .leading-relaxed { line-height: 1.625; }
+
+/* text-align */
+.parallel-agents .text-left { text-align: left; }
+.parallel-agents .text-center { text-align: center; }
+
+/* 文本截断 / 换行 */
+.parallel-agents .truncate { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.parallel-agents .break-words { overflow-wrap: break-word; }
+.parallel-agents .line-clamp-2 {
+  display: -webkit-box;
+  -webkit-box-orient: vertical;
+  -webkit-line-clamp: 2;
+  overflow: hidden;
+}
+
+/* overflow */
+.parallel-agents .overflow-hidden { overflow: hidden; }
+.parallel-agents .overflow-auto { overflow: auto; }
+.parallel-agents .overflow-x-auto { overflow-x: auto; }
+.parallel-agents .overflow-y-auto { overflow-y: auto; }
+
+/* 效果 / 变换 / 过渡 */
+.parallel-agents .opacity-60 { opacity: 0.6; }
+.parallel-agents .shadow-sm { box-shadow: 0 1px 2px 0 rgb(0 0 0 / 0.05); }
+.parallel-agents .resize-none { resize: none; }
+.parallel-agents .rotate-90 { transform: rotate(90deg); }
+.parallel-agents .transition {
+  transition-property: color, background-color, border-color, fill, stroke, opacity,
+    box-shadow, transform, filter, backdrop-filter;
+  transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+  transition-duration: 150ms;
+}
+.parallel-agents .transition-transform {
+  transition-property: transform;
+  transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+  transition-duration: 150ms;
+}
+.parallel-agents .hover\:opacity-90:hover { opacity: 0.9; }
+
+} /* @layer pa-utilities */
diff --git a/parallel-agents-vue/src/lib/step-display.ts b/parallel-agents-vue/src/parallel-agents/step-display.ts
similarity index 100%
rename from parallel-agents-vue/src/lib/step-display.ts
rename to parallel-agents-vue/src/parallel-agents/step-display.ts
diff --git a/parallel-agents-vue/src/types.ts b/parallel-agents-vue/src/parallel-agents/types.ts
similarity index 79%
rename from parallel-agents-vue/src/types.ts
rename to parallel-agents-vue/src/parallel-agents/types.ts
index baa86396..26170666 100644
--- a/parallel-agents-vue/src/types.ts
+++ b/parallel-agents-vue/src/parallel-agents/types.ts
@@ -44,12 +44,15 @@ export interface Dialogue {
   clarification?: ClarificationPayload;
 }
 
+/** 席位 / 结果的状态。`clarify` = 智能体在等用户协助（待确认），不是已完成。 */
+export type SeatStatus = "pending" | "running" | "done" | "clarify" | "error";
+
 /** 并行席位的视图状态（席位状态条用）。 */
 export interface SeatView {
   agentId: string;
   name: string;
   avatarType: string;
-  status: "pending" | "running" | "done" | "error";
+  status: SeatStatus;
   /** 关联的 Dialogue.id。 */
   bubbleId: number;
 }
@@ -81,13 +84,26 @@ export type StreamEvent =
   | { type: "agent_error"; agent_id: string; message: string }
   | { type: "all_done" };
 
-/** 单个智能体的返回结果（供宿主通过 getResults() / completed 事件读取）。 */
+/** 单个智能体的返回结果（供宿主通过 getResults() 读取）。 */
 export interface AgentResult {
   agent_id: string;
   name: string;
   /** 该智能体模型返回的正文（Markdown）。 */
   content: string;
-  status: "pending" | "running" | "done" | "error";
+  /** `clarify` 表示在等用户协助（待确认），宿主据此判断「未完成」。 */
+  status: SeatStatus;
+}
+
+/**
+ * 回传给宿主的「已完成」结果（agent-completed / completed 事件用）：只含**智能体名称 + 模型返回
+ * 结果**（agent_id 便于识别）。不带 status —— 因为只在真正完成（done）时才回传，本身即代表已完成。
+ */
+export interface AgentReply {
+  agent_id: string;
+  /** 智能体名称（显示名）。 */
+  name: string;
+  /** 模型返回结果（正文 Markdown）。 */
+  content: string;
 }
 
 /** 持久化的任务记录（与后端 /api/parallel-agent-tasks 对应）。 */
diff --git a/parallel-agents-vue/src/composables/useParallelRun.ts b/parallel-agents-vue/src/parallel-agents/useParallelRun.ts
similarity index 58%
rename from parallel-agents-vue/src/composables/useParallelRun.ts
rename to parallel-agents-vue/src/parallel-agents/useParallelRun.ts
index 0167af05..8f2dbb9e 100644
--- a/parallel-agents-vue/src/composables/useParallelRun.ts
+++ b/parallel-agents-vue/src/parallel-agents/useParallelRun.ts
@@ -3,9 +3,9 @@
  * 气泡，维护并行席位状态条；带轻量节流（rAF 合并增量），支持取消、回显 hydrate、重置。
  */
 import { ref, shallowRef } from "vue";
-import type { AgentInput, Dialogue, SeatView, StreamEvent } from "@/types";
-import { getAvatarTypeFor } from "@/lib/avatar-constants";
-import { streamParallelAgents, type ApiConfig } from "@/api";
+import type { AgentInput, Dialogue, SeatStatus, SeatView, StreamEvent } from "./types";
+import { getAvatarTypeFor } from "./avatar-constants";
+import { streamParallelAgents, type ApiConfig } from "./api";
 
 function nowTime(): string {
   const d = new Date();
@@ -18,12 +18,47 @@ function nextId(): number {
   return _seq++;
 }
 
-export function useParallelRun() {
+export interface ParallelRunOptions {
+  /** 单个智能体进入终态（完成 / 待确认 / 出错）时回调一次，用于「一分析完就回传」。 */
+  onAgentSettled?: (agentId: string, status: SeatView["status"]) => void;
+}
+
+export function useParallelRun(opts: ParallelRunOptions = {}) {
   const dialogues = ref<Dialogue[]>([]);
   const seats = ref<SeatView[]>([]);
   const running = ref(false);
   const abortRef = shallowRef<AbortController | null>(null);
 
+  // 正在「单席位重跑」（用户协助后继续）的 agentId 集合。澄清卡片的禁用态按席位取这里，
+  // 而不是全局 running —— 这样多个智能体都待协助时，协助 A 不会禁用 B/C 的卡片。
+  const busy = ref<Set<string>>(new Set());
+  // 每个重跑各自的 AbortController（支持多席位并发协助 + 统一取消）。
+  const acByAgent = new Map<string, AbortController>();
+  function setBusy(agentId: string, on: boolean) {
+    const next = new Set(busy.value);
+    if (on) next.add(agentId);
+    else next.delete(agentId);
+    busy.value = next;
+  }
+
+  // 本轮已「结算」（回调过 onAgentSettled）的 agentId，去重，避免重复回传。
+  const settled = new Set<string>();
+  function settleAgent(agentId: string, status: SeatView["status"]) {
+    if (settled.has(agentId)) return;
+    settled.add(agentId);
+    opts.onAgentSettled?.(agentId, status);
+  }
+
+  // 「单席位重跑」（回答澄清后继续）要**保留**协助前的历史正文：把「旧正文 + 我的补充」作为
+  // 前缀（在 rerunAgent 里写进 d.content 并记到这里），新一轮输出接在后面。该席位收到带 content
+  // 的终态事件（done / clarification）时，把前缀拼回最终正文最前面，避免被后端终态正文覆盖掉历史。
+  const rerunPrefix = new Map<string, string>();
+  function applyRerunPrefix(agentId: string, content: string): string {
+    const pre = rerunPrefix.get(agentId);
+    rerunPrefix.delete(agentId);
+    return (pre ?? "") + content;
+  }
+
   // 增量节流：累积到 pending，rAF 合并刷新一次，避免逐 token reflow。
   const pending = new Map<string, string>(); // agentId -> 待追加文本
   let rafScheduled = false;
@@ -48,6 +83,11 @@ export function useParallelRun() {
     requestAnimationFrame(flushPending);
   }
 
+  // 断流兜底时把席位状态归一为「终态」：保留待协助 / 出错，其余（running/pending）算完成。
+  function settleStatusOf(status: SeatStatus): SeatStatus {
+    return status === "clarify" || status === "error" ? status : "done";
+  }
+
   function setSeatStatus(agentId: string, status: SeatView["status"]) {
     const s = seats.value.find((x) => x.agentId === agentId);
     if (s) s.status = status;
@@ -87,19 +127,24 @@ export function useParallelRun() {
         flushPending();
         const d = findDialogue(ev.agent_id);
         if (d) {
-          if (ev.content) d.content = ev.content; // 终态正文以后端为准
+          // 终态正文以后端为准；若是「回答澄清后的重跑」，把协助前的历史前缀拼回正文最前面。
+          if (ev.content) d.content = applyRerunPrefix(ev.agent_id, ev.content);
+          else rerunPrefix.delete(ev.agent_id);
           d.streaming = false;
           d.confidence = "已完成";
         }
         setSeatStatus(ev.agent_id, "done");
         dialogues.value = [...dialogues.value];
+        settleAgent(ev.agent_id, "done");
         break;
       }
       case "agent_clarification": {
         flushPending();
         const d = findDialogue(ev.agent_id);
         if (d) {
-          if (ev.content) d.content = ev.content;
+          // 同 done：重跑后再次澄清也要保留历史前缀。
+          if (ev.content) d.content = applyRerunPrefix(ev.agent_id, ev.content);
+          else rerunPrefix.delete(ev.agent_id);
           d.clarification = {
             question: ev.question,
             clarificationType: ev.clarification_type,
@@ -111,12 +156,15 @@ export function useParallelRun() {
           d.streaming = false;
           d.confidence = "待确认";
         }
-        setSeatStatus(ev.agent_id, "done");
+        // 待协助是独立状态，不是 done —— 否则席位条显示 ✓、宿主判定已完成。
+        setSeatStatus(ev.agent_id, "clarify");
         dialogues.value = [...dialogues.value];
+        settleAgent(ev.agent_id, "clarify");
         break;
       }
       case "agent_error": {
         flushPending();
+        rerunPrefix.delete(ev.agent_id); // 出错就丢弃前缀（正文已含历史+已流出的增量）
         const d = findDialogue(ev.agent_id);
         if (d) {
           d.content = d.content || `⚠️ 该智能体执行出错：${ev.message}`;
@@ -125,6 +173,7 @@ export function useParallelRun() {
         }
         setSeatStatus(ev.agent_id, "error");
         dialogues.value = [...dialogues.value];
+        settleAgent(ev.agent_id, "error");
         break;
       }
       case "all_done":
@@ -180,14 +229,22 @@ export function useParallelRun() {
         ac.signal,
       );
     } finally {
-      // 收尾：任何仍在 streaming 的气泡都置完成态。
+      // 收尾：任何仍在 streaming 的气泡都置完成态。跳过正在「协助重跑」的席位（busy）——
+      // 它有自己独立的流，由 rerunAgent 的 finally 负责收尾，别被整批收尾误置完成。
       for (const d of dialogues.value) {
+        if (busy.value.has(d.agentId)) continue;
         if (d.streaming) {
           d.streaming = false;
           if (d.confidence === "并行执行中") d.confidence = "已完成";
         }
       }
       dialogues.value = [...dialogues.value];
+      // 兜底：没收到终态事件就断流的席位也回调一次（按当前席位状态，保留待协助/出错）。
+      // 同样跳过 busy 席位：它的结算交给 rerunAgent，避免在重跑途中被提前判完成回传。
+      for (const s of seats.value) {
+        if (busy.value.has(s.agentId)) continue;
+        settleAgent(s.agentId, settleStatusOf(s.status));
+      }
       running.value = false;
       abortRef.value = null;
     }
@@ -195,6 +252,9 @@ export function useParallelRun() {
 
   function cancel() {
     abortRef.value?.abort();
+    for (const ac of acByAgent.values()) ac.abort();
+    acByAgent.clear();
+    busy.value = new Set();
     running.value = false;
   }
 
@@ -204,13 +264,23 @@ export function useParallelRun() {
    */
   async function rerunAgent(
     cfg: ApiConfig,
-    args: { taskName: string; brief: string; agentId: string; model?: string },
+    args: { taskName: string; brief: string; agentId: string; model?: string; userNote?: string },
   ): Promise<void> {
-    if (running.value) return;
+    // 允许在整批仍在跑（running）时回答某个已澄清的席位：它在合并流里那一轮已经结束
+    // （澄清是该席位的终态），不会再抢同一气泡。这里只拦截同一席位的并发重跑。
+    if (busy.value.has(args.agentId)) return;
     const d = dialogues.value.find((x) => x.agentId === args.agentId);
     if (!d) return;
-    d.content = "";
-    d.steps = [];
+    // 保留协助前的历史：把「旧正文 + 我的补充」作为前缀立刻写进正文（不清空，避免历史丢失），
+    // 新一轮输出接在后面；终态事件回来时由 applyRerunPrefix 把前缀拼到最终正文最前面。
+    const prev = (d.content || "").trim();
+    const note = (args.userNote || "").trim();
+    const prefix = prev
+      ? `${prev}\n\n---\n\n**🙋 我的补充：** ${note || "（已补充）"}\n\n---\n\n`
+      : "";
+    rerunPrefix.set(args.agentId, prefix);
+    d.content = prefix;
+    d.steps = []; // 步骤条按新一轮重新累计
     d.clarification = undefined;
     d.streaming = true;
     d.confidence = "并行执行中";
@@ -218,9 +288,11 @@ export function useParallelRun() {
     setSeatStatus(args.agentId, "running");
     dialogues.value = [...dialogues.value];
 
-    running.value = true;
+    settled.delete(args.agentId); // 该席位重跑，允许再次回传
+    // 不动全局 running —— 用按席位的 busy，这样可同时协助多个待确认的智能体。
+    setBusy(args.agentId, true);
     const ac = new AbortController();
-    abortRef.value = ac;
+    acByAgent.set(args.agentId, ac);
     try {
       await streamParallelAgents(
         cfg,
@@ -235,8 +307,10 @@ export function useParallelRun() {
         if (dd.confidence === "并行执行中") dd.confidence = "已完成";
       }
       dialogues.value = [...dialogues.value];
-      running.value = false;
-      abortRef.value = null;
+      const st = seats.value.find((x) => x.agentId === args.agentId);
+      settleAgent(args.agentId, settleStatusOf(st?.status ?? "done"));
+      acByAgent.delete(args.agentId);
+      setBusy(args.agentId, false);
     }
   }
 
@@ -250,11 +324,13 @@ export function useParallelRun() {
     restored.forEach((d) => {
       bubbleByAgent.set(d.agentId, d.id);
       if (!seatMap.has(d.agentId)) {
+        const status: SeatStatus =
+          d.confidence === "出错" ? "error" : d.clarification ? "clarify" : "done";
         seatMap.set(d.agentId, {
           agentId: d.agentId,
           name: d.sender,
           avatarType: d.avatarType,
-          status: d.confidence === "出错" ? "error" : "done",
+          status,
           bubbleId: d.id,
         });
       }
@@ -266,9 +342,11 @@ export function useParallelRun() {
     cancel();
     pending.clear();
     bubbleByAgent.clear();
+    settled.clear();
+    rerunPrefix.clear();
     dialogues.value = [];
     seats.value = [];
   }
 
-  return { dialogues, seats, running, start, cancel, hydrate, reset, rerunAgent };
+  return { dialogues, seats, running, busy, start, cancel, hydrate, reset, rerunAgent };
 }
diff --git a/parallel-agents-vue/src/styles/parallel-agents.css b/parallel-agents-vue/src/styles/parallel-agents.css
deleted file mode 100644
index cb90b13f..00000000
--- a/parallel-agents-vue/src/styles/parallel-agents.css
+++ /dev/null
@@ -1,282 +0,0 @@
-/* 并行多智能体面板样式。
- *
- * 嵌入安全：只引 Tailwind 的 theme + utilities（**不引 preflight**，避免重置宿主全局样式）。
- * 颜色用作用域内的 `--pa-*` 深蓝 token（取自《深蓝 UI 规范》ZS-004 / ZS-002，与圆桌 Step2
- * 深色一致），全部包在根类 `.parallel-agents` 下，绝不污染宿主。布局用 Tailwind 工具类，
- * 主题色用下面的 `.pa-*` 语义类。 */
-
-@layer theme, base, components, utilities;
-@import "tailwindcss/theme.css" layer(theme);
-@import "tailwindcss/utilities.css" layer(utilities);
-
-/* ── 作用域 token（深色深蓝，自带成色，不依赖宿主主题）─────────────────────── */
-.parallel-agents {
-  --pa-bg: #0c1836; /* 页面背景 zs-004-09 */
-  --pa-card: #122347; /* 卡片 / 气泡容器 zs-004-08 */
-  --pa-muted: #16294d; /* 次级表面（步骤卡 / 并行列底） */
-  --pa-accent: #1a2f5a; /* hover / 软高亮 */
-  --pa-fg: #c5cfe0; /* 正文 zs-004-02 */
-  --pa-fg-muted: #6e88b0; /* 次级文字 zs-004-04 */
-  --pa-border: #2d4473; /* 容器边框 zs-004-06 */
-  --pa-input: #4a6491; /* 控件描边 */
-  --pa-primary: #1677ff; /* 主操作 zs-002-06 */
-  --pa-primary-fg: #ffffff;
-  --pa-chip-bg: #16335f; /* badge 底 */
-  --pa-chip-fg: #4096ff; /* badge 文字 */
-  --pa-amber: #f59e0b;
-  --pa-emerald: #10b981;
-  --pa-rose: #ef4444;
-
-  color: var(--pa-fg);
-  background-color: var(--pa-bg);
-  font-size: 14px;
-  line-height: 1.6;
-  box-sizing: border-box;
-}
-.parallel-agents *,
-.parallel-agents *::before,
-.parallel-agents *::after {
-  box-sizing: border-box;
-}
-
-/* 滚动条 */
-.parallel-agents ::-webkit-scrollbar {
-  width: 8px;
-  height: 8px;
-}
-.parallel-agents ::-webkit-scrollbar-thumb {
-  background: color-mix(in oklch, var(--pa-primary) 40%, var(--pa-border));
-  border-radius: 999px;
-}
-.parallel-agents ::-webkit-scrollbar-thumb:hover {
-  background: color-mix(in oklch, var(--pa-primary) 60%, var(--pa-border));
-}
-
-/* ── 语义颜色类（组件用这些上色，布局仍用 Tailwind 工具类）──────────────────── */
-.parallel-agents .pa-bg {
-  background-color: var(--pa-bg);
-}
-.parallel-agents .pa-card {
-  background-color: var(--pa-card);
-}
-.parallel-agents .pa-surface {
-  background-color: var(--pa-muted);
-}
-.parallel-agents .pa-surface-soft {
-  background-color: color-mix(in oklch, var(--pa-muted) 55%, transparent);
-}
-.parallel-agents .pa-border {
-  border-color: var(--pa-border);
-}
-.parallel-agents .pa-text {
-  color: var(--pa-fg);
-}
-.parallel-agents .pa-text-muted {
-  color: var(--pa-fg-muted);
-}
-.parallel-agents .pa-text-primary {
-  color: var(--pa-primary);
-}
-
-/* 输入框 / 文本域 */
-.parallel-agents .pa-input {
-  background-color: var(--pa-card);
-  border: 1px solid var(--pa-border);
-  color: var(--pa-fg);
-  border-radius: 8px;
-}
-.parallel-agents .pa-input::placeholder {
-  color: color-mix(in oklch, var(--pa-fg-muted) 80%, transparent);
-}
-.parallel-agents .pa-input:focus {
-  outline: none;
-  border-color: color-mix(in oklch, var(--pa-primary) 55%, var(--pa-border));
-}
-
-/* 主按钮 / 次按钮 */
-.parallel-agents .pa-btn-primary {
-  background-color: var(--pa-primary);
-  color: var(--pa-primary-fg);
-  border-radius: 8px;
-  transition: filter 0.15s ease;
-}
-.parallel-agents .pa-btn-primary:hover {
-  filter: brightness(1.08);
-}
-.parallel-agents .pa-btn-primary:disabled {
-  opacity: 0.5;
-  cursor: not-allowed;
-}
-.parallel-agents .pa-btn-ghost {
-  border: 1px solid var(--pa-border);
-  color: var(--pa-fg);
-  background-color: transparent;
-  border-radius: 8px;
-  transition: background-color 0.15s ease;
-}
-.parallel-agents .pa-btn-ghost:hover {
-  background-color: var(--pa-accent);
-}
-.parallel-agents .pa-btn-ghost:disabled {
-  opacity: 0.5;
-  cursor: not-allowed;
-}
-
-/* 状态徽标（"实时输出" / "已完成" …）—— 对齐 Step2 confidence chip */
-.parallel-agents .pa-badge {
-  background-color: var(--pa-chip-bg);
-  color: var(--pa-chip-fg);
-  border: 1px solid var(--pa-border);
-  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
-  font-weight: 800;
-  text-transform: uppercase;
-  border-radius: 4px;
-  padding: 1px 6px;
-  font-size: 11px;
-  letter-spacing: 0.02em;
-}
-
-/* 席位状态角标色 */
-.parallel-agents .pa-dot-running {
-  background-color: var(--pa-primary);
-  color: #fff;
-}
-.parallel-agents .pa-dot-done {
-  background-color: var(--pa-emerald);
-  color: #fff;
-}
-.parallel-agents .pa-dot-error {
-  background-color: var(--pa-rose);
-  color: #fff;
-}
-
-/* 流式光标 + loading 点 */
-.parallel-agents .pa-cursor {
-  display: inline-block;
-  width: 4px;
-  height: 13px;
-  margin-left: 2px;
-  vertical-align: middle;
-  background: var(--pa-primary);
-  animation: pa-pulse 1s ease-in-out infinite;
-}
-@keyframes pa-pulse {
-  0%,
-  100% {
-    opacity: 1;
-  }
-  50% {
-    opacity: 0.25;
-  }
-}
-.parallel-agents .pa-bounce {
-  animation: pa-bounce 0.9s infinite;
-}
-@keyframes pa-bounce {
-  0%,
-  100% {
-    transform: translateY(0);
-  }
-  50% {
-    transform: translateY(-3px);
-  }
-}
-@keyframes pa-spin {
-  to {
-    transform: rotate(360deg);
-  }
-}
-.parallel-agents .pa-spin {
-  animation: pa-spin 0.8s linear infinite;
-}
-@keyframes pa-ping {
-  75%,
-  100% {
-    transform: scale(1.8);
-    opacity: 0;
-  }
-}
-.parallel-agents .pa-ping {
-  animation: pa-ping 1.2s cubic-bezier(0, 0, 0.2, 1) infinite;
-}
-
-/* ── Markdown 正文（对齐 Step2 sharedMarkdownComponents 的深色观感）──────────── */
-.parallel-agents .pa-md {
-  color: var(--pa-fg);
-  font-size: 14px;
-  line-height: 1.7;
-  word-break: break-word;
-}
-.parallel-agents .pa-md p {
-  margin: 0.35em 0;
-}
-.parallel-agents .pa-md h1,
-.parallel-agents .pa-md h2,
-.parallel-agents .pa-md h3,
-.parallel-agents .pa-md h4 {
-  font-weight: 700;
-  margin: 0.7em 0 0.35em;
-  color: var(--pa-fg);
-}
-.parallel-agents .pa-md h1 {
-  font-size: 1.3em;
-}
-.parallel-agents .pa-md h2 {
-  font-size: 1.18em;
-}
-.parallel-agents .pa-md h3 {
-  font-size: 1.06em;
-}
-.parallel-agents .pa-md ul,
-.parallel-agents .pa-md ol {
-  margin: 0.35em 0;
-  padding-left: 1.4em;
-}
-.parallel-agents .pa-md li {
-  margin: 0.2em 0;
-}
-.parallel-agents .pa-md a {
-  color: var(--pa-chip-fg);
-  text-decoration: underline;
-}
-.parallel-agents .pa-md code {
-  background: var(--pa-muted);
-  border: 1px solid var(--pa-border);
-  border-radius: 4px;
-  padding: 0.1em 0.35em;
-  font-size: 0.9em;
-  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
-}
-.parallel-agents .pa-md pre {
-  background: var(--pa-muted);
-  border: 1px solid var(--pa-border);
-  border-radius: 8px;
-  padding: 0.75em;
-  overflow-x: auto;
-  margin: 0.5em 0;
-}
-.parallel-agents .pa-md pre code {
-  background: transparent;
-  border: 0;
-  padding: 0;
-}
-.parallel-agents .pa-md blockquote {
-  border-left: 3px solid var(--pa-border);
-  padding-left: 0.75em;
-  color: var(--pa-fg-muted);
-  margin: 0.5em 0;
-}
-.parallel-agents .pa-md table {
-  border-collapse: collapse;
-  margin: 0.5em 0;
-  width: 100%;
-}
-.parallel-agents .pa-md th,
-.parallel-agents .pa-md td {
-  border: 1px solid var(--pa-border);
-  padding: 0.35em 0.6em;
-  text-align: left;
-}
-.parallel-agents .pa-md th {
-  background: var(--pa-muted);
-}
diff --git a/parallel-agents-vue/vite.config.ts b/parallel-agents-vue/vite.config.ts
index 1032a296..73c927e6 100644
--- a/parallel-agents-vue/vite.config.ts
+++ b/parallel-agents-vue/vite.config.ts
@@ -1,7 +1,6 @@
 import { fileURLToPath, URL } from "node:url";
 import { defineConfig } from "vite";
 import vue from "@vitejs/plugin-vue";
-import tailwindcss from "@tailwindcss/vite";
 
 // 两种构建：
 //  - 默认（`vite build` / `vite dev`）：独立 demo 应用（index.html）。
@@ -10,7 +9,7 @@ import tailwindcss from "@tailwindcss/vite";
 export default defineConfig(({ mode }) => {
   const isLib = mode === "lib";
   return {
-    plugins: [vue(), tailwindcss()],
+    plugins: [vue()],
     resolve: {
       alias: { "@": fileURLToPath(new URL("./src", import.meta.url)) },
     },
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
new file mode 100644
index 00000000..6ec1aeb7
--- /dev/null
+++ b/pnpm-lock.yaml
@@ -0,0 +1,246 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    dependencies:
+      axios:
+        specifier: ^1.16.1
+        version: 1.17.0
+
+packages:
+
+  agent-base@6.0.2:
+    resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==}
+    engines: {node: '>= 6.0.0'}
+
+  asynckit@0.4.0:
+    resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
+
+  axios@1.17.0:
+    resolution: {integrity: sha512-J8SwNxprqqpbfenehxWYXE7CW+wM1BB4w3+N+g+/Wx40xM4rsLrfPmHHxSWIxJLYDgSY/HqlFPIYb2/S3rxafw==}
+
+  call-bind-apply-helpers@1.0.2:
+    resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==}
+    engines: {node: '>= 0.4'}
+
+  combined-stream@1.0.8:
+    resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==}
+    engines: {node: '>= 0.8'}
+
+  debug@4.4.3:
+    resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  delayed-stream@1.0.0:
+    resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==}
+    engines: {node: '>=0.4.0'}
+
+  dunder-proto@1.0.1:
+    resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==}
+    engines: {node: '>= 0.4'}
+
+  es-define-property@1.0.1:
+    resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==}
+    engines: {node: '>= 0.4'}
+
+  es-errors@1.3.0:
+    resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==}
+    engines: {node: '>= 0.4'}
+
+  es-object-atoms@1.1.2:
+    resolution: {integrity: sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==}
+    engines: {node: '>= 0.4'}
+
+  es-set-tostringtag@2.1.0:
+    resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==}
+    engines: {node: '>= 0.4'}
+
+  follow-redirects@1.16.0:
+    resolution: {integrity: sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==}
+    engines: {node: '>=4.0'}
+    peerDependencies:
+      debug: '*'
+    peerDependenciesMeta:
+      debug:
+        optional: true
+
+  form-data@4.0.5:
+    resolution: {integrity: sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==}
+    engines: {node: '>= 6'}
+
+  function-bind@1.1.2:
+    resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==}
+
+  get-intrinsic@1.3.0:
+    resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==}
+    engines: {node: '>= 0.4'}
+
+  get-proto@1.0.1:
+    resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==}
+    engines: {node: '>= 0.4'}
+
+  gopd@1.2.0:
+    resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==}
+    engines: {node: '>= 0.4'}
+
+  has-symbols@1.1.0:
+    resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==}
+    engines: {node: '>= 0.4'}
+
+  has-tostringtag@1.0.2:
+    resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==}
+    engines: {node: '>= 0.4'}
+
+  hasown@2.0.4:
+    resolution: {integrity: sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==}
+    engines: {node: '>= 0.4'}
+
+  https-proxy-agent@5.0.1:
+    resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==}
+    engines: {node: '>= 6'}
+
+  math-intrinsics@1.1.0:
+    resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}
+    engines: {node: '>= 0.4'}
+
+  mime-db@1.52.0:
+    resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==}
+    engines: {node: '>= 0.6'}
+
+  mime-types@2.1.35:
+    resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==}
+    engines: {node: '>= 0.6'}
+
+  ms@2.1.3:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+
+  proxy-from-env@2.1.0:
+    resolution: {integrity: sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==}
+    engines: {node: '>=10'}
+
+snapshots:
+
+  agent-base@6.0.2:
+    dependencies:
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
+  asynckit@0.4.0: {}
+
+  axios@1.17.0:
+    dependencies:
+      follow-redirects: 1.16.0
+      form-data: 4.0.5
+      https-proxy-agent: 5.0.1
+      proxy-from-env: 2.1.0
+    transitivePeerDependencies:
+      - debug
+      - supports-color
+
+  call-bind-apply-helpers@1.0.2:
+    dependencies:
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+
+  combined-stream@1.0.8:
+    dependencies:
+      delayed-stream: 1.0.0
+
+  debug@4.4.3:
+    dependencies:
+      ms: 2.1.3
+
+  delayed-stream@1.0.0: {}
+
+  dunder-proto@1.0.1:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-errors: 1.3.0
+      gopd: 1.2.0
+
+  es-define-property@1.0.1: {}
+
+  es-errors@1.3.0: {}
+
+  es-object-atoms@1.1.2:
+    dependencies:
+      es-errors: 1.3.0
+
+  es-set-tostringtag@2.1.0:
+    dependencies:
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      has-tostringtag: 1.0.2
+      hasown: 2.0.4
+
+  follow-redirects@1.16.0: {}
+
+  form-data@4.0.5:
+    dependencies:
+      asynckit: 0.4.0
+      combined-stream: 1.0.8
+      es-set-tostringtag: 2.1.0
+      hasown: 2.0.4
+      mime-types: 2.1.35
+
+  function-bind@1.1.2: {}
+
+  get-intrinsic@1.3.0:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.2
+      function-bind: 1.1.2
+      get-proto: 1.0.1
+      gopd: 1.2.0
+      has-symbols: 1.1.0
+      hasown: 2.0.4
+      math-intrinsics: 1.1.0
+
+  get-proto@1.0.1:
+    dependencies:
+      dunder-proto: 1.0.1
+      es-object-atoms: 1.1.2
+
+  gopd@1.2.0: {}
+
+  has-symbols@1.1.0: {}
+
+  has-tostringtag@1.0.2:
+    dependencies:
+      has-symbols: 1.1.0
+
+  hasown@2.0.4:
+    dependencies:
+      function-bind: 1.1.2
+
+  https-proxy-agent@5.0.1:
+    dependencies:
+      agent-base: 6.0.2
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
+  math-intrinsics@1.1.0: {}
+
+  mime-db@1.52.0: {}
+
+  mime-types@2.1.35:
+    dependencies:
+      mime-db: 1.52.0
+
+  ms@2.1.3: {}
+
+  proxy-from-env@2.1.0: {}