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/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/package.json b/frontend-web/package.json
index e54c5f66..c74784bd 100644
--- a/frontend-web/package.json
+++ b/frontend-web/package.json
@@ -74,6 +74,7 @@
     "hast": "^1.0.0",
     "katex": "^0.16.28",
     "lucide-react": "^0.562.0",
+    "mermaid": "11.14.0",
     "motion": "^12.26.2",
     "nanoid": "^5.1.6",
     "next-themes": "^0.4.6",
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 f75996d2..636135d1 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";
@@ -164,6 +164,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 59d15e9d..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,
@@ -28,14 +29,13 @@ import {
   ListChecks,
   ListTodo,
   MessageSquareCode,
-  MessageSquarePlus,
   Network,
   NotebookPen,
   Plus,
   Settings,
-  ShieldCheck,
   Sparkles,
   Target,
+  Trophy,
   Users,
 } from "lucide-react";
 
@@ -233,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: "大模型调用统计",
@@ -268,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: "定时任务管理",
@@ -295,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: "知识库资源管理",
@@ -318,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/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/WorkspaceRoutes.tsx b/frontend-web/src/pages/WorkspaceRoutes.tsx
index 57ff765d..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';
@@ -344,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/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/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/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/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/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 b1c9ffe8..09f277da 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/config.yaml b/offline-backend-20260512/backend/config.yaml
index d95031b0..5ec643d9 100644
--- a/offline-backend-20260512/backend/config.yaml
+++ b/offline-backend-20260512/backend/config.yaml
@@ -10,90 +10,90 @@ gateway:
   port: 8001
 
 models:
-  - name: deepseek-chat
-    display_name: DeepSeek Chat
-    use: langchain_openai:ChatOpenAI
-    model: deepseek-chat
-    api_key: sk-3fee562f834a4c08bb0d471ef44cb445
-    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: deepseek-chat
+  #   display_name: DeepSeek Chat
+  #   use: langchain_openai:ChatOpenAI
+  #   model: deepseek-chat
+  #   api_key: sk-1520028668cb4cc388ed8315ff1e856e
+  #   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: deepseek-v4-flash
-    display_name: DeepSeek V4 Flash
-    use: langchain_openai:ChatOpenAI
-    model: deepseek-v4-flash
-    api_key: sk-3fee562f834a4c08bb0d471ef44cb445
-    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: deepseek-v4-flash
+  #   display_name: DeepSeek V4 Flash
+  #   use: langchain_openai:ChatOpenAI
+  #   model: deepseek-v4-flash
+  #   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: deepseek-v4-pro
-    display_name: DeepSeek V4 Pro
+  # - 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/v1
+  #   max_tokens: 4096
+  #   temperature: 1.0
+  #   supports_vision: true
+  #   supports_thinking: true
+  # - name: glm-5.1
+  #   display_name: glm-5.1
+  #   use: langchain_openai:ChatOpenAI
+  #   model: glm-5.1
+  #   api_key: 75121e4bed7640d5b71ac95cf8b4310a.RA3GyRBAR3kv7VrR
+  #   base_url: https://open.bigmodel.cn/api/paas/v4/
+  #   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: 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-ai/DeepSeek-V4-Flash
+    display_name: deepseek-ai/DeepSeek-V4-Flash
     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/v1
-    max_tokens: 4096
-    temperature: 1.0
-    supports_vision: true
-    supports_thinking: true
-  - name: glm-5.1
-    display_name: glm-5.1
-    use: langchain_openai:ChatOpenAI
-    model: glm-5.1
-    api_key: 75121e4bed7640d5b71ac95cf8b4310a.RA3GyRBAR3kv7VrR
-    base_url: https://open.bigmodel.cn/api/paas/v4/
-    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: 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: 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-ighylafootabtuthwueirmoycccyqtdgbifyhozduvolkdyt
     base_url: https://api.siliconflow.cn/v1/
     max_tokens: 4096
@@ -122,6 +122,26 @@ uploads:
   auto_convert_documents: true
   pdf_converter: auto
 
+# Chrome 插件「当前网页发送到 Deer」入口。默认关闭，打开后才启用
+# /api/browser-context/capture。它只保存当前页 Markdown 到线程 uploads，
+# 不会改变普通聊天、上传或工具调用流程。
+browser_context:
+  enabled: true
+  max_content_chars: 200000
+  max_title_chars: 300
+  max_url_chars: 2048
+  filename_prefix: webpage
+  route_base: /page/workspace
+  task_result_timeout_seconds: 60
+  task_poll_interval_seconds: 1
+  task_lease_seconds: 120
+  tool_result_max_chars: 60000
+  # 交互式页面操作（browser_act：点击/输入/滚动/等待/跳转）。关闭后只保留只读抓取。
+  actions_enabled: true
+  action_result_timeout_seconds: 45
+  max_observed_elements: 150
+  observation_text_max_chars: 12000
+
 title:
   enabled: true
   max_words: 6
@@ -139,6 +159,7 @@ title:
 
 tool_groups:
   - name: web
+  - name: browser
   - name: file:read
   - name: file:write
   - name: bash
@@ -154,6 +175,14 @@ tools:
     use: deerflow.community.jina_ai.tools:web_fetch_tool
     timeout: 15
 
+  - name: browser_fetch_page
+    group: browser
+    use: deerflow.tools.builtins.browser_context_tool:browser_fetch_page_tool
+
+  - name: browser_act
+    group: browser
+    use: deerflow.tools.builtins.browser_act_tool:browser_act_tool
+
   - name: ls
     group: file:read
     use: deerflow.sandbox.tools:ls_tool
@@ -223,7 +252,7 @@ auth_login:
 
 database:
   backend: sqlite
-  sqlite_dir: .deer-flow/data
+  sqlite_dir: /app/backend/.deer-flow/data
   pool_size: 20          # 基础连接池(postgres/mysql 生效;sqlite 忽略)
   max_overflow: 20       # 高峰期可临时超出 pool_size 的额外连接数,真实上限 = pool_size + max_overflow
   pool_timeout: 30       # 池满时等待空闲连接的秒数,超时报错
@@ -231,7 +260,7 @@ database:
 
 checkpointer:
   type: sqlite
-  connection_string: .deer-flow/data/deerflow.db
+  connection_string: /app/backend/.deer-flow/data/deerflow.db
 
 # 记忆子系统:跨会话持久化用户画像与 agent 私有记忆。
 # 三层覆盖优先级(高->低):
@@ -313,3 +342,39 @@ log_system:
   enabled: true
   url: "https://your-log-system.example.com"
   label: "日志系统"
+
+# 产品内知识库 —— obsidian-wiki 兼容 vault。知识元数据写入数据库，正文
+# content_md 写入 Markdown vault（index.md/log.md/hot.md/.manifest.json/frontmatter/
+# wikilinks/wiki-export 图谱产物）。知识库为全局共享，不做 user_id 隔离，
+# 写入时记录 created_by / updated_by 作为审计。
+knowledge:
+  enabled: true
+  provider: obsidian_wiki
+  vault_dir: data/knowledge/obsidian-vault
+  project_name: zncm
+  auto_ingest_enabled: false
+  auto_ingest_min_chars: 300
+  # 用大模型按 wiki-capture 规范提炼陈述式知识（而非堆砌对话原文）。
+  # 关闭则回退到规则抽取；extract_model_name 留空时用 models[0]。
+  llm_extract_enabled: true
+  extract_model_name: ""
+  extract_max_input_chars: 12000
+  max_thread_messages: 80
+  max_source_items: 20
+  rag_enabled: false
+  rag_limit: 5
+  # 阶段三：写入前脱敏（token/密钥/手机号/身份证/邮箱）；重复检测相似度阈值。
+  sensitive_redaction_enabled: true
+  dedup_similarity_threshold: 0.82
+  export:
+    enabled: true
+    graph_html_enabled: true
+    graph_json_enabled: true
+  query:
+    use_hot_md: true
+    use_index_md: true
+    use_frontmatter_scan: true
+  embedding:
+    enabled: false
+    provider: local
+    model: ""
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 ae1398fe..833091e2 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/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: {}