hob-bot 1.0.4 → 1.2.0

package/server/src/transcript.ts

@@ -4,6 +4,9 @@ import { commandSummary } from "../../shared/command.ts";
 import type { JobStep } from "../../shared/types.ts";
 import { showPath } from "./text.ts";
 
+/** 沉淀技能那一轮发给任务的话的开头：任务详情里这句显示成「沉淀技能」。 */
+export const SEDIMENT_PROMPT_HEAD = "这件事以后还会再做。回顾刚才的过程，把能复用的做法沉淀成技能";
+
 /** transcript 里单步输出最多这么多字，超出的整段落盘，页面按路径去拉。 */
 export const STEP_OUTPUT_LIMIT = 20 * 1024;
 /** 实时事件里的单步输出最多这么多字（全文落盘，给路径）。 */
@@ -84,8 +87,19 @@ const MEMORY_TOOLS: Record<string, string> = {
   lore_status: "查看记忆状态",
 };
 
+/** MCP 工具（mcp__<服务>__<工具>）显示成「服务名 · 工具名」，不露原始名。 */
+function mcpToolDisplay(name: string, mcpServers: Record<string, string> | undefined): string | undefined {
+  if (!name.startsWith("mcp__")) return undefined;
+  const rest = name.slice("mcp__".length);
+  const split = rest.indexOf("__");
+  if (split <= 0) return undefined;
+  const server = mcpServers?.[rest.slice(0, split)] ?? rest.slice(0, split);
+  const tool = rest.slice(split + 2) || "?";
+  return `${server} · ${tool}`;
+}
+
 /** 一行中文：「运行 `npm test`」「修改 server/src/jobs.ts」「读取 README.md」。 */
-export function toolTitle(name: string, args: Record<string, unknown>): string {
+export function toolTitle(name: string, args: Record<string, unknown>, mcpServers?: Record<string, string>): string {
   const path = String(args.path ?? "");
   switch (name) {
     case "bash":
@@ -104,6 +118,8 @@ export function toolTitle(name: string, args: Record<string, unknown>): string {
       return `列出 ${path}`;
     case "report":
       return "提交结果";
+    case "save_skill":
+      return `保存技能：${oneLine(String(args.title ?? ""), 60)}`;
     case "ask_user":
       return `询问用户：${oneLine(String(args.title ?? ""), 60)}`;
     case "overview":
@@ -112,9 +128,40 @@ export function toolTitle(name: string, args: Record<string, unknown>): string {
       return `生成图片：${oneLine(String(args.prompt ?? ""), 60)}`;
     case "web_search":
       return `联网搜索：${oneLine(String(args.query ?? ""), 60)}`;
+    case "find_knowledge":
+      return args.query ? `找资料：${oneLine(String(args.query), 60)}` : "找资料";
+    case "search_knowledge":
+      return args.query ? `查知识库：${oneLine(String(args.query), 60)}` : "查知识库";
     case "web_fetch":
       return `读取网页：${oneLine(String(args.url ?? ""), 60)}`;
+    case "browser_open": {
+      let target = oneLine(String(args.url ?? ""), 60);
+      try { target = new URL(target).hostname; } catch { /* 无效地址保留原样 */ }
+      return `浏览器 · 打开 ${target}`;
+    }
+    case "browser_snapshot": return "浏览器 · 读取页面";
+    case "browser_click": return "浏览器 · 点击";
+    case "browser_type": return "浏览器 · 输入";
+    case "browser_press": return "浏览器 · 按键";
+    case "browser_back": return "浏览器 · 返回";
+    case "browser_screenshot": return "浏览器 · 截图";
+    case "desktop_screenshot": return "桌面 · 截图";
+    case "desktop_action": {
+      const names: Record<string, string> = { click: "点击", move: "移动", drag: "拖动", type: "输入", key: "按键", scroll: "滚动", wait: "等待" };
+      const first = Array.isArray(args.actions) ? args.actions[0] as { type?: string } | undefined : undefined;
+      return `桌面 · ${names[first?.type ?? ""] ?? "操作"}`;
+    }
+    case "tool_search":
+      return `搜索可用工具：${oneLine(String(args.query ?? ""), 60)}`;
+    case "list_mcp_resources":
+      return "列出 MCP 资源";
+    case "list_mcp_resource_templates":
+      return "列出 MCP 资源模板";
+    case "read_mcp_resource":
+      return `读取 MCP 资源：${oneLine(String(args.uri ?? ""), 90)}`;
     default: {
+      const mcp = mcpToolDisplay(name, mcpServers);
+      if (mcp) return `调用 ${mcp}`;
       const label = MEMORY_TOOLS[name];
       if (!label) return name;
       const target = String(args.uri ?? args.query ?? "");
@@ -148,17 +195,20 @@ export interface ToolStepInput {
   at?: string;
   cwd?: string;
   running?: boolean;
+  /** MCP 工具的显示名映射（转义后的服务名 → 配置里的原名） */
+  mcpServers?: Record<string, string>;
 }
 
 /** 一次工具调用 → 一个步骤（还没有结果）。实时事件和落盘推导都用它，页面按 id 合并。 */
 export function toolStep(input: ToolStepInput): JobStep {
   const args = toolArgs(input.name, input.args, input.cwd ?? "");
+  const mcp = mcpToolDisplay(input.name, input.mcpServers);
   return {
     id: input.id,
     kind: "tool",
     at: input.at ?? new Date().toISOString(),
-    name: input.name,
-    title: toolTitle(input.name, args),
+    name: mcp ?? input.name,
+    title: toolTitle(input.name, args, input.mcpServers),
     args,
     ...(input.running ? { running: true } : {}),
   };
@@ -193,6 +243,8 @@ export interface DeriveOptions {
   limit?: number;
   /** 输出过长时落盘，返回路径 */
   save?: (stepId: string, text: string) => string;
+  /** MCP 工具的显示名映射（转义后的服务名 → 配置里的原名） */
+  mcpServers?: Record<string, string>;
 }
 
 /** 从任务会话文件推导整个过程：说明文字、思考摘要、工具调用（含结果）。 */
@@ -237,6 +289,7 @@ export function deriveSteps(file: string, options: DeriveOptions = {}): JobStep[
             args: block.arguments ?? {},
             at,
             cwd: options.cwd ?? "",
+            mcpServers: options.mcpServers,
             running: true,
           });
           toolIndex.set(step.id, steps.length);
@@ -265,7 +318,7 @@ export function deriveSteps(file: string, options: DeriveOptions = {}): JobStep[
         seenUser = true; // 第一句是任务说明，详情头部已经有
         continue;
       }
-      steps.push({ id: `u${message.timestamp ?? at}`, kind: "text", at, from: "user", text });
+      steps.push({ id: `u${message.timestamp ?? at}`, kind: "text", at, from: "user", text: text.startsWith(SEDIMENT_PROMPT_HEAD) ? "沉淀技能" : text });
     }
   }
   return steps;

package/server/src/worker-tools.ts

@@ -13,15 +13,14 @@ export function registerReportTool(runtime: HobRuntime, jobId: string): ToolDefi
   return {
     name: "report",
     label: "提交结果",
-    description:
-      "任务结束时必须调用一次，提交结果。summary 用中文写给用户：一两句结论 + 关键数字，不要罗列过程。",
+    description: "任务结束时调用一次，提交结果。",
     promptSnippet: "任务结束必须调用 report 提交结果。",
     parameters: Type.Object({
       outcome: Type.Unsafe<"done" | "stuck" | "need_approval">(
-        Type.String({ description: "done 已完成 / stuck 受阻 / need_approval 待确认" }),
+        Type.String({ description: "done 做完 / stuck 做不下去（写明缺什么）/ need_approval 需要用户拍板" }),
       ),
-      summary: Type.String({ description: "中文摘要，一两句结论 + 关键数字，不超过 600 字" }),
-      files: Type.Optional(Type.Array(Type.String(), { description: "产出文件的绝对路径" })),
+      result: Type.String({ description: "完整结果：结论、数据、链接、文件路径；写给派活的助手。" }),
+      files: Type.Optional(Type.Array(Type.String(), { description: "要给用户看的文件（绝对路径）" })),
     }),
     execute: async (_id, params: any) => {
       // 不认识的结果不能当成已完成：退回让模型重新调用
@@ -34,7 +33,7 @@ export function registerReportTool(runtime: HobRuntime, jobId: string): ToolDefi
       }
       runtime.jobs.reportFromTool(jobId, {
         outcome: params.outcome,
-        summary: String(params.summary ?? ""),
+        result: String(params.result ?? ""),
         ...(Array.isArray(params.files) && params.files.length ? { files: params.files as string[] } : {}),
       });
       return ok("结果已记录。");
@@ -47,7 +46,7 @@ export function registerAskTool(runtime: HobRuntime, jobId: string): ToolDefinit
   return {
     name: "ask_user",
     label: "询问用户",
-    description: "遇到规则要求执行前确认、或者不可逆的操作时，用这个询问用户，会一直等到用户选择。返回用户选择的选项文字。",
+    description: "在对话里出选择题卡片（2 到 3 个选项），等用户选，返回用户的选择。用于用户定的规则要求先确认的事，或发送、删除、付费这类撤不回的事。",
     promptSnippet: "规则要求执行前确认的事，执行前必须调用 ask_user。",
     parameters: Type.Object({
       title: Type.String({ description: "问题，一句话" }),
@@ -55,27 +54,30 @@ export function registerAskTool(runtime: HobRuntime, jobId: string): ToolDefinit
       options: Type.Array(
         Type.Object({
           label: Type.String({ description: "选项文字" }),
-          always: Type.Optional(Type.Boolean({ description: "选中后将这句话记为规则" })),
         }),
         { description: "2 到 3 个选项", minItems: 2, maxItems: 3 },
       ),
-      ruleText: Type.Optional(Type.String({ description: "always 选项要写进规则的文字" })),
+      remember: Type.Optional(Type.String({ description: "同类事以后可以不再问时，填这类事的简称（如「清理临时目录」）；卡片会多一个「以后直接做」的选项。" })),
     }),
     execute: async (_id, params: any) => {
-      const labels: { label: string; always?: boolean }[] = Array.isArray(params.options) ? params.options : [];
+      const labels: { label: string }[] = Array.isArray(params.options) ? params.options : [];
       if (labels.length < 2 || labels.length > 3) {
         return { content: [{ type: "text" as const, text: "选项要 2 到 3 个。" }], details: undefined, isError: true };
       }
+      const remember = typeof params.remember === "string" ? params.remember.trim() : "";
+      if (remember && labels.length > 2) {
+        return { content: [{ type: "text" as const, text: "带 remember 时最多给 2 个选项。" }], details: undefined, isError: true };
+      }
       const options: ApprovalOption[] = labels.map((option, index) => ({
         key: (["A", "B", "C"] as const)[index],
         label: String(option.label),
-        ...(option.always ? { always: true } : {}),
       }));
+      if (remember) options.push({ key: "C", label: `以后「${remember}」直接做`, always: true });
       const answer = await runtime.jobs.askQuestion(jobId, {
         title: String(params.title),
         ...(params.detail ? { detail: String(params.detail) } : {}),
         options,
-        ...(params.ruleText ? { ruleText: String(params.ruleText) } : {}),
+        ...(remember ? { ruleText: remember } : {}),
       });
       // 用户可能没选给出的选项，而是自己写了一段：answer 已经是回给模型的整句
       return ok(answer);

package/shared/knowledge.ts

@@ -0,0 +1,92 @@
+// 知识库的数据契约：服务端（server/src/knowledge.ts、http.ts）和页面共用。设计见 .scratch/v2/design-knowledge.md。
+
+import type { FileKind } from "./types.ts";
+
+/** 怎么进来的：助手产出、对话上传（这两类自动收，不建索引），或在知识库里上传。 */
+export type KnowledgeOrigin = "output" | "chat" | "upload";
+
+/** 页面上的类型筛选；一条只属于一组，由 FileKind 决定（见 knowledgeGroup）。 */
+export type KnowledgeGroup = "image" | "document" | "table" | "page" | "other";
+
+export interface KnowledgeVersion {
+  hash: string;
+  path: string;
+  size: number;
+  at: string;
+}
+
+export interface KnowledgeEntry {
+  id: string; // k-xxxx
+  origin: KnowledgeOrigin;
+  name: string; // 显示名：原文件名或页面标题，用户可改
+  description?: string; // 页面摘要、生图提示词或任务标题
+  kind: FileKind;
+  path: string; // 当前版本在知识库目录里的绝对路径，经 /api/files 取
+  hash: string;
+  size: number;
+  createdAt: string;
+  updatedAt: string; // 只跟内容走（新版本时更新），改名和整理不动；列表按它排序
+  versions?: KnowledgeVersion[]; // 旧版本，旧的在前
+  source?: { assistantId: string; itemId?: string; jobId?: string }; // 出处
+  collections: string[]; // 所在的用户知识库 id
+  index?: KnowledgeIndex; // 二期：只在条目属于至少一个用户知识库时有
+}
+
+export interface KnowledgeCollection {
+  id: string; // kc-xxxx
+  name: string;
+  createdAt: string;
+  count: number; // 里面有几条
+  indexed?: number; // 二期：索引已建好的条数
+  failed?: number; // 二期：建索引失败的条数
+  unsupported?: number; // 二期：这类文件还不能建索引的条数（不算进「已建索引 a/b」的 b）
+}
+
+/** 二期：用户知识库里文件的索引状态。queued/indexing/failed 的文件查不到；unsupported = 这类文件还不能建索引。 */
+export type KnowledgeIndexState = "queued" | "indexing" | "ready" | "failed" | "unsupported";
+
+export interface KnowledgeIndex {
+  state: KnowledgeIndexState;
+  chunks?: number; // ready 时有几段
+  error?: string; // failed / unsupported 的原因，直接给用户看
+}
+
+/** 一段原文。出处链接 #k/<条目 id>/<index> 指到这里。 */
+export interface KnowledgeChunk {
+  index: number; // 在这个文件里是第几段，从 0 起
+  heading: string; // 标题路径：「文件名 › 一级 › 二级」
+  text: string;
+  page?: number; // PDF 的页码，从 1 起
+}
+
+/** GET /api/knowledge/entries/:id[?chunk=N] 的返回。 */
+export interface KnowledgeEntryView {
+  entry: KnowledgeEntry;
+  chunk?: KnowledgeChunk; // 带了 chunk 且这段存在时才有
+}
+
+/** 出处链接：工具和自动检索给出，助手照抄进回答，界面点开定位。 */
+export function knowledgeLink(entryId: string, chunk: number): string {
+  return `#k/${entryId}/${chunk}`;
+}
+
+export function parseKnowledgeLink(href: string): { entryId: string; chunk?: number } | null {
+  const match = /^#k\/(k-[\w-]+)(?:\/(\d+))?$/.exec(href.trim());
+  return match ? { entryId: match[1]!, ...(match[2] !== undefined ? { chunk: Number(match[2]) } : {}) } : null;
+}
+
+/** GET /api/knowledge 的返回。 */
+export interface KnowledgePage {
+  entries: (KnowledgeEntry & { snippet?: string })[]; // snippet：关键词命中文字时的前后片段
+  hasMore: boolean;
+  collections: KnowledgeCollection[];
+}
+
+/** 类型筛选的分组。 */
+export function knowledgeGroup(kind: FileKind): KnowledgeGroup {
+  if (kind === "image" || kind === "svg") return "image";
+  if (kind === "csv" || kind === "json") return "table";
+  if (kind === "html") return "page";
+  if (kind === "markdown" || kind === "text" || kind === "pdf" || kind === "code" || kind === "xml") return "document";
+  return "other";
+}

package/shared/mcp.ts

@@ -0,0 +1,91 @@
+// MCP（Model Context Protocol）服务的契约：设置 → MCP 页和 REST 接口共用。
+// 配置文件就是引擎读的那份 HOB_HOME/engine/mcp.json；说明见 docs/architecture.md 的 MCP 一节。
+
+/** 服务里每个工具怎么给模型：direct = 直接提供；deferred = 按需搜索。 */
+export type McpExposureChoice = "direct" | "deferred";
+
+/**
+ * 环境变量 / 请求头的值：密钥永不回传。redacted = 只知道「已设置」；
+ * 整值 `${VAR}` 引用或 `!command` 不含密钥，原样回显。
+ */
+export interface McpSecretValue {
+  redacted: boolean;
+  value?: string;
+}
+
+/** GET /api/mcp：列表里的一项（不含密钥明文）。valid = false 表示手改坏了，只可编辑或删除。 */
+export interface McpServerView {
+  name: string;
+  valid: boolean;
+  invalidReason?: string;
+  kind?: "stdio" | "http";
+  enabled: boolean;
+  exposure: McpExposureChoice;
+  description?: string;
+  /** 本地命令（stdio） */
+  command?: string;
+  args?: string[];
+  env?: Record<string, McpSecretValue>;
+  cwd?: string;
+  /** 远程地址（streamable HTTP） */
+  url?: string;
+  headers?: Record<string, McpSecretValue>;
+  /** 单独关掉的工具名（toolExposure 里设为 hidden 的） */
+  hiddenTools?: string[];
+}
+
+/** GET /api/mcp。 */
+export interface McpView {
+  servers: McpServerView[];
+}
+
+/** POST /api/mcp/:name/test（失败也是 200，原因在这里）。 */
+export type McpTestResult =
+  | { ok: true; tools: { name: string; description: string }[] }
+  | { ok: false; state: "failed" | "needs_auth"; error: string; stderrTail: string[] };
+
+/** 环境变量 / 请求头逐键的改法：保留已存的值 / 删除 / 换成新值。 */
+export type McpSecretMutation = { mode: "preserve" } | { mode: "remove" } | { mode: "replace"; value: string };
+
+/** PUT /api/mcp/:name：新建或改一个服务。提供方式、启用状态不在这里改。 */
+export interface McpServerSave {
+  kind: "stdio" | "http";
+  command?: string;
+  args?: string[];
+  cwd?: string;
+  url?: string;
+  description?: string;
+  env?: Record<string, McpSecretMutation>;
+  headers?: Record<string, McpSecretMutation>;
+}
+
+/** PATCH /api/mcp/:name：启用开关、提供方式、单独关掉的工具（完整列表，全量替换）。 */
+export interface McpServerPatch {
+  enabled?: boolean;
+  exposure?: McpExposureChoice;
+  hiddenTools?: string[];
+}
+
+/** GET /api/mcp/import：本机其他客户端里配的 MCP 服务（只读来源文件）。 */
+export interface McpImportItem {
+  /** 勾选时回传的标识：来源:服务名 */
+  id: string;
+  name: string;
+  source: "pi" | "claude" | "cursor";
+  kind?: "stdio" | "http";
+  exists: boolean; // Hob 里已有同名（- 和 _ 视为同名），导入会跳过
+  selectable: boolean;
+  note?: string; // 不可选的原因
+}
+
+export interface McpImportView {
+  /** 读了哪些位置（界面显示用） */
+  sources: string[];
+  items: McpImportItem[];
+}
+
+/** POST /api/mcp/import {ids}。 */
+export interface McpImportResult {
+  imported: string[];
+  skipped: string[]; // 跳过的，带说明
+}

package/shared/skills.ts

@@ -35,3 +35,21 @@ export interface SkillImportResult {
   skipped: string[];
   errors: string[];
 }
+
+/**
+ * 助手自己沉淀的技能：HOB_HOME/assistants/<id>/skills/<name>/SKILL.md（加 scripts/、references/），
+ * 元数据在 assistants/<id>/skills/skills.json。只有这个助手的任务加载。
+ */
+export interface AssistantSkill {
+  name: string; // 目录名：小写字母、数字、连字符
+  title: string; // 界面上显示的名字，如「网关每日巡检」
+  description: string; // 一句话：什么时候用
+  path: string; // SKILL.md 的绝对路径（预览用）
+  version: number; // 每次修补 +1，旧版在 skills/<name>/.history/<版本>/
+  createdAt: string;
+  updatedAt: string;
+  fromJobId?: string; // 最近一次从哪个任务沉淀或修补
+  uses: number; // 被任务读过几次
+  lastUsedAt?: string;
+  enabled: boolean;
+}

package/shared/types.ts

@@ -126,6 +126,28 @@ export interface ModelThinkingView {
   custom: boolean; // 存过自定义档位（可以恢复默认）
 }
 
+export interface ClaudeCodeSettings {
+  enabled: boolean;
+  plan: "pro" | "max";
+  executable: string;
+}
+
+export interface ClaudeCodeView {
+  settings: SettingsFile;
+  status: ClaudeCodeStatus;
+}
+
+/** 本机 Claude Code 状态，不包含凭据或程序原始输出。 */
+export interface ClaudeCodeStatus {
+  found: boolean;
+  executable?: string;
+  version?: string;
+  loggedIn: boolean;
+  email?: string;
+  plan?: string;
+  error?: string;
+}
+
 /** GET /api/providers：已配的服务商、引擎自带的服务商目录、跟着一起回的整份设置（前端要新 revision）。 */
 export interface ProvidersView {
   providers: ProviderView[];
@@ -214,6 +236,8 @@ export interface Assistant {
   };
   /** 派出去的活能用的能力；缺省全开（读总是有） */
   abilities?: { exec: boolean; write: boolean; image: boolean };
+  /** 知识库二期：绑定的用户知识库 id。缺省 = 没绑定：不自动查，也没有 search_knowledge */
+  knowledge?: string[];
   createdAt: Iso;
   splitFrom?: { from: string; at: Iso; conversations: number };
 }
@@ -245,6 +269,9 @@ export interface RoutineRun {
   jobId: string;
   at: Iso;
   status: JobStatus;
+  durationMs?: number; // 技能二期：这次用时
+  tools?: number; // 技能二期：工具调用次数
+  tokens?: number; // 技能二期：输入加输出 token
 }
 
 export interface Routine {
@@ -256,6 +283,7 @@ export interface Routine {
   active: boolean;
   createdAt: Iso;
   runs: RoutineRun[]; // 最近 20 次，新的在前
+  skill?: string; // 绑定这个助手自己的技能（AssistantSkill.name）：每次执行按它做
 }
 
 export interface Delegation {
@@ -264,7 +292,7 @@ export interface Delegation {
   to: string;
   text: string;
   createdAt: Iso;
-  status: "running" | "waiting" | "done" | "stuck" | "interrupted" | "returned";
+  status: "running" | "waiting" | "done" | "stuck" | "interrupted" | "returned" | "takenOver";
   jobIds: string[];
   reply?: string;
   returnedText?: string; // 退回时补充的用户要求
@@ -342,7 +370,7 @@ export interface JobsPage {
 export interface Job {
   id: string; // "t-" + 4 位以上
   assistantId: string;
-  assistantName?: string; // 建任务时的助手名：助手并回 Hob 后，任务详情里照样显示
+  assistantName?: string; // 建任务时的助手名：助手归档后，任务详情里照样显示
   title: string; // 如 "查页面卡顿"
   instruction: string;
   status: JobStatus;
@@ -352,8 +380,9 @@ export interface Job {
   endedAt?: Iso;
   usage?: JobUsage; // 输入/输出 token 和花费
   durationMs?: number; // 用时（结束时间 − 开始时间）
+  expect?: { minutes: number; source: "assistant" | "routine" | "default"; runs?: number };
   stats: { reads: number; commands: number; edits: number };
-  summary?: string; // report 的摘要（≤600 字）
+  summary?: string; // report 的完整结果
   reportPath?: string; // 完整报告
   files?: string[]; // 产出文件（绝对路径）
   cwd?: string; // 工作目录（缺省为 HOB_HOME/jobs/<id>/work）
@@ -362,10 +391,26 @@ export interface Job {
   modelReason?: string; // 换了模型的原因，如「需要看图，换成了 X」
   inputs?: string[]; // 交给任务的附件（绝对路径）
   routineId?: string; // 由定时触发
+  skillsUsed?: string[]; // 这次读过的本助手技能（AssistantSkill.name）
   delegationId?: string; // 转交回合创建的任务
+  /** 续做前每一轮结束时的样子（第 0 轮起）。对话里前面几张任务卡照它显示，最后一张跟着任务实时变 */
+  rounds?: JobRound[];
   activity: ActivityLine[]; // 最近 200 行
 }
 
+export interface JobRound {
+  summary?: string;
+  files?: string[];
+  usage?: JobUsage;
+  reportPath?: string;
+  followUp?: string;
+  status: JobStatus;
+  statusReason?: string;
+  startedAt?: Iso;
+  endedAt?: Iso;
+  durationMs?: number;
+}
+
 export interface ApprovalOption {
   key: "A" | "B" | "C";
   label: string; // 如 "以后同类内容直接发布，无需确认"
@@ -408,16 +453,17 @@ export interface Draft {
   createdAt: Iso;
 }
 
-export type NoteIcon = "memory" | "rule" | "routine" | "split" | "info";
+export type NoteIcon = "memory" | "rule" | "routine" | "split" | "info" | "skill";
 
 export type Item = (
   | { kind: "user"; id: string; at: Iso; text: string; quote?: { itemId: string; text: string }; files?: string[]; from?: { assistantId: string; name: string; delegationId: string } }
-  | { kind: "assistant"; id: string; at: Iso; text: string; streaming?: boolean; routine?: { id: string; name: string } }
-  | { kind: "note"; id: string; at: Iso; icon: NoteIcon; text: string; handbackId?: string } // 居中灰色一行，如 "记忆已更新 · 不看融资新闻"
+  | { kind: "assistant"; id: string; at: Iso; text: string; streaming?: boolean; routine?: { id: string; name: string; jobId?: string } }
+  | { kind: "note"; id: string; at: Iso; icon: NoteIcon; text: string; handbackId?: string; path?: string } // path：点了预览这个文件（如技能的 SKILL.md） // 居中灰色一行，如 "记忆已更新 · 不看融资新闻"
   | { kind: "question"; id: string; at: Iso; approvalId: string }
-  | { kind: "job"; id: string; at: Iso; jobId: string }
+  | { kind: "job"; id: string; at: Iso; jobId: string; round?: number } // 第几轮（续做一次 +1），缺省是第 0 轮
   | { kind: "delegation"; id: string; at: Iso; delegationId: string }
   | { kind: "draft"; id: string; at: Iso; draftId: string }
+  | { kind: "image"; id: string; at: Iso; prompt: string; size?: string; startedAt: Iso; status: "pending" | "done" | "failed"; path?: string; error?: string }
   | { kind: "file"; id: string; at: Iso; path: string; name: string; meta?: string } // meta 如 "3200 字 · 4 张图"
 ) & {
   /** 这条开启新的一组，前端在它上面拉开间距：事件触发的新一轮回复，或任务直接发进对话的图片、提问卡 */
@@ -468,6 +514,7 @@ export interface MemoryConfig {
   provider: MemoryProvider;
   providerExplicit: boolean; // 用户在设置里明确选过（没选过就是按有没有配好 Lore 推出的）
   lore: LoreConnectionInfo;
+  lorePlugin: string; // Hob 自带的 Lore 插件版本（Lore 正式版的版本号）
 }
 
 /** POST /api/memory/lore-test：测试失败也是 200，原因在这里。 */
@@ -508,13 +555,47 @@ export interface Settings {
   models: ModelSettings;
   image: ImageSettings;
   search: SearchSettings;
+  /** 云桌面令牌保存在 secrets.json，不包含在设置中。 */
+  desktop?: { url: string; enabled: boolean; publicAssistants?: string[] };
+  claude?: ClaudeCodeSettings;
   /** 停用的技能，键为来源和技能名。 */
   skills?: { disabled: string[] };
   work: WorkSettings;
   push: PushSettings;
+  /** 知识库二期：向量模型（Key 在 secrets.json 的 embedding）；缺省 = 关闭，只按关键词查 */
+  knowledge?: { embedding: EmbeddingSettings };
 }
 
+/** 设置 → 知识库：向量模型，照图像生成的做法（兼容接口的地址 + 模型，Key 单独存）。 */
+export type EmbeddingSettings = { source: "off" } | { source: "openai"; baseUrl: string; model: string };
+
+/** GET /api/knowledge/embedding：Key 配没配（永不回显）。 */
+export interface EmbeddingKeyView {
+  keyConfigured: boolean;
+}
+
+/** PUT /api/knowledge/embedding 的返回：整份设置和 Key 状态。 */
+export interface EmbeddingSettingsSaved {
+  settings: SettingsFile;
+  keyConfigured: boolean;
+}
+
+/** POST /api/knowledge/embedding/test：失败也是 200，原因在这里。 */
+export type EmbeddingTestResult = { ok: true; dims: number } | { ok: false; error: string };
+
 /** HOB_HOME/settings.json：界面可改的设置，写入走 revision 比对（CAS）。 */
+export interface DesktopView {
+  revision: number;
+  url: string;
+  enabled: boolean;
+  deployed: boolean;
+  tokenConfigured: boolean;
+  publicAssistants: string[];
+}
+
+export interface DesktopScreen { id: string; running: boolean; browserRunning: boolean; viewers: number; lastActiveAt: string | null }
+export type DesktopTestResult = { ok: true; health: { version: string; display: { width: number; height: number }; screens: DesktopScreen[] } } | { ok: false; error: string };
+
 export interface SettingsFile {
   revision: number;
   settings: Settings;
@@ -583,20 +664,18 @@ export interface FileMeta {
   page?: boolean; // 展示页面目录中的渲染产物
 }
 
-/** GET /api/jobs/:id/files：任务工作目录里的一个文件。 */
-export interface JobFileEntry {
-  path: string; // 绝对路径
-  rel: string; // 相对任务工作目录，如 "src/index.ts"
-  name: string;
-  size: number;
-  modifiedAt: Iso;
-  kind: FileKind;
-}
+/** 工作目录中的一项，目录的 count 是其下一层可见项数。 */
+export type JobFileEntry = { path: string; rel: string; name: string } & (
+  | { type: "file"; size: number; modifiedAt: Iso; kind: FileKind }
+  | { type: "directory"; count: number }
+);
 
-/** GET /api/jobs/:id/files：任务工作目录（HOB_HOME/jobs/<id>/work）里的文件，最多 200 个。 */
+/** 一层最多返回 200 项，total 为截断前的总数。 */
 export interface JobFilesView {
-  files: JobFileEntry[]; // 修改时间倒序
-  hasMore: boolean;
+  files: JobFileEntry[];
+  total: number;
+  fileCount: number;
+  directoryCount: number;
 }
 
 export interface Bootstrap {
@@ -609,12 +688,15 @@ export interface Bootstrap {
 }
 
 export type HobEvent =
+  | { type: "desktop-control"; screen: string; taken: boolean }
+  | { type: "desktop-screens"; screens: DesktopScreen[] }
   | ({ type: "page-live" } & PageLive)
   | { type: "assistant"; assistant: AssistantSummary } // 新建或变化
   | { type: "assistant_removed"; id: string }
   | { type: "item"; assistantId: string; item: Item } // 新条目，或按 id 替换
   | { type: "delta"; assistantId: string; itemId: string; text: string } // 流式追加到 assistant 条目
   | { type: "job"; job: Job }
+  | { type: "sediment-finished"; jobId: string }
   | { type: "delegation"; delegation: Delegation }
   | { type: "job_step"; jobId: string; step: JobStep } // 新的一步，或按 id 替换（输出流式更新、跑完补结果）
   | { type: "router-activity"; assistantId: string; activity: RouterActivity | null }
@@ -623,7 +705,9 @@ export type HobEvent =
   | { type: "draft"; draft: Draft }
   | { type: "routine"; routine: Routine }
   | { type: "routine_removed"; id: string }
-  | { type: "profile"; assistantId: string }; // rules/memories/worklog 变了，前端重拉 profile
+  | { type: "profile"; assistantId: string } // rules/memories/worklog 变了，前端重拉 profile
+  | { type: "knowledge" } // 知识库有变化，打开着的知识库页面重拉
+  | { type: "skills"; assistantId: string }; // 这个助手的技能有变化，打开着的技能列表重拉
 
 /** POST /api/assistants/:id/messages 的请求体 */
 export interface SendMessageBody {

package/vendor/claude-bridge/HOB-PATCH.md

@@ -0,0 +1,10 @@
+# Hob 补丁
+
+来源：`pi-claude-bridge@0.9.3`，MIT，原许可证见 `LICENSE`。
+
+- 只读取 Hob 引擎目录的 `claude-bridge.json`，不合并任务工作目录的配置。
+- Claude Code 普通请求和摘要请求都传 `--safe-mode`；摘要请求不再传空的 `settingSources`，因为当前 Claude Code 登录在该参数下不可用。
+- 不通过全局环境设置安全模式，避免影响用户在任务中启动的 Claude Code。
+- Hob 在模型目录初始化时预注册模型，所有会话复用同一个扩展模块；生命周期清理仅影响当前会话，避免并行对话和任务互相清除状态。
+- 不修改 Hob 进程的 Claude Code 环境变量；启用桥调试日志时记录实际追加的系统提示词，供隔离验收。
+- 移除桥直接读取、重建和删除 Claude Code 会话文件的路径。无法直接续接时，以 SDK 消息重放 Hob 自己的历史（包含图片）；正常续接仍由 Claude Code 处理。这可能增加重启或上下文改写后的 token 用量。